ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/Terrain/OgreTerrainLayerBlendMap.h

@@ -0,0 +1,199 @@
+/*
+-----------------------------------------------------------------------------
+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 __Ogre_TerrainLayerBlendMap_H__
+#define __Ogre_TerrainLayerBlendMap_H__
+
+#include "OgreTerrainPrerequisites.h"
+#include "OgreCommon.h"
+#include "OgreVector3.h"
+#include "OgreDataStream.h"
+
+namespace Ogre
+{
+	class Image;
+	/** \addtogroup Optional Components
+	*  @{
+	*/
+	/** \addtogroup Terrain
+	*  Some details on the terrain component
+	*  @{
+	*/
+
+
+	/** Class exposing an interface to a blend map for a given layer. 
+	Each layer after the first layer in a terrain has a blend map which 
+	expresses how it is alpha blended with the layers beneath. Internally, this
+	blend map is packed into one channel of an RGB or RGBA texture in
+	order to use the smallest number of samplers, but this class allows
+	a caller to manipulate the data more easily without worrying about
+	this packing. Also, the values you use to interact with the blend map are
+	floating point, which gives you full precision for updating, but in fact the
+	values are packed into 8-bit integers in the actual blend map.
+	@par
+	You shouldn't construct this class directly, use Terrain::getLayerBlendMap().
+	*/
+	class _OgreTerrainExport TerrainLayerBlendMap : public TerrainAlloc
+	{
+	protected:
+		Terrain* mParent;
+		uint8 mLayerIdx;
+		uint8 mChannel; // RGBA
+		uint8 mChannelOffset; // in pixel format
+		Box mDirtyBox;
+		bool mDirty;
+		HardwarePixelBuffer* mBuffer;
+		float* mData;
+
+		void download();
+		void upload();
+
+	public:
+		/** Constructor
+		@param parent The parent terrain
+		@param layerIndex The layer index (should be 1 or higher)
+		@param box The region of the blend map to address (in image space)
+		@param buf The buffer holding the data
+		*/
+		TerrainLayerBlendMap(Terrain* parent, uint8 layerIndex, HardwarePixelBuffer* buf);
+		~TerrainLayerBlendMap();
+		/// Get the parent terrain
+		Terrain* getParent() const { return mParent; }
+		/// Get the index of the layer this is targeting
+		uint8 getLayerIndex() const { return mLayerIdx; }
+
+		/** Helper method - convert a point in world space to UV space based on the
+			terrain settings.
+		@param worldPos World position
+		@param outX, outY Pointers to variables which will be filled in with the
+			local UV space value. Note they are deliberately signed Real values, because the
+			point you supply may be outside of image space and may be between texels.
+			The values will range from 0 to 1, top/bottom, left/right.
+		*/
+		void convertWorldToUVSpace(const Vector3& worldPos, Real *outX, Real* outY);
+
+		/** Helper method - convert a point in local space to worldspace based on the
+			terrain settings.
+		@param x,y Local position, ranging from 0 to 1, top/bottom, left/right.
+		@param outWorldPos Pointer will be filled in with the world space value
+		*/
+		void convertUVToWorldSpace(Real x, Real y, Vector3* outWorldPos);
+
+		/** Convert local space values (0,1) to image space (0, imageSize).
+		*/
+		void convertUVToImageSpace(Real x, Real y, size_t* outX, size_t* outY);
+		/** Convert image space (0, imageSize) to local space values (0,1).
+		*/
+		void convertImageToUVSpace(size_t x, size_t y, Real* outX, Real* outY);
+		/** Convert image space (0, imageSize) to terrain space values (0,1).
+		*/
+		void convertImageToTerrainSpace(size_t x, size_t y, Real* outX, Real* outY);
+		/** Convert terrain space values (0,1) to image space (0, imageSize).
+		*/
+		void convertTerrainToImageSpace(Real x, Real y, size_t* outX, size_t* outY);
+
+		/** Get a single value of blend information, in image space.
+		@param x,y Coordinates of the point of data to get, in image space (top down)
+		@return The blend data
+		*/
+		float getBlendValue(size_t x, size_t y);
+
+		/** Set a single value of blend information (0 = transparent, 255 = solid)
+		@param x,y Coordinates of the point of data to get, in image space (top down)
+		@param val The blend value to set (0..1)
+		*/
+		void setBlendValue(size_t x, size_t y, float val);
+
+		/** Get a pointer to the whole blend data. 
+		@remarks
+			This method allows you to get a raw pointer to all the blend data, to 
+			update it as you like. However, you must then call dirtyRect manually 
+			if you want those changes to be recognised. 
+		*/
+		float* getBlendPointer();
+
+		/** Indicate that all of the blend data is dirty and needs updating.
+		*/
+		void dirty();
+
+		/** Indicate that a portion of the blend data is dirty and needs updating.
+		@param rect Rectangle in image space
+		*/
+		void dirtyRect(const Rect& rect);
+
+		/** Blits a set of values into a region on the blend map. 
+		   	@param src		PixelBox containing the source pixels and format 
+		   	@param dstBox	Image::Box describing the destination region in this map
+            @remarks The source and destination regions dimensions don't have to match, in which
+            case scaling is done. 
+			@note You can call this method in a background thread if you want.
+				You still need to call update() to commit the changes to the GPU. 
+		*/
+		void blit(const PixelBox &src, const Box &dstBox);
+		
+		/** Blits a set of values into the entire map. The source data is scaled if needed.
+			@param src		PixelBox containing the source pixels and format
+			@note You can call this method in a background thread if you want.
+				You still need to call update() to commit the changes to the GPU. 
+				
+		*/
+		void blit(const PixelBox &src);
+
+		/** Load an image into this blend layer. 
+		*/
+		void loadImage(const Image& img);
+
+		/** Load an image into this blend layer. 
+		@param stream Stream containing the image data
+		@param ext Extension identifying the image type, if the stream data doesn't identify
+		*/
+		void loadImage(DataStreamPtr& stream, const String& ext = StringUtil::BLANK);
+
+		/** Load an image into this blend layer. 
+		*/
+		void loadImage(const String& filename, const String& groupName);
+
+		/** Publish any changes you made to the blend data back to the blend map. 
+		@note
+			Can only be called in the main render thread.
+		*/
+		void update();
+
+
+	};
+
+	typedef vector<TerrainLayerBlendMap*>::type TerrainLayerBlendMapList;
+
+	/** @} */
+	/** @} */
+
+}
+
+
+
+#endif

