@galacean/engine-core 0.0.0-experimental-animator-additive.1

package/types/mesh/ModelMesh.d.ts

@@ -0,0 +1,226 @@
+import { Color, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
+import { Engine } from "../Engine";
+import { Buffer } from "../graphic/Buffer";
+import { Mesh } from "../graphic/Mesh";
+import { VertexBufferBinding } from "../graphic/VertexBufferBinding";
+import { VertexElement } from "../graphic/VertexElement";
+import { BlendShape } from "./BlendShape";
+/**
+ * Mesh containing common vertex elements of the model.
+ */
+export declare class ModelMesh extends Mesh {
+    private static _tempVec0;
+    private static _tempVec1;
+    private static _tempVec2;
+    private static _tempVec3;
+    private static _tempVec4;
+    private _vertexCount;
+    private _accessible;
+    private _verticesFloat32;
+    private _verticesUint8;
+    private _indices;
+    private _indicesFormat;
+    private _indicesChangeFlag;
+    private _positions;
+    private _normals;
+    private _colors;
+    private _tangents;
+    private _uv;
+    private _uv1;
+    private _uv2;
+    private _uv3;
+    private _uv4;
+    private _uv5;
+    private _uv6;
+    private _uv7;
+    private _boneWeights;
+    private _boneIndices;
+    private _bufferStrides;
+    private _vertexBufferUpdateFlag;
+    private _vertexDataUpdateFlag;
+    private _vertexElementsUpdate;
+    private _customVertexElements;
+    private _vertexCountChanged;
+    /**
+     * Whether to access data of the mesh.
+     */
+    get accessible(): boolean;
+    /**
+     * Vertex count of current mesh.
+     */
+    get vertexCount(): number;
+    /**
+     * Vertex element collection.
+     */
+    get vertexElements(): Readonly<VertexElement[]>;
+    /**
+     * Vertex buffer binding collection.
+     */
+    get vertexBufferBindings(): Readonly<VertexBufferBinding[]>;
+    /**
+     * BlendShapes of this ModelMesh.
+     */
+    get blendShapes(): Readonly<BlendShape[]>;
+    /**
+     * BlendShape count of this ModelMesh.
+     */
+    get blendShapeCount(): number;
+    /**
+     * Create a model mesh.
+     * @param engine - Engine to which the mesh belongs
+     * @param name - Mesh name
+     */
+    constructor(engine: Engine, name?: string);
+    /**
+     * Set positions for the mesh.
+     * @param positions - The positions for the mesh.
+     */
+    setPositions(positions: Vector3[] | null): void;
+    /**
+     * Get positions for the mesh.
+     * @remarks Please call the setPositions() method after modification to ensure that the modification takes effect.
+     */
+    getPositions(): Vector3[] | null;
+    /**
+     * Set per-vertex normals for the mesh.
+     * @param normals - The normals for the mesh.
+     */
+    setNormals(normals: Vector3[] | null): void;
+    /**
+     * Get normals for the mesh.
+     * @remarks Please call the setNormals() method after modification to ensure that the modification takes effect.
+     */
+    getNormals(): Vector3[] | null;
+    /**
+     * Set per-vertex colors for the mesh.
+     * @param colors - The colors for the mesh.
+     */
+    setColors(colors: Color[] | null): void;
+    /**
+     * Get colors for the mesh.
+     * @remarks Please call the setColors() method after modification to ensure that the modification takes effect.
+     */
+    getColors(): Color[] | null;
+    /**
+     * Set per-vertex bone weights for the mesh.
+     * @param boneWeights - The bone weights for the mesh.
+     */
+    setBoneWeights(boneWeights: Vector4[] | null): void;
+    /**
+     * Get weights for the mesh.
+     * @remarks Please call the setWeights() method after modification to ensure that the modification takes effect.
+     */
+    getBoneWeights(): Vector4[] | null;
+    /**
+     * Set per-vertex bone indices for the mesh.
+     * @param boneIndices - The bone indices for the mesh.
+     */
+    setBoneIndices(boneIndices: Vector4[] | null): void;
+    /**
+     * Get joints for the mesh.
+     * @remarks Please call the setBoneIndices() method after modification to ensure that the modification takes effect.
+     */
+    getBoneIndices(): Vector4[] | null;
+    /**
+     * Set per-vertex tangents for the mesh.
+     * @param tangents - The tangents for the mesh.
+     */
+    setTangents(tangents: Vector4[] | null): void;
+    /**
+     * Get tangents for the mesh.
+     * @remarks Please call the setTangents() method after modification to ensure that the modification takes effect.
+     */
+    getTangents(): Vector4[] | null;
+    /**
+     * Set per-vertex uv for the mesh.
+     * @param uv - The uv for the mesh.
+     */
+    setUVs(uv: Vector2[] | null): void;
+    /**
+     * Set per-vertex uv for the mesh by channelIndex.
+     * @param uv - The uv for the mesh.
+     * @param channelIndex - The index of uv channels, in [0 ~ 7] range.
+     */
+    setUVs(uv: Vector2[] | null, channelIndex: number): void;
+    /**
+     * Get uv for the mesh.
+     * @remarks Please call the setUV() method after modification to ensure that the modification takes effect.
+     */
+    getUVs(): Vector2[] | null;
+    /**
+     * Get uv for the mesh by channelIndex.
+     * @param channelIndex - The index of uv channels, in [0 ~ 7] range.
+     * @remarks Please call the setUV() method after modification to ensure that the modification takes effect.
+     */
+    getUVs(channelIndex: number): Vector2[] | null;
+    /**
+     * Set indices for the mesh.
+     * @param indices - The indices for the mesh.
+     */
+    setIndices(indices: Uint8Array | Uint16Array | Uint32Array): void;
+    /**
+     * Get indices for the mesh.
+     */
+    getIndices(): Uint8Array | Uint16Array | Uint32Array;
+    /**
+     * @beta
+     * @todo Update buffer should support custom vertex elements.
+     * Set vertex elements.
+     * @param elements - Vertex element collection
+     */
+    setVertexElements(elements: VertexElement[]): void;
+    /**
+     * @beta
+     * Set vertex buffer binding.
+     * @param vertexBufferBindings - Vertex buffer binding
+     * @param index - Vertex buffer index, the default value is 0
+     */
+    setVertexBufferBinding(vertexBufferBindings: VertexBufferBinding, index?: number): void;
+    /**
+     * @beta
+     * Set vertex buffer binding.
+     * @param vertexBuffer - Vertex buffer
+     * @param stride - Vertex buffer data stride
+     * @param index - Vertex buffer index, the default value is 0
+     */
+    setVertexBufferBinding(vertexBuffer: Buffer, stride: number, index?: number): void;
+    /**
+     * Set vertex buffer binding.
+     * @param vertexBufferBindings - Vertex buffer binding
+     * @param firstIndex - First vertex buffer index, the default value is 0
+     */
+    setVertexBufferBindings(vertexBufferBindings: VertexBufferBinding[], firstIndex?: number): void;
+    /**
+     * Add a BlendShape for this ModelMesh.
+     * @param blendShape - The BlendShape
+     */
+    addBlendShape(blendShape: BlendShape): void;
+    /**
+     * Clear all BlendShapes.
+     */
+    clearBlendShapes(): void;
+    /**
+     * Get name of BlendShape by given index.
+     * @param index - The index of BlendShape
+     * @returns The name of BlendShape
+     */
+    getBlendShapeName(index: number): string;
+    /**
+     * Upload Mesh Data to GPU.
+     * @param noLongerAccessible - Whether to access data later. If true, you'll never access data anymore (free memory cache)
+     */
+    uploadData(noLongerAccessible: boolean): void;
+    /**
+     * Calculate mesh tangent.
+     * @remark need to set positions(with or not with indices), normals, uv before calculation.
+     * @remark based on http://foundationsofgameenginedev.com/FGED2-sample.pdf
+     */
+    calculateTangents(): void;
+    private _supplementaryVertexElements;
+    private _updateVertexElements;
+    private _updateVertices;
+    private _insertVertexAttribute;
+    private _getAttributeFormat;
+    private _getAttributeByteLength;
+    private _releaseCache;
+}

package/types/mesh/PrimitiveMesh.d.ts

@@ -0,0 +1,86 @@
+import { Engine } from "../Engine";
+import { ModelMesh } from "./ModelMesh";
+/**
+ * Used to generate common primitive meshes.
+ */
+export declare class PrimitiveMesh {
+    /**
+     * Create a sphere mesh.
+     * @param engine - Engine
+     * @param radius - Sphere radius
+     * @param segments - Number of segments
+     * @param noLongerAccessible - No longer access the vertices of the mesh after creation
+     * @returns Sphere model mesh
+     */
+    static createSphere(engine: Engine, radius?: number, segments?: number, noLongerAccessible?: boolean): ModelMesh;
+    /**
+     * Create a cuboid mesh.
+     * @param engine - Engine
+     * @param width - Cuboid width
+     * @param height - Cuboid height
+     * @param depth - Cuboid depth
+     * @param noLongerAccessible - No longer access the vertices of the mesh after creation
+     * @returns Cuboid model mesh
+     */
+    static createCuboid(engine: Engine, width?: number, height?: number, depth?: number, noLongerAccessible?: boolean): ModelMesh;
+    /**
+     * Create a plane mesh.
+     * @param engine - Engine
+     * @param width - Plane width
+     * @param height - Plane height
+     * @param horizontalSegments - Plane horizontal segments
+     * @param verticalSegments - Plane vertical segments
+     * @param noLongerAccessible - No longer access the vertices of the mesh after creation
+     * @returns Plane model mesh
+     */
+    static createPlane(engine: Engine, width?: number, height?: number, horizontalSegments?: number, verticalSegments?: number, noLongerAccessible?: boolean): ModelMesh;
+    /**
+     * Create a cylinder mesh.
+     * @param engine - Engine
+     * @param radiusTop - The radius of top cap
+     * @param radiusBottom - The radius of bottom cap
+     * @param height - The height of torso
+     * @param radialSegments - Cylinder radial segments
+     * @param heightSegments - Cylinder height segments
+     * @param noLongerAccessible - No longer access the vertices of the mesh after creation
+     * @returns Cylinder model mesh
+     */
+    static createCylinder(engine: Engine, radiusTop?: number, radiusBottom?: number, height?: number, radialSegments?: number, heightSegments?: number, noLongerAccessible?: boolean): ModelMesh;
+    /**
+     * Create a torus mesh.
+     * @param engine - Engine
+     * @param radius - Torus radius
+     * @param tubeRadius - Torus tube
+     * @param radialSegments - Torus radial segments
+     * @param tubularSegments - Torus tubular segments
+     * @param arc - Central angle
+     * @param noLongerAccessible - No longer access the vertices of the mesh after creation
+     * @returns Torus model mesh
+     */
+    static createTorus(engine: Engine, radius?: number, tubeRadius?: number, radialSegments?: number, tubularSegments?: number, arc?: number, noLongerAccessible?: boolean): ModelMesh;
+    /**
+     * Create a cone mesh.
+     * @param engine - Engine
+     * @param radius - The radius of cap
+     * @param height - The height of torso
+     * @param radialSegments - Cylinder radial segments
+     * @param heightSegments - Cylinder height segments
+     * @param noLongerAccessible - No longer access the vertices of the mesh after creation
+     * @returns Cone model mesh
+     */
+    static createCone(engine: Engine, radius?: number, height?: number, radialSegments?: number, heightSegments?: number, noLongerAccessible?: boolean): ModelMesh;
+    /**
+     * Create a capsule mesh.
+     * @param engine - Engine
+     * @param radius - The radius of the two hemispherical ends
+     * @param height - The height of the cylindrical part, measured between the centers of the hemispherical ends
+     * @param radialSegments - Hemispherical end radial segments
+     * @param heightSegments - Cylindrical part height segments
+     * @param noLongerAccessible - No longer access the vertices of the mesh after creation
+     * @returns Capsule model mesh
+     */
+    static createCapsule(engine: Engine, radius?: number, height?: number, radialSegments?: number, heightSegments?: number, noLongerAccessible?: boolean): ModelMesh;
+    private static _initialize;
+    private static _generateIndices;
+    private static _createCapsuleCap;
+}

package/types/mesh/PrimitiveMeshRestorer.d.ts

@@ -0,0 +1 @@
+export {};

package/types/mesh/Skin.d.ts

@@ -0,0 +1,16 @@
+import { Matrix } from "@galacean/engine-math";
+import { EngineObject } from "../base/EngineObject";
+/**
+ * Mesh skin data, equal glTF skins define
+ */
+export declare class Skin extends EngineObject {
+    name: string;
+    inverseBindMatrices: Matrix[];
+    joints: string[];
+    skeleton: string;
+    /**
+     * Constructor of skin
+     * @param name - name
+     */
+    constructor(name: string);
+}

package/types/mesh/SkinnedMeshRenderer.d.ts

@@ -0,0 +1,62 @@
+import { BoundingBox } from "@galacean/engine-math";
+import { Entity } from "../Entity";
+import { RenderContext } from "../RenderPipeline/RenderContext";
+import { MeshRenderer } from "./MeshRenderer";
+import { Skin } from "./Skin";
+/**
+ * SkinnedMeshRenderer.
+ */
+export declare class SkinnedMeshRenderer extends MeshRenderer {
+    private static _tempMatrix;
+    private static _jointCountProperty;
+    private static _jointSamplerProperty;
+    private static _jointMatrixProperty;
+    private _hasInitSkin;
+    private _jointDataCreateCache;
+    private _skin;
+    private _blendShapeWeights;
+    private _maxVertexUniformVectors;
+    private _rootBone;
+    private _localBounds;
+    private _jointMatrices;
+    private _jointTexture;
+    private _jointEntities;
+    /**
+     * The weights of the BlendShapes.
+     * @remarks Array index is BlendShape index.
+     */
+    get blendShapeWeights(): Float32Array;
+    set blendShapeWeights(value: Float32Array);
+    /**
+     * Skin Object.
+     */
+    get skin(): Skin;
+    set skin(value: Skin);
+    /**
+     * Local bounds.
+     */
+    get localBounds(): BoundingBox;
+    set localBounds(value: BoundingBox);
+    /**
+     * Root bone.
+     */
+    get rootBone(): Entity;
+    set rootBone(value: Entity);
+    /**
+     * @override
+     */
+    protected _updateShaderData(context: RenderContext): void;
+    /**
+     * @override
+     */
+    protected _registerEntityTransformListener(): void;
+    /**
+     * @override
+     */
+    protected _updateBounds(worldBounds: BoundingBox): void;
+    private _initSkin;
+    private _computeApproximateBindMatrix;
+    private _findByEntityName;
+    private _checkBlendShapeWeightLength;
+    private _onLocalBoundsChanged;
+}

package/types/mesh/enums/VertexAttribute.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Vertex attribute types of a vertex in a ModelMesh.
+ */
+export declare enum VertexAttribute {
+    /** Vertex position. */
+    Position = "POSITION",
+    /** Vertex normal. */
+    Normal = "NORMAL",
+    /** Vertex color. */
+    Color = "COLOR_0",
+    /** Vertex tangent. */
+    Tangent = "TANGENT",
+    /** Vertex bone weight. */
+    BoneWeight = "WEIGHTS_0",
+    /** Vertex bone index. */
+    BoneIndex = "JOINTS_0",
+    /** Vertex UV. */
+    UV = "TEXCOORD_0",
+    /** Vertex UV1. */
+    UV1 = "TEXCOORD_1",
+    /** Vertex UV2. */
+    UV2 = "TEXCOORD_2",
+    /** Vertex UV3. */
+    UV3 = "TEXCOORD_3",
+    /** Vertex UV4. */
+    UV4 = "TEXCOORD_4",
+    /** Vertex UV5. */
+    UV5 = "TEXCOORD_5",
+    /** Vertex UV6. */
+    UV6 = "TEXCOORD_6",
+    /** Vertex UV7. */
+    UV7 = "TEXCOORD_7"
+}

package/types/mesh/index.d.ts

@@ -0,0 +1,8 @@
+export { ModelMesh } from "./ModelMesh";
+export { Skin } from "./Skin";
+export { MeshRenderer } from "./MeshRenderer";
+export { SkinnedMeshRenderer } from "./SkinnedMeshRenderer";
+export { PrimitiveMesh } from "./PrimitiveMesh";
+export { BufferMesh } from "./BufferMesh";
+export { BlendShape } from "./BlendShape";
+export { BlendShapeFrame } from "./BlendShapeFrame";

package/types/particle/ParticleRenderer.d.ts

@@ -0,0 +1,235 @@
+import { Vector3, Color } from "@galacean/engine-math";
+import { Texture } from "../texture";
+import { MeshRenderer } from "../mesh/MeshRenderer";
+/**
+ * Blend mode enums of the particle renderer's material.
+ */
+export declare enum ParticleRendererBlendMode {
+    Transparent = 0,
+    Additive = 1
+}
+/**
+ * Particle Renderer Component.
+ */
+export declare class ParticleRenderer extends MeshRenderer {
+    /** The max number of indices that Uint16Array can support. */
+    private static _uint16VertexLimit;
+    private static _getRandom;
+    private _vertexStride;
+    private _vertices;
+    private _vertexBuffer;
+    private _maxCount;
+    private _position;
+    private _positionRandomness;
+    private _positionArray;
+    private _velocity;
+    private _velocityRandomness;
+    private _acceleration;
+    private _accelerationRandomness;
+    private _color;
+    private _colorRandomness;
+    private _size;
+    private _sizeRandomness;
+    private _alpha;
+    private _alphaRandomness;
+    private _startAngle;
+    private _startAngleRandomness;
+    private _rotateVelocity;
+    private _rotateVelocityRandomness;
+    private _lifetime;
+    private _startTimeRandomness;
+    private _scale;
+    private _isOnce;
+    private _onceTime;
+    private _time;
+    private _isInit;
+    private _isStart;
+    private _updateDirtyFlag;
+    private _isRotateToVelocity;
+    private _isUseOriginColor;
+    private _isScaleByLifetime;
+    private _is2d;
+    private _isFadeIn;
+    private _isFadeOut;
+    private _playOnEnable;
+    private _blendMode;
+    /**
+     * Sprite sheet of texture.
+     */
+    spriteSheet: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }[];
+    /**
+     * Texture of particle.
+     */
+    get texture(): Texture;
+    set texture(texture: Texture);
+    /**
+     * Position of particles.
+     */
+    get position(): Vector3;
+    set position(value: Vector3);
+    /**
+     * Random range of positions.
+     */
+    get positionRandomness(): Vector3;
+    set positionRandomness(value: Vector3);
+    /**
+     * Array of fixed positions.
+     */
+    get positionArray(): Vector3[];
+    set positionArray(value: Vector3[]);
+    /**
+     * Velocity of particles.
+     */
+    get velocity(): Vector3;
+    set velocity(value: Vector3);
+    /**
+     * Random range of velocity.
+     */
+    get velocityRandomness(): Vector3;
+    set velocityRandomness(value: Vector3);
+    /**
+     * Acceleration of particles.
+     */
+    get acceleration(): Vector3;
+    set acceleration(value: Vector3);
+    /**
+     * Random range of acceleration.
+     */
+    get accelerationRandomness(): Vector3;
+    set accelerationRandomness(value: Vector3);
+    /**
+     * Color of particles.
+     */
+    get color(): Color;
+    set color(value: Color);
+    /**
+     * Random range of color.
+     */
+    get colorRandomness(): number;
+    set colorRandomness(value: number);
+    /**
+     * Size of particles.
+     */
+    get size(): number;
+    set size(value: number);
+    /**
+     * Random range of size.
+     */
+    get sizeRandomness(): number;
+    set sizeRandomness(value: number);
+    /**
+     * Alpha of particles.
+     */
+    get alpha(): number;
+    set alpha(value: number);
+    /**
+     * Random range of alpha.
+     */
+    get alphaRandomness(): number;
+    set alphaRandomness(value: number);
+    /**
+     * Angle of particles.
+     */
+    get angle(): number;
+    set angle(value: number);
+    /**
+     * Random range of angle.
+     */
+    get angleRandomness(): number;
+    set angleRandomness(value: number);
+    /**
+     * Rotate velocity of particles.
+     */
+    get rotateVelocity(): number;
+    set rotateVelocity(value: number);
+    /**
+     * Random range of rotate velocity.
+     */
+    get rotateVelocityRandomness(): number;
+    set rotateVelocityRandomness(value: number);
+    /**
+     * Lifetime of particles.
+     */
+    get lifetime(): number;
+    set lifetime(value: number);
+    /**
+     * Random range of start time.
+     */
+    get startTimeRandomness(): number;
+    set startTimeRandomness(value: number);
+    /**
+     * Scale factor of particles.
+     */
+    get scale(): number;
+    set scale(value: number);
+    /**
+     * Max count of particles.
+     */
+    get maxCount(): number;
+    set maxCount(value: number);
+    /**
+     * Whether play once.
+     */
+    get isOnce(): boolean;
+    set isOnce(value: boolean);
+    /**
+     * Whether follow the direction of velocity.
+     */
+    get isRotateToVelocity(): boolean;
+    set isRotateToVelocity(value: boolean);
+    /**
+     * Whether use origin color.
+     */
+    get isUseOriginColor(): boolean;
+    set isUseOriginColor(value: boolean);
+    /**
+     * Whether scale by lifetime.
+     */
+    get isScaleByLifetime(): boolean;
+    set isScaleByLifetime(value: boolean);
+    /**
+     * Whether 2D rendering.
+     */
+    get is2d(): boolean;
+    set is2d(value: boolean);
+    /**
+     * Whether fade in.
+     */
+    get isFadeIn(): boolean;
+    set isFadeIn(value: boolean);
+    /**
+     * Whether fade out.
+     */
+    get isFadeOut(): boolean;
+    set isFadeOut(value: boolean);
+    /**
+     * Whether play on enable.
+     */
+    get playOnEnable(): boolean;
+    set playOnEnable(value: boolean);
+    /**
+     * Blend mode of the particle renderer's material.
+     */
+    get blendMode(): ParticleRendererBlendMode;
+    set blendMode(value: ParticleRendererBlendMode);
+    constructor(props: any);
+    /**
+     * Start emitting.
+     */
+    start(): void;
+    /**
+     * Stop emitting.
+     */
+    stop(): void;
+    private _createMaterial;
+    private _createMesh;
+    private _updateBuffer;
+    private _updateSingleBuffer;
+    private _updateSingleUv;
+    private _onColorChanged;
+}

package/types/particle/index.d.ts

@@ -0,0 +1 @@
+export { ParticleRenderer, ParticleRendererBlendMode } from "./ParticleRenderer";