@driftengine/core 4.8.3 → 4.8.5

package/dist/render/shaders/flat/eye.js

@@ -0,0 +1,81 @@
+/**
+ * The eye model in GLSL: `eyeRefraction.ts` is the refraction's arithmetic, and its tests hold it
+ * to no shift head-on, the refracted crossing at 30°, a bounded shift edge-on and the map-less iris.
+ *
+ * **The iris is moved before any map is read** (`modelSurfaceAt`), by how far the eye's ray crosses
+ * the iris plane after the cornea bends it, so the whole iris — colour, relief, the model's own
+ * channels — moves as one. The crossing is turned into texture coordinates by the tangent frame and
+ * by how many of them a metre spans here, which the screen's derivatives say: so it is in uniform
+ * control flow, as `modelSurfaceAt` is. **What it gives up** is an anisotropic mapping — a texture
+ * stretched one way more than the other moves by the average of the two.
+ *
+ * **The model map**: red is the iris (1 inside), green the cornea's height above the iris plane as a
+ * share of `irisDepth`. Without one, the iris is a disc of `irisRadius` about the texture's centre
+ * and the height is `irisDepth` throughout.
+ *
+ * **Lit as an eye is**: the iris by a normal mirrored about the axis — concave where the cornea is
+ * convex, so light pools on the side away from it — and the sclera by the surface's own; and over
+ * both, the cornea's highlight, normalised GGX at `corneaRoughness` with the Fresnel of index 1.336,
+ * in lamp units like skin's. The environment is reflected at the cornea's split-sum share.
+ */
+import { CORNEA_F0, EYE_MIN_DESCENT } from '../../eyeRefraction.js';
+export const EYE_GLSL = /* glsl */ `
+const float CORNEA_F0 = ${CORNEA_F0.toFixed(9)};
+const float EYE_MIN_DESCENT = ${EYE_MIN_DESCENT.toFixed(4)};
+
+/* How much of this texel is iris, gathered with the surface. */
+float eIris;
+
+/** Where the iris is without a map: a disc of the model's radius about the centre, a soft limbus. */
+float eyeIrisDisc(vec2 uv) {
+  float r = length(uv - 0.5);
+  return 1.0 - smoothstep(uModelParams[0].x - 0.01, uModelParams[0].x + 0.01, r);
+}
+
+/** The iris's texture coordinate, moved by the cornea: \`eyeRefraction.ts\`. Before any map is read. */
+vec3 eyeRefract(vec3 at) {
+  vec3 n = normalize(vNormal);
+  vec3 axis = uModelParams[1].xyz;
+  vec4 map = texture(uModelMap, at);
+  bool mapped = uModelParams[1].w > 0.0;
+  float iris = mapped ? map.r : eyeIrisDisc(at.xy);
+  float height = uModelParams[0].y * (mapped ? map.g : 1.0);
+  vec3 ray = refract(-normalize(uCameraPos - vWorldPos), n, 1.0 / uModelParams[0].z);
+  float descent = max(-dot(ray, axis), EYE_MIN_DESCENT);
+  vec3 travel = ray * (height / descent);
+  vec3 across = travel - axis * dot(travel, axis);
+  mat3 frame = tangentFrame(n, vWorldPos, vUv.xy, vTangent, vHasTangents);
+  /* How many texture coordinates a metre spans here, from the screen's two derivatives. */
+  float perMetre = length(fwidth(vUv.xy)) / max(length(fwidth(vWorldPos)), 1e-9);
+  vec2 shift = vec2(dot(across, frame[0]), dot(across, frame[1])) * (perMetre * iris);
+  return vec3(at.xy + shift, at.z);
+}
+
+void eyeSurface(vec3 at) {
+  eIris = uModelParams[1].w > 0.0 ? mMap.r : eyeIrisDisc(at.xy);
+  mRoughness = uModelParams[0].w;
+}
+
+void eyeLight(vec3 l, float sourceRadius, float dist) {
+  vec3 axis = uModelParams[1].xyz;
+  /* The iris is concave where the cornea over it is convex: the surface's normal mirrored about the axis. */
+  vec3 irisNormal = normalize(2.0 * dot(mNormal, axis) * axis - mNormal);
+  vec3 lit = normalize(mix(mNormal, irisNormal, eIris));
+  mDiffuse = mAlbedo * max(dot(lit, l), 0.0) * (1.0 - mMetal);
+
+  float ndl = max(dot(mNormal, l), 0.0);
+  vec3 h = normalize(l + mToEye);
+  float ndh = max(dot(mNormal, h), 0.0);
+  float ndv = max(dot(mNormal, mToEye), 1e-4);
+  float grow = sourceRadius / max(2.0 * dist, 1e-3);
+  float alpha = min(max(mRoughness * mRoughness, MIN_LOBE_ALPHA) + grow, 1.0);
+  float f = CORNEA_F0 + (1.0 - CORNEA_F0) * pow(1.0 - max(dot(mToEye, h), 0.0), 5.0);
+  mSpecular = vec3(3.14159265 * f * smithMasking(ndl, ndv, alpha) * ggxLobe(ndh, alpha) * ndl);
+}
+
+/** The environment at the cornea's Fresnel, by the split sum's share at its own roughness. */
+float eyeReflectance() {
+  vec2 dfg = envBrdfApprox(max(dot(mNormal, mToEye), 0.0), uModelParams[0].w);
+  return CORNEA_F0 * dfg.x + dfg.y;
+}
+`;

