@antv/g-plugin-webgl-renderer

--- package/package.json (excerpt) ---
{
  "name": "@antv/g-plugin-webgl-renderer",
  "version": "1.0.26",
  "description": "A G plugin of renderer implementation with WebGL1",
  "main": "dist/index.js",
  "module": "dist/index.esm.js",
  "types": "dist/index.d.ts",
  "unpkg": "dist/index.umd.min.js",
  "files": [
    "package.json",
    "dist",
    "LICENSE",
    "README.md"
  ],
  "repository": {
    "type": "git",
    "url": "git+https://github.com/antvis/g.git"
  },
  "keywords": [
    "util",
    "antv",
    "g"
  ],
  "publishConfig": {
    "access": "public"
  },
  "author": "https://github.com/orgs/antvis/people",
  "license": "MIT",
  "bugs": {
    "url": "https://github.com/antvis/g/issues"
  },
  "dependencies": {
    "@antv/g-shader-components": "^1.0.18",
    "@mapbox/tiny-sdf": "^2.0.4",
    "@types/offscreencanvas": "^2019.6.4",
    "@webgpu/types": "^0.1.6",
    "earcut": "^2.2.3",
    "eventemitter3": "^4.0.0",
    "regenerator-runtime": "^0.13.9",
    "tslib": "^2.3.1"
  },
  "devDependencies": {
    "@rollup/plugin-wasm": "^5.1.2",
    "@types/earcut": "^2.1.1",
    "@types/jest": "^25.0.0",
    "glslify-import": "3.1.0",
    "rollup-plugin-glslify": "^1.2.1"
  },
  "peerDependencies": {
    "@antv/g": "^5.0.1",
    "mana-syringe": "^0.3.0"
  },
  "browser": {
    "fs": false,
    "path": false
  },
  "glslify": {
    "transform": [
      "glslify-import"
    ]
  },
  "homepage": "https://github.com/antvis/g#readme",
  "gitHead": "e2325a6285d12ef05abd9f9e12cf095280006167"
}


--- bundled output (OSV-MAL flagged — LLM scope expansion) ---

--- dist/LightPool.d.ts (bundled) ---
import type { Light, Fog } from './lights';
export declare class LightPool {
    /**
     * lights
     */
    private lights;
    /**
     * support only 1 fog
     */
    private fog;
    addLight(light: Light): void;
    removeLight(light: Light): void;
    addFog(fog: Fog): void;
    removeFog(fog: Fog): void;
    getFog(): Fog;
    getAllLights(): Light[];
    /**
     * USE_LIGHT
     * NUM_AMBIENT_LIGHTS
     * NUM_DIR_LIGHTS
     */
    getDefines(): Record<string, number | boolean>;
    private sortLights;
}
//# sourceMappingURL=LightPool.d.ts.map

--- dist/Mesh.d.ts (bundled) ---
import { DisplayObject } from '@antv/g';
import type { ParsedBaseStyleProps, BaseStyleProps, DisplayObjectConfig } from '@antv/g';
import type { BufferGeometry } from './geometries';
import type { Material } from './materials';
export interface MeshStyleProps extends BaseStyleProps {
    geometry: BufferGeometry;
    material: Material;
}
export interface ParsedMeshStyleProps extends ParsedBaseStyleProps {
    geometry: BufferGeometry;
    material: Material;
}
export declare class Mesh<GeometryProps = any> extends DisplayObject<GeometryProps & MeshStyleProps> {
    static tag: string;
    constructor({ style, ...rest }: DisplayObjectConfig<GeometryProps & MeshStyleProps>);
    destroy(): void;
}
//# sourceMappingURL=Mesh.d.ts.map

--- dist/MeshUpdater.d.ts (bundled) ---
import { GeometryAABBUpdater } from '@antv/g';
import type { ParsedMeshStyleProps } from './Mesh';
export declare class MeshUpdater implements GeometryAABBUpdater<ParsedMeshStyleProps> {
    update(parsedStyle: ParsedMeshStyleProps): {
        width: number;
        height: number;
        depth: number;
        x: number;
        y: number;
        z: number;
    };
}
//# sourceMappingURL=MeshUpdater.d.ts.map

--- dist/PickingIdGenerator.d.ts (bundled) ---
import type { DisplayObject } from '@antv/g';
export declare class PickingIdGenerator {
    private counter;
    private id2DisplayObjectMap;
    getId(displayObject: DisplayObject): number;
    getById(id: number): DisplayObject;
    reset(): void;
    decodePickingColor(color: Uint8Array): number;
    encodePickingColor(featureIdx: number): [number, number, number];
}
//# sourceMappingURL=PickingIdGenerator.d.ts.map

--- dist/PickingPlugin.d.ts (bundled) ---
import type { RenderingService, RenderingPlugin } from '@antv/g';
import { SceneGraphService } from '@antv/g';
/**
 * Use color-based picking in GPU
 */
