shattered_ogrerb 0.5.0.1

data/vendor/ogrerb/src_headers/OGRE/OgrePlugin.h

@@ -0,0 +1,132 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+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.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+#ifndef __OGREPLUGIN_H__
+#define __OGREPLUGIN_H__
+
+#include "OgrePrerequisites.h"
+
+namespace Ogre
+{
+	/** Class defining a generic OGRE plugin.
+	@remarks
+		OGRE is very plugin-oriented and you can customise much of its behaviour
+		by registering new plugins, dynamically if you are using dynamic linking.
+		This class abstracts the generic interface that all plugins must support.
+		Within the implementations of this interface, the plugin must call other
+		OGRE classes in order to register the detailed customisations it is
+		providing, e.g. registering a new SceneManagerFactory, a new
+		MovableObjectFactory, or a new RenderSystem.
+	@par
+		Plugins can be linked statically or dynamically. If they are linked
+		dynamically (ie the plugin is in a DLL or Shared Object file), then you
+		load the plugin by calling the Root::loadPlugin method (or some other
+		mechanism which leads to that call, e.g. plugins.cfg), passing the name of
+		the DLL. OGRE will then call a global init function on that DLL, and it
+		will be expected to register one or more Plugin implementations using
+		Root::installPlugin. The procedure is very similar if you use a static
+		linked plugin, except that you simply instantiate the Plugin implementation
+		yourself and pass it to Root::installPlugin.
+	@note
+		Lifecycle of a Plugin instance is very important. The Plugin instance must
+		remain valid until the Plugin is uninstalled. Here are the things you
+		must bear in  mind:
+		<ul><li>If your plugin is in a DLL:
+		<ul><li>Create the Plugin instance and call Root::installPlugin in dllStartPlugin</li>
+		<li>Call Root::uninstallPlugin, then delete it in dllStopPlugin</li></ul>
+		<li>If your plugin is statically linked in your app:
+		<ul><li>Create the Plugin anytime you like</li>
+		<li>Call Root::installPlugin any time whilst Root is valid</li>
+		<li>Call Root::uninstallPlugin if you like so long as Root is valid. However,
+			it will be done for you when Root is destroyed, so the Plugin instance must
+			still be valid at that point if you haven't manually uninstalled it.</li></ul>
+		</ul>
+		The install and unninstall methods will be called when the plugin is
+		installed or uninstalled. The initialise and shutdown will be called when
+		there is a system initialisation or shutdown, e.g. when Root::initialise 
+		or Root::shutdown are called.
+	*/
+	class _OgreExport Plugin
+	{
+	public:
+		Plugin() {}
+		virtual ~Plugin() {}
+
+		/** Get the name of the plugin. 
+		@remarks An implementation must be supplied for this method to uniquely
+			identify the plugin.
+		*/
+		virtual const String& getName() const = 0;
+
+		/** Perform the plugin initial installation sequence. 
+		@remarks An implementation must be supplied for this method. It must perform
+		the startup tasks necessary to install any rendersystem customisations 
+		or anything else that is not dependent on system initialisation, ie
+		only dependent on the core of Ogre. It must not perform any
+		operations that would create rendersystem-specific objects at this stage,
+		that should be done in initialise().
+		*/
+		virtual void install() = 0;
+
+		/** Perform any tasks the plugin needs to perform on full system
+			initialisation.
+		@remarks An implementation must be supplied for this method. It is called 
+			just after the system is fully initialised (either after Root::initialise
+			if a window is created then, or after the frist window is created)
+			and therefore all rendersystem functionality is available at this
+			time. You can use this hook to create any resources which are 
+			dependent on a rendersystem or have rendersystem-specific implementations.
+		*/
+		virtual void initialise() = 0;
+
+		/** Perform any tasks the plugin needs to perform when the system is shut down.
+		@remarks An implementation must be supplied for this method.
+		This method is called just before key parts of the system are unloaded, 
+		such as rendersystems being shut down. You should use this hook to free up 
+		resources and decouple custom objects from the OGRE system, whilst all the
+		instances of other plugins (e.g. rendersystems) still exist.
+		*/
+		virtual void shutdown() = 0;
+
+		/** Perform the final plugin uninstallation sequence. 
+		@remarks An implementation must be supplied for this method. It must perform
+		the cleanup tasks which haven't already been performed in shutdown()
+		(e.g. final deletion of custom instances, if you kept them around incase
+		the system was reinitialised). At this stage you cannot be sure what other
+		plugins are still loaded or active. It must therefore not perform any
+		operations that would reference any rendersystem-specific objects - those
+		should have been sorted out in the 'shutdown' method.
+		*/
+		virtual void uninstall() = 0;
+	};
+
+}
+
+#endif
+
+

