/// <summary> /// Sets up the provided Material to be used with this NoiseSettings instance. Some assumptions are made /// here as far as definitions and variable declarations in the Material's Shader go. /// float4 _NoiseTranslation, float4 _NoiseRotation, float4 _NoiseScale, and float4x4 _NoiseTransform are /// assumed to be declared. Sets up the Material using the NoiseType and FractalType SetupMaterial /// functions. /// </summary> /// <param name="mat"> The Material to set up for use with this NoiseSettings instance </param> public void SetupMaterial(Material mat) { INoiseType noiseType = NoiseLib.GetNoiseTypeInstance(domainSettings.noiseTypeName); IFractalType fractalType = NoiseLib.GetFractalTypeInstance(domainSettings.fractalTypeName); // set individual transform info mat.SetVector(ShaderStrings.translation, transformSettings.translation); mat.SetVector(ShaderStrings.rotation, transformSettings.rotation); mat.SetVector(ShaderStrings.scale, transformSettings.scale); // set full transform matrix mat.SetMatrix(ShaderStrings.transform, trs); noiseType?.SetupMaterial(mat, domainSettings.noiseTypeParams); fractalType?.SetupMaterial(mat, domainSettings.fractalTypeParams); if (useTextureForPositions) { mat.EnableKeyword("USE_NOISE_TEXTURE"); mat.SetTexture("_NoiseTex", positionTexture); } else { mat.DisableKeyword("USE_NOISE_TEXTURE"); } }
/// <summary> /// Returns a Material reference to the default blit material for the given NoiseSettings object. /// </summary> /// <remarks> /// Internally, this uses noise.domainSettings.fractalTypeName to get it's FractalType /// </remarks> /// <returns> A reference to the default blit Material for the specified NoiseSettings instance </returns> public static Material GetDefaultBlitMaterial(NoiseSettings noise) { IFractalType fractal = NoiseLib.GetFractalTypeInstance(noise.domainSettings.fractalTypeName); if (fractal == null) { return(null); } return(GetDefaultBlitMaterial(fractal.GetType())); }
private void DomainSettingsGUI() { noiseTypeName.stringValue = NoiseLib.NoiseTypePopup(Styles.noiseType, noiseTypeName.stringValue); INoiseType noiseType = NoiseLib.GetNoiseTypeInstance(noiseTypeName.stringValue); noiseTypeParams.stringValue = noiseType?.DoGUI(noiseTypeParams.stringValue); fractalTypeName.stringValue = NoiseLib.FractalTypePopup(Styles.fractalType, fractalTypeName.stringValue); IFractalType fractalType = NoiseLib.GetFractalTypeInstance(fractalTypeName.stringValue); fractalTypeParams.stringValue = fractalType?.DoGUI(fractalTypeParams.stringValue); }
/// <summary> /// Sets up the provided Material to be used with this NoiseSettings instance. Some assumptions are made /// here as far as definitions and variable declarations in the Material's Shader go. /// float4 _NoiseTranslation, float4 _NoiseRotation, float4 _NoiseScale, and float4x4 _NoiseTransform are /// assumed to be declared. Sets up the Material using the NoiseType and FractalType SetupMaterial /// functions. /// </summary> /// <param name="mat"> The Material to set up for use with this NoiseSettings instance </param> public void SetupMaterial(Material mat) { INoiseType noiseType = NoiseLib.GetNoiseTypeInstance(domainSettings.noiseTypeName); IFractalType fractalType = NoiseLib.GetFractalTypeInstance(domainSettings.fractalTypeName); // set individual transform info mat.SetVector(ShaderStrings.translation, transformSettings.translation); mat.SetVector(ShaderStrings.rotation, transformSettings.rotation); mat.SetVector(ShaderStrings.scale, transformSettings.scale); // set full transform matrix mat.SetMatrix(ShaderStrings.transform, trs); noiseType?.SetupMaterial(mat, domainSettings.noiseTypeParams); fractalType?.SetupMaterial(mat, domainSettings.fractalTypeParams); }
/// <summary> /// Returns the Singleton instance for the specified FractalType /// </summary> /// <param name="t"> The Type for the FractalType implementation </param> public static IFractalType GetFractalTypeInstance(Type t) { IFractalType[] instances = s_fractalTypes; for (int i = 0; i < instances.Length; ++i) { IFractalType fractalType = instances[i]; if (fractalType.GetType() == t) { return(instances[i]); } } return(null); }
private static void GatherFractalTypes() { List <IFractalType> instances = new List <IFractalType>(); List <string> names = new List <string>(); List <Type> types = new List <Type>(); foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies()) { Type[] assemblyTypes = null; try { assemblyTypes = asm.GetTypes(); } catch (Exception) { Debug.Log("NoiseLib::GatherFractalTypes: Failed to get types from assembly: " + asm); assemblyTypes = null; } if (assemblyTypes != null) { types.AddRange(GetSubclassesOfGenericType(assemblyTypes, typeof(FractalType <>))); } } foreach (Type t in types) { PropertyInfo propertyInfo = t.GetProperty("instance", s_bindingFlags); MethodInfo methodInfo = propertyInfo.GetGetMethod(); IFractalType instance = (IFractalType)methodInfo.Invoke(null, null); FractalTypeDescriptor desc = instance.GetDescription(); if (string.IsNullOrEmpty(desc.name)) { Debug.LogError("FractalType name cannot be null or empty! Skipping fractal type: " + desc.name); continue; } instances.Add(instance); names.Add(desc.name); } s_fractalTypes = instances.ToArray(); s_fractalNames = names.ToArray(); }
public GeneratedShaderInfo(IFractalType fractalType, INoiseType noiseType) { this.fractalDesc = fractalType.GetDescription(); this.noiseDesc = noiseType.GetDescription(); this.noiseIncludeStr = string.Format("#include \"{0}\"", noiseDesc.sourcePath); if (!string.IsNullOrEmpty(fractalDesc.name)) { this.variantName = string.Format("{0}{1}", fractalDesc.name, noiseDesc.name); } else { this.variantName = noiseDesc.name; } // set the path of the generated file. this will be used when writing the file // to disk and when adding the include in any generated shaders that use this // fractal and noise type variant this.generatedIncludePath = string.Format("{0}/{1}/{2}.hlsl", noiseDesc.outputDir, fractalDesc.name, noiseDesc.name); this.outputDir = string.Format("{0}/{1}", noiseDesc.outputDir, fractalDesc.name); fractalStructName = string.Format("{0}FractalInput", fractalDesc.name); noiseStructName = string.Format("{0}NoiseInput", noiseDesc.name); numFractalInputs = fractalDesc.inputStructDefinition == null ? 0 : fractalDesc.inputStructDefinition.Count; numNoiseInputs = noiseDesc.inputStructDefinition == null ? 0 : noiseDesc.inputStructDefinition.Count; fractalParamStr = null; noiseParamStr = null; functionInputStr = ""; // construct include paths string additionalIncludePaths = "\n"; for (int i = 0; i < fractalDesc.additionalIncludePaths.Count; ++i) { additionalIncludePaths += $"#include \"{ fractalDesc.additionalIncludePaths[ i ] }\"\n"; } additionalIncludePaths += "\n"; // generate the string for the fractal type structure as it would appear as a parameter // in an HLSL function declaration if (numFractalInputs > 0) { fractalParamStr = string.Format("{0} {1}", fractalStructName, "fractalInput"); } // generate the string for the noise type structure as it would appear as a parameter // in an HLSL function declaration if (numNoiseInputs > 0) { noiseParamStr = string.Format("{0} {1}", noiseStructName, "noiseInput"); } // generate the argument string for an HLSL function declaration that would be // using this combination of noise and fractal type structure definitions functionParamStr = ""; if (fractalParamStr != null) { functionParamStr += fractalParamStr; functionInputStr += "fractalInput"; } if (fractalParamStr != null && noiseParamStr != null) { functionParamStr += ", "; functionInputStr += ", "; } if (noiseParamStr != null) { functionParamStr += noiseParamStr; functionInputStr += "noiseInput"; } fractalStructDef = ""; if (numFractalInputs > 0) { fractalStructDef = NoiseLib.BuildStructString(fractalStructName, fractalDesc.inputStructDefinition); string getDefaultFuncStr = NoiseLib.GetDefaultFunctionString(fractalStructName, fractalDesc.inputStructDefinition); fractalStructDef += $"\n\n{ getDefaultFuncStr }\n\n"; } noiseStructDef = ""; if (numNoiseInputs > 0) { noiseStructDef = NoiseLib.BuildStructString(noiseStructName, noiseDesc.inputStructDefinition); } // get input str construction getInputsStr = ""; getFractalInputStr = NoiseLib.GetInputFunctionCallString(fractalStructName); getNoiseInputStr = NoiseLib.GetInputFunctionCallString(fractalStructName); if (numFractalInputs > 0) { getInputsStr += getFractalInputStr; } if (numFractalInputs > 0 && numNoiseInputs > 0) { getInputsStr += ", "; } if (numNoiseInputs > 0) { getInputsStr += getNoiseInputStr; } // get default input str construction getDefaultInputsStr = ""; getDefaultFractalInputStr = NoiseLib.GetDefaultInputFunctionCallString(fractalStructName); getDefaultNoiseInputStr = NoiseLib.GetDefaultInputFunctionCallString(noiseStructName); if (numFractalInputs > 0) { getDefaultInputsStr += getDefaultFractalInputStr; } if (numFractalInputs > 0 && numNoiseInputs > 0) { getDefaultInputsStr += ", "; } if (numNoiseInputs > 0) { getDefaultInputsStr += getDefaultNoiseInputStr; } fractalPropertyDefStr = ""; if (fractalDesc.inputStructDefinition != null && fractalDesc.inputStructDefinition.Count > 0) { fractalPropertyDefStr = NoiseLib.GetPropertyDefinitionStr(fractalDesc.name, fractalDesc.inputStructDefinition); fractalPropertyDefStr += "\n" + NoiseLib.GetPropertyFunctionStr(fractalStructName, fractalDesc.name, fractalDesc.inputStructDefinition); } }
/*========================================================================================== * * Generate HLSL * * ==========================================================================================*/ /// <summary> /// Forces generation of the NoiseType and FractalType variant HLSL header files /// </summary> public static void GenerateHeaderFiles() { System.Globalization.CultureInfo prevCultureInfo = System.Threading.Thread.CurrentThread.CurrentCulture; System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture; GatherNoiseTypes(); GatherFractalTypes(); INoiseType[] noiseTypes = s_noiseTypes; IFractalType[] fractalTypes = s_fractalTypes; string[] fractalContents = LoadFractalSource(fractalTypes); string[] noiseContents = LoadNoiseSource(noiseTypes); for (int f = 0; f < fractalTypes.Length; ++f) { string fractalStr = fractalContents[f]; // dont generate for this fractal type if the source could not be found if (fractalStr == null) { continue; } IFractalType fractal = fractalTypes[f]; for (int n = 0; n < noiseTypes.Length; ++n) { string noiseStr = noiseContents[n]; // dont generate for this noise type if the source could not be found if (noiseStr == null) { continue; } INoiseType noise = noiseTypes[n]; GeneratedShaderInfo info = new GeneratedShaderInfo(fractal, noise); StringBuilder sb = new StringBuilder(); sb.Append(Strings.k_warningHeader); // add the DO NOT EDIT warning sb.Append(fractalStr); // add the fractal template info.ReplaceTags(sb); string newContents = sb.ToString(); // do some code cleanup newContents = Regex.Replace(newContents, Strings.k_regexDupCommas, ", "); newContents = Regex.Replace(newContents, Strings.k_emptyArgsRight, " )"); newContents = Regex.Replace(newContents, Strings.k_emptyArgsLeft, "( "); newContents = NormalizeLineEndings(newContents); string outputDir = info.outputDir; // TODO(wyatt): need to verify this is actually a directory and not a file if (!Directory.Exists(outputDir)) { Directory.CreateDirectory(outputDir); } string oldContents = null; FileInfo fi = new FileInfo(info.generatedIncludePath); if (File.Exists(info.generatedIncludePath)) { using (StreamReader sr = new StreamReader(info.generatedIncludePath)) { oldContents = sr.ReadToEnd(); oldContents = NormalizeLineEndings(oldContents); } } if (!fi.IsReadOnly) { if (oldContents == null || newContents.CompareTo(oldContents) != 0) { try { using (StreamWriter sw = new StreamWriter(info.generatedIncludePath)) { sw.Write(newContents); } } catch (Exception) { // restore previous cultureinfo System.Threading.Thread.CurrentThread.CurrentCulture = prevCultureInfo; } } } } } // restore previous cultureinfo System.Threading.Thread.CurrentThread.CurrentCulture = prevCultureInfo; //UnityEditor.AssetDatabase.Refresh(); }
private TerrainToolsAnalytics.IBrushParameter[] UpdateAnalyticParameters() { m_AnalyticsData.Clear(); SerializedProperty transformSettings = noiseSettingsGUI.serializedNoise.FindProperty("transformSettings"); SerializedProperty domainSettings = noiseSettingsGUI.serializedNoise.FindProperty("domainSettings"); SerializedProperty fractalTypeName = domainSettings.FindPropertyRelative("fractalTypeName"); SerializedProperty fractalTypeParams = domainSettings.FindPropertyRelative("fractalTypeParams"); //Add Generic, Transform, and Domain type settings to be sent as analytic data m_AnalyticsData.AddRange(new TerrainToolsAnalytics.IBrushParameter[] { //Generic Settings new TerrainToolsAnalytics.BrushParameter <string> { Name = Styles.coordSpace.text, Value = m_toolSettings.coordSpace.ToString() }, //Transform Settings new TerrainToolsAnalytics.BrushParameter <Vector3> { Name = "Translation", Value = transformSettings.FindPropertyRelative("translation").vector3Value }, new TerrainToolsAnalytics.BrushParameter <Vector3> { Name = "Rotation", Value = transformSettings.FindPropertyRelative("rotation").vector3Value }, new TerrainToolsAnalytics.BrushParameter <Vector3> { Name = "Scale", Value = transformSettings.FindPropertyRelative("scale").vector3Value }, new TerrainToolsAnalytics.BrushParameter <bool> { Name = NoiseSettingsGUI.Styles.flipScaleX.text, Value = transformSettings.FindPropertyRelative("flipScaleX").boolValue }, new TerrainToolsAnalytics.BrushParameter <bool> { Name = NoiseSettingsGUI.Styles.flipScaleY.text, Value = transformSettings.FindPropertyRelative("flipScaleY").boolValue }, new TerrainToolsAnalytics.BrushParameter <bool> { Name = NoiseSettingsGUI.Styles.flipScaleZ.text, Value = transformSettings.FindPropertyRelative("flipScaleZ").boolValue }, //Domain new TerrainToolsAnalytics.BrushParameter <string> { Name = NoiseSettingsGUI.Styles.noiseType.text, Value = domainSettings.FindPropertyRelative("noiseTypeName").stringValue }, new TerrainToolsAnalytics.BrushParameter <string> { Name = NoiseSettingsGUI.Styles.fractalType.text, Value = domainSettings.FindPropertyRelative("fractalTypeName").stringValue } } ); //Add fractal specific settings to be sent as analytic data IFractalType fractalType = NoiseLib.GetFractalTypeInstance(fractalTypeName.stringValue); switch (domainSettings.FindPropertyRelative("fractalTypeName").stringValue) { case "Fbm": FbmFractalType.FbmFractalInput fbmFractalSettings = (FbmFractalType.FbmFractalInput)fractalType.FromSerializedString(fractalTypeParams.stringValue); m_AnalyticsData.AddRange(new TerrainToolsAnalytics.IBrushParameter[] { new TerrainToolsAnalytics.BrushParameter <float> { Name = FbmFractalType.Styles.octaves.text, Value = fbmFractalSettings.octaves }, new TerrainToolsAnalytics.BrushParameter <float> { Name = FbmFractalType.Styles.amplitude.text, Value = fbmFractalSettings.amplitude }, new TerrainToolsAnalytics.BrushParameter <float> { Name = FbmFractalType.Styles.persistence.text, Value = fbmFractalSettings.persistence }, new TerrainToolsAnalytics.BrushParameter <float> { Name = FbmFractalType.Styles.frequency.text, Value = fbmFractalSettings.frequency }, new TerrainToolsAnalytics.BrushParameter <float> { Name = FbmFractalType.Styles.lacunarity.text, Value = fbmFractalSettings.lacunarity }, new TerrainToolsAnalytics.BrushParameter <bool> { Name = FbmFractalType.Styles.domainWarpSettings.text, Value = fbmFractalSettings.warpEnabled }, new TerrainToolsAnalytics.BrushParameter <float> { Name = FbmFractalType.Styles.warpIterations.text, Value = fbmFractalSettings.warpIterations }, new TerrainToolsAnalytics.BrushParameter <float> { Name = FbmFractalType.Styles.warpStrength.text, Value = fbmFractalSettings.warpStrength }, new TerrainToolsAnalytics.BrushParameter <Vector4> { Name = FbmFractalType.Styles.warpOffsets.text, Value = fbmFractalSettings.warpOffsets }, }); break; case "Strata": StrataFractalType.StrataFractalInput strataFractalSettings = (StrataFractalType.StrataFractalInput)fractalType.FromSerializedString(fractalTypeParams.stringValue); m_AnalyticsData.AddRange(new TerrainToolsAnalytics.IBrushParameter[] { new TerrainToolsAnalytics.BrushParameter <float> { Name = StrataFractalType.Styles.octaves.text, Value = strataFractalSettings.octaves }, new TerrainToolsAnalytics.BrushParameter <float> { Name = StrataFractalType.Styles.amplitude.text, Value = strataFractalSettings.amplitude }, new TerrainToolsAnalytics.BrushParameter <float> { Name = StrataFractalType.Styles.persistence.text, Value = strataFractalSettings.persistence }, new TerrainToolsAnalytics.BrushParameter <float> { Name = StrataFractalType.Styles.frequency.text, Value = strataFractalSettings.frequency }, new TerrainToolsAnalytics.BrushParameter <float> { Name = StrataFractalType.Styles.lacunarity.text, Value = strataFractalSettings.lacunarity }, new TerrainToolsAnalytics.BrushParameter <bool> { Name = StrataFractalType.Styles.domainWarpSettings.text, Value = strataFractalSettings.warpEnabled }, new TerrainToolsAnalytics.BrushParameter <float> { Name = StrataFractalType.Styles.warpIterations.text, Value = strataFractalSettings.warpIterations }, new TerrainToolsAnalytics.BrushParameter <float> { Name = StrataFractalType.Styles.warpStrength.text, Value = strataFractalSettings.warpStrength }, new TerrainToolsAnalytics.BrushParameter <Vector4> { Name = StrataFractalType.Styles.warpOffsets.text, Value = strataFractalSettings.warpOffsets }, new TerrainToolsAnalytics.BrushParameter <float> { Name = StrataFractalType.Styles.strataOffset.text, Value = strataFractalSettings.strataOffset }, new TerrainToolsAnalytics.BrushParameter <float> { Name = StrataFractalType.Styles.strataScale.text, Value = strataFractalSettings.strataScale }, }); break; case "None": default: break; } return(m_AnalyticsData.ToArray()); }