pixi-shadows.js

/* eslint-disable */
 
/*!
 * pixi-shadows - v1.1.0
 * Compiled Tue, 12 Jul 2022 21:19:40 UTC
 *
 * pixi-shadows is licensed under the MIT License.
 * http://www.opensource.org/licenses/mit-license
 * 
 * Copyright 2019-2020, Tar van Krieken, All Rights Reserved
 */
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var layers = require('@pixi/layers');
var display = require('@pixi/display');
var constants = require('@pixi/constants');
var core = require('@pixi/core');
var math = require('@pixi/math');
var sprite = require('@pixi/sprite');
require('@pixi/ticker');

// Some functions to map a value as a color
const filterFuncs = /*glsl*/ `
float colorToFloat(vec4 color){
    return (color.r + (color.g + color.b * 256.0) * 256.0) * 255.0 - 8388608.0;
}
vec4 floatToColor(float f){
    f += 8388608.0;
    vec4 color;
    color.a = 255.0;
    color.b = floor(f / 256.0 / 256.0);
    color.g = floor((f - color.b * 256.0 * 256.0) / 256.0);
    color.r = floor(f - color.b * 256.0 * 256.0 - color.g * 256.0);
    return color / 255.0;
}
`;

const maxDepthResolution = '2000.0';

class ShadowMapFilter extends core.Filter {
    __init() {this.autoFit = false;}
    __init2() {this.padding = 0;}
    __init3() {this.ignoreShadowCasterMatrix = new math.Matrix();}

    constructor( shadow) {
        super(
            /* glsl*/ `
            attribute vec2 aVertexPosition;
            attribute vec2 aTextureCoord;
            
            uniform mat3 projectionMatrix;
            uniform mat3 filterMatrix;
            
            varying vec2 vTextureCoord;
            varying vec2 vFilterCoord;
            
            void main(void){
                gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
                vTextureCoord = aTextureCoord;
            }
        `,
            /* glsl*/ `
            varying vec2 vMaskCoord;
            varying vec2 vTextureCoord;
            uniform vec4 filterArea;
            
            uniform sampler2D shadowCasterSampler;
            uniform vec2 shadowCasterSpriteDimensions;

            uniform bool hasIgnoreShadowCaster;
            uniform sampler2D ignoreShadowCasterSampler;
            uniform mat3 ignoreShadowCasterMatrix;
            uniform vec2 ignoreShadowCasterDimensions;

            uniform float lightRange;
            uniform float lightScatterRange;
            uniform vec2 lightLoc;

            uniform float depthResolution;
            uniform bool darkenOverlay;

            uniform vec2 dimensions;

            ${filterFuncs}
            
            void main(void){
                float pi = 3.141592653589793238462643;
                
                // Cap the depthResolution (as I expect performance loss by having a big value, but I am not sure)
                float depthRes = min(${maxDepthResolution}, depthResolution);

                // The current coordinate on the texutre measured in pixels, as well as a fraction
                vec2 pixelCoord = vTextureCoord * filterArea.xy;
                vec2 normalizedCoord = pixelCoord / dimensions;
                
                // Extract the components of the normalized coordinate
                float x = normalizedCoord.x;
                float y = normalizedCoord.y;

                // Calculate the offset of the lightPoint we are currently at
                float offsetAngle = 2.0 * pi * y;
                vec2 offset = vec2(cos(offsetAngle), sin(offsetAngle)) * lightScatterRange;

                // Calculate the angle at which we are ray tracing
                float angle = x * pi * 2.0;

                // The distance at which we hit an object
                float hitDistancePer = 1.0;

                // Increase the distance until we hit an object or reach the maximum value
                bool reached = false;
                for(float dist=0.0; dist < ${maxDepthResolution}; dist+=1.0){
                    if(dist > depthRes) break;
                    
                    // Calculate the actual distance in pixel units, and use it to calculate the pixel coordinate to inspect
                    float distance = dist / depthRes * lightRange;
                    vec2 coord = lightLoc + offset + vec2(cos(angle), sin(angle)) * distance;
                
                    // Extract the pixel and check if it is opaque
                    float opacity = texture2D(shadowCasterSampler, coord / shadowCasterSpriteDimensions).a;
                    if((opacity > 0.0 && darkenOverlay) || opacity > 0.5){
                        // Check if it isn't hitting something that should be ignore
                        if(hasIgnoreShadowCaster){ 
                            vec2 l = (ignoreShadowCasterMatrix * vec3(coord, 1.0)).xy / ignoreShadowCasterDimensions;
                            if(l.x >= -0.01 && l.x <= 1.01 && l.y >= -0.01 && l.y <= 1.01){
                                // If the pixel at the ignoreShadowCaster is opaque here, skip this pixel
                                if(opacity > 0.0){
                                    continue;
                                }
                            }
                        }

                        // Calculate the percentage at which this hit occurred, and stop the loop
                        if(!darkenOverlay){
                            hitDistancePer = distance / lightRange;
                            break;
                        }
                        reached = true;
                    }else if(reached){
                        hitDistancePer = (distance - 1.0) / lightRange;
                        break;
                    }
                }

                // Express the distance as a color in the map
                gl_FragColor = floatToColor(hitDistancePer * 100000.0);
            }
        `
        );this.shadow = shadow;ShadowMapFilter.prototype.__init.call(this);ShadowMapFilter.prototype.__init2.call(this);ShadowMapFilter.prototype.__init3.call(this);        this.uniforms.lightPointCount = shadow.pointCount;
        this.uniforms.dimensions = [shadow.radialResolution, shadow.pointCount];
    }

