@itwin/core-frontend/lib/esm/internal/render/webgl/RenderState.d.ts

iTwin.js frontend components

/** @packageDocumentation
 * @module WebGL
 */
import { GL } from "./GL";
/** @internal */
export declare class RenderStateFlags {
    cull: boolean;
    depthTest: boolean;
    blend: boolean;
    stencilTest: boolean;
    depthMask: boolean;
    colorWrite: boolean;
    constructor(src?: RenderStateFlags);
    copyFrom(src: RenderStateFlags): void;
    clone(result?: RenderStateFlags): RenderStateFlags;
    equals(rhs: RenderStateFlags): boolean;
    apply(previousFlags: RenderStateFlags): void;
    static enableOrDisable(currentFlag: boolean, value: number, previousFlag: boolean): void;
}
/** @internal */
export declare class RenderStateBlend {
    color: [number, number, number, number];
    equationRgb: GL.BlendEquation;
    equationAlpha: GL.BlendEquation;
    functionSourceRgb: GL.BlendFactor;
    functionSourceAlpha: GL.BlendFactor;
    functionDestRgb: GL.BlendFactor;
    functionDestAlpha: GL.BlendFactor;
    constructor(src?: RenderStateBlend);
    apply(previousBlend?: RenderStateBlend): void;
    copyFrom(src: RenderStateBlend): void;
    clone(result?: RenderStateBlend): RenderStateBlend;
    equals(rhs: RenderStateBlend): boolean;
    equalColors(rhs: RenderStateBlend): boolean;
    setColor(color: [number, number, number, number]): void;
    setBlendFunc(src: GL.BlendFactor, dst: GL.BlendFactor): void;
    setBlendFuncSeparate(srcRgb: GL.BlendFactor, srcAlpha: GL.BlendFactor, dstRgb: GL.BlendFactor, dstAlpha: GL.BlendFactor): void;
}
/** @internal */
export declare class RenderStateStencilOperation {
    fail: GL.StencilOperation;
    zFail: GL.StencilOperation;
    zPass: GL.StencilOperation;
    constructor(src?: RenderStateStencilOperation);
    copyFrom(src: RenderStateStencilOperation): void;
    clone(result?: RenderStateStencilOperation): RenderStateStencilOperation;
    equals(rhs: RenderStateStencilOperation): boolean;
}
/** @internal */
export declare class RenderStateStencilFunction {
    function: GL.StencilFunction;
    ref: number;
    mask: number;
    constructor(src?: RenderStateStencilFunction);
    copyFrom(src: RenderStateStencilFunction): void;
    clone(result?: RenderStateStencilFunction): RenderStateStencilFunction;
    equals(rhs: RenderStateStencilFunction): boolean;
}
/** @internal */
export declare class RenderStateStencil {
    frontFunction: RenderStateStencilFunction;
    backFunction: RenderStateStencilFunction;
    frontOperation: RenderStateStencilOperation;
    backOperation: RenderStateStencilOperation;
    constructor(src?: RenderStateStencil);
    apply(previousStencil?: RenderStateStencil): void;
    copyFrom(src: RenderStateStencil): void;
    clone(result?: RenderStateStencil): RenderStateStencil;
    equals(rhs: RenderStateStencil): boolean;
}
/** Encapsulates the state of an OpenGL context.
 * to modify the context for a rendering operation, do *not* directly call
 * functions like glDepthMask(), glBlendFunc(), etc - otherwise such calls may adversely
 * affect subsequent rendering operations.
 * Instead, set up a RenderState as desired and invoke System.instance.applyRenderState()
 * The context tracks the most-recently applied RenderState, allowing it to minimize
 * the number of GL state changes actually invoked, improving performance.
 * @internal
 */
export declare class RenderState {
    flags: RenderStateFlags;
    blend: RenderStateBlend;
    stencil: RenderStateStencil;
    frontFace: GL.FrontFace;
    cullFace: GL.CullFace;
    depthFunc: GL.DepthFunc;
    stencilMask: number;
    constructor(src?: RenderState);
    static defaults: RenderState;
    copyFrom(src: RenderState): void;
    clone(result?: RenderState): RenderState;
    set clockwiseFrontFace(clockwise: boolean);
    equals(rhs: RenderState): boolean;
    apply(prevState: RenderState): void;
}
//# sourceMappingURL=RenderState.d.ts.map