Some more stuff ported

CamelotRenderer/CamelotRenderer.vcxproj

@@ -99,9 +99,11 @@
     <ClInclude Include="OgreHardwareBuffer.h" />
     <ClInclude Include="OgreHardwareBufferManager.h" />
     <ClInclude Include="OgreHardwareIndexBuffer.h" />
+    <ClInclude Include="OgreHardwareOcclusionQuery.h" />
     <ClInclude Include="OgreHardwareVertexBuffer.h" />
     <ClInclude Include="OgreHeaderPrefix.h" />
     <ClInclude Include="OgreHeaderSuffix.h" />
+    <ClInclude Include="OgreHighLevelGpuProgram.h" />
     <ClInclude Include="OgreMath.h" />
     <ClInclude Include="OgreMatrix3.h" />
     <ClInclude Include="OgreMatrix4.h" />
@@ -147,7 +149,9 @@
     <ClCompile Include="OgreGpuProgramParams.cpp" />
     <ClCompile Include="OgreHardwareBufferManager.cpp" />
     <ClCompile Include="OgreHardwareIndexBuffer.cpp" />
+    <ClCompile Include="OgreHardwareOcclusionQuery.cpp" />
     <ClCompile Include="OgreHardwareVertexBuffer.cpp" />
+    <ClCompile Include="OgreHighLevelGpuProgram.cpp" />
     <ClCompile Include="OgreMath.cpp" />
     <ClCompile Include="OgreMatrix3.cpp" />
     <ClCompile Include="OgreMatrix4.cpp" />

CamelotRenderer/CamelotRenderer.vcxproj.filters

@@ -192,6 +192,12 @@
     <ClInclude Include="OgreStringInterface.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="OgreHighLevelGpuProgram.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="OgreHardwareOcclusionQuery.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="stdafx.cpp">
@@ -287,5 +293,11 @@
     <ClCompile Include="OgreStringInterface.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="OgreHighLevelGpuProgram.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="OgreHardwareOcclusionQuery.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotRenderer/OgreGpuProgram.cpp

@@ -26,7 +26,7 @@ THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
 #include "OgreGpuProgram.h"
-//#include "OgreHighLevelGpuProgram.h"
+#include "OgreHighLevelGpuProgram.h"
 #include "OgreVector3.h"
 #include "OgreVector4.h"
 #include "OgreRenderSystemCapabilities.h"
@@ -399,34 +399,34 @@ namespace Ogre
 		GpuProgram* t = static_cast<GpuProgram*>(target);
 		t->setAdjacencyInfoRequired(StringConverter::parseBool(val));
 	}
-	// TODO PORT - I've hidden this cast until it will be needed
-  //  //-----------------------------------------------------------------------
-  //  GpuProgramPtr& GpuProgramPtr::operator=(const HighLevelGpuProgramPtr& r)
-  //  {
-  //      // Can assign direct
-  //      if (pRep == 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 = 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;
-  //  }
+
+    //-----------------------------------------------------------------------
+    GpuProgramPtr& GpuProgramPtr::operator=(const HighLevelGpuProgramPtr& r)
+    {
+        // Can assign direct
+        if (pRep == 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 = 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;
+    }
 
 }
 

CamelotRenderer/OgreGpuProgram.h

@@ -433,9 +433,8 @@ namespace Ogre {
 		explicit GpuProgramPtr(GpuProgram* rep) : SharedPtr<GpuProgram>(rep) {}
 		GpuProgramPtr(const GpuProgramPtr& r) : SharedPtr<GpuProgram>(r) {} 
 
-		// TODO PORT - I've hidden this cast until it will be needed
-        ///// Operator used to convert a HighLevelGpuProgramPtr to a GpuProgramPtr
-        //GpuProgramPtr& operator=(const HighLevelGpuProgramPtr& r);
+        /// Operator used to convert a HighLevelGpuProgramPtr to a GpuProgramPtr
+        GpuProgramPtr& operator=(const HighLevelGpuProgramPtr& r);
 	};
 	/** @} */
 	/** @} */

CamelotRenderer/OgreHardwareOcclusionQuery.cpp

@@ -0,0 +1,44 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org
+
+Copyright (c) 2000-2011 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.
+-----------------------------------------------------------------------------
+*/
+
+#include "OgreHardwareOcclusionQuery.h"
+
+namespace Ogre {
+
+
+    HardwareOcclusionQuery::HardwareOcclusionQuery() : 
+        mPixelCount(0),
+        mIsQueryResultStillOutstanding(false)
+    {
+    }
+    HardwareOcclusionQuery::~HardwareOcclusionQuery()
+    {
+    }
+
+}
+

