@zephyr3d/scene 0.5.0 → 0.6.1

package/dist/render/renderscheme.js

@@ -1,61 +0,0 @@
-import { Application } from '../app.js';
-
-/**
- * Base class for any kind of render scheme
- * @public
- */ class RenderScheme {
-    /** @internal */ _shadowMapFormat;
-    /** @internal */ _enableDepthPass;
-    /** @internal */ _currentScene;
-    /**
-   * Creates an instance of RenderScheme
-   */ constructor(){
-        this._shadowMapFormat = null;
-        this._enableDepthPass = false;
-        this._currentScene = null;
-    }
-    /** True if an early depth pass is required  */ get requireDepthPass() {
-        return this._enableDepthPass;
-    }
-    set requireDepthPass(val) {
-        this._enableDepthPass = !!val;
-    }
-    /** The scene that is currently been rendered */ get currentScene() {
-        return this._currentScene;
-    }
-    /**
-   * Renders a scene by given camera
-   * @param scene - The scene to be rendered
-   * @param camera - The camera that will be used to render the scene
-   */ renderScene(scene, camera, compositor) {
-        this._currentScene = scene;
-        const ctx = {
-            scene,
-            camera,
-            compositor
-        };
-        scene.frameUpdate();
-        if (camera && !Application.instance.device.isContextLost()) {
-            this._renderScene(ctx);
-        }
-        this._currentScene = null;
-    }
-    /**
-   * Disposes the render scheme
-   */ dispose() {
-        this._dispose();
-    }
-    /**
-   * Gets the texture format for shadow maps
-   * @returns Texture format for shadow maps
-   */ getShadowMapFormat() {
-        if (!this._shadowMapFormat) {
-            const device = Application.instance.device;
-            this._shadowMapFormat = device.getDeviceCaps().textureCaps.supportHalfFloatColorBuffer ? device.type === 'webgl' ? 'rgba16f' : 'r16f' : device.getDeviceCaps().textureCaps.supportFloatColorBuffer ? device.type === 'webgl' ? 'rgba32f' : 'r32f' : 'rgba8unorm';
-        }
-        return this._shadowMapFormat;
-    }
-}
-
-export { RenderScheme };
-//# sourceMappingURL=renderscheme.js.map

package/dist/render/renderscheme.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"renderscheme.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/render/temporalcache.js

