rombotools::freebie::mathparser

[maxtarpini]

this is a math expression parser.. ie. you can simply input a basic math expression and use a variable 'x' to source the connected input. This unleashes some tremendous power if you know what to do with math. So instead to have to use many math nodes you can use one to rule most of them.

Current operators : + - / * ^ %
Current functions : sin, cos, tan, floor, fract
Parentheses : ()

For example : floor(x*12)%2 , where x is the floating input node (U/V coord) and % is the modulo operator

https://www.rombo.tools/downloads/romboMathParser.zip

[maxtarpini]

Updated to three inputs and so three variables : x,y and z.

Added following ops : (bitwise) & | << >> 

Added following fncs : asin acos atan sinh cosh tanh exp floor ceil fract sqrt log log2 logn inv(ert) comp(lement) abs

Added : verbosity for incorrect expressions, MTD file for DCCs

Remarkably, this doesn't work : 3+(-2) .. meaning, I don't plan to fix it 🙂

From v1.5, you can write it like this however : 3+neg(2).

We can now re-do the previous example with just one romboMathParser.

Btw, you can have any number of nested parentheses ..
like with the following expression that will draw a diamond pattern. 

This simple expression instead will return the luminance of a color.
In Maya, romboMathParser is under Utility/Math.
No need for parentheses here because the order of operations is exploited.

[maxtarpini]

Added following fncs : rnd(seed) .. generates random numbers in 0-1

Added support for two-arguments fncs : max, min, atanz (atan2), mod, pow, step

Now with two-args fncs we can do more interesting stuff easily.

The 'sin' thing with magic numbers generates random numbers, the 'fract' ensures they are in 0-1.
Or try this exp 'fract(fract(p * 0.1031) * (p * 33.33))' which avoids 'sin'.
We could have used also just the 'rnd' fnc.

Below with both X and Y. ScreenSpaceX/Y is in Arnold math node : state_float->imagespaceU/V.
Thickness node is used to tweak how thick are the lines without touching the expression.

This last example would involve at least 12 nodes and all the pain to keep track of that. Btw, romboMathParser doesn't need to compile anything and does not embed full-fledged scripting language like Python, Lua or OSL because does everything inline based on a simple and effective math parser algorithm.

[maxtarpini]

Addded fncs :
- radtodeg -> converts radians to degrees
- degtorad -> converts degrees to radians
- union -> perlin boolean op -> ((a+b) - (a*b))
- diff -> perlin boolean op -> ((a) - (a*b))

Added 3-args fncs :
- clamp -> constrains x to lie between a and b ..(x,a,b)
- lerp -> interpolates linearly x between a and b .. (a,b,x)
- exerp -> exponential interpolation
- logerp -> logarithmic interpolation
- sstep -> smoothstep function .. (a,b,x)
- pulse -> step(edge0, x) - step(edge1, x);
- pulset -> pulse (edge, period, mod(x,period));

Added constants :
- PI -> π -> 3.1459...
- E -> euler -> 2.7182...
- GR -> goldenratio -> 1.6180...

Added globals :
all shading float/int globals are available.
Name convention is : SG(shading globals) + uppercase variable name, ie:
SGU -> float u .. U surface parameter
SGDUDX -> float dudx .. U derivative wrt screen X-axis
SGSC -> uint8_t sc .. type of shading context

Added : README file

Now, to test for example constants and new fncs .. we know that Pi is the ratio of a circle's circumference to its diameter .. so if you input radtodeg(PI) .. and assign the shader to a cube .. go to the Pixel tab of your Arnold IPR view .. and put the mouse cursor over the rendered cube .. you should see 180 under Lum (remember that what you see in the IPR is not what you source from the pixel which is linear raw.. so values are not altered).

With globals instead we can re-write the previous exps without having to leave mathParser .. for example following :
(floor(SGU*12-SGV*12) + floor(SGU*12+SGV*12)) %2
does the same as above .. where SGU and SGV are the previous state_float->U and state_float->V connected to x and y slots.

Eventually a bit more involved example where we design some antialised circles.

[maxtarpini]

Re-engineered the parser to better cope with Arnold initialize and evaluate phases.

We now parse and tokenize the expression in the init/update phase. Still there we convert the math expression from infix to postfix notation (also known as Reverse Polish Notation or RPN). Eventually we use the RPN like 'compiled code' in the evaluate phase because together with the token to parse the expression we have associated a lambda function that will be called from the RPN with the dynamic content from Arnold (xyz user-defined variables and globals) because the funny part was to be able to support the dynamic stuff while tokenizing/converting the expression as static.

This makes romboMathParser x20 faster and at least on pair (generally faster) with any shader network (or OSL code) you'd want to use to accomplish the same thing while remaining easier faster and funnier to setup.

Please re-download the lib (v1.4) from the initial post.

Below I'm using an rnd fnc to displace the circles we modelled previously.

[maxtarpini]

Here some kind of origami pattern to test all the stuff works together. 

You may want to write the same with atan in this way : mod((((atan((SGV-.5)/(SGU-.5)) / (PI*2)) +0.5) *16), 1).

🖖

[maxtarpini]

.....

🖖

[maxtarpini]

To collect use cases for the romboMathParser ..

I post here too the solution to : 

https://forums.autodesk.com/t5/arnold-general-rendering-forum/facing-ratio-linear-attribute/td-p/132...

See that post for more info.

How to linearize a cosine gradient with trig fncs :

🖖