spaceship/gas_surface.gdshader

shader_type canvas_item;

// Gas giant cloud-band backdrop for a landed gas surface. Same uniform
// interface as lunar_surface.gdshader (camera_cell/camera_frac/camera_zoom/
// viewport_size/cell_size/base_color/crater_color/highlight_color), so
// LunarBackground.gd feeds this shader with no changes at all - only
// PlanetSurfaceController swaps which shader the material uses.
//
// Renders horizontal cloud bands instead of craters: each grid row (a
// horizontal strip one cell tall) hashes its own band centre and thickness,
// nearest-row-wins picks which band a pixel belongs to, and the resulting
// distance field drives colour exactly the way the crater distance field
// does in lunar_surface.gdshader - base_color is the deep atmosphere,
// crater_color the shadowed band body, highlight_color the lit band crest.
// A low-frequency turbulence value perturbs each row's edge so the bands
// ripple instead of reading as ruled lines, and slides sideways over time
// for the lateral drift.
//
// PRECISION: never reconstruct an absolute world position. Every value fed
// to a hash is either a small camera-relative fraction (local, in [0,1]) or
// an exact integer cell/row index (cell, camera_cell + cell_rel) - the same
// split lunar_surface.gdshader and Starfield.gd use, for the same reason:
// world coordinates reach the tens of thousands, where a mobile float loses
// the fractional precision this shader depends on and no `highp` fixes it.
// The one exception is TIME, which the drift is built from directly per the
// ticket - see combine_lattice() for why that's still safe to mix in.

uniform vec2 camera_cell = vec2(0.0, 0.0);
uniform vec2 camera_frac = vec2(0.0, 0.0);
uniform float camera_zoom = 1.0;
uniform vec2 viewport_size = vec2(720.0, 1280.0);
uniform float cell_size = 220.0;
uniform vec4 base_color : source_color = vec4(0.13, 0.025, 0.22, 1.0);
uniform vec4 crater_color : source_color = vec4(0.055, 0.008, 0.11, 1.0);
uniform vec4 highlight_color : source_color = vec4(0.52, 0.17, 0.7, 1.0);

// Row scan range. 4 rows x a handful of hashes each is far cheaper than
// lunar's 5x5 (25-sample) crater scan - this shader has to stay renderable
// through the softpipe software rasterizer the screenshot harness uses.
const int ROW_SCAN = 2; // rows -1..+2
const float MIN_THICKNESS = 0.25;
const float MAX_THICKNESS = 0.55;
const float TURBULENCE_STRENGTH = 0.22;
const float DRIFT_SPEED = 0.045; // cells per second, lateral

// Same hash21 formulation as lunar_surface.gdshader (Dave Hoskins, all
// multipliers < 1 so it stays accurate at any cell-index magnitude).
float hash21(vec2 p) {
	vec3 p3 = fract(vec3(p.xyx) * 0.1031);
	p3 += dot(p3, p3.yzx + 33.33);
	return fract((p3.x + p3.y) * p3.z);
}

// Splits a float into an exact integer part and a [0,1) remainder - the
// same floor/subtract trick `rel` -> `cell_rel` + `local` already uses
// below, generalized so it can also fold TIME-based drift into a lattice
// coordinate without ever forming one large continuous float.
vec2 int_frac(float v) {
	float i = floor(v);
	return vec2(i, v - i);
}

// Combines two already-safe (integer, fraction) pairs - e.g. a cell index
// plus a drift offset - by adding the integers (exact, since both are
// integers) and the fractions (both in [0,1), so the sum is in [0,2)),
// then re-normalizing any carry out of the fraction back into the integer
// part. Never adds an integer directly to a fraction.
vec2 combine_lattice(vec2 base, vec2 add) {
	float f = base.y + add.y;
	float carry = floor(f);
	return vec2(base.x + add.x + carry, f - carry);
}

// 1D value noise over an integer lattice, given as a pre-split (i, f) pair:
// hashes the two neighboring integers and blends by the fraction. `axis`
// varies the hash sequence so different callers (different rows, or the
// turbulence octaves) don't sample the same noise.
float value_noise(vec2 coord, float axis) {
	float a = hash21(vec2(coord.x, axis));
	float b = hash21(vec2(coord.x + 1.0, axis));
	return mix(a, b, smoothstep(0.0, 1.0, coord.y));
}

void fragment() {
	vec2 screen_px = UV * viewport_size;
	vec2 centered = screen_px - viewport_size * 0.5;

	// Identical split to lunar_surface.gdshader: `rel` is always small and
	// camera-relative, `cell` is an exact integer built from two integers
	// (camera_cell + cell_rel), and `local` is the bounded [0,1) remainder.
	vec2 rel = camera_frac + centered * (camera_zoom / cell_size);
	vec2 cell_rel = floor(rel);
	vec2 local = rel - cell_rel;
	vec2 cell = camera_cell + cell_rel;

	// Lateral drift, folded into the X lattice coordinate the safe way:
	// TIME is unbounded but session-scale (the ticket calls for using it
	// directly, no extra uniform), so it gets its own int/frac split and is
	// combined with the cell's via combine_lattice() rather than added to
	// cell.x as one continuous float.
	vec2 drift = int_frac(TIME * DRIFT_SPEED);
	vec2 turb_x = combine_lattice(vec2(cell.x, local.x), drift);

	// Nearest-row-wins band field, the same single-scalar discipline as
	// lunar_surface.gdshader's nearest-crater distance: every visual below
	// is a pure function of `nearest`, so the band body and its crest can
	// never describe two different bands.
	float nearest = 1000.0;
	for (int dy = -1; dy <= ROW_SCAN; dy++) {
		float row = cell.y + float(dy);
		float band_centre = hash21(vec2(row, 5.0));
		float thickness = mix(MIN_THICKNESS, MAX_THICKNESS, hash21(vec2(row, 8.0)));

		// Two octaves of drifting turbulence, phased per-row so neighboring
		// bands don't ripple in lockstep.
		float turb = value_noise(turb_x, row * 3.7 + 11.0) * 0.65
			+ value_noise(vec2(turb_x.x * 2.0, turb_x.y), row * 3.7 + 47.0) * 0.35;

		// Safe: local.y is bounded [0,1), dy and row are small integers, so
		// this stays a small camera-relative value with no huge magnitude.
		float to_band = (local.y - float(dy)) - band_centre;
		to_band += (turb - 0.5) * TURBULENCE_STRENGTH;

		float normalized = abs(to_band) / thickness;
		nearest = min(nearest, normalized);
	}

	float core = 1.0 - smoothstep(0.0, 0.6, nearest);
	float crest = smoothstep(0.5, 0.75, nearest) * (1.0 - smoothstep(0.75, 1.0, nearest));

	vec3 color = base_color.rgb;
	color = mix(color, crater_color.rgb, core * 0.85);
	color = mix(color, highlight_color.rgb, crest * 0.6);

	// Same dither as lunar_surface.gdshader, to mask 8-bit banding on the
	// smooth band gradients.
	float dither = (hash21(screen_px + vec2(7.0, 13.0)) - 0.5) / 128.0;
	color += vec3(dither);

	COLOR = vec4(color, 1.0);
}