ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreBillboard.h

@@ -0,0 +1,225 @@
+/*
+-----------------------------------------------------------------------------
+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 __Billboard_H__
+#define __Billboard_H__
+
+#include "OgrePrerequisites.h"
+
+#include "OgreVector3.h"
+#include "OgreColourValue.h"
+#include "OgreCommon.h"
+
+namespace Ogre {
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Effects
+	*  @{
+	*/
+
+    /** A billboard is a primitive which always faces the camera in every frame.
+        @remarks
+            Billboards can be used for special effects or some other trickery which requires the
+            triangles to always facing the camera no matter where it is. Ogre groups billboards into
+            sets for efficiency, so you should never create a billboard on it's own (it's ok to have a
+            set of one if you need it).
+        @par
+            Billboards have their geometry generated every frame depending on where the camera is. It is most
+            beneficial for all billboards in a set to be identically sized since Ogre can take advantage of this and
+            save some calculations - useful when you have sets of hundreds of billboards as is possible with special
+            effects. You can deviate from this if you wish (example: a smoke effect would probably have smoke puffs
+            expanding as they rise, so each billboard will legitimately have it's own size) but be aware the extra
+            overhead this brings and try to avoid it if you can.
+        @par
+            Billboards are just the mechanism for rendering a range of effects such as particles. It is other classes
+            which use billboards to create their individual effects, so the methods here are quite generic.
+        @see
+            BillboardSet
+    */
+
+	class _OgreExport Billboard : public FXAlloc
+    {
+        friend class BillboardSet;
+        friend class BillboardParticleRenderer;
+    protected:
+        bool mOwnDimensions;
+        bool mUseTexcoordRect;
+        uint16 mTexcoordIndex;      // index into the BillboardSet array of texture coordinates
+        FloatRect mTexcoordRect;    // individual texture coordinates
+        Real mWidth;
+        Real mHeight;
+    public:
+        // Note the intentional public access to main internal variables used at runtime
+        // Forcing access via get/set would be too costly for 000's of billboards
+        Vector3 mPosition;
+        // Normalised direction vector
+        Vector3 mDirection;
+        BillboardSet* mParentSet;
+        ColourValue mColour;
+        Radian mRotation;
+
+        /** Default constructor.
+        */
+        Billboard();
+
+        /** Default destructor.
+        */
+        ~Billboard();
+
+        /** Normal constructor as called by BillboardSet.
+        */
+        Billboard(const Vector3& position, BillboardSet* owner, const ColourValue& colour = ColourValue::White);
+
+        /** Get the rotation of the billboard.
+            @remarks
+                This rotation is relative to the center of the billboard.
+        */
+        const Radian& getRotation(void) const { return mRotation; }
+
+        /** Set the rotation of the billboard.
+            @remarks
+                This rotation is relative to the center of the billboard.
+        */
+        void setRotation(const Radian& rotation);
+
+        /** Set the position of the billboard.
+            @remarks
+                This position is relative to a point on the quad which is the billboard. Depending on the BillboardSet,
+                this may be the center of the quad, the top-left etc. See BillboardSet::setBillboardOrigin for more info.
+        */
+        void setPosition(const Vector3& position);
+
+        /** Set the position of the billboard.
+            @remarks
+                This position is relative to a point on the quad which is the billboard. Depending on the BillboardSet,
+                this may be the center of the quad, the top-left etc. See BillboardSet::setBillboardOrigin for more info.
+        */
+        void setPosition(Real x, Real y, Real z);
+
+        /** Get the position of the billboard.
+            @remarks
+                This position is relative to a point on the quad which is the billboard. Depending on the BillboardSet,
+                this may be the center of the quad, the top-left etc. See BillboardSet::setBillboardOrigin for more info.
+        */
+        const Vector3& getPosition(void) const;
+
+        /** Sets the width and height for this billboard.
+            @remarks
+                Note that it is most efficient for every billboard in a BillboardSet to have the same dimensions. If you
+                choose to alter the dimensions of an individual billboard the set will be less efficient. Do not call
+                this method unless you really need to have different billboard dimensions within the same set. Otherwise
+                just call the BillboardSet::setDefaultDimensions method instead.
+        */
+        void setDimensions(Real width, Real height);
+
+        /** Resets this Billboard to use the parent BillboardSet's dimensions instead of it's own. */
+        void resetDimensions(void) { mOwnDimensions = false; }
+        /** Sets the colour of this billboard.
+            @remarks
+                Billboards can be tinted based on a base colour. This allows variations in colour irrespective of the
+                base colour of the material allowing more varied billboards. The default colour is white.
+                The tinting is effected using vertex colours.
+        */
+        void setColour(const ColourValue& colour);
+
+        /** Gets the colour of this billboard.
+        */
+        const ColourValue& getColour(void) const;
+
+        /** Returns true if this billboard deviates from the BillboardSet's default dimensions (i.e. if the
+            Billboard::setDimensions method has been called for this instance).
+            @see
+                Billboard::setDimensions
+        */
+        bool hasOwnDimensions(void) const;
+
+        /** Retrieves the billboard's personal width, if hasOwnDimensions is true. */
+        Real getOwnWidth(void) const;
+
+        /** Retrieves the billboard's personal width, if hasOwnDimensions is true. */
+        Real getOwnHeight(void) const;
+
+        /** Internal method for notifying the billboard of it's owner.
+        */
+        void _notifyOwner(BillboardSet* owner);
+
+        /** Returns true if this billboard use individual texture coordinate rect (i.e. if the 
+            Billboard::setTexcoordRect method has been called for this instance), or returns
+            false if use texture coordinates defined in the parent BillboardSet's texture
+            coordinates array (i.e. if the Billboard::setTexcoordIndex method has been called
+            for this instance).
+            @see
+                Billboard::setTexcoordIndex()
+                Billboard::setTexcoordRect()
+        */
+        bool isUseTexcoordRect(void) const { return mUseTexcoordRect; }
+
+        /** setTexcoordIndex() sets which texture coordinate rect this billboard will use 
+            when rendering. The parent billboard set may contain more than one, in which 
+            case a billboard can be textured with different pieces of a larger texture 
+            sheet very efficiently.
+          @see
+            BillboardSet::setTextureCoords()
+          */
+        void setTexcoordIndex(uint16 texcoordIndex);
+
+        /** getTexcoordIndex() returns the previous value set by setTexcoordIndex(). 
+            The default value is 0, which is always a valid texture coordinate set.
+            @remarks
+                This value is useful only when isUseTexcoordRect return false.
+          */
+        uint16 getTexcoordIndex(void) const { return mTexcoordIndex; }
+
+        /** setTexcoordRect() sets the individual texture coordinate rect of this billboard
+            will use when rendering. The parent billboard set may contain more than one, in
+            which case a billboard can be textured with different pieces of a larger texture
+            sheet very efficiently.
+        */
+        void setTexcoordRect(const FloatRect& texcoordRect);
+
+        /** setTexcoordRect() sets the individual texture coordinate rect of this billboard
+            will use when rendering. The parent billboard set may contain more than one, in
+            which case a billboard can be textured with different pieces of a larger texture
+            sheet very efficiently.
+        */
+        void setTexcoordRect(Real u0, Real v0, Real u1, Real v1);
+
+        /** getTexcoordRect() returns the previous value set by setTexcoordRect(). 
+            @remarks
+                This value is useful only when isUseTexcoordRect return true.
+        */
+        const FloatRect& getTexcoordRect(void) const { return mTexcoordRect; }
+    };
+
+	/** @} */
+	/** @} */
+
+}
+
+#endif

