Community

Arnold General Rendering Forum

Turn on suggestions

Auto-suggest helps you quickly narrow down your search results by suggesting possible matches as you type.

This page has been translated for your convenience with an automatic translation service. This is not an official translation and may contain errors and inaccurate translations. Autodesk does not warrant, either expressly or implied, the accuracy, reliability or completeness of the information translated by the machine translation service and will not be liable for damages or losses caused by the trust placed in the translation service.
Translate

Topic Options

- Subscribe to RSS Feed
- Mark Topic as New
- Mark Topic as Read
- Float this Topic for Current User
- Bookmark
- Subscribe
- Printer Friendly Page

Message 1 of 5

07-09-2024
02:28 PM

- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Report

07-09-2024
02:28 PM

rombotools::freebie::mathparser

**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

4 REPLIES 4

Message 2 of 5

07-10-2024
01:17 PM

- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Report

07-10-2024
01:17 PM

**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* 🙂

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.

Message 3 of 5

07-11-2024
02:04 PM

- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Report

07-11-2024
02:04 PM

**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. I provide some initial source code here : https://github.com/RomboDev/Miscellaneous/tree/master/ShuntingYard%20Algorithm

Message 4 of 5

07-15-2024
09:48 AM

- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Report

07-15-2024
09:48 AM

**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.

Message 5 of 5

07-16-2024
08:43 AM

- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Report

07-16-2024
08:43 AM

**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.

- Subscribe to RSS Feed
- Mark Topic as New
- Mark Topic as Read
- Float this Topic for Current User
- Bookmark
- Subscribe
- Printer Friendly Page

Can't find what you're looking for? Ask the community or share your knowledge.