    apply(filterManager, input, output, clearMode) {
        // Decide whether or not to darken the overlays
        this.uniforms.darkenOverlay = this.shadow.darkenOverlay;

        // Attach the object sampler
        const sc = this.shadow._shadowCasterSprite;

        this.uniforms.shadowCasterSpriteDimensions = [sc.width, sc.height];
        this.uniforms.shadowCasterSampler = sc._texture;

        // Use the world transform (data about the absolute location on the screen) to determine the lights relation to the objectSampler
        const wt = this.shadow.worldTransform;
        const scale = Math.sqrt(wt.a * wt.a + wt.b * wt.b);
        const range = this.shadow.range * scale;

        this.uniforms.lightRange = range;
        this.uniforms.lightScatterRange = this.shadow.scatterRange;
        this.uniforms.lightLoc = [wt.tx, wt.ty];
        this.uniforms.depthResolution = range * this.shadow.depthResolution;

        // Check if there is an object that the filter should attempt to ignore
        const isc = this.shadow.ignoreShadowCaster;

        this.uniforms.hasIgnoreShadowCaster = !!isc;
        if (isc) {
            // Calculate the tranform matrix in order to access the proper pixel of the ignoreObject
            isc.worldTransform.copyFrom(this.ignoreShadowCasterMatrix);
            this.uniforms.ignoreShadowCasterMatrix = this.ignoreShadowCasterMatrix.invert();

            // Attach the ignore object
            this.uniforms.ignoreShadowCasterDimensions = [isc.width, isc.height];
            this.uniforms.ignoreShadowCasterSampler = isc._texture;
        }

        // Apply the filter
        filterManager.applyFilter(this, input, output, clearMode);
    }
}

class ShadowMaskFilter extends core.Filter {
     __init() {this.inverted = false;}

    __init2() {this.autoFit = false;}
    __init3() {this.padding = 0;}
    __init4() {this.overlayMatrix = new math.Matrix();}

