modern-canvas 0.13.6 → 0.14.1

package/dist/scene/effects/OutlineEffect.d.ts

@@ -1,4 +1,4 @@
-import type { ColorValue, WebGLRenderer } from '../../core';
+import type { ColorValue, GlRenderer } from '../../core';
 import type { EffectProperties, Node, Viewport } from '../main';
 import { Color } from '../../core';
 import { Effect } from '../main/Effect';
@@ -24,5 +24,5 @@ export declare class OutlineEffect extends Effect {
     knockout: boolean;
     protected _color: Color;
     constructor(properties?: Partial<OutlineEffectProperties>, children?: Node[]);
-    apply(renderer: WebGLRenderer, source: Viewport): void;
+    apply(renderer: GlRenderer, source: Viewport): void;
 }

package/dist/scene/effects/PixelateEffect.d.ts

@@ -1,4 +1,4 @@
-import type { WebGLRenderer } from '../../core';
+import type { GlRenderer } from '../../core';
 import type { EffectProperties, Node, Viewport } from '../main';
 import { Effect } from '../main/Effect';
 import { Material } from '../resources';
@@ -9,5 +9,5 @@ export declare class PixelateEffect extends Effect {
     static material: Material;
     strength: number;
     constructor(properties?: Partial<PixelateEffectProperties>, children?: Node[]);
-    apply(renderer: WebGLRenderer, source: Viewport): void;
+    apply(renderer: GlRenderer, source: Viewport): void;
 }

package/dist/scene/effects/ZoomBlurEffect.d.ts

