This is a shader for particles to create a bokeh-esque depth of field effect. It works by essentially "precomputing" the various amounts of blur, instead of blurring in real time. Since the particles are radial, we can store only a single row of pixels per blur level, and the shader will distort the UV coordinates to turn it into a circle. This gives us a very compact 512x1024 texture that stores 1024 different blur levels, which can be smoothly interpolated.

A shader that changes sprite colors based on provided palette. Top row of palette are color references; these colors are sampled from the original image and replaced by colors from subsequent rows. The shader will cycle between palette rows, resulting in an animation. By default, the reference row is also part of the animation, but it can be skipped. 2-row palette with first row skipped results in a static palette swap. The shader will automatically adjust to palette size, so it requires minimal setup (just drop palette image and it works). It uses integer comparison for the colors, so it's fast and perfectly accurate. I also made sure that the code is optimized. You can use the alpha from palette colors or keep the original. When using palette alpha, keep in mind that transparent pixels are sampled too. Only RGB values are sampled, alpha is used only for final image. Warning: Be sure to set texture_filter property to Nearest. Also, while the palette size is only limited by maximum texture size, having too many columns (hundreds/thousands) will impact performance. The new version comes with a PaletteMaterial resource that has improved performance. You can assign it as a material and put palette into palette property (not the shader params). It has some limitations, but it's faster. The addon also comes with a tool that can generate palette from image. Make sure that the plugin is enabled, then go to Project -> Tools -> Generate Palette... and pick a source image file. Check the example project for some usage examples or check the repo for more details.

A shader that changes sprite colors based on provided palette. Top row of palette are color references; these colors are sampled from the original image and replaced by colors from subsequent rows. The shader will cycle between palette rows, resulting in an animation. By default, the reference row is also part of the animation, but it can be skipped. 2-row palette with first row skipped results in a static palette swap. The shader will automatically adjust to palette size, so it requires minimal setup (just drop palette image and it works). It uses integer comparison for the colors, so it's fast and perfectly accurate. I also made sure that the code is optimized. You can use the alpha from palette colors or keep the original. When using palette alpha, keep in mind that transparent pixels are sampled too. Only RGB values are sampled, alpha is used only for final image. Warning: Be sure to import all used textures with "filter" disabled, otherwise the shader won't work properly. Also, while the palette size is only limited by maximum texture size, having too many columns (hundreds/thousands) will impact performance. The shader comes bundled with a file PaletteGenerator.gd. It's an editor script for quick generating palettes from images. Select a Sprite or any node with texture property and in Script Editor do File -> Run to generate a palette template. Check the example project for some usage examples or check the repo for more details.

This intends to solve the problem that the SSR (Screen Space Reflection) implementation of Godot 4 is limited to surfaces that are not transparent. For a water shader it is often necessary to support both transparency and reflections. In a lot of cases this can be worked around with reflection probes, but the need for SSR stands, especially because SSR works quiet well for water. The only solution is to write a custom SSR shader for that matter. This is a full water shader implementation supporting: - Screen Space Reflection - Transparency - 3D waves - Edge detection - Normal textures for a varied surface - Fake refraction I try to keep the latest version up to date with latest godot version, but in the repository are older branches named after the godot version they were created with. Older branches might not contain all features/bugfixes.

This plugin gives you the ability to have lens flare in your 3d projects. And it's procedural too; meaning you don't need to assign actual lens flare textures as long as you have a bright spot in your screen. Just install the addons folder to add it to your project. Find out more here: https://github.com/SIsilicon/Godot-Lens-Flare-Plugin

An that renders 100 000 stars in realtime, with low performance cost. It's an alternative to using a skybox, and also may be relevant to anyone making a space game. Features: - Stars are rendered positionally in 3D, allowing you to fly around and see stars go by. - Exact position, luminosity, and temperature of each star can be configured by you. - Physically based light model: Using a Point Spread Function (PSF), rather than a texture that grows or shrinks with distance/brightness. - Based on MultiMeshInstance3D for performance. - Uses a trick to avoid being clipped by the far plane, to let stars be very far away. - Works with Forward+, Mobile, and Compatibility renderers. - Comes with a random star generator based on main sequence stars (classes M through O).

