@kingsy/viewer 2.25.7

package/dist/modules/materials/shaders/kingsy-standard-vert.d.ts

@@ -0,0 +1 @@
+export declare const kingsyStandardVert = "\n#define STANDARD\n#ifdef USE_RTE\n    // The high component is stored as the default 'position' attribute buffer\n    attribute vec3 position_low;\n    uniform vec3 uViewer_high;\n    uniform vec3 uViewer_low;\n    uniform mat4 rteShadowMatrix;\n    uniform vec3 uShadowViewer_high;\n    uniform vec3 uShadowViewer_low;\n#endif\n\n#ifdef TRANSFORM_STORAGE\n    attribute float objIndex;\n    #if TRANSFORM_STORAGE == 0\n        #if __VERSION__ == 300\n            #define TRANSFORM_STRIDE 4\n        #else\n            #define TRANSFORM_STRIDE 4.\n        #endif\n        uniform sampler2D tTransforms;\n        uniform float objCount;\n    #elif TRANSFORM_STORAGE == 1\n        uniform mat4 uTransforms[OBJ_COUNT];\n    #endif\n#endif\n\nvarying vec3 vViewPosition;\n\n#ifdef USE_TRANSMISSION\n\n    varying vec3 vWorldPosition;\n\n#endif\n\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n\n#ifdef TRANSFORM_STORAGE\n    void objectTransform(out vec4 quaternion, out vec4 pivotLow, out vec4 pivotHigh, out vec4 translation, out vec4 scale){\n        #if TRANSFORM_STORAGE == 0\n            #if __VERSION__ == 300\n                ivec2 uv = ivec2(int(objIndex) * TRANSFORM_STRIDE, 0); \n                vec4 v0 = texelFetch( tTransforms, uv, 0 );\n                vec4 v1 = texelFetch( tTransforms, uv + ivec2(1, 0), 0);\n                vec4 v2 = texelFetch( tTransforms, uv + ivec2(2, 0), 0);\n                vec4 v3 = texelFetch( tTransforms, uv + ivec2(3, 0), 0);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #else\n                float size = objCount * TRANSFORM_STRIDE;\n                vec2 cUv = vec2(0.5/size, 0.5);\n                vec2 dUv = vec2(1./size, 0.);\n                \n                vec2 uv = vec2((objIndex * TRANSFORM_STRIDE)/size + cUv.x, cUv.y);\n                vec4 v0 = texture2D( tTransforms, uv);\n                vec4 v1 = texture2D( tTransforms, uv + dUv);\n                vec4 v2 = texture2D( tTransforms, uv + 2. * dUv);\n                vec4 v3 = texture2D( tTransforms, uv + 3. * dUv);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #endif\n        #elif TRANSFORM_STORAGE == 1\n            mat4 tMatrix = uTransforms[int(objIndex)];\n            quaternion = tMatrix[0];\n            pivotLow = vec4(tMatrix[1].xyz, 1.);\n            pivotHigh = vec4(tMatrix[2].xyz, 1.);\n            translation = vec4(tMatrix[3].xyz, 1.);\n            scale = vec4(tMatrix[1][3], tMatrix[2][3], tMatrix[3][3], 1.);\n        #endif\n    }\n\n\n    highp vec3 rotate_vertex_position(highp vec3 position, highp vec4 quat)\n    {   \n        return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n    }\n\n    /** Another workaround for Apple's stupid compiler */\n    vec4 safeMul(vec4 a, vec4 b) {\n        // Prevents constant folding and optimization\n        return (a + vec4(0.0)) * (b + vec4(1.0)) - a * vec4(1.0);\n    }\n\n    highp vec3 rotate_scaled_vertex_position_delta(highp vec4 v0, highp vec4 v1, highp vec4 scale, highp vec4 quat)\n    {\n        /** !!! WORKAROUND FOR Intel IrisXe CARDS !!! */\n        /** The code below will not produce correct results in intel IrisXE integrated GPUs. \n         *  The geometry will turn mangled, albeit stable\n         *  I can't know for sure what is going on, but rotating the difference seems to \n         *  force the result into a lower precision?\n         */\n        // highp vec4 position = v0 - v1;\n        // return position.xyz + 2.0 * cross(quat.xyz, cross(quat.xyz, position.xyz) + quat.w * position.xyz);\n\n        /** Subtracting the rotated vectors works. */\n        return rotate_vertex_position(safeMul(v0, scale).xyz, quat)  - rotate_vertex_position(safeMul(v1, scale).xyz, quat) ;\n\n        /** An alternate workaround is\n         * highp vec3 position = (v0.xyz * (1. + 1e-7)) - (v1.xyz * (1. + 1e-7));\n           return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n\n           However I'm not such a fan of the (1. + 1e-7) part\n         */\n    }\n#endif\n\n#ifdef USE_RTE\n    highp vec4 computeRelativePosition(in highp vec3 position_low, in highp vec3 position_high, in highp vec3 relativeTo_low, in highp vec3 relativeTo_high){\n        /* \n        Source https://github.com/virtualglobebook/OpenGlobe/blob/master/Source/Examples/Chapter05/Jitter/GPURelativeToEyeDSFUN90/Shaders/VS.glsl \n        Note here, we're storing the high part of the position encoding inside three's default 'position' attribute buffer so we avoid redundancy \n        */\n        highp vec3 t1 = position_low.xyz - relativeTo_low.xyz;\n        highp vec3 e = t1 - position_low.xyz;\n        /** This is redunant, but necessary as a workaround for Apple platforms */\n        highp float x = position_high.x - relativeTo_high.x;\n        highp float y = position_high.y - relativeTo_high.y;\n        highp float z = position_high.z - relativeTo_high.z;\n        highp vec3 v = vec3(x, y, z);\n        /** End of redundant part */\n        highp vec3 t2 = ((-relativeTo_low - e) + (position_low.xyz - (t1 - e))) + v;\n        highp vec3 highDifference = t1 + t2;\n        highp vec3 lowDifference = t2 - (highDifference.xyz - t1.xyz);\n        \n        highp vec3 position = highDifference.xyz + lowDifference.xyz;\n        return vec4(position, 1.);\n    }\n#endif\n\n\nvoid main() {\n\n    #include <uv_vertex>\n    #include <uv2_vertex>\n    #include <color_vertex>\n    #include <morphcolor_vertex>\n    #include <beginnormal_vertex>\n    #include <morphnormal_vertex>\n    #include <skinbase_vertex>\n    #include <skinnormal_vertex>\n    #include <defaultnormal_vertex>\n    #include <normal_vertex>\n\n    #include <begin_vertex>\n    #include <morphtarget_vertex>\n    #include <skinning_vertex>\n    #include <displacementmap_vertex>\n    //#include <project_vertex> // EDITED CHUNK\n    \n    #ifdef TRANSFORM_STORAGE\n        highp vec4 tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale;\n        objectTransform(tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale);\n    #endif\n    #ifdef USE_RTE\n        vec4 position_lowT = vec4(position_low, 1.);\n        vec4 position_highT = vec4(position, 1.);\n        const vec3 ZERO3 = vec3(0., 0., 0.);\n\n        highp vec4 rteLocalPosition = computeRelativePosition(position_lowT.xyz, position_highT.xyz, uViewer_low, uViewer_high);\n        #ifdef TRANSFORM_STORAGE\n            highp vec4 rtePivot = computeRelativePosition(tPivotLow.xyz, tPivotHigh.xyz, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = rotate_scaled_vertex_position_delta(rteLocalPosition, rtePivot, tScale, tQuaternion) + rtePivot.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            vec4 instancePivot = computeRelativePosition(ZERO3, ZERO3, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = (mat3(instanceMatrix) * (rteLocalPosition - instancePivot).xyz) + instancePivot.xyz + instanceMatrix[3].xyz;\n        #endif\n    #endif\n\n    #ifdef USE_RTE\n        vec4 mvPosition = rteLocalPosition;\n    #else\n        vec4 mvPosition = vec4( transformed, 1.0 );\n        #ifdef TRANSFORM_STORAGE\n            mvPosition.xyz = rotate_scaled_vertex_position_delta(mvPosition, tPivotHigh, tScale, tQuaternion) + tPivotHigh.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            mvPosition = instanceMatrix * mvPosition;\n        #endif\n    #endif\n    \n    mvPosition = modelViewMatrix * mvPosition;\n\n    gl_Position = projectionMatrix * mvPosition;\n\n\n    #include <logdepthbuf_vertex>\n    #include <clipping_planes_vertex>\n\n    vViewPosition = - mvPosition.xyz;\n\n    #include <worldpos_vertex>\n    // #include <shadowmap_vertex> COMMENTED CHUNK!!!\n    #ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0\n\t\t// Offsetting the position used for querying occlusion along the world normal can be used to reduce shadow acne.\n\t\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\tvec4 shadowWorldPosition;\n\t#endif\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n        highp vec4 shadowPosition = vec4(transformed, 1.0);\n        mat4 shadowMatrix = directionalShadowMatrix[ i ];\n\n        #ifdef USE_RTE\n            shadowPosition = computeRelativePosition(position_low.xyz, position.xyz, uShadowViewer_low, uShadowViewer_high);\n            shadowMatrix = rteShadowMatrix;\n            #ifdef TRANSFORM_STORAGE\n                highp vec4 rtePivotShadow = computeRelativePosition(tPivotLow.xyz, tPivotHigh.xyz, uShadowViewer_low, uShadowViewer_high);\n                shadowPosition.xyz = rotate_scaled_vertex_position_delta(shadowPosition, rtePivotShadow, tScale, tQuaternion) + rtePivotShadow.xyz + tTranslation.xyz;\n            #endif\n            #ifdef USE_INSTANCING\n                vec4 rtePivotShadow = computeRelativePosition(ZERO3, ZERO3, uShadowViewer_low, uShadowViewer_high);\n                shadowPosition.xyz = (mat3(instanceMatrix) * (shadowPosition - rtePivotShadow).xyz) + rtePivotShadow.xyz + instanceMatrix[3].xyz;\n            #endif\n        #else\n            #ifdef TRANSFORM_STORAGE\n                shadowPosition.xyz = rotate_vertex_position(shadowPosition.xyz * tScale.xyz, tQuaternion) + tTranslation.xyz;\n            #endif\n            #ifdef USE_INSTANCING\n                shadowPosition = instanceMatrix * shadowPosition;\n            #endif\n        #endif\n        shadowWorldPosition = modelMatrix * shadowPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n        vDirectionalShadowCoord[ i ] = shadowMatrix * shadowWorldPosition;\n\t}\n    \n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t/*\n\t#if NUM_RECT_AREA_LIGHTS > 0\n\t\t// TODO (abelnation): update vAreaShadowCoord with area light info\n\t#endif\n\t*/\n    #endif\n\n    #include <fog_vertex>\n\n#ifdef USE_TRANSMISSION\n\n    vWorldPosition = worldPosition.xyz;\n\n#endif\n}\n";

