building a pure graphics pipeline version of this

slime_simulation_cs/shaders/agents_cs.glsl

@@ -0,0 +1,88 @@
+#[compute]
+#version 450
+
+// Invocations in the (x, y, z) dimension
+layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
+
+layout(r32f,  binding = 0) uniform restrict readonly image2D current_trail;
+layout(r32f,  binding = 1) uniform restrict writeonly image2D output_trail;
+layout(binding = 2) restrict buffer AgentBuffer {
+    vec2 positions[1024 * 1024];
+    float headings[1024 * 1024];
+} agent_buffer;
+
+layout(push_constant, std430) uniform Params {
+    vec2 texture_size;
+    float sensor_angle;
+    float sensor_distance;
+} params;
+
+const float SPEED = 1.0;
+const float DEPOSIT = 0.5;
+
+
+float random(vec2 coords) {
+   return fract(sin(dot(coords.xy, vec2(12.9898,78.233))) * 43758.5453);
+}
+
+vec2 loop_position(vec2 pos) {
+    return mod(pos, params.texture_size);
+}
+
+void main() {
+
+    uint id = gl_GlobalInvocationID.x;
+    vec2 position = agent_buffer.positions[id];
+    float heading = agent_buffer.headings[id];
+
+    float current_v = imageLoad(current_trail, ivec2(position)).r;
+
+    float sa = params.sensor_angle;
+    float left_heading = heading - sa;
+    float right_heading = heading + sa;
+
+    vec2 left_detect_dir = vec2(cos(left_heading), sin(left_heading));
+    vec2 right_detect_dir = vec2(cos(right_heading), sin(right_heading));
+    vec2 forward_detect_dir = vec2(cos(heading), sin(heading));
+
+    float sd = params.sensor_distance;
+    vec2 left_detect_pos = loop_position(position + left_detect_dir * sd);
+    vec2 right_detect_pos = loop_position(position + right_detect_dir * sd);
+    vec2 forward_detect_pos = loop_position(position + forward_detect_dir * sd);
+
+    float left = imageLoad(current_trail, ivec2(left_detect_pos)).r;
+    float right = imageLoad(current_trail, ivec2(right_detect_pos)).r;
+    float forward = imageLoad(current_trail, ivec2(forward_detect_pos)).r;
+
+    vec2 pos = position;
+    float new_heading = heading;
+    if (left > forward && left > right) {
+        pos += left_detect_dir * SPEED;
+        new_heading = left_heading;
+    } else if (right > forward && right > left) {
+        pos += right_detect_dir * SPEED;
+        new_heading = right_heading;
+    } else if (forward < left && forward < right) {
+        // uuugh
+        float r = random(pos);
+        if (r < 0.5) {
+            pos += right_detect_dir * SPEED;
+            new_heading = right_heading;
+        } else {
+            pos += left_detect_dir * SPEED;
+            new_heading = left_heading;
+        }
+    } else {
+        pos += forward_detect_dir * SPEED;
+    }
+
+    pos = mod(pos, params.texture_size);
+    agent_buffer.positions[id] = pos;
+    agent_buffer.headings[id] = new_heading;
+
+    float new_v = current_v + DEPOSIT;
+    if (new_v > 1.0) new_v = 1.0;
+
+    vec4 result = vec4(new_v, new_v, new_v, 1.0);
+    imageStore(output_trail, ivec2(pos), result);
+}

slime_simulation_cs/shaders/agents_cs.glsl.import

@@ -0,0 +1,14 @@
+[remap]
+
+importer="glsl"
+type="RDShaderFile"
+uid="uid://u3grg3r2bgi1"
+path="res://.godot/imported/agents_cs.glsl-f5fde0e4c35a05360ed8814f4e4a012a.res"
+
+[deps]
+
+source_file="res://slime_simulation_cs/shaders/agents_cs.glsl"
+dest_files=["res://.godot/imported/agents_cs.glsl-f5fde0e4c35a05360ed8814f4e4a012a.res"]
+
+[params]
+

slime_simulation_cs/shaders/decay_cs.glsl

