With a high number of local variables in the shader, new renamed identifiers get up to do, which is a GLSL reserved word and the minified shader fails to compile with some Intel drivers.

A list of reserved words not used for new identifiers would help with that.

Here is such a list in another similar minifier project: https://github.com/flowtsohg/glsl-minifier/blob/3497fbecc1b096ee9733d368f1a2737677ffbd5b/glsl_min.rb#L484 And here are those reserved words with 3 or less letters extracted from that project:

u        # this seems like a typo to me, but who knows :)
do
if
in
for
out
int
sin
cos
tan
pow
exp
log
abs
mod
min
max
mix
fma
dot
any
all
not

Btw, thanks for this great project!

Hello,

I was wondering if it'd be possible to add an output option to print the minified shader into stdout, which would allow piping with other tools and programs instead of handling files

Related: #27

Input

vec3 func() {
#ifdef CONDITION
  return vec3( 1.0 );
#else
  return vec3( 0.0 );
#endif
}

Actual

vec3 v(){
#ifdef CONDITION
return vec3(1.);}

Expected

vec3 v(){
#ifdef CONDITION
return vec3(1.);
#else
return vec3(0.};
#endif
}

For a while template literals have been supported in browsers, which allows us to define multiline strings without the need for escape characters like \n.

So a minified shader output could simply be outputted multiline, just like --format none would do, but with backticks enclosing the text. So instead of, what gets now outputted with --format js:

var var_U_RESOLUTION = "m"
var var_U_TIME = "v"

var shader_frag =
 "#version 300 es\n" +
 "uniform float v;" +
 "uniform vec2 m;" +
 "const float f=3.14159,s=50.,n=.01;struct Intersection{bool intersected;vec3 position;vec3 normal;};" +
 "float e(in vec2 v)" +
 "{" +
   "return fract(sin(dot(v.xy,vec2(12.9898,78.233)))*43758.5);" +
 "}" +
 "float x(in vec2 v)" +
 "{" +
   "vec2 f=floor(v),n=fract(v);" +
   "float m=e(f),s=e(f+vec2(1.,0.)),y=e(f+vec2(0.,1.)),I=e(f+vec2(1.,1.));" +
   "vec2 p=n*n*(3.-2.*n);" +
   "float i=mix(m,s,smoothstep(0.,1.,n.x)),x=mix(y,I,smoothstep(0.,1.,n.x)),l=mix(i,x,smoothstep(0.,1.,n.y));" +
   "return l;" +
 "}" +

// snip

the same thing could be written via template strings:

var var_U_RESOLUTION = "m"
var var_U_TIME = "v"

var shader_frag = `
#version 300 es
uniform float v;uniform vec2 m;const float f=3.14159,s=50.,n=.01;struct Intersection{bool intersected;vec3 position;vec3 normal;};float e(in vec2 v){return fract(sin(dot(v.xy,vec2(12.9898,78.233)))*43758.5);}float x(in vec2 v){vec2 f=floor(v),n=fract(v);float m=e(f),s=e(f+vec2(1.,0.)),y=e(f+vec2(0.,1.)),I=e(f+vec2(1.,1.));vec2 p=n*n*(3.-2.*n);float i=mix(m,s,smoothstep(0.,1.,n.x)),x=mix(y,I,smoothstep(0.,1.,n.x)),l=mix(i,x,smoothstep(0.,1.,n.y));return l;} // snip
`

Template literals are supported in all mayor browsers for quite some time now. see: https://caniuse.com/#feat=template-literals

Minifying the following produces the error:

vec4 foobar() { 
#if (SOME_CONSTANT == 0)
  return vec4(texture2D(someTexture, texCoord).rgb, 1.0);
#else
  return vec4(1.0);
#endif
}

void main(void) {
  gl_FragColor = foobar();
}

Was able to reproduce it here too https://ctrl-alt-test.fr/minifier/?main

