public static Dna Load(BulletReader dnaReader, bool swap)
{
var dna = new Dna();
dna.Init(dnaReader, swap);
return(dna);
}
public static Dna Load(byte[] dnaData, bool swap)
{
using (var stream = new MemoryStream(dnaData))
{
using (var reader = new BulletReader(stream))
{
return Load(reader, swap);
}
}
}
public static Dna Load(byte[] dnaData, bool swap)
{
using (var stream = new MemoryStream(dnaData))
{
using (var reader = new BulletReader(stream))
{
return(Load(reader, swap));
}
}
}
// Replaces an identifier in serialized data with an actual pointer to something.
// The handle should be used to free the pointer once it is no longer used.
private static GCHandle?PinDataAtPointer(byte[] data, int pointerPosition, BulletFile file)
{
long pointer = BulletReader.ToPtr(data, pointerPosition);
if (pointer != 0)
{
byte[] referencedData = file.LibPointers[pointer];
GCHandle dataHandle = GCHandle.Alloc(referencedData, GCHandleType.Pinned);
WritePointer(data, pointerPosition, dataHandle.AddrOfPinnedObject());
return(dataHandle);
}
return(null);
}
private void InitDna()
{
_dnaData = IntPtr.Size == 8 ? GetBulletDna64() : GetBulletDna();
bool swap = !BitConverter.IsLittleEndian;
using (var stream = new MemoryStream(_dnaData))
{
using (var reader = new BulletReader(stream))
{
_dna = Dna.Load(reader, swap);
}
}
}
private void LoadDna(FileVerboseMode verboseMode)
{
bool swap = (Flags & FileFlags.EndianSwap) != 0;
using (var stream = new MemoryStream(_fileBuffer, false))
{
using (var reader = new BulletReader(stream))
{
long dnaStart = FindDnaChunk(reader);
OK = dnaStart != -1;
if (!OK)
{
return;
}
stream.Position = dnaStart;
_fileDna = Dna.Load(reader, swap);
}
}
if (_fileDna.IsBroken(_version))
{
Console.WriteLine("Warning: broken DNA version");
Flags |= FileFlags.BrokenDna;
}
//if ((verboseMode & FileVerboseMode.DumpDnaTypeDefinitions) != 0)
// _fileDna.DumpTypeDefinitions();
byte[] memoryDnaData = IntPtr.Size == 8
? Serializer.GetBulletDna64()
: Serializer.GetBulletDna();
_memoryDna = Dna.Load(memoryDnaData, !BitConverter.IsLittleEndian);
_structChanged = _fileDna.Compare(_memoryDna);
}
private void AutoSerializeRootLevelChildren(XmlElement parent)
{
foreach (XmlNode node in parent)
{
if (node.NodeType != XmlNodeType.Element)
{
continue;
}
XmlElement element = node as XmlElement;
switch (element.Name)
{
case "btCompoundShapeChildData":
DeSerializeCompoundShapeChildData(element);
continue;
case "btCompoundShapeData":
DeSerializeCompoundShapeData(element);
continue;
case "btConvexHullShapeData":
DeSerializeConvexHullShapeData(element);
continue;
case "btConvexInternalShapeData":
DeSerializeConvexInternalShapeData(element);
continue;
case "btDynamicsWorldFloatData":
DeSerializeDynamicsWorldData(element);
continue;
case "btGeneric6DofConstraintData":
DeSerializeGeneric6DofConstraintData(element);
continue;
case "btRigidBodyFloatData":
DeSerializeRigidBodyFloatData(element);
continue;
case "btStaticPlaneShapeData":
DeSerializeStaticPlaneShapeData(element);
continue;
case "btVector3FloatData":
DeSerializeVector3FloatData(element);
continue;
default:
throw new NotImplementedException();
}
}
foreach (byte[] shapeData in _collisionShapeData)
{
CollisionShape shape = ConvertCollisionShape(shapeData, _pointerLookup);
if (shape != null)
{
foreach (KeyValuePair <long, byte[]> lib in _pointerLookup)
{
if (lib.Value == shapeData)
{
_shapeMap.Add(lib.Key, shape);
break;
}
}
using (var stream = new MemoryStream(shapeData, false))
{
using (var reader = new BulletReader(stream))
{
long namePtr = reader.ReadPtr(CollisionShapeData.Offset("Name"));
if (namePtr != 0)
{
byte[] nameData = _pointerLookup[namePtr];
int length = Array.IndexOf(nameData, (byte)0);
string name = System.Text.Encoding.ASCII.GetString(nameData, 0, length);
_objectNameMap.Add(shape, name);
_nameShapeMap.Add(name, shape);
}
}
}
}
}
foreach (byte[] rbData in _rigidBodyData)
{
ConvertRigidBodyFloat(rbData, _pointerLookup);
}
foreach (byte[] constraintData in _constraintData)
{
//throw new NotImplementedException();
//ConvertConstraint(constraintData);
}
}
public bool ConvertAllObjects(BulletFile file)
{
_shapeMap.Clear();
_bodyMap.Clear();
foreach (byte[] bvhData in file.Bvhs)
{
OptimizedBvh bvh = CreateOptimizedBvh();
if ((file.Flags & FileFlags.DoublePrecision) != 0)
{
throw new NotImplementedException();
}
else
{
// QuantizedBvhData is parsed in C++, so we need to actually fix pointers
GCHandle bvhDataHandle = GCHandle.Alloc(bvhData, GCHandleType.Pinned);
IntPtr bvhDataPinnedPtr = bvhDataHandle.AddrOfPinnedObject();
IntPtr contiguousNodesHandlePtr = IntPtr.Zero;
IntPtr quantizedContiguousNodesHandlePtr = IntPtr.Zero;
IntPtr subTreeInfoHandlePtr = IntPtr.Zero;
using (var stream = new MemoryStream(bvhData))
{
using (var reader = new BulletReader(stream))
{
long contiguousNodesPtr = reader.ReadPtr(QuantizedBvhFloatData.Offset("ContiguousNodesPtr"));
long quantizedContiguousNodesPtr = reader.ReadPtr(QuantizedBvhFloatData.Offset("QuantizedContiguousNodesPtr"));
long subTreeInfoPtr = reader.ReadPtr(QuantizedBvhFloatData.Offset("SubTreeInfoPtr"));
using (var writer = new BulletWriter(stream))
{
if (contiguousNodesPtr != 0)
{
GCHandle contiguousNodesHandle = GCHandle.Alloc(file.LibPointers[contiguousNodesPtr], GCHandleType.Pinned);
contiguousNodesHandlePtr = GCHandle.ToIntPtr(contiguousNodesHandle);
stream.Position = QuantizedBvhFloatData.Offset("ContiguousNodesPtr");
writer.Write(contiguousNodesHandle.AddrOfPinnedObject());
}
if (quantizedContiguousNodesPtr != 0)
{
GCHandle quantizedContiguousNodesHandle = GCHandle.Alloc(file.LibPointers[quantizedContiguousNodesPtr], GCHandleType.Pinned);
quantizedContiguousNodesHandlePtr = GCHandle.ToIntPtr(quantizedContiguousNodesHandle);
stream.Position = QuantizedBvhFloatData.Offset("QuantizedContiguousNodesPtr");
writer.Write(quantizedContiguousNodesHandle.AddrOfPinnedObject());
}
if (subTreeInfoPtr != 0)
{
GCHandle subTreeInfoHandle = GCHandle.Alloc(file.LibPointers[subTreeInfoPtr], GCHandleType.Pinned);
subTreeInfoHandlePtr = GCHandle.ToIntPtr(subTreeInfoHandle);
stream.Position = QuantizedBvhFloatData.Offset("SubTreeInfoPtr");
writer.Write(subTreeInfoHandle.AddrOfPinnedObject());
}
}
}
}
bvh.DeSerializeFloat(bvhDataPinnedPtr);
bvhDataHandle.Free();
if (contiguousNodesHandlePtr != IntPtr.Zero)
{
GCHandle.FromIntPtr(contiguousNodesHandlePtr).Free();
}
if (quantizedContiguousNodesHandlePtr != IntPtr.Zero)
{
GCHandle.FromIntPtr(quantizedContiguousNodesHandlePtr).Free();
}
if (subTreeInfoHandlePtr != IntPtr.Zero)
{
GCHandle.FromIntPtr(subTreeInfoHandlePtr).Free();
}
}
foreach (KeyValuePair <long, byte[]> lib in file.LibPointers)
{
if (lib.Value == bvhData)
{
_bvhMap.Add(lib.Key, bvh);
break;
}
}
}
foreach (byte[] shapeData in file.CollisionShapes)
{
CollisionShape shape = ConvertCollisionShape(shapeData, file.LibPointers);
if (shape != null)
{
foreach (KeyValuePair <long, byte[]> lib in file.LibPointers)
{
if (lib.Value == shapeData)
{
_shapeMap.Add(lib.Key, shape);
break;
}
}
using (var stream = new MemoryStream(shapeData, false))
{
using (var reader = new BulletReader(stream))
{
long namePtr = reader.ReadPtr(CollisionShapeFloatData.Offset("Name"));
if (namePtr != 0)
{
byte[] nameData = file.LibPointers[namePtr];
int length = Array.IndexOf(nameData, (byte)0);
string name = System.Text.Encoding.ASCII.GetString(nameData, 0, length);
_objectNameMap.Add(shape, name);
_nameShapeMap.Add(name, shape);
}
}
}
}
}
foreach (byte[] solverInfoData in file.DynamicsWorldInfo)
{
if ((file.Flags & FileFlags.DoublePrecision) != 0)
{
//throw new NotImplementedException();
}
else
{
//throw new NotImplementedException();
}
}
foreach (byte[] bodyData in file.RigidBodies)
{
if ((file.Flags & FileFlags.DoublePrecision) != 0)
{
throw new NotImplementedException();
}
else
{
ConvertRigidBodyFloat(bodyData, file.LibPointers);
}
}
foreach (byte[] colObjData in file.CollisionObjects)
{
if ((file.Flags & FileFlags.DoublePrecision) != 0)
{
throw new NotImplementedException();
}
else
{
using (var colObjStream = new MemoryStream(colObjData, false))
{
using (var colObjReader = new BulletReader(colObjStream))
{
long shapePtr = colObjReader.ReadPtr(CollisionObjectFloatData.Offset("CollisionShape"));
CollisionShape shape = _shapeMap[shapePtr];
Math.Matrix startTransform = colObjReader.ReadMatrix(CollisionObjectFloatData.Offset("WorldTransform"));
long namePtr = colObjReader.ReadPtr(CollisionObjectFloatData.Offset("Name"));
string name = null;
if (namePtr != 0)
{
byte[] nameData = file.FindLibPointer(namePtr);
int length = Array.IndexOf(nameData, (byte)0);
name = System.Text.Encoding.ASCII.GetString(nameData, 0, length);
}
CollisionObject colObj = CreateCollisionObject(ref startTransform, shape, name);
_bodyMap.Add(colObjData, colObj);
}
}
}
}
foreach (byte[] constraintData in file.Constraints)
{
var stream = new MemoryStream(constraintData, false);
using (var reader = new BulletReader(stream))
{
long collisionObjectAPtr = reader.ReadPtr(TypedConstraintFloatData.Offset("RigidBodyA"));
long collisionObjectBPtr = reader.ReadPtr(TypedConstraintFloatData.Offset("RigidBodyB"));
RigidBody a = null, b = null;
if (collisionObjectAPtr != 0)
{
if (!file.LibPointers.ContainsKey(collisionObjectAPtr))
{
a = TypedConstraint.GetFixedBody();
}
else
{
byte[] coData = file.LibPointers[collisionObjectAPtr];
a = RigidBody.Upcast(_bodyMap[coData]);
if (a == null)
{
a = TypedConstraint.GetFixedBody();
}
}
}
if (collisionObjectBPtr != 0)
{
if (!file.LibPointers.ContainsKey(collisionObjectBPtr))
{
b = TypedConstraint.GetFixedBody();
}
else
{
byte[] coData = file.LibPointers[collisionObjectBPtr];
b = RigidBody.Upcast(_bodyMap[coData]);
if (b == null)
{
b = TypedConstraint.GetFixedBody();
}
}
}
if (a == null && b == null)
{
stream.Dispose();
continue;
}
if ((file.Flags & FileFlags.DoublePrecision) != 0)
{
throw new NotImplementedException();
}
else
{
ConvertConstraintFloat(a, b, constraintData, file.Version, file.LibPointers);
}
}
stream.Dispose();
}
return(true);
}
public bool ConvertAllObjects(BulletFile file)
{
_shapeMap.Clear();
_bodyMap.Clear();
foreach (byte[] bvhData in file._bvhs)
{
OptimizedBvh bvh = CreateOptimizedBvh();
if ((file.Flags & FileFlags.DoublePrecision) != 0)
{
throw new NotImplementedException();
}
else
{
// QuantizedBvhData is parsed in C++, so we need to actually fix pointers
GCHandle bvhDataHandle = GCHandle.Alloc(bvhData, GCHandleType.Pinned);
IntPtr bvhDataPinnedPtr = bvhDataHandle.AddrOfPinnedObject();
IntPtr contiguousNodesHandlePtr = IntPtr.Zero;
IntPtr quantizedContiguousNodesHandlePtr = IntPtr.Zero;
IntPtr subTreeInfoHandlePtr = IntPtr.Zero;
using (MemoryStream stream = new MemoryStream(bvhData))
{
using (BulletReader reader = new BulletReader(stream))
{
long contiguousNodesPtr = reader.ReadPtr(QuantizedBvhFloatData.Offset("ContiguousNodesPtr"));
long quantizedContiguousNodesPtr = reader.ReadPtr(QuantizedBvhFloatData.Offset("QuantizedContiguousNodesPtr"));
long subTreeInfoPtr = reader.ReadPtr(QuantizedBvhFloatData.Offset("SubTreeInfoPtr"));
using (BulletWriter writer = new BulletWriter(stream))
{
if (contiguousNodesPtr != 0)
{
GCHandle contiguousNodesHandle = GCHandle.Alloc(file.LibPointers[contiguousNodesPtr], GCHandleType.Pinned);
contiguousNodesHandlePtr = GCHandle.ToIntPtr(contiguousNodesHandle);
stream.Position = QuantizedBvhFloatData.Offset("ContiguousNodesPtr");
writer.Write(contiguousNodesHandle.AddrOfPinnedObject());
}
if (quantizedContiguousNodesPtr != 0)
{
GCHandle quantizedContiguousNodesHandle = GCHandle.Alloc(file.LibPointers[quantizedContiguousNodesPtr], GCHandleType.Pinned);
quantizedContiguousNodesHandlePtr = GCHandle.ToIntPtr(quantizedContiguousNodesHandle);
stream.Position = QuantizedBvhFloatData.Offset("QuantizedContiguousNodesPtr");
writer.Write(quantizedContiguousNodesHandle.AddrOfPinnedObject());
}
if (subTreeInfoPtr != 0)
{
GCHandle subTreeInfoHandle = GCHandle.Alloc(file.LibPointers[subTreeInfoPtr], GCHandleType.Pinned);
subTreeInfoHandlePtr = GCHandle.ToIntPtr(subTreeInfoHandle);
stream.Position = QuantizedBvhFloatData.Offset("SubTreeInfoPtr");
writer.Write(subTreeInfoHandle.AddrOfPinnedObject());
}
}
}
}
bvh.DeSerializeFloat(bvhDataPinnedPtr);
bvhDataHandle.Free();
if (contiguousNodesHandlePtr != IntPtr.Zero)
{
GCHandle.FromIntPtr(contiguousNodesHandlePtr).Free();
}
if (quantizedContiguousNodesHandlePtr != IntPtr.Zero)
{
GCHandle.FromIntPtr(quantizedContiguousNodesHandlePtr).Free();
}
if (subTreeInfoHandlePtr != IntPtr.Zero)
{
GCHandle.FromIntPtr(subTreeInfoHandlePtr).Free();
}
}
foreach (KeyValuePair<long, byte[]> lib in file.LibPointers)
{
if (lib.Value == bvhData)
{
_bvhMap.Add(lib.Key, bvh);
break;
}
}
}
foreach (byte[] shapeData in file._collisionShapes)
{
CollisionShape shape = ConvertCollisionShape(shapeData, file.LibPointers);
if (shape != null)
{
foreach (KeyValuePair<long, byte[]> lib in file.LibPointers)
{
if (lib.Value == shapeData)
{
_shapeMap.Add(lib.Key, shape);
break;
}
}
using (MemoryStream stream = new MemoryStream(shapeData, false))
{
using (BulletReader reader = new BulletReader(stream))
{
long namePtr = reader.ReadPtr(CollisionShapeFloatData.Offset("Name"));
if (namePtr != 0)
{
byte[] nameData = file.LibPointers[namePtr];
int length = Array.IndexOf(nameData, (byte)0);
string name = System.Text.Encoding.ASCII.GetString(nameData, 0, length);
_objectNameMap.Add(shape, name);
_nameShapeMap.Add(name, shape);
}
}
}
}
}
foreach (byte[] solverInfoData in file._dynamicsWorldInfo)
{
if ((file.Flags & FileFlags.DoublePrecision) != 0)
{
//throw new NotImplementedException();
}
else
{
//throw new NotImplementedException();
}
}
foreach (byte[] bodyData in file._rigidBodies)
{
if ((file.Flags & FileFlags.DoublePrecision) != 0)
{
throw new NotImplementedException();
}
else
{
ConvertRigidBodyFloat(bodyData, file.LibPointers);
}
}
foreach (byte[] colObjData in file._collisionObjects)
{
if ((file.Flags & FileFlags.DoublePrecision) != 0)
{
throw new NotImplementedException();
}
else
{
using (MemoryStream colObjStream = new MemoryStream(colObjData, false))
{
using (BulletReader colObjReader = new BulletReader(colObjStream))
{
long shapePtr = colObjReader.ReadPtr(CollisionObjectFloatData.Offset("CollisionShape"));
CollisionShape shape = _shapeMap[shapePtr];
Math.Matrix startTransform = colObjReader.ReadMatrix(CollisionObjectFloatData.Offset("WorldTransform"));
long namePtr = colObjReader.ReadPtr(CollisionObjectFloatData.Offset("Name"));
string name = null;
if (namePtr != 0)
{
byte[] nameData = file.FindLibPointer(namePtr);
int length = Array.IndexOf(nameData, (byte)0);
name = System.Text.Encoding.ASCII.GetString(nameData, 0, length);
}
CollisionObject colObj = CreateCollisionObject(ref startTransform, shape, name);
_bodyMap.Add(colObjData, colObj);
}
}
}
}
foreach (byte[] constraintData in file._constraints)
{
MemoryStream stream = new MemoryStream(constraintData, false);
using (BulletReader reader = new BulletReader(stream))
{
long collisionObjectAPtr = reader.ReadPtr(TypedConstraintFloatData.Offset("RigidBodyA"));
long collisionObjectBPtr = reader.ReadPtr(TypedConstraintFloatData.Offset("RigidBodyB"));
RigidBody a = null, b = null;
if (collisionObjectAPtr != 0)
{
if (!file.LibPointers.ContainsKey(collisionObjectAPtr))
{
a = TypedConstraint.GetFixedBody();
}
else
{
byte[] coData = file.LibPointers[collisionObjectAPtr];
a = RigidBody.Upcast(_bodyMap[coData]);
if (a == null)
{
a = TypedConstraint.GetFixedBody();
}
}
}
if (collisionObjectBPtr != 0)
{
if (!file.LibPointers.ContainsKey(collisionObjectBPtr))
{
b = TypedConstraint.GetFixedBody();
}
else
{
byte[] coData = file.LibPointers[collisionObjectBPtr];
b = RigidBody.Upcast(_bodyMap[coData]);
if (b == null)
{
b = TypedConstraint.GetFixedBody();
}
}
}
if (a == null && b == null)
{
stream.Dispose();
continue;
}
if ((file.Flags & FileFlags.DoublePrecision) != 0)
{
throw new NotImplementedException();
}
else
{
ConvertConstraintFloat(a, b, constraintData, file.Version, file.LibPointers);
}
}
stream.Dispose();
}
return true;
}
protected void ConvertConstraintFloat(RigidBody rigidBodyA, RigidBody rigidBodyB, byte[] constraintData, int fileVersion, Dictionary<long, byte[]> libPointers)
{
TypedConstraint constraint = null;
MemoryStream stream = new MemoryStream(constraintData, false);
BulletReader reader = new BulletReader(stream);
TypedConstraintType type = (TypedConstraintType)reader.ReadInt32(TypedConstraintFloatData.Offset("ObjectType"));
switch (type)
{
case TypedConstraintType.Point2Point:
{
Vector3 pivotInA = reader.ReadVector3(Point2PointConstraintFloatData.Offset("PivotInA"));
if (rigidBodyA != null && rigidBodyB != null)
{
Vector3 pivotInB = reader.ReadVector3(Point2PointConstraintFloatData.Offset("PivotInB"));
constraint = CreatePoint2PointConstraint(rigidBodyA, rigidBodyB, ref pivotInA, ref pivotInB);
}
else
{
constraint = CreatePoint2PointConstraint(rigidBodyA, ref pivotInA);
}
break;
}
case TypedConstraintType.ConeTwist:
{
ConeTwistConstraint coneTwist;
Matrix rbaFrame = reader.ReadMatrix(ConeTwistConstraintFloatData.Offset("RigidBodyAFrame"));
if (rigidBodyA != null && rigidBodyB != null)
{
Matrix rbbFrame = reader.ReadMatrix(ConeTwistConstraintFloatData.Offset("RigidBodyBFrame"));
coneTwist = CreateConeTwistConstraint(rigidBodyA, rigidBodyB, ref rbaFrame, ref rbbFrame);
}
else
{
coneTwist = CreateConeTwistConstraint(rigidBodyA, ref rbaFrame);
}
coneTwist.SetLimit(
reader.ReadSingle(ConeTwistConstraintFloatData.Offset("SwingSpan1")),
reader.ReadSingle(ConeTwistConstraintFloatData.Offset("SwingSpan2")),
reader.ReadSingle(ConeTwistConstraintFloatData.Offset("TwistSpan")),
reader.ReadSingle(ConeTwistConstraintFloatData.Offset("LimitSoftness")),
reader.ReadSingle(ConeTwistConstraintFloatData.Offset("BiasFactor")),
reader.ReadSingle(ConeTwistConstraintFloatData.Offset("RelaxationFactor")));
coneTwist.Damping = reader.ReadSingle(ConeTwistConstraintFloatData.Offset("Damping"));
constraint = coneTwist;
break;
}
case TypedConstraintType.D6:
{
Generic6DofConstraint dof = null;
if (rigidBodyA != null && rigidBodyB != null)
{
Matrix rbaFrame = reader.ReadMatrix(Generic6DofConstraintFloatData.Offset("RigidBodyAFrame"));
Matrix rbbFrame = reader.ReadMatrix(Generic6DofConstraintFloatData.Offset("RigidBodyBFrame"));
int useLinearReferenceFrameA = reader.ReadInt32(Generic6DofConstraintFloatData.Offset("UseLinearReferenceFrameA"));
dof = CreateGeneric6DofConstraint(rigidBodyA, rigidBodyB, ref rbaFrame, ref rbbFrame, useLinearReferenceFrameA != 0);
}
else
{
if (rigidBodyB != null)
{
Matrix rbbFrame = reader.ReadMatrix(Generic6DofConstraintFloatData.Offset("RigidBodyBFrame"));
int useLinearReferenceFrameA = reader.ReadInt32(Generic6DofConstraintFloatData.Offset("UseLinearReferenceFrameA"));
dof = CreateGeneric6DofConstraint(rigidBodyB, ref rbbFrame, useLinearReferenceFrameA != 0);
}
else
{
Console.WriteLine("Error in WorldImporter.CreateGeneric6DofConstraint: missing rigidBodyB");
}
}
if (dof != null)
{
dof.AngularLowerLimit = reader.ReadVector3(Generic6DofConstraintFloatData.Offset("AngularLowerLimit"));
dof.AngularUpperLimit = reader.ReadVector3(Generic6DofConstraintFloatData.Offset("AngularUpperLimit"));
dof.LinearLowerLimit = reader.ReadVector3(Generic6DofConstraintFloatData.Offset("LinearLowerLimit"));
dof.LinearUpperLimit = reader.ReadVector3(Generic6DofConstraintFloatData.Offset("LinearUpperLimit"));
}
constraint = dof;
break;
}
case TypedConstraintType.D6Spring:
{
Generic6DofSpringConstraint dof = null;
int sixDofData = Generic6DofSpringConstraintFloatData.Offset("SixDofData");
if (rigidBodyA != null && rigidBodyB != null)
{
Matrix rbaFrame = reader.ReadMatrix(sixDofData + Generic6DofConstraintFloatData.Offset("RigidBodyAFrame"));
Matrix rbbFrame = reader.ReadMatrix(sixDofData + Generic6DofConstraintFloatData.Offset("RigidBodyBFrame"));
int useLinearReferenceFrameA = reader.ReadInt32(sixDofData + Generic6DofConstraintFloatData.Offset("UseLinearReferenceFrameA"));
dof = CreateGeneric6DofSpringConstraint(rigidBodyA, rigidBodyB, ref rbaFrame, ref rbbFrame, useLinearReferenceFrameA != 0);
}
else
{
Console.WriteLine("Error in WorldImporter.CreateGeneric6DofSpringConstraint: requires rigidBodyA && rigidBodyB");
}
if (dof != null)
{
dof.AngularLowerLimit = reader.ReadVector3(sixDofData + Generic6DofConstraintFloatData.Offset("AngularLowerLimit"));
dof.AngularUpperLimit = reader.ReadVector3(sixDofData + Generic6DofConstraintFloatData.Offset("AngularUpperLimit"));
dof.LinearLowerLimit = reader.ReadVector3(sixDofData + Generic6DofConstraintFloatData.Offset("LinearLowerLimit"));
dof.LinearUpperLimit = reader.ReadVector3(sixDofData + Generic6DofConstraintFloatData.Offset("LinearUpperLimit"));
int i;
if (fileVersion > 280)
{
int springEnabledOffset = Generic6DofSpringConstraintFloatData.Offset("SpringEnabled");
int equilibriumPointOffset = Generic6DofSpringConstraintFloatData.Offset("EquilibriumPoint");
int springStiffnessOffset = Generic6DofSpringConstraintFloatData.Offset("SpringStiffness");
int springDampingOffset = Generic6DofSpringConstraintFloatData.Offset("SpringDamping");
for (i = 0; i < 6; i++)
{
dof.SetStiffness(i, reader.ReadSingle(springStiffnessOffset + sizeof(float) * i));
dof.SetEquilibriumPoint(i, reader.ReadSingle(equilibriumPointOffset + sizeof(float) * i));
dof.EnableSpring(i, reader.ReadInt32(springEnabledOffset + sizeof(int) * i) != 0);
dof.SetDamping(i, reader.ReadSingle(springDampingOffset + sizeof(float) * i));
}
}
}
constraint = dof;
break;
}
case TypedConstraintType.D6Spring2:
{
Generic6DofSpring2Constraint dof = null;
if (rigidBodyA != null && rigidBodyB != null)
{
Matrix rbaFrame = reader.ReadMatrix(Generic6DofSpring2ConstraintFloatData.Offset("RigidBodyAFrame"));
Matrix rbbFrame = reader.ReadMatrix(Generic6DofSpring2ConstraintFloatData.Offset("RigidBodyBFrame"));
RotateOrder rotateOrder = (RotateOrder)reader.ReadInt32(Generic6DofSpring2ConstraintFloatData.Offset("RotateOrder"));
dof = CreateGeneric6DofSpring2Constraint(rigidBodyA, rigidBodyB, ref rbaFrame, ref rbbFrame, rotateOrder);
}
else
{
Console.WriteLine("Error in WorldImporter.CreateGeneric6DofSpring2Constraint: requires rigidBodyA && rigidBodyB");
}
if (dof != null)
{
dof.AngularLowerLimit = reader.ReadVector3(Generic6DofSpring2ConstraintFloatData.Offset("AngularLowerLimit"));
dof.AngularUpperLimit = reader.ReadVector3(Generic6DofSpring2ConstraintFloatData.Offset("AngularUpperLimit"));
dof.LinearLowerLimit = reader.ReadVector3(Generic6DofSpring2ConstraintFloatData.Offset("LinearLowerLimit"));
dof.LinearUpperLimit = reader.ReadVector3(Generic6DofSpring2ConstraintFloatData.Offset("LinearUpperLimit"));
int i;
if (fileVersion > 280)
{
int linearSpringStiffnessOffset = Generic6DofSpring2ConstraintFloatData.Offset("LinearSpringStiffness");
int linearSpringStiffnessLimitedOffset = Generic6DofSpring2ConstraintFloatData.Offset("LinearSpringStiffnessLimited");
int linearEnableSpringdOffset = Generic6DofSpring2ConstraintFloatData.Offset("LinearEnableSpring");
int linearEquilibriumPointOffset = Generic6DofSpring2ConstraintFloatData.Offset("LinearEquilibriumPoint");
int linearSpringDampingOffset = Generic6DofSpring2ConstraintFloatData.Offset("LinearSpringDamping");
int linearSpringDampingLimitedOffset = Generic6DofSpring2ConstraintFloatData.Offset("LinearSpringDampingLimited");
for (i = 0; i < 3; i++)
{
dof.SetStiffness(i, reader.ReadSingle(linearSpringStiffnessOffset + sizeof(float) * i), reader.ReadByte(linearSpringStiffnessLimitedOffset + sizeof(byte) * i) != 0);
dof.SetEquilibriumPoint(i, reader.ReadSingle(linearEquilibriumPointOffset + sizeof(float) * i));
dof.EnableSpring(i, reader.ReadInt32(linearEnableSpringdOffset + sizeof(byte) * i) != 0);
dof.SetDamping(i, reader.ReadSingle(linearSpringDampingOffset + sizeof(float) * i), reader.ReadByte(linearSpringDampingLimitedOffset + sizeof(float) * i) != 0);
}
int angularSpringStiffnessOffset = Generic6DofSpring2ConstraintFloatData.Offset("AngularSpringStiffness");
int angularSpringStiffnessLimitedOffset = Generic6DofSpring2ConstraintFloatData.Offset("AngularSpringStiffnessLimited");
int angularEnableSpringdOffset = Generic6DofSpring2ConstraintFloatData.Offset("AngularEnableSpring");
int angularEquilibriumPointOffset = Generic6DofSpring2ConstraintFloatData.Offset("AngularEquilibriumPoint");
int angularSpringDampingOffset = Generic6DofSpring2ConstraintFloatData.Offset("AngularSpringDamping");
int angularSpringDampingLimitedOffset = Generic6DofSpring2ConstraintFloatData.Offset("AngularSpringDampingLimited");
for (i = 0; i < 3; i++)
{
dof.SetStiffness(i + 3, reader.ReadSingle(angularSpringStiffnessOffset + sizeof(float) * i), reader.ReadByte(angularSpringStiffnessLimitedOffset + sizeof(byte) * i) != 0);
dof.SetEquilibriumPoint(i + 3, reader.ReadSingle(angularEquilibriumPointOffset + sizeof(float) * i));
dof.EnableSpring(i + 3, reader.ReadInt32(angularEnableSpringdOffset + sizeof(byte) * i) != 0);
dof.SetDamping(i + 3, reader.ReadSingle(angularSpringDampingOffset + sizeof(float) * i), reader.ReadByte(angularSpringDampingLimitedOffset + sizeof(float) * i) != 0);
}
}
}
constraint = dof;
break;
}
case TypedConstraintType.Gear:
{
GearConstraint gear;
if (rigidBodyA != null && rigidBodyB != null)
{
Vector3 axisInA = reader.ReadVector3(GearConstraintFloatData.Offset("AxisInA"));
Vector3 axisInB = reader.ReadVector3(GearConstraintFloatData.Offset("AxisInB"));
float ratio = reader.ReadSingle(GearConstraintFloatData.Offset("Ratio"));
gear = CreateGearConstraint(rigidBodyA, rigidBodyB, ref axisInA, ref axisInB, ratio);
}
else
{
throw new NotImplementedException();
}
constraint = gear;
break;
}
case TypedConstraintType.Hinge:
{
HingeConstraint hinge;
Matrix rbaFrame = reader.ReadMatrix(HingeConstraintFloatData.Offset("RigidBodyAFrame"));
int useReferenceFrameA = reader.ReadInt32(HingeConstraintFloatData.Offset("UseReferenceFrameA"));
if (rigidBodyA != null && rigidBodyB != null)
{
Matrix rbbFrame = reader.ReadMatrix(HingeConstraintFloatData.Offset("RigidBodyBFrame"));
hinge = CreateHingeConstraint(rigidBodyA, rigidBodyB, ref rbaFrame, ref rbbFrame, useReferenceFrameA != 0);
}
else
{
hinge = CreateHingeConstraint(rigidBodyA, ref rbaFrame, useReferenceFrameA != 0);
}
if (reader.ReadInt32(HingeConstraintFloatData.Offset("EnableAngularMotor")) != 0)
{
hinge.EnableAngularMotor(true,
reader.ReadSingle(HingeConstraintFloatData.Offset("MotorTargetVelocity")),
reader.ReadSingle(HingeConstraintFloatData.Offset("MaxMotorImpulse")));
}
hinge.AngularOnly = reader.ReadInt32(HingeConstraintFloatData.Offset("AngularOnly")) != 0;
hinge.SetLimit(
reader.ReadSingle(HingeConstraintFloatData.Offset("LowerLimit")),
reader.ReadSingle(HingeConstraintFloatData.Offset("UpperLimit")),
reader.ReadSingle(HingeConstraintFloatData.Offset("LimitSoftness")),
reader.ReadSingle(HingeConstraintFloatData.Offset("BiasFactor")),
reader.ReadSingle(HingeConstraintFloatData.Offset("RelaxationFactor")));
constraint = hinge;
break;
}
case TypedConstraintType.Slider:
{
SliderConstraint slider;
Matrix rbbFrame = reader.ReadMatrix(SliderConstraintFloatData.Offset("RigidBodyBFrame"));
int useLinearReferenceFrameA = reader.ReadInt32(SliderConstraintFloatData.Offset("UseLinearReferenceFrameA"));
if (rigidBodyA != null && rigidBodyB != null)
{
Matrix rbaFrame = reader.ReadMatrix(SliderConstraintFloatData.Offset("RigidBodyAFrame"));
slider = CreateSliderConstraint(rigidBodyA, rigidBodyB, ref rbaFrame, ref rbbFrame, useLinearReferenceFrameA != 0);
}
else
{
slider = CreateSliderConstraint(rigidBodyB, ref rbbFrame, useLinearReferenceFrameA != 0);
}
slider.LowerLinearLimit = reader.ReadSingle(SliderConstraintFloatData.Offset("LinearLowerLimit"));
slider.UpperLinearLimit = reader.ReadSingle(SliderConstraintFloatData.Offset("LinearUpperLimit"));
slider.LowerAngularLimit = reader.ReadSingle(SliderConstraintFloatData.Offset("AngularLowerLimit"));
slider.UpperAngularLimit = reader.ReadSingle(SliderConstraintFloatData.Offset("AngularUpperLimit"));
slider.UseFrameOffset = reader.ReadInt32(SliderConstraintFloatData.Offset("UseOffsetForConstraintFrame")) != 0;
break;
}
default:
throw new NotImplementedException();
}
if (constraint != null)
{
constraint.DebugDrawSize = reader.ReadSingle(TypedConstraintFloatData.Offset("DebugDrawSize"));
// those fields didn't exist and set to zero for pre-280 versions, so do a check here
if (fileVersion >= 280)
{
constraint.BreakingImpulseThreshold = reader.ReadSingle(TypedConstraintFloatData.Offset("BreakingImpulseThreshold"));
constraint.IsEnabled = reader.ReadInt32(TypedConstraintFloatData.Offset("IsEnabled")) != 0;
constraint.OverrideNumSolverIterations = reader.ReadInt32(TypedConstraintFloatData.Offset("OverrideNumSolverIterations"));
}
long namePtr = reader.ReadPtr(TypedConstraintFloatData.Offset("Name"));
if (namePtr != 0)
{
byte[] nameData = libPointers[namePtr];
int length = Array.IndexOf(nameData, (byte)0);
string name = System.Text.Encoding.ASCII.GetString(nameData, 0, length);
_nameConstraintMap.Add(name, constraint);
_objectNameMap.Add(constraint, name);
}
if (_dynamicsWorld != null)
{
_dynamicsWorld.AddConstraint(constraint);
}
}
reader.Dispose();
stream.Dispose();
}
protected CollisionShape ConvertCollisionShape(byte[] shapeData, Dictionary<long, byte[]> libPointers)
{
CollisionShape shape = null;
MemoryStream stream = new MemoryStream(shapeData, false);
BulletReader reader = new BulletReader(stream);
BroadphaseNativeType type = (BroadphaseNativeType) reader.ReadInt32(CollisionShapeFloatData.Offset("ShapeType"));
stream.Position = Marshal.SizeOf(typeof(CollisionShapeFloatData));
switch (type)
{
case BroadphaseNativeType.StaticPlaneShape:
{
Vector3 localScaling = reader.ReadVector3();
Vector3 planeNormal = reader.ReadVector3();
float planeConstant = reader.ReadSingle();
shape = CreatePlaneShape(ref planeNormal, planeConstant);
shape.LocalScaling = localScaling;
break;
}
case BroadphaseNativeType.GImpactShape:
{
//StridingMeshInterfaceData* interfaceData = CreateStridingMeshInterfaceData(&gimpactData->m_meshInterface)
TriangleIndexVertexArray meshInterface = CreateMeshInterface(shapeData, GImpactMeshShapeData.Offset("MeshInterface"), libPointers);
GImpactShapeType gImpactType = (GImpactShapeType)reader.ReadInt32(GImpactMeshShapeData.Offset("GImpactSubType"));
if (gImpactType == GImpactShapeType.TrimeshShape)
{
GImpactMeshShape gimpactShape = CreateGimpactShape(meshInterface);
gimpactShape.LocalScaling = reader.ReadVector3(GImpactMeshShapeData.Offset("LocalScaling"));
gimpactShape.Margin = reader.ReadSingle(GImpactMeshShapeData.Offset("CollisionMargin"));
gimpactShape.UpdateBound();
shape = gimpactShape;
}
else
{
#if DEBUG
Console.WriteLine("Unsupported GImpact subtype");
#endif
}
break;
}
case BroadphaseNativeType.CompoundShape:
{
long childShapesPtr = reader.ReadPtr();
byte[] childShapes = libPointers[childShapesPtr];
int numChildShapes = reader.ReadInt32();
//float collisionMargin = reader.ReadInt32();
CompoundShape compoundShape = CreateCompoundShape();
using (MemoryStream shapeStream = new MemoryStream(childShapes, false))
{
using (BulletReader shapeReader = new BulletReader(shapeStream))
{
for (int i = 0; i < numChildShapes; i++)
{
Matrix localTransform = shapeReader.ReadMatrix();
long childShapePtr = shapeReader.ReadPtr();
int childShapeType = shapeReader.ReadInt32();
float childMargin = shapeReader.ReadSingle();
CollisionShape childShape = ConvertCollisionShape(libPointers[childShapePtr], libPointers);
compoundShape.AddChildShape(localTransform, childShape);
}
}
}
shape = compoundShape;
break;
}
case BroadphaseNativeType.BoxShape:
case BroadphaseNativeType.CapsuleShape:
case BroadphaseNativeType.ConeShape:
case BroadphaseNativeType.ConvexHullShape:
case BroadphaseNativeType.CylinderShape:
case BroadphaseNativeType.MultiSphereShape:
case BroadphaseNativeType.SphereShape:
{
Vector3 localScaling = reader.ReadVector3();
Vector3 implicitShapeDimensions = reader.ReadVector3();
float collisionMargin = reader.ReadSingle();
stream.Position += 4; // m_padding
switch (type)
{
case BroadphaseNativeType.BoxShape:
{
Vector3 boxExtents = implicitShapeDimensions / localScaling + new Vector3(collisionMargin);
BoxShape box = CreateBoxShape(ref boxExtents) as BoxShape;
//box.InitializePolyhedralFeatures();
shape = box;
break;
}
case BroadphaseNativeType.CapsuleShape:
{
Vector3 halfExtents = implicitShapeDimensions + new Vector3(collisionMargin);
int upAxis = reader.ReadInt32();
switch (upAxis)
{
case 0:
shape = CreateCapsuleShapeX(halfExtents.Y, halfExtents.X);
break;
case 1:
shape = CreateCapsuleShapeY(halfExtents.X, halfExtents.Y);
break;
case 2:
shape = CreateCapsuleShapeZ(halfExtents.X, halfExtents.Z);
break;
default:
Console.WriteLine("error: wrong up axis for btCapsuleShape");
break;
}
break;
}
case BroadphaseNativeType.ConeShape:
{
Vector3 halfExtents = implicitShapeDimensions; // + new Vector3(collisionMargin);
int upAxis = reader.ReadInt32();
switch (upAxis)
{
case 0:
shape = CreateConeShapeX(halfExtents.Y, halfExtents.X);
break;
case 1:
shape = CreateConeShapeY(halfExtents.X, halfExtents.Y);
break;
case 2:
shape = CreateConeShapeZ(halfExtents.X, halfExtents.Z);
break;
default:
Console.WriteLine("unknown Cone up axis");
break;
}
break;
}
case BroadphaseNativeType.ConvexHullShape:
{
long unscaledPointsFloatPtr = reader.ReadPtr();
long unscaledPointsDoublePtr = reader.ReadPtr();
int numPoints = reader.ReadInt32();
byte[] points = libPointers[unscaledPointsFloatPtr];
ConvexHullShape hullShape = CreateConvexHullShape();
using (MemoryStream pointStream = new MemoryStream(points, false))
{
using (BulletReader pointReader = new BulletReader(pointStream))
{
for (int i = 0; i < numPoints; i++)
{
hullShape.AddPoint(pointReader.ReadVector3());
}
}
}
hullShape.Margin = collisionMargin;
//hullShape.InitializePolyhedralFeatures();
shape = hullShape;
break;
}
case BroadphaseNativeType.CylinderShape:
{
Vector3 halfExtents = implicitShapeDimensions + new Vector3(collisionMargin);
int upAxis = reader.ReadInt32();
switch (upAxis)
{
case 0:
shape = CreateCylinderShapeX(halfExtents.Y, halfExtents.X);
break;
case 1:
shape = CreateCylinderShapeY(halfExtents.X, halfExtents.Y);
break;
case 2:
shape = CreateCylinderShapeZ(halfExtents.X, halfExtents.Z);
break;
default:
Console.WriteLine("unknown Cylinder up axis");
break;
}
break;
}
case BroadphaseNativeType.MultiSphereShape:
{
long localPositionArrayPtr = reader.ReadPtr();
byte[] localPositionArray = libPointers[localPositionArrayPtr];
int localPositionArraySize = reader.ReadInt32();
Vector3[] positions = new Vector3[localPositionArraySize];
float[] radi = new float[localPositionArraySize];
using (MemoryStream localPositionArrayStream = new MemoryStream(localPositionArray, false))
{
using (BulletReader localPositionArrayReader = new BulletReader(localPositionArrayStream))
{
for (int i = 0; i < localPositionArraySize; i++)
{
positions[i] = localPositionArrayReader.ReadVector3();
radi[i] = localPositionArrayReader.ReadSingle();
}
}
}
shape = CreateMultiSphereShape(positions, radi);
break;
}
}
if (shape != null)
{
shape.LocalScaling = localScaling;
}
break;
}
case BroadphaseNativeType.TriangleMeshShape:
{
TriangleIndexVertexArray meshInterface = CreateMeshInterface(shapeData, TriangleMeshShapeData.Offset("MeshInterface"), libPointers);
if (meshInterface.NumSubParts == 0)
{
return null;
}
OptimizedBvh bvh = null;
long bvhPtr = reader.ReadPtr(TriangleMeshShapeData.Offset("QuantizedFloatBvh"));
if (bvhPtr != 0)
{
if (_bvhMap.ContainsKey(bvhPtr))
{
bvh = _bvhMap[bvhPtr];
}
else
{
bvh = CreateOptimizedBvh();
throw new NotImplementedException();
//bvh.DeserializeFloat(bvhPtr);
}
}
bvhPtr = reader.ReadPtr(TriangleMeshShapeData.Offset("QuantizedDoubleBvh"));
if (bvhPtr != 0)
{
throw new NotImplementedException();
}
BvhTriangleMeshShape trimeshShape = CreateBvhTriangleMeshShape(meshInterface, bvh);
trimeshShape.Margin = reader.ReadSingle(TriangleMeshShapeData.Offset("CollisionMargin"));
shape = trimeshShape;
break;
}
case BroadphaseNativeType.SoftBodyShape:
return null;
default:
#if DEBUG
Console.WriteLine("Unsupported shape type ({0})\n", type);
#endif
throw new NotImplementedException();
}
reader.Dispose();
stream.Dispose();
return shape;
}
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;
}
protected void ConvertRigidBodyFloat(byte[] bodyData, Dictionary<long, byte[]> libPointers)
{
MemoryStream stream = new MemoryStream(bodyData, false);
BulletReader reader = new BulletReader(stream);
int cod = RigidBodyFloatData.Offset("CollisionObjectData");
long collisionShapePtr = reader.ReadPtr(cod + CollisionObjectFloatData.Offset("CollisionShape"));
Matrix startTransform = reader.ReadMatrix(cod + CollisionObjectFloatData.Offset("WorldTransform"));
float inverseMass = reader.ReadSingle(RigidBodyFloatData.Offset("InverseMass"));
long namePtr = reader.ReadPtr(CollisionObjectFloatData.Offset("Name"));
float mass = inverseMass.Equals(0) ? 0 : 1.0f / inverseMass;
CollisionShape shape = _shapeMap[collisionShapePtr];
if (shape.IsNonMoving)
{
mass = 0.0f;
}
bool isDynamic;
Vector3 localInertia;
if (mass != 0.0f)
{
isDynamic = true;
shape.CalculateLocalInertia(mass, out localInertia);
}
else
{
isDynamic = false;
localInertia = Vector3.Zero;
}
string name = null;
if (namePtr != 0)
{
byte[] nameData = libPointers[namePtr];
int length = Array.IndexOf(nameData, (byte)0);
name = System.Text.Encoding.ASCII.GetString(nameData, 0, length);
}
RigidBody body = CreateRigidBody(isDynamic, mass, ref startTransform, shape, name);
_bodyMap.Add(bodyData, body);
reader.Dispose();
stream.Dispose();
}
protected void ConvertRigidBodyFloat(byte[] bodyData, Dictionary<long, byte[]> libPointers)
{
long collisionShapePtr, namePtr;
Matrix startTransform;
float inverseMass;
float friction, restitution;
Vector3 angularFactor, linearFactor;
using (var stream = new MemoryStream(bodyData, false))
{
using (var reader = new BulletReader(stream))
{
int cod = RigidBodyFloatData.Offset("CollisionObjectData");
collisionShapePtr = reader.ReadPtr(cod + CollisionObjectFloatData.Offset("CollisionShape"));
startTransform = reader.ReadMatrix(cod + CollisionObjectFloatData.Offset("WorldTransform"));
namePtr = reader.ReadPtr(cod + CollisionObjectFloatData.Offset("Name"));
friction = reader.ReadSingle(cod + CollisionObjectFloatData.Offset("Friction"));
restitution = reader.ReadSingle(cod + CollisionObjectFloatData.Offset("Restitution"));
inverseMass = reader.ReadSingle(RigidBodyFloatData.Offset("InverseMass"));
angularFactor = reader.ReadVector3(RigidBodyFloatData.Offset("AngularFactor"));
linearFactor = reader.ReadVector3(RigidBodyFloatData.Offset("LinearFactor"));
}
}
CollisionShape shape = _shapeMap[collisionShapePtr];
float mass;
bool isDynamic;
if (shape.IsNonMoving)
{
mass = 0.0f;
isDynamic = false;
}
else
{
isDynamic = inverseMass != 0;
mass = isDynamic ? 1.0f / inverseMass : 0;
}
string name = null;
if (namePtr != 0)
{
byte[] nameData = libPointers[namePtr];
int length = Array.IndexOf(nameData, (byte)0);
name = Encoding.ASCII.GetString(nameData, 0, length);
}
RigidBody body = CreateRigidBody(isDynamic, mass, ref startTransform, shape, name);
body.Friction = friction;
body.Restitution = restitution;
body.AngularFactor = angularFactor;
body.LinearFactor = linearFactor;
_bodyMap.Add(bodyData, body);
}
private void Init(BulletReader reader, bool swap)
{
if (swap)
{
throw new NotImplementedException();
}
Stream stream = reader.BaseStream;
reader.ReadTag("SDNA");
// Element names
reader.ReadTag("NAME");
string[] names = reader.ReadStringList();
var nameInfos = names
.Select(n => new NameInfo(n))
.ToArray();
_hasIntType = names.Contains("int");
// Types
reader.ReadTag("TYPE");
string[] typeNames = reader.ReadStringList();
stream.Position = (stream.Position + 3) & ~3;
reader.ReadTag("TLEN");
TypeDecl[] types = typeNames.Select(name =>
{
short length = reader.ReadInt16();
if (_ptrLen == 0 && name == "ListBase")
{
_ptrLen = length / 2;
}
return(new TypeDecl(name, length));
}).ToArray();
stream.Position = (stream.Position + 3) & ~3;
// Structs
reader.ReadTag("STRC");
int numStructs = reader.ReadInt32();
_structs = new StructDecl[numStructs];
_structByTypeName = new Dictionary <string, StructDecl>(numStructs);
for (int i = 0; i < numStructs; i++)
{
short typeIndex = reader.ReadInt16();
TypeDecl structType = types[typeIndex];
int numElements = reader.ReadInt16();
var elements = new ElementDecl[numElements];
for (int j = 0; j < numElements; j++)
{
typeIndex = reader.ReadInt16();
short nameIndex = reader.ReadInt16();
elements[j] = new ElementDecl(types[typeIndex], nameInfos[nameIndex]);
}
var structDecl = new StructDecl(structType, elements);
structType.Struct = structDecl;
_structs[i] = structDecl;
_structByTypeName.Add(structType.Name, structDecl);
}
}
private void AutoSerializeRootLevelChildren(XmlElement parent)
{
foreach (XmlNode node in parent)
{
if (node.NodeType != XmlNodeType.Element)
{
continue;
}
XmlElement element = node as XmlElement;
switch (element.Name)
{
case "btCompoundShapeChildData":
DeSerializeCompoundShapeChildData(element);
continue;
case "btCompoundShapeData":
DeSerializeCompoundShapeData(element);
continue;
case "btConvexHullShapeData":
DeSerializeConvexHullShapeData(element);
continue;
case "btConvexInternalShapeData":
DeSerializeConvexInternalShapeData(element);
continue;
case "btDynamicsWorldFloatData":
DeSerializeDynamicsWorldData(element);
continue;
case "btGeneric6DofConstraintData":
DeSerializeGeneric6DofConstraintData(element);
continue;
case "btRigidBodyFloatData":
DeSerializeRigidBodyFloatData(element);
continue;
case "btStaticPlaneShapeData":
DeSerializeStaticPlaneShapeData(element);
continue;
case "btVector3FloatData":
DeSerializeVector3FloatData(element);
continue;
default:
throw new NotImplementedException();
}
}
foreach (byte[] shapeData in _collisionShapeData)
{
CollisionShape shape = ConvertCollisionShape(shapeData, _pointerLookup);
if (shape != null)
{
foreach (KeyValuePair<long, byte[]> lib in _pointerLookup)
{
if (lib.Value == shapeData)
{
_shapeMap.Add(lib.Key, shape);
break;
}
}
using (var stream = new MemoryStream(shapeData, false))
{
using (var reader = new BulletReader(stream))
{
long namePtr = reader.ReadPtr(CollisionShapeFloatData.Offset("Name"));
if (namePtr != 0)
{
byte[] nameData = _pointerLookup[namePtr];
int length = Array.IndexOf(nameData, (byte)0);
string name = System.Text.Encoding.ASCII.GetString(nameData, 0, length);
_objectNameMap.Add(shape, name);
_nameShapeMap.Add(name, shape);
}
}
}
}
}
foreach (byte[] rbData in _rigidBodyData)
{
ConvertRigidBodyFloat(rbData, _pointerLookup);
}
foreach (byte[] constraintData in _constraintData)
{
//throw new NotImplementedException();
//ConvertConstraint(constraintData);
}
}
private void InitDna()
{
_dnaData = IntPtr.Size == 8 ? GetBulletDna64() : GetBulletDna();
bool swap = !BitConverter.IsLittleEndian;
using (var stream = new MemoryStream(_dnaData))
{
using (var reader = new BulletReader(stream))
{
_dna = Dna.Load(reader, swap);
}
}
}
public static Dna Load(BulletReader dnaReader, bool swap)
{
var dna = new Dna();
dna.Init(dnaReader, swap);
return dna;
}
private void Init(BulletReader reader, bool swap)
{
if (swap)
{
throw new NotImplementedException();
}
Stream stream = reader.BaseStream;
reader.ReadTag("SDNA");
// Element names
reader.ReadTag("NAME");
string[] names = reader.ReadStringList();
var nameInfos = names
.Select(n => new NameInfo(n))
.ToArray();
_hasIntType = names.Contains("int");
// Types
reader.ReadTag("TYPE");
string[] typeNames = reader.ReadStringList();
stream.Position = (stream.Position + 3) & ~3;
reader.ReadTag("TLEN");
TypeDecl[] types = typeNames.Select(name =>
{
short length = reader.ReadInt16();
if (_ptrLen == 0 && name == "ListBase")
{
_ptrLen = length / 2;
}
return new TypeDecl(name, length);
}).ToArray();
stream.Position = (stream.Position + 3) & ~3;
// Structs
reader.ReadTag("STRC");
int numStructs = reader.ReadInt32();
_structs = new StructDecl[numStructs];
_structByTypeName = new Dictionary<string, StructDecl>(numStructs);
for (int i = 0; i < numStructs; i++)
{
short typeIndex = reader.ReadInt16();
TypeDecl structType = types[typeIndex];
int numElements = reader.ReadInt16();
var elements = new ElementDecl[numElements];
for (int j = 0; j < numElements; j++)
{
typeIndex = reader.ReadInt16();
short nameIndex = reader.ReadInt16();
elements[j] = new ElementDecl(types[typeIndex], nameInfos[nameIndex]);
}
var structDecl = new StructDecl(structType, elements);
structType.Struct = structDecl;
_structs[i] = structDecl;
_structByTypeName.Add(structType.Name, structDecl);
}
}
