@galacean/engine-core 2.0.0-alpha.44 → 2.0.0-alpha.46

package/types/animation/animationCurve/AnimationQuaternionCurve.d.ts

@@ -1,8 +1,49 @@
 import { Quaternion } from "@galacean/engine-math";
+import { AnimationCurveLayerOwner } from "../internal/AnimationCurveLayerOwner";
+import { AnimationCurveOwner } from "../internal/animationCurveOwner/AnimationCurveOwner";
+import { Keyframe } from "../Keyframe";
 import { AnimationCurve } from "./AnimationCurve";
 /**
  * Store a collection of Keyframes that can be evaluated over time.
  */
 export declare class AnimationQuaternionCurve extends AnimationCurve<Quaternion> {
+    /** @internal */
+    static _supportInterpolationMode: boolean;
+    /** @internal */
+    static _isCopyMode: boolean;
+    /** @internal */
+    private static _tempConjugateQuat;
+    /**
+     * @internal
+     */
+    static _initializeOwner(owner: AnimationCurveOwner<Quaternion>): void;
+    /**
+     * @internal
+     */
+    static _initializeLayerOwner(owner: AnimationCurveLayerOwner): void;
+    /**
+     * @internal
+     */
+    static _lerpValue(src: Quaternion, dest: Quaternion, weight: number, out: Quaternion): Quaternion;
+    /**
+     * @internal
+     */
+    static _additiveValue(value: Quaternion, weight: number, out: Quaternion): Quaternion;
+    /**
+     * @internal
+     */
+    static _subtractValue(src: Quaternion, base: Quaternion, out: Quaternion): Quaternion;
+    /**
+     * @internal
+     */
+    static _getZeroValue(out: Quaternion): Quaternion;
+    /**
+     * @internal
+     */
+    static _setValue(source: Quaternion, out: Quaternion): Quaternion;
+    /**
+     * @internal
+     */
+    static _hermiteInterpolationValue(frame: Keyframe<Quaternion>, nextFrame: Keyframe<Quaternion>, t: number, dur: number, out: Quaternion): Quaternion;
     constructor();
 }

package/types/animation/animationCurve/AnimationRectCurve.d.ts

@@ -1,8 +1,26 @@
 import { Rect } from "@galacean/engine-math";
+import { AnimationCurveLayerOwner } from "../internal/AnimationCurveLayerOwner";
+import { AnimationCurveOwner } from "../internal/animationCurveOwner/AnimationCurveOwner";
 import { AnimationCurve } from "./AnimationCurve";
 /**
  * Store a collection of Keyframes that can be evaluated over time.
  */
 export declare class AnimationRectCurve extends AnimationCurve<Rect> {
+    /** @internal */
+    static _isCopyMode: boolean;
+    /** @internal */
+    static _supportInterpolationMode: boolean;
+    /**
+     * @internal
+     */
+    static _initializeOwner(owner: AnimationCurveOwner<Rect>): void;
+    /**
+     * @internal
+     */
+    static _initializeLayerOwner(owner: AnimationCurveLayerOwner): void;
+    /**
+     * @internal
+     */
+    static _setValue(source: Rect, out: Rect): Rect;
     constructor();
 }

package/types/animation/animationCurve/AnimationRefCurve.d.ts

@@ -1,8 +1,26 @@
 import { ReferResource } from "../../asset/ReferResource";
+import { AnimationCurveLayerOwner } from "../internal/AnimationCurveLayerOwner";
+import { AnimationCurveOwner } from "../internal/animationCurveOwner/AnimationCurveOwner";
 import { AnimationCurve } from "./AnimationCurve";
 /**
  * Store a collection of Keyframes that can be evaluated over time.
  */
 export declare class AnimationRefCurve extends AnimationCurve<ReferResource> {
+    /** @internal */
+    static _isCopyMode: boolean;
+    /** @internal */
+    static _supportInterpolationMode: boolean;
+    /**
+     * @internal
+     */
+    static _initializeOwner(owner: AnimationCurveOwner<ReferResource>): void;
+    /**
+     * @internal
+     */
+    static _initializeLayerOwner(owner: AnimationCurveLayerOwner): void;
+    /**
+     * @internal
+     */
+    static _setValue(value: ReferResource): ReferResource;
     constructor();
 }

