ruby-ogre 0.0.5-x86-linux → 0.1.0-x86-linux

data/deps/include/OGRE/OgreHeaderPrefix.h

@@ -1,82 +0,0 @@
-/*-------------------------------------------------------------------------
-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
--------------------------------------------------------------------------*/
-#ifndef __OgreHeaderPrefix_H__
-#define __OgreHeaderPrefix_H__
-
-#include "OgrePrerequisites.h"
-
-#if OGRE_COMPILER == OGRE_COMPILER_MSVC
-
-// Save warnings state
-#   pragma warning (push)
-// Turn off warnings generated by long std templates
-// This warns about truncation to 255 characters in debug/browse info
-#   pragma warning (disable : 4786)
-
-// Turn off warnings generated by long std templates
-// This warns about truncation to 255 characters in debug/browse info
-#   pragma warning (disable : 4503)
-
-// disable: "<type> needs to have dll-interface to be used by clients'
-// Happens on STL member variables which are not public therefore is ok
-#   pragma warning (disable : 4251)
-
-// disable: "non dll-interface class used as base for dll-interface class"
-// Happens when deriving from Singleton because bug in compiler ignores
-// template export
-#   pragma warning (disable : 4275)
-
-// disable: "C++ Exception Specification ignored"
-// This is because MSVC 6 did not implement all the C++ exception
-// specifications in the ANSI C++ draft.
-#   pragma warning( disable : 4290 )
-
-// disable: "no suitable definition provided for explicit template
-// instantiation request" Occurs in VC7 for no justifiable reason on all
-// #includes of Singleton
-#   pragma warning( disable: 4661)
-
-// disable: deprecation warnings when using CRT calls in VC8
-// These show up on all C runtime lib code in VC8, disable since they clutter
-// the warnings with things we may not be able to do anything about (e.g.
-// generated code from nvparse etc). I doubt very much that these calls
-// will ever be actually removed from VC anyway, it would break too much code.
-#	pragma warning( disable: 4996)
-
-// disable: "conditional expression constant", always occurs on 
-// OGRE_MUTEX_CONDITIONAL when no threading enabled
-#   pragma warning (disable : 201)
-
-// disable: "unreferenced formal parameter"
-// Many versions of VC have bugs which generate this error in cases where they shouldn't
-#   pragma warning (disable : 4100)
-
-#endif
-
-
-#endif
-
-

data/deps/include/OGRE/OgreHeaderSuffix.h

@@ -1,44 +0,0 @@
-/*-------------------------------------------------------------------------
-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
--------------------------------------------------------------------------*/
-#ifndef __OgreHeaderSuffix_H__
-#define __OgreHeaderSuffix_H__
-
-#include "OgrePrerequisites.h"
-
-#if OGRE_COMPILER == OGRE_COMPILER_MSVC
-
-// restore previous warnings settings
-#   pragma warning (pop)
-
-
-#endif
-
-
-#endif
-// allow inclusion of prefix again now (this is scoped)
-#undef __OgreHeaderSuffix_H__
-
-

data/deps/include/OGRE/OgreHighLevelGpuProgram.h

@@ -1,194 +0,0 @@
-/*
------------------------------------------------------------------------------
-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 __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(ResourceManager* creator, const String& name, ResourceHandle handle,
-            const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
-        ~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) {} 
-        HighLevelGpuProgramPtr(const ResourcePtr& r) : SharedPtr<HighLevelGpuProgram>()
-        {
-			// 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);
-                }
-            }
-        }
-
-        /// Operator used to convert a ResourcePtr to a HighLevelGpuProgramPtr
-        HighLevelGpuProgramPtr& operator=(const ResourcePtr& r)
-        {
-            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;
-        }
-		/// Operator used to convert a GpuProgramPtr to a HighLevelGpuProgramPtr
-		HighLevelGpuProgramPtr& operator=(const GpuProgramPtr& r);
-    };
-	/** @} */
-	/** @} */
-
-}
-#endif

