OgreRefAppApplicationObject.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of the OGRE Reference Application, a layer built
on top of OGRE(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
#ifndef __REFAPP_APPLICATIONOBJECT_H__
#define __REFAPP_APPLICATIONOBJECT_H__

#include "OgreRefAppPrerequisites.h"

namespace OgreRefApp {

    class _OgreRefAppExport ApplicationObject : public UserDefinedObject
    {
    protected:
        // Visual component
        SceneNode* mSceneNode;
        Entity* mEntity;

        dBody* mOdeBody;
        dMass mMass;


        typedef std::list<dGeom*> CollisionProxyList;
        CollisionProxyList mCollisionProxies;


        bool mDynamicsEnabled;
        bool mReenableIfInteractedWith;
        bool mCollisionEnabled;

        Real mBounceCoeffRestitution;
        Real mBounceVelocityThreshold;
        Real mSoftness;
        Real mFriction;
        Real mLinearVelDisableThreshold;
        Real mAngularVelDisableThreshold;
        Real mDisableTime;
        Real mDisableTimeEnd;

        // Set up method, must override
        virtual void setUp(const String& name) = 0;
        virtual void updateCollisionProxies(void);

        virtual bool testCollidePlaneBounds(SceneQuery::WorldFragment* wf);

        virtual void setEntityQueryFlags(void);

    public:
        ApplicationObject(const String& name);
        virtual ~ApplicationObject();

        virtual void setPosition(const Vector3& vec);
        virtual void setPosition(Real x, Real y, Real z);
        virtual void setOrientation(const Quaternion& orientation);
        virtual const Vector3& getPosition(void);
        virtual const Quaternion& getOrientation(void);

        virtual void _updateFromDynamics(void);

        virtual bool isCollisionEnabled(void);
        virtual bool isDynamicsEnabled(void);
        virtual void setDynamicsDisableThreshold(Real linearSq, Real angularSq, Real overTime);

        virtual void setCollisionEnabled(bool enabled);
        virtual void setDynamicsEnabled(bool enabled, bool reEnableOnInteraction = false);

        virtual void setBounceParameters(Real restitutionValue, Real velocityThreshold);
        virtual Real getBounceRestitutionValue(void);
        virtual Real getBounceVelocityThreshold(void);

        virtual void setSoftness(Real softness);
        virtual Real getSoftness(void);

        virtual void setFriction(Real friction);
        virtual Real getFriction(void);
        virtual void addForce(const Vector3& direction, const Vector3& atPosition = Vector3::ZERO);
        virtual void addForce(Real dir_x, Real dir_y, Real dir_z, 
            Real pos_x = 0, Real pos_y = 0, Real pos_z = 0);
        virtual void addForceWorldSpace(const Vector3& direction, const Vector3& atPosition = Vector3::ZERO);
        virtual void addForceWorldSpace(Real dir_x, Real dir_y, Real dir_z, 
        Real pos_x, Real pos_y, Real pos_z);
        virtual void addTorque(const Vector3& direction);
        virtual void addTorque(Real x, Real y, Real z);
        virtual void addTorqueWorldSpace(const Vector3& direction);
        virtual void addTorqueWorldSpace(Real x, Real y, Real z);

        virtual bool testCollide(ApplicationObject* otherObj);

        virtual bool testCollide(SceneQuery::WorldFragment* wf);

        struct CollisionInfo
        {
            Vector3 position;
            Vector3 normal;
            Real penetrationDepth;
        };
        virtual void _notifyCollided(ApplicationObject* otherObj, const CollisionInfo& info);
        virtual void _notifyCollided(SceneQuery::WorldFragment* wf, const CollisionInfo& info);
        SceneNode* getSceneNode(void);
        Entity* getEntity(void);
        dBody* getOdeBody(void);

        void setMassSphere(Real density, Real radius);

        void setMassBox(Real density, const Vector3& dimensions, 
            const Quaternion& orientation = Quaternion::IDENTITY);

        void setMassCappedCylinder(Real density, Real length, Real width, 
            const Quaternion& orientation = Quaternion::IDENTITY);

        void setMassExpert(Real mass, const Vector3 center, const Matrix3 inertia);

        const dMass* getOdeMass(void);

        void setLinearVelocity(const Vector3& vel);
        void setLinearVelocity(Real x, Real y, Real z);
        const Vector3& getLinearVelocity(void);

        const Vector3& getAngularVelocity(void);

        void setAngularVelocity(const Vector3& vel);
        void setAngularVelocity(Real x, Real y, Real z);

        virtual void translate(const Vector3& d);
        virtual void translate(Real x, Real y, Real z);

        virtual void translateWorldSpace(const Vector3& d);
        virtual void translateWorldSpace(Real x, Real y, Real z);

        virtual void roll(const Radian& angle);
#ifndef OGRE_FORCE_ANGLE_TYPES
        inline void roll(Real angleunits) {
            roll ( Angle(angleunits) );
        }
#endif//OGRE_FORCE_ANGLE_TYPES

        virtual void pitch(const Radian& angle);
#ifndef OGRE_FORCE_ANGLE_TYPES
        inline void pitch(Real angleunits) {
            pitch ( Angle(angleunits) );
        }
#endif//OGRE_FORCE_ANGLE_TYPES

        virtual void yaw(const Radian& angle);
#ifndef OGRE_FORCE_ANGLE_TYPES
        inline void yaw(Real angleunits) {
            yaw ( Angle(angleunits) );
        }
#endif//OGRE_FORCE_ANGLE_TYPES

        virtual void rotate(const Vector3& axis, const Radian& angle);
#ifndef OGRE_FORCE_ANGLE_TYPES
        inline void rotate(const Vector3& axis, Real angleunits) {
            rotate ( axis, Angle(angleunits) );
        }
#endif//OGRE_FORCE_ANGLE_TYPES

        virtual void rotate(const Quaternion& q);


    };


} // namespace

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:50 2006