EnvironmentObject.h

Go to the documentation of this file.

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


#ifndef ENVIRONMENTOBJECT_H
#define ENVIRONMENTOBJECT_H

#include <osg/Vec3>
#include <osg/Matrix>
#include <osg/MatrixTransform>
#include <vrecko/IOPins.h>
#include <vrecko/BaseClass.h>
#include <vrecko/Ability.h>
#include <vrecko/Message.h>

//#include <esg/OSGAdapter.h>

#include <vector>

#include <esg/Definitions.h>

#define SYSTEM_VISIBLE_OBJECT_TRAVERSAL_MASK    0x00000001
#define RECEIVES_SHADOW_TRAVERSAL_MASK          0x20
#define CASTS_SHADOW_TRAVERSAL_MASK             0x40
#define SYSTEM_TRAVERSAL_MASK__MASK             (RECEIVES_SHADOW_TRAVERSAL_MASK | CASTS_SHADOW_TRAVERSAL_MASK)


namespace esg {
    class OSGAdapter;
}

namespace osg {
    class Geometry;
    class Geode;
}


namespace vrecko {  


class VRECKO_EXPORT Scene;

class VRECKO_EXPORT EnvironmentObject: public BaseClass, public osg::MatrixTransform {
    friend class World;
    public:
        EnvironmentObject();
        ~EnvironmentObject();
        EnvironmentObject(EnvironmentObject &eo);

        virtual bool initialize(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *parameters = NULL);

        void setID(unsigned long new_id);

        
        inline const unsigned long getID() const {return id;}

        void setName(const std::string &n) {name = n;}

        
        inline const std::string &getName(void) const {return name;}
        
        
        bool loadGeometry(const char *filename, bool bOutputErrors = true);
        
        
        bool setGeometry(osg::Geode *new_geomtetry, long int k = 1, long int l = 100000);

        void setModelFileName(const std::string mfn) {modelFileName = mfn;}

        
        inline const std::string &getModelFileName(void) const {return modelFileName;}

        bool addAbility(Ability *ability, bool bCreateNewIdIfColliding = true);

        bool removeAbility(Ability *pAbility);

        bool removeAbility(const std::string &ability_id);


        bool removeAllAbilities() { ability_dispatcher.removeAllAbilities(); return true; }

        
        inline Ability *getAbility(const std::string &ab_id) { return ability_dispatcher.getAbility(ab_id); }

        
        Ability *getAbility(const std::string &pluginName, const std::string &abilityName);

        inline Ability *getAbilityWithInput(const std::string &input_name) {return ability_dispatcher.getAbilityWithInput(input_name);}

        inline Ability *getAbilityWithOutput(const std::string &output_name) {return ability_dispatcher.getAbilityWithOutput(output_name);}

        
        std::map<std::string, Ability*> &getAbilityMap(void) {return ability_dispatcher.getAbilityMap();}


        osg::Matrix &getWorldTransformation(void);

        
        osg::Vec3 getWorldPosition(void);
        

        osg::Matrix getWorldRotation(void);

        void setIdentityTransformation(void);

        void setPosition( const osg::Vec3 & coords );

        void setPosition( float x, float y, float z );

        osg::Vec3 &getPosition();

        void setRotation(float angle, float x, float y, float z);

        void setRotation(const osg::Vec3 & angles);

        void setRotation(const osg::Matrix & new_matrix);

        void setRotation(const osg::Quat & quat);

        osg::Matrix &getRotation(void) {return rotation_matrix;}

        void setScale(const osg::Vec3 &new_scale);

        void setScale(float x, float y, float z);

        osg::Vec3& getScale(void) {return scale_vec;}

        void setOSGAdapter(std::vector<esg::OSGAdapter *> new_osga) {osgadapter_vector = new_osga;}

        std::vector<esg::OSGAdapter *>* getOSGAdapter(void) {return &osgadapter_vector;}

        EnvironmentObject* getParentEO(void);


        bool addEOChild(EnvironmentObject *new_EO);

        bool removeEOChild(EnvironmentObject *new_EO);


        typedef enum {
            UD_UNKNOWN = 0,
            UD_BOOL,
            UD_INT,
            UD_LONG_INT,
            UD_FLOAT,
            UD_DOUBLE,
            UD_STRING,
            UD_VEC2,
            UD_VEC3,
            UD_VEC4,
            UD_MATRIX,
            UD_QUAT,
            UD_POINTER,
            UD_USER
        } UserData_Type;
        
/*      // This struct is used to define user type UserData and functions for load and save.
        typedef struct {
            // Return the XML-DOMNode with parameters. 
            virtual DOMNode *saveXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *) {return NULL;}
            // This virtual function serves to load XML-parameters.
            virtual bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *) {return false;}
        } UserDataStruct;
*/
        typedef struct {
            void *pointer;
            UserData_Type type;
        } UserData;

        void addUserData(const std::string &nlabel, void *npointer, UserData_Type ntype);

        bool removeUserData(const std::string &label);

        UserData *getUserData(const std::string &label);

        std::map<std::string, UserData *> getUserDataMap(void) {return user_data;}
        
        void setTransparency(float transp);

        inline float getTransparency(void) {return transparency;}

        inline void show() {bVisible = true; updateNodeMask();}

        inline void hide() {bVisible = false; updateNodeMask();}

        inline bool isVisible() { return bVisible;}

        inline bool isCollisionFree() {return bCollisionFree;}

        void setCastShadows(bool cast);

    protected:
        unsigned long id;

        std::string name;

        std::string modelFileName;

        AbilityDispatcher ability_dispatcher;

        // Temporary transform matrix variable, so it doesn't need to be allocated
        // every time the getWorldTransformation() is called and then copied to the caller
        osg::Matrix tempTransformMatrix;

        osg::Vec3 trans_vec;

        osg::Matrix rotation_matrix;

        osg::Vec3 scale_vec;

        float transparency;

        // Visibility of object
        bool bVisible;

        // True equals that the object is not able to collision to any onther objects
        bool bCollisionFree;

        std::vector<esg::OSGAdapter *> osgadapter_vector;

        std::map<std::string, UserData *> user_data;

        void updateNodeMask();

        void createCollisionHierarchy(osg::Node *pNode);

        void fixGeometryMirroring(const osg::Node *node);
        
        void fixGeometryHelper(const osg::Node *node, bool bMirrored);
        
        void fixGeometryDrawableHelper(const osg::Drawable *draw, bool bMirrored);

        DECLARE_INPUT(Position, MessageVec3);

        DECLARE_INPUT(Orientation, MessageQuat);
        DECLARE_INPUT(Location, MessageMatrix);
        DECLARE_INPUT(RelativePosition, MessageVec3);
        DECLARE_INPUT(RelativeOrientation, MessageQuat);
        DECLARE_INPUT(RelativeLocation, MessageMatrix);
};

}

#endif