ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreSubEntity.h

@@ -0,0 +1,288 @@
+/*
+-----------------------------------------------------------------------------
+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 __SubEntity_H__
+#define __SubEntity_H__
+
+#include "OgrePrerequisites.h"
+
+#include "OgreString.h"
+#include "OgreRenderable.h"
+#include "OgreHardwareBufferManager.h"
+#include "OgreResourceGroupManager.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Scene
+	*  @{
+	*/
+	/** Utility class which defines the sub-parts of an Entity.
+        @remarks
+            Just as meshes are split into submeshes, an Entity is made up of
+            potentially multiple SubMeshes. These are mainly here to provide the
+            link between the Material which the SubEntity uses (which may be the
+            default Material for the SubMesh or may have been changed for this
+            object) and the SubMesh data.
+        @par
+            The SubEntity also allows the application some flexibility in the
+            material properties for this section of a particular instance of this
+            Mesh, e.g. tinting the windows on a car model.
+        @par
+            SubEntity instances are never created manually. They are created at
+            the same time as their parent Entity by the SceneManager method
+            createEntity.
+    */
+    class _OgreExport SubEntity: public Renderable, public SubEntityAlloc
+    {
+        // Note no virtual functions for efficiency
+        friend class Entity;
+        friend class SceneManager;
+    protected:
+        /** Private constructor - don't allow creation by anybody else.
+        */
+        SubEntity(Entity* parent, SubMesh* subMeshBasis);
+
+        /** Private destructor.
+        */
+        virtual ~SubEntity();
+
+        /// Pointer to parent.
+        Entity* mParentEntity;
+
+        /// Name of Material in use by this SubEntity.
+        String mMaterialName;
+
+        /// Cached pointer to material.
+        MaterialPtr mMaterial;
+
+        // Pointer to the SubMesh defining geometry.
+        SubMesh* mSubMesh;
+
+        /// Is this SubEntity visible?
+        bool mVisible;
+
+        /// The render queue to use when rendering this renderable
+        uint8 mRenderQueueID;
+        /// Flags whether the RenderQueue's default should be used.
+        bool mRenderQueueIDSet;
+        /// The render queue priority to use when rendering this renderable
+        ushort mRenderQueuePriority;
+        /// Flags whether the RenderQueue's default should be used.
+        bool mRenderQueuePrioritySet;
+
+		/// The LOD number of the material to use, calculated by Entity::_notifyCurrentCamera
+		unsigned short mMaterialLodIndex;
+
+        /// blend buffer details for dedicated geometry
+        VertexData* mSkelAnimVertexData;
+        /// Quick lookup of buffers
+        TempBlendedBufferInfo mTempSkelAnimInfo;
+		/// Temp buffer details for software Vertex anim geometry
+		TempBlendedBufferInfo mTempVertexAnimInfo;
+		/// Vertex data details for software Vertex anim of shared geometry
+		VertexData* mSoftwareVertexAnimVertexData;
+		/// Vertex data details for hardware Vertex anim of shared geometry
+		/// - separate since we need to s/w anim for shadows whilst still altering
+		///   the vertex data for hardware morphing (pos2 binding)
+		VertexData* mHardwareVertexAnimVertexData;
+		/// Have we applied any vertex animation to geometry?
+		bool mVertexAnimationAppliedThisFrame;
+		/// Number of hardware blended poses supported by material
+		ushort mHardwarePoseCount;
+		/// Cached distance to last camera for getSquaredViewDepth
+		mutable Real mCachedCameraDist;
+		/// The camera for which the cached distance is valid
+		mutable const Camera *mCachedCamera;
+
+        /** Internal method for preparing this Entity for use in animation. */
+        void prepareTempBlendBuffers(void);
+
+    public:
+        /** Gets the name of the Material in use by this instance.
+        */
+        const String& getMaterialName() const;
+
+        /** Sets the name of the Material to be used.
+            @remarks
+                By default a SubEntity uses the default Material that the SubMesh
+                uses. This call can alter that so that the Material is different
+                for this instance.
+        */
+        void setMaterialName( const String& name, const String& groupName = ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME );
+
+		/** Sets a Material to be used.
+			@remarks
+				By default a SubEntity uses the default Material that the SubMesh
+				uses. This call can alter that so that the Material is different
+				for this instance.
+		*/
+		void setMaterial( const MaterialPtr& material );
+
+        /** Tells this SubEntity whether to be visible or not. */
+        virtual void setVisible(bool visible);
+
+        /** Returns whether or not this SubEntity is supposed to be visible. */
+        virtual bool isVisible(void) const;
+
+        /** Sets the render queue group this subentity will be rendered through.
+        @remarks
+            Render queues are grouped to allow you to more tightly control the ordering
+            of rendered objects. If you do not call this method, the SubEntity will use
+            either the Entity's queue or it will use the default
+            (RenderQueue::getDefaultQueueGroup).
+        @par
+            See Entity::setRenderQueueGroup for more details.
+        @param queueID Enumerated value of the queue group to use. See the
+            enum RenderQueueGroupID for what kind of values can be used here.
+        */
+        virtual void setRenderQueueGroup(uint8 queueID);
+
+        /** Sets the render queue group and group priority this subentity will be rendered through.
+        @remarks
+            Render queues are grouped to allow you to more tightly control the ordering
+            of rendered objects. Within a single render group there another type of grouping
+            called priority which allows further control.  If you do not call this method, 
+            all Entity objects default to the default queue and priority 
+            (RenderQueue::getDefaultQueueGroup, RenderQueue::getDefaultRenderablePriority).
+        @par
+            See Entity::setRenderQueueGroupAndPriority for more details.
+        @param queueID Enumerated value of the queue group to use. See the
+            enum RenderQueueGroupID for what kind of values can be used here.
+        @param priority The priority within a group to use.
+        */
+        virtual void setRenderQueueGroupAndPriority(uint8 queueID, ushort priority);
+
+        /** Gets the queue group for this entity, see setRenderQueueGroup for full details. */
+        virtual uint8 getRenderQueueGroup(void) const;
+
+        /** Gets the queue group for this entity, see setRenderQueueGroup for full details. */
+        virtual ushort getRenderQueuePriority(void) const;
+
+        /** Gets the queue group for this entity, see setRenderQueueGroup for full details. */
+        virtual bool isRenderQueueGroupSet(void) const;
+
+        /** Gets the queue group for this entity, see setRenderQueueGroup for full details. */
+        virtual bool isRenderQueuePrioritySet(void) const;
+
+        /** Accessor method to read mesh data.
+        */
+        SubMesh* getSubMesh(void);
+
+		/** Accessor to get parent Entity */
+		Entity* getParent(void) const { return mParentEntity; }
+
+        /** Overridden - see Renderable.
+        */
+        const MaterialPtr& getMaterial(void) const;
+
+        /** Overridden - see Renderable.
+        */
+        Technique* getTechnique(void) const;
+
+        /** Overridden - see Renderable.
+        */
+        void getRenderOperation(RenderOperation& op);
+
+        /** Overridden - see Renderable.
+        */
+        void getWorldTransforms(Matrix4* xform) const;
+        /** Overridden - see Renderable.
+        */
+        unsigned short getNumWorldTransforms(void) const;
+        /** Overridden, see Renderable */
+        Real getSquaredViewDepth(const Camera* cam) const;
+        /** @copydoc Renderable::getLights */
+        const LightList& getLights(void) const;
+        /** @copydoc Renderable::getCastsShadows */
+        bool getCastsShadows(void) const;
+		/** Advanced method to get the temporarily blended vertex information
+		for entities which are software skinned. 
+        @remarks
+            Internal engine will eliminate software animation if possible, this
+            information is unreliable unless added request for software animation
+            via Entity::addSoftwareAnimationRequest.
+        @note
+            The positions/normals of the returned vertex data is in object space.
+		*/
+		VertexData* _getSkelAnimVertexData(void);
+		/** Advanced method to get the temporarily blended software morph vertex information
+        @remarks
+            Internal engine will eliminate software animation if possible, this
+            information is unreliable unless added request for software animation
+            via Entity::addSoftwareAnimationRequest.
+        @note
+            The positions/normals of the returned vertex data is in object space.
+		*/
+		VertexData* _getSoftwareVertexAnimVertexData(void);
+		/** Advanced method to get the hardware morph vertex information
+        @note
+            The positions/normals of the returned vertex data is in object space.
+		*/
+		VertexData* _getHardwareVertexAnimVertexData(void);
+		/** Advanced method to get the temp buffer information for software 
+		skeletal animation.
+		*/
+		TempBlendedBufferInfo* _getSkelAnimTempBufferInfo(void);
+		/** Advanced method to get the temp buffer information for software 
+		morph animation.
+		*/
+		TempBlendedBufferInfo* _getVertexAnimTempBufferInfo(void);
+		/// Retrieve the VertexData which should be used for GPU binding
+		VertexData* getVertexDataForBinding(void);
+
+		/** Mark all vertex data as so far unanimated. 
+		*/
+		void _markBuffersUnusedForAnimation(void);
+		/** Mark all vertex data as animated. 
+		*/
+		void _markBuffersUsedForAnimation(void);
+		/** Are buffers already marked as vertex animated? */
+		bool _getBuffersMarkedForAnimation(void) const { return mVertexAnimationAppliedThisFrame; }
+		/** Internal method to copy original vertex data to the morph structures
+		should there be no active animation in use.
+		*/
+		void _restoreBuffersForUnusedAnimation(bool hardwareAnimation);
+
+		/** Overridden from Renderable to provide some custom behaviour. */
+		void _updateCustomGpuParameter(
+			const GpuProgramParameters::AutoConstantEntry& constantEntry,
+			GpuProgramParameters* params) const;
+
+		/** Invalidate the camera distance cache */
+		void _invalidateCameraCache ()
+		{ mCachedCamera = 0; }
+    };
+	/** @} */
+	/** @} */
+
+}
+
+
+#endif

