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); }