uniform float real;

uniform float w;

uniform float imag;

uniform float h;

varying float xpos;

varying float ypos;

void main(void)

{

xpos = clamp(gl_Vertex.x, 0.0,1.0)*w+real;

ypos = clamp(gl_Vertex.y, 0.0,1.0)*h+imag;

gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;

}

varying float xpos;

varying float ypos;

varying float zpos;

void main (void)

{

float iter = 0.0;

float max_square = 3.0;

float square = 0.0;

float r = 0.0;

float i = 0.0;

float rt = 0.0;

float it = 0.0;

while(iter < 1.0 && square < max_square)

{

rt = (r*r) - (i*i) + xpos;

it = (2.0 * r * i) + ypos;

r = rt;

i = it;

square = (r*r)+(i*i);

iter += 0.005;

}

gl_FragColor = vec4 (iter, iter, sin(iter*2.00), 1.0);

}

"""Wrapper to create opengl 2.0 shader programms"""

def __init__(self, vertex_source, fragment_source):

self.program = gl.glCreateProgram()

self.vertex_shader = self.create_shader(vertex_source,

gl.GL_VERTEX_SHADER)

self.fragment_shader = self.create_shader(fragment_source,

gl.GL_FRAGMENT_SHADER)

gl.glAttachShader(self.program, self.vertex_shader)

gl.glAttachShader(self.program, self.fragment_shader)

gl.glLinkProgram(self.program)

message = self.get_program_log(self.program)

if message:

raise ShaderException(message)

def create_shader(self, source, shadertype):

# get a char[]

sbuffer = c.create_string_buffer(source)

# get a char **

pointer = c.cast(c.pointer(c.pointer(sbuffer)),

c.POINTER(c.POINTER(c.c_char)))

# a long * NULL pointer

nulll = c.POINTER(c.c_long)()

shader = gl.glCreateShader(shadertype)

gl.glShaderSource(shader, 1, pointer, None)

gl.glCompileShader(shader)

message = self.get_shader_log(shader)

if message:

raise ShaderException(message)

return shader

def set_uniform_f(self, name, value):

location = gl.glGetUniformLocation(self.program, name)

gl.glUniform1f(location, value)

def __setitem__(self, name, value):

"""pass a variable to the shader"""

if isinstance(value, float):

self.set_uniform_f(name, value)

else:

raise TypeError("Only floats are supported so far")

def use(self):

gl.glUseProgram(self.program)

def stop(self):

gl.glUseProgram(0)

def get_shader_log(self, shader):

return self.get_log(shader, gl.glGetShaderInfoLog)

def get_program_log(self, shader):

return self.get_log(shader, gl.glGetProgramInfoLog)

def get_log(self, obj, func):

log_buffer = c.create_string_buffer(4096)

buffer_pointer = c.cast(c.pointer(log_buffer), c.POINTER(c.c_char))

written = c.c_int()

func(obj, 4096, c.pointer(written), buffer_pointer)

def __init__(self):

pyglet.window.Window.__init__(self, width=640, height=480,

resizable=True)

self.fps = pyglet.clock.ClockDisplay()

self.shader = Shader(vertex_shader, fragment_shader)

self.real = -2.0

self.w = 3.0

self.imag = -1.0

self.h = 2.0

self.show_fps = False

def on_key_press(self, symbol, modifiers):

if symbol == key.ESCAPE:

self.has_exit = True

elif symbol == key.F:

self.set_fullscreen(not self.fullscreen)

elif symbol == key.F1:

self.show_fps = not self.show_fps

elif symbol == key.F2:

pyglet.image.get_buffer_manager().get_color_buffer().save('screenshot.png')

def on_mouse_drag(self, x, y, dx, dy, buttons, modifiers):

self.real -= self.w / self.width * dx

self.imag -= self.h / self.height * dy

def on_mouse_scroll(self, x, y, scroll_x, scroll_y):

if scroll_y > 0:

self.real += (float(x) / self.width * self.w) - self.w * 0.25

self.w *= 0.5

self.imag += (float(y) / self.height * self.h) - self.h * 0.25

self.h *= 0.5

else:

self.real += (float(x) / self.width * self.w) - self.w

self.w *= 2.0

self.imag += (float(y) / self.height * self.h) - self.h

self.h *= 2.0

def on_resize(self, width, height):

ratio = float(width) / height

self.w = ratio * self.h

pyglet.window.Window.on_resize(self, width, height)

def run(self):

while not self.has_exit:

pyglet.clock.tick()

self.dispatch_events()

gl.glClear(gl.GL_COLOR_BUFFER_BIT)

gl.glLoadIdentity()

self.shader.use()

self.shader["real"] = self.real

self.shader["w"] = self.w

self.shader["imag"] = self.imag

self.shader["h"] = self.h

gl.glBegin(gl.GL_QUADS)

gl.glVertex3f(0.0, 0.0, 0.0)

gl.glVertex3f(0.0, self.height, 0.0)

gl.glVertex3f(self.width, self.height, 0.0)

gl.glVertex3f(self.width, 0.0, 0.0)

gl.glEnd()

self.shader.stop()

if self.show_fps:

self.fps.draw()