Yes this is possible. You declare uniform arrays similar to how you&#39;d do it in C, e.g.

    uniform float v[10];

Then you can set their values using `glUniform{1,2,3,4}{f,i}v`

    GLfloat v[10] = {...};
    glUniform1fv(glGetUniformLocation(program, &quot;v&quot;), 10, v);

Yes it is possible to declare an array of uniforms in GLSL shaders. Just google &quot;glsl uniform array&quot; for some examples (edit: or see datenwolf&#39;s example). There are however limitations on how many uniforms can be sent to different graphics cards (at least on older ones, I&#39;m not sure about current ones (although I imagine there still would be)).

If you do decide to go down the route of uniforms, i would suggest using uniform buffers. According to http://www.opengl.org/wiki/Uniform_Buffer_Object, &quot;Switching between uniform buffer bindings is typically faster than switching dozens of uniforms in a program&quot;.

If you have large numbers of lights and parameters, you could also send the data as float buffers.

I&#39;ve been looking into learning Erlang/OTP, and as a result, have been reading (okay, skimming) about the actor model.

From what I understand, the actor model is simply a set of functions (run within lightweight threads called &quot;processes&quot; in Erlang/OTP), which communicate with each other only via _message passing_.

This seems fairly trivial to implement in C++, or any other language:

    class BaseActor {
    	std::queue&lt;BaseMessage*&gt; messages;
    	CriticalSection messagecs;
    	BaseMessage* Pop();
    public:
    	void Push(BaseMessage* message)
    	{
    		auto scopedlock = messagecs.AquireScopedLock();
    		messagecs.push(message);
    	}
    	virtual void ActorFn() = 0;
    	virtual ~BaseActor() {} = 0;
    }

With each of your processes being an instance of a derived BaseActor. Actors communicate with each other only via message-passing. (namely, pushing). Actors register themselves with a central map on initialization which allows other actors to find them, and allows a central function to run through them.

Now, I understand I&#39;m missing, or rather, glossing over one important issue here, namely:
lack of yielding means a single Actor can unfairly consume excessive time. But are cross-platform coroutines the primary thing that makes this hard in C++? (Windows for instance has fibers.)

Is there anything else I&#39;m missing, though, or is the model really this obvious?

The actor model: Why is Erlang/OTP special? Could you use another language?

I have a method that takes 30 parameters.  I took the parameters and put them into one class, so that I could just pass one parameter (the class) into the method.  Is it perfectly fine in the case of refactoring to pass in an object that encapsulates all the parameters even if that is all it contains.

Is it OK to have a class with just properties for refactoring purposes?

I would like to leave OpenGL&#39;s lights and make my own.
I would like my shaders to allow for a variable number of lights.

Can we declare an array of uniforms in GLSL shaders?
If so, how would we set the values of those uniforms?

Creating a GLSL Arrays of Uniforms?

<p>I would like to leave OpenGL's lights and make my own.
I would like my shaders to allow for a variable number of lights.</p>
<p>Can we declare an array of uniforms in GLSL shaders?
If so, how would we set the values of those uniforms?</p>


If I have a record like this;

    {
      &quot;text&quot;: &quot;text goes here&quot;,
      &quot;words&quot;: [&quot;text&quot;, &quot;goes&quot;, &quot;here&quot;]
    }

How can I match multiple words from it in MongoDB? When matching a single word I can do this;

    db.find({ words: &quot;text&quot; })

But when I try this for multiple words, it doesn&#39;t work;

    db.find({ words: [&quot;text&quot;, &quot;here&quot;] })

I&#39;m guessing that by using an array, it tries to match the entire array against the one in the record, rather than matching the individual contents.

mongodb find by multiple array items

I need to pass an array of strings as parameter to a MySQL stored routine. The array could be long and its number of elements is not fixed. I then want to put the string values into an in-memory table with one column, so I can work with the data. I don&#39;t know if this can be done in MySQL. Maybe dirty workarounds are needed.

For example, I have the string values:

    Banana, Apple, Orange

Now I want to get data on these fruits from my MySQL `Fruits` table. Pseudo code:

    create function GetFruits(Array fruitArray) 
       declare @temp table as
          fruitName varchar(100)
       end
    
       @temp = convert fruitArray to table
       select * from Fruits where Name in (select fruitName from @temp)
    end

Microsoft SQL Server allows you to use the `TEXT` datatype and submit the array as an XML string, swiftly creating the in-memory table. However, I don&#39;t think that technique is possible in MySQL.

Any help on how to do this would be appreciated!

Pass array to MySQL stored routine

Imagine I have an JS array like this:

    var a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

What I want is to split that array into N smaller arrays. For instance:

    split_list_in_n(a, 2)
    [[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11]]
    
    For N = 3:
    [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11]]
    
    For N = 4:
    [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11]]
    
    For N = 5:
    [[1, 2, 3], [4, 5], [6, 7], [8, 9], [10, 11]]


For Python, I have this:

    def split_list_in_n(l, cols):
        &quot;&quot;&quot; Split up a list in n lists evenly size chuncks &quot;&quot;&quot;
        start = 0
        for i in xrange(cols):
            stop = start + len(l[i::cols])
            yield l[start:stop]
            start = stop

For JS, the best right solution that I could come up with is a recursive function, but I don&#39;t like it because it&#39;s complicated and ugly. This inner function returns an array like this [1, 2, 3, null, 4, 5, 6, null, 7, 8], and then I have to loop it again and split it manually. (My first attempt was returning this: [1, 2, 3, [4, 5, 6, [7, 8, 9]]], and I decided to do it with the null separator).

    function split(array, cols) {
        if (cols==1) return array;
        var size = Math.ceil(array.length / cols);
        return array.slice(0, size).concat([null]).concat(split(array.slice(size), cols-1));
    }

Here&#39;s a jsfiddle of that: http://jsfiddle.net/uduhH/

How would you do that? Thanks!

Splitting a JS array into N arrays

What is the difference (if there is any) between

    x = Array()

and

    x = new Array()

Which one should I use?

Array() vs new Array()

