@react-three/postprocessing 2.15.5 → 2.15.6

package/dist/effects/N8AO/EffectShader.js

@@ -0,0 +1,219 @@
+import * as THREE from "three";
+const EffectShader = {
+  uniforms: {
+    sceneDiffuse: { value: null },
+    sceneDepth: { value: null },
+    sceneNormal: { value: null },
+    projMat: { value: new THREE.Matrix4() },
+    viewMat: { value: new THREE.Matrix4() },
+    projViewMat: { value: new THREE.Matrix4() },
+    projectionMatrixInv: { value: new THREE.Matrix4() },
+    viewMatrixInv: { value: new THREE.Matrix4() },
+    cameraPos: { value: new THREE.Vector3() },
+    resolution: { value: new THREE.Vector2() },
+    time: { value: 0 },
+    samples: { value: [] },
+    samplesR: { value: [] },
+    bluenoise: { value: null },
+    distanceFalloff: { value: 1 },
+    radius: { value: 5 },
+    near: { value: 0.1 },
+    far: { value: 1e3 },
+    logDepth: { value: false },
+    ortho: { value: false },
+    screenSpaceRadius: { value: false }
+  },
+  depthWrite: false,
+  depthTest: false,
+  vertexShader: (
+    /* glsl */
+    `
+varying vec2 vUv;
+void main() {
+  vUv = uv;
+  gl_Position = vec4(position, 1);
+}`
+  ),
+  fragmentShader: (
+    /* glsl */
+    `
+    #define SAMPLES 16
+    #define FSAMPLES 16.0
+uniform sampler2D sceneDiffuse;
+uniform highp sampler2D sceneNormal;
+uniform highp sampler2D sceneDepth;
+uniform mat4 projectionMatrixInv;
+uniform mat4 viewMatrixInv;
+uniform mat4 projMat;
+uniform mat4 viewMat;
+uniform mat4 projViewMat;
+uniform vec3 cameraPos;
+uniform vec2 resolution;
+uniform float time;
+uniform vec3[SAMPLES] samples;
+uniform float[SAMPLES] samplesR;
+uniform float radius;
+uniform float distanceFalloff;
+uniform float near;
+uniform float far;
+uniform bool logDepth;
+uniform bool ortho;
+uniform bool screenSpaceRadius;
+uniform sampler2D bluenoise;
+    varying vec2 vUv;
+    highp float linearize_depth(highp float d, highp float zNear,highp float zFar)
+    {
+        return (zFar * zNear) / (zFar - d * (zFar - zNear));
+    }
+    highp float linearize_depth_ortho(highp float d, highp float nearZ, highp float farZ) {
+      return nearZ + (farZ - nearZ) * d;
+    }
+    highp float linearize_depth_log(highp float d, highp float nearZ,highp float farZ) {
+      float depth = pow(2.0, d * log2(farZ + 1.0)) - 1.0;
+      float a = farZ / (farZ - nearZ);
+      float b = farZ * nearZ / (nearZ - farZ);
+      float linDepth = a + b / depth;
+      return ortho ? linearize_depth_ortho(
+        linDepth,
+        nearZ,
+        farZ
+      ) :linearize_depth(linDepth, nearZ, farZ);
+    }
+
+    vec3 getWorldPosLog(vec3 posS) {
+      vec2 uv = posS.xy;
+      float z = posS.z;
+      float nearZ =near;
+      float farZ = far;
+      float depth = pow(2.0, z * log2(farZ + 1.0)) - 1.0;
+      float a = farZ / (farZ - nearZ);
+      float b = farZ * nearZ / (nearZ - farZ);
+      float linDepth = a + b / depth;
+      vec4 clipVec = vec4(uv, linDepth, 1.0) * 2.0 - 1.0;
+      vec4 wpos = projectionMatrixInv * clipVec;
+      return wpos.xyz / wpos.w;
+    }
+    vec3 getWorldPos(float depth, vec2 coord) {
+      #ifdef LOGDEPTH
+        return getWorldPosLog(vec3(coord, depth));
+      #endif
+      float z = depth * 2.0 - 1.0;
+      vec4 clipSpacePosition = vec4(coord * 2.0 - 1.0, z, 1.0);
+      vec4 viewSpacePosition = projectionMatrixInv * clipSpacePosition;
+      // Perspective division
+     vec4 worldSpacePosition = viewSpacePosition;
+     worldSpacePosition.xyz /= worldSpacePosition.w;
+      return worldSpacePosition.xyz;
+  }
+
+  vec3 computeNormal(vec3 worldPos, vec2 vUv) {
+    ivec2 p = ivec2(vUv * resolution);
+    float c0 = texelFetch(sceneDepth, p, 0).x;
+    float l2 = texelFetch(sceneDepth, p - ivec2(2, 0), 0).x;
+    float l1 = texelFetch(sceneDepth, p - ivec2(1, 0), 0).x;
+    float r1 = texelFetch(sceneDepth, p + ivec2(1, 0), 0).x;
+    float r2 = texelFetch(sceneDepth, p + ivec2(2, 0), 0).x;
+    float b2 = texelFetch(sceneDepth, p - ivec2(0, 2), 0).x;
+    float b1 = texelFetch(sceneDepth, p - ivec2(0, 1), 0).x;
+    float t1 = texelFetch(sceneDepth, p + ivec2(0, 1), 0).x;
+    float t2 = texelFetch(sceneDepth, p + ivec2(0, 2), 0).x;
+
+    float dl = abs((2.0 * l1 - l2) - c0);
+    float dr = abs((2.0 * r1 - r2) - c0);
+    float db = abs((2.0 * b1 - b2) - c0);
+    float dt = abs((2.0 * t1 - t2) - c0);
+
+    vec3 ce = getWorldPos(c0, vUv).xyz;
+
+    vec3 dpdx = (dl < dr) ? ce - getWorldPos(l1, (vUv - vec2(1.0 / resolution.x, 0.0))).xyz
+                          : -ce + getWorldPos(r1, (vUv + vec2(1.0 / resolution.x, 0.0))).xyz;
+    vec3 dpdy = (db < dt) ? ce - getWorldPos(b1, (vUv - vec2(0.0, 1.0 / resolution.y))).xyz
+                          : -ce + getWorldPos(t1, (vUv + vec2(0.0, 1.0 / resolution.y))).xyz;
+
+    return normalize(cross(dpdx, dpdy));
+}
+
+void main() {
+      vec4 diffuse = texture2D(sceneDiffuse, vUv);
+      float depth = texture2D(sceneDepth, vUv).x;
+      if (depth == 1.0) {
+        gl_FragColor = vec4(vec3(1.0), 1.0);
+        return;
+      }
+      vec3 worldPos = getWorldPos(depth, vUv);
+    //  vec3 normal = texture2D(sceneNormal, vUv).rgb;//computeNormal(worldPos, vUv);
+      #ifdef HALFRES
+        vec3 normal = texture2D(sceneNormal, vUv).rgb;
+      #else
+        vec3 normal = computeNormal(worldPos, vUv);
+      #endif
+      vec4 noise = texture2D(bluenoise, gl_FragCoord.xy / 128.0);
+      vec3 randomVec = normalize(noise.rgb * 2.0 - 1.0);
+      vec3 tangent = normalize(randomVec - normal * dot(randomVec, normal));
+      vec3 bitangent = cross(normal, tangent);
+      mat3 tbn = mat3(tangent, bitangent, normal);
+      float occluded = 0.0;
+      float totalWeight = 0.0;
+     /* float radiusScreen = distance(
+        worldPos,
+        getWorldPos(depth, vUv + 
+          vec2(48.0, 0.0) / resolution)
+      );/*vUv.x < 0.5 ? radius : min(distance(
+        worldPos,
+        getWorldPos(depth, vUv + 
+          vec2(100.0, 0.0) / resolution)
+      ), radius);
+      float distanceFalloffScreen = radiusScreen * 0.2;*/
+      float radiusToUse = screenSpaceRadius ? distance(
+        worldPos,
+        getWorldPos(depth, vUv +
+          vec2(radius, 0.0) / resolution)
+      ) : radius;
+      float distanceFalloffToUse =screenSpaceRadius ?
+          radiusToUse * distanceFalloff
+      : distanceFalloff;
+      float bias = (0.1 / near) * fwidth(distance(worldPos, cameraPos)) / radiusToUse;
+      for(float i = 0.0; i < FSAMPLES; i++) {
+        vec3 sampleDirection = 
+        tbn * 
+        samples[int(i)];
+        ;
+        float moveAmt = samplesR[int(mod(i + noise.a * FSAMPLES, FSAMPLES))];
+        vec3 samplePos = worldPos + radiusToUse * moveAmt * sampleDirection;
+        vec4 offset = projMat * vec4(samplePos, 1.0);
+        offset.xyz /= offset.w;
+        offset.xyz = offset.xyz * 0.5 + 0.5;
+        float sampleDepth = textureLod(sceneDepth, offset.xy, 0.0).x;
+        /*float distSample = logDepth ? linearize_depth_log(sampleDepth, near, far) 
+         (ortho ?  linearize_depth_ortho(sampleDepth, near, far) : linearize_depth(sampleDepth, near, far));*/
+        #ifdef LOGDEPTH
+        float distSample = linearize_depth_log(sampleDepth, near, far);
+        #else
+        float distSample = ortho ? linearize_depth_ortho(sampleDepth, near, far) : linearize_depth(sampleDepth, near, far);
+        #endif
+        float distWorld = ortho ? linearize_depth_ortho(offset.z, near, far) : linearize_depth(offset.z, near, far);
+        float rangeCheck = smoothstep(0.0, 1.0, distanceFalloffToUse / (abs(distSample - distWorld)));
+        vec2 diff = gl_FragCoord.xy - ( offset.xy * resolution);
+        float weight = dot(sampleDirection, normal);
+          occluded += rangeCheck * weight * 
+            (distSample + bias
+               < distWorld ? 1.0 : 0.0) * (
+          (dot(
+            diff,
+            diff
+             
+            ) < 1.0 || (sampleDepth == depth) || (
+              offset.x < 0.0 || offset.x > 1.0 || offset.y < 0.0 || offset.y > 1.0
+            ) ? 0.0 : 1.0)
+          );
+          totalWeight += weight;
+      }
+      float occ = clamp(1.0 - occluded / totalWeight, 0.0, 1.0);
+      gl_FragColor = vec4(0.5 + 0.5 * normal, occ);
+}`
+  )
+};
+export {
+  EffectShader
+};
+//# sourceMappingURL=EffectShader.js.map

