1241 lines
53 KiB
C#
1241 lines
53 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Runtime.Serialization.Formatters.Binary;
|
|
using System.Text;
|
|
using UnityEditor.EditorTools;
|
|
using UnityEditor.ShortcutManagement;
|
|
using UnityEngine;
|
|
using UnityEngine.Experimental.Rendering;
|
|
using UnityEditor.Overlays;
|
|
using UnityEngine.UIElements;
|
|
using Cursor = UnityEngine.Cursor;
|
|
using UnityEngine.TerrainTools;
|
|
|
|
namespace UnityEditor.TerrainTools
|
|
{
|
|
/// <summary>
|
|
/// Provides methods for altering brush data.
|
|
/// </summary>
|
|
public abstract class BaseBrushUIGroup : IBrushUIGroup, IBrushEventHandler, IBrushTerrainCache
|
|
{
|
|
private bool m_ShowBrushMaskFilters = true;
|
|
private bool m_ShowModifierControls = true;
|
|
|
|
private static readonly BrushShortcutHandler<BrushShortcutType> s_ShortcutHandler = new BrushShortcutHandler<BrushShortcutType>();
|
|
|
|
private readonly string m_Name;
|
|
private readonly HashSet<Event> m_ConsumedEvents = new HashSet<Event>();
|
|
private readonly List<IBrushController> m_Controllers = new List<IBrushController>();
|
|
|
|
private IBrushSizeController m_BrushSizeController = null;
|
|
private IBrushRotationController m_BrushRotationController = null;
|
|
private IBrushStrengthController m_BrushStrengthController = null;
|
|
private IBrushSpacingController m_BrushSpacingController = null;
|
|
private IBrushScatterController m_BrushScatterController = null;
|
|
private IBrushModifierKeyController m_BrushModifierKeyController = null;
|
|
private IBrushSmoothController m_BrushSmoothController = null;
|
|
|
|
internal bool m_HasBrushSize; // tells you which of the controllers are null or not
|
|
internal bool m_HasBrushRotation;
|
|
internal bool m_HasBrushStrength;
|
|
internal bool m_HasBrushSpacing;
|
|
internal bool m_HasBrushScatter;
|
|
|
|
[ SerializeField ]
|
|
private FilterStack m_BrushMaskFilterStack = null;
|
|
|
|
/// <summary>
|
|
/// Gets the brush mask's <see cref="FilterStack"/>.
|
|
/// </summary>
|
|
public FilterStack brushMaskFilterStack
|
|
{
|
|
get
|
|
{
|
|
if( m_BrushMaskFilterStack == null )
|
|
{
|
|
if( File.Exists( getFilterStackFilePath ) )
|
|
{
|
|
m_BrushMaskFilterStack = LoadFilterStack();
|
|
}
|
|
// If there is no filter stack or if it failed to load
|
|
if( m_BrushMaskFilterStack == null )
|
|
{
|
|
// create the first filterstack if this is the first time this tool is being used
|
|
// because a save file has not been made yet for the filterstack
|
|
m_BrushMaskFilterStack = ScriptableObject.CreateInstance< FilterStack >();
|
|
}
|
|
}
|
|
|
|
return m_BrushMaskFilterStack;
|
|
}
|
|
}
|
|
|
|
private FilterStackView m_BrushMaskFilterStackView = null;
|
|
|
|
/// <summary>
|
|
/// Gets the brush mask's <see cref="FilterStackView"/>.
|
|
/// </summary>
|
|
public FilterStackView brushMaskFilterStackView
|
|
{
|
|
get
|
|
{
|
|
// need to make the UI if the view hasnt been created yet or if the reference to the FilterStack SerializedObject has
|
|
// been lost, like when entering and exiting Play Mode
|
|
if( m_BrushMaskFilterStackView == null || m_BrushMaskFilterStackView.serializedFilterStack.targetObject == null )
|
|
{
|
|
m_BrushMaskFilterStackView = new FilterStackView(new GUIContent("Brush Mask Filters"), new SerializedObject( brushMaskFilterStack ) );
|
|
m_BrushMaskFilterStackView.FilterContext = filterContext;
|
|
m_BrushMaskFilterStackView.onChanged += SaveFilterStack;
|
|
}
|
|
|
|
return m_BrushMaskFilterStackView;
|
|
}
|
|
}
|
|
|
|
FilterContext m_FilterContext;
|
|
FilterContext filterContext
|
|
{
|
|
get
|
|
{
|
|
if (m_FilterContext != null) return m_FilterContext;
|
|
|
|
m_FilterContext = new FilterContext(FilterUtility.defaultFormat, Vector3.zero, 1f, 0f);
|
|
return m_FilterContext;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if Filters are enabled.
|
|
/// </summary>
|
|
public bool hasEnabledFilters => brushMaskFilterStack.hasEnabledFilters;
|
|
|
|
private void SetFilterContext(TerrainData terrainData, Vector3 position, float scale, float rotation)
|
|
{
|
|
// set the filter context properties
|
|
filterContext.brushPos = position;
|
|
filterContext.brushSize = scale;
|
|
filterContext.brushRotation = rotation;
|
|
|
|
// bind properties for filters to read/write to
|
|
filterContext.diffuseTextures = terrainData.terrainLayers;
|
|
filterContext.floatProperties[FilterContext.Keywords.TerrainScale] = Mathf.Sqrt(terrainData.size.x * terrainData.size.x + terrainData.size.z * terrainData.size.z);
|
|
filterContext.vectorProperties["_TerrainSize"] = new Vector4(terrainData.size.x, terrainData.size.y, terrainData.size.z, 0.0f);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generates the brush mask.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// **Note:** Using this version of the overloaded method allows for the use of the Layer Filter
|
|
/// </remarks>
|
|
/// <param name="terrain">The terrain in focus.</param>
|
|
/// <param name="brushRender">The brushRender object used for acquiring the heightmap and splatmap texture to blit from.</param>
|
|
/// <param name="destinationRenderTexture">The destination render texture for bliting to.</param>
|
|
/// <param name="position">The brush's position.</param>
|
|
/// <param name="scale">The brush's scale.</param>
|
|
/// <param name="rotation">The brush's rotation.</param>
|
|
/// <seealso cref="GenerateBrushMask(Terrain terrain, RenderTexture sourceRenderTexture, RenderTexture destinationRenderTexture, Vector3 position, float scale, float rotation)"/>
|
|
public void GenerateBrushMask(Terrain terrain, IBrushRenderUnderCursor brushRender, RenderTexture destinationRenderTexture,
|
|
Vector3 position, float scale, float rotation)
|
|
{
|
|
filterContext.ReleaseRTHandles();
|
|
|
|
FilterUtility.LayerFilterActiveState = true;
|
|
if (brushRender.CalculateBrushTransform(out BrushTransform brushTransform))
|
|
{
|
|
Rect brushRect = brushTransform.GetBrushXYBounds();
|
|
|
|
using (new ActiveRenderTextureScope(null))
|
|
{
|
|
TerrainData terrainData = terrain.terrainData;
|
|
SetFilterContext(terrainData, position, scale, rotation);
|
|
|
|
// bind terrain texture data
|
|
PaintContext heightContext = brushRender.AcquireHeightmap(false, brushRect);
|
|
filterContext.rtHandleCollection.AddRTHandle(0, FilterContext.Keywords.Heightmap, heightContext.sourceRenderTexture.graphicsFormat);
|
|
|
|
List<LayerFilter> layerFilters = brushMaskFilterStack.filters.OfType<LayerFilter>().ToList();
|
|
if(layerFilters.Count > 0)
|
|
{
|
|
// bind layer filter alphamap textures
|
|
for (int i = 0; i < layerFilters.Count; i++)
|
|
{
|
|
LayerFilter layerFilter = layerFilters[i];
|
|
if (layerFilter.layerIndex >= terrainData.terrainLayers.Length)
|
|
continue;
|
|
|
|
PaintContext paintContext = brushRender.AcquireTexture(false, brushRect, terrain.terrainData.terrainLayers[layerFilter.layerIndex]);
|
|
layerFilter.splatmapKeyword = FilterContext.Keywords.Splatmap + i;
|
|
filterContext.rtHandleCollection.AddRTHandle(1 + i, layerFilter.splatmapKeyword, paintContext.sourceRenderTexture.graphicsFormat);
|
|
brushRender.Release(paintContext);
|
|
}
|
|
filterContext.rtHandleCollection.GatherRTHandles(heightContext.sourceRenderTexture.width, heightContext.sourceRenderTexture.height);
|
|
|
|
// blit the gathered rthandles
|
|
foreach(LayerFilter layerFilter in layerFilters)
|
|
{
|
|
if (layerFilter.layerIndex >= terrainData.terrainLayers.Length)
|
|
continue;
|
|
|
|
PaintContext paintContext = brushRender.AcquireTexture(false, brushRect, terrain.terrainData.terrainLayers[layerFilter.layerIndex]);
|
|
Graphics.Blit(paintContext.sourceRenderTexture, filterContext.rtHandleCollection[layerFilter.splatmapKeyword]);
|
|
brushRender.Release(paintContext);
|
|
}
|
|
Graphics.Blit(heightContext.sourceRenderTexture, filterContext.rtHandleCollection[FilterContext.Keywords.Heightmap]);
|
|
}
|
|
else
|
|
{
|
|
filterContext.rtHandleCollection.GatherRTHandles(heightContext.sourceRenderTexture.width, heightContext.sourceRenderTexture.height);
|
|
Graphics.Blit(heightContext.sourceRenderTexture, filterContext.rtHandleCollection[FilterContext.Keywords.Heightmap]);
|
|
}
|
|
|
|
brushMaskFilterStack.Eval(filterContext, heightContext.sourceRenderTexture, destinationRenderTexture);
|
|
}
|
|
filterContext.ReleaseRTHandles();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generates the brush mask.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// **Note:** Use <see cref="GenerateBrushMask(Terrain terrain, IBrushRenderUnderCursor brushRender, RenderTexture destinationRenderTexture, Vector3 position, float scale, float rotation)"/>
|
|
/// if Layer Filtering capabilities are desired.
|
|
/// </remarks>
|
|
/// <param name="terrain">The terrain in focus.</param>
|
|
/// <param name="sourceRenderTexture">The source render texture to blit from.</param>
|
|
/// <param name="destinationRenderTexture">The destination render texture for bliting to.</param>
|
|
/// <param name="position">The brush's position.</param>
|
|
/// <param name="scale">The brush's scale.</param>
|
|
/// <param name="rotation">The brush's rotation.</param>
|
|
/// <seealso cref="GenerateBrushMask(Terrain terrain, RenderTexture sourceRenderTexture, RenderTexture destinationRenderTexture, Vector3 position, float scale, float rotation)"/>
|
|
public void GenerateBrushMask(Terrain terrain, RenderTexture sourceRenderTexture, RenderTexture destinationRenderTexture,
|
|
Vector3 position, float scale, float rotation)
|
|
{
|
|
filterContext.ReleaseRTHandles();
|
|
|
|
FilterUtility.LayerFilterActiveState = false;
|
|
using (new ActiveRenderTextureScope(null))
|
|
{
|
|
SetFilterContext(terrain.terrainData, position, scale, rotation);
|
|
|
|
// bind terrain texture data
|
|
filterContext.rtHandleCollection.AddRTHandle(0, FilterContext.Keywords.Heightmap, sourceRenderTexture.graphicsFormat);
|
|
filterContext.rtHandleCollection.GatherRTHandles(sourceRenderTexture.width, sourceRenderTexture.height);
|
|
Graphics.Blit(sourceRenderTexture, filterContext.rtHandleCollection[FilterContext.Keywords.Heightmap]);
|
|
brushMaskFilterStack.Eval(filterContext, sourceRenderTexture, destinationRenderTexture);
|
|
}
|
|
|
|
filterContext.ReleaseRTHandles();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generates the brush mask.
|
|
/// </summary>
|
|
/// <param name="terrain">The terrain in focus.</param>
|
|
/// <param name="sourceRenderTexture">The source render texture to blit from.</param>
|
|
/// <param name="destinationRenderTexture">The destination render texture for bliting to.</param>
|
|
/// <seealso cref="GenerateBrushMask(Terrain, RenderTexture, RenderTexture, Vector3, float, float)"/>
|
|
public void GenerateBrushMask(Terrain terrain, RenderTexture sourceRenderTexture, RenderTexture destinationRenderTexture)
|
|
{
|
|
GenerateBrushMask(terrain, sourceRenderTexture, destinationRenderTexture, raycastHitUnderCursor.point, brushSize, brushRotation);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generates the brush mask.
|
|
/// </summary>
|
|
/// <param name="sourceRenderTexture">The source render texture to blit from.</param>
|
|
/// <param name="destinationRenderTexture">The destination render texture for bliting to.</param>
|
|
/// <seealso cref="GenerateBrushMask(Terrain, RenderTexture, RenderTexture, Vector3, float, float)"/>
|
|
public void GenerateBrushMask(RenderTexture sourceRenderTexture, RenderTexture destinationRenderTexture)
|
|
{
|
|
GenerateBrushMask(terrainUnderCursor, sourceRenderTexture, destinationRenderTexture);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generates the brush mask.
|
|
/// </summary>
|
|
/// <param name="brushRender">The brushRender object used for acquiring the heightmap and splatmap texture to blit from.</param>
|
|
/// <param name="destinationRenderTexture">The destination render texture for bliting to.</param>
|
|
public void GenerateBrushMask(IBrushRenderUnderCursor brushRender, RenderTexture destinationRenderTexture)
|
|
{
|
|
GenerateBrushMask(terrainUnderCursor, brushRender, destinationRenderTexture, raycastHitUnderCursor.point, brushSize, brushRotation);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the brush name.
|
|
/// </summary>
|
|
public string brushName => m_Name;
|
|
|
|
/// <summary>
|
|
/// Does the commonUI have a size controller?
|
|
/// </summary>
|
|
public bool hasBrushSize => m_HasBrushSize;
|
|
|
|
/// <summary>
|
|
/// Does the commonUI have a rotation controller?
|
|
/// </summary>
|
|
public bool hasBrushRotation => m_HasBrushRotation;
|
|
|
|
/// <summary>
|
|
/// Does the commonUI have a strength controller?
|
|
/// </summary>
|
|
public bool hasBrushStrength => m_HasBrushStrength;
|
|
|
|
/// <summary>
|
|
/// Does the commonUI have a spacing controller?
|
|
/// </summary>
|
|
public bool hasBrushSpacing => m_HasBrushSpacing;
|
|
|
|
/// <summary>
|
|
/// Does the commonUI have a scatter controller?
|
|
/// </summary>
|
|
public bool hasBrushScatter => m_HasBrushScatter;
|
|
|
|
/// <summary>
|
|
/// Gets and sets the brush size.
|
|
/// </summary>
|
|
/// <remarks>Gets a value of 100 if the brush size controller isn't initialized.</remarks>
|
|
public float brushSize
|
|
{
|
|
get { return m_BrushSizeController?.brushSize ?? 100.0f; }
|
|
set { m_BrushSizeController.brushSize = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The size of the brush without jitter.
|
|
/// </summary>
|
|
/// <remarks>Gets a value of 100 if the brush size controller isn't initialized.</remarks>
|
|
public float brushSizeVal
|
|
{
|
|
get { return m_BrushSizeController?.brushSizeVal ?? 100.0f; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets and sets the brush min size.
|
|
/// </summary>
|
|
/// <remarks>Gets a value of 0 if the brush size controller isn't initialized.</remarks>
|
|
public float brushSizeMin
|
|
{
|
|
get { return m_BrushSizeController?.brushSizeMin ?? 0.0f; }
|
|
set { m_BrushSizeController.brushSizeMin = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets and sets the brush max size.
|
|
/// </summary>
|
|
/// <remarks>Gets a value of 1 if the brush size controller isn't initialized.</remarks>
|
|
public float brushSizeMax
|
|
{
|
|
get { return m_BrushSizeController?.brushSizeMax ?? 1.0f; }
|
|
set { m_BrushSizeController.brushSizeMax = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets and sets the brush size jitter.
|
|
/// </summary>
|
|
/// <remarks>Gets a value of 0 if the brush size controller isn't initialized.</remarks>
|
|
public float brushSizeJitter
|
|
{
|
|
get { return m_BrushSizeController?.brushSizeJitter ?? 0.0f; }
|
|
set { m_BrushSizeController.brushSizeJitter = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets and sets the brush rotation.
|
|
/// </summary>
|
|
/// <remarks>Gets a value of 0 if the brush rotation controller isn't initialized.</remarks>
|
|
public float brushRotation
|
|
{
|
|
get { return m_BrushRotationController?.brushRotation ?? 0.0f; }
|
|
set { m_BrushRotationController.brushRotation = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The strength of the brush without jitter.
|
|
/// </summary>
|
|
/// <remarks>Gets a value of 0 if the brush rotation controller isn't initialized.</remarks>
|
|
public float brushRotationVal
|
|
{
|
|
get { return m_BrushRotationController?.brushRotationVal ?? 0.0f; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets and sets the brush rotation jitter.
|
|
/// </summary>
|
|
/// <remarks>Gets a value of 0 if the brush rotation controller isn't initialized.</remarks>
|
|
public float brushRotationJitter
|
|
{
|
|
get { return m_BrushRotationController?.brushRotationJitter ?? 0.0f; }
|
|
set { m_BrushRotationController.brushRotationJitter = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets and sets the brush strength.
|
|
/// </summary>
|
|
/// <remarks>Gets a value of 1 if the brush strength controller isn't initialized.</remarks>
|
|
public float brushStrength
|
|
{
|
|
get { return m_BrushStrengthController?.brushStrength ?? 1.0f; }
|
|
set { m_BrushStrengthController.brushStrength = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The strength of the brush without jitter.
|
|
/// </summary>
|
|
/// <remarks>Gets a value of 1 if the brush strength controller isn't initialized.</remarks>
|
|
public float brushStrengthVal
|
|
{
|
|
get { return m_BrushStrengthController?.brushStrengthVal ?? 1.0f; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets and sets the brush min strength.
|
|
/// </summary>
|
|
/// <remarks>Gets a value of 0 if the brush strength controller isn't initialized.</remarks>
|
|
public float brushStrengthMin
|
|
{
|
|
get { return m_BrushStrengthController?.brushStrengthMin ?? 0.0f; }
|
|
set { m_BrushStrengthController.brushStrengthMin = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets and sets the brush max strength.
|
|
/// </summary>
|
|
/// <remarks>Gets a value of 1 if the brush strength controller isn't initialized.</remarks>
|
|
public float brushStrengthMax
|
|
{
|
|
get { return m_BrushStrengthController?.brushStrengthMax ?? 1.0f; }
|
|
set { m_BrushStrengthController.brushStrengthMax = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets and sets the brush strength jitter.
|
|
/// </summary>
|
|
/// <remarks>Gets a value of 0 if the brush strength controller isn't initialized.</remarks>
|
|
public float brushStrengthJitter
|
|
{
|
|
get { return m_BrushStrengthController?.brushStrengthJitter ?? 0.0f; }
|
|
set { m_BrushStrengthController.brushStrengthJitter = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the brush spacing.
|
|
/// </summary>
|
|
/// <remarks>Returns a value of 0 if the brush spacing controller isn't initialized.</remarks>
|
|
public float brushSpacing
|
|
{
|
|
get { return m_BrushSpacingController?.brushSpacing ?? 0.0f; }
|
|
set { m_BrushSpacingController.brushSpacing = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the brush scatter.
|
|
/// </summary>
|
|
/// <remarks>Returns a value of 0 if the brush scattering controller isn't initialized.</remarks>
|
|
public float brushScatter
|
|
{
|
|
get { return m_BrushScatterController?.brushScatter ?? 0.0f; }
|
|
set { m_BrushScatterController.brushScatter = value; }
|
|
}
|
|
|
|
private bool isSmoothing
|
|
{
|
|
get
|
|
{
|
|
if (m_BrushSmoothController != null)
|
|
{
|
|
return Event.current != null && Event.current.shift;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if painting is allowed.
|
|
/// </summary>
|
|
public virtual bool allowPaint => (m_BrushSpacingController?.allowPaint ?? true) && !isSmoothing;
|
|
|
|
/// <summary>
|
|
/// Inverts the brush strength.
|
|
/// </summary>
|
|
public bool InvertStrength => m_BrushModifierKeyController?.ModifierActive(BrushModifierKey.BRUSH_MOD_INVERT) ?? false;
|
|
|
|
/// <summary>
|
|
/// Checks if the brush is in use.
|
|
/// </summary>
|
|
public bool isInUse
|
|
{
|
|
get
|
|
{
|
|
foreach(IBrushController c in m_Controllers)
|
|
{
|
|
if(c.isInUse)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static class Styles
|
|
{
|
|
public static GUIStyle Box { get; private set; }
|
|
public static readonly GUIContent brushMask = EditorGUIUtility.TrTextContent("Brush Mask");
|
|
public static readonly GUIContent multipleControls = EditorGUIUtility.TrTextContent("Multiple Controls");
|
|
public static readonly GUIContent stroke = EditorGUIUtility.TrTextContent("Stroke");
|
|
|
|
public static readonly string kGroupBox = "GroupBox";
|
|
|
|
static Styles()
|
|
{
|
|
Box = new GUIStyle(EditorStyles.helpBox);
|
|
Box.normal.textColor = Color.white;
|
|
}
|
|
}
|
|
|
|
Func<TerrainToolsAnalytics.IBrushParameter[]> m_analyticsCallback;
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of BaseBrushUIGroup.
|
|
/// </summary>
|
|
/// <param name="name">The name of the brush.</param>
|
|
/// <param name="analyticsCall">The brush's analytics function.</param>
|
|
protected BaseBrushUIGroup(string name, Func<TerrainToolsAnalytics.IBrushParameter[]> analyticsCall = null)
|
|
{
|
|
m_Name = name;
|
|
m_analyticsCallback = analyticsCall;
|
|
}
|
|
|
|
#if UNITY_2019_1_OR_NEWER
|
|
[ClutchShortcut("Terrain/Adjust Brush Strength (SceneView)", typeof(TerrainToolShortcutContext), KeyCode.A)]
|
|
static void StrengthBrushShortcut(ShortcutArguments args) {
|
|
s_ShortcutHandler.HandleShortcutChanged(args, BrushShortcutType.Strength);
|
|
}
|
|
|
|
[ClutchShortcut("Terrain/Adjust Brush Size (SceneView)", typeof(TerrainToolShortcutContext), KeyCode.S)]
|
|
static void ResizeBrushShortcut(ShortcutArguments args) {
|
|
s_ShortcutHandler.HandleShortcutChanged(args, BrushShortcutType.Size);
|
|
}
|
|
|
|
[ClutchShortcut("Terrain/Adjust Brush Rotation (SceneView)", typeof(TerrainToolShortcutContext), KeyCode.D)]
|
|
private static void RotateBrushShortcut(ShortcutArguments args) {
|
|
s_ShortcutHandler.HandleShortcutChanged(args, BrushShortcutType.Rotation);
|
|
}
|
|
#endif
|
|
/// <summary>
|
|
/// Adds a generic controller of type <see cref="IBrushController"/> to the brush's controller list.
|
|
/// </summary>
|
|
/// <typeparam name="TController">A generic controller type of IBrushController.</typeparam>
|
|
/// <param name="newController">The new controller to add.</param>
|
|
/// <returns>Returns the new generic controller.</returns>
|
|
protected TController AddController<TController>(TController newController) where TController: IBrushController
|
|
{
|
|
m_Controllers.Add(newController);
|
|
return newController;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a rotation controller of type <see cref="IBrushRotationController"/> to the brush's controller list.
|
|
/// </summary>
|
|
/// <typeparam name="TController">A generic controller type of IBrushRotationController.</typeparam>
|
|
/// <param name="newController">The new controller to add.</param>
|
|
/// <returns>Returns the new rotation controller.</returns>
|
|
protected TController AddRotationController<TController>(TController newController) where TController : IBrushRotationController
|
|
{
|
|
m_BrushRotationController = AddController(newController);
|
|
return newController;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a size controller of type <see cref="IBrushSizeController"/> to the brush's controller list.
|
|
/// </summary>
|
|
/// <typeparam name="TController">A generic controller type of IBrushSizeController.</typeparam>
|
|
/// <param name="newController">The new controller to add.</param>
|
|
/// <returns>Returns the new size controller.</returns>
|
|
protected TController AddSizeController<TController>(TController newController) where TController : IBrushSizeController
|
|
{
|
|
m_BrushSizeController = AddController(newController);
|
|
return newController;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a strength controller of type <see cref="IBrushStrengthController"/> to the brush's controller list.
|
|
/// </summary>
|
|
/// <typeparam name="TController">A generic controller type of IBrushStrengthController.</typeparam>
|
|
/// <param name="newController">The new controller to add.</param>
|
|
/// <returns>Returns the new strength controller.</returns>
|
|
protected TController AddStrengthController<TController>(TController newController) where TController : IBrushStrengthController
|
|
{
|
|
m_BrushStrengthController = AddController(newController);
|
|
return newController;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a spacing controller of type <see cref="IBrushSpacingController"/> to the brush's controller list.
|
|
/// </summary>
|
|
/// <typeparam name="TController">A generic controller type of IBrushSpacingController.</typeparam>
|
|
/// <param name="newController">The new controller to add.</param>
|
|
/// <returns>Returns the new spacing controller.</returns>
|
|
protected TController AddSpacingController<TController>(TController newController) where TController : IBrushSpacingController
|
|
{
|
|
m_BrushSpacingController = AddController(newController);
|
|
return newController;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a scatter controller of type <see cref="IBrushScatterController"/> to the brush's controller list.
|
|
/// </summary>
|
|
/// <typeparam name="TController">A generic controller type of IBrushScatterController.</typeparam>
|
|
/// <param name="newController">The new controller to add.</param>
|
|
/// <returns>Returns the new scatter controller.</returns>
|
|
protected TController AddScatterController<TController>(TController newController) where TController : IBrushScatterController
|
|
{
|
|
m_BrushScatterController = AddController(newController);
|
|
return newController;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a modifier key controller of type <see cref="IBrushModifierKeyController"/> to the brush's controller list.
|
|
/// </summary>
|
|
/// <typeparam name="TController">A generic controller type of IBrushModifierKeyController.</typeparam>
|
|
/// <param name="newController">The new controller to add.</param>
|
|
/// <returns>Returns the new modifier key controller.</returns>
|
|
protected TController AddModifierKeyController<TController>(TController newController) where TController : IBrushModifierKeyController
|
|
{
|
|
m_BrushModifierKeyController = newController;
|
|
return newController;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a smoothing controller of type <see cref="IBrushSmoothController"/> to the brush's controller list.
|
|
/// </summary>
|
|
/// <typeparam name="TController">A generic controller type of IBrushSmoothController.</typeparam>
|
|
/// <param name="newController">The new controller to add.</param>
|
|
/// <returns>Returns the new smoothing controller.</returns>
|
|
protected TController AddSmoothingController<TController>(TController newController) where TController : IBrushSmoothController
|
|
{
|
|
m_BrushSmoothController = newController;
|
|
return newController;
|
|
}
|
|
|
|
private bool m_RepaintRequested;
|
|
|
|
/// <summary>
|
|
/// Registers a new event to be used witin <see cref="OnSceneGUI(Terrain, IOnSceneGUI)"/>.
|
|
/// </summary>
|
|
/// <param name="newEvent">The event to add.</param>
|
|
public void RegisterEvent(Event newEvent)
|
|
{
|
|
m_ConsumedEvents.Add(newEvent);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calls the Use function of the registered events.
|
|
/// </summary>
|
|
/// <param name="terrain">The terrain in focus.</param>
|
|
/// <param name="editContext">The editcontext to repaint.</param>
|
|
/// <seealso cref="RegisterEvent(Event)"/>
|
|
public void ConsumeEvents(Terrain terrain, IOnSceneGUI editContext)
|
|
{
|
|
// Consume all of the events we've handled...
|
|
foreach(Event currentEvent in m_ConsumedEvents)
|
|
{
|
|
currentEvent.Use();
|
|
}
|
|
m_ConsumedEvents.Clear();
|
|
|
|
// Repaint everything if we need to...
|
|
if(m_RepaintRequested)
|
|
{
|
|
EditorWindow view = EditorWindow.GetWindow<SceneView>();
|
|
|
|
editContext.Repaint();
|
|
view.Repaint();
|
|
|
|
m_RepaintRequested = false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the repaint request to <c>true</c>.
|
|
/// </summary>
|
|
public void RequestRepaint()
|
|
{
|
|
m_RepaintRequested = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Renders the brush's GUI within the inspector view.
|
|
/// </summary>
|
|
/// <param name="terrain">The terrain in focus.</param>
|
|
/// <param name="editContext">The editcontext used to show the brush GUI.</param>
|
|
/// <param name="brushFlags">The brushflags to use when displaying the brush GUI.</param>
|
|
public virtual void OnInspectorGUI(Terrain terrain, IOnInspectorGUI editContext,
|
|
BrushGUIEditFlags brushFlags = BrushGUIEditFlags.SelectAndInspect)
|
|
{
|
|
OnInspectorGUI(terrain, editContext, false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Renders the brush's GUI within the inspector view.
|
|
/// </summary>
|
|
/// <param name="terrain">The terrain in focus.</param>
|
|
/// <param name="editContext">The editcontext used to show the brush GUI.</param>
|
|
/// <param name="overlays">The bool to mark true when showing UI specific for overlays.</param>
|
|
/// <param name="brushFlags">The brushflags to use when displaying the brush GUI.</param>
|
|
/// <param name="brushOverlaysFlags"></param>
|
|
public virtual void OnInspectorGUI(Terrain terrain, IOnInspectorGUI editContext, bool overlays,
|
|
BrushGUIEditFlags brushFlags = BrushGUIEditFlags.SelectAndInspect,
|
|
BrushOverlaysGUIFlags brushOverlaysFlags = BrushOverlaysGUIFlags.All)
|
|
{
|
|
// get flag booleans for overlays
|
|
bool showNone = brushOverlaysFlags.Equals(BrushOverlaysGUIFlags.None);
|
|
bool showFilter = (brushOverlaysFlags & BrushOverlaysGUIFlags.Filter) != 0;
|
|
bool showStrength = (brushOverlaysFlags & BrushOverlaysGUIFlags.Strength) != 0;
|
|
bool showSize = (brushOverlaysFlags & BrushOverlaysGUIFlags.Size) != 0;
|
|
bool showRotation = (brushOverlaysFlags & BrushOverlaysGUIFlags.Rotation) != 0;
|
|
bool showSpacing = (brushOverlaysFlags & BrushOverlaysGUIFlags.Spacing) != 0;
|
|
bool showScatter = (brushOverlaysFlags & BrushOverlaysGUIFlags.Scatter) != 0;
|
|
|
|
if (overlays && showNone) return; // if show nothing for overlays, then return
|
|
|
|
if (brushFlags != BrushGUIEditFlags.None && !overlays)
|
|
{
|
|
editContext.ShowBrushesGUI(0, brushFlags);
|
|
}
|
|
|
|
EditorGUI.BeginChangeCheck();
|
|
|
|
if (showFilter)
|
|
{
|
|
// only show drop down for not overlays
|
|
if (!overlays) m_ShowBrushMaskFilters = TerrainToolGUIHelper.DrawHeaderFoldout(Styles.brushMask, m_ShowBrushMaskFilters);
|
|
if (m_ShowBrushMaskFilters)
|
|
{
|
|
brushMaskFilterStackView.OnGUI();
|
|
}
|
|
}
|
|
|
|
// only show drop down for not overlays
|
|
if (!overlays) m_ShowModifierControls = TerrainToolGUIHelper.DrawHeaderFoldout(Styles.stroke, m_ShowModifierControls);
|
|
|
|
if (m_ShowModifierControls)
|
|
{
|
|
if(m_BrushStrengthController != null && showStrength)
|
|
{
|
|
EditorGUILayout.BeginVertical(Styles.kGroupBox);
|
|
m_BrushStrengthController.OnInspectorGUI(terrain, editContext);
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
|
|
if(m_BrushSizeController != null && showSize)
|
|
{
|
|
EditorGUILayout.BeginVertical(Styles.kGroupBox);
|
|
m_BrushSizeController.OnInspectorGUI(terrain, editContext);
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
|
|
if(m_BrushRotationController != null && showRotation)
|
|
{
|
|
EditorGUILayout.BeginVertical(Styles.kGroupBox);
|
|
m_BrushRotationController?.OnInspectorGUI(terrain, editContext);
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
|
|
// if NOT overlays then draw spacing and scatter together. else draw scatter and spacing separately
|
|
if (overlays)
|
|
{
|
|
if (((m_BrushSpacingController != null) || (m_BrushScatterController != null)) && showSpacing)
|
|
{
|
|
EditorGUILayout.BeginVertical(Styles.kGroupBox);
|
|
m_BrushSpacingController?.OnInspectorGUI(terrain, editContext);
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
|
|
if (((m_BrushSpacingController != null) || (m_BrushScatterController != null)) && showScatter)
|
|
{
|
|
EditorGUILayout.BeginVertical(Styles.kGroupBox);
|
|
m_BrushScatterController?.OnInspectorGUI(terrain, editContext);
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if((m_BrushSpacingController != null) || (m_BrushScatterController != null))
|
|
{
|
|
EditorGUILayout.BeginVertical(Styles.kGroupBox);
|
|
m_BrushSpacingController?.OnInspectorGUI(terrain, editContext);
|
|
m_BrushScatterController?.OnInspectorGUI(terrain, editContext);
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
if (EditorGUI.EndChangeCheck())
|
|
TerrainToolsAnalytics.OnParameterChange();
|
|
}
|
|
|
|
private string getFilterStackFilePath
|
|
{
|
|
get { return Application.persistentDataPath + "/TerrainTools_" + m_Name + "_FilterStack.filterstack"; }
|
|
}
|
|
|
|
private FilterStack LoadFilterStack()
|
|
{
|
|
UnityEngine.Object[] obs = UnityEditorInternal.InternalEditorUtility.LoadSerializedFileAndForget( getFilterStackFilePath );
|
|
|
|
if( obs != null && obs.Length > 0 )
|
|
{
|
|
return obs[ 0 ] as FilterStack;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private void SaveFilterStack( FilterStack filterStack )
|
|
{
|
|
List< UnityEngine.Object > objList = new List< UnityEngine.Object >();
|
|
objList.Add( filterStack );
|
|
objList.AddRange( filterStack.filters );
|
|
|
|
filterStack.filters.ForEach( ( f ) =>
|
|
{
|
|
var l = f.GetObjectsToSerialize();
|
|
|
|
if( l != null && l.Count > 0 )
|
|
{
|
|
objList.AddRange( l );
|
|
}
|
|
} );
|
|
|
|
// write to the file
|
|
UnityEditorInternal.InternalEditorUtility.SaveToSerializedFileAndForget(objList.ToArray(), getFilterStackFilePath, true );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines data when the brush is selected.
|
|
/// </summary>
|
|
/// <seealso cref="OnExitToolMode"/>
|
|
public virtual void OnEnterToolMode()
|
|
{
|
|
m_BrushModifierKeyController?.OnEnterToolMode();
|
|
m_Controllers.ForEach((controller) => controller.OnEnterToolMode(s_ShortcutHandler));
|
|
|
|
TerrainToolsAnalytics.m_OriginalParameters = m_analyticsCallback?.Invoke();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines data when the brush is deselected.
|
|
/// </summary>
|
|
/// <seealso cref="OnEnterToolMode"/>
|
|
public virtual void OnExitToolMode()
|
|
{
|
|
m_Controllers.ForEach((controller) => controller.OnExitToolMode(s_ShortcutHandler));
|
|
m_BrushModifierKeyController?.OnExitToolMode();
|
|
|
|
SaveFilterStack(brushMaskFilterStack);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the brush strokes are being recorded.
|
|
/// </summary>
|
|
public static bool isRecording = false;
|
|
|
|
/// <summary>
|
|
/// Provides methods for the brush's painting.
|
|
/// </summary>
|
|
[Serializable]
|
|
public class OnPaintOccurrence
|
|
{
|
|
[NonSerialized] internal static List<OnPaintOccurrence> history = new List<OnPaintOccurrence>();
|
|
[NonSerialized] private static float prevRealTime;
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of OnPaintOccurrence.
|
|
/// </summary>
|
|
/// <param name="brushTexture">The brush's texture.</param>
|
|
/// <param name="brushSize">The brush's size.</param>
|
|
/// <param name="brushStrength">The brush's strength.</param>
|
|
/// <param name="brushRotation">The brush's rotation.</param>
|
|
/// <param name="uvX">The cursor's X position within UV space.</param>
|
|
/// <param name="uvY">The cursor's Y position within UV space.</param>
|
|
public OnPaintOccurrence(Texture brushTexture, float brushSize,
|
|
float brushStrength, float brushRotation,
|
|
float uvX, float uvY)
|
|
{
|
|
this.xPos = uvX;
|
|
this.yPos = uvY;
|
|
this.brushTextureAssetPath = AssetDatabase.GetAssetPath(brushTexture);
|
|
this.brushStrength = brushStrength;
|
|
this.brushSize = brushSize;
|
|
|
|
if (history.Count == 0)
|
|
{
|
|
duration = 0;
|
|
}
|
|
else
|
|
{
|
|
duration = Time.realtimeSinceStartup - prevRealTime;
|
|
}
|
|
|
|
prevRealTime = Time.realtimeSinceStartup;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The cursor's X position within UV space.
|
|
/// </summary>
|
|
[SerializeField] public float xPos;
|
|
|
|
/// <summary>
|
|
/// The cursor's Y position within UV space.
|
|
/// </summary>
|
|
[SerializeField] public float yPos;
|
|
|
|
/// <summary>
|
|
/// The asset file path of the brush texture in use.
|
|
/// </summary>
|
|
[SerializeField] public string brushTextureAssetPath;
|
|
|
|
/// <summary>
|
|
/// The brush strength.
|
|
/// </summary>
|
|
[SerializeField] public float brushStrength;
|
|
|
|
/// <summary>
|
|
/// The brush rotation.
|
|
/// </summary>
|
|
[SerializeField] public float brushRotation;
|
|
|
|
/// <summary>
|
|
/// The brush size.
|
|
/// </summary>
|
|
[SerializeField] public float brushSize;
|
|
|
|
/// <summary>
|
|
/// The total duration of painting.
|
|
/// </summary>
|
|
[SerializeField] public float duration;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Triggers events when painting on a terrain.
|
|
/// </summary>
|
|
/// <param name="terrain">The terrain in focus.</param>
|
|
/// <param name="editContext">The editcontext to reference.</param>
|
|
public virtual void OnPaint(Terrain terrain, IOnPaint editContext)
|
|
{
|
|
filterContext.ReleaseRTHandles();
|
|
|
|
// Manage brush capture history for playback in tests
|
|
if (isRecording)
|
|
{
|
|
OnPaintOccurrence.history.Add(new OnPaintOccurrence(editContext.brushTexture, brushSize,
|
|
brushStrength, brushRotation,
|
|
editContext.uv.x, editContext.uv.y));
|
|
}
|
|
|
|
m_Controllers.ForEach((controller) => controller.OnPaint(terrain, editContext));
|
|
|
|
if (isSmoothing)
|
|
{
|
|
Vector2 uv = editContext.uv;
|
|
|
|
m_BrushSmoothController.kernelSize = (int)Mathf.Max(1, 0.1f * m_BrushSizeController.brushSize);
|
|
m_BrushSmoothController.OnPaint(terrain, editContext, brushSize, brushRotation, brushStrength, uv);
|
|
}
|
|
|
|
/// Ensure that we re-randomize where the next scatter operation will place the brush,
|
|
/// that way we can render the preview in a representative manner.
|
|
m_BrushScatterController?.RequestRandomisation();
|
|
|
|
TerrainToolsAnalytics.UpdateAnalytics(this, m_analyticsCallback);
|
|
|
|
filterContext.ReleaseRTHandles();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Triggers events to render a 2D GUI within the Scene view.
|
|
/// </summary>
|
|
/// <param name="terrain">The terrain in focus.</param>
|
|
/// <param name="editContext">The editcontext to reference.</param>
|
|
/// <seealso cref="OnSceneGUI(Terrain, IOnSceneGUI)"/>
|
|
private static string brushInfo = ""; // adding this to grab brush info
|
|
public virtual void OnSceneGUI2D(Terrain terrain, IOnSceneGUI editContext)
|
|
{
|
|
StringBuilder builder = new StringBuilder();
|
|
|
|
Handles.BeginGUI();
|
|
{
|
|
AppendBrushInfo(terrain, editContext, builder);
|
|
string text = builder.ToString();
|
|
string trimmedText = text.Trim('\n', '\r', ' ', '\t');
|
|
brushInfo = trimmedText;
|
|
BrushInfoIsAccessed();
|
|
Handles.EndGUI();
|
|
}
|
|
}
|
|
|
|
// adding this to grab brush info
|
|
public static string getBrushInfoText()
|
|
{
|
|
return brushInfo;
|
|
}
|
|
|
|
public static event Action brushInfoAccessed;
|
|
internal static void BrushInfoIsAccessed()
|
|
{
|
|
if (brushInfoAccessed == null)
|
|
return;
|
|
brushInfoAccessed();
|
|
}
|
|
|
|
[Overlay(typeof(SceneView), k_Id, "Brush Info")]
|
|
class BrushInfoOverlay : Overlay, ITransientOverlay
|
|
{
|
|
const string k_Id = "brush-info-overlay";
|
|
private Label m_Label;
|
|
|
|
public bool visible
|
|
{
|
|
get
|
|
{
|
|
var currTool = BrushesOverlay.ActiveTerrainTool as TerrainPaintToolWithOverlaysBase;
|
|
if (currTool == null)
|
|
return false;
|
|
return currTool.HasBrushAttributes && BrushesOverlay.IsSelectedObjectTerrain();
|
|
}
|
|
}
|
|
|
|
void UpdateText()
|
|
{
|
|
if (m_Label != null) m_Label.text = getBrushInfoText();
|
|
}
|
|
|
|
void EmptyText()
|
|
{
|
|
if (m_Label != null) m_Label.text = "";
|
|
}
|
|
|
|
public override VisualElement CreatePanelContent()
|
|
{
|
|
brushInfoAccessed += UpdateText;
|
|
Selection.selectionChanged += EmptyText;
|
|
|
|
return m_Label = new Label(getBrushInfoText());
|
|
}
|
|
|
|
public override void OnWillBeDestroyed()
|
|
{
|
|
base.OnWillBeDestroyed();
|
|
brushInfoAccessed -= UpdateText;
|
|
Selection.selectionChanged -= EmptyText;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Triggers events to render objects and displays within Scene view.
|
|
/// </summary>
|
|
/// <param name="terrain">The terrain in focus.</param>
|
|
/// <param name="editContext">The editcontext to reference.</param>
|
|
/// <seealso cref="OnSceneGUI(Terrain, IOnSceneGUI)"/>
|
|
public virtual void OnSceneGUI(Terrain terrain, IOnSceneGUI editContext)
|
|
{
|
|
filterContext.ReleaseRTHandles();
|
|
|
|
Event currentEvent = Event.current;
|
|
int controlId = GUIUtility.GetControlID(TerrainToolGUIHelper.s_TerrainEditorHash, FocusType.Passive);
|
|
|
|
if(canUpdateTerrainUnderCursor)
|
|
{
|
|
isRaycastHitUnderCursorValid = editContext.hitValidTerrain;
|
|
terrainUnderCursor = terrain;
|
|
raycastHitUnderCursor = editContext.raycastHit;
|
|
}
|
|
|
|
m_Controllers.ForEach((controller) => controller.OnSceneGUI(currentEvent, controlId, terrain, editContext));
|
|
|
|
ConsumeEvents(terrain, editContext);
|
|
|
|
if (!isRecording && OnPaintOccurrence.history.Count != 0) {
|
|
SaveBrushData();
|
|
}
|
|
|
|
brushMaskFilterStackView.OnSceneGUI(editContext.sceneView);
|
|
|
|
if( editContext.hitValidTerrain && Event.current.keyCode == KeyCode.F && Event.current.type != EventType.Layout )
|
|
{
|
|
SceneView.currentDrawingSceneView.Frame( new Bounds() { center = raycastHitUnderCursor.point, size = new Vector3( brushSize, 1, brushSize ) }, false );
|
|
Event.current.Use();
|
|
}
|
|
|
|
filterContext.ReleaseRTHandles();
|
|
}
|
|
|
|
private void SaveBrushData() {
|
|
// Copy paintOccurrenceHistory to temp variable to prevent re-activating this condition
|
|
List<OnPaintOccurrence> tmpPaintOccurrenceHistory = new List<OnPaintOccurrence>(OnPaintOccurrence.history);
|
|
OnPaintOccurrence.history.Clear();
|
|
|
|
string fileName = EditorUtility.SaveFilePanelInProject("Save input playback", "PaintHistory", "txt", "");
|
|
if (fileName == "") {
|
|
return;
|
|
}
|
|
|
|
FileStream file;
|
|
if (File.Exists(fileName)) file = File.OpenWrite(fileName);
|
|
else file = File.Create(fileName);
|
|
|
|
BinaryFormatter binaryFormatter = new BinaryFormatter();
|
|
binaryFormatter.Serialize(file, tmpPaintOccurrenceHistory);
|
|
file.Close();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds basic information to the selected brush.
|
|
/// </summary>
|
|
/// <param name="terrain">The Terrain in focus.</param>
|
|
/// <param name="editContext">The IOnSceneGUI to reference.</param>
|
|
/// <param name="builder">The StringBuilder containing the brush information.</param>
|
|
public virtual void AppendBrushInfo(Terrain terrain, IOnSceneGUI editContext, StringBuilder builder)
|
|
{
|
|
|
|
builder.AppendLine($"Brush: {m_Name}");
|
|
builder.AppendLine();
|
|
|
|
m_Controllers.ForEach((controller) => controller.AppendBrushInfo(terrain, editContext, builder));
|
|
builder.AppendLine();
|
|
builder.AppendLine(validationMessage);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scatters the location of the brush's stamp operation.
|
|
/// </summary>
|
|
/// <param name="terrain">The terrain in reference.</param>
|
|
/// <param name="uv">The UV location to scatter at.</param>
|
|
/// <returns>Returns false if there aren't any terrains to scatter the stamp on.</returns>
|
|
public bool ScatterBrushStamp(ref Terrain terrain, ref Vector2 uv)
|
|
{
|
|
if(m_BrushScatterController == null) {
|
|
bool invalidTerrain = terrain == null;
|
|
|
|
return !invalidTerrain;
|
|
}
|
|
else {
|
|
Vector2 scatteredUv = m_BrushScatterController.ScatterBrushStamp(uv, brushSize);
|
|
Terrain scatteredTerrain = terrain;
|
|
|
|
// Ensure that our UV is over a valid terrain AND in the range 0-1...
|
|
while((scatteredTerrain != null) && (scatteredUv.x < 0.0f)) {
|
|
scatteredTerrain = scatteredTerrain.leftNeighbor;
|
|
scatteredUv.x += 1.0f;
|
|
}
|
|
while((scatteredTerrain != null) && (scatteredUv.x > 1.0f)) {
|
|
scatteredTerrain = scatteredTerrain.rightNeighbor;
|
|
scatteredUv.x -= 1.0f;
|
|
}
|
|
while((scatteredTerrain != null) && scatteredUv.y < 0.0f) {
|
|
scatteredTerrain = scatteredTerrain.bottomNeighbor;
|
|
scatteredUv.y += 1.0f;
|
|
}
|
|
while((scatteredTerrain != null) && (scatteredUv.y > 1.0f)) {
|
|
scatteredTerrain = scatteredTerrain.topNeighbor;
|
|
scatteredUv.y -= 1.0f;
|
|
}
|
|
|
|
// Did we run out of terrains?
|
|
if(scatteredTerrain == null) {
|
|
return false;
|
|
}
|
|
else {
|
|
terrain = scatteredTerrain;
|
|
uv = scatteredUv;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Activates a modifier key controller.
|
|
/// </summary>
|
|
/// <param name="k">The modifier key to activate.</param>
|
|
/// <returns>Returns false when the modifier key controller is null.</returns>
|
|
public bool ModifierActive(BrushModifierKey k)
|
|
{
|
|
return m_BrushModifierKeyController?.ModifierActive(k) ?? false;
|
|
}
|
|
|
|
private int m_TerrainUnderCursorLockCount = 0;
|
|
|
|
/// <summary>
|
|
/// Handles the locking of the terrain cursor in it's current position.
|
|
/// </summary>
|
|
/// <remarks>This method is commonly used when utilizing shortcuts.</remarks>
|
|
/// <param name="cursorVisible">Whether the cursor is visible within the scene. When the value is <c>true</c> the cursor is visible.</param>
|
|
/// <seealso cref="UnlockTerrainUnderCursor"/>
|
|
public void LockTerrainUnderCursor(bool cursorVisible)
|
|
{
|
|
if (m_TerrainUnderCursorLockCount == 0)
|
|
{
|
|
Cursor.visible = cursorVisible;
|
|
}
|
|
|
|
m_TerrainUnderCursorLockCount++;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handles unlocking of the terrain cursor.
|
|
/// </summary>
|
|
/// <seealso cref="LockTerrainUnderCursor(bool)"/>
|
|
public void UnlockTerrainUnderCursor()
|
|
{
|
|
if (m_TerrainUnderCursorLockCount > 0)
|
|
{
|
|
m_TerrainUnderCursorLockCount--;
|
|
}
|
|
else if (m_TerrainUnderCursorLockCount == 0)
|
|
{
|
|
// Last unlock enables the cursor...
|
|
Cursor.visible = true;
|
|
}
|
|
else if (m_TerrainUnderCursorLockCount < 0)
|
|
{
|
|
m_TerrainUnderCursorLockCount = 0;
|
|
throw new ArgumentOutOfRangeException(nameof(m_TerrainUnderCursorLockCount), "Cannot reduce m_TerrainUnderCursorLockCount below zero. Possible mismatch between lock/unlock calls.");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the cursor is currently locked and can not be updated.
|
|
/// </summary>
|
|
public bool canUpdateTerrainUnderCursor => m_TerrainUnderCursorLockCount == 0;
|
|
|
|
/// <summary>
|
|
/// Gets and sets the terrain in focus.
|
|
/// </summary>
|
|
public Terrain terrainUnderCursor { get; protected set; }
|
|
|
|
/// <summary>
|
|
/// Gets and sets the value associated to whether there is a raycast hit detecting a terrain under the cursor.
|
|
/// </summary>
|
|
public bool isRaycastHitUnderCursorValid { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets and sets the raycast hit that was under the cursor's position.
|
|
/// </summary>
|
|
public RaycastHit raycastHitUnderCursor { get; protected set; }
|
|
|
|
/// <summary>
|
|
/// Gets and sets the message for validating terrain parameters.
|
|
/// </summary>
|
|
public virtual string validationMessage { get; set; }
|
|
}
|
|
}
|