I created a sample post-processing shader to illustrate some of the information that can be obtained within a post-processing shader in Godot. You can find the code here:
The Post Process Ref Grid shader provides several options for overlaying a coordinate grid onto the surface of the world and visualizing other data points available within post-processing shaders (roughness, depth, distance to camera, normals). This shader can serve as a handy reference for how to access certain types of data within a post-processing shader:
Original pixel color
Original pixel roughness
Normal in view space or world space
Pixel position in view space or world space
Camera position in world space
The following image shows the world space grid overlay.
This next image has a view space grid overlay. The thicker red, green, and blue lines with gradients mark the area from 0.0 to 1.0 to make it easier to see where the origin of the axes are located.
And, here's the full source of the shader for quick reference, but I'd recommend viewing the source file on github to make sure you are seeing the latest version:
shader_type spatial;
render_mode skip_vertex_transform, unshaded;
uniform sampler2D screen_texture: hint_screen_texture, filter_nearest;
uniform sampler2D normal_texture: hint_normal_roughness_texture, filter_nearest;
uniform sampler2D depth_texture: source_color, hint_depth_texture, filter_nearest;
uniform int grid_mode = 1;
uniform vec3 grid_origin = vec3(0.0);
uniform float grid_scale = 1.0;
uniform float depth_min = 0.0;
uniform float depth_max = 50.0;
uniform uint mode = 0;
void vertex(){
POSITION = vec4(VERTEX, 1.0);
}
vec3 get_grid_color(vec3 pos, float scale, vec3 original_color) {
pos -= grid_origin;
vec3 cell_pos = fract(pos / scale);
float thickness = 0.05 / scale;
vec3 grid_color = vec3(0.0);
grid_color.x = step(cell_pos.x, thickness);
grid_color.y = step(cell_pos.y, thickness);
grid_color.z = step(cell_pos.z, thickness);
if (pos.x >= 0.0 && pos.x < 1.0) {
grid_color.x = pos.x;
}
if (pos.y >= 0.0 && pos.y < 1.0) {
grid_color.y = pos.y;
}
if (pos.z >= 0.0 && pos.z < 1.0) {
grid_color.z = pos.z;
}
if (grid_color == vec3(0)) {
grid_color = original_color;
}
return grid_color;
}
float map_depth_to_depth_ratio(float depth) {
float depth_ratio = clamp((depth - depth_min) / (depth_max - depth_min), 0.0, 1.0);
return depth_ratio;
}
void fragment() {
vec3 original_color = texture(screen_texture, SCREEN_UV).rgb;
vec4 normal_color = texture(normal_texture, SCREEN_UV);
vec3 normal_in_viewspace = normal_color.xyz * 2.0 - 1.0;
float roughness = normal_color.w;
float depth_value = texture(depth_texture, SCREEN_UV).x;
if (depth_value < 1.0) {
vec3 ndc = vec3(SCREEN_UV * 2.0 - 1.0, depth_value);
vec4 view_vec = INV_PROJECTION_MATRIX * vec4(ndc, 1.0);
vec3 pos_in_viewspace = view_vec.xyz / view_vec.w;
vec3 pos_in_worldspace = (INV_VIEW_MATRIX * vec4(pos_in_viewspace, 1.0)).xyz;
mat3 view_to_world_normal_mat = mat3(
INV_VIEW_MATRIX[0].xyz,
INV_VIEW_MATRIX[1].xyz,
INV_VIEW_MATRIX[2].xyz);
vec3 normal_in_worldspace = view_to_world_normal_mat * normal_in_viewspace;
vec3 camera_pos_in_worldspace = (INV_VIEW_MATRIX * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
float distance_to_camera = length(camera_pos_in_worldspace - pos_in_worldspace);
switch (mode) {
case 0: ALBEDO = original_color; break;
case 1: ALBEDO = vec3(0.0); break;
case 2: ALBEDO = vec3(roughness); break;
case 3: ALBEDO = normal_in_worldspace; break;
case 4: ALBEDO = normal_in_viewspace; break;
case 5:
ALBEDO = vec3(map_depth_to_depth_ratio(-pos_in_viewspace.z));
break;
case 6:
ALBEDO = vec3(map_depth_to_depth_ratio(distance_to_camera));
break;
};
if (grid_mode == 1) {
ALBEDO = get_grid_color(pos_in_worldspace, grid_scale, ALBEDO);
}
else if (grid_mode == 2) {
ALBEDO = get_grid_color(pos_in_viewspace, grid_scale, ALBEDO);
}
}
else {
ALBEDO = original_color;
}
}