package/dist/modules/materials/shaders/kingsy-static-ao-accumulate-frag.d.ts

@@ -0,0 +1 @@
+export declare const kingsyStaticAoAccumulateFrag = "\n    uniform float opacity;\n    uniform sampler2D tDiffuse;\n    varying vec2 vUv;\n    // #define NUM_FRAMES 16\n\n    void main() {\n        vec4 frameSample = texture2D( tDiffuse, vUv );\n        gl_FragColor.xyz = frameSample.rgb * 1./float(NUM_FRAMES);\n        gl_FragColor.a = 1.;//*= opacity;\n    }";

package/dist/modules/materials/shaders/kingsy-static-ao-accumulate-vert.d.ts

@@ -0,0 +1 @@
+export declare const kingsyStaticAoAccumulateVert = "\n    varying vec2 vUv;\n    void main() {\n        vUv = uv;\n        gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n    }";

package/dist/modules/materials/shaders/kingsy-static-ao-generate-frag.d.ts

@@ -0,0 +1 @@
+export declare const kingsyStaticAoGenerateFrag = "\n\t\t#include <common>\n\t\t#define AO_ESTIMATOR 1\n\t\t#define NORMAL_TEXTURE 0\n\t\t#define IMPROVED_NORMAL_RECONSTRUCTION 0\n\t\t#define ACCURATE_NORMAL_RECONSTRUCTION 1\n\n\t\tvarying vec2 vUv;\n\t\tuniform sampler2D tDepth;\n\t\tuniform sampler2D tNormal;\n        uniform vec2 size;\n\n\t\tuniform float cameraNear;\n\t\tuniform float cameraFar;\n\t\tuniform mat4 cameraProjectionMatrix;\n\t\tuniform mat4 cameraInverseProjectionMatrix;\n\t\t\n\t\tuniform float intensity;\n\t\tuniform float bias;\n\t\tuniform float kernelRadius;\n\t\t\n\t\t\n\t\t#if AO_ESTIMATOR == 0\n\t\t\t#define NUM_SAMPLES 16\n        \t#define SPIRAL_TURNS 2\n\t\t\t#define INV_NUM_SAMPLES 1.0 / float( NUM_SAMPLES )\n        \t#define offset PI2 / float(NUM_FRAMES)\n\n\t\t\tuniform float minResolution;\n\t\t\tuniform float frameIndex;\n\t\t\tuniform float scale;\n\t\t#endif\n\n\t\t#if AO_ESTIMATOR == 1\n\t\t\tuniform float tanFov;\n\t\t\tuniform sampler2D tNoise;\n\t\t\tuniform vec3 kernel[ KERNEL_SIZE ];\n\t\t#endif\n\n\t\t// RGBA depth\n\t\t#include <packing>\n\t\tvec4 getDefaultColor( const in vec2 screenPosition ) {\n\t\t\treturn vec4( 1.0 );\n\t\t}\n\n\n\t\tfloat getLinearDepth( const in vec2 screenPosition ) {\n\t\t\treturn unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );\n\t\t}\n\n\t\tfloat getPerspectiveDepth(const in vec2 coords) {\n\t\t\tfloat linearDepth = unpackRGBAToDepth( texture2D( tDepth, coords ) );\n\t\t\t#if PERSPECTIVE_CAMERA == 1\n\t\t\t\tfloat viewZ = orthographicDepthToViewZ(linearDepth, cameraNear, cameraFar);\n\t\t\t\tfloat centerDepth = viewZToPerspectiveDepth(viewZ, cameraNear, cameraFar);\n\t\t\t\treturn centerDepth;\n\t\t\t#else\n\t\t\t\treturn linearDepth;\n\t\t\t#endif\n\t\t}\n\n\t\tfloat getViewDepth(const in float linearDepth) {\n\t\t\treturn orthographicDepthToViewZ(linearDepth, cameraNear, cameraFar);\n\t\t}\n\n\t\tfloat getViewZ( const in float depth ) {\n\t\t\t#if PERSPECTIVE_CAMERA == 1\n\t\t\treturn perspectiveDepthToViewZ( depth, cameraNear, cameraFar );\n\t\t\t#else\n\t\t\treturn orthographicDepthToViewZ( depth, cameraNear, cameraFar );\n\t\t\t#endif\n\t\t}\n\n\t\tvec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {\n\t\t\tfloat clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];\n\t\t\tvec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );\n\t\t\tclipPosition *= clipW; // unprojection.\n\t\t\treturn ( cameraInverseProjectionMatrix * clipPosition ).xyz;\n\t\t}\n\n\t\t//https://wickedengine.net/2019/09/22/improved-normal-reconstruction-from-depth/\n\t\tvec3 viewNormalImproved(in vec2 uv, in vec3 origin)\n\t\t{\t\n\t\t\thighp vec2 dd = abs(vec2(1./size.x, 1./size.y));\n\t\t\thighp vec2 ddx = vec2(dd.x, 0.);\n\t\t\thighp vec2 ddy = vec2(0., dd.y);\n\n\t\t\tfloat sampleDepth = getPerspectiveDepth( uv - ddy );\n\t\t\tfloat sampleViewZ = getViewZ( sampleDepth );\n\t\t\thighp vec3 top = getViewPosition( uv - ddy, sampleDepth, sampleViewZ );\n\n\t\t\tsampleDepth = getPerspectiveDepth( uv + ddy );\n\t\t\tsampleViewZ = getViewZ( sampleDepth );\n\t\t\thighp vec3 bottom = getViewPosition( uv + ddy, sampleDepth, sampleViewZ );\n\n\t\t\thighp vec3 center = origin;\n\t\t\t\n\t\t\tsampleDepth = getPerspectiveDepth( uv - ddx );\n\t\t\tsampleViewZ = getViewZ( sampleDepth );\n\t\t\thighp vec3 left = getViewPosition( uv - ddx, sampleDepth, sampleViewZ );\n\n\t\t\tsampleDepth = getPerspectiveDepth( uv + ddx );\n\t\t\tsampleViewZ = getViewZ( sampleDepth );\n\t\t\thighp vec3 right = getViewPosition( uv + ddx, sampleDepth, sampleViewZ );\n\n\t\t\t // get the difference between the current and each offset position\n\t\t\tvec3 l = center - left;\n\t\t\tvec3 r = right - center;\n\t\t\tvec3 d = center - top;\n\t\t\tvec3 u = bottom - center;\n\n\t\t\t// pick horizontal and vertical diff with the smallest z difference\n\t\t\tvec3 hDeriv = abs(l.z) < abs(r.z) ? l : r;\n\t\t\tvec3 vDeriv = abs(d.z) < abs(u.z) ? d : u;\n\n\t\t\t// get view space normal from the cross product of the two smallest offsets\n\t\t\tvec3 viewNormal = normalize(cross(hDeriv, vDeriv));\n\n\t\t\treturn viewNormal;\n\t\t}\n\n\t\tvec3 viewNormalAccurate(in vec2 uv, in vec3 origin, in float centerDepth) {\n\t\t\thighp vec2 dd = abs(vec2(1./size.x, 1./size.y));\n\t\t\thighp vec2 ddx = vec2(dd.x, 0.);\n\t\t\thighp vec2 ddy = vec2(0., dd.y);\n\n\t\t\tfloat sampleDepth = getPerspectiveDepth( uv - ddy );\n\t\t\tfloat sampleViewZ = getViewZ( sampleDepth );\n\t\t\thighp vec3 top = getViewPosition( uv - ddy, sampleDepth, sampleViewZ );\n\n\t\t\tsampleDepth = getPerspectiveDepth( uv + ddy );\n\t\t\tsampleViewZ = getViewZ( sampleDepth );\n\t\t\thighp vec3 bottom = getViewPosition( uv + ddy, sampleDepth, sampleViewZ );\n\n\t\t\thighp vec3 center = origin;\n\t\t\t\n\t\t\tsampleDepth = getPerspectiveDepth( uv - ddx );\n\t\t\tsampleViewZ = getViewZ( sampleDepth );\n\t\t\thighp vec3 left = getViewPosition( uv - ddx, sampleDepth, sampleViewZ );\n\n\t\t\tsampleDepth = getPerspectiveDepth( uv + ddx );\n\t\t\tsampleViewZ = getViewZ( sampleDepth );\n\t\t\thighp vec3 right = getViewPosition( uv + ddx, sampleDepth, sampleViewZ );\n\n\t\t\t // get the difference between the current and each offset position\n\t\t\tvec3 l = center - left;\n\t\t\tvec3 r = right - center;\n\t\t\tvec3 d = center - top;\n\t\t\tvec3 u = bottom - center;\n\n\t\t\t// get depth values at 1 & 2 pixels offsets from current along the horizontal axis\n\t\t\tvec4 H = vec4(\n\t\t\t\tgetLinearDepth(uv - ddx),\n\t\t\t\tgetLinearDepth(uv + ddx),\n\t\t\t\tgetLinearDepth(uv - 2. * ddx),\n\t\t\t\tgetLinearDepth(uv + 2. * ddx)\n\t\t\t);\n\n\t\t\t// get depth values at 1 & 2 pixels offsets from current along the vertical axis\n\t\t\tvec4 V = vec4(\n\t\t\t\tgetLinearDepth(uv - ddy),\n\t\t\t\tgetLinearDepth(uv + ddy),\n\t\t\t\tgetLinearDepth(uv - 2. * ddy),\n\t\t\t\tgetLinearDepth(uv + 2. * ddy)\n\t\t\t);\n\n\t\t\t// current pixel's depth difference from slope of offset depth samples\n\t\t\t// differs from original article because we're using non-linear depth values\n\t\t\t// see article's comments\n\t\t\tvec2 he = abs((2. * H.xy - H.zw) - centerDepth);\n\t\t\tvec2 ve = abs((2. * V.xy - V.zw) - centerDepth);\n\n\t\t\t// pick horizontal and vertical diff with the smallest depth difference from slopes\n\t\t\tvec3 hDeriv = he.x < he.y ? l : r;\n\t\t\tvec3 vDeriv = ve.x < ve.y ? d : u;\n\n\t\t\t// get view space normal from the cross product of the best derivatives\n\t\t\tvec3 viewNormal = normalize(cross(hDeriv, vDeriv));\n\n\t\t\treturn viewNormal;\n\n\t\t}\n\n\t\tvec3 getViewNormal( const in vec3 viewPosition, const in vec2 screenPosition, in float centerDepth ) {\n\t\t\t#if NORMAL_TEXTURE == 1\n\t\t\t\treturn unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );\n\t\t\t#elif IMPROVED_NORMAL_RECONSTRUCTION == 1\n\t\t\t\treturn viewNormalImproved(screenPosition, viewPosition);\n\t\t\t#elif ACCURATE_NORMAL_RECONSTRUCTION == 1\n\t\t\t\treturn viewNormalAccurate(screenPosition, viewPosition, centerDepth);\n\t\t\t#else\n\t\t\t\treturn normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );\n\t\t\t#endif\n\t\t}\n\n\n\t\tfloat scaleDividedByCameraFar;\n\t\tfloat minResolutionMultipliedByCameraFar;\n        // moving costly divides into consts\n\t\t\n\n\t\tfloat computeKernelSize(float d, float r) {\n\t\t\t#if PERSPECTIVE_CAMERA == 1\n\t\t\t\t// Apparently this is wrong\n\t\t\t\t// return (r * tan(fov) * d) / (size.y * 0.5);\n\t\t\t\t// And this is correct\n\t\t\t\tfloat rp = r / (size.y * 0.5);\n\t\t\t\treturn sqrt((rp*rp*tanFov*tanFov*d*d)/(1. + rp*rp*tanFov*tanFov));\n\t\t\t#else\n\t\t\t\tfloat twoOrthoSize = size.y / (2./ cameraProjectionMatrix[1][1]);\n\t\t\t\treturn r / twoOrthoSize;\n\t\t\t#endif\n\t\t}\n\n\t\tfloat getAmbientOcclusion( const in vec3 centerViewPosition, in float centerDepth ) {\n            #if AO_ESTIMATOR == 0\n                // precompute some variables require in getOcclusion.\n                scaleDividedByCameraFar = scale / cameraFar;\n                minResolutionMultipliedByCameraFar = minResolution * cameraFar;\n                vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv, centerDepth );\n                // jsfiddle that shows sample pattern: https://jsfiddle.net/TenHands/jun67k9y/7/\n                float occlusionSum = 0.0;\n                float weightSum = 0.0;\n                for( int i = 0; i < NUM_SAMPLES; i ++ ) {\n                    float alpha = ( float(i) + 1. ) / float(NUM_SAMPLES);\n                    float angle = float(SPIRAL_TURNS)  * alpha;\n                    vec2 radius = (kernelRadius / size) * pow( alpha, 1.1 );\n                    vec2 sampleUv = vUv + vec2( cos( angle + frameIndex * offset ), sin( angle + frameIndex * offset ) ) * radius;\n\n                    float sampleDepth = getPerspectiveDepth( sampleUv );\n                    if( sampleDepth >= ( 1.0 - EPSILON ) ) {\n                        continue;\n                    }\n                    float sampleViewZ = getViewZ( sampleDepth );\n                    vec3 sampleViewPosition = getViewPosition( sampleUv, sampleDepth, sampleViewZ );\n\n\t\t\t\t\t/** McGuire Estimator*/\n\t\t\t\t\tvec3 v = sampleViewPosition - centerViewPosition;\n\t\t\t\t\tfloat vv = dot(v, v);\n\t\t\t\t\tfloat vn = dot(v, centerViewNormal) - bias;\n\t\t\t\t\t\n\t\t\t\t\t// Note large epsilon to avoid overdarkening within cracks\n\t\t\t\t\tfloat radius2 = 2.;//uSampleRadiusWS * uSampleRadiusWS\n\t\t\t\t\tfloat epsilon = 0.01;\n\t\t\t\t\t\n\t\t\t\t\tfloat f = max(radius2 - vv, 0.0) / radius2;\n\t\t\t\t\tocclusionSum += f * f * f * max(vn / (epsilon + vv), 0.0) / 4.;\n\n\t\t\t\t\t/** Three.js SAO Estimator*/\n                    // vec3 viewDelta = sampleViewPosition - centerViewPosition;\n                    // float viewDistance = length( viewDelta );\n                    // float scaledScreenDistance = scaleDividedByCameraFar * viewDistance;\n                    // occlusionSum += max(0.0, (dot(centerViewNormal, viewDelta) - minResolutionMultipliedByCameraFar) / scaledScreenDistance - bias) / (1.0 + pow2( scaledScreenDistance ) );\n                    weightSum += 1.0;\n                }\n                if( weightSum == 0.0 ) discard;\n                return occlusionSum * ( intensity / weightSum );\n\t\t\t#elif AO_ESTIMATOR == 1\n\t\t\t\tvec3 viewPosition = centerViewPosition;\n\t\t\t\tvec3 viewNormal = getViewNormal( centerViewPosition, vUv, centerDepth );\n\t\t\t\tvec2 noiseScale = vec2( size.x / 4.0, size.y / 4.0 );\n\t\t\t\tvec3 random = vec3( texture2D( tNoise, vUv * noiseScale ).r );\n\t\t\t\t// compute matrix used to reorient a kernel vector\n\t\t\t\tvec3 tangent = normalize( random - viewNormal * dot( random, viewNormal ) );\n\t\t\t\tvec3 bitangent = cross( viewNormal, tangent );\n\t\t\t\tmat3 kernelMatrix = mat3( tangent, bitangent, viewNormal );\n\t\t\t\tfloat occlusion = 0.0;\n\t\t\t\tfloat kernelSize_ws = computeKernelSize(-viewPosition.z, kernelRadius);\n\t\t\t\tfloat div = float( KERNEL_SIZE);\n\t\t\t\tfloat maxDist = kernelSize_ws / (cameraFar - cameraNear);\n\t\t\t\tfor ( int i = 0; i < KERNEL_SIZE; i ++ ) {\n\t\t\t\t\tvec3 sampleVector = kernelMatrix * kernel[ i ]; // reorient sample vector in view space\n\t\t\t\t\tvec3 samplePoint = viewPosition + ( sampleVector * kernelSize_ws ); // calculate sample point\n\t\t\t\t\tvec4 samplePointNDC = cameraProjectionMatrix * vec4( samplePoint, 1.0 ); // project point and calculate NDC\n\t\t\t\t\tsamplePointNDC /= samplePointNDC.w;\n\t\t\t\t\tvec2 samplePointUv = samplePointNDC.xy * 0.5 + 0.5; // compute uv coordinates\n\t\t\t\t\tfloat realDepth = getLinearDepth( samplePointUv ); // get linear depth from depth texture\n\t\t\t\t\tfloat sampleDepth = viewZToOrthographicDepth( samplePoint.z + bias, cameraNear, cameraFar ); // compute linear depth of the sample view Z value\n\t\t\t\t\tfloat delta = sampleDepth - realDepth;\n\t\t\t\t\tif ( delta > 0. && delta < maxDist ) { // if fragment is before sample point, increase occlusion\n\t\t\t\t\t\tocclusion += 1.0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn clamp( occlusion * intensity / div, 0.0, 1.0 );\n\t\t\t#endif\n\t\t\t}\n\t\tvoid main() {\n\t\t\tfloat linearDepth = unpackRGBAToDepth( texture2D( tDepth, vUv ) );\n\t\t\tfloat centerDepth = getPerspectiveDepth(vUv);\n\t\t\tif( centerDepth >= ( 1.0 - EPSILON ) ) {\n\t\t\t\tdiscard;\n\t\t\t}\n\t\t\tfloat centerViewZ = getViewDepth(linearDepth);\n\t\t\tvec3 viewPosition = getViewPosition( vUv, centerDepth, centerViewZ );\n\t\t\tvec3 viewNormal = getViewNormal(viewPosition, vUv, linearDepth);\n\t\t\tfloat ambientOcclusion = getAmbientOcclusion( viewPosition, centerDepth );\n\t\t\tgl_FragColor = getDefaultColor( vUv );\n\t\t\tgl_FragColor.xyz *=  ambientOcclusion;\n\t\t\tgl_FragColor.a = 1.;\n\t\t}";

