archgine 1.0.36 → 1.0.39

package/lib/renderers/binding-states.d.ts

@@ -1,4 +1,4 @@
-import { ICamera2, ILight, IObject2, IPath2, IRenderer2Config, IShape, ITexture } from '../interfaces';
+import { ICamera2, ILight, IObject2, IPath2Command, IRenderer2Config, IShape2, ITexture } from '../interfaces';
 import { Path } from '../geometries/path';
 export interface IBindingState {
     id: number;
@@ -11,7 +11,7 @@ export interface IBindingState {
     mtlVersion?: number;
     version: number;
     cachedTexture?: ITexture;
-    pat?: IPath2;
+    renderCommands?: IPath2Command[];
 }
 export interface IRenderState {
     light?: ILight;
@@ -27,10 +27,10 @@ export declare class BindingStates {
     constructor(config: IRenderer2Config);
     destroy(): void;
     reset(): void;
-    setup(obj: IShape, currentRenderState?: IRenderState, camera?: ICamera2): IBindingState;
+    setup(obj: IShape2, currentRenderState?: IRenderState, camera?: ICamera2): IBindingState;
     getBindingState(obj: IObject2): IBindingState;
     clearBindingState(): void;
-    needsUpdate(obj: IShape): boolean;
+    needsUpdate(obj: IShape2): boolean;
     saveCache(obj: IShape2): void;
     updateModelViewMatrix(obj: IObject2, camera?: ICamera2): void;
 }

package/lib/renderers/buffer-renderer.d.ts

@@ -1,4 +1,4 @@
-import { IContext2D, IObject2, IPath2, IShape2 } from '../interfaces';
+import { IContext2D, IObject2, IShape2, IText2 } from '../interfaces';
 import { BindingStates } from './binding-states';
 export default class BufferRenderer {
     ctx: IContext2D;
@@ -10,8 +10,14 @@ export default class BufferRenderer {
     destroy(): void;
     beforeRender(obj: IObject2): void;
     render(obj: IShape2): void;
+    renderFill(obj: IShape2): void;
+    renderStroke(obj: IShape2): void;
+    renderText(obj: IText2): void;
     afterRender(): void;
-    renderWireFrame(shape: IShape2): void;
-    renderStroke(path?: IPath2, color?: string, lineWidth?: number, lineDash?: [number, number]): void;
+    renderWireFrame(obj: IShape2): void;
     renderSelected(shape: IShape2): void;
+    renderMergedBefore(): void;
+    renderMergedGeo(obj: IShape2): void;
+    renderMergedMat(obj: IShape2): void;
+    renderMergedAfter(): void;
 }

package/lib/renderers/cvs-renderer.d.ts

@@ -3,11 +3,12 @@ import { RenderState, RenderStates } from './render-states';
 import { default as BufferRenderer } from './buffer-renderer';
 import { BindingStates } from './binding-states';
 import { Renderer } from './renderer';
-import { IRenderItem, RenderList, RenderLists } from '../renders/render-lists';
+import { RenderList, RenderLists } from './render-lists';
 import { IQueue } from '../core/queue';
 export declare class CvsRenderer<Config extends IRenderer2Config> extends Renderer<Config> implements IRenderer2 {
     readonly name: string;
     id: string;
+    mergeRendering: boolean;
     renderer: BufferRenderer;
     bindingStates: BindingStates;
     renderStates: RenderStates;
@@ -22,8 +23,9 @@ export declare class CvsRenderer<Config extends IRenderer2Config> extends Render
     destroy(): void;
     render(scene: IObject2, camera?: ICamera2): void;
     projectObject(obj: IObject2, camera?: ICamera2 | undefined, groupOrder?: number): void;
+    renderMerged(currentRenderList: RenderList, camera?: ICamera2): void;
     renderScene(currentRenderList: RenderList, scene: IObject2, camera?: ICamera2): void;
-    renderObjects(queue: IQueue<IRenderItem>, scene: IObject2, camera?: ICamera2): void;
+    renderObjects(queue: IQueue<IObject2>, scene: IObject2, camera?: ICamera2): void;
     renderObject(obj: IObject2, scene: IObject2, camera?: ICamera2): void;
     renderBufferDirect(obj: IObject2, scene: IObject2, camera?: ICamera2): void;
     renderTexture(texture: ITexture): void;

package/lib/renderers/render-lists.d.ts

@@ -9,17 +9,15 @@ export interface IRenderItem {
     group: Group2<IGroup2Config> | undefined;
 }
 export declare class RenderList {
-    renderItems: IRenderItem[];
-    renderItemsIndex: number;
     queue: IQueue;
+    mergedQueue: Record<string, IQueue>;
     constructor();
     destroy(): void;
     clear(): void;
-    getNextRenderItem(object: IObject2, groupOrder: number, group?: Group2<IGroup2Config>): IRenderItem;
-    push(object: IObject2, groupOrder: number, group?: Group2<IGroup2Config>): this;
-    unshift(object: IObject2, groupOrder: number, group: Group2<IGroup2Config>): void;
+    push(object: IObject2, groupOrder: number): this;
+    unshift(object: IObject2): void;
     sort(fn?: (a: any, b: any) => number): this;
-    finish(): this;
+    mergeQueue(): this;
 }
 export declare class RenderLists {
     lists: WeakMap<IObject2, RenderList[]>;

package/lib/renderers/render-target.d.ts

@@ -1,4 +1,4 @@
-import { IContext2D, IRenderer2Config, IRenderTarget, ITexture } from '../interfaces';
+import { ICanvas, IContext2D, IRenderer2Config, IRenderTarget, ITexture } from '../interfaces';
 import { default as EventDispatcher } from '../core/event-dispatcher';
 export interface IRenderTargetConfig extends IRenderer2Config {
     width: number;
@@ -15,7 +15,7 @@ export declare class RenderTarget<Config extends IRenderTargetConfig> extends Ev
     height: number;
     dpr: number | undefined;
     texture: ITexture;
-    cvs: OffscreenCanvas | HTMLCanvasElement;
+    cvs: ICanvas;
     ctx: IContext2D;
     constructor(config?: Config);
     destroy(): void;

package/lib/renderers/renderer.d.ts

@@ -7,9 +7,9 @@ export declare abstract class Renderer<Config extends IRenderer2Config> {
     cvs: ICanvas | undefined;
     ctx: IContext2D | undefined;
     _currentRenderTarget: IRenderTarget | undefined;
+    _isContextLost: boolean;
     private readonly contextLostHandler;
     private readonly contextRestoreHandler;
-    _isContextLost: boolean;
     protected constructor(config?: Config);
     destroy(): void;
     init(): void;

package/lib/renders/render-target.d.ts

@@ -1,4 +1,4 @@
-import { IContext2D, IRenderer2Config, IRenderTarget, ITexture } from '../interfaces';
+import { ICanvas, IContext2D, IRenderer2Config, IRenderTarget, ITexture } from '../interfaces';
 import { default as EventDispatcher } from '../core/event-dispatcher';
 export interface IRenderTargetConfig extends IRenderer2Config {
     width: number;
@@ -15,7 +15,7 @@ export declare class RenderTarget<Config extends IRenderTargetConfig> extends Ev
     height: number;
     dpr: number | undefined;
     texture: ITexture;
-    cvs: OffscreenCanvas | HTMLCanvasElement;
+    cvs: ICanvas;
     ctx: IContext2D;
     constructor(config?: Config);
     destroy(): void;

package/lib/scenes/loading-scene.d.ts

@@ -1,8 +1,8 @@
-import { IShapeConfig } from '../objects/shape';
 import { DynamicScene } from './dynamic-scene';
-import { Circle, ICircleConfig } from '../shapes/circle';
-import { Text, ITextConfig } from '../shapes/text';
-export interface ILoadingSceneConfig extends IShapeConfig {
+import { Circle, ICircleConfig } from '../shapes2/circle';
+import { ITextConfig, Text } from '../shapes2/text';
+import { IShape2Config } from '../objects/shape2';
+export interface ILoadingSceneConfig extends IShape2Config {
 }
 export declare class LoadingScene<Config extends ILoadingSceneConfig> extends DynamicScene {
     readonly isLoadingScene: boolean;
@@ -15,5 +15,4 @@ export declare class LoadingScene<Config extends ILoadingSceneConfig> extends Dy
     scaleTrend: boolean;
     constructor(config?: Config);
     onBeforeRender(): void;
-    fullscreen(padding?: number, animate?: boolean): void;
 }

package/lib/{extras → scenes}/main-scene.d.ts

@@ -1,5 +1,5 @@
-import { StaticScene } from '../scenes/static-scene';
-import { AxesHelper } from '../helpers/axes-helper';
+import { StaticScene } from './static-scene';
+import { AxesHelper2 } from '../helpers/axes-helper2';
 export interface IMainSceneConfig {
     castShadow?: boolean;
 }
@@ -7,7 +7,7 @@ export declare class MainScene<Config extends IMainSceneConfig> extends StaticSc
     readonly isMainScene: boolean;
     name: string;
     featureKey: string;
-    axesHelper?: AxesHelper;
+    axesHelper?: AxesHelper2<any>;
     constructor(config?: Config);
     destroy(): void;
     initAxesHelper(): void;

package/lib/scenes/scene.d.ts

@@ -12,7 +12,6 @@ export default class Scene extends Object2 implements IScene {
     constructor();
     destroy(): void;
     setup(view?: IView): void;
-    fullscreen(padding?: number, animate?: boolean): void;
     /** @override */
     onBeforeRender(renderer: any, scene: Object2, camera?: ICamera2): void;
     /** @override */

package/lib/scenes/svg-scene.d.ts

@@ -1,8 +1,7 @@
 import { default as Scene } from './scene';
 import { default as Box2 } from '../math/box2';
-import { IBox2, IRaycaster, IScene, ITree } from '../interfaces';
+import { IBox2, IRaycaster, ITree } from '../interfaces';
 import { SvgChef } from '../extras/svg-chef';
-import { TLayer } from '../extras/chef';
 import { ISvgAppConfig } from '../extras/svg-app';
 import { SvgPainter } from '../extras/svg-painter';
 export interface ISvgSceneConfig extends ISvgAppConfig {
@@ -12,7 +11,7 @@ export type TLegend = {
     color: string;
     ids: Array<string>;
 };
-export declare class SvgScene<Config extends ISvgSceneConfig> extends Scene implements IScene {
+export declare class SvgScene<Config extends ISvgSceneConfig> extends Scene {
     readonly isSvgScene: boolean;
     readonly name: string;
     dynamically: boolean;
@@ -45,7 +44,7 @@ export declare class SvgScene<Config extends ISvgSceneConfig> extends Scene impl
     load(url: string): Promise<any>;
     bind(str: string): void;
     appendStyles(): void;
-    getLayers(lv?: number): TLayer[];
+    getLayers(lv?: number): ITree[];
     setDefaultLayers(ids: string[]): void;
     setSkeletonLayers(ids: string[]): void;
     setCurrentLayers(ids: string[]): void;

package/lib/shapes2/arrow.d.ts

@@ -0,0 +1,6 @@
+import { IPolygonConfig, Polygon } from './polygon';
+export declare class Arrow<Config extends IPolygonConfig = IPolygonConfig> extends Polygon<Config> {
+    type: string;
+    readonly isArrow: boolean;
+    constructor(config?: Config);
+}

package/lib/shapes2/axes.d.ts

@@ -0,0 +1,35 @@
+import { IShape2Config, Shape2 } from '../objects/shape2';
+export interface IAxesConfig extends IShape2Config {
+    width?: number;
+    height?: number;
+    arrowDeg?: number;
+    arrowLength?: number;
+}
+/**
+ *        ^       p1
+ *        │
+ *        │
+ * ----- p0 ───────>
+ *        ╎
+ *        ╎
+ *
+ * @Author Dio Zhu 2024.8.11
+ */
+export declare class Axes<Config extends IAxesConfig> extends Shape2 {
+    name: string;
+    readonly isAxes: boolean;
+    matrixAutoUpdate: boolean;
+    matrixWorldAutoUpdate: boolean;
+    composeNode: boolean;
+    dynamically: boolean;
+    arrowLength: number;
+    arrowDeg: number;
+    stroke: string;
+    fill: string | undefined;
+    lineWidth: number;
+    xMesh: Shape2;
+    yMesh: Shape2;
+    xrMesh: Shape2;
+    yrMesh: Shape2;
+    constructor(config?: Config);
+}

package/lib/shapes2/circle.d.ts

@@ -0,0 +1,10 @@
+import { IShape2Config, Shape2 } from '../objects/shape2';
+export interface ICircleConfig extends IShape2Config {
+    radius?: number;
+}
+export declare class Circle<Config extends ICircleConfig> extends Shape2 {
+    type: string;
+    name: string;
+    readonly isCircle: boolean;
+    constructor(config?: Config);
+}

package/lib/shapes2/polygon.d.ts

@@ -0,0 +1,9 @@
+import { IShape2Config, Shape2 } from '../objects/shape2';
+export interface IPolygonConfig extends IShape2Config {
+}
+export declare class Polygon<Config extends IPolygonConfig> extends Shape2 {
+    readonly isPolygon: boolean;
+    type: string;
+    name: string;
+    constructor(config?: Config);
+}

package/lib/shapes2/text.d.ts

@@ -0,0 +1,21 @@
+import { default as Vector2 } from '../math/vector2';
+import { IBox2, IContext2D, IText2 } from '../interfaces';
+import { ITextMaterial2Config } from '../materials/text-material2';
+import { IShape2Config, Shape2 } from '../objects/shape2';
+import { TextMat2 } from '../materials/text-mat2';
+export interface ITextConfig extends IShape2Config, ITextMaterial2Config {
+    fixed?: boolean;
+    rotated?: number;
+}
+export declare class Text<Config extends ITextConfig> extends Shape2 implements IText2 {
+    readonly isText: boolean;
+    name: string;
+    mat: TextMat2<Config>;
+    textContent?: string;
+    size: Vector2;
+    constructor(config?: Config);
+    /** @override */
+    computeBoundingBox(): IBox2;
+    /** @override */
+    render(ctx: IContext2D): void;
+}

package/lib/textures/texture.d.ts

@@ -1,4 +1,4 @@
-import { ITexture, IVector2 } from '../interfaces';
+import { ICanvas, ITexture, IVector2 } from '../interfaces';
 import { default as Vector2 } from '../math/vector2';
 import { default as Matrix3 } from '../math/matrix3';
 import { Node2 } from '../objects/node2';
@@ -25,7 +25,7 @@ export declare class Texture<Config extends ITextureConfig> extends Node2<Config
     userData: any;
     version: number;
     private _needsUpdate;
-    image: OffscreenCanvas | HTMLCanvasElement | undefined;
+    image: ICanvas | undefined;
     offset: Vector2;
     repeat: Vector2;
     center: Vector2;

package/lib/utils/svg.d.ts

@@ -0,0 +1,14 @@
+import { IBox2, IMatrix3, ITree } from '../interfaces';
+import { default as Matrix3 } from '../math/matrix3';
+export declare function getBoxFromString(str?: string, out?: IBox2): IBox2;
+export declare function getBoxString(box?: IBox2): string;
+export declare function getRoot(svg: Element, rn?: string): Element | undefined;
+export declare function removeEmpty(out: Element): Element;
+export declare function traverseSvg(o: Element, cb: Function): void;
+export declare function getElementsMap(el: Element, out?: Record<string, Element>): Record<string, Element>;
+export declare function getLayersTree(el: Element, lv?: number, lvi?: number, out?: ITree[]): ITree[];
+export declare function traverseTree(t: ITree | ITree[], cb: Function): void;
+export declare function getUseSymbolId(el: Element): string | undefined;
+export declare function getAttr<T>(el: Element | null, attr: string, def?: T): T;
+export declare function getMatrix(el: Element, flipY?: boolean, out?: Matrix3): IMatrix3;
+export declare function convertEndpointToCenterParameterization(x1: number, y1: number, x2: number, y2: number, fa: number, fs: number, rx: number, ry: number, psiDeg: number): number[];

package/lib/workers/renderer.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archgine",
-  "version": "1.0.36",
+  "version": "1.0.39",
   "description": "A simple rendering engine developed by archbds.",
   "author": "diozhu@163.com",
   "license": "ISC",

package/lib/geometries/path2.d.ts

@@ -1,20 +0,0 @@
-import { SVGPathData } from 'svg-pathdata';
-import { default as Matrix3 } from '../math/matrix3';
-import { IBox2, IContext2D, IMatrix3, IPath2, IPath2Command } from '../interfaces';
-export interface IPath2Config {
-    commands: string | IPath2Command[];
-}
-export declare class Path2<Config extends IPath2Config> extends SVGPathData implements IPath2 {
-    readonly name: string;
-    version: number;
-    viewMatrix: Matrix3;
-    boundingBox: IBox2;
-    constructor(config?: Config);
-    static getInstanceByPath(o: Element): Path2<any> | undefined;
-    computeBoundingBox(): IBox2;
-    render(ctx: IContext2D): void;
-    applyMatrix(m: IMatrix3): IPath2;
-    copy(source: IPath2): IPath2;
-    clone(): IPath2;
-    static render(ctx: IContext2D, commands: IPath2Command[]): void;
-}