@galacean/engine-core 0.9.0-beta.80

package/types/physics/enums/PhysicsMaterialCombineMode.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Describes how physics materials of the colliding objects are combined.
+ */
+export declare enum PhysicsMaterialCombineMode {
+    /** Averages the friction/bounce of the two colliding materials. */
+    Average = 0,
+    /** Uses the smaller friction/bounce of the two colliding materials. */
+    Minimum = 1,
+    /** Multiplies the friction/bounce of the two colliding materials. */
+    Multiply = 2,
+    /** Uses the larger friction/bounce of the two colliding materials. */
+    Maximum = 3
+}

package/types/physics/enums/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./PhysicsMaterialCombineMode";
+export * from "./ColliderShapeUpAxis";
+export * from "./ControllerCollisionFlag";
+export * from "./ControllerNonWalkableMode";

package/types/physics/index.d.ts

@@ -0,0 +1,10 @@
+export { HitResult } from "./HitResult";
+export { PhysicsManager } from "./PhysicsManager";
+export { PhysicsMaterial } from "./PhysicsMaterial";
+export { CharacterController } from "./CharacterController";
+export * from "./shape";
+export * from "./joint";
+export * from "./enums";
+export { Collider } from "./Collider";
+export { StaticCollider } from "./StaticCollider";
+export { DynamicCollider, CollisionDetectionMode, DynamicColliderConstraints } from "./DynamicCollider";

package/types/physics/joint/FixedJoint.d.ts

@@ -0,0 +1,3 @@
+import { Joint } from "./Joint";
+export declare class FixedJoint extends Joint {
+}

package/types/physics/joint/HingeJoint.d.ts

@@ -0,0 +1,57 @@
+import { Joint } from "./Joint";
+import { Vector3 } from "@galacean/engine-math";
+import { JointMotor } from "./JointMotor";
+import { JointLimits } from "./JointLimits";
+/**
+ * A joint which behaves in a similar way to a hinge or axle.
+ */
+export declare class HingeJoint extends Joint {
+    private _axis;
+    private _hingeFlags;
+    private _useSpring;
+    private _jointMonitor;
+    private _limits;
+    /**
+     * The anchor rotation.
+     */
+    get axis(): Vector3;
+    set axis(value: Vector3);
+    /**
+     * The swing offset.
+     */
+    get swingOffset(): Vector3;
+    set swingOffset(value: Vector3);
+    /**
+     * The current angle in degrees of the joint relative to its rest position.
+     */
+    get angle(): number;
+    /**
+     * The angular velocity of the joint in degrees per second.
+     */
+    get velocity(): Readonly<Vector3>;
+    /**
+     * Enables the joint's limits. Disabled by default.
+     */
+    get useLimits(): boolean;
+    set useLimits(value: boolean);
+    /**
+     * Enables the joint's motor. Disabled by default.
+     */
+    get useMotor(): boolean;
+    set useMotor(value: boolean);
+    /**
+     * Enables the joint's spring. Disabled by default.
+     */
+    get useSpring(): boolean;
+    set useSpring(value: boolean);
+    /**
+     * The motor will apply a force up to a maximum force to achieve the target velocity in degrees per second.
+     */
+    get motor(): JointMotor;
+    set motor(value: JointMotor);
+    /**
+     * Limit of angular rotation (in degrees) on the hinge joint.
+     */
+    get limits(): JointLimits;
+    set limits(value: JointLimits);
+}

package/types/physics/joint/Joint.d.ts

