vee_scene.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_SCENE_H
#define VEE_SCENE_H

#include <vee_bounding_box.h>
#include <vee_object.h>
#include <vee_object_store.h>
#include <vee_force_object.h>
#include <vee_gravity.h>
#include <vee_time.h>

#include <iostream>
#include <sys/time.h>

// #include <vector>



#define VEE_SB_CHILDREN 8
#define VEE_SB_SPLITS 2
// #define VEE_SB_SQUARES VEE_SB_SPLITS * VEE_SB_SPLITS

class VEE_SceneBox
{
public:

  // typedef std::vector<VEE_Object *>::iterator iterator;
  typedef VEE_PointerStoreSet<VEE_Object> ObjectStore;
  typedef ObjectStore::iterator iterator;

  VEE_SceneBox();
  VEE_SceneBox(VEE_SceneBox *parent, 
         const VEE_Vector3 &low,
         const VEE_Vector3 &high);

  virtual ~VEE_SceneBox();

  void init(VEE_SceneBox *parent, 
      const VEE_Vector3 &low,
      const VEE_Vector3 &high);

  void setArea(const VEE_Vector3 &low,
         const VEE_Vector3 &high)
  { m_bbox.low() = low; m_bbox.high() = high; }

  bool addObject(VEE_Object *);
  bool addNewObject(VEE_Object *);
  bool addObject(VEE_ForceObject *);
  bool addNewForce(VEE_ForceObject *);
  void addChildObject(VEE_Object *);
  void removeChildObject(VEE_Object *);

  void addForceHere(VEE_ForceObject *o, 
        const VEE_BoundingBox *bbox, 
        const VEE_SceneBox * caller = 0);
  void addForceSomewhere(VEE_ForceObject *o, 
       const VEE_BoundingBox *bbox, 
       const VEE_SceneBox * caller = 0);
  void forgetForce(VEE_ForceObject *o);

  void updateScene(int frame);
  void updateScene() { updateScene(m_frame); }

  void getObjects(ObjectStore * target);
  void getForces(std::set<VEE_ForceObject *> * target);

  uint totalChildren();
  uint totalForces();

  void update(uint splitTreshold, 
        uint collapseTreshold, 
        int allowRecursionLevels);
  void update(uint splitTreshold, 
        uint collapseTreshold, 
        int allowRecursionLevels,
        float dt);

  bool updateTree(uint splitTreshold, 
      uint collapseTreshold, 
      int allowRecursionLevels = 10);

  void updateR(float dt);

  bool trySplit(uint treshold, int allowRecursionLevels);
  bool tryCollapse(uint treshold);

  void refreshTimeLastUpdate();
  void incrementFrame() { m_frame++; }

  bool isSplit() const { return m_children != 0; }

  bool write(std::ostream * s = 0);

  void getForce(VEE_ForceType forceType,
    const VEE_Object *object,
    VEE_Vector3 *force, 
    const VEE_Vector3 &velocity,
    const VEE_Vector3 &location);
  uint getForces(VEE_ForceType forceType,
     const VEE_Object *object,
     VEE_Vector3 *force,
     uint n,
     const VEE_Vector3 *velocity,
     const VEE_Vector3 *location);
  uint getForcesDown(VEE_ForceType forceType,
         const VEE_Object *object,
         VEE_Vector3 *force,
         uint n,
         const VEE_Vector3 *velocity,
         const VEE_Vector3 *location);
  uint getForcesNR(VEE_ForceType forceType,
       const VEE_Object *object,
       VEE_Vector3 *force,
       uint n,
       const VEE_Vector3 *velocity,
       const VEE_Vector3 *location);
    
  VEE_SceneBox *parent() { return m_parent; }
  VEE_SceneBox *children() { return m_children; }
  VEE_SceneBox *child(uint k) { return &m_children[k]; }
  // VEE_Object *&object(uint k) { return m_objects[k]; }
  uint numObjects() { return m_objects.size(); }
  uint numForceObjects() { return m_forces.size(); }
  VEE_BoundingBox & boundingBox() { return m_bbox; }
  const VEE_BoundingBox & boundingBox() const { return m_bbox; }

  uint numChildBoxes();

#ifndef VEE_FAST
  static long count() { return m_count; }
#endif

  iterator begin() { return m_objects.begin(); }
  iterator end() { return m_objects.end(); }
  static VEE_Object * getObject(iterator & it) { return (*it); }

protected:

  VEE_SceneBox &getChild(uint x, uint y, uint z)
  { return m_children[x * 4 + y * 2 + z]; }

  bool updateSceneLocation(VEE_Object *);
  bool updateForceSceneLocation(VEE_ForceObject *);
  void updateVelocities(float dt);
  void tryToSendForcesDown();

  // std::vector<VEE_Object *>      m_objects;
  ObjectStore                    m_objects;
  
  typedef VEE_PointerStoreSet<VEE_ForceObject> ForceStore;

  // VEE_PointerStoreList<VEE_ForceObject> m_forces;
  // VEE_PointerStoreHash<VEE_ForceObject> m_forces;
  ForceStore                     m_forces;
  // std::vector<VEE_Polygon *>     m_polygonObjects;

  VEE_SceneBox *m_parent;
  VEE_SceneBox *m_children;

  VEE_BoundingBox m_bbox;

  int m_frame;

private:
  VEE_SceneBox(const VEE_SceneBox &) {}

#ifndef VEE_FAST
  static long m_count;
#endif

  VEE_Time m_tvLast;
};

#endif

---