Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 367 insertions, 0 deletions

diff --git a/PhysX_3.4/Samples/SampleVehicle/SampleVehicleDebugRender.cpp b/PhysX_3.4/Samples/SampleVehicle/SampleVehicleDebugRender.cpp
new file mode 100644
index 00000000..233bad36
--- /dev/null
+++ b/PhysX_3.4/Samples/SampleVehicle/SampleVehicleDebugRender.cpp
@@ -0,0 +1,367 @@
+// 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.
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#include "SampleVehicle.h"
+#include "RenderPhysX3Debug.h"
+#include "PxRigidDynamic.h"
+#include "SampleVehicle_VehicleManager.h"
+
+using namespace SampleRenderer;
+
+// PT: this file contains the part of SampleVehicle dealing with cars' debug rendering
+
+void SampleVehicle::drawWheels()
+{
+	PxSceneReadLock scopedLock(*mScene);
+	const RendererColor colorPurple(255, 0, 255);
+
+	for(PxU32 i=0;i<mVehicleManager.getNbVehicles();i++)
+	{
+		//Draw a rotating arrow to get an idea of the wheel rotation speed.
+		PxVehicleWheels* veh=mVehicleManager.getVehicle(i);
+		const PxRigidDynamic* actor=veh->getRigidDynamicActor();
+		PxShape* shapeBuffer[PX_MAX_NB_WHEELS];
+		actor->getShapes(shapeBuffer,veh->mWheelsSimData.getNbWheels());
+		const PxTransform vehGlobalPose=actor->getGlobalPose();
+		const PxU32 numWheels=veh->mWheelsSimData.getNbWheels();
+		for(PxU32 j=0;j<numWheels;j++)
+		{
+			const PxTransform wheelTransform=vehGlobalPose.transform(shapeBuffer[j]->getLocalPose());
+			const PxF32 wheelRadius=veh->mWheelsSimData.getWheelData(j).mRadius;
+			const PxF32 wheelHalfWidth=veh->mWheelsSimData.getWheelData(j).mWidth*0.5f;
+			PxVec3 offset=wheelTransform.q.getBasisVector0()*wheelHalfWidth;
+			offset*= (veh->mWheelsSimData.getWheelCentreOffset(j).x > 0) ? 1.0f : -1.0f;
+			const PxVec3 arrow=wheelTransform.rotate(PxVec3(0,0,1));
+			getDebugRenderer()->addLine(wheelTransform.p+offset, wheelTransform.p+offset+arrow*wheelRadius, colorPurple);
+		}
+	}
+}
+
+void SampleVehicle::drawVehicleDebug()
+{
+	PxSceneReadLock scopedLock(*mScene);
+	const RendererColor colorColl(255, 0, 0);
+	const RendererColor colorCol2(0, 255, 0);
+	const RendererColor colorCol3(0, 0, 255);
+	
+#if PX_DEBUG_VEHICLE_ON
+	const PxVec3* tireForceAppPoints=NULL;
+	const PxVec3* suspForceAppPoints=NULL;
+	switch(mPlayerVehicleType)
+	{
+	case ePLAYER_VEHICLE_TYPE_VEHICLE4W:
+	case ePLAYER_VEHICLE_TYPE_TANK4W:
+		tireForceAppPoints=mTelemetryData4W->getTireforceAppPoints();
+		suspForceAppPoints=mTelemetryData4W->getSuspforceAppPoints();
+		break;
+	case ePLAYER_VEHICLE_TYPE_VEHICLE6W:
+	case ePLAYER_VEHICLE_TYPE_TANK6W:
+		tireForceAppPoints=mTelemetryData6W->getTireforceAppPoints();
+		suspForceAppPoints=mTelemetryData6W->getSuspforceAppPoints();
+		break;
+	default:
+		PX_ASSERT(false);
+		break;
+	}
+#endif
+
+	const PxVehicleWheels& vehicle4W=*mVehicleManager.getVehicle(mPlayerVehicle);
+	const PxVehicleWheelQueryResult& vehicleWheelQueryResults=mVehicleManager.getVehicleWheelQueryResults(mPlayerVehicle);
+	const PxRigidDynamic* actor=vehicle4W.getRigidDynamicActor();
+	const PxU32 numWheels=vehicle4W.mWheelsSimData.getNbWheels();
+	PxVec3 v[8];
+	PxVec3 w[8];
+	PxF32 l[8];
+	for(PxU32 i=0;i<numWheels;i++)
+	{
+		v[i] = vehicleWheelQueryResults.wheelQueryResults[i].suspLineStart;
+		w[i] = vehicleWheelQueryResults.wheelQueryResults[i].suspLineDir;
+		l[i] = vehicleWheelQueryResults.wheelQueryResults[i].suspLineLength;
+	}
+
+
+	const PxTransform t=actor->getGlobalPose().transform(actor->getCMassLocalPose());
+	const PxVec3 dirs[3]={t.rotate(PxVec3(1,0,0)),t.rotate(PxVec3(0,1,0)),t.rotate(PxVec3(0,0,1))};
+	getDebugRenderer()->addLine(t.p, t.p + dirs[0]*4.0f, colorColl);
+	getDebugRenderer()->addLine(t.p, t.p + dirs[1]*4.0f, colorColl);
+	getDebugRenderer()->addLine(t.p, t.p + dirs[2]*4.0f, colorColl);
+
+	for(PxU32 j=0;j<numWheels;j++)
+	{
+		getDebugRenderer()->addLine(v[j], v[j]+w[j]*l[j], colorColl);
+
+#if PX_DEBUG_VEHICLE_ON
+		//Draw all tire force app points.
+		const PxVec3& appPoint = tireForceAppPoints[j];
+		getDebugRenderer()->addLine(appPoint - dirs[0], appPoint + dirs[0], colorCol2);
+		getDebugRenderer()->addLine(appPoint - dirs[2], appPoint + dirs[2], colorCol2);
+
+		//Draw all susp force app points.
+		const PxVec3& appPoint2 = suspForceAppPoints[j];
+		getDebugRenderer()->addLine(appPoint2 - dirs[0], appPoint2 + dirs[0], colorCol3);
+		getDebugRenderer()->addLine(appPoint2 - dirs[2], appPoint2 + dirs[2], colorCol3);
+#endif
+	}
+}
+
+static void drawBox2D(Renderer* renderer, PxF32 minX, PxF32 maxX, PxF32 minY, PxF32 maxY, const RendererColor& color, PxF32 alpha)
+{
+	ScreenQuad sq;
+	sq.mX0				= minX;
+	sq.mY0				= 1.0f - minY;
+	sq.mX1				= maxX;
+	sq.mY1				= 1.0f - maxY;
+	sq.mLeftUpColor		= color;
+	sq.mRightUpColor	= color;
+	sq.mLeftDownColor	= color;
+	sq.mRightDownColor	= color;
+	sq.mAlpha			= alpha;
+
+	renderer->drawScreenQuad(sq);
+}
+
+static void print(Renderer* renderer, PxF32 x, PxF32 y, PxF32 scale_, const char* text)
+{
+	PxU32 width, height;
+	renderer->getWindowSize(width, height);
+
+	y = 1.0f - y;
+
+	const PxReal scale = scale_*20.0f;
+	const PxReal shadowOffset = 6.0f;
+	const RendererColor textColor(255, 255, 255, 255);
+
+	renderer->print(PxU32(x*PxF32(width)), PxU32(y*PxF32(height)), text, scale, shadowOffset, textColor);
+}
+
+void SampleVehicle::drawHud()
+{
+	const PxVehicleWheels& focusVehicle = *mVehicleManager.getVehicle(mPlayerVehicle);
+	PxVehicleDriveDynData* driveDynData=NULL;
+	PxVehicleDriveSimData* driveSimData=NULL;
+	switch(focusVehicle.getVehicleType())
+	{
+	case PxVehicleTypes::eDRIVE4W:
+		{
+			PxVehicleDrive4W& vehDrive4W=(PxVehicleDrive4W&)focusVehicle;
+			driveDynData=&vehDrive4W.mDriveDynData;
+			driveSimData=&vehDrive4W.mDriveSimData;
+		}
+		break;
+	case PxVehicleTypes::eDRIVENW:
+		{
+			PxVehicleDriveNW& vehDriveNW=(PxVehicleDriveNW&)focusVehicle;
+			driveDynData=&vehDriveNW.mDriveDynData;
+			driveSimData=&vehDriveNW.mDriveSimData;
+		}
+		break;
+	case PxVehicleTypes::eDRIVETANK:
+		{
+			PxVehicleDriveTank& vehDriveTank=(PxVehicleDriveTank&)focusVehicle;
+			driveDynData=&vehDriveTank.mDriveDynData;
+			driveSimData=&vehDriveTank.mDriveSimData;
+		}
+		break;
+	default:
+		PX_ASSERT(false);
+		break;
+	}
+
+	const PxU32 currentGear=driveDynData->getCurrentGear();
+	const PxF32 vz=mForwardSpeedHud*3.6f;
+	const PxF32 revs=driveDynData->getEngineRotationSpeed();
+	const PxF32 maxRevs=driveSimData->getEngineData().mMaxOmega*60*0.5f/PxPi;//Convert from radians per second to rpm
+	const PxF32 invMaxRevs=driveSimData->getEngineData().getRecipMaxOmega();
+
+	//Draw gears and speed.
+
+	const PxF32 x=0.5f;
+	const PxF32 y=0.18f;
+	const PxF32 length=0.1f;
+	const PxF32 textheight=0.02f;
+
+	Renderer* renderer = getRenderer();
+	drawBox2D(renderer, x-length-textheight, x+length+textheight, y, y+length+textheight, RendererColor(255, 255, 255), 0.5f);
+
+	//Gear
+	char gear[PxVehicleGearsData::eGEARSRATIO_COUNT][64]=
+	{
+		"R","N","1","2","3","4","5"
+	};
+	print(renderer, x-0.25f*textheight, y+0.02f, 0.02f, gear[currentGear]);
+
+	//Speed
+	char speed[64];
+	sprintf(speed, "%1.0f %s",  PxAbs(vz), "kmph");
+	print(renderer, x-textheight, y+length-textheight, textheight, speed);
+
+	//Revs
+	{
+		const PxF32 xy[4]={x, 1.0f-y, x-length, 1.0f-(y+length)};
+		renderer->drawLines2D(2, xy, RendererColor(0, 0, 255));
+
+		char buffer[64];
+		sprintf(buffer, "%d \n", 0);
+		print(renderer, x-length, y+length, textheight, buffer);
+	}
+	{
+		const PxF32 xy[4]={x, 1.0f-y, x+length, 1.0f-(y+length)};
+		renderer->drawLines2D(2, xy, RendererColor(0, 0, 255));
+
+		char buffer[64];
+		sprintf(buffer, "%1.0f \n", maxRevs);
+		print(renderer, x+length-2*textheight, y+length, textheight, buffer);
+	}
+	{
+		const PxF32 alpha=revs*invMaxRevs;
+		const PxF32 dx=-(1.0f-alpha)*length + alpha*length;
+		const PxF32 xy[4]={x, 1.0f-y, x+dx, 1.0f-(y+length)};
+		renderer->drawLines2D(2, xy, RendererColor(255, 0, 0));
+	}
+}
+
+#if PX_DEBUG_VEHICLE_ON
+
+static PX_FORCE_INLINE RendererColor getColor(const PxVec3& c)
+{
+	return RendererColor(PxU8(c.x), PxU8(c.y), PxU8(c.z));
+}
+
+static PX_FORCE_INLINE void convertColors(const PxVec3* src, RendererColor* dst)
+{
+	for(PxU32 i=0;i<PxVehicleGraph::eMAX_NB_SAMPLES;i++)
+		*dst++ = getColor(src[i]);
+}
+
+static void convertY(PxF32* xy)
+{
+	for(PxU32 i=0;i<PxVehicleGraph::eMAX_NB_SAMPLES;i++)
+		xy[2*i+1]=1.0f-xy[2*i+1];
+}
+
+#endif //PX_DEBUG_VEHICLE_ON
+
+#if PX_DEBUG_VEHICLE_ON
+
+void drawGraphsAndPrintTireSurfaceTypesN
+(const PxVehicleTelemetryData& telemetryData, const PxU32* tireTypes, const PxU32* surfaceTypes,
+ const PxU32 activeEngineGraphChannel, const PxU32 activeWheelGraphChannel,
+ SampleRenderer::Renderer* renderer)
+{
+
+	PxF32 xy[2*PxVehicleGraph::eMAX_NB_SAMPLES];
+	PxVec3 color[PxVehicleGraph::eMAX_NB_SAMPLES];
+	RendererColor rendererColor[PxVehicleGraph::eMAX_NB_SAMPLES];
+	char title[PxVehicleGraph::eMAX_NB_TITLE_CHARS];
+
+	const PxU32 numWheelGraphs=telemetryData.getNbWheelGraphs();
+
+	for(PxU32 i=0;i<numWheelGraphs;i++)
+	{
+		PxF32 xMin,xMax,yMin,yMax;
+		telemetryData.getWheelGraph(i).getBackgroundCoords(xMin,yMin,xMax,yMax);
+		const PxVec3& backgroundColor=telemetryData.getWheelGraph(i).getBackgroundColor();
+		const PxF32 alpha=telemetryData.getWheelGraph(i).getBackgroundAlpha();
+		drawBox2D(renderer, xMin,xMax,yMin,yMax, getColor(backgroundColor),alpha);
+
+		telemetryData.getWheelGraph(i).computeGraphChannel(activeWheelGraphChannel,xy,color,title);
+		convertY(xy);
+		convertColors(color, rendererColor);
+		renderer->drawLines2D(PxVehicleGraph::eMAX_NB_SAMPLES, xy, rendererColor);
+
+		print(renderer, xMin,yMax-0.02f, 0.02f, title);
+
+		const PxU32 tireType=tireTypes[i];
+		const PxU32 tireSurfaceType=surfaceTypes[i];
+
+		if (PxVehicleDrivableSurfaceType::eSURFACE_TYPE_UNKNOWN!=tireSurfaceType)
+		{
+			const char* surfaceType= SurfaceTypeNames::getName(tireSurfaceType);
+			const PxF32 friction=TireFrictionMultipliers::getValue(tireSurfaceType, tireType);
+			char surfaceDetails[64];
+			sprintf(surfaceDetails, "%s %1.2f \n", surfaceType, friction);
+			print(renderer, xMin+0.1f, yMax-0.12f, 0.02f, surfaceDetails);
+		}
+	}
+
+	PxF32 xMin,xMax,yMin,yMax;
+	telemetryData.getEngineGraph().getBackgroundCoords(xMin,yMin,xMax,yMax);
+	const PxVec3& backgroundColor=telemetryData.getEngineGraph().getBackgroundColor();
+	const PxF32 alpha=telemetryData.getEngineGraph().getBackgroundAlpha();
+	drawBox2D(renderer, xMin,xMax,yMin,yMax, getColor(backgroundColor),alpha);
+
+	telemetryData.getEngineGraph().computeGraphChannel(activeEngineGraphChannel,xy,color,title);
+	convertY(xy);
+	convertColors(color, rendererColor);
+	renderer->drawLines2D(PxVehicleGraph::eMAX_NB_SAMPLES, xy, rendererColor);
+
+	print(renderer, xMin,yMax-0.02f,0.02f,title);
+}
+
+#endif //PX_DEBUG_VEHICLE_GRAPH_ON
+
+void SampleVehicle::drawGraphsAndPrintTireSurfaceTypes(const PxVehicleWheels& focusVehicle, const PxVehicleWheelQueryResult& focusVehicleWheelQueryResults)
+{
+#if PX_DEBUG_VEHICLE_ON
+
+	PxU32 tireTypes[8];
+	PxU32 surfaceTypes[8];
+	const PxU32 numWheels=focusVehicle.mWheelsSimData.getNbWheels();
+	PX_ASSERT(numWheels<=8);
+	for(PxU32 i=0;i<numWheels;i++)
+	{
+		tireTypes[i]=focusVehicle.mWheelsSimData.getTireData(i).mType;
+		surfaceTypes[i]=focusVehicleWheelQueryResults.wheelQueryResults[i].tireSurfaceType;
+	}
+
+	PxVehicleTelemetryData* vehTelData=NULL;
+	switch(mPlayerVehicleType)
+	{
+	case ePLAYER_VEHICLE_TYPE_VEHICLE4W:
+	case ePLAYER_VEHICLE_TYPE_TANK4W:
+		vehTelData=mTelemetryData4W;
+		break;
+	case ePLAYER_VEHICLE_TYPE_VEHICLE6W:
+	case ePLAYER_VEHICLE_TYPE_TANK6W:
+		vehTelData=mTelemetryData6W;
+		break;
+	default:
+		PX_ASSERT(false);
+		break;
+	}
+
+	drawGraphsAndPrintTireSurfaceTypesN(
+		*vehTelData,tireTypes,surfaceTypes,
+		mDebugRenderActiveGraphChannelEngine,mDebugRenderActiveGraphChannelWheel,
+		getRenderer());
+
+#endif
+}
+
+