@@ -0,0 +1,58 @@
+import { IJoint } from "@galacean/engine-design";
+import { Vector3 } from "@galacean/engine-math";
+import { Component } from "../../Component";
+import { Collider } from "../Collider";
+import { Entity } from "../../Entity";
+/**
+ * A base class providing common functionality for joints.
+ * @decorator `@dependentComponents(Collider)`
+ */
+export declare class Joint extends Component {
+    protected _connectedCollider: JointCollider;
+    protected _collider: JointCollider;
+    protected _nativeJoint: IJoint;
+    private _force;
+    private _torque;
+    /**
+     * The connected collider.
+     */
+    get connectedCollider(): Collider;
+    set connectedCollider(value: Collider);
+    /**
+     * The connected anchor position.
+     * @remarks If connectedCollider is set, this anchor is relative offset, or the anchor is world position.
+     */
+    get connectedAnchor(): Vector3;
+    set connectedAnchor(value: Vector3);
+    /**
+     *  The scale to apply to the inverse mass of collider 0 for resolving this constraint.
+     */
+    get connectedMassScale(): number;
+    set connectedMassScale(value: number);
+    /**
+     * The scale to apply to the inverse inertia of collider0 for resolving this constraint.
+     */
+    get connectedInertiaScale(): number;
+    set connectedInertiaScale(value: number);
+    /**
+     * The scale to apply to the inverse mass of collider 1 for resolving this constraint.
+     */
+    get massScale(): number;
+    set massScale(value: number);
+    /**
+     * The scale to apply to the inverse inertia of collider1 for resolving this constraint.
+     */
+    get inertiaScale(): number;
+    set inertiaScale(value: number);
+    /**
+     * The maximum force the joint can apply before breaking.
+     */
+    get breakForce(): number;
+    set breakForce(value: number);
+    /**
+     * The maximum torque the joint can apply before breaking.
+     */
+    get breakTorque(): number;
+    set breakTorque(value: number);
+    constructor(entity: Entity);
+}

package/types/physics/joint/JointLimits.d.ts

@@ -0,0 +1,15 @@
+/**
+ * JointLimits is used to limit the joints angle.
+ */
+export declare class JointLimits {
+    /** The upper angular limit (in degrees) of the joint. */
+    max: number;
+    /** The lower angular limit (in degrees) of the joint. */
+    min: number;
+    /** Distance inside the limit value at which the limit will be considered to be active by the solver. */
+    contactDistance: number;
+    /** The spring forces used to reach the target position. */
+    stiffness: number;
+    /** The damper force uses to dampen the spring. */
+    damping: number;
+}

package/types/physics/joint/JointMotor.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The JointMotor is used to motorize a joint.
+ */
+export declare class JointMotor {
+    /** The motor will apply a force up to force to achieve targetVelocity. */
+    targetVelocity: number;
+    /** The force limit.*/
+    forceLimit: number;
+    /** Gear ration for the motor */
+    gearRation: number;
+    /** If freeSpin is enabled the motor will only accelerate but never slow down. */
+    freeSpin: boolean;
+}

package/types/physics/joint/SpringJoint.d.ts

@@ -0,0 +1,42 @@
+import { Joint } from "./Joint";
+import { Vector3 } from "@galacean/engine-math";
+/**
+ * A joint that maintains an upper or lower bound (or both) on the distance between two points on different objects.
+ */
+export declare class SpringJoint extends Joint {
+    private _minDistance;
+    private _maxDistance;
+    private _tolerance;
+    private _stiffness;
+    private _damping;
+    /**
+     * The swing offset.
+     */
+    get swingOffset(): Vector3;
+    set swingOffset(value: Vector3);
+    /**
+     * The minimum distance.
+     */
+    get minDistance(): number;
+    set minDistance(value: number);
+    /**
+     * The maximum distance.
+     */
+    get maxDistance(): number;
+    set maxDistance(value: number);
+    /**
+     * The distance beyond the allowed range at which the joint becomes active.
+     */
+    get tolerance(): number;
+    set tolerance(value: number);
+    /**
+     * The spring strength of the joint.
+     */
+    get stiffness(): number;
+    set stiffness(value: number);
+    /**
+     * The degree of damping of the joint spring of the joint.
+     */
+    get damping(): number;
+    set damping(value: number);
+}

package/types/physics/joint/index.d.ts

@@ -0,0 +1,6 @@
+export { Joint } from "./Joint";
+export { FixedJoint } from "./FixedJoint";
+export { HingeJoint } from "./HingeJoint";
+export { SpringJoint } from "./SpringJoint";
+export { JointLimits } from "./JointLimits";
+export { JointMotor } from "./JointMotor";

