protected override void CreateDeviceDependentResources()
{
// Dispose of each vertex and index buffer
vertexBuffers.ForEach(vb => RemoveAndDispose(ref vb));
vertexBuffers.Clear();
indexBuffers.ForEach(ib => RemoveAndDispose(ref ib));
indexBuffers.Clear();
textureViews.ForEach(tv => RemoveAndDispose(ref tv));
textureViews.Clear();
RemoveAndDispose(ref samplerState);
// Retrieve our SharpDX.Direct3D11.Device1 instance
var device = this.DeviceManager.Direct3DDevice;
// Initialize vertex buffers
for (int indx = 0; indx < mesh.VertexBuffers.Count; indx++)
{
var vb = mesh.VertexBuffers[indx];
Vertex[] vertices = new Vertex[vb.Length];
for (var i = 0; i < vb.Length; i++)
{
// Retrieve skinning information for vertex
Common.Mesh.SkinningVertex skin = new Common.Mesh.SkinningVertex();
if (mesh.SkinningVertexBuffers.Count > 0)
skin = mesh.SkinningVertexBuffers[indx][i];
// Create vertex
vertices[i] = new Vertex(vb[i].Position, vb[i].Normal, vb[i].Color, vb[i].UV, skin);
}
vertexBuffers.Add(ToDispose(Buffer.Create(device, BindFlags.VertexBuffer, vertices.ToArray())));
vertexBuffers[vertexBuffers.Count - 1].DebugName = "VertexBuffer_" + indx.ToString();
}
// Initialize index buffers
foreach (var ib in mesh.IndexBuffers)
{
indexBuffers.Add(ToDispose(Buffer.Create(device, BindFlags.IndexBuffer, ib)));
indexBuffers[indexBuffers.Count - 1].DebugName = "IndexBuffer_" + (indexBuffers.Count - 1).ToString();
}
// Load textures if a material has any.
foreach (var m in mesh.Materials)
{
for (var i = 0; i < m.Textures.Length; i++)
{
if (System.IO.File.Exists(m.Textures[i]))
textureViews.Add(ToDispose(ShaderResourceView.FromFile(device, m.Textures[i])));
else
textureViews.Add(null);
}
}
// Create our sampler state
samplerState = ToDispose(new SamplerState(device, new SamplerStateDescription()
{
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
BorderColor = new Color4(0, 0, 0, 0),
ComparisonFunction = Comparison.Never,
Filter = Filter.Anisotropic,
MaximumAnisotropy = 16,
MaximumLod = float.MaxValue,
MinimumLod = 0,
MipLodBias = 0.0f
}));
}
public static Pathmap ImportFromCSV(string text, IPathmapErrorHandler errorHandler)
{
CsvFrame frame;
try
{
frame = CsvFrame.ParseOne(text);
}
catch (Exception)
{
errorHandler.Error("Incorrect CSV format.");
return(null);
}
if (frame.VariableSetOwner != "Global")
{
errorHandler.Error("Need the global variable set, got the '" + frame.VariableSetOwner + "' variable set instead.");
return(null);
}
// Get nodes
CsvArray nodeArray = frame.VariableValues[nodesOut] as CsvArray;
if (nodeArray == null)
{
errorHandler.Error("Incorrect format, 'nodesOut' is not an array. Did you compile your pathmap?");
return(null);
}
Vertex[] vectors = new Vertex[nodeArray.Values.Length];
for (int i = 0; i < nodeArray.Values.Length; i++)
{
CsvVector nodeVector = (CsvVector)nodeArray.Values[i];
vectors[i] = nodeVector.Value;
}
// Get segments
CsvArray segmentArray = frame.VariableValues[segmentsOut] as CsvArray;
if (segmentArray == null)
{
errorHandler.Error("Incorrect format, 'segmentsOut' is not an array.");
return(null);
}
Segment[] segments = new Segment[segmentArray.Values.Length];
for (int i = 0; i < segmentArray.Values.Length; i++)
{
CsvVector segmentVector = (CsvVector)segmentArray.Values[i];
segments[i] = new Segment(
(int)segmentVector.Value.X,
(int)segmentVector.Value.Y
);
}
// Get attributes
CsvArray attributeArray = frame.VariableValues[attributesOut] as CsvArray;
if (attributeArray == null)
{
errorHandler.Error("Incorrect format, 'attributesOut' is not an array.");
return(null);
}
MapAttribute[] attributes = new MapAttribute[attributeArray.Values.Length];
for (int i = 0; i < attributeArray.Values.Length; i++)
{
CsvVector attributeVector = (CsvVector)attributeArray.Values[i];
attributes[i] = new MapAttribute(
(int)attributeVector.Value.X,
(int)attributeVector.Value.Y,
(int)attributeVector.Value.Z
);
}
return(new Pathmap(vectors.ToArray(), segments.ToArray(), attributes));
}
public void DrawStretchPicture(float x, float y, float width, float height, float s, float t, float s2, float t2, idMaterial material)
{
Vertex[] verts = new Vertex[4];
int[] indexes = new int[6];
/*indexes[0] = 0;
* indexes[1] = 1;
* indexes[2] = 2;
* indexes[3] = 0;
* indexes[4] = 2;
* indexes[5] = 3;*/
indexes[0] = 3;
indexes[1] = 0;
indexes[2] = 2;
indexes[3] = 2;
indexes[4] = 0;
indexes[5] = 1;
verts[0].Position = new Vector3(x, y, 0);
verts[0].TextureCoordinates = new Vector2(s, t);
verts[0].Normal = new Vector3(0, 0, 1);
/*verts[0].Tangents = new Vector3[] {
* new Vector3(1, 0, 0),
* new Vector3(0, 1, 0)
* };*/
verts[1].Position = new Vector3(x + width, y, 0);
verts[1].TextureCoordinates = new Vector2(s2, t);
verts[1].Normal = new Vector3(0, 0, 1);
/*verts[1].Tangents = new Vector3[] {
* new Vector3(1, 0, 0),
* new Vector3(0, 1, 0)
* };*/
verts[2].Position = new Vector3(x + width, y + height, 0);
verts[2].TextureCoordinates = new Vector2(s2, t2);
verts[2].Normal = new Vector3(0, 0, 1);
/*verts[2].Tangents = new Vector3[] {
* new Vector3(1, 0, 0),
* new Vector3(0, 1, 0)
* };*/
verts[3].Position = new Vector3(x, y + height, 0);
verts[3].TextureCoordinates = new Vector2(s, t2);
verts[3].Normal = new Vector3(0, 0, 1);
/*verts[3].Tangents = new Vector3[] {
* new Vector3(1, 0, 0),
* new Vector3(0, 1, 0)
* };*/
bool ident = _matrix != Matrix.Identity;
if (ident == true)
{
idConsole.Warning("TODO: IDENT == true");
/*verts[0].Position -= _origin;
* verts[0].Position *= _matrix.Translation;
* verts[0].Position += _origin;
* verts[1].Position -= _origin;
* verts[1].Position *= _matrix.Translation;
* verts[1].Position += _origin;
* verts[2].Position -= _origin;
* verts[2].Position *= _matrix.Translation;
* verts[2].Position += _origin;
* verts[3].Position -= _origin;
* verts[3].Position *= _matrix.Translation;
* verts[3].Position += _origin;*/
}
idE.RenderSystem.DrawStretchPicture(verts.ToArray(), indexes.ToArray(), material, ident);
}
/// <summary>
/// Imports an FBX file.
/// </summary>
/// <param name="stream">The FBX stream.</param>
/// <param name="settings">An import settings object.</param>
/// <param name="format">The filetype of the mesh.</param>
/// <param name="filePath">The path to the file.</param>
/// <returns>An <see cref="ImportResult" /> object.</returns>
public static ImportResult Import(Stream stream, ImportSettings settings, string format, string filePath)
{
var sceneName = Path.GetFileNameWithoutExtension(filePath);
Debug.Assert(sceneName != null, "sceneName != null");
var steps = PostProcessSteps.ValidateDataStructure
| PostProcessSteps.GenerateUVCoords
| PostProcessSteps.Triangulate
| PostProcessSteps.SortByPrimitiveType
| PostProcessSteps.FlipUVs
| PostProcessSteps.FlipWindingOrder
| PostProcessSteps.LimitBoneWeights
| PostProcessSteps.ImproveCacheLocality
| PostProcessSteps.RemoveComponent
| PostProcessSteps.RemoveRedundantMaterials;
if (!settings.KeepOverlappingVertices)
{
steps |= PostProcessSteps.JoinIdenticalVertices;
}
if (!settings.ImportAsSkeletal)
{
steps |= PostProcessSteps.Debone;
}
if (settings.MergeMeshes)
{
steps |= PostProcessSteps.OptimizeMeshes;
}
switch (settings.NormalImportMethod)
{
case NormalImportMethod.ComputeNormals:
steps |= PostProcessSteps.GenerateNormals;
steps |= PostProcessSteps.CalculateTangentSpace;
break;
case NormalImportMethod.ComputeNormalsSmooth:
steps |= PostProcessSteps.GenerateSmoothNormals;
steps |= PostProcessSteps.CalculateTangentSpace;
break;
case NormalImportMethod.ImportNormals:
steps |= PostProcessSteps.CalculateTangentSpace;
break;
case NormalImportMethod.ImportNormalsAndTangents:
break;
default:
throw new ArgumentOutOfRangeException();
}
var scene = ContentProvider.AssimpContext.ImportFileFromStream(stream, steps, format);
Skeleton skeleton = null;
var importedSkeleton = false;
var importedAnimation = false;
var importedMesh = false;
var importedMaterials = false;
var geometries = new Dictionary <string, Geometry>(scene.MeshCount);
var animations = new AnimationData[scene.AnimationCount];
var materials = new Material[scene.MaterialCount];
var textures = new Data.Texture[scene.TextureCount];
if (settings.ImportAsSkeletal)
{
if (settings.Skeleton == null)
{
SkeletonNodeData nodeData;
if (!FindSkeleton(ref scene, out nodeData))
{
throw new InvalidOperationException("Could not import skeleton.");
}
skeleton = ImportSkeleton(ref nodeData);
importedSkeleton = true;
}
else
{
skeleton = settings.Skeleton;
}
}
if (scene.HasMaterials)
{
importedMaterials = true;
if (filePath != null)
{
var fileFolder = Path.GetDirectoryName(filePath);
for (var i = 0; i < scene.MaterialCount; i++)
{
var mat = scene.Materials[i];
var material = new Material();
materials[i] = material;
}
}
}
for (var i = 0; i < scene.MeshCount; i++)
{
var mesh = scene.Meshes[i];
var meshName = string.IsNullOrWhiteSpace(mesh.Name) ? $"{sceneName} ({i})" : mesh.Name;
var vertices = new Vertex[mesh.VertexCount];
WeightedVertex[] weights = null;
if (mesh.HasBones && settings.ImportAsSkeletal)
{
weights = new WeightedVertex[mesh.VertexCount];
}
for (var j = 0; j < mesh.VertexCount; j++)
{
var texCoordChannel = mesh.HasTextureCoords(0)
? mesh.TextureCoordinateChannels[0][j]
: new Vector3D(0, 0, 0);
var vertexColourChannel = mesh.HasVertexColors(0)
? mesh.VertexColorChannels[0][j]
: new Color4D(0, 0, 0, 1);
var tangent = mesh.HasTangentBasis ? mesh.Tangents[j] : new Vector3D(0, 0, 0);
var bitangent = mesh.HasTangentBasis ? mesh.Tangents[j] : new Vector3D(0, 0, 0);
vertices[j] = new Vertex
{
Position = (Vector3)mesh.Vertices[j],
Normal = (Vector3)mesh.Normals[j],
Colour = vertexColourChannel,
TexCoord = new Vector2(texCoordChannel.X, texCoordChannel.Y),
Tangent = (Vector3)tangent,
BiTangent = (Vector3)bitangent
};
// TODO: add bone data
}
importedMesh = true;
geometries[mesh.Name] = new Geometry(meshName, vertices.ToArray(), mesh.GetIndices(), weights?.ToArray(),
PrimitiveTopology.TriangleList)
{
MaterialIndex = mesh.MaterialIndex
};
}
if (settings.MergeMeshes && !settings.ImportAsSkeletal)
{
var vertices = new Vertex[0];
var weights = new WeightedVertex[0];
var indices = new int[0];
foreach (var mesh in geometries.Values)
{
var lastVertices = vertices;
vertices = new Vertex[lastVertices.Length + mesh.Vertices.Length];
lastVertices.CopyTo(vertices, 0);
mesh.Vertices.CopyTo(vertices, lastVertices.Length);
var lastWeights = weights;
weights = new WeightedVertex[lastWeights.Length + (mesh.Weights?.Length ?? 0)];
lastWeights.CopyTo(weights, 0);
mesh.Weights?.CopyTo(weights, lastWeights.Length);
var lastIndices = indices;
indices = new int[indices.Length + mesh.Indices.Length];
lastIndices.CopyTo(indices, 0);
mesh.Indices.Select(i => i + lastVertices.Length).ToArray().CopyTo(indices, lastIndices.Length);
mesh.Dispose();
}
geometries.Clear();
geometries[sceneName] = new Geometry(sceneName, vertices, indices, weights);
}
for (var i = 0; i < scene.AnimationCount; i++)
{
var animation = scene.Animations[i];
animations[i] = new AnimationData();
importedAnimation = true;
// TODO: import animations
}
string path;
if (settings.ContentPath == null)
{
path = Path.Combine(Engine.TempPath, Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(path);
}
else
{
path = settings.ContentPath;
}
#region File Creation
foreach (var material in materials)
{
var materialPath = Path.Combine(path, $"{material.Name}.material");
if (materialPath == null)
{
continue;
}
using (var file = File.Create(materialPath))
{
Inst.Serialize(material, file);
}
}
foreach (var geo in geometries.Values)
{
var meshPath = GetFilePath(sceneName, path, settings);
if (meshPath == null)
{
continue;
}
using (var file = File.Create(meshPath))
{
geo.Material = materials[geo.MaterialIndex];
geo.Save(file);
}
}
if (importedSkeleton)
{
var skeletonPath = GetFilePath(sceneName, path, settings);
if (skeletonPath != null)
{
using (var file = File.Create(skeletonPath))
{
Inst.Serialize(skeleton, file);
}
}
}
foreach (var animation in animations)
{
var animPath = GetFilePath(sceneName, path, settings);
if (animPath == null)
{
continue;
}
using (var file = File.Create(animPath))
{
animation.Save(file);
}
}
#endregion
if (settings.ContentPath != null)
{
foreach (var file in Directory.GetFiles(path))
{
File.Move(file, Path.Combine(settings.ContentPath, Path.GetFileName(file)));
}
}
return(new ImportResult(geometries, animations, materials, skeleton, importedSkeleton, importedAnimation,
importedMesh, importedMaterials));
}