private InputSlotElement[] ProcessSlots(InputElement[] elements)
{
var result = new List<InputSlotElement>();
for (int i = 0; i < elements.Length; i++)
{
var element = elements[i];
var existingSlotElement = result.SingleOrDefault(x => x.InputSlot == element.InputSlot);
if (existingSlotElement == null)
{
result.Add(new InputSlotElement
{
InputSlot = element.InputSlot,
InputSlotClass = element.InputSlotClass,
InstanceDataStepRate = element.InstanceDataStepRate
});
}
else
{
if (element.InputSlotClass != existingSlotElement.InputSlotClass)
throw new Exception(string.Format("Element[{0}]'s InputSlotClass is different from the InputSlotClass of a previously defined element at the same input slot. All elements from a given input slot must have the same InputSlotClass and InstanceDataStepRate.", i));
if (element.InstanceDataStepRate != existingSlotElement.InstanceDataStepRate)
throw new Exception(string.Format("Element[{0}]'s InstanceDataStepRate is different from the InstanceDataStepRate of a previously defined element at the same input slot. All elements from a given input slot must have the same InputSlotClass and InstanceDataStepRate.", i));
}
}
return result.ToArray();
}
private ProcessedInputElement[] ProcessElements(InputElement[] elements)
{
var slotOffsets = new int[InputAssemblerStage.VertexInputResourceSlotCount];
var result = new List<ProcessedInputElement>();
foreach (var element in elements)
{
var registerIndex = _inputSignature.Parameters.FindRegister(
element.SemanticName, (uint) element.SemanticIndex);
// If registerIndex is null, it means that this element in the input
// data has no corresponding vertex shader input. That's okay -
// we just ignore it.
if (registerIndex == null)
continue;
if (element.AlignedByteOffset != InputElement.AppendAligned)
slotOffsets[element.InputSlot] = element.AlignedByteOffset;
result.Add(new ProcessedInputElement
{
RegisterIndex = (int) registerIndex.Value,
Format = element.Format,
InputSlot = element.InputSlot,
AlignedByteOffset = slotOffsets[element.InputSlot],
InputSlotClass = element.InputSlotClass,
InstanceDataStepRate = element.InstanceDataStepRate
});
slotOffsets[element.InputSlot] += FormatHelper.SizeOfInBytes(element.Format);
}
return result.ToArray();
}
/// <summary>
/// Only used in unit tests.
/// </summary>
internal InputLayout(Device device, InputElement[] elements, InputSignatureChunk inputSignature)
: base(device)
{
// TODO: Verify that shader bytecode matches input elements.
_inputSignature = inputSignature;
_rawElements = elements;
_elements = ProcessElements(elements);
_slots = ProcessSlots(elements);
}
public InputElementViewModel(InputElement inputElement)
{
_inputElement = inputElement;
}
internal InputLayout(Device device, InputElement[] elements, byte[] shaderBytecodeWithInputSignature)
: this(device, elements, BytecodeContainer.Parse(shaderBytecodeWithInputSignature).InputSignature)
{
}
/// <summary>
/// Create meshes and add vertex and index buffers.
/// </summary>
private void AddVertexData(
Model model, Scene scene, Node node, Device device,
ref Matrix transform)
{
var previousTransform = transform;
transform = Matrix.Multiply(previousTransform, node.Transform.ToMatrix());
// Also calculate inverse transpose matrix for normal/tangent/bitagent transformation.
var invTranspose = transform;
invTranspose.Invert();
invTranspose.Transpose();
if (node.HasMeshes)
{
foreach (int index in node.MeshIndices)
{
// Get a mesh from the scene.
Mesh mesh = scene.Meshes[index];
// Create new mesh to add to model.
var modelMesh = new ModelMesh();
model.AddMesh(modelMesh);
// If mesh has a material extract the diffuse texture, if present.
Material material = scene.Materials[mesh.MaterialIndex];
if (material != null && material.GetTextureCount(TextureType.Diffuse) > 0)
{
TextureSlot aiTexture = material.GetTexture(TextureType.Diffuse, 0);
using (var fileStream = File.OpenRead(_modelPath + "\\" + Path.GetFileName(aiTexture.FilePath)))
{
var texture = _textureLoadHandler(_device, fileStream);
modelMesh.AddTextureDiffuse(device, texture);
}
}
// Determine the elements in the vertex.
bool hasTexCoords = mesh.HasTextureCoords(0);
bool hasColors = mesh.HasVertexColors(0);
bool hasNormals = mesh.HasNormals;
bool hasTangents = mesh.Tangents != null;
bool hasBitangents = mesh.BiTangents != null;
// Create vertex element list.
var vertexElements = new InputElement[GetNumberOfInputElements(mesh)];
uint elementIndex = 0;
vertexElements[elementIndex++] = new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0);
var vertexSize = (short) Utilities.SizeOf<Vector3>();
if (hasColors)
{
vertexElements[elementIndex++] = new InputElement("COLOR", 0, Format.R8G8B8A8_UInt, 0, vertexSize);
vertexSize += (short) Utilities.SizeOf<Color>();
}
if (hasNormals)
{
vertexElements[elementIndex++] = new InputElement("NORMAL", 0, Format.R32G32B32_Float, 0, vertexSize);
vertexSize += (short) Utilities.SizeOf<Vector3>();
}
if (hasTangents)
{
vertexElements[elementIndex++] = new InputElement("TANGENT", 0, Format.R32G32B32_Float, 0, vertexSize);
vertexSize += (short) Utilities.SizeOf<Vector3>();
}
if (hasBitangents)
{
vertexElements[elementIndex++] = new InputElement("BITANGENT", 0, Format.R32G32B32_Float, 0, vertexSize);
vertexSize += (short) Utilities.SizeOf<Vector3>();
}
if (hasTexCoords)
{
vertexElements[elementIndex++] = new InputElement("TEXCOORD", 0, Format.R32G32_Float, 0, vertexSize);
vertexSize += (short) Utilities.SizeOf<Vector2>();
}
//set the vertex elements and size
modelMesh.InputElements = vertexElements;
modelMesh.VertexSize = vertexSize;
//get pointers to vertex data
Vector3D[] positions = mesh.Vertices;
Vector3D[] texCoords = mesh.GetTextureCoords(0);
Vector3D[] normals = mesh.Normals;
Vector3D[] tangents = mesh.Tangents;
Vector3D[] biTangents = mesh.BiTangents;
Color4D[] colours = mesh.GetVertexColors(0);
//also determine primitive type
switch (mesh.PrimitiveType)
{
case PrimitiveType.Point:
modelMesh.PrimitiveTopology = PrimitiveTopology.PointList;
break;
case PrimitiveType.Line:
modelMesh.PrimitiveTopology = PrimitiveTopology.LineList;
break;
case PrimitiveType.Triangle:
modelMesh.PrimitiveTopology = PrimitiveTopology.TriangleList;
break;
default:
throw new Exception("ModelLoader::AddVertexData(): Unknown primitive type");
}
// Create new vertex buffer.
var vertexBuffer = device.CreateBuffer(
new BufferDescription
{
BindFlags = BindFlags.VertexBuffer,
SizeInBytes = mesh.VertexCount * vertexSize
});
int byteOffset = 0;
for (int i = 0; i < mesh.VertexCount; i++)
{
{
// Add position, after transforming it with accumulated node transform.
Vector4 tempResult;
Vector3 pos = positions[i].ToVector3();
Vector3.Transform(ref pos, ref transform, out tempResult);
var result = new Vector3(tempResult.X, tempResult.Y, tempResult.Z);
device.ImmediateContext.SetBufferData(vertexBuffer, ref result, byteOffset);
byteOffset += Vector3.SizeInBytes;
}
if (hasColors)
{
var vertColor = colours[i].ToColor();
device.ImmediateContext.SetBufferData(vertexBuffer, ref vertColor, byteOffset);
byteOffset += 4;
}
if (hasNormals)
{
var normal = normals[i].ToVector3();
Vector4 tempResult;
Vector3.Transform(ref normal, ref invTranspose, out tempResult);
var result = new Vector3(tempResult.X, tempResult.Y, tempResult.Z);
device.ImmediateContext.SetBufferData(vertexBuffer, ref result, byteOffset);
byteOffset += Vector3.SizeInBytes;
}
if (hasTangents)
{
var tangent = tangents[i].ToVector3();
Vector4 tempResult;
Vector3.Transform(ref tangent, ref invTranspose, out tempResult);
var result = new Vector3(tempResult.X, tempResult.Y, tempResult.Z);
device.ImmediateContext.SetBufferData(vertexBuffer, ref result, byteOffset);
byteOffset += Vector3.SizeInBytes;
}
if (hasBitangents)
{
var biTangent = biTangents[i].ToVector3();
Vector4 tempResult;
Vector3.Transform(ref biTangent, ref invTranspose, out tempResult);
var result = new Vector3(tempResult.X, tempResult.Y, tempResult.Z);
device.ImmediateContext.SetBufferData(vertexBuffer, ref result, byteOffset);
byteOffset += Vector3.SizeInBytes;
}
if (hasTexCoords)
{
var result = new Vector2(texCoords[i].X, 1 - texCoords[i].Y);
device.ImmediateContext.SetBufferData(vertexBuffer, ref result, byteOffset);
byteOffset += Vector2.SizeInBytes;
}
}
// Add it to the mesh.
modelMesh.VertexBuffer = vertexBuffer;
modelMesh.VertexCount = mesh.VertexCount;
modelMesh.PrimitiveCount = mesh.FaceCount;
// Get pointer to indices data.
var indices = mesh.GetIndices();
// Create new index buffer.
var indexBuffer = device.CreateBuffer(
new BufferDescription
{
BindFlags = BindFlags.IndexBuffer,
SizeInBytes = indices.Length * sizeof(uint)
}, indices);
// Add it to the mesh.
modelMesh.IndexBuffer = indexBuffer;
modelMesh.IndexCount = indices.Length;
}
}
// If node has more children process them as well.
for (var i = 0; i < node.ChildCount; i++)
AddVertexData(model, scene, node.Children[i], device, ref transform);
transform = previousTransform;
}
