How to support other precision throughout the codebase cleanly

[vade]

In Metal, Half Float (half, half2, half3, half4, samplers with half precision, etc) are all fast path and native.

Im working on converting some of the metal lygia code to support half float, and frankly its a ton of violations of DRY.

Im not entirely sure if thats 'wrong', but im getting a lot of code like this:

vade#2

which if you look at the commit history, it a lot of repetitious and error prone work.

I don't have a solution but was curious to open the discussion?

[patriciogonzalezvivo]

Not sure how would be on Metal. In GLSL I would do something like:

#ifndef BLEND_PRECISION
#define BLEND_PRECISION mediump
#endif 

#ifndef FNC_BLEND
#define FNC_BLEND
vec4 BLEND_PRECISION blend(vec4 BLEND_PRECISION A, vec4 BLEND_PRECISION B, float BLEND_PRECISION amount) {
   ....
}
#endif

[vade]

Yes, i understand how we should do it code wise, Im more talking about structural changes.

Most of the performance benefit is for image processing, which means some functions which are used for color blending but also math in other contexts need precision defs

So it would be a very large, labor intensive change which also has in some cases some interpretabiloty concerns (we want float sampler coords, but half float sample reads), and we might use the same math functions to calculate both etc.

[vade]

ie:

• is this something worth doing for other languages?
• is this something worth doing in totality for all functions with float / vec arguments and outputs?
• is this a universal config, or is it per 'module', and if so, do we need to do COLOR_PRECISION, MATH_PRECISION etc depending on what we include and what precisions we want?
• Or do we just have duplicate / triplicates of all functions with half / medium signatures ?

[patriciogonzalezvivo]

ah... got it.

This seems like a similar case of the texture sampler function. There is a global setting at:

/sampler.glsl

#ifndef SAMPLER_FNC
#if __VERSION__ >= 300
#define SAMPLER_FNC(TEX, UV) texture(TEX, UV)
#else
#define SAMPLER_FNC(TEX, UV) texture2D(TEX, UV)
#endif
#endif

Then all functions that perform a sampling use the default SAMPLER_FNC(TEX, UV) and over load it with a specific. For example: [/filter/gaussianBlur.glsl(https://github.com/patriciogonzalezvivo/lygia/blob/main/filter/gaussianBlur.glsl#L28-L30)

#ifndef GAUSSIANBLUR_SAMPLER_FNC
#define GAUSSIANBLUR_SAMPLER_FNC(TEX, UV) SAMPLER_FNC(TEX, UV)
#endif

So as a user it's possible to overwrite all sampling functions. Useful when working on specific GLSL versions or specific platform. Or just change the one of the function you are using.

we could having a /precision.* where:

#ifndef DEFAULT_PRECISION
#define DEFAULT_PRECISION mediump
#endif

That all other files use and extend into particulars.

lygia/color/blend/presicion.glsl

#ifndef COLOR_BLEND_PRECISION
#define COLOR_BLEND_PRECISION DEFAULT_PRECISION
#endif

What do you think? To tedious?

[vade]

Im open to that in theory, i just think it would touch every single line of code in Lygia and litter the code with ifdefs which might force precision globally for the shader and not at the call site.

i cant decide if thats nicer than just making additional function signatures and being able to chose precision by just using a type and calling a function?

Both are a lot of work! Woof!