~robot3d-team/robot3d/trunk

#ifndef OBJECTBASE_H_

#define OBJECTBASE_H_

 

// Delta3D files

#include <dtGame/gamemanager.h>

#include <dtABC/application.h>

#include <dtCore/transform.h>

#include <dtCore/scene.h>

 

// Robot3D files

#include <srCore/body/bodyBase.h>

 

//TODO: scale function for scaling the object mesh.

 

namespace srCore {

 

struct Parameters{

 

        std::string valueName;

        std::string valueType;

 

};

 

 

//! Object base class.

 

/*!

 *

 * Handles general properties of the objects.

 *

 * @author Lutz Winkler

 *

 */

class ObjectBase : public dtCore::Object

{

public:

 

        /**

         * \brief  Constructor

         *

         * \param                       attachedTo                                      Body, where the object is attached to

         * \param               translation                                     Local position of the object

         * \param                       orientation                                     Local orientation of the object

         * \param                       name                                            name of the object

         * \param                       type                                            type of the object

         *

         */

        ObjectBase( dtCore::RefPtr<BodyBase> attachedBody = NULL,

                                osg::Vec3f translation = osg::Vec3f(0,0,0), osg::Vec3f orientation= osg::Vec3f(0,0,0),

                                std::string name = "noName", std::string type = "noType",

                                bool active = true);

 

        //! Returns the name of the object

        inline std::string getName() const {return name;};

 

        //! Returns the type of the object

        inline std::string getType() const {return type;};

 

        //! Returns translation of the object - currently only local translation

        osg::Vec3f getTranslation(dtCore::Transformable::CoordSysEnum cs = dtCore::Transformable::REL_CS);

 

        //! Returns orientation of the object - currently only local orientation

        virtual osg::Vec3f getOrientation(dtCore::Transformable::CoordSysEnum cs = dtCore::Transformable::REL_CS);

 

        /**

         * \brief  Writes the parameter value in parameter

         *

         *              The available parameters can be retrieved by calling getParameterList()

         *

         * \param               name                                            name of the parameter

         * \param                       parameter                                       pointer where parameter value will be written to

         *

         * Example:

         * parameter is type of float, myHinge is instance of HingeActuator. The following program snippet writes the

         * parameter value of "RelPosition" to parameter. getParameter() checks hereby if the type of parameter is valid.

         *

         * myHinge->getParameter("RelPosition", MAKE_PARAMETER_VALUE(&parameter));

         *

         *

         */

        virtual void getParameter(const std::string &name, ParameterReturnValue  parameter);

 

        /**

         * \brief  Sets a parameter

         *

         *              See also getParameter()

         *

         */

        virtual void setParameter(const std::string &name, ParameterReturnValue  parameter);

 

        //! Returns the body, the object is attached to

        inline dtCore::RefPtr<BodyBase> getAttachedBody() const {return myBody;};

 

        //! Returns the parameter list. See also getParameter()

        inline std::vector<Parameters> getParameterList() const {return myParameters;}

 

        //! Activate/deactivate object. A deactivated object has no influence in the simulation

        inline void setActive(bool activate) {active = activate;}

 

        //! Returns true, if object is activated, else false.

        inline bool isActive() const {return active;}

 

        //! Will be called in RobotActorBase::TickLocal()

        virtual void update(float deltaSimTme) {};

 

protected:

        virtual ~ObjectBase();

 

        void setName(std::string name) {this->name = name;};

        void setType(std::string name) {this->type = type;};

        virtual void attachToBody(dtCore::RefPtr<BodyBase> body) {myBody = body; };

 

        std::vector<Parameters> myParameters;

        std::string name, type;

        osg::Vec3f relTranslation, relOrientation;

        osg::Vec3f absTranslation, absOrientation;

        dtCore::RefPtr<BodyBase> myBody;

        bool active;

 

};

}

 

#endif /*OBJECTBASE_H_*/