Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 274 insertions, 0 deletions

diff --git a/PhysX_3.4/Samples/SampleBase/SampleCameraController.cpp b/PhysX_3.4/Samples/SampleBase/SampleCameraController.cpp
new file mode 100644
index 00000000..161a0928
--- /dev/null
+++ b/PhysX_3.4/Samples/SampleBase/SampleCameraController.cpp
@@ -0,0 +1,274 @@
+// 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 "SamplePreprocessor.h"
+#include "SampleCameraController.h"
+#include "SampleCamera.h"
+#include "SampleApplication.h"
+#include "SamplePlatform.h"
+#include "PsUtilities.h"
+#include "SampleBaseInputEventIds.h"
+#include <SampleFrameworkInputEventIds.h>
+#include "SampleUserInputDefines.h"
+
+#include <SampleUserInputIds.h>
+
+using namespace physx;
+using namespace SampleRenderer;
+using namespace SampleFramework;
+
+// PT: this replicates the default SampleApplication behaviour, but with a much better design. We
+// want to be able to isolate & replace the camera controlling code easily.
+
+static const float g_smoothCamBaseVel  = 6.0f;
+static const float g_smoothCamPosLerp  = 0.4f;
+static const float g_smoothCamFastMul = 4.0f;
+
+static const float g_smoothCamRotSpeed = 0.005f;
+static const float g_smoothCamRotLerp  = 0.4f;
+
+static PxReal	gGamepadYawInc			= 0.0f;
+static PxReal	gGamepadPitchInc		= 0.0f;
+static PxReal	gGamepadForwardInc		= 0.0f;
+static PxReal	gGamepadLateralInc		= 0.0f;
+
+static PxVec3 QuatToEuler(const PxQuat& q)
+{
+	PxVec3 dir = -PxMat33(q)[2];
+	PxReal r = PxSqrt(dir.x * dir.x + dir.z * dir.z);
+	PxVec3 rot(0.0f, PxHalfPi, 0.0f);
+	if (r != 0.0f)
+	{
+		rot.x = -PxAtan(dir.y / r);
+		rot.y =  PxAsin(dir.x / r);
+		if (dir.z > 0.0f)
+			rot.y = PxPi - rot.y;
+	}
+
+	return rot;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+DefaultCameraController::DefaultCameraController() :
+	mMouseButtonDown		(false),
+	mKeyFWDown				(false),
+	mKeyBKDown				(false),
+	mKeyRTDown				(false),
+	mKeyLTDown				(false),
+	mKeyUpDown				(false),
+	mKeyDownDown			(false),
+	mKeyShiftDown			(false),
+	mCameraSpeed			(0.f),
+	mCameraSpeedMultiplier	(1.f),
+	mMouseLookOnMB			(true), 
+	mMouseSensitivity		(1.f)
+{
+	mTargetEyePos	= PxVec3(0);
+	mTargetEyeRot	= PxVec3(0);
+	mEyePos			= PxVec3(0);
+	mEyeRot			= PxVec3(0);
+}
+
+DefaultCameraController::~DefaultCameraController()
+{
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void DefaultCameraController::init(const PxVec3& pos, const PxVec3& rot)
+{
+	mTargetEyePos = mEyePos = pos;
+	mTargetEyeRot = mEyeRot = rot;
+}
+
+void DefaultCameraController::init(const PxTransform& pose)
+{
+	init(pose.p, QuatToEuler(pose.q));
+}
+
+void DefaultCameraController::onPointerInputEvent(const InputEvent& ie, physx::PxU32 x, physx::PxU32 y, physx::PxReal dx, physx::PxReal dy, bool val)
+{
+	switch (ie.m_Id)
+	{
+	case CAMERA_MOUSE_LOOK:
+		{
+			if (!mMouseLookOnMB || mMouseButtonDown)
+				onMouseDelta(static_cast<physx::PxI32>(dx), static_cast<physx::PxI32>(dy));
+		}
+		break;
+	case MOUSE_LOOK_BUTTON:
+		{
+			mMouseButtonDown = val;
+		}
+		break;
+	}
+
+}
+
+void DefaultCameraController::onMouseDelta(PxI32 dx, PxI32 dy)
+{
+	mTargetEyeRot.x -= dy * mMouseSensitivity * g_smoothCamRotSpeed;
+	mTargetEyeRot.y += dx * mMouseSensitivity * g_smoothCamRotSpeed;
+}
+
+void DefaultCameraController::collectInputEvents(std::vector<const InputEvent*>& inputEvents)
+{
+	//digital keyboard events
+	DIGITAL_INPUT_EVENT_DEF(CAMERA_MOVE_FORWARD,											SCAN_CODE_FORWARD,		XKEY_W,					X1KEY_W,				PS3KEY_W,				PS4KEY_W,				AKEY_UNKNOWN,			SCAN_CODE_FORWARD,		IKEY_UNKNOWN,			SCAN_CODE_FORWARD,		WIIUKEY_UNKNOWN);
+	DIGITAL_INPUT_EVENT_DEF(CAMERA_MOVE_BACKWARD,											SCAN_CODE_BACKWARD,		XKEY_S,					X1KEY_S,				PS3KEY_S,				PS4KEY_S,				AKEY_UNKNOWN,			SCAN_CODE_BACKWARD,		IKEY_UNKNOWN,			SCAN_CODE_BACKWARD,		WIIUKEY_UNKNOWN);
+	DIGITAL_INPUT_EVENT_DEF(CAMERA_MOVE_UP,													SCAN_CODE_UP,			XKEY_E,					X1KEY_E,				PS3KEY_E,				PS4KEY_E,				AKEY_UNKNOWN,			SCAN_CODE_UP,			IKEY_UNKNOWN,			SCAN_CODE_UP,			WIIUKEY_UNKNOWN);
+	DIGITAL_INPUT_EVENT_DEF(CAMERA_MOVE_DOWN,												SCAN_CODE_DOWN,			XKEY_C,					X1KEY_C,				PS3KEY_C,				PS4KEY_C,				AKEY_UNKNOWN,			SCAN_CODE_DOWN,			IKEY_UNKNOWN,			SCAN_CODE_DOWN,			WIIUKEY_UNKNOWN);
+	DIGITAL_INPUT_EVENT_DEF(CAMERA_MOVE_LEFT,												SCAN_CODE_LEFT,			XKEY_A,					X1KEY_A,				PS3KEY_A,				PS4KEY_A,				AKEY_UNKNOWN,			SCAN_CODE_LEFT,			IKEY_UNKNOWN,			SCAN_CODE_LEFT,			WIIUKEY_UNKNOWN);
+	DIGITAL_INPUT_EVENT_DEF(CAMERA_MOVE_RIGHT,												SCAN_CODE_RIGHT,		XKEY_D,					X1KEY_D,				PS3KEY_D,				PS4KEY_D,				AKEY_UNKNOWN,			SCAN_CODE_RIGHT,		IKEY_UNKNOWN,			SCAN_CODE_RIGHT,		WIIUKEY_UNKNOWN);
+	DIGITAL_INPUT_EVENT_DEF(CAMERA_SHIFT_SPEED,												SCAN_CODE_LEFT_SHIFT,	XKEY_SHIFT,				X1KEY_SHIFT,			PS3KEY_SHIFT,			PS4KEY_SHIFT,			AKEY_UNKNOWN,			OSXKEY_SHIFT,			IKEY_UNKNOWN,			LINUXKEY_SHIFT,			WIIUKEY_UNKNOWN);
+	DIGITAL_INPUT_EVENT_DEF(CAMERA_SPEED_INCREASE,											WKEY_ADD,				XKEY_ADD,				X1KEY_ADD,				PS3KEY_ADD,				PS4KEY_ADD,				AKEY_UNKNOWN,			OSXKEY_ADD,				IKEY_UNKNOWN,			LINUXKEY_ADD,			WIIUKEY_UNKNOWN);
+	DIGITAL_INPUT_EVENT_DEF(CAMERA_SPEED_DECREASE,											WKEY_SUBTRACT,			XKEY_SUBTRACT,			X1KEY_SUBTRACT,			PS3KEY_SUBTRACT,		PS4KEY_SUBTRACT,		AKEY_UNKNOWN,			OSXKEY_SUBTRACT,		IKEY_UNKNOWN,			LINUXKEY_SUBTRACT,		WIIUKEY_UNKNOWN);
+														
+	//digital mouse events																					
+	DIGITAL_INPUT_EVENT_DEF(MOUSE_LOOK_BUTTON,												MOUSE_BUTTON_LEFT,		XKEY_UNKNOWN,			X1KEY_UNKNOWN,			PS3KEY_UNKNOWN,			PS4KEY_UNKNOWN,			AKEY_UNKNOWN,			MOUSE_BUTTON_LEFT,		IKEY_UNKNOWN,			LINUXKEY_UNKNOWN,		WIIUKEY_UNKNOWN);
+									
+	//digital gamepad events																
+	DIGITAL_INPUT_EVENT_DEF(CAMERA_SPEED_INCREASE,											GAMEPAD_LEFT_STICK,		GAMEPAD_LEFT_STICK,		GAMEPAD_LEFT_STICK,		GAMEPAD_LEFT_STICK,		GAMEPAD_LEFT_STICK,		AKEY_UNKNOWN,			OSXKEY_UNKNOWN,			IKEY_UNKNOWN,			LINUXKEY_UNKNOWN,		GAMEPAD_LEFT_STICK);
+	DIGITAL_INPUT_EVENT_DEF(CAMERA_SPEED_DECREASE,											GAMEPAD_RIGHT_STICK,	GAMEPAD_RIGHT_STICK,	GAMEPAD_RIGHT_STICK,	GAMEPAD_LEFT_STICK,		GAMEPAD_LEFT_STICK,		AKEY_UNKNOWN,			OSXKEY_UNKNOWN,			IKEY_UNKNOWN,			LINUXKEY_UNKNOWN,		GAMEPAD_RIGHT_STICK);
+
+	//analog gamepad events
+	ANALOG_INPUT_EVENT_DEF(CAMERA_GAMEPAD_ROTATE_LEFT_RIGHT, GAMEPAD_ROTATE_SENSITIVITY,	GAMEPAD_RIGHT_STICK_X,	GAMEPAD_RIGHT_STICK_X,	GAMEPAD_RIGHT_STICK_X,	GAMEPAD_RIGHT_STICK_X,	GAMEPAD_RIGHT_STICK_X,	GAMEPAD_RIGHT_STICK_X,	GAMEPAD_RIGHT_STICK_X,	GAMEPAD_RIGHT_STICK_X,	LINUXKEY_UNKNOWN,		GAMEPAD_RIGHT_STICK_X);
+	ANALOG_INPUT_EVENT_DEF(CAMERA_GAMEPAD_ROTATE_UP_DOWN, GAMEPAD_ROTATE_SENSITIVITY,		GAMEPAD_RIGHT_STICK_Y,	GAMEPAD_RIGHT_STICK_Y,	GAMEPAD_RIGHT_STICK_Y,	GAMEPAD_RIGHT_STICK_Y,	GAMEPAD_RIGHT_STICK_Y,	GAMEPAD_RIGHT_STICK_Y,	GAMEPAD_RIGHT_STICK_Y,	GAMEPAD_RIGHT_STICK_Y,	LINUXKEY_UNKNOWN,		GAMEPAD_RIGHT_STICK_Y);
+	ANALOG_INPUT_EVENT_DEF(CAMERA_GAMEPAD_MOVE_LEFT_RIGHT, GAMEPAD_DEFAULT_SENSITIVITY,		GAMEPAD_LEFT_STICK_X,	GAMEPAD_LEFT_STICK_X,	GAMEPAD_LEFT_STICK_X,	GAMEPAD_LEFT_STICK_X,	GAMEPAD_LEFT_STICK_X,	GAMEPAD_LEFT_STICK_X,	GAMEPAD_LEFT_STICK_X,	GAMEPAD_LEFT_STICK_X,	LINUXKEY_UNKNOWN,		GAMEPAD_LEFT_STICK_X);
+	ANALOG_INPUT_EVENT_DEF(CAMERA_GAMEPAD_MOVE_FORWARD_BACK, GAMEPAD_DEFAULT_SENSITIVITY,	GAMEPAD_LEFT_STICK_Y,	GAMEPAD_LEFT_STICK_Y,	GAMEPAD_LEFT_STICK_Y,	GAMEPAD_LEFT_STICK_Y,	GAMEPAD_LEFT_STICK_Y,	GAMEPAD_LEFT_STICK_Y,	GAMEPAD_LEFT_STICK_Y,	GAMEPAD_LEFT_STICK_Y,	LINUXKEY_UNKNOWN,		GAMEPAD_LEFT_STICK_Y);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void DefaultCameraController::onDigitalInputEvent(const SampleFramework::InputEvent& ie, bool val)
+{
+	if(val)
+	{
+				if(ie.m_Id == CAMERA_MOVE_FORWARD)	mKeyFWDown = true;
+		else	if(ie.m_Id == CAMERA_MOVE_UP)	mKeyUpDown = true;
+		else	if(ie.m_Id == CAMERA_MOVE_BACKWARD)	mKeyBKDown = true;
+		else	if(ie.m_Id == CAMERA_MOVE_LEFT)	mKeyLTDown = true;
+		else	if(ie.m_Id == CAMERA_MOVE_RIGHT)	mKeyRTDown = true;
+		else	if(ie.m_Id == CAMERA_SHIFT_SPEED)	mKeyShiftDown = true;
+		else    if(ie.m_Id == CAMERA_MOVE_DOWN)	mKeyDownDown = true;
+		else	if(ie.m_Id == CAMERA_SPEED_DECREASE) mCameraSpeedMultiplier *= 0.5f;
+		else	if(ie.m_Id == CAMERA_SPEED_INCREASE) mCameraSpeedMultiplier *= 2.0f;
+	}
+	else
+	{
+				if(ie.m_Id == CAMERA_MOVE_FORWARD)	mKeyFWDown = false;
+		else	if(ie.m_Id == CAMERA_MOVE_UP)	mKeyUpDown = false;
+		else	if(ie.m_Id == CAMERA_MOVE_BACKWARD)	mKeyBKDown = false;
+		else	if(ie.m_Id == CAMERA_MOVE_LEFT)	mKeyLTDown = false;
+		else	if(ie.m_Id == CAMERA_MOVE_RIGHT)	mKeyRTDown = false;
+		else	if(ie.m_Id == CAMERA_SHIFT_SPEED)	mKeyShiftDown = false;
+		else    if(ie.m_Id == CAMERA_MOVE_DOWN)	mKeyDownDown = false;
+	}
+}
+
+static PX_FORCE_INLINE PxReal remapAxisValue(PxReal absolutePosition)
+{
+	return absolutePosition * absolutePosition * absolutePosition * 5.0f;
+}
+
+void DefaultCameraController::onAnalogInputEvent(const SampleFramework::InputEvent& ie, float val)
+{
+	if(ie.m_Id == CAMERA_GAMEPAD_ROTATE_LEFT_RIGHT)
+	{
+		gGamepadYawInc = remapAxisValue(val);
+	}
+	else if(ie.m_Id == CAMERA_GAMEPAD_ROTATE_UP_DOWN)
+	{
+		gGamepadPitchInc = - remapAxisValue(val);
+	}
+	else if(ie.m_Id == CAMERA_GAMEPAD_MOVE_LEFT_RIGHT)
+	{
+		gGamepadLateralInc = - val;
+	}
+	else if(ie.m_Id == CAMERA_GAMEPAD_MOVE_FORWARD_BACK)
+	{
+		gGamepadForwardInc = val;
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// PT: TODO: refactor this
+static PxMat33 EulerToMat33(const PxVec3 &e)
+{
+	float c1 = cosf(e.z);
+	float s1 = sinf(e.z);
+	float c2 = cosf(e.y);
+	float s2 = sinf(e.y);
+	float c3 = cosf(e.x);
+	float s3 = sinf(e.x);
+	PxMat33 m(PxVec3(c1*c2,              -s1*c2,             s2),
+			  PxVec3((s1*c3)+(c1*s2*s3), (c1*c3)-(s1*s2*s3),-c2*s3),
+			  PxVec3((s1*s3)-(c1*s2*c3), (c1*s3)+(s1*s2*c3), c2*c3));
+
+	return m;
+}
+
+void DefaultCameraController::update(Camera& camera, PxReal dtime)
+{
+	// PT: copied from SampleApplication::onMouseMove
+	
+	const float eyeCap = 1.5f;
+
+	mTargetEyeRot.x += gGamepadPitchInc * dtime;
+	mTargetEyeRot.y += gGamepadYawInc * dtime;
+
+	if(mTargetEyeRot.x >  eyeCap) mTargetEyeRot.x =  eyeCap;
+	if(mTargetEyeRot.x < -eyeCap) mTargetEyeRot.x = -eyeCap;
+	mEyeRot += (mTargetEyeRot - mEyeRot) * g_smoothCamRotLerp;
+
+	const PxMat33 tmp = EulerToMat33(mEyeRot);
+	const PxVec3 forward = -tmp[2];
+	const PxVec3 right = -tmp[0];
+
+	const PxReal padEyeSpeed = mCameraSpeed == 0.f ? g_smoothCamBaseVel * mCameraSpeedMultiplier * dtime * g_smoothCamFastMul : mCameraSpeed;
+	mTargetEyePos += forward * padEyeSpeed * gGamepadForwardInc;
+	mTargetEyePos += right * padEyeSpeed * gGamepadLateralInc;
+
+	const PxReal keyEyeSpeed = mCameraSpeed == 0.f ? g_smoothCamBaseVel * mCameraSpeedMultiplier * dtime * (mKeyShiftDown ? g_smoothCamFastMul : 1.0f) : mCameraSpeed;
+	if(mKeyFWDown) mTargetEyePos -= tmp[2] * keyEyeSpeed;
+	if(mKeyBKDown) mTargetEyePos += tmp[2] * keyEyeSpeed;
+	if(mKeyLTDown) mTargetEyePos -= tmp[0] * keyEyeSpeed;
+	if(mKeyRTDown) mTargetEyePos += tmp[0] * keyEyeSpeed;
+	if(mKeyUpDown) mTargetEyePos += tmp[1] * keyEyeSpeed;
+	if(mKeyDownDown) mTargetEyePos -= tmp[1] * keyEyeSpeed;
+
+	mEyePos += (mTargetEyePos - mEyePos) * g_smoothCamPosLerp;
+
+	camera.setPos(mEyePos);
+	camera.setRot(mEyeRot);
+}
+
+///////////////////////////////////////////////////////////////////////////////