ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreStringConverter.h

@@ -0,0 +1,270 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+*/
+
+#ifndef __StringConverter_H__
+#define __StringConverter_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreStringVector.h"
+#include "OgreColourValue.h"
+#include "OgreMath.h"
+#include "OgreMatrix3.h"
+#include "OgreMatrix4.h"
+#include "OgreQuaternion.h"
+#include "OgreVector2.h"
+#include "OgreVector3.h"
+#include "OgreVector4.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup General
+	*  @{
+	*/
+	/** Class for converting the core Ogre data types to/from Strings.
+    @remarks
+        The code for converting values to and from strings is here as a separate
+        class to avoid coupling String to other datatypes (and vice-versa) which reduces
+        compilation dependency: important given how often the core types are used.
+    @par
+        This class is mainly used for parsing settings in text files. External applications
+        can also use it to interface with classes which use the StringInterface template
+        class.
+    @par
+        The String formats of each of the major types is listed with the methods. The basic types
+        like int and Real just use the underlying C runtime library atof and atoi family methods,
+        however custom types like Vector3, ColourValue and Matrix4 are also supported by this class
+        using custom formats.
+    @author
+        Steve Streeting
+    */
+    class _OgreExport StringConverter
+    {
+    public:
+
+        /** Converts a Real to a String. */
+        static String toString(Real val, unsigned short precision = 6, 
+            unsigned short width = 0, char fill = ' ', 
+            std::ios::fmtflags flags = std::ios::fmtflags(0) );
+        /** Converts a Radian to a String. */
+        static String toString(Radian val, unsigned short precision = 6, 
+            unsigned short width = 0, char fill = ' ', 
+            std::ios::fmtflags flags = std::ios::fmtflags(0) )
+        {
+            return toString(val.valueAngleUnits(), precision, width, fill, flags);
+        }
+        /** Converts a Degree to a String. */
+        static String toString(Degree val, unsigned short precision = 6, 
+            unsigned short width = 0, char fill = ' ', 
+            std::ios::fmtflags flags = std::ios::fmtflags(0) )
+        {
+            return toString(val.valueAngleUnits(), precision, width, fill, flags);
+        }
+        /** Converts an int to a String. */
+        static String toString(int val, unsigned short width = 0, 
+            char fill = ' ', 
+            std::ios::fmtflags flags = std::ios::fmtflags(0) );
+#if OGRE_PLATFORM != OGRE_PLATFORM_NACL &&  ( OGRE_ARCH_TYPE == OGRE_ARCHITECTURE_64 || OGRE_PLATFORM == OGRE_PLATFORM_APPLE || OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS )
+        /** Converts an unsigned int to a String. */
+        static String toString(unsigned int val, 
+            unsigned short width = 0, char fill = ' ', 
+            std::ios::fmtflags flags = std::ios::fmtflags(0) );
+        /** Converts a size_t to a String. */
+        static String toString(size_t val, 
+            unsigned short width = 0, char fill = ' ', 
+            std::ios::fmtflags flags = std::ios::fmtflags(0) );
+        #if OGRE_COMPILER == OGRE_COMPILER_MSVC
+                /** Converts an unsigned long to a String. */
+                static String toString(unsigned long val, 
+                    unsigned short width = 0, char fill = ' ', 
+                    std::ios::fmtflags flags = std::ios::fmtflags(0) );
+
+        #endif
+#else
+        /** Converts a size_t to a String. */
+        static String toString(size_t val, 
+            unsigned short width = 0, char fill = ' ', 
+            std::ios::fmtflags flags = std::ios::fmtflags(0) );
+        /** Converts an unsigned long to a String. */
+        static String toString(unsigned long val, 
+            unsigned short width = 0, char fill = ' ', 
+            std::ios::fmtflags flags = std::ios::fmtflags(0) );
+#endif
+        /** Converts a long to a String. */
+        static String toString(long val, 
+            unsigned short width = 0, char fill = ' ', 
+            std::ios::fmtflags flags = std::ios::fmtflags(0) );
+        /** Converts a boolean to a String. 
+        @param yesNo If set to true, result is 'yes' or 'no' instead of 'true' or 'false'
+        */
+        static String toString(bool val, bool yesNo = false);
+		/** Converts a Vector2 to a String. 
+        @remarks
+            Format is "x y" (i.e. 2x Real values, space delimited)
+        */
+        static String toString(const Vector2& val);
+        /** Converts a Vector3 to a String. 
+        @remarks
+            Format is "x y z" (i.e. 3x Real values, space delimited)
+        */
+        static String toString(const Vector3& val);
+		/** Converts a Vector4 to a String. 
+        @remarks
+            Format is "x y z w" (i.e. 4x Real values, space delimited)
+        */
+        static String toString(const Vector4& val);
+        /** Converts a Matrix3 to a String. 
+        @remarks
+            Format is "00 01 02 10 11 12 20 21 22" where '01' means row 0 column 1 etc.
+        */
+        static String toString(const Matrix3& val);
+        /** Converts a Matrix4 to a String. 
+        @remarks
+            Format is "00 01 02 03 10 11 12 13 20 21 22 23 30 31 32 33" where 
+            '01' means row 0 column 1 etc.
+        */
+        static String toString(const Matrix4& val);
+        /** Converts a Quaternion to a String. 
+        @remarks
+            Format is "w x y z" (i.e. 4x Real values, space delimited)
+        */
+        static String toString(const Quaternion& val);
+        /** Converts a ColourValue to a String. 
+        @remarks
+            Format is "r g b a" (i.e. 4x Real values, space delimited). 
+        */
+        static String toString(const ColourValue& val);
+        /** Converts a StringVector to a string.
+        @remarks
+            Strings must not contain spaces since space is used as a delimiter in
+            the output.
+        */
+        static String toString(const StringVector& val);
+
+        /** Converts a String to a Real. 
+        @return
+            0.0 if the value could not be parsed, otherwise the Real version of the String.
+        */
+        static Real parseReal(const String& val, Real defaultValue = 0);
+        /** Converts a String to a Angle. 
+        @return
+            0.0 if the value could not be parsed, otherwise the Angle version of the String.
+        */
+        static inline Radian parseAngle(const String& val, Radian defaultValue = Radian(0)) {
+			return Angle(parseReal(val, defaultValue.valueRadians()));
+		}
+        /** Converts a String to a whole number. 
+        @return
+            0.0 if the value could not be parsed, otherwise the numeric version of the String.
+        */
+        static int parseInt(const String& val, int defaultValue = 0);
+        /** Converts a String to a whole number. 
+        @return
+            0.0 if the value could not be parsed, otherwise the numeric version of the String.
+        */
+        static unsigned int parseUnsignedInt(const String& val, unsigned int defaultValue = 0);
+        /** Converts a String to a whole number. 
+        @return
+            0.0 if the value could not be parsed, otherwise the numeric version of the String.
+        */
+        static long parseLong(const String& val, long defaultValue = 0);
+        /** Converts a String to a whole number. 
+        @return
+            0.0 if the value could not be parsed, otherwise the numeric version of the String.
+        */
+        static unsigned long parseUnsignedLong(const String& val, unsigned long defaultValue = 0);
+        /** Converts a String to a boolean. 
+        @remarks
+            Returns true if case-insensitive match of the start of the string
+			matches "true", "yes" or "1", false otherwise.
+        */
+        static bool parseBool(const String& val, bool defaultValue = 0);
+		/** Parses a Vector2 out of a String.
+        @remarks
+            Format is "x y" ie. 2 Real components, space delimited. Failure to parse returns
+            Vector2::ZERO.
+        */
+		static Vector2 parseVector2(const String& val, const Vector2& defaultValue = Vector2::ZERO);
+		/** Parses a Vector3 out of a String.
+        @remarks
+            Format is "x y z" ie. 3 Real components, space delimited. Failure to parse returns
+            Vector3::ZERO.
+        */
+        static Vector3 parseVector3(const String& val, const Vector3& defaultValue = Vector3::ZERO);
+        /** Parses a Vector4 out of a String.
+        @remarks
+            Format is "x y z w" ie. 4 Real components, space delimited. Failure to parse returns
+            Vector4::ZERO.
+        */
+        static Vector4 parseVector4(const String& val, const Vector4& defaultValue = Vector4::ZERO);
+        /** Parses a Matrix3 out of a String.
+        @remarks
+            Format is "00 01 02 10 11 12 20 21 22" where '01' means row 0 column 1 etc.
+            Failure to parse returns Matrix3::IDENTITY.
+        */
+        static Matrix3 parseMatrix3(const String& val, const Matrix3& defaultValue = Matrix3::IDENTITY);
+        /** Parses a Matrix4 out of a String.
+        @remarks
+            Format is "00 01 02 03 10 11 12 13 20 21 22 23 30 31 32 33" where 
+            '01' means row 0 column 1 etc. Failure to parse returns Matrix4::IDENTITY.
+        */
+        static Matrix4 parseMatrix4(const String& val, const Matrix4& defaultValue = Matrix4::IDENTITY);
+        /** Parses a Quaternion out of a String. 
+        @remarks
+            Format is "w x y z" (i.e. 4x Real values, space delimited). 
+            Failure to parse returns Quaternion::IDENTITY.
+        */
+        static Quaternion parseQuaternion(const String& val, const Quaternion& defaultValue = Quaternion::IDENTITY);
+        /** Parses a ColourValue out of a String. 
+        @remarks
+            Format is "r g b a" (i.e. 4x Real values, space delimited), or "r g b" which implies
+            an alpha value of 1.0 (opaque). Failure to parse returns ColourValue::Black.
+        */
+        static ColourValue parseColourValue(const String& val, const ColourValue& defaultValue = ColourValue::Black);
+
+        /** Pareses a StringVector from a string.
+        @remarks
+            Strings must not contain spaces since space is used as a delimiter in
+            the output.
+        */
+        static StringVector parseStringVector(const String& val);
+        /** Checks the String is a valid number value. */
+        static bool isNumber(const String& val);
+    };
+
+	/** @} */
+	/** @} */
+
+}
+
+
+
+#endif
+