The minifier version 1.1 did not have this bug (however that one had another issue that causes NVIDIA drivers to not accept certain minified GLSL. Seems like it's re-using certain names for variables as well as functions.).

Create a small website (heavily built on top of the Bolero template) that runs Shader Minifier in the browser, using WebAssembly.

This is a prototype; it's not yet possible to change the flags for Shader Minifier.

Try it online: https://ctrl-alt-test.fr/minifier/

The shader

const vec3 x = 0.*vec3(1.,0.,1.);

gets minified to const vec3 f=0.;, resulting in compiler errors. Expected behavior would be const vec3 f=vec3(0.);.

Interestingly, glslang-validator will validate the output of shader_minifier as correct (?), which makes these kind of issues hard to debug.

Observed on version 1.2.

• The tool needs a UX update.
• It should be more mobile friendly.
• It should use the latest version of Shader Minifier
• It would be nice if it supported multiple versions of Shader Minifier.

https://ctrl-alt-test.fr/minifier/

For arrays like this:

const uvec3[24] SWIZZLE_ROT = uvec3[24](
  uvec3(0u, 0u, 0u),
  ...
);

I'm getting:

System.Exception: Parse error:
const uvec3[24] SWIZZLE_ROT = uvec3[24](
           ^
Expecting: identifier

   at Microsoft.FSharp.Core.PrintfModule.PrintFormatToStringThenFail@1433.Invoke(String message)
   at Main.minify(Tuple`2[] files)
   at Main.run(String[] files)

I found that swapping the brackets to the end makes the minifier work again:

const uvec3 SWIZZLE_ROT[24]

But unfortunately I'm using WebGL2, which expects the brackets before the variable identifier, and not afterwards.

Instead of using "aa", "ab", "ac"... take into account the frequency of the characters and the context in which they are used.

This little snippet of code causes shader minifier to crash and clear the input file:

const int TEST = 3;
void main () {
  int[5] a = {1,2,3,4,5};
  gl_FragColor = a[TEST];
}

I suspect it also took down the server(trying it in the online version) but I didn't confirm this yet due to obvious reasons.

Any chance of adding a separate option for this?

Input:

float f(){
  float r = 1.;

  return r;
}

vec2 pos = vec2(0.5);

void main(){
  gl_FragColor = vec4(1.);
}

Current output:

float n(){return 1.;}vec2 r=vec2(.5);void main(){gl_FragColor=vec4(1.);}

Desired:

void main(){gl_FragColor=vec4(1.);}

Hello,

The minifier doesn't consider #define/#undef and doesn't optimize #if blocks

Example input:

#define MUT_0
#undef MUT_1

float f(){
  float r = 1.;

  #ifdef MUT_0
    r = mut0(r);
  #endif

  #ifdef MUT_1
    r = mut1(r);
  #endif

  return r;
}

1.3.1 gives:

#define MUT_0
#undef MUT_1
float M(){float M=1.;
#ifdef MUT_0
M=mut0(M);
#endif

#ifdef MUT_1
M=mut1(M);
#endif
return M;}

So it would make sense to preserve #if blocks only if there are no corresponding #define/#undef statements and process them if they are present

Example:

float noinl9(float x) {
	const float old = x;
	x = 100.0;
	return old + x;
}

It currently minifies to:

float noinl9(float x)
{
  return x=100.,x+x;
}

1. Even if we need the variable f, we can inline the last assignment here (since A is not used afterwards):

f+=r*smoothstep(.5,-1.,sunDir.y);
return f;

2. We could get rid of the variable here, by inlining everything:

vec2 A=vec2(s,1.);
A=v(A,vec2(D,1.));
A=v(A,vec2(u,2.));
...
A=v(A,vec2(P,2.));
return A;

One way to detect these patterns is to introduce new variables when there's an assignment, similar to the SSA form (often seen in compilers). By introducing new variable names, detecting which ones are effectively constant, and aggressively inlining, we should be able to perform many optimizations.

in float a;
in vec2 b;
in float c;

could be minified as:

in float a,c;
in vec2 b;

Right now, we merge only adjacent declarations of the same type. It is often safe to reorder the definitions (e.g. when there's no initialization value, or when it's trivial).