package/types/animation/animationCurve/AnimationStringCurve.d.ts

@@ -1,7 +1,46 @@
+import { AnimationCurveLayerOwner } from "../internal/AnimationCurveLayerOwner";
+import { AnimationCurveOwner } from "../internal/animationCurveOwner/AnimationCurveOwner";
+import { Keyframe } from "../Keyframe";
 import { AnimationCurve } from "./AnimationCurve";
 /**
  * Store a collection of Keyframes that can be evaluated over time.
  */
 export declare class AnimationStringCurve extends AnimationCurve<string> {
+    /** @internal */
+    static _isCopyMode: boolean;
+    /** @internal */
+    static _supportInterpolationMode: boolean;
+    /**
+     * @internal
+     */
+    static _initializeOwner(owner: AnimationCurveOwner<string>): void;
+    /**
+     * @internal
+     */
+    static _initializeLayerOwner(owner: AnimationCurveLayerOwner): void;
+    /**
+     * @internal
+     */
+    static _lerpValue(srcValue: string, destValue: string): string;
+    /**
+     * @internal
+     */
+    static _subtractValue(src: string, base: string, out: string): string;
+    /**
+     * @internal
+     */
+    static _getZeroValue(): string;
+    /**
+     * @internal
+     */
+    static _additiveValue(value: string, weight: number, source: string): string;
+    /**
+     * @internal
+     */
+    static _setValue(value: string): string;
+    /**
+     * @internal
+     */
+    static _hermiteInterpolationValue(frame: Keyframe<string>): string;
     constructor();
 }

package/types/animation/animationCurve/AnimationVector2Curve.d.ts

@@ -1,8 +1,47 @@
 import { Vector2 } from "@galacean/engine-math";
+import { AnimationCurveLayerOwner } from "../internal/AnimationCurveLayerOwner";
+import { AnimationCurveOwner } from "../internal/animationCurveOwner/AnimationCurveOwner";
+import { Keyframe } from "../Keyframe";
 import { AnimationCurve } from "./AnimationCurve";
 /**
  * Store a collection of Keyframes that can be evaluated over time.
  */
 export declare class AnimationVector2Curve extends AnimationCurve<Vector2> {
+    /** @internal */
+    static _isCopyMode: boolean;
+    /** @internal */
+    static _supportInterpolationMode: boolean;
+    /**
+     * @internal
+     */
+    static _initializeOwner(owner: AnimationCurveOwner<Vector2>): void;
+    /**
+     * @internal
+     */
+    static _initializeLayerOwner(owner: AnimationCurveLayerOwner): void;
+    /**
+     * @internal
+     */
+    static _lerpValue(srcValue: Vector2, destValue: Vector2, weight: number, out: Vector2): Vector2;
+    /**
+     * @internal
+     */
+    static _additiveValue(value: Vector2, weight: number, out: Vector2): Vector2;
+    /**
+     * @internal
+     */
+    static _subtractValue(src: Vector2, base: Vector2, out: Vector2): Vector2;
+    /**
+     * @internal
+     */
+    static _getZeroValue(out: Vector2): Vector2;
+    /**
+     * @internal
+     */
+    static _setValue(source: Vector2, out: Vector2): Vector2;
+    /**
+     * @internal
+     */
+    static _hermiteInterpolationValue(frame: Keyframe<Vector2>, nextFrame: Keyframe<Vector2>, t: number, dur: number, out: Vector2): Vector2;
     constructor();
 }

package/types/animation/animationCurve/AnimationVector3Curve.d.ts

@@ -1,8 +1,51 @@
 import { Vector3 } from "@galacean/engine-math";