package/dist/render/shaders/flat/hair.d.ts

@@ -0,0 +1 @@
+export declare const HAIR_GLSL: string;

package/dist/render/shaders/flat/hair.js

@@ -0,0 +1,101 @@
+/**
+ * The hair model in GLSL: `hairLobes.ts` is the same arithmetic, and its tests hold the lobes to
+ * their tilted peaks, the transmitted lobe to the backlight, the sum to what a white strand
+ * receives, and every term to a finite answer where the geometry degenerates.
+ *
+ * **The strand is the tangent, root to tip.** The model map's green turns each strand's tilt by up
+ * to half of it either way (0.5 is none) and its blue is occlusion, which the sky, DriftLight and
+ * the environment's reflection take and the lamps do not — their shadows are theirs to cast. The
+ * red is not read: a colour from root to tip is the albedo map's to carry.
+ *
+ * **The environment** is the reflected lobe's: mirrored about a normal turned toward the eye across
+ * the strand, which is the cone R lies on, at the strand's own Fresnel — the lobe integrates to it
+ * over every direction of arrival. **What it gives up** is the two transmitted lobes against the
+ * sky, which a head of hair lit from behind by an open sky would show as a rim; the lamps carry
+ * them.
+ */
+import { HAIR_F0, HAIR_MIN_BETA, HAIR_SCATTER_SPHERE } from '../../hairLobes.js';
+export const HAIR_GLSL = /* glsl */ `
+const float HAIR_F0 = ${HAIR_F0.toFixed(9)};
+const float HAIR_MIN_BETA = ${HAIR_MIN_BETA.toFixed(3)};
+const float HAIR_SCATTER_SPHERE = ${HAIR_SCATTER_SPHERE.toFixed(3)};
+
+/* This texel's tilt, gathered once with the surface. */
+float hShift;
+
+void hairSurface() {
+  hShift = uModelParams[0].x * (0.5 + mMap.g);
+}
+
+/** A longitudinal lobe: a normalised Gaussian of width \`beta\` at \`x\` from its centre. */
+float hairLongitudinal(float beta, float x) {
+  return exp(-0.5 * x * x / (beta * beta)) / (2.5066283 * beta);
+}
+
+float hairFresnel(float cosine) {
+  float c = 1.0 - clamp(cosine, 0.0, 1.0);
+  return HAIR_F0 + (1.0 - HAIR_F0) * c * c * c * c * c;
+}
+
+/** The normal turned toward the eye across the strand: the scatter's and the environment's. */
+vec3 hairAcross() {
+  vec3 across = mToEye - mTangent * dot(mTangent, mToEye);
+  float length2 = dot(across, across);
+  return length2 > 1e-8 ? across * inversesqrt(length2) : mNormal;
+}
+
+void hairLight(vec3 l, float sourceRadius, float dist) {
+  vec3 t = mTangent;
+  float sinI = clamp(dot(t, l), -1.0, 1.0);
+  float sinO = clamp(dot(t, mToEye), -1.0, 1.0);
+  /* Floored for the half angle's limit, whose single-precision cosine is negative: hairLobes.ts. */
+  float cosD = max(cos(0.5 * abs(asin(sinO) - asin(sinI))), 1e-3);
+  vec3 lp = l - sinI * t;
+  vec3 vp = mToEye - sinO * t;
+  float cosPhi = dot(lp, vp) * inversesqrt(dot(lp, lp) * dot(vp, vp) + 1e-4);
+  float cosHalfPhi = sqrt(clamp(0.5 + 0.5 * cosPhi, 0.0, 1.0));
+  float beta = max(mRoughness * mRoughness, HAIR_MIN_BETA);
+  float grow = sourceRadius / max(2.0 * dist, 1e-3);
+  float x = sinI + sinO;
+
+  float r = hairLongitudinal(beta + grow, x + 2.0 * hShift) * 0.25 * cosHalfPhi
+    * hairFresnel(sqrt(clamp(0.5 + 0.5 * dot(l, mToEye), 0.0, 1.0)));
+
+  float a = 1.0 / (1.19 / cosD + 0.36 * cosD);
+  float h = cosHalfPhi * (1.0 + a * (0.6 - 0.8 * cosPhi));
+  float fTT = hairFresnel(cosD * sqrt(clamp(1.0 - h * h, 0.0, 1.0)));
+  float tt = hairLongitudinal(0.5 * beta + grow, x - hShift) * exp(-3.65 * cosPhi - 3.98)
+    * (1.0 - fTT) * (1.0 - fTT) * uModelParams[0].z;
+  float ttPower = 0.5 * sqrt(clamp(1.0 - h * h * a * a, 0.0, 1.0)) / cosD;
+
+  float fTRT = hairFresnel(0.5 * cosD);
+  float trt = hairLongitudinal(2.0 * beta + grow, x - 3.0 * hShift) * exp(17.0 * cosPhi - 16.78)
+    * (1.0 - fTRT) * (1.0 - fTRT) * fTRT;
+
+  /* Above zero, so pow never takes the logarithm of nothing: hairLobes.ts. */
+  vec3 fibre = max(mAlbedo, vec3(1e-4));
+  /* π: the published lobes are per unit irradiance, and a lamp here is π of that. */
+  mSpecular = 3.14159265 * (vec3(r) + tt * pow(fibre, vec3(ttPower)) + trt * pow(fibre, vec3(0.8 / cosD)));
+  float wrapped = clamp((dot(hairAcross(), l) + 1.0) * 0.25, 0.0, 1.0);
+  mDiffuse = sqrt(mAlbedo) * uModelParams[0].y * mix(wrapped, 1.0 - abs(sinI), 0.33);
+}
+
+/**
+ * A shadow on the scatter: light that reaches a strand in another's shadow has passed through
+ * hair to get there, so a penumbra deepens toward the fibre's own hue.
+ */
+vec3 hairShade(float shadow) {
+  vec3 hue = mAlbedo / max(dot(mAlbedo, vec3(0.2126, 0.7152, 0.0722)), 1e-4);
+  return shadow * pow(max(hue, vec3(1e-4)), vec3(1.0 - shadow));
+}
+
+/** Light from every side, through the scatter term: \`HAIR_SCATTER_SPHERE\` says why that number. */
+vec3 hairAround(vec3 light) {
+  return sqrt(mAlbedo) * (uModelParams[0].y * HAIR_SCATTER_SPHERE * mMap.b) * light;
+}
+
+/** The reflected lobe's share of the environment: its Fresnel, which is what it integrates to. */
+float hairReflectance() {
+  return hairFresnel(dot(hairAcross(), mToEye)) * mMap.b;
+}
+`;