@@ -1,5 +1,5 @@
-import type { WebGLRenderer } from '../../core';
-import type { EffectContext, EffectProperties, Node, Viewport } from '../main';
+import type { GlRenderer } from '../../core';
+import type { EffectProperties, Node, Viewport } from '../main';
 import { Effect } from '../main/Effect';
 import { Material } from '../resources';
 export interface ZoomBlurEffectProperties extends EffectProperties {
@@ -15,5 +15,5 @@ export declare class ZoomBlurEffect extends Effect {
     radius: number;
     strength: number;
     constructor(properties?: Partial<ZoomBlurEffectProperties>, children?: Node[]);
-    apply(renderer: WebGLRenderer, source: Viewport, context: EffectContext): void;
+    apply(renderer: GlRenderer, source: Viewport): void;
 }

package/dist/scene/main/CanvasContext.d.ts

@@ -1,23 +1,27 @@
 import type { LineCap, LineJoin, LineStyle } from 'modern-path2d';
-import type { Batchable2D, ColorValue, Transform2D } from '../../core';
+import type { Batchable2D, ColorValue } from '../../core';
 import { Path2D } from 'modern-path2d';
 import { Texture2D } from '../resources';
+export type TransformUv = (uvs: Float32Array, index: number) => void;
+export type TransformVertex = (vertices: Float32Array, index: number) => void;
 export interface CanvasBatchable extends Batchable2D {
     type: 'stroke' | 'fill';
     texture?: Texture2D;
-    uvTransform?: Transform2D;
-    vertTransform?: Transform2D;
+    transformUv?: TransformUv;
+    transformVertex?: TransformVertex;
+    size?: {
+        width: number;
+        height: number;
+    };
 }
 export interface StrokeDraw extends Partial<CanvasBatchable> {
     type: 'stroke';
     path: Path2D;
     lineStyle: LineStyle;
-    uvTransform?: Transform2D;
 }
 export interface FillDraw extends Partial<CanvasBatchable> {
     type: 'fill';
     path: Path2D;
-    uvTransform?: Transform2D;
 }
 export declare class CanvasContext extends Path2D {
     fillStyle?: ColorValue | Texture2D;
@@ -27,12 +31,11 @@ export declare class CanvasContext extends Path2D {
     lineJoin?: LineJoin;
     lineWidth?: number;
     miterLimit?: number;
-    uvTransform?: Transform2D;
-    vertTransform?: Transform2D;
+    transformUv?: TransformUv;
+    transformVertex?: TransformVertex;
     protected _draws: (StrokeDraw | FillDraw)[];
     protected _parseDrawStyle(source?: ColorValue | Texture2D): {
         texture?: Texture2D;
-        backgroundColor?: number[];
     };
     stroke(options?: Partial<StrokeDraw>): void;
     fillRect(x: number, y: number, width: number, height: number): void;
@@ -41,6 +44,5 @@ export declare class CanvasContext extends Path2D {
     copy(source: CanvasContext): this;
     resetStatus(): void;
     reset(): this;
-    buildUvs(start: number, vertices: number[], uvs: number[], texture?: Texture2D, uvTransform?: Transform2D): void;
     toBatchables(): CanvasBatchable[];
 }

package/dist/scene/main/CanvasItem.d.ts

@@ -1,14 +1,12 @@
-import type { Batchable2D, ColorValue, WebGLBlendMode, WebGLRenderer } from '../../core';
+import type { Batchable2D, GlBlendMode, GlRenderer } from '../../core';
 import type { Texture2D } from '../resources';
 import type { CanvasBatchable } from './CanvasContext';
 import type { Node } from './Node';
 import type { TimelineNodeEvents, TimelineNodeProperties } from './TimelineNode';
-import { Color } from '../../core';
 import { CanvasContext } from './CanvasContext';
 import { TimelineNode } from './TimelineNode';
 export interface CanvasItemProperties extends TimelineNodeProperties {
-    modulate: ColorValue;
-    blendMode: WebGLBlendMode;
+    blendMode: GlBlendMode;
 }
 export interface CanvasItemEvents extends TimelineNodeEvents {
     draw: [];
@@ -20,8 +18,7 @@ export interface CanvasItem {
     emit: <K extends keyof CanvasItemEvents & string>(event: K, ...args: CanvasItemEvents[K]) => this;
 }
 export declare class CanvasItem extends TimelineNode {
-    modulate: ColorValue | undefined;
-    blendMode: WebGLBlendMode | undefined;
+    blendMode: GlBlendMode | undefined;
     visible: boolean;
     opacity: number;
     protected _parentGlobalVisible?: boolean;
@@ -30,14 +27,13 @@ export declare class CanvasItem extends TimelineNode {
     protected _parentGlobalOpacity?: number;
     protected _globalOpacity?: number;
     get globalOpacity(): number;
-    protected _modulate: Color;
     context: CanvasContext;
     protected _resetContext: boolean;
-    protected _redrawing: boolean;
-    protected _relayouting: boolean;
-    protected _repainting: boolean;
-    protected _originalBatchables: CanvasBatchable[];
-    protected _layoutedBatchables: CanvasBatchable[];
+    needsRender: boolean;
+    needsLayout: boolean;
+    needsPaint: boolean;
+    protected _rawBatchables: CanvasBatchable[];
+    protected _layoutBatchables: CanvasBatchable[];
     protected _batchables: CanvasBatchable[];
     constructor(properties?: Partial<CanvasItemProperties>, nodes?: Node[]);
     protected _updateProperty(key: string, value: any, oldValue: any): void;
@@ -45,17 +41,18 @@ export declare class CanvasItem extends TimelineNode {
     hide(): void;
     isVisibleInTree(): boolean;
     canRender(): boolean;
-    requestRedraw(): void;
-    requestRelayout(): void;
-    requestRepaint(): void;
+    requestRender(): void;
+    requestLayout(): void;
+    requestPaint(): void;
     protected _updateGlobalVisible(): void;
     protected _updateGlobalOpacity(): void;
     protected _draw(): void;
+    protected _transformUvs(batchable: CanvasBatchable): Float32Array | undefined;
     protected _redraw(): CanvasBatchable[];
     protected _relayout(batchables: CanvasBatchable[]): CanvasBatchable[];
     protected _repaint(batchables: CanvasBatchable[]): CanvasBatchable[];
     protected _process(delta: number): void;
     protected _updateBatchables(): void;
     protected _handleViewportTexture(batchable: Batchable2D): Texture2D | undefined;
-    protected _render(renderer: WebGLRenderer): void;
+    protected _render(renderer: GlRenderer): void;
 }

package/dist/scene/main/Effect.d.ts

@@ -1,4 +1,4 @@
-import type { WebGLRenderer } from '../../core';
+import type { GlRenderer } from '../../core';
 import type { Material } from '../resources';
 import type { Node } from './Node';
 import type { SceneTree } from './SceneTree';
@@ -16,7 +16,6 @@ export interface EffectContext {
     redraw?: boolean;
     /** parent redraw */
     target?: Node;
-    targetArea?: [number, number, number, number];
     /** transition */
     from?: Viewport;
     to?: Viewport;
@@ -26,6 +25,7 @@ export declare class Effect extends TimelineNode {
     effectMode?: EffectMode;
     glsl?: string;
     glslSrc?: string;
+    needsRender: boolean;
     protected get _effectMode(): EffectMode;
     /** Viewports */
     readonly viewport1: Viewport;
@@ -45,10 +45,9 @@ export declare class Effect extends TimelineNode {
     protected _processParent(): void;
     protected _processChildren(): void;
     _onProcess(delta?: number): void;
-    protected _renderBefore(renderer: WebGLRenderer): void;
-    protected _renderTransition(renderer: WebGLRenderer): void;
-    protected _renderParentOrChildren(renderer: WebGLRenderer): void;
-    protected _parseTargetArea(): number[] | undefined;
-    protected _render(renderer: WebGLRenderer): void;
-    apply(renderer: WebGLRenderer, viewport: Viewport, context?: EffectContext): void;
+    protected _renderBefore(renderer: GlRenderer): void;
+    protected _renderTransition(renderer: GlRenderer): void;
+    protected _renderParentOrChildren(renderer: GlRenderer): void;
+    protected _render(renderer: GlRenderer): void;
+    apply(renderer: GlRenderer, viewport: Viewport, context?: EffectContext): void;
 }

package/dist/scene/main/Node.d.ts

@@ -1,4 +1,4 @@
-import type { CoreObjectEvents, InputEvent, InputEventKey, InputEvents, Maskable, WebGLRenderer } from '../../core';
+import type { CoreObjectEvents, GlRenderer, InputEvent, InputEventKey, InputEvents, MaskLike } from '../../core';
 import type { SceneTree } from './SceneTree';
 import type { Viewport } from './Viewport';
 import type { Window } from './Window';
@@ -30,21 +30,30 @@ export interface Node {
     off: <K extends keyof NodeEvents & string>(event: K, listener: (...args: NodeEvents[K]) => void) => this;
     emit: <K extends keyof NodeEvents & string>(event: K, ...args: NodeEvents[K]) => this;
 }
-export type ProcessMode = 'inherit' | 'pausable' | 'when_paused' | 'always' | 'disabled';
-export type ProcessSortMode = 'default' | 'parent_before';
+export type ProcessMode = 'inherit' | 'pausable' | 'when-paused' | 'always' | 'disabled';
+export type ProcessSortMode = 'default' | 'parent-before';
 export type RenderMode = 'inherit' | 'always' | 'disabled';
 export type InputMode = 'inherit' | 'always' | 'disabled';
 export type InternalMode = 'default' | 'front' | 'back';
 export interface NodeProperties {
     id: string;
     name: string;
-    mask: Maskable;
+    mask: MaskLike;
     processMode: ProcessMode;
     processSortMode: ProcessSortMode;
     renderMode: RenderMode;
     internalMode: InternalMode;
     meta: Record<string, any>;
 }
+export interface SerializedNode {
+    [key: string]: any;
+    is?: string;
+    children?: SerializedNode[];
+    meta?: {
+        [key: string]: any;
+        inCanvasIs?: string;
+    };
+}
 export declare class Node extends CoreObject {
     readonly is: string;
     id: string;
@@ -54,7 +63,7 @@ export declare class Node extends CoreObject {
     renderMode: RenderMode;
     inputMode: InputMode;
     internalMode: InternalMode;
-    mask?: Maskable;
+    mask?: MaskLike;
     protected _meta: Meta;
     get meta(): Meta;
     set meta(value: Record<string, any>);
@@ -101,7 +110,7 @@ export declare class Node extends CoreObject {
     protected _onUnparented(oldParent: Node): void;
     protected _onReady(): void;
     protected _onProcess(delta?: number): void;
-    render(renderer: WebGLRenderer, next?: () => void): void;
+    render(renderer: GlRenderer, next?: () => void): void;
     input(event: InputEvent, key: InputEventKey): void;
     getIndex(): number;
     getNode<T extends Node>(path: string): T | undefined;
@@ -109,8 +118,8 @@ export declare class Node extends CoreObject {
     addSibling(sibling: Node): this;
     prepend<T extends Node>(nodes: T[]): void;
     prepend<T extends Node>(...nodes: T[]): void;
-    append<T extends Node>(nodes: T[]): void;
-    append<T extends Node>(...nodes: T[]): void;
+    append<T extends Node | SerializedNode>(nodes: T[]): void;
+    append<T extends Node | SerializedNode>(...nodes: T[]): void;
     before<T extends Node>(nodes: T[]): void;
     before<T extends Node>(...nodes: T[]): void;
     after<T extends Node>(nodes: T[]): void;
@@ -132,9 +141,9 @@ export declare class Node extends CoreObject {
     protected _unparented(oldParent: Node): void;
     protected _process(delta: number): void;
     protected _input(event: InputEvent, key: InputEventKey): void;
-    protected _render(renderer: WebGLRenderer): void;
+    protected _render(renderer: GlRenderer): void;
     destroy(): void;
     clone(): this;
     toJSON(): Record<string, any>;
-    static parse(value: any): any;
+    static parse(value: SerializedNode | SerializedNode[]): any;
 }

package/dist/scene/main/RenderStack.d.ts

@@ -1,15 +1,18 @@
-import type { WebGLRenderer } from '../../core';
+import type { GlRenderer } from '../../core';
 import type { Node } from './Node';
+export type Renderable = Node & {
+    needsRender?: boolean;
+};
 export interface RenderCall {
-    renderable: Node;
-    fn: (renderer: WebGLRenderer, next: () => void) => void;
+    renderable: Renderable;
+    fn: (renderer: GlRenderer, next: () => void) => void;
     parentCall: RenderCall | undefined;
     calls: RenderCall[];
 }
 export declare class RenderStack {
     currentCall?: RenderCall;
     calls: RenderCall[];
-    createCall(renderable: Node): RenderCall;
-    push(renderable: Node): RenderCall;
-    render(renderer: WebGLRenderer): void;
+    createCall(renderable: Renderable): RenderCall;
+    push(renderable: Renderable): RenderCall;
+    render(renderer: GlRenderer): void;
 }

package/dist/scene/main/SceneTree.d.ts

@@ -1,6 +1,6 @@
 import type { Fonts } from 'modern-font';
 import type { Hex8Color } from 'modern-idoc';
-import type { InputEvents, MainLoopEvents, MainLoopProperties, WebGLRenderer } from '../../core';
+import type { GlRenderer, InputEvents, MainLoopEvents, MainLoopProperties } from '../../core';
 import type { Node } from './Node';
 import type { Viewport } from './Viewport';
 import { Color, Input, MainLoop } from '../../core';
@@ -24,6 +24,7 @@ export interface SceneTree {
 export interface SceneTreeProperties extends MainLoopProperties {
     msaa: boolean;
     pixelate: boolean;
+    roundPixels: boolean;
     backgroundColor: Hex8Color;
     debug: boolean;
     processPaused: boolean;
@@ -33,6 +34,7 @@ export interface SceneTreeProperties extends MainLoopProperties {
 export declare class SceneTree extends MainLoop {
     msaa: boolean;
     pixelate: boolean;
+    roundPixels: boolean;
     backgroundColor?: Hex8Color;
     debug: boolean;
     processPaused: boolean;
@@ -44,14 +46,14 @@ export declare class SceneTree extends MainLoop {
     protected _backgroundColor: Color;
     protected _previousViewport?: Viewport;
     protected _currentViewport?: Viewport;
-    getCurrentViewport(): Viewport | undefined;
     getPreviousViewport(): Viewport | undefined;
+    getCurrentViewport(): Viewport | undefined;
     setCurrentViewport(viewport: Viewport | undefined): void;
     constructor(properties?: Partial<SceneTreeProperties>);
     protected _updateProperty(key: string, value: any, oldValue: any): void;
     log(...args: any[]): void;
     protected _process(delta?: number): void;
-    protected _render(renderer: WebGLRenderer): void;
-    protected _renderScreen(renderer: WebGLRenderer): void;
+    protected _render(renderer: GlRenderer): void;
+    protected _renderScreen(renderer: GlRenderer): void;
     destroy(): void;
 }

package/dist/scene/main/Viewport.d.ts

@@ -1,8 +1,9 @@
-import type { Vector2, Vector2Data, WebGLFramebufferOptions, WebGLRenderer } from '../../core';
+import type { GlRenderer, RectangleLike, Vector2, Vector2Data } from '../../core';
+import type { Texture2D } from '../resources';
 import type { Rectangulable, RectangulableEvents } from './interfaces';
 import type { NodeEvents } from './Node';
-import { Projection2D, Rect2, Transform2D } from '../../core';
-import { ViewportTexture } from '../resources';
+import { Rectangle, Transform2D } from '../../core';
+import { RenderTarget } from '../resources';
 import { Node } from './Node';
 export interface ViewportEvents extends NodeEvents, RectangulableEvents {
 }
@@ -12,40 +13,31 @@ export interface Viewport {
     off: <K extends keyof ViewportEvents & string>(event: K, listener: (...args: ViewportEvents[K]) => void) => this;
     emit: <K extends keyof ViewportEvents & string>(event: K, ...args: ViewportEvents[K]) => this;
 }
-export interface ViewportFramebuffer {
-    texture: ViewportTexture;
-    needsUpload: boolean;
-}
 export declare class Viewport extends Node implements Rectangulable {
-    flipY: boolean;
-    readonly projection: Projection2D;
     readonly canvasTransform: Transform2D;
-    protected _framebufferIndex: number;
-    protected _framebuffers: ViewportFramebuffer[];
+    renderTargetIndex: number;
+    readonly renderTargets: RenderTarget[];
     x: number;
     y: number;
     width: number;
     height: number;
+    mipLevel: number;
     msaa: boolean;
     get valid(): boolean;
-    get framebuffer(): ViewportFramebuffer;
-    get texture(): ViewportTexture;
+    get renderTarget(): RenderTarget;
+    get previousRenderTarget(): RenderTarget;
+    get texture(): Texture2D<null>;
     getViewport(): Viewport;
-    constructor(flipY?: boolean);
-    /** @internal */
-    _glFramebufferOptions(renderer: WebGLRenderer): WebGLFramebufferOptions;
-    /** @internal */
-    _glFramebuffer(renderer: WebGLRenderer): WebGLFramebuffer;
     protected _updateProperty(key: string, value: any, oldValue: any): void;
-    requestUpload(): void;
+    flush(renderer: GlRenderer): void;
     resize(width: number, height: number): void;
-    upload(renderer: WebGLRenderer): boolean;
-    activate(renderer: WebGLRenderer): boolean;
-    flush(renderer: WebGLRenderer): void;
-    redraw(renderer: WebGLRenderer, cb: () => void): boolean;
-    activateWithCopy(renderer: WebGLRenderer, target: Viewport): void;
-    render(renderer: WebGLRenderer, next?: () => void): void;
-    getRect(): Rect2;
+    activate(renderer: GlRenderer, frame?: RectangleLike): boolean;
+    redraw(renderer: GlRenderer, cb: () => void): boolean;
+    activateWithCopy(renderer: GlRenderer, target: Viewport): void;
+    renderStart(renderer: GlRenderer, frame?: RectangleLike): void;
+    renderEnd(renderer: GlRenderer, oldViewport: Viewport | undefined): void;
+    render(renderer: GlRenderer, next?: () => void): void;
+    getRect(): Rectangle;
     toCanvasGlobal<P extends Vector2Data = Vector2>(screenPos: Vector2Data, newPos?: P): P;
     toCanvasScreen<P extends Vector2Data = Vector2>(globalPos: Vector2Data, newPos?: P): P;
 }

package/dist/scene/main/Window.d.ts

@@ -1,7 +1,7 @@
-import type { WebGLRenderer } from '../../core';
+import type { GlRenderer } from '../../core';
 import { Viewport } from './Viewport';
 export declare class Window extends Viewport {
-    msaa: boolean;
-    finish(renderer: WebGLRenderer): void;
-    flush(renderer: WebGLRenderer): void;
+    constructor();
+    finish(renderer: GlRenderer): void;
+    flush(renderer: GlRenderer): void;
 }

package/dist/scene/main/interfaces/Rectangulable.d.ts

@@ -1,4 +1,4 @@
-import type { Rect2 } from '../../../core';
+import type { Rectangle } from '../../../core';
 export interface RectangulableEvents {
     updateRect: [];
 }
@@ -9,5 +9,5 @@ export interface Rectangulable {
     emit: <K extends keyof RectangulableEvents & string>(event: K, ...args: RectangulableEvents[K]) => this;
 }
 export interface Rectangulable {
-    getRect: () => Rect2;
+    getRect: () => Rectangle;
 }

package/dist/scene/resources/RenderTarget.d.ts

@@ -0,0 +1,24 @@
+import type { GlRenderer, RectangleLike, RenderTargetLikeReactiveObject, ResourceEvents } from '../../core';
+import { Resource } from '../../core';
+import { Texture2D } from '../resources';
+export interface RenderTargetEvents extends ResourceEvents {
+}
+export interface RenderTarget {
+    on: <K extends keyof RenderTargetEvents & string>(event: K, listener: (...args: RenderTargetEvents[K]) => void) => this;
+    once: <K extends keyof RenderTargetEvents & string>(event: K, listener: (...args: RenderTargetEvents[K]) => void) => this;
+    off: <K extends keyof RenderTargetEvents & string>(event: K, listener: (...args: RenderTargetEvents[K]) => void) => this;
+    emit: <K extends keyof RenderTargetEvents & string>(event: K, ...args: RenderTargetEvents[K]) => this;
+}
+export declare class RenderTarget extends Resource implements RenderTargetLikeReactiveObject {
+    isRoot: boolean;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    mipLevel: number;
+    msaa: boolean;
+    colorTextures: Texture2D<null>[];
+    get valid(): boolean;
+    get colorTexture(): Texture2D<null>;
+    activate(renderer: GlRenderer, frame?: RectangleLike): boolean;
+}

package/dist/scene/resources/geometries/Geometry.d.ts

@@ -1,24 +1,15 @@
-import type { WebGLDrawMode, WebGLRenderer, WebGLVertexArrayObjectOptions } from '../../../core';
+import type { GeometryLikeObject, GeometryLikeReactiveObject, GlRenderer, Topology } from '../../../core';
 import type { Material } from '../materials/Material';
-import type { IndexBuffer } from './IndexBuffer';
 import type { VertexAttribute } from './VertexAttribute';
-import { RawWeakMap, Resource } from '../../../core';
-export interface GeometryOptions {
-    vertexAttributes?: Record<string, VertexAttribute>;
-    indexBuffer?: IndexBuffer;
-    instanceCount?: number;
-    mode?: WebGLDrawMode;
+import { Resource } from '../../../core';
+import { IndexBuffer } from './IndexBuffer';
+export interface GeometryProperties extends Partial<Omit<GeometryLikeObject, 'instanceId'>> {
 }
-export declare class Geometry extends Resource {
-    vertexAttributes: Map<string, VertexAttribute>;
-    indexBuffer?: IndexBuffer;
-    instanceCount?: number;
-    mode: WebGLDrawMode;
-    protected _materialWeakMap: RawWeakMap<Material, Record<string, any>>;
-    constructor(options?: GeometryOptions);
-    /** @internal */
-    _glVertexArray(renderer: WebGLRenderer): WebGLVertexArrayObjectOptions;
-    /** @internal */
-    _glVertexArrayObject(renderer: WebGLRenderer, material: Material): WebGLVertexArrayObject | null;
-    draw(renderer: WebGLRenderer, material: Material, uniforms?: Record<string, any>): void;
+export declare class Geometry extends Resource implements GeometryLikeReactiveObject {
+    topology: Topology;
+    attributes: Record<string, VertexAttribute>;
+    indexBuffer: IndexBuffer;
+    instanceCount: number;
+    constructor(properties?: GeometryProperties);
+    draw(renderer: GlRenderer, material: Material, uniforms?: Record<string, any>): void;
 }

package/dist/scene/resources/geometries/IndexBuffer.d.ts

@@ -1,18 +1,9 @@
-import type { WebGLBufferOptions, WebGLRenderer } from '../../../core';
-import { Resource } from '../../../core';
-export interface IndexBufferOptions {
-    data?: Uint16Array<ArrayBuffer> | null;
-    dynamic?: boolean;
+import type { BufferLikeObject, BufferLikeReactiveObject } from '../../../core';
+import { BufferUsage, Resource } from '../../../core';
+export interface IndexBufferProperties extends Partial<Omit<BufferLikeObject, 'instanceId'>> {
 }
-export declare class IndexBuffer extends Resource {
-    data: Uint16Array<ArrayBuffer> | null;
-    dynamic: boolean;
-    needsUpload: boolean;
-    constructor(options?: IndexBufferOptions);
-    /** @internal */
-    _glBufferOptions(): WebGLBufferOptions;
-    /** @internal */
-    _glBuffer(renderer: WebGLRenderer): WebGLBuffer;
-    protected _updateProperty(key: string, value: any, oldValue: any): void;
-    upload(renderer: WebGLRenderer): boolean;
+export declare class IndexBuffer extends Resource implements BufferLikeReactiveObject {
+    usage: BufferUsage;
+    data: BufferLikeObject['data'];
+    constructor(properties?: IndexBufferProperties);
 }

package/dist/scene/resources/geometries/QuadUvGeometry.d.ts

@@ -1,9 +1,9 @@
-import type { WebGLRenderer } from '../../../core';
+import type { GlRenderer } from '../../../core';
 import type { Material } from '../materials';
 import { Geometry } from './Geometry';
 export declare class QuadUvGeometry extends Geometry {
     protected static _instance: QuadUvGeometry;
     static get instance(): QuadUvGeometry;
-    static draw(renderer: WebGLRenderer, material?: Material, uniforms?: Record<string, any>): void;
+    static draw(renderer: GlRenderer, material?: Material, uniforms?: Record<string, any>): void;
     constructor();
 }

package/dist/scene/resources/geometries/UvGeometry.d.ts

@@ -1,7 +1,10 @@
+import type { GeometryProperties } from './Geometry';
 import { Geometry } from './Geometry';
 import { VertexBuffer } from './VertexBuffer';
+export interface UvGeometryProperties extends GeometryProperties {
+}
 export declare class UvGeometry extends Geometry {
     positionBuffer: VertexBuffer;
     uvBuffer: VertexBuffer;
-    constructor();
+    constructor(properties: UvGeometryProperties);
 }

package/dist/scene/resources/geometries/VertexAttribute.d.ts

@@ -1,24 +1,15 @@
+import type { GeometryAttributeLike, VertexFormat } from '../../../core';
 import { Resource } from '../../../core';
 import { VertexBuffer } from './VertexBuffer';
-export interface VertexAttributeOptions {
-    buffer?: VertexBuffer;
-    size?: number;
-    normalized?: boolean;
-    type?: 'float' | 'unsigned_byte' | 'unsigned_short';
+export interface VertexAttributeProperties extends Partial<GeometryAttributeLike> {
+}
+export declare class VertexAttribute extends Resource implements GeometryAttributeLike {
+    buffer: VertexBuffer;
+    format: VertexFormat;
+    instance?: boolean;
     stride?: number;
     offset?: number;
+    start?: number;
     divisor?: number;
-}
-export declare class VertexAttribute extends Resource {
-    buffer: VertexBuffer;
-    size: number;
-    normalized: boolean;
-    type: 'float' | 'unsigned_byte' | 'unsigned_short';
-    stride: number | undefined;
-    offset: number | undefined;
-    divisor: number | undefined;
-    needsUpload: boolean;
-    constructor(options?: VertexAttributeOptions);
-    protected _updateProperty(key: string, value: any, oldValue: any): void;
-    upload(): boolean;
+    constructor(properties?: VertexAttributeProperties);
 }

package/dist/scene/resources/geometries/VertexBuffer.d.ts

@@ -1,18 +1,9 @@
-import type { WebGLBufferOptions, WebGLRenderer } from '../../../core';
-import { Resource } from '../../../core';
-export interface VertexBufferOptions {
-    data?: BufferSource | null;
-    dynamic?: boolean;
+import type { BufferLikeObject, BufferLikeReactiveObject } from '../../../core';
+import { BufferUsage, Resource } from '../../../core';
+export interface VertexBufferProperties extends Partial<Omit<BufferLikeObject, 'instanceId'>> {
 }
-export declare class VertexBuffer extends Resource {
-    data: BufferSource | null;
-    dynamic: boolean;
-    needsUpload: boolean;
-    constructor(options?: VertexBufferOptions);
-    /** @internal */
-    _glBufferOptions(): WebGLBufferOptions;
-    /** @internal */
-    _glBuffer(renderer: WebGLRenderer): WebGLBuffer;
-    protected _updateProperty(key: string, value: any, oldValue: any): void;
-    upload(renderer: WebGLRenderer): boolean;
+export declare class VertexBuffer extends Resource implements BufferLikeReactiveObject {
+    usage: BufferUsage;
+    data: BufferLikeObject['data'];
+    constructor(properties?: VertexBufferProperties);
 }

package/dist/scene/resources/index.d.ts

@@ -1,3 +1,4 @@
 export * from './geometries';
 export * from './materials';
+export * from './RenderTarget';
 export * from './textures';

package/dist/scene/resources/materials/EffectMaterial.d.ts

@@ -1,7 +1,5 @@
 import { Material } from './Material';
 export declare class EffectMaterial extends Material {
-    vert: string;
-    readonly uniforms: Map<string, any>;
     static RE: {
         getColor: RegExp;
         getFromColor: RegExp;