vee_grid_force.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_GRID_FORCE_H
#define VEE_GRID_FORCE_H

#include <vee_force_object.h>
#include <vee_reference_object.h>
#include <vee_vector4.h>

#include <mj_array3d.h>

#define VEE_GRID_SENTINEL -1.11e+10f

namespace Solar
{
  class Model;
}

typedef Solar::Model Solar_Model;

class GEE_Group;
class GEE_Io;

class VEE_VectorGridCell {
public:
  void clear() { m_gradient.clear(); m_distance = -1.0e+10; }
  
  void add(const VEE_VectorGridCell &c) 
  { m_gradient += c.m_gradient; }
  
  void scale(float s) { m_gradient *= s; }
  
  VEE_Vector3 m_gradient;
  float       m_distance;
};

class VEE_VectorGrid 
{
public:

  class JanneGrid3;

  VEE_VectorGrid();
  virtual ~VEE_VectorGrid();
  
  VEE_VectorGridCell getGradient(const VEE_Vector3 &) const;
  VEE_VectorGridCell interpolateGradient(const VEE_Vector3 &) const;

  const float & scale() const { return m_scale; }

  float meanDistance();
  float meanGradientLength();

  bool createFromModel(Solar_Model *m, 
           uint division,
           int blurRepeats,
           int blurRadius,
           int pad = -1);

  bool createFromModel(GEE_Group *m, 
           uint division,
           int blurRepeats,
           int blurRadius,
           int pad = -1);

  bool createFromModel2(Solar_Model *m, 
      uint division,
      int blurRepeats,
      int blurRadius);

  bool writeGridToFile(const char *);
  bool readGridFromFile(const char *);
  bool writeAsciiFile(const char *, int selectLayer = -1) const;

  static bool fromModelToFile(const char * fieldFile,
            const char * solarModel, 
            int division,
            int blurRepeats,
            int blurRadius,
            int method);

  static void setDebug(bool b) { m_debug = b; }

  typedef MJ_Array3D<VEE_VectorGridCell> grid3d;

  grid3d & grid() { return m_field; }

  int layers() const { return m_field.layers(); }
  int rows() const { return m_field.rows(); }
  int cols() const { return m_field.cols(); }

protected:
  bool createFromGrid(JanneGrid3 *,
          const VEE_Vector3 & low, 
          const VEE_Vector3 & high,
          uint division,
          int blurRepeats,
          int blurRadius,
          int pad);

  bool createFromGrid2(JanneGrid3 *,
           const VEE_Vector3 & low, 
           const VEE_Vector3 & high,
           uint division,
           int blurRepeats,
           int blurRadius);

  void setInsides(JanneGrid3 *);

  grid3d m_field;

  float  m_scale;

  static bool m_debug;
};


/*
class VEE_VectorGridCompressed
{
public:
  VEE_VectorGridCompressed();
  ~VEE_VectorGridCompressed();

  
  void build(VEE_VectorGrid * source, 
       uint firstDivision = 8, 
       float maximumVectorSpread = 0.2);

protected:

  class Branch {
  public:

    Branch() {}
    ~Branch() {}
    
    MJ_Array3D<Leaf>  m_leafs;
    Fluid::Vector4<char> 
  };
};

*/


class VEE_VectorGridTree
{
public:
  VEE_VectorGridTree();
  ~VEE_VectorGridTree();

  uint bytesUsed() const;
  uint lowestVoxels() const;
  uint totalVoxelDim() const { return m_totalVoxelDim; }
  float voxelSize() const { return m_voxelSize; }

  void build(VEE_VectorGrid * source, 
       uint firstDivision = 8, 
       float maximumVectorSpread = 0.2);

  bool write(const char * filename);
  bool read(const char * filename);

  bool write(GEE_Io *);
  bool read(GEE_Io *);

  const VEE_Vector4 & getPlane(const VEE_Vector3 &loc);

  uint validLeafCount() const;

protected:

