public static MeshData[] LoadModelFromFile(string filename) { var importer = new AssimpContext(); if (!importer.IsImportFormatSupported(System.IO.Path.GetExtension(filename))) { throw new ArgumentException($"Model format {System.IO.Path.GetExtension(filename)} is not supported. Cannot load {filename}.", nameof(filename)); } var postProcessFlags = PostProcessSteps.GenerateSmoothNormals | PostProcessSteps.CalculateTangentSpace; var model = importer.ImportFile(filename, postProcessFlags); List <MeshData> meshDatas = new List <MeshData>(model.MeshCount); MeshData meshData = new MeshData(); foreach (var mesh in model.Meshes) { List <MyVertex> myVertices = new List <MyVertex>(mesh.VertexCount); for (int i = 0; i < mesh.VertexCount; i++) { var pos = mesh.HasVertices ? mesh.Vertices[i].ToVector3() : new Vector3(); var norm = mesh.HasNormals ? mesh.Normals[i] : new Vector3D(); var texC = mesh.HasTextureCoords(0) ? mesh.TextureCoordinateChannels[0][i] : new Vector3D(1, 1, 0); var v = new MyVertex(pos, norm.ToVector3(), texC.ToVector2()); myVertices.Add(v); } var indices = mesh.GetIndices().ToList(); meshData.Vertices = myVertices.ToArray(); meshData.Indices = indices.ToArray(); meshDatas.Add(meshData); } return(meshDatas.ToArray()); }
public ModelUtil(string file) { AssimpContext importer = new AssimpContext(); fileInfo = new FileInfo(file); if (fileInfo.Exists && importer.IsImportFormatSupported(fileInfo.Extension)) { scene = importer.ImportFile(file, PostProcessSteps.GenerateNormals | PostProcessSteps.CalculateTangentSpace | PostProcessSteps.Triangulate); } else { Console.WriteLine("Extension <{0}> isn't supported!", fileInfo.Extension); } name = fileInfo.Name.Substring(0, fileInfo.Name.LastIndexOf('.')); string outDir = fileInfo.DirectoryName + @"\" + name; if (!Directory.Exists(outDir)) { outDirInfo = Directory.CreateDirectory(outDir); } else { outDirInfo = new DirectoryInfo(outDir); } }
public void Create(Device1 device) { PrimitiveTopology = PrimitiveTopology.TriangleList; VertexStride = Marshal.SizeOf <VertexPosColNormTex>(); var verts = new List <VertexPosColNormTex>(); var importer = new AssimpContext(); var s = importer.GetSupportedImportFormats(); if (!importer.IsImportFormatSupported(Path.GetExtension(_FileName))) { throw new ArgumentException( "Model format " + Path.GetExtension(_FileName) + " is not supported! Cannot load {1}", "filename"); } var model = importer.ImportFile(_FileName, PostProcessSteps.GenerateSmoothNormals | PostProcessSteps.CalculateTangentSpace | PostProcessSteps.Triangulate); foreach (var mesh in model.Meshes) { for (int i = 0; i < mesh.VertexCount; i++) { var pos = new Vector3(mesh.Vertices[i].X, mesh.Vertices[i].Y, mesh.Vertices[i].Z); var color = Color.AliceBlue; var norm = new Vector3(mesh.Normals[i].X, mesh.Normals[i].Y, mesh.Normals[i].Z); var tx = new Vector2(mesh.TextureCoordinateChannels[0][i].X, -mesh.TextureCoordinateChannels[0][i].Y); verts.Add(new VertexPosColNormTex(pos, color, norm, tx)); } var bufferDesc = new BufferDescription { Usage = ResourceUsage.Immutable, BindFlags = BindFlags.VertexBuffer, SizeInBytes = VertexStride * verts.Count, CpuAccessFlags = CpuAccessFlags.None, OptionFlags = ResourceOptionFlags.None }; VertexBuffer = new Buffer(device, DataStream.Create(verts.ToArray(), false, false), bufferDesc); IndexCount = mesh.GetIndices().Length; //buffer creations bufferDesc = new BufferDescription { Usage = ResourceUsage.Immutable, BindFlags = BindFlags.IndexBuffer, SizeInBytes = sizeof(uint) * IndexCount, CpuAccessFlags = CpuAccessFlags.None, OptionFlags = ResourceOptionFlags.None }; IndexBuffer = new Buffer(device, DataStream.Create(mesh.GetIndices(), false, false), bufferDesc); } }
public static ResourceType GetResourceTypeFromFile(string fullPath) { // Check if it's an image if (FreeImage.GetFileType(fullPath, 0) != FREE_IMAGE_FORMAT.FIF_UNKNOWN || FreeImage.GetFIFFromFilename(fullPath) != FREE_IMAGE_FORMAT.FIF_UNKNOWN) { return(ResourceType.Texture); } // Check if it's a model var assimp = new AssimpContext(); return(assimp.IsImportFormatSupported(Path.GetExtension(fullPath)) ? ResourceType.Model : ResourceType.Unknown); // Unknown resource type, out of luck }
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 Model(string file, D3D11.Device device, Matrix transform) { AssimpContext ctx = new AssimpContext(); if (!ctx.IsImportFormatSupported(Path.GetExtension(file))) { return; } modelPath = Path.GetDirectoryName(file); Scene scene = ctx.ImportFile(file); Node node = scene.RootNode; Meshes = new List <ModelMesh>(); AddNode(scene, scene.RootNode, device, Matrix.Identity, transform); constants = new Constants(); SpecularColor = Color.White; Shininess = 200; SpecularIntensity = 1; EmissiveIntensity = 1; }
public static void LoadSource(this RMesh rmesh, string filename) { AssimpContext context = new AssimpContext(); context.SetConfig(new Assimp.Configs.FBXImportAllMaterialsConfig(true)); context.SetConfig(new Assimp.Configs.FBXImportAllGeometryLayersConfig(true)); context.SetConfig(new Assimp.Configs.MultithreadingConfig(2)); context.SetConfig(new Assimp.Configs.FBXStrictModeConfig(false)); if (!context.IsImportFormatSupported(Path.GetExtension(filename))) { throw new ReactorException("Attempted to load a model that Assimp doesn't know how to load"); } LogStream log = new LogStream((msg, user) => { RLog.Info(msg.Remove(msg.Length - 2)); }); log.Attach(); int platform = (int)Environment.OSVersion.Platform; Scene scene = context.ImportFile(filename, PostProcessSteps.FindInvalidData | PostProcessSteps.GenerateSmoothNormals | PostProcessSteps.Triangulate | PostProcessSteps.GenerateUVCoords | PostProcessSteps.CalculateTangentSpace | PostProcessSteps.PreTransformVertices); if (scene.HasMeshes) { foreach (Mesh mesh in scene.Meshes) { if (!mesh.HasVertices) { continue; } RMeshPart rmeshpart = RMeshPart.Create <RMeshPart> (); RVertexData [] data = new RVertexData [mesh.VertexCount]; List <int> indicesList = new List <int> (); if (mesh.HasFaces) { foreach (Face face in mesh.Faces) { indicesList.AddRange(face.Indices.ToArray()); foreach (int index in face.Indices) { Vector3D p = mesh.Vertices [index]; data [index].Position = new Vector3(p.X, p.Y, p.Z); if (mesh.HasTextureCoords(0)) { Vector3D t = mesh.TextureCoordinateChannels [0] [index]; data [index].TexCoord = new Vector2(t.X, -t.Y); } if (mesh.HasNormals) { Vector3D n = mesh.Normals [index]; data [index].Normal = new Vector3(n.X, n.Y, n.Z); } if (mesh.HasTangentBasis) { Vector3D b = mesh.BiTangents [index]; Vector3D t = mesh.Tangents [index]; data [index].Bitangent = new Vector3(b.X, b.Y, b.Z); data [index].Tangent = new Vector3(t.X, t.Y, t.Z); } } } } RVertexBuffer vbuffer = new RVertexBuffer(typeof(RVertexData), mesh.VertexCount, RBufferUsage.WriteOnly, true); RIndexBuffer ibuffer = new RIndexBuffer(typeof(int), indicesList.Count, RBufferUsage.WriteOnly); ibuffer.SetData(indicesList.ToArray()); vbuffer.SetData <RVertexData> (data); #if WINDOWS var separator = "\\"; #else var separator = "/"; #endif rmeshpart.VertexBuffer = vbuffer; rmeshpart.IndexBuffer = ibuffer; RMaterial material = new RMaterial(rmesh.Name + ":Material"); if (scene.HasMaterials) { Material mat = scene.Materials[mesh.MaterialIndex]; material.Shininess = mat.Shininess; material.SetColor(RMaterialColor.DIFFUSE, new RColor(mat.ColorDiffuse.R, mat.ColorDiffuse.G, mat.ColorDiffuse.B, mat.ColorDiffuse.A)); if (mat.HasTextureDiffuse) { var texFileName = Path.GetFileName(mat.TextureDiffuse.FilePath.Replace("\\", separator).Replace("/", separator)); RTexture2D tex = (RTexture2D)RTextures.Instance.CreateTexture <RTexture2D>(texFileName, "/textures/" + texFileName.ToLower()); tex.Bind(); tex.GenerateMipmaps(); tex.SetTextureMagFilter(RTextureMagFilter.Linear); tex.SetTextureMinFilter(RTextureMinFilter.LinearMipmapLinear); tex.SetTextureWrapMode(RTextureWrapMode.Repeat, RTextureWrapMode.Repeat); tex.Unbind(); material.SetTexture(RTextureLayer.DIFFUSE, tex); } if (mat.HasTextureNormal) { var texFileName = Path.GetFileName(mat.TextureNormal.FilePath.Replace("\\", separator).Replace("/", separator)); RTexture2D tex = (RTexture2D)RTextures.Instance.CreateTexture <RTexture2D>(texFileName, "/textures/" + texFileName.ToLower()); tex.Bind(); tex.GenerateMipmaps(); tex.SetTextureMagFilter(RTextureMagFilter.Linear); tex.SetTextureMinFilter(RTextureMinFilter.LinearMipmapLinear); tex.SetTextureWrapMode(RTextureWrapMode.Repeat, RTextureWrapMode.Repeat); tex.Unbind(); material.SetTexture(RTextureLayer.NORMAL, tex); } if (mat.HasTextureAmbient) { var texFileName = Path.GetFileName(mat.TextureAmbient.FilePath.Replace("\\", separator).Replace("/", separator)); RTexture2D tex = (RTexture2D)RTextures.Instance.CreateTexture <RTexture2D>(texFileName, "/textures/" + texFileName.ToLower()); tex.SetTextureMagFilter(RTextureMagFilter.Linear); tex.SetTextureMinFilter(RTextureMinFilter.LinearMipmapLinear); tex.SetTextureWrapMode(RTextureWrapMode.Repeat, RTextureWrapMode.Repeat); material.SetTexture(RTextureLayer.AMBIENT, tex); } if (mat.HasTextureHeight) { var texFileName = Path.GetFileName(mat.TextureHeight.FilePath.Replace("\\", separator).Replace("/", separator)); RTexture2D tex = (RTexture2D)RTextures.Instance.CreateTexture <RTexture2D>(texFileName, "/textures/" + texFileName.ToLower()); tex.SetTextureMagFilter(RTextureMagFilter.Linear); tex.SetTextureMinFilter(RTextureMinFilter.LinearMipmapLinear); tex.SetTextureWrapMode(RTextureWrapMode.Repeat, RTextureWrapMode.Repeat); material.SetTexture(RTextureLayer.HEIGHT, tex); } if (mat.HasTextureEmissive) { var texFileName = Path.GetFileName(mat.TextureEmissive.FilePath.Replace("\\", separator).Replace("/", separator)); RTexture2D tex = (RTexture2D)RTextures.Instance.CreateTexture <RTexture2D>(texFileName, "/textures/" + texFileName.ToLower()); tex.SetTextureMagFilter(RTextureMagFilter.Linear); tex.SetTextureMinFilter(RTextureMinFilter.LinearMipmapLinear); tex.SetTextureWrapMode(RTextureWrapMode.Repeat, RTextureWrapMode.Repeat); material.SetTexture(RTextureLayer.GLOW, tex); } if (mat.HasTextureSpecular) { var texFileName = Path.GetFileName(mat.TextureSpecular.FilePath.Replace("\\", separator).Replace("/", separator)); RTexture2D tex = (RTexture2D)RTextures.Instance.CreateTexture <RTexture2D>(texFileName, "/textures/" + texFileName.ToLower()); tex.SetTextureMagFilter(RTextureMagFilter.Linear); tex.SetTextureMinFilter(RTextureMinFilter.LinearMipmapLinear); tex.SetTextureWrapMode(RTextureWrapMode.Repeat, RTextureWrapMode.Repeat); material.SetTexture(RTextureLayer.SPECULAR, tex); } } rmeshpart.Material = material; rmesh.Parts.Add(rmeshpart); } //return rmesh; } //return null; if (rmesh.Parts.Count == 0) { throw new ReactorException("Attempted to load a model when Assimp couldn't find any verticies!"); } context.Dispose(); }
public void ReadFromFile(string filename) { var file = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), filename); //Create new importer var importer = new AssimpContext(); //Check if model is supported if (!importer.IsImportFormatSupported(Path.GetExtension(file))) { throw new ArgumentException("Model format " + Path.GetExtension(file) + " is not supported! Cannot load {1}", "filename"); } //Configs importer.SetConfig(new NormalSmoothingAngleConfig(66.0f)); var model = importer.ImportFile(file, PostProcessPreset.TargetRealTimeMaximumQuality); importer.Dispose(); MeshData = new MeshData(); AnimationData = new AnimationData(); foreach (var mesh in model.Meshes) { MeshData.Indices = mesh.GetIndices().ToList(); MeshData.IndexCount = MeshData.Indices.Count; MeshData.Name = mesh.Name; MeshData.VertexCount = mesh.VertexCount; foreach (var v in mesh.Vertices) { MeshData.VertexPositions.Add(new Vector3(v.X, v.Y, v.Z)); } foreach (var v in mesh.Normals) { MeshData.VertexNormals.Add(new Vector3(v.X, v.Y, v.Z)); } foreach (var v in mesh.TextureCoordinateChannels[0]) { MeshData.VertexTextureCoordinates.Add(new Vector2(v.X, v.Y)); } AnimationData.BoneCount = mesh.BoneCount; foreach (var b in mesh.Bones) { var j = new AnimationJoint(); j.Name = b.Name; //j.OffsetMatrix = b.OffsetMatrix; AnimationData.Bones.Add(j); } } return; //TO DO STILL BONES ARE DONE IN A DIFFERENT WAY AnimationData.HasAnimations = model.HasAnimations; foreach (var a in model.Animations) { //Clip var clip = new AnimationClip() { Name = a.Name, Duration = (float)a.DurationInTicks, TicksPerSecond = (float)a.TicksPerSecond }; //KeyFrames foreach (var m in a.NodeAnimationChannels) { var key = new AnimationKey(); for (var i = 0; i < m.PositionKeyCount; ++i) { var time = m.PositionKeys[i].Time; var pos = m.PositionKeys[i].Value.ToVector3(); var rot = m.RotationKeys[i].Value; var s = m.ScalingKeys[i].Value.ToVector3(); } //clip.Keys.Add(key); } } // AnimationData.Animations.Add(clip); //} }
public override bool CanLoadExt(string Extension) { bool Can = AssimpCtx.IsImportFormatSupported(Extension); return(Can); }
private BasicModel(Device device, TextureManager11 textureManager, string filename, string texturePath, bool autoLoadTextures, bool flipUv, bool tex1By1) { var importer = new AssimpContext(); if (!importer.IsImportFormatSupported(Path.GetExtension(filename))) { throw new ArgumentException($"Model format {Path.GetExtension(filename)} is not supported. Cannot load {filename}.", nameof(filename)); } #if DEBUG var logStream = new ConsoleLogStream(); logStream.Attach(); #endif var postProcessFlags = PostProcessSteps.GenerateSmoothNormals | PostProcessSteps.CalculateTangentSpace; if (flipUv) { postProcessFlags |= PostProcessSteps.FlipUVs; } var model = importer.ImportFile(filename, postProcessFlags); var min = new Vector3(float.MaxValue); var max = new Vector3(float.MinValue); _meshCount = model.Meshes.Count; foreach (var mesh in model.Meshes) { var verts = new List <VertPosNormTexTan>(); var subset = new MeshSubset() { VertexCount = mesh.VertexCount, VertexStart = Vertices.Count, FaceStart = Indices.Count / 3, FaceCount = mesh.FaceCount }; Subsets.Add(subset); // bounding box corners for (var i = 0; i < mesh.VertexCount; i++) { var pos = mesh.HasVertices ? mesh.Vertices[i].ToVector3() : new Vector3(); min = MathF.Minimize(min, pos); max = MathF.Maximize(max, pos); var norm = mesh.HasNormals ? mesh.Normals[i] : new Vector3D(); var texC = mesh.HasTextureCoords(0) ? mesh.TextureCoordinateChannels[0][i] : (tex1By1 ? new Vector3D(1, 1, 0) : new Vector3D()); var tan = mesh.HasTangentBasis ? mesh.Tangents[i] : new Vector3D(); var v = new VertPosNormTexTan(pos, norm.ToVector3(), texC.ToVector2(), tan.ToVector3()); verts.Add(v); } Vertices.AddRange(verts); var indices = mesh.GetIndices().Select(i => i + subset.VertexStart).ToList(); Indices.AddRange(indices); var mat = model.Materials[mesh.MaterialIndex]; var material = mat.ToMaterial(); Materials.Add(material); if (autoLoadTextures) { TextureSlot diffuseSlot; mat.GetMaterialTexture(TextureType.Diffuse, 0, out diffuseSlot); var diffusePath = diffuseSlot.FilePath; if (Path.GetExtension(diffusePath) == ".tga") { // DirectX doesn't like to load tgas, so you will need to convert them to pngs yourself with an image editor diffusePath = diffusePath.Replace(".tga", ".png"); } var fullDiffusePath = diffusePath == null ? null : Path.Combine(texturePath, diffusePath); if (File.Exists(fullDiffusePath)) { DiffuseMapSRV.Add(textureManager.CreateTexture(fullDiffusePath)); } else { DiffuseMapSRV.Add(textureManager.CreateColor1By1(material.Diffuse.ToColor())); } TextureSlot normalSlot; mat.GetMaterialTexture(TextureType.Normals, 0, out normalSlot); var normalPath = normalSlot.FilePath; var fullNormalPath = normalPath == null ? null : Path.Combine(texturePath, normalPath); string textureName; if (File.Exists(fullNormalPath)) { textureName = fullNormalPath; } else { if (File.Exists(fullDiffusePath)) { var normalExt = Path.GetExtension(fullDiffusePath); normalPath = Path.GetFileNameWithoutExtension(diffusePath) + "_nmap" + normalExt; fullNormalPath = Path.Combine(texturePath, normalPath); if (File.Exists(fullNormalPath)) { textureName = fullNormalPath; } else { textureName = TextureManager11.TexDefaultNorm; } } else { textureName = TextureManager11.TexDefaultNorm; } } NormalMapSRV.Add(textureManager.CreateTexture(textureName)); } } BoundingBox = new BoundingBox(min, max); ModelMesh.SetSubsetTable(Subsets); ModelMesh.SetVertices(device, Vertices); ModelMesh.SetIndices(device, Indices); }
public BasicModel(Device device, TextureManager texMgr, string filename, string texturePath, bool flipUv = false) { var importer = new AssimpContext(); if (!importer.IsImportFormatSupported(Path.GetExtension(filename))) { throw new ArgumentException("Model format " + Path.GetExtension(filename) + " is not supported! Cannot load {1}", "filename"); } #if DEBUG var logStream = new ConsoleLogStream(); logStream.Attach(); //importer. .AttachLogStream(new ConsoleLogStream()); //importer.VerboseLoggingEnabled = true; #endif var postProcessFlags = PostProcessSteps.GenerateSmoothNormals | PostProcessSteps.CalculateTangentSpace; if (flipUv) { postProcessFlags |= PostProcessSteps.FlipUVs; } var model = importer.ImportFile(filename, postProcessFlags); var min = new Vector3(float.MaxValue); var max = new Vector3(float.MinValue); foreach (var mesh in model.Meshes) { var verts = new List <PosNormalTexTan>(); var subset = new MeshGeometry.Subset { VertexCount = mesh.VertexCount, VertexStart = Vertices.Count, FaceStart = Indices.Count / 3, FaceCount = mesh.FaceCount }; Subsets.Add(subset); // bounding box corners for (var i = 0; i < mesh.VertexCount; i++) { var pos = mesh.HasVertices ? mesh.Vertices[i].ToVector3() : new Vector3(); min = Vector3.Minimize(min, pos); max = Vector3.Maximize(max, pos); var norm = mesh.HasNormals ? mesh.Normals[i] : new Vector3D(); var texC = mesh.HasTextureCoords(0) ? mesh.TextureCoordinateChannels[0][i] : new Vector3D(); var tan = mesh.HasTangentBasis ? mesh.Tangents[i] : new Vector3D(); var v = new PosNormalTexTan(pos, norm.ToVector3(), texC.ToVector2(), tan.ToVector3()); verts.Add(v); } Vertices.AddRange(verts); var indices = mesh.GetIndices().Select(i => ((int)i + subset.VertexStart)).ToList(); Indices.AddRange(indices); var mat = model.Materials[mesh.MaterialIndex]; var material = mat.ToMaterial(); Materials.Add(material); TextureSlot diffuseSlot; mat.GetMaterialTexture(TextureType.Diffuse, 0, out diffuseSlot); var diffusePath = diffuseSlot.FilePath; if (Path.GetExtension(diffusePath) == ".tga") { // DirectX doesn't like to load tgas, so you will need to convert them to pngs yourself with an image editor diffusePath = diffusePath.Replace(".tga", ".png"); } if (!string.IsNullOrEmpty(diffusePath)) { DiffuseMapSRV.Add(texMgr.CreateTexture(Path.Combine(texturePath, diffusePath))); } TextureSlot normalSlot; mat.GetMaterialTexture(TextureType.Normals, 0, out normalSlot); var normalPath = normalSlot.FilePath; if (!string.IsNullOrEmpty(normalPath)) { NormalMapSRV.Add(texMgr.CreateTexture(Path.Combine(texturePath, normalPath))); } else { var normalExt = Path.GetExtension(diffusePath); normalPath = Path.GetFileNameWithoutExtension(diffusePath) + "_nmap" + normalExt; NormalMapSRV.Add(texMgr.CreateTexture(Path.Combine(texturePath, normalPath))); } } BoundingBox = new BoundingBox(min, max); ModelMesh.SetSubsetTable(Subsets); ModelMesh.SetVertices(device, Vertices); ModelMesh.SetIndices(device, Indices); }
public void Create(Device1 device, GenericShader effect) { PrimitiveTopology = PrimitiveTopology.TriangleList; VertexStride = effect.VertexStride; List <int> indices = new List <int>(); var importer = new AssimpContext(); Scene scene = importer.ImportFile(_fileName, PostProcessSteps.GenerateSmoothNormals | PostProcessSteps.CalculateTangentSpace | PostProcessSteps.Triangulate); if (!importer.IsImportFormatSupported(Path.GetExtension(_fileName))) { throw new Exception("File Format not supported"); } long vertCount = 0; foreach (var model in scene.Meshes) { vertCount += model.VertexCount; } var verts = new float[VertexStride * vertCount]; int meshOffset = 0; foreach (var model in scene.Meshes) { for (var i = 0; i < model.VertexCount; ++i) { var pos = model.Vertices[i]; var nor = model.Normals[i]; var uv = model.TextureCoordinateChannels[0][i]; uv.Y = -uv.Y; var col = model.HasVertexColors(0) ? model.VertexColorChannels[0][i] : new Color4D(1, 0, 1); var tan = model.Tangents[i]; var inputOffset = 0; foreach (var inputParam in effect.InputParameters) { if (inputParam.SemanticName == "POSITION") { Array.Copy(pos.ToArray(), 0, verts, i * (VertexStride / sizeof(float)) + inputOffset + meshOffset, 3); inputOffset += 3; } else if (inputParam.SemanticName == "NORMAL") { Array.Copy(nor.ToArray(), 0, verts, i * (VertexStride / sizeof(float)) + inputOffset + meshOffset, 3); inputOffset += 3; } else if (inputParam.SemanticName == "COLOR") { Array.Copy(col.ToArray(), 0, verts, i * (VertexStride / sizeof(float)) + inputOffset + meshOffset, 4); inputOffset += 4; } else if (inputParam.SemanticName == "TEXCOORD" || inputParam.SemanticName == "TEXCOORD0") { Array.Copy(uv.ToArray(), 0, verts, i * (VertexStride / sizeof(float)) + inputOffset + meshOffset, 2); inputOffset += 2; } else if (inputParam.SemanticName == "TANGENT") { Array.Copy(tan.ToArray(), 0, verts, i * (VertexStride / sizeof(float)) + inputOffset + meshOffset, 3); inputOffset += 3; } else { MessageBox.Show("AssimpModel::Create() > Unsupported Semantic type! ({inputParam.SemanticName})"); } } } meshOffset += model.VertexCount * VertexStride; indices.AddRange(model.GetIndices().ToList()); } IndexCount = indices.Count; BufferDescription bd = new BufferDescription( (int)(verts.Length), ResourceUsage.Immutable, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None); VertexBuffer = new Buffer(device, DataStream.Create(verts, false, false), bd); bd = new BufferDescription( sizeof(int) * IndexCount, ResourceUsage.Immutable, BindFlags.IndexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None); IndexBuffer = new Buffer(device, DataStream.Create(indices.ToArray(), false, false), bd); }
public Mesh(string FileName, bool flipUv = false) { Vertices = new List <Vertex>(); Indices = new List <int>(); AssimpContext importer = new AssimpContext(); if (!importer.IsImportFormatSupported(Path.GetExtension(FileName))) { throw new ArgumentException("Model format " + Path.GetExtension(FileName) + " is not supported! Cannot load {1}", "filename"); } ConsoleLogStream logStream = new ConsoleLogStream(); logStream.Attach(); PostProcessSteps postProcessFlags = PostProcessSteps.GenerateSmoothNormals | PostProcessSteps.CalculateTangentSpace; if (flipUv) { postProcessFlags |= PostProcessSteps.FlipUVs; } Scene model = importer.ImportFile(FileName, postProcessFlags); int[] indices = new int[model.Meshes.Sum(m => m.FaceCount * 3)]; int vertexOffSet = 0; int indexOffSet = 0; foreach (Assimp.Mesh mesh in model.Meshes) { List <Vertex> verts = new List <Vertex>(); List <Face> faces = mesh.Faces; for (int i = 0; i < mesh.VertexCount; i++) { Vector3 pos = mesh.HasVertices ? new Vector3(mesh.Vertices[i].X, mesh.Vertices[i].Y, mesh.Vertices[i].Z) : new Vector3(); Vector3D texC = mesh.HasTextureCoords(0) ? mesh.TextureCoordinateChannels[0][i] : new Vector3D(); Vector2 TeC = new Vector2(texC.X, texC.Y); Vertex v = new Vertex(pos, TeC); verts.Add(v); } Vertices.AddRange(verts); for (int i = 0; i < mesh.FaceCount; i++) { indices[i * 3 + 0] = (int)faces[i].Indices[2]; indices[i * 3 + 1] = (int)faces[i].Indices[1]; indices[i * 3 + 2] = (int)faces[i].Indices[0]; Indices.Add(indices[i * 3 + 2] + vertexOffSet); Indices.Add(indices[i * 3 + 1] + vertexOffSet); Indices.Add(indices[i * 3 + 0] + vertexOffSet); } vertexOffSet += mesh.VertexCount; indexOffSet += mesh.FaceCount * 3; } VertexCount = Vertices.Count(); IndexCount = Indices.Count(); Size = Utilities.SizeOf <Vertex>(); SizeInBytes = Utilities.SizeOf <Vertex>() * Vertices.Count(); IndexSize = Utilities.SizeOf <int>(); IndexSizeInBytes = Utilities.SizeOf <int>() * Indices.Count(); }
public static bool CanLoad(string filePath) => Context.IsImportFormatSupported(Path.GetExtension(filePath));