**Based on an article written by Laurent Belcour, Alban Fichet, Pascal Barla.**

  
**What is a fluorescent material ?**



To understand fluorescence, we must first define color as light at a specific wavelength. When light hits a normal object, it absorbs some wavelengths and reflects others. For example, an object that reflects light around 700nm appears red. Standard materials can only reflect existing light, they cannot change its wavelength or produce new visible light.



Fluorescent materials behave differently: they absorb light and re emit it at a longer wavelength. Blue light at 450nm can be absorbed and re-emitted as green light at 550nm. This process, called the Stokes Shift, makes fluorescent objects appear brighter because they convert higher-energy or invisible light into visible light, effectively adding to what we see.



**How do render fluorescent materials ?**



Well, that used to be a problem, especially if you wanted to render it in real time. Until recently, you essentially had to fake it using emissive materials, bloom, and other post-processing techniques. This is because an accurate physical render would require representing light spectrally (typically a few dozen spectral bands rather than the familiar 3-channel RGB), then computing how energy absorbed in each band is re-emitted into other bands, and finally converting the resulting spectrum back to RGB. This entire process is extremely computationally expensive and generally impractical for real-time rendering.



A few months ago, a paper titled “A Fluorescent Material Model for Non-Spectral Editing & Rendering” by Laurent Belcour, Alban Fichet, and Pascal Barla showed that physically accurate fluorescence can, in fact, be rendered in real time. Rather than relying on full spectral rendering, their approach reformulates fluorescence in a way that is compatible with standard RGB pipelines.



Skipping the heavy mathematics, the core idea is to approximate the spectral absorption and re-emission behavior using Gaussian functions. These Gaussians describe how incoming light energy is absorbed around certain wavelengths and re-emitted at longer ones, while preserving energy conservation. This way allows the expensive spectral integration to be reduced analytically into compact matrices that can be evaluated efficiently at runtime.



**In Godot ?**



Well, that’s the complicated part: the implementation. After spending days understanding the original paper, I spent several more days trying to create (or rather, debug) a shader to implement the method. It was particularly challenging because this approach is fairly new, and no major engines (Unreal, Unity, Blender, etc.) currently provide an implementation of it, or even of fluorescence rendering in general (tbf, my google search skills are shit, so maybe I just didn't find it). As a result, I only had the theoretical math to guide me. But as you can see in the video, it works.



The entire method is essentially wrapped into a single shader (along with a few shader includes), where you can provide a base albedo and adjust a set of parameters to control how fluorescent the material appears.



**The limitation of my implementation.**



Now, my implementation is fairly limited. First, there are some heavy calculations happening inside the vertex and fragment shaders that could probably be moved to a script and passed to the shader as uniforms. However, since this is only a first implementation, I chose to keep everything inside the shaders, and Godot does not provide (to my knowledge) any kind of shader initialization function to run computations once per material.



Additionally, the paper strongly focuses on artist-friendly ways of editing fluorescent materials (such as a dedicated color palette and editing workflows), which I did not implement because it was outside the scope of a quick first implementation.



I am sure that others will be able to take this further and address these limitations, but for now, I am satisfied with what I have achieved.



Source code : [https://github.com/ykar-rux/fluorescent-materials-godot-shaders](https://github.com/ykar-rux/fluorescent-materials-godot-shaders)



REFERENCE ARTICLE :

Laurent Belcour, Alban Fichet, Pascal Barla. A Fluorescent Material Model for Non-Spectral Editing & Rendering. 10.1145/3721238.3730721 .  hal-05267431

A Fluorescent Material Model for Non-Spectral Editing & Rendering in Godot.