modern-canvas 0.18.0 → 0.18.2

package/dist/core/renderers/gl/GlStencilSystem.d.ts

@@ -4,8 +4,6 @@ import type { WebGLRenderer } from './WebGLRenderer';
 import { StencilMode } from './const';
 import { GlSystem } from './system';
 export interface StencilState {
-    stencilWriteMask?: number;
-    stencilReadMask?: number;
     stencilFront?: {
         compare: 'always' | 'equal' | 'not-equal';
         passOp: 'increment-clamp' | 'decrement-clamp' | 'keep' | 'replace';

package/dist/core/renderers/gl/shader/GlProgram.d.ts

@@ -9,6 +9,8 @@ export interface GlUniform {
     size: number;
     isArray: boolean;
     value: any;
+    /** cached uniform location, looked up lazily on first upload (undefined = not yet resolved) */
+    location?: WebGLUniformLocation | null;
 }
 export interface GlProgramOptions {
     fragment: string;

package/dist/core/renderers/gl/shader/GlProgramData.d.ts

@@ -1,4 +1,10 @@
 export declare class GlProgramData {
     native: WebGLProgram;
+    /**
+     * Per uniform-group last-synced `_dirtyId`, keyed by the group's uid.
+     * If a group's current `_dirtyId` differs from the value stored here, the
+     * group's data is (re)uploaded to this program.
+     */
+    uniformDirtyGroups: Record<number, number>;
     constructor(native: WebGLProgram);
 }

package/dist/core/renderers/gl/shader/GlShaderSystem.d.ts

@@ -1,22 +1,42 @@
 import type { ShaderLike } from '../../shared';
 import type { WebGLRenderer } from '../WebGLRenderer';
 import type { GlProgram } from './GlProgram';
+import { UniformGroup } from '../../shared/shader';
 import { GlSystem } from '../system';
 import { GlProgramData } from './GlProgramData';
 export declare class GlShaderSystem extends GlSystem {
     install(renderer: WebGLRenderer): void;
     readonly glProgramDatas: Map<number, GlProgramData>;
     currentProgram: GlProgram | null;
-    uniforms: {
+    /**
+     * Global uniforms (projection/view) shared by every shader. Held as a
+     * UniformGroup so each program only re-uploads them when they actually change
+     * (tracked via the group's `_dirtyId`). Call {@link markGlobalUniformsDirty}
+     * after mutating `uniforms.projectionMatrix` / `uniforms.viewMatrix`.
+     */
+    readonly globalUniforms: UniformGroup<{
         projectionMatrix: Float32Array<ArrayBuffer>;
         viewMatrix: Float32Array<ArrayBuffer>;
+    }>;
+    /** Backwards-compatible accessor for the global uniform values. */
+    get uniforms(): {
+        projectionMatrix: Float32Array;
+        viewMatrix: Float32Array;
     };
+    /** Flag the global uniforms as changed so they are re-uploaded on next use. */
+    markGlobalUniformsDirty(): void;
     bind(source: ShaderLike | null): void;
     useProgram(glProgram: GlProgram | null): void;
     getGlProgramData(source: GlProgram): GlProgramData;
     protected _createGlProgramData(glProgram: GlProgram): GlProgramData;
     protected _createGlShader(source: string, target: number): WebGLShader;
     updateUniforms(source: ShaderLike): void;
+    /**
+     * Upload a shared uniform group to a program, skipping the work entirely when
+     * the group has not changed since it was last synced to this program.
+     */
+    updateUniformGroup(group: UniformGroup, glProgram: GlProgram): void;
+    protected _uploadUniforms(glProgram: GlProgram, glProgramData: GlProgramData, uniforms: Record<string, any>): void;
     reset(): void;
     destroy(): void;
 }

package/dist/core/renderers/shared/shader/UniformGroup.d.ts

@@ -0,0 +1,34 @@
+export interface UniformGroupOptions {
+    /**
+     * If true the group is treated as a Uniform Buffer Object (WebGL2 only). The
+     * whole group is uploaded as a single buffer instead of per-uniform calls.
+     */
+    ubo?: boolean;
+    /**
+     * If true the group is only re-uploaded to a program when its `_dirtyId`
+     * changes (you are responsible for calling `update()`); otherwise it is
+     * re-uploaded every time it is used.
+     */
+    isStatic?: boolean;
+}
+/**
+ * A named bag of uniform values shared across shaders, with a version counter
+ * (`_dirtyId`) so the renderer can skip re-uploading it when nothing changed.
+ *
+ * This is the unit the renderer tracks per program (see
+ * `GlShaderSystem.updateUniformGroup`): each program records the last `_dirtyId`
+ * it synced, and re-uploads only when the group's id moved on.
+ */
+export declare class UniformGroup<T extends Record<string, any> = Record<string, any>> {
+    readonly isUniformGroup = true;
+    /** unique id used as the key for per-program dirty tracking */
+    readonly uid: number;
+    uniforms: T;
+    ubo: boolean;
+    isStatic: boolean;
+    /** bumped whenever the group's data changes; compared against per-program last-synced id */
+    _dirtyId: number;
+    constructor(uniforms: T, options?: UniformGroupOptions);
+    /** Flag the group's data as changed so it is re-uploaded on next use. */
+    update(): void;
+}

package/dist/core/renderers/shared/shader/index.d.ts

@@ -1 +1,2 @@
 export * from './ShaderLike';
+export * from './UniformGroup';