public MultimaterialTriangleMeshShape(StridingMeshInterface meshInterface, bool useQuantizedAabbCompression, Vector3 bvhAabbMin, Vector3 bvhAabbMax) : base(btMultimaterialTriangleMeshShape_new3(meshInterface._native, useQuantizedAabbCompression, ref bvhAabbMin, ref bvhAabbMax)) { _meshInterface = meshInterface; }
public BvhTriangleMeshShape(StridingMeshInterface meshInterface, bool useQuantizedAabbCompression, bool buildBvh = true) : base(btBvhTriangleMeshShape_new(meshInterface._native, useQuantizedAabbCompression, buildBvh)) { _meshInterface = meshInterface; }
public MultimaterialTriangleMeshShape(StridingMeshInterface meshInterface, bool useQuantizedAabbCompression, bool buildBvh) : base(btMultimaterialTriangleMeshShape_new2(meshInterface._native, useQuantizedAabbCompression, buildBvh)) { _meshInterface = meshInterface; }
public BvhTriangleMeshShape(StridingMeshInterface meshInterface, bool useQuantizedAabbCompression, Vector3 bvhAabbMin, Vector3 bvhAabbMax) : base(btBvhTriangleMeshShape_new3(meshInterface._native, useQuantizedAabbCompression, ref bvhAabbMin, ref bvhAabbMax)) { _meshInterface = meshInterface; }
public BvhTriangleMeshShape(StridingMeshInterface meshInterface, bool useQuantizedAabbCompression, Vector3 bvhAabbMin, Vector3 bvhAabbMax, bool buildBvh) : base(btBvhTriangleMeshShape_new4(meshInterface._native, useQuantizedAabbCompression, ref bvhAabbMin, ref bvhAabbMax, buildBvh)) { _meshInterface = meshInterface; }
public BvhTriangleMeshShape(StridingMeshInterface meshInterface, bool useQuantizedAabbCompression, Vector3 bvhAabbMin, Vector3 bvhAabbMax, bool buildBvh = true) : base(btBvhTriangleMeshShape_new2(meshInterface.Native, useQuantizedAabbCompression, ref bvhAabbMin, ref bvhAabbMax, buildBvh)) { _meshInterface = meshInterface; }
public unsafe static void SetScaling(this StridingMeshInterface obj, ref OpenTK.Vector3 value) { fixed(OpenTK.Vector3 *valuePtr = &value) { obj.Scaling = *(BulletSharp.Math.Vector3 *)valuePtr; } }
public MultimaterialTriangleMeshShape(StridingMeshInterface meshInterface, bool useQuantizedAabbCompression, bool buildBvh = true) { IntPtr native = btMultimaterialTriangleMeshShape_new(meshInterface.Native, useQuantizedAabbCompression, buildBvh); InitializeCollisionShape(native); InitializeMembers(meshInterface); }
public ConvexTriangleMeshShape(StridingMeshInterface meshInterface, bool calcAabb = true) { IntPtr native = btConvexTriangleMeshShape_new(meshInterface.Native, calcAabb); InitializeCollisionShape(native); MeshInterface = meshInterface; }
public TrimeshPrimitiveManager(StridingMeshInterface meshInterface, int part) { IntPtr native = btGImpactMeshShapePart_TrimeshPrimitiveManager_new(meshInterface.Native, part); InitializeUserOwned(native); _meshInterface = meshInterface; }
public BvhTriangleMeshShape(StridingMeshInterface meshInterface, bool useQuantizedAabbCompression, Vector3 bvhAabbMin, Vector3 bvhAabbMax, bool buildBvh = true) { IntPtr native = btBvhTriangleMeshShape_new2(meshInterface.Native, useQuantizedAabbCompression, ref bvhAabbMin, ref bvhAabbMax, buildBvh); InitializeCollisionShape(native); InitializeMembers(meshInterface); }
public unsafe static void CalculateAabbBruteForce(this StridingMeshInterface obj, out OpenTK.Vector3 aabbMin, out OpenTK.Vector3 aabbMax) { fixed(OpenTK.Vector3 *aabbMinPtr = &aabbMin) { fixed(OpenTK.Vector3 *aabbMaxPtr = &aabbMax) { obj.CalculateAabbBruteForce(out *(BulletSharp.Math.Vector3 *)aabbMinPtr, out *(BulletSharp.Math.Vector3 *)aabbMaxPtr); } } }
/* * public unsafe static void InternalProcessAllTriangles(this StridingMeshInterface obj, InternalTriangleIndexCallback callback, ref OpenTK.Vector3 aabbMin, ref OpenTK.Vector3 aabbMax) * { * fixed (OpenTK.Vector3* aabbMinPtr = &aabbMin) * { * fixed (OpenTK.Vector3* aabbMaxPtr = &aabbMax) * { * obj.InternalProcessAllTriangles(callback, ref *(BulletSharp.Math.Vector3*)aabbMinPtr, ref *(BulletSharp.Math.Vector3*)aabbMaxPtr); * } * } * } */ public unsafe static void SetPremadeAabb(this StridingMeshInterface obj, ref OpenTK.Vector3 aabbMin, ref OpenTK.Vector3 aabbMax) { fixed(OpenTK.Vector3 *aabbMinPtr = &aabbMin) { fixed(OpenTK.Vector3 *aabbMaxPtr = &aabbMax) { obj.SetPremadeAabb(ref *(BulletSharp.Math.Vector3 *)aabbMinPtr, ref *(BulletSharp.Math.Vector3 *)aabbMaxPtr); } } }
public BvhTriangleMeshShape CreateBvhTriangleMeshShape(StridingMeshInterface trimesh, OptimizedBvh bvh) { BvhTriangleMeshShape shape; if (bvh != null) { shape = new BvhTriangleMeshShape(trimesh, bvh.IsQuantized, false); shape.OptimizedBvh = bvh; } else { shape = new BvhTriangleMeshShape(trimesh, true); } _allocatedCollisionShapes.Add(shape); return shape; }
public ConvexTriangleMeshShape(StridingMeshInterface meshInterface, bool calcAabb) : base(btConvexTriangleMeshShape_new2(meshInterface._native, calcAabb)) { _meshInterface = meshInterface; }
protected internal void InitializeMembers(StridingMeshInterface meshInterface) { MeshInterface = meshInterface; }
public GImpactMeshShape(StridingMeshInterface meshInterface) : base(btGImpactMeshShape_new(meshInterface._native)) { _meshInterface = meshInterface; }
public TrimeshPrimitiveManager(StridingMeshInterface meshInterface, int part) : base(btGImpactMeshShapePart_TrimeshPrimitiveManager_new(meshInterface._native, part)) { _meshInterface = meshInterface; }
public void RefitPartial(StridingMeshInterface triangles, Vector3 aabbMin, Vector3 aabbMax) { btOptimizedBvh_refitPartial(_native, triangles._native, ref aabbMin, ref aabbMax); }
public ConvexTriangleMeshShape(StridingMeshInterface meshInterface) : base(btConvexTriangleMeshShape_new(meshInterface._native)) { _meshInterface = meshInterface; }
public MultimaterialTriangleMeshShape(StridingMeshInterface meshInterface, bool useQuantizedAabbCompression, Vector3 bvhAabbMin, Vector3 bvhAabbMax, bool buildBvh) : base(btMultimaterialTriangleMeshShape_new4(meshInterface._native, useQuantizedAabbCompression, ref bvhAabbMin, ref bvhAabbMax, buildBvh)) { }
public void UpdateBvhNodes(StridingMeshInterface meshInterface, int firstNode, int endNode, int index) { btOptimizedBvh_updateBvhNodes(_native, meshInterface._native, firstNode, endNode, index); }
public GImpactMeshShape CreateGimpactShape(StridingMeshInterface trimesh) { GImpactMeshShape shape = new GImpactMeshShape(trimesh._native); _allocatedCollisionShapes.Add(shape); return shape; }
public void Build(StridingMeshInterface triangles, bool useQuantizedAabbCompression, Vector3 bvhAabbMin, Vector3 bvhAabbMax) { btOptimizedBvh_build(_native, triangles._native, useQuantizedAabbCompression, ref bvhAabbMin, ref bvhAabbMax); }
static Vector3[] CreateTriangleMesh(StridingMeshInterface meshInterface) { var indexStream = meshInterface.GetIndexStream(); var vertexStream = meshInterface.GetVertexStream(); var indexReader = new BinaryReader(indexStream); var vertexReader = new BinaryReader(vertexStream); int numVertices = (int)indexStream.Length / 4; const int vertexStride = 12; Vector3[] vertices = new Vector3[numVertices * 2]; int v = 0; while (indexStream.Position < indexStream.Length) { uint i = indexReader.ReadUInt32(); vertexStream.Position = vertexStride * i; Vector3 v0 = new Vector3(vertexReader.ReadSingle(), vertexReader.ReadSingle(), vertexReader.ReadSingle()); i = indexReader.ReadUInt32(); vertexStream.Position = vertexStride * i; Vector3 v1 = new Vector3(vertexReader.ReadSingle(), vertexReader.ReadSingle(), vertexReader.ReadSingle()); i = indexReader.ReadUInt32(); vertexStream.Position = vertexStride * i; Vector3 v2 = new Vector3(vertexReader.ReadSingle(), vertexReader.ReadSingle(), vertexReader.ReadSingle()); Vector3 v01 = v0 - v1; Vector3 v02 = v0 - v2; Vector3 normal = Vector3.Cross(v01, v02); normal.Normalize(); vertices[v++] = v0; vertices[v++] = normal; vertices[v++] = v1; vertices[v++] = normal; vertices[v++] = v2; vertices[v++] = normal; } indexStream.Dispose(); vertexStream.Dispose(); return vertices; }
public MultimaterialTriangleMeshShape(StridingMeshInterface meshInterface, bool useQuantizedAabbCompression) : base(btMultimaterialTriangleMeshShape_new(meshInterface._native, useQuantizedAabbCompression)) { }
public GImpactMeshShapePart(StridingMeshInterface meshInterface, int part) : base(btGImpactMeshShapePart_new2(meshInterface._native, part)) { }
static UnityEngine.Vector3[] CreateTriangleMesh(StridingMeshInterface meshInterface) { // StridingMeshInterface can only be TriangleIndexVertexArray var meshes = (meshInterface as TriangleIndexVertexArray).IndexedMeshArray; int numTriangles = 0; foreach (var mesh in meshes) { numTriangles += mesh.NumTriangles; } int numVertices = numTriangles * 3; UnityEngine.Vector3[] vertices = new UnityEngine.Vector3[numVertices * 2]; int v = 0; for (int part = 0; part < meshInterface.NumSubParts; part++) { var mesh = meshes[part]; var indexStream = mesh.GetTriangleStream(); var vertexStream = mesh.GetVertexStream(); var indexReader = new BinaryReader(indexStream); var vertexReader = new BinaryReader(vertexStream); int vertexStride = mesh.VertexStride; int triangleStrideDelta = mesh.TriangleIndexStride - 3 * sizeof(int); while (indexStream.Position < indexStream.Length) { uint i = indexReader.ReadUInt32(); vertexStream.Position = vertexStride * i; float f1 = vertexReader.ReadSingle(); float f2 = vertexReader.ReadSingle(); float f3 = vertexReader.ReadSingle(); UnityEngine.Vector3 v0 = new UnityEngine.Vector3(f1, f2, f3); i = indexReader.ReadUInt32(); vertexStream.Position = vertexStride * i; f1 = vertexReader.ReadSingle(); f2 = vertexReader.ReadSingle(); f3 = vertexReader.ReadSingle(); UnityEngine.Vector3 v1 = new UnityEngine.Vector3(f1, f2, f3); i = indexReader.ReadUInt32(); vertexStream.Position = vertexStride * i; f1 = vertexReader.ReadSingle(); f2 = vertexReader.ReadSingle(); f3 = vertexReader.ReadSingle(); UnityEngine.Vector3 v2 = new UnityEngine.Vector3(f1, f2, f3); UnityEngine.Vector3 v01 = v0 - v1; UnityEngine.Vector3 v02 = v0 - v2; UnityEngine.Vector3 normal = UnityEngine.Vector3.Cross(v01, v02); normal.Normalize(); vertices[v++] = v0; vertices[v++] = normal; vertices[v++] = v1; vertices[v++] = normal; vertices[v++] = v2; vertices[v++] = normal; indexStream.Position += triangleStrideDelta; } indexStream.Dispose(); vertexStream.Dispose(); } return vertices; }
public static void CreateTriangleMeshShape(StridingMeshInterface meshInterface, Mesh m) { // StridingMeshInterface can only be TriangleIndexVertexArray var meshes = (meshInterface as TriangleIndexVertexArray).IndexedMeshArray; int numTriangles = 0; foreach (var mesh in meshes) { numTriangles += mesh.NumTriangles; } int numVertices = numTriangles * 3; UnityEngine.Vector3[] vertices = new UnityEngine.Vector3[numVertices * 2]; int v = 0; List<int> triangles = new List<int>(); for (int part = 0; part < meshInterface.NumSubParts; part++) { var mesh = meshes[part]; var indexStream = mesh.GetTriangleStream(); var vertexStream = mesh.GetVertexStream(); var indexReader = new BinaryReader(indexStream); var vertexReader = new BinaryReader(vertexStream); int vertexStride = mesh.VertexStride; int triangleStrideDelta = mesh.TriangleIndexStride - 3 * sizeof(int); while (indexStream.Position < indexStream.Length) { uint i = indexReader.ReadUInt32(); vertexStream.Position = vertexStride * i; float f1 = vertexReader.ReadSingle(); float f2 = vertexReader.ReadSingle(); float f3 = vertexReader.ReadSingle(); UnityEngine.Vector3 v0 = new UnityEngine.Vector3(f1, f2, f3); i = indexReader.ReadUInt32(); vertexStream.Position = vertexStride * i; f1 = vertexReader.ReadSingle(); f2 = vertexReader.ReadSingle(); f3 = vertexReader.ReadSingle(); UnityEngine.Vector3 v1 = new UnityEngine.Vector3(f1, f2, f3); i = indexReader.ReadUInt32(); vertexStream.Position = vertexStride * i; f1 = vertexReader.ReadSingle(); f2 = vertexReader.ReadSingle(); f3 = vertexReader.ReadSingle(); UnityEngine.Vector3 v2 = new UnityEngine.Vector3(f1, f2, f3); UnityEngine.Vector3 v01 = v0 - v1; UnityEngine.Vector3 v02 = v0 - v2; UnityEngine.Vector3 normal = UnityEngine.Vector3.Cross(v01, v02); normal.Normalize(); triangles.Add(v); triangles.Add(v + 1); triangles.Add(v + 2); vertices[v++] = v0; vertices[v++] = v1; vertices[v++] = v2; indexStream.Position += triangleStrideDelta; } indexStream.Dispose(); vertexStream.Dispose(); } m.Clear(); m.vertices = vertices; m.triangles = triangles.ToArray(); m.RecalculateBounds(); m.RecalculateNormals(); }
public BvhTriangleMeshShape(StridingMeshInterface meshInterface, bool useQuantizedAabbCompression) : base(btBvhTriangleMeshShape_new(meshInterface._native, useQuantizedAabbCompression)) { _meshInterface = meshInterface; }
/* Mesh CreateStaticPlaneShape(StaticPlaneShape shape) { // Load shader if (planeShader == null) { Assembly assembly = Assembly.GetExecutingAssembly(); Stream shaderStream = assembly.GetManifestResourceStream("DemoFramework.checker_shader.fx"); planeShader = Effect.FromStream(device, shaderStream, ShaderFlags.None); } Vector3[] vertices = new Vector3[4 * 2]; Mesh mesh = new Mesh(device, 2, 4, MeshFlags.SystemMemory, VertexFormat.Position | VertexFormat.Normal); Vector3 planeOrigin = shape.PlaneNormal * shape.PlaneConstant; Vector3 vec0, vec1; PlaneSpace1(shape.PlaneNormal, out vec0, out vec1); float size = 1000; Vector3[] verts = new Vector3[4] { planeOrigin + vec0*size, planeOrigin - vec0*size, planeOrigin + vec1*size, planeOrigin - vec1*size }; SlimDX.DataStream vertexBuffer = mesh.LockVertexBuffer(LockFlags.Discard); vertexBuffer.Write(verts[0]); vertexBuffer.Position += 12; vertexBuffer.Write(verts[1]); vertexBuffer.Position += 12; vertexBuffer.Write(verts[2]); vertexBuffer.Position += 12; vertexBuffer.Write(verts[3]); vertexBuffer.Position += 12; mesh.UnlockVertexBuffer(); SlimDX.DataStream indexBuffer = mesh.LockIndexBuffer(LockFlags.Discard); indexBuffer.Write((short)1); indexBuffer.Write((short)2); indexBuffer.Write((short)0); indexBuffer.Write((short)1); indexBuffer.Write((short)3); indexBuffer.Write((short)0); mesh.UnlockIndexBuffer(); mesh.ComputeNormals(); complexShapes.Add(shape, mesh); return mesh; } */ ShapeData CreateTriangleMeshShape(StridingMeshInterface meshInterface) { BulletSharp.DataStream vertexStream, indexStream; int numVerts, numFaces; PhyScalarType vertsType, indicesType; int vertexStride, indexStride; meshInterface.GetLockedReadOnlyVertexIndexData(out vertexStream, out numVerts, out vertsType, out vertexStride, out indexStream, out indexStride, out numFaces, out indicesType); ShapeData shapeData = new ShapeData(); shapeData.VertexCount = numVerts; shapeData.IndexCount = numFaces * 3; Vector3[] vertices = new Vector3[shapeData.VertexCount * 2]; int v = 0; int vStrideExtra = vertexStride - Marshal.SizeOf(typeof(Vector3)); while (vertexStream.Position < vertexStream.Length) { Vector3 v0 = vertexStream.Read<Vector3>(); vertexStream.Position += vStrideExtra; Vector3 v1 = vertexStream.Read<Vector3>(); vertexStream.Position += vStrideExtra; Vector3 v2 = vertexStream.Read<Vector3>(); vertexStream.Position += vStrideExtra; Vector3 v01 = v0 - v1; Vector3 v02 = v0 - v2; Vector3 normal = Vector3.Cross(v01, v02); vertices[v++] = v0; vertices[v++] = normal; vertices[v++] = v1; vertices[v++] = normal; vertices[v++] = v2; vertices[v++] = normal; } int i = 0; if (numVerts > 65536) { uint[] indices = new uint[shapeData.IndexCount]; while (indexStream.Position < indexStream.Length) indices[i++] = indexStream.Read<uint>(); shapeData.SetIndexBuffer(device, indices); } else { ushort[] indices = new ushort[shapeData.IndexCount]; while (indexStream.Position < indexStream.Length) indices[i++] = (ushort)indexStream.Read<int>(); shapeData.SetIndexBuffer(device, indices); } shapeData.SetVertexBuffer(device, vertices); return shapeData; }
static Vector3[] CreateTriangleMesh(StridingMeshInterface meshInterface) { BulletSharp.DataStream vertexBuffer, indexBuffer; int numVerts, numFaces; PhyScalarType vertsType, indicesType; int vertexStride, indexStride; meshInterface.GetLockedReadOnlyVertexIndexData(out vertexBuffer, out numVerts, out vertsType, out vertexStride, out indexBuffer, out indexStride, out numFaces, out indicesType); Vector3[] vertices = new Vector3[numFaces * 3 * 2]; // Need to un-index the vertex buffer to make the normals right. int v = 0; while (indexBuffer.Position < indexBuffer.Length) { uint i = indexBuffer.Read<uint>(); vertexBuffer.Position = vertexStride * i; Vector3 v0 = vertexBuffer.Read<Vector3>(); i = indexBuffer.Read<uint>(); vertexBuffer.Position = vertexStride * i; Vector3 v1 = vertexBuffer.Read<Vector3>(); i = indexBuffer.Read<uint>(); vertexBuffer.Position = vertexStride * i; Vector3 v2 = vertexBuffer.Read<Vector3>(); Vector3 v01 = v0 - v1; Vector3 v02 = v0 - v2; Vector3 normal = Vector3.Cross(v01, v02); normal.Normalize(); vertices[v++] = v0; vertices[v++] = normal; vertices[v++] = v1; vertices[v++] = normal; vertices[v++] = v2; vertices[v++] = normal; } return vertices; }
public static void SetScaling(this StridingMeshInterface obj, OpenTK.Vector3 value) { SetScaling(obj, ref value); }
public static OpenTK.Vector3 GetScaling(this StridingMeshInterface obj) { OpenTK.Vector3 value; GetScaling(obj, out value); return(value); }