    constructor( shadow) {
        super(
            /* glsl*/ `
            attribute vec2 aVertexPosition;
            attribute vec2 aTextureCoord;
            
            uniform mat3 projectionMatrix;
            uniform mat3 overlayMatrix;
            uniform mat3 filterMatrix;
            
            varying vec2 vTextureCoord;
            varying vec2 vOverlayCoord;
            varying vec2 vFilterCoord;
            
            void main(void){
                gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
                vTextureCoord = aTextureCoord;
                vOverlayCoord = (overlayMatrix * vec3(aTextureCoord, 1.0) ).xy;
            }
        `,
            /* glsl*/ `
            varying vec2 vOverlayCoord;
            varying vec2 vTextureCoord;
            uniform vec4 filterArea;
            
            uniform sampler2D shadowOverlaySampler;

            uniform vec2 dimensions;

            uniform sampler2D shadowSampler;

            uniform bool darkenOverlay;
            uniform bool inverted;

            uniform float overlayLightLength;

            uniform float lightPointCount;
            uniform float lightRange;
            uniform float lightScatterRange;
            uniform float lightIntensity;
            uniform float fallOffFraction;

            ${filterFuncs}
            
            void main(void){
                float pi = 3.141592653589793238462643;
                
                // The current coordinate on the texture measured in pixels
                vec2 pixelCoord = vTextureCoord * filterArea.xy;

                // The distance delta relative to the center
                vec2 lightDelta = pixelCoord - dimensions / 2.0;
                float distance = sqrt(lightDelta.x * lightDelta.x + lightDelta.y * lightDelta.y);
                if (distance > lightRange) return;

                // The final intensity of the light at this pixel
                float totalIntensity = 0.0;

                // The intensity of the pixel in the overlay map at this pixel
                vec4 overlayPixel = texture2D(shadowOverlaySampler, vOverlayCoord);

                // Go through all light points (at most 1000) to add them to the intensity
                for(float lightIndex=0.0; lightIndex<1000.0; lightIndex++){
                    if (lightIndex >= lightPointCount) break; // Stop the loop if we went over the pointCount

                    // Calculate the offset of this lightPoint, relative the the center of the light
                    float lightIndexFrac = (lightIndex + 0.5) / lightPointCount;
                    float offsetAngle = 2.0 * pi * lightIndexFrac;
                    vec2 offset = vec2(cos(offsetAngle), sin(offsetAngle)) * lightScatterRange;

                    // Calculate the location of this pixel relative to the lightPoint, and check the depth map
                    vec2 pointDelta = lightDelta - offset;
                    float pointDistance = sqrt(pointDelta.x * pointDelta.x + pointDelta.y * pointDelta.y);
                    float angle = mod(atan(pointDelta.y, pointDelta.x) + 2.0 * pi, 2.0 * pi);
                    vec4 depthPixel = texture2D(shadowSampler, vec2(angle / (2.0 * pi), lightIndexFrac));

                    // Extract the object distance from the depth map pixel
                    float objectDistance = colorToFloat(depthPixel) / 100000.0 * lightRange;
                    
                    // Calculate the intensity of this pixel based on the overlaySampler and objectDistance
                    float distFromEdge = lightRange - distance;
                    float fallOffDist = lightRange * fallOffFraction;
                    float defaultIntensity = min(1.0, distFromEdge/fallOffDist);


                    float intensity = 0.0;
                    if (darkenOverlay) {
                        if (objectDistance > pointDistance || objectDistance >= lightRange) {
                            intensity = defaultIntensity;
                        }else if (overlayPixel.a > 0.5) {
                            intensity = defaultIntensity * pow(1.0 - (distance - objectDistance) / (lightRange - objectDistance), 2.5) * overlayPixel.a;
                        }
                    } else {
                        if (inverted) {
                            if (overlayPixel.a > 0.5) {
                                intensity = 1.0-overlayPixel.a;
                            }else if (objectDistance > pointDistance || objectDistance >= lightRange) {
                                intensity = 0.0;
                            }else{
                                intensity = 1.0;
                            }
                        }else{
                            if (objectDistance > pointDistance || objectDistance >= lightRange) {
                                intensity = defaultIntensity;
                            }else if (overlayPixel.a > 0.5) {
                                intensity = defaultIntensity * (1.0 - (pointDistance - objectDistance) / overlayLightLength);
                            }
                        }
                    }
                    

                    // Add the intensity to the total intensity
                    totalIntensity += intensity / lightPointCount;
                }

                // Create a mask based on the intensity
                gl_FragColor = vec4(vec3(lightIntensity * totalIntensity), 1.0);
            }
        `
        );this.shadow = shadow;ShadowMaskFilter.prototype.__init.call(this);ShadowMaskFilter.prototype.__init2.call(this);ShadowMaskFilter.prototype.__init3.call(this);ShadowMaskFilter.prototype.__init4.call(this);
        this.uniforms.shadowSampler = shadow._shadowMapResultTexture;
        this.uniforms.lightPointCount = shadow.pointCount;
    }

