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 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 GImpactMeshShape(StridingMeshInterface meshInterface)
: base(btGImpactMeshShape_new(meshInterface._native))
{
_meshInterface = meshInterface;
}
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 RefitPartial(StridingMeshInterface triangles, Vector3 aabbMin, Vector3 aabbMax)
{
btOptimizedBvh_refitPartial(_native, triangles._native, ref aabbMin, ref aabbMax);
}
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 TrimeshPrimitiveManager(StridingMeshInterface meshInterface, int part)
: base(btGImpactMeshShapePart_TrimeshPrimitiveManager_new(meshInterface._native, part))
{
_meshInterface = meshInterface;
}
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 void Build(StridingMeshInterface triangles, bool useQuantizedAabbCompression,
Vector3 bvhAabbMin, Vector3 bvhAabbMax)
{
btOptimizedBvh_build(_native, triangles._native, useQuantizedAabbCompression,
ref bvhAabbMin, ref bvhAabbMax);
}
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 void UpdateBvhNodes(StridingMeshInterface meshInterface, int firstNode,
int endNode, int index)
{
btOptimizedBvh_updateBvhNodes(_native, meshInterface._native, firstNode,
endNode, index);
}
public BvhTriangleMeshShape(StridingMeshInterface meshInterface, bool useQuantizedAabbCompression)
: base(btBvhTriangleMeshShape_new(meshInterface._native, useQuantizedAabbCompression))
{
_meshInterface = meshInterface;
}
public ConvexTriangleMeshShape(StridingMeshInterface meshInterface, bool calcAabb)
: base(btConvexTriangleMeshShape_new2(meshInterface._native, calcAabb))
{
_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;
}
public GImpactMeshShapePart(StridingMeshInterface meshInterface, int part)
: base(btGImpactMeshShapePart_new2(meshInterface._native, part))
{
}
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 ConvexTriangleMeshShape(StridingMeshInterface meshInterface)
: base(btConvexTriangleMeshShape_new(meshInterface._native))
{
_meshInterface = meshInterface;
}
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);
}
public MultimaterialTriangleMeshShape(StridingMeshInterface meshInterface, bool useQuantizedAabbCompression)
: base(btMultimaterialTriangleMeshShape_new(meshInterface._native, useQuantizedAabbCompression))
{
}