I have an array like

    vendors = [{
        Name: &#39;Magenic&#39;,
        ID: &#39;ABC&#39;
      },
      {
        Name: &#39;Microsoft&#39;,
        ID: &#39;DEF&#39;
      } // and so on... 
    ];

How do I check this array to see if &quot;Magenic&quot; exists? I don&#39;t want to loop, unless I have to. I&#39;m working with potentially a couple thousand records.

How to determine if Javascript array contains an object with an attribute that equals a given value?

My gdb backtrace gives:

    (gdb) backtrace
    #0  0x00000000 in ?? ()
    #1  0x0804a211 in init () at example1.cpp:147
    #2  0x0804a6bc in main (argc=1, argv=0xbffff3d4) at example1.cpp:283

Not very informative. Eclipse debugger at least lets me see that it stops on line 3 below:

    // Create a vertex array object
    GLuint vao;
    glGenVertexArrays( 1, &amp;vao );
    glBindVertexArray( vao );

This is a very common block to see in gl programming, and I&#39;m even running other code with the same block with no problem. So I&#39;m baffled.

Build output from running make:

    g++ -g -DFREEGLUT_STATIC -DGLEW_STATIC -I../../include example1.cpp ../../Commo/InitShader.o  -L/usr/lib/mesa -lGLEW -lglut -lGL -lX11  -lm  -o example1

