public static BasicModel Create(Device device, TextureManager11 textureManager, string filePath, string texturePath, bool autoLoadTextures = true, bool flipUv = false, bool tex1By1 = true)
{
return(new BasicModel(device, textureManager, filePath, texturePath, autoLoadTextures, flipUv, tex1By1));
}
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 static BasicModel LoadSdkMesh(Device device, TextureManager11 texMgr, string filename, string texturePath)
{
// NOTE: this assumes that the model file only contains a single mesh
var sdkMesh = new SdkMesh(filename);
var ret = new BasicModel();
var faceStart = 0;
var vertexStart = 0;
foreach (var sdkMeshSubset in sdkMesh.Subsets)
{
var subset = new MeshSubset()
{
FaceCount = (int)(sdkMeshSubset.IndexCount / 3),
FaceStart = faceStart,
VertexCount = (int)sdkMeshSubset.VertexCount,
VertexStart = vertexStart
};
// fixup any subset indices that assume that all vertices and indices are not in the same buffers
faceStart = subset.FaceStart + subset.FaceCount;
vertexStart = subset.VertexStart + subset.VertexCount;
ret.Subsets.Add(subset);
}
ret._meshCount = ret.SubsetCount;
var max = new Vector3(float.MinValue);
var min = new Vector3(float.MaxValue);
foreach (var vb in sdkMesh.VertexBuffers)
{
foreach (var vertex in vb.Vertices)
{
max = MathF.Maximize(max, vertex.Pos);
min = MathF.Minimize(min, vertex.Pos);
ret.Vertices.Add(vertex);
}
}
ret.BoundingBox = new BoundingBox(min, max);
foreach (var ib in sdkMesh.IndexBuffers)
{
ret.Indices.AddRange(ib.Indices.Select(i => i));
}
foreach (var sdkMeshMaterial in sdkMesh.Materials)
{
var material = new Noire.Common.Material {
Ambient = sdkMeshMaterial.Ambient,
Diffuse = sdkMeshMaterial.Diffuse,
Reflect = Color.Black,
Specular = sdkMeshMaterial.Specular
};
material.Specular.Alpha = sdkMeshMaterial.Power;
ret.Materials.Add(material);
if (!string.IsNullOrEmpty(sdkMeshMaterial.DiffuseTexture))
{
ret.DiffuseMapSRV.Add(texMgr.CreateTexture(Path.Combine(texturePath, sdkMeshMaterial.DiffuseTexture)));
}
else
{
ret.DiffuseMapSRV.Add(texMgr[TextureManager11.TexDefault]);
}
if (!string.IsNullOrEmpty(sdkMeshMaterial.NormalTexture))
{
ret.NormalMapSRV.Add(texMgr.CreateTexture(Path.Combine(texturePath, sdkMeshMaterial.NormalTexture)));
}
else
{
ret.NormalMapSRV.Add(texMgr[TextureManager11.TexDefaultNorm]);
}
}
ret.ModelMesh.SetSubsetTable(ret.Subsets);
ret.ModelMesh.SetVertices(device, ret.Vertices);
ret.ModelMesh.SetIndices(device, ret.Indices);
return(ret);
}
