public void ComputeHeight(ref ComputeBuffer layerBuffer, ref ComputeBuffer maskBuffer, float seedParent, bool first = false)
{
TC_Compute compute = TC_Compute.instance;
float seedTotal = seed + seedParent;
layerBuffer = selectNodeGroup.ComputeValue(seedTotal);
if (layerBuffer != null)
{
if (maskNodeGroup.active)
{
maskBuffer = maskNodeGroup.ComputeValue(seedTotal);
}
if (maskBuffer != null)
{
if (method != Method.Lerp || first)
{
InitPreviewRenderTexture(true, "rtPreview_Layer_" + TC.outputNames[outputId]);
compute.RunComputeMethod(null, null, layerBuffer, ref maskBuffer, 0, rtPreview);
}
}
else
{
rtDisplay = selectNodeGroup.rtDisplay;
}
}
else
{
TC_Reporter.Log("Layerbuffer " + listIndex + " = null, reporting from layer");
}
}
void DestroyMe()
{
TC_Settings settings = TC_Settings.instance;
if (settings == null)
{
return;
}
if (settings.imageList == null)
{
return;
}
int index = settings.imageList.IndexOf(this);
if (index != -1)
{
settings.imageList.RemoveAt(index);
}
TC_Compute.DisposeRenderTexture(ref rt);
#if UNITY_EDITOR
UnityEditor.Undo.DestroyObjectImmediate(gameObject);
#else
Destroy(gameObject);
#endif
}
public void Capture(int collisionMask, CollisionDirection collisionDirection, int outputId, Vector2 resolution)
{
if (TC_Area2D.current.currentTerrainArea == null)
{
return;
}
bool create = false;
if (rtCapture == null)
{
create = true;
}
else if (rtCapture.width != resolution.x || rtCapture.height != resolution.y)
{
TC_Compute.DisposeRenderTexture(ref rtCapture);
create = true;
}
if (create)
{
rtCapture = new RenderTexture((int)resolution.x, (int)resolution.y, 16, RenderTextureFormat.Depth, RenderTextureReadWrite.Linear);
cam.targetTexture = rtCapture;
}
// Debug.Log("Capture");
this.collisionMask = collisionMask;
terrain = TC_Area2D.current.currentTerrain;
// this.collisionDirection = collisionDirection;
cam.cullingMask = collisionMask;
SetCamera(collisionDirection, outputId);
cam.Render();
}
// public Texture2D texHeight;
// [HideInInspector] public byte[] treemap;
// [HideInInspector] public byte[] objectmap;
public void DisposeTextures()
{
TC_Compute.DisposeRenderTexture(ref rtHeight);
TC_Compute.DisposeTexture(ref texHeight);
TC_Compute.DisposeTexture(ref texColormap);
TC_Compute.DisposeTexture(ref texNormalmap);
}
public void InitPreviewRenderTexture(bool assignRtDisplay = true, string name = "Preview")
{
TC_Compute.InitPreviewRenderTexture(ref rtPreview, name);
if (assignRtDisplay)
{
rtDisplay = rtPreview;
}
}
void OnDestroy()
{
TC_Compute.DisposeTexture(ref tex);
if (!callDestroy)
{
TC.refreshOutputReferences = TC.allOutput;
}
}
// Compute height, trees and objects
public ComputeBuffer ComputeSingle(ref ComputeBuffer totalBuffer, float seedParent, bool first = false)
{
if (!groupResult.active)
{
return(null);
}
TC_Compute compute = TC_Compute.instance;
float seedTotal = seed + seedParent;
totalBuffer = groupResult.ComputeSingle(seedTotal, first);
// Debug.Log("layerMaskBuffer " + layerMaskBuffer == null);
ComputeBuffer maskBuffer = null;
if (maskNodeGroup.active)
{
maskBuffer = maskNodeGroup.ComputeValue(seedTotal);
}
if (maskBuffer != null)
{
TC_Compute.InitPreviewRenderTexture(ref rtPreview, "rtPreview_LayerGroup");
if (method != Method.Lerp || first)
{
if (outputId == TC.heightOutput)
{
compute.RunComputeMethod(null, null, totalBuffer, ref maskBuffer, 0, rtPreview);
}
else
{
compute.RunItemComputeMask(this, ref rtPreview, groupResult.rtDisplay, ref totalBuffer, ref maskBuffer);
}
}
rtDisplay = rtPreview;
}
else
{
if (outputId == TC.heightOutput || level == 0 || groupResult.totalActive == 1)
{
rtDisplay = groupResult.rtDisplay;
}
else
{
rtDisplay = rtPreview;
}
}
if (totalBuffer == null)
{
TC_Reporter.Log("Layer buffer null");
}
return(maskBuffer);
}
public bool ComputeMulti(ref RenderTexture[] renderTextures, ref ComputeBuffer maskBuffer, float seedParent, bool first = false)
{
TC_Compute compute = TC_Compute.instance;
bool didCompute = false;
float seedTotal = seed + seedParent;
ComputeBuffer layerBuffer = selectNodeGroup.ComputeValue(seedTotal);
if (layerBuffer != null)
{
didCompute = true;
TC_Compute.InitPreviewRenderTexture(ref rtPreview, "rtPreview_Layer");
if (maskNodeGroup.active)
{
maskBuffer = maskNodeGroup.ComputeValue(seedTotal);
}
TC_Compute.InitPreviewRenderTexture(ref selectNodeGroup.rtColorPreview, "rtNodeGroupPreview_" + TC.outputNames[outputId]);
if (outputId == TC.colorOutput)
{
compute.RunColorCompute(selectNodeGroup, selectItemGroup, ref renderTextures[0], ref layerBuffer);
}
else
{
compute.RunSplatCompute(selectNodeGroup, selectItemGroup, ref renderTextures, ref layerBuffer);
}
compute.DisposeBuffer(ref layerBuffer);
if (maskBuffer != null)
{
TC_Reporter.Log("Run layer select * mask");
if (method != Method.Lerp || first)
{
if (outputId == TC.colorOutput)
{
compute.RunComputeColorMethod(this, ref renderTextures[0], maskBuffer, rtPreview);
}
else
{
compute.RunComputeMultiMethod(this, doNormalize, ref renderTextures, maskBuffer, rtPreview);
}
}
rtDisplay = rtPreview;
}
else
{
TC_Reporter.Log("No mask buffer assign colorPreviewTex to layer");
rtDisplay = selectNodeGroup.rtColorPreview;
}
}
return(didCompute);
}
public void SetPreviewTextureAfter()
{
if (totalActive == 1)
{
TC_Compute.DisposeRenderTexture(ref rtPreview);
rtDisplay = itemList[firstActive].rtDisplay;
}
}
public void DisposeTextures()
{
TC_Compute.DisposeRenderTextures(ref rtSplatmaps);
TC_Compute.DisposeRenderTexture(ref rtColormap);
for (int i = 0; i < terrains.Count; i++)
{
terrains[i].DisposeTextures();
}
}
void OnDestroy()
{
TC_Compute.DisposeTexture(ref tex);
#if UNITY_EDITOR
if (!UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode && !callDestroy)
{
TC.RefreshOutputReferences(TC.allOutput);
}
#else
if (!callDestroy)
{
TC.RefreshOutputReferences(TC.allOutput);
}
#endif
}
public void SetPreviewTextureBefore()
{
// Debug.Log("no " + maskNodeGroup.itemList.Count + " " + itemList.Count);
if (totalActive == 0)
{
active = false;
rtDisplay = null;
TC_Compute.DisposeRenderTexture(ref rtPreview);
}
else if (totalActive != 1)
{
TC_Compute.InitPreviewRenderTexture(ref rtPreview, "rtGroupResult");
rtDisplay = rtPreview;
}
}
public void RemoveFromPortalNode()
{
if (portalNode == null)
{
return;
}
if (portalNode.isPortalCount > 0)
{
portalNode.isPortalCount--;
portalNode.usedAsPortalList.Remove(this);
if (portalNode.isPortalCount == 0)
{
TC_Compute.DisposeRenderTexture(ref portalNode.rtPortal);
}
}
else
{
portalNode.isPortalCount = 0;
}
}
// Compute trees and objects
public bool ComputeItem(ref ComputeBuffer itemMapBuffer, ref ComputeBuffer maskBuffer, float seedParent, bool first = false)
{
TC_Compute compute = TC_Compute.instance;
bool didCompute = false;
float seedTotal = seed + seedParent;
ComputeBuffer selectBuffer = selectNodeGroup.ComputeValue(seedTotal);
if (selectBuffer != null)
{
didCompute = true;
TC_Compute.InitPreviewRenderTexture(ref rtPreview, "rtPreview_Layer_" + TC.outputNames[outputId]);
rtDisplay = rtPreview;
TC_Compute.InitPreviewRenderTexture(ref selectNodeGroup.rtColorPreview, "rtColorPreview");
compute.RunItemCompute(this, ref itemMapBuffer, ref selectBuffer);
compute.DisposeBuffer(ref selectBuffer);
// compute.shader.SetBuffer(compute.terrainSplatmap0Kernel, "itemMapBuffer", itemMapBuffer);
// compute.RunItemPositionCompute(itemMapBuffer, TC.treeOutput);
if (maskNodeGroup.active)
{
maskBuffer = maskNodeGroup.ComputeValue(seedTotal);
}
if (maskBuffer != null)
{
TC_Reporter.Log("Run layer select * mask");
if (method != Method.Lerp || first)
{
compute.RunItemComputeMask(this, ref rtPreview, selectNodeGroup.rtColorPreview, ref itemMapBuffer, ref maskBuffer);
}
}
}
return(didCompute);
}
// Compute Color, splat and grass
public bool ComputeMulti(ref RenderTexture[] renderTextures, ref ComputeBuffer maskBuffer, float seedParent, bool first = false)
{
TC_Compute compute = TC_Compute.instance;
float totalSeed = seed + seedParent;
bool computed = groupResult.ComputeMulti(ref renderTextures, totalSeed, doNormalize, first);
if (maskNodeGroup.active)
{
maskBuffer = maskNodeGroup.ComputeValue(totalSeed);
}
if (maskBuffer != null)
{
TC_Compute.InitPreviewRenderTexture(ref rtPreview, "rtPreview_LayerGroup_" + TC.outputNames[outputId]);
if (method != Method.Lerp || first)
{
if (outputId == TC.colorOutput)
{
compute.RunComputeColorMethod(this, ref renderTextures[0], maskBuffer, groupResult.rtDisplay);
}
else
{
compute.RunComputeMultiMethod(this, doNormalize, ref renderTextures, maskBuffer, groupResult.rtDisplay);
}
}
rtDisplay = rtPreview;
}
else
{
rtDisplay = groupResult.rtDisplay;
}
return(computed);
}
public override void DisposeTextures()
{
base.DisposeTextures();
TC_Compute.DisposeRenderTexture(ref rtColorPreview);
}
public virtual void DisposeTextures()
{
rtDisplay = null;
TC_Compute.DisposeRenderTexture(ref rtPreview);
}
static int LoadDefault()
{
if (!NewScene())
{
return(-1);
}
GameObject defaultGo = AssetDatabase.LoadAssetAtPath(TC.installPath + "/Defaults/TerrainComposer2.prefab", typeof(GameObject)) as GameObject;
if (defaultGo != null)
{
GameObject go = Instantiate(defaultGo, Vector3.zero, Quaternion.identity) as GameObject;
if (go == null)
{
return(-2);
}
else
{
go.transform.hideFlags = HideFlags.HideInInspector;
go.name = go.name.Replace("(Clone)", "");
go.transform.SetAsFirstSibling();
DebugMode();
if (!TC.LoadGlobalSettings())
{
return(-2);
}
Transform generateT = go.transform.Find("Generate");
if (generateT != null)
{
TC_Compute compute = generateT.GetComponent <TC_Compute>();
if (compute != null)
{
compute.enabled = true;
}
else
{
return(-2);
}
}
else
{
return(-2);
}
}
}
else
{
return(-2);
}
if (GameObject.Find("Terrain Area") == null)
{
GameObject terrainAreaGo = AssetDatabase.LoadAssetAtPath(TC.installPath + "/Defaults/Terrain Area.prefab", typeof(GameObject)) as GameObject;
if (terrainAreaGo != null)
{
GameObject go = Instantiate(terrainAreaGo, Vector3.zero, Quaternion.identity) as GameObject;
TC_TerrainLayer terrainLayer = TC_Generate.instance.area2D.terrainLayer;
terrainLayer.GetItems(false, true, false);
// Detect prefab import issue
if (terrainLayer.layerGroups[TC.splatOutput].visible)
{
TC.AddMessage("TerrainComposer2 prefabs did not import correctly.\n\nYou need to be reimport TerrainComposer2 again (So import it twice).\n\nThis happens if ‘Asset Serialization’ is set to ‘Force Text’ in Unity Menu -> Project Settings -> Editor. It is a Unity import bug that can happen on any Asset. If that does not fix it, the ‘Asset Serialization’ can be set to ‘Mixed’ and then reimport TC2 again, then after importing the ‘Asset Serialization’ can be set to ‘Force Text’ again.", 0, 60);
}
else if (go == null)
{
TC.AddMessage("Default Terrain Area prefab is missing. Please reimport this prefab.");
}
go.name = go.name.Replace("(Clone)", "");
}
else
{
TC.AddMessage("Default Terrain Area prefab is missing. Please reimport this prefab.");
}
}
TC.AddMessage("Loading default TerrainComposer project.");
return(0);
}
// Compute height, trees and objects
public ComputeBuffer ComputeSingle(float seedParent, bool first = false)
{
TC_Compute compute = TC_Compute.instance;
ComputeBuffer totalBuffer = null;
ComputeBuffer layerBuffer = null;
ComputeBuffer layerMaskBuffer = null;
RenderTexture[] rtsPreview = null;
RenderTexture rtRightPreview = null;
RenderTexture rtLeftPreview = null;
if (outputId != TC.heightOutput)
{
rtsPreview = new RenderTexture[2];
}
SetPreviewTextureBefore();
int even = 0;
float seedTotal = seed + seedParent;
for (int i = 0; i < itemList.Count; i++)
{
TC_Layer layer = itemList[i] as TC_Layer;
if (layer != null)
{
if (!layer.active)
{
TC_Reporter.Log("Inactive layer " + i); continue;
}
if (totalBuffer == null)
{
if (outputId == TC.heightOutput)
{
layer.ComputeHeight(ref totalBuffer, ref layerMaskBuffer, seedTotal, i == firstActive);
}
else
{
layer.ComputeItem(ref totalBuffer, ref layerMaskBuffer, seedTotal, i == firstActive);
if (totalBuffer != null)
{
rtLeftPreview = layer.rtDisplay;
}
}
TC_Area2D.current.layerGroupBuffer = totalBuffer; // Portal
compute.DisposeBuffer(ref layerMaskBuffer);
}
else
{
if (outputId == TC.heightOutput)
{
layer.ComputeHeight(ref layerBuffer, ref layerMaskBuffer, seedTotal);
}
else
{
layer.ComputeItem(ref layerBuffer, ref layerMaskBuffer, seedTotal);
}
if (layerBuffer != null)
{
if (outputId == TC.heightOutput)
{
compute.RunComputeMethod(this, layer, totalBuffer, ref layerBuffer, totalActive, i == lastActive ? rtPreview : null, layerMaskBuffer);
}
else
{
rtRightPreview = layer.rtDisplay;
compute.RunComputeObjectMethod(this, layer, totalBuffer, ref layerBuffer, layerMaskBuffer, rtPreview, ref rtsPreview[even++ % 2], ref rtLeftPreview, rtRightPreview);
}
TC_Area2D.current.layerGroupBuffer = totalBuffer;
}
compute.DisposeBuffer(ref layerMaskBuffer);
}
}
else
{
TC_LayerGroup layerGroup = itemList[i] as TC_LayerGroup;
if (layerGroup == null)
{
continue;
}
if (!layerGroup.active)
{
continue;
}
if (totalBuffer == null)
{
layerMaskBuffer = layerGroup.ComputeSingle(ref totalBuffer, seedTotal, i == firstActive);
if (totalBuffer != null)
{
rtLeftPreview = layerGroup.rtDisplay;
}
TC_Area2D.current.layerGroupBuffer = totalBuffer;
compute.DisposeBuffer(ref layerMaskBuffer);
}
else
{
layerMaskBuffer = layerGroup.ComputeSingle(ref layerBuffer, seedTotal);
if (layerBuffer != null)
{
if (outputId == TC.heightOutput)
{
compute.RunComputeMethod(this, layerGroup, totalBuffer, ref layerBuffer, totalActive, i == lastActive ? rtPreview : null, layerMaskBuffer);
}
else
{
rtRightPreview = layerGroup.rtDisplay;
compute.RunComputeObjectMethod(this, layerGroup, totalBuffer, ref layerBuffer, layerMaskBuffer, rtPreview, ref rtsPreview[even++ % 2], ref rtLeftPreview, rtRightPreview);
}
TC_Area2D.current.layerGroupBuffer = totalBuffer;
}
compute.DisposeBuffer(ref layerMaskBuffer);
}
}
}
SetPreviewTextureAfter();
if (outputId != TC.heightOutput)
{
TC_Compute.DisposeRenderTextures(ref rtsPreview);
}
compute.DisposeBuffer(ref layerMaskBuffer);
if (totalBuffer == null)
{
TC_Reporter.Log("Layer buffer null");
}
return(totalBuffer);
}
public void DisposeRTCapture()
{
cam.targetTexture = null;
TC_Compute.DisposeRenderTexture(ref rtCapture);
}
public bool ComputeMulti(ref RenderTexture[] renderTextures, float seedParent, bool doNormalize, bool first = false)
{
TC_Compute compute = TC_Compute.instance;
RenderTexture[] rtsLayer = null;
RenderTexture rtRightPreview = null;
RenderTexture rtLeftPreview = null;
RenderTexture[] rtsPreview = null;
// RenderTexture rtPreview2 = null;
ComputeBuffer layerMaskBuffer = null;
TC_LayerGroup layerGroup;
TC_Layer layer;
bool firstCompute = false;
bool lastCompute = false;
int even = 0;
rtsPreview = new RenderTexture[2];
SetPreviewTextureBefore();
float seedTotal = seed + seedParent;
for (int i = 0; i < itemList.Count; i++)
{
layer = itemList[i] as TC_Layer;
if (layer != null)
{
if (!layer.active)
{
continue;
}
// InitPreview(ref layer.previewRenderTex);
if (!firstCompute)
{
firstCompute = layer.ComputeMulti(ref renderTextures, ref layerMaskBuffer, seedTotal, i == firstActive);
if (firstCompute)
{
rtLeftPreview = layer.rtDisplay;
TC_Reporter.Log("firt compute " + layer.maskNodeGroup.totalActive);
compute.DisposeBuffer(ref layerMaskBuffer);
}
}
else
{
TC_Compute.InitRenderTextures(ref rtsLayer, "rtsLayer", renderTextures.Length);
lastCompute = layer.ComputeMulti(ref rtsLayer, ref layerMaskBuffer, seedTotal);
if (lastCompute)
{
TC_Reporter.Log("Run layer method multi");
rtRightPreview = (layer.method == Method.Lerp) ? layer.selectNodeGroup.rtColorPreview : layer.rtDisplay;
// Debug.Log(rtRight.name+ " "+ (layer.maskNodeGroup.activeTotal == 0 || layer.method == Method.Lerp));
if (outputId == TC.colorOutput)
{
compute.RunComputeColorMethod(layer, layer.method, ref renderTextures[0], ref rtsLayer[0], layerMaskBuffer, rtPreview, ref rtsPreview[even++ % 2], ref rtLeftPreview, rtRightPreview);
}
else
{
compute.RunComputeMultiMethod(layer, layer.method, i == lastActive && doNormalize, ref renderTextures, ref rtsLayer, layerMaskBuffer, rtPreview, ref rtsPreview[even++ % 2], ref rtLeftPreview, rtRightPreview);
}
compute.DisposeBuffer(ref layerMaskBuffer);
}
}
}
else
{
layerGroup = itemList[i] as TC_LayerGroup;
if (layerGroup == null)
{
continue;
}
if (!layerGroup.active)
{
continue;
}
if (!firstCompute)
{
firstCompute = layerGroup.ComputeMulti(ref renderTextures, ref layerMaskBuffer, seedTotal, i == firstActive);
if (firstCompute)
{
rtLeftPreview = layerGroup.rtDisplay;
compute.DisposeBuffer(ref layerMaskBuffer);
TC_Reporter.Log("LayerGroup did first compute");
}
}
else
{
TC_Compute.InitRenderTextures(ref rtsLayer, "rtsLayer", renderTextures.Length);
lastCompute = layerGroup.ComputeMulti(ref rtsLayer, ref layerMaskBuffer, seedTotal);
if (lastCompute)
{
// if (layerGroup.groupResult.activeTotal == 1) rtRight = layerGroup.rtDisplay; else rtRight = layerGroup.rtPreview;
rtRightPreview = (layerGroup.method == Method.Lerp) ? layerGroup.groupResult.rtDisplay : layerGroup.rtDisplay;
if (outputId == TC.colorOutput)
{
compute.RunComputeColorMethod(layerGroup, layerGroup.method, ref renderTextures[0], ref rtsLayer[0], layerMaskBuffer, rtPreview, ref rtsPreview[even++ % 2], ref rtLeftPreview, rtRightPreview);
}
else
{
compute.RunComputeMultiMethod(layerGroup, layerGroup.method, i == lastActive && doNormalize, ref renderTextures, ref rtsLayer, layerMaskBuffer, rtPreview, ref rtsPreview[even++ % 2], ref rtLeftPreview, rtRightPreview);
}
compute.DisposeBuffer(ref layerMaskBuffer);
}
}
}
}
SetPreviewTextureAfter();
if (layerMaskBuffer != null)
{
compute.DisposeBuffer(ref layerMaskBuffer); TC_Reporter.Log("Dispose layerMaskBuffer");
}
TC_Compute.DisposeRenderTextures(ref rtsPreview);
TC_Compute.DisposeRenderTextures(ref rtsLayer);
return(firstCompute);
}
public ComputeBuffer ComputeValue(float seedParent)
{
TC_Compute compute = TC_Compute.instance;
if (compute == null)
{
Debug.Log("Compute is null");
}
ComputeBuffer nodeBuffer = null;
ComputeBuffer totalBuffer = null;
bool inputCurrent;
if (totalActive > 1)
{
InitPreviewRenderTexture(true, name);
}
int length = useConstant ? 1 : itemList.Count;
float seedTotal = seed + seedParent;
for (int i = 0; i < length; i++)
{
TC_Node node = itemList[i] as TC_Node;
if (node != null)
{
node.Init();
if (!node.active)
{
continue;
}
if (node.clamp)
{
// if (node.OutOfBounds()) continue;
}
inputCurrent = (node.inputKind == InputKind.Current);
node.InitPreviewRenderTexture(true, node.name);
if (totalBuffer == null && !inputCurrent)
{
totalBuffer = compute.RunNodeCompute(this, node, seedTotal);
}
else
{
if (!inputCurrent)
{
// Debug.Log(totalBuffer == null);
nodeBuffer = compute.RunNodeCompute(this, node, seedTotal, totalBuffer, false);
}
else
{
for (int j = 0; j < node.iterations; j++)
{
totalBuffer = compute.RunNodeCompute(this, node, seedTotal, totalBuffer, true);
}
// if (preview && totalBuffer != null) { compute.DisposeBuffer(ref totalBuffer); }
}
// if (preview && nodeBuffer != null) { compute.DisposeBuffer(ref nodeBuffer); }
}
if (totalBuffer != null && nodeBuffer != null && !inputCurrent)
{
compute.RunComputeMethod(this, node, totalBuffer, ref nodeBuffer, itemList.Count, i == lastActive ? rtPreview : null);
}
}
else
{
TC_NodeGroup nodeGroup = itemList[i] as TC_NodeGroup;
if (nodeGroup != null)
{
if (!nodeGroup.active)
{
continue;
}
if (totalBuffer == null)
{
totalBuffer = nodeGroup.ComputeValue(seedTotal);
}
else
{
nodeBuffer = nodeGroup.ComputeValue(seedTotal);
}
if (totalBuffer != null && nodeBuffer != null)
{
compute.RunComputeMethod(this, nodeGroup, totalBuffer, ref nodeBuffer, itemList.Count, i == lastActive ? rtPreview : null);
}
}
}
}
if (totalActive == 1)
{
TC_Compute.DisposeRenderTexture(ref rtPreview);
rtDisplay = itemList[firstActive].rtDisplay;
}
if (isPortalCount > 0 && totalBuffer != null)
{
TC_Compute.instance.MakePortalBuffer(this, totalBuffer);
}
return(totalBuffer);
}
