@galacean/engine-core 1.6.8 → 1.6.9

package/types/material/PBRMaterial.d.ts

@@ -0,0 +1,311 @@
+import { Color, Vector2, Vector4 } from "@galacean/engine-math";
+import { Engine } from "../Engine";
+import { Texture2D } from "../texture/Texture2D";
+import { BaseMaterial } from "./BaseMaterial";
+import { RefractionMode } from "./enums/Refraction";
+import { TextureCoordinate } from "./enums/TextureCoordinate";
+/**
+ * PBR (Metallic-Roughness Workflow) Material.
+ */
+export declare class PBRMaterial 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;
+    private static _metallicProp;
+    private static _roughnessProp;
+    private static _roughnessMetallicTextureProp;
+    private static _iorProp;
+    private static _anisotropyInfoProp;
+    private static _anisotropyTextureProp;
+    private static _iridescenceInfoProp;
+    private static _iridescenceThicknessTextureProp;
+    private static _iridescenceTextureProp;
+    private static _sheenColorProp;
+    private static _sheenRoughnessProp;
+    private static _sheenTextureProp;
+    private static _sheenRoughnessTextureProp;
+    private static _transmissionMacro;
+    private static _thicknessMacro;
+    private static _thicknessTextureMacro;
+    private static _transmissionTextureMacro;
+    private static _transmissionProp;
+    private static _transmissionTextureProp;
+    private static _attenuationColorProp;
+    private static _attenuationDistanceProp;
+    private static _thicknessProp;
+    private static _thicknessTextureProp;
+    private static _specularTextureMacro;
+    private static _specularColorTextureMacro;
+    private static _specularIntensityProp;
+    private static _specularColorProp;
+    private static _specularIntensityTextureProp;
+    private static _specularColorTextureProp;
+    private _refractionMode;
+    private _anisotropyRotation;
+    private _iridescenceRange;
+    private _sheenEnabled;
+    /**
+     * 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);
+    /**
+     * Index Of Refraction.
+     * @defaultValue `1.5`
+     */
+    get ior(): number;
+    set ior(v: number);
+    /**
+     * Metallic.
+     * @defaultValue `1.0`
+     */
+    get metallic(): number;
+    set metallic(value: number);
+    /**
+     * Roughness. default 1.0.
+     * @defaultValue `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);
+    /**
+     * The strength of anisotropy, when anisotropyTexture is present, this value is multiplied by the blue channel.
+     * @defaultValue `0`
+     */
+    get anisotropy(): number;
+    set anisotropy(value: number);
+    /**
+     * The rotation of the anisotropy in tangent, bitangent space, value in degrees.
+     * @defaultValue `0`
+     */
+    get anisotropyRotation(): number;
+    set anisotropyRotation(value: number);
+    /**
+     * The anisotropy texture.
+     * @remarks
+     * Red and green channels represent the anisotropy direction in [-1, 1] tangent, bitangent space, to be rotated by anisotropyRotation.
+     * The blue channel contains strength as [0, 1] to be multiplied by anisotropy.
+     */
+    get anisotropyTexture(): Texture2D;
+    set anisotropyTexture(value: Texture2D);
+    /**
+     * The iridescence intensity factor, from 0.0 to 1.0.
+     * @defaultValue `0.0`
+     */
+    get iridescence(): number;
+    set iridescence(value: number);
+    /**
+     * The iridescence intensity texture, sampling red channel, and multiply 'iridescence'.
+     */
+    get iridescenceTexture(): Texture2D;
+    set iridescenceTexture(value: Texture2D);
+    /**
+     * The index of refraction of the dielectric thin-film layer, greater than or equal to 1.0.
+     * @defaultValue `1.3`
+     */
+    get iridescenceIOR(): number;
+    set iridescenceIOR(value: number);
+    /**
+     * The range of iridescence thickness, x is minimum, y is maximum.
+     *  @defaultValue `[100, 400]`
+     */
+    get iridescenceThicknessRange(): Vector2;
+    set iridescenceThicknessRange(value: Vector2);
+    /**
+     * The thickness texture of the thin-film layer, sampling green channel.
+     * @remarks
+     * If iridescenceThicknessTexture is defined, iridescence thickness between the 'iridescenceThicknessRange'.
+     * If iridescenceThicknessTexture is not defined, iridescence thickness will use only 'iridescenceThicknessRange.y'.
+     */
+    get iridescenceThicknessTexture(): Texture2D;
+    set iridescenceThicknessTexture(value: Texture2D);
+    /**
+     * Sheen color.
+     * @defaultValue `[0,0,0]`
+     */
+    get sheenColor(): Color;
+    set sheenColor(value: Color);
+    /**
+     * Sheen roughness, from 0.0 to 1.0.
+     * @defaultValue `0.0`
+     */
+    get sheenRoughness(): number;
+    set sheenRoughness(value: number);
+    /**
+     * Sheen color texture, multiply ‘sheenColor’.
+     */
+    get sheenColorTexture(): Texture2D;
+    set sheenColorTexture(value: Texture2D);
+    /**
+     * Sheen roughness texture.
+     * @remarks Use alpha channel, and multiply 'sheenRoughness'.
+     */
+    get sheenRoughnessTexture(): Texture2D;
+    set sheenRoughnessTexture(value: Texture2D);
+    /**
+     * Refraction switch.
+     * @remarks Use refractionMode to set the refraction shape.
+     */
+    get refractionMode(): RefractionMode;
+    set refractionMode(value: RefractionMode);
+    /**
+     * @inheritdoc
+     */
+    get isTransparent(): boolean;
+    set isTransparent(value: boolean);
+    /**
+     * @inheritdoc
+     */
+    get alphaCutoff(): number;
+    set alphaCutoff(value: number);
+    /**
+     * Transmission factor.
+     * @defaultValue `0.0`
+     */
+    get transmission(): number;
+    set transmission(value: number);
+    /**
+     * Transmission texture.
+     * @remarks Use red channel, and multiply 'transmission'.
+     */
+    get transmissionTexture(): Texture2D;
+    set transmissionTexture(value: Texture2D);
+    /**
+     * Attenuation color.
+     * @defaultValue `[1,1,1]`
+     */
+    get attenuationColor(): Color;
+    set attenuationColor(value: Color);
+    /**
+     * Attenuation distance, greater than 0.0.
+     * @defaultValue `infinity`
+     */
+    get attenuationDistance(): number;
+    set attenuationDistance(value: number);
+    /**
+     * Thickness, greater than or equal to 0.0.
+     * @defaultValue `0.0`
+     */
+    get thickness(): number;
+    set thickness(value: number);
+    /**
+     * Thickness texture.
+     * @remarks Use green channel, and multiply 'thickness', range is 0.0 to 1.0.
+     */
+    get thicknessTexture(): Texture2D;
+    set thicknessTexture(value: Texture2D);
+    /**
+     * The intensity of the specular reflection.
+     * @defaultValue `1.0`
+     */
+    get specularIntensity(): number;
+    set specularIntensity(value: number);
+    /**
+     * The F0 color of the specular reflection.
+     * @defaultValue `[1,1,1]`
+     */
+    get specularColor(): Color;
+    set specularColor(value: Color);
+    /**
+     * The intensity of the specular reflection, stored in alpha(A) channel. This will be multiplied by `specularIntensity`.
+     */
+    get specularIntensityTexture(): Texture2D;
+    set specularIntensityTexture(value: Texture2D);
+    /**
+     * The F0 color of the specular reflection, stored in the RGB channels. This will be multiplied by `specularColor`.
+     */
+    get specularColorTexture(): Texture2D;
+    set specularColorTexture(value: Texture2D);
+    /**
+     * Create a pbr metallic-roughness workflow material instance.
+     * @param engine - Engine to which the material belongs
+     */
+    constructor(engine: Engine);
+    /**
+     * @inheritdoc
+     */
+    clone(): PBRMaterial;
+    private _onIridescenceRangeChanged;
+    private _onSheenColorChanged;
+}

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);
+    /**
+     * @inheritdoc
+     */
+    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/Refraction.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Refraction mode.
+ */
+export declare enum RefractionMode {
+    /** Use the sphere refraction model when light passes through the surface. */
+    Sphere = 0,
+    /** Use the planar refraction model when light passes through the surface. */
+    Planar = 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,9 @@
+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 { PBRMaterial } from "./PBRMaterial";
+export { UnlitMaterial } from "./UnlitMaterial";
+export { RefractionMode } from "./enums/Refraction";

package/types/material/utils/PrefilteredDFG.d.ts

@@ -0,0 +1,7 @@
+import { Engine } from "../../Engine";
+import { Texture2D } from "../../texture/Texture2D";
+export declare class PrefilteredDFG {
+    private static _size;
+    private static _base64;
+    static create(engine: Engine): Promise<Texture2D>;
+}

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 _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;
+    private _frameDataChangeListener;
+}

