public static void RandomizeSubMatInst(ExportEntry childMat, Dictionary <string, CFVector4> vectorValues, Dictionary <string, float> scalarValues)
        {
            // VECTOR PARAMETERS
            //Debug.WriteLine($"Randomizing matinst {childMat.InstancedFullPath}");
            var vectorParameterValues = VectorParameter.GetVectorParameters(childMat);

            if (vectorParameterValues != null)
            {
                foreach (var vpv in vectorParameterValues)
                {
                    CFVector4 color;
                    if (!vectorValues.TryGetValue(vpv.ParameterName, out color))
                    {
                        color = vpv.ParameterValue;
                        RStructs.RandomizeTint(color, false);
                        vectorValues[vpv.ParameterName] = color;
                    }
                    else
                    {
                        vpv.ParameterValue = color;
                    }
                }
                //Debug.WriteLine(childMat.InstancedFullPath);
                VectorParameter.WriteVectorParameters(childMat, vectorParameterValues);
            }

            // SCALAR PARAMETERS
            var scalarParameterValues = ScalarParameter.GetScalarParameters(childMat);

            if (scalarParameterValues != null)
            {
                foreach (var vpv in scalarParameterValues)
                {
                    if (!scalarValues.TryGetValue(vpv.ParameterName, out float scalarVal))
                    {
                        // Write new
                        vpv.ParameterValue *= ThreadSafeRandom.NextFloat(0.75, 1.25);
                        scalarValues[vpv.ParameterName] = vpv.ParameterValue;
                    }
                    else
                    {
                        // Write existing
                        vpv.ParameterValue = scalarVal;
                    }
                }
                //Debug.WriteLine(childMat.InstancedFullPath);
                ScalarParameter.WriteScalarParameters(childMat, scalarParameterValues);
            }
        }
Example #2
0
        List <MaterialAsset> loadMaterials()
        {
            var materials = new List <MaterialAsset>();

            if (!Directory.Exists(metadataPath + "Materials"))
            {
                Directory.CreateDirectory(metadataPath + "Materials");
            }

            foreach (var filename in Directory.EnumerateFiles(metadataPath + "Materials"))
            {
                var metadata = File.ReadAllLines(filename);

                var material = new MaterialAsset();

                material.Name             = System.IO.Path.GetFileNameWithoutExtension(filename);
                material.Description      = metadata[0].Split('=')[1].Trim();
                material.LastUpdated      = parseLastUpdatedDate(metadata[1].Split('=')[1].Trim(), "material", material.Name);
                material.ImportedFilename = metadata[2].Split('=')[1].Trim();
                material.ImporterVersion  = int.Parse(metadata[3].Split('=')[1].Trim());

                var textureLine    = metadata[4].Split('=')[1].Trim();
                var textureConfigs = textureLine.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);

                foreach (var config in textureConfigs)
                {
                    var data    = config.Split(',');
                    var texture = new Texture()
                    {
                        Binding  = data[0].Trim(),
                        SourceId = data[1].Trim()
                    };

                    material.Textures.Add(texture);
                }

                for (int i = 5; i < metadata.Length; i++)
                {
                    var parameterGroupLine = metadata[i].Split('=')[1].Trim();
                    var groupConfigs       = parameterGroupLine.Split('#');

                    var parameterGroup = new ParameterGroup()
                    {
                        Name = groupConfigs[0].Trim()
                    };

                    var parameterConfigs = groupConfigs[1].Trim().Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);

                    foreach (var config in parameterConfigs)
                    {
                        var data = config.Split(',');

                        var parameterType = data[1].Trim();

                        if (parameterType == "float")
                        {
                            var parameter = new ScalarParameter <float>()
                            {
                                Name = data[0].Trim(), Value = float.Parse(data[2].Trim())
                            };
                            parameterGroup.Parameters.Add(parameter);
                        }
                        else if (parameterType == "int")
                        {
                            var parameter = new ScalarParameter <int>()
                            {
                                Name = data[0].Trim(), Value = int.Parse(data[2].Trim())
                            };
                            parameterGroup.Parameters.Add(parameter);
                        }
                        else if (parameterType == "bool")
                        {
                            var parameter = new ScalarParameter <bool>()
                            {
                                Name = data[0].Trim(), Value = bool.Parse(data[2].Trim())
                            };
                            parameterGroup.Parameters.Add(parameter);
                        }
                        else if (parameterType == "float2")
                        {
                            var parameter = parseVector2 <float>(data[0].Trim(), data[2]);
                            parameterGroup.Parameters.Add(parameter);
                        }
                        else if (parameterType == "int2")
                        {
                            var parameter = parseVector2 <int>(data[0].Trim(), data[2]);
                            parameterGroup.Parameters.Add(parameter);
                        }
                        else if (parameterType == "bool2")
                        {
                            var parameter = parseVector2 <bool>(data[0].Trim(), data[2]);
                            parameterGroup.Parameters.Add(parameter);
                        }
                        else if (parameterType == "float3")
                        {
                            var parameter = parseVector3 <float>(data[0].Trim(), data[2]);
                            parameterGroup.Parameters.Add(parameter);
                        }
                        else if (parameterType == "int3")
                        {
                            var parameter = parseVector3 <int>(data[0].Trim(), data[2]);
                            parameterGroup.Parameters.Add(parameter);
                        }
                        else if (parameterType == "bool3")
                        {
                            var parameter = parseVector3 <bool>(data[0].Trim(), data[2]);
                            parameterGroup.Parameters.Add(parameter);
                        }
                        else if (parameterType == "float4")
                        {
                            var parameter = parseVector4 <float>(data[0].Trim(), data[2]);
                            parameterGroup.Parameters.Add(parameter);
                        }
                        else if (parameterType == "int4")
                        {
                            var parameter = parseVector4 <int>(data[0].Trim(), data[2]);
                            parameterGroup.Parameters.Add(parameter);
                        }
                        else if (parameterType == "bool4")
                        {
                            var parameter = parseVector4 <bool>(data[0].Trim(), data[2]);
                            parameterGroup.Parameters.Add(parameter);
                        }
                        else if (parameterType == "float4 array")
                        {
                            var elements = data[2].Split('$');

                            var array = new ArrayParameter <float>();
                            array.Name = data[0].Trim();

                            foreach (var element in elements)
                            {
                                var elementData = element.Split(',');
                                var parameter   = parseVector4 <float>(elementData[0].Trim(), elementData[2]);
                                array.Elements.Add(parameter);
                            }

                            parameterGroup.Parameters.Add(array);
                        }
                        else if (parameterType == "int4 array")
                        {
                            var elements = data[2].Split('$');

                            var array = new ArrayParameter <int>();
                            array.Name = data[0].Trim();

                            foreach (var element in elements)
                            {
                                var elementData = element.Split(',');
                                var parameter   = parseVector4 <int>(elementData[0].Trim(), elementData[2]);
                                array.Elements.Add(parameter);
                            }

                            parameterGroup.Parameters.Add(array);
                        }
                        else if (parameterType == "bool4 array")
                        {
                            var elements = data[2].Split('$');

                            var array = new ArrayParameter <bool>();
                            array.Name = data[0].Trim();

                            foreach (var element in elements)
                            {
                                var elementData = element.Split(',');
                                var parameter   = parseVector4 <bool>(elementData[0].Trim(), elementData[2]);
                                array.Elements.Add(parameter);
                            }

                            parameterGroup.Parameters.Add(array);
                        }
                    }

                    material.ParameterGroups.Add(parameterGroup);
                }

                materials.Add(material);
            }

            return(materials);
        }