Ejemplo n.º 1
0
        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);
                }
            }
        }
Ejemplo n.º 2
0
        public void SetRenderData(STGenericMaterial mat, ShaderProgram shader, HSFMesh m)
        {
            var hsfMaterial    = (HSFMaterialWrapper)mat;
            var materialData   = hsfMaterial.Material.MaterialData;
            var objectData     = hsfMaterial.Mesh.ObjectData;
            var textureCount   = materialData.TextureCount;
            var vtx_mode       = materialData.VertexMode;
            var use_color      = vtx_mode & VTXMODE_USE_CLR0;
            var material_flags = objectData.RenderFlags | materialData.MaterialFlags;
            var pass_flags     = materialData.AltFlags & PASS_BITS;
            var alpha_flags    = material_flags & PUNCHTHROUGH_ALPHA_BITS;

            shader.SetInt("vertex_mode", materialData.VertexMode);
            shader.SetFloat("alpha_flags", alpha_flags);
            shader.SetFloat("pass_flags", pass_flags);

            Vector3 ambientColor = new Vector3(
                materialData.AmbientColor.R / 255f,
                materialData.AmbientColor.G / 255f,
                materialData.AmbientColor.B / 255f);
            Vector3 ambientLitColor = new Vector3(
                materialData.LitAmbientColor.R / 255f,
                materialData.LitAmbientColor.G / 255f,
                materialData.LitAmbientColor.B / 255f);
            Vector3 shadowColor = new Vector3(
                materialData.ShadowColor.R / 255f,
                materialData.ShadowColor.G / 255f,
                materialData.ShadowColor.B / 255f);

            float transparency = 1 - materialData.TransparencyInverted;

            int matIndex = HSFParent.Header.Materials.IndexOf(hsfMaterial.Material);

            if (HSFParent.Header.MatAnimControllers.ContainsKey(matIndex))
            {
                var controller = HSFParent.Header.MatAnimControllers[matIndex];
                ambientColor.X    = controller.AmbientColorR;
                ambientColor.Y    = controller.AmbientColorG;
                ambientColor.Z    = controller.AmbientColorB;
                ambientLitColor.X = controller.LitAmbientColorR;
                ambientLitColor.Y = controller.LitAmbientColorG;
                ambientLitColor.Z = controller.LitAmbientColorB;
                shadowColor.X     = controller.ShadowColorR;
                shadowColor.Y     = controller.ShadowColorG;
                shadowColor.Z     = controller.ShadowColorB;
                transparency      = 1 - controller.TransparencyInverted;
            }

            shader.SetFloat("transparency", transparency);
            shader.SetVector3("ambient_color", ambientColor);
            shader.SetVector3("ambient_lit_color", ambientLitColor);
            shader.SetVector3("shadow_color", shadowColor);

            bool cullNone = (material_flags & DONT_CULL_BACKFACES) != 0;

            if (pass_flags != 0 || materialData.TransparencyInverted != 0)
            {
            }
            else
            {
            }

            /*   if (materialData.VertexMode == 0 && alpha_flags == 0 && pass_flags == 0)
             * {
             *     GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.One);
             * }
             * else
             * {
             *     GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
             * }*/

            bool IsTransparent = alpha_flags != 0;

            shader.SetBoolToInt("isTransparent", false);
            if (alpha_flags != 0)
            {
                shader.SetBoolToInt("isTransparent", true);
            }
            else
            {
            }
            if (cullNone)
            {
                GL.Disable(EnableCap.CullFace);
            }
            else
            {
                GL.Enable(EnableCap.CullFace);
                GL.CullFace(CullFaceMode.Back);
            }
        }