--- name: jame581-rendering-pipeline description: "Use when choosing a renderer or planning a project's look and frame budget — renderer per platform, lighting strategy and light limits, anti-aliasing, 3D resolution scaling (FSR, MetalFX), SubViewports and render targets, shader stutter, graphics settings menus, and rendering stats" license: "MIT" metadata: decimalai-skill-id: "0d4279d9-672c-48cf-9d6f-9d1ddfc0bf55" decimalai-version-id: "49f84dff-2795-42f1-8f13-82a4d027030f" decimalai-version: "1" decimalai-body-sha256: "d17de17d6227517a75b69597b5d8da088b41773a6ae2d94a0ac2698ba28c70d6" decimalai-name: "jame581/rendering-pipeline" decimalai-format: "1" decimalai-invocation: "model" decimalai-category: "coding" decimalai-source: "https://app.decimal.ai/s/jame581-rendering-pipeline@1/SKILL.md" --- # Rendering Pipeline in Godot 4.3+ Project-level rendering decisions: which renderer runs where, how the lighting is built for it, how edges are smoothed, what resolution 3D renders at, and how to measure the result. All examples target Godot 4.3+ with no deprecated APIs. GDScript is shown first, then C#. This skill picks the strategy; **3d-essentials** holds the per-node recipes (materials, light properties, GI setup, fog, decals). > **Related skills:** **3d-essentials** for materials, lights, environment and GI node setup, **2d-essentials** for 2D lights and shadows, **shader-basics** for post-processing, compositor effects and the Shader Baker, **godot-optimization** for profiling CPU/GPU bottlenecks, **web-export** for the Compatibility-only browser target. --- ## 1. Pick the Renderer First The renderer decides which lighting features exist at all, so choose it before building the look. | Renderer | `rendering_method` | Use for | Missing compared to Forward+ | |---|---|---|---| | **Forward+** | `forward_plus` | Desktop and console, high-end visuals | — | | **Mobile** | `mobile` | Phones, tablets, standalone XR, low-end desktop | SDFGI, VoxelGI, SSAO/SSIL/SSR, volumetric fog, TAA, FSR | | **Compatibility** | `gl_compatibility` | Web (the only option there), very old GPUs | Everything Mobile lacks (though SSAO arrives in 4.6), plus FXAA/SMAA and MetalFX; glow is a simplified version | Set **Project Settings → Rendering → Renderer → Rendering Method**. Platform overrides already exist: `rendering/renderer/rendering_method.mobile` defaults to `mobile` and `rendering_method.web` to `gl_compatibility`, so one project can run Forward+ on desktop and Mobile on phones — but then **test the look on both**, because effects silently disappear on the lighter renderer. A settings menu must hide options the running renderer cannot honor. The later sections use this helper: ```gdscript func is_forward_plus() -> bool: # Godot 4.4+: prefer RenderingServer.get_current_rendering_method(), which also sees # the --rendering-method CLI flag and the automatic fallback on unsupported hardware. return ProjectSettings.get_setting_with_override("rendering/renderer/rendering_method") == "forward_plus" ``` ```csharp public static bool IsForwardPlus() { // Godot 4.4+: prefer RenderingServer.GetCurrentRenderingMethod(), which also sees // the --rendering-method CLI flag and the automatic fallback on unsupported hardware. return ProjectSettings.GetSettingWithOverride("rendering/renderer/rendering_method").AsString() == "forward_plus"; } ``` Short feature table: see the renderer comparison in **3d-essentials** (`references/renderer-comparison.md`). --- ## 2. Lighting Strategy Decide where light comes from before placing lights. Baked light is nearly free at runtime on every renderer; real-time GI is Forward+ only. | Scene | Forward+ | Mobile | Compatibility | |---|---|---|---| | Static level, fixed sun | LightmapGI + real-time sun shadows | LightmapGI | LightmapGI | | Day/night cycle, large outdoor | SDFGI | Sky ambient + DirectionalLight3D | Sky ambient + DirectionalLight3D | | Small dynamic interiors | VoxelGI | LightmapGI + ReflectionProbes | LightmapGI + ReflectionProbes | | Procedural levels (nothing to bake) | SDFGI | Ambient + a few shadowed lights | Ambient + few unshadowed lights | **Light budgets** | Renderer | Limit | Setting | |---|---|---| | Forward+ | 512 clustered elements (omni + spot lights + decals + reflection probes) in view | `rendering/limits/cluster_builder/max_clustered_elements` | | Mobile | 8 omni + 8 spot lights per mesh | — split large meshes so lights don't compete | | Compatibility | 8 omni + 8 spot lights per object; 32 renderable lights per type (omni, spot) per frame | `rendering/limits/opengl/max_lights_per_object`, `max_renderable_lights` | Rules that hold everywhere: - **Shadows are the expensive part, not lights.** Keep one shadowed `DirectionalLight3D`; turn `shadow_enabled` off on fill lights and small props. - **Bake what doesn't move.** Set static lights' `light_bake_mode` to Static so the lightmap carries them and they cost nothing at runtime. Baking needs a Forward+ or Mobile capable editor; the baked result plays on all three renderers. - **Fade distant lights** with `distance_fade_enabled` instead of leaving dozens active. Light and GI node setup: **3d-essentials** (Sections 3 and 5). --- ## 3. Anti-Aliasing | Method | Cost | Smooths | Renderers | Notes | |---|---|---|---|---| | MSAA 2×/4×/8× (`msaa_3d`) | Medium–high | Geometry edges | All three | 2× or 4× is usually the sweet spot; no help with shader/texture shimmer | | FXAA (`screen_space_aa`) | Low | Everything, blurry | Forward+, Mobile | Cheapest whole-image option | | SMAA (Godot 4.5+) | Low–medium | Everything, sharper than FXAA | Forward+, Mobile | Tune `rendering/anti_aliasing/quality/smaa_edge_detection_threshold` | | TAA (`use_taa`) | Medium | Everything incl. specular shimmer | Forward+ only | Ghosting on particles and skinned meshes | | FSR 2 at scale `1.0` | Medium | Like TAA, sharper | Forward+ only | Set `scaling_3d_mode` to FSR 2 and `scaling_3d_scale = 1.0` | The project settings (`rendering/anti_aliasing/quality/*`) are read once at startup. To change AA from a settings menu, set the root viewport: ```gdscript func apply_antialiasing(msaa: Viewport.MSAA, use_fxaa: bool, use_taa: bool) -> void: var vp := get_viewport() vp.msaa_3d = msaa vp.screen_space_aa = Viewport.SCREEN_SPACE_AA_FXAA if use_fxaa else Viewport.SCREEN_SPACE_AA_DISABLED vp.use_taa = use_taa and is_forward_plus() ``` ```csharp public void ApplyAntialiasing(Viewport.Msaa msaa, bool useFxaa, bool useTaa) { Viewport vp = GetViewport(); vp.Msaa3D = msaa; vp.ScreenSpaceAA = useFxaa ? Viewport.ScreenSpaceAAEnum.Fxaa : Viewport.ScreenSpaceAAEnum.Disabled; vp.UseTaa = useTaa && IsForwardPlus(); } ``` Setting an unsupported mode does not crash; Godot ignores it and logs a warning (an editor error on 4.3–4.5). Gate the options in the UI instead. 2D has its own `msaa_2d`, which smooths 2D geometry edges such as lines and polygons. --- ## 4. 3D Resolution Scaling Render 3D below native resolution and upscale it — the biggest single GPU saving on fill-rate-bound scenes. 2D and UI stay at native resolution. | `scaling_3d_mode` | Renderers | Notes | |---|---|---| | Bilinear | All | Also the only mode that supersamples (`scale > 1.0`) | | FSR 1 | Forward+ | Spatial upscaler; `rendering/scaling_3d/fsr_sharpness` (default `0.2`, lower = sharper) | | FSR 2 | Forward+ | Temporal; replaces TAA; best quality per pixel | | MetalFX Spatial / Temporal (Godot 4.4+) | Apple Metal: spatial on Forward+/Mobile, temporal on Forward+ | Falls back to FSR when unavailable | | Nearest (Godot 4.7+) | All | Crisp pixel look; use integer divisors (`0.5`, `0.333`, `0.25`) | Offer presets rather than a raw slider. These are AMD's FSR 1 scales, which work as well with FSR 2: **Ultra Quality 0.77, Quality 0.67, Balanced 0.59, Performance 0.5**. ```gdscript const FSR_PRESETS := {"ultra_quality": 0.77, "quality": 0.67, "balanced": 0.59, "performance": 0.5} func apply_upscaling(preset: String) -> void: var vp := get_viewport() if preset == "native": vp.scaling_3d_mode = Viewport.SCALING_3D_MODE_BILINEAR vp.scaling_3d_scale = 1.0 return vp.scaling_3d_mode = Viewport.SCALING_3D_MODE_FSR2 if is_forward_plus() else Viewport.SCALING_3D_MODE_BILINEAR vp.scaling_3d_scale = FSR_PRESETS.get(preset, 1.0) ``` ```csharp private static readonly System.Collections.Generic.Dictionary FsrPresets = new() { { "ultra_quality", 0.77f }, { "quality", 0.67f }, { "balanced", 0.59f }, { "performance", 0.5f }, }; public void ApplyUpscaling(string preset) { Viewport vp = GetViewport(); if (preset == "native") { vp.Scaling3DMode = Viewport.Scaling3DModeEnum.Bilinear; vp.Scaling3DScale = 1.0f; return; } vp.Scaling3DMode = IsForwardPlus() ? Viewport.Scaling3DModeEnum.Fsr2 : Viewport.Scaling3DModeEnum.Bilinear; vp.Scaling3DScale = FsrPresets.GetValueOrDefault(preset, 1.0f); } ``` Lower scales blur textures; on Forward+ and Mobile, Godot lowers the mipmap bias automatically by `log2(scale)` to compensate (plus `-0.5` with TAA). --- ## 5. SubViewports and Render Targets Each active `SubViewport` is another full render. Set `render_target_update_mode`: `UPDATE_WHEN_VISIBLE` (live views), `UPDATE_ONCE` (snapshots), `UPDATE_DISABLED` (pause), `UPDATE_ALWAYS`. > See [references/subviewports.md](references/subviewports.md) for UI display, per-viewport settings, and icon capture. --- ## 6. Shader Compilation Stutter The first time a material, light combination, or effect is drawn, the GPU pipeline is compiled, which can hitch a frame. - **Godot 4.4+** compiles pipelines in the background with ubershaders on Forward+ and Mobile, which removes most of this hitching. Projects on 4.3 benefit from upgrading. - The **pipeline cache** (`rendering/rendering_device/pipeline_cache/enable`, on by default) makes the second launch faster than the first. - The **Shader Baker** (Godot 4.5+, export preset option) shortens the first launch on D3D12 and Metal — see **shader-basics** and **export-pipeline**. - On Compatibility, and for effects that still hitch, show each material once behind a loading screen (spawn the effect off-camera or at zero scale for a frame). --- ## 7. Measuring Read rendering stats from `Performance` and switch `Viewport.debug_draw` to see where the cost is. ```gdscript func _process(_delta: float) -> void: $Stats.text = "draw calls %d | primitives %d | VRAM %.0f MB" % [ Performance.get_monitor(Performance.RENDER_TOTAL_DRAW_CALLS_IN_FRAME), Performance.get_monitor(Performance.RENDER_TOTAL_PRIMITIVES_IN_FRAME), Performance.get_monitor(Performance.RENDER_VIDEO_MEM_USED) / 1048576.0, ] func _unhandled_input(event: InputEvent) -> void: if event.is_action_pressed("debug_overdraw"): var vp := get_viewport() vp.debug_draw = Viewport.DEBUG_DRAW_DISABLED if vp.debug_draw == Viewport.DEBUG_DRAW_OVERDRAW else Viewport.DEBUG_DRAW_OVERDRAW ``` ```csharp public override void _Process(double delta) { GetNode