good progress, but no other compute pass yet

slime_simulation.gd

@@ -16,7 +16,7 @@ func _ready():
 
 
 func _process(_delta: float) -> void:
-	next_texture = (next_texture + 1) % 3
+	next_texture = (next_texture + 1) % 2
 
 	if texture:
 		texture.texture_rd_rid = texture_rds[next_texture]
@@ -37,15 +37,22 @@ func _exit_tree() -> void:
 
 var rd: RenderingDevice
 
-var shader: RID
-var pipeline: RID
+var decay_shader: RID
+var decay_pipeline: RID
+
+var agent_shader: RID
+var agent_pipeline: RID
 
 # We use 3 textures:
 # - One to render into
 # - One that contains the last frame rendered
 # - One for the frame before that
-var texture_rds: Array[RID] = [RID(), RID(), RID()]
-var texture_sets: Array[RID] = [RID(), RID(), RID()]
+var texture_rds: Array[RID] = [RID(), RID()]
+var texture_sets: Array[RID] = [RID(), RID()]
+
+var agent_uniform_sets: Array[RID] = [RID(), RID()]
+var agent_buffer: RID
+var agent_set: RID
 
 
 func _load_shader(rd_: RenderingDevice, path: String) -> RID:
@@ -54,13 +61,12 @@ func _load_shader(rd_: RenderingDevice, path: String) -> RID:
 	return rd_.shader_create_from_spirv(shader_spirv)
 
 
-func _create_uniform_set(texture_rd: RID) -> RID:
+func _create_trail_uniform(texture_rd: RID) -> RDUniform:
 	var uniform := RDUniform.new()
 	uniform.uniform_type = RenderingDevice.UNIFORM_TYPE_IMAGE
 	uniform.binding = 0
 	uniform.add_id(texture_rd)
-	# Even though we're using 3 sets, they are identical, so we're kinda cheating.
-	return rd.uniform_set_create([uniform], shader, 0)
+	return uniform
 
 
 func _initialize_compute_code(init_with_texture_size: Vector2i) -> void:
@@ -68,9 +74,28 @@ func _initialize_compute_code(init_with_texture_size: Vector2i) -> void:
 	# we use our main rendering device here.
 	rd = RenderingServer.get_rendering_device()
 
-	# Create shader
-	shader = _load_shader(rd, "res://shaders/decay_cs.glsl")
-	pipeline = rd.compute_pipeline_create(shader)
+	# Create shaders
+	decay_shader = _load_shader(rd, "res://shaders/decay_cs.glsl")
+	decay_pipeline = rd.compute_pipeline_create(decay_shader)
+
+	agent_shader = _load_shader(rd, "res://shaders/agents_cs.glsl")
+	agent_pipeline = rd.compute_pipeline_create(agent_shader)
+
+	# Create agent buffer
+	var rng := RandomNumberGenerator.new()
+	rng.seed = 80085
+	var agent_data := PackedVector2Array()
+	for n in 64 * 16:
+		var new_position: Vector2i = Vector2(
+			rng.randi_range(0, init_with_texture_size.x),
+			rng.randi_range(0, init_with_texture_size.y)
+		)
+		agent_data.push_back(new_position)
+
+	var agent_size_in_bytes := 8
+	agent_buffer = rd.storage_buffer_create(
+		agent_data.size() * agent_size_in_bytes, agent_data.to_byte_array()
+	)
 
 	# Create trail texture
 	var tf: RDTextureFormat = RDTextureFormat.new()
@@ -89,38 +114,65 @@ func _initialize_compute_code(init_with_texture_size: Vector2i) -> void:
 		| RenderingDevice.TEXTURE_USAGE_CAN_COPY_TO_BIT
 	)
 
-	for i in 3:
+
+	var agent_uniforms = []
+	for i in 2:
 		texture_rds[i] = rd.texture_create(tf, RDTextureView.new(), [])
