@rings-webgpu/core 1.0.2 → 1.0.3

package/dist/src/math/AnimationCurve.js

@@ -1,191 +0,0 @@
-import { PingPong, RepeatSE } from "./MathUtil";
-import { FrameCache } from "./enum/FrameCache";
-import { WrapTimeMode } from "./enum/WrapTimeMode";
-import { Keyframe } from "./enum/Keyframe";
-export class AnimationCurve {
-    get cacheOut() {
-        return this._cacheOut;
-    }
-    constructor(frames, preWarpMode = WrapTimeMode.Repeat, postWarpMode = WrapTimeMode.Repeat) {
-        this._totalTime = 1;
-        this._cache = new FrameCache();
-        this._cacheOut = {
-            lhsIndex: 0,
-            rhsIndex: 0,
-        };
-        this._InvalidateCache = false;
-        this.curve = [];
-        if (frames)
-            for (let i = 0; i < frames.length; i++) {
-                const frame = frames[i];
-                this.addKeyFrame(frame);
-            }
-        this.preWarpMode = preWarpMode;
-        this.postWarpMode = postWarpMode;
-    }
-    get totalTime() {
-        return this._totalTime;
-    }
-    get first() {
-        return this.curve[0];
-    }
-    get last() {
-        return this.curve[this.curve.length - 1];
-    }
-    addKeyFrame(keyFrame) {
-        if (this.curve.indexOf(keyFrame) == -1) {
-            this.curve.push(keyFrame);
-        }
-        this.calcTotalTime();
-    }
-    removeKeyFrame(keyFrame) {
-        let index = this.curve.indexOf(keyFrame);
-        if (index != -1) {
-            this.curve.splice(index, 1);
-        }
-        this.calcTotalTime();
-    }
-    calculateCacheData(cache, lhsIndex, rhsIndex, timeOffset = 0) {
-        let m_Curve = this.curve;
-        let lhs = m_Curve[lhsIndex];
-        let rhs = m_Curve[rhsIndex];
-        cache.index = lhsIndex;
-        cache.time = lhs.time + timeOffset;
-        cache.timeEnd = rhs.time + timeOffset;
-        cache.index = lhsIndex;
-        let dx, length;
-        let dy;
-        let m1, m2, d1, d2;
-        dx = rhs.time - lhs.time;
-        dx = Math.max(dx, 0.0001);
-        dy = rhs.value - lhs.value;
-        length = 1.0 / (dx * dx);
-        m1 = lhs.outSlope;
-        m2 = rhs.inSlope;
-        d1 = m1 * dx;
-        d2 = m2 * dx;
-        cache.coeff[0] = ((d1 + d2 - dy - dy) * length) / dx;
-        cache.coeff[1] = (dy + dy + dy - d1 - d1 - d2) * length;
-        cache.coeff[2] = m1;
-        cache.coeff[3] = lhs.value;
-        this.setupStepped(cache.coeff, lhs, rhs);
-    }
-    getValue(time) {
-        time = this.wrapTime(time);
-        this.findCurve(time, this._cacheOut);
-        this.calculateCacheData(this._cache, this._cacheOut.lhsIndex, this._cacheOut.rhsIndex, 0);
-        return this.evaluateCache(this._cache, time);
-    }
-    getCurveFramesExtent(time) {
-        time = this.wrapTime(time);
-        this.findCurve(time, this._cacheOut);
-        return {
-            lhsIndex: this._cacheOut.lhsIndex,
-            rhsIndex: this._cacheOut.rhsIndex,
-            time: time,
-        };
-    }
-    getKeyCount() {
-        return this.curve.length;
-    }
-    getKey(index) {
-        return this.curve[index];
-    }
-    unSerialized(data) {
-        this.preWarpMode = data["m_PreInfinity"];
-        this.postWarpMode = data["m_PostInfinity"];
-        this.rotationOrder = data["m_RotationOrder"];
-        let len = data["m_Curve"].length;
-        for (let i = 0; i < len; i++) {
-            this.curve[i] = new Keyframe();
-            this.curve[i].unSerialized(data["m_Curve"][i.toString()]);
-        }
-        this.calcTotalTime();
-        return this;
-    }
-    unSerialized2(data) {
-        this.preWarpMode = data["preWrapMode"];
-        this.postWarpMode = data["postWrapMode"];
-        let keyFrames = data["keyFrames"] || data["keys"];
-        let len = keyFrames.length;
-        for (let i = 0; i < len; i++) {
-            this.curve[i] = new Keyframe();
-            this.curve[i].unSerialized2(keyFrames[i.toString()]);
-        }
-        this.calcTotalTime();
-        return this;
-    }
-    wrapTime(curveT) {
-        let m_Curve = this.curve;
-        let begTime = m_Curve[0].time;
-        let endTime = m_Curve[m_Curve.length - 1].time;
-        if (curveT < begTime) {
-            if (this.preWarpMode == WrapTimeMode.Clamp)
-                curveT = begTime;
-            else if (this.preWarpMode == WrapTimeMode.PingPong)
-                curveT = PingPong(curveT, begTime, endTime);
-            else
-                curveT = RepeatSE(curveT, begTime, endTime);
-        }
-        else if (curveT > endTime) {
-            if (this.postWarpMode == WrapTimeMode.Clamp)
-                curveT = endTime;
-            else if (this.postWarpMode == WrapTimeMode.PingPong)
-                curveT = PingPong(curveT, begTime, endTime);
-            else
-                curveT = RepeatSE(curveT, begTime, endTime);
-        }
-        return curveT;
-    }
-    evaluateCache(cache, curveT) {
-        let t = curveT - cache.time;
-        let output = t * (t * (t * cache.coeff[0] + cache.coeff[1]) + cache.coeff[2]) +
-            cache.coeff[3];
-        return output;
-    }
-    findCurve(time, out) {
-        let frames = this.curve;
-        for (let i = 1; i < frames.length; i++) {
-            let left = frames[i - 1];
-            let right = frames[i];
-            if (left.time <= time && right.time > time) {
-                out.lhsIndex = i - 1;
-                out.rhsIndex = i;
-            }
-        }
-    }
-    setupStepped(coeff, lhs, rhs) {
-        if (isNaN(lhs.outSlope) || isNaN(rhs.inSlope)) {
-            coeff[0] = 0.0;
-            coeff[1] = 0.0;
-            coeff[2] = 0.0;
-            coeff[3] = lhs.value;
-        }
-    }
-    invalidateCache() {
-        this._InvalidateCache = true;
-    }
-    calcTotalTime() {
-        let maxTime = 0;
-        for (let curve of this.curve) {
-            if (curve) {
-                maxTime = Math.max(maxTime, curve.time);
-            }
-            else {
-                console.error(curve);
-            }
-        }
-        this._totalTime = maxTime;
-    }
-    static scaleCurveValue(curve, scale) {
-        if (!curve._InvalidateCache) {
-            for (let i = 0; i < curve.curve.length; i++) {
-                let c = curve.curve[i];
-                c.value *= scale;
-                c.inSlope *= scale;
-                c.outSlope *= scale;
-            }
-        }
-        curve.invalidateCache();
-    }
-}

