Ultimate Retro Shader Collection

Shaders bringing 5th-gen console aesthetics to Godot 4.

Features

• Vertex snapping and affine texture mapping (as seen on PlayStation and Saturn)
• 3-point texture filtering (as seen on Nintendo 64)
• Distance-based, per-vertex texture LOD and fog
• Metallic and shiny shaders
• 3D sprite shaders (shaded/unshaded, single/double-sided)
• Scrolling sky shader (think Mario 64)
• Screen-reading dithering and fade shaders
• Create custom spatial shaders using macros
• Compatible with all rendering backends

Credits

URSC is built upon various shaders from the Godot community. It would not have been possible without the work done by:

• MenacingMecha
  • This collection derives primarily from his PSX and N64 shaders.
• Zacksly
  • The Shiny shaders are adapted from their PSX Pickup Shader for Godot 3.
• tentabrobpy
  • The Flat Sky shader is adapted from their N64 Style Skybox shader on Godot Shaders.

Getting Started

Check out these articles from the Godot documentation (if you haven't already) before getting started:

• Available 3D Formats
• Introduction to Shaders
• Shader Materials
• Shading Reference

There are a few different places you can download the collection from:

• the Releases page here on GitHub
• the itch.io page
• the Godot Asset Library
  • If you download URSC through the editor interface, uncheck "ignore asset root" to place the collection in your addons folder.

Of course, there's no need to "enable" URSC through the project settings menu, as it isn't a plugin. However, some additional setup is needed once URSC has been downloaded before you can use the shaders.

URSC depends on a number of global uniforms which need to be added to your project settings. An editor script, setup.gd is provided with your download and can be executed through the editor to add these uniforms quickly.

After running this script once (or adding the uniforms to project settings manually), you'll be ready to use URSC shaders in your project.

Upgrading From v1.3- to v1.4+

In version 1.4.0, URSC's spatial shaders were organized into subfolders to make it easier to select them from the file system view. This means attempting to upgrade by deleting the old version and copying in the new one will break your materials!

In versions prior to 1.4.0, URSC's spatial shaders were all placed under the ursc/spatial directory, like so:

To upgrade safely, you must first reorganize the existing shaders in your project to match the layout of newer versions. This ensures the references to them in your materials (and anywhere else) are still valid after the upgrade, preventing you from needing to fix them all manually. Be sure to do any file moving and renaming inside Godot.

Notice how the Basic shaders have been placed into their own subfolder -- you need to do this for the Basic, Metallic, Shiny, Sprite and Standard shaders. Leave common.gdshaderinc and flat_sky.gdshader where they are.

After you've reorganized your existing shaders, you can download the latest version and copy over the new files.

One last thing: in 1.4.0, sprite.gdshader was renamed to sprite_shaded.gdshader. If you correctly followed the previous instructions and then copied over the new files, you'll see something like this in the sprite folder:

sprite_shaded.gdshader is redundant, so just delete it and rename the old sprite.gdshader to sprite_shaded.gdshader. Then, open the file and change the #include path from "common.gdshaderinc" to "../common.gdshaderinc".

All URSC versions after 1.4.0 will remain organized this way, so there'll be no need to take these specific upgrade steps again.

CanvasItem Shaders

dithering.gdshader

Apply this shader to the material of a CanvasItem node, like a SubViewportContainer. Then, supply a dithering pattern texture and set your preferred color depth. This shader reduces the color depth of the CanvasItem, limiting the number of colors used for rendering, while applying dithering (if a pattern texture is supplied) to minimize the resulting color banding.

In the example above, the shader is applied to a SubViewportContainer with a SubViewport rendering a 3D scene. On the left, the shader is disabled.

fade.gdshader

You can use this shader to create a PSX-like "fade-overlay" for scene or menu transitions -- just apply it to the material of a ColorRect node with its layout preset set to "Full Rect." If you're using the dithering shader on a SubViewportContainer, add this ColorRect as a child so it renders above the container's SubViewport.

The mode uniform exposed by this shader controls the blending mode to use; a value of -1 for subtractive (to fade to black), and 1 for additive (to fade to white).

Fading in and out is done by setting the opacity of the node the shader's applied to. With a ColorRect, changing color.a, modulate.a and self_modulate.a all work.

In the example above, both tiles are being dimmed by an overlay with an alpha value of 25. On the left, the shader is disabled (but the overlay is still being rendered). Notice how much deeper and darker the colors are on the right; this effect is due to subtractive blending. With subtractive blending, the lightest colors take the longest to fade out, and vice versa with additive blending.

Spatial Shaders

Most of the spatial shaders in the collection are organized by category. For example, under ursc/spatial/standard you'll see standard_opaque.gdshader and standard_transparent.gdshader.

Here's a quick breakdown of the different categories. If you'd like to know what their uniforms do, see the complete list of uniforms in common.gdshaderinc further below.

Category	Description	Example
Basic	For simple models with no texture, just vertex colors. Prefer this over a Standard shader for a less cluttered inspector.
Standard	For the majority of models. Supports mixing an albedo texture with vertex colors.
Metallic	Gives models a metallic or reflective look. Be sure your model is smooth-shaded for best results. NOTE: the texture in the example is not generated by the shader -- you must supply your own texture.
Shiny	Gives models a shiny or glossy look. Be sure your model is flat-shaded for best results. No albedo texture or vertex colors -- you must set the color of the model with the albedo_color uniform.
Sprite	Designed to be applied to a MeshInstance3D (with a QuadMesh or PlaneMesh) or an AnimatedSprite3D. Uses alpha scissor transparency and supports billboarding. See Tips and Tricks below for a guide on how to set up an AnimatedSprite3D with a Sprite shader.

flat_sky.gdshader

This is a special shader that can be used to create a sort of "sky background" which scrolls as the camera moves. To use it:

1. Create a new MeshInstance3D in your scene. Consider keeping it aligned with your camera by adding it as a child of the camera. Name it something like "Sky."
2. Add a new BoxMesh to the Sky node. Set its size to something very large in all axes, like 1,000 units. You want it to cover your entire scene and be large enough that distant surfaces are culled before the sky "clips" over them. Enable the BoxMesh's flip_faces option.
3. Add a new ShaderMaterial with flat_sky.gdshader to the Sky node. Supply a texture to the albedo_texture uniform and adjust uv_offset, uv_scale and uv_scroll_speed to your liking.

common.gdshaderinc

This is the foundation of all the spatial shaders in the collection (except for flat_sky.gdshader). It makes extensive use of preprocessor macros to determine the render mode, uniforms and functionality of whatever shader file includes it.

If you need your model to look a certain way, and there isn't a shader already provided by the collection which achieves that look, you can configure your own shader file by including common.gdshaderinc and defining some macros. For instance, suppose you want to completely disable lighting (ambient, directional and fog) for a particular model. Being this isn't a very common case, URSC does not provide a shader file to accomplish this -- however, you can create your own shader file which does.

// my_custom_shader.gdshader
shader_type spatial;

// Macro definitions must go first.
// The ones you define depend on your intended look.
// These are for the example above.
#define AMBIENT_LIGHT_DISABLED
#define UNSHADED
#define FOG_DISABLED

// If you save this shader file to disk next to common.gdshaderinc:
#include "common.gdshaderinc"

// OR, if this shader is embedded in a material:
#include "res://path/to/common.gdshaderinc"

Of course, you are free to edit common.gdshaderinc itself. You can define some macros at the top to change how all URSC shaders work.

Macros

These are all the macros which affect the compilation of common.gdshaderinc.

Uniforms

These are all the uniforms compiled in common.gdshaderinc depending on the macros that have been defined in a shader file before its inclusion.

Tips and Tricks

Models

Keep your models low-poly, but if you're going for a PSX or Saturn look, consider subdividing textured surfaces to mitigate the warping caused by affine texture mapping.

Smooth vs. Flat Shading

The Metallic and Shiny shaders require models to be smooth-shaded and flat-shaded, respectively. Godot, and subsequently URSC, don't expose this property. Instead, you need to set it in your modeling program. If you're using Blender to create your models, you can set this by right-clicking your model in Object Mode and choosing Shade Smooth for smooth shading or Shade Flat for flat shading. You can also control this property per-face by right-clicking on the face on Edit Mode. Check out this page from the Blender documentation to learn more.

Textures

Keep your textures low-resolution. Anywhere between 16x16 to 64x64 would be a good range for texture sizes. If you're going for an N64 look, stay within the 32x32 to 64x64 range so the 3-point texture filtering stands out more.

To ensure your textures aren't automatically filtered by Godot, open project settings, and under Rendering/Textures, set all filter options to Nearest.

Lighting

The key to lighting a scene for a retro-3D game is to avoid relying heavily on real-time lighting with Light3D nodes and shadows. The PSX, Saturn and N64 all had limited support, if any, for real-time lighting, so artists used vertex colors to feign light in a scene.

While you can get away with using a DirectionalLight3D node and ambient light from a WorldEnvironment, you should avoid using too many SpotLight3D and OmniLight3D nodes.

Godot versions prior to 4.4 do not have vertex-based lighting. Instead, they only have pixel-based lighting, which detracts from the retro look.

Here's a comparison. On the left, you can see the result of pixel-based lighting, which creates a smooth circle. This may look nicer in the image, but that's the problem -- it's too nice. For low-poly, jagged models, a more fitting choice would be lighting that complements their rough edges, which would be the vertex-based lighting on the right.

URSC shaders use vertex lighting by default. If you'd rather use pixel lighting, you can remove the vertex_lighting render mode option from the top of common.gdshaderinc. Likewise, if you want shadows, remove the shadows_disabled option.

Sprites

It's possible to apply the Sprite shaders to AnimatedSprite3D nodes, but it takes a little bit of setup:

1. Set up the AnimatedSprite3D's SpriteFrames resource like normal.
2. Add a ShaderMaterial to the node's Material Override slot (NOT the Material Overlay slot), and supply it the Sprite shader of your choice. You'll notice the AnimatedSprite3D's texture disappear -- this can be fixed with some code.
3. Add the following script to the AnimatedSprite3D (with a little translation, this works in C# too):

@tool
extends AnimatedSprite3D


@onready
var shader_material: ShaderMaterial = material_override as ShaderMaterial


func _process(delta: float) -> void:
	shader_material.set_shader_parameter(
		"albedo_texture", sprite_frames.get_frame_texture(animation, frame))

	shader_material.set_shader_parameter("billboard_mode", billboard)