package/dist/modules/materials/shaders/kingsy-static-ao-generate-vert.d.ts

@@ -0,0 +1 @@
+export declare const kingsyStaticAoGenerateVert = "\n\t\tvarying vec2 vUv;\n\t\tvoid main() {\n\t\t\tvUv = uv;\n\t\t\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\t\t}";

package/dist/modules/materials/shaders/kingsy-temporal-supersampling-frag.d.ts

@@ -0,0 +1 @@
+export declare const kingsyTemporalSupersamplingFrag = "\n    uniform float height;\n    uniform float width;\n    uniform sampler2D tDiffuse;\n    uniform sampler2D tLastFrame;\n    varying vec2 Uv;\n\n    #define LuminanceEncodeApprox vec3(0.2126, 0.7152, 0.0722)\n    float getLuminance(vec3 color) {\n        return clamp(dot(color, LuminanceEncodeApprox), 0., 1.);\n    }\n    \n    void main() {\n        vec4 texel = texture2D(tDiffuse, Uv);\n        vec2 oldPixelUv = Uv;\n        vec4 oldTexel = texture2D(tLastFrame, oldPixelUv);\n\n        // Use simple neighbor clamping\n        vec4 maxNeighbor = vec4(0.0, 0.0, 0.0, 1.0);\n        vec4 minNeighbor = vec4(1.0);\n        vec4 average = vec4(0.0);\n        for (int x = -1; x <= 1; x++) {\n            for (int y = -1; y <= 1; y++) {\n                vec2 neighborUv = Uv + vec2(float(x) / width, float(y) / height);\n                vec4 neighborTexel = texture2D(tDiffuse, neighborUv);\n                maxNeighbor = max(maxNeighbor, neighborTexel);\n                minNeighbor = min(minNeighbor, neighborTexel);\n                average += neighborTexel / 9.0;\n            }\n        }\n        float lum0 = getLuminance(texel.rgb);\n        float lum1 = getLuminance(oldTexel.rgb);\n\n        float unbiased_diff = abs(lum0 - lum1) / max(lum0, max(lum1, 0.2));\n        float unbiased_weight = 1.0 - unbiased_diff;\n        float unbiased_weight_sqr = unbiased_weight * unbiased_weight;\n        float k_feedback = mix(0.8800, 0.9700, unbiased_weight_sqr);\n        \n        // UE Method to get rid of flickering. Weight frame mixing amount\n        // based on local contrast.\n        float contrast = distance(average, texel);\n        float weight = 0.05 * contrast;\n\n        float blendFactor = mix(1. - weight, k_feedback, 1.);\n        vec4 compositeColor = mix(texel, oldTexel, blendFactor);\n    \n        gl_FragColor = compositeColor;\n    }";

