PyOpenGL Geometry Shaders - Python and OpenGL Geometry Shader

Geometry Shaders using PyOpenGL - Implementation

Extending our shader from a previous post, Using GLSL in Python PyOpenGL we can simply add geometry shaders if your video card supports such a beast.

Geometry Shader Class in Python

The following is a shader class written in Python. Its based on our previous shader class except weve made some additions to support Geometry Shaders. We will start with the includes

from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GL.ARB.framebuffer_object import *
from OpenGL.GL.EXT.framebuffer_object import *
from OpenGL.GL.ARB.vertex_buffer_object import *
from OpenGL.GL.ARB.geometry_shader4 import *
from OpenGL.GL.EXT.geometry_shader4 import *

Not sure how many of these are actually used in this class, but they are there in case. The file contains other opengl related classes so they are there. Next I will show the class itself

class shader(node) :
 def __init__(self, filename):
  node.__init__(self)
  self.filename = filename
  self.load()
  
 def load(self, debug=False):
  fh = open(self.filename)  
  self.source = {'vertex': '', 'fragment':'', 'geometry':''}
  write = None
  for line in fh :
   if line == '[[vertex-program]]\n' : 
    write = 'vertex'
   elif line == '[[fragment-program]]\n' : 
    write = 'fragment'
   elif line == '[[geometry-program]]\n' : 
    write = 'geometry'
   else :
    self.source[write] += line
    
  self.draw = self.init
  if debug :
   print self.source['vertex']
   print self.source['fragment']
   print self.source['geometry']
 
    

 def init(self):
  ##compile and link shader
  self.vs = self.fs = self.gs = 0

  self.vs = glCreateShader(GL_VERTEX_SHADER)
  self.fs = glCreateShader(GL_FRAGMENT_SHADER)
  self.gs = glCreateShader(GL_GEOMETRY_SHADER_EXT)

  glShaderSource(self.vs, self.source['vertex'])
  glShaderSource(self.fs, self.source['fragment'])
  glShaderSource(self.gs, self.source['geometry'])

  glCompileShader(self.vs)
  log = glGetShaderInfoLog(self.vs)
  if log: print 'Vertex Shader: ', log

  glCompileShader(self.gs)
  log = glGetShaderInfoLog(self.gs)
  if log: print 'Geometry Shader: ', log

  glCompileShader(self.fs)
  log = glGetShaderInfoLog(self.fs)
  if log: print 'Fragment Shader: ', log

  self.prog = glCreateProgram()

  glAttachShader(self.prog, self.vs)
  glAttachShader(self.prog, self.fs)
  glAttachShader(self.prog, self.gs)

  glLinkProgram(self.prog)
  
  glUseProgram(self.prog)
  
  self.draw = self.use

 def use(self):
  glUseProgram(self.prog)
  uniform_location = glGetUniformLocation(self.prog, "time")
  glUniform1i(uniform_location, pygame.time.get_ticks())

 def end(self):
  glUseProgram(0)

Explaination of OpenGL Geometry Shader GL_GEOMETRY_SHADER_EXT

First difference is in the shader.load function. We have added code to load the actual source code for the shader. Secondly we create the shader with:

self.gs = glCreateShader(GL_GEOMETRY_SHADER_EXT)

GL_GEOMETRY_SHADER_EXT seems to be the only one defined for me. We contine normally now. The main additions are to the shader source code.

OpenGL Geometry Shader source code

Each section of the code is marked by delimters [[vertex-program]], [[fragment-program]], and [[geometry-program]]. Below is the source code

[[vertex-program]]
uniform int time;

void main(void) {
 gl_TexCoord[0] = gl_MultiTexCoord0;
 gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}

[[geometry-program]]
#version 150
#extension GL_EXT_geometry_shader4 : enable
 
layout(triangles) in;
layout(line_strip, max_vertices = 20) out;

void emit(vec4 vertex) {
 gl_Position = vertex;
 EmitVertex();
}

void main(void) {
 vec4 avg = vec4(0., 0., 0., 0.);
 int i;
 for(i=0; i< gl_VerticesIn; i++){
  avg += gl_PositionIn[i];
 }
 avg /= (gl_VerticesIn * 1.0);
 
 vec4 mid1 = (gl_PositionIn[0] + gl_PositionIn[1]) / 2.0;
 vec4 mid2 = (gl_PositionIn[1] + gl_PositionIn[2]) / 2.0;
 vec4 mid3 = (gl_PositionIn[2] + gl_PositionIn[0]) / 2.0;
 
 emit(gl_PositionIn[0]);
 emit(mid1);
 emit(mid3);
 emit(mid2);
 emit(mid1);
 emit(gl_PositionIn[1]);
 emit(mid2);
 emit(gl_PositionIn[2]);
 emit(mid3);
 emit(gl_PositionIn[0]);
 
 EndPrimitive();
}


[[fragment-program]]
uniform sampler2D texture_0;

void main (void)  {
 vec4 cvec = texture2D(texture_0, gl_TexCoord[0].xy);
 gl_FragColor = cvec;
 gl_FragColor.a = 1.0;
}

Caveats with OpenGL Geometry Program, it always uses triangles

Something that took me awhile to figure out is that the geometry shader always works in triangles. I couldn't figure out why quads was not defined in GLSL. I was using GL_QUADS so I naturally figured it would exist. It does not. Internal OpenGL pipeline converts to triangles here. Maybe this is common knowledge, maybe it is not. Someone can feel free to correct me.

Other interesting things are the extra lines there

#version 150
#extension GL_EXT_geometry_shader4 : enable
 
layout(triangles) in;
layout(line_strip, max_vertices = 20) out;

The top comments are required for me. The first function layout() show the input, triangles as mentioned earlier. The next specifies output, which is line strip. I did this to show the effect of the shader, it will draw line strips instead of triangle_strip which would make more sense in the real world perhaps.