Port of libretro's CRT Lottes GLSL shader

This asset contains a set of multicolored dithering shaders for Godot 4. The shaders work by replacing the colors of 2D nodes, 3D nodes or the entire screen in the case of postprocessing. The colors are replaced with a pre-planned dithering pattern of one or more colors taken from a "dither palette" image. The resulting dither mix roughly approximates the original color, giving the scene an old-school retro look.

Three shaders to generate 3D animated planets and stars in Godot 4: - Planet body generation shader - Cloud generation shader - Atmosphere generation shader The project contains seven example planets: - No atmosphere planet - Terrestrial planet - Ice planet - Lava planet - Sand planet - Gaseous planet - Star FAQ and more information: https://naejimer.itch.io/godot-3d-planet-generator

Simple shader that allows for create animations similar to palette cycling. Make a grayscale sprite and a gradient, put a ShaderMaterial on the sprite and assign the gradient and it will animate. See the example project for usage. Caveats for best effect: - the node with shader should have texture_filter set to Nearest - number of colors in the gradient and base texture should match - gray shades in the base texture should be uniformly distributed (i.e. with equal increments between colors) Check out the repo page for animated example.

Simple shader that allows for create animations similar to palette cycling. Make a grayscale sprite and a gradient, put a ShaderMaterial on the sprite and assign the gradient and it will animate. See the example project for usage. Caveats for best effect: - the base texture should have filter disabled - number of colors in the gradient and base texture should match - gray shades in the base texture should be uniformly distributed (i.e. with equal increments between colors) Check out the repo page for animated example.

EasyBlend is a shader which allows you to set a custom blending mode for your canvas item. Included are many of the blending modes you will find in common image editors. The blend is applied based on a 2d lookup table per color channel in the form of an input texture. This allows plenty of blends in addition to the ones shown, such as colored fogs and underwater effects. Update 1.1 (18 Sep 2018): Added an "Enabled" property and fixed the default intensity to 1.0.

Emulator-style pixel upscaling algorithm. Ported from the SameBoy to Godot 3+. Works similarly to hqx at arbitrary precision.

Simple material shader with added debanding noise for use with GLES2 renderer that does not support full-screen debanding

The Godot Sprite Shader Mixer is an add-on for Godot that allows Sprite2D and AnimationSprite2D (Label and ColorRect since version 1.2.0) nodes to blend shaders from a collection of available shaders. Users can select and add shaders to sprites dynamically, automatically downloading them from GitHub as needed. The plugin handles shader generation and blending, resulting in a texture that combines all selected shaders. The add-on allows you to download a set of shaders from a collection (the collection is public on GitHub and you can collaborate on adding new ones). Once downloaded the tool will mix them in a unique shader for your sprite. Since then you can manipulate the shader as usual, customizing the input variables of each shader. version 1.2.0 Update: - Added Label and ColorRect nodes to add shader mixer - default opacity parameter for all shaders Version 1.1.0 Update: - Added a Search Manager Window to easily select the shader Basic instructions: - You only need to download the addon folder to your project - Active the plugin - Select a Sprite2D or AnimatedSprite2D node (also Label and ColorRect since version 1.2.0) - At the right, you will see a button to create a shader mixer - Press the button to Sync the list of available shaders (ensure it is pressed, if not the combo will be empty) - Select a Shader and download it (repeat this if you want to merge several shaders) - Go to your material->Shader->Parameters to tune the shader FULL INSTRUCTIONS AND EXAMPLES HERE: https://github.com/spheras/godot-sprite-shader-mixer#godot-sprite-shader-mixer IMPORTANT: Those shaders are compatible with GODOT 4.1, but not older versions.