+import { AnimationCurveLayerOwner } from "../internal/AnimationCurveLayerOwner";
+import { AnimationCurveOwner } from "../internal/animationCurveOwner/AnimationCurveOwner";
+import { Keyframe } from "../Keyframe";
 import { AnimationCurve } from "./AnimationCurve";
 /**
  * Store a collection of Keyframes that can be evaluated over time.
  */
 export declare class AnimationVector3Curve extends AnimationCurve<Vector3> {
+    /** @internal */
+    static _isCopyMode: boolean;
+    /** @internal */
+    static _supportInterpolationMode: boolean;
+    /**
+     * @internal
+     */
+    static _initializeOwner(owner: AnimationCurveOwner<Vector3>): void;
+    /**
+     * @internal
+     */
+    static _initializeLayerOwner(owner: AnimationCurveLayerOwner): void;
+    /**
+     * @internal
+     */
+    static _lerpValue(srcValue: Vector3, destValue: Vector3, weight: number, out: Vector3): Vector3;
+    /**
+     * @internal
+     */
+    static _relativeBaseValue(base: Vector3, out: Vector3): Vector3;
+    /**
+     * @internal
+     */
+    static _additiveValue(value: Vector3, weight: number, out: Vector3): Vector3;
+    /**
+     * @internal
+     */
+    static _subtractValue(src: Vector3, base: Vector3, out: Vector3): Vector3;
+    /**
+     * @internal
+     */
+    static _getZeroValue(out: Vector3): Vector3;
+    /**
+     * @internal
+     */
+    static _setValue(source: Vector3, out: Vector3): Vector3;
+    /**
+     * @internal
+     */
+    static _hermiteInterpolationValue(frame: Keyframe<Vector3>, nextFrame: Keyframe<Vector3>, t: number, dur: number, out: Vector3): Vector3;
     constructor();
 }

package/types/animation/animationCurve/AnimationVector4Curve.d.ts

@@ -1,8 +1,47 @@
 import { Vector4 } from "@galacean/engine-math";
+import { AnimationCurveLayerOwner } from "../internal/AnimationCurveLayerOwner";
+import { AnimationCurveOwner } from "../internal/animationCurveOwner/AnimationCurveOwner";
+import { Keyframe } from "../Keyframe";
 import { AnimationCurve } from "./AnimationCurve";
 /**
  * Store a collection of Keyframes that can be evaluated over time.
  */
 export declare class AnimationVector4Curve extends AnimationCurve<Vector4> {
+    /** @internal */
+    static _isCopyMode: boolean;
+    /** @internal */
+    static _supportInterpolationMode: boolean;
+    /**
+     * @internal
+     */
+    static _initializeOwner(owner: AnimationCurveOwner<Vector4>): void;
+    /**
+     * @internal
+     */
+    static _initializeLayerOwner(owner: AnimationCurveLayerOwner): void;
+    /**
+     * @internal
+     */
+    static _lerpValue(srcValue: Vector4, destValue: Vector4, weight: number, out: Vector4): Vector4;
+    /**
+     * @internal
+     */
+    static _additiveValue(value: Vector4, weight: number, out: Vector4): Vector4;
+    /**
+     * @internal
+     */
+    static _subtractValue(src: Vector4, base: Vector4, out: Vector4): Vector4;
+    /**
+     * @internal
+     */
+    static _getZeroValue(out: Vector4): Vector4;
+    /**
+     * @internal
+     */
+    static _setValue(source: Vector4, out: Vector4): Vector4;
+    /**
+     * @internal
+     */
+    static _hermiteInterpolationValue(frame: Keyframe<Vector4>, nextFrame: Keyframe<Vector4>, t: number, dur: number, out: Vector4): Vector4;
     constructor();
 }

package/types/animation/animationCurve/interfaces/IAnimationCurveCalculator.d.ts

