Demo Catalogue

Interactive animated diagram of the GPU pipeline: vertex shader → rasterisation → fragment shader. Explains where each glEnable() call fits, what the driver does vs what you write, and why vertex position flows from CPU RAM to screen pixel.

Sets up a GLFW window, creates an OpenGL 3.3 core context, enters the event loop with glfwPollEvents(), clears to navy blue each frame, prints GPU name to terminal. Proves your environment works before writing a single shader.

Creates a VkBuffer (OpenGL: glGenBuffers), uploads 3 vertices with glBufferData(), then reads back the data to confirm the upload. Prints byte size, memory address, and confirms round-trip integrity. Foundation for every GPU draw call.

Shows how a VAO records the connection between a VBO and shader attribute locations. Live diagram printed to terminal: stride=20 bytes, location 0=position (offset 0), location 1=colour (offset 12). Break it by changing stride to see garbage output.

Compiles vertex and fragment shaders at runtime, links a program, draws the first triangle using glDrawArrays(). Shader compilation errors are printed to terminal with full GLSL log. The simplest possible full render pipeline.

Uses glDrawElements() + an index buffer to draw a rectangle from only 4 vertices (vs 6 duplicate vertices without EBO). Prints memory saved vs brute-force approach. Introduces TRIANGLE_LIST indexing pattern used in every production renderer.

Sends a float time uniform each frame via glUniform1f(), drives a translation and colour shift in the vertex shader. Shows glGetUniformLocation() cache pattern and why GPU uniforms are cheaper than per-vertex data for shared values.

Builds a full projection pipeline: glm::translate/rotate/scale → model matrix, glm::lookAt → view, glm::perspective → projection. WASD keys move the camera; mouse drag rotates. Demonstrates view frustum and near/far plane clipping live.

Implements Blinn-Phong: ambient constant + diffuse dot(N,L) + specular pow(dot(N,H), shininess). UP/DOWN keys change shininess live (2→256). Normal matrix corrects for non-uniform model scale. Orbiting point light demonstrates all three components separately.

Loads a PNG via stb_image into a GL_TEXTURE_2D object, binds to sampler uniform, applies to a lit 3D cube. UV coordinates are interleaved with positions and normals in a single VBO. Demonstrates mip-mapping, GL_REPEAT wrap mode, and texture × Phong multiplication.

Writes an entire radar PPI display inside a fragment shader using no textures. atan(x,y) computes bearing, fract() creates range rings, mod() drives the rotating sweep, smoothstep() softens edges. No geometry beyond one quad — the GPU draws everything via math.

Renders 1,000 coloured contacts with one glDrawArraysInstanced() call. Instance data (position, colour, size) is in a second VBO with glVertexAttribDivisor(1,1). Toggle instancing off and measure the frame time difference — see CPU overhead vs GPU throughput.

Two-pass render: scene → off-screen FBO texture, then fullscreen quad → apply shader filter. Keys 1-4 switch between passthrough, greyscale, invert, and Sobel edge detection without rebuilding any scene geometry. Classic deferred rendering foundation.

Two-pass stencil: first pass writes object pixels to stencil buffer; second pass draws scaled-up outline only where stencil=0 (outside original). Then adds a transparent alpha-blended radar sweep sector on top. Demonstrates blending order and depth–stencil interaction.

Creates VkInstance with validation enabled, enumerates all GPUs, scores each by VRAM and device type, creates VkSurfaceKHR via GLFW, destroys everything in correct order. Terminal shows GPU names, VRAM, and queue family availability. No rendering — pure setup.

Creates VkDevice requesting graphics + present queues, creates VkCommandPool and allocates a primary command buffer, records a no-op (empty) command buffer and submits it with a fence. Validates the full command recording and submission cycle before adding any rendering.

Creates VkSwapchainKHR, wraps images in VkImageViews, builds a VkRenderPass with LOAD_OP_CLEAR, creates framebuffers, runs the acquire → record → submit → present frame loop clearing to an animated navy colour via VkClearValue. First time real pixels appear.

Compiles GLSL to SPIR-V with glslc, loads .spv at runtime, creates VkShaderModules, builds VkGraphicsPipelineCreateInfo baking all state. Draws a white triangle on navy. No vertex buffer — positions hardcoded in vertex shader via gl_VertexIndex. Complete frame loop with semaphore+fence sync.

Builds the full descriptor system: VkDescriptorSetLayout (binding 0 = uniform buffer), VkDescriptorPool, one VkDescriptorSet per swapchain image. Each frame updates MVP matrices via persistent-mapped UBO memory and binds before vkCmdDraw. Orange triangle rotates via shader MVP with Vulkan Y-flip correction.

