Modern OpenGL in Python

Basic QOpenGLWidget Class

from PySide6.QtOpenGLWidgets import QOpenGLWidget

class GLWidget(QOpenGLWidget):

    def initializeGL(self):
        pass

    def resizeGL(self, w, h):
        pass

    def paintGL(self):
        pass

Important Functions

Rendering Lifecycle

Application Starts
        ↓
QOpenGLWidget Created
        ↓
initializeGL()
        ↓
resizeGL()
        ↓
paintGL()
        ↓
Screen Updated
        ↓
paintGL() Repeats

Updating the Viewport

def resizeGL(self, w, h):

    glViewport(0, 0, w, h)

The viewport defines the rendering area inside the widget.

Clearing the Screen

def paintGL(self):

    glClearColor(0.2, 0.2, 0.2, 1.0)

    glClear(
        GL_COLOR_BUFFER_BIT |
        GL_DEPTH_BUFFER_BIT
    )

The framebuffer is cleared before rendering a new frame.

Updating the Widget

self.update()

Calling update() schedules a repaint and triggers the paintGL() function.

Mouse and Keyboard Events

def mousePressEvent(self, event):
    pass

def mouseMoveEvent(self, event):
    pass

def wheelEvent(self, event):
    pass

QOpenGLWidget supports all standard Qt input events for implementing camera movement and interaction.

Advantages of QOpenGLWidget

QOpenGLWidget Rendering Flow

Qt Application
        ↓
QOpenGLWidget
        ↓
OpenGL Context
        ↓
GPU Rendering
        ↓
Framebuffer
        ↓
Widget Display

Responsibilities of a Vertex Shader

Basic Vertex Shader

#version 330 core

layout(location = 0) in vec3 position;

void main()
{
    gl_Position = vec4(position, 1.0);
}

Code Explanation

Vertex Transformations

In most applications, vertices are transformed using model, view and projection matrices.

Local Space
        ↓
World Space
        ↓
View Space
        ↓
Clip Space

Vertex Shader with Transformations

#version 330 core

layout(location = 0) in vec3 position;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main()
{
    gl_Position =
        projection *
        view *
        model *
        vec4(position, 1.0);
}

Uniform Variables

Vertex Shader Data Flow

Vertex Buffer
        ↓
Vertex Shader
        ↓
Transformed Vertices
        ↓
Rasterization
        ↓
Fragment Shader

Important Notes

• Vertex shaders execute once per vertex.
• The output position must be written to gl_Position.
• Vertex shaders cannot create pixels directly.
• The vertex shader runs on the GPU.
• Vertex shaders are written using GLSL.

Responsibilities of a Fragment Shader

Basic Fragment Shader

#version 330 core

out vec4 FragColor;

void main()
{
    FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}

Code Explanation

RGBA Color Components

vec4(red, green, blue, alpha)

Example:

vec4(1.0, 0.0, 0.0, 1.0)

Red   = 1.0
Green = 0.0
Blue  = 0.0
Alpha = 1.0

Receiving Data from the Vertex Shader

Fragment shaders can receive interpolated data from the vertex shader.

#version 330 core

in vec3 vertexColor;

out vec4 FragColor;

void main()
{
    FragColor = vec4(vertexColor, 1.0);
}

Attribute Interpolation

Values passed from the vertex shader are automatically interpolated across the surface of a primitive during rasterization.

Vertex Shader Outputs
        ↓
Rasterization
        ↓
Interpolated Fragment Data
        ↓
Fragment Shader

Fragment Shader Lighting Example

vec3 finalColor = baseColor;

float diffuse =
    max(dot(normal, lightDir), 0.0);

finalColor *= diffuse;

FragColor = vec4(finalColor, 1.0);

Lighting calculations are commonly performed inside the fragment shader to achieve smooth shading and realistic visual appearance.

Texture Sampling

uniform sampler2D textureSampler;

in vec2 texCoord;

FragColor =
    texture(textureSampler, texCoord);

Fragment shaders can sample textures using UV coordinates.

Fragment Shader Data Flow

Vertex Shader
        ↓
Rasterization
        ↓
Fragment Shader
        ↓
Depth Testing
        ↓
Framebuffer

Important Notes

• Fragment shaders execute once per fragment.
• Fragment shaders determine the final pixel color.
• Fragment shaders run on the GPU.
• Fragment shaders are written using GLSL.
• Fragment shaders are commonly used for lighting and texturing.

Why Buffers are Required

Without buffers, geometry data would need to be sent repeatedly from the CPU to the GPU during rendering.

Main Buffer Types

Vertex Buffer Object (VBO)

A VBO stores vertex data inside GPU memory.

vertices = np.array([
    -0.5, -0.5, 0.0,
     0.5, -0.5, 0.0,
     0.0,  0.5, 0.0
], dtype=np.float32)

This array contains vertex positions for a triangle.

Creating a VBO

vbo = glGenBuffers(1)

glBindBuffer(GL_ARRAY_BUFFER, vbo)

glBufferData(
    GL_ARRAY_BUFFER,
    vertices.nbytes,
    vertices,
    GL_STATIC_DRAW
)

VBO Explanation

Element Buffer Object (EBO)

An EBO stores indices that define how vertices form primitives.

indices = np.array([
    0, 1, 2,
    2, 3, 0
], dtype=np.uint32)

