@react-three/drei 9.74.13 → 9.74.14

package/src/materials/MeshReflectorMaterial.js

@@ -1,290 +0,0 @@
-import { MeshStandardMaterial } from 'three';
-
-class MeshReflectorMaterial extends MeshStandardMaterial {
-  constructor(parameters = {}) {
-    super(parameters);
-    this._tDepth = {
-      value: null
-    };
-    this._distortionMap = {
-      value: null
-    };
-    this._tDiffuse = {
-      value: null
-    };
-    this._tDiffuseBlur = {
-      value: null
-    };
-    this._textureMatrix = {
-      value: null
-    };
-    this._hasBlur = {
-      value: false
-    };
-    this._mirror = {
-      value: 0.0
-    };
-    this._mixBlur = {
-      value: 0.0
-    };
-    this._blurStrength = {
-      value: 0.5
-    };
-    this._minDepthThreshold = {
-      value: 0.9
-    };
-    this._maxDepthThreshold = {
-      value: 1
-    };
-    this._depthScale = {
-      value: 0
-    };
-    this._depthToBlurRatioBias = {
-      value: 0.25
-    };
-    this._distortion = {
-      value: 1
-    };
-    this._mixContrast = {
-      value: 1.0
-    };
-    this.setValues(parameters);
-  }
-
-  onBeforeCompile(shader) {
-    var _shader$defines;
-
-    if (!((_shader$defines = shader.defines) != null && _shader$defines.USE_UV)) {
-      shader.defines.USE_UV = '';
-    }
-
-    shader.uniforms.hasBlur = this._hasBlur;
-    shader.uniforms.tDiffuse = this._tDiffuse;
-    shader.uniforms.tDepth = this._tDepth;
-    shader.uniforms.distortionMap = this._distortionMap;
-    shader.uniforms.tDiffuseBlur = this._tDiffuseBlur;
-    shader.uniforms.textureMatrix = this._textureMatrix;
-    shader.uniforms.mirror = this._mirror;
-    shader.uniforms.mixBlur = this._mixBlur;
-    shader.uniforms.mixStrength = this._blurStrength;
-    shader.uniforms.minDepthThreshold = this._minDepthThreshold;
-    shader.uniforms.maxDepthThreshold = this._maxDepthThreshold;
-    shader.uniforms.depthScale = this._depthScale;
-    shader.uniforms.depthToBlurRatioBias = this._depthToBlurRatioBias;
-    shader.uniforms.distortion = this._distortion;
-    shader.uniforms.mixContrast = this._mixContrast;
-    shader.vertexShader = `
-        uniform mat4 textureMatrix;
-        varying vec4 my_vUv;
-      ${shader.vertexShader}`;
-    shader.vertexShader = shader.vertexShader.replace('#include <project_vertex>', `#include <project_vertex>
-        my_vUv = textureMatrix * vec4( position, 1.0 );
-        gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );`);
-    shader.fragmentShader = `
-        uniform sampler2D tDiffuse;
-        uniform sampler2D tDiffuseBlur;
-        uniform sampler2D tDepth;
-        uniform sampler2D distortionMap;
-        uniform float distortion;
-        uniform float cameraNear;
-			  uniform float cameraFar;
-        uniform bool hasBlur;
-        uniform float mixBlur;
-        uniform float mirror;
-        uniform float mixStrength;
-        uniform float minDepthThreshold;
-        uniform float maxDepthThreshold;
-        uniform float mixContrast;
-        uniform float depthScale;
-        uniform float depthToBlurRatioBias;
-        varying vec4 my_vUv;
-        ${shader.fragmentShader}`;
-    shader.fragmentShader = shader.fragmentShader.replace('#include <emissivemap_fragment>', `#include <emissivemap_fragment>
-
-      float distortionFactor = 0.0;
-      #ifdef USE_DISTORTION
-        distortionFactor = texture2D(distortionMap, vUv).r * distortion;
-      #endif
-
-      vec4 new_vUv = my_vUv;
-      new_vUv.x += distortionFactor;
-      new_vUv.y += distortionFactor;
-
-      vec4 base = texture2DProj(tDiffuse, new_vUv);
-      vec4 blur = texture2DProj(tDiffuseBlur, new_vUv);
-
-      vec4 merge = base;
-
-      #ifdef USE_NORMALMAP
-        vec2 normal_uv = vec2(0.0);
-        vec4 normalColor = texture2D(normalMap, vUv * normalScale);
-        vec3 my_normal = normalize( vec3( normalColor.r * 2.0 - 1.0, normalColor.b,  normalColor.g * 2.0 - 1.0 ) );
-        vec3 coord = new_vUv.xyz / new_vUv.w;
-        normal_uv = coord.xy + coord.z * my_normal.xz * 0.05;
-        vec4 base_normal = texture2D(tDiffuse, normal_uv);
-        vec4 blur_normal = texture2D(tDiffuseBlur, normal_uv);
-        merge = base_normal;
-        blur = blur_normal;
-      #endif
-
-      float depthFactor = 0.0001;
-      float blurFactor = 0.0;
-
-      #ifdef USE_DEPTH
-        vec4 depth = texture2DProj(tDepth, new_vUv);
-        depthFactor = smoothstep(minDepthThreshold, maxDepthThreshold, 1.0-(depth.r * depth.a));
-        depthFactor *= depthScale;
-        depthFactor = max(0.0001, min(1.0, depthFactor));
-
-        #ifdef USE_BLUR
-          blur = blur * min(1.0, depthFactor + depthToBlurRatioBias);
-          merge = merge * min(1.0, depthFactor + 0.5);
-        #else
-          merge = merge * depthFactor;
-        #endif
-
-      #endif
-
-      float reflectorRoughnessFactor = roughness;
-      #ifdef USE_ROUGHNESSMAP
-        vec4 reflectorTexelRoughness = texture2D( roughnessMap, vUv );
-        reflectorRoughnessFactor *= reflectorTexelRoughness.g;
-      #endif
-
-      #ifdef USE_BLUR
-        blurFactor = min(1.0, mixBlur * reflectorRoughnessFactor);
-        merge = mix(merge, blur, blurFactor);
-      #endif
-
-      vec4 newMerge = vec4(0.0, 0.0, 0.0, 1.0);
-      newMerge.r = (merge.r - 0.5) * mixContrast + 0.5;
-      newMerge.g = (merge.g - 0.5) * mixContrast + 0.5;
-      newMerge.b = (merge.b - 0.5) * mixContrast + 0.5;
-
-      diffuseColor.rgb = diffuseColor.rgb * ((1.0 - min(1.0, mirror)) + newMerge.rgb * mixStrength);
-      `);
-  }
-
-  get tDiffuse() {
-    return this._tDiffuse.value;
-  }
-
-  set tDiffuse(v) {
-    this._tDiffuse.value = v;
-  }
-
-  get tDepth() {
-    return this._tDepth.value;
-  }
-
-  set tDepth(v) {
-    this._tDepth.value = v;
-  }
-
-  get distortionMap() {
-    return this._distortionMap.value;
-  }
-
-  set distortionMap(v) {
-    this._distortionMap.value = v;
-  }
-
-  get tDiffuseBlur() {
-    return this._tDiffuseBlur.value;
-  }
-
-  set tDiffuseBlur(v) {
-    this._tDiffuseBlur.value = v;
-  }
-
-  get textureMatrix() {
-    return this._textureMatrix.value;
-  }
-
-  set textureMatrix(v) {
-    this._textureMatrix.value = v;
-  }
-
-  get hasBlur() {
-    return this._hasBlur.value;
-  }
-
-  set hasBlur(v) {
-    this._hasBlur.value = v;
-  }
-
-  get mirror() {
-    return this._mirror.value;
-  }
-
-  set mirror(v) {
-    this._mirror.value = v;
-  }
-
-  get mixBlur() {
-    return this._mixBlur.value;
-  }
-
-  set mixBlur(v) {
-    this._mixBlur.value = v;
-  }
-
-  get mixStrength() {
-    return this._blurStrength.value;
-  }
-
-  set mixStrength(v) {
-    this._blurStrength.value = v;
-  }
-
-  get minDepthThreshold() {
-    return this._minDepthThreshold.value;
-  }
-
-  set minDepthThreshold(v) {
-    this._minDepthThreshold.value = v;
-  }
-
-  get maxDepthThreshold() {
-    return this._maxDepthThreshold.value;
-  }
-
-  set maxDepthThreshold(v) {
-    this._maxDepthThreshold.value = v;
-  }
-
-  get depthScale() {
-    return this._depthScale.value;
-  }
-
-  set depthScale(v) {
-    this._depthScale.value = v;
-  }
-
-  get depthToBlurRatioBias() {
-    return this._depthToBlurRatioBias.value;
-  }
-
-  set depthToBlurRatioBias(v) {
-    this._depthToBlurRatioBias.value = v;
-  }
-
-  get distortion() {
-    return this._distortion.value;
-  }
-
-  set distortion(v) {
-    this._distortion.value = v;
-  }
-
-  get mixContrast() {
-    return this._mixContrast.value;
-  }
-
-  set mixContrast(v) {
-    this._mixContrast.value = v;
-  }
-
-}
-
-export { MeshReflectorMaterial };

