public override void RenderMaterials(ShaderProgram shader,
STGenericMesh mesh, STPolygonGroup group, STGenericMaterial material, Vector4 highlight_color)
{
shader.SetVector4("highlight_color", highlight_color);
shader.SetBoolToInt("hasShadowMap", false);
SetTextureUniforms(shader);
SetMaterialUniforms(shader, material, mesh);
if (material == null)
{
return;
}
int textureUintID = 1;
foreach (var textureMap in material.TextureMaps)
{
var tex = textureMap.GetTexture();
if (textureMap.Type == STTextureType.Diffuse)
{
shader.SetBoolToInt("hasDiffuse", true);
BindTexture(shader, Runtime.TextureCache, textureMap, textureUintID);
shader.SetInt($"tex_Diffuse", textureUintID);
}
if (textureMap.Type == STTextureType.Shadow)
{
shader.SetBoolToInt("hasShadowMap", true);
BindTexture(shader, Runtime.TextureCache, textureMap, textureUintID);
shader.SetInt($"tex_ShadowMap", textureUintID);
}
textureUintID++;
}
}
public virtual void RenderMaterials(ShaderProgram shader,
STGenericMesh mesh, STPolygonGroup group, STGenericMaterial material, Vector4 highlight_color)
{
if (material == null && group.MaterialIndex != -1 && Model.Materials.Count > group.MaterialIndex)
{
material = Model.Materials[group.MaterialIndex];
}
shader.SetVector4("highlight_color", highlight_color);
SetTextureUniforms(shader);
SetMaterialUniforms(shader, material, mesh);
if (material == null)
{
return;
}
int textureUintID = 1;
foreach (var textureMap in material.TextureMaps)
{
var tex = textureMap.GetTexture();
if (textureMap.Type == STTextureType.Diffuse)
{
shader.SetBoolToInt("hasDiffuse", true);
BindTexture(shader, Model.Textures, textureMap, textureUintID);
shader.SetInt($"tex_Diffuse", textureUintID);
}
textureUintID++;
}
}
public STGenericModel ToGeneric()
{
if (Model != null)
{
return(Model);
}
var model = new STGenericModel(FileInfo.FileName);
/* var msh = new STGenericMesh() { Name = $"Mesh0" };
* model.Meshes.Add(msh);
*
* List<STVertex> verts = new List<STVertex>();
* for (int v = 0; v < MorphData.Positions.Count; v++)
* {
* STVertex vertex = new STVertex();
* vertex.Position = MorphData.Positions[v];
* verts.Add(vertex);
* }
*
* STPolygonGroup group = new STPolygonGroup();
* group.PrimitiveType = STPrimitiveType.Points;
* msh.PolygonGroups.Add(group);
*
* msh.Vertices.AddRange(verts);
* msh.Optmize(group);
*/
for (int i = 0; i < MorphData.MorphGroups.Count; i++)
{
var mesh = new STGenericMesh()
{
Name = $"Mesh{i}"
};
model.Meshes.Add(mesh);
var morphData = MorphData.MorphGroups[i];
STPolygonGroup group = new STPolygonGroup();
group.PrimitiveType = STPrimitiveType.Triangles;
mesh.PolygonGroups.Add(group);
List <STVertex> verts = new List <STVertex>();
for (int v = 0; v < morphData.Positions.Count; v++)
{
STVertex vertex = new STVertex();
vertex.Position = morphData.Positions[v];
verts.Add(vertex);
}
verts = ConvertTriStrips(verts);
mesh.Vertices.AddRange(verts);
mesh.Optmize(group);
}
Model = model;
return(model);
}
public override void RenderMaterials(ShaderProgram shader, STGenericMesh mesh,
STPolygonGroup group, STGenericMaterial material, Vector4 highlight_color)
{
var msh = (HSFMesh)mesh;
shader.SetVector4("highlight_color", highlight_color);
//Note we render picking pass here for backface culling
shader.SetFloat("brightness", 1.0f);
SetRenderData(group.Material, shader, msh);
SetTextureUniforms(shader, (HSFMaterialWrapper)group.Material);
}
public virtual void OnMeshDraw(MeshRender msh, STPolygonGroup group)
{
PrimitiveType mode = PrimitiveType.Triangles;
switch (group.PrimitiveType)
{
case STPrimitiveType.TriangleStrips:
mode = PrimitiveType.TriangleStrip;
break;
case STPrimitiveType.TriangleFans:
mode = PrimitiveType.TriangleFan;
break;
case STPrimitiveType.Lines:
mode = PrimitiveType.Lines;
break;
case STPrimitiveType.LineLoop:
mode = PrimitiveType.LineLoop;
break;
case STPrimitiveType.Points:
mode = PrimitiveType.Points;
break;
case STPrimitiveType.QuadStrips:
mode = PrimitiveType.QuadStrip;
break;
case STPrimitiveType.Quad:
mode = PrimitiveType.Quads;
break;
}
GL.Disable(EnableCap.CullFace);
msh.vao.Enable();
msh.vao.Use();
GL.DrawElements(mode,
group.Faces.Count,
DrawElementsType.UnsignedInt,
group.FaceOffset);
GL.Enable(EnableCap.CullFace);
}
public STGenericModel ToGeneric()
{
if (CachedModel != null)
{
return(CachedModel);
}
STGenericModel model = new STGenericModel("Model");
foreach (var shape in Meshes)
{
foreach (var meshGroup in shape.Groups)
{
var genericMesh = new STGenericMesh();
genericMesh.Name = $"Mesh{model.Meshes.Count}";
genericMesh.Vertices.AddRange(meshGroup.Vertices);
var group = new STPolygonGroup();
genericMesh.PolygonGroups.Add(group);
var mat = new STGenericMaterial();
mat.DiffuseColor = meshGroup.Color;
group.Material = mat;
if (meshGroup.TextureIndex != -1)
{
var texMap = new STGenericTextureMap()
{
Name = $"Texture{meshGroup.TextureIndex}",
Type = STTextureType.Diffuse,
};
mat.TextureMaps.Add(texMap);
}
genericMesh.Optmize(group);
model.Meshes.Add(genericMesh);
}
}
CachedModel = model;
return(model);
}
public STGenericModel ToGeneric()
{
if (CachedModel != null) return CachedModel;
STGenericModel model = new STGenericModel(FileName);
foreach (var shape in Meshes)
{
foreach (var meshGroup in shape.Groups)
{
var genericMesh = new STGenericMesh();
genericMesh.Name = $"Mesh{model.Meshes.Count}";
genericMesh.Vertices.AddRange(meshGroup.Vertices);
var group = new STPolygonGroup();
genericMesh.PolygonGroups.Add(group);
genericMesh.Optmize(group);
model.Meshes.Add(genericMesh);
var mat = new STGenericMaterial();
group.Material = mat;
// group.IsTransparentPass = true;
if (TextureContainer.Textures.Count > 0)
{
var texMap = new STGenericTextureMap()
{
Name = $"Texture{meshGroup.TextureIndex}",
Type = STTextureType.Diffuse,
};
mat.TextureMaps.Add(texMap);
}
}
}
foreach (var tex in TextureContainer.Textures)
model.Textures.Add(tex);
CachedModel = model;
return model;
}
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 STGenericModel ToGeneric()
{
if (Model != null)
{
return(Model);
}
STGenericModel model = new STGenericModel(FileInfo.FileName);
model.Skeleton = new STSkeleton();
foreach (var bone in Header.Bones)
{
var matrix = bone.InverseTransform.Inverted();
model.Skeleton.Bones.Add(new STBone(model.Skeleton)
{
Name = bone.Name,
Position = bone.Position,
Rotation = matrix.ExtractRotation(),
Scale = matrix.ExtractScale(),
ParentIndex = bone.ParentIndex,
});
}
model.Skeleton.Reset();
model.Skeleton.Update();
List <STGenericMaterial> materials = new List <STGenericMaterial>();
foreach (var mat in Header.Materials)
{
STGenericMaterial genericMaterial = new STGenericMaterial();
genericMaterial.Name = mat.Name;
materials.Add(genericMaterial);
for (int i = 0; i < mat.TextureSlots.Length; i++)
{
if (mat.TextureSlots[i] == null)
{
continue;
}
genericMaterial.TextureMaps.Add(new STGenericTextureMap()
{
Name = mat.TextureSlots[i].Name,
Type = STTextureType.Diffuse,
WrapU = STTextureWrapMode.Mirror,
WrapV = STTextureWrapMode.Mirror,
});
break;
}
}
foreach (var mesh in Header.Meshes)
{
if (mesh.Vertices.Count == 0)
{
continue;
}
STGenericMesh genericMesh = new STGenericMesh();
genericMesh.Name = mesh.Name;
model.Meshes.Add(genericMesh);
foreach (var vert in mesh.Vertices)
{
if (mesh.BoneIndices.Length == 1)
{
var bone = model.Skeleton.Bones[(int)mesh.BoneIndices[0]];
vert.Position = Vector3.TransformPosition(vert.Position, bone.Transform);
}
genericMesh.Vertices.Add(new STVertex()
{
Position = vert.Position,
Normal = vert.Normal,
TexCoords = new Vector2[] { vert.TexCoord0, vert.TexCoord1 },
Colors = new Vector4[] { vert.Color },
});
}
Console.WriteLine($"Vertices {mesh.Vertices.Count}");
genericMesh.FlipUvsVertical();
var poly = new STPolygonGroup();
poly.Material = materials[(int)mesh.MaterialIndex];
foreach (var face in mesh.Faces)
{
poly.Faces.Add(face);
}
genericMesh.PolygonGroups.Add(poly);
}
Model = model;
return(model);
}
public override void OnClick()
{
if (loaded)
{
return;
}
STGenericModel model = new STGenericModel(Label);
model.Skeleton = new SkeletonFormat();
for (int i = 0; i < DataParser.Files.Count; i++)
{
if (DataParser.Files[i].Hash == File.Hash &&
DataParser.Files[i].ChunkEntry.ChunkType == ChunkFileType.Skeleton)
{
if (DataParser.Version == DICT.GameVersion.LM2)
{
model.Skeleton = LM2.SkeletonChunk.Read(DataParser.Files[i].ChunkEntry.SubData);
}
if (DataParser.Version == DICT.GameVersion.LM3)
{
model.Skeleton = LM3.SkeletonChunk.Read(DataParser.Files[i].ChunkEntry.SubData);
}
}
}
Dictionary <uint, int> boneHashToID = ((SkeletonFormat)model.Skeleton).BoneHashToID;
if (DataParser.Version == DICT.GameVersion.LM3)
{
var modelList = ModelChunk.Read(File.ChunkEntry.SubData, boneHashToID);
/* var materialChunk = File.ChunkEntry.SubData.FirstOrDefault(x => x.ChunkType == ChunkDataType.MaterialData);
* var materialLookupChunk = File.ChunkEntry.SubData.FirstOrDefault(x => x.ChunkType == ChunkDataType.MaterialLookupTable);
*
* var matChunks = MaterialLoaderHelper.CreateMaterialChunkList(materialChunk.Data,
* materialLookupChunk.Data, modelList.SelectMany(x => x.Meshes).ToList());*/
int index = 0;
foreach (var mdl in modelList)
{
foreach (var mesh in mdl.Meshes)
{
var genericMesh = new STGenericMesh();
genericMesh.Name = Hashing.CreateHashString(mesh.MeshHeader.Hash);
if (Hashing.HashNames.ContainsKey(mesh.MeshHeader.MaterialHash))
{
genericMesh.Name += $"_{Hashing.CreateHashString(mesh.MeshHeader.MaterialHash)}";
}
Console.WriteLine($"MESH_HASHM {Hashing.CreateHashString(mesh.MeshHeader.MaterialHash)}");
Console.WriteLine($"MESH_HASHV {Hashing.CreateHashString(mesh.MeshHeader.VertexFormatHash)}");
genericMesh.Vertices.AddRange(mesh.Vertices);
var poly = new STPolygonGroup();
poly.Faces = mesh.Faces.ToList();
genericMesh.PolygonGroups.Add(poly);
model.Meshes.Add(genericMesh);
var material = new LMMaterial();
poly.Material = material;
material.TextureMaps.Add(new STGenericTextureMap()
{
Name = Hashing.CreateHashString(mesh.Material.DiffuseHash),
Type = STTextureType.Diffuse,
});
index++;
}
}
}
else
{
var modelList = LM2.ModelChunk.Read(File.ChunkEntry.SubData, boneHashToID);
foreach (var mdl in modelList)
{
foreach (var mesh in mdl.Meshes)
{
var genericMesh = new STGenericMesh();
genericMesh.Name = Hashing.CreateHashString(mesh.MeshHeader.Hash);
if (Hashing.HashNames.ContainsKey(mesh.MeshHeader.MaterialHash))
{
genericMesh.Name += $"_{Hashing.CreateHashString(mesh.MeshHeader.MaterialHash)}";
}
genericMesh.Name += $"_{mesh.MeshHeader.VertexFormatHash}_{VertexLoaderExtension.GetStride(mesh.MeshHeader.VertexFormatHash)}";
uint vertexStride = VertexLoaderExtension.GetStride(mesh.MeshHeader.VertexFormatHash);
if (mesh.Vertices.Count == 0)
{
continue;
}
genericMesh.Vertices.AddRange(mesh.Vertices);
var poly = new STPolygonGroup();
poly.Faces = mesh.Faces.ToList();
genericMesh.PolygonGroups.Add(poly);
model.Meshes.Add(genericMesh);
var material = new LMMaterial();
material.IsAmbientMap = mesh.Material.IsAmbientMap;
poly.Material = material;
material.TextureMaps.Add(new STGenericTextureMap()
{
Name = Hashing.CreateHashString(mesh.Material.DiffuseTextureHash),
Type = STTextureType.Diffuse,
});
if (mesh.Material.HasShadowMap)
{
material.TextureMaps.Add(new STGenericTextureMap()
{
Name = Hashing.CreateHashString(mesh.Material.ShadowTextureHash),
Type = STTextureType.Shadow,
});
}
}
}
}
Tag = new ModelFormat(model);
foreach (var child in model.CreateTreeHiearchy().Children)
{
AddChild(child);
}
loaded = true;
}
public STGenericModel ToGeneric()
{
if (Model != null)
{
return(Model);
}
var model = new STGenericModel(FileInfo.FileName);
model.Textures = Textures;
Matrix4 matrix = Matrix4.Identity;
List <STGenericMaterial> materials = new List <STGenericMaterial>();
for (int i = 0; i < Header.Materials.Length; i++)
{
materials.Add(CreateMaterial(Header.Materials[i], i));
}
model.Skeleton = new STSkeleton();
Matrix4[] transforms = new Matrix4[Header.FileHeader.JointCount];
for (int i = 0; i < Header.FileHeader.JointCount; i++)
{
var transfrom = Header.Matrix4Table[i];
transfrom.Invert();
transfrom.Transpose();
transforms[i] = transfrom;
model.Skeleton.Bones.Add(new STBone(model.Skeleton)
{
Name = Header.Nodes[i].ShapeCount > 0 ? $"Mesh{i}" : $"Bone{i}",
Position = transfrom.ExtractTranslation(),
Rotation = transfrom.ExtractRotation(),
Scale = transfrom.ExtractScale(),
});
}
TraverseNodeGraph(model.Skeleton, 0);
model.Skeleton.ConvertWorldToLocalSpace();
model.Skeleton.Reset();
model.Skeleton.Update();
for (int i = 0; i < Header.Meshes.Count; i++)
{
var mesh = new STGenericMesh()
{
Name = $"Mesh{i}"
};
model.Meshes.Add(mesh);
var matIndex = Header.Meshes[i].DrawElement.MaterialIndex;
STPolygonGroup group = new STPolygonGroup();
group.Material = materials[matIndex];
group.PrimitiveType = STPrimitiveType.Triangles;
mesh.PolygonGroups.Add(group);
foreach (var packet in Header.Meshes[i].Packets)
{
foreach (var drawList in packet.DrawLists)
{
var verts = new List <STVertex>();
for (int v = 0; v < drawList.Vertices.Count; v++)
{
if (drawList.Vertices[v].MatrixIndex != -1 && drawList.Vertices[v].MatrixDataIndex < Header.FileHeader.JointCount)
{
matrix = transforms[drawList.Vertices[v].MatrixDataIndex];
}
else
{
matrix = Matrix4.Identity;
}
verts.Add(ToVertex(drawList.Vertices[v], ref matrix));
}
switch (drawList.OpCode)
{
case 0xA0:
verts = ConvertTriFans(verts);
mesh.Vertices.AddRange(verts);
break;
case 0x90:
mesh.Vertices.AddRange(verts);
break;
case 0x98:
verts = ConvertTriStrips(verts);
mesh.Vertices.AddRange(verts);
break;
default:
throw new Exception("Unknown opcode " + drawList.OpCode);
}
}
}
mesh.Optmize(group);
}
Model = model;
return(model);
}
private STGenericMesh CreateGenericMesh(STGenericModel model, MOD_Parser.Shape mesh, Material material)
{
List <STVertex> transformedVertices2 = new List <STVertex>();
for (int v = 0; v < mesh.Vertices.Count; v++)
{
if (mesh.Vertices[v].BoneIndices.Count > 1 || transformedVertices2.Contains(mesh.Vertices[v]))
{
continue;
}
transformedVertices2.Add(mesh.Vertices[v]);
for (int j = 0; j < mesh.Vertices[v].BoneIndices.Count; j++)
{
int index = mesh.Vertices[v].BoneIndices[j];
if (mesh.Vertices[v].BoneIndices.Count == 1)
{
mesh.Vertices[v].BoneIndices[j] = Header.RigidSkinningIndices[index];
}
}
}
var genericMesh = new STGenericMesh();
List <STVertex> transformedVertices = new List <STVertex>();
for (int v = 0; v < mesh.Vertices.Count; v++)
{
if (mesh.Vertices[v].BoneIndices.Count == 1 && !transformedVertices.Contains(mesh.Vertices[v]))
{
transformedVertices.Add(mesh.Vertices[v]);
var boneIndex = mesh.Vertices[v].BoneIndices[0];
var transform = model.Skeleton.Bones[boneIndex].Transform;
mesh.Vertices[v].Position = Vector3.TransformPosition(mesh.Vertices[v].Position,
transform);
mesh.Vertices[v].Normal = Vector3.TransformNormal(mesh.Vertices[v].Normal,
transform);
Console.WriteLine($"TRANSFORM {boneIndex}");
}
}
genericMesh.Vertices.AddRange(mesh.Vertices);
var poly = new STPolygonGroup();
genericMesh.PolygonGroups.Add(poly);
genericMesh.Optmize(poly);
var genericMat = new MODMaterial(Header, material);
poly.Material = genericMat;
if (material.TextureFlags == 2)
{
poly.IsTransparentPass = true;
}
return(genericMesh);
}
public STGenericModel ToGeneric()
{
if (Model != null)
{
return(Model);
}
var model = new STGenericModel(FileInfo.FileName);
List <Texture> textures = new List <Texture>();
Header.GetTextures(textures);
for (int i = 0; i < textures.Count; i++)
{
model.Textures.Add(new BINTexture(textures[i])
{
Name = $"Texture{i}"
});
}
int index = 0;
foreach (var node in Header.GetAllSceneNodes())
{
model.Skeleton.Bones.Add(new STBone(model.Skeleton)
{
Name = $"Node{index++}",
Position = node.Translate,
EulerRotation = node.Rotate * STMath.Deg2Rad,
Scale = node.Scale,
ParentIndex = node.ParentIndex,
});
}
model.Skeleton.Reset();
model.Skeleton.Update();
int nodeIndex = 0;
foreach (var node in Header.GetAllSceneNodes())
{
for (int i = 0; i < node.DrawnParts.Count; i++)
{
STGenericMesh mesh = new STGenericMesh();
mesh.Name = $"Mesh{model.Meshes.Count}";
STPolygonGroup group = new STPolygonGroup();
group.PrimitiveType = STPrimitiveType.Triangles;
mesh.PolygonGroups.Add(group);
group.IsTransparentPass = true;
BIN_Material mat = new BIN_Material();
var element = node.DrawnParts[i];
mat.TintColor = element.Material.AmbientColor;
foreach (var sampler in element.Material.Samplers)
{
mat.TextureMaps.Add(new STGenericTextureMap()
{
WrapU = ConvertWrapModes(sampler.WrapS),
WrapV = ConvertWrapModes(sampler.WrapT),
Name = $"Texture{sampler.TextureIndex}",
Type = mat.TextureMaps.Count == 0 ? STTextureType.Diffuse : STTextureType.None,
});
}
group.Material = mat;
foreach (var packet in element.Batch.Packets)
{
List <STVertex> verts = new List <STVertex>();
for (int v = 0; v < packet.Vertices.Length; v++)
{
verts.Add(ToVertex(model.Skeleton.Bones[nodeIndex], packet.Vertices[v]));
}
switch (packet.OpCode)
{
case 0xA0:
ConvertTriFans(verts);
mesh.Vertices.AddRange(verts);
break;
case 0x90:
mesh.Vertices.AddRange(verts);
break;
case 0x98:
verts = ConvertTriStrips(verts);
mesh.Vertices.AddRange(verts);
break;
default:
throw new Exception("Unknown opcode " + packet.OpCode);
}
}
mesh.Optmize(group);
model.Meshes.Add(mesh);
}
nodeIndex++;
}
Model = model;
return(model);
}
private static void ConvertPolygon(ColladaScene scene, STGenericMesh mesh, mesh daeMesh,
InputLocalOffset[] inputs, List <BoneWeight[]> boneWeights,
library_materials materials, string material, string polys, int polyCount, string vcount = "")
{
List <uint> faces = new List <uint>();
STPolygonGroup group = new STPolygonGroup();
mesh.PolygonGroups.Add(group);
group.MaterialIndex = DaeUtility.FindMaterialIndex(materials, material);
string[] indices = polys.Trim(' ').Split(' ');
string[] vertexCount = new string[0];
if (vcount != string.Empty)
{
vertexCount = vcount.Trim(' ').Split(' ');
}
int stride = 0;
for (int i = 0; i < inputs.Length; i++)
{
stride = Math.Max(0, (int)inputs[i].offset + 1);
}
//Create a current list of all the vertices
//Use a list to expand duplicate indices
List <Vertex> vertices = new List <Vertex>();
var vertexSource = DaeUtility.FindSourceFromInput(daeMesh.vertices.input[0], daeMesh.source);
var floatArr = vertexSource.Item as float_array;
for (int v = 0; v < (int)floatArr.count / 3; v++)
{
vertices.Add(new Vertex(vertices.Count, new List <int>()));
}
var indexStride = (indices.Length / 3) / polyCount;
for (int i = 0; i < polyCount; i++)
{
int count = 3;
if (vertexCount.Length > i)
{
count = Convert.ToInt32(vertexCount[i]);
}
for (int v = 0; v < count; v++)
{
List <int> semanticIndices = new List <int>();
for (int j = 0; j < inputs.Length; j++)
{
int faceOffset = (indexStride * 3) * i;
int index = Convert.ToInt32(indices[faceOffset + (v * indexStride) + (int)inputs[j].offset]);
semanticIndices.Add(index);
}
BoneWeight[] boneWeightData = new BoneWeight[0];
if (boneWeights?.Count > semanticIndices[0])
{
boneWeightData = boneWeights[semanticIndices[0]];
}
VertexLoader.LoadVertex(ref faces, ref vertices, semanticIndices, boneWeightData);
}
}
int numTexCoordChannels = 0;
int numColorChannels = 0;
//Find them in both types of inputs
for (int i = 0; i < inputs.Length; i++)
{
if (inputs[i].semantic == "TEXCOORD")
{
numTexCoordChannels++;
}
if (inputs[i].semantic == "COLOR")
{
numColorChannels++;
}
}
for (int i = 0; i < daeMesh.vertices.input.Length; i++)
{
if (daeMesh.vertices.input[i].semantic == "TEXCOORD")
{
numTexCoordChannels++;
}
if (daeMesh.vertices.input[i].semantic == "COLOR")
{
numColorChannels++;
}
}
for (int i = 0; i < vertices.Count; i++)
{
if (!vertices[i].IsSet)
{
vertices.Remove(vertices[i]);
}
}
bool hasNormals = false;
foreach (var daeVertex in vertices)
{
if (daeVertex.semanticIndices.Count == 0)
{
continue;
}
STVertex vertex = new STVertex();
vertex.TexCoords = new Vector2[numTexCoordChannels];
vertex.Colors = new Vector4[numColorChannels];
vertex.BoneWeights = daeVertex.BoneWeights.ToList();
mesh.Vertices.Add(vertex);
//DAE has 2 inputs. Vertex and triangle inputs
//Triangle inputs use indices over vertex inputs which only use one
//Triangle inputs allow multiple color/uv sets unlike vertex inputs
//Certain programs ie Noesis DAEs use vertex inputs. Most programs use triangle inputs
for (int j = 0; j < daeMesh.vertices.input.Length; j++)
{
//Vertex inputs only use the first index
var vertexInput = daeMesh.vertices.input[j];
source source = DaeUtility.FindSourceFromInput(vertexInput, daeMesh.source);
if (source == null)
{
continue;
}
if (vertexInput.semantic == "NORMAL")
{
hasNormals = true;
}
int dataStride = (int)source.technique_common.accessor.stride;
int index = daeVertex.semanticIndices[0] * dataStride;
ParseVertexSource(ref vertex, scene, source, numTexCoordChannels, numColorChannels,
dataStride, index, 0, vertexInput.semantic);
}
for (int i = 0; i < inputs.Length; i++)
{
var input = inputs[i];
source source = DaeUtility.FindSourceFromInput(input, daeMesh.source);
if (source == null)
{
continue;
}
if (input.semantic == "NORMAL")
{
hasNormals = true;
}
int dataStride = (int)source.technique_common.accessor.stride;
int index = daeVertex.semanticIndices[i] * dataStride;
ParseVertexSource(ref vertex, scene, source, numTexCoordChannels, numColorChannels,
dataStride, index, (int)input.set, input.semantic);
}
}
group.Faces = faces;
if (!hasNormals)
{
CalculateNormals(mesh.Vertices, faces);
}
if (scene.Settings.RemoveDuplicateVerts)
{
RemoveDuplicateVerts(mesh.Vertices, faces);
}
}
public STGenericModel ToGeneric()
{
if (Model != null)
{
return(Model);
}
var model = new STGenericModel(FileInfo.FileName);
var sectionData = Header.FileHeader.SectionData;
foreach (var bone in sectionData.SkeletonChunk.Bones)
{
model.Skeleton.Bones.Add(new STBone(model.Skeleton)
{
Name = $"Bone{bone.ID}",
Position = new Vector3(
bone.Translation.X,
bone.Translation.Y,
bone.Translation.Z),
Scale = new Vector3(
bone.Scale.X,
bone.Scale.Y,
bone.Scale.Z),
EulerRotation = new Vector3(
bone.Rotation.X,
bone.Rotation.Y,
bone.Rotation.Z),
ParentIndex = bone.ParentIndex,
});
}
model.Skeleton.Reset();
model.Skeleton.Update();
foreach (var tex in sectionData.TextureChunk.Textures)
{
model.Textures.Add(new CTXB.TextureWrapper(tex)
{
Name = $"Texture{model.Textures.Count}"
});
}
foreach (var mat in sectionData.MaterialChunk.Materials)
{
STGenericMaterial genericMat = new STGenericMaterial();
genericMat.Name = $"Material{model.Materials.Count}";
model.Materials.Add(genericMat);
bool HasDiffuse = false;
foreach (var tex in mat.TextureMaps)
{
if (tex.TextureIndex != -1)
{
STGenericTextureMap matTexture = new STGenericTextureMap();
genericMat.TextureMaps.Add(matTexture);
if (tex.TextureIndex < model.Textures.Count)
{
matTexture.Name = model.Textures[tex.TextureIndex].Name;
}
if (!HasDiffuse && matTexture.Name != "bg_syadowmap") //Quick hack till i do texture env stuff
{
matTexture.Type = STTextureType.Diffuse;
HasDiffuse = true;
}
}
}
}
var shapeData = sectionData.SkeletalMeshChunk.ShapeChunk;
var meshData = sectionData.SkeletalMeshChunk.MeshChunk;
foreach (var mesh in meshData.Meshes)
{
STGenericMesh genericMesh = new STGenericMesh();
genericMesh.Name = $"Mesh_{model.Meshes.Count}";
model.Meshes.Add(genericMesh);
var shape = shapeData.SeperateShapes[(int)mesh.SepdIndex];
List <ushort> SkinnedBoneTable = new List <ushort>();
foreach (var prim in shape.Primatives)
{
if (prim.BoneIndexTable != null)
{
SkinnedBoneTable.AddRange(prim.BoneIndexTable);
}
}
//Now load the vertex and face data
if (shape.Position.VertexData != null)
{
int VertexCount = shape.Position.VertexData.Length;
for (int v = 0; v < VertexCount; v++)
{
STVertex vert = new STVertex();
vert.TexCoords = new Vector2[1];
vert.Position = new OpenTK.Vector3(
shape.Position.VertexData[v].X,
shape.Position.VertexData[v].Y,
shape.Position.VertexData[v].Z);
if (shape.Normal.VertexData != null && shape.Normal.VertexData.Length > v)
{
vert.Normal = new OpenTK.Vector3(
shape.Normal.VertexData[v].X,
shape.Normal.VertexData[v].Y,
shape.Normal.VertexData[v].Z).Normalized();
}
if (shape.Color.VertexData != null && shape.Color.VertexData.Length > v)
{
vert.Colors = new Vector4[1]
{
new OpenTK.Vector4(
shape.Color.VertexData[v].X,
shape.Color.VertexData[v].Y,
shape.Color.VertexData[v].Z,
shape.Color.VertexData[v].W).Normalized()
};
}
if (shape.TexCoord0.VertexData != null && shape.TexCoord0.VertexData.Length > v)
{
vert.TexCoords[0] = new OpenTK.Vector2(
shape.TexCoord0.VertexData[v].X,
1 - shape.TexCoord0.VertexData[v].Y);
}
if (shape.TexCoord1.VertexData != null)
{
}
if (shape.TexCoord2.VertexData != null)
{
}
for (int i = 0; i < 16; i++)
{
if (i < shape.Primatives[0].BoneIndexTable.Length)
{
int boneId = shape.Primatives[0].BoneIndexTable[i];
if (shape.Primatives[0].SkinningMode == SkinningMode.RIGID_SKINNING)
{
vert.Position = Vector3.TransformPosition(vert.Position, model.Skeleton.Bones[boneId].Transform);
vert.Normal = Vector3.TransformNormal(vert.Position, model.Skeleton.Bones[boneId].Transform);
}
}
}
bool HasSkinning = shape.Primatives[0].SkinningMode != SkinningMode.SINGLE_BONE &&
shape.BoneIndices.Type == CmbDataType.UByte; //Noclip checks the type for ubyte so do the same
bool HasWeights = shape.Primatives[0].SkinningMode == SkinningMode.SMOOTH_SKINNING;
if (shape.BoneIndices.VertexData != null && HasSkinning && shape.BoneIndices.VertexData.Length > v)
{
var BoneIndices = shape.BoneIndices.VertexData[v];
for (int j = 0; j < shape.boneDimension; j++)
{
if (BoneIndices[j] < SkinnedBoneTable.Count)
{
vert.BoneIndices.Add((int)SkinnedBoneTable[(int)BoneIndices[j]]);
}
// Console.WriteLine("boneIds " + BoneIndices[j]);
// ushort index = shape.Primatives[0].BoneIndexTable[(uint)BoneIndices[j]];
}
}
if (shape.BoneWeights.VertexData != null && HasWeights && shape.BoneWeights.VertexData.Length > v)
{
var BoneWeights = shape.BoneWeights.VertexData[v];
for (int j = 0; j < shape.boneDimension; j++)
{
vert.BoneWeights.Add(BoneWeights[j]);
}
}
genericMesh.Vertices.Add(vert);
}
}
foreach (var prim in shape.Primatives)
{
STPolygonGroup group = new STPolygonGroup();
genericMesh.PolygonGroups.Add(group);
group.MaterialIndex = mesh.MaterialIndex;
// for (int i = 0; i < prim.Primatives[0].Indices.Length; i++)
// group.Faces.Add(prim.Primatives[0].Indices[i]);
}
}
Model = model;
return(model);
}
