private void AssignMeshes(Assimp.Node node, GameObject parent)
{
if (node.MeshIndices.Count == 0)
{
return;
}
if (scene.Meshes[node.MeshIndices[0]].HasBones)
{
delayedMesh.Add(node, parent);
return;
}
Material[] mats = new Material[node.MeshIndices.Count];
CombineInstance[] combine = new CombineInstance[node.MeshIndices.Count];
int i = 0;
foreach (int indice in node.MeshIndices)
{
combine[i].mesh = meshes[indice].mesh;
combine[i].transform = Matrix4x4.identity;
mats[i] = materials[meshes[indice].materialIndex];
i++;
}
AddSimpleMesh(node, parent, mats, combine);
progress += (0.25f * node.MeshIndices.Count) / scene.MeshCount;
}
private void exportToAssimp(object sender, EventArgs e)
{
Debug.WriteLine("Exporting to assimp");
if (RenderState.rootObject != null)
{
Assimp.AssimpContext ctx = new Assimp.AssimpContext();
Dictionary <int, int> meshImportStatus = new Dictionary <int, int>();
Assimp.Scene aScene = new Assimp.Scene();
Assimp.Node rootNode = RenderState.rootObject.assimpExport(ref aScene, ref meshImportStatus);
aScene.RootNode = rootNode;
//add a single material for now
Assimp.Material aMat = new Assimp.Material();
aMat.Name = "testMaterial";
aScene.Materials.Add(aMat);
Assimp.ExportFormatDescription[] supported_formats = ctx.GetSupportedExportFormats();
//Assimp.Scene blenderScene = ctx.ImportFile("SimpleSkin.gltf");
//ctx.ExportFile(blenderScene, "SimpleSkin.glb", "glb2");
try
{
ctx.ExportFile(aScene, "test.glb", "glb2");
//ctx.ExportFile(aScene, "test.fbx", "fbx");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
private static int FindNodeIndex(Assimp.Node rootNode, string nodeName)
{
int targetId = 0;
bool GetTargetIdForNodeRecursive(Assimp.Node node)
{
if (node.Name == nodeName)
{
return(true);
}
++targetId;
foreach (var child in node.Children)
{
if (GetTargetIdForNodeRecursive(child))
{
return(true);
}
}
return(false);
}
if (GetTargetIdForNodeRecursive(rootNode))
{
return(targetId);
}
else
{
return(-1);
}
}
private void AssignMeshes(Assimp.Node node, GameObject parent)
{
if (node.MeshIndices.Count == 0)
{
return;
}
MeshFilter meshFilter = parent.AddComponent <MeshFilter>();
MeshRenderer meshRenderer = parent.AddComponent <MeshRenderer>();
Material[] mats = new Material[node.MeshIndices.Count];
CombineInstance[] combine = new CombineInstance[node.MeshIndices.Count];
int i = 0;
foreach (int indice in node.MeshIndices)
{
combine[i].mesh = meshes[indice].mesh;
combine[i].transform = Matrix4x4.identity;
mats[i] = materials[meshes[indice].materialIndex];
i++;
}
meshFilter.mesh = new Mesh();
meshFilter.mesh.CombineMeshes(combine, false);
meshFilter.name = meshes[node.MeshIndices[0]].name;
meshFilter.mesh.name = meshFilter.name;
meshRenderer.sharedMaterials = mats;
MeshCollider collider = parent.AddComponent <MeshCollider>();
progress += (0.25f * node.MeshIndices.Count) / scene.MeshCount;
}
private Bone CreateBoneTree(Assimp.Node node, Bone parent)
{
Bone internalNode = new Bone
{
Name = node.Name,
Parent = parent
};
if (internalNode.Name == "")
{
internalNode.Name = "foo" + _i++;
}
_bonesByName[internalNode.Name] = internalNode;
Assimp.Matrix4x4 trans = node.Transform;
// trans.Transpose();
internalNode.LocalTransform = ToTK(trans);
internalNode.OriginalLocalTransform = internalNode.LocalTransform;
CalculateBoneToWorldTransform(internalNode);
for (int i = 0; i < node.ChildCount; i++)
{
Bone child = CreateBoneTree(node.Children[i], internalNode);
if (child != null)
{
internalNode.Children.Add(child);
}
}
return(internalNode);
}
private NodeContent ParseNode(ModelContent model, Assimp.Node node, NodeContent parent = null)
{
NodeContent n = new NodeContent(parent);
model.Nodes.Add(n);
if (settings.TransformMesh)
{
Matrix matrix = ConvertMatrix(node.Transform);
matrix.M41 *= settings.Scale.X;
matrix.M42 *= settings.Scale.Y;
matrix.M43 *= settings.Scale.Z;
n.Transformation = matrix;
}
else
{
n.Transformation = Matrix.Identity;
}
n.Name = node.Name;
n.Meshes = new List <int>();
foreach (var meshIndex in node.MeshIndices)
{
n.Meshes.Add(meshIndex);
}
n.Children = new List <NodeContent>();
foreach (var child in node.Children)
{
n.Children.Add(ParseNode(model, child, n));
}
return(n);
}
public virtual Assimp.Node assimpExport(ref Assimp.Scene scn, ref Dictionary <int, int> meshImportStatus)
{
//Default shit
//Create assimp node
Assimp.Node node = new Assimp.Node(Name);
node.Transform = MathUtils.convertMatrix(localMat);
//Handle animations maybe?
int animComponentId = hasComponent(typeof(AnimComponent));
if (animComponentId > -1)
{
AnimComponent cmp = (AnimComponent)_components[animComponentId];
cmp.assimpExport(ref scn);
}
foreach (Model child in children)
{
Assimp.Node c = child.assimpExport(ref scn, ref meshImportStatus);
node.Children.Add(c);
}
return(node);
}
internal static void CopyNodesWithMeshes(Assimp.Scene pScene, Assimp.Node node, ref List <SceneObject> meshArr)
{
// if node has meshes, create a new scene object for it
if (node.HasMeshes)
{
foreach (int i in node.MeshIndices)
{
SceneObject so = new SceneObject();
so.nodeName = node.Name;
if (node.Parent != null)
{
so.parentNodeName = node.Parent.Name;
}
so.pMesh = pScene.Meshes[i];
so.transform = node.Transform;
so.transform.Transpose();
meshArr.Add(so);
}
}
// continue for all child nodes
if (node.HasChildren)
{
foreach (Assimp.Node childNode in node.Children)
{
CopyNodesWithMeshes(pScene, childNode, ref meshArr);
}
}
}
void RekursiveDraw(Assimp.Node node, OpenGlDevice Device)
{
if ((node.HasMeshes))
{
foreach (var index in node.MeshIndices)
{
D3DMesh mesh = (Meshes[index] as D3DMesh);
xyzf b = new xyzf(0, 0, 0);
CpuSkinningEvaluator.CachedMeshData MD = SkinninEvaluator.GetEntry(mesh);
SkinninEvaluator.GetTransformedVertexPosition(node, mesh, 0, out b);
if (mesh.Material.Translucent < 1)
{
TransparentMeshes.Add(new TransParencyItem(mesh, MD._cachedPositions, MD._cachedNormals));
continue;
}
xyzf[] SavePos = mesh.Position;
xyzf[] SaveNormals = mesh.Normals;
mesh.Position = MD._cachedPositions;
mesh.Normals = MD._cachedNormals;
mesh.Paint(Device);
mesh.Position = SavePos;
mesh.Normals = SaveNormals;
}
}
for (int i = 0; i < node.Children.Count; i++)
{
RekursiveDraw(node.Children[i], Device);
}
}
Box RekursiveGetBox(Assimp.Node node, Box BoxMin)
{
Box _Box = BoxMin;
if ((node.HasMeshes))
{
foreach (var index in node.MeshIndices)
{
D3DMesh mesh = (Meshes[index] as D3DMesh);
xyzf b = new xyzf(0, 0, 0);
CpuSkinningEvaluator.CachedMeshData MD = SkinninEvaluator.GetEntry(mesh);
SkinninEvaluator.GetTransformedVertexPosition(node, mesh, 0, out b);
xyzf[] P = new xyzf[MD._cachedPositions.Length];
for (int i = 0; i < P.Length; i++)
{
P[i] = mesh.Transformation * MD._cachedPositions[i];
}
_Box = Box.GetEnvBox(P, _Box);
}
}
for (int i = 0; i < node.Children.Count; i++)
{
_Box = RekursiveGetBox(node.Children[i], _Box);
}
return(_Box);
}
internal SceneNode(Assimp.Node node, Assimp.Matrix4x4 transform, List <SceneMesh> meshes, Action <Matrix4> setTransform, Func <int, MaterialBinding> materialSelector)
{
Name = node.Name;
draw = EmptyAction;
Transform = MatrixHelper.ToMatrix4(transform * node.Transform);
if (node.HasMeshes)
{
draw += () => setTransform(Transform);
foreach (var index in node.MeshIndices)
{
var mesh = meshes[index];
draw += () =>
{
var material = materialSelector(mesh.MaterialIndex);
if (material != null)
{
material.Bind();
mesh.Draw();
}
};
}
}
if (node.HasChildren)
{
children.AddRange(node.Children.Select(
child => new SceneNode(child, node.Transform, meshes, setTransform, materialSelector)));
}
}
private static Node ConvertNode(Assimp.Node aiNode, List <Assimp.Mesh> aiMeshes, List <MaterialBuildInfo> materialBuildInfos, ConvertGeometryDelegate convertGeometry)
{
Node ConvertHierarchyNodeRecursively(Assimp.Node curAiNode, ref Node previousSibling, Node parent, ref Assimp.Matrix4x4 parentNodeWorldTransform)
{
var nodeWorldTransform = curAiNode.Transform * parentNodeWorldTransform;
curAiNode.Transform.Decompose(out var scale, out var rotation, out var translation);
// Create node
//var node = new Node( AssimpHelper.FromAssimp( translation ), AngleVector.FromQuaternion( AssimpHelper.FromAssimp( rotation ) ),
// AssimpHelper.FromAssimp( scale ), parent );
var node = new Node(Vector3.Zero, AngleVector.Zero, Vector3.One, parent);
if (curAiNode.HasMeshes)
{
Console.WriteLine(curAiNode.Name);
node.Geometry = convertGeometry(curAiNode, nodeWorldTransform, aiMeshes, materialBuildInfos);
}
// Set sibling (next) reference of previous
if (previousSibling != null)
{
previousSibling.Sibling = node;
}
previousSibling = node;
if (curAiNode.HasChildren)
{
Node childPreviousSibling = null;
foreach (var aiChildNode in curAiNode.Children)
{
var childNode = ConvertHierarchyNodeRecursively(aiChildNode, ref childPreviousSibling, node, ref nodeWorldTransform);
// Make sure to set the 'first child' reference if we haven't already
if (node.Child == null)
{
node.Child = childNode;
}
}
}
return(node);
}
// Dummy!
Node dummyNode = null;
var identityMatrix = Assimp.Matrix4x4.Identity;
var rootNode = ConvertHierarchyNodeRecursively(aiNode, ref dummyNode, null, ref identityMatrix);
foreach (var node in rootNode.EnumerateAllNodes())
{
node.OptimizeFlags();
}
return(rootNode);
}
private static IGeometry ConvertCollisionGeometry(Assimp.Node curAiNode, Assimp.Matrix4x4 nodeWorldTransform,
List <Assimp.Mesh> aiMeshes,
List <MaterialBuildInfo> materialBuildInfos)
{
var vertices = new List <Assimp.Vector3D>();
var triangles = new List <Basic.Triangle>();
foreach (var aiMeshIndex in curAiNode.MeshIndices)
{
var aiMesh = aiMeshes[aiMeshIndex];
for (var i = 0; i < aiMesh.Faces.Count; i++)
{
var aiFace = aiMesh.Faces[i];
var triangle = new Basic.Triangle();
var flip = false;
if (!flip)
{
triangle.A = ( ushort )vertices.AddUnique(aiMesh.Vertices[aiFace.Indices[0]]);
triangle.B = aiFace.IndexCount > 1 ? ( ushort )vertices.AddUnique(aiMesh.Vertices[aiFace.Indices[1]]) : triangle.A;
triangle.C = aiFace.IndexCount > 2 ? ( ushort )vertices.AddUnique(aiMesh.Vertices[aiFace.Indices[2]]) : triangle.B;
}
else
{
triangle.C = ( ushort )vertices.AddUnique(aiMesh.Vertices[aiFace.Indices[0]]);
triangle.B = aiFace.IndexCount > 1 ? ( ushort )vertices.AddUnique(aiMesh.Vertices[aiFace.Indices[1]]) : triangle.A;
triangle.A = aiFace.IndexCount > 2 ? ( ushort )vertices.AddUnique(aiMesh.Vertices[aiFace.Indices[2]]) : triangle.B;
}
triangles.Add(triangle);
}
}
var geometry = new Basic.Geometry
{
Meshes = new[]
{
new Basic.Mesh
{
PrimitiveType = PrimitiveType.Triangles,
Primitives = triangles.Cast <Basic.IPrimitive>().ToArray(),
}
},
VertexPositions = vertices.Select(x =>
{
Assimp.Unmanaged.AssimpLibrary.Instance.TransformVecByMatrix4(ref x, ref nodeWorldTransform);
return(AssimpHelper.FromAssimp(x));
}
).ToArray()
};
geometry.Bounds = BoundingSphere.Calculate(geometry.VertexPositions);
return(geometry);
}
private void ImportAnimation(Assimp.Node node, GameObject go, Quaternion cumulRotation)
{
Assimp.Animation animation = scene.Animations[0];
if ((GlobalState.Animation.fps / (float)animation.TicksPerSecond) * animation.DurationInTicks > GlobalState.Animation.EndFrame)
{
GlobalState.Animation.EndFrame = Mathf.CeilToInt(GlobalState.Animation.fps / (float)animation.TicksPerSecond * (float)animation.DurationInTicks) + 1;
}
Assimp.NodeAnimationChannel nodeChannel = animation.NodeAnimationChannels.Find(x => x.NodeName == node.Name);
if (nodeChannel == null)
{
nodeChannel = animation.NodeAnimationChannels.Find(x => x.NodeName.Split('_')[0] == node.Name);
}
if (null != nodeChannel)
{
if (nodeChannel.PositionKeyCount < 2 && nodeChannel.RotationKeyCount < 2)
{
return;
}
AnimationSet animationSet = new AnimationSet(go);
animationSet.ComputeCache();
if (nodeChannel.PositionKeyCount > 1 || nodeChannel.RotationKeyCount == nodeChannel.PositionKeyCount)
{
foreach (Assimp.VectorKey vectorKey in nodeChannel.PositionKeys)
{
int frame = Mathf.CeilToInt((float)vectorKey.Time * GlobalState.Animation.fps / (float)animation.TicksPerSecond) + 1;
animationSet.curves[AnimatableProperty.PositionX].AddKey(new AnimationKey(frame, vectorKey.Value.X, Interpolation.Bezier));
animationSet.curves[AnimatableProperty.PositionY].AddKey(new AnimationKey(frame, vectorKey.Value.Y, Interpolation.Bezier));
animationSet.curves[AnimatableProperty.PositionZ].AddKey(new AnimationKey(frame, vectorKey.Value.Z, Interpolation.Bezier));
}
}
foreach (Assimp.VectorKey vectorKey in nodeChannel.ScalingKeys)
{
int frame = Mathf.CeilToInt((float)vectorKey.Time * GlobalState.Animation.fps / (float)animation.TicksPerSecond) + 1;
animationSet.curves[AnimatableProperty.ScaleX].AddKey(new AnimationKey(frame, vectorKey.Value.X, Interpolation.Bezier));
animationSet.curves[AnimatableProperty.ScaleY].AddKey(new AnimationKey(frame, vectorKey.Value.Y, Interpolation.Bezier));
animationSet.curves[AnimatableProperty.ScaleZ].AddKey(new AnimationKey(frame, vectorKey.Value.Z, Interpolation.Bezier));
}
Vector3 previousRotation = Vector3.zero;
foreach (Assimp.QuaternionKey quaternionKey in nodeChannel.RotationKeys)
{
int frame = Mathf.RoundToInt((float)quaternionKey.Time * GlobalState.Animation.fps / (float)animation.TicksPerSecond) + 1;
Quaternion uQuaternion = new Quaternion(quaternionKey.Value.X, quaternionKey.Value.Y, quaternionKey.Value.Z, quaternionKey.Value.W);
uQuaternion = cumulRotation * uQuaternion * Quaternion.Inverse(cumulRotation);
Vector3 eulerValue = uQuaternion.eulerAngles;
eulerValue.x = previousRotation.x + Mathf.DeltaAngle(previousRotation.x, eulerValue.x);
eulerValue.y = previousRotation.y + Mathf.DeltaAngle(previousRotation.y, eulerValue.y);
eulerValue.z = previousRotation.z + Mathf.DeltaAngle(previousRotation.z, eulerValue.z);
animationSet.curves[AnimatableProperty.RotationX].AddKey(new AnimationKey(frame, eulerValue.x, Interpolation.Bezier));
animationSet.curves[AnimatableProperty.RotationY].AddKey(new AnimationKey(frame, eulerValue.y, Interpolation.Bezier));
animationSet.curves[AnimatableProperty.RotationZ].AddKey(new AnimationKey(frame, eulerValue.z, Interpolation.Bezier));
previousRotation = eulerValue;
}
GlobalState.Animation.SetObjectAnimations(go, animationSet);
}
}
internal static Mesh3D LoadFromFile(Device device, Assimp.Scene pScene, InputElement[] ieLayout)
{
Assimp.Node root = pScene.RootNode;
List <SceneObject> meshArr = new List <SceneObject>();
CopyNodesWithMeshes(pScene, root, ref meshArr);
return(LoadFromFileSUB(device, pScene, ieLayout, meshArr));
}
public static XElement BuildAssimpNodeTree(Assimp.Node node)
{
XElement element = new XElement("Mesh", node.Name);
foreach (Assimp.Node child in node.Children)
{
element.Add(BuildAssimpNodeTree(child));
}
return(element);
}
/// <summary>
/// Get the world transform for the given Assimp node.
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
private static Assimp.Matrix4x4 ComputeWorldTransform(Assimp.Node node)
{
var matrix = node.Transform;
if (node.Parent != null)
{
matrix *= ComputeWorldTransform(node.Parent);
}
return(matrix);
}
private void AddSimpleMesh(Assimp.Node node, GameObject parent, Material[] mats, CombineInstance[] combine)
{
MeshFilter meshFilter = parent.AddComponent <MeshFilter>();
MeshRenderer meshRenderer = parent.AddComponent <MeshRenderer>();
meshFilter.mesh = new Mesh();
meshFilter.mesh.CombineMeshes(combine, false);
meshFilter.name = meshes[node.MeshIndices[0]].name;
meshFilter.mesh.name = meshFilter.name;
meshRenderer.sharedMaterials = mats;
MeshCollider collider = parent.AddComponent <MeshCollider>();
}
private void ParseNodeTransform(Assimp.Node node, List <mat4> list, mat4 parentTransform)
{
mat4 thisTransform = parentTransform * node.Transform.ToMat4();
list.Add(thisTransform);
if (node.HasChildren)
{
foreach (Assimp.Node child in node.Children)
{
ParseNodeTransform(child, list, thisTransform);
}
}
}
public static Assimp.Matrix4x4 GetWorldMatrix(Assimp.Node node)
{
var mat = node.Transform;
var currNode = node;
while (currNode.Parent != null)
{
mat *= currNode.Parent.Transform;
currNode = currNode.Parent;
}
return(mat);
}
private void ParseNode(Assimp.Node node, List <vec3> list, mat4 parentTransform)
{
mat4 thisTransform = parentTransform * node.Transform.ToMat4();
var position = new vec3(thisTransform * new vec4(0, 0, 0, 1));
list.Add(position);
if (node.HasChildren)
{
foreach (Assimp.Node child in node.Children)
{
ParseNode(child, list, thisTransform);
}
}
}
public Assimp.Scene ConvertToScene(Model model, Config config)
{
// Start building scene
var aiScene = AssimpHelper.CreateDefaultScene();
// Convert materials
for (var i = 0; i < model.Materials.Count; i++)
{
var material = model.Materials[i];
var aiMaterial = new Assimp.Material {
Name = FormatMaterialName(material, i)
};
if (material.TextureId != null)
{
aiMaterial.TextureDiffuse = new Assimp.TextureSlot
{
TextureType = Assimp.TextureType.Diffuse,
FilePath = Path.Combine("textures", FormatTextureName(material.TextureId.Value))
};
}
aiScene.Materials.Add(aiMaterial);
}
// Convert nodes
var aiNodeLookup = new Dictionary <Node, Assimp.Node>();
for (var i = 0; i < model.Nodes.Count; i++)
{
var node = model.Nodes[i];
var aiNode = new Assimp.Node(FormatNodeName(node, i), node.Parent != null ? aiNodeLookup[node.Parent] : aiScene.RootNode);
aiNodeLookup[node] = aiNode;
aiNode.Transform = node.Transform.ToAssimp();
if (node.Geometry != null)
{
ConvertMeshList(node.Geometry.Meshes, node, i, model.Nodes, aiScene, aiNode);
if (node.Geometry.TranslucentMeshes != null)
{
ConvertMeshList(node.Geometry.TranslucentMeshes, node, i, model.Nodes, aiScene, aiNode);
}
}
aiNode.Parent.Children.Add(aiNode);
}
return(aiScene);
}
public BoneAnimation LoadBoneAnimation(Assimp.Scene aScene, Assimp.Node aNode, BoneAnimation parent)
{
var boneAnimation = new BoneAnimation()
{
Parent = parent,
Children = new List <BoneAnimation>(),
Positions = new List <Vector3>(),
Rotations = new List <Quaternion>(),
Scales = new List <Vector3>()
};
boneAnimation.Name = aNode.Name;
var animationChanel = aScene.Animations[0].NodeAnimationChannels.Where(n => n.NodeName == boneAnimation.Name).FirstOrDefault();
if (animationChanel != null)
{
boneAnimation.IsAnimate = true;
foreach (var aScale in animationChanel.ScalingKeys)
{
var scale = new Vector3(aScale.Value.X, aScale.Value.Y, aScale.Value.Z);
boneAnimation.Scales.Add(scale);
}
foreach (var aRotation in animationChanel.RotationKeys)
{
var rotation = new Quaternion(aRotation.Value.X, aRotation.Value.Y, aRotation.Value.Z, aRotation.Value.W);
boneAnimation.Rotations.Add(rotation);
}
foreach (var aTranslate in animationChanel.PositionKeys)
{
var translate = new Vector3(aTranslate.Value.X, aTranslate.Value.Y, aTranslate.Value.Z);
boneAnimation.Positions.Add(translate);
}
}
else
{
boneAnimation.IsAnimate = false;
boneAnimation.Transformation = Matrix.Transpose(AssimpHelper.MatrixAssimpToXna(aNode.Transform));
}
foreach (var child in aNode.Children)
{
boneAnimation.Children.Add(LoadBoneAnimation(aScene, child, boneAnimation));
}
BoneAnimations.Add(boneAnimation);
return(boneAnimation);
}
private static void AddOnePosFrame(AquaMotion.KeyData node, Assimp.Node aiNode, float baseScale)
{
AquaMotion.MKEY posKeys = new AquaMotion.MKEY();
posKeys.keyType = 1;
posKeys.dataType = 1;
posKeys.keyCount = 1;
var mat4 = GetMat4FromAssimpMat4(aiNode.Transform);
posKeys.vector4Keys = new List <Vector4>()
{
new Vector4(mat4.M14 * baseScale, mat4.M24 * baseScale, mat4.M34 * baseScale, 0)
};
node.keyData.Add(posKeys);
}
public static void CollectAnimated(Assimp.Node node, Dictionary <int, Assimp.Node> nodes)
{
//Be extra sure that this isn't an effect node
if (IsAnimatedNode(node, out string name, out int num))
{
//For now, assume animated node is numbered and we can add it directly
nodes.Add(num, node);
}
foreach (var childNode in node.Children)
{
CollectAnimated(childNode, nodes);
}
}
public void ExportModel()
{
using (System.Windows.Forms.SaveFileDialog a = new System.Windows.Forms.SaveFileDialog
{
DefaultExt = "dae",
Filter = "SAModel Files|*.sa1mdl|Collada|*.dae|Wavefront|*.obj"
})
{
if (a.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
string ftype = "collada";
switch (System.IO.Path.GetExtension(a.FileName).ToLowerInvariant())
{
case ".sa1mdl":
ModelFile.CreateFile(a.FileName, COL.Model, null, null, null, null, COL.Model.GetModelFormat());
return;
case ".fbx":
ftype = "fbx";
break;
case ".obj":
ftype = "obj";
break;
}
Assimp.AssimpContext context = new Assimp.AssimpContext();
Assimp.Scene scene = new Assimp.Scene();
scene.Materials.Add(new Assimp.Material());
Assimp.Node n = new Assimp.Node();
n.Name = "RootNode";
scene.RootNode = n;
string rootPath = System.IO.Path.GetDirectoryName(a.FileName);
List <string> texturePaths = new List <string>();
int numSteps = 0;
if (LevelData.TextureBitmaps != null && LevelData.TextureBitmaps.Count > 0)
{
numSteps = LevelData.TextureBitmaps[LevelData.leveltexs].Length;
}
for (int i = 0; i < numSteps; i++)
{
BMPInfo bmp = LevelData.TextureBitmaps[LevelData.leveltexs][i];
texturePaths.Add(System.IO.Path.Combine(rootPath, bmp.Name + ".png"));
bmp.Image.Save(System.IO.Path.Combine(rootPath, bmp.Name + ".png"));
}
SAEditorCommon.Import.AssimpStuff.AssimpExport(COL.Model, scene, Matrix.Identity, texturePaths.Count > 0 ? texturePaths.ToArray() : null, scene.RootNode);
context.ExportFile(scene, a.FileName, ftype, Assimp.PostProcessSteps.ValidateDataStructure | Assimp.PostProcessSteps.Triangulate | Assimp.PostProcessSteps.FlipUVs); //
}
}
}
private static void AddOneRotFrame(AquaMotion.KeyData node, Assimp.Node aiNode)
{
AquaMotion.MKEY rotKeys = new AquaMotion.MKEY();
rotKeys.keyType = 2;
rotKeys.dataType = 3;
rotKeys.keyCount = 1;
Matrix4x4.Invert(GetMat4FromAssimpMat4(aiNode.Transform), out Matrix4x4 mat4);
var quat = Quaternion.CreateFromRotationMatrix(mat4);
rotKeys.vector4Keys = new List <Vector4>()
{
new Vector4(quat.X, quat.Y, quat.Z, quat.W)
};
node.keyData.Add(rotKeys);
}
public static Matrix4x4 CalculateWorldTransform(Assimp.Node node)
{
Assimp.Matrix4x4 CalculateWorldTransformInternal(Assimp.Node currentNode)
{
var transform = currentNode.Transform;
if (currentNode.Parent != null)
{
transform *= CalculateWorldTransformInternal(currentNode.Parent);
}
return(transform);
}
return(FromAssimp(CalculateWorldTransformInternal(node)));
}
private static void ConvertMeshList(MeshList meshList, Node node, int nodeIndex, List <Node> nodes, Assimp.Scene aiScene, Assimp.Node aiNode)
{
var meshStartIndex = aiScene.Meshes.Count;
foreach (var mesh in meshList)
{
switch (mesh.Type)
{
case MeshType.Type1:
aiScene.Meshes.AddRange(ConvertMeshType1(( MeshType1 )mesh, node, nodeIndex));
break;
case MeshType.Type2:
aiScene.Meshes.AddRange(ConvertMeshType2(( MeshType2 )mesh, nodes));
break;
case MeshType.Type3:
break;
case MeshType.Type4:
aiScene.Meshes.Add(ConvertMeshType4(( MeshType4 )mesh, node, nodeIndex));
break;
case MeshType.Type5:
aiScene.Meshes.AddRange(ConvertMeshType5(( MeshType5 )mesh, node, nodes, nodeIndex));
break;
case MeshType.Type7:
aiScene.Meshes.Add(ConvertMeshType7(( MeshType7 )mesh, nodes));
break;
case MeshType.Type8:
aiScene.Meshes.Add(ConvertMeshType8(( MeshType8 )mesh, node, nodeIndex));
break;
}
}
var meshEndIndex = aiScene.Meshes.Count;
for (int i = meshStartIndex; i < meshEndIndex; i++)
{
var meshNode = new Assimp.Node($"mesh_{i:D2}", aiScene.RootNode);
meshNode.MeshIndices.Add(i);
meshNode.Parent.Children.Add(meshNode);
}
}
private void ParseNode(Assimp.Node node, List <vec3> lstPosition, List <vec3> lstColor, List <Assimp.Node> lstNode, mat4 parentTransform)
{
var parentPosition = new vec3(parentTransform * new vec4(0, 0, 0, 1));
lstPosition.Add(parentPosition); lstColor.Add(new vec3(1, 0, 0)); lstNode.Add(node.Parent);
mat4 thisTransform = parentTransform * node.Transform.ToMat4();
var position = new vec3(thisTransform * new vec4(0, 0, 0, 1));
lstPosition.Add(position); lstColor.Add(new vec3(1, 1, 1)); lstNode.Add(node);
if (node.HasChildren)
{
foreach (Assimp.Node child in node.Children)
{
ParseNode(child, lstPosition, lstColor, lstNode, thisTransform);
}
}
}
private static void WalkChildren(RWSceneNode rwNode, Assimp.Node parent)
{
foreach (RWSceneNode child in rwNode.Children)
{
string name = child.BoneMetadata.BoneNameID.ToString();
Assimp.Node aiNode = new Assimp.Node(name, parent);
}
}
public static Assimp.Scene ToAssimpScene(RWScene scene)
{
Assimp.Scene aiScene = new Assimp.Scene();
int drawCallIdx = 0;
int materialIdx = 0;
int totalSplitIdx = 0;
List<int> meshStartIndices = new List<int>();
foreach (RWDrawCall drawCall in scene.DrawCalls)
{
meshStartIndices.Add(totalSplitIdx);
var mesh = scene.Meshes[drawCall.MeshIndex];
var node = scene.Nodes[drawCall.NodeIndex];
int splitIdx = 0;
foreach (RWMeshMaterialSplit split in mesh.MaterialSplitData.MaterialSplits)
{
Assimp.Mesh aiMesh = new Assimp.Mesh(Assimp.PrimitiveType.Triangle);
aiMesh.Name = string.Format("DrawCall{0}_Split{1}", drawCallIdx.ToString("00"), splitIdx.ToString("00"));
aiMesh.MaterialIndex = split.MaterialIndex + materialIdx;
// get split indices
int[] indices = split.Indices;
if (mesh.MaterialSplitData.PrimitiveType == RWPrimitiveType.TriangleStrip)
indices = MeshUtilities.ToTriangleList(indices, true);
// pos & nrm
for (int i = 0; i < indices.Length; i++)
{
if (mesh.HasVertices)
{
var vert = Vector3.Transform(mesh.Vertices[indices[i]], node.WorldTransform);
aiMesh.Vertices.Add(vert.ToAssimpVector3D());
}
if (mesh.HasNormals)
{
var nrm = Vector3.TransformNormal(mesh.Normals[indices[i]], node.WorldTransform);
aiMesh.Normals.Add(nrm.ToAssimpVector3D());
}
}
// tex coords
if (mesh.HasTexCoords)
{
for (int i = 0; i < mesh.TextureCoordinateChannelCount; i++)
{
List<Assimp.Vector3D> texCoordChannel = new List<Assimp.Vector3D>();
for (int j = 0; j < indices.Length; j++)
{
texCoordChannel.Add(mesh.TextureCoordinateChannels[i][indices[j]].ToAssimpVector3D(0));
}
aiMesh.TextureCoordinateChannels[i] = texCoordChannel;
}
}
// colors
if (mesh.HasColors)
{
List<Assimp.Color4D> vertColorChannel = new List<Assimp.Color4D>();
for (int i = 0; i < indices.Length; i++)
{
var color = mesh.Colors[indices[i]];
vertColorChannel.Add(new Assimp.Color4D(color.R / 255f, color.G / 255f, color.B / 255f, color.A / 255f));
}
aiMesh.VertexColorChannels[0] = vertColorChannel;
}
// generate temporary face indices
int[] tempIndices = new int[aiMesh.VertexCount];
for (int i = 0; i < aiMesh.VertexCount; i++)
tempIndices[i] = i;
aiMesh.SetIndices(tempIndices, 3);
// add the mesh to the list
aiScene.Meshes.Add(aiMesh);
splitIdx++;
}
totalSplitIdx += splitIdx;
foreach (RWMaterial mat in mesh.Materials)
{
Assimp.Material aiMaterial = new Assimp.Material();
aiMaterial.AddProperty(new Assimp.MaterialProperty(Assimp.Unmanaged.AiMatKeys.NAME, "Material" + (materialIdx++).ToString("00")));
if (mat.IsTextured)
{
aiMaterial.AddProperty(new Assimp.MaterialProperty(Assimp.Unmanaged.AiMatKeys.TEXTURE_BASE, mat.TextureReference.ReferencedTextureName + ".png", Assimp.TextureType.Diffuse, 0));
}
aiScene.Materials.Add(aiMaterial);
}
drawCallIdx++;
}
// store node lookup
Dictionary<RWSceneNode, Assimp.Node> nodeLookup = new Dictionary<RWSceneNode, Assimp.Node>();
// first create the root node
var rootNode = new Assimp.Node("SceneRoot");
rootNode.Transform = scene.Nodes[0].Transform.ToAssimpMatrix4x4();
nodeLookup.Add(scene.Nodes[0], rootNode);
for (int i = 1; i < scene.Nodes.Count - 1; i++)
{
var node = scene.Nodes[i];
string name = node.BoneMetadata.BoneNameID.ToString();
var aiNode = new Assimp.Node(name);
aiNode.Transform = node.Transform.ToAssimpMatrix4x4();
// get the associated meshes for this node
var drawCalls = scene.DrawCalls.FindAll(dc => dc.NodeIndex == i);
foreach (var drawCall in drawCalls)
{
for (int j = 0; j < scene.Meshes[drawCall.MeshIndex].MaterialCount; j++)
{
aiNode.MeshIndices.Add(meshStartIndices[scene.DrawCalls.IndexOf(drawCall)] + j);
}
}
nodeLookup[node.Parent].Children.Add(aiNode);
nodeLookup.Add(node, aiNode);
}
aiScene.RootNode = rootNode;
return aiScene;
}