data/deps/include/OGRE/OgreHighLevelGpuProgramManager.h

@@ -1,158 +0,0 @@
-/*
------------------------------------------------------------------------------
-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 __HighLevelGpuProgramManager_H__
-#define __HighLevelGpuProgramManager_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreResourceManager.h"
-#include "OgreSingleton.h"
-#include "OgreException.h"
-#include "OgreHighLevelGpuProgram.h"
-
-namespace Ogre {
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Resources
-	*  @{
-	*/
-	/** Interface definition for factories of HighLevelGpuProgram. */
-	class _OgreExport HighLevelGpuProgramFactory : public FactoryAlloc
-	{
-	public:
-        HighLevelGpuProgramFactory() {}
-        virtual ~HighLevelGpuProgramFactory();
-		/// Get the name of the language this factory creates programs for
-		virtual const String& getLanguage(void) const = 0;
-        virtual HighLevelGpuProgram* create(ResourceManager* creator, 
-            const String& name, ResourceHandle handle,
-            const String& group, bool isManual, ManualResourceLoader* loader) = 0;
-		virtual void destroy(HighLevelGpuProgram* prog) = 0;
-	};
-	/** This ResourceManager manages high-level vertex and fragment programs. 
-	@remarks
-		High-level vertex and fragment programs can be used instead of assembler programs
-		as managed by GpuProgramManager; however they typically result in a GpuProgram
-		being created as a derivative of the high-level program. High-level programs are
-		easier to write, and can often be API-independent, unlike assembler programs. 
-	@par
-		This class not only manages the programs themselves, it also manages the factory
-		classes which allow the creation of high-level programs using a variety of high-level
-		syntaxes. Plugins can be created which register themselves as high-level program
-		factories and as such the engine can be extended to accept virtually any kind of
-		program provided a plugin is written.
-	*/
-	class _OgreExport HighLevelGpuProgramManager 
-		: public ResourceManager, public Singleton<HighLevelGpuProgramManager>
-	{
-	public:
-		typedef map<String, HighLevelGpuProgramFactory*>::type FactoryMap;
-	protected:
-		/// Factories capable of creating HighLevelGpuProgram instances
-		FactoryMap mFactories;
-
-		/// Factory for dealing with programs for languages we can't create
-		HighLevelGpuProgramFactory* mNullFactory;
-		/// Factory for unified high-level programs
-		HighLevelGpuProgramFactory* mUnifiedFactory;
-
-		HighLevelGpuProgramFactory* getFactory(const String& language);
-
-        /// @copydoc ResourceManager::createImpl
-        Resource* createImpl(const String& name, ResourceHandle handle, 
-            const String& group, bool isManual, ManualResourceLoader* loader,
-            const NameValuePairList* params);
-	public:
-		HighLevelGpuProgramManager();
-		~HighLevelGpuProgramManager();
-		/** Add a new factory object for high-level programs of a given language. */
-		void addFactory(HighLevelGpuProgramFactory* factory);
-		/** Remove a factory object for high-level programs of a given language. */
-		void removeFactory(HighLevelGpuProgramFactory* factory);
-
-		/** Returns whether a given high-level language is supported. */
-		bool isLanguageSupported(const String& lang);
-
-
-        /** Create a new, unloaded HighLevelGpuProgram. 
-		@par
-			This method creates a new program of the type specified as the second and third parameters.
-			You will have to call further methods on the returned program in order to 
-			define the program fully before you can load it.
-		@param name The identifying name of the program
-        @param groupName The name of the resource group which this program is
-            to be a member of
-		@param language Code of the language to use (e.g. "cg")
-		@param gptype The type of program to create
-		*/
-		HighLevelGpuProgramPtr createProgram(
-			const String& name, const String& groupName, 
-            const String& language, GpuProgramType gptype);
-
-        /** 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 HighLevelGpuProgramManager& 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 HighLevelGpuProgramManager* getSingletonPtr(void);
-
-
-	};
-	/** @} */
-	/** @} */
-
-}
-
-#endif