modern-canvas 0.26.2 → 0.27.0

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

@@ -0,0 +1,49 @@
+/**
+ * 合批 shader 的效果插槽：每个效果是一个独立模块，声明自己的 GLSL 片段与
+ * uniform，编译时组装进共享 uber-shader —— 特性代码不再散落在核心模板里，
+ * 新增同类效果（虚线 / 渐变描边 / 选中脉冲…）只需注册一个新效果对象。
+ *
+ * 核心向片段提供的通用通道：
+ * - `vec4 color`（可读写，预乘 alpha）
+ * - `vec2 vUv`（纯色描边下 u = 路径像素弧长、v = 横向 0..1，见 CanvasContext）
+ * - `float vFlags`（aTextureParams.y 字节：bit0 = clipOutsideUv 为核心保留，
+ *   bit1+ 归效果使用，由 {@link Batchable2D.effectFlags} 写入）
+ * - `float vParam`（aTextureParams.w 字节：效果自定义标量，
+ *   由 {@link Batchable2D.effectParam} 写入，0 = 关闭）
+ * - `float uTime`（秒，核心时钟）+ 效果自声明的 uniform
+ *   （宿主经 `batch2D.effectUniforms` 覆盖默认值）
+ *
+ * 运行成本：标志/参数是 per-primitive 常量，warp 内分支不发散，未启用的
+ * 元素只付几条标量比较。
+ */
+export interface Batch2DEffect {
+    /** 唯一名；重复注册按名替换。 */
+    name: string;
+    /** ES300 片段，注入 main() 内（clip 之后、输出之前）。 */
+    fragment?: string;
+    /** ES100（WebGL1，无导数函数）降级片段；缺省则该效果在 GL1 下关闭。 */
+    fragmentGl1?: string;
+    /** 片段所需的 uniform 声明，如 `uniform vec3 uFlowColor;`。 */
+    uniformDecls?: string;
+    /** uniform 默认值；宿主可经 `batch2D.effectUniforms` 逐帧覆盖。 */
+    uniformDefaults?: Record<string, any>;
+}
+/** aTextureParams.y bit0：UV 越界裁剪（核心语义，效果位从 bit1 起）。 */
+export declare const FLAG_CLIP_OUTSIDE_UV = 1;
+/** aTextureParams.y bit1：描边羽化 + hairline（需要横向 v UV）。 */
+export declare const FLAG_STROKE_AA = 2;
+/** 流动速度（周期/秒，符号=方向）→ 参数字节：128=0 速，1 单位=1/32 周期/s，0=关。 */
+export declare function encodeFlowSpeed(speed: number): number;
+/**
+ * 描边羽化 + 亚像素 hairline 补偿。1/fwidth(v) 即描边屏幕像素宽度：边缘做
+ * ~1px alpha 渐变；宽度不足 1px 时按覆盖率降 alpha（能量守恒），细线不再
+ * 碎成点刻。流动描边自带 core AA，编码侧不会同时置此位。
+ */
+export declare const strokeFeatherEffect: Batch2DEffect;
+/**
+ * 描边流动亮段（vParam = encodeFlowSpeed 编码的速度）：u 为路径像素弧长，
+ * 亮段间距 uFlowPeriod 路径像素（固定物理长度，长短线亮段一致），每段
+ * 前缘快收 + 短拖尾（~22% 周期）。宿主把几何加宽（widthBoost）后，可见
+ * 线体只画在中间 50%，外圈是亮段经过时点亮的辉光带——零额外 pass 的 bloom。
+ */
+export declare const flowStreakEffect: Batch2DEffect;

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

@@ -1,4 +1,5 @@
-import type { BufferLike, GeometryAttributeLike, TextureLike } from '../shared';
+import type { BufferLikeObject, GeometryAttributeLike, GeometryLikeObject, ShaderLikeObject, TextureLike } from '../shared';
+import type { Batch2DEffect } from './Batch2DEffect';
 import type { GlDrawOptions } from './geometry';
 import type { WebGLRenderer } from './WebGLRenderer';
 import { GlBlendMode, GlState } from './state';
@@ -16,10 +17,48 @@ export interface Batchable2D {
     blendMode?: GlBlendMode;
     roundPixels?: boolean;
     clipOutsideUv?: boolean;
+    /**
+     * Effect flag bits (bit 1+ of the aTextureParams.y byte; bit 0 is reserved
+     * for clipOutsideUv). Semantics are defined by the registered
+     * {@link Batch2DEffect}s — e.g. {@link FLAG_STROKE_AA}. 0/undefined = none.
+     */
+    effectFlags?: number;
+    /**
+     * Effect scalar parameter (the spare aTextureParams.w byte, 0-255; 0 = off).
+     * Encoding is defined by the effect that consumes it — e.g. the flow streak
+     * effect's {@link encodeFlowSpeed}. Costs no extra vertex attribute.
+     */
+    effectParam?: number;
 }