package/dist/effects/N8AO/EffectShader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectShader.js","sources":["../../../src/effects/N8AO/EffectShader.js"],"sourcesContent":["import * as THREE from 'three'\n\nconst EffectShader = {\n  uniforms: {\n    sceneDiffuse: { value: null },\n    sceneDepth: { value: null },\n    sceneNormal: { value: null },\n    projMat: { value: new THREE.Matrix4() },\n    viewMat: { value: new THREE.Matrix4() },\n    projViewMat: { value: new THREE.Matrix4() },\n    projectionMatrixInv: { value: new THREE.Matrix4() },\n    viewMatrixInv: { value: new THREE.Matrix4() },\n    cameraPos: { value: new THREE.Vector3() },\n    resolution: { value: new THREE.Vector2() },\n    time: { value: 0.0 },\n    samples: { value: [] },\n    samplesR: { value: [] },\n    bluenoise: { value: null },\n    distanceFalloff: { value: 1.0 },\n    radius: { value: 5.0 },\n    near: { value: 0.1 },\n    far: { value: 1000.0 },\n    logDepth: { value: false },\n    ortho: { value: false },\n    screenSpaceRadius: { value: false },\n  },\n  depthWrite: false,\n  depthTest: false,\n  vertexShader: /* glsl */ `\nvarying vec2 vUv;\nvoid main() {\n  vUv = uv;\n  gl_Position = vec4(position, 1);\n}`,\n\n  fragmentShader: /* glsl */ `\n    #define SAMPLES 16\n    #define FSAMPLES 16.0\nuniform sampler2D sceneDiffuse;\nuniform highp sampler2D sceneNormal;\nuniform highp sampler2D sceneDepth;\nuniform mat4 projectionMatrixInv;\nuniform mat4 viewMatrixInv;\nuniform mat4 projMat;\nuniform mat4 viewMat;\nuniform mat4 projViewMat;\nuniform vec3 cameraPos;\nuniform vec2 resolution;\nuniform float time;\nuniform vec3[SAMPLES] samples;\nuniform float[SAMPLES] samplesR;\nuniform float radius;\nuniform float distanceFalloff;\nuniform float near;\nuniform float far;\nuniform bool logDepth;\nuniform bool ortho;\nuniform bool screenSpaceRadius;\nuniform sampler2D bluenoise;\n    varying vec2 vUv;\n    highp float linearize_depth(highp float d, highp float zNear,highp float zFar)\n    {\n        return (zFar * zNear) / (zFar - d * (zFar - zNear));\n    }\n    highp float linearize_depth_ortho(highp float d, highp float nearZ, highp float farZ) {\n      return nearZ + (farZ - nearZ) * d;\n    }\n    highp float linearize_depth_log(highp float d, highp float nearZ,highp float farZ) {\n      float depth = pow(2.0, d * log2(farZ + 1.0)) - 1.0;\n      float a = farZ / (farZ - nearZ);\n      float b = farZ * nearZ / (nearZ - farZ);\n      float linDepth = a + b / depth;\n      return ortho ? linearize_depth_ortho(\n        linDepth,\n        nearZ,\n        farZ\n      ) :linearize_depth(linDepth, nearZ, farZ);\n    }\n\n    vec3 getWorldPosLog(vec3 posS) {\n      vec2 uv = posS.xy;\n      float z = posS.z;\n      float nearZ =near;\n      float farZ = far;\n      float depth = pow(2.0, z * log2(farZ + 1.0)) - 1.0;\n      float a = farZ / (farZ - nearZ);\n      float b = farZ * nearZ / (nearZ - farZ);\n      float linDepth = a + b / depth;\n      vec4 clipVec = vec4(uv, linDepth, 1.0) * 2.0 - 1.0;\n      vec4 wpos = projectionMatrixInv * clipVec;\n      return wpos.xyz / wpos.w;\n    }\n    vec3 getWorldPos(float depth, vec2 coord) {\n      #ifdef LOGDEPTH\n        return getWorldPosLog(vec3(coord, depth));\n      #endif\n      float z = depth * 2.0 - 1.0;\n      vec4 clipSpacePosition = vec4(coord * 2.0 - 1.0, z, 1.0);\n      vec4 viewSpacePosition = projectionMatrixInv * clipSpacePosition;\n      // Perspective division\n     vec4 worldSpacePosition = viewSpacePosition;\n     worldSpacePosition.xyz /= worldSpacePosition.w;\n      return worldSpacePosition.xyz;\n  }\n\n  vec3 computeNormal(vec3 worldPos, vec2 vUv) {\n    ivec2 p = ivec2(vUv * resolution);\n    float c0 = texelFetch(sceneDepth, p, 0).x;\n    float l2 = texelFetch(sceneDepth, p - ivec2(2, 0), 0).x;\n    float l1 = texelFetch(sceneDepth, p - ivec2(1, 0), 0).x;\n    float r1 = texelFetch(sceneDepth, p + ivec2(1, 0), 0).x;\n    float r2 = texelFetch(sceneDepth, p + ivec2(2, 0), 0).x;\n    float b2 = texelFetch(sceneDepth, p - ivec2(0, 2), 0).x;\n    float b1 = texelFetch(sceneDepth, p - ivec2(0, 1), 0).x;\n    float t1 = texelFetch(sceneDepth, p + ivec2(0, 1), 0).x;\n    float t2 = texelFetch(sceneDepth, p + ivec2(0, 2), 0).x;\n\n    float dl = abs((2.0 * l1 - l2) - c0);\n    float dr = abs((2.0 * r1 - r2) - c0);\n    float db = abs((2.0 * b1 - b2) - c0);\n    float dt = abs((2.0 * t1 - t2) - c0);\n\n    vec3 ce = getWorldPos(c0, vUv).xyz;\n\n    vec3 dpdx = (dl < dr) ? ce - getWorldPos(l1, (vUv - vec2(1.0 / resolution.x, 0.0))).xyz\n                          : -ce + getWorldPos(r1, (vUv + vec2(1.0 / resolution.x, 0.0))).xyz;\n    vec3 dpdy = (db < dt) ? ce - getWorldPos(b1, (vUv - vec2(0.0, 1.0 / resolution.y))).xyz\n                          : -ce + getWorldPos(t1, (vUv + vec2(0.0, 1.0 / resolution.y))).xyz;\n\n    return normalize(cross(dpdx, dpdy));\n}\n\nvoid main() {\n      vec4 diffuse = texture2D(sceneDiffuse, vUv);\n      float depth = texture2D(sceneDepth, vUv).x;\n      if (depth == 1.0) {\n        gl_FragColor = vec4(vec3(1.0), 1.0);\n        return;\n      }\n      vec3 worldPos = getWorldPos(depth, vUv);\n    //  vec3 normal = texture2D(sceneNormal, vUv).rgb;//computeNormal(worldPos, vUv);\n      #ifdef HALFRES\n        vec3 normal = texture2D(sceneNormal, vUv).rgb;\n      #else\n        vec3 normal = computeNormal(worldPos, vUv);\n      #endif\n      vec4 noise = texture2D(bluenoise, gl_FragCoord.xy / 128.0);\n      vec3 randomVec = normalize(noise.rgb * 2.0 - 1.0);\n      vec3 tangent = normalize(randomVec - normal * dot(randomVec, normal));\n      vec3 bitangent = cross(normal, tangent);\n      mat3 tbn = mat3(tangent, bitangent, normal);\n      float occluded = 0.0;\n      float totalWeight = 0.0;\n     /* float radiusScreen = distance(\n        worldPos,\n        getWorldPos(depth, vUv + \n          vec2(48.0, 0.0) / resolution)\n      );/*vUv.x < 0.5 ? radius : min(distance(\n        worldPos,\n        getWorldPos(depth, vUv + \n          vec2(100.0, 0.0) / resolution)\n      ), radius);\n      float distanceFalloffScreen = radiusScreen * 0.2;*/\n      float radiusToUse = screenSpaceRadius ? distance(\n        worldPos,\n        getWorldPos(depth, vUv +\n          vec2(radius, 0.0) / resolution)\n      ) : radius;\n      float distanceFalloffToUse =screenSpaceRadius ?\n          radiusToUse * distanceFalloff\n      : distanceFalloff;\n      float bias = (0.1 / near) * fwidth(distance(worldPos, cameraPos)) / radiusToUse;\n      for(float i = 0.0; i < FSAMPLES; i++) {\n        vec3 sampleDirection = \n        tbn * \n        samples[int(i)];\n        ;\n        float moveAmt = samplesR[int(mod(i + noise.a * FSAMPLES, FSAMPLES))];\n        vec3 samplePos = worldPos + radiusToUse * moveAmt * sampleDirection;\n        vec4 offset = projMat * vec4(samplePos, 1.0);\n        offset.xyz /= offset.w;\n        offset.xyz = offset.xyz * 0.5 + 0.5;\n        float sampleDepth = textureLod(sceneDepth, offset.xy, 0.0).x;\n        /*float distSample = logDepth ? linearize_depth_log(sampleDepth, near, far) \n         (ortho ?  linearize_depth_ortho(sampleDepth, near, far) : linearize_depth(sampleDepth, near, far));*/\n        #ifdef LOGDEPTH\n        float distSample = linearize_depth_log(sampleDepth, near, far);\n        #else\n        float distSample = ortho ? linearize_depth_ortho(sampleDepth, near, far) : linearize_depth(sampleDepth, near, far);\n        #endif\n        float distWorld = ortho ? linearize_depth_ortho(offset.z, near, far) : linearize_depth(offset.z, near, far);\n        float rangeCheck = smoothstep(0.0, 1.0, distanceFalloffToUse / (abs(distSample - distWorld)));\n        vec2 diff = gl_FragCoord.xy - ( offset.xy * resolution);\n        float weight = dot(sampleDirection, normal);\n          occluded += rangeCheck * weight * \n            (distSample + bias\n               < distWorld ? 1.0 : 0.0) * (\n          (dot(\n            diff,\n            diff\n             \n            ) < 1.0 || (sampleDepth == depth) || (\n              offset.x < 0.0 || offset.x > 1.0 || offset.y < 0.0 || offset.y > 1.0\n            ) ? 0.0 : 1.0)\n          );\n          totalWeight += weight;\n      }\n      float occ = clamp(1.0 - occluded / totalWeight, 0.0, 1.0);\n      gl_FragColor = vec4(0.5 + 0.5 * normal, occ);\n}`,\n}\n\nexport { EffectShader }\n"],"names":[],"mappings":";AAEK,MAAC,eAAe;AAAA,EACnB,UAAU;AAAA,IACR,cAAc,EAAE,OAAO,KAAM;AAAA,IAC7B,YAAY,EAAE,OAAO,KAAM;AAAA,IAC3B,aAAa,EAAE,OAAO,KAAM;AAAA,IAC5B,SAAS,EAAE,OAAO,IAAI,MAAM,QAAO,EAAI;AAAA,IACvC,SAAS,EAAE,OAAO,IAAI,MAAM,QAAO,EAAI;AAAA,IACvC,aAAa,EAAE,OAAO,IAAI,MAAM,QAAO,EAAI;AAAA,IAC3C,qBAAqB,EAAE,OAAO,IAAI,MAAM,QAAO,EAAI;AAAA,IACnD,eAAe,EAAE,OAAO,IAAI,MAAM,QAAO,EAAI;AAAA,IAC7C,WAAW,EAAE,OAAO,IAAI,MAAM,QAAO,EAAI;AAAA,IACzC,YAAY,EAAE,OAAO,IAAI,MAAM,QAAO,EAAI;AAAA,IAC1C,MAAM,EAAE,OAAO,EAAK;AAAA,IACpB,SAAS,EAAE,OAAO,GAAI;AAAA,IACtB,UAAU,EAAE,OAAO,GAAI;AAAA,IACvB,WAAW,EAAE,OAAO,KAAM;AAAA,IAC1B,iBAAiB,EAAE,OAAO,EAAK;AAAA,IAC/B,QAAQ,EAAE,OAAO,EAAK;AAAA,IACtB,MAAM,EAAE,OAAO,IAAK;AAAA,IACpB,KAAK,EAAE,OAAO,IAAQ;AAAA,IACtB,UAAU,EAAE,OAAO,MAAO;AAAA,IAC1B,OAAO,EAAE,OAAO,MAAO;AAAA,IACvB,mBAAmB,EAAE,OAAO,MAAO;AAAA,EACpC;AAAA,EACD,YAAY;AAAA,EACZ,WAAW;AAAA,EACX;AAAA;AAAA,IAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOzB;AAAA;AAAA,IAA2B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA+K7B;"}