package/dist/modules/materials/shaders/kingsy-temporal-supersampling-vert.d.ts

@@ -0,0 +1 @@
+export declare const kingsyTemporalSupersamplingVert = "\n    varying vec2 Uv;\n    \n    void main() {\n        Uv = uv;\n        gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n    }";

package/dist/modules/materials/shaders/kingsy-text-frag.d.ts

@@ -0,0 +1 @@
+export declare const kingsyTextFrag = "\nuniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t// accumulation (baked indirect lighting only)\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vUv2 );\n\t\treflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity * RECIPROCAL_PI;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t// modulation\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <envmap_fragment>\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}\n";

package/dist/modules/materials/shaders/kingsy-text-vert.d.ts

@@ -0,0 +1 @@
+export declare const kingsyTextVert = "\n#include <common>\n#ifdef USE_RTE\n    // The high component is stored as the default 'position' attribute buffer\n    attribute vec3 position_low;\n    uniform vec3 uViewer_high;\n    uniform vec3 uViewer_low;\n#endif\n\n#ifdef TRANSFORM_STORAGE\n    attribute float objIndex;\n\n    #if TRANSFORM_STORAGE == 0\n        #if __VERSION__ == 300\n            #define TRANSFORM_STRIDE 4\n        #else\n            #define TRANSFORM_STRIDE 4.\n        #endif\n        uniform sampler2D tTransforms;\n        uniform float objCount;\n    #elif TRANSFORM_STORAGE == 1\n        uniform mat4 uTransforms[OBJ_COUNT];\n    #endif\n#endif\n\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n\n#ifdef USE_RTE\n    highp vec4 computeRelativePosition(in highp vec3 position_low, in highp vec3 position_high, in highp vec3 relativeTo_low, in highp vec3 relativeTo_high){\n        /* \n        Source https://github.com/virtualglobebook/OpenGlobe/blob/master/Source/Examples/Chapter05/Jitter/GPURelativeToEyeDSFUN90/Shaders/VS.glsl \n        Note here, we're storing the high part of the position encoding inside three's default 'position' attribute buffer so we avoid redundancy \n        */\n        highp vec3 t1 = position_low.xyz - relativeTo_low.xyz;\n        highp vec3 e = t1 - position_low.xyz;\n        /** This is redunant, but necessary as a workaround for Apple platforms */\n        highp float x = position_high.x - relativeTo_high.x;\n        highp float y = position_high.y - relativeTo_high.y;\n        highp float z = position_high.z - relativeTo_high.z;\n        highp vec3 v = vec3(x, y, z);\n        /** End of redundant part */\n        highp vec3 t2 = ((-relativeTo_low - e) + (position_low.xyz - (t1 - e))) + v;\n        highp vec3 highDifference = t1 + t2;\n        highp vec3 lowDifference = t2 - (highDifference.xyz - t1.xyz);\n        \n        highp vec3 position = highDifference.xyz + lowDifference.xyz;\n        return vec4(position, 1.);\n    }\n#endif\n\n#ifdef TRANSFORM_STORAGE\n    void objectTransform(out vec4 quaternion, out vec4 pivotLow, out vec4 pivotHigh, out vec4 translation, out vec4 scale){\n        #if TRANSFORM_STORAGE == 0\n            #if __VERSION__ == 300\n                ivec2 uv = ivec2(int(objIndex) * TRANSFORM_STRIDE, 0); \n                vec4 v0 = texelFetch( tTransforms, uv, 0 );\n                vec4 v1 = texelFetch( tTransforms, uv + ivec2(1, 0), 0);\n                vec4 v2 = texelFetch( tTransforms, uv + ivec2(2, 0), 0);\n                vec4 v3 = texelFetch( tTransforms, uv + ivec2(3, 0), 0);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #else\n                float size = objCount * TRANSFORM_STRIDE;\n                vec2 cUv = vec2(0.5/size, 0.5);\n                vec2 dUv = vec2(1./size, 0.);\n                \n                vec2 uv = vec2((objIndex * TRANSFORM_STRIDE)/size + cUv.x, cUv.y);\n                vec4 v0 = texture2D( tTransforms, uv);\n                vec4 v1 = texture2D( tTransforms, uv + dUv);\n                vec4 v2 = texture2D( tTransforms, uv + 2. * dUv);\n                vec4 v3 = texture2D( tTransforms, uv + 3. * dUv);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #endif\n        #elif TRANSFORM_STORAGE == 1\n            mat4 tMatrix = uTransforms[int(objIndex)];\n            quaternion = tMatrix[0];\n            pivotLow = vec4(tMatrix[1].xyz, 1.);\n            pivotHigh = vec4(tMatrix[2].xyz, 1.);\n            translation = vec4(tMatrix[3].xyz, 1.);\n            scale = vec4(tMatrix[1][3], tMatrix[2][3], tMatrix[3][3], 1.);\n        #endif\n    }\n\n    vec3 rotate_vertex_position(vec3 position, vec4 quat)\n    { \n        return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n    }\n\n    /** Another workaround for Apple's stupid compiler */\n    vec4 safeMul(vec4 a, vec4 b) {\n        // Prevents constant folding and optimization\n        return (a + vec4(0.0)) * (b + vec4(1.0)) - a * vec4(1.0);\n    }\n\n    highp vec3 rotate_scaled_vertex_position_delta(highp vec4 v0, highp vec4 v1, highp vec4 scale, highp vec4 quat)\n    {\n        /** !!! WORKAROUND FOR Intel IrisXe CARDS !!! */\n        /** The code below will not produce correct results in intel IrisXE integrated GPUs. \n         *  The geometry will turn mangled, albeit stable\n         *  I can't know for sure what is going on, but rotating the difference seems to \n         *  force the result into a lower precision?\n         */\n        // highp vec4 position = v0 - v1;\n        // return position.xyz + 2.0 * cross(quat.xyz, cross(quat.xyz, position.xyz) + quat.w * position.xyz);\n\n        /** Subtracting the rotated vectors works. */\n        return rotate_vertex_position(safeMul(v0, scale).xyz, quat)  - rotate_vertex_position(safeMul(v1, scale).xyz, quat) ;\n\n        /** An alternate workaround is\n         * highp vec3 position = (v0.xyz * (1. + 1e-7)) - (v1.xyz * (1. + 1e-7));\n           return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n\n           However I'm not such a fan of the (1. + 1e-7) part\n         */\n    }\n\n#endif\n\n#if defined(BILLBOARD) || defined(BILLBOARD_FIXED)\n    uniform vec3 billboardPos;\n    uniform mat4 invProjection;\n#endif\n#ifdef BILLBOARD_FIXED\n    uniform vec2 billboardSize;\n#endif\n\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinbase_vertex>\n\t\t#include <skinnormal_vertex>\n\t\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t// #include <project_vertex> COMMENTED CHUNK\n    #ifdef TRANSFORM_STORAGE\n        vec4 tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale;\n        objectTransform(tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale);\n    #endif\n    #ifdef USE_RTE\n        vec4 position_lowT = vec4(position_low, 1.);\n        vec4 position_highT = vec4(position, 1.);\n        const vec3 ZERO3 = vec3(0., 0., 0.);\n\n        highp vec4 rteLocalPosition = computeRelativePosition(position_lowT.xyz, position_highT.xyz, uViewer_low, uViewer_high);\n        #ifdef TRANSFORM_STORAGE\n            highp vec4 rtePivot = computeRelativePosition(tPivotLow.xyz, tPivotHigh.xyz, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = rotate_scaled_vertex_position_delta(rteLocalPosition, rtePivot, tScale, tQuaternion) + rtePivot.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            vec4 instancePivot = computeRelativePosition(ZERO3, ZERO3, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = (mat3(instanceMatrix) * (rteLocalPosition - instancePivot).xyz) + instancePivot.xyz + instanceMatrix[3].xyz;\n        #endif\n    #endif\n\n    #ifdef USE_RTE\n        vec4 mvPosition = rteLocalPosition;\n    #else\n        vec4 mvPosition = vec4( transformed, 1.0 );\n        #ifdef TRANSFORM_STORAGE\n            mvPosition.xyz = rotate_scaled_vertex_position_delta(mvPosition, tPivotHigh, tScale, tQuaternion) + tPivotHigh.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            mvPosition = instanceMatrix * mvPosition;\n        #endif\n    #endif\n    \n    mvPosition = modelViewMatrix * mvPosition;\n    \n    #if defined(BILLBOARD)\n        float div = 1.;\n        gl_Position = projectionMatrix * (viewMatrix * vec4(billboardPos, 1.0) + vec4(position.x, position.y, 0., 0.0));\n    #elif defined(BILLBOARD_FIXED)\n        gl_Position = projectionMatrix * (viewMatrix * vec4(billboardPos, 1.0));\n        float div = gl_Position.w;\n        gl_Position /= gl_Position.w;\n        gl_Position.xy += position.xy * billboardSize;\n    #else\n        gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.);\n    #endif\n\t#include <logdepthbuf_vertex>\n\t// #include <clipping_planes_vertex> COMMENTED CHUNK\n    #if NUM_CLIPPING_PLANES > 0\n        #if defined(BILLBOARD) || defined(BILLBOARD_FIXED)\n            vec4 movelViewProjection = gl_Position * div;\n            vClipPosition = - (invProjection * movelViewProjection).xyz;\n        #else\n\t        vClipPosition = - mvPosition.xyz;\n        #endif\n    #endif\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}\n";