package/types/physics/shape/BoxColliderShape.d.ts

@@ -0,0 +1,15 @@
+import { ColliderShape } from "./ColliderShape";
+import { Vector3 } from "@galacean/engine-math";
+/**
+ * Physical collider shape for box.
+ */
+export declare class BoxColliderShape extends ColliderShape {
+    private _size;
+    /**
+     * Size of box shape.
+     */
+    get size(): Vector3;
+    set size(value: Vector3);
+    constructor();
+    private _setSize;
+}

package/types/physics/shape/CapsuleColliderShape.d.ts

@@ -0,0 +1,26 @@
+import { ColliderShape } from "./ColliderShape";
+import { ColliderShapeUpAxis } from "../enums/ColliderShapeUpAxis";
+/**
+ * Physical collider shape for capsule.
+ */
+export declare class CapsuleColliderShape extends ColliderShape {
+    private _radius;
+    private _height;
+    private _upAxis;
+    /**
+     * Radius of capsule.
+     */
+    get radius(): number;
+    set radius(value: number);
+    /**
+     * Height of capsule.
+     */
+    get height(): number;
+    set height(value: number);
+    /**
+     * Up axis of capsule.
+     */
+    get upAxis(): ColliderShapeUpAxis;
+    set upAxis(value: ColliderShapeUpAxis);
+    constructor();
+}

package/types/physics/shape/ColliderShape.d.ts

@@ -0,0 +1,51 @@
+import { PhysicsMaterial } from "../PhysicsMaterial";
+import { Vector3 } from "@galacean/engine-math";
+import { Collider } from "../Collider";
+/**
+ * Abstract class for collider shapes.
+ */
+export declare abstract class ColliderShape {
+    private static _idGenerator;
+    protected _id: number;
+    protected _material: PhysicsMaterial;
+    private _isTrigger;
+    private _rotation;
+    private _position;
+    private _contactOffset;
+    /**
+     * Collider owner of this shape.
+     */
+    get collider(): Collider;
+    /**
+     * Unique id for this shape.
+     */
+    get id(): number;
+    /**
+     * Contact offset for this shape.
+     */
+    get contactOffset(): number;
+    set contactOffset(value: number);
+    /**
+     * Physical material.
+     */
+    get material(): PhysicsMaterial;
+    set material(value: PhysicsMaterial);
+    /**
+     * The local rotation of this ColliderShape.
+     */
+    get rotation(): Vector3;
+    set rotation(value: Vector3);
+    /**
+     * The local position of this ColliderShape.
+     */
+    get position(): Vector3;
+    set position(value: Vector3);
+    /**
+     * True for TriggerShape, false for SimulationShape.
+     */
+    get isTrigger(): boolean;
+    set isTrigger(value: boolean);
+    protected constructor();
+    private _setPosition;
+    private _setRotation;
+}

package/types/physics/shape/PlaneColliderShape.d.ts

@@ -0,0 +1,7 @@
+import { ColliderShape } from "./ColliderShape";
+/**
+ * Physical collider shape plane.
+ */
+export declare class PlaneColliderShape extends ColliderShape {
+    constructor();
+}

package/types/physics/shape/SphereColliderShape.d.ts

@@ -0,0 +1,13 @@
+import { ColliderShape } from "./ColliderShape";
+/**
+ * Physical collider shape for sphere.
+ */
+export declare class SphereColliderShape extends ColliderShape {
+    private _radius;
+    /**
+     * Radius of sphere shape.
+     */
+    get radius(): number;
+    set radius(value: number);
+    constructor();
+}

package/types/physics/shape/index.d.ts

@@ -0,0 +1,5 @@
+export { ColliderShape } from "./ColliderShape";
+export { BoxColliderShape } from "./BoxColliderShape";
+export { SphereColliderShape } from "./SphereColliderShape";
+export { PlaneColliderShape } from "./PlaneColliderShape";
+export { CapsuleColliderShape } from "./CapsuleColliderShape";

package/types/renderingHardwareInterface/IHardwareRenderer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hardware graphics API renderer.
+ */
+export interface IHardwareRenderer {
+    [key: string]: any;
+}