package/src/materials/MeshRefractionMaterial.js

@@ -1,171 +0,0 @@
-import * as THREE from 'three';
-import { shaderMaterial } from '../core/shaderMaterial.js';
-import { shaderStructs, shaderIntersectFunction, MeshBVHUniformStruct } from 'three-mesh-bvh';
-
-// Author: N8Programs
-const MeshRefractionMaterial = shaderMaterial({
-  envMap: null,
-  bounces: 3,
-  ior: 2.4,
-  correctMips: true,
-  aberrationStrength: 0.01,
-  fresnel: 0,
-  bvh: new MeshBVHUniformStruct(),
-  color: new THREE.Color('white'),
-  resolution: new THREE.Vector2(),
-  viewMatrixInverse: new THREE.Matrix4(),
-  projectionMatrixInverse: new THREE.Matrix4()
-},
-/*glsl*/
-`
-  uniform mat4 viewMatrixInverse;
-
-  varying vec3 vWorldPosition;  
-  varying vec3 vNormal;
-  varying mat4 vModelMatrixInverse;
-
-  #ifdef USE_INSTANCING_COLOR
-    varying vec3 vInstanceColor;
-  #endif
-
-  void main() {        
-    vec4 transformedNormal = vec4(normal, 0.0);
-    vec4 transformedPosition = vec4(position, 1.0);
-    #ifdef USE_INSTANCING
-      transformedNormal = instanceMatrix * transformedNormal;
-      transformedPosition = instanceMatrix * transformedPosition;
-    #endif
-
-    #ifdef USE_INSTANCING
-      vModelMatrixInverse = inverse(modelMatrix * instanceMatrix);
-    #else
-      vModelMatrixInverse = inverse(modelMatrix);
-    #endif
-
-    #ifdef USE_INSTANCING_COLOR
-      vInstanceColor = instanceColor.rgb;
-    #endif
-
-    vWorldPosition = (modelMatrix * transformedPosition).xyz;
-    vNormal = normalize((viewMatrixInverse * vec4(normalMatrix * transformedNormal.xyz, 0.0)).xyz);
-    gl_Position = projectionMatrix * viewMatrix * modelMatrix * transformedPosition;
-  }`,
-/*glsl*/
-`
-  #define ENVMAP_TYPE_CUBE_UV
-  precision highp isampler2D;
-  precision highp usampler2D;
-  varying vec3 vWorldPosition;
-  varying vec3 vNormal;
-  varying mat4 vModelMatrixInverse;
-
-  #ifdef USE_INSTANCING_COLOR
-    varying vec3 vInstanceColor;
-  #endif
-    
-  #ifdef ENVMAP_TYPE_CUBEM
-    uniform samplerCube envMap;
-  #else
-    uniform sampler2D envMap;
-  #endif
-    
-  uniform float bounces;
-  ${shaderStructs}
-  ${shaderIntersectFunction}
-  uniform BVH bvh;
-  uniform float ior;
-  uniform bool correctMips;
-  uniform vec2 resolution;
-  uniform float fresnel;
-  uniform mat4 modelMatrix;
-  uniform mat4 projectionMatrixInverse;
-  uniform mat4 viewMatrixInverse;
-  uniform float aberrationStrength;
-  uniform vec3 color;
-  
-  float fresnelFunc(vec3 viewDirection, vec3 worldNormal) {
-    return pow( 1.0 + dot( viewDirection, worldNormal), 10.0 );
-  }
-    
-  vec3 totalInternalReflection(vec3 ro, vec3 rd, vec3 normal, float ior, mat4 modelMatrixInverse) {
-    vec3 rayOrigin = ro;
-    vec3 rayDirection = rd;
-    rayDirection = refract(rayDirection, normal, 1.0 / ior);
-    rayOrigin = vWorldPosition + rayDirection * 0.001;
-    rayOrigin = (modelMatrixInverse * vec4(rayOrigin, 1.0)).xyz;
-    rayDirection = normalize((modelMatrixInverse * vec4(rayDirection, 0.0)).xyz);
-    for(float i = 0.0; i < bounces; i++) {
-      uvec4 faceIndices = uvec4( 0u );
-      vec3 faceNormal = vec3( 0.0, 0.0, 1.0 );
-      vec3 barycoord = vec3( 0.0 );
-      float side = 1.0;
-      float dist = 0.0;
-      bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist );
-      vec3 hitPos = rayOrigin + rayDirection * max(dist - 0.001, 0.0);      
-      vec3 tempDir = refract(rayDirection, faceNormal, ior);
-      if (length(tempDir) != 0.0) {
-        rayDirection = tempDir;
-        break;
-      }
-      rayDirection = reflect(rayDirection, faceNormal);
-      rayOrigin = hitPos + rayDirection * 0.01;
-    }
-    rayDirection = normalize((modelMatrix * vec4(rayDirection, 0.0)).xyz);
-    return rayDirection;
-  }
-    
-  #include <common>
-  #include <cube_uv_reflection_fragment>
-    
-  #ifdef ENVMAP_TYPE_CUBEM
-    vec4 textureGradient(samplerCube envMap, vec3 rayDirection, vec3 directionCamPerfect) {
-      return textureGrad(envMap, rayDirection, dFdx(correctMips ? directionCamPerfect: rayDirection), dFdy(correctMips ? directionCamPerfect: rayDirection));
-    }
-  #else
-    vec4 textureGradient(sampler2D envMap, vec3 rayDirection, vec3 directionCamPerfect) {
-      vec2 uvv = equirectUv( rayDirection );
-      vec2 smoothUv = equirectUv( directionCamPerfect );
-      return textureGrad(envMap, uvv, dFdx(correctMips ? smoothUv : uvv), dFdy(correctMips ? smoothUv : uvv));
-    }
-  #endif
-  
-  void main() {
-    vec2 uv = gl_FragCoord.xy / resolution;
-    vec3 directionCamPerfect = (projectionMatrixInverse * vec4(uv * 2.0 - 1.0, 0.0, 1.0)).xyz;
-    directionCamPerfect = (viewMatrixInverse * vec4(directionCamPerfect, 0.0)).xyz;
-    directionCamPerfect = normalize(directionCamPerfect);
-    vec3 normal = vNormal;
-    vec3 rayOrigin = cameraPosition;
-    vec3 rayDirection = normalize(vWorldPosition - cameraPosition);
-    vec3 finalColor;
-    #ifdef CHROMATIC_ABERRATIONS
-      vec3 rayDirectionG = totalInternalReflection(rayOrigin, rayDirection, normal, max(ior, 1.0), vModelMatrixInverse);
-      #ifdef FAST_CHROMA 
-        vec3 rayDirectionR = normalize(rayDirectionG + 1.0 * vec3(aberrationStrength / 2.0));
-        vec3 rayDirectionB = normalize(rayDirectionG - 1.0 * vec3(aberrationStrength / 2.0));
-      #else
-        vec3 rayDirectionR = totalInternalReflection(rayOrigin, rayDirection, normal, max(ior * (1.0 - aberrationStrength), 1.0), vModelMatrixInverse);
-        vec3 rayDirectionB = totalInternalReflection(rayOrigin, rayDirection, normal, max(ior * (1.0 + aberrationStrength), 1.0), vModelMatrixInverse);
-      #endif
-      float finalColorR = textureGradient(envMap, rayDirectionR, directionCamPerfect).r;
-      float finalColorG = textureGradient(envMap, rayDirectionG, directionCamPerfect).g;
-      float finalColorB = textureGradient(envMap, rayDirectionB, directionCamPerfect).b;
-      finalColor = vec3(finalColorR, finalColorG, finalColorB);
-    #else
-      rayDirection = totalInternalReflection(rayOrigin, rayDirection, normal, max(ior, 1.0), vModelMatrixInverse);
-      finalColor = textureGradient(envMap, rayDirection, directionCamPerfect).rgb;    
-    #endif
-
-    finalColor *= color;
-    #ifdef USE_INSTANCING_COLOR
-      finalColor *= vInstanceColor;
-    #endif
-
-    vec3 viewDirection = normalize(vWorldPosition - cameraPosition);
-    float nFresnel = fresnelFunc(viewDirection, normal) * fresnel;
-    gl_FragColor = vec4(mix(finalColor, vec3(1.0), nFresnel), 1.0);      
-    #include <tonemapping_fragment>
-    #include <encodings_fragment>
-  }`);
-
-export { MeshRefractionMaterial };

