static public void AddMenuItem(TC_Node node, GenericMenu menu, string instanceID, Enum e, int startIndex = 0, bool showOne = false)
{
int length;
if (showOne)
{
length = startIndex + 1;
}
else
{
length = Enum.GetNames(e.GetType()).Length;
}
string inputName = e.GetType().ToString().Replace("TerrainComposer2.Input", "");
for (int i = startIndex; i < length; i++)
{
string name = Enum.GetName(e.GetType(), i);
if ((name == "Convexity" || name == "Collision") && node.outputId != TC.heightOutput)
{
menu.AddSeparator("Terrain/");
}
if (name == "IQ" || name == "Random")
{
menu.AddSeparator("Noise/");
}
menu.AddItem(new GUIContent(inputName + "/" + name), false, ClickMenuInput, instanceID + ":" + inputName + "/" + name);
}
}
static public void Draw(TC_Node node, bool nodeFoldout, bool drawMethod, Vector2 pos, Color color, float activeMulti)
{
// Draw total node
// startOffset.x -= TD.nodeSpaceWidth;
// parent.DropDownMenu();
bool isCulled = false;
Rect rect = TD.DrawNode(node, pos, color, Color.white, ref isCulled, activeMulti, nodeFoldout, drawMethod, false);
if (nodeFoldout)
{
Rect rectButton = new Rect(pos.x + 7.24f, pos.y + 306.09f, 253.92f, 30);
if (TD.GetRectScaled(rectButton).y > 0)
{
string text = node.GetInputPopup().ToString();
TD.DrawTextureScaled(rectButton, TD.texButton, color * activeMulti);
TD.DrawText(new Vector2(rectButton.x + 5.02f, rectButton.y + 14.54f), text, 21, Color.white, FontStyle.Normal, HorTextAlign.Left, VerTextAlign.Center);
//if (node.inputKind == InputKind.Terrain && node.inputTerrain == InputTerrain.Splatmap)
//{
// TD.DrawTextureScaled(new Rect(pos.x + g.rect3.x, pos.y + g.rect3.y, 75, 75), TC_Settings.instance.GetPreviewSplatTexture(node.splatSelectIndex), Color.white * activeMulti * 0.8f);
//}
DrawAddItem(rect, pos, node);
DropDownMenuInput(TD.GetRectScaled(rectButton), node);
}
LeftClickMenu(rect, node);
}
}
static public void DropDownMenuInput(Rect rect, TC_Node node)
{
if (TD.ClickRect(rect) != 0)
{
return;
}
GenericMenu menu = new GenericMenu();
string instanceID = node.GetInstanceID().ToString();
if (node.outputId == TC.heightOutput)
{
AddMenuItem(node, menu, instanceID, node.inputTerrain, 5, true);
}
else
{
AddMenuItem(node, menu, instanceID, node.inputTerrain, 0);
}
AddMenuItem(node, menu, instanceID, node.inputNoise);
AddMenuItem(node, menu, instanceID, node.inputShape);
AddMenuItem(node, menu, instanceID, node.inputFile);
AddMenuItem(node, menu, instanceID, node.inputCurrent);
menu.AddItem(new GUIContent("Portal"), false, ClickMenuInput, instanceID + ":Portal/Portal");
menu.ShowAsContext();
Event.current.Use();
}
public void CopySpecial(TC_Node node)
{
posOffset = node.posOffset;
bool lockPosParent = node.lockPosParent;
if (node.lockTransform || lockPosParent)
{
Vector3 posTemp = Vector3.zero;
Quaternion rotTemp;
Vector3 scaleTemp = Vector3.zero;
if (!(node.lockPosX || lockPosParent)) posTemp.x = node.t.position.x; else posTemp.x = position.x;
if (!(node.lockPosY || lockPosParent)) posTemp.y = node.posY * scale.y; else posTemp.y = position.y;
if (!(node.lockPosZ || lockPosParent)) posTemp.z = node.t.position.z; else posTemp.z = position.z;
if (!(node.lockRotY && node.lockTransform)) rotTemp = Quaternion.Euler(0, node.t.eulerAngles.y, 0); else rotTemp = rotation;
if (!(node.lockScaleX && node.lockTransform)) scaleTemp.x = node.t.lossyScale.x; else scaleTemp.x = scale.x;
if (!(node.lockScaleY && node.lockTransform))
{
if (node.nodeType == NodeGroupType.Mask) scaleTemp.y = node.t.localScale.y; else scaleTemp.y = node.t.lossyScale.y * node.opacity;
}
else scaleTemp.y = scale.y;
if (!(node.lockScaleZ && node.lockTransform)) scaleTemp.z = node.t.lossyScale.z; else scaleTemp.z = scale.z;
position = posTemp;
rotation = rotTemp;
scale = scaleTemp;
if (node.t.position != position) node.t.position = position;
if (node.t.rotation != rotation) node.t.rotation = rotation;
node.t.hasChanged = false;
}
else
{
rotation = Quaternion.Euler(0, node.t.eulerAngles.y, 0);
scale.x = node.t.lossyScale.x;
scale.z = node.t.lossyScale.z;
if (node.nodeType == NodeGroupType.Mask) scale.y = node.t.localScale.y; else scale.y = node.t.lossyScale.y;
scale.y *= node.opacity;
position = node.t.position;
position.y = node.posY * scale.y;
}
// if (scale.x == 0) scale.x = 1;
// if (scale.y == 0) scale.y = 1;
// if (scale.z == 0) scale.z = 1;
}
public override void UpdateTransforms()
{
// ct.CopySpecial(this);
for (int i = 0; i < itemList.Count; i++)
{
TC_Node node = itemList[i] as TC_Node;
if (node != null)
{
node.ct.CopySpecial(node);
}
}
}
public override void SetLockChildrenPosition(bool lockPos)
{
lockPosParent = lockPos;
for (int i = 0; i < itemList.Count; i++)
{
TC_Node node = itemList[i] as TC_Node;
if (node != null)
{
node.lockPosParent = lockPosParent || lockPosChildren;
}
}
}
static public void DeleteKey()
{
if (Selection.transforms != null)
{
for (int i = 0; i < Selection.transforms.Length; i++)
{
Transform t = Selection.transforms[i];
TC_LayerGroup layerGroup = t.GetComponent <TC_LayerGroup>();
TC_LayerGroupResult groupResult = t.GetComponent <TC_LayerGroupResult>();
TC_SelectItemGroup selectItemGroup = t.GetComponent <TC_SelectItemGroup>();
TC_NodeGroup nodeGroup = t.GetComponent <TC_NodeGroup>();
TC_Node node = t.GetComponent <TC_Node>();
if (node != null)
{
if (node.nodeType == NodeGroupType.Select)
{
TC_NodeGroup nodeGroupParent = (TC_NodeGroup)node.parentItem;
if (nodeGroupParent.itemList.Count == 1 && node.outputId != TC.heightOutput)
{
TC.AddMessage("Select node cannot be deleted as there is always minimum one needed in a Layer."); continue;
}
}
}
else if (layerGroup != null)
{
if (layerGroup.level == 0)
{
TC.AddMessage("The main " + TC.outputNames[layerGroup.outputId] + " Output Layer Group cannot be deleted. \n\nRight click to clear it."); continue;
}
}
else if (groupResult != null)
{
TC.AddMessage("A Result Node cannot be deleted. The Layer Group itself needs to be deleted."); continue;
}
else if (selectItemGroup != null)
{
selectItemGroup.Clear(true); continue;
}
else if (nodeGroup != null)
{
nodeGroup.Clear(true); continue;
}
Undo.DestroyObjectImmediate(Selection.gameObjects[i]);
--i;
}
}
}
public void LinkClone(TC_NodeGroup nodeGroupS)
{
preview = nodeGroupS.preview;
for (int i = 0; i < itemList.Count; i++)
{
TC_Node node = itemList[i] as TC_Node;
if (node != null)
{
TC_Node sNode = nodeGroupS.itemList[i] as TC_Node;
node.preview = sNode.preview;
node.Init();
}
}
}
public override bool ContainsCollisionNode()
{
for (int i = 0; i < itemList.Count; i++)
{
TC_Node node = itemList[i] as TC_Node;
if (node != null)
{
if (node.active && node.visible)
{
if (node.inputKind == InputKind.Terrain && node.inputTerrain == InputTerrain.Collision)
{
return(true);
}
}
}
}
return(false);
}
public void CopySpecial(TC_ItemBehaviour item)
{
TC_Node node = item as TC_Node;
bool maskNode = false;
if (node != null)
{
if (node.nodeType == NodeGroupType.Mask)
{
maskNode = true;
}
}
posOffset = item.posOffset;
bool lockPosParent = item.lockPosParent;
if (item.lockTransform || lockPosParent)
{
Vector3 posTemp = Vector3.zero;
Quaternion rotTemp;
Vector3 scaleTemp = Vector3.zero;
if (!(item.lockPosX || lockPosParent))
{
posTemp.x = item.t.position.x;
}
else
{
posTemp.x = position.x;
}
if (!(item.lockPosY || lockPosParent))
{
posTemp.y = item.posY * scale.y;
}
else
{
posTemp.y = position.y;
}
if (!(item.lockPosZ || lockPosParent))
{
posTemp.z = item.t.position.z;
}
else
{
posTemp.z = position.z;
}
if (!(item.lockRotY && item.lockTransform))
{
rotTemp = Quaternion.Euler(0, item.t.eulerAngles.y, 0);
}
else
{
rotTemp = rotation;
}
if (!(item.lockScaleX && item.lockTransform))
{
scaleTemp.x = item.t.lossyScale.x;
}
else
{
scaleTemp.x = scale.x;
}
if (!(item.lockScaleY && item.lockTransform))
{
if (maskNode)
{
scaleTemp.y = item.t.localScale.y;
}
else
{
scaleTemp.y = item.t.lossyScale.y * item.opacity;
}
}
else
{
scaleTemp.y = scale.y;
}
if (!(item.lockScaleZ && item.lockTransform))
{
scaleTemp.z = item.t.lossyScale.z;
}
else
{
scaleTemp.z = scale.z;
}
position = posTemp;
rotation = rotTemp;
scale = scaleTemp;
if (item.t.position != position)
{
item.t.position = position;
}
if (item.t.rotation != rotation)
{
item.t.rotation = rotation;
}
item.t.hasChanged = false;
}
else
{
rotation = Quaternion.Euler(0, item.t.eulerAngles.y, 0);
scale.x = item.t.lossyScale.x;
scale.z = item.t.lossyScale.z;
if (maskNode)
{
scale.y = item.t.localScale.y;
}
else
{
scale.y = item.t.lossyScale.y;
}
scale.y *= item.opacity;
position = item.t.position;
position.y = item.posY * scale.y;
}
// if (scale.x == 0) scale.x = 1;
// if (scale.y == 0) scale.y = 1;
// if (scale.z == 0) scale.z = 1;
}
static public void ClickMenuInput(object obj)
{
int instanceID;
string command = TD.ObjectToCommandAndInstanceID(obj, out instanceID);
TC_Node node = EditorUtility.InstanceIDToObject(instanceID) as TC_Node;
if (node != null)
{
int index = command.IndexOf("/");
string inputKind = command.Substring(0, index);
string input = command.Substring(index + 1);
bool changed = false;
InputKind oldInputKind = node.inputKind;
node.inputKind = (InputKind)Enum.Parse(typeof(InputKind), inputKind);
if (node.inputKind != oldInputKind)
{
changed = true;
}
if (inputKind == "Terrain")
{
InputTerrain oldInputTerrain = node.inputTerrain;
node.inputTerrain = (InputTerrain)Enum.Parse(typeof(InputTerrain), input);
if (node.inputTerrain != oldInputTerrain)
{
changed = true;
}
}
else if (inputKind == "Noise")
{
InputNoise oldInputNoise = node.inputNoise;
node.inputNoise = (InputNoise)Enum.Parse(typeof(InputNoise), input);
if (node.inputNoise != oldInputNoise)
{
changed = true;
}
}
else if (inputKind == "Shape")
{
InputShape oldInputShape = node.inputShape;
node.inputShape = (InputShape)Enum.Parse(typeof(InputShape), input);
if (node.inputShape != oldInputShape)
{
changed = true;
}
}
else if (inputKind == "File")
{
InputFile oldInputFile = node.inputFile;
node.inputFile = (InputFile)Enum.Parse(typeof(InputFile), input);
if (node.inputFile != oldInputFile)
{
changed = true;
}
}
else if (inputKind == "Current")
{
InputCurrent oldInputCurrent = node.inputCurrent;
node.inputCurrent = (InputCurrent)Enum.Parse(typeof(InputCurrent), input);
if (node.inputCurrent != oldInputCurrent)
{
changed = true;
}
}
if (changed)
{
node.Init();
EditorUtility.SetDirty(node);
TC.RefreshOutputReferences(node.outputId, true);
}
}
}
static public int Draw(TC_NodeGroup nodeGroup, ref Vector2 pos, Color colGroupNode, Color colNode, Color colBracket, float activeMulti, bool nodeFoldout, bool drawMethod, bool colorPreviewTex, bool hideSelectNodes)
{
if (nodeGroup == null)
{
return(0);
}
// bool select = false;
// Draw total node
Rect dropDownRect;
float activeMultiOld = activeMulti;
activeMulti *= nodeGroup.active ? 1 : 0.75f;
bool isCulled = false;
TC_GlobalSettings g = TC_Settings.instance.global;
// if ((nodeGroup.foldout == 1 && nodeGroup.itemList.Count == 1) || nodeGroup.itemList.Count == 0) nodeGroup.foldout = 0;
// Closing Bracket
TD.DrawBracket(ref pos, nodeFoldout, true, colBracket * activeMultiOld, ref nodeGroup.foldout, true, nodeGroup.itemList.Count > 0);
if (nodeGroup.foldout > 0)
{
if ((nodeGroup.itemList.Count != 1 || nodeGroup.foldout != 1) && nodeGroup.itemList.Count != 0 && !hideSelectNodes)
{
pos.x -= TD.texCardBody.width;
}
if (nodeGroup.itemList.Count > 1 && !hideSelectNodes)
{
dropDownRect = TD.DrawNode(nodeGroup, pos, colGroupNode, Color.white, ref isCulled, activeMulti, nodeFoldout, drawMethod, false);
if (nodeGroup.foldout == 2)
{
pos.x -= TD.texCardBody.width + g.nodeHSpace;
}
DropDownMenu(dropDownRect, nodeGroup);
}
//if (colorPreviewTex)
//{
// startOffset.x -= TD.nodeWidth;
// TD.DrawNode(nodeGroup, drawMethod, ref startOffset, true, color, click, Color.white, ref isCulled);
// startOffset.x -= TD.nodeWidth;
//}
// Draw ()
//if (nodeGroup.itemList.Count > 1)
//{
// startOffset.x += 10;
// Draw ItemList Count
// if (!nodeGroup.foldout)
// {
// TD.DrawRect(new Rect(startOffset.x - 9, (startOffset.y + TD.nodeHeight / 2) - 5, 18, 10), TC_Settings.instance.global.colTextBackGround);
// TD.DrawText(new Vector2(startOffset.x + 2, startOffset.y + TD.nodeHeight / 2), nodeGroup.itemList.Count.ToString(), 8, FontStyle.Bold, Color.white, HorTextAlign.Center, VerTextAlign.Center);
// }
// startOffset.x -= TD.nodeWidthSpace;
//}
if (nodeGroup.foldout == 2 && !hideSelectNodes)
{
if (nodeGroup.itemList.Count > 1 && nodeFoldout)
{
TD.DrawMethod(nodeGroup, pos + new Vector2(TD.texCardBody.width - 18, 172), true, colNode, activeMulti);
}
for (int i = nodeGroup.itemList.Count - 1; i >= 0; --i)
{
TC_Node node = nodeGroup.itemList[i] as TC_Node;
if (node != null)
{
TC_NodeGUI.Draw(node, nodeFoldout, i == 0 ? false : true, pos, colNode, activeMulti);
if (i != 0)
{
pos.x -= TD.nodeWidthHSpace;
}
if (node.inputKind != InputKind.Current && node.inputKind != InputKind.Portal && i != 0 && nodeFoldout)
{
TD.DrawMethod(node, pos + new Vector2(TD.texCardBody.width - 18, 172), false, colNode, (node.active ? 1 : 0.5f) * activeMulti);
}
}
else
{
TC_NodeGroup nodeGroupChild = nodeGroup.itemList[i] as TC_NodeGroup;
if (nodeGroupChild != null)
{
pos.x += TD.nodeWidthHSpace;
Draw(nodeGroupChild, ref pos, colGroupNode, colNode, colBracket, activeMulti, nodeFoldout, drawMethod, false, false);
if (i != 0)
{
pos.x -= TD.nodeWidthHSpace;
TD.DrawMethod(nodeGroupChild, pos + new Vector2(TD.texCardBody.width - 18, 172), false, colNode, (nodeGroupChild.active ? 1 : 0.5f) * activeMulti);
}
}
}
}
}
}
if (nodeFoldout)
{
int mouseClick = TD.DrawNodeCount(nodeGroup, ref pos, nodeGroup.itemList.Count, nodeFoldout, ref nodeGroup.foldout, (nodeGroup.foldout == 1 && nodeGroup.itemList.Count != 1 ? colGroupNode * 0.75f : colBracket) * activeMulti);
if (mouseClick == 0 && nodeGroup.itemList.Count == 0)
{
nodeGroup.Add <TC_Node>("", false, false, true);
}
}
// Opening Bracket
TD.DrawBracket(ref pos, nodeFoldout, false, colBracket * activeMultiOld, ref nodeGroup.foldout, true, nodeGroup.itemList.Count > 0);
return(0);
}
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);
}
public override void GetItems(bool refresh, bool rebuildGlobalLists, bool resetTextures)
{
if (resetTextures)
{
DisposeTextures();
}
int childCount = transform.childCount;
// Init();
itemList.Clear();
active = visible;
firstActive = lastActive = -1;
totalActive = 0;
bool newBounds = true;
int listIndex = 0;
for (int i = childCount - 1; i >= 0; i--)
{
Transform child = t.GetChild(i);
TC_Node node = child.GetComponent <TC_Node>();
if (node != null)
{
if (resetTextures)
{
node.DisposeTextures();
}
node.active = true;
node.Init();
if (node.inputKind == InputKind.Current && totalActive == 0)
{
TC.AddMessage("'Current' can only be used if there is active node/s before it.");
node.active = false;
}
if (!node.visible)
{
node.active = false;
// Debug.Log(node.name);
}
node.SetParameters(this, listIndex);
node.nodeGroupLevel = nodeGroupLevel + 1;
node.nodeType = type;
node.UpdateVersion();
if (node.active)
{
if (node.clamp)
{
node.CalcBounds();
}
if (newBounds)
{
bounds = node.bounds; newBounds = false;
}
else
{
bounds.Encapsulate(node.bounds);
}
lastActive = listIndex;
if (firstActive == -1)
{
firstActive = lastActive;
}
++totalActive;
}
if (i == childCount - 1) // TODO: Consider hide and do in calculation
{
if (node.method != Method.Add && node.method != Method.Subtract)
{
node.method = Method.Add;
}
}
itemList.Add(node);
++listIndex;
}
else
{
TC_NodeGroup nodeGroup = child.GetComponent <TC_NodeGroup>();
if (nodeGroup != null)
{
nodeGroup.SetParameters(this, listIndex);
nodeGroup.nodeGroupLevel = nodeGroupLevel + 1;
itemList.Add(nodeGroup);
++listIndex;
nodeGroup.GetItems(refresh, rebuildGlobalLists, resetTextures);
if (nodeGroup.active)
{
lastActive = listIndex;
if (firstActive == -1)
{
firstActive = lastActive;
}
++totalActive;
}
}
//else
//{
// TC_NodeClone nodeClone = child.GetComponent<TC_NodeClone>();
//}
}
}
if (itemList.Count == 1)
{
if (itemList[0].active)
{
active = visible = true;
}
}
if (!active)
{
totalActive = 0;
}
if (totalActive == 0)
{
active = false;
}
}
