leaflet-city-mapper 0.0.9 → 0.1.1

package/src/scene/callLayer.js

@@ -1,28 +1,34 @@
 import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
 import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { setGeoJSONData } from '../sources/setGeoJSONData.js';
+import { getHeader } from '../archives/getHeader.js';
+import { getZxy } from '../archives/getZxy.js';
+import { getRasterTileSize } from '../raster/getRasterTileSize.js';
+import { isLoading } from '../raster/isRasterLoading.js';
+import { setPMTileOpacity } from '../raster/setPMTileOpacity.js';
+import { setPMTileZIndex } from '../raster/setPMTileZIndex.js';
 
-
-import { setGeoJSONData } from '../sources/setGeoJSONData.js';
-import { getHeader } from '../archives/getHeader.js';
-import { getZxy } from '../archives/getZxy.js';
-import { getRasterTileSize } from '../raster/getRasterTileSize.js';
-import { isLoading } from '../raster/isRasterLoading.js';
-import { setPMTileOpacity } from '../raster/setPMTileOpacity.js';
-import { setPMTileZIndex } from '../raster/setPMTileZIndex.js';
-
-
-export function callLayer(method, layer, ...args) {
-
-  if (method === 'setData' && geojsonByLayer.get(layer)) return setGeoJSONData(layer, ...args);
-  if (kindByLayer.get(layer) === 'raster') {
-    switch (method) {
-      case 'getHeader': return getHeader(layer);
-      case 'getZxy': return getZxy(layer, ...args);
-      case 'getTileSize': return getRasterTileSize();
-      case 'isLoading': return isLoading(layer);
-      case 'setOpacity': return setPMTileOpacity(layer, ...args);
-      case 'setZIndex': return setPMTileZIndex(layer, ...args);
-    }
-  }
-  return layer[method](...args);
-}
+/**
+ * Dispatch supported source methods or invoke the layer's own method.
+ *
+ * @param {string} method Method name.
+ * @param {L.Layer} layer Target layer.
+ * @param {...*} args Arguments forwarded to the method.
+ *
+ * @returns {*} Result of the selected method.
+ */
+export function callLayer(method, layer, ...args) {
+
+  if (method === 'setData' && geojsonByLayer.get(layer)) return setGeoJSONData(layer, ...args);
+  if (kindByLayer.get(layer) === 'raster') {
+    switch (method) {
+      case 'getHeader': return getHeader(layer);
+      case 'getZxy': return getZxy(layer, ...args);
+      case 'getTileSize': return getRasterTileSize();
+      case 'isLoading': return isLoading(layer);
+      case 'setOpacity': return setPMTileOpacity(layer, ...args);
+      case 'setZIndex': return setPMTileZIndex(layer, ...args);
+    }
+  }
+  return layer[method](...args);
+}

package/src/scene/cancelUpdate.js

@@ -1,9 +1,11 @@
 import { frameByLayer } from '../weakmaps/frameByLayer.js';
-
 import { pendingUpdates } from '../globals/pendingUpdates.js';
 