These indices define two triangles forming a quad.

Creating an EBO

ebo = glGenBuffers(1)

glBindBuffer(
    GL_ELEMENT_ARRAY_BUFFER,
    ebo
)

glBufferData(
    GL_ELEMENT_ARRAY_BUFFER,
    indices.nbytes,
    indices,
    GL_STATIC_DRAW
)

Why EBOs are Important

Without EBO
        ↓
Duplicate Vertices
        ↓
More GPU Memory

With EBO
        ↓
Reuse Vertices
        ↓
Efficient Rendering

Indexed rendering reduces duplicate geometry data and improves rendering efficiency.

Vertex Array Object (VAO)

A VAO stores vertex attribute configuration and buffer state.

VAO Stores:
    • Vertex Attribute Layout
    • Bound VBO
    • Bound EBO
    • Attribute Configuration

Creating a VAO

vao = glGenVertexArrays(1)

glBindVertexArray(vao)

Vertex Attribute Configuration

glVertexAttribPointer(
    0,
    3,
    GL_FLOAT,
    GL_FALSE,
    3 * 4,
    ctypes.c_void_p(0)
)

glEnableVertexAttribArray(0)

glVertexAttribPointer Parameters

Complete Rendering Flow

Vertex Data
        ↓
VBO
        ↓
EBO
        ↓
VAO Configuration
        ↓
glDrawElements()
        ↓
Vertex Shader
        ↓
Fragment Shader
        ↓
Framebuffer
                        

Rendering Geometry

glBindVertexArray(vao)

glDrawElements(
    GL_TRIANGLES,
    len(indices),
    GL_UNSIGNED_INT,
    None
)

Once the VAO is configured, rendering becomes very simple.

VAO vs VBO vs EBO

Important Notes

• Buffers store data inside GPU memory.
• VBOs store vertex attributes.
• EBOs store indexed connectivity.
• VAOs store vertex attribute configuration.
• Modern OpenGL rendering heavily relies on buffer objects.

Projection Types

Orthographic Projection

Orthographic projection removes perspective distortion and preserves object dimensions regardless of depth.

Parallel Projection Rays
        ↓
No Perspective Distortion
        ↓
Constant Object Size

Orthographic projection is commonly used in: CAD software, engineering tools, architectural applications and technical visualization.

Orthographic Projection Matrix

projection = ortho(left,right,bottom,top,near,far)

The orthographic matrix defines a rectangular viewing volume.

Orthographic Parameters

Camera System

The camera defines how the scene is viewed. In OpenGL, the camera is implemented using the view matrix.

View Matrix

The view matrix transforms the scene relative to the camera position and orientation.

view = lookAt(
    cameraPosition,
    targetPosition,
    upDirection
)

Camera Parameters

Camera Movement

Interactive applications commonly support: orbiting, panning and zooming.

Complete Transformation Pipeline

gl_Position =
    projection *
    view *
    model *
    vec4(position, 1.0);

Vertices are transformed from local coordinates into clip space before rasterization.

Coordinate Transformation Flow

Local Space
        ↓
Model Matrix
        ↓
World Space
        ↓
View Matrix
        ↓
Camera Space
        ↓
Projection Matrix
        ↓
Clip Space
        ↓
Screen Space

Important Notes

• Orthographic projection preserves object dimensions.
• Perspective projection creates realistic depth perception.
• The camera is implemented using the view matrix.
• Projection matrices convert 3D coordinates into clip space.
• The final transformed vertex position is written to gl_Position.

Ray Casting Flow

Mouse Position
        ↓
Normalized Device Coordinates
        ↓
View Space Ray
        ↓
World Space Ray
        ↓
Intersection Tests
        ↓
Selected Object
                        

Ray Intersection Testing

Once the ray is generated, intersection tests are performed against geometry.

Ray-Triangle Intersection

Most 3D geometry is composed of triangles, so ray-triangle intersection is one of the most important selection algorithms in computer graphics.

Ray
        ↓
Triangle Intersection Test
        ↓
Hit Position
        ↓
Closest Intersection
        ↓
Selected Object
                        

Importance of Ray Casting

Important Notes

• Ray casting converts 2D mouse input into a 3D selection ray.
• Ray intersection testing is heavily based on vector mathematics.
• Most object selection systems rely on ray-triangle intersection.
• Accurate picking requires inverse projection and view transformations.
• Ray casting is widely used in CAD, games and scientific visualization applications.

What We Built

PySide6 Application
        ↓
QOpenGLWidget
        ↓
PyOpenGL
        ↓
Modern OpenGL Pipeline
        ↓
Shaders
        ↓
GPU Buffers
        ↓
Interactive 3D Rendering
                        

Instead of building isolated rendering demos, the goal was to gradually develop a complete real-time visualization system.

Core Features

Graphical User Interface

The application interface is built using PySide6 and organized into multiple interactive panels.

Interactive Selection System

IGLViewer supports body and face level selection using ray casting. Mouse events from the OpenGL viewport are converted into 3D rays for accurate object intersection testing.

IGLViewer demonstrates how modern OpenGL, GPU rendering, PySide6 and custom visualization systems can be combined to create a professional engineering graphics application. It serves as a practical implementation of the concepts covered throughout this OpenGL tutorial series.