data/deps/include/OGRE/OgreStringInterface.h

@@ -0,0 +1,335 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+*/
+
+#ifndef __StringInterface_H__
+#define __StringInterface_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreString.h"
+#include "OgreCommon.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup General
+	*  @{
+	*/
+
+    /// List of parameter types available
+    enum ParameterType
+    {
+        PT_BOOL,
+        PT_REAL,
+        PT_INT,
+        PT_UNSIGNED_INT,
+        PT_SHORT,
+        PT_UNSIGNED_SHORT,
+        PT_LONG,
+        PT_UNSIGNED_LONG,
+        PT_STRING,
+        PT_VECTOR3,
+        PT_MATRIX3,
+        PT_MATRIX4,
+        PT_QUATERNION,
+        PT_COLOURVALUE
+    };
+
+    /// Definition of a parameter supported by a StringInterface class, for introspection
+    class _OgreExport ParameterDef
+    {
+    public:
+        String name;
+        String description;
+        ParameterType paramType;
+        ParameterDef(const String& newName, const String& newDescription, ParameterType newType)
+            : name(newName), description(newDescription), paramType(newType) {}
+    };
+    typedef vector<ParameterDef>::type ParameterList;
+
+    /** Abstract class which is command object which gets/sets parameters.*/
+    class _OgreExport ParamCommand
+    {
+    public:
+        virtual String doGet(const void* target) const = 0;
+        virtual void doSet(void* target, const String& val) = 0;
+
+        virtual ~ParamCommand() { }
+    };
+    typedef map<String, ParamCommand* >::type ParamCommandMap;
+
+    /** Class to hold a dictionary of parameters for a single class. */
+    class _OgreExport ParamDictionary
+    {
+        friend class StringInterface;
+    protected:
+        /// Definitions of parameters
+        ParameterList mParamDefs;
+
+        /// Command objects to get/set
+        ParamCommandMap mParamCommands;
+
+        /** Retrieves the parameter command object for a named parameter. */
+        ParamCommand* getParamCommand(const String& name)
+        {
+            ParamCommandMap::iterator i = mParamCommands.find(name);
+            if (i != mParamCommands.end())
+            {
+                return i->second;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+
+		const ParamCommand* getParamCommand(const String& name) const
+        {
+            ParamCommandMap::const_iterator i = mParamCommands.find(name);
+            if (i != mParamCommands.end())
+            {
+                return i->second;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+    public:
+        ParamDictionary()  {}
+        /** Method for adding a parameter definition for this class. 
+        @param paramDef A ParameterDef object defining the parameter
+        @param paramCmd Pointer to a ParamCommand subclass to handle the getting / setting of this parameter.
+            NB this class will not destroy this on shutdown, please ensure you do
+
+        */
+        void addParameter(const ParameterDef& paramDef, ParamCommand* paramCmd)
+        {
+            mParamDefs.push_back(paramDef);
+            mParamCommands[paramDef.name] = paramCmd;
+        }
+        /** Retrieves a list of parameters valid for this object. 
+        @return
+            A reference to a static list of ParameterDef objects.
+
+        */
+        const ParameterList& getParameters(void) const
+        {
+            return mParamDefs;
+        }
+
+
+
+    };
+    typedef map<String, ParamDictionary>::type ParamDictionaryMap;
+    
+    /** Class defining the common interface which classes can use to 
+        present a reflection-style, self-defining parameter set to callers.
+    @remarks
+        This class also holds a static map of class name to parameter dictionaries
+        for each subclass to use. See ParamDictionary for details. 
+    @remarks
+        In order to use this class, each subclass must call createParamDictionary in their constructors
+        which will create a parameter dictionary for the class if it does not exist yet.
+    */
+    class _OgreExport StringInterface 
+    {
+    private:
+		OGRE_STATIC_MUTEX( msDictionaryMutex )
+
+        /// Dictionary of parameters
+        static ParamDictionaryMap msDictionary;
+
+        /// Class name for this instance to be used as a lookup (must be initialised by subclasses)
+        String mParamDictName;
+		ParamDictionary* mParamDict;
+
+	protected:
+        /** Internal method for creating a parameter dictionary for the class, if it does not already exist.
+        @remarks
+            This method will check to see if a parameter dictionary exist for this class yet,
+            and if not will create one. NB you must supply the name of the class (RTTI is not 
+            used or performance).
+        @param
+            className the name of the class using the dictionary
+        @return
+            true if a new dictionary was created, false if it was already there
+        */
+        bool createParamDictionary(const String& className)
+        {
+			OGRE_LOCK_MUTEX( msDictionaryMutex )
+
+			ParamDictionaryMap::iterator it = msDictionary.find(className);
+
+			if ( it == msDictionary.end() )
+			{
+				mParamDict = &msDictionary.insert( std::make_pair( className, ParamDictionary() ) ).first->second;
+				mParamDictName = className;
+				return true;
+			}
+			else
+			{
+				mParamDict = &it->second;
+				mParamDictName = className;
+				return false;
+			}
+        }
+
+    public:
+		StringInterface() : mParamDict(NULL) { }
+
+        /** Virtual destructor, see Effective C++ */
+        virtual ~StringInterface() {}
+
+        /** Retrieves the parameter dictionary for this class. 
+        @remarks
+            Only valid to call this after createParamDictionary.
+        @return
+            Pointer to ParamDictionary shared by all instances of this class
+            which you can add parameters to, retrieve parameters etc.
+        */
+        ParamDictionary* getParamDictionary(void)
+        {
+			return mParamDict;
+        }
+
+		const ParamDictionary* getParamDictionary(void) const
+        {
+			return mParamDict;
+        }
+
+        /** Retrieves a list of parameters valid for this object. 
+        @return
+            A reference to a static list of ParameterDef objects.
+
+        */
+        const ParameterList& getParameters(void) const;
+
+        /** Generic parameter setting method.
+        @remarks
+            Call this method with the name of a parameter and a string version of the value
+            to set. The implementor will convert the string to a native type internally.
+            If in doubt, check the parameter definition in the list returned from 
+            StringInterface::getParameters.
+        @param
+            name The name of the parameter to set
+        @param
+            value String value. Must be in the right format for the type specified in the parameter definition.
+            See the StringConverter class for more information.
+        @return
+            true if set was successful, false otherwise (NB no exceptions thrown - tolerant method)
+        */
+        virtual bool setParameter(const String& name, const String& value);
+        /** Generic multiple parameter setting method.
+        @remarks
+            Call this method with a list of name / value pairs
+            to set. The implementor will convert the string to a native type internally.
+            If in doubt, check the parameter definition in the list returned from 
+            StringInterface::getParameters.
+        @param
+            paramList Name/value pair list
+        */
+        virtual void setParameterList(const NameValuePairList& paramList);
+        /** Generic parameter retrieval method.
+        @remarks
+            Call this method with the name of a parameter to retrieve a string-format value of
+            the parameter in question. If in doubt, check the parameter definition in the
+            list returned from getParameters for the type of this parameter. If you
+            like you can use StringConverter to convert this string back into a native type.
+        @param
+            name The name of the parameter to get
+        @return
+            String value of parameter, blank if not found
+        */
+        virtual String getParameter(const String& name) const
+        {
+            // Get dictionary
+            const ParamDictionary* dict = getParamDictionary();
+
+            if (dict)
+            {
+                // Look up command object
+                const ParamCommand* cmd = dict->getParamCommand(name);
+
+                if (cmd)
+                {
+                    return cmd->doGet(this);
+                }
+            }
+
+            // Fallback
+            return "";
+        }
+        /** Method for copying this object's parameters to another object.
+        @remarks
+            This method takes the values of all the object's parameters and tries to set the
+            same values on the destination object. This provides a completely type independent
+            way to copy parameters to other objects. Note that because of the String manipulation 
+            involved, this should not be regarded as an efficient process and should be saved for
+            times outside of the rendering loop.
+        @par
+            Any unrecognised parameters will be ignored as with setParameter method.
+        @param dest Pointer to object to have it's parameters set the same as this object.
+
+        */
+        virtual void copyParametersTo(StringInterface* dest) const
+        {
+            // Get dictionary
+            const ParamDictionary* dict = getParamDictionary();
+
+            if (dict)
+            {
+                // Iterate through own parameters
+                ParameterList::const_iterator i;
+            
+                for (i = dict->mParamDefs.begin(); 
+                i != dict->mParamDefs.end(); ++i)
+                {
+                    dest->setParameter(i->name, getParameter(i->name));
+                }
+            }
+
+
+        }
+
+        /** Cleans up the static 'msDictionary' required to reset Ogre,
+        otherwise the containers are left with invalid pointers, which will lead to a crash
+        as soon as one of the ResourceManager implementers (e.g. MaterialManager) initializes.*/
+        static void cleanupDictionary () ;
+
+    };
+
+	/** @} */
+	/** @} */
+
+
+}
+
+#endif
+

data/deps/include/OGRE/OgreStringVector.h

@@ -0,0 +1,53 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+*/
+#ifndef _StringVector_H__
+#define _StringVector_H__
+
+#include "OgrePrerequisites.h"
+
+#include "OgreString.h"
+#include "OgreSharedPtr.h"
+
+
+namespace Ogre {
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup General
+	*  @{
+	*/
+
+    typedef vector<String>::type StringVector;
+    typedef SharedPtr<StringVector> StringVectorPtr;
+
+	/** @} */
+	/** @} */
+
+}
+
+#endif