data/deps/include/OGRE/Terrain/OgreTerrainMaterialGenerator.h

@@ -0,0 +1,404 @@
+/*
+-----------------------------------------------------------------------------
+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 __Ogre_TerrainMaterialGenerator_H__
+#define __Ogre_TerrainMaterialGenerator_H__
+
+#include "OgreTerrainPrerequisites.h"
+#include "OgrePixelFormat.h"
+#include "OgreMaterial.h"
+#include "OgreTexture.h"
+
+namespace Ogre
+{
+	class Terrain;
+
+	/** \addtogroup Optional Components
+	*  @{
+	*/
+	/** \addtogroup Terrain
+	*  Some details on the terrain component
+	*  @{
+	*/
+
+
+	/** Enumeration of types of data that can be read from textures that are
+	specific to a given layer. Notice that global texture information 
+	such as shadows and terrain normals are not represented
+	here because they are not a per-layer attribute, and blending
+	is stored in packed texture structures which are stored separately.
+	*/
+	enum TerrainLayerSamplerSemantic
+	{
+		/// Albedo colour (diffuse reflectance colour)
+		TLSS_ALBEDO = 0,
+		/// Tangent-space normal information from a detail texture
+		TLSS_NORMAL = 1,
+		/// Height information for the detail texture
+		TLSS_HEIGHT = 2,
+		/// Specular reflectance
+		TLSS_SPECULAR = 3
+	};
+
+	/** Information about one element of a sampler / texture within a layer. 
+	*/
+	struct _OgreTerrainExport TerrainLayerSamplerElement
+	{
+		/// The source sampler index of this element relative to LayerDeclaration's list
+		uint8 source;
+		/// The semantic this element represents
+		TerrainLayerSamplerSemantic semantic;
+		/// The colour element at which this element starts
+		uint8 elementStart;
+		/// The number of colour elements this semantic uses (usually standard per semantic)
+		uint8 elementCount;
+
+		bool operator==(const TerrainLayerSamplerElement& e) const
+		{
+			return source == e.source &&
+				semantic == e.semantic &&
+				elementStart == e.elementStart &&
+				elementCount == e.elementCount;
+		}
+
+		TerrainLayerSamplerElement() {}
+		TerrainLayerSamplerElement(uint8 src, TerrainLayerSamplerSemantic sem,
+			uint8 elemStart, uint8 elemCount)
+			: source(src), semantic(sem), elementStart(elemStart), elementCount(elemCount)
+		{
+		}
+	};
+	typedef vector<TerrainLayerSamplerElement>::type TerrainLayerSamplerElementList;
+
+	/** Description of a sampler that will be used with each layer. 
+	*/
+	struct _OgreTerrainExport TerrainLayerSampler
+	{
+		/// A descriptive name that is merely used to assist in recognition
+		String alias;
+		/// The format required of this texture
+		PixelFormat format;
+
+		bool operator==(const TerrainLayerSampler& s) const
+		{
+			return alias == s.alias && format == s.format;
+		}
+
+		TerrainLayerSampler() {}
+
+		TerrainLayerSampler(const String& aliasName, PixelFormat fmt)
+			: alias(aliasName), format(fmt)
+		{
+		}
+	};
+	typedef vector<TerrainLayerSampler>::type TerrainLayerSamplerList;
+
+	/** The definition of the information each layer will contain in this terrain.
+	All layers must contain the same structure of information, although the
+	input textures can be different per layer instance. 
+	*/
+	struct _OgreTerrainExport TerrainLayerDeclaration
+	{
+		TerrainLayerSamplerList samplers;
+		TerrainLayerSamplerElementList elements;
+
+		bool operator==(const TerrainLayerDeclaration& dcl) const
+		{
+			return samplers == dcl.samplers && elements == dcl.elements;
+		}
+	};
+
+	/** Class that provides functionality to generate materials for use with a terrain.
+	@remarks
+		Terrains are composed of one or more layers of texture information, and
+		require that a material is generated to render them. There are various approaches
+		to rendering the terrain, which may vary due to:
+		<ul><li>Hardware support (static)</li>
+		<li>Texture instances assigned to a particular terrain (dynamic in an editor)</li>
+		<li>User selection (e.g. changing to a cheaper option in order to increase performance, 
+		or in order to test how the material might look on other hardware (dynamic)</li>
+		</ul>
+		Subclasses of this class are responsible for responding to these factors and
+		to generate a terrain material. 
+		@par
+		In order to cope with both hardware support and user selection, the generator
+		must expose a number of named 'profiles'. These profiles should function on
+		a known range of hardware, and be graded by quality. At runtime, the user 
+		should be able to select the profile they wish to use (provided hardware
+		support is available). 
+	*/
+	class _OgreTerrainExport TerrainMaterialGenerator : public TerrainAlloc
+	{
+	public:
+		/** Inner class which should also be subclassed to provide profile-specific 
+			material generation.
+		*/
+		class _OgreTerrainExport Profile : public TerrainAlloc
+		{
+		protected:
+			TerrainMaterialGenerator* mParent;
+			String mName;
+			String mDesc;
+		public:
+			Profile(TerrainMaterialGenerator* parent, const String& name, const String& desc)
+				: mParent(parent), mName(name), mDesc(desc) {}
+			Profile(const Profile& prof) 
+				: mParent(prof.mParent), mName(prof.mName), mDesc(prof.mDesc) {}
+			virtual ~Profile() {}
+			/// Get the generator which owns this profile
+			TerrainMaterialGenerator* getParent() const { return mParent; }
+			/// Get the name of this profile
+			const String& getName() const { return mName; }
+			/// Get the description of this profile
+			const String& getDescription() const { return mDesc; }
+			/// Compressed vertex format supported?
+			virtual bool isVertexCompressionSupported() const = 0;		
+			/// Generate / resuse a material for the terrain
+			virtual MaterialPtr generate(const Terrain* terrain) = 0;
+			/// Generate / resuse a material for the terrain
+			virtual MaterialPtr generateForCompositeMap(const Terrain* terrain) = 0;
+			/// Get the number of layers supported
+			virtual uint8 getMaxLayers(const Terrain* terrain) const = 0;
+			/// Update the composite map for a terrain
+			virtual void updateCompositeMap(const Terrain* terrain, const Rect& rect);
+
+			/// Update params for a terrain
+			virtual void updateParams(const MaterialPtr& mat, const Terrain* terrain) = 0;
+			/// Update params for a terrain
+			virtual void updateParamsForCompositeMap(const MaterialPtr& mat, const Terrain* terrain) = 0;
+
+			/// Request the options needed from the terrain
+			virtual void requestOptions(Terrain* terrain) = 0;
+
+		};
+
+		TerrainMaterialGenerator();
+		virtual ~TerrainMaterialGenerator();
+
+		/// List of profiles - NB should be ordered in descending complexity
+		typedef vector<Profile*>::type ProfileList;
+	
+		/** Get the list of profiles that this generator supports.
+		*/
+		virtual const ProfileList& getProfiles() const { return mProfiles; }
+
+		/** Set the active profile by name. */
+		virtual void setActiveProfile(const String& name)
+		{
+			if (!mActiveProfile || mActiveProfile->getName() != name)
+			{
+				for (ProfileList::iterator i = mProfiles.begin(); i != mProfiles.end(); ++i)
+				{
+					if ((*i)->getName() == name)
+					{
+						setActiveProfile(*i);
+						break;
+					}
+				}
+			}
+
+		}
+
+		/** Set the active Profile. */
+		virtual void setActiveProfile(Profile* p)
+		{
+			if (mActiveProfile != p)
+			{
+				mActiveProfile = p;
+				_markChanged();
+			}
+		}
+		/// Get the active profile
+		Profile* getActiveProfile() const 
+		{ 
+			// default if not chosen yet
+			if (!mActiveProfile && !mProfiles.empty())
+				mActiveProfile = mProfiles[0];
+
+			return mActiveProfile; 
+		}
+
+		/// Internal method - indicates that a change has been made that would require material regeneration
+		void _markChanged() { ++mChangeCounter; }
+
+		/** Returns the number of times the generator has undergone a change which 
+			would require materials to be regenerated.
+		*/
+		unsigned long long int getChangeCount() const { return mChangeCounter; }
+
+		/** Get the layer declaration that this material generator operates with.
+		*/
+		virtual const TerrainLayerDeclaration& getLayerDeclaration() const { return mLayerDecl; }
+		/** Whether this generator can generate a material for a given declaration. 
+			By default this only returns true if the declaration is equal to the 
+			standard one returned from getLayerDeclaration, but if a subclass wants
+			to be flexible to generate materials for other declarations too, it 
+			can specify here. 
+		*/
+		virtual bool canGenerateUsingDeclaration(const TerrainLayerDeclaration& decl)
+		{
+			return decl == mLayerDecl;
+		}
+		
+		/** Return whether this material generator supports using a compressed
+			vertex format. This is only possible when using shaders.
+		*/
+		virtual bool isVertexCompressionSupported() const
+		{
+			return getActiveProfile()->isVertexCompressionSupported();
+		}
+
+		/** Triggers the generator to request the options that it needs.
+		*/
+		virtual void requestOptions(Terrain* terrain)
+		{
+			Profile* p = getActiveProfile();
+			if (p)
+				p->requestOptions(terrain);
+
+		}
+		/** Generate a material for the given terrain using the active profile.
+		*/
+		virtual MaterialPtr generate(const Terrain* terrain)
+		{
+			Profile* p = getActiveProfile();
+			if (!p)
+				return MaterialPtr();
+			else
+				return p->generate(terrain);
+		}
+		/** Generate a material for the given composite map of the terrain using the active profile.
+		*/
+		virtual MaterialPtr generateForCompositeMap(const Terrain* terrain)
+		{
+			Profile* p = getActiveProfile();
+			if (!p)
+				return MaterialPtr();
+			else
+				return p->generateForCompositeMap(terrain);
+		}
+		/** Get the maximum number of layers supported with the given terrain. 
+		@note When you change the options on the terrain, this value can change. 
+		*/
+		virtual uint8 getMaxLayers(const Terrain* terrain) const
+		{
+			Profile* p = getActiveProfile();
+			if (p)
+				return p->getMaxLayers(terrain);
+			else
+				return 0;
+		}
+
+		/** Update the composite map for a terrain.
+		The composite map for a terrain must match what the terrain should look like
+		at distance. This method will only be called in the render thread so the
+		generator is free to render into a texture to support this, so long as 
+		the results are blitted into the Terrain's own composite map afterwards.
+		*/
+		virtual void updateCompositeMap(const Terrain* terrain, const Rect& rect)
+		{
+			Profile* p = getActiveProfile();
+			if (!p)
+				return;
+			else
+				p->updateCompositeMap(terrain, rect);
+		}
+
+
+		/** Update parameters for the given terrain using the active profile.
+		*/
+		virtual void updateParams(const MaterialPtr& mat, const Terrain* terrain)
+		{
+			Profile* p = getActiveProfile();
+			if (p)
+				p->updateParams(mat, terrain);
+		}
+		/** Update parameters for the given terrain composite map using the active profile.
+		*/
+		virtual void updateParamsForCompositeMap(const MaterialPtr& mat, const Terrain* terrain)
+		{
+			Profile* p = getActiveProfile();
+			if (p)
+				p->updateParamsForCompositeMap(mat, terrain);
+		}
+
+		/** Set the debug level of the material. 
+		@remarks
+			Sets the level of debug display for this material.
+			What this debug level means is entirely depdendent on the generator, 
+			the only constant is that 0 means 'no debug' and non-zero means 
+			'some level of debugging', with any graduations in non-zero values
+			being generator-specific.
+		*/
+		virtual void setDebugLevel(unsigned int dbg)
+		{
+			if (mDebugLevel != dbg)
+			{
+				mDebugLevel = dbg;
+				_markChanged();
+			}
+		}
+		/// Get the debug level of the material. 
+		virtual unsigned int getDebugLevel() const { return mDebugLevel; }
+
+		/** Helper method to render a composite map.
+		@param size The requested composite map size
+		@param rect The region of the composite map to update, in image space
+		@param mat The material to use to render the map
+		@param outBox The box region of the texture which has been updated, and
+			should be copied into your final texture
+		*/
+		virtual void _renderCompositeMap(size_t size, const Rect& rect, 
+			const MaterialPtr& mat, const TexturePtr& destCompositeMap);
+
+		Texture* _getCompositeMapRTT() { return mCompositeMapRTT; }
+	protected:
+
+		ProfileList mProfiles;
+		mutable Profile* mActiveProfile;
+		unsigned long long int mChangeCounter;
+		TerrainLayerDeclaration mLayerDecl;
+		unsigned int mDebugLevel;
+		SceneManager* mCompositeMapSM;
+		Camera* mCompositeMapCam;
+		Texture* mCompositeMapRTT; // deliberately holding this by raw pointer to avoid shutdown issues
+		ManualObject* mCompositeMapPlane;
+		Light* mCompositeMapLight;
+
+
+
+	};
+
+	typedef SharedPtr<TerrainMaterialGenerator> TerrainMaterialGeneratorPtr;
+
+	/** @} */
+	/** @} */
+
+}
+#endif
+