Scene.h

Go to the documentation of this file.

/***************************************************************************
                          Scene.h  -  description
                             -------------------
    begin                : May 2002
    copyright            : (C) 2002 by Jan Flasar, Ludek Pokluda
    email                : flasar|xpokluda@fi.muni.cz
 ***************************************************************************/

#ifndef SCENE_H
#define SCENE_H

#include <osg/Node>

#include <vrecko/BaseClass.h>
#include <vrecko/EnvironmentObject.h>

#include <vrecko/World.h>
#include <vrecko/MTLock.h>

#include <helpers/DynamicArray.h>
#include <vrecko/SP_CommonDefs.h>

namespace vrecko {

class SP_SceneInterface;
class SP_ObjectInterface;


// Flags for CalcNodeBBox:

#define CNBB_F_FORCE_AABBOX             0x00000001
    
#define CNBB_F_ONLY_LOCAL_TRANSFORM     0x00000002
    
#define CNBB_F_NO_SELF_TRANSFORM        0x00000004




// Flags for Scene::EOIteratorHelper::initIterationFrom()

#define EOIH_IF_START_BEGINNING     0x00000001
    
#define EOIH_IF_START_CURRENT       0x00000002
    
#define EOIH_IF_START_NEXT          0x00000004
    



struct ScenePSThreadInfo {
    // This structure is both stored and passed to the thread as a parameter,
    // therefore we must pass also the pointer to this class.
    Scene *scene;
    HANDLE hThreadHandle;

    bool bTerminateThread;
        

    osg::Timer_t lastRequest;

    CollisionParams params;
    unsigned long limitToEO1, limitToEO2;
};



DWORD WINAPI ScenePSThreadProc(ScenePSThreadInfo *lpParameter);


class VRECKO_EXPORT Scene: public BaseClass, public osg::MatrixTransform {
    public:


        class VRECKO_EXPORT EOIteratorHelper: public BaseClass {


        public:
            EOIteratorHelper();
            ~EOIteratorHelper();

            bool initIteration();

            bool initIterationFrom(Scene::EOIteratorHelper *sourceHelper, unsigned long dwInitFlags = EOIH_IF_START_BEGINNING);

            void endIteration();

            bool getAndLockNextObject(EnvironmentObject **outObject);

            bool releaseObject(void);

        protected:
            bool bInited; 

            MTLock generalLock;

            typedef DynamicArray<EnvironmentObject*> EOVector;
            EOVector objects; 

            int currentObjectIndex;

            bool bObjectLocked;
                


            HANDLE hCollisionEvent1, hCollisionEvent2;
            bool bCollisionOccured_EventExpected;


            virtual int processNotification(BaseClass *sender, unsigned long notificationType, void *notificationData);
        };

        Scene();
        ~Scene();
//      Scene(const Scene& s);

        void prepareForTermination();

        void setDescription(const std::string &desc) {description = desc;}

        const std::string &getDescription(void) {return description;}

        void update(void);

        osg::MatrixTransform *getRoot() {return rootNode;}

        osg::MatrixTransform *getEORoot() {return eoRootNode;}

        unsigned long getFreeID(unsigned long req_id);

        int addEnvironmentObject(EnvironmentObject *environment_object, osg::Group *parentNode);

        inline int addEnvironmentObject(EnvironmentObject *environment_object ) { return addEnvironmentObject(environment_object, eoRootNode); }

        bool removeEnvironmentObject( unsigned long id );

        EnvironmentObject * getEnvironmentObject( unsigned long id, bool bReportErrorIfNotFound = true );

        bool registerEnvironmentObject(EnvironmentObject *environment_object);

        bool unregisterEnvironmentObject(EnvironmentObject *environment_object);

        bool unregisterEnvironmentObject(unsigned long id);
        
        typedef Sgi::hash_map<unsigned long, EnvironmentObject *> EOMap;

        inline EOMap &getEOMap(void) {return environment_objects_map;}

        inline void lockEOMapForRead(void) { eoMapLock.lockRead(); }
            
        inline void unlockEOMapForRead(void) { eoMapLock.unlockRead(); }
            
        inline void lockEOMapForWrite(void) { eoMapLock.lockWrite(); }
            
