OgreAnimable.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part 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 __ANIMABLE_H__
#define __ANIMABLE_H__

#include "OgrePrerequisites.h"
#include "OgreVector2.h"
#include "OgreVector3.h"
#include "OgreVector4.h"
#include "OgreQuaternion.h"
#include "OgreColourValue.h"
#include "OgreSharedPtr.h"
#include "OgreStringVector.h"
#include "OgreException.h"
#include "OgreAny.h"

namespace Ogre {

    class _OgreExport AnimableValue
    {
    public:
        enum ValueType
        {
            INT,
            REAL,
            VECTOR2,
            VECTOR3,
            VECTOR4,
            QUATERNION,
            COLOUR
        };
    protected:
        ValueType mType;

        union
        {
            int mBaseValueInt;
            Real mBaseValueReal[4];
        };

        virtual void setAsBaseValue(int val) { mBaseValueInt = val; }
        virtual void setAsBaseValue(Real val) { mBaseValueReal[0] = val; }
        virtual void setAsBaseValue(const Vector2& val) 
        { memcpy(mBaseValueReal, val.val, sizeof(Real)*2); }
        virtual void setAsBaseValue(const Vector3& val) 
        { memcpy(mBaseValueReal, val.val, sizeof(Real)*3); }
        virtual void setAsBaseValue(const Vector4& val) 
        { memcpy(mBaseValueReal, val.val, sizeof(Real)*4); }
        virtual void setAsBaseValue(const Quaternion& val) 
        { memcpy(mBaseValueReal, val.val, sizeof(Real)*4); }
        virtual void setAsBaseValue(const Any& val);
        virtual void setAsBaseValue(const ColourValue& val)
        { 
            mBaseValueReal[0] = val.r;
            mBaseValueReal[1] = val.g;
            mBaseValueReal[2] = val.b;
            mBaseValueReal[3] = val.a;
        }


    public:
        AnimableValue(ValueType t) : mType(t) {}
        virtual ~AnimableValue() {}

        ValueType getType(void) const { return mType; }

        virtual void setCurrentStateAsBaseValue(void) = 0;

        virtual void setValue(int val) {
            OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "", "");
        }
        virtual void setValue(Real val) {
            OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "", "");
        }
        virtual void setValue(const Vector2& val) {
            OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "", "");
        }
        virtual void setValue(const Vector3& val) {
            OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "", "");
        }
        virtual void setValue(const Vector4& val) {
            OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "", "");
        }
        virtual void setValue(const Quaternion& val) {
            OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "", "");
        }
        virtual void setValue(const ColourValue& val) {
            OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "", "");
        }
        virtual void setValue(const Any& val);

        // reset to base value
        virtual void resetToBaseValue(void);

        virtual void applyDeltaValue(int val) {
            OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "", "");
        }
        virtual void applyDeltaValue(Real val) {
            OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "", "");
        }
        virtual void applyDeltaValue(const Vector2& val) {
            OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "", "");
        }
        virtual void applyDeltaValue(const Vector3& val) {
            OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "", "");
        }
        virtual void applyDeltaValue(const Vector4& val) {
            OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "", "");
        }
        virtual void applyDeltaValue(const Quaternion& val) {
            OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "", "");
        }
        virtual void applyDeltaValue(const ColourValue& val) {
            OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "", "");
        }
        virtual void applyDeltaValue(const Any& val);


    };

    typedef SharedPtr<AnimableValue> AnimableValuePtr;



    class _OgreExport AnimableObject
    {
    protected:
        typedef std::map<String, StringVector> AnimableDictionaryMap;
        static AnimableDictionaryMap msAnimableDictionary;
        virtual const String& getAnimableDictionaryName(void) const 
        { return StringUtil::BLANK; }
        void createAnimableDictionary(void) const
        {
            if (msAnimableDictionary.find(getAnimableDictionaryName()) 
                == msAnimableDictionary.end())
            {
                StringVector vec;
                initialiseAnimableDictionary(vec);
                msAnimableDictionary[getAnimableDictionaryName()] = vec;
            }

        }
    
        StringVector& getAnimableValueNames(void)
        {
            AnimableDictionaryMap::iterator i = 
                msAnimableDictionary.find(getAnimableDictionaryName());
            if (i != msAnimableDictionary.end())
            {
                return i->second;
            }
            else
            {
                OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, 
                    "Animable value list not found for " + getAnimableDictionaryName(), 
                    "AnimableObject::getAnimableValueNames");
            }

        }

        virtual void initialiseAnimableDictionary(StringVector& vec) const {}


    public:
        AnimableObject() {}
        virtual ~AnimableObject() {}

        const StringVector& getAnimableValueNames(void) const
        {
            createAnimableDictionary();

            AnimableDictionaryMap::iterator i = 
                msAnimableDictionary.find(getAnimableDictionaryName());
            if (i != msAnimableDictionary.end())
            {
                return i->second;
            }
            else
            {
                OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, 
                    "Animable value list not found for " + getAnimableDictionaryName(), 
                    "AnimableObject::getAnimableValueNames");
            }

        }

        virtual AnimableValuePtr createAnimableValue(const String& valueName)
        {
            OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, 
                "No animable value named '" + valueName + "' present.", 
                "AnimableObject::createAnimableValue");
        }



    };


}
#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:36 2006