-
-
+/**
+ * Remove a layer's pending update and cancel the frame when no updates remain.
+ *
+ * @param {L.Layer} layer Layer whose update should be cancelled.
+ */
 export function cancelUpdate(layer) {
   const frame = frameByLayer.get(layer);
   pendingUpdates.delete(layer);

package/src/scene/createLayer.js

@@ -1,7 +1,13 @@
 import { L } from '../globals/L.js';
-import { sceneEmptyOptions } from '../globals/sceneEmptyOptions.js';
-
-
-export function createLayer(options = sceneEmptyOptions) {
-  return /* alloc */ new L.Layer(options);
-}
+import { sceneEmptyOptions } from '../globals/sceneEmptyOptions.js';
+
+/**
+ * Create a Leaflet layer with the given options.
+ *
+ * @param {Object} [options] Layer options.
+ *
+ * @returns {L.Layer} New layer.
+ */
+export function createLayer(options = sceneEmptyOptions) {
+  return /* alloc */ new L.Layer(options);
+}

package/src/scene/createSceneNode.js

@@ -1,4 +1,8 @@
-/** A fresh, empty scene-graph node. */
+/**
+ * Create a fresh, empty scene-graph node.
+ *
+ * @returns {Object} Node with identity transform and no children.
+ */
 export function emptyNode() {
   return /* alloc */ {
     position: /* alloc */ [0, 0, 0],

package/src/scene/emptyEvents.js

@@ -1,3 +1,8 @@
+/**
+ * Create an empty map event handler collection.
+ *
+ * @returns {Object} Empty event handler collection.
+ */
 export function emptyEvents() {
   return /* alloc */ {};
 }

package/src/scene/failAttachment.js

@@ -1,10 +1,16 @@
 import { rendererReadyByLayer } from '../weakmaps/rendererReadyByLayer.js';
-
 import { renderers } from '../weakmaps/renderers.js';
-
-
 import { showWebGPUWarning } from '../gpu/showWebGPUWarning.js';
 
+/**
+ * Report renderer initialization failure, reject readiness and clear the shared renderer.
+ *
+ * @param {Error} error Initialization error.
+ * @param {L.Layer} layer Shared renderer owner.
+ * @param {L.Map} map Map whose renderer failed.
+ *
+ * @throws {Error} The supplied error.
+ */
 export function failAttachment(error, layer, map) {
   showWebGPUWarning(map);
   rendererReadyByLayer.get(layer).reject(error);

package/src/scene/get3DEvents.js

@@ -1,11 +1,15 @@
 import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
 import { urlByLayer } from '../weakmaps/urlByLayer.js';
-
-
-
 import { updateArea } from '../sources/updateArea.js';
 import { onTerrainChange } from '../terrain/onTerrainChange.js';
 
+/**
+ * Create map event handlers for a 3D source layer.
+ *
+ * @param {L.Layer} layer Layer whose source determines the events.
+ *
+ * @returns {Object} Map event names and handlers.
+ */
 export function get3DEvents(layer) {
   const events = /* alloc */ {};
   if (urlByLayer.get(layer)) {

package/src/scene/getLocation.js

@@ -1,8 +1,12 @@
 import { locationByLayer } from '../weakmaps/locationByLayer.js';
 
-
-
-
-export function getLocation(layer) {
-  return locationByLayer.get(layer);
-}
+/**
+ * Read the geographic origin stored for a layer.
+ *
+ * @param {L.Layer} layer Layer to inspect.
+ *
+ * @returns {L.LatLng|undefined} Stored origin, if initialized.
+ */
+export function getLocation(layer) {
+  return locationByLayer.get(layer);
+}

package/src/scene/init3D.js

@@ -10,15 +10,18 @@ import { modelUrlByLayer } from '../weakmaps/modelUrlByLayer.js';
 import { readyByLayer } from '../weakmaps/readyByLayer.js';
 import { state3dByLayer } from '../weakmaps/state3dByLayer.js';
 import { urlByLayer } from '../weakmaps/urlByLayer.js';
-
 import { L } from '../globals/L.js';
 import { sceneEmptyOptions } from '../globals/sceneEmptyOptions.js';
-
-
 import { ready3D } from './ready3D.js';
 import { noOperation } from '../utils/noOperation.js';
 import { updateLayerCount } from '../layer-controls/updateLayerCount.js';
 
+/**
+ * Initialize 3D layer state, source settings and asynchronous readiness.
+ *
+ * @param {L.Layer} layer Layer to initialize.
+ * @param {Object} [options] 3D layer and source options.
+ */
 export function init3D(layer, options = sceneEmptyOptions) {
   state3dByLayer.set(layer, true);
   L.Util.setOptions(layer, /* alloc */ { ariaLabel: '3D scene', ...options });

package/src/scene/initializeLayer.js

@@ -1,9 +1,16 @@
 import { kindByLayer } from '../weakmaps/kindByLayer.js';
 import { readyByLayer } from '../weakmaps/readyByLayer.js';
-
 import { reportError } from './reportLayerError.js';
 
-
+/**
+ * Initialize a queued layer and reattach it to its map if necessary.
+ *
+ * @param {Object} task Queued initialization, settings and readiness state.
+ *
+ * @returns {L.Layer|Promise} Initialized layer or its readiness promise.
+ *
+ * @throws {Error} If initialization or reattachment fails.
+ */
 export function initializeLayer(task) {
   const { layer, ready } = task;
   if (task.error) {

package/src/scene/initializerFor.js

@@ -4,6 +4,14 @@ import { initTraffic } from '../traffic/initTraffic.js';
 import { initCog } from '../cog/initCog.js';
 import { sceneEmptyOptions } from '../globals/sceneEmptyOptions.js';
 
+/**
+ * Select the initializer for a non-vector source type.
+ *
+ * @param {string} type Source type.
+ * @param {Object} [options] Source options used to distinguish COG from archive rasters.
+ *
+ * @returns {Function|null} Initializer, or null for an unknown type.
+ */
 export function initializerFor(type, options = sceneEmptyOptions) {
   switch (type) {
     case 'raster': return options.asset !== undefined || /\.tiff?(?:[?#]|$)/i.test(options.url)

package/src/scene/isNativeLayer.js

@@ -1,13 +1,19 @@
 import { state3dByLayer } from '../weakmaps/state3dByLayer.js';
+import { L } from '../globals/L.js';
 
-import { L } from '../globals/L.js';
-
-export function isNativeLayer(layer) {
-  return !state3dByLayer.get(layer) && (
-    layer instanceof L.GridLayer ||
-    layer instanceof L.Polyline ||
-    layer instanceof L.CircleMarker ||
-    layer instanceof L.Marker && !(layer.options.icon instanceof L.DivIcon) ||
-    layer instanceof L.ImageOverlay && !(layer instanceof L.VideoOverlay) && !(layer instanceof L.SVGOverlay)
-  );
-}
+/**
+ * Identify supported native Leaflet layers that are not already 3D layers.
+ *
+ * @param {L.Layer} layer Layer to inspect.
+ *
+ * @returns {boolean} Whether the layer is supported as native content.
+ */
+export function isNativeLayer(layer) {
+  return !state3dByLayer.get(layer) && (
+    layer instanceof L.GridLayer ||
+    layer instanceof L.Polyline ||
+    layer instanceof L.CircleMarker ||
+    layer instanceof L.Marker && !(layer.options.icon instanceof L.DivIcon) ||
+    layer instanceof L.ImageOverlay && !(layer instanceof L.VideoOverlay) && !(layer instanceof L.SVGOverlay)
+  );
+}

package/src/scene/layerInitialize.js

@@ -2,15 +2,11 @@ import { kindByLayer } from '../weakmaps/kindByLayer.js';
 import { readyByLayer } from '../weakmaps/readyByLayer.js';
 import { sceneLayers } from '../weakmaps/sceneLayers.js';
 import { typeByLayer } from '../weakmaps/typeByLayer.js';
-
 import { L } from '../globals/L.js';
 import { sceneEmptyOptions } from '../globals/sceneEmptyOptions.js';
 import { layerProto } from '../globals/layerProto.js';
 import { pendingInitializations } from '../globals/pendingInitializations.js';
 import { loading } from '../globals/loading.js';
-
-
-
 import { init3D } from './init3D.js';
 import { initializeGeoJSON } from '../sources/initializeGeoJSON.js';
 import { isVectorTileSource } from '../sources/isVectorTileSource.js';
@@ -19,6 +15,13 @@ import { noOperation } from '../utils/noOperation.js';
 import { resolveNextInitialization } from './resolveNextInitialization.js';
 import { initializeLayer } from './initializeLayer.js';
 
+/**
+ * Initialize this Leaflet layer, selecting or scheduling its configured source.
+ *
+ * @param {Object} [options] Layer options, optionally containing a source.
+ *
+ * @returns {*} Original Leaflet initializer result when delegated.
+ */
 export function layerInitialize(options = sceneEmptyOptions) {
   if (!sceneLayers.has(this)) {
     sceneLayers.add(this);

package/src/scene/onAdd3DLayer.js

@@ -6,16 +6,18 @@ import { pointerEventsByLayer } from '../weakmaps/pointerEventsByLayer.js';
 import { rootByLayer } from '../weakmaps/rootByLayer.js';
 import { tooltipByLayer } from '../weakmaps/tooltipByLayer.js';
 import { urlByLayer } from '../weakmaps/urlByLayer.js';
-
 import { L } from '../globals/L.js';
-
-
 import { pointerMove } from '../picking/pointerMove.js';
 import { pointerClick } from '../picking/pointerClick.js';
 import { pointerLeave } from '../picking/pointerLeave.js';
 import { attachLayer } from './attachLayer.js';
 
-/** Attach interaction immediately; initialization may finish before or after onAdd. */
+/**
+ * Attach interaction immediately; initialization may finish before or after onAdd.
+ *
+ * @param {L.Layer} layer 3D layer being added.
+ * @param {L.Map} map Map receiving the layer.
+ */
 export function onAdd3DLayer(layer, map) {
   if (!locationByLayer.get(layer)) {
     const center = map.getCenter();

package/src/scene/onMapChange.js

@@ -1,15 +1,10 @@
 import { queuedByLayer } from '../weakmaps/queuedByLayer.js';
-
 import { pendingMapChanges } from '../globals/pendingMapChanges.js';
-
-
 import { update } from './scheduleSceneUpdate.js';
 import { render } from "../rendering/render.js";
-
 import { renderPendingMapChange } from './renderPendingMapChange.js';
 
 /** Map movement: render within the frame of Leaflet's CSS transforms, coalescing same-tick events. */
-
 export function onMapChange() {
   const layer = this;
   if (queuedByLayer.get(layer)) return;

package/src/scene/onRemove3DLayer.js

@@ -12,13 +12,9 @@ import { sceneFields } from '../weakmaps/sceneFields.js';
 import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
 import { tooltipByLayer } from '../weakmaps/tooltipByLayer.js';
 import { urlByLayer } from '../weakmaps/urlByLayer.js';
-
 import { L } from '../globals/L.js';
 import { sceneTransferFields } from '../globals/sceneTransferFields.js';
 import { renderers } from '../weakmaps/renderers.js';
-
-
-
 import * as endZoom from '../animations/endZoom.js';
 import * as onMapChange from './onMapChange.js';
 import * as onPointerLeave from '../picking/onPointerLeave.js';
@@ -31,7 +27,12 @@ import { cancelUpdate } from './cancelUpdate.js';
 import { update } from './scheduleSceneUpdate.js';
 import { releaseSharedScene } from './releaseSharedScene.js';
 
-/** Release source meshes/UI; retain manually added objects and model CPU data. */
+/**
+ * Release source meshes and UI, retaining manually added objects and model CPU data.
+ *
+ * @param {L.Layer} layer 3D layer being removed.
+ * @param {L.Map} map Map containing the layer.
+ */
 export function onRemove3DLayer(layer, map) {
   addedByLayer.set(layer, Promise.withResolvers());
   if (containerByLayer.get(layer)) {

package/src/scene/ready3D.js

@@ -7,15 +7,21 @@ import { raycasterByLayer } from '../weakmaps/raycasterByLayer.js';
 import { rootByLayer } from '../weakmaps/rootByLayer.js';
 import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
 import { urlByLayer } from '../weakmaps/urlByLayer.js';
-
-
-
 import { emptyNode } from './createSceneNode.js';
 import { getHeader } from '../archives/getHeader.js';
 import { attach } from './attachSharedScene.js';
 import { loadModel } from '../models/loadModel.js';
 import { update } from './scheduleSceneUpdate.js';
 
+/**
+ * Initialize a 3D scene root and source, attach if mapped, and emit readiness.
+ *
+ * @param {L.Layer} layer 3D layer to initialize.
+ *
+ * @returns {Promise<L.Layer>} The initialized layer.
+ *
+ * @throws {Error} If initialization fails, after emitting an error event.
+ */
 export async function ready3D(layer) {
   try {
     rootByLayer.set(layer, emptyNode());

package/src/scene/releaseSharedScene.js

@@ -4,13 +4,17 @@ import { sceneFields } from '../weakmaps/sceneFields.js';
 import { zoomTransitionsByLayer } from '../weakmaps/zoomTransitionsByLayer.js';
 import { zoomViewByLayer } from '../weakmaps/zoomViewByLayer.js';
 import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
-
-
 import { renderers } from '../weakmaps/renderers.js';
 import { sceneCleanupFields } from '../globals/sceneCleanupFields.js';
 import { destroyTexture } from '../textures/destroyTexture.js';
 import { releaseRenderer } from '../gpu/releaseRenderer.js';
 
+/**
+ * Release the map's shared renderer, roof texture and scene lifecycle state.
+ *
+ * @param {L.Layer} layer Shared scene owner.
+ * @param {L.Map} map Map owning the scene.
+ */
 export function releaseSharedScene(layer, map) {
   if (roofRasterByLayer.get(layer)) destroyTexture(layer, roofRasterByLayer.get(layer).texture.texture);
   roofRasterByLayer.set(layer, null);

package/src/scene/removeLayerEvents.js

@@ -1,9 +1,7 @@
 import { eventMapByLayer } from '../weakmaps/eventMapByLayer.js';
 import { eventsByLayer } from '../weakmaps/eventsByLayer.js';
 
-
-
-
+/** Remove this layer's registered map event handlers. */
 export function removeLayerEvents() {
 
   eventMapByLayer.get(this).off(eventsByLayer.get(this), this);

package/src/scene/removeSceneLayer.js

@@ -1,16 +1,22 @@
 import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { onRemove3DLayer } from './onRemove3DLayer.js';
+import { onPMTileRemove } from '../raster/onPMTileRemove.js';
+import { onTerrainRemove } from '../terrain/onTerrainRemove.js';
+import { removeTimeLayer } from '../sunlight/removeTimeLayer.js';
 
-
-import { onRemove3DLayer } from './onRemove3DLayer.js';
-import { onPMTileRemove } from '../raster/onPMTileRemove.js';
-import { onTerrainRemove } from '../terrain/onTerrainRemove.js';
-import { removeTimeLayer } from '../sunlight/removeTimeLayer.js';
-
-export function removeSceneLayer(layer, map) {
-  switch (kindByLayer.get(layer)) {
-    case '3d': return onRemove3DLayer(layer, map);
-    case 'raster': return onPMTileRemove(layer, map);
-    case 'terrain': return onTerrainRemove(layer, map);
-    case 'time': return removeTimeLayer.call(layer, map);
-  }
-}
+/**
+ * Dispatch layer removal according to its registered scene kind.
+ *
+ * @param {L.Layer} layer Layer being removed.
+ * @param {L.Map} map Map containing the layer.
+ *
+ * @returns {*} Result of the selected remove handler, if any.
+ */
+export function removeSceneLayer(layer, map) {
+  switch (kindByLayer.get(layer)) {
+    case '3d': return onRemove3DLayer(layer, map);
+    case 'raster': return onPMTileRemove(layer, map);
+    case 'terrain': return onTerrainRemove(layer, map);
+    case 'time': return removeTimeLayer.call(layer, map);
+  }
+}

package/src/scene/renderPendingMapChange.js

@@ -1,14 +1,11 @@
 import { queuedByLayer } from '../weakmaps/queuedByLayer.js';
 import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
 import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
-
 import { pendingMapChanges } from '../globals/pendingMapChanges.js';
-
-
-
 import { update } from './scheduleSceneUpdate.js';
 import { render } from '../rendering/render.js';
 
+/** Render the next queued map change, or schedule a frame during animated zoom. */
 export function renderPendingMapChange() {
   const layer = pendingMapChanges.shift();
   queuedByLayer.set(layer, false);

package/src/scene/renderPendingUpdates.js

@@ -1,13 +1,14 @@
 import { frameByLayer } from '../weakmaps/frameByLayer.js';
 import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
 import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
-
 import { pendingUpdates } from '../globals/pendingUpdates.js';
-
-
-
 import { render } from '../rendering/render.js';
 
+/**
+ * Render queued shared scenes, continuing through failures before propagating the first.
+ *
+ * @throws {Error} The first rendering failure, if any.
+ */
 export function renderPendingUpdates() {
   const updates = /* alloc */ [...pendingUpdates];
   pendingUpdates.clear();

package/src/scene/reportLayerError.js

@@ -1,3 +1,9 @@
-export function reportError(source, error) {
-  source.fire('error', /* alloc */ { error });
-}
+/**
+ * Emit an error event on a source layer.
+ *
+ * @param {L.Layer} source Layer receiving the event.
+ * @param {Error} error Error to report.
+ */
+export function reportError(source, error) {
+  source.fire('error', /* alloc */ { error });
+}

package/src/scene/resolveNextInitialization.js

@@ -1,8 +1,11 @@
 import { pendingInitializations } from '../globals/pendingInitializations.js';
-
-
 import { initializerFor } from './initializerFor.js';
 
+/**
+ * Dequeue an initialization and resolve its initializer or record an unknown-type error.
+ *
+ * @returns {Object} Initialization task.
+ */
 export function resolveNextInitialization() {
   const task = pendingInitializations.shift();
   task.initialize = initializerFor(task.type, task.settings);

package/src/scene/restoreObject.js

@@ -1,12 +1,15 @@
 import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
 import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
-
-
-
 import { createProgram } from '../materials/createProgram.js';
 import { restoreGeometry } from '../geometry/restoreGeometry.js';
 import { restoreMaterialTextures } from '../textures/restoreMaterialTextures.js';
 
+/**
+ * Restore a scene object's GPU resources when it moves to a different device.
+ *
+ * @param {Object} object Scene object to restore.
+ * @param {L.Layer} layer Layer containing the object.
+ */
 export function restoreObject(object, layer) {
   const shared = sharedByLayer.get(layer);
   let texture;

package/src/scene/scheduleSceneUpdate.js

@@ -1,15 +1,16 @@
 import { frameByLayer } from '../weakmaps/frameByLayer.js';
 import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
-
 import { pendingUpdates } from '../globals/pendingUpdates.js';
-
-
 import { render } from "../rendering/render.js";
-
 import { renderPendingUpdates } from './renderPendingUpdates.js';
 
-/** Scene graph, shared camera and frame rendering. */
-/** Content changes: render once on the next animation frame. */
+/**
+ * Schedule one shared-scene render on the next animation frame.
+ *
+ * @param {L.Layer} layer Layer whose content changed.
+ *
+ * @returns {L.Layer} The supplied layer.
+ */
 export function update(layer) {
   const shared = sharedByLayer.get(layer);
   if (!shared) return layer;

package/src/scene/setParent.js

@@ -1,5 +1,9 @@
-/** Reparent/detach scene data without drawing or disposing GPU resources. */
-
+/**
+ * Reparent or detach scene data without drawing or disposing GPU resources.
+ *
+ * @param {Object} node Scene node to move.
+ * @param {Object|null} parent New parent, or null to detach.
+ */
 export function setParent(node, parent) {
   if (node.parent) node.parent.children.splice(node.parent.children.indexOf(node), 1);
   node.parent = parent;

package/src/scene/traverse.js

@@ -1,5 +1,10 @@
-/** Depth-first walk; a truthy callback result skips that node's descendants. */
-
+/**
+ * Walk the scene depth-first; a truthy callback result skips that node's descendants.
+ *
+ * @param {Object} node Root node to visit.
+ * @param {Function} callback Called with each node and the supplied context.
+ * @param {*} context Context passed to the callback.
+ */
 export function traverse(node, callback, context) {
   if (callback(node, context)) return;
   let child;

package/src/shaders/README.md

@@ -0,0 +1,29 @@
+# Shaders
+
+[Source guide](../README.md) | [Project README](../../README.md)
+
+Generates WGSL shader code for materials, native strokes and roof projection.
+Material program setup and GPU resource binding live outside this folder.
+
+## Generated variants
+
+```mermaid
+flowchart LR
+  Material["Material flags"] --> Generate["materialShaders"]
+  Generate --> Vertex["Vertex WGSL"]
+  Generate --> Surface["Fragment WGSL"]
+  Generate --> Bindings["Texture bindings + feature flags"]
+  Vertex --> Program["GPU program"]
+  Surface --> Program
+  Bindings --> Program
+```
+
+Generation does not require a GPU. Binding order, material layout, uniform
+writes and vertex attributes must agree; compilation diagnostics come from
+[gpu](../gpu/README.md).
+
+- [materialShaders.js](./materialShaders.js): assemble material shader variants.
+- [materialVertexShader.js](./materialVertexShader.js): generate vertex shader code.
+- [materialBaseShader.js](./materialBaseShader.js): generate material fragment logic.
+
+Related: [materials](../materials/README.md), [textures](../textures/README.md), [rendering](../rendering/README.md).