data/vendor/ogrerb/src_headers/OGRE/OgrePolygon.h

@@ -0,0 +1,130 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+Copyright (c) 2006 Matthias Fink, netAllied GmbH <matthias.fink@web.de>								
+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.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+#ifndef __Polygon_H__
+#define __Polygon_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreVector3.h"
+
+
+namespace Ogre
+{
+
+
+	/** The class represents a polygon in 3D space.
+	@remarks
+		It is made up of 3 or more vertices in a single plane, listed in 
+		counter-clockwise order.
+	*/
+	class _OgreExport Polygon
+	{
+
+	public:
+		typedef std::vector<Vector3>				VertexList;
+
+		typedef std::multimap<Vector3, Vector3>		EdgeMap;
+		typedef std::pair< Vector3, Vector3>		Edge;
+
+	protected:
+		VertexList		mVertexList;
+		Vector3			mNormal;
+		bool			mIsNormalSet;
+		/** Updates the normal.
+		*/
+		void updateNormal(void);
+
+
+	public:
+		Polygon();
+		~Polygon();
+		Polygon( const Polygon& cpy );
+
+		/** Inserts a vertex at a specific position.
+		@note Vertices must be coplanar.
+		*/
+		void insertVertex(const Vector3& vdata, size_t vertexIndex);
+		/** Inserts a vertex at the end of the polygon.
+		@note Vertices must be coplanar.
+		*/
+		void insertVertex(const Vector3& vdata);
+
+		/** Returns a vertex.
+		*/
+		const Vector3& getVertex(size_t vertex) const;
+
+		/** Sets a specific vertex of a polygon.
+		@note Vertices must be coplanar.
+		*/
+		void setVertex(const Vector3& vdata, size_t vertexIndex);
+
+		/** Removes duplicate vertices from a polygon.
+		*/
+		void removeDuplicates(void);
+
+		/** Vertex count.
+		*/
+		size_t getVertexCount(void) const;
+
+		/** Returns the polygon normal.
+		*/
+		const Vector3& getNormal(void);
+
+		/** Deletes a specific vertex.
+		*/
+		void deleteVertex(size_t vertex);
+
+		/** Stores the edges of the polygon in ccw order.
+			The vertices are copied so the user has to take the 
+			deletion into account.
+		*/
+		void storeEdges(EdgeMap *edgeMap) const;
+
+		/** Resets the object.
+		*/
+		void reset(void);
+
+		/** Determines if the current object is equal to the compared one.
+		*/
+		bool operator == (const Polygon& rhs) const;
+
+		/** Determines if the current object is not equal to the compared one.
+		*/
+		bool operator != (const Polygon& rhs) const
+		{ return !( *this == rhs ); }
+
+		/** Prints out the polygon data.
+		*/
+		_OgreExport friend std::ostream& operator<< ( std::ostream& strm, const Polygon& poly );
+
+	};
+
+}
+
+#endif

data/vendor/ogrerb/src_headers/OGRE/OgrePose.h