package/dist/src/math/AnimationCurveClip.d.ts

@@ -1,15 +0,0 @@
-import { AnimationCurveT, BytesArray } from "..";
-export declare class PropertyAnimationClip {
-    clipName: string;
-    loopTime: boolean;
-    startTime: number;
-    stopTime: number;
-    sampleRate: number;
-    useSkeletonPos: boolean;
-    useSkeletonScale: boolean;
-    positionCurves: Map<string, AnimationCurveT>;
-    rotationCurves: Map<string, AnimationCurveT>;
-    scaleCurves: Map<string, AnimationCurveT>;
-    floatCurves: Map<string, AnimationCurveT>;
-    formBytes(bytes: BytesArray): void;
-}

package/dist/src/math/AnimationCurveClip.js

@@ -1,46 +0,0 @@
-import { AnimationCurveT } from "..";
-export class PropertyAnimationClip {
-    constructor() {
-        this.positionCurves = new Map();
-        this.rotationCurves = new Map();
-        this.scaleCurves = new Map();
-        this.floatCurves = new Map();
-    }
-    formBytes(bytes) {
-        this.clipName = bytes.readUTF();
-        this.loopTime = bytes.readInt32() ? false : true;
-        this.startTime = bytes.readFloat32();
-        this.stopTime = bytes.readFloat32();
-        this.sampleRate = bytes.readInt32();
-        this.useSkeletonPos = bytes.readInt32() > 0;
-        this.useSkeletonScale = bytes.readInt32() > 0;
-        if (this.useSkeletonPos) {
-            let positionCurvesCount = bytes.readInt32();
-            for (let i = 0; i < positionCurvesCount; i++) {
-                let curveData = new AnimationCurveT();
-                curveData.formBytes(bytes);
-                this.positionCurves.set(curveData.path, curveData);
-            }
-        }
-        let rotationCurvesCount = bytes.readInt32();
-        for (let i = 0; i < rotationCurvesCount; i++) {
-            let curveData = new AnimationCurveT();
-            curveData.formBytes(bytes);
-            this.rotationCurves.set(curveData.path, curveData);
-        }
-        if (this.useSkeletonScale) {
-            let scaleCurvesCount = bytes.readInt32();
-            for (let i = 0; i < scaleCurvesCount; i++) {
-                let curveData = new AnimationCurveT();
-                curveData.formBytes(bytes);
-                this.scaleCurves.set(curveData.path, curveData);
-            }
-        }
-        let floatCurvesCount = bytes.readInt32();
-        for (let i = 0; i < floatCurvesCount; i++) {
-            let curveData = new AnimationCurveT();
-            curveData.formBytes(bytes);
-            this.floatCurves.set(curveData.attribute, curveData);
-        }
-    }
-}