    apply(filterManager, input, output, clearMode) {
        // Update simple uniforms
        this.uniforms.fallOffFraction = this.shadow.fallOffFraction;
        this.uniforms.darkenOverlay = this.shadow.darkenOverlay;

        // Attach the object sampler
        const sc = this.shadow._shadowOverlaySprite;

        this.uniforms.shadowOverlaySpriteDimensions = [sc.width, sc.height];
        this.uniforms.shadowOverlaySampler = sc._texture;

        // Use the world transform (data about the absolute location on the screen) to determine the lights relation to the objectSampler
        const wt = this.shadow.worldTransform;
        const scale = Math.sqrt(wt.a * wt.a + wt.b * wt.b);
        const range = this.shadow.range * scale;

        this.uniforms.lightRange = range;
        this.uniforms.lightScatterRange = this.shadow.scatterRange;
        this.uniforms.lightIntensity = this.shadow.intensity;

        // The length of the area of the overlay to be lit
        this.uniforms.overlayLightLength = this.shadow.overlayLightLength;

        // Invert the filter if specified
        this.uniforms.inverted = this.inverted;

        // Texture size increase in order to fit the sprite rectangle (even though we are only interested in a circle)
        // So we have to consider this in the texture size
        const texSize = 2 * this.shadow.range * (wt.a + wt.b);

        this.uniforms.dimensions = [texSize, texSize];

        // Calculate the object sampler position in relation to the light
        this.uniforms.overlayMatrix = filterManager.calculateSpriteMatrix(this.overlayMatrix, sc);

        // Apply the filter
        filterManager.applyFilter(this, input, output, clearMode);
    }
}

/**
 * @class
 * @memberof PIXI.shadows
 *
 * @param range {number} The radius of the lit area in pixels.
 * @param [intensity=1] {number} The opacity of the lit area.
 * @param [pointCount=20] {number} The number of points that makes up this light.
 * @param [scatterRange=15] {number} The radius at which the points of the light should be scattered.
 */

class Shadow extends sprite.Sprite {
    /**
     * The of steps to take per pixel. (Higher resolution = more precise edges + more intensive).
     */
    __init() {this.depthResolution = 1;} // per screen pixel
    /**
     * Whther or not overlays in shadows should become darker (can create odd artifacts, is very experimental/unfinished)
     */
    __init2() {this.darkenOverlay = false;}

    /**
     * How many pixels of the overlay should be lit up by the light
     */
    __init3() {this.overlayLightLength = Infinity;}

    /**
     * A shadow caster to ignore while creating the shadows. (Can be used if sprite and light always overlap).
     */
    

    /**
     * The fraction of the range over which the light will fall-off linearly
     */
    __init4() {this.fallOffFraction = 1.0;}

    
    
    

    
    
    

    

