override public List <List <Property> > ApplySpecialProperties(ModelGroup test, List <List <Property> > combos)
        {
            // Test the VertexColor in combo with DiffuseTexture
            var    diffuseTexture     = properties.Find(e => e.name == Propertyname.DiffuseTexture);
            string vertexColorName    = ReadmeStringHelper.GenerateNameWithSpaces(Propertyname.VertexColor_Vector3_Float.ToString());
            string diffuseTextureName = ReadmeStringHelper.GenerateNameWithSpaces(Propertyname.DiffuseTexture.ToString());

            foreach (var y in combos)
            {
                // Checks if combos contain the vertexcolor property
                if ((y.Find(e => ReadmeStringHelper.GenerateNameWithSpaces(e.name.ToString()) == vertexColorName)) != null)
                {
                    // Makes sure that diffuseTexture isn't already in that combo
                    if ((y.Find(e => ReadmeStringHelper.GenerateNameWithSpaces(e.name.ToString()) == diffuseTextureName)) == null)
                    {
                        y.Add(diffuseTexture);
                    }
                }
            }

            // When not testing SpecularFactor, set it to all 0s to avoid a default of 1s overriding the diffuse texture.
            var specularFactorOverride = properties.Find(e => e.name == Propertyname.SpecularFactor_Override);

            foreach (var y in combos)
            {
                // Not one of the empty sets, doesn't already have SpecFactor set. is using a DiffuseTexture
                if (y.Count > 0 &&
                    (y.Find(e => e.name == Propertyname.SpecularFactor)) == null &&
                    (y.Find(e => e.name == Propertyname.DiffuseTexture)) != null)
                {
                    y.Add(specularFactorOverride);
                }
            }

            var diffuseFactor    = properties.Find(e => e.name == Propertyname.DiffuseFactor);
            var glossinessFactor = properties.Find(e => e.name == Propertyname.GlossinessFactor);

            combos.Add(new List <Property>()
            {
                diffuseTexture,
                diffuseFactor
            });
            combos.Add(new List <Property>()
            {
                diffuseTexture,
                glossinessFactor
            });

            // Sort the combos by complexity
            combos.Sort(delegate(List <Property> x, List <Property> y)
            {
                if (x.Count == 0)
                {
                    return(-1);              // Empty Set
                }
                else if (y.Count == 0)
                {
                    return(1);                   // Empty Set
                }
                else if (x.Count > y.Count)
                {
                    return(1);
                }
                else if (x.Count < y.Count)
                {
                    return(-1);
                }
                else if (x.Count == y.Count)
                {
                    // Tie goes to the combo with the left-most property on the table
                    for (int p = 0; p < x.Count; p++)
                    {
                        if (x[p].propertyGroup != y[p].propertyGroup ||
                            x[p].propertyGroup == 0)
                        {
                            int xPropertyIndex = properties.FindIndex(e => e.name == x[p].name);
                            int yPropertyIndex = properties.FindIndex(e => e.name == y[p].name);
                            if (xPropertyIndex > yPropertyIndex)
                            {
                                return(1);
                            }
                            else if (xPropertyIndex < yPropertyIndex)
                            {
                                return(-1);
                            }
                        }
                    }
                    for (int p = 0; p < x.Count; p++)
                    {
                        int xPropertyIndex = properties.FindIndex(e => e.name == x[p].name);
                        int yPropertyIndex = properties.FindIndex(e => e.name == y[p].name);
                        if (xPropertyIndex > yPropertyIndex)
                        {
                            return(1);
                        }
                        else if (xPropertyIndex < yPropertyIndex)
                        {
                            return(-1);
                        }
                    }
                    return(0);
                }
                else
                {
                    return(0);
                }
            });

            return(combos);
        }
