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

package/types/lighting/SpotLight.d.ts

@@ -0,0 +1,36 @@
+import { Vector3 } from "@galacean/engine-math";
+import { Light } from "./Light";
+/**
+ * Spot light.
+ */
+export declare class SpotLight extends Light {
+    private static _cullingMaskProperty;
+    private static _colorProperty;
+    private static _positionProperty;
+    private static _directionProperty;
+    private static _distanceProperty;
+    private static _angleCosProperty;
+    private static _penumbraCosProperty;
+    private static _combinedData;
+    /** Defines a distance cutoff at which the light's intensity must be considered zero. */
+    distance: number;
+    /** Angle, in radians, from centre of spotlight where falloff begins. */
+    angle: number;
+    /** Angle, in radians, from falloff begins to ends. */
+    penumbra: number;
+    private _forward;
+    private _inverseDirection;
+    private _projectMatrix;
+    /**
+     * Get light position.
+     */
+    get position(): Vector3;
+    /**
+     * Get light direction.
+     */
+    get direction(): Vector3;
+    /**
+     * Get the opposite direction of the spotlight.
+     */
+    get reverseDirection(): Vector3;
+}

package/types/lighting/enums/DiffuseMode.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Diffuse mode.
+ */
+export declare enum DiffuseMode {
+    /** Solid color mode. */
+    SolidColor = 0,
+    /**
+     * SH mode
+     * @remarks
+     * Use SH3 to represent irradiance environment maps efficiently, allowing for interactive rendering of diffuse objects under distant illumination.
+     */
+    SphericalHarmonics = 1
+}

package/types/lighting/index.d.ts

@@ -0,0 +1,6 @@
+export { AmbientLight } from "./AmbientLight";
+export { DirectLight } from "./DirectLight";
+export { DiffuseMode } from "./enums/DiffuseMode";
+export { Light } from "./Light";
+export { PointLight } from "./PointLight";
+export { SpotLight } from "./SpotLight";

package/types/material/BaseMaterial.d.ts

@@ -0,0 +1,88 @@
+import { Engine } from "../Engine";
+import { Shader } from "../shader";
+import { ShaderMacro } from "../shader/ShaderMacro";
+import { BlendMode } from "./enums/BlendMode";
+import { RenderFace } from "./enums/RenderFace";
+import { Material } from "./Material";
+export declare class BaseMaterial extends Material {
+    protected static _baseColorProp: import("../shader").ShaderProperty;
+    protected static _baseTextureProp: import("../shader").ShaderProperty;
+    protected static _baseTextureMacro: ShaderMacro;
+    protected static _tilingOffsetProp: import("../shader").ShaderProperty;
+    protected static _normalTextureProp: import("../shader").ShaderProperty;
+    protected static _normalIntensityProp: import("../shader").ShaderProperty;
+    protected static _normalTextureMacro: ShaderMacro;
+    protected static _emissiveColorProp: import("../shader").ShaderProperty;
+    protected static _emissiveTextureProp: import("../shader").ShaderProperty;
+    protected static _emissiveTextureMacro: ShaderMacro;
+    protected static _transparentMacro: ShaderMacro;
+    private static _alphaCutoffProp;
+    private static _alphaCutoffMacro;
+    private _renderFace;
+    private _isTransparent;
+    private _blendMode;
+    /**
+     * Shader used by the material.
+     */
+    get shader(): Shader;
+    set shader(value: Shader);
+    /**
+     * Whethor transparent of first shader pass render state.
+     */
+    get isTransparent(): boolean;
+    set isTransparent(value: boolean);
+    /**
+     * Blend mode of first shader pass render state.
+     * @remarks Only take effect when `isTransparent` is `true`.
+     */
+    get blendMode(): BlendMode;
+    set blendMode(value: BlendMode);
+    /**
+     * Alpha cutoff value.
+     * @remarks
+     * Fragments with alpha channel lower than cutoff value will be discarded.
+     * `0` means no fragment will be discarded.
+     */
+    get alphaCutoff(): number;
+    set alphaCutoff(value: number);
+    /**
+     * Face for render of first shader pass render state.
+     */
+    get renderFace(): RenderFace;
+    set renderFace(value: RenderFace);
+    /**
+     * Create a BaseMaterial instance.
+     * @param engine - Engine to which the material belongs
+     * @param shader - Shader used by the material
+     */
+    constructor(engine: Engine, shader: Shader);
+    /**
+     * Set if is transparent of the shader pass render state.
+     * @param passIndex - Shader pass index
+     * @param isTransparent - If is transparent
+     */
+    setIsTransparent(passIndex: number, isTransparent: boolean): void;
+    /**
+     * Set the blend mode of shader pass render state.
+     * @param passIndex - Shader pass index
+     * @param blendMode - Blend mode
+     */
+    setBlendMode(passIndex: number, blendMode: BlendMode): void;
+    /**
+     * Set the render face of shader pass render state.
+     * @param passIndex - Shader pass index
+     * @param renderFace - Render face
+     */
+    setRenderFace(passIndex: number, renderFace: RenderFace): void;
+    /**
+     * @override
+     * Clone and return the instance.
+     */
+    clone(): BaseMaterial;
+    /**
+     * @override
+     * Clone to the target material.
+     * @param target - target material
+     */
+    cloneTo(target: BaseMaterial): void;
+}