    /**
     * @param range The radius of the lit area in pixels.
     * @param intensity The opacity of the lit area.
     * @param pointCount The number of points that makes up this light.
     * @param scatterRange The radius at which the points of the light should be scattered.
     */
    constructor(
         _range,
        /**
         * The opacity of the lit area. (may exceed 1).
         */
         intensity = 1,
         _pointCount = 20,
        /**
         * The radius at which the points of the light should be scattered. (Greater range = softer shadow boundary).
         */
         scatterRange = _pointCount === 1 ? 0 : 15,
         _radialResolution = 800
    ) {
        super(
            core.RenderTexture.create({
                width: _range * 2,
                height: _range * 2,
            })
        );this._range = _range;this.intensity = intensity;this._pointCount = _pointCount;this.scatterRange = scatterRange;this._radialResolution = _radialResolution;Shadow.prototype.__init.call(this);Shadow.prototype.__init2.call(this);Shadow.prototype.__init3.call(this);Shadow.prototype.__init4.call(this);
        this.anchor.set(0.5);

        this.__createShadowMapSources();
    }
    // Create the texture to apply this mask filter to
    __updateTextureSize() {
        this.texture.destroy();
        this.texture = core.RenderTexture.create({
            width: this._range * 2,
            height: this._range * 2,
        });
    }
    // Create the resources that create the shadow map
    __createShadowMapSources() {
        if (this._shadowMapSprite) this._shadowMapSprite.destroy();
        if (this.shadowMapResultSprite) this.shadowMapResultSprite.destroy();
        if (this._shadowMapResultTexture) this._shadowMapResultTexture.destroy();

        // A blank texture/sprite to apply the filter to
        this._shadowMapResultTexture = core.RenderTexture.create({
            width: this._radialResolution,
            height: this._pointCount,
        });
        this._shadowMapResultTexture.baseTexture.scaleMode = constants.SCALE_MODES.NEAREST;
        this._shadowMapSprite = new sprite.Sprite(this._shadowMapResultTexture);
        this._shadowMapSprite.filters = [new ShadowMapFilter(this)];

        // The resulting texture/sprite after the filter has been applied
        this.shadowMapResultSprite = new sprite.Sprite(this._shadowMapResultTexture);

        // Create the mask filter
        const filter = new ShadowMaskFilter(this);

        filter.blendMode = constants.BLEND_MODES.ADD;
        this.shadowFilter = filter;
        this.filters = [filter];
    }
    // Properly dispose all the created resources
    destroy() {
        if (this._shadowMapSprite) this._shadowMapSprite.destroy();
        if (this.shadowMapResultSprite) this.shadowMapResultSprite.destroy();
        if (this._shadowMapResultTexture) this._shadowMapResultTexture.destroy();
        this.texture.destroy();

        return super.destroy();
    }
    // Don't render this sprite unless we are in the dedicated render step called by the shadow filter
    renderAdvanced(renderer) {
        if (this.renderStep) super.renderAdvanced(renderer);
    }

    // Update the map to create the mask from
    update(renderer, shadowCasterSprite, shadowOverlaySprite) {
        this._shadowCasterSprite = shadowCasterSprite;
        this._shadowOverlaySprite = shadowOverlaySprite;
        renderer.render(this._shadowMapSprite, {
            renderTexture: this._shadowMapResultTexture,
            clear: true,
            skipUpdateTransform: true,
        });
    }

    // Attribute getters + setters

    /**
     * @type {number} The radius of the lit area in pixels.
     */
    set range(range) {
        this._range = range;
        this.__updateTextureSize();
    }
    get range() {
        return this._range;
    }

    /**
     * @type {number} The number of points that makes up this light, for soft shadows. (More points = softer shadow edges + more intensive).
     */
    set pointCount(count) {
        this._pointCount = count;
        this.__createShadowMapSources();
    }
    get pointCount() {
        return this._pointCount;
    }

    /**
     * @type {number} The number of rays to draw for the light. (Higher resolution = more precise edges + more intensive).
     */
    set radialResolution(resolution) {
        this._radialResolution = resolution;
        this.__createShadowMapSources();
    }
    get radialResolution() {
        return this._radialResolution;
    }
}