Exemplo n.º 2
0
        public Runtime.GLTF SetModelAttributes(Runtime.GLTF wrapper, Runtime.Material material, List <Property> combo, ref glTFLoader.Schema.Gltf gltf)
        {
            // Determines which of the primitives will have the material and attributes applied to it
            var splitType = combo.Find(e => e.propertyGroup == 1);

            foreach (Property property in combo)
            {
                if (property.name == Propertyname.Primitives_Split1 ||
                    property.name == Propertyname.Primitives_Split2 ||
                    property.name == Propertyname.Primitives_Split3 ||
                    property.name == Propertyname.Primitives_Split4)
                {
                    // Same plane, but split into two triangle primitives
                    var primitive0 = specialProperties.Find(e => e.name == Propertyname.Primitive_0);
                    var primitive1 = specialProperties.Find(e => e.name == Propertyname.Primitive_1);
                    Runtime.MeshPrimitive prim0 = new Runtime.MeshPrimitive
                    {
                        Positions = primitive0.value.Positions,
                        Indices   = primitive0.value.Indices,
                    };
                    Runtime.MeshPrimitive prim1 = new Runtime.MeshPrimitive
                    {
                        Positions = primitive1.value.Positions,
                        Indices   = primitive1.value.Indices,
                    };
                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives = new List <Runtime.MeshPrimitive>
                    {
                        prim0,
                        prim1
                    };
                }

                if (property.name == Propertyname.BaseColorTexture)
                {
                    if (material.MetallicRoughnessMaterial == null)
                    {
                        material.MetallicRoughnessMaterial = new Runtime.PbrMetallicRoughness();
                        material.MetallicRoughnessMaterial.BaseColorTexture = new Runtime.Texture();
                    }
                    material.MetallicRoughnessMaterial.BaseColorTexture.Source        = property.value;
                    material.MetallicRoughnessMaterial.BaseColorTexture.TexCoordIndex = 0;
                }

                if (property.name == Propertyname.NormalTexture)
                {
                    if (material.NormalTexture == null)
                    {
                        material.NormalTexture = new Runtime.Texture();
                    }
                    material.NormalTexture.Source        = property.value;
                    material.NormalTexture.TexCoordIndex = 0;
                }

                // Attributes set for only the first primitive
                if (splitType.name == Propertyname.Primitives_Split1)
                {
                    if (property.name == Propertyname.VertexNormal)
                    {
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Normals = property.value;
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Normals = null;
                    }
                    else if (property.name == Propertyname.VertexTangent)
                    {
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Tangents = property.value;
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Tangents = null;
                    }
                    else if (property.name == Propertyname.VertexColor_Vector4_Float)
                    {
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Colors = property.value;
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Colors = null;
                    }
                    else if (ReadmeStringHelper.GenerateNameWithSpaces(property.name.ToString()) ==
                             ReadmeStringHelper.GenerateNameWithSpaces(Propertyname.Primitive0VertexUV0.ToString())) // All UV0
                    {
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = new List <List <Vector2> >();
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = null;
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets.Add(
                            specialProperties.Find(e => e.name == Propertyname.Primitive0VertexUV0).value);
                    }
                    else if (ReadmeStringHelper.GenerateNameWithSpaces(property.name.ToString()) ==
                             ReadmeStringHelper.GenerateNameWithSpaces(Propertyname.Primitive0VertexUV1.ToString())) // All UV1
                    {
                        if (wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets == null)
                        {
                            wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = new List <List <Vector2> >();
                        }
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets.Add(
                            specialProperties.Find(e => e.name == Propertyname.Primitive0VertexUV1).value);
                    }
                }
                // Attributes set for only the second primitive
                else if (splitType.name == Propertyname.Primitives_Split2)
                {
                    if (property.name == Propertyname.VertexNormal)
                    {
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Normals = null;
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Normals = property.value;
                    }
                    else if (property.name == Propertyname.VertexTangent)
                    {
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Tangents = null;
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Tangents = property.value;
                    }
                    else if (property.name == Propertyname.VertexColor_Vector4_Float)
                    {
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Colors = null;
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Colors = property.value;
                    }
                    else if (ReadmeStringHelper.GenerateNameWithSpaces(property.name.ToString()) ==
                             ReadmeStringHelper.GenerateNameWithSpaces(Propertyname.Primitive1VertexUV0.ToString())) // All UV0
                    {
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = null;
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = new List <List <Vector2> >();
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets.Add(
                            specialProperties.Find(e => e.name == Propertyname.Primitive1VertexUV0).value);
                    }
                    else if (ReadmeStringHelper.GenerateNameWithSpaces(property.name.ToString()) ==
                             ReadmeStringHelper.GenerateNameWithSpaces(Propertyname.Primitive1VertexUV1.ToString())) // All UV1
                    {
                        if (wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets == null)
                        {
                            wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = new List <List <Vector2> >();
                        }
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets.Add(
                            specialProperties.Find(e => e.name == Propertyname.Primitive1VertexUV1).value);
                    }
                }
                // Attributes set for both of the primitives
                else if (splitType.name == Propertyname.Primitives_Split3)
                {
                    if (property.name == Propertyname.VertexNormal)
                    {
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Normals = property.value;
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Normals = property.value;
                    }
                    else if (property.name == Propertyname.VertexTangent)
                    {
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Tangents = property.value;
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Tangents = property.value;
                    }
                    else if (property.name == Propertyname.VertexColor_Vector4_Float)
                    {
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Colors = property.value;
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Colors = property.value;
                    }
                    else if (property.name == Propertyname.Primitive0VertexUV0)
                    {
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = new List <List <Vector2> >();
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets.Add(
                            specialProperties.Find(e => e.name == Propertyname.Primitive0VertexUV0).value);
                    }
                    else if (property.name == Propertyname.Primitive1VertexUV0)
                    {
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = new List <List <Vector2> >();
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets.Add(
                            specialProperties.Find(e => e.name == Propertyname.Primitive1VertexUV0).value);
                    }
                    else if (property.name == Propertyname.Primitive0VertexUV1)
                    {
                        if (wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets == null)
                        {
                            wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = new List <List <Vector2> >();
                        }
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets.Add(
                            specialProperties.Find(e => e.name == Propertyname.Primitive0VertexUV1).value);
                    }
                    else if (property.name == Propertyname.Primitive1VertexUV1)
                    {
                        if (wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets == null)
                        {
                            wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = new List <List <Vector2> >();
                        }
                        wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets.Add(
                            specialProperties.Find(e => e.name == Propertyname.Primitive1VertexUV1).value);
                    }
                }
                // Attributes set for neither of the primitives
                else if (splitType.name == Propertyname.Primitives_Split4)
                {
                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Normals = null;
                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Normals = null;

                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Tangents = null;
                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Tangents = null;

                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Colors = null;
                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Colors = null;

                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = null;
                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = null;

                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = null;
                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = null;
                }
            }

            // Material needs to be a deep copy here, or both primitives will get the same Mat.
            if (material.MetallicRoughnessMaterial != null)
            {
                if (splitType.name == Propertyname.Primitives_Split1 ||
                    splitType.name == Propertyname.Primitives_Split3)
                {
                    var mat = DeepCopy.CloneObject(material);
                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Material = mat;
                }
                if (splitType.name == Propertyname.Primitives_Split2 ||
                    splitType.name == Propertyname.Primitives_Split3)
                {
                    var mat = DeepCopy.CloneObject(material);
                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Material = mat;
                }
            }

            // Use the second UV if it has been set
            if (splitType.name != Propertyname.Primitives_Split4)
            {
                var prim0UV1 = combo.Find(e => e.name == Propertyname.Primitive0VertexUV1);
                var prim1UV1 = combo.Find(e => e.name == Propertyname.Primitive1VertexUV1);
                if (prim0UV1 != null)
                {
                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].
                    Material.MetallicRoughnessMaterial.BaseColorTexture.TexCoordIndex = 1;
                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].
                    Material.NormalTexture.TexCoordIndex = 1;
                }
                if (prim1UV1 != null)
                {
                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].
                    Material.MetallicRoughnessMaterial.BaseColorTexture.TexCoordIndex = 1;
                    wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].
                    Material.NormalTexture.TexCoordIndex = 1;
                }
            }

            return(wrapper);
        }