package/dist/effects/N8AO/FullScreenTriangle.cjs

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const THREE__namespace = /* @__PURE__ */ _interopNamespaceDefault(THREE);
+class FullScreenTriangleGeometry extends THREE__namespace.BufferGeometry {
+  constructor() {
+    super();
+    __publicField(this, "boundingSphere", new THREE__namespace.Sphere());
+    this.setAttribute("position", new THREE__namespace.BufferAttribute(new Float32Array([-1, -1, 3, -1, -1, 3]), 2));
+    this.setAttribute("uv", new THREE__namespace.BufferAttribute(new Float32Array([0, 0, 2, 0, 0, 2]), 2));
+  }
+  computeBoundingSphere() {
+  }
+}
+const _geometry = new FullScreenTriangleGeometry();
+const _camera = new THREE__namespace.OrthographicCamera();
+class FullScreenTriangle {
+  constructor(material) {
+    this._mesh = new THREE__namespace.Mesh(_geometry, material);
+    this._mesh.frustumCulled = false;
+  }
+  render(renderer) {
+    renderer.render(this._mesh, _camera);
+  }
+  get material() {
+    return this._mesh.material;
+  }
+  set material(value) {
+    this._mesh.material = value;
+  }
+  dispose() {
+    this._mesh.material.dispose();
+    this._mesh.geometry.dispose();
+  }
+}
+exports.FullScreenTriangle = FullScreenTriangle;
+//# sourceMappingURL=FullScreenTriangle.cjs.map