class ShadowFilter extends core.Filter {
     __init() {this.tick = 0;}
     __init2() {this._useShadowCastersAsOverlay = true;}
    
    
    
    
    
    
    
    
    
    
    constructor( _width,  _height) {
        super(
            /* glsl*/ `
            attribute vec2 aVertexPosition;
            attribute vec2 aTextureCoord;
            
            uniform mat3 projectionMatrix;
            uniform mat3 otherMatrix;
            
            varying vec2 vMaskCoord;
            varying vec2 vTextureCoord;
            
            void main(void)
            {
                gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
            
                vTextureCoord = aTextureCoord;
                vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;
            }
        `,
            /* glsl*/ `                    
            varying vec2 vMaskCoord;
            varying vec2 vTextureCoord;
            
            uniform sampler2D uSampler;
            uniform sampler2D mask;
            uniform vec4 maskClamp;
            uniform float ambientLight;
            
            void main(void){            
                vec4 original = texture2D(uSampler, vTextureCoord);
                vec4 masky = texture2D(mask, vMaskCoord);
            
                original *= ambientLight + (1.0 - ambientLight) * (masky.r + masky.g + masky.b) / 3.0;
            
                gl_FragColor = original;
            }
        `
        );this._width = _width;this._height = _height;ShadowFilter.prototype.__init.call(this);ShadowFilter.prototype.__init2.call(this);
        this.uniforms.ambientLight = 0.0;
        this.uniforms.size = [this._width, this._height];

        this.__createCasterSources();
        this.__createOverlaySources();
        this.__createMaskSources();
    }
    // Shadow overlay objects
    __createOverlaySources() {
        if (this._shadowOverlayResultTexture) this._shadowOverlayResultTexture.destroy();
        if (this._shadowOverlayResultSprite) this._shadowOverlayResultSprite.destroy();

        if (!this._shadowOverlayContainer) this._shadowOverlayContainer = new display.Container();

        // Create the final mask to apply to the container that this filter is applied to
        this._shadowOverlayResultTexture = core.RenderTexture.create({ width: this._width, height: this._height });
        this._shadowOverlayResultTexture.baseTexture.scaleMode = constants.SCALE_MODES.NEAREST;
        this._shadowOverlayResultSprite = new sprite.Sprite(this._shadowOverlayResultTexture);
    }
    // Shadow caster objects
    __createCasterSources() {
        if (this._shadowCasterResultTexture) this._shadowCasterResultTexture.destroy();
        if (this._shadowCasterResultSprite) this._shadowCasterResultSprite.destroy();

        if (!this._shadowCasterContainer) this._shadowCasterContainer = new display.Container();

        // Create the final mask to apply to the container that this filter is applied to
        this._shadowCasterResultTexture = core.RenderTexture.create({ width: this._width, height: this._height });
        this._shadowCasterResultTexture.baseTexture.scaleMode = constants.SCALE_MODES.NEAREST;
        this._shadowCasterResultSprite = new sprite.Sprite(this._shadowCasterResultTexture);
    }
    // Final mask to apply as a filter
    __createMaskSources() {
        if (this._maskResultTexture) this._maskResultTexture.destroy();
        if (this._maskResultSprite) this._maskResultSprite.destroy();

        // Create maskMatrix for shader transform data
        if (!this._maskMatrix) this._maskMatrix = new math.Matrix();

        // Create the final mask to apply to the container that this filter is applied to
        this._maskResultTexture = core.RenderTexture.create({ width: this._width, height: this._height });
        this._maskResultTexture.baseTexture.scaleMode = constants.SCALE_MODES.NEAREST;
        if (!this._maskContainer) this._maskContainer = new display.Container();
        this._maskResultSprite = new sprite.Sprite(this._maskResultTexture);
    }
    // Update the mask texture (called from the Application mixin)
    update(renderer) {
        // Shadows and objects will automatically be added to containers because of the Container mixin

        this.tick++; // Increase the tick so that shadows and objects know they can add themselves to the container again in their next update

        /* render shadow casters */
        // Remove the parent layer from the objects in order to properly render it to the container
        this._shadowCasterContainer.children.forEach((child) => {
            child._activeParentLayer = null;
        });

        // Render all the objects onto 1 texture
        renderer.render(this._shadowCasterContainer, {
            renderTexture: this._shadowCasterResultTexture,
            clear: true,
            skipUpdateTransform: true,
        });

        // Remove all the objects from the container
        this._shadowCasterContainer.children.length = 0;

        /* render shadow overlays */
        if (!this._useShadowCastersAsOverlay) {
            this._shadowOverlayContainer.children.forEach((child) => {
                child._activeParentLayer = null;
            });

            // Render all the objects onto 1 texture
            renderer.render(this._shadowOverlayContainer, {
                renderTexture: this._shadowOverlayResultTexture,
                clear: true,
                skipUpdateTransform: true,
            });

            // Remove all the objects from the container
            this._shadowOverlayContainer.children.length = 0;
        }

        /* render shadows */

        // Update all shadows and indicate that they may properly be rendered now
        const overlay = this._useShadowCastersAsOverlay
            ? this._shadowCasterResultSprite
            : this._shadowOverlayResultSprite;

        this._maskContainer.children.forEach((shadow) => {
            if (shadow instanceof Shadow) {
                shadow.renderStep = true;
                shadow.update(renderer, this._shadowCasterResultSprite, overlay);
            }
        });

        // Render all the final shadow masks onto 1 texture
        renderer.render(this._maskContainer, {
            renderTexture: this._maskResultTexture,
            clear: true,
            skipUpdateTransform: true,
        });

        // Indicate that the shadows may no longer render
        this._maskContainer.children.forEach((shadow) => {
            if (shadow instanceof Shadow) {
                delete shadow.renderStep;
            }
        });

        // Remove all the shadows from the container
        this._maskContainer.children.length = 0;
    }