Program containing the problem:
    
    // rotating cube with two texture objects
    // change textures with 1 and 2 keys

    #include &quot;Angel.h&quot;

    const int  NumTriangles = 12; // (6 faces)(2 triangles/face)
    const int  NumVertices  = 3 * NumTriangles;
    const int  TextureSize  = 64;

    typedef Angel::vec4 point4;
    typedef Angel::vec4 color4;

    // Texture objects and storage for texture image
    GLuint textures[2];

    GLubyte image[TextureSize][TextureSize][3];
    GLubyte image2[TextureSize][TextureSize][3];

    // Vertex data arrays
    point4  points[NumVertices];
    color4  quad_colors[NumVertices];
    vec2    tex_coords[NumVertices];

    // Array of rotation angles (in degrees) for each coordinate axis
    enum { Xaxis = 0, Yaxis = 1, Zaxis = 2, NumAxes = 3 };
    int      Axis = Xaxis;
    GLfloat  Theta[NumAxes] = { 0.0, 0.0, 0.0 };
    GLuint   theta;

    //----------------------------------------------------------------------------
    int Index = 0;
    void quad( int a, int b, int c, int d )
    {
        point4 vertices[8] = {
            point4( -0.5, -0.5,  0.5, 1.0 ),
            point4( -0.5,  0.5,  0.5, 1.0 ),
            point4(  0.5,  0.5,  0.5, 1.0 ),
            point4(  0.5, -0.5,  0.5, 1.0 ),
            point4( -0.5, -0.5, -0.5, 1.0 ),
            point4( -0.5,  0.5, -0.5, 1.0 ),
            point4(  0.5,  0.5, -0.5, 1.0 ),
            point4(  0.5, -0.5, -0.5, 1.0 )
        };

        color4 colors[8] = {
            color4( 0.0, 0.0, 0.0, 1.0 ),  // black
            color4( 1.0, 0.0, 0.0, 1.0 ),  // red
            color4( 1.0, 1.0, 0.0, 1.0 ),  // yellow
            color4( 0.0, 1.0, 0.0, 1.0 ),  // green
            color4( 0.0, 0.0, 1.0, 1.0 ),  // blue
            color4( 1.0, 0.0, 1.0, 1.0 ),  // magenta
            color4( 0.0, 1.0, 1.0, 1.0 ),  // white
            color4( 1.0, 1.0, 1.0, 1.0 )   // cyan
        };

        quad_colors[Index] = colors[a];
        points[Index] = vertices[a];
        tex_coords[Index] = vec2( 0.0, 0.0 );
        Index++;

        quad_colors[Index] = colors[a];
        points[Index] = vertices[b];
        tex_coords[Index] = vec2( 0.0, 1.0 );
        Index++;

        quad_colors[Index] = colors[a];
        points[Index] = vertices[c];
        tex_coords[Index] = vec2( 1.0, 1.0 );
        Index++;

        quad_colors[Index] = colors[a];
        points[Index] = vertices[a];
        tex_coords[Index] = vec2( 0.0, 0.0 );
        Index++;

        quad_colors[Index] = colors[a];
        points[Index] = vertices[c];
        tex_coords[Index] = vec2( 1.0, 1.0 );
        Index++;

        quad_colors[Index] = colors[a];
        points[Index] = vertices[d];
        tex_coords[Index] = vec2( 1.0, 0.0 );
        Index++;
    }

    //----------------------------------------------------------------------------
    void colorcube()
    {
        quad( 1, 0, 3, 2 );
        quad( 2, 3, 7, 6 );
        quad( 3, 0, 4, 7 );
        quad( 6, 5, 1, 2 );
        quad( 4, 5, 6, 7 );
        quad( 5, 4, 0, 1 );
    }

    //----------------------------------------------------------------------------
    void init()
    {
        colorcube();

        // Create a checkerboard pattern
        for ( int i = 0; i &lt; 64; i++ ) {
            for ( int j = 0; j &lt; 64; j++ ) {
                GLubyte c = (((i &amp; 0x8) == 0) ^ ((j &amp; 0x8)  == 0)) * 255;
                image[i][j][0]  = c;
                image[i][j][1]  = c;
                image[i][j][2]  = c;
                image2[i][j][0] = c;
                image2[i][j][1] = 0;
                image2[i][j][2] = c;
            }
        }

        // Initialize texture objects
        glGenTextures( 2, textures );

        glBindTexture( GL_TEXTURE_2D, textures[0] );
        glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, TextureSize, TextureSize, 0,
            GL_RGB, GL_UNSIGNED_BYTE, image );
        glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
        glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
        glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
        glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );

        glBindTexture( GL_TEXTURE_2D, textures[1] );
        glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, TextureSize, TextureSize, 0,
            GL_RGB, GL_UNSIGNED_BYTE, image2 );
        glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
        glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
        glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
        glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );

        glActiveTexture( GL_TEXTURE0 );
        glBindTexture( GL_TEXTURE_2D, textures[0] );

        // Create a vertex array object
        GLuint vao;
        glGenVertexArrays( 1, &amp;vao );
        glBindVertexArray( vao );

        // Create and initialize a buffer object
        GLuint buffer;
        glGenBuffers( 1, &amp;buffer );
        glBindBuffer( GL_ARRAY_BUFFER, buffer );
        glBufferData( GL_ARRAY_BUFFER,
            sizeof(points) + sizeof(quad_colors) + sizeof(tex_coords),
            NULL, GL_STATIC_DRAW );

        // Specify an offset to keep track of where we&#39;re placing data in our
        //   vertex array buffer.  We&#39;ll use the same technique when we
        //   associate the offsets with vertex attribute pointers.
        GLintptr offset = 0;
        glBufferSubData( GL_ARRAY_BUFFER, offset, sizeof(points), points );
        offset += sizeof(points);

        glBufferSubData( GL_ARRAY_BUFFER, offset,
            sizeof(quad_colors), quad_colors );
        offset += sizeof(quad_colors);

        glBufferSubData( GL_ARRAY_BUFFER, offset, sizeof(tex_coords), tex_coords );

        // Load shaders and use the resulting shader program
        GLuint program = InitShader( &quot;vshader71.glsl&quot;, &quot;fshader71.glsl&quot; );
        glUseProgram( program );

        // set up vertex arrays
        offset = 0;
        GLuint vPosition = glGetAttribLocation( program, &quot;vPosition&quot; );
        glEnableVertexAttribArray( vPosition );
        glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0,
            BUFFER_OFFSET(offset) );
        offset += sizeof(points);

        GLuint vColor = glGetAttribLocation( program, &quot;vColor&quot; ); 
        glEnableVertexAttribArray( vColor );
        glVertexAttribPointer( vColor, 4, GL_FLOAT, GL_FALSE, 0,
            BUFFER_OFFSET(offset) );
        offset += sizeof(quad_colors);

        GLuint vTexCoord = glGetAttribLocation( program, &quot;vTexCoord&quot; );
        glEnableVertexAttribArray( vTexCoord );
        glVertexAttribPointer( vTexCoord, 2, GL_FLOAT, GL_FALSE, 0,
            BUFFER_OFFSET(offset) );

        // Set the value of the fragment shader texture sampler variable
        //   (&quot;texture&quot;) to the the appropriate texture unit. In this case,
        //   zero, for GL_TEXTURE0 which was previously set by calling
        //   glActiveTexture().
        glUniform1i( glGetUniformLocation(program, &quot;texture&quot;), 0 );

        theta = glGetUniformLocation( program, &quot;theta&quot; );

        glEnable( GL_DEPTH_TEST );

        glClearColor( 1.0, 1.0, 1.0, 1.0 );
    }

    void display( void )
    {
        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

        glUniform3fv( theta, 1, Theta );

        glDrawArrays( GL_TRIANGLES, 0, NumVertices );

        glutSwapBuffers();
    }

    //----------------------------------------------------------------------------
    void mouse( int button, int state, int x, int y )
    {
        if ( state == GLUT_DOWN ) {
            switch( button ) {
            case GLUT_LEFT_BUTTON:    Axis = Xaxis;  break;
            case GLUT_MIDDLE_BUTTON:  Axis = Yaxis;  break;
            case GLUT_RIGHT_BUTTON:   Axis = Zaxis;  break;
            }
        }
    }

    //----------------------------------------------------------------------------
    void idle( void )
    {
        Theta[Axis] += 0.01;

        if ( Theta[Axis] &gt; 360.0 ) {
            Theta[Axis] -= 360.0;
        }

        glutPostRedisplay();
    }

    //----------------------------------------------------------------------------
    void keyboard( unsigned char key, int mousex, int mousey )
    {
        switch( key ) {
        case 033: // Escape Key
        case &#39;q&#39;: case &#39;Q&#39;:
            exit( EXIT_SUCCESS );
            break;
        case &#39;1&#39;:
            glBindTexture( GL_TEXTURE_2D, textures[0] );
            break;

        case &#39;2&#39;:
            glBindTexture( GL_TEXTURE_2D, textures[1] );
            break;
        }

        glutPostRedisplay();
    }

    //----------------------------------------------------------------------------
    int main( int argc, char **argv )
    {
        glutInit( &amp;argc, argv );
        glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH );
        glutInitWindowSize( 512, 512 );
        glutInitContextVersion( 3, 2 );
        glutInitContextProfile( GLUT_CORE_PROFILE );
        glutCreateWindow( &quot;Color Cube&quot; );

        glewInit();

        init();

        glutDisplayFunc( display );
        glutKeyboardFunc( keyboard );
        glutMouseFunc( mouse );
        glutIdleFunc( idle );

        glutMainLoop();
        return 0;
    }

Segmentation fault at glGenVertexArrays( 1, &amp;vao );

