Mandelbrot

# -*- coding: utf-8 -*-
#!/usr/bin/env python
from __future__ import division

from PyQt4 import QtCore, QtGui, QtOpenGL
from PyQt4.QtCore import Qt
import sys

try:
    from OpenGL import GL
    from OpenGL import GLU
except ImportError:
    app = QtGui.QApplication(sys.argv)
    QtGui.QMessageBox.critical(None, "OpenGL hellogl",
            "PyOpenGL must be installed to run this example.")
    sys.exit(1)


class Window(QtGui.QWidget):
    def __init__(self):
        super(Window, self).__init__()

        self.glWidget = GLWidget()
        mainLayout = QtGui.QHBoxLayout()
        mainLayout.addWidget(self.glWidget)
        self.setLayout(mainLayout)

        self.setWindowTitle("Hello GL")

    def wheelEvent(self, event):
        self.glWidget.wheelEvent(event)

    def keyPressEvent(self, event):
        self.glWidget.keyPressEvent(event)

class GLWidget(QtOpenGL.QGLWidget):

    def __init__(self, parent=None):
        super(GLWidget, self).__init__(parent)

        self.lastPos = QtCore.QPoint()
        self.program =  QtOpenGL.QGLShaderProgram()

        self.iterations = 400
        self.radius = 4.0
        self.xpos = -0.5
        self.ypos = 0.0
        self.zoom = 128.0
        self.w = float(self.width())
        self.h = float(self.height())

    def minimumSizeHint(self):
        return QtCore.QSize(50, 50)

    def sizeHint(self):
        return QtCore.QSize(800, 800)

    def setZoom(self, amount):
        self.zoom = amount
        self.iterations += 5
        self.updateGL()

    def initializeGL(self):
        GL.glClearColor(0.25, 0.25, 0.4, 0.0)
        GL.glDisable(GL.GL_DEPTH_TEST)
        GL.glEnable(GL.GL_TEXTURE_2D)
        self.addShaders("Basic.vsh", "FloatMandel.fsh")

    def addShaders(self, vertex_shader_file, fragment_shader_file):
        vertex_shader = QtOpenGL.QGLShader(QtOpenGL.QGLShader.Vertex)
        if not vertex_shader.compileSourceFile(vertex_shader_file):
            print "vertex shader could not be loaded", vertex_shader.log()
        else:
            self.program.addShader(vertex_shader)

        fragment_shader = QtOpenGL.QGLShader(QtOpenGL.QGLShader.Fragment)
        if not fragment_shader.compileSourceFile(fragment_shader_file):
            print "fragment shader could not be loaded", fragment_shader.log()
        else:
            self.program.addShader(fragment_shader)

        self.program.link()
        self.program.bind()

    def paintGL(self):
        self.program.setUniformValue("iterations", self.iterations)
        self.program.setUniformValue("radius", self.zoom)
        self.program.setUniformValue("frame", 0)

        self.program.setUniformValue("f_cx", self.xpos)
        self.program.setUniformValue("f_cy", self.ypos)

        self.program.setUniformValue("f_sx", -self.w/2/self.zoom)
        self.program.setUniformValue("f_sy", -self.h/2/self.zoom)
        self.program.setUniformValue("f_z", 1/self.zoom)


        GL.glBegin(GL.GL_QUADS)
        GL.glNormal3f(0.,0.,1.); GL.glColor3f(1.,0.,0.); GL.glTexCoord2f(0, 0); GL.glVertex3i(0, 0, 0)
        GL.glNormal3f(0.,0.,1.); GL.glColor3f(1.,1.,0.); GL.glTexCoord2f(self.w, 0); GL.glVertex3i(self.w, 0, 0)
        GL.glNormal3f(0.,0.,1.); GL.glColor3f(1.,1.,1.); GL.glTexCoord2f(self.w, self.h); GL.glVertex3i(self.w, self.h, 0)
        GL.glNormal3f(0.,0.,1.); GL.glColor3f(1.,0.,1.); GL.glTexCoord2f(0, self.h); GL.glVertex3i(0, self.h, 0)
        GL.glEnd()





    def resizeGL(self, width, height):
        GL.glViewport(0, 0, width, height)
        GL.glMatrixMode(GL.GL_PROJECTION)
        GL.glLoadIdentity()
        GL.glOrtho(0, width, 0, height, 0, 1)
        GL.glMatrixMode(GL.GL_MODELVIEW)
        GL.glLoadIdentity()

        self.w = width
        self.h = height

    def mousePressEvent(self, event):
        self.lastPos = event.pos()

    def wheelEvent(self, event):
        sens = 1.25
        if event.delta() >= 0:
            self.setZoom(self.zoom*sens)
        else:
            self.setZoom(self.zoom/sens)

    def mouseMoveEvent(self, event):
        pos = event.pos()
        dx = event.x() - self.lastPos.x()
        dy = event.y() - self.lastPos.y()

        self.lastPos = event.pos()

    def keyPressEvent(self, event):
        sensitivity = 0.5
        if event.key() == Qt.Key_W:
            self.eye_translation.z -=sensitivity
        elif event.key() == Qt.Key_S:
            self.eye_translation.z +=sensitivity
        elif event.key() == Qt.Key_A:
            self.eye_translation.x +=sensitivity
        elif event.key() == Qt.Key_D:
            self.eye_translation.x-=sensitivity
        elif event.key() == Qt.Key_Space:
            self.eye_translation.y -= sensitivity
        elif event.key() == Qt.Key_X:
            self.eye_translation.y += sensitivity

        self.updateGL()


if __name__ == '__main__':
    app = QtGui.QApplication(sys.argv)



    window = Window()
    window.show()
    sys.exit(app.exec_())