text: //
  // Redistribution and use in source and binary forms, with or without
  // modification, are permitted provided that the following conditions
  // are met:
  //  * Redistributions of source code must retain the above copyright
  //    notice, this list of conditions and the following disclaimer.
  //  * Redistributions in binary form must reproduce the above copyright
  //    notice, this list of conditions and the following disclaimer in the
  //    documentation and/or other materials provided with the distribution.
  //  * Neither the name of NVIDIA CORPORATION nor the names of its
  //    contributors may be used to endorse or promote products derived
  //    from this software without specific prior written permission.
  //
  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
  // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  // PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  // OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  //
  // Copyright (c) 2008-2018 NVIDIA Corporation. All rights reserved.
  // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
  // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
  
  // ****************************************************************************
  // This snippet illustrates simple use of physx
  //
  // It creates a number of box stacks on a plane, and if rendering, allows the
  // user to create new stacks and fire a ball from the camera position
  // ****************************************************************************
  
  #include <ctype.h>
  
  #include "PxPhysicsAPI.h"
  
  #include "../snippetcommon/SnippetPrint.h"
  #include "../snippetcommon/SnippetPVD.h"
  #include "../snippetutils/SnippetUtils.h"
  
  
  using namespace physx;
  
  PxDefaultAllocator		gAllocator;
  PxDefaultErrorCallback	gErrorCallback;
  
  PxFoundation*			gFoundation = NULL;
  PxPhysics*				gPhysics	= NULL;
  
  PxDefaultCpuDispatcher*	gDispatcher = NULL;
  PxScene*				gScene		= NULL;
  
  PxMaterial*				gMaterial	= NULL;
  
  PxPvd*                  gPvd = NULL;
  
  PxCudaContextManager* gCudaContextManager = NULL;
  
  PxReal stackZ = 10.0f;
  
  PxRigidDynamic* createDynamic(const PxTransform& t, const PxGeometry& geometry, const PxVec3& velocity=PxVec3(0))
  {
  	PxRigidDynamic* dynamic = PxCreateDynamic(*gPhysics, t, geometry, *gMaterial, 10.0f);
  	dynamic->setAngularDamping(0.5f);
  	dynamic->setLinearVelocity(velocity);
  	gScene->addActor(*dynamic);
  	return dynamic;
  }
  
  void createStack(const PxTransform& t, PxU32 size, PxReal halfExtent)
  {
  	PxShape* shape = gPhysics->createShape(PxBoxGeometry(halfExtent, halfExtent, halfExtent), *gMaterial);
  	for(PxU32 i=0; i<size;i++)
  	{
  		for(PxU32 j=0;j<size-i;j++)
  		{
  			PxTransform localTm(PxVec3(PxReal(j*2) - PxReal(size-i), PxReal(i*2+1), 0) * halfExtent);
  			PxRigidDynamic* body = gPhysics->createRigidDynamic(t.transform(localTm));
  			body->attachShape(*shape);
  			PxRigidBodyExt::updateMassAndInertia(*body, 10.0f);
  			gScene->addActor(*body);
  		}
  	}
  	shape->release();
  }
  
  void initPhysics(bool /*interactive*/)
  {
  	gFoundation = PxCreateFoundation(PX_PHYSICS_VERSION, gAllocator, gErrorCallback);
  	gPvd = PxCreatePvd(*gFoundation);
  	PxPvdTransport* transport = PxDefaultPvdSocketTransportCreate(PVD_HOST, 5425, 10);
  	gPvd->connect(*transport, PxPvdInstrumentationFlag::ePROFILE);
  
  	gPhysics = PxCreatePhysics(PX_PHYSICS_VERSION, *gFoundation, PxTolerancesScale(), true, gPvd);
  	
  	PxCudaContextManagerDesc cudaContextManagerDesc;
  
  #ifdef RENDER_SNIPPET
  	cudaContextManagerDesc.interopMode = PxCudaInteropMode::OGL_INTEROP;	//Choose interop mode. As the snippets use OGL, we select OGL_INTEROP
  																			//when using D3D, cudaContextManagerDesc.graphicsDevice must be set as the graphics device pointer.
  #else
  	cudaContextManagerDesc.interopMode = PxCudaInteropMode::NO_INTEROP;
  #endif
  	
  
  	gCudaContextManager = PxCreateCudaContextManager(*gFoundation, cudaContextManagerDesc);	//Create the CUDA context manager, required for GRB to dispatch CUDA kernels.
  	if( gCudaContextManager )
  	{
  		if( !gCudaContextManager->contextIsValid() )
  		{
  			gCudaContextManager->release();
  			gCudaContextManager = NULL;
  		}
  	}	
  
  	PxSceneDesc sceneDesc(gPhysics->getTolerancesScale());
  	sceneDesc.gravity = PxVec3(0.0f, -9.81f, 0.0f);
  	gDispatcher = PxDefaultCpuDispatcherCreate(4);			//Create a CPU dispatcher using 4 worther threads
  	sceneDesc.cpuDispatcher	= gDispatcher;
  	sceneDesc.filterShader	= PxDefaultSimulationFilterShader;
  
  	if(gCudaContextManager)
  		sceneDesc.gpuDispatcher = gCudaContextManager->getGpuDispatcher();	//Set the GPU dispatcher, used by GRB to dispatch CUDA kernels.
  
  	sceneDesc.flags |= PxSceneFlag::eENABLE_GPU_DYNAMICS;	//Enable GPU dynamics - without this enabled, simulation (contact gen and solver) will run on the CPU.
  	sceneDesc.flags |= PxSceneFlag::eENABLE_PCM;			//Enable PCM. PCM NP is supported on GPU. Legacy contact gen will fall back to CPU
  	sceneDesc.flags |= PxSceneFlag::eENABLE_STABILIZATION;	//Improve solver stability by enabling post-stabilization.
  	sceneDesc.broadPhaseType = PxBroadPhaseType::eGPU;		//Enable GPU broad phase. Without this set, broad phase will run on the CPU.
  	sceneDesc.gpuMaxNumPartitions = 8;						//Defines the maximum number of partitions used by the solver. Only power-of-2 values are valid. 
  															//A value of 8 generally gives best balance between performance and stability.
  
  	gScene = gPhysics->createScene(sceneDesc);
  
  
  	PxPvdSceneClient* pvdClient = gScene->getScenePvdClient();
  	if (pvdClient)
  	{
  		pvdClient->setScenePvdFlag(PxPvdSceneFlag::eTRANSMIT_CONSTRAINTS, false);
  		pvdClient->setScenePvdFlag(PxPvdSceneFlag::eTRANSMIT_CONTACTS, false);
  		pvdClient->setScenePvdFlag(PxPvdSceneFlag::eTRANSMIT_SCENEQUERIES, false);
  	}
  
  
  
  	gMaterial = gPhysics->createMaterial(0.5f, 0.5f, 0.6f);
  
  	PxRigidStatic* groundPlane = PxCreatePlane(*gPhysics, PxPlane(0,1,0,0), *gMaterial);
  	gScene->addActor(*groundPlane);
  
  	for(PxU32 i=0;i<40;i++)
  		createStack(PxTransform(PxVec3(0,0,stackZ-=10.0f)), 20, 1.0f);
  
  	//if(!interactive)
  		PxRigidDynamic* ball = createDynamic(PxTransform(PxVec3(0,20,100)), PxSphereGeometry(5), PxVec3(0,-25,-100));
  		PxRigidBodyExt::updateMassAndInertia(*ball, 1000.f);
  }
  
  void stepPhysics(bool interactive)
  {
  	PX_UNUSED(interactive);
  	gScene->simulate(1.0f/60.0f);
  	gScene->fetchResults(true);
  }
  	
  void cleanupPhysics(bool interactive)
  {
  	PX_UNUSED(interactive);
  
  	if (gScene)
  	{
  		gScene->release();
  		gScene = NULL;
  	}
  	if (gDispatcher)
  	{
  		gDispatcher->release();
  		gDispatcher = NULL;
  	}
  	
  	if (gPhysics)
  	{
  		gPhysics->release();
  		gPhysics = NULL;
  
  	}
  	if (gPvd)
  	{
  		PxPvdTransport* transport = gPvd->getTransport();
  		gPvd->release();
  		transport->release();
  	}
  
  	if (gCudaContextManager)
  	{
  		gCudaContextManager->release();
  		gCudaContextManager = NULL;
  	}
  
  	if (gFoundation)
  	{
  		gFoundation->release();
  		gFoundation = NULL;
  	}
  	
  	printf("SnippetHelloWorld done.\n");
  }
  
  void keyPress(const char key, const PxTransform& camera)
  {
  	switch(toupper(key))
  	{
  	case 'B':	createStack(PxTransform(PxVec3(0,0,stackZ-=10.0f)), 10, 2.0f);						break;
  	case ' ':	createDynamic(camera, PxSphereGeometry(3.0f), camera.rotate(PxVec3(0,0,-1))*200);	break;
  	}
  }
  
  int snippetMain(int, const char*const*)
  {
  #ifdef RENDER_SNIPPET
  	extern void renderLoop();
  	renderLoop();
  #else
  	static const PxU32 frameCount = 100;
  	initPhysics(false);
  	for(PxU32 i=0; i<frameCount; i++)
  		stepPhysics(false);
  	cleanupPhysics(false);
  #endif
  
  	return 0;
  }
  