@@ -1,222 +0,0 @@
-import { Application } from '../app.js';
-
-/**
- * Temporal framebuffer cache
- *
- * @internal
- */ class TemporalCache {
-    static _ownDepthTextures = new Set();
-    static _variantWidth = 0;
-    static _variantHeight = 0;
-    static _releaseFuncs = new Map();
-    static _cachedFrameBuffers = {};
-    static getFramebufferFixedSize(width, height, numLayers, colorFmt, depthFmt, colorType, depthType, mipmapping, sampleCount = 1) {
-        return this.getFramebuffer(width, height, numLayers, colorFmt, depthFmt, colorType, depthType, mipmapping, false, sampleCount);
-    }
-    static getFramebufferVariantSize(width, height, numLayers, colorFmt, depthFmt, colorType, depthType, mipmapping, sampleCount = 1) {
-        return this.getFramebuffer(width, height, numLayers, colorFmt, depthFmt, colorType, depthType, mipmapping, true, sampleCount);
-    }
-    static getFramebufferFixedSizeWithDepth(depthTex, numLayers, colorFmt, colorType, mipmapping, sampleCount = 1) {
-        return this.getFramebufferWithDepth(depthTex, numLayers, colorFmt, colorType, mipmapping, false, sampleCount);
-    }
-    static getFramebufferVariantSizeWithDepth(depthTex, numLayers, colorFmt, colorType, mipmapping, sampleCount = 1) {
-        return this.getFramebufferWithDepth(depthTex, numLayers, colorFmt, colorType, mipmapping, true, sampleCount);
-    }
-    static getFramebuffer(width, height, numLayers, colorFmt, depthFmt, colorType, depthType, mipmapping, variant, sampleCount) {
-        if (variant && (width !== this._variantWidth || height !== this._variantHeight)) {
-            this.purgeVariantFramebuffers();
-            this._variantWidth = width;
-            this._variantHeight = height;
-        }
-        if (colorType !== '2darray' && depthType !== '2darray') {
-            numLayers = 1;
-        }
-        const device = Application.instance.device;
-        if (device.type === 'webgl') {
-            sampleCount = 1;
-        }
-        const sizeHash = variant ? '' : `${width}x${height}`;
-        const fmtHash = `${colorFmt ?? ''}:${depthFmt ?? ''}:${colorFmt ? colorType : ''}:${numLayers}:${depthFmt ? depthType : ''}:${colorFmt && mipmapping ? 1 : 0}:${sampleCount}`;
-        const sizedFrameBuffers = this._cachedFrameBuffers[sizeHash];
-        const fbList = sizedFrameBuffers?.get(null)?.[fmtHash];
-        let fb = null;
-        if (!fbList || fbList.length === 0) {
-            let colorTex = null;
-            const opt = mipmapping ? {} : {
-                samplerOptions: {
-                    mipFilter: 'none'
-                }
-            };
-            if (colorFmt) {
-                switch(colorType){
-                    case '2d':
-                        colorTex = device.createTexture2D(colorFmt, width, height, opt);
-                        break;
-                    case '2darray':
-                        colorTex = device.createTexture2DArray(colorFmt, width, height, numLayers, opt);
-                        break;
-                    case 'cube':
-                        colorTex = device.createCubeTexture(colorFmt, width, opt);
-                        break;
-                }
-            }
-            let depthTex = null;
-            if (depthFmt) {
-                switch(depthType){
-                    case '2d':
-                        depthTex = device.createTexture2D(depthFmt, width, height);
-                        break;
-                    case '2darray':
-                        depthTex = device.createTexture2DArray(depthFmt, width, height, numLayers);
-                        break;
-                    case 'cube':
-                        depthTex = device.createCubeTexture(depthFmt, width);
-                        break;
-                }
-            }
-            fb = device.createFrameBuffer(colorTex ? [
-                colorTex
-            ] : [], depthTex, {
-                sampleCount,
-                ignoreDepthStencil: false
-            });
-            this._ownDepthTextures.add(depthTex);
-        } else {
-            fb = fbList.pop();
-        }
-        this._releaseFuncs.set(fb, variant ? this.releaseWithoutDepthTexVariantSize : this.releaseWithoutDepthTexFixedSize);
-        return fb;
-    }
-    static getFramebufferWithDepth(depth, numLayers, colorFmt, colorType, mipmapping, variant, sampleCount) {
-        if (variant && (depth.width !== this._variantWidth || depth.height !== this._variantHeight)) {
-            this.purgeVariantFramebuffers();
-            this._variantWidth = depth.width;
-            this._variantHeight = depth.height;
-        }
-        if (!colorFmt || colorType !== '2darray') {
-            numLayers = 1;
-        }
-        const device = Application.instance.device;
-        if (device.type === 'webgl') {
-            sampleCount = 1;
-        }
-        const sizeHash = variant ? '' : `${depth.width}x${depth.height}`;
-        const fmtHash = `${colorFmt ?? ''}:${depth.format}:${colorFmt ? colorType : ''}:${numLayers}:${depth.target}:${colorFmt && mipmapping ? 1 : 0}:${sampleCount}`;
-        const sizedFrameBuffers = this._cachedFrameBuffers[sizeHash];
-        const fbList = sizedFrameBuffers?.get(depth)?.[fmtHash];
-        let fb = null;
-        if (!fbList || fbList.length === 0) {
-            let colorTex = null;
-            const opt = mipmapping ? {} : {
-                samplerOptions: {
-                    mipFilter: 'none'
-                }
-            };
-            if (colorFmt) {
-                switch(colorType){
-                    case '2d':
-                        colorTex = device.createTexture2D(colorFmt, depth.width, depth.height, opt);
-                        break;
-                    case '2darray':
-                        colorTex = device.createTexture2DArray(colorFmt, depth.width, depth.height, numLayers, opt);
-                        break;
-                    case 'cube':
-                        colorTex = device.createCubeTexture(colorFmt, depth.width, opt);
-                        break;
-                }
-            }
-            fb = device.createFrameBuffer([
-                colorTex
-            ], depth, {
-                sampleCount,
-                ignoreDepthStencil: false
-            });
-            depth.on('disposed', ()=>{
-                const sizedFrameBuffers = this._cachedFrameBuffers[sizeHash];
-                const entry = sizedFrameBuffers?.get(depth);
-                if (entry) {
-                    for(const k in entry){
-                        const index = entry[k].indexOf(fb);
-                        if (index >= 0) {
-                            entry[k].splice(index, 1);
-                            if (entry[k].length === 0) {
-                                delete entry[k];
-                            }
-                        }
-                    }
-                    if (Object.getOwnPropertyNames(entry).length === 0) {
-                        sizedFrameBuffers.delete(depth);
-                    }
-                }
-                fb.getColorAttachments()[0]?.dispose();
-                fb.dispose();
-            });
-        } else {
-            fb = fbList.pop();
-        }
-        this._releaseFuncs.set(fb, variant ? this.releaseWithDepthTexVariantSize : this.releaseWithDepthTexFixedSize);
-        return fb;
-    }
-    static releaseFramebuffer(fb) {
-        const releaseFunc = this._releaseFuncs.get(fb);
-        if (releaseFunc) {
-            releaseFunc.call(this, fb);
-            this._releaseFuncs.delete(fb);
-        }
-    }
-    static releaseWithDepthTexFixedSize(fb) {
-        this.releaseFrameBufferInternal(fb, fb.getDepthAttachment(), true);
-    }
-    static releaseWithDepthTexVariantSize(fb) {
-        this.releaseFrameBufferInternal(fb, fb.getDepthAttachment(), false);
-    }
-    static releaseWithoutDepthTexFixedSize(fb) {
-        this.releaseFrameBufferInternal(fb, null, true);
-    }
-    static releaseWithoutDepthTexVariantSize(fb) {
-        this.releaseFrameBufferInternal(fb, null, false);
-    }
-    static releaseFrameBufferInternal(fb, withDepthTex, withSize) {
-        const tex = fb.getDepthAttachment() ?? fb.getColorAttachments()[0];
-        const sizeHash = withSize ? `${tex.width}x${tex.height}` : '';
-        let variantSizeFrameBuffers = this._cachedFrameBuffers[sizeHash];
-        if (!variantSizeFrameBuffers) {
-            variantSizeFrameBuffers = new Map();
-            this._cachedFrameBuffers[sizeHash] = variantSizeFrameBuffers;
-        }
-        const colorTex = fb.getColorAttachments()[0];
-        const depthTex = fb.getDepthAttachment();
-        const numLayers = colorTex?.isTexture2DArray() ? colorTex.depth : depthTex?.isTexture2DArray() ? depthTex.depth : 1;
-        const hash = `${colorTex?.format ?? ''}:${depthTex?.format ?? ''}:${colorTex ? colorTex.target : ''}:${numLayers}:${depthTex ? depthTex.target : ''}:${colorTex?.mipLevelCount > 1 ? 1 : 0}:${fb.getSampleCount()}`;
-        let entry = variantSizeFrameBuffers.get(withDepthTex);
-        if (!entry) {
-            entry = {};
-            variantSizeFrameBuffers.set(withDepthTex, entry);
-        }
-        let fblist = entry[hash];
-        if (!fblist) {
-            fblist = [];
-            entry[hash] = fblist;
-        }
-        fblist.push(fb);
-    }
-    static purgeVariantFramebuffers() {
-        const variantSizeFrameBuffers = this._cachedFrameBuffers[''];
-        variantSizeFrameBuffers?.forEach((val, key)=>{
-            for(const k in val){
-                val[k].forEach((fb)=>{
-                    fb.getColorAttachments()[0].dispose();
-                    fb.dispose();
-                });
-            }
-            if (this._ownDepthTextures.has(key)) {
-                this._ownDepthTextures.delete(key);
-                key?.dispose();
-            }
-        });
-        variantSizeFrameBuffers?.clear();
-    }
-}
-
-export { TemporalCache };
-//# sourceMappingURL=temporalcache.js.map