Just want to make sure I understand this correctly (I&#39;d ask on SO Chat, but it&#39;s dead in there!):

We&#39;ve got a Vertex Array, which we make &quot;current&quot; by binding it  
then we&#39;ve got a Buffer, which we bind to a Target  
then we fill that Target via `glBufferData`
which essentially populates whatever was bound to that target, i.e. our Buffer  
and then we call `glVertexAttribPointer` which describes how the data is laid out -- the data being whatever is bound to `GL_ARRAY_BUFFER`
and this descriptor is saved to our original Vertex Array  

(1) Is my understanding correct?  
The [documentation][1] is a little sparse about how everything correlates.

(2) Is there some kind of default Vertex Array? Because I forgot/omitted `glGenVertexArrays` and `glBindVertexArray` and my program worked fine without it.

---

**Edit:** I missed a step... `glEnableVertexAttribArray`. 

(3) Is the Vertex Attrib tied to the Vertex Array at the time `glVertexAttribPointer` is called, and then we can enable/disable that attrib via `glEnableVertexAttribArray` at any time, regardless of which Vertex Array is currently bound?

Or (3b) Is the Vertex Attrib tied to the Vertex Array at the time `glEnableVertexAttribArray` is called, and thus we can add the same Vertex Attrib to multiple Vertex Arrays by calling `glEnableVertexAttribArray` at different times, when different Vertex Arrays are bound?


  [1]: https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glVertexAttribPointer.xhtml

glVertexAttribPointer clarification

I don&#39;t have the option to use but OpenGL methods (that is `glxxx()` methods). I need to draw text using gl methods only. After reading the red book, I understand that it is possible only through the `glBitmap()` method. If this is the only possible way, then can any one help me with the pixel array information for all the characters. Is there is any other way to draw text?

How to draw text using only OpenGL methods?

From what I gather, `glActiveTexture` sets the active &quot;texture unit&quot;. Each texture unit can have multiple texture targets (usually GL_TEXTURE_1D, 2D, 3D or CUBE_MAP).

If I understand correctly, you have to call `glActiveTexture` to set the texture unit first (initialized to `GL_TEXTURE0`), and then you bind (one or more) &quot;texture targets&quot; to that texture unit?

The number of texture units available is system dependent. I see enums for up to 32 in my library. I guess this essentially means I can have the lesser of my GPU&#39;s limit (which I think is &lt;del&gt;16&lt;/del&gt; 8) and 32 textures in GPU memory at any one time? I guess there&#39;s an additional limit that I don&#39;t exceed my GPU&#39;s maximum memory (supposedly 1 GB).

Am I understanding the relationship between texture targets and texture units correctly? Let&#39;s say I&#39;m allowed 16 units and 4 targets each, does that mean there&#39;s room for 16*4=64 targets, or does it not work like that?

Next you typically want to load a texture. You can do this via `glTexImage2D`. The first argument of which is a texture target. If this [works like `glBufferData`](https://stackoverflow.com/a/8691709/65387), then we essentially bind the &quot;handle&quot;/&quot;texture name&quot; to the texture target, and then load the texture data into that target, and thus indirectly associate it with that handle.

What about `glTexParameter`? We have to bind a texture target, and then choose that same target again as the first argument? Or does the texture target not need to be bound as long as we have the correct active texture unit?

`glGenerateMipmap` operates on a target too...that target has to still be bound to the texture name for it to succeed?

Then when we want to draw our object with a texture on it, do we have to *both* choose an active texture unit, and then a texture target? Or do we choose a texture unit, and then we can grab data from any of the 4 targets associated with that unit? This is the part that&#39;s really confusing me.

Differences and relationship between glActiveTexture and glBindTexture

Im facing an issue which I believe to be VAO-dependant, but Im not sure..

I am not sure about the correct usage of a VAO, what I used to do during GL initialization was a simple

    glGenVertexArrays(1,&amp;vao)

followed by a

    glBindVertexArray(vao)

and later, in my drawing pipeline, I just called **glBindBuffer(), glVertexAttribPointer(), glEnableVertexAttribArray()** and so on.. without caring about the initally bound VAO

is this a correct practice?

OpenGL VAO best practices

My code approaches GLSL shader management in the way, that it creates each shader and the associated program and deletes each shader and program. I recently read http://www.opengl.org/wiki/GLSL_Object and there it is stated that:

&gt; The shader object, due to being attached to the program object, will
&gt; continue to exist even if you delete the shader object. It will only
&gt; be deleted by the system when it is no longer  attached to any program
&gt; object (and when the user has asked to delete it, of course).

Do I get this correctly, if I call `glDeleteShader()` on the shader object after linking to the program, I only need to track the program? Is it safe to assume this is always true?

Proper way to delete GLSL shader?

I see a lot of different fragment shaders,


    #version 130
    
    out vec4 flatColor;
    
    void main(void)
    {
        flatColor = vec4(0.0,1.0,0.0,0.5);
    }

And they all use a different variable for the &quot;out color&quot; (in this case `flatColor`). So how does OpenGL know what you&#39;re trying to do?

I&#39;m guessing this works because `flatColor` is the only variable defined as `out`, but you&#39;re allowed to add more `out` variables aren&#39;t you? Or would that just crash?

---

Actually, as a test, I just ran this:

    #version 330
    
    in vec2 TexCoord0;
    
    uniform sampler2D TexSampler;
    
    out vec4 x;
    out vec4 y;
    
    void main()
    {
        y = texture2D(TexSampler, TexCoord0.xy);
    }

It worked fine whether I used `x` or `y`.

(answer: the compiler is optimizing out the unused var, so the remaining var is assigned to location 0)

---

Furthermore, we have a predefined `gl_FragColor`. What&#39;s the difference, and why do people usually insist on using their own variables?

How does the fragment shader know what variable to use for the color of a pixel?

When you are learning 3D programming, you are taught that it&#39;s easiest think in terms of 3 transformation matrices:

   1. *The Model Matrix*. This matrix is individual to every single model and it rotates and scales the object as desired and finally moves it to its final position within your 3D world. &quot;The Model Matrix transforms model coordinates to world coordinates&quot;.

   2. *The View Matrix*. This matrix is usually the same for a large number of objects (if not for all of them) and it rotates and moves all objects according to the current &quot;camera position&quot;. If you imaging that the 3D scene is filmed by a camera and what is rendered on the screen are the images that were captured by this camera, the location of the camera and its viewing direction define which parts of the scene are visible and how the objects appear on the captured image. There are little reasons for changing the view matrix while rendering a single frame, but those do in fact exists (e.g. by rendering the scene twice and changing the view matrix in between, you can create a very simple, yet impressive mirror within your scene). Usually the view matrix changes only once between two frames being drawn. &quot;The View Matrix transforms world coordinates to eye coordinates&quot;.

   3. *The Projection Matrix*. The projection matrix decides how those 3D coordinates are mapped to 2D coordinates, e.g. if there is a perspective applied to them (objects get smaller the farther they are away from the viewer) or not (orthogonal projection). The projection matrix hardly ever changes at all. It may have to change if you are rendering into a window and the window size has changed or if you are rendering full screen and the resolution has changed, however only if the new window size/screen resolution has a different display aspect ratio than before. There are some crazy effects for that you may want to change this matrix but in most cases its pretty much constant for the whole live of your program. &quot;The Projection Matrix transforms eye coordinates to screen coordinates&quot;.

This makes all a lot of sense to me. Of course one could always combine all three matrices into a single one, since multiplying a vector first by matrix `A` and then by matrix `B` is the same as multiplying the vector by matrix `C`, where `C = B * A`.

Now if you look at the classical OpenGL (OpenGL 1.x/2.x), OpenGL knows a projection matrix. Yet OpenGL does not offer a model or a view matrix, it only offers a combined model-view matrix. **Why?** This design forces you to permanently save and restore the &quot;view matrix&quot; since it will get &quot;destroyed&quot; by model transformations applied to it. Why aren&#39;t there three separate matrices?

If you look at the new OpenGL versions (OpenGL 3.x/4.x) and you don&#39;t use the classical render pipeline but customize everything with shaders (GLSL), there are no matrices available any longer at all, you have to define your own matrices. Still most people keep the old concept of a projection matrix and a model-view matrix. **Why would you do that?** Why not using either three matrices, which means you don&#39;t have to permanently save and restore the model-view matrix or you use a single combined model-view-projection (MVP) matrix, which saves you a matrix multiplication in your vertex shader for ever single vertex rendered (after all such a multiplication doesn&#39;t come for free either).

So to summarize my question: Which advantage has a combined model-view matrix together with a separate projection matrix over having three separate matrices or a single MVP matrix?

Why would it be beneficial to have a separate projection matrix, yet combine model and view matrix?

I&#39;ve been attempting to write a two-pass GPU implementation of the Marching Cubes algorithm, similar to the one detailed in the first chapter of GPU Gems 3, using OpenGL and GLSL. However, the call to `glDrawArrays` in my first pass consistently fails with a `GL_INVALID_OPERATION`.

I&#39;ve looked up all the documentation I can find, and found these conditions under which `glDrawArrays` can throw that error:

 1. `GL_INVALID_OPERATION` is generated if a non-zero buffer object name is bound to an enabled array or to the `GL_DRAW_INDIRECT_BUFFER` binding and the buffer object&#39;s data store is currently mapped.
 2. `GL_INVALID_OPERATION` is generated if `glDrawArrays` is executed between the execution of `glBegin` and the corresponding `glEnd`.
 3. `GL_INVALID_OPERATION` will be generated by `glDrawArrays` or `glDrawElements` if any two active samplers in the current program object are of different types, but refer to the same texture image unit.
 4. `GL_INVALID_OPERATION` is generated if a geometry shader is active and mode is incompatible with the input primitive type of the geometry shader in the currently installed program object.
 5. `GL_INVALID_OPERATION` is generated if mode is `GL_PATCHES` and no tessellation control shader is active.
 6. `GL_INVALID_OPERATION` is generated if recording the vertices of a primitive to the buffer objects being used for transform feedback purposes would result in either exceeding the limits of any buffer object’s size, or in exceeding the end position offset + size - 1, as set by `glBindBufferRange`.
 7. `GL_INVALID_OPERATION` is generated by `glDrawArrays()` if no geometry shader is present, transform feedback is active and mode is not one of the allowed modes.
 8. `GL_INVALID_OPERATION` is generated by `glDrawArrays()` if a geometry shader is present, transform feedback is active and the output primitive type of the geometry shader does not match the transform feedback primitiveMode.
 9. `GL_INVALID_OPERATION` is generated if the bound shader program is invalid.
 10. **EDIT 10/10/12:** `GL_INVALID_OPERATION` is generated if transform feedback is in use, and the buffer bound to the transform feedback binding point is also bound to the array buffer binding point. **This is the problem I was having, due to a typo in which buffer I bound. While the spec does state that this is illegal, it isn&#39;t listed under glDrawArrays as one of the reasons it can throw an error, in any documentation I found.**

Unfortunately, no one piece of official documentation I can find covers more than 3 of these. I had to collect this list from numerous sources. Points 7 and 8 actually come from the documentation for `glBeginTransformFeedback`, and point 9 doesn&#39;t seem to be documented at all. I found it mentioned in a forum post somewhere. However, I still don&#39;t think this list is complete, as none of these seem to explain the error I&#39;m getting.

 1. I&#39;m not mapping any buffers at all in my program, anywhere.
 2. I&#39;m using the Core profile, so `glBegin` and `glEnd` aren&#39;t even available.
 3. I have two samplers, and they are of different types, but they&#39;re definitely mapped to different textures.
 4. A geometry shader is active, but it&#39;s input layout is `layout (points) in`, and `glDrawArrays` is being called with `GL_POINTS`.
 5. I&#39;m not using `GL_PATCHES` or tessellation shaders of any sort.
 6. I&#39;ve made sure I&#39;m allocating the maximum amount of space my geometry shaders could possible output. Then I tried quadrupling it. Didn&#39;t help.
 7. There is a geometry shader. See the next point.
 8. Transform feedback is being used, and there is a geometry shader, but the output layout is `layout (points) out` and `glBeginTransformFeedback` is called with `GL_POINTS`.
 9. I tried inserting a call to `glValidateProgram` right before the call to `glDrawArrays`, and it returned `GL_TRUE`.

The actual OpenGL code is here:

        const int SECTOR_SIZE = 32;
        const int SECTOR_SIZE_CUBED = SECTOR_SIZE * SECTOR_SIZE * SECTOR_SIZE;
        const int CACHE_SIZE = SECTOR_SIZE + 3;
        const int CACHE_SIZE_CUBED = CACHE_SIZE * CACHE_SIZE * CACHE_SIZE;
        
        MarchingCubesDoublePass::MarchingCubesDoublePass(ServiceProvider* svc, DensityMap* sourceData) {
            this-&gt;sourceData = sourceData;
            densityCache = new float[CACHE_SIZE_CUBED];
        }
        
        MarchingCubesDoublePass::~MarchingCubesDoublePass() {
            delete densityCache;
        }
        
        void MarchingCubesDoublePass::InitShaders() {
            ShaderInfo vertShader, geoShader, fragShader;
            
            vertShader = svc-&gt;shader-&gt;Load(&quot;data/shaders/MarchingCubesDoublePass-Pass1.vert&quot;, GL_VERTEX_SHADER);
            svc-&gt;shader-&gt;Compile(vertShader);
            geoShader = svc-&gt;shader-&gt;Load(&quot;data/shaders/MarchingCubesDoublePass-Pass1.geo&quot;, GL_GEOMETRY_SHADER);
            svc-&gt;shader-&gt;Compile(geoShader);
            shaderPass1 = glCreateProgram();
            static const char* outputVaryings[] = { &quot;triangle&quot; };
            glTransformFeedbackVaryings(shaderPass1, 1, outputVaryings, GL_SEPARATE_ATTRIBS);
            assert(svc-&gt;shader-&gt;Link(shaderPass1, vertShader, geoShader));
            
            uniPass1DensityMap = glGetUniformLocation(shaderPass1, &quot;densityMap&quot;);
            uniPass1TriTable = glGetUniformLocation(shaderPass1, &quot;triangleTable&quot;);
            uniPass1Size = glGetUniformLocation(shaderPass1, &quot;size&quot;);
            attribPass1VertPosition = glGetAttribLocation(shaderPass1, &quot;vertPosition&quot;);
            
            vertShader = svc-&gt;shader-&gt;Load(&quot;data/shaders/MarchingCubesDoublePass-Pass2.vert&quot;, GL_VERTEX_SHADER);
            svc-&gt;shader-&gt;Compile(vertShader);
            geoShader = svc-&gt;shader-&gt;Load(&quot;data/shaders/MarchingCubesDoublePass-Pass2.geo&quot;, GL_GEOMETRY_SHADER);
            svc-&gt;shader-&gt;Compile(geoShader);
            fragShader = svc-&gt;shader-&gt;Load(&quot;data/shaders/MarchingCubesDoublePass-Pass2.frag&quot;, GL_FRAGMENT_SHADER);
            svc-&gt;shader-&gt;Compile(fragShader);
            shaderPass2 = glCreateProgram();
            assert(svc-&gt;shader-&gt;Link(shaderPass2, vertShader, geoShader, fragShader));
            
            uniPass2DensityMap = glGetUniformLocation(shaderPass2, &quot;densityMap&quot;);
            uniPass2Size = glGetUniformLocation(shaderPass2, &quot;size&quot;);
            uniPass2Offset = glGetUniformLocation(shaderPass2, &quot;offset&quot;);
            uniPass2Matrix = glGetUniformLocation(shaderPass2, &quot;matrix&quot;);
            attribPass2Triangle = glGetAttribLocation(shaderPass2, &quot;triangle&quot;);
        }
        
        void MarchingCubesDoublePass::InitTextures() {
            for (int x = 0; x &lt; CACHE_SIZE; x++) {
                for (int y = 0; y &lt; CACHE_SIZE; y++) {
                    for (int z = 0; z &lt; CACHE_SIZE; z++) {
                        densityCache[x + y*CACHE_SIZE + z*CACHE_SIZE*CACHE_SIZE] = sourceData-&gt;GetDensity(Vector3(x-1, y-1, z-1));
                    }
                }
            }
            glGenTextures(1, &amp;densityTex);
            glBindTexture(GL_TEXTURE_3D, densityTex);
            glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
            glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
            glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
            glTexImage3D(GL_TEXTURE_3D, 0, GL_R32F, CACHE_SIZE, CACHE_SIZE, CACHE_SIZE, 0, GL_RED, GL_FLOAT, densityCache);
            
            glGenTextures(1, &amp;triTableTex);
            glBindTexture(GL_TEXTURE_RECTANGLE, triTableTex);
            glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
            glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
            glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
            glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
            glTexImage2D(GL_TEXTURE_RECTANGLE, 0, GL_R16I, 16, 256, 0, GL_RED_INTEGER, GL_INT, triTable);
        }
        
        void MarchingCubesDoublePass::InitBuffers() {
            float* voxelGrid = new float[SECTOR_SIZE_CUBED*3];
            unsigned int index = 0;
            for (int x = 0; x &lt; SECTOR_SIZE; x++) {
                for (int y = 0; y &lt; SECTOR_SIZE; y++) {
                    for (int z = 0; z &lt; SECTOR_SIZE; z++) {
                        voxelGrid[index*3 + 0] = x;
                        voxelGrid[index*3 + 1] = y;
                        voxelGrid[index*3 + 2] = z;
                        index++;
                    }
                }
            }
            
            glGenBuffers(1, &amp;bufferPass1);
            glBindBuffer(GL_ARRAY_BUFFER, bufferPass1);
            glBufferData(GL_ARRAY_BUFFER, SECTOR_SIZE_CUBED*3*sizeof(float), voxelGrid, GL_STATIC_DRAW);
            glBindBuffer(GL_ARRAY_BUFFER, 0);
            
            glGenBuffers(1, &amp;bufferPass2);
            glBindBuffer(GL_ARRAY_BUFFER, bufferPass2);
            glBufferData(GL_ARRAY_BUFFER, SECTOR_SIZE_CUBED*5*sizeof(int), NULL, GL_DYNAMIC_COPY);
            glBindBuffer(GL_ARRAY_BUFFER, 0);
            
            glGenVertexArrays(1, &amp;vaoPass1);
            glBindVertexArray(vaoPass1);
            glBindBuffer(GL_ARRAY_BUFFER, bufferPass1);
            glVertexAttribPointer(attribPass1VertPosition, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
            glBindBuffer(GL_ARRAY_BUFFER, 0);
            glEnableVertexAttribArray(attribPass1VertPosition);
            glBindVertexArray(0);
            
            glGenVertexArrays(1, &amp;vaoPass2);
            glBindVertexArray(vaoPass2);
            glBindBuffer(GL_ARRAY_BUFFER, bufferPass2);
            glVertexAttribIPointer(attribPass2Triangle, 1, GL_INT, 0, (void*)0);
            glBindBuffer(GL_ARRAY_BUFFER, 0);
            glEnableVertexAttribArray(attribPass2Triangle);
            glBindVertexArray(0);
            
            glGenQueries(1, &amp;queryNumTriangles);
        }
        
        void MarchingCubesDoublePass::Register(Genesis::ServiceProvider* svc, Genesis::Entity* ent) {
            this-&gt;svc = svc;
            this-&gt;ent = ent;
            svc-&gt;scene-&gt;RegisterEntity(ent);
            
            InitShaders();
            InitTextures();
            InitBuffers();
        }
        
        void MarchingCubesDoublePass::Unregister() {
            if (!ent-&gt;GetBehavior&lt;Genesis::Render&gt;()) {
                svc-&gt;scene-&gt;UnregisterEntity(ent);
            }
        }
        
        void MarchingCubesDoublePass::RenderPass1() {
            glEnable(GL_RASTERIZER_DISCARD);
            
            glUseProgram(shaderPass1);
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_3D, densityTex);
            glActiveTexture(GL_TEXTURE1);
            glBindTexture(GL_TEXTURE_RECTANGLE, triTableTex);
            glUniform1i(uniPass1DensityMap, 0);
            glUniform1i(uniPass1TriTable, 1);
            glUniform1i(uniPass1Size, SECTOR_SIZE);
            
            glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufferPass2);
            
            glBindVertexArray(vaoPass2);
            glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, queryNumTriangles);
            glBeginTransformFeedback(GL_POINTS);
                GLenum error = glGetError();
                glDrawArrays(GL_POINTS, 0, SECTOR_SIZE_CUBED);
                error = glGetError();
            glEndTransformFeedback();
            glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
            glBindVertexArray(0);
            
            glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
            
            glUseProgram(0);
            
            glDisable(GL_RASTERIZER_DISCARD);
            
            glGetQueryObjectuiv(queryNumTriangles, GL_QUERY_RESULT, &amp;numTriangles);
        }
        
        void MarchingCubesDoublePass::RenderPass2(Matrix mat) {
            glUseProgram(shaderPass2);
            
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_3D, densityTex);
            
            glUniform1i(uniPass2DensityMap, 0);
            glUniform1i(uniPass2Size, SECTOR_SIZE);
            glUniform3f(uniPass2Offset, 0, 0, 0);
            mat.UniformMatrix(uniPass2Matrix);
            
            glBindVertexArray(vaoPass2);
            glDrawArrays(GL_POINTS, 0, numTriangles);
            glBindVertexArray(0);
            
            glUseProgram(0);
        }
        
        void MarchingCubesDoublePass::OnRender(Matrix mat) {
            RenderPass1();
            RenderPass2(mat);
        }

