Vertex Buffers

The SubmeshDesc contains contains an array of VertexBuffer objects, which just contain format descriptors and pointers to your data. You set these pointers using RenderMeshAssetAuthoring::VertexBuffer::setSemanticData(...):

PX_INLINE void setSemanticData(RenderVertexSemantic::Enum semantic, const void *data, physx::PxU32 stride, RenderDataFormat::Enum format, RenderDataFormat::Enum srcFormat = RenderDataFormat::UNSPECIFIED)

The first argument, semantic, is the data channel you are setting. For example, this may be the vertex position, normal, tangent, uv coordinate, etc. The possible “standard semantics” are given below.

Only these semantics may be set with the setSemanticData function, and only one data channel per semantic is allowed. The data buffer pointer is passed in as a void* pointer in data. The stride field gives the byte difference between one data element and the next. The format field is the format you wish to store the data in, in the created render mesh. If this is same format as the source data (pointed to by data), then you may leave the last parameter at its default. If the source data is a different format, you must specify this format in the last parameter.

The allowed formats are given in RenderDataFormat::Enum (see RenderDataFormat.h). These formats are shown below.

Source and destination formats may be different only if a conversion is defined between the formats. Currently, these conversions are defined:

• BYTE_SNORM1 <=> FLOAT1
• BYTE_SNORM2 <=> FLOAT2
• BYTE_SNORM3 <=> FLOAT3
• BYTE_SNORM4 <=> FLOAT4
• SHORT_SNORM1 <=> FLOAT1
• SHORT_SNORM2 <=> FLOAT2
• SHORT_SNORM3 <=> FLOAT3
• SHORT_SNORM4 <=> FLOAT4
• BYTE_SNORM4_QUATXYZW <=> FLOAT4_QUAT
• SHORT_SNORM4_QUATXYZW <=> FLOAT4_QUAT
• USHORT1 <=> UINT1
• USHORT2 <=> UINT2
• USHORT3 <=> UINT3
• USHORT4 <=> UINT4
• R8G8B8A8 <=> B8G8R8A8
• R8G8B8A8 <=> R32G32B32A32_FLOAT
• R8G8B8A8 <=> B32G32R32A32_FLOAT
• B8G8R8A8 <=> R32G32B32A32_FLOAT
• B8G8R8A8 <=> B32G32R32A32_FLOAT
• R32G32B32A32_FLOAT <=> B32G32R32A32_FLOAT

If you wish to supply other data channels, you may create an array of custom buffer descriptors (RenderMeshAssetAuthoring::VertexBuffer::RenderSemanticData) and pass them into RenderMeshAssetAuthoring::VertexBuffer::setCustomSemanticData(...).

When possible, however, use the standard semantics so that APEX modules which might rely on the data can interpret it correctly. For example, positions should always use the RenderVertexSemantic::POSITION semantic, as many modules rely on vertex positions for various calculations.

Index Buffers

In addition, you supply the mesh’s index buffer in the SubmeshDesc. Currently only triangle primitives (no strips or fans) are supported. If you partition your index buffer(s) into disjoint parts, you can use the SubmeshDesc’s m_partIndices array to specify this partition. The RenderMesh interface allows the user to set visibility on part subsets of the mesh. Note: it is required that the vertex buffer also be similarly partitioned by parts, but this is not enforced in the user’s data. The authoring function will sort the APEX render mesh’s vertex buffer to meet this requirement, however. This means that the final vertex indices may not correspond to your original indices. In order to map the vertices back to your original ordering, you may create a mapping buffer as described below.

The RenderMeshAssetAuthoring::createRenderMesh(...) function takes the MeshDesc descriptor and builds an APEX render mesh asset from it. Its second parameter is the createMappingInformation bool. If this is set to TRUE, then a custom buffer named “VERTEX_ORIGINAL_INDEX” (see VertexBuffer Interface) will be created which is is the original index in the MeshDesc for each vertex. The only time the vertices will be rearranged is when they are made into contiguous parts. There is no further cooking of the mesh data, for example to reduce the vertex buffer by eliminating redundant vertices.

If you wish to reduce your vertex buffer by eliminating redundant vertices, the RenderMeshAssetAuthoring API provides a helper function to do this called createReductionMap(...). It only gives you a map by which you may reduce your vertex data. It will not modify your vertex data for you.

Once you have called RenderMeshAssetAuthoring::createRenderMesh, this authoring class may be used to create an RenderMeshAsset using the standard authorable asset functions (see Loading Assets).

Once you have created an APEX render mesh, you may access it through the RenderMeshAsset interface. This interface gives you the mesh broken into submeshes via the RenderMeshAsset::getSubmesh method. This method returns an RenderSubmesh interface. Through that, you can access the mesh’s vertex buffer using RenderSubmesh::getVertexBuffer, which returns an VertexBuffer interface.