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(); 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 - Smudge Height"); m_PrevBrushPos = editContext.uv; } m_PreviousEvent = Event.current.type; return(false); }
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); PaintContext paintContext = TerrainPaintUtility.BeginPaintTexture(terrain, brushXform.GetBrushXYBounds(), m_SelectedTerrainLayer); if (paintContext == null) { return(false); } Material mat = TerrainPaintUtility.GetBuiltinPaintMaterial(); // apply brush float targetAlpha = 1.0f; // always 1.0 now -- no subtractive painting (we assume this in the ScatterAlphaMap) Vector4 brushParams = new Vector4(editContext.brushStrength, targetAlpha, 0.0f, 0.0f); mat.SetTexture("_BrushTex", editContext.brushTexture); mat.SetVector("_BrushParams", brushParams); TerrainPaintUtility.SetupTerrainToolMaterialProperties(paintContext, brushXform, mat); Graphics.Blit(paintContext.sourceRenderTexture, paintContext.destinationRenderTexture, mat, (int)TerrainPaintUtility.BuiltinPaintMaterialPasses.PaintTexture); TerrainPaintUtility.EndPaintTexture(paintContext, "Terrain Paint - Texture"); return(true); }
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 bool OnPaint(Terrain terrain, IOnPaint editContext) { Vector2 uv = editContext.uv; if (Event.current.shift) { height = terrain.terrainData.GetInterpolatedHeight(uv.x, uv.y) / terrain.terrainData.size.y; return(true); } BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv, editContext.brushSize, 0.0f); PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1); paintContext.sourceRenderTexture.filterMode = FilterMode.Bilinear; Material mat = GetPaintMaterial(); int currentMode = (int)mode; if (Event.current.control) { currentMode *= -1; } float modeValue = Mathf.Clamp01(currentMode); Vector4 brushParams = new Vector4(editContext.brushStrength, 0.5f * height, modeValue, 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 - Directional Flatten Height"); return(false); }
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); }
public override bool OnPaint(Terrain terrain, IOnPaint editContext) { Init(); commonUI.OnPaint(terrain, editContext); if (commonUI.allowPaint) { Vector2 uv = editContext.uv; if (commonUI.ScatterBrushStamp(ref terrain, ref uv)) { BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, uv, commonUI.brushSize, commonUI.brushRotation); PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds()); float brushStrength = Event.current.control ? -commonUI.brushStrength : commonUI.brushStrength; Vector3 brushPosWS = WSPosFromTerrainUV(terrain, uv); ApplyBrushInternal(paintContext, brushXform, brushPosWS, commonUI.brushRotation, brushStrength, commonUI.brushSize, editContext.brushTexture); TerrainPaintUtility.EndPaintHeightmap(paintContext, "Terrain Paint - Noise"); } } editContext.Repaint(RepaintFlags.UI); return(true); }
public bool OnPaint(Terrain terrain, IOnPaint editContext, float brushSize, float brushRotation, float brushStrength, Vector2 uv) { if (Event.current != null && Event.current.shift) { BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, uv, brushSize, brushRotation); PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds()); Material mat = GetMaterial(); //TerrainPaintUtility.GetBuiltinPaintMaterial(); float m_direction = 0.0f; //TODO: UI for this Vector4 brushParams = new Vector4(brushStrength, 0.0f, 0.0f, 0.0f); mat.SetTexture("_BrushTex", editContext.brushTexture); mat.SetVector("_BrushParams", brushParams); Vector4 smoothWeights = new Vector4( Mathf.Clamp01(1.0f - Mathf.Abs(m_direction)), // centered Mathf.Clamp01(-m_direction), // min Mathf.Clamp01(m_direction), // max kernelSize); // blur kernel size mat.SetVector("_SmoothWeights", smoothWeights); TerrainPaintUtility.SetupTerrainToolMaterialProperties(paintContext, brushXform, mat); RenderTexture temp = RenderTexture.GetTemporary(paintContext.destinationRenderTexture.descriptor); Graphics.Blit(paintContext.sourceRenderTexture, temp, mat, 0); Graphics.Blit(temp, paintContext.destinationRenderTexture, mat, 1); RenderTexture.ReleaseTemporary(temp); TerrainPaintUtility.EndPaintHeightmap(paintContext, "Terrain Paint - Smooth Height"); return(true); } return(false); }
private void PaintAlphamap(Terrain sampleTerrain, Terrain targetTerrain, BrushTransform sampleXform, BrushTransform targetXform, Material mat) { Rect sampleRect = sampleXform.GetBrushXYBounds(); Rect targetRect = targetXform.GetBrushXYBounds(); int numSampleTerrainLayers = sampleTerrain.terrainData.terrainLayers.Length; for (int i = 0; i < numSampleTerrainLayers; ++i) { TerrainLayer layer = sampleTerrain.terrainData.terrainLayers[i]; if (layer == null) { continue; // nothing to paint if the layer is NULL } PaintContext sampleContext = TerrainPaintUtility.BeginPaintTexture(sampleTerrain, sampleRect, layer); // manually create target context since we are possibly applying another terrain's layers and not its own int layerIndex = TerrainPaintUtility.FindTerrainLayerIndex(sampleTerrain, layer); Texture2D layerTexture = TerrainPaintUtility.GetTerrainAlphaMapChecked(sampleTerrain, layerIndex >> 2); PaintContext targetContext = PaintContext.CreateFromBounds(targetTerrain, targetRect, layerTexture.width, layerTexture.height); targetContext.CreateRenderTargets(RenderTextureFormat.R8); targetContext.GatherAlphamap(layer, true); sampleContext.sourceRenderTexture.filterMode = FilterMode.Point; mat.SetTexture("_CloneTex", sampleContext.sourceRenderTexture); Graphics.Blit(targetContext.sourceRenderTexture, targetContext.destinationRenderTexture, mat, (int)ShaderPasses.CloneAlphamap); // apply texture modifications and perform cleanup. same thing as calling TerrainPaintUtility.EndPaintTexture targetContext.ScatterAlphamap("Terrain Paint - Clone Brush (Texture)"); targetContext.Cleanup(); } }
public override bool OnPaint(Terrain terrain, IOnPaint editContext) { if (!m_isPainting || m_SampleLocation.terrain == null) { return(true); } // grab brush transforms for the sample location (where we are cloning from) // and target location (where we are cloning to) Vector2 sampleUV = TerrainUVFromBrushLocation(m_SampleLocation.terrain, m_SampleLocation.pos); BrushTransform sampleBrushXform = TerrainPaintUtility.CalculateBrushTransform(m_SampleLocation.terrain, sampleUV, editContext.brushSize, 1); BrushTransform targetBrushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv, editContext.brushSize, 1); // set material props that will be used for both heightmap and alphamap painting Material mat = GetPaintMaterial(); Vector4 brushParams = new Vector4(editContext.brushStrength, m_StampingOffsetFromClone * 0.5f, terrain.terrainData.size.y, 0f); mat.SetTexture("_BrushTex", editContext.brushTexture); mat.SetVector("_BrushParams", brushParams); // apply texture modifications to terrain if (m_PaintAlphamap) { PaintAlphamap(m_SampleLocation.terrain, terrain, sampleBrushXform, targetBrushXform, mat); } if (m_PaintHeightmap) { PaintHeightmap(m_SampleLocation.terrain, terrain, sampleBrushXform, targetBrushXform, editContext, mat); } return(false); }
private bool Smooth(Terrain terrain, IOnPaint editContext, Vector2 currUV, BrushSettings brushSettings) { // the brush size is relative to the main brush size float brushSize = brushSettings.brushSize * this.smoothBrushSize / 100f; BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv, brushSize, brushSettings.brushRotationDegrees); PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds()); Material mat = TerrainPaintUtility.GetBuiltinPaintMaterial(); float brushStrength = smoothBrushStrength / 100f; // editContext.brushStrength; // brushStrength = Event.current.shift ? -brushStrength : brushStrength; Vector4 brushParams = new Vector4(brushStrength, 0.0f, 0.0f, 0.0f); mat.SetTexture("_BrushTex", editContext.brushTexture); mat.SetVector("_BrushParams", brushParams); TerrainPaintUtility.SetupTerrainToolMaterialProperties(paintContext, brushXform, mat); Graphics.Blit(paintContext.sourceRenderTexture, paintContext.destinationRenderTexture, mat, (int)TerrainPaintUtility.BuiltinPaintMaterialPasses.SmoothHeights); TerrainPaintUtility.EndPaintHeightmap(paintContext, "Terrain Paint - Smooth Height"); return(true); }
private bool Bridge(Terrain terrain, IOnPaint editContext, Vector2 currUV, float pct, Vector3 stroke, Vector3 startPoint) { float heightOffset = heightProfile.Evaluate(pct) / terrain.terrainData.size.y; float strengthScale = strengthProfile.Evaluate(pct); float widthScale = widthProfile.Evaluate(pct); float finalHeight = (startPoint + pct * stroke).z + heightOffset; int finalBrushSize = (int)(widthScale * (float)editContext.brushSize); BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, currUV, finalBrushSize, 0.0f); PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds()); Material mat = GetMaterial(); Vector4 brushParams = new Vector4(); mat.SetTexture("_BrushTex", editContext.brushTexture); brushParams.x = editContext.brushStrength * strengthScale; brushParams.y = 0.5f * finalHeight; mat.SetVector("_BrushParams", brushParams); TerrainPaintUtility.SetupTerrainToolMaterialProperties(paintContext, brushXform, mat); Graphics.Blit(paintContext.sourceRenderTexture, paintContext.destinationRenderTexture, mat, 0); TerrainPaintUtility.EndPaintHeightmap(paintContext, "Terrain Paint - Bridge"); return(true); }
public override bool OnPaint(Terrain terrain, IOnPaint editContext) { Init(); if (activeMesh == null || Event.current.type != EventType.MouseDown || Event.current.shift == true || m_editTransform) { return(false); } brushUI.OnPaint(terrain, editContext); if (brushUI.allowPaint) { Texture brushTexture = editContext.brushTexture; BrushTransform brushTransform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv, brushUI.brushSize, brushUI.brushRotation); PaintContext ctx = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushTransform.GetBrushXYBounds()); ApplyBrushInternal(terrain, ctx, brushTransform); TerrainPaintUtility.EndPaintHeightmap(ctx, "Mesh Stamp - Stamp Mesh"); } return(true); }
public override bool OnPaint(Terrain terrain, IOnPaint editContext) { commonUI.OnPaint(terrain, editContext); if (commonUI.allowPaint) { Texture brushTexture = editContext.brushTexture; using (IBrushRenderUnderCursor brushRender = new BrushRenderUIGroupUnderCursor(commonUI, "PaintHoles", brushTexture)) { Vector2 halfTexelOffset = new Vector2(0.5f / terrain.terrainData.holesResolution, 0.5f / terrain.terrainData.holesResolution); BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv - halfTexelOffset, commonUI.brushSize, commonUI.brushRotation); PaintContext paintContext = brushRender.AquireHolesTexture(true, brushXform.GetBrushXYBounds()); PaintContext paintContextHeight = brushRender.AcquireHeightmap(false, brushXform.GetBrushXYBounds()); // filter stack Material mat = Utility.GetPaintHeightMaterial(); var brushMask = RTUtils.GetTempHandle(paintContextHeight.sourceRenderTexture.width, paintContextHeight.sourceRenderTexture.height, 0, FilterUtility.defaultFormat); Utility.SetFilterRT(commonUI, paintContextHeight.sourceRenderTexture, brushMask, mat); // hold control key to erase float brushStrength = Event.current.control ? commonUI.brushStrength : -commonUI.brushStrength; Vector4 brushParams = new Vector4(brushStrength, 0.0f, 0.0f, 0.0f); mat.SetTexture("_BrushTex", editContext.brushTexture); mat.SetVector("_BrushParams", brushParams); brushRender.SetupTerrainToolMaterialProperties(paintContext, brushXform, mat); brushRender.RenderBrush(paintContext, mat, (int)TerrainBuiltinPaintMaterialPasses.PaintHoles); TerrainPaintUtility.EndPaintHoles(paintContext, "Terrain Paint - Paint Holes"); RTUtils.Release(brushMask); } } return(true); }
private bool Height(Terrain terrain, IOnPaint editContext, Vector2 currUV, Vector2 prevUV) { // the brush size is relative to the main brush size float brushSize = editContext.brushSize * heightBrushSize / 100f; BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, currUV, brushSize, 0.0f); PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1); paintContext.sourceRenderTexture.filterMode = FilterMode.Bilinear; Material mat = TerrainPaintUtility.GetBuiltinPaintMaterial(); float brushStrength = heightBrushStrength / 100f; brushStrength = Event.current.shift ? -brushStrength : brushStrength; brushStrength *= 0.001f; // magic number ... Vector4 brushParams = new Vector4(brushStrength, 0.0f, 0.0f, 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, "Terrain Paint - Raise or Lower Height"); return(true); }
public override bool OnPaint(Terrain terrain, IOnPaint editContext) { BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv, editContext.brushSize, 0.0f); PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1); float finalPinchAmount = m_PinchAmount * 0.005f; //scale to a reasonable value and negate so default mode is clockwise if (Event.current.shift) { finalPinchAmount *= -1.0f; } paintContext.sourceRenderTexture.filterMode = FilterMode.Bilinear; Material mat = GetPaintMaterial(); Vector4 brushParams = new Vector4(editContext.brushStrength, 0.0f, finalPinchAmount, 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, "Terrain Paint - Pinch Height"); return(false); }
public override bool OnPaint(Terrain terrain, IOnPaint editContext) { BrushTransform targetBrushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv, editContext.brushSize, 1); Material mat = GetPaintMaterial(); Vector4 brushParams = new Vector4(editContext.brushStrength, 0, 0, 0f); mat.SetTexture("_BrushTex", editContext.brushTexture); mat.SetVector("_BrushParams", brushParams); Rect targetRect = targetBrushXform.GetBrushXYBounds(); int numSampleTerrainLayers = terrain.terrainData.terrainLayers.Length; for (int i = 0; i < numSampleTerrainLayers; ++i) { TerrainLayer layer = terrain.terrainData.terrainLayers[i]; if (layer == null) { continue; } int layerIndex = TerrainPaintUtility.FindTerrainLayerIndex(terrain, layer); Texture2D layerTexture = TerrainPaintUtility.GetTerrainAlphaMapChecked(terrain, layerIndex >> 2); PaintContext targetContext = PaintContext.CreateFromBounds(terrain, targetRect, layerTexture.width, layerTexture.height); targetContext.CreateRenderTargets(RenderTextureFormat.R8); targetContext.GatherAlphamap(layer, true); Graphics.Blit(targetContext.sourceRenderTexture, targetContext.destinationRenderTexture, mat, 0); TerrainPaintUtility.EndPaintTexture(targetContext, "Terrain Paint - Smooth Splatmaps"); } return(false); }
private bool PaintTexture(Terrain terrain, IOnPaint editContext, Vector2 currUV) { // the brush size is relative to the main brush size float brushSize = editContext.brushSize * paintBrushSize / 100f; BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, currUV, brushSize, 0.0f); PaintContext paintContext = TerrainPaintUtility.BeginPaintTexture(terrain, brushXform.GetBrushXYBounds(), m_SelectedInnerTerrainLayer); if (paintContext == null) { return(false); } Material mat = TerrainPaintUtility.GetBuiltinPaintMaterial(); float targetAlpha = 1.0f; // always 1.0 now -- no subtractive painting (we assume this in the ScatterAlphaMap) float brushStrength = paintBrushStrength / 100f; // editContext.brushStrength // apply brush Vector4 brushParams = new Vector4(brushStrength, targetAlpha, 0.0f, 0.0f); mat.SetTexture("_BrushTex", editContext.brushTexture); mat.SetVector("_BrushParams", brushParams); TerrainPaintUtility.SetupTerrainToolMaterialProperties(paintContext, brushXform, mat); Graphics.Blit(paintContext.sourceRenderTexture, paintContext.destinationRenderTexture, mat, (int)TerrainPaintUtility.BuiltinPaintMaterialPasses.PaintTexture); TerrainPaintUtility.EndPaintTexture(paintContext, "Terrain Paint - Texture"); return(true); }
private bool Smudge(Terrain terrain, IOnPaint editContext, Vector2 currUV, Vector2 prevUV) { // the brush size is relative to the main brush size float brushSize = editContext.brushSize * ridgeErodeBrushSize / 100f; BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, currUV, brushSize, 0.0f); PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds(), 1); Vector2 smudgeDir = editContext.uv - prevUV; paintContext.sourceRenderTexture.filterMode = FilterMode.Bilinear; Material mat = GetMaterial(); float brushStrength = ridgeErodeBrushStrength / 100f; // editContext.brushStrength; Vector4 brushParams = new Vector4(brushStrength, erosionStrength, mixStrength, 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 - Ridge Erode"); return(true); }
public override bool OnPaint(Terrain terrain, IOnPaint editContext) { BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv, editContext.brushSize, 0.0f); float sign = Event.current.shift?-1.0f:1.0f; return(DoPaint(terrain, editContext.brushStrength * sign, editContext.brushTexture, brushXform)); }
/// <summary> /// This is the handler that is called when one of the gizmo is moved. /// </summary> /// <param name="gizmo"> /// The gizmo that was dragged. /// </param> /// <param name="handleId"> /// The id of the handle that is being dragged. /// </param> private void OnGizmoDragUpdate(Gizmo gizmo, int handleId) { // This is where we want to adjust the position of the TerrainData heights for mesh control points // and change the terrain height. First, we need to check the drag // channel. The drag channel informs us about the kind of drag that is // being applied (offset, rotation or scale). Tt will most // likely always be offset, but it's safer to always check. if (gizmo.ActiveDragChannel == GizmoDragChannel.Offset) { #if FALSE Vector3 pos = transform.position; Vector2 pos2 = new Vector2(pos.x, pos.z); BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(theTerrain, pos2, gcount, 0.0f); PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(theTerrain, brushXform.GetBrushXYBounds(), 1); //float finalPinchAmount = m_PinchAmount * 0.005f; //scale to a reasonable value and negate so default mode is clockwise //if (Event.current.shift) //{ // finalPinchAmount *= -1.0f; //} paintContext.sourceRenderTexture.filterMode = FilterMode.Bilinear; Material mat = GetPaintMaterial(); Vector4 brushParams = new Vector4(1.0f, 0.0f, 1.0f /*finalPinchAmount*/, 0.0f); mat.SetFloatArray("_Brush", grid); mat.SetFloat("_BrushSize", gcount); mat.SetVector("_BrushParams", brushParams); TerrainPaintUtility.SetupTerrainToolMaterialProperties(paintContext, brushXform, mat); Graphics.Blit(paintContext.sourceRenderTexture, paintContext.destinationRenderTexture, mat, 0); TerrainPaintUtility.EndPaintHeightmap(paintContext, null); #endif // We are offsetting the gizmo. Good. Now we need to apply the drag offset to the TerrainData (or mesh control point) // associated with the gizmo. // Note: pseudo code to adjust TerrainData heights. // The gizmo positions and terrain heights don't match up after a gizmo move - this pseudo code is just meant to show the concept. // Depending on what we come up with, I feel a terrain mesh with vertice control points might be the best method? // Get the amount of height change from the gizmo move. switch (interpolation) { case Interpolation.Bilinear: UpdateTerrainBilinear(gizmo); break; case Interpolation.Bicubic: UpdateTerrainBicubic(gizmo); break; } // ideally use a mesh instead of TerrainData and change control points? e.g. controlPoint.Position += dragOffset; // The control point could be moved using the amount of drag that was applied to the gizmo. // As I mentioned, the the Ogre application I did, the terrain was a mesh generated by creating a spline from control points // and tessellated into a mesh so the result from the spline was a fairly smooth mesh. // I'm open to the best method we can come up with that is easy for the user to adjust terrain with and also allow importing // of control points from 2D CAD data to build the mesh. } }
public override bool OnPaint(Terrain terrain, IOnPaint editContext) { BrushTransform brushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv, editContext.brushSize, 0.0f); PaintContext paintContext = TerrainPaintUtility.BeginPaintHeightmap(terrain, brushXform.GetBrushXYBounds()); ApplyBrushInternal(paintContext, editContext.brushStrength, editContext.brushTexture, brushXform); TerrainPaintUtility.EndPaintHeightmap(paintContext, "Terrain Paint - Smooth Height"); return(true); }
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); }
protected override bool CalculateTransform(ref Terrain terrain, out BrushTransform brushTransform) { Vector2 uv = textureCoordUnderCursor; float brushSize = uiGroup.brushSize; float brushRotation = uiGroup.brushRotation; // TODO: Remove this method and replace the preview with a radius effect and scatter at the correct position... brushTransform = TerrainPaintUtility.CalculateBrushTransform(terrain, uv, brushSize, brushRotation); return(true); }
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); } }
internal static BrushTransform GetBrushTransform(float rotation, float brushSize) { float f = rotation * Mathf.Deg2Rad; float num = Mathf.Cos(f); float x = Mathf.Sin(f); Vector2 brushU = new Vector2(num, -x) * brushSize; Vector2 brushV = new Vector2(x, num) * brushSize; var brushTransform = new BrushTransform(Vector2.zero - 0.5f * brushU - 0.5f * brushV, brushU, brushV); return(brushTransform); }
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); } }
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, commonUI.brushStrength); TerrainPaintUtility.EndPaintHeightmap(targetContext, "Terrain Paint - Clone Brush (Heightmap)"); // Restores RenderTexture.active sampleContext.Cleanup(); targetContext.Cleanup(); }
public virtual bool CalculateBrushTransform(Terrain terrain, Vector2 uv, float size, float rotation, out BrushTransform brushTransform) { if (m_UiGroup.ScatterBrushStamp(ref terrain, ref uv)) { brushTransform = TerrainPaintUtility.CalculateBrushTransform(terrain, uv, size, rotation); return(true); } else { brushTransform = new BrushTransform(); return(false); } }
public static d.Brush ToGdiPlus(this LinearGradientBrush brush, Rect bounds) { var db = CheckDegenerate(brush); if (db != null) return db; var bt = new BrushTransform(brush, bounds); if (bt.DegenerateBrush != null) return bt.DegenerateBrush; var start = brush.StartPoint; var end = brush.EndPoint; if (brush.MappingMode == BrushMappingMode.RelativeToBoundingBox) { start = bt.ToAbsolute.Transform(start); end = bt.ToAbsolute.Transform(end); } var wm = brush.SpreadMethod.ToGdiPlus(); if (wm == d2.WrapMode.Clamp) { wm = d2.WrapMode.TileFlipX; var delta = (bounds.BottomRight - bounds.TopLeft).Length / (bt.ToBrush.Transform(end) - bt.ToBrush.Transform(start)).Length; var diff = delta * (end - start); start -= diff; end += diff; brush = brush.Clone(); var g = brush.GradientStops; g.Insert(0, new GradientStop(g[0].Color, -delta)); g.Add(new GradientStop(g[g.Count - 1].Color, delta + 1)); } var b = new d2.LinearGradientBrush(start.ToGdiPlus(), end.ToGdiPlus(), d.Color.Black, d.Color.White); b.InterpolationColors = ConvertGradient(brush); b.WrapMode = wm; b.MultiplyTransform(bt.ToBrush.ToGdiPlus(), d2.MatrixOrder.Append); return b; }
public static d.Brush ToGdiPlus(this RadialGradientBrush brush, Rect bounds) { var db = CheckDegenerate(brush); if (db != null) return db; var bt = new BrushTransform(brush, bounds); if (bt.DegenerateBrush != null) return bt.DegenerateBrush; var center = brush.Center; var focus = brush.GradientOrigin; var size = new Vector(brush.RadiusX, brush.RadiusY); if (brush.MappingMode == BrushMappingMode.RelativeToBoundingBox) { center = bt.ToAbsolute.Transform(center); focus = bt.ToAbsolute.Transform(focus); size = bt.ToAbsolute.Transform(size); } var ts = bt.ToBrush.Transform(size); var delta = (int)Math.Ceiling(4 * (bounds.BottomRight - bounds.TopLeft).Length / Math.Min(Math.Abs(ts.X), Math.Abs(ts.Y))); size *= delta; center += (delta - 1) * (center - focus); brush = brush.Clone(); var g = brush.GradientStops; var last = g.Count - 1; var offset = 1.00000001; switch(brush.SpreadMethod) { case GradientSpreadMethod.Pad: g.Add(new GradientStop(g[last].Color, delta)); break; case GradientSpreadMethod.Repeat: for(var i = 0; i < delta; ++i) for(var j = 0; j <= last; ++j) g.Add(new GradientStop(g[j].Color, i + g[j].Offset + (j == last ? 1 : offset))); break; case GradientSpreadMethod.Reflect: for(var i = 0; i < delta; ++i) if (i % 2 == 0) for(var j = 0; j <= last; ++j) g.Add(new GradientStop(g[j].Color, i + (1 - g[j].Offset) + (j == 0 ? 1 : offset))); else for(var j = 0; j <= last; ++j) g.Add(new GradientStop(g[j].Color, i + g[j].Offset + (j == last ? 1 : offset))); break; } var b = new d2.PathGradientBrush(new EllipseGeometry(center, size.X, size.Y).ToGdiPlus()); b.CenterPoint = focus.ToGdiPlus(); b.InterpolationColors = ConvertGradient(brush); b.WrapMode = brush.SpreadMethod.ToGdiPlus(); b.MultiplyTransform(bt.ToBrush.ToGdiPlus(), d2.MatrixOrder.Append); return b; }
public static d.Brush ToGdiPlus(this ImageBrush brush, Rect bounds) { var img = brush.ImageSource; var bt = new BrushTransform(brush, bounds); if (bt.DegenerateBrush != null) return bt.DegenerateBrush; var viewbox = brush.Viewbox; if (brush.ViewboxUnits == BrushMappingMode.RelativeToBoundingBox) viewbox.Scale(img.Width, img.Height); var viewport = brush.Viewport; if (brush.ViewportUnits == BrushMappingMode.RelativeToBoundingBox) viewport.Transform(bt.ToAbsolute); var ia = new di.ImageAttributes(); ia.SetColorMatrix(new di.ColorMatrix { Matrix33 = (float)brush.Opacity }); var b = new d.TextureBrush(img.ToGdiPlus(), viewbox.ToGdiPlus(), ia); b.WrapMode = brush.TileMode.ToGdiPlus(); b.TranslateTransform((float)viewport.X, (float)viewport.Y); b.ScaleTransform((float)(viewport.Width/viewbox.Width), (float)(viewport.Height/viewbox.Height)); b.MultiplyTransform(bt.ToBrush.ToGdiPlus(), d2.MatrixOrder.Append); return b; }