package/dist/scene/model.js

@@ -1,111 +0,0 @@
-import { AnimationClip } from '../animation/animation.js';
-import { GraphNode } from './graph_node.js';
-
-/**
- * Model node
- * @public
- */ class Model extends GraphNode {
-    /** @internal */ _animations;
-    /** @internal */ _animationIndex;
-    /** @internal */ _updateCallback;
-    /**
-   * Creates an instance of model node
-   * @param scene - The scene to which the model belongs
-   */ constructor(scene){
-        super(scene);
-        this._animations = {};
-        this._animationIndex = 0;
-        this._updateCallback = (evt)=>{
-            if (this.attached) {
-                this.update();
-            }
-        };
-    }
-    /**
-   * Creates a new animation for the model
-   * @param name - Name of the animation to be created
-   * @returns The created animation
-   */ createAnimation(name) {
-        if (!name) {
-            for(;;){
-                name = `animation${this._animationIndex++}`;
-                if (!this._animationIndex[name]) {
-                    break;
-                }
-            }
-        }
-        if (this._animations[name]) {
-            console.error(`Model.createAnimation() failed: animation '${name}' already exists`);
-            return null;
-        } else {
-            const ani = new AnimationClip(name, this);
-            this._animations[name] = ani;
-            return ani;
-        }
-    }
-    /**
-   * Deletes an animation of this model
-   * @param name - Name of the animation to be deleted
-   */ deleteAnimation(name) {
-        this.stopAnimation(name);
-        delete this._animations[name];
-    }
-    /**
-   * Gets names of all the animations of the model
-   * @returns An array of string that contains the animation names
-   */ getAnimationNames() {
-        return Object.keys(this._animations);
-    }
-    /**
-   * Updates all animations of the model
-   */ update() {
-        for(const k in this._animations){
-            this._animations[k].update();
-        }
-    }
-    /**
-   * Checks whether an animation is playing
-   * @param name - Name of the animation to be checked
-   * @returns true if the animation is playing, otherwise false
-   */ isPlayingAnimation(name) {
-        if (name) {
-            return this._animations[name]?.isPlaying();
-        } else {
-            for(const k in this._animations){
-                if (this._animations[k].isPlaying()) {
-                    return true;
-                }
-            }
-            return false;
-        }
-    }
-    /**
-   * Starts playing an animation of the model
-   * @param name - Name of the animation to play
-   * @param repeat - The repeat times, 0 for always repeating
-   */ playAnimation(name, repeat = 1) {
-        const ani = this._animations[name];
-        if (ani && !ani.isPlaying()) {
-            for (const name of this.getAnimationNames()){
-                if (this.isPlayingAnimation(name)) {
-                    this.stopAnimation(name);
-                }
-            }
-            ani.play(repeat, 1);
-            this.scene.on('sceneupdate', this._updateCallback);
-        }
-    }
-    /**
-   * Stops playing an animation of the model
-   * @param name - Name of the animation to stop playing
-   */ stopAnimation(name) {
-        const isPlaying = this.isPlayingAnimation();
-        this._animations[name]?.stop();
-        if (isPlaying && !this.isPlayingAnimation()) {
-            this.scene.off('sceneupdate', this._updateCallback);
-        }
-    }
-}
-
-export { Model };
-//# sourceMappingURL=model.js.map

