dustyentity.h

Go to the documentation of this file.

/*
Dusty Engine Library
by Dave Andrews

Dusty Engine is a task engine using the Irrlicht (irrlicht.sourceforge.net)
3d Engine, by Nikolaus Gebhardt.

This software is released on the zlib license.  Contents of that license follow.

  Copyright (C) 2005 Dave Andrews

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.

  Dave Andrews (dave@daveandrews.org)
*/

#ifndef __DUSTY_ENTITY_H__
#define __DUSTY_ENTITY_H__

#include <irrlicht.h>
#include "dustyengine.h"

namespace DustyEngine
{
        class NodeAffector;
        class EntityParentTask;
        const irr::u32 DEFAULT_UPDATE_INTERVAL = 20;

        enum EntityActionType
        {
                VECTOR = 0,
                INTERPOLATED,
                BOUNDED,
                WAYPOINT
        };


        class DUSTYENGINE_API Entity : public irr::IUnknown, public NodeAffector
        {
        public:
                Entity(DustyDriver * d);

                virtual ~Entity();


                void SetUpdateInterval(irr::u32 interval);

                irr::u32 GetUpdateInterval();

                void SetMoveType(EntityActionType type);

                void SetRotateType(EntityActionType type);

                void SetScaleType(EntityActionType type);

                EntityActionType GetMoveType();

                EntityActionType GetRotateType();

                EntityActionType GetScaleType();

                void Pause();

                void Unpause();

                void PauseMovement();

                void PauseRotation();

                void PauseScaling();

                void UnpauseMovement();

                void UnpauseRotation();

                void UnpauseScaling();

                void SetExecuteMultiple(bool multiple);
                bool GetExecuteMultiple();

                void SetNode(irr::scene::ISceneNode * n);


                EntityParentTask * GetParentTask();

                void SetRemoveNodeOnDestroy(bool remove);

                bool GetRemoveNodeOnDestroy();

// **** Vector Functions ****


                void SetMoveVector(irr::core::vector3df vector);

                irr::core::vector3df GetMoveVector();


                void SetScaleVector(irr::core::vector3df vector);

                irr::core::vector3df GetScaleVector();


                void SetRotateVector(irr::core::vector3df vector);

                irr::core::vector3df GetRotateVector();

// **** Bounded Functions ****


                void SetMoveBoundaries(irr::core::vector3df min, irr::core::vector3df max);

                void SetMoveMinBoundary(irr::core::vector3df min);
                
                void SetMoveMaxBoundary(irr::core::vector3df max);

                irr::core::vector3df GetMoveMinBoundary();

                irr::core::vector3df GetMoveMaxBoundary();

                irr::u32 GetMoveCollisionValue();


                void SetScaleBoundaries(irr::core::vector3df min, irr::core::vector3df max);

                void SetScaleMinBoundary(irr::core::vector3df min);

                void SetScaleMaxBoundary(irr::core::vector3df max);

                irr::core::vector3df GetScaleMinBoundary();
                
                irr::core::vector3df GetScaleMaxBoundary();

                irr::u32 GetScaleCollisionValue();


                void SetRotateBoundaries(irr::core::vector3df min, irr::core::vector3df max);
                
                void SetRotateMinBoundary(irr::core::vector3df min);

                void SetRotateMaxBoundary(irr::core::vector3df max);

                irr::core::vector3df GetRotateMinBoundary();

                irr::core::vector3df GetRotateMaxBoundary();

                irr::u32 GetRotateCollisionValue();

// **** Interpolation Functions ****

                void SetMoveLooping(bool loop);

                bool GetMoveLooping();

                void SetMoveReverseLooping(bool loop);

                bool GetMoveReverseLooping();

                void SetMoveInterpolationTime(irr::u32 time);

                irr::u32 GetMoveInterpolationTime();

                void SetMoveInterpolationValue(irr::f32 value);
                
                irr::f32 GetMoveInterpolationValue();

                void SetMoveStartPoint(irr::core::vector3df start);

                irr::core::vector3df GetMoveStartPoint();

                void SetMoveEndPoint(irr::core::vector3df end);

