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.
