A name that a sprite already owns cannot name a property, and a division by zero cannot answer (#63, #64)

#63: a shader Property node named "width" quietly took over the sprite
row of the same name. isSpriteProp lives in PropertySchema now and is
derived from FULL_SCHEMAS.sprite instead of being a second list that
drifts. isValidPropertyName rejects those ten names, and the compiler
reports it at the node as its own problem: "width" is a sprite
property, told apart from "not a word" and from a duplicate.

#64: Divide emitted (a / b) and handed NaN to the driver. It emits
divide(a, b) now, with the guard in the prologue next to straight(),
scalar and per channel: zero divided by zero is zero. That was already
the house rule in the behavior and particle graphs - only the shader
had never been told. Clamp comes along as a shader node for the same
reason: the behavior catalog has had it all along.

src/core/shader/compile.ts

@@ -1,9 +1,11 @@
 import { edgesInto, findNode, type Graph, type GraphNode } from '../graph/Graph';
 import { nodeDef, type PortDef } from '../graph/NodeRegistry';
 import { colorOf } from '../model/Properties';
-import { isPropertyNode, isValidPropertyName, propertyName, shaderParamDefs } from '../properties/shaders';
+import { isSpriteProp, isValidFieldName } from '../properties/PropertySchema';
+import { isPropertyNode, propertyName, shaderParamDefs } from '../properties/shaders';
 import {
   asVec3,
+  DIVIDE_FN,
   type EdgeMode,
   edgeOf,
   type Expr,
@@ -74,7 +76,8 @@ export function compileShader(graph: Graph): ShaderBuild {
   for (const node of graph.nodes) {
     if (!isPropertyNode(node)) continue;
     const name = propertyName(node);
-    if (!isValidPropertyName(name)) problem(node, 'Name must be one word: letters, digits, _');
+    if (!isValidFieldName(name)) problem(node, 'Name must be one word: letters, digits, _');
+    else if (isSpriteProp(name)) problem(node, `"${name}" is a sprite property`);
     else if (names.has(name)) problem(node, `Another property is named "${name}"`);
     names.add(name);
   }
@@ -172,6 +175,7 @@ export function compileShader(graph: Graph): ShaderBuild {
     ...(time ? [`uniform float ${TIME_UNIFORM};`] : []),
     ...uniforms.map((u) => `uniform float ${uniformName(u.name)};`),
     STRAIGHT_FN,
+    DIVIDE_FN,
     'void main()',
     '{',
     '    vec4 texel = texture(uTexture, vTextureCoord) * vColor;',

src/core/shader/nodes.ts

@@ -287,7 +287,43 @@ export const ShaderMultiply = arithmetic(
   'a × b, per channel for colours.',
   1,
 );
-export const ShaderDivide = arithmetic('ShaderDivide', 'Divide', '/', 'a / b, per channel for colours.', 1);
+/**
+ * Division with an answer at zero. `a / 0.0` is NaN, and the epilog's `clamp(NaN, 0.0, 1.0)` is
+ * undefined in GLSL – the driver decides the pixel, so the same graph looks different on Intel,
+ * Nvidia and a phone (#64). Zero is the answer, the same one the `Divide` of a behavior graph and
+ * of a particle graph give.
+ */
+export const DIVIDE_FN = [
+  'float divide(float a, float b) { return b == 0.0 ? 0.0 : a / b; }',
+  'vec3 divide(vec3 a, vec3 b) { return vec3(divide(a.x, b.x), divide(a.y, b.y), divide(a.z, b.z)); }',
+].join('\n');
+
+export const ShaderDivide: ShaderNodeDef = {
+  type: 'ShaderDivide',
+  label: 'Divide',
+  category: 'shader',
+  description: 'a / b, per channel for colours. Dividing by 0 is 0, not a pixel the driver picks.',
+  inputs: [anyIn('a', 1), anyIn('b', 1)],
+  outputs: [anyOut('result')],
+  params: [],
+  emit: ({ a, b }) => {
+    const l = lifted(a!, b!);
+    return { result: { code: `divide(${l.a}, ${l.b})`, type: l.type } };
+  },
+};
+
+export const ShaderClamp: ShaderNodeDef = {
+  type: 'ShaderClamp',
+  label: 'Clamp',
+  category: 'shader',
+  description: 'Holds the value inside min..max, per channel for colours.',
+  inputs: [anyIn('value', 0), floatIn('min', 0), floatIn('max', 1)],
+  outputs: [anyOut('result')],
+  params: [],
+  emit: ({ value, min, max }) => ({
+    result: { code: `clamp(${value!.code}, ${min!.code}, ${max!.code})`, type: value!.type },
+  }),
+};
 
 export const ShaderMix: ShaderNodeDef = {
   type: 'ShaderMix',
@@ -423,6 +459,7 @@ export const SHADER_NODES: readonly ShaderNodeDef[] = [
   ShaderStep,
   ShaderPow,
   ShaderSqrt,
+  ShaderClamp,
 ];
 
 /** A GLSL float literal: always with a decimal point, so `1` does not become an int. */