    //  Apply the filter to a container
    apply(filterManager, input, output, clearMode) {
        // Filter almost directly taken from the pixi mask filter
        const maskSprite = this._maskResultSprite;
        const tex = this._maskResultSprite.texture;

        if (!tex.valid) {
            return;
        }

        // TODO: uvMatrix ?
        // if (!tex.transform) {
        //   tex.transform = new TextureMatrix(tex, 0.0);
        // }

        this.uniforms.mask = tex;
        this.uniforms.otherMatrix = filterManager.calculateSpriteMatrix(this._maskMatrix, maskSprite);

        filterManager.applyFilter(this, input, output, clearMode);
    }

    // Attribute getters + setters
    /**
     * @type {number} The brightness that unlit areas of the world should have
     */
    set ambientLight(frac) {
        this.uniforms.ambientLight = frac;
    }
    get ambientLight() {
        return this.uniforms.ambientLight ;
    }
    /**
     * @type {number} The width of your application
     */
    set width(width) {
        this._width = width;

        this.uniforms.size = [this._width, this._height];
        this.__createOverlaySources();
        this.__createCasterSources();
        this.__createMaskSources();
    }
    get width() {
        return this._width;
    }
    /**
     * @type {number} The height of your application
     */
    set height(height) {
        this._height = height;

        this.uniforms.size = [this._width, this._height];
        this.__createOverlaySources();
        this.__createCasterSources();
        this.__createMaskSources();
    }
    get height() {
        return this._height;
    }
    /**
     * @type {boolean} Whether or not to use shadow casters as shadow overlays as well
     */
    set useShadowCasterAsOverlay(val) {
        this._useShadowCastersAsOverlay = val;
    }

    get useShadowCasterAsOverlay() {
        return this._useShadowCastersAsOverlay;
    }
}