The actual error is the call to `glDrawArrays` in `RenderPass1`. Worth noting that if I comment out the calls to `glBeginTransformFeedback` and `glEndTransformFeedback`, then `glDrawArrays` stops generating the error. So whatever&#39;s wrong, it&#39;s probably somehow related to transform feedback.

**Edit 8/18/12, 9 PM:**

I just found the NVIDIA GLExpert feature in gDEBugger, which I wasn&#39;t previously familiar with. When I turned this on, it gave somewhat more substantial information on the `GL_INVALID_OPERATION`, specifically `The current operation is illegal in the current state:  Buffer is mapped.`. So I&#39;m running into point 1, above. Though I have no idea how.

I have no calls to `glMapBuffer`, or any related function, anywhere in my code. I set gDEBugger to break on any calls to `glMapBuffer`, `glMapBufferARB`, `glMapBufferRange`, `glUnmapBuffer` and `glUnmapBufferARB`, and it didn&#39;t break anywhere. Then I added code to the start of `RenderPass1` to explicitly unmap bother buffers. Not only did the error not go away, but calls to `glUnmapBuffer` now both generate `The current operation is illegal in the current state:  Buffer is unbound or is already unmapped.`. So if neither of the buffers I&#39;m using are mapped, where is the error coming from?

**Edit 8/19/12, 12 AM:**