package/types/renderingHardwareInterface/IPlatformBuffer.d.ts

@@ -0,0 +1,8 @@
+import { SetDataOptions } from "../graphic";
+export interface IPlatformBuffer {
+    bind(): void;
+    setData(byteLength: number, data: ArrayBuffer | ArrayBufferView, bufferByteOffset?: number, dataOffset?: number, dataLength?: number, options?: SetDataOptions): void;
+    getData(data: ArrayBufferView, bufferByteOffset?: number, dataOffset?: number, dataLength?: number): void;
+    resize(byteLength: number): void;
+    destroy(): void;
+}

package/types/renderingHardwareInterface/IPlatformRenderTarget.d.ts

@@ -0,0 +1,20 @@
+import { TextureCubeFace } from "../texture";
+/**
+ * Off-screen rendering target specification.
+ */
+export interface IPlatformRenderTarget {
+    /**
+     * Set which face and mipLevel of the cube texture to render to.
+     * @param faceIndex - Cube texture face
+     * @param mipLevel - Set mip level the data want to write
+     */
+    setRenderTargetInfo(faceIndex: TextureCubeFace, mipLevel: number): void;
+    /**
+     * Blit FBO.
+     */
+    blitRenderTarget(): void;
+    /**
+     * Destroy render target.
+     */
+    destroy(): void;
+}

package/types/renderingHardwareInterface/IPlatformTexture.d.ts

@@ -0,0 +1,36 @@
+import { TextureFilterMode, TextureWrapMode } from "../texture";
+import { TextureDepthCompareFunction } from "../texture/enums/TextureDepthCompareFunction";
+/**
+ * Texture interface specification.
+ */
+export interface IPlatformTexture {
+    /**
+     * Wrapping mode for texture coordinate S.
+     */
+    wrapModeU: TextureWrapMode;
+    /**
+     * Wrapping mode for texture coordinate T.
+     */
+    wrapModeV: TextureWrapMode;
+    /**
+     * Filter mode for texture.
+     */
+    filterMode: TextureFilterMode;
+    /**
+     * Anisotropic level for texture.
+     */
+    anisoLevel: number;
+    /**
+     *  Filter mode when texture as depth Texture.
+     */
+    depthCompareFunction: TextureDepthCompareFunction;
+    /**
+     * Destroy texture.
+     */
+    destroy(): void;
+    /**
+     * Generate multi-level textures based on the 0th level data.
+     */
+    generateMipmaps(): void;
+    setUseDepthCompareMode(value: boolean): any;
+}

package/types/renderingHardwareInterface/IPlatformTexture2D.d.ts