package/dist/effects/N8AO/FullScreenTriangle.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FullScreenTriangle.cjs","sources":["../../../src/effects/N8AO/FullScreenTriangle.js"],"sourcesContent":["import * as THREE from 'three'\n\nclass FullScreenTriangleGeometry extends THREE.BufferGeometry {\n  boundingSphere = new THREE.Sphere()\n\n  constructor() {\n    super()\n    this.setAttribute('position', new THREE.BufferAttribute(new Float32Array([-1, -1, 3, -1, -1, 3]), 2))\n    this.setAttribute('uv', new THREE.BufferAttribute(new Float32Array([0, 0, 2, 0, 0, 2]), 2))\n  }\n\n  computeBoundingSphere() {}\n}\n\nconst _geometry = new FullScreenTriangleGeometry()\nconst _camera = new THREE.OrthographicCamera()\n\nexport class FullScreenTriangle {\n  constructor(material) {\n    this._mesh = new THREE.Mesh(_geometry, material)\n    this._mesh.frustumCulled = false\n  }\n\n  render(renderer) {\n    renderer.render(this._mesh, _camera)\n  }\n\n  get material() {\n    return this._mesh.material\n  }\n\n  set material(value) {\n    this._mesh.material = value\n  }\n\n  dispose() {\n    this._mesh.material.dispose()\n    this._mesh.geometry.dispose()\n  }\n}\n"],"names":["THREE"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,MAAM,mCAAmCA,iBAAM,eAAe;AAAA,EAG5D,cAAc;AACZ,UAAO;AAHT,0CAAiB,IAAIA,iBAAM,OAAQ;AAIjC,SAAK,aAAa,YAAY,IAAIA,iBAAM,gBAAgB,IAAI,aAAa,CAAC,IAAI,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AACpG,SAAK,aAAa,MAAM,IAAIA,iBAAM,gBAAgB,IAAI,aAAa,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;AAAA,EAC3F;AAAA,EAED,wBAAwB;AAAA,EAAE;AAC5B;AAEA,MAAM,YAAY,IAAI,2BAA4B;AAClD,MAAM,UAAU,IAAIA,iBAAM,mBAAoB;AAEvC,MAAM,mBAAmB;AAAA,EAC9B,YAAY,UAAU;AACpB,SAAK,QAAQ,IAAIA,iBAAM,KAAK,WAAW,QAAQ;AAC/C,SAAK,MAAM,gBAAgB;AAAA,EAC5B;AAAA,EAED,OAAO,UAAU;AACf,aAAS,OAAO,KAAK,OAAO,OAAO;AAAA,EACpC;AAAA,EAED,IAAI,WAAW;AACb,WAAO,KAAK,MAAM;AAAA,EACnB;AAAA,EAED,IAAI,SAAS,OAAO;AAClB,SAAK,MAAM,WAAW;AAAA,EACvB;AAAA,EAED,UAAU;AACR,SAAK,MAAM,SAAS,QAAS;AAC7B,SAAK,MAAM,SAAS,QAAS;AAAA,EAC9B;AACH;;"}

