A shader costs a source nothing, because a field was already one draw call (#88)

A particle source can wear a shader asset the way a sprite does, and it is the
cheapest place in the editor to wear one: a shaded sprite gives up its batch and
costs a draw call of its own, while `ParticleContainerPipe` breaks the batch for
every field regardless. Five hundred shaded particles are the one call five
hundred plain ones were.

The fragment the compiler emits needed no change, only a second vertex stage:
Pixi's particle vertex is GLSL ES 1.00 and ours is ES 3.00, so it is translated
rather than invented. What it sees is a particle's picture, not its life — the
buffer carries five fixed attributes and takes no sixth, so age, index and seed
stay on the graph, which is what the graph is for.

Two things the issue did not ask about:

`Shader.resources` is an accessor over the names its constructor declared, so a
slot that is not declared becomes a loose JS property and is never bound. The
adaptor writes `uTranslationMatrix` into whichever shader the container names —
without an empty block for it the vertex gets no matrix and the particles land
elsewhere.

`schemaOf` in serialize.ts hung on `schema !== schemaFor('sprite')`, an identity
check a source never satisfies, so its shader values would have been dropped on
save.

A source is the one asset drawing rows from two graphs, so a name can arrive
twice. Its own row wins and the uniform keeps its default; nothing is rejected
on the shader's side, because the collision exists only at this one wearer.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/core/properties/PropertySchema.ts

@@ -237,6 +237,8 @@ const ASSET_SCHEMAS: Record<AssetType, PropertySchema> = {
     { key: PARTICLE_TEXTURE_KEY, label: 'Texture', kind: 'texture', default: '' },
     { key: PARTICLE_COLOR_KEY, label: 'Color', kind: 'color', default: 0xffffff },
     { key: MOVE_WITH_SOURCE_KEY, label: 'Move with source', kind: 'boolean', default: false },
+    // Worn by every particle of the source, not by the field as a whole – see `schemaForBag`.
+    { key: SHADER_KEY, label: 'Shader', kind: 'asset', default: '', assetTypes: ['shader'] },
   ],
   collider: [
     {
@@ -297,7 +299,7 @@ export function schemaForAsset(project: Project, asset: Asset): PropertySchema {
   return schemaForBag(project, asset, asset.props);
 }
 
-/** A placed object's rows: a sprite overriding its shader has that shader's parameters. */
+/** A placed object's rows: an object overriding its shader has that shader's parameters. */
 export function schemaForObject(project: Project, asset: Asset, object: SceneObject): PropertySchema {
   const shader = object.overrides[SHADER_KEY];
   return schemaForBag(project, asset, shader === undefined ? asset.props : { [SHADER_KEY]: shader });
@@ -307,10 +309,24 @@ function schemaForBag(project: Project, asset: Asset, bag: PropertyBag): Propert
   if (asset.type === 'behavior') return [...FULL_SCHEMAS.behavior, ...asset.variables];
   if (asset.type === 'sprite') return [...FULL_SCHEMAS.sprite, ...shaderParamRows(project, shaderOf(bag))];
   // Unlike a sprite's shader, a source's graph is its own asset's, so no id has to be looked up.
-  if (asset.type === 'particles') return [...FULL_SCHEMAS.particles, ...particleParamDefs(asset.graph)];
+  if (asset.type === 'particles') {
+    const own = [...FULL_SCHEMAS.particles, ...particleParamDefs(asset.graph)];
+    return [...own, ...rowsNotClaimedBy(shaderParamRows(project, shaderOf(bag)), own)];
+  }
   return FULL_SCHEMAS[asset.type];
 }
 
+/**
+ * A source draws its rows from two graphs, so one name can arrive twice: `speed` on the particle
+ * graph and `speed` on the shader it wears. The source's own row wins and the uniform keeps its
+ * declared default – the shader cannot be blamed for the collision, the same one is legitimate on a
+ * sprite, so nothing is rejected on its side.
+ */
+export function rowsNotClaimedBy(rows: readonly PropertyDef[], taken: readonly PropertyDef[]): PropertyDef[] {
+  const claimed = new Set(taken.map((d) => d.key));
+  return rows.filter((row) => !claimed.has(row.key));
+}
+
 /** The rows a shader asset adds to the sprites wearing it; a dangling id adds none. */
 export function shaderParamRows(project: Project, shaderId: string): PropertyDef[] {
   const shader = shaderId ? findAssetOf(project, shaderId, 'shader') : undefined;