Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 171 insertions, 0 deletions

diff --git a/PhysX_3.4/Samples/SampleFramework/renderer/src/RendererMeshShape.cpp b/PhysX_3.4/Samples/SampleFramework/renderer/src/RendererMeshShape.cpp
new file mode 100644
index 00000000..94e167bb
--- /dev/null
+++ b/PhysX_3.4/Samples/SampleFramework/renderer/src/RendererMeshShape.cpp
@@ -0,0 +1,171 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and 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.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2016 NVIDIA Corporation. All rights reserved.
+
+#include <RendererMeshShape.h>
+
+#include <Renderer.h>
+
+#include <RendererVertexBuffer.h>
+#include <RendererVertexBufferDesc.h>
+
+#include <RendererIndexBuffer.h>
+#include <RendererIndexBufferDesc.h>
+
+#include <RendererMesh.h>
+#include <RendererMeshDesc.h>
+
+#include <RendererMemoryMacros.h>
+
+using namespace SampleRenderer;
+
+RendererMeshShape::RendererMeshShape(	Renderer& renderer, 
+	const PxVec3* verts, PxU32 numVerts, 
+	const PxVec3* normals,
+	const PxReal* uvs,
+	const PxU16* faces16, const PxU32* faces32, PxU32 numFaces, bool flipWinding) :
+RendererShape(renderer)
+{
+	RENDERER_ASSERT((faces16 || faces32), "Needs either 16bit or 32bit indices.");
+	RendererVertexBufferDesc vbdesc;
+	vbdesc.hint = RendererVertexBuffer::HINT_STATIC;
+	vbdesc.semanticFormats[RendererVertexBuffer::SEMANTIC_POSITION]  = RendererVertexBuffer::FORMAT_FLOAT3;
+	vbdesc.semanticFormats[RendererVertexBuffer::SEMANTIC_NORMAL]    = RendererVertexBuffer::FORMAT_FLOAT3;
+	vbdesc.semanticFormats[RendererVertexBuffer::SEMANTIC_TEXCOORD0] = RendererVertexBuffer::FORMAT_FLOAT2;
+	vbdesc.maxVertices = numVerts;
+	m_vertexBuffer = m_renderer.createVertexBuffer(vbdesc);
+	RENDERER_ASSERT(m_vertexBuffer, "Failed to create Vertex Buffer.");
+	if(m_vertexBuffer)
+	{
+		PxU32 positionStride = 0;
+		void* vertPositions = m_vertexBuffer->lockSemantic(RendererVertexBuffer::SEMANTIC_POSITION, positionStride);
+
+		PxU32 normalStride = 0;
+		void* vertNormals = m_vertexBuffer->lockSemantic(RendererVertexBuffer::SEMANTIC_NORMAL, normalStride);
+
+		PxU32 uvStride = 0;
+		void* vertUVs = m_vertexBuffer->lockSemantic(RendererVertexBuffer::SEMANTIC_TEXCOORD0, uvStride);
+
+		if(vertPositions && vertNormals && vertUVs)
+		{
+			for(PxU32 i=0; i<numVerts; i++)
+			{
+				memcpy(vertPositions, verts+i, sizeof(PxVec3));
+				if(normals)
+					memcpy(vertNormals, normals+i, sizeof(PxVec3));
+				else
+					memset(vertNormals, 0, sizeof(PxVec3));
+
+				if(uvs)
+					memcpy(vertUVs, uvs+i*2, sizeof(PxReal)*2);
+				else
+					memset(vertUVs, 0, sizeof(PxReal)*2);
+
+				vertPositions = (void*)(((PxU8*)vertPositions) + positionStride);
+				vertNormals   = (void*)(((PxU8*)vertNormals)   + normalStride);
+				vertUVs       = (void*)(((PxU8*)vertUVs)       + uvStride);
+			}
+		}
+		m_vertexBuffer->unlockSemantic(RendererVertexBuffer::SEMANTIC_NORMAL);
+		m_vertexBuffer->unlockSemantic(RendererVertexBuffer::SEMANTIC_POSITION);
+		m_vertexBuffer->unlockSemantic(RendererVertexBuffer::SEMANTIC_TEXCOORD0);
+	}
+
+	const PxU32 numIndices = numFaces*3;
+
+	RendererIndexBufferDesc ibdesc;
+	ibdesc.hint       = RendererIndexBuffer::HINT_STATIC;
+	ibdesc.format     = faces16 ? RendererIndexBuffer::FORMAT_UINT16 : RendererIndexBuffer::FORMAT_UINT32;
+	ibdesc.maxIndices = numIndices;
+	m_indexBuffer = m_renderer.createIndexBuffer(ibdesc);
+	RENDERER_ASSERT(m_indexBuffer, "Failed to create Index Buffer.");
+	if(m_indexBuffer)
+	{
+		if(faces16)
+		{
+			PxU16* indices = (PxU16*)m_indexBuffer->lock();
+			if(indices)
+			{
+				if(flipWinding)
+				{
+					for(PxU32 i=0;i<numFaces;i++)
+					{
+						indices[i*3+0] = faces16[i*3+0];
+						indices[i*3+1] = faces16[i*3+2];
+						indices[i*3+2] = faces16[i*3+1];
+					}
+				}
+				else
+				{
+					memcpy(indices, faces16, sizeof(*faces16)*numFaces*3);
+				}
+			}
+		}
+		else
+		{
+			PxU32* indices = (PxU32*)m_indexBuffer->lock();
+			if(indices)
+			{
+				if(flipWinding)
+				{
+					for(PxU32 i=0;i<numFaces;i++)
+					{
+						indices[i*3+0] = faces32[i*3+0];
+						indices[i*3+1] = faces32[i*3+2];
+						indices[i*3+2] = faces32[i*3+1];
+					}
+				}
+				else
+				{
+					memcpy(indices, faces32, sizeof(*faces32)*numFaces*3);
+				}
+			}
+		}
+		m_indexBuffer->unlock();
+	}
+
+	if(m_vertexBuffer && m_indexBuffer)
+	{
+		RendererMeshDesc meshdesc;
+		meshdesc.primitives       = RendererMesh::PRIMITIVE_TRIANGLES;
+		meshdesc.vertexBuffers    = &m_vertexBuffer;
+		meshdesc.numVertexBuffers = 1;
+		meshdesc.firstVertex      = 0;
+		meshdesc.numVertices      = numVerts;
+		meshdesc.indexBuffer      = m_indexBuffer;
+		meshdesc.firstIndex       = 0;
+		meshdesc.numIndices       = numIndices;
+		m_mesh = m_renderer.createMesh(meshdesc);
+		RENDERER_ASSERT(m_mesh, "Failed to create Mesh.");
+	}
+}
+
+RendererMeshShape::~RendererMeshShape(void)
+{
+	SAFE_RELEASE(m_vertexBuffer);
+	SAFE_RELEASE(m_indexBuffer);
+	SAFE_RELEASE(m_mesh);
+}