ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreGpuProgram.h

@@ -0,0 +1,487 @@
+/*
+-----------------------------------------------------------------------------
+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 __GpuProgram_H_
+#define __GpuProgram_H_
+
+// Precompiler options
+#include "OgrePrerequisites.h"
+#include "OgreResource.h"
+#include "OgreSharedPtr.h"
+#include "OgreIteratorWrappers.h"
+#include "OgreSerializer.h"
+#include "OgreRenderOperation.h"
+#include "OgreGpuProgramParams.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Resources
+	*  @{
+	*/
+	/** Enumerates the types of programs which can run on the GPU. */
+	enum GpuProgramType
+	{
+		GPT_VERTEX_PROGRAM,
+		GPT_FRAGMENT_PROGRAM,
+		GPT_GEOMETRY_PROGRAM
+	};
+
+
+    // Forward declaration 
+    class GpuProgramPtr;
+
+	/** Defines a program which runs on the GPU such as a vertex or fragment program. 
+	@remarks
+		This class defines the low-level program in assembler code, the sort used to
+		directly assemble into machine instructions for the GPU to execute. By nature,
+		this means that the assembler source is rendersystem specific, which is why this
+		is an abstract class - real instances are created through the RenderSystem. 
+		If you wish to use higher level shading languages like HLSL and Cg, you need to 
+		use the HighLevelGpuProgram class instead.
+	*/
+	class _OgreExport GpuProgram : public Resource
+	{
+	protected:
+		/// Command object - see ParamCommand 
+		class _OgreExport CmdType : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+		class _OgreExport CmdSyntax : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+		class _OgreExport CmdSkeletal : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+		class _OgreExport CmdMorph : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+		class _OgreExport CmdPose : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+		class _OgreExport CmdVTF : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+		class _OgreExport CmdManualNamedConstsFile : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+		class _OgreExport CmdAdjacency : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+		// Command object for setting / getting parameters
+		static CmdType msTypeCmd;
+		static CmdSyntax msSyntaxCmd;
+		static CmdSkeletal msSkeletalCmd;
+		static CmdMorph msMorphCmd;
+		static CmdPose msPoseCmd;
+		static CmdVTF msVTFCmd;
+		static CmdManualNamedConstsFile msManNamedConstsFileCmd;
+		static CmdAdjacency msAdjacencyCmd;
+		/// The type of the program
+		GpuProgramType mType;
+		/// The name of the file to load source from (may be blank)
+		String mFilename;
+        /// The assembler source of the program (may be blank until file loaded)
+        String mSource;
+        /// Whether we need to load source from file or not
+        bool mLoadFromFile;
+        /// Syntax code e.g. arbvp1, vs_2_0 etc
+        String mSyntaxCode;
+        /// Does this (vertex) program include skeletal animation?
+        bool mSkeletalAnimation;
+		/// Does this (vertex) program include morph animation?
+		bool mMorphAnimation;
+		/// Does this (vertex) program include pose animation (count of number of poses supported)
+		ushort mPoseAnimation;
+		/// Does this (vertex) program require support for vertex texture fetch?
+		bool mVertexTextureFetch;
+		/// Does this (geometry) program require adjacency information?
+		bool mNeedsAdjacencyInfo;
+		/// The default parameters for use with this object
+		GpuProgramParametersSharedPtr mDefaultParams;
+		/// Did we encounter a compilation error?
+		bool mCompileError;
+		/** Record of logical to physical buffer maps. Mandatory for low-level
+			programs or high-level programs which set their params the same way. 
+			This is a shared pointer because if the program is recompiled and the parameters
+			change, this definition will alter, but previous params may reference the old def. */
+		mutable GpuLogicalBufferStructPtr mFloatLogicalToPhysical;
+		/** Record of logical to physical buffer maps. Mandatory for low-level
+			programs or high-level programs which set their params the same way. 
+			This is a shared pointer because if the program is recompiled and the parameters
+			change, this definition will alter, but previous params may reference the old def.*/
+		mutable GpuLogicalBufferStructPtr mIntLogicalToPhysical;
+		/** Parameter name -> ConstantDefinition map, shared instance used by all parameter objects.
+		This is a shared pointer because if the program is recompiled and the parameters
+		change, this definition will alter, but previous params may reference the old def.
+		*/
+		mutable GpuNamedConstantsPtr mConstantDefs;
+		/// File from which to load named constants manually
+		String mManualNamedConstantsFile;
+		bool mLoadedManualNamedConstants;
+
+
+		/** Internal method for setting up the basic parameter definitions for a subclass. 
+		@remarks
+		Because StringInterface holds a dictionary of parameters per class, subclasses need to
+		call this to ask the base class to add it's parameters to their dictionary as well.
+		Can't do this in the constructor because that runs in a non-virtual context.
+		@par
+		The subclass must have called it's own createParamDictionary before calling this method.
+		*/
+		void setupBaseParamDictionary(void);
+
+        /** Internal method returns whether required capabilities for this program is supported.
+        */
+        bool isRequiredCapabilitiesSupported(void) const;
+
+		/// @copydoc Resource::calculateSize
+		size_t calculateSize(void) const { return 0; } // TODO 
+
+		/// @copydoc Resource::loadImpl
+		void loadImpl(void);
+
+		/// Create the internal params logical & named mapping structures
+		void createParameterMappingStructures(bool recreateIfExists = true) const;
+		/// Create the internal params logical mapping structures
+		void createLogicalParameterMappingStructures(bool recreateIfExists = true) const;
+		/// Create the internal params named mapping structures
+		void createNamedParameterMappingStructures(bool recreateIfExists = true) const;
+
+	public:
+
+		GpuProgram(ResourceManager* creator, const String& name, ResourceHandle handle,
+			const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
+
+		virtual ~GpuProgram() {}
+
+        /** Sets the filename of the source assembly for this program.
+        @remarks
+            Setting this will have no effect until you (re)load the program.
+        */
+        virtual void setSourceFile(const String& filename);
+
+		/** Sets the source assembly for this program from an in-memory string.
+        @remarks
+            Setting this will have no effect until you (re)load the program.
+        */
+        virtual void setSource(const String& source);
+
+        /** Gets the syntax code for this program e.g. arbvp1, fp20, vs_1_1 etc */
+        virtual const String& getSyntaxCode(void) const { return mSyntaxCode; }
+
+		/** Sets the syntax code for this program e.g. arbvp1, fp20, vs_1_1 etc */
+		virtual void setSyntaxCode(const String& syntax);
+
+		/** Gets the name of the file used as source for this program. */
+		virtual const String& getSourceFile(void) const { return mFilename; }
+        /** Gets the assembler source for this program. */
+        virtual const String& getSource(void) const { return mSource; }
+		/// Set the program type (only valid before load)
+		virtual void setType(GpuProgramType t);
+        /// Get the program type
+        virtual GpuProgramType getType(void) const { return mType; }
+
+        /** Returns the GpuProgram which should be bound to the pipeline.
+        @remarks
+            This method is simply to allow some subclasses of GpuProgram to delegate
+            the program which is bound to the pipeline to a delegate, if required. */
+        virtual GpuProgram* _getBindingDelegate(void) { return this; }
+
+        /** Returns whether this program can be supported on the current renderer and hardware. */
+        virtual bool isSupported(void) const;
+
+        /** Creates a new parameters object compatible with this program definition. 
+        @remarks
+            It is recommended that you use this method of creating parameters objects
+            rather than going direct to GpuProgramManager, because this method will
+            populate any implementation-specific extras (like named parameters) where
+            they are appropriate.
+        */
+        virtual GpuProgramParametersSharedPtr createParameters(void);
+
+        /** Sets whether a vertex program includes the required instructions
+        to perform skeletal animation. 
+        @remarks
+        If this is set to true, OGRE will not blend the geometry according to 
+        skeletal animation, it will expect the vertex program to do it.
+        */
+        virtual void setSkeletalAnimationIncluded(bool included) 
+        { mSkeletalAnimation = included; }
+
+        /** Returns whether a vertex program includes the required instructions
+            to perform skeletal animation. 
+        @remarks
+            If this returns true, OGRE will not blend the geometry according to 
+            skeletal animation, it will expect the vertex program to do it.
+        */
+        virtual bool isSkeletalAnimationIncluded(void) const { return mSkeletalAnimation; }
+
+        /** Sets whether a vertex program includes the required instructions
+        to perform morph animation. 
+        @remarks
+        If this is set to true, OGRE will not blend the geometry according to 
+        morph animation, it will expect the vertex program to do it.
+        */
+        virtual void setMorphAnimationIncluded(bool included) 
+		{ mMorphAnimation = included; }
+
+        /** Sets whether a vertex program includes the required instructions
+        to perform pose animation. 
+        @remarks
+        If this is set to true, OGRE will not blend the geometry according to 
+        pose animation, it will expect the vertex program to do it.
+		@param poseCount The number of simultaneous poses the program can blend
+        */
+        virtual void setPoseAnimationIncluded(ushort poseCount) 
+		{ mPoseAnimation = poseCount; }
+
+		/** Returns whether a vertex program includes the required instructions
+            to perform morph animation. 
+        @remarks
+            If this returns true, OGRE will not blend the geometry according to 
+            morph animation, it will expect the vertex program to do it.
+        */
+        virtual bool isMorphAnimationIncluded(void) const { return mMorphAnimation; }
+
+		/** Returns whether a vertex program includes the required instructions
+            to perform pose animation. 
+        @remarks
+            If this returns true, OGRE will not blend the geometry according to 
+            pose animation, it will expect the vertex program to do it.
+        */
+        virtual bool isPoseAnimationIncluded(void) const { return mPoseAnimation > 0; }
+		/** Returns the number of simultaneous poses the vertex program can 
+			blend, for use in pose animation.
+        */
+        virtual ushort getNumberOfPosesIncluded(void) const { return mPoseAnimation; }
+		/** Sets whether this vertex program requires support for vertex 
+			texture fetch from the hardware.
+		*/
+		virtual void setVertexTextureFetchRequired(bool r) { mVertexTextureFetch = r; }
+		/** Returns whether this vertex program requires support for vertex 
+			texture fetch from the hardware.
+		*/
+		virtual bool isVertexTextureFetchRequired(void) const { return mVertexTextureFetch; }
+
+		/** Sets whether this geometry program requires adjacency information
+			from the input primitives.
+		*/
+		virtual void setAdjacencyInfoRequired(bool r) { mNeedsAdjacencyInfo = r; }
+		/** Returns whether this geometry program requires adjacency information 
+			from the input primitives.
+		*/
+		virtual bool isAdjacencyInfoRequired(void) const { return mNeedsAdjacencyInfo; }
+		
+		/** Get a reference to the default parameters which are to be used for all
+			uses of this program.
+		@remarks
+			A program can be set up with a list of default parameters, which can save time when 
+			using a program many times in a material with roughly the same settings. By 
+			retrieving the default parameters and populating it with the most used options, 
+			any new parameter objects created from this program afterwards will automatically include
+			the default parameters; thus users of the program need only change the parameters
+			which are unique to their own usage of the program.
+		*/
+		virtual GpuProgramParametersSharedPtr getDefaultParameters(void);
+
+        /** Returns true if default parameters have been set up.  
+        */
+        virtual bool hasDefaultParameters(void) const { return !mDefaultParams.isNull(); }
+
+		/** Returns whether a vertex program wants light and material states to be passed
+		through fixed pipeline low level API rendering calls (default false, subclasses can override)
+		@remarks
+			Most vertex programs do not need this material information, however GLSL
+			shaders can refer to this material and lighting state so enable this option
+		*/
+		virtual bool getPassSurfaceAndLightStates(void) const { return false; }
+
+		/** Returns whether a fragment program wants fog state to be passed
+		through fixed pipeline low level API rendering calls (default true, subclasses can override)
+		@remarks
+		On DirectX, shader model 2 and earlier continues to have fixed-function fog
+		applied to it, so fog state is still passed (you should disable fog on the
+		pass if you want to perform fog in the shader). In OpenGL it is also
+		common to be able to access the fixed-function fog state inside the shader. 
+		*/
+		virtual bool getPassFogStates(void) const { return true; }
+
+		/** Returns whether a vertex program wants transform state to be passed
+		through fixed pipeline low level API rendering calls
+		@remarks
+		Most vertex programs do not need fixed-function transform information, however GLSL
+		shaders can refer to this state so enable this option
+		*/
+		virtual bool getPassTransformStates(void) const { return false; }
+
+		/** Returns a string that specifies the language of the gpu programs as specified
+        in a material script. ie: asm, cg, hlsl, glsl
+        */
+        virtual const String& getLanguage(void) const;
+
+		/** Did this program encounter a compile error when loading?
+		*/
+		virtual bool hasCompileError(void) const { return mCompileError; }
+
+		/** Reset a compile error if it occurred, allowing the load to be retried
+		*/
+		virtual void resetCompileError(void) { mCompileError = false; }
+
+		/** Allows you to manually provide a set of named parameter mappings
+			to a program which would not be able to derive named parameters itself.
+		@remarks
+			You may wish to use this if you have assembler programs that were compiled
+			from a high-level source, and want the convenience of still being able
+			to use the named parameters from the original high-level source.
+		@see setManualNamedConstantsFile
+		*/
+		virtual void setManualNamedConstants(const GpuNamedConstants& namedConstants);
+
+		/// Get a read-only reference to the named constants registered for this program (manually or automatically)
+		virtual const GpuNamedConstants& getNamedConstants() const { return *mConstantDefs.get(); }
+
+		/** Specifies the name of a file from which to load named parameters mapping
+			for a program which would not be able to derive named parameters itself.
+		@remarks
+			You may wish to use this if you have assembler programs that were compiled
+			from a high-level source, and want the convenience of still being able
+			to use the named parameters from the original high-level source. This
+			method will make a low-level program search in the resource group of the
+			program for the named file from which to load parameter names from. 
+			The file must be in the format produced by GpuNamedConstants::save.
+		*/
+		virtual void setManualNamedConstantsFile(const String& paramDefFile);
+
+		/** Gets the name of a file from which to load named parameters mapping
+			for a program which would not be able to derive named parameters itself.
+		*/
+		virtual const String& getManualNamedConstantsFile() const { return mManualNamedConstantsFile; }
+		/** Get the full list of named constants.
+		@note
+		Only available if this parameters object has named parameters, which means either
+		a high-level program which loads them, or a low-level program which has them
+		specified manually.
+		*/
+		virtual const GpuNamedConstants& getConstantDefinitions() const { return *mConstantDefs.get(); }
+
+
+    protected:
+        /// Virtual method which must be implemented by subclasses, load from mSource
+        virtual void loadFromSource(void) = 0;
+
+	};
+
+
+	/** Specialisation of SharedPtr to allow SharedPtr to be assigned to GpuProgramPtr 
+	@note Has to be a subclass since we need operator=.
+	We could templatise this instead of repeating per Resource subclass, 
+	except to do so requires a form VC6 does not support i.e.
+	ResourceSubclassPtr<T> : public SharedPtr<T>
+	*/
+	class _OgreExport GpuProgramPtr : public SharedPtr<GpuProgram> 
+	{
+	public:
+		GpuProgramPtr() : SharedPtr<GpuProgram>() {}
+		explicit GpuProgramPtr(GpuProgram* rep) : SharedPtr<GpuProgram>(rep) {}
+		GpuProgramPtr(const GpuProgramPtr& r) : SharedPtr<GpuProgram>(r) {} 
+		GpuProgramPtr(const ResourcePtr& r) : SharedPtr<GpuProgram>()
+		{
+			// 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 = static_cast<GpuProgram*>(r.getPointer());
+			    pUseCount = r.useCountPointer();
+			    if (pUseCount)
+			    {
+				    ++(*pUseCount);
+			    }
+            }
+		}
+
+		/// Operator used to convert a ResourcePtr to a GpuProgramPtr
+		GpuProgramPtr& operator=(const ResourcePtr& r)
+		{
+			if (pRep == static_cast<GpuProgram*>(r.getPointer()))
+				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 = static_cast<GpuProgram*>(r.getPointer());
+			    pUseCount = r.useCountPointer();
+			    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;
+		}
+        /// Operator used to convert a HighLevelGpuProgramPtr to a GpuProgramPtr
+        GpuProgramPtr& operator=(const HighLevelGpuProgramPtr& r);
+	};
+	/** @} */
+	/** @} */
+}
+
+#endif