Minimal Compute Shader Example

[clayjohn]

Your Godot version:
4.0 dev

Issue description:
Before 4.0 alpha releases we will need to put together some tutorials on using the new rendering device API. For starters we should write a compute shader tutorial that explains the below code:

func _ready():
	
	# We will be using our own RenderingDevice to handle the compute commands
	var rd = RenderingServer.create_local_rendering_device()
	
	# Create shader and pipeline
	var shader_file = load("res://compute_example.glsl")
	var shader_bytecode = shader_file.get_bytecode()
	var shader = rd.shader_create(shader_bytecode)
	var pipeline = rd.compute_pipeline_create(shader)
	
	# Data for compute shaders has to come as an array of bytes
	var pba = PackedByteArray()
	pba.resize(64)
	for i in range(16):
		pba.encode_float(i*4, 2.0)
	
	# Create storage buffer
	# Data not needed, can just create with length
	var storage_buffer = rd.storage_buffer_create(64, pba)
	
	# Create uniform set using the storage buffer
	var u = RDUniform.new()
	u.uniform_type = RenderingDevice.UNIFORM_TYPE_STORAGE_BUFFER
	u.binding = 0
	u.add_id(storage_buffer)
	var uniform_set = rd.uniform_set_create([u], shader, 0)
	
	# Start compute list to start recording our compute commands
	var compute_list = rd.compute_list_begin()
	# Bind the pipeline, this tells the GPU what shader to use
	rd.compute_list_bind_compute_pipeline(compute_list, pipeline)
	# Binds the uniform set with the data we want to give our shader
	rd.compute_list_bind_uniform_set(compute_list, uniform_set, 0)
	# Dispatch 1x1x1 (XxYxZ) work groups
	rd.compute_list_dispatch(compute_list, 2, 1, 1)
	#rd.compute_list_add_barrier(compute_list)
	# Tell the GPU we are done with this compute task
	rd.compute_list_end()
	# Force the GPU to start our commands
	rd.submit()
	# Force the CPU to wait for the GPU to finish with the recorded commands
	rd.sync()
	
	# Now we can grab our data from the storage buffer
	var byte_data = rd.buffer_get_data(storage_buffer)
	for i in range(16):
		print(byte_data.decode_float(i*4))
	

And compute.glsl

#[compute]

#version 450

layout(local_size_x = 8, local_size_y = 1, local_size_z = 1) in;

layout(set = 0, binding = 0, std430) buffer ColorBuffer {
	float data[];
}
color_buffer;

void main() {
	color_buffer.data[gl_GlobalInvocationID.x] = gl_GlobalInvocationID.x;
}

[aroidzap]

For newer Godot builds you have to change:

var shader_bytecode = shader_file.get_bytecode()
var shader = rd.shader_create(shader_bytecode)

to:

var shader_spirv = shader_file.get_spirv()
var shader = rd.shader_create_from_spirv(shader_spirv)

[underdoeg]

Would be nice to also have an example on how to modify a texture with a compute shader. I tried something but wasn't able to use a texture created with the rendering device with a Control. (something like)

rd = RenderingServer.create_local_rendering_device()
var fmt = RDTextureFormat.new()
fmt.width = 64
fmt.height = 64
fmt.format = RenderingDevice.DATA_FORMAT_R8G8B8A8_UINT
fmt.usage_bits = RenderingDevice.TEXTURE_USAGE_CAN_UPDATE_BIT
var view = RDTextureView.new()
tex = rd.texture_create(fmt, view, [img.get_image().get_data()])
# this will not work because tex is not part of a lookup table in renderer storage
RenderingServer.canvas_item_add_texture_rect(get_canvas_item(),  get_rect(), tex);

[clayjohn]

Here is a gist from another person who adapted the above sample to a more recent version of the engine. https://gist.github.com/winston-yallow/aab20fa437bfa3dd80bfb0ed6605d28e

[mbrlabs]

Here are some simple real-world applications of Compute Shaders that could be added to the godot-demo-projects repository:

• Calculate a mandelbrot set in a compute shader using n GPU threads and export it as PNG. Also show it as a sprite in Godot
• Various image filters like: Color Inversion, Grayscaling, Gaussian blur, edge detection, etc.
• Mesh generation. Could be simple like meshing 1000 cubes in a 10x10x10 grid or more complex like meshing a voxel volume.

[Calinou]

Various image filters like: Color Inversion, Grayscaling, Gaussian blur, edge detection, etc.

Isn't this better done with standard fragment shaders like in the 2D Sprite Shaders demo?

[mbrlabs]

Yeah probably. I just listed them because these are simple and approachable problems which demonstrate aspects of compute shaders which almost everyone needs when developing their own:

• input of lots of data
• output of lots of data
• distribution of data/work packets across gpu cores
• using the output

[winston-yallow]

Isn't this better done with standard fragment shaders like in the 2D Sprite Shaders demo?

I think there is value in showing how to do it in compute shaders. Not necessarily for the image filters listed, but in a more general sense. Manipulating textures this way has quite a few advantages (for example only regenerating them on demand) and can be used for stuff like generating flow maps for fluid sims.

[ajunca]

I'm trying to achieve part of what is commented, share a texture between the compute pipeline and a viewport, but without success. The gist with the updated code was very helpfull to get basic compute shader up and running, but I'm really stuck on sharing a texture. Any news/example/something on that?

I tried several things:
1- Create the texture from within the local rendering device. Binding to an image2D in the compute shader works. Binding the texture to the viewport shader material does not complain with any warning/error message but I can not get the real image data inside the shader.
2- Create the texture outside of local rendering device (for example with a normal ImageTexture). Binding to the viewport no problem at all. Binding to the compute shader it complains that the texture is not valid.

It seems that maybe resources can be only shared from local rendering device to RenderingServer but not viceversa? If so, it seems that approch 1 is somehow the way. But probably I'm totally wrong altogether (very shallow insights).

[clayjohn]

Right now it isnt possible to share resources between RenderingDevices. It is something we plan on adding in the future, but haven't had time to figure out quite yet.

[ajunca]

Thanks I understand. I'm guessing that is neither prepared to copy data between RenderingDevices within GPU realm, correct? Without doing GPU->CPU->GPU?

[clayjohn]

Thanks I understand. I'm guessing that is neither prepared to copy data between RenderingDevices within GPU realm, correct? Without doing GPU->CPU->GPU?

Not yet, no.

[EpEpDragon]

I'm trying to render a bunch of similar meshes over a area. I figured out the code above but I'm having trouble seeing what I need to add to draw meshes (from predefined triangles). Do I need to define a render pipeline, or does it fit into the compute pipeline. I saw some draw related functions that seem to match with a render pipeline, but I'm unsure of what I need to call when.