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); }