Part of the Khronos Group
OpenGL.org

The Industry's Foundation for High Performance Graphics

from games to virtual reality, mobile phones to supercomputers

Results 1 to 3 of 3

Thread: Problem using GL_COLOR_ARRAY to send information to shader

  1. #1
    Intern Newbie
    Join Date
    Apr 2011
    Posts
    36

    Cool Problem using GL_COLOR_ARRAY to send information to shader

    I have an array of particles that I'd like to draw at once using glDrawArrays, however I would also like to dynamically set the alpha of some particles while using a shader. I came up with a method of using GL_COLOR_ARRAY to send the alpha information per point to the shader. It works fine, however after calling glDisableClientState(GL_COLOR_ARRAY); on certain graphics cards the color array stays active and modifies everything else drawn. For example:

    Here is where I draw my particles:
    Code :
    glUseProgram(particleShader);
    glEnableClientState(GL_COLOR_ARRAY);
    glBindTexture(GL_TEXTURE_2D, particleTexture);
    glColorPointer(4, GL_FLOAT, 0, betweenPartColorArray);
    glTexCoordPointer(2, GL_FLOAT, 0,textureCoordsBetweenParticles);
    glVertexPointer(3, GL_FLOAT, 0, verticesBetweenParticles);
    glDrawArrays(GL_QUADS, 0, numberBetweenPartIndices);
    glDisableClientState(GL_COLOR_ARRAY);
    glUseProgram(0);
    Here is the relevant part of my shader that takes the color array and uses that to change the alpha on individual particles:


    Vertex:
    Code :
    varying vec4 vertex_color;
    varying vec4 verpos; // had an error with verpos for whatever reason.  If problems crop check into it
    void main(void){
        vertex_color = gl_Color;
        gl_Position = ftransform();
        gl_TexCoord[0] = gl_MultiTexCoord0;
        verpos = gl_ModelViewMatrix*gl_Vertex;
    }
    Fragment:
    Code :
    varying vec4 vertex_color;
    uniform sampler2D sceneTex;
    void main (void) {
        vec4 finalColor = texture2D(sceneTex, gl_TexCoord[0].xy) ;
        gl_FragColor=finalColor;
        finalColor.a*=vertex_color.a;
        finalColor=clamp(finalColor, 0.0, 1.0);
        gl_FragColor=finalColor;
    }

    The problem is (on certain computers) everything drawn after this gets tinted according to the color array even though glDisableClientState(GL_COLOR_ARRAY); is called. If I were to change the red component on the color array, everything drawn after the color array is disabled has a red tint.


    Is there a way to make sure GL_COLOR_ARRAY is really disabled besides what I am doing here?
    Also, is there a better method to send per vertex information to a shader. I mainly need to the shader to know which vertices I want alpha modified while leaving all of the particles in the array.

    Thanks!

  2. #2
    Member Regular Contributor
    Join Date
    Aug 2008
    Posts
    445
    Do they take the colors in the array, or the value of the last color?
    In earlier OpenGL versions, the spec states
    Quote Originally Posted by OpenGL_2.1 spec
    the current normal coordinates, color, secondary color, color
    index, edge flag, fog coordinate, texture coordinates, and generic attributes are each
    indeterminate after the execution of DrawElements, if the corresponding array is
    enabled. Current values corresponding to disabled arrays are not modified by the
    execution of DrawElements.
    The same text applies to DrawArrays.

    In recent OpenGL specs they state:
    Quote Originally Posted by OpenGL 4.3 Compatibility spec
    If an array is enabled, the corresponding current vertex attribute value is unaffected
    by the execution of DrawElementsOneInstance.
    So older versions may or may not affect the current color after a draw call, but recent versions are guaranteed not to affect current values. This behavior changed in OpenGL version 4.1.

    In older versions you would need to call glColor after a draw call that uses the color array and before a draw call that doesn't use it (eg. reset the current color to (1,1,1,1)) to guarantee that the color tint doesn't bleed over, but that's not required if your implementation follows a newer version of the OpenGL spec.
    Last edited by Dan Bartlett; 11-10-2012 at 06:39 AM. Reason: found version where behavior was tightened up

  3. #3
    Intern Newbie
    Join Date
    Apr 2011
    Posts
    36
    Ahh yea, that might work. I haven't tested it yet (need my friends computer) but I believe it is taking the last color instead of the entire array as every object after is the same tint even though some have large arrays. Thanks, I'll try this.

    Also still standing if anyone knows a better method to send per vertex information to a shader, let me know .

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •