ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreShadowCaster.h

@@ -0,0 +1,225 @@
+/*
+-----------------------------------------------------------------------------
+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 __ShadowCaster_H__
+#define __ShadowCaster_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreRenderable.h"
+
+
+namespace Ogre {
+
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Scene
+	*  @{
+	*/
+	/** Class which represents the renderable aspects of a set of shadow volume faces. 
+    @remarks
+        Note that for casters comprised of more than one set of vertex buffers (e.g. SubMeshes each
+        using their own geometry), it will take more than one ShadowRenderable to render the 
+        shadow volume. Therefore for shadow caster geometry, it is best to stick to one set of
+        vertex buffers (not necessarily one buffer, but the positions for the entire geometry 
+        should come from one buffer if possible)
+    */
+    class _OgreExport ShadowRenderable : public Renderable, public ShadowDataAlloc
+    {
+    protected:
+        MaterialPtr mMaterial;
+        RenderOperation mRenderOp;
+        ShadowRenderable* mLightCap; // used only if isLightCapSeparate == true
+    public:
+        ShadowRenderable() : mMaterial(), mLightCap(0) {}
+        virtual ~ShadowRenderable() { delete mLightCap; }
+        /** Set the material to be used by the shadow, should be set by the caller 
+          before adding to a render queue
+        */
+        void setMaterial(const MaterialPtr& mat) { mMaterial = mat; }
+        /// Overridden from Renderable
+        const MaterialPtr& getMaterial(void) const { return mMaterial; }
+        /// Overridden from Renderable
+        void getRenderOperation(RenderOperation& op) { op = mRenderOp; }
+        /// Get the internal render operation for set up
+        RenderOperation* getRenderOperationForUpdate(void) {return &mRenderOp;}
+        /// Overridden from Renderable
+        void getWorldTransforms(Matrix4* xform) const = 0;
+        /// Overridden from Renderable
+        Real getSquaredViewDepth(const Camera*) const{ return 0; /* not used */}
+        /// Overridden from Renderable
+        const LightList& getLights(void) const;
+        /** Does this renderable require a separate light cap?
+        @remarks
+            If possible, the light cap (when required) should be contained in the
+            usual geometry of the shadow renderable. However, if for some reason
+            the normal depth function (less than) could cause artefacts, then a
+            separate light cap with a depth function of 'always fail' can be used 
+            instead. The primary example of this is when there are floating point
+            inaccuracies caused by calculating the shadow geometry separately from
+            the real geometry. 
+        */
+        bool isLightCapSeparate(void) const { return mLightCap != 0; }
+
+        /// Get the light cap version of this renderable
+        ShadowRenderable* getLightCapRenderable(void) { return mLightCap; }
+        /// Should this ShadowRenderable be treated as visible?
+        virtual bool isVisible(void) const { return true; }
+
+		/** This function informs the shadow renderable that the global index buffer
+		from the SceneManager has been updated. As all shadow use this buffer their pointer 
+		must be updated as well
+		@indexBuffer pointer to the new index buffer
+		*/
+		virtual void rebindIndexBuffer(const HardwareIndexBufferSharedPtr& indexBuffer) = 0;
+
+    };
+
+    /** A set of flags that can be used to influence ShadowRenderable creation. */
+    enum ShadowRenderableFlags
+    {
+        /// For shadow volume techniques only, generate a light cap on the volume
+        SRF_INCLUDE_LIGHT_CAP = 0x00000001,
+        /// For shadow volume techniques only, generate a dark cap on the volume
+        SRF_INCLUDE_DARK_CAP  = 0x00000002,
+        /// For shadow volume techniques only, indicates volume is extruded to infinity
+        SRF_EXTRUDE_TO_INFINITY  = 0x00000004
+    };
+
+    /** This class defines the interface that must be implemented by shadow casters.
+    */
+    class _OgreExport ShadowCaster
+    {
+    public:
+        virtual ~ShadowCaster() { }
+        /** Returns whether or not this object currently casts a shadow. */
+        virtual bool getCastShadows(void) const = 0;
+
+        /** Returns details of the edges which might be used to determine a silhouette. */
+        virtual EdgeData* getEdgeList(void) = 0;
+		/** Returns whether the object has a valid edge list. */
+		virtual bool hasEdgeList(void) = 0;
+
+        /** Get the world bounding box of the caster. */
+        virtual const AxisAlignedBox& getWorldBoundingBox(bool derive = false) const = 0;
+        /** Gets the world space bounding box of the light cap */
+        virtual const AxisAlignedBox& getLightCapBounds(void) const = 0;
+        /** Gets the world space bounding box of the dark cap, as extruded using the light provided */
+        virtual const AxisAlignedBox& getDarkCapBounds(const Light& light, Real dirLightExtrusionDist) const = 0;
+
+        typedef vector<ShadowRenderable*>::type ShadowRenderableList;
+        typedef VectorIterator<ShadowRenderableList> ShadowRenderableListIterator;
+
+        /** Gets an iterator over the renderables required to render the shadow volume. 
+        @remarks
+            Shadowable geometry should ideally be designed such that there is only one
+            ShadowRenderable required to render the the shadow; however this is not a necessary
+            limitation and it can be exceeded if required.
+        @param shadowTechnique The technique being used to generate the shadow
+        @param light The light to generate the shadow from
+        @param indexBuffer The index buffer to build the renderables into, 
+            the current contents are assumed to be disposable.
+        @param extrudeVertices If true, this means this class should extrude
+            the vertices of the back of the volume in software. If false, it
+            will not be done (a vertex program is assumed).
+        @param extrusionDistance The distance to extrude the shadow volume
+        @param flags Technique-specific flags, see ShadowRenderableFlags
+        */
+        virtual ShadowRenderableListIterator getShadowVolumeRenderableIterator(
+            ShadowTechnique shadowTechnique, const Light* light, 
+            HardwareIndexBufferSharedPtr* indexBuffer, 
+            bool extrudeVertices, Real extrusionDistance, unsigned long flags = 0 ) = 0;
+
+        /** Utility method for extruding vertices based on a light. 
+        @remarks
+            Unfortunately, because D3D cannot handle homogeneous (4D) position
+            coordinates in the fixed-function pipeline (GL can, but we have to
+            be cross-API), when we extrude in software we cannot extrude to 
+            infinity the way we do in the vertex program (by setting w to
+            0.0f). Therefore we extrude by a fixed distance, which may cause 
+            some problems with larger scenes. Luckily better hardware (ie
+            vertex programs) can fix this.
+        @param vertexBuffer The vertex buffer containing ONLY xyz position
+        values, which must be originalVertexCount * 2 * 3 floats long.
+        @param originalVertexCount The count of the original number of
+        vertices, i.e. the number in the mesh, not counting the doubling
+        which has already been done (by VertexData::prepareForShadowVolume)
+        to provide the extruded area of the buffer.
+        @param lightPos 4D light position in object space, when w=0.0f this
+        represents a directional light
+        @param extrudeDist The distance to extrude
+        */
+        static void extrudeVertices(const HardwareVertexBufferSharedPtr& vertexBuffer, 
+            size_t originalVertexCount, const Vector4& lightPos, Real extrudeDist);
+        /** Get the distance to extrude for a point/spot light */
+        virtual Real getPointExtrusionDistance(const Light* l) const = 0;
+    protected:
+        /// Helper method for calculating extrusion distance
+        Real getExtrusionDistance(const Vector3& objectPos, const Light* light) const;
+        /** Tells the caster to perform the tasks necessary to update the 
+            edge data's light listing. Can be overridden if the subclass needs 
+            to do additional things. 
+        @param edgeData The edge information to update
+        @param lightPos 4D vector representing the light, a directional light
+            has w=0.0
+       */
+        virtual void updateEdgeListLightFacing(EdgeData* edgeData, 
+            const Vector4& lightPos);
+
+        /** Generates the indexes required to render a shadow volume into the 
+            index buffer which is passed in, and updates shadow renderables
+            to use it.
+        @param edgeData The edge information to use
+        @param indexBuffer The buffer into which to write data into; current 
+            contents are assumed to be discardable.
+        @param light The light, mainly for type info as silhouette calculations
+            should already have been done in updateEdgeListLightFacing
+        @param shadowRenderables A list of shadow renderables which has 
+            already been constructed but will need populating with details of
+            the index ranges to be used.
+        @param flags Additional controller flags, see ShadowRenderableFlags
+        */
+        virtual void generateShadowVolume(EdgeData* edgeData, 
+            const HardwareIndexBufferSharedPtr& indexBuffer, const Light* light,
+            ShadowRenderableList& shadowRenderables, unsigned long flags);
+        /** Utility method for extruding a bounding box. 
+        @param box Original bounding box, will be updated in-place
+        @param lightPos 4D light position in object space, when w=0.0f this
+        represents a directional light
+        @param extrudeDist The distance to extrude
+        */
+        virtual void extrudeBounds(AxisAlignedBox& box, const Vector4& lightPos, 
+            Real extrudeDist) const;
+
+
+    };
+	/** @} */
+	/** @} */
+}
+
+#endif

