shattered_ogrerb 0.5.0.1

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

@@ -0,0 +1,145 @@
+/*-------------------------------------------------------------------------
+This source file is a 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 library is free software; you can redistribute it and/or modify it
+under the terms of the GNU Lesser General Public License (LGPL) as 
+published by the Free Software Foundation; either version 2.1 of the 
+License, or (at your option) any later version.
+
+This library 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 library; 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 __ShadowTextureManager_H__
+#define __ShadowTextureManager_H__
+
+// Precompiler options
+#include "OgrePrerequisites.h"
+#include "OgreSingleton.h"
+#include "OgrePixelFormat.h"
+#include "OgreTexture.h"
+#include "OgreIteratorWrappers.h"
+
+
+namespace Ogre
+{
+	typedef std::vector<TexturePtr> ShadowTextureList;
+
+	/** Structure containing the configuration for one shadow texture. */
+	struct ShadowTextureConfig
+	{
+		unsigned int width;
+		unsigned int height;
+		PixelFormat format;
+
+		ShadowTextureConfig()
+			: width(512), height(512), format(PF_X8R8G8B8) {}
+	};
+
+	typedef std::vector<ShadowTextureConfig> ShadowTextureConfigList;
+	typedef ConstVectorIterator<ShadowTextureConfigList> ConstShadowTextureConfigIterator;
+
+	inline _OgreExport bool operator== ( const ShadowTextureConfig& lhs, const ShadowTextureConfig& rhs );
+	inline _OgreExport bool operator!= ( const ShadowTextureConfig& lhs, const ShadowTextureConfig& rhs );
+
+
+	/** Class to manage the available shadow textures which may be shared between
+		many SceneManager instances if formats agree.
+	@remarks
+		The management of the list of shadow textures has been separated out into
+		a dedicated class to enable the clean management of shadow textures
+		across many scene manager instances. Where multiple scene managers are
+		used with shadow textures, the configuration of those shadows may or may
+		not be consistent - if it is, it is good to centrally manage the textures
+		so that creation and destruction responsibility is clear.
+	*/
+	class _OgreExport ShadowTextureManager : public Singleton<ShadowTextureManager>
+	{
+	protected:
+		ShadowTextureList mTextureList;
+		ShadowTextureList mNullTextureList;
+		size_t mCount;
+
+	public:
+		ShadowTextureManager();
+		virtual ~ShadowTextureManager();
+
+		/** Populate an incoming list with shadow texture references as requested
+			in the configuration list.
+		*/
+		virtual void getShadowTextures(const ShadowTextureConfigList& config, 
+			ShadowTextureList& listToPopulate);
+
+		/** Get an appropriately defined 'null' texture, ie one which will always
+			result in no shadows.
+		*/
+		virtual TexturePtr getNullShadowTexture(PixelFormat format);
+
+		/** Remove any shadow textures that are no longer being referenced.
+		@remarks
+			This should be called fairly regularly since references may take a 
+			little while to disappear in some cases (if referenced by materials)
+		*/
+		virtual void clearUnused();
+		/** Dereference all the shadow textures kept in this class and remove them
+			from TextureManager; note that it is up to the SceneManagers to clear 
+			their local references.
+		*/
+		virtual void clear();
+
+        /** Override standard Singleton retrieval.
+        @remarks
+        Why do we do this? Well, it's because the Singleton
+        implementation is in a .h file, which means it gets compiled
+        into anybody who includes it. This is needed for the
+        Singleton template to work, but we actually only want it
+        compiled into the implementation of the class based on the
+        Singleton, not all of them. If we don't change this, we get
+        link errors when trying to use the Singleton-based class from
+        an outside dll.
+        @par
+        This method just delegates to the template version anyway,
+        but the implementation stays in this single compilation unit,
+        preventing link errors.
+        */
+        static ShadowTextureManager& getSingleton(void);
+        /** Override standard Singleton retrieval.
+        @remarks
+        Why do we do this? Well, it's because the Singleton
+        implementation is in a .h file, which means it gets compiled
+        into anybody who includes it. This is needed for the
+        Singleton template to work, but we actually only want it
+        compiled into the implementation of the class based on the
+        Singleton, not all of them. If we don't change this, we get
+        link errors when trying to use the Singleton-based class from
+        an outside dll.
+        @par
+        This method just delegates to the template version anyway,
+        but the implementation stays in this single compilation unit,
+        preventing link errors.
+        */
+        static ShadowTextureManager* getSingletonPtr(void);
+
+	};
+
+}
+
+
+#endif
+

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

