@woosh/meep-engine 3.3.0 → 3.4.0

package/src/engine/graphics/render/frame_graph/webgl/WebGLRenderContext.d.ts

@@ -1,19 +0,0 @@
-export class WebGLRenderContext extends IFrameGraphContext {
-    /**
-     *
-     * @param {WebGL2RenderingContext} ctx
-     */
-    constructor(ctx: WebGL2RenderingContext);
-    createResource(descriptor: any): RenderTarget;
-    destroyResource(resource: any, descriptor: any): boolean;
-    /**
-     *
-     * @param {TextureDescriptor} descriptor
-     */
-    createRenderTarget(descriptor: TextureDescriptor): RenderTarget;
-    destroyRenderTarget(target: any): boolean;
-    #private;
-}
-import { IFrameGraphContext } from "../IFrameGraphContext.js";
-import { RenderTarget } from "../resource/RenderTarget.js";
-//# sourceMappingURL=WebGLRenderContext.d.ts.map

package/src/engine/graphics/render/frame_graph/webgl/WebGLRenderContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WebGLRenderContext.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/frame_graph/webgl/WebGLRenderContext.js"],"names":[],"mappings":"AAGA;IAOI;;;OAGG;IACH,iBAFW,sBAAsB,EAMhC;IAED,8CAQC;IAED,yDAWC;IAED;;;OAGG;IACH,gEASC;IAED,0CAEC;;CACJ;mCA7DkC,0BAA0B;6BAChC,6BAA6B"}

package/src/engine/graphics/render/frame_graph/webgl/WebGLRenderContext.js

@@ -1,62 +0,0 @@
-import { IFrameGraphContext } from "../IFrameGraphContext.js";
-import { RenderTarget } from "../resource/RenderTarget.js";
-
-export class WebGLRenderContext extends IFrameGraphContext {
-    /**
-     *
-     * @type {WebGL2RenderingContext|null}
-     */
-    #gl = null;
-
-    /**
-     *
-     * @param {WebGL2RenderingContext} ctx
-     */
-    constructor(ctx) {
-        super();
-
-        this.#gl = ctx;
-    }
-
-    createResource(descriptor) {
-        const resource_type = descriptor.type;
-
-        if(resource_type === "texture"){
-            return this.createRenderTarget(descriptor);
-        }
-
-        throw new Error(`Unsupported resource type ${resource_type}`);
-    }
-
-    destroyResource(resource, descriptor) {
-
-
-        const resource_type = descriptor.type;
-
-        if(resource_type === "texture"){
-            return this.destroyRenderTarget(resource);
-        }
-
-        throw new Error(`Unsupported resource type ${resource_type}`);
-
-    }
-
-    /**
-     *
-     * @param {TextureDescriptor} descriptor
-     */
-    createRenderTarget(descriptor) {
-        console.log("createRenderTarget", descriptor)
-
-        const rt = new RenderTarget();
-
-        rt.descriptor = descriptor;
-        rt.handle = 0;
-
-        return rt;
-    }
-
-    destroyRenderTarget(target) {
-        return true;
-    }
-}

package/src/engine/graphics/shaders/AlphaBlendShader.d.ts

@@ -1,18 +0,0 @@
-export default AlphaBlendShader;
-declare namespace AlphaBlendShader {
-    namespace uniforms {
-        namespace tDiffuse1 {
-            let type: string;
-            let value: any;
-        }
-        namespace tDiffuse2 {
-            let type_1: string;
-            export { type_1 as type };
-            let value_1: any;
-            export { value_1 as value };
-        }
-    }
-    let vertexShader: string;
-    let fragmentShader: string;
-}
-//# sourceMappingURL=AlphaBlendShader.d.ts.map

package/src/engine/graphics/shaders/AlphaBlendShader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AlphaBlendShader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shaders/AlphaBlendShader.js"],"names":[],"mappings":""}

package/src/engine/graphics/shaders/AlphaBlendShader.js

@@ -1,42 +0,0 @@
-
-const AlphaBlendShader = {
-
-    uniforms: {
-
-        "tDiffuse1": { type: "t", value: null },
-        "tDiffuse2": { type: "t", value: null }
-    },
-
-    vertexShader: [
-
-        "varying vec2 vUv;",
-
-        "void main() {",
-
-        "vUv = uv;",
-        "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-
-        "}"
-
-    ].join("\n"),
-
-    fragmentShader: [
-
-        "uniform sampler2D tDiffuse1;",
-        "uniform sampler2D tDiffuse2;",
-
-        "varying vec2 vUv;",
-
-        "void main() {",
-
-        "vec4 source = texture2D( tDiffuse1, vUv );",
-        "vec4 destination = texture2D( tDiffuse2, vUv );",
-        "gl_FragColor = source + destination.rgba*(1.0-source.a);",
-        //"gl_FragColor = source+destination;",
-        "}"
-
-    ].join("\n")
-
-};
-
-export default AlphaBlendShader;

