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 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++;
}
}
private static STGenericMesh LoadMeshData(ColladaScene scene, Node node,
geometry geom, library_materials materials, controller controller = null)
{
mesh daeMesh = geom.Item as mesh;
STGenericMesh mesh = new STGenericMesh();
mesh.Vertices = new List <STVertex>();
mesh.Name = geom.name;
var boneWeights = ParseWeightController(controller, scene);
foreach (var item in daeMesh.Items)
{
//Poly lists can control specific amounts of indices for primitive types like quads
if (item is polylist)
{
var poly = item as polylist;
ConvertPolygon(scene, mesh, daeMesh, poly.input,
boneWeights, materials, poly.material, poly.p, (int)poly.count, poly.vcount);
}
else if (item is triangles)
{
var triangle = item as triangles;
ConvertPolygon(scene, mesh, daeMesh, triangle.input,
boneWeights, materials, triangle.material, triangle.p, (int)triangle.count);
}
}
return(mesh);
}
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);
}
static ObjectTreeNode LoadMesh(STGenericMesh mesh)
{
ObjectTreeNode node = new ObjectTreeNode(mesh.Name);
node.ImageKey = "Mesh";
node.Tag = mesh;
return(node);
}
public static void Export(string FileName, ExportSettings settings, STGenericMesh mesh)
{
Export(FileName, settings, new List <STGenericMesh>()
{
mesh
},
new List <STGenericMaterial>(), new List <STGenericTexture>());
}
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 void LoadMesh(STGenericMesh mesh)
{
ActiveMesh = mesh;
for (int i = 0; i < mesh.PolygonGroups.Count; i++)
{
if (mesh.PolygonGroups[i].Material != null)
{
LoadMaterial(mesh.PolygonGroups[i].Material);
break;
}
}
}
private int[] CreateIndexBuffer(STGenericMesh mesh)
{
List <int> indices = new List <int>();
foreach (var poly in mesh.PolygonGroups)
{
for (int f = 0; f < poly.Faces.Count; f++)
{
indices.Add((int)poly.Faces[f]);
}
}
return(indices.ToArray());
}
private static STGenericMesh LoadMeshData(ColladaScene scene, Node node,
geometry geom, library_materials materials, controller controller = null)
{
mesh daeMesh = geom.Item as mesh;
STGenericMesh mesh = new STGenericMesh();
mesh.Vertices = new List <STVertex>();
mesh.Name = geom.name;
var boneWeights = ParseWeightController(controller, scene);
foreach (var item in daeMesh.Items)
{
//Poly lists can control specific amounts of indices for primitive types like quads
if (item is polylist)
{
var poly = item as polylist;
ConvertPolygon(scene, mesh, daeMesh, poly.input,
boneWeights, materials, poly.material, poly.p, (int)poly.count, poly.vcount);
}
else if (item is triangles)
{
var triangle = item as triangles;
ConvertPolygon(scene, mesh, daeMesh, triangle.input,
boneWeights, materials, triangle.material, triangle.p, (int)triangle.count);
}
}
foreach (var vertex in mesh.Vertices)
{
if (scene.Settings.FlipUVsVertical)
{
for (int i = 0; i < vertex.TexCoords.Length; i++)
{
vertex.TexCoords[i] = new Vector2(vertex.TexCoords[i].X, 1 - vertex.TexCoords[i].Y);
}
}
vertex.Position = Vector3.TransformPosition(vertex.Position, node.Transform);
vertex.Position = Vector3.TransformPosition(vertex.Position, Matrix4.CreateScale(0.01f));
//vertex.Normal = Vector3.TransformNormal(vertex.Normal, node.Transform);
}
return(mesh);
}
private int[] CreateIndexBuffer(STGenericMesh mesh)
{
int polyOffset = 0;
List <int> indices = new List <int>();
foreach (var poly in mesh.PolygonGroups)
{
poly.FaceOffset = polyOffset * sizeof(int);
for (int f = 0; f < poly.Faces.Count; f++)
{
indices.Add((int)poly.Faces[f]);
}
polyOffset += poly.Faces.Count;
}
return(indices.ToArray());
}
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;
}
static BoundingBox GenerateBoundingBox(STGenericMesh mesh)
{
float minX = float.MaxValue;
float minY = float.MaxValue;
float minZ = float.MaxValue;
float maxX = float.MinValue;
float maxY = float.MinValue;
float maxZ = float.MinValue;
for (int v = 0; v < mesh.Vertices.Count; v++)
{
minX = Math.Min(minX, mesh.Vertices[v].Position.X);
minY = Math.Min(minY, mesh.Vertices[v].Position.Y);
minZ = Math.Min(minZ, mesh.Vertices[v].Position.Z);
maxX = Math.Max(maxX, mesh.Vertices[v].Position.X);
maxY = Math.Max(maxY, mesh.Vertices[v].Position.Y);
maxZ = Math.Max(maxZ, mesh.Vertices[v].Position.Z);
}
return(new BoundingBox()
{
Min = new Vector3XYZ(minX, minY, minZ),
Max = new Vector3XYZ(maxX, maxY, maxZ),
});
}
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);
}
public override void SetMaterialUniforms(ShaderProgram shader, STGenericMaterial material, STGenericMesh mesh)
{
var mat = (LMMaterial)material;
if (mat == null)
{
return;
}
shader.SetBool("isAmbientMap", mat.IsAmbientMap);
base.SetMaterialUniforms(shader, material, mesh);
}
private STGenericMesh LoadMesh(ModelBlock mdl, ObjectBlock obj, MeshBlock mesh)
{
STGenericMesh genericMesh = new STGenericMesh();
genericMesh.Name = obj.Name;
var transform = obj.GetTransform();
var meshInfo = obj.MeshData;
var ctx = NitroGX.ReadCmds(meshInfo.Data);
for (int i = 0; i < ctx.vertices.Count; i++)
{
STVertex vertex = new STVertex();
vertex.Position = ctx.vertices[i].Position;
vertex.Normal = ctx.vertices[i].Normal;
vertex.TexCoords = new Vector2[1]
{
ctx.vertices[i].TexCoord
};
vertex.Colors = new Vector4[1]
{
new Vector4(ctx.vertices[i].Color / 255f,
ctx.vertices[i].Alpha / 255f)
};
vertex.Position = Vector3.TransformPosition(vertex.Position, transform);
genericMesh.Vertices.Add(vertex);
}
uint[] faces = new uint[ctx.indices.Count];
for (int i = 0; i < ctx.indices.Count; i++)
{
faces[i] = ctx.indices[i];
}
foreach (var poly in mesh.PolyGroups)
{
var material = mdl.Materials[poly.MaterialIndex];
/* uint[] polyFaces = new uint[poly.FaceCount];
* for (int i = 0; i < poly.FaceCount; i++) {
* polyFaces[i] = ctx.indices[poly.FaceStart + i];
* }*/
STGenericMaterial genericMaterial = new STGenericMaterial();
genericMaterial.Name = material.Name;
if (material.MaterialBlock.AttributeIndex != -1)
{
var attribute = mdl.Attributes[material.MaterialBlock.AttributeIndex];
genericMaterial.TextureMaps.Add(new STGenericTextureMap()
{
Name = attribute.TextureName,
Type = STTextureType.Diffuse,
});
}
genericMesh.PolygonGroups.Add(new STPolygonGroup()
{
PrimitiveType = STPrimitiveType.Triangles,
Material = genericMaterial,
Faces = faces.ToList(),
});
break;
}
return(genericMesh);
}
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 override void SetMaterialUniforms(ShaderProgram shader, STGenericMaterial material, STGenericMesh mesh)
{
shader.SetVector4("tint_color", Vector4.One);
var mat = (BIN.BIN_Material)material;
shader.SetVector4("tint_color", new Vector4(
mat.TintColor.R / 255F,
mat.TintColor.G / 255F,
mat.TintColor.B / 255F,
mat.TintColor.A / 255F));
}
public GenericPickableMesh(STGenericMesh mesh) : base(Vector3.Zero, Vector3.Zero, Vector3.One)
{
Mesh = mesh;
mesh.SelectMesh += ForceSelection;
}
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 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);
}
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 virtual void SetMaterialUniforms(ShaderProgram shader, STGenericMaterial material, STGenericMesh mesh)
{
shader.SetColor("diffuseColor", STColor8.White.Color);
if (material == null)
{
return;
}
shader.SetColor("diffuseColor", material.DiffuseColor.Color);
}
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 MeshRender(STGenericMesh mesh, ModelRenderer render)
{
Mesh = mesh;
Renderer = render;
}
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 float[] CreateVertexBuffer(STGenericMesh mesh)
{
List <float> list = new List <float>();
Console.WriteLine($"Vertex Count {mesh.Vertices.Count}");
for (int i = 0; i < mesh.Vertices.Count; i++)
{
list.Add(mesh.Vertices[i].Position.X);
list.Add(mesh.Vertices[i].Position.Y);
list.Add(mesh.Vertices[i].Position.Z);
list.Add(mesh.Vertices[i].Normal.X);
list.Add(mesh.Vertices[i].Normal.Y);
list.Add(mesh.Vertices[i].Normal.Z);
for (int t = 0; t < 1; t++)
{
if (mesh.Vertices[i].TexCoords.Length > t)
{
list.Add(mesh.Vertices[i].TexCoords[t].X);
list.Add(mesh.Vertices[i].TexCoords[t].Y);
}
else
{
list.Add(0);
list.Add(0);
}
}
Vector4 color = new Vector4(255, 255, 255, 255);
if (mesh.Vertices[i].Colors.Length > 0)
{
color = mesh.Vertices[i].Colors[0] * 255;
}
list.Add(BitConverter.ToSingle(new byte[4]
{
(byte)color.X,
(byte)color.Y,
(byte)color.Z,
(byte)color.W
}, 0));
for (int j = 0; j < 4; j++)
{
int index = -1;
if (mesh.Vertices[i].BoneIndices.Count > j)
{
index = mesh.Vertices[i].BoneIndices[j];
}
list.Add(Convert.ToSingle(index));
}
for (int j = 0; j < 4; j++)
{
if (mesh.Vertices[i].BoneWeights.Count > j)
{
list.Add(mesh.Vertices[i].BoneWeights[j]);
}
else
{
list.Add(0);
}
}
if (Renderer.SupportsTangents)
{
list.Add(mesh.Vertices[i].Tangent.X);
list.Add(mesh.Vertices[i].Tangent.Y);
list.Add(mesh.Vertices[i].Tangent.Z);
}
if (Renderer.SupportsBinormals)
{
list.Add(mesh.Vertices[i].Bitangent.X);
list.Add(mesh.Vertices[i].Bitangent.Y);
list.Add(mesh.Vertices[i].Bitangent.Z);
}
}
return(list.ToArray());
}
private static List <STGenericMesh> LoadMeshData(ColladaScene scene, Node node,
geometry geom, library_materials materials, controller controller = null)
{
List <STGenericMesh> meshes = new List <STGenericMesh>();
mesh daeMesh = geom.Item as mesh;
STGenericMesh mesh = new STGenericMesh();
mesh.Vertices = new List <STVertex>();
mesh.Name = geom.name;
meshes.Add(mesh);
var boneWeights = ParseWeightController(controller, scene);
foreach (var item in daeMesh.Items)
{
//Poly lists can control specific amounts of indices for primitive types like quads
if (item is polylist)
{
var poly = item as polylist;
ConvertPolygon(scene, mesh, daeMesh, poly.input,
boneWeights, materials, poly.material, poly.p, (int)poly.count, poly.vcount);
}
else if (item is triangles)
{
var triangle = item as triangles;
ConvertPolygon(scene, mesh, daeMesh, triangle.input,
boneWeights, materials, triangle.material, triangle.p, (int)triangle.count);
}
}
for (int v = 0; v < mesh.Vertices.Count; v++)
{
if (scene.Settings.FlipUVsVertical)
{
for (int i = 0; i < mesh.Vertices[v].TexCoords.Length; i++)
{
mesh.Vertices[v].TexCoords[i] = new Vector2(mesh.Vertices[v].TexCoords[i].X, 1 - mesh.Vertices[v].TexCoords[i].Y);
}
}
mesh.Vertices[v].Position = Vector3.TransformPosition(mesh.Vertices[v].Position, node.Transform);
mesh.Vertices[v].Normal = Vector3.TransformNormal(mesh.Vertices[v].Normal, node.Transform);
}
if (controller != null)
{
skin skin = controller.Item as skin;
var bindMatrix = CreateBindMatrix(skin.bind_shape_matrix);
Console.WriteLine($"bindMatrix {bindMatrix.ExtractScale()}");
bindMatrix = bindMatrix.ClearScale();
for (int v = 0; v < mesh.Vertices.Count; v++)
{
mesh.Vertices[v].Position = Vector3.TransformPosition(mesh.Vertices[v].Position, bindMatrix);
mesh.Vertices[v].Normal = Vector3.TransformNormal(mesh.Vertices[v].Normal, bindMatrix);
}
}
// meshes = STGenericMesh.SeperatePolygonGroups<STGenericMesh>(mesh);
if (scene.Settings.RemoveDuplicateVerts)
{
// mesh.RemoveDuplicateVertices();
}
return(meshes);
}
