static void Main(string[] args)
{
if (args.Length < 1)
{
Console.WriteLine(EXENAME + " <filename>");
return;
}
string fname = Environment.CurrentDirectory + "/" + args[0];
if (!File.Exists(fname))
{
Console.WriteLine("Invalid filename.");
Console.WriteLine(EXENAME + " <filename>");
return;
}
AssimpContext ac = new AssimpContext();
PT = args.Length > 1 && args[1].ToLower().Contains("pretrans");
TEXTURE = args.Length > 1 && args[1].ToLower().Contains("texture");
Console.WriteLine("Pre-transform = " + PT);
Console.WriteLine("Texture = " + TEXTURE);
Scene fdata = ac.ImportFile(fname, PostProcessSteps.Triangulate | PostProcessSteps.FlipWindingOrder);
if (File.Exists(fname + ".vmd"))
{
File.Delete(fname + ".vmd");
}
FileStream fs = File.OpenWrite(fname + ".vmd");
File.WriteAllText(fname + ".skin", ExportModelData(fdata, fs));
fs.Flush();
fs.Close();
}
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);
}
private void OnLoadAssets_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog filePicker = new OpenFileDialog {
Filter = "Any Assets|*.*"
};
if (filePicker.ShowDialog() == true)
{
string assetPath = filePicker.FileName;
// Check for duplicates
if (_assetPaths.LastIndexOf(assetPath) > -1)
{
MessageBox.Show("This file has already been loaded!");
return;
}
_assetPaths.Add(assetPath);
LoadedAssetsListbox.Items.Add(assetPath);
AssimpContext importer = new AssimpContext();
Scene scene = importer.ImportFile(assetPath, PostProcessSteps.None);
}
}
static void GainSphere()
{
AssimpContext c = new AssimpContext();
Scene s = c.ImportFile(@"C:\Users\jaken\Desktop\sphere.obj");
string text = "";
foreach (Vector3D v in s.Meshes[0].Vertices)
{
//text += v.X.ToString() + "f, " + v.Y.ToString() + "f, " + v.Z.ToString() + "f,\n";
}
for (int i = 0; i < s.Meshes[0].GetIndices().Count(); i += 10)
{
text += s.Meshes[0].GetIndices()[i + 0].ToString() + ", ";
text += s.Meshes[0].GetIndices()[i + 1].ToString() + ", ";
text += s.Meshes[0].GetIndices()[i + 2].ToString() + ", ";
text += s.Meshes[0].GetIndices()[i + 3].ToString() + ", ";
text += s.Meshes[0].GetIndices()[i + 4].ToString() + ", ";
text += s.Meshes[0].GetIndices()[i + 5].ToString() + ", ";
text += s.Meshes[0].GetIndices()[i + 6].ToString() + ", ";
text += s.Meshes[0].GetIndices()[i + 7].ToString() + ", ";
text += s.Meshes[0].GetIndices()[i + 8].ToString() + ", ";
text += s.Meshes[0].GetIndices()[i + 9].ToString() + ",\n";
}
File.WriteAllText(@"C:\Users\jaken\Desktop\sphere.txt", text);
}
public ModelObject(string tag, string fileName, string shaderType)
{
m_ShaderType = shaderType;
m_Tag = tag;
Scene model;
AssimpContext importer = new AssimpContext();
importer.SetConfig(new Assimp.Configs.NormalSmoothingAngleConfig(66.0f));
model = importer.ImportFile(fileName, PostProcessPreset.TargetRealTimeMaximumQuality);
m_Geometry = new Geometry[model.MeshCount];
m_NumberOfMeshes = m_Geometry.Length;
int count = 0;
foreach (var item in model.Meshes)
{
List <Vector3D[]> vertList = new List <Vector3D[]>
{
item.Vertices.ToArray(),
item.TextureCoordinateChannels[0].ToArray(),
item.Normals.ToArray(),
item.BiTangents.ToArray(),
item.Tangents.ToArray()
};
m_Geometry[count] = new Geometry(vertList, item.GetIndices(), item.VertexCount);
count++;
}
}
private void LoadModel(string fileName)
{
string path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Assets", fileName);
using (AssimpContext importer = new AssimpContext()) {
try {
importer.SetConfig(new NormalSmoothingAngleConfig(66.0f));
Scene scene = importer.ImportFile(path, PostProcessPreset.TargetRealTimeQuality | PostProcessSteps.FlipWindingOrder);
if (scene != null && scene.HasMeshes)
{
Console.WriteLine($"Loading {fileName}");
}
else
{
Console.WriteLine($"ERROR: Failed to load {fileName}");
return;
}
ProcessNode(scene.RootNode, scene);
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.ReferenceLoopHandling = ReferenceLoopHandling.Serialize;
settings.Formatting = Formatting.Indented;
string modelData = JsonConvert.SerializeObject(meshes, settings);
System.IO.File.WriteAllText(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Assets", fileName + ".json"), modelData);
Console.WriteLine($"Finished loading {fileName}");
}
catch (Exception e) {
Console.WriteLine($"ERROR: Somthing went wrong while loading the mesh {fileName}. " + e.Message);
}
}
}
public Model LoadModel(string filePath)
{
string path = Path.Combine(rootFolder, filePath);
if (_loadedModels.TryGetValue(path, out var mesh))
{
return(mesh);
}
var model = new Model(filePath.ToLower());
var context = new AssimpContext();
var scene = context.ImportFile(path, PostProcessSteps.Triangulate);
if (scene.SceneFlags == SceneFlags.Incomplete)
{
throw new Exception("Assimp import error");
}
foreach (var aiMesh in scene.Meshes)
{
model.Meshes.Add(LoadMesh(aiMesh, scene));
}
//SetupModel(model);
_loadedModels.Add(path, model);
return(model);
}
public Dictionary <string, EngineMaterial> LoadFromFile(string path)
{
string relativeLocation = Directory.GetParent(path).FullName;
Dictionary <string, EngineMaterial> mats = new Dictionary <string, EngineMaterial>();
List <Mesh> meshes = new List <Mesh>();
AssimpContext context = new AssimpContext();
Scene loadedAssimpScene = context.ImportFile(path, PostProcessSteps.OptimizeMeshes | PostProcessSteps.Triangulate | PostProcessSteps.FlipUVs);
if (loadedAssimpScene == null || loadedAssimpScene.SceneFlags == SceneFlags.Incomplete)
{
Console.WriteLine("Scene error");
}
List <AssimpMat> materials = loadedAssimpScene.Materials;
foreach (var material in materials)
{
EngineMaterial _material = new EngineMaterial();
_material.MaterialName = material.Name;
TextureSlot[] textureSlots = material.GetAllMaterialTextures();
if (material.HasTextureDiffuse)
{
_material.DiffuseMap = "C:/Users/kpbil/source/models/mira/textures/Mira_bc2.jpg"; //Path.Combine(relativeLocation, material.TextureDiffuse.FilePath);
}
if (material.HasTextureNormal)
{
_material.NormalMap = "C:/Users/kpbil/source/models/mira/textures/Mira_nm.jpg"; //Path.Combine(relativeLocation, material.TextureNormal.FilePath);
}
if (material.HasTextureAmbient)
{
_material.AmbientMap = "C:/Users/kpbil/source/models/mira/textures/Mira_ao.jpg";//Path.Combine(relativeLocation, material.TextureAmbient.FilePath);
}
try
{
_material.Metallic = "C:/Users/kpbil/source/models/mira/textures/Mira_metal.jpg";//Path.Combine(relativeLocation, textureSlots.Where(t => t.TextureType == TextureType.Unknown).FirstOrDefault().FilePath);
}
catch {
//TODO: add handling
}
try
{
_material.Roughness = "C:/Users/kpbil/source/models/mira/textures/Mira_rou.jpg";//Path.Combine(relativeLocation, textureSlots.Where(t => t.TextureType == TextureType.Unknown).FirstOrDefault().FilePath);
}
catch
{
//TODO: add handling
}
mats.Add(_material.MaterialName, _material);
}
return(mats);
}
public static Assimp.Scene Load(string fileName)
{
Assimp.AssimpContext importer = new AssimpContext();
importer.SetConfig(new Assimp.Configs.NormalSmoothingAngleConfig(0.66f));
Scene model = importer.ImportFile(fileName, PostProcessPreset.TargetRealTimeMaximumQuality);
return(model);
}
public static void Load(IEnumerable <string> paths)
{
foreach (var path in paths)
{
var name = Path.GetFileNameWithoutExtension(path);
Models.Add(name, AssimpContext.ImportFile(path, Flags).Meshes);
}
}
public static ImportedAnimation ImportFBX(string fbxPath, AnimationImportSettings settings)
{
using (var context = new AssimpContext())
{
var fbx = context.ImportFile(fbxPath, PostProcessSteps.CalculateTangentSpace | PostProcessSteps.GlobalScale);
return(ImportFromAssimpScene(fbx, settings));
}
}
public Mesh(string FileName)
{
Vertices = new ModelPart <Vertex>();
Indices = new ModelPart <int>();
PostProcessSteps Flags = PostProcessSteps.GenerateSmoothNormals | PostProcessSteps.CalculateTangentSpace | PostProcessSteps.Triangulate;
AssimpContext importer = new AssimpContext();
Scene model = importer.ImportFile(FileName, Flags);
foreach (Assimp.Mesh mesh in model.Meshes)
{
for (int i = 0; i < mesh.VertexCount; i++)
{
Vector3D Pos = mesh.Vertices[i];
Vector3D Normal = mesh.Normals[i];
Vector3D Tex = mesh.HasTextureCoords(0) ? mesh.TextureCoordinateChannels[0][i] : new Vector3D();
Vertices.Data.Add(new Vertex(new Vector3(Pos.X, Pos.Y, Pos.Z), new Vector3(Normal.X, Normal.Y, Normal.Z), new Vector2(Tex.X, Tex.Y)));
}
int indexBase = Indices.Data.Count();
foreach (Face Faces in mesh.Faces)
{
if (Faces.IndexCount != 3)
{
continue;
}
Indices.Data.Add(indexBase + Faces.Indices[0]);
Indices.Data.Add(indexBase + Faces.Indices[1]);
Indices.Data.Add(indexBase + Faces.Indices[2]);
}
}
Vertices.Count = Vertices.Data.Count();
Vertices.SizeInBytes = Utilities.SizeOf <Vertex>() * Vertices.Data.Count();
Vertices.Size = Utilities.SizeOf <Vertex>();
Indices.Count = Indices.Data.Count();
Indices.SizeInBytes = Utilities.SizeOf <int>() * Indices.Data.Count();
Indices.Size = Utilities.SizeOf <int>();
}
/// <summary>
/// Load an FBX file from a file on disk.
/// </summary>
/// <param name="filename">
/// The filename of the FBX file to load.
/// </param>
/// <param name="additionalAnimationFiles">
/// A dictionary mapping of animation names to filenames for additional FBX files to load.
/// </param>
/// <returns>
/// The loaded <see cref="IModel"/>.
/// </returns>
public IModel Load(string filename, Dictionary <string, string> additionalAnimationFiles)
{
this.LoadAssimpLibrary();
// Import the scene via AssImp.
var importer = new AssimpContext();
const PostProcessSteps ProcessFlags = 0
| PostProcessSteps.FlipUVs
| PostProcessSteps.FlipWindingOrder
;
var scene = importer.ImportFile(filename, ProcessFlags);
VertexPositionNormalTextureBlendable[] vertexes;
int[] indices;
IModelBone boneHierarchy;
if (scene.MeshCount >= 1)
{
var boneWeightingMap = this.BuildBoneWeightingMap(scene);
boneHierarchy = this.ImportBoneHierarchy(scene.RootNode, scene.Meshes[0]);
vertexes = this.ImportVertexes(scene, boneWeightingMap);
indices = this.ImportIndices(scene);
}
else
{
boneHierarchy = this.ImportBoneHierarchy(scene.RootNode, null);
vertexes = new VertexPositionNormalTextureBlendable[0];
indices = new int[0];
}
// Create the list of animations, including the null animation.
var animations = new List <IAnimation>();
// Import the basic animation.
if (scene.AnimationCount > 0)
{
animations.AddRange(
scene.Animations.Select(
assimpAnimation => this.ImportAnimation(assimpAnimation.Name, assimpAnimation)));
}
// For each additional animation file, import that and add the animation to the existing scene.
animations.AddRange(
from kv in additionalAnimationFiles
let animationImporter = new AssimpContext()
let additionalScene = animationImporter.ImportFile(kv.Value, ProcessFlags)
where additionalScene.AnimationCount == 1
select this.ImportAnimation(kv.Key, additionalScene.Animations[0]));
// Return the resulting model.
return(new Model(
new AnimationCollection(animations),
boneHierarchy,
vertexes,
indices));
}
public static void Start()
{
Cam = new Object3D("Camera", new Vector3(0, 0, 0), new Vector3(0, 0, 0), new Vector3(0, 0, 0), new Component3D[] { new Camera3DComponent(75) });
AssimpContext imp = new AssimpContext();
Scene scn = imp.ImportFile(ContentLoader.ContentPath + "/Defaults/Cube.dae");
Cube = new Object3D("Cube", new Vector3(0, 0, 5), new Vector3(1, 1, 1), new Vector3(0, 0, 0), new Component3D[] { new Renderer3DComponent(scn.Meshes[0], new Vector3(0.1f, 0.1f, 0.1f), new Vector3(1, 0, 0)) });
}
public void LoadFile(string FileName)
{
AssimpContext Importer = new AssimpContext();
scene = Importer.ImportFile(FileName, PostProcessSteps.Triangulate | PostProcessSteps.JoinIdenticalVertices
| PostProcessSteps.FlipUVs | PostProcessSteps.ValidateDataStructure |
PostProcessSteps.CalculateTangentSpace | PostProcessSteps.GenerateNormals);
LoadMeshes();
}
public static G3D LoadAssimpFile(string filePath)
{
using (var context = new AssimpContext())
{
var scene = context.ImportFile(filePath);
Assert.AreEqual(1, scene.Meshes.Count);
return(scene.Meshes[0].ToG3D());
}
}
private void Load(string path)
{
AssimpContext importer = new AssimpContext();
Scene scene = importer.ImportFile(path, PostProcessSteps.Triangulate);
//directory = path.(0, path.find_last_of('/'));
ProcessNode(scene.RootNode, scene);
}
static void Main()
{
String fileName = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "duck.dae");
AssimpContext importer = new AssimpContext();
var m_model = importer.ImportFile(fileName);
return;
}
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]);
}
}
}
static void Main(string[] args)
{
AssimpContext c = new AssimpContext();
c.SetConfig(new NormalSmoothingAngleConfig(66));
Scene s = c.ImportFile("test.fbx");
Console.WriteLine("Hello World!");
}
private void loadModel(string path)
{
AssimpContext importer = new AssimpContext();
Assimp.Scene scene = new Assimp.Scene();
scene = importer.ImportFile(path, PostProcessSteps.Triangulate | PostProcessSteps.FlipUVs);
directory = path.Substring(0, path.LastIndexOf('/'));
processNode(scene.RootNode, scene);
}
public Model(string path)
{
var importer = new AssimpContext();
importer.SetConfig(new NormalSmoothingAngleConfig(66.0f));
var scene = importer.ImportFile(path, PostProcessSteps.Triangulate | PostProcessSteps.FlipUVs);
processNode(scene.RootNode, scene);
}
public static Mesh LoadFromModel(string Filename)
{
if (Cache.ContainsKey(Filename))
{
return(Cache[Filename]);
}
Assimp.Scene scene = Context.ImportFile(Filename, PostProcess);
Cache.Add(Filename, GetMesh(scene));
return(Cache[Filename]);
}
public void LoadAssimpFile(string filePath)
{
var scene = context.ImportFile(filePath, PostProcessSteps.Triangulate);
LoadedMeshes = scene.Meshes
.Select(ToMeshData)
.ToList();
CollectInstances(scene.RootNode, Matrix4x4.Identity, LoadedInstances);
meshesLoaded = true;
}
public void TestImportExportFile()
{
String colladaPath = Path.Combine(TestHelper.RootPath, "TestFiles\\duck.dae");
String plyPath = Path.Combine(TestHelper.RootPath, "TestFiles\\duck.ply");
AssimpContext context = new AssimpContext();
Scene ducky = context.ImportFile(colladaPath);
context.ExportFile(ducky, plyPath, "ply");
}
private void LoadModel(string path)
{
using var importer = new AssimpContext();
string fullPath = Path.Combine(AppContext.BaseDirectory, path);
Directory = fullPath.Substring(0, fullPath.LastIndexOf('/'));
Scene scene = importer.ImportFile(fullPath, PostProcessSteps.ValidateDataStructure | PostProcessSteps.Triangulate | PostProcessSteps.FlipUVs | PostProcessSteps.CalculateTangentSpace | PostProcessSteps.GenerateSmoothNormals);
ProcessNode(scene.RootNode, scene);
}
public override NodeContent Import(string filename, ContentImporterContext context)
{
var identity = new ContentIdentity(filename, GetType().Name);
using (var importer = new AssimpContext())
{
_scene = importer.ImportFile(filename,
//PostProcessSteps.FindInstances | // No effect + slow?
PostProcessSteps.FindInvalidData |
PostProcessSteps.FlipUVs |
PostProcessSteps.FlipWindingOrder |
//PostProcessSteps.MakeLeftHanded | // Appears to just mess things up
PostProcessSteps.JoinIdenticalVertices |
PostProcessSteps.ImproveCacheLocality |
PostProcessSteps.OptimizeMeshes |
//PostProcessSteps.OptimizeGraph | // Will eliminate helper nodes
PostProcessSteps.RemoveRedundantMaterials |
PostProcessSteps.Triangulate
);
_globalInverseXform = _scene.RootNode.Transform;
_globalInverseXform.Inverse();
_rootNode = new NodeContent
{
Name = _scene.RootNode.Name,
Identity = identity,
Transform = ToXna(_scene.RootNode.Transform)
};
_materials = ImportMaterials(identity, _scene);
FindMeshes(_scene.RootNode, _scene.RootNode.Transform);
if (_scene.HasAnimations)
{
var skeleton = CreateSkeleton();
CreateAnimation(skeleton);
}
// If we have a simple hierarchy with no bones and just the one
// mesh, we can flatten it out so the mesh is the root node.
if (_rootNode.Children.Count == 1 && _rootNode.Children[0] is MeshContent)
{
var absXform = _rootNode.Children[0].AbsoluteTransform;
_rootNode = _rootNode.Children[0];
_rootNode.Identity = identity;
_rootNode.Transform = absXform;
}
_scene.Clear();
}
return(_rootNode);
}
/// <summary>
/// loads models, materials, ... based on info in PartData
/// </summary>
public override void LoadMesh()
{
try
{
var lod = partData.Renderable.LodList.First();
Scene meshScene = assimpImporter.ImportFile(PathResolver.ResolvePath(lod.Mesh, this.mod?.ModFolderPath));
this.subMeshes = meshScene.Meshes.Select(mesh => ConvertMesh(mesh)).ToArray();
if (lod.SubMeshList != null)
{
this.materials = lod.SubMeshList.Select(submesh => submesh.Material).ToArray();
}
if (lod.SubMeshMap != null)
{
this.materials = meshScene.Materials.Select(material => lod.SubMeshMap[material.Name]?.Material).ToArray();
}
if (lod.Pose0 != null && false)
{
Scene pose0Scene = assimpImporter.ImportFile(PathResolver.ResolvePath(lod.Pose0, this.mod?.ModFolderPath));
this.pose0 = pose0Scene.Meshes.Select(mesh => ConvertMesh(mesh)).ToArray();
}
if (lod.Pose1 != null && false)
{
Scene pose1Scene = assimpImporter.ImportFile(PathResolver.ResolvePath(lod.Pose1, this.mod?.ModFolderPath));
this.pose1 = pose1Scene.Meshes.Select(mesh => ConvertMesh(mesh)).ToArray();
}
if (lod.Pose2 != null && false)
{
Scene pose2Scene = assimpImporter.ImportFile(PathResolver.ResolvePath(lod.Pose2, this.mod?.ModFolderPath));
this.pose2 = pose2Scene.Meshes.Select(mesh => ConvertMesh(mesh)).ToArray();
}
}
catch (Exception e)
{
Debug.LogException(new Exception($"\nFailed loading model for part {partData.Uuid}", e));
// use cuboid from prefab, stretch if bounds found in partdata
// use diffuse & normal from prefab
}
}
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 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 static Mesh LoadMesh(string path, Material meshMaterial)
{
Scene scene = importer.ImportFile(path, PostProcessSteps.MakeLeftHanded | PostProcessSteps.GenerateSmoothNormals);
Buffer vertexBuffer = MeshLoader.CreateVertexBufferFromMesh(scene.Meshes[0]);
Buffer indexBuffer = MeshLoader.CreateIndexBufferFromMesh(scene.Meshes[0]);
Mesh createdMesh = new Mesh(vertexBuffer, indexBuffer, meshMaterial, 0, scene.Meshes[0].GetIndices().Length);
return(createdMesh);
}
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 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 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 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 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);
}
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 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);
}
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();
}
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();
}
}
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 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");
}