Based on the error messages I&#39;m getting out of GLExpert in gDEBugger, it appears that calling `glBeginTransformFeedback` is causing the buffer bound to `GL_TRANSFORM_FEEDBACK_BUFFER` to become mapped. Specifically, when I click on the buffer in &quot;Textures, Buffers and Images Viewer&quot; it outputs the message `The current operation is illegal in the current state:  Buffer must be bound and not mapped.`. However, if I add this between `glBeginTransformFeedback` and `glEndTransformFeedback`:

    int bufferBinding;
    glGetBufferParameteriv(GL_TRANSFORM_FEEDBACK_BUFFER, GL_BUFFER_MAPPED, &amp;bufferBinding);
    printf(&quot;Transform feedback buffer binding: %d\n&quot;, bufferBinding);

it outputs 0, which would indicate that `GL_TRANSFORM_FEEDBACK_BUFFER` is not mapped. If this buffer is mapped on another binding point, would this still return 0? Why would `glBeginTransformFeedback` map the buffer, thus rendering it unusable for transform feedback?

The more I learn here, the more confused I&#39;m becoming.

**Edit 10/10/12:**

As indicated in my reply below to Nicol Bolas&#39; solution, I found the problem, and it&#39;s the same one he found: Due to a stupid typo, I was binding the same buffer to both the input and output binding points.

