/// <summary>
/// Sets up this instance of NoiseSettingsGUI with the specified SerializedObject containing an object reference
/// to a NoiseSettings instance. GUI will be drawn for this serialized NoiseSettings instance.
/// </summary>
/// <param name="serializedNoise"> A SerializedObject instance containing an object reference to a NoiseSettings object </param>
public void Init(SerializedObject serializedNoise)
{
this.serializedNoise = serializedNoise;
target = this.serializedNoise.targetObject as NoiseSettings;
// transform settings
transformSettings = this.serializedNoise.FindProperty("transformSettings");
translation = transformSettings.FindPropertyRelative("translation");
rotation = transformSettings.FindPropertyRelative("rotation");
scale = transformSettings.FindPropertyRelative("scale");
flipScaleX = transformSettings.FindPropertyRelative("flipScaleX");
flipScaleY = transformSettings.FindPropertyRelative("flipScaleY");
flipScaleZ = transformSettings.FindPropertyRelative("flipScaleZ");
// domain settings
domainSettings = this.serializedNoise.FindProperty("domainSettings");
noiseTypeName = domainSettings.FindPropertyRelative("noiseTypeName");
noiseTypeParams = domainSettings.FindPropertyRelative("noiseTypeParams");
fractalTypeName = domainSettings.FindPropertyRelative("fractalTypeName");
fractalTypeParams = domainSettings.FindPropertyRelative("fractalTypeParams");
// filter settings
// filterSettings = serializedNoise.FindProperty( "filterSettings" );
// m_filterStack = filterSettings.FindPropertyRelative( "filterStack" ).objectReferenceValue as FilterStack;
// m_serializedFilterStack = new SerializedObject( m_filterStack );
// m_filterStackView = new FilterStackView( new GUIContent( "Filters" ), m_serializedFilterStack, m_serializedFilterStack.targetObject as FilterStack );
}
private static void INTERNAL_Blit2D(NoiseSettings noise, RenderTexture dest, Material mat, int pass)
{
noise.SetupMaterial(mat);
RenderTexture tempRT = RenderTexture.GetTemporary(dest.descriptor);
RenderTexture prev = RenderTexture.active;
RenderTexture.active = tempRT;
Graphics.Blit(tempRT, mat, pass);
RenderTexture.active = dest;
// if(noise.filterSettings.filterStack != null)
// {
// noise.filterSettings.filterStack.Eval(tempRT, dest);
// }
// else
{
Graphics.Blit(tempRT, dest);
}
RenderTexture.active = prev;
RenderTexture.ReleaseTemporary(tempRT);
}
/// <summary>
/// Copies the runtime information from a provided NoiseSettings instance.
/// </summary>
/// <param name="noiseSettings"> The NoiseSettings instance to copy from </param>
public void Copy(NoiseSettings noiseSettings)
{
transformSettings = noiseSettings.transformSettings;
domainSettings = noiseSettings.domainSettings;
// // TODO(wyatt): copy Filter Stack
// Debug.LogError("TODO(wyatt): copy filter stack");
}
/// <summary>
/// Bakes 3D noise defined by the given NoiseSettings instance into a Texture3D instance and returns
/// a reference to it.
/// </summary>
/// <param name = "noise"> An instance of NoiseSettings defining the type of noise to bake </param>
/// <param name = "width"> The width of the baked Texture3D </param>
/// <param name = "height"> The height of the baked Texture3D </param>
/// <param name = "depth"> The depth of the baked Texture3D </param>
/// <param name = "format"> The GraphicsFormat for the baked Texture3D. In most cases, you will want to use GraphicsFormat.R16_UNorm </param>
/// <param name = "flags"> TextureCreation flags for the baked Texture3D. </param>
/// <returns> A reference to the baked Texture3D instance </returns>
/// <remarks>
/// Be careful when specifying TextureCreation flags. If you specify that mipmaps should be generated for
/// a Texture3D, that will use a lot more memory than if you were generating mipmaps for a Texture2D.
/// </remarks>
public static Texture3D BakeToTexture3D(NoiseSettings noise, int width, int height, int depth,
GraphicsFormat format = GraphicsFormat.R16_UNorm,
TextureCreationFlags flags = TextureCreationFlags.None)
{
Material mat = GetDefaultBlitMaterial(noise);
if (mat == null)
{
return(null);
}
RenderTexture sliceRT = RenderTexture.GetTemporary(width, height, 0, GraphicsFormat.R16_UNorm);
Texture2D slice2D = new Texture2D(width, height, format, flags);
Color[] colors = new Color[width * height * depth];
noise.SetupMaterial(mat);
int pass = NoiseLib.GetNoiseIndex(noise);
RenderTexture.active = sliceRT;
List <Color[]> sliceColors = new List <Color[]>(depth);
for (int i = 0; i < depth; ++i)
{
float uvy = ((float)i + 0.5f) / depth;
mat.SetFloat("_UVY", uvy);
Graphics.Blit(null, sliceRT, mat, pass * kNumBlitPasses + 1);
slice2D.ReadPixels(new Rect(0, 0, width, height), 0, 0);
sliceColors.Add(slice2D.GetPixels(0, 0, width, height));
}
int pixPerSlice = width * height;
for (int sliceID = 0; sliceID < sliceColors.Count; ++sliceID)
{
for (int pixelID = 0; pixelID < sliceColors[sliceID].Length; ++pixelID)
{
int pixel = (pixPerSlice * sliceID) + pixelID;
colors[pixel] = sliceColors[sliceID][pixelID];
}
}
bool mipChain = ((int)flags & (int)TextureCreationFlags.MipChain) != 0;
Texture3D texture = new Texture3D(width, height, depth, format, flags);
texture.SetPixels(colors);
texture.Apply(mipChain);
RenderTexture.active = null;
RenderTexture.ReleaseTemporary(sliceRT);
return(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()));
}
public static void ShowWindow(NoiseSettings noise)
{
var wnd = ScriptableObject.CreateInstance <ExportNoiseWindow>();
wnd.titleContent = Styles.title;
wnd.Init(noise);
wnd.minSize = new Vector2(400f, 160f);
wnd.maxSize = new Vector2(400f, 160f);
wnd.Show();
}
/*=========================================================================
*
* Blit
* - Blit raw noise data into texture
*
* =========================================================================*/
/// <summary>
/// Blits 2D noise defined by the given NoiseSettings instance into the destination RenderTexture.
/// </summary>
/// <param name = "noise"> An instance of NoiseSettings defining the type of noise to render </param>
/// <param name = "dest"> The destination RenderTexture that the noise will be rendered into. </param>
public static void Blit2D(NoiseSettings noise, RenderTexture dest)
{
Material mat = GetDefaultBlitMaterial(noise);
if (mat == null)
{
return;
}
Blit2D(noise, dest, mat);
}
/// <summary>
/// Copies the serialized information from a provided NoiseSettings instance
/// </summary>
/// <param name="noiseSettings"> The NoiseSettings instance to copy from </param>
public void CopySerialized(NoiseSettings noiseSettings)
{
SerializedObject copy = new SerializedObject(noiseSettings);
SerializedObject _this = new SerializedObject(this);
copy.Update();
_this.Update();
_this.CopyFromSerializedProperty(copy.FindProperty("transformSettings"));
_this.CopyFromSerializedProperty(copy.FindProperty("domainSettings"));
// _this.CopyFromSerializedProperty(copy.FindProperty("m_filterSettings"));
_this.ApplyModifiedProperties();
}
/// <summary>
/// Creates a new NoiseSettings Asset in the root Assets folder. This is the function
/// accessible via the "Assets/Create/Noise Settings" MenuItem
/// </summary>
/// <returns> A reference to the newly created NoiseSettings Asset </returns>d
//[MenuItem("Assets/Create/Noise Settings")]
//public static NoiseSettings CreateAsset()
//{
// return CreateAsset("Assets/New Noise Settings.asset");
//}
/// <summary>
/// Creates a new NoiseSettings Asset at the specified Asset path
/// </summary>
/// <param name="assetPath"> The path in the AssetDatabase where the new NoiseSettings Asset should be saved </param>
/// <returns> A reference to the newly created NoiseSettings Asset </returns>
public static NoiseSettings CreateAsset(string assetPath)
{
NoiseSettings noiseSettings = ScriptableObject.CreateInstance <NoiseSettings>();
// FilterStack filterStack = ScriptableObject.CreateInstance<FilterStack>();
// filterStack.hideFlags = HideFlags.HideInInspector | HideFlags.HideInHierarchy | HideFlags.NotEditable;
// noiseSettings.filterSettings.filterStack = filterStack;
AssetDatabase.CreateAsset(noiseSettings, assetPath);
// AssetDatabase.AddObjectToAsset(filterStack, noiseSettings);
// AssetDatabase.ImportAsset( AssetDatabase.GetAssetPath( filterStack ) );
AssetDatabase.SaveAssets();
EditorGUIUtility.PingObject(noiseSettings);
return(noiseSettings);
}
/// <summary>
/// Bakes 2D noise defined by the given NoiseSettings instance into a Texture2D instance and returns
/// a reference to it.
/// </summary>
/// <param name = "noise"> An instance of NoiseSettings defining the type of noise to bake </param>
/// <param name = "width"> The width of the baked Texture2D </param>
/// <param name = "height"> The height of the baked Texture2D </param>
/// <param name = "format"> The GraphicsFormat for the baked Texture2D. In most cases, you will want to use GraphicsFormat.R16_UNorm </param>
/// <param name = "flags"> TextureCreation flags for the baked Texture2D </param>
/// <returns> A reference to the baked Texture2D instance </returns>
public static Texture2D BakeToTexture2D(NoiseSettings noise, int width, int height,
GraphicsFormat format = GraphicsFormat.R16_UNorm,
TextureCreationFlags flags = TextureCreationFlags.None)
{
RenderTexture rt = RenderTexture.GetTemporary(width, height, 0, GraphicsFormat.R16_UNorm);
Texture2D texture = new Texture2D(width, height, format, flags);
Blit2D(noise, rt);
RenderTexture.active = rt;
bool mipChain = ((int)flags & (int)TextureCreationFlags.MipChain) != 0;
texture.ReadPixels(new Rect(0, 0, width, height), 0, 0, mipChain);
RenderTexture.active = null;
RenderTexture.ReleaseTemporary(rt);
return(texture);
}
/// <summary>
/// Blits 3D noise defined by the given NoiseSettings instance into the destination RenderTexture.
/// </summary>
/// <param name = "noise"> An instance of NoiseSettings defining the type of noise to render </param>
/// <param name = "dest"> The destination RenderTexture that the noise will be rendered into. </param>
public static void Blit3D(NoiseSettings noise, RenderTexture dest)
{
throw new NotImplementedException("NoiseUtils::Blit3D: Function not implemented yet");
// Debug.Assert(dest.dimension == UnityEngine.Rendering.TextureDimension.Tex3D,
// "NoiseUtils::Blit3D: Provided RenderTexture is not a 3D texture. You have to manually create it as a volume");
// Material mat = GetDefaultBlitMaterial(noise);
// if(mat == null)
// {
// return;
// }
// int pass = NoiseLib.GetNoiseIndex(noise.domainSettings.noiseTypeName);
// RenderTexture prev = RenderTexture.active;
// Graphics.SetRenderTarget(dest, 0, CubemapFace.Unknown, kAllSlices);
// // Graphics.Blit( dest, mat, )
// RenderTexture.active = prev;
}
/// <summary>
/// Returns the global FractalType index associated with provided NoiseSettings instance
/// </summary>
/// <param name="noise"> The NoiseSettings instance </param>
public static int GetFractalIndex(NoiseSettings noise)
{
return(GetFractalIndex(noise.domainSettings.fractalTypeName));
}
/// <summary>
/// Returns the global NoiseType index associated with provided NoiseSettings instance
/// </summary>
/// <param name="noise"> The NoiseSettings instance </param>
public static int GetNoiseIndex(NoiseSettings noise)
{
return(GetNoiseIndex(noise.domainSettings.noiseTypeName));
}
/// <summary>
/// Initializes the ExportNoiseWindow instance with the given NoiseSettings instance.
/// </summary>
/// <param name = "noise"> The NoiseSettings instance to be used with this ExportNoiseWindow instance </param>
public void Init(NoiseSettings noise)
{
m_noise = noise;
}
/// <summary>
/// Sets up this instance of NoiseSettingsGUI with the specified NoiseSettings object.
/// GUI will be drawn for this NoiseSettings instance.
/// </summary>
/// <param name="noiseSettings"> The NoiseSettings instance for which GUI will be drawn </param>
public void Init(NoiseSettings noiseSettings)
{
Init(new SerializedObject(noiseSettings));
}
/// <summary>
/// Renders an interactive Noise Preview along with tooltip icons and an optional Export button that opens a new ExportNoiseWindow.
/// A background image is also rendered behind the preview that takes up the entire width of the EditorWindow currently being drawn.
/// </summary>
/// <param name = "minSize"> Minimum size for the Preview </param>
/// <param name = "showExportButton"> Whether or not to render the Export button </param>
public void DrawPreviewTexture(float minSize, ref bool isLocked)
{
// Draw label with tooltip
//GUILayout.Label( Styles.noisePreview );
float padding = 4f;
float iconWidth = 40f;
int size = (int)Mathf.Min(minSize, EditorGUIUtility.currentViewWidth);
Rect currentRect = rect;
currentRect.y += EditorGUIUtility.singleLineHeight * 2f;
Rect totalRect = new Rect(currentRect.x, currentRect.y, currentRect.width, size); //GUILayoutUtility.GetRect(EditorGUIUtility.currentViewWidth, size + padding * 2); // extra pixels for highlight border
Color prev = GUI.color;
GUI.color = new Color(.1f, .1f, .1f, 1f);
GUI.DrawTexture(totalRect, Texture2D.whiteTexture, ScaleMode.StretchToFill, false);
GUI.color = Color.white;
// draw info icon
// if(totalRect.Contains(Event.current.mousePosition))
{
Rect infoIconRect = new Rect(totalRect.x + padding, totalRect.y + padding, iconWidth, iconWidth);
GUI.Label(infoIconRect, Styles.infoIcon);
// GUI.Label( infoIconRect, Styles.noiseTooltip );
}
float buttonWidth = GUI.skin.button.CalcSize(Styles.buttonUnlocked).x;
float buttonHeight = EditorGUIUtility.singleLineHeight;
Rect lockButtonRect = new Rect(totalRect.x + padding, totalRect.y + padding * 2f + GUI.skin.button.CalcSize(Styles.infoIcon).y, buttonWidth, buttonHeight);
if (isLocked)
{
if (GUI.Button(lockButtonRect, Styles.buttonLocked))
{
isLocked = false;
}
}
else
{
if (GUI.Button(lockButtonRect, Styles.buttonUnlocked))
{
isLocked = true;
}
}
m_noisePreviewIsLocked = isLocked;
// draw export button
//Rect exportRect = new Rect( totalRect.xMax - buttonWidth - padding, totalRect.yMax - buttonHeight - padding, buttonWidth, buttonHeight );
//if(GUI.Button(exportRect, Styles.export))
//{
// serializedNoise.ApplyModifiedProperties();
// serializedNoise.Update();
// ExportNoiseWindow.ShowWindow( serializedNoise.targetObject as NoiseSettings );
//}
float safeSpace = Mathf.Max(iconWidth * 2, buttonWidth * 2) + padding * 4;
float minWidth = Mathf.Min(size, totalRect.width - safeSpace);
Rect previewRect = new Rect(totalRect.x + totalRect.width / 2 - minWidth / 2, totalRect.y + totalRect.height / 2 - minWidth / 2, minWidth, minWidth);
EditorGUIUtility.AddCursorRect(previewRect, MouseCursor.Pan);
if (previewRect.Contains(Event.current.mousePosition) && !isLocked)
{
serializedNoise.Update();
HandlePreviewTextureInput(previewRect);
serializedNoise.ApplyModifiedProperties();
}
if (Event.current.type == EventType.Repaint)
{
// create preview RT here and keep until the next Repaint
if (m_previewRT != null)
{
RenderTexture.ReleaseTemporary(m_previewRT);
}
NoiseSettings noiseSettings = serializedNoise.targetObject as NoiseSettings;
m_previewRT = RenderTexture.GetTemporary(512, 512, 0, RenderTextureFormat.ARGB32);
RenderTexture tempRT = RenderTexture.GetTemporary(512, 512, 0, RenderTextureFormat.RFloat);
RenderTexture prevActive = RenderTexture.active;
NoiseUtils.Blit2D(noiseSettings, tempRT);
NoiseUtils.BlitPreview2D(tempRT, m_previewRT);
RenderTexture.active = prevActive;
GUI.DrawTexture(previewRect, m_previewRT, ScaleMode.ScaleToFit, false);
RenderTexture.ReleaseTemporary(tempRT);
}
GUI.color = prev;
}
/// <summary>
/// Blits 2D noise defined by the given NoiseSettings instance into the destination RenderTexture
/// using the provided Material.
/// </summary>
/// <param name = "noise"> An instance of NoiseSettings defining the type of noise to render </param>
/// <param name = "dest"> The destination RenderTexture that the noise will be rendered into. </param>
/// <param name = "mat"> The Material to be used for rendering the noise </param>
public static void Blit2D(NoiseSettings noise, RenderTexture dest, Material mat)
{
int pass = NoiseLib.GetNoiseIndex(noise.domainSettings.noiseTypeName);
INTERNAL_Blit2D(noise, dest, mat, pass * kNumBlitPasses + 0);
}
