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); }