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

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

@@ -1,199 +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 __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

@@ -1,404 +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 __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
-