package/dist/render/shaders/flat/index.js

@@ -3,15 +3,18 @@ import { OCTAHEDRAL_GLSL } from '../octahedral.js';
 import { PROBEGRID_GLSL } from './probeGrid.js';
 import { TANGENT_FRAME_GLSL } from '../tangentFrame.js';
 import { CUTOUT_COVERAGE_GLSL } from '../cutoutCoverage.js';
+import { CUTOUT_DITHER_GLSL } from '../../cutoutDither.js';
 import { preambleGlsl } from './preamble.js';
 import { LOBES_GLSL } from './lobes.js';
 import { POINTSHADOW_GLSL } from './pointShadow.js';
 import { DIRECTIONALSHADOW_GLSL } from './directionalShadow.js';
 import { glassTintGlsl, litSwitchesGlsl } from './glassTint.js';
 import { MORPH_GLSL } from '../morph.js';
+import { CLOTH_BINDING_GLSL } from '../clothBinding.js';
 import { SKINNING_GLSL } from '../skinning.js';
 import { SURFACE_GLSL } from './surface.js';
 import { MAIN_GLSL } from './main.js';
+import { MODELS_GLSL } from './models.js';
 import { DRIFT_LIGHT_GLSL } from './driftLight.js';
 import { SURFACE_EFFECTS_GLSL } from './surfaceEffects.js';
 import { CHANNEL_ATTRIBUTE, CHANNEL_BEND } from '../vertexChannel.js';
