interface ElementsWithGPUResource { freeGPU(): void; } declare class BaseElement { /** * @internal */ $weak: any; /** * @internal */ __DO_NOT_USE_THIS_URC: any; private isFreed; private __guid; private _businessTag; /** * @internal */ metaData: Record; readonly userData: Record; markBusinessTag(v: string): this; set businessTag(v: string); get businessTag(): string; constructor(); isDestroyed(): boolean; destroy(): void; validate(): void; destroyAllResourcesOwned(): void; freeAllGpuResourceOwned(): void; } declare class EventType { description: string; payload?: Payload; symbol: symbol; constructor(description?: string); } interface Listener { (payload: Payload): void; } /** * JavaScript events for custom objects. */ declare class EventDispatcher { _uuid: string | null; get uuid(): string; set uuid(uuid: string); _listeners: Map; /** * Adds a listener to an event type. * @param type The type of event to listen to. * @param listener The function that gets called when the event is fired. */ on(type: EventType, listener: Listener): void; /** * Only active the listener one times and then off {@link it| it}. */ once(type: EventType, listener: Listener): void; /** * Checks if listener is added to an event type. */ has(type: EventType, listener: Listener): boolean; /** * Removes a listener from listening list. */ off(type: EventType, listener: Listener): void; /** * Active the event and call the registered listener. */ emit(type: EventType): void; emit(type: EventType, payload: T): void; /** * Removes all listeners from listening list. */ clearAllListeners(): void; } declare abstract class ElementEventDispatcher extends BaseElement implements EventDispatcher { _uuid: any; uuid: string; _listeners: Map; on(_type: EventType, _listener: Listener): void; once(_type: EventType, _listener: Listener): void; has(_type: EventType, _listener: Listener): boolean; off(_type: EventType, _listener: Listener): void; emit(type: EventType): void; emit(type: EventType, payload: T): void; clearAllListeners(): void; } /** * All supported type of data in shader. */ declare enum WebGLShaderDataType { Bool = 35670, BoolVec2 = 35671, BoolVec3 = 35672, BoolVec4 = 35673, Int = 5124, IntVec2 = 35667, IntVec3 = 35668, IntVec4 = 35669, UInt = 5125, UIntVec2 = 36294, UIntVec3 = 36295, UIntVec4 = 36296, Float = 5126, Vec2 = 35664, Vec3 = 35665, Vec4 = 35666, Mat2 = 35674, Mat3 = 35675, Mat4 = 35676, Sampler2D = 35678, Sampler2DArray = 36289, Sampler3D = 35679, SamplerCube = 35680, USampler2D = 36306, USampler2DArray = 36311, USampler3D = 36307, FloatV = 9999999, IntV = 9999998, UintV = 9999997, ArraySampler2D = 9999996, ArraySamplerCube = 9999995 } /** * Supported type of texture by webGL. */ declare enum WebGLTextureType { Texture2D = 3553, TextureCubeMap = 34067 } /** * The cullFace method of the WebGL API specifies whether or not front- and/or back-facing polygons can be culled. */ declare enum WebGLCullFace { None = 1000000, Back = 1028, Front = 1029, FrontBack = 1032 } /** * Decide the color format in each pixel. */ declare enum WebGLPixelFormat { Red = 6403, RG = 33319, /** * @deprecated 3 channel texture support dropped. */ RGB = 6407, RGBA = 6408, RedInteger = 36244, RGInteger = 33320, RGBInteger = 36248, RGBAInteger = 36249, Alpha = 6406, Luminance = 6409, LuminanceAlpha = 6410, Depth = 6402, DepthStencil = 34041 } /** * Implementation of a {@link http://en.wikipedia.org/wiki/Quaternion| quaternion}. * Quaternions are used to represent {@link https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation| rotations}. */ declare class Quaternion { private _x; private _y; private _z; private _w; /** * Check the type whether it belongs to Matrix3. * This value should not be changed by user. */ isQuaternion: boolean; constructor(x?: number, y?: number, z?: number, w?: number); /** * The function will be called when {@link _x| x}, {@link _y| y} {@link _z| z} and {@link _w| w} is changed. */ onChangeCallback(): void; get x(): number; set x(value: number); get y(): number; set y(value: number); get z(): number; set z(value: number); get w(): number; set w(value: number); /** * Handles the spherical linear interpolation between quaternions. * t represents the amount of rotation between this quaternion (where t is 0) and qb (where t is 1). * This quaternion is set to the result. Also see the static version of the `slerp` below. *

     * // rotate a mesh towards a target quaternion
     * mesh.quaternion.slerp( endQuaternion, 0.01 );
     *

* @param qb The other quaternion rotation. * @param t interpolation factor in the closed interval [0, 1]. */ static slerp(qa: Quaternion, qb: Quaternion, qm: Quaternion, t: number): Quaternion; /** * Like the static {@link slerp| slerp} method above, but operates directly on flat arrays of numbers. * @param dst The output array. * @param dstOffset An offset into the output array. * @param src0 The source array of the starting quaternion. * @param srcOffset0 An offset into the array `src0`. * @param src1 The source array of the target quaternions. * @param srcOffset1 An offset into the array `src1`. * @param t Normalized interpolation factor (between 0 and 1). */ static slerpFlat(dst: number[], dstOffset: number, src0: number[], srcOffset0: number, src1: number[], srcOffset1: number, t: number): void; /** * Sets {@link x| x}, {@link y| y}, {@link z| z}, {@link w| w} properties of this quaternion. */ set(x: number, y: number, z: number, w: number): Quaternion; /** * Creates a new Quaternion with identical {@link x| x}, {@link y| y},{@link z| z} and {@link w| w} properties to this one. */ clone(): Quaternion; /** * Copies the {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} properties of {@link Quaternion| q} into this quaternion. */ copy(quaternion: Quaternion): Quaternion; /** * Sets this quaternion from the rotation specified by {@link Euler| Euler} angle. */ setFromEuler(euler: Euler, update?: boolean): Quaternion; /** * Sets this quaternion from rotation specified by {@link Vector3| axis} and {@link Float| angle}. * Adapted from the method {@link http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm| here}. * @param Axis is assumed to be normalized. * @param angle is in radians. */ setFromAxisAngle(axis: Vector3, angle: number): Quaternion; /** * Sets this quaternion from rotation component of {@link Matrix4| m}. * Adapted from the method {@link http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm| here}. * @param m a {@link Matrix4| Matrix4} of which the upper 3x3 of matrix is a pure {@link https://en.wikipedia.org/wiki/Rotation_matrix| rotation matrix}. */ setFromRotationMatrix(m: Matrix4): Quaternion; /** * Sets this quaternion to the rotation required to rotate direction vector {@link Vector3| vFrom} to direction vector {@link Vector3| vTo}. * Adapted from the method {@link http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors| here}. * {@link Vector3| vFrom} and {@link Vector3| vTo} are assumed to be normalized. */ setFromUnitVectors(vFrom: Vector3, vTo: Vector3): Quaternion; /** * @ignore */ inverse(): Quaternion; /** * Returns the rotational conjugate of this quaternion. The conjugate of a quaternion * represents the same rotation in the opposite direction about the rotational axis. */ conjugate(): Quaternion; /** * Calculates the {@link https://en.wikipedia.org/wiki/Dot_product| dot product} of quaternions {@link Quaternion| v} and this one. */ dot(v: Quaternion): number; /** * Computes the squared {@link https://en.wikipedia.org/wiki/Euclidean_distance| Euclidean length} * (straight-line length) of this quaternion, considered as a 4 dimensional vector. * This can be useful if you are comparing the lengths of two quaternions, * as this is a slightly more efficient calculation than {@link length| length}(). */ lengthSq(): number; /** * Computes the Euclidean length (straight-line length) of this quaternion, considered as a 4 dimensional vector. */ length(): number; /** * Normalizes this quaternion - that is, calculated the quaternion that performs the same rotation as this one, * but has {@link length| length} equal to `1`. */ normalize(): Quaternion; /** * Multiplies this quaternion by {@link Quaternion| q}. */ multiply(q: Quaternion): Quaternion; /** * Pre-multiplies this quaternion by {@link Quaternion| q}. */ premultiply(q: Quaternion): Quaternion; /** * Sets this quaternion to {@link Quaternion| a} x {@link Quaternion| b}. * Adapted from the method outlined {@link http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm| here}. */ multiplyQuaternions(a: Quaternion, b: Quaternion): Quaternion; /** * Handles the spherical linear interpolation between quaternions. t represents the * amount of rotation between this quaternion (where t is 0) and {@link Quaternion| qb} (where t is 1). * This quaternion is set to the result. * Also see the static version of the method {@link slerp| slerp}. *

     * // rotate a mesh towards a target quaternion
     * mesh.quaternion.slerp( endQuaternion, 0.01 );
     *

* @param qb The other quaternion rotation. * @param t interpolation factor in the closed interval [0, 1]. */ slerp(qb: Quaternion, t: number): Quaternion; /** * Compares the {@link x| x}, {@link y| y},{@link z| z} and {@link w| w} properties of * {@link Quaternion| v} to the equivalent properties of this quaternion to determine if they represent the same rotation. * @param v Quaternion that this quaternion will be compared to. */ equals(quaternion: Quaternion): boolean; /** * Sets this quaternion's {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} properties from an array. * @param array array of format (x, y, z, w) used to construct the quaternion. * @param offset (optional) an offset into the array. */ fromArray(array: ArrayLike, offset?: number): Quaternion; /** * Returns the numerical elements of this quaternion in an array of format [x, y, z, w]. * @param array An optional array to store the quaternion. If not specified, a new array will be created. * @param offset (optional) if specified, the result will be copied into this array. */ toArray(array?: number[], offset?: number): number[]; /** * A method to call {@link onChangeCallback| onChangeCallback}. */ onChange(callback: Function): Quaternion; } declare class Euler { /** * The angle of the x axis in radians. */ _x: number; /** * The angle of the y axis in radians. */ _y: number; /** * The angle of the z axis in radians. */ _z: number; /** * A string representing the order that the rotations are applied. */ _order: string; /** * Check the type whether it belongs to Euler. * This value should not be changed by user. */ isEuler: boolean; /** * The function will be called when {@link _x| x}, {@link _y| y} {@link _z| z} and {@link _order| order} is changed. */ onChangeCallback: Function; /** * All possible value for {@link _order| order}. */ static RotationOrders: string[]; /** * The default of {@link _order| order}. */ static DefaultOrder: string; constructor(x?: number, y?: number, z?: number, order?: string); get x(): number; set x(value: number); get y(): number; set y(value: number); get z(): number; set z(value: number); get order(): string; set order(value: string); /** * Sets the angles of this euler transform and optionally the {@link order| order}. */ set(x: number, y: number, z: number, order?: string): Euler; /** * Returns a new Euler with the same parameters as this one. */ clone(): Euler; /** * Copies value of {@link Euler| euler} to this euler. */ copy(euler: Euler): Euler; /** * Sets the angles of this euler transform from a pure rotation matrix based on the orientation specified by order. * @param m a {@link Matrix4| Matrix4} of which the upper 3x3 of matrix is a pure * {@link https://en.wikipedia.org/wiki/Rotation_matrix| rotation matrix} (i.e. unscaled). * @param order (optional) a string representing the order that the rotations are applied. */ setFromRotationMatrix(m: Matrix4, order?: string, update?: boolean): Euler; /** * Sets the angles of this euler transform from a normalized quaternion based on the orientation specified by {@link order| order}. * @param q a normalized quaternion. * @param order (optional) a string representing the order that the rotations are applied. */ setFromQuaternion(q: Quaternion, order?: string, update?: boolean): Euler; /** * Set the {@link x| x}, {@link y| y} and {@link z| z} from vector, and optionally update the {@link order| order}. * @param vector {@link Vector3| Vector3}. * @param order (optional) a string representing the order that the rotations are applied. */ setFromVector3(v: Vector3, order?: string): Euler; /** * Resets the euler angle with a new order by creating a quaternion from this euler angle * and then setting this euler angle with the quaternion and the new order. * @WARNING this discards revolution information. */ reorder(newOrder: string): Euler; /** * Checks for strict equality of this euler and {@link Euler| euler}. */ equals(euler: Euler): boolean; /** * Array of length 3 or 4. The optional 4th argument corresponds from the {@link order| order}. * Assigns this euler's {@link x| x} angle from array[0]. * Assigns this euler's {@link y| y} angle from array[1]. * Assigns this euler's {@link z| z} angle from array[2]. * Optionally assigns this euler's {@link order| order} from array[3]. */ fromArray(array: ArrayLike): Euler; /** * Returns an array of the form [{@link x| x}, {@link y| y}, {@link z| z}, {@link order| order}]. * @param array (optional) array to store the euler in. * @param offset (optional) offset in the array. */ toArray(array?: number[], offset?: number): number[]; /** * @param optionalResult (optional) If specified, the result will be copied into this Vector, otherwise a new one will be created. * Returns the Euler's {@link x| x}, {@link y| y} and {@link z| z} properties as a {@link Vector3| Vector3}. */ toVector3(optionalResult?: Vector3): Vector3; /** * A method to call {@link onChangeCallback| onChangeCallback}. */ onChange(callback: Function): void; } interface HSL { h: number; s: number; l: number; } /** * Class representing a color. */ declare class Color { /** * Red channel value between 0 and 1. * @defaultValue `1`. */ r: number; /** * Green channel value between 0 and 1. * @defaultValue `1`. */ g: number; /** * Blue channel value between 0 and 1. * @defaultValue `1`. */ b: number; /** * Check the type whether it belongs to Color. * This value should not be changed by user. */ isColor: boolean; get x(): number; get y(): number; get z(): number; constructor(color_or_r?: string | Color | number, g?: number, b?: number); /** * Sets this color from RGB values. * @param r Red channel value between 0.0 and 1.0. * @param g Green channel value between 0.0 and 1.0. * @param b Blue channel value between 0.0 and 1.0. */ setRGB(r: number, g: number, b: number): Color; /** * Copies the {@link r| r}, {@link g| g} and {@link b| b} parameters from {@link Color| color} in to this color. */ copy(color: Color): Color; /** * Sets this color from a hexadecimal value. * @param hex {@link https://en.wikipedia.org/wiki/Web_colors#Hex_triplet| hexadecimal triplet} format. */ setHex(hex: number): Color; private hue2rgb; /** * Sets color from HSL values. * @param h hue value between 0.0 and 1.0. * @param s saturation value between 0.0 and 1.0. * @param l lightness value between 0.0 and 1.0. */ setHSL(h: number, s: number, l: number): Color; /** * Translucent colors such as "rgba(255, 0, 0, 0.5)" and "hsla(0, 100%, 50%, 0.5)" are also accepted, * but the alpha-channel coordinate will be discarded. * @Note that for X11 color names, multiple words such as Dark Orange become the string 'darkorange' (all lowercase). * @param style color as a CSS-style string. * Sets this color from a CSS-style string. For example, * "rgb(250, 0,0)", * "rgb(100%, 0%, 0%)", * "hsl(0, 100%, 50%)", * "#ff0000", * "#f00", or * "red" ( or any {@link https://en.wikipedia.org/wiki/X11_color_names#Color_name_chart| X11 color name} * - all 140 color names are supported ).
*/ setStyle(style: string): Color; /** * See the Constructor above for full details of what {@link Color_Hex_or_String| value} can be. * Delegates to {@link .copy| .copy}, {@link .setStyle| .setStyle}, or {@link setHex| setHex} depending on input type. * @param value Value to set this color to. */ set(value: string | Color | number): Color; /** * Sets all three color components to the value {@link Float| scalar}. * @param scalar a value between 0.0 and 1.0. */ setScalar(scalar: number): Color; /** * Return a new Color with the same {@link r| r}, {@link g| g} and {@link b| b} values as this clone. */ clone(): Color; cloneReadonly(): Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "g" | "r" | "b" | "isColor" | "equals" | "getHex" | "getSerializeData">>; /** * Copies the given color into this color, and then converts this color from gamma space to linear space * by taking {@link r| r}, {@link g| g} and {@link b| b} to the power of {@link Float| gammaFactor}. * @param color Color to copy. * @param gammaFactor (optional). * @defaultValue `2.0`. */ copyGammaToLinear(color: Color, gammaFactor?: number): Color; /** * Copies the given color into this color, and then converts this color from linear space to gamma space * by taking {@link r| r}, {@link g| g} and {@link b| b} to the power of 1 / {@link Float| gammaFactor}. * @param color Color to copy. * @param gammaFactor (optional). * @defaultValue `2.0`. */ copyLinearToGamma(color: Color, gammaFactor?: number): Color; /** * Converts this color from gamma space to linear space by taking {@link .r| r}, {@link .g| g} and {@link .b| b} to the power of {@link Float| gammaFactor}. * @param gammaFactor (optional). * @defaultValue `2.0`. */ convertGammaToLinear(gammaFactor?: number): Color; /** * Converts this color from linear space to gamma space by taking {@link .r| r}, {@link .g| g} and {@link .b| b} to the power of 1 / {@link Float| gammaFactor}. * @param gammaFactor (optional). * @defaultValue `2.0`. */ convertLinearToGamma(gammaFactor?: number): Color; private SRGBToLinear; /** * Copies the given color into this color, and then converts this color from sRGB space to linear space. * @param color Color to copy. */ copySRGBToLinear(color: Color): Color; private LinearToSRGB; /** * Copies the given color into this color, and then converts this color from linear space to sRGB space. * @param color Color to copy. */ copyLinearToSRGB(color: Color): Color; /** * Converts this color from sRGB space to linear space. */ convertSRGBToLinear(): Color; /** * Converts this color from linear space to sRGB space. */ convertLinearToSRGB(): Color; /** * Returns the hexadecimal value of this color. */ getHex(): number; /** * Returns the hexadecimal value of this color as a string (for example, 'FFFFFF'). */ getHexString(): string; /** * Convert this Color's {@link .r| r}, {@link .g| g} and {@link .b| b} values to {@link https://en.wikipedia.org/wiki/HSL_and_HSV| HSL} * format and returns an object of the form: * `{ h: 0, s: 0, l: 0 }` * @param target the result will be copied into this Object. Adds h, s and l keys to the object (if not already present). */ getHSL(target: HSL): HSL; /** * Returns the value of this color as a CSS style string. Example: `rgb(255,0,0)`. */ getStyle(): string; /** * Adds the RGB values of {@link Color| color} to the RGB values of this color. */ add(color: Color): Color; /** * Sets this color's RGB values to the sum of the RGB values of color1 and color2. */ addColors(color1: Color, color2: Color): Color; /** * Adds {@link Number| s} to the RGB values of this color. */ addScalar(s: number): Color; /** * Subtracts the RGB components of the given color from the RGB components of this color. * If this results in a negative component, that component is set to zero. */ sub(color: Color): Color; /** * Multiplies this color's RGB values by the given {@link Color| color}'s RGB values. */ multiply(color: Color): Color; /** * Multiplies this color's RGB values by s. */ multiplyScalar(s: number): Color; /** * Linearly interpolates this color's RGB values toward the RGB values of the passed argument. * The alpha argument can be thought of as the ratio between the two colors, where 0.0 is this color and 1.0 is the first argument. * @param color color to converge on. * @param alpha interpolation factor in the closed interval [0, 1]. */ lerp(color: Color, alpha: number): Color; /** * Compares the RGB values of {@link Color| color} with those of this object. Returns true if they are the same, false otherwise. */ equals(c: Color): boolean; /** * Sets this color's components based on an array formatted like [ r, g, b ]. * @param array Array of floats in the form [ r, g, b ]. * @param offset An optional offset into the array. */ fromArray(array: ArrayLike, offset?: number): Color; /** * r,g,b return 3 */ getNumberCount(): number; /** * Returns an array of the form [ r, g, b ]. * @param array An optional array to store the color to. * @param offset An optional offset into the array. */ toArray(array?: number[], offset?: number): number[]; /** * @ignore */ getSerializeData(): number; /** * @ignore */ setSerializeData(value: number): void; /** * Adds the given h, s, and l to this color's values. * Internally, this converts the color's r, g and b values to HSL, * adds h,s,l, and then converts the color back to RGB. */ offsetHSL(h: number, s: number, l: number): Color; /** * Linearly interpolates this color's HSL values toward the HSL values of the passed argument. * It differs from the classic {@link lerp| lerp} by not interpolating straight from one color to the other, * but instead going through all the hues in between those two colors. * The alpha argument can be thought of as the ratio between the two colors, where 0.0 is this color and 1.0 is the first argument. */ lerpHSL(color: Color, alpha: number): this; /** * Converts a hexadecimal color number to a string. * `Color.hex2string(0xffffff); * -hex - Number in hex (e.g., `0xffffff`) * -return The string color (e.g., `"#ffffff"`).` */ static hex2string(hex: number): string; /** * Converts a hexadecimal color number to an [R, G, B] array of normalized floats (numbers from 0.0 to 1.0). * `Color.hex2rgb(0xffffff); // returns [1, 1, 1] * -hex The hexadecimal number to convert * -out If supplied, this array will be used rather than returning a new one * -return An array representing the [R, G, B] of the color where all values are floats.` */ static hex2rgb(hex: number, out?: number[] | Float32Array): number[] | Float32Array; /** * Converts a color as an [R, G, B] array to a hex number */ static rgb2hex(rgb: number[] | Float32Array): number; /** * Converts a hexadecimal string to a hexadecimal color number. * `Color.string2hex("#ffffff"); // returns 0xffffff * -string - The string color (e.g., `"#ffffff"`) * -return Number in hexadecimal.` */ static string2hex(string: string): number; } declare type ReadonlyColor = PickReadonly; /** * A class representing a 3x3 {@link https://en.wikipedia.org/wiki/Matrix_(mathematics)| matrix}. */ declare class Matrix3 { /** * A {@link https://en.wikipedia.org/wiki/Row-_and_column-major_order | column-major } list of matrix values. * @internal */ _elements: Float32Array; /** * Check the type whether it belongs to Matrix3. * This value should not be changed by user. */ isMatrix3: boolean; /** * If this value is true, then fast matrix operations can be used. * If not, then we presume the matrix to the points needs to do some * 'fake' 3d projection transforms. * @remarks see {@link multiplyMatrixFast | multiplyMatrixFast } for more detail */ is2x3: boolean; private static defaultElements; /** * A {@link https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order| column-major } list of matrix values. */ get elements(): Float32Array; /** * @deprecated use `fromArray` instead; */ set elements(v: Float32Array); constructor(); /** * @ignore */ getSerializeData(): number[]; /** * @ignore */ setSerializeData(value: any): void; /** * Sets the 3x3 matrix values to the given {@link https://en.wikipedia.org/wiki/Row-_and_column-major_order | row-major } sequence of values. * @param n11 value to put in row 1, col 1. * @param n12 value to put in row 1, col 2. * @param n32 value to put in row 3, col 2. * @param n33 value to put in row 3, col 3. */ set(n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number): Matrix3; /** * Resets this matrix to the 3x3 identity matrix: *


     * 1, 0, 0
     * 0, 1, 0
     * 0, 0, 1
     * 
     *      */
    identity(): Matrix3;
    /**
     * Creates a new Matrix3 and with identical elements to this one.
     */
    clone(): Matrix3;
    cloneReadonly(): Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "equals" | "getSerializeData" | "getNumberCount" | "toArray" | "elements" | "applyToBufferAttribute" | "determinant" | "transposeIntoArray" | "applyToArray" | "applyInverse" | "decompose">>;
    /**
     * Copies the elements of matrix {@link Matrix3| m} into this matrix.
     */
    copy(m: Matrix3): Matrix3;
    /**
     * Set this matrix to the upper 3x3 matrix of the Matrix4 {@link Matrix4| m}.
     */
    setFromMatrix4(m: Matrix4): Matrix3;
    /**
     * Apply this matrix to given {@link BufferAttribute| attribute buffer}.
     */
    applyToBufferAttribute(attribute: BufferAttribute, __forceJSImpl?: boolean): BufferAttribute;
    /**
     * Post-multiplies this matrix by {@link Matrix3| m}.
     */
    multiply(m: Matrix3): Matrix3;
    /**
     * Pre-multiplies this matrix by {@link Matrix3| m}.
     */
    premultiply(m: Matrix3): Matrix3;
    /**
     * Sets this matrix to {@link Matrix3| a} x {@link Matrix3| b}.
     */
    multiplyMatrices(a: Matrix3, b: Matrix3): Matrix3;
    addMatrices(a: Matrix3, b: Matrix3): Matrix3;
    /**
     * Multiplies every component of the matrix by the scalar value `s`.
     */
    multiplyScalar(s: number): Matrix3;
    /**
     * Computes and returns the {@link https://en.wikipedia.org/wiki/Determinant| determinant} of this matrix.
     */
    determinant(): number;
    /**
     * Return the inverse matrix of given matrix.
     */
    getInverse(matrix: Matrix3, throwOnDegenerate?: boolean): Matrix3;
    /**
     * Return the transpose matrix of this.
     */
    transpose(): Matrix3;
    /**
     * Sets this matrix as the upper left 3x3 of the {@link https://en.wikipedia.org/wiki/Normal_matrix| normal matrix} of the passed {@link Matrix4| matrix4}.
     * The normal matrix is the {@link https://en.wikipedia.org/wiki/Invertible_matrix| inverse } {@link https://en.wikipedia.org/wiki/Transpose | transpose } of the matrix {@link Matrix4| m}.
     * @param m {@link Matrix4| Matrix4}
     */
    getNormalMatrix(matrix4: Matrix4): Matrix3;
    /**
     * Transpose this matrix into the supplied array, and returns itself unchanged.
     * @param array array to store the resulting vector in.
     */
    transposeIntoArray(r: Matrix3): Matrix3;
    /**
     * Build transform matrix.
     * @param tx A translate add to u.
     * @param tx A translate add to v.
     * @param sx Scale multiply to u.
     * @param sy Scale multiply to v.
     * @param rotation A rotation apply to u and v.
     * @param cx Translate u influenced by same rotation.
     * @param cy Translate v influenced by same rotation.
     */
    setUVTransform(tx: number, ty: number, sx: number, sy: number, rotation: number, cx: number, cy: number): void;
    /**
     * Apply a scale on this matrix.
     * @param sx scale the value of first row.
     * @param sy scale the value of second row.
     */
    scale(sx: number, sy: number): Matrix3;
    /**
     * Apply a rotation on this matrix.
     * @param theta a value in radius.
     */
    rotate(theta: number): Matrix3;
    /**
     * Apply a translation to this matrix.
     * @param tx translate first row by tx.
     * @param ty translate second row by ty.
     */
    translate(tx: number, ty: number): Matrix3;
    /**
     * Return true if this matrix and {@link Matrix3| m} are equal.
     */
    equals(matrix: Matrix3): boolean;
    /**
     * Apply this matrix on vector pos, and store the result in newPos (if it is given) or as return.
     */
    apply(pos: Vector2, newPos?: Vector2): Vector2;
    /**
     * Apply this matrix on given array.
     * Each vector item of array should hold three elements.
     */
    applyToArray(array: Float32Array): Float32Array;
    /**
     * Apply this matrix's inverse on vector pos, and store the result in newPos (if it is given) or as return.
     */
    applyInverse(pos: Vector2, newPos?: Vector2): Vector2;
    /**
     * Sets the elements of this matrix based on an array in column-major format.
     * @param array the array to read the elements from.
     * @param offset (optional) index of first element in the array.
     * @defaultValue `0`.
     */
    fromArray(array: ArrayLike, offset?: number): Matrix3;
    /**
     * There are 9 elements in this matrix.
     */
    getNumberCount(): number;
    /**
     * Writes the elements of this matrix to an array in column-major format.
     * @param array (optional) array to store the resulting vector in. If not given a new array will be created.
     * @param offset (optional) offset in the array at which to put the result.
     */
    toArray(array?: number[], offset?: number): number[];
    toStd140Array(array?: number[], offset?: number): number[];
    /**
     * Sets the matrix based on all the available properties.
     * @param x Position on the x axis.
     * @param y Position on the y axis.
     * @param pivotX Pivot on the x axis.
     * @param pivotY Pivot on the y axis.
     * @param scaleX Scale on the x axis.
     * @param scaleY Scale on the y axis.
     * @param rotation Rotation in radians.
     * @param skewX Skew on the x axis.
     * @param skewY Skew on the y axis.
     * @return This matrix. Good for chaining method calls.
     */
    compose(x: number, y: number, pivotX: number, pivotY: number, scaleX: number, scaleY: number, rotation: number, skewX: number, skewY: number): this;
    /**
     * Decomposes the matrix (x, y, scaleX, scaleY, and rotation) and sets the properties on to a transform.
     * @return The transform with the newly applied properties.
     */
    decompose(): {
        x: number;
        y: number;
        scaleX: number;
        scaleY: number;
        rotation: number;
        skewX: number;
        skewY: number;
    };
    /**
     * Return an orthogonal projection matrix which is set by parameter.
     * @remarks See {@link OrthographicCamera | OrthographicCamera } for more details.
     */
    makeOrthographic(left: number, right: number, top: number, bottom: number): Matrix3;
    /**
     * This multiplication is specifically used for 2x3 matrixes calculation.
     */
    static multiplyMatrixFast(a: Matrix3, b: Matrix3, result: Matrix3): Matrix3;
}
declare type ReadonlyMatrix3 = PickReadonly;

interface Vector {
    setComponent(index: number, value: number): void;
    getComponent(index: number): number;
    copy(v: this): Vector;
    add(v: Vector): Vector;
    addVectors(a: Vector, b: Vector): Vector;
    sub(v: Vector): Vector;
    subVectors(a: Vector, b: Vector): Vector;
    multiplyScalar(s: number): Vector;
    divideScalar(s: number): Vector;
    negate(): Vector;
    dot(v: Vector): number;
    lengthSq(): number;
    length(): number;
    normalize(): Vector;
    distanceTo?(v: Vector): number;
    distanceToSquared?(v: Vector): number;
    setLength(l: number): Vector;
    lerp(v: Vector, alpha: number): Vector;
    equals(v: Vector): boolean;
    clone(): Vector;
    toArray(arr?: number[]): number[];
}

/**
 * Class representing a 2D {@link https://en.wikipedia.org/wiki/Vector_space| vector}.
 * A 2D vector is an ordered pair of numbers (labeled x and y).
 */
declare class Vector2 implements Vector {
    /**
     * the x value of this vector.
     * @defaultValue `0`.
     */
    x: number;
    /**
     * the y value of this vector.
     * @defaultValue `0`.
     */
    y: number;
    /**
     * Check the type whether it belongs to Vector2.
     * This value should not be changed by user.
     */
    isVector2: boolean;
    constructor(_x?: number, _y?: number);
    /**
     * @ignore
     */
    getSerializeData(): number[];
    /**
     * @ignore
     */
    setSerializeData(value: any): void;
    /**
     * Same to x.
     */
    get width(): number;
    set width(w: number);
    /**
     * Same to y.
     */
    get height(): number;
    set height(h: number);
    /**
     * Sets the {@link x| x} and {@link y| y} components of this vector.
     */
    set(x: number, y: number): Vector2;
    /**
     * Sets the {@link x| x} and {@link y| y} values of this vector both equal to scalar.
     */
    setScalar(scalar: number): Vector2;
    /**
     * Replaces this vector's {@link x| x} value with {@link Float| x}.
     */
    setX(x: number): Vector2;
    /**
     * Replaces this vector's {@link y| y} value with {@link Float| y}.
     */
    setY(y: number): Vector2;
    /**
     * If index equals 0 set {@link x| x} to {@link Float| value}.
     * If index equals 1 set {@link y| y} to {@link Float| value}.
     */
    setComponent(index: number, value: number): Vector2;
    /**
     * If index equals 0 returns the {@link x| x} value.
     * If index equals 1 returns the {@link y| y} value.
     * @param index 0 or 1.
     */
    getComponent(index: number): number;
    /**
     * Returns a new Vector2 with the same {@link x| x} and {@link y| y} values as this one.
     */
    clone(): Vector2;
    cloneReadonly(): Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "equals" | "getSerializeData" | "x" | "y" | "getNumberCount" | "toArray" | "width" | "height" | "isVector2" | "dot" | "cross" | "lengthSq" | "length" | "angle" | "manhattanLength" | "distanceTo" | "distanceToSquared" | "manhattanDistanceTo" | "intoSize">>;
    /**
     * Copies the values of the passed Vector2's {@link x| x} and {@link y| y} properties to this Vector2.
     */
    copy(v: Vector2): Vector2;
    /**
     * Adds {@link Vector2| v} to this vector.
     */
    add(v: Vector2): Vector2;
    /**
     * Adds the scalar value s to this vector's {@link x| x} and {@link y| y} values.
     */
    addScalar(s: number): Vector2;
    /**
     * Sets this vector to {@link Vector2| a} + {@link Vector2| b}.
     */
    addVectors(a: Vector2, b: Vector2): Vector2;
    /**
     * Adds the multiple of {@link Vector2| v} and s to this vector.
     */
    addScaledVector(v: Vector2, s: number): Vector2;
    /**
     * Subtracts {@link Vector2| v} from this vector.
     */
    sub(v: Vector2): Vector2;
    /**
     * Subtracts s from this vector's {@link x| x} and {@link y| y} components.
     */
    subScalar(s: number): Vector2;
    /**
     * Sets this vector to {@link Vector2| a} - {@link Vector2| b}.
     */
    subVectors(a: Vector2, b: Vector2): Vector2;
    /**
     * Multiplies this vector by {@link Vector2| v}.
     */
    multiply(v: Vector2): Vector2;
    /**
     * Multiplies this vector by scalar s.
     */
    multiplyScalar(scalar: number): Vector2;
    /**
     * Divides this vector by {@link Vector2| v}.
     */
    divide(v: Vector2): Vector2;
    /**
     * Divides this vector by scalar s.

     * Sets vector to `( 0, 0 )` if s = 0.
     */
    divideScalar(scalar: number): Vector2;
    /**
     * Multiplies this vector (with an implicit 1 as the 3rd component) by m.
     */
    applyMatrix3(m: Matrix3): Vector2;
    /**
     * Multiplies this vector (with an implicit 1 as the 4rd component) by m.
     */
    applyMatrix4(m: Matrix4): Vector2;
    /**
     * If this vector's x or y value is greater than the max vector's x or y value, it is replaced by the corresponding value.
     * If this vector's x or y value is less than the min vector's x or y value, it is replaced by the corresponding value.
     * @param min the minimum x and y values.
     * @param max the maximum x and y values in the desired range.
     */
    min(v: Vector2): Vector2;
    /**
     * If this vector's x or y value is greater than the max vector's x or y value, it is replaced by the corresponding value.
     * If this vector's x or y value is less than the min vector's x or y value, it is replaced by the corresponding value.
     * @param min the minimum x and y values.
     * @param max the maximum x and y values in the desired range.
     */
    max(v: Vector2): Vector2;
    /**
     * If this vector's x or y value is greater than the max vector's x or y value, it is replaced by the corresponding value. 


     * If this vector's x or y value is less than the min vector's x or y value, it is replaced by the corresponding value.
     * @param min the minimum x and y values.
     * @param max the maximum x and y values in the desired range.
     */
    clamp(min: Vector2, max: Vector2): Vector2;
    /**
     * If this vector's x or y values are greater than the max value, they are replaced by the max value. 


     * If this vector's x or y values are less than the min value, they are replaced by the min value.
     * @param min the minimum value the components will be clamped to.
     * @param max the maximum value the components will be clamped to.
     */
    clampScalar(minVal: number, maxVal: number): Vector2;
    /**
     * If this vector's length is greater than the max value, it is replaced by the max value. 


     * If this vector's length is less than the min value, it is replaced by the min value.
     * @param min the minimum value the length will be clamped to.
     * @param max the maximum value the length will be clamped to.
     */
    clampLength(min: number, max: number): Vector2;
    /**
     * The components of this vector are rounded down to the nearest integer value.
     */
    floor(): Vector2;
    /**
     * The {@link x| x} and {@link y| y} components of this vector are rounded up to the nearest integer value.
     */
    ceil(): Vector2;
    /**
     * The components of this vector are rounded to the nearest integer value.
     */
    round(): Vector2;
    /**
     * The components of this vector are rounded towards zero (up if negative, down if positive) to an integer value.
     */
    roundToZero(): Vector2;
    /**
     * Inverts this vector - i.e. sets x = -x and y = -y.
     */
    negate(): Vector2;
    /**
     * Calculates the {@link https://en.wikipedia.org/wiki/Dot_product| dot product} of this vector and {@link Vector2| v}.
     */
    dot(v: Vector2): number;
    /**
     * Calculates the cross product of this vector and {@link Vector2| v}.
     * @tips that a 'cross-product' in 2D is not well-defined. This function computes a geometric cross-product often used in 2D graphics
     */
    cross(v: Vector2): number;
    /**
     * Computes the square of the {@link https://en.wikipedia.org/wiki/Euclidean_distance| Euclidean length } (straight-line length) from (0, 0) to (x, y).
     * If you are comparing the lengths of vectors, you should compare the length squared instead as it is slightly more efficient to calculate.
     */
    lengthSq(): number;
    /**
     * Computes the Euclidean length (straight-line length) from (0, 0) to (x, y).
     */
    length(): number;
    /**
     * Computes the {@link http://en.wikipedia.org/wiki/Taxicab_geometry| Manhattan length } of this vector.
     */
    manhattanLength(): number;
    /**
     * Converts this vector to a {@link https://en.wikipedia.org/wiki/Unit_vector| unit vector }.
     * that is, sets it equal to a vector with the same direction as this one, but {@link length| length} 1.
     */
    normalize(): Vector2;
    /**
     * Computes the angle in radians of this vector with respect to the positive x-axis.
     */
    angle(): number;
    /**
     * Computes the distance from this vector to {@link Vector2| v}.
     */
    distanceTo(v: Vector2): number;
    /**
     * Computes the squared distance from this vector to {@link Vector2| v}.
     * If you are just comparing the distance with another distance,
     * you should compare the distance squared instead as it is slightly more efficient to calculate.
     */
    distanceToSquared(v: Vector2): number;
    /**
     * Computes the {@link https://en.wikipedia.org/wiki/Taxicab_geometry| Manhattan distance} from this vector to {@link Vector2| v}.
     */
    manhattanDistanceTo(v: Vector2): number;
    /**
     * Sets this vector to a vector with given length the same direction as this one.
     */
    setLength(length: number): Vector2;
    /**
     * Linearly interpolates between this vector and {@link Vector2| v},
     * where alpha is the percent distance along the line - alpha = 0 will be this vector, and alpha = 1 will be {@link Vector2| v}.
     * @param v {@link Vector2| Vector2} to interpolate towards.
     * @param alpha interpolation factor, typically in the closed interval [0, 1].
     */
    lerp(v: Vector2, alpha: number): Vector2;
    /**
     * Sets this vector to be the vector linearly interpolated between {@link Vector2| v1} and
     * {@link Vector2| v2} where alpha is the percent distance along the line connecting the two vectors -
     * alpha = 0 will be {@link Vector2| v1}, and alpha = 1 will be {@link Vector2| v2}.
     * @param v1 the starting {@link Vector2| Vector2}.
     * @param v2 {@link Vector2| Vector2} to interpolate towards.
     * @param alpha interpolation factor, typically in the closed interval [0, 1].
     */
    lerpVectors(v1: Vector2, v2: Vector2, alpha: number): Vector2;
    /**
     * Checks for strict equality of this vector and {@link Vector2| v}.
     */
    equals(v: Vector2): boolean;
    /**
     * Sets this vector's {@link x| x} value to be array[ offset ] and {@link y| y} value to be array[ offset + 1 ].
     * @param array the source array.
     * @param offset (optional) offset into the array.
     * @defaultValue is 0.
     */
    fromArray(array: ArrayLike, offset?: number): Vector2;
    /**
     * There are 2 elements in this vector.
     */
    getNumberCount(): number;
    /**
     * Returns an array [x, y], or copies x and y into the provided array.
     * @param array (optional) array to store this vector to. If this is not provided, a new array will be created.
     * @param offset (optional) optional offset into the array.
     */
    toArray(array?: number[], offset?: number): number[];
    /**
     * @deprecated please use BufferAttribute.getVector2
     * Sets this vector's {@link .x| x} and {@link .y| y} values from the {@link BufferAttribute| attribute}.
     * @param attribute the source attribute.
     * @param index index in the attribute.
     */
    fromBufferAttribute(attribute: {
        getX: (number: number) => number;
        getY: (number: number) => number;
    }, index: number, offset?: number): Vector2;
    /**
     * Rotates this vector around {@link Vector2| center} by {@link Float| angle} radians.
     * @param center the point around which to rotate.
     * @param angle the angle to rotate, in radians.
     */
    rotateAround(center: Vector2, angle: number): Vector2;
    intoSize(): Size;
}
declare type ReadonlyVector2 = PickReadonly;

/**
 * This class is base class of all types of light source.
 * Every lights have two basic attributes which are color and intensity.
 */
declare abstract class Light extends Object3D {
    /**
     * The type of this Object3D.
     */
    type: string;
    /**
     * Check the type whether it belongs to Light.
     * This value should not be changed by user.
     */
    isLight: boolean;
    /**
     * Color of the light. This value can influence the color of model's surface according to the material.
     * Defaults to a new {@link Color | color } set to white, if not passed in the constructor.
     */
    color: Color;
    /**
     * The light's intensity, or strength.
     * In physically correct mode, the product of color * intensity is interpreted as luminous intensity measured in candela.
     * @defaultValue `1`
     */
    intensity: number;
    private _enabled;
    get enabled(): boolean;
    set enabled(v: boolean);
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(color?: number | string, intensity?: number);
    /**
     * Copy the data to this light instance from source.
     * This method need override in derived classes to copy extended data.
     * @param {Light} source the data source.
     */
    copy(source: Light, recursive?: boolean): this;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx an instance give the method to take the data for attribute.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx an instance used to store the data of scene objects.
     */
    serialize(ctx: Serializer): void;
}

/**
 * {@link Vector3| Vector3} representing the start point of the line.
 * A geometric line segment represented by a start and end point.
 */
declare class Line3 {
    /**
     * {@link Vector3| Vector3} representing the start point of the line.
     */
    start: Vector3;
    /**
     * {@link Vector3| Vector3} representing the end point of the line.
     */
    end: Vector3;
    constructor(start?: Vector3, end?: Vector3);
    /**
     * Sets the start and end values by copying the provided vectors.
     * @param start set the {@link start | start} of the line.
     * @param end set the {@link end | end} of the line.
     */
    set(start: Vector3, end: Vector3): Line3;
    /**
     * Returns a new {@link Line3 | Line3} with the same {@link start | start} and {@link end | end} vectors as this one.
     */
    clone(): Line3;
    /**
     * Copies the passed line's {@link start | start} and {@link end | end} vectors to this line.
     */
    copy(line: Line3): Line3;
    /**
     * Returns the center of the line segment.
     * @param target the result will be copied into this Vector3.
     */
    getCenter(target: Vector3): Vector3;
    /**
     * Returns the delta vector of the line segment ({@link end | end} vector minus the {@link start | start} vector).
     * @param target the result will be copied into this Vector3.
     */
    delta(target: Vector3): Vector3;
    /**
     * Returns the square of the {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
     * (straight-line distance) between the line's {@link start | start} and {@link end | end} vectors.
     */
    distanceSq(): number;
    /**
     * Returns the {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
     * (straight-line distance) between the line's {@link start | start} and {@link end | end} points.
     */
    distance(): number;
    /**
     * Returns a vector at a certain position along the line. When {@link Float| t} = 0, it returns the start vector,
     * and when {@link Float| t} = 1 it returns the end vector.
     * @param t Use values 0-1 to return a position along the line segment.
     * @param target the result will be copied into this Vector3.
     */
    at(t: number, target: Vector3): Vector3;
    /**
     * Returns a point parameter based on the closest point as projected on the line segment.
     * If {@link Boolean| clampToLine} is true, then the returned value will be between 0 and 1.
     * @param point the point for which to return a point parameter.
     * @param clampToLine Whether to clamp the result to the range [0, 1].
     */
    closestPointToPointParameter(point: Vector3, clampToLine?: boolean): number;
    /**
     * Returns the closets point on the line. If {@link Boolean| clampToLine} is true, then the returned value will be clamped to the line segment.
     * @param point return the closest point on the line to this point.
     * @param clampToLine whether to clamp the returned value to the line segment.
     * @param target the result will be copied into this Vector3.
     */
    closestPointToPoint(point: Vector3, clampToLine: boolean, target: Vector3): Vector3;
    /**
     * Applies a matrix transform to the line segment.
     */
    applyMatrix4(matrix: Matrix4): Line3;
    /**
     * Returns true if both line's {@link start| start} and {@link end| end} points are equal.
     * @param line {@link Line3| Line3} to compare with this one.
     */
    equals(line: Line3): boolean;
}

/**
 * A two dimensional surface that extends infinitely in 3d space,
 * represented in {@link http://mathworld.wolfram.com/HessianNormalForm.html| Hessian normal form} by a unit length normal vector and a constant.
 */
declare class Plane {
    /**
     * (optional) a unit length vector3 defining the normal of the plane.
     * @defaultValue `(1, 0, 0)`.
     */
    normal: Vector3;
    /**
     * (optional) the signed distance from the origin to the plane.
     * @defaultValue `0`.
     */
    constant: number;
    constructor(normal?: Vector3, constant?: number);
    /**
     * Sets this plane's {@link normal| normal} and {@link constant| constant} properties by copying the values from the given normal.
     * @param normal a unit length {@link Vector3| Vector3} defining the normal of the plane.
     * @param constant the signed distance from the origin to the plane.
     * @defaultValue `0`.
     */
    set(normal: Vector3, constant: number): Plane;
    /**
     * Set the individual components that define the plane.
     * @param x x value of the unit length normal vector.
     * @param y y value of the unit length normal vector.
     * @param z z value of the unit length normal vector.
     * @param w the value of the plane's {@link constant| constant} property.
     */
    setComponents(x: number, y: number, z: number, w: number): Plane;
    /**
     * Sets the plane's properties as defined by a {@link Vector3| normal} and an arbitrary coplanar {@link Vector3| point}.
     * @param normal a unit length {@link Vector3| Vector3} defining the normal of the plane.
     * @param point {@link Vector3| Vector3}.
     */
    setFromNormalAndCoplanarPoint(normal: Vector3, point: Vector3): Plane;
    /**
     * Defines the plane based on the 3 provided points.
     * The winding order is assumed to be counter-clockwise, and determines the direction of the {@link normal| normal}.
     * @param a first point on the plane.
     * @param b second point on the plane.
     * @param c third point on the plane.
     */
    setFromCoplanarPoints(a: Vector3, b: Vector3, c: Vector3): Plane;
    /**
     * Returns a new plane with the same {@link normal| normal} and {@link constant| constant} as this one.
     */
    clone(): Plane;
    /**
     * Copies the values of the passed plane's {@link normal| normal} and {@link constant| constant} properties to this plane.
     */
    copy(plane: Plane): Plane;
    /**
     * Normalizes the {@link normal| normal} vector, and adjusts the {@link constant| constant} value accordingly.
     */
    normalize(): Plane;
    /**
     * Negates both the normal vector and the constant.
     */
    negate(): Plane;
    /**
     * Returns the signed distance from the {@link Vector3| point} to the plane.
     */
    distanceToPoint(point: Vector3): number;
    /**
     * Returns the signed distance from the {@link Sphere| sphere} to the plane.
     */
    distanceToSphere(sphere: Sphere): number;
    /**
     * Projects a {@link Vector3| point} onto the plane.
     * @param point the {@link Vector3| Vector3} to project onto the plane.
     * @param target the result will be copied into this Vector3.
     */
    projectPoint(point: Vector3, target: Vector3): Vector3;
    /**
     * Returns the intersection point of the passed line and the plane. Returns null
     * if the line does not intersect. Returns the line's starting point if the line is coplanar with the plane.
     * @param line the {@link Line3| Line3} to check for intersection.
     * @param target the result will be copied into this Vector3.
     */
    intersectLine(line: Line3, target: Vector3): Nullable;
    /**
     * Tests whether a line segment intersects with (passes through) the plane.
     * @param line the {@link Line3| Line3} to check for intersection.
     */
    intersectsLine(line: Line3): boolean;
    /**
     * Determines whether or not this plane intersects {@link Box3| box}.
     * @param box the {@link Box3| Box3} to check for intersection.
     */
    intersectsBox(box: Box3): boolean;
    /**
     * Determines whether or not this plane intersects {@link Sphere| sphere}.
     * @param sphere the {@link Sphere| Sphere} to check for intersection.
     */
    intersectsSphere(sphere: Sphere): boolean;
    /**
     * By calculating the projection of the normal vector at the origin onto the plane.
     * @return a {@link Vector3| Vector3} coplanar to the plane,
     * @param target the result will be copied into this Vector3.
     */
    coplanarPoint(target: Vector3): Vector3;
    /**
     * Apply a Matrix4 to the plane. The matrix must be an affine, homogeneous transform.
     * If supplying an {@link Matrix3| optionalNormalMatrix}, it can be created like so:
     * 
     * const optionalNormalMatrix = new THREE.Matrix3().getNormalMatrix( matrix );
     * 
     * @param matrix the Matrix4 to apply.
     * @param optionalNormalMatrix (optional) pre-computed normal [Page:Matrix3] of the Matrix4 being applied.
     */
    applyMatrix4(matrix: Matrix4, optionalNormalMatrix?: Matrix3): Plane;
    /**
     * Translates the plane by the distance defined by the {@link Vector3| offset} vector.
     * @param offset the amount to move the plane by.
     * @tips that this only affects the plane constant and will not affect the normal vector.
     */
    translate(offset: Vector3): Plane;
    /**
     * Checks to see if two planes are equal (their {@link normal| normal} and {@link .constant| constant} properties match).
     */
    equals(plane: Plane): boolean;
}

/**
 * A two dimensional surface that extends infinitely in 3d space,
 * represented in {@link http://mathworld.wolfram.com/HessianNormalForm.html| Hessian normal form} by a unit length normal vector and a constant.
 */
declare class Sphere {
    /**
     * A {@link Vector3| Vector3} defining the center of the sphere.
     * @defaultValue `(0, 0, 0)`.
     */
    center: Vector3;
    /**
     * The radius of the sphere.
     * @defaultValue `0`.
     */
    radius: number;
    constructor(center?: Vector3, radius?: number);
    /**
     * Sets the {@link center| center} and {@link radius| radius} properties of this sphere.

     * Please note that this method only copies the values from the given center.
     * @param center center of the sphere.
     * @param radius radius of the sphere.
     */
    set(center: Vector3, radius: number): Sphere;
    /**
     * Computes the minimum bounding sphere for an array of {@link Array| points}.
     * If {@link Vector3| optionalCenter} is given, it is used as the sphere's center.
     * Otherwise, the center of the axis-aligned bounding box encompassing {@link Array| points} is calculated.
     * @param points an array of {@link Vector3| Vector3} positions.
     * @param optionalCenter Optional {@link Vector3| Vector3} position for the sphere's center.
     */
    setFromPoints(points: Vector3[], optionalCenter?: Vector3): Sphere;
    /**
     * Returns a new sphere with the same {@link center| center} and {@link radius| radius} as this one.
     */
    clone(): Sphere;
    /**
     * Copies the values of the passed sphere's {@link center| center} and {@link radius| radius} properties to this sphere.
     */
    copy(sphere: Sphere): Sphere;
    /**
     * If the radius smaller than zero, this will return false, otherwise return true.
     */
    empty(): boolean;
    /**
     * Checks to see if the sphere contains the provided {@link Vector3| point} inclusive of the surface of the sphere.
     * @param point the {@link Vector3| Vector3} to be checked.
     */
    containsPoint(point: Vector3): boolean;
    /**
     * Returns the closest distance from the boundary of the sphere to the {@link Vector3| point}.
     * If the sphere contains the point, the distance will be negative.
     */
    distanceToPoint(point: Vector3): number;
    /**
     * Checks to see if two spheres intersect.
     * @param sphere Sphere to check for intersection against.
     */
    intersectsSphere(sphere: Sphere): boolean;
    /**
     * Determines whether or not this sphere intersects a given {@link Box3| box}.
     * @param box {@link Box3| Box3} to check for intersection against.
     */
    intersectsBox(box: Box3): boolean;
    /**
     * Determines whether or not this sphere intersects a given {@link Plane| plane}.
     * @param plane Plane to check for intersection against.
     */
    intersectsPlane(plane: Plane): boolean;
    /**
     * Clamps a point within the sphere. If the point is outside the sphere, it will clamp it to the closest point on the edge of the sphere.
     * Points already inside the sphere will not be affected.
     * @param point {@link Vector3| Vector3} The point to clamp.
     * @param target the result will be copied into this Vector3.
     */
    clampPoint(point: Vector3, target: Vector3): Vector3;
    /**
     * Returns a {@link https://en.wikipedia.org/wiki/Minimum_bounding_box| Minimum Bounding Box} for the sphere.
     * @param target the result will be copied into this Box3.
     */
    getBoundingBox(target: Box3): Box3;
    /**
     * Transforms this sphere with the provided {@link Matrix4| Matrix4}.
     * @param matrix the {@link Matrix4| Matrix4} to apply
     */
    applyMatrix4(matrix: Matrix4): Sphere;
    /**
     * Translate the sphere's center by the provided offset {@link Vector3| Vector3}.
     */
    translate(offset: Vector3): Sphere;
    /**
     * Checks to see if the two spheres' centers and radii are equal.
     */
    equals(sphere: Sphere): boolean;
}

/**
 * A ray that emits from an origin in a certain direction. This is used by the
 * {@link Raycaster| Raycaster} to assist with {@link https://en.wikipedia.org/wiki/Ray_casting| ray casting}.
 * Raycaster is used for mouse picking (working out what objects in the 3D space the mouse is over) amongst other things.
 */
declare class Ray {
    /**
     * The origin of the {@link Ray| Ray}.
     * @defaultValue is a {@link Vector3| Vector3} at `(0, 0, 0)`.
     */
    origin: Vector3;
    /**
     * The direction of the {@link Ray| Ray}.
     * This must be normalized (with {@link Vector3.normalize| Vector3.normalize}) for the methods to operate properly.
     * @defaultValue is a {@link Vector3| Vector3} at `(0, 0, -1)`.
     */
    direction: Vector3;
    constructor(origin?: Vector3, direction?: Vector3);
    /**
     * This must be normalized (with {@link Vector3.normalize| Vector3.normalize}) for the methods to operate properly.
     * Sets this ray's {@link .origin| origin} and {@link .direction| direction} properties by copying the values from the given objects.
     * @param origin the {@link origin| origin} of the {@link Ray| Ray}.
     * @param origin the {@link direction| direction} of the {@link Ray| Ray}.
     */
    set(origin: Vector3, direction: Vector3): Ray;
    /**
     * Creates a new Ray with identical {@link origin| origin} and {@link direction| direction} to this one.
     */
    clone(): Ray;
    /**
     * Copies the {@link origin| origin} and {@link direction| direction} properties of {@link Ray| ray} into this ray.
     */
    copy(ray: Ray): Ray;
    /**
     * Get a {@link Vector3| Vector3} that is a given distance along this {@link Ray| Ray}.
     * @param t the distance along the {@link Ray| Ray} to retrieve a position for.
     * @param target the result will be copied into this Vector3.
     */
    at(t: number, target: Vector3): Vector3;
    /**
     * Adjusts the direction of the ray to point at the vector in world coordinates.
     * @param v The {@link Vector3| Vector3} to look at.
     */
    lookAt(v: Vector3): Ray;
    /**
     * Shift the origin of this {@link Ray| Ray} along its direction by the distance given.
     * @param t The distance along the {@link Ray| Ray} to interpolate.
     */
    recast(t: number): Ray;
    /**
     * Get the point along this {@link Ray| Ray} that is closest to the {@link Vector3| Vector3} provided.
     * @param point the point to get the closest approach to.
     * @param target the result will be copied into this Vector3.
     */
    closestPointToPoint(point: Vector3, target: Vector3): Vector3;
    /**
     * Get the distance of the closest approach between the {@link Ray| Ray} and the {@link Vector3| point}.
     * @param point {@link Vector3| Vector3} The {@link Vector3| Vector3} to compute a distance to.
     */
    distanceToPoint(point: Vector3): number;
    /**
     * Get the squared distance of the closest approach between the {@link Ray| Ray} and the {@link Vector3| Vector3}.
     * @param point the {@link Vector3| Vector3} to compute a distance to.
     */
    distanceSqToPoint(point: Vector3): number;
    /**
     * Get the squared distance between this {@link Ray| Ray} and a line segment.
     * @param v0 the start of the line segment.
     * @param v1 the end of the line segment.
     * @param optionalPointOnRay (optional) if this is provided, it receives the point on this {@link Ray| Ray} that is closest to the segment.
     * @param optionalPointOnSegment - (optional) if this is provided, it receives the point on the line segment that is closest to this {@link Ray| Ray}.
     */
    distanceSqToSegment(v0: Vector3, v1: Vector3, optionalPointOnRay?: Vector3, optionalPointOnSegment?: Vector3): number;
    /**
     * Intersect this {@link Ray| Ray} with a {@link Sphere| Sphere}, returning the intersection point or `null` if there is no intersection.
     * @param sphere the {@link Sphere| Sphere} to intersect with.
     * @param target the result will be copied into this Vector3.
     */
    intersectSphere(sphere: Sphere, target: Vector3): Nullable;
    /**
     * Calculate the maximum distance between origin and one or two intersections if this ray through the sphere.
     */
    intersectSphereMaxDistance(sphere: Sphere): number;
    /**
     * Calculate the length, which is the distance projected on the ray from given point to origin.
     */
    directionDistance(point: Vector3): number;
    /**
     * Return true if this {@link Ray| Ray} intersects with the {@link Sphere| Sphere}.
     * @param sphere the {@link Sphere| Sphere} to intersect with
     */
    intersectsSphere(sphere: Sphere): boolean;
    /**
     * Get the distance from {@link origin| origin} to the {@link Plane| Plane}, or *null* if the {@link Ray| Ray} doesn't intersect the {@link Plane| Plane}.
     * @param plane the {@link Plane| Plane} to get the distance to.
     */
    distanceToPlane(plane: Plane): Nullable;
    /**
     * Intersect this {@link Ray| Ray} with a {@link Plane| Plane}, returning the intersection point or `null` if there is no intersection.
     * @param plane the {@link Plane| Plane} to intersect with.
     * @param target the result will be copied into this Vector3.
     */
    intersectPlane(plane: Plane, target: Vector3): Nullable;
    /**
     * Return true if this {@link Ray| Ray} intersects with the {@link Plane| Plane}.
     * @param plane the {@link Plane| Plane} to intersect with.
     */
    intersectsPlane(plane: Plane): boolean;
    /**
     * Intersect this {@link Ray| Ray} with a {@link Box3| Box3}, returning the intersection point or `null` if there is no intersection.
     * @param box the {@link Box3| Box3} to intersect with.
     * @param target the result will be copied into this Vector3.
     */
    intersectBox(box: Box3, target?: Vector3): Nullable;
    /**
     * Return true if this {@link Ray| Ray} intersects with the {@link Box3| Box3}.
     * @param box the {@link Box3| Box3} to intersect with.
     */
    intersectsBox(box: Box3): boolean;
    /**
     * Transform this {@link Ray| Ray} by the {@link Matrix4| Matrix4}.
     * @param matrix4 the {@link Matrix4| Matrix4} to apply to this {@link Ray| Ray}.
     */
    applyMatrix4(matrix4: Matrix4): Ray;
    /**
     * Returns true if this and the other {@link Ray| ray} have equal {@link origin| origin} and {@link direction| direction}.
     * @param ray the {@link Ray| Ray} to compare to.
     */
    equals(ray: Ray): boolean;
    /**
     * Intersect this {@link Ray| Ray} with a triangle, returning the intersection point or `null` if there is no intersection.
     * @param abc The {@link Vector3| Vector3} points making up the triangle.
     * @param backfaceCulling whether to use backface culling
     * @param target the result will be copied into this Vector3.
     */
    intersectTriangle(a: Vector3, b: Vector3, c: Vector3, backfaceCulling: boolean, target: Vector3): Nullable;
}

declare abstract class GeometryBase extends ElementEventDispatcher implements SerializerableDelegatedAsReference, ElementsWithGPUResource {
    id: number;
    protected boundingBox: Nullable;
    protected boundingSphere: Nullable;
    getUUID(): string;
    abstract computeBoundingBox(): void;
    abstract computeBoundingSphere(): void;
    abstract className(): string;
    abstract serialize(serialize: Serializer): void;
    abstract deserialize(ctx: Deserializer): void;
    abstract freeGPU(): void;
    abstract clone(): GeometryBase;
    getBoundingBox(): Box3;
    getBoundingSphere(): Sphere;
    notifyShapeChanged(): void;
    notifyGeometryContentChange(): void;
}

declare enum WebGLExtEnums {
    WEBGL_lose_context = "WEBGL_lose_context",
    WEBGL_debug_renderer_info = "WEBGL_debug_renderer_info",
    ANGLE_instanced_arrays = "ANGLE_instanced_arrays",
    OES_texture_float = "OES_texture_float",
    OES_texture_half_float = "OES_texture_half_float",
    OES_texture_float_linear = "OES_texture_float_linear",
    OES_texture_half_float_linear = "OES_texture_half_float_linear",
    OES_standard_derivatives = "OES_standard_derivatives",
    OES_vertex_array_object = "OES_vertex_array_object",
    OES_element_index_uint = "OES_element_index_uint",
    WEBGL_depth_texture = "WEBGL_depth_texture",
    WEBGL_color_buffer_float = "WEBGL_color_buffer_float",
    WEBGL_draw_buffers = "WEBGL_draw_buffers",
    EXT_texture_filter_anisotropic = "EXT_texture_filter_anisotropic",
    EXT_shader_texture_lod = "EXT_shader_texture_lod",
    EXT_color_buffer_half_float = "EXT_color_buffer_half_float",
    EXT_color_buffer_float = "EXT_color_buffer_float",
    EXT_frag_depth = "EXT_frag_depth",
    EXT_sRGB = "EXT_sRGB",
    EXT_blend_minmax = "EXT_blend_minmax",
    WEBGL_compressed_texture_s3tc = "WEBGL_compressed_texture_s3tc",
    WEBGL_compressed_texture_astc = "WEBGL_compressed_texture_astc",
    WEBGL_compressed_texture_etc1 = "WEBGL_compressed_texture_etc1",
    WEBGL_compressed_texture_etc = "WEBGL_compressed_texture_etc",
    WEBGL_compressed_texture_pvrtc = "WEBGL_compressed_texture_pvrtc",
    EXT_texture_compression_bptc = "EXT_texture_compression_bptc"
}
declare class WGLExtensions {
    _extensions: {
        [index: string]: any;
    };
    get(name: WebGLExtEnums): any;
    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
}

declare class FPSTimer extends EventDispatcher {
    frameId: number;
    private requestAnimationFrame;
    private cancelAnimationFrame;
    private enabled;
    private defaultTickCounter;
    private activeTickCounter;
    private lastTickTime;
    private lastRequestID;
    get lastFrameTime(): number;
    setupAnimationFunction(requestAnimationFrame: typeof globalThis.requestAnimationFrame, cancelAnimationFrame: typeof globalThis.cancelAnimationFrame): void;
    resetDefaultAnimationFunction(): void;
    start(): void;
    stop(): void;
    destroy(): void;
    tick: (now: number) => void;
    pick(): void;
    getAverageFrameTime(): number;
    reset(): void;
}

declare class ValueCounter {
    private sum;
    private buffer;
    private cursor;
    private capacity;
    constructor();
    toJSON(): string;
    set(value: number): void;
    clear(): void;
    getLast(): number;
    getAverage(): number;
}

declare class RenderInfo {
    objectInfo: ObjectStatsInfo;
    refreshProgramCount: number;
    refreshMaterialCount: number;
    refreshLightsCount: number;
    resetFrameStart(): void;
}
declare class FrameInfo {
    fpsCollector: FPSTimer;
    timeStart: number;
    timeEnd: number;
    lastFrameTimeStart: number;
    lastFrameRenderCPUTime: number;
    frameCPUCounter: ValueCounter;
    constructor();
    get averageRenderFrameTime(): number;
    getActiveCPUHistoryData(): string;
    get lastFrameTime(): number;
    resetRenderFrameTimeStat(): void;
    setupAnimationFunction(requestAnimationFrame: typeof globalThis.requestAnimationFrame, cancelAnimationFrame: typeof globalThis.cancelAnimationFrame): void;
    resetDefaultAnimationFunction(): void;
    beginFrameTick(): void;
    endFrameTick(): void;
    destroy(): void;
}
declare class ObjectStatsInfo {
    geometries: number;
    textures: number;
    calls: number;
    vertices: number;
    faces: number;
    programs: number;
    callsByObjectCategoryId: Map;
    callsBySourceType: Map;
    enableDrawcallClassify: boolean;
    addDrawcall(object: Object3D): void;
    reset(): void;
}

declare class ColorState {
    private color;
    private currentColorMask;
    private currentColorClear;
    readonly gl: WebGLRenderingContext | WebGL2RenderingContext;
    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
    setMask(red: boolean, green?: boolean, blue?: boolean, alpha?: boolean): void;
    setClear(r: number, g: number, b: number, a: number, premultipliedAlpha?: boolean): void;
    reset(): void;
}

/**
 * Specified the showing side of objects, which the fround side is normal vector's direction.
 */
declare enum Side {
    FrontSide = 0,
    BackSide = 1,
    DoubleSide = 2
}
/**
 * Specified the color blending mode for transparent effect.
 */
declare enum Blending {
    NoBlending = 0,
    NormalBlending = 1,
    AdditiveBlending = 2,
    SubtractiveBlending = 3,
    MultiplyBlending = 4,
    CustomBlending = 5
}
/**
 * The depth test {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/depthFunc| function}.
 */
declare enum DepthModes {
    NeverDepth = 0,
    AlwaysDepth = 1,
    LessDepth = 2,
    LessEqualDepth = 3,
    EqualDepth = 4,
    GreaterEqualDepth = 5,
    GreaterDepth = 6,
    NotEqualDepth = 7
}
/**
 * Specify the data type of texture.
 */
declare enum TextureDataType {
    UnsignedByteType = 5121,
    ByteType = 5120,
    ShortType = 5122,
    UnsignedShortType = 5123,
    IntType = 5124,
    UnsignedIntType = 5125,
    FloatType = 5126,
    HalfFloatType = 5131,
    UnsignedShort4444Type = 32819,
    UnsignedShort5551Type = 32820,
    UnsignedShort565Type = 33635,
    UnsignedInt248Type = 34042,
    UnsignedInt2101010Type = 33640
}
/**
 * This is used to decide how the vertex array is drawing.
 */
declare enum DrawMode {
    Points = 0,
    Lines = 1,
    LineLoop = 2,
    LineStrip = 3,
    Triangles = 4,
    TriangleStrip = 5,
    TriangleFan = 6
}
/**
 * These define the texture's wrapS and wrapT properties, which define horizontal and vertical texture wrapping.
 */
declare enum SamplerWrap {
    /**
     * With RepeatWrapping the texture will simply repeat to infinity.
     */
    Repeat = 10497,
    /**
     * ClampToEdgeWrapping is the default. The last pixel of the texture stretches to the edge of the mesh.
     */
    ClampToEdge = 33071,
    /**
     * With MirroredRepeatWrapping the texture will repeats to infinity, mirroring on each repeat.
     */
    MirroredRepeat = 33648
}
/**
 * With MirroredRepeatWrapping the texture will repeats to infinity, mirroring on each repeat.
 */
declare enum SamplerFilter {
    Nearest = 9728,
    Linear = 9729,
    NearestMipmapNearest = 9984,
    LinearMipmapNearest = 9985,
    NearestMipmapLinear = 9986,
    LinearMipmapLinear = 9987
}
/**
 * The blendEquation method of the WebGL API is used to set both the RGB blend equation and alpha blend equation to a single equation.
 */
declare enum BlendingEquation {
    Add = 32774,
    Subtract = 32778,
    ReverseSubtract = 32779,
    Min = 32775,
    Max = 32776
}
/**
 * The following constants can be used for sfactor and dfactor.
 * The formula for the blending color can be described like this: color(RGBA) = (sourceColor * sfactor) + (destinationColor * dfactor).
 * The RBGA values are between 0 and 1.
 */
declare enum BlendingFactor {
    Zero = 0,
    One = 1,
    SrcColor = 768,
    OneMinusSrcColor = 769,
    SrcAlphaFactor = 770,
    OneMinusSrcAlpha = 771,
    DstAlpha = 772,
    OneMinusDstAlpha = 773,
    DstColor = 774,
    OneMinusDstColor = 775
}
/**
 * The stencilOp method of the WebGL API sets both the front and back-facing stencil test actions.
 */
declare enum StencilOp {
    ZeroStencilOp = 0,
    KeepStencilOp = 7680,
    ReplaceStencilOp = 7681,
    IncrementStencilOp = 7682,
    DecrementStencilOp = 7683,
    IncrementWrapStencilOp = 34055,
    DecrementWrapStencilOp = 34056,
    InvertStencilOp = 5386
}
/**
 * The stencilFunc method of the WebGL API sets the front and back function and reference value for stencil testing.
 * Stenciling enables and disables drawing on a per-pixel basis. It is typically used in multipass rendering to achieve special effects.
 */
declare enum StencilFunc {
    NeverStencilFunc = 512,
    LessStencilFunc = 513,
    EqualStencilFunc = 514,
    LessEqualStencilFunc = 515,
    GreaterStencilFunc = 516,
    NotEqualStencilFunc = 517,
    GreaterEqualStencilFunc = 518,
    AlwaysStencilFunc = 519
}

declare class DepthState {
    readonly gl: WebGLRenderingContext | WebGL2RenderingContext;
    private currentDepthMask;
    private currentDepthFunc;
    private currentDepthClear;
    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
    setMask(depthMask: boolean): void;
    setFunc(depthFunc: DepthModes): void;
    setClear(depth: number): void;
    reset(): void;
}

declare class StencilState {
    private currentStencilMask;
    private currentStencilFunc;
    private currentStencilRef;
    private currentStencilFuncMask;
    private currentStencilFail;
    private currentStencilZFail;
    private currentStencilZPass;
    private currentStencilClear;
    private gl;
    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
    setMask(stencilMask: number): void;
    setFunc(stencilFunc: StencilFunc, stencilRef: number, stencilMask: number): void;
    setOp(stencilFail: StencilOp, stencilZFail: number, stencilZPass: number): void;
    setClear(stencil: number): void;
    reset(): void;
}

declare class AttributeState {
    readonly gl: WebGL2RenderingContext | WebGLRenderingContext;
    private newAttributes;
    private enabledAttributes;
    private attributeDivisors;
    private extensions;
    constructor(gl: WebGL2RenderingContext | WebGLRenderingContext, extensions: WGLExtensions);
    initAttributes(): void;
    enableAttribute(attributeLocation: number): void;
    enableAttributeAndDivisor(attributeLocation: number, meshPerAttribute: number): void;
    disableUnusedAttributes(): void;
    reset(): void;
}

declare class TextureState {
    readonly gl: WebGLRenderingContext | WebGL2RenderingContext;
    private currentTextureSlot;
    private currentBindTextures;
    private slot;
    private textureSlotMap;
    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
    activeTexture(slot: number): void;
    bindTextureAndActiveForUploading(webglType: WebGLTextureType, webglTexture: WebGLTexture): void;
    bindTextureAt(webglType: WebGLTextureType, webglTexture: WebGLTexture, slot: number): void;
    resetSlotIndex(): void;
    getFreeSlot(): number;
}

declare class BlendState {
    private currentBlending?;
    private currentBlendEquation?;
    private currentBlendSrc?;
    private currentBlendDst?;
    private currentBlendEquationAlpha?;
    private currentBlendSrcAlpha?;
    private currentBlendDstAlpha?;
    private currentPremultipliedAlpha;
    readonly gl: WebGLRenderingContext | WebGL2RenderingContext;
    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
    setBlending(blending: Blending, blendEquation: BlendingEquation, blendSrc: number, blendDst: number, blendEquationAlpha?: number, blendSrcAlpha?: number, blendDstAlpha?: number, premultipliedAlpha?: boolean): void;
}

declare class WGLState {
    readonly colorState: ColorState;
    readonly depthState: DepthState;
    readonly blendState: BlendState;
    readonly stencilState: StencilState;
    readonly textureState: TextureState;
    readonly attributeState: AttributeState;
    private enabledStates;
    private currentProgram;
    private currentFlipSided;
    private currentCullFace;
    private currentPolygonOffsetFactor;
    private currentPolygonOffsetUnits;
    private currentScissor;
    private currentViewport;
    readonly gl: WebGLRenderingContext | WebGL2RenderingContext;
    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, extensions: WGLExtensions);
    private enable;
    private disable;
    setDepthTest(depthTest: boolean): void;
    setStencilTest(stencilTest: boolean): void;
    setStencilClear(stencil: number): void;
    setDepthMask(depthMask: boolean): void;
    setColorClear(r: number, g: number, b: number, a: number, premultipliedAlpha?: boolean): void;
    bindTextureAndActiveForUploading(webglType: WebGLTextureType, webglTexture: WebGLTexture): void;
    bindTextureAt(webglType: WebGLTextureType, webglTexture: WebGLTexture, slot: number): void;
    resetTextureSlotIndex(): void;
    getFreeTextureSlot(namedSlot?: number): number;
    useProgram(program: WGLProgram): boolean;
    setFlipSided(flipSided: boolean): void;
    setCullFace(cullFace: WebGLCullFace): void;
    setPolygonOffset(polygonOffset: boolean, factor: number, units: number): void;
    setMaterial(material: MaterialState, frontFaceCW: boolean): void;
    setStencil(stencilWrite: boolean, stencilWriteMask: number, stencilFunc: StencilFunc, stencilRef: number, stencilFuncMask: number, stencilFail: StencilOp, stencilZFail: number, stencilZPass: number): void;
    setBlending(blending: Blending.NoBlending): void;
    setBlending(blending: Blending, blendEquation: BlendingEquation, blendSrc: number, blendDst: number, blendEquationAlpha?: number, blendSrcAlpha?: number, blendDstAlpha?: number, premultipliedAlpha?: boolean): void;
    setScissorTest(scissorTest: boolean): void;
    setScissor(scissor: Vector4): void;
    setViewport(viewport: Vector4): void;
    clear(color?: boolean, depth?: boolean, stencil?: boolean): void;
    reset(): void;
}

interface Renderable {
    /**
     * used to update render pass, such as clear.
     * @returns batchable
     */
    config(renderer: IRenderer): boolean;
    /**
     * do render
     */
    render(renderer: IRenderer): void;
}

/**
 * A Layers object assigns an Object3D to 1 or more of 32 layers numbered 0 to 31 - internally the layers are stored as a bit mask,
 * and by default all Object3Ds are a member of layer 0.
 * This can be used to control visibility - an object must share a layer with a camera to be visible when that camera's view is renderered.
 * All classes that inherit from Object3D have an {@link Object3D.layers| layers } property which is an instance of this class.
 */
declare class Layers extends EventDispatcher {
    /**
     * @internal
     */
    isDefault: boolean;
    get mask(): number;
    set mask(value: number);
    /**
     * A bit mask storing which of the 32 layers this layers object is currently a member of.
     */
    private _mask;
    /**
     * Set membership to layer, and remove membership all other layers.
     * @param channel an integer from 0 to 31.
     */
    set(channel: number): this;
    /**
     * Add membership of this layer.
     * @param channel an integer from 0 to 31.
     */
    enable(channel: number): this;
    /**
     * Toggle membership of layer.
     * @param channel an integer from 0 to 31.
     */
    toggle(channel: number): this;
    /**
     * Remove membership of this layer.
     * @param channel an integer from 0 to 31.
     */
    disable(channel: number): this;
    /**
     * Returns true if this and the passed layers object are members of the same set of layers.
     * @param layers a Layers object.
     */
    test(layers: Layers): boolean;
    /**
     * @ignore
     */
    getSerializeData(): number;
    /**
     * @ignore
     */
    setSerializeData(value: number): void;
    /**
     * Copies the {@link mask| mask} of given layers to this.
     */
    copy(value: Layers): void;
    /**
     * Returns a new Layers with the same {@link mask| mask} as this one.
     */
    clone(): Layers;
}

/**
 * Triangular face used in {@link Geometry | Geometry }.
 * These are created automatically for all standard geometry types, however if you are building a custom geometry you will have to create them manually.
 */
declare class Face3 {
    /**
     * Vertex A index.
     */
    a: number;
    /**
     * Vertex B index.
     */
    b: number;
    /**
     * Vertex C index.
     */
    c: number;
    /**
     * (optional) Face normal {@link Vector3 | Vector3 } or array of vertex normals.
     * If a single vector is passed in, this sets {@link normal | normal }, otherwise if an array of three vectors is passed in this sets {@link vertexNormals | vertexNormals }.
     */
    normal: Vector3;
    /**
     * Array of 3 vertex normals.
     */
    vertexNormals: Vector3[];
    /**
     * Face color - for this to be used a material's vertexColors property must be set to FaceColors.
     * @defaultValue `new Color()`.
     */
    color: Color;
    /**
     * Array of 3 vertex colors - for these to be used a material's vertexColors property must be set to {@link VertexColors | VertexColors }.
     * @defaultValue `0`.
     */
    vertexColors: Color[];
    /**
     * Material index (points to an index in the associated array of materials).
     * @defaultValue `0`.
     */
    materialIndex: number;
    constructor(a?: number, b?: number, c?: number, vertexNormals?: Vector3[] | Vector3, vertexColors?: Color[] | Color, materialIndex?: number);
    /**
     * Return a clone of this object.
     */
    clone(): Face3;
    /**
     * Copy the data to this object from source.
     * @param { Face3 } source the data source.
     */
    copy(source: Face3): Face3;
}

/**
 * The attributes of this Intersection used to record the result of calculation.
 */
interface Intersection {
    object: Object3D;
    point: Vector3;
    distance: number;
    /**
     * primitive of the intersection
     * for indexed geometry, it related to index buffer
     * for non-index geometry, it is related to position buffer
     */
    primitiveIndex: number;
    distanceToRay?: number;
    /**
     * @deprecated use `primitiveIndex` instead
     * only exist when hit points or lines
     * the value maybe confused, not recommended to use
     */
    index?: number;
    face?: Face3;
    uv?: Vector2;
    /**
     * @deprecated use `primitiveIndex` instead
     * only exist when hit mesh
     */
    faceIndex?: number;
    instanceIndex?: number;
}
/**
 * This class is designed to assist with raycasting.
 * Raycasting is used for mouse picking (working out what objects in the 3d space the mouse is over) amongst other things.
 */
declare class Raycaster {
    /**
     * The Ray used for the raycasting.
     */
    ray: Ray;
    /**
     * The near factor of the raycaster.
     * This value indicates which objects can be discarded based on the distance.
     * This value shouldn't be negative and should be smaller than the far property.
     */
    near: number;
    /**
     * The far factor of the raycaster.
     * This value indicates which objects can be discarded based on the distance.
     * This value shouldn't be negative and should be larger than the near property.
     */
    far: number;
    /**
     * The precision factor of the raycaster when intersecting Line objects.
     */
    linePrecision: number;
    /**
     * The distance threshold to check a point's intersection.
     */
    pointThreshold: number;
    layers: Layers;
    /**
     * Accept some difference when picked point do not locate on the line or points
     */
    enableScreenSpaceTolerance: boolean;
    _camera: Nullable;
    _viewHeight: number;
    constructor(origin?: Vector3, direction?: Vector3, near?: number, far?: number);
    /**
     * Set {@link ray| ray}, {@link near| near} and {@link far| far} by given origin and direction.
     * @param origin The origin vector where the ray casts from.
     * @param direction The normalized direction vector that gives direction to the ray.
     */
    set(origin: Vector3, direction: Vector3): void;
    /**
     * Set {@link ray| ray} by given camera's {@link Camera3D.castRay| castRay}.
     * @param coords the position of window where the ray through out.
     * @param camera used to decide a way of casting the ray.
     * @param {number} viewHeight the hight of view window.
     */
    setFromCamera(coords: Vector2, camera: Camera3D, viewHeight?: number): void;
    /**
     * @internal
     */
    getScreenLineToleranceSq(distance: number): number;
    /**
     * @internal
     */
    getPointTolerance(distance: number): number;
    /**
     * Calculating intersection for given object, return this object if the ray intersect with it.
     * @param recursive put children of given object into calculation together.
     * @param intersects if given, the result will be store here.
     */
    intersectObject(object: Object3D, recursive: boolean, intersects?: Intersection[]): Intersection[];
    /**
     * Calculating intersection for array of objects, return the objects which the ray intersect with.
     * @param recursive put children of objects into calculation together.
     * @param intersects if given, the result will be store here.
     */
    intersectObjects(objects: Object3D[], recursive: boolean, intersects?: Intersection[]): Intersection[];
    raycastScene(scene: Scene3D, intersects: Intersection[]): Intersection[];
}

/**
 * This class is used to link points as pair and draw a segmented line between them.
 * It supports any type of geometry, but only line material is supported.
 */
declare class LineSegments extends Drawable> {
    /**
     * Used to check type of this or extended instance.
     * This value should not be changed by user.
     */
    isLineSegments: boolean;
    /**
     * Decisive attribute to draw this object as separate line.
     */
    drawMode: DrawMode;
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(geometry?: BufferGeometry, material?: M | M[]);
    /**
     * Get intersections between a casted {@link Ray| ray} and this Line.
     * The method {@link Raycaster.intersectObject| intersectObject()} will call this method, but the results are not ordered.
     * @param {Raycaster} raycaster the instance of Raycaster is used to get the data for calculation.
     * @param {Intersection} intersects the result will be stored here.
     */
    raycastJsImpl(raycaster: Raycaster, intersects: Intersection[]): void;
    /**
     * Return a clone of this object.
     */
    clone(): LineSegments;
}

/**
 * This class is used to connect every three points into a triangle and draws every meshes as corresponding material in the scene.
 */
declare class Mesh = BufferGeometry> extends Drawable {
    /**
     * Check the type whether it belongs to Mesh.
     * This value should not be changed by user.
     */
    isMesh: boolean;
    /**
    * Mark this mesh use origin material in transparent mode
    */
    useOriginMaterialInTransparentMode: boolean;
    /**
     * The type of this Object3D.
     */
    type: string;
    /**
     * Bind edges to a mesh.
     * Since the material is same, so all the groups will be combined together here.
     */
    edges: Nullable;
    _syncedEdgeThreshold: number;
    private _instanceKey;
    /**
    * This key is used to identify the different instances with same data.
    * @remarks See {@link InstanceMesh| InstanceMesh} for more details
    */
    set instanceKey(value: Nullable);
    get instanceKey(): Nullable;
    private _mergeKey;
    /**
     * This key is used to merge different meshes which have same key into one WebGL Draw Call.
     */
    set mergeKey(value: Nullable);
    get mergeKey(): Nullable;
    /**
     * The name of instance's class.
     */
    className(): string;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx this parameter has not supported external Serializer yet.
     * It may cause that this method can not be used directly.
     * @ignore
     */
    serialize(ctx: Serializer): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx this parameter has not supported external Deserializer yet.
     * It may cause that this method can not be used directly.
     * @ignore
     */
    deserialize(ctx: Deserializer): void;
    constructor(geometry?: G, material?: M | M[]);
    /**
     * Update the data which need be changed according to the camera's state and
     * attributes of {@link Drawable.updateRenderInfo| Drawable} before drawing this object.
     * @param {Camera3D} camera the camera which is used in current frame.
     * @param {number} viewHeight the height of canvas.
     */
    updateRenderInfo(camera: Camera3D, viewHeight: number): void;
    /**
     * If user change the data of geometry, use this method to refresh the data.
     */
    setGeometryChanged(): void;
    /**
     * If user change the data of geometry, use this method to refresh referring data.
     * @remarks See {@link Drawable.onReferencedGeometryContentChange| onReferencedGeometryContentChange()} for more details.
     */
    onReferencedGeometryContentChange(): void;
    /**
     * Copy the data to this object from source.
     * This method need override in derived classes to copy extended data.
     * @param {Mesh} source the data source.
     */
    copy(source: Mesh, recursive?: boolean): this;
    /**
     * Return a clone of this object.
     */
    clone(recursive?: boolean): Mesh;
    destroy(): void;
    /**
     * Get intersections between a casted {@link Ray| ray} and this Mesh.
     * The method {@link Raycaster.intersectObject| intersectObject()} will call this method, but the results are not ordered.
     * @param {Raycaster} raycaster the instance of Raycaster is used to get the data for calculation.
     * @param {Intersection} intersects the result will be stored here.
     */
    raycastJsImpl(raycaster: Raycaster, intersects: Intersection[]): void;
}

declare class ClippingShaderComponent extends SharedShaderComponent {
    className(): string;
    constructor(isSceneClipping?: boolean);
    private isSceneClipping;
    private get uniformName();
    private _clippingPlanes;
    get clippingPlanes(): Plane[];
    set clippingPlanes(value: Plane[]);
    updateClipping(): void;
    private transformedPlanes;
    get planeCount(): number;
    copy(other: ClippingShaderComponent): this;
    clone(): ClippingShaderComponent;
    updatePlane(camera: Camera3D): void;
    extendShaderShape(builder: ShaderBuilder): void;
    extendShaderShading(_builder: ShaderBuilder): void;
    updateShapeUniforms(program: WGLProgram): void;
    generateShaderKey(): string;
    computeShapeKey(): string;
    serialize(ctx: Serializer): void;
    deserialize(ctx: Deserializer): void | Promise;
}

declare class ShaderComponentRegistry {
    static global: Map;
    light: LightShaderComponent;
    dynamicForwardLight: LightShaderComponent;
    isDeferMode: boolean;
    clipping: ClippingShaderComponent;
    tooManyLightsForForward(): boolean;
    destroy(): void;
}

declare class PopShaderComponent extends ShaderComponent {
    className(): string;
    extendShaderShading(_builder: ShaderBuilder): void;
    extendShaderShape(builder: ShaderBuilder): void;
    computeShapeKey(): string;
    copy(_: PopShaderComponent): this;
    clone(): PopShaderComponent;
    serialize(_ctx: Serializer): void;
    deserialize(_ctx: Deserializer): void | Promise;
}

declare abstract class SceneMaterial extends Material {
    extendShaderShape(builder: ShaderBuilder, _: ShaderComponentRegistry): void;
    computeShapeKey(_: ShaderComponentRegistry): string;
    updateShapeUniforms(_1: WGLProgram, _: ShaderComponentRegistry): void;
}
declare abstract class SceneClipMaterial extends SceneMaterial {
    enableSceneClipping: boolean;
    extendShaderShape(builder: ShaderBuilder, r: ShaderComponentRegistry): void;
    generateShaderKey(r: ShaderComponentRegistry): string;
    computeShapeKey(r: ShaderComponentRegistry): string;
    updateShapeUniforms(p: WGLProgram, r: ShaderComponentRegistry): void;
    freeGPU(): void;
}
declare abstract class ScenePopLODMaterial extends SceneClipMaterial {
    pop: Nullable;
    extendShaderShape(builder: ShaderBuilder, r: ShaderComponentRegistry): void;
    computeShapeKey(r: ShaderComponentRegistry): string;
    generateShaderKey(r: ShaderComponentRegistry): string;
    copyBase(other: ScenePopLODMaterial): this;
}

declare abstract class BackgroundLikeMaterial extends Material {
    up: ReadonlyVector3;
    quat: ReadonlyVector4;
    extendShaderShape(builder: ShaderBuilder, _: ShaderComponentRegistry): void;
    computeShapeKey(_: ShaderComponentRegistry): string;
    updateShapeUniforms(program: WGLProgram, _: ShaderComponentRegistry): void;
}
interface DeferredMaterial extends Material {
    isSupportDeferred: true;
    extendEncodeDeferred(builder: ShaderBuilder): void;
    updateDeferredUniform(p: WGLProgram): void;
}

declare class GradientMaterial extends BackgroundLikeMaterial {
    skyColor: Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "g" | "r" | "b" | "isColor" | "equals" | "getHex" | "getSerializeData">>;
    groundColor: Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "g" | "r" | "b" | "isColor" | "equals" | "getHex" | "getSerializeData">>;
    power: number;
    scale: number;
    offset: number;
    className(): string;
    constructor();
    updateShadingUniforms(p: WGLProgram): void;
    extendShaderShading(builder: ShaderBuilder, _: any): void;
    copy(): this;
    clone(): GradientMaterial;
}

declare class SkyMaterial extends BackgroundLikeMaterial {
    private _luminance;
    private _turbidity;
    private _rayleigh;
    private _mieCoefficient;
    private _mieDirectionalG;
    get luminance(): number;
    set luminance(v: number);
    get turbidity(): number;
    set turbidity(v: number);
    get rayleigh(): number;
    set rayleigh(v: number);
    get mieCoefficient(): number;
    set mieCoefficient(v: number);
    get mieDirectionalG(): number;
    set mieDirectionalG(v: number);
    tEquirect: Nullable;
    className(): string;
    constructor();
    updateShadingUniforms(p: WGLProgram): void;
    extendShaderShading(b: ShaderBuilder, _: any): void;
    generateShaderKey(r: ShaderComponentRegistry): string;
    copy(): this;
    clone(): SkyMaterial;
    traverseTexture(visitor: (tex: Texture) => void): void;
}

declare class EnvMapMaterial extends BackgroundLikeMaterial {
    verticalRotation: number;
    horizonRotation: number;
    luma: number;
    tEquirect: Texture;
    reverseVertical: boolean;
    reverseHorizon: boolean;
    className(): string;
    constructor();
    updateShadingUniforms(p: WGLProgram): void;
    traverseTexture(visitor: (tex: Texture) => void): void;
    generateShaderKey(r: ShaderComponentRegistry): string;
    extendShaderShading(builder: ShaderBuilder, _: any): void;
    copy(): this;
    clone(): EnvMapMaterial;
}

declare enum BackgroundMode {
    BasicBackground = "basic",
    /**
     * @deprecated use BackgroundMode.BasicBackground
     */
    SolidColorBackground = "solid",
    SkyBackground = "sky",
    GradientBackground = "gradient",
    EnvMapBackground = "env"
}
interface SolidColorBackgroundParameter {
    color: Color;
    alpha: number;
}
interface GradientBackgroundParameter {
    skyColor: Color;
    groundColor: Color;
}
interface SkyBackgroundParameter {
    enableSkyMap: boolean;
    luminance: number;
    turbidity: number;
    rayleigh: number;
    mieCoefficient: number;
    mieDirectionalG: number;
}
interface EnvMapBackgroundParameter {
    texture: Texture;
    luma: number;
    verticalRotation: number;
    horizonRotation: number;
}
interface BasicBackgroundParameter {
    color: Color;
    alpha: number;
    texture: Texture;
}
interface BackgroundParameter {
    mode: BackgroundMode;
    parameter?: Partial;
}
/**
 * Draw background with a solid color.
 */
declare class SolidColorBackground implements Renderable {
    color: Color;
    alpha: number;
    constructor(color?: Color, alpha?: number);
    config(renderer: IRenderer): boolean;
    render(_: IRenderer): void;
}
/**
 * Draw background with a picture.
 */
declare class BasicBackground implements Renderable {
    color: Color;
    alpha: number;
    texture: Nullable;
    private quad;
    private copy;
    constructor(color?: Color, alpha?: number);
    config(renderer: IRenderer): boolean;
    render(renderer: IRenderer): void;
    destroy(): void;
}
declare class MeshBackground implements Renderable {
    protected box: Mesh;
    protected geometry: BufferGeometry;
    protected rotation: Quaternion;
    readonly material: T;
    constructor(material: T);
    get up(): Vector3;
    set up(up: Vector3);
    config(renderer: IRenderer): boolean;
    render(renderer: IRenderer): void;
    destroy(): void;
}
/**
 * Draw background with a gradient color.
 */
declare class GradientBackground extends MeshBackground {
    constructor();
}
/**
 * Draw background with a gray ground and blue sky.
 */
declare class SkyBackground extends MeshBackground {
    constructor();
    /**
     * @internal
     */
    enableSkyMap: boolean;
    /**
     * @internal
     */
    setSkyMapEnable(enable: boolean): void;
    /**
    * @internal
    */
    setSkyMap(texture: Nullable): void;
}
/**
 * Draw background with a picture.
 */
declare class EnvMapBackground extends MeshBackground {
    constructor();
}

interface IPopbufferInfo {
    version: number;
    attributes: IPopbufferAttributes;
    indices: Uint16Array | Uint32Array;
    vertices: Float32Array;
    normals: Float32Array;
    textures: Float32Array;
    blocks: IMetaBlock[];
    maxPrecision: number;
    levelPrecisions: number[];
    /**
     * @deprecated
     */
    currentVertexCount: number;
    /**
     * @deprecated
     */
    currentBlockFaceCounts: number[];
    /**
     * @deprecated
     */
    verticeDataLengthForEachLevel: any[];
}
interface IMetaBlock {
    index: number;
    name: string;
    start: number;
    count: number;
    minLevelStart: number;
    levelFaceCounts: number[];
    levelVerticesCounts: number[];
    levelFaceAccumulateCounts: number[];
    levelVerticesAccumulateCounts: number[];
}
interface INumber3 {
    x: number;
    y: number;
    z: number;
}
interface IPopbufferAttributes {
    boxMax: INumber3;
    boxMin: INumber3;
    vertexGridSize: number;
    vertexRepresentBit: INumber3;
    textureScale: number;
    normalScale: number;
    groupCount: number;
    blockNames: string[];
    faceCount: number;
    blockFaceCounts: number[];
    vertexCount: number;
}

interface Metadata {
    boxMin: Readonly;
    boxSizeMagnitude: number;
    vertexGridSize: number;
    vertexConstant: Readonly;
}
/**
 * This is a dedicated geometry for {@link PopMesh| PopMesh }.
 */
declare class PopBufferGeometry extends BufferGeometry {
    /**
     * Used to check type of this or extended instance.
     * This value should not be changed by user.
     */
    isPopBufferGeometry: boolean;
    /**
     * The attributes data which are stored into an object.
     * It is better to change this by {@link setModel| setModel }.
     */
    model: IPopbufferInfo;
    /**
     * An item of vertex array.
     */
    metadata: Metadata;
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(model?: IPopbufferInfo);
    /**
     * Return the name of specific group.
     * @param groupIndex the index of model.blocks.
     */
    getGroupNameByGroupIndex(groupIndex: number): string | undefined;
    /**
     * Return the name of the group which the specific vertex belongs to.
     * @param index the index of checked vertex.
     */
    getGroupNameByVertexIndex(index: number): string | undefined;
    /**
     * Change the attribute data and {@link model| model }.
     * @param model the given model data.
     */
    setModel(model?: IPopbufferInfo): void;
    /**
     * As the name shown.
     */
    updateBufferAttributeFromModelData(): void;
    private computeMetadata;
    /**
     * Copy the data to this object from source.
     * @param { PopBufferGeometry } source the data source.
     */
    copy(source: this): PopBufferGeometry;
    /**
     * Return a clone of this object.
     */
    clone(): PopBufferGeometry;
    /**
     * @ignore
     */
    serialize(ctx: Serializer): void;
    /**
     * @ignore
     */
    deserialize(ctx: Deserializer): void;
}

/**
 * Camera that uses perspective projection.
 * This projection mode is designed to mimic the way the human eye sees.
 * It is the most common projection mode used for rendering a 3D scene.
 */
declare class PerspectiveCamera extends Camera3D {
    /**
     * Check the type whether it belongs to PerspectiveCamera.
     * This value should not be changed by user.
     */
    readonly isPerspectiveCamera = true;
    private _isTwoPointPerspectiveViewEnabled;
    /**
     * This effect can elongate models when camera looks up or down.
     */
    get isTwoPointPerspectiveViewEnabled(): boolean;
    set isTwoPointPerspectiveViewEnabled(v: boolean);
    /**
     * Update the camera's {@link Object3D.matrixWorld| matrixWorld } and {@link matrixWorldInverse| matrixWorldInverse }.
     * @param {boolean} force Whether or not force to updates the matrix.
     */
    updateMatrixWorld(force?: boolean): void;
    private _fov;
    /**
     * Camera frustum vertical field of view, from bottom to top of view, in degrees.
     */
    get fov(): number;
    set fov(v: number);
    private _zoom;
    /**
     * Scale width and height of view frustum.
     */
    get zoom(): number;
    set zoom(v: number);
    private _near;
    /**
     * Distance from camera position to small plane of view frustum.
     */
    get near(): number;
    set near(v: number);
    private _far;
    /**
     * Distance from camera position to big plane of view frustum.
     */
    get far(): number;
    set far(v: number);
    private _focus;
    /**
     * Object distance used for stereoscopy and depth-of-field effects.
     * @defaultValue `10`.
     */
    get focus(): number;
    set focus(v: number);
    private _aspect;
    /**
     * Full screen width divided by its height in case of more view, this value equals to fov when there was only one viewer.
     */
    get aspect(): number;
    set aspect(v: number);
    /**
     * Frustum window specification or null.
     * This is set using the {@link setViewOffset| setViewOffset } method and cleared using {@link clearViewOffset| clearViewOffset }.
     */
    view: Nullable;
    /**
     * Film size used for the larger axis. Default is 35 (millimeters).
     * This parameter does not influence the projection matrix unless {@link filmOffset| filmOffset } is set to a nonzero value.
     */
    filmGauge: number;
    /**
     * Horizontal off-center offset in the same unit as {@link filmGauge| filmGauge }.
     * @defaultValue `0`.
     */
    filmOffset: number;
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(fov?: number, aspect?: number, near?: number, far?: number);
    /**
     * Copy the data to this camera instance from source.
     * This method need override in derived classes to copy extended data.
     * @param {PerspectiveCamera} source the data source.
     * @param {boolean} recursive if true, descendants of the object are also cloned. Default is true.
     */
    copy(source: PerspectiveCamera, recursive?: boolean): this;
    /**
     * The tangent value of camera frustum's vertical angle.
     */
    getPixelsOfDistOne(): number;
    /**
     * As name says
     */
    getDistanceWhenEachWorldUnitMatchScreenUnit(viewHeight: number): number;
    /**
     * Calculate how many screen pixel match one world unit at given distance.
     * @param {number} distance the distance from camera to object.
     * @param {number} viewHeight the hight of view window.
     */
    pixelsPerUnit(distance: number, viewHeight: number): number;
    /**
     * Set the origin and direction for ray.
     * @param {Ray} ray the calculate result will be set to this.
     * @param {Vector2} coords the position of window where the ray through out.
     */
    castRay(ray: Ray, coords: Vector2): void;
    /**
     * Sets the FOV by focal length in respect to the current {@link filmGauge | filmGauge }.
     * Values for focal length and film gauge must have the same unit.
     * @defaultValue The default film gauge is 35, so that the focal length can be specified for a 35mm (full frame) camera.
     */
    setFocalLength(focalLength: number): void;
    /**
     * Calculates the focal length from the current {@link fov | fov } and {@link filmGauge | filmGauge }.
     */
    getFocalLength(): number;
    /**
     * Returns the current vertical field of view angle in degrees considering {@link zoom | zoom }.
     */
    getEffectiveFOV(): number;
    /**
     * Returns the width of the image on the film. If .aspect is greater than or equal to one (landscape format), the result equals {@link filmGauge | filmGauge }.
     */
    getFilmWidth(): number;
    /**
     * Returns the height of the image on the film. If .aspect is less than or equal to one (portrait format), the result equals {@link filmGauge | filmGauge }.
     */
    getFilmHeight(): number;
    /**
     * Sets an offset in a larger frustum. This is useful for multi-window or multi-monitor/multi-machine setups.
     * For example, if you have 3x2 monitors and each monitor is 1920x1080 and the monitors are in grid like this: 

     * +---+---+---+ 

     * | A | B | C | 

     * +---+---+---+ 

     * | D | E | F | 

     * +---+---+---+ 

     * then for each monitor you would call it like this:
     * `
     * let w = 1920;
     * let h = 1080;
     * let fullWidth = w * 3;
     * let fullHeight = h * 2;
     *  // A
     * camera.setOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );
     *  // B
     * camera.setOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );
     *  // C
     * camera.setOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );
     *  // D
     * camera.setOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );
     *  // E
     * camera.setOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );
     *  // F
     * camera.setOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );
     * `
     * @tips there is no reason monitors have to be the same size or in a grid.
     * @param {number} fullWidth full width of multi-view setup.
     * @param {number} fullHeight full height of multi-view setup.
     * @param {number} x horizontal offset of sub-camera.
     * @param {number} y vertical offset of sub-camera.
     * @param {number} width width of sub-camera.
     * @param {number} height height of sub-camera.
     */
    setViewOffset(fullWidth: number, fullHeight: number, x: number, y: number, width: number, height: number): void;
    /**
     * Removes any offset set by the {@link setViewOffset | setViewOffset } method.
     */
    clearViewOffset(): void;
    /**
     * Updates the camera's {@link projectionMatrix | projectionMatrix } and {@link projectionMatrixInverse | projectionMatrixInverse }.
     * When user change the attribute such as far, top ...,
     * this method will have to be called for the changes to take effect.
     * @param { Object } jitter if jitters need to be applied on this camera, this parameter need to be given.
     */
    updateProjectionMatrix(jitter?: {
        offset: Vector2;
        canvas_size: Vector2;
    }): void;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx an instance used to store the data of scene objects.
     */
    serialize(ctx: Serializer): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx an instance give the method to take the data for attribute.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Return a cloned instance of this instance.
     */
    clone(recursive?: boolean): PerspectiveCamera;
}

declare class ShaderBlock {
    source: string;
    constructor(str: string);
}

interface UBOItem {
    value: Flattenable | number;
    offset: number;
    isDirty: boolean;
}
interface Flattenable {
    toArray(arrayLike: number[] | TypedArray$3, offset?: number): void;
    copy(other: any): void;
}
declare class UniformBlockObject {
    uniforms: ShaderInputDescriptor[];
    uniformArrays: UniformArrayDescriptor[];
    buffer: Nullable;
    isDirty: boolean;
    version: number;
    data: Map;
    arrayData: Map;
    readonly name: string;
    constructor(name: string);
    static spawn(name: string): UniformBlockObject;
    createItem(name: string, type: WebGLShaderDataType, defaultValue: any): this;
    createItemArray(name: string, type: WebGLShaderDataType, length: number, defaultValue: any): this;
    getDescriptor(): UniformBlockDescriptor;
    setItem(name: string, value: any): void;
    getItem(name: string): any;
    getUBOBuffer(): Float32Array;
    private setupLayout;
    updateWebGL(program: WGLProgram): void;
    createShaderHeader(supportUBO: boolean): string;
}

declare abstract class LightableMaterial extends ScenePopLODMaterial {
    isLightableMaterial: boolean;
    flatShadingNormal: boolean;
    freeGPU(): void;
    extendShaderShading(b: ShaderBuilder, _r: ShaderComponentRegistry): void;
    extendShaderShape(b: ShaderBuilder, r: ShaderComponentRegistry): void;
    getLightSystem(registry: ShaderComponentRegistry): LightShaderComponent;
    updateShadingUniforms(program: WGLProgram, r: ShaderComponentRegistry): void;
    generateShaderKey(r: ShaderComponentRegistry): string;
}

declare abstract class Texture2DLayer implements WebGLUploadable {
    __brand: 'WebGLUploadable';
    width: number;
    height: number;
    setWidth(width: number): this;
    setHeight(height: number): this;
    setSize(width: number, height: number): this;
    /**
     * @internal
     */
    abstract uploadWebGL(ctx: WebGLTextureUploadCtx, target: number, level: number, needPOT: boolean): SourceTextureLayerWebGLUploadResult;
}
declare class Texture2DCommonLayer extends Texture2DLayer {
    source: Texture2DLayerSource;
    format: WebGLPixelFormat;
    type: TextureDataType;
    constructor(source: Texture2DLayerSource, width?: number, height?: number, isHTMLSource?: boolean);
    setSource(source: Texture2DLayerSource, width?: number, height?: number, isHTMLSource?: boolean): void;
    ser(): any;
    static create(source: Texture2DLayerSource, width?: number, height?: number, isHTMLSource?: boolean): Texture2DCommonLayer;
    static createAsync(source: HTMLImageElement): Promise;
    setFormat(format: WebGLPixelFormat): this;
    setType(type: TextureDataType): this;
    /**
     * @internal
     */
    uploadWebGL(ctx: WebGLTextureUploadCtx, target: number, level: number, needPOT: boolean): SourceTextureLayerWebGLUploadResult;
    /**
     * @internal
     */
    getAutoGeneratedMipmapFromCurrentLevel(): number;
}
declare class Texture2D extends LegacySourceTexture {
    static get default(): Texture2D;
    className(): string;
    source: TextureMipmapGroup;
    get main(): Texture2DCommonLayer;
    get width(): number;
    get height(): number;
    constructor(source: TextureMipmapGroup);
    static createByMainLayer(layer: Texture2DCommonLayer): Texture2D;
    static createByMainLayerSource(source: Texture2DLayerSource, format?: WebGLPixelFormat, type?: TextureDataType, width?: number, height?: number, isHTMLSource?: boolean): Texture2D;
    /**
     * @internal
     */
    uploadWebGLImpl(ctx: WebGLTextureUploadCtx, disableCustomMipmap: boolean, needPOT: boolean): SourceTextureWebGLUploadResult;
    /**
     * @internal
     */
    canAutoGenerateMipmap(): boolean;
    protected getAutoGeneratedMipmapByteSize(): number;
    serialize(ctx: Serializer): void;
    deserialize(ctx: Deserializer): Promise;
}
declare type Texture2DLayerSource = HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | OffscreenCanvas | ImageData | ImageBitmap | TypedArray$3;

/**
 * A new texture base with immutable size after creation.
 * TextureV2 will represent any texture type(2D/2DArray/3D/Cube and etc..).
 */
declare abstract class TextureV2 extends Texture {
    readonly format: TextureFormat$1;
    readonly width: number;
    readonly height: number;
    readonly depthOrArrayLayers: number;
    readonly sampleCount: number;
    readonly levels: number;
    readonly mipmaps: boolean;
    /**
    * @internal
    */
    readonly glFormat: WebGLTextureFormat;
    readonly byteSize: number;
    /**
     * @internal
     */
    readonly isPot: boolean;
    constructor(dimension: TextureDimension$1, viewDimension: TextureViewDimension$1, format: TextureFormat$1, width: number, height: number, depthOrArrayLayers: number, sampleCount: number, mipmaps: boolean, isInternal: boolean);
    /**
     * @internal
     */
    get isLayeredTexture(): boolean;
    /**
     * @internal
     */
    get isCube(): boolean;
    /**
     * @internal
     */
    uploadWebGL(ctx: WebGLTextureUploadCtx): number;
    /**
     * @internal
     */
    protected contextCheck({ isWebGL1 }: WebGLTextureUploadCtx): boolean;
    /**
     * allocate gpu memory for texture
     * @internal
     */
    protected allocate(ctx: WebGLTextureUploadCtx): boolean;
    /**
     * do texture upload
     * @internal
     */
    protected abstract upload(ctx: WebGLTextureUploadCtx): void;
}

declare type MeshPhongMaterialParameters = MaterialParameters & ConvertMaterialParameters, 'color' | 'texture' | 'specular' | 'opacity' | 'opacityTex' | 'shininess' | 'specularStrength' | 'uvTransform'>>;
/**
 * This material can apply illumination on model surface, which makes model looks shiny and specular.
 * Performance will generally be greater when using this material over the {@link PBRMaterial| PBRMaterial}, at the cost of some graphical accuracy.
 */
declare class MeshPhongMaterial$1 extends LightableMaterial implements DeferredMaterial {
    /**
     * @internal
     */
    static DefaultSceneClipEnabled: boolean;
    readonly isSupportDeferred: true;
    static constructMaterialFromGBufferForLight(): string;
    static extendDeferredLight(builder: ShaderBuilder): void;
    extendEncodeDeferred(builder: ShaderBuilder): void;
    updateDeferredUniform(p: WGLProgram): void;
    /**
     * The name of instance's class.
     */
    className(): string;
    /**
     * Check the type whether it belongs to MeshPhongMaterial.
     * This value should not be changed by user.
     */
    isMeshPhongMaterial: boolean;
    constructor(p?: MeshPhongMaterialParameters);
    private UBO;
    /**
     * The basic color of object.
     * The final color on screen is also influenced by color and intensity of light and other parameters.
     */
    protected _color: ReadonlyColor;
    get color(): ReadonlyColor;
    set color(v: ReadonlyColor);
    /**
     * Use texture cover object, if it is given.
     */
    texture: Nullable;
    /**
     * Apply opacity texture to change the transparency on object's some part.
     * The opacity is decided by the value of texture's red channel.
     */
    opacityTex: Nullable;
    /**
     * The color of specular. This value and color of light influence the color of the edge part of specular area together.
     */
    protected _specular: ReadonlyColor;
    get specular(): ReadonlyColor;
    set specular(v: ReadonlyColor);
    /**
     * Opacity decide the transparency of whole surface of object.
     */
    protected _opacity: number;
    get opacity(): number;
    set opacity(v: number);
    /**
     * This value determines the area of specular reflect and the ratio of white part.
     */
    protected _shininess: number;
    get shininess(): number;
    set shininess(v: number);
    /**
     * This value determines the area of specular reflection. This influence is similar with {@link Light.intensity| intensity} of light.
     */
    protected _specularStrength: number;
    get specularStrength(): number;
    set specularStrength(v: number);
    /**
     * If set to true, uv used for opacityTex is independent
     * @internal
     */
    isOpacityTexUseIndependentUv: boolean;
    /**
     * Change the corresponding attribute according to the values of given {@link MeshPhongMaterialParameters| parameters}.
     * @param {MeshPhongMaterialParameters} values a object of specified type contains parameters.
     */
    setValues(values?: MeshPhongMaterialParameters): void;
    traverseTexture(visitor: (tex: Texture) => void): void;
    /**
     * Execute the given method for every ubo.
     * @param {function} _visitor a method to process ubo.
     */
    traverseUBO(visitor: (ubo: UniformBlockObject) => void): void;
    /**
     * Generate a key for texture of material, and engine will recompile shader if the texture added or removed.
     * This method may override in extended class.
     * @ignore
     */
    generateShaderKey(r: ShaderComponentRegistry): string;
    /**
     * Copy the data to this instance from other instance.
     * @param {MeshPhongMaterial} other the source of copied data
     */
    copy(other: MeshPhongMaterial$1): this;
    /**
     * Return a cloned instance of this class.
     */
    clone(): MeshPhongMaterial$1;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx an instance used to store the data of scene objects.
     */
    serialize(ctx: Serializer): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx an instance give the method to take the data for attribute.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Change the uv data by this matrix.
     */
    _uvTransform: Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "equals" | "getSerializeData" | "getNumberCount" | "toArray" | "elements" | "applyToBufferAttribute" | "determinant" | "transposeIntoArray" | "applyToArray" | "applyInverse" | "decompose">>;
    get uvTransform(): ReadonlyMatrix3;
    set uvTransform(v: ReadonlyMatrix3);
    /**
     * @ignore
     */
    updateShadingUniforms(program: WGLProgram, r: ShaderComponentRegistry): void;
    /**
     * @ignore
     */
    extendShaderShading(b: ShaderBuilder, r: ShaderComponentRegistry): void;
    /**
     * @ignore
     */
    generateMaterialForLight(): string;
    /**
     * @ignore
     */
    RE_Direct(): string;
    /**
     * @ignore
     */
    RE_Direct_RectArea(): string;
    /**
     * @ignore
     */
    RE_Direct_DiskArea(): string;
    /**
     * @ignore
     */
    RE_IndirectDiffuse(): string;
}

/**
 * This is a spacial mesh to draw content in one WebGL Drawcall.
 */
declare class PopMesh extends Mesh {
    /**
     * Check the type whether it belongs to PopMesh.
     */
    readonly isPopMesh = true;
    /**
     * The type of this instance.
     */
    readonly type = "PopMesh";
    /**
     * Record the LOD level of last update.
    */
    oldLevelFactor: number;
    /**
     * Record the frame id of last updating LOD level.
    */
    LODUpdateId: number;
    /**
     * a unique key of the Mesh. When this Mesh is merged, this key will be update.
    */
    popMergeCacheKey: Nullable;
    /**
     * Switch of LOD.
     */
    isLODEnabled: boolean;
    /**
     * The name of instance's class.
     */
    className(): string;
    /**
     * @internal
     */
    lodInfo: Float32Array;
    constructor(geometry: PopBufferGeometry, material: MeshPhongMaterial$1[]);
    /**
     * This is an override method to update render data for optimization.
     * This method is used to assign data from {@link geometry| geometry } and {@link material| material } to
     * {@link renderGeometry| renderGeometry } and {@link renderMaterial| renderMaterial }.
     */
    updateRenderEntity(): void;
    /**
     * Create a clone of this instance.
     */
    clone(): PopMesh;
}

declare class InstancedBufferGeometry$1 extends BufferGeometry {
    /**
     * Used to check type of this or extended instance.
     * This value should not be changed by user.
     */
    isInstancedBufferGeometry: boolean;
    /**
     * The type of this instance.
     */
    type: string;
    /**
     * The number of instanced object.
     */
    private _instancedCount;
    get instancedCount(): number;
    set instancedCount(v: number);
    /**
     * Copy the data to this object from source.
     * This method need override in derived classes to copy extended data.
     * @param {InstancedBufferGeometry} source the data source.
     */
    copy(source: InstancedBufferGeometry$1): this;
    /**
     * Create a clone of this instance.
     */
    clone(): InstancedBufferGeometry$1;
}

/**
 * A special version of Mesh with instanced rendering supported.
 * Use InstancedMesh if you have to render a large number of objects with the same geometry and material but with different world transformations.
 * The usage of InstancedMesh will help you to reduce the number of draw calls and thus improve the overall rendering performance in your application.
 */
declare class InstanceMesh extends Mesh {
    className(): string;
    private bbxMap;
    /**
     * @internal
     */
    proxyedMeshes: Mesh[];
    instanceMatrixBuffer: Float32Array;
    /**
     * @internal
     */
    get firstProxyedMesh(): Mesh>;
    /**
     * A key mark let engine know this object need be rendered as instance,
     * which should not be changed by the users.
     * @internal
    */
    readonly isInstance = true;
    /**
     * Record the LOD level of last update.
     * @internal
    */
    oldLevelFactor: number;
    /**
     * Record the frame id of last updating LOD level.
     * @internal
    */
    LODUpdateId: number;
    /**
     * @internal
     */
    lodInfo: Float32Array;
    /**
     * @internal
     */
    instancedGeometry: BufferGeometryBase;
    /**
     * @internal
     * max value of the proxyed meshes...
     */
    maxScaleOnAxis: number;
    constructor(meshes: Mesh[]);
    private updateInstanceMatrix;
    /**
     * Update the data which needs be changed according to the camera's state and
     * attributes of {@link Drawable.updateRenderInfo| Drawable} before drawing this object.
     * @param {Camera3D} camera the camera which is used in current frame.
     * @param {number} viewHeight the height of canvas.
     */
    updateRenderInfo(camera: Camera3D, viewHeight: number): void;
    updateSource(meshes: Mesh[]): void;
    private updateTransforms;
    /**
     * Update the rendering date from this instance.
    */
    updateRenderEntity(): void;
    /**
     * Clear the rendering data of engine.
    */
    updateInstance(): void;
    raycastJsImpl(raycaster: Raycaster, intersects: Intersection[]): void;
    destroy(): void;
    clone(recursive?: boolean): InstanceMesh;
}

declare type Mapper = (drawcall: T) => T | null;
interface Drawcall {
    object: Drawable;
    range: Nullable;
    material: Material;
    geometry: BufferGeometryBase;
}
declare class FilteredDrawcallList implements Renderable {
    readonly list: ProjectedDrawcallList;
    filter: IPipelineFilter;
    constructor(list: ProjectedDrawcallList);
    config(_: IRenderer): boolean;
    render(renderer: IRenderer, renderObjectsType?: RenderObjectsType): void;
}
interface DrawcallListClassifyResult {
    opaque: Drawcall[];
    transparent: Drawcall[];
    extraDrawcallList: Map;
}
interface DrawcallListClassifyType {
    $TYPE_NAME: string;
    (opaque: Drawcall[], transparent: Drawcall[]): DrawcallListClassifyResult;
}
declare enum RenderObjectsType {
    Default = 0,
    Opaque = 1,
    Transparent = 2,
    OIT = 3,
    AfterOIT = 4
}
declare class ProjectedDrawcallList implements Renderable {
    readonly list: DrawableList;
    opaque: Drawcall[];
    transparent: Drawcall[];
    private camera;
    extraDrawcallList: Map;
    constructor(list: DrawableList, opaque: Drawcall[], transparent: Drawcall[], camera: Camera3D);
    useOnce: boolean;
    private destroyed;
    destroy(): void;
    private renderObjects;
    config(_: IRenderer): boolean;
    getRenderListLength(type: RenderObjectsType): number;
    render(renderer: IRenderer, renderObjectsType?: RenderObjectsType, filter?: IPipelineFilter): void;
    filterBy(f: () => IPipelineFilter): FilteredDrawcallList;
}
declare class DrawableList {
    private destroyed;
    private _lodEnabled;
    set lodEnabled(v: boolean);
    get lodEnabled(): boolean;
    destroy(): void;
    list: Drawable[];
    push(d: Drawable): void;
    filter(f: () => IPipelineFilter, forceExecJS?: boolean): DrawableList;
    filterMap(f: Mapper): DrawableList;
    project(camera: Camera3D, isCulledByCamera?: boolean, viewHeight?: number, classifyType?: DrawcallListClassifyType, enableLights?: boolean): ProjectedDrawcallList;
    updateRenderInfoInList(camera: Camera3D, viewHeight: number): void;
    updateLODs(camera: Camera3D, viewHeight: number): this;
    forEach(f: (item: Drawable, index: number) => any): void;
    getCameraClosestDistance(camera: PerspectiveCamera): number;
}

declare abstract class MaterialDispatcher extends BaseElement {
    constructor(skip?: boolean);
    destroy(): void;
    update(): void;
    abstract className(): string;
    abstract dispatch(renderer: Renderer, geometry: BufferGeometryBase, material: Material, object: Drawable): Nullable;
}

/**
 * Make a cone volume for calculating intersection.
 */
declare class Cone {
    /**
     * The position of peak.
     */
    tip: Vector3;
    /**
     * The angle of cone in vertical field.
     */
    fov: number;
    /**
     * The scale modification for fov.
     */
    aspect: number;
    /**
     * The bottom plane will be vertical to this vector.
     */
    direction: Vector3;
    private _theta;
    private _tanTheta;
    sinTheta: number;
    cosTheta: number;
    constructor(tip?: Vector3, fov?: number, direction?: Vector3, aspect?: number);
    /**
     * Update the cone's corresponding attributes by given parameters.
     */
    update(tip?: Vector3, fov?: number, direction?: Vector3, aspect?: number): this;
    /**
     * Check the intersection of this cone and given sphere.
     */
    isSphereOutsideCone(sphere: Sphere): boolean;
    /**
     * Creates a new clone of the Cone.
     */
    clone(): Cone;
    /**
     * Copy the data to this object from source.
     * This method need override in derived classes to copy extended data.
     * @param {Geometry} source the data source.
     */
    copy(other: Cone): Cone;
}

interface IPipelineFilter {
    $PARAM: any;
    $TYPE_NAME: string;
    (o: T): boolean;
}

declare class HashKeyBuilder {
    private key;
    private static instance;
    getKey(): string;
    reset(): this;
    bool(item: boolean): this;
    hasItem(item: Nullable): this;
    isTexture(t: any): this;
    raw(item: any): this;
    static getInstance(): HashKeyBuilder;
}

declare class CubeCamera {
    cameras: PerspectiveCamera[];
    static cubeDirections: Vector3[];
    static cubeUps: Vector3[];
    constructor(fov?: number, aspect?: number, near?: number, far?: number);
    update(worldMatrix: Matrix4): void;
    destroy(): void;
}

declare class SpotShadow extends SingleProjectShadow {
    customNear: number;
    customFar: number;
    isAutoComputeNearFar: boolean;
    shadowCameraNear: number;
    shadowCameraFar: number;
    enableAutoBias: boolean;
    captureScale: Vector2;
    constructor(light: SpotLight);
    className(): string;
    copy(other: SpotShadow): void;
    extendsShader(builder: ShaderBuilder, length: number): void;
    extendsShaderDeferred(builder: ShaderBuilder): void;
    updateSpotNearFar(fullList: DrawableList, light: SpotLight): void;
    updateCameraAndShadowMatrices(light: SpotLight): void;
    updateUniformsImpl(program: WGLProgram, prefix: string): void;
    deserialize(ctx: Deserializer): void;
    serialize(ctx: Serializer): void;
}

/**
 * This light gets emitted from a single point in one direction,
 * along a cone that increases in size the further from the light it gets.
 */
declare class SpotLight extends Light {
    viewMatrix: Matrix4;
    invViewMatrix: Matrix4;
    static get DEFAULT_TARGET(): Object3D;
    /**
     * The target is a point in world space used to calculate the direction of light.
     */
    private _target;
    get target(): Object3D;
    set target(t: Object3D);
    private _distance;
    /**
     * Maximum extent of the spotlight, in radians, from its direction. Should be no more than Math.PI/2.
     * @defaultValue `Math.PI/3`
     */
    angle: number;
    /**
     * Percent of the spotlight cone that is attenuated due to penumbra. Takes values between zero and 1.
     * @defaultValue `0`
     */
    penumbra: number;
    /**
     * The intensity scale of IES file.
     * @defaultValue `1`
     */
    iesIntensityScale: number;
    /**
     * Resolution of ies texture.
     * @defaultValue `Vector2(182, 1)`
     */
    iesTextureResolution: Vector2;
    /**
     * The amount the light dims along the distance of the light
     * In physically correct mode, decay = 2 leads to physically realistic light falloff.
     * @defaultValue `1` representing the intensity do not decay with distance increasing.
     */
    decay: number;
    isIESEnabled: boolean;
    /**
     * To support IES, spotLight set isRotationModeOn as true to calculate intensity according to rotation of light.
     * @defaultValue `false` calculate intensity according to target of light.
     */
    isRotationModeOn: boolean;
    /**
     * Check the type whether it belongs to PerspectiveCamera.
     * This value should not be changed by user.
     */
    isSpotLight: boolean;
    defaultDirection: Vector3;
    direction: Vector3;
    private uniforms;
    shadow: SpotShadow;
    private _textureIES_inner;
    protected _textureIES: T;
    get textureIES(): Nullable;
    set textureIES(value: Nullable);
    isShadowNeedsUpdate: boolean;
    private _up;
    /**
     * @internal
     */
    cone: Cone;
    destroy(): void;
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(color?: number | string, intensity?: number, distance?: number, angle?: number, penumbra?: number, decay?: number, isIESEnabled?: boolean, textureIES?: T, iesIntensityScale?: number, iesTextureResolution?: Vector2);
    /**
     * The light's power.
     * In physically correct mode, the luminous power of the light measured in lumens.
     * This is directly related to the {@link intensity | intensity } in the ratio
     */
    get power(): number;
    set power(power: number);
    getIntensity(): number;
    /**
     * When distance is zero, light does not attenuate.
     * When distance is non-zero, light will attenuate linearly from maximum intensity at the light's position down to zero at this distance from the light.
     */
    get distance(): number;
    set distance(dis: number);
    /**
     * Copy the data to this light instance from source.
     * This method need override in derived classes to copy extended data.
     * @param {SpotLight} source the data source.
     * @param {boolean} recursive if true, descendants of the object are also cloned. Default is true.
     */
    copy(source: SpotLight, recursive?: boolean): this;
    clone(recursive?: boolean): SpotLight;
    getDirection(): Vector3;
    /**
     * @ignore
     */
    refreshUniforms(viewMatrix: Matrix4): void;
    updateUniformForForward(program: WGLProgram, index: number): void;
    updateUniformForDefer(program: WGLProgram): void;
    updateUniformByPrefix(program: WGLProgram, lightPrefix: string, shadowPrefix: string): void;
    static getHeader(isArray: boolean): "\n                uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n                uniform sampler2D spotIES[ NUM_SPOT_LIGHTS ];\n            " | "\n                uniform SpotLight spotLight;\n                uniform sampler2D spotLightIES;\n            ";
    /**
     * @ignore
     */
    static getLightCollectShader(): string;
    /**
     * @ignore
     */
    static getShaderInclude(): ShaderBlock;
    getIESMapOrDefault(): Texture2D | T;
    updateCone(): void;
    isDrawableOutsideLightVolume(drawable: Drawable): boolean;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx an instance give the method to take the data for attribute.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx an instance used to store the data of scene objects.
     */
    serialize(ctx: Serializer): void;
}

interface Size$1 {
    width: number;
    height: number;
    depthOrArrayLayers?: number;
}
declare type ResizeFN = (size: Size$1) => Size$1;

declare class SceneAdaptorDispatcher {
    adaptor: SceneAdaptor;
    setAdaptor(a: SceneAdaptor): void;
    get scene(): Scene3D;
    get camera(): Camera3D;
    get origin(): DrawableList;
    get default(): () => ProjectedDrawcallList;
    get OIT(): () => ProjectedDrawcallList;
    get static(): () => ProjectedDrawcallList;
    get dynamic(): () => ProjectedDrawcallList;
    get overlay(): () => ProjectedDrawcallList;
    syncDirectionalShadowLayers(i: number): () => void;
    isDirectionalShadowRequireUpdate(i: number): () => boolean;
    getDirectionalShadowMapSize(i: number): ResizeFN;
    renderDirectionalShadow(i: number, useProxy: boolean): (renderer: RendererAdaptor) => void;
    returnDirectionalShadowResult(i: number): (r: PassExecuteCtx) => void;
    syncSpotShadowLayers(i: number): () => void;
    isSpotShadowRequireUpdate(i: number): () => boolean;
    getSpotShadowMapSize(i: number): ResizeFN;
    renderSpotShadow(i: number, useProxy: boolean): (renderer: RendererAdaptor) => void;
    returnSpotShadowResult(i: number): (r: PassExecuteCtx) => void;
    syncPointShadowLayers(i: number): () => void;
    isPointShadowRequireUpdate(i: number): () => boolean;
    getPointShadowMapSize(i: number): ResizeFN;
    getPointShadowPassContent(useProxy: boolean): () => DrawableList;
    getPointShadowPassContentUnfiltered(): () => DrawableList;
    getAndUpdatePointCamera(i: number): () => CubeCamera;
    returnPointShadowResult(i: number): (r: PassExecuteCtx) => void;
}
declare class SceneAdaptor {
    scene: Scene3D;
    camera: Camera3D;
    constructor(scene: Scene3D, camera: Camera3D);
    get origin(): DrawableList;
    get proxied(): DrawableList;
    private cachedDefault;
    get default(): ProjectedDrawcallList;
    private cachedOIT;
    get OIT(): ProjectedDrawcallList;
    private cachedStatic;
    get static(): ProjectedDrawcallList;
    private cachedDynamic;
    get dynamic(): ProjectedDrawcallList;
    private cachedOverlay;
    get overlay(): ProjectedDrawcallList;
    getDirectionalShadowMapCaster: (light: DirectionalLight, useProxy: boolean) => ProjectedDrawcallList;
    getDirectionalShadowMapCasterUnfiltered: (light: DirectionalLight) => ProjectedDrawcallList;
    getSpotShadowMapCaster: (light: SpotLight, useProxy: boolean) => ProjectedDrawcallList;
    getSpotShadowMapCasterUnfiltered: (light: SpotLight) => ProjectedDrawcallList;
    destroy(): void;
}

declare abstract class DAGNode {
    readonly name: string;
    private readonly uid;
    protected toNodes: Set;
    protected fromNodes: Set;
    constructor(name: string);
    private addFromRef;
    private removeFromRef;
    private addToRef;
    private removeToRef;
    depend(node: DAGNode): this;
    connect(node: DAGNode): this;
    disconnect(node: DAGNode): this;
    disconnectAll(to?: boolean, from?: boolean): this;
    traverseDFS(callback: (node: DAGNode) => void, visited?: Set, actives?: Set): void;
    private fulfills;
    getTopologicalSortedList(): DAGNode[];
}

declare abstract class ResourceNode extends DAGNode {
    isKeepContent: boolean;
    keepContent(): this;
}

declare abstract class RenderAttachmentNode extends ResourceNode {
    private _width;
    get width(): number;
    private _height;
    get height(): number;
    depthOrArrayLayers: number;
    dimension: TextureViewDimension$1;
    multiSample: boolean;
    resizeFn: ResizeFN;
    abstract get formatKey(): string;
    updateSize(size: Size$1): void;
}
declare class RenderColorAttachmentNode extends RenderAttachmentNode {
    format: TextureFormat$1;
    enableMipmap: boolean;
    sampler: SamplerDescriptor;
    get formatKey(): string;
    constructor(name?: string);
    modify(fn: (node: RenderColorAttachmentNode) => void): this;
    setFilter(linearFilter: boolean, mipmap?: boolean): this;
}
declare class RenderDepthAttachmentNode extends RenderAttachmentNode {
    enableTexture: boolean;
    enableStencil: boolean;
    sampler: SamplerDescriptor;
    get formatKey(): string;
    constructor(name?: string);
    modify(fn: (node: RenderDepthAttachmentNode) => void): this;
}

declare class RenderTargetNode extends DAGNode {
    readonly isScreenNode: boolean;
    width: number;
    height: number;
    depthOrArrayLayers: number;
    multiSample: boolean;
    dimension: TextureViewDimension$1;
    resizeFn: ResizeFN;
    colorAttachments: RenderColorAttachmentNode[];
    depthAttachment?: RenderDepthAttachmentNode;
    constructor(name: string, isScreenNode?: boolean);
    modify(fn: (node: RenderTargetNode) => void): this;
    keepContent(): this;
    resize(fn: ResizeFN): this;
    enableMultiSample(): this;
    disableStencil(): this;
    setFilter(linearFilter: boolean, mipmap?: boolean, range?: number[]): this;
    attach(node: RenderAttachmentNode, attachIndex?: number): this;
    from(node: PassNode | Array): this;
    private checkAttachmentNode;
    check(): boolean;
    updateSize(size: Size$1): void;
}

interface ConfigCell$1 {
    get: () => T;
    set: (value: T) => void;
}
interface ConfigCellObject {
    [key: string]: ConfigCell$1 | ConfigCellObject;
}
interface IEffectConfig {
    isPerformanceSlow: boolean;
    planarShadowEnabled: boolean;
    planarShadowReady: boolean;
    taaEnabled: boolean;
    taaStable: boolean;
}
interface DrivenCullingConfig {
    frustumCullingEnabled: boolean;
    occlusionCullingEnabled: boolean;
    detailCullingEnabled: boolean;
    layersCullingEnabled: boolean;
    triCullingEnabled: boolean;
    occlusionCullingBias: number;
}
declare enum TextureCompression {
    None = 0,
    BC3 = 1,
    BC3HighQuality = 2,
    BC7 = 3
}
interface GpuDrivenConfig {
    enabled: boolean;
    requested: boolean;
    textureCompression: TextureCompression;
}
/**
 * some global rendering config.
 */
interface RenderingConfig {
    tlsFlags: number;
    gpuDriven: GpuDrivenConfig;
    MSAA: boolean;
}
interface PipelineContext {
    renderingConfig: RenderingConfig;
    drivenCullingConfig: DrivenCullingConfig;
}
declare abstract class PipelinePlugin {
    protected readonly scene: SceneAdaptorDispatcher;
    protected readonly renderer: RendererAdaptor;
    protected readonly IS_SUPPORT_DEPTH_TEXTURE: boolean;
    protected get IS_WEBGL2(): boolean;
    protected get IS_WEBGPU(): boolean;
    protected get IS_ADVANCED_BACKEND(): boolean;
    abstract readonly PLUGIN_NAME: string;
    get envSupported(): boolean;
    protected _enabled: boolean;
    get enabled(): boolean;
    set enabled(v: boolean);
    get shouldRender(): boolean;
    constructor(scene: SceneAdaptorDispatcher, renderer: RendererAdaptor);
    abstract destroy(): void;
    abstract updateFrameSize(width: number, height: number): void;
    abstract updateEffect(scene: SceneAdaptor, isFrameStable: boolean, isCameraStable: boolean, effectConfig: IEffectConfig): void;
    abstract updateGraphHash(hasher: HashKeyBuilder): void;
    abstract updateRenderGraph(graph: RenderGraph, context: PipelineContext, depthPyramid: RenderTargetNode): void;
    abstract createConfig(): ConfigCellObject;
}

declare class ColorShaderComponent extends ShaderComponent {
    color: ReadonlyColor;
    texture: Nullable;
    constructor();
    className(): string;
    extendShaderShading(builder: ShaderBuilder): void;
    updateShadingUniforms(program: WGLProgram): void;
    copy(other: ColorShaderComponent): this;
    clone(): ColorShaderComponent;
    serialize(ctx: Serializer): void;
    deserialize(ctx: Deserializer): void;
}

declare class AlphaShaderComponent extends ShaderComponent {
    opacity: number;
    texture: Nullable;
    constructor();
    className(): string;
    extendShaderShading(builder: ShaderBuilder): void;
    updateShadingUniforms(program: WGLProgram): void;
    copy(other: AlphaShaderComponent): this;
    clone(): AlphaShaderComponent;
    deserialize(ctx: Deserializer): void;
    serialize(ctx: Serializer): void;
}

declare type MeshBasicMaterialParameters = MaterialParameters & {
    color?: number | string | Color;
    opacity?: number;
    texture?: T;
    uvTransform?: ReadonlyMatrix3;
    enableVertexColor?: boolean;
};
/**
 * A material for drawing geometries in a simple shaded way.
 * This material is not affected by lights.
 */
declare class MeshBasicMaterial$1 extends SceneClipMaterial {
    isMeshBasicMaterial: boolean;
    /**
     * The basic color of object. User can set texture by this.
     * @tips change the color by {@link setValues| setValues()} that is a better way.
     */
    readonly color: ColorShaderComponent;
    /**
     * The Transparency of object.
     * @tips change the alpha by {@link setValues| setValues()} that is a better way.
     */
    readonly alpha: AlphaShaderComponent;
    /**
     * Change the uv data by this matrix.
     */
    uvTransform: Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "equals" | "getSerializeData" | "getNumberCount" | "toArray" | "elements" | "applyToBufferAttribute" | "determinant" | "transposeIntoArray" | "applyToArray" | "applyInverse" | "decompose">>;
    enableVertexColor: boolean;
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(p?: MeshBasicMaterialParameters);
    /**
     * Change the corresponding attribute according to the values of given {@link MeshBasicMaterialParameters| parameters}.
     * @param {MeshBasicMaterialParameters} values a object of specified type contains parameters.
     */
    setValues(values?: MeshBasicMaterialParameters): void;
    /**
     * @ignore
     */
    extendShaderShading(builder: ShaderBuilder): void;
    traverseTexture(visitor: (tex: Texture) => void): void;
    /**
     * Generate a key for texture of material, and engine will refresh texture if it is changed.
     * This method may override in extended class.
     * @ignore
     */
    generateShaderKey(r: ShaderComponentRegistry): string;
    /**
     * @ignore
     */
    updateShadingUniforms(program: WGLProgram): void;
    /**
     * Copy the data to this instance from other instance.
     * @param {MeshBasicMaterial} other the source of copied data
     */
    copy(other: MeshBasicMaterial$1): this;
    /**
     * Return a cloned instance of this class.
     */
    clone(): MeshBasicMaterial$1;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx an instance used to store the data of scene objects.
     */
    serialize(ctx: Serializer): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx an instance give the method to take the data for attribute.
     */
    deserialize(ctx: Deserializer): void;
}

declare class ForwardPlugin extends PipelinePlugin {
    eventDispatcher: EventDispatcher;
    readonly PLUGIN_NAME = "forward";
    protected _enabled: boolean;
    private solidEnabled;
    private solidColor;
    private solidLightMaterialEnabled;
    private solidBasicMaterial;
    private solidPhongMaterial;
    private toonEnabled;
    private toonMaterial;
    private _oitEnabled;
    private get oitEnabled();
    private oitMaterial;
    private mixOITMaterial;
    private _staticFrameCacheEnabled;
    private staticFrameCacheActive;
    private get staticFrameCacheEnabled();
    private sceneId;
    private frameSyncId;
    private get hasStaticCacheFrame();
    private copyMaterial;
    private _planarShadowEnabled;
    private _planarShadowActive;
    private _planarShadowDelay;
    private get planarShadowEnabled();
    private set planarShadowEnabled(value);
    private planarShadowLastActiveTime;
    private planarShadowIntensity;
    private get planarShadowReady();
    private planarShadowOrderIndependent;
    private planarShadowMaxGroundHeight;
    private planarShadowMaxGroundThickness;
    private planarShadowMaterial;
    private planarShadowDispatcher;
    private planarShadowMixMaterial;
    private blurXMaterial;
    private blurYMaterial;
    private planarShadowCopyMaterial;
    private dispatcher;
    private drivenCullingMaterial;
    private drivenShadingMaterial;
    get shouldRender(): boolean;
    constructor(scene: SceneAdaptorDispatcher, renderer: RendererAdaptor);
    destroy(): void;
    updateFrameSize(width: number, height: number): void;
    updateEffect(scene: SceneAdaptor, isFrameStable: boolean, isCameraStable: boolean, effectConfig: IEffectConfig): void;
    updateGraphHash(hasher: HashKeyBuilder): void;
    private createStaticFrameCachePass;
    private createPlanarShadowTarget;
    private createPlanarShadowPass;
    private createPlanarShadowPassV2;
    private createOitPass;
    /**
     * WEBGPU only, enable MSAA in OIT pass.
     */
    private createMultisampledOitPass;
    updateRenderGraph(graph: RenderGraph, context: PipelineContext, depthPyramid: RenderTargetNode): void;
    private updateDrivenShadingMaterial;
    private updateDrivenCullingMaterial;
    createConfig(): {
        enabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        oit: {
            enabled: {
                get: () => boolean;
                set: (v: boolean) => void;
            };
        };
        solid: {
            enabled: {
                get: () => boolean;
                set: (v: boolean) => void;
            };
            lightMaterialEnabled: {
                get: () => boolean;
                set: (v: boolean) => void;
            };
            color: {
                get: () => Color;
                set: (v: Color) => void;
            };
        };
        toon: {
            enabled: {
                get: () => boolean;
                set: (v: boolean) => void;
            };
            tooniness: {
                get: () => number;
                set: (v: number) => void;
            };
            toonColor: {
                get: () => Color;
                set: (v: Color) => void;
            };
            diffuseColor: {
                get: () => Color;
                set: (v: Color) => void;
            };
            smoothnessMin: {
                get: () => number;
                set: (v: number) => void;
            };
            smoothnessMax: {
                get: () => number;
                set: (v: number) => void;
            };
        };
        staticFrameCache: {
            enabled: {
                get: () => boolean;
                set: (v: boolean) => void;
            };
        };
        planarShadow: {
            enabled: {
                get: () => boolean;
                set: (v: boolean) => void;
            };
            orderIndependentEnabled: {
                get: () => boolean;
                set: (v: boolean) => void;
            };
            intensity: {
                get: () => number;
                set: (v: number) => void;
            };
            blurKernelRadius: {
                get: () => number;
                set: (v: number) => void;
            };
            maxGroundThickness: {
                get: () => number;
                set: (v: number) => void;
            };
            maxGroundHeight: {
                get: () => number;
                set: (v: number) => void;
            };
        };
    };
    notifyChanged(): void;
}

declare class OutlinePlugin extends PipelinePlugin {
    readonly PLUGIN_NAME = "outline";
    private OUTLINE_DEPTH_ENABLE;
    private highQuality;
    private enableDepth;
    private outlineMaskEnabled;
    private encoder;
    private computeMaterial;
    private outlineMaskDispatcher;
    private composeMaterial;
    constructor(scene: SceneAdaptorDispatcher, renderer: RendererAdaptor);
    destroy(): void;
    private width;
    private height;
    updateFrameSize(width: number, height: number): void;
    updateEffect(): void;
    updateGraphHash(hasher: HashKeyBuilder): void;
    notifyChanged(): void;
    private drivenCullingMaterial;
    private drivenShadingMaterial;
    updateRenderGraph(graph: RenderGraph, context: PipelineContext, depthPyramid: RenderTargetNode): void;
    createConfig(): {
        enabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        useMrt: {
            get: () => boolean;
            set: (_: boolean) => void;
        };
        fixMergedPhongEncode: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        highQuality: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        enableDepth: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        outlineMaskEnabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        outlineColor: {
            get: () => Color;
            set: (v: Color) => void;
        };
        edgeThickness: {
            get: () => number;
            set: (v: number) => void;
        };
        indexEdgeThickness: {
            get: () => number;
            set: (v: number) => void;
        };
        normalEdgeThickness: {
            get: () => number;
            set: (v: number) => void;
        };
        depthEdgeThickness: {
            get: () => number;
            set: (v: number) => void;
        };
        coefficient: {
            get: () => number;
            set: (v: number) => void;
        };
        indexCoefficient: {
            get: () => number;
            set: (v: number) => void;
        };
        normalCoefficient: {
            get: () => number;
            set: (v: number) => void;
        };
        depthCoefficient: {
            get: () => number;
            set: (v: number) => void;
        };
    };
}

declare class SpriteBufferGeometry extends BufferGeometry {
    isSpriteBufferGeometry: boolean;
    constructor();
    computeBoundingBox(): void;
    computeBoundingSphere(): void;
}

interface WGLTextureData {
    webglTexture: WebGLTexture;
    byteSize: number;
}
declare type RenderBufferAttachment = WebGLRenderbuffer[];
declare type WGLRenderAttachment = WebGLTexture | RenderBufferAttachment;
declare class TextureManager {
    private renderer;
    private isWebGL1;
    private webglTextureMap;
    private bufferAttachmentMap;
    private totalUserByteSize;
    private totalInternalByteSize;
    constructor(renderer: Renderer);
    getWebGLByteSize(): number;
    getInternalWebGLByteSize(): number;
    get(texture: Texture, glState: WGLState): WGLTextureData;
    getAttachment(attachment: RenderAttachment, glState: WGLState): WGLRenderAttachment;
    private createRenderBuffer;
    private onTextureDispose;
    private onAttachmentDispose;
    freeGPU(): void;
}

/**
 * color or depth attachment for render target.
 * Anything affect texture size should be specified at creation, and will be immutable after creation.
 */
declare class RenderAttachment extends TextureV2 {
    /**
     * @internal
     */
    readonly isRenderAttachment = true;
    /**
     * @internal
     */
    readonly forceRenderBuffer: boolean;
    constructor(dimension: TextureDimension$1, viewDimension: TextureViewDimension$1, format: TextureFormat$1, width: number, height: number, depthOrArrayLayers: number, mipmaps: boolean, sampleCount: number, forceRenderBuffer: boolean, sampler: SamplerDescriptor);
    /**
     * @internal
     */
    protected upload(ctx: WebGLTextureUploadCtx): number;
    /**
     * @internal
     */
    attach(gl: WebGL2RenderingContext | WebGLRenderingContext, backend: RendererBackend, frameBuffer: number, attachment: number, data: WGLRenderAttachment, layer: number, level: number): void;
}
declare class RenderTarget {
    width: number;
    height: number;
    depthOrArrayLayers: number;
    multiSample: boolean;
    colors: RenderAttachment[];
    depth?: RenderAttachment;
    layer: number;
    level: number;
    drawBuffers?: number[];
    constructor(width: number, height: number, depthOrArrayLayers: number, multiSample?: boolean);
    setSize(width: number, height: number, depthOrArrayLayers: number): void;
    setAttachments(colors: RenderAttachment[], depth?: RenderAttachment): void;
    setBindInfo(level: number, buffers?: number[]): void;
    destroy(): void;
}

declare class GroundMaterial extends SceneMaterial {
    groundColor: Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "g" | "r" | "b" | "isColor" | "equals" | "getHex" | "getSerializeData">>;
    quat: Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "equals" | "getSerializeData" | "x" | "y" | "z" | "getNumberCount" | "toArray" | "dot" | "lengthSq" | "length" | "manhattanLength" | "w">>;
    private _isGroundColorEnabled;
    get isGroundColorEnabled(): boolean;
    set isGroundColorEnabled(v: boolean);
    groundIntensity: number;
    gridGapSizeA: number;
    offsetA: Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "equals" | "getSerializeData" | "x" | "y" | "getNumberCount" | "toArray" | "width" | "height" | "isVector2" | "dot" | "cross" | "lengthSq" | "length" | "angle" | "manhattanLength" | "distanceTo" | "distanceToSquared" | "manhattanDistanceTo" | "intoSize">>;
    colorA: Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "g" | "r" | "b" | "isColor" | "equals" | "getHex" | "getSerializeData">>;
    private _lineWidthA;
    private lineFactorA;
    get lineWidthA(): number;
    set lineWidthA(v: number);
    gridGapSizeB: number;
    offsetB: Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "equals" | "getSerializeData" | "x" | "y" | "getNumberCount" | "toArray" | "width" | "height" | "isVector2" | "dot" | "cross" | "lengthSq" | "length" | "angle" | "manhattanLength" | "distanceTo" | "distanceToSquared" | "manhattanDistanceTo" | "intoSize">>;
    colorB: Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "g" | "r" | "b" | "isColor" | "equals" | "getHex" | "getSerializeData">>;
    private _lineWidthB;
    private lineFactorB;
    get lineWidthB(): number;
    set lineWidthB(v: number);
    className(): string;
    constructor();
    copy(): this;
    clone(): GroundMaterial;
    private get scaledDeviceRatio();
    extendShaderShading(builder: ShaderBuilder, _: ShaderComponentRegistry): void;
    updateShadingUniforms(program: WGLProgram): void;
}

/**
 * A light that gets emitted from a single point in all directions.
 * A common use case for this is to replicate the light emitted from a bare lightbulb.
 */
declare class PointLight extends Light {
    viewMatrix: Matrix4;
    invViewMatrix: Matrix4;
    /**
     * When distance is zero, light does not attenuate.
     * When distance is non-zero, light will attenuate linearly from maximum intensity at the light's position down to zero at this distance from the light.
     */
    distance: number;
    isIESEnabled: boolean;
    /**
     * The amount the light dims along the distance of the light
     * In physically correct mode, decay = 2 leads to physically realistic light falloff.
     * @defaultValue `1` representing the intensity do not decay with distance increasing.
     */
    decay: number;
    /**
     * Check the type whether it belongs to PerspectiveCamera.
     * This value should not be changed by user.
     */
    isPointLight: boolean;
    private uniforms;
    /**
     * Use this attribute to set the shadow's config.
     * @remarks See example '3d shadow' for more details.
     */
    shadow: PointShadow;
    isShadowNeedsUpdate: boolean;
    private _textureIES_inner;
    protected _textureIES: T;
    get textureIES(): Nullable;
    set textureIES(value: Nullable);
    /**
     * The intensity scale of IES file.
     * @defaultValue `1`
     */
    iesIntensityScale: number;
    /**
     * Resolution of ies texture.
     * @defaultValue `Vector2(182, 1)`
     */
    iesTextureResolution: Vector2;
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(color?: number | string, intensity?: number, distance?: number, decay?: number, isIESEnabled?: boolean, textureIES?: T, iesIntensityScale?: number, iesTextureResolution?: Vector2);
    /**
     * The light's power.
     * In physically correct mode, the luminous power of the light measured in lumens.
     * This is directly related to the {@link intensity | intensity } in the ratio
     */
    get power(): number;
    set power(power: number);
    getIntensity(): number;
    /**
     * Copy the data to this light instance from source.
     * This method need override in derived classes to copy extended data.
     * @param {PointLight} source the data source.
     * @param {boolean} recursive if true, descendants of the object are also cloned. Default is true.
     */
    copy(source: PointLight, recursive?: boolean): this;
    clone(recursive?: boolean): PointLight;
    /**
     * @ignore
     */
    refreshUniforms(viewMatrix: Matrix4): void;
    /**
     * @ignore
     */
    updateUniformForForward(program: WGLProgram, index: number): void;
    updateUniformForDefer(program: WGLProgram): void;
    updateUniformByPrefix(program: WGLProgram, lightPrefix: string, shadowPrefix: string): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx an instance give the method to take the data for attribute.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx an instance used to store the data of scene objects.
     */
    serialize(ctx: Serializer): void;
    /**
     * @ignore
     */
    static getLightCollectShader(): string;
    /**
     * @ignore
     */
    static getShaderInclude(): ShaderBlock;
    static getHeader(isArray: boolean): "\n                uniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n                uniform sampler2D pointIES[ NUM_POINT_LIGHTS ];\n            " | "\n                uniform PointLight pointLight;\n                uniform sampler2D pointLightIES;\n            ";
    destroy(): void;
    getIESMapOrDefault(): Texture2D | T;
}

declare class PointShadow extends Shadow {
    enableAutoBias: boolean;
    private captureScale;
    updateMapUniform(program: WGLProgram, mapName: string): void;
    updateUniformsImpl(program: WGLProgram, prefix: string): void;
    getMapOrDefault(): RenderAttachment;
    camera: CubeCamera;
    customNear: number;
    customFar: number;
    constructor(light: PointLight);
    className(): string;
    copy(other: PointShadow): void;
    extendsShader(builder: ShaderBuilder, length: number): void;
    extendsShaderDeferred(builder: ShaderBuilder): void;
    updateCamera(light: Light): void;
    deserialize(ctx: Deserializer): void;
    serialize(ctx: Serializer): void;
}

declare enum FilterTarget {
    All = 0,
    Foreground = 1,
    Background = 2
}

declare enum ToneMapping {
    Linear = 0,
    Reinhard = 1,
    ACES = 2,
    ACESFilmic = 3,
    Neutral = 4
}

declare type MipLevelSource = TypedArray$3;
declare type LayerSource = HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | OffscreenCanvas | ImageData | ImageBitmap | TypedArray$3;
/**
 * SourceTexture is texture which contains cpu data.
 */
declare class SourceTexture$1 extends TextureV2 {
    /**
     * @internal
     */
    readonly isSourceTexture = true;
    readonly autoGenerateMipmap: boolean;
    private samplerNeedSync;
    private modifiedLevels;
    private modifiedLayers;
    private source;
    constructor(dimension: TextureDimension$1, viewDimension: TextureViewDimension$1, format: TextureFormat$1, width: number, height: number, depthOrArrayLayers: number, mipmaps: boolean, autoGenerateMipmap: boolean);
    getLevelLayerSource(level: number, layer?: number): Float32Array | Float64Array | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | HTMLCanvasElement | HTMLImageElement | HTMLVideoElement | OffscreenCanvas | ImageData | ImageBitmap | undefined;
    configSampler(visitor: (s: SamplerDescriptor) => any): this;
    /**
     * @internal
     */
    protected upload(ctx: WebGLTextureUploadCtx): number;
    setLevelData(data: MipLevelSource, level: number): this;
    setLevelLayerData(data: LayerSource, level: number, layer: number): this;
    /**
     * @internal
     */
    syncAllLevels(): void;
    /**
     * @internal
     */
    assumeUploaded(): void;
}

/**
 * This is a spacial mesh for skeletal mesh.
 */
declare class SkinnedMesh extends Mesh {
    readonly isSkinnedMesh: boolean;
    boneMatricesTexture: Nullable;
    boneMatricesBuffer: Nullable;
    private boundingBox;
    private boneBoundingBoxes;
    /**
     * @internal
     */
    get boneTextureSize(): number;
    /**
     * @internal
     */
    get boneCount(): number;
    /**
     * @internal
     */
    get isBound(): boolean;
    constructor(geometry?: BufferGeometry, material?: M | M[]);
    /**
     * Special raycast for skinned mesh
     */
    raycastJsImpl(raycaster: Raycaster, intersects: Intersection[]): void;
    /**
     * Copy skinned mesh with shared skeleton.
     */
    copy(source: SkinnedMesh, recursive?: boolean): this;
    /**
     * Clone skinned mesh with shared skeleton.
     */
    clone(recursive?: boolean): SkinnedMesh;
    /**
     * Bind skeleton to skinned mesh by bone texture in skeleton
     * @internal
     */
    bind(texture: T): void;
    /**
     * Compute bone bounding boxes in local space for raycast
     */
    private computeBoneBoundingBoxes;
    /**
     * Update local bboxes when bones change
     * @internal
     */
    updateLocalBounding(): void;
    updateBoundings(): void;
    /**
     * Compute animated position
     */
    applyBoneTransform(index: number, vector: Vector3): void;
    /**
     * Update bone matrices and local bounding
     */
    update(): void;
    /**
     * get local bbox which is not only related to geometry
     */
    getBoundingBox(): Box3;
    private getBoneMatrixAt;
}

declare enum SplattingRenderMode {
    Default = 0,
    PickingId = 1
}
declare class SplattingPlugin extends PipelinePlugin {
    PLUGIN_NAME: string;
    private forceUpdate;
    private shouldRenderNextFrame;
    private packQueue;
    private packMaterial;
    private packQuad;
    private packHighPrecisionEnabled;
    private packAttachSize;
    private precalculateEnabled;
    private precalculateQueue;
    private precalculateMaterial;
    private precalculateQuad;
    private repackEnabled;
    private repackIsDirty;
    private repackAttachSize;
    private repackMaterial;
    private repackQuat;
    private isSortDirty;
    private isSorting;
    private sortMinDuration;
    private sortLastTime;
    private sortPingPongTarget;
    private sortMaterial;
    private sortQuad;
    private reorderMaterial;
    private reorderQuad;
    private splattingMesh;
    private splattingGeometry;
    private splattingMaterial;
    private splattingRenderMode;
    private compositeEnabled;
    private compositeHighPrecisionAttachEnabled;
    private copyMaterial;
    private toneMappingEnabled;
    private toneMappingMaterial;
    private highlightKernelEnabled;
    private highlightKernelMesh;
    private highlightKernelGeometry;
    private highlightKernelMaterial;
    get envSupported(): boolean;
    get enabled(): boolean;
    set enabled(v: boolean);
    get shouldRender(): boolean;
    constructor(scene: SceneAdaptorDispatcher, renderer: RendererAdaptor);
    private sortCurrentVersion;
    private sortLastVersion;
    private sortingBuffer?;
    private sortTaskRunning;
    private pendingSortTask?;
    private orderBuffer?;
    private orderLayout;
    private flushSortTask;
    private addSortTask;
    destroy(): void;
    private sortSplatDistance;
    private sortSplatCoorient;
    private sortCameraDistance;
    private sortCameraCoorient;
    private prevSceneVersion;
    private prevSplatCache;
    private prevSortCameraMatrix?;
    private prevSortCameraLayer;
    updateEffect(sceneAdaptor: SceneAdaptor): void;
    updateFrameSize(): void;
    updateGraphHash(hasher: HashKeyBuilder): void;
    updateRenderGraph(graph: RenderGraph): void;
    createConfig(): {
        enabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        precalculateEnabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        repackEnabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        packHighPrecisionEnabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        preBlurAmount: {
            get: () => number;
            set: (v: number) => void;
        };
        blurAmount: {
            get: () => number;
            set: (v: number) => void;
        };
        focalAdjustment: {
            get: () => number;
            set: (v: number) => void;
        };
        maxStdDev: {
            get: () => number;
            set: (v: number) => void;
        };
        maxPixelRadius: {
            get: () => number;
            set: (v: number) => void;
        };
        detailCullingThreshold: {
            get: () => number;
            set: (v: number) => void;
        };
        normalizedFalloff: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        selectedColor: {
            get: () => Vector4;
            set: (v: Vector4) => void;
        };
        sort: {
            sortRadial: {
                get: () => boolean;
                set: (v: boolean) => void;
            };
            sortMinDuration: {
                get: () => number;
                set: (v: number) => void;
            };
            sortSplatDistance: {
                get: () => number;
                set: (v: number) => void;
            };
            sortSplatCoorient: {
                get: () => number;
                set: (v: number) => void;
            };
            sortCameraDistance: {
                get: () => number;
                set: (v: number) => void;
            };
            sortCameraCoorient: {
                get: () => number;
                set: (v: number) => void;
            };
        };
        composite: {
            enabled: {
                get: () => boolean;
                set: (v: boolean) => void;
            };
            highPrecisionAttachEnabled: {
                get: () => boolean;
                set: (v: boolean) => void;
            };
        };
        toneMapping: {
            enabled: {
                get: () => boolean;
                set: (v: boolean) => void;
            };
            toneMapping: {
                get: () => ToneMapping;
                set: (v: ToneMapping) => void;
            };
            exposure: {
                get: () => number;
                set: (v: number) => void;
            };
        };
        highlightKernel: {
            enabled: {
                get: () => boolean;
                set: (v: boolean) => void;
            };
            size: {
                get: () => number;
                set: (v: number) => void;
            };
            color: {
                get: () => number;
                set: (v: number) => void;
            };
        };
        __INNER__: {
            renderMode: {
                get: () => SplattingRenderMode;
                set: (v: SplattingRenderMode) => void;
            };
        };
    };
    notifyChanged(): void;
}

declare const SplatRenderingStabilityChangedEvent: EventType;
declare const SplatSortedEvent: EventType;
declare enum SplatState {
    Deleted = 1,
    Selected = 2
}
interface SplatEffectConfig {
    enabled: boolean;
    pulseEnabled: boolean;
    pulseSparseThreshold: number;
    pulseJitterPhase: number;
    pulseJitterAmount: number;
    pulsePhase: number;
    pulseAmount: number;
    pulseSize: number;
    pulseSizeVariance: number;
    pulseColorBoost: number;
    ringEnabled: boolean;
    ringInnerRegionVisible: boolean;
    ringOrigin: Vector3;
    ringRadius: number;
    ringWidth: number;
    ringColor: Vector3;
    spreadEnabled: boolean;
    spreadOrigin: Vector3;
    spreadRadius: number;
    spreadPreRadius: number;
    spreadPreScale: number;
    spreadColorBlendRadius: number;
    spreadColorBlendBase: Vector4;
    remyEnabled: boolean;
    remyOrigin: Vector3;
    remyPreRadius: number;
    remyPreScale: number;
    remyDenseRadius: number;
    remyDenseScale: number;
    remyDenseMinRatio: number;
    remyDenseMaxRatio: number;
    remyColorBlendRadius: number;
    remyColorBlendBase: Vector4;
    remyNormalRadius: number;
    remyRingRadius: number;
    remyRingWidth: number;
    remyRingInnerColor: Vector4;
    remyRingMidRatios: number;
    remyRingMidColor: Vector4;
    remyRingOuterColor: Vector4;
    magicEnabled: boolean;
    magicOrigin: Vector3;
    magicExpandRadius: number;
    magicInitialSize: number;
    magicInitialAlpha: number;
    magicInitialDensity: number;
    magicExpandJitterAmount: number;
    magicExpandScale: number;
    magicColorBlendRadius: number;
    magicColorBlendBase: Vector4;
    magicRingRadius: number;
    magicRingWidth: number;
    magicRingColor: Vector4;
    magicRingJitterAmount: number;
    overrideEnabled: boolean;
    overrideColor: Vector4;
}
declare abstract class Splat extends Object3D {
    abstract readonly PackType: string;
    abstract createUnpackSplatShader(): string;
    abstract createUnpackSHShader(): string;
    readonly isSplat: boolean;
    /**
     * @internal
     */
    version: number;
    offset: number;
    counts: number;
    shDegree: number;
    autoFreeResourceOnGpuPacked: boolean;
    maxShDegree: number;
    /**
     * @internal
     */
    extrasTex: SourceTexture$1[];
    /**
     * @internal
     */
    groupTex?: SourceTexture$1;
    /**
     * @internal
     */
    groupTransformTex?: SourceTexture$1;
    /**
     * @internal
     */
    stateTex?: SourceTexture$1;
    /**
     * @internal
     */
    extrasUBO: UniformBlockObject[];
    /**
     * @internal
     */
    effect: SplatEffectConfig;
    constructor(counts: number, shDegree: number);
    private isRenderingStability;
    /**
     * @internal
     */
    onUpdateRenderingStability(stable: boolean): void;
    /**
     * @internal
     */
    abstract onGpuDataPacked(): void;
    /**
     * @internal
     */
    onSorted(): void;
    updateVersion(): void;
    setEffectConfig(config: Partial): void;
    freeGPU(): void;
}

declare class CompressedSplat$1 extends Splat {
    readonly PackType = "compressed";
    /**
     * @internal
     */
    splat1Tex: SourceTexture$1;
    /**
     * @internal
     */
    splat2Tex: SourceTexture$1;
    /**
     * @internal
     */
    sh1Tex?: SourceTexture$1;
    /**
     * @internal
     */
    sh2Tex?: SourceTexture$1;
    /**
     * @internal
     */
    sh3Tex?: SourceTexture$1;
    /**
     * @internal
     */
    sh4Tex?: SourceTexture$1;
    constructor(counts: number, shDegree: number, splat1Tex: SourceTexture$1, splat2Tex: SourceTexture$1, sh1Tex?: SourceTexture$1, sh2Tex?: SourceTexture$1, sh3Tex?: SourceTexture$1, sh4Tex?: SourceTexture$1);
    createUnpackSplatShader(): string;
    createUnpackSHShader(): string;
    onGpuDataPacked(): void;
}

declare class SuperCompressedSplat$1 extends Splat {
    readonly PackType = "super_compressed";
    /**
     * @internal
     */
    splatTex: SourceTexture$1;
    /**
     * @internal
     */
    sh1Tex?: SourceTexture$1;
    /**
     * @internal
     */
    sh2Tex?: SourceTexture$1;
    constructor(counts: number, shDegree: number, splatTex: SourceTexture$1, sh1Tex?: SourceTexture$1, sh2Tex?: SourceTexture$1);
    createUnpackSplatShader(): string;
    createUnpackSHShader(): string;
    onGpuDataPacked(): void;
}

declare type SogSplatMeta = {
    counts: number;
    shDegree: number;
    means: {
        mins: [number, number, number];
        maxs: [number, number, number];
    };
} & ({
    version: 1;
    scales: {
        mins: [number, number, number];
        maxs: [number, number, number];
    };
    sh0: {
        mins: [number, number, number, number];
        maxs: [number, number, number, number];
    };
    shN?: {
        mins: number;
        maxs: number;
    };
} | {
    version: 2;
    scales: {
        codebook: number[];
    };
    sh0: {
        codebook: number[];
    };
    shN?: {
        codebook: number[];
    };
});
declare class SogSplat$1 extends Splat {
    readonly PackType: string;
    /**
     * @internal
     */
    meta: SogSplatMeta;
    /**
     * @internal
     */
    meansL: SourceTexture$1;
    /**
     * @internal
     */
    meansU: SourceTexture$1;
    /**
     * @internal
     */
    quats: SourceTexture$1;
    /**
     * @internal
     */
    scales: SourceTexture$1;
    /**
     * @internal
     */
    colors: SourceTexture$1;
    constructor(meta: SogSplatMeta, meansL: SourceTexture$1, meansU: SourceTexture$1, quats: SourceTexture$1, scales: SourceTexture$1, colors: SourceTexture$1, _shNLabels?: SourceTexture$1, _shNCentroids?: SourceTexture$1);
    createUnpackSplatShader(): string;
    createUnpackSHShader(): string;
    onGpuDataPacked(): void;
}

interface BVH {
    pick(ox: number, oy: number, oz: number, tx: number, ty: number, tz: number): Uint32Array;
    free(): void;
}

declare class MeshBVH {
    private bvh;
    private triangleIndexMap;
    constructor(bvh: BVH, triangleIndexMap: Uint32Array);
    pick(source: Mesh, raycaster: Raycaster, ray: Ray, intersects: Intersection[]): void;
    destroy(): void;
}

declare abstract class DrivenMaterial extends Material {
    readonly isDrivenMaterial: boolean;
    extendShaderShape(): void;
    extendShaderShading(): void;
    updateShapeUniforms(): void;
    updateShadingUniforms(): void;
    computeShapeKey(): string;
    clone(): Material;
    copy(_other: Material): void;
}

declare enum DepthPackingStrategies {
    BasicDepthPacking = 0,
    RGBADepthPacking = 1,
    NDC_DepthPacking = 2
}
declare class MeshDepthMaterial extends SceneMaterial {
    depthPacking: DepthPackingStrategies;
    className(): string;
    extendShaderShading(b: ShaderBuilder): void;
    generateShaderKey(r: ShaderComponentRegistry): string;
    updateShadingUniforms(_: WGLProgram): void;
    clone(): MeshDepthMaterial;
    copy(other: MeshDepthMaterial): this;
}

interface TargetLight extends Object3D {
    target: Object3D;
}
declare abstract class Shadow {
    readonly light: Object3D;
    protected constructor(light: Object3D);
    abstract className(): string;
    destroy(): void;
    static _IN_TEMPORAL: boolean;
    static ENABLE_TEMPORAL_EFFECT: boolean;
    static JITTER_SIZE: number;
    readonly isShadow = true;
    private _enabled;
    get enabled(): boolean;
    set enabled(v: boolean);
    intensity: number;
    bias: number;
    normalBias: number;
    radius: number;
    mapSize: Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "equals" | "getSerializeData" | "x" | "y" | "getNumberCount" | "toArray" | "width" | "height" | "isVector2" | "dot" | "cross" | "lengthSq" | "length" | "angle" | "manhattanLength" | "distanceTo" | "distanceToSquared" | "manhattanDistanceTo" | "intoSize">>;
    map: Nullable;
    abstract updateMapUniform(program: WGLProgram, mapName: string): void;
    abstract getMapOrDefault(): M;
    copy(other: Shadow): void;
    updateUniforms(program: WGLProgram, prefix: string): void;
    updateUniformsImpl(program: WGLProgram, prefix: string): void;
    includeShadowMapCommon(builder: ShaderBuilder): void;
    deserialize(ctx: Deserializer): void;
    serialize(ctx: Serializer): void;
}
declare abstract class SingleProjectShadow extends Shadow {
    constructor(light: Object3D);
    camera: C;
    destroy(): void;
    protected matrix: Matrix4;
    updateCameraAndShadowMatrices(light: TargetLight): void;
    updateCamera(light: TargetLight): void;
    updateShadowMatrix(): void;
    updateUniformsImpl(program: WGLProgram, prefix: string): void;
    updateMapUniform(program: WGLProgram, mapName: string): void;
    getMapOrDefault(): RenderAttachment;
}

/**
 * The orthographic camera class, which has no "bigger when it's closer, small when it's far" effect.
 * Size will not be affected by the distance.
 */
declare class OrthographicCamera extends Camera3D {
    /**
     * Check the type whether it belongs to OrthographicCamera.
     * This value should not be changed by user.
     */
    isOrthographicCamera: boolean;
    /**
     * The name of instance's class.
     */
    className(): string;
    private _zoom;
    /**
     * Scale width and height of view frustum.
     */
    get zoom(): number;
    set zoom(v: number);
    protected _left: number;
    /**
     * Distance from projective plane center to left side.
     */
    get left(): number;
    set left(v: number);
    protected _right: number;
    /**
     * Distance from projective plane center to right side.
     */
    get right(): number;
    set right(v: number);
    /**
     * Distance from projective plane center to top side.
     */
    protected _top: number;
    get top(): number;
    set top(v: number);
    /**
     * Distance from projective plane center to bottom side.
     */
    protected _bottom: number;
    get bottom(): number;
    set bottom(v: number);
    /**
     * Distance from camera position to near plane of view frustum.
     */
    private _near;
    get near(): number;
    set near(v: number);
    /**
     * Distance from camera position to far plane of view frustum.
     */
    private _far;
    get far(): number;
    set far(v: number);
    /**
     * Frustum window specification or null.
     * This is set using the {@link setViewOffset| setViewOffset } method and cleared using {@link clearViewOffset| clearViewOffset }.
     */
    view: Nullable;
    constructor(left?: number, right?: number, top?: number, bottom?: number, near?: number, far?: number);
    /**
     * Copy the data to this camera instance from source.
     * This method need override in derived classes to copy extended data.
     * @param {OrthographicCamera} source the data source.
     * @param {boolean} recursive if true, descendants of the object are also cloned. Default is true.
     */
    copy(source: OrthographicCamera, recursive?: boolean): this;
    /**
     * @remarks See {@link PerspectiveCamera.setViewOffset | PerspectiveCamera } for more details.
     */
    setViewOffset(fullWidth: number, fullHeight: number, x: number, y: number, width: number, height: number): void;
    /**
     * Removes any offset set by the {@link setViewOffset | setViewOffset } method.
     */
    clearViewOffset(): void;
    /**
     * Updates the camera's {@link projectionMatrix | projectionMatrix } and {@link projectionMatrixInverse | projectionMatrixInverse }.
     * When user change the attribute such as far, top ...,
     * this method will have to be called for the changes to take effect.
     * @param { Object } jitter if jitters need to be applied on this camera, this parameter need to be given.
     */
    updateProjectionMatrix(jitter?: {
        offset: Vector2;
        canvas_size: Vector2;
    }): void;
    /**
     * The tangent value of camera frustum's vertical angle.
     */
    getPixelsOfDistOne(): number;
    /**
     * Calculate how many screen pixel match one world unit at given distance.
     * @param {number} distance the distance from camera to object.
     * @param {number} viewHeight the hight of view window.
     */
    pixelsPerUnit(_: number, viewHeight: number): number;
    /**
     * Set the origin and direction for ray.
     * @param {Ray} ray the calculate result will be set to this.
     * @param {Vector2} coords the position of window where the ray through out.
     */
    castRay(ray: Ray, coords: Vector2): void;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx an instance used to store the data of scene objects.
     */
    serialize(ctx: Serializer): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx an instance give the method to take the data for attribute.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Return a cloned instance of this instance.
     */
    clone(recursive?: boolean): OrthographicCamera;
}

declare class DirectionalShadow extends SingleProjectShadow {
    enableAutoBias: boolean;
    shadowCameraNear: number;
    shadowCameraFar: number;
    shadowRenderSize: Vector2;
    className(): string;
    constructor(directional: DirectionalLight);
    copy(other: DirectionalShadow): void;
    updateCameraAndShadowMatrices(light: DirectionalLight): void;
    extendsShader(builder: ShaderBuilder, length: number): void;
    extendsShaderDeferred(builder: ShaderBuilder): void;
    updateUniformsImpl(program: WGLProgram, prefix: string): void;
    deserialize(ctx: Deserializer): void;
    serialize(ctx: Serializer): void;
}

declare class DirectionalLight extends Light {
    viewMatrix: Matrix4;
    invViewMatrix: Matrix4;
    static get DEFAULT_TARGET(): Object3D;
    /**
     * The target is a point in world space used to calculate the direction of light.
     */
    private _target;
    get target(): Object3D;
    set target(t: Object3D);
    /**
     * Check the type whether it belongs to PerspectiveCamera.
     * This value should not be changed by user.
     */
    isDirectionalLight: boolean;
    private vector3;
    private uniforms;
    /**
     * Use this attribute to set the shadow's config.
     * @remarks See example '3d shadow' for more details.
     */
    shadow: DirectionalShadow;
    isShadowNeedsUpdate: boolean;
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(color?: number | string, intensity?: number);
    /**
     * Copy the data to this light instance from source.
     * This method need override in derived classes to copy extended data.
     * @param {Light} source the data source.
     * @param {boolean} recursive if true, descendants of the object are also cloned. Default is true.
     */
    copy(source: DirectionalLight, recursive?: boolean): this;
    clone(recursive?: boolean): DirectionalLight;
    /**
     * @ignore
     */
    refreshUniforms(viewMatrix: Matrix4): void;
    updateUniformForForward(program: WGLProgram, index: number): void;
    updateUniformForDefer(program: WGLProgram): void;
    updateUniformByPrefix(program: WGLProgram, lightPrefix: string, shadowPrefix: string): void;
    destroy(): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx an instance give the method to take the data for attribute.
     * @ignore
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx an instance used to store the data of scene objects.
     * @ignore
     */
    serialize(ctx: Serializer): void;
    /**
     * @ignore
     */
    static getLightCollectShader(): string;
    static getHeader(isArray: boolean): "uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];" | "uniform DirectionalLight directionalLight;";
    /**
     * @ignore
     */
    static getShaderInclude(): ShaderBlock;
}

/**
 * This light's color gets applied to all the objects in the scene globally.
 * The color of this light can influence object's natural color.
 */
declare class AmbientLight extends Light {
    /**
     * Check the type whether it belongs to PerspectiveCamera.
     * This value should not be changed by user.
     */
    isAmbientLight: boolean;
    /**
     * This attribute calculate the final color by {@link intensity | intensity } and {@link color | color }
     */
    uniformColor: Color;
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(color?: number | string, intensity?: number);
    /**
     * @ignore
     */
    refreshUniforms(): void;
    /**
     * @ignore
     */
    updateUniforms(program: WGLProgram): void;
    clone(recursive?: boolean): AmbientLight;
}

declare class AreaLight extends Light {
    constructor(color: number | string, intensity: number);
    static get ltc_1_texture(): Texture2D;
    static get ltc_2_texture(): Texture2D;
    /**
     * The name of instance's class.
     */
    className(): string;
    static updateLTCUniform(program: WGLProgram): void;
}

/**
 * RectAreaLight emits light uniformly across the face a rectangular plane.
 * This light type can be used to simulate light sources such as bright windows or strip lighting.
 */
declare class RectAreaLight extends AreaLight {
    isRectAreaLight: boolean;
    width: number;
    height: number;
    specularStrength: number;
    private uniforms;
    /**
     * The name of instance's class.
     */
    className(): string;
    /**
     * @param color (optional) hexadecimal color of the light. Default is 0xffffff (white).

     * @param intensity (optional) the light's intensity, or brightness. Default is 1.

     * @param width (optional) width of the light. Default is 10.

     * @param height (optional) height of the light. Default is 10.

     */
    constructor(color?: number | string, intensity?: number, width?: number, height?: number, specularStrength?: number);
    copy(source: RectAreaLight, recursive?: boolean): this;
    clone(recursive?: boolean): RectAreaLight;
    /**
     * @ignore
     */
    refreshUniforms(viewMatrix: Matrix4): void;
    /**
     * @ignore
     */
    updateUniformForForward(program: WGLProgram, index: number): void;
    /**
     * @ignore
     */
    updateUniformForDefer(program: WGLProgram): void;
    updateUniformByPrefix(program: WGLProgram, prefix: string): void;
    static getHeader(isArray: boolean): "uniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];" | "uniform RectAreaLight rectAreaLight;";
    /**
     * @ignore
     */
    static getLightCollectShader(): string;
    /**
     * @ignore
     */
    static getShaderInclude(): ShaderBlock;
    /**
     * @ignore
     */
    deserialize(ctx: Deserializer): void;
    /**
     * @ignore
     */
    serialize(ctx: Serializer): void;
}

declare class DiskAreaLight extends AreaLight {
    isDiskAreaLight: boolean;
    width: number;
    height: number;
    specularStrength: number;
    private uniforms;
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(color?: number | string, intensity?: number, width?: number, height?: number, specularStrength?: number);
    copy(source: DiskAreaLight, recursive?: boolean): this;
    clone(recursive?: boolean): DiskAreaLight;
    /**
     * @ignore
     */
    refreshUniforms(viewMatrix: Matrix4): void;
    /**
     * @ignore
     */
    updateUniformForForward(program: WGLProgram, index: number): void;
    updateUniformForDefer(program: WGLProgram): void;
    updateUniformByPrefix(program: WGLProgram, prefix: string): void;
    static getHeader(isArray: boolean): "uniform DiskAreaLight diskAreaLights[ NUM_DISK_AREA_LIGHTS ];" | "uniform DiskAreaLight diskAreaLight;";
    /**
     * @ignore
     */
    static getLightCollectShader(): string;
    /**
     * @ignore
     */
    static getShaderInclude(): ShaderBlock;
    /**
     * @ignore
     */
    deserialize(ctx: Deserializer): void;
    /**
     * @ignore
     */
    serialize(ctx: Serializer): void;
}

declare class DeferredPlugin extends PipelinePlugin {
    readonly PLUGIN_NAME = "deferred";
    private mixOITMaterial;
    isAutoExposedEnabled: boolean;
    private keyMinuend;
    private result;
    private dispatcher;
    private forwardDispatcher;
    private dynamicLightsDispatcher;
    private copier;
    private copyMaterial;
    private enableWhiteBalance;
    private dialuxLuminance;
    private dialuxWhiteBalanceExposure;
    private drivenEnabled;
    private _enablePseudoColor;
    private get enablePseudoColor();
    private set enablePseudoColor(value);
    private _decodeSrgb;
    private get decodeSrgb();
    private set decodeSrgb(value);
    private pseudoColorMaterial;
    private exposedCopier;
    private exposedToneMappingCopier;
    private histogramComputeMaterial;
    private avgLuminanceMaterial;
    private depthCopier;
    private deferredDirectionalLightMaterial;
    private deferredSpotLightMaterial;
    private deferredPointLightMaterial;
    private deferredAmbientLightMaterial;
    private deferredRectAreaLightMaterial;
    private deferredDiskAreaLightMaterial;
    private drivenCullingMaterial;
    private drivenShadingMaterial;
    private deferredQuad;
    constructor(scene: SceneAdaptorDispatcher, renderer: RendererAdaptor);
    get envSupported(): boolean;
    destroy(): void;
    updateFrameSize(): void;
    updateEffect(): void;
    updateGraphHash(hasher: HashKeyBuilder): void;
    private createOitPass;
    updateRenderGraph(graph: RenderGraph, context: PipelineContext, depthPyramid: RenderTargetNode): void;
    createConfig(): {
        enabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        enableWhiteBalance: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        enablePseudoColor: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        pseudoColors: {
            get: () => number[];
            set: (v: number[]) => void;
        };
        pseudoGradations: {
            get: () => number[];
            set: (v: number[]) => void;
        };
        temperature: {
            get: () => number;
            set: (v: number) => void;
        };
        autoExposedEnabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        keyMinuend: {
            get: () => number;
            set: (v: number) => void;
        };
        gamma: {
            get: () => number;
            set: (v: number) => void;
        };
        multiplier: {
            get: () => number;
            set: (v: number) => void;
        };
        burnValue: {
            get: () => number;
            set: (v: number) => void;
        };
        contrast: {
            get: () => number;
            set: (v: number) => void;
        };
        decodeSrgb: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
    };
}

declare class RendererAdaptor {
    renderer: IRenderer;
    width: number;
    height: number;
    activeResources: Map;
    constructor(renderer: IRenderer);
    setSize(width: number, height: number): void;
    setClearColor(color: Vector4): void;
    render(renderable: Renderable): void;
    clear(color: boolean, depth: boolean, stencil?: boolean): void;
    setRenderTarget(target: RenderTarget, resolveTarget?: RenderTarget): void;
    setRenderToScreen(): void;
}

declare abstract class ExecuteNode extends DAGNode {
    protected readonly executeHooks: EventDispatcher;
    before(callback: (ctx: ExecuteCtx) => void): this;
    after(callback: (ctx: ExecuteCtx) => void): this;
    emit(event: EventType, data: T): void;
    abstract execute(ctx: ExecuteCtx): void;
    abstract check(): boolean;
}

declare type RenderMethod = (renderer: RendererAdaptor, target?: RenderTarget, i?: number) => void;
declare type ConfigMethod = (renderer: RendererAdaptor) => boolean;
declare type CustomPassMethod = (node: PassNode, ctx: PassExecuteCtx) => void;
interface RenderSource {
    /**
     * used to update render pass, such as clear
     */
    config?: ConfigMethod;
    /**
     * do render
     */
    render: RenderMethod;
}
declare type AttachmentDescriptor = number | 'depth';
interface OverrideScreenOutputTarget {
    target: RenderTarget;
    resolveTarget?: RenderTarget;
}
interface PassExecuteCtx {
    renderer: RendererAdaptor;
    target?: RenderTarget;
    resolveTarget?: RenderTarget;
    overrideScreenOutputTarget?: OverrideScreenOutputTarget;
}
/**
 * render processing class, as a render pass, can customize uniform、target and renderMethod
 * normal pass: beforeHook -> bindTarget -> configRenderPass -> renderer.beginPass(composer) -> execute -> renderer.endPass(composer) -> afterHook
 * custom pass(when customPassMethod configured): beforeHook -> execute -> afterHook
 */
declare class PassNode extends ExecuteNode {
    target: RenderTargetNode;
    resolveTarget?: RenderTargetNode;
    dependResources: Set;
    private writeTargetLevel;
    writeLevel(level: number): this;
    private writeTargetBuffers?;
    writeBuffers(buffers?: number[]): this;
    private dispatcher;
    useDispatcher(d: MaterialDispatcher | undefined): this;
    private clearColor;
    setClearColor(c: Vector4): this;
    private isColorClearEnabled;
    private isDepthClearEnabled;
    enableClear(color?: boolean, depth?: boolean): this;
    disableClear(): this;
    private clearConfig;
    setClearConfig(isClear: () => boolean): this;
    private _needResolveContent;
    private _needResolveDepth;
    private _needGenerateMipmap;
    resolveTo(resolveTarget?: RenderTargetNode, resolveDepth?: boolean, generateMipmap?: boolean): this;
    resolveToScreen(resolveDepth?: boolean, generateMipmap?: boolean): void;
    get needResolveContent(): boolean;
    get needResolveDepth(): boolean;
    get needGenerateMipmap(): boolean;
    drivenMaterial?: DrivenMaterial;
    useDriven(material?: DrivenMaterial): this;
    private _needStoreOutput;
    /**
    * whether discard attachments.
    * for webgpu set storeOp to 'discard' in begin render pass
    * for webgl will call invalidateFramebuffer.
    */
    discardOutput(): this;
    get needStoreOutput(): boolean;
    private renderMethods;
    private configMethods;
    private inputs;
    private resources;
    private customPassMethod;
    get isCustomPass(): boolean;
    input(key: string, dependNode: RenderTargetNode, attachment?: AttachmentDescriptor): this;
    updateResource(getResource: (node: ResourceNode) => Texture): void;
    clear(): this;
    use(source: RenderSource | RenderMethod): this;
    customPass(source: CustomPassMethod): this;
    render(source: RenderMethod): this;
    config(source: ConfigMethod): this;
    useIf(shouldRender: () => boolean, source: RenderSource | RenderMethod): this;
    useIfAndDisableClear(shouldRender: () => boolean, source: RenderSource | RenderMethod): this;
    draw(renderable: () => Renderable): this;
    bindTarget(ctx: PassExecuteCtx): void;
    /**
     * setup clear or other render pass configs.
     * @returns whether current pass can be merged into previous pass.
     */
    configRenderPass(ctx: PassExecuteCtx): boolean;
    execute(ctx: PassExecuteCtx): void;
    check(): boolean;
}

declare class RenderGraph {
    private initialized;
    private _isValid;
    get isValid(): boolean;
    private root;
    private nodes;
    private _depthTarget?;
    get depthTarget(): RenderTargetNode | undefined;
    set depthTarget(v: RenderTargetNode | undefined);
    sceneCullingPass?: PassNode;
    dropResources: Array>;
    private cachedPassNodes?;
    get passNodes(): PassNode[];
    constructor(root: RenderTargetNode);
    reset(): this;
    private passList;
    addPass(node: PassNode | Array): void;
    removePass(name: string): PassNode | undefined;
    removeAllPasses(): PassNode[];
    lastValidPass(): PassNode | undefined;
    build(): this;
}

declare class EffectComposer {
    overrideScreenOutputTarget?: OverrideScreenOutputTarget;
    private renderer;
    private attachmentPool;
    private targets;
    private attachments;
    constructor(renderer: RendererAdaptor);
    _getFrameBuffer(key: string): RenderTarget | undefined;
    private getAttachment;
    private getFrameBuffer;
    render(graph: RenderGraph): void;
    clear(): void;
}

declare class ShadowMapPlugin extends PipelinePlugin {
    readonly PLUGIN_NAME = "shadowMap";
    private depthDispatcher;
    /**
     * whether use render proxy to render shadow map
     * be careful. current some render proxy(eg. auto instance, multi merge) does not fully support cast shadow flag.
     * @default false
     */
    private useProxy;
    protected _enabled: boolean;
    get enabled(): boolean;
    set enabled(v: boolean);
    private drivenCullingMaterial;
    private drivenShadingMaterial;
    constructor(scene: SceneAdaptorDispatcher, renderer: RendererAdaptor);
    destroy(): void;
    updateFrameSize(): void;
    updateEffect(): void;
    updateGraphHash(hasher: HashKeyBuilder): void;
    /**
     * notes:
     * You should not directly reference a specific scene object(like light, shadow, light system)
     * into rendergraph hooks(like render, before, after), or it will cause mem leak
     * Instead, any scene object access, should provider by scene adaptor, every graph
     * actually reference the one scene adaptor dispatcher which pipeline provides,
     * and scene adaptor is provided by scene adaptor dispatcher. That's how we avoid mem leak.
     *
     * In shadowmap updating/generation case, you can't name specific shadow/light when
     * updating, because the graph instance has no relationship with what exactly light/shadow
     * in the scene. In fact, in current implementation only the number of light decide
     * the graph structure. So for each i in scene, we do check and update i th light,
     * and the scene dispatcher must responsible for updating/access same light when given same i;
     */
    updateRenderGraph(graph: RenderGraph, context: PipelineContext): void;
    private shadowPass;
    private updateCullingConfig;
    /**
     * in gpu driven, shadow drawable list will be unfiltered, will use drawcall filter instead of drawable filter.
     * additional the projected drawcall list will disable light manually to prevent issue.
     */
    private gpuDrivenShadowPass;
    createConfig(): {
        useProxy: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        enableTemporal: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        targetJitterSize: {
            get: () => number;
            set: (v: number) => void;
        };
    };
}

declare class Ground implements Renderable {
    /**
     * The material of ground can be used to change style.
     */
    readonly material: GroundMaterial;
    /**
     * Switch of drawing ground.
     */
    enabled: boolean;
    private _size;
    get size(): number;
    set size(v: number);
    private groundMesh;
    private geometry;
    constructor();
    get up(): Vector3;
    set up(up: Vector3);
    config(_: IRenderer): boolean;
    private updateGeometry;
    /**
     * @ignore
     */
    render(renderer: IRenderer): void;
    destroy(): void;
}

declare class BackgroundPlugin extends PipelinePlugin {
    readonly PLUGIN_NAME = "background";
    ground: Ground;
    basicBackground: BasicBackground;
    solidBackground: SolidColorBackground;
    skyBackground: SkyBackground;
    envBackground: EnvMapBackground;
    gradientBackground: GradientBackground;
    activeBackground: BackgroundMode;
    private get background();
    private skyMapMaterial;
    private copyMaterial;
    private up;
    private get needRecreateSkyMap();
    protected _enabled: boolean;
    constructor(scene: SceneAdaptorDispatcher, renderer: RendererAdaptor);
    destroy(): void;
    updateFrameSize(): void;
    notifyChanged(): void;
    updateEffect(): void;
    updateGraphHash(hasher: HashKeyBuilder): void;
    updateRenderGraph(graph: RenderGraph): void;
    createConfig(): {
        enabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        up: {
            get: () => Vector3;
            set: (v: Vector3) => void;
        };
        ground: {
            enabled: {
                get: () => boolean;
                set: (v: boolean) => void;
            };
            gridSize: {
                get: () => number;
                set: (v: number) => void;
            };
            offsetA: {
                get: () => Vector2;
                set: (v: Vector2) => void;
            };
            gridGapSizeA: {
                get: () => number;
                set: (v: number) => void;
            };
            colorA: {
                get: () => Color;
                set: (v: Color) => void;
            };
            lineWidthA: {
                get: () => number;
                set: (v: number) => void;
            };
            offsetB: {
                get: () => Vector2;
                set: (v: Vector2) => void;
            };
            gridGapSizeB: {
                get: () => number;
                set: (v: number) => void;
            };
            colorB: {
                get: () => Color;
                set: (v: Color) => void;
            };
            lineWidthB: {
                get: () => number;
                set: (v: number) => void;
            };
            isGroundColorEnabled: {
                get: () => boolean;
                set: (v: boolean) => void;
            };
            groundColor: {
                get: () => Color;
                set: (v: Color) => void;
            };
        };
        background: {
            active: {
                get: () => BackgroundMode;
                set: (v: BackgroundMode) => void;
            };
            solid: {
                color: {
                    get: () => Color;
                    set: (v: Color) => void;
                };
                alpha: {
                    get: () => number;
                    set: (v: number) => void;
                };
            };
            envmap: {
                texture: {
                    get: () => Texture;
                    set: (v: Texture) => void;
                };
                luma: {
                    get: () => number;
                    set: (v: number) => void;
                };
                verticalRotation: {
                    get: () => number;
                    set: (v: number) => void;
                };
                horizonRotation: {
                    get: () => number;
                    set: (v: number) => void;
                };
                reverseVertical: {
                    get: () => boolean;
                    set: (v: boolean) => void;
                };
                reverseHorizon: {
                    get: () => boolean;
                    set: (v: boolean) => void;
                };
            };
            gradient: {
                skyColor: {
                    get: () => Color;
                    set: (v: Color) => void;
                };
                groundColor: {
                    get: () => Color;
                    set: (v: Color) => void;
                };
            };
            sky: {
                enablePreSkyMap: {
                    get: () => boolean;
                    set: (v: boolean) => void;
                };
                luminance: {
                    get: () => number;
                    set: (v: number) => void;
                };
                turbidity: {
                    get: () => number;
                    set: (v: number) => void;
                };
                rayleigh: {
                    get: () => number;
                    set: (v: number) => void;
                };
                mieCoefficient: {
                    get: () => number;
                    set: (v: number) => void;
                };
                mieDirectionalG: {
                    get: () => number;
                    set: (v: number) => void;
                };
            };
            basic: {
                color: {
                    get: () => Color;
                    set: (v: Color) => void;
                };
                alpha: {
                    get: () => number;
                    set: (v: number) => void;
                };
                texture: {
                    get: () => Texture | null;
                    set: (v: Texture | null) => void;
                };
            };
        };
    };
    private updateMaterial;
}

/**
 * Type of parameters of {@link setHighlightObjects|setHighlightObjects}
 * @highlightGroupIndex If there are more than one material for geometry groups, the index of groups which need be highlight must push into this.
*/
interface HighLightItem {
    object: Drawable;
    highlightGroupIndex?: number[];
    instanceIndex?: number;
}
interface HighlightGroup {
    items: HighLightItem[];
    width?: number;
    borderColor?: Color;
    borderOpacity?: number;
    innerColor?: Color;
    innerOpacity?: number;
}
declare class HighlightPlugin extends PipelinePlugin {
    readonly PLUGIN_NAME = "highlight";
    private dispatcher;
    private blendMaterials;
    private width;
    private borderColor;
    private borderOpacity;
    private innerColor;
    private innerOpacity;
    private highlightGroups;
    private texelSize;
    get enabled(): boolean;
    set enabled(v: boolean);
    constructor(scene: SceneAdaptorDispatcher, renderer: RendererAdaptor);
    destroy(): void;
    updateFrameSize(width: number, height: number): void;
    updateEffect(): void;
    notifyChanged(): void;
    updateGraphHash(hasher: HashKeyBuilder): void;
    updateRenderGraph(graph: RenderGraph): void;
    createConfig(): {
        enabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        width: {
            get: () => number;
            set: (v: number) => void;
        };
        borderColor: {
            get: () => Color;
            set: (v: Color) => void;
        };
        borderOpacity: {
            get: () => number;
            set: (v: number) => void;
        };
        innerColor: {
            get: () => Color;
            set: (v: Color) => void;
        };
        innerOpacity: {
            get: () => number;
            set: (v: number) => void;
        };
    };
    setHighlightGroups(highlightGroups: HighlightGroup[]): void;
}

declare class AOPlugin extends PipelinePlugin {
    readonly PLUGIN_NAME = "AO";
    private depthMaterial;
    private aoPassMaterial;
    private aoBlurXMaterial;
    private aoBlurYMaterial;
    private aoComposeMaterial;
    private depthDispatcher;
    private drivenShadingMaterial;
    private active;
    get enabled(): boolean;
    set enabled(v: boolean);
    constructor(scene: SceneAdaptorDispatcher, renderer: RendererAdaptor);
    destroy(): void;
    updateFrameSize(width: number, height: number): void;
    updateEffect(_scene: SceneAdaptor, isFrameStable: boolean, isCameraStable: boolean, effectConfig: IEffectConfig): void;
    updateGraphHash(_hasher: HashKeyBuilder): void;
    updateRenderGraph(graph: RenderGraph, context: PipelineContext): void;
    createConfig(): {
        enabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        aoBias: {
            get: () => number;
            set: (v: number) => void;
        };
        aoRadius: {
            get: () => number;
            set: (v: number) => void;
        };
        blurKernelRadius: {
            get: () => number;
            set: (v: number) => void;
        };
        blurEdgeSharpness: {
            get: () => number;
            set: (v: number) => void;
        };
        aoIntensity: {
            get: () => number;
            set: (v: number) => void;
        };
    };
}

declare class OverlayScenePlugin extends PipelinePlugin {
    readonly PLUGIN_NAME = "overlay_scene";
    private dispatcher;
    protected _enabled: boolean;
    destroy(): void;
    updateFrameSize(): void;
    updateEffect(): void;
    updateGraphHash(_hasher: HashKeyBuilder): void;
    updateRenderGraph(graph: RenderGraph): void;
    createConfig(): {
        enabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
    };
}

declare class StylizePlugin extends PipelinePlugin {
    readonly PLUGIN_NAME = "stylize";
    private filterMaterial;
    private get useDepth();
    constructor(scene: SceneAdaptorDispatcher, renderer: RendererAdaptor);
    destroy(): void;
    updateFrameSize(): void;
    updateEffect(): void;
    updateGraphHash(hasher: HashKeyBuilder): void;
    updateRenderGraph(graph: RenderGraph): void;
    createConfig(): {
        enabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        temperature: {
            get: () => number;
            set: (v: number) => void;
        };
        tint: {
            get: () => number;
            set: (v: number) => void;
        };
        brightness: {
            get: () => number;
            set: (v: number) => void;
        };
        contrast: {
            get: () => number;
            set: (v: number) => void;
        };
        saturation: {
            get: () => number;
            set: (v: number) => void;
        };
        colorBalance: {
            get: () => Vector3;
            set: (v: Vector3) => void;
        };
        hue: {
            get: () => number;
            set: (v: number) => void;
        };
        lut: {
            get: () => Texture | null;
            set: (v: Texture | null) => void;
        };
        texture: {
            get: () => Texture | null;
            set: (v: Texture | null) => void;
        };
        target: {
            get: () => FilterTarget;
            set: (v: FilterTarget) => void;
        };
    };
}

declare class TAAPlugin extends PipelinePlugin {
    readonly PLUGIN_NAME = "taa";
    private taaMaterial;
    private copyMaterial;
    private taaPingPong;
    private outSampleCount;
    private samples;
    private active;
    get enabled(): boolean;
    set enabled(v: boolean);
    private _maxSampleCount;
    get maxSampleCount(): number;
    set maxSampleCount(v: number);
    private waitingTime;
    private lastResetTimestamp;
    private get isTAAReady();
    get shouldRender(): boolean;
    resetSample(): void;
    destroy(): void;
    updateFrameSize(): void;
    updateEffect(_scene: SceneAdaptor, isFrameStable: boolean, isCameraStable: boolean, effectConfig: IEffectConfig): void;
    updateGraphHash(hasher: HashKeyBuilder): void;
    updateRenderGraph(graph: RenderGraph): void;
    createConfig(): {
        enabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        maxSample: {
            get: () => number;
            set: (v: number) => void;
        };
        outputSample: {
            get: () => number;
            set: (v: number) => void;
        };
        waitingTime: {
            get: () => number;
            set: (v: number) => void;
        };
    };
    private get outputScreen();
    tick(): void;
    jitterCamera(camera: Camera3D, width: number, height: number): void;
    jitterClear(camera: Camera3D): void;
}

declare class TransparentLinePlugin extends PipelinePlugin {
    readonly PLUGIN_NAME = "transparent_line";
    private edgeThreshold;
    private enabledOriginShading;
    private enableDrawAdditional;
    private lineMat;
    private lineD;
    private basicMat;
    private basicD;
    private hideMat;
    constructor(scene: SceneAdaptorDispatcher, renderer: RendererAdaptor);
    destroy(): void;
    updateFrameSize(): void;
    updateEffect(): void;
    updateGraphHash(hasher: HashKeyBuilder): void;
    updateRenderGraph(graph: RenderGraph): void;
    private transform;
    createConfig(): {
        enabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        opacity: {
            get: () => number;
            set: (v: number) => void;
        };
        transparentColor: {
            get: () => Color;
            set: (v: Color) => void;
        };
        lineColor: {
            get: () => Color;
            set: (v: Color) => void;
        };
        edgeThreshold: {
            get: () => number;
            set: (v: number) => void;
        };
        drawWithOriginalMaterial: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        drawAdditionalLines: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
    };
}

declare class SceneClipPlugin extends PipelinePlugin {
    PLUGIN_NAME: string;
    private clippingEnabled;
    private clippingPlanes;
    private clippingEnabledCached;
    private clippingPlanesCached;
    destroy(): void;
    updateEffect(): void;
    updateFrameSize(): void;
    updateGraphHash(): void;
    updateRenderGraph(): void;
    setSceneClip(scene: Scene3D): void;
    restoreSceneClip(scene: Scene3D): void;
    createConfig(): {
        enabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        clippingEnabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        clippingPlanes: {
            get: () => Plane[];
            set: (v: Plane[]) => void;
        };
    };
}

declare class CompositePlugin extends PipelinePlugin {
    readonly PLUGIN_NAME = "composite";
    private staticFrameCacheEnabled;
    private hasStaticCacheFrame;
    private _multiSamplingEnabled;
    private get multiSamplingEnabled();
    private copyMaterial;
    /**
     * @internal
     */
    private _bound?;
    get bound(): Vector4 | undefined;
    set bound(v: Vector4 | undefined);
    private quad?;
    private updateQuad;
    private _shouldMacWorkaround;
    get enabled(): boolean;
    set enabled(v: boolean);
    destroy(): void;
    updateFrameSize(): void;
    updateEffect(_scene: SceneAdaptor, isFrameStable: boolean, isCameraStable: boolean, effectConfig: IEffectConfig): void;
    updateGraphHash(hasher: HashKeyBuilder): void;
    updateRenderGraph(graph: RenderGraph): void;
    createConfig(): {
        enabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        macWorkaround: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        multiSamplingEnabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        staticFrameCacheEnabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
    };
    notifyChanged(): void;
}

declare enum DebugMode {
    Depth = 0,
    Normal = 1
}
declare class DebugPlugin extends PipelinePlugin {
    readonly PLUGIN_NAME = "debug";
    private debugMode;
    private normalMaterial;
    private depthMaterial;
    private dispatcher;
    private drivenCullingMaterial;
    private drivenShadingMaterial;
    destroy(): void;
    updateFrameSize(_width: number, _height: number): void;
    updateEffect(_scene: SceneAdaptor, _isFrameStable: boolean, _isCameraStable: boolean, _effectConfig: IEffectConfig): void;
    updateGraphHash(_hasher: HashKeyBuilder): void;
    updateRenderGraph(graph: RenderGraph, context: PipelineContext, depthPyramid: RenderTargetNode): void;
    createConfig(): {
        enabled: {
            get: () => boolean;
            set: (v: boolean) => void;
        };
        debugMode: {
            get: () => DebugMode;
            set: (v: DebugMode) => void;
        };
        depthPacking: {
            get: () => DepthPackingStrategies;
            set: (v: DepthPackingStrategies) => void;
        };
    };
}

declare class PostPipeline {
    /**
     * @internal
     */
    isPerformanceSlow: boolean;
    /**
     * @internal
     */
    currentRenderMode: RenderMode;
    /**
     * @internal
     */
    adaptor: SceneAdaptorDispatcher;
    /**
     * @internal
     */
    rendererAdaptor: RendererAdaptor;
    private depthPyramid;
    private effectComposer;
    _getEffectComposer(): EffectComposer;
    sceneClipPlugin: SceneClipPlugin;
    shadowMapPlugin: ShadowMapPlugin;
    backgroundPlugin: BackgroundPlugin;
    splattingPlugin: SplattingPlugin;
    deferredPlugin: DeferredPlugin;
    transparentLinePlugin: TransparentLinePlugin;
    forwardPlugin: ForwardPlugin;
    stylizePlugin: StylizePlugin;
    aoPlugin: AOPlugin;
    outlinePlugin: OutlinePlugin;
    overlayScene: OverlayScenePlugin;
    highlightPlugin: HighlightPlugin;
    taaPlugin: TAAPlugin;
    compositePlugin: CompositePlugin;
    debugPlugin: DebugPlugin;
    private _cachedPlugins?;
    private get plugins();
    constructor(rendererAdaptor: RendererAdaptor);
    mapPlugins(callback: (plugin: PipelinePlugin) => void): void;
    updateRenderer(renderer: IRenderer): void;
    resetContentCache(): void;
    setFrameSize(width: number, height: number): void;
    updateEffect(scene: SceneAdaptor, isFrameStable: boolean, isCameraStable: boolean, renderingConfig: RenderingConfig, drivenCullingConfig: DrivenCullingConfig): void;
    private shouldRenderCurrentFrameByHZB;
    private shouldRenderNextFrameByHZB;
    shouldRenderFrame(): boolean;
    shouldRenderNextFrame(): boolean;
    render(sceneAdaptor: SceneAdaptor, renderingConfig: RenderingConfig, drivenCullingConfig: DrivenCullingConfig): void;
    renderSnapshot(scene: SceneAdaptor, target: OverrideScreenOutputTarget, renderingConfig: RenderingConfig, drivenCullingConfig: DrivenCullingConfig): void;
    private graphCaches;
    private volatileGraphCaches;
    private genHZBMaterial;
    private createRenderGraph;
    destroy(): void;
}

interface PipelineConfig {
    MSAA: {
        enabled: ConfigCell$1;
    };
    SceneClip: ReturnType;
    AO: ReturnType;
    Background: ReturnType;
    Splatting: ReturnType;
    Deferred: ReturnType;
    Forward: ReturnType;
    TransparentLine: ReturnType;
    Outline: ReturnType;
    Highlight: ReturnType;
    ShadowMap: ReturnType;
    Stylize: ReturnType;
    TAA: ReturnType;
    Composite: ReturnType;
    Debug: ReturnType;
}
/**
 * @deprecated
 */
interface DeprecatedPipelineConfig {
    isPreferMultiSampling: ConfigCell$1;
    debug: {
        enabled: ConfigCell$1;
    };
    renderMode: {
        type: ConfigCell$1;
    };
    deferred: {
        enabled: ConfigCell$1;
        enableWhiteBalance: ConfigCell$1;
        enablePseudoColor: ConfigCell$1;
        pseudoColorConfig: ConfigCell$1<{
            colors: number[];
            gradations: number[];
        }>;
        temperature: ConfigCell$1;
        autoExposedEnabled: ConfigCell$1;
        keyMinuend: ConfigCell$1;
        gamma: ConfigCell$1;
        multiplier: ConfigCell$1;
        burnValue: ConfigCell$1;
        contrast: ConfigCell$1;
    };
    OIT: {
        enabled: ConfigCell$1;
    };
    outline: {
        useMrt: ConfigCell$1;
        highQuality: ConfigCell$1;
        enablePhongSolidMode: ConfigCell$1;
        enableDepth: ConfigCell$1;
        outlineMaskEnabled: ConfigCell$1;
        outlineColor: ConfigCell$1;
        solidBaseColor: ConfigCell$1;
        edgeThickness: ConfigCell$1;
        indexEdgeThickness: ConfigCell$1;
        normalEdgeThickness: ConfigCell$1;
        depthEdgeThickness: ConfigCell$1;
        coefficient: ConfigCell$1;
        normalCoefficient: ConfigCell$1;
        indexCoefficient: ConfigCell$1;
        depthCoefficient: ConfigCell$1;
    };
    toon: {
        tooniness: ConfigCell$1;
        toonColor: ConfigCell$1;
        diffuseColor: ConfigCell$1;
        smoothnessMin: ConfigCell$1;
        smoothnessMax: ConfigCell$1;
    };
    stylizeFilter: {
        enabled: ConfigCell$1;
        /** @deprecated use target instead */
        applyToBackgroundAndGround: ConfigCell$1;
        target: ConfigCell$1;
        brightness: ConfigCell$1;
        contrast: ConfigCell$1;
        saturation: ConfigCell$1;
        hue: ConfigCell$1;
        colorBalance: ConfigCell$1;
        texture: ConfigCell$1;
        lut: ConfigCell$1;
    };
    ao: {
        enabled: ConfigCell$1;
        aoBias: ConfigCell$1;
        aoRadius: ConfigCell$1;
        aoIntensity: ConfigCell$1;
        blurKernelRadius: ConfigCell$1;
        blurEdgeSharpness: ConfigCell$1;
    };
    planarShadow: {
        enabled: ConfigCell$1;
        downScale: ConfigCell$1;
        intensity: ConfigCell$1;
        blurKernelRadius: ConfigCell$1;
        maxGroundThickness: ConfigCell$1;
        maxGroundHeight: ConfigCell$1;
    };
    shadow: {
        enableTemporal: ConfigCell$1;
        targetJitterSize: ConfigCell$1;
    };
    highLight: {
        enabled: ConfigCell$1;
        width: ConfigCell$1;
        colorA: ConfigCell$1;
        colorB: ConfigCell$1;
        borderOpacity: ConfigCell$1;
        innerOpacity: ConfigCell$1;
    };
    transparentLine: {
        opacity: ConfigCell$1;
        transparentColor: ConfigCell$1;
        lineColor: ConfigCell$1;
        edgeThreshold: ConfigCell$1;
        drawWithOriginalMaterial: ConfigCell$1;
        drawAdditionalLines: ConfigCell$1;
    };
    taa: {
        enabled: ConfigCell$1;
        maxSample: ConfigCell$1;
        outputSample: ConfigCell$1;
        waitingTime: ConfigCell$1;
    };
    staticFrameCache: {
        enabled: ConfigCell$1;
    };
    composite: {
        enabled: ConfigCell$1;
        multiSamplingEnabled: ConfigCell$1;
        staticFrameCacheEnabled: ConfigCell$1;
    };
    sceneClip: {
        enabled: ConfigCell$1;
        clippingEnabled: ConfigCell$1;
        clippingPlanes: ConfigCell$1;
    };
    Splatting: PipelineConfig['Splatting'];
    __INNER__: PipelineConfig;
}

interface ConfigCell {
    get: () => T;
    set: (value: T) => void;
}
declare enum RenderMode {
    SHADING = "SHADING",
    OUTLINE_ONLY = "OUTLINE_ONLY",
    OUTLINE_WITH_SHADING = "OUTLINE_WITH_SHADING",
    TRANSPARENT_LINE = "TRANSPARENT_LINE",
    TOON_SHADING = "TOON_SHADING",
    OUTLINE_WITH_TOON = "OUTLINE_WITH_TOON",
    DEPTH = "DEPTH",
    NORMAL = "NORMAL"
}
interface EngineInitializeConfig {
    name?: string;
    antialiasing?: boolean;
    alpha?: boolean;
    preferWebGL1?: boolean;
    /**
     * will pass it to getContext
     * @default true
     * @deprecated not all context support `preserveDrawingBuffer`
     * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/getContext
     */
    preserveDrawingBuffer?: boolean;
}
interface ViewerConfig {
    forceFrameIsUnstable: ConfigCell;
    canvas: {
        renderPixelRatio: ConfigCell;
    };
    autoInstance: {
        enabled: ConfigCell;
        autoInstanceKeyEnabled: ConfigCell;
    };
    multiMeshMerge: {
        enabled: ConfigCell;
    };
    popMeshMerge: {
        enabled: ConfigCell;
    };
    gpuDriven: {
        enabled: ConfigCell;
        textureCompression: ConfigCell;
        frustumCullingEnabled: ConfigCell;
        occlusionCullingEnabled: ConfigCell;
        detailCullingEnabled: ConfigCell;
        layersCullingEnabled: ConfigCell;
        triCullingEnabled: ConfigCell;
        occlusionCullingBias: ConfigCell;
    };
    shadingMode: {
        physical: ConfigCell;
    };
    statistics: {
        enableDrawcallClassify: ConfigCell;
    };
    global: {
        meshBVHEnabled: ConfigCell;
    };
    scene: {
        onlyDirectLight: ConfigCell;
        layerLightEnabled: ConfigCell;
        sceneBVHEnabled: ConfigCell;
    };
    /**
     * TODO: deprecated pipeline config. we need disable use and remove it.
     */
    renderMode: {
        type: ConfigCell;
    };
    staticFrameCache: {
        enabled: ConfigCell;
    };
    isExtraCopyBeforeScreenEnabled: ConfigCell;
    ground: {
        enabled: ConfigCell;
        offsetA: ConfigCell;
        gridGapSizeA: ConfigCell;
        colorA: ConfigCell;
        offsetB: ConfigCell;
        gridGapSizeB: ConfigCell;
        colorB: ConfigCell;
        isGroundColorEnabled: ConfigCell;
        groundColor: ConfigCell;
    };
    background: {
        active: ConfigCell;
        basic: {
            color: ConfigCell;
            alpha: ConfigCell;
            texture: ConfigCell>;
        };
        solid: {
            color: ConfigCell;
            alpha: ConfigCell;
        };
        envmap: {
            texture: ConfigCell;
            luma: ConfigCell;
            verticalRotation: ConfigCell;
            horizonRotation: ConfigCell;
            reverseHorizon: ConfigCell;
        };
        gradient: {
            skyColor: ConfigCell;
            groundColor: ConfigCell;
        };
        sky: {
            enablePreSkyMap: ConfigCell;
            luminance: ConfigCell;
            turbidity: ConfigCell;
            rayleigh: ConfigCell;
            mieCoefficient: ConfigCell;
            mieDirectionalG: ConfigCell;
        };
    };
    coordinateSystem: {
        enabled: ConfigCell;
        x: ConfigCell;
        y: ConfigCell;
        size: ConfigCell;
    };
    effects: DeprecatedPipelineConfig;
}
declare type ConfigCellImpl = T extends object ? {
    [P in keyof T]?: T[P] extends ConfigCell ? V : ConfigCellImpl;
} : T;

declare enum SnapshotResultResultType {
    Success = 0,
    Empty = 1,
    Error = 2
}
interface SnapshotCameraInfo {
    projectionMatrix: Matrix4;
    worldMatrix: Matrix4;
}
declare class SnapshotResult {
    data: Uint8Array;
    size: Size;
    cameraInfo: SnapshotCameraInfo;
    worldBox?: Box3 | undefined;
    type: SnapshotResultResultType;
    reason?: any;
    constructor(data: Uint8Array, size: Size, cameraInfo: SnapshotCameraInfo, worldBox?: Box3 | undefined);
    static exception(type: SnapshotResultResultType, reason?: any): SnapshotResult;
    flipY(): this;
    createDataURL(): string;
    downloadImage(name?: string): void;
}

declare enum SnapshotBoxPrecision {
    BoundingBox = "BoundingBox",
    Vertex = "Vertex"
}
declare enum SnapshotAxisDirection {
    Top = "top",
    Bottom = "bottom",
    Left = "left",
    Right = "right",
    Front = "front",
    Back = "back"
}

interface SnapshotRenderConfig {
    worldBox?: Box3;
    boxPrecision?: SnapshotBoxPrecision;
}
/**
 * This class provide function to get
 */
declare class SnapshotRenderer$1 {
    private renderer;
    defaultScene: Scene3D;
    constructor(renderer: IRenderer);
    destroy(): void;
    private postPipeline;
    private pipelineConfig;
    backgroundColor: Color;
    backgroundAlpha: number;
    defaultAdjustMaxSideSize: number;
    extraPaddingForEffect: number;
    skipSceneVisible: boolean;
    private camera;
    getCamera(): Readonly;
    private effectConfig;
    private drivenCullingConfig;
    private renderingConfig;
    /**
     * @internal
     */
    onRendererChanged(renderer: IRenderer): void;
    /**
     * Set RenderMode and AO effect for snapshot rendering.
     */
    setEffectConfig(mode: RenderMode, isAOEnabled?: boolean, isDeferredEnabled?: boolean, isHighQuality?: boolean, taaSampleCount?: number): void;
    private updatePipelineParam;
    setCameraLayer(layers: Layers): void;
    /**
     * A function to define the width and height of snapshot.
     */
    resolutionAdjustor: (size: Size) => {
        width: number;
        height: number;
    };
    /**
     * Render the objects in specified scene except other objects.
     * @param object
     * @param direction set the camera facing direction.
     * @param generate
     * @param extraPadding
     * @param config
     */
    private renderImpl;
    private renderInner;
    private renderWithOverrideMaterialImpl;
    /**
     * @deprecated use `renderWithOverrideMaterialAsync` instead, sync function will unavailable in webgpu version
     */
    renderWithOverrideMaterial(object: Object3D, direction: SnapshotAxisDirection, material: Material, config?: SnapshotRenderConfig): SnapshotResult;
    renderWithOverrideMaterialAsync(object: Object3D, direction: SnapshotAxisDirection, material: Material, config?: SnapshotRenderConfig): Promise;
    /**
     * @deprecated use `renderAsync` instead, sync function will unavailable in webgpu version
     */
    render(object: Object3D, direction: SnapshotAxisDirection, scene?: Scene3D, config?: SnapshotRenderConfig): SnapshotResult;
    renderAsync(object: Object3D, direction: SnapshotAxisDirection, scene?: Scene3D, config?: SnapshotRenderConfig): Promise;
    private renderCustomViewImpl;
    /**
     * @deprecated use `renderCustomViewAsync` instead, sync function will unavailable in webgpu version
     */
    renderCustomView(object: Object3D | Object3D[], camera: Camera3D, resolution: Size): SnapshotResult;
    renderCustomViewAsync(object: Object3D | Object3D[], camera: Camera3D, resolution: Size): Promise;
    private readPixels;
    private readPixelsAsync;
}

declare class SnapShotAdaptor extends SceneAdaptor {
    objectToSnapShot: DrawableList;
    objectToSnapShotProjected: Nullable;
    constructor(camera: Camera3D, objectToSnapShot: DrawableList, scene: Scene3D);
    get origin(): DrawableList;
    get default(): ProjectedDrawcallList;
    destroy(): void;
}

declare type IPipelineConfig$1 = ConfigCellImpl> & {
    Stylize?: {
        /**
         * @deprecated use target instead
         */
        applyToBackgroundAndGround?: boolean;
    };
};
interface RenderConfig {
    mode: RenderMode;
    deferred: boolean;
    ao: boolean;
    antialias: 'ssaa' | 'msaa' | 'taa' | 'disable';
    outline: 'default';
    resolutionRatio: number;
    physicalSizeRatio: number;
    background: [number, number];
    light: 'default' | 'scene' | Light[];
    overrideMaterial: Material | undefined;
    ignoreVisible: boolean;
    maxRenderSize: number;
    calcRenderSizeType: 'default' | 'pixel';
    autoPOT: boolean;
    combineDepthAlpha: boolean;
    overrideOutputSize: Size | undefined;
    pipelineConfig: IPipelineConfig$1;
}
interface DirectionCameraCustom {
    type: SnapshotAxisDirection;
    layer?: number;
    worldBox?: Box3;
    boxPrecision?: SnapshotBoxPrecision;
}
interface CustomCamera {
    type: Camera3D;
    size: Size;
}
interface SnapshotCtx {
    drawableList: DrawableList;
    scene: Scene3D;
    camera: Camera3D;
    size: Size;
    freeables: RenderTarget[];
}
declare enum PresetRenderConfig {
    Default = "default",
    Tool_2D = "tool_2d",
    Tool_2D_Depth = "tool_2d_depth"
}
declare class SnapshotRenderer {
    private DEFAULT_PIPELINE_CONFIG;
    private renderer;
    private pipeline;
    private pipelineConfig;
    private defaultScene;
    private defaultCamera;
    private defaultLights;
    private renderConfig;
    private isDestroy;
    private isAdvancedBackend;
    private quadDrawer;
    private downsample;
    private downsampleDepth;
    private mixColorDepth;
    private depthMaterial;
    private drivenCullingConfig;
    private renderingConfig;
    constructor(renderer: IRenderer);
    get config(): Readonly;
    private get realRatio();
    destroy(): void;
    private updateRenderConfig;
    /**
     * @internal
     */
    onRendererChanged(renderer: IRenderer): void;
    private getAxisCamera;
    private baseShading;
    generateDepthTexture(width: number, height: number, multiSample: boolean, adaptor: SnapShotAdaptor, ctx: SnapshotCtx): RenderAttachment;
    private downsampleShading;
    private mixDepthShading;
    private inner_render;
    private prerender;
    render(object: Object3D | Object3D[], camera: SnapshotAxisDirection | DirectionCameraCustom | CustomCamera, config?: PresetRenderConfig | Partial): Promise;
}

declare class RenderEngine extends EventDispatcher {
    private _enablePhysicalShading;
    get enablePhysicalShading(): boolean;
    set enablePhysicalShading(v: boolean);
    renderer: IRenderer;
    config: EngineInitializeConfig;
    forceFrameIsUnstable: boolean;
    snapshotRenderer: SnapshotRenderer;
    deprecatedSnapshotRenderer: SnapshotRenderer$1;
    lastRenderedFrameId: number;
    private isRefreshRenderables;
    private _renderPixelRatio;
    private lastRestoreTimeStamp;
    private _countOfFailed;
    private _sumOfTime;
    private _restoreFailed;
    private canvasContainer;
    private canvas;
    private requestedSize?;
    constructor(canvasContainer: HTMLElement, config: EngineInitializeConfig);
    get renderParameter(): RendererParameters;
    get width(): number;
    get height(): number;
    get canvasElement(): HTMLCanvasElement;
    set renderPixelRatio(value: number);
    get renderPixelRatio(): number;
    refreshRenderables(): void;
    private toggleWebgpu;
    destroy(): void;
    resize(size?: Size): void;
    render(scene: Scene3D, camera: Camera3D, pipeline: PostPipeline, isCameraChange: boolean, isCameraStable: boolean, renderingConfig: RenderingConfig, drivenCullingConfig: DrivenCullingConfig, viewport?: Vector4, // x, y, width, height
    frameId?: number, forceRender?: boolean): boolean;
    afterRender(): void;
    /**
     * @internal
     */
    _unsafeDestroyRenderer(): void;
    resetRenderer(canvas?: HTMLCanvasElement, context?: WebGLRenderingContext | WebGL2RenderingContext): void;
    private onCtxLost;
    private onWebGPUUnstable;
    private onWebGPUValidationFailed;
    private checkRestoreCtx;
}

declare class Picker {
    readonly raycaster: Raycaster;
    private viewer;
    constructor(viewer: Viewer);
    private intersectObject;
    pick(coordinates: Vector2, camera: Camera3D, pickFirst?: boolean, objects?: Drawable[]): Intersection[];
    pickFirst(camera: Camera3D, objects?: Drawable[]): Intersection[];
}

/**
 * This class is used to link points as one by one and draw a continuous line between them.
 * It supports any type of geometry, but only line material is supported.
 * The segment and loop line also need to extend this class.
 */
declare class Line extends Drawable> {
    /**
     * Check the type whether it belongs to Line.
     * This value should not be changed by user.
     */
    isLine: boolean;
    /**
     * Decisive attribute to draw this object as continuous line.
     */
    drawMode: DrawMode;
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(geometry?: BufferGeometry, material?: M | M[]);
    /**
     * Get intersections between a casted {@link Ray| ray} and this Line.
     * The method {@link Raycaster.intersectObject| intersectObject()} will call this method, but the results are not ordered.
     * @param {Raycaster} raycaster the instance of Raycaster is used to get the data for calculation.
     * @param {Intersection} intersects the result will be stored here.
     */
    raycastJsImpl(raycaster: Raycaster, intersects: Intersection[]): void;
    /**
     * Return a clone of this object.
     */
    clone(recursive?: boolean): Line;
}

declare type LineBasicMaterialParameters = MaterialParameters & ColorWithAlphaParam;
/**
 * Give linear object a specific color.
 */
declare class LineBasicMaterial extends SceneClipMaterial {
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(p?: LineBasicMaterialParameters);
    /**
     * Let color become to gradient from one end to another end.
     */
    enableVertexColor: boolean;
    /**
     * @deprecated
     */
    bias: number;
    /**
     * The basic color of lines.
     * @tips change the color by {@link setValues| setValues()} that is a better way.
     */
    readonly color: ColorWithAlpha;
    /**
     * Generate a key to make engine know user changes attribute {@link enableVertexColor| enableVertexColor}.
     * This method may override in extended class.
     */
    generateShaderKey(r: ShaderComponentRegistry): string;
    /**
     * Change the corresponding attribute according to the values of given {@link LineBasicMaterialParameters| parameters}.
     * @param {LineBasicMaterialParameters} values a object of specified type contains parameters.
     */
    setValues(values?: LineBasicMaterialParameters): void;
    /**
     * @ignore
     */
    updateShadingUniforms(program: WGLProgram): void;
    /**
     * @ignore
     */
    extendShaderShading(b: ShaderBuilder, _r: ShaderComponentRegistry): void;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx an instance used to store the data of scene objects.
     */
    serialize(ctx: Serializer): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx an instance give the method to take the data for attribute.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Copy the data to this instance from other instance.
     * @param {LineBasicMaterial} other the source of copied data.
     */
    copy(other: LineBasicMaterial): this;
    /**
     * Return a cloned instance of this class.
     */
    clone(): LineBasicMaterial;
}
declare type ColorWithAlphaParam = ConvertMaterialParameters>;
/**
 * This class give a simple shading method for the objects which does not need complicated shading,
 * such as {@link PointsMaterial| PointsMaterial}, {@link FatLineMaterial| FatLineMaterial} and {@link LineBasicMaterial| LineBasicMaterial}.
 */
declare class ColorWithAlpha extends ShaderComponent {
    /**
     * Determine the color's rgb.
     */
    color: Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "g" | "r" | "b" | "isColor" | "equals" | "getHex" | "getSerializeData">>;
    /**
     * Determine the alpha of color's rgba.
     */
    opacity: number;
    /**
     * The name of instance's class.
     */
    className(): string;
    /**
     * Change the corresponding attribute according to the values of given {@link ColorWithAlphaParam| parameters}.
     * @param {ColorWithAlphaParam} values a object of specified type contains parameters.
     */
    setValues(param: ColorWithAlphaParam): void;
    /**
     * @ignore
     */
    extendShaderShading(builder: ShaderBuilder): void;
    /**
     * @ignore
     */
    updateShadingUniforms(program: WGLProgram): void;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx an instance used to store the data of scene objects.
     */
    serialize(ctx: Serializer): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx an instance give the method to take the data for attribute.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Copy the data to this instance from other instance.
     * @param {ColorWithAlpha} other the source of copied data.
     */
    copy(other: ColorWithAlpha): this;
    /**
     * Return a cloned instance of this class.
     */
    clone(): ColorWithAlpha;
}
/**
 * @scale This parameter influence the length both of gaps and segments.
 * @gapSize This parameter influence the length of gaps.
 * @dashSize This parameter influence the length of segments.
 * @viewScale This parameter influence the length of one dash with one gap and segment.
 * This parameter commonly do not need user to set it.
 * It is automatically updated when the zoom of camera is changed.
 */
declare type LineDashParam = ConvertMaterialParameters>;
/**
 * This class is used to control the length of gaps and segments for dashed line material,
 * which includes {@link FatLineMaterial| FatLineMaterial} and {@link LineDashedMaterial| LineDashedMaterial}.
 */
declare class LineDash extends ShaderComponent {
    constructor();
    /**
     * This parameter influence the length both of gaps and segments.
     */
    scale: number;
    /**
     * This parameter influence the length of gaps.
     */
    gapSize: number;
    /**
     * This parameter influence the length of segments.
     */
    dashSize: number;
    /**
     * secondary gap
     * @defaultValue 0
     */
    gapSize2: number;
    /**
    * secondary dash
    * @defaultValue 0
    */
    dashSize2: number;
    /**
     * This parameter influence the length of one dash with one gap and segment.
     * This parameter commonly do not need user to set it.
     * It is automatically updated when the zoom of camera is changed.
     */
    viewScale: number;
    /**
     * This material can not be used to instanced object.
     */
    useInstance: boolean;
    /**
     * The name of instance's class.
     */
    className(): string;
    /**
     * Change the corresponding attribute according to the values of given {@link LineDashParam | parameters}.
     * @param {LineDashParam} values a object of specified type contains parameters.
     */
    setValues(param: LineDashParam): void;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx an instance used to store the data of scene objects.
     */
    serialize(ctx: Serializer): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx an instance give the method to take the data for attribute.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * @ignore
     */
    extendShaderShading(builder: ShaderBuilder): void;
    /**
     * @ignore
     */
    updateShadingUniforms(program: WGLProgram): void;
    /**
     * Copy the data to this instance from other instance.
     * @param {LineDash} other the source of copied data.
     */
    copy(other: LineDash): LineDash;
    /**
     * Return a cloned instance of this class.
     */
    clone(): LineDash;
}

/**
 * Draw a arrow with a head and a line.
 */
declare class ArrowHelper extends CombinedObjectGroup {
    line: Line;
    cone: Mesh;
    /**
     * @param {Vector3} dir this vector representing the world space direction of arrow. Default is Vector3(0, 0, 1).
     * @param {Vector3} origin the beginning position of arrow's tail. Default is Vector3(0, 0, 0).
     * @param {number} length the length of line. Default is 1.
     * @param {number} color the color of arrow. Default is 0xffff00.
     * @param {number} headLength the height of head. Default is 0.2 * length.
     * @param {number} headWidth the radius of arrow's head. Default is 0.2 * headLength.
     */
    constructor(dir?: Vector3, origin?: Vector3, length?: number, color?: number, headLength?: number, headWidth?: number);
    /**
     * Change the direction of the arrow.
     */
    setDirection(dir: Vector3): void;
    /**
     * Change the length of the arrow includes the line and the head.
     */
    setLength(length: number, headLength?: number, headWidth?: number): void;
    /**
     * Change the color of the arrow includes the line and the head.
     */
    setColor(color: Color): void;
    copy(source: ArrowHelper): this;
    clone(): ArrowHelper;
    destroyCombined(): void;
}

/**
 * This class is used to draw a fixed coordinate system on screen.
 */
declare class CoordinateSystemHelper implements Renderable {
    /**
     * The switch of this effect.
     * @defaultValue `false`.
     */
    enabled: boolean;
    arrowHelperX: ArrowHelper;
    arrowHelperY: ArrowHelper;
    arrowHelperZ: ArrowHelper;
    total_length: number;
    private location;
    private isCameraNeedsUpdate;
    private axisCamera;
    private alphabetX;
    private alphabetY;
    private alphabetZ;
    private isWithAlphabets;
    destroy(): void;
    constructor(isWithAlphabets?: boolean);
    private createArrowAxis;
    private createAlphabet;
    getLocation(): Vector3;
    setLocation(x?: number, y?: number, size?: number): void;
    setAlphabetParam(scale?: number, colorX?: Color, colorY?: Color, colorZ?: Color): void;
    setAlphabetOffset(offsetX?: Vector3, offsetY?: Vector3, offsetZ?: Vector3): void;
    updateAxisCamera(camera: Camera3D): void;
    private renderArrowHelper;
    private renderAlphabet;
    private renderByOrder;
    config(_: IRenderer): boolean;
    render(renderer: IRenderer): void;
}

/**
 * ArrayCamera can be used in order to efficiently render a scene with a predefined set of cameras. This is an important performance aspect for rendering VR scenes.

 * An instance of ArrayCamera always has an array of sub cameras. It's mandatory to define for each sub camera the viewport property which determines the part of the viewport that is rendered with this camera.
 * @deprecated use `Viewport` instead.
 */
declare class ArrayCamera extends ElementEventDispatcher {
    /**
     * Check the type whether it belongs to ArrayCamera.
     * This value should not be changed by user.
     */
    isArrayCamera: boolean;
    /**
    * An array of cameras.
    */
    cameras: Camera3D[];
    constructor(arr?: Camera3D[]);
}

declare class Viewport {
    readonly name: string;
    private isDestroyed;
    private viewer;
    private engine;
    /**
     * @internal
     */
    pipeline: PostPipeline;
    /**
     * @internal
     */
    viewIndex: number;
    /**
     * @internal
     */
    drivenCullingConfig: DrivenCullingConfig;
    private _config;
    get config(): ViewerConfig;
    /**
     * @internal
     */
    scene: Scene3D;
    private isCameraChange;
    private isCameraStable;
    private cameraObserver;
    private _camera;
    get camera(): Camera3D;
    set camera(camera: Camera3D);
    /**
     * @internal
     */
    requestRenderHandler?: RequestRenderHandler;
    private requestRender;
    layer: number;
    private _bound;
    get bound(): Vector4;
    set bound(v: Vector4);
    constructor(name: string, viewer: Viewer, engine: RenderEngine, scene: Scene3D, viewIndex: number, bound?: Vector4);
    private size;
    private viewBound;
    private updateTlsFlag;
    /**
     * @internal
     */
    resize(size: Size): void;
    /**
     * @internal
     */
    updateRenderer(): void;
    /**
     * @internal
     */
    resetPipelineCache(): void;
    /**
     * @internal
     */
    render(frameId: number, forceRender?: boolean, isPerformanceSlow?: boolean): boolean;
    setHighlightGroups(groups: HighlightGroup[]): void;
    snapshotRenderResult(range?: IRange): Promise | undefined;
    destroy(): void;
}

declare type RequestRenderHandler = () => void;
interface ViewerPlugin$1 {
    /**
     * called when register to viewer
     */
    init(viewer: Viewer, viewerContainer: HTMLElement): void;
    /**
     * called when unregister from viewer or destroying viewer.
     */
    destroy(viewer: Viewer, viewerContainer: HTMLElement): void;
    /**
     * called on every rendering request started.
     * @param requestFrameId the frame id will be rendered in current rendering request
     * @param lastRenderedFrameId last actually rendered the frame id
     */
    beforeRendering?(requestFrameId: number, lastRenderedFrameId: number): void;
    /**
     * called on every rendering request finish, but the rendering request maybe not actually executed.
     * use `renderedFrameId` to check whether rendering request has executed.
     * @param renderedFrameId the latest rendered frame id after current rendering request finished.
     */
    afterRendering?(renderedFrameId: number): void;
}
/**
 * This class is used to set up the configuration and canvas for RenderEngine.
 * It also contains instance of grid-like ground, background and Coordinate System.
 */
declare class Viewer extends EventDispatcher {
    static instances: Set;
    /**
     * The name of viewer, which could be empty.
     */
    name: string;
    /**
     * HTMLElements, which is set in the constructor function.
     */
    private _canvasContainer;
    get canvasContainer(): HTMLElement;
    private engine;
    /**
     * @internal
     */
    _getEngine(): RenderEngine;
    /**
     * @internal
     */
    frameInfo: FrameInfo;
    private statistics;
    private scene;
    /**
     * @internal
     */
    renderingConfig: RenderingConfig;
    /**
     * Get the instance of 3D scene in current viewer.
     */
    getScene(): Scene3D;
    /**
     * If some users hopes to replace or update the 3d scene, they need to use the function,
     * which has been invoked in constructor to initialize the root.
     * @param scene A Scene3D object of current scene.
     * @tips If change the scene, ground, coordinate system and background will be reset.
     */
    setScene(scene: Scene3D): void;
    private _isDestroyed;
    get isDestroyed(): boolean;
    /**
     * Enabled instance rendering can make engine accelerate render for a large number of same objects in the scene.
     * It is effective for both 2D and 3D scene.
     * @defaultValue `false`
     */
    private _enableInstance;
    get enableInstance(): boolean;
    set enableInstance(v: boolean);
    /**
     * Enabled auto instance key can automatically generate instance key on meshes without this key originally.
     * @defaultValue `false`
     */
    private _enableAutoInstanceKey;
    get enableAutoInstanceKey(): boolean;
    set enableAutoInstanceKey(v: boolean);
    /**
     * Enabled this attribute can accelerate render for all mesh by merge some small objects into one big buffer.
     * It is effective for both 2D and 3D scene.
     * @defaultValue `true`
     */
    private _enableMultiMeshMerge;
    get enableMultiMeshMerge(): boolean;
    set enableMultiMeshMerge(v: boolean);
    /**
     * Enabled this attribute can accelerate render each mesh by merge some small objects into one big buffer.
     * It is only effective for 3D scene.
     * @defaultValue `true`
     */
    private _enableMeshMerge;
    get enableMeshMerge(): boolean;
    set enableMeshMerge(v: boolean);
    /**
     * Enabled gpu driven.
     * @internal
     * @defaultValue `false`
     */
    get enableGpuDriven(): boolean;
    /**
     * @internal
     */
    set enableGpuDriven(v: boolean);
    /**
     * Gpu driven texture compression type.
     * @defaultValue `TextureCompression.BC3HighQuality`
     * @internal
     */
    get gpuDrivenTextureCompression(): TextureCompression;
    /**
     * @internal
     */
    set gpuDrivenTextureCompression(v: TextureCompression);
    get rendererBackend(): RendererBackend;
    private plugins;
    /**
     * @internal
     */
    registerPlugin(plugin: ViewerPlugin$1): void;
    /**
     * @internal
     */
    unregisterPlugin(plugin: ViewerPlugin$1): void;
    /**
     * This method provides some information of the engine for users.
     * The instance of RenderInfo can get the number of refreshed times in the Shader program, materials and lights.
     * The frameInfo includes Fps, usage of CPU and so on.
     * The objectInfo includes the number of geometries, textures, drawcall, vertices, faces and so on.
     */
    get renderInfo(): RenderInfo;
    get snapshotRendererV2(): SnapshotRenderer;
    /**
     * An customizable arrow function will be called when use requestRender();
     */
    private _requestRenderHandler?;
    get requestRenderHandler(): RequestRenderHandler | undefined;
    set requestRenderHandler(v: RequestRenderHandler | undefined);
    /**
     * Request to invoke RenderHandler function if it is not null;
     */
    requestRender: () => void;
    private onlyDefaultViewport;
    private viewportList;
    /**
     * @internal
     */
    get defaultViewport(): Viewport;
    /**
     * @internal
     */
    clearPipelineCache(): void;
    /**
     * @internal
     */
    set renderPixelRatio(value: number);
    /**
     * @internal
     */
    get renderPixelRatio(): number;
    /**
     * Creates an instance of Viewer.
     * @param {HTMLElement} canvasContainer
     * A dom of canvas where is used to render.
     * @param {EngineInitializeConfig} engineInitializeConfig
     * User's defined object of EngineInitializeConfig includes antialiasing and alpha, both are boolean types.
     * Default value is usually true for antialiasing and false for alpha
     * @return
     */
    constructor(canvasContainer: HTMLElement, engineInitializeConfig: EngineInitializeConfig);
    createViewport(name: string, bound?: Vector4): Viewport;
    removeViewport(viewport: Viewport): void;
    clearViewport(): void;
    private lastRenderEmitTime;
    private noRenderChecker?;
    private notifyRendered;
    /**
     * Give an asynchronous function to user to block program until passed a period from last render.
     * @param {number} time wait for setting milliseconds. Default is 1000.
     */
    waitForRenderOver: (v?: number) => Promise;
    /**
     * Get real size of drawing area from engine's width and height.
     * The size normally is same as canvas.
     */
    getSize(): Size;
    /**
     * Change the size of rendering area, if the size is not given then it will automatically adapt to the canvas.
     * @param {Size} size Optional parameter.
     */
    resize(size?: Size): void;
    /**
     * keep instance but do nothing in CPU;
     */
    private isPaused;
    pause(): void;
    resume(): void;
    /**
     * @internal
     */
    forceNextFrameRender: boolean;
    private isPerformanceSlow;
    /**
     * Render one frame with the configuration and objects in the scene.
     * All setting of config, scene or camera need to be finished before this.
     * @tip If user draw a 2D scene, the attribute render2D should be set to true in advance.
     */
    render(): void;
    /**
     * Get render result to a TypedArray from the Framebuffer.
     * The result is a rectangular area from left-bottom beginning to right-top ending pixel.
     * @param {Uint8Array} resultData All color will be store in this array, which color' format is RGBA within 0-255,
     * @param {number} x Beginning pixel position's x.
     * @param {number} y Beginning pixel position's y.
     * @param {number} width Rectangular area's width.
     * @param {number} height Rectangular area's height.
     * @deprecated use `readRenderResultAsync` instead
     */
    readRenderResult(resultData: Uint8Array, range: IRange): void;
    /**
     * Get render result to a TypedArray from the Framebuffer.
     * The result is a rectangular area from left-bottom beginning to right-top ending pixel.
     * @param {Uint8Array} resultData All color will be store in this array, which color' format is RGBA within 0-255,
     * @param {number} x Beginning pixel position's x.
     * @param {number} y Beginning pixel position's y.
     * @param {number} width Rectangular area's width.
     * @param {number} height Rectangular area's height.
     */
    readRenderResultAsync(resultData: Uint8Array, range: IRange): Promise | undefined;
    /**
     * Get render result to a Data Url from the canvas api.
     * @deprecated unstable read back, depend on browser's implement, use `readRenderResultAsync` instead.
     * @param {string} type A DOMString indicating the image format. The default type is image/png;
     */
    readRenderResultDataUrl(type?: string, ...args: any[]): string;
    /**
     * stop the listening events,
     * reset scene graph and camera,
     * release the resource of engine
     * and remove bounded canvas.
     */
    destroy(): void;
    /**
     * Statistics data not only include the content of RenderInfo,
     * also provide the size of geometryBuffer, textureByte and Framebuffer and so on.
     * @remarks See {@link renderInfo | renderInfo } for more details.
     */
    getRenderStatistics(): Readonly;
    getMemoryInfo(whenGrowFailed?: boolean): Readonly;
    /**
     * Download a file which store the data of current scene from browser.
     * @param {string} name The name of downloaded file. Default name is debug.
     */
    downloadSceneData(name?: string): void;
    /**
     * If user needs picking feature, this method will offer a Picker's instance with two APIS: pick and pickFirst.
     */
    createPicker(): Picker;
    /**
     * free gpu memory by context lost, restore gpu memory when next draw
     */
    freeGPU(): void;
    /**
     * An instance of SnapshotRenderer used to take snapshot of selected object.
     * @deprecated use snapshotRendererV2
     * @initialize It is initialized in the constructor of the RenderEngine.
     * @remarks See {@link SnapshotRenderer| SnapshotRenderer} for more details.
     */
    get snapshotRenderer(): SnapshotRenderer$1;
    /**
     * An instance of EngineConfig used to manipulate configuration of the engine.
     * @initialize The instance is initialized in constructor function of Viewer.
     * @remarks See {@link EngineConfig| EngineConfig} for more details.
     */
    get config(): ViewerConfig;
    /**
     * The background mode which is shown in current canvas.
     * @defaultValue `BackgroundMode.SkyBackground`
     * @deprecated
     * currentBackground is move to postPipeline
     */
    get currentBackground(): BackgroundMode;
    set currentBackground(v: BackgroundMode);
    get ground(): Ground;
    set ground(v: Ground);
    /**
     * An instance of CoordinateSystemHelper which could be turned on by the config.
     */
    coordSysHelper: CoordinateSystemHelper;
    /**
     * The mode of render which is applied in current scene.
     * @defaultValue `RenderMode.SHADING`
     * @deprecated
     */
    get currentRenderMode(): RenderMode;
    /**
     * An instance of BasicBackground, which only works when the render mode of background is set to BasicBackground.
     * @deprecated use `config.background.basic` instead
     * basicBackground is move to postPipeline
     */
    get basicBackground(): BasicBackground;
    /**
     * @deprecated  set is not allow to use, use `config.background.basic` to update parameters instead.
     * basicBackground is move to postPipeline
     */
    set basicBackground(background: BasicBackground);
    /**
     * An instance of SolidColorBackground, which only works when the render mode of background is set to SolidColorBackground.
     * @deprecated use `config.background.solid` instead
     * solidBackground is move to postPipeline
     */
    get solidBackground(): SolidColorBackground;
    /**
     * @deprecated set is not allow to use, use `config.background.solid` to update parameters instead.
     * solidBackground is move to postPipeline
     */
    set solidBackground(background: SolidColorBackground);
    /**
     * An instance of SkyBackground, which only works when the render mode of background is set to SkyBackground.
     * @deprecated use `config.background.sky` instead
     * skyBackground is move to postPipeline
     */
    get skyBackground(): SkyBackground;
    /**
     * @deprecated set is not allow to use, use `config.background.sky` to update parameters instead.
     * skyBackground is move to postPipeline
     */
    set skyBackground(background: SkyBackground);
    /**
     * An instance of EnvMapBackground, which only works when the render mode of background is set to EnvMapBackground.
     * @deprecated use `config.background.envmap` instead
     * envBackground is move to postPipeline
     */
    get envBackground(): EnvMapBackground;
    /**
     * @deprecated set is not allow to use, use `config.background.envmap` to update parameters instead.
     * envBackground is move to postPipeline
     */
    set envBackground(background: EnvMapBackground);
    /**
     * An instance of GradientBackground, which only works when the render mode of background is set to GradientBackground.
     * @deprecated use `config.background.gradient` instead
     * gradientBackground is move to postPipeline
     */
    get gradientBackground(): GradientBackground;
    /**
     * @deprecated set is not allow to use, use `config.background.gradient` to update parameters instead.
     * gradientBackground is move to postPipeline
     */
    set gradientBackground(background: GradientBackground);
    /**
     * @deprecated use `canvasContainer`
     * Get instance of HTMLElement that will attach canvas which is set in the constructor function.
     */
    getContainerElement(): Readonly;
    /**
     * Change the parameters of background such as mode and corresponding parameters.
     * @param {BackgroundParameter} parameter An object of BackgroundParameter.
     * @deprecated use `config.background` instead.
     */
    updateBackGroundParameter(parameter: BackgroundParameter): void;
    /**
     * Change the mode of background, and the parameters of the background will be set to default values;
     * @param {BackgroundMode} type A constant of BackgroundMode.
     * @deprecated use `config.background.active` instead.
     */
    setBackGroundMode(type: BackgroundMode): void;
    /**
     * Apply user's camera to renderer.
     * This only works for 3D scene.
     * `ArrayCamera` is not supported in this function, use Viewport instead.
     * @param {Camera3D | ArrayCamera} camera An instance belongs or extents form Camera.
     * @tips If the user changes the camera's parameter or uses a new camera, the better way is through this function to avoid errors;
     */
    setCamera(camera: Camera3D | ArrayCamera): void;
    /**
     * Get the camera instance of current viewer.
     * This only works for 3D scene.
     */
    getCamera(): Camera3D;
    /**
     * This method will add highlight effect to all objects in the array.
     * @param {HighLightItem[]} objects HighLightItem is an interface which requires a Drawable object and an optional group index of geometry.
     */
    setHighlightObjects(objects: HighLightItem[]): void;
    setHighlightGroups(groups: HighlightGroup[]): void;
}
declare class RenderStatistics {
    backend: RendererBackend;
    /**
     * The number of WebGL drawcall.
     */
    calls: number;
    /**
     * The number of driven mesh counts.
     */
    drivenDrawcalls: number;
    /**
     * used by frontend custom statistics.
     */
    callsByObjectCategoryId: Map;
    /**
     * used by frontend custom statistics.
     */
    callsBySourceType: Map;
    /**
     * The number of geometry vertices.
     */
    vertices: number;
    /**
     * The number of driven geometry vertices.
     */
    drivenVertices: number;
    /**
     * The number of geometry faces.
     */
    faces: number;
    /**
     * The number of texture.
     */
    textures: number;
    /**
     * The number of BufferGeometry.
     */
    geometries: number;
    /**
     * The number of shader program.
     */
    programs: number;
    /**
     * The number of frame.
     */
    frames: number;
    /**
     * Record some information of refresh.
     */
    counters: Map;
    /**
     * One frame time (CPU + GPU time).
     */
    totalTime: number;
    /**
     * CPU frame time.
     */
    CPUTime: number;
    /**
     * CPU time details.
     */
    timeDetails: Map;
    /**
     * The byte length of geometry attributes
     */
    geometryBufferByteSize: number;
    /**
     * The byte length of texture
     */
    textureByteSize: number;
    /**
     * The byte length of UBO
     */
    uboByteSize: number;
    /**
     * The byte length of FBO
     */
    fboByteSize: number;
    /**
     * The byte length of storageBuffer
     */
    storageByteSize: number;
    /**
     * the byte length of storageBuffer used
     */
    storageByteSizeUsed: number;
}

declare class UBOManager {
    private gl;
    private bindingPoints;
    private UBOMap;
    private totalByteSize;
    constructor(gl: WebGL2RenderingContext);
    getWebGLByteSize(): number;
    bindUBO(ubo: WebGLBuffer, bindPoint: number): void;
    private _create;
    create(provider: UniformBlockObject): WebGLBuffer;
    delete(provider: UniformBlockObject): void;
    freeGPU(): void;
}

declare class ProgramManager {
    private info;
    static PROGRAM_DELETE_TIMEOUT: number;
    uboManager: UBOManager;
    private renderState;
    private programs;
    private cacheMap;
    private deletingMap;
    private currentTimeStamp;
    get activeShaderComponentRegistry(): ShaderComponentRegistry;
    constructor(renderState: RenderState, info: RenderInfo);
    tick(timestamp: number): void;
    get(material: Material): WGLProgram;
    delete: (material: Material) => void;
    freeGPU(): void;
}

interface WGLBufferData {
    buffer: WebGLBuffer;
    type: number;
    bytesPerElement: number;
    version: number;
    referencesBy: Set;
    byteSize: number;
}

declare class BufferManager {
    private webglBufferMap;
    private gl;
    private totalByteSize;
    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
    getWebGLByteSize(): number;
    get(attribute: BufferAttribute): WGLBufferData | undefined;
    delete(attribute: BufferAttribute, bufferGeometry: BufferGeometryBase): void;
    create(attribute: BufferAttribute, bufferType: number, bufferGeometry: BufferGeometryBase): void;
    freeGPU(): void;
}

declare class VAOManager {
    private gl;
    private webglVAOMap;
    private VAOExtension;
    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, extensions: WGLExtensions);
    create(bufferGeometry: BufferGeometryBase, attributeKey: string): boolean;
    delete(bufferGeometry: BufferGeometryBase): void;
    freeGPU(): void;
}

interface ResourceStatistics {
    geometryBufferByteSize: number;
    textureByteSize: number;
    fboByteSize: number;
    uboByteSize: number;
}
declare class ResourceManager {
    readonly gl: WebGLRenderingContext | WebGL2RenderingContext;
    private info;
    readonly bufferManager: BufferManager;
    readonly textureManager: TextureManager;
    readonly programManager: ProgramManager;
    readonly instanceProgramManager: ProgramManager;
    readonly dynamicPrograms: Map;
    readonly uboManager?: UBOManager;
    readonly vaoManager?: VAOManager;
    private geometries;
    constructor(renderer: Renderer);
    outputResourceStatistics(): ResourceStatistics;
    setupGeometry(bufferGeometry: BufferGeometryBase): void;
    setupVAO(bufferGeometry: BufferGeometryBase, attributeKey: string): boolean;
    private onGeometryAttributeChanged;
    private onGeometryDispose;
    getWebGLBufferData(attribute: BufferAttribute): WGLBufferData;
    setupWGLProgram(material: Material, useInstance: boolean): WGLProgram;
    setupWGLUBOBuffer(provider: UniformBlockObject): WebGLBuffer;
    freeGPU(): void;
}

declare type RendererParameters = Required> & {
    version: string;
    name: string;
    canvas: HTMLCanvasElement;
    container: HTMLElement;
    context?: WebGLRenderingContext | WebGL2RenderingContext;
    preferWebGL1?: boolean;
    precision?: string;
    logarithmicDepthBuffer?: boolean;
};
interface MemoryInfo {
    wasm_total_size: number;
    all_real: number;
    attributes_manager_real: number;
    geometries_manager_real: number;
    materials_manager_real: number;
    scene_nodes_manager_real: number;
    scenes_real: number;
    textures_manager_real: number;
    ubo_real: number;
    all_allocated: number;
    attributes_manager_allocated: number;
    geometries_manager_allocated: number;
    materials_manager_allocated: number;
    scene_nodes_manager_allocated: number;
    scenes_allocated: number;
    textures_manager_allocated: number;
    ubo_allocated: number;
}
declare enum RendererBackend {
    WEBGL_JS = "WEBGL_JS",
    WEBGL_WASM = "WEBGL_WASM",
    WEBGL2_JS = "WEBGL2_JS",
    WEBGL2_WASM = "WEBGL2_WASM",
    WEBGPU_WASM = "WEBGPU_WASM"
}
declare enum RendererState {
    Initializing = 0,
    Ready = 1,
    ContextLost = 2,
    Destroyed = 3
}
interface RendererStatus {
    state: RendererState;
    initialized: Promise;
}
interface IRenderer extends EventDispatcher {
    readonly renderInfo: RenderInfo;
    /**
     * @internal
     */
    readonly backend: RendererBackend;
    /**
     * @internal
     */
    readonly rendererStatus: Readonly;
    /**
     * @internal
     */
    readonly parameters: RendererParameters;
    overrideDispatcher: Nullable;
    getGPUInfo(): string;
    beforeFrameRender(requestFrameId: number, lastRenderedFrameId: number): void;
    afterFrameRender(renderedFrameId: number): void;
    updateRenderStatistics(r: RenderStatistics): void;
    getPixelRatio(): number;
    setPixelRatio(value: number): void;
    setSize(width: number, height: number, updateStyle?: boolean): void;
    getSize(): {
        width: number;
        height: number;
    };
    getDrawingBufferSize(): {
        width: number;
        height: number;
    };
    setViewport(x: number, y: number, width: number, height: number): void;
    setViewportInRenderPass(x: number, y: number, width: number, height: number): void;
    setClearColor(color: Color | string | number, alpha?: number): void;
    /**
     * Tells the renderer to clear its color, depth or stencil drawing buffer(s).
     * @param color @default true
     * @param depth @default true
     * @param stencil @default true
     */
    clear(color?: boolean, depth?: boolean, stencil?: boolean): void;
    getCanvas(): HTMLCanvasElement;
    destroy(forceLost?: boolean): void;
    tick(timestamp: number): void;
    getCurrentCamera(): Camera3D;
    useCamera(camera: Nullable): void;
    useRegistry(registry: ShaderComponentRegistry): void;
    renderDrawcall(geometry: BufferGeometryBase, material: Material, object: Drawable, range: Nullable): void;
    renderRenderable(renderable: Renderable): void;
    resetRenderState(): void;
    setMaterialUploadDirty(): void;
    beginPass(store: boolean, resolveContent: boolean, resolveDepth: boolean, generateMipmap: boolean, material?: Material): void;
    endPass(): void;
    flushCommands(): void;
    setRenderTarget(target?: RenderTarget, resolveTarget?: RenderTarget): void;
    setScissorTest(enable: boolean): void;
    setScissor(x: number, y: number, width: number, height: number): void;
    /**
    * @deprecated use readPixelsAsync instead.
    */
    readPixels(target: RenderTarget, range: IRange, result: TypedArray$3): void;
    readPixelsAsync(target: RenderTarget, range: IRange, result: TypedArray$3): Promise;
    forceContextLost(manual?: boolean): void;
    getMemoryInfo(whenGrowFailed?: boolean): Readonly;
    releaseUnusedResources(delta: number): void;
    /**
     * queue a task to upload texture to gpu.
     */
    queueFlushTexture(texture: Texture): void;
}

declare enum TextureDimension$1 {
    D2 = 0,
    D3 = 1
}
declare enum TextureViewDimension$1 {
    D2 = 0,
    D2Array = 1,
    Cube = 2,
    D3 = 3
}
declare enum TextureFormat$1 {
    R8Snorm = "r8snorm",
    R8Unorm = "r8unorm",
    R8Uint = "r8uint",
    R8Sint = "r8sint",
    R16Float = "r16float",
    R16Sint = "r16sint",
    R16Uint = "r16uint",
    R32Float = "r32float",
    R32Sint = "r32sint",
    R32Uint = "r32uint",
    Rg8Snorm = "rg8snorm",
    Rg8Unorm = "rg8unorm",
    Rg8Sint = "rg8sint",
    Rg8Uint = "rg8uint",
    Rg16Float = "rg16float",
    Rg16Sint = "rg16sint",
    Rg16Uint = "rg16uint",
    Rg32Float = "rg32float",
    Rg32Sint = "rg32sint",
    Rg32Uint = "rg32uint",
    Rgba8Snorm = "rgba8snorm",
    Rgba8Unorm = "rgba8unorm",
    Rgba8Sint = "rgba8sint",
    Rgba8Uint = "rgba8uint",
    Rgba8UnormSrgb = "rgba8unorm-srgb",
    Rgb10a2Unorm = "rgb10a2unorm",
    Rgba16Float = "rgba16float",
    Rgba16Sint = "rgba16sint",
    Rgba16Uint = "rgba16uint",
    Rgba32Float = "rgba32float",
    Rgba32Sint = "rgba32sint",
    Rgba32Uint = "rgba32uint",
    Bgra8Unorm = "bgra8unorm",
    Bgra8UnormSrgb = "bgra8unorm-srgb",
    Depth16Unorm = "depth16unorm",
    Depth24Plus = "depth24plus",
    Depth24PlusStencil8 = "depth24plus-stencil8",
    Astc4x4Unorm = "astc-4x4-unorm",
    Astc4x4UnormSrgb = "astc-4x4-unorm-srgb",
    Astc5x4Unorm = "astc-5x4-unorm",
    Astc5x4UnormSrgb = "astc-5x4-unorm-srgb",
    Astc5x5Unorm = "astc-5x5-unorm",
    Astc5x5UnormSrgb = "astc-5x5-unorm-srgb",
    Astc6x5Unorm = "astc-6x5-unorm",
    Astc6x5UnormSrgb = "astc-6x5-unorm-srgb",
    Astc6x6Unorm = "astc-6x6-unorm",
    Astc6x6UnormSrgb = "astc-6x6-unorm-srgb",
    Astc8x5Unorm = "astc-8x5-unorm",
    Astc8x5UnormSrgb = "astc-8x5-unorm-srgb",
    Astc8x6Unorm = "astc-8x6-unorm",
    Astc8x6UnormSrgb = "astc-8x6-unorm-srgb",
    Astc8x8Unorm = "astc-8x8-unorm",
    Astc8x8UnormSrgb = "astc-8x8-unorm-srgb",
    Astc10x5Unorm = "astc-10x5-unorm",
    Astc10x5UnormSrgb = "astc-10x5-unorm-srgb",
    Astc10x6Unorm = "astc-10x6-unorm",
    Astc10x6UnormSrgb = "astc-10x6-unorm-srgb",
    Astc10x8Unorm = "astc-10x8-unorm",
    Astc10x8UnormSrgb = "astc-10x8-unorm-srgb",
    Astc10x10Unorm = "astc-10x10-unorm",
    Astc10x10UnormSrgb = "astc-10x10-unorm-srgb",
    Astc12x10Unorm = "astc-12x10-unorm",
    Astc12x10UnormSrgb = "astc-12x10-unorm-srgb",
    Astc12x12Unorm = "astc-12x12-unorm",
    Astc12x12UnormSrgb = "astc-12x12-unorm-srgb",
    Bc1RgbaUnorm = "bc1-rgba-unorm",
    Bc2RgbaUnorm = "bc2-rgba-unorm",
    Bc3RgbaUnorm = "bc3-rgba-unorm",
    Bc7RgbaUnorm = "bc7-rgba-unorm",
    Bc7RgbaUnormSrgb = "bc7-rgba-unorm-srgb",
    Etc2Rgb8Unorm = "etc2-rgb8unorm",
    Etc2Rgb8UnormSrgb = "etc2-rgb8unorm-srgb",
    Etc2Rgba8Unorm = "etc2-rgba8unorm",
    Etc2Rgba8UnormSrgb = "etc2-rgba8unorm-srgb"
}
declare class WebGLTextureFormat {
    private _internal;
    private _external;
    private _dataType;
    readonly compressed: boolean;
    private _cache;
    constructor(_internal: number, _external: number, _dataType: number, compressed: boolean);
    internal(backend: RendererBackend): number;
    external(backend: RendererBackend): number;
    dataType(backend: RendererBackend): number;
    private specifyInternal;
    private specifyExternal;
    private specifyDataType;
    private backendSpecified;
}

/**
 * Base class for texture like data. Each texture match one WebGLTexture
 */
declare abstract class Texture extends ElementEventDispatcher implements ElementsWithGPUResource {
    /**
     * @internal
     */
    readonly isInternal: boolean;
    /**
     * @internal
     */
    readonly dimension: TextureDimension$1;
    /**
     * @internal
     */
    readonly viewDimension: TextureViewDimension$1;
    /**
     * @internal
     */
    readonly bindableTarget: number;
    name: string;
    readonly samplerDescriptor: SamplerDescriptor;
    readonly storageDescriptor: TextureStorageDescriptor;
    isMipmapDisabled: boolean;
    constructor();
    /**
     * @internal
     */
    constructor(dimension: TextureDimension$1, viewDimension: TextureViewDimension$1, isInternal: boolean);
    destroy(): void;
    syncBase(): void;
    getUUID(): string;
    disableAutoMipmap(): this;
    copyBaseInfo(other: Texture): this;
    configAsDataTexture(): this;
    configSampler(visitor: (s: SamplerDescriptor) => any): this;
    configSamplerRepeat(): this;
    configTrilinear(): this;
    configDoubleLinear(): this;
    configStorage(visitor: (t: TextureStorageDescriptor) => any): this;
    /**
     * @internal
     */
    abstract uploadWebGL(ctx: WebGLTextureUploadCtx): number;
    /**
     * @internal
     * @deprecated use `bindableTarget`
     */
    getTargetBindType(_gl: WebGL2RenderingContext): number;
    freeGPU(): void;
    serialize(ctx: Serializer): void;
    deserialize(ctx: Deserializer): void;
}
declare class WebGLTextureUploadCtx {
    gl: WebGL2RenderingContext;
    backend: RendererBackend;
    isWebGL1: boolean;
    maxTextureSize: number;
    newCreated: boolean;
    constructor(gl: WebGL2RenderingContext, backend: RendererBackend, isWebGL1: boolean, maxTextureSize: number, newCreated: boolean);
}
interface SourceTextureWebGLUploadResult {
    is_pot: boolean;
    has_uploaded_custom_mipmap: boolean;
    byteSize: number;
}
interface SourceTextureLayerWebGLUploadResult {
    is_pot: boolean;
    byteSize: number;
}
/**
 * LegacySourceTexture is the base texture class for texture with cpu data(eg. Texture2D, Texture2DCompressed...)
 */
declare abstract class LegacySourceTexture extends Texture {
    /**
     * @internal
     */
    readonly isLegacySourceTexture = true;
    /**
     * @internal
     */
    abstract uploadWebGLImpl(ctx: WebGLTextureUploadCtx, disableCustomMipmap: boolean, needPot: boolean): SourceTextureWebGLUploadResult;
    /**
     * @internal
     */
    abstract canAutoGenerateMipmap(): boolean;
    protected abstract getAutoGeneratedMipmapByteSize(): number;
    /**
     * @internal
     */
    uploadWebGL(ctx: WebGLTextureUploadCtx): number;
}
interface WebGLUploadable {
    __brand: 'WebGLUploadable';
    /**
     * @internal
     */
    uploadWebGL(ctx: WebGLTextureUploadCtx, target: number, level: number, needPOT: boolean): SourceTextureLayerWebGLUploadResult;
}
/**
 * Container for texture data and their mipmap
 */
declare class TextureMipmapGroup {
    texture?: Texture;
    /**
     * Main layer
     */
    get main(): T;
    set main(v: T);
    mipmaps: T[];
    constructor(main: T[]);
    syncData(texture?: Texture, layer?: number): void;
    static create(main: T): TextureMipmapGroup;
    static fromArray(arr: T[]): TextureMipmapGroup;
    modifyMain(visitor: (T: T) => any): this;
    modifyMipmap(layer: number, visitor: (T: T) => any): this;
    setMipmap(mipmap: T, level: number): this;
    pushMipmap(mipmap: T): this;
    /**
     * @internal
     */
    uploadWebGL(ctx: WebGLTextureUploadCtx, target: number, disableCustomMipmap: boolean, needPOT: boolean): SourceTextureWebGLUploadResult;
}
declare class TextureStorageDescriptor {
    /**
     * If set to true, the texture is flipped along the vertical axis when uploaded to the GPU.
     * @defaultValue `true`
     */
    flipY: boolean;
    /**
     * If set to true, the alpha channel, if present, is multiplied into the color channels when the texture is uploaded to the GPU.
     * @defaultValue `false`
     */
    premultipliedAlpha: boolean;
    /**
     * valid values: 1, 2, 4, 8 (see glPixelStorei for more details)
     */
    /**
     * @deprecated unsupported, always be 4
     */
    unpackAlignment: 1 | 2 | 4 | 8;
    copy(other: TextureStorageDescriptor): void;
    /**
     * @internal
     */
    sync_webgl(gl: WebGLRenderingContext, is3D?: boolean): void;
    serialize(ctx: Serializer): void;
    deserialize(ctx: Deserializer): void;
}
declare enum SamplerBindingType {
    Filtering = 0,
    NonFiltering = 1,
    Comparison = 2
}
declare class SamplerDescriptor {
    static CreateAttachmentSampler(): SamplerDescriptor;
    static CreateDepthAttachmentSampler(): SamplerDescriptor;
    copy(other: SamplerDescriptor): void;
    /**
     * This defines how the texture is wrapped horizontally and corresponds to U in UV mapping.
     * The default is {@link SamplerWrap.ClampToEdgeWrapping | ClampToEdgeWrapping}, where the edge is clamped to the outer edge texel.
     */
    wrapS: SamplerWrap;
    /**
     * This defines how the texture is wrapped vertically and corresponds to V in UV mapping.
     * The same choices are available as for {@link wrapS | wrapT}.
     */
    wrapT: SamplerWrap;
    /**
     * For use with a texture's magFilter property,
     * these define the texture magnification function to be used when the pixel being textured maps to an area less than or equal to one texture element (texel).
     */
    magFilter: SamplerFilter;
    /**
     * For use with a texture's minFilter property,
     * these define the texture minifying function that is used whenever the pixel being textured maps to an area greater than one texture element (texel).
     */
    minFilter: SamplerFilter;
    /**
     * @internal
     */
    samplerBindingType?: SamplerBindingType;
    serialize(ctx: Serializer): void;
    deserialize(ctx: Deserializer): void;
    /**
     * @internal
     */
    sync_webgl(gl: WebGLRenderingContext, target: number, mipmapEnabled: boolean, forceClampToEdge: boolean): void;
    min_filter_fallback(): SamplerFilter;
    needMipmap(): boolean;
}

declare const enum BuiltInUniformTypes {
    resolution = 0,
    cameraPosition = 1,
    normalMatrix = 2,
    viewMatrix = 3,
    modelMatrix = 4,
    modelViewMatrix = 5,
    projectionMatrix = 6,
    lodInfo = 7,
    boneTexture = 8,
    boneTextureSize = 9
}
declare class BuiltInUniforms {
    currentCamera: Camera3D;
    currentDrawable: Drawable;
    resolution: Vector2;
    cameraPosition: Vector3;
    isDrawableStaticChange: boolean;
    constructor();
    reset(): void;
}

declare class RenderState {
    builtUniforms: BuiltInUniforms;
    activeShaderComponentRegistry: ShaderComponentRegistry;
    resourceManager: ResourceManager;
    state: WGLState;
    readonly gl: WebGLRenderingContext | WebGL2RenderingContext;
    isCameraPositionDirty: boolean;
    isCameraProjectionDirty: boolean;
    isCameraViewProjectionDirty: boolean;
    isViewMatrixDirty: boolean;
    isModelMatrixDirty: boolean;
    isNormalMatrixDirty: boolean;
    isModelViewMatrixDirty: boolean;
    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, state: WGLState);
    setTexture(texture: Texture, namedSlot?: number): number;
    setupVBOs(bufferGeometry: BufferGeometryBase, program: WGLProgram, needUpdateAttribute?: string[], updateIndex?: boolean): void;
    setupVertexAttributes(bufferGeometry: BufferGeometryBase, program: WGLProgram): void;
    updateGlobalUniforms(program: WGLProgram): void;
    updateDrawable(drawable: Drawable): void;
    updateCamera(camera: Camera3D): void;
    markAllDirty(): void;
    updateResolution(width: number, height: number): void;
    resetFrame(): void;
}

declare class Renderer extends EventDispatcher implements IRenderer {
    /**
     * @internal
     */
    readonly backend: RendererBackend;
    /**
     * @internal
     */
    readonly rendererStatus: {
        state: RendererState;
        initialized: Promise;
    };
    parameters: RendererParameters;
    domElement: HTMLCanvasElement;
    gl: WebGLRenderingContext | WebGL2RenderingContext;
    readonly renderInfo: RenderInfo;
    wglState: WGLState;
    renderState: RenderState;
    resourceManager: ResourceManager;
    extensions: WGLExtensions;
    currentWGLProgram: Nullable;
    private bufferRenderer;
    private indexedBufferRenderer;
    private _currentScissor;
    private _scissor;
    private _pixelRatio;
    private _currentViewport;
    _viewport: Vector4;
    private _cachedFBO;
    _isContextLost: boolean;
    private ctx_info;
    private _width;
    private _height;
    private _canvas;
    private _scissorTest;
    private _currentGeometryProgram;
    private _destroyed;
    private renderPass;
    private drawFrameBuffer;
    private readFrameBuffer;
    lastUsedMaterial: Nullable;
    constructor(parameters: RendererParameters);
    getRenderTarget(): void;
    getContext(): WebGLRenderingContext | WebGL2RenderingContext;
    beforeFrameRender(): void;
    afterFrameRender(): void;
    getGPUInfo(): string;
    tick(timestamp: number): void;
    updateRenderStatistics(re: RenderStatistics): void;
    getPixelRatio(): number;
    setPixelRatio(value: number): void;
    setSize(width: number, height: number, updateStyle?: boolean): void;
    getSize(): {
        width: number;
        height: number;
    };
    getDrawingBufferSize(): {
        width: number;
        height: number;
    };
    setViewport(x: number, y: number, width: number, height: number): void;
    setViewportInRenderPass(x: number, y: number, width: number, height: number): void;
    setClearColor(color: Color | string | number, alpha?: number): void;
    clear(color?: boolean, depth?: boolean, stencil?: boolean): void;
    getCanvas(): HTMLCanvasElement;
    destroy(forceLost?: boolean): void;
    private manualContextLost;
    forceContextLost(manual?: boolean): void;
    private onContextLost;
    getCurrentCamera(): Camera3D;
    getCurrentDrawable(): Drawable;
    useCamera(camera: Nullable): void;
    useRegistry(registry: ShaderComponentRegistry): void;
    overrideDispatcher: Nullable;
    private useGeometry;
    renderDrawcall(geometry: BufferGeometryBase, material: Material, object: Drawable, range: Nullable): void;
    renderRenderable(renderable: Renderable): void;
    resetRenderState(): void;
    setMaterialUploadDirty(): void;
    private bindTarget;
    /**
     * do all gl bind stuffs
     * bind Target -> set viewport -> set scissor -> clear
     */
    beginPass(store: boolean, resolveContent: boolean, resolveDepth: boolean, generateMipmap: boolean): void;
    endPass(): void;
    flushCommands(): void;
    setRenderTarget(target?: RenderTarget, resolveTarget?: RenderTarget): void;
    setScissorTest(enable: boolean): void;
    setScissor(x: number, y: number, width: number, height: number): void;
    private checkAndBindTargetForReading;
    readPixels(target: RenderTarget, range: IRange, result: TypedArray$3): void;
    readPixelsAsync(target: RenderTarget, range: IRange, result: TypedArray$3): Promise;
    getMemoryInfo(): MemoryInfo;
    releaseUnusedResources(): void;
    queueFlushTexture(texture: Texture): void;
}

declare enum DrawableRenderMode {
    Default = 0,
    Overlay = 1
}
declare enum OutlineRenderMode {
    Default = 0,
    DisableOutline = 1,
    Overlay = 2
}
declare enum OutlineShadingMode {
    Default = 0,
    Normal = 1
}
declare enum OutlineMode {
    Disabled = 0,
    Outlined = 1,
    Solid = 2,
    Exclude = 3
}
declare type RenderHook = (renderer: Renderer, geometry: GeometryBase, material: Material, object: Drawable, group: Nullable) => void;
/**
 * This is a base class of Mesh, Line, Point and Sprite.
 * This class has attributes which make the engine know the changed data and apply optimization.
 * Only drawable node of scene can be seen on screen.
 */
declare class Drawable extends Object3D {
    /**
     * This value allows the default rendering order of scene graph objects to be overridden although opaque and transparent objects remain sorted independently.
     * When this property is set for an instance of {@link Group| Group }, all descendants objects will be sorted and rendered together.
     * Sorting is from lowest to highest renderOrder.
     * @defaultValue `0`
     */
    renderOrder: number;
    /**
     * This is a decisive attribute for drawing method.
     * @defaultValue Mesh.
     */
    drawMode: DrawMode;
    private _outlineMode;
    /**
    * Mark this drawable should be rendered in outline style
    * if you set outlinePipelineMode & outlineShadingMode, get this value maybe error
    */
    get outlineMode(): OutlineMode;
    set outlineMode(v: OutlineMode);
    private _outlineShadingMode;
    get outlineShadingMode(): OutlineShadingMode;
    set outlineShadingMode(value: OutlineShadingMode);
    private _outlineRenderMode;
    get outlineRenderMode(): OutlineRenderMode;
    /**
     * OutlineRenderMode.Overlay is deprecated. use renderMode replaced
     */
    set outlineRenderMode(value: OutlineRenderMode);
    private _renderMode;
    get renderMode(): DrawableRenderMode;
    set renderMode(value: DrawableRenderMode);
    overlayLayers: number;
    /**
    * Mark this drawable can cast shadow
    */
    castShadow: boolean;
    /**
    * Mark this drawable can cast shadow
    */
    castPlanarShadow: boolean;
    /**
     * Used to check type of this or extended instance.
     * This value should not be changed by user.
     */
    isDrawable: boolean;
    /**
     * Mark the material reference changed.
     * @defaultValue `true`
     */
    materialChanged: boolean;
    /**
     * Mark the geometry reference changed.
     * @defaultValue `true`
     */
    geometryChanged: boolean;
    /**
     * Specify the winding orientation of mesh as counter-clock-wise, only meaningful on mesh.
     * @defaultValue `false`.
     */
    frontFaceCW: boolean;
    /**
     * Store the Model-View matrix for this object.
     * It is not suggested to change the matrix because it will be update automatically when camera move.
     */
    modelViewMatrix: Matrix4;
    /**
     * This matrix is used to calculate the normal in eye-space.
     */
    normalMatrix: Matrix3;
    /**
     * Mark bounding need to be recalculated.
     * @defaultValue `true`
     */
    worldBoundingDirty: boolean;
    /**
     * Calculate the bounding as box.
     */
    worldBoundingBox: Box3;
    /**
     * Calculate the bounding as sphere.
     */
    worldBoundingSphere: Sphere;
    /**
     * The distance from object to camera in the direction of camera. Use this value to simply estimate the depth in 3D scene.
     */
    z: number;
    /**
     * This method allow user manually process data before the engine drawing object.
     * @remarks See {@link RenderHook| RenderHook} for more details.
     */
    onBeforeRender: Nullable;
    /**
    * @ignore
    * @deprecated
    */
    hasDynamicShapeMaterial: boolean;
    private _isAlwaysDynamic;
    get isAlwaysDynamic(): boolean;
    set isAlwaysDynamic(v: boolean);
    /**
     * This is used to scale a drawable object by specified number when {@link enableViewIndependentScale| enableViewIndependentScale } is true.
     */
    viewIndependentScale: number;
    private _enableViewIndependentScale;
    /**
     * Let this object can be scale independently.
     */
    get enableViewIndependentScale(): boolean;
    set enableViewIndependentScale(v: boolean);
    categoryId: string;
    sourceType: string;
    protected _geometry: G;
    protected _material: M[];
    protected _renderGeometry: Nullable;
    protected _renderMaterial: Nullable;
    /**
     * @internal
     */
    overrideGroups?: BufferRange[];
    constructor(geometry?: G, material?: M | M[]);
    /**
     * This attribute stores {@link Geometry| Geometry } or {@link BufferGeometry| BufferGeometry } (or derived classes),
     * defining the object's shape.
     * @defaultValue {@link BoxBufferGeometry| BoxBufferGeometry }
     */
    get geometry(): G;
    set geometry(newGeo: G);
    /**
     * Get the geometry which is really rendered by gpu.
     */
    get renderGeometry(): BufferGeometryBase;
    getMaterials(): ReadonlyArray;
    getMaterialCount(): number;
    /**
    * Add a new material into this object.
    * If use this method, please make sure that the {@link material| material } has set to Array.
    * @param {Material} material a new material which is set.
    * @param {number} index the target position in the Array.
    */
    setMaterial(material: M, index: number): this;
    setMaterials(materials: M[] | M): this;
    setOnlyMaterial(material: M): this;
    /**
     * Expect this drawable only has one material, and return it.
     */
    expectOnlyMaterial(): M;
    checkIfOnlyMaterial(innerChecker?: (m: Material) => boolean): boolean;
    /**
     * Do something for every {@link material| material } whatever it is an instance or array.
     * @param {function} f a function to operate the material instance.
     */
    forEachMaterial(v: (m: M) => any): void;
    /**
     * Get the material which is really rendered by gpu.
     */
    get renderMaterial(): Material[];
    /**
     * update the data of bounding box and bounding sphere, set dirty mark to false.
     */
    updateBoundings(): void;
    _updateMatrixByViewIndependentScale(camera: Camera3D, viewHeight: number): void;
    /**
     * This method is used to update {@link modelViewMatrix| model-view matrix } and {@link normalMatrix| normal matrix } before drawing this object.
     * In addition, the estimated {@link z| depth } information will be update here.
     */
    updateRenderInfo(camera: Camera3D, viewHeight: number): void;
    /**
     * Update the matrix local transform. Override
     */
    updateMatrix(): void;
    private viewIndependentOverrideScale;
    _clearViewIndependentOverrideScale(): void;
    /**
     * Set all changing mark, such as {@link geometryChanged| geometryChanged }, {@link materialChanged| materialChanged }
     * and {@link Object3D.clearChangeMark| extended mark }.
     */
    clearChangeMark(): void;
    /**
     * This method need override in derived classes to give a special calculation for picking feature.
     * @remarks See {@link Raycaster| Raycaster } for more detail.
     */
    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
    protected raycastJsImpl(_raycaster: Raycaster, _intersects: Intersection[]): void;
    /**
     * Clean render data for optimization.
     */
    resetRenderEntity(): void;
    /**
     * Update render data for optimization.
     * This method is used to assign data from {@link geometry| geometry } and {@link material| material } to
     * {@link renderGeometry| renderGeometry } and {@link renderMaterial| renderMaterial }.
     */
    updateRenderEntity(): void;
    private _removeSceneReference;
    private createSceneReference;
    private addDrawcall;
    /**
     * Reset entity reference.
     * @remarks See {@link Scene3D._refManager| refManager} for more details.
     */
    refreshSceneReference(): void;
    /**
     * If user changes geometry for drawable, use this method to refresh corresponding states.
     */
    setGeometryChanged(): void;
    /**
     * Manually {@link Object3D.notifySceneChange| refresh} and {@link resetRenderEntity| reset} data of this drawable.
     * @tips This method can be replaced by {@link resetRenderEntity| resetRenderEntity()}.
     */
    onReferencedGeometryContentChange(): void;
    /**
     * If user changes {@link material| material } for drawable, use this method to refresh corresponding states.
     */
    setMaterialChanged(): void;
    protected onSelfAttachingScene(scene: Scene3D): void;
    protected onSelfDetachingScene(scene: Scene3D): void;
    shouldUseGeometryGroupsWhenOnlyHasOneMaterial: boolean;
    useGeometryGroupsWhenOnlyHasOneMaterial(): this;
    /**
     * @ignore
     */
    appendDrawcall(transparent: Drawcall[], opaque: Drawcall[]): void;
    /**
     * Copy the data to this object from source.
     * This method need override in derived classes to copy extended data.
     * @param {Drawable} source the data source.
     * @param {boolean} recursive if true, descendants of the object are also cloned. Default is true.
     */
    copy(source: Drawable, recursive?: boolean): this;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx this parameter has not supported external Serializer yet.
     * It may cause that this method can not be used directly.
     * @ignore
     */
    serialize(ctx: Serializer): void;
    set __material(v: M[]);
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx this parameter has not supported external Deserializer yet.
     * It may cause that this method can not be used directly.
     * @ignore
     */
    deserialize(ctx: Deserializer): void;
    destroyAllResourcesOwned(): void;
    freeAllGpuResourceOwned(): void;
}

declare class Culler {
    enableFrustumCulling: boolean;
    private frustum;
    private projScreenMatrix;
    enableDetailCulling: boolean;
    private pixelsOfDistOne;
    private cameraWorldPosition;
    /**
     * @ignore
     * camera should updated
     */
    update(camera: Camera3D): void;
    /**
     * @ignore
     */
    queryCulling: (item: Drawable) => boolean;
    private queryFrustumCulling;
    private queryDetailCulling;
}

interface CameraView {
    fullWidth: number;
    fullHeight: number;
    offsetX: number;
    offsetY: number;
    width: number;
    height: number;
    enabled: boolean;
}
/**
 * Abstract base class for cameras. This class should always be inherited when you build a new camera,
 * such as perspective and orthographic camera.
 * The abstracted function need to respectively implement for different types of cameras.
 */
declare abstract class Camera3D extends Object3D {
    enableFrustumCulling: boolean;
    enableDetailCulling: boolean;
    /**
     * @internal
     */
    culler: Culler;
    /**
     * @ignore
     */
    queryCulling: (object: Drawable) => boolean;
    /**
     * @ignore
     */
    filterLayers: (object: Drawable) => boolean;
    /**
     * Check the type whether it belongs to Camera3D.
     * This value should not be changed by user.
     */
    isCamera3D: boolean;
    /**
     * The type of this Object3D.
     */
    type: string;
    /**
     * This is the inverse of matrixWorld. MatrixWorld contains the Matrix which has the world transform of the Camera3D.
     */
    matrixWorldInverse: Matrix4;
    worldRotation: Matrix4;
    /**
     * @internal
     */
    viewRotation: Matrix4;
    worldPosition: Vector3;
    /**
     * This matrix decides the method of projection such as perspective and orthographic.
     */
    projectionMatrix: Matrix4;
    /**
     * The inverse matrix of {@link projectionMatrix| projectionMatrix }.
     */
    projectionMatrixInverse: Matrix4;
    /**
     * This is used to adapt the bounds of camera to canvas.
     */
    bounds: Vector4;
    /**
     * The name of instance's class.
     */
    className(): string;
    /**
     * Make the engine to render the scene again.
     */
    notifyCameraChanged(): void;
    /**
     * Copy the data to this camera instance from source.
     * This method need override in derived classes to copy extended data.
     * @param {Camera3D} source the data source.
     * @param {boolean} recursive if true, descendants of the object are also cloned. Default is true.
     */
    copy(source: Camera3D, recursive?: boolean): this;
    /**
     * Set the value of camera's faced direction to given vector.
     * @param {Vector3} target this vector representing the world space direction in which the camera is looking.
     */
    getWorldDirection(target: Vector3): Vector3;
    /**
     * Update the camera's {@link Object3D.matrixWorld| matrixWorld } and {@link matrixWorldInverse| matrixWorldInverse }.
     * @param {boolean} updateParents if true, it also updates all the parents.
     * @param {boolean} updateChildren if true, it also updates all the children.
     * @param {boolean} force Whether or not force to updates the matrix.
     */
    updateWorldMatrix(updateParents: boolean, updateChildren: boolean, force?: boolean): void;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx an instance used to store the data of scene objects.
     */
    serialize(ctx: Serializer): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx an instance give the method to take the data for attribute.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Update the projection matrix base on different type of camera. And a modification also can be applied on the projection.
     */
    abstract updateProjectionMatrix(jitter?: {
        offset: Vector2;
        canvas_size: Vector2;
    }): void;
    private _jitter;
    updateJitter(jitter: ReadonlyVector2): void;
    getJitter(): Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "equals" | "getSerializeData" | "x" | "y" | "getNumberCount" | "toArray" | "width" | "height" | "isVector2" | "dot" | "cross" | "lengthSq" | "length" | "angle" | "manhattanLength" | "distanceTo" | "distanceToSquared" | "manhattanDistanceTo" | "intoSize">>;
    updatePrev(): void;
    /**
     * how many screen pixels rendered in 1 distance from camera
     */
    abstract getPixelsOfDistOne(): number;
    /**
     * Calculate how many screen pixel match one world unit at given distance.
     * @param {number} distance the distance from camera to object.
     * @param {number} viewHeight the hight of view window.
     */
    abstract pixelsPerUnit(distance: number, viewHeight: number): number;
    /**
     * return a function that compute pixelsPerUnit
     */
    pixelsPerUnitCreator(viewHeight: number): (distance: number) => number;
    /**
     * Calculate a scale value that keep one object's screen unit size match it's world unit size
     * @param {number} distance the distance from camera to object.
     * @param {number} viewHeight the hight of view window.
     */
    getViewIndependentScaleRatio(distance: number, viewHeight: number): number;
    /**
     * Set the origin and direction for ray.
     * @param {Ray} ray the calculate result will be set to this.
     * @param {Vector2} coords the position of window where the ray through out.
     */
    abstract castRay(ray: Ray, coords: Vector2): void;
}

declare class MergedMeshPhongMaterial extends MeshPhongMaterial$1 {
    readonly isMergedMeshPhongMaterial = true;
    className(): string;
    generateShaderKey(r: ShaderComponentRegistry): string;
    dataTexture: T;
    textures: T[];
    traverseTexture(visitor: (tex: Texture) => void): void;
    setTextureUnit(texture: T, unit: number): void;
    private updateShadingUniformsSelf;
    updateShadingUniforms(program: WGLProgram, r: ShaderComponentRegistry): void;
    updateDeferredUniform(program: WGLProgram): void;
    private extendShadingSelf;
    extendShaderShading(b: ShaderBuilder, r: ShaderComponentRegistry): void;
    extendEncodeDeferred(b: ShaderBuilder): void;
}

interface MergedMeshData {
    geometry: PopBufferGeometry;
    material: MergedMeshPhongMaterial[];
}

declare class RenderProxyManager {
    private scene;
    staticFrameDirtyId: number;
    isProxyChanged: boolean;
    private freeDynamicAnalyser;
    private allRenderables;
    private allFreeRenderables;
    private instancePool;
    private meshMergePool;
    constructor(scene: Scene3D);
    tick(): void;
    private popMerger;
    private _enablePopMeshMerge;
    get enablePopMeshMerge(): boolean;
    set enablePopMeshMerge(value: boolean);
    mergePopMesh(popMesh: PopMesh): Nullable;
    private _enableMeshMerge;
    get enableMeshMerge(): boolean;
    set enableMeshMerge(value: boolean);
    private _enableInstance;
    get enableInstance(): boolean;
    set enableInstance(value: boolean);
    private _enableAutoInstanceKey;
    get enableAutoInstanceKey(): boolean;
    set enableAutoInstanceKey(value: boolean);
    private _enableGpuDriven;
    private _gpuDriveCompressTextureCompression;
    get enableGpuDriven(): boolean;
    set enableGpuDriven(value: boolean);
    /**
     * @internal
     */
    get gpuDriveCompressTextureCompression(): TextureCompression;
    /**
     * @internal
     */
    set gpuDriveCompressTextureCompression(value: TextureCompression);
    onObjectChange(obj: Drawable): void;
    onObjectAdd(obj: Drawable): void;
    onObjectDelete(obj: Drawable): void;
    maintain(): void;
    proxyFree(): void;
    private isCachedDrawableListDirty;
    cleanDrawableListCache(): void;
    private isLastBatchUseProxy;
    private drawableListAllCache?;
    generateDrawableList(isUseProxy: boolean): DrawableList;
    private overlayDrawableListCache?;
    generateOverlayDrawableList(): DrawableList;
    generateDynamicList(camera: Camera3D): ProjectedDrawcallList;
    generateStaticList(camera: Camera3D): ProjectedDrawcallList;
    destroy(): void;
}

declare class RefObjectMap {
    map: Map>;
    clear(): void;
    has(key: K): boolean;
    add(key: K, value: V): void;
    delete(key: K, value: V): void;
    forEachValueByKey(key: K, visitor: (v: V) => void): void;
}

declare class SceneElementRefManager {
    private lastSyncedDrawableRefMaterial;
    materialUsedByDrawable: RefObjectMap;
    private lastSyncedDrawableRefGeometry;
    private geometryUsedByDrawable;
    destroy(): void;
    private onMaterialChanged;
    private onGeometryShapeChanged;
    private onGeometryContentChanged;
    removeDrawableGeometryRef(d: Drawable): void;
    removeDrawableMaterialRef(d: Drawable): void;
    createDrawableGeometryRef(d: Drawable): void;
    createDrawableMaterialRef(d: Drawable): void;
}

declare class SplatManager {
    private _splats;
    private _sceneVersion;
    private _splatCounts;
    get splats(): Splat[];
    get sceneVersion(): number;
    get splatCounts(): number;
    has(splat: Splat): boolean;
    add(splat: Splat): void;
    remove(splat: Splat): void;
}

/**
 * Scene3D is a root node of 3d scene graph, other kinds of 3D object need to be add as children into it.
 * This class provides operating functions to control nodes in scene tree and record which nodes are changed in current frame.
 * The effect and renderable content also can be managed here.
 */
declare class Scene3D extends Object3D {
    /**
     * Mark this scene with a unique number.
     */
    readonly sceneId: number;
    readonly scene: Scene3D;
    readonly attachedNodes: Map;
    /**
     * Store all {@link Light| lights } source which need to apply on the models of scene.
     */
    lights: Set;
    /**
     * Clipping planes setting for scene. When setting changed, should call notifyClippingChanged to update
     */
    clippingPlanes: Plane[];
    /**
     * If enable the scene level clipping
     */
    enableSceneClipping: boolean;
    notifyClippingChanged(): void;
    /**
     * The type of current {@link Object3D| Object3D }.
     * @deprecated
     */
    type: string;
    /**
     * The {@link CoordinateSystemHelper| coordSysHelper } of this scene, if it needs to be rendered.
     */
    coordSysHelper: Nullable;
    /**
     * The instance of RenderProxyManager that is used to process some optimization.
     */
    renderProxyManager: RenderProxyManager;
    /**
     * Give api to nodes of this scene to mark them with a reference.
     * @ignore
     */
    _refManager: SceneElementRefManager;
    /**
     * The instance of ShaderComponentRegistry.
     * This class has a static map to cache the key of shader components which will be rendered to screen.
     * In addition, update light need use the api of this.
     * @ignore
     */
    shaderComponentRegistry: ShaderComponentRegistry;
    /**
     * @internal
     */
    splatManager: SplatManager;
    /**
     * If any nodes of scene is added, deleted or changed, this would be set to true.
     * @defaultValue `false`
     */
    anyDrawableChanged: boolean;
    shadowMapNeedsUpdate: boolean;
    private newAddedSceneNodes;
    private newDeletedSceneNodes;
    private newChangedSceneNodes;
    private allNodes;
    /**
     * @internal
     */
    anythingChanged: boolean;
    private updateId;
    private _layerLightEnabled;
    /**
     * @internal
     */
    get layerLightEnabled(): boolean;
    /**
     * @internal
     */
    set layerLightEnabled(value: boolean);
    private _onlyDirectLight;
    /**
     * @internal
     */
    get onlyDirectLight(): boolean;
    /**
     * @internal
     */
    set onlyDirectLight(value: boolean);
    private _bvhEnabled;
    /**
     * @internal
     */
    get bvhEnabled(): boolean;
    /**
     * @internal
     */
    set bvhEnabled(v: boolean);
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor();
    /**
     * Clears this scene related data.
     */
    destroy(): void;
    /**
     * Get {@link Scene3D.anythingChanged| anythingChanged } to know if any change of node happen in scene graph.
     * When there is any change happening on the sets which store the all nodes of this scene,
     * the value will be set to true, it does not allow user to arrange.
     */
    get isAnythingChanged(): boolean;
    get isShadowMapNeedsUpdate(): boolean;
    /**
     * When any node is added to scene, this method will record which nodes are added or just changed.
     * @param {Object3D} o added node.
     */
    onNodeAdd(o: Object3D): void;
    /**
     * When any changes occur at the node, this method will be used to record which nodes are changed.
     * @param {Object3D} o changed node.
     */
    onNodeChanged(o: Object3D): void;
    /**
     * When any node is deleted, this method will be used to record which nodes are deleted.
     * @param {Object3D} o deleted node.
     */
    onNodeDelete(o: Object3D): void;
    /**
     * change {@link Object3D.updateDirtyId| updateDirtyId } of all node's parent to current update id
     * in order to avoid loop checking.
     */
    popParentChanges(): void;
    /**
     * Synchronize the changes of scene nodes to {@link renderProxyManager| renderProxyManager } and clear these cache.
     */
    refreshChangeSets(): void;
    /**
     * When {@link isAnythingChanged| isAnythingChanged } is true, all nodes of this scene will be checked if there is any change and increase update id.
     * The update id is used to compare with nodes' dirty mark and decide it needs to update in current frame.
     * @param {Renderer} renderer give renderer the {@link shaderComponentRegistry| shaderComponentRegistry } of this scene.
     * @param {Camera} camera this is used to update corresponding data.
     */
    update(forceRefreshChanges?: boolean): void;
    afterRender(): void;
    /**
     * {@link update| update } the data of current scene and let {@link renderProxyManager| renderProxyManager } do optimize before final drawing;
     * @param {Renderer} renderer give renderer the {@link shaderComponentRegistry| shaderComponentRegistry } of this scene.
     * @param {Camera} camera this is used to update corresponding data.
     * @ignore
     */
    generateDrawableList(isUseProxy?: boolean): DrawableList;
    /**
     * Update data and render the effect of shader components whose corresponding config is active.
     * @param {IRenderer} renderer give renderer the {@link shaderComponentRegistry| shaderComponentRegistry } of this scene.
     * @param {Camera} camera this is used to update corresponding data.
     */
    updateRegistryAndActive(renderer: IRenderer, camera: Camera3D): void;
    /**
     * Ues {@link Object3D.copy| copy() } of Object3D to copy {@link Object3D.matrixAutoUpdate| matrixAutoUpdate },
     * {@link Object3D.overrideMaterial| overrideMaterial } and data from source.
     * @param {Scene3D} source the data source.
     * @param {boolean} recursive if true, all nodes of this scene are also cloned. Default is true.
     */
    copy(source: Scene3D, recursive?: boolean): this;
}

/**
 * This class is a base class of every objects which can be added into scene tree for the 3d rendering.
 * As a basic class, it has implemented event listening and serialization for every objects of scene.
 * Each object has position, rotation and scale attribute to represent the spatial transform in a 3D coordinate.
 */
declare class Object3D extends ElementEventDispatcher implements SerializerableDelegatedAsReference {
    /**
     * Every objects in 3D space must have a default up direction.
     * @defaultValue `Vector3(0, 1, 0)`
     */
    static DefaultUp: Vector3;
    /**
     * Unique number for each object3D instance.
     */
    id: number;
    /**
     * Reserved attribute
     */
    categoryId: string;
    /**
     * Record the object rendered as instance or other type.
     */
    sourceType: string;
    /**
     * The scene which this object belong to.
     */
    scene: Nullable;
    /**
     * The number is the frame id which this object is changed or participates change of scene graph.
     * If this value equals to frame id - 1,
     * @defaultValue `-1` means no change happen
     */
    updateDirtyId: number;
    /**
     * The name of this object, it is empty if useless.
     */
    name: string;
    /**
     * Used to check type of this or extended instance.
     * This value should not be changed by user.
     */
    isObject3D: boolean;
    /**
     * The name of instance's class.
     */
    className(): string;
    /**
     * Object's parent node in the scene graph. An object can have at most one parent.
     */
    parent: Nullable;
    /**
     * Array with object's children.
     * @remarks See {@link Group| Group } for information on manually grouping objects.
     */
    children: Object3D[];
    /**
     * This is used by the lookAt method, for example, to determine the orientation of the result.
     * Default is {@link Object3D.DefaultUp| DefaultUp }.
     */
    up: Vector3;
    /**
     * Record when this object's world matrix last updated.
     */
    worldMatrixUpdateTimestamp: number;
    /**
     * Record whether the object's any {@link attribute| attribute } is updated.
     */
    transformChanged: boolean;
    visibleChanged: boolean;
    /**
     * The global transform of the object. If the Object3D has no parent, then it's identical to the local transform matrix.
     */
    matrixWorld: Matrix4;
    /**
     * When this is set, it calculates the matrixWorld in that frame and resets this property to false.
     * @defaultValue `false`
     */
    matrixWorldNeedsUpdate: boolean;
    private _netLayer;
    /**
     * @internal
     */
    get netLayer(): Layers;
    private _netInteractionLayer;
    /**
     * @internal
     */
    get netInteractionLayer(): Layers;
    /**
     * The layer membership of the object. The object is only visible if it has at least one layer in common with the Camera in use.
     */
    private _layer;
    get layers(): Layers;
    set layers(v: Layers);
    private onLayerChange;
    private _interactionLayers?;
    get interactionLayers(): Layers | undefined;
    set interactionLayers(v: Layers | undefined);
    private onInteractionLayerChange;
    private _netGroupLayer?;
    /**
     * @internal
     */
    get netGroupLayer(): Layers | undefined;
    /**
     * @internal
     */
    set netGroupLayer(v: Layers | undefined);
    private _groupLayer?;
    get groupLayer(): Layers | undefined;
    set groupLayer(v: Layers | undefined);
    private groupLayersListener;
    private updateGroupLayer;
    /**
     * Record if the object is really visible in rendering process. If the Object3D has no parent, it would be set by {@link visible| visible };
     */
    netVisibility: boolean;
    /**
     * When this is set, it calculates the model matrix in that frame and resets this property to false.
     * @defaultValue `false`
     */
    localMatrixNeedUpdate: boolean;
    private worldMatrixUpdateId;
    private _visible;
    private _position;
    private _rotation;
    private _scale;
    private _quaternion;
    protected _matrix: Matrix4;
    constructor();
    destroy(): void;
    freeGPU(): void;
    syncData(): void;
    /**
     * A {@link Vector3| vector } representing the object's local position.
     */
    set position(_position: Vector3);
    get position(): Vector3;
    /**
     * Object's local rotation, in radians.
     */
    set rotation(rotation: Euler);
    get rotation(): Euler;
    /**
     * Object's local rotation as a Quaternion.
     * @remarks See {@link Quaternion| Quaternion} for more details.
     */
    set quaternion(_quaternion: Quaternion);
    get quaternion(): Quaternion;
    /**
     * The object's local scale.
     * @defaultValue `Vector3( 1, 1, 1 )`
     */
    set scale(_scale: Vector3);
    get scale(): Vector3;
    /**
     * The local transform {@link Matrix4| matrix}.
     */
    get matrix(): Matrix4;
    set matrix(value: Matrix4);
    /**
     * Object gets rendered if true.
     * @defaultValue `true`
     */
    get visible(): boolean;
    set visible(value: boolean);
    /**
     * Scene will check the object's visibility in each render and make change {@link netVisibility| netVisibility }
     * based on its and parent's {@link visible| visible }.
     */
    updateVisibility(): boolean;
    /**
     * Set marks of change to false include {@link attributeChanged| attribute }, {@link transformChanged| transform } and {@link visibleChanged| visible }.
     */
    clearChangeMark(): void;
    /**
     * If the local matrix is changed, use this method to manually refresh data in scene graph.
     * @tips It's better to use {@link notifySceneChange| notifySceneChange() } as an alternative.
     */
    setMatrixUpdated(): void;
    /**
     * Use this method to manually refresh data in scene graph and draw again.
     * The engine may not notify every change of the scene.
     * If any effect is not changed with the parameters, use this may solve.
     */
    notifySceneChange(): void;
    /**
     * If the local matrix or world matrix is changed, use this method to make engine refresh data in scene graph automatically.
     * This method will set {@link matrixWorldNeedsUpdate| matrixWorldNeedsUpdate } and {@link localMatrixNeedUpdate| localMatrixNeedUpdate } to true.
     */
    setMatrixDirty(): void;
    /**
     * Change {@link matrixWorldNeedsUpdate| matrixWorldNeedsUpdate } and {@link worldMatrixUpdateTimestamp| worldMatrixUpdateTimestamp } state.
     * This method will refresh data of world matrix by {@link updateMatrixWorld| updateMatrixWorld }
     * @param {number} updateID This number is used to identify the render.
     */
    updateWorldRenderData(updateID: number): boolean;
    /**
     * If there are zero or two negative numbers in xyz, return false, otherwise return true.
     */
    isFlipped(): boolean;
    /**
     * Converts the vector from local space to world space.
     * @param {Vector3} vector A vector represents a position in local (object) coordinate.
     */
    localToWorld(vector: Vector3): Vector3;
    /**
     * Updates the vector from world space to local space.
     * @param {Vector3} vector A vector in world coordinate.
     */
    worldToLocal(vector: Vector3): Vector3;
    /**
     * Applies the matrix transform to the object and updates the object's position, rotation and scale.
     * @param {Matrix4} matrix A matrix represents the information of transform.
     */
    applyMatrix(matrix: Matrix4): void;
    /**
     * Applies the rotation represented by the quaternion to the object.
     * @param {Quaternion} q A Quaternion represents the information of rotation.
     */
    applyQuaternion(q: Quaternion): this;
    /**
     * Calls {@link Quaternion.setFromAxisAngle| setFromAxisAngle }( axis, angle ) on the Quaternion.
     * @param {Vector3} axis A normalized vector in object space.
     * @param {number} angle Angle in radians.
     */
    setRotationFromAxisAngle(axis: Vector3, angle: number): void;
    /**
     * Calls {@link Quaternion.setRotationFromEuler| setRotationFromEuler }(euler, true) on the Quaternion.
     * @param {Euler} euler Euler angle specifying rotation amount.
     */
    setRotationFromEuler(euler: Euler): void;
    /**
     * Calls {@link Quaternion.setFromRotationMatrix| setFromRotationMatrix }(m) on the Quaternion.
     * @param {Matrix4} m Euler angle specifying rotation amount.
     */
    setRotationFromMatrix(m: Matrix4): void;
    /**
     * Copy the given quaternion to object's {@link Object3D.quaternion | quaternion }.
     * @param {Quaternion} q Euler angle specifying rotation amount.
     */
    setRotationFromQuaternion(q: Quaternion): void;
    /**
     * Rotate an object along an axis in object space. The axis is assumed to be normalized.
     * @param {Vector3} axis A normalized vector in object space.
     * @param {number} angle Angle in radians.
     */
    rotateOnAxis(axis: Vector3, angle: number): this;
    /**
     * Rotate an object along an axis in world space. The axis is assumed to be normalized. Method Assumes no rotated parent.
     * @param {Vector3} axis A normalized vector in object space.
     * @param {number} angle Angle in radians.
     */
    rotateOnWorldAxis(axis: Vector3, angle: number): this;
    /**
     * Rotates the object around x axis in local space.
     * @param {number} angle The angle to rotate in radians.
     */
    rotateX(angle: number): this;
    /**
     * Rotates the object around x axis in local space.
     * @param {number} angle The angle to rotate in radians.
     */
    rotateY(angle: number): this;
    /**
     * Rotates the object around x axis in local space.
     * @param {number} angle The angle to rotate in radians.
     */
    rotateZ(angle: number): this;
    /**
     * Translate an object by distance along an axis in object space. The axis is assumed to be normalized.
     * @param {Vector3} axis A normalized vector in object space.
     * @param {number} distance The distance to translate.
     */
    translateOnAxis(axis: Vector3, distance: number): this;
    /**
     * Translates object along x axis in object space by distance units.
     * @param {number} distance The distance to translate.
     */
    translateX(distance: number): this;
    /**
     * Translates object along y axis in object space by distance units.
     * @param {number} distance The distance to translate.
     */
    translateY(distance: number): this;
    /**
     * Translates object along z axis in object space by distance units.
     * @param {number} distance The distance to translate.
     */
    translateZ(distance: number): this;
    /**
     * Rotates the object to face to a point in world space.
     * This method does not support objects having non-uniformly-scaled parent(s)
     * @param {Vector3} _x A vector representing position of target in world space.
     */
    lookAt(_x: Vector3): void;
    /**
     * Rotates the object to face a point in local space.
     * @param {Vector3} _x A vector representing position of target in local space.
     */
    lookAtLocalPoint(_x: Vector3): void;
    /**
     * Adds object as child of this object.
     * An arbitrary number of objects may be added. Any current parent on an object passed in here will be removed, since an object can have at most one parent.
     * The scene graph change will be immediately notify by engine after adding nodes.
     * @param {Object3D | Object3D[]} o Parameter can be one object or objects array, all of them is added to this object.
     */
    add(o: Object3D | Object3D[]): this;
    /**
     * Remove the specified object form children.
     * @param {Object3D} object The object which needs to be removed.
     */
    remove(object: Object3D): this;
    removeFromParent(): void;
    /**
     * Remove all children of this object.
     */
    removeAllChildren(): Object3D[];
    /**
     * Remove all children in specified objects from this objects.
     * Migrate from tools common
     * @param {Object3D[]} objects An array of objects which need to be removed.
     */
    removeObjects(objects: Object3D[]): this;
    /**
     * Searches through an object and its children, starting with the object itself, and returns the first with a matching id.
     * Note that ids are assigned in chronological order: 1, 2, 3, ..., incrementing by one for each new object.
     * @param {number} id Unique number of the object instance.
     */
    getObjectById(id: number): Object3D;
    /**
     * Searches through an object and its children, starting with the object itself, and returns the first with a matching name.
     * Note that for most objects the name is an empty string by default. You will have to set it manually to make use of this method.
     * @param {string} name String to match to the children's Object3D.name property.
     */
    getObjectByName(name: string): Object3D;
    /**
     * Searches through an object and its children, starting with the object itself, and returns the first with a property that matches the value given.
     * @param {string} name The property name to search for.
     * @param {any} value Value of the given property.
     */
    getObjectByProperty(name: string, value: any): Object3D;
    /**
     * Return a vector representing the position of the object in world space.
     * @param {string} target the result will be copied into this Vector3.
     */
    getWorldPosition(target: Vector3): Vector3;
    /**
     * Return a quaternion representing the rotation of the object in world space.
     * @param {string} target the result will be copied into this Quaternion.
     */
    getWorldQuaternion(target: Quaternion): Quaternion;
    /**
     * Return a vector of the scaling factors applied to the object for each axis in world space.
     * @param {string} target the result will be copied into this Vector3.
     */
    getWorldScale(target: Vector3): Vector3;
    /**
     * Return a vector representing the direction of object's positive z-axis in world space.
     * @param {string} target the result will be copied into this Vector3.
     */
    getWorldDirection(target: Vector3): Vector3;
    /**
     * Execute the callback on this object and all descendants.
     * @param {function} callback A function with as first argument an object3D object.
     */
    traverse(callback: (object: Object3D) => any | false): void;
    /**
     * Execute the callback when return is false, stop traverse the object's descendants.
     * @param {function} callback A function with as first argument an object3D object, return boolean.
     */
    traverseWithChildrenSkip(callback: (object: Object3D) => boolean): void;
    /**
     * Execute the callback on this object and all descendants which is visible.
     * @param {function} callback A function with as first argument an object3D object.
     */
    traverseVisible(callback: (object: Object3D) => any): void;
    /**
     * Execute the callback on this object and all ancestors.
     * @param {function} callback A function with as first argument an object3D object.
     */
    traverseAncestors(callback: (object: Object3D) => any): void;
    /**
     * Update the matrix local transform.
     */
    updateMatrix(): void;
    /**
     * Update the object's and its descendants' matrix of global transform with.
     * If the parameter or {@link Object3D.matrixWorldNeedsUpdate| matrixWorldNeedsUpdate } is true, matrix will not skip updates.
     * @param {boolean} force Whether or not force to updates the matrix.
     */
    updateMatrixWorld(force?: boolean): void;
    /**
     * Update the object's and its descendants' matrix of global transform with. will update parent or children according to the parameters
     * @param updateParents update parents.
     * @param updateChildren update children.
     * @param force Whether or not force to updates the matrix.
     */
    updateWorldMatrix(updateParents: boolean, updateChildren: boolean, force?: boolean): void;
    /**
     * Get the whole bounding box of current object cover all children's.
     * @param {Box3} localBox If this is not undefined, result will be stored to it.
     */
    getLocalBounds(localBox?: Box3): Box3;
    /**
     * Get UUID of this object instance.
     * This value is automatically assigned, so this shouldn't be edited.
     */
    getUUID(): string;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx this parameter has not supported external Serializer yet.
     * It may cause that this method can not be used directly.
     */
    serialize(ctx: Serializer): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx this parameter has not supported external Deserializer yet.
     * It may cause that this method can not be used directly.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Return a cloned instance of this class and optionally all descendants.
     * @param {boolean} recursive if true, descendants of the object are also cloned. Default is true.
     */
    clone(recursive?: boolean): Object3D;
    /**
     * Copy the data to this object from source.
     * This method need override in derived classes to copy extended data.
     * @param {Object3D} source the data source.
     * @param {boolean} recursive if true, descendants of the object are also cloned. Default is true.
     */
    copy(source: Object3D, recursive?: boolean): this;
    protected onSelfAttachingScene(scene: Scene3D): void;
    protected onSelfDetachingScene(scene: Scene3D): void;
}
declare abstract class CombinedObjectGroup extends Object3D {
    abstract destroyCombined(): void;
}

interface SerializerableDelegated {
    serialize(serialize: Serializer): void;
    deserialize(ctx: Deserializer): void | Promise;
}
interface SerializerableDelegatedAsReference extends SerializerableDelegated, ClassNamePreserved {
    getUUID(): string;
}
interface ClassNamePreserved {
    className(): string;
}
interface MutableSerializerableRaw {
    getSerializeData(): any;
    setSerializeData(value: any): void;
}
interface ReadonlySerializerableRaw extends ReadOnlyMarkedCreatable, ReadonlyMarked {
    getSerializeData(): any;
    clone(): MutableSerializerableRaw;
}
declare type SerializerableRaw = MutableSerializerableRaw | ReadonlySerializerableRaw;
declare type primitive = boolean | number | undefined | null | string;
declare type Serializerable = SerializerableRaw | SerializerableDelegated | primitive;
declare type ArrayOrSingle = T | T[];
declare type SerializerablePartKeys = PickSubTypeProperty>;
declare type SerializeResult = {
    typeName?: string;
    data: any;
} | any;
interface CollectedBufferDescriptor {
    type: string;
    offset: number;
    length: number;
    index: number;
}
declare class Serializer {
    serializedResource: {
        [index: string]: any;
    };
    buffer: ArrayBuffer[];
    byteLengthAll: number;
    private serializeSource;
    private serializeTarget;
    private serializeTargetUuid;
    collectBuffer(data: TypedArray$3): CollectedBufferDescriptor;
    deepClone(value: any): any;
    putRaw(key: string, value: any): void;
    put(key: string, readKey?: string): this | undefined;
    puts(keys: Array>): void;
    serialize(s: any): SerializeResult;
}
declare class SerializerMetaData {
    ctors: Map any>;
    registerCtor(key: string, builder: () => T): void;
}
declare class Deserializer {
    meta: SerializerMetaData;
    promisePool: Array>;
    private rawData;
    private deSerializedResource;
    private serializedData;
    private deSerializeTarget;
    private buffers;
    private getSliced;
    constructor(json: any, buffers: ArrayBuffer[], meta: SerializerMetaData, isWholeBuffer?: boolean);
    getBuffer(tag: CollectedBufferDescriptor): TypedArray$3;
    readRaw(key: string): any;
    getData(): any;
    read(key: string, writeKey?: string): void | Promise;
    reads(keys: Array>): void | Promise;
    readCustom(key: string): any;
    readRawFromSource(id: string): any;
    deserialize>(seredData: any, container?: T): T | Promise;
    deserializeObjectsById(rootId: string[]): Object3D[];
    loadResourceAsync(onload: () => void): Promise;
    private getAttributeFromWholeBuffer;
    private getAttributeFromSplitBuffer;
}

/**
 * This class stores data for an attribute (such as vertex positions, face indices, normals,
 * colors, UVs, and any custom attributes ) associated with a {@link BufferGeometry | BufferGeometry },
 * which allows for more efficient passing of data to the GPU. See that page for details and a usage example.


 * Data is stored as vectors of any length (defined by {@link itemSize | itemSize }),
 * and in general in the methods outlined below if passing in an index, this is automatically multiplied by the vector length.
 */
declare class BufferAttribute extends ElementEventDispatcher {
    /**
     * @internal
     */
    dataVersion: number;
    private lastSyncedVersion;
    /**
     * The geometry attribute data store as TypedArray.
     */
    _array: T;
    /**
     * The geometry attribute data store as TypedArray.
     */
    get array(): T;
    set array(v: T);
    notifyContentChange(): void;
    /**
     * If the buffer is storing a 3-component vector (such as a position, normal, or color),
     * then this will count the number of such vectors stored.
     */
    itemSize: number;
    /**
     * If attribute data is normalized.
     */
    normalized: boolean;
    /**
     * Stores the {@link array | array's } length divided by the {@link itemSize | itemSize }.


     * If the buffer is storing a 3-component vector (such as a position, normal, or color),
     * then this will count the number of such vectors stored.
     */
    count: number;
    /**
     * The data of this buffer always need update.
     * @deprecated will not take effect, update `attribute.array` if need to reupload
     */
    dynamic: boolean;
    /**
     * Object containing:

     * offset:Integer - Default is *0*. Position at which to start update.

     * count:Integer - Default is *-1*, which means don't use update ranges. 


     * This can be used to only update some components of stored vectors (for example, just the component related to color).
     * @deprecated will not take effect, update `attribute.array` instead
     */
    updateRange: {
        offset: number;
        count: number;
    };
    /**
     * Used to check type of this or extended instance.
     * This value should not be changed by user.
     */
    isBufferAttribute: boolean;
    /**
     * When the data is cleared from memory, this mark will be set true.
     * @deprecated never updated, always `false`.
     */
    isDataDropped: boolean;
    /**
     * Remove the data after it is uploaded to GPU memory.
     * @deprecated will not take effect
     */
    removeDataAfterUpload: boolean;
    /**
     * A version number, incremented every time the {@link needsUpdate | needsUpdate } property is set to true.
     */
    version: number;
    constructor(array: T, itemSize: number);
    /**
     * @ignore
     */
    getLayoutKey(): string;
    /**
     * A callback function for updating. It will be called after {@link needsUpdate | needsUpdate }.
     */
    onUpdateCallback: () => void;
    /**
     * A callback function for uploading. It will be called after the data uploaded to WebGL.
     */
    onUploadCallback: () => void;
    /**
     * When this attribute is set to true, the {@link version | version } will be change.
     */
    set needsUpdate(value: boolean);
    /**
     * Change the data of {@link array | array }.
     */
    setArray(array: T): this;
    /**
     * Change the state of {@link dynamic | dynamic }.
     */
    setDynamic(value: boolean): this;
    /**
     * Copy the data to this object from source.
     * @param { BufferAttribute } source the data source.
     */
    copy(source: BufferAttribute): this;
    /**
     * Copy the data at specified position. The given index is items' index, do not need to multiply with item' size.
     * @param { number } index1 the start position of this array.
     * @param { BufferAttribute } attribute the start position of this array.
     * @param { number } index2 the start position of source array.
     */
    copyAt(index1: number, attribute: BufferAttribute, index2: number): this;
    /**
     * Copy the data from given array to this {@link array | array }.
     * @param { TypedArray } array the start position of this array.
     */
    copyArray(array: TypedArray$3 | number[]): this;
    /**
     * Copy the data from given array to this {@link array | array }.
     * @param { Color[] } colors the start position of this array.
     */
    copyColorArray(colors: Color[]): this;
    /**
     * Copy the data which is type of Vector2 from given array to this {@link array | array }.
     * @param { Vector2[] } vectors the start position of this array.
     */
    copyVector2Array(vectors: Vector2[]): this;
    /**
     * Copy the data which is type of Vector3 from given array to this {@link array | array }.
     * @param { Vector3[] } vectors the start position of this array.
     */
    copyVector3Array(vectors: Vector3[]): this;
    /**
     * Copy the data which is type of Vector4 from given array to this {@link array | array }.
     * @param { Vector4[] } vectors the start position of this array.
     */
    copyVector4Array(vectors: Vector4[]): this;
    /**
     * Copy the data from given Array or typedArray.
     * @param { ArrayLike } value an Array or TypedArray from which to copy values.
     * @param { number } offset (optional) index of the {@link array | array } at which to start copying.
     */
    set(value: ArrayLike, offset?: number): this;
    /**
     * Return the x component of all items.
     */
    getX(index: number): number;
    /**
     * Set the x component of the vector at the given index.
     */
    setX(index: number, x: number): this;
    /**
     * Return the y component of all vectors.
     */
    getY(index: number): number;
    /**
     * Set the y component of the vector at the given index.
     */
    setY(index: number, y: number): this;
    /**
     * Return the z component of all vectors.
     */
    getZ(index: number): number;
    /**
     * Set the z component of the vector at the given index.
     */
    setZ(index: number, z: number): this;
    /**
     * Return the w component of all vectors.
     */
    getW(index: number): number;
    /**
     * Set the w component of the vector at the given index.
     */
    setW(index: number, w: number): this;
    /**
     * Set the x and y component of the vector at the given index.
     */
    setXY(index: number, x: number, y: number): this;
    /**
     * Set the x , y and z component of the vector at the given index.
     */
    setXYZ(index: number, x: number, y: number, z: number): this;
    /**
     * Set all component of the vector at the given index.
     */
    setXYZW(index: number, x: number, y: number, z: number, w: number): this;
    /**
     * Return the vector2 at specific position.
     */
    getVector2(index: number, out?: Vector2): Vector2;
    /**
     * @ignore
     */
    onUpload(callback: () => void): this;
    /**
     * Return a clone of this object.
     */
    clone(): BufferAttribute;
    /**
     * @ignore
     */
    serialize(ctx: Serializer): void;
    /**
     * @ignore
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Release the memory which is occupied by this instance from CPU and GPU.
     */
    destroy(): void;
    freeGPU(): void;
}

declare class Matrix4 {
    /**
     * @internal
     */
    _elements: Float32Array;
    /**
     * Check the type whether it belongs to Matrix4.
     * This value should not be changed by user.
     */
    isMatrix4: boolean;
    private static defaultElements;
    /**
     * A {@link https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order| column-major } list of matrix values.
     */
    get elements(): Float32Array;
    /**
     * @deprecated use `fromArray` instead;
     */
    set elements(v: Float32Array);
    constructor();
    /**
     * @ignore
     */
    getSerializeData(): number[];
    /**
     * @ignore
     */
    setSerializeData(value: any): void;
    /**
     * Set the {@link elements| elements} of this matrix to the supplied row-major values n11, n12, ... n44.
     */
    set(n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number): Matrix4;
    /**
     * Resets this matrix to the {@link https://en.wikipedia.org/wiki/Identity_matrix | identity matrix}.
     */
    identity(): Matrix4;
    /**
     * Creates a new Matrix4 with identical {@link elements | elements } to this one.
     */
    clone(): Matrix4;
    cloneReadonly(): Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "equals" | "getSerializeData" | "getNumberCount" | "toArray" | "elements" | "applyToBufferAttribute" | "determinant" | "applyToArray" | "decompose" | "extractBasis" | "getPosition" | "getMaxScaleOnAxis" | "decompose2D">>;
    /**
     * Copies the {@link elements| elements} of matrix {@link Matrix4| m} into this matrix.
     */
    copy(m: Matrix4): Matrix4;
    /**
     * Copies the translation component of the supplied matrix {@link Matrix4| m} into this matrix's translation component.
     */
    copyPosition(m: Matrix4): Matrix4;
    /**
     * Extracts the {@link https://en.wikipedia.org/wiki/Basis_(linear_algebra)| basis} of this matrix into the three axis vectors provided. If this matrix is:
     *      * a, b, c, d,
     * e, f, g, h,
     * i, j, k, l,
     * m, n, o, p
     * 
     * then the {@link Vector3| xAxis}, {@link Vector3| yAxis}, {@link Vector3| zAxis} will be set to:
     *      * xAxis = (a, e, i)
     * yAxis = (b, f, j)
     * zAxis = (c, g, k)
     * 
     */
    extractBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): Matrix4;
    /**
     * Set this to the basis matrix consisting of the three provided basis vectors:
     *      * xAxis.x, yAxis.x, zAxis.x, 0,
     * xAxis.y, yAxis.y, zAxis.y, 0,
     * xAxis.z, yAxis.z, zAxis.z, 0,
     * 0,       0,       0,       1
     * 
     */
    makeBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): Matrix4;
    /**
     * Extracts the rotation component of the supplied matrix {@link Matrix4| m} into this matrix's rotation component.
     */
    extractRotation(m: Matrix4): Matrix4;
    /**
     * Sets the rotation component (the upper left 3x3 matrix) of this matrix to the rotation specified by the given {@link Euler| euler}.
     * The rest of the matrix is set to the identity. Depending on the {@link Euler.order| order} of the {@link Euler| euler}, there are six possible outcomes.
     * @remarks See {@link https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix| this page} for a complete list.
     */
    makeRotationFromEuler(euler: Euler): Matrix4;
    /**
     * Sets the rotation component of this matrix to the rotation specified by {@link Quaternion| q},
     * as outlined {@link https://en.wikipedia.org/wiki/Rotation_matrix#Quaternion| here}.
     * The rest of the matrix is set to the identity. So, given {@link Quaternion| q} = w + xi + yj + zk, the resulting matrix will be:
     *      * 1-2y²-2z²    2xy-2zw    2xz+2yw    0
     * 2xy+2zw      1-2x²-2z²  2yz-2xw    0
     * 2xz-2yw      2yz+2xw    1-2x²-2y²  0
     * 0            0          0          1
     * 
     */
    makeRotationFromQuaternion(q: Quaternion): Matrix4;
    /**
     * Constructs a rotation matrix, looking from {@link Vector3| eye} towards {@link Vector3| center} oriented by the {@link Vector3| up} vector.
     */
    lookAt(eye: Vector3, target: Vector3, up: Vector3): Matrix4;
    /**
     * Post-multiplies this matrix by {@link Matrix4| m}.
     */
    multiply(m: Matrix4): Matrix4;
    /**
     * Pre-multiplies this matrix by {@link Matrix4| m}.
     */
    premultiply(m: Matrix4): Matrix4;
    /**
     * Sets this matrix to {@link Matrix4| a} x {@link Matrix4| b}.
     */
    multiplyMatrices(a: Matrix4, b: Matrix4): Matrix4;
    /**
     * Multiplies every component of the matrix by a scalar value s.
     */
    multiplyScalar(s: number): Matrix4;
    /**
     * Apply this matrix to given {@link BufferAttribute| attribute buffer}.
     */
    applyToBufferAttribute(attribute: BufferAttribute, __forceJSImpl?: boolean): BufferAttribute;
    /**
     * Apply this matrix on given array.
     * Each vector item of array should hold three elements.
     */
    applyToArray(array: Float32Array): Float32Array;
    /**
     * Computes and returns the {@link https://en.wikipedia.org/wiki/Determinant| determinant } of this matrix.
     * Based on the method outlined {@link http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm| here }.
     */
    determinant(): number;
    /**
     * {@link https://en.wikipedia.org/wiki/Transpose| Transposes } this matrix.
     */
    transpose(): Matrix4;
    /**
     * Sets the position component for this matrix from vector {@link Vector3| v}, without affecting the rest of the matrix - i.e. if the matrix is currently:
     *      * a, b, c, d,
     * e, f, g, h,
     * i, j, k, l,
     * m, n, o, p
     * 
     * This becomes:
     *      * a, b, c, v.x,
     * e, f, g, v.y,
     * i, j, k, v.z,
     * m, n, o, p
     * 
     */
    setPosition(v: Vector3): Matrix4;
    /**
     * Return the first three elements of last column.
     */
    getPosition(v: Vector3): Vector3;
    /**
     * Change this matrix to inverse.
     */
    getInverse(m: Matrix4, throwOnDegenerate?: boolean): Matrix4;
    /**
     * Multiplies the columns of this matrix by vector {@link Vector3| v}.
     */
    scale(v: Vector3): Matrix4;
    /**
     * Return the scales of three dimension.
     */
    getScale(v: Vector3): Vector3;
    /**
     * Apply a translation to this matrix.
     * @param tx translate first row by tx.
     * @param ty translate second row by ty.
     * @param ty translate third row by ty.
     */
    translate(tx: number, ty: number, tz: number): Matrix4;
    /**
     * Gets the maximum scale value of the 3 axes.
     */
    getMaxScaleOnAxis(): number;
    /**
     * Sets this matrix as a translation transform:
     *      * 1, 0, 0, x,
     * 0, 1, 0, y,
     * 0, 0, 1, z,
     * 0, 0, 0, 1
     * 
     * @param x the amount to translate in the X axis.
     * @param y the amount to translate in the Y axis.
     * @param z the amount to translate in the Z axis.
     */
    makeTranslation(x: number, y: number, z: number): Matrix4;
    /**
     * Sets this matrix as a rotational transformation around the X axis by {@link Float| theta} (θ) radians.
     * The resulting matrix will be:
     *      * 1      0             0        0
     * 0 cos(θ) -sin(θ)  0
     * 0 sin(θ) cos(θ)   0
     * 0      0             0        1
     * 
     * @param theta Rotation angle in radians.
     */
    makeRotationX(theta: number): Matrix4;
    /**
     * Sets this matrix as a rotational transformation around the Y axis by {@link Float| theta} (θ) radians.
     * The resulting matrix will be:
     *      * cos(θ)  0 sin(θ) 0
     *      0        1      0       0
     * -sin(θ) 0 cos(θ) 0
     *      0        0      0       1
     * 
     * @param theta Rotation angle in radians.
     */
    makeRotationY(theta: number): Matrix4;
    /**
     * Sets this matrix as a rotational transformation around the Z axis by {@link Float| theta} (θ) radians.
     * The resulting matrix will be:
     *      * cos(θ) -sin(θ) 0 0
     * sin(θ) cos(θ)  0 0
     *       0            0       1 0
     *       0            0       0 1
     * 
     * @param theta Rotation angle in radians.
     */
    makeRotationZ(theta: number): Matrix4;
    /**
     * Sets this matrix as rotation transform around {@link Vector3| axis} by {@link Float| theta} radians.

     * This is a somewhat controversial but mathematically sound alternative to rotating via {@link Quaternions| Quaternions}.
     * @remarks See the discussion {@link https://www.gamedev.net/articles/programming/math-and-physics/do-we-really-need-quaternions-r1199| here}.
     * @param axis Rotation axis, should be normalized.
     * @param theta Rotation angle in radians.
     */
    makeRotationAxis(axis: Vector3, angle: number): Matrix4;
    /**
     * @param x the amount to scale in the X axis.
     * @param y the amount to scale in the Y axis.
     * @param z the amount to scale in the Z axis.
     * Sets this matrix as scale transform:
     *      * x, 0, 0, 0,
     * 0, y, 0, 0,
     * 0, 0, z, 0,
     * 0, 0, 0, 1
     * 
     */
    makeScale(x: number, y: number, z: number): Matrix4;
    /**
     * @param x the amount to shear in the X axis.
     * @param y the amount to shear in the Y axis.
     * @param z the amount to shear in the Z axis.
     * Sets this matrix as a shear transform:
     *      * 1, y, z, 0,
     * x, 1, z, 0,
     * x, y, 1, 0,
     * 0, 0, 0, 1
     * 
     */
    makeShear(x: number, y: number, z: number): Matrix4;
    /**
     * Sets this matrix to the transformation composed of {@link Vector3| position}, {@link Quaternion| quaternion} and {@link Vector3| scale}.
     */
    compose(position: Vector3, quaternion: Quaternion, scale: Vector3): Matrix4;
    /**
     * Decomposes this matrix into it's {@link Vector3| position}, {@link Quaternion| quaternion} and {@link Vector3| scale} components.
     * @Note Not all matrices are decomposable in this way.
     * For example, if an object has a non-uniformly scaled parent, then the object's world matrix may not be decomposable, and this method may not be appropriate.
     */
    decompose(position: Vector3, quaternion: Quaternion, scale: Vector3): Matrix4;
    /**
     * Sets the matrix based on all the available properties.
     * @param x Position on the x axis.
     * @param y Position on the y axis.
     * @param pivotX Pivot on the x axis.
     * @param pivotY Pivot on the y axis.
     * @param scaleX Scale on the x axis.
     * @param scaleY Scale on the y axis.
     * @param rotation Rotation in radians.
     * @param skewX Skew on the x axis.
     * @param skewY Skew on the y axis.
     * @return This matrix. Good for chaining method calls.
     */
    compose2D(x: number, y: number, pivotX: number, pivotY: number, scaleX: number, scaleY: number, rotation: number, skewX: number, skewY: number): this;
    /**
     * Decomposes the matrix (x, y, scaleX, scaleY, and rotation) and sets the properties on to a transform.
     * @returns The transform with the newly applied properties.
     */
    decompose2D(): {
        x: number;
        y: number;
        scaleX: number;
        scaleY: number;
        rotation: number;
        skewX: number;
        skewY: number;
    };
    /**
     * Creates a {@link https://en.wikipedia.org/wiki/3D_projection#Perspective_projection| perspective projection} matrix.
     * This is used internally by {@link PerspectiveCamera.updateProjectionMatrix| PerspectiveCamera.updateProjectionMatrix}()
     */
    makePerspective(left: number, right: number, top: number, bottom: number, near: number, far: number): Matrix4;
    /**
     * Creates an {@link https://en.wikipedia.org/wiki/Orthographic_projection| orthographic projection} matrix.
     * This is used internally by {@link OrthographicCamera.updateProjectionMatrix| OrthographicCamera.updateProjectionMatrix}().
     */
    makeOrthographic(left: number, right: number, top: number, bottom: number, near: number, far: number): Matrix4;
    /**
     * Apply this matrix to a 2D vector, z and w will set to 1 and 0.
     */
    transformVector2(vIn: {
        x: number;
        y: number;
    }, vOut?: Vector2): Vector2;
    /**
     * Return true if this matrix and {@link Matrix4| matrix} are equal.
     */
    equals(matrix: Matrix4): boolean;
    /**
     * Sets the elements of this matrix based on an array in column-major format.
     * @param array the array to read the elements from.
     * @param offset ( optional ) offset into the array.
     * @defaultValue `0`.
     */
    fromArray(array: ArrayLike, offset?: number): Matrix4;
    /**
     * There are 16 elements in this matrix.
     */
    getNumberCount(): number;
    /**
     * Writes the elements of this matrix to an array in column-major format.
     * @param array (optional) array to store the resulting vector in.
     * @param offset (optional) offset in the array at which to put the result.
     */
    toArray(array?: number[], offset?: number): number[];
}
declare type ReadonlyMatrix4 = PickReadonly;

/**
 * Class representing a 4D {@link https://en.wikipedia.org/wiki/Vector_space| vector}.
 * A 4D vector is an ordered quadruplet of numbers (labeled x, y, z, and w).
 */
declare class Vector4 {
    /**
     * the x value of this vector.
     * @defaultValue `0`.
     */
    x: number;
    /**
     * the y value of this vector.
     * @defaultValue `0`.
     */
    y: number;
    /**
     * the z value of this vector.
     * @defaultValue `0`.
     */
    z: number;
    /**
     * the w value of this vector.
     * @defaultValue `0`.
     */
    w: number;
    /**
     * Check the type whether it belongs to Vector4.
     * This value should not be changed by user.
     */
    isVector4: boolean;
    constructor(_x?: number, _y?: number, _z?: number, _w?: number);
    /**
     * @ignore
     */
    getSerializeData(): number[];
    /**
     * @ignore
     */
    setSerializeData(value: any): void;
    /**
     * Sets the {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} components of this vector.
     */
    set(x: number, y: number, z: number, w: number): Vector4;
    /**
     * Sets the {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} values of this vector both equal to scalar.
     */
    setScalar(scalar: number): Vector4;
    /**
     * Replaces this vector's {@link x| x} value with x.
     */
    setX(x: number): Vector4;
    /**
     * Replaces this vector's {@link y| y} value with y.
     */
    setY(y: number): Vector4;
    /**
     * Replaces this vector's {@link z| z} value with z.
     */
    setZ(z: number): Vector4;
    /**
     * Replaces this vector's {@link w| w} value with w.
     */
    setW(w: number): Vector4;
    /**
     * If index equals 0 set {@link x| x} to value.
     * If index equals 1 set {@link y| y} to value.
     * If index equals 2 set {@link z| z} to value.
     * If index equals 3 set {@link w| w} to value.
     * @param index 0, 1 or 2.
     */
    setComponent(index: number, value: number): Vector4;
    /**
     * If index equals 0 returns the {@link x| x} value.
     * If index equals 1 returns the {@link y| y} value.
     * If index equals 2 returns the {@link z| z} value.
     * If index equals 3 returns the {@link w| w} value.
     * @param index 0, 1, 2 or 3.
     */
    getComponent(index: number): number;
    /**
     * Returns a new Vector4 with the same {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} values as this one.
     */
    clone(): Vector4;
    cloneReadonly(): Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "equals" | "getSerializeData" | "x" | "y" | "z" | "getNumberCount" | "toArray" | "dot" | "lengthSq" | "length" | "manhattanLength" | "w">>;
    /**
     * Copies the values of the passed Vector4's {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} properties to this Vector4.
     */
    copy(v: Vector4): Vector4;
    /**
     * Adds {@link Vector4| v} to this vector.
     */
    add(v: Vector4): Vector4;
    /**
     * Adds the scalar value s to this vector's {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} values.
     */
    addScalar(s: number): Vector4;
    /**
     * Sets this vector to {@link Vector4| a} + {@link Vector4| b}.
     */
    addVectors(a: Vector4, b: Vector4): Vector4;
    /**
     * Adds the multiple of {@link Vector4| v} and s to this vector.
     */
    addScaledVector(v: Vector4, s: number): Vector4;
    /**
     * Subtracts {@link Vector4| v} from this vector.
     */
    sub(v: Vector4): Vector4;
    /**
     * Subtracts s from this vector's {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} components.
     */
    subScalar(s: number): Vector4;
    /**
     * Sets this vector to {@link Vector4| a} - {@link Vector4| b}.
     */
    subVectors(a: Vector4, b: Vector4): Vector4;
    /**
     * Multiplies this vector by scalar s.
     */
    multiplyScalar(scalar: number): Vector4;
    /**
     * Multiplies this vector by 4 x 4 {@link Matrix4| m}.
     */
    applyMatrix4(m: Matrix4): Vector4;
    /**
     * Divides this vector by scalar s.
     * Sets vector to `( 0, 0, 0, 0 )` if `s = 0`.
     */
    divideScalar(scalar: number): Vector4;
    /**
     * If this vector's x, y, z or w value is greater than the max vector's x, y, z or w value, it is replaced by the corresponding value. 


     * If this vector's x, y, z or w value is less than the min vector's x, y, z or w value, it is replaced by the corresponding value.
     * @param min the minimum {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} values.
     * @param max the maximum {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} values in the desired range.
     */
    min(v: Vector4): Vector4;
    /**
     * If this vector's x, y, z or w value is greater than the max vector's x, y, z or w value, it is replaced by the corresponding value. 


     * If this vector's x, y, z or w value is less than the min vector's x, y, z or w value, it is replaced by the corresponding value.
     * @param min the minimum {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} values.
     * @param max the maximum {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} values in the desired range.
     */
    max(v: Vector4): Vector4;
    /**
     * If this vector's x, y, z or w value is greater than the max vector's x, y, z or w value, it is replaced by the corresponding value. 


     * If this vector's x, y, z or w value is less than the min vector's x, y, z or w value, it is replaced by the corresponding value.
     * @param min the minimum {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} values.
     * @param max the maximum {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} values in the desired range.
     */
    clamp(min: Vector4, max: Vector4): Vector4;
    /**
     * If this vector's x, y, z or w values are greater than the max value, they are replaced by the max value. 


     * If this vector's x, y, z or w values are less than the min value, they are replaced by the min value.
     * @param min the minimum {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} values.
     * @param max the maximum {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} values in the desired range.
     */
    clampScalar(minVal: number, maxVal: number): Vector4;
    /**
     * If this vector's length is greater than the max value, it is replaced by the max value. 


     * If this vector's length is less than the min value, it is replaced by the min value.
     * @param min the minimum {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} values.
     * @param max the maximum {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} values in the desired range.
     */
    clampLength(min: number, max: number): Vector4;
    /**
     * The components of this vector are rounded down to the nearest integer value.
     */
    floor(): Vector4;
    /**
     * The {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} components of this vector are rounded up to the nearest integer value.
     */
    ceil(): Vector4;
    /**
     * The components of this vector are rounded to the nearest integer value.
     */
    round(): Vector4;
    /**
     * The components of this vector are rounded towards zero (up if negative, down if positive) to an integer value.
     */
    roundToZero(): Vector4;
    /**
     * Inverts this vector - i.e. sets x = -x, y = -y, z = -z and w = -w.
     */
    negate(): Vector4;
    /**
     * Calculates the {@link https://en.wikipedia.org/wiki/Dot_product| dot product} of this vector and {@link Vector4| v}.
     */
    dot(v: Vector4): number;
    /**
     * Computes the square of the {@link https://en.wikipedia.org/wiki/Euclidean_distance| Euclidean length }
     * (straight-line length) from (0, 0, 0, 0) to (x, y, z, w).
     * If you are comparing the lengths of vectors, you should compare the length squared instead as it is slightly more efficient to calculate.
     */
    lengthSq(): number;
    /**
     * Computes the Euclidean length (straight-line length) from (0, 0, 0, 0) to (x, y, z, w).
     */
    length(): number;
    /**
     * Computes the {@link http://en.wikipedia.org/wiki/Taxicab_geometry| Manhattan length } of this vector.
     */
    manhattanLength(): number;
    /**
     * Converts this vector to a {@link https://en.wikipedia.org/wiki/Unit_vector| unit vector }
     * - that is, sets it equal to a vector with the same direction as this one, but {@link length| length} 1.
     */
    normalize(): Vector4;
    /**
     * Sets this vector to a vector with given length the same direction as this one.
     */
    setLength(length: number): Vector4;
    /**
     * Linearly interpolates between this vector and {@link Vector4| v},
     * where alpha is the percent distance along the line - alpha = 0 will be this vector, and alpha = 1 will be {@link Vector4| v}.
     * @param v {@link Vector4| Vector4} to interpolate towards.
     * @param alpha interpolation factor, typically in the closed interval [0, 1].
     */
    lerp(v: Vector4, alpha: number): Vector4;
    /**
     * Sets this vector to be the vector linearly interpolated between {@link Vector4| v1} and
     * {@link Vector4| v2} where alpha is the percent distance along the line connecting the two vectors
     * - alpha = 0 will be {@link Vector4| v1}, and alpha = 1 will be {@link Vector4| v2}.
     * @param v1 the starting {@link Vector4| Vector4}.
     * @param v2 {@link Vector4| Vector4} to interpolate towards.
     * @param alpha interpolation factor, typically in the closed interval [0, 1].
     */
    lerpVectors(v1: Vector4, v2: Vector4, alpha: number): Vector4;
    /**
     * Checks for strict equality of this vector and {@link Vector4| v}.
     */
    equals(v: Vector4): boolean;
    /**
     * Sets the {@link x| x}, {@link y| y} and {@link z| z} components of this vector to the quaternion's axis and {@link w| w} to the angle.
     * @param q a normalized {@link Quaterion| Quaterion}
     */
    setAxisAngleFromQuaternion(q: Quaternion): Vector4;
    /**
     * {@link Matrix4| m} a {@link Matrix4| Matrix4} of which the upper left 3x3 matrix is a pure rotation matrix.
     * Sets the {@link x| x}, {@link y| y} and {@link z| z} to the axis of rotation and {@link w| w} to the angle.
     */
    setAxisAngleFromRotationMatrix(m: Matrix4): Vector4;
    /**
     * Sets this vector's {@link x| x} value to be array[ offset + 0 ], {@link y| y} value to be array[ offset + 1 ]
     * {@link z| z} value to be array[ offset + 2 ] and {@link w| w} value to be array[ offset + 3 ].
     * @param array the source array.
     * @param offset (optional) offset into the array.
     * @defaultValue `0`.
     */
    fromArray(array: ArrayLike, offset?: number): Vector4;
    /**
     * There are 4 elements in this vector.
     */
    getNumberCount(): number;
    /**
     * Returns an array [x, y, z, w], or copies x, y, z and w into the provided array.
     * @param array (optional) array to store this vector to. If this is not provided, a new array will be created.
     * @param offset (optional) optional offset into the array.
     */
    toArray(array?: number[], offset?: number): number[];
    /**
     * Sets this vector's {@link x| x}, {@link y| y}, {@link z| z} and {@link w| w} values from the {@link BufferAttribute| attribute}.
     * @param attribute the source attribute.
     * @param index index in the attribute.
     */
    fromBufferAttribute(attribute: BufferAttribute, index: number): Vector4;
}
declare type ReadonlyVector4 = PickReadonly;

declare type UniformUploadTypes = boolean | number | Float32Array | Int32Array | number[];
declare type UniformGeneralTypes = UniformUploadTypes | Color | Matrix3 | Matrix4 | Vector2 | Vector3 | Vector4 | ReadonlyMatrix4 | ReadonlyMatrix3 | ReadonlyColor | ReadonlyVector2 | ReadonlyVector3 | ReadonlyVector4;

declare type TextureCubeSide = TextureMipmapGroup;
declare class TextureCube extends LegacySourceTexture {
    px: TextureCubeSide;
    nx: TextureCubeSide;
    py: TextureCubeSide;
    ny: TextureCubeSide;
    pz: TextureCubeSide;
    nz: TextureCubeSide;
    static get default(): TextureCube;
    className(): string;
    static fromImageArray(arr: HTMLImageElement[]): TextureCube;
    static fromImageArrayAsync(arr: HTMLImageElement[]): Promise;
    static fromFirstLayerArray(arr: Texture2DCommonLayer[]): TextureCube;
    static fromArray(arr: Array>): TextureCube;
    static defaultEnvMap: TextureCube;
    static getDefaultEnvMap(): Promise;
    constructor(px: TextureCubeSide, nx: TextureCubeSide, py: TextureCubeSide, ny: TextureCubeSide, pz: TextureCubeSide, nz: TextureCubeSide);
    syncData(): void;
    /**
     * @internal
     */
    uploadWebGLImpl(ctx: WebGLTextureUploadCtx, disableCustomMipmap: boolean, needPOT: boolean): SourceTextureWebGLUploadResult;
    /**
     * @internal
     */
    canAutoGenerateMipmap(): boolean;
    protected getAutoGeneratedMipmapByteSize(): number;
    serialize(ctx: Serializer): void;
    deserialize(ctx: Deserializer): Promise;
}

declare class WGLProgram {
    readonly id: number;
    readonly version: number;
    readonly key: string;
    readonly shaderInfo: ShaderInfo;
    readonly globalUniforms: BuiltInUniforms;
    readonly gl: WebGLRenderingContext | WebGL2RenderingContext;
    readonly renderState: RenderState;
    _disposed: boolean;
    uniformSkipTag: Map;
    readonly attributeKey = "";
    readonly program: WebGLProgram;
    private attributes;
    private uniforms;
    private uniformBlocks;
    private referenceSet;
    constructor(renderState: RenderState, info: ShaderInfo, material: Nullable, key: string);
    getAttributesInfo(): {
        [index: string]: number;
    };
    private createWebGLProgram;
    private createUniformBlocks;
    private fetchUniformsInfo;
    private fetchAttributesInfo;
    setUniform(name: string, data: UniformGeneralTypes, silent?: boolean): void;
    setUniformBlock(name: string, data: UniformBlockObject): void;
    queryUBOLayout(name: string): {
        all: number;
        offsets: number[];
    } | undefined;
    setTexture(name: string, texture: Texture, silent?: boolean): void;
    setTextures(name: string, textures: Texture[], silent?: boolean): void;
    setTexture2D(name: string, texture: Texture, silent?: boolean): void;
    setArrayTexture2D(name: string, textures: Texture[]): void;
    setTexture3D(name: string, texture: Texture): void;
    setArrayTextureCube(name: string, textures: TextureCube[]): void;
    setTextureCube(name: string, texture: TextureCube): void;
    attach(material: Material): void;
    detach(material: Material): boolean;
    destroy(): void;
}

declare abstract class ShaderComponent implements SerializerableDelegated {
    /**
     * @internal
     */
    __material: Material | undefined;
    /**
     * @internal
     */
    isShaderComponent: boolean;
    abstract extendShaderShading(builder: ShaderBuilder): void;
    extendShaderShape(_builder: ShaderBuilder): void;
    updateShapeUniforms?(program: WGLProgram): void;
    updateShadingUniforms?(program: WGLProgram): void;
    generateShaderKey?(): string;
    computeShapeKey?(): string;
    abstract className(): string;
    abstract deserialize(ctx: Deserializer): void | Promise;
    abstract serialize(serialize: Serializer): void;
    abstract copy(other: ShaderComponent): any;
    abstract clone(): any;
    constructor();
}
declare abstract class SharedShaderComponent extends ShaderComponent {
    serialize(_: Serializer): void;
    deserialize(_: Deserializer): void | Promise;
    referenceSet: Set;
    className(): string;
    clearAllRef(): void;
    attachMaterial(m: Material): void;
    detachMaterial(m: Material): void;
    broadcastToRecompile(): void;
    broadcastToPropertyChanged(): void;
    abstract extendShaderShading(builder: ShaderBuilder): void;
    updateImpl(_camera: Camera3D): boolean;
    dirtyKey: number;
    update(camera: Camera3D): void;
}
interface ShaderInputDescriptor {
    name: string;
    type: WebGLShaderDataType;
}
interface UniformArrayDescriptor {
    length: number;
    des: ShaderInputDescriptor;
}
interface UniformBlockDescriptor {
    name: string;
    uniforms: ShaderInputDescriptor[];
}
interface ShaderInfo {
    uniforms: ShaderInputDescriptor[];
    uniformArrays: UniformArrayDescriptor[];
    uniformsBlocks: UniformBlockDescriptor[];
    globalUniforms: BuiltInUniformTypes[];
    attributes: ShaderInputDescriptor[];
    varyings: ShaderInputDescriptor[];
    vertex: string;
    frag: string;
}

declare type PickedBySubType = Pick>;
declare type NotPickedBySubType = Omit>;
declare type SubTypeMap = Record, V> & NotPickedBySubType;
declare type ConvertMaterialParameters = Partial>;
declare type MaterialParameters = ConvertMaterialParameters>;
interface MaterialState {
    transparent: boolean;
    visible: boolean;
    side: Side;
    blending: Blending;
    blendSrc: BlendingFactor;
    blendDst: BlendingFactor;
    blendEquation: BlendingEquation;
    blendSrcAlpha: Nullable;
    blendDstAlpha: Nullable;
    blendEquationAlpha: Nullable;
    stencilWriteMask: number;
    stencilFunc: StencilFunc;
    stencilRef: number;
    stencilFuncMask: number;
    stencilFail: StencilOp;
    stencilZFail: StencilOp;
    stencilZPass: StencilOp;
    stencilWrite: boolean;
    depthFunc: DepthModes;
    depthTest: boolean;
    depthWrite: boolean;
    colorWrite: boolean;
    colorWriteMasks: [boolean, boolean, boolean, boolean];
    polygonOffset: boolean;
    polygonOffsetFactor: number;
    polygonOffsetUnits: number;
    premultipliedAlpha: boolean;
}
/**
 * A base class for all materials with some abstract functions.
 * Materials describe the appearance of the objects.
 * They are defined in a (mostly) renderer-independent way, so you don't have to rewrite materials if you decide to use a different renderer.
 * The following properties and methods are inherited by all other material types (although they may have different defaults).
 */
declare abstract class Material extends ElementEventDispatcher implements SerializerableDelegatedAsReference, MaterialState, ElementsWithGPUResource {
    /**
     * @internal
     */
    isMaterial: boolean;
    private components;
    private componentNameList;
    getComponents(): ReadonlyArray;
    deleteComponent(index: number): void;
    addComponent(c: ShaderComponent, index?: number): void;
    /**
     * Mark this shape of this material is largely affect by shader.
     * Hint the engine that pick, culling is disabled
     * @deprecated
     */
    isDynamicShape: boolean;
    /**
     * Mark this material uses volume like rendering technology.
     * Hint the engine that some effect is disabled
     * @deprecated
     */
    isVolumeRendering: boolean;
    /**
     * max texture count, just in case some platform will take use of some channels by default,
     * so set to 6 instead of 8
     */
    static readonly MAX_TEXTURES = 6;
    /**
     * Optional name of the object (doesn't need to be unique). Default is an empty string.
     */
    name: string;
    /**
     * Unique number for this material instance.
     */
    id: number;
    /**
     * If use transparent effect, this value must be set to true to enable blending.
     * @defaultValue `false`
     */
    transparent: boolean;
    /**
     * Defines whether this material is visible.
     * @defaultValue `true`
     */
    visible: boolean;
    /**
     * The id of shader program which this material shader belongs to.
     */
    programId: number;
    /**
     * This just for control the shader compile behavior, not a state.
     * If this value is set to true, {@link isSupportInstance| isSupportInstance } must be set to true.
     * @ignore
     */
    useInstance: boolean;
    refreshInstanceInBuilding(enable: boolean): void;
    /**
     * Set which side of the object will be seen on screen.
     */
    side: Side;
    /**
     * Which blending to use when displaying objects with this material.
     * This must be set to CustomBlending to use custom
     * {@link blendSrc| blendSrc }, {@link blendDst| blendDst } or {@link blendEquation| blendEquation }.
     * See the blending mode constants for all possible values. Default is NormalBlending.
     * @defaultValue {@link Blending.NormalBlending| NormalBlending }
     */
    blending: Blending;
    /**
     * Blending source. Default is SrcAlphaFactor. See the source factors constants for all possible values.
     * @defaultValue {@link BlendingFactor.SrcAlphaFactor| SrcAlphaFactor }
     */
    blendSrc: BlendingFactor;
    /**
     * Blending destination. Default is OneMinusSrcAlphaFactor. See the destination factors constants for all possible values.
     * @defaultValue {@link BlendingFactor.OneMinusSrcAlpha| OneMinusSrcAlpha }
     */
    blendDst: BlendingFactor;
    /**
     * Blending equation to use when applying blending. Default is AddEquation. See the blending equation constants for all possible values.
     * @defaultValue {@link BlendingEquation.Add| Add }
     */
    blendEquation: BlendingEquation;
    /**
     * The transparency of the {@link blendSrc| blendSrc }.
     */
    blendSrcAlpha: Nullable;
    /**
     * The transparency of the {@link blendDst| blendDst }.
     */
    blendDstAlpha: Nullable;
    /**
     * The transparency of the {@link blendEquation| blendEquation }.
     */
    blendEquationAlpha: Nullable;
    /**
     * Whether rendering this material has any effect on the stencil buffer.
     * @defaultValue `false`
     */
    stencilWrite: boolean;
    /**
     * The bit mask to use when writing to the stencil buffer.
     * @defaultValue `0xFF`
     */
    stencilWriteMask: number;
    /**
     * The bit mask to use when comparing against the stencil buffer.
     * @defaultValue `0xFF`
     */
    stencilFuncMask: number;
    /**
     * The stencil comparison function to use.
     * @defaultValue {@link StencilFunc.AlwaysStencilFunc| AlwaysStencilFunc }
     */
    stencilFunc: StencilFunc;
    /**
     * The value to use when performing stencil comparisons or stencil operations.
     * @defaultValue `0`
     */
    stencilRef: number;
    /**
     * Which stencil operation to perform when the comparison function returns false.
     * @defaultValue {@link StencilOp.KeepStencilOp| KeepStencilOp }
     */
    stencilFail: StencilOp;
    /**
     * Which stencil operation to perform when the comparison function returns true but the depth test fails.
     * @defaultValue {@link StencilOp.KeepStencilOp| KeepStencilOp }
     */
    stencilZFail: StencilOp;
    /**
     * Which stencil operation to perform when the comparison function returns true and the depth test passes.
     * @defaultValue {@link StencilOp.KeepStencilOp| KeepStencilOp }
     */
    stencilZPass: StencilOp;
    /**
     * Which depth function to use.
     * @defaultValue {@link DepthModes.LessEqualDepth| LessEqualDepth }
     */
    depthFunc: DepthModes;
    /**
     * Whether to have depth test enabled when rendering this material.
     * If this is set to false, this object's occluding relationship will depend on {@link Object3D.renderOrder| renderOrder }.
     * @defaultValue `true`
     */
    depthTest: boolean;
    /**
     * Whether rendering this material has any effect on the depth buffer.
     * @defaultValue `true`
     */
    depthWrite: boolean;
    /**
     * Whether to render the material's color.
     * This can be used in conjunction with a {@link Object3D.renderOrder| renderOrder } property to create invisible objects that occlude other objects.
     * @defaultValue `true`
     */
    colorWrite: boolean;
    colorWriteMasks: [boolean, boolean, boolean, boolean];
    setColorWriteMasks(r: boolean, g: boolean, b: boolean, a: boolean): void;
    /**
     * Whether to use polygon offset.
     * @defaultValue `false`
     */
    polygonOffset: boolean;
    /**
     * Sets the polygon offset factor.
     * @defaultValue `0`
     */
    polygonOffsetFactor: number;
    /**
     * Sets the polygon offset units.
     * @defaultValue `0`
     */
    polygonOffsetUnits: number;
    /**
     * Whether to premultiply the alpha (transparency) value.
     * @defaultValue `false`
     */
    premultipliedAlpha: boolean;
    private _shaderKey?;
    private _shapeKey?;
    /**
     * An optionally overriding method for extents to get data from renderer before update uniforms.
     * @param {Renderer} renderer instance of renderer for engine.
     */
    onBeforeRender?: (renderer: Renderer) => void;
    /**
     * When user change the material property manually, this method need to use to refresh data.
     */
    notifyMaterialPropertyChanged(): void;
    /**
     * User can give any parameter to create new instance with corresponding properties.
     */
    constructor(params?: MaterialParameters);
    colorWriteMask: [boolean, boolean, boolean, boolean];
    /**
     * UUID of this material instance. This gets automatically assigned, so this shouldn't be edited.
     */
    getUUID(): string;
    /**
     * @ignore
     */
    createShader(registry: ShaderComponentRegistry): ShaderInfo;
    /**
     * @ignore
     */
    extendShader(builder: ShaderBuilder, registry: ShaderComponentRegistry): void;
    /**
     * @ignore
     */
    updateUniforms(program: WGLProgram, registry: ShaderComponentRegistry): void;
    /**
     * The name of instance's class.
     */
    abstract className(): string;
    /**
     * @ignore
     */
    abstract extendShaderShape(builder: ShaderBuilder, registry: ShaderComponentRegistry): void;
    /**
     * @ignore
     */
    abstract extendShaderShading(builder: ShaderBuilder, registry: ShaderComponentRegistry): void;
    /**
     * @ignore
     */
    abstract updateShapeUniforms(program: WGLProgram, registry: ShaderComponentRegistry): void;
    /**
     * @ignore
     */
    abstract updateShadingUniforms(program: WGLProgram, registry: ShaderComponentRegistry): void;
    /**
     * abstract function to clone each instance of the class
     */
    abstract clone(): Material;
    /**
     * abstract function to copy a same type material instance
     */
    abstract copy(other: Material): void;
    /**
     * @ignore
     */
    canDraw(): boolean;
    /**
     * Sets the properties with the given values.
     * In extents class, this method need to override in extended material for corresponding parameters.
     */
    setValues(values?: MaterialParameters): void;
    /**
     * Generate a unique key for shader.
     * @ignore
     */
    getShaderKey(registry: ShaderComponentRegistry): string;
    /**
     * Generate a unique shape key for ShapeExtractableDispatcher.
     * @ignore
     */
    getShapeKey(registry: ShaderComponentRegistry): string;
    /**
     * Reset the key of shader and force engine to compile shader again.
     */
    notifyRecompileShader(): void;
    /**
     * Copy basic properties from other material.
     * @param {Material} other the source of copied data
     */
    copyBase(other: Material): void;
    /**
     * Make engine clear the current material's data in Ubo.
     */
    freeGPU(): void;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx this parameter has not supported external Serializer yet.
     * It may cause that this method can not be used directly.
     */
    serialize(ctx: Serializer): any;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx this parameter has not supported external Deserializer yet.
     * It may cause that this method can not be used directly.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Use this to traverse material which has texture need to process.
     * @param {function} _visitor a method to process {@link Texture| texture}.
     * @ignore
     */
    traverseTexture(_visitor: (tex: Texture) => void): void;
    /**
     * Execute the given method for every ubo.
     * @param {function} _visitor a method to process ubo.
     * @ignore
     */
    traverseUBO(_visitor: (ubo: UniformBlockObject) => void): void;
    /**
     * Generate a basic key for material, and engine will recompile shader if this key is changed.
     * This method may override in extended class.
     * @ignore
     */
    generateShaderKey(_registry: ShaderComponentRegistry): string;
    /**
     * @ignore
     */
    abstract computeShapeKey(registry: ShaderComponentRegistry): string;
    destroyAllResourcesOwned(): void;
    freeAllGpuResourceOwned(): void;
}

interface Size {
    width: number;
    height: number;
    depth?: number;
}
interface IRange {
    x: number;
    y: number;
    width: number;
    height: number;
}
declare type Nullable = T | null;
declare type PickSubTypeProperty = {
    [P in keyof T]: T[P] extends U ? P : never;
}[keyof T];
declare type TypedArray$3 = Float32Array | Float64Array | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array;
declare type PickReadonly, K extends keyof T> = Readonly, K | '_readonly_mark' | 'cloneReadonly' | 'clone'>>;
declare type ReadonlyMarked = {
    _readonly_mark: unknown;
} & T;
interface ReadOnlyMarkedCreatable {
    clone(): T;
    cloneReadonly(): any;
}

/**
 * A point's {@link https://en.wikipedia.org/wiki/Cylindrical_coordinate_system| cylindrical coordinates}.
 */
declare class Cylindrical {
    /**
     * The radius of bottom cycle.
     */
    radius: number;
    /**
     * counterclockwise angle in the x-z plane measured in radians from the positive z-axis.
     * @defaultValue `0`.
     */
    theta: number;
    /**
     * height above the x-z plane.
     * @defaultValue `0`.
     */
    y: number;
    constructor(radius?: number, theta?: number, y?: number);
    /**
     * Sets values of this cylinder's {@link radius| radius}, {@link theta| theta} and {@link y| y} properties.
     */
    set(radius: number, theta: number, y: number): Cylindrical;
    /**
     * Returns a new cylinder with the same {@link radius| radius}, {@link theta| theta} and {@link y| y} properties as this one.
     */
    clone(): Cylindrical;
    /**
     * Copies the values of the passed cylinder's {@link radius| radius}, {@link theta| theta} and {@link y| y} properties to this cylinder.
     */
    copy(other: Cylindrical): Cylindrical;
    /**
     * Sets values of this cylinder's {@link radius| radius}, {@link theta| theta} and {@link y| y} properties from the {@link Vector3| Vector3}.
     */
    setFromVector3(v: Vector3): Cylindrical;
    /**
     * Sets values of this cylinder's {@link radius| radius}, {@link theta| theta} and {@link y| y} properties from Cartesian coordinates.
     */
    setFromCartesianCoords(x: number, y: number, z: number): Cylindrical;
}

/**
 * A point's {@link https://en.wikipedia.org/wiki/Spherical_coordinate_system| spherical coordinates}.
 */
declare class Spherical {
    /**
     * the radius, or the {@link https://en.wikipedia.org/wiki/Euclidean_distance| Euclidean distance}.
     */
    radius: number;
    /**
     * polar angle in radians from the y (up) axis.
     * @defaultValue `0`.
     */
    phi: number;
    /**
     * equator angle in radians around the y (up) axis.
     * @defaultValue `0`.
     */
    theta: number;
    constructor(radius?: number, phi?: number, theta?: number);
    /**
     * Sets values of this spherical's {@link radius| radius}, {@link phi| phi} and {@link theta| theta} properties.
     */
    set(radius: number, phi: number, theta: number): Spherical;
    /**
     * Returns a new spherical with the same {@link radius| radius}, {@link phi| phi} and {@link theta| theta} properties as this one.
     */
    clone(): Spherical;
    /**
     * Copies the values of the passed Spherical's {@link radius| radius}, {@link phi| phi} and {@link theta| theta} properties to this spherical.
     */
    copy(other: Spherical): Spherical;
    /**
     * Restricts the polar angle {@link phi| phi} to be between 0.000001 and pi - 0.000001.
     */
    makeSafe(): Spherical;
    /**
     * Sets values of this spherical's {@link radius| radius}, {@link phi| phi} and {@link theta| theta} properties from the {@link Vector3| Vector3}.
     */
    setFromVector3(v: Vector3): Spherical;
    /**
     * Sets values of this spherical's {@link radius| radius}, {@link phi| phi} and {@link theta| theta} properties from Cartesian coordinates.
     */
    setFromCartesianCoords(x: number, y: number, z: number): Spherical;
}

/**
 * Class representing a 3D {@link https://en.wikipedia.org/wiki/Vector_space| vector}.
 * A 3D vector is an ordered triplet of numbers (labeled x, y, and z).
 */
declare class Vector3 implements Vector {
    /**
     * the x value of this vector.
     * @defaultValue `0`.
     */
    x: number;
    /**
     * the y value of this vector.
     * @defaultValue `0`.
     */
    y: number;
    /**
     * the z value of this vector.
     * @defaultValue `0`.
     */
    z: number;
    /**
     * Check the type whether it belongs to Vector3.
     * This value should not be changed by user.
     */
    isVector3: boolean;
    constructor(_x?: number, _y?: number, _z?: number);
    /**
     * If NaN exists in three elements, return true.
     */
    hasNan(): boolean;
    /**
     * @ignore
     */
    getSerializeData(): number[];
    /**
     * @ignore
     */
    setSerializeData(value: any): void;
    /**
     * Set the {@link x| x}, {@link y| y} and {@link z| z} components of this vector.
     */
    set(x: number, y: number, z: number): Vector3;
    /**
     * Set the {@link x| x}, {@link y| y} and {@link z| z} values of this vector both equal to scalar.
     */
    setScalar(scalar: number): Vector3;
    /**
     * Replace this vector's {@link x| x} value with x.
     */
    setX(x: number): Vector3;
    /**
     * Replace this vector's {@link y| y} value with y.
     */
    setY(y: number): Vector3;
    /**
     * Replace this vector's {@link z| z} value with z.
     */
    setZ(z: number): Vector3;
    /**
     * If index equals 0 set {@link x| x} to {@link Float| value}.
     * If index equals 1 set {@link y| y} to {@link Float| value}.
     * If index equals 2 set {@link z| z} to {@link Float| value}.
     */
    setComponent(index: number, value: number): Vector3;
    /**
     * If index equals 0 returns the {@link x| x} value.
     * If index equals 1 returns the {@link y| y} value.
     * If index equals 2 returns the {@link z| z} value.
     * @param index 0, 1 or 2.
     */
    getComponent(index: number): number;
    /**
     * Returns a new vector3 with the same {@link x| x}, {@link y| y} and {@link z| z} values as this one.
     */
    clone(): Vector3;
    cloneReadonly(): Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "equals" | "getSerializeData" | "x" | "y" | "z" | "getNumberCount" | "toArray" | "dot" | "lengthSq" | "length" | "manhattanLength" | "distanceTo" | "distanceToSquared" | "manhattanDistanceTo" | "angleTo">>;
    /**
     * Copies the values of the passed vector3's {@link x| x}, {@link y| y} and {@link z| z} properties to this vector3.
     */
    copy(v: Vector3): Vector3;
    /**
     * Adds {@link Vector3| v} to this vector.
     */
    add(v: Vector3): Vector3;
    /**
     * Adds the scalar value s to this vector's {@link x| x}, {@link y| y} and {@link z| z} values.
     */
    addScalar(s: number): Vector3;
    /**
     * Sets this vector to {@link Vector3| a} + {@link Vector3| b}.
     */
    addVectors(a: Vector3, b: Vector3): Vector3;
    /**
     * Adds the multiple of {@link Vector3| v} and s to this vector.
     */
    addScaledVector(v: Vector3, s: number): Vector3;
    /**
     * Subtracts {@link Vector3| v} from this vector.
     */
    sub(v: Vector3): Vector3;
    /**
     * Subtracts s from this vector's {@link x| x}, {@link y| y} and {@link z| z} components.
     */
    subScalar(s: number): Vector3;
    /**
     * Sets this vector to {@link Vector3| a} - {@link Vector3| b}.
     */
    subVectors(a: Vector3, b: Vector3): Vector3;
    /**
     * Multiplies this vector by {@link Vector3| v}.
     */
    multiply(v: Vector3): Vector3;
    /**
     * Multiplies this vector by scalar s.
     */
    multiplyScalar(scalar: number): Vector3;
    /**
     * Sets this vector equal to {@link Vector3| a} * {@link Vector3| b}, component-wise.
     */
    multiplyVectors(a: Vector3, b: Vector3): Vector3;
    /**
     * Multiplies this vector by {@link Matrix3| m}
     */
    applyMatrix3(m: Matrix3): Vector3;
    /**
     * Multiplies this vector (with an implicit 1 in the 4th dimension) and m, and divides by perspective.
     */
    applyMatrix4(m: Matrix4): Vector3;
    /**
     * Applies a {@link Quaternion| Quaternion} transform to this vector.
     */
    applyQuaternion(q: Quaternion): Vector3;
    /**
     * Projects this vector from world space into the camera's normalized device coordinate (NDC) space.
     * @param camera camera to use in the projection.
     */
    project(camera: Camera3D): Vector3;
    /**
     * Projects this vector from the camera's normalized device coordinate (NDC) space into world space.
     * @param camera camera to use in the projection.
     */
    unproject(camera: Camera3D): Vector3;
    /**
     * Transforms the direction of this vector by a matrix (the upper left 3 x 3 subset of a {@link Matrix4| m}) and then {@link normalize| normalizes} the result.
     */
    transformDirection(m: Matrix4): Vector3;
    /**
     * Divides this vector by {@link Vector3| v}.
     */
    divide(v: Vector3): Vector3;
    /**
     * Divides this vector by scalar s.
     * Sets vector to `( 0, 0, 0 )` if `s = 0`.
     */
    divideScalar(scalar: number): Vector3;
    /**
     * If this vector's x, y or z value is greater than the max vector's x, y or z value, it is replaced by the corresponding value. 


     * If this vector's x, y or z value is less than the min vector's x, y or z value, it is replaced by the corresponding value.
     * @param min the minimum {@link x| x}, {@link y| y} and {@link z| z} values.
     * @param max the maximum {@link x| x}, {@link y| y} and {@link z| z} values in the desired range.
     */
    min(v: Vector3): Vector3;
    /**
     * If this vector's x, y or z value is greater than the max vector's x, y or z value, it is replaced by the corresponding value. 


     * If this vector's x, y or z value is less than the min vector's x, y or z value, it is replaced by the corresponding value.
     * @param min the minimum {@link x| x}, {@link y| y} and {@link z| z} values.
     * @param max the maximum {@link x| x}, {@link y| y} and {@link z| z} values in the desired range.
     */
    max(v: Vector3): Vector3;
    /**
     * If this vector's x, y or z value is greater than the max vector's x, y or z value, it is replaced by the corresponding value. 


     * If this vector's x, y or z value is less than the min vector's x, y or z value, it is replaced by the corresponding value.
     * @param min the minimum {@link x| x}, {@link y| y} and {@link z| z} values.
     * @param max the maximum {@link x| x}, {@link y| y} and {@link z| z} values in the desired range.
     */
    clamp(min: Vector3, max: Vector3): Vector3;
    /**
     * If this vector's x, y or z values are greater than the max value, they are replaced by the max value. 


     * If this vector's x, y or z values are less than the min value, they are replaced by the min value.
     * @param min the minimum value the components will be clamped to.
     * @param max the maximum value the components will be clamped to.
     */
    clampScalar(minVal: number, maxVal: number): Vector3;
    /**
     * If this vector's length is greater than the max value, the vector will be scaled down so its length is the max value. 


     * If this vector's length is less than the min value, the vector will be scaled up so its length is the min value.
     * @param min the minimum value the length will be clamped to.
     * @param max the maximum value the length will be clamped to.
     */
    clampLength(min: number, max: number): Vector3;
    /**
     * The components of this vector are rounded down to the nearest integer value.
     */
    floor(): Vector3;
    /**
     * The {@link x| x}, {@link y| y} and {@link z| z} components of this vector are rounded up to the nearest integer value.
     */
    ceil(): Vector3;
    /**
     * The components of this vector are rounded to the nearest integer value.
     */
    round(): Vector3;
    /**
     * The components of this vector are rounded towards zero (up if negative, down if positive) to an integer value.
     */
    roundToZero(): Vector3;
    /**
     * Inverts this vector - i.e. sets x = -x, y = -y and z = -z.
     */
    negate(): Vector3;
    /**
     * Calculate the {@link https://en.wikipedia.org/wiki/Dot_product| dot product} of this vector and {@link Vector3| v}.
     */
    dot(v: Vector3): number;
    /**
     * Computes the square of the {@link https://en.wikipedia.org/wiki/Euclidean_distance| Euclidean length}
     * (straight-line length) from (0, 0, 0) to (x, y, z). If you are 	comparing the lengths of
     * vectors, you should compare the length squared instead as it is slightly more efficient to calculate.
     */
    lengthSq(): number;
    /**
     * Computes the Euclidean length (straight-line length) from (0, 0, 0) to (x, y, z).
     */
    length(): number;
    /**
     * Computes the {@link http://en.wikipedia.org/wiki/Taxicab_geometry| Manhattan length} of this vector.
     */
    manhattanLength(): number;
    /**
     * Convert this vector to a {@link https://en.wikipedia.org/wiki/Unit_vector| unit vector}
     * - that is, sets it equal to a vector with the same direction as this one, but {@link length| length} 1.
     */
    normalize(): Vector3;
    /**
     * Sets this vector to a vector with given length the same direction as this one.
     */
    setLength(length: number): Vector3;
    /**
     * Linearly interpolate between this vector and {@link Vector3| v}, where alpha is the
     * percent distance along the line - alpha = 0 will be this vector, and alpha = 1 will be {@link Vector3| v}.
     * @param v {@link Vector3| Vector3} to interpolate towards.
     * @param alpha interpolation factor, typically in the closed interval [0, 1].
     */
    lerp(v: Vector3, alpha: number): Vector3;
    /**
     * Sets this vector to be the vector linearly interpolated between {@link Vector3| v1} and
     * {@link Vector3| v2} where alpha is the percent distance along the line connecting the two vectors -
     * alpha = 0 will be {@link Vector3| v1}, and alpha = 1 will be {@link Vector3| v2}.
     * @param v1 the starting {@link Vector3| Vector3}.
     * @param v2 {@link Vector3| Vector3} to interpolate towards.
     * @param alpha interpolation factor, typically in the closed interval [0, 1].
     */
    lerpVectors(v1: Vector3, v2: Vector3, alpha: number): Vector3;
    /**
     * Sets this vector to {@link https://en.wikipedia.org/wiki/Cross_product| cross product} of itself and {@link Vector3| v}.
     */
    cross(v: Vector3): Vector3;
    /**
     * Sets this vector to cross product of {@link Vector3| a} and {@link Vector3| b}.
     */
    crossVectors(a: Vector3, b: Vector3): Vector3;
    /**
     * {@link https://en.wikipedia.org/wiki/Vector_projection| Projects} this vector onto {@link Vector3| vector}.
     */
    projectOnVector(vector: Vector3): Vector3;
    /**
     * {@link https://en.wikipedia.org/wiki/Vector_projection| Projects} this vector onto a plane by subtracting this vector projected onto the plane's normal from this vector.
     * @param planeNormal A vector representing a plane normal.
     */
    projectOnPlane(planeNormal: Vector3): Vector3;
    /**
     * Reflect this vector off of plane orthogonal to {@link Vector3| normal}.
     * Normal is assumed to have unit length.
     * @param normal the normal to the reflecting plane.
     */
    reflect(normal: Vector3): Vector3;
    /**
     * Returns the angle between this vector and vector {@link Vector3| v} in radians.
     */
    angleTo(v: Vector3): number;
    /**
     * Computes the distance from this vector to {@link Vector3| v}.
     */
    distanceTo(v: Vector3): number;
    /**
     * Computes the squared distance from this vector to {@link Vector3| v}.
     * If you are just comparing the distance with another distance,
     * you should compare the distance squared instead as it is slightly more efficient to calculate.
     */
    distanceToSquared(v: Vector3): number;
    /**
     * Computes the {@link https://en.wikipedia.org/wiki/Taxicab_geometry| Manhattan distance} from this vector to {@link Vector3| v}.
     */
    manhattanDistanceTo(v: Vector3): number;
    /**
     * Sets this vector from the spherical coordinates {@link Spherical| s}.
     */
    setFromSpherical(s: Spherical): Vector3;
    /**
     * Sets this vector from the spherical coordinates {@link Spherical| radius}, {@link Spherical| phi} and {@link Spherical| theta}.
     */
    setFromSphericalCoords(radius: number, phi: number, theta: number): Vector3;
    /**
     * Sets this vector from the cylindrical coordinates {@link Cylindrical| c}.
     */
    setFromCylindrical(c: Cylindrical): Vector3;
    /**
     * Sets this vector from the cylindrical coordinates {@link Cylindrical| radius}, {@link Cylindrical| theta} and {@link Cylindrical| y}.
     */
    setFromCylindricalCoords(radius: number, theta: number, y: number): Vector3;
    /**
     * Sets this vector to the position elements of the {@link https://en.wikipedia.org/wiki/Transformation_matrix| transformation matrix} {@link Matrix4| m}.
     */
    setFromMatrixPosition(m: Matrix4): Vector3;
    /**
     * Sets this vector's {@link x| x}, {@link y| y} and {@link z| z} components from {@link Integer| index} column of {@link Matrix4| matrix}.
     */
    setFromMatrixColumn(matrix: Matrix4, index: number): Vector3;
    /**
     * Sets this vector to the scale elements of the {@link https://en.wikipedia.org/wiki/Transformation_matrix| transformation matrix} {@link Matrix4| m}.
     */
    setFromMatrixScale(m: Matrix4): Vector3;
    /**
     * Checks for strict equality of this vector and {@link Vector3| v}.
     */
    equals(v: Vector3): boolean;
    /**
     * Sets this vector's {@link x| x} value to be array[ offset + 0 ], {@link y| y} value to be array[ offset + 1 ] and {@link z| z} value to be array[ offset + 2 ].
     * @param array the source array.
     * @param offset ( optional) offset into the array.
     * @defaultValue `0`.
     */
    fromArray(array: ArrayLike, offset?: number): Vector3;
    /**
     * There are 3 elements in this vector.
     */
    getNumberCount(): number;
    /**
     * Returns an array [x, y, z], or copies x, y and z into the provided array.
     * @param array (optional) array to store this vector to.
     * If this is not provided a new array will be created.
     * @param offset (optional) optional offset into the array.
     */
    toArray(array?: number[], offset?: number): number[];
    /**
     * Sets this vector's {@link x| x}, {@link y| y} and {@link z| z} values from the {@link BufferAttribute| attribute}.
     * @param attribute the source attribute.
     * @param index index in the attribute.
     */
    fromBufferAttribute(attribute: BufferAttribute, index: number): Vector3;
}
declare type ReadonlyVector3 = PickReadonly;

/**
 * A geometric triangle as defined by three {@link Vector3| Vector3} representing its three corners.
 */
declare class Triangle {
    /**
     * The first corner of the triangle.
     * @defaultValue is (0, 0, 0).
     */
    a: Vector3;
    /**
     * The second corner of the triangle.
     * @defaultValue is (0, 0, 0).
     */
    b: Vector3;
    /**
     * The final corner of the triangle.
     * @defaultValue is (0, 0, 0).
     */
    c: Vector3;
    constructor(a?: Vector3, b?: Vector3, c?: Vector3);
    /**
     * Calculate the {@link https://en.wikipedia.org/wiki/Normal_(geometry)| normal vector} of the triangle.
     */
    static getNormal(a: Vector3, b: Vector3, c: Vector3, target: Vector3): Vector3;
    /**
     * Return a {@link https://en.wikipedia.org/wiki/Barycentric_coordinate_system| barycentric coordinate} from the given vector.
     */
    static getBarycoord(point: Vector3, a: Vector3, b: Vector3, c: Vector3, target: Vector3): Vector3;
    /**
     * Returns true if the passed point, when projected onto the plane of the triangle, lies within the triangle.
     */
    static containsPoint(point: Vector3, a: Vector3, b: Vector3, c: Vector3): boolean;
    /**
     * Calculate the uv value of given point by a,b,c and their uv.
     * @param target the result will be stored here.
     */
    static getUV(point: Vector3, a: Vector3, b: Vector3, c: Vector3, uv1: Vector2, uv2: Vector2, uv3: Vector2, target: Vector2): Vector2;
    /**
     * Sets the triangle's {@link a| a}, {@link b| b} and {@link c| c} properties to the passed {@link Vector3| vector3}.

     * Please note that this method only copies the values from the given objects.
     */
    set(a: Vector3, b: Vector3, c: Vector3): Triangle;
    /**
     * Sets the triangle's vectors to the vectors in the array.
     * @param points array of {@link Vector3| Vector3}.
     * @param i0 {@link Integer| Integer} index.
     * @param i1 {@link Integer| Integer} index.
     * @param i2 {@link Integer| Integer} index.
     */
    setFromPointsAndIndices(points: Vector3[], i0: number, i1: number, i2: number): Triangle;
    /**
     * Returns a new triangle with the same {@link a| a}, {@link b| b} and  {@link c| c} properties as this one.
     */
    clone(): Triangle;
    /**
     * Copies the values of the passed triangle's {@link a| a}, {@link b| b} and {@link c| c} properties to this triangle.
     */
    copy(triangle: Triangle): Triangle;
    /**
     * Return the area of the triangle.
     */
    getArea(): number;
    /**
     * Calculate the midpoint of the triangle.
     * @param target the result will be copied into this Vector3.
     */
    getMidpoint(target: Vector3): Vector3;
    /**
     * Calculate the {@link https://en.wikipedia.org/wiki/Normal_(geometry)| normal vector } of the triangle.
     * @param target the result will be copied into this Vector3.
     */
    getNormal(target: Vector3): Vector3;
    /**
     * Use this triangle to calculate {@link Triangle.getBarycoord| barycentric coordinate}.
     */
    getBarycoord(point: Vector3, target: Vector3): Vector3;
    /**
     * Returns true if the passed point, when projected onto the plane of the triangle, lies within the triangle.
     * @param point {@link Vector3| Vector3} to check.
     */
    containsPoint(point: Vector3): boolean;
    /**
     * Use this triangle to calculate {@link Triangle.getUV| UV }.
     */
    getUV(point: Vector3, uv1: Vector2, uv2: Vector2, uv3: Vector2, result: Vector2): Vector2;
    /**
     * Determines whether or not this triangle intersects {@link Box3| box}.
     * @param box Box to check for intersection against.
     */
    intersectsBox(box: Box3): boolean;
    /**
     * Returns true if the two triangles have identical {@link a| a}, {@link b| b} and {@link c| c} properties.
     */
    equals(triangle: Triangle): boolean;
    /**
     * Returns the closest point on the triangle to {@link Vector3| point}.
     */
    closestPointToPoint(p: Vector3, target: Vector3): Vector3;
}

/**
 * A 2D box represents by {@link min| min} and {@link max| max}.
 */
declare class Box2 {
    /**
     * {@link Vector2| Vector2} representing the lower (x, y) boundary of the box.

     * @defaultValue is ( + Infinity, + Infinity ).
     */
    min: Vector2;
    /**
     * {@link Vector2| Vector2} representing the upper (x, y) boundary of the box.

     * @defaultValue is ( - Infinity, - Infinity ).
     */
    max: Vector2;
    constructor(min?: Vector2, max?: Vector2);
    /**
     * Sets the lower and upper (x, y) boundaries of this box.

     * Please note that this method only copies the values from the given objects.
     * @param min {@link Vector2| Vector2} representing the lower (x, y) boundary of the box. 

     * @param max {@link Vector2| Vector2} representing the upper (x, y) boundary of the box. 


     */
    set(min: Vector2, max: Vector2): Box2;
    /**
     * Sets the upper and lower bounds of this box to include all of the points in {@link Array| points}.
     * @param points Array of {@link Vector2| Vector2s} that the resulting box will contain.


     */
    setFromPoints(points: Vector2[]): Box2;
    /**
     * Centers this box on {@link Vector2| center} and sets this box's width and height to the values specified in {@link Vector2| size}.
     * @param center Desired center position of the box ({@link Vector2| Vector2}).

     * @param size Desired x and y dimensions of the box ({@link Vector2| Vector2}).


     */
    setFromCenterAndSize(center: Vector2, size: Vector2): Box2;
    /**
     * Return a new {@link Box2| Box2} with the same {@link .min| min} and {@link .max| max} as this clone
     */
    clone(): Box2;
    /**
     * Copies the {@link min| min} and {@link max| max} from {@link Box2| box} to this box.
     */
    copy(box: Box2): Box2;
    /**
     * Makes this box empty.
     */
    makeEmpty(): Box2;
    /**
     * Return true if this box includes zero points within its bounds.

     * @tips that a box with equal lower and upper bounds still includes one point, the one both bounds share.
     */
    isEmpty(): boolean;
    /**
     * Return the center point of the box as a {@link Vector2| Vector2}.
     * @param target the result will be copied into this Vector2.
     */
    getCenter(target: Vector2): Vector2;
    /**
     * Return the width and height of this box.
     * @param target the result will be copied into this Vector2.
     */
    getSize(target?: Vector2): Vector2;
    /**
     * Expands the boundaries of this box to include {@link Vector2| point}.
     * @param point {@link Vector2| Vector2} that should be included in the box.
     */
    expandByPoint(point: Vector2): Box2;
    /**
     * Expands this box equilaterally by {@link Vector2| vector}. The width of this box will be
     * expanded by the x component of {@link Vector2| vector} in both directions. The height of
     * this box will be expanded by the y component of {@link Vector2| vector} in both directions.
     * @param vector {@link Vector2| Vector2} to expand the box by.
     */
    expandByVector(vector: Vector2): Box2;
    /**
     * Expands each dimension of the box by scalar. If negative, the dimensions of the box will be contracted.
     * @param scalar Distance to expand the box by.
     */
    expandByScalar(scalar: number): Box2;
    /**
     * Return true if the specified {@link Vector2| point} lies within or on the boundaries of this box.
     * @param point {@link Vector2| Vector2} to check for inclusion.
     */
    containsPoint(point: Vector2): boolean;
    /**
     * Return true if this box includes the entirety of {@link Box2| box}.
     * If this and {@link Box2| box} are identical, this function also returns true.
     * @param box {@link Box2| Box2} to test for inclusion.
     */
    containsBox(box: Box2): boolean;
    /**
     * Return a point as a proportion of this box's width and height.
     * @param target the result will be copied into this Vector2.
     */
    getParameter(point: Vector2, target: Vector2): Vector2;
    /**
     * Determines whether or not this box intersects {@link Box2| box}.
     * @param box Box to check for intersection against.
     */
    intersectsBox(box: Box2): boolean;
    /**
     * {@link https://en.wikipedia.org/wiki/Clamping_(graphics)| Clamps} the {@link Vector2| point} within the bounds of this box.

     * @param point {@link Vector2| Vector2} to clamp.
     * @param target the result will be copied into this Vector2.
     */
    clampPoint(point: Vector2, target: Vector2): Vector2;
    /**
     * Return the distance from any edge of this box to the specified point.
     * If the {@link Vector2| point} lies inside of this box, the distance will be 0.
     * @param point {@link Vector2| Vector2} to measure distance to.
     */
    distanceToPoint(point: Vector2): number;
    /**
     * Return the intersection of this and {@link Box2| box}, setting the upper bound of this box to the lesser
     * of the two boxes' upper bounds and the lower bound of this box to the greater of the two boxes' lower bounds.
     * @param box Box to intersect with.
     */
    intersect(box: Box2): Box2;
    /**
     * Unions this box with {@link Box2| box}, setting the upper bound of this box to the greater of the
     * two boxes' upper bounds and the lower bound of this box to the lesser of the two boxes' lower bounds.
     * @param box Box that will be unioned with this box.
     */
    union(box: Box2): Box2;
    /**
     * Adds {@link Vector2| offset} to both the upper and lower bounds of this box, effectively moving this box {@link Vector2| offset} units in 2D space.
     * @param offset Direction and distance of offset.
     */
    translate(offset: Vector2): Box2;
    /**
     * Return true if this box and {@link Box2| box} share the same lower and upper bounds.
     * @param box Box to compare with this one.
     */
    equals(box: Box2): boolean;
    /**
     * Apply the transform matrix on four vertexes.
     */
    applyMatrix3(matrix: Matrix3): Box2;
    /**
     * Apply the four left-top elements of matrix on four vertexes.
     */
    applyMatrix4(matrix: Matrix4): this;
    /**
     * Enlarges box2 that way its corners lie on grid.
     * Get max box based on resolution which is small than this box.
     */
    ceil(resolution?: number, eps?: number): this;
}

/**
 * A 3D box represents by {@link min| min} and {@link max| max}.
 */
declare class Box3 {
    /**
     * {@link Vector3| Vector3} representing the lower (x, y, z) boundary of the box.
     * @defaultValue ( + Infinity, + Infinity, + Infinity ).
     */
    min: Vector3;
    /**
     * {@link Vector3| Vector3} representing the upper (x, y, z) boundary of the box.
     * @defaultValue ( - Infinity, - Infinity, - Infinity ).
     */
    max: Vector3;
    /**
     * An array of {@link Plane| Planes} represents the six faces of the box.
     */
    planes: Plane[];
    /**
     * The position of eight box's vertexes.
     */
    corners: Vector3[];
    /**
     * Check the type whether it belongs to Box3.
     * This value should not be changed by user.
     */
    isBox3: boolean;
    constructor(min?: Vector3, max?: Vector3);
    /**
     * Sets the lower and upper (x, y, z) boundaries of this box.

     * Please note that this method only copies the values from the given objects.
     * @param min {@link Vector3| Vector3} representing the lower (x, y, z) boundary of the box.
     * @param max {@link Vector3| Vector3} representing the lower upper (x, y, z) boundary of the box.
     */
    set(min: Vector3, max: Vector3): Box3;
    /**
     * Sets the upper and lower bounds of this box to include all of the data in `array`.
     * @param array An array of position data that the resulting box will envelop.
     */
    setFromArray(array: ArrayLike): Box3;
    /**
     * Sets the upper and lower bounds of this box to include all of the data in {@link BufferAttribute| attribute}.
     * @param attribute A buffer attribute of position data that the resulting box will envelop.
     */
    setFromBufferAttribute(attribute: BufferAttribute): Box3;
    /**
     * Sets the upper and lower bounds of this box by a part of attributes.
     * @param attribute A buffer attribute of position data that the resulting box will envelop.
     * @param start The start attributes of range.
     * @param count The count of attributes in range.
     */
    setFromBufferAttributeRange(attribute: BufferAttribute, start: number, count: number): Box3;
    /**
     * Sets the upper and lower bounds of this box by a part of vertexes' index.
     * @param positionAttribute A buffer of vertex data.
     * @param indexAttribute A buffer of vertex' index.
     * @param start The start indexes of range.
     * @param count The count of indexes in range.
     */
    setFromIndexBufferAttributeRange(positionAttribute: BufferAttribute, indexAttribute: BufferAttribute, start: number, count: number): Box3;
    /**
     * Sets the upper and lower bounds of this box to include all of the points in {@link Array| points}.
     * @param points Array of {@link Vector3| Vector3s} that the resulting box will contain.
     */
    setFromPoints(_points: Vector3[]): Box3;
    /**
     * Centers this box on {@link Vector3| center} and sets this box's width, height and depth to the values specified in {@link Vector3| size}.
     * @param center Desired center position of the box.
     * @param size Desired x, y and z dimensions of the box.
     */
    setFromCenterAndSize(_center: Vector3, size: Vector3): Box3;
    /**
     * Computes the world-axis-aligned bounding box of an {@link Object3D| Object3D} (including its children),
     * accounting for the object's, and children's, world transforms.
     * The function may result in a larger box than strictly necessary.
     * @param object {@link Object3D| Object3D} to compute the bounding box of.
     */
    setFromObject(object: Object3D): Box3;
    /**
     * Returns a new {@link Box3| Box3} with the same {@link min| min} and {@link max| max} as this clone.
     */
    clone(): Box3;
    /**
     * Copies the {@link min| min} and {@link max| max} from {@link Box3| box} to this box.
     * @param box {@link Box3| Box3} to copy.
     */
    copy(box: Box3): Box3;
    /**
     * Makes this box empty.
     */
    makeEmpty(): Box3;
    /**
     * Returns true if this box includes zero points within its bounds.
     * Note that a box with equal lower and upper bounds still includes one point, the one both bounds share.
     */
    isEmpty(): boolean;
    /**
     * Returns the center point of the box as a {@link Vector3| Vector3}.
     * @param target the result will be copied into this Vector3.
     */
    getCenter(target: Vector3): Vector3;
    /**
     * Returns the center point of the box as a {@link Vector3| Vector3}.
     * this method returns the center whatever the values of box' {@link min| min} is over than {@link max| max}.
     * @param target the result will be copied into this Vector3.
     */
    getCenterUnsafe(target: Vector3): void;
    /**
     * Returns the width, height and depth of this box.
     * @param target the result will be copied into this Vector3.
     */
    getSize(target?: Vector3): Vector3;
    /**
     * Return the position of eight box's vertexes.
     */
    getCorners(): Vector3[];
    /**
     * Return an array of planes of eight box's surface.
     */
    getPlanes(): Plane[];
    /**
     * Expands the boundaries of this box to include {@link Vector3| point}.
     * @param point {@link Vector3| Vector3} that should be included in the box.
     */
    expandByPoint(point: Vector3): Box3;
    /**
     * Expands this box equilaterally by {@link Vector3| vector}. The width of this box will be
     * expanded by the x component of {@link Vector3| vector} in both directions. The height of
     * this box will be expanded by the y component of {@link Vector3| vector} in both directions.
     * The depth of this box will be expanded by the z component of *vector* in both directions.
     * @param vector {@link Vector3| Vector3} to expand the box by.
     */
    expandByVector(vector: Vector3): Box3;
    /**
     * Expands each dimension of the box by scalar.
     * If negative, the dimensions of the box will be contracted.
     * @param scalar Distance to expand the box by.
     */
    expandByScalar(scalar: number): Box3;
    /**
     * Expands the boundaries of this box to include {@link Object3D| object} and its children,
     * accounting for the object's, and children's, world transforms.
     * The function may result in a larger box than strictly necessary.
     * @param object {@link Object3D| Object3D} to expand the box by.
     */
    expandByObject(object: Object3D): Box3;
    private _satForAxes;
    /**
     * @param triangle {@link Triangle| Triangle} to check for intersection against.
     * Determines whether or not this box intersects {@link Triangle| triangle}.
     */
    intersectsTriangle(triangle: Triangle): boolean;
    /**
     * Return true if the specified {@link Vector3| point} lies within or on the boundaries of this box.
     * @param point {@link Vector3| Vector3} to check for inclusion.
     */
    containsPoint(point: Vector3): boolean;
    /**
     * Return true if this box includes the entirety of {@link Box3| box}. If this and {@link Box3| box} are identical, this function also returns true.
     * @param box {@link Box3| Box3} to test for inclusion.
     */
    containsBox(box: Box3): boolean;
    /**
     * Return a point as a proportion of this box's width and height.
     * @param point {@link Vector3| Vector3}.
     * @param target the result will be copied into this Vector3.
     */
    getParameter(point: Vector3, target: Vector3): Vector3;
    /**
     * {@link Box3| box} Box to check for intersection against.
     * Determines whether or not this box intersects {@link Box3| box}.
     */
    intersectsBox(box: Box3): boolean;
    /**
     * Determines whether or not this box intersects {@link Sphere| sphere}.
     * @param sphere {@link Sphere| Sphere} to check for intersection against.
     */
    intersectsSphere(sphere: Sphere): boolean;
    /**
     * Determines whether or not this box intersects {@link Plane| plane}.
     * @param plane {@link Plane| Plane} to check for intersection against.
     */
    intersectsPlane(plane: Plane): boolean;
    /**
     * {@link https://en.wikipedia.org/wiki/Clamping_(graphics)| Clamps} the {@link Vector3| point} within the bounds of this box.
     * @param point {@link Vector3| Vector3} to clamp.
     * @param target the result will be copied into this Vector3.
     */
    clampPoint(point: Vector3, target: Vector3): Vector3;
    /**
     * If the {@link Vector3| point} lies inside of this box, the distance will be 0.
     * @param point {@link Vector3| Vector3} to measure distance to.
     * @return the distance from any edge of this box to the specified point.
     */
    distanceToPoint(point: Vector3): number;
    /**
     * Gets a {@link Sphere| Sphere} that bounds the box.
     * @param target the result will be copied into this Sphere.
     */
    getBoundingSphere(target: Sphere): Sphere;
    /**
     * Computes the intersection of this and {@link Box3| box}, setting the upper bound of this box to the lesser
     * of the two boxes' upper bounds and the lower bound of this box to the greater of the two boxes'
     * lower bounds. If there's no overlap, makes this box empty.
     * @param Box to intersect with.
     */
    intersect(box: Box3): Box3;
    /**
     * Computes the union of this box and {@link Box3| box}, setting the upper bound of this box to the greater of the
     * two boxes' upper bounds and the lower bound of this box to the lesser of the two boxes' lower bounds.
     * @param box Box that will be unioned with this box.
     */
    union(box: Box3): Box3;
    /**
     * If NaN exists in three values of min and max, return true.
     */
    hasNan(): boolean;
    /**
     * Check the given box is valid and let this box can contain it.
     */
    unionSafe(box: Box3): Box3;
    /**
     * Transforms this Box3 with the supplied matrix.
     * @param matrix The {@link Matrix4| Matrix4} to apply.
     */
    applyMatrix4(matrix: Matrix4): Box3;
    /**
     * Adds {@link Vector3| offset} to both the upper and lower bounds of this box, effectively moving this box {@link Vector3| offset} units in 3D space.
     * @param offset Direction and distance of offset.
     */
    translate(offset: Vector3): Box3;
    /**
     * Return true if this box and {@link Box3| box} share the same lower and upper bounds.
     * @param box Box to compare with this one.
     */
    equals(box: Box3): boolean;
    /**
     * Return the Bounding on plane XY.
     */
    toBox2(box2?: Box2): Box2;
}

declare class Geometry extends EventDispatcher {
    /**
     * The name of instance's class.
     */
    className(): string;
    /**
     * Unique number of this geometry instance.
     */
    id: number;
    /**
     * Name for this geometry. Default is an empty string.
     */
    name: string;
    /**
     * The type of this instance.
     */
    type: string;
    /**
     * An array of vertices hold every position of points of the model.
     */
    vertices: Vector3[];
    /**
     * An array of vertex colors, matching number and order of vertices.
     * Used in ParticleSystem, Line and Ribbon.
     * Meshes use per-face-use-of-vertex colors embedded directly in faces.
     */
    colors: Color[];
    /**
     * An array of triangles or/and quads.
     * The array of faces describe how each vertex in the model is connected with each other.
     * @remarks See {@link Face3| Face3} for more details.
     */
    faces: Face3[];
    /**
     * An array of face UV layers.
     * Each UV layer is an array of UV matching order and number of vertices in faces.
     */
    faceVertexUvs: Vector2[][][];
    /**
     * The distance is used to determine the length of line, this is necessary for drawing segmented line.
     * The value can be calculated by {@link BufferAttribute.getAttributeLayoutKey| getAttributeLayoutKey()}.
     */
    lineDistances: number[];
    /**
     * Used to check type of this or extended instance.
     * This value should not be changed by user.
     */
    isGeometry: boolean;
    /**
     * Let every positional and normal vector multiple with specified matrix.
     * @param {Matrix4} matrix a 4×4 matrix which is applied to.
     */
    applyMatrix(matrix: Matrix4): Geometry;
    /**
     * Rotate this object around X independently.
     * @param {number} angle a radian value to rotate.
     */
    rotateX(angle: number): Geometry;
    /**
     * Rotate this object around Y independently.
     * @param {number} angle a radian value to rotate.
     */
    rotateY(angle: number): Geometry;
    /**
     * Rotate this object around Z independently.
     * @param {number} angle a radian value to rotate.
     */
    rotateZ(angle: number): Geometry;
    /**
     * Translate the geometry with specified vector.
     * @param {number} x translate vector' x, represent the distance of moving object along X.
     * @param {number} y translate vector' y, represent the distance of moving object along Y.
     * @param {number} z translate vector' z, represent the distance of moving object along Z.
     */
    translate(x: number, y: number, z: number): Geometry;
    /**
     * Make object bigger or smaller.
     * @param {number} x change the size on X direction.
     * @param {number} y change the size on Y direction.
     * @param {number} z change the size on Z direction.
     */
    scale(x: number, y: number, z: number): Geometry;
    /**
     * Rotates the object to face to a point in world space.
     * @param {Vector3} vector A vector representing position of target in world space.
     */
    lookAt(vector: Vector3): void;
    /**
     * Duplicate data from {@link BufferGeometry| BufferGeometry} to this {@link Geometry| Geometry} object.
     * @param {BufferGeometry} geometry the data source.
     */
    fromBufferGeometry(geometry: BufferGeometry): Geometry;
    /**
     * Make all numbers' abs of {@link vertices| vertices} and {@link faces| faces} less than 1.
     */
    normalize(): Geometry;
    /**
     * Computes the distance between two vertexes, store to {@link lineDistances| lineDistances}.
     * the distance is used to determine the length of line, this is necessary for drawing segmented line.
     */
    computeLineDistances(): void;
    /**
     * Compute normals for every faces.
     */
    computeFaceNormals(): void;
    /**
     * Computes vertex normals by averaging face normals. Face normals must be existing / computed beforehand.
     */
    computeVertexNormals(areaWeighted?: boolean): void;
    /**
     * Compute vertex normals, but duplicating face normals.
     */
    computeFlatVertexNormals(): void;
    /**
     * Combine all data of external geometry and this geometry into one array.
     * @param {Geometry} geometry all attributes from this geometry will be merged.
     * @param {Matrix4} matrix a matrix to modify the vertices' data. Usually this is the world matrix of merged object.
     * @param {number} materialIndexOffset an index mark the material data for the merged object.
     */
    merge(geometry: Geometry, matrix?: Matrix4, materialIndexOffset?: number): void;
    /**
     * Checks for duplicate vertices using hashmap.
     * Duplicated vertices are removed and faces' vertices are updated.
     */
    mergeVertices(): number;
    /**
     * Add some new vertices to this geometry.
     * @param {Vector3[]} points every Vector3 represent a vertex on object.
     */
    setFromPoints(points: Vector3[]): this;
    /**
     * Sorts the faces array according to material index. For complex geometries with several materials,
     * this can result in reduced draw calls and improved performance.
     */
    sortFacesByMaterialIndex(): void;
    /**
     * Get UUID of this object instance.
     * This value is automatically assigned, so this shouldn't be edited.
     */
    getUUID(): string;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx this parameter has not supported external Deserializer yet.
     * It may cause that this method can not be used directly.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx this parameter has not supported external Serializer yet.
     * It may cause that this method can not be used directly.
     */
    serialize(ctx: Serializer): void;
    /**
     * Creates a new clone of this Geometry.
     */
    clone(): Geometry;
    /**
     * Copy the data to this object from source.
     * This method need override in derived classes to copy extended data.
     * @param {Geometry} source the data source.
     */
    copy(source: Geometry): Geometry;
    parseGeometryFromJSON(json: any, geometry: Geometry): void;
}

/**
 * used to describe draw range
 */
interface BufferRange {
    /**
     * start offset of index or position
     */
    start: number;
    /**
     * index or position element count
     */
    count: number;
}
interface BufferGroup extends BufferRange {
    materialIndex: number;
}
declare type IndexBufferAttribute = BufferAttribute;
/**
 * An efficient representation of mesh, line, or point geometry, which includes vertex positions, face indices, normals, colors, UVs,
 * and custom attributes within buffers, reducing the cost of passing all this data to the GPU.
 * To read and edit data in BufferGeometry attributes, see {@link BufferAttribute| BufferAttribute } documentation.
 * For a less efficient but easier-to-use representation of geometry, see {@link Geometry| Geometry }.

 */
declare abstract class BufferGeometryBase extends GeometryBase {
    /**
     * The name of viewer, which could be empty.
     */
    name: string;
    /**
     * The type of this instance.
     * This will be give in extended class.
     */
    type: string;
    /**
     * Flag to indicate the type of this class.
     * This value should not be changed by user.
     */
    isBufferGeometry: boolean;
    /**
     * This object is used to record all parameters which are set when instance is initialized.
     * But, change the value of this object may not change the geometry directly.
     */
    parameters: {};
    /**
     * Use BVH to accelerate rendering.
     * This value usually dose not need you to change it, it is built by the engine automatically.
     */
    meshBVH?: MeshBVH;
    /**
     * @internal
     */
    meshBVHVersion: number;
    /**
     * Allows for vertices to be re-used across multiple triangles; this is called using "indexed triangles". 

     * and works much the same as it does in Geometry: each triangle is associated with the indices of three vertices. 

     * This attribute therefore stores the index of each vertex for each triangular face. 

     * If this attribute is not set, the renderer assumes that each three contiguous positions represent a single triangle. 

     * This should be set by {@link setIndex| setIndex()} to avoid error.
     * @defaultValue `null`
     */
    _index: Nullable;
    get index(): IndexBufferAttribute;
    set index(v: IndexBufferAttribute);
    /**
     * Core data of Geometry such as vertex positions, normals, UVs and color.
     * @tips It's better to use {@link addAttribute| addAttribute() } or {@link setAttribute| setAttribute() } to change this.
     * @remarks See {@link BufferAttribute| BufferAttribute} for more details.
     */
    attributes: {
        [index: string]: BufferAttribute;
    };
    /**
     * @ignore
     * */
    getAttributes(): Readonly<{
        [index: string]: BufferAttribute;
    }>;
    /**
     * @internal
     */
    _attributeBindMap: Record;
    get position(): BufferAttribute;
    get uv(): BufferAttribute;
    /**
     * Split the geometry into groups, they still are rendered in different WebGL drawcalls. 

     * This allows an array of materials to be used with the bufferGeometry.
     * Each group is an object of the form: `{ start: Integer, count: Integer, materialIndex: Integer, instances?: Integer }`

     * Start specifies the first element in this draw call – the first vertex for non-indexed geometry, otherwise the first triangle index.

     * Count specifies how many vertices (or indices) are included.

     * MaterialIndex specifies the material array index to use.

     * Instances(optional) specifies the number of instanced object, this value do not manually set.
     */
    protected groups: BufferGroup[];
    /**
     * @ignore
     */
    getGroups(): ReadonlyArray>;
    /**
     * get group at index
     */
    getGroup(index: number): BufferGroup | undefined;
    /**
     * Split the data into different groups.
     */
    setGroup(group: BufferGroup, index: number): void;
    /**
     * set entire groups
     */
    setGroups(groups: BufferGroup[]): this;
    /**
     * push a group
     */
    pushGroup(group: BufferGroup): this;
    /**
     * Split geometry data to a new group.
     * @remarks See {@link groups| groups} for more details.
     */
    addGroup(start: number, count: number, materialIndex?: number): void;
    /**
     * Clean all objects in the {@link groups| groups}.
     */
    clearGroups(): void;
    /**
     * Determines which part of buffer will be rendered.
     * @deprecated
     * @defaultValue `{ start: 0, count: Infinity }` All data will be uploaded.
     */
    drawRange: BufferRange;
    protected boundingBox: Nullable;
    protected boundingSphere: Nullable;
    /**
     * If {@link boundingBox| boundingBox} is null, it will be {@link computeBoundingBox| calculated} a new one.
     */
    getBoundingBox(): Box3;
    /**
     * If {@link boundingSphere| boundingSphere} is null, it will be {@link computeBoundingSphere| calculated} a new one.
     */
    getBoundingSphere(): Sphere;
    /**
     * Clear the bounding box and sphere and recalculate them later.
     */
    notifyShapeChanged(): void;
    /**
     * Generate a hash key according to {@link index| index} and all {@link attributes| attributes}.
     */
    getAttributeLayoutKey(): string;
    constructor();
    /**
     * The name of instance's class.
     */
    className(): string;
    /**
     * Clean old data of engine and load new data in next update.
     */
    attributeChanged(): void;
    /**
     * Return current instance of this class.
     */
    getBufferGeometry(): this;
    /**
     * Return current instance of this class.
     */
    getLineBufferGeometry(): this;
    /**
     * Return the instance of {@link index| index}.
     */
    getIndex(): IndexBufferAttribute;
    /**
     * Call this method to let engine refresh data of {@link meshBVH| meshBVH}.
     */
    onAttributeUpdate(): void;
    /**
     * Use this method to set new {@link index| index} for geometry.
     * @param {IndexBufferAttribute | number[]} index source data of the index.
     */
    setIndex(index: IndexBufferAttribute | number[] | TypedArray$3): this;
    addAttribute(name: string, attribute: BufferAttribute): this;
    /**
     * Change the given {@link attributes| attributes} for geometry.
     * @param {string} name the name of data such as position, uv and normal.
     * @param {BufferAttribute} attribute source data. see {@link BufferAttribute| BufferAttribute} for more details.
     */
    setAttribute(name: string, attribute: BufferAttribute): this;
    /**
     * Get specified {@link attributes| attributes} from geometry.
     * @param {string} name the name of target attributes.
     */
    addOrSetAttribute(name: string, array: TypedArray$3, itemSize: number): void;
    getAttribute(name: string): BufferAttribute | undefined;
    /**
     * Remove specified {@link attributes| attributes} from geometry.
     * @param {string} name the name of target attributes.
     */
    removeAttribute(name: string): this;
    removeAndDestroyAttribute(name: string): this;
    /**
     * Find the group which the vertex belong to.
     * @param {number} index Queried vertex index.
     */
    getGroupByVertexIndex(index: number): {
        group: BufferGroup;
        groupIndex: number;
    };
    /**
     * Change the value of {@link drawRange| drawRange}.
     * @deprecated
     */
    setDrawRange(start: number, count: number): void;
    protected checkRefreshBoundingSphereFast(): boolean;
    protected checkRefreshBoundingBoxFast(): boolean;
    /**
     * Computes bounding box according to vertexes, updating boundingBox attribute.
     * Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are null.
     */
    computeBoundingBox(): void;
    /**
     * Computes bounding sphere according to vertexes, updating boundingSphere attribute.
     * Bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are null.
     */
    computeBoundingSphere(): void;
    /**
     * Copy the data to this object from source.
     * This method need override in derived classes to copy extended data.
     * @param {Object3D} source the data source.
     */
    copy(source: BufferGeometryBase): BufferGeometryBase;
    _computeGroups(geometry: Geometry): void;
    /**
     * UUID of this BufferGeometries instance. This gets automatically assigned, so this shouldn't be edited.
     */
    getUUID(): string;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx this parameter has not supported external Serializer yet.
     * It may cause that this method can not be used directly.
     */
    serialize(ctx: Serializer): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx this parameter has not supported external Deserializer yet.
     * It may cause that this method can not be used directly.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * Clear the current geometry's data in memory.
     */
    freeGPU(): void;
    destroy(): void;
    destroyAttributes(): void;
    freeAttributesGpuResource(): void;
    destroyAllResourcesOwned(): void;
    freeAllGpuResourceOwned(): void;
    forceCastTopology(): BufferGeometry;
}
declare enum PrimitiveTopology {
    Point = 0,
    Line = 1,
    LineStrip = 2,
    Triangle = 3,
    TriangleStrip = 4
}
interface Topology {
    __topologyTypeMark: PrimitiveTopology;
}
declare class TriangleList implements Topology {
    __topologyTypeMark: PrimitiveTopology.Triangle;
    __tl: boolean;
}
declare class LineList implements Topology {
    __topologyTypeMark: PrimitiveTopology.Line;
    __ll: boolean;
}
declare class LineStrip implements Topology {
    __topologyTypeMark: PrimitiveTopology.LineStrip;
    __ls: boolean;
}
declare class PointList implements Topology {
    __topologyTypeMark: PrimitiveTopology.Point;
    __pl: boolean;
}
declare class BufferGeometry extends BufferGeometryBase {
    __topologyMark: T;
    /**
    * Create a clone of this instance.
    */
    clone(): BufferGeometry;
}

/**
 * An extensible curve object which contains methods for interpolation.
 */
declare class Curve implements SerializerableDelegatedAsReference {
    /**
     * The type of this curve.
     */
    type: string;
    /**
     * Divide this curve into how many parts of segments
     */
    arcLengthDivisions: number;
    cacheArcLengths: number[];
    needsUpdate: boolean;
    private _uuid;
    get uuid(): string;
    set uuid(uuid: string);
    getUUID(): string;
    /**
     * @ignore
     */
    serialize(ctx: Serializer): void;
    /**
     * @ignore
     */
    deserialize(ctx: Deserializer): void;
    className(): string;
    constructor();
    /**
     * Returns a vector for point t of the curve where t is between 0 and 1.
     */
    getPoint(_t: number, _optionalTarget?: T): T;
    /**
     * Returns a vector for point at relative position in curve according to arc length.
     */
    getPointAt(u: number, optionalTarget?: T): T;
    /**
     * Get sequence of points using getPoint(t).
     */
    getPoints(divisions?: number): T[];
    toArray(path?: number[], divisions?: number): number[];
    /**
     * Get sequence of equi-spaced points using getPointAt(u)
     */
    getSpacedPoints(divisions?: number): T[];
    /**
     * Get total curve arc length
     */
    getLength(): number;
    /**
     * Get list of cumulative segment lengths
     */
    getLengths(divisions?: number): number[];
    /**
     * Update the cumulative segment distance cache
     */
    updateArcLengths(): void;
    /**
     * Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equi distance
     */
    getUtoTmapping(u: number, distance?: number): number;
    /**
     * Returns a unit vector tangent at t. If the subclassed curve do not implement its tangent derivation,
     * 2 points a small delta apart will be used to find its gradient which seems to give a reasonable approximation
     */
    getTangent(t: number): T;
    /**
     * Returns tangent at equidistance point u on the curve.
     */
    getTangentAt(u: number): T;
    /**
     * @remarks see {@link http://www.cs.indiana.edu/pub/techreports/TR425.pdf | Frenet Frames}
     */
    computeFrenetFrames(segments: number, closed: boolean): any;
    clone(): Curve;
    copy(source: Curve): this;
    toJSON(): any;
    fromJSON(json: any): Curve;
    static adaptive: boolean;
    static maxLength: number;
    static minSegments: number;
    static maxSegments: number;
    static epsilon: number;
    static segmentsCount(length: number, defaultSegments?: number): number;
}

/**
 * A basic class for curve which can be drawn in {@link Path | path }. 2d space
 */
declare class Curve2D extends Curve {
    getBounds(bounds?: Box2): Box2;
    clone(): Curve2D;
    className(): string;
}

/**
 * An instanced version of {@link BufferAttribute | BufferAttribute }.
 */
declare class InstancedBufferAttribute extends BufferAttribute {
    /**
     * Defines how often a value of this buffer attribute should be repeated.
     * A value of one means that each value of the instanced attribute is used for a single instance.
     * A value of two means that each value is used for two consecutive instances (and so on).
     * Default is *1*.
     */
    meshPerAttribute: number;
    /**
     * Used to check type of this or extended instance.
     * This value should not be changed by user.
     */
    isInstancedBufferAttribute: boolean;
    constructor(data: T, itemSize: number, meshPerAttribute?: number);
    /**
     * Copy the data to this object from source.
     * @param { InstancedBufferAttribute } source the data source.
     */
    copy(source: InstancedBufferAttribute): this;
}

/**
 * This is a dedicated geometry for {@link FatLineSegments| FatLineSegments }.
 */
declare class FatLineBufferGeometry extends InstancedBufferGeometry$1 {
    /**
     * Used to check type of this or extended instance.
     * This value should not be changed by user.
     */
    isLineSegmentsGeometry: boolean;
    private _fallback_geometry;
    get fallback(): BufferGeometry;
    get instanceStart(): InstancedBufferAttribute;
    get instanceEnd(): InstancedBufferAttribute;
    /**
     * Creates an instance of FatLineBufferGeometry. geometry layout must be LineSegment
     * @param {(BufferGeometry | WireframeBufferGeometry)} geometry
     * @param {boolean} [geometryLayoutIsLineSegment=false]
     * @memberof FatLineBufferGeometry
     */
    constructor(geometry: BufferGeometry);
    /**
     * Apply the given matrix to vertexes data.
     * @return this object.
     */
    applyMatrix(matrix: Matrix4): FatLineBufferGeometry;
    /**
     * Build segmented line data by given data and update bounding.
     * @param { Float32Array } lineSegments the segments data store as Float32Array.
     * @return this object.
     */
    setPositions(lineSegments: Float32Array): FatLineBufferGeometry;
    /**
     * Recalculate the bounding box for this geometry.
     */
    computeBoundingBox(): void;
    /**
     * Recalculate the bounding sphere for this geometry.
     */
    computeBoundingSphere(): void;
    /**
     * Clear the current geometry's data in memory.
     */
    freeGPU(): void;
}

interface IViewerContext {
    /**
     * @internal
     */
    viewer: Viewer;
    config: ViewerConfig;
    snapshotRenderer: SnapshotRenderer;
    setHighlightGroups(groups: HighlightGroup[]): void;
    snapshotRenderResult(range?: IRange): Promise | undefined;
}
declare function createViewerContext(viewer: Viewer, viewport?: Viewport): IViewerContext;

declare type SpriteMaterialParameters = MaterialParameters & ConvertMaterialParameters, 'sizeAttenuation' | 'rotation' | 'texture' | 'opacity' | 'color'>>;
/**
 * A dedicated material of {@link Sprite| Sprite}.
 */
declare class SpriteMaterial$1 extends Material {
    /**
     * Whether the size of the sprite is attenuated by the camera depth. (Perspective camera only.)
     * @defaultValue `false`
     */
    sizeAttenuation: boolean;
    /**
     * The rotation of the sprite in radians.
     * @defaultValue `0`
     */
    rotation: number;
    /**
     * Color of the material, by default set to white (0xffffff).
     * The value of color multiply with the color of {@link texture| texture}.
     */
    color: Readonly, "_readonly_mark" | "cloneReadonly" | "clone" | "g" | "r" | "b" | "isColor" | "equals" | "getHex" | "getSerializeData">>;
    /**
     * A picture for sprite.
     * @defaultValue `null`
     */
    texture: Nullable;
    /**
     * The Transparency of object.
     * @defaultValue `null`
     */
    opacity: number;
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(p?: SpriteMaterialParameters);
    /**
     * Change the corresponding attribute according to the values of given {@link SpriteMaterialParameters| parameters}.
     * @param {SpriteMaterialParameters} p a object of specified type contains parameters.
     */
    setValues(p: SpriteMaterialParameters): void;
    traverseTexture(visitor: (tex: Texture) => void): void;
    /**
     * @ignore
     */
    generateShaderKey(r: ShaderComponentRegistry): string;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx an instance used to store the data of scene objects.
     */
    serialize(ctx: Serializer): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx an instance give the method to take the data for attribute.
     */
    deserialize(ctx: Deserializer): void;
    /**
     * @ignore
     */
    extendShaderShape(builder: ShaderBuilder, _: ShaderComponentRegistry): void;
    /**
     * @ignore
     */
    computeShapeKey(_: ShaderComponentRegistry): string;
    /**
     * @ignore
     */
    updateShapeUniforms(p: WGLProgram, _: ShaderComponentRegistry): void;
    /**
     * @ignore
     */
    updateShadingUniforms(program: WGLProgram): void;
    /**
     * @ignore
     */
    extendShaderShading(b: ShaderBuilder, _: ShaderComponentRegistry): void;
    /**
     * Copy the data to this instance from other instance.
     * @param {MeshBasicMaterial} other the source of copied data
     */
    copy(other: SpriteMaterial$1): this;
    /**
     * Return a cloned instance of this class.
     */
    clone(): SpriteMaterial$1;
}

/**
 * A sprite is a plane that always faces towards the camera, generally with a partially transparent texture applied.
 */
declare class Sprite extends Drawable {
    /**
     * The sprite's anchor point, and the point around which the sprite rotates.
     * A value of (0.5, 0.5) corresponds to the midpoint of the sprite.
     * A value of (0, 0) corresponds to the lower left corner of the sprite. The default is (0.5, 0.5).
     */
    center: Vector2;
    /**
     * The type of this Object3D.
     */
    type: 'Sprite';
    /**
     * Check the type whether it belongs to Sprite.
     * This value should not be changed by user.
     */
    isSprite: true;
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(material: SpriteMaterial$1);
    /**
     * Get intersections between a casted {@link Ray| ray} and this Sprite.
     * The method {@link Raycaster.intersectObject| intersectObject()} will call this method, but the results are not ordered.
     * @param {Raycaster} raycaster the instance of Raycaster is used to get the data for calculation.
     * @param {Intersection} intersects the result will be stored here.
     */
    raycastJsImpl(raycaster: Raycaster, intersects: Intersection[]): void;
    /**
     * Return a cloned instance of this class.
     */
    clone(): Sprite;
    /**
     * Copy the data to this instance from other instance.
     * @param {Sprite} other the source of copied data
     */
    copy(source: Sprite): this;
    /**
     * Store the attributes of this class into string as serializing format.
     * @param {Serializer} ctx an instance used to store the data of scene objects.
     */
    serialize(ctx: Serializer): void;
    /**
     * Parse the data for this class from string according to serializing format.
     * @param {Deserializer} ctx an instance give the method to take the data for attribute.
     */
    deserialize(ctx: Deserializer): void;
}

declare class Frustum {
    /**
     * Array of 6 {@link Plane| planes}.
     */
    planes: Plane[];
    /**
     * The eight vertex's position of frustum
     */
    corners: Vector3[];
    constructor(p0?: Plane, p1?: Plane, p2?: Plane, p3?: Plane, p4?: Plane, p5?: Plane);
    /**
     * Sets the frustum from the passed planes. No plane order is implied.
     * Note that this method only copies the values from the given objects.
     */
    set(p0: Plane, p1: Plane, p2: Plane, p3: Plane, p4: Plane, p5: Plane): Frustum;
    /**
     * Return a new Frustum with the same parameters as this one.
     */
    clone(): Frustum;
    /**
     * Copies the properties of the passed {@link Frustum| frustum} into this one.
     * @param frustum The frustum to copy.
     */
    copy(frustum: Frustum): Frustum;
    /**
     * Return the {@link corners| corners}.
     */
    getCorners(): Vector3[];
    /**
     * Sets the frustum by a transform matrix.
     */
    setFromMatrix(m: Matrix4): Frustum;
    /**
     * Checks whether the {@link Object3D| object}'s {@link BufferGeometry.boundingSphere| bounding} is intersecting the frustum.
     * Note that the object must have a {@link BufferGeometry| geometry} so that the bounding sphere can be calculated.
     */
    intersectsObject(object: Object3D): boolean;
    /**
     * Checks whether the {@link Sprite| sprite} is intersecting the frustum.
     */
    intersectsSprite(sprite: Sprite): boolean;
    /**
     * Return true if {@link Sphere| sphere} intersects with this frustum.
     * @param sphere {@link Sphere| Sphere} to check for intersection.
     */
    intersectsSphere(sphere: Sphere): boolean;
    /**
     * Return true if {@link Box3| box} intersects with this frustum.
     * @param box {@link Box3| Box3} to check for intersection.
     */
    intersectsBox(box: Box3): boolean;
    /**
     * Checks to see if the frustum contains the {@link Vector3| point}.
     * @param point {@link Vector3| Vector3} to test.
     */
    containsPoint(point: Vector3): boolean;
    /**
     * Return a value to represent the closest distance between camera and box, if there are any part of bos inside the frustum.
     */
    getCameraClosestDistanceFromBoxes(camera: PerspectiveCamera, boxes: Box3[]): number;
}

/**
 * Creates a 2d curve in the shape of an ellipse. Setting the xRadius equal to the yRadius will result in a circle.
 */
declare class EllipseCurve2D extends Curve2D {
    aX: number;
    aY: number;
    xRadius: number;
    yRadius: number;
    aStartAngle: number;
    aEndAngle: number;
    aClockwise: boolean;
    aRotation: number;
    isEllipseCurve2D: boolean;
    divisions?: number;
    /**
     * @param { number } aX The X center of the ellipse. Default is 0.
     * @param { number } aY The Y center of the ellipse. Default is 0.
     * @param { number } xRadius The radius of the ellipse in the x direction. Default is 1.
     * @param { number } yRadius The radius of the ellipse in the y direction. Default is 1.
     * @param { number } aStartAngle The start angle of the curve in radians starting from the positive X axis. Default is 0.
     * @param { number } aEndAngle The end angle of the curve in radians starting from the positive X axis. Default is 2 PI.
     * @param { number } aClockwise Whether the ellipse is drawn clockwise. Default is false.
     * @param { number } aRotation The rotation angle of the ellipse in radians, counterclockwise from the positive X axis (optional). Default is 0.
     * @param { number } divisions How many parts will each curve been seperated(Optional).
     */
    constructor(aX?: number, aY?: number, xRadius?: number, yRadius?: number, aStartAngle?: number, aEndAngle?: number, aClockwise?: boolean, aRotation?: number, divisions?: number);
    serialize(ctx: Serializer): void;
    deserialize(ctx: Deserializer): void;
    className(): string;
    getPoints(divisions?: number): Vector2[];
    getPoint(t: number, optionalTarget?: Vector2): Vector2;
    clone(): EllipseCurve2D;
    copy(source: EllipseCurve2D): this;
}

/**
 * Build a line from {@link v1 | v1 } to {@link v2 | v2 } in 2D space.
 */
declare class LineCurve2D extends Curve2D {
    isLineCurve2D: boolean;
    v1: Vector2;
    v2: Vector2;
    constructor(v1?: Vector2, v2?: Vector2);
    serialize(ctx: Serializer): void;
    deserialize(ctx: Deserializer): void;
    className(): string;
    getPoint(t: number, optionalTarget?: Vector2): Vector2;
    getPointAt(u: number, optionalTarget?: Vector2): Vector2;
    getPoints(divisions?: number): Vector2[];
    clone(): LineCurve2D;
    copy(source: LineCurve2D): this;
    toJSON(): any;
    fromJSON(json: any): this;
}

/**
 * Build spline curve by an array of controlling points.
 */
declare class SplineCurve2D extends Curve2D {
    points: Vector2[];
    isSplineCurve2D: boolean;
    constructor(points?: Vector2[]);
    serialize(ctx: Serializer): void;
    deserialize(ctx: Deserializer): void;
    className(): string;
    getPointAt(t: number, optionalTarget?: Vector2): Vector2;
    copy(source: SplineCurve2D): this;
    clone(): SplineCurve2D;
    toJSON(): any;
    fromJSON(json: any): this;
}

declare type FatLineMaterialParameter = ConvertMaterialParameters> & LineDashParam & ColorWithAlphaParam & MaterialParameters;
/**
 * This material is specifically used to draw line or dash-line which has width more than 1 pixel.
 */
declare class FatLineMaterial extends SceneClipMaterial {
    fallback: LineBasicMaterial;
    color: ColorWithAlpha;
    enableDash: boolean;
    dash: LineDash;
    fatLineWidth: number;
    enableViewIndependentDashScale: boolean;
    className(): string;
    generateShaderKey(r: ShaderComponentRegistry): string;
    constructor(p?: FatLineMaterialParameter);
    /**
     * This method will be used automatically before
     * @param {Renderer} renderer instance of renderer for engine.
     */
    onBeforeRender: (renderer: Renderer) => void;
    setValues(p?: FatLineMaterialParameter): void;
    updateShapeUniforms(program: WGLProgram, r: ShaderComponentRegistry): void;
    updateShadingUniforms(program: WGLProgram): void;
    extendShaderShading(builder: ShaderBuilder): void;
    computeShapeKey(r: ShaderComponentRegistry): string;
    extendShaderShape(builder: ShaderBuilder, registry: ShaderComponentRegistry): void;
    copy(other: FatLineMaterial): this;
    serialize(ctx: Serializer): void;
    deserialize(ctx: Deserializer): void;
    clone(): FatLineMaterial;
}

declare type PointsMaterialParameters = MaterialParameters & ColorWithAlphaParam & ConvertMaterialParameters>;
/**
 * This material is specified used to change performance of {@link Points | Points }
 */
declare class PointsMaterial extends Material {
    constructor(p?: PointsMaterialParameters);
    setValues(values?: PointsMaterialParameters): void;
    size: number;
    color: ColorWithAlpha;
    enableSizeAttenuation: boolean;
    enableVertexColor: boolean;
    className(): string;
    extendShaderShape(builder: ShaderBuilder, _: ShaderComponentRegistry): void;
    computeShapeKey(_: ShaderComponentRegistry): string;
    updateShapeUniforms(p: WGLProgram, _: ShaderComponentRegistry): void;
    extendShaderShading(b: ShaderBuilder, _: ShaderComponentRegistry): void;
    generateShaderKey(r: ShaderComponentRegistry): string;
    updateShadingUniforms(p: WGLProgram, _: ShaderComponentRegistry): void;
    copy(other: PointsMaterial): this;
    clone(): PointsMaterial;
    serialize(ctx: Serializer): void;
    deserialize(ctx: Deserializer): void;
}

/**
 * This class is used to draw lines which has same width between each vertexes of Geometry on the surfaces. 

 */
declare class FatLineSegments extends Drawable {
    /**
     * If require engine to draw this as Line instead of Mesh, set this to true.
     */
    static UseFallBack: boolean;
    /**
     * Check the type whether it belongs to FatLineSegments.
     * This value should not be changed by user.
     */
    isFatLineSegments: boolean;
    __isFatLineSegments: boolean;
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(geometry: FatLineBufferGeometry, material: FatLineMaterial);
    updateRenderEntity(): void;
    /**
     * Get intersections between a casted {@link Ray| ray} and this Mesh.
     * The method {@link Raycaster.intersectObject| intersectObject()} will call this method, but the results are not ordered.
     * @param {Raycaster} raycaster the instance of Raycaster is used to get the data for calculation.
     * @param {Intersection} intersects the result will be stored here.
     */
    raycastJsImpl(raycaster: Raycaster, intersects: Intersection[]): void;
    serialize(ctx: Serializer): void;
    deserialize(ctx: Deserializer): void;
}

/**
 * This class is used to draw all vertexes of geometry as a series of independent points.
 * It supports any type of geometry, but only PointsMaterial is supported.
 */
declare class Points extends Drawable> {
    className(): string;
    type: string;
    /**
     * Check the type whether it belongs to Points.
     */
    isPoints: boolean;
    /**
     * Decisive attribute to draw this object as continuous line.
     */
    drawMode: DrawMode;
    constructor(geometry?: BufferGeometry, material?: M | M[]);
    /**
     * Get intersections between a casted {@link Ray| ray} and this point,
     * all points whose distance from ray less than {@link Raycaster.pointThreshold| threshold} will be push into intersects.

     * The method {@link Raycaster.intersectObject| intersectObject()} will call this method.
     * @param {Raycaster} raycaster the instance of Raycaster is used to get the data for calculation.
     * @param {Intersection} intersects the result will be stored here.
     */
    raycastJsImpl(raycaster: Raycaster, intersects: Intersection[]): void;
    /**
     * Return a clone of this object.
     */
    clone(recursive?: boolean): Points;
}

/**
 * A light source positioned directly above the scene, with color fading from the sky color to the ground color.
 * This light cannot be used to cast shadows.
 */
declare class HemisphereLight extends Light {
    /**
     * Check the type whether it belongs to HemisphereLight.
     * This value should not be changed by user.
     */
    isHemisphereLight: boolean;
    /**
     * The light's ground color, as passed in the constructor. Default is a new Color set to white (0xffffff).
     */
    groundColor: Color;
    /**
     * The name of instance's class.
     */
    className(): string;
    constructor(skyColor?: number | string, groundColor?: number | string, intensity?: number);
    copy(source: HemisphereLight): this;
    /**
     * @ignore
     */
    deserialize(ctx: Deserializer): void;
    /**
     * @ignore
     */
    serialize(ctx: Serializer): void;
}

/**
 * All functions in this class is static and is used to recognize if an object belongs to certain class.
 * Every value as return is boolean variable.
 */
declare class TypeAssert {
    static isObject3D(o: any): o is Object3D;
    static isDrawable(o: any): o is Drawable;
    static isMaterial(m: any): m is Material;
    static isShaderComponent(c: any): c is ShaderComponent;
    static isArrayCamera(camera: any): camera is ArrayCamera;
    static isDeferredMaterial(m: Material): m is DeferredMaterial;
    static isPopBufferGeometry(geometry: any): geometry is PopBufferGeometry;
    static isBufferGeometry(geometry: any): geometry is BufferGeometry;
    static isInstancedBufferGeometry(geometry: any): geometry is InstancedBufferGeometry$1;
    static isFatlineBufferGeometry(geometry: any): geometry is FatLineBufferGeometry;
    /**
     * @internal
     */
    static isSpriteBufferGeometry(geometry: any): geometry is SpriteBufferGeometry;
    static isGeometry(geometry: any): geometry is Geometry;
    static isMesh(obj: any): obj is Mesh;
    static isPopMesh(obj: any): obj is PopMesh;
    static isSkinnedMesh(obj: any): obj is SkinnedMesh;
    static isLineLike(obj: any): obj is Line | LineSegments | FatLineSegments;
    static isFatLineSegmentsDecideByUser(object: any): object is FatLineSegments;
    static isFatLineSegments(object: any): object is FatLineSegments;
    static isLineSegments(object: any): object is LineSegments;
    static isLine(object: any): object is Line;
    static isPoints(object: any): object is Points;
    static isSplat(object: any): object is Splat;
    static isLight(obj: any): obj is Light;
    static isShadow(obj: any): obj is Shadow;
    static isSprite(obj: any): obj is Sprite;
    static isInstanceMesh(obj: any): obj is InstanceMesh;
    static isCamera3D(camera: any): camera is Camera3D;
    static isPerspectiveCamera(camera: Camera3D): camera is PerspectiveCamera;
    static isOrthographicCamera(camera: Camera3D): camera is OrthographicCamera;
    static isEllipseCurve2D(curve: Curve2D): curve is EllipseCurve2D;
    static isSplineCurve2D(curve: Curve2D): curve is SplineCurve2D;
    static isLineCurve2D(curve: Curve2D): curve is LineCurve2D;
    static isBufferAttribute(item: any): item is BufferAttribute;
    static isInstancedBufferAttribute(item: any): item is InstancedBufferAttribute;
    static isAmbientLight(value: any): value is AmbientLight;
    static isDirectionalLight(value: any): value is DirectionalLight;
    static isSpotLight(value: any): value is SpotLight;
    static isPointLight(value: any): value is PointLight;
    static isRectAreaLight(value: any): value is RectAreaLight;
    static isDiskAreaLight(value: any): value is DiskAreaLight;
    static isHemisphereLight(value: any): value is HemisphereLight;
    static isLightableMaterial(value: any): value is LightableMaterial;
    static isSpriteMaterial(value: any): value is SpriteMaterial$1;
    static isMeshBasicMaterial(value: any): value is MeshBasicMaterial$1;
    static isMeshPhongMaterial(value: any): value is MeshPhongMaterial$1;
    static isMergedMeshPhongMaterial(value: any): value is MergedMeshPhongMaterial;
    static isMeshDepthMaterial(value: any): value is MeshDepthMaterial;
    /**
     * @internal
     */
    static isRenderAttachment(value: any): value is RenderAttachment;
    /**
     * @internal
     */
    static isLegacySourceTexture(value: any): value is LegacySourceTexture;
    /**
     * @internal
     */
    static isSourceTexture(value: any): value is SourceTexture$1;
}

/**
 * Object for keeping track of time.
 */
declare class Clock {
    /**
     * If set, starts the clock automatically when the first update is called.
     * @DefaultValue is true.
     */
    autoStart: boolean;
    /**
     * Holds the time at which the clock's start method was last called.
     */
    startTime: number;
    /**
     * Holds the time at which the clock's {@link start| start}, {@link getElapsedTime| getElapsedTime} or {@link getDelta| getDelta} methods were last called.
     */
    oldTime: number;
    /**
     * Keeps track of the total time that the clock has been running.
     */
    elapsedTime: number;
    /**
     * Whether the clock is running or not.
     */
    running: boolean;
    constructor(autoStart?: boolean);
    /**
     * Starts clock.
     * Also sets the {@link startTime| startTime} and {@link oldTime| oldTime} to the current time, sets {@link elapsedTime| elapsedTime} to 0 and running to true.
     */
    start(): void;
    /**
     * Stops clock and sets {@link oldTime| oldTime} to the current time.
     */
    stop(): void;
    /**
     * Get the seconds passed since the clock started and sets {@link oldTime| oldTime} to the current time.
     * If {@link autoStart| autoStart} is true and the clock is not running, also starts the clock.
     */
    getElapsedTime(): number;
    /**
     * Get the seconds passed since the time {@link oldTime| oldTime} was set and sets oldTime to the current time.
     * If {@link autoStart| autoStart} is true and the clock is not running, also starts the clock.
     */
    getDelta(): number;
}

interface LightMaterialComponent {
    generateMaterialForLight(): string;
    RE_Direct?(): string;
    RE_IndirectDiffuse?(): string;
    RE_IndirectSpecular?(): string;
    RE_Direct_RectArea?(): string;
    RE_Direct_DiskArea?(): string;
}
declare class LightShaderComponent extends SharedShaderComponent {
    lights: Set;
    enabled_light: number;
    lightHashKeyPrevious: string;
    onlyDirectLight: boolean;
    activeLayers?: Layers;
    className(): string;
    pointLights: PointLight[];
    pointShadowLength: number;
    get hasPointShadow(): boolean;
    getNthShadowPointLight(n: number): PointLight;
    spotLights: SpotLight[];
    spotShadowLength: number;
    get hasSpotShadow(): boolean;
    getNthShadowSpotLight(n: number): SpotLight;
    directionalLights: DirectionalLight[];
    directionalShadowLength: number;
    get hasDirectionalShadow(): boolean;
    getNthShadowDirectionalLight(n: number): DirectionalLight;
    createShadowMetaInfo(): {
        directionalShadowCount: number;
        pointShadowCount: number;
        spotShadowCount: number;
    };
    rectAreaLights: RectAreaLight[];
    diskAreaLights: DiskAreaLight[];
    ambientLight: Nullable;
    hemiLights: HemisphereLight[];
    updateImpl(camera: Camera3D): boolean;
    lightAndShadowHashKey(): string;
    shadowHashKey(): string;
    get hasAnyShadow(): boolean;
    clear(): void;
    dispose(): void;
    setupOnlyLightSetForLaterRecollecting(lights: Set): void;
    collectDynamicForwardLightsByDrawable(drawable: Drawable): void;
    collectLights(lights: Set): void;
    collectLightImpl(): void;
    updateShadingUniforms(program: WGLProgram): void;
    updateShadowMapUniforms(program: WGLProgram): void;
    extendShaderShading(builder: ShaderBuilder): void;
    RE_Direct(_builder: ShaderBuilder, mat: LightMaterialComponent): string;
    RE_Direct_RectArea(_builder: ShaderBuilder, mat: LightMaterialComponent): string;
    RE_Direct_DiskArea(_builder: ShaderBuilder, mat: LightMaterialComponent): string;
    RE_IndirectDiffuse(builder: ShaderBuilder, mat: LightMaterialComponent): string;
    RE_IndirectSpecular(builder: ShaderBuilder, mat: LightMaterialComponent): string;
    buildLightCollector(builder: ShaderBuilder): string;
    copy(other: LightShaderComponent): LightShaderComponent;
    clone(): LightShaderComponent;
}

declare enum ShaderAttributeTypes {
    position = 0,
    normal = 1,
    uv = 2,
    lineDistance = 3,
    color = 4,
    joints = 5,
    weights = 6
}
declare enum ShaderVaryingTypes {
    fragUV = 0,
    fragNormal = 1,
    viewPosition = 2,
    worldPosition = 3,
    vertexColor = 4
}
declare enum ShaderInjectionTypes {
    position = 0,
    gl_Position = 1,
    gl_PointSize = 2,
    vary_any = 3,
    vary_normal = 4,
    vary_viewPosition = 5,
    vary_worldPosition = 6,
    vary_uv = 7,
    frag_normal = 8,
    discard = 9,
    channel_color = 10,
    channel_alpha = 11,
    channel_ao = 12,
    channel_lightMap = 13,
    channel_specular = 14,
    channel_metalness = 15,
    channel_roughness = 16,
    channel_specularStrength = 17,
    channel_shininess = 18,
    gl_FragColor = 19,
    gl_FragColorModify = 20,
    gl_FragDepthEXT = 21,
    frag_any = 22
}
declare enum ShaderExtensionTypes {
    derivatives = 0,
    GL_EXT_shader_texture_lod = 1,
    GL_EXT_frag_depth = 2
}

declare enum FragOutType {
    Float = "float",
    Vec2 = "vec2",
    Vec3 = "vec3",
    Vec4 = "vec4",
    UInt = "uint",
    UVec4 = "uvec4"
}
interface FragOut {
    name: string;
    type: FragOutType;
}
declare class ShaderBuilder {
    lightComponent: Nullable;
    private extensions;
    private isInstanceMeshEnabled;
    private fragDefines;
    private postShaderStrProc;
    private components;
    private componentsMap;
    private attributes;
    private attributesCustom;
    private instanceAttributes;
    private vertexes;
    private vertexesCustom;
    private globalUniforms;
    private uniforms;
    private uniformArrays;
    private varyings;
    private varyingsCustom;
    private varyingsCustomArray;
    private fragOut;
    private fragments;
    private fragmentsCustom;
    private injections;
    private uniformBlocks;
    addDefaultFragColor: boolean;
    flatShadingNormal: boolean;
    static spawn(): ShaderBuilder;
    constructor();
    setFragOutputChannel(fragOut: FragOut[]): this;
    addNewFragOutputChannel(name: string, type?: FragOutType): this;
    addUBO(ubo: UniformBlockObject): this;
    addExtension(re: ShaderExtensionTypes): this;
    addLight(l: LightMaterialComponent): this;
    hasComponent(name: string): boolean;
    getComponent(name: string): ShaderComponent | undefined;
    extend(sc: ShaderComponent | null): this;
    addInstanceAttribute(name: string, type: WebGLShaderDataType): this;
    addCustomAttribute(name: string, type: WebGLShaderDataType): this;
    addDefaultAttribute(att: ShaderAttributeTypes): this;
    generateAttributes(): ShaderInputDescriptor[];
    private getVertexesString;
    addVertex(lib: ShaderBlock): this;
    addVertexCustom(lib: string): this;
    private getFragmentsString;
    addFragmentCustom(s: string): this;
    addFragment(lib: ShaderBlock): this;
    addUniform(name: string, type: WebGLShaderDataType): this;
    addUniformArray(name: string, type: WebGLShaderDataType, length: number): this;
    addUniformStruct(_name: string, _value: any): this;
    addUniformStructArray(_name: string, _value: any, _length: number): this;
    addGlobalUniform(g: BuiltInUniformTypes): this;
    private generateGlobalUniforms;
    addVaryingCustomArray(name: string, type: WebGLShaderDataType, length: number): this;
    addVaryingCustom(name: string, type: WebGLShaderDataType): this;
    addVarying(v: ShaderVaryingTypes): this;
    private expandVaryingSupport;
    private generateVaryings;
    addFragDefine(de: string): this;
    private getInjectionString;
    when(prediction: boolean, c: (builder: ShaderBuilder) => ShaderBuilder): ShaderBuilder;
    inject(point: ShaderInjectionTypes, shader: string): this;
    useCamera(useInstance?: boolean): this;
    useComponent(sc: ShaderComponent): void;
    addShaderStrProcess(f: (input: string) => string): this;
    private processPostShaderString;
    private getFragOutShaderHeader;
    build(): ShaderInfo;
}

declare const events_d_SplatRenderingStabilityChangedEvent: typeof SplatRenderingStabilityChangedEvent;
declare const events_d_SplatSortedEvent: typeof SplatSortedEvent;
declare namespace events_d {
  export {
    events_d_SplatRenderingStabilityChangedEvent as SplatRenderingStabilityChangedEvent,
    events_d_SplatSortedEvent as SplatSortedEvent,
  };
}

declare type TypedArray$2 = Float32Array | Float64Array | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array;
declare enum Loop {
    Once = 2200,
    Repeat = 2201,
    PingPong = 2202
}
declare enum InterpolationMode {
    Discrete = 2300,
    Linear = 2301,
    Smooth = 2302
}
interface KeyframeTrack {
    path: string;
    times: TypedArray$2;
    values: TypedArray$2;
    interpolation: InterpolationMode;
}
declare enum Blend {
    Normal = 2500,
    Additive = 2501
}
interface AnimationClip {
    name: string;
    blend?: Blend;
    tracks: KeyframeTrack[];
}

declare const SupportedScopeNames: readonly ["Materials"];
declare const SupportedObjectNames: readonly ["materials"];
declare const SupportedPropertyNames: readonly ["translation", "rotation", "scale", "uvRotation", "uvOffset", "uvScale"];
interface TrackPath {
    scope?: typeof SupportedScopeNames[number];
    nodeName?: string;
    objectName?: typeof SupportedObjectNames[number];
    objectIndex?: string;
    propertyName: typeof SupportedPropertyNames[number];
    propertyIndex?: string;
}

declare class PropertyMixer {
    readonly buffer: number[];
    private stride;
    private cumulativeWeight;
    private cumulativeWeightAdditive;
    private mixer;
    constructor(target: Object3D | Material, property: TrackPath['propertyName'], stride: number);
    update(blend: Blend, weight: number, accuIndex: number): void;
    apply(accuIndex: number): void;
}

interface ActionCtx {
    propertyMixerMap: Map;
    materialSet: Set;
}
declare const AnimationFinishEvent: EventType<{
    action: AnimationAction;
}>;
/**
 * An instance schedules the playback of an animation stored in {@link AnimationClip}
 */
declare class AnimationAction {
    static createId(root: Object3D, clip: AnimationClip): string;
    /**
     * Action id = `root.uuid@clip.name`
     */
    readonly id: string;
    /**
     * Name from {@link AnimationClip}
     */
    readonly name: string;
    /**
     * If set to `true`, the action is played. It will be automatically set to `false` when animation stops.
     */
    active: boolean;
    /**
     * If set to `true`, the playback of the action is paused.
     */
    paused: boolean;
    /**
     * If set to `true`, the animation will be paused on its last frame.
     * If set to `false`, the animation target will be reset to original state at the end.
     */
    pauseWhenFinished: boolean;
    /**
     * The degree of influence of this action for blending with other actions
     */
    weight: number;
    /**
     * Weight factor for time, which can be set to negative.
     */
    speed: number;
    /**
     * local time for this action
     */
    time: number;
    private duration;
    private blend;
    private interpolants;
    private mixers;
    private animationMixer;
    /**
     * Return max time
     */
    get timeDuration(): number;
    constructor(root: Object3D, clip: AnimationClip, ctx: ActionCtx, mixer: AnimationMixer);
    private loop;
    private loopCounts;
    private repetitions;
    /**
     * Configures the loop settings for this action
     * @param mode {@link Loop} mode
     * @param repetitions number of repetitions
     * @returns
     */
    setLoop(mode: Loop, repetitions: number): this;
    /**
     * Reset action
     * @returns
     */
    reset(): this;
    update(deltaTime: number, accuIndex: number): void;
    private updateTime;
}

/**
 * The class is a player for animations on a particular object called root
 */
declare class AnimationMixer extends EventDispatcher {
    private root;
    private actions;
    private propertyMixerMap;
    private materialSet;
    private accuIndex;
    private useCache;
    /**
     * Constructor
     * @param root animation target.
     * @param useCache optional, default is true. By default, animationAction will be cached with root id and name when clipAction.
     */
    constructor(root: Object3D, useCache?: boolean);
    /**
     * Generating {@link AnimationAction} from {@link AnimationClip}.
     * Calling With the same clip name and root, it will always return the same action instance.
     * @param clip
     * @param root optional, default is the root of {@link AnimationMixer}.
     * It is used for searching animation target.
     * @returns
     */
    clipAction(clip: AnimationClip, root?: Object3D): AnimationAction;
    /**
     * Advance the mixer time and update animation
     * @param deltaTime delta time in seconds
     */
    update(deltaTime: number): void;
    /**
     * Set the mixer to a specific time and update animation
     * @param time time in seconds
     */
    setTime(time: number): void;
    private apply;
}

/**
 * A special class used by {@link SkinnedMesh} containing an array of bones.
 */
declare class Skeleton {
    private bones;
    private boneInverses;
    private boneMatrices;
    private boneTexture;
    private needUpdate;
    get texture(): Texture2D;
    get rootBone(): Object3D;
    constructor(bones: Object3D[], boneInverses: Matrix4[]);
    private onBoneUpdate;
    /**
     * Update animation and sync bone matrix texture
     */
    update(isWASM?: boolean): boolean;
}

import ViewerPlugin = ViewerPlugin$1;
declare const SkeletonUpdatedEvent: EventType;
/**
 * A special viewer plugin responsible for animation and skeleton updating.
 */
declare class AnimationPlugin implements ViewerPlugin {
    readonly clock: Clock;
    private mixerList;
    private skeletonMap;
    private viewer;
    init(): void;
    destroy(): void;
    beforeRendering(): void;
    afterRendering(): void;
    /**
     * Register this animation plugin to the viewer.
     * @param viewer Viewer or IViewerContext
     */
    registerToViewer(viewer: IViewerContext | Viewer): void;
    /**
     * Register {@link AnimationMixer} into the plugin, then the animation will be updated along with rendering
     * @param mixer
     */
    add(mixer: AnimationMixer): void;
    /**
     * Unregister {@link AnimationMixer}
     * @param mixer
     */
    remove(mixer: AnimationMixer): void;
    /**
     * Bind {@link SkinnedMesh} with skeleton and register in animation plugin, then the skeletal animation will be update along with skeleton change.
     * After binding, the {@link SkinnedMesh} can be considered as {@link ISkinnedMesh}
     * @param mesh
     * @param skeleton {@link Skeleton} to be bound
     * @param mixer {@link AnimationMixer} to be bound to listen for events
     */
    bindSkinned(mesh: SkinnedMesh, skeleton: Skeleton, mixer: AnimationMixer): void;
    /**
     * Unbind {@link SkinnedMesh}
     * @param mesh
     */
    unbindSkinned(mesh: SkinnedMesh): void;
}

type animation_d_AnimationAction = AnimationAction;
declare const animation_d_AnimationAction: typeof AnimationAction;
type animation_d_AnimationClip = AnimationClip;
declare const animation_d_AnimationFinishEvent: typeof AnimationFinishEvent;
type animation_d_AnimationMixer = AnimationMixer;
declare const animation_d_AnimationMixer: typeof AnimationMixer;
type animation_d_AnimationPlugin = AnimationPlugin;
declare const animation_d_AnimationPlugin: typeof AnimationPlugin;
type animation_d_Blend = Blend;
declare const animation_d_Blend: typeof Blend;
type animation_d_InterpolationMode = InterpolationMode;
declare const animation_d_InterpolationMode: typeof InterpolationMode;
type animation_d_KeyframeTrack = KeyframeTrack;
type animation_d_Loop = Loop;
declare const animation_d_Loop: typeof Loop;
type animation_d_Skeleton = Skeleton;
declare const animation_d_Skeleton: typeof Skeleton;
declare const animation_d_SkeletonUpdatedEvent: typeof SkeletonUpdatedEvent;
declare namespace animation_d {
  export { animation_d_AnimationAction as AnimationAction, animation_d_AnimationFinishEvent as AnimationFinishEvent, animation_d_AnimationMixer as AnimationMixer, animation_d_AnimationPlugin as AnimationPlugin, animation_d_Blend as Blend, animation_d_InterpolationMode as InterpolationMode, animation_d_Loop as Loop, animation_d_Skeleton as Skeleton, animation_d_SkeletonUpdatedEvent as SkeletonUpdatedEvent };
  export type { animation_d_AnimationClip as AnimationClip, animation_d_KeyframeTrack as KeyframeTrack };
}

declare enum SplatFileType {
    PLY = 0,
    SPZ = 1,
    SPLAT = 2,
    KSPLAT = 3,
    SOG = 4,
    LCC = 5
}
declare enum SplatPackType {
    Raw = 0,
    Compressed = 1,
    SuperCompressed = 2,
    Sog = 3
}
declare function detectSplatFileType(filename: string, buffer: Uint8Array): SplatFileType | undefined;

declare enum ISamplerFormat {
    RG_UINT = 0,
    RGBA_UINT = 1
}
interface ISampler$1 {
    width: number;
    height: number;
    depth: number;
    format: ISamplerFormat;
    source: Uint8Array;
}
interface ISplatData {
    counts: number;
    shDegree: number;
    samplers: ISampler$1[];
    extras?: any[];
}
interface ISingleSplat$1 {
    x: number;
    y: number;
    z: number;
    sx: number;
    sy: number;
    sz: number;
    qx: number;
    qy: number;
    qz: number;
    qw: number;
    r: number;
    g: number;
    b: number;
    a: number;
}

interface ParseExtras {
    maxShDegree: number;
    maxTextureSize: number;
}

declare abstract class SplatData {
    readonly counts: number;
    readonly shDegree: number;
    readonly maxShDegree: number;
    readonly maxTextureSize: number;
    private blockCounts;
    constructor(maxShDegree?: number, maxTextureSize?: number, blockCounts?: number);
    private totalBlockCounts;
    private totalBlockShDegree;
    private blockOffsets;
    private blockExecs;
    private currentBlockIndex;
    initBlock(counts: number, shDegree: number): Promise;
    finishBlock(): void;
    abstract init(counts: number, shDegree: number): void;
    abstract set(i: number, single: ISingleSplat$1): void;
    abstract setCenter(i: number, x: number, y: number, z: number): void;
    abstract setScale(i: number, sx: number, sy: number, sz: number): void;
    abstract setQuat(i: number, qx: number, qy: number, qz: number, qw: number): void;
    abstract setColor(i: number, r: number, g: number, b: number): void;
    abstract setAlpha(i: number, a: number): void;
    abstract setShN(i: number, shN: number[]): void;
    abstract get(i: number, single: ISingleSplat$1): void;
    abstract getCenter(i: number, single: ISingleSplat$1): void;
    abstract getScale(i: number, single: ISingleSplat$1): void;
    abstract getQuat(i: number, single: ISingleSplat$1): void;
    abstract getColor(i: number, single: ISingleSplat$1): void;
    abstract getAlpha(i: number, single: ISingleSplat$1): void;
    abstract getShN(i: number, shN: number[]): void;
    abstract fillCenters(centers: Float32Array): void;
    abstract serialize(): ISplatData;
    abstract deserialize(data: ISplatData): void;
}

declare class RawSplatData extends SplatData {
    counts: number;
    shDegree: number;
    private shCounts;
    private table;
    init(counts: number, shDegree: number): void;
    set(i: number, single: ISingleSplat$1): void;
    setCenter(i: number, x: number, y: number, z: number): void;
    setScale(i: number, sx: number, sy: number, sz: number): void;
    setQuat(i: number, qx: number, qy: number, qz: number, qw: number): void;
    setColor(i: number, r: number, g: number, b: number): void;
    setAlpha(i: number, a: number): void;
    setShN(i: number, shN: number[]): void;
    get(i: number, single: ISingleSplat$1): void;
    getCenter(i: number, single: ISingleSplat$1): void;
    getScale(i: number, single: ISingleSplat$1): void;
    getQuat(i: number, single: ISingleSplat$1): void;
    getColor(i: number, single: ISingleSplat$1): void;
    getAlpha(i: number, single: ISingleSplat$1): void;
    getShN(i: number, shN: number[]): void;
    fillCenters(centers: Float32Array): void;
    serialize(): ISplatData;
    deserialize(data: ISplatData): void;
}

declare class CompressedSplatData extends SplatData {
    counts: number;
    shDegree: number;
    private splat1Sampler;
    private splat1Float32Buffer;
    private splat1Uint16Buffer;
    private splat2Sampler;
    private splat2Uint16Buffer;
    private splat2Uint32Buffer;
    private sh1Sampler;
    private sh1Uint32Buffer;
    private sh2Sampler;
    private sh2Uint32Buffer;
    private sh3Sampler;
    private sh3Uint32Buffer;
    private sh4Sampler;
    private sh4Uint32Buffer;
    init(counts: number, shDegree: number): void;
    set(i: number, single: ISingleSplat$1): void;
    setCenter(i: number, x: number, y: number, z: number): void;
    setScale(i: number, sx: number, sy: number, sz: number): void;
    setQuat(i: number, qx: number, qy: number, qz: number, qw: number): void;
    setColor(i: number, r: number, g: number, b: number): void;
    setAlpha(i: number, a: number): void;
    setShN(i: number, shN: number[]): void;
    get(i: number, single: ISingleSplat$1): void;
    getCenter(i: number, single: ISingleSplat$1): void;
    getScale(i: number, single: ISingleSplat$1): void;
    getQuat(i: number, single: ISingleSplat$1): void;
    getColor(i: number, single: ISingleSplat$1): void;
    getAlpha(i: number, single: ISingleSplat$1): void;
    getShN(i: number, shN: number[]): void;
    fillCenters(centers: Float32Array): void;
    serialize(): ISplatData;
    deserialize(data: ISplatData): void;
}

declare class SuperCompressedSplatData extends SplatData {
    counts: number;
    shDegree: number;
    private splatSampler;
    private splatUint8Buffer;
    private splatUint16Buffer;
    private sh1Sampler;
    private sh1Uint8Buffer;
    private sh1Uint32Buffer;
    private sh2Sampler;
    private sh2Uint8Buffer;
    init(counts: number, shDegree: number): void;
    set(i: number, single: ISingleSplat$1): void;
    setCenter(i: number, x: number, y: number, z: number): void;
    setScale(i: number, sx: number, sy: number, sz: number): void;
    setQuat(i: number, qx: number, qy: number, qz: number, qw: number): void;
    setColor(i: number, r: number, g: number, b: number): void;
    setAlpha(i: number, a: number): void;
    setShN(i: number, shN: number[]): void;
    get(i: number, single: ISingleSplat$1): void;
    getCenter(i: number, single: ISingleSplat$1): void;
    getScale(i: number, single: ISingleSplat$1): void;
    getQuat(i: number, single: ISingleSplat$1): void;
    getColor(i: number, single: ISingleSplat$1): void;
    getAlpha(i: number, single: ISingleSplat$1): void;
    getShN(i: number, shN: number[]): void;
    fillCenters(centers: Float32Array): void;
    serialize(): ISplatData;
    deserialize(data: ISplatData): void;
}

declare type SogMetadata$1 = {
    counts: number;
    shDegree: number;
    means: {
        mins: [number, number, number];
        maxs: [number, number, number];
    };
} & ({
    version: 1;
    scales: {
        mins: [number, number, number];
        maxs: [number, number, number];
    };
    sh0: {
        mins: [number, number, number, number];
        maxs: [number, number, number, number];
    };
    shN?: {
        mins: number;
        maxs: number;
    };
} | {
    version: 2;
    scales: {
        codebook: number[];
    };
    sh0: {
        codebook: number[];
    };
    shN?: {
        codebook: number[];
    };
});
declare class SogSplatData extends SplatData {
    counts: number;
    shDegree: number;
    private meta;
    private meansL;
    private meansU;
    private quats;
    private scales;
    private colors;
    private shNLabels?;
    private shNCentroids?;
    init(_counts: number, _shDegree: number): void;
    load(meta: SogMetadata$1, meansL: Uint8Array, meansU: Uint8Array, quats: Uint8Array, scales: Uint8Array, colors: Uint8Array, shNLabels?: Uint8Array, shNCentroids?: Uint8Array): void;
    set(_i: number, _single: ISingleSplat$1): void;
    setCenter(_i: number, _x: number, _y: number, _z: number): void;
    setScale(_i: number, _sx: number, _sy: number, _sz: number): void;
    setQuat(_i: number, _qx: number, _qy: number, _qz: number, _qw: number): void;
    setColor(_i: number, _r: number, _g: number, _b: number): void;
    setAlpha(_i: number, _a: number): void;
    setShN(_i: number, _shN: number[]): void;
    get(_i: number, _single: ISingleSplat$1): void;
    getCenter(_i: number, _single: ISingleSplat$1): void;
    getScale(_i: number, _single: ISingleSplat$1): void;
    getQuat(_i: number, _single: ISingleSplat$1): void;
    getColor(_i: number, _single: ISingleSplat$1): void;
    getAlpha(_i: number, _single: ISingleSplat$1): void;
    getShN(_i: number, _shN: number[]): void;
    fillCenters(_centers: Float32Array): void;
    serialize(): ISplatData;
    deserialize(data: ISplatData): void;
}

interface ISingleSplat {
    x: number;
    y: number;
    z: number;
    sx: number;
    sy: number;
    sz: number;
    qx: number;
    qy: number;
    qz: number;
    qw: number;
    r: number;
    g: number;
    b: number;
    a: number;
    shN: number[];
}
interface IData {
    readonly counts: number;
    readonly shDegree: number;
    initBlock(counts: number, shDegree: number): Promise;
    finishBlock(): void;
    set(i: number, single: Omit): void;
    setCenter(i: number, x: number, y: number, z: number): void;
    setScale(i: number, sx: number, sy: number, sz: number): void;
    setQuat(i: number, qx: number, qy: number, qz: number, qw: number): void;
    setColor(i: number, r: number, g: number, b: number): void;
    setAlpha(i: number, a: number): void;
    setShN(i: number, shN: number[]): void;
    get(i: number, single: ISingleSplat): void;
    getCenter(i: number, single: ISingleSplat): void;
    getScale(i: number, single: ISingleSplat): void;
    getQuat(i: number, single: ISingleSplat): void;
    getColor(i: number, single: ISingleSplat): void;
    getAlpha(i: number, single: ISingleSplat): void;
    getShN(i: number, out: number[]): void;
}
interface IFile {
    read(stream: ReadableStream, contentLength: number, data: IData): Promise;
    write(stream: WritableStream, data: IData): Promise;
}

declare class KsplatFile implements IFile {
    private counts;
    private shDegree;
    private header;
    private sections;
    private buffer;
    private load;
    read(stream: ReadableStream, contentLength: number, data: IData): Promise;
    write(_stream: WritableStream, _data: IData): Promise;
}

declare class PlyFile implements IFile {
    private littleEndian;
    private comments;
    private elements;
    private isSuperSplatCompressed;
    private counts;
    private shDegree;
    private initHeader;
    read(stream: ReadableStream, _contentLength: number, data: IData): Promise;
    write(stream: WritableStream, data: IData): Promise;
}

interface SogMetadataV1 {
    version: undefined;
    means: {
        shape: number[];
        dtype: string;
        mins: number[];
        maxs: number[];
        files: string[];
    };
    scales: {
        shape: number[];
        dtype: string;
        mins: number[];
        maxs: number[];
        files: string[];
    };
    quats: {
        shape: number[];
        dtype: string;
        encoding?: string;
        files: string[];
    };
    sh0: {
        shape: number[];
        dtype: string;
        mins: number[];
        maxs: number[];
        files: string[];
    };
    shN?: {
        shape: number[];
        dtype: string;
        mins: number;
        maxs: number;
        quantization: number;
        files: string[];
    };
}
interface SogMetadataV2 {
    version: number;
    count: number;
    means: {
        mins: number[];
        maxs: number[];
        files: string[];
    };
    scales: {
        codebook: number[];
        files: string[];
    };
    quats: {
        files: string[];
    };
    sh0: {
        codebook: number[];
        files: string[];
    };
    shN?: {
        count: number;
        bands: number;
        codebook: number[];
        files: string[];
    };
}
declare type SogMetadata = SogMetadataV1 | SogMetadataV2;
declare class SogFile implements IFile {
    private counts;
    private shDegree;
    /**
     * @internal
     */
    version: number;
    /**
     * @internal
     */
    meta: SogMetadata;
    /**
     * @internal
     */
    refs: Record;
    private cached;
    load(stream: ReadableStream, contentLength: number): Promise;
    private parse_v1;
    private parse_v2;
    private loadTexture;
    read(stream: ReadableStream, contentLength: number, data: IData): Promise;
    write(_stream: WritableStream, _data: IData): Promise;
}

declare class SplatFile implements IFile {
    read(stream: ReadableStream, contentLength: number, data: IData): Promise;
    write(stream: WritableStream, data: IData): Promise;
}

declare class SpzFile implements IFile {
    read(stream: ReadableStream, _contentLength: number, data: IData): Promise;
    write(writeStream: WritableStream, data: IData): Promise;
}

declare class LccFile implements IFile {
    private counts;
    private shDegree;
    private meta;
    private refs;
    private load;
    read(stream: ReadableStream, contentLength: number, data: IData): Promise;
    write(_stream: WritableStream, _data: IData): Promise;
}

declare function parseSplatData(type: SplatFileType, input: Uint8Array | string | File | {
    stream: ReadableStream;
    contentLength: number;
}, packType?: SplatPackType, extras?: Partial): Promise;

type splatLoader_d_CompressedSplatData = CompressedSplatData;
declare const splatLoader_d_CompressedSplatData: typeof CompressedSplatData;
type splatLoader_d_IFile = IFile;
type splatLoader_d_ISamplerFormat = ISamplerFormat;
declare const splatLoader_d_ISamplerFormat: typeof ISamplerFormat;
type splatLoader_d_KsplatFile = KsplatFile;
declare const splatLoader_d_KsplatFile: typeof KsplatFile;
type splatLoader_d_LccFile = LccFile;
declare const splatLoader_d_LccFile: typeof LccFile;
type splatLoader_d_PlyFile = PlyFile;
declare const splatLoader_d_PlyFile: typeof PlyFile;
type splatLoader_d_RawSplatData = RawSplatData;
declare const splatLoader_d_RawSplatData: typeof RawSplatData;
type splatLoader_d_SogFile = SogFile;
declare const splatLoader_d_SogFile: typeof SogFile;
type splatLoader_d_SogSplatData = SogSplatData;
declare const splatLoader_d_SogSplatData: typeof SogSplatData;
type splatLoader_d_SplatData = SplatData;
declare const splatLoader_d_SplatData: typeof SplatData;
type splatLoader_d_SplatFile = SplatFile;
declare const splatLoader_d_SplatFile: typeof SplatFile;
type splatLoader_d_SplatFileType = SplatFileType;
declare const splatLoader_d_SplatFileType: typeof SplatFileType;
type splatLoader_d_SplatPackType = SplatPackType;
declare const splatLoader_d_SplatPackType: typeof SplatPackType;
type splatLoader_d_SpzFile = SpzFile;
declare const splatLoader_d_SpzFile: typeof SpzFile;
type splatLoader_d_SuperCompressedSplatData = SuperCompressedSplatData;
declare const splatLoader_d_SuperCompressedSplatData: typeof SuperCompressedSplatData;
declare const splatLoader_d_detectSplatFileType: typeof detectSplatFileType;
declare const splatLoader_d_parseSplatData: typeof parseSplatData;
declare namespace splatLoader_d {
  export { splatLoader_d_CompressedSplatData as CompressedSplatData, splatLoader_d_ISamplerFormat as ISamplerFormat, splatLoader_d_KsplatFile as KsplatFile, splatLoader_d_LccFile as LccFile, splatLoader_d_PlyFile as PlyFile, splatLoader_d_RawSplatData as RawSplatData, splatLoader_d_SogFile as SogFile, splatLoader_d_SogSplatData as SogSplatData, splatLoader_d_SplatData as SplatData, splatLoader_d_SplatFile as SplatFile, splatLoader_d_SplatFileType as SplatFileType, splatLoader_d_SplatPackType as SplatPackType, splatLoader_d_SpzFile as SpzFile, splatLoader_d_SuperCompressedSplatData as SuperCompressedSplatData, splatLoader_d_detectSplatFileType as detectSplatFileType, splatLoader_d_parseSplatData as parseSplatData };
  export type { splatLoader_d_IFile as IFile, ISampler$1 as ISampler, ISingleSplat$1 as ISingleSplat };
}

type TypedArray$1 = Float32Array | Uint32Array | Uint16Array | Uint8Array | Int32Array | Int16Array | Int8Array;

interface IAttribute {
    array: T;
    itemSize: number;
}
interface IGroup {
    start: number;
    count: number;
    materialIndex: number;
    block: {
        name: string;
        index: number;
    };
}
interface IDracoGeometry {
    isPointCloud: boolean;
    index?: IAttribute;
    position: IAttribute;
    normal?: IAttribute;
    uv?: IAttribute;
    color?: IAttribute;
    groups: IGroup[];
}
interface ParseConfig {
    enableParseMesh: boolean;
    enableParsePointCloud: boolean;
}
declare function parseDracoBuffer(buffer: ArrayBuffer, config?: Partial): Promise;

type dracoLoader_d_ParseConfig = ParseConfig;
declare const dracoLoader_d_parseDracoBuffer: typeof parseDracoBuffer;
declare namespace dracoLoader_d {
  export { dracoLoader_d_parseDracoBuffer as parseDracoBuffer };
  export type { dracoLoader_d_ParseConfig as ParseConfig };
}

declare type TypedArray = Float32Array | Float64Array | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array;
interface IBase {
    extensions?: Record;
    extras?: any;
}
interface IAsset extends IBase {
    copyright?: string;
    generator?: string;
    version: string;
    minVersion?: string;
}
interface IScene extends IBase {
    nodes?: number[];
    name?: string;
}
interface INode extends IBase {
    name?: string;
    children?: number[];
    matrix?: number[];
    translation?: [number, number, number];
    rotation?: [number, number, number, number];
    scale?: [number, number, number];
    mesh?: number;
    skin?: number;
    weights?: number[];
    camera?: number;
}
interface IMesh extends IBase {
    name?: string;
    primitives: IPrimitive[];
    weights?: number[];
}
interface IPrimitive extends IBase {
    attributes: Record;
    indices?: number;
    material?: number;
    targets?: Array<{
        [semantic: string]: number;
    }>;
    mode?: PrimitiveMode;
}
declare enum PrimitiveMode {
    POINTS = 0,
    LINES = 1,
    LINE_LOOP = 2,
    LINE_STRIP = 3,
    TRIANGLES = 4,
    TRIANGLE_STRIP = 5,
    TRIANGLE_FAN = 6
}
declare enum ALPHA_MODES {
    OPAQUE = "OPAQUE",
    MASK = "MASK",
    BLEND = "BLEND"
}
interface IMaterial extends IBase {
    name?: string;
    pbrMetallicRoughness?: PBRMetallicRoughness;
    normalTexture?: INormalTextureInfo;
    occlusionTexture?: IOcclusionTextureInfo;
    emissiveTexture?: ITextureInfo;
    emissiveFactor?: [number, number, number];
    alphaMode?: ALPHA_MODES;
    alphaCutoff?: number;
    doubleSided?: boolean;
}
interface PBRMetallicRoughness extends IBase {
    baseColorFactor?: [number, number, number, number];
    baseColorTexture?: ITextureInfo;
    metallicFactor?: number;
    roughnessFactor?: number;
    metallicRoughnessTexture?: ITextureInfo;
}
interface ITextureInfo extends IBase {
    index: number;
    texCoord?: number;
}
interface INormalTextureInfo extends ITextureInfo {
    scale?: number;
}
interface IOcclusionTextureInfo extends ITextureInfo {
    strength?: number;
}
interface ITexture extends IBase {
    name?: string;
    source?: number;
    sampler?: number;
}
interface ISampler extends IBase {
    name?: string;
    magFilter?: GLTFTextureMagFilter;
    minFilter?: GLTFTextureMinFilter;
    wrapS?: GLTFWrapMode;
    wrapT?: GLTFWrapMode;
}
declare type GLTFWrapMode = 33071 | 33648 | 10497;
declare type GLTFTextureMagFilter = 9728 | 9729;
declare type GLTFTextureMinFilter = 9728 | 9729 | 9984 | 9985 | 9986 | 9987;
interface IImage extends IBase {
    name?: string;
    uri?: string;
    mimeType?: 'image/jpeg' | 'image/png';
    bufferView?: number;
}
declare type IAccessorType = 'SCALAR' | 'VEC2' | 'VEC3' | 'VEC4' | 'MAT2' | 'MAT3' | 'MAT4';
declare enum AccessorComponentType {
    BYTE = 5120,
    UNSIGNED_BYTE = 5121,
    SHORT = 5122,
    UNSIGNED_SHORT = 5123,
    UNSIGNED_INT = 5125,
    FLOAT = 5126
}
interface IAccessor extends IBase {
    bufferView?: number;
    byteOffset?: number;
    componentType: AccessorComponentType;
    normalized?: boolean;
    count: number;
    type: IAccessorType;
    max?: number[];
    min?: number[];
    sparse?: any;
}
interface IBufferView extends IBase {
    buffer: number;
    byteOffset?: number;
    byteLength: number;
    byteStride?: number;
    target?: IBufferViewTarget;
}
declare enum IBufferViewTarget {
    ARRAY_BUFFER = 34962,
    ELEMENT_ARRAY_BUFFER = 34963
}
interface IBuffer extends IBase {
    uri?: string;
    byteLength: number;
}
interface IAnimation extends IBase {
    name?: string;
    channels: IAnimationChannel[];
    samplers: IAnimationSampler[];
}
interface IAnimationChannel extends IBase {
    sampler: number;
    target: IAnimationChannelTarget;
}
interface IAnimationChannelTarget extends IBase {
    node?: number;
    path: 'translation' | 'rotation' | 'scale' | 'weights' | 'pointer';
}
interface IAnimationSampler extends IBase {
    input: number;
    output: number;
    interpolation?: 'LINEAR' | 'STEP' | 'CUBICSPLINE';
}
interface ISkin extends IBase {
    name?: string;
    inverseBindMatrices?: number;
    skeleton?: number;
    joints: number[];
}
interface ICamera extends IBase {
    name?: string;
    type: 'perspective' | 'orthographic';
    perspective?: IPerspectiveCamera;
    orthographic?: IOrthographicCamera;
}
interface IPerspectiveCamera extends IBase {
    aspectRatio?: number;
    yfov: number;
    zfar?: number;
    znear: number;
}
interface IOrthographicCamera extends IBase {
    xmag: number;
    ymag: number;
    zfar: number;
    znear: number;
}
interface GLTF extends IBase {
    asset: IAsset;
    scene?: number;
    scenes?: IScene[];
    nodes?: INode[];
    meshes?: IMesh[];
    accessors?: IAccessor[];
    bufferViews?: IBufferView[];
    buffers?: IBuffer[];
    materials?: IMaterial[];
    textures?: ITexture[];
    images?: IImage[];
    samplers?: ISampler[];
    animations?: IAnimation[];
    skins?: ISkin[];
    cameras?: ICamera[];
    extensionsUsed?: string[];
    extensionsRequired?: string[];
}
interface ISkeleton {
    bones: Object3D[];
    inverseBindMatrices: Matrix4[];
}
interface AnimationTrack {
    path: string;
    times: TypedArray;
    values: TypedArray;
    interpolation: number;
}
interface Animation {
    name: string;
    tracks: AnimationTrack[];
}

interface LoaderConfig {
    textureLoader: (url: string) => Promise;
}
interface ParseResult {
    source: GLTF;
    scene: Object3D;
    scenes: Object3D[];
    animations: Animation[];
    skeletons: Map;
    componentMap: Map;
}
declare function loadGLTF(data: ArrayBuffer | string, config: LoaderConfig): Promise;

type gltfLoader_d_LoaderConfig = LoaderConfig;
type gltfLoader_d_ParseResult = ParseResult;
declare const gltfLoader_d_loadGLTF: typeof loadGLTF;
declare namespace gltfLoader_d {
  export { gltfLoader_d_loadGLTF as loadGLTF };
  export type { gltfLoader_d_LoaderConfig as LoaderConfig, gltfLoader_d_ParseResult as ParseResult };
}

interface IVector3 {
    set(x: number, y: number, z: number): void;
}
declare class SplatOperator {
    splat: Splat;
    /**
     * @internal
     */
    data: SplatData;
    private counts;
    private centers;
    constructor(splat: Splat, data: SplatData);
    getActiveCounts(): number;
    readSplatCenter(index: number, result: T): T;
    foreachSplatCenter(callback: (i: number, x: number, y: number, z: number) => void): void;
    readSplat(index: number): ISingleSplat$1;
    foreachSplat(callback: (i: number, single: ISingleSplat$1) => void): void;
    private initState;
    setState(indices: number[], state: SplatState, invert?: boolean): void;
    clearState(): void;
}

declare function computeDenseBox(operator: SplatOperator, ratio?: number): {
    boxMin: number[];
    boxMax: number[];
};

declare enum IntersectContainment {
    Outside = 0,
    Intersect = 1,
    Inside = 2
}
interface BVHNode {
    boxMin: [number, number, number];
    boxMax: [number, number, number];
    left: number;
    right: number;
    parent: number;
    start: number;
    end: number;
    isLeaf: boolean;
}
/**
 * splat model space bvh
 */
declare class SplatBVH {
    private operator;
    private maxLeafSize;
    private nodes;
    private indices;
    private sorted;
    private positions;
    constructor(operator: SplatOperator, maxLeafSize?: number);
    rebuild(): void;
    getBBox3(): {
        boxMin: [number, number, number];
        boxMax: [number, number, number];
    };
    search(intersectNode: (node: BVHNode) => IntersectContainment, intersectPoint: (x: number, y: number, z: number) => boolean): number[];
}

interface ISplatModifyData {
    transform: Matrix4;
    deletedIndices: number[];
    indicesTransforms: Array<{
        indices: number[];
        transform: Matrix4;
    }>;
}
declare function createSplatModifyData(splat: Splat): ISplatModifyData;
declare function createSplat(data: SplatData): Promise;
declare function createSplatData(splat: Splat): SplatData;
declare function combineSplatData(source: SplatData[]): SplatData;
declare function transformSplatFile(source: SplatData, outType: SplatFileType): ReadableStream;

interface IBox {
    min: [number, number, number];
    max: [number, number, number];
}
interface LodMeta {
    magicCode: 2500660;
    type: 'lod-splat';
    version: number;
    counts: number;
    shDegree: number;
    levels: number;
    files: string[];
    forwardBox: IBox;
    permanentFiles: number[];
    tree: Array<{
        bound: IBox;
        lods: Array<{
            file: number;
            offset: number;
            count: number;
        }>;
    }>;
}
interface DistanceStep {
    distance: number;
    step: number;
}
interface LodConfig {
    minLevel: number;
    maxBudget: number;
    backgroundPenalty: number;
    outsidePenalty: number;
    behindPenalty: number;
    behindTolerance: number;
    behindDistanceTolerance: number;
    distanceStep: DistanceStep[];
    hysteresisTicks: number;
    schedulerParallelCounts: number;
    schedulerExistingTaskLimit: number;
    schedulerMinDuration: number;
    debuggerEnabled: boolean;
    debuggerType: 0 | 1;
}
declare function DefaultLoadResource(url: string): Promise;
declare class LodSplat {
    private minLevel;
    private maxLevel;
    private maxBudget;
    private backgroundPenalty;
    private outsidePenalty;
    private behindPenalty;
    private behindTolerance;
    private behindDistanceTolerance;
    private distanceStep;
    private hysteresisTicks;
    private schedulerParallelCounts;
    private schedulerExistingTaskLimit;
    private schedulerMinDuration;
    private debuggerEnabled;
    private debuggerType;
    private viewerCtx?;
    private resourceManager;
    private nodes;
    private lessUsedBudget;
    readonly container: Object3D;
    constructor(meta: LodMeta, config?: Partial, viewerCtx?: IViewerContext, loadResource?: typeof DefaultLoadResource);
    setConfig(config: Partial): void;
    private flush;
    tick(camera: Camera3D): void;
    private running?;
    onFinishSchedule(): Promise;
    private rafId?;
    start(): void;
    private isDestroy;
    destroy(): void;
}

type splatUtils_d_IntersectContainment = IntersectContainment;
declare const splatUtils_d_IntersectContainment: typeof IntersectContainment;
type splatUtils_d_LodConfig = LodConfig;
type splatUtils_d_LodMeta = LodMeta;
type splatUtils_d_LodSplat = LodSplat;
declare const splatUtils_d_LodSplat: typeof LodSplat;
type splatUtils_d_SplatBVH = SplatBVH;
declare const splatUtils_d_SplatBVH: typeof SplatBVH;
type splatUtils_d_SplatOperator = SplatOperator;
declare const splatUtils_d_SplatOperator: typeof SplatOperator;
declare const splatUtils_d_combineSplatData: typeof combineSplatData;
declare const splatUtils_d_computeDenseBox: typeof computeDenseBox;
declare const splatUtils_d_createSplat: typeof createSplat;
declare const splatUtils_d_createSplatData: typeof createSplatData;
declare const splatUtils_d_createSplatModifyData: typeof createSplatModifyData;
declare const splatUtils_d_transformSplatFile: typeof transformSplatFile;
declare namespace splatUtils_d {
  export { splatUtils_d_IntersectContainment as IntersectContainment, splatUtils_d_LodSplat as LodSplat, splatUtils_d_SplatBVH as SplatBVH, splatUtils_d_SplatOperator as SplatOperator, splatUtils_d_combineSplatData as combineSplatData, splatUtils_d_computeDenseBox as computeDenseBox, splatUtils_d_createSplat as createSplat, splatUtils_d_createSplatData as createSplatData, splatUtils_d_createSplatModifyData as createSplatModifyData, splatUtils_d_transformSplatFile as transformSplatFile };
  export type { splatUtils_d_LodConfig as LodConfig, splatUtils_d_LodMeta as LodMeta };
}

import SourceTexture = SourceTexture$1;
import TextureDimension = TextureDimension$1;
import TextureViewDimension = TextureViewDimension$1;
import TextureFormat = TextureFormat$1;
import InstancedBufferGeometry = InstancedBufferGeometry$1;
import CompressedSplat = CompressedSplat$1;
import SuperCompressedSplat = SuperCompressedSplat$1;
import SogSplat = SogSplat$1;
declare const MeshBasicMaterial: {
    new (p?: MeshBasicMaterialParameters | undefined): MeshBasicMaterial$1;
    readonly MAX_TEXTURES: 6;
};
declare const MeshPhongMaterial: {
    new (p?: MeshPhongMaterialParameters | undefined): MeshPhongMaterial$1;
    DefaultSceneClipEnabled: boolean;
    constructMaterialFromGBufferForLight(): string;
    extendDeferredLight(builder: ShaderBuilder): void;
    readonly MAX_TEXTURES: 6;
};
declare const SpriteMaterial: {
    new (p?: SpriteMaterialParameters | undefined): SpriteMaterial$1;
    readonly MAX_TEXTURES: 6;
};
interface IBasicBackgroundConfig {
    color?: Color;
    alpha?: number;
    texture?: Texture | null;
}
interface IEnvMapBackgroundConfig {
    texture?: Texture;
    luma?: number;
    verticalRotation?: number;
    horizonRotation?: number;
    reverseVertical?: boolean;
    reverseHorizon?: boolean;
}
interface IGradientBackgroundConfig {
    skyColor?: Color;
    groundColor?: Color;
}
interface ISkyBackgroundConfig {
    enablePreSkyMap?: boolean;
    luminance?: number;
    turbidity?: number;
    rayleigh?: number;
    mieCoefficient?: number;
    mieDirectionalG?: number;
}
interface IBackgroundPluginConfig {
    /**
     * @default `true`
     */
    enabled?: boolean;
    /**
     * up for background rendering, will effect ground and background
     * @default `Vector3(0.0, 0.0, 1.0)`
     */
    up?: Vector3;
    ground?: {
        /**
         * enable ground grid
         * @default `true`
         */
        enabled?: boolean;
        /**
         * default ground grid size
         * @default `1000000`
         */
        gridSize?: number;
        /**
         * grid A gap
         * @default `500`
         */
        gridGapSizeA?: number;
        /**
         * grid A color
         * @default `Color(1.0, 1.0, 1.0)`
         */
        colorA?: Color;
        /**
         * grid A line width
         * @default `1`
         */
        lineWidthA?: number;
        /**
         * grid B gap
         * @default `5000`
         */
        gridGapSizeB?: number;
        /**
         * grid B color
         * @default `Color(1.0, 1.0, 1.0)`
         */
        colorB?: Color;
        /**
         * grid B line width
         * @default `1`
         */
        lineWidthB?: number;
        /**
         * enable ground color shading, by default will only render noise for ground.
         * @default `false`
         */
        isGroundColorEnabled?: boolean;
        /**
         * ground color
         * @default `Color(0.7, 0.7, 0.7)`
         */
        groundColor?: Color;
    };
    background?: {
        /**
         * @default `BackgroundMode.BasicBackground`
         */
        active?: BackgroundMode;
        /**
         * basic color and texture
         * active by `BackgroundMode.BasicBackground`
         */
        basic?: IBasicBackgroundConfig;
        /**
         * sphere envmap
         * active by `BackgroundMode.EnvMapBackground`
         */
        envmap?: IEnvMapBackgroundConfig;
        /**
         * sphere gradient
         * active by `BackgroundMode.GradientBackground`
         */
        gradient?: IGradientBackgroundConfig;
        /**
         * sky box
         * active by `BackgroundMode.SkyBackground`
         */
        sky?: ISkyBackgroundConfig;
    };
}
interface ICompositePluginConfig {
    enabled?: boolean;
    multiSamplingEnabled?: boolean;
    staticFrameCacheEnabled?: boolean;
}
interface ISplattingPluginConfig {
    enabled?: boolean;
    precalculateEnabled?: boolean;
    repackEnabled?: boolean;
    packHighPrecisionEnabled?: boolean;
    preBlurAmount?: number;
    blurAmount?: number;
    focalAdjustment?: number;
    maxStdDev?: number;
    maxPixelRadius?: number;
    detailCullingThreshold?: number;
    normalizedFalloff?: boolean;
    selectedColor?: Vector4;
    /**
     * gaussian sorting
     */
    sort?: {
        sortRadial?: boolean;
        sortMinDuration?: number;
        sortSplatDistance?: number;
        sortSplatCoorient?: number;
        sortCameraDistance?: number;
        sortCameraCoorient?: number;
    };
    /**
     * composite before output
     */
    composite?: {
        enabled?: boolean;
        highPrecisionAttachEnabled?: boolean;
    };
    /**
     * tone mapping functions
     */
    toneMapping?: {
        enabled?: boolean;
        toneMapping?: ToneMapping;
        exposure?: number;
    };
    /**
     * gaussian center highlight
     */
    highlightKernel?: {
        enabled?: boolean;
        size?: number;
        color?: number;
    };
}
interface ITaaPluginConfig {
    /**
     * enabled static TAA
     * @default `true`
     */
    enabled?: boolean;
}
interface IPipelineConfig {
    /**
     * background and ground
     */
    Background?: IBackgroundPluginConfig;
    /**
     * output Composite, used to optimize multi viewport rendering
     */
    Composite?: ICompositePluginConfig;
    /**
     * gaussian splatting
     */
    Splatting?: ISplattingPluginConfig;
    /**
     * static TAA
     */
    TAA?: ITaaPluginConfig;
}
interface IViewerConfig {
    /**
     * pixel ratio used for rendering
     * @default `1.0`
     * @remarks
     * default the renderer will use physical pixel in rendering.
     * if `devicePixelRatio` is large on some device, will cause performance issue, could set it to `1 / devicePixelRatio`
     */
    pixelRatio?: number;
    /**
     * render pipeline config
     */
    pipeline?: IPipelineConfig;
}
declare function downloadTexture(url: string): Promise;
declare function createViewer(name: string, container: HTMLElement, config: EngineInitializeConfig): Viewer;
declare function setViewerConfig(ctx: Viewer | Viewport, config: IViewerConfig): void;

export { AmbientLight, animation_d as Animation, BackgroundMode, Blending, BlendingEquation, BlendingFactor, Box3, BufferAttribute, BufferGeometry, Camera3D, Color, CompressedSplat, DepthModes, DirectionalLight, dracoLoader_d as DracoLoader, DrawMode, DrawableRenderMode, Euler, events_d as Events, FatLineBufferGeometry, FatLineMaterial, FatLineSegments, FilterTarget, Frustum, gltfLoader_d as GLTFLoader, InstanceMesh, InstancedBufferAttribute, InstancedBufferGeometry, Layers, Light, Line, LineBasicMaterial as LineMaterial, LineSegments, Material, Matrix3, Matrix4, Mesh, MeshBasicMaterial, MeshPhongMaterial, Object3D, OrthographicCamera, PerspectiveCamera, Plane, PointLight, Points, PointsMaterial, Quaternion, Ray, Raycaster, SamplerFilter, SamplerWrap, Scene3D, Side, SogSplat, SourceTexture, Sphere, Splat, splatLoader_d as SplatLoader, SplatState, splatUtils_d as SplatUtils, SpotLight, Sprite, SpriteMaterial, StencilFunc, StencilOp, SuperCompressedSplat, TextureDimension, TextureFormat, TextureViewDimension, ToneMapping, TypeAssert, Vector2, Vector3, Vector4, Viewer, Viewport, createViewer, createViewerContext, downloadTexture, setViewerConfig };
export type { IBackgroundPluginConfig, IBasicBackgroundConfig, ICompositePluginConfig, IEnvMapBackgroundConfig, IGradientBackgroundConfig, IPipelineConfig, ISkyBackgroundConfig, ISplattingPluginConfig, ITaaPluginConfig, IViewerConfig, IViewerContext, Intersection, ReadonlyColor, ReadonlyMatrix3, ReadonlyMatrix4, ReadonlyVector2, ReadonlyVector3, ReadonlyVector4 };