Re: Difficulty with the shaders tutorial

import os, sys, ctypes
import numpy as np
import OpenGL.GL as gl
import OpenGL.GLUT as glut


class ShaderException(Exception):
    pass

class Shader:
    def __init__(self, vertex_code = None, fragment_code = None):
        self.uniforms = {}
        self.handle = gl.glCreateProgram()
        self.linked = False
        self._build_shader(vertex_code, gl.GL_VERTEX_SHADER)
        self._build_shader(fragment_code, gl.GL_FRAGMENT_SHADER)
        self._link()

    def _build_shader(self, strings, shader_type):
        count = len(strings)
        if count < 1: 
            return
        shader = gl.glCreateShader(shader_type)
        gl.glShaderSource(shader, strings)
        gl.glCompileShader(shader)
        status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
        if not status:
            if shader_type == gl.GL_VERTEX_SHADER:
                raise (ShaderException, 
                       'Vertex compilation: ' + gl.glGetShaderInfoLog(shader))
            elif shader_type == gl.GL_FRAGMENT_SHADER:
                raise (ShaderException,
                       'Fragment compilation:' + gl.glGetShaderInfoLog(shader))
            else:
                raise (ShaderException,
                           gl.glGetShaderInfoLog(shader))
        else:
            gl.glAttachShader(self.handle, shader)

    def _link(self):
        gl.glLinkProgram(self.handle)
        temp = ctypes.c_int(0)
        gl.glGetProgramiv(self.handle, gl.GL_LINK_STATUS, ctypes.byref(temp))
        if not temp:
            gl.glGetProgramiv(self.handle,
                              gl.GL_INFO_LOG_LENGTH, ctypes.byref(temp))
            log = gl.glGetProgramInfoLog(self.handle)
            raise(ShaderException, 'Linking: '+ log)
        else:
            self.linked = True

    def bind(self):
        gl.glUseProgram(self.handle)

    def unbind(self):
        gl.glUseProgram(0)

    def uniformf(self, name, *vals):
        loc = self.uniforms.get(name, gl.glGetUniformLocation(self.handle,name))
        self.uniforms[name] = loc
        if len(vals) in range(1, 5):
            { 1 : gl.glUniform1f,
              2 : gl.glUniform2f,
              3 : gl.glUniform3f,
              4 : gl.glUniform4f
            }[len(vals)](loc, *vals)

    def uniformi(self, name, *vals):
        loc = self.uniforms.get(name, gl.glGetUniformLocation(self.handle,name))
        self.uniforms[name] = loc
        if len(vals) in range(1, 5):
            { 1 : gl.glUniform1i,
              2 : gl.glUniform2i,
              3 : gl.glUniform3i,
              4 : gl.glUniform4i
            }[len(vals)](loc, *vals)

    def uniform_matrixf(self, name, mat):
        loc = self.uniforms.get(name, gl.glGetUniformLocation(self.handle,name))
        self.uniforms[name] = loc
        gl.glUniformMatrix4fv(loc, 1, False, (ctypes.c_float * 16)(*mat))



def display():
    gl.glClearColor(1,1,1,1)
    gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)

    gl.glEnable(gl.GL_BLEND)
    gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
    gl.glColor(1,1,1,1)

    gl.glEnable( gl.GL_TEXTURE_1D )
    gl.glActiveTexture( gl.GL_TEXTURE1 )
    gl.glBindTexture( gl.GL_TEXTURE_1D, lut_id)

    gl.glEnable( gl.GL_TEXTURE_2D )
    gl.glActiveTexture( gl.GL_TEXTURE0 )
    gl.glBindTexture( gl.GL_TEXTURE_2D, image_id)

    # gl.glTexSubImage2D (gl.GL_TEXTURE_2D, 0, 0, 0,
    #                     512, 512, gl.GL_ALPHA, gl.GL_FLOAT, image)

    shader.bind()
    shader.uniformi('texture', 0)
    shader.uniformi('lut', 1)
    gl.glBegin(gl.GL_QUADS)
    gl.glTexCoord2f(0, 1), gl.glVertex2i(0,   0)
    gl.glTexCoord2f(0, 0), gl.glVertex2i(0,   512)
    gl.glTexCoord2f(1, 0), gl.glVertex2i(512, 512)
    gl.glTexCoord2f(1, 1), gl.glVertex2i(512, 0)
    gl.glEnd()
    shader.unbind()

    glut.glutSwapBuffers()

def reshape(width,height):
    gl.glViewport(0, 0, width, height)
    gl.glMatrixMode(gl.GL_PROJECTION)
    gl.glLoadIdentity()
    gl.glOrtho(0, width, 0, height, -1, 1)
    gl.glMatrixMode(gl.GL_MODELVIEW)

def keyboard( key, x, y ):
    if key == '\033':
        sys.exit( )


if __name__ == '__main__':
    glut.glutInit(sys.argv)
    glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH)
    glut.glutCreateWindow('glut-colorizer')
    glut.glutReshapeWindow(512,512)
    glut.glutDisplayFunc(display)
    glut.glutReshapeFunc(reshape)
    glut.glutKeyboardFunc(keyboard )

    fragment = """
        uniform sampler2D texture; 
        uniform sampler1D lut; 
        void main() 
        { 
            vec2 uv = gl_TexCoord[0].xy; 
            vec4 color = texture2D(texture, uv); 
            gl_FragColor = texture1D(lut,color.a); 
        }"""
    vertex = """
        void main()
        {
            gl_FrontColor = gl_Color;
            gl_TexCoord[0].xy = gl_MultiTexCoord0.xy;
            gl_Position = gl_ModelViewProjectionMatrix*gl_Vertex;
        }"""

    shader = Shader(vertex,fragment)

    # Image to be displayed
    image = np.random.uniform(0,1,(64,64)).astype(np.float32)

    image_id = gl.glGenTextures(1)
    gl.glEnable(gl.GL_TEXTURE_2D)
    gl.glBindTexture(gl.GL_TEXTURE_2D, image_id)
    gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_ALPHA32F_ARB, 64, 64, 0,
                    gl.GL_ALPHA, gl.GL_FLOAT, image)
    gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
    gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST)

    # Color lookup table (R,G,B)
    lut = np.zeros((512,3)).astype(np.float32)
    lut[:,0] = np.linspace(0,1,512)
    lut[:,1] = np.linspace(1,0,512)
    lut[:,2] = .5
    lut_id = gl.glGenTextures(1)
    gl.glEnable(gl.GL_TEXTURE_1D)
    gl.glBindTexture(gl.GL_TEXTURE_1D, lut_id)
    gl.glTexImage1D(gl.GL_TEXTURE_1D, 0, gl.GL_RGB, 512, 0,
                    gl.GL_RGB, gl.GL_FLOAT, lut)
    gl.glTexParameterf(gl.GL_TEXTURE_1D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
    gl.glTexParameterf(gl.GL_TEXTURE_1D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST)

    glut.glutMainLoop()