@@ -1 +1,18 @@
-export {};
+import { AnimationCurveLayerOwner } from "../../internal/AnimationCurveLayerOwner";
+import { AnimationCurveOwner } from "../../internal/animationCurveOwner/AnimationCurveOwner";
+import { Keyframe, KeyframeValueType } from "../../Keyframe";
+/**
+ * @internal
+ */
+export interface IAnimationCurveCalculator<V extends KeyframeValueType> {
+    _isCopyMode: boolean;
+    _supportInterpolationMode: boolean;
+    _initializeOwner(owner: AnimationCurveOwner<V>): any;
+    _initializeLayerOwner(owner: AnimationCurveLayerOwner): any;
+    _setValue(src: V, out?: V): V;
+    _lerpValue?(src: V, dest: V, weight: number, out?: V): V;
+    _additiveValue?(additive: V, weight: number, srcOut: V): V;
+    _subtractValue?(src: V, base: V, out?: V): V;
+    _getZeroValue?(out?: V): V;
+    _hermiteInterpolationValue?(frame: Keyframe<V>, nextFrame: Keyframe<V>, t: number, dur: number, out?: V): V;
+}

package/types/animation/enums/AnimatorStatePlayState.d.ts

@@ -1 +1,8 @@
-export {};
+/**
+ * @internal
+ */
+export declare enum AnimatorStatePlayState {
+    UnStarted = 0,
+    Playing = 1,
+    Finished = 2
+}

package/types/animation/internal/AnimationCurveLayerOwner.d.ts

@@ -1 +1,15 @@
-export {};
+import { KeyframeValueType } from "../Keyframe";
+import { AnimationCurveOwner } from "./animationCurveOwner/AnimationCurveOwner";
+/**
+ * @internal
+ */
+export declare class AnimationCurveLayerOwner {
+    crossSrcCurveIndex: number;
+    crossDestCurveIndex: number;
+    crossCurveMark: number;
+    curveOwner: AnimationCurveOwner<KeyframeValueType>;
+    finalValue: KeyframeValueType;
+    isActive: boolean;
+    initFinalValue(): void;
+    saveFinalValue(): void;
+}

package/types/animation/internal/AnimationEventHandler.d.ts

@@ -1 +1,8 @@
-export {};
+import { AnimationEvent } from "../AnimationEvent";
+/**
+ * @internal
+ */
+export declare class AnimationEventHandler {
+    event: AnimationEvent;
+    handlers: Function[];
+}

package/types/animation/internal/AnimatorLayerData.d.ts

@@ -1 +1,28 @@
-export {};
+import { Component } from "../../Component";
+import { AnimatorControllerLayer } from "../AnimatorControllerLayer";
+import { AnimatorState } from "../AnimatorState";
+import { AnimatorStateInstance } from "../AnimatorStateInstance";
+import { AnimatorStateTransition } from "../AnimatorStateTransition";
+import { LayerState } from "../enums/LayerState";
+import { AnimationCurveLayerOwner } from "./AnimationCurveLayerOwner";
+import { AnimatorStateData } from "./AnimatorStateData";
+import type { AnimatorStatePlayData } from "./AnimatorStatePlayData";
+/**
+ * @internal
+ */
+export declare class AnimatorLayerData {
+    layerIndex: number;
+    layer: AnimatorControllerLayer;
+    curveOwnerPool: WeakMap<Component, Record<string, AnimationCurveLayerOwner>>;
+    animatorStateDataMap: Map<AnimatorState, AnimatorStateData>;
+    instanceMap: WeakMap<AnimatorState, AnimatorStateInstance>;
+    srcPlayData: AnimatorStatePlayData | null;
+    destPlayData: AnimatorStatePlayData | null;
+    layerState: LayerState;
+    crossCurveMark: number;
+    manuallyTransition: AnimatorStateTransition;
+    crossFadeTransition: AnimatorStateTransition;
+    crossLayerOwnerCollection: AnimationCurveLayerOwner[];
+    getOrCreateInstance(state: AnimatorState): AnimatorStateInstance;
+    resetCurrentCheckIndex(): void;
+}