CamelotRenderer/OgreHardwareOcclusionQuery.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-2011 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 _HardwareOcclusionQuery__
+#define _HardwareOcclusionQuery__
+
+// Precompiler options
+#include "OgrePrerequisites.h"
+
+namespace Ogre {
+
+
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup RenderSystem
+	*  @{
+	*/
+/**
+  * This is a abstract class that that provides the interface for the query class for 
+  * hardware occlusion.
+  *
+  * @author Lee Sandberg
+  * Updated on 13/8/2005 by Tuan Kuranes email: [email protected]
+  */
+	class _OgreExport HardwareOcclusionQuery
+{
+//----------------------------------------------------------------------
+// Public methods
+//--
+public:
+	/**
+	  * Object public member functions
+	  */
+
+	/**
+	  * Default object constructor
+	  * 
+	  */
+	HardwareOcclusionQuery();
+
+	/**
+	  * Object destructor
+	  */
+	virtual ~HardwareOcclusionQuery();
+
+	/**
+	  * Starts the hardware occlusion query
+	  * @Remarks	Simple usage: Create one or more OcclusionQuery object one per outstanding query or one per tested object 
+	  *				OcclusionQuery* m_pOcclusionQuery;
+	  *				createOcclusionQuery( &m_pOcclusionQuery );
+	  *				In the rendering loop:
+	  *				Draw all occluders
+	  *				m_pOcclusionQuery->startOcclusionQuery();
+	  *				Draw the polygons to be tested
+	  *				m_pOcclusionQuery->endOcclusionQuery();
+	  *
+	  *				Results must be pulled using:
+	  *				UINT	m_uintNumberOfPixelsVisable;
+	  *				pullOcclusionQuery( &m_dwNumberOfPixelsVisable );
+	  *			
+	  */
+	virtual void beginOcclusionQuery() = 0;
+
+	/**
+	  * Ends the hardware occlusion test
+	  */
+	virtual void endOcclusionQuery() = 0;
+
+	/**
+      * Pulls the hardware occlusion query.
+	  * @note Waits until the query result is available; use isStillOutstanding
+	  *		if just want to test if the result is available.
+      * @retval NumOfFragments will get the resulting number of fragments.
+      * @return True if success or false if not.
+      */
+	virtual bool pullOcclusionQuery(unsigned int* NumOfFragments) = 0;
+
+	/**
+	  * Let's you get the last pixel count with out doing the hardware occlusion test
+	  * @return The last fragment count from the last test.
+	  * Remarks This function won't give you new values, just the old value.
+	  */
+	unsigned int getLastQuerysPixelcount() const { return mPixelCount; }
+
+	/**
+	  * Lets you know when query is done, or still be processed by the Hardware
+	  * @return true if query isn't finished.
+	  */
+	 virtual bool isStillOutstanding(void) = 0; 
+
+
+    //----------------------------------------------------------------------
+    // protected members
+    //--
+    protected :
+        // numbers of visible pixels determined by last query
+        unsigned int mPixelCount;
+        // is query hasn't yet returned a result.
+		bool		 mIsQueryResultStillOutstanding;
+};
+
+	/** @} */
+	/** @} */
+}
+#endif
+

CamelotRenderer/OgreHighLevelGpuProgram.cpp

@@ -0,0 +1,209 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2011 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.
+-----------------------------------------------------------------------------
+*/
+#include "OgreHighLevelGpuProgram.h"
+#include "OgreException.h"
+
+namespace Ogre
+{
+    //---------------------------------------------------------------------------
+    HighLevelGpuProgram::HighLevelGpuProgram()
+        : GpuProgram(), 
+        mHighLevelLoaded(false), mAssemblerProgram(0), mConstantDefsBuilt(false)
+    {
+    }
+    //---------------------------------------------------------------------------
+    void HighLevelGpuProgram::loadImpl()
+    {
+		if (isSupported())
+		{
+			// load self 
+			loadHighLevel();
+
+			// create low-level implementation
+			createLowLevelImpl();
+
+		}
+    }
+    //---------------------------------------------------------------------------
+    void HighLevelGpuProgram::unloadImpl()
+    {   
+        if (!mAssemblerProgram.isNull() && mAssemblerProgram.getPointer() != this)
+        {
+            mAssemblerProgram.setNull();
+        }
+
+        unloadHighLevel();
+		resetCompileError();
+    }
+    //---------------------------------------------------------------------------
+    HighLevelGpuProgram::~HighLevelGpuProgram()
+    {
+        // superclasses will trigger unload
+    }
+    //---------------------------------------------------------------------------
+    GpuProgramParametersSharedPtr HighLevelGpuProgram::createParameters(void)
+    {
+		// Lock mutex before allowing this since this is a top-level method
+		// called outside of the load()
+		OGRE_LOCK_AUTO_MUTEX
+
+        // Make sure param defs are loaded
+        GpuProgramParametersSharedPtr params = GpuProgramParametersSharedPtr(OGRE_NEW GpuProgramParameters());
+		// Only populate named parameters if we can support this program
+		if (this->isSupported())
+		{
+			loadHighLevel();
+			// Errors during load may have prevented compile
+			if (this->isSupported())
+			{
+				populateParameterNames(params);
+			}
+		}
+		// Copy in default parameters if present
+		if (!mDefaultParams.isNull())
+			params->copyConstantsFrom(*(mDefaultParams.get()));
+        return params;
+    }
+    //---------------------------------------------------------------------------
+    void HighLevelGpuProgram::loadHighLevel(void)
+    {
+        if (!mHighLevelLoaded)
+        {
+			try 
+			{
+				loadHighLevelImpl();
+				mHighLevelLoaded = true;
+				if (!mDefaultParams.isNull())
+				{
+					// Keep a reference to old ones to copy
+					GpuProgramParametersSharedPtr savedParams = mDefaultParams;
+					// reset params to stop them being referenced in the next create
+					mDefaultParams.setNull();
+
+					// Create new params
+					mDefaultParams = createParameters();
+
+					// Copy old (matching) values across
+					// Don't use copyConstantsFrom since program may be different
+					mDefaultParams->copyMatchingNamedConstantsFrom(*savedParams.get());
+
+				}
+
+			}
+			catch (const Exception& e)
+			{
+				//// will already have been logged
+				//LogManager::getSingleton().stream()
+				//	<< "High-level program " << mName << " encountered an error "
+				//	<< "during loading and is thus not supported.\n"
+				//	<< e.getFullDescription();
+
+				mCompileError = true;
+			}
+        }
+    }
+    //---------------------------------------------------------------------------
+    void HighLevelGpuProgram::unloadHighLevel(void)
+    {
+        if (mHighLevelLoaded)
+        {
+            unloadHighLevelImpl();
+			// Clear saved constant defs
+			mConstantDefsBuilt = false;
+			createParameterMappingStructures(true);
+
+            mHighLevelLoaded = false;
+        }
+    }
+    //---------------------------------------------------------------------------
+    void HighLevelGpuProgram::loadHighLevelImpl(void)
+    {
+        if (mLoadFromFile)
+        {
+            //// find & load source code
+            //DataStreamPtr stream = 
+            //    ResourceGroupManager::getSingleton().openResource(
+            //        mFilename, mGroup, true, this);
+
+            //mSource = stream->getAsString();
+        }
+
+        loadFromSource();
+
+
+    }
+	//---------------------------------------------------------------------
+	const GpuNamedConstants& HighLevelGpuProgram::getConstantDefinitions() const
+	{
+		if (!mConstantDefsBuilt)
+		{
+			buildConstantDefinitions();
+			mConstantDefsBuilt = true;
+		}
+		return *mConstantDefs.get();
+
+	}
+	//---------------------------------------------------------------------
+	void HighLevelGpuProgram::populateParameterNames(GpuProgramParametersSharedPtr params)
+	{
+		getConstantDefinitions();
+		params->_setNamedConstants(mConstantDefs);
+		// also set logical / physical maps for programs which use this
+		params->_setLogicalIndexes(mFloatLogicalToPhysical, mIntLogicalToPhysical);
+	}
+	//-----------------------------------------------------------------------
+	//-----------------------------------------------------------------------
+	HighLevelGpuProgramPtr& HighLevelGpuProgramPtr::operator=(const GpuProgramPtr& r)
+	{
+		// Can assign direct
+		if (pRep == static_cast<HighLevelGpuProgram*>(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<HighLevelGpuProgram*>(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;
+	}
+
+
+}

CamelotRenderer/OgreHighLevelGpuProgram.h

@@ -0,0 +1,152 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2011 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 __HighLevelGpuProgram_H__
+#define __HighLevelGpuProgram_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreGpuProgram.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Resources
+	*  @{
+	*/
+	/** Abstract base class representing a high-level program (a vertex or
+        fragment program).
+    @remarks
+        High-level programs are vertex and fragment programs written in a high-level
+        language such as Cg or HLSL, and as such do not require you to write assembler code
+        like GpuProgram does. However, the high-level program does eventually 
+        get converted (compiled) into assembler and then eventually microcode which is
+        what runs on the GPU. As well as the convenience, some high-level languages like Cg allow
+        you to write a program which will operate under both Direct3D and OpenGL, something
+        which you cannot do with just GpuProgram (which requires you to write 2 programs and
+        use each in a Technique to provide cross-API compatibility). Ogre will be creating
+        a GpuProgram for you based on the high-level program, which is compiled specifically 
+        for the API being used at the time, but this process is transparent.
+    @par
+        You cannot create high-level programs direct - use HighLevelGpuProgramManager instead.
+        Plugins can register new implementations of HighLevelGpuProgramFactory in order to add
+        support for new languages without requiring changes to the core Ogre API. To allow 
+        custom parameters to be set, this class extends StringInterface - the application
+        can query on the available custom parameters and get/set them without having to 
+        link specifically with it.
+    */
+    class _OgreExport HighLevelGpuProgram : public GpuProgram
+    {
+    protected:
+        /// Whether the high-level program (and it's parameter defs) is loaded
+        bool mHighLevelLoaded;
+        /// The underlying assembler program
+        GpuProgramPtr mAssemblerProgram;
+		/// Have we built the name->index parameter map yet?
+		mutable bool mConstantDefsBuilt;
+
+        /// Internal load high-level portion if not loaded
+        virtual void loadHighLevel(void);
+        /// Internal unload high-level portion if loaded
+        virtual void unloadHighLevel(void);
+        /** Internal load implementation, loads just the high-level portion, enough to 
+            get parameters.
+        */
+        virtual void loadHighLevelImpl(void);
+        /** Internal method for creating an appropriate low-level program from this
+        high-level program, must be implemented by subclasses. */
+        virtual void createLowLevelImpl(void) = 0;
+        /// Internal unload implementation, must be implemented by subclasses
+        virtual void unloadHighLevelImpl(void) = 0;
+        /// Populate the passed parameters with name->index map
+        virtual void populateParameterNames(GpuProgramParametersSharedPtr params);
+		/** Build the constant definition map, must be overridden.
+		@note The implementation must fill in the (inherited) mConstantDefs field at a minimum, 
+			and if the program requires that parameters are bound using logical 
+			parameter indexes then the mFloatLogicalToPhysical and mIntLogicalToPhysical
+			maps must also be populated.
+		*/
+		virtual void buildConstantDefinitions() const = 0;
+
+        /** @copydoc Resource::loadImpl */
+        void loadImpl();
+        /** @copydoc Resource::unloadImpl */
+        void unloadImpl();
+    public:
+        /** Constructor, should be used only by factory classes. */
+        HighLevelGpuProgram();
+        ~HighLevelGpuProgram();
+
+
+        /** Creates a new parameters object compatible with this program definition. 
+        @remarks
+            Unlike low-level assembly programs, parameters objects are specific to the
+            program and therefore must be created from it rather than by the 
+            HighLevelGpuProgramManager. This method creates a new instance of a parameters
+            object containing the definition of the parameters this program understands.
+        */
+        GpuProgramParametersSharedPtr createParameters(void);
+        /** @copydoc GpuProgram::getBindingDelegate */
+        GpuProgram* _getBindingDelegate(void) { return mAssemblerProgram.getPointer(); }
+
+		/** Get the full list of GpuConstantDefinition instances.
+		@note
+		Only available if this parameters object has named parameters.
+		*/
+		const GpuNamedConstants& getConstantDefinitions() const;
+
+		/// Override GpuProgram::getNamedConstants to ensure built
+		const GpuNamedConstants& getNamedConstants() const { return getConstantDefinitions(); }
+
+
+
+
+
+    };
+
+    /** Specialisation of SharedPtr to allow SharedPtr to be assigned to HighLevelGpuProgramPtr 
+    @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 HighLevelGpuProgramPtr : public SharedPtr<HighLevelGpuProgram> 
+    {
+    public:
+        HighLevelGpuProgramPtr() : SharedPtr<HighLevelGpuProgram>() {}
+        explicit HighLevelGpuProgramPtr(HighLevelGpuProgram* rep) : SharedPtr<HighLevelGpuProgram>(rep) {}
+        HighLevelGpuProgramPtr(const HighLevelGpuProgramPtr& r) : SharedPtr<HighLevelGpuProgram>(r) {} 
+
+		/// Operator used to convert a GpuProgramPtr to a HighLevelGpuProgramPtr
+		HighLevelGpuProgramPtr& operator=(const GpuProgramPtr& r);
+    };
+	/** @} */
+	/** @} */
+
+}
+#endif