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