Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 221 insertions, 0 deletions

diff --git a/PhysX_3.4/Samples/SampleNorthPole/SampleNorthPoleCameraController.cpp b/PhysX_3.4/Samples/SampleNorthPole/SampleNorthPoleCameraController.cpp
new file mode 100644
index 00000000..0fe2e83a
--- /dev/null
+++ b/PhysX_3.4/Samples/SampleNorthPole/SampleNorthPoleCameraController.cpp
@@ -0,0 +1,221 @@
+// 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 "SampleNorthPole.h"
+#include "SampleNorthPoleCameraController.h"
+#include "PxRigidDynamic.h"
+#include "geometry/PxCapsuleGeometry.h"
+#include "PxShape.h"
+#include "characterkinematic/PxCapsuleController.h"
+#include <SampleBaseInputEventIds.h>
+#include <SamplePlatform.h>
+#include <SampleUserInput.h>
+#include <SampleUserInputIds.h>
+#include <SampleUserInputDefines.h>
+
+using namespace SampleRenderer;
+using namespace SampleFramework;
+
+SampleNorthPoleCameraController::SampleNorthPoleCameraController(PxCapsuleController& controlled, SampleNorthPole& base) :
+	mCCT						(controlled),
+	mBase						(base),
+	mTargetYaw					(0.0f-PxPi/2),
+	mTargetPitch				(0.0f),
+	mPitchMin					(-PxHalfPi*.99f),
+	mPitchMax					(PxHalfPi*.99f),
+	mGamepadPitchInc			(0.0f),
+	mGamepadYawInc				(0.0f),
+	mGamepadForwardInc			(0.0f),
+	mGamepadLateralInc			(0.0f),
+	mSensibility				(0.001f),
+	mFwd						(false),
+	mBwd						(false),
+	mLeft						(false),
+	mRight						(false),
+	mKeyShiftDown				(false),
+	mRunningSpeed				(10.0f),
+	mWalkingSpeed				(2.5f),
+	mFilterMemory				(0.0f)
+{
+	mFilterMemory = float(computeCameraTarget().y);
+}
+
+void SampleNorthPoleCameraController::collectInputEvents(std::vector<const SampleFramework::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_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);
+
+	//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 SampleNorthPoleCameraController::onDigitalInputEvent(const SampleFramework::InputEvent& ie, bool val)
+{
+	if(val)
+	{
+		if(ie.m_Id == CAMERA_MOVE_FORWARD)	mFwd = true;		
+		else	if(ie.m_Id == CAMERA_MOVE_BACKWARD)	mBwd = true;
+		else	if(ie.m_Id == CAMERA_MOVE_LEFT)	mLeft = true;
+		else	if(ie.m_Id == CAMERA_MOVE_RIGHT)	mRight = true;
+		else	if(ie.m_Id == CAMERA_SHIFT_SPEED)	mKeyShiftDown = true;
+	}
+	else
+	{
+		if(ie.m_Id == CAMERA_MOVE_FORWARD)	mFwd = false;
+		else	if(ie.m_Id == CAMERA_MOVE_BACKWARD)	mBwd = false;
+		else	if(ie.m_Id == CAMERA_MOVE_LEFT)	mLeft = false;
+		else	if(ie.m_Id == CAMERA_MOVE_RIGHT)	mRight = false;
+		else	if(ie.m_Id == CAMERA_SHIFT_SPEED)	mKeyShiftDown = false;
+	}
+}
+
+static PX_FORCE_INLINE PxReal remapAxisValue(PxReal absolutePosition)
+{
+	return absolutePosition * absolutePosition * absolutePosition * 5.0f;
+}
+
+void SampleNorthPoleCameraController::onAnalogInputEvent(const SampleFramework::InputEvent& ie, float val)
+{
+	if(ie.m_Id == CAMERA_GAMEPAD_ROTATE_LEFT_RIGHT)
+	{
+		mGamepadYawInc = -remapAxisValue(val);
+	}
+	else if(ie.m_Id == CAMERA_GAMEPAD_ROTATE_UP_DOWN)
+	{
+		// PT: ideally we'd need an option to "invert Y axis" here
+//		mGamepadPitchInc = - remapAxisValue(val);
+		mGamepadPitchInc = remapAxisValue(val);
+	}
+	else if(ie.m_Id == CAMERA_GAMEPAD_MOVE_LEFT_RIGHT)
+	{
+		mGamepadLateralInc = val;
+	}
+	else if(ie.m_Id == CAMERA_GAMEPAD_MOVE_FORWARD_BACK)
+	{
+		mGamepadForwardInc = val;
+	}
+}
+
+void SampleNorthPoleCameraController::onPointerInputEvent(const SampleFramework::InputEvent &ie, physx::PxU32 x, physx::PxU32 y, physx::PxReal dx, physx::PxReal dy, bool val)
+{
+	if (ie.m_Id == CAMERA_MOUSE_LOOK)
+	{
+		mTargetYaw		-= dx * mSensibility;
+		mTargetPitch	+= dy * mSensibility;
+	}
+}
+
+void SampleNorthPoleCameraController::setView(PxReal pitch, PxReal yaw)
+{
+	mTargetPitch = pitch;
+	mTargetYaw   = yaw;
+}
+
+PxExtendedVec3 SampleNorthPoleCameraController::computeCameraTarget()
+{
+	PxRigidActor* characterActor = mCCT.getActor();
+	PxShape* shape;
+	characterActor->getShapes(&shape,1);
+	PxCapsuleGeometry geom;
+	shape->getCapsuleGeometry(geom);
+
+	const PxExtendedVec3 headPos = PxExtendedVec3(0,geom.halfHeight+geom.radius,0);
+	return mCCT.getPosition() + headPos;
+}
+
+static PX_INLINE float feedbackFilter(float val, float& memory, float sharpness)
+{
+			if(sharpness<0.0f)	sharpness = 0.0f;
+	else	if(sharpness>1.0f)	sharpness = 1.0f;
+	return memory = val * sharpness + memory * (1.0f - sharpness);
+}
+
+void SampleNorthPoleCameraController::update(Camera& camera, PxReal dtime)
+{
+	PxSceneReadLock scopedLock(mBase.getActiveScene());
+
+	// Update CCT
+	if(!mBase.isPaused())
+	{
+		PxVec3 targetKeyDisplacement(0);
+		PxVec3 targetPadDisplacement(0);
+
+		PxVec3 forward = camera.getViewDir();
+		forward.y = 0;
+		forward.normalize();
+		PxVec3 up = PxVec3(0,1,0);
+		PxVec3 right = forward.cross(up);
+
+		if(mFwd)	targetKeyDisplacement += forward;
+		if(mBwd)	targetKeyDisplacement -= forward;
+
+		if(mRight)	targetKeyDisplacement += right;
+		if(mLeft)	targetKeyDisplacement -= right;
+
+		targetKeyDisplacement *= mKeyShiftDown ? mRunningSpeed : mWalkingSpeed;
+		targetKeyDisplacement += PxVec3(0,-9.81,0);
+		targetKeyDisplacement *= dtime;
+
+		targetPadDisplacement += forward * mGamepadForwardInc * mRunningSpeed;
+		targetPadDisplacement += right * mGamepadLateralInc * mRunningSpeed;
+		targetPadDisplacement += PxVec3(0,-9.81,0);
+		targetPadDisplacement *= dtime;
+
+//		PxU32 flags = mCCT.move(targetKeyDisplacement + targetPadDisplacement, 0.001f, dtime, PxControllerFilters(0));
+		PxU32 flags = mCCT.move(targetKeyDisplacement + targetPadDisplacement, 0.0f, dtime, PxControllerFilters(0));
+		PX_UNUSED(flags);
+	}
+	// Update camera
+	{
+		mTargetYaw		+= mGamepadYawInc * dtime;
+		mTargetPitch	+= mGamepadPitchInc * dtime;
+		
+		// Clamp pitch
+		if(mTargetPitch<mPitchMin)	mTargetPitch = mPitchMin;
+		if(mTargetPitch>mPitchMax)	mTargetPitch = mPitchMax;
+		
+		camera.setRot(PxVec3(-mTargetPitch,-mTargetYaw,0));
+
+		PxExtendedVec3 camTarget = computeCameraTarget();
+		const float filteredHeight = feedbackFilter((float)camTarget.y, mFilterMemory, dtime*6.0f);
+		camTarget.y = filteredHeight;
+
+		const PxF32 distanceToTarget = 0.0f;
+		const PxVec3 target = toVec3(camTarget) - camera.getViewDir()*distanceToTarget;
+		camera.setPos(target);
+	}
+}
+