public void TestConvertFromStream()
{
String path = Path.Combine(TestHelper.RootPath, "TestFiles\\duck.dae");
String outputPath = Path.Combine(TestHelper.RootPath, "TestFiles\\duck.obj");
String outputPath2 = Path.Combine(TestHelper.RootPath, "TestFiles\\duck-fromBlob.obj");
FileStream fs = File.OpenRead(path);
new ConsoleLogStream().Attach();
AssimpContext importer = new AssimpContext();
importer.ConvertFromStreamToFile(fs, ".dae", outputPath, "obj");
fs.Position = 0;
ExportDataBlob blob = importer.ConvertFromStreamToBlob(fs, ".dae", "collada");
fs.Close();
//Take ExportDataBlob's data, write it to a memory stream and export that back to an obj and write it
MemoryStream memStream = new MemoryStream();
memStream.Write(blob.Data, 0, blob.Data.Length);
memStream.Position = 0;
importer.ConvertFromStreamToFile(memStream, ".dae", outputPath2, "obj");
memStream.Close();
LogStream.DetachAllLogstreams();
}
public void TestToStream()
{
String path = Path.Combine(TestHelper.RootPath, "TestFiles\\duck.dae");
AssimpContext importer = new AssimpContext();
ExportDataBlob blob = importer.ConvertFromFileToBlob(path, "obj");
Assert.IsNotNull(blob);
MemoryStream stream = new MemoryStream();
blob.ToStream(stream);
Assert.IsTrue(stream.Length != 0);
stream.Position = 0;
ExportDataBlob blob2 = ExportDataBlob.FromStream(stream);
Assert.IsNotNull(blob2);
Assert.IsTrue(blob.Data.Length == blob.Data.Length);
if(blob.NextBlob != null)
{
Assert.IsTrue(blob2.NextBlob != null);
Assert.IsTrue(blob2.NextBlob.Name.Equals(blob.NextBlob.Name));
Assert.IsTrue(blob2.NextBlob.Data.Length == blob.NextBlob.Data.Length);
}
}
public void TestConvertFromFile()
{
String path = Path.Combine(TestHelper.RootPath, "TestFiles\\Bob.md5mesh");
String outputPath = Path.Combine(TestHelper.RootPath, "TestFiles\\Bob.dae");
AssimpContext importer = new AssimpContext();
importer.ConvertFromFileToFile(path, outputPath, "collada");
ExportDataBlob blob = importer.ConvertFromFileToBlob(path, "collada");
}
public void TestObjLoad()
{
String path = Path.Combine(TestHelper.RootPath, "TestFiles\\sphere.obj");
AssimpContext importer = new AssimpContext();
Scene scene = importer.ImportFile(path);
Assert.IsNotNull(scene);
Assert.IsNotNull(scene.RootNode);
Assert.IsTrue(scene.RootNode.Name.Equals("sphere.obj"));
}
public SimpleOpenGLSample()
: base()
{
Title = "Quack! - AssimpNet Simple OpenGL Sample";
String fileName = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "duck.dae");
AssimpContext importer = new AssimpContext();
importer.SetConfig(new NormalSmoothingAngleConfig(66.0f));
m_model = importer.ImportFile(fileName, PostProcessPreset.TargetRealTimeMaximumQuality);
ComputeBoundingBox();
}
public void TestIOSystemError()
{
String fileName = "duckduck.dae"; //GOOSE!
String[] searchPaths = { Path.Combine(TestHelper.RootPath, "TestFiles") };
FileIOSystem ioSystem = new FileIOSystem(searchPaths);
AssimpContext importer = new AssimpContext();
importer.SetIOSystem(ioSystem);
Assert.Throws<AssimpException>(delegate()
{
importer.ImportFile(fileName, PostProcessSteps.None);
});
}
public void TestMultiSearchDirectoryLoad()
{
String fileName = "fenris.lws";
String[] searchPaths = { Path.Combine(TestHelper.RootPath, "TestFiles\\fenris\\scenes"), Path.Combine(TestHelper.RootPath, "TestFiles\\fenris\\objects") };
FileIOSystem ioSystem = new FileIOSystem(searchPaths);
AssimpContext importer = new AssimpContext();
importer.SetIOSystem(ioSystem);
//None, using the "target high quality flags caused a crash with this model.
Scene scene = importer.ImportFile(fileName, PostProcessSteps.None);
Assert.IsNotNull(scene);
}
public void TestMultiSearchDirectoryConvert()
{
String fileName = Path.Combine(TestHelper.RootPath, "TestFiles\\fenris\\scenes\\fenris.lws");
String[] searchPaths = { Path.Combine(TestHelper.RootPath, "TestFiles\\fenris\\objects") };
FileIOSystem ioSystem = new FileIOSystem(searchPaths);
AssimpContext importer = new AssimpContext();
importer.SetIOSystem(ioSystem);
//Output path has to be specified fully, since we may be creating the file
String outputPath = Path.Combine(TestHelper.RootPath, "TestFiles\\fenris\\fenris2.obj");
importer.ConvertFromFileToFile(fileName, PostProcessSteps.None, outputPath, "obj", PostProcessSteps.None);
}
public void TestImportExportImportFile()
{
String colladaPath = Path.Combine(TestHelper.RootPath, "TestFiles\\duck.dae");
String plyPath = Path.Combine(TestHelper.RootPath, "TestFiles\\duck2.dae");
AssimpContext context = new AssimpContext();
Scene ducky = context.ImportFile(colladaPath);
context.ExportFile(ducky, plyPath, "collada");
Scene ducky2 = context.ImportFile(plyPath);
Assert.IsNotNull(ducky2);
}
private void LoadSceneB()
{
Console.WriteLine("Thread B: Starting import.");
AssimpContext importer = new AssimpContext();
String path = Path.Combine(TestHelper.RootPath, "TestFiles\\duck.dae");
new ConsoleLogStream("Thread B:").Attach();
importer.SetConfig(new NormalSmoothingAngleConfig(55.0f));
Console.WriteLine("Thread B: Importing");
Scene scene = importer.ImportFile(path);
Console.WriteLine("Thread B: Done importing");
}
private void LoadSceneA()
{
Console.WriteLine("Thread A: Starting import.");
AssimpContext importer = new AssimpContext();
String path = Path.Combine(TestHelper.RootPath, "TestFiles\\Bob.md5mesh");
new ConsoleLogStream("Thread A:").Attach();
Console.WriteLine("Thread A: Importing");
Scene scene = importer.ImportFile(path);
Console.WriteLine("Thread A: Done importing");
}
private void ConvertSceneC()
{
Console.WriteLine("Thread C: Starting convert.");
AssimpContext importer = new AssimpContext();
String path = Path.Combine(TestHelper.RootPath, "TestFiles\\duck.dae");
String outputPath = Path.Combine(TestHelper.RootPath, "TestFiles\\duck2.obj");
new ConsoleLogStream("Thread C:").Attach();
importer.SetConfig(new NormalSmoothingAngleConfig(55.0f));
importer.SetConfig(new FavorSpeedConfig(true));
Console.WriteLine("Thread C: Converting");
ExportDataBlob blob = importer.ConvertFromFileToBlob(path, "obj");
Console.WriteLine("Thread C: Done converting");
}
public void TestSupportedFormats()
{
AssimpContext importer = new AssimpContext();
ExportFormatDescription[] exportDescs = importer.GetSupportedExportFormats();
String[] importFormats = importer.GetSupportedImportFormats();
Assert.IsNotNull(exportDescs);
Assert.IsNotNull(importFormats);
Assert.IsTrue(exportDescs.Length >= 1);
Assert.IsTrue(importFormats.Length >= 1);
Assert.IsTrue(importer.IsExportFormatSupported(exportDescs[0].FileExtension));
Assert.IsTrue(importer.IsImportFormatSupported(importFormats[0]));
}
public void TestLoadFreeLibrary()
{
if(AssimpLibrary.Instance.IsLibraryLoaded)
AssimpLibrary.Instance.FreeLibrary();
AssimpLibrary.Instance.LoadLibrary();
String path = Path.Combine(TestHelper.RootPath, "TestFiles\\duck.dae");
AssimpContext importer = new AssimpContext();
importer.ImportFile(path);
importer.Dispose();
AssimpLibrary.Instance.FreeLibrary();
}
public void TestImportFromStream()
{
String path = Path.Combine(TestHelper.RootPath, "TestFiles\\duck.dae");
FileStream fs = File.OpenRead(path);
AssimpContext importer = new AssimpContext();
LogStream.IsVerboseLoggingEnabled = true;
LogStream logstream = new LogStream(delegate(String msg, String userData)
{
Console.WriteLine(msg);
});
logstream.Attach();
Scene scene = importer.ImportFileFromStream(fs, ".dae");
fs.Close();
Assert.IsNotNull(scene);
Assert.IsTrue((scene.SceneFlags & SceneFlags.Incomplete) != SceneFlags.Incomplete);
}
static void ExportFile(string fileName, string destFolder)
{
String targetMeshFile = Path.GetFileNameWithoutExtension(fileName) + ".mesh";
String targetAnimFile = Path.GetFileNameWithoutExtension(fileName) + ".anim";
Console.WriteLine("Exporting " + targetMeshFile + "...");
AssimpContext importer = new AssimpContext();
importer.SetConfig(new NormalSmoothingAngleConfig(66.0f));
importer.SetConfig(new VertexBoneWeightLimitConfig(4));
Scene scene = importer.ImportFile(fileName, PostProcessPreset.TargetRealTimeMaximumQuality | PostProcessSteps.FlipUVs);
System.Globalization.CultureInfo customCulture = (System.Globalization.CultureInfo)System.Threading.Thread.CurrentThread.CurrentCulture.Clone();
customCulture.NumberFormat.NumberDecimalSeparator = ".";
System.Threading.Thread.CurrentThread.CurrentCulture = customCulture;
FileStream fs = new FileStream(Path.Combine(destFolder, targetMeshFile), FileMode.Create);
BinaryWriter dest = new BinaryWriter(fs);
MeshBlock meshBlock = new MeshBlock(dest, "MX3D");
List<MeshNode> nodes = new List<MeshNode>();
addNodes(nodes, scene.RootNode, scene.Meshes[0]);
for (int j = 0; j < 1; j++)
{
MeshBlock groupBlock = new MeshBlock(dest, "XGRP");
exportGroup(dest, scene.Meshes[j], scene, nodes);
groupBlock.EndBlock(dest);
}
MeshBlock skeletonDataBlock;
skeletonDataBlock = new MeshBlock(dest, "XSKL");
UInt32 boneCount = (UInt32)nodes.Count;
dest.Write(boneCount);
for (int j = 0; j < nodes.Count; j++)
{
exportBone(dest, nodes[j], scene, j);
}
skeletonDataBlock.EndBlock(dest);
meshBlock.EndBlock(dest);
dest.Close();
fs.Close();
for (int i = 0; i < scene.AnimationCount; i++)
{
Animation animation = scene.Animations[i];
String name = animation.Name;
if (name.Length <= 0)
{
name = Path.GetFileNameWithoutExtension(targetAnimFile);
int p = name.LastIndexOf("@");
if (p >= 0)
{
name = name.Substring(p + 1);
}
}
Console.WriteLine("Exporting " + name + " animation...");
fs = new FileStream(Path.Combine(destFolder, targetAnimFile), FileMode.Create);
dest = new BinaryWriter(fs);
byte[] tagData = Encoding.ASCII.GetBytes("ANIM");
dest.Write(tagData);
float FPS = (float)animation.TicksPerSecond;
dest.Write(FPS);
byte loop = 1;
dest.Write(loop);
float loopPoint = 0.0f;
dest.Write(loopPoint);
float animSpeed = 1.0f;
dest.Write(animSpeed);
String nextAnim = "";
exportString(dest, nextAnim);
UInt32 channelCount = (UInt32)animation.NodeAnimationChannelCount;
dest.Write(channelCount);
for (int j = 0; j < channelCount; j++)
{
NodeAnimationChannel channel = animation.NodeAnimationChannels[j];
exportString(dest, channel.NodeName);
UInt32 posCount = (UInt32)channel.PositionKeyCount;
dest.Write(posCount);
for (int k = 0; k < posCount; k++)
{
float t = (float)channel.PositionKeys[k].Time;
float x = channel.PositionKeys[k].Value.X;
float y = channel.PositionKeys[k].Value.Y;
float z = channel.PositionKeys[k].Value.Z;
float w = 1.0f;
dest.Write(t);
dest.Write(x);
dest.Write(y);
dest.Write(z);
dest.Write(w);
}
UInt32 rotCount = (UInt32)channel.RotationKeyCount;
dest.Write(rotCount);
for (int k = 0; k < rotCount; k++)
{
float t = (float)channel.RotationKeys[k].Time;
float x = channel.RotationKeys[k].Value.X;
float y = channel.RotationKeys[k].Value.Y;
float z = channel.RotationKeys[k].Value.Z;
float w = channel.RotationKeys[k].Value.W;
dest.Write(t);
dest.Write(x);
dest.Write(y);
dest.Write(z);
dest.Write(w);
}
UInt32 scaleCount = (UInt32)channel.ScalingKeyCount;
dest.Write(scaleCount);
for (int k = 0; k < scaleCount; k++)
{
float t = (float)channel.ScalingKeys[k].Time;
float x = channel.ScalingKeys[k].Value.X;
float y = channel.ScalingKeys[k].Value.Y;
float z = channel.ScalingKeys[k].Value.Z;
float w = 1.0f;
dest.Write(t);
dest.Write(x);
dest.Write(y);
dest.Write(z);
dest.Write(w);
}
}
dest.Close();
fs.Close();
}
}
public void TestExportToFile()
{
String path = Path.Combine(TestHelper.RootPath, "TestFiles\\ExportedTriangle.obj");
//Create a very simple scene a single node with a mesh that has a single face, a triangle and a default material
Scene scene = new Scene();
scene.RootNode = new Node("Root");
Mesh triangle = new Mesh("", PrimitiveType.Triangle);
triangle.Vertices.Add(new Vector3D(1, 0, 0));
triangle.Vertices.Add(new Vector3D(5, 5, 0));
triangle.Vertices.Add(new Vector3D(10, 0, 0));
triangle.Faces.Add(new Face(new int[] { 0, 1, 2 }));
triangle.MaterialIndex = 0;
scene.Meshes.Add(triangle);
scene.RootNode.MeshIndices.Add(0);
Material mat = new Material();
mat.Name = "MyMaterial";
scene.Materials.Add(mat);
//Export the scene then read it in and compare!
AssimpContext context = new AssimpContext();
Assert.IsTrue(context.ExportFile(scene, path, "obj"));
Scene importedScene = context.ImportFile(path);
Assert.IsTrue(importedScene.MeshCount == scene.MeshCount);
Assert.IsTrue(importedScene.MaterialCount == 2); //Always has the default material, should also have our material
//Compare the meshes
Mesh importedTriangle = importedScene.Meshes[0];
Assert.IsTrue(importedTriangle.VertexCount == triangle.VertexCount);
for(int i = 0; i < importedTriangle.VertexCount; i++)
{
Assert.IsTrue(importedTriangle.Vertices[i].Equals(triangle.Vertices[i]));
}
Assert.IsTrue(importedTriangle.FaceCount == triangle.FaceCount);
for(int i = 0; i < importedTriangle.FaceCount; i++)
{
Face importedFace = importedTriangle.Faces[i];
Face face = triangle.Faces[i];
for(int j = 0; j < importedFace.IndexCount; j++)
{
Assert.IsTrue(importedFace.Indices[j] == face.Indices[j]);
}
}
}
public void TestExportToBlob()
{
String colladaPath = Path.Combine(TestHelper.RootPath, "TestFiles\\duck.dae");
AssimpContext context = new AssimpContext();
Scene ducky = context.ImportFile(colladaPath);
ExportDataBlob blob = context.ExportToBlob(ducky, "obj");
Assert.IsTrue(blob.HasData);
Assert.IsTrue(blob.NextBlob != null);
Assert.IsTrue(blob.NextBlob.Name.Equals("mtl"));
}
public void TestImportFromFile()
{
String path = Path.Combine(TestHelper.RootPath, "TestFiles\\sphere.obj");
AssimpContext importer = new AssimpContext();
importer.SetConfig(new NormalSmoothingAngleConfig(55.0f));
importer.Scale = .5f;
importer.XAxisRotation = 25.0f;
importer.YAxisRotation = 50.0f;
LogStream.IsVerboseLoggingEnabled = true;
Assert.IsTrue(importer.ContainsConfig(NormalSmoothingAngleConfig.NormalSmoothingAngleConfigName));
importer.RemoveConfigs();
Assert.IsFalse(importer.ContainsConfig(NormalSmoothingAngleConfig.NormalSmoothingAngleConfigName));
importer.SetConfig(new NormalSmoothingAngleConfig(65.0f));
importer.SetConfig(new NormalSmoothingAngleConfig(22.5f));
importer.RemoveConfig(NormalSmoothingAngleConfig.NormalSmoothingAngleConfigName);
Assert.IsFalse(importer.ContainsConfig(NormalSmoothingAngleConfig.NormalSmoothingAngleConfigName));
importer.SetConfig(new NormalSmoothingAngleConfig(65.0f));
Scene scene = importer.ImportFile(path, PostProcessPreset.TargetRealTimeMaximumQuality);
Assert.IsNotNull(scene);
Assert.IsTrue((scene.SceneFlags & SceneFlags.Incomplete) != SceneFlags.Incomplete);
}