@@ -0,0 +1,61 @@
+#[compute]
+#version 450
+
+// Invocations in the (x, y, z) dimension
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+// Our textures.
+layout(r32f, set = 0, binding = 0) uniform restrict readonly image2D current_image;
+layout(r32f, set = 1, binding = 0) uniform restrict writeonly image2D output_image;
+
+// PushConstants
+layout(push_constant, std430) uniform Params {
+    ivec2 texture_size;
+    float decay_factor;
+    float dissipation_factor;
+} params;
+
+float get_dissipation_from(ivec2 uv) {
+    float v = imageLoad(current_image, uv).r;
+    // return v * params.dissipation_factor;
+    return v;
+}
+
+ivec2 loop_position(ivec2 pos) {
+    return pos % params.texture_size;
+}
+
+// The code we want to execute in each invocation
+void main() {
+
+    ivec2 uv = ivec2(gl_GlobalInvocationID.xy);
+
+    float current_sum = 0.0;
+    for (int i = -1; i <= 1; i++) {
+        for (int j = -1; j <= 1; j++) {
+            ivec2 kuv = loop_position(uv + ivec2(i,j));
+            current_sum += get_dissipation_from(kuv);
+        }
+    }
+    // ivec2 up_uv = loop_position(uv - ivec2(0, 1));
+    // ivec2 down_uv = loop_position(uv + ivec2(0, 1));
+    // ivec2 left_uv = loop_position(uv - ivec2(1, 0));
+    // ivec2 right_uv = loop_position(uv + ivec2(1, 0));
+
+
+    // Kill very old trails completely
+    // if (new_v < 0.001) {
+    //     new_v = 0;
+    // }
+
+    // new_v = clamp(new_v, 0, 1);
+
+    // This is good when not using trail for showind as is.
+    // https://github.com/Bleuje/physarum-36p/blob/main/bin/data/shaders/computeshader_deposit.glsl
+    current_sum = current_sum / pow(3.0, 2.0);
+
+    vec4 result = vec4(vec3(current_sum), 1.0);
+    imageStore(output_image, uv, result);
+
+
+}

slime_simulation_cs/shaders/decay_cs.glsl.import

@@ -0,0 +1,14 @@
+[remap]
+
+importer="glsl"
+type="RDShaderFile"
+uid="uid://vn5yxao0oxx0"
+path="res://.godot/imported/decay_cs.glsl-ddb2bd80ce1fa22519e2cc84d49ab13a.res"
+
+[deps]
+
+source_file="res://slime_simulation_cs/shaders/decay_cs.glsl"
+dest_files=["res://.godot/imported/decay_cs.glsl-ddb2bd80ce1fa22519e2cc84d49ab13a.res"]
+
+[params]
+

slime_simulation_cs/show_simulation_cs.gdshader

@@ -0,0 +1,7 @@
+shader_type canvas_item;
+uniform sampler2D trail_tex;
+
+void fragment() {
+	float v = texture(trail_tex, UV).r;
+	COLOR = vec4(vec3(v), 1.0);
+}

slime_simulation_cs/show_simulation_cs.gdshader.uid

@@ -0,0 +1 @@
+uid://bh4h5oqyhr5bx

slime_simulation_cs/slime_simulation_cs.gd

