Jekyll2026-07-28T07:52:21+00:00https://fe0437.github.io/feed.xml🌵 Federico Forti (fe0437)This is a personal blog where I'm going to write long articles about my projects when I need more space and resources than a simple tweet. In particular, I will write about graphics programming real-time and offline, 2D and 3D. At the moment focusing on swift, metal and C++.Metal Tutorial 6 — GPU-Driven Rendering2024-06-04T23:00:00+00:002024-06-04T23:00:00+00:00https://fe0437.github.io/metal/tutorial/swift/2024/06/04/metal-tutorial-6In every previous tutorial the CPU decides what to draw and when. This one removes the CPU from the render loop entirely. A compute shader reads the scene, culls what’s invisible, and writes draw commands directly into an MTLIndirectCommandBuffer — the GPU issues its own draw calls. This is the architecture behind modern game engines on Apple platforms.
What you’ll learn:
Encoding draw commands with MTLIndirectCommandBuffer
Bindless resource access via argument buffers
Suballocating buffers and textures from a single MTLHeap
Running a compute dispatch to cull objects and populate the ICB on the GPU
]]>Metal Tutorial 5 — Tiled Rendering2024-05-21T23:00:00+00:002024-05-21T23:00:00+00:00https://fe0437.github.io/metal/tutorial/swift/2024/05/21/metal-tutorial-5Every Apple GPU is a tile-based deferred renderer (TBDR). Instead of writing intermediate results to DRAM and reading them back, the GPU processes each screen tile entirely in fast on-chip memory. This tutorial exploits that architecture with memoryless textures and tile shaders — eliminating the G-buffer bandwidth cost that conventional deferred rendering pays on every frame.
What you’ll learn:
How Apple’s TBDR architecture differs from immediate-mode GPUs
Declaring G-buffer textures as memoryless to keep them on-chip
Writing tile shaders that run between render passes within a tile
Using .dontCare load/store actions to eliminate unnecessary memory traffic
]]>Metal Tutorial 4 — Shadows2024-05-07T23:00:00+00:002024-05-07T23:00:00+00:00https://fe0437.github.io/metal/tutorial/swift/2024/05/07/metal-tutorial-4Shadows are what make objects feel grounded in a scene. This tutorial implements shadow mapping: a depth-only first pass from the light’s perspective builds the shadow map, and the deferred lighting pass compares each fragment’s light-space depth against it to decide lit vs. shadowed.
What you’ll learn:
Rendering a depth-only pass into an MTLTexture shadow map
Transforming fragments to light space for depth comparison
Shadow bias to avoid self-shadowing artifacts
Percentage-closer filtering (PCF) for soft shadow edges
]]>Metal Tutorial 3 — Deferred Rendering2024-04-23T23:00:00+00:002024-04-23T23:00:00+00:00https://fe0437.github.io/metal/tutorial/swift/2024/04/23/metal-tutorial-3Forward rendering shades every fragment for every light — which blows up fast. Deferred rendering solves this by splitting the work into two passes: first write geometry data into a G-buffer, then run a single full-screen lighting pass that reads from it. The result is a scene that can support many lights without the cost growing with geometry complexity.
What you’ll learn:
Writing to multiple render targets (MRT) in a single pass
Structuring a G-buffer with position, normal, and albedo textures
Reading G-buffer textures in a full-screen lighting pass
How MTLRenderPassDescriptor load/store actions control memory usage
]]>Metal Tutorial 2 — Sample Object2024-04-09T23:00:00+00:002024-04-09T23:00:00+00:00https://fe0437.github.io/metal/tutorial/swift/2024/04/09/metal-tutorial-2A hard-coded triangle only gets you so far. This tutorial loads a real 3D mesh from disk using Model I/O, introduces MTLBuffer for per-frame uniform data, and enables depth testing so that geometry sorts correctly regardless of draw order.
What you’ll learn:
Loading .obj geometry with MDLAsset and MTKMesh
Passing per-frame uniforms (model/view/projection matrices) via MTLBuffer
Setting up MTLDepthStencilState so nearer fragments win
Vertex descriptors and how Metal maps buffer layout to shader inputs
]]>Metal Tutorial 1 — Hello Triangle2024-03-26T18:04:14+00:002024-03-26T18:04:14+00:00https://fe0437.github.io/metal/tutorial/swift/2024/03/26/metal-tutorial-1A colored triangle is the “hello world” of GPU programming — deceptively simple on screen, but wiring it up teaches you the full Metal pipeline end-to-end. By the time you’re done you’ll have written your first MSL shaders, compiled a render pipeline, encoded a draw call, and presented a frame.
What you’ll learn:
How MTLRenderPipelineState ties a vertex and fragment shader together
Encoding draw calls with MTLRenderCommandEncoder
Writing vertex and fragment shaders in Metal Shading Language (MSL)
Memory layout gotchas with vector_float2 / vector_float4 and GPU alignment
]]>Metal Tutorial 0 — Preparation2024-02-29T23:00:00+00:002024-02-29T23:00:00+00:00https://fe0437.github.io/metal/tutorial/swift/2024/02/29/metal-tutorial-0Metal doesn’t hide the GPU from you — it gives you direct access to it. Before writing a single shader, this tutorial builds the mental model you’ll rely on throughout the series: how GPU objects relate, what the render loop actually does each frame, and which setup work belongs in init vs. draw.
What you’ll learn:
The MTLDevice → MTLCommandQueue → MTLCommandBuffer ownership chain
How UIViewRepresentable wires up MTKView and MTKViewDelegate
Coordinate spaces from model space through NDC to screen pixels
Which objects pay a one-time creation cost vs. which are created per frame