                irr::core::vector3df GetMoveEndPoint();

                void ReverseMoveInterpolation();

                bool IsMoveInterpolatedReversed();

                void SetRotateLooping(bool loop);

                bool GetRotateLooping();

                void SetRotateReverseLooping(bool loop);

                bool GetRotateReverseLooping();

                void SetRotateInterpolationTime(irr::u32 time);

                irr::u32 GetRotateInterpolationTime();

                void SetRotateInterpolationValue(irr::f32 value);

                irr::f32 GetRotateInterpolationValue();

                void SetRotateStartPoint(irr::core::vector3df start);

                irr::core::vector3df GetRotateStartPoint();

                void SetRotateEndPoint(irr::core::vector3df end);

                irr::core::vector3df GetRotateEndPoint();
                
                void ReverseRotateInterpolation();

                bool IsRotateInterpolatedReversed();

                void SetScaleLooping(bool loop);

                bool GetScaleLooping();

                void SetScaleReverseLooping(bool loop);

                bool GetScaleReverseLooping();

                void SetScaleInterpolationTime(irr::u32 time);

                irr::u32 GetScaleInterpolationTime();

                void SetScaleInterpolationValue(irr::f32 value);

                irr::f32 GetScaleInterpolationValue();

                void SetScaleStartPoint(irr::core::vector3df start);

                irr::core::vector3df GetScaleStartPoint();

                void SetScaleEndPoint(irr::core::vector3df end);

                irr::core::vector3df GetScaleEndPoint();

                void ReverseScaleInterpolation();

                bool IsScaleInterpolatedReversed();

// **** Waypoint Functions ****

                void SetMoveWaypointLooping(bool loop);

                bool GetMoveWaypointLooping();

                void SetMoveWaypointReverseLooping(bool loop);

                bool GetMoveWaypointReverseLooping();

                void ClearMoveWaypoints();

                irr::u32 GetNumMoveWaypoints();




                void AddMoveWaypoint(irr::core::vector3df point, irr::u32 time);

                irr::f32 GetMoveWaypointInterpolationValue();

                void SetScaleWaypointLooping(bool loop);

                bool GetScaleWaypointLooping();

                void SetScaleWaypointReverseLooping(bool loop);

                bool GetScaleWaypointReverseLooping();

                void ClearScaleWaypoints();

                irr::u32 GetNumScaleWaypoints();




                void AddScaleWaypoint(irr::core::vector3df point, irr::u32 time);
                
                irr::f32 GetScaleWaypointInterpolationValue();

                void SetRotateWaypointLooping(bool loop);

                bool GetRotateWaypointLooping();

                void SetRotateWaypointReverseLooping(bool loop);

                bool GetRotateWaypointReverseLooping();

                void ClearRotateWaypoints();

                irr::u32 GetNumRotateWaypoints();




                void AddRotateWaypoint(irr::core::vector3df point, irr::u32 time);

                irr::f32 GetRotateWaypointInterpolationValue();

                void AddChildTask(Task * t);

                void RemoveChildTask(Task * t);

        protected:
                DustyDriver * dustyDriver;

                bool executeMultiple;
                bool removeNodeOnDestroy;

                irr::u32 updateInterval;

                EntityParentTask * parentTask;
                
                EntityActionType currentMoveAction;
                EntityActionType currentScaleAction;
                EntityActionType currentRotateAction;

                MoveTask * moveTask;
                RotateTask * rotateTask;
                ScaleTask * scaleTask;
                MoveInterpolatedTask * moveInterpolatedTask;
                ScaleInterpolatedTask * scaleInterpolatedTask;
                RotateInterpolatedTask * rotateInterpolatedTask;
                MoveBoundedTask * moveBoundedTask;
                ScaleBoundedTask * scaleBoundedTask;
                RotateBoundedTask * rotateBoundedTask;
                WaypointMoveInterpolatedTask * moveWaypointTask;
                WaypointScaleInterpolatedTask * scaleWaypointTask;
                WaypointRotateInterpolatedTask * rotateWaypointTask;
        };
}

#endif

---