public void TestMaterialFbx(string filename)
{
var testFile = Path.Combine(PathHelper.FilesPath, filename);
var documentNode = FbxIO.Read(testFile, ErrorLevel.Strict);
var scaleFactor = documentNode.GetScaleFactor();
var materialIds = documentNode.GetMaterialIds();
Assert.True(materialIds.Length > 0);
foreach (var materialId in materialIds)
{
var materialName = documentNode.GetMaterialName(materialId);
var diffuseColor = documentNode.GetMaterialDiffuseColor(materialId);
}
var geometryIds = documentNode.GetGeometryIds();
Assert.True(geometryIds.Length > 0);
foreach (var geometryId in geometryIds)
{
var vertexIndices = documentNode.GetVertexIndices(geometryId);
var positions = documentNode.GetPositions(geometryId, vertexIndices);
var tangents = documentNode.GetTangents(geometryId, vertexIndices);
var binormals = documentNode.GetBinormals(geometryId, vertexIndices);
var texCoords = documentNode.GetTexCoords(geometryId, vertexIndices);
var materials = documentNode.GetMaterials(geometryId, vertexIndices);
var hasTexCoords = documentNode.GetGeometryHasTexCoords(geometryId);
var hasTangents = documentNode.GetGeometryHasTangents(geometryId);
var hasBinormals = documentNode.GetGeometryHasBinormals(geometryId);
}
}
public static void CompareBinaryFiles(string filename)
{
var testFile = Path.Combine(PathHelper.FilesPath, filename);
var originalData = File.ReadAllBytes(testFile);
var isBinary = FbxIO.IsBinaryFbx(testFile);
Assert.True(isBinary);
var documentNode = FbxIO.Read(testFile);
using (var newStream = new MemoryStream())
{
FbxIO.WriteBinary(documentNode, newStream);
var newData = newStream.ToArray();
Assert.True(newData.Length <= originalData.Length, $"Unexpected size comparisson");
var identical = true;
for (var i = 0; i < newData.Length; i++)
{
if (originalData[i] != newData[i])
{
identical = false;
break;
}
}
Assert.True(identical, $"Files data did not match as expected");
}
}
static void ParseFbxTextures(string path, string downloadRoot, string destinationRoot)
{
//var isBinary = FbxIO.IsBinaryFbx(path);
var documentNode = FbxIO.Read(path);
Console.WriteLine("Parsing fbx - {0}", path);
ParseNodes(documentNode.Nodes, downloadRoot, destinationRoot);
}
public Task <IContentContainer> ReadAsync(Stream stream)
{
return(Task.Run(() =>
{
var contentContainer = new ContentContainer();
var fbxDocument = FbxIO.Read(stream, ErrorLevel.Permissive);
return (IContentContainer)contentContainer;
}));
}
public static void CompareAsciiFiles(string filename)
{
var path = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
var testFile = Path.Combine(path, "Files", filename);
var isBinary = FbxIO.IsBinaryFbx(testFile);
Assert.False(isBinary);
var documentNode = FbxIO.Read(testFile);
using (var tempStream = new MemoryStream())
{
FbxIO.WriteAscii(documentNode, tempStream);
tempStream.Position = 0;
var originalBuffer = string.Empty;
using (StreamReader originalStream = new StreamReader(testFile))
{
while (originalStream.EndOfStream)
{
originalBuffer += FilterLine(originalStream.ReadLine());
}
}
var newBuffer = string.Empty;
using (StreamReader newStream = new StreamReader(tempStream))
{
while (newStream.EndOfStream)
{
newBuffer += FilterLine(newStream.ReadLine());
}
}
Assert.True(originalBuffer.Length == newBuffer.Length, $"Unexpected size comparisson");
var identical = true;
for (var i = 0; i < newBuffer.Length; i++)
{
if (originalBuffer[i] != newBuffer[i])
{
identical = false;
break;
}
}
Assert.True(identical, $"Files data did not match as expected");
}
}
public YdrFile ConvertToYdr(string name, byte[] fbxdata)
{
var fdoc = FbxIO.Read(fbxdata);
if (fdoc == null)
{
return(null);
}
var dwbl = TryConvertDrawable(fdoc, name);
YdrFile ydr = new YdrFile();
ydr.Drawable = dwbl;
ydr.Name = name;
return(ydr);
}
private static IKn5 LodFbxToKn5(IKn5 preparedKn5, string fbxFilename, CarLodGeneratorStageParams stage)
{
var fbx = FbxIO.Read(fbxFilename);
var geometries = fbx.GetGeometryIds()
.Select(id => new { id, name = fbx.GetNode("Model", fbx.GetConnection(id)).GetName("Model") })
.GroupBy(v => v.name).ToDictionary(x => x.Key, x => x.Select(v => v.id).ToList());
MergeNode(preparedKn5.RootNode);
foreach (var geometry in geometries.Where(g => g.Value.Count > 0))
{
var parent = preparedKn5.FirstByName(geometry.Key);
if (parent == null)
{
AcToolsLogging.Write($"Error: parent {geometry.Key} is missing");
continue;
}
var mesh = Kn5MeshUtils.Create($"{geometry.Key}__mesh_", parent.Children[0].MaterialId);
if (parent.Children.Count != 1)
{
throw new Exception("Unexpected arrangement");
}
MergeMeshWith(parent, mesh, geometry.Value.Select(x => Tuple.Create(fbx.GetGeometry(x), 1d)));
parent.Children.Add(mesh);
}
RemoveEmpty(preparedKn5.RootNode);
return(preparedKn5);
void MergeMeshWith(Kn5Node parent, Kn5Node mesh, IEnumerable <Tuple <FbxNode, double> > geometriesList)
{
var builder = new Kn5MeshBuilder();
var subCounter = 1;
foreach (var geometry in geometriesList)
{
var fbxIndices = geometry?.Item1?.GetRelative("PolygonVertexIndex")?.Value?.GetAsIntArray();
if (fbxIndices == null)
{
continue;
}
var fbxVertices = geometry.Item1.GetRelative("Vertices").Value.GetAsFloatArray();
var fbxNormals = geometry.Item1.GetRelative("LayerElementNormal").GetRelative("Normals").Value.GetAsFloatArray();
var fbxUvs = geometry.Item1.GetRelative("LayerElementUV").GetRelative("UV").Value.GetAsFloatArray();
var offset = MoveAsideDistance(geometry.Item2, stage);
var scale = (float)(1d / geometry.Item2);
for (var i = 0; i < fbxIndices.Length; ++i)
{
if (i % 3 == 0 && builder.IsCloseToLimit)
{
builder.SetTo(mesh);
mesh.RecalculateTangents();
builder.Clear();
var oldIndex = parent.Children.IndexOf(mesh);
mesh = Kn5MeshUtils.Create(mesh.Name + $"___$sub:{subCounter}", mesh.MaterialId);
++subCounter;
if (oldIndex != -1 && oldIndex < parent.Children.Count - 1)
{
parent.Children.Insert(oldIndex + 1, mesh);
}
else
{
parent.Children.Add(mesh);
}
}
var index = fbxIndices[i] < 0 ? -fbxIndices[i] - 1 : fbxIndices[i];
builder.AddVertex(new Kn5Node.Vertex {
Position = new Vec3((fbxVertices[index * 3] - offset.X) * scale, (fbxVertices[index * 3 + 1] - offset.Y) * scale,
(fbxVertices[index * 3 + 2] - offset.Z) * scale),
Normal = new Vec3(fbxNormals[i * 3], fbxNormals[i * 3 + 1], fbxNormals[i * 3 + 2]),
Tex = new Vec2(fbxUvs[i * 2], 1f - fbxUvs[i * 2 + 1])
});
}
}
builder.SetTo(mesh);
mesh.RecalculateTangents();
}
void MergeMesh(Kn5Node parent, Kn5Node node, IEnumerable <Kn5Node> merges)
{
if (Regex.IsMatch(node.Name, @"___\$extra:\d+$"))
{
node.Vertices = new Kn5Node.Vertex[0];
return;
}
MergeMeshWith(parent, node, Enumerable.Range(-1, 100).Select(i => GetGeometry(node, i)).TakeWhile(i => i != null)
.Concat(merges.Select(n => GetGeometry(n))));
}
Tuple <FbxNode, double> GetGeometry(Kn5Node node, int extraBit = -1)
{
var name = extraBit < 0 ? node.Name : $"{node.Name}___$extra:{extraBit}";
if (geometries.TryGetValue(name, out var list))
{
if (list.Count == 0)
{
return(null);
}
var geometryId = list[0];
list.RemoveAt(0);
return(Tuple.Create(fbx.GetGeometry(geometryId), node.Tag is double priority ? priority : 1d));
}
return(null);
}
void MergeNode(Kn5Node node)
{
foreach (var child in node.Children.ToList())
{
if (child.NodeClass == Kn5NodeClass.Base)
{
MergeNode(child);
}
else if (child.NodeClass == Kn5NodeClass.Mesh && child.Vertices.Length > 0)
{
var mergeKey = MergeKey(child);
var merge = node.Children.ApartFrom(child).Where(c => c.NodeClass == Kn5NodeClass.Mesh && MergeKey(c) == mergeKey).ToList();
MergeMesh(node, child, merge);
merge.ForEach(m => m.Vertices = new Kn5Node.Vertex[0]);
}
}
}
int MergeKey(Kn5Node node)
{
return((int)(node.MaterialId * 397) | (node.IsTransparent ? 1 << 31 : 0) | (node.CastShadows ? 1 << 30 : 0));
}
bool RemoveEmpty(Kn5Node node)
{
if (node.NodeClass == Kn5NodeClass.Mesh)
{
if (Regex.IsMatch(node.Name, @"___\$extra:\d+$"))
{
return(false);
}
return(node.Vertices.Length > 0);
}
if (node.NodeClass == Kn5NodeClass.SkinnedMesh)
{
return(false);
}
var found = node.Name.IndexOf("___$unique:", StringComparison.Ordinal);
if (found != -1)
{
node.Name = node.Name.Substring(0, found);
}
for (var i = 0; i < node.Children.Count; ++i)
{
if (!RemoveEmpty(node.Children[i]))
{
node.Children.RemoveAt(i);
--i;
}
}
return(node.Children.Count > 0);
}
}
public static void LoadFbx(string path, ref Vector3[] positions, ref Vector3[] normals, ref Vector2[] texCoords,
ref int[] vertexIndices)
{
var isBinary = FbxIO.IsBinaryFbx(path);
var documentNode = FbxIO.Read(path);
// Scale factor usually 1 or 2.54
var scaleFactor = documentNode.GetScaleFactor();
var geometryIds = documentNode.GetGeometryIds();
var fbxIndexer = new FbxIndexer();
foreach (var geometryId in geometryIds)
{
vertexIndices = documentNode.GetVertexIndices(geometryId);
long[] normalLayerIndices = documentNode.GetLayerIndices(geometryId, FbxLayerElementType.Normal);
long[] tangentLayerIndices = documentNode.GetLayerIndices(geometryId, FbxLayerElementType.Tangent);
long[] binormalLayerIndices = documentNode.GetLayerIndices(geometryId, FbxLayerElementType.Binormal);
long[] texCoordLayerIndices = documentNode.GetLayerIndices(geometryId, FbxLayerElementType.TexCoord);
long[] materialLayerIndices = documentNode.GetLayerIndices(geometryId, FbxLayerElementType.Material);
positions = documentNode.GetPositions(geometryId, vertexIndices);
normals = documentNode.GetNormals(geometryId, vertexIndices, normalLayerIndices[0]);
texCoords = documentNode.GetTexCoords(geometryId, vertexIndices, texCoordLayerIndices[0]);
int[] materials = documentNode.GetMaterials(geometryId, vertexIndices, materialLayerIndices[0]);
bool hasNormals = documentNode.GetGeometryHasNormals(geometryId);
bool hasTexCoords = documentNode.GetGeometryHasTexCoords(geometryId);
bool hasTangents = documentNode.GetGeometryHasTangents(geometryId);
bool hasBinormals = documentNode.GetGeometryHasBinormals(geometryId);
bool hasMaterials = documentNode.GetGeometryHasMaterials(geometryId);
Vector3[] tangents = Array.Empty <Vector3>();
Vector3[] binormals = Array.Empty <Vector3>();
if (hasTangents)
{
tangents = documentNode.GetTangents(geometryId, vertexIndices, tangentLayerIndices[0]);
}
if (hasBinormals)
{
binormals = documentNode.GetBinormals(geometryId, vertexIndices, binormalLayerIndices[0]);
}
for (var i = 0; i < positions.Length; i++)
{
var vertex = new FbxVertex
{
Position = positions[i],
Normal = hasNormals ? normals[i] : new Vector3(),
Tangent = hasTangents ? tangents[i] : new Vector3(),
Binormal = hasBinormals ? binormals[i] : new Vector3(),
TexCoord = hasTexCoords ? texCoords[i] : new Vector2()
};
var materialId = hasMaterials ? materials[i] : 0;
fbxIndexer.AddVertex(vertex, materialId, 0);
}
}
}
public void TestFbx(string filename, bool expectedIsBinary, double expectedScaleFacor, bool expectedHasTexCoord, bool expectedHasTangent, bool expectedHasBinormal)
{
var testFile = Path.Combine(PathHelper.FilesPath, filename);
Assert.True(expectedIsBinary == FbxIO.IsBinaryFbx(testFile), $"IsBinaryFbx expected {expectedIsBinary}");
var documentNode = FbxIO.Read(testFile, ErrorLevel.Strict);
var scaleFactor = documentNode.GetScaleFactor();
Assert.True(expectedScaleFacor == scaleFactor, $"ScaleFactor expected {expectedScaleFacor}");
var materialIds = documentNode.GetMaterialIds();
var geometryIds = documentNode.GetGeometryIds();
Assert.True(geometryIds.Length > 0);
var fbxIndexer = new FbxIndexer();
foreach (var geometryId in geometryIds)
{
var vertexIndices = documentNode.GetVertexIndices(geometryId);
var positions = documentNode.GetPositions(geometryId, vertexIndices);
var normals = documentNode.GetNormals(geometryId, vertexIndices);
var tangents = documentNode.GetTangents(geometryId, vertexIndices);
var binormals = documentNode.GetBinormals(geometryId, vertexIndices);
var texCoords = documentNode.GetTexCoords(geometryId, vertexIndices);
var materials = documentNode.GetMaterials(geometryId, vertexIndices);
var hasNormals = documentNode.GetGeometryHasNormals(geometryId);
var hasTexCoords = documentNode.GetGeometryHasTexCoords(geometryId);
Assert.True(expectedHasTexCoord == hasTexCoords, $"HasTexCoord expected {expectedHasTexCoord}");
var hasTangents = documentNode.GetGeometryHasTangents(geometryId);
Assert.True(expectedHasTangent == hasTangents, $"HasTangent expected {expectedHasTangent}");
var hasBinormals = documentNode.GetGeometryHasBinormals(geometryId);
Assert.True(expectedHasBinormal == hasBinormals, $"HasBinormal expected {expectedHasBinormal}");
var hasMaterials = documentNode.GetGeometryHasMaterials(geometryId);
for (var i = 0; i < positions.Length; i++)
{
var vertex = new FbxVertex
{
Position = positions[i],
Normal = hasNormals ? normals[i] : new Vector3(),
Tangent = hasTangents ? tangents[i] : new Vector3(),
Binormal = hasBinormals ? binormals[i] : new Vector3(),
TexCoord = hasTexCoords ? texCoords[i] : new Vector2()
};
var materialId = hasMaterials ? materials[i] : 0;
fbxIndexer.AddVertex(vertex, materialId);
}
}
foreach (var materialId in materialIds)
{
var materialName = documentNode.GetMaterialName(materialId);
var diffuseColor = documentNode.GetMaterialDiffuseColor(materialId);
fbxIndexer.Index(materialId, out var indexedVertices, out var indexedIndices);
}
}