@@ -0,0 +1,111 @@
+/*
+-----------------------------------------------------------------------------
+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.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+#ifndef __OGRE_POSE_H
+#define __OGRE_POSE_H
+
+#include "OgrePrerequisites.h"
+#include "OgreString.h"
+#include "OgreHardwareVertexBuffer.h"
+#include "OgreVector3.h"
+#include "OgreIteratorWrappers.h"
+
+namespace Ogre {
+
+	/** A pose is a linked set of vertex offsets applying to one set of vertex
+		data. 
+	@remarks
+		The target index referred to by the pose has a meaning set by the user
+		of this class; but for example when used by Mesh it refers to either the
+		Mesh shared geometry (0) or a SubMesh dedicated geometry (1+).
+		Pose instances can be referred to by keyframes in VertexAnimationTrack in
+		order to animate based on blending poses together.
+	*/
+	class _OgreExport Pose
+	{
+	public:
+		/** Constructor
+			@param target The target vertexdata index (0 for shared, 1+ for 
+				dedicated at the submesh index + 1)
+			@param name Optional name
+		*/
+		Pose(ushort target, const String& name = StringUtil::BLANK);
+		virtual ~Pose();
+		/// Return the name of the pose (may be blank)
+		const String& getName(void) const { return mName; }
+		/// Return the target geometry index of the pose
+		ushort getTarget(void) const { return mTarget; }
+		/// A collection of vertex offsets based on the vertex index
+		typedef std::map<size_t, Vector3> VertexOffsetMap;
+		/// An iterator over the vertex offsets
+		typedef MapIterator<VertexOffsetMap> VertexOffsetIterator;
+		/// An iterator over the vertex offsets
+		typedef ConstMapIterator<VertexOffsetMap> ConstVertexOffsetIterator;
+
+		/** Adds an offset to a vertex for this pose. 
+		@param index The vertex index
+		@param offset The position offset for this pose
+		*/
+		void addVertex(size_t index, const Vector3& offset);
+
+		/** Remove a vertex offset. */
+		void removeVertex(size_t index);
+
+		/** Clear all vertex offsets. */
+		void clearVertexOffsets(void);
+
+		/** Gets an iterator over all the vertex offsets. */
+		ConstVertexOffsetIterator getVertexOffsetIterator(void) const;
+		/** Gets an iterator over all the vertex offsets. */
+		VertexOffsetIterator getVertexOffsetIterator(void);
+		/** Gets a const reference to the vertex offsets. */
+		const VertexOffsetMap& getVertexOffsets(void) const { return mVertexOffsetMap; }
+
+		/** Get a hardware vertex buffer version of the vertex offsets. */
+		const HardwareVertexBufferSharedPtr& _getHardwareVertexBuffer(size_t numVertices) const;
+
+		/** Clone this pose and create another one configured exactly the same
+			way (only really useful for cloning holders of this class).
+		*/
+		Pose* clone(void) const;
+	protected:
+		/// Target geometry index
+		ushort mTarget;
+		/// Optional name
+		String mName;
+		/// Primary storage, sparse vertex use
+		VertexOffsetMap mVertexOffsetMap;
+		/// Derived hardware buffer, covers all vertices
+		mutable HardwareVertexBufferSharedPtr mBuffer;
+	};
+	typedef std::vector<Pose*> PoseList;
+
+
+}
+
+#endif

data/vendor/ogrerb/src_headers/OGRE/OgrePredefinedControllers.h