package/types/material/BlinnPhongMaterial.d.ts

@@ -0,0 +1,71 @@
+import { Color, Vector4 } from "@galacean/engine-math";
+import { Engine } from "../Engine";
+import { Texture2D } from "../texture/Texture2D";
+import { BaseMaterial } from "./BaseMaterial";
+/**
+ * Blinn-phong Material.
+ */
+export declare class BlinnPhongMaterial extends BaseMaterial {
+    private static _specularColorProp;
+    private static _shininessProp;
+    private static _specularTextureProp;
+    /**
+     * Base color.
+     */
+    get baseColor(): Color;
+    set baseColor(value: Color);
+    /**
+     * Base texture.
+     */
+    get baseTexture(): Texture2D;
+    set baseTexture(value: Texture2D);
+    /**
+     * Specular color.
+     */
+    get specularColor(): Color;
+    set specularColor(value: Color);
+    /**
+     * Specular texture.
+     */
+    get specularTexture(): Texture2D;
+    set specularTexture(value: Texture2D);
+    /**
+     * Emissive color.
+     */
+    get emissiveColor(): Color;
+    set emissiveColor(value: Color);
+    /**
+     * Emissive texture.
+     */
+    get emissiveTexture(): Texture2D;
+    set emissiveTexture(value: Texture2D);
+    /**
+     * Normal texture.
+     */
+    get normalTexture(): Texture2D;
+    set normalTexture(value: Texture2D);
+    /**
+     * Normal texture intensity.
+     */
+    get normalIntensity(): number;
+    set normalIntensity(value: number);
+    /**
+     * Set the specular reflection coefficient, the larger the value, the more convergent the specular reflection effect.
+     */
+    get shininess(): number;
+    set shininess(value: number);
+    /**
+     * Tiling and offset of main textures.
+     */
+    get tilingOffset(): Vector4;
+    set tilingOffset(value: Vector4);
+    /**
+     * Create a BlinnPhong material instance.
+     * @param engine - Engine to which the material belongs
+     */
+    constructor(engine: Engine);
+    /**
+     * @override
+     */
+    clone(): BlinnPhongMaterial;
+}

package/types/material/Material.d.ts

@@ -0,0 +1,51 @@
+import { IClone } from "@galacean/engine-design";
+import { RefObject } from "../asset/RefObject";
+import { Engine } from "../Engine";
+import { Shader } from "../shader/Shader";
+import { ShaderData } from "../shader/ShaderData";
+import { RenderState } from "../shader/state/RenderState";
+/**
+ * Material.
+ */
+export declare class Material extends RefObject implements IClone {
+    /** Name. */
+    name: string;
+    /** Shader data. */
+    readonly shaderData: ShaderData;
+    /**
+     * Shader used by the material.
+     */
+    get shader(): Shader;
+    set shader(value: Shader);
+    /**
+     * First Render state.
+     */
+    get renderState(): RenderState;
+    /**
+     * Render states.
+     */
+    get renderStates(): Readonly<RenderState[]>;
+    /**
+     * Create a material instance.
+     * @param engine - Engine to which the material belongs
+     * @param shader - Shader used by the material
+     */
+    constructor(engine: Engine, shader: Shader);
+    /**
+     * Clone and return the instance.
+     */
+    clone(): Material;
+    /**
+     * Clone to the target material.
+     * @param target - target material
+     */
+    cloneTo(target: Material): void;
+    /**
+     * @override
+     */
+    _addRefCount(value: number): void;
+    /**
+     * @override
+     */
+    protected _onDestroy(): void;
+}

package/types/material/PBRBaseMaterial.d.ts

