public TriangleProcessor(SoftwareTriangle triangle, HardwareMeshProcessor mesh, bool loadColors, bool loadUVs, bool loadNormals)
{
// get color components
var colors = new Vector4[3][];
if (loadColors)
{
int componentCount = mesh.colorComponents.Count;
for (int i = 0; i != colors.Length; ++i)
{
colors[i] = new Vector4[componentCount];
}
for (int i = 0; i != componentCount; ++i)
{
var colorComponent = mesh.colorComponents[i][triangle.Index].Colors;
colors[0][i] = colorComponent[0];
colors[1][i] = colorComponent[1];
colors[2][i] = colorComponent[2];
}
}
// get normal components
var normals = new Vector3[3][];
if (loadNormals)
{
int componentCount = mesh.normalComponents.Count;
for (int i = 0; i != normals.Length; ++i)
{
normals[i] = new Vector3[componentCount];
}
for (int i = 0; i != componentCount; ++i)
{
var normalComponent = mesh.normalComponents[i][triangle.Index].Normals;
normals[0][i] = normalComponent[0];
normals[1][i] = normalComponent[1];
normals[2][i] = normalComponent[2];
}
}
// get uv components
var uvs = new Vector2[3][];
if (loadUVs)
{
int componentCount = mesh.uvComponents.Count;
for (int i = 0; i != uvs.Length; ++i)
{
uvs[i] = new Vector2[componentCount];
}
for (int i = 0; i != componentCount; ++i)
{
var normalComponent = mesh.uvComponents[i][triangle.Index].UVs;
uvs[0][i] = normalComponent[0];
uvs[1][i] = normalComponent[1];
uvs[2][i] = normalComponent[2];
}
}
// add verticies
var vertex1 = new VertexProcessor(triangle.Verticies[0], colors[0], normals[0], uvs[0], mesh);
var vertex2 = new VertexProcessor(triangle.Verticies[1], colors[1], normals[1], uvs[1], mesh);
var vertex3 = new VertexProcessor(triangle.Verticies[2], colors[2], normals[2], uvs[2], mesh);
Verticies = new VertexProcessor[3] {vertex1, vertex2, vertex3};
mesh.Triangles.Add(this);
}
public SoftwareMesh(SoftwareModel model, RMX_Mesh mesh)
{
Model = model;
Name = mesh.Name;
Verticies = new List <SoftwareVertex>();
Triangles = new List <SoftwareTriangle>();
Edges = new List <SoftwareEdge>();
VetexComponents = new List <object>();
TriangleComponents = new List <object>();
EdgeComponents = new List <object>();
VertexComponentKeys = new Dictionary <VertexComponentKeyTypes, int>();
TriangleComponentKeys = new Dictionary <TriangleComponentKeyTypes, int>();
EdgeComponentKeys = new Dictionary <EdgeComponentKeyTypes, int>();
// material
if (!string.IsNullOrEmpty(mesh.Material))
{
foreach (var material in model.Materials)
{
if (material.Name == mesh.Material)
{
this.Material = material;
}
}
if (Material == null)
{
Debug.ThrowError("SoftwareMesh", "Failed to find material: " + mesh.Material);
}
}
// verticies
var channels = mesh.Verticies.Channels;
int positionStep = 0;
for (int i = 0; i != channels.Length; ++i)
{
var channel = channels[i];
if (channel.ID != "Position")
{
continue;
}
Dimensions = channel.Step;
positionStep = channel.Step;
if (channel.Step == 3)
{
var vertexPostions = new Vector3[channel.Values.Length / 3];
var positions = channel.Values;
int i2 = 0;
for (int i3 = 0; i3 != vertexPostions.Length; ++i3)
{
Verticies.Add(new SoftwareVertex(i3));
vertexPostions[i3] = new Vector3(positions[i2], positions[i2 + 1], positions[i2 + 2]);
i2 += 3;
}
VetexComponents.Add(vertexPostions);
}
else if (channel.Step == 2)
{
var vertexPostions = new Vector2[channel.Values.Length / 2];
var positions = channel.Values;
int i2 = 0;
for (int i3 = 0; i3 != vertexPostions.Length; ++i3)
{
Verticies.Add(new SoftwareVertex(i3));
vertexPostions[i3] = new Vector2(positions[i2], positions[i2 + 1]);
i2 += 2;
}
VetexComponents.Add(vertexPostions);
}
else
{
Debug.ThrowError("SoftwareMesh", "Unsupotred position step count");
}
VertexComponentKeys.Add(VertexComponentKeyTypes.Positions, i);
}
// vertex bone groups
var counts = mesh.Verticies.BoneGroups.Counts.Values;
var indices = mesh.Verticies.BoneGroups.Indices.Values;
var weights = mesh.Verticies.BoneGroups.Weights.Values;
if (counts.Length != Verticies.Count)
{
Debug.ThrowError("SoftwareMesh", "BoneGroup counts do not match vertex count");
}
int bg = 0;
for (int i = 0; i != counts.Length; ++i)
{
for (int i2 = 0; i2 != counts[i]; ++i2)
{
int i3 = bg + i2;
Verticies[i].BoneGroups.Add(new SoftwareVertexBoneGroup(indices[i3], weights[i3]));
}
bg += counts[i];
}
// triangles
bool hasPositionData = false;
float[] colors = null, normals = null, uvs = null;
foreach (var channel in channels)
{
switch (channel.ID)
{
case "Position": hasPositionData = true; break;
case "Color": colors = channel.Values; break;
case "Normal": normals = channel.Values; break;
case "UV": uvs = channel.Values; break;
}
}
if (!hasPositionData)
{
Debug.ThrowError("SoftwareMesh", "Vertices missing position data");
}
int[] positionIndices = null, colorIndices = null, normalIndices = null, uvIndices = null;
foreach (var index in mesh.Faces.Indices)
{
switch (index.ID)
{
case "Position": positionIndices = index.Values; break;
case "Color": colorIndices = index.Values; break;
case "Normal": normalIndices = index.Values; break;
case "UV": uvIndices = index.Values; break;
}
}
if (positionIndices == null)
{
Debug.ThrowError("SoftwareMesh", "Faces missing position data");
}
var triangleColors = new List <TriangleColorComponent>();
var triangleNormals = new List <TriangleNormalComponent>();
var triangleUVs = new List <TriangleUVComponent>();
int ti = 0, vi = 0;
if (positionStep == 3)
{
foreach (int step in mesh.Faces.Steps.Values)
{
int loop = step - 2;
int vi2 = vi + 1, vi3 = vi + 2;
for (int i2 = 0; i2 != loop; ++i2)
{
var triangle = new SoftwareTriangle(ti, Verticies[positionIndices[vi]], Verticies[positionIndices[vi2]], Verticies[positionIndices[vi3]]);
Triangles.Add(triangle);
if (colorIndices != null)
{
int cii = colorIndices[vi] * 3, cii2 = colorIndices[vi2] * 3, cii3 = colorIndices[vi3] * 3;
triangleColors.Add(new TriangleColorComponent
(
new Vector4(colors[cii], colors[cii + 1], colors[cii + 2], colors[cii + 3]),
new Vector4(colors[cii2], colors[cii2 + 1], colors[cii2 + 2], colors[cii2 + 3]),
new Vector4(colors[cii3], colors[cii3 + 1], colors[cii3 + 2], colors[cii3 + 3]))
);
}
if (normalIndices != null)
{
int nii = normalIndices[vi] * 3, nii2 = normalIndices[vi2] * 3, nii3 = normalIndices[vi3] * 3;
triangleNormals.Add(new TriangleNormalComponent
(
new Vector3(normals[nii], normals[nii + 1], normals[nii + 2]),
new Vector3(normals[nii2], normals[nii2 + 1], normals[nii2 + 2]),
new Vector3(normals[nii3], normals[nii3 + 1], normals[nii3 + 2]))
);
}
if (uvIndices != null)
{
int uii = uvIndices[vi] * 2, uii2 = uvIndices[vi2] * 2, uii3 = uvIndices[vi3] * 2;
triangleUVs.Add(new TriangleUVComponent
(
new Vector2(uvs[uii], uvs[uii + 1]),
new Vector2(uvs[uii2], uvs[uii2 + 1]),
new Vector2(uvs[uii3], uvs[uii3 + 1]))
);
}
++ti;
++vi2;
++vi3;
}
vi += step;
}
}
else
{
Debug.ThrowError("SoftwareMesh", "Position step not implemented yet: Step value = " + positionStep);
}
int componentIndex = 0;
if (colors != null)
{
TriangleComponents.Add(triangleColors.ToArray());
TriangleComponentKeys.Add(TriangleComponentKeyTypes.ColorComponents, componentIndex);
++componentIndex;
}
if (normals != null)
{
TriangleComponents.Add(triangleNormals.ToArray());
TriangleComponentKeys.Add(TriangleComponentKeyTypes.NormalComponents, componentIndex);
++componentIndex;
}
if (uvs != null)
{
TriangleComponents.Add(triangleUVs.ToArray());
TriangleComponentKeys.Add(TriangleComponentKeyTypes.UVComponents, componentIndex);
++componentIndex;
}
}
public TriangleProcessor(SoftwareTriangle triangle, HardwareMeshProcessor mesh, bool loadColors, bool loadUVs, bool loadNormals)
{
// get color components
var colors = new Vector4[3][];
if (loadColors)
{
int componentCount = mesh.colorComponents.Count;
for (int i = 0; i != colors.Length; ++i)
{
colors[i] = new Vector4[componentCount];
}
for (int i = 0; i != componentCount; ++i)
{
var colorComponent = mesh.colorComponents[i][triangle.Index].Colors;
colors[0][i] = colorComponent[0];
colors[1][i] = colorComponent[1];
colors[2][i] = colorComponent[2];
}
}
// get normal components
var normals = new Vector3[3][];
if (loadNormals)
{
int componentCount = mesh.normalComponents.Count;
for (int i = 0; i != normals.Length; ++i)
{
normals[i] = new Vector3[componentCount];
}
for (int i = 0; i != componentCount; ++i)
{
var normalComponent = mesh.normalComponents[i][triangle.Index].Normals;
normals[0][i] = normalComponent[0];
normals[1][i] = normalComponent[1];
normals[2][i] = normalComponent[2];
}
}
// get uv components
var uvs = new Vector2[3][];
if (loadUVs)
{
int componentCount = mesh.uvComponents.Count;
for (int i = 0; i != uvs.Length; ++i)
{
uvs[i] = new Vector2[componentCount];
}
for (int i = 0; i != componentCount; ++i)
{
var normalComponent = mesh.uvComponents[i][triangle.Index].UVs;
uvs[0][i] = normalComponent[0];
uvs[1][i] = normalComponent[1];
uvs[2][i] = normalComponent[2];
}
}
// add verticies
var vertex1 = new VertexProcessor(triangle.Verticies[0], colors[0], normals[0], uvs[0], mesh);
var vertex2 = new VertexProcessor(triangle.Verticies[1], colors[1], normals[1], uvs[1], mesh);
var vertex3 = new VertexProcessor(triangle.Verticies[2], colors[2], normals[2], uvs[2], mesh);
Verticies = new VertexProcessor[3] {
vertex1, vertex2, vertex3
};
mesh.Triangles.Add(this);
}
