def __init__(self,
scene,
updateFpsDisplay,
renderSettings=Rendersettings(),
parent=None):
View.__init__(self, scene)
QOpenGLWidget.__init__(self, parent)
self.renderImage = QImage()
self.renderSettings = renderSettings
self.updateFpsDisplay = updateFpsDisplay
self.shaderProgram = QOpenGLShaderProgram()
self.viewPortShaderProgram = QOpenGLShaderProgram()
self.lightShaderProgram = QOpenGLShaderProgram()
self.eyeLoc = QVector3D(0.0, 0.0, 5.0)
self.pressLoc = QVector2D()
self.isRendering = False
self.viewportPlane = ViewportPlane()
self.viewportTexture = None
self.timer = QTimer()
self.timer.setSingleShot(True)
self.timer.timeout.connect(self.checkRender)
self.scene.registerView(self, [
UpdateType.MATERIAL_CHANGE, UpdateType.MATERIAL_CREATE,
UpdateType.MATERIAL_DELETE, UpdateType.OBJECT_CREATE,
UpdateType.OBJECT_DELETE, UpdateType.OBJECT_TRANSFORM,
UpdateType.CAMERA_CHANGE, UpdateType.LIGHT_CHANGE,
UpdateType.SCENE_LOAD
])
self.timestamps = None
self.fpsWindow = 10
self.renderer = None
self.renderStartTime = None
def __init__(self, parent=None):
QOpenGLWidget.__init__(self, parent)
QOpenGLFunctions.__init__(self)
self.setMinimumSize(32, 32)
self.info = ""
self._supported_images = [
"TGA", "PNG", "JPG", "JPEG", "TIF", "TIFF", "BMP", "DDS"
]
# indices
indices = [0, 1, 3, 1, 2, 3]
self._indices = array('I', indices)
# vertices
# 3 position | 2 texture coord
vertex = [
1.0,
1.0,
0.0,
1.0,
1.0, # top right
1.0,
-1.0,
0.0,
1.0,
0.0, # bottom right
-1.0,
-1.0,
0.0,
0.0,
0.0, # bottom left
-1.0,
1.0,
0.0,
0.0,
1.0 # top left
]
self._vertex = array('f', vertex)
# opengl data related
self._program = QOpenGLShaderProgram()
self._program_bg = QOpenGLShaderProgram()
self._vao = QOpenGLVertexArrayObject()
self._vbo = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
self._texture = None
self._texture_size = (1, 1)
self._location = ()
self._colors_default = (QColor.fromRgbF(0.65, 0.65, 0.65, 1.0),
QColor.fromRgbF(0.90, 0.90, 0.90, 1.0))
self._u_colors = self._colors_default
self._height = QVector4D(0, self.height(), 0, 0)
self._u_channels = QMatrix4x4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0,
0, 0)
def __init__(self, fmt: QSurfaceFormat, parent=None, *args, **kwargs):
QOpenGLWidget.__init__(self, parent, *args, **kwargs)
QOpenGLExtraFunctions.__init__(self, *args, **kwargs)
self.width, self.height = 1280, 720
self.program = QOpenGLShaderProgram()
self.vbo = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
self.ebo = QOpenGLBuffer(QOpenGLBuffer.IndexBuffer)
self.vao = QOpenGLVertexArrayObject()
self.model_loc = None
self.projection_loc = None
self.camera_loc = None
self.attrib_loc = None
self.shape = Cube()
self.models = []
self.model = None
self.projection = None
self.camera = Camera()
self.last_pos = QPoint(self.width / 2.0, self.height / 2.0)
self.setFormat(fmt)
self.context = QOpenGLContext(self)
if not self.context.create():
raise RuntimeError("Unable to create GL context")
self.timer = QTimer()
self.timer.timeout.connect(self.update)
self.timer.start(1000.0/FPS)
def __init__(self, parent=None):
QOpenGLWidget.__init__(self, parent)
QOpenGLFunctions.__init__(self)
self.core = "--coreprofile" in QCoreApplication.arguments()
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.lastPos = 0
self.logo = Logo()
self.vao = QOpenGLVertexArrayObject()
self.logoVbo = QOpenGLBuffer()
self.program = QOpenGLShaderProgram()
self.projMatrixLoc = 0
self.mvMatrixLoc = 0
self.normalMatrixLoc = 0
self.lightPosLoc = 0
self.proj = QMatrix4x4()
self.camera = QMatrix4x4()
self.world = QMatrix4x4()
self.transparent = "--transparent" in QCoreApplication.arguments()
if self.transparent:
fmt = self.format()
fmt.setAlphaBufferSize(8)
self.setFormat(fmt)
def initialize_shader_program(self):
self.vertex_shader = """
#version 330 core
layout (location = 0) in vec3 in_coords;
layout (location = 1) in vec3 in_color;
out vec3 out_color;
void main()
{
gl_Position = vec4(in_coords, 1.0);
gl_PointSize = 200.0;
out_color = in_color;
}
"""
self.fragment_shader = """
#version 330 core
in vec3 out_color;
out vec4 frag_color;
void main()
{
frag_color = vec4(out_color, 1.0);
}
"""
self.arg_pos = {'in_coords': 0, 'in_color': 1, 'out_color': 0}
self.program = QOpenGLShaderProgram(parent=self.parent())
self.program.addCacheableShaderFromSourceCode(QOpenGLShader.Vertex,
self.vertex_shader)
self.program.addCacheableShaderFromSourceCode(QOpenGLShader.Fragment,
self.fragment_shader)
self.program.link()
def initializeGL(self):
"Initialize opengl "
print('gl initial')
print(self.getGlInfo())
# create context and make it current
self.context.create()
self.context.aboutToBeDestroyed.connect(self.cleanUpGl)
# initialize functions
funcs = self.context.functions()
funcs.initializeOpenGLFunctions()
funcs.glClearColor(1, 0, 1, 1)
# shader
shaderName = "texture"
vshader = self.loadVertexShader(shaderName)
fshader = self.loadFragmentShader(shaderName)
# create shader program
self.program = QOpenGLShaderProgram(self.context)
self.program.addShader(vshader)
self.program.addShader(fshader)
# bind attribute location
self.program.bindAttributeLocation("aPos", 0)
self.program.bindAttributeLocation("aTexCoord", 1)
# link shader program
isLinked = self.program.link()
print("shader program is linked: ", isLinked)
# activate shader program to set uniform an attribute values
self.program.bind()
self.program.setUniformValue('myTexture', 0)
# vbo
isVbo = self.vbo.create()
isVboBound = self.vbo.bind()
floatSize = ctypes.sizeof(ctypes.c_float)
# allocate vbo
self.vbo.allocate(self.vertexData.tobytes(),
floatSize * self.vertexData.size)
# texture new school
self.texture = QOpenGLTexture(QOpenGLTexture.Target2D)
self.texture.create()
# new school
self.texture.bind()
self.texture.setData(self.image)
self.texture.setMinMagFilters(QOpenGLTexture.Linear,
QOpenGLTexture.Linear)
self.texture.setWrapMode(QOpenGLTexture.DirectionS,
QOpenGLTexture.Repeat)
self.texture.setWrapMode(QOpenGLTexture.DirectionT,
QOpenGLTexture.Repeat)
def __init__(self, parent=None):
QOpenGLWidget.__init__(self, parent)
# shaders etc
triangleTutoDir = os.path.dirname(__file__)
trianglePardir = os.path.join(triangleTutoDir, os.pardir)
mediaDir = os.path.join(trianglePardir, "media")
shaderDir = os.path.join(mediaDir, "shaders")
availableShaders = ["triangle", "triangle2"]
self.shaders = {
name: {
"fragment": os.path.join(shaderDir, name + ".frag"),
"vertex": os.path.join(shaderDir, name + ".vert")
} for name in availableShaders
}
self.core = "--coreprofile" in QCoreApplication.arguments()
# opengl data related
self.context = QOpenGLContext()
self.vao1 = QOpenGLVertexArrayObject()
self.vbo1 = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
self.vao2 = QOpenGLVertexArrayObject()
self.vbo2 = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
self.program1 = QOpenGLShaderProgram()
self.program2 = QOpenGLShaderProgram()
# some vertex data for corners of triangle
self.vertexData1 = np.array(
[0.9, 0.9, 0.0, # x, y, z
0.9, 0.7, 0.0, # x, y, z
0.7, 0.9, 0.0], # x, y, z
dtype=ctypes.c_float
)
self.vertexData2 = np.array(
[-0.9, -0.9, 0.0, # x, y, z
-0.9, -0.7, 0.0, # x, y, z
-0.7, -0.9, 0.0], # x, y, z
dtype=ctypes.c_float
)
# triangle color
self.triangleColor1 = QVector4D(1.0, 0.0, 0.0, 0.0) # yellow triangle
self.triangleColor2 = QVector4D(
0.0, 0.0, 0.5, 0.0) # not yellow triangle
def paint(self):
try:
print("drawing")
if self._shader_program is None:
self._shader_program = QOpenGLShaderProgram()
self._shader_program.addShaderFromSourceCode(
QOpenGLShader.Vertex, "attribute highp vec4 vertices;"
"varying highp vec2 coords;"
"void main() {"
" gl_Position = vertices;"
" coords = vertices.xy;"
"}")
self._shader_program.addShaderFromSourceCode(
QOpenGLShader.Fragment, "uniform lowp float t;"
"varying highp vec2 coords;"
"void main() {"
" lowp float i = 1. - (pow(abs(coords.x), 4.) + pow(abs(coords.y), 4.));"
" i = smoothstep(t - 0.8, t + 0.8, i);"
" i = floor(i * 20.) / 20.;"
" gl_FragColor = vec4(coords * .5 + .5, i, i);"
"}")
self._shader_program.bindAttributeLocation('vertices', 0)
self._shader_program.link()
self._shader_program.bind()
self._shader_program.enableAttributeArray(0)
values = np.array([(-1.0, -1.0), (1.0, -1.0), (-1.0, 1.0),
(1.0, 1.0)],
dtype=ctypes.c_float)
self._shader_program.setAttributeArray(0, GL_FLOAT,
values.tobytes(), 2)
self._shader_program.setUniformValue1f('t', self._t)
gl = self._window.openglContext().functions()
gl.glViewport(0, 0, self._viewport_size.width(),
self._viewport_size.height())
gl.glDisable(GL_DEPTH_TEST)
gl.glClearColor(0.1, 0.1, 0.1, 1)
gl.glClear(GL_COLOR_BUFFER_BIT)
gl.glEnable(GL_BLEND)
gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE)
gl.glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)
self._shader_program.disableAttributeArray(0)
self._shader_program.release()
self._window.resetOpenGLState()
except Exception as e:
print(e)
def initialize_shader_program(self):
self.vertex_shader = """
#version 330 core
layout (location = 0) in vec3 in_coords;
layout (location = 1) in vec3 in_color;
layout (location = 2) in vec2 in_tex_coords;
uniform mat4 transform;
out vec3 out_color;
out vec2 out_tex_coords;
void main()
{
gl_Position = transform * vec4(in_coords, 1.0);
out_color = in_color;
out_tex_coords = vec2(in_tex_coords.x, in_tex_coords.y);
}
"""
self.fragment_shader = """
#version 330 core
in vec3 out_color;
in vec2 out_tex_coords;
out vec4 frag_color;
uniform sampler2D texture0;
uniform sampler2D texture1;
void main()
{
if (out_tex_coords.x > 0.5)
frag_color = texture(texture0, out_tex_coords);
else
frag_color = texture(texture1, out_tex_coords);
//frag_color = mix(texture(texture0, out_tex_coords),
// texture(texture1, out_tex_coords), 0.5)
// * vec4(out_color, 1.0);
}
"""
self.arg_pos = {
'in_coords': 0,
'in_color': 1,
'in_tex_coords': 2,
'out_color': 0
}
self.program = QOpenGLShaderProgram(parent=self.parent())
self.program.addCacheableShaderFromSourceCode(QOpenGLShader.Vertex,
self.vertex_shader)
self.program.addCacheableShaderFromSourceCode(QOpenGLShader.Fragment,
self.fragment_shader)
self.program.link()
self.program.bind()
def __init__(self, parent=None):
"Constructor"
QOpenGLWidget.__init__(self, parent)
tutoTutoDir = os.path.dirname(__file__)
tutoPardir = os.path.join(tutoTutoDir, os.pardir)
tutoPardir = os.path.realpath(tutoPardir)
mediaDir = os.path.join(tutoPardir, "media")
shaderDir = os.path.join(mediaDir, "shaders")
#
availableShaders = ["rectangle", "triangle"]
self.shaders = {
name: {
"fragment": os.path.join(shaderDir, name + ".frag"),
"vertex": os.path.join(shaderDir, name + ".vert")
}
for name in availableShaders
}
self.core = "--coreprofile" in QCoreApplication.arguments()
# opengl data related
self.context = QOpenGLContext()
self.program = QOpenGLShaderProgram()
self.vao = QOpenGLVertexArrayObject()
self.vbo = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
self.indices = np.array(
[
0,
1,
3, # first triangle
1,
2,
3 # second triangle
],
dtype=ctypes.c_uint)
# vertex data of the panel that would hold the image
self.vertexData = np.array(
[
# viewport position || colors || texture coords
0.5,
0.5,
0.0, # top right
0.5,
-0.5,
0.0, # bottom right
-0.5,
-0.5,
0.0, # bottom left
-0.5,
0.5,
0.0, # top left
],
dtype=ctypes.c_float)
self.rectColor = QVector4D(0.0, 1.0, 1.0, 0.0)
def createimpl(self, gl):
if not self.filename:
raise Exception("missing program filename")
self.program = QOpenGLShaderProgram()
self.mtime = max(
os.stat(self.path / ('%s.vs' % self.filename)).st_mtime,
os.stat(self.path / ('%s.fs' % self.filename)).st_mtime)
with io.open(self.path / ('%s.vs' % self.filename), 'r') as f:
self.program.addShaderFromSourceCode(QOpenGLShader.Vertex,
f.read())
with io.open(self.path / ('%s.fs' % self.filename), 'r') as f:
self.program.addShaderFromSourceCode(QOpenGLShader.Fragment,
f.read())
if not self.program.link():
raise Exception("invalid program")
def initGl(self):
self.program = QOpenGLShaderProgram(self)
self.vao = QOpenGLVertexArrayObject()
self.vbo = QOpenGLBuffer()
format = self.context.format()
useNewStyleShader = format.profile() == QSurfaceFormat.CoreProfile
# Try to handle 3.0 & 3.1 that do not have the core/compatibility profile
# concept 3.2+ has. This may still fail since version 150 (3.2) is
# specified in the sources but it's worth a try.
if (format.renderableType() == QSurfaceFormat.OpenGL
and format.majorVersion() == 3 and format.minorVersion() <= 1):
useNewStyleShader = not format.testOption(
QSurfaceFormat.DeprecatedFunctions)
vertexShader = vertexShaderSource if useNewStyleShader else vertexShaderSource110
fragmentShader = fragmentShaderSource if useNewStyleShader else fragmentShaderSource110
if not self.program.addShaderFromSourceCode(QOpenGLShader.Vertex,
vertexShader):
raise Exception("Vertex shader could not be added: {} ({})".format(
self.program.log(), vertexShader))
if not self.program.addShaderFromSourceCode(QOpenGLShader.Fragment,
fragmentShader):
raise Exception(
"Fragment shader could not be added: {} ({})".format(
self.program.log(), fragmentShader))
if not self.program.link():
raise Exception("Could not link shaders: {}".format(
self.program.log()))
self.posAttr = self.program.attributeLocation("posAttr")
self.colAttr = self.program.attributeLocation("colAttr")
self.matrixUniform = self.program.uniformLocation("matrix")
self.vbo.create()
self.vbo.bind()
self.verticesData = vertices.tobytes()
self.colorsData = colors.tobytes()
verticesSize = 4 * vertices.size
colorsSize = 4 * colors.size
self.vbo.allocate(VoidPtr(self.verticesData),
verticesSize + colorsSize)
self.vbo.write(verticesSize, VoidPtr(self.colorsData), colorsSize)
self.vbo.release()
vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao)
if self.vao.isCreated(): # have VAO support, use it
self.setupVertexAttribs()
def initializeGL(self):
self.context().aboutToBeDestroyed.connect(self.cleanup)
self.initializeOpenGLFunctions()
self.glClearColor(0, 0, 0, 1)
self.program = QOpenGLShaderProgram()
if self.core:
self.vertexShader = self.vertexShaderSourceCore()
self.fragmentShader = self.fragmentShaderSourceCore()
else:
self.vertexShader = self.vertexShaderSource()
self.fragmentShader = self.fragmentShaderSource()
self.program.addShaderFromSourceCode(QOpenGLShader.Vertex,
self.vertexShader)
self.program.addShaderFromSourceCode(QOpenGLShader.Fragment,
self.fragmentShader)
self.program.bindAttributeLocation("vertex", 0)
self.program.bindAttributeLocation("normal", 1)
self.program.link()
self.program.bind()
self.projMatrixLoc = self.program.uniformLocation("projMatrix")
self.mvMatrixLoc = self.program.uniformLocation("mvMatrix")
self.normalMatrixLoc = self.program.uniformLocation("normalMatrix")
self.lightPosLoc = self.program.uniformLocation("lightPos")
self.vao.create()
vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao)
self.logoVbo.create()
self.logoVbo.bind()
float_size = ctypes.sizeof(ctypes.c_float)
self.logoVbo.allocate(self.logo.constData(),
self.logo.count() * float_size)
self.setupVertexAttribs()
self.camera.setToIdentity()
self.camera.translate(0, 0, -1)
self.program.setUniformValue(self.lightPosLoc, QVector3D(0, 0, 70))
self.program.release()
vaoBinder = None
def initializeGL(self):
print('gl initial')
print(self.getGlInfo())
# create context and make it current
self.context.create()
self.context.aboutToBeDestroyed.connect(self.cleanUpGl)
# initialize functions
funcs = self.context.functions()
funcs.initializeOpenGLFunctions()
funcs.glClearColor(0.0, 0.4, 0.4, 0)
funcs.glEnable(pygl.GL_DEPTH_TEST)
funcs.glEnable(pygl.GL_TEXTURE_2D)
# create uniform values for shaders
# deal with shaders
# cube shader
self.program = QOpenGLShaderProgram(self.context)
vshader = self.loadVertexShader("cube")
fshader = self.loadFragmentShader("cube")
self.program.addShader(vshader) # adding vertex shader
self.program.addShader(fshader) # adding fragment shader
self.program.bindAttributeLocation("aPos", 0)
self.program.bindAttributeLocation("aTexCoord", 1)
isLinked = self.program.link()
print("cube shader program is linked: ", isLinked)
# bind the program
self.program.bind()
self.program.setUniformValue('myTexture1', self.texUnit1)
self.program.setUniformValue('myTexture2', self.texUnit2)
#
# deal with vaos and vbo
# vbo
isVbo = self.vbo.create()
isVboBound = self.vbo.bind()
floatSize = ctypes.sizeof(ctypes.c_float)
# allocate space on vbo buffer
self.vbo.allocate(self.cubeVertices.tobytes(),
floatSize * self.cubeVertices.size)
self.vao.create()
vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao)
funcs.glEnableVertexAttribArray(0) # viewport
funcs.glVertexAttribPointer(0, 3, int(pygl.GL_FLOAT),
int(pygl.GL_FALSE), 5 * floatSize,
VoidPtr(0))
funcs.glEnableVertexAttribArray(1)
funcs.glVertexAttribPointer(1, 2, int(pygl.GL_FLOAT),
int(pygl.GL_FALSE), 5 * floatSize,
VoidPtr(3 * floatSize))
# deal with textures
# first texture
self.texture1 = QOpenGLTexture(QOpenGLTexture.Target2D)
self.texture1.create()
self.texture1.bind(self.texUnit1)
self.texture1.setData(self.image1)
self.texture1.setMinMagFilters(QOpenGLTexture.Nearest,
QOpenGLTexture.Nearest)
self.texture1.setWrapMode(QOpenGLTexture.DirectionS,
QOpenGLTexture.Repeat)
self.texture1.setWrapMode(QOpenGLTexture.DirectionT,
QOpenGLTexture.Repeat)
# second texture
self.texture2 = QOpenGLTexture(QOpenGLTexture.Target2D)
self.texture2.create()
self.texture2.bind(self.texUnit2)
self.texture2.setData(self.image2)
self.texture2.setMinMagFilters(QOpenGLTexture.Linear,
QOpenGLTexture.Linear)
self.texture2.setWrapMode(QOpenGLTexture.DirectionS,
QOpenGLTexture.Repeat)
self.texture2.setWrapMode(QOpenGLTexture.DirectionT,
QOpenGLTexture.Repeat)
self.vbo.release()
vaoBinder = None
print("gl initialized")
def initializeGL(self):
print('gl initial')
print(self.getGlInfo())
# create context and make it current
self.context.create()
self.context.aboutToBeDestroyed.connect(self.cleanUpGl)
# initialize functions
funcs = self.context.functions()
funcs.initializeOpenGLFunctions()
funcs.glClearColor(1, 1, 1, 1)
# deal with shaders
# first shader
shaderName = "triangle"
vshader = self.loadVertexShader(shaderName)
fshader = self.loadFragmentShader(shaderName)
# creating shader program
self.program1 = QOpenGLShaderProgram(self.context)
self.program1.addShader(vshader) # adding vertex shader
self.program1.addShader(fshader) # adding fragment shader
# bind attribute to a location
self.program1.bindAttributeLocation("aPos", 0)
# link shader program1
isLinked = self.program1.link()
print("shader program1 is linked: ", isLinked)
# bind the program1
self.program1.bind()
# specify uniform value
colorLoc = self.program1.uniformLocation("color")
self.program1.setUniformValue(colorLoc,
self.triangleColor1)
# second shader
shaderName = "triangle2"
vshader = self.loadVertexShader(shaderName)
fshader = self.loadFragmentShader(shaderName)
#
self.program2 = QOpenGLShaderProgram(self.context)
self.program2.addShader(vshader) # adding vertex shader
self.program2.addShader(fshader) # adding fragment shader
# bind attribute to a location
self.program2.bindAttributeLocation("aPos", 0)
# link shader program2
isLinked = self.program2.link()
print("shader program2 is linked: ", isLinked)
# bind the program2
self.program2.bind()
# specify uniform value
colorLoc = self.program2.uniformLocation("color")
self.program2.setUniformValue(colorLoc,
self.triangleColor2)
# self.useShader("triangle")
# deal with vao and vbo
# create vao and vbo
# vao
isVao = self.vao1.create()
vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao1)
# vbo
isVbo = self.vbo1.create()
isBound = self.vbo1.bind()
# check if vao and vbo are created
print('vao created: ', isVao)
print('vbo created: ', isVbo)
floatSize = ctypes.sizeof(ctypes.c_float)
# allocate space on buffer
self.vbo1.allocate(self.vertexData1.tobytes(),
floatSize * self.vertexData1.size)
funcs.glEnableVertexAttribArray(0)
nullptr = VoidPtr(0)
funcs.glVertexAttribPointer(0,
3,
int(pygl.GL_FLOAT),
int(pygl.GL_FALSE),
3 * floatSize,
nullptr)
self.vbo1.release()
vaoBinder = None
# second triangle vao vbo
# vao
isVao = self.vao2.create()
vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao2)
# vbo
isVbo = self.vbo2.create()
isBound = self.vbo2.bind()
# check if vao and vbo are created
print('vao created: ', isVao)
print('vbo created: ', isVbo)
floatSize = ctypes.sizeof(ctypes.c_float)
# allocate space on buffer
self.vbo2.allocate(self.vertexData2.tobytes(),
floatSize * self.vertexData2.size)
funcs.glEnableVertexAttribArray(0)
nullptr = VoidPtr(0)
funcs.glVertexAttribPointer(0,
3,
int(pygl.GL_FLOAT),
int(pygl.GL_FALSE),
3 * floatSize,
nullptr)
self.vbo2.release()
self.program2.release()
def __init__(self, parent=None):
QOpenGLWidget.__init__(self, parent)
# camera
self.camera = QtCamera()
self.camera.position = QVector3D(0.0, 0.0, 3.0)
self.camera.front = QVector3D(0.0, 0.0, -1.0)
self.camera.up = QVector3D(0.0, 1.0, 0.0)
self.camera.movementSensitivity = 0.05
# shaders etc
tutoTutoDir = os.path.dirname(__file__)
tutoPardir = os.path.join(tutoTutoDir, os.pardir)
tutoPardir = os.path.realpath(tutoPardir)
mediaDir = os.path.join(tutoPardir, "media")
shaderDir = os.path.join(mediaDir, "shaders")
availableShaders = ["cube"]
self.shaders = {
name: {
"fragment": os.path.join(shaderDir, name + ".frag"),
"vertex": os.path.join(shaderDir, name + ".vert")
}
for name in availableShaders
}
self.core = "--coreprofile" in QCoreApplication.arguments()
imdir = os.path.join(mediaDir, "images")
imFName = "im"
imageFile1 = os.path.join(imdir, imFName + "0.png")
self.image1 = QImage(imageFile1).mirrored()
imageFile2 = os.path.join(imdir, imFName + "1.png")
self.image2 = QImage(imageFile2).mirrored()
# opengl data related
self.context = QOpenGLContext()
self.vao = QOpenGLVertexArrayObject()
self.vbo = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
self.program = QOpenGLShaderProgram()
self.texture1 = None
self.texture2 = None
self.texUnit1 = 0
self.texUnit2 = 1
# vertex data
self.cubeVertices = np.array(
[
# pos vec3 || texcoord vec2
-0.5,
-0.5,
-0.5,
0.0,
0.0,
0.5,
-0.5,
-0.5,
1.0,
0.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
-0.5,
0.5,
-0.5,
0.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
0.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
0.5,
-0.5,
0.5,
1.0,
0.0,
0.5,
0.5,
0.5,
1.0,
1.0,
0.5,
0.5,
0.5,
1.0,
1.0,
-0.5,
0.5,
0.5,
0.0,
1.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
-0.5,
0.5,
0.5,
1.0,
0.0,
-0.5,
0.5,
-0.5,
1.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
-0.5,
0.5,
0.5,
1.0,
0.0,
0.5,
0.5,
0.5,
1.0,
0.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
0.5,
-0.5,
-0.5,
0.0,
1.0,
0.5,
-0.5,
-0.5,
0.0,
1.0,
0.5,
-0.5,
0.5,
0.0,
0.0,
0.5,
0.5,
0.5,
1.0,
0.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
0.5,
-0.5,
-0.5,
1.0,
1.0,
0.5,
-0.5,
0.5,
1.0,
0.0,
0.5,
-0.5,
0.5,
1.0,
0.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
-0.5,
0.5,
-0.5,
0.0,
1.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
0.5,
0.5,
0.5,
1.0,
0.0,
0.5,
0.5,
0.5,
1.0,
0.0,
-0.5,
0.5,
0.5,
0.0,
0.0,
-0.5,
0.5,
-0.5,
0.0,
1.0
],
dtype=ctypes.c_float)
# cube worldSpace coordinates
self.cubeCoords = [
QVector3D(0.2, 1.1, -1.0),
QVector3D(2.0, 5.0, -15.0),
QVector3D(-1.5, -2.2, -2.5),
QVector3D(-3.8, -2.0, -12.3),
QVector3D(2.4, -0.4, -3.5),
QVector3D(-1.7, 3.0, -7.5),
QVector3D(1.3, -2.0, -2.5),
QVector3D(1.5, 2.0, -2.5),
QVector3D(1.5, 0.2, -1.5),
QVector3D(-1.3, 1.0, -1.5)
]
self.rotateVector = QVector3D(0.7, 0.2, 0.5)
def initializeGL(self):
"Initialize opengl "
print('gl initial')
print(self.getGlInfo())
# create context and make it current
self.context.create()
self.context.aboutToBeDestroyed.connect(self.cleanUpGl)
# initialize functions
funcs = self.context.functions()
funcs.initializeOpenGLFunctions()
funcs.glClearColor(1, 1, 1, 1)
# shader
shaderName = "triangle"
vshader = self.loadVertexShader(shaderName)
fshader = self.loadFragmentShader(shaderName)
# create shader program
self.program = QOpenGLShaderProgram(self.context)
self.program.addShader(vshader)
self.program.addShader(fshader)
# bind attribute location
self.program.bindAttributeLocation("aPos", 0)
# link shader program
isLinked = self.program.link()
print("shader program is linked: ", isLinked)
# activate shader program to set uniform an attribute values
self.program.bind()
# specify uniform value
colorLoc = self.program.uniformLocation("color")
self.program.setUniformValue(colorLoc, self.rectColor)
# vao, vbo, texture
# vao
isVao = self.vao.create()
vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao)
# vbo
isVbo = self.vbo.create()
isVboBound = self.vbo.bind()
floatSize = ctypes.sizeof(ctypes.c_float)
# allocate vbo
self.vbo.allocate(self.vertexData.tobytes(),
floatSize * self.vertexData.size)
print("vao created: ", isVao)
print("vbo created: ", isVbo)
print("vbo bound: ", isVboBound)
# dealing with attributes
# vertex array position
funcs.glVertexAttribPointer(0, 3, int(pygl.GL_FLOAT),
int(pygl.GL_FALSE), 3 * floatSize,
VoidPtr(0))
funcs.glEnableVertexAttribArray(0)
self.vbo.release()
vaoBinder = None
def initializeGL(self):
# Set up the rendering context, define display lists etc.
self.initializeOpenGLFunctions()
self.glClearColor(0.2, 0.0, 0.2, 0.0)
self.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
# shader code (OpenGL ES)
# texture
vs_source_es = """
attribute highp vec3 Pos;
attribute highp vec2 UV;
uniform highp vec2 Scale;
varying highp vec2 oUV;
void main() {
gl_Position = vec4(Pos * vec3(Scale, 1.0), 1.0);
oUV = UV;
}
"""
ps_source_es = """
varying highp vec2 oUV;
uniform sampler2D Texture;
uniform highp mat4 Channels;
uniform highp vec4 Add;
void main() {
gl_FragColor = texture2D(Texture, oUV * vec2(1.0, -1.0)) * Channels;
gl_FragColor.a += (1.0 - Channels[3][3]);
}
"""
# background
vs_grid_es = """
attribute highp vec3 Pos;
void main() {
gl_Position = vec4(Pos, 1.0);
}
"""
ps_grid_es = """
uniform highp vec4 Color1;
uniform highp vec4 Color2;
uniform highp vec4 Height;
void main() {
highp vec2 a = floor((Height.xy - gl_FragCoord.xy) / 64.0);
highp float even = mod(a.x + a.y, 2.0);
highp vec3 c = mix(Color1.rgb, Color2.rgb, even);
gl_FragColor = vec4(c, 1);
}
"""
# program - texture
# shader
vs = self.__create_shader(QOpenGLShader.Vertex, vs_source_es)
fs = self.__create_shader(QOpenGLShader.Fragment, ps_source_es)
# program
self._program = QOpenGLShaderProgram(self.context())
self._program.addShader(vs)
self._program.addShader(fs)
# attribute location
self._program.bindAttributeLocation("Pos", 0)
self._program.bindAttributeLocation("UV", 1)
# link program
r = self._program.link()
# program - background
# shader
vs = self.__create_shader(QOpenGLShader.Vertex, vs_grid_es)
fs = self.__create_shader(QOpenGLShader.Fragment, ps_grid_es)
# program
self._program_bg = QOpenGLShaderProgram(self.context())
self._program_bg.addShader(vs)
self._program_bg.addShader(fs)
# attribute location
self._program_bg.bindAttributeLocation("Pos", 0)
# link program
r = self._program_bg.link()
# uniform locations
self._location = (
self._program.uniformLocation("Scale"),
self._program.uniformLocation("Channels"),
self._program_bg.uniformLocation("Color1"),
self._program_bg.uniformLocation("Color2"),
self._program_bg.uniformLocation("Height"),
)
# vao
r = self._vao.create()
r = self._vao.bind()
# vbo
r = self._vbo.create()
self._vbo.setUsagePattern(QOpenGLBuffer.StaticDraw)
r = self._vbo.bind()
sz_float = ctypes.sizeof(ctypes.c_float)
self._vbo.allocate(self._vertex.tobytes(),
sz_float * len(self._vertex))
self._vao.release()
# texture
self.set_texture(r"C:")
