public virtual bool getBoxGeometry(PxBoxGeometry geometry) { bool ret = physxPINVOKE.PxShape_getBoxGeometry(swigCPtr, PxBoxGeometry.getCPtr(geometry)); if (physxPINVOKE.SWIGPendingException.Pending) { throw physxPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
protected override void OnInit() { var geometry = new PxBoxGeometry(0.5f, 0.5f, 0.5f); var material = pxPhysics.createMaterial(.5f, .5f, .5f); var wallSize = 4; for (int i = 0; i < wallSize; i++) { for (int j = 0; j < wallSize; j++) { var transform = new PxTransform(new PxVec3(i - wallSize / 2, j, 0)); PxRigidDynamicPtr dynamic = PxCreateDynamic(pxPhysics, transform, geometry, material, 10); dynamic.setAngularDamping(.5f); pxScene.addActor(dynamic); } } }
static void renderGeometry(ref PxGeometry geom) { switch (geom.getType()) { case PxGeometryType.eBOX: { ref PxBoxGeometry boxGeom = ref Unsafe.As <PxGeometry, PxBoxGeometry>(ref geom); float hx = boxGeom.halfExtents.x; float hy = boxGeom.halfExtents.y; float hz = boxGeom.halfExtents.z; // +x GL.Begin(PrimitiveType.Quads); GL.Normal3(1f, 0f, 0f); GL.Vertex3(+hx, +hy, +hz); GL.Vertex3(+hx, -hy, +hz); GL.Vertex3(+hx, -hy, -hz); GL.Vertex3(+hx, +hy, -hz); GL.End(); // -x GL.Begin(PrimitiveType.Quads); GL.Normal3(-1f, 0f, 0f); GL.Vertex3(-hx, +hy, +hz); GL.Vertex3(-hx, +hy, -hz); GL.Vertex3(-hx, -hy, -hz); GL.Vertex3(-hx, -hy, +hz); GL.End(); // +y GL.Begin(PrimitiveType.Quads); GL.Normal3(0f, 1f, 0f); GL.Vertex3(+hx, +hy, +hz); GL.Vertex3(-hx, +hy, +hz); GL.Vertex3(-hx, +hy, -hz); GL.Vertex3(+hx, +hy, -hz); GL.End(); // -y GL.Begin(PrimitiveType.Quads); GL.Normal3(0f, -1f, 0f); GL.Vertex3(+hx, -hy, +hz); GL.Vertex3(+hx, -hy, -hz); GL.Vertex3(-hx, -hy, -hz); GL.Vertex3(-hx, -hy, +hz); GL.End(); // +z GL.Begin(PrimitiveType.Quads); GL.Normal3(0f, 0f, 1f); GL.Vertex3(+hx, +hy, +hz); GL.Vertex3(-hx, +hy, +hz); GL.Vertex3(-hx, -hy, +hz); GL.Vertex3(+hx, -hy, +hz); GL.End(); // -z GL.Begin(PrimitiveType.Quads); GL.Normal3(0f, 0f, -1f); GL.Vertex3(+hx, +hy, -hz); GL.Vertex3(+hx, -hy, -hz); GL.Vertex3(-hx, -hy, -hz); GL.Vertex3(-hx, +hy, -hz); GL.End(); } break;
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PxBoxGeometry obj) { return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr); }
public static void Main(string[] args) { Console.WriteLine($"PhysX native runtime build information: '{MochiPhysX.BuildInfo}'..."); //--------------------------------------------------------------------------------------------------------------------------------------- Console.WriteLine("Initializing error callback"); // Switch between these to use PhysX's default error callback or one implemented from C# PxDefaultErrorCallback errorCallback = new(); //PxErrorCallback errorCallback = ErrorCallback.Create(); //--------------------------------------------------------------------------------------------------------------------------------------- Console.WriteLine("Initializing allocator callback"); // Switch between these to use PhysX's default allocator callback or one implemented from C# PxDefaultAllocator allocator = new(); //PxAllocatorCallback allocator = BasicAllocator.Create(); //PxAllocatorCallback allocator = LoggingAllocator.Create(); //--------------------------------------------------------------------------------------------------------------------------------------- Console.WriteLine("Initializing foundation"); //BIOQUIRK: PhysX owns both of these references, which means both the allocator and error callback must remain pinned for the lifetime of the foundation. // (In our case they're stack allocated and implicitly pinned.) // This seems somewhat unobvious since C# references don't normally care. Should we emit this function differently to convey the unsafe-ness here? PxFoundation *foundation = PxCreateFoundation(PX_PHYSICS_VERSION, ref allocator, ref errorCallback); if (foundation == null) { Console.Error.WriteLine("Failed to create foundation."); return; } //--------------------------------------------------------------------------------------------------------------------------------------- Console.WriteLine("Initializing Pvd..."); //BIOQUIRK: This pattern comes up a lot in PhysX. It does technically match how it is in C++ though, not sure if it's a problem. // I experimentally enabled having C++ reference returns translate as C# reference returns, but that creates a weird situation when you need to store them. PxPvd *pvd = PxCreatePvd(ref *foundation); PxPvdTransport *transport; byte[] host = Encoding.ASCII.GetBytes("127.0.0.1"); fixed(byte *hostP = host) { transport = PxDefaultPvdSocketTransportCreate(hostP, 5425, 10); } Console.WriteLine("Connecting to Pvd..."); pvd->connect(ref *transport, PxPvdInstrumentationFlags.eALL); //--------------------------------------------------------------------------------------------------------------------------------------- Console.WriteLine("Initializing physics"); PxPhysics *physics = PxCreatePhysics(PX_PHYSICS_VERSION, ref *foundation, new PxTolerancesScale(), trackOutstandingAllocations: true, pvd); if (physics == null) { Console.Error.WriteLine("Failed to create physics."); return; } //--------------------------------------------------------------------------------------------------------------------------------------- Console.WriteLine("Creating dispatcher"); PxDefaultCpuDispatcher *dispatcher = PxDefaultCpuDispatcherCreate(2, null); //--------------------------------------------------------------------------------------------------------------------------------------- Console.WriteLine("Creating scene"); PxSceneDesc sceneDescription = new(*physics->getTolerancesScale()); sceneDescription.gravity = new PxVec3() { x = 0f, y = -9.81f, z = 0f }; sceneDescription.cpuDispatcher = (PxCpuDispatcher *)dispatcher; sceneDescription.filterShader = PxDefaultSimulationFilterShader; PxScene *scene = physics->createScene(sceneDescription); //--------------------------------------------------------------------------------------------------------------------------------------- Console.WriteLine("Configuring scene Pvd client"); PxPvdSceneClient *pvdClient = scene->getScenePvdClient(); if (pvdClient != null) { pvdClient->setScenePvdFlag(PxPvdSceneFlags.eTRANSMIT_CONSTRAINTS, true); pvdClient->setScenePvdFlag(PxPvdSceneFlags.eTRANSMIT_CONTACTS, true); pvdClient->setScenePvdFlag(PxPvdSceneFlags.eTRANSMIT_SCENEQUERIES, true); } //--------------------------------------------------------------------------------------------------------------------------------------- Console.WriteLine("Creating a basic material"); PxMaterial *material = physics->createMaterial(0.5f, 0.5f, 0.6f); //--------------------------------------------------------------------------------------------------------------------------------------- Console.WriteLine("Adding a ground plane"); PxPlane planeDescription = new PxPlane() { n = new PxVec3() { x = 0f, y = 1f, z = 0f }, d = 0f }; PxRigidStatic *groundPlane = PxCreatePlane(ref *physics, planeDescription, ref *material); scene->addActor(ref *groundPlane, null); //--------------------------------------------------------------------------------------------------------------------------------------- Console.WriteLine("Adding stacks"); { const float halfExtent = 2f; PxBoxGeometry stackBoxGeometry = new PxBoxGeometry(halfExtent, halfExtent, halfExtent); PxShapeFlags shapeFlags = PxShapeFlags.eVISUALIZATION | PxShapeFlags.eSCENE_QUERY_SHAPE | PxShapeFlags.eSIMULATION_SHAPE; //BIOQUIRK: shapeFlags should be able to be defaulted now but it isn't. PxShape *shape = physics->createShape(stackBoxGeometry, *material, isExclusive: false, shapeFlags); float stackZ = 10f; for (int stackNum = 0; stackNum < 5; stackNum++) { const int size = 10; PxVec3 transformPosition = new PxVec3() { x = 0f, y = 0f, z = stackZ -= 10f }; PxTransform transform = new(transformPosition); for (int i = 0; i < size; i++) { for (int j = 0; j < size - i; j++) { PxVec3 position = new PxVec3() { x = ((float)(j * 2) - (float)(size - i)) * halfExtent, y = ((float)(i * 2 + 1)) * halfExtent, z = 0f }; PxTransform localTransform = new(position); PxTransform bodyTransform = transform.transform(localTransform); PxRigidDynamic *body = physics->createRigidDynamic(bodyTransform); body->attachShape(ref *shape); PxRigidBodyExt.updateMassAndInertia(ref *body, 10f); scene->addActor(ref *body); } } } shape->release(); } //--------------------------------------------------------------------------------------------------------------------------------------- Console.WriteLine("Throwing a ball at the stacks"); { PxVec3 position = new PxVec3() { x = 0f, y = 40f, z = 100f, }; PxTransform transform = new(position); PxSphereGeometry geometry = new(10f); PxVec3 velocity = new PxVec3() { x = 0f, y = -50f, z = -100f }; PxTransform identity = new(default(PxIDENTITY)); //BIOQUIRK: This could be a special generated property instead. Also missing default. PxRigidDynamic *dynamic = PxCreateDynamic(ref *physics, transform, geometry, ref *material, 10f, identity); dynamic->setAngularDamping(0.5f); dynamic->setLinearVelocity(velocity); scene->addActor(ref *dynamic); } //--------------------------------------------------------------------------------------------------------------------------------------- const int noInputFrameCount = 100; Console.WriteLine($"Simulating the world{(Console.IsInputRedirected ? $" for {noInputFrameCount} frames." : "... (Press escape to stop.)")}"); Stopwatch sw = new Stopwatch(); int frameNum = 0; const uint scratchMemoryBlockSize = 16 * 1024; const uint scratchMemoryBlockCount = 4; uint scratchMemorySize = scratchMemoryBlockSize * scratchMemoryBlockCount; void * scratchMemory = allocator.allocate(scratchMemorySize, null, null, 0); while (true) { double msSinceLastTick = sw.Elapsed.TotalMilliseconds; string consoleTitle = $"Simulating frame {frameNum} -- {msSinceLastTick:0.00} ms -- {1.0 / (msSinceLastTick / 1000.0):00.0} FPS"; if (BasicAllocator.AllocationCount > 0) // This is only applicable when a allocator implemented in C# is in use, assume 0 allocations implies the PhysX one is being used { consoleTitle += $" -- {BasicAllocator.AllocationCount} allocations"; BasicAllocator.AllocationCount = 0; } Console.Title = consoleTitle; frameNum++; sw.Restart(); scene->simulate(1f / 60f, scratchMemBlock: scratchMemory, scratchMemBlockSize: scratchMemorySize); uint errors; scene->fetchResults(true, &errors); if (errors != 0) { Console.WriteLine($"fetchResults error: {errors}"); } if (Console.IsInputRedirected) { if (frameNum > noInputFrameCount) { break; } } else if (Console.KeyAvailable && Console.ReadKey(true).Key == ConsoleKey.Escape) { break; } } //--------------------------------------------------------------------------------------------------------------------------------------- Console.WriteLine("Shutting down"); allocator.deallocate(scratchMemory); physics->release(); foundation->release(); }
public PxBoxGeometry box() { PxBoxGeometry ret = new PxBoxGeometry(physxPINVOKE.PxGeometryHolder_box__SWIG_0(swigCPtr), false); return(ret); }