@woosh/meep-engine/src/engine/EngineHarness.d.ts

Pure JavaScript game engine. Fully featured and production ready.

export class EngineHarness {
    /**
     * Quick initialization of the engine in a sensible default configuration
     * @param {(config:EngineConfiguration,engine:Engine)=>*} [configuration]
     * @return {Promise<Engine>}
     */
    static bootstrap({ configuration }?: (config: EngineConfiguration, engine: Engine) => any): Promise<Engine>;
    /**
     *
     * @param {Engine} engine
     */
    static addFpsCounter(engine: Engine): void;
    /**
     * @param {Object} param
     * @param {Engine} param.engine
     * @param {EntityComponentDataset} [param.ecd]
     * @param {Vector3} [param.target]
     * @param {number} [param.distance]
     * @param {number} [param.pitch]
     * @param {number} [param.yaw]
     * @param {boolean} [param.autoClip]
     * @param {number} [param.distanceMin]
     * @param {number} [param.distanceMax]
     * @param {number} [param.fieldOfView] in degrees
     * @returns {Entity}
     */
    static buildCamera({ engine, ecd, target, distance, pitch, yaw, autoClip, distanceMin, distanceMax, fieldOfView }: {
        engine: Engine;
        ecd?: EntityComponentDataset;
        target?: Vector3;
        distance?: number;
        pitch?: number;
        yaw?: number;
        autoClip?: boolean;
        distanceMin?: number;
        distanceMax?: number;
        fieldOfView?: number;
    }): Entity;
    /**
     * @param {Object} params
     * @param {Engine} params.engine
     * @param {{x:number,y:number,z:number}} [params.focus]
     * @param [params.heightMap]
     * @param [params.heightRange]
     * @param {number} [params.pitch]
     * @param {number} [params.yaw]
     * @param {number} [params.distance]
     * @param {{x:number, y:number}} [params.terrainSize]
     * @param {number} [params.terrainResolution]
     * @param {boolean} [params.enableWater]
     * @param {boolean} [params.enableTerrain]
     * @param {boolean} [params.enableLights=true]
     * @param {boolean} [params.enableShadows=true] if lights are enabled, enable shadows for sun
     * @param {number} [params.cameraFieldOfView]
     * @param {number} [params.cameraFarDistance]
     * @param {boolean} [params.cameraController=true]
     * @param {boolean} [params.cameraAutoClip]
     * @param {number} [params.shadowmapResolution]
     * @param {boolean} [params.showFps]
     */
    static buildBasics({ engine, focus, heightMap, heightRange, pitch, yaw, distance, terrainSize, terrainResolution, enableWater, enableTerrain, enableLights, enableShadows, cameraFieldOfView, cameraFarDistance, cameraController, cameraAutoClip, shadowmapResolution, showFps }: {
        engine: Engine;
        focus?: {
            x: number;
            y: number;
            z: number;
        };
        heightMap?: any;
        heightRange?: any;
        pitch?: number;
        yaw?: number;
        distance?: number;
        terrainSize?: {
            x: number;
            y: number;
        };
        terrainResolution?: number;
        enableWater?: boolean;
        enableTerrain?: boolean;
        enableLights?: boolean;
        enableShadows?: boolean;
        cameraFieldOfView?: number;
        cameraFarDistance?: number;
        cameraController?: boolean;
        cameraAutoClip?: boolean;
        shadowmapResolution?: number;
        showFps?: boolean;
    }): Promise<void>;
    /**
     * @param {Object} param
     * @param {Engine} param.engine
     * @param {EntityComponentDataset} [param.ecd]
     * @param {number} [param.shadowmapResolution]
     * @param {boolean} [param.castShadow]
     * @param {Color} [param.sun]
     * @param {number} [param.sunIntensity]
     * @param {Vector3} [param.sunDirection]
     * @param {Color} [param.ambient]
     * @param {number} [param.ambientIntensity]
     */
    static buildLights({ engine, ecd, shadowmapResolution, castShadow, sun, sunIntensity, sunDirection, ambient, ambientIntensity }: {
        engine: Engine;
        ecd?: EntityComponentDataset;
        shadowmapResolution?: number;
        castShadow?: boolean;
        sun?: Color;
        sunIntensity?: number;
        sunDirection?: Vector3;
        ambient?: Color;
        ambientIntensity?: number;
    }): Promise<void>;
    /**
     * @param {Object} param
     * @param {number} [param.cameraEntity]
     * @param {Engine} param.engine
     * @param {number} [param.sensitivity]
     * @param {EntityComponentDataset} [param.ecd]
     * @returns {Promise<Entity>}
     */
    static buildOrbitalCameraController({ cameraEntity, engine, ecd, sensitivity }: {
        cameraEntity?: number;
        engine: Engine;
        sensitivity?: number;
        ecd?: EntityComponentDataset;
    }): Promise<Entity>;
    /**
     *
     * @param {Engine} engine
     * @param {Vector2} [size]
     * @param {String} [diffuse0]
     * @param heightMap
     * @param {number} [resolution]
     * @param {number} [waterLevel]
     * @param {boolean} [enableWater]
     * @returns {Terrain}
     */
    static buildTerrain({ engine, size, diffuse0, resolution, waterLevel, enableWater, }: Engine): Terrain;
    /**
     *
     * @type {Engine}
     */
    engine: Engine;
    /**
     * @readonly
     * @type {Promise|null}
     */
    readonly p: Promise<any> | null;
    /**
     * @param {Object} [params]
     * @param {(config:EngineConfiguration,engine:Engine)=>*} [params.configuration]
     * @param {boolean} [params.enable_localization] Whether or not to load localization data
     * @returns {Promise<Engine>}
     */
    initialize({ configuration, enable_localization, }?: {
        configuration?: (config: EngineConfiguration, engine: Engine) => any;
        enable_localization?: boolean;
    }): Promise<Engine>;
}
export namespace EngineHarness {
    /**
     *
     * @returns {EngineHarness}
     */
    function getSingleton(): EngineHarness;
}
import Engine from "./Engine.js";
import { EngineConfiguration } from "./EngineConfiguration.js";
import Vector3 from "../core/geom/Vector3.js";
import Entity from "./ecs/Entity.js";
import { Color } from "../core/color/Color.js";
import Terrain from "./ecs/terrain/ecs/Terrain.js";
//# sourceMappingURL=EngineHarness.d.ts.map