Creates a compute-only pipeline (no swapchain, no window). 256×256 synthetic image uploaded to storage buffer, compute shader inverts RGB of all 65,536 pixels in parallel (16×16 workgroups). Pipeline barrier ensures GPU writes complete before CPU reads. Prints timing and throughput in pixels/sec.

The definitive Vulkan hello-world. Creates VkInstance with validation, enumerates + scores all GPUs by VRAM and device type, creates VkDevice + queues, builds a VkSwapchainKHR. Every object printed to terminal. No shaders. No rendering. Proves your toolchain is working before anything else.

First rendered output in Vulkan. Vertex positions hardcoded in shader.vert via gl_VertexIndex — no vertex buffer. Builds complete VkGraphicsPipelineCreateInfo baking all fixed-function state. Shows acquire → record → vkCmdBeginRenderPass → vkCmdDraw → present loop with semaphore+fence synchronisation.

Uploads a coloured pentagon from CPU memory to a HOST_VISIBLE buffer using vkMapMemory + memcpy. VkVertexInputBindingDescription describes stride; VkVertexInputAttributeDescription describes location, format, and byte offset for position (vec2) and colour (vec3). Topology: TRIANGLE_FAN from centre vertex.

Draws a rectangle from 4 vertices + 6 indices with vkCmdDrawIndexed. Introduces the staging pattern: CPU writes to HOST_VISIBLE buffer → one-shot command buffer copies to DEVICE_LOCAL memory → staging buffer destroyed. Device-local is faster GPU memory — the standard pattern for all static geometry.

Builds the complete descriptor infrastructure: layout → pool → sets → update. One UBO per swapchain image (prevents CPU overwriting data GPU is reading). Rotating quad driven by MVP matrix. Persistent vkMapMemory + memcpy per frame. proj[1][1]*=-1 corrects Vulkan Y-axis flip.

Uploads a procedural 256×256 checkerboard texture via staging buffer → vkCmdCopyBufferToImage. Two image layout transitions: UNDEFINED→TRANSFER_DST→SHADER_READ_ONLY. Descriptor set with two bindings: UBO (binding 0) + COMBINED_IMAGE_SAMPLER (binding 1). Rotating textured quad.

Adds a depth attachment: VkImage with D32_SFLOAT format, render pass with two attachments, two VkClearValues (colour + depth=1.0). VkPipelineDepthStencilStateCreateInfo enables LESS compare op. 36-vertex cube with unique face colours. Back-face culling ON. Validates face ordering without depth corruption.

Draws 5 cubes with one shared vertex buffer but unique transforms via 80-byte push constants (mat4 model + vec4 colour). Push constants are the fastest per-draw update path — no descriptor overhead. Shared VP UBO for camera. Each cube orbits at a different radius and speed.

Procedurally generated UV sphere (32 stacks × 64 slices). SceneUBO carries model/view/proj + lightPos + viewPos. Normal matrix: transpose(inverse(model)). Blinn-Phong in fragment shader: ambient + diffuse dot(N,L) + specular pow(dot(N,H), shininess). Shininess adjustable with UP/DOWN keys.

Full compute + graphics dual pipeline. Compute shader runs Sobel edge detection / box blur / sharpen on a Mandelbrot fractal (generated in code). Output copied to a VkImage. Graphics renders it as a fullscreen triangle via a combined image sampler. Keys 1/2/3/4 switch filters every frame.

USS Monterey CIC scenario. Rotating green sweep beam with persistent alpha-blended trail. 4 range rings, north/south/east/west crosshair, 8 simulated surface contacts orbiting at different ranges and speeds. Two pipelines in one render pass: LINE_LIST for rings, TRIANGLE_LIST for sweep sector. Dynamic vertex buffer rebuilt each frame. +/- keys change sweep speed.

Royal Australian Navy bridge simulator scenario. 64×64 grid mesh uploaded once — all wave displacement computed in vertex shader via 4 superimposed Gerstner waves (no CPU geometry rebuild per frame). Blinn-Phong sun lighting, Fresnel edge glow, foam on wave crests, depth colour gradient. Fly camera: WASD + mouse drag + +/- wave height.

Naval simulation game scenario — missile exhaust fire. 100,000 particles simulated entirely on GPU: compute shader integrates velocity, applies gravity, respawns dead particles. Critical compute→graphics pipeline barrier ensures GPU writes complete before vertex reads. Additive blending creates fire glow. Circular soft-edged point sprites via gl_PointCoord. SPACE adds new emitter.