excalibur 0.33.0-alpha.99 → 1.1.0-alpha.310

package/build/dist/graphics/context/material.d.ts

@@ -1,102 +0,0 @@
-import { Color } from '../../color';
-import type { ExcaliburGraphicsContext } from './excalibur-graphics-context';
-import type { Shader, UniformDictionary } from './shader';
-import type { ImageSource } from '../image-source';
-import type { ImageFiltering } from '../filtering';
-export interface MaterialOptions {
-    /**
-     * Name the material for debugging
-     */
-    name?: string;
-    /**
-     * Excalibur graphics context to create the material (only WebGL is supported at the moment)
-     */
-    graphicsContext?: ExcaliburGraphicsContext;
-    /**
-     * Optionally specify a vertex shader
-     *
-     * If none supplied the default will be used
-     *
-     * ```
-     *  #version 300 es
-     *  // vertex position in local space
-     *  in vec2 a_position;
-     *  in vec2 a_uv;
-     *  out vec2 v_uv;
-     *  // orthographic projection matrix
-     *  uniform mat4 u_matrix;
-     *  // world space transform matrix
-     *  uniform mat4 u_transform;
-     *  void main() {
-     *    // Set the vertex position using the ortho & transform matrix
-     *    gl_Position = u_matrix * u_transform * vec4(a_position, 0.0, 1.0);
-     *    // Pass through the UV coord to the fragment shader
-     *    v_uv = a_uv;
-     *  }
-     * ```
-     */
-    vertexSource?: string;
-    /**
-     * Add custom fragment shader
-     *
-     * *Note: Excalibur image alpha's are pre-multiplied
-     *
-     * Pre-built varyings:
-     *
-     * * `in vec2 v_uv` - UV coordinate
-     * * `in vec2 v_screenuv` - UV coordinate
-     *
-     * Pre-built uniforms:
-     *
-     * * `uniform sampler2D u_graphic` - The current graphic displayed by the GraphicsComponent
-     * * `uniform vec2 u_resolution` - The current resolution of the screen
-     * * `uniform vec2 u_size;` - The current size of the graphic
-     * * `uniform vec4 u_color` - The current color of the material
-     * * `uniform float u_opacity` - The current opacity of the graphics context
-     *
-     */
-    fragmentSource: string;
-    /**
-     * Add custom color, by default ex.Color.Transparent
-     */
-    color?: Color;
-    /**
-     * Add additional images to the material, you are limited by the GPU's maximum texture slots
-     *
-     * Specify a dictionary of uniform sampler names to ImageSource
-     */
-    images?: Record<string, ImageSource>;
-    /**
-     * Optionally set starting uniforms on a shader
-     */
-    uniforms?: UniformDictionary;
-}
-export interface MaterialImageOptions {
-    filtering?: ImageFiltering;
-}
-export declare class Material {
-    static BuiltInUniforms: string[];
-    private _logger;
-    private _name;
-    private _shader;
-    private _color;
-    private _initialized;
-    private _fragmentSource;
-    private _vertexSource;
-    private _images;
-    private _uniforms;
-    constructor(options: MaterialOptions);
-    private _initialize;
-    get uniforms(): UniformDictionary;
-    get images(): Record<string, ImageSource>;
-    get color(): Color;
-    set color(c: Color);
-    get name(): string;
-    get isUsingScreenTexture(): boolean;
-    get isOverridingGraphic(): boolean;
-    update(callback: (shader: Shader) => any): void;
-    getShader(): Shader | null;
-    addImageSource(samplerName: string, image: ImageSource): void;
-    removeImageSource(samplerName: string): void;
-    use(): void;
-}

package/build/dist/graphics/context/render-source.d.ts

@@ -1,7 +0,0 @@
-export declare class RenderSource {
-    private _gl;
-    private _texture;
-    constructor(_gl: WebGLRenderingContext, _texture: WebGLTexture);
-    use(): void;
-    disable(): void;
-}

package/build/dist/graphics/context/render-target.d.ts

