Options
All
  • Public
  • Public/Protected
  • All
Menu

Namespace <internal>

Index

Namespaces

Enumerations

Enumeration Members

Classes

Interfaces

Type Aliases

Variables

Enumeration Members

Direct

Direct: 3

Type Aliases

ApplyParams

ApplyParams: { scene: Scene }

Type declaration

ArrayBufferLike

ArrayBufferLike: ArrayBufferTypes[keyof ArrayBufferTypes]

ArrayBufferView

ArrayBufferView: <internal>.TypedArray | DataView

Attributes

Attributes: { [ K in string]: BufferData }

BasePluginConstructor

BasePluginConstructor: {}

Type declaration

    BodyInit

    BodyInit: <internal>.ReadableStream | XMLHttpRequestBodyInit

    BufferData

    BufferData: { bindingIdx?: number; bufferUsage?: BufferUsage; data?: <internal>.TypedArray; divisor?: number; instanceCount?: number; isIndex?: boolean; isPosition?: boolean; itemSize?: number; normalize?: boolean; offset?: number; stride?: number; type?: ComponentType }

    Type declaration

    • Optional bindingIdx?: number
    • Optional bufferUsage?: BufferUsage
    • Optional data?: <internal>.TypedArray
    • Optional divisor?: number
    • Optional instanceCount?: number

      仅供实例属性数据使用

    • Optional isIndex?: boolean
    • Optional isPosition?: boolean
    • Optional itemSize?: number
    • Optional normalize?: boolean
    • Optional offset?: number
    • Optional stride?: number
    • Optional type?: ComponentType

    BufferEncoding

    BufferEncoding: "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex"

    BufferSource

    BufferSource: <internal>.ArrayBufferView | ArrayBuffer

    Canvas

    Canvas: { getContext: HTMLCanvasElement["getContext"]; height: number; width: number }

    Type declaration

    • getContext: HTMLCanvasElement["getContext"]
    • height: number
    • width: number

    ColorParams

    ColorParams: ColorType | Color

    ColorType

    ColorType: string | [number, number, number] | [number, number, number, number]

    ConstructorParameters

    ConstructorParameters<T>: T extends (abstract new (...args: infer P) => any) ? P : never

    Obtain the parameters of a constructor function type in a tuple

    Type Parameters

    • T extends (abstract new (...args: any) => any)

    Equation

    Equation: ((t: number) => Vector3)

    Type declaration

    EulerOrder

    EulerOrder: "XYZ" | "XZY" | "YXZ" | "YZX" | "ZXY" | "ZYX"

    EventListenerFn

    EventListenerFn: ((type: string, handler: ((e: any) => void), params?: boolean) => void)

    Type declaration

      • (type: string, handler: ((e: any) => void), params?: boolean): void

      • Parameters

        • type: string
        • handler: ((e: any) => void)
            • (e: any): void

            • Parameters

              • e: any

              Returns void

        • Optional params: boolean

        Returns void

    Exclude

    Exclude<T, U>: T extends U ? never : T

    Exclude from T those types that are assignable to U

    Type Parameters

    • T

    • U

    FormDataEntryValue

    FormDataEntryValue: <internal>.File | string

    GLAStateKeys

    GLAStateKeys: StateKeys

    GLAStateValue

    GLAStateValue<K>: StateValue<K>

    Type Parameters

    GLCTextureDetailProps

    GLCTextureDetailProps: ITinoeTextureDetailProps & { source?: ITinoePixelBuffer | ITinoeImageSource }

    GLCTextureDetailProps

    GLCTextureDetailProps: ITinoeTextureDetailProps & { source?: ITinoePixelBuffer | ITinoeImageSource }

    ITinoeBufferProps

    ITinoeBufferProps: { bufferData?: number | ArrayBuffer | <internal>.ArrayBufferView; bufferUsage?: BufferUsage; gl?: ITinoeGLInstance; type: BufferBindFlag }

    Type declaration

    ITinoeCanvasContainer

    ITinoeCanvasContainer: HTMLDivElement

    ITinoeCanvasProps

    ITinoeCanvasProps: { container?: ITinoeCanvasContainer; height?: number; id?: string; width?: number }

    Type declaration

    • Optional container?: ITinoeCanvasContainer
    • Optional height?: number
    • Optional id?: string
    • Optional width?: number

    ITinoeGLAProps

    ITinoeGLAProps: Omit<TinoeContextProps, "canvas"> & { canvas?: TinoeCanvasProps; shaderPrecision?: ShaderPrecision }

    ITinoeGLInstance

    ITinoeGLInstance: WebGLRenderingContext | WebGL2RenderingContext

    ITinoeImageSource

    ITinoeImageSource: TexImageSource | Canvas

    ITinoePixelBuffer

    ITinoePixelBuffer: <internal>.ArrayBufferView

    ITinoeWebGLInstance

    ITinoeWebGLInstance: WebGLRenderingContext & { bindVertexArray?: WebGL2RenderingContext["bindVertexArray"]; createVertexArray?: WebGL2RenderingContext["createVertexArray"]; deleteVertexArray?: WebGL2RenderingContext["deleteVertexArray"]; drawArraysInstanced?: WebGL2RenderingContext["drawArraysInstanced"]; drawElementsInstanced?: WebGL2RenderingContext["drawElementsInstanced"]; vertexAttribDivisor?: WebGL2RenderingContext["vertexAttribDivisor"] } | WebGL2RenderingContext & { instancedArrays?: ANGLE_instanced_arrays }

    InstanceType

    InstanceType<T>: T extends (abstract new (...args: any) => infer R) ? R : any

    Obtain the return type of a constructor function type

    Type Parameters

    • T extends (abstract new (...args: any) => any)

    IteratorResult

    IteratorResult<T, TReturn>: IteratorYieldResult<T> | IteratorReturnResult<TReturn>

    Type Parameters

    • T

    • TReturn = any

    Key

    Key: string | number

    MorphTargetAttribute

    MorphTargetAttribute: { [ K in string]: BufferData }

    ObservedClazz

    ObservedClazz: typeof Vector2 | typeof Vector3 | typeof Vector4 | typeof Quaternion | typeof Color

    ObservedInstanceType

    ObservedInstanceType<T>: InstanceType<T> & { elements: readonly number[]; tapChange: any }

    Type Parameters

    Omit

    Omit<T, K>: Pick<T, Exclude<keyof T, K>>

    Construct a type with the properties of T except for those in type K.

    Type Parameters

    • T

    • K extends keyof any

    Partial

    Partial<T>: { [ P in keyof T]?: T[P] }

    Make all properties in T optional

    Type Parameters

    • T

    Pick

    Pick<T, K>: { [ P in K]: T[P] }

    From T, pick a set of properties whose keys are in the union K

    Type Parameters

    • T

    • K extends keyof T

    Picker

    Picker: ((x: number, y: number) => Promise<Mesh> | Mesh | undefined)

    Type declaration

      • (x: number, y: number): Promise<Mesh> | Mesh | undefined

      • Parameters

        • x: number
        • y: number

        Returns Promise<Mesh> | Mesh | undefined

    PluginKey

    PluginKey: string | symbol

    PredefinedColorSpace

    PredefinedColorSpace: "display-p3" | "srgb"

    Queues

    Queues<T>: { alpha: T; opaque: T; transparent: T }

    Type Parameters

    Type declaration

    • alpha: T
    • opaque: T
    • transparent: T

    ReadableStreamDefaultReadResult

    ReadableStreamDefaultReadResult<T>: ReadableStreamDefaultReadValueResult<T> | ReadableStreamDefaultReadDoneResult

    Type Parameters

    • T

    Record

    Record<K, T>: { [ P in K]: T }

    Construct a type with a set of properties K of type T

    Type Parameters

    • K extends keyof any

    • T

    RenderContext

    RenderContext: { deltaTime: number; gla: <internal>.default; hooks: RenderHooks; viewport: number[] }

    Type declaration

    RenderContext2D

    RenderContext2D: RenderContext & { scene: Scene2D }

    RenderContext3D

    RenderContext3D: RenderContext & { bufferClearFlag: boolean; coreDataManager?: CoreDataManager; elementPool?: WeakCache<Mesh, RenderElement>; queues?: Queues; scene: Scene }

    RenderHooks

    RenderHooks: { preDraw: SyncHook<RenderElement>; preQueue: SyncHook<Queues>; preTick: SyncHook<RenderContext3D>; tick: SyncHook<RenderContext3D>; tick2d: SyncHook<RenderContext2D> }

    Type declaration

    RenderPassProps

    RenderPassProps: { name?: string; priority?: number; renderTarget?: <internal>.default; replaceMaterial?: Material }

    Type declaration

    • Optional name?: string
    • Optional priority?: number
    • Optional renderTarget?: <internal>.default
    • Optional replaceMaterial?: Material

    RenderTargetProps

    RenderTargetProps: { colorTexture?: { instance: <internal>.default }; depthFormat?: RenderBufferDepthFormat; height?: number; width?: number }

    Type declaration

    ResponseType

    ResponseType: "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect"

    SetPointParams

    SetPointParams<T>: LineGeometryConfigParams<T> & { updateBBox?: boolean }

    Type Parameters

    StateParams

    StateParams: { dependency?: EnableValueState; gl: ITinoeWebGLInstance }

    Type declaration

    StateValue

    StateValue<K>: TinoeWebGLStateManager["statesPool"][K]["value"]

    Type Parameters

    TexImageSource

    TexImageSource: <internal>.ImageBitmap | <internal>.ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement

    TinoeCanvasProps

    TinoeCanvasProps: ConstructorParameters<typeof <internal>.default>[0] | ConstructorParameters<typeof <internal>.default>[0]

    TinoeContextProps

    TinoeContextProps: ConstructorParameters<typeof <internal>.default>[0] | ConstructorParameters<typeof <internal>.default>[0]

    TinoeEngineProps

    TinoeEngineProps: <internal>.ITinoeGLAProps

    TinoeScene

    TinoeScene: Scene | Scene2D

    TinoeStageProps

    TinoeStageProps: TinoeEngineProps & { autoResize?: boolean; frameRate?: number }

    TypedArray

    TypedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array

    TypedArray

    TypedArray: Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | BigUint64Array | BigInt64Array | Float32Array | Float64Array

    VertexAttribInfo

    VertexAttribInfo: { bindingIdx?: number; format: vertexAttribFormat; isIndex?: boolean; key: AttributeKeys; macroKey?: string; semanticKey: string; size: number; type: Float32ArrayConstructor | Uint16ArrayConstructor }

    Type declaration

    • Optional bindingIdx?: number
    • format: vertexAttribFormat
    • Optional isIndex?: boolean
    • key: AttributeKeys
    • Optional macroKey?: string
    • semanticKey: string
    • size: number
    • type: Float32ArrayConstructor | Uint16ArrayConstructor

    WeakInjectOptions

    WeakInjectOptions: { key?: string; onInject?: any; onRelease?: any }

    Type declaration

    • Optional key?: string
    • onInject?:function
      • onInject(): void

      • Returns void

    • onRelease?:function
      • onRelease(): void

      • Returns void

    WebGLPowerPreference

    WebGLPowerPreference: "default" | "high-performance" | "low-power"

    WithImplicitCoercion

    WithImplicitCoercion<T>: T | { valueOf: any }

    Type Parameters

    • T

    XHRResponseType

    XHRResponseType: "arraybuffer" | "blob" | "document" | "json" | "text" | ""

    XMLHttpRequestBodyInit

    XMLHttpRequestBodyInit: Blob | BufferSource | <internal>.FormData | URLSearchParams | string

    Variables

    Buffer

    Buffer: BufferConstructor

    Error

    Error: ErrorConstructor

    File

    File: { prototype: <internal>.File }

    Type declaration

    FormData

    FormData: { prototype: <internal>.FormData }

    Type declaration

    Headers

    Headers: { prototype: <internal>.Headers }

    Type declaration

    ImageBitmap

    ImageBitmap: { prototype: <internal>.ImageBitmap }

    Type declaration

    ImageData

    ImageData: { prototype: <internal>.ImageData }

    Type declaration

    ReadableStream

    ReadableStream: { prototype: <internal>.ReadableStream<any> }

    Type declaration

    ReadableStreamDefaultReader

    ReadableStreamDefaultReader: { prototype: <internal>.ReadableStreamDefaultReader<any> }

    Type declaration

    Response

    Response: { prototype: <internal>.Response; error: any; redirect: any }

    Type declaration

    SharedArrayBuffer

    SharedArrayBuffer: SharedArrayBufferConstructor

    WebGLBuffer

    WebGLBuffer: { prototype: <internal>.WebGLBuffer }

    Type declaration

    WebGLProgram

    WebGLProgram: { prototype: <internal>.WebGLProgram }

    Type declaration

    WebGLTexture

    WebGLTexture: { prototype: <internal>.WebGLTexture }

    Type declaration

    WritableStream

    WritableStream: { prototype: <internal>.WritableStream<any> }

    Type declaration

    WritableStreamDefaultWriter

    WritableStreamDefaultWriter: { prototype: <internal>.WritableStreamDefaultWriter<any> }

    Type declaration

    Generated using TypeDoc