This Float value stepper uses the Elena Designs ESD Step Increment Float Module to step up and down in GUI and DSP Floating point values, which are also converted to DSP Voltage for controlling DSP Modules. There is no built in Wrap function on this module, so when you reach the upper limit it counts no further. There are four settings taken to an IO Mod: Minimum – sets the lowest float value, Maximum sets the highest float value, Step sets the amount by which the stepper increments/decrements, Display Decimals– sets the number of decimal points in the displayed value.
The GUI-DSP Bool Switch: This is just a slider control changed to Small Button in the properties list, with its DSP output voltage converted to GUI bools, then containerised.
This Pre-Fab steps up and down through a user pre-set range of integers, with the option to wrap or non-wrap the count. Wrapping means that when you reach the maximum or minimum points the count doesn’t stop. At the maximum it starts decrementing, and at the minimum it starts incrementing. In non-wrapping mode the count halts at maximum or minimum. The integer stepping range is set in the Pre-Fab’s properties using the range 0,n Text input plug. The first number does not need to be zero . Note: The first digit in the count must be lower in value than the second Integer, the prefab will not function with the values reversed or with negative values, and this plug will only update the number of steps set in properties when the audio engine is running. The Wrap function is a Boolean input, or can be set in the Prefab properties via the Wrap plug. Note: this plug will only update the Wrap mode when the audio engine is running. The Increment 3 Module does just that, it steps backwards or forwards through the range specified on the Item List plug the format is: range minInt, maxInt, for example range 2,22 will step through the range of Integers starting at 2 and ending at 22. The Patch Memory Text Out and Patch Memory Bool Out modules are required for the Prefab to receive, use, and remember the values set on the range 0,n and Wrap plugs. Without these modules these plugs will not function. There are two Integer outputs, DSP and GUI.
Clickable text labels. The Image2 modules can be replaced with any GUI module that sends/receives a Mouse Down event. So the layout below will work just the same, but with the added feature that clicking on the Up/Down text labels will also step through the count.
Expanding on the functionality: By Adding a few more modules we can add more outputs: GUI/DSP Float and DSP Volts. Note: Even though Float and Volts have decimal places, because our Increment module outputs Integers you will never get decimal places.
This seems to be something that confuses most newcomers to the world of SynthEdit plug-in design. Once you know how it’s done its easy, if a little repetitive in large projects. The usual mistake that’s made is to change the Name in the properties panel, then wonder why the control is still labelled “Knob” in the panel view. The first thing to realise is that the Knob control is not so much a module as a prefab, which you can open up and customise.
How to rename the Synthedit Knob control.
Put a knob control into a structure window. Double click on the blue bar at the top, and it will open a new structure window.
Once this is open all you need to do is select the Text Entry4 module, then in the Properties panel change the entry in the Text box from “Knob” to a suitable title for the control. press the return (enter) key and close the window. Your knob is now renamed.
Hint: If you find yourself doing this lots of times and using the same titles, why not set up some prefabs knobs of your own with useful titles such as: Cut-off, Q, Frequency, Attack, Decay & so on. You can even set up your own sub-folder in the Prefabs folder called Knobs to keep your selection in. You’ll usually find the Prefabs folder by using Windows File Explorer in one of the sections under Users: see below…
Saving a new Prefab. Just right click on your renamed Knob control, and select Selection to Prefab from the popup menu and save in your folder of choice. You’ll then be able to see your new prefab control in the Modules menu.
The idea behind this is that you can step through the options (for example) of an oscillator with just a single button rather than using a drop-down list box. Once the prefab control is put together it’s self configuring apart from the text label, and text colours. The list is taken from the module you connect up to.
How to step through a list with a single button in SynthEdit.
The idea here is that when we click on the button (Image2) module, it sends a “True” pulse to the ED Step Increment Int module, which connects to the PatchMemory List3 module. The PM List3 module reads the list of options from the DSP module (for example an Oscillator) it’s connected to and converts this to an Enumerated List For the List to Text and ED Step Increment Int module…(this makes life easier…less typing, and less opportunity for errors creeping in). Each time the ED Step Increment Int module receives a True pulse on the Increment plug it advances one step at a time through the list of options by advancing the Integer count by one step. The DAM list size module is used to inform the ED Step Increment Int module how many steps there should be, but for some reason I found you need to subtract 1 from the list co get the correct size. The two ED Text entry modules are used to display the selected value, and add a label to the control. Note: The Wrap option on the ED Step Increment Int module module should be set to “True” by selecting this on the options panel, then we can cycle through the list forever… Note: The RH-Int-Redir module is needed to connect up the ED Step Increment Int module and the List to Text module due to the Outputs being on the LHS of the ED Step Increment Int module… The List to Text module sends the Text name of the option selected to the Text Entry4 module where the selected option is displayed in the text box. If you want to cycle the other way, just send the Boolean pulse to the Decrement plug, it’s as easy as that. Note: If you want to make the Text label into a “click to select” connect the Increment plug on the ED Step Increment Int module module to the Mouse Down plug on the Text Entry4 module, and then you can step through in the same way by clicking on the text box.
Connecting up and using the prefab is easy, as you can see below, as I said the list is automatically generated when you connect the Switch to the Modules “List” plug.
Why have separate control panels? Sometimes when we are designing a Synthesizer, we can end up with a very complex, if not outright cluttered and confusing control panel (we have all seen examples of those!). Wouldn’t it be great if we could have separate control panels for different functions, such as a sequencer panel, an effects panel, etc. Well the good news is that we can, and it’s not over complicated either! Not only this anyone who uses your plug-in will thank you for it too.
How to have separate panels-the push button route.
With a few sub controls we can switch between control panels using a stepper controlled by a single button. Each switch is connected to a Bools to Int module via an QTN_Volt2GUIBool. This module converts as DSP voltage to a GUI Bool signal. When a button is pressed it sends a momentary “True” to the Bools to Int module, which the outputs an integer which corresponds to the plug receiving the pulse. Bool Val 1 outputs a 1, Bool Val 2 outputs a 2 and so on… This is then converted back into individual latched (that is it’s held at “True” until a new integer value is received on the Value plug) Boolean outputs to the integer value received.
Note: When designing this sort of panel switching we need to be disciplined, and give plugs appropriate names wherever possible (annoyingly you can’t rename the plugs on some modules!) otherwise things can rapidly become extremely confusing, and difficult to de-bug.
When this is connected up as shown below, we can switch between the individual panels by clicking on the appropriate button. Each individual control, or panel must be inside a container of it’s own for this to work properly. Note: switching these panels on and off is only visible in the panel view when the audio engine is on, and not in not the structure view, where all the panel containers will be visible.
Admin note: Updated 03/02/24 to reflect changes in the Elena Designs module pack (dsp-gui modules removed).
This is a method of creating a combined control for a coarse and fine voltage setting. It’s quite simple and uses the newer Vector controls. This is the finished control (Sorry that flashy looking knob in the centre is V1.5 only but the principle will work with the plain Vector Knob B in V1.4)
How it looks using Vector Knob B in V1.4
This is the structure below (Inside a container). We are just taking the Animation position of each vector control through a PatchMemory Float 3 to convert it to a DSP float value, this will later be converted to Voltage for DSP modules. The PatchMem connected to the vector ring has its maximum value set to 1 so that we get a range of 0 to 1 for this control, and 0 to 10 for the Knob C. The two values are added together using an ED Add (Float) module, and converted to Volts for controlling DSP modules. This means we get a total range of 0 to 11 for the control (shades of Spinal Tap), so by setting the Knob C’s PatchMem to a maximum of 9, we go back to our usual default of 0 to 10 volts. All you need to do once its working is to create a panel view, size and line up the two controls then lock the container view and save as a prefab control. This enables us to use the main inner knob as a coarse 0 to 10 control, and the outer ring as a fine 0 to 1 control (or any range you wish).
Changing the control ranges:
Changing the ranges for the inner and outer controls is as easy as setting the Max and Min values in the properties panel. This is set up for 0-to-1 for the outer ring, and 0-to-9 for the knob, giving an overall range of 0-to10 Volts out.
Two similar concentric knobs (V1.5 only)
The principle is similar, however I have added a text readout for the output value, and a text label for the control. Colours of the knobs and the text are editable too.
I have seen this question asked a few times in various places online, and compared to the (outdated) solution in the old SynthEdit e-book this is quite an elegant solution. Your first move is to add a List Entry 4 module, then in the properties, enter the list of waveforms you want to have in your list (lets face it, if you have a four VCO synth, you really don’t need the White Noise and Pink Noise option on each one- you may even opt to have a separate noise source). You need to follow this format very carefully: Sine=0,Saw=1,Ramp=2,Triangle=3,Pulse=4,White Noise=5,Pink Noise=6 Just choose the options you want from this list, and enter them in the Item List box. Only use spaces where I have shown them, and remember the correct format name of waveform before number. You may think having option 0 is odd, but it’s an Enumerated List and in C++ (the language of Synthedit) these always start at 0. The actual text names you use in the list don’t have to be the names that are used in the Modules list, you can use names that are meaningful to you. Connecting the “Hint” plug on the List Entry 4 module to the “Name” plug on the Patch Memory List3 uses the name of the list that the module is connected to as a hint when you hover the mouse cursor oven the list box. The List to Text module supplies the list of items that will appear in the dropdown list, this needs no properties to be set.
The limited choice list in action in a VCO panel.
This can be applied to any module that has a List Selection plug such as an SV Filter, or a TD_Modules LFO. All you need to do is go through the list of options, always starting the list at 0 for the first item, then select the ones you want to keep/use. Note: As usual with PatchMemory modules, don’t copy and paste the one from this module… it WILL retain the values it took from the List Entry 4 module. In the structure below I have adapted the list for the SV Filter to take the Band Reject option out of the list: Low Pass=0,High Pass=1,Bandpass=2
This is another good module to gain an understanding of how sub controls work, and how the various modules interact.
The Stock Joystick module
It’s all fairly standard stuff in this prefab, apart from introducing the Spring Module. The Joystick Image module reports both of the Joystick control image X and Y positions as floating point values in the normal default range of 0 to 1 (Position X and Position Y plugs). A static Bitmap Image provides the background for the joystick control. Scaled from 0 to 1, the X and Y Positions plugs are connected to the Animation Position input plugs of the respective PatchMemory Float 3 modules. The PatchMemory Float3 Low Value and High Value are set to −5 and +5, respectively, which are set in the Properties panel.
These modules scale the Animation Position to float values within this range, and the Floating Point values are then converted to Voltages by the Float to Volts modules, and the voltages are fed to the X and Y output plugs. When the user releases the left mouse button after clicking or dragging the joystick knob, the Mouse Down value changes from True to False, this value is then input to both of the Spring Modules which sets the Animation Positions to the default value of 0.5, thereby centering the joystick knob as soon as the left mouse button is released. The default return value is set in the Properties Panel (see below). For the X axis: 0 = Left, 0.5 = Centre, 1.0 = Right. For the X axis: 0 = Bottom, 0.5 = Centre, 1.0 = Top.
Creating a custom slider control from a joystick control.
Its suggested in the SE help file that using the stock Joystick Image GUI control is a good place to start creating your own slider control. You can, but I find a much better option is the third party ED Joystick Image control, as this allows you to “constrain” the movement of the control in the X or Y axis, whereas the native SE control doesn’t, meaning you can still move the control horizontally…not ideal. By constrain we mean that you can set limits on how far the joystick’s knob can be moved in the X or Y axis, so if we set a minimum of 0.5 and a maximum of 0.5 for the Constrain X Min, and Constrain X Max, and leave the Constrain Y values at their default of 0 for the Minimum, and 1.0 for the Maximum, then we will get a vertical slider control, with no possibility of horizontal movement.
The structure of our new slider control prefab. There’s nothing too unusual in here, just a few things need explaining. Module names: Slider = ED Joystick Image. Scale = Image2 (SE Sub-Controls) Title = Text Entry4 Value = Text Entry4 I have just renamed these to make it easier to see what’s going on. You won’t find the Slider knob image or the Scale image in SE, you would need to create these yourself. This can be done in Paintshop Pro, Photoshop or similar editing software by cropping the scale off the VSlider_Med.png image and saving the knob as Slider-Knob.png (for example) and copying and pasting the scale into a new image V-Slider-Scale.png (for example). Don’t use the existing file names as this will mess up the SE controls! Don’t forget to save them as .png to preserve the transparency. You can now modify the new slider scale to the length you can require, and stretch your new slider control to fit. Note: you cannot “stretch” or resize the images used by the SE Image2 Sub-control. The Patch Memory modules on the Title and Decimal point are to enable you to set your values for the control without opening it, and editing, however the values you set will no show until you run the audio engine. The CTRL Scaling Factor sets how finely you can control the slider when the CTRL key is held down. For most purposes the default of 0.1 is fine.
The finished prefab control. I have put in output plugs for GUI as well as DSP controls, including the animation position, whether you do so is entirely up to you. As the DSP Float output is taken from the Patch Memory Float3 it’s already normalized, and suitable for DSP usage.
I think these modules are worth a separate page all on their own, as they are quite an “in depth” subject, and can be a source of confusion for beginners.
The rules of using Patch Memory.
Rule 1Avoid splitters (redirectors) Due to a design mistake, SynthEdit 1.0 had the Container’s ‘Control on Parent’ pin on the wrong side. This made it impossible to connect it to a Patch Mem module (needed for save/recall of paged panel settings). The ‘Bool Splitter’ was introduced to fix this problem, but the bool splitter causes problems of it’s own. The bool splitter ‘reflects‘ any one input signal back out it’s other inputs, this is a bad design because it is not clear which module is in control of the others. The result is modules ‘fighting‘ each other for control. Symptoms include ‘flakey‘ inconsistent behavior and patches not saved/recalled correctly. 3rd party module developers have sometimes copied SynthEdit’s example and released modules that rely on the use of splitters. This is not their fault, however if at all possible avoid using splitters.
Rule 2: The second rule of Patch Memory is: The first wire connected to the ‘Value Out’ plug always resets the Parameter. The Value, Name and Range of the parameter are taken from whatever module you are connecting to. To avoid this behaviour when replacing a wire – connect the new wire first before disconnecting the old one.
Rule 3:Do not connect a Patch Memory to the Polyphony Control module. The Polyphony control is itself a type of Patch Memory, so if you do it will cause data conflicts and the two modules will “fight” over which is doing what.
Rule 4: Never use more than one Patch Memory for each control in a Sub-Control since this can cause some very unpredictable data conflicts and extremely strange behaviors in your GUI controls.
Patch Memory Modules.
The Patch Memory modules are the hub around which you will construct any Sub-Control prefab. They are the link from your controls (GUI) to the audio side (DSP) of SynthEdit. They are also an Integral part of the system for creating and saving patches in the finished VST. What the Patch Memory can and cannot do. 1) GUI to DSP Link: They are the interface (bridge) between the DSP (Audio Processing) side, and the GUI controls and graphics. 2) Storing values for Presets: They allow the storing of values as a preset to “remember” the state or position of a control. 3) Store the value ranges of controls: Patch memory when used for Sub-Controls can be used to set the Minimum and Maximum values of the knob, switch, slider etc. This is useful as the default range is 0 to 10, but by using a Patch Memory Float or Integer the Minimum and Maximum can be set to any useful range. The Patch Memory Txt modules will only accept a single default value. 4) Use the correct type: There is one Patch Memory for each datatype, divided into input and output controls. Don’t fall into the trap of trying to use float Patch Memory for everything! 5) Limited Data Size: When using Patch Memory modules for passing large block of Data between modules (BLOB data is a good example) for samplers (for example) there is a limit to the maximum side of the block of data. 6) No Math or other processing: A Patch Memory Float module cannot handle any maths functions, changes to the number of digits after the decimal point. This must be handled by external modules. It just stores the 32bit Float value, and converts it to a DSP Float value. This applies also to the Text and Integer modules. Important Note: Data passed through a Patch Memory (especially BLOB) must never exceed 5Mb in size. V1.4 and it’s plug-ins will crash as as soon as the data maximum is exceeded. SynthEdit 1.5 is now much better behaved in this respect, it will now not pass the data through the Patch Memory at all, but will not crash. So we still have the 5Mb Data limit but SE and it’s VST plug ins handle the limit in a more stable manner. This limit applies to all the Patch Memory modules.
Note: In the Headings below I just refer to each of the two basic types of module as PatchMemory “Data-Type” 3 or PatchMemory “Data-type” Out3 where Data-Type is for example Integer, or Text to save loads of repetition.
PatchMemory “Data-type” 3
GUI in – DSP out.
These are the modules that take a GUI data input, and convert them to a DSP output, for example the module shown above will take the Position of an Image used as a control, convert it so data suitable for DSP output on the Value Out Plug.
PatchMemory “Data-Type” Out
DSP in – GUI out.
These are the modules that take a DSP data input, and convert them to a GUI output, for example the module shown above will take the value on the Value In plug, convert it so data suitable for GUI output on the Value, and Animation Position plugs. Value In: The Value In plug is always a DSP data plug receiving data from DSP to be sent to the GUI side. Value out: The Value Out plug is always a DSP data plug sending data from the GUI modules to the DSP side.
Send or Receive? Which way does the data flow?
This is somewhat confusing and counter intuitive for newcomers to SE but these are the rules for Patch Memory module names: A Patch Memory Out module always Inputs data from a DSP module. A Patch Memory Module always Outputs data to a DSP Module.
Note: GUI plugs are bi-directional, they send and receive. Note: The first wire connected to the ‘Value Out’ plug resets the Parameters. The Value, Name and Range of the parameter are taken from whatever module you are connecting to. To avoid and complications caused by this behaviour when replacing a connection:- always connect the new wire first before disconnecting the old one
Typical use of a PatchMemory Float3 Module.
One of the basic and easy to understand of PatchMemory uses is it’s use in the Knob prefab included in the SynthEdit control modules. 1) The Animation Position plug on the Patch Memory is linked to both of the Image2 modules (the body of the knob, and the shiny cap) as we want these to move together. Note: Although the Tinted Bitmap Image has an Animation Position plug It’s not used here, as we don’t want the scale for the knob to move. 2) The Patch Memory Float3 module serves three main purposes: a) To link all the modules together b) It memorizes the position of the knob c) It allows us to convert the position of the image of a knob into a Floating Point value, which is output as a DSP value (hence the grey background). This allows us to use the position of image to output a Voltage which can be used to control (for example) the cut-off frequency of a filter module. 3) The Animation Position plugs are always scaled from 0 to 1 as a default, whereas both the Value, and Value Out plugs have the value scaled up to the default 0 to 10 range required for controlling DSP modules. 4) The Text Entry4 module allows us to display a title adjacent to the control knob. Float to Volts conversion. The Float to Volts module is included to convert the Floating point output of the Patch Memory to a suitable Data stream for DSP modules. this allows us to set the response speed of the control, so that there is a smooth output signal sent to the DSP controls. Menu Items, and Menu Selection plugs. These can be used to set up a Right Click menu for the control knob.
PatchMemory List3
Our two important plugs here are Choice and Item List: Choice is the Integer which refers to the Item from the Item List that is being chosen. Defining the list: The list is set up as a text string in the Properties for the module. Each entry is given an ID number starting at 0 Note: the first item is always 0. So if you are choosing pre-defined options from another module, so a typical list could be: Sine=0,Saw=1,Triangle=3,Pulse=4 This is referred to as an “Enumerated List” There must be no spaces in the list, unless the Item name specifically has a space in it such as “White Noise”. Note: The last entry is not followed by a comma or period. Example: A pop-up menu system is shown below. If we don’t define a list then the list entries will be read directly from the Oscillator module (OK we expect the Value Out plugs to be uni-directional, but in the case of this module it can extract the item list from the Module that this plug is connected to-trust me it does!) Limiting our choices: If we want to limit the choices available in the list then we need to pre-define our list. This is done in the properties for the Popup Menu module. Note: You must define the list options before connecting the Popup Menu to any other modules, otherwise the Choice and Item List entry boxes will be “greyed out”, and the list will be defined by the Patch Memory List3 and the module it’s reading the list items from. In this case we use the list: Sine=0,Saw=1,Triangle=3,Pulse=4 which limits the choices available by leaving out Ramp=2,White Noise=5,Pink Noise=6. The choice option requires no programming, it just selects the ID number from the list supplied. This system will work with any DSP module that uses the green List Entry plug. Just remember that the first item in the enumerated list will be 0, and not 1.
This is how the properties panel for the Popup Menu module should read: (Unless you want different options of course)
Programmers notes about Patch Mem:
The range attributes are specified in the xml for the parameter, they are called minVal maxVal, the default range being 0 to 10.
A patch memory is pretty much a ‘stub’ box module containing a SE entity called a Parameter. The module simply communicates to the parameter value using its plugs. A parameter is in effect a memory whose value is stored in presets and which changes for every preset, and can of course be of int, float, bool, blob or string type.
By using xml, a parameter can be linked to either GUI or DSP plugs. The linked pin(s) won’t be exposed, but are used for sending or receiving data to/from the parameter. Therefore, a parameter also allows communication between GUI and DSP.
You must keep in mind that when the GUI is closed, the GUI part of a module (including a PM) effectively does not exist. However, a parameter can still transmit its value to any DSP input plug it is linked to, or receive the value from a DSP output plug it is linked to. Once the GUI is opened (but not until then), it will transmit its value to a GUI plug it is linked to.
These modules change the value of a GUI variable. They may or may not also convert the value from one GUI data type to another.
dB to Animation.
This is a module of limited use except in the SynthEdit VU Meter prefab. (“Unfortunately the ‘dB to animation’ module is specific to the SynthEdit VU Meter image, which is copied off real VU Meters and is not any kind of ‘nice’ formula. It can’t be used on meters with a different scale.” Jeff McClintock.)
Float Function.
These modules provide a generic conversion function. Both audio processing and GUI versions are provided.
The supported functions are shown below: *, /, +, -, ^, sin, cos, tan, asin, acos, atan, sinh, cosh, tanh , exp, log, log10, sqrt, floor, ceil, abs, hypot, deg, rad, sgn, min, max. This list applies to both the DSP and GUI modules.
DSP/Audio Float Function
Left Hand Side Plugs: -> A:- (Floating Point) Input value -> Formula: B=:- (Text) Function applied to the signal flow from B to A for example B= A*2 Right Hand Side Plugs: -> B:- (Floating point) Output Value The audio version (as usual) sends data in just one direction. For example to double the amplitude of a ‘float’ signal, open the properties screen, enter the formula – A * 2.
GUI Float Function:
The GUI function module is similar except it works in both directions, so you have two formulae Usually Formula B will be the inverse of Formula A. For example if you wanted a text entry to display a knob’s value as ranging from 1-100, you could enter formula B=A*100, so it follows that Formula B should be the inverse which is B=A/100
Left Hand Side Plugs: ->A:- (Floating Point) Input value ->Formula: A=:- (Text) Function applied to signal flow from A to B ->Formula: B=:- (Text) Function applied to signal flow from B to A Note: If either the A or B function is left as an empty string or the value 0, signal flow from that pin will be disabled. Right Hand Side Plugs: <- B:- (Floating point) Output Value
An example of using these modules is shown below in the SynthEdit VU Meter prefab. We take the Audio input, and feed it into the Volts to Float module where the signal level is converted to floating point at a rate optimised for DSP, which will also give a suitable response time for the meter to be useful (Conversion rate = 60hZ), and the type of response is dB VU to suit a VU meter readout. The next step is to use a PatchMemory Float Out3 to convert the data from Audio/DSP to GUI, and to take the value output (not the Animation Position output) and feed it via the Float Function with these values for the Formulae:
Using these modules.
Formula A= B-18 Formula B= A+18 From here the data is sent via the dB to Animation module to convert the data to fit the scale used for the VU meter, this is where we finally use Animation Position to move the “meter” to the position that matches the Audio input on the VU “scale”. The actual meter we see on the panel uses two Image2 modules. The top one which displays the meter needle is connected to the Animation Position data, and the lower Image has no connections as it’s just the meter scale.
Data Type Conversion Modules
These modules convert from one data type to another, without affecting the value. I’m not including the BLOB datatype converters as this is a rather specialist data format which is used for Audio analysis etc. Bool to Float: Converts a Boolean input to a Floating Point value. For example: False =0, True =10 Bool to Int: Converts a Boolean input to an Integer output. False = 0, True = 1 Bool to Text: Converts a Boolean Input to the equivalent Text string. False = False, True = True. Float to Bool: =<0 = False, >0 =True Float to Double: Converts ordinary 32bit floating Point values to 64bit Floating Point values (Double Precision) Float to Integer: converts the Floating Point input to the nearest whole number. For example a Floating Point value of 3.4 would output Integer 3, and a Floating Point value of 3.6 would result in an Integer output of 4. Float to Text: Converts a Floating point value to a numeric Text string, so 3.1415962 will display these numbers in a text box. The number of digits after the decimal point is set by the Decimal Places plug so with Decimal Places set to 3 the input value will be truncated 3.141. Int to Bool: Converts an Integer input to an Boolean output. 0 = False, 1= True. Int to Float: Converts an Integer value to a Floating Point value (The starting point being Integer the result will obviously be a whole number). Int to Text: Converts an Integer value to a numeric Text string.
