World.h

Go to the documentation of this file.

/***************************************************************************
                          World.h  -  description
                             -------------------
    begin                : Jun 2004
    copyright            : (C) 2004 by Jan Flasar
    email                : flasar@fi.muni.cz
 ***************************************************************************/

#ifndef WORLD_H
#define WORLD_H



#include <vrecko/BaseClass.h>
#include <vrecko/vThread.h>
#include <vrecko/Scheduler.h>
#include <vrecko/Ability.h>
#include <vrecko/Viewer.h>
#include <vrecko/EventDispatcher.h>

#include <osg/Group>
#include <osgText/Text>


//---------------------------------------------------------------
//Shadows
//---------------------------------------------------------------
#include <osgShadow/ShadowedScene>
#include <osgShadow/ShadowVolume>
#include <osgShadow/ShadowTexture>
#include <osgShadow/ShadowMap>
#include <osgShadow/SoftShadowMap>
//---------------------------------------------------------------
//Shadows
//---------------------------------------------------------------

#include <vrecko/Logger.h> // at jde kdekoliv pouzivat globalni promenna [logger] (resp. vrecko::logger)
#include <vrecko/PersistentCache.h>


namespace vrecko {

class VRECKO_EXPORT Scene;
class VRECKO_EXPORT DeviceManager;
class VRECKO_EXPORT EventDispatcher;

class VRECKO_EXPORT World: public BaseClass, public osg::Group {
    public:
        World();
        ~World();
        World(const World &w);

        void setViewerPtr(ViewerBase *pV);
        ViewerBase *getViewerPtr() { return pViewer; };
        osg::Camera *getCamera(void) {return (pViewer ? pViewer->getCamera(0) : NULL);}
        
        //---------------------------------------------------------------
        //Shadows
        //---------------------------------------------------------------
        osg::ref_ptr<osgShadow::ShadowedScene> shadowedScene;
        osgShadow::ShadowedScene*   getShadowedScenePtr()   { return shadowedScene.get(); }
        osg::LightSource*           getShadowedSceneLight() { return mainLightSource.get(); }
        //---------------------------------------------------------------
        //Shadows
        //---------------------------------------------------------------
        
        void setDescription(const std::string &desc) {description = desc;}
        inline const std::string &getDescription(void) const {return description;}
        
        void setScenePtr(Scene *nScene);
        Scene *getScenePtr(void) {return pScene;}

        typedef struct AvatarView {
            std::string ID;
            BaseClass *owner;
            osg::Vec3 eye_position;
            osg::Vec3 look_at_center;
            osg::Vec3 up_vector;
        };

        AvatarView *getActualAvatarView(void) {return avatar_view_vector[0];}
        void setActualAvatarView(AvatarView *av) {avatar_view_vector.insert(avatar_view_vector.begin(), av);}
        bool removeAvatarView(AvatarView *av);

        struct AvatarEye
        {
            osg::Vec3       eye_offset;
            osg::Matrix     projection;
        };

        class
        {
        private:
            std::vector<AvatarEye>  _eyes;

        public:
            void CreateEyes(int count)      {   _eyes.resize(count);    }
            void DestroyEyes()              {   _eyes.clear();          }

            int GetCount()                  {   return _eyes.size();    }

            AvatarEye *Get(int eye_index)
            {   return ((eye_index >= 0) && (eye_index < GetCount())) ? (&(_eyes[eye_index])) : 0;      }
        } AvatarEyes;





        typedef enum {
            UNKNOWN,
            ADD_CHILD,
            ADD_EOCHILD,
            REMOVE_CHILD,
            REMOVE_EOCHILD,
            SET_STATESET,
            DELETE_STATESET,
            SET_TEXT
        } SG_OPERATION_TYPE;
        
        typedef struct {
            osg::Node *pNode;
            osg::Group *pGroup;
            osg::StateSet *pStateSet;
            osgText::Text *pText;
            std::string text_string;
            SG_OPERATION_TYPE type;
        } SG_CHANGE;
        

        // You can set [owner] to NULL, which means "world".
        vrecko::Ability* createAbility(const std::string& plugin_name, const std::string& ability_name, BaseClass* _owner, const char* _overridingID = NULL);

        
        void setDeviceManagerPtr(DeviceManager *ptr) {pDeviceManager = ptr;}
        DeviceManager* getDeviceManagerPtr() {return pDeviceManager;}
        
        void setEventDispatcherPtr(EventDispatcher *ptr) {pEventDispatcher = ptr;}
        EventDispatcher* getEventDispatcherPtr() {return pEventDispatcher;}
    
        void setSchedulerPtr(Scheduler *sched) {pScheduler = sched;}
        inline Scheduler* getSchedulerPtr() {return pScheduler;}

        inline PersistentCache* getPersistentCache() { return persistentCache; }
        
        bool getTerminationFlag() {return termination_flag;}
    
        bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *parametersNode);