        inline void unlockEOMapForWrite(void) { eoMapLock.unlockWrite(); }
            

        inline bool isLoaded(void) { return _bIsLoaded; }   

        
        inline void setIsLoaded(bool bNewValue) { _bIsLoaded = bNewValue; }
        

        EnvironmentObject *getCollisionObject(EnvironmentObject *eobject);
        EnvironmentObject **getCollisionObjects(EnvironmentObject *eobject, int &size);
        EnvironmentObject **getCollisionObjects(esg::OSGAdapter *pOSGAdapter, const osg::Matrix &transf, int &size);
        
        EnvironmentObject *getRayIntersection(const osg::Vec3 &origin, const osg::Vec3 &dir);
        
        EnvironmentObject *getRayIntersection(const osg::Vec3 &origin, const osg::Vec3 &dir, osg::Vec3 &intersection_point);
        
        bool getRayIntersection(EnvironmentObject *eobject, const osg::Vec3 &origin, const osg::Vec3 &dir, osg::Vec3 &intersection_point);

        void getObjectExtent(EnvironmentObject *eobject, const osg::Vec3 &dir, float &min, float &max);

        bool separation(esg::Matrix4 *trMat1, std::vector<esg::OSGAdapter *> object1, esg::Matrix4 *trMat2, std::vector<esg::OSGAdapter *> object2, unsigned d1 = UINT_MAX, unsigned d2 = UINT_MAX);




        bool calcNodeBBox(osg::Node *node, osg::BoundingBox *outBox, osg::Matrix *outTransform, bool *bTransformUsed = NULL, unsigned long dwFlags = 0, osg::Node *subTreeToIgnore = NULL);

        bool getCollisions(CollisionParams * params, COLLISIONS_INFO_VECTOR ** collisions, unsigned long limitToEO1 = 0, unsigned long limitToEO2 = 0);

        /* INTERNAL USAGE - set/get scene partitioning interface for scene operations.
           You should probably use Scene::getCollisions(). */
        bool addPartitioningSceneInterface(SP_SceneInterface *newInterface, int priority = 0);
        void removePartitioningSceneInterface(SP_SceneInterface *anInterface);
        SP_SceneInterface* getPartitioningSceneInterface(int id = PARTITIONING_INTERFACE_DEFAULT);

        /* INTERNAL USAGE - set/get scene partitioning interface for object operations
           You should probably use Scene::getCollisions(). */
        bool addPartitioningObjectInterface(SP_ObjectInterface *newInterface, int priority = 0);
        void removePartitioningObjectInterface(SP_ObjectInterface *anInterface);
        SP_ObjectInterface* getPartitioningObjectInterface(int id = PARTITIONING_INTERFACE_DEFAULT);

        
        void logHierarchy(const osg::Node *topNode, const char *note = NULL);

        
    protected:
        std::string description;

        MTReadWriteLock eoMapLock;
        
        EOMap environment_objects_map;
        osg::MatrixTransform *rootNode;
        osg::MatrixTransform *eoRootNode;

        unsigned long nextFreeID;

        bool _bIsLoaded;


        struct SC_INT_PRIO {
            SP_SceneInterface* scInt;
            int priority;
        };
        DynamicArray<SC_INT_PRIO> partitioningSceneInterfaces; 

        struct OBJ_INT_PRIO {
            SP_ObjectInterface* objInt;
            int priority;
        };
        DynamicArray<OBJ_INT_PRIO> partitioningObjectInterfaces; 

        std::vector<ScenePSThreadInfo*> partThreadsInfo;

        int lastUpdatePartThrIndex;

        bool calcNodeBBoxHelper(osg::Node *node, osg::BoundingBox *outBox, osg::Matrix *outTransform, bool *bTransformUsed, unsigned long dwFlags, osg::Node *nodeToStopTraversalAt, osg::Node *subTreeToIgnore);

        friend DWORD WINAPI ScenePSThreadProc(ScenePSThreadInfo *lpParameter);

        void logHierarchyHelper(int level, const osg::Node *node);
        void logHierarchyDrawableHelper(int level, const osg::Drawable *dw);
};

}

#endif