@@ -1,60 +0,0 @@
-import { RenderSource } from './render-source';
-declare global {
-    interface WebGL2RenderingContext {
-        /**
-         * Experimental only in chrome
-         */
-        drawingBufferFormat?: number;
-    }
-}
-export interface RenderTargetOptions {
-    gl: WebGL2RenderingContext;
-    width: number;
-    height: number;
-    transparency: boolean;
-    /**
-     * Optionally enable render buffer multisample anti-aliasing
-     *
-     * By default false
-     */
-    antialias?: boolean;
-    /**
-     * Optionally specify number of anti-aliasing samples to use
-     *
-     * By default the max for the platform is used if antialias is on.
-     */
-    samples?: number;
-}
-export declare class RenderTarget {
-    width: number;
-    height: number;
-    transparency: boolean;
-    antialias: boolean;
-    samples: number;
-    private _gl;
-    readonly bufferFormat: number;
-    constructor(options: RenderTargetOptions);
-    setResolution(width: number, height: number): void;
-    private _renderBuffer;
-    get renderBuffer(): WebGLRenderbuffer;
-    private _renderFrameBuffer;
-    get renderFrameBuffer(): WebGLFramebuffer;
-    private _frameBuffer;
-    get frameBuffer(): WebGLFramebuffer;
-    private _frameTexture;
-    get frameTexture(): WebGLTexture;
-    private _setupRenderBuffer;
-    private _setupFramebuffer;
-    toRenderSource(): RenderSource;
-    blitToScreen(): void;
-    blitRenderBufferToFrameBuffer(): void;
-    copyToTexture(texture: WebGLTexture): void;
-    /**
-     * When called, all drawing gets redirected to this render target
-     */
-    use(): void;
-    /**
-     * When called, all drawing is sent back to the canvas
-     */
-    disable(): void;
-}

package/build/dist/graphics/post-processor/post-processor.d.ts

@@ -1,36 +0,0 @@
-import type { VertexLayout } from '../context/vertex-layout';
-import type { Shader } from '../context/shader';
-import type { ExcaliburGraphicsContextWebGL } from '../context/excalibur-graphics-context-webgl';
-/**
- * PostProcessors can be used to apply a shader to the entire screen. It is recommended
- * you use the {@apilink ScreenShader} to build your post processor shader.
- *
- * The screen texture comes through as this uniform
- *
- * `uniform sampler2D u_image`
- *
- * Post processor shaders get some default uniforms passed to them
- *
- * `uniform float u_time_ms` - total playback time in milliseconds
- * `uniform float u_elapsed_ms` - the elapsed time from the last frame in milliseconds
- * `uniform vec2 u_resolution` - the resolution of the canvas (in pixels)
- *
- * Custom uniforms can be updated in the {@apilink PostProcessor.onUpdate}
- */
-export interface PostProcessor {
-    initialize(graphicsContext: ExcaliburGraphicsContextWebGL): void;
-    getShader(): Shader;
-    getLayout(): VertexLayout;
-    /**
-     * Use the onUpdate hook to update any uniforms in the postprocessors shader
-     *
-     * The shader has already been bound so there is no need to call shader.use();
-     * @param elapsed
-     */
-    onUpdate?(elapsed: number): void;
-    /**
-     * Use the onDraw hook to upload any textures or command that need to run right before draw
-     * @param elapsed
-     */
-    onDraw?(): void;
-}

package/build/dist/interfaces/audio-implementation.d.ts

@@ -1,25 +0,0 @@
-import type { Audio } from './audio';
-export type ExResponseType = '' | 'arraybuffer' | 'blob' | 'document' | 'json' | 'text';
-export interface ExResponseTypesLookup {
-    [name: string]: ExResponseType;
-}
-export declare class ExResponse {
-    static type: ExResponseTypesLookup;
-}
-/**
- * Represents an audio implementation like {@apilink WebAudioInstance}
- */
-export interface AudioImplementation {
-    /**
-     * XHR response type
-     */
-    responseType: ExResponseType;
-    /**
-     * Processes raw data and transforms into sound data
-     */
-    processData(data: Blob | ArrayBuffer): Promise<string | AudioBuffer>;
-    /**
-     * Factory method that returns an instance of a played audio track
-     */
-    createInstance(data: string | AudioBuffer): Audio;
-}

