public override void OnInspectorGUI()
{
EditorGUI.BeginChangeCheck();
GUI.enabled = !GEditorSettings.Instance.splineTools.showTransformGizmos;
instance.GroupId = GEditorCommon.ActiveTerrainGroupPopupWithAllOption("Group Id", instance.GroupId);
GEditorSettings.Instance.splineTools.raycastLayer = EditorGUILayout.LayerField("Raycast Layer", GEditorSettings.Instance.splineTools.raycastLayer);
GEditorSettings.Instance.splineTools.autoTangent = EditorGUILayout.Toggle("Auto Tangent", GEditorSettings.Instance.splineTools.autoTangent);
instance.EnableTerrainMask = EditorGUILayout.Toggle("Enable Terrain Mask", instance.EnableTerrainMask);
GEditorSettings.Instance.topographic.enable = EditorGUILayout.Toggle("Enable Topographic", GEditorSettings.Instance.topographic.enable);
DrawInstructionGUI();
GUI.enabled = true;
DrawTransformGUI();
GUI.enabled = !GEditorSettings.Instance.splineTools.showTransformGizmos;
DrawAnchorDefaultValueGUI();
DrawSelectedAnchorGUI();
DrawSegmentDefaultValueGUI();
DrawSelectedSegmentGUI();
DrawGizmosGUI();
DrawActionsGUI();
GEditorCommon.DrawBackupHelpBox();
GUI.enabled = false;
//DrawDebugGUI();
if (EditorGUI.EndChangeCheck())
{
instance.Editor_Vertices = instance.GenerateVerticesWithFalloff();
GSplineCreator.MarkSplineChanged(instance);
GUtilities.MarkCurrentSceneDirty();
}
}
private void RemoveGrassOnTerrain(GStylizedTerrain t, Color[] maskData)
{
GGrassPatch[] patches = t.TerrainData.Foliage.GrassPatches;
for (int p = 0; p < patches.Length; ++p)
{
for (int i = 0; i < GrassPrototypeIndices.Count; ++i)
{
int grassIndex = GrassPrototypeIndices[i];
int removedInstanceCount = patches[p].Instances.RemoveAll(grass =>
{
if (grass.PrototypeIndex != grassIndex)
{
return(false);
}
Vector2 uv = new Vector2(grass.Position.x, grass.Position.z);
float alpha = GUtilities.GetColorBilinear(maskData, MaskResolution, MaskResolution, uv).r;
return(Random.value <= alpha);
});
if (removedInstanceCount > 0)
{
t.TerrainData.Foliage.SetGrassRegionDirty(patches[p].GetUvRange());
}
}
}
}
private void DrawCursorProjected(GStylizedTerrain t)
{
for (int i = 0; i < normalizedPoints.Length; ++i)
{
normalizedPoints[i] = t.WorldPointToUV(worldPoints[i]);
}
Rect dirtyRect = GUtilities.GetRectContainsPoints(normalizedPoints);
GTerrainChunk[] chunks = t.GetChunks();
for (int i = 0; i < chunks.Length; ++i)
{
Rect uvRect = chunks[i].GetUvRange();
if (!uvRect.Overlaps(dirtyRect))
{
continue;
}
Mesh m = chunks[i].MeshFilterComponent.sharedMesh;
if (m == null)
{
continue;
}
Graphics.DrawMeshNow(
m,
Matrix4x4.TRS(chunks[i].transform.position, chunks[i].transform.rotation, chunks[i].transform.lossyScale));
}
}
public void Editor_DrawLivePreview(GStylizedTerrain terrain, GTexturePainterArgs args, Camera cam)
{
#if UNITY_EDITOR
Vector2[] uvCorners = new Vector2[args.WorldPointCorners.Length];
for (int i = 0; i < uvCorners.Length; ++i)
{
uvCorners[i] = terrain.WorldPointToUV(args.WorldPointCorners[i]);
}
Rect dirtyRect = GUtilities.GetRectContainsPoints(uvCorners);
if (!dirtyRect.Overlaps(new Rect(0, 0, 1, 1)))
{
return;
}
Texture2D bg = terrain.TerrainData.Geometry.HeightMap;
int heightMapResolution = terrain.TerrainData.Geometry.HeightMapResolution;
RenderTexture rt = GTerrainTexturePainter.Internal_GetRenderTexture(terrain, heightMapResolution);
GCommon.CopyToRT(bg, rt);
Texture2D remapTex = GCommon.CreateTextureFromCurve(GTexturePainterCustomParams.Instance.Remap.Curve, 512, 1);
Material mat = GInternalMaterials.RemapPainterMaterial;
mat.SetTexture("_MainTex", bg);
mat.SetTexture("_Mask", args.Mask);
mat.SetFloat("_Opacity", args.Opacity);
mat.SetTexture("_RemapTex", remapTex);
int pass = 0;
GCommon.DrawQuad(rt, uvCorners, mat, pass);
GLivePreviewDrawer.DrawGeometryLivePreview(terrain, cam, rt, dirtyRect);
GUtilities.DestroyObject(remapTex);
#endif
}
private void Apply(GStylizedTerrain t)
{
if (t.TerrainData == null)
{
return;
}
RenderTexture rt = new RenderTexture(MaskResolution, MaskResolution, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
List <Vector4> vertices = SplineCreator.GenerateVerticesWithFalloff();
Internal_Apply(t, rt, vertices);
Texture2D mask = GCommon.CreateTexture(MaskResolution, Color.clear);
GCommon.CopyFromRT(mask, rt);
mask.wrapMode = TextureWrapMode.Clamp;
Color[] maskColors = mask.GetPixels();
if (RemoveTrees)
{
RemoveTreeOnTerrain(t, maskColors);
}
if (RemoveGrasses)
{
RemoveGrassOnTerrain(t, maskColors);
t.UpdateGrassPatches();
}
t.TerrainData.Foliage.ClearGrassDirtyRegions();
t.TerrainData.SetDirty(GTerrainData.DirtyFlags.Foliage);
rt.Release();
GUtilities.DestroyObject(rt);
GUtilities.DestroyObject(mask);
}
private void DoExportRaw8()
{
int rawResolution = SrcData.Geometry.HeightMapResolution + 1;
byte[] data = new byte[rawResolution * rawResolution];
Vector2 uv = Vector2.zero;
Color c = Color.white;
Vector2 enc = Vector2.zero;
byte h = 0;
for (int z = 0; z < rawResolution; ++z)
{
for (int x = 0; x < rawResolution; ++x)
{
uv.Set(
Mathf.InverseLerp(0, rawResolution - 1, x),
1 - Mathf.InverseLerp(0, rawResolution - 1, z));
c = SrcData.Geometry.HeightMap.GetPixelBilinear(uv.x, uv.y);
enc.Set(c.r, c.g);
h = (byte)(GCommon.DecodeFloatRG(enc) * byte.MaxValue);
data[GUtilities.To1DIndex(x, z, rawResolution)] = h;
}
}
GUtilities.EnsureDirectoryExists(DataDirectory);
string fileName = string.Format("RAW8_{0}x{0}_{1}.raw", rawResolution, SrcData.Id);
string path = Path.Combine(DataDirectory, fileName);
File.WriteAllBytes(path, data);
#if UNITY_EDITOR
AssetDatabase.Refresh();
#endif
}
public static BillboardAsset CreateBillboardAsset(GBillboardCreatorArgs args)
{
BillboardAsset billboard = new BillboardAsset();
billboard.SetVertices(args.Vertices);
billboard.SetIndices(Triangulate(args.Vertices));
billboard.width = args.Width;
billboard.height = args.Height;
billboard.bottom = args.Bottom;
Vector4[] texcoords = new Vector4[args.Row * args.Column];
Vector2 imageSize = new Vector2(1f / args.Column, 1f / args.Row);
Vector2 imageTopLeft = new Vector2(0, 0);
for (int y = 0; y < args.Row; ++y)
{
for (int x = 0; x < args.Column; ++x)
{
imageTopLeft = new Vector2(x * imageSize.x, y * imageSize.y);
texcoords[GUtilities.To1DIndex(x, y, args.Column)] = new Vector4(imageTopLeft.x, imageTopLeft.y, imageSize.x, imageSize.y);
}
}
billboard.SetImageTexCoords(texcoords);
billboard.name = args.Target.name + "_Billboard";
return(billboard);
}
private void DoImportColors()
{
int resolution = LPTCommon.PAINTER_MAP_RESOLUTION;
DesData.Shading.AlbedoMapResolution = resolution;
Color[] colors = new Color[resolution * resolution];
Vector2 uv = Vector2.zero;
Color c = Color.clear;
for (int z = 0; z < resolution; ++z)
{
for (int x = 0; x < resolution; ++x)
{
uv.Set(
Mathf.InverseLerp(0, resolution - 1, x),
Mathf.InverseLerp(0, resolution - 1, z));
c = SrcData.SurfaceSettings.GetColor(uv);
colors[GUtilities.To1DIndex(x, z, resolution)] = c;
}
}
DesData.Shading.Internal_AlbedoMap.SetPixels(colors);
DesData.Shading.Internal_AlbedoMap.Apply();
DesData.SetDirty(GTerrainData.DirtyFlags.Shading);
}
public static int CalculateEstimatedGrassStorage(TerrainData srcData, float grassDensity)
{
int estimatedGrassStorage = 0;
if (srcData == null)
{
estimatedGrassStorage = 0;
return(estimatedGrassStorage);
}
int quadMeshSize = 4 * 12 + 4 * 8 + 4 * 12 + 4 * 16 + 4 * 12 + 6 * 4;
// 4 verts 4 uvs 4 norm 4 tang 4 color 6 indices
int storage = 0;
DetailPrototype[] detailPrototypes = srcData.detailPrototypes;
int detailResolution = srcData.detailResolution;
for (int i = 0; i < detailPrototypes.Length; ++i)
{
int[,] density = srcData.GetDetailLayer(0, 0, detailResolution, detailResolution, i);
int sum = Mathf.FloorToInt(GUtilities.Sum(density) * grassDensity);
storage += sum * quadMeshSize;
}
estimatedGrassStorage = storage * 2; //File Explorer show a double size, don't know why!
return(estimatedGrassStorage);
}
private static void RenderPreviewFlipbook(RenderTexture rt, GBillboardCreatorArgs args)
{
Clear(rt, Color.clear);
if (args.AtlasMaterial == null)
{
return;
}
args.Mode = GBillboardRenderMode.Flipbook;
Camera cam = CreatePreviewCamera(args);
cam.targetTexture = rt;
GameObject g = CreatePreviewGameObject(cam.transform, args);
int imageCount = args.Row * args.Column;
float angleStep = 360f / imageCount;
g.transform.rotation = Quaternion.Euler(0, args.CellIndex * angleStep, 0);
cam.rect = new Rect(0, 0, 1, 1);
cam.Render();
cam.targetTexture = null;
GUtilities.DestroyGameobject(cam.gameObject);
GUtilities.DestroyGameobject(g);
}
private void DrawLivePreview(GStylizedTerrain t, Camera cam)
{
if (t.transform.rotation != Quaternion.identity ||
t.transform.lossyScale != Vector3.one)
{
return;
}
RenderTexture[] brushes = new RenderTexture[instance.Layers.Count];
for (int i = 0; i < brushes.Length; ++i)
{
brushes[i] = GetPreviewTexture(t, "brush" + i.ToString(), instance.MaskResolution, FilterMode.Bilinear);
}
Vector3[] worldPoints = instance.GetQuad();
Vector2[] uvPoint = new Vector2[worldPoints.Length];
for (int i = 0; i < uvPoint.Length; ++i)
{
uvPoint[i] = t.WorldPointToUV(worldPoints[i]);
}
Rect dirtyRect = GUtilities.GetRectContainsPoints(uvPoint);
if (!dirtyRect.Overlaps(new Rect(0, 0, 1, 1)))
{
return;
}
Color[] colors = new Color[instance.Layers.Count];
for (int i = 0; i < colors.Length; ++i)
{
colors[i] = instance.Layers[i].VisualizeColor;
}
GLivePreviewDrawer.DrawMasksLivePreview(t, cam, brushes, colors, dirtyRect);
}
public void Paint(Pinwheel.Griffin.GStylizedTerrain terrain, GObjectPainterArgs args)
{
if (args.MouseEventType == GPainterMouseEventType.Up)
{
return;
}
Vector2[] uvCorners = new Vector2[args.WorldPointCorners.Length];
for (int i = 0; i < uvCorners.Length; ++i)
{
uvCorners[i] = terrain.WorldPointToUV(args.WorldPointCorners[i]);
}
Rect dirtyRect = GUtilities.GetRectContainsPoints(uvCorners);
if (!dirtyRect.Overlaps(new Rect(0, 0, 1, 1)))
{
return;
}
if (args.ActionType == GPainterActionType.Normal)
{
HandleSpawnObject(terrain, args);
}
else if (args.ActionType == GPainterActionType.Negative)
{
HandleEraseObject(terrain, args);
}
}
private void Apply(GStylizedTerrain t)
{
if (t.TerrainData == null)
{
return;
}
if (PrototypeIndices.Count == 0)
{
return;
}
if (Prototypes.Count == 0)
{
return;
}
RenderTexture rt = new RenderTexture(MaskResolution, MaskResolution, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
List <Vector4> vertices = SplineCreator.GenerateVerticesWithFalloff();
Internal_Apply(t, rt, vertices);
Texture2D mask = GCommon.CreateTexture(MaskResolution, Color.clear);
GCommon.CopyFromRT(mask, rt);
mask.wrapMode = TextureWrapMode.Clamp;
Color[] maskColors = mask.GetPixels();
RemoveObjectFromTerrain(t, maskColors);
rt.Release();
GUtilities.DestroyObject(rt);
GUtilities.DestroyObject(mask);
}
private void CloneBg(RenderTexture targetRt, out RenderTexture bg0, out RenderTexture bg1)
{
if (bgRt0 == null)
{
bgRt0 = new RenderTexture(targetRt);
}
else if (bgRt0.width != targetRt.width || bgRt0.height != targetRt.height || bgRt0.format != targetRt.format)
{
bgRt0.Release();
GUtilities.DestroyObject(bgRt0);
bgRt0 = new RenderTexture(targetRt);
}
if (bgRt1 == null)
{
bgRt1 = new RenderTexture(targetRt);
}
else if (bgRt1.width != targetRt.width || bgRt1.height != targetRt.height || bgRt1.format != targetRt.format)
{
bgRt1.Release();
GUtilities.DestroyObject(bgRt1);
bgRt1 = new RenderTexture(targetRt);
}
//GCommon.CopyToRT(targetRt, bgRt0);
//GCommon.CopyToRT(targetRt, bgRt1);
bg0 = bgRt0;
bg1 = bgRt1;
}
private void HandleAddVertex(Rect previewRect)
{
if (vertices.Count >= MAX_VERTICES)
{
return;
}
if (Event.current == null)
{
return;
}
Event e = Event.current;
if (e.type == EventType.MouseDown && e.shift)
{
if (!previewRect.Contains(e.mousePosition))
{
return;
}
Vector2 uv = Rect.PointToNormalized(previewRect, e.mousePosition);
vertices.Add(GUtilities.FlipY(uv));
selectedVertexIndex = vertices.Count - 1;
tris = GBillboardCreator.Triangulate(vertices.ToArray());
e.Use();
}
}
private void DrawTriangles(Rect previewRect)
{
if (tris == null)
{
return;
}
if (tris.Length % 3 != 0)
{
Debug.Log("Invalid tris array!");
return;
}
int trisCount = tris.Length / 3;
for (int i = 0; i < trisCount; ++i)
{
Vector2 v0 = vertices[tris[i * 3 + 0]];
Vector2 v1 = vertices[tris[i * 3 + 1]];
Vector2 v2 = vertices[tris[i * 3 + 2]];
v0 = GUtilities.FlipY(v0);
v1 = GUtilities.FlipY(v1);
v2 = GUtilities.FlipY(v2);
Vector2 p0 = Rect.NormalizedToPoint(previewRect, v0);
Vector2 p1 = Rect.NormalizedToPoint(previewRect, v1);
Vector2 p2 = Rect.NormalizedToPoint(previewRect, v2);
GEditorCommon.DrawLine(p0, p1, Color.green);
GEditorCommon.DrawLine(p1, p2, Color.green);
GEditorCommon.DrawLine(p2, p0, Color.green);
}
}
private void ApplyAlbedoMetallicSmoothness(GStylizedTerrain t)
{
int albedoMapResolution = t.TerrainData.Shading.AlbedoMapResolution;
RenderTexture albedoRt = new RenderTexture(albedoMapResolution, albedoMapResolution, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
int metallicMapResolution = t.TerrainData.Shading.MetallicMapResolution;
RenderTexture metallicRt = new RenderTexture(metallicMapResolution, metallicMapResolution, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
bool succeed = Internal_ApplyAlbedoMetallicSmoothness(t, albedoRt, metallicRt);
if (!succeed)
{
return;
}
RenderTexture.active = albedoRt;
t.TerrainData.Shading.AlbedoMap.ReadPixels(new Rect(0, 0, albedoMapResolution, albedoMapResolution), 0, 0);
t.TerrainData.Shading.AlbedoMap.Apply();
RenderTexture.active = null;
RenderTexture.active = metallicRt;
t.TerrainData.Shading.MetallicMap.ReadPixels(new Rect(0, 0, metallicMapResolution, metallicMapResolution), 0, 0);
t.TerrainData.Shading.MetallicMap.Apply();
RenderTexture.active = null;
albedoRt.Release();
GUtilities.DestroyObject(albedoRt);
metallicRt.Release();
GUtilities.DestroyObject(metallicRt);
}
private void DrawLivePreview(GStylizedTerrain t, Camera cam)
{
if (t.transform.rotation != Quaternion.identity ||
t.transform.lossyScale != Vector3.one)
{
return;
}
//Mesh previewMesh = GGriffinSettings.Instance.GetLivePreviewMesh(t.TerrainData.Geometry.MeshResolution);
RenderTexture rt = GetPreviewTexture(t);
instance.GetQuad(worldPoints);
for (int i = 0; i < normalizedPoints.Length; ++i)
{
normalizedPoints[i] = t.WorldPointToUV(worldPoints[i]);
}
Rect dirtyRect = GUtilities.GetRectContainsPoints(normalizedPoints);
if (instance.Channel == GGeometryStamper.GStampChannel.Elevation)
{
GLivePreviewDrawer.DrawGeometryLivePreview(t, cam, rt, dirtyRect);
}
else if (instance.Channel == GGeometryStamper.GStampChannel.Visibility)
{
Matrix4x4 worldToMaskMatrix = Matrix4x4.TRS(
worldPoints[0],
instance.Rotation,
instance.Scale).inverse;
GLivePreviewDrawer.DrawVisibilityLivePreview(t, cam, rt, dirtyRect, instance.Stamp, worldToMaskMatrix);
}
}
public void Editor_DrawLivePreview(GStylizedTerrain terrain, GTexturePainterArgs args, Camera cam)
{
#if UNITY_EDITOR
Vector2[] uvCorners = new Vector2[args.WorldPointCorners.Length];
for (int i = 0; i < uvCorners.Length; ++i)
{
uvCorners[i] = terrain.WorldPointToUV(args.WorldPointCorners[i]);
}
Rect dirtyRect = GUtilities.GetRectContainsPoints(uvCorners);
if (!dirtyRect.Overlaps(new Rect(0, 0, 1, 1)))
{
return;
}
Texture2D bg = terrain.TerrainData.Shading.AlbedoMap;
int albedoResolution = terrain.TerrainData.Shading.AlbedoMapResolution;
RenderTexture rt = GTerrainTexturePainter.Internal_GetRenderTexture(terrain, albedoResolution);
GCommon.CopyToRT(bg, rt);
Material mat = GInternalMaterials.AlbedoPainterMaterial;
mat.SetColor("_Color", args.Color);
mat.SetTexture("_MainTex", bg);
SetupTextureGrid(terrain, mat);
mat.SetTexture("_Mask", args.Mask);
mat.SetFloat("_Opacity", args.Opacity);
int pass =
args.ActionType == GPainterActionType.Normal ? 0 :
args.ActionType == GPainterActionType.Negative ? 1 :
args.ActionType == GPainterActionType.Alternative ? 2 : 0;
GCommon.DrawQuad(rt, uvCorners, mat, pass);
GLivePreviewDrawer.DrawAlbedoLivePreview(terrain, cam, rt, dirtyRect);
#endif
}
public void Editor_DrawLivePreview(GStylizedTerrain terrain, GTexturePainterArgs args, Camera cam)
{
#if UNITY_EDITOR
Vector2[] uvCorners = new Vector2[args.WorldPointCorners.Length];
for (int i = 0; i < uvCorners.Length; ++i)
{
uvCorners[i] = terrain.WorldPointToUV(args.WorldPointCorners[i]);
}
Rect dirtyRect = GUtilities.GetRectContainsPoints(uvCorners);
if (!dirtyRect.Overlaps(new Rect(0, 0, 1, 1)))
{
return;
}
Texture2D bg = terrain.TerrainData.Geometry.HeightMap;
int heightMapResolution = terrain.TerrainData.Geometry.HeightMapResolution;
RenderTexture rt = GTerrainTexturePainter.Internal_GetRenderTexture(terrain, heightMapResolution);
GCommon.CopyToRT(bg, rt);
Vector3 localSamplePoint = terrain.transform.InverseTransformPoint(args.SamplePoint);
Material mat = GInternalMaterials.HeightSamplingPainterMaterial;
mat.SetTexture("_MainTex", bg);
mat.SetTexture("_Mask", args.Mask);
mat.SetFloat("_Opacity", args.Opacity);
mat.SetFloat("_TargetGray", Mathf.InverseLerp(0, terrain.TerrainData.Geometry.Height, localSamplePoint.y));
int pass = 0;
GCommon.DrawQuad(rt, uvCorners, mat, pass);
GLivePreviewDrawer.DrawGeometryLivePreview(terrain, cam, rt, dirtyRect);
#endif
}
private void ClearTrees(GStylizedTerrain t)
{
if (t.TerrainData == null)
{
return;
}
if (t.TerrainData.Foliage.Trees == null)
{
return;
}
Vector3 terrainSize = new Vector3(
t.TerrainData.Geometry.Width,
t.TerrainData.Geometry.Height,
t.TerrainData.Geometry.Length);
Vector3 scale = new Vector3(
GUtilities.InverseLerpUnclamped(0, terrainSize.x, Scale.x),
GUtilities.InverseLerpUnclamped(0, terrainSize.y, Scale.y),
GUtilities.InverseLerpUnclamped(0, terrainSize.z, Scale.z));
Matrix4x4 matrix = Matrix4x4.TRS(
t.WorldPointToNormalized(Position),
Rotation,
scale);
Matrix4x4 normalizeToStamp = matrix.inverse;
t.TerrainData.Foliage.TreeInstances.RemoveAll(tree =>
{
Vector3 stampSpacePos = normalizeToStamp.MultiplyPoint(tree.Position);
return
(stampSpacePos.x >= -0.5f && stampSpacePos.x <= 0.5f &&
stampSpacePos.y >= 0f && stampSpacePos.y <= 1f &&
stampSpacePos.z >= -0.5f && stampSpacePos.z <= 0.5f);
});
t.TerrainData.SetDirty(GTerrainData.DirtyFlags.Foliage);
}
private void DrawReArrangeGUI()
{
string label = "Re-Arrange";
string id = "rearrange" + instance.GetInstanceID();
GEditorCommon.Foldout(label, false, id, () =>
{
string s = string.Format(
"This function requires terrain neighboring to be set and the following properties to be overriden:\n" +
" - Width\n" +
" - Length");
EditorGUILayout.LabelField(s, GEditorCommon.WordWrapItalicLabel);
GGeometryOverride g = instance.GeometryOverride;
GUI.enabled =
g.OverrideWidth &&
g.OverrideLength;
if (GUILayout.Button("Re-Arrange"))
{
GAnalytics.Record(GAnalytics.GROUP_REARRANGE);
instance.ReArrange();
GUtilities.MarkCurrentSceneDirty();
}
GUI.enabled = true;
});
}
private void ClearObjects(GStylizedTerrain t)
{
if (t.TerrainData == null)
{
return;
}
Vector3 terrainSize = new Vector3(
t.TerrainData.Geometry.Width,
t.TerrainData.Geometry.Height,
t.TerrainData.Geometry.Length);
Vector3 scale = new Vector3(
GUtilities.InverseLerpUnclamped(0, terrainSize.x, Scale.x),
GUtilities.InverseLerpUnclamped(0, terrainSize.y, Scale.y),
GUtilities.InverseLerpUnclamped(0, terrainSize.z, Scale.z));
Matrix4x4 matrix = Matrix4x4.TRS(
t.WorldPointToNormalized(Position),
Rotation,
scale);
Matrix4x4 normalizeToStamp = matrix.inverse;
GSpawner.DestroyIf(t, (g) =>
{
Vector3 normalizePos = t.WorldPointToNormalized(g.transform.position);
Vector3 stampSpacePos = normalizeToStamp.MultiplyPoint(normalizePos);
return
(stampSpacePos.x >= -0.5f && stampSpacePos.x <= 0.5f &&
stampSpacePos.y >= 0f && stampSpacePos.y <= 1f &&
stampSpacePos.z >= -0.5f && stampSpacePos.z <= 0.5f);
});
}
public static void SetShader(GStylizedTerrain terrain, GLightingModel lighting, GTexturingModel texturing, GSplatsModel splats = GSplatsModel.Splats4)
{
if (terrain.TerrainData == null)
{
throw new NullReferenceException("The selected terrain doesn't have terrain data.");
}
if (terrain.TerrainData.Shading.CustomMaterial == null)
{
throw new NullReferenceException("The selected terrain doesn't have material. Make sure you've assigned a material for it.");
}
Material mat = GRuntimeSettings.Instance.terrainRendering.GetClonedMaterial(
GCommon.CurrentRenderPipeline,
lighting,
texturing,
splats);
if (mat == null)
{
throw new Exception("Fail to get template material. Try re-install render pipeline extension package.");
}
terrain.TerrainData.Shading.CustomMaterial.shader = mat.shader;
terrain.TerrainData.Shading.UpdateMaterials();
GUtilities.DestroyObject(mat);
}
public void Generate(RenderTexture targetRt)
{
GBlendMapGeneratorParams param = GTextureToolParams.Instance.Blend;
RenderTexture bg = new RenderTexture(targetRt);
GCommon.CopyToRT(targetRt, bg);
GCommon.FillTexture(targetRt, Color.black);
for (int i = 0; i < param.Layers.Count; ++i)
{
GBlendLayer l = param.Layers[i];
Mat.SetTexture("_Background", bg);
Mat.SetTexture("_Foreground", l.Texture);
Mat.SetFloat("_Number", l.Number);
Mat.SetVector("_Vector", l.Vector);
Mat.SetInt("_Ops", (int)l.BlendOps);
Mat.SetFloat("_LerpFactor", l.LerpFactor);
Mat.SetTexture("_LerpMask", l.LerpMask);
Mat.SetInt("_Saturate", l.Saturate ? 1 : 0);
GCommon.DrawQuad(targetRt, GCommon.FullRectUvPoints, Mat, (int)l.DataSource);
GCommon.CopyToRT(targetRt, bg);
}
bg.Release();
GUtilities.DestroyObject(bg);
}
public override void OnInspectorGUI()
{
EditorGUI.BeginChangeCheck();
painter.GroupId = GEditorCommon.ActiveTerrainGroupPopupWithAllOption("Group Id", painter.GroupId);
DrawPaintMode();
IGObjectPainter p = painter.ActivePainter;
if (p == null)
{
EditorGUILayout.LabelField("No painter found!", GEditorCommon.WordWrapItalicLabel);
}
else
{
DrawInstructionGUI();
DrawBrushMaskGUI();
DrawObjectSelectionGUI();
DrawBrushGUI();
DrawFilterGUI();
}
if (EditorGUI.EndChangeCheck())
{
GUtilities.MarkCurrentSceneDirty();
}
}
public void Paint(Pinwheel.Griffin.GStylizedTerrain terrain, GTexturePainterArgs args)
{
if (terrain.TerrainData == null)
{
return;
}
if (args.MouseEventType == GPainterMouseEventType.Up)
{
return;
}
Vector2[] uvCorners = new Vector2[args.WorldPointCorners.Length];
for (int i = 0; i < uvCorners.Length; ++i)
{
uvCorners[i] = terrain.WorldPointToUV(args.WorldPointCorners[i]);
}
Rect dirtyRect = GUtilities.GetRectContainsPoints(uvCorners);
if (!dirtyRect.Overlaps(new Rect(0, 0, 1, 1)))
{
return;
}
Texture2D bg = terrain.TerrainData.Shading.AlbedoMap;
int albedoResolution = terrain.TerrainData.Shading.AlbedoMapResolution;
RenderTexture rt = GTerrainTexturePainter.Internal_GetRenderTexture(albedoResolution);
GCommon.CopyToRT(bg, rt);
Material mat = GInternalMaterials.AlbedoPainterMaterial;
mat.SetColor("_Color", args.Color);
mat.SetTexture("_MainTex", bg);
SetupTextureGrid(terrain, mat);
mat.SetTexture("_Mask", args.Mask);
mat.SetFloat("_Opacity", args.Opacity);
int pass =
args.ActionType == GPainterActionType.Normal ? 0 :
args.ActionType == GPainterActionType.Negative ? 1 :
args.ActionType == GPainterActionType.Alternative ? 2 : 0;
GCommon.DrawQuad(rt, uvCorners, mat, pass);
RenderTexture.active = rt;
terrain.TerrainData.Shading.AlbedoMap.ReadPixels(
new Rect(0, 0, albedoResolution, albedoResolution), 0, 0);
terrain.TerrainData.Shading.AlbedoMap.Apply();
RenderTexture.active = null;
terrain.TerrainData.SetDirty(GTerrainData.DirtyFlags.Shading);
if (!args.ForceUpdateGeometry)
{
return;
}
terrain.TerrainData.Geometry.SetRegionDirty(dirtyRect);
terrain.TerrainData.SetDirty(GTerrainData.DirtyFlags.Geometry);
}
public void Internal_UpdateFalloffTexture()
{
if (falloffTexture != null)
{
GUtilities.DestroyObject(falloffTexture);
}
falloffTexture = GCommon.CreateTextureFromCurve(Falloff, 256, 1);
}
public GTreeNativeData(List <GTreeInstance> trees)
{
instances = new NativeArray <GTreeInstance>(trees.ToArray(), Allocator.Persistent);
prototypeIndices = new NativeArray <int>(trees.Count, Allocator.Persistent);
GUtilities.Fill(prototypeIndices, -1);
trs = new NativeArray <Matrix4x4>(trees.Count, Allocator.Persistent);
cullResults = new NativeArray <byte>(trees.Count, Allocator.Persistent);
}
public static void CleanUp()
{
foreach (Mesh m in BillboardMeshes.Values)
{
GUtilities.DestroyObject(m);
}
BillboardMeshes.Clear();
}
