protected override void Dispose(bool disposing) { if (disposing) { if (_initialMesh != null) { _initialMesh.Dispose(); _initialMesh = null; } } base.Dispose(disposing); }
public TriangleIndexVertexArray(ICollection <int> triangles, ICollection <float> vertices) : base(btTriangleIndexVertexArray_new()) { _initialMesh = new IndexedMesh(); _initialMesh.Allocate(triangles.Count / 3, vertices.Count / 3); int[] triangleArray = new int[triangles.Count]; triangles.CopyTo(triangleArray, 0); Marshal.Copy(triangleArray, 0, _initialMesh.TriangleIndexBase, triangles.Count); float[] vertexArray = new float[vertices.Count]; vertices.CopyTo(vertexArray, 0); Marshal.Copy(vertexArray, 0, _initialMesh.VertexBase, vertices.Count); AddIndexedMesh(_initialMesh); }
public TriangleIndexVertexArray(ICollection <int> triangles, ICollection <Vector3> vertices) : base(btTriangleIndexVertexArray_new()) { _initialMesh = new IndexedMesh(); _initialMesh.Allocate(triangles.Count / 3, vertices.Count); int[] triangleArray = new int[triangles.Count]; triangles.CopyTo(triangleArray, 0); Marshal.Copy(triangleArray, 0, _initialMesh.TriangleIndexBase, triangles.Count); float[] vertexArray = new float[vertices.Count]; int i = 0; foreach (Vector3 v in vertices) { vertexArray[i] = v.X; vertexArray[i + 1] = v.Y; vertexArray[i + 2] = v.Z; i += 3; } Marshal.Copy(vertexArray, 0, _initialMesh.VertexBase, vertices.Count); AddIndexedMesh(_initialMesh); }
public void AddIndexedMesh(IndexedMesh mesh) { _meshes.Add(mesh); btTriangleIndexVertexArray_addIndexedMesh(_native, mesh._native); }
public TriangleIndexVertexArray(ICollection<int> triangles, ICollection<Vector3> vertices) : base(btTriangleIndexVertexArray_new()) { _initialMesh = new IndexedMesh(); _initialMesh.Allocate(triangles.Count / 3, vertices.Count); int[] triangleArray = triangles as int[]; if (triangleArray == null) { triangleArray = new int[triangles.Count]; triangles.CopyTo(triangleArray, 0); } Marshal.Copy(triangleArray, 0, _initialMesh.TriangleIndexBase, triangles.Count); float[] vertexArray = new float[vertices.Count * 3]; int i = 0; foreach (Vector3 v in vertices) { vertexArray[i] = v.X; vertexArray[i + 1] = v.Y; vertexArray[i + 2] = v.Z; i += 3; } Marshal.Copy(vertexArray, 0, _initialMesh.VertexBase, vertices.Count); AddIndexedMesh(_initialMesh); }
public TriangleIndexVertexArray(ICollection<int> triangles, ICollection<float> vertices) : base(btTriangleIndexVertexArray_new()) { _initialMesh = new IndexedMesh(); _initialMesh.Allocate(triangles.Count / 3, vertices.Count / 3); int[] triangleArray = triangles as int[]; if (triangleArray == null) { triangleArray = new int[triangles.Count]; triangles.CopyTo(triangleArray, 0); } Marshal.Copy(triangleArray, 0, _initialMesh.TriangleIndexBase, triangles.Count); float[] vertexArray = vertices as float[]; if (vertexArray == null) { vertexArray = new float[vertices.Count]; vertices.CopyTo(vertexArray, 0); } Marshal.Copy(vertexArray, 0, _initialMesh.VertexBase, vertices.Count); AddIndexedMesh(_initialMesh); }
protected override void OnInitialize() { Freelook.SetEyeTarget(eye, target); Graphics.SetFormText("BulletSharp - Concave Convexcast Demo"); Graphics.SetInfoText("Move using mouse and WASD+shift\n" + "F3 - Toggle debug\n" + //"F11 - Toggle fullscreen\n" + "Space - Shoot box"); DebugDrawMode = debugMode; const int totalVerts = NumVertsX * NumVertsY; const int totalTriangles = 2 * (NumVertsX - 1) * (NumVertsY - 1); indexVertexArrays = new TriangleIndexVertexArray(); IndexedMesh mesh = new IndexedMesh(); mesh.NumTriangles = totalTriangles; mesh.NumVertices = totalVerts; mesh.TriangleIndexStride = 3 * sizeof(int); mesh.VertexStride = Vector3.SizeInBytes; mesh.TriangleIndexBase = Marshal.AllocHGlobal(mesh.TriangleIndexStride * totalTriangles); mesh.VertexBase = Marshal.AllocHGlobal(mesh.VertexStride * totalVerts); var indicesStream = mesh.GetTriangleStream(); var indices = new BinaryWriter(indicesStream); for (int i = 0; i < NumVertsX - 1; i++) { for (int j = 0; j < NumVertsY - 1; j++) { indices.Write(j * NumVertsX + i); indices.Write(j * NumVertsX + i + 1); indices.Write((j + 1) * NumVertsX + i + 1); indices.Write(j * NumVertsX + i); indices.Write((j + 1) * NumVertsX + i + 1); indices.Write((j + 1) * NumVertsX + i); } } indices.Dispose(); indexVertexArrays.AddIndexedMesh(mesh); convexcastBatch = new ConvexcastBatch(40.0f, 0.0f, -10.0f, 80.0f); //convexcastBatch = new ConvexcastBatch(true, 40.0f, -50.0f, 50.0f); }
public void AddIndexedMesh(IndexedMesh mesh, PhyScalarType indexType = PhyScalarType.Int32) { _meshes.Add(mesh); btTriangleIndexVertexArray_addIndexedMesh(_native, mesh._native, indexType); }
protected override void OnInitializePhysics() { // collision configuration contains default setup for memory, collision setup CollisionConf = new DefaultCollisionConfiguration(); Dispatcher = new CollisionDispatcher(CollisionConf); Vector3 worldMin = new Vector3(-1000, -1000, -1000); Vector3 worldMax = new Vector3(1000, 1000, 1000); Broadphase = new AxisSweep3(worldMin, worldMax); Solver = new SequentialImpulseConstraintSolver(); World = new DiscreteDynamicsWorld(Dispatcher, Broadphase, Solver, CollisionConf); World.SolverInfo.SplitImpulse = 1; World.Gravity = new Vector3(0, -10, 0); const int totalVerts = NumVertsX * NumVertsY; const int totalTriangles = 2 * (NumVertsX - 1) * (NumVertsY - 1); indexVertexArrays = new TriangleIndexVertexArray(); IndexedMesh mesh = new IndexedMesh(); mesh.NumTriangles = totalTriangles; mesh.NumVertices = totalVerts; mesh.TriangleIndexStride = 3 * sizeof(int); mesh.VertexStride = Vector3.SizeInBytes; mesh.TriangleIndexBase = Marshal.AllocHGlobal(mesh.TriangleIndexStride * totalTriangles); mesh.VertexBase = Marshal.AllocHGlobal(mesh.VertexStride * totalVerts); var indicesStream = mesh.GetTriangleStream(); using (var indices = new BinaryWriter(indicesStream)) { for (int i = 0; i < NumVertsX - 1; i++) { for (int j = 0; j < NumVertsY - 1; j++) { indices.Write(j*NumVertsX + i); indices.Write(j*NumVertsX + i + 1); indices.Write((j + 1)*NumVertsX + i + 1); indices.Write(j*NumVertsX + i); indices.Write((j + 1)*NumVertsX + i + 1); indices.Write((j + 1)*NumVertsX + i); } } } indexVertexArrays.AddIndexedMesh(mesh); convexcastBatch = new ConvexcastBatch(40.0f, 0.0f, -10.0f, 80.0f); CollisionShape colShape = new BoxShape(1); CollisionShapes.Add(colShape); for (int j = 0; j < NumDynamicBoxesX; j++) { for (int i = 0; i < NumDynamicBoxesY; i++) { //CollisionShape colShape = new CapsuleShape(0.5f,2.0f);//boxShape = new SphereShape(1.0f); Matrix startTransform = Matrix.Translation(5 * (i - NumDynamicBoxesX / 2), 10, 5 * (j - NumDynamicBoxesY / 2)); LocalCreateRigidBody(1.0f, startTransform, colShape); } } SetVertexPositions(WaveHeight, 0.0f); const bool useQuantizedAabbCompression = true; groundShape = new BvhTriangleMeshShape(indexVertexArrays, useQuantizedAabbCompression); CollisionShapes.Add(groundShape); staticBody = LocalCreateRigidBody(0.0f, Matrix.Identity, groundShape); staticBody.CollisionFlags |= CollisionFlags.StaticObject; staticBody.UserObject = "Ground"; }
protected override void OnInitializePhysics() { CollisionShape groundShape = new BoxShape(50, 3, 50); CollisionShapes.Add(groundShape); CollisionConf = new DefaultCollisionConfiguration(); Dispatcher = new CollisionDispatcher(CollisionConf); Solver = new SequentialImpulseConstraintSolver(); Vector3 worldMin = new Vector3(-10000, -10000, -10000); Vector3 worldMax = new Vector3(10000, 10000, 10000); Broadphase = new AxisSweep3(worldMin, worldMax); //Broadphase = new DbvtBroadphase(); World = new DiscreteDynamicsWorld(Dispatcher, Broadphase, Solver, CollisionConf); int i; Matrix tr; Matrix vehicleTr; //if (UseTrimeshGround) { const float scale = 20.0f; //create a triangle-mesh ground const int NumVertsX = 20; const int NumVertsY = 20; const int totalVerts = NumVertsX * NumVertsY; const int totalTriangles = 2 * (NumVertsX - 1) * (NumVertsY - 1); TriangleIndexVertexArray vertexArray = new TriangleIndexVertexArray(); IndexedMesh mesh = new IndexedMesh(); mesh.Allocate(totalTriangles, totalVerts); mesh.NumTriangles = totalTriangles; mesh.NumVertices = totalVerts; mesh.TriangleIndexStride = 3 * sizeof(int); mesh.VertexStride = Vector3.SizeInBytes; using (var indicesStream = mesh.GetTriangleStream()) { var indices = new BinaryWriter(indicesStream); for (i = 0; i < NumVertsX - 1; i++) { for (int j = 0; j < NumVertsY - 1; j++) { indices.Write(j * NumVertsX + i); indices.Write(j * NumVertsX + i + 1); indices.Write((j + 1) * NumVertsX + i + 1); indices.Write(j * NumVertsX + i); indices.Write((j + 1) * NumVertsX + i + 1); indices.Write((j + 1) * NumVertsX + i); } } indices.Dispose(); } using (var vertexStream = mesh.GetVertexStream()) { var vertices = new BinaryWriter(vertexStream); for (i = 0; i < NumVertsX; i++) { for (int j = 0; j < NumVertsY; j++) { float wl = .2f; float height = 20.0f * (float)(Math.Sin(i * wl) * Math.Cos(j * wl)); vertices.Write((i - NumVertsX * 0.5f) * scale); vertices.Write(height); vertices.Write((j - NumVertsY * 0.5f) * scale); } } vertices.Dispose(); } vertexArray.AddIndexedMesh(mesh); groundShape = new BvhTriangleMeshShape(vertexArray, true); tr = Matrix.Identity; vehicleTr = Matrix.Translation(0, -2, 0); }/* else { // Use HeightfieldTerrainShape int width = 40, length = 40; //int width = 128, length = 128; // Debugging is too slow for this float maxHeight = 10.0f; float heightScale = maxHeight / 256.0f; Vector3 scale = new Vector3(20.0f, maxHeight, 20.0f); //PhyScalarType scalarType = PhyScalarType.PhyUChar; //FileStream file = new FileStream(heightfieldFile, FileMode.Open, FileAccess.Read); // Use float data PhyScalarType scalarType = PhyScalarType.PhyFloat; byte[] terr = new byte[width * length * 4]; MemoryStream file = new MemoryStream(terr); BinaryWriter writer = new BinaryWriter(file); for (i = 0; i < width; i++) for (int j = 0; j < length; j++) writer.Write((float)((maxHeight / 2) + 4 * Math.Sin(j * 0.5f) * Math.Cos(i))); writer.Flush(); file.Position = 0; HeightfieldTerrainShape heightterrainShape = new HeightfieldTerrainShape(width, length, file, heightScale, 0, maxHeight, upIndex, scalarType, false); heightterrainShape.SetUseDiamondSubdivision(true); groundShape = heightterrainShape; groundShape.LocalScaling = new Vector3(scale.X, 1, scale.Z); tr = Matrix.Translation(new Vector3(-scale.X / 2, scale.Y / 2, -scale.Z / 2)); vehicleTr = Matrix.Translation(new Vector3(20, 3, -3)); // Create graphics object file.Position = 0; BinaryReader reader = new BinaryReader(file); int totalTriangles = (width - 1) * (length - 1) * 2; int totalVerts = width * length; game.groundMesh = new Mesh(game.Device, totalTriangles, totalVerts, MeshFlags.SystemMemory | MeshFlags.Use32Bit, VertexFormat.Position | VertexFormat.Normal); SlimDX.DataStream data = game.groundMesh.LockVertexBuffer(LockFlags.None); for (i = 0; i < width; i++) { for (int j = 0; j < length; j++) { float height; if (scalarType == PhyScalarType.PhyFloat) { // heightScale isn't applied internally for float data height = reader.ReadSingle(); } else if (scalarType == PhyScalarType.PhyUChar) { height = file.ReadByte() * heightScale; } else { height = 0.0f; } data.Write((j - length * 0.5f) * scale.X); data.Write(height); data.Write((i - width * 0.5f) * scale.Z); // Normals will be calculated later data.Position += 12; } } game.groundMesh.UnlockVertexBuffer(); file.Close(); data = game.groundMesh.LockIndexBuffer(LockFlags.None); for (i = 0; i < width - 1; i++) { for (int j = 0; j < length - 1; j++) { // Using diamond subdivision if ((j + i) % 2 == 0) { data.Write(j * width + i); data.Write((j + 1) * width + i + 1); data.Write(j * width + i + 1); data.Write(j * width + i); data.Write((j + 1) * width + i); data.Write((j + 1) * width + i + 1); } else { data.Write(j * width + i); data.Write((j + 1) * width + i); data.Write(j * width + i + 1); data.Write(j * width + i + 1); data.Write((j + 1) * width + i); data.Write((j + 1) * width + i + 1); } / * // Not using diamond subdivision data.Write(j * width + i); data.Write((j + 1) * width + i); data.Write(j * width + i + 1); data.Write(j * width + i + 1); data.Write((j + 1) * width + i); data.Write((j + 1) * width + i + 1); * / } } game.groundMesh.UnlockIndexBuffer(); game.groundMesh.ComputeNormals(); }*/ CollisionShapes.Add(groundShape); //create ground object RigidBody ground = LocalCreateRigidBody(0, tr, groundShape); ground.UserObject = "Ground"; CollisionShape chassisShape = new BoxShape(1.0f, 0.5f, 2.0f); CollisionShapes.Add(chassisShape); CompoundShape compound = new CompoundShape(); CollisionShapes.Add(compound); //localTrans effectively shifts the center of mass with respect to the chassis Matrix localTrans = Matrix.Translation(Vector3.UnitY); compound.AddChildShape(localTrans, chassisShape); RigidBody carChassis = LocalCreateRigidBody(800, Matrix.Identity, compound); carChassis.UserObject = "Chassis"; //carChassis.SetDamping(0.2f, 0.2f); //CylinderShapeX wheelShape = new CylinderShapeX(wheelWidth, wheelRadius, wheelRadius); // clientResetScene(); // create vehicle VehicleTuning tuning = new VehicleTuning(); IVehicleRaycaster vehicleRayCaster = new DefaultVehicleRaycaster(World); //vehicle = new RaycastVehicle(tuning, carChassis, vehicleRayCaster); vehicle = new CustomVehicle(tuning, carChassis, vehicleRayCaster); carChassis.ActivationState = ActivationState.DisableDeactivation; World.AddAction(vehicle); const float connectionHeight = 1.2f; bool isFrontWheel = true; // choose coordinate system vehicle.SetCoordinateSystem(rightIndex, upIndex, forwardIndex); BulletSharp.Math.Vector3 connectionPointCS0 = new Vector3(CUBE_HALF_EXTENTS - (0.3f * wheelWidth), connectionHeight, 2 * CUBE_HALF_EXTENTS - wheelRadius); vehicle.AddWheel(connectionPointCS0, wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, isFrontWheel); connectionPointCS0 = new Vector3(-CUBE_HALF_EXTENTS + (0.3f * wheelWidth), connectionHeight, 2 * CUBE_HALF_EXTENTS - wheelRadius); vehicle.AddWheel(connectionPointCS0, wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, isFrontWheel); isFrontWheel = false; connectionPointCS0 = new Vector3(-CUBE_HALF_EXTENTS + (0.3f * wheelWidth), connectionHeight, -2 * CUBE_HALF_EXTENTS + wheelRadius); vehicle.AddWheel(connectionPointCS0, wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, isFrontWheel); connectionPointCS0 = new Vector3(CUBE_HALF_EXTENTS - (0.3f * wheelWidth), connectionHeight, -2 * CUBE_HALF_EXTENTS + wheelRadius); vehicle.AddWheel(connectionPointCS0, wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, isFrontWheel); for (i = 0; i < vehicle.NumWheels; i++) { WheelInfo wheel = vehicle.GetWheelInfo(i); wheel.SuspensionStiffness = suspensionStiffness; wheel.WheelsDampingRelaxation = suspensionDamping; wheel.WheelsDampingCompression = suspensionCompression; wheel.FrictionSlip = wheelFriction; wheel.RollInfluence = rollInfluence; } vehicle.RigidBody.WorldTransform = vehicleTr; }
public TriangleIndexVertexArray CreateMeshInterface(byte[] meshData, int offset, Dictionary<long, byte[]> libPointers) { TriangleIndexVertexArray meshInterface = CreateTriangleMeshContainer(); byte[] meshParts; Vector3 scaling; int numMeshParts; using (MemoryStream shapeStream = new MemoryStream(meshData, false)) { using (BulletReader shapeReader = new BulletReader(shapeStream)) { shapeStream.Position += offset; long meshPartsPtr = shapeReader.ReadPtr(); meshParts = libPointers[meshPartsPtr]; scaling = shapeReader.ReadVector3(); numMeshParts = shapeReader.ReadInt32(); } } using (MemoryStream meshStream = new MemoryStream(meshParts, false)) { using (BulletReader meshReader = new BulletReader(meshStream)) { for (int i = 0; i < numMeshParts; i++) { int meshOffset = i * Marshal.SizeOf(typeof(MeshPartData)); IndexedMesh meshPart = new IndexedMesh(); long vertices3f = meshReader.ReadPtr(meshOffset + MeshPartData.Offset("Vertices3F")); long vertices3d = meshReader.ReadPtr(meshOffset + MeshPartData.Offset("Vertices3D")); long indices32 = meshReader.ReadPtr(meshOffset + MeshPartData.Offset("Indices32")); meshPart.NumTriangles = meshReader.ReadInt32(meshOffset + MeshPartData.Offset("NumTriangles")); meshPart.NumVertices = meshReader.ReadInt32(meshOffset + MeshPartData.Offset("NumVertices")); meshPart.Allocate(meshPart.NumTriangles, meshPart.NumVertices, sizeof(int) * 3, sizeof(float) * 4); if (indices32 != 0) { using (Stream triangleStream = meshPart.GetTriangleStream()) { byte[] indices = libPointers[indices32]; triangleStream.Write(indices, 0, indices.Length); } } else { throw new NotImplementedException(); long indices16 = meshReader.ReadPtr(meshOffset + MeshPartData.Offset("Indices16")); } if (vertices3f != 0) { using (Stream vertexStream = meshPart.GetVertexStream()) { byte[] vertices = libPointers[vertices3f]; vertexStream.Write(vertices, 0, vertices.Length); } } else { throw new NotImplementedException(); } if (meshPart.TriangleIndexBase != IntPtr.Zero && meshPart.VertexBase != IntPtr.Zero) { meshInterface.AddIndexedMesh(meshPart, meshPart.IndexType); } //meshPart.Dispose(); } } } return meshInterface; }
public TriangleIndexVertexArray(int[] triangles, float[] vertices) : base(btTriangleIndexVertexArray_new()) { _initialMesh = new IndexedMesh(); _initialMesh.Allocate(triangles.Length / 3, vertices.Length / 3); Marshal.Copy(triangles, 0, _initialMesh.TriangleIndexBase, triangles.Length); Marshal.Copy(vertices, 0, _initialMesh.VertexBase, vertices.Length); AddIndexedMesh(_initialMesh); }
// Create a sequence of flag objects and add them to the world. void CreateFlag(int width, int height, out AlignedSoftBodyArray flags) { flags = new AlignedSoftBodyArray(); // First create a triangle mesh to represent a flag // Allocate a simple mesh consisting of a vertex array and a triangle index array IndexedMesh mesh = new IndexedMesh(); mesh.NumVertices = width * height; mesh.NumTriangles = 2 * (width - 1) * (height - 1); Vector3Array vertexArray = new Vector3Array(mesh.NumVertices); mesh.Vertices = vertexArray; mesh.VertexStride = Vector3.SizeInBytes; IntArray triangleVertexIndexArray = new IntArray(3 * mesh.NumTriangles); mesh.TriangleIndices = triangleVertexIndexArray; mesh.TriangleIndexStride = sizeof(int) * 3; // Generate normalised object space vertex coordinates for a rectangular flag Matrix defaultScale = Matrix.Scaling(5, 20, 1); for (int y = 0; y < height; ++y) { float yCoordinate = y * 2.0f / (float)height - 1.0f; for (int x = 0; x < width; ++x) { float xCoordinate = x * 2.0f / (float)width - 1.0f; Vector3 vertex = new Vector3(xCoordinate, yCoordinate, 0.0f); vertexArray[y * width + x] = Vector3.TransformCoordinate(vertex, defaultScale); } } // Generate vertex indices for triangles for (int y = 0; y < (height - 1); ++y) { for (int x = 0; x < (width - 1); ++x) { // Triangle 0 // Top left of square on mesh { int vertex0 = y * width + x; int vertex1 = vertex0 + 1; int vertex2 = vertex0 + width; int triangleIndex = 2 * (y * (width - 1) + x); triangleVertexIndexArray[(mesh.TriangleIndexStride * triangleIndex) / sizeof(int)] = vertex0; triangleVertexIndexArray[(mesh.TriangleIndexStride * triangleIndex + 1) / sizeof(int) + 1] = vertex1; triangleVertexIndexArray[(mesh.TriangleIndexStride * triangleIndex + 2) / sizeof(int) + 2] = vertex2; } // Triangle 1 // Bottom right of square on mesh { int vertex0 = y * width + x + 1; int vertex1 = vertex0 + width; int vertex2 = vertex1 - 1; int triangleIndex = 2 * y * (width - 1) + 2 * x + 1; triangleVertexIndexArray[(mesh.TriangleIndexStride * triangleIndex) / sizeof(int)] = vertex0; triangleVertexIndexArray[(mesh.TriangleIndexStride * triangleIndex) / sizeof(int) + 1] = vertex1; triangleVertexIndexArray[(mesh.TriangleIndexStride * triangleIndex) / sizeof(int) + 2] = vertex2; } } } Matrix defaultRotateAndScale = Matrix.RotationX(0.5f); // Construct the sequence flags applying a slightly different translation to each one to arrange them // appropriately in the scene. for (int i = 0; i < numFlags; ++i) { float zTranslate = flagSpacing * (i - numFlags / 2); Vector3 defaultTranslate = new Vector3(0, 20, zTranslate); Matrix transform = defaultRotateAndScale * Matrix.Translation(defaultTranslate); SoftBody softBody = CreateFromIndexedMesh(vertexArray, triangleVertexIndexArray, true); for (int j = 0; j < mesh.NumVertices; ++j) { softBody.SetMass(j, 10.0f / mesh.NumVertices); } softBody.SetMass((height - 1) * width, 0); softBody.SetMass((height - 1) * width + width - 1, 0); softBody.SetMass((height - 1) * width + width / 2, 0); softBody.Cfg.Collisions = FCollisions.CLSS | FCollisions.CLRS; softBody.Cfg.LF = 0.0005f; softBody.Cfg.VCF = 0.001f; softBody.Cfg.DP = 0.0f; softBody.Cfg.DG = 0.0f; flags.Add(softBody); softBody.Transform(transform); SoftWorld.AddSoftBody(softBody); } //delete [] vertexArray; //delete [] triangleVertexIndexArray; }
protected override void OnInitialize() { Freelook.SetEyeTarget(eye, target); Graphics.SetFormText("BulletSharp - Concave Raycast Demo"); Graphics.SetInfoText("Move using mouse and WASD+shift\n" + "F3 - Toggle debug\n" + //"F11 - Toggle fullscreen\n" + "Space - Shoot box"); DebugDrawMode = debugMode; const int totalVerts = NUM_VERTS_X * NUM_VERTS_Y; const int totalTriangles = 2 * (NUM_VERTS_X - 1) * (NUM_VERTS_Y - 1); indexVertexArrays = new TriangleIndexVertexArray(); IndexedMesh mesh = new IndexedMesh(); mesh.Allocate(totalVerts, Vector3.SizeInBytes, totalTriangles, 3 * sizeof(int)); DataStream indices = mesh.LockIndices(); for (int i = 0; i < NUM_VERTS_X - 1; i++) { for (int j = 0; j < NUM_VERTS_Y - 1; j++) { indices.Write(j * NUM_VERTS_X + i); indices.Write(j * NUM_VERTS_X + i + 1); indices.Write((j + 1) * NUM_VERTS_X + i + 1); indices.Write(j * NUM_VERTS_X + i); indices.Write((j + 1) * NUM_VERTS_X + i + 1); indices.Write((j + 1) * NUM_VERTS_X + i); } } indices.Dispose(); indexVertexArrays.AddIndexedMesh(mesh); raycastBar = new RaycastBar(4000.0f, 0.0f); //raycastBar = new RaycastBar(true, 40.0f, -50.0f, 50.0f); }
public void AddIndexedMesh(IndexedMesh mesh, PhyScalarType indexType) { _meshes.Add(mesh); btTriangleIndexVertexArray_addIndexedMesh2(_native, mesh._native, indexType); }
protected override void OnInitializePhysics() { // collision configuration contains default setup for memory, collision setup CollisionConf = new DefaultCollisionConfiguration(); Dispatcher = new CollisionDispatcher(CollisionConf); Vector3 worldMin = new Vector3(-1000, -1000, -1000); Vector3 worldMax = new Vector3(1000, 1000, 1000); Broadphase = new AxisSweep3(worldMin, worldMax); Solver = new SequentialImpulseConstraintSolver(); World = new DiscreteDynamicsWorld(Dispatcher, Broadphase, Solver, CollisionConf); World.SolverInfo.SplitImpulse = 1; World.Gravity = new Vector3(0, -10, 0); const int totalVerts = NUM_VERTS_X * NUM_VERTS_Y; const int totalTriangles = 2 * (NUM_VERTS_X - 1) * (NUM_VERTS_Y - 1); indexVertexArrays = new TriangleIndexVertexArray(); IndexedMesh mesh = new IndexedMesh(); mesh.Allocate(totalVerts, totalTriangles, 3 * sizeof(int), Vector3.SizeInBytes, PhyScalarType.Int32, PhyScalarType.Single); using (var indices = mesh.LockIndices()) { for (int i = 0; i < NUM_VERTS_X - 1; i++) { for (int j = 0; j < NUM_VERTS_Y - 1; j++) { indices.Write(j * NUM_VERTS_X + i); indices.Write(j * NUM_VERTS_X + i + 1); indices.Write((j + 1) * NUM_VERTS_X + i + 1); indices.Write(j * NUM_VERTS_X + i); indices.Write((j + 1) * NUM_VERTS_X + i + 1); indices.Write((j + 1) * NUM_VERTS_X + i); } } } indexVertexArrays.AddIndexedMesh(mesh); raycastBar = new RaycastBar(4000.0f, 0.0f); //raycastBar = new RaycastBar(true, 40.0f, -50.0f, 50.0f); CollisionShape colShape = new BoxShape(1); CollisionShapes.Add(colShape); for (int i = 0; i < 10; i++) { //CollisionShape colShape = new CapsuleShape(0.5f,2.0f);//boxShape = new SphereShape(1.0f); Matrix startTransform = Matrix.Translation(2 * i, 10, 1); LocalCreateRigidBody(1.0f, startTransform, colShape); } SetVertexPositions(waveHeight, 0.0f); const bool useQuantizedAabbCompression = true; groundShape = new BvhTriangleMeshShape(indexVertexArrays, useQuantizedAabbCompression); CollisionShapes.Add(groundShape); staticBody = LocalCreateRigidBody(0.0f, Matrix.Identity, groundShape); staticBody.CollisionFlags |= CollisionFlags.StaticObject; staticBody.UserObject = "Ground"; }