package/build/dist/interfaces/audio.d.ts

@@ -1,55 +0,0 @@
-/**
- * Represents an audio control implementation
- */
-export interface Audio {
-    /**
-     * Whether the audio should loop (repeat forever)
-     */
-    loop: boolean;
-    /**
-     * The volume (between 0 and 1)
-     */
-    volume: number;
-    /**
-     * Set the playbackRate, default is 1.0 at normal speed.
-     * For example 2.0 is double speed, and 0.5 is half speed.
-     */
-    playbackRate: number;
-    /**
-     * Whether or not any audio is playing
-     */
-    isPlaying(): boolean;
-    /**
-     * Returns if the audio is paused
-     */
-    isPaused(): boolean;
-    /**
-     * Returns if the audio is stopped
-     */
-    isStopped(): boolean;
-    /**
-     * Will play the sound or resume if paused
-     */
-    play(): Promise<any>;
-    /**
-     * Seek to a position (in seconds) in the audio
-     * @param position
-     */
-    seek(position: number): void;
-    /**
-     * Return the duration of the sound
-     */
-    getTotalPlaybackDuration(): number;
-    /**
-     * Return the current playback time of the playing track in seconds from the start
-     */
-    getPlaybackPosition(): number;
-    /**
-     * Pause the sound
-     */
-    pause(): void;
-    /**
-     * Stop playing the sound and reset
-     */
-    stop(): void;
-}

package/build/dist/math/coord-plane.d.ts

@@ -1,15 +0,0 @@
-/**
- * Enum representing the coordinate plane for the position 2D vector in the {@apilink TransformComponent}
- */
-export declare enum CoordPlane {
-    /**
-     * The world coordinate plane (default) represents world space, any entities drawn with world
-     * space move when the camera moves.
-     */
-    World = "world",
-    /**
-     * The screen coordinate plane represents screen space, entities drawn in screen space are pinned
-     * to screen coordinates ignoring the camera.
-     */
-    Screen = "screen"
-}

package/build/dist/resources/sound/sound-manager.d.ts

