public static CollisionHull CreateCylinder(WorldBase world, int shapeID, double radius, double height, Matrix3D?offsetMatrix) { float[] newtOffsetMatrix = null; // null means no offset if (offsetMatrix != null) { newtOffsetMatrix = new NewtonMatrix(offsetMatrix.Value).Matrix; } IntPtr handle = Newton.NewtonCreateCylinder(world.Handle, Convert.ToSingle(radius), Convert.ToSingle(height), shapeID, newtOffsetMatrix); return(new CollisionHull(handle, world, newtOffsetMatrix, CollisionShapeType.Cylinder)); }
public static CollisionHull CreateBox(WorldBase world, int shapeID, Vector3D size, Matrix3D?offsetMatrix) { float[] newtOffsetMatrix = null; // null means no offset if (offsetMatrix != null) { newtOffsetMatrix = new NewtonMatrix(offsetMatrix.Value).Matrix; } IntPtr handle = Newton.NewtonCreateBox(world.Handle, Convert.ToSingle(size.X), Convert.ToSingle(size.Y), Convert.ToSingle(size.Z), shapeID, newtOffsetMatrix); return(new CollisionHull(handle, world, newtOffsetMatrix, CollisionShapeType.Box)); }
public static CollisionHull CreateCapsule(WorldBase world, int shapeID, double radius, double height, Matrix3D?offsetMatrix) { //NOTE: Height must be >= diameter. If you want less, use ChamferCylinder float[] newtOffsetMatrix = null; // null means no offset if (offsetMatrix != null) { newtOffsetMatrix = new NewtonMatrix(offsetMatrix.Value).Matrix; } IntPtr handle = Newton.NewtonCreateCapsule(world.Handle, Convert.ToSingle(radius), Convert.ToSingle(height), shapeID, newtOffsetMatrix); return(new CollisionHull(handle, world, newtOffsetMatrix, CollisionShapeType.Capsule)); }
public static CollisionHull CreateConvexHull(WorldBase world, int shapeID, IEnumerable<Point3D> verticies, Matrix3D? offsetMatrix = null, double tolerance = .002d) { //NOTE: If the mesh passed in is concave, newton will make it convex. If you require concave, build up a complex collision out of convex primitives //NOTE: Must have at least 4 verticies #region Tolerance Comments // Got this from here: //http://newtondynamics.com/wiki/index.php5?title=NewtonCreateConvexHull // dFloat tolerance - the vertex optimization tolerance. A higher number means the hull can be simplified where there are multiple vertices with distance lower than // the tolerance; this is useful when generating simpler convex hulls from highly detailed meshes. // It's new in Newton 2 and can speed up the performance by reducing the count of vertices of a convex hull. // Here is the description by Julio Jerez (author of Newton): // The convex hull tolerance does not always apply and it is hard to predict, say for example you have a box, then the parameter will do nothing because adjacent plane // bend 90 degree. // // Say some body have a cube with bevel edges, the at the corner you will have many points that are very close to each other this result on a convex hull that is very dense // on the edges and the vertex. // // In that case the tolerance parameter does make a difference. What is does is that after the Hull is made, for each vertex, an average plane is created by fanning of all the // vertices that can be reach from a direct edge going out of that vertex. // // If the distance from each vertex to the average plane is very small, // And the distance from the center vertex to the plane is smaller than the tolerance, // Then the center vertex can be extracted from the hull and the hull can be reconstructed, // The resulting shape will not be too different from the ideal one. // // It continues doing that until not more vertex can be subtracted from the original shape. // // Basically what is does is that is remove lots of vertices that are too close and make the shep to dense for collision. // // A tolerance of 0.002 is good candidate especially when you have large cloud of vertices because it will eliminate points that are a 2 millimeter of less from the ideal hull, // It leads to a great speed up in collision time. // // (additional note: this value depends to the kind of application and their dimensions) // Since Newton 2.25 the tolerance depend of the diagonal of the cloud point (or bounding box). Ex: A prism with large and small dimension (580 x 0.5 x 580) will have // a large diagonal (820). If you set tolerance at 0.001 then the function will eliminate point that are less close of 820*0.001=0.8 units. So your prism become a plane and // the function return NULL. To resolve this error just set a lower tolerance. This change was made to get same shape for hull with different scale. #endregion // Offset Matrix float[] newtOffsetMatrix = null; // null means no offset if (offsetMatrix != null) { newtOffsetMatrix = new NewtonMatrix(offsetMatrix.Value).Matrix; } int vertexCount = verticies.Count(); // Verticies float[,] vertexArray = new float[vertexCount, 3]; int i = 0; foreach (Point3D vertex in verticies) { vertexArray[i, 0] = (float)vertex.X; vertexArray[i, 1] = (float)vertex.Y; vertexArray[i, 2] = (float)vertex.Z; i++; } // Create in newton IntPtr handle = Newton.NewtonCreateConvexHull(world.Handle, vertexCount, vertexArray, sizeof(float) * 3, Convert.ToSingle(tolerance), shapeID, newtOffsetMatrix); // Exit Function return new CollisionHull(handle, world, newtOffsetMatrix, CollisionShapeType.ConvexHull); }
public static CollisionHull CreateChamferCylinder(WorldBase world, int shapeID, double radius, double height, Matrix3D? offsetMatrix) { //TODO: Figure out what is wrong when this is tall and skinny float[] newtOffsetMatrix = null; // null means no offset if (offsetMatrix != null) { newtOffsetMatrix = new NewtonMatrix(offsetMatrix.Value).Matrix; } IntPtr handle = Newton.NewtonCreateChamferCylinder(world.Handle, Convert.ToSingle(radius), Convert.ToSingle(height), shapeID, newtOffsetMatrix); return new CollisionHull(handle, world, newtOffsetMatrix, CollisionShapeType.ChamferCylinder); }
public static CollisionHull CreateCapsule(WorldBase world, int shapeID, double radius, double height, Matrix3D? offsetMatrix) { //NOTE: Height must be >= diameter. If you want less, use ChamferCylinder float[] newtOffsetMatrix = null; // null means no offset if (offsetMatrix != null) { newtOffsetMatrix = new NewtonMatrix(offsetMatrix.Value).Matrix; } IntPtr handle = Newton.NewtonCreateCapsule(world.Handle, Convert.ToSingle(radius), Convert.ToSingle(height), shapeID, newtOffsetMatrix); return new CollisionHull(handle, world, newtOffsetMatrix, CollisionShapeType.Capsule); }
public static CollisionHull CreateBox(WorldBase world, int shapeID, Vector3D size, Matrix3D? offsetMatrix) { float[] newtOffsetMatrix = null; // null means no offset if (offsetMatrix != null) { newtOffsetMatrix = new NewtonMatrix(offsetMatrix.Value).Matrix; } IntPtr handle = Newton.NewtonCreateBox(world.Handle, Convert.ToSingle(size.X), Convert.ToSingle(size.Y), Convert.ToSingle(size.Z), shapeID, newtOffsetMatrix); return new CollisionHull(handle, world, newtOffsetMatrix, CollisionShapeType.Box); }
public static CollisionHull CreateConvexHull(WorldBase world, int shapeID, IEnumerable <Point3D> verticies, Matrix3D?offsetMatrix = null, double tolerance = .002d) { //NOTE: If the mesh passed in is concave, newton will make it convex. If you require concave, build up a complex collision out of convex primitives //NOTE: Must have at least 4 verticies #region Tolerance Comments // Got this from here: //http://newtondynamics.com/wiki/index.php5?title=NewtonCreateConvexHull // dFloat tolerance - the vertex optimization tolerance. A higher number means the hull can be simplified where there are multiple vertices with distance lower than // the tolerance; this is useful when generating simpler convex hulls from highly detailed meshes. // It's new in Newton 2 and can speed up the performance by reducing the count of vertices of a convex hull. // Here is the description by Julio Jerez (author of Newton): // The convex hull tolerance does not always apply and it is hard to predict, say for example you have a box, then the parameter will do nothing because adjacent plane // bend 90 degree. // // Say some body have a cube with bevel edges, the at the corner you will have many points that are very close to each other this result on a convex hull that is very dense // on the edges and the vertex. // // In that case the tolerance parameter does make a difference. What is does is that after the Hull is made, for each vertex, an average plane is created by fanning of all the // vertices that can be reach from a direct edge going out of that vertex. // // If the distance from each vertex to the average plane is very small, // And the distance from the center vertex to the plane is smaller than the tolerance, // Then the center vertex can be extracted from the hull and the hull can be reconstructed, // The resulting shape will not be too different from the ideal one. // // It continues doing that until not more vertex can be subtracted from the original shape. // // Basically what is does is that is remove lots of vertices that are too close and make the shep to dense for collision. // // A tolerance of 0.002 is good candidate especially when you have large cloud of vertices because it will eliminate points that are a 2 millimeter of less from the ideal hull, // It leads to a great speed up in collision time. // // (additional note: this value depends to the kind of application and their dimensions) // Since Newton 2.25 the tolerance depend of the diagonal of the cloud point (or bounding box). Ex: A prism with large and small dimension (580 x 0.5 x 580) will have // a large diagonal (820). If you set tolerance at 0.001 then the function will eliminate point that are less close of 820*0.001=0.8 units. So your prism become a plane and // the function return NULL. To resolve this error just set a lower tolerance. This change was made to get same shape for hull with different scale. #endregion // Offset Matrix float[] newtOffsetMatrix = null; // null means no offset if (offsetMatrix != null) { newtOffsetMatrix = new NewtonMatrix(offsetMatrix.Value).Matrix; } int vertexCount = verticies.Count(); // Verticies float[,] vertexArray = new float[vertexCount, 3]; int i = 0; foreach (Point3D vertex in verticies) { vertexArray[i, 0] = (float)vertex.X; vertexArray[i, 1] = (float)vertex.Y; vertexArray[i, 2] = (float)vertex.Z; i++; } // Create in newton IntPtr handle = Newton.NewtonCreateConvexHull(world.Handle, vertexCount, vertexArray, sizeof(float) * 3, Convert.ToSingle(tolerance), shapeID, newtOffsetMatrix); // Exit Function return(new CollisionHull(handle, world, newtOffsetMatrix, CollisionShapeType.ConvexHull)); }