I found it probably two weeks after posting the question. I&#39;d given up in frustration for a time, and eventually came back and basically re-implemented the whole thing from scratch, regularly comparing bits and pieces the older, non-working one. When I was done, the new version worked, and it was when I searched out the differences that I discovered I&#39;d been binding the wrong buffer.

What can cause glDrawArrays to generate a GL_INVALID_OPERATION error?

I&#39;ve seen this pseudo-random number generator for use in shaders referred to [here and there around the web][1]:

    float rand(vec2 co){
      return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
    }


It&#39;s variously called &quot;canonical&quot;, or &quot;a one-liner I found on the web somewhere&quot;.

What&#39;s the origin of this function? Are the constant values as arbitrary as they seem or is there some art to their selection? Is there any discussion of the merits of this function?

EDIT: The oldest reference to this function that I&#39;ve come across is [this archive from Feb &#39;08][2], the original page now being gone from the web. But there&#39;s no more discussion of it there than anywhere else.


  [1]: https://www.google.com/search?q=fract%28sin%28dot%28co.xy%20,vec2%2812.9898,78.233%29%29%29%20*%2043758.5453%29&amp;rlz=1C1CHFA_enUS484US484&amp;oq=fract%28sin%28dot%28co.xy%20,vec2%2812.9898,78.233%29%29%29%20*%2043758.5453%29&amp;sugexp=chrome,mod=9&amp;sourceid=chrome&amp;ie=UTF-8
  [2]: http://web.archive.org/web/20080211204527/http://lumina.sourceforge.net/Tutorials/Noise.html

