public override Texture2D GenerateTexture()
{
if (!IsShaderInit)
{
return(Texture2D.whiteTexture);
}
if (!Dirty)
{
return(HasTexture ? Texture : GenerateTexture());
}
NoiseNode inputNoise = GetInputValue <NoiseNode>("input");
if (inputNoise == null)
{
return(Texture2D.whiteTexture);
}
Texture2D inputTexture = inputNoise.Texture == null?inputNoise.GenerateTexture() : inputNoise.Texture;
Material noiseMaterial = new Material(shader);
noiseMaterial.SetTexture("_Texture", inputTexture);
noiseMaterial.SetFloat("_Threshold", threshold);
Texture = TextureMaker.Generate(GetGraph.mapSize, noiseMaterial);
GetPort(nameof(output))?.GetConnections()?.ForEach(f => ((NoiseNode)f.node)?.SetTextureDirty());
Dirty = false;
return(Texture);
}
public override int GetWidth()
{
NoiseNode noiseNode = (NoiseNode)target;
if (noiseNode != null && noiseNode.HasTexture && noiseNode.ShowTextureInEditor)
{
return((int)(150 * noiseNode.GetGraph.Ratio));
}
return((int)(base.GetWidth() * 1.2f));
}
public override Texture2D GenerateTexture()
{
if (!IsShaderInit)
{
return(Texture2D.whiteTexture);
}
if (!GetInputPort(nameof(input1)).IsConnected || !GetInputPort(nameof(input2)).IsConnected)
{
return(Texture2D.whiteTexture);
}
if (!Dirty)
{
return(HasTexture ? Texture : GenerateTexture());
}
NoiseNode input1Noise = GetInputValue <NoiseNode>("input1");
NoiseNode input2Noise = GetInputValue <NoiseNode>("input2");
if (input1Noise == null)
{
return(Texture2D.whiteTexture);
}
if (input2Noise == null)
{
return(Texture2D.whiteTexture);
}
Texture2D input1Texture = input1Noise.Texture == null?input1Noise.GenerateTexture() : input1Noise.Texture;
Texture2D input2Texture = input2Noise.Texture == null?input2Noise.GenerateTexture() : input2Noise.Texture;
Texture = new Texture2D(GetGraph.mapSize.x, GetGraph.mapSize.y, TextureFormat.RGBA32, false);
Material noiseMaterial = new Material(shader);
noiseMaterial.SetTexture("_Texture1", input1Texture);
noiseMaterial.SetTexture("_Texture2", input2Texture);
noiseMaterial.SetInt("_Mode", (int)mixType);
Texture = TextureMaker.Generate(GetGraph.mapSize, noiseMaterial);
GetPort(nameof(output))?.GetConnections()?.ForEach(f => ((NoiseNode)f.node)?.SetTextureDirty());
Dirty = false;
return(Texture);
}
public override void OnBodyGUI()
{
EditorGUI.BeginChangeCheck();
NoiseNode noiseNode = (NoiseNode)target;
if (noiseNode.Dirty)
{
noiseNode.GenerateTexture();
}
base.OnBodyGUI();
Rect lastRect = GUILayoutUtility.GetLastRect();
Rect toggleRect = new Rect(lastRect)
{
width = 18,
height = 18,
y = lastRect.y + EditorGUIUtility.singleLineHeight,
x = (GetWidth() - 18f) / 2
};
noiseNode.ShowTextureInEditor = EditorGUI.Toggle(toggleRect, noiseNode.ShowTextureInEditor, NodeEditorResources.styles.preview);
GUILayoutUtility.GetRect(toggleRect.width, toggleRect.height);
if (noiseNode.ShowTextureInEditor)
{
if (noiseNode.HasTexture)
{
Rect textureRect = new Rect(toggleRect)
{
width = GetWidth() * 0.95f,
height = GetWidth() * 0.8f / noiseNode.GetGraph.Ratio,
y = toggleRect.y + EditorGUIUtility.singleLineHeight * 2
};
textureRect.x = (GetWidth() - textureRect.width) / 2;
GUILayoutUtility.GetRect(textureRect.width, textureRect.height + EditorGUIUtility.singleLineHeight);
EditorGUI.DrawPreviewTexture(textureRect, noiseNode.Texture);
}
}
if (EditorGUI.EndChangeCheck())
{
noiseNode.Update();
}
}
public override Texture2D GenerateTexture()
{
if (!Dirty)
{
return(Texture != null ? Texture : GenerateTexture());
}
NoiseNode inputNoise = GetInputValue <NoiseNode>("input");
if (inputNoise == null)
{
return(Texture2D.whiteTexture);
}
Texture = inputNoise.Texture == null?inputNoise.GenerateTexture() : inputNoise.Texture;
Dirty = false;
return(Texture);
}
void ContextCallback(object obj)
{
string clb = obj.ToString();
if (clb.Equals("noiseNode"))
{
NoiseNode noiseNode = new NoiseNode();
noiseNode.windowRect = new Rect(mousePos, new Vector2(200, 150));
//noiseNode.myComputeTextureCreator = computeTextureCreator;
nodes.Add(noiseNode);
noiseNode.name = "zzz" + noiseNode.name + saver.assetAmount.ToString();
noiseNode.index = nodes.Count - 1;
saver.assetAmount += 1;
saver.nodes.Add(noiseNode);
AssetDatabase.AddObjectToAsset(noiseNode, pathName);
AssetDatabase.SaveAssets();
//AssetDatabase.ImportAsset(pathName);
}
else if (clb.Equals("calculationNode"))
{
CalculationNode noiseNode = new CalculationNode();
noiseNode.windowRect = new Rect(mousePos, new Vector2(200, 150));
nodes.Add(noiseNode);
noiseNode.name = "zzz" + noiseNode.name + saver.assetAmount.ToString();
saver.assetAmount += 1;
saver.nodes.Add(noiseNode);
AssetDatabase.AddObjectToAsset(noiseNode, pathName);
AssetDatabase.SaveAssets();
}
else if (clb.Equals("outputNode"))
{
OutputNode noiseNode = new OutputNode();
noiseNode.windowRect = new Rect(mousePos, new Vector2(200, 200));
nodes.Add(noiseNode);
noiseNode.name = "zzz" + noiseNode.name + saver.assetAmount.ToString();
saver.assetAmount += 1;
saver.nodes.Add(noiseNode);
AssetDatabase.AddObjectToAsset(noiseNode, pathName);
AssetDatabase.SaveAssets();
}
else if (clb.Equals("waveNode"))
{
WaveNode noiseNode = new WaveNode();
noiseNode.windowRect = new Rect(mousePos, new Vector2(200, 200));
nodes.Add(noiseNode);
noiseNode.name = "zzz" + noiseNode.name + saver.assetAmount.ToString();
saver.assetAmount += 1;
saver.nodes.Add(noiseNode);
AssetDatabase.AddObjectToAsset(noiseNode, pathName);
AssetDatabase.SaveAssets();
}
else if (clb.Equals("makeTransition"))
{
bool clickedOnWindow = false;
BaseNode tempSelectedNode = null;
foreach (BaseNode node in nodes)
{
if (node.windowRect.Contains(mousePos))
{
tempSelectedNode = node;
clickedOnWindow = true;
break;
}
}
if (clickedOnWindow)
{
selectedNode = tempSelectedNode;
makeTransitionMode = true;
}
AssetDatabase.SaveAssets();
}
else if (clb.Equals("callMethod"))
{
foreach (BaseNode node in nodes)
{
if (node.windowRect.Contains(mousePos))
{
((NoiseNode)(node)).TheMethod(0);
break;
}
}
}
else if (clb.Equals("deleteNode"))
{
bool clickedOnWindow = false;
BaseNode tempSelectedNode = null;
int index = 0;
foreach (BaseNode node in nodes)
{
if (node.windowRect.Contains(mousePos))
{
index = nodes.IndexOf(node);
tempSelectedNode = node;
clickedOnWindow = true;
break;
}
}
if (clickedOnWindow)
{
//nodes = nodes.Where(x => x.index != index).ToList();
//nodes.Remove(tempSelectedNode);
nodes.Remove(tempSelectedNode);
saver.nodes.Remove(tempSelectedNode);
//nodes.RemoveAt(index);
foreach (BaseNode node in nodes)
{
node.NodeDeleted(tempSelectedNode);
//node.NodeDeleted(index);
}
DestroyImmediate(tempSelectedNode, true);
AssetDatabase.SaveAssets();
//AssetDatabase.ImportAsset(pathName);
}
}
}
public override Texture2D GenerateTexture()
{
if (!Dirty)
{
return(HasTexture ? Texture : GenerateTexture());
}
NoiseNode inputNoise = GetInputValue <NoiseNode>("input");
if (inputNoise == null)
{
return(Texture2D.whiteTexture);
}
Texture2D inputTexture = !inputNoise.HasTexture ? inputNoise.GenerateTexture() : inputNoise.Texture;
Vector2Int size = new Vector2Int(inputTexture.width, inputTexture.height);
Texture = TextureMaker.Generate(inputTexture);
Color[] colors = Texture.GetPixels();
List <List <Vector2Int> > regions = new List <List <Vector2Int> >();
HashSet <int> visited = new HashSet <int>();
for (int i = 0; i < colors.Length; i++)
{
if (GetDenoiseCondition(colors[i]))
{
continue;
}
Vector2Int coord = new Vector2Int(i % size.x, i / size.x);
if (visited.Contains(i))
{
continue;
}
List <Vector2Int> region = CheckRegion(colors, coord, size, ref visited);
if (region.Count > 0)
{
regions.Add(region);
}
}
foreach (List <Vector2Int> region in regions)
{
if (region.Count > minRoomSize)
{
continue;
}
foreach (Vector2Int coord in region)
{
colors[coord.x + coord.y * size.x] = GetDenoiseColor();
}
}
Texture.SetPixels(colors);
Texture.Apply();
GetPort(nameof(output))?.GetConnections()?.ForEach(f => ((NoiseNode)f.node)?.SetTextureDirty());
Dirty = false;
return(Texture);
}
void CreateInstructionBuffer()
{
instructionBuffer = new List <float>();
for (int i = 0; i < PriorityQueue.Count; i++)
{
BaseInputNode node = PriorityQueue[i];
if (node.priority == 0)
{
instructionBuffer.Add(-1f);
instructionBuffer.Add(i);
}
else if (node.HasInputs())
{
if (node.GetType() == typeof(NoiseNode))
{
NoiseNode noiseNode = (NoiseNode)node;
instructionBuffer.Add(-3);
instructionBuffer.Add(i);
for (int j = 0; j < noiseNode.inputNodes.Count; j++)
{
foreach (BaseInputNode node1 in noiseNode.inputNodes[j].nodes)
{
instructionBuffer.Add(PriorityQueue.IndexOf(node1) + j / 100);
}
}
instructionBuffer.Add(i);
}
if (node.GetType() == typeof(CalculationNode))
{
CalculationNode calcNode = (CalculationNode)node;
switch (calcNode.calcType)
{
case CalcType.Adition:
instructionBuffer.Add(-2.1f);
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[0]));
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[1]));
break;
case CalcType.Subtraction:
instructionBuffer.Add(-2.2f);
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[0]));
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[1]));
break;
case CalcType.Division:
instructionBuffer.Add(-2.3f);
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[0]));
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[1]));
break;
case CalcType.Multiplication:
instructionBuffer.Add(-2.4f);
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[0]));
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[1]));
break;
case CalcType.SingleNumber:
instructionBuffer.Add(-2.5f);
break;
case CalcType.Clamp:
instructionBuffer.Add(-2.6f);
if (calcNode.inputNodes[0] != null)
{
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[0]));
}
else if (calcNode.inputNodes[1] != null)
{
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[1]));
}
instructionBuffer.Add(calcNode.clampValues.x);
instructionBuffer.Add(calcNode.clampValues.y);
break;
case CalcType.ReScale:
instructionBuffer.Add(-2.7f);
if (calcNode.inputNodes[0] != null)
{
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[0]));
}
else if (calcNode.inputNodes[1] != null)
{
instructionBuffer.Add(PriorityQueue.IndexOf(calcNode.inputNodes[1]));
}
instructionBuffer.Add(calcNode.numberScale.x);
instructionBuffer.Add(calcNode.numberScale.y);
break;
}
}
}
}
}