package/types/animation/internal/AnimatorStateData.d.ts

@@ -1 +1,14 @@
-export {};
+import { AnimatorState } from "../AnimatorState";
+import { AnimationCurveLayerOwner } from "./AnimationCurveLayerOwner";
+import { AnimationEventHandler } from "./AnimationEventHandler";
+/**
+ * @internal
+ */
+export declare class AnimatorStateData {
+    readonly state: AnimatorState;
+    curveLayerOwner: AnimationCurveLayerOwner[];
+    eventHandlers: AnimationEventHandler[];
+    eventsBuiltVersion: number;
+    eventsBuiltScriptsVersion: number;
+    constructor(state: AnimatorState);
+}

package/types/animation/internal/AnimatorStatePlayData.d.ts

@@ -1 +1,27 @@
-export {};
+import { AnimatorStateInstance } from "../AnimatorStateInstance";
+import { AnimatorState } from "../AnimatorState";
+import { AnimatorStatePlayState } from "../enums/AnimatorStatePlayState";
+import { WrapMode } from "../enums/WrapMode";
+import { AnimatorStateData } from "./AnimatorStateData";
+/**
+ * @internal
+ */
+export declare class AnimatorStatePlayData {
+    readonly instance: AnimatorStateInstance;
+    stateData: AnimatorStateData;
+    playedTime: number;
+    playState: AnimatorStatePlayState;
+    clipTime: number;
+    currentEventIndex: number;
+    isForward: boolean;
+    offsetFrameTime: number;
+    private _changedOrientation;
+    constructor(instance: AnimatorStateInstance);
+    get state(): AnimatorState;
+    get speed(): number;
+    get wrapMode(): WrapMode;
+    reset(stateData: AnimatorStateData, offsetFrameTime: number): void;
+    updateOrientation(deltaTime: number): void;
+    update(deltaTime: number): void;
+    private _correctTime;
+}

package/types/animation/internal/AnimatorTempValue.d.ts

@@ -1 +1,12 @@
-export {};
+import { Vector2, Vector3, Vector4, Quaternion } from "@galacean/engine-math";
+/**
+ * @internal
+ */
+export declare class AnimatorTempValue {
+    vector2: Vector2;
+    vector3: Vector3;
+    vector4: Vector4;
+    quaternion: Quaternion;
+    private _floatArrayPool;
+    getFloatArray(length: number): Float32Array;
+}

package/types/animation/internal/animationCurveOwner/AnimationCurveOwner.d.ts

@@ -1,5 +1,44 @@
+import { Component } from "../../../Component";
+import { ComponentConstructor, Entity } from "../../../Entity";
+import { AnimationCurve } from "../../animationCurve/AnimationCurve";
+import { IAnimationCurveCalculator } from "../../animationCurve/interfaces/IAnimationCurveCalculator";
 import { KeyframeValueType } from "../../Keyframe";
