//General features, sorted by most useful//
ability to select multiple nodes and change multiple parameters simultaneously, so long as they're the same parameters.
tool options to distribute nodes evenly, horizontally or vertically.
dynamic input node (input that accepts grayscale and color, like on most atomic nodes)
smooth min mode for voronoi nodes
atomic histogram equalization node
atomic gaussian blur Filter (the blur HQ node is a favorite among most users, so why not make it an atomic node? having 2 separate nodes is a burden for something people use very frequently, and blur HQ is rather slow, in my humble opinion. a fast atomic gaussian blur would be an awesome addition)
-----------------------------------------------------------------------
//Pixel/Value Processor Features, sorted by most useful//
mipmaps for sample gray/color, both manual and automatic. this is my #1 suggestion/request. It would open up so many doors.
multiple outputs for custom functions, and any new atomic nodes that require multiple outputs.
automatic scalar vectorization. Would eliminate the need for scalar nodes, i.e. scalar multiplication, etc.
ability to expose parameters on sample gray/color as inputs. if mipmaps are added, this would be especially useful. No longer would one need to use multiple sample nodes to switch between input images, filtering modes, and wrap modes. additionally, having the input image parameter exposed would make certain things much easier. for example, one could easily create an atlas function with a while loop)
system variable for the original node size (example: if your node has a size of 256x256 and you increase the size by a factor of 1, making it 512x512, this variable would still return 256x256)
system variable for texel size (1/size)
system variable for total number of input images.
system variables for Pixel Size, Pixel Ratio, and Random Seed (more so Pixel Size and Pixel Ratio. these are only used on atomic graph nodes, which is kind of a waste)
dynamic number of inputs (up to 16 or more) for all arithmetic nodes, and minimum/maximum nodes. (similar to how the pixel/value processor and fxmap have a dynamic number of inputs. By default, only have 2 inputs visible, and each additional input would be visible only when you're dragging a wire. example: add 10 values together with a single addition node)
default input values for nodes (example: the multiply node would have a default value of 1 for both the A and B inputs). In addition to this, make the default values directly modifiable on the node, i.e. no need to even click on the node. this would make any user's workflow much faster and smoother.
access to atomic random node's position.
different precision types. would greatly help with optimizing.
unsigned Integer data type.
matrix data type (not extremely necessary, but would be a nice addition)
arrays (useful for all sorts of things, though i understand this may be difficult to implement in an intuitive, flexible way. Nuke has array nodes, so it's probably doable)
-----------------------------------------------------------------------
//Pixel/Value Processor Atomic Nodes, sorted by most useful.
Atomic versions for these would be extremely helpful, and save many users a lot of time.
Quite a few these already exist as functions, some of which have multiple, for floats and different size vectors.
Atomic versions would clean up the function library by a good bit//
atomic scalar division (3 functions for this exist)
atomic one minus (2 functions for this exist, only for float. the other function is called [0,1] to [1,0])
atomic frac (1 function for this exists, only for float)
atomic saturate (2 functions for this exist)
atomic reciprocal/rcp
atomic sign (1 function for this exists, only for float)
atomic scalar addition
atomic scalar subtraction
atomic scalar modulo
atomic scalar power
atomic smoothstep (1 function for this exists, only for float)
atomic clamp (1 function for this exists, only for float)
atomic length (2 functions for this exist)
atomic distance (2 functions for this exist)
atomic round (1 function for this exists, only for float)
atomic normalize (3 functions for this exist)
atomic truncate/trunc (like hlsl or glsl trunc, not like the truncate function in designer)
atomic reciprocal squareroot/inverse squareroot
atomic roundEven
atomic step (1 function for this exists, only for float)
atomic reflect (1 function for this exists)
atomic refract
atomic degrees to radians
atomic radians to degrees
atomic degrees to turns
atomic turns to degrees
atomic log10
atomic multiply add
atomic fmod and scalar fmod (1 function for this exists, only for float)
atomic isnan, isfinite, and isinf
atomic any and all (8 functions exist for all, under the names equality and inequality)
atomic acos
atomic asin
atomic atan
atomic cosh
atomic sinh
atomic tanh
atomic acosh
atomic asinh
atomic atanh
atomic cross (2 functions for this exist)
atomic bitwise operators: ~, <<, >>, &, |, ^, <<=, >>=, &=, |=, ^=
atomic packing/unpacking functions
-----------------------------------------------------------------------
//non-instrinsic functions//
atomic increment (input+1)
atomic decrement (input-1)
atomic double (input*2)
atomic halve (input/2)
atomic remap 0-1 to -1-1 (x*2-1); (1 function for this exists, only for float)
atomic remap -1-1 to 0-1 (x*.5+.5); (1 function for this exists, only for float)
atomic remap lerp(a,b,inverseLerp(a,b,t));
atomic average (a whopping 4 functions exist for this)
atomic inverse lerp (1 function for this exists, only for float, named [a,b] to [0,1])
atomic polar node (would compliment the atomic cartesian node)
atomic triangle wave, sawtooth wave, and square wave (current functions for triangle and sawtooth waves are not ideal and poorly optimized. See my personal formulas below)
atomic split/break components node
atomic merge/combine components node
//My personal waveform functions. All have a period of 1.//
float triangle( float x ) //Triangle Wave in the -1-1 range
{
return 1. - abs(fract(x + .25) * 4. - 2.);
}
float triangle01( float x ) //Triangle Wave in the 0-1 range
{
return abs(fract(x - .25) * 2. - 1.);
}
float square( float x ) //Square Wave in the -1-1 range
{
return fract(x) < .5 ? 1.: -1.;
}
float square01( float x ) //Square Wave in the 0-1 range
{
return fract(x) < .5 ? 1.: 0.;
}
float sawtooth( float x ) //Sawtooth Wave in the -1-1 range
{
return 2. * (x - round(x));
}
float sawtooth01( float x ) //Sawtooth Wave in the 0-1 range
{
return fract(x+.5);
}