@@ -0,0 +1,230 @@
+extends Node2D
+
+@export var texture_size: Vector2i = Vector2i(512, 512)
+@export var decay_factor: float = 0.98
+@export var dissipation_factor: float = 0.12
+@export var sensor_angle: float = 32.0:
+	get():
+		return deg_to_rad(sensor_angle)
+@export var sensor_distance: float = 3.86
+@export var rng_seed: int = 80085
+
+@onready var mesh := $MeshInstance2D
+
+## Needs to be changed from the shader as well
+const AGENTS: int = 1024 * 1024
+
+var texture: Texture2DRD
+var next_texture: int = 0
+
+
+func _ready():
+	RenderingServer.call_on_render_thread(_initialize_compute_code.bind(texture_size))
+	var mat: ShaderMaterial = mesh.material
+	texture = mat.get_shader_parameter("trail_tex")
+
+
+func _process(_delta: float) -> void:
+	next_texture = (next_texture + 1) % 2
+
+	if texture:
+		texture.texture_rd_rid = texture_rds[next_texture]
+
+	RenderingServer.call_on_render_thread(
+		_render_process.bind(
+			next_texture,
+			texture_size,
+			decay_factor,
+			dissipation_factor,
+			sensor_angle,
+			sensor_distance
+		)
+	)
+
+
+func _exit_tree() -> void:
+	if texture:
+		texture.texture_rd_id = RID()
+
+	RenderingServer.call_on_render_thread(_free_compute_resources)
+
+
+# Everything after this point is designed to run on our rendering thread.
+
+var rd: RenderingDevice
+
+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()]
+var texture_sets: Array[RID] = [RID(), RID()]
+
+var agent_buffer: RID
+var agent_sets: Array[RID] = [RID(), RID()]
+
+
+func _load_shader(rd_: RenderingDevice, path: String) -> RID:
+	var shader_file := load(path)
+	var shader_spirv: RDShaderSPIRV = shader_file.get_spirv()
+	return rd_.shader_create_from_spirv(shader_spirv)
+
+
+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)
+	return uniform
+
+
+func _initialize_compute_code(with_texture_size: Vector2i) -> void:
+	# As this becomes part of our normal frame rendering,
+	# we use our main rendering device here.
+	rd = RenderingServer.get_rendering_device()
+
+	# Create shaders
+	decay_shader = _load_shader(rd, "res://slime_simulation_cs/shaders/decay_cs.glsl")
+	decay_pipeline = rd.compute_pipeline_create(decay_shader)
+
+	agent_shader = _load_shader(rd, "res://slime_simulation_cs/shaders/agents_cs.glsl")
+	agent_pipeline = rd.compute_pipeline_create(agent_shader)
+
+	# Create agent buffer
+	var rng := RandomNumberGenerator.new()
+	rng.seed = rng_seed
+	var agent_positions := PackedVector2Array()
+	var agent_angles := PackedFloat32Array()
+	# This must match what is set in the shader, if fixed size
+	for n in AGENTS:
+		var new_position := Vector2(
+			rng.randf_range(0, with_texture_size.x), rng.randf_range(0, with_texture_size.y)
+		)
+		agent_positions.push_back(new_position)
+		agent_angles.push_back(rng.randf_range(0, TAU))
+
+	var agent_data := PackedByteArray(agent_positions.to_byte_array())
+	agent_data.append_array(agent_angles.to_byte_array())
+	agent_buffer = rd.storage_buffer_create(
+		agent_data.size(), agent_data, 0, RenderingDevice.BUFFER_CREATION_AS_STORAGE_BIT
+	)
+
+	# Create trail texture
+	var tf: RDTextureFormat = RDTextureFormat.new()
+	tf.format = RenderingDevice.DATA_FORMAT_R32_SFLOAT
+	tf.texture_type = RenderingDevice.TEXTURE_TYPE_2D
+	tf.width = with_texture_size.x
+	tf.height = with_texture_size.y
+	tf.depth = 1
+	tf.array_layers = 1
+	tf.mipmaps = 1
+	tf.usage_bits = (
+		RenderingDevice.TEXTURE_USAGE_SAMPLING_BIT
+		| RenderingDevice.TEXTURE_USAGE_COLOR_ATTACHMENT_BIT
+		| RenderingDevice.TEXTURE_USAGE_STORAGE_BIT
+		| RenderingDevice.TEXTURE_USAGE_CAN_UPDATE_BIT
+		| RenderingDevice.TEXTURE_USAGE_CAN_COPY_TO_BIT
+	)
+
+	var agent_uniforms: Array[RDUniform] = []
+	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.BLACK, 0, 1, 0, 1)
+
+		var trail_uniform := _create_trail_uniform(texture_rds[i])
+		texture_sets[i] = rd.uniform_set_create([trail_uniform], decay_shader, 0)
+
+	var txtr_uniform_1 := RDUniform.new()
+	txtr_uniform_1.uniform_type = RenderingDevice.UNIFORM_TYPE_IMAGE
+	txtr_uniform_1.binding = 0
+	txtr_uniform_1.add_id(texture_rds[0])
+	agent_uniforms.append(txtr_uniform_1)
+
+	var txtr_uniform_2 := RDUniform.new()
+	txtr_uniform_2.uniform_type = RenderingDevice.UNIFORM_TYPE_IMAGE
+	txtr_uniform_2.binding = 1
+	txtr_uniform_2.add_id(texture_rds[1])
+	agent_uniforms.append(txtr_uniform_2)
+
+	var uniform := RDUniform.new()
+	uniform.uniform_type = RenderingDevice.UNIFORM_TYPE_STORAGE_BUFFER
+	uniform.binding = 2
+	uniform.add_id(agent_buffer)
+	agent_sets[0] = rd.uniform_set_create(
+		[txtr_uniform_1, txtr_uniform_2, uniform], agent_shader, 0
+	)
+	agent_sets[1] = rd.uniform_set_create(
+		[txtr_uniform_2, txtr_uniform_1, uniform], agent_shader, 0
+	)
+
+
+func _render_process(
+	with_next_texture: int,
+	tex_size: Vector2i,
+	decay_fctr: float,
+	dissipation_fctr: float,
+	snsr_angle: float,
+	snsr_distance: 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(snsr_angle)
+	push_constant.push_back(snsr_distance)
+
+	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, agent_sets[with_next_texture], 0)
+	rd.compute_list_set_push_constant(
+		agent_compute_list, push_constant.to_byte_array(), push_constant.size() * 4
+	)
+	@warning_ignore("integer_division")
+	rd.compute_list_dispatch(agent_compute_list, 64, 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(dissipation_fctr)
+
+	@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
+
+	# Run the compute shader
+	var compute_list := rd.compute_list_begin()
+	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, next_set, 1)
+	rd.compute_list_set_push_constant(
+		compute_list, push_constant.to_byte_array(), push_constant.size() * 4
+	)
+	rd.compute_list_dispatch(compute_list, x_groups, y_groups, 1)
+	rd.compute_list_end()
+
+
+func _free_compute_resources() -> void:
+	# Note that our sets and pipeline are cleaned up automatically
+	# as they are dependencies :P
+	for i in 2:
+		if texture_rds[i]:
+			rd.free_rid(texture_rds[i])
+
+	if decay_shader:
+		rd.free_rid(decay_shader)
+	if agent_shader:
+		rd.free_rid(agent_shader)