@@ -0,0 +1,285 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+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.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+#ifndef __PredefinedControllers_H__
+#define __PredefinedControllers_H__
+
+#include "OgrePrerequisites.h"
+
+#include "OgreCommon.h"
+#include "OgreController.h"
+#include "OgreFrameListener.h"
+#include "OgreGpuProgram.h"
+
+namespace Ogre {
+
+    //-----------------------------------------------------------------------
+    // Controller Values
+    //-----------------------------------------------------------------------
+    /** Predefined controller value for getting the latest frame time.
+    */
+    class _OgreExport FrameTimeControllerValue : public ControllerValue<Real>, public FrameListener
+    {
+    protected:
+        Real mFrameTime;
+		Real mTimeFactor;
+		Real mElapsedTime;
+		Real mFrameDelay;
+
+    public:
+        FrameTimeControllerValue();
+        bool frameEnded(const FrameEvent &evt);
+        bool frameStarted(const FrameEvent &evt);
+        Real getValue(void) const;
+        void setValue(Real value);
+		Real getTimeFactor(void) const;
+		void setTimeFactor(Real tf);
+		Real getFrameDelay(void) const;
+		void setFrameDelay(Real fd);
+		Real getElapsedTime(void) const;
+		void setElapsedTime(Real elapsedTime);
+    };
+
+    //-----------------------------------------------------------------------
+    /** Predefined controller value for getting / setting the frame number of a texture layer
+    */
+    class _OgreExport TextureFrameControllerValue : public ControllerValue<Real>
+    {
+    protected:
+        TextureUnitState* mTextureLayer;
+    public:
+        TextureFrameControllerValue(TextureUnitState* t);
+
+        /** Gets the frame number as a parametric value in the range [0,1]
+        */
+        Real getValue(void) const;
+        /** Sets the frame number as a parametric value in the range [0,1]; the actual frame number is value * (numFrames-1).
+        */
+        void setValue(Real value);
+
+    };
+    //-----------------------------------------------------------------------
+    /** Predefined controller value for getting / setting a texture coordinate modifications (scales and translates).
+        @remarks
+            Effects can be applied to the scale or the offset of the u or v coordinates, or both. If separate
+            modifications are required to u and v then 2 instances are required to control both independently, or 4
+            if you ant separate u and v scales as well as separate u and v offsets.
+        @par
+            Because of the nature of this value, it can accept values outside the 0..1 parametric range.
+    */
+    class _OgreExport TexCoordModifierControllerValue : public ControllerValue<Real>
+    {
+    protected:
+        bool mTransU, mTransV;
+        bool mScaleU, mScaleV;
+        bool mRotate;
+        TextureUnitState* mTextureLayer;
+    public:
+        /** Constructor.
+            @param
+                t TextureUnitState to apply the modification to.
+            @param
+                translateU If true, the u coordinates will be translated by the modification.
+            @param
+                translateV If true, the v coordinates will be translated by the modification.
+            @param
+                scaleU If true, the u coordinates will be scaled by the modification.
+            @param
+                scaleV If true, the v coordinates will be scaled by the modification.
+            @param
+                rotate If true, the texture will be rotated by the modification.
+        */
+        TexCoordModifierControllerValue(TextureUnitState* t, bool translateU = false, bool translateV = false,
+            bool scaleU = false, bool scaleV = false, bool rotate = false );
+
+        Real getValue(void) const;
+        void setValue(Real value);
+
+    };
+
+    //-----------------------------------------------------------------------
+    /** Predefined controller value for setting a single floating-
+	    point value in a constant paramter of a vertex or fragment program.
+    @remarks
+		Any value is accepted, it is propagated into the 'x'
+		component of the constant register identified by the index. If you
+		need to use named parameters, retrieve the index from the param
+		object before setting this controller up.
+	@note
+		Retrieving a value from the program parameters is not currently 
+		supported, therefore do not use this controller value as a source,
+		only as a target.
+    */
+    class _OgreExport FloatGpuParameterControllerValue : public ControllerValue<Real>
+    {
+    protected:
+		/// The parameters to access
+		GpuProgramParameters* mParams;
+		/// The index of the parameter to e read or set
+		size_t mParamIndex;
+    public:
+        /** Constructor.
+		    @param
+				params The parameters object to access
+            @param
+                index The index of the parameter to be set
+        */
+        FloatGpuParameterControllerValue(GpuProgramParameters* params,
+				size_t index );
+
+        ~FloatGpuParameterControllerValue() {}
+
+        Real getValue(void) const;
+        void setValue(Real value);
+
+    };
+    //-----------------------------------------------------------------------
+    // Controller functions
+    //-----------------------------------------------------------------------
+
+	/** Predefined controller function which just passes through the original source
+	directly to dest.
+	*/
+	class _OgreExport PassthroughControllerFunction : public ControllerFunction<Real>
+	{
+	public:
+		/** Constructor.
+		@param
+		sequenceTime The amount of time in seconds it takes to loop through the whole animation sequence.
+		@param
+		timeOffset The offset in seconds at which to start (default is start at 0)
+		*/
+		PassthroughControllerFunction(bool deltaInput = false);
+
+		/** Overriden function.
+		*/
+		Real calculate(Real source);
+	};
+
+	/** Predefined controller function for dealing with animation.
+    */
+    class _OgreExport AnimationControllerFunction : public ControllerFunction<Real>
+    {
+    protected:
+        Real mSeqTime;
+        Real mTime;
+    public:
+        /** Constructor.
+            @param
+                sequenceTime The amount of time in seconds it takes to loop through the whole animation sequence.
+            @param
+                timeOffset The offset in seconds at which to start (default is start at 0)
+        */
+        AnimationControllerFunction(Real sequenceTime, Real timeOffset = 0.0f);
+
+        /** Overriden function.
+        */
+        Real calculate(Real source);
+
+		/** Set the time value manually. */
+		void setTime(Real timeVal);
+		/** Set the sequence duration value manually. */
+		void setSequenceTime(Real seqVal);
+    };
+
+	//-----------------------------------------------------------------------
+    /** Predefined controller function which simply scales an input to an output value.
+    */
+    class _OgreExport ScaleControllerFunction : public ControllerFunction<Real>
+    {
+    protected:
+        Real mScale;
+    public:
+        /** Constructor, requires a scale factor.
+            @param
+                scalefactor The multipier applied to the input to produce the output.
+            @param
+                deltaInput If true, signifies that the input will be a delta value such that the function should
+                 add it to an internal counter before calculating the output.
+        */
+        ScaleControllerFunction(Real scalefactor, bool deltaInput);
+
+        /** Overriden method.
+        */
+        Real calculate(Real source);
+
+    };
+
+    //-----------------------------------------------------------------------
+    /** Predefined controller function based on a waveform.
+        @remarks
+            A waveform function translates parametric intput to parametric output based on a wave. The factors
+            affecting the function are:
+            - wave type - the shape of the wave
+            - base - the base value of the output from the wave
+            - frequency - the speed of the wave in cycles per second
+            - phase - the offset of the start of the wave, e.g. 0.5 to start half-way through the wave
+            - amplitude - scales the output so that instead of lying within [0,1] it lies within [0,1] * amplitude
+			- duty cycle - the active width of a PWM signal
+        @par
+            Note that for simplicity of integration with the rest of the controller insfrastructure, the output of
+            the wave is parametric i.e. 0..1, rather than the typical wave output of [-1,1]. To compensate for this, the
+            traditional output of the wave is scaled by the following function before output:
+        @par
+            output = (waveoutput + 1) * 0.5
+        @par
+            Hence a wave output of -1 becomes 0, a wave ouput of 1 becomes 1, and a wave output of 0 becomes 0.5.
+    */
+    class _OgreExport WaveformControllerFunction : public ControllerFunction<Real>
+    {
+    protected:
+        WaveformType mWaveType;
+        Real mBase;
+        Real mFrequency;
+        Real mPhase;
+        Real mAmplitude;
+		Real mDutyCycle;
+
+        /** Overridden from ControllerFunction. */
+        Real getAdjustedInput(Real input);
+
+    public:
+        /** Default contructor, requires at least a wave type, other parameters can be defaulted unless required.
+            @param
+                deltaInput If true, signifies that the input will be a delta value such that the function should
+                add it to an internal counter before calculating the output.
+			@param
+				dutyCycle Used in PWM mode to specify the pulse width.
+        */
+        WaveformControllerFunction(WaveformType wType, Real base = 0, Real frequency = 1, Real phase = 0, Real amplitude = 1, bool deltaInput = true, Real dutyCycle = 0.5);
+
+        /** Overriden function.
+        */
+        Real calculate(Real source);
+
+    };
+    //-----------------------------------------------------------------------
+
+}
+
+#endif