def init_context(self):
self.gl_context = QOpenGLContext(self)
self.gl_context.setFormat(self.gl_format)
if self.gl_context.create():
print("Context created !")
if self.gl_context.makeCurrent(self):
print("Context made current !")
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 __enter__(self):
self.mutex.lock()
self.ctx = QOpenGLContext()
self.ctx.setShareContext(self.parent)
self.ctx.create()
if not self.ctx.makeCurrent(self.surface):
raise Exception("cannot make context current")
self.project.renderer.lock()
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 __init__(self, format):
super(RenderWindow, self).__init__()
self.setSurfaceType(QWindow.OpenGLSurface)
self.setFormat(format)
self.context = QOpenGLContext(self)
self.context.setFormat(self.requestedFormat())
if not self.context.create():
raise Exception("Unable to create GL context")
self.program = None
self.timer = None
self.angle = 0
def __init__(self, id: str, app: QGuiApplication):
assert self._initialized
self.id = id
self.app = app
self.qml_view = QUrl(os.fspath(get_data_path("webview.qml")))
gl_context = QOpenGLContext()
gl_context.setFormat(QSurfaceFormat.defaultFormat())
gl_context.create()
self.client = Client(id, self.qml_view, gl_context)
self.client.disconnected.connect(self.on_disconnected)
self.client.start()
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 __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 initialize(self, size: QSize, shareContext: QOpenGLContext) -> None:
"""
Initialize offscreen renderer.
Args:
size: The size of the area available for rendering.
shareContext: OpenGL context used as a share context.
Raises:
RuntimeError: If the renderer has already been initialized.
"""
print(f'QmlOffscreenRenderer.initialize: {size}')
if self.initialized:
raise RuntimeError('Already initialized')
context = QOpenGLContext()
context.setShareContext(shareContext)
context.setFormat(get_default_format(gles=False))
context.create()
assert not context.isOpenGLES(), "We need glGetTexImage from OpenGL"
self.size = size
# Create offscreen surface with initialized format
surface = QOffscreenSurface()
surface.setFormat(context.format())
surface.create()
self.ctx = RenderContext(context, surface)
# Set up quick rendering
self._control = control = QQuickRenderControl()
self._window = window = QQuickWindow(control)
self._cursor = self._window.cursor()
# Don't polish/sync/render immediately for better performance, use a timer
self._renderTimer = renderTimer = QTimer()
renderTimer.setSingleShot(True)
renderTimer.setInterval(5)
renderTimer.timeout.connect(self._onRenderTimer)
self._syncTimer = syncTimer = QTimer()
syncTimer.setSingleShot(True)
syncTimer.setInterval(5)
syncTimer.timeout.connect(self._onSyncTimer)
syncTimer.destroyed.connect(self._onSyncTimerDestroyed)
# Request to create frame buffer
window.sceneGraphInitialized.connect(self._onSceneGraphInitialized)
# Request to release frame buffer
window.sceneGraphInvalidated.connect(self._onSceneGraphInvalidated)
# Only render is needed
control.renderRequested.connect(self._onRenderRequested)
# Polish, sync & render
control.sceneChanged.connect(self._onSceneChanged)
self.initialized = True
# Attach root item
self.rootItem.setParentItem(self._window.contentItem())
self._window.contentItem().forceActiveFocus()
self._updateSizes()
self.ctx.makeCurrent()
self._control.initialize(self.ctx.glContext)
def initialize(self, size: QSize, shareContext: QOpenGLContext) -> None:
"""
Initialize offscreen renderer.
Args:
size: The size of the area available for rendering.
shareContext: OpenGL context used as a share context.
Raises:
RuntimeError: If the renderer has already been initialized.
"""
print(f'QmlOffscreenRenderer.initialize: {size}')
if self.initialized:
raise RuntimeError('Already initialized')
format = QSurfaceFormat()
format.setDepthBufferSize(16)
format.setStencilBufferSize(8)
context = QOpenGLContext()
context.setFormat(format)
context.setShareContext(shareContext)
context.create()
self.size = size
self.context = context
# Create offscreen surface with initialized format
self._surface = surface = QOffscreenSurface()
surface.setFormat(context.format())
surface.create()
# Set up quick rendering
self._control = control = QQuickRenderControl()
self._window = window = QQuickWindow(control)
self._engine = engine = QQmlEngine()
if not engine.incubationController():
engine.setIncubationController(window.incubationController())
# Don't polish/sync/render immediately for better performance, use a timer
self._renderTimer = renderTimer = QTimer()
renderTimer.setSingleShot(True)
renderTimer.setInterval(5)
renderTimer.timeout.connect(self._onRenderTimer)
self._syncTimer = syncTimer = QTimer()
syncTimer.setSingleShot(True)
syncTimer.setInterval(5)
syncTimer.timeout.connect(self._onSyncTimer)
syncTimer.destroyed.connect(self._onSyncTimerDestroyed)
# Request to create frame buffer
window.sceneGraphInitialized.connect(self._onSceneGraphInitialized)
# Request to release frame buffer
window.sceneGraphInvalidated.connect(self._onSceneGraphInvalidated)
# Only render is needed
control.renderRequested.connect(self._onRenderRequested)
# Polish, sync & render
control.sceneChanged.connect(self._onSceneChanged)
self.initialized = True
# Load QML component
self._component = component = QQmlComponent(self._engine, self.qmlUrl)
if component.isLoading():
component.statusChanged.connect(self._onComponentStatusChanged)
else:
self._attachRootItem()