+import { IAnimationCurveOwnerAssembler } from "./assembler/IAnimationCurveOwnerAssembler";
+/**
+ * @internal
+ */
+export declare class AnimationCurveOwner<V extends KeyframeValueType> {
+    /** @internal */
+    static _components: Component[];
+    private static _assemblerMap;
+    static registerAssembler(componentType: ComponentConstructor, property: string, assemblerType: AssemblerType): void;
+    static getAssemblerType(componentType: ComponentConstructor, property: string): AssemblerType;
+    readonly target: Entity;
+    readonly property: string;
+    readonly getProperty?: string;
+    readonly component: Component;
+    defaultValue: V;
+    fixedPoseValue: V;
+    baseEvaluateData: IEvaluateData<V>;
+    crossEvaluateData: IEvaluateData<V>;
+    referenceTargetValue: V;
+    cureType: IAnimationCurveCalculator<V>;
+    updateMark: number;
+    private _assembler;
+    constructor(target: Entity, type: ComponentConstructor, component: Component, property: string, getProperty: string, cureType: IAnimationCurveCalculator<V>);
+    evaluateValue(curve: AnimationCurve<V>, time: number, additive: boolean): KeyframeValueType;
+    evaluateCrossFadeValue(srcCurve: AnimationCurve<V>, destCurve: AnimationCurve<V>, srcTime: number, destTime: number, crossWeight: number, additive: boolean): KeyframeValueType;
+    crossFadeFromPoseAndApplyValue(destCurve: AnimationCurve<V>, destTime: number, crossWeight: number, additive: boolean): KeyframeValueType;
+    revertDefaultValue(): void;
+    getEvaluateValue(out: V): V;
+    saveDefaultValue(): void;
+    saveFixedPoseValue(): void;
+    applyValue(value: V, weight: number, additive: boolean): void;
+    private _lerpValue;
+}
+type AssemblerType = new () => IAnimationCurveOwnerAssembler<KeyframeValueType>;
 export interface IEvaluateData<V extends KeyframeValueType> {
     curKeyframeIndex: number;
     value: V;
 }
+export {};

package/types/animation/internal/animationCurveOwner/assembler/BlendShapeWeightsAnimationCurveOwnerAssembler.d.ts

@@ -1 +1,12 @@
-export {};
+import { KeyframeValueType } from "../../../Keyframe";
+import { AnimationCurveOwner } from "../AnimationCurveOwner";
+import { IAnimationCurveOwnerAssembler } from "./IAnimationCurveOwnerAssembler";
+/**
+ * @internal
+ */
+export declare class BlendShapeWeightsAnimationCurveOwnerAssembler implements IAnimationCurveOwnerAssembler<Float32Array> {
+    private _skinnedMeshRenderer;
+    initialize(owner: AnimationCurveOwner<KeyframeValueType>): void;
+    getTargetValue(): Float32Array;
+    setTargetValue(value: Float32Array): void;
+}

package/types/animation/internal/animationCurveOwner/assembler/IAnimationCurveOwnerAssembler.d.ts

@@ -1 +1,10 @@
-export {};
+import { KeyframeValueType } from "../../../Keyframe";
+import { AnimationCurveOwner } from "../AnimationCurveOwner";
+/**
+ * @internal
+ */
+export interface IAnimationCurveOwnerAssembler<V extends KeyframeValueType> {
+    initialize(owner: AnimationCurveOwner<KeyframeValueType>): void;
+    getTargetValue(): V;
+    setTargetValue(value: V): void;
+}

package/types/animation/internal/animationCurveOwner/assembler/PositionAnimationCurveOwnerAssembler.d.ts

@@ -1 +1,13 @@
-export {};
+import { Vector3 } from "@galacean/engine-math";
+import { KeyframeValueType } from "../../../Keyframe";
+import { AnimationCurveOwner } from "../AnimationCurveOwner";
+import { IAnimationCurveOwnerAssembler } from "./IAnimationCurveOwnerAssembler";
+/**
+ * @internal
+ */
+export declare class PositionAnimationCurveOwnerAssembler implements IAnimationCurveOwnerAssembler<Vector3> {
+    private _transform;
+    initialize(owner: AnimationCurveOwner<KeyframeValueType>): void;
+    getTargetValue(): Vector3;
+    setTargetValue(value: Vector3): void;
+}

package/types/animation/internal/animationCurveOwner/assembler/RotationAnimationCurveOwnerAssembler.d.ts

@@ -1 +1,13 @@
-export {};
+import { Quaternion } from "@galacean/engine-math";
+import { KeyframeValueType } from "../../../Keyframe";
+import { AnimationCurveOwner } from "../AnimationCurveOwner";
+import { IAnimationCurveOwnerAssembler } from "./IAnimationCurveOwnerAssembler";
+/**
+ * @internal
+ */
+export declare class RotationAnimationCurveOwnerAssembler implements IAnimationCurveOwnerAssembler<Quaternion> {
+    private _transform;
+    initialize(owner: AnimationCurveOwner<KeyframeValueType>): void;
+    getTargetValue(): Quaternion;
+    setTargetValue(value: Quaternion): void;
+}