@@ -0,0 +1,37 @@
+import { IPlatformTexture } from "./IPlatformTexture";
+/**
+ * 2D texture interface specification.
+ */
+export interface IPlatformTexture2D extends IPlatformTexture {
+    /**
+     * Setting pixels data through color buffer data, designated area and texture mipmapping level,it's also applicable to compressed formats.
+     * @remarks If it is the WebGL1.0 platform and the texture format is compressed, the first upload must be filled with textures.
+     * @param colorBuffer - Color buffer data
+     * @param mipLevel - Texture mipmapping level
+     * @param x - X coordinate of area start
+     * @param y - Y coordinate of area start
+     * @param width - Data width. if it's empty, width is the width corresponding to mipLevel minus x , width corresponding to mipLevel is Math.max(1, this.width >> mipLevel)
+     * @param height - Data height. if it's empty, height is the height corresponding to mipLevel minus y , height corresponding to mipLevel is Math.max(1, this.height >> mipLevel)
+     */
+    setPixelBuffer(colorBuffer: ArrayBufferView, mipLevel: number, x: number, y: number, width?: number, height?: number): void;
+    /**
+     * Setting pixels data through TexImageSource, designated area and texture mipmapping level.
+     * @param imageSource - The source of texture
+     * @param mipLevel - Texture mipmapping level
+     * @param flipY - Whether to flip the Y axis
+     * @param premultiplyAlpha - Whether to premultiply the transparent channel
+     * @param x - X coordinate of area start
+     * @param y - Y coordinate of area start
+     */
+    setImageSource(imageSource: TexImageSource | OffscreenCanvas, mipLevel: number, flipY: boolean, premultiplyAlpha: boolean, x: number, y: number): void;
+    /**
+     * Get the pixel color buffer according to the specified area.
+     * @param x - X coordinate of area start
+     * @param y - Y coordinate of area start
+     * @param width - Area width
+     * @param height - Area height
+     * @param mipLevel - Set mip level the data want to get from
+     * @param out - Color buffer
+     */
+    getPixelBuffer(x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+}

package/types/renderingHardwareInterface/IPlatformTexture2DArray.d.ts

@@ -0,0 +1,40 @@
+import { IPlatformTexture } from "./IPlatformTexture";
+/**
+ * 2D texture array interface specification.
+ */
+export interface IPlatformTexture2DArray extends IPlatformTexture {
+    /**
+     * Setting pixels data through color buffer data, designated area and texture mipmapping level,it's also applicable to compressed formats.
+     * @param offsetIndex - The texture array element offset index
+     * @param colorBuffer - Color buffer data
+     * @param mipLevel - Texture mipmapping level
+     * @param x - X coordinate of area start
+     * @param y - Y coordinate of area start
+     * @param width - Data width. if it's empty, width is the width corresponding to mipLevel minus x , width corresponding to mipLevel is Math.max(1, this.width >> mipLevel)
+     * @param height - Data height. if it's empty, height is the height corresponding to mipLevel minus y , height corresponding to mipLevel is Math.max(1, this.height >> mipLevel)
+     * @param length - Data length.
+     */
+    setPixelBuffer(offsetIndex: number, colorBuffer: ArrayBufferView, mipLevel: number, x: number, y: number, width?: number, height?: number, length?: number): void;
+    /**
+     * Setting pixels data through TexImageSource, designated area and texture mipmapping level.
+     * @param index - The texture array element index
+     * @param imageSource - The source of texture
+     * @param mipLevel - Texture mipmapping level
+     * @param flipY - Whether to flip the Y axis
+     * @param premultiplyAlpha - Whether to premultiply the transparent channel
+     * @param x - X coordinate of area start
+     * @param y - Y coordinate of area start
+     */
+    setImageSource(index: number, imageSource: TexImageSource | OffscreenCanvas, mipLevel: number, flipY: boolean, premultiplyAlpha: boolean, x: number, y: number): void;
+    /**
+     * Get the pixel color buffer according to the specified area.
+     * @param elementIndex - The texture array element index
+     * @param x - X coordinate of area start
+     * @param y - Y coordinate of area start
+     * @param width - Area width
+     * @param height - Area height
+     * @param mipLevel - Set mip level the data want to get from
+     * @param out - Color buffer
+     */
+    getPixelBuffer(elementIndex: number, x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+}

package/types/renderingHardwareInterface/IPlatformTextureCube.d.ts

@@ -0,0 +1,41 @@
+import { TextureCubeFace } from "../texture";
+import { IPlatformTexture } from "./IPlatformTexture";
+/**
+ * Cube texture interface specification.
+ */
+export interface IPlatformTextureCube extends IPlatformTexture {
+    /**
+     * Setting pixels data through cube face,color buffer data, designated area and texture mipmapping level,it's also applicable to compressed formats.
+     * @remarks When compressed texture is in WebGL1, the texture must be filled first before writing the sub-region
+     * @param face - Cube face
+     * @param colorBuffer - Color buffer data
+     * @param mipLevel - Texture mipmapping level
+     * @param x - X coordinate of area start
+     * @param y -  Y coordinate of area start
+     * @param width - Data width.if it's empty, width is the width corresponding to mipLevel minus x , width corresponding to mipLevel is Math.max(1, this.width >> mipLevel)
+     * @param height - Data height.if it's empty, height is the height corresponding to mipLevel minus y , height corresponding to mipLevel is Math.max(1, this.height >> mipLevel)
+     */
+    setPixelBuffer(face: TextureCubeFace, colorBuffer: ArrayBufferView, mipLevel: number, x: number, y: number, width?: number, height?: number): void;
+    /**
+     * Setting pixels data through cube face, TexImageSource, designated area and texture mipmapping level.
+     * @param face - Cube face
+     * @param imageSource - The source of texture
+     * @param mipLevel - Texture mipmapping level
+     * @param flipY - Whether to flip the Y axis
+     * @param premultiplyAlpha - Whether to premultiply the transparent channel
+     * @param x - X coordinate of area start
+     * @param y - Y coordinate of area start
+     */
+    setImageSource(face: TextureCubeFace, imageSource: TexImageSource | OffscreenCanvas, mipLevel: number, flipY: boolean, premultiplyAlpha: boolean, x: number, y: number): void;
+    /**
+     * Get the pixel color buffer according to the specified cube face and area.
+     * @param face - You can choose which cube face to read
+     * @param x - X coordinate of area start
+     * @param y - Y coordinate of area start
+     * @param width - Area width
+     * @param height - Area height
+     * @param mipLevel - Set mip level the data want to get from
+     * @param out - Color buffer
+     */
+    getPixelBuffer(face: TextureCubeFace, x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+}

package/types/renderingHardwareInterface/index.d.ts

@@ -0,0 +1,6 @@
+export type { IHardwareRenderer } from "./IHardwareRenderer";
+export type { IPlatformRenderTarget } from "./IPlatformRenderTarget";
+export type { IPlatformTexture } from "./IPlatformTexture";
+export type { IPlatformTexture2D } from "./IPlatformTexture2D";
+export type { IPlatformTexture2DArray } from "./IPlatformTexture2DArray";
+export type { IPlatformTextureCube } from "./IPlatformTextureCube";

package/types/shader/Shader.d.ts

@@ -0,0 +1,72 @@
+import { Engine } from "../Engine";
+import { ShaderMacro } from "./ShaderMacro";
+import { ShaderPass } from "./ShaderPass";
+import { ShaderProperty } from "./ShaderProperty";
+/**
+ * Shader for rendering.
+ */
+export declare class Shader {
+    private static _shaderMap;
+    private static _propertyNameMap;
+    private static _macroMaskMap;
+    private static _macroCounter;
+    private static _macroMap;
+    /**
+     * Create a shader.
+     * @param name - Name of the shader
+     * @param vertexSource - Vertex source code
+     * @param fragmentSource - Fragment source code
+     * @returns Shader
+     */
+    static create(name: string, vertexSource: string, fragmentSource: string): Shader;
+    /**
+     * Create a shader.
+     * @param name - Name of the shader
+     * @param shaderPasses - Shader passes
+     * @returns Shader
+     */
+    static create(name: string, shaderPasses: ShaderPass[]): Shader;
+    /**
+     * Find a shader by name.
+     * @param name - Name of the shader
+     */
+    static find(name: string): Shader;
+    /**
+     * Get shader macro by name.
+     * @param name - Name of the shader macro
+     * @returns Shader macro
+     */
+    static getMacroByName(name: string): ShaderMacro;
+    /**
+     * Get shader macro by name.
+     * @param name - Name of the shader macro
+     * @param value - Value of the shader macro
+     * @returns Shader macro
+     */
+    static getMacroByName(name: string, value: string): ShaderMacro;
+    /**
+     * Get shader property by name.
+     * @param name - Name of the shader property
+     * @returns Shader property
+     */
+    static getPropertyByName(name: string): ShaderProperty;
+    /** The name of shader. */
+    readonly name: string;
+    /**
+     *  Shader passes.
+     */
+    get passes(): ReadonlyArray<ShaderPass>;
+    private _passes;
+    private constructor();
+    /**
+     * Compile shader variant by macro name list.
+     *
+     * @remarks
+     * Usually a shader contains some macros,any combination of macros is called shader variant.
+     *
+     * @param engine - Engine to which the shader variant belongs
+     * @param macros - Macro name list
+     * @returns Is the compiled shader variant valid
+     */
+    compileVariant(engine: Engine, macros: string[]): boolean;
+}