# Copyright (C) 2022 The Qt Company Ltd. # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause from __future__ import annotations import ctypes import math import numpy from OpenGL import GL from PySide6.QtOpenGL import QOpenGLShader, QOpenGLShaderProgram, QOpenGLBuffer from PySide6.QtGui import (QGuiApplication, QOpenGLFunctions, QVector3D, QMatrix4x4) from PySide6.QtCore import (QElapsedTimer, QObject, QMetaObject, QMutex, QMutexLocker, QThread, QWaitCondition, Signal, Slot) # Some OpenGL implementations have serious issues with compiling and linking # shaders on multiple threads concurrently. Avoid self. init_mutex = QMutex() VERTEX_SHADER = """attribute highp vec4 vertex; attribute mediump vec3 normal; uniform mediump mat4 matrix; varying mediump vec4 color; void main(void) { vec3 toLight = normalize(vec3(0.0, 0.3, 1.0)); float angle = max(dot(normal, toLight), 0.0); vec3 col = vec3(0.40, 1.0, 0.0); color = vec4(col * 0.2 + col * 0.8 * angle, 1.0); color = clamp(color, 0.0, 1.0); gl_Position = matrix * vertex; } """ FRAGMENT_SHADER = """varying mediump vec4 color; void main(void) { gl_FragColor = color; } """ class Renderer(QObject, QOpenGLFunctions): context_wanted = Signal() def __init__(self, widget): QObject.__init__(self) QOpenGLFunctions.__init__(self) self._glwidget = widget self._inited = False self._fAngle = 0 self._fScale = 1 self._vertices = [] self._normals = [] self._program = QOpenGLShaderProgram() self._vbo = QOpenGLBuffer() self._vertex_attr = 0 self._normal_attr = 0 self._matrix_uniform = 0 self._renderMutex = QMutex() self._elapsed = QElapsedTimer() self._grabMutex = QMutex() self._grab_condition = QWaitCondition() self._exiting = False def lock_renderer(self): self._renderMutex.lock() def unlock_renderer(self): self._renderMutex.unlock() def grab_mutex(self): return self._grabMutex def grab_condition(self): return self._grab_condition def prepare_exit(self): self._exiting = True self._grab_condition.wakeAll() def paint_Qt_logo(self): self._vbo.bind() self._program.setAttributeBuffer(self._vertex_attr, GL.GL_FLOAT, 0, 3) size = len(self._vertices) * 3 * ctypes.sizeof(ctypes.c_float) self._program.setAttributeBuffer(self._normal_attr, GL.GL_FLOAT, size, 3) self._vbo.release() self._program.enableAttributeArray(self._vertex_attr) self._program.enableAttributeArray(self._normal_attr) self.glDrawArrays(GL.GL_TRIANGLES, 0, len(self._vertices)) self._program.disableAttributeArray(self._normal_attr) self._program.disableAttributeArray(self._vertex_attr) @Slot() def render(self): global init_mutex if self._exiting: return ctx = self._glwidget.context() if not ctx: # QOpenGLWidget not yet initialized return # Grab the context. self._grabMutex.lock() self.context_wanted.emit() self._grab_condition.wait(self._grabMutex) with QMutexLocker(self._renderMutex): self._grabMutex.unlock() if self._exiting: return assert ctx.thread() == QThread.currentThread() # Make the context (and an offscreen surface) current for self thread. # The QOpenGLWidget's fbo is bound in the context. self._glwidget.makeCurrent() if not self._inited: self._inited = True self.initializeOpenGLFunctions() with QMutexLocker(init_mutex): self._init_gl() self._elapsed.start() self._render_next() # Make no context current on self thread and move the # QOpenGLWidget'scontext back to the gui thread. self._glwidget.doneCurrent() ctx.moveToThread(QGuiApplication.instance().thread()) # Schedule composition. Note that self will use QueuedConnection, # meaning that update() will be invoked on the gui thread. QMetaObject.invokeMethod(self._glwidget, "update") def _init_gl(self): vshader = QOpenGLShader(QOpenGLShader.ShaderTypeBit.Vertex, self) vshader.compileSourceCode(VERTEX_SHADER) fshader = QOpenGLShader(QOpenGLShader.ShaderTypeBit.Fragment, self) fshader.compileSourceCode(FRAGMENT_SHADER) self._program.addShader(vshader) self._program.addShader(fshader) self._program.link() self._vertex_attr = self._program.attributeLocation("vertex") self._normal_attr = self._program.attributeLocation("normal") self._matrix_uniform = self._program.uniformLocation("matrix") self._fAngle = 0 self._fScale = 1 self.create_geometry() self._vbo.create() self._vbo.bind() data_count = len(self._vertices) * 2 * 3 data = numpy.empty(data_count, dtype=ctypes.c_float) i = 0 for v in self._vertices: data[i] = v.x() i += 1 data[i] = v.y() i += 1 data[i] = v.z() i += 1 for n in self._normals: data[i] = n.x() i += 1 data[i] = n.y() i += 1 data[i] = n.z() i += 1 vertices_size = data_count * ctypes.sizeof(ctypes.c_float) self._vbo.allocate(data.tobytes(), vertices_size) def _render_next(self): self.glClearColor(0.1, 0.2, 0.2, 1.0) self.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) self.glFrontFace(GL.GL_CW) self.glCullFace(GL.GL_FRONT) self.glEnable(GL.GL_CULL_FACE) self.glEnable(GL.GL_DEPTH_TEST) modelview = QMatrix4x4() modelview.rotate(self._fAngle, 0.0, 1.0, 0.0) modelview.rotate(self._fAngle, 1.0, 0.0, 0.0) modelview.rotate(self._fAngle, 0.0, 0.0, 1.0) modelview.scale(self._fScale) modelview.translate(0.0, -0.2, 0.0) self._program.bind() self._program.setUniformValue(self._matrix_uniform, modelview) self.paint_Qt_logo() self._program.release() self.glDisable(GL.GL_DEPTH_TEST) self.glDisable(GL.GL_CULL_FACE) self._fAngle += 1.0 def create_geometry(self): self._vertices = [] self._normals = [] x1 = +0.06 y1 = -0.14 x2 = +0.14 y2 = -0.06 x3 = +0.08 y3 = +0.00 x4 = +0.30 y4 = +0.22 self.quad(x1, y1, x2, y2, y2, x2, y1, x1) self.quad(x3, y3, x4, y4, y4, x4, y3, x3) self.extrude(x1, y1, x2, y2) self.extrude(x2, y2, y2, x2) self.extrude(y2, x2, y1, x1) self.extrude(y1, x1, x1, y1) self.extrude(x3, y3, x4, y4) self.extrude(x4, y4, y4, x4) self.extrude(y4, x4, y3, x3) NUM_SECTORS = 100 SECTOR_ANGLE = 2 * math.pi / NUM_SECTORS for i in range(NUM_SECTORS): angle = i * SECTOR_ANGLE sin_angle = math.sin(angle) cos_angle = math.cos(angle) x5 = 0.30 * sin_angle y5 = 0.30 * cos_angle x6 = 0.20 * sin_angle y6 = 0.20 * cos_angle angle += SECTOR_ANGLE sin_angle = math.sin(angle) cos_angle = math.cos(angle) x7 = 0.20 * sin_angle y7 = 0.20 * cos_angle x8 = 0.30 * sin_angle y8 = 0.30 * cos_angle self.quad(x5, y5, x6, y6, x7, y7, x8, y8) self.extrude(x6, y6, x7, y7) self.extrude(x8, y8, x5, y5) for i in range(len(self._vertices)): self._vertices[i] *= 2.0 def quad(self, x1, y1, x2, y2, x3, y3, x4, y4): self._vertices.append(QVector3D(x1, y1, -0.05)) self._vertices.append(QVector3D(x2, y2, -0.05)) self._vertices.append(QVector3D(x4, y4, -0.05)) self._vertices.append(QVector3D(x3, y3, -0.05)) self._vertices.append(QVector3D(x4, y4, -0.05)) self._vertices.append(QVector3D(x2, y2, -0.05)) n = QVector3D.normal(QVector3D(x2 - x1, y2 - y1, 0.0), QVector3D(x4 - x1, y4 - y1, 0.0)) self._normals.append(n) self._normals.append(n) self._normals.append(n) self._normals.append(n) self._normals.append(n) self._normals.append(n) self._vertices.append(QVector3D(x4, y4, 0.05)) self._vertices.append(QVector3D(x2, y2, 0.05)) self._vertices.append(QVector3D(x1, y1, 0.05)) self._vertices.append(QVector3D(x2, y2, 0.05)) self._vertices.append(QVector3D(x4, y4, 0.05)) self._vertices.append(QVector3D(x3, y3, 0.05)) n = QVector3D.normal(QVector3D(x2 - x4, y2 - y4, 0.0), QVector3D(x1 - x4, y1 - y4, 0.0)) self._normals.append(n) self._normals.append(n) self._normals.append(n) self._normals.append(n) self._normals.append(n) self._normals.append(n) def extrude(self, x1, y1, x2, y2): self._vertices.append(QVector3D(x1, y1, +0.05)) self._vertices.append(QVector3D(x2, y2, +0.05)) self._vertices.append(QVector3D(x1, y1, -0.05)) self._vertices.append(QVector3D(x2, y2, -0.05)) self._vertices.append(QVector3D(x1, y1, -0.05)) self._vertices.append(QVector3D(x2, y2, +0.05)) n = QVector3D.normal(QVector3D(x2 - x1, y2 - y1, 0.0), QVector3D(0.0, 0.0, -0.1)) self._normals.append(n) self._normals.append(n) self._normals.append(n) self._normals.append(n) self._normals.append(n) self._normals.append(n)