An introduction to shaders.

• This activity is taken from the OpenGL Red Book, Eight Edition.
• If all else fails, you should be able to get a copy of the code in this exercise from ~dbennett/gltest
• You will need to link against some new header files
  • These are from the source code for the book.
  • I have placed them in ~dbennett/RedBook/include
  • If you add the line CXXFLAGS = -I ~dbennett/RedBook/include to your Makefile, it should work just fine.
    • -I path adds path to your include file search path.
    • This is the path used to look for included files inside of angle brackets.
    • This is a flag for the compiler (c++)
    • CXXFLAGS is part of the default rule to build c++ executable in make.
  • vgl.h
    • seems to handle all of the proper includes.
  • LoadShaders.h
    • Provides the interface to a library to load shaders.
• You will need to link against LoadShaders.o
  • This is from the Red Book as well.
  • I have placed a copy in ~dbennett/RedBook/lib
    • LoadShaders.C
    • LoadShaders.o
    • libLoadShaders.a
  • You should place the following line in your Makefile
  • LDFLAGS = -L ~dbennett/RedBook/lib
    • -L is a compiler flag
    • Well, actually a loader flag
    • It tells the compiler to add the next directory to the library search path
    • LDFLAGS is a default variable in the rule to construct executable.
  • And add -lLoadShaders to your LDLIBS
    • This is a compiler flag
    • Well, again probably a loader flag
    • It tells the loader to link with the given library
    • I created the library with the ar command.
    • Look at the Makefile in ~dbennett/RedBook/lib for more information
  • This is my Makefile
  • I have commented out the paths on cslab machines,
• Enter the following in triangle.C (or .cpp, or .fred if you really wish but ...)

  • #include <iostream>
    #include <vgl.h>
    #include <LoadShaders.h>
    
    using namespace std;
           

    • Note, the work in the Makefile section above allowed you to include the second and third file in angle brackets.

  • enum VAO_IDs {Triangles, NumVAOs};
    enum Buffer_IDs {ArrayBuffer, NumBuffers};
    enum Attrib_IDs {vPosition = 0};
           

    • He uses these enums to name things nicely.
    • I assume that if he wanted more than just triangles, he would add more things to VAO_IDs for example.
    • Remember C++ assigns the first enum to 0, the next to one and so on.
    • So NumVAOs will be the actual count for the enums.

  • GLuint VAOs[NumVAOs];
    GLuint Buffers[NumBuffers];
    
    const GLuint NumVertices = 6;
    
    GLfloat vertices[NumVertices][2] = {
          { -0.90, -0.90},
          {  0.85, -0.90},
          { -0.90,  0.85},
          {  0.90, -0.85},
          {  0.90,  0.90},
          { -0.85,  0.90}
    };
           

    • Nothing surprising here.
    • We will not be changing any transformation matrices, so everything is drawn within the clipping volume.

  • ShaderInfo shaders[] = {
        { GL_VERTEX_SHADER, "triangles.vert" },
        { GL_FRAGMENT_SHADER, "triangles.frag"},
        { GL_NONE, NULL}
    };
           

    • Here we set up a structure that holds types and names of shaders we will be creating.
    • You are required to have a Vertex shader and a Fragment shader.
    • These will be in a file in the current directory with the given name.
    • We will create these later in this exercise

  • 
    void setup() {
       GLuint program;
    
       glGenVertexArrays(NumVAOs, VAOs);
       glBindVertexArray(VAOs[Triangles]);
           

    • This generates the space to store all VAOs (only 1 in this case)
    • And makes the first one active.
      • All action takes place with the current VAO
      • We will really not see this since there is only one in this program.
      • But more later.

  •    glGenBuffers(NumBuffers, Buffers);
       glBindBuffer(GL_ARRAY_BUFFER, Buffers[ArrayBuffer]);
       glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
           

    • Make a space to hold actual data
    • And copy it over.

  •    program = LoadShaders(shaders);
       glUseProgram(program);
           

    • This is new.
    • LoadShaders is part of the code we linked above.
    • It will probably become part of a new OpenGL Toolkit some day
    • It is somewhat complex, but it reads, compiles and installs parallel programs on the GPU
    • Look at the code in LoadShaders.C (in ~dbennett/RedBook/lib) if you want more detail.

  •    glVertexAttribPointer(vPosition, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
       glEnableVertexAttribArray(vPosition);
    
       return;
    }
           

    • This tells the shaders that the data in the buffer should be associated with vPosition
    • More on this later

  • void display(){
    
       glClear(GL_COLOR_BUFFER_BIT);
    
       glBindVertexArray(VAOs[Triangles]);
       glDrawArrays(GL_TRIANGLES, 0, NumVertices);
    
       glFlush();
       return;
    }
           

    • This makes the VAO active
    • And Draws it.

  • void keypress(unsigned char key, int x, int y) {
    
        switch(key) {
           case 'q':
              exit(0);
        }
    
        glutPostRedisplay();
        return;
    }
    
    int main(int argc, char * argv[]) {
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_RGBA);
        glutInitWindowSize(512, 512);
        glutInitContextVersion(3,0);
        glutInitContextProfile(GLUT_CORE_PROFILE);
        glutCreateWindow(argv[0]);
    
        glutDisplayFunc(display);
        glutKeyboardFunc(keypress);
    
        glewExperimental = GL_TRUE;
        if (glewInit()) {
            cerr << "Unable to initialize glew, exiting " << endl;
            exit (-1);
        }
    
        setup();
    
        glutMainLoop();
    
        return 0;
    }
           

    • Some change in style, but nothing new here either.
• We now need to create the two shaders
• The vertex shader.
  • Create the file triangle.vert

  • attribute vec4 vPosition;
    
    varying vec4 color;
    
    void main() {
       gl_Position = vPosition;
       color = vec4(0.0, 1.0, 0.0, 1.0);
    }
    	

    • We may change the extension to .glsl later
    • This is written in a very c like language
    • We will discuss this language in some detail.
    • For now
    • Declare an attribute, vPosition
      • of type vec4
    • Declare a variable color
      • Of type vec4 again.
      • This will be shared across the shaders.
    • The main routine
      • Copies the vPosition variable to the gl_Position variable where it will be used to draw.
      • Later we will apply transformation matrices at this point
      • And assigns a value to color, for the fragment shader
• The fragment shader.
  • Create the file triangle.frag

  • varying vec4 color;
    
    void main() {
        gl_FragColor = color;
    }
    
    	

    • This is the shader which will do fragment color.
    • The variable color comes from the vertex shader.
    • And all we do is make an assignment to gl_FragColor
    • Later we will write a full color model to go here.
• you should now be able to compile and run this program.

• All files for this section
  • Makefile
  • triangles.C
  • triangles.frag
  • triangles.vert