I'm getting this compiler error:

/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp: In function ‘void mark(gl_program*, ir_variable*, int, int, bool)’:
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:87:7: error: ‘GLbitfield64’ was not declared in this scope
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:87:20: error: expected ‘;’ before ‘bitfield’
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:89:9: error: ‘struct gl_program’ has no member named ‘InputsRead’
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:89:23: error: ‘bitfield’ was not declared in this scope
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:91:13: error: ‘gl_fragment_program’ was not declared in this scope
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:91:34: error: ‘fprog’ was not declared in this scope
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:91:64: error: expected primary-expression before ‘)’ token
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:91:66: error: expected ‘;’ before ‘prog’
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:98:16: error: ‘struct gl_program’ has no member named ‘SystemValuesRead’
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:98:36: error: ‘bitfield’ was not declared in this scope
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:100:9: error: ‘struct gl_program’ has no member named ‘OutputsWritten’
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:100:27: error: ‘bitfield’ was not declared in this scope
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp: In member function ‘virtual ir_visitor_status ir_set_program_inouts_visitor::visit_enter(ir_expression*)’:
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:178:7: error: ‘gl_fragment_program’ was not declared in this scope
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:178:28: error: ‘fprog’ was not declared in this scope
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:178:58: error: expected primary-expression before ‘)’ token
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:178:60: error: expected ‘;’ before ‘prog’
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp: In member function ‘virtual ir_visitor_status ir_set_program_inouts_visitor::visit_enter(ir_discard*)’:
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:190:4: error: ‘gl_fragment_program’ was not declared in this scope
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:190:25: error: ‘fprog’ was not declared in this scope
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:190:55: error: expected primary-expression before ‘)’ token
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:190:57: error: expected ‘;’ before ‘prog’
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp: In function ‘void do_set_program_inouts(exec_list*, gl_program*, bool)’:
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:202:10: error: ‘struct gl_program’ has no member named ‘InputsRead’
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:203:10: error: ‘struct gl_program’ has no member named ‘OutputsWritten’
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:204:10: error: ‘struct gl_program’ has no member named ‘SystemValuesRead’
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:206:7: error: ‘gl_fragment_program’ was not declared in this scope
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:206:28: error: ‘fprog’ was not declared in this scope
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:206:58: error: expected primary-expression before ‘)’ token
/home/glsl-optimizer/src/glsl/ir_set_program_inouts.cpp:206:60: error: expected ‘;’ before ‘prog’
make[2]: *** [CMakeFiles/glsl_optimizer.dir/src/glsl/ir_set_program_inouts.cpp.o] Error 1
make[1]: *** [CMakeFiles/glsl_optimizer.dir/all] Error 2
make: *** [all] Error 2

I'm running on Ubuntu 12.04 LTS, 64-bit.

Hi,

Here are some fixes for the glsl code generator bug I encountered while optimizing our engine glsl code (translated from hlsl with hlsl2glslfork :) ), I did not run the test suite as the test app is not Linux compatible yet, but the results should be changed mainly due to more paranoid parenthesis.

Cheers,

Maxime Coste.

P.S. there looks to be a bug in copy_propagation elements code, I saw a.xy = a.yx; a.x = -a.x; becoming a.xy = a.yx; a.x = -a.y; I'm investigating

I have the following at the top of my GLSL ES shader for GLES 2.0 platform:

    #if defined(GL_OES_standard_derivatives)
        #extension GL_OES_standard_derivatives : enable
    #endif
    precision highp float;
    ...

And uses this extension as such:

...
float calculateSmoothing(in float distance)
{
#if defined(GL_OES_standard_derivatives)
    return (0.707106781 * length(vec2(dFdx(distance), dFdy(distance))));
#else
    return u_smoothing / gl_FragCoord.w;
#endif
}
...

And after it was optimised, it turned to this:

#extension GL_OES_standard_derivatives : enable
precision highp float;

while calculateSmoothing turned into the following in my main (got inlined, which is awesome):

...
lowp float tmpvar_4;
lowp vec2 tmpvar_5;
tmpvar_5.x = dFdx(tmpvar_3);
tmpvar_5.y = dFdy(tmpvar_3);
tmpvar_4 = (0.7071068 * sqrt(dot (tmpvar_5, tmpvar_5)));
...

and the u_smoothing was optimised out.

The GLSL optimizer works great. My mind is blown away. However, there's one major problem: my shader doesn't work anymore on hardware that doesn't support the GL_OES_standard_derivatives extension (e.g. RaspberryPi, Amazon FireTV Stick gen 1, etc)

Is there a way to keep the preprocessor conditionals as-is? or perhaps there's a way to generate 2 optimised versions of my shader (one version with the extension, the other without the extension)?

Any help would be greatly appreciated! Thanks!

The ES/Metal/MesaGL ecosystem is new to me right now so please correct any errors I've made.

Texture samplers are defined by default to have low precision. In Mesa's GLSL compiler, this is specified in the class ir_texture which initialises its ir_rvalue member with glsl_precision_low. The type is defined in ir.h. This decision is also reinforced in apply_precision_to_variable where it says: samplers default to low precision (outside of function arguments).

For comparison, in glslang texture samplers are similarly set to EpqLow but only if the ES profile is active. Otherwise they're set to EpqHigh. This can be found in TParseContext::setPrecisionDefaults in ParseHelper.cpp.

So it appears that an ES-only requirement is that texture samplers default to low-precision, which is typically enough to sample 8-bit textures. For cases where higher precision is required, samplers can be annotated to provide mediump or highp precision on ES. Implied in the behaviour specified above, Mesa's GLSL compiler only cares about ES.

For what it's worth, I've checked the OpenGL Core and ES specifications and can't find mention of this behaviour anywhere so a pointer to some legalese would be great.

For Metal this can break down when required to sample high-precision textures as precision qualifiers are not a valid part of the language. All you get are low-precision values from high-precision textures that can propagate up through assignment and destroy the precision of your calculations.

This fix follows a different path for texture precision management when the Metal profile is active.

This requires bumping the GLSLVersion constant up but AFAICS it's not used for the output - #version directive is preserved, and it's just used to populate the available definitions/features. Let me know if you want me to fix this by making another kGlslTarget enum value.

More importantly, texelFetch was converted to textureProj during ir->glsl pass :) so this fixes that.