slime_simulation_cs/slime_simulation_cs.gd.uid

@@ -0,0 +1 @@
+uid://d1bbllvcal2uw

slime_simulation_cs/slime_simulation_cs.tscn

@@ -0,0 +1,27 @@
+[gd_scene load_steps=6 format=3 uid="uid://bf4ohdg0sfl8l"]
+
+[ext_resource type="Script" uid="uid://d1bbllvcal2uw" path="res://slime_simulation_cs/slime_simulation_cs.gd" id="1_uoug3"]
+[ext_resource type="Shader" uid="uid://bh4h5oqyhr5bx" path="res://slime_simulation_cs/show_simulation_cs.gdshader" id="2_w43x7"]
+
+[sub_resource type="Texture2DRD" id="Texture2DRD_pxe3a"]
+
+[sub_resource type="ShaderMaterial" id="ShaderMaterial_pxe3a"]
+shader = ExtResource("2_w43x7")
+shader_parameter/trail_tex = SubResource("Texture2DRD_pxe3a")
+
+[sub_resource type="QuadMesh" id="QuadMesh_pxe3a"]
+size = Vector2(1920, 1080)
+
+[node name="CSSlimeSimulation" type="Node2D"]
+script = ExtResource("1_uoug3")
+texture_size = Vector2i(1920, 1080)
+decay_factor = 0.8
+sensor_angle = 7.0
+sensor_distance = 10.0
+rng_seed = 8008
+
+[node name="MeshInstance2D" type="MeshInstance2D" parent="."]
+self_modulate = Color(0.581022, 0.701395, 0.890748, 1)
+material = SubResource("ShaderMaterial_pxe3a")
+position = Vector2(960, 540)
+mesh = SubResource("QuadMesh_pxe3a")