function augmentApplication(application, shadowFilter) {
    // Replace the stage with a layered stage
    application.stage = new layers.Stage();

    // Remove the current render function
    // eslint-disable-next-line @typescript-eslint/unbound-method
    application.ticker.remove(application.render, application);

    // Overwrite the render function
    application.render = function render() {
        // Update stage transforms
        const cacheParent = this.stage.parent;
        // this.stage.parent = this.renderer._tempDisplayObjectParent;
        // this.stage.parent = this.stage._tempDisplayObjectParent;

        this.stage.parent = this.stage;
        this.stage.updateTransform();
        this.stage.parent = cacheParent;

        // Update the shadow filter
        shadowFilter.update(this.renderer);

        // Render the stage without updating the transforms again
        this.renderer.render(this.stage, { skipUpdateTransform: true });
    };

    // Reassign ticker because its setter initialises the render method
    // eslint-disable-next-line no-self-assign
    application.ticker = application.ticker;
}

function augmentContainer(shadowCasterGroup, shadowOverlayGroup, shadowFilter) {
    // eslint-disable-next-line @typescript-eslint/unbound-method
    const orTransform = display.Container.prototype.updateTransform;
    const ticks = new WeakMap();

    display.Container.prototype.updateTransform = function updateTransform( ...args) {
        if (this.parentGroup === shadowCasterGroup) {
            if (ticks.get(this) !== shadowFilter.tick) shadowFilter._shadowCasterContainer.children.push(this);
            ticks.set(this, shadowFilter.tick);
        }

        if (this.parentGroup === shadowOverlayGroup) {
            if (ticks.get(this) !== shadowFilter.tick) shadowFilter._shadowOverlayContainer.children.push(this);
            ticks.set(this, shadowFilter.tick);
        }

        if (this instanceof Shadow) {
            if (ticks.get(this) !== shadowFilter.tick) shadowFilter._maskContainer.children.push(this);
            ticks.set(this, shadowFilter.tick);
        }

        return orTransform.apply(this, args) ;
    };
}

function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }








class Shadows {
    // The objects that will cast shadows
    __init() {this.casterGroup = new layers.Group();}
    // The objects that will remain ontop of the shadows
    __init2() {this.overlayGroup = new layers.Group();}
    
    __init3() {this.container = new display.Container();}
    constructor(app, options) {Shadows.prototype.__init.call(this);Shadows.prototype.__init2.call(this);Shadows.prototype.__init3.call(this);
        // // Create the shadow filter
        this.filter = new ShadowFilter(app.renderer.width, app.renderer.height);
        // Set up the container mixin so that it tells the filter about the available shadows and objects
        augmentContainer(this.casterGroup, this.overlayGroup, this.filter);
        // Overwrite the application render method
        augmentApplication(app, this.filter);
        app.stage.addChild(this.container);

        if (_optionalChain([options, 'optionalAccess', _ => _.pixiLights])) {
            // Set up pixi-light's layers
            const diffuseLayer = new layers.Layer(options.pixiLights.diffuseGroup);
            const normalLayer = new layers.Layer(options.pixiLights.normalGroup);
            const lightLayer = new layers.Layer(options.pixiLights.lightGroup);
            const diffuseBlackSprite = new sprite.Sprite(diffuseLayer.getRenderTexture());

            diffuseBlackSprite.tint = 0;
            // Set up the lighting layers
            app.stage.addChild(diffuseLayer, diffuseBlackSprite, normalLayer, lightLayer);
            // Add the shadow filter to the diffuse layer
            app.stage.filters = [this.filter];
        } else {
            this.container.filters = [this.filter];
        }
    }
}









const AppLoaderPlugin = {
    init( options) {
        this.shadows = new Shadows(this, options.fov);
    },
    destroy() {
        delete this.shadows;
    },
};

exports.AppLoaderPlugin = AppLoaderPlugin;
exports.Shadow = Shadow;
exports.ShadowFilter = ShadowFilter;
exports.ShadowMaskFilter = ShadowMaskFilter;
exports.Shadows = Shadows;
exports.augmentApplication = augmentApplication;
exports.augmentContainer = augmentContainer;
exports.filterFuncs = filterFuncs;
//# sourceMappingURL=pixi-shadows.js.map