package/types/animation/internal/animationCurveOwner/assembler/ScaleAnimationCurveOwnerAssembler.d.ts

@@ -1 +1,13 @@
-export {};
+import { Vector3 } from "@galacean/engine-math";
+import { KeyframeValueType } from "../../../Keyframe";
+import { AnimationCurveOwner } from "../AnimationCurveOwner";
+import { IAnimationCurveOwnerAssembler } from "./IAnimationCurveOwnerAssembler";
+/**
+ * @internal
+ */
+export declare class ScaleAnimationCurveOwnerAssembler implements IAnimationCurveOwnerAssembler<Vector3> {
+    private _transform;
+    initialize(owner: AnimationCurveOwner<KeyframeValueType>): void;
+    getTargetValue(): Vector3;
+    setTargetValue(value: Vector3): void;
+}

package/types/animation/internal/animationCurveOwner/assembler/UniversalAnimationCurveOwnerAssembler.d.ts

@@ -1 +1,23 @@
-export {};
+import { KeyframeValueType } from "../../../Keyframe";
+import { AnimationCurveOwner } from "../AnimationCurveOwner";
+import { IAnimationCurveOwnerAssembler } from "./IAnimationCurveOwnerAssembler";
+/**
+ * @internal
+ */
+export declare class UniversalAnimationCurveOwnerAssembler implements IAnimationCurveOwnerAssembler<KeyframeValueType> {
+    private _getMounted;
+    private _setMounted;
+    private _getType;
+    private _setType;
+    private _getValueName;
+    private _setValueName;
+    private _getArgs;
+    private _setArgs;
+    private _replaceValueIndex;
+    private _getArrayIndex;
+    private _setArrayIndex;
+    initialize(owner: AnimationCurveOwner<KeyframeValueType>): void;
+    getTargetValue(): KeyframeValueType;
+    setTargetValue(value: KeyframeValueType): void;
+    private _initializeMounted;
+}

package/types/asset/GraphicsResource.d.ts

@@ -1,9 +1,19 @@
 import { Engine } from "../Engine";
 import { ReferResource } from "./ReferResource";
 export declare abstract class GraphicsResource extends ReferResource {
+    /** @internal */
+    _isContentLost: boolean;
     /**
      * Whether the content of the resource is lost.
      */
     get isContentLost(): boolean;
     protected constructor(engine: Engine);
+    /**
+     * @internal
+     */
+    abstract _rebuild(): void;
+    /**
+     * @internal
+     */
+    protected _onDestroy(): void;
 }

package/types/asset/IReferable.d.ts

@@ -1,2 +1,10 @@
 export interface IReferable {
+    /**
+     * @internal
+     */
+    _getReferCount(): number;
+    /**
+     * @internal
+     */
+    _addReferCount(count: number): void;
 }

package/types/asset/ReferResource.d.ts

@@ -20,4 +20,32 @@ export declare abstract class ReferResource extends EngineObject implements IRef
      * @returns Whether the release was successful
      */
     destroy(force?: boolean): boolean;
+    /**
+     * @internal
+     */
+    destroy(force: boolean, isGC: boolean): boolean;
+    /**
+     * @internal
+     */
+    _associationSuperResource(superResource: ReferResource): void;
+    /**
+     * @internal
+     */
+    _disassociationSuperResource(superResource: ReferResource): void;
+    /**
+     * @internal
+     */
+    _getReferCount(): number;
+    /**
+     * @internal
+     */
+    _addReferCount(value: number): void;
+    /**
+     * @internal
+     */
+    _addToResourceManager(path: string): void;
+    /**
+     * @internal
+     */
+    protected _onDestroy(): void;
 }