package/src/engine/graphics/shaders/ClearShader.d.ts

@@ -1,8 +0,0 @@
-export default ClearShader;
-declare namespace ClearShader {
-    let defines: {};
-    let uniforms: {};
-    let vertexShader: string;
-    let fragmentShader: string;
-}
-//# sourceMappingURL=ClearShader.d.ts.map

package/src/engine/graphics/shaders/ClearShader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClearShader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shaders/ClearShader.js"],"names":[],"mappings":""}

package/src/engine/graphics/shaders/ClearShader.js

@@ -1,28 +0,0 @@
-
-const ClearShader = {
-
-    defines: {},
-
-    uniforms: {},
-
-    vertexShader: [
-
-        "void main() {",
-
-        "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-
-        "}"
-
-    ].join("\n"),
-    fragmentShader: [
-        "void main() {",
-
-        "   gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);",
-
-        "}"
-
-
-    ].join("\n")
-};
-
-export default ClearShader;

package/src/engine/graphics/shaders/ScreenSpaceQuadShader.d.ts

@@ -1,13 +0,0 @@
-export namespace ScreenSpaceQuadShader {
-    export { vertexShader };
-    export { fragmentShader };
-}
-declare function vertexShader(): string;
-/**
- *
- * @param {string[]} [swizzle] what to read from the texture
- * @returns {string}
- */
-declare function fragmentShader(swizzle?: string[]): string;
-export {};
-//# sourceMappingURL=ScreenSpaceQuadShader.d.ts.map

package/src/engine/graphics/shaders/ScreenSpaceQuadShader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ScreenSpaceQuadShader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shaders/ScreenSpaceQuadShader.js"],"names":[],"mappings":";;;;AAEA,wCAWC;AAGD;;;;GAIG;AACH,0CAHW,MAAM,EAAE,GACN,MAAM,CAalB"}

package/src/engine/graphics/shaders/ScreenSpaceQuadShader.js

@@ -1,38 +0,0 @@
-import { glsl_gen_swizzled_read } from "./glsl_gen_swizzled_read.js";
-
-function vertexShader() {
-    return `
-                varying vec2 vUv;
-        
-                void main() {
-        
-                    vUv = uv;
-                    gl_Position = vec4( (uv - 0.5)*2.0, 0.0, 1.0 );
-                    
-                }
-        `;
-}
-
-
-/**
- *
- * @param {string[]} [swizzle] what to read from the texture
- * @returns {string}
- */
-function fragmentShader(swizzle = ['r', 'g', 'b', 'a']) {
-
-    return `
-                uniform sampler2D tTexture;
-                varying vec2 vUv;
-                            
-                void main(){
-                    vec4 texel = texture2D( tTexture, vUv );
-                    gl_FragColor = ${glsl_gen_swizzled_read('texel', swizzle)};
-                }
-        `;
-}
-
-export const ScreenSpaceQuadShader = {
-    vertexShader,
-    fragmentShader
-};

package/src/engine/graphics/shaders/ScreenSpaceShader.d.ts

@@ -1,7 +0,0 @@
-export const screenplane_pars_fragment: string;
-/**
- * @author jbouny / https://github.com/fft-ocean
- */
-export const screenplane_pars_vertex: string;
-export const screenplane_vertex: string;
-//# sourceMappingURL=ScreenSpaceShader.d.ts.map

package/src/engine/graphics/shaders/ScreenSpaceShader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ScreenSpaceShader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shaders/ScreenSpaceShader.js"],"names":[],"mappings":"AA6FA,+CAEa;AA/Fb;;GAEG;AAGH,6CAkFa;AAEb,wCAEa"}

package/src/engine/graphics/shaders/ScreenSpaceShader.js