package/dist/effects/N8AO/FullScreenTriangle.js

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import * as THREE from "three";
+class FullScreenTriangleGeometry extends THREE.BufferGeometry {
+  constructor() {
+    super();
+    __publicField(this, "boundingSphere", new THREE.Sphere());
+    this.setAttribute("position", new THREE.BufferAttribute(new Float32Array([-1, -1, 3, -1, -1, 3]), 2));
+    this.setAttribute("uv", new THREE.BufferAttribute(new Float32Array([0, 0, 2, 0, 0, 2]), 2));
+  }
+  computeBoundingSphere() {
+  }
+}
+const _geometry = new FullScreenTriangleGeometry();
+const _camera = new THREE.OrthographicCamera();
+class FullScreenTriangle {
+  constructor(material) {
+    this._mesh = new THREE.Mesh(_geometry, material);
+    this._mesh.frustumCulled = false;
+  }
+  render(renderer) {
+    renderer.render(this._mesh, _camera);
+  }
+  get material() {
+    return this._mesh.material;
+  }
+  set material(value) {
+    this._mesh.material = value;
+  }
+  dispose() {
+    this._mesh.material.dispose();
+    this._mesh.geometry.dispose();
+  }
+}
+export {
+  FullScreenTriangle
+};
+//# sourceMappingURL=FullScreenTriangle.js.map