  void resize(uint firstDivision, uint secondDivision);

  class Leaf
  {
  public:
    Leaf() : m_plane(0, 0, 0, VEE_GRID_SENTINEL) {}
    ~Leaf() {}

    void clear() { m_plane.make(0, 0, 0, VEE_GRID_SENTINEL); }

    VEE_Vector4 m_plane;
  };

  class Branch
  {
  public:
    Branch();

    ~Branch();

    void resize(uint layers, uint rows, uint cols)
    { 
      m_leafs.resize(layers, rows, cols); 
    }

    bool tryCollapse(float maximumVectorSpread);
    
    bool isEmpty() const { return m_leafs.data() == 0; }

    uint bytesUsed() const;

    bool write(GEE_Io *);
    bool read(GEE_Io *);

    // MJ_Array3D<Branch> m_children;
    MJ_Array3D<Leaf>   m_leafs;

    Leaf               m_topLeaf;
  };

  MJ_Array3D<Branch> m_tree;

  Leaf m_zeroLeaf;

  float m_voxelSize;
  uint  m_totalVoxelDim;
  uint  m_bottomDivision;
};


class VEE_GridForceBase : public VEE_ForceObject
{
public:
  VEE_GridForceBase();
  virtual ~VEE_GridForceBase();

  virtual void getForce(VEE_Vector3 *force,
      const VEE_Vector3 &velocity,
      const VEE_Vector3 &location);
  virtual void boundingBoxOfForce(VEE_BoundingBox *box);

  virtual bool setValue(const char *, VEE_Value *);
  virtual VEE_Variable getVariable(const char *) const;

  void setRotation(const VEE_Matrix3 & r)
  { m_rotation = r; m_rotationInv = r; m_rotationInv.transpose(); }

  const VEE_Matrix3 & rotation() { return m_rotation; }

protected:

  float       m_scale;
  VEE_Matrix3 m_rotation;
  VEE_Matrix3 m_rotationInv;

  float       m_magnitude;
  float       m_tangentForce;
  float       m_tangentGrab;
  float       m_bounce;
  float       m_drag;
  float       m_dragPower;

  float       m_bounceDistance;
  float       m_flowDistance;
  float       m_dragDistance;

  float       m_frameTime;

  bool        m_impactMethod;
  bool        m_onlyImpact;
};


class VEE_GridForce : public VEE_GridForceBase
{
public:
  VEE_GridForce();
  virtual ~VEE_GridForce();

  void getForce(VEE_Vector3 *force,
    const VEE_Vector3 &velocity,
                const VEE_Vector3 &location);
  void boundingBoxOfForce(VEE_BoundingBox *box);

  virtual void update(float);

  VEE_Object * clone() const;


  void setGrid(const VEE_VectorGrid &g) { m_grid = g; }

  VEE_VectorGrid & grid() { return (*m_grid); }

  float totalScale() const 
  { return (*m_grid).scale() * m_scale; }

protected:

  void recursiveImpact(VEE_SceneBox *, VEE_BoundingBox *);

  VEE_ReferenceObject<VEE_VectorGrid> m_grid;

};


class VEE_GridForce2 : public VEE_GridForceBase
{
public:
  VEE_GridForce2();
  virtual ~VEE_GridForce2();

  void getForce(VEE_Vector3 *force,
    const VEE_Vector3 &velocity,
                const VEE_Vector3 &location);
  void boundingBoxOfForce(VEE_BoundingBox *box);

  virtual void update(float);

  VEE_Object * clone() const;


  void setGrid(const VEE_VectorGridTree &g) { m_grid = g; }

  VEE_VectorGridTree & grid() { return (*m_grid); }

  float totalScale() const 
  { return m_scale; }

protected:

  void recursiveImpact(VEE_SceneBox *, VEE_BoundingBox *);

  VEE_ReferenceObject<VEE_VectorGridTree> m_grid;

};



#endif

---