public BasicTankEntity(Game game, Model model, AbstractSphereEntity target)
: base(game)
{
this.tankModel = model;
this._target = target;
this.Scale = 0.001f;
// Sweden
geoLatitude = 57;
geoLongitude = 14;
// Look up shortcut references to the bones we are going to animate.
leftBackWheelBone = tankModel.Bones["l_back_wheel_geo"];
rightBackWheelBone = tankModel.Bones["r_back_wheel_geo"];
leftFrontWheelBone = tankModel.Bones["l_front_wheel_geo"];
rightFrontWheelBone = tankModel.Bones["r_front_wheel_geo"];
leftSteerBone = tankModel.Bones["l_steer_geo"];
rightSteerBone = tankModel.Bones["r_steer_geo"];
turretBone = tankModel.Bones["turret_geo"];
cannonBone = tankModel.Bones["canon_geo"];
hatchBone = tankModel.Bones["hatch_geo"];
// Store the original transform matrix for each animating bone.
leftBackWheelTransform = leftBackWheelBone.Transform;
rightBackWheelTransform = rightBackWheelBone.Transform;
leftFrontWheelTransform = leftFrontWheelBone.Transform;
rightFrontWheelTransform = rightFrontWheelBone.Transform;
leftSteerTransform = leftSteerBone.Transform;
rightSteerTransform = rightSteerBone.Transform;
turretTransform = turretBone.Transform;
cannonTransform = cannonBone.Transform;
hatchTransform = hatchBone.Transform;
// Allocate the transform matrix array.
boneTransforms = new Matrix[tankModel.Bones.Count];
}
public NPC2(Model model, Tank destination)
: base(model)
{
#region boneyard
turretBone = model.Bones["turret_geo"];
cannonBone = model.Bones["canon_geo"];
hatchBone = model.Bones["hatch_geo"];
lFrontWBone = model.Bones["l_front_wheel_geo"];
rFrontWBone = model.Bones["r_front_wheel_geo"];
lSteer = model.Bones["l_steer_geo"];
rSteer = model.Bones["r_steer_geo"];
lBackWBone = model.Bones["l_back_wheel_geo"];
rBackWBone = model.Bones["r_back_wheel_geo"];
tankBone = model.Bones["tank_geo"];
#endregion
#region boneTransform
if (turretBone != null) turretTransform = turretBone.Transform;
if (lFrontWBone != null) lFrontTransform = lFrontWBone.Transform;
if (rFrontWBone != null) rFrontTransform = rFrontWBone.Transform;
if (lBackWBone != null) lBackTransform = lBackWBone.Transform;
if (rBackWBone != null) rBackTransform = rBackWBone.Transform;
#endregion
tank = destination;
translation *= Matrix.CreateTranslation(0, 0, -1200);
distant = distance + 20;
}
public Tank(Model model, GraphicsDevice device, Camera camera, GraphicsDeviceManager graphics, String name)
: base(model)
{
this.name = name;
graphicsDeviceManager = graphics;
mousePick = new MousePick(device, camera);
boneTransforms = new Matrix[model.Bones.Count];
// references to bones to animate
turretBone = model.Bones["turret_geo"];
leftBackWheelBone = model.Bones["l_back_wheel_geo"];
rightBackWheelBone = model.Bones["r_back_wheel_geo"];
leftFrontWheelBone = model.Bones["l_front_wheel_geo"];
rightFrontWheelBone = model.Bones["r_front_wheel_geo"];
cannonBone = model.Bones["canon_geo"];
// store the original transform matrix, otherwise animations on rotations will be all wonky
turretTransform = turretBone.Transform;
leftBackWheelTransform = leftBackWheelBone.Transform;
rightBackWheelTransform = rightBackWheelBone.Transform;
leftFrontWheelTransform = leftFrontWheelBone.Transform;
rightFrontWheelTransform = rightFrontWheelBone.Transform;
cannonTransform = cannonBone.Transform;
health = maxHealth;
}
/// <summary>
/// Copies bone transforms relative to all parent bones of the each bone from this model to a given array.
/// </summary>
/// <param name="destinationBoneTransforms">The array receiving the transformed bones.</param>
public void CopyAbsoluteBoneTransformsTo(Matrix[] destinationBoneTransforms)
{
if (destinationBoneTransforms == null)
{
throw new ArgumentNullException("destinationBoneTransforms");
}
if (destinationBoneTransforms.Length < Bones.Count)
{
throw new ArgumentOutOfRangeException("destinationBoneTransforms");
}
int count = Bones.Count;
for (int index1 = 0; index1 < count; index1 += 1)
{
ModelBone modelBone = Bones[index1];
if (modelBone.Parent == null)
{
destinationBoneTransforms[index1] = modelBone.Transform;
}
else
{
int index2 = modelBone.Parent.Index;
Matrix modelBoneTransform = modelBone.Transform;
Matrix.Multiply(
ref modelBoneTransform,
ref destinationBoneTransforms[index2],
out destinationBoneTransforms[index1]
);
}
}
}
public SentryModel(Sentry sentry, Game1 game)
: base()
{
this.sentry = sentry;
this.game = game;
pos = sentry.pos;
scale = new Vector3(0.2f);
model = ModelLibrary.sentry;
bodyTex = TextureManager.sentryBod;
visorTex = TextureManager.sEye3;
ant = model.Bones["anten"];
topCap = model.Bones["topCap"];
visor = model.Bones["visor"];
midCap = model.Bones["midCap"];
canRot = model.Bones["cannonRound"];
cannon = model.Bones["cannon"];
botCap = model.Bones["botCap"];
topOffset = Vector3.Zero;
tiltRot = 0;
spinRot = 0;
}
public Tank(WarZGame game, Model model)
: base(game, model)
{
WZGame = game;
// _scale /= 300;
_model.Root.Transform *= Matrix.CreateScale(Vector3.One / 300);
_model.Root.Transform *= Matrix.CreateRotationY(MathHelper.Pi);
_boneTransforms = new Matrix[_model.Bones.Count];
_model.CopyAbsoluteBoneTransformsTo(_boneTransforms);
LoadBoundingSphere();
leftBackWheelBone = model.Bones["l_back_wheel_geo"];
rightBackWheelBone = model.Bones["r_back_wheel_geo"];
leftFrontWheelBone = model.Bones["l_front_wheel_geo"];
rightFrontWheelBone = model.Bones["r_front_wheel_geo"];
turretBone = model.Bones["turret_geo"];
canonBone = model.Bones["canon_geo"];
leftBackWheelTransform = leftBackWheelBone.Transform;
rightBackWheelTransform = rightBackWheelBone.Transform;
leftFrontWheelTransform = leftFrontWheelBone.Transform;
rightFrontWheelTransform = rightFrontWheelBone.Transform;
turretTransform = turretBone.Transform;
canonTransform = turretBone.Transform;
_specularColor_original = ((BasicEffect)(_model.Meshes[0].Effects[0])).SpecularColor;
_specularColor_red = Color.Red.ToVector3();
}
private void ReadBones(ContentReader input)
{
ModelBone[] bones = new ModelBone[input.ReadInt32()];
for (int i = 0; i < bones.Length; i++)
{
string name = input.ReadObject<string>();
Matrix transform = input.ReadMatrix();
bones[i] = new ModelBone(i, name, transform);
}
this.bones = new ModelBoneCollection(bones);
foreach (ModelBone bone in bones)
{
ModelBone newParent = this.ReadBoneReference(input);
int size = input.ReadInt32();
ModelBone[] newChildren = new ModelBone[size];
for (int j = 0; j < size; j++)
{
newChildren[j] = this.ReadBoneReference(input);
}
bone.SetParentChildren(newParent, newChildren);
}
}
/// <summary>
/// Gets the transform to move a mesh to its exported origin.
/// </summary>
/// <param name="bone">The mesh's 'ParentBone'.</param>
/// <param name="startBone">The bone to call GetTransform() on after world transform has been applied.</param>
/// <returns>The matrix to move the mesh to its origin.</returns>
public static Matrix GetOriginTransform( ModelBone bone, out ModelBone startBone )
{
startBone = bone.Parent;
if ( bone.Parent != null && bone.Parent.Name == "" )
return ( bone.Transform * GetOriginTransform( bone.Parent, out startBone ) );
return bone.Transform;
}
public Tank1(Model model, GraphicsDevice device, Camera camera)
: base(model)
{
mousePick = new MousePicking(device, camera);
//载入模型
turretBone = model.Bones["turret_geo"];
canonBone = model.Bones["canon_geo"];
lbackwheelBone = model.Bones["l_back_wheel_geo"];
rbackwheelBone = model.Bones["r_back_wheel_geo"];
lfrontwheelBone = model.Bones["l_front_wheel_geo"];
rfrontwheelBone = model.Bones["r_front_wheel_geo"];
lsteergeoBone = model.Bones["l_steer_geo"];
rsteergeoBone = model.Bones["r_steer_geo"];
hatchgeo = model.Bones["hatch_geo"];
//赋值给每个部件的变换
leftBackWheelTransform = lbackwheelBone.Transform;
rightBackWheelTransform = rbackwheelBone.Transform;
leftFrontWheelTransform = lfrontwheelBone.Transform;
rightFrontWheelTransform = rfrontwheelBone.Transform;
leftSteerTransform = lsteergeoBone.Transform;
rightSteerTransform = rsteergeoBone.Transform;
turretTransform = turretBone.Transform;
hatchTransform = hatchgeo.Transform;
canonTransform = canonBone.Transform;
}
public StationModel(Model model, Vector3 pos, float rotation, float scale)
: base(model, pos, rotation, scale)
{
this.model = model;
this.pos = pos;
pos.Y = 0;
this.rot = rot;
this.scale = new Vector3(scale, scale, scale);
tex = TextureManager.station1;
try
{
cog1 = this.model.Bones["cog1"];
cog1trans = cog1.Transform.Translation;
}
catch (KeyNotFoundException) { }
try
{
cog2 = this.model.Bones["cog2"];
cog2trans = cog2.Transform.Translation;
}
catch (KeyNotFoundException)
{
}
}
//Y axis rotation (for turret)
public void rotateY(ModelBone bone, Matrix tr, float rotation)
{
Vector3 oringalTrans = tr.Translation;
bone.Transform *= Matrix.CreateRotationY(rotation);
Vector3 newTrans = bone.Transform.Translation;
bone.Transform *= Matrix.CreateTranslation(oringalTrans - newTrans);
}
public Tank(Model model,GraphicsDevice device,Camera camera)
: base(model)
{
mousepick = new MousePick(device, camera);
turretBone = model.Bones["turret_geo"];
rightfrontwheel = model.Bones["r_front_wheel_geo"];
rightbackwheel = model.Bones["r_back_wheel_geo"];
leftfrontwheel = model.Bones["l_front_wheel_geo"];
leftbackwheel = model.Bones["l_back_wheel_geo"];
rightsteergeo = model.Bones["r_steer_geo"];
leftsteergeo = model.Bones["l_steer_geo"];
hatchgeo = model.Bones["hatch_geo"];
canongeo = model.Bones["canon_geo"];
leftBackWheelTransform = leftbackwheel.Transform;
rightBackWheelTransform = rightbackwheel.Transform;
leftFrontWheelTransform = leftfrontwheel.Transform;
rightFrontWheelTransform = rightfrontwheel.Transform;
leftSteerTransform = leftsteergeo.Transform;
rightSteerTransform = rightsteergeo.Transform;
turretTransform = turretBone.Transform;
hatchTransform = hatchgeo.Transform;
canonTransform = canongeo.Transform;
currentAngle = MathHelper.PiOver2;
currentPosition = new Vector3(0, 0, 0);
tankBox = new BoundingBox(MIN, MAX);
}
private void BuildHierarchy(ModelBone node, Matrix parentTransform, int level)
{
node.ModelTransform = node.Transform * parentTransform;
foreach (ModelBone node1 in (ReadOnlyCollection <ModelBone>)node.Children)
{
this.BuildHierarchy(node1, node.ModelTransform, level + 1);
}
}
private void BuildHierarchy(ModelBone node, Matrix parentTransform, int level)
{
node.ModelTransform = node.Transform * parentTransform;
foreach (ModelBone node1 in (ReadOnlyCollection<ModelBone>) node.Children)
this.BuildHierarchy(node1, node.ModelTransform, level + 1);
string str = string.Empty;
for (int index = 0; index < level; ++index)
str = str + "\t";
}
public static void GetModelMeshTransform( ModelBone bone, ref Matrix mat ) {
if( bone.Parent == null ) {
mat = bone.Transform;
} else {
GetModelMeshTransform( bone.Parent, ref mat );
mat = bone.Transform * mat;
}
}
private void BuildHierarchy(ModelBone node, Matrix parentTransform, int level)
{
node.ModelTransform = node.Transform * parentTransform;
foreach (ModelBone child in node.Children)
{
BuildHierarchy(child, node.ModelTransform, level + 1);
}
}
//SoundEffect soundFx;
//SoundEffectInstance music;
//SoundEffectInstance soundEffect;
public Tank(Model model, GraphicsDevice device, camera camera)
: base(model)
{
MousePick = new MousePick(device, camera);
turretBone = model.Bones["turret_geo"];
rightFrontWheel = model.Bones["r_front_wheel_geo"];
leftFrontWheel = model.Bones["l_front_wheel_geo"];
rightRearWheel = model.Bones["r_back_wheel_geo"];
leftRearWheel = model.Bones["l_back_wheel_geo"];
}
public Snowplow(ContentManager content, GraphicsDevice device, Vector3 position)
{
this.device = device;
_model = content.Load<Model>("snowplow");
_position = position;
_rotation = 0.0f;
containerBone = _model.Bones["Cube.013"];
containerTransform = containerBone.Transform;
}
public Tank(Model model, GraphicsDevice device, Camera camera)
: base(model)
{
mousePick = new MousePick(device, camera);
turretBone = model.Bones["turret_geo"];
wheels = new ModelBone[4];
wheels[0] = model.Bones["r_front_wheel_geo"];
wheels[1] = model.Bones["r_back_wheel_geo"];
wheels[2] = model.Bones["l_front_wheel_geo"];
wheels[3] = model.Bones["l_back_wheel_geo"];
speed = 10f;
}
public Flag(Model _model, Vector3 _position)
: base(_model, _position)
{
SpawnPosition = _position;
Hidden = true;
VrotationAngle = (float)Math.PI;
TrotationAngle = 0f;
VBone = _model.Bones["FlagV"];
TBone = _model.Bones["FlagT"];
VT = VBone.Transform;
TT = TBone.Transform;
emitting = true;
}
private void BuildHierarchy(ModelBone node, Matrix parentTransform, int level)
{
node.ModelTransform = node.Transform * parentTransform;
foreach (ModelBone node1 in (ReadOnlyCollection <ModelBone>)node.Children)
{
this.BuildHierarchy(node1, node.ModelTransform, level + 1);
}
string str = string.Empty;
for (int index = 0; index < level; ++index)
{
str = str + "\t";
}
}
public FleeTank(Model model, GraphicsDevice device, Camera camera, Vector3 position, int tankID)
: base(model)
{
mousePick = new MousePick(device, camera);
npcTankID = tankID;
//position = new Vector3(100, 0, -100); //enemy tank's spawn position
this.position = position;
currentVelocity = Vector3.Normalize(new Vector3(0, 0, 1)); //enemy tank is facing vector3(0,0,1) when it spawn, this is initial velocity
turretBone = model.Bones["turret_geo"];
backWheelBone = model.Bones["r_back_wheel_geo"];
//9-11 patrol
RandomPatrolPoint();
translation = Matrix.CreateTranslation(position);
}
private void BuildHierarchy(ModelBone node, Matrix parentTransform, int level)
{
node.ModelTransform = node.Transform * parentTransform;
foreach (var child in node.Children)
{
BuildHierarchy(child, node.ModelTransform, level + 1);
}
//string s = string.Empty;
//
//for (int i = 0; i < level; i++)
//{
// s += "\t";
//}
//
//Debug.WriteLine("{0}:{1}", s, node.Name);
}
private void BuildHierarchy(ModelBone node, Matrix parentTransform, int level)
{
node.ModelTransform = node.Transform * parentTransform;
foreach (var child in node.Children)
{
BuildHierarchy(child, node.ModelTransform, level + 1);
}
//string s = string.Empty;
//
//for (int i = 0; i < level; i++)
//{
// s += "\t";
//}
//
//Debug.WriteLine("{0}:{1}", s, node.Name);
}
internal ModelMesh(string name, ModelBone parentBone, BoundingSphere boundingSphere, VertexBuffer vertexBuffer, IndexBuffer indexBuffer, ModelMeshPart[] meshParts, object tag)
{
this.boundingSphere = new BoundingSphere();
this.effects = new ModelEffectCollection();
this.name = name;
this.parentBone = parentBone;
this.boundingSphere = boundingSphere;
this.vertexBuffer = vertexBuffer;
this.indexBuffer = indexBuffer;
this.meshParts = new ModelMeshPartCollection(meshParts);
this.tag = tag;
int length = meshParts.Length;
for (int i = 0; i < length; i++)
{
ModelMeshPart part = meshParts[i];
part.parent = this;
}
}
internal c0000de(ModelBone p0, ModelBoneCollection p1, c0000de[] p2)
{
this.f00000b = p0.Index;
this.f000006 = p0.Name;
this.f0000e1 = p0.Transform;
if (p0.Parent != null)
{
this.f000028 = p2[p0.Parent.Index];
}
p2[this.f00000b] = this;
List<c0000de> list = new List<c0000de>();
foreach (ModelBone bone in p0.Children)
{
c0000de item = new c0000de(p1[bone.Index], p1, p2);
list.Add(item);
}
this.f000018 = new c0000db(list);
}
internal ModelMesh(string name, ModelBone parentBone, BoundingSphere boundingSphere, VertexBuffer vertexBuffer, IndexBuffer indexBuffer, ModelMeshPart[] meshParts, object tag)
{
this.boundingSphere = new BoundingSphere();
this.effects = new ModelEffectCollection();
this.name = name;
this.parentBone = parentBone;
this.boundingSphere = boundingSphere;
this.vertexBuffer = vertexBuffer;
this.indexBuffer = indexBuffer;
this.meshParts = new ModelMeshPartCollection(meshParts);
this.tag = tag;
int length = meshParts.Length;
for (int i = 0; i < length; i++)
{
ModelMeshPart part = meshParts[i];
part.parent = this;
}
}
private void ReadMeshes(ContentReader input, VertexDeclaration[] vertexDeclarations)
{
int length = input.ReadInt32();
ModelMesh[] meshes = new ModelMesh[length];
for (int i = 0; i < length; i++)
{
string name = input.ReadObject <string>();
ModelBone parentBone = this.ReadBoneReference(input);
BoundingSphere boundingSphere = new BoundingSphere();
boundingSphere.Center = input.ReadVector3();
boundingSphere.Radius = input.ReadSingle();
VertexBuffer vertexBuffer = input.ReadObject <VertexBuffer>();
IndexBuffer indexBuffer = input.ReadObject <IndexBuffer>();
object tag = input.ReadObject <object>();
ModelMeshPart[] meshParts = ReadMeshParts(input, vertexBuffer, indexBuffer, vertexDeclarations);
meshes[i] = new ModelMesh(name, parentBone, boundingSphere, vertexBuffer, indexBuffer, meshParts, tag);
}
this.meshes = new ModelMeshCollection(meshes);
}
public Vehicle(Model Model, Vector3 Position, Vector3 Rotation,
Vector3 Scale, GraphicsDevice graphicsDevice, Track track, string name, int laps)
: base(Model, Position, Rotation, Scale, graphicsDevice)
{
this.track = track;
leftBackWheelBone = Model.Bones["Left_Rear"];
rightBackWheelBone = Model.Bones["Right_Rear"];
leftFrontWheelBone = Model.Bones["Left_Front"];
rightFrontWheelBone = Model.Bones["Right_Front"];
leftBackWheelTransform = leftBackWheelBone.Transform;
rightBackWheelTransform = rightBackWheelBone.Transform;
leftFrontWheelTransform = leftFrontWheelBone.Transform;
rightFrontWheelTransform = rightFrontWheelBone.Transform;
this.name = name;
this.lapsLeft = laps;
this.graphicsDevice = graphicsDevice;
}
public Tank(Model model,GraphicsDevice device,Camera camera)
: base(model)
{
mousepick = new MousePick(device, camera);
turretBone = model.Bones["turret_geo"];
rightfrontwheel = model.Bones["r_front_wheel_geo"];
rightbackwheel = model.Bones["r_back_wheel_geo"];
leftfrontwheel = model.Bones["l_front_wheel_geo"];
leftbackwheel = model.Bones["l_back_wheel_geo"];
rightsteergeo = model.Bones["r_steer_geo"];
leftsteergeo = model.Bones["l_steer_geo"];
hatchgeo = model.Bones["hatch_geo"];
canongeo = model.Bones["canon_geo"];
leftBackWheelTransform = leftbackwheel.Transform;
rightBackWheelTransform = rightbackwheel.Transform;
leftFrontWheelTransform = leftfrontwheel.Transform;
rightFrontWheelTransform = rightfrontwheel.Transform;
leftSteerTransform = leftsteergeo.Transform;
rightSteerTransform = rightsteergeo.Transform;
turretTransform = turretBone.Transform;
hatchTransform = hatchgeo.Transform;
canonTransform = canongeo.Transform;
currentPosition = prePosition;
}
public static void m000286(ModelBoneCollection p0, ref ModelBone p1)
{
Type type = typeof(ModelBone);
type.GetField("children", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(p1, p0);
}
public static void m000285(ModelBone p0, ref ModelBone p1)
{
Type type = typeof(ModelBone);
type.GetField("parent", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(p1, p0);
}
internal void AddChild(ModelBone modelBone)
{
children.Add(modelBone);
Children = new ModelBoneCollection(children);
}
public Tank(Model model, GraphicsDevice device, Camera camera, int[,] map, int r, int c)
: base(model)
{
pickPosition = Vector3.Zero;
tankPosition = Vector3.Zero;
mousePick = new MousePick(device, camera);
v = new Velocity();
preMousePick = Vector3.Zero;
array = map;
row = r;
col = c;
isNavigate = false;
leftBackWheelBone = model.Bones["l_back_wheel_geo"];
rightBackWheelBone = model.Bones["r_back_wheel_geo"];
leftFrontWheelBone = model.Bones["l_front_wheel_geo"];
rightFrontWheelBone = model.Bones["r_front_wheel_geo"];
leftSteerBone = model.Bones["l_steer_geo"];
rightSteerBone = model.Bones["r_steer_geo"];
turretBone = model.Bones["turret_geo"];
cannonBone = model.Bones["canon_geo"];
hatchBone = model.Bones["hatch_geo"];
leftBackWheelTransform = leftBackWheelBone.Transform;
rightBackWheelTransform = rightBackWheelBone.Transform;
leftFrontWheelTransform = leftFrontWheelBone.Transform;
rightFrontWheelTransform = rightFrontWheelBone.Transform;
leftSteerTransform = leftSteerBone.Transform;
rightSteerTransform = rightSteerBone.Transform;
turretTransform = turretBone.Transform;
cannonTransform = cannonBone.Transform;
hatchTransform = hatchBone.Transform;
}
private void BuildHierarchy(ModelBone node, Matrix parentTransform, int level)
{
node.ModelTransform = node.Transform * parentTransform;
foreach (ModelBone node1 in (ReadOnlyCollection<ModelBone>) node.Children)
this.BuildHierarchy(node1, node.ModelTransform, level + 1);
}
internal void AddChild(ModelBone modelBone)
{
children.Add(modelBone);
Children = new ModelBoneCollection(children);
}
public static Matrix GetAbsoluteTransform(ModelBone bone)
{
if (bone == null)
return Matrix.Identity;
return bone.Transform * GetAbsoluteTransform(bone.Parent);
}
public void AddChild(ModelBone modelBone)
{
this.children.Add(modelBone);
this.Children = new ModelBoneCollection((IList <ModelBone>) this.children);
}
/// <summary>
/// Called when the Game is loading its content. Pass in a ContentManager so the
/// tank can load its model.
/// </summary>
public void LoadContent(ContentManager content)
{
model = content.Load<Model>("Models//tank");
experimentalEffect = content.Load<Effect>("effects");
tankIndicator = new Indicator(game, this);
tankIndicator.LoadContentDamnit();
game.Components.Add(tankIndicator);
moving = content.Load<SoundEffect>("Audio\\Tank");
movingInstance = moving.CreateInstance();
movingInstance.IsLooped = true;
// As discussed in the Simple Animation Sample, we'll look up the bones
// that control the wheels.
leftBackWheelBone = model.Bones["l_back_wheel_geo"];
rightBackWheelBone = model.Bones["r_back_wheel_geo"];
leftFrontWheelBone = model.Bones["l_front_wheel_geo"];
rightFrontWheelBone = model.Bones["r_front_wheel_geo"];
// Also, we'll store the original transform matrix for each animating bone.
leftBackWheelTransform = leftBackWheelBone.Transform;
rightBackWheelTransform = rightBackWheelBone.Transform;
leftFrontWheelTransform = leftFrontWheelBone.Transform;
rightFrontWheelTransform = rightFrontWheelBone.Transform;
turretBone = model.Bones["turret_geo"];
turretTransform = turretBone.Transform;
canonBone = model.Bones["canon_geo"];
canonTransform = canonBone.Transform;
}
internal void SetParentChildren(ModelBone Parent, ModelBone[] Children)
{
this.parent = Parent;
this.children = new ModelBoneCollection(Children);
}
