protected override void OnEval(FilterContext filterContext, RenderTexture source, RenderTexture dest)
{
var mat = Material;
Vector4 smoothWeights = new Vector4(
Mathf.Clamp01(1.0f - Mathf.Abs(m_Direction)), // centered
Mathf.Clamp01(-m_Direction), // min
Mathf.Clamp01(m_Direction), // max
0);
mat.SetVector("_SmoothWeights", smoothWeights);
mat.SetInt("_KernelSize", Mathf.Max(1, m_Amount)); // kernel size
// Two pass blur (first horizontal, then vertical)
var tmpRT = RTUtils.GetTempHandle(dest.descriptor);
tmpRT.RT.wrapMode = TextureWrapMode.Clamp;
mat.SetVector("_BlurDirection", Vector2.right);
Graphics.Blit(source, tmpRT, mat);
mat.SetVector("_BlurDirection", Vector2.up);
Graphics.Blit(tmpRT, dest, mat);
RTUtils.Release(tmpRT);
}
protected override void OnDrawGUI(Rect rect, FilterContext filterContext)
{
//Calculate dimensions
float epsilonLabelWidth = GUI.skin.label.CalcSize(epsilonLabel).x;
float modeLabelWidth = GUI.skin.label.CalcSize(modeLabel).x;
float strengthLabelWidth = GUI.skin.label.CalcSize(strengthLabel).x;
float curveLabelWidth = GUI.skin.label.CalcSize(curveLabel).x;
float labelWidth = Mathf.Max(Mathf.Max(Mathf.Max(modeLabelWidth, epsilonLabelWidth), strengthLabelWidth), curveLabelWidth) + 4.0f;
//Strength Slider
Rect strengthLabelRect = new Rect(rect.x, rect.y, labelWidth, EditorGUIUtility.singleLineHeight);
EditorGUI.LabelField(strengthLabelRect, strengthLabel);
Rect strengthSliderRect = new Rect(strengthLabelRect.xMax, strengthLabelRect.y, rect.width - labelWidth, strengthLabelRect.height);
m_FilterStrength = EditorGUI.Slider(strengthSliderRect, m_FilterStrength, 0.0f, 1.0f);
//Epsilon (kernel size) Slider
Rect epsilonLabelRect = new Rect(rect.x, strengthSliderRect.yMax, labelWidth, EditorGUIUtility.singleLineHeight);
EditorGUI.LabelField(epsilonLabelRect, epsilonLabel);
Rect epsilonSliderRect = new Rect(epsilonLabelRect.xMax, epsilonLabelRect.y, rect.width - labelWidth, epsilonLabelRect.height);
m_Epsilon = EditorGUI.Slider(epsilonSliderRect, m_Epsilon, 1.0f, 20.0f);
//Value Remap Curve
Rect curveLabelRect = new Rect(rect.x, epsilonSliderRect.yMax, labelWidth, EditorGUIUtility.singleLineHeight);
EditorGUI.LabelField(curveLabelRect, curveLabel);
Rect curveRect = new Rect(curveLabelRect.xMax, curveLabelRect.y, rect.width - labelWidth, curveLabelRect.height);
EditorGUI.BeginChangeCheck();
m_RemapCurve = EditorGUI.CurveField(curveRect, m_RemapCurve);
if (EditorGUI.EndChangeCheck())
{
var tex = GetRemapTexture();
Utility.AnimationCurveToRenderTexture(m_RemapCurve, ref tex);
}
}
/// <summary>
/// Returns a brush transform that can only be used for its size.
/// </summary>
/// <param name="fc">filter context for brush size & rotation</param>
/// <returns></returns>
internal static BrushTransform GetBrushTransform(FilterContext fc)
{
return(GetBrushTransform(fc.brushRotation, fc.brushSize));
}
protected override void OnDrawGUI(Rect rect, FilterContext filterContext)
{
value = EditorGUI.FloatField(rect, value);
}
protected override void OnEval(FilterContext fc, RenderTexture sourceRenderTexture, RenderTexture destinationRenderTexture)
{
FilterUtility.builtinMaterial.SetFloat("_Pow", value);
Graphics.Blit(sourceRenderTexture, destinationRenderTexture, FilterUtility.builtinMaterial, (int)FilterUtility.BuiltinPasses.Power);
}
protected override void OnEval(FilterContext filterContext, RenderTexture sourceRenderTexture, RenderTexture destinationRenderTexture)
{
Graphics.Blit(sourceRenderTexture, destinationRenderTexture, FilterUtility.builtinMaterial, (int)FilterUtility.BuiltinPasses.Negate);
}
protected override void OnDrawGUI(Rect rect, FilterContext filterContext)
{
range = EditorGUI.Vector2Field(rect, "", range);
}
/// <summary>
/// Handle SceneView related logic or rendering
/// </summary>
/// <param name="terrain">The target Terrain</param>
/// <param name="brushContext">The current brush parameters</param>
protected virtual void OnSceneGUI(SceneView sceneView, FilterContext filterContext)
{
}
protected override void OnEval(FilterContext filterContext, RenderTexture source, RenderTexture dest)
{
FilterUtility.builtinMaterial.SetFloat("_Add", value);
Graphics.Blit(source, dest, FilterUtility.builtinMaterial, (int)FilterUtility.BuiltinPasses.Add);
}
protected override void OnSceneGUI(SceneView sceneView, FilterContext filterContext)
{
Quaternion windRot = Quaternion.AngleAxis(filterContext.brushRotation, new Vector3(0.0f, 1.0f, 0.0f));
Handles.ArrowHandleCap(0, filterContext.brushPos, windRot, 0.5f * filterContext.brushSize, EventType.Repaint);
}
protected override void OnEval(FilterContext filterContext, RenderTexture source, RenderTexture dest)
{
FilterUtility.builtinMaterial.SetVector("_RemapRanges", new Vector4(m_FromRange.x, m_FromRange.y, m_ToRange.x, m_ToRange.y));
Graphics.Blit(source, dest, FilterUtility.builtinMaterial, (int)FilterUtility.BuiltinPasses.Remap);
}
/// <summary>
/// Evaluate the Filter. Override this function for custom Filter logic
/// </summary>
/// <param name="filterContext">The FilterContext related to the current evaluation</param>
/// <param name="source">The source RenderTexture on which the Filter operates</param>
/// <param name="dest">The destination RenderTexture to which the Filter blits the results of the Filter operation</param>
protected virtual void OnEval(FilterContext filterContext, RenderTexture source, RenderTexture dest)
{
Graphics.Blit(source, dest);
}
/// <summary>
/// Called before OnEval. Use this to set up anything needed before Filter evaluation and to also tell the system
/// whether or not the Filter is supported based on current hardware, the data provided by the provided
/// FilterContext, etc. Do this by returning True or False.
/// </summary>
/// <param name="filterContext">The FilterContext related to the current evaluation</param>
/// <returns>Whether or not the Filter is supported and should be evaluated. True = supported and is okay to evaluate.
/// False = the Filter is not supported with the current hardware and should be skipped</returns>
public virtual bool ValidateFilter(FilterContext filterContext, out string message)
{
message = string.Empty;
return(true);
}
protected override void OnDrawGUI(Rect rect, FilterContext filterContext)
{
if (m_noiseSettings == null)
{
m_noiseSettings = ScriptableObject.CreateInstance <NoiseSettings>();
}
GUIContent localLabel = NoiseFilter.localLabel;
GUIContent worldLabel = NoiseFilter.worldLabel;
GUIContent heightmapLabel = NoiseFilter.heightmapLabel;
GUIContent editLabel = NoiseFilter.editLabel;
float editWith = GUI.skin.label.CalcSize(editLabel).x + 20f;
Rect editRect = new Rect(rect.xMax - editWith, rect.y, editWith, rect.height);
Rect labelRect = rect;
labelRect.width = GUI.skin.label.CalcSize(coordinateLabel).x;
Rect worldRect = labelRect;
worldRect.x = labelRect.xMax;
worldRect.width = GUI.skin.button.CalcSize(worldLabel).x + 10f;
Rect localRect = worldRect;
localRect.x = worldRect.xMax;
localRect.width = GUI.skin.button.CalcSize(localLabel).x + 10f;
Rect heightmapRect = localRect;
heightmapRect.x = localRect.xMax + 10f;
heightmapRect.width = GUI.skin.button.CalcSize(heightmapLabel).x + 10f;
if (editRect.xMin < heightmapRect.xMax + 10f)
{
worldRect.x -= labelRect.width;
localRect.x -= labelRect.width;
heightmapRect.x -= labelRect.width;
labelRect.width = 0;
}
editRect.x = Mathf.Max(editRect.x, heightmapRect.xMax + 4f);
if (editRect.xMax > rect.xMax)
{
worldLabel = NoiseFilter.worldShortLabel;
localLabel = NoiseFilter.localShortLabel;
heightmapLabel = NoiseFilter.heightmapShortLabel;
worldRect.width = GUI.skin.label.CalcSize(worldLabel).x + 10f;
localRect.width = GUI.skin.label.CalcSize(localLabel).x + 10f;
heightmapRect.width = GUI.skin.label.CalcSize(heightmapLabel).x + 10f;
localRect.x = worldRect.xMax;
heightmapRect.x = localRect.xMax + 10f;
editRect.x = rect.xMax - editWith;
}
editRect.x = Mathf.Max(heightmapRect.xMax + 4f, editRect.x);
if (editRect.xMax > rect.xMax)
{
editLabel = editShortLabel;
editRect.width = GUI.skin.label.CalcSize(editLabel).x + 10f;
}
GUI.Label(labelRect, coordinateLabel);
if (GUI.Toggle(worldRect, !m_isLocalSpace, worldLabel, GUI.skin.button))
{
m_isLocalSpace = false;
}
if (GUI.Toggle(localRect, m_isLocalSpace, localLabel, GUI.skin.button))
{
m_isLocalSpace = true;
}
m_useHeightmap = GUI.Toggle(heightmapRect, m_useHeightmap, heightmapLabel, GUI.skin.button);
m_noiseSettings.useTextureForPositions = m_useHeightmap;
if (GUI.Button(editRect, editLabel))
{
NoiseWindow wnd = NoiseWindow.Create(m_noiseSettings, m_noiseSource);
wnd.noiseEditorView.onSettingsChanged += (noise) =>
{
m_noiseSettings.Copy(noise);
};
wnd.noiseEditorView.onSourceAssetChanged += (noise) =>
{
m_noiseSource = noise;
};
wnd.onDisableCallback += () =>
{
m_window = null;
};
m_window = wnd;
}
}
protected override void OnEval(FilterContext fc, RenderTexture sourceRenderTexture, RenderTexture destinationRenderTexture)
{
FilterUtility.builtinMaterial.SetVector("_ClampRange", range);
Graphics.Blit(sourceRenderTexture, destinationRenderTexture, FilterUtility.builtinMaterial, (int)FilterUtility.BuiltinPasses.Clamp);
}
protected override void OnEval(FilterContext fc, RenderTexture sourceRenderTexture, RenderTexture destinationRenderTexture)
{
if (m_noiseSettings == null)
{
m_noiseSettings = ScriptableObject.CreateInstance <NoiseSettings>();
}
m_noiseSettings.useTextureForPositions = m_useHeightmap;
if (m_useHeightmap)
{
m_noiseSettings.positionTexture = fc.rtHandleCollection[FilterContext.Keywords.Heightmap];
}
Vector3 brushPosWS = fc.brushPos - m_lastBrushPosition;
brushPosWS.y = 0;
m_lastBrushPosition = fc.brushPos;
float brushSize = fc.brushSize;
float brushRotation = fc.brushRotation - m_lastRotation;
m_lastRotation = fc.brushRotation;
// TODO(wyatt): remove magic number and tie it into NoiseSettingsGUI preview size somehow
float previewSize = 1 / 512f;
// get proper noise material from current noise settings
NoiseSettings noiseSettings = m_noiseSettings;
Material mat = NoiseUtils.GetDefaultBlitMaterial(noiseSettings);
// setup the noise material with values in noise settings
noiseSettings.SetupMaterial(mat);
// change pos and scale so they match the noiseSettings preview
bool isWorldSpace = false == m_isLocalSpace;
brushSize = isWorldSpace ? brushSize * previewSize : 1;
brushPosWS = isWorldSpace ? brushPosWS * previewSize : Vector3.zero;
// compensate for the difference between the size of the rotated brush and the square noise RT
var brushTransform = GetBrushTransform(fc);
var scaleMultiplier = new Vector2(
1.0f / (fc.brushSize / brushTransform.GetBrushXYBounds().width),
1.0f / (fc.brushSize / brushTransform.GetBrushXYBounds().height));
Quaternion rotQ = Quaternion.AngleAxis(-brushRotation, Vector3.up);
// accumulate transformation delta
m_noiseToWorld *= Matrix4x4.TRS(brushPosWS, rotQ, Vector3.one);
mat.SetMatrix(NoiseSettings.ShaderStrings.transform, noiseSettings.trs * m_noiseToWorld * Matrix4x4.Scale(new Vector3(scaleMultiplier.x, 1.0f, scaleMultiplier.y) * brushSize));
int pass = NoiseUtils.kNumBlitPasses * NoiseLib.GetNoiseIndex(noiseSettings.domainSettings.noiseTypeName);
var desc = destinationRenderTexture.descriptor;
desc.graphicsFormat = NoiseUtils.singleChannelFormat;
desc.sRGB = false;
RTHandle rt = RTUtils.GetTempHandle(desc);
Graphics.Blit(sourceRenderTexture, rt, mat, pass);
Material blendMat = FilterUtility.blendModesMaterial;
blendMat.SetTexture("_BlendTex", rt);
Graphics.Blit(sourceRenderTexture, destinationRenderTexture, blendMat, 1);
RTUtils.Release(rt);
}
/// <summary>
/// Draw the GUI for the Filter
/// </summary>
/// <param name="rect">The Rect where the GUI should be drawn</param>
/// <param name="filterContext">The FilterContext related to the current evaluation. Use this to show different information in the Filter GUI</param>
protected virtual void OnDrawGUI(Rect rect, FilterContext filterContext)
{
}