tessellation shaders

#!/usr/bin/python
import sys
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *
from OpenGL.arrays import vbo
from numpy import *

vertex_src = r"""
void main()
{
    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
    gl_FrontColor = vec4(0.0, 1.0, 0.0, 1.0);
}
"""

fragment_src = r"""
void main()
{
    gl_FragColor = gl_Color;
}
"""

tess_ctrl_src = r"""
#version 410 core

// define the number of CPs in the output patch
layout (vertices = 3) out;

void main()
{
    // here the LOD is constant
    // see: http://i.stack.imgur.com/p68tW.png

    //if (gl_InvocationID == 0) {
    // LOD of the mid of the triangle
    gl_TessLevelInner[0] = 3;

    // LOD can be different for every point of the triangle
    gl_TessLevelOuter[0] = 3;
    gl_TessLevelOuter[1] = 3;
    gl_TessLevelOuter[2] = 3;
   //}
   gl_out[gl_InvocationID].gl_FrontColor = gl_in[gl_InvocationID].gl_FrontColor;
   gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;

}
"""

tess_eval_src = r"""
#version 410 core

layout(triangles, equal_spacing, ccw) in;

void main()
{
        gl_FrontColor =
        (gl_TessCoord.x * gl_in[0].gl_FrontColor) +
            (gl_TessCoord.y * gl_in[1].gl_FrontColor) +
            (gl_TessCoord.z * gl_in[2].gl_FrontColor);
    gl_Position =
        (gl_TessCoord.x * gl_in[0].gl_Position) +
            (gl_TessCoord.y * gl_in[1].gl_Position) +
            (gl_TessCoord.z * gl_in[2].gl_Position);
}
"""

class Triangle:

    def __init__(self):
        self.vbo = vbo.VBO(
          array([
              [ -0.8, -0.8, 0.0],
              [ +0.8, -0.8, 0.0],
              [ +0.0, +0.8, 0.0],
               ],'f')
          )
        self.vbo.bind()

    def draw(self):
        glEnableClientState(GL_VERTEX_ARRAY)
        glVertexPointer(3, GL_FLOAT, 12, self.vbo )

        glPatchParameteri(GL_PATCH_VERTICES, 3)
        glDrawArrays(GL_PATCHES, 0, len(self.vbo))

        glDisableClientState(GL_VERTEX_ARRAY)

class Application(object):
    def shader(self, type, src):
        shader = glCreateShader(type)
        glShaderSource(shader, src)
        glCompileShader(shader)
        if not glGetShaderiv(shader, GL_COMPILE_STATUS):
            raise RuntimeError(glGetShaderInfoLog(shader))
        return shader

    def make_program(self, shaders):
        program = glCreateProgram()
        for ty, src in shaders:
            compiled = self.shader(ty, src)
            glAttachShader(program, compiled)

        glLinkProgram(program)
        if not glGetProgramiv(program, GL_LINK_STATUS):
            raise RuntimeError(glGetProgramInfoLog(program))

        return program

    def draw(self):
        glClearColor(0.5, 0.5, 1.0, 1)
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()
        glTranslate(0.0, 0.0, -1.0)

        glUseProgram(self.program)
        self.triangle.draw()

        glutSwapBuffers()

    def resize(self, w, h):
        if h == 0:
            h = 1

        self.w = w
        self.h = h

        glViewport(0, 0, w, h)

        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        gluPerspective(90.0, float(w)/float(h), 0.1, 100.0)

    def main(self):
        glutInit(*sys.argv)

        glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH)
        glutInitWindowSize(640, 512)

        glutCreateWindow("tessellation")

        glutDisplayFunc(self.draw)
        glutReshapeFunc(self.resize)

        # create shader
        self.program = self.make_program(
            [ (GL_VERTEX_SHADER, vertex_src)
            , (GL_FRAGMENT_SHADER, fragment_src)
            , (GL_TESS_CONTROL_SHADER, tess_ctrl_src)
            , (GL_TESS_EVALUATION_SHADER, tess_eval_src)
            ])
        # create triangle
        self.triangle = Triangle()

        glutMainLoop()

if __name__ == '__main__':
    Application().main()