-interface Shader {
-    update: (bufferData: BufferLike['data'], indexBufferData: BufferLike['data']) => void;
-    draw: (options?: GlDrawOptions) => void;
+type DrawCall = Required<GlDrawOptions> & {
+    id: number;
+    textures: TextureLike[];
+    textureLocationMap: Map<TextureLike, number>;
+    blendMode: GlBlendMode;
+};
+interface BatchProgram {
+    shader: ShaderLikeObject;
+    samplers: Int32Array;
+    /** merged `uniformDefaults` of the effects compiled into this program */
+    uniformDefaults: Record<string, any>;
+}
+/**
+ * Per-flush GPU + staging resources, addressed by flush ordinal within a frame.
+ * Dedicated (not pooled/shared) so an unchanged flush can skip both the CPU
+ * vertex rewrite and the GPU upload and just re-issue its draw calls — the GL
+ * buffers still hold exactly this flush's data. `refs` snapshots what the
+ * buffer content was built from (see {@link GlBatch2DSystem.flush}).
+ */
+interface BatchSlot {
+    buffer: BufferLikeObject;
+    indexBuffer: BufferLikeObject;
+    geometry: GeometryLikeObject;
+    attrData?: ArrayBuffer;
+    f32?: Float32Array;
+    u8?: Uint8Array;
+    indexData?: Uint32Array<ArrayBuffer>;
+    refs: any[];
+    drawCalls: DrawCall[];
 }
 export declare class GlBatch2DSystem extends GlSystem {
     install(renderer: WebGLRenderer): void;
@@ -28,17 +67,38 @@ export declare class GlBatch2DSystem extends GlSystem {
     protected _batchables: Batchable2D[];
     protected _vertexCount: number;
     protected _indexCount: number;
-    protected _attributeBuffer: ArrayBuffer[];
-    protected _indexBuffers: Uint32Array<ArrayBuffer>[];
-    protected _shaders: Map<number, Shader>;
+    protected _programs: Map<string, BatchProgram>;
+    /**
+     * Registered shader effects, composed into the batch program at compile time
+     * (see {@link Batch2DEffect}). Re-registering by name replaces and triggers a
+     * program rebuild on the next flush.
+     */
+    protected _effects: Batch2DEffect[];
+    protected _effectsRevision: number;
+    /**
+     * Host-written uniform values for effect snippets (e.g. `uFlowColor`).
+     * Merged over each effect's `uniformDefaults` on every draw.
+     */
+    effectUniforms: Record<string, any>;
+    registerEffect(effect: Batch2DEffect): void;
+    protected _slots: BatchSlot[];
+    protected _slotIndex: number;
+    /**
+     * Marks the start of a frame: flush ordinals restart so each flush lines up
+     * with the slot holding its previous content. Without this call slots keep
+     * advancing and simply never reuse (capped at {@link MAX_SLOTS}).
+     */
+    beginFrame(): void;
     protected _attributes: Record<string, Partial<GeometryAttributeLike>>;
     protected _vertexSize: number;
-    protected _getShader(maxTextureUnits: number): Shader;
-    protected _createShader(maxTextureUnits: number): Shader;
+    protected _getProgram(maxTextureUnits: number): BatchProgram;
+    protected _createProgram(maxTextureUnits: number): BatchProgram;
+    protected _getSlot(): BatchSlot;
+    protected _drawSlot(program: BatchProgram, slot: BatchSlot, options: GlDrawOptions): void;
+    protected _issueDrawCalls(program: BatchProgram, slot: BatchSlot): void;
     render(batchable: Batchable2D): void;
     flush(): void;
-    protected _getBufferData(size: number): ArrayBuffer;
-    protected _getIndexBufferData(size: number): Uint32Array<ArrayBuffer>;
+    reset(): void;
 }
 export declare function nextPow2(v: number): number;
 export declare function log2(v: number): number;

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

@@ -1,3 +1,4 @@
+export * from './Batch2DEffect';
 export * from './buffer';
 export * from './GlBatch2DSystem';
 export * from './GlMaskSystem';

package/dist/core/renderers/gl/renderTarget/GlRenderTargetSystem.d.ts

@@ -24,6 +24,8 @@ export declare class GlRenderTargetSystem extends GlSystem {
     protected _hasMRT: boolean;
     protected _writeDepthTexture: boolean;
     projection: Projection2D;
+    /** 4x MSAA, clamped to what the device actually supports (some GPUs cap at 2). */
+    protected get _sampleCount(): number;
     protected _updateContext(gl: GlRenderingContext): void;
     bind(renderTarget: RenderTargetLike | null, frame?: RectangleLike): void;
     unbind(): void;

package/dist/core/shared/geometryRevision.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Revision of everything a connection's endpoints can be derived from. Bumped when:
+ *
+ * - any Element2D's world geometry is recomputed (globalTransform / globalAabb / size)
+ * - a shape's `connectionPoints` are replaced
+ * - a node enters or leaves the tree (changes what an id resolves to)
+ *
+ * Deliberately global rather than per-element: a connection would otherwise have to
+ * read its two targets to notice a change, and reading is exactly what we're avoiding.
+ * `route()` runs every frame for every connection (Element2D._process), and in a host
+ * that wraps elements in a reactive proxy — mce puts them behind Vue's `reactive()` —
+ * even reading a handful of properties per connection per frame adds up, while writing
+ * a cache field back triggers the proxy's dependency machinery. One integer compare
+ * costs nothing.
+ *
+ * Being global only ever costs extra work, never correctness: an unrelated element
+ * moving makes every connection fall through to comparing its own endpoints, which is
+ * still far cheaper than re-resolving them.
+ *
+ * The camera is a plain Node2D whose transform touches no Element2D aabb, so panning /
+ * zooming the viewport does NOT bump this — connections stay fully cached while the
+ * user navigates.
+ */
+export declare function geometryRevision(): number;
+export declare function bumpGeometryRevision(): void;

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

@@ -1,4 +1,5 @@
 export * from './css';
 export * from './dom';
+export * from './geometryRevision';
 export * from './id';
 export * from './utils';