Exemplo n.º 3
0
        override public List <List <Property> > ApplySpecialProperties(ModelGroup test, List <List <Property> > combos)
        {
            // Test the VertexColor in combo with BaseColorTexture
            var    baseColorTexture     = properties.Find(e => e.name == Propertyname.BaseColorTexture);
            string vertexColorName      = ReadmeStringHelper.GenerateNameWithSpaces(Propertyname.VertexColor_Vector3_Float.ToString());
            string baseColorTextureName = ReadmeStringHelper.GenerateNameWithSpaces(Propertyname.BaseColorTexture.ToString());

            foreach (var y in combos)
            {
                // Checks if combos contain the vertexcolor property
                if ((y.Find(e => ReadmeStringHelper.GenerateNameWithSpaces(e.name.ToString()) == vertexColorName)) != null)
                {
                    // Makes sure that BaseColorTexture isn't already in that combo
                    if ((y.Find(e => ReadmeStringHelper.GenerateNameWithSpaces(e.name.ToString()) == baseColorTextureName)) == null)
                    {
                        y.Add(baseColorTexture);
                    }
                }
            }

            // Sort the combos by complexity
            combos.Sort(delegate(List <Property> x, List <Property> y)
            {
                if (x.Count == 0)
                {
                    return(-1);              // Empty Set
                }
                else if (y.Count == 0)
                {
                    return(1);                   // Empty Set
                }
                else if (x.Count > y.Count)
                {
                    return(1);
                }
                else if (x.Count < y.Count)
                {
                    return(-1);
                }
                else if (x.Count == y.Count)
                {
                    // Tie goes to the combo with the left-most property on the table
                    for (int p = 0; p < x.Count; p++)
                    {
                        if (x[p].propertyGroup != y[p].propertyGroup ||
                            x[p].propertyGroup == 0)
                        {
                            int xPropertyIndex = properties.FindIndex(e => e.name == x[p].name);
                            int yPropertyIndex = properties.FindIndex(e => e.name == y[p].name);
                            if (xPropertyIndex > yPropertyIndex)
                            {
                                return(1);
                            }
                            else if (xPropertyIndex < yPropertyIndex)
                            {
                                return(-1);
                            }
                        }
                    }
                    for (int p = 0; p < x.Count; p++)
                    {
                        int xPropertyIndex = properties.FindIndex(e => e.name == x[p].name);
                        int yPropertyIndex = properties.FindIndex(e => e.name == y[p].name);
                        if (xPropertyIndex > yPropertyIndex)
                        {
                            return(1);
                        }
                        else if (xPropertyIndex < yPropertyIndex)
                        {
                            return(-1);
                        }
                    }
                    return(0);
                }
                else
                {
                    return(0);
                }
            });

            return(combos);
        }
        override public List <List <Property> > ApplySpecialProperties(ModelGroup test, List <List <Property> > combos)
        {
            // TextCoord0 is used everywhere a base color texture is used, so include it in everything except the empty set
            var vertexUV0 = properties.Find(e => e.name == Propertyname.VertexUV0_Float);

            foreach (var y in combos)
            {
                // Checks if the property is already in that combo
                if ((y.Find(e => ReadmeStringHelper.GenerateNameWithSpaces(e.name.ToString()) ==
                            ReadmeStringHelper.GenerateNameWithSpaces(vertexUV0.name.ToString()))) == null)
                {
                    // If there are already values in the combo, just add this new property
                    // Otherwise skip the empty set
                    if (y.Count > 0)
                    {
                        y.Insert(0, vertexUV0);
                    }
                }
            }

            // Sort the combos by complexity
            combos.Sort(delegate(List <Property> x, List <Property> y)
            {
                if (x.Count == 0)
                {
                    return(-1);              // Empty Set
                }
                else if (y.Count == 0)
                {
                    return(1);                   // Empty Set
                }
                else if (x.Count > y.Count)
                {
                    return(1);
                }
                else if (x.Count < y.Count)
                {
                    return(-1);
                }
                else if (x.Count == y.Count)
                {
                    // Tie goes to the combo with the left-most property on the table
                    for (int p = 0; p < x.Count; p++)
                    {
                        if (x[p].propertyGroup != y[p].propertyGroup ||
                            x[p].propertyGroup == 0)
                        {
                            int xPropertyIndex = properties.FindIndex(e => e.name == x[p].name);
                            int yPropertyIndex = properties.FindIndex(e => e.name == y[p].name);
                            if (xPropertyIndex > yPropertyIndex)
                            {
                                return(1);
                            }
                            else if (xPropertyIndex < yPropertyIndex)
                            {
                                return(-1);
                            }
                        }
                    }
                    for (int p = 0; p < x.Count; p++)
                    {
                        int xPropertyIndex = properties.FindIndex(e => e.name == x[p].name);
                        int yPropertyIndex = properties.FindIndex(e => e.name == y[p].name);
                        if (xPropertyIndex > yPropertyIndex)
                        {
                            return(1);
                        }
                        else if (xPropertyIndex < yPropertyIndex)
                        {
                            return(-1);
                        }
                    }
                    return(0);
                }
                else
                {
                    return(0);
                }
            });

            combos.RemoveAt(0); // Remove the empty set combo

            return(combos);
        }