@aethervtt/shard-render 0.0.1 → 0.1.0

package/dist/graph.js

@@ -1,4 +1,6 @@
 import { ShardError } from "@aethervtt/shard-core";
+import { flushDataStores } from "./data-store.js";
+import { unsupportedNodes } from "./features.js";
 import { TexturePool } from "./pool.js";
 import { BYTES_PER_TEXEL, toFloats } from "./readback.js";
 import { GpuTimer } from "./timer.js";
@@ -10,8 +12,14 @@ const RenderPhase = {
   Opaque: 300,
   Lighting: 350,
   Sky: 400,
+  /** Coplanar ground bands (0057): after the sky, which draws where no depth was written. */
+  Ground: 420,
   Sprites: 450,
   Transparent: 500,
+  /** Projected fog's composite (0058): after transparent objects, before the overlay band. */
+  Fog: 520,
+  /** Ground bands from the overlay band up, over fog (0058). */
+  Overlay3d: 530,
   Effects3d: 550,
   Resolve: 600,
   Post: 700,
@@ -127,6 +135,12 @@ class RenderGraph {
     this.pool = new TexturePool(gpu);
     this.timer = new GpuTimer(gpu);
   }
+  /** Rejects pending captures and destroys the timer's query set (the app is being disposed). */
+  dispose() {
+    const error = new ShardError("render/disposed", "The app was disposed before the capture ran");
+    for (const capture of this.captures.splice(0)) capture.reject(error);
+    this.timer.destroy();
+  }
   addNode(name, node) {
     if (this.nodes.has(name)) {
       throw new ShardError("render/duplicate-node", `Render graph node "${name}" already exists`);
@@ -141,6 +155,10 @@ class RenderGraph {
   hasNode(name) {
     return this.nodes.has(name);
   }
+  /** Every node's name, in the order they were added. */
+  nodeNames() {
+    return [...this.nodes.keys()];
+  }
   /** The data of a view rendered in the last frame. */
   lastViewData(view) {
     return this.viewData.get(view);
@@ -153,11 +171,12 @@ class RenderGraph {
   resolve() {
     return this.resolveFor(void 0);
   }
-  resolveFor(view) {
+  /** `off`: nodes that don't run on this device (features the baseline tier doesn't support). */
+  resolveFor(view, off) {
     let key = "";
     const enabled = /* @__PURE__ */ new Map();
     for (const [name, node] of this.nodes) {
-      const on = !view || !node.enabled || node.enabled(view);
+      const on = (!view || !node.enabled || node.enabled(view)) && !off?.has(name);
       key += on ? "1" : "0";
       if (on) enabled.set(name, node);
     }
@@ -233,8 +252,9 @@ class RenderGraph {
     this.lastViews = sorted.map((v) => v.name);
     this.viewData.clear();
     for (const v of sorted) this.viewData.set(v.name, v.data);
+    const off = this.gpu.tier === "baseline" ? unsupportedNodes(world) : void 0;
     for (const view of sorted) {
-      const resolved = this.resolveFor(view);
+      const resolved = this.resolveFor(view, off);
       const order = resolved.order;
       this.lastByView.set(view.name, resolved);
       const textures = /* @__PURE__ */ new Map();
@@ -264,13 +284,17 @@ class RenderGraph {
         const vh = view.height ?? view.target.height;
         const px = size === "view" ? [vw, vh] : Array.isArray(size) ? size : [Math.max(1, Math.ceil(vw / size.divide)), Math.max(1, Math.ceil(vh / size.divide))];
         const format = perView(desc.format, view);
+        const sampleCount = perView(desc.sampleCount ?? 1, view);
+        let usage = (desc.usage ?? GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING) | GPUTextureUsage.COPY_SRC;
+        if (sampleCount > 1 && this.gpu.tier === "baseline")
+          usage &= ~GPUTextureUsage.TEXTURE_BINDING;
         t = this.pool.acquire({
           label: `${view.name}/${canonical}`,
           format: format === "view" ? view.target.format : format,
           size: px,
-          sampleCount: perView(desc.sampleCount ?? 1, view),
+          sampleCount,
           mipLevelCount: perView(desc.mipLevelCount ?? 1, view),
-          usage: (desc.usage ?? GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING) | GPUTextureUsage.COPY_SRC
+          usage
         });
         textures.set(canonical, t);
         return t;
@@ -358,6 +382,7 @@ class RenderGraph {
     }
     this.captures = this.captures.filter((c) => !readbacks.some((r) => r.capture === c));
     this.timer.resolve(encoder);
+    flushDataStores(this.gpu);
     device.queue.submit([encoder.finish()]);
     this.timer.readback(world);
     for (const fn of submitted) fn();

package/dist/health.d.ts

@@ -0,0 +1,58 @@
+import { type World } from '@aethervtt/shard-core';
+import type { GpuStatus } from '@aethervtt/shard-gpu';
+export type RenderHealthState = 'ok' | 'degraded' | 'lost' | 'failed';
+export interface RenderHealthIssue {
+    /** `package/what-happened`, e.g. `assets/load-failed`, `render/material-fallback`. */
+    code: string;
+    message: string;
+    /** What it's about: an asset path, a material type, a feature. */
+    ref?: string;
+    /** When it was first seen, in ms since the epoch. */
+    since: number;
+    /**
+     * `degraded` issues make the state `degraded` (something draws a fallback or not at all); `info`
+     * ones are reported without changing it (a shader cache miss in a dev build).
+     */
+    severity: 'degraded' | 'info';
+}
+export interface RenderHealthValue {
+    /**
+     * `ok`; `degraded` while any fallback, failed pipeline or unsupported feature is in use; `lost`
+     * between a device loss and its recovery; `failed` when recovery gave up.
+     */
+    state: RenderHealthState;
+    issues: RenderHealthIssue[];
+}
+export declare const RenderHealth: import("@aethervtt/shard-core").ResourceDef<RenderHealthValue>;
+export declare const RenderHealthChanged: import("@aethervtt/shard-core").EventDef<{
+    from: RenderHealthState;
+    to: RenderHealthState;
+    issues: RenderHealthIssue[];
+}>;
+type Raised = Omit<RenderHealthIssue, 'since'>;
+/** Issues raised by code other than the renderer's own checks (unsupported features, 0064). */
+export declare const RenderHealthReports: import("@aethervtt/shard-core").ResourceDef<{
+    issues: Map<string, Raised>;
+    version: number;
+}>;
+/** Raises an issue until `clearHealthIssue` (same code and ref). Raising it again does nothing. */
+export declare function raiseHealthIssue(world: World, issue: Raised): void;
+export declare function clearHealthIssue(world: World, code: string, ref?: string): void;
+/** Material types drawing through the standard fallback (filled by the forward plugin). */
+export declare const MaterialFallbacks: import("@aethervtt/shard-core").ResourceDef<{
+    count(): number;
+    list(): readonly {
+        type: string;
+        error: {
+            code: string;
+            message: string;
+        };
+    }[];
+}>;
+/** Where the device status comes from (the render plugin's GPU context). */
+export interface HealthSources {
+    status(): GpuStatus;
+}
+/** Rebuilds RenderHealth when its inputs change, and sends RenderHealthChanged on transitions. */
+export declare function healthSystem(sources: HealthSources): import("@aethervtt/shard-core").SystemDef<undefined>;
+export {};

package/dist/health.js

@@ -0,0 +1,112 @@
+import { AssetServerResource } from "@aethervtt/shard-assets";
+import { defineEvent, defineResource, defineSystem } from "@aethervtt/shard-core";
+const RenderHealth = defineResource("render/Health", {
+  description: "The renderer's health: ok, degraded (fallbacks in use), lost (device reset in progress) or failed, with the issues behind it.",
+  init: () => ({ state: "ok", issues: [] })
+});
+const RenderHealthChanged = defineEvent("render/HealthChanged", {
+  description: "RenderHealth moved to another state (ok, degraded, lost, failed)."
+});
+const RenderHealthReports = defineResource(
+  "render/HealthReports",
+  {
+    description: "Health issues raised by features and backends, by code and ref.",
+    init: () => ({ issues: /* @__PURE__ */ new Map(), version: 0 })
+  }
+);
+function raiseHealthIssue(world, issue) {
+  const reports = world.initResource(RenderHealthReports);
+  const key = `${issue.code}|${issue.ref ?? ""}`;
+  const had = reports.issues.get(key);
+  if (had && had.message === issue.message && had.severity === issue.severity) return;
+  reports.issues.set(key, issue);
+  reports.version++;
+}
+function clearHealthIssue(world, code, ref) {
+  const reports = world.tryResource(RenderHealthReports);
+  if (reports?.issues.delete(`${code}|${ref ?? ""}`)) reports.version++;
+}
+const MaterialFallbacks = defineResource("render/MaterialFallbacks", {
+  description: "Material types whose shader or pipeline failed, drawn with the standard one."
+});
+function healthSystem(sources) {
+  const seen = { status: "", fallbacks: -1, materials: -1, reports: -1 };
+  const since = /* @__PURE__ */ new Map();
+  return defineSystem({
+    name: "render/health",
+    description: "Keeps RenderHealth current: device status, fallbacks in use, raised issues.",
+    run: (_, world) => {
+      const status = sources.status();
+      const server = world.tryResource(AssetServerResource);
+      const fallbacks = server?.fallbackCount ?? 0;
+      const fallbackMaterials = world.tryResource(MaterialFallbacks);
+      const materials = fallbackMaterials?.count() ?? 0;
+      const reports = world.tryResource(RenderHealthReports)?.version ?? 0;
+      if (status === seen.status && fallbacks === seen.fallbacks && materials === seen.materials && reports === seen.reports)
+        return;
+      seen.status = status;
+      seen.fallbacks = fallbacks;
+      seen.materials = materials;
+      seen.reports = reports;
+      const now = Date.now();
+      const issues = [];
+      const add = (issue) => {
+        const key = `${issue.code}|${issue.ref ?? ""}`;
+        let at = since.get(key);
+        if (at === void 0) {
+          at = now;
+          since.set(key, at);
+        }
+        issues.push({ ...issue, since: at });
+      };
+      if (status === "lost") {
+        add({
+          code: "gpu/device-lost",
+          message: "The GPU device was lost; recovering",
+          severity: "degraded"
+        });
+      } else if (status === "failed") {
+        add({
+          code: "gpu/recovery-failed",
+          message: "The GPU device couldn't be replaced",
+          severity: "degraded"
+        });
+      }
+      for (const f of server?.failed() ?? []) {
+        add({ code: f.code, message: f.message, ref: f.path, severity: "degraded" });
+      }
+      for (const f of fallbackMaterials?.list() ?? []) {
+        add({
+          code: "render/material-fallback",
+          message: `Drawn with the standard material: ${f.error.message}`,
+          ref: f.type,
+          severity: "degraded"
+        });
+      }
+      for (const issue of world.tryResource(RenderHealthReports)?.issues.values() ?? []) add(issue);
+      for (const key of since.keys()) {
+        if (!issues.some((i) => `${i.code}|${i.ref ?? ""}` === key)) since.delete(key);
+      }
+      const state = status === "failed" ? "failed" : status === "lost" ? "lost" : issues.some((i) => i.severity === "degraded") ? "degraded" : "ok";
+      const health = world.initResource(RenderHealth);
+      const from = health.state;
+      health.state = state;
+      health.issues = issues;
+      world.touchResource(RenderHealth);
+      if (from !== state) {
+        const change = { from, to: state, issues };
+        world.send(RenderHealthChanged, change);
+        world.trigger(RenderHealthChanged, change);
+      }
+    }
+  });
+}
+export {
+  MaterialFallbacks,
+  RenderHealth,
+  RenderHealthChanged,
+  RenderHealthReports,
+  clearHealthIssue,
+  healthSystem,
+  raiseHealthIssue
+};

package/dist/index.d.ts

@@ -1,11 +1,14 @@
-export { AssetStore, MaterialAsset, MaterialAssetType, MaterialImporter, Materials, type MaterialValue, MeshAsset, Meshes, materialFields, materialFromJson, materialTypeOf, RenderTargets, STANDARD_TYPE, StandardMaterial, type StandardMaterialValue, validateMaterial, } from './assets.js';
+export { AssetStore, MaterialAsset, MaterialAssetType, MaterialImporter, Materials, type MaterialValue, MeshAsset, Meshes, materialFields, materialFromJson, materialTypeOf, missingMesh, RenderTargets, STANDARD_TYPE, StandardMaterial, type StandardMaterialValue, validateMaterial, } from './assets.js';
 export { Atmosphere, type AtmospherePreset, AtmospherePresets, type AtmosphereRecord, type AtmosphereSampleResult, AtmosphereSettings, AtmosphereStore, Atmospheres, type AtmosphereValue, atmosphereMethods, atmosphereModel, type CameraAtmosphere, describeAtmospheres, sampleAtmosphere, selectAtmospheres, sunTransmittanceAt, } from './atmosphere.js';
 export { type AtmosphereModel, createSkySample, integrateSky, multiscatterLut, transmittanceLut, transmittanceToTop, } from './atmosphere-model.js';
 export { AtmosphereGpu, AtmosphereGpuResource, LUT_LAYERS } from './atmosphere-nodes.js';
 export { atmospherePlugin } from './atmosphere-plugin.js';
 export { applyPhysicalCameras, Camera3d, type Camera3dValue, camera2d, Exposure, type ExposurePreset, ExposurePresets, ev100, ev100FromCamera, ev100FromIlluminance, exposureScale, type LightPreset, LightPresets, lux, PhysicalCamera, } from './camera.js';
 export { CLUSTER_COUNT, CLUSTER_X, CLUSTER_Y, CLUSTER_Z, ClusterBuffers, type ClusterStats, clusterAabb, clusterAabbs, clusterLightsCpu, clusterRange, MAX_LIGHTS_PER_CLUSTER, ViewLightList, } from './clusters.js';
-export { Culler, GpuCuller, readVisibleSlots, visibleSlots } from './culling.js';
+export { Culler, cullGround, GpuCuller, readVisibleSlots, visibleSlots } from './culling.js';
+export { Cutaway, CutawayPath, type CutawaySupport, CutawayView, MAX_REVEAL_POINTS, } from './cutaway.js';
+export { CUTAWAY_SHADERS, CutawayCameras, type CutawayState, cutawayPlugin, describeCutaways, extractCutaways, } from './cutaway-plugin.js';
+export { DATA_WIDTH, DataStore, type DataStoreOptions, dataEntry, flushDataStores, loadDataTextures, } from './data-store.js';
 export { captureShadowMap, DEBUG_VIEWS, type DebugView, describeCulling, describeLighting, readBuffer, readTextureLayer, setDebugView, } from './debug-views.js';
 export { captureGBuffer, describeDeferred, GBUFFER_CHANNELS, type GBufferChannel, } from './deferred.js';
 export { deferredPlugin } from './deferred-plugin.js';
@@ -15,39 +18,55 @@ export { whiteBalance } from './display-nodes.js';
 export { dynamicResolutionPlugin, type FrameTimings, RenderScaleController, updateRenderScale, } from './dynamic-resolution.js';
 export { type CameraEnvironment, DefaultEnvironment, type DefaultEnvironmentValue, describeEnvironment, Environment, type EnvironmentBaker, EnvironmentMap, type EnvironmentMapValue, EnvironmentPresets, EnvironmentStore, Environments, environmentBakers, ProceduralSky, type ProceduralSkyValue, Skybox, } from './environment.js';
 export { environmentPlugin } from './environment-plugin.js';
-export { type ForwardPluginOptions, type ForwardState, ForwardStateResource, forwardCorePlugin, PICK_TARGETS, sceneColor, type ViewGpu, viewBindGroup, } from './forward.js';
+export { addRenderFeatures, type BaselineStrategy, clearUnsupported, describeFeatures, featureOfNode, type RenderFeature, RenderFeatures, reportUnsupported, unsupportedNodes, } from './features.js';
+export { type ForwardPluginOptions, type ForwardState, ForwardStateResource, forwardCorePlugin, forwardQueue, PASS_GROUND, PICK_TARGETS, sceneColor, VERTEX_BUFFERS, type ViewGpu, viewBindGroup, viewPixelScale, } from './forward.js';
 export { fxaaPlugin } from './fxaa.js';
-export { LABEL_FONT, labelWidth } from './gizmo-font.js';
+export { LABEL_FONT, labelAtlas, labelWidth } from './gizmo-font.js';
 export { GIZMO_LINE_FLOATS, type GizmoOptions, GizmoStore, Gizmos, packGizmoColor, } from './gizmos.js';
 export { gizmosPlugin } from './gizmos-plugin.js';
 export { GpuAssets, GpuAssetsResource, type GpuMaterial, type GpuMesh, type GpuTexture, } from './gpu-assets.js';
 export { type CapturedBuffer, type CapturedImage, type ColorAttachment, type DepthAttachment, type NodeContext, type NodeDescriptor, RenderGraph, RenderPhase, type RenderView, type ResolvedGraph, type ResourceRef, resolveGraph, type TransientTexture, VIEW_TARGET, } from './graph.js';
-export { type Batch, createDrawList, DeformPath, type DrawItem, type DrawList, INSTANCE_BYTES, INSTANCE_FLOATS, InstanceData, InstanceFlags, InstanceSlot, InstanceStore, Instances, LOD_BIT, Lod, lodSize, Mesh3d, MeshMaterial, MorphWeights, NotShadowCaster, NotShadowReceiver, SkinnedMesh, selectLod, VisibilityRange, } from './instances.js';
+export { clearHealthIssue, MaterialFallbacks, RenderHealth, RenderHealthChanged, type RenderHealthIssue, RenderHealthReports, type RenderHealthState, type RenderHealthValue, raiseHealthIssue, } from './health.js';
+export { type Batch, CUTAWAY_BIT, createDrawList, DeformPath, type DrawItem, type DrawList, groundKey, INSTANCE_BYTES, INSTANCE_FLOATS, InstanceData, InstanceFlags, InstanceSlot, InstanceStore, Instances, LOD_BIT, Lod, lodSize, Mesh3d, MeshMaterial, MorphWeights, NotShadowCaster, NotShadowReceiver, recordFlags, ShadowWhenHidden, SkinnedMesh, selectLod, VisibilityRange, } from './instances.js';
+export { INTERIOR_BINDINGS, INTERIOR_BLOCKED, INTERIOR_SKY, InteriorPath, type InteriorSupport, } from './interior.js';
+export { COVER_SCALE, COVER_ZERO, describeInterior, INTERIOR_GROUND, INTERIOR_LEVELS, INTERIOR_SHADERS, InteriorLighting, InteriorLightingResource, interiorPlugin, LINK_X, LINK_Z, ROW_CLEAR, ROW_SCALE, ROW_ZERO, VISIBILITY_MAX, } from './interior-plugin.js';
 export { observeOriginShifts, shiftRenderHistory } from './large-world.js';
-export { AmbientLight, type AmbientLightValue, CascadeSettings, DirectionalLight, LIGHT_FLOATS, LightingSettings, type LightingSettingsValue, type LightRecord, LightStore, Lights, type LuminousPowerPreset, LuminousPowerPresets, lumens, PointLight, SpotLight, } from './lights.js';
+export { GROUND_BANDS, type GroundBand, GroundLayer, RenderLayers } from './layers.js';
+export { clearLensFields, expireLensFields, forwardLensFields, LENS_DEMAND, Lens, type LensField, LensFields, LensPath, MAX_LENS_FIELDS, publishLensField, } from './lens.js';
+export { describeLens, extractLens, LENS_SHADERS, type LensView, LensViews, lensPlugin, MAX_LENS_PIXELS, } from './lens-plugin.js';
+export { AmbientLight, type AmbientLightValue, CascadeSettings, DirectionalLight, extractLights, FALLOFFS, LIGHT_FLOATS, LIGHT_ROW_WORD, LightingSettings, type LightingSettingsValue, type LightRecord, LightStore, Lights, type LuminousPowerPreset, LuminousPowerPresets, lumens, PointLight, SHADOW_UPDATES, SpotLight, setLightRow, tabletopFalloff, } from './lights.js';
 export { MaterialNoise, type MaterialNoiseSupport } from './material-noise.js';
 export { registerMaterialModule, typeOrdinal } from './material-pipelines.js';
 export { allMaterialTypes, BLEND_MODES, type BlendMode, defineMaterial, findMaterialType, isTransparent, type MaterialNoiseSlot, MaterialType, type MaterialTypeOptions, materialModulePath, onMaterialTypeChange, } from './materials.js';
+export { MAX_OUTLINE_STYLES, OUTLINE_OCCLUSION, Outline, OutlinePath, } from './outline.js';
+export { describeOutlines, OUTLINE_SHADERS, type OutlineView, OutlineViews, outlinePlugin, queueOutlines, } from './outline-plugin.js';
 export { allOverlays, DebugOverlays, type DebugOverlaysValue, defineOverlay, gridsOverlay, isOverlayOn, OVERLAYS, type Overlay, type OverlayDef, type OverlayFilter, overlayNames, setOverlays, } from './overlays.js';
 export { descendantPaths, entityName, findModelRoot } from './paths.js';
-export { type PickBlocker, type PickDrawer, type PickHit, Picking, pick, primaryView, type RaycastOptions, raycast, } from './picking.js';
+export { type PickBlocker, type PickDetail, type PickDetailer, type PickDrawer, type PickHit, Picking, pick, primaryView, type RaycastOptions, raycast, } from './picking.js';
 export { pickingPlugin } from './picking-plugin.js';
 export { PixelPerfect, type PixelPerfectLayout, PixelPerfectPath, PixelTargets, pixelPerfectLayout, } from './pixel-perfect.js';
 export { pixelPerfectPlugin } from './pixel-perfect-plugin.js';
-export { captureBuffer, captureView, describeRender, Gpu, GpuDeviceLost, Graph, RenderDescribers, type RenderPluginOptions, RenderSet, renderPlugin, Shaders, Views, Window, } from './plugin.js';
+export { captureBuffer, captureView, describeRender, Gpu, GpuDeviceLost, Graph, RenderDescribers, RenderOptions, type RenderOptionsValue, type RenderPluginOptions, RenderSet, renderOwner, renderPlugin, Shaders, Views, Window, } from './plugin.js';
 export { TexturePool } from './pool.js';
 export { ANTIALIASING_MODES, Antialiasing, AutoExposure, Bloom, ColorGrading, cocRadiusPixels, DepthOfField, Fog, METERING_MODES, MotionBlur, PostEffect, type PostSettings, SSAO_QUALITIES, Ssao, Vignette, } from './post.js';
 export { bloomLevels, describePost, ExposureMeters, type ExposureState, histogramEv, METER_READBACKS, POST_NODES, } from './post-nodes.js';
 export { postPlugin } from './post-plugin.js';
+export { screenToPlane, screenToRay, worldToScreen } from './projection.js';
 export { describeRenderScale, RenderScale, type RenderScaleValue, SCALE_STEP, scaledSize, } from './render-scale.js';
+export { clearScreenEffects, describeScreenEffects, expireScreenEffects, forwardScreenEffects, MAX_SCREEN_EFFECT_PARAMS, MAX_SCREEN_EFFECTS, onScreenEffect, publishScreenEffect, runScreenEffects, SCREEN_EFFECTS_DEMAND, type ScreenEffect, type ScreenEffectHandler, ScreenEffectHandlers, type ScreenEffectParams, ScreenEffects, } from './screen-effects.js';
 export { ENGINE_SHADERS, materialLayout, registerEngineShaders, registerShaders, ViewUniform, viewLayout, } from './shaders.js';
+export { SHADOW_CATCHER_SHADERS, ShadowCatcher, shadowCatcherPlugin } from './shadow-catcher.js';
 export { Cascades, cascadeSplits, LocalShadows, ShadowsResource, sliceSphere, } from './shadows.js';
 export { MAX_JOINTS, type SkinAsset, SkinAssetType, Skins, skinArtifact } from './skin-asset.js';
 export { prepareDeforms } from './skinning.js';
 export { skinningPlugin } from './skinning-plugin.js';
 export { forwardPlugin } from './standard.js';
-export { GpuMemory, type GpuMemoryData, RenderCounters, type RenderCountersData, RenderStats, type ViewStats, } from './stats.js';
-export { OffscreenTarget, type OffscreenTargetOptions, type RenderTarget, WindowTarget, } from './target.js';
+export { type FrameCounts, type FrameRecord, GpuMemory, type GpuMemoryData, RECENT_FRAMES, RenderCounters, type RenderCountersData, RenderStats, RenderStatsMap, type ViewStats, } from './stats.js';
+export { OffscreenTarget, type OffscreenTargetOptions, type RenderTarget, } from './target.js';
+export { bindingDimension, depthReadEntry } from './tier.js';
 export { GpuTimer } from './timer.js';
-export { type CameraData, Cameras, cameraOf, DEFAULT_CURVE, isScaled, RenderPath, shiftCameraHistory, TONEMAP_CURVES, type TonemapCurve, Tonemapping, ViewSettings, type ViewSettingsValue, viewAliases, } from './view.js';
+export { addShaderVariantSource, type MaterialVariantEntry, materialVariants, type ShaderVariantManifest, type ShaderVariantSource, ShaderVariantSources, showToCamera, showVariants, } from './variants.js';
+export { type CameraData, CameraMoved, Cameras, cameraOf, DEFAULT_CURVE, isScaled, RenderPath, shiftCameraHistory, TONEMAP_CURVES, type TonemapCurve, Tonemapping, ViewSettings, type ViewSettingsValue, viewAliases, } from './view.js';
+export { type HiddenSet, HiddenSetsResource, NO_HIDDEN, observeViewVisibilityWithoutPlugin, VIEW_SHADOWS, ViewVisibility, } from './view-visibility.js';
+export { describeViewVisibility, HiddenSets, resolveViewVisibility, viewVisibilityPlugin, } from './view-visibility-plugin.js';
 export { ComputedVisibility, computeVisibility, Visibility } from './visibility.js';