@@ -0,0 +1,233 @@
+/*
+-----------------------------------------------------------------------------
+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 __SHADOWVOLUMEEXTRUDEPROGRAM_H__
+#define __SHADOWVOLUMEEXTRUDEPROGRAM_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreLight.h"
+
+namespace Ogre {
+    /** Static class containing source for vertex programs for extruding shadow volumes
+    @remarks
+        This exists so we don't have to be dependent on an external media files.
+        Assembler is used so we don't have to rely on particular plugins.
+        The assembler contents of this file were generated from the following Cg:
+    @code
+        // Point light shadow volume extrude
+        void shadowVolumeExtrudePointLight_vp (
+            float4 position			: POSITION,
+            float  wcoord			: TEXCOORD0,
+
+            out float4 oPosition	: POSITION,
+
+            uniform float4x4 worldViewProjMatrix,
+            uniform float4   lightPos // homogenous, object space
+            )
+        {
+            // extrusion in object space
+            // vertex unmodified if w==1, extruded if w==0
+            float4 newpos = 
+                (wcoord.xxxx * lightPos) + 
+                float4(position.xyz - lightPos.xyz, 0);
+
+            oPosition = mul(worldViewProjMatrix, newpos);
+
+        }
+
+        // Directional light extrude
+        void shadowVolumeExtrudeDirLight_vp (
+            float4 position			: POSITION,
+            float  wcoord			: TEXCOORD0,
+
+            out float4 oPosition	: POSITION,
+
+            uniform float4x4 worldViewProjMatrix,
+            uniform float4   lightPos // homogenous, object space
+            )
+        {
+            // extrusion in object space
+            // vertex unmodified if w==1, extruded if w==0
+            float4 newpos = 
+                (wcoord.xxxx * (position + lightPos)) - lightPos;
+
+            oPosition = mul(worldViewProjMatrix, newpos);
+
+        }
+        // Point light shadow volume extrude - FINITE
+        void shadowVolumeExtrudePointLightFinite_vp (
+            float4 position			: POSITION,
+            float  wcoord			: TEXCOORD0,
+
+            out float4 oPosition	: POSITION,
+
+            uniform float4x4 worldViewProjMatrix,
+            uniform float4   lightPos, // homogenous, object space
+			uniform float    extrusionDistance // how far to extrude
+            )
+        {
+            // extrusion in object space
+            // vertex unmodified if w==1, extruded if w==0
+			float3 extrusionDir = position.xyz - lightPos.xyz;
+			extrusionDir = normalize(extrusionDir);
+			
+            float4 newpos = float4(position.xyz +  
+                ((1 - wcoord.x) * extrusionDistance * extrusionDir), 1);
+
+            oPosition = mul(worldViewProjMatrix, newpos);
+
+        }
+
+        // Directional light extrude - FINITE
+        void shadowVolumeExtrudeDirLightFinite_vp (
+            float4 position			: POSITION,
+            float  wcoord			: TEXCOORD0,
+
+            out float4 oPosition	: POSITION,
+
+            uniform float4x4 worldViewProjMatrix,
+            uniform float4   lightPos, // homogenous, object space
+			uniform float    extrusionDistance // how far to extrude
+            )
+        {
+            // extrusion in object space
+            // vertex unmodified if w==1, extruded if w==0
+			// -ve lightPos is direction
+            float4 newpos = float4(position.xyz - 
+                (wcoord.x * extrusionDistance * lightPos.xyz), 1);
+
+            oPosition = mul(worldViewProjMatrix, newpos);
+
+        }		
+    @endcode
+    */
+    class _OgreExport ShadowVolumeExtrudeProgram
+    {
+    private:
+        static String mPointArbvp1;
+        static String mPointVs_1_1;
+        static String mDirArbvp1;
+        static String mDirVs_1_1;
+        // same as above, except the color is set to 1 to enable debug volumes to be seen
+        static String mPointArbvp1Debug;
+        static String mPointVs_1_1Debug;
+        static String mDirArbvp1Debug;
+        static String mDirVs_1_1Debug;
+		
+        static String mPointArbvp1Finite;
+        static String mPointVs_1_1Finite;
+        static String mDirArbvp1Finite;
+        static String mDirVs_1_1Finite;
+        // same as above, except the color is set to 1 to enable debug volumes to be seen
+        static String mPointArbvp1FiniteDebug;
+        static String mPointVs_1_1FiniteDebug;
+        static String mDirArbvp1FiniteDebug;
+        static String mDirVs_1_1FiniteDebug;
+
+		static bool mInitialised;
+
+	public:
+#define OGRE_NUM_SHADOW_EXTRUDER_PROGRAMS 8
+        enum Programs
+        {
+            // Point light extruder, infinite distance
+            POINT_LIGHT = 0,
+            // Point light extruder, infinite distance, debug mode
+            POINT_LIGHT_DEBUG = 1,
+            // Directional light extruder, infinite distance
+            DIRECTIONAL_LIGHT = 2,
+            // Directional light extruder, infinite distance, debug mode
+            DIRECTIONAL_LIGHT_DEBUG = 3,
+            // Point light extruder, finite distance
+            POINT_LIGHT_FINITE = 4,
+            // Point light extruder, finite distance, debug mode
+            POINT_LIGHT_FINITE_DEBUG = 5,
+            // Directional light extruder, finite distance
+            DIRECTIONAL_LIGHT_FINITE = 6,
+            // Directional light extruder, finite distance, debug mode
+            DIRECTIONAL_LIGHT_FINITE_DEBUG = 7
+
+        };
+        static const String programNames[OGRE_NUM_SHADOW_EXTRUDER_PROGRAMS];
+
+        /// Initialise the creation of these vertex programs
+        static void initialise(void);
+        /// Shutdown & destroy the vertex programs
+        static void shutdown(void);
+        /// Get extruder program source for point lights, compatible with arbvp1
+        static const String& getPointLightExtruderArbvp1(void) { return mPointArbvp1; }
+        /// Get extruder program source for point lights, compatible with vs_1_1
+        static const String& getPointLightExtruderVs_1_1(void) { return mPointVs_1_1; }
+        /// Get extruder program source for directional lights, compatible with arbvp1
+        static const String& getDirectionalLightExtruderArbvp1(void) { return mDirArbvp1; }
+        /// Get extruder program source for directional lights, compatible with vs_1_1
+        static const String& getDirectionalLightExtruderVs_1_1(void) { return mDirVs_1_1; }
+
+        /// Get extruder program source for debug point lights, compatible with arbvp1
+        static const String& getPointLightExtruderArbvp1Debug(void) { return mPointArbvp1Debug; }
+        /// Get extruder program source for debug point lights, compatible with vs_1_1
+        static const String& getPointLightExtruderVs_1_1Debug(void) { return mPointVs_1_1Debug; }
+        /// Get extruder program source for debug directional lights, compatible with arbvp1
+        static const String& getDirectionalLightExtruderArbvp1Debug(void) { return mDirArbvp1Debug; }
+        /// Get extruder program source for debug directional lights, compatible with vs_1_1
+        static const String& getDirectionalLightExtruderVs_1_1Debug(void) { return mDirVs_1_1Debug; }
+        /// General purpose method to get any of the program sources
+        static const String& getProgramSource(Light::LightTypes lightType, const String syntax, 
+            bool finite, bool debug);
+
+        static const String& getProgramName(Light::LightTypes lightType, bool finite, bool debug);
+
+
+
+
+
+        /// Get FINITE extruder program source for point lights, compatible with arbvp1
+        static const String& getPointLightExtruderArbvp1Finite(void) { return mPointArbvp1Finite; }
+        /// Get FINITE extruder program source for point lights, compatible with vs_1_1
+        static const String& getPointLightExtruderVs_1_1Finite(void) { return mPointVs_1_1Finite; }
+        /// Get FINITE extruder program source for directional lights, compatible with arbvp1
+        static const String& getDirectionalLightExtruderArbvp1Finite(void) { return mDirArbvp1Finite; }
+        /// Get FINITE extruder program source for directional lights, compatible with vs_1_1
+        static const String& getDirectionalLightExtruderVs_1_1Finite(void) { return mDirVs_1_1Finite; }
+
+        /// Get FINITE extruder program source for debug point lights, compatible with arbvp1
+        static const String& getPointLightExtruderArbvp1FiniteDebug(void) { return mPointArbvp1FiniteDebug; }
+        /// Get extruder program source for debug point lights, compatible with vs_1_1
+        static const String& getPointLightExtruderVs_1_1FiniteDebug(void) { return mPointVs_1_1FiniteDebug; }
+        /// Get FINITE extruder program source for debug directional lights, compatible with arbvp1
+        static const String& getDirectionalLightExtruderArbvp1FiniteDebug(void) { return mDirArbvp1FiniteDebug; }
+        /// Get FINITE extruder program source for debug directional lights, compatible with vs_1_1
+        static const String& getDirectionalLightExtruderVs_1_1FiniteDebug(void) { return mDirVs_1_1FiniteDebug; }
+
+
+
+		
+    };
+}
+#endif

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