package/src/materials/SpotLightMaterial.js

@@ -1,111 +0,0 @@
-import { ShaderMaterial, Vector3, Color, Vector2 } from 'three';
-
-class SpotLightMaterial extends ShaderMaterial {
-  constructor() {
-    super({
-      uniforms: {
-        depth: {
-          value: null
-        },
-        opacity: {
-          value: 1
-        },
-        attenuation: {
-          value: 2.5
-        },
-        anglePower: {
-          value: 12
-        },
-        spotPosition: {
-          value: new Vector3(0, 0, 0)
-        },
-        lightColor: {
-          value: new Color('white')
-        },
-        cameraNear: {
-          value: 0
-        },
-        cameraFar: {
-          value: 1
-        },
-        resolution: {
-          value: new Vector2(0, 0)
-        }
-      },
-      transparent: true,
-      depthWrite: false,
-      vertexShader:
-      /* glsl */
-      `
-      varying vec3 vNormal;
-      varying vec3 vWorldPosition;
-      varying float vViewZ;
-      varying float vIntensity;
-      uniform vec3 spotPosition;
-      uniform float attenuation;      
-
-      void main() {
-        // compute intensity
-        vNormal = normalize( normalMatrix * normal );
-        vec4 worldPosition	= modelMatrix * vec4( position, 1.0 );
-        vWorldPosition = worldPosition.xyz;
-        vec4 viewPosition = viewMatrix * worldPosition;
-        vViewZ = viewPosition.z;
-        float intensity	= distance(worldPosition.xyz, spotPosition) / attenuation;
-        intensity	= 1.0 - clamp(intensity, 0.0, 1.0);
-        vIntensity = intensity;        
-        // set gl_Position
-        gl_Position	= projectionMatrix * viewPosition;
-
-      }`,
-      fragmentShader:
-      /* glsl */
-      `
-      #include <packing>
-
-      varying vec3 vNormal;
-      varying vec3 vWorldPosition;
-      uniform vec3 lightColor;
-      uniform vec3 spotPosition;
-      uniform float attenuation;
-      uniform float anglePower;
-      uniform sampler2D depth;
-      uniform vec2 resolution;
-      uniform float cameraNear;
-      uniform float cameraFar;
-      varying float vViewZ;
-      varying float vIntensity;
-      uniform float opacity;
-
-      float readDepth( sampler2D depthSampler, vec2 coord ) {
-        float fragCoordZ = texture2D( depthSampler, coord ).x;
-        float viewZ = perspectiveDepthToViewZ(fragCoordZ, cameraNear, cameraFar);
-        return viewZ;
-      }
-
-      void main() {
-        float d = 1.0;
-        bool isSoft = resolution[0] > 0.0 && resolution[1] > 0.0;
-        if (isSoft) {
-          vec2 sUv = gl_FragCoord.xy / resolution;
-          d = readDepth(depth, sUv);
-        }
-        float intensity = vIntensity;
-        vec3 normal	= vec3(vNormal.x, vNormal.y, abs(vNormal.z));
-        float angleIntensity	= pow( dot(normal, vec3(0.0, 0.0, 1.0)), anglePower );
-        intensity	*= angleIntensity;
-        // fades when z is close to sampled depth, meaning the cone is intersecting existing geometry
-        if (isSoft) {
-          intensity	*= smoothstep(0., 1., vViewZ - d);
-        }
-        gl_FragColor = vec4(lightColor, intensity * opacity);
-
-        #include <tonemapping_fragment>
-	      #include <encodings_fragment>
-      }`
-    });
-  }
-
-}
-
-export { SpotLightMaterial };