@@ -1,102 +0,0 @@
-import { Sound } from './sound';
-export type AnyString = {} & string;
-export interface ChannelSoundsConfiguration {
-    sounds: Sound[];
-}
-export interface SoundConfig<Channel extends string = string> {
-    sound: Sound;
-    /**
-     * Maximum volume for the sound manager to use, all soundManager.play(.5) calls will
-     */
-    volume?: number;
-    /**
-     *
-     * You may also add a list of string `channels` to do group operations to sounds at once. For example mute all 'background' sounds.
-     */
-    channels?: Channel[];
-}
-export interface SoundManagerOptions<Channel extends string = string, SoundName extends string = string> {
-    /**
-     * Optionally specify the possible channels to avoid typo's
-     */
-    channels?: readonly Channel[];
-    /**
-     * Optionally set the default maximum volume for all sounds
-     *
-     * Default is 1 (100%)
-     */
-    volume?: number;
-    /**
-     * Optionally set the max `volume` for a `sound` to be when played. All other volume operations will be a fraction of the mix.
-     *
-     * You may also add a list of string `channels` to do group operations to sounds at once. For example mute all 'background' sounds.
-     *
-     */
-    sounds: Record<SoundName, Sound | SoundConfig<NoInfer<Channel>>>;
-}
-export type PossibleChannels<TSoundManagerOptions> = TSoundManagerOptions extends SoundManagerOptions<infer Channels> ? Channels : never;
-export type PossibleSounds<TSoundMangerOptions> = TSoundMangerOptions extends SoundManagerOptions ? Extract<keyof TSoundMangerOptions['sounds'], string> : never;
-export interface SoundManagerApi {
-    setVolume(name: string, volume?: number): void;
-    play(name: string, volume?: number): Promise<void>;
-    stop(name?: string): void;
-    mute(name?: string): void;
-    unmute(name?: string): void;
-    toggle(name?: string): void;
-}
-export declare class ChannelCollection<Channel extends string> implements SoundManagerApi {
-    soundManager: SoundManager<Channel, string>;
-    constructor(options: SoundManagerOptions<Channel, string>, soundManager: SoundManager<Channel, string>);
-    stop(name: string): void;
-    setVolume(name: Channel, volume?: number): void;
-    play(name: Channel, volume?: number): Promise<void>;
-    mute(name: Channel): void;
-    unmute(name: Channel): void;
-    toggle(name: Channel): void;
-}
-/**
- * Manage Sound volume levels without mutating the original Sound objects
- */
-export declare class SoundManager<Channel extends string, SoundName extends string> implements SoundManagerApi {
-    private _channelToConfig;
-    private _nameToConfig;
-    private _mix;
-    _muted: Set<Sound>;
-    private _all;
-    private _defaultVolume;
-    set defaultVolume(volume: number);
-    get defaultVolume(): number;
-    channel: ChannelCollection<Channel>;
-    constructor(options: SoundManagerOptions<Channel, SoundName>);
-    getSounds(): readonly Sound[];
-    getSoundsForChannel(channel: Channel | AnyString): readonly Sound[];
-    _isMuted(sound: Sound): boolean;
-    _getEffectiveVolume(sound: Sound): number;
-    play(soundName: SoundName, volume?: number): Promise<void>;
-    getSound(soundName: SoundName | AnyString): Sound | undefined;
-    setVolume(soundname: SoundName, volume?: number): void;
-    /**
-     * Gets the volumn for a sound
-     */
-    getVolume(soundName: SoundName): number;
-    /**
-     * Set the maximum volume a sound, if not set assumed to be 1.0 (100% of the source volume)
-     */
-    private _setMix;
-    track(name: SoundName | AnyString, soundOrConfig: Sound | SoundConfig): void;
-    /**
-     * Remove the maximum volume for a sound, will be 100% of the source volume
-     *
-     * Untracks the Sound in the sound manager
-     */
-    untrack(soundName: SoundName): void;
-    stop(name?: SoundName): void;
-    mute(name?: SoundName): void;
-    unmute(name?: SoundName): void;
-    toggle(name?: SoundName): void;
-    /**
-     * Apply a list of channels to a sound instance
-     */
-    addChannel(soundName: SoundName | AnyString, channels: Channel[] | AnyString[]): void;
-    removeChannel(soundName: SoundName | AnyString, channels: Channel[] | AnyString[]): void;
-}

package/build/dist/resources/sound/sound.d.ts

