public void LoadFile(string FileName)
{
try
{
AssimpContext Importer = new AssimpContext();
STConsole.WriteLine($"Loading File {FileName}", Color.FromArgb(0, 255, 0));
var Flags = PostProcessSteps.Triangulate;
Flags |= PostProcessSteps.JoinIdenticalVertices;
Flags |= PostProcessSteps.FlipUVs;
Flags |= PostProcessSteps.LimitBoneWeights;
Flags |= PostProcessSteps.CalculateTangentSpace;
Flags |= PostProcessSteps.GenerateNormals;
scene = Importer.ImportFile(FileName, Flags);
LoadScene();
}
catch (Exception e)
{
if (e.ToString().Contains("Error loading unmanaged library from path"))
{
MessageBox.Show($"Failed to load assimp! Make sure you have Assimp32.dll next to the program!");
}
Console.WriteLine(e);
}
}
private void BuildNode(Node parent, ref Matrix4x4 rootTransform)
{
Matrix4x4 world = rootTransform;
Matrix4 worldTK = Matrix4.Identity;
if (UseTransformMatrix)
{
Matrix4x4 trafo = parent.Transform;
world = trafo * rootTransform;
worldTK = AssimpHelper.TKMatrix(world);
}
if (parent.MeshCount > 0)
{
STConsole.WriteLine($"Use Transform Matrix {UseTransformMatrix}");
STConsole.WriteLine($"Transform node {parent.Name}");
STConsole.WriteLine($"Translation {worldTK.ExtractTranslation()}");
STConsole.WriteLine($"Rotation {worldTK.ExtractRotation()}");
STConsole.WriteLine($"Scale {worldTK.ExtractScale()}");
}
foreach (int index in parent.MeshIndices)
{
objects.Add(CreateGenericObject(scene.Meshes[index], index, worldTK));
}
foreach (Node child in parent.Children)
{
BuildNode(child, ref world);
}
}
public void SetEntry(string FileName, byte[] Data = null, bool IsYaz0Compressed = false, bool Force = false)
{
uint OldSize = GetSize(FileName);
uint NewSize = (uint)ParseSize(FileName, Data, IsYaz0Compressed, Force);
STConsole.WriteLine($"Setting RSTB Entry!");
STConsole.WriteLine($"{FileName} OldSize {OldSize}");
STConsole.WriteLine($"{FileName} NewSize {NewSize}");
SetSize(FileName, NewSize);
}
private STGenericMatTexture CreateTextureSlot(TextureSlot tex, TextureType type)
{
var matTex = new STGenericMatTexture();
switch (type)
{
case TextureType.Diffuse:
matTex.Type = STGenericMatTexture.TextureType.Diffuse;
break;
case TextureType.Normals:
matTex.Type = STGenericMatTexture.TextureType.Normal;
break;
case TextureType.Lightmap:
matTex.Type = STGenericMatTexture.TextureType.Light;
break;
case TextureType.Emissive:
matTex.Type = STGenericMatTexture.TextureType.Emission;
break;
case TextureType.Specular:
matTex.Type = STGenericMatTexture.TextureType.Specular;
break;
case TextureType.Shininess:
matTex.Type = STGenericMatTexture.TextureType.Metalness;
break;
case TextureType.Opacity:
matTex.Type = STGenericMatTexture.TextureType.Transparency;
break;
case TextureType.Displacement:
break;
default:
matTex.Type = STGenericMatTexture.TextureType.Unknown;
break;
}
matTex.Name = System.IO.Path.GetFileNameWithoutExtension(tex.FilePath);
matTex.wrapModeS = SetWrapMode(tex.WrapModeU);
matTex.wrapModeT = SetWrapMode(tex.WrapModeV);
STConsole.WriteLine($"Getting assimp texture slot {matTex.Name} Type {matTex.Type}");
return(matTex);
}
public static Animations.Animation[] ImportAnimations(string FileName)
{
AssimpContext Importer = new AssimpContext();
STConsole.WriteLine($"Loading File {FileName}", Color.FromArgb(0, 255, 0));
var scene = Importer.ImportFile(FileName);
List <Animations.Animation> Anims = new List <Animations.Animation>();
foreach (var anim in scene.Animations)
{
Anims.Add(CreateGenericAnimation(anim));
}
return(Anims.ToArray());
}
public bool LoadFile(string FileName)
{
try
{
var settings = new Assimp_Settings();
if (settings.ShowDialog() == DialogResult.OK)
{
UseTransformMatrix = settings.UseNodeTransform;
RotateSkeleton = settings.RotateSkeleton;
RotateSkeletonAmount = settings.RotateSkeletonAmount;
AssimpContext Importer = new AssimpContext();
STConsole.WriteLine($"Loading File {FileName}", Color.FromArgb(0, 255, 0));
/* var Flags = PostProcessSteps.Triangulate;
* Flags |= PostProcessSteps.JoinIdenticalVertices;
* Flags |= PostProcessSteps.FlipUVs;
* Flags |= PostProcessSteps.LimitBoneWeights;
* Flags |= PostProcessSteps.CalculateTangentSpace;
* Flags |= PostProcessSteps.GenerateNormals;*/
scene = Importer.ImportFile(FileName, settings.GetFlags());
LoadScene();
return(true);
}
return(false);
}
catch (Exception e)
{
if (e.ToString().Contains("Error loading unmanaged library from path"))
{
MessageBox.Show($"Failed to load assimp! Make sure you have Assimp32.dll next to the program!");
}
else
{
MessageBox.Show($"{e.ToString()}");
}
return(false);
}
}
public void processNode()
{
Console.WriteLine($"Mesh Count " + scene.MeshCount);
Matrix4x4 identity = Matrix4x4.Identity;
if (scene.RootNode != null)
{
BuildNode(scene.RootNode, ref identity);
Console.WriteLine($"BuildNode Mesh Count " + scene.MeshCount);
}
else
{
STConsole.WriteLine("No root node found! Will default to Idenity Matrix!", Color.Red);
int Index = 0;
foreach (Mesh msh in scene.Meshes)
{
objects.Add(CreateGenericObject(msh, Index, Matrix4.Identity));
Index++;
}
}
}
private void CreateByNode(Node node, STSkeleton skeleton, short SmoothIndex, short RigidIndex, bool IsRoot, ref Assimp.Matrix4x4 rootTransform)
{
Matrix4x4 trafo = node.Transform;
Matrix4x4 world = trafo * rootTransform;
var transformMat = AssimpHelper.TKMatrix(world);
int matchedBoneIndex = skeleton.bones.FindIndex(item => item.Name == node.Name);
if (matchedBoneIndex < 0)
{
tempBoneNodes.Add(node);
STBone bone = new STBone();
bone.skeletonParent = skeleton;
skeleton.bones.Add(bone);
bone.Text = node.Name;
bone.SmoothMatrixIndex = (short)skeleton.bones.IndexOf(bone);
bone.RigidMatrixIndex = -1; //Todo calculate these
STConsole.WriteLine($"-".Repeat(30));
STConsole.WriteLine($"Processing Bone {bone.Text}");
STConsole.WriteLine($"SmoothMatrixIndex {bone.SmoothMatrixIndex}");
STConsole.WriteLine($"RigidMatrixIndex {bone.RigidMatrixIndex}");
STConsole.WriteLine($"Transform Matrix {transformMat}");
STConsole.WriteLine($"-".Repeat(30));
if (IsRoot)
{
bone.parentIndex = -1;
transformMat = AssimpHelper.TKMatrix(world * Matrix4x4.FromRotationX(MathHelper.DegreesToRadians(BoneRotation)));
}
else
{
if (tempBoneNodes.Contains(node.Parent))
{
bone.parentIndex = tempBoneNodes.IndexOf(node.Parent);
}
}
var scale = transformMat.ExtractScale();
var rotation = transformMat.ExtractRotation();
var position = transformMat.ExtractTranslation();
var rotEular = AssimpHelper.ToEular(rotation);
bone.position = new float[] { position.X, position.Y, position.Z };
bone.scale = new float[] { scale.X, scale.Y, scale.Z };
bone.rotation = new float[] { rotEular.X, rotEular.Y, rotEular.Z, 0 };
}
else
{
STConsole.WriteLine($"Duplicate node name found for bone {node.Name}!", Color.Red);
}
foreach (Node child in node.Children)
{
CreateByNode(child, skeleton, SmoothIndex, RigidIndex, false, ref rootTransform);
}
}
public List <Vertex> GetVertices(Mesh msh, Matrix4 transform, STGenericObject STobj)
{
Matrix4 NormalsTransform = Matrix4.CreateFromQuaternion(transform.ExtractRotation());
List <Vertex> vertices = new List <Vertex>();
for (int v = 0; v < msh.VertexCount; v++)
{
Vertex vert = new Vertex();
if (msh.HasVertices)
{
vert.pos = Vector3.TransformPosition(AssimpHelper.FromVector(msh.Vertices[v]), transform);
}
if (msh.HasNormals)
{
vert.nrm = Vector3.TransformNormal(AssimpHelper.FromVector(msh.Normals[v]), NormalsTransform);
}
if (msh.HasTextureCoords(0))
{
vert.uv0 = new Vector2(msh.TextureCoordinateChannels[0][v].X, msh.TextureCoordinateChannels[0][v].Y);
}
if (msh.HasTextureCoords(1))
{
vert.uv1 = new Vector2(msh.TextureCoordinateChannels[1][v].X, msh.TextureCoordinateChannels[1][v].Y);
}
if (msh.HasTextureCoords(2))
{
vert.uv2 = new Vector2(msh.TextureCoordinateChannels[2][v].X, msh.TextureCoordinateChannels[2][v].Y);
}
if (msh.HasTangentBasis)
{
vert.tan = new Vector4(msh.Tangents[v].X, msh.Tangents[v].Y, msh.Tangents[v].Z, 1);
}
if (msh.HasVertexColors(0))
{
vert.col = new Vector4(msh.VertexColorChannels[0][v].R, msh.VertexColorChannels[0][v].G, msh.VertexColorChannels[0][v].B, msh.VertexColorChannels[0][v].A);
Console.WriteLine("VTX Col " + vert.col);
}
if (msh.HasTangentBasis)
{
vert.bitan = new Vector4(msh.BiTangents[v].X, msh.BiTangents[v].Y, msh.BiTangents[v].Z, 1);
}
vertices.Add(vert);
}
if (msh.HasBones)
{
STConsole.WriteLine(msh.Name + " HasBones " + msh.HasBones);
STConsole.WriteLine(msh.Name + " BoneCount " + msh.BoneCount);
for (int i = 0; i < msh.BoneCount; i++)
{
Bone bn = msh.Bones[i];
if (bn.HasVertexWeights)
{
foreach (VertexWeight w in bn.VertexWeights)
{
vertices[w.VertexID].boneWeights.Add(w.Weight);
vertices[w.VertexID].boneNames.Add(bn.Name);
BoneNames.Add(bn.Name);
}
}
}
}
return(vertices);
}
public static Animations.Animation CreateGenericAnimation(Assimp.Animation animation)
{
Animations.Animation STanim = new Animations.Animation();
STanim.Text = animation.Name;
float TicksPerSecond = animation.TicksPerSecond != 0 ? (float)animation.TicksPerSecond : 25.0f;
float Duriation = (float)animation.DurationInTicks;
STanim.FrameCount = (int)(Duriation * 30);
//Load node animations
if (animation.HasNodeAnimations)
{
var _channels = new NodeAnimationChannel[animation.NodeAnimationChannelCount];
for (int i = 0; i < _channels.Length; i++)
{
_channels[i] = new NodeAnimationChannel();
var boneAnim = new Animations.Animation.KeyNode(_channels[i].NodeName);
boneAnim.RotType = Animations.Animation.RotationType.EULER;
STanim.Bones.Add(boneAnim);
STConsole.WriteLine($"Creating Bone Anims {boneAnim.Text} ");
for (int frame = 0; frame < STanim.FrameCount; i++)
{
if (_channels[i].HasPositionKeys)
{
for (int key = 0; key < _channels[i].PositionKeyCount; key++)
{
if (frame == _channels[i].PositionKeys[key].Time)
{
boneAnim.XPOS.Keys.Add(new Animations.Animation.KeyFrame()
{
Value = _channels[i].PositionKeys[key].Value.X,
Frame = frame,
});
boneAnim.YPOS.Keys.Add(new Animations.Animation.KeyFrame()
{
Value = _channels[i].PositionKeys[key].Value.Y,
Frame = frame,
});
boneAnim.ZPOS.Keys.Add(new Animations.Animation.KeyFrame()
{
Value = _channels[i].PositionKeys[key].Value.Z,
Frame = frame,
});
}
}
}
if (_channels[i].HasRotationKeys)
{
for (int key = 0; key < _channels[i].RotationKeyCount; key++)
{
if (frame == _channels[i].RotationKeys[key].Time)
{
var quat = _channels[i].RotationKeys[key].Value;
var euler = STMath.ToEulerAngles(quat.X, quat.Y, quat.Z, quat.W);
boneAnim.XROT.Keys.Add(new Animations.Animation.KeyFrame()
{
Value = euler.X,
Frame = frame,
});
boneAnim.YROT.Keys.Add(new Animations.Animation.KeyFrame()
{
Value = euler.Y,
Frame = frame,
});
boneAnim.ZROT.Keys.Add(new Animations.Animation.KeyFrame()
{
Value = euler.Z,
Frame = frame,
});
boneAnim.WROT.Keys.Add(new Animations.Animation.KeyFrame()
{
Value = 1,
Frame = frame,
});
}
}
}
if (_channels[i].HasScalingKeys)
{
for (int key = 0; key < _channels[i].ScalingKeyCount; key++)
{
if (frame == _channels[i].ScalingKeys[key].Time)
{
boneAnim.XSCA.Keys.Add(new Animations.Animation.KeyFrame()
{
Value = _channels[i].ScalingKeys[key].Value.X,
Frame = frame,
});
boneAnim.YSCA.Keys.Add(new Animations.Animation.KeyFrame()
{
Value = _channels[i].ScalingKeys[key].Value.Y,
Frame = frame,
});
boneAnim.ZSCA.Keys.Add(new Animations.Animation.KeyFrame()
{
Value = _channels[i].ScalingKeys[key].Value.Z,
Frame = frame,
});
}
}
}
}
}
}
//Load mesh animations
if (animation.HasMeshAnimations)
{
var _meshChannels = new MeshAnimationChannel[animation.MeshAnimationChannelCount];
for (int i = 0; i < _meshChannels.Length; i++)
{
_meshChannels[i] = new MeshAnimationChannel();
}
}
return(STanim);
}