package/dist/src/math/AnimationCurveT.d.ts

@@ -1,24 +0,0 @@
-import { Keyframe } from "./enum/Keyframe";
-import { AnimationCurve, BytesArray, KeyframeT, Quaternion, Vector2, Vector3, Vector4 } from "..";
-export type CurveValueT = number | Vector2 | Vector3 | Vector4 | Quaternion;
-export declare class AnimationCurveT {
-    path: string;
-    attribute: string;
-    propertys: string[];
-    preInfinity: number;
-    postInfinity: number;
-    rotationOrder: number;
-    m_curves: AnimationCurve[];
-    private k;
-    private _cacheValue;
-    private _kValue;
-    constructor(k?: number);
-    private check;
-    get totalTime(): number;
-    addKeyFrame(keyFrame: KeyframeT): void;
-    removeKeyFrame(keyFrame: KeyframeT): void;
-    getValue(time: number): CurveValueT;
-    getKeyCount(): number;
-    getKey(index: number): Keyframe[];
-    formBytes(bytes: BytesArray): void;
-}

package/dist/src/math/AnimationCurveT.js

@@ -1,105 +0,0 @@
-import { AnimationCurve, KeyframeT, Quaternion, Vector2, Vector3, Vector4, } from "..";
-export class AnimationCurveT {
-    constructor(k = 1) {
-        this.k = 0;
-        this.k = k;
-        this.m_curves = [];
-        this.check();
-    }
-    check() {
-        for (let i = 0; i < this.k; i++) {
-            this.m_curves[i] ||= new AnimationCurve();
-        }
-        switch (this.k) {
-            case 1:
-                this._cacheValue = 0;
-                break;
-            case 2:
-                this._cacheValue = new Vector2();
-                break;
-            case 3:
-                this._cacheValue = new Vector3();
-                break;
-            case 4:
-                this._cacheValue = new Vector4();
-                break;
-            default:
-                break;
-        }
-    }
-    get totalTime() {
-        return this.m_curves[0].totalTime;
-    }
-    addKeyFrame(keyFrame) {
-        for (let i = 0; i < this.k; i++) {
-            this.m_curves[i].addKeyFrame(keyFrame.getK(i));
-        }
-    }
-    removeKeyFrame(keyFrame) {
-        for (let i = 0; i < this.k; i++) {
-            this.m_curves[i].removeKeyFrame(keyFrame.getK(i));
-        }
-    }
-    getValue(time) {
-        switch (this.k) {
-            case 1:
-                this._cacheValue = this.m_curves[0].getValue(time);
-                break;
-            case 2:
-                this._cacheValue.x = this.m_curves[0].getValue(time);
-                this._cacheValue.y = this.m_curves[1].getValue(time);
-                break;
-            case 3:
-                this._cacheValue.x = this.m_curves[0].getValue(time);
-                this._cacheValue.y = this.m_curves[1].getValue(time);
-                this._cacheValue.z = this.m_curves[2].getValue(time);
-                break;
-            case 4:
-                const extent = this.m_curves[0].getCurveFramesExtent(time);
-                const lhsIndex = extent.lhsIndex;
-                const rhsIndex = extent.rhsIndex;
-                time = extent.time;
-                let kL = this.m_curves[0].getKey(lhsIndex);
-                let kR = this.m_curves[0].getKey(rhsIndex);
-                time %= this.m_curves[0].totalTime;
-                let t = (time - kL.time) / (kR.time - kL.time);
-                Quaternion.HELP_0.set(this.m_curves[0].getKey(lhsIndex).value, this.m_curves[1].getKey(lhsIndex).value, this.m_curves[2].getKey(lhsIndex).value, this.m_curves[3].getKey(lhsIndex).value);
-                Quaternion.HELP_1.set(this.m_curves[0].getKey(rhsIndex).value, this.m_curves[1].getKey(rhsIndex).value, this.m_curves[2].getKey(rhsIndex).value, this.m_curves[3].getKey(rhsIndex).value);
-                Quaternion.HELP_2.slerp(Quaternion.HELP_0, Quaternion.HELP_1, t);
-                this._cacheValue.x = Quaternion.HELP_2.x;
-                this._cacheValue.y = Quaternion.HELP_2.y;
-                this._cacheValue.z = Quaternion.HELP_2.z;
-                this._cacheValue.w = Quaternion.HELP_2.w;
-                break;
-            default:
-                break;
-        }
-        return this._cacheValue;
-    }
-    getKeyCount() {
-        return this.m_curves[0].getKeyCount();
-    }
-    getKey(index) {
-        let list = [];
-        for (let i = 0; i < this.k; i++) {
-            list.push(this.m_curves[i].getKey(index));
-        }
-        return list;
-    }
-    formBytes(bytes) {
-        this.path = bytes.readUTF();
-        this.k = bytes.readInt32();
-        this.check();
-        this.attribute = bytes.readUTF();
-        this.propertys = this.attribute.split(".");
-        this.preInfinity = bytes.readInt32();
-        this.postInfinity = bytes.readInt32();
-        this.rotationOrder = bytes.readInt32();
-        let curvesCount = bytes.readInt32();
-        for (let i = 0; i < curvesCount; i++) {
-            let keyframe = new KeyframeT(0);
-            keyframe.formBytes(bytes);
-            this.addKeyFrame(keyframe);
-        }
-    }
-}