@@ -0,0 +1,101 @@
+import { Color, Vector4 } from "@galacean/engine-math";
+import { Engine } from "../Engine";
+import { Shader } from "../shader/Shader";
+import { Texture2D } from "../texture/Texture2D";
+import { BaseMaterial } from "./BaseMaterial";
+import { TextureCoordinate } from "./enums/TextureCoordinate";
+/**
+ * PBR (Physically-Based Rendering) Material.
+ */
+export declare abstract class PBRBaseMaterial extends BaseMaterial {
+    private static _occlusionTextureIntensityProp;
+    private static _occlusionTextureCoordProp;
+    private static _occlusionTextureProp;
+    private static _clearCoatProp;
+    private static _clearCoatTextureProp;
+    private static _clearCoatRoughnessProp;
+    private static _clearCoatRoughnessTextureProp;
+    private static _clearCoatNormalTextureProp;
+    /**
+     * Base color.
+     */
+    get baseColor(): Color;
+    set baseColor(value: Color);
+    /**
+     * Base texture.
+     */
+    get baseTexture(): Texture2D;
+    set baseTexture(value: Texture2D);
+    /**
+     * Normal texture.
+     */
+    get normalTexture(): Texture2D;
+    set normalTexture(value: Texture2D);
+    /**
+     * Normal texture intensity.
+     */
+    get normalTextureIntensity(): number;
+    set normalTextureIntensity(value: number);
+    /**
+     * Emissive color.
+     */
+    get emissiveColor(): Color;
+    set emissiveColor(value: Color);
+    /**
+     * Emissive texture.
+     */
+    get emissiveTexture(): Texture2D;
+    set emissiveTexture(value: Texture2D);
+    /**
+     * Occlusion texture.
+     */
+    get occlusionTexture(): Texture2D;
+    set occlusionTexture(value: Texture2D);
+    /**
+     * Occlusion texture intensity.
+     */
+    get occlusionTextureIntensity(): number;
+    set occlusionTextureIntensity(value: number);
+    /**
+     * Occlusion texture uv coordinate.
+     * @remarks Must be UV0 or UV1.
+     */
+    get occlusionTextureCoord(): TextureCoordinate;
+    set occlusionTextureCoord(value: TextureCoordinate);
+    /**
+     * Tiling and offset of main textures.
+     */
+    get tilingOffset(): Vector4;
+    set tilingOffset(value: Vector4);
+    /**
+     * The clearCoat layer intensity, default 0.
+     */
+    get clearCoat(): number;
+    set clearCoat(value: number);
+    /**
+     * The clearCoat layer intensity texture.
+     */
+    get clearCoatTexture(): Texture2D;
+    set clearCoatTexture(value: Texture2D);
+    /**
+     * The clearCoat layer roughness, default 0.
+     */
+    get clearCoatRoughness(): number;
+    set clearCoatRoughness(value: number);
+    /**
+     * The clearCoat layer roughness texture.
+     */
+    get clearCoatRoughnessTexture(): Texture2D;
+    set clearCoatRoughnessTexture(value: Texture2D);
+    /**
+     * The clearCoat normal map texture.
+     */
+    get clearCoatNormalTexture(): Texture2D;
+    set clearCoatNormalTexture(value: Texture2D);
+    /**
+     * Create a pbr base material instance.
+     * @param engine - Engine to which the material belongs
+     * @param shader - Shader used by the material
+     */
+    protected constructor(engine: Engine, shader: Shader);
+}

package/types/material/PBRMaterial.d.ts

@@ -0,0 +1,36 @@
+import { Engine } from "../Engine";
+import { Texture2D } from "../texture/Texture2D";
+import { PBRBaseMaterial } from "./PBRBaseMaterial";
+/**
+ * PBR (Metallic-Roughness Workflow) Material.
+ */
+export declare class PBRMaterial extends PBRBaseMaterial {
+    private static _metallicProp;
+    private static _roughnessProp;
+    private static _roughnessMetallicTextureProp;
+    /**
+     * Metallic, default 1.0.
+     */
+    get metallic(): number;
+    set metallic(value: number);
+    /**
+     * Roughness, default 1.0.
+     */
+    get roughness(): number;
+    set roughness(value: number);
+    /**
+     * Roughness metallic texture.
+     * @remarks G channel is roughness, B channel is metallic
+     */
+    get roughnessMetallicTexture(): Texture2D;
+    set roughnessMetallicTexture(value: Texture2D);
+    /**
+     * Create a pbr metallic-roughness workflow material instance.
+     * @param engine - Engine to which the material belongs
+     */
+    constructor(engine: Engine);
+    /**
+     * @override
+     */
+    clone(): PBRMaterial;
+}

package/types/material/PBRSpecularMaterial.d.ts

