private void updateMatrix(Vector3 position, Vector3 rotation, Vector3 scale, bool absolute)
{
Matrix4D mS = Matrix4D.CreateScale(scale);
Matrix4D mR = Matrix4D.CreateFromQuaternion(
Quaternion.FromAxisAngle(Vector3.UnitX, Maths.DegreesToRadians(rotation.X)) *
Quaternion.FromAxisAngle(Vector3.UnitY, Maths.DegreesToRadians(rotation.Y)) *
Quaternion.FromAxisAngle(Vector3.UnitZ, Maths.DegreesToRadians(rotation.Z))
);
Matrix4D t = Matrix4D.Identity;
t *= mS;
t *= mR;
t.M41 = position.X;
t.M42 = position.Y;
t.M43 = position.Z;
if (absolute)
{
Transform = t;
}
else
{
Transform *= t;
}
SceneManager.Current.Models[0].SetTransform(Transform, SceneManager.Current.SelectedBoneIndex);
}
public static void FlipAxis(Model model, Axis axis, bool bApplyToHierarchy = false)
{
Vector3 transform = Vector3.One;
List <string> processed = new List <string>();
ModelBoneCollection bones = (bApplyToHierarchy ? model.Root.AllChildren() : new ModelBoneCollection {
model.Root
});
switch (axis)
{
case Axis.X:
transform.X = -1.0f;
break;
case Axis.Y:
transform.Y = -1.0f;
break;
case Axis.Z:
transform.Z = -1.0f;
break;
}
foreach (ModelBone bone in bones)
{
if (bone.Type == BoneType.Mesh && bone.Mesh != null && !processed.Contains(bone.Mesh.Name))
{
ModelMesh mesh = bone.Mesh;
foreach (ModelMeshPart meshpart in mesh.MeshParts)
{
for (int i = 0; i < meshpart.VertexCount; i++)
{
meshpart.VertexBuffer.ModifyVertexPosition(i, meshpart.VertexBuffer.Data[i].Position * transform);
meshpart.VertexBuffer.ModifyVertexNormal(i, meshpart.VertexBuffer.Data[i].Normal * transform);
}
for (int i = 0; i < meshpart.IndexBuffer.Data.Count; i += 3)
{
meshpart.IndexBuffer.SwapIndices(i + 1, i + 2);
}
meshpart.IndexBuffer.Initialise();
meshpart.VertexBuffer.Initialise();
}
mesh.BoundingBox.Calculate(mesh);
processed.Add(mesh.Name);
}
bone.Transform = Matrix4D.CreateScale(transform) * bone.Transform * Matrix4D.CreateScale(transform);
}
}
public static void Freeze(ModelMesh model, FreezeComponents flags)
{
bool freezePos = flags.HasFlag(FreezeComponents.Position);
bool freezeRot = flags.HasFlag(FreezeComponents.Rotation);
bool freezeSca = flags.HasFlag(FreezeComponents.Scale);
Matrix4D mPosition = Matrix4D.CreateTranslation(model.Parent.Transform.ExtractTranslation());
Matrix4D mRotation = Matrix4D.CreateFromQuaternion(model.Parent.Transform.ExtractRotation());
Matrix4D mScale = Matrix4D.CreateScale(model.Parent.Transform.ExtractScale());
if (freezePos)
{
model.Parent.Transform = model.Parent.Transform.ClearTranslation();
}
if (freezeRot)
{
model.Parent.Transform = model.Parent.Transform.ClearRotation();
}
if (freezeSca)
{
model.Parent.Transform = model.Parent.Transform.ClearScale();
}
foreach (ModelMeshPart meshpart in model.MeshParts)
{
for (int i = 0; i < meshpart.VertexCount; i++)
{
if (freezePos)
{
meshpart.VertexBuffer.ModifyVertexPosition(i, Vector3.TransformVector(meshpart.VertexBuffer.Data[i].Position, mPosition));
}
if (freezeRot)
{
meshpart.VertexBuffer.ModifyVertexPosition(i, Vector3.TransformVector(meshpart.VertexBuffer.Data[i].Position, mRotation));
meshpart.VertexBuffer.ModifyVertexNormal(i, Vector3.TransformNormal(meshpart.VertexBuffer.Data[i].Normal, mRotation));
}
if (freezeSca)
{
meshpart.VertexBuffer.ModifyVertexPosition(i, Vector3.TransformVector(meshpart.VertexBuffer.Data[i].Position, mScale));
}
}
meshpart.VertexBuffer.Initialise();
}
model.BoundingBox.Calculate(model);
}
public void SetCoordinateSystem(CoordinateSystem c)
{
CoordinateSystem = c;
if (c == CoordinateSystem.RightHanded)
{
Transform = Matrix4D.Identity;
FrontFace = "Ccw";
}
else
{
Transform = Matrix4D.CreateScale(1, 1, -1);
FrontFace = "Cw";
}
}
private void applyTransforms()
{
ModelBoneCollection bones = (chkHierarchy.Checked ? SceneManager.Current.Models[modelIndex].Bones[boneIndex].AllChildren() : new ModelBoneCollection {
SceneManager.Current.Models[modelIndex].Bones[boneIndex]
});
if (rdoScaling.Checked)
{
Matrix4D scaleMatrix = Matrix4D.Identity;
if (rdoScaleWholeModel.Checked)
{
scaleMatrix = Matrix4D.CreateScale(
txtScaleWholeModel.Text.ToSingle(),
txtScaleWholeModel.Text.ToSingle(),
txtScaleWholeModel.Text.ToSingle()
);
}
else if (rdoScaleByAxis.Checked)
{
scaleMatrix = Matrix4D.CreateScale(
txtScaleAxisX.Text.ToSingle(),
txtScaleAxisY.Text.ToSingle(),
txtScaleAxisZ.Text.ToSingle()
);
}
ModelManipulator.Scale(bones, scaleMatrix, chkHierarchy.Checked);
}
else if (rdoMunging.Checked)
{
if (rdoInvert.Checked)
{
//ModelManipulator.FlipAxis(SceneManager.Current.Models[modelIndex].Bones[boneIndex].Mesh, cboInvertAxis.SelectedItem.ToString().ToEnum<Axis>(), chkHierarchy.Checked);
}
else if (rdoMeshBoneSwap.Checked)
{
ModelManipulator.MungeMeshWithBone(bones);
}
else if (rdoFlipWindingOrder.Checked)
{
ModelManipulator.FlipFaces(bones, chkHierarchy.Checked);
}
}
}
public static void ProcessLevelForCarmageddonMaxDamage()
{
if (SceneManager.Current.Models.Count == 0)
{
return;
}
ModelBoneCollection bones = SceneManager.Current.Models[0].Bones[0].AllChildren();
SceneManager.Current.UpdateProgress("Applying Carmageddon: Max Damage scale");
ModelManipulator.Scale(bones, Matrix4D.CreateScale(6.9f, 6.9f, -6.9f), true);
ModelManipulator.FlipFaces(bones, true);
SceneManager.Current.UpdateProgress("Fixing material names");
foreach (Material material in SceneManager.Current.Materials)
{
if (material.Name.Contains("."))
{
material.Name = material.Name.Substring(0, material.Name.IndexOf("."));
}
material.Name = material.Name.Replace("\\", "");
MATMaterial m = (material.SupportingDocuments["Source"] as MATMaterial);
if (!m.HasTexture)
{
using (Bitmap bmp = new Bitmap(16, 16))
using (Graphics g = Graphics.FromImage(bmp))
{
g.FillRectangle(new SolidBrush(Color.FromArgb(m.DiffuseColour[3], m.DiffuseColour[0], m.DiffuseColour[1], m.DiffuseColour[2])), 0, 0, 16, 16);
Texture t = new Texture();
t.CreateFromBitmap(bmp, string.Format("{4}_R{0:x2}G{1:x2}B{2:x2}A{3:x2}", m.DiffuseColour[0], m.DiffuseColour[1], m.DiffuseColour[2], m.DiffuseColour[3], material.Name));
material.Texture = t;
}
}
}
SceneManager.Current.UpdateProgress("Processing powerups and accessories");
for (int i = bones.Count - 1; i >= 0; i--)
{
ModelBone bone = bones[i];
if (bone.Name.StartsWith("&"))
{
if (bone.Name.StartsWith("&£"))
{
C2Powerup pup = Powerups.LookupID(int.Parse(bone.Name.Substring(2, 2)));
Powerup powerup = new Powerup();
if (pup.InMD)
{
powerup.Name = $"pup_{pup.Name}";
powerup.Tag = pup.Model;
}
else
{
powerup.Name = "pup_Credits";
powerup.Tag = pup.Model;
}
powerup.Transform = bone.CombinedTransform;
SceneManager.Current.Entities.Add(powerup);
}
else
{
Accessory accessory = new Accessory
{
Name = $"C2_{bone.Mesh.Name.Substring(3)}"
};
SceneManager.Current.Entities.Add(accessory);
}
SceneManager.Current.Models[0].RemoveBone(bone.Index);
}
}
if (SceneManager.Current.Models[0].SupportingDocuments.ContainsKey("TXT"))
{
Map map = SceneManager.Current.Models[0].GetSupportingDocument <Map>("TXT");
StartingGrid grid = new StartingGrid
{
Transform = Matrix4D.CreateTranslation(map.GridPosition.X * 6.9f, map.GridPosition.Y * 6.9f, map.GridPosition.Z * -6.9f)
};
SceneManager.Current.Entities.Add(grid);
}
SceneManager.Current.UpdateProgress("Processing complete!");
SceneManager.Current.SetCoordinateSystem(CoordinateSystem.LeftHanded);
SceneManager.Current.Change(ChangeType.Munge, ChangeContext.Model, -1);
SceneManager.Current.SetContext("Carmageddon Max Damage", ContextMode.Level);
}
public static void ProcessCarForCarmageddonMaxDamage()
{
if (SceneManager.Current.Models.Count == 0)
{
return;
}
Model model = SceneManager.Current.Models[0];
ModelBoneCollection bones = SceneManager.Current.Models[0].Bones[0].AllChildren();
SceneManager.Current.UpdateProgress("Applying Carmageddon Reincarnation scale");
ModelManipulator.Scale(bones, Matrix4D.CreateScale(6.9f, 6.9f, -6.9f), true);
ModelManipulator.FlipFaces(bones, true);
SceneManager.Current.UpdateProgress("Fixing material names");
foreach (Material material in SceneManager.Current.Materials)
{
if (material.Name.Contains("."))
{
material.Name = material.Name.Substring(0, material.Name.IndexOf("."));
}
material.Name = material.Name.Replace("\\", "");
}
SceneManager.Current.UpdateProgress("Munging parts and fixing wheels");
float scale;
for (int i = 0; i < bones.Count; i++)
{
ModelBone bone = bones[i];
if (i == 0)
{
bone.Name = "c_Body";
bone.Mesh.Name = "c_Body";
}
else
{
bone.Name = Path.GetFileNameWithoutExtension(bone.Name);
}
switch (bone.Name.ToUpper())
{
case "C_BODY":
break;
case "FLPIVOT":
case "FRPIVOT":
bone.Name = "Hub_" + bone.Name.ToUpper().Substring(0, 2);
if (bone.Transform.ExtractTranslation() == Vector3.Zero)
{
ModelManipulator.MungeMeshWithBone(bone.Children[0].Mesh, false);
Matrix4D m = bone.Transform;
m.M31 = bone.Children[0].Transform.M31;
m.M32 = bone.Children[0].Transform.M32;
m.M33 = bone.Children[0].Transform.M33;
bone.Transform = m;
model.SetTransform(Matrix4D.Identity, bone.Children[0].Index);
}
break;
case "FLWHEEL":
scale = bone.CombinedTransform.ExtractTranslation().Y / 0.35f;
bone.Name = "Wheel_FL";
model.ClearMesh(bone.Index);
model.SetTransform(Matrix4D.CreateScale(scale) * Matrix4D.CreateRotationY(Maths.DegreesToRadians(180)), bone.Index);
break;
case "FRWHEEL":
scale = bone.CombinedTransform.ExtractTranslation().Y / 0.35f;
bone.Name = "Wheel_FR";
model.ClearMesh(bone.Index);
model.SetTransform(Matrix4D.CreateScale(scale), bone.Index);
break;
case "RLWHEEL":
case "RRWHEEL":
string suffix = bone.Name.ToUpper().Substring(0, 2);
bone.Name = "Hub_" + suffix;
if (bone.Transform.ExtractTranslation() == Vector3.Zero)
{
ModelManipulator.MungeMeshWithBone(bone.Mesh, false);
}
model.ClearMesh(bone.Index);
scale = bone.CombinedTransform.ExtractTranslation().Y / 0.35f;
int newBone = model.AddMesh(null, bone.Index);
model.SetName("Wheel_" + suffix, newBone);
model.SetTransform(Matrix4D.CreateScale(scale) * (suffix == "RL" ? Matrix4D.CreateRotationY(Maths.DegreesToRadians(180)) : Matrix4D.Identity), newBone);
break;
case "DRIVER":
bone.Name = "Dryver";
goto default;
default:
if (bone.Type == BoneType.Mesh)
{
ModelManipulator.MungeMeshWithBone(bone.Mesh, false);
}
break;
}
}
SceneManager.Current.UpdateProgress("Processing complete!");
SceneManager.Current.SetCoordinateSystem(CoordinateSystem.LeftHanded);
SceneManager.Current.Change(ChangeType.Munge, ChangeContext.Model, -1);
SceneManager.Current.SetContext("Carmageddon Max Damage", ContextMode.Car);
}
public void Draw()
{
if (asset == null)
{
ModelMeshPart sprite = new ModelMeshPart();
sprite.AddVertex(new Vector3(-0.25f, -0.25f, 0.0f), Vector3.UnitY, new Vector2(0, 1));
sprite.AddVertex(new Vector3(-0.25f, 0.25f, 0.0f), Vector3.UnitY, new Vector2(0, 0));
sprite.AddVertex(new Vector3(0.25f, 0.25f, 0.0f), Vector3.UnitY, new Vector2(1, 0));
sprite.AddVertex(new Vector3(0.25f, -0.25f, 0.0f), Vector3.UnitY, new Vector2(1, 1));
sprite.AddVertex(new Vector3(0.25f, -0.25f, 0.0f), Vector3.UnitY, new Vector2(0, 1));
sprite.AddVertex(new Vector3(0.25f, 0.25f, 0.0f), Vector3.UnitY, new Vector2(0, 0));
sprite.AddVertex(new Vector3(-0.25f, 0.25f, 0.0f), Vector3.UnitY, new Vector2(1, 0));
sprite.AddVertex(new Vector3(-0.25f, -0.25f, 0.0f), Vector3.UnitY, new Vector2(1, 1));
sprite.IndexBuffer.Initialise();
sprite.VertexBuffer.Initialise();
sprite.Material = new Material {
Name = "Entity.Asset", Texture = SceneManager.Current.Content.Load <Texture, PNGImporter>(IconFilename)
};
sprite.PrimitiveType = PrimitiveType.Quads;
ModelMesh spritemesh = new ModelMesh();
spritemesh.AddModelMeshPart(sprite);
Model spritemodel = new Model();
spritemodel.AddMesh(spritemesh);
asset = spritemodel;
}
if (Linked)
{
Matrix4D parentTransform = ((ModelBone)Link).CombinedTransform;
if (LinkType == LinkType.All)
{
Transform = parentTransform;
}
else
{
Transform = Matrix4D.Identity;
Vector3 v = parentTransform.ExtractTranslation();
parentTransform.Normalise();
parentTransform.M41 = v.X;
parentTransform.M42 = v.Y;
parentTransform.M43 = v.Z;
if (LinkType.HasFlag(LinkType.Rotation))
{
Transform *= Matrix4D.CreateFromQuaternion(parentTransform.ExtractRotation());
}
if (LinkType.HasFlag(LinkType.Scale))
{
Transform *= Matrix4D.CreateScale(parentTransform.ExtractScale());
}
if (LinkType.HasFlag(LinkType.Position))
{
Transform *= Matrix4D.CreateTranslation(parentTransform.ExtractTranslation());
}
}
}
Matrix4D mS = SceneManager.Current.Transform;
Matrix4D mT = Transform;
SceneManager.Current.Renderer.PushMatrix();
Matrix4D position = Matrix4D.CreateTranslation(mT.ExtractTranslation());
SceneManager.Current.Renderer.MultMatrix(ref mS);
SceneManager.Current.Renderer.MultMatrix(ref position);
if (Lollipop)
{
Matrix4D rotation = ViewportManager.Current.Active.Camera.Rotation;
Matrix4D scale = Matrix4D.CreateScale(0.1f);
SceneManager.Current.Renderer.MultMatrix(ref rotation);
SceneManager.Current.Renderer.MultMatrix(ref scale);
}
SceneManager.Current.Renderer.Enable("Blend");
SceneManager.Current.Renderer.BlendFunc("SrcAlpha", "OneMinusSrcAlpha");
((Model)asset).Draw();
SceneManager.Current.Renderer.Disable("Blend");
SceneManager.Current.Renderer.PopMatrix();
}
public override Asset Import(string path)
{
FBX fbx = FBX.Load(path);
Model model = new Model();
Dictionary <long, object> components = new Dictionary <long, object>();
Dictionary <long, Matrix4D> transforms = new Dictionary <long, Matrix4D>();
Dictionary <long, string> triangulationErrors = new Dictionary <long, string>();
string name = Path.GetFileNameWithoutExtension(path);
if (fbx == null)
{
SceneManager.Current.RaiseError($"File \"{name}\" could not be opened. Please ensure this is a binary FBX file.");
return(null);
}
FBXElem objects = fbx.Elements.Find(e => e.ID == "Objects");
Matrix4D worldMatrix = createTransformFor(fbx.Elements.Find(e => e.ID == "GlobalSettings").Children[1], out Quaternion.RotationOrder order);
foreach (FBXElem material in objects.Children.Where(e => e.ID == "Material"))
{
string matName = material.Properties[1].Value.ToString();
matName = matName.Substring(0, matName.IndexOf("::"));
Material m = new Material {
Name = matName
};
components.Add((long)material.Properties[0].Value, m);
Console.WriteLine($"Added material \"{matName}\" ({material.Properties[0].Value})");
}
foreach (FBXElem video in objects.Children.Where(e => e.ID == "Video"))
{
FBXElem content = video.Children.Find(e => e.ID == "Content");
if (content.Properties[0].Size > 4)
{
components.Add((long)video.Properties[0].Value, (byte[])content.Properties[0].Value);
}
}
IEnumerable <FBXElem> textures = objects.Children.Where(e => e.ID == "Texture");
foreach (FBXElem texture in textures)
{
string fullFile = texture.Children.Find(e => e.ID == "FileName").Properties[0].Value.ToString();
if (fullFile.IndexOf('.') == -1)
{
continue;
}
string file = Path.GetFileName(fullFile);
Texture t = new Texture();
long videoKey = (long)fbx.Elements.Find(e => e.ID == "Connections").Children.Where(c => (long)c.Properties[2].Value == (long)texture.Properties[0].Value).First().Properties[1].Value;
if (components.ContainsKey(videoKey))
{
using (FileStream fs = new FileStream(Path.Combine(Path.GetDirectoryName(path), file), FileMode.Create))
using (BinaryWriter bw = new BinaryWriter(fs))
{
bw.Write((byte[])components[videoKey]);
}
}
t = SceneManager.Current.Content.Load(Path.GetFileName(file));
switch (fbx.Elements.Find(e => e.ID == "Connections").Children.Where(c => (long)c.Properties[1].Value == (long)texture.Properties[0].Value).First().Properties.Last().Value.ToString())
{
case "NormalMap":
t.Type = Texture.TextureType.Normal;
break;
case "SpecularColor":
t.Type = Texture.TextureType.Specular;
break;
}
if (!components.ContainsKey((long)texture.Properties[0].Value))
{
components.Add((long)texture.Properties[0].Value, t);
Console.WriteLine($"Added texture \"{file}\" ({texture.Properties[0].Value})");
}
}
foreach (FBXElem element in objects.Children.Where(e => e.ID == "Model"))
{
string modelName = element.Properties[1].Value.ToString();
modelName = modelName.Substring(0, modelName.IndexOf("::"));
components.Add((long)element.Properties[0].Value, new ModelMesh {
Name = modelName, Tag = (long)element.Properties[0].Value
});
Console.WriteLine("Added model \"{0}\" ({1})", modelName, element.Properties[0].Value);
FBXElem properties = element.Children.Find(c => c.ID == "Properties70");
Matrix4D m = Matrix4D.Identity;
bool bRotationActive = false;
Vector3 lclTranslation = Vector3.Zero;
Quaternion lclRotation = Quaternion.Identity;
Quaternion preRotation = Quaternion.Identity;
Quaternion postRotation = Quaternion.Identity;
Vector3 rotationPivot = Vector3.Zero;
Vector3 rotationOffset = Vector3.Zero;
Vector3 lclScaling = Vector3.One;
Vector3 scalingPivot = Vector3.Zero;
Vector3 scalingOffset = Vector3.Zero;
Vector3 geoPosition = Vector3.Zero;
Quaternion geoRotation = Quaternion.Identity;
Vector3 geoScale = Vector3.One;
FBXElem property;
property = properties.Children.GetProperty("RotationActive");
if (property != null)
{
bRotationActive = ((int)property.Properties[4].Value == 1);
}
property = properties.Children.GetProperty("ScalingPivot");
if (property != null)
{
scalingPivot = new Vector3(
Convert.ToSingle(property.Properties[4].Value),
Convert.ToSingle(property.Properties[5].Value),
Convert.ToSingle(property.Properties[6].Value)
);
}
property = properties.Children.GetProperty("Lcl Scaling");
if (property != null)
{
lclScaling = new Vector3(
Convert.ToSingle(property.Properties[4].Value),
Convert.ToSingle(property.Properties[5].Value),
Convert.ToSingle(property.Properties[6].Value)
);
}
property = properties.Children.GetProperty("ScalingOffset");
if (property != null)
{
scalingOffset = new Vector3(
Convert.ToSingle(property.Properties[4].Value),
Convert.ToSingle(property.Properties[5].Value),
Convert.ToSingle(property.Properties[6].Value)
);
}
property = properties.Children.GetProperty("RotationPivot");
if (property != null)
{
rotationPivot = new Vector3(
Convert.ToSingle(property.Properties[4].Value),
Convert.ToSingle(property.Properties[5].Value),
Convert.ToSingle(property.Properties[6].Value)
);
}
property = properties.Children.GetProperty("PostRotation");
if (property != null)
{
postRotation = MakeQuaternion(
Convert.ToSingle(property.Properties[4].Value),
Convert.ToSingle(property.Properties[5].Value),
Convert.ToSingle(property.Properties[6].Value),
order
);
}
property = properties.Children.GetProperty("Lcl Rotation");
if (property != null)
{
lclRotation = MakeQuaternion(
Convert.ToSingle(property.Properties[4].Value),
Convert.ToSingle(property.Properties[5].Value),
Convert.ToSingle(property.Properties[6].Value),
order
);
}
property = properties.Children.GetProperty("PreRotation");
if (property != null)
{
preRotation = MakeQuaternion(
Convert.ToSingle(property.Properties[4].Value),
Convert.ToSingle(property.Properties[5].Value),
Convert.ToSingle(property.Properties[6].Value),
order
);
}
property = properties.Children.GetProperty("RotationOffset");
if (property != null)
{
rotationOffset = new Vector3(
Convert.ToSingle(property.Properties[4].Value),
Convert.ToSingle(property.Properties[5].Value),
Convert.ToSingle(property.Properties[6].Value)
);
}
property = properties.Children.GetProperty("Lcl Translation");
if (property != null)
{
lclTranslation = new Vector3(
Convert.ToSingle(property.Properties[4].Value),
Convert.ToSingle(property.Properties[5].Value),
Convert.ToSingle(property.Properties[6].Value)
);
}
property = properties.Children.GetProperty("GeometricTranslation");
if (property != null)
{
geoPosition = new Vector3(
Convert.ToSingle(property.Properties[4].Value),
Convert.ToSingle(property.Properties[5].Value),
Convert.ToSingle(property.Properties[6].Value)
);
}
property = properties.Children.GetProperty("GeometricRotation");
if (property != null)
{
geoRotation = MakeQuaternion(
Convert.ToSingle(property.Properties[4].Value),
Convert.ToSingle(property.Properties[5].Value),
Convert.ToSingle(property.Properties[6].Value),
order
);
}
property = properties.Children.GetProperty("GeometricScaling");
if (property != null)
{
geoScale = new Vector3(
Convert.ToSingle(property.Properties[4].Value),
Convert.ToSingle(property.Properties[5].Value),
Convert.ToSingle(property.Properties[6].Value)
);
}
m =
Matrix4D.CreateTranslation(scalingPivot).Inverted() *
Matrix4D.CreateScale(lclScaling) *
Matrix4D.CreateTranslation(scalingPivot) *
Matrix4D.CreateTranslation(scalingOffset) *
Matrix4D.CreateTranslation(rotationPivot).Inverted() *
Matrix4D.CreateFromQuaternion(postRotation) *
Matrix4D.CreateFromQuaternion(lclRotation) *
Matrix4D.CreateFromQuaternion(preRotation) *
Matrix4D.CreateTranslation(rotationPivot) *
Matrix4D.CreateTranslation(rotationOffset) *
Matrix4D.CreateTranslation(lclTranslation);
if (m != Matrix4D.Identity)
{
transforms.Add((long)element.Properties[0].Value, m);
}
}
foreach (FBXElem element in objects.Children.Where(e => e.ID == "Geometry"))
{
bool bUVs = true;
bool bNorms = true;
bool bColours = true;
bool bUseIndexNorm = false;
bool bNeedsTriangulating = false;
string geometryName = element.Properties[1].Value.ToString();
geometryName = geometryName.Substring(0, geometryName.IndexOf("::"));
List <Vector3> verts = new List <Vector3>();
List <Vector3> norms = new List <Vector3>();
List <Vector2> uvs = new List <Vector2>();
List <Colour> colours = new List <Colour>();
double[] vertParts = (double[])element.Children.Find(e => e.ID == "Vertices").Properties[0].Value;
for (int i = 0; i < vertParts.Length; i += 3)
{
verts.Add(new Vector3((float)vertParts[i + 0], (float)vertParts[i + 1], (float)vertParts[i + 2]));
}
SceneManager.Current.UpdateProgress($"Processed {element.Properties[1].Value}->Vertices");
FBXElem normElem = element.Children.Find(e => e.ID == "LayerElementNormal");
if (normElem != null)
{
double[] normParts = (double[])normElem.Children.Find(e => e.ID == "Normals").Properties[0].Value;
for (int i = 0; i < normParts.Length; i += 3)
{
norms.Add(new Vector3((float)normParts[i + 0], (float)normParts[i + 1], (float)normParts[i + 2]));
}
bUseIndexNorm = (normElem.Children.Find(e => e.ID == "MappingInformationType").Properties[0].Value.ToString() == "ByVertice");
SceneManager.Current.UpdateProgress($"Processed {element.Properties[1].Value}->Normals");
}
else
{
bNorms = false;
}
FBXElem colourElem = element.Children.Find(e => e.ID == "LayerElementColor");
if (colourElem != null)
{
double[] colourParts = (double[])colourElem.Children.Find(e => e.ID == "Colors").Properties[0].Value;
FBXElem colourReferenceType = colourElem.Children.Find(e => e.ID == "ReferenceInformationType");
switch (colourReferenceType.Properties[0].Value.ToString())
{
case "IndexToDirect":
int[] colourIndicies = (int[])colourElem.Children.Find(e => e.ID == "ColorIndex").Properties[0].Value;
for (int i = 0; i < colourIndicies.Length; i++)
{
int offset = colourIndicies[i] * 4;
colours.Add(new Colour(
(float)colourParts[offset + 0],
(float)colourParts[offset + 1],
(float)colourParts[offset + 2],
(float)colourParts[offset + 3])
);
}
break;
case "Direct":
bColours = false;
break;
default:
throw new NotImplementedException($"Unsupported Colour Reference Type: {colourReferenceType.Properties[0].Value}");
}
SceneManager.Current.UpdateProgress($"Processed {element.Properties[1].Value}->Colours");
}
else
{
bColours = false;
}
FBXElem uvElem = element.Children.Find(e => e.ID == "LayerElementUV");
if (uvElem != null)
{
double[] uvParts = (double[])uvElem.Children.Find(e => e.ID == "UV").Properties[0].Value;
FBXElem uvReferenceType = uvElem.Children.Find(e => e.ID == "ReferenceInformationType");
if (uvReferenceType.Properties[0].Value.ToString() == "IndexToDirect")
{
List <Vector2> luvs = new List <Vector2>();
for (int i = 0; i < uvParts.Length; i += 2)
{
luvs.Add(new Vector2((float)uvParts[i + 0], 1 - (float)uvParts[i + 1]));
}
int[] uvindicies = (int[])uvElem.Children.Find(e => e.ID == "UVIndex").Properties[0].Value;
for (int i = 0; i < uvindicies.Length; i++)
{
if (uvindicies[i] == -1)
{
uvs.Add(Vector2.Zero);
}
else
{
uvs.Add(luvs[uvindicies[i]]);
}
}
}
else
{
for (int i = 0; i < uvParts.Length; i += 2)
{
uvs.Add(new Vector2((float)uvParts[i + 0], (float)uvParts[i + 1]));
}
}
SceneManager.Current.UpdateProgress($"Processed {element.Properties[1].Value}->UVs");
}
else
{
bUVs = false;
}
int[] indicies = (int[])element.Children.Find(e => e.ID == "PolygonVertexIndex").Properties[0].Value;
List <FBXFace> faces = new List <FBXFace>();
FBXFace face = new FBXFace();
int j = 0;
for (int i = 0; i < indicies.Length; i++)
{
bool bFace = false;
int index = indicies[i];
if (index < 0)
{
bFace = true;
index = (index * -1) - 1;
}
j++;
face.AddVertex(verts[index], bNorms ? norms[bUseIndexNorm ? index : i] : Vector3.Zero, bUVs ? uvs[i] : Vector2.Zero, bColours ? colours[i] : Colour.White);
if (bFace)
{
if (j > 3)
{
triangulationErrors.Add((long)element.Properties[0].Value, geometryName);
bNeedsTriangulating = true;
break;
}
faces.Add(face);
face = new FBXFace();
j = 0;
}
}
List <ModelMeshPart> parts = new List <ModelMeshPart>();
if (!bNeedsTriangulating)
{
SceneManager.Current.UpdateProgress($"Processed {element.Properties[1].Value}->Faces");
FBXElem elemMaterial = element.Children.Find(e => e.ID == "LayerElementMaterial");
if (elemMaterial != null)
{
int[] faceMaterials = (int[])elemMaterial.Children.Find(e => e.ID == "Materials").Properties[0].Value;
for (int i = 0; i < faceMaterials.Length; i++)
{
faces[i].MaterialID = faceMaterials[i];
}
SceneManager.Current.UpdateProgress($"Processed {element.Properties[1].Value}->Materials");
}
IEnumerable <IGrouping <int, FBXFace> > materialGroups = faces.GroupBy(f => f.MaterialID);
int processedFaceCount = 0,
processedGroupCount = 0;
foreach (IGrouping <int, FBXFace> materialGroup in materialGroups)
{
IEnumerable <IGrouping <int, FBXFace> > smoothingGroups = materialGroup.GroupBy(f => f.SmoothingGroup);
foreach (IGrouping <int, FBXFace> smoothingGroup in smoothingGroups)
{
ModelMeshPart meshpart = new ModelMeshPart {
PrimitiveType = Flummery.Core.PrimitiveType.Triangles
};
processedFaceCount = 0;
foreach (FBXFace groupface in smoothingGroup)
{
foreach (Vertex vert in groupface.Vertices)
{
meshpart.AddVertex(vert.Position, vert.Normal, vert.UV, vert.Colour);
}
processedFaceCount++;
if (processedFaceCount % 250 == 0)
{
SceneManager.Current.UpdateProgress($"Processed {element.Properties[1].Value}->MeshPart[{processedGroupCount}]->Face[{processedFaceCount}]");
}
}
meshpart.Key = materialGroup.Key;
parts.Add(meshpart);
SceneManager.Current.UpdateProgress($"Processed {element.Properties[1].Value}->MeshPart");
processedGroupCount++;
}
}
}
components.Add((long)element.Properties[0].Value, parts);
SceneManager.Current.UpdateProgress($"Processed {element.Properties[1].Value}");
}
Dictionary <long, BoneType> nodeAttributes = new Dictionary <long, BoneType>();
Dictionary <long, object> nodeAttachments = new Dictionary <long, object>();
foreach (FBXElem nodeAttribute in objects.Children.Where(e => e.ID == "NodeAttribute"))
{
FBXElem typeFlags = nodeAttribute.Children.Find(e => e.ID == "TypeFlags");
if (typeFlags != null)
{
switch (typeFlags.Properties[0].Value.ToString().ToLower())
{
case "light":
LIGHT light = new LIGHT();
FBXElem lightType = nodeAttribute.Children.Find(c => c.ID == "Properties70").Children.GetProperty("LightType");
light.Type = (LIGHT.LightType)(lightType == null ? 0 : lightType.Properties[4].Value);
nodeAttributes.Add((long)nodeAttribute.Properties[0].Value, BoneType.Light);
nodeAttachments.Add((long)nodeAttribute.Properties[0].Value, light);
break;
default:
// null node
break;
}
}
}
string[] connectionOrder = new string[] { "System.Collections.Generic.List`1[Flummery.Core.ModelMeshPart]", "Flummery.Core.Texture", "Flummery.Core.Material", "Flummery.Core.ModelMesh" };
FBXElem connections = fbx.Elements.Find(e => e.ID == "Connections");
HashSet <long> loaded = new HashSet <long>();
foreach (string connectionType in connectionOrder)
{
IEnumerable <FBXElem> connectionsOfType = connections.Children.Where(c => components.ContainsKey((long)c.Properties[1].Value) && components[(long)c.Properties[1].Value].GetType().ToString() == connectionType);
foreach (FBXElem connection in connectionsOfType)
{
long keyA = (long)connection.Properties[1].Value;
long keyB = (long)connection.Properties[2].Value;
Console.WriteLine("{0} is connected to {1} :: {2}", keyA, keyB, connectionType);
switch (connectionType)
{
case "Flummery.Core.ModelMesh":
int boneID;
if (keyB == 0)
{
boneID = model.AddMesh((ModelMesh)components[keyA]);
model.SetName(((ModelMesh)components[keyA]).Name, boneID);
if (transforms.ContainsKey(keyA))
{
model.SetTransform(transforms[keyA], boneID);
}
FBXElem attribute = connections.Children.FirstOrDefault(c => nodeAttributes.ContainsKey((long)c.Properties[1].Value) && (long)c.Properties[2].Value == keyA);
if (attribute != null)
{
keyA = (long)attribute.Properties[1].Value;
if (nodeAttributes.ContainsKey(keyA))
{
model.Bones[boneID].Type = nodeAttributes[keyA];
}
if (nodeAttachments.ContainsKey(keyA))
{
model.Bones[boneID].Attachment = nodeAttachments[keyA];
}
}
}
else
{
ModelMesh parent = model.FindMesh(keyB);
if (parent != null)
{
boneID = model.AddMesh((ModelMesh)components[keyA], parent.Parent.Index);
model.SetName(((ModelMesh)components[keyA]).Name, boneID);
if (transforms.ContainsKey(keyA))
{
model.SetTransform(transforms[keyA], boneID);
}
}
else
{
if (!components.ContainsKey(keyB))
{
Console.WriteLine("Components doesn't contain {0}", keyB);
}
else
{
Console.WriteLine("Couldn't find {0}", ((ModelMesh)components[keyB]).Name);
}
}
}
break;
case "Flummery.Core.Texture":
if (components.ContainsKey(keyB) && components[keyB].GetType().ToString() == "Flummery.Core.Material")
{
if (loaded.Add(keyA))
{
((Material)components[keyB]).Texture = (Texture)components[keyA];
//SceneManager.Current.Add((Material)components[keyB]);
}
}
else
{
Console.WriteLine("{0} is of unknown type {1}", keyA, components[keyA].GetType().ToString());
Console.WriteLine("{0} is of unknown type {1}", keyB, components[keyB].GetType().ToString());
}
break;
case "System.Collections.Generic.List`1[Flummery.Core.ModelMeshPart]":
if (components.ContainsKey(keyB) && components[keyB].GetType().ToString() == "Flummery.Core.ModelMesh")
{
if (triangulationErrors.ContainsKey(keyA))
{
triangulationErrors[keyA] += " (geometry of " + ((ModelMesh)components[keyB]).Name + ")";
}
foreach (ModelMeshPart part in (List <ModelMeshPart>)components[keyA])
{
((ModelMesh)components[keyB]).AddModelMeshPart(part);
}
}
break;
case "Flummery.Core.Material":
if (components.ContainsKey(keyB) && components[keyB].GetType().ToString() == "Flummery.Core.ModelMesh")
{
List <FBXElem> materialLookup = connections.Children.Where(c => (long)c.Properties[2].Value == keyB).ToList();
for (int i = materialLookup.Count - 1; i > -1; i--)
{
if (!connectionsOfType.Any(c => (long)c.Properties[1].Value == (long)materialLookup[i].Properties[1].Value))
{
materialLookup.RemoveAt(i);
}
}
foreach (ModelMeshPart part in ((ModelMesh)components[keyB]).MeshParts)
{
if ((long)materialLookup[(int)part.Key].Properties[1].Value == keyA)
{
part.Material = (Material)components[keyA];
SceneManager.Current.Add(part.Material);
}
}
}
break;
default:
Console.WriteLine("{0} is of unknown type {1}", keyA, components[keyA].GetType().ToString());
if (components.ContainsKey(keyB))
{
Console.WriteLine("{0} is of unknown type {1}", keyB, components[keyB].GetType().ToString());
}
Console.WriteLine("===");
break;
}
}
}
if (triangulationErrors.Count > 0)
{
SceneManager.Current.UpdateProgress($"Failed to load {name}");
string error = $"File \"{name}\" has part{(triangulationErrors.Count > 1 ? "s" : "")} that need been triangulating! Please triangulate the following:";
foreach (KeyValuePair <long, string> kvp in triangulationErrors)
{
error += $"\r\n{kvp.Value}";
}
SceneManager.Current.RaiseError(error);
return(null);
}
else
{
SceneManager.Current.UpdateProgress($"Loaded {name}");
model.Santise();
//if (worldMatrix != Matrix4D.Identity) { ModelManipulator.Freeze(model, worldMatrix); }
ModelManipulator.FlipAxis(model, Axis.Z, true);
return(model);
}
}