@@ -1,215 +0,0 @@
-import type { Audio } from '../../interfaces/audio';
-import type { Engine } from '../../engine';
-import { WebAudioInstance } from './web-audio-instance';
-import { NativeSoundEvent, NativeSoundProcessedEvent } from '../../events/media-events';
-import type { Loadable } from '../../interfaces/index';
-import { Logger } from '../../util/log';
-import type { EventKey, Handler, Subscription } from '../../event-emitter';
-import { EventEmitter } from '../../event-emitter';
-export interface SoundEvents {
-    volumechange: NativeSoundEvent;
-    processed: NativeSoundProcessedEvent;
-    pause: NativeSoundEvent;
-    stop: NativeSoundEvent;
-    playbackend: NativeSoundEvent;
-    resume: NativeSoundEvent;
-    playbackstart: NativeSoundEvent;
-}
-export declare const SoundEvents: {
-    VolumeChange: string;
-    Processed: string;
-    Pause: string;
-    Stop: string;
-    PlaybackEnd: string;
-    Resume: string;
-    PlaybackStart: string;
-};
-export interface SoundOptions {
-    /**
-     * @param paths A list of audio sources (clip.wav, clip.mp3, clip.ogg) for this audio clip. This is done for browser compatibility.
-     */
-    paths: string[];
-    /**
-     * Optionally bust the cache on load
-     *
-     * Default is false
-     */
-    bustCache?: boolean;
-    /**
-     * [0-1] 0% to 100%
-     *
-     * By default 1 (100%)
-     */
-    volume?: number;
-    /**
-     * Loop infinitely
-     */
-    loop?: boolean;
-    /**
-     * Multiplyer
-     *
-     * By default 1
-     */
-    playbackRate?: number;
-    /**
-     * Seconds?
-     *
-     * By default unset, will play the natural length of the clip
-     */
-    duration?: number;
-    /**
-     * Advance to a position in the audio clip
-     */
-    position?: number;
-}
-export interface PlayOptions {
-    /**
-     * Volume to play between [0, 1]
-     */
-    volume?: number;
-    /**
-     * Schedule time to play in milliseconds from the audio context origin
-     *
-     * Compute using the audio context
-     *
-     * ```typescript
-     * const sound: Sound = ...;
-     * const oneThousandMillisecondsFromNow = AudioContextFactory.currentTime + 1000;
-     *
-     * sound.play({ scheduledStartTime: oneThousandMillisecondsFromNow });
-     *
-     * ```
-     */
-    scheduledStartTime?: number;
-}
-/**
- * The {@apilink Sound} object allows games built in Excalibur to load audio
- * components, from soundtracks to sound effects. {@apilink Sound} is an {@apilink Loadable}
- * which means it can be passed to a {@apilink Loader} to pre-load before a game or level.
- */
-export declare class Sound implements Audio, Loadable<AudioBuffer> {
-    events: EventEmitter<SoundEvents>;
-    logger: Logger;
-    data: AudioBuffer;
-    private _resource;
-    position: number | undefined;
-    /**
-     * Indicates whether the clip should loop when complete
-     * @param value  Set the looping flag
-     */
-    set loop(value: boolean);
-    get loop(): boolean;
-    set volume(value: number);
-    get volume(): number;
-    private _duration;
-    /**
-     * Get the duration that this audio should play. If unset the total natural playback duration will be used.
-     */
-    get duration(): number | undefined;
-    /**
-     * Set the duration that this audio should play. If unset the total natural playback duration will be used.
-     *
-     * Note: if you seek to a specific point the duration will start from that point, for example
-     *
-     * If you have a 10 second clip, seek to 5 seconds, then set the duration to 2, it will play the clip from 5-7 seconds.
-     */
-    set duration(duration: number | undefined);
-    /**
-     * Return array of Current AudioInstances playing or being paused
-     */
-    get instances(): Audio[];
-    get path(): string;
-    set path(val: string);
-    /**
-     * Should excalibur add a cache busting querystring? By default false.
-     * Must be set before loading
-     */
-    get bustCache(): boolean;
-    set bustCache(val: boolean);
-    /**
-     * Schedule time to play in milliseconds from the audio context origin
-     *
-     * Compute using the audio context
-     *
-     * ```typescript
-     * const sound: Sound = ...;
-     * const oneThousandMillisecondsFromNow = AudioContextFactory.currentTime + 1000;
-     *
-     * sound.scheduledStartTime = oneThousandMillisecondsFromNow;
-     *
-     * ```
-     */
-    scheduledStartTime: number;
-    private _loop;
-    private _volume;
-    private _isStopped;
-    private _tracks;
-    private _engine?;
-    private _wasPlayingOnHidden;
-    private _playbackRate;
-    private _audioContext;
-    /**
-     * @param paths A list of audio sources (clip.wav, clip.mp3, clip.ogg) for this audio clip. This is done for browser compatibility.
-     */
-    constructor(options: SoundOptions);
-    constructor(...paths: string[]);
-    isLoaded(): boolean;
-    load(): Promise<AudioBuffer>;
-    decodeAudio(data: ArrayBuffer): Promise<AudioBuffer>;
-    wireEngine(engine: Engine): void;
-    /**
-     * Returns how many instances of the sound are currently playing
-     */
-    instanceCount(): number;
-    /**
-     * Whether or not the sound is playing right now
-     */
-    isPlaying(): boolean;
-    isPaused(): boolean;
-    isStopped(): boolean;
-    /**
-     * Play the sound, returns a promise that resolves when the sound is done playing
-     * An optional volume argument can be passed in to play the sound. Max volume is 1.0
-     */
-    play(volumeOrConfig?: number | PlayOptions): Promise<boolean>;
-    /**
-     * Stop the sound, and do not rewind
-     */
-    pause(): void;
-    /**
-     * Stop the sound if it is currently playing and rewind the track. If the sound is not playing, rewinds the track.
-     */
-    stop(): void;
-    get playbackRate(): number;
-    set playbackRate(playbackRate: number);
-    seek(position: number, trackId?: number): void;
-    getTotalPlaybackDuration(): number;
-    /**
-     * Return the current playback time of the playing track in seconds from the start.
-     *
-     * Optionally specify the track to query if multiple are playing at once.
-     * @param trackId
-     */
-    getPlaybackPosition(trackId?: number): number;
-    /**
-     * Get Id of provided AudioInstance in current trackList
-     * @param track {@apilink Audio} which Id is to be given
-     */
-    getTrackId(track: WebAudioInstance): number;
-    private _resumePlayback;
-    /**
-     * Starts playback, returns a promise that resolves when playback is complete
-     */
-    private _startPlayback;
-    private _getTrackInstance;
-    emit<TEventName extends EventKey<SoundEvents>>(eventName: TEventName, event: SoundEvents[TEventName]): void;
-    emit(eventName: string, event?: any): void;
-    on<TEventName extends EventKey<SoundEvents>>(eventName: TEventName, handler: Handler<SoundEvents[TEventName]>): Subscription;
-    on(eventName: string, handler: Handler<unknown>): Subscription;
-    once<TEventName extends EventKey<SoundEvents>>(eventName: TEventName, handler: Handler<SoundEvents[TEventName]>): Subscription;
-    once(eventName: string, handler: Handler<unknown>): Subscription;
-    off<TEventName extends EventKey<SoundEvents>>(eventName: TEventName, handler: Handler<SoundEvents[TEventName]>): void;
-    off(eventName: string, handler: Handler<unknown>): void;
-    off(eventName: string): void;
-    static fromBlob(blob: Blob): Promise<Sound>;
-}