data/deps/include/OGRE/OgreSubMesh.h

@@ -0,0 +1,294 @@
+/*
+-----------------------------------------------------------------------------
+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 __SubMesh_H_
+#define __SubMesh_H_
+
+#include "OgrePrerequisites.h"
+
+#include "OgreVertexIndexData.h"
+#include "OgreMaterial.h"
+#include "OgreRenderOperation.h"
+#include "OgreVertexBoneAssignment.h"
+#include "OgreAnimationTrack.h"
+#include "OgreResourceGroupManager.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Resources
+	*  @{
+	*/
+	/** Defines a part of a complete mesh.
+        @remarks
+            Meshes which make up the definition of a discrete 3D object
+            are made up of potentially multiple parts. This is because
+            different parts of the mesh may use different materials or
+            use different vertex formats, such that a rendering state
+            change is required between them.
+        @par
+            Like the Mesh class, instantiations of 3D objects in the scene
+            share the SubMesh instances, and have the option of overriding
+            their material differences on a per-object basis if required.
+            See the SubEntity class for more information.
+    */
+	class _OgreExport SubMesh : public SubMeshAlloc
+    {
+        friend class Mesh;
+        friend class MeshSerializerImpl;
+        friend class MeshSerializerImpl_v1_2;
+        friend class MeshSerializerImpl_v1_1;
+    public:
+        SubMesh();
+        ~SubMesh();
+
+
+        /// Indicates if this submesh shares vertex data with other meshes or whether it has it's own vertices.
+        bool useSharedVertices;
+
+        /// The render operation type used to render this submesh
+        RenderOperation::OperationType operationType;
+
+        /** Dedicated vertex data (only valid if useSharedVertices = false).
+            @remarks
+                This data is completely owned by this submesh.
+            @par
+                The use of shared or non-shared buffers is determined when
+                model data is converted to the OGRE .mesh format.
+        */
+        VertexData *vertexData;
+
+        /// Face index data
+        IndexData *indexData;
+
+        /** Dedicated index map for translate blend index to bone index (only valid if useSharedVertices = false).
+            @remarks
+                This data is completely owned by this submesh.
+            @par
+                We collect actually used bones of all bone assignments, and build the
+                blend index in 'packed' form, then the range of the blend index in vertex
+                data VES_BLEND_INDICES element is continuous, with no gaps. Thus, by
+                minimising the world matrix array constants passing to GPU, we can support
+                more bones for a mesh when hardware skinning is used. The hardware skinning
+                support limit is applied to each set of vertex data in the mesh, in other words, the
+                hardware skinning support limit is applied only to the actually used bones of each
+                SubMeshes, not all bones across the entire Mesh.
+            @par
+                Because the blend index is different to the bone index, therefore, we use
+                the index map to translate the blend index to bone index.
+            @par
+                The use of shared or non-shared index map is determined when
+                model data is converted to the OGRE .mesh format.
+        */
+        typedef vector<unsigned short>::type IndexMap;
+        IndexMap blendIndexToBoneIndexMap;
+
+		typedef vector<IndexData*>::type LODFaceList;
+		LODFaceList mLodFaceList;
+
+        /** A list of extreme points on the submesh (optional).
+            @remarks
+                These points are some arbitrary points on the mesh that are used
+                by engine to better sort submeshes by depth. This doesn't matter
+                much for non-transparent submeshes, as Z-buffer takes care of invisible
+                surface culling anyway, but is pretty useful for semi-transparent
+                submeshes because the order in which transparent submeshes must be
+                rendered cannot be always correctly deduced from entity position.
+            @par
+                These points are intelligently chosen from the points that make up
+                the submesh, the criteria for choosing them should be that these points
+                somewhat characterize the submesh outline, e.g. they should not be
+                close to each other, and they should be on the outer hull of the submesh.
+                They can be stored in the .mesh file, or generated at runtime
+                (see generateExtremes ()).
+            @par
+                If this array is empty, submesh sorting is done like in older versions -
+                by comparing the positions of the owning entity.
+         */
+        vector<Vector3>::type extremityPoints;
+
+        /// Reference to parent Mesh (not a smart pointer so child does not keep parent alive).
+        Mesh* parent;
+
+        /// Sets the name of the Material which this SubMesh will use
+        void setMaterialName(const String& matName, const String& groupName = ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME );
+        const String& getMaterialName(void) const;
+
+        /** Returns true if a material has been assigned to the submesh, otherwise returns false.
+        */
+        bool isMatInitialised(void) const;
+
+        /** Returns a RenderOperation structure required to render this mesh.
+            @param 
+                rend Reference to a RenderOperation structure to populate.
+            @param
+                lodIndex The index of the LOD to use. 
+        */
+        void _getRenderOperation(RenderOperation& rend, ushort lodIndex = 0);
+
+        /** Assigns a vertex to a bone with a given weight, for skeletal animation. 
+        @remarks    
+            This method is only valid after calling setSkeletonName.
+            Since this is a one-off process there exists only 'addBoneAssignment' and
+            'clearBoneAssignments' methods, no 'editBoneAssignment'. You should not need
+            to modify bone assignments during rendering (only the positions of bones) and OGRE
+            reserves the right to do some internal data reformatting of this information, depending
+            on render system requirements.
+        @par
+            This method is for assigning weights to the dedicated geometry of the SubMesh. To assign
+            weights to the shared Mesh geometry, see the equivalent methods on Mesh.
+        */
+        void addBoneAssignment(const VertexBoneAssignment& vertBoneAssign);
+
+        /** Removes all bone assignments for this mesh. 
+        @par
+            This method is for assigning weights to the dedicated geometry of the SubMesh. To assign
+            weights to the shared Mesh geometry, see the equivalent methods on Mesh.
+        */
+        void clearBoneAssignments(void);
+
+        /// Multimap of verex bone assignments (orders by vertex index)
+        typedef multimap<size_t, VertexBoneAssignment>::type VertexBoneAssignmentList;
+        typedef MapIterator<VertexBoneAssignmentList> BoneAssignmentIterator;
+
+        /** Gets an iterator for access all bone assignments. 
+        @remarks
+            Only valid if this SubMesh has dedicated geometry.
+        */
+        BoneAssignmentIterator getBoneAssignmentIterator(void);
+
+		/** Gets a const reference to the list of bone assignments
+		*/
+		const VertexBoneAssignmentList& getBoneAssignments() { return mBoneAssignments; }
+
+
+        /** Must be called once to compile bone assignments into geometry buffer. */
+        void _compileBoneAssignments(void);
+
+        typedef ConstMapIterator<AliasTextureNamePairList> AliasTextureIterator;
+        /** Gets an constant iterator to access all texture alias names assigned to this submesh. 
+
+        */
+        AliasTextureIterator getAliasTextureIterator(void) const;
+        /** Adds the alias or replaces an existing one and associates the texture name to it.
+        @remarks
+          The submesh uses the texture alias to replace textures used in the material applied
+          to the submesh.
+        @param
+            aliasName is the name of the alias.
+        @param
+            textureName is the name of the texture to be associated with the alias
+
+        */
+        void addTextureAlias(const String& aliasName, const String& textureName);
+        /** Remove a specific texture alias name from the sub mesh
+        @param
+            aliasName is the name of the alias to be removed.  If it is not found 
+            then it is ignored.
+        */
+        void removeTextureAlias(const String& aliasName);
+        /** removes all texture aliases from the sub mesh
+        */
+        void removeAllTextureAliases(void);
+        /** returns true if the sub mesh has texture aliases
+        */
+        bool hasTextureAliases(void) const { return !mTextureAliases.empty(); }
+        /** Gets the number of texture aliases assigned to the sub mesh.
+        */
+        size_t getTextureAliasCount(void) const { return mTextureAliases.size(); }
+
+        /**  The current material used by the submesh is copied into a new material
+            and the submesh's texture aliases are applied if the current texture alias
+            names match those found in the original material.
+        @remarks
+            The submesh's texture aliases must be setup prior to calling this method.
+            If a new material has to be created, the subMesh autogenerates the new name.
+            The new name is the old name + "_" + number.
+        @return 
+            True if texture aliases were applied and a new material was created.
+        */
+        bool updateMaterialUsingTextureAliases(void);
+
+		/** Get the type of any vertex animation used by dedicated geometry.
+		*/
+		VertexAnimationType getVertexAnimationType(void) const;
+		
+		/// Returns whether animation on dedicated vertex data includes normals
+		bool getVertexAnimationIncludesNormals() const { return mVertexAnimationIncludesNormals; }
+
+
+        /** Generate the submesh extremes (@see extremityPoints).
+        @param count
+            Number of extreme points to compute for the submesh.
+        */
+        void generateExtremes(size_t count);
+
+		/** Returns true(by default) if the submesh should be included in the mesh EdgeList, otherwise returns false.
+        */		
+		bool isBuildEdgesEnabled(void) const { return mBuildEdgesEnabled; }
+		void setBuildEdgesEnabled(bool b);
+
+    protected:
+
+        /// Name of the material this SubMesh uses.
+        String mMaterialName;
+
+        /// Is there a material yet?
+        bool mMatInitialised;
+
+        /// paired list of texture aliases and texture names
+        AliasTextureNamePairList mTextureAliases;
+
+        VertexBoneAssignmentList mBoneAssignments;
+
+        /// Flag indicating that bone assignments need to be recompiled
+        bool mBoneAssignmentsOutOfDate;
+
+		/// Type of vertex animation for dedicated vertex data (populated by Mesh)
+		mutable VertexAnimationType mVertexAnimationType;
+
+		/// Whether normals are included in vertex animation keyframes
+		mutable bool mVertexAnimationIncludesNormals;
+
+		/// Is Build Edges Enabled
+		bool mBuildEdgesEnabled;
+
+        /// Internal method for removing LOD data
+        void removeLodLevels(void);
+
+
+    };
+	/** @} */
+	/** @} */
+
+} // namespace
+
+#endif
+
+