-
 		# Make sure our textures are cleared.
-		rd.texture_clear(texture_rds[i], Color.WHITE, 0, 1, 0, 1)
+		rd.texture_clear(texture_rds[i], Color.BLACK, 0, 1, 0, 1)
 
-		# Now create our uniform set so we can use these textures in our shader.
-		texture_sets[i] = _create_uniform_set(texture_rds[i])
+		var trail_uniform := _create_trail_uniform(texture_rds[i])
+		texture_sets[i] = rd.uniform_set_create([trail_uniform], decay_shader, 0)
+		agent_uniform_sets[i] = rd.uniform_set_create([trail_uniform], agent_shader, 0)
+
+	
+	var uniform := RDUniform.new()
+	uniform.uniform_type = RenderingDevice.UNIFORM_TYPE_STORAGE_BUFFER
+	uniform.binding = 1
+	uniform.add_id(agent_buffer)
+	agent_set = rd.uniform_set_create([uniform], agent_shader, 0)
 
 
 func _render_process(with_next_texture: int, tex_size: Vector2i, decay_fctr: float) -> void:
+	var next_set := texture_sets[with_next_texture]
+	var current_set := texture_sets[(with_next_texture - 1) % 2]
+
+	# Run agents
 	var push_constant := PackedFloat32Array()
 	push_constant.push_back(tex_size.x)
 	push_constant.push_back(tex_size.y)
+	push_constant.push_back(0.0)
+	push_constant.push_back(0.0)
+
+
+	var agent_compute_list := rd.compute_list_begin()
+	rd.compute_list_bind_compute_pipeline(agent_compute_list, agent_pipeline)
+	rd.compute_list_bind_uniform_set(agent_compute_list, current_set, 0)
+	rd.compute_list_bind_uniform_set(agent_compute_list, next_set, 1)
+	rd.compute_list_bind_uniform_set(agent_compute_list, agent_set, 2)
+	rd.compute_list_set_push_constant(
+		agent_compute_list, push_constant.to_byte_array(), push_constant.size() * 4
+	)
+	rd.compute_list_dispatch(agent_compute_list, 16, 1, 1)
+	rd.compute_list_end()
+
+	# Decay and dissipate
+	push_constant.clear()
+	push_constant.push_back(tex_size.x)
+	push_constant.push_back(tex_size.y)
 	push_constant.push_back(decay_fctr)
-	push_constant.push_back(0.0)  # not sure if this is needed
+	push_constant.push_back(0.0)
 
 	@warning_ignore("integer_division")
 	var x_groups := (tex_size.x - 1) / 8 + 1
 	@warning_ignore("integer_division")
 	var y_groups := (tex_size.y - 1) / 8 + 1
 
-	var next_set := texture_sets[with_next_texture]
-	var current_set := texture_sets[(with_next_texture - 1) % 3]
-	var previous_set := texture_sets[(with_next_texture - 2) % 3]
-
 	# Run the compute shader
 	var compute_list := rd.compute_list_begin()
-	rd.compute_list_bind_compute_pipeline(compute_list, pipeline)
+	rd.compute_list_bind_compute_pipeline(compute_list, decay_pipeline)
 	rd.compute_list_bind_uniform_set(compute_list, current_set, 0)
-	rd.compute_list_bind_uniform_set(compute_list, previous_set, 1)
-	rd.compute_list_bind_uniform_set(compute_list, next_set, 2)
+	rd.compute_list_bind_uniform_set(compute_list, next_set, 1)
 	rd.compute_list_set_push_constant(
 		compute_list, push_constant.to_byte_array(), push_constant.size() * 4
 	)
@@ -140,5 +192,5 @@ func _free_compute_resources() -> void:
 		if texture_rds[i]:
 			rd.free_rid(texture_rds[i])
 
-	if shader:
-		rd.free_rid(shader)
+	if decay_shader:
+		rd.free_rid(decay_shader)