@@ -0,0 +1,244 @@
+/*
+-----------------------------------------------------------------------------
+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 __SharedPtr_H__
+#define __SharedPtr_H__
+
+#include "OgrePrerequisites.h"
+
+namespace Ogre {
+
+	/** Reference-counted shared pointer, used for objects where implicit destruction is 
+        required. 
+    @remarks
+        This is a standard shared pointer implementation which uses a reference 
+        count to work out when to delete the object. OGRE does not use this class
+        very often, because it is usually more efficient to make the destruction
+        of objects more intentional (in blocks, say). However in some cases you
+        really cannot tell how many people are using an object, and this approach is
+        worthwhile (e.g. ControllerValue)
+	@par
+		If OGRE_THREAD_SUPPORT is defined to be 1, use of this class is thread-safe.
+    */
+    template<class T> class SharedPtr {
+	protected:
+		T* pRep;
+		unsigned int* pUseCount;
+	public:
+		OGRE_AUTO_SHARED_MUTEX // public to allow external locking
+		/** Constructor, does not initialise the SharedPtr.
+			@remarks
+				<b>Dangerous!</b> You have to call bind() before using the SharedPtr.
+		*/
+		SharedPtr() : pRep(0), pUseCount(0)
+        {
+            OGRE_SET_AUTO_SHARED_MUTEX_NULL
+        }
+
+        template< class Y>
+		explicit SharedPtr(Y* rep) : pRep(rep), pUseCount(new unsigned int(1))
+		{
+            OGRE_SET_AUTO_SHARED_MUTEX_NULL
+			OGRE_NEW_AUTO_SHARED_MUTEX
+		}
+		SharedPtr(const SharedPtr& r)
+            : pRep(0), pUseCount(0)
+		{
+			// lock & copy other mutex pointer
+            
+            OGRE_SET_AUTO_SHARED_MUTEX_NULL
+            OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
+            {
+			    OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
+			    OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
+			    pRep = r.pRep;
+			    pUseCount = r.pUseCount; 
+			    // Handle zero pointer gracefully to manage STL containers
+			    if(pUseCount)
+			    {
+				    ++(*pUseCount); 
+			    }
+            }
+		}
+		SharedPtr& operator=(const SharedPtr& r) {
+			if (pRep == r.pRep)
+				return *this;
+			release();
+			// lock & copy other mutex pointer
+            OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
+            {
+			    OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
+			    OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
+			    pRep = r.pRep;
+			    pUseCount = r.pUseCount;
+			    if (pUseCount)
+			    {
+				    ++(*pUseCount);
+			    }
+            }
+			else
+			{
+				// RHS must be a null pointer
+				assert(r.isNull() && "RHS must be null if it has no mutex!");
+				setNull();
+			}
+			return *this;
+		}
+		
+		template< class Y>
+		SharedPtr(const SharedPtr<Y>& r)
+            : pRep(0), pUseCount(0)
+		{
+			// lock & copy other mutex pointer
+
+            OGRE_SET_AUTO_SHARED_MUTEX_NULL
+            OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
+            {
+			    OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
+			    OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
+			    pRep = r.getPointer();
+			    pUseCount = r.useCountPointer();
+			    // Handle zero pointer gracefully to manage STL containers
+			    if(pUseCount)
+			    {
+				    ++(*pUseCount);
+			    }
+            }
+		}
+		template< class Y>
+		SharedPtr& operator=(const SharedPtr<Y>& r) {
+			if (pRep == r.pRep)
+				return *this;
+			release();
+			// lock & copy other mutex pointer
+            OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
+            {
+			    OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
+			    OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
+			    pRep = r.getPointer();
+			    pUseCount = r.useCountPointer();
+			    if (pUseCount)
+			    {
+				    ++(*pUseCount);
+			    }
+            }
+			return *this;
+		}
+		virtual ~SharedPtr() {
+            release();
+		}
+
+
+		inline T& operator*() const { assert(pRep); return *pRep; }
+		inline T* operator->() const { assert(pRep); return pRep; }
+		inline T* get() const { return pRep; }
+
+		/** Binds rep to the SharedPtr.
+			@remarks
+				Assumes that the SharedPtr is uninitialised!
+		*/
+		void bind(T* rep) {
+			assert(!pRep && !pUseCount);
+            OGRE_NEW_AUTO_SHARED_MUTEX
+			OGRE_LOCK_AUTO_SHARED_MUTEX
+			pUseCount = new unsigned int(1);
+			pRep = rep;
+		}
+
+		inline bool unique() const { OGRE_LOCK_AUTO_SHARED_MUTEX assert(pUseCount); return *pUseCount == 1; }
+		inline unsigned int useCount() const { OGRE_LOCK_AUTO_SHARED_MUTEX assert(pUseCount); return *pUseCount; }
+		inline unsigned int* useCountPointer() const { return pUseCount; }
+
+		inline T* getPointer() const { return pRep; }
+
+		inline bool isNull(void) const { return pRep == 0; }
+
+        inline void setNull(void) { 
+			if (pRep)
+			{
+				// can't scope lock mutex before release incase deleted
+				release();
+				pRep = 0;
+				pUseCount = 0;
+			}
+        }
+
+    protected:
+
+        inline void release(void)
+        {
+			bool destroyThis = false;
+
+            /* If the mutex is not initialized to a non-zero value, then
+               neither is pUseCount nor pRep.
+             */
+
+            OGRE_MUTEX_CONDITIONAL(OGRE_AUTO_MUTEX_NAME)
+			{
+				// lock own mutex in limited scope (must unlock before destroy)
+				OGRE_LOCK_AUTO_SHARED_MUTEX
+				if (pUseCount)
+				{
+					if (--(*pUseCount) == 0) 
+					{
+						destroyThis = true;
+	                }
+				}
+            }
+			if (destroyThis)
+				destroy();
+
+            OGRE_SET_AUTO_SHARED_MUTEX_NULL
+        }
+
+        virtual void destroy(void)
+        {
+            // IF YOU GET A CRASH HERE, YOU FORGOT TO FREE UP POINTERS
+            // BEFORE SHUTTING OGRE DOWN
+            // Use setNull() before shutdown or make sure your pointer goes
+            // out of scope before OGRE shuts down to avoid this.
+            delete pRep;
+            delete pUseCount;
+			OGRE_DELETE_AUTO_SHARED_MUTEX
+        }
+	};
+
+	template<class T, class U> inline bool operator==(SharedPtr<T> const& a, SharedPtr<U> const& b)
+	{
+		return a.get() == b.get();
+	}
+
+	template<class T, class U> inline bool operator!=(SharedPtr<T> const& a, SharedPtr<U> const& b)
+	{
+		return a.get() != b.get();
+	}
+}
+
+
+
+#endif