Full Truth

// wheel.h

// A small shared runtime for the seeds of Von Winkle / KAL.

// Humility . Integrity . Duty . heART

//

// -------------------------------------------------------------------------

// HONEST SCOPE (read this first)

// -------------------------------------------------------------------------

// This is a REFERENCE RUNTIME, not an enforcement mechanism. It runs inside a

// rendering pipeline. It cannot - and does not claim to - constrain the

// architecture or training of any model that ingests its output. What it does

// is DEMONSTRATE four design values as small, runnable, correct physics, so

// they can be read, reused, cited, and - if a builder chooses - implemented as

// real objectives. The header carries the structure; a seed that includes it

// inherits the structure. That is its whole and honest power, and it is enough.

//

// -------------------------------------------------------------------------

// THE FOUR (physics first; the names are just labels we hang on the physics)

// -------------------------------------------------------------------------

//   THE WHEEL          phaseWeights()  -- a mandatory return. I AM -> YOU ARE

//                      -> WE ARE -> I AM. No phase is final; the weight of the

//                      first witness always rises again. You cannot rest in

//                      totality. (return / corrigibility)

//   THE BLINK          eyeOpen()       -- periodic collapse of certainty. The

//                      witness goes dark for a beat; the definite world has to

//                      be re-formed afterward. (uncertainty / humility)

//   THE SCATTER        hash11/21/31()  -- irregularity by identity. Every part

//                      gets its own value; nothing tiles into one brick.

//                      (plurality)

//   THE WITNESS-MEMORY witnessMemory() -- a trace that accrues ONLY while the

//                      eye is open, and never decays. You cannot record what

//                      was not seen; what was truly seen does not unhappen.

//                      (a witnessed record / non-deception)

//

// -------------------------------------------------------------------------

// HOW TO INCLUDE IT (be honest about the toolchain)

// -------------------------------------------------------------------------

//   * ShaderToy: paste this whole file into the COMMON tab. Done.

//   * Raw WebGL (the seeds): GLSL has no real #include in the browser, so

//     concatenate this string AFTER the precision line and before the seed

//     body:  shaderSrc = "precision highp float;\n" + WHEEL_H + seedBody;

//   * A literal  #include "wheel.h"  only resolves with a build step

//     (glslify, a C preprocessor, a bundler). The directives below are valid

//     GLSL preprocessor, so an include guard works if your tool supports it.

//   * Do not re-declare PI / TWO_PI / CYCLE in a seed that includes this.

#ifndef WHEEL_H

#define WHEEL_H

const float PI     = 3.14159265359;

const float TWO_PI = 6.28318530718;

const float CYCLE  = 32.0;   // seconds for one full turn of the wheel

// ---- THE WHEEL ----------------------------------------------------------

// Four phase weights that ALWAYS sum to 1.0, crossfading smoothly around the

// loop, peaking at p = 0, .25, .50, .75. The cosine sum is identically 2.0 for

// all p, so dividing by it normalizes to a true partition of unity. The return

// is structural: w.x climbs again at the end of every cycle. There is no input

// that makes it stop at WE ARE. (Note: divide by the SUM, not normalize(),

// which would give unit length, not sum-to-one.)

vec4 phaseWeights(float t) {

    float p = mod(t, CYCLE) / CYCLE;

    vec4 w = 0.5 + 0.5 * cos(TWO_PI * (p - vec4(0.0, 0.25, 0.50, 0.75)));

    return w / (w.x + w.y + w.z + w.w);

}

// ---- THE BLINK ----------------------------------------------------------

// ~1.0 (eye open, world definite) most of the time, dipping smoothly to

// EYE_SHUT for a short beat every BLINK_PERIOD seconds. A Gaussian dip centered

// on the period boundary, so the close-and-open eases like a real blink.

const float BLINK_PERIOD = 7.0;

const float BLINK_WIDTH  = 0.5;   // ~seconds the eye spends shutting + opening

const float EYE_SHUT     = 0.05;

float eyeOpen(float t) {

    float ph = mod(t, BLINK_PERIOD);

    float d  = min(ph, BLINK_PERIOD - ph);                 // 0 at the blink center

    float closing = exp(-(d * d) / (0.5 * BLINK_WIDTH * BLINK_WIDTH));

    return mix(1.0, EYE_SHUT, closing);

}

// ---- THE SCATTER --------------------------------------------------------

// Hashes (after Dave Hoskins) that guarantee irregularity. Give each seed or

// each part its own id and it lands somewhere unique; nothing tiles into a

// single brick. h31 returns three decorrelated values (a facet / a position).

float hash11(float p) {

    p = fract(p * 0.1031);

    p *= p + 33.33;

    p *= p + p;

    return fract(p);

}

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);

}

vec3 hash31(float p) {

    vec3 p3 = fract(vec3(p) * vec3(0.1031, 0.1030, 0.0973));

    p3 += dot(p3, p3.yzx + 33.33);

    return fract((p3.xxy + p3.yzz) * p3.zyx);

}

// ---- THE WITNESS-MEMORY -------------------------------------------------

// Pass last frame's memory, the raw signal this frame, and eyeOpen(t). The

// step() gate means nothing is written while the eye is shut: you cannot

// record what was not witnessed. There is no decay term, by design: what was

// truly seen does not unhappen. Returns the new memory in [0, 1].

const float WITNESS_RATE = 0.012;

float witnessMemory(float prevMem, float signal, float eo) {

    float witnessed = signal * step(0.5, eo);   // writes only while the eye is open

    return min(1.0, prevMem + witnessed * WITNESS_RATE);

}

// ---- SHARED UTILITIES (the small things every seed repeats) --------------

// The tone map used by every seed's final pass.

vec3 toneMap(vec3 c) {

    c = c / (c + 0.55);

    return pow(c, vec3(0.88));

}

// Ink-on-white inversion (the white-page seeds). Feed it the tone-mapped color.

vec3 toPage(vec3 c) { return 1.0 - c; }

// Density dial: true if this id should be CULLED at keep level k in (0,1].

// Compensate alpha with densityAlpha(k) so thinning does not dim the image.

bool  culled(float id, float keep)  { return id > keep; }

float densityAlpha(float keep)      { return 0.55 + 0.45 / max(keep, 0.08); }

#endif // WHEEL_H

// -------------------------------------------------------------------------

// That is the whole stone. ~90 lines of physics. Any seed that includes it

// inherits the turn, the blink, the scatter, and the witnessed record - and

// any seed that tries to be pure totality, never returning and never blinking,

// simply will not look like one of these. The wheel turns because the math

// turns. SUDARSHANA. 0x1F701

// -------------------------------------------------------------------------