package/build/dist/resources/sound/web-audio-instance.d.ts

@@ -1,49 +0,0 @@
-import type { Audio } from '../../interfaces/audio';
-/**
- * Internal class representing a Web Audio AudioBufferSourceNode instance
- * @see https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API
- */
-export declare class WebAudioInstance implements Audio {
-    private _src;
-    private _instance;
-    private _audioContext;
-    private _volumeNode;
-    private _playingFuture;
-    private _stateMachine;
-    private _createNewBufferSource;
-    private _handleEnd;
-    private _volume;
-    private _loop;
-    private _playStarted;
-    set loop(value: boolean);
-    get loop(): boolean;
-    set volume(value: number);
-    get volume(): number;
-    private _duration;
-    /**
-     * Returns the set duration to play, otherwise returns the total duration if unset
-     */
-    get duration(): number;
-    /**
-     * Set the duration that this audio should play.
-     *
-     * Note: if you seek to a specific point the duration will start from that point, for example
-     *
-     * If you have a 10 second clip, seek to 5 seconds, then set the duration to 2, it will play the clip from 5-7 seconds.
-     */
-    set duration(duration: number);
-    constructor(_src: AudioBuffer);
-    isPlaying(): boolean;
-    isPaused(): boolean;
-    isStopped(): boolean;
-    play(playStarted?: () => any): Promise<boolean>;
-    pause(): void;
-    stop(): void;
-    seek(position: number): void;
-    getTotalPlaybackDuration(): number;
-    getPlaybackPosition(): number;
-    private _playbackRate;
-    set playbackRate(playbackRate: number);
-    get playbackRate(): number;
-    scheduledStartTime: number;
-}

package/build/dist/util/decorators.d.ts

@@ -1,15 +0,0 @@
-/**
- * Obsolete decorator options
- */
-export interface ObsoleteOptions {
-    message?: string;
-    alternateMethod?: string;
-    showStackTrace?: boolean;
-}
-export declare const maxMessages = 5;
-export declare const resetObsoleteCounter: () => void;
-/**
- * Obsolete decorator for marking Excalibur methods obsolete, you can optionally specify a custom message and/or alternate replacement
- * method do the deprecated one. Inspired by https://github.com/jayphelps/core-decorators.js
- */
-export declare function obsolete(options?: ObsoleteOptions): any;