package/dist/effects/N8AO/FullScreenTriangle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FullScreenTriangle.js","sources":["../../../src/effects/N8AO/FullScreenTriangle.js"],"sourcesContent":["import * as THREE from 'three'\n\nclass FullScreenTriangleGeometry extends THREE.BufferGeometry {\n  boundingSphere = new THREE.Sphere()\n\n  constructor() {\n    super()\n    this.setAttribute('position', new THREE.BufferAttribute(new Float32Array([-1, -1, 3, -1, -1, 3]), 2))\n    this.setAttribute('uv', new THREE.BufferAttribute(new Float32Array([0, 0, 2, 0, 0, 2]), 2))\n  }\n\n  computeBoundingSphere() {}\n}\n\nconst _geometry = new FullScreenTriangleGeometry()\nconst _camera = new THREE.OrthographicCamera()\n\nexport class FullScreenTriangle {\n  constructor(material) {\n    this._mesh = new THREE.Mesh(_geometry, material)\n    this._mesh.frustumCulled = false\n  }\n\n  render(renderer) {\n    renderer.render(this._mesh, _camera)\n  }\n\n  get material() {\n    return this._mesh.material\n  }\n\n  set material(value) {\n    this._mesh.material = value\n  }\n\n  dispose() {\n    this._mesh.material.dispose()\n    this._mesh.geometry.dispose()\n  }\n}\n"],"names":[],"mappings":";;;;;;;AAEA,MAAM,mCAAmC,MAAM,eAAe;AAAA,EAG5D,cAAc;AACZ,UAAO;AAHT,0CAAiB,IAAI,MAAM,OAAQ;AAIjC,SAAK,aAAa,YAAY,IAAI,MAAM,gBAAgB,IAAI,aAAa,CAAC,IAAI,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AACpG,SAAK,aAAa,MAAM,IAAI,MAAM,gBAAgB,IAAI,aAAa,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;AAAA,EAC3F;AAAA,EAED,wBAAwB;AAAA,EAAE;AAC5B;AAEA,MAAM,YAAY,IAAI,2BAA4B;AAClD,MAAM,UAAU,IAAI,MAAM,mBAAoB;AAEvC,MAAM,mBAAmB;AAAA,EAC9B,YAAY,UAAU;AACpB,SAAK,QAAQ,IAAI,MAAM,KAAK,WAAW,QAAQ;AAC/C,SAAK,MAAM,gBAAgB;AAAA,EAC5B;AAAA,EAED,OAAO,UAAU;AACf,aAAS,OAAO,KAAK,OAAO,OAAO;AAAA,EACpC;AAAA,EAED,IAAI,WAAW;AACb,WAAO,KAAK,MAAM;AAAA,EACnB;AAAA,EAED,IAAI,SAAS,OAAO;AAClB,SAAK,MAAM,WAAW;AAAA,EACvB;AAAA,EAED,UAAU;AACR,SAAK,MAAM,SAAS,QAAS;AAC7B,SAAK,MAAM,SAAS,QAAS;AAAA,EAC9B;AACH;"}