package/dist/modules/materials/shaders/kingsy-viewport-frag.d.ts

@@ -0,0 +1 @@
+export declare const kingsyViewportFrag = "\nuniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\n\nuniform float minIntensity;\nvarying vec3 vViewPosition;\n\n#ifdef MATCAP_TEXTURE\n\tuniform sampler2D tMatcap;\n#endif\n\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t// accumulation (baked indirect lighting only)\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vUv2 );\n\t\treflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity * RECIPROCAL_PI;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t// modulation\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <envmap_fragment>\n\t// #include <output_fragment> COMMENTED CHUNK\n\t#ifdef OPAQUE\n\t\tdiffuseColor.a = 1.0;\n\t#endif\n\n\t// https://github.com/mrdoob/three.js/pull/22425\n\t#ifdef USE_TRANSMISSION\n\t\tdiffuseColor.a *= transmissionAlpha + 0.1;\n\t#endif\n\n\tvec3 normal = normalize( vNormal );\n\tvec3 viewDir = normalize( vViewPosition );\n    vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n    vec3 y = cross( viewDir, x );\n    vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\n\tvec3 color = vec3(1.0);\n\t#ifdef MATCAP_TEXTURE\n\t\tcolor = texture2D(tMatcap, uv).rgb;\n\t#else\n\t\tcolor = vec3( mix( minIntensity, 1., uv.y ) );\n\t#endif\n\n\tgl_FragColor = vec4( color.rgb, diffuseColor.a);\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}\n";

package/dist/modules/materials/shaders/kingsy-viewport-vert.d.ts

@@ -0,0 +1 @@
+export declare const kingsyViewportVert = "\n#define USE_ENVMAP\n#include <common>\n#ifdef USE_RTE\n    // The high component is stored as the default 'position' attribute buffer\n    attribute vec3 position_low;\n    uniform vec3 uViewer_high;\n    uniform vec3 uViewer_low;\n#endif\n\n#ifdef TRANSFORM_STORAGE\n    attribute float objIndex;\n\n    #if TRANSFORM_STORAGE == 0\n        #if __VERSION__ == 300\n            #define TRANSFORM_STRIDE 4\n        #else\n            #define TRANSFORM_STRIDE 4.\n        #endif\n        uniform sampler2D tTransforms;\n        uniform float objCount;\n    #elif TRANSFORM_STORAGE == 1\n        uniform mat4 uTransforms[OBJ_COUNT];\n    #endif\n#endif\nvarying vec3 vNormal;\nvarying vec3 vViewPosition;\n\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n\n#ifdef USE_RTE\n    highp vec4 computeRelativePosition(in highp vec3 position_low, in highp vec3 position_high, in highp vec3 relativeTo_low, in highp vec3 relativeTo_high){\n        /* \n        Source https://github.com/virtualglobebook/OpenGlobe/blob/master/Source/Examples/Chapter05/Jitter/GPURelativeToEyeDSFUN90/Shaders/VS.glsl \n        Note here, we're storing the high part of the position encoding inside three's default 'position' attribute buffer so we avoid redundancy \n        */\n        highp vec3 t1 = position_low.xyz - relativeTo_low.xyz;\n        highp vec3 e = t1 - position_low.xyz;\n        /** This is redunant, but necessary as a workaround for Apple platforms */\n        highp float x = position_high.x - relativeTo_high.x;\n        highp float y = position_high.y - relativeTo_high.y;\n        highp float z = position_high.z - relativeTo_high.z;\n        highp vec3 v = vec3(x, y, z);\n        /** End of redundant part */\n        highp vec3 t2 = ((-relativeTo_low - e) + (position_low.xyz - (t1 - e))) + v;\n        highp vec3 highDifference = t1 + t2;\n        highp vec3 lowDifference = t2 - (highDifference.xyz - t1.xyz);\n        \n        highp vec3 position = highDifference.xyz + lowDifference.xyz;\n        return vec4(position, 1.);\n    }\n#endif\n\n#ifdef TRANSFORM_STORAGE\n    void objectTransform(out vec4 quaternion, out vec4 pivotLow, out vec4 pivotHigh, out vec4 translation, out vec4 scale){\n        #if TRANSFORM_STORAGE == 0\n            #if __VERSION__ == 300\n                ivec2 uv = ivec2(int(objIndex) * TRANSFORM_STRIDE, 0); \n                vec4 v0 = texelFetch( tTransforms, uv, 0 );\n                vec4 v1 = texelFetch( tTransforms, uv + ivec2(1, 0), 0);\n                vec4 v2 = texelFetch( tTransforms, uv + ivec2(2, 0), 0);\n                vec4 v3 = texelFetch( tTransforms, uv + ivec2(3, 0), 0);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #else\n                float size = objCount * TRANSFORM_STRIDE;\n                vec2 cUv = vec2(0.5/size, 0.5);\n                vec2 dUv = vec2(1./size, 0.);\n                \n                vec2 uv = vec2((objIndex * TRANSFORM_STRIDE)/size + cUv.x, cUv.y);\n                vec4 v0 = texture2D( tTransforms, uv);\n                vec4 v1 = texture2D( tTransforms, uv + dUv);\n                vec4 v2 = texture2D( tTransforms, uv + 2. * dUv);\n                vec4 v3 = texture2D( tTransforms, uv + 3. * dUv);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #endif\n        #elif TRANSFORM_STORAGE == 1\n            mat4 tMatrix = uTransforms[int(objIndex)];\n            quaternion = tMatrix[0];\n            pivotLow = vec4(tMatrix[1].xyz, 1.);\n            pivotHigh = vec4(tMatrix[2].xyz, 1.);\n            translation = vec4(tMatrix[3].xyz, 1.);\n            scale = vec4(tMatrix[1][3], tMatrix[2][3], tMatrix[3][3], 1.);\n        #endif\n    }\n\n    vec3 rotate_vertex_position(vec3 position, vec4 quat)\n    { \n        return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n    }\n\n    /** Another workaround for Apple's stupid compiler */\n    vec4 safeMul(vec4 a, vec4 b) {\n        // Prevents constant folding and optimization\n        return (a + vec4(0.0)) * (b + vec4(1.0)) - a * vec4(1.0);\n    }\n\n    highp vec3 rotate_scaled_vertex_position_delta(highp vec4 v0, highp vec4 v1, highp vec4 scale, highp vec4 quat)\n    {\n        /** !!! WORKAROUND FOR Intel IrisXe CARDS !!! */\n        /** The code below will not produce correct results in intel IrisXE integrated GPUs. \n         *  The geometry will turn mangled, albeit stable\n         *  I can't know for sure what is going on, but rotating the difference seems to \n         *  force the result into a lower precision?\n         */\n        // highp vec4 position = v0 - v1;\n        // return position.xyz + 2.0 * cross(quat.xyz, cross(quat.xyz, position.xyz) + quat.w * position.xyz);\n\n        /** Subtracting the rotated vectors works. */\n        return rotate_vertex_position(safeMul(v0, scale).xyz, quat)  - rotate_vertex_position(safeMul(v1, scale).xyz, quat) ;\n\n        /** An alternate workaround is\n         * highp vec3 position = (v0.xyz * (1. + 1e-7)) - (v1.xyz * (1. + 1e-7));\n           return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n\n           However I'm not such a fan of the (1. + 1e-7) part\n         */\n    }\n\n#endif\n\n#if defined(BILLBOARD) || defined(BILLBOARD_FIXED)\n    uniform vec3 billboardPos;\n    uniform mat4 invProjection;\n#endif\n#ifdef BILLBOARD_FIXED\n    uniform vec2 billboardSize;\n#endif\nvarying float dotValue;\n\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinbase_vertex>\n\t\t#include <skinnormal_vertex>\n\t\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t// #include <project_vertex> COMMENTED CHUNK\n    #ifdef TRANSFORM_STORAGE\n        vec4 tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale;\n        objectTransform(tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale);\n    #endif\n    #ifdef USE_RTE\n        vec4 position_lowT = vec4(position_low, 1.);\n        vec4 position_highT = vec4(position, 1.);\n        const vec3 ZERO3 = vec3(0., 0., 0.);\n\n        highp vec4 rteLocalPosition = computeRelativePosition(position_lowT.xyz, position_highT.xyz, uViewer_low, uViewer_high);\n        #ifdef TRANSFORM_STORAGE\n            highp vec4 rtePivot = computeRelativePosition(tPivotLow.xyz, tPivotHigh.xyz, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = rotate_scaled_vertex_position_delta(rteLocalPosition, rtePivot, tScale, tQuaternion) + rtePivot.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            vec4 instancePivot = computeRelativePosition(ZERO3, ZERO3, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = (mat3(instanceMatrix) * (rteLocalPosition - instancePivot).xyz) + instancePivot.xyz + instanceMatrix[3].xyz;\n        #endif\n    #endif\n\n    #ifdef USE_RTE\n        vec4 mvPosition = rteLocalPosition;\n    #else\n        vec4 mvPosition = vec4( transformed, 1.0 );\n        #ifdef TRANSFORM_STORAGE\n            mvPosition.xyz = rotate_scaled_vertex_position_delta(mvPosition, tPivotHigh, tScale, tQuaternion) + tPivotHigh.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            mvPosition = instanceMatrix * mvPosition;\n        #endif\n    #endif\n    \n    mvPosition = modelViewMatrix * mvPosition;\n\n    vNormal = normalize( transformedNormal );\n    vViewPosition = -mvPosition.xyz;\n\n    #if defined(BILLBOARD)\n        float div = 1.;\n        gl_Position = projectionMatrix * (viewMatrix * vec4(billboardPos, 1.0) + vec4(position.x, position.y, 0., 0.0));\n    #elif defined(BILLBOARD_FIXED)\n        gl_Position = projectionMatrix * (viewMatrix * vec4(billboardPos, 1.0));\n        float div = gl_Position.w;\n        gl_Position /= gl_Position.w;\n        gl_Position.xy += position.xy * billboardSize;\n    #else\n        gl_Position = projectionMatrix * mvPosition;\n    #endif\n\n\n\t#include <logdepthbuf_vertex>\n\t// #include <clipping_planes_vertex> COMMENTED CHUNK\n    #if NUM_CLIPPING_PLANES > 0\n        #if defined(BILLBOARD) || defined(BILLBOARD_FIXED)\n            vec4 movelViewProjection = gl_Position * div;\n            vClipPosition = - (invProjection * movelViewProjection).xyz;\n        #else\n\t        vClipPosition = - mvPosition.xyz;\n        #endif\n    #endif\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}\n";

