public void Load(ContentManager content, Matrix worldm)
{
turretpositions[0] = 45;
turretpositions[1] = 0;
turretpositions[2] = -25;
steerpositions[0] = 45;
steerpositions[1] = 0;
steerpositions[2] = -45;
tankModel = content.Load <Model>(@"tank");
world = worldm;
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"];
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;
boneTransforms = new Matrix[tankModel.Bones.Count];
}
/// <summary>
/// Recursively build Bone's for self and children from ModelBones.
/// </summary>
/// <param name="modelBone"></param>
/// <param name="dst"></param>
/// <returns></returns>
private static Bone AddBoneSubtree(
ModelBone modelBone,
Bone[] dst)
{
int index = modelBone.Index;
string name = modelBone.Name;
Matrix defaultBoneToParent = modelBone.Transform;
Bone parent = modelBone.Parent != null
? dst[modelBone.Parent.Index]
: null;
int numChildren = modelBone.Children.Count;
Bone[] children = new Bone[numChildren];
Bone bone = new Bone(
index,
name,
defaultBoneToParent,
parent,
children);
dst[bone.Index] = bone;
for (int i = 0; i < numChildren; ++i)
{
children[i] = AddBoneSubtree(
modelBone.Children[i],
dst);
}
return(bone);
}
public Tank(Model model, GraphicsDevice device, Camera camera) : base(model)
{
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"];
mousePick = new MousePick(device, camera);
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;
}
}
public Vector3 getBonePosition(string boneName)
{
//matrice di trasformazione che dall'origine mi porta al centro del modello
//partiamo dalla trasformazione della bone che stiamo cercando, quindi le altre matrici andranno moltiplicate a destra
Matrix fromOriginToBoneTransform = Matrix.Identity;
//ora devo trovare le matrici di trasformazione che mi permettono di passare dal centro del modello
//alla bone voluta
ModelBone bone = model.Bones[boneName];
fromOriginToBoneTransform = bone.Transform * Transform;
//costruisco la matrice, moltiplicando a destra la matrice del genitore
//nota che all'ultimo passo la matrice di destra sarà equivalente alla matrice di trasformazione
//che dal centro mi porta al centro del modello
while (bone.Parent != null)
{
fromOriginToBoneTransform = fromOriginToBoneTransform * bone.Parent.Transform;
bone = bone.Parent;
}
//prendo il punto è lo moltiplico per la matrice di trasformazione complessiva
Vector3 bonePosition = Vector3.Transform(Vector3.Zero, fromOriginToBoneTransform);
return(bonePosition);
}
/// <summary>
/// Setup bone attachment.
/// </summary>
/// <param name="animator"></param>
/// <param name="parentBone"></param>
public virtual void SetBone(AnimationInstance animator, ModelBone parentBone)
{
this.parentBone = parentBone;
this.animator = animator;
UpdateTransforms();
}
// Internal creation
internal BonePose(ModelBone bone,
ModelBoneCollection bones,
BonePose[] anims)
{
// Set the values according to the bone
index = bone.Index;
name = bone.Name;
defaultMatrix = bone.Transform;
if (bone.Parent != null)
{
parent = anims[bone.Parent.Index];
}
anims[index] = this;
// Recurse on children
List <BonePose> childList = new List <BonePose>();
foreach (ModelBone child in bone.Children)
{
BonePose newChild = new BonePose(
bones[child.Index],
bones,
anims);
childList.Add(newChild);
}
children = new BonePoseCollection(childList);
}
//Construtor tank
public Tank(Model tankModel, float scale, Vector3 pos)
{
this.tankModel = tankModel;
worldMatrix = Matrix.Identity;
this.scale = scale;
this.pos = pos;
dir = Vector3.Forward;
//associar bones as devidas variaveis
rFWheelBone = tankModel.Bones["r_front_wheel_geo"];
lFWheelBone = tankModel.Bones["l_front_wheel_geo"];
rBWheelBone = tankModel.Bones["r_back_wheel_geo"];
lBWheelBone = tankModel.Bones["l_back_wheel_geo"];
lSteerBone = tankModel.Bones["l_steer_geo"];
rSteerBone = tankModel.Bones["r_steer_geo"];
turretBone = tankModel.Bones["turret_geo"];
cannonBone = tankModel.Bones["canon_geo"];
hatchBone = tankModel.Bones["hatch_geo"];
turretTransform = turretBone.Transform;
cannonTransform = cannonBone.Transform;
boneTransforms = new Matrix[tankModel.Bones.Count];
tankModel.Root.Transform = Matrix.CreateScale(scale);
}
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);
}
public override void Animate()
{
base.Opacity = m_componentHumanModel.Opacity;
foreach (ModelBone bone in base.Model.Bones)
{
ModelBone modelBone = m_componentHumanModel.Model.FindBone(bone.Name);
SetBoneTransform(bone.Index, m_componentHumanModel.GetBoneTransform(modelBone.Index));
}
if (base.Opacity.HasValue && base.Opacity.Value < 1f)
{
bool num = m_componentCreature.ComponentBody.ImmersionFactor >= 1f;
bool flag = m_subsystemSky.ViewUnderWaterDepth > 0f;
if (num == flag)
{
RenderingMode = ModelRenderingMode.TransparentAfterWater;
}
else
{
RenderingMode = ModelRenderingMode.TransparentBeforeWater;
}
}
else
{
RenderingMode = ModelRenderingMode.AlphaThreshold;
}
base.Animate();
}
public void AddChild(ModelBone modelBone)
{
if (!Children.Contains(modelBone))
{
Children.Add(modelBone);
}
}
//Generates a model from required parameters, used to simplify and clean up code.
public static Model makeModel(List <ModelMesh> meshes, GraphicsDevice graphics, Effect effect)
{
List <ModelBone> boneList = new List <ModelBone>();
ModelBone boneObj = new ModelBone();
boneObj.Transform = Matrix.CreateTranslation(0, 0, 0);
boneObj.ModelTransform = Matrix.CreateTranslation(0, 0, 0);
foreach (ModelMesh modelMeshObj in meshes)
{
boneObj.AddChild(modelMeshObj.ParentBone);
modelMeshObj.ParentBone.Parent = boneObj;
boneList.Add(modelMeshObj.ParentBone);
}
Model modelObj = new Model(graphics, boneList, meshes);
modelObj.Root = boneObj;
foreach (ModelMesh modelMesh in modelObj.Meshes)
{
foreach (ModelMeshPart meshPart in modelMesh.MeshParts)
{
meshPart.Effect = effect;
}
}
return(modelObj);
}
private static void WriteBone(ModelBone bone, int level, StreamWriter writer)
{
for (int l = 0; l < level; l++)
{
writer.Write("\t");
}
writer.Write("- Name : ");
if ((bone.Name == "") || (bone.Name == "null"))
{
writer.WriteLine("null");
}
else
{
writer.WriteLine(bone.Name);
}
for (int l = 0; l < level; l++)
{
writer.Write("\t");
}
writer.WriteLine(" Index: " + bone.Index);
foreach (ModelBone childBone in bone.Children)
{
WriteBone(childBone, level + 1, writer);
}
}
public override void SetModel(Model model)
{
base.SetModel(model);
if (base.Model != null)
{
m_bodyBone = base.Model.FindBone("Body");
m_neckBone = base.Model.FindBone("Neck");
m_headBone = base.Model.FindBone("Head");
m_leg1Bone = base.Model.FindBone("Leg1");
m_leg2Bone = base.Model.FindBone("Leg2");
m_wing1Bone = base.Model.FindBone("Wing1", throwIfNotFound: false);
m_wing2Bone = base.Model.FindBone("Wing2", throwIfNotFound: false);
}
else
{
m_bodyBone = null;
m_neckBone = null;
m_headBone = null;
m_leg1Bone = null;
m_leg2Bone = null;
m_wing1Bone = null;
m_wing2Bone = null;
}
m_hasWings = (m_wing1Bone != null && m_wing2Bone != null);
}
//Generates a mesh from required parameters, as well as specifying a parent bone to be used, used to simplify and clean up code.
public static ModelMesh makeMeshFromPolygonList(List <Polygon> polys, GraphicsDevice graphics, ModelBone parentBone)
{
List <ModelMeshPart> parts = new List <ModelMeshPart>();
ModelBone bone = new ModelBone();
bone.Transform = Matrix.CreateTranslation(0, 0, 0);
bone.ModelTransform = parentBone.ModelTransform;
List <Vector3> points = new List <Vector3>();
foreach (Polygon p in polys)
{
ModelMeshPart part = makePartFromPolygon(p, graphics);
parts.Add(part);
foreach (Vector3 point in p.points)
{
points.Add(point);
}
}
ModelMesh mesh = new ModelMesh(graphics, parts);
bone.AddMesh(mesh);
parentBone.AddChild(bone);
bone.Parent = parentBone;
mesh.ParentBone = bone;
mesh.BoundingSphere = BoundingSphere.CreateFromPoints(points);
return(mesh);
}
/// <summary>
/// Loads the tank model.
/// </summary>
public void Load(ContentManager content)
{
// Load the tank model from the ContentManager.
tankModel = content.Load <Model>("tank");
// 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];
}
//Used whenever a bone is moved, this also makes sure that the child bones are updates as well, since xna does not provide it by default
public static void moveBone(Matrix matrix, ModelBone bone)
{
bone.Transform = matrix;
foreach (ModelBone b in bone.Children)
{
b.ModelTransform = Matrix.Multiply(matrix, b.Transform);
}
}
private static ModelBone ReadBone(BinaryReader r)
{
var data = new ModelBone();
data.Name = ReadString(r);
data.Unknown= r.ReadByte();
return data;
}
private void CheckAll(ModelBone modelBone)
{
modelBone.Check = checkAll;
for (int i = 0; i < modelBone.Child.Count; i++)
{
CheckAll(modelBone.Child[i]);
}
}
public static Matrix GetAbsoluteTransform(ModelBone bone)
{
if (bone == null)
{
return(Matrix.Identity);
}
return(bone.Transform * GetAbsoluteTransform(bone.Parent));
}
public static Matrix GetBoneAbsoluteTransform(ModelBone modelBone)
{
if (modelBone.ParentBone != null)
{
return(GetBoneAbsoluteTransform(modelBone.ParentBone) * modelBone.Transform);
}
return(modelBone.Transform);
}
public static void TravelTree(ModelBone bone, ref CNT parent, bool root = false)
{
var cnt = new CNT();
if (root) { cnt = parent; }
cnt.Name = bone.Name;
cnt.Transform = new Matrix3D(
bone.Transform.M11, bone.Transform.M12, bone.Transform.M13,
bone.Transform.M21, bone.Transform.M22, bone.Transform.M23,
bone.Transform.M31, bone.Transform.M32, bone.Transform.M33,
bone.Transform.M41, bone.Transform.M42, bone.Transform.M43
);
switch (bone.Type)
{
case BoneType.Mesh:
cnt.Section = CNT.NodeType.MODL;
cnt.Model = bone.Mesh.Name;
break;
case BoneType.Light:
cnt.Section = CNT.NodeType.LITg;
cnt.EmbeddedLight = (bone.AttachmentFile == null);
if (cnt.EmbeddedLight)
{
cnt.Light = (ToxicRagers.CarmageddonReincarnation.Formats.LIGHT)bone.Attachment;
}
else
{
cnt.LightName = bone.AttachmentFile;
var light = bone.Attachment as ToxicRagers.CarmageddonReincarnation.Formats.LIGHT;
if (light != null)
{
light.Save(Path.Combine(rootPath, cnt.LightName + ".light"));
}
}
break;
case BoneType.VFX:
cnt.Section = CNT.NodeType.VFXI;
cnt.VFXFile = bone.AttachmentFile;
break;
default:
cnt.Section = CNT.NodeType.NULL;
break;
}
foreach (var b in bone.Children)
{
TravelTree(b, ref cnt);
}
if (!root) { parent.Children.Add(cnt); }
}
private ModelBone ProcessBone(EntityModelBone bone, List <VertexPositionNormalTexture> vertices, Vector2 uvScale, Vector2 textureSize, Dictionary <string, ModelBone> modelBones)
{
ModelBone modelBone;
List <short> indices = new List <short>();
if (bone.Cubes != null)
{
foreach (var cube in bone.Cubes)
{
if (cube == null)
{
Log.Warn("Cube was null!");
continue;
}
Cube built = new Cube(cube.Size * (float)cube.Inflate, textureSize);
built.Mirrored = bone.Mirror;
built.BuildCube(cube.Uv * uvScale);
vertices = ModifyCubeIndexes(vertices, cube, ref built.Front);
vertices = ModifyCubeIndexes(vertices, cube, ref built.Back);
vertices = ModifyCubeIndexes(vertices, cube, ref built.Top);
vertices = ModifyCubeIndexes(vertices, cube, ref built.Bottom);
vertices = ModifyCubeIndexes(vertices, cube, ref built.Left);
vertices = ModifyCubeIndexes(vertices, cube, ref built.Right);
indices.AddRange(built.Front.indexes.Concat(built.Back.indexes).Concat(built.Top.indexes)
.Concat(built.Bottom.indexes).Concat(built.Left.indexes).Concat(built.Right.indexes)
.ToArray());
}
}
var bindPoseMatrix = Matrix.CreateTranslation(-bone.Pivot)
* Matrix.CreateRotationX(MathUtils.ToRadians(-bone.BindPoseRotation.X))
* Matrix.CreateRotationY(MathUtils.ToRadians(-bone.BindPoseRotation.Y))
* Matrix.CreateRotationZ(MathUtils.ToRadians(-bone.BindPoseRotation.Z))
* Matrix.CreateTranslation(bone.Pivot);
var boneMatrix = Matrix.Identity * Matrix.CreateTranslation(-bone.Pivot)
* Matrix.CreateFromAxisAngle(
Vector3.Right, MathUtils.ToRadians(bone.Rotation.X))
* Matrix.CreateFromAxisAngle(
Vector3.Backward, MathUtils.ToRadians(bone.Rotation.Z))
* Matrix.CreateFromAxisAngle(
Vector3.Up, MathUtils.ToRadians(bone.Rotation.Y))
* Matrix.CreateTranslation(bone.Pivot);
modelBone = new ModelBone(Texture, indices.ToArray(), bone.Parent, bone, bindPoseMatrix * boneMatrix);
//modelBone.UpdateRotationMatrix = !bone.NeverRender;
if (!modelBones.TryAdd(bone.Name, modelBone))
{
Log.Debug($"Failed to add bone! {bone.Name}");
}
return(modelBone);
}
private static ModelBoneInstance[] NewDefaultModelBoneInstances()
{
var testBone = new ModelBone(0, "myBone", null, Vector3.Zero, Quaternion.Identity);
return(new[]
{
new ModelBoneInstance(testBone)
});
}
/// <summary>
/// Setup bone attachment.
/// </summary>
/// <param name="animator"></param>
/// <param name="parentBone"></param>
public override void SetBone(AnimationInstance animator, ModelBone parentBone)
{
base.SetBone(animator, parentBone);
foreach (Rectangle rect in sides)
{
rect.SetBone(animator, parentBone);
}
}
public void rotateY(ModelBone bone, Matrix tr, float rotation) //Y axis rotation (for turret)
{
Vector3 oringalTrans = tr.Translation;
bone.Transform *= Matrix.CreateRotationY(rotation);
Vector3 newTrans = bone.Transform.Translation;
bone.Transform *= Matrix.CreateTranslation(oringalTrans - newTrans);
}
public void rotateX(ModelBone bone, Matrix tr, float rotation) //X axis rotation (for wheels)
{
Vector3 oringalTrans = tr.Translation;
bone.Transform *= Matrix.CreateRotationX(rotation);
Vector3 newTrans = bone.Transform.Translation;
bone.Transform *= Matrix.CreateTranslation(oringalTrans - newTrans);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Nombre</param>
/// <param name="bone">Bone que representa la posición del jugador</param>
/// <param name="translation">Posición adicional a la posición marcada por el bone</param>
public PlayerPosition(string name, ModelBone bone, Vector3 translation)
{
this.Name = name;
this.Index = bone.Index;
this.BoneName = bone.Name;
m_Bone = bone;
m_AditionalTranslation = translation;
}
private ModelBone ProcessBone(EntityModelBone bone, List <VertexPositionNormalTexture> vertices, Vector2 uvScale, Vector2 textureSize, Dictionary <string, ModelBone> modelBones)
{
List <ModelBoneCube> cubes = new List <ModelBoneCube>();
ModelBone modelBone;
if (bone.Cubes != null)
{
foreach (var cube in bone.Cubes)
{
if (cube == null)
{
Log.Warn("Cube was null!");
continue;
}
var size = cube.Size;
var origin = cube.Origin;
var pivot = cube.Pivot;
var rotation = cube.Rotation;
origin = new Vector3(-(origin.X + size.X), origin.Y, origin.Z);
//VertexPositionNormalTexture[] vertices;
Cube built = new Cube(size * (float)cube.Inflate, textureSize);
built.Mirrored = bone.Mirror;
built.BuildCube(cube.Uv * uvScale);
vertices = ModifyCubeIndexes(vertices, ref built.Front);
vertices = ModifyCubeIndexes(vertices, ref built.Back);
vertices = ModifyCubeIndexes(vertices, ref built.Top);
vertices = ModifyCubeIndexes(vertices, ref built.Bottom);
vertices = ModifyCubeIndexes(vertices, ref built.Left);
vertices = ModifyCubeIndexes(vertices, ref built.Right);
var part = new ModelBoneCube(built.Front.indexes
.Concat(built.Back.indexes)
.Concat(built.Top.indexes)
.Concat(built.Bottom.indexes)
.Concat(built.Left.indexes)
.Concat(built.Right.indexes)
.ToArray(), Texture, rotation, pivot, origin);
part.Mirror = bone.Mirror;
cubes.Add(part);
}
}
modelBone = new ModelBone(cubes.ToArray(), bone.Parent, bone);
modelBone.UpdateRotationMatrix = !bone.NeverRender;
if (!modelBones.TryAdd(bone.Name, modelBone))
{
Log.Debug($"Failed to add bone! {bone.Name}");
}
return(modelBone);
}
protected void AddClassRender(string classname, Model model, ModelBone bone)
{
string controlName;
controlName = bone.Name.Substring(classname.Length).Trim();
// create a class render object
ClassRenderObj classRender = new ClassRenderObj(classname, model, bone);
collection.Add(controlName, classRender);
}
//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 Tank(GraphicsDevice device, ContentManager content, ChooseTank tank)
{
wordlMatrix = Matrix.Identity;
r = Matrix.Identity;
direction = new Vector3(0f, 0f, -1f);
bullets = new List <Bullet>();
tankModel = content.Load <Model>("tank");
scale = 0.005f;
if (tank == ChooseTank.tank)
{
position = new Vector3(15f, -10.0f, 40f);
}
if (tank == ChooseTank.enemyTank)
{
position = new Vector3(20f, -10f, 40f);
}
effect = new BasicEffect(device);
// Calcula a aspectRatio, a view matrix e a projeção
aspectRatio = (float)device.Viewport.Width / device.Viewport.Height;
bsphere = new BoundingSphere(position, 2);
// Lê os bones
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"];
// Lê as transformações iniciais dos bones
leftBackWheelTransform = leftBackWheelBone.Transform;
rightBackWheelTransform = rightBackWheelBone.Transform;
leftFrontWheelTransform = leftFrontWheelBone.Transform;
rightFrontWheelTransform = rightFrontWheelBone.Transform;
leftSteerTransform = leftSteerBone.Transform;
rightSteerTransform = rightSteerBone.Transform;
turretTransform = turretBone.Transform;
cannonTransform = cannonBone.Transform;
// cria o array que armazenará as transformações em cascata dos bones
boneTransforms = new Matrix[tankModel.Bones.Count];
}
public Matrix GetTransformPaths(ModelBone bone)
{
Matrix result = Matrix.Identity;
while (bone != null)
{
result = result * bone.Transform;
bone = bone.Parent;
}
return(result);
}
public static void TravelTree(ModelBone bone, ref ACT act, bool root = false)
{
act.AddActor(
bone.Name,
(bone.Type == BoneType.Mesh && bone.Mesh != null ? bone.Mesh.Name : null),
new Matrix3D(
bone.Transform.M11, bone.Transform.M21, bone.Transform.M31,
bone.Transform.M12, bone.Transform.M22, bone.Transform.M32,
bone.Transform.M13, bone.Transform.M23, bone.Transform.M33,
bone.Transform.M41, bone.Transform.M42, bone.Transform.M43
),
true
);
foreach (var b in bone.Children)
{
TravelTree(b, ref act);
act.AddSubLevelEnd();
}
}
private void CreateBone(ModelBone i, int no)
{
var boneid = i.Name.Replace(" ", "_");
var bone = new Bone() { ID= "Bone-"+boneid, Name= i.Name, };
var bonenode= new VisualNode() { ID= "Node-"+boneid, Name= i.Name, Instance= bone };
var trn = new SlimDX.Vector3(i.Params[0], i.Params[1], i.Params[2]);
var rot = new SlimDX.Quaternion(i.Params[3], i.Params[4], i.Params[5], -i.Params[6]);
var mat = SlimDX.Matrix.RotationQuaternion(rot)
* SlimDX.Matrix.Translation(trn);
bonenode.SID = "joint" + no;
bonenode.LocalTransform = mat;
Bones.Add(bonenode);
Root.Instances.Add(bone);
if(i.ParentID < 0)
{
bonenode.GlobalTransform= mat;
Scene.Nodes.Add(bonenode);
} else
{
var parent = Bones[i.ParentID];
bonenode.GlobalTransform= mat * parent.GlobalTransform;
//bonenode.GlobalTransform= parent.GlobalTransform * mat;
parent.Nodes.Add(bonenode);
}
}
public static void TravelTree(ModelBone bone, ref StructurePart parent, bool root = false)
{
var part = new StructurePart();
if (root) { part = parent; }
part.Name = bone.Name;
switch (bone.Name.ToLower())
{
case "driver":
return;
case "wheel_fl":
parent.DamageSettings.SetParameterForMethod("PhysicsProperty", "Name", StructurePhysicsProperty.FRONT_LEFT_POINT_OF_SUSPENSION);
parent.DamageSettings.SetParameterForMethod("PhysicsProperty", "Name", StructurePhysicsProperty.FRONT_LEFT_POINT_OF_STEERING);
part.DamageSettings.SetParameterForMethod("Crushability", "Value", 0.0f);
part.DamageSettings.SetParameterForMethod("PhysicsProperty", "Name", StructurePhysicsProperty.FRONT_LEFT_WHEEL);
part.DamageSettings.SetParameterForMethod("PhysicsProperty", "Name", StructurePhysicsProperty.FRONT_LEFT_POINT_OF_ROTATION);
part.DamageSettings.SetParameterForMethod("ShapeType", "Shape", "TIC_TAC_X");
part.DamageSettings.SetParameterForMethod("Restitution", "Value", 2.0f);
break;
case "wheel_fr":
parent.DamageSettings.SetParameterForMethod("PhysicsProperty", "Name", StructurePhysicsProperty.FRONT_RIGHT_POINT_OF_SUSPENSION);
parent.DamageSettings.SetParameterForMethod("PhysicsProperty", "Name", StructurePhysicsProperty.FRONT_RIGHT_POINT_OF_STEERING);
part.DamageSettings.SetParameterForMethod("Crushability", "Value", 0.0f);
part.DamageSettings.SetParameterForMethod("PhysicsProperty", "Name", StructurePhysicsProperty.FRONT_RIGHT_WHEEL);
part.DamageSettings.SetParameterForMethod("PhysicsProperty", "Name", StructurePhysicsProperty.FRONT_RIGHT_POINT_OF_ROTATION);
part.DamageSettings.SetParameterForMethod("ShapeType", "Shape", "TIC_TAC_X");
part.DamageSettings.SetParameterForMethod("Restitution", "Value", 2.0f);
break;
case "wheel_rl":
parent.DamageSettings.SetParameterForMethod("PhysicsProperty", "Name", StructurePhysicsProperty.REAR_LEFT_POINT_OF_SUSPENSION);
part.DamageSettings.SetParameterForMethod("Crushability", "Value", 0.0f);
part.DamageSettings.SetParameterForMethod("PhysicsProperty", "Name", StructurePhysicsProperty.REAR_LEFT_WHEEL);
part.DamageSettings.SetParameterForMethod("PhysicsProperty", "Name", StructurePhysicsProperty.REAR_LEFT_POINT_OF_ROTATION);
part.DamageSettings.SetParameterForMethod("ShapeType", "Shape", "TIC_TAC_X");
part.DamageSettings.SetParameterForMethod("Restitution", "Value", 2.0f);
break;
case "wheel_rr":
parent.DamageSettings.SetParameterForMethod("PhysicsProperty", "Name", StructurePhysicsProperty.REAR_RIGHT_POINT_OF_SUSPENSION);
part.DamageSettings.SetParameterForMethod("Crushability", "Value", 0.0f);
part.DamageSettings.SetParameterForMethod("PhysicsProperty", "Name", StructurePhysicsProperty.REAR_RIGHT_WHEEL);
part.DamageSettings.SetParameterForMethod("PhysicsProperty", "Name", StructurePhysicsProperty.REAR_RIGHT_POINT_OF_ROTATION);
part.DamageSettings.SetParameterForMethod("ShapeType", "Shape", "TIC_TAC_X");
part.DamageSettings.SetParameterForMethod("Restitution", "Value", 2.0f);
break;
default:
if (bone.Name.Length > 2 && bone.Name.StartsWith("c_", StringComparison.InvariantCultureIgnoreCase))
{
part.DamageSettings.SetParameterForMethod("Crushability", "Value", 1.0f);
}
else
{
part.DamageSettings.SetParameterForMethod("Crushability", "Value", 0.0f);
}
break;
}
foreach (var b in bone.Children)
{
TravelTree(b, ref part);
}
if (!root)
{
var weld = new StructureWeld();
weld.Partner = parent.Name;
weld.WeldSettings.SetParametersForMethod("PartSpaceVertex", "X", 0, "Y", 0, "Z", 0);
part.Welds.Add(weld);
parent.Parts.Add(part);
}
}
void scene_OnSelect(object sender, SelectEventArgs e)
{
bone = (e.Item as ModelBone);
resetWidget();
}
private static void WriteBone(BinaryWriter w, ModelBone data)
{
WriteString(w, data.Name);
w.Write(data.Unknown);
}