What&#39;s the origin of this GLSL rand() one-liner?

## The Problem (TL;DR)

My problem, fundamentally, is that I do not know how OpenGL ES 2.0 expects me to write and use multiple shaders; or if it is even advisable/expected that a person will do so.

The fundamental question here is: if I have an apple, a glowing rock and a fuzzy mesh, all in the same 3D world, all best drawn with different shader programs but using the same mvpMatrix then how would I go about using all of them in the same OpenGL render such that they all use their most appropriate shaders that I have written?

## What Have I done

So I have written a basic OpenGL ES 2.0 program for my Android Game that works perfectly in that it can draw the outline of the objects to the screen. But it does nothing else; pretty much because the shaders look like this:

### Vertex Shader

    uniform mat4 uMVPMatrix;
    attribute vec4 aPosition;
    
    void main() {
    	gl_Position = uMVPMatrix * aPosition;
    }

### Fragment Shader

    void main() {
    	gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
    }

Now they are pretty basic. The reason that I have not gone further is because I cannot figure out if I am supposed to write one shader to apply to all of my different objects or if I am supposed to use multiple shaders. And if I am supposed to use multiple shaders to draw multiple different objects then how do I go about doing that in an efficient way?

I get the feeling that this must be basic knowledge to anybody that does OpenGL ES 2.0 day in and day out so I am hoping that somebody can answer my question or point me in the right direction.

I have:

 - Looked at multiple tutorials; none of which use anything but the most basic shaders.
 - Read the entire OpenGL ES 2.0 GLSL Spec (none of which mentioned how it was intended to be used; it was just about what everything did rather than how it fits together).
 - Tried to modify my shaders a bit.

So I&#39;m hoping that I am close to understanding the OpenGL workflow but I don&#39;t seem to be there yet. 

Edit: I found this well afterwards:

&gt; If your application is written for OpenGL ES 2.0, do not create a single shader with lots of switches and conditionals that performs every task your application needs to render the scene. Instead, compile multiple shader programs that each perform a specific, focused task.

That is from the [iOS OpenGL ES 2.0 guidelines.][1]


  [1]: http://developer.apple.com/library/ios/#documentation/3DDrawing/Conceptual/OpenGLES_ProgrammingGuide/Performance/Performance.html#//apple_ref/doc/uid/TP40008793-CH105-SW11

OpenGL ES 2.0 Multiple Programs or Multiple Shaders or what? How does it work?

I&#39;ve been knocking around Shadertoy - https://www.shadertoy.com/ - recently, in an effort to learn more about OpenGL and GLSL in particular. 

From what I understand so far, the OpenGL user first has to prepare all the geometry to be used and configure the OpenGL server (number of lights allowed, texture storage, etc). Once that&#39;s done, the user then has to provide at least one vertex shader program, and one fragment shader program before an OpenGL program compiles.

However, when I look at the code samples on Shadertoy, I only ever see one shader program, and most of the geometry used appears to be written directly into the GLSL code.

How does that work?

My guess is that a vertex shader is already prepared upfront, and that the editable/sample shader is only a fragment shader. But then that doesn&#39;t explain the geometry in some of the more complex examples...

Can anyone explain how Shadertoy works?



WebGL/GLSL - How does a ShaderToy work?

I want to know if &quot;if-statements&quot; inside shaders (vertex / fragment / pixel...) are really slowing down the shader performance. For example:

Is it better to use this:

    vec3 output;
    output = input*enable + input2*(1-enable);
instead of using this:

    vec3 output;
    if(enable == 1)
    {
        output = input;
    }
    else
    {
        output = input2;
    }

in another forum there was a talk about that (2013): http://answers.unity3d.com/questions/442688/shader-if-else-performance.html
Here the guys are saying, that the If-statements are really bad for the performance of the shader.

Also here they are talking about how much is inside the if/else statements (2012):
https://www.opengl.org/discussion_boards/showthread.php/177762-Performance-alternative-for-if-(-)

maybe the hardware or the shadercompiler are better now and they fix somehow this (maybe not existing) performance issue.

EDIT:

What is with this case, here lets say enable is a uniform variable and it is always set to 0:

    if(enable == 1) //never happens
    {
        output = vec4(0,0,0,0);
    }
    else  //always happens
    {
        output = calcPhong(normal, lightDir);
    }

I think here we have a branch inside the shader which slows the shader down. Is that correct?

Does it make more sense to make 2 different shaders like one for the else and the other for the if part?

Content Type	Original Author	Original Content on Stackoverflow
Question	Miles	View Question on Stackoverflow
Solution 1 - Arrays	datenwolf	View Answer on Stackoverflow
Solution 2 - Arrays	NickLH	View Answer on Stackoverflow

Creating a GLSL Arrays of Uniforms?

Arrays Problem Overview

Arrays Solutions

Solution 1 - Arrays

Solution 2 - Arrays

Is it OK to have a class with just properties for refactoring purposes?

The actor model: Why is Erlang/OTP special? Could you use another language?

Attributions