@@ -0,0 +1,38 @@
+import { Color } from "@galacean/engine-math";
+import { Engine } from "../Engine";
+import { Texture2D } from "../texture/Texture2D";
+import { PBRBaseMaterial } from "./PBRBaseMaterial";
+/**
+ * PBR (Specular-Glossiness Workflow) Material.
+ */
+export declare class PBRSpecularMaterial extends PBRBaseMaterial {
+    private static _specularColorProp;
+    private static _glossinessProp;
+    private static _specularGlossinessTextureProp;
+    private static _specularGlossinessTextureMacro;
+    /**
+     * Specular color.
+     */
+    get specularColor(): Color;
+    set specularColor(value: Color);
+    /**
+     * Glossiness.
+     */
+    get glossiness(): number;
+    set glossiness(value: number);
+    /**
+     * Specular glossiness texture.
+     * @remarks RGB is specular, A is glossiness
+     */
+    get specularGlossinessTexture(): Texture2D;
+    set specularGlossinessTexture(value: Texture2D);
+    /**
+     * Create a pbr specular-glossiness workflow material instance.
+     * @param engine - Engine to which the material belongs
+     */
+    constructor(engine: Engine);
+    /**
+     * @override
+     */
+    clone(): PBRSpecularMaterial;
+}

package/types/material/UnlitMaterial.d.ts

@@ -0,0 +1,33 @@
+import { Color, Vector4 } from "@galacean/engine-math";
+import { Engine } from "../Engine";
+import { Texture2D } from "../texture/Texture2D";
+import { BaseMaterial } from "./BaseMaterial";
+/**
+ * Unlit Material.
+ */
+export declare class UnlitMaterial extends BaseMaterial {
+    /**
+     * Base color.
+     */
+    get baseColor(): Color;
+    set baseColor(value: Color);
+    /**
+     * Base texture.
+     */
+    get baseTexture(): Texture2D;
+    set baseTexture(value: Texture2D);
+    /**
+     * Tiling and offset of main textures.
+     */
+    get tilingOffset(): Vector4;
+    set tilingOffset(value: Vector4);
+    /**
+     * Create a unlit material instance.
+     * @param engine - Engine to which the material belongs
+     */
+    constructor(engine: Engine);
+    /**
+     * @override
+     */
+    clone(): UnlitMaterial;
+}

package/types/material/enums/BlendMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Alpha blend mode.
+ */
+export declare enum BlendMode {
+    /** SRC ALPHA * SRC + (1 - SRC ALPHA) * DEST */
+    Normal = 0,
+    /** SRC ALPHA * SRC + ONE * DEST */
+    Additive = 1
+}

package/types/material/enums/RenderFace.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Set which face for render.
+ */
+export declare enum RenderFace {
+    /** Render front face. */
+    Front = 0,
+    /** Render back face. */
+    Back = 1,
+    /** Render double face. */
+    Double = 2
+}

package/types/material/enums/TextureCoordinate.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Texture UV coordinate.
+ */
+export declare enum TextureCoordinate {
+    UV0 = 0,
+    UV1 = 1,
+    UV2 = 2,
+    UV3 = 3,
+    UV4 = 4,
+    UV5 = 5,
+    UV6 = 6,
+    UV7 = 7
+}

package/types/material/index.d.ts

@@ -0,0 +1,10 @@
+export { BaseMaterial } from "./BaseMaterial";
+export { BlinnPhongMaterial } from "./BlinnPhongMaterial";
+export { BlendMode } from "./enums/BlendMode";
+export { RenderFace } from "./enums/RenderFace";
+export { TextureCoordinate } from "./enums/TextureCoordinate";
+export { Material } from "./Material";
+export { PBRBaseMaterial } from "./PBRBaseMaterial";
+export { PBRMaterial } from "./PBRMaterial";
+export { PBRSpecularMaterial } from "./PBRSpecularMaterial";
+export { UnlitMaterial } from "./UnlitMaterial";

package/types/mesh/BlendShape.d.ts

