public Camera(Math.Matrix projection)
{
_orientation = new Gk3Main.Math.Quaternion();
_position = new Gk3Main.Math.Vector3();
_projection = projection;
}
public Layer(uint size, Layer prevLayer = null)
{
Size = size;
NeuronValue = new Math.Matrix <double>(size, 1);
Bias = new Math.Matrix <double>(size, 1);
PrevLayer = prevLayer;
}
public static void LerpToMatrix(float amount,
ref FrameTransformation t1, ref FrameTransformation t2,
out Math.Matrix result)
{
float invAmount = 1.0f - amount;
result = t1._original;
// TODO: right now we're doing a naive interpolation,
// which will work, but doesn't look as good as breaking
// apart the matrix into components (rotation, scale, translation)
// and interpolating the individual components with lerp/slerp
result.M11 = t1._original.M11 * invAmount + t2._original.M11 * amount;
result.M12 = t1._original.M12 * invAmount + t2._original.M12 * amount;
result.M13 = t1._original.M13 * invAmount + t2._original.M13 * amount;
result.M14 = t1._original.M14 * invAmount + t2._original.M14 * amount;
result.M21 = t1._original.M21 * invAmount + t2._original.M21 * amount;
result.M22 = t1._original.M22 * invAmount + t2._original.M22 * amount;
result.M23 = t1._original.M23 * invAmount + t2._original.M23 * amount;
result.M24 = t1._original.M24 * invAmount + t2._original.M24 * amount;
result.M31 = t1._original.M31 * invAmount + t2._original.M31 * amount;
result.M32 = t1._original.M32 * invAmount + t2._original.M32 * amount;
result.M33 = t1._original.M33 * invAmount + t2._original.M33 * amount;
result.M34 = t1._original.M34 * invAmount + t2._original.M34 * amount;
result.M41 = t1._translation.X * invAmount + t2._translation.X * amount;
result.M42 = t1._translation.Y * invAmount + t2._translation.Y * amount;
result.M43 = t1._translation.Z * invAmount + t2._translation.Z * amount;
}
/// <summary>
/// "Batched" version of RenderAt(). This version is much faster, but
/// it must be called between BeginBatchRender() and EndBatchRender().
/// </summary>
public void RenderAtBatch(Math.Vector3 position, float angle, Camera camera)
{
if (!_loaded)
{
return;
}
Math.Matrix world = Math.Matrix.RotateY(angle)
* Math.Matrix.Translate(position);
foreach (ModMesh mesh in _meshes)
{
Math.Matrix worldview;
if (mesh.AnimatedTransformMatrix.HasValue)
{
if (mesh.AnimatedTransformIsAbsolute)
{
worldview = mesh.AnimatedTransformMatrix.Value * TempTransform * camera.ViewProjection;
}
else
{
worldview = mesh.AnimatedTransformMatrix.Value * world * camera.ViewProjection;
}
}
else
{
worldview = mesh.TransformMatrix * world * camera.ViewProjection;
}
_effect.SetParameter("ModelViewProjection", worldview);
foreach (ModMeshSection section in mesh.sections)
{
_effect.SetParameter("Diffuse", section.textureResource, 0);
_effect.CommitParams();
VertexBuffer vertices;
if (section.AnimatedVertices != null)
{
section.AnimatedVertexBuffer.SetData(section.AnimatedVertices, 0, (int)section.numVerts * _elements.Stride / 4);
vertices = section.AnimatedVertexBuffer;
}
else
{
vertices = section.vertexBuffer;
}
RendererManager.CurrentRenderer.SetVertexBuffer(vertices);
RendererManager.CurrentRenderer.Indices = section.indexBuffer;
RendererManager.CurrentRenderer.DrawIndexed(PrimitiveType.Triangles, 0, 0, vertices.NumVertices, 0, section.indices.Length);
}
}
}
public Frustum(Math.Matrix modelViewProjection)
{
// need this to make the compiler happy
_near = new Math.Vector4();
_far = new Math.Vector4();
_right = new Math.Vector4();
_left = new Math.Vector4();
_bottom = new Math.Vector4();
_top = new Math.Vector4();
Build(modelViewProjection);
}
public AxisAlignedBoundingBox Transform(Math.Matrix transform)
{
Math.Vector3 transformedBBMin = transform * Min;
Math.Vector3 transformedBBMax = transform * Max;
AxisAlignedBoundingBox newBBox = new AxisAlignedBoundingBox();
newBBox.Min.X = System.Math.Min(transformedBBMin.X, transformedBBMax.X);
newBBox.Min.Y = System.Math.Min(transformedBBMin.Y, transformedBBMax.Y);
newBBox.Min.Z = System.Math.Min(transformedBBMin.Z, transformedBBMax.Z);
newBBox.Max.X = System.Math.Max(transformedBBMin.X, transformedBBMax.X);
newBBox.Max.Y = System.Math.Max(transformedBBMin.Y, transformedBBMax.Y);
newBBox.Max.Z = System.Math.Max(transformedBBMin.Z, transformedBBMax.Z);
return(newBBox);
}
public void Train(double[] inputs, double[] answersArray)
{
var output = Predict(inputs);
var answers = new Math.Matrix <double>();
answers = answers.FromArray(answersArray);
//Error
var error = answers - output;
//hidden error
var gradient = Matrix <double> .Map(output, Dsigmoid);
gradient.HadamardProduct(error);
gradient *= LearningRate;
var hidden_wt_delta = Matrix <double> .Multiply(gradient, Matrix <double> .Transpose(Layers[Layers.Count - 2].NeuronValue));
Layers[Layers.Count - 2].Weights += hidden_wt_delta;
Layers[Layers.Count - 1].Bias += gradient;
//Layers[Layers.Count-2].Weights.Print();
var prevError = error;
for (int i = Layers.Count - 2; i > 0; i--)
{
var hidden_error = Matrix <double> .Multiply(Matrix <double> .Transpose(Layers[i].Weights), prevError);
prevError = hidden_error;
gradient = Matrix <double> .Map(Layers[i].NeuronValue, Dsigmoid);
gradient.HadamardProduct(hidden_error);
gradient *= LearningRate;
hidden_wt_delta = Matrix <double> .Multiply(gradient, Matrix <double> .Transpose(Layers[i - 1].NeuronValue));
Layers[i - 1].Weights += hidden_wt_delta;
Layers[i].Bias += gradient;
}
}
public void Render(Camera camera, Math.Matrix world)
{
if (_vertices == null)
{
createVertices();
}
Math.Matrix modelViewProjection = world * camera.ViewProjection;
_effect.Bind();
_effect.SetParameter("ModelViewProjection", modelViewProjection);
_effect.Begin();
//RendererManager.CurrentRenderer.RenderIndices(PrimitiveType.Lines, 0, 8, _indices, _vertices, _declaration);
//RendererManager.CurrentRenderer.RenderPrimitives(PrimitiveType.Lines, 0, 8, _vertices);
//RendererManager.CurrentRenderer.RenderPrimitives(PrimitiveType.Lines, 8, 8, _vertices);
_effect.End();
}
public Math.Vector3 Unproject(Math.Vector3 source,
ref Math.Matrix projection, ref Math.Matrix view, ref Math.Matrix world)
{
Math.Vector4 result;
result.X = ((source.X - X) * 2 / Width) - 1;
result.Y = 1 - ((source.Y - Y) * 2 / Height);
result.Z = source.Z;
result.W = 1.0f;
Math.Matrix invProj, invView, invWorld;
Math.Matrix.Invert(ref projection, out invProj);
Math.Matrix.Invert(ref view, out invView);
Math.Matrix.Invert(ref world, out invWorld);
result = invProj * result;
result = invView * result;
result = invWorld * result;
result = result / result.W;
return(new Math.Vector3(result.X, result.Y, result.Z));
}
public void Render(Camera camera)
{
if (SceneManager.CurrentFilterMode == TextureFilterMode.None)
{
RendererManager.CurrentRenderer.SamplerStates[0] = SamplerState.PointClamp;
RendererManager.CurrentRenderer.SamplerStates[1] = SamplerState.PointClamp;
}
else
{
RendererManager.CurrentRenderer.SamplerStates[0] = SamplerState.LinearClamp;
RendererManager.CurrentRenderer.SamplerStates[1] = SamplerState.LinearClamp;
}
RendererManager.CurrentRenderer.DepthTestEnabled = false;
RendererManager.CurrentRenderer.SetVertexBuffer(_vertices);
RendererManager.CurrentRenderer.Indices = _indices;
_skyboxEffect.Bind();
_skyboxEffect.SetParameter("Diffuse", _cubeMap, 0);
Math.Matrix modelViewProjection = Math.Matrix.RotateY(_azimuth) * Math.Matrix.Translate(camera.Position.X, camera.Position.Y, camera.Position.Z) * camera.View * camera.Projection;
_skyboxEffect.SetParameter("ModelViewProjection", modelViewProjection);
_skyboxEffect.Begin();
Graphics.RendererManager.CurrentRenderer.DrawIndexed(PrimitiveType.Triangles, 0, 0, _vertices.NumVertices, 0, _indices.Length);
_skyboxEffect.End();
if (_sun != null)
{
BillboardManager.AddBillboard(camera.Position + -_sunDirection * 500.0f, 100.0f, 100.0f, _sun, _sunMask);
BillboardManager.RenderBillboardsWithAlpha(camera);
}
RendererManager.CurrentRenderer.DepthTestEnabled = true;
}
public void CreateBillboardMatrix(Math.Vector3 position, bool includePosition, out Math.Matrix matrix)
{
matrix = Math.Matrix.Translate(-position) *
Math.Matrix.RotateY(CalcYaw()) *
Math.Matrix.Translate(position);
}
public Math.Vector3 Unproject(Math.Vector3 v)
{
Math.Matrix world = Math.Matrix.Identity;
return(RendererManager.CurrentRenderer.Viewport.Unproject(v, ref _projection, ref _modelView, ref world));
}
/// <summary>
/// "Batched" version of Render(). This version is much faster, but
/// it must be called between BeginBatchRender() and EndBatchRender().
/// </summary>
public void RenderBatch(Camera camera, Math.Matrix?transform)
{
if (!_isBillboard)
{
Math.Matrix worldViewProjection = (transform.HasValue ? transform.Value * camera.ViewProjection : camera.ViewProjection);
//Math.Matrix worldViewProjection = camera.ViewProjection;
foreach (ModMesh mesh in _meshes)
{
Math.Matrix worldview;
if (mesh.AnimatedTransformMatrix.HasValue)
{
worldview = mesh.AnimatedTransformMatrix.Value * worldViewProjection;
}
else
{
worldview = mesh.TransformMatrix * worldViewProjection;
}
_effect.SetParameter("ModelViewProjection", worldview);
foreach (ModMeshSection section in mesh.sections)
{
_effect.SetParameter("Diffuse", section.textureResource, 0);
_effect.SetParameter("Color", section.color);
_effect.CommitParams();
RendererManager.CurrentRenderer.SetVertexBuffer(section.vertexBuffer);
RendererManager.CurrentRenderer.Indices = section.indexBuffer;
RendererManager.CurrentRenderer.DrawIndexed(PrimitiveType.Triangles, 0, 0, section.vertexBuffer.NumVertices, 0, section.indices.Length);
}
}
}
else
{
// render the model as a billboard
for (int i = 0; i < _meshes.Length; i++)
{
Math.Vector3 meshPosition;
if (_useBillboardCenter)
{
meshPosition = _billboardCenter;
}
else
{
meshPosition = _meshes[i].OriginalBoundingBox.Center;
}
Math.Matrix billboardMatrix;
camera.CreateBillboardMatrix(meshPosition, true, out billboardMatrix);
_effect.SetParameter("ModelViewProjection", billboardMatrix * _meshes[i].TransformMatrix * camera.ViewProjection);
foreach (ModMeshSection section in _meshes[i].sections)
{
_effect.SetParameter("Diffuse", section.textureResource, 0);
_effect.CommitParams();
RendererManager.CurrentRenderer.SetVertexBuffer(section.vertexBuffer);
RendererManager.CurrentRenderer.Indices = section.indexBuffer;
RendererManager.CurrentRenderer.DrawIndexed(PrimitiveType.Triangles, 0, 0, section.vertexBuffer.NumVertices, 0, section.indices.Length);
}
}
}
}
public void SetTransform(Math.Matrix transform)
{
AnimatedTransformMatrix = transform;
UpdatedBoundingBox = OriginalBoundingBox.Transform(transform);
}
public void Build(Math.Matrix modelViewProjection)
{
_right.X = modelViewProjection.M14 - modelViewProjection.M11;
_right.Y = modelViewProjection.M24 - modelViewProjection.M21;
_right.Z = modelViewProjection.M34 - modelViewProjection.M31;
_right.W = modelViewProjection.M44 - modelViewProjection.M41;
float len = (float)System.Math.Sqrt(_right.X * _right.X + _right.Y * _right.Y + _right.Z * _right.Z);
_right.X /= len;
_right.Y /= len;
_right.Z /= len;
_right.W /= len;
_left.X = modelViewProjection.M14 + modelViewProjection.M11;
_left.Y = modelViewProjection.M24 + modelViewProjection.M21;
_left.Z = modelViewProjection.M34 + modelViewProjection.M31;
_left.W = modelViewProjection.M44 + modelViewProjection.M41;
len = (float)System.Math.Sqrt(_left.X * _left.X + _left.Y * _left.Y + _left.Z * _left.Z);
_left.X /= len;
_left.Y /= len;
_left.Z /= len;
_left.W /= len;
_bottom.X = modelViewProjection.M14 + modelViewProjection.M12;
_bottom.Y = modelViewProjection.M24 + modelViewProjection.M22;
_bottom.Z = modelViewProjection.M34 + modelViewProjection.M32;
_bottom.W = modelViewProjection.M44 + modelViewProjection.M42;
len = (float)System.Math.Sqrt(_bottom.X * _bottom.X + _bottom.Y * _bottom.Y + _bottom.Z * _bottom.Z);
_bottom.X /= len;
_bottom.Y /= len;
_bottom.Z /= len;
_bottom.W /= len;
_top.X = modelViewProjection.M14 - modelViewProjection.M12;
_top.Y = modelViewProjection.M24 - modelViewProjection.M22;
_top.Z = modelViewProjection.M34 - modelViewProjection.M32;
_top.W = modelViewProjection.M44 - modelViewProjection.M42;
len = (float)System.Math.Sqrt(_top.X * _top.X + _top.Y * _top.Y + _top.Z * _top.Z);
_top.X /= len;
_top.Y /= len;
_top.Z /= len;
_top.W /= len;
_near.X = modelViewProjection.M13;
_near.Y = modelViewProjection.M23;
_near.Z = modelViewProjection.M33;
_near.W = modelViewProjection.M43;
len = (float)System.Math.Sqrt(_near.X * _near.X + _near.Y * _near.Y + _near.Z * _near.Z);
_near.X /= len;
_near.Y /= len;
_near.Z /= len;
_near.W /= len;
_far.X = modelViewProjection.M14 - modelViewProjection.M13;
_far.Y = modelViewProjection.M24 - modelViewProjection.M23;
_far.Z = modelViewProjection.M34 - modelViewProjection.M33;
_far.W = modelViewProjection.M44 - modelViewProjection.M43;
len = (float)System.Math.Sqrt(_far.X * _far.X + _far.Y * _far.Y + _far.Z * _far.Z);
_far.X /= len;
_far.Y /= len;
_far.Z /= len;
_far.W /= len;
}
private void play(int timeSinceStart, int duration)
{
int startIndex, count;
// play model visibility
if (_modelVisibilitySection != null)
{
GetAllFramesSince(_modelVisibilitySection, timeSinceStart, duration, MillisecondsPerFrame,
out startIndex, out count);
for (int i = startIndex; i < startIndex + count; i++)
{
string model = _modelVisibilitySection.Lines[i].Params[0].StringValue;
string onoff = _modelVisibilitySection.Lines[i].Params[1].StringValue;
bool visible = onoff.Equals("on", StringComparison.OrdinalIgnoreCase);
SceneManager.SetSceneModelVisibility(model, visible);
}
}
if (_modelTexturesSection != null)
{
GetAllFramesSince(_modelTexturesSection, timeSinceStart, duration, MillisecondsPerFrame,
out startIndex, out count);
for (int i = startIndex; i < startIndex + count; i++)
{
string model = _modelTexturesSection.Lines[i].Params[0].StringValue;
int meshIndex = _modelTexturesSection.Lines[i].Params[1].IntValue;
int groupIndex = _modelTexturesSection.Lines[i].Params[2].IntValue;
string texture = _modelTexturesSection.Lines[i].Params[3].StringValue;
SceneManager.SetModelTexture(model, meshIndex, groupIndex, texture);
}
}
// play sounds
if (_soundSection != null)
{
GetAllFramesSince(_soundSection, timeSinceStart, duration, MillisecondsPerFrame,
out startIndex, out count);
for (int i = startIndex; i < startIndex + count; i++)
{
// the indices in the little sound list *should* match "i"
Sound.SoundManager.PlaySound2DToChannel(_sounds[i], Sound.SoundTrackChannel.SFX);
}
}
// play the dialog
if (_gk3Section != null)
{
GetAllFramesSince(_gk3Section, timeSinceStart, duration, MillisecondsPerFrame,
out startIndex, out count);
for (int i = startIndex; i < startIndex + count; i++)
{
string command = _gk3Section.Lines[i].Params[0].StringValue;
if (command.Equals("DIALOGUE", StringComparison.OrdinalIgnoreCase))
{
string yak = _gk3Section.Lines[i].Params[1].StringValue;
DialogManager.PlayDialogue(yak, 1, yak.StartsWith("E", StringComparison.OrdinalIgnoreCase), false);
}
else if (command.Equals("LIPSYNCH", StringComparison.OrdinalIgnoreCase))
{
string param2 = _gk3Section.Lines[i].Params[1].StringValue;
Actor actor = SceneManager.GetActor(param2);
if (actor == null)
{
continue; // couldn't find this actor for some reason, so give up
}
string param3 = _gk3Section.Lines[i].Params[2].StringValue;
actor.SetMouth(param3);
}
}
}
// add any new ACT files
if (_actionSection != null)
{
GetAllFramesSince(_actionSection, timeSinceStart, duration, MillisecondsPerFrame,
out startIndex, out count);
for (int i = startIndex; i < startIndex + count; i++)
{
string actName = _actionSection.Lines[i].Params[0].StringValue;
if (actName.Length > 31)
{
actName = actName.Substring(0, 31); // we can get FileNotFound without this
}
if (actName.EndsWith(".ACT", StringComparison.OrdinalIgnoreCase) == false)
{
actName += ".ACT";
}
MomAct act = new MomAct();
act.Act = _content.Load <Graphics.ActResource>(actName);
act.Model = SceneManager.GetSceneModel(act.Act.ModelName);
// check if this is an absolute animation or contains a transformation
if (_actionSection.Lines[i].Params.Count > 1)
{
act.IsAbsolute = true;
Math.Matrix transform = Math.Matrix.Translate(-_actionSection.Lines[i].Params[1].FloatValue,
-_actionSection.Lines[i].Params[3].FloatValue,
-_actionSection.Lines[i].Params[2].FloatValue);
transform = transform * Math.Matrix.RotateY(Utils.DegreesToRadians(-_actionSection.Lines[i].Params[4].FloatValue + _actionSection.Lines[i].Params[8].FloatValue));
transform = transform * Math.Matrix.Translate(_actionSection.Lines[i].Params[5].FloatValue,
_actionSection.Lines[i].Params[7].FloatValue,
_actionSection.Lines[i].Params[6].FloatValue);
act.Transformation = transform;
}
else
{
act.Transformation = Math.Matrix.Identity;
}
if (act.Model == null)
{
continue;
}
// add the act file to the list
bool added = false;
for (int j = 0; j < _acts.Count; j++)
{
if (_acts[j].HasValue == false)
{
_acts[j] = act;
added = true;
break;
}
}
if (added == false)
{
_acts.Add(act);
}
}
}
// animate models using ACT files
for (int i = 0; i < _acts.Count; i++)
{
if (_acts[i].HasValue)
{
_acts[i].Value.Model.TempTransform = _acts[i].Value.Transformation;
if (_acts[i].Value.Act.Animate(_acts[i].Value.Model, timeSinceStart, duration, true, _acts[i].Value.IsAbsolute) == false)
{
_acts[i] = null;
}
}
}
}
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 abstract void SetParameter(string name, Math.Matrix parameter);