data/deps/include/OGRE/OgreShadowTextureManager.h

@@ -0,0 +1,156 @@
+/*-------------------------------------------------------------------------
+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-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
+
+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
+{
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Scene
+	*  @{
+	*/
+	typedef vector<TexturePtr>::type ShadowTextureList;
+
+	/** Structure containing the configuration for one shadow texture. */
+	struct ShadowTextureConfig
+	{
+		unsigned int width;
+		unsigned int height;
+		PixelFormat format;
+        unsigned int fsaa;
+		uint16		depthBufferPoolId;
+
+		ShadowTextureConfig()
+			: width(512), height(512), format(PF_X8R8G8B8), fsaa(0), depthBufferPoolId(1) {}
+	};
+
+	typedef vector<ShadowTextureConfig>::type 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>, public ShadowDataAlloc
+	{
+	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, i.e. 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/deps/include/OGRE/OgreShadowVolumeExtrudeProgram.h

@@ -0,0 +1,286 @@
+/*
+-----------------------------------------------------------------------------
+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 __SHADOWVOLUMEEXTRUDEPROGRAM_H__
+#define __SHADOWVOLUMEEXTRUDEPROGRAM_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreLight.h"
+
+namespace Ogre {
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Scene
+	*  @{
+	*/
+	/** 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 // homogeneous, 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, // homogeneous, 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, // homogeneous, 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 : public ShadowDataAlloc
+    {
+    private:
+        static String mPointArbvp1;
+        static String mPointVs_1_1;
+		static String mPointVs_4_0;
+		static String mPointVs_glsles;
+        static String mDirArbvp1;
+        static String mDirVs_1_1;
+		static String mDirVs_4_0;
+		static String mDirVs_glsles;
+        // 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 mPointVs_4_0Debug;
+		static String mPointVs_glslesDebug;
+        static String mDirArbvp1Debug;
+        static String mDirVs_1_1Debug;
+		static String mDirVs_4_0Debug;
+		static String mDirVs_glslesDebug;
+		
+        static String mPointArbvp1Finite;
+        static String mPointVs_1_1Finite;
+		static String mPointVs_4_0Finite;
+		static String mPointVs_glslesFinite;
+        static String mDirArbvp1Finite;
+        static String mDirVs_1_1Finite;
+		static String mDirVs_4_0Finite;
+		static String mDirVs_glslesFinite;
+        // 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 mPointVs_4_0FiniteDebug;
+		static String mPointVs_glslesFiniteDebug;
+        static String mDirArbvp1FiniteDebug;
+        static String mDirVs_1_1FiniteDebug;
+		static String mDirVs_4_0FiniteDebug;
+		static String mDirVs_glslesFiniteDebug;
+
+		static String mGeneralFs_4_0;
+		static String mGeneralFs_glsles;
+
+		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];
+		static String frgProgramName;
+
+        /// 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 point lights, compatible with vs_4_0
+		static const String& getPointLightExtruderVs_4_0(void) { return mPointVs_4_0; }
+		/// Get extruder program source for point lights, compatible with glsles
+		static const String& getPointLightExtruderVs_glsles(void) { return mPointVs_glsles; }
+        /// 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 directional lights, compatible with vs_4_0
+		static const String& getDirectionalLightExtruderVs_4_0(void) { return mDirVs_4_0; }
+		/// Get extruder program source for directional lights, compatible with glsles
+		static const String& getDirectionalLightExtruderVs_glsles(void) { return mDirVs_glsles; }
+
+        /// 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 point lights, compatible with vs_4_0
+		static const String& getPointLightExtruderVs_4_0Debug(void) { return mPointVs_4_0Debug; }
+		/// Get extruder program source for debug point lights, compatible with glsles
+		static const String& getPointLightExtruderVs_glslesDebug(void) { return mPointVs_glslesDebug; }
+        /// 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; }
+		/// Get extruder program source for debug directional lights, compatible with vs_4_0
+		static const String& getDirectionalLightExtruderVs_4_0Debug(void) { return mDirVs_4_0Debug; }
+		/// Get extruder program source for debug directional lights, compatible with glsles
+		static const String& getDirectionalLightExtruderVs_glslesDebug(void) { return mDirVs_glslesDebug; }
+        /// 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 point lights, compatible with vs_4_0
+		static const String& getPointLightExtruderVs_4_0Finite(void) { return mPointVs_4_0Finite; }
+		/// Get FINITE extruder program source for point lights, compatible with glsles
+		static const String& getPointLightExtruderVs_glslesFinite(void) { return mPointVs_glslesFinite; }
+        /// 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 directional lights, compatible with vs_4_0
+		static const String& getDirectionalLightExtruderVs_4_0Finite(void) { return mDirVs_4_0Finite; }
+		/// Get FINITE extruder program source for directional lights, compatible with glsles
+		static const String& getDirectionalLightExtruderVs_glslesFinite(void) { return mDirVs_glslesFinite; }
+
+        /// 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 extruder program source for debug point lights, compatible with vs_4_0
+		static const String& getPointLightExtruderVs_4_0FiniteDebug(void) { return mPointVs_4_0FiniteDebug; }
+		/// Get extruder program source for debug point lights, compatible with glsles
+		static const String& getPointLightExtruderVs_glslesFiniteDebug(void) { return mPointVs_glslesFiniteDebug; }
+        /// 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; }
+		/// Get FINITE extruder program source for debug directional lights, compatible with vs_4_0
+		static const String& getDirectionalLightExtruderVs_4_0FiniteDebug(void) { return mDirVs_4_0FiniteDebug; }
+		/// Get FINITE extruder program source for debug directional lights, compatible with glsles
+		static const String& getDirectionalLightExtruderVs_glslesFiniteDebug(void) { return mDirVs_glslesFiniteDebug; }
+
+    };
+	/** @} */
+	/** @} */
+}
+#endif