I'm not sure how to run tests so I haven't ran tests :(

Hi Aras,

I hope this meets with your approval. I tested it on Visual Studio 2008, 2010, 2012 and Xcode 5. I will do a follow-up commit with the new projects in a few minutes.

Fixed up lots of Windows-specific issues in the GYP files. This required a modification to GYP: gyp-patches/0001-Add-config_conditions-as-PHASE_..patch which adds 'config_conditions' to allow modification of build settings in configuration blocks so that debugging flags and the target platform are set there (so Debug32 is a debuggable 32bit configuration).

Added generateMyProjects.sh script which creates project files for vs2008, vs2010, vs2012 and xcode; again, this required a modification to GYP: gyp-patches/0002-Add-generator-output-flat-option.patch which adds an option (--generator-output-flat) that forces all project and solution files to be made in the directory specified by --generator-output=

Noticing something odd with for-loops when passing through output from hlsl2glsl. The optimised output doesn't seem to be assigning the initial value of the index at all. Noticed this as I was having glDrawArrays lock up on shaders using for loops.

For state in question (in source HLSL):

    for ( int index = 0 ; index < sampleNum ; index += 4 ) 

In GLSL after running through HLSL2GLSL

    int index = 0;
    for ( ; (index < sampleNum); index += 4) {
    ...
    }

Raw glsloptimiser output:

  tmpvar_254 = 0;
  index_230 = tmpvar_254;
  while (true) {
    ...
    if (!((index_230 < sampleNum_226))) {
      break;
    };
   ...
    int tmpvar_322;
    tmpvar_322 = (index_230 + 4);
    index_230 = tmpvar_322;
    }

Optimised glsloptimiser output:

  for (int index_5; index_5 < sampleNum_2; index_5 += 4) {
  ...
  }

The initial value is completely lost. Changing this to a non-zero value yields the same results, initially I thought it may just be an assumption on the optimisers part, but it seems to be more than that.

i take version from master: https://github.com/aras-p/glsl-optimizer

set version300 es he show message - not support 3.0, support only 1.0 bun on master page - GLSL ES versions 1.00 and 3.00 are supported.

need make brach with this ? https://github.com/aras-p/glsl-optimizer/tree/bbatkin

Or ?

ir->coordinate is 0.

Target: kGlslTargetOpenGLES30 Shader code:

#version 300 es
precision highp float;
#define USE_OPENGL_ES_2
#define USE_OPENGL_ES_3
#define SUPPORTED_VERTEX_TEXTURE_FETCH
#line 2

#line 1

uniform mat4 in_ProjectionMatrix;
uniform mat4 in_ViewMatrix;
uniform mat4 in_ViewMatrixInverse;
uniform mat4 in_ModelMatrix;
uniform mat4 in_ModelMatrixInverse;
uniform mat4 in_ModelViewMatrix;
uniform mat4 in_ModelViewMatrixInverse;
uniform mat4 in_ModelViewProjectionMatrix;   
uniform mat4 in_NormalMatrix; // mat4 is used due to std140 padding
#line 4

in vec4 in_Vertex;
in vec4 in_TexCoord;
in vec3 in_Normal;
in vec2 in_Bones;

out vec3 v_WorldPosition;

uniform sampler2D Texture0; // packed skeleton
uniform vec4 u_KeyFrame;    // Frame1, Frame2, Lerp, Skinned

#line 1

vec4 QuatMul( in vec4 q1, in vec4 q2 )
{
vec3  im = q1.w * q2.xyz + q1.xyz * q2.w + cross ( q1.xyz, q2.xyz );
vec4  dt = q1 * q2;
float re = dot ( dt, vec4 ( -1.0, -1.0, -1.0, 1.0 ) );

return vec4( im, re );
}

vec3 RotateVector( in vec3 p, in vec4 q )
{
return p + 2.0 * cross( q.xyz, cross( q.xyz, p ) + q.w * p );
}

vec4 Slerp( vec4 Q1, vec4 Q2, float Coef )
{
float cosHalfTheta = dot( Q1.xyz, Q2.xyz ) + Q1.w * Q2.w;

if ( abs(cosHalfTheta) >= 1.0 ) return Q1;

if ( cosHalfTheta < 0.0 )
{
Q2 = -Q2;
cosHalfTheta = -cosHalfTheta; 
}

float halfTheta = acos(cosHalfTheta);
float sinHalfTheta = sqrt(1.0 - cosHalfTheta*cosHalfTheta);

if ( abs(sinHalfTheta) < 0.001) return 0.5 * ( Q1+Q2 );

float ratioA = sin((1.0 - Coef) * halfTheta) / sinHalfTheta;
float ratioB = sin(Coef * halfTheta) / sinHalfTheta; 

return ratioA * Q1 + ratioB * Q2;
}
#line 16
#line 1

vec4 GetPoint( int X, int Y )
{
ivec2 Size = textureSize( Texture0, 0 );

return textureLod( Texture0, vec2( ( float(X) + 0.5 ) / float(Size.x), ( float(Y) + 0.5 ) / float(Size.y) ), 0.0 );
}

vec4 SkinVertex()
{
vec3 Pos = vec3( 0.0, 0.0, 0.0 );

int WeightIndex = int(in_Bones.x);
int WeightCount = int(in_Bones.y);

int VStart1 = int(u_KeyFrame.x) * 4;
int VStart2 = int(u_KeyFrame.y) * 4;

float LerpCoef = u_KeyFrame.z;

for ( int k = 0; k < WeightCount; k++ )
{
vec4  PosWeight  =     GetPoint( WeightIndex + k, VStart1 + 0 );
int   JointIndex = int(GetPoint( WeightIndex + k, VStart1 + 1 ).x);

vec4 J1Orientation = GetPoint( JointIndex, VStart1 + 2 );
vec3 J1Position    = GetPoint( JointIndex, VStart1 + 3 ).xyz;

vec4 J2Orientation = GetPoint( JointIndex, VStart2 + 2 );
vec3 J2Position    = GetPoint( JointIndex, VStart2 + 3 ).xyz;

vec4 JOrientation = Slerp( J1Orientation, J2Orientation, LerpCoef );
vec3 JPosition    = mix(   J1Position,    J2Position,    LerpCoef );

Pos += ( RotateVector( PosWeight.xyz, JOrientation ) + JPosition ) * PosWeight.w;
}

return vec4( Pos, 1.0 );
}
#line 17

void main()
{
vec4 Position = ( u_KeyFrame.w == 1.0 ) ? SkinVertex() : in_Vertex;

gl_Position = in_ModelViewProjectionMatrix * Position;

v_WorldPosition = ( in_ModelMatrix * Position ).xyz;
}

Hi,

Here is the error I receive at the very beginning:

In file included from src/glsl/glcpp/glcpp-parse.y:31:0:
/home/noob/CoolCode/glsl-optimizer/src/glsl/glcpp/glcpp.h:32:25: fatal error: util/ralloc.h: No such file or directory
 #include "util/ralloc.h"
                         ^
compilation terminated.
CMakeFiles/glcpp-library.dir/build.make:54: recipe for target 'CMakeFiles/glcpp-library.dir/src/glsl/glcpp/glcpp-parse.c.o' failed
make[2]: *** [CMakeFiles/glcpp-library.dir/src/glsl/glcpp/glcpp-parse.c.o] Error 1
CMakeFiles/Makefile2:60: recipe for target 'CMakeFiles/glcpp-library.dir/all' failed
make[1]: *** [CMakeFiles/glcpp-library.dir/all] Error 2
Makefile:76: recipe for target 'all' failed
make: *** [all] Error 2

Tried with CMake in both a separate build directory, and an in-source build; neither worked. Running Gentoo.

After optimizing, sometimes multiple expressions are placed into a for loop. This causes the shader to crash on WebGL.

for (int i=0; i<10; i++, otherVar++) { .. }

Tested on Chrome and FireFox, OSX 10.8.5. See here:

http://glsl.heroku.com/e#17544.1

bug.glsl

#version 100
#define SAMPLER_COUNT 2
uniform sampler2D samplers[SAMPLER_COUNT];
void main() {
  vec4 sum = vec4(0.0);
  for(int i = 0; i < SAMPLER_COUNT; i++) {
    sum += samplers[i];
  }
  gl_FragColor = sum;
}

$ glslopt -2 -f bug.glsl
Failed to compile bug.glsl:

(7,9): error: sampler arrays indexed with non-constant expressions is forbidden in GLSL 1.30 and later
(7,2): error: operands to arithmetic operators must be numeric

However, according to the GLSL ES 2.0 spec Page 109 (115 in PDF): https://www.khronos.org/registry/OpenGL/specs/es/2.0/GLSL_ES_Specification_1.00.pdf:

5 Indexing of Arrays, Vectors and Matrices

[...] The following are constant-index-expressions:

• Constant expressions
• Loop indices as defined in section 4
• [...]

Samplers

GLSL ES 1.00 supports both arrays of samplers and arrays of structures which contain samplers. In both these cases, for ES 2.0, support for indexing with a constant-index-expression is mandated but support for indexing with other values is not mandated.

So this is a bug, because I'm using a constant-index-expressions, for which support is mandated by the GLSL spec.

I did look into it, and the broken check is here:

https://github.com/aras-p/glsl-optimizer/blob/d78c3d2f249aa870368ad320905bc954c47704f6/src/glsl/ast_array_index.cpp#L230-L250

This bug does not exist in a rebased fork with a more recent mesa: https://github.com/jamienicol/glsl-optimizer/ The fixed check is here.

If const variable initialized with builtin function such as bellowing present in the shader, program will crash: const vec3 var_test = log(vec3(0.0,0.0,0.0));

Crash stack:

We are exploring the use of storage buffers in WebRender, and glsl optimizing stage unfortunately doesn't recognize them. Example syntax we use:

layout(std140, binding = 0) buffer bInstances {
    ivec4 bInstanceData[];
};

This is code in GLES 3.1, and under "GL_ARB_shader_storage_buffer_object" extension in GL.

I was working with a (too) large fragment shader, and due to method inlining this resulted in a very long main() function. On multiple (older, Andoid 5/6, gles2) android devices, this resulted in strange artifacts such as incorrect colors. Extracting part of the instructions to a separate function resolved the issue.

no problems on iOS or desktop.