package/dist/src/math/BiMap.d.ts

@@ -1,9 +0,0 @@
-export declare class BiMap<K, V> extends Map<K, V> {
-    private readonly negtive;
-    constructor(iterable?: Iterable<readonly [K, V]> | null);
-    delete(key: K): boolean;
-    getKey(value: V): K;
-    deleteValue(value: V): boolean;
-    set(key: K, value: V): this;
-    clear(): void;
-}

package/dist/src/math/BiMap.js

@@ -1,37 +0,0 @@
-//双向map
-export class BiMap extends Map {
-    constructor(iterable) {
-        super(iterable);
-        this.negtive = new Map();
-        if (iterable) {
-            for (let item of iterable) {
-                this.negtive.set(item[1], item[0]);
-            }
-        }
-    }
-    delete(key) {
-        if (this.has(key)) {
-            let value = this.get(key);
-            this.negtive.delete(value);
-            return super.delete(key);
-        }
-        return false;
-    }
-    getKey(value) {
-        return this.negtive.get(value);
-    }
-    deleteValue(value) {
-        let k = this.negtive.get(value);
-        k && this.delete(k);
-        return this.negtive.delete(value);
-    }
-    set(key, value) {
-        super.set(key, value);
-        this.negtive.set(value, key);
-        return this;
-    }
-    clear() {
-        this.negtive.clear();
-        super.clear();
-    }
-}

