// APICAL WEATHER cell simulation, rooted in Fluoddity's Entity/Fourier Rule. // // Entity is exactly 48 bytes: // pos + vel 16 bytes // size + lineage + age + alive 16 bytes // auxin + cytokinin + stress + energy 16 bytes // // Rule is exactly 80 f32 values: ten 32-byte Fourier centers. const PI: f32 = 3.1415926; const TAU: f32 = 6.2831852; const SEED_LIMIT: u32 = 8u; struct Globals { // x=dt, y=time, z=motion, w=signal persistence timing: vec4, // x=field width, y=field height, z=entity capacity, w=frame field: vec4, // x=deposit radius, y=signal diffusion, z=signal decay, w=render scale plant: vec4, // x/y=pointer position, z=pointer strength, w=pointer mode interaction: vec4, }; struct Entity { pos: vec2, vel: vec2, size: f32, lineage: f32, age: f32, alive: f32, // x=auxin, y=cytokinin, z=stress, w=energy hormones: vec4, }; struct FourierCenter { frequency: vec4, amplitude: vec4, }; struct Rule { centers: array, }; @group(0) @binding(0) var globals: Globals; @group(0) @binding(1) var rule: Rule; @group(0) @binding(2) var entities_in: array; @group(0) @binding(3) var entities_out: array; @group(0) @binding(4) var hormone_field: texture_2d; fn pcg_hash(seed: u32) -> u32 { let state = seed * 747796405u + 2891336453u; let word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u; return (word >> 22u) ^ word; } fn random_01(seed: u32) -> f32 { return f32(pcg_hash(seed) & 0x00ffffffu) / 16777216.0; } fn safe_normalize(value: vec2) -> vec2 { let magnitude = length(value); if (magnitude < 0.000001) { return vec2(0.0, -1.0); } return value / magnitude; } fn rotate_clockwise(value: vec2, angle: f32) -> vec2 { return cos(angle) * value + sin(angle) * vec2(value.y, -value.x); } fn y_reflect(value: vec2) -> vec2 { return value * vec2(1.0, -1.0); } fn fourier_noise(position: vec4) -> vec4 { var result = vec4(0.0); for (var index = 0u; index < 10u; index += 1u) { let center = rule.centers[index]; let phase = dot(position, center.frequency); let phase_offset = 2.0 * f32(index) * 0.6283 + center.amplitude.w * PI; let basis = vec4( sin(phase + phase_offset), cos(phase + phase_offset * 0.7), sin(phase * 2.0 + phase_offset * 1.3), cos(phase * 2.0 + phase_offset * 0.5), ); result += center.amplitude * basis; } return result; } fn seed_count() -> u32 { return min(SEED_LIMIT, globals.field.z); } fn root_partition_start() -> u32 { let seeds = seed_count(); let descendants = globals.field.z - seeds; return seeds + descendants * 2u / 3u; } // +1 is shoot, -1 is root, 0 is the anchored seed plate. fn partition_kind(index: u32) -> f32 { if (index < seed_count()) { return 0.0; } if (index < root_partition_start()) { return 1.0; } return -1.0; } // Both descendant pools form deterministic binary trees over the fixed Entity // capacity. Every parent index is lower than its child, and reads come only // from the previous ping-pong buffer, so division is deterministic. fn parent_index(index: u32) -> u32 { let seeds = seed_count(); let root_start = root_partition_start(); if (index < seeds) { return index; } if (index < root_start) { let local = index - seeds; if (local < seeds) { return local; } return seeds + (local - seeds) / 2u; } let local = index - root_start; if (local < seeds) { return local; } return root_start + (local - seeds) / 2u; } fn lineage_depth(index: u32) -> u32 { var cursor = index; var depth = 0u; loop { if (cursor < seed_count() || depth >= 24u) { break; } cursor = parent_index(cursor); depth += 1u; } return depth; } fn field_dimensions() -> vec2 { return vec2( max(f32(globals.field.x), 1.0), max(f32(globals.field.y), 1.0), ); } fn sample_hormones(position: vec2) -> vec4 { let dimensions = max(globals.field.xy, vec2(1u)); let clamped_position = clamp(position, vec2(0.0), vec2(0.999999)); let pixel = min( vec2(clamped_position * vec2(dimensions)), dimensions - vec2(1u), ); return textureLoad(hormone_field, vec2(pixel), 0); } fn dormant_entity(index: u32) -> Entity { let seed = pcg_hash(index ^ 0x9e3779b9u); let kind = partition_kind(index); let lineage_phase = (0.15 + random_01(seed ^ 0x3c6ef372u) * TAU) * kind; return Entity( vec2(0.5, 0.62), vec2(0.0), 0.72 + random_01(seed ^ 0xbb67ae85u) * 0.58, lineage_phase, 0.0, 0.0, vec4(0.0), ); } fn initial_entity(index: u32) -> Entity { if (index >= seed_count()) { return dormant_entity(index); } let seed = pcg_hash(index ^ globals.field.w ^ 0xa91ca1u); let angle = TAU * f32(index) / max(f32(seed_count()), 1.0); let radial = 0.003 + 0.011 * random_01(seed ^ 0xa341316cu); let position = vec2(0.5, 0.62) + radial * vec2(cos(angle), sin(angle) * 0.42); return Entity( position, vec2(0.0), 0.92 + 0.44 * random_01(seed ^ 0xbb67ae85u), angle, 0.0, 1.0, vec4( 0.52 + 0.15 * random_01(seed ^ 0xad90777du), 0.46 + 0.15 * random_01(seed ^ 0x7e95761eu), 0.025, 0.82, ), ); } fn activation_delay(index: u32) -> f32 { let seed = pcg_hash(index ^ 0x6a09e667u); let root_delay = select(0.0, 0.05, partition_kind(index) < 0.0); return 0.40 + root_delay + random_01(seed) * 0.25; } fn activated_child(index: u32, parent: Entity) -> Entity { let seed = pcg_hash(index ^ 0x510e527fu); let kind = partition_kind(index); let vertical = vec2(0.0, -kind); var inherited = parent.vel; if (length(inherited) < 0.000001) { inherited = vertical; } let depth = lineage_depth(index); let branch_sign = select(-1.0, 1.0, (index & 1u) != 0u); let branch_random = random_01(seed ^ 0x9b05688cu); let branch_magnitude = select( 0.05 + branch_random * 0.17, 0.35 + branch_random * 0.65, depth >= 3u, ); let branch_angle = branch_sign * branch_magnitude; let branched_heading = rotate_clockwise(safe_normalize(inherited), branch_angle); let vertical_rebias = select(0.18, 0.22, kind > 0.0); let direction = safe_normalize( mix(branched_heading, vertical, vertical_rebias) ); let size = clamp(parent.size * (0.94 + random_01(seed ^ 0x1f83d9abu) * 0.09), 0.62, 1.55); let step_pixels = 4.0 + random_01(seed ^ 0x5be0cd19u) * 4.0; let position = clamp( parent.pos + direction * step_pixels / field_dimensions(), vec2(0.018), vec2(0.982), ); let shoot_mix = select(0.0, 1.0, kind > 0.0); let root_mix = 1.0 - shoot_mix; let hormones = vec4( clamp(parent.hormones.x * 0.74 + 0.24 + shoot_mix * 0.19, 0.0, 1.5), clamp(parent.hormones.y * 0.76 + 0.20 + root_mix * 0.22, 0.0, 1.5), parent.hormones.z * 0.42 + 0.025, clamp(parent.hormones.w * 0.88 + 0.09, 0.35, 1.25), ); let lineage_phase = kind * (abs(parent.lineage) + branch_angle * 0.45 + 0.017 * f32(index % 17u)); return Entity( position, direction * 0.0015, size, lineage_phase, 0.0, 1.0, hormones, ); } @compute @workgroup_size(256) fn cs_main(@builtin(global_invocation_id) invocation: vec3) { let index = invocation.x; if (index >= globals.field.z) { return; } if (globals.field.w == 0u) { entities_out[index] = initial_entity(index); return; } var entity = entities_in[index]; if (entity.alive < 0.5) { // Negative age marks a terminal wound, distinct from a dormant cell. if (entity.age < 0.0) { entities_out[index] = entity; return; } let parent = entities_in[parent_index(index)]; if (parent.alive >= 0.5 && parent.age >= activation_delay(index)) { entities_out[index] = activated_child(index, parent); } else { entities_out[index] = entity; } return; } let dt = clamp(globals.timing.x, 0.0, 0.05); let kind = partition_kind(index); let anchored = index < seed_count(); let interaction_pulse = max(globals.interaction.z, 0.0); let pointer_delta = globals.interaction.xy - entity.pos; let pointer_distance = length(pointer_delta); let feed_mode = globals.interaction.w >= 1.5 && globals.interaction.w < 2.5; let wound_mode = globals.interaction.w >= 2.5 && globals.interaction.w < 3.5; var feed_boost = 0.0; if (feed_mode && interaction_pulse > 0.0) { feed_boost = (1.0 - smoothstep(0.045, 0.19, pointer_distance)) * interaction_pulse; } if ( wound_mode && interaction_pulse > 0.0 && pointer_distance < 0.060 ) { let wound_falloff = pow(1.0 - pointer_distance / 0.060, 2.0) * interaction_pulse; if (wound_falloff > 0.46 || entity.hormones.w - wound_falloff < 0.08) { entities_out[index] = Entity( entity.pos, vec2(0.0), entity.size, entity.lineage, -1.0, 0.0, vec4( entity.hormones.x * 0.12, entity.hormones.y * 0.12, 1.5, 0.0, ), ); return; } entity.hormones.z = clamp(entity.hormones.z + wound_falloff, 0.0, 1.5); entity.hormones.w = clamp(entity.hormones.w - wound_falloff, 0.0, 1.5); } var heading = safe_normalize(entity.vel); if (anchored) { heading = vec2(0.0, -1.0); } let radius_uv = max(entity.size, 0.5) / field_dimensions(); let sensor_distance = max(radius_uv.x, radius_uv.y) * 6.5; let sensor_angle = 0.50; let forward_position = entity.pos + heading * sensor_distance; let left_position = entity.pos + rotate_clockwise(heading, sensor_angle) * sensor_distance; let right_position = entity.pos + rotate_clockwise(heading, -sensor_angle) * sensor_distance; let forward = sample_hormones(forward_position); let left = sample_hormones(left_position); let right = sample_hormones(right_position); // Hormone gates are explicit: auxin promotes shoot extension, cytokinin // promotes root branching, and stress suppresses both. let auxin_gate = smoothstep(0.08, 0.78, entity.hormones.x + forward.x * 0.34); let cytokinin_gate = smoothstep(0.06, 0.72, entity.hormones.y + forward.y * 0.32); let stress_gate = 1.0 - smoothstep(0.16, 0.94, entity.hormones.z + forward.z * 0.58); let left_sample = vec2( (left.x - forward.x) * auxin_gate - (left.z - forward.z) * (1.0 - stress_gate), (left.y - forward.y) * cytokinin_gate, ); let right_sample = vec2( (right.x - forward.x) * auxin_gate - (right.z - forward.z) * (1.0 - stress_gate), (right.y - forward.y) * cytokinin_gate, ); // Canonical Fluoddity handedness: evaluate the saved Fourier Rule once on // left/right sensing and once on the mirrored right/left features. let base_term = fourier_noise(vec4(left_sample, right_sample)); let mirror_term = fourier_noise( vec4(y_reflect(right_sample), y_reflect(left_sample)), ); let neural_force = base_term.xy + y_reflect(mirror_term.xy); let neural_strafe = base_term.zw + y_reflect(mirror_term.zw); let vertical = select(vec2(0.0, 1.0), vec2(0.0, -1.0), kind >= 0.0); let hormone_tropism = select(cytokinin_gate, auxin_gate, kind >= 0.0); let turn = clamp( (neural_force.y + neural_strafe.x * 0.35) * 0.13 + (right.x - left.x) * auxin_gate * 0.72 - (right.y - left.y) * cytokinin_gate * 0.58, -0.78, 0.78, ); let steered = rotate_clockwise(heading, turn * dt * 4.2); var desired_heading = safe_normalize( mix(steered, vertical, 0.09 + hormone_tropism * 0.13), ); let light_mode = globals.interaction.w >= 0.5 && globals.interaction.w < 1.5; if ( light_mode && kind > 0.0 && interaction_pulse > 0.0 && pointer_distance > 0.000001 ) { let light_reach = interaction_pulse * (1.0 - smoothstep(0.12, 0.72, pointer_distance)); desired_heading = safe_normalize( mix( desired_heading, pointer_delta / pointer_distance, clamp(light_reach * 0.42, 0.0, 0.72), ), ); } let occupancy_brake = 1.0 - smoothstep(0.55, 2.4, forward.w); let growth_drive = clamp(auxin_gate * 0.56 + cytokinin_gate * 0.44, 0.0, 1.0) * stress_gate * occupancy_brake; let growth_window = exp(-entity.age * 1.65); let speed = max(globals.timing.z, 0.0) * 0.012 * growth_drive * growth_window; let velocity_mix = 1.0 - exp(-dt * 8.0); var velocity = mix(entity.vel, desired_heading * speed, velocity_mix); if (anchored) { velocity = vec2(0.0); } var position = clamp( entity.pos + velocity * dt, vec2(0.018), vec2(0.982), ); let shoot_mix = select(0.0, 1.0, kind >= 0.0); let root_mix = 1.0 - shoot_mix; let auxin_target = clamp( 0.17 + shoot_mix * 0.30 + forward.x * 0.60 - forward.z * 0.18, 0.0, 1.5, ); let cytokinin_target = clamp( 0.16 + root_mix * 0.32 + forward.y * 0.58 + forward.w * 0.025 + feed_boost * 0.95, 0.0, 1.5, ); let stress_target = clamp( 0.018 + forward.z * 0.78 + max(forward.w - 1.2, 0.0) * 0.24, 0.0, 1.5, ); let hormone_mix = 1.0 - exp(-dt * 2.5); let hormones = vec3( mix(entity.hormones.x, auxin_target, hormone_mix), mix(entity.hormones.y, cytokinin_target, hormone_mix * 0.86), mix(entity.hormones.z, stress_target, hormone_mix * 1.15), ); let energy_target = clamp( 0.28 + hormones.x * 0.40 + hormones.y * 0.34 - hormones.z * 0.52 + feed_boost * 0.18, 0.18, 1.35, ); let energy = mix(entity.hormones.w, energy_target, hormone_mix * 0.55); entities_out[index] = Entity( position, velocity, clamp(entity.size + (growth_drive - 0.54) * dt * 0.035, 0.60, 1.65), entity.lineage, entity.age + dt, 1.0, vec4(hormones, energy), ); }