@@ -1,102 +0,0 @@
-/**
- * @author jbouny / https://github.com/fft-ocean
- */
-
-
-const screenplane_pars_vertex = [
-    'const float infinite = 150000.0;',
-    'const float screenScale = 1.2;',
-    'uniform vec3 groundNormal;',
-    'uniform float groundHeight;',
-
-    'varying vec3 vCamPosition;',
-
-    'vec3 interceptPlane( in vec3 source, in vec3 dir, in vec3 normal, float height )',
-    '{',
-    // Compute the distance between the source and the surface, following a ray, then return the intersection
-    // http://www.cs.rpi.edu/~cutler/classes/advancedgraphics/S09/lectures/11_ray_tracing.pdf
-    '	float distance = ( - height - dot( normal, source ) ) / dot( normal, dir );',
-    '	if( distance < 0.0 )',
-    '		return source + dir * distance;',
-    '	else ',
-    '		return - ( vec3( source.x, height, source.z ) + vec3( dir.x, height, dir.z ) * infinite );',
-    '}',
-
-    'mat3 getRotation()',
-    '{',
-    // Extract the 3x3 rotation matrix from the 4x4 view matrix
-    '	return mat3( ',
-    '		viewMatrix[0].xyz,',
-    '		viewMatrix[1].xyz,',
-    '		viewMatrix[2].xyz',
-    '	);',
-    '}',
-
-    'vec3 getCameraPos( in mat3 rotation )',
-    '{',
-    // Xc = R * Xw + t
-    // c = - R.t() * t <=> c = - t.t() * R
-    '	return - viewMatrix[3].xyz * rotation;',
-    '}',
-
-    'vec2 getImagePlan()',
-    '{',
-    // Extracting aspect and focal from projection matrix:
-    // P = | e   0       0   0 |
-    //     | 0   e/(h/w) 0   0 |
-    //     | 0   0       .   . |
-    //     | 0   0       -1  0 |
-    '	float focal = projectionMatrix[0].x;',
-    '	float aspect = projectionMatrix[1].y;',
-
-    // Fix coordinate aspect and scale
-    '	return vec2( ( uv.x - 0.5 ) * screenScale * aspect, ( uv.y - 0.5 ) * screenScale * focal );',
-    '}',
-
-    'vec3 getCamRay( in mat3 rotation, in vec2 screenUV )',
-    '{',
-    // Compute camera ray then rotate it in order to get it in world coordinate
-    '	return vec3( screenUV.x, screenUV.y, projectionMatrix[0].x ) * rotation;',
-    '}',
-
-    'vec3 computeProjectedPosition()',
-    '{',
-    // Extract camera position and rotation from the model view matrix
-    '	mat3 cameraRotation = getRotation();',
-    '	vec3 camPosition = getCameraPos( cameraRotation );',
-    '	vCamPosition = camPosition;',
-
-    // Return the intersection between the camera ray and a given plane
-    '	if( camPosition.y < groundHeight )',
-    '		return vec3( 0.0, 0.0, 0.0 );',
-
-    // Extract coordinate of the vertex on the image plan
-    '	vec2 screenUV = getImagePlan() ;',
-
-    // Compute the ray from camera to world
-    '	vec3 ray = getCamRay( cameraRotation, screenUV );',
-
-    '	vec3 finalPos = interceptPlane( camPosition, ray, groundNormal, groundHeight );',
-
-    '	float distance = length( finalPos );',
-    '	if( distance > infinite )',
-    '		finalPos *= infinite / distance;',
-
-    '	return finalPos;',
-    '}'
-
-].join('\n');
-
-const screenplane_vertex = [
-    'vec4 screenPlaneWorldPosition = vec4( computeProjectedPosition(), 1.0 );',
-].join('\n');
-
-const screenplane_pars_fragment = [
-    'varying vec3 vCamPosition;'
-].join('\n');
-
-export {
-    screenplane_pars_fragment,
-    screenplane_pars_vertex,
-    screenplane_vertex
-};

package/src/engine/graphics/shaders/chunks/glsl_octahedral_impostor.d.ts

@@ -1,102 +0,0 @@
-/**
- * Shared GLSL source fragments for the octahedral-impostor family.
- *
- * WHY THIS EXISTS
- *
- * The octahedral atlas mapping is a single invariant shared by the bake side
- * (`impostors/octahedral/grid/OctahedralUvEncoder.js`) and every sampling
- * shader. Before this module the whole ~90-line library was transcribed nine
- * times — once per stage of `ImpostorShaderV0`, `...DepthV0`, `...NormalsV0`,
- * `...ViewportDepthV0`, `...WireframeV0`, `...PerPixelV0` (vertex AND fragment)
- * and `...LitV0` (vertex AND fragment). Nine transcriptions of one invariant is
- * nine chances for the sample side to stop agreeing with the bake side, and the
- * failure mode (subtly wrong atlas frame) is invisible in code review.
- *
- * These are plain named string exports rather than a keyed chunk registry: a
- * shader interpolates exactly the fragments it needs, by name, and an unused
- * import is a static error rather than a silent miss.
- *
- * HOST REQUIREMENTS
- *
- * `GLSL_OCTAHEDRAL_GRID` reads `uniform bool uIsFullSphere;` and
- * `GLSL_IMPOSTOR_BLEND_4_FRAMES` reads `uniform float uFrames;` — the including
- * shader must declare both. GLSL requires declaration-before-use, so each
- * fragment must be interpolated above the function that calls it.
- *
- * KNOWN DIVERGENCE FROM THE CPU REFERENCE — DO NOT "FIX" IN PASSING
- *
- * `VecToSphereOct` below uses the GLSL builtin `sign()`, while the CPU
- * reference `core/geom/3d/octahedra/octahedral_direction_to_uv.js:24` uses
- * `sign_not_zero()`. `sign(0.0)` is `0.0` in GLSL, so for a direction with an
- * exactly-zero component the two disagree: the GPU path shrinks the L1 norm
- * (`sum`) and folds an axis-aligned direction differently. This module
- * preserves the GPU behaviour verbatim — reconciling the two conventions
- * changes rendered output for axis-aligned view directions and must be done as
- * a deliberate, separately-verified change, not as a side effect of
- * deduplication.
- */
-/**
- * Direction <-> octahedral grid coordinate, both sphere and hemisphere folds.
- *
- * `VectorToGrid` returns the grid coordinate in the range -1..+1; callers remap
- * with `* 0.5 + 0.5`. `GridToVector` is its inverse over the 0..1 range, and
- * `FrameToRay` turns an integer atlas frame index into the bake-camera
- * direction that captured it.
- *
- * Requires: `uniform bool uIsFullSphere;`
- *
- * @type {string}
- */
-export const GLSL_OCTAHEDRAL_GRID: string;
-/**
- * Bilinear weights over the four corners of the current atlas cell.
- *
- * The impostor family blends a full 2x2 cell rather than interpolating over
- * three corners: triangle interpolation has a C1-discontinuous "diagonal
- * switch" whose weight derivative jumps inside the cell, which reads as a snap.
- *
- * @type {string}
- */
-export const GLSL_IMPOSTOR_BILINEAR_WEIGHTS: string;
-/**
- * Card-UV -> single-frame texture-UV rotation matrix.
- *
- * Each atlas frame was baked with its own camera right/up (three.js
- * `Camera.lookAt` with up=(0,1,0)); near the octahedral pole those right-axes
- * swing by 90 degrees or more between adjacent frames, so the four blended
- * corners have to be rotated into a common orientation first.
- *
- * The `abs(D_frame.y) > 0.99999` nudge mirrors three.js's own polar
- * degeneracy handling so the shader basis matches what the baker used.
- *
- * @type {string}
- */
-export const GLSL_IMPOSTOR_COMPUTE_FRAME_XFORM: string;
-/**
- * Fragment-side application of a `ComputeFrameXform` matrix to a card UV.
- *
- * @type {string}
- */
-export const GLSL_IMPOSTOR_APPLY_FRAME_XFORM: string;
-/**
- * Sample one card UV from the four cell-corner atlas frames and blend.
- *
- * Requires `apply_frame_xform` (see {@link GLSL_IMPOSTOR_APPLY_FRAME_XFORM})
- * and `uniform float uFrames;`.
- *
- * @type {string}
- */
-export const GLSL_IMPOSTOR_BLEND_4_FRAMES: string;
-/**
- * Decode an atlas normal (stored in bake-camera view space) back to object
- * space, given the frame's own bake direction.
- *
- * The bake basis reconstruction here MUST match
- * {@link GLSL_IMPOSTOR_COMPUTE_FRAME_XFORM} and `BakeShaderStandard`'s encode
- * side, including the polar nudge threshold — a normal decoded in the wrong
- * basis tilts lighting rather than producing an obvious artefact.
- *
- * @type {string}
- */
-export const GLSL_IMPOSTOR_DECODE_NORMAL_OS: string;
-//# sourceMappingURL=glsl_octahedral_impostor.d.ts.map

package/src/engine/graphics/shaders/chunks/glsl_octahedral_impostor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"glsl_octahedral_impostor.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/shaders/chunks/glsl_octahedral_impostor.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;;;;;;;;;GAWG;AACH,mCAFU,MAAM,CAmFd;AAEF;;;;;;;;GAQG;AACH,6CAFU,MAAM,CAed;AAEF;;;;;;;;;;;;GAYG;AACH,gDAFU,MAAM,CA0Bd;AAEF;;;;GAIG;AACH,8CAFU,MAAM,CAcd;AAEF;;;;;;;GAOG;AACH,2CAFU,MAAM,CA4Bd;AAEF;;;;;;;;;;GAUG;AACH,6CAFU,MAAM,CAgBd"}