data/deps/include/OGRE/OgreBillboardChain.h

@@ -0,0 +1,383 @@
+/*
+-----------------------------------------------------------------------------
+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.
+-----------------------------------------------------------------------------
+*/
+
+// Thanks to Vincent Cantin (karmaGfa) for the original implementation of this
+// class, although it has now been mostly rewritten
+
+#ifndef _BillboardChain_H__
+#define _BillboardChain_H__
+
+#include "OgrePrerequisites.h"
+
+#include "OgreMovableObject.h"
+#include "OgreRenderable.h"
+#include "OgreResourceGroupManager.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Effects
+	*  @{
+	*/
+
+	/** Allows the rendering of a chain of connected billboards.
+	@remarks
+		A billboard chain operates much like a traditional billboard, i.e. its
+		segments always face the camera; the difference being that instead of
+		a set of disconnected quads, the elements in this class are connected
+		together in a chain which must always stay in a continuous strip. This
+		kind of effect is useful for creating effects such as trails, beams,
+		lightning effects, etc.
+	@par
+		A single instance of this class can actually render multiple separate
+		chain segments in a single render operation, provided they all use the
+		same material. To clarify the terminology: a 'segment' is a separate 
+		sub-part of the chain with its own start and end (called the 'head'
+		and the 'tail'. An 'element' is a single position / colour / texcoord
+		entry in a segment. You can add items to the head of a chain, and 
+		remove them from the tail, very efficiently. Each segment has a max
+		size, and if adding an element to the segment would exceed this size, 
+		the tail element is automatically removed and re-used as the new item
+		on the head.
+	@par
+		This class has no auto-updating features to do things like alter the
+		colour of the elements or to automatically add / remove elements over
+		time - you have to do all this yourself as a user of the class. 
+		Subclasses can however be used to provide this kind of behaviour 
+		automatically. @see RibbonTrail
+	*/
+	class _OgreExport BillboardChain : public MovableObject, public Renderable
+	{
+
+	public:
+
+		/** Contains the data of an element of the BillboardChain.
+		*/
+		class _OgreExport Element
+		{
+
+		public:
+
+			Element();
+
+			Element(const Vector3 &position,
+				Real width,
+				Real texCoord,
+				const ColourValue &colour,
+				const Quaternion &orientation);
+
+			Vector3 position;
+			Real width;
+			/// U or V texture coord depending on options
+			Real texCoord;
+			ColourValue colour;
+
+			//Only used when mFaceCamera == false
+			Quaternion orientation;
+		};
+		typedef vector<Element>::type ElementList;
+
+		/** Constructor (don't use directly, use factory) 
+		@param name The name to give this object
+		@param maxElements The maximum number of elements per chain
+		@param numberOfChains The number of separate chain segments contained in this object
+		@param useTextureCoords If true, use texture coordinates from the chain elements
+		@param useVertexColours If true, use vertex colours from the chain elements
+		@param dynamic If true, buffers are created with the intention of being updated
+		*/
+		BillboardChain(const String& name, size_t maxElements = 20, size_t numberOfChains = 1, 
+			bool useTextureCoords = true, bool useColours = true, bool dynamic = true);
+		/// destructor
+		virtual ~BillboardChain();
+
+		/** Set the maximum number of chain elements per chain 
+		*/
+		virtual void setMaxChainElements(size_t maxElements);
+		/** Get the maximum number of chain elements per chain 
+		*/
+		virtual size_t getMaxChainElements(void) const { return mMaxElementsPerChain; }
+		/** Set the number of chain segments (this class can render multiple chains
+			at once using the same material). 
+		*/
+		virtual void setNumberOfChains(size_t numChains);
+		/** Get the number of chain segments (this class can render multiple chains
+		at once using the same material). 
+		*/
+		virtual size_t getNumberOfChains(void) const { return mChainCount; }
+
+		/** Sets whether texture coordinate information should be included in the
+			final buffers generated.
+		@note You must use either texture coordinates or vertex colour since the
+			vertices have no normals and without one of these there is no source of
+			colour for the vertices.
+		*/
+		virtual void setUseTextureCoords(bool use);
+		/** Gets whether texture coordinate information should be included in the
+			final buffers generated.
+		*/
+		virtual bool getUseTextureCoords(void) const { return mUseTexCoords; }
+
+		/** The direction in which texture coordinates from elements of the
+			chain are used.
+		*/
+		enum TexCoordDirection
+		{
+			/// Tex coord in elements is treated as the 'u' texture coordinate
+			TCD_U,
+			/// Tex coord in elements is treated as the 'v' texture coordinate
+			TCD_V
+		};
+		/** Sets the direction in which texture coords specified on each element
+			are deemed to run along the length of the chain.
+		@param dir The direction, default is TCD_U.
+		*/
+		virtual void setTextureCoordDirection(TexCoordDirection dir);
+		/** Gets the direction in which texture coords specified on each element
+			are deemed to run.
+		*/
+		virtual TexCoordDirection getTextureCoordDirection(void) { return mTexCoordDir; }
+
+		/** Set the range of the texture coordinates generated across the width of
+			the chain elements.
+		@param start Start coordinate, default 0.0
+		@param end End coordinate, default 1.0
+		*/
+		virtual void setOtherTextureCoordRange(Real start, Real end);
+		/** Get the range of the texture coordinates generated across the width of
+			the chain elements.
+		*/
+		virtual const Real* getOtherTextureCoordRange(void) const { return mOtherTexCoordRange; }
+
+		/** Sets whether vertex colour information should be included in the
+			final buffers generated.
+		@note You must use either texture coordinates or vertex colour since the
+			vertices have no normals and without one of these there is no source of
+			colour for the vertices.
+		*/
+		virtual void setUseVertexColours(bool use);
+		/** Gets whether vertex colour information should be included in the
+			final buffers generated.
+		*/
+		virtual bool getUseVertexColours(void) const { return mUseVertexColour; }
+
+		/** Sets whether or not the buffers created for this object are suitable
+			for dynamic alteration.
+		*/
+		virtual void setDynamic(bool dyn);
+
+		/** Gets whether or not the buffers created for this object are suitable
+			for dynamic alteration.
+		*/
+		virtual bool getDynamic(void) const { return mDynamic; }
+		
+		/** Add an element to the 'head' of a chain.
+		@remarks
+			If this causes the number of elements to exceed the maximum elements
+			per chain, the last element in the chain (the 'tail') will be removed
+			to allow the additional element to be added.
+		@param chainIndex The index of the chain
+		@param billboardChainElement The details to add
+		*/
+		virtual void addChainElement(size_t chainIndex, 
+			const Element& billboardChainElement);
+		/** Remove an element from the 'tail' of a chain.
+		@param chainIndex The index of the chain
+		*/
+		virtual void removeChainElement(size_t chainIndex);
+		/** Update the details of an existing chain element.
+		@param chainIndex The index of the chain
+		@param elementIndex The element index within the chain, measured from 
+			the 'head' of the chain
+		@param billboardChainElement The details to set
+		*/
+		virtual void updateChainElement(size_t chainIndex, size_t elementIndex, 
+			const Element& billboardChainElement);
+		/** Get the detail of a chain element.
+		@param chainIndex The index of the chain
+		@param elementIndex The element index within the chain, measured from
+			the 'head' of the chain
+		*/
+		virtual const Element& getChainElement(size_t chainIndex, size_t elementIndex) const;
+
+		/** Returns the number of chain elements. */
+		virtual size_t getNumChainElements(size_t chainIndex) const;
+
+		/** Remove all elements of a given chain (but leave the chain intact). */
+		virtual void clearChain(size_t chainIndex);
+		/** Remove all elements from all chains (but leave the chains themselves intact). */
+		virtual void clearAllChains(void);
+
+		/** Sets whether the billboard should always be facing the camera or a custom direction
+			set by each point element.
+		@remarks
+			Billboards facing the camera are useful for smoke trails, light beams, etc by
+			simulating a cylinder. However, because of this property, wide trails can cause
+			several artefacts unless the head is properly covered.
+			Therefore, non-camera-facing billboards are much more convenient for leaving big
+			trails of movement from thin objects, for example a sword swing as seen in many
+			fighting games.
+		@param faceCamera True to be always facing the camera (Default value: True)
+		@param normalVector Only used when faceCamera == false. Must be a non-zero vector.
+		This vector is the "point of reference" for each point orientation. For example,
+		if normalVector is Vector3::UNIT_Z, and the point's orientation is an identity
+		matrix, the segment corresponding to that point will be facing towards UNIT_Z
+		This vector is internally normalized.
+		*/
+		void setFaceCamera( bool faceCamera, const Vector3 &normalVector=Vector3::UNIT_X );
+
+		/// Get the material name in use
+		virtual const String& getMaterialName(void) const { return mMaterialName; }
+		/// Set the material name to use for rendering
+		virtual void setMaterialName( const String& name, const String& groupName = ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME );
+
+
+		// Overridden members follow
+		void _notifyCurrentCamera(Camera* cam);
+		Real getSquaredViewDepth(const Camera* cam) const;
+		Real getBoundingRadius(void) const;
+		const AxisAlignedBox& getBoundingBox(void) const;
+		const MaterialPtr& getMaterial(void) const;
+		const String& getMovableType(void) const;
+		void _updateRenderQueue(RenderQueue *);
+		void getRenderOperation(RenderOperation &);
+		void getWorldTransforms(Matrix4 *) const;
+		const LightList& getLights(void) const;
+		/// @copydoc MovableObject::visitRenderables
+		void visitRenderables(Renderable::Visitor* visitor, 
+			bool debugRenderables = false);
+
+
+
+	protected:
+
+		/// Maximum length of each chain
+		size_t mMaxElementsPerChain;
+		/// Number of chains
+		size_t mChainCount;
+		/// Use texture coords?
+		bool mUseTexCoords;
+		/// Use vertex colour?
+		bool mUseVertexColour;
+		/// Dynamic use?
+		bool mDynamic;
+		/// Vertex data
+		VertexData* mVertexData;
+		/// Index data (to allow multiple unconnected chains)
+		IndexData* mIndexData;
+		/// Is the vertex declaration dirty?
+		bool mVertexDeclDirty;
+		/// Do the buffers need recreating?
+		bool mBuffersNeedRecreating;
+		/// Do the bounds need redefining?
+		mutable bool mBoundsDirty;
+		/// Is the index buffer dirty?
+		bool mIndexContentDirty;
+		/// AABB
+		mutable AxisAlignedBox mAABB;
+		/// Bounding radius
+		mutable Real mRadius;
+		/// Material 
+		String mMaterialName;
+		MaterialPtr mMaterial;
+		/// Texture coord direction
+		TexCoordDirection mTexCoordDir;
+		/// Other texture coord range
+		Real mOtherTexCoordRange[2];
+		/// When true, the billboards always face the camera
+		bool mFaceCamera;
+		/// Used when mFaceCamera == false; determines the billboard's "normal". i.e.
+		/// when the orientation is identity, the billboard is perpendicular to this
+		/// vector
+		Vector3 mNormalBase;
+
+
+		/// The list holding the chain elements
+		ElementList mChainElementList;
+
+		/** Simple struct defining a chain segment by referencing a subset of
+			the preallocated buffer (which will be mMaxElementsPerChain * mChainCount
+			long), by it's chain index, and a head and tail value which describe
+			the current chain. The buffer subset wraps at mMaxElementsPerChain
+			so that head and tail can move freely. head and tail are inclusive,
+			when the chain is empty head and tail are filled with high-values.
+		*/
+		struct ChainSegment
+		{
+			/// The start of this chains subset of the buffer
+			size_t start;
+			/// The 'head' of the chain, relative to start
+			size_t head;
+			/// The 'tail' of the chain, relative to start
+			size_t tail;
+		};
+		typedef vector<ChainSegment>::type ChainSegmentList;
+		ChainSegmentList mChainSegmentList;
+
+		/// Setup the STL collections
+		virtual void setupChainContainers(void);
+		/// Setup vertex declaration
+		virtual void setupVertexDeclaration(void);
+		// Setup buffers
+		virtual void setupBuffers(void);
+		/// Update the contents of the vertex buffer
+		virtual void updateVertexBuffer(Camera* cam);
+		/// Update the contents of the index buffer
+		virtual void updateIndexBuffer(void);
+		virtual void updateBoundingBox(void) const;
+
+		/// Chain segment has no elements
+		static const size_t SEGMENT_EMPTY;
+	};
+
+
+	/** Factory object for creating BillboardChain instances */
+	class _OgreExport BillboardChainFactory : public MovableObjectFactory
+	{
+	protected:
+		MovableObject* createInstanceImpl( const String& name, const NameValuePairList* params);
+	public:
+		BillboardChainFactory() {}
+		~BillboardChainFactory() {}
+
+		static String FACTORY_TYPE_NAME;
+
+		const String& getType(void) const;
+		void destroyInstance( MovableObject* obj);  
+
+	};
+
+	/** @} */
+	/** @} */
+
+} // namespace
+
+#endif
+
+