        // ----- LogFile functions
//      void textLog(const char *text = "", ...);
        void noticeLog(const char *notice = "", ...);
//      void noticeLog(int level, const char *notice = "", ...);
        void warningLog(const char *warning = "", ...);
//      void warningLog(int level, const char *warning = "", ...);
        void errorLog(const char *error = "", ...);
//      void errorLog(int level, const char *error = "", ...);
        void debugLog(const char *debugText = "", ...);
        // The debugFileLog() function only writes info to the file
        void debugFileLog(const char *debugText = "", ...);
        
        // functions for handling abilities
        bool addAbility(Ability *pAbility) {ability_dispatcher->addAbility(pAbility); return true;}
        bool removeAbility(Ability *pAbility) {ability_dispatcher->removeAbility(pAbility); return true;}
        bool removeAbility(const std::string &ability_id);
        Ability *getAbility(const std::string &ab_id) {return ability_dispatcher->getAbility(ab_id);}
        //Ability *getAppropriateAbility(const std::string &message_ID) {return ability_dispatcher->getAppropriateAbility(message_ID);}
        //Ability *getAbilityWithInput(const std::string &input_name) {return ability_dispatcher->getAbilityWithInput(input_name);}
        //Ability *getAbilityWithOutput(const std::string &output_name) {return ability_dispatcher->getAbilityWithOutput(output_name);}
        std::map<std::string, Ability*> &getAbilityMap(void) {return ability_dispatcher->getAbilityMap();}



// Heavily used methods from EventDispatcher are inlined here, so we do not need to write "world->getEventDispatcher()->reportEvent",
// but just "world->reportEvent"
        inline bool reportEvent(const std::string &senderAndOutputString, VreckoMessage *pMessage, EventType eType = EXPRESS_EVENT) {
            return getEventDispatcherPtr()->reportEvent(senderAndOutputString, pMessage, eType);
        }       
        inline bool reportEvent(BaseClass *receiver_ptr, const std::string &input_name, VreckoMessage *pMessage, EventType eType = EXPRESS_EVENT) {
            return getEventDispatcherPtr()->reportEvent(receiver_ptr, input_name, pMessage, eType);
        }
        inline osg::ref_ptr<VreckoMessage> request(const std::string &req_sender, VreckoMessage *pMessage) {
            return getEventDispatcherPtr()->request(req_sender, pMessage);
        }
        inline osg::ref_ptr<VreckoMessage> request(BaseClass *receiver_ptr, const std::string &request_name, VreckoMessage *pMessage) {
            return getEventDispatcherPtr()->request(receiver_ptr, request_name, pMessage);
        }




        inline unsigned long getFrameID() { return frameID; }
        inline void incrementFrameID() { ++frameID; }

        inline bool getShowTimeWarnings() { return bShowTimeWarnings; };
        inline void setShowTimeWarnings(bool bNewValue) { bShowTimeWarnings = bNewValue; };

        inline unsigned long getTimeWarningsTime() { return ulTimeWarningsTime; };
        inline void setTimeWarningsTime(unsigned long ulNewValue) { ulTimeWarningsTime = ulNewValue; };

        void SendTerminationNotifications() { sendNotifications(BaseClass::NOTIFICATION_PROGRAM_TERMINATION, NULL); };

        /*
        * Method saves arguments and its count from main class to be accessible for objects
        */
        void setArgumens(int &count, char **arguments);

        /*
        * Method returns number of arguments with which the program started 
        */
        int getNumberOfArguments();

        /*
        * Method returns the field of arguments with which the program started
        */
        char ** getArguments();

    protected:
        std::string description;
        Scene *pScene;
        std::vector<AvatarView *> avatar_view_vector;
        
        // ???
        ViewerBase *viewer;
        
        //NEW shadows and light;
        osg::ref_ptr<osg::LightSource> mainLightSource;
        
        AbilityDispatcher *ability_dispatcher;

        // Data cache that is persistent throughout multiple app runs.
        PersistentCache *persistentCache;
    
    private:
        //saved arguments from command
        int arguments_count;
        char **arguments;

        // Pointer to the viewer
        ViewerBase *pViewer;

        DeviceManager *pDeviceManager;
        
        EventDispatcher *pEventDispatcher;
        
        Scheduler *pScheduler;

        bool termination_flag;

        // Current frame ID (will be different for each frame)
        unsigned long frameID;

        // Will display warnings like "Processing a MESSAGE took a long time (... ms)"
        bool bShowTimeWarnings;
        unsigned long ulTimeWarningsTime; // in ms. An event will need to take at least this time for the warning to be displayed.
};

VRECKO_EXPORT bool initXML();
VRECKO_EXPORT bool doneXML();


VRECKO_EXPORT const std::string& getSafeSceneFile(const std::string &sceneFile);

VRECKO_EXPORT unsigned long getNumSceneFiles();

VRECKO_EXPORT const std::string& getSafeSceneFile(unsigned long index);

VRECKO_EXPORT const std::string& getSafeDefaultSceneFile();

VRECKO_EXPORT void setDefaultSceneFile(const std::string &newDefaultSceneFile);


}

#endif


namespace vrecko {
    extern VRECKO_EXPORT World *world;
};