package/types/mesh/BlendShapeFrame.d.ts

@@ -0,0 +1,44 @@
+import { Vector3 } from "@galacean/engine-math";
+/**
+ * BlendShapeFrame.
+ */
+export declare class BlendShapeFrame {
+    /** Weight of BlendShapeFrame. */
+    readonly weight: number;
+    private _dirty;
+    private _deltaPositions;
+    private _deltaNormals;
+    private _deltaTangents;
+    /**
+     * Delta positions for the frame being added.
+     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+     */
+    get deltaPositions(): Vector3[];
+    set deltaPositions(value: Vector3[]);
+    /**
+     * Delta normals for the frame being added.
+     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+     */
+    get deltaNormals(): Vector3[];
+    set deltaNormals(value: Vector3[]);
+    /**
+     * Delta tangents for the frame being added.
+     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+     */
+    get deltaTangents(): Vector3[];
+    set deltaTangents(value: Vector3[]);
+    /**
+     * 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[]);
+}
+export declare enum BlendShapeFrameDirty {
+    Position = 1,
+    Normal = 2,
+    Tangent = 4,
+    All = 7
+}

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 vertexBufferBinding - Vertex buffer binding
+     * @param index - Vertex buffer index, the default value is 0
+     */
+    setVertexBufferBinding(vertexBufferBinding: 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,25 @@
+import { Renderer } from "../Renderer";
+import { Mesh } from "../graphic/Mesh";
+/**
+ * MeshRenderer Component.
+ */
+export declare class MeshRenderer extends Renderer {
+    private static _uvMacro;
+    private static _uv1Macro;
+    private static _normalMacro;
+    private static _tangentMacro;
+    private static _enableVertexColorMacro;
+    private _enableVertexColor;
+    /**
+     * Mesh assigned to the renderer.
+     */
+    get mesh(): Mesh;
+    set mesh(value: Mesh);
+    /**
+     * Whether enable vertex color.
+     */
+    get enableVertexColor(): boolean;
+    set enableVertexColor(value: boolean);
+    private _setMesh;
+    private _onMeshChanged;
+}