@lightningjs/renderer 3.0.0-beta1 → 3.0.0-beta10

package/dist/src/core/renderers/webgl/WebGlCoreRenderer.d.ts

@@ -1,133 +0,0 @@
-import { CoreRenderer, type BufferInfo, type CoreRendererOptions, type QuadOptions } from '../CoreRenderer.js';
-import { WebGlCoreRenderOp } from './WebGlCoreRenderOp.js';
-import type { CoreContextTexture } from '../CoreContextTexture.js';
-import { type CoreWebGlParameters, type CoreWebGlExtensions, type WebGlColor } from './internal/RendererUtils.js';
-import { Texture } from '../../textures/Texture.js';
-import { CoreShaderManager } from '../../CoreShaderManager.js';
-import { BufferCollection } from './internal/BufferCollection.js';
-import { WebGlCoreShader } from './WebGlCoreShader.js';
-import { WebGlContextWrapper } from '../../lib/WebGlContextWrapper.js';
-import { type CoreNode } from '../../CoreNode.js';
-import type { BaseShaderController } from '../../../main-api/ShaderController.js';
-export type WebGlCoreRendererOptions = CoreRendererOptions;
-interface CoreWebGlSystem {
-    parameters: CoreWebGlParameters;
-    extensions: CoreWebGlExtensions;
-}
-export declare class WebGlCoreRenderer extends CoreRenderer {
-    glw: WebGlContextWrapper;
-    system: CoreWebGlSystem;
-    quadBuffer: ArrayBuffer;
-    fQuadBuffer: Float32Array;
-    uiQuadBuffer: Uint32Array;
-    renderOps: WebGlCoreRenderOp[];
-    curBufferIdx: number;
-    curRenderOp: WebGlCoreRenderOp | null;
-    rttNodes: CoreNode[];
-    activeRttNode: CoreNode | null;
-    defShaderCtrl: BaseShaderController;
-    defaultShader: WebGlCoreShader;
-    quadBufferCollection: BufferCollection;
-    clearColor: WebGlColor;
-    /**
-     * White pixel texture used by default when no texture is specified.
-     */
-    quadBufferUsage: number;
-    numQuadsRendered: number;
-    /**
-     * Whether the renderer is currently rendering to a texture.
-     */
-    renderToTextureActive: boolean;
-    constructor(options: WebGlCoreRendererOptions);
-    reset(): void;
-    getShaderManager(): CoreShaderManager;
-    createCtxTexture(textureSource: Texture): CoreContextTexture;
-    /**
-     * This function adds a quad (a rectangle composed of two triangles) to the WebGL rendering pipeline.
-     *
-     * It takes a set of options that define the quad's properties, such as its dimensions, colors, texture, shader, and transformation matrix.
-     * The function first updates the shader properties with the current dimensions if necessary, then sets the default texture if none is provided.
-     * It then checks if a new render operation is needed, based on the current shader and clipping rectangle.
-     * If a new render operation is needed, it creates one and updates the current render operation.
-     * The function then adjusts the texture coordinates based on the texture options and adds the texture to the texture manager.
-     *
-     * Finally, it calculates the vertices for the quad, taking into account any transformations, and adds them to the quad buffer.
-     * The function updates the length and number of quads in the current render operation, and updates the current buffer index.
-     */
-    addQuad(params: QuadOptions): void;
-    /**
-     * Replace the existing RenderOp with a new one that uses the specified Shader
-     * and starts at the specified buffer index.
-     *
-     * @param shader
-     * @param bufferIdx
-     */
-    private newRenderOp;
-    /**
-     * Add a texture to the current RenderOp. If the texture cannot be added to the
-     * current RenderOp, a new RenderOp will be created and the texture will be added
-     * to that one.
-     *
-     * If the texture cannot be added to the new RenderOp, an error will be thrown.
-     *
-     * @param texture
-     * @param bufferIdx
-     * @param recursive
-     * @returns Assigned Texture Index of the texture in the render op
-     */
-    private addTexture;
-    /**
-     * Test if the current Render operation can be reused for the specified parameters.
-     * @param params
-     * @returns
-     */
-    reuseRenderOp(params: QuadOptions): boolean;
-    /**
-     * add RenderOp to the render pipeline
-     */
-    addRenderOp(renderable: WebGlCoreRenderOp): void;
-    /**
-     * Render the current set of RenderOps to render to the specified surface.
-     *
-     * TODO: 'screen' is the only supported surface at the moment.
-     *
-     * @param surface
-     */
-    render(surface?: 'screen' | CoreContextTexture): void;
-    getQuadCount(): number;
-    renderToTexture(node: CoreNode): void;
-    /**
-     * Inserts an RTT node into `this.rttNodes` while maintaining the correct rendering order based on hierarchy.
-     *
-     * Rendering order for RTT nodes is critical when nested RTT nodes exist in a parent-child relationship.
-     * Specifically:
-     *  - Child RTT nodes must be rendered before their RTT-enabled parents to ensure proper texture composition.
-     *  - If an RTT node is added and it has existing RTT children, it should be rendered after those children.
-     *
-     * This function addresses both cases by:
-     * 1. **Checking Upwards**: It traverses the node's hierarchy upwards to identify any RTT parent
-     *    already in `rttNodes`. If an RTT parent is found, the new node is placed before this parent.
-     * 2. **Checking Downwards**: It traverses the node’s children recursively to find any RTT-enabled
-     *    children that are already in `rttNodes`. If such children are found, the new node is inserted
-     *    after the last (highest index) RTT child node.
-     *
-     * The final calculated insertion index ensures the new node is positioned in `rttNodes` to respect
-     * both parent-before-child and child-before-parent rendering rules, preserving the correct order
-     * for the WebGL renderer.
-     *
-     * @param node - The RTT-enabled CoreNode to be added to `rttNodes` in the appropriate hierarchical position.
-     */
-    private insertRTTNodeInOrder;
-    private findMaxChildRTTIndex;
-    renderRTTNodes(): void;
-    removeRTTNode(node: CoreNode): void;
-    getBufferInfo(): BufferInfo | null;
-    getDefShaderCtr(): BaseShaderController;
-    /**
-     * Updates the WebGL context's clear color and clears the color buffer.
-     *
-     * @param color - The color to set as the clear color, represented as a 32-bit integer.
-     */
-    updateClearColor(color: number): void;
-}
-export {};