package/dist/src/math/Color.d.ts

@@ -1,249 +0,0 @@
-export declare class Color {
-    /**
-     * red color
-     */
-    static COLOR_RED: Color;
-    /**
-     * green color
-     */
-    static COLOR_GREEN: Color;
-    /**
-     * blue color
-     */
-    static COLOR_BLUE: Color;
-    /**
-     * white color
-     */
-    static COLOR_WHITE: Color;
-    /**
-     * cache
-     * @internal
-     */
-    static COLOR_0: Color;
-    /**
-     * cache
-     * @internal
-     */
-    static COLOR_1: Color;
-    /**
-     * cache
-     * @internal
-     */
-    static COLOR_2: Color;
-    /**
-     * @internal
-     */
-    private static HEX_CHARACTERS;
-    /**
-     * @internal
-     */
-    private static MATCH_3OR4_HEX;
-    /**
-     * @internal
-     */
-    private static MATCH_6OR8_HEX;
-    /**
-     * @internal
-     */
-    private static NON_HEX_CHARS;
-    /**
-     * @internal
-     */
-    private static VALID_HEX_SIZE;
-    /**
-     * red channel
-     */
-    r: number;
-    /**
-     * green channel
-     */
-    g: number;
-    /**
-     * blue channel
-     */
-    b: number;
-    /**
-     * alpha channel
-     */
-    a: number;
-    constructor(r?: number, g?: number, b?: number, a?: number);
-    convertToHDRRGB(): Color;
-    unSerialized(data: any): this;
-    hexToRGB(value: number): Color;
-    hexToRGBA(value: number): Color;
-    static random(base?: number): Color;
-    static randomRGB(seedR?: number, seedG?: number, seedB?: number, baseR?: number, baseG?: number, baseB?: number): Color;
-    static randomGray(base?: number, random?: number): Color;
-    setTo(r: number, g: number, b: number, a: number): void;
-    setHex(hex: string): void;
-    getHex(): string;
-    /**
-     * get rgb to array
-     */
-    get rgb(): number[];
-    /**
-     * set rgb by array
-     */
-    set rgb(c: number[]);
-    /**
-     * get rgba to array
-     */
-    get rgba(): number[];
-    /**
-     * set rgb by array
-     */
-    set rgba(c: number[]);
-    clone(): Color;
-    copyFrom(src: Color): this;
-    copyFromArray(arr: number[], scalar?: number): this;
-    copyFromVector(value: {
-        x: number;
-        y: number;
-        z: number;
-        w?: number;
-    }): this;
-    static hexRGBColor(hexColor: number, dst?: Color): Color;
-    static lerp(v: number, c1: Color, c2: Color, target?: Color): Color;
-    static PRIMARY: number;
-    static PRIMARYDARK: number;
-    static ACCENT: number;
-    static WHITE: number;
-    static IVORY: number;
-    static LIGHTYELLOW: number;
-    static YELLOW: number;
-    static SNOW: number;
-    static FLORALWHITE: number;
-    static LEMONCHIFFON: number;
-    static CORNSILK: number;
-    static SEASHELL: number;
-    static LAVENDERBLUSH: number;
-    static PAPAYAWHIP: number;
-    static BLANCHEDALMOND: number;
-    static MISTYROSE: number;
-    static BISQUE: number;
-    static MOCCASIN: number;
-    static NAVAJOWHITE: number;
-    static PEACHPUFF: number;
-    static GOLD: number;
-    static PINK: number;
-    static LIGHTPINK: number;
-    static ORANGE: number;
-    static LIGHTSALMON: number;
-    static DARKORANGE: number;
-    static CORAL: number;
-    static HOTPINK: number;
-    static TOMATO: number;
-    static ORANGERED: number;
-    static DEEPPINK: number;
-    static FUCHSIA: number;
-    static MAGENTA: number;
-    static RED: number;
-    static OLDLACE: number;
-    static LIGHTGOLDENRODYELLOW: number;
-    static LINEN: number;
-    static ANTIQUEWHITE: number;
-    static SALMON: number;
-    static GHOSTWHITE: number;
-    static MINTCREAM: number;
-    static WHITESMOKE: number;
-    static BEIGE: number;
-    static WHEAT: number;
-    static SANDYBROWN: number;
-    static AZURE: number;
-    static HONEYDEW: number;
-    static ALICEBLUE: number;
-    static KHAKI: number;
-    static LIGHTCORAL: number;
-    static PALEGOLDENROD: number;
-    static VIOLET: number;
-    static DARKSALMON: number;
-    static LAVENDER: number;
-    static LIGHTCYAN: number;
-    static BURLYWOOD: number;
-    static PLUM: number;
-    static GAINSBORO: number;
-    static CRIMSON: number;
-    static PALEVIOLETRED: number;
-    static GOLDENROD: number;
-    static ORCHID: number;
-    static THISTLE: number;
-    static LIGHTGREY: number;
-    static TAN: number;
-    static CHOCOLATE: number;
-    static PERU: number;
-    static INDIANRED: number;
-    static MEDIUMVIOLETRED: number;
-    static SILVER: number;
-    static DARKKHAKI: number;
-    static ROSYBROWN: number;
-    static MEDIUMORCHID: number;
-    static DARKGOLDENROD: number;
-    static FIREBRICK: number;
-    static POWDERBLUE: number;
-    static LIGHTSTEELBLUE: number;
-    static PALETURQUOISE: number;
-    static GREENYELLOW: number;
-    static LIGHTBLUE: number;
-    static DARKGRAY: number;
-    static BROWN: number;
-    static SIENNA: number;
-    static DARKORCHID: number;
-    static PALEGREEN: number;
-    static DARKVIOLET: number;
-    static MEDIUMPURPLE: number;
-    static LIGHTGREEN: number;
-    static DARKSEAGREEN: number;
-    static SADDLEBROWN: number;
-    static DARKMAGENTA: number;
-    static DARKRED: number;
-    static BLUEVIOLET: number;
-    static LIGHTSKYBLUE: number;
-    static SKYBLUE: number;
-    static GRAY: number;
-    static OLIVE: number;
-    static PURPLE: number;
-    static MAROON: number;
-    static AQUAMARINE: number;
-    static CHARTREUSE: number;
-    static LAWNGREEN: number;
-    static MEDIUMSLATEBLUE: number;
-    static LIGHTSLATEGRAY: number;
-    static SLATEGRAY: number;
-    static OLIVEDRAB: number;
-    static SLATEBLUE: number;
-    static DIMGRAY: number;
-    static MEDIUMAQUAMARINE: number;
-    static CORNFLOWERBLUE: number;
-    static CADETBLUE: number;
-    static DARKOLIVEGREEN: number;
-    static INDIGO: number;
-    static MEDIUMTURQUOISE: number;
-    static DARKSLATEBLUE: number;
-    static STEELBLUE: number;
-    static ROYALBLUE: number;
-    static TURQUOISE: number;
-    static MEDIUMSEAGREEN: number;
-    static LIMEGREEN: number;
-    static DARKSLATEGRAY: number;
-    static SEAGREEN: number;
-    static FORESTGREEN: number;
-    static LIGHTSEAGREEN: number;
-    static DODGERBLUE: number;
-    static MIDNIGHTBLUE: number;
-    static AQUA: number;
-    static CYAN: number;
-    static SPRINGGREEN: number;
-    static LIME: number;
-    static MEDIUMSPRINGGREEN: number;
-    static DARKTURQUOISE: number;
-    static DEEPSKYBLUE: number;
-    static DARKCYAN: number;
-    static TEAL: number;
-    static GREEN: number;
-    static DARKGREEN: number;
-    static BLUE: number;
-    static MEDIUMBLUE: number;
-    static DARKBLUE: number;
-    static NAVY: number;
-    static BLACK: number;
-}