public static unsafe PhysicsShapeHandle CreateConcaveHullShape(IEnumerable <Vector3> vertices, IEnumerable <int> indices, CollisionShapeOptionsDesc shapeOptions, string acdFilePath) { return(LosgapSystem.InvokeOnMaster(() => { AlignedAllocation <CollisionShapeOptionsDesc> shapeOptionsAligned = new AlignedAllocation <CollisionShapeOptionsDesc>(16L, (uint)sizeof(CollisionShapeOptionsDesc)); *((CollisionShapeOptionsDesc *)shapeOptionsAligned.AlignedPointer) = shapeOptions; Vector3 *verticesLocal = stackalloc Vector3[vertices.Count()]; int *indicesLocal = stackalloc int[indices.Count()]; int numVertices = 0; int numIndices = 0; foreach (Vector3 vertex in vertices) { verticesLocal[numVertices++] = vertex; } foreach (int index in indices) { indicesLocal[numIndices++] = index; } PhysicsShapeHandle result; InteropUtils.CallNative( NativeMethods.PhysicsManager_CreateConcaveHullShape, (IntPtr)verticesLocal, numVertices, (IntPtr)indicesLocal, numIndices, shapeOptionsAligned.AlignedPointer, acdFilePath, (IntPtr)(&result) ).ThrowOnFailure(); shapeOptionsAligned.Dispose(); return result; })); }
internal unsafe static void AddTorqueImpulseToBody(PhysicsBodyHandle body, Vector3 torque) { LosgapSystem.InvokeOnMasterAsync(() => { AlignedAllocation <Vector4> vec4Aligned = new AlignedAllocation <Vector4>(16L, (uint)sizeof(Vector4)); *((Vector4 *)vec4Aligned.AlignedPointer) = torque; InteropUtils.CallNative(NativeMethods.PhysicsManager_AddTorqueImpulseToBody, body, vec4Aligned.AlignedPointer ).ThrowOnFailure(); vec4Aligned.Dispose(); }); }
public virtual void Dispose() { lock (InstanceMutationLock) { if (isDisposed) { return; } isDisposed = true; // ReSharper disable once ImpureMethodCallOnReadonlyValueField Resharper bug, Dispose is not impure viewMatrix.Dispose(); } }
private unsafe void ResizeList() { uint newListLen = CurListLen + LIST_SIZE_INCREMENT; GC.RemoveMemoryPressure(sizeof(RenderCommand) * CurListLen); AlignedAllocation <RenderCommand> newListSpace = AlignedAllocation <RenderCommand> .AllocArray(LIST_ALIGNMENT, newListLen); GC.AddMemoryPressure(sizeof(RenderCommand) * CurListLen); UnsafeUtils.MemCopy(RenderCommandList.AlignedPointer, newListSpace.AlignedPointer, (uint)sizeof(RenderCommand) * CurListLen); CurListLen = newListLen; RenderCommandList.Dispose(); RenderCommandList = newListSpace; }
public static unsafe void SetGravityOnAllBodies(Vector3 gravity) { LosgapSystem.InvokeOnMasterAsync(() => { AlignedAllocation <Vector4> vec4Aligned = new AlignedAllocation <Vector4>(16L, (uint)sizeof(Vector4)); *((Vector4 *)vec4Aligned.AlignedPointer) = gravity; try { InteropUtils.CallNative( NativeMethods.PhysicsManager_SetGravity, vec4Aligned.AlignedPointer ).ThrowOnFailure(); } finally { vec4Aligned.Dispose(); } }); }
public static unsafe PhysicsShapeHandle CreateSimpleSphereShape(float radius, CollisionShapeOptionsDesc shapeOptions) { return(LosgapSystem.InvokeOnMaster(() => { AlignedAllocation <CollisionShapeOptionsDesc> shapeOptionsAligned = new AlignedAllocation <CollisionShapeOptionsDesc>(16L, (uint)sizeof(CollisionShapeOptionsDesc)); *((CollisionShapeOptionsDesc *)shapeOptionsAligned.AlignedPointer) = shapeOptions; PhysicsShapeHandle result; InteropUtils.CallNative( NativeMethods.PhysicsManager_CreateSimpleSphereShape, radius, shapeOptionsAligned.AlignedPointer, (IntPtr)(&result) ).ThrowOnFailure(); shapeOptionsAligned.Dispose(); return result; })); }
internal unsafe static Vector3 GetBodyAngularVelocity(PhysicsBodyHandle body) { return(LosgapSystem.InvokeOnMaster(() => { AlignedAllocation <Vector4> vec4Aligned = new AlignedAllocation <Vector4>(16L, (uint)sizeof(Vector4)); InteropUtils.CallNative(NativeMethods.PhysicsManager_GetBodyAngularVelocity, body, vec4Aligned.AlignedPointer ).ThrowOnFailure(); try { return (Vector3)(*((Vector4 *)vec4Aligned.AlignedPointer)); } finally { vec4Aligned.Dispose(); } })); }
public unsafe void TestAllocArray() { // Define variables and constants const int NUM_ALLOCS = 2000; const long ALLOC_ALIGNMENT = 2L; // Set up context AlignedAllocation <Vector4> alignedArray = AlignedAllocation <Vector4> .AllocArray(ALLOC_ALIGNMENT, NUM_ALLOCS); // Execute *((Vector4 *)(alignedArray.AlignedPointer + NUM_ALLOCS - 1)) = new Vector4(1, 2, 3, 4); // Assert outcome Assert.AreEqual(new Vector4(1, 2, 3, 4), *((Vector4 *)(alignedArray.AlignedPointer + NUM_ALLOCS - 1))); Assert.AreEqual(0L, (long)alignedArray.AlignedPointer % ALLOC_ALIGNMENT); alignedArray.Dispose(); }
internal static unsafe IEnumerable <RayTestCollisionDesc> RayTestAll(Vector3 startPoint, Vector3 endPoint, uint maxCollisions) { RayTestCollisionDesc *collisionArr = stackalloc RayTestCollisionDesc[(int)maxCollisions]; uint maxCollisionsLocal = maxCollisions; RayTestCollisionDesc *collisionArrLocal = collisionArr; uint outNumCollisions; AlignedAllocation <Vector4> startPointAligned = new AlignedAllocation <Vector4>(16L, (uint)sizeof(Vector4)); *((Vector4 *)startPointAligned.AlignedPointer) = startPoint; AlignedAllocation <Vector4> endPointAligned = new AlignedAllocation <Vector4>(16L, (uint)sizeof(Vector4)); *((Vector4 *)endPointAligned.AlignedPointer) = endPoint; // WARNING: No longer thread-safe unsafe { char *failReason = stackalloc char[InteropUtils.MAX_INTEROP_FAIL_REASON_STRING_LENGTH + 1]; bool success = NativeMethods.PhysicsManager_RayTestAll( (IntPtr)failReason, startPointAligned.AlignedPointer, endPointAligned.AlignedPointer, (IntPtr)collisionArrLocal, maxCollisionsLocal, (IntPtr)(&outNumCollisions) ); if (!success) { throw new NativeOperationFailedException(Marshal.PtrToStringUni((IntPtr)failReason)); } } List <RayTestCollisionDesc> result = new List <RayTestCollisionDesc>((int)outNumCollisions); for (uint i = 0U; i < outNumCollisions; ++i) { result.Add(collisionArr[i]); } startPointAligned.Dispose(); endPointAligned.Dispose(); return(result); }
public static unsafe PhysicsShapeHandle CreateBoxShape(float width, float height, float depth, CollisionShapeOptionsDesc shapeOptions) { return(LosgapSystem.InvokeOnMaster(() => { AlignedAllocation <CollisionShapeOptionsDesc> shapeOptionsAligned = new AlignedAllocation <CollisionShapeOptionsDesc>(16L, (uint)sizeof(CollisionShapeOptionsDesc)); *((CollisionShapeOptionsDesc *)shapeOptionsAligned.AlignedPointer) = shapeOptions; AlignedAllocation <Vector4> boxExtents = new AlignedAllocation <Vector4>(16L, (uint)sizeof(Vector4)); *((Vector4 *)boxExtents.AlignedPointer) = new Vector4(width * 0.5f, height * 0.5f, depth * 0.5f, 0f); PhysicsShapeHandle result; InteropUtils.CallNative( NativeMethods.PhysicsManager_CreateBoxShape, boxExtents.AlignedPointer, shapeOptionsAligned.AlignedPointer, (IntPtr)(&result) ).ThrowOnFailure(); shapeOptionsAligned.Dispose(); boxExtents.Dispose(); return result; })); }
public static unsafe PhysicsShapeHandle CreateConeShape(float radius, float height, CollisionShapeOptionsDesc shapeOptions, out Vector3 translationOffset) { //translationOffset = Vector3.DOWN * (height * 0.5f); translationOffset = Vector3.ZERO; return(LosgapSystem.InvokeOnMaster(() => { AlignedAllocation <CollisionShapeOptionsDesc> shapeOptionsAligned = new AlignedAllocation <CollisionShapeOptionsDesc>(16L, (uint)sizeof(CollisionShapeOptionsDesc)); *((CollisionShapeOptionsDesc *)shapeOptionsAligned.AlignedPointer) = shapeOptions; PhysicsShapeHandle result; InteropUtils.CallNative( NativeMethods.PhysicsManager_CreateConeShape, radius, height, shapeOptionsAligned.AlignedPointer, (IntPtr)(&result) ).ThrowOnFailure(); shapeOptionsAligned.Dispose(); return result; })); }
public void Dispose() { lock (TargetWindow.WindowMutationLock) { if (isDisposed) { return; } projectionMatrix.Dispose(); try { InteropUtils.CallNative(NativeMethods.WindowFactory_DestroyViewport, ViewportHandle ).ThrowOnFailure(); } finally { isDisposed = true; } } }
internal unsafe static void SetBodyGravity(PhysicsBodyHandle body, Vector3 gravity) { AlignedAllocation <Vector4> gravityAligned = new AlignedAllocation <Vector4>(16L, (uint)sizeof(Vector4)); *((Vector4 *)gravityAligned.AlignedPointer) = gravity; // WARNING: No longer thread-safe try { unsafe { char *failReason = stackalloc char[InteropUtils.MAX_INTEROP_FAIL_REASON_STRING_LENGTH + 1]; bool success = NativeMethods.PhysicsManager_SetBodyGravity((IntPtr)failReason, body, gravityAligned.AlignedPointer); if (!success) { throw new NativeOperationFailedException(Marshal.PtrToStringUni((IntPtr)failReason)); } } } finally { gravityAligned.Dispose(); } }
internal unsafe static Vector3 GetBodyLinearVelocity(PhysicsBodyHandle body) { AlignedAllocation <Vector4> vec4Aligned = new AlignedAllocation <Vector4>(16L, (uint)sizeof(Vector4)); // WARNING: No longer thread-safe unsafe { char *failReason = stackalloc char[InteropUtils.MAX_INTEROP_FAIL_REASON_STRING_LENGTH + 1]; bool success = NativeMethods.PhysicsManager_GetBodyLinearVelocity((IntPtr)failReason, body, vec4Aligned.AlignedPointer); if (!success) { throw new NativeOperationFailedException(Marshal.PtrToStringUni((IntPtr)failReason)); } } try { return((Vector3)(*((Vector4 *)vec4Aligned.AlignedPointer))); } finally { vec4Aligned.Dispose(); } }
public virtual void Dispose() { lock (InstanceMutationLock) { if (isDisposed) { return; } isDisposed = true; DisposePhysicsBody(); EntityModule.RemoveActiveEntity(this); if (modelInstance != null) { modelInstance.Value.Dispose(); } modelInstance = null; transform.Dispose(); if (physicsShapeOffset != null) { physicsShapeOffset.Value.Dispose(); } } }
public static unsafe PhysicsShapeHandle CreateCompoundCurveShape(IEnumerable <Vector3> vertices, CollisionShapeOptionsDesc shapeOptions) { return(LosgapSystem.InvokeOnMaster(() => { AlignedAllocation <CollisionShapeOptionsDesc> shapeOptionsAligned = new AlignedAllocation <CollisionShapeOptionsDesc>(16L, (uint)sizeof(CollisionShapeOptionsDesc)); *((CollisionShapeOptionsDesc *)shapeOptionsAligned.AlignedPointer) = shapeOptions; Vector3 *verticesLocal = stackalloc Vector3[vertices.Count()]; int numVertices = 0; foreach (Vector3 vertex in vertices) { verticesLocal[numVertices++] = vertex; } PhysicsShapeHandle result; InteropUtils.CallNative( NativeMethods.PhysicsManager_CreateCompoundCurveShape, (IntPtr)verticesLocal, (uint)numVertices / 8U, shapeOptionsAligned.AlignedPointer, (IntPtr)(&result) ).ThrowOnFailure(); shapeOptionsAligned.Dispose(); return result; })); }
internal static unsafe PhysicsBodyHandle RayTestNearest(Vector3 startPoint, Vector3 endPoint, out Vector3 hitPoint) { AlignedAllocation <Vector4> hitPointAligned = new AlignedAllocation <Vector4>(16L, (uint)sizeof(Vector4)); Vector4 *hitPoint4Ptr = (Vector4 *)hitPointAligned.AlignedPointer; var result = LosgapSystem.InvokeOnMaster(() => { AlignedAllocation <Vector4> startPointAligned = new AlignedAllocation <Vector4>(16L, (uint)sizeof(Vector4)); *((Vector4 *)startPointAligned.AlignedPointer) = startPoint; AlignedAllocation <Vector4> endPointAligned = new AlignedAllocation <Vector4>(16L, (uint)sizeof(Vector4)); *((Vector4 *)endPointAligned.AlignedPointer) = endPoint; Vector4 *hitPoint4PtrLocal = hitPoint4Ptr; PhysicsBodyHandle outPBH; InteropUtils.CallNative(NativeMethods.PhysicsManager_RayTestNearest, startPointAligned.AlignedPointer, endPointAligned.AlignedPointer, (IntPtr)(&outPBH), (IntPtr)(hitPoint4PtrLocal) ).ThrowOnFailure(); startPointAligned.Dispose(); endPointAligned.Dispose(); return(outPBH); }); try { if (result != PhysicsBodyHandle.NULL) { hitPoint = (Vector3)(*((Vector4 *)hitPointAligned.AlignedPointer)); } else { hitPoint = Vector3.ZERO; } return(result); } finally { hitPointAligned.Dispose(); } }
/// <summary> /// Disposes this cache, making it no longer usable, and releasing all resources it created (including vertex/index buffers, /// instance buffers, transform buffers, etc). /// </summary> public void Dispose() { lock (staticMutationLock) { activeCaches.Remove(ID); activeCacheList.Remove(this); } lock (instanceMutationLock) { if (isDisposed) { return; } GC.RemoveMemoryPressure(sizeof(uint) * 2 * (NumModels + 1)); vertexComponentBuffers.ForEach(buffer => buffer.Dispose()); indices.Dispose(); // ReSharper disable ImpureMethodCallOnReadonlyValueField R# bug componentStartPointsAlloc.Dispose(); indexStartPointsAlloc.Dispose(); // ReSharper restore ImpureMethodCallOnReadonlyValueField instanceManager.Dispose(); isDisposed = true; assembledInputLayouts.ForEach(ail => ail.Value.Dispose()); assembledInputLayouts.Clear(); } }
public void TestAlignment() { // Define variables and constants const int NUM_ALLOCATIONS_PER_TEST_ALIGNMENT = 350; int[] testAlignments = { 1, 2, 3, 4, 6, 8, 12, 16, 32 }; // Set up context // Execute // Assert outcome for (int i = 0; i < testAlignments.Length; i++) { for (int j = 0; j < NUM_ALLOCATIONS_PER_TEST_ALIGNMENT; j++) { AlignedAllocation <Matrix> alignedAlloc = new AlignedAllocation <Matrix>(testAlignments[i]); Assert.IsTrue(((long)alignedAlloc.AlignedPointer) % testAlignments[i] == 0L); alignedAlloc.Dispose(); } } }