@@ -0,0 +1,39 @@
+import { Vector3 } from "@galacean/engine-math";
+import { BlendShapeFrame } from "./BlendShapeFrame";
+/**
+ * BlendShape.
+ */
+export declare class BlendShape {
+    /** Name of BlendShape. */
+    name: string;
+    private _dataChangeManager;
+    private _frames;
+    /**
+     * Frames of BlendShape.
+     */
+    get frames(): Readonly<BlendShapeFrame[]>;
+    /**
+     * Create a BlendShape.
+     * @param name - BlendShape name.
+     */
+    constructor(name: string);
+    /**
+     * Add a BlendShapeFrame by weight, deltaPositions, deltaNormals and deltaTangents.
+     * @param weight - Weight of BlendShapeFrame
+     * @param deltaPositions - Delta positions for the frame being added
+     * @param deltaNormals - Delta normals for the frame being added
+     * @param deltaTangents - Delta tangents for the frame being added
+     */
+    addFrame(weight: number, deltaPositions: Vector3[], deltaNormals?: Vector3[], deltaTangents?: Vector3[]): BlendShapeFrame;
+    /**
+     * Add a BlendShapeFrame.
+     * @param frame - The BlendShapeFrame.
+     */
+    addFrame(frame: BlendShapeFrame): void;
+    /**
+     * Clear all frames.
+     */
+    clearFrames(): void;
+    private _addFrame;
+    private _updateUseNormalAndTangent;
+}

package/types/mesh/BlendShapeFrame.d.ts

@@ -0,0 +1,22 @@
+import { Vector3 } from "@galacean/engine-math";
+/**
+ * BlendShapeFrame.
+ */
+export declare class BlendShapeFrame {
+    /** Weight of BlendShapeFrame. */
+    readonly weight: number;
+    /** Delta positions for the frame being added. */
+    readonly deltaPositions: Readonly<Readonly<Vector3>[]>;
+    /** Delta normals for the frame being added. */
+    readonly deltaNormals: Readonly<Readonly<Vector3[]> | null>;
+    /** Delta tangents for the frame being added. */
+    readonly deltaTangents: Readonly<Readonly<Vector3[]> | null>;
+    /**
+     * Create a BlendShapeFrame.
+     * @param weight - Weight of BlendShapeFrame
+     * @param deltaPositions - Delta positions for the frame being added
+     * @param deltaNormals - Delta normals for the frame being added
+     * @param deltaTangents - Delta tangents for the frame being added
+     */
+    constructor(weight: number, deltaPositions: Vector3[], deltaNormals?: Vector3[], deltaTangents?: Vector3[]);
+}

package/types/mesh/BlendShapeManager.d.ts

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

package/types/mesh/BufferMesh.d.ts

@@ -0,0 +1,59 @@
+import { IndexBufferBinding, IndexFormat, Mesh, Buffer, VertexBufferBinding, VertexElement } from "../graphic";
+/**
+ * BufferMesh.
+ */
+export declare class BufferMesh extends Mesh {
+    /**
+     * Instanced count, disable instanced drawing when set zero.
+     */
+    get instanceCount(): number;
+    set instanceCount(value: number);
+    /**
+     * Vertex buffer binding collection.
+     */
+    get vertexBufferBindings(): Readonly<VertexBufferBinding[]>;
+    /**
+     * Index buffer binding.
+     */
+    get indexBufferBinding(): IndexBufferBinding;
+    /**
+     * Vertex element collection.
+     */
+    get vertexElements(): Readonly<VertexElement[]>;
+    /**
+     * Set vertex elements.
+     * @param elements - Vertex element collection
+     */
+    setVertexElements(elements: VertexElement[]): void;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Set index buffer binding.
+     * @param buffer - Index buffer
+     * @param format - Index buffer format
+     */
+    setIndexBufferBinding(buffer: Buffer, format: IndexFormat): void;
+    /**
+     * Set index buffer binding.
+     * @param bufferBinding - Index buffer binding
+     * @remarks When bufferBinding is null, it will clear IndexBufferBinding
+     */
+    setIndexBufferBinding(bufferBinding: IndexBufferBinding | null): void;
+}

package/types/mesh/MeshRenderer.d.ts

@@ -0,0 +1,30 @@
+import { BoundingBox } from "@galacean/engine-math";
+import { ICustomClone } from "../clone/ComponentCloner";
+import { Mesh } from "../graphic/Mesh";
+import { Renderer } from "../Renderer";
+import { RenderContext } from "../RenderPipeline/RenderContext";
+/**
+ * MeshRenderer Component.
+ */
+export declare class MeshRenderer extends Renderer implements ICustomClone {
+    private static _uvMacro;
+    private static _uv1Macro;
+    private static _normalMacro;
+    private static _tangentMacro;
+    private static _vertexColorMacro;
+    /**
+     * Mesh assigned to the renderer.
+     */
+    get mesh(): Mesh;
+    set mesh(value: Mesh);
+    /**
+     * @override
+     */
+    protected _updateBounds(worldBounds: BoundingBox): void;
+    /**
+     * @override
+     */
+    protected _render(context: RenderContext): void;
+    private _setMesh;
+    private _onMeshChanged;
+}