package/dist/scene/model.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"model.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/scene/octree_update_visitor.js

@@ -1,20 +0,0 @@
-import { GraphNode } from './graph_node.js';
-
-/** @internal */ class OctreeUpdateVisitor {
-    /** @internal */ _octree;
-    constructor(octree){
-        this._octree = octree;
-    }
-    visit(node) {
-        if (node instanceof GraphNode) {
-            if (node.placeToOctree) {
-                this._octree.placeNode(node);
-            } else {
-                this._octree.removeNode(node);
-            }
-        }
-    }
-}
-
-export { OctreeUpdateVisitor };
-//# sourceMappingURL=octree_update_visitor.js.map

package/dist/scene/octree_update_visitor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"octree_update_visitor.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}

package/dist/shaders/builtins.js

@@ -1,110 +0,0 @@
-import { ShaderFramework } from './framework.js';
-import { encodeColorOutput } from './misc.js';
-import '../app.js';
-import { ScatteringLut } from '../render/scatteringlut.js';
-
-const MESH_MATERIAL = {
-    FRAGMENT_SHADER (scope, ctx) {
-        ShaderFramework.prepareFragmentShader(scope.$builder, ctx);
-    },
-    VERTEX_SHADER (scope, ctx) {
-        ShaderFramework.prepareVertexShader(scope.$builder, ctx);
-    },
-    FTRANSFORM (scope) {
-        ShaderFramework.ftransform(scope);
-    },
-    DEFINE_VERTEX_COLOR (color) {
-        return color.tag(ShaderFramework.USAGE_VERTEX_COLOR);
-    },
-    DEFINE_WORLD_NORMAL (normal) {
-        return normal.tag(ShaderFramework.USAGE_WORLD_NORMAL);
-    },
-    DEFINE_WORLD_TANGENT (tangent) {
-        return tangent.tag(ShaderFramework.USAGE_WORLD_TANGENT);
-    },
-    DEFINE_WORLD_BINORMAL (binormal) {
-        return binormal.tag(ShaderFramework.USAGE_WORLD_BINORMAL);
-    },
-    DEFINE_WORLD_POSITION (pos) {
-        return pos.tag(ShaderFramework.USAGE_WORLD_POSITION);
-    },
-    FRAGMENT_OUTPUT (scope, color) {
-        return encodeColorOutput(scope, color);
-    },
-    GET_WORLD_MATRIX (scope) {
-        return ShaderFramework.getWorldMatrix(scope);
-    },
-    GET_VIEW_PROJ_MATRIX (scope) {
-        return ShaderFramework.getViewProjectionMatrix(scope);
-    },
-    GET_ENVLIGHT_STRENGTH (scope) {
-        return ShaderFramework.getEnvLightStrength(scope);
-    },
-    GET_CAMERA_POSITION (scope) {
-        return ShaderFramework.getCameraPosition(scope);
-    },
-    GET_CAMERA_PARAMS (scope) {
-        return ShaderFramework.getCameraParams(scope);
-    },
-    GET_WORLD_POSITION (scope) {
-        return ShaderFramework.getWorldPosition(scope);
-    },
-    GET_WORLD_NORMAL (scope) {
-        return ShaderFramework.getWorldNormal(scope);
-    },
-    GET_WORLD_TANGENT (scope) {
-        return ShaderFramework.getWorldTangent(scope);
-    },
-    GET_WORLD_BINORMAL (scope) {
-        return ShaderFramework.getWorldBinormal(scope);
-    },
-    SET_CLIP_SPACE_POSITION (scope, pos) {
-        ShaderFramework.setClipSpacePosition(scope, pos);
-    },
-    DISCARD_IF_CLIPPED (scope) {
-        ShaderFramework.discardIfClipped(scope);
-    },
-    APPLY_FOG (scope, color, ctx) {
-        if (ctx.applyFog) {
-            const pb = scope.$builder;
-            if (ctx.env.sky.drawScatteredFog(ctx)) {
-                const funcName = 'applyAerialPerspective';
-                pb.func(funcName, [
-                    pb.vec4('color').inout()
-                ], function() {
-                    this.$l.viewDir = pb.sub(ShaderFramework.getWorldPosition(this).xyz, ShaderFramework.getCameraPosition(this));
-                    this.viewDir.y = pb.max(this.viewDir.y, 0);
-                    this.$l.distance = pb.mul(pb.length(this.viewDir), ShaderFramework.getWorldUnit(this));
-                    this.$l.sliceDist = pb.div(pb.mul(ShaderFramework.getCameraParams(this).y, ShaderFramework.getWorldUnit(this)), ScatteringLut.aerialPerspectiveSliceZ);
-                    this.$l.slice0 = pb.floor(pb.div(this.distance, this.sliceDist));
-                    this.$l.slice1 = pb.add(this.slice0, 1);
-                    this.$l.factor = pb.sub(pb.div(this.distance, this.sliceDist), this.slice0);
-                    this.$l.viewNormal = pb.normalize(this.viewDir);
-                    this.$l.zenithAngle = pb.asin(this.viewNormal.y);
-                    this.$l.horizonAngle = pb.atan2(this.viewNormal.z, this.viewNormal.x);
-                    this.$l.u0 = pb.div(pb.add(this.slice0, pb.div(this.horizonAngle, Math.PI * 2)), ScatteringLut.aerialPerspectiveSliceZ);
-                    this.$l.u1 = pb.add(this.u0, 1 / ScatteringLut.aerialPerspectiveSliceZ);
-                    this.$l.v = pb.div(this.zenithAngle, Math.PI / 2);
-                    this.$l.t0 = pb.textureSampleLevel(ShaderFramework.getAerialPerspectiveLUT(this), pb.vec2(this.u0, this.v), 0);
-                    this.$l.t1 = pb.textureSampleLevel(ShaderFramework.getAerialPerspectiveLUT(this), pb.vec2(this.u1, this.v), 0);
-                    this.$l.t = pb.mix(this.t0, this.t1, this.factor);
-                    this.color = pb.vec4(pb.add(pb.mul(this.color.rgb, this.factor), this.t.rgb), this.color.a);
-                });
-                scope[funcName](color);
-            } else {
-                const funcName = 'applyFog';
-                pb.func(funcName, [
-                    pb.vec4('color').inout()
-                ], function() {
-                    this.$l.viewDir = pb.sub(ShaderFramework.getWorldPosition(this).xyz, ShaderFramework.getCameraPosition(this));
-                    this.$l.fogFactor = ShaderFramework.computeFogFactor(this, this.viewDir, ShaderFramework.getFogType(this), ShaderFramework.getFogParams(this));
-                    this.color = pb.vec4(pb.mix(this.color.rgb, ShaderFramework.getFogColor(this).rgb, pb.mul(this.fogFactor, this.color.a, this.color.a)), this.color.a);
-                });
-                scope[funcName](color);
-            }
-        }
-    }
-};
-
-export { MESH_MATERIAL };
-//# sourceMappingURL=builtins.js.map

package/dist/shaders/builtins.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"builtins.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}