public override void NodeGUI() { GUILayout.BeginVertical(); // Signal input knob and value label GUILayout.BeginHorizontal(); signalKnob.DisplayLayout(); GUILayout.Label(string.Format("value: {0:0.0000}", signalKnob.GetValue <float>())); GUILayout.EndHorizontal(); GUILayout.FlexibleSpace(); GUILayout.BeginHorizontal(); //Top/mid/bottom labels GUILayout.FlexibleSpace(); GUILayout.BeginVertical(); GUILayout.Label(string.Format("{0:0.00}", windowMaxY)); GUILayout.FlexibleSpace(); GUILayout.Label(string.Format("{0:0.00}", (windowMaxY + windowMinY) / 2)); GUILayout.FlexibleSpace(); GUILayout.Label(string.Format("{0:0.00}", windowMinY)); GUILayout.EndVertical(); GUILayout.Box(graphTexture, GUILayout.MaxWidth(256), GUILayout.MaxHeight(256)); GUILayout.EndHorizontal(); GUILayout.Space(4); GUILayout.EndVertical(); outputTexKnob.SetPosition(DefaultSize.x - 20); 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 bool Calculate() { signalValue = inputSignalKnob.GetValue <float>(); switch (triggerMode.SelectedOption()) { case "leadingEdge": output = (signalValue > threshold) && !wasOverThreshold; break; case "trailingEdge": output = (signalValue < threshold) && wasOverThreshold; break; case "high": output = signalValue > threshold; break; case "low": output = signalValue < threshold; break; default: output = false; break; } wasOverThreshold = signalValue > threshold; outputEventKnob.SetValue(output); return(true); }
public override bool Calculate() { var newPeriod = periodInputKnob.connected() ? periodInputKnob.GetValue <float>() : period; var newPhase = phaseInputKnob.connected() ? phaseInputKnob.GetValue <float>() : phase; if (newPeriod != period || newPhase != phase) { if (newPeriod != period) { //Find a phase such that the oscillator won't instantaneously jump in amplitude //If phase and freq change on the same Calculate()... we pick freq. float t = Time.time; newPhase = 2 * Mathf.PI * t - (newPeriod / period) * (2 * Mathf.PI * t - phase); } period = newPeriod; phase = newPhase; } synthShader.SetInt("width", outputSize.x); synthShader.SetInt("height", outputSize.y); synthShader.SetFloat("period", period); synthShader.SetFloat("phase", phase); synthShader.SetFloat("time", Time.time); synthShader.SetTexture(kernelId, "OutputTex", outputTex); var threadGroupX = Mathf.CeilToInt(outputSize.x / 16.0f); var threadGroupY = Mathf.CeilToInt(outputSize.y / 16.0f); synthShader.Dispatch(kernelId, threadGroupX, threadGroupY, 1); // Assign output channels textureOutputKnob.SetValue(outputTex); return(true); }
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 bool Calculate() { tinselOne.phase = Time.time / 10; tinselOne.amplitude = tinselAmplitude; tinselOne.thickness = tinselThickness; tinselOne.offset = tinselOffset; tinselOne.period = tinselOne.amplitude * 1.25f; turbScale = turbScaleKnob.connected() ? turbScaleKnob.GetValue <float>() : turbScale; if (turbScale != oldScale) { oldScale = turbScale; GenerateNoiseTex(); patternShader.SetTexture(patternKernel, "noiseTex", noiseTex); } turbFactor = turbIntensityKnob.connected() ? turbIntensityKnob.GetValue <float>() : turbFactor; patternShader.SetInt("width", outputTex.width); patternShader.SetInt("height", outputTex.height); patternShader.SetTexture(patternKernel, "OutputTex", outputTex); uint tx, ty, tz; //patternShader.GetKernelThreadGroupSizes(patternKernel, out tx, out ty, out tz); //patternShader.Dispatch(patternKernel, Mathf.CeilToInt(outputTex.width / tx), Mathf.CeilToInt(outputTex.height / ty), 1); DrawTree(); textureOutputKnob.SetValue(treeTex); 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() { 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() { if (input1Knob.connected()) { Input1Val = input1Knob.GetValue <float> (); } if (input2Knob.connected()) { Input2Val = input2Knob.GetValue <float> (); } switch (type) { case CalcType.Add: outputKnob.SetValue <float> (Input1Val + Input2Val); break; case CalcType.Substract: outputKnob.SetValue <float> (Input1Val - Input2Val); break; case CalcType.Multiply: outputKnob.SetValue <float> (Input1Val * Input2Val); break; case CalcType.Divide: outputKnob.SetValue <float> (Input1Val / Input2Val); break; } return(true); }
public override bool Calculate() { var dummySpectrum = new float[32]; for (int i = 0; i < 32; i++) { dummySpectrum[i] = 0.5f; } spectrumData = spectrumDataKnob.GetValue <float[]>(); if (spectrumData != null) { patternShader.SetInt("width", outputSize.x); patternShader.SetInt("height", outputSize.y); patternShader.SetInt("spectrumSize", spectrumData.Length); patternShader.SetFloats("spectrumData", spectrumData); 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() { a = aKnob.connected() ? aKnob.GetValue <float>(): a; b = bKnob.connected() ? bKnob.GetValue <float>() : b; m1 = m1Knob.connected() ? m1Knob.GetValue <float>() : m1; m2 = m2Knob.connected() ? m2Knob.GetValue <float>() : m2; n1 = n1Knob.connected() ? n1Knob.GetValue <float>() : n1; n2 = n2Knob.connected() ? n2Knob.GetValue <float>() : n2; n3 = n3Knob.connected() ? n3Knob.GetValue <float>() : n3; patternShader.SetFloat("a", a); patternShader.SetFloat("b", b); patternShader.SetFloat("m1", m1); patternShader.SetFloat("m2", m2); patternShader.SetFloat("n1", n1); patternShader.SetFloat("n2", n2); patternShader.SetFloat("n3", n3); patternShader.SetInt("width", outputSize.x); patternShader.SetInt("height", outputSize.y); 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 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 bool Calculate() { VoxelBlock <T> block = input.GetValue <VoxelBlock <T> >(); if (block == null || block.Layers == null) { return(false); } CalculationSetup(block); bool success = true; for (int i = 0; i < block.Layers.Count(); i++) { if (!CalculateLayer(block.Layers[i], i - block.Overlap)) { success = false; break; } } CalculationTeardown(); output.SetValue(block); return(success); }
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() { 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 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() { 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 (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 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 override bool CalculateVoxel(Voxel voxel, int x, int y, int z) { if (thresholdConnection.connected()) { threshold = thresholdConnection.GetValue <float>(); } voxel.Data = voxel.Data > threshold ? 1.0f : 0.0f; return(true); }
public override bool Calculate() { outputTop.SetValue <float> (inputTop.GetValue <float> ()); outputBottom.SetValue <float> (inputBottom.GetValue <float> ()); outputRight.SetValue <float> (inputRight.GetValue <float> ()); outputLeft.SetValue <float> (inputLeft.GetValue <float> ()); return(true); }
private void AddDye() { fluidSimShader.SetFloat("dyeMultiplier", dyeInputLevel); Graphics.Blit(dyeInputKnob.GetValue <Texture>(), scaledBuffer); fluidSimShader.SetTexture(dyeKernel, "uField", dyeField); fluidSimShader.SetTexture(dyeKernel, "vField", scaledBuffer); ExecuteFullTexShader(dyeKernel); Graphics.Blit(resultField, dyeField); }
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() { 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 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 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); }
protected override void ConfigureMaterial(Material material) { var combineTex = combineInputKnob.GetValue <Texture>(); if (combineTex) { material.SetTexture("_CombineTex", combineTex); } material.SetFloat("_CombineMode", (float)_combineMode); }