vee_volume_grid.h

Go to the documentation of this file.

/* -*- C++ -*- */

/* COPYRIGHT
 *
 * This file is part of the Visual Effects Engine - VEE
 *
 * Read the "VEE-LICENSE" file for the license.
 *
 * Authors & Copyright:   
 *
 * Tommi Ilmonen, Tuukka Heikura, Marko Myllymaa and 
 * Janne Kontkanen 2001-2004
 *
 * Additional copyrights: Tekes 2003-2004
 *
 * firstname.lastname@hut.fi
 *
 */

#ifndef VEE_VOLUME_GRID_H
#define VEE_VOLUME_GRID_H

#include <vee_bounding_box.h>
#include <vee_marching_cubes.h>
#include <vee_meta_balls.h>
#include <vee_volume.h>

#include <mj_array3d.h>

#include <map>

class VEE_MetaBalls;

class VEE_VolumeGrid : public VEE_Volume
{
public:
  VEE_VolumeGrid();
  virtual ~VEE_VolumeGrid();

  virtual float inside(const VEE_Vector3 &);
  virtual void getBoundingBox(VEE_BoundingBox *);
  virtual VEE_Vector3 newRandomPoint();

  virtual bool setValue(const char *, VEE_Value *);
  virtual VEE_Volume * clone() const;

  VEE_MetaBalls * metaBalls() { return m_metaBalls; }

  VEE_Vector3 createFromMetaBalls(VEE_MetaBalls *, uint density = 60);

  void updateMarchingCubes(float threshold) 
  { m_triangles.triangulateGrid(m_grid, threshold); }

  const VEE_Matrix3 & rotation() const { return m_rotation; }
  const VEE_Vector3 & scale()    const { return m_scale;}
  
  VEE_MarchingCubes & marchingCubes() { return m_triangles; }

  void clear(bool zeroSize = true)
  {
    if(zeroSize)
      m_grid.resize(0, 0, 0);
    else
      m_grid.setAll(0.0);
    m_triangles.clear();
  }

protected:

  MJ_Array3D<float> m_grid;
  VEE_MarchingCubes m_triangles;

  VEE_Matrix3 m_rotation;
  VEE_Matrix3 m_rotationInv;
  VEE_Vector3 m_scale;

  VEE_MetaBalls * m_metaBalls;
};


class VEE_VolumeGrid2 : public VEE_Volume
{
public:
  class GridGrid
  {
  public:
    GridGrid() : m_touched(false), m_dirty(false) { m_bbox.clear(); }

    uint byteCount() const
    {
      return sizeof(*this) + sizeof(float) * m_grid.elements();
    }

    VEE_BoundingBox m_bbox;
    MJ_Array3D<float> m_grid;
    bool m_touched;
    bool m_dirty;
    int  m_ind[3];

    VEE_MarchingCubes m_triangles;
  };

  VEE_VolumeGrid2();
  VEE_VolumeGrid2(const VEE_VolumeGrid2 &);
  virtual ~VEE_VolumeGrid2();

  virtual float inside(const VEE_Vector3 &);
  virtual void getBoundingBox(VEE_BoundingBox *);
  virtual VEE_Vector3 newRandomPoint();

  virtual bool setValue(const char *, VEE_Value *);
  virtual VEE_Volume * clone() const;

  const VEE_Matrix3 & rotation() const { return m_rotation; }
  float scale()    const { return m_scale;}
  
  void addBall(const VEE_Vector3 &loc, float radius);

  void clear();

  void setVoxelSize(float s) { m_scale = 1.0 / s; m_voxelSize = s; }
  float voxelSize() const { return m_voxelSize; }

  float & getVoxel(int x, int y, int z, GridGrid ** gptr = 0);
  float getVoxel2(int x, int y, int z);

  void triangulate();

  uint triangleCount() const;
  uint byteCount() const;
  uint ballCount() const { return m_balls.nofBalls(); }

  VEE_MetaBalls * metaBalls() { return & m_balls; }

  GridGrid ** grids() { return & m_gridLinear[0];}
  const GridGrid * grid(uint i) const { return m_gridLinear[i];}
  uint gridCount() const { return m_gridLinear.size(); }

  VEE_VolumeGrid2 & operator = (const VEE_VolumeGrid2 & that);

protected:

  typedef std::map<int, GridGrid>    grid_array;
  typedef std::map<int, grid_array>  grid_array2;
  typedef std::map<int, grid_array2> grid_array3;

  grid_array3 m_grids;
  std::vector<GridGrid * > m_gridLinear;

  float m_scale;
  float m_voxelSize;
  uint  m_firstLevelDivision;

  VEE_BoundingBox m_bbox;

  VEE_Matrix3 m_rotation;
  VEE_Matrix3 m_rotationInv;

  VEE_MetaBalls m_balls;
  bool m_absoluteCoords;
};


#endif

---