export declare class PickingPlugin implements RenderingPlugin {
    static tag: string;
    private canvasConfig;
    protected sceneGraphService: SceneGraphService;
    private contextService;
    private renderingContext;
    private renderHelper;
    private renderGraphPlugin;
    private pickingIdGenerator;
    private camera;
    private batchManager;
    /**
     * used for reading pixels when picking
     */
    apply(renderingService: RenderingService): void;
    private pickByRectangleInDepth;
    private restorePickingColor;
    /**
     * return displayobjects in target rectangle
     */
    private pickByRectangle;
}
//# sourceMappingURL=PickingPlugin.d.ts.map

--- dist/RenderGraphPlugin.d.ts (bundled) ---
import type { RenderingService, RenderingPlugin } from '@antv/g';
import type { Device, SwapChain, Texture, TextureDescriptor } from './platform';
import { RenderInstList } from './render/RenderInstList';
export declare const SceneUniformBufferIndex = 0;
export declare enum SceneUniform {
    PROJECTION_MATRIX = "u_ProjectionMatrix",
    VIEW_MATRIX = "u_ViewMatrix",
    CAMERA_POSITION = "u_CameraPosition",
    DEVICE_PIXEL_RATIO = "u_DevicePixelRatio",
    VIEWPORT = "u_Viewport",
    IS_ORTHO = "u_IsOrtho",
    IS_PICKING = "u_IsPicking"
}
export declare class RenderGraphPlugin implements RenderingPlugin {
    static tag: string;
    private canvasConfig;
    private contextService;
    private renderingContext;
    private camera;
    private pluginOptions;
    private renderHelper;
    private lightPool;
    private texturePool;
    private batchManager;
    private renderingService;
    private device;
    private swapChain;
    private renderLists;
    /**
     * Render Graph builder at each frame
     */
    private builder;
    getDevice(): Device;
    getSwapChain(): SwapChain;
    getRenderLists(): {
        /**
         * used in main forward rendering pass
         */
        world: RenderInstList;
        /**
         * used in picking pass, should disable blending
         */
        picking: RenderInstList;
    };
    apply(renderingService: RenderingService): void;
    /**
     * auto downgrade from WebGPU to WebGL2 & 1
     */
    private createSwapChain;
    private createSwapChainForWebGL;
    private createSwapChainForWebGPU;
    private handleContextEvents;
    /**
     * load texture in an async way and render when loaded
     */
    loadTexture(src: string | TexImageSource, descriptor?: TextureDescriptor, successCallback?: (t: Texture) => void): Texture;
}
//# sourceMappingURL=RenderGraphPlugin.d.ts.map

--- dist/TexturePool.d.ts (bundled) ---
/// <reference types="offscreencanvas" />
/// <reference types="@webgpu/types" />
import type { LinearGradient, RadialGradient } from '@antv/g';
import { GradientPatternType } from '@antv/g';
import type { Device, Texture, TextureDescriptor } from './platform';
export declare type GradientParams = (LinearGradient | RadialGradient) & {
    width: number;
    height: number;
    type: GradientPatternType;
};
export declare class TexturePool {
    private offscreenCanvas;
    private renderingService;
    private canvasConfig;
    private textureCache;
    private gradientCache;
    getOrCreateTexture(device: Device, src: string | TexImageSource, descriptor?: TextureDescriptor, successCallback?: (t: Texture) => void): Texture;
    getOrCreateCanvas(): HTMLCanvasElement | OffscreenCanvas;
    getOrCreateGradient(params: GradientParams): void;
    private generateCacheKey;
    destroy(): void;
}
//# sourceMappingURL=TexturePool.d.ts.map

--- dist/index.d.ts (bundled) ---
import 'regenerator-runtime/runtime';
import type { RendererPlugin } from '@antv/g';
import type { Syringe } from 'mana-syringe';
import { Renderable3D } from './components/Renderable3D';
import { RenderGraphPlugin } from './RenderGraphPlugin';
import { WebGLRendererPluginOptions } from './interfaces';
import { Batch } from './renderer';
import { TexturePool } from './TexturePool';
import { Mesh } from './Mesh';
import type { Texture, TextureDescriptor } from './platform';
export { Renderable3D, Batch, TexturePool, RenderGraphPlugin, Mesh };
export * from './interfaces';
export * from './platform';
export * from './render';
export * from './geometries';
export * from './materials';
export * from './meshes';
export * from './lights';
export declare const containerModule: import("mana-syringe").SyringeModule;
export declare class Plugin implements RendererPlugin {
    private options?;
    constructor(options?: Partial<WebGLRendererPluginOptions>);
    private container;
    init(container: Syringe.Container): void;
    destroy(container: Syringe.Container): void;
    getDevice(): import("./platform").Device;
    loadTexture(src: string | TexImageSource, descriptor?: TextureDescriptor, successCallback?: (t: Texture) => void): Texture;
}
//# sourceMappingURL=index.d.ts.map

--- dist/index.esm.js (bundled) ---
import 'regenerator-runtime/runtime';
import { singleton, inject, Syringe, injectable, Module, GlobalContainer } from 'mana-syringe';
import { __decorate, __metadata, __spreadArray, __read } from 'tslib';
import { isNil, clamp, OffscreenCanvasCreator, RenderingService, CanvasConfig, isBrowser, GradientPatternType, DefaultCamera, Camera, AABB, MutationEvent, ElementEvent, CSSRGB, par