package/dist/modules/objects/AccelerationStructure.d.ts

@@ -0,0 +1,72 @@
+import { Box3, BufferGeometry, Material, Matrix4, Ray, Side, Vector3 } from 'three';
+import { ExtendedTriangle, MeshBVH, ShapecastIntersection, SplitStrategy } from 'three-mesh-bvh';
+import { MeshIntersection } from './KingSyRaycaster.js';
+declare const SKIP_GENERATION: unique symbol;
+export interface BVHOptions {
+    strategy: SplitStrategy;
+    maxDepth: number;
+    maxLeafTris: number;
+    verbose: boolean;
+    useSharedArrayBuffer: boolean;
+    setBoundingBox: boolean;
+    onProgress?: () => void;
+    [SKIP_GENERATION]: boolean;
+}
+export declare const DefaultBVHOptions: {
+    strategy: SplitStrategy;
+    maxDepth: number;
+    maxLeafTris: number;
+    verbose: boolean;
+    useSharedArrayBuffer: boolean;
+    setBoundingBox: boolean;
+    [SKIP_GENERATION]: boolean;
+};
+/**
+ *
+  _____                            _              _
+ |_   _|                          | |            | |
+   | |  _ __ ___  _ __   ___  _ __| |_ __ _ _ __ | |_
+   | | | '_ ` _ \| '_ \ / _ \| '__| __/ _` | '_ \| __|
+  _| |_| | | | | | |_) | (_) | |  | || (_| | | | | |_
+ |_____|_| |_| |_| .__/ \___/|_|   \__\__,_|_| |_|\__|
+                 | |
+                 |_|
+
+We've made this wrapper around the original implementation to hide the transformations we do behind the scenes
+in order to avoid storing vertex positions as Float64. Instead we store them as Float32, but the whole BVH is
+re-centered around the mesh local origin as (0,0,0). We use the resulting transformations to transform anything that comes
+in or out of the BVH in order to keep this re-centering opaque.
+
+We've implemented auto-transformation for raycasting and shapecasting. Other functionalities like bvhcast or geometrycast
+will need to be wrapped around if required.
+
+Otherwise, keep in mind that if you use this class for any other purposes, you can use transformInput and transformOutput
+to get the correct values for Vectors, Rays, Boxes, etc
+ */
+export declare class AccelerationStructure {
+    private static readonly MatBuff;
+    private _bvh;
+    inputTransform: Matrix4;
+    outputTransform: Matrix4;
+    inputOriginTransform: Matrix4;
+    outputOriginTransfom: Matrix4;
+    get geometry(): BufferGeometry;
+    get bvh(): MeshBVH;
+    static buildBVH(indices: number[] | undefined, position: number[] | undefined, options?: BVHOptions, transform?: Matrix4): MeshBVH;
+    constructor(bvh: MeshBVH);
+    raycast(ray: Ray, materialOrSide?: Side | Material | Material[]): MeshIntersection[];
+    raycastFirst(ray: Ray, materialOrSide?: Side | Material | Material[]): MeshIntersection;
+    shapecast(callbacks: {
+        intersectsBounds: (box: Box3, isLeaf: boolean, score: number | undefined, depth: number, nodeIndex: number) => ShapecastIntersection | boolean;
+        traverseBoundsOrder?: (box: Box3) => number;
+    } & ({
+        intersectsRange: (triangleOffset: number, triangleCount: number, contained: boolean, depth: number, nodeIndex: number, box: Box3) => boolean;
+    } | {
+        intersectsTriangle: (triangle: ExtendedTriangle, triangleIndex: number, contained: boolean, depth: number) => boolean | void;
+    })): boolean;
+    transformInput<T extends Vector3 | Ray | Box3>(input: T): T;
+    transformOutput<T extends Vector3 | Ray | Box3>(output: T): T;
+    getBoundingBox(target?: Box3): Box3;
+    getVertexAtIndex(index: number): Vector3;
+}
+export {};

package/dist/modules/objects/ExtendedInstancedMesh.d.ts

@@ -0,0 +1,6 @@
+import { BufferGeometry, InstancedMesh, Material } from 'three';
+export declare class ExtendedInstancedMesh extends InstancedMesh<BufferGeometry, Material | Material[]> {
+    private _batchIndex;
+    constructor(geometry: BufferGeometry | undefined, material: Material | Material[] | undefined, count: number, batchIndex: number);
+    get batchIndex(): number;
+}

package/dist/modules/objects/JitterQuad.d.ts

@@ -0,0 +1,10 @@
+import { Material, OrthographicCamera, WebGLRenderer } from 'three';
+export declare class JitterQuad {
+    private _camera;
+    private mesh;
+    get camera(): OrthographicCamera;
+    get material(): Material | Material[];
+    set material(value: Material | Material[]);
+    constructor(material?: Material);
+    render(renderer: WebGLRenderer): void;
+}

package/dist/modules/objects/KingSyCamera.d.ts

@@ -0,0 +1,31 @@
+import { Box3, OrthographicCamera, PerspectiveCamera } from 'three';
+export declare enum CameraEvent {
+    Stationary = "stationary",
+    Dynamic = "dynamic",
+    FrameUpdate = "frame-update",
+    LateFrameUpdate = "late-frame-update",
+    ProjectionChanged = "projection-changed",
+    InteractionStarted = "interaction-started",
+    InteractionEnded = "interaction-ended"
+}
+export interface CameraEventPayload {
+    [CameraEvent.Stationary]: void;
+    [CameraEvent.Dynamic]: void;
+    [CameraEvent.FrameUpdate]: boolean;
+    [CameraEvent.LateFrameUpdate]: boolean;
+    [CameraEvent.ProjectionChanged]: CameraProjection;
+    [CameraEvent.InteractionStarted]: void;
+    [CameraEvent.InteractionEnded]: void;
+}
+export interface KingSyCamera {
+    get renderingCamera(): PerspectiveCamera | OrthographicCamera;
+    get fieldOfView(): number;
+    set fieldOfView(value: number);
+    get aspect(): number;
+    on<T extends CameraEvent>(eventType: T, listener: (arg: CameraEventPayload[T]) => void): void;
+    updateCameraPlanes(targetVolume?: Box3, offsetScale?: number): void;
+}
+export declare enum CameraProjection {
+    PERSPECTIVE = 0,
+    ORTHOGRAPHIC = 1
+}

package/dist/modules/objects/KingSyInstancedMesh.d.ts

@@ -0,0 +1,44 @@
+import { BufferGeometry, Group, Material, type Intersection } from 'three';
+import { BatchObject } from '../batching/BatchObject.js';
+import { TopLevelAccelerationStructure } from './TopLevelAccelerationStructure.js';
+import { type DrawGroup } from '../batching/Batch.js';
+import { KingSyRaycaster } from './KingSyRaycaster.js';
+export default class KingSyInstancedMesh extends Group {
+    static MeshBatchNumber: number;
+    private tas;
+    private batchMaterial;
+    private materialCache;
+    private materialStack;
+    private batchMaterialStack;
+    private materialCacheLUT;
+    private _batchObjects;
+    private _needsRTE;
+    groups: Array<DrawGroup>;
+    materials: Material[];
+    private instanceGeometry;
+    private instances;
+    get TAS(): TopLevelAccelerationStructure;
+    get batchObjects(): BatchObject[];
+    get needsRTE(): boolean;
+    constructor(geometry: BufferGeometry, RTE?: boolean);
+    setBatchMaterial(material: Material): void;
+    setBatchObjects(batchObjects: BatchObject[]): void;
+    setOverrideMaterial(material: Material): void;
+    setOverrideBatchMaterial(material: Material): void;
+    restoreBatchMaterial(): void;
+    private lookupMaterial;
+    getCachedMaterial(material: Material, copy?: boolean): Material;
+    restoreMaterial(): void;
+    buildTAS(): void;
+    updateDrawGroups(transformBuffer: Float32Array, gradientBuffer: Float32Array, objectIndexBuffer?: Float32Array): void;
+    updateTransformsUniform(): void;
+    updateMaterialTransformsUniform(material: Material): void;
+    getBatchObjectMaterial(batchObject: BatchObject): Material | null;
+    /** Three's 'clone' and 'copy' from geometry and buffer attributes
+     *  create duplicates of arrays and we don't want that. Most of the
+     *  buffer attributes need to be shared to avoid redundancy
+     */
+    private getInstanceGeometryShallowCopy;
+    private convertRaycastIntersect;
+    raycast(raycaster: KingSyRaycaster, intersects: Array<Intersection>): void;
+}

package/dist/modules/objects/KingSyMesh.d.ts

@@ -0,0 +1,43 @@
+import { BufferGeometry, DataTexture, Material, Matrix4, Mesh, type Intersection } from 'three';
+import { BatchObject } from '../batching/BatchObject.js';
+import { TopLevelAccelerationStructure } from './TopLevelAccelerationStructure.js';
+import { KingSyRaycaster } from './KingSyRaycaster.js';
+export declare enum TransformStorage {
+    VERTEX_TEXTURE = 0,
+    UNIFORM_ARRAY = 1
+}
+export default class KingSyMesh extends Mesh {
+    static MeshBatchNumber: number;
+    private tas;
+    private batchMaterial;
+    private materialCache;
+    private materialStack;
+    private batchMaterialStack;
+    private materialCacheLUT;
+    private _batchObjects;
+    private _batchIndex;
+    private _needsRTE;
+    private transformsBuffer;
+    private transformStorage;
+    transformsTextureUniform: DataTexture;
+    transformsArrayUniforms: Matrix4[] | null;
+    get TAS(): TopLevelAccelerationStructure;
+    get batchObjects(): BatchObject[];
+    get batchIndex(): number;
+    get needsRTE(): boolean;
+    constructor(geometry: BufferGeometry, RTE?: boolean);
+    setBatchMaterial(material: Material): void;
+    setBatchObjects(batchObjects: BatchObject[], transformStorage: TransformStorage): void;
+    setOverrideMaterial(material: Material): void;
+    setOverrideBatchMaterial(material: Material): void;
+    restoreBatchMaterial(): void;
+    private lookupMaterial;
+    getCachedMaterial(material: Material, copy?: boolean): Material;
+    restoreMaterial(): void;
+    updateMaterialTransformsUniform(material: Material): void;
+    updateTransformsUniform(): void;
+    buildTAS(): void;
+    getBatchObjectMaterial(batchObject: BatchObject): Material | null;
+    private convertRaycastIntersect;
+    raycast(raycaster: KingSyRaycaster, intersects: Array<Intersection>): void;
+}

package/dist/modules/objects/KingSyRaycaster.d.ts

@@ -0,0 +1,42 @@
+import { Box3, type Intersection, Object3D, Raycaster, Vector3, RaycasterParameters, Face } from 'three';
+import { ExtendedTriangle, ShapecastIntersection } from 'three-mesh-bvh';
+import { BatchObject } from '../batching/BatchObject.js';
+import KingSyMesh from './KingSyMesh.js';
+import KingSyInstancedMesh from './KingSyInstancedMesh.js';
+export declare const NOT_INTERSECTED: ShapecastIntersection;
+export declare const INTERSECTED: ShapecastIntersection;
+export declare const CONTAINED: ShapecastIntersection;
+export type ExtendedShapeCastCallbacks = {
+    intersectsTAS?: (box: Box3, isLeaf: boolean, score: number | undefined, depth: number, nodeIndex: number) => ShapecastIntersection | boolean;
+    intersectTASRange?: (batchObjects: BatchObject) => ShapecastIntersection | boolean;
+    intersectsBounds: (box: Box3, isLeaf: boolean, score: number | undefined, depth: number, nodeIndex: number) => ShapecastIntersection | boolean;
+    traverseBoundsOrder?: (box: Box3) => number;
+} & ({
+    intersectsRange: (triangleOffset: number, triangleCount: number, contained: boolean, depth: number, nodeIndex: number, box: Box3) => boolean;
+} | {
+    intersectsTriangle: (triangle: ExtendedTriangle, triangleIndex: number, contained: boolean, depth: number, batchObject?: BatchObject) => boolean | void;
+});
+export interface ExtendedIntersection extends Intersection {
+    batchObject?: BatchObject;
+    pointOnLine?: Vector3;
+}
+export interface MeshIntersection extends Intersection {
+    face: Face;
+    faceIndex: number;
+}
+export interface ExtendedMeshIntersection extends MeshIntersection {
+    batchObject: BatchObject;
+    object: KingSyMesh | KingSyInstancedMesh;
+}
+export interface ExtendedRaycasterParameters extends RaycasterParameters {
+    Line2: {
+        threshold: number;
+    };
+}
+export declare class KingSyRaycaster extends Raycaster {
+    intersectTASOnly: boolean;
+    onObjectIntersectionTest: ((object: Object3D) => void) | null;
+    params: ExtendedRaycasterParameters;
+    constructor(origin?: Vector3, direction?: Vector3, near?: number, far?: number);
+    intersectObjects(objects: Array<Object3D>, recursive?: boolean, intersects?: never[]): never[];
+}

package/dist/modules/objects/KingSyText.d.ts

@@ -0,0 +1,39 @@
+import { BufferGeometry, Color, Mesh, Quaternion, Raycaster, Vector3, type Intersection } from 'three';
+import { ObjectLayers, type KingSyObject } from '../../IViewer.js';
+export interface KingSyTextParams {
+    textValue?: string;
+    richTextValue?: string;
+    height?: number;
+    anchorX?: string;
+    anchorY?: string;
+}
+export interface KingSyTextStyle {
+    backgroundColor?: Color | null;
+    backgroundCornerRadius?: number;
+    backgroundPixelHeight?: number;
+    textColor?: Color;
+    billboard?: boolean;
+}
+export declare class KingSyText extends Mesh {
+    private _layer;
+    private _text;
+    private _background;
+    private _backgroundSize;
+    private _style;
+    private _resolution;
+    private defaultMaterial;
+    private getFlatRaycastMesh;
+    private getCurvedRaycastMesh;
+    static KingSyTextParamsFromMetadata(metadata: KingSyObject): KingSyTextParams;
+    get textMesh(): Text;
+    get backgroundMesh(): Mesh<BufferGeometry, import("three").Material | import("three").Material[]> | null;
+    set style(value: KingSyTextStyle);
+    constructor(uuid: string, layer: ObjectLayers);
+    update(params: KingSyTextParams, updateFinished?: () => void): Promise<void>;
+    setTransform(position?: Vector3, quaternion?: Quaternion, scale?: Vector3): void;
+    raycast(raycaster: Raycaster, intersects: Array<Intersection>): void;
+    private updateStyle;
+    private updateBackground;
+    /** From https://discourse.threejs.org/t/roundedrectangle-squircle/28645  */
+    private RectangleRounded;
+}

package/dist/modules/objects/KingSyWebGLRenderer.d.ts

@@ -0,0 +1,24 @@
+import { Camera, Matrix4, Vector3, WebGLCubeRenderTarget, WebGLMultipleRenderTargets, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { TypedArray } from 'type-fest';
+export declare class RTEBuffers {
+    private _cache;
+    viewer: Vector3;
+    viewerLow: Vector3;
+    viewerHigh: Vector3;
+    rteViewModelMatrix: Matrix4;
+    shadowViewer: Vector3;
+    shadowViewerLow: Vector3;
+    shadowViewerHigh: Vector3;
+    rteShadowViewModelMatrix: Matrix4;
+    rteShadowMatrix: Matrix4;
+    copy(from: RTEBuffers, to: RTEBuffers): void;
+    push(): void;
+    pop(): void;
+}
+export declare class KingSyWebGLRenderer extends WebGLRenderer {
+    RTEBuffers: RTEBuffers;
+    updateRTEViewModel(camera: Camera): void;
+    readRenderTargetPixels: (renderTarget: WebGLRenderTarget | WebGLCubeRenderTarget | WebGLMultipleRenderTargets, x: number, y: number, width: number, height: number, buffer: TypedArray, activeCubeFaceIndex?: number) => void;
+    /** Taken from three since they hide it, thank you very much */
+    private convert;
+}

package/dist/modules/objects/RotatablePMREMGenerator.d.ts

@@ -0,0 +1,5 @@
+import { Matrix4, PMREMGenerator, WebGLRenderer } from 'three';
+export declare class RotatablePMREMGenerator extends PMREMGenerator {
+    constructor(renderer: WebGLRenderer);
+    compileProperEquirectShader(rotationMatrix?: Matrix4): void;
+}

package/dist/modules/objects/TopLevelAccelerationStructure.d.ts

@@ -0,0 +1,41 @@
+import { Box3, Material, Ray, Side, Vector3 } from 'three';
+import { MeshBVHVisualizer } from 'three-mesh-bvh';
+import { BatchObject } from '../batching/BatchObject.js';
+import { HitPointInfo } from 'three-mesh-bvh';
+import type { ExtendedMeshIntersection, ExtendedShapeCastCallbacks } from './KingSyRaycaster.js';
+import { AccelerationStructure } from './AccelerationStructure.js';
+/**
+ *
+  _____                            _              _
+ |_   _|                          | |            | |
+   | |  _ __ ___  _ __   ___  _ __| |_ __ _ _ __ | |_
+   | | | '_ ` _ \| '_ \ / _ \| '__| __/ _` | '_ \| __|
+  _| |_| | | | | | |_) | (_) | |  | || (_| | | | | |_
+ |_____|_| |_| |_| .__/ \___/|_|   \__\__,_|_| |_|\__|
+                 | |
+                 |_|
+
+  Unlike the BVHs for the individual objects, which act as our BAS, the TAS *is not relative to the world origin*!
+  All coordinates are the final world coordinates derived from the BAS bounding boxes, after all transformations.
+  In theory this might mean the TAS is not 100% accurate for objects far away from origin, but I think it should do
+  fine as it is. If we really really really need that 100% accuracy, we'll just make it relative to the origin
+ */
+export declare class TopLevelAccelerationStructure {
+    private debugBVH;
+    private static cubeIndices;
+    private static CUBE_VERTS;
+    batchObjects: BatchObject[];
+    bounds: Box3;
+    accelerationStructure: AccelerationStructure;
+    bvhHelper: MeshBVHVisualizer;
+    constructor(batchObjects: BatchObject[]);
+    private buildBVH;
+    private updateVertArray;
+    refit(): void;
+    raycast(ray: Ray, tasOnly?: boolean, materialOrSide?: Side | Material | Material[]): ExtendedMeshIntersection[];
+    raycastFirst(ray: Ray, tasOnly?: boolean, materialOrSide?: Side | Material | Material[]): ExtendedMeshIntersection | null;
+    shapecast(callbacks: ExtendedShapeCastCallbacks): boolean;
+    closestPointToPoint(point: Vector3): HitPointInfo | null;
+    closestPointToPointHalfplane(point: Vector3, planeNormal: Vector3, fallback?: number, target?: HitPointInfo, minThreshold?: number, maxThreshold?: number): HitPointInfo | null;
+    getBoundingBox(target: Box3): Box3;
+}

package/dist/modules/pipeline/Passes/BlendPass.d.ts

@@ -0,0 +1,17 @@
+import { ShaderMaterial, Texture, WebGLRenderer } from 'three';
+import { PassOptions, ProgressiveGPass } from './GPass.js';
+export interface BlendPassOptions extends PassOptions {
+    blendAO?: boolean;
+    blendEdges?: boolean;
+}
+export declare const DefaultBlendPassOptions: Required<BlendPassOptions>;
+export declare class BlendPass extends ProgressiveGPass {
+    private fsQuad;
+    materialCopy: ShaderMaterial;
+    _options: Required<BlendPassOptions>;
+    set options(value: BlendPassOptions);
+    constructor();
+    setTexture(uName: string, texture: Texture | undefined): void;
+    get displayName(): string;
+    render(renderer: WebGLRenderer): boolean;
+}

package/dist/modules/pipeline/Passes/DepthNormalIdPass.d.ts

@@ -0,0 +1,12 @@
+import { Texture } from 'three';
+import { DepthNormalPass, DepthNormalPassOptions } from './DepthNormalPass.js';
+export interface DepthNormalIdPassOptions extends DepthNormalPassOptions {
+}
+export declare const DefaultDepthNormalIdPassOptions: Required<DepthNormalIdPassOptions>;
+export declare class DepthNormalIdPass extends DepthNormalPass {
+    _options: Required<DepthNormalPassOptions>;
+    get displayName(): string;
+    get idTexture(): Texture;
+    set options(value: DepthNormalIdPassOptions);
+    constructor();
+}

package/dist/modules/pipeline/Passes/DepthNormalPass.d.ts

@@ -0,0 +1,25 @@
+import { Material, OrthographicCamera, PerspectiveCamera, Plane, Scene, Texture, WebGLMultipleRenderTargets, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { BaseGPass } from './GPass.js';
+import { DepthPassOptions, DepthType } from './DepthPass.js';
+import KingSyDepthNormalMaterial from '../../materials/KingSyDepthNormalMaterial.js';
+export interface DepthNormalPassOptions extends DepthPassOptions {
+}
+export declare const DefaultDepthNormalPassOptions: Required<DepthNormalPassOptions>;
+export declare class DepthNormalPass extends BaseGPass {
+    protected mrtMaterial: KingSyDepthNormalMaterial;
+    protected mrt: WebGLMultipleRenderTargets;
+    _options: Required<DepthNormalPassOptions>;
+    get displayName(): string;
+    get overrideMaterial(): Material;
+    get depthTexture(): Texture;
+    get normalTexture(): Texture;
+    get outputTarget(): WebGLRenderTarget | null;
+    set outputTarget(target: WebGLMultipleRenderTargets);
+    set options(value: DepthNormalPassOptions);
+    protected set depthType(value: DepthType);
+    constructor();
+    setClippingPlanes(planes: Plane[]): void;
+    update(camera: PerspectiveCamera | OrthographicCamera): void;
+    render(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera | null, scene?: Scene): boolean;
+    setSize(width: number, height: number): void;
+}

package/dist/modules/pipeline/Passes/DepthPass.d.ts

@@ -0,0 +1,23 @@
+import { Material, OrthographicCamera, PerspectiveCamera, Side, Texture } from 'three';
+import { PassOptions } from './GPass.js';
+import { GeometryPass } from './GeometryPass.js';
+export declare enum DepthType {
+    PERSPECTIVE_DEPTH = 0,
+    LINEAR_DEPTH = 1
+}
+export interface DepthPassOptions extends PassOptions {
+    depthType?: DepthType;
+}
+export declare const DefaultDepthPassOptions: Required<DepthPassOptions>;
+export declare class DepthPass extends GeometryPass {
+    private depthMaterial;
+    _options: Required<DepthPassOptions>;
+    get displayName(): string;
+    get depthTexture(): Texture | undefined;
+    get overrideMaterial(): Material;
+    set options(value: DepthPassOptions);
+    protected set depthType(value: DepthType);
+    set depthSide(value: Side);
+    constructor();
+    update(camera: PerspectiveCamera | OrthographicCamera): void;
+}

package/dist/modules/pipeline/Passes/EdgesPass.d.ts

@@ -0,0 +1,25 @@
+import { OrthographicCamera, PerspectiveCamera, ShaderMaterial, Texture, WebGLRenderer } from 'three';
+import { BaseGPass, PassOptions } from './GPass.js';
+export interface EdgesPassOptions extends PassOptions {
+    depthMultiplier?: number;
+    depthBias?: number;
+    normalMultiplier?: number;
+    normalBias?: number;
+    outlineThickness?: number;
+    outlineOpacity?: number;
+    outlineColor?: number;
+    backgroundColor?: number;
+}
+export declare const DefaultEdgesPassOptions: Required<EdgesPassOptions>;
+export declare class EdgesPass extends BaseGPass {
+    edgesMaterial: ShaderMaterial;
+    private fsQuad;
+    _options: Required<EdgesPassOptions>;
+    set options(value: EdgesPassOptions);
+    constructor();
+    setTexture(uName: string, texture: Texture | undefined): void;
+    get displayName(): string;
+    update(camera: PerspectiveCamera | OrthographicCamera): void;
+    render(renderer: WebGLRenderer): boolean;
+    setSize(width: number, height: number): void;
+}