private void LoadMeshes()
{
ObjectTreeNode meshesFolder = new ObjectTreeNode("Meshes");
this.AddChild(meshesFolder);
foreach (var mesh in Header.Meshes)
{
Dictionary <int, List <STVertex> > VertexMatMapper = new Dictionary <int, List <STVertex> >();
int index = 0;
foreach (var primative in mesh.Primitives)
{
if (!VertexMatMapper.ContainsKey(primative.MaterialIndex))
{
VertexMatMapper.Add(primative.MaterialIndex, new List <STVertex>());
}
var vertices = VertexMatMapper[primative.MaterialIndex];
switch (primative.Type)
{
case PrimitiveType.Triangle:
vertices.Add(ToGenericVertex(mesh, primative.Vertices[0], Skeleton));
vertices.Add(ToGenericVertex(mesh, primative.Vertices[1], Skeleton));
vertices.Add(ToGenericVertex(mesh, primative.Vertices[2], Skeleton));
break;
case PrimitiveType.Quad:
vertices.Add(ToGenericVertex(mesh, primative.Vertices[0], Skeleton));
vertices.Add(ToGenericVertex(mesh, primative.Vertices[1], Skeleton));
vertices.Add(ToGenericVertex(mesh, primative.Vertices[2], Skeleton));
vertices.Add(ToGenericVertex(mesh, primative.Vertices[1], Skeleton));
vertices.Add(ToGenericVertex(mesh, primative.Vertices[3], Skeleton));
vertices.Add(ToGenericVertex(mesh, primative.Vertices[2], Skeleton));
break;
case PrimitiveType.TriangleStrip:
var verts = new List <STVertex>();
foreach (var dv in primative.Vertices)
{
verts.Add(ToGenericVertex(mesh, dv, Skeleton));
}
verts = ConvertTriStrips(verts);
vertices.AddRange(verts);
break;
}
}
foreach (var poly in VertexMatMapper)
{
HSFMesh genericMesh = new HSFMesh();
genericMesh.Name = mesh.Name;
GenericMeshes.Add(genericMesh);
meshesFolder.AddChild(new ObjectTreeNode(mesh.Name)
{
Tag = genericMesh,
ImageKey = "Mesh",
});
int objectIndex = Header.ObjectData.Objects.IndexOf(mesh.ObjectData);
if (objectIndex != -1)
{
var bone = Skeleton.Bones[objectIndex];
genericMesh.ObjectNode = bone;
bone.Visible = false;
}
HSFMaterialWrapper genericMat = new HSFMaterialWrapper(this);
STPolygonGroup group = new STPolygonGroup();
group.Material = genericMat;
genericMesh.PolygonGroups.Add(group);
var matData = Header.Materials[poly.Key].MaterialData;
genericMat.Material = Header.Materials[poly.Key];
genericMat.Name = Header.Materials[poly.Key].Name;
var pass_flags = matData.AltFlags & HSF_Renderer.PASS_BITS;
if (pass_flags != 0 || (matData.TransparencyInverted != 0 &&
matData.VertexMode == 0))
{
genericMesh.IsTransparent = true;
group.IsTransparentPass = true;
}
genericMat.Mesh = mesh;
var attributes = Header.Materials[poly.Key].Textures;
for (int i = 0; i < attributes.Count; i++)
{
var attribute = attributes[i].Item2;
var texIndex = attribute.TextureIndex;
genericMat.Attributes.Add(attribute);
group.Material.TextureMaps.Add(new HSFMatTexture(this)
{
Attribute = attribute,
Name = Header.Textures[texIndex].Name,
TextureIndex = texIndex,
Type = i == 0 ? STTextureType.Diffuse : STTextureType.None,
WrapU = ConvertWrapMode(attribute.WrapS),
WrapV = ConvertWrapMode(attribute.WrapT),
MagFilter = STTextureMagFilter.Linear,
MinFilter = STTextureMinFilter.Linear,
});
}
genericMesh.Vertices.AddRange(poly.Value);
genericMesh.Optmize(group);
}
}
}
public void SetRenderData(STGenericMaterial mat, ShaderProgram shader, HSFMesh m)
{
var hsfMaterial = (HSFMaterialWrapper)mat;
var materialData = hsfMaterial.Material.MaterialData;
var objectData = hsfMaterial.Mesh.ObjectData;
var textureCount = materialData.TextureCount;
var vtx_mode = materialData.VertexMode;
var use_color = vtx_mode & VTXMODE_USE_CLR0;
var material_flags = objectData.RenderFlags | materialData.MaterialFlags;
var pass_flags = materialData.AltFlags & PASS_BITS;
var alpha_flags = material_flags & PUNCHTHROUGH_ALPHA_BITS;
shader.SetInt("vertex_mode", materialData.VertexMode);
shader.SetFloat("alpha_flags", alpha_flags);
shader.SetFloat("pass_flags", pass_flags);
Vector3 ambientColor = new Vector3(
materialData.AmbientColor.R / 255f,
materialData.AmbientColor.G / 255f,
materialData.AmbientColor.B / 255f);
Vector3 ambientLitColor = new Vector3(
materialData.LitAmbientColor.R / 255f,
materialData.LitAmbientColor.G / 255f,
materialData.LitAmbientColor.B / 255f);
Vector3 shadowColor = new Vector3(
materialData.ShadowColor.R / 255f,
materialData.ShadowColor.G / 255f,
materialData.ShadowColor.B / 255f);
float transparency = 1 - materialData.TransparencyInverted;
int matIndex = HSFParent.Header.Materials.IndexOf(hsfMaterial.Material);
if (HSFParent.Header.MatAnimControllers.ContainsKey(matIndex))
{
var controller = HSFParent.Header.MatAnimControllers[matIndex];
ambientColor.X = controller.AmbientColorR;
ambientColor.Y = controller.AmbientColorG;
ambientColor.Z = controller.AmbientColorB;
ambientLitColor.X = controller.LitAmbientColorR;
ambientLitColor.Y = controller.LitAmbientColorG;
ambientLitColor.Z = controller.LitAmbientColorB;
shadowColor.X = controller.ShadowColorR;
shadowColor.Y = controller.ShadowColorG;
shadowColor.Z = controller.ShadowColorB;
transparency = 1 - controller.TransparencyInverted;
}
shader.SetFloat("transparency", transparency);
shader.SetVector3("ambient_color", ambientColor);
shader.SetVector3("ambient_lit_color", ambientLitColor);
shader.SetVector3("shadow_color", shadowColor);
bool cullNone = (material_flags & DONT_CULL_BACKFACES) != 0;
if (pass_flags != 0 || materialData.TransparencyInverted != 0)
{
}
else
{
}
/* if (materialData.VertexMode == 0 && alpha_flags == 0 && pass_flags == 0)
* {
* GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.One);
* }
* else
* {
* GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
* }*/
bool IsTransparent = alpha_flags != 0;
shader.SetBoolToInt("isTransparent", false);
if (alpha_flags != 0)
{
shader.SetBoolToInt("isTransparent", true);
}
else
{
}
if (cullNone)
{
GL.Disable(EnableCap.CullFace);
}
else
{
GL.Enable(EnableCap.CullFace);
GL.CullFace(CullFaceMode.Back);
}
}
