public static void ShowDefaultPreviewBrush(Terrain terrain, Texture brushTexture, float brushStrength, float brushSize, float futurePreviewScale)
{
Ray mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
RaycastHit hit;
if (terrain.GetComponent <Collider>().Raycast(mouseRay, out hit, Mathf.Infinity))
{
if (Event.current.shift)
{
brushStrength = -brushStrength;
}
Rect brushRect = TerrainPaintUtility.CalculateBrushRectInTerrainUnits(terrain, hit.textureCoord, brushSize);
TerrainPaintUtility.PaintContext ctx = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushRect);
ctx.sourceRenderTexture.filterMode = FilterMode.Bilinear;
brushTexture.filterMode = FilterMode.Bilinear;
Vector2 topLeft = ctx.brushRect.min;
float xfrac = ((topLeft.x - (int)topLeft.x) / (float)ctx.sourceRenderTexture.width);
float yfrac = ((topLeft.y - (int)topLeft.y) / (float)ctx.sourceRenderTexture.height);
Vector4 texScaleOffset = new Vector4(0.5f, 0.5f, 0.5f + xfrac + 0.5f / (float)ctx.sourceRenderTexture.width, 0.5f + yfrac + 0.5f / (float)ctx.sourceRenderTexture.height);
DrawDefaultBrushPreviewMesh(terrain, hit, ctx.sourceRenderTexture, brushTexture, brushStrength * 0.01f, brushSize, defaultPreviewPatchMesh, false, texScaleOffset);
if ((futurePreviewScale > Mathf.Epsilon) && Event.current.control)
{
DrawDefaultBrushPreviewMesh(terrain, hit, ctx.sourceRenderTexture, brushTexture, futurePreviewScale, brushSize, defaultPreviewPatchMesh, true, texScaleOffset);
}
TerrainPaintUtility.ReleaseContextResources(ctx);
}
}
public void Release(PaintContext paintContext)
{
if (ReferenceEquals(paintContext, m_HeightmapContext))
{
if (m_WriteToHeightmap)
{
TerrainPaintUtility.EndPaintHeightmap(m_HeightmapContext, $"{m_Name} - Heightmap");
}
else
{
TerrainPaintUtility.ReleaseContextResources(m_HeightmapContext);
}
m_HeightmapContext = null;
}
else if (ReferenceEquals(paintContext, m_NormalmapContext))
{
TerrainPaintUtility.ReleaseContextResources(m_NormalmapContext);
m_NormalmapContext = null;
}
else if (ReferenceEquals(paintContext, m_TextureContext))
{
if (m_WriteToTexture)
{
TerrainPaintUtility.EndPaintTexture(m_TextureContext, $"{m_Name} - Texture");
}
else
{
TerrainPaintUtility.ReleaseContextResources(m_TextureContext);
}
m_TextureContext = null;
}
}
public override bool OnPaint(Terrain terrain, IOnPaint editContext)
{
if (splatPaintRules == null)
{
return(false);
}
Material mat = GetPaintMaterial();
mat.SetTexture("_BrushTex", editContext.brushTexture);
// gathering heightmap
BrushTransform brushXformForGatheringHeightmap = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv, editContext.brushSize, 0.0f);
PaintContext paintContextForGatheringHeightmap = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXformForGatheringHeightmap.GetBrushXYBounds(), 1);
if (paintContextForGatheringHeightmap == null)
{
return(false);
}
RenderTexture gatheredHeightmap = RenderTexture.GetTemporary(terrain.terrainData.heightmapTexture.descriptor);
Graphics.Blit(paintContextForGatheringHeightmap.sourceRenderTexture, gatheredHeightmap); //, TerrainPaintUtility.GetBlitMaterial(), 0);
TerrainPaintUtility.ReleaseContextResources(paintContextForGatheringHeightmap);
// painting alphamap
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv, editContext.brushSize, 0.0f);
PaintContext paintContext = TerrainPaintUtility.BeginPaintTexture(terrain, brushXform.GetBrushXYBounds(), m_SelectedTerrainLayer);
if (paintContext == null)
{
return(false);
}
float targetAlpha = 1.0f; // always 1.0 now -- no subtractive painting (we assume this in the ScatterAlphaMap)
Vector4 brushParams = new Vector4(editContext.brushStrength, targetAlpha, splatPaintRules.useHeightTransition ? 1f : 0f, splatPaintRules.useAngleTransition ? 1f : 0f);
Vector4 paintRulesParametersHeight = new Vector4(splatPaintRules.minHeightStart, splatPaintRules.minHeightEnd, splatPaintRules.maxHeightStart, splatPaintRules.maxHeightEnd);
Vector4 paintRulesParametersAngle = new Vector4(splatPaintRules.minAngleStart, splatPaintRules.minAngleEnd, splatPaintRules.maxAngleStart, splatPaintRules.maxAngleEnd);
Vector4 paintRulesInversionAndUsage = new Vector4(splatPaintRules.inverseHeightRule ? 1f : 0f, splatPaintRules.inverseAngleRule ? 1f : 0f, splatPaintRules.applyHeightRule ? 1f : 0f, splatPaintRules.applyAngleRule ? 1f : 0f);
mat.SetVector("_BrushParams", brushParams);
mat.SetVector("_TerrainSize", (Vector4)terrain.terrainData.size);
mat.SetVector("_PaintRulesParametersHeight", paintRulesParametersHeight);
mat.SetVector("_PaintRulesParametersAngle", paintRulesParametersAngle);
mat.SetVector("_PaintRulesInversionAndUsage", paintRulesInversionAndUsage);
mat.SetTexture("_Heightmap", gatheredHeightmap);
TerrainPaintUtility.SetupTerrainToolMaterialProperties(paintContext, brushXform, mat);
Graphics.Blit(paintContext.sourceRenderTexture, paintContext.destinationRenderTexture, mat, 0);
TerrainPaintUtility.EndPaintTexture(paintContext, "Terrain Paint - Texture");
RenderTexture.ReleaseTemporary(gatheredHeightmap);
return(true);
}
public override void OnSceneGUI(Terrain terrain, IOnSceneGUI editContext)
{
commonUI.OnSceneGUI2D(terrain, editContext);
if (!editContext.hitValidTerrain && !commonUI.isInUse)
{
return;
}
commonUI.OnSceneGUI(terrain, editContext);
Event evt = Event.current;
if (evt.control && (evt.type == EventType.ScrollWheel))
{
const float k_mouseWheelToHeightRatio = -0.004f;
stampToolProperties.stampHeight += Event.current.delta.y * k_mouseWheelToHeightRatio * editContext.raycastHit.distance;
evt.Use();
editContext.Repaint();
SaveSetting();
}
// We're only doing painting operations, early out if it's not a repaint
if (evt.type != EventType.Repaint)
{
return;
}
if (commonUI.isRaycastHitUnderCursorValid)
{
Texture brushTexture = editContext.brushTexture;
using (IBrushRenderPreviewUnderCursor brushRender = new BrushRenderPreviewUIGroupUnderCursor(commonUI, "Stamp", brushTexture))
{
if (brushRender.CalculateBrushTransform(out BrushTransform brushXform))
{
PaintContext paintContext = brushRender.AcquireHeightmap(false, brushXform.GetBrushXYBounds(), 1);
Material previewMaterial = Utility.GetDefaultPreviewMaterial();
var texelCtx = Utility.CollectTexelValidity(paintContext.originTerrain, brushXform.GetBrushXYBounds());
Utility.SetupMaterialForPaintingWithTexelValidityContext(paintContext, texelCtx, brushXform, previewMaterial);
TerrainPaintUtilityEditor.DrawBrushPreview(paintContext, TerrainBrushPreviewMode.SourceRenderTexture,
editContext.brushTexture, brushXform, previewMaterial, 0);
// draw result preview
{
ApplyBrushInternal(brushRender, paintContext, commonUI.brushStrength, brushTexture, brushXform, terrain);
// restore old render target
RenderTexture.active = paintContext.oldRenderTexture;
previewMaterial.SetTexture("_HeightmapOrig", paintContext.sourceRenderTexture);
TerrainPaintUtilityEditor.DrawBrushPreview(paintContext, TerrainBrushPreviewMode.DestinationRenderTexture,
editContext.brushTexture, brushXform, previewMaterial, 1);
}
TerrainPaintUtility.ReleaseContextResources(paintContext);
texelCtx.Cleanup();
}
}
}
}
void Update()
{
if (stepsRemaining <= 0)
{
ToggleRenderSurface(false);
return;
}
ToggleRenderSurface(true);
int stepsThisUpdate = (int)(m_SimSpeed * 20.0f) + 1;
while (stepsThisUpdate-- > 0 && stepsRemaining > 0)
{
Erode();
}
if (stepsRemaining <= 0)
{
continuing = false;
ToggleRenderSurface(false);
TerrainPaintUtility.EndPaintHeightmap(heightContext, "Terrain Paint - Hydraulic Erosion");
if (maskContext != null)
{
TerrainPaintUtility.ReleaseContextResources(maskContext);
}
}
else
{
heightContext.ScatterHeightmap("Terrain Paint - Hydraulic Erosion");
}
}
private void PaintAlphamap(Rect writeBrushRect, Terrain terrain, Material mat)
{
// paint each layer from the sample to the clone location (adds layer if not present already)
for (int i = 0; i < m_Sample.m_Terrain.terrainData.terrainLayers.Length; ++i)
{
TerrainPaintUtility.PaintContext write = TerrainPaintUtility.BeginPaintTexture(terrain,
writeBrushRect,
m_Sample.m_Terrain.terrainData.terrainLayers[i]);
if (write == null)
{
continue;
}
// read created manually to force read to not add the layer if it wasnt already on the terrain, and to use write's rect with offset
TerrainPaintUtility.PaintContext read = new TerrainPaintUtility.PaintContext();
read.brushRect = new RectInt(write.brushRect.position + m_CloneRectPixelOffsetFromStampRect, write.brushRect.size);
// TODO(wyatt): Uncomment this once Andrew's API changes make it to trunk
read.CreateTerrainTiles(m_Sample.m_Terrain,
m_Sample.m_Terrain.terrainData.alphamapWidth,
m_Sample.m_Terrain.terrainData.alphamapHeight);
read.CreateRenderTargets(RenderTextureFormat.R8);
read.GatherAlphamap(m_Sample.m_Terrain, m_Sample.m_Terrain.terrainData.terrainLayers[i], false);
// render mix of clone and stamp areas
StampRender(read, write, mat, (int)ShaderPasses.CloneAlphamap);
TerrainPaintUtility.ReleaseContextResources(read);
TerrainPaintUtility.EndPaintTexture(write, "Terrain Paint - Clone Stamp Tool (Alphamap layer " + i + ")");
}
}
public override void OnSceneGUI(Terrain terrain, IOnSceneGUI editContext)
{
// We're only doing painting operations, early out if it's not a repaint
if (Event.current.type != EventType.Repaint)
{
return;
}
if (editContext.hitValidTerrain)
{
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.raycastHit.textureCoord, editContext.brushSize, 0.0f);
PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1);
Material material = TerrainPaintUtilityEditor.GetDefaultBrushPreviewMaterial();
TerrainPaintUtilityEditor.DrawBrushPreview(
paintContext, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture, editContext.brushTexture, brushXform, material, 0);
// draw result preview
{
ApplyBrushInternal(paintContext, editContext.brushStrength, editContext.brushTexture, brushXform);
// restore old render target
RenderTexture.active = paintContext.oldRenderTexture;
material.SetTexture("_HeightmapOrig", paintContext.sourceRenderTexture);
TerrainPaintUtilityEditor.DrawBrushPreview(
paintContext, TerrainPaintUtilityEditor.BrushPreview.DestinationRenderTexture, editContext.brushTexture, brushXform, material, 1);
}
TerrainPaintUtility.ReleaseContextResources(paintContext);
}
}
public override bool OnPaint(Terrain terrain, IOnPaint editContext)
{
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv, editContext.brushSize, 0.0f);
Rect rect = brushXform.GetBrushXYBounds();
PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, rect);
Material mat = GetPaintMaterial();
PaintContext maskContext = null;
if (m_TextureMask || m_TextureStencil)
{
TerrainLayer maskTerrainLayer = terrain.terrainData.terrainLayers[m_TextureMask ? m_maskIndex : m_stencilIndex];
maskContext = TerrainPaintUtility.BeginPaintTexture(terrain, rect, maskTerrainLayer);
if (maskContext == null)
{
return(false);
}
mat.SetTexture("_MaskTex", maskContext.sourceRenderTexture);
}
mat.SetInt("_MaskStencil", m_TextureMask ? 1 : (m_TextureStencil ? 2 : 0));
ApplyBrushInternal(paintContext, editContext.brushStrength, editContext.brushTexture, brushXform, mat);
if (maskContext != null)
{
TerrainPaintUtility.ReleaseContextResources(maskContext);
}
TerrainPaintUtility.EndPaintHeightmap(paintContext, "Terrain Paint - Masked Terrace Erosion");
return(false);
}
private void PaintHeightmap(Terrain sampleTerrain, Terrain targetTerrain, BrushTransform sampleXform,
BrushTransform targetXform, IOnPaint editContext, Material mat)
{
PaintContext sampleContext = TerrainPaintUtility.BeginPaintHeightmap(sampleTerrain, sampleXform.GetBrushXYBounds());
PaintContext targetContext = TerrainPaintUtility.BeginPaintHeightmap(targetTerrain, targetXform.GetBrushXYBounds());
ApplyHeightmap(sampleContext, targetContext, targetXform, targetTerrain, editContext.brushTexture, editContext.brushStrength);
TerrainPaintUtility.EndPaintHeightmap(targetContext, "Terrain Paint - Clone Brush (Heightmap)");
TerrainPaintUtility.ReleaseContextResources(sampleContext);
}
public override void OnRenderBrushPreview(Terrain terrain, IOnSceneGUI editContext)
{
if (m_MouseOnPatchIndex == -1 && editContext.hitValidTerrain && Event.current.type == EventType.Repaint)
{
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.raycastHit.textureCoord, editContext.brushSize, 0.0f);
PaintContext ctx = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1);
TerrainPaintUtilityEditor.DrawBrushPreview(ctx, TerrainBrushPreviewMode.SourceRenderTexture, editContext.brushTexture, brushXform, TerrainPaintUtilityEditor.GetDefaultBrushPreviewMaterial(), 0);
TerrainPaintUtility.ReleaseContextResources(ctx);
}
}
public override void OnSceneGUI(Terrain terrain, IOnSceneGUI editContext)
{
commonUI.OnSceneGUI2D(terrain, editContext);
// only do the rest if user mouse hits valid terrain or they are using the
// brush parameter hotkeys to resize, etc
if (!editContext.hitValidTerrain && !commonUI.isInUse)
{
return;
}
// update brush UI group
commonUI.OnSceneGUI(terrain, editContext);
// dont render preview if this isnt a repaint. losing performance if we do
if (Event.current.type != EventType.Repaint)
{
return;
}
using (IBrushRenderPreviewUnderCursor brushPreview =
new BrushRenderPreviewUIGroupUnderCursor(commonUI, "NoiseHeightTool", editContext.brushTexture))
{
float brushSize = commonUI.brushSize;
float brushStrength = Event.current.control ? -commonUI.brushStrength : commonUI.brushStrength;
Vector3 brushPosWS = commonUI.raycastHitUnderCursor.point;
brushPreview.CalculateBrushTransform(out var brushXform);
PaintContext ctx = brushPreview.AcquireHeightmap(false, brushXform.GetBrushXYBounds(), 1);
Material previewMaterial = Utility.GetDefaultPreviewMaterial();
var texelCtx = Utility.CollectTexelValidity(ctx.originTerrain, brushXform.GetBrushXYBounds());
Utility.SetupMaterialForPaintingWithTexelValidityContext(ctx, texelCtx, brushXform, previewMaterial);
TerrainPaintUtilityEditor.DrawBrushPreview(ctx, TerrainBrushPreviewMode.SourceRenderTexture,
editContext.brushTexture, brushXform, previewMaterial, 0);
ApplyBrushInternal(terrain, ctx, brushXform, brushPosWS, commonUI.brushRotation,
brushStrength, brushSize, editContext.brushTexture);
TerrainPaintUtility.SetupTerrainToolMaterialProperties(ctx, brushXform, previewMaterial);
// restore old render target
RenderTexture.active = ctx.oldRenderTexture;
previewMaterial.SetTexture("_HeightmapOrig", ctx.sourceRenderTexture);
TerrainPaintUtilityEditor.DrawBrushPreview(ctx, TerrainBrushPreviewMode.DestinationRenderTexture,
editContext.brushTexture, brushXform, previewMaterial, 1);
texelCtx.Cleanup();
TerrainPaintUtility.ReleaseContextResources(ctx);
}
}
public override void OnSceneGUI(Terrain terrain, IOnSceneGUI editContext)
{
commonUI.OnSceneGUI2D(terrain, editContext);
if (editContext.hitValidTerrain || commonUI.isInUse)
{
commonUI.OnSceneGUI(terrain, editContext);
if (Event.current.type != EventType.Repaint)
{
return;
}
if (pathToolProperties != null && pathToolProperties.widthProfile != null)
{
float endWidth = Mathf.Abs(pathToolProperties.widthProfile.Evaluate(1.0f));
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, commonUI.raycastHitUnderCursor.textureCoord, commonUI.brushSize * endWidth, commonUI.brushRotation);
PaintContext ctx = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1);
TerrainPaintUtilityEditor.DrawBrushPreview(ctx, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture, editContext.brushTexture, brushXform, TerrainPaintUtilityEditor.GetDefaultBrushPreviewMaterial(), 0);
TerrainPaintUtility.ReleaseContextResources(ctx);
}
}
if (Event.current.type != EventType.Repaint)
{
return;
}
switch (pathToolProperties.paintMode)
{
case PaintMode.Paint:
// nothing to do, no special indicator
break;
case PaintMode.Stroke:
//display a brush preview at first or last clicked path location, using starting size from width profile
if (m_StartTerrain != null)
{
float startWidth = Mathf.Abs(pathToolProperties.widthProfile.Evaluate(0.0f));
BrushTransform brushTransform = TerrainPaintUtility.CalculateBrushTransform(m_StartTerrain, m_StartPoint, commonUI.brushSize * startWidth, commonUI.brushRotation);
PaintContext sampleContext = TerrainPaintUtility.BeginPaintHeightmap(m_StartTerrain, brushTransform.GetBrushXYBounds());
TerrainPaintUtilityEditor.DrawBrushPreview(sampleContext, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture,
editContext.brushTexture, brushTransform, TerrainPaintUtilityEditor.GetDefaultBrushPreviewMaterial(), 0);
TerrainPaintUtility.ReleaseContextResources(sampleContext);
}
break;
default:
throw new System.Exception(string.Format("Unsupported paint mode {0}", pathToolProperties.paintMode));
}
}
public static void ShowDefaultPreviewBrush(Terrain terrain, Texture brushTexture, float brushSize)
{
Ray mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
RaycastHit hit;
if (terrain.GetComponent <Collider>().Raycast(mouseRay, out hit, Mathf.Infinity))
{
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, hit.textureCoord, brushSize, 0.0f);
PaintContext ctx = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1);
DrawBrushPreview(ctx, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture, brushTexture, brushXform, GetDefaultBrushPreviewMaterial(), 0);
TerrainPaintUtility.ReleaseContextResources(ctx);
}
}
override public void OnSceneGUI(Terrain currentTerrain, IOnSceneGUI editContext)
{
Terrain terrain = currentTerrain;
float brushSize = editContext.brushSize;
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.raycastHit.textureCoord, brushSize, 0.0f);
PaintContext ctx = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1);
Material brushPreviewMat = BrushUtilities.GetDefaultBrushPreviewMaterial();
brushPreviewMat.color = bridgeBrushColor;
BrushUtilities.DrawBrushPreview(ctx, BrushUtilities.BrushPreview.SourceRenderTexture, editContext.brushTexture, brushXform, brushPreviewMat, 0);
TerrainPaintUtility.ReleaseContextResources(ctx);
}
public override bool OnPaint(Terrain terrain, IOnPaint editContext)
{
if (Event.current.type == EventType.MouseDown)
{
m_PrevBrushPos = editContext.uv;
return(false);
}
if (Event.current.type == EventType.MouseDrag && m_PreviousEvent == EventType.MouseDrag)
{
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv, editContext.brushSize, 0.0f);
PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1);
Vector2 smudgeDir = editContext.uv - m_PrevBrushPos;
paintContext.sourceRenderTexture.filterMode = FilterMode.Bilinear;
Material mat = GetPaintMaterial();
PaintContext maskContext = null;
if (m_TextureMask || m_TextureStencil)
{
TerrainLayer maskTerrainLayer = terrain.terrainData.terrainLayers[m_TextureMask ? m_maskIndex : m_stencilIndex];
maskContext = TerrainPaintUtility.BeginPaintTexture(terrain, brushXform.GetBrushXYBounds(), maskTerrainLayer);
if (maskContext == null)
{
return(false);
}
mat.SetTexture("_MaskTex", maskContext.sourceRenderTexture);
}
mat.SetInt("_MaskStencil", m_TextureMask ? 1 : (m_TextureStencil ? 2 : 0));
Vector4 brushParams = new Vector4(editContext.brushStrength, smudgeDir.x, smudgeDir.y, 0);
mat.SetTexture("_BrushTex", editContext.brushTexture);
mat.SetVector("_BrushParams", brushParams);
TerrainPaintUtility.SetupTerrainToolMaterialProperties(paintContext, brushXform, mat);
Graphics.Blit(paintContext.sourceRenderTexture, paintContext.destinationRenderTexture, mat, 0);
TerrainPaintUtility.EndPaintHeightmap(paintContext, "Terrain Paint - Masked Smudge");
if (maskContext != null)
{
TerrainPaintUtility.ReleaseContextResources(maskContext);
}
m_PrevBrushPos = editContext.uv;
}
m_PreviousEvent = Event.current.type;
return(false);
}
public void Release(PaintContext paintContext)
{
if (ReferenceEquals(paintContext, m_HeightmapContext))
{
if (m_WriteToHeightmap)
{
TerrainPaintUtility.EndPaintHeightmap(m_HeightmapContext, $"{m_Name} - Heightmap");
}
else
{
TerrainPaintUtility.ReleaseContextResources(m_HeightmapContext);
}
m_HeightmapContext = null;
}
else if (ReferenceEquals(paintContext, m_NormalmapContext))
{
TerrainPaintUtility.ReleaseContextResources(m_NormalmapContext);
m_NormalmapContext = null;
}
else if (ReferenceEquals(paintContext, m_TextureContext))
{
if (m_WriteToTexture)
{
TerrainPaintUtility.EndPaintTexture(m_TextureContext, $"{m_Name} - Texture");
}
else
{
TerrainPaintUtility.ReleaseContextResources(m_TextureContext);
}
m_TextureContext = null;
}
#if UNITY_2019_3_OR_NEWER
else if (ReferenceEquals(paintContext, m_HolesContext))
{
if (m_WriteToHoles)
{
TerrainPaintUtility.EndPaintHoles(m_HolesContext, "Terrain Paint - Paint Holes");
}
else
{
TerrainPaintUtility.ReleaseContextResources(m_HolesContext);
}
m_HolesContext = null;
}
#endif
}
public void OnSceneGUI(Terrain currentTerrain, IOnSceneGUI editContext, BrushSettings brushSettings)
{
if (m_StartTerrain != null && m_StartPoint != null)
{
// anchor is placed on the start terrain, independent of the active one; needed for multi-tiles
Terrain terrain = m_StartTerrain;
BrushTransform anchorBrushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, m_StartPoint, brushSettings.brushSize, brushSettings.brushRotationDegrees);
PaintContext anchorCtx = TerrainPaintUtility.BeginPaintHeightmap(terrain, anchorBrushXform.GetBrushXYBounds(), 1);
Material brushPreviewMat = BrushUtilities.GetDefaultBrushPreviewMaterial();
brushPreviewMat.color = anchorBrushColor;
BrushUtilities.DrawBrushPreview(anchorCtx, BrushUtilities.BrushPreview.SourceRenderTexture, editContext.brushTexture, anchorBrushXform, brushPreviewMat, 0);
TerrainPaintUtility.ReleaseContextResources(anchorCtx);
}
}
public override void OnSceneGUI(Terrain terrain, IOnSceneGUI editContext)
{
// We're only doing painting operations, early out if it's not a repaint
if (Event.current.type != EventType.Repaint)
{
return;
}
if (editContext.hitValidTerrain)
{
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.raycastHit.textureCoord, editContext.brushSize, 0.0f);
PaintContext ctx = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1);
TerrainPaintUtilityEditor.DrawBrushPreview(ctx, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture, editContext.brushTexture, brushXform, TerrainPaintUtilityEditor.GetDefaultBrushPreviewMaterial(), 0);
TerrainPaintUtility.ReleaseContextResources(ctx);
}
}
private void DrawBrushPreviews(Terrain terrain, IOnSceneGUI editContext)
{
Vector2 sampleUV;
BrushTransform sampleXform;
PaintContext sampleContext = null;
Material previewMat = TerrainPaintUtilityEditor.GetDefaultBrushPreviewMaterial();
// draw sample location brush and create context data to be used when drawing target brush previews
if (m_SampleLocation.terrain != null)
{
sampleUV = TerrainUVFromBrushLocation(m_SampleLocation.terrain, m_SampleLocation.pos);
sampleXform = TerrainPaintUtility.CalculateBrushTransform(m_SampleLocation.terrain, sampleUV, editContext.brushSize, 0);
sampleContext = TerrainPaintUtility.BeginPaintHeightmap(m_SampleLocation.terrain, sampleXform.GetBrushXYBounds());
TerrainPaintUtilityEditor.DrawBrushPreview(sampleContext, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture,
editContext.brushTexture, sampleXform, previewMat, 0);
}
// draw brush preview and mesh preview for current mouse position
if (editContext.hitValidTerrain)
{
BrushTransform targetXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.raycastHit.textureCoord, editContext.brushSize, 0f);
PaintContext targetContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, targetXform.GetBrushXYBounds(), 1);
// draw basic preview of brush
TerrainPaintUtilityEditor.DrawBrushPreview(targetContext, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture,
editContext.brushTexture, targetXform, previewMat, 0);
if (sampleContext != null && m_PaintHeightmap)
{
ApplyHeightmap(sampleContext, targetContext, targetXform, terrain, editContext.brushTexture, editContext.brushStrength);
// draw preview of brush mesh
RenderTexture.active = targetContext.oldRenderTexture;
previewMat.SetTexture("_HeightmapOrig", targetContext.sourceRenderTexture);
TerrainPaintUtilityEditor.DrawBrushPreview(targetContext, TerrainPaintUtilityEditor.BrushPreview.DestinationRenderTexture,
editContext.brushTexture, targetXform, previewMat, 1);
}
TerrainPaintUtility.ReleaseContextResources(targetContext);
}
if (sampleContext != null)
{
TerrainPaintUtility.ReleaseContextResources(sampleContext);
}
}
override public void OnSceneGUI(Terrain currentTerrain, IOnSceneGUI editContext, BrushSettings brushSettings)
{
if (editContext.hitValidTerrain)
{
Terrain terrain = currentTerrain;
// the smooth brush size is relative to the main brush size
float brushSize = brushSettings.brushSize * paintBrushSize / 100f;
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.raycastHit.textureCoord, brushSize, brushSettings.brushRotationDegrees);
PaintContext ctx = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1);
Material brushPreviewMat = BrushUtilities.GetDefaultBrushPreviewMaterial();
brushPreviewMat.color = paintBrushColor;
BrushUtilities.DrawBrushPreview(ctx, BrushUtilities.BrushPreview.SourceRenderTexture, editContext.brushTexture, brushXform, brushPreviewMat, 0);
TerrainPaintUtility.ReleaseContextResources(ctx);
}
}
private bool DoPaint(Terrain terrain, float brushStrength, Texture brushTexture, BrushTransform brushXform)
{
Rect rect = brushXform.GetBrushXYBounds();
PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1);
if (paintContext == null)
{
return(false);
}
paintContext.sourceRenderTexture.filterMode = FilterMode.Bilinear;
Material mat = GetPaintMaterial();
PaintContext maskContext = null;
if (m_TextureMask || m_TextureStencil)
{
TerrainLayer maskTerrainLayer = terrain.terrainData.terrainLayers[m_TextureMask ? m_maskIndex : m_stencilIndex];
maskContext = TerrainPaintUtility.BeginPaintTexture(terrain, rect, maskTerrainLayer);
if (maskContext == null)
{
return(false);
}
mat.SetTexture("_MaskTex", maskContext.sourceRenderTexture);
}
mat.SetInt("_MaskStencil", m_TextureMask ? 1 : (m_TextureStencil ? 2 : 0));
Vector4 brushParams = new Vector4(brushStrength, 0.0f, m_FeatureSize, 0);
mat.SetTexture("_BrushTex", brushTexture);
mat.SetVector("_BrushParams", brushParams);
TerrainPaintUtility.SetupTerrainToolMaterialProperties(paintContext, brushXform, mat);
Graphics.Blit(paintContext.sourceRenderTexture, paintContext.destinationRenderTexture, mat, 0);
TerrainPaintUtility.EndPaintHeightmap(paintContext, "Terrain Paint - Masked Smooth Sharpen");
if (maskContext != null)
{
TerrainPaintUtility.ReleaseContextResources(maskContext);
}
return(true);
}
public override bool OnPaint(Terrain terrain, IOnPaint editContext)
{
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv, editContext.brushSize, 0.0f);
Rect rect = brushXform.GetBrushXYBounds();
PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, rect, 1);
Material mat = GetPaintMaterial();
PaintContext maskContext = null;
if (m_TextureMask || m_TextureStencil)
{
TerrainLayer maskTerrainLayer = terrain.terrainData.terrainLayers[m_TextureMask ? m_maskIndex : m_stencilIndex];
maskContext = TerrainPaintUtility.BeginPaintTexture(terrain, rect, maskTerrainLayer);
if (maskContext == null)
{
return(false);
}
mat.SetTexture("_MaskTex", maskContext.sourceRenderTexture);
}
mat.SetInt("_MaskStencil", m_TextureMask ? 1 : (m_TextureStencil ? 2 : 0));
// apply brush
Vector4 brushParams = new Vector4(
editContext.brushStrength,
m_ErosionStrength,
m_MixStrength,
0.0f);
mat.SetTexture("_BrushTex", editContext.brushTexture);
mat.SetVector("_BrushParams", brushParams);
TerrainPaintUtility.SetupTerrainToolMaterialProperties(paintContext, brushXform, mat);
Graphics.Blit(paintContext.sourceRenderTexture, paintContext.destinationRenderTexture, mat, 0);
TerrainPaintUtility.EndPaintHeightmap(paintContext, "Masked Ridge Erode");
if (maskContext != null)
{
TerrainPaintUtility.ReleaseContextResources(maskContext);
}
return(false);
}
public override void OnSceneGUI(Terrain terrain, IOnSceneGUI editContext)
{
Event evt = Event.current;
if (evt.control && (evt.type == EventType.ScrollWheel))
{
const float k_mouseWheelToHeightRatio = -0.0004f;
// we use distance to modify the scroll speed, so that when a user is up close to the brush, they get fine adjustment, and when the user is far from the brush, it adjusts quickly
m_StampHeightTerrainSpace += Event.current.delta.y * k_mouseWheelToHeightRatio * editContext.raycastHit.distance;
evt.Use();
editContext.Repaint();
}
// We're only doing painting operations, early out if it's not a repaint
if (evt.type != EventType.Repaint)
{
return;
}
if (editContext.hitValidTerrain)
{
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.raycastHit.textureCoord, editContext.brushSize, 0.0f);
PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1);
Material material = TerrainPaintUtilityEditor.GetDefaultBrushPreviewMaterial();
TerrainPaintUtilityEditor.DrawBrushPreview(
paintContext, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture, editContext.brushTexture, brushXform, material, 0);
// draw result preview
{
ApplyBrushInternal(paintContext, editContext.brushStrength, editContext.brushTexture, brushXform, terrain, evt.shift);
// restore old render target
RenderTexture.active = paintContext.oldRenderTexture;
material.SetTexture("_HeightmapOrig", paintContext.sourceRenderTexture);
TerrainPaintUtilityEditor.DrawBrushPreview(
paintContext, TerrainPaintUtilityEditor.BrushPreview.DestinationRenderTexture, editContext.brushTexture, brushXform, material, 1);
}
TerrainPaintUtility.ReleaseContextResources(paintContext);
}
}
public override void OnSceneGUI(Terrain terrain, IOnSceneGUI editContext)
{
commonUI.OnSceneGUI2D(terrain, editContext);
if (editContext.hitValidTerrain || commonUI.isInUse)
{
commonUI.OnSceneGUI(terrain, editContext);
if (Event.current.type != EventType.Repaint)
{
return;
}
if (bridgeToolProperties != null && bridgeToolProperties.widthProfile != null)
{
float endWidth = Mathf.Abs(bridgeToolProperties.widthProfile.Evaluate(1.0f));
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, commonUI.raycastHitUnderCursor.textureCoord, commonUI.brushSize * endWidth, commonUI.brushRotation);
PaintContext ctx = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1);
TerrainPaintUtilityEditor.DrawBrushPreview(ctx, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture, editContext.brushTexture, brushXform, TerrainPaintUtilityEditor.GetDefaultBrushPreviewMaterial(), 0);
TerrainPaintUtility.ReleaseContextResources(ctx);
}
}
if (Event.current.type != EventType.Repaint)
{
return;
}
//display a brush preview at the bridge starting location, using starting size from width profile
if (m_StartTerrain != null)
{
float startWidth = Mathf.Abs(bridgeToolProperties.widthProfile.Evaluate(0.0f));
BrushTransform brushTransform = TerrainPaintUtility.CalculateBrushTransform(m_StartTerrain, m_StartPoint, commonUI.brushSize * startWidth, commonUI.brushRotation);
PaintContext sampleContext = TerrainPaintUtility.BeginPaintHeightmap(m_StartTerrain, brushTransform.GetBrushXYBounds());
TerrainPaintUtilityEditor.DrawBrushPreview(sampleContext, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture,
editContext.brushTexture, brushTransform, TerrainPaintUtilityEditor.GetDefaultBrushPreviewMaterial(), 0);
TerrainPaintUtility.ReleaseContextResources(sampleContext);
}
}
private void PaintHeightmap(Rect writeBrushRect, Terrain terrain, Material mat)
{
TerrainPaintUtility.PaintContext write = TerrainPaintUtility.BeginPaintHeightmap(terrain, writeBrushRect);
// read created manually to use write's rect with offset
TerrainPaintUtility.PaintContext read = new TerrainPaintUtility.PaintContext();
read.brushRect = new RectInt(write.brushRect.position + m_CloneRectPixelOffsetFromStampRect, write.brushRect.size);
// TODO(wyatt): Uncomment this once Andrew's API changes make it to trunk
read.CreateTerrainTiles(m_Sample.m_Terrain,
m_Sample.m_Terrain.terrainData.heightmapWidth,
m_Sample.m_Terrain.terrainData.heightmapHeight);
read.CreateRenderTargets(m_Sample.m_Terrain.terrainData.heightmapTexture.format);
read.GatherHeightmap(m_Sample.m_Terrain);
// render mix of clone and stamp areas
StampRender(read, write, mat, (int)ShaderPasses.CloneHeightmap);
TerrainPaintUtility.ReleaseContextResources(read);
TerrainPaintUtility.EndPaintHeightmap(write, "Terrain Paint - Clone Stamp Tool (Heightmap)");
}
public override void OnSceneGUI(Terrain terrain, IOnSceneGUI editContext)
{
// there's probably more logic we need to handle here
if (paintInProgress && (Event.current.type == EventType.MouseUp))
{
MaterialManager mgr = terrain.GetComponent <MaterialManager>();
if (mgr != null)
{
mgr.GetIndexMap().SetIndexMapDirty();
}
paintInProgress = false;
}
// We're only doing painting operations, early out if it's not a repaint
if (Event.current.type != EventType.Repaint)
{
return;
}
if (editContext.hitValidTerrain)
{
if (lastUV != editContext.raycastHit.textureCoord)
{
editContext.Repaint(RepaintFlags.UI);
}
lastUV = editContext.raycastHit.textureCoord;
lastBrushSize = editContext.brushSize;
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.raycastHit.textureCoord, editContext.brushSize, 0.0f);
PaintContext ctx = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1);
Material brushPreviewMaterial = GetBrushPreviewMaterial();
Vector4 brushParams = new Vector4(editContext.brushStrength, 0.0f, 0.0f, 0.0f);
brushPreviewMaterial.SetVector("_BrushParams", brushParams);
TerrainPaintUtilityEditor.DrawBrushPreview(ctx, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture, editContext.brushTexture, brushXform, brushPreviewMaterial, 0);
TerrainPaintUtility.ReleaseContextResources(ctx);
}
}
public override void OnSceneGUI(Terrain terrain, IOnSceneGUI editContext)
{
Event evt = Event.current;
// brush rotation
if (evt.control && !evt.shift && evt.type == EventType.ScrollWheel)
{
m_BrushRotation += Event.current.delta.y;
if (m_BrushRotation >= 360)
{
m_BrushRotation -= 360;
}
if (m_BrushRotation < 0)
{
m_BrushRotation += 360;
}
m_BrushRotation %= 360;
evt.Use();
editContext.Repaint();
}
// brush resize
if (evt.control && evt.type == EventType.MouseDrag)
{
m_BrushSize += Event.current.delta.x;
evt.Use();
editContext.Repaint();
}
// stamp height
if (evt.control && evt.shift && evt.type == EventType.ScrollWheel)
{
m_StampHeight += Event.current.delta.y * k_mouseWheelToHeightRatio * editContext.raycastHit.distance;
evt.Use();
editContext.Repaint();
}
if (evt.type != EventType.Repaint)
{
return;
}
if (editContext.hitValidTerrain)
{
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.raycastHit.textureCoord, m_BrushSize, m_BrushRotation);
PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1);
Material material = TerrainPaintUtilityEditor.GetDefaultBrushPreviewMaterial();
TerrainPaintUtilityEditor.DrawBrushPreview(paintContext, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture, editContext.brushTexture, brushXform, material, 0);
ApplyBrushInternal(paintContext, m_BrushStrength, editContext.brushTexture, brushXform, terrain);
RenderTexture.active = paintContext.oldRenderTexture;
material.SetTexture("_HeightmapOrig", paintContext.sourceRenderTexture);
TerrainPaintUtilityEditor.DrawBrushPreview(paintContext, TerrainPaintUtilityEditor.BrushPreview.DestinationRenderTexture, editContext.brushTexture, brushXform, material, 1);
TerrainPaintUtility.ReleaseContextResources(paintContext);
}
#region BrushPreview3d
if (preview3dEnabled)
{
UpdateBrushPreview3d(editContext);
}
#endregion BrushPreview3d
}
public override void OnSceneGUI(Terrain terrain, IOnSceneGUI editContext)
{
TerrainPaintUtilityEditor.ShowDefaultPreviewBrush(terrain,
editContext.brushTexture,
editContext.brushStrength,
editContext.brushSize,
0.0f);
bool drawCloneBrush = true;
// on mouse up
if (Event.current.type == EventType.MouseUp)
{
m_ActivePaint = false;
if (!m_Aligned)
{
m_Sample.m_UV = m_SnapbackCache.m_UV;
m_Sample.m_Terrain = m_SnapbackCache.m_Terrain;
m_Sample.m_Position = m_SnapbackCache.m_Position;
}
}
// on mouse move
if (Event.current.type == EventType.MouseMove || Event.current.type == EventType.MouseDrag)
{
if (m_Aligned && m_PaintedOnce)
{
RaycastHit hit;
Ray mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
terrain.GetComponent <Collider>().Raycast(mouseRay, out hit, Mathf.Infinity);
// check for moving across tiles
if (terrain != m_LastPaintLocation.m_Terrain && m_LastPaintLocation.m_Terrain != null)
{
UpdateLastPosition(hit, terrain);
}
if (m_Sample.m_Terrain != null)
{
PositionCloneBrush(hit);
}
// capture last (current) location for next frame
m_LastPaintLocation.m_UV = hit.textureCoord;
m_LastPaintLocation.m_Position = hit.point;
m_LastPaintLocation.m_Terrain = terrain;
}
if (m_Aligned && !m_PaintedOnce)
{
drawCloneBrush = false; // dont draw if we havent selected where to paint yet when aligned
}
}
// draw the clone brush preview
if (m_Sample.m_Terrain != null && drawCloneBrush)
{
Rect sampleRect = TerrainPaintUtility.CalculateBrushRectInTerrainUnits(m_Sample.m_Terrain, m_Sample.m_UV, editContext.brushSize);
TerrainPaintUtility.PaintContext ctx = TerrainPaintUtility.BeginPaintHeightmap(m_Sample.m_Terrain, sampleRect);
FilterMode prevCtxFilterMode = ctx.sourceRenderTexture.filterMode;
FilterMode prevBrushTextureFilterMode = editContext.brushTexture.filterMode;
ctx.sourceRenderTexture.filterMode = FilterMode.Bilinear;
editContext.brushTexture.filterMode = FilterMode.Bilinear;
Vector2 topLeft = ctx.brushRect.min;
float xfrac = ((topLeft.x - (int)topLeft.x) / (float)ctx.sourceRenderTexture.width);
float yfrac = ((topLeft.y - (int)topLeft.y) / (float)ctx.sourceRenderTexture.height);
Vector4 texScaleOffset = new Vector4(0.5f, 0.5f, 0.5f + xfrac + 0.5f / (float)ctx.sourceRenderTexture.width, 0.5f + yfrac + 0.5f / (float)ctx.sourceRenderTexture.height);
RaycastHit hit = new RaycastHit();
hit.point = m_Sample.m_Position;
TerrainPaintUtilityEditor.DrawDefaultBrushPreviewMesh(m_Sample.m_Terrain, hit, ctx.sourceRenderTexture, editContext.brushTexture, 0.0001f, editContext.brushSize, TerrainPaintUtilityEditor.defaultPreviewPatchMesh, true, texScaleOffset);
ctx.sourceRenderTexture.filterMode = prevCtxFilterMode;
editContext.brushTexture.filterMode = prevBrushTextureFilterMode;
TerrainPaintUtility.ReleaseContextResources(ctx);
}
}
public override void OnSceneGUI(Terrain terrain, IOnSceneGUI editContext)
{
Init();
// m_rtCollection.DebugGUI( editContext.sceneView );
brushUI.OnSceneGUI2D(terrain, editContext);
// only do the rest if user mouse hits valid terrain or they are using the
// brush parameter hotkeys to resize, etc
if (!editContext.hitValidTerrain && !brushUI.isInUse && !m_editTransform && !debugOrtho)
{
return;
}
// update brush UI group
brushUI.OnSceneGUI(terrain, editContext);
bool justPressedEditKey = m_editTransform && !m_prevEditTransform;
bool justReleaseEditKey = m_prevEditTransform && !m_editTransform;
m_prevEditTransform = m_editTransform;
if (justPressedEditKey)
{
(brushUI as MeshBrushUIGroup).LockTerrainUnderCursor(true);
m_baseHandlePos = brushUI.raycastHitUnderCursor.point;
m_handleHeightOffsetWS = 0;
}
else if (justReleaseEditKey)
{
(brushUI as MeshBrushUIGroup).UnlockTerrainUnderCursor();
m_handleHeightOffsetWS = 0;
}
// don't render mesh previews, etc. if the mesh field has not been populated yet
if (activeMesh == null)
{
return;
}
// dont render preview if this isnt a repaint. losing performance if we do
if (Event.current.type == EventType.Repaint)
{
Terrain currTerrain = brushUI.terrainUnderCursor;
Vector2 uv = brushUI.raycastHitUnderCursor.textureCoord;
float brushSize = brushUI.brushSize;
float brushRotation = brushUI.brushRotation;
if (/* debugOrtho || */ brushUI.isRaycastHitUnderCursorValid)
{
// if(debugOrtho)
// {
// uv = Vector2.one * .5f;
// }
BrushTransform brushTransform = TerrainPaintUtility.CalculateBrushTransform(currTerrain, uv, brushSize, brushRotation);
PaintContext ctx = TerrainPaintUtility.BeginPaintHeightmap(brushUI.terrainUnderCursor, brushTransform.GetBrushXYBounds(), 1);
Material material = TerrainPaintUtilityEditor.GetDefaultBrushPreviewMaterial();
// don't draw the brush mask preview
// but draw the resulting mesh stamp preview
{
ApplyBrushInternal(terrain, ctx, brushTransform);
TerrainPaintUtilityEditor.DrawBrushPreview(ctx, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture,
m_rtCollection[RenderTextureIDs.meshStamp], brushTransform, material, 0);
RenderTexture.active = ctx.oldRenderTexture;
material.SetTexture("_HeightmapOrig", ctx.sourceRenderTexture);
TerrainPaintUtility.SetupTerrainToolMaterialProperties(ctx, brushTransform, material);
TerrainPaintUtilityEditor.DrawBrushPreview(ctx, TerrainPaintUtilityEditor.BrushPreview.DestinationRenderTexture,
m_rtCollection[RenderTextureIDs.meshStamp], brushTransform, material, 1);
TerrainPaintUtility.ReleaseContextResources(ctx);
}
}
}
if (m_editTransform)
{
EditorGUI.BeginChangeCheck();
{
Vector3 prevHandlePosWS = m_baseHandlePos + Vector3.up * m_handleHeightOffsetWS;
// draw transform handles
float handleSize = HandleUtility.GetHandleSize(prevHandlePosWS);
toolSettings.scale = Handles.ScaleHandle(toolSettings.scale, prevHandlePosWS, toolSettings.rotation, handleSize * 1.5f);
Quaternion brushRotation = Quaternion.AngleAxis(brushUI.brushRotation, Vector3.up);
toolSettings.rotation = Handles.RotationHandle(toolSettings.rotation, prevHandlePosWS);
Vector3 currHandlePosWS = Handles.Slider(prevHandlePosWS, Vector3.up, handleSize, Handles.ArrowHandleCap, 1f);
float deltaHeight = (currHandlePosWS.y - prevHandlePosWS.y);
m_handleHeightOffsetWS += deltaHeight;
toolSettings.stampHeight += deltaHeight;
}
if (EditorGUI.EndChangeCheck())
{
editContext.Repaint();
SaveSettings();
}
}
}
private void DrawBrushPreviews(Terrain terrain, IOnSceneGUI editContext)
{
Vector2 sampleUV;
BrushTransform sampleXform;
PaintContext sampleContext = null;
Material previewMat = TerrainPaintUtilityEditor.GetDefaultBrushPreviewMaterial();
// draw sample location brush and create context data to be used when drawing target brush previews
if (m_SampleLocation.terrain != null)
{
sampleUV = TerrainUVFromBrushLocation(m_SampleLocation.terrain, m_SampleLocation.pos);
sampleXform = TerrainPaintUtility.CalculateBrushTransform(m_SampleLocation.terrain, sampleUV, commonUI.brushSize, commonUI.brushRotation);
sampleContext = TerrainPaintUtility.BeginPaintHeightmap(m_SampleLocation.terrain, sampleXform.GetBrushXYBounds());
TerrainPaintUtilityEditor.DrawBrushPreview(sampleContext, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture,
editContext.brushTexture, sampleXform, previewMat, 0);
}
// draw brush preview and mesh preview for current mouse position
if (commonUI.isRaycastHitUnderCursorValid)
{
BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, commonUI.raycastHitUnderCursor.textureCoord, commonUI.brushSize, commonUI.brushRotation);
PaintContext ctx = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1);
TerrainPaintUtilityEditor.DrawBrushPreview(ctx, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture, editContext.brushTexture, brushXform, TerrainPaintUtilityEditor.GetDefaultBrushPreviewMaterial(), 0);
if (sampleContext != null && cloneToolProperties.m_PaintHeightmap)
{
ApplyHeightmap(sampleContext, ctx, brushXform, terrain, editContext.brushTexture, commonUI.brushStrength);
RenderTexture.active = ctx.oldRenderTexture;
previewMat.SetTexture("_HeightmapOrig", ctx.sourceRenderTexture);
TerrainPaintUtilityEditor.DrawBrushPreview(ctx, TerrainPaintUtilityEditor.BrushPreview.DestinationRenderTexture,
editContext.brushTexture, brushXform, previewMat, 1);
}
TerrainPaintUtility.ReleaseContextResources(ctx);
/*
* BrushTransform targetXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.raycastHit.textureCoord, editContext.brushSize, 0f);
* PaintContext targetContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, targetXform.GetBrushXYBounds(), 1);
*
* // draw basic preview of brush
* TerrainPaintUtilityEditor.DrawBrushPreview(targetContext, TerrainPaintUtilityEditor.BrushPreview.SourceRenderTexture,
* editContext.brushTexture, targetXform, previewMat, 0);
*
* if (sampleContext != null && m_PaintHeightmap)
* {
* ApplyHeightmap(sampleContext, targetContext, targetXform, terrain, editContext.brushTexture, brushIntensity.brushStrength);
*
* // draw preview of brush mesh
* RenderTexture.active = targetContext.oldRenderTexture;
* previewMat.SetTexture("_HeightmapOrig", targetContext.sourceRenderTexture);
* TerrainPaintUtilityEditor.DrawBrushPreview(targetContext, TerrainPaintUtilityEditor.BrushPreview.DestinationRenderTexture,
* editContext.brushTexture, targetXform, previewMat, 1);
* }
*
* TerrainPaintUtility.ReleaseContextResources(targetContext);
*/
}
if (sampleContext != null)
{
TerrainPaintUtility.ReleaseContextResources(sampleContext);
}
}