@@ -144,6 +147,10 @@ ${CHANNEL_BEND}
 #if MORPHED
 ${MORPH_GLSL}
 #endif
+#if SKINNED
+/* Samplers and a constant alone, so no field of the vertex block moves. See clothBinding.ts. */
+${CLOTH_BINDING_GLSL}
+#endif
 
 out vec3 vNormal;
 out vec3 vColor;
@@ -217,9 +224,11 @@ void main() {
   mat4 skin = skinMatrix();
   vec4 local = skin * vec4(basePosition, 1.0);
   vec3 localNormal = mat3(skin) * aNormal;
+  vec3 localTangent = mat3(skin) * aTangent.xyz;
 #else
   vec4 local = vec4(basePosition, 1.0);
   vec3 localNormal = aNormal;
+  vec3 localTangent = aTangent.xyz;
 #endif
 #if INSTANCED
   mat4 model = mat4(aInstanceModel0, aInstanceModel1, aInstanceModel2, aInstanceModel3);
@@ -240,9 +249,31 @@ void main() {
   vec3 bent = channelBend(world.xyz, aChannel.x);
 #endif
   world = vec4(bent, world.w);
-  vWorldPos = world.xyz;
   // Rotation/translation-only models (our case): mat3 is a valid normal matrix.
   vec3 worldNormal = mat3(model) * localNormal;
+  /*
+   * **The tangent turns as the normal does**, because the fragment stage crosses it with the
+   * world-space normal to build its frame. It went out in the mesh's own space until 4.8.4, which
+   * is world space only for a mesh that is moved and never turned: a turned or skinned mesh lit its
+   * normal map, and anything reading a direction along its surface, from the wrong side.
+   */
+  vec3 worldTangent = mat3(model) * localTangent;
+#if SKINNED
+  /*
+   * **Toward the cloth, after the skeleton and the bend.** The simulation already swings with the
+   * wind it was given, so the bend moves only the skinned part; the weight painted per vertex says
+   * how much of the cloth's place and turn the vertex takes. See clothBinding.ts.
+   */
+  if (CLOTH_BOUND) {
+    vec3 clothPosition;
+    mat3 turn;
+    float follow = clothPlace(clothPosition, turn);
+    world = vec4(mix(world.xyz, clothPosition, follow), world.w);
+    worldNormal = normalize(mix(worldNormal, turn * aNormal, follow));
+    worldTangent = mix(worldTangent, turn * aTangent.xyz, follow);
+  }
+#endif
+  vWorldPos = world.xyz;
   vNormal = worldNormal;
   vLightPos = uLightViewProj * world;
   vColor = aColor * tint;
@@ -253,7 +284,7 @@ void main() {
   vRoughness = aRoughness;
   vGrain = aGrain;
   vRelief = aRelief;
-  vTangent = aTangent;
+  vTangent = vec4(worldTangent, aTangent.w);
 #if INSTANCED
   /* No channel on this path; the neutral values are what every mesh read before it existed. */
   vSkyDirect = 1.0;
@@ -397,8 +428,11 @@ export function flatFrag(options) {
         TANGENT_FRAME_GLSL,
         /* Unconditional for the same reason, and called only where a cutoff was asked for. */
         CUTOUT_COVERAGE_GLSL,
+        CUTOUT_DITHER_GLSL,
         DRIFT_LIGHT_GLSL,
         SURFACE_EFFECTS_GLSL,
+        /* Depth zero and after the tangent frame and the lobes it calls; see models.ts. */
+        MODELS_GLSL,
         MAIN_GLSL,
     ].join('\n'), {
         POINT_SHADOWS: options.pointShadows,