public override void NodeGUI()
{
//GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
speedInputKnob.DisplayLayout(new GUIContent("Speed", "The speed to pan in image widths/second"));
if (!speedInputKnob.connected())
{
speed = RTEditorGUI.Slider(speed, -1, 1);
}
angleInputKnob.DisplayLayout(new GUIContent("Angle", "The angle to pan in radians"));
if (!angleInputKnob.connected())
{
angle = RTEditorGUI.Slider(angle, 0, 6.2831f);
}
GUILayout.BeginHorizontal();
smoothTransitions = RTEditorGUI.Toggle(smoothTransitions, new GUIContent("Smooth", "Whether the image panning should use bilinear filtering to produce smooth transitions"));
mirror = RTEditorGUI.Toggle(mirror, new GUIContent("Mirror", "Use mirror wraping at texture edges"));
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label(string.Format("Offset: ({0:0.00}, {1:0.00})", offset.x, offset.y));
if (GUILayout.Button("Reset"))
{
offset = Vector2.zero;
}
GUILayout.EndHorizontal();
GUILayout.EndVertical();
//GUILayout.EndHorizontal();
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
public override bool Calculate()
{
Texture tex = inputTexKnob.GetValue <Texture>();
if (!inputTexKnob.connected() || tex == null)
{ // Reset outputs if no texture is available
outputSize = Vector2Int.zero;
if (outputTex != null)
{
outputTex.Release();
spoutController.RefreshSender();
}
return(true);
}
var inputSize = new Vector2Int(tex.width, tex.height);
if (inputSize != outputSize)
{
outputSize = inputSize;
InitializeRenderTexture();
}
if (inputTexKnob.connected() && tex != null)
{
Graphics.Blit(tex, outputTex);
}
return(true);
}
public override void NodeGUI()
{
base.NodeGUI();
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
// First input
if (thresholdConnection.connected())
{
GUILayout.Label(thresholdConnection.name);
}
else
{
threshold = RTEditorGUI.FloatField(GUIContent.none, threshold);
}
thresholdConnection.SetPosition();
GUILayout.EndVertical();
GUILayout.EndHorizontal();
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
public override void NodeGUI()
{
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
input.DisplayLayout();
GUILayout.BeginHorizontal();
GUILayout.Label(surfaceConnection.name);
if (!surfaceConnection.connected())
{
surface = RTEditorGUI.FloatField(GUIContent.none, surface);
}
surfaceConnection.SetPosition();
GUILayout.EndHorizontal();
GUILayout.EndVertical();
GUILayout.EndHorizontal();
RTEditorGUI.EnumPopup(new GUIContent("Generation", "The type of Vertex generation"), mode, m =>
{
if (mode != m)
{
mode = m;
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
});
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
public override void NodeGUI()
{
GUILayout.BeginVertical();
emissionRateKnob.DisplayLayout();
if (!emissionRateKnob.connected())
{
emissionRate = RTEditorGUI.Slider(emissionRate, 0, 1000);
}
else
{
emissionRate = emissionRateKnob.GetValue <float>();
}
GUILayout.FlexibleSpace();
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Box(outputTex, GUILayout.MaxWidth(64), GUILayout.MaxHeight(64));
GUILayout.EndHorizontal();
GUILayout.Space(4);
GUILayout.EndVertical();
outputTexKnob.SetPosition(180);
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
public override void NodeGUI()
{
inputTexKnob.SetPosition(20);
GUILayout.BeginVertical();
controlSignalKnob.DisplayLayout();
if (!controlSignalKnob.connected())
{
controlSignal = RTEditorGUI.Slider(controlSignal, 0, 1);
}
else
{
controlSignal = controlSignalKnob.GetValue <float>();
}
GUILayout.FlexibleSpace();
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Box(outputTex, GUILayout.MaxWidth(64), GUILayout.MaxHeight(64));
GUILayout.EndHorizontal();
GUILayout.Space(4);
GUILayout.EndVertical();
outputTexKnob.SetPosition(180);
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
public override void NodeGUI()
{
GUILayout.BeginVertical();
inputSignalKnob.DisplayLayout();
GUILayout.BeginHorizontal();
recordControlKnob.DisplayLayout();
// Start state: neither recorded nor recording
if (!clipRecorded && !clipRecording)
{
// Display start recording button
if (GUILayout.Button("Start recording"))
{
StartRecording();
}
}
else
{
// Second state: recording input
if (clipRecording)
{
// Display end recording button
if (GUILayout.Button("Finish"))
{
FinishRecording();
}
}
// Third state: recording is finished
else
{
// Display Start/stop button
string label = clipPlaying ? "Stop" : "Start";
if (GUILayout.Button(label))
{
TogglePlayback();
}
}
}
GUILayout.EndHorizontal();
frequencyModulationKnob.DisplayLayout();
if (!frequencyModulationKnob.connected())
{
frequencyModulation = RTEditorGUI.Slider(frequencyModulation, 0, 1);
}
if (clipRecorded)
{
if (GUILayout.Button("Reset"))
{
ResetRecording();
}
}
GUILayout.EndVertical();
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
public override void NodeGUI()
{
GUILayout.BeginVertical();
GUILayout.BeginHorizontal(GUILayout.MaxHeight(40));
//GUILayout.Label(new GUIContent("Turbulence factor", "The offset of the normal angle per point"));
turbIntensityKnob.DisplayLayout();
if (!turbIntensityKnob.connected())
{
turbFactor = RTEditorGUI.Slider(turbFactor, 0, 1, options: GUILayout.MaxWidth(120));
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal(GUILayout.MaxHeight(40));
turbScaleKnob.DisplayLayout();
//GUILayout.Label(new GUIContent("Turbulence scale", "The offset of the normal angle per point"));
if (!turbScaleKnob.connected())
{
turbScale = RTEditorGUI.Slider(turbScale, 2, 64, options: GUILayout.MaxWidth(120));
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal(GUILayout.MaxHeight(40));
tinselThicknessKnob.DisplayLayout();
if (!tinselThicknessKnob.connected())
{
tinselThickness = RTEditorGUI.Slider(tinselThickness, 1, 32, options: GUILayout.MaxWidth(120));
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal(GUILayout.MaxHeight(40));
tinselAmplitudeKnob.DisplayLayout();
if (!tinselAmplitudeKnob.connected())
{
tinselAmplitude = RTEditorGUI.Slider(tinselAmplitude, 2, 32, options: GUILayout.MaxWidth(120));
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal(GUILayout.MaxHeight(40));
tinselOffsetKnob.DisplayLayout();
if (!tinselOffsetKnob.connected())
{
tinselOffset = RTEditorGUI.Slider(tinselOffset, 0, 128, options: GUILayout.MaxWidth(120));
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal(GUILayout.MaxHeight(40));
GUILayout.Box(noiseTex, GUILayout.MaxHeight(100));
GUILayout.Box(treeTex, GUILayout.MaxHeight(100));
GUILayout.EndHorizontal();
GUILayout.EndVertical();
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
public override void NodeGUI()
{
GUILayout.BeginVertical();
aKnob.DisplayLayout();
if (!aKnob.connected())
{
a = RTEditorGUI.Slider(a, 0.1f, 100);
}
bKnob.DisplayLayout();
if (!bKnob.connected())
{
b = RTEditorGUI.Slider(b, 0.1f, 100);
}
m1Knob.DisplayLayout();
if (!m1Knob.connected())
{
m1 = RTEditorGUI.Slider(m1, 0, 100);
}
m2Knob.DisplayLayout();
if (!m2Knob.connected())
{
m2 = RTEditorGUI.Slider(m2, 0, 100);
}
n1Knob.DisplayLayout();
if (!n1Knob.connected())
{
n1 = RTEditorGUI.Slider(n1, 0, 100);
}
n2Knob.DisplayLayout();
if (!n2Knob.connected())
{
n2 = RTEditorGUI.Slider(n2, 0, 100);
}
n3Knob.DisplayLayout();
if (!n3Knob.connected())
{
n3 = RTEditorGUI.Slider(n3, 0, 100);
}
GUILayout.FlexibleSpace();
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Box(outputTex, GUILayout.MaxWidth(64), GUILayout.MaxHeight(64));
GUILayout.EndHorizontal();
GUILayout.Space(4);
GUILayout.EndVertical();
outputTexKnob.SetPosition(236);
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
public override bool Calculate()
{
Texture tex = textureInputKnob.GetValue <Texture>();
if (!textureInputKnob.connected() || tex == null)
{ // Reset outputs if no texture is available
textureOutputKnob.ResetValue();
outputSize = Vector2Int.zero;
return(true);
}
var inputSize = new Vector2Int(tex.width, tex.height);
if (inputSize != outputSize)
{
outputSize = inputSize;
InitializeRenderTexture();
}
//Execute compute shader
PolarizeShader.SetInt("width", tex.width);
PolarizeShader.SetInt("height", tex.height);
PolarizeShader.SetTexture(kernelId, "OutputTex", outputTex);
PolarizeShader.SetTexture(kernelId, "InputTex", tex);
var threadGroupX = Mathf.CeilToInt(tex.width / 16.0f);
var threadGroupY = Mathf.CeilToInt(tex.height / 16.0f);
PolarizeShader.Dispatch(kernelId, threadGroupX, threadGroupY, 1);
// Assign output channels
textureOutputKnob.SetValue(outputTex);
return(true);
}
public override bool Calculate()
{
if (timeMultiplierKnob.connected())
{
timeMultiplier = timeMultiplierKnob.GetValue <float>();
}
if (applyForceKnob.GetValue <bool>())
{
ApplyVelocity();
}
if (running && Time.time - lastStep > 1 / 60f)
{
if (continuousDye)
{
AddDye();
}
if (clicked)
{
timestep = Time.deltaTime;
}
else
{
timestep = Time.time - lastStep;
}
lastStep = Time.time;
SimulateFluid();
}
if (clicked)
{
clicked = false;
}
textureOutputKnob.SetValue <Texture>(dyeField);
return(true);
}
public override bool Calculate()
{
_output = null;
if (!inputKnob.connected())
{
return(true);
}
var input = inputKnob.GetValue <Texture>();
if (input && !string.IsNullOrEmpty(savePath))
{
Directory.CreateDirectory(Path.GetDirectoryName(savePath));
Debug.Log("Saving to '" + savePath + "'!");
Texture2D outputTexture = input as Texture2D;
if (outputTexture == null && input is RenderTexture)
{
}
if (outputTexture == null)
{
Debug.LogWarning($"Failed to generate output for {savePath}, unrecognised texture type. Should be one of: Texture2D or RenderTexture.");
return(false);
}
File.WriteAllBytes(savePath, outputTexture.EncodeToPNG());
#if UNITY_EDITOR
UnityEditor.AssetDatabase.Refresh();
#endif
_output = outputTexture;
}
return(true);
}
public override bool Calculate()
{
var input = inputKnob.GetValue <Texture>();
if (!input || !outputKnob.connected())
{
return(true);
}
var output = CreateOutputTexture(input);
if (_material == null)
{
_material = new Material(GetShader());
}
ConfigureMaterial(_material);
Graphics.Blit(input, output, _material);
var prevActive = RenderTexture.active;
RenderTexture.active = output;
var outputTexture = new Texture2D(output.width, output.height);
outputTexture.ReadPixels(new Rect(0, 0, output.width, output.height), 0, 0);
outputTexture.Apply();
RenderTexture.active = prevActive;
outputKnob.SetValue <Texture>(outputTexture);
return(true);
}
public override bool Calculate()
{
Channel RChannel = channelRKnob.connected() ? channelRKnob.GetValue <Channel>() : null;
Channel GChannel = channelGKnob.connected() ? channelGKnob.GetValue <Channel>() : null;
Channel BChannel = channelBKnob.connected() ? channelBKnob.GetValue <Channel>() : null;
Channel AChannel = channelAKnob.connected() ? channelAKnob.GetValue <Channel>() : null;
if (RChannel == null && GChannel == null && BChannel == null)
{
bundledKnob.ResetValue();
return(true);
}
int width = Mathf.Max(new int[] { RChannel != null ? RChannel.width : 0, GChannel != null ? GChannel.width : 0, BChannel != null ? BChannel.width : 0, AChannel != null ? AChannel.width : 0 });
int height = Mathf.Max(new int[] { RChannel != null ? RChannel.height : 0, GChannel != null ? GChannel.height : 0, BChannel != null ? BChannel.height : 0, AChannel != null ? AChannel.height : 0 });
Texture2D bundled = new Texture2D(width, height, AChannel != null ? TextureFormat.RGBA32 : TextureFormat.RGB24, false);
bundled.name = "Bundled Tex";
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
bundled.SetPixel(x, y, new Color(RChannel != null ? RChannel.GetValue(x, y, width, height) : 0,
GChannel != null ? GChannel.GetValue(x, y, width, height) : 0,
BChannel != null ? BChannel.GetValue(x, y, width, height) : 0,
AChannel != null ? AChannel.GetValue(x, y, width, height) : 1));
}
}
bundled.Apply();
bundledKnob.SetValue(bundled);
return(true);
}
public override bool Calculate()
{
patternShader.SetInts("outputSize", outputSize.x, outputSize.y);
patternShader.SetInt("maxIterations", maxIterations);
patternShader.SetInt("order", order);
patternShader.SetFloat("bias", bias);
patternShader.SetFloat("zoom", zoom);
patternShader.SetFloat("radius", radius);
if (offsetKnob.connected())
{
offset = offsetKnob.GetValue <Vector2>();
}
else
{
offset = new Vector2(1, 1);
}
patternShader.SetFloats("offset", offset.x, offset.y);
patternShader.SetVector("convergeColor", Color.red);
patternShader.SetVector("divergeColor", Color.black);
patternShader.SetTexture(patternKernel, "outputTex", outputTex);
uint tx, ty, tz;
patternShader.GetKernelThreadGroupSizes(patternKernel, out tx, out ty, out tz);
var threadGroupX = Mathf.CeilToInt(((float)outputSize.x) / tx);
var threadGroupY = Mathf.CeilToInt(((float)outputSize.y) / ty);
patternShader.Dispatch(patternKernel, threadGroupX, threadGroupY, 1);
outputTexKnob.SetValue(outputTex);
return(true);
}
public override bool Calculate()
{
Texture tex = textureInputKnob.GetValue <Texture>();
if (!textureInputKnob.connected() || tex == null)
{ // Reset outputs if no texture is available
textureOutputKnob.ResetValue();
outputSize = Vector2Int.zero;
return(true);
}
if (outputSize.x == 0 || outputSize.y == 0 || reflections != previousReflections)
{
outputSize = new Vector2Int(tex.width, tex.height * reflections);
previousReflections = reflections;
InitializeRenderTexture();
Debug.Log("tex.height");
Debug.Log(tex.height);
}
//Execute compute shader
KaleidoscopeShader.SetInt("width", tex.width);
KaleidoscopeShader.SetInt("height", tex.height);
KaleidoscopeShader.SetTexture(kernelId, "InputTex", tex);
KaleidoscopeShader.SetTexture(kernelId, "OutputTex", outputTex);
var threadGroupX = Mathf.CeilToInt(outputTex.width / 16.0f);
var threadGroupY = Mathf.CeilToInt(outputTex.height / 16.0f);
KaleidoscopeShader.Dispatch(kernelId, threadGroupX, threadGroupY, 1);
// Assign output channels
textureOutputKnob.SetValue(outputTex);
return(true);
}
public override bool Calculate()
{
if (Time.time - lastCalced > (1 / targetFPS))
{
Texture tex = inputTexKnob.GetValue <Texture>();
if (!inputTexKnob.connected() || tex == null)
{ // Reset outputs if no texture is available
if (buffer != null)
{
buffer.Release();
}
outputSize = Vector2Int.zero;
return(true);
}
var inputSize = new Vector2Int(tex.width, tex.height);
if (inputSize != outputSize)
{
outputSize = inputSize;
InitializeRenderTexture();
}
Graphics.Blit(tex, buffer);
Texture2D tex2d = buffer.ToTexture2D();
FillFromTexture(tex2d);
SendDMX();
Destroy(tex2d);
lastCalced = Time.time;
}
return(true);
}
public override bool Calculate()
{
float value = 0;
float t = Time.time;
amplitude = amplInputKnob.connected() ? amplInputKnob.GetValue <float>() : amplitude;
period = periodInputKnob.connected() ? periodInputKnob.GetValue <float>() : period;
phase = phaseInputKnob.connected() ? phaseInputKnob.GetValue <float>() : phase;
offset = 0;
if (paramStyle.SelectedOption() == "min max")
{
amplitude = (max - min) / 2;
offset = min + amplitude;
}
var newParams = (period, amplitude, phase);
var oldParams = (lastPeriod, lastAmplitude, lastPhase);
if (newParams != oldParams)
{
if (period != lastPeriod)
{
phase = (t - period / lastPeriod * (t - lastPhase)) % period;
}
}
value = signalGenerators[signalType.SelectedOption()](t, period, amplitude, phase, 0);
outputKnob.SetValue(value + offset);
lastPeriod = period;
lastPhase = phase;
lastAmplitude = amplitude;
return(true);
}
public override void NodeGUI()
{
gameStateKnob.SetPosition(20);
GUILayout.BeginVertical();
if (gameStateKnob.connected())
{
if (GUILayout.Button("Apply state"))
{
Graphics.Blit(gameStateKnob.GetValue <Texture>(), inputState);
}
}
string label = running ? "Stop" : "Run";
if (GUILayout.Button(label))
{
running = !running;
}
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Box(outputState, GUILayout.MaxWidth(64), GUILayout.MaxHeight(64));
GUILayout.EndHorizontal();
GUILayout.Space(4);
GUILayout.EndVertical();
outputTexKnob.SetPosition(DefaultSize.x - 20);
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
public override void NodeGUI()
{
inputTexKnob.SetPosition(20);
GUILayout.BeginVertical();
startHueKnob.DisplayLayout();
if (!startHueKnob.connected())
{
startHue = RTEditorGUI.Slider(startHue, 0, 1);
}
else
{
startHue = startHueKnob.GetValue <float>();
}
endHueKnob.DisplayLayout();
if (!endHueKnob.connected())
{
endHue = RTEditorGUI.Slider(endHue, 0, 1);
}
else
{
endHue = endHueKnob.GetValue <float>();
}
offsetKnob.DisplayLayout();
if (!offsetKnob.connected())
{
offset = RTEditorGUI.Slider(offset, 0, 1);
}
else
{
offset = offsetKnob.GetValue <float>();
}
center = RTEditorGUI.Toggle(center, new GUIContent("Center", "Gradient from center"));
GUILayout.FlexibleSpace();
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Box(outputTex, GUILayout.MaxWidth(64), GUILayout.MaxHeight(64));
GUILayout.EndHorizontal();
GUILayout.Space(4);
GUILayout.EndVertical();
outputTexKnob.SetPosition(180);
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
protected bool EventKnobOrButton(string label, ValueConnectionKnob knob)
{
GUILayout.BeginHorizontal();
knob.DisplayLayout();
bool val = knob.connected() ? GUILayout.Button(label) || knob.GetValue <bool>() : GUILayout.Button(label);
GUILayout.EndHorizontal();
return(val);
}
public override bool Calculate()
{
Texture tex = textureInputKnob.GetValue <Texture>();
if (!textureInputKnob.connected() || tex == null)
{ // Reset outputs if no texture is available
textureOutputKnob.ResetValue();
outputSize = Vector2Int.zero;
if (outputTex != null)
{
outputTex.Release();
}
return(true);
}
// Guard against multiple Calculate()'s per frame
if (Time.time - lastStep > Time.deltaTime)
{
lastStep = Time.time;
}
else
{
textureOutputKnob.SetValue(outputTex);
return(true);
}
var inputSize = new Vector2Int(tex.width, tex.height);
if (inputSize != outputSize)
{
outputSize = inputSize;
InitializeRenderTexture();
}
in1 = in1Knob.connected() ? in1Knob.GetValue <float>() : in1;
in2 = in2Knob.connected() ? in2Knob.GetValue <float>() : in2;
SetOffsetAndKnobParams();
BoundOffset();
int panKernel = ChooseKernel();
panShader.SetInt("width", tex.width);
panShader.SetInt("height", tex.height);
panShader.SetFloats("offset", offset.x, offset.y);
panShader.SetTexture(panKernel, "OutputTex", outputTex);
panShader.SetTexture(panKernel, "InputTex", tex);
var threadGroupX = Mathf.CeilToInt(tex.width / 16.0f);
var threadGroupY = Mathf.CeilToInt(tex.height / 16.0f);
panShader.Dispatch(panKernel, threadGroupX, threadGroupY, 1);
// Assign output channels
textureOutputKnob.SetValue(outputTex);
return(true);
}
public override bool Calculate()
{
if (!block1Connection.connected() || !block2Connection.connected())
{
return(false);
}
VoxelBlock <Voxel> block1 = block1Connection.GetValue <VoxelBlock <Voxel> >();
VoxelBlock <Voxel> block2 = block2Connection.GetValue <VoxelBlock <Voxel> >();
int overlap = block1.Overlap;
int width = block1.Width;
int height = block1.Height;
int length = block1.Length;
for (int y = 0; y < height + 2 * overlap; y++)
{
VoxelLayer <Voxel> l1 = block1.Layers[y];
VoxelLayer <Voxel> l2 = block2.Layers[y];
for (int x = 0; x < width + 2 * overlap; x++)
{
for (int z = 0; z < length + 2 * overlap; z++)
{
var v1 = l1.Layer[x, z];
var v2 = l2.Layer[x, z];
switch (mode)
{
case CombiningMode.Average:
v1.Data = (v1.Data + v2.Data) / 2;
break;
case CombiningMode.Add:
v1.Data = v1.Data + v2.Data;
break;
case CombiningMode.Subtract:
v1.Data = v1.Data - v2.Data;
break;
case CombiningMode.Divide:
if (v2.Data != 0)
{
v1.Data = v1.Data / v2.Data;
}
break;
case CombiningMode.Multiply:
v1.Data = v1.Data * v2.Data;
break;
}
}
}
}
outputConnection.SetValue(block1);
return(true);
}
public override void NodeGUI()
{
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
// First input
if (input1Knob.connected())
{
GUILayout.Label(input1Knob.name);
}
else
{
Input1Val = RTEditorGUI.FloatField(GUIContent.none, Input1Val);
}
input1Knob.SetPosition();
// Second input
if (input2Knob.connected())
{
GUILayout.Label(input2Knob.name);
}
else
{
Input2Val = RTEditorGUI.FloatField(GUIContent.none, Input2Val);
}
input2Knob.SetPosition();
GUILayout.EndVertical();
GUILayout.BeginVertical();
// Output
outputKnob.DisplayLayout();
GUILayout.EndVertical();
GUILayout.EndHorizontal();
type = (CalcType)RTEditorGUI.EnumPopup(new GUIContent("Calculation Type", "The type of calculation performed on Input 1 and Input 2"), type);
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
public static int GetSeed(ValueConnectionKnob knob, int localValue)
{
Debug.Assert(typeof(int).IsAssignableFrom(knob.valueType), "Tried to read seed from a non-int source knob.");
if (knob.connected())
{
return(knob.GetValue <int>());
}
return(localValue);
}
public override void NodeGUI()
{
GUILayout.BeginVertical();
textureInputKnob.SetPosition(20);
GUILayout.BeginHorizontal();
widthInputKnob.DisplayLayout();
if (!widthInputKnob.connected())
{
width = RTEditorGUI.Slider(width, 1f, 1024f);
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
heightInputKnob.DisplayLayout();
if (!heightInputKnob.connected())
{
height = RTEditorGUI.Slider(height, 1f, 1024f);
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
// Strategy for in size < out size: choose scale/tile/mirror, default is fill black/alpha
// Strategy for out size < in size: default crop, allow scale
GUILayout.Label("Edge wrap mode");
RadioButtons(edgeWrapMode);
GUILayout.EndVertical();
GUILayout.BeginVertical();
GUILayout.FlexibleSpace();
GUILayout.Box(outputTex, GUILayout.MaxHeight(64), GUILayout.MaxWidth(64));
GUILayout.EndVertical();
GUILayout.EndHorizontal();
textureOutputKnob.SetPosition(DefaultSize.x - 20);
GUILayout.EndVertical();
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
public override void NodeGUI()
{
texLKnob.SetPosition(20);
texRKnob.SetPosition(60);
GUILayout.BeginVertical();
GUILayout.BeginHorizontal();
RadioButtons(mergeModeSelection);
GUILayout.EndHorizontal();
if (mergeModeSelection.Selected == "Simple")
{
crossfaderKnob.DisplayLayout();
if (!crossfaderKnob.connected())
{
crossfader = RTEditorGUI.Slider(crossfader, 0, 1);
}
else
{
crossfader = crossfaderKnob.GetValue <float>();
}
}
GUILayout.FlexibleSpace();
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Box(outputTex, GUILayout.MaxWidth(64), GUILayout.MaxHeight(64));
GUILayout.EndHorizontal();
GUILayout.Space(4);
GUILayout.EndVertical();
outputTexKnob.SetPosition(180);
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
public override void NodeGUI()
{
GUILayout.BeginVertical();
GUILayout.BeginHorizontal();
RadioButtonsVertical(signalType);
GUILayout.BeginVertical();
GUILayout.Label("Param config:");
RadioButtons(paramStyle);
outputKnob.DisplayLayout();
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.FlexibleSpace();
if (paramStyle.SelectedOption() == "amplitude")
{
amplInputKnob.DisplayLayout();
if (!amplInputKnob.connected())
{
amplitude = RTEditorGUI.FloatField(amplitude);
}
}
else if (paramStyle.SelectedOption() == "min max")
{
min = RTEditorGUI.FloatField("Min", min);
max = RTEditorGUI.FloatField("Max", max);
}
FloatKnobOrSlider(ref period, 0.01f, 50, periodInputKnob);
FloatKnobOrSlider(ref phase, -period, period, phaseInputKnob);
GUILayout.Space(4);
GUILayout.EndVertical();
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
protected void IntKnobOrSlider(ref int val, int min, int max, ValueConnectionKnob knob, params GUILayoutOption[] layoutOpts)
{
GUILayout.BeginHorizontal();
knob.DisplayLayout();
if (!knob.connected())
{
val = RTEditorGUI.IntSlider(val, min, max, layoutOpts);
}
else
{
val = knob.GetValue <int>();
}
GUILayout.EndHorizontal();
}
public override bool Calculate()
{
tex = inputKnob.connected() ? inputKnob.GetValue <Texture2D>() : null;
if (!string.IsNullOrEmpty(savePath))
{
Directory.CreateDirectory(Path.GetDirectoryName(savePath));
Debug.Log("Saving to '" + savePath + "'!");
File.WriteAllBytes(savePath, tex.EncodeToPNG());
#if UNITY_EDITOR
UnityEditor.AssetDatabase.Refresh();
#endif
}
return(true);
}