Shader to animate a fish without armature or blend shapes. This shader is strongly inspired by the fish shader used in ABZU and demonstrated by Matt Nava in his presentation at GDC 2017. The repository contains only what is absolutely necessary to demonstrate the shader. The shading of the object has to be refined. credits: Fish Perch by holmen released under Creative Commons Zero (Public Domain)

There are some basic shaders, as a blur filter, a mosic filter, an edge filter and others. You can use as your shader in your project, after download the shaders.

Godot Stereo 3D adds stereoscopic 3D support to Godot Engine (red/cyan anaglyph 3D glasses) in game and in editor. Works as a screen-space shader based on the depth buffer (2D to 3D conversion) so is very fast. Requires GLES3. The best 3D glasses to use with this add-on are called Pro-Ana (red/cyan). They make plastic and paper versions and are very affordable. - Place the Stereo3D.tscn scene inside your main game tree. - If used in combination with Godot Super Scaling, the Stereo3D node should be inside your game world. - In the Stereo3D inspector settings, check the Enable box to turn stereo on or off in game or in editor. - Set Z Near to the z_near of your camera. - Set Z Far to the z_far of your camera. - The Separation controls the distance between the eyes. 0 is no distance and 100 is the maximum. - Setting Separation too high may cause discomfort, so leaving it around the default of 50 is recommended. - The Convergence controls the distance to the parallax plane the eyes are focused on (on the z axis). - Higher values for Convergence will result in a greater 3D effect, but setting it too high may cause discomfort. - The Pop Out setting controls the overlap between the left/right images. This makes the image more 3D or more comfortable. - Typically lower Pop Out settings are easier to focus on. However, if you use transparent surfaces or reflections (e.g. glass windows) then it is better to set Pop Out to the maximum so that the transparent pass closer matches the 3D render. - If you have overlapping transparent surfaces in your game, you need to set the Render Priority of the transparent material to 1 or above (for example, in a racing game, viewed from the 3rd person, the front window could have Render Priority of 0 and the back 1). - For cut-out textures (like decals or grass) the Render Priority should be above 0, the Depth Draw Mode set to Opaque Pre-Pass, Transparent set to false, and enable Use Alpha Scissor on the material. If the decal texture is on top of a transparent material (e.g. a sticker on a window) then the Depth Draw Mode must be set to Never. - If you use reflection probes, the reflections will be captured with the results of the post-process and will be incorrect. In these cases, you should leave the Stereo3D disabled in game, then on _ready() in your game, wait a certain amount of time (enough for the captures to take place) before enabling Stereo3D. - You must control whether Stereo3D is enabled or not within the inspector settings for the add-on. The eye icon in the tree is disabled by design. - Note, since this is a post-process effect (2D to 3D conversion) and not a true dual camera stereo render, you may see some artifacts (typically halos around objects or duplicated textures). This is unavoidable with a screen-space shader, and is why it performs so fast. Changing the Stereo3D settings so that the 3D effect is less can mitigate some of these artifacts.

Compute Shader Studio is an addon for Godot Engine that enables you to write Compute Shaders in a minute.

This addon contains two shaders meant to be used as a material for terrain objects. The shaders support color, normal, roughness and metallic maps. They also provide a tile scrambling feature that gets rid of obvious repeated patterns. You can also stack several different terrain shader on top of each other and use masks to blend between them.

Original Addon for Godot 3 by CaptainProton42 ported to Godot 4 A flexible toon shader for the Godot Engine with many features: 🤸Flexibility through parameters like number of cuts/bands, steepness, and wrap 🎨 Supports custom color ramps 🌈 Affected by the colors of light sources and ambient light in the scene 💡 Allows for multiple light sources ⛱️ Supports shadows and attenuation ✨ Visual extras like specular reflections and rim lighting 🖼️ Supports textures for albedo and specular New: ✏️ Experimental toon hatching shader (available as a separate material)

A gameboy dot-matrix retro post-processing filter for your games. Enjoy.

Split texture, stochastic sampling, triplanar projection shader for Godot4

Force Field shader that uses depth buffer to find intersection with other meshes and a rgb texture to draw some animated details.