Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 521 insertions, 0 deletions

diff --git a/APEX_1.4/include/RenderMeshAsset.h b/APEX_1.4/include/RenderMeshAsset.h
new file mode 100644
index 00000000..3c0204a4
--- /dev/null
+++ b/APEX_1.4/include/RenderMeshAsset.h
@@ -0,0 +1,521 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef RENDER_MESH_ASSET_H
+#define RENDER_MESH_ASSET_H
+
+/*!
+\file
+\brief APEX RenderMesh Asset
+*/
+
+#include "ApexUsingNamespace.h"
+#include "VertexFormat.h"
+#include "Asset.h"
+#include "RenderBufferData.h"
+#include "RenderMesh.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+PX_PUSH_PACK_DEFAULT
+
+class RenderMeshActor;
+class RenderMeshActorDesc;
+class CustomBufferIterator;
+
+//! \brief Name of RenderMesh authoring type namespace
+#define RENDER_MESH_AUTHORING_TYPE_NAME "ApexRenderMesh"
+
+/**
+\brief Stats for an RenderMeshAsset: memory usage, counts, etc.
+*/
+struct RenderMeshAssetStats
+{
+	uint32_t	totalBytes;				//!< Total byte size of mesh
+	uint32_t	submeshCount;			//!< Number of submeshes
+	uint32_t	partCount;				//!< Number of mesh parts
+	uint32_t	vertexCount;			//!< Number of vertices
+	uint32_t	indexCount;				//!< Size (count) of index buffer
+	uint32_t	vertexBufferBytes;		//!< Byte size of vertex buffer
+	uint32_t	indexBufferBytes;		//!< Byte size of index buffer
+};
+
+/**
+\brief Instance buffer data mode.  DEPRECATED, to be removed by APEX 1.0
+*/
+struct RenderMeshAssetInstanceMode
+{
+	/**
+	\brief Enum of instance buffer data.
+	*/
+	enum Enum
+	{
+		POSE_SCALE = 0,
+		POS_VEL_LIFE,
+
+		NUM_MODES
+	};
+};
+
+
+/**
+\brief The full RGBA color of a vertex
+*/
+struct VertexColor
+{
+public:
+
+	PX_INLINE					VertexColor()	{}
+
+	/**
+	\brief Constructor
+	*/
+	PX_INLINE					VertexColor(const ColorRGBA c)
+	{
+		const float recip255 = 1 / (float)255;
+		set((float)c.r * recip255, (float)c.g * recip255, (float)c.b * recip255, (float)c.a * recip255);
+	}
+
+	/**
+	\brief Copy assignment operator
+	*/
+	PX_INLINE	VertexColor&	operator = (const VertexColor& c)
+	{
+		r = c.r;
+		g = c.g;
+		b = c.b;
+		a = c.a;
+		return *this;
+	}
+
+	/// \brief set the color as RGBA floats
+	PX_INLINE	void			set(float _r, float _g, float _b, float _a)
+	{
+		r = _r;
+		g = _g;
+		b = _b;
+		a = _a;
+	}
+
+	/// \brief return the color as a 32bit integer
+	PX_INLINE	ColorRGBA		toColorRGBA() const
+	{
+		return ColorRGBA((uint8_t)(255 * r + (float)0.5),
+		                   (uint8_t)(255 * g + (float)0.5),
+		                   (uint8_t)(255 * b + (float)0.5),
+		                   (uint8_t)(255 * a + (float)0.5));
+	}
+
+	float r;		//!< RED
+	float g;		//!< GREEN
+	float b;		//!< BLUE
+	float a;		//!< ALPHA
+};
+
+
+/**
+\brief a simple u, v coordinate struct
+*/
+struct VertexUV
+{
+	VertexUV() {}
+
+	/**
+	\brief Constructor
+	*/
+	VertexUV(float _u, float _v)
+	{
+		set(_u, _v);
+	}
+
+	/**
+	\brief Constructor
+	*/
+	VertexUV(const float uv[])
+	{
+		set(uv);
+	}
+
+	/**
+	\brief Set coordinates
+	*/
+	void			set(float _u, float _v)
+	{
+		u = _u;
+		v = _v;
+	}
+
+	/**
+	\brief Set coordinates
+	*/
+	void			set(const float uv[])
+	{
+		u = uv[0];
+		v = uv[1];
+	}
+
+	/**
+	\brief operator []
+	*/
+	float&			operator [](int i)
+	{
+		PX_ASSERT(i >= 0 && i <= 1);
+		return (&u)[i];
+	}
+
+	/**
+	\brief const operator []
+	*/
+	const float&	operator [](int i) const
+	{
+		PX_ASSERT(i >= 0 && i <= 1);
+		return (&u)[i];
+	}
+
+	/// coordinate
+	float	u;
+	/// coordinate
+	float	v;
+};
+
+
+/**
+\brief An inefficient vertex description used for authoring
+*/
+struct Vertex
+{
+	PxVec3		position;		//!< Vertex position
+	PxVec3		normal;			//!< Surface normal at this position
+	PxVec3		tangent;		//!< Surface tangent at this position
+	PxVec3		binormal;		//!< Surface binormal at this position
+	VertexUV	uv[VertexFormat::MAX_UV_COUNT]; //!< Texture UV coordinates
+	VertexColor	color;			//!< Color ar this position
+	uint16_t	boneIndices[VertexFormat::MAX_BONE_PER_VERTEX_COUNT]; //!< Bones which are attached to this vertex
+	float		boneWeights[VertexFormat::MAX_BONE_PER_VERTEX_COUNT]; //!< Per bone wieght, 0.0 if no bone
+	uint16_t	displacementFlags; //!< Flags for vertex displacement
+
+	/**
+	\brief Constructor which clears the entire structure
+	*/
+	Vertex()
+	{
+		memset(this, 0, sizeof(Vertex));
+	}
+};
+
+
+/**
+\brief A less inefficient triangle description used for authoring
+*/
+struct ExplicitRenderTriangle
+{
+	Vertex		vertices[3];		//!< The three verts that define the triangle
+	int32_t		submeshIndex;		//!< The submesh to which this triangle belongs
+	uint32_t	smoothingMask;		//!< Smoothing mask
+	uint32_t	extraDataIndex;		//!< Index of extra data
+
+	/**
+	\brief Returns an unnormalized normal, in general
+	*/
+	PxVec3	calculateNormal() const
+	{
+		return (vertices[1].position - vertices[0].position).cross(vertices[2].position - vertices[0].position);
+	}
+};
+
+
+
+/**
+\brief Descriptor for creating a rendering mesh part
+*/
+struct RenderMeshPartData
+{
+	RenderMeshPartData() : triangleCount(0), userData(NULL) {}
+
+	/**
+	\brief Constructor
+	*/
+	RenderMeshPartData(uint32_t _triCount, void* _data) : triangleCount(_triCount), userData(_data) {}
+
+	uint32_t		triangleCount;	//!< Number of triangles in this mesh part
+	void*			userData;		//!< User definable pointer to part data, passed back to createTriangles
+};
+
+
+/**
+\brief Authoring interface for an RenderMeshAsset
+*/
+class RenderMeshAssetAuthoring : public AssetAuthoring
+{
+public:
+	/** \brief Vertex buffer class used for mesh creation */
+	class VertexBuffer : public RenderBufferData<RenderVertexSemantic, RenderVertexSemantic::Enum> {};
+
+	/** \brief How the geometry is stored.  Currently only supporting triangles. */
+	struct Primitive
+	{
+		/**
+		\brief Enum of geometry stored types.
+		*/
+		enum Enum
+		{
+			TRIANGLE_LIST,
+			//		TRIANGLE_STRIP, // Not supported for now
+			//		TRIANGLE_FAN,	// Not supported for now
+
+			COUNT
+		};
+	};
+
+	/** What kind of integer is used for indices. */
+	struct IndexType
+	{
+		/**
+		\brief Enum of integers types using for indices.
+		*/
+		enum Enum
+		{
+			UINT,
+			USHORT,
+
+			COUNT
+		};
+	};
+
+	/** Description of one submesh, corresponding to one material.  The vertex buffer format contains bone indices, so these do not need
+	    to be described here.  The submesh's partitioning into parts is described here. */
+	class SubmeshDesc
+	{
+	public:
+		/** Name of material associated with this geometry. */
+		const char*				m_materialName;
+
+		/** Vertex buffers for this submesh. One may pass in the same buffers for each submesh. */
+		const VertexBuffer*		m_vertexBuffers;
+
+		/** Number of vertex buffers in m_VertexBuffers array. */
+		uint32_t				m_numVertexBuffers;
+
+		/** Number of vertices.  Each vertex buffer in m_VertexBuffers must have this many vertices. */
+		uint32_t				m_numVertices;
+
+		/** How the geometry is represented.  See the Primitive enum. */
+		Primitive::Enum			m_primitive;
+
+		/** Type of the indices used in m_VertexIndices. See the IndexType enum. */
+		IndexType::Enum			m_indexType;
+
+		/** Buffer of vertex indices, stored as described by primitive and indexSize. If NULL, m_vertexIndices = {0,1,2,...} is implied. */
+		const void*				m_vertexIndices;
+
+		/** Size (in indices) of m_VertexIndices. */
+		uint32_t				m_numIndices;
+
+		/**
+			Smoothing groups associated with each triangle.  The size of this array (if not NULL) must be appropriate for the m_primitive type.
+			Since only triangle lists are currently supported, the size of this array (if not NULL) must currently be m_numIndices/3.
+		*/
+		uint32_t*				m_smoothingGroups;
+
+		/** Vertex index offset. */
+		uint32_t				m_firstVertex;
+
+		/** If not NULL, an array (of m_IndexType-sized indices) into m_VertexIndices, at the start of each part. */
+		const void*				m_partIndices;
+
+		/** If m_PartIndices is not NULL, the number of parts. */
+		uint32_t				m_numParts;
+
+		/** Winding order of the submesh */
+		RenderCullMode::Enum	m_cullMode;
+
+		/** Constructor sets default values. */
+		SubmeshDesc()
+		{
+			memset(this, 0, sizeof(SubmeshDesc));
+		}
+
+		/** Validity check, returns true if this descriptor contains valid fields. */
+		bool	isValid() const
+		{
+			return	m_materialName != NULL &&
+			        m_vertexBuffers != NULL &&	// BRG - todo: check the vertex buffers for validity
+			        m_numVertexBuffers > 0 &&
+			        m_numVertices > 0 &&
+			        m_primitive >= (Primitive::Enum)0 && m_primitive < Primitive::COUNT &&
+			        m_indexType >= (IndexType::Enum)0 && m_indexType < IndexType::COUNT &&
+			        m_numIndices > 0 &&
+			        (m_partIndices == NULL || m_numParts > 0) &&
+			        (m_cullMode == RenderCullMode::CLOCKWISE || m_cullMode == RenderCullMode::COUNTER_CLOCKWISE || m_cullMode == RenderCullMode::NONE);
+		}
+	};
+
+	/** Description of a mesh, used for authoring an Render mesh.  It contains a number of vertex buffers and submeshes. */
+	class MeshDesc
+	{
+	public:
+		/** Array of descriptors for the submeshes in this mesh. */
+		const SubmeshDesc*		m_submeshes;
+
+		/** The number of elements in m_submeshes. */
+		uint32_t				m_numSubmeshes;
+
+		/** Texture UV direction. */
+		TextureUVOrigin::Enum	m_uvOrigin;
+
+
+
+		/** Constructor sets default values. */
+		MeshDesc() : m_submeshes(NULL), m_numSubmeshes(0), m_uvOrigin(TextureUVOrigin::ORIGIN_TOP_LEFT) {}
+
+		/** Validity check, returns true if this descriptor contains valid fields. */
+		bool	isValid() const
+		{
+			return	m_submeshes != NULL &&
+			        m_numSubmeshes > 0;
+		}
+	};
+
+
+	/**
+	\brief Mesh-building function.
+	\param [in] meshDesc					contains the setup for all vertex buffers
+	\param [in] createMappingInformation	A vertex buffer with remapping indices will be generated. The name of the buffer is VERTEX_ORIGINAL_INDEX
+	*/
+	virtual void					createRenderMesh(const MeshDesc& meshDesc, bool createMappingInformation) = 0;
+
+
+	/**
+	Utility to reduce a vertex buffer of explicit vertices (Vertex).
+	The parameters 'map' and 'vertices' must point to arrays of size vertexCount.
+	The parameter 'smoothingGroups' must point to an array of size vertexCount, or be NULL.  If not NULL, only vertices with equal smoothing groups will be merged.
+	Upon return, the map array will be filled in with remapped vertex positions for a new vertex buffer.
+	The return value is the number of vertices in the reduced buffer.
+	Note: this function does NOT actually create the new vertex buffer.
+	*/
+	virtual uint32_t				createReductionMap(uint32_t* map, const Vertex* vertices, const uint32_t* smoothingGroups, uint32_t vertexCount,
+													   const PxVec3& positionTolerance, float normalTolerance, float UVTolerance) = 0;
+
+
+	/**
+	If set, static data buffers will be deleted after they are used in createRenderResources.
+	*/
+	virtual void					deleteStaticBuffersAfterUse(bool set)	= 0;
+
+	/**
+	Old mesh-building interface follows (DEPRECATED, to be removed by beta release):
+	*/
+
+	/* Public access to RenderMeshAsset get methods */
+
+	/// \brief Return the number of submeshes
+	virtual uint32_t				getSubmeshCount() const = 0;
+	/// \brief Return the number of mesh parts
+	virtual uint32_t				getPartCount() const = 0;
+	/// \brief Return the name of a submesh
+	virtual const char*				getMaterialName(uint32_t submeshIndex) const = 0;
+	/// \brief Set the name of a submesh
+	virtual void					setMaterialName(uint32_t submeshIndex, const char* name) = 0;
+	/// \brief Set the winding order of a submesh
+	virtual void					setWindingOrder(uint32_t submeshIndex, RenderCullMode::Enum winding) = 0;
+	/// \brief Return the winding order of a submesh
+	virtual RenderCullMode::Enum	getWindingOrder(uint32_t submeshIndex) const = 0;
+	/// \brief Return a submesh
+	virtual const RenderSubmesh&	getSubmesh(uint32_t submeshIndex) const = 0;
+	/// \brief Return a mutable submesh
+	virtual RenderSubmesh&			getSubmeshWritable(uint32_t submeshIndex) = 0;
+	/// \brief Return the bounds of a mesh part
+	virtual const PxBounds3&		getBounds(uint32_t partIndex = 0) const = 0;
+	/// \brief Get the asset statistics
+	virtual void					getStats(RenderMeshAssetStats& stats) const = 0;
+};
+
+
+/**
+\brief Rendering mesh (data) class.
+
+To render a mesh asset, you must create an instance
+*/
+class RenderMeshAsset : public Asset
+{
+public:
+
+	/**
+	\brief Instance this asset, return the created RenderMeshActor.
+
+	See RenderMeshActor
+	*/
+	virtual RenderMeshActor*		createActor(const RenderMeshActorDesc& desc) = 0;
+
+	/**
+	\brief Releases an RenderMeshActor instanced by this asset.
+	*/
+	virtual void					releaseActor(RenderMeshActor&) = 0;
+
+	/**
+	\brief Number of submeshes.
+
+	Each part effectively has the same number of submeshes, even if some are empty.
+	*/
+	virtual uint32_t				getSubmeshCount() const = 0;
+
+	/**
+	\brief Number of parts.
+
+	These act as separate meshes, but they share submesh data (like materials).
+	*/
+	virtual uint32_t				getPartCount() const = 0;
+
+	/**
+	\brief Returns an array of length submeshCount()
+	*/
+	virtual const char*				getMaterialName(uint32_t submeshIndex) const = 0;
+
+	/**
+	\brief Returns an submesh
+
+	A submesh contains all the triangles in all parts with the same material
+	(indexed by submeshIndex)
+	*/
+	virtual const RenderSubmesh&	getSubmesh(uint32_t submeshIndex) const = 0;
+
+	/**
+	\brief Returns the axis-aligned bounding box of the vertices for the given part.
+
+	Valid range of partIndex is {0..partCount()-1}
+	*/
+	virtual const PxBounds3&		getBounds(uint32_t partIndex = 0) const = 0;
+
+	/**
+	\brief Returns stats (sizes, counts) for the asset.
+
+	See RenderMeshAssetStats.
+	*/
+	virtual void					getStats(RenderMeshAssetStats& stats) const = 0;
+
+	/**
+	\brief Returns opaque mesh resource (NULL when opaque mesh isn't specified)
+	*/
+	virtual UserOpaqueMesh*			getOpaqueMesh(void) const = 0;
+
+protected:
+	virtual							~RenderMeshAsset() {}
+};
+
+PX_POP_PACK
+
+}
+} // end namespace nvidia::apex
+
+#endif // RENDER_MESH_ASSET_H