trois/build/trois.module.min.js

import{Vector3 as Y,Raycaster as Ur,Plane as Hr,Vector2 as T,InstancedMesh as ce,WebGLRenderer as Xr,PCFShadowMap as Kr,NoToneMapping as Wr,OrthographicCamera as Vr,PerspectiveCamera as qr,Scene as Zr,Color as se,Texture as Yr,Group as Jr,WebGLCubeRenderTarget as Qr,RGBFormat as es,LinearMipmapLinearFilter as Me,CubeCamera as ts,Mesh as rs,BufferGeometry as ss,BufferAttribute as is,BoxGeometry as Ce,CircleGeometry as ns,ConeGeometry as as,CylinderGeometry as os,DodecahedronGeometry as hs,IcosahedronGeometry as ds,LatheGeometry as ls,OctahedronGeometry as us,PlaneGeometry as Le,PolyhedronGeometry as cs,RingGeometry as ms,SphereGeometry as fs,TetrahedronGeometry as ps,TorusGeometry as ys,TorusKnotGeometry as gs,TubeGeometry as vs,Curve as bs,CatmullRomCurve3 as Ne,SpotLight as me,DirectionalLight as fe,AmbientLight as Ss,HemisphereLight as Ps,PointLight as ws,RectAreaLight as xs,NormalBlending as Ms,FrontSide as Cs,MeshBasicMaterial as Ge,MeshLambertMaterial as Ls,TextureLoader as J,MeshMatcapMaterial as Ns,MeshPhongMaterial as Gs,MeshStandardMaterial as _s,MeshPhysicalMaterial as js,ShaderMaterial as pe,ShaderChunk as K,UniformsUtils as _e,ShaderLib as Es,MeshToonMaterial as Os,LinearEncoding as ks,UVMapping as Rs,ClampToEdgeWrapping as je,LinearFilter as $s,CubeReflectionMapping as zs,CubeTextureLoader as Ts,PointsMaterial as Is,FontLoader as As,TextGeometry as Bs,DoubleSide as Fs,SpriteMaterial as Ds,Sprite as Us,Points as Hs}from"three";import{toRef as Xs,watch as l,defineComponent as o,inject as W,provide as Ks,onUnmounted as Ws,createApp as Vs}from"vue";import{OrbitControls as qs}from"three/examples/jsm/controls/OrbitControls.js";import{RectAreaLightUniformsLib as Zs}from"three/examples/jsm/lights/RectAreaLightUniformsLib.js";import{RectAreaLightHelper as Ys}from"three/examples/jsm/helpers/RectAreaLightHelper.js";import{GLTFLoader as Js}from"three/examples/jsm/loaders/GLTFLoader.js";import{FBXLoader as Qs}from"three/examples/jsm/loaders/FBXLoader.js";import{EffectComposer as ei}from"three/examples/jsm/postprocessing/EffectComposer.js";import{RenderPass as ti}from"three/examples/jsm/postprocessing/RenderPass.js";import{BokehPass as ri}from"three/examples/jsm/postprocessing/BokehPass.js";import{FilmPass as si}from"three/examples/jsm/postprocessing/FilmPass.js";import{ShaderPass as ie}from"three/examples/jsm/postprocessing/ShaderPass.js";import{FXAAShader as ii}from"three/examples/jsm/shaders/FXAAShader.js";import{HalftonePass as ni}from"three/examples/jsm/postprocessing/HalftonePass.js";import{SMAAPass as ai}from"three/examples/jsm/postprocessing/SMAAPass.js";import{SSAOPass as oi}from"three/examples/jsm/postprocessing/SSAOPass.js";import{UnrealBloomPass as hi}from"three/examples/jsm/postprocessing/UnrealBloomPass.js";function V(e,t){t instanceof Object&&Object.entries(t).forEach(([r,s])=>{e[r]=s})}function U(e,t,r){t.forEach(s=>{u(e,s,r,s)})}function u(e,t,r,s){const n=s||t,a=Xs(e,t);a.value instanceof Object?(V(r[n],a.value),l(a,i=>{V(r[n],i)},{deep:!0})):(a.value!==void 0&&(r[n]=e[t]),l(a,i=>{r[n]=i}))}function N(e,t=[]){const r={};return Object.entries(e).forEach(([s,n])=>{(!t||t&&!t.includes(s))&&(r[s]=n)}),r}function Ee(e,t,r){return r=r<0?0:r,r=r>1?1:r,e+(t-e)*r}function Oe(e,t,r){return e<t?t:e>r?r:e}const di="https://rawcdn.githack.com/emmelleppi/matcaps/9b36ccaaf0a24881a39062d05566c9e92be4aa0d",li="0404E8_0404B5_0404CB_3333FC";function ye(e=li,t=1024){const r=`${e}${ui(t)}.png`;return`${di}/${t}/${r}`}function ui(e){switch(e){case 64:return"-64px";case 128:return"-128px";case 256:return"-256px";case 512:return"-512px";default:return""}}function ci(e){const{camera:t,resetPosition:r=new Y(0,0,0)}=e,s=new Ur,n=r.clone(),a=new Hr(new Y(0,0,1),0);return{position:n,updatePosition:b=>{s.setFromCamera(b,t),t.getWorldDirection(a.normal),s.ray.intersectPlane(a,n)},intersect:(b,R)=>(s.setFromCamera(b,t),s.intersectObjects(R))}}function ke(e){const{camera:t,domElement:r,intersectObjects:s,touch:n=!0,resetOnEnd:a=!1,resetPosition:i=new T(0,0),resetPositionV3:c=new Y(0,0,0),onEnter:b=()=>{},onMove:R=()=>{},onLeave:f=()=>{
  varying vec2 vUv;
  void main(){
    vUv = uv;
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0);
  }
`,yi=`
  varying vec2 vUv;
  void main() {
    gl_FragColor = vec4(vUv.x, vUv.y, 0., 1.0);
  }
`;var Wt=o({extends:_,props:{uniforms:{type:Object,default:()=>({})},vertexShader:{type:String,default:pi},fragmentShader:{type:String,default:yi}},methods:{createMaterial(){const e=new pe(N(this.$props,["color"]));return["vertexShader","fragmentShader"].forEach(t=>{l(()=>this[t],r=>{e[t]=r,e.needsUpdate=!0})}),e}},__hmrId:"ShaderMaterial"});function gi(e,t,r){return e.split(t).join(r)}const vi=K.meshphong_frag.slice(0,K.meshphong_frag.indexOf("void main() {")),bi=K.meshphong_frag.slice(K.meshphong_frag.indexOf("void main() {")),Si={uniforms:_e.merge([Es.phong.uniforms,{thicknessColor:{value:new se(16777215)},thicknessDistortion:{value:.1},thicknessAmbient:{value:0},thicknessAttenuation:{value:.1},thicknessPower:{value:2},thicknessScale:{value:10}}]),vertexShader:`
    #define USE_UV
    ${K.meshphong_vert}
  `,fragmentShader:`
    #define USE_UV
    #define SUBSURFACE

    ${vi}

    uniform float thicknessPower;
    uniform float thicknessScale;
    uniform float thicknessDistortion;
    uniform float thicknessAmbient;
    uniform float thicknessAttenuation;
    uniform vec3 thicknessColor;

    void RE_Direct_Scattering(const in IncidentLight directLight, const in vec2 uv, const in GeometricContext geometry, inout ReflectedLight reflectedLight) {
      #ifdef USE_COLOR
        vec3 thickness = vColor * thicknessColor;
      #else
        vec3 thickness = thicknessColor;
      #endif
      vec3 scatteringHalf = normalize(directLight.direction + (geometry.normal * thicknessDistortion));
      float scatteringDot = pow(saturate(dot(geometry.viewDir, -scatteringHalf)), thicknessPower) * thicknessScale;
      vec3 scatteringIllu = (scatteringDot + thicknessAmbient) * thickness;
      reflectedLight.directDiffuse += scatteringIllu * thicknessAttenuation * directLight.color;
    }
  `+bi.replace("#include <lights_fragment_begin>",gi(K.lights_fragment_begin,"RE_Direct( directLight, geometry, material, reflectedLight );",`
        RE_Direct( directLight, geometry, material, reflectedLight );
        #if defined( SUBSURFACE ) && defined( USE_UV )
          RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);
        #endif
      `))},Vt={color:{type:[String,Number],default:"#ffffff"},thicknessColor:{type:[String,Number],default:"#ffffff"},thicknessDistortion:{type:Number,default:.4},thicknessAmbient:{type:Number,default:.01},thicknessAttenuation:{type:Number,default:.7},thicknessPower:{type:Number,default:2},thicknessScale:{type:Number,default:4}};var qt=o({extends:_,props:Vt,methods:{createMaterial(){const e=Si,t=_e.clone(e.uniforms);return Object.keys(Vt).forEach(s=>{const n=this[s];let a=s,i=n;["color","thicknessColor"].includes(s)&&(s==="color"&&(a="diffuse"),i=new se(n)),t[a].value=i}),new pe({...e,uniforms:t,lights:!0,transparent:this.transparent,vertexColors:this.vertexColors})}},__hmrId:"SubSurfaceMaterial"}),Zt=o({extends:_,props:{...O},methods:{createMaterial(){const e=new Os(N(this.$props));return U(this,Object.keys(O),e),e}},__hmrId:"ToonMaterial"}),be=o({inject:{material:he},props:{name:{type:String,default:"map"},uniform:String,src:String,onLoad:Function,onProgress:Function,onError:Function,encoding:{type:Number,default:ks},mapping:{type:Number,default:Rs},wrapS:{type:Number,default:je},wrapT:{type:Number,default:je},magFilter:{type:Number,default:$s},minFilter:{type:Number,default:Me},repeat:{type:Object,default:()=>({x:1,y:1})},rotation:{type:Number,default:0},center:{type:Object,default:()=>({x:0,y:0})}},setup(){return{}},created(){this.refreshTexture(),l(()=>this.src,this.refreshTexture)},unmounted(){var e,t;(e=this.material)==null||e.setTexture(null,this.name),(t=this.texture)==null||t.dispose()},methods:{createTexture(){if(!this.src)return;const e=new J().load(this.src,this.onLoaded,this.onProgress,this.onError);return["encoding","mapping","wrapS","wrapT","magFilter","minFilter","repeat","rotation","center"].forEach(r=>{u(this,r,e)}),e},refreshTexture(){this.texture=this.createTexture(),this.texture&&this.material&&(this.material.setTexture(this.texture,this.name),this.material.material instanceof pe&&this.uniform&&(this.material.uniforms[this.uniform]={value:this.texture}))},onLoaded(e){var t;(t=this.onLoad)==null||t.call(this,e)}},render(){return[]}}),Yt=o({extends:be,props:{path:{type:String,required:!0},urls:{type:Array,default:()=>["px.jpg","nx.jpg","py.jpg","ny.jpg","pz.jpg","nz.jpg"]},mapping:{type:Number,default:zs}},created(){l(()=>this.path,this.refreshTexture),l(()=>this.urls,this.refreshTexture)},methods:{createTexture(){return new Ts().setPath(this.path).load(this.urls,this.onLoaded,this.onProgress,this.onError)}}}),Jt=o({extends:_,props:{size:{type:Number,default:10},sizeAttenuation:{type:Boolean,default:!0}},methods:{createMaterial(){return new Is(N(this.$props))}},__hmrId:"PointsMaterial"}),Qt=g("Box",Fe,De),er=g("Circle",He,Xe),tr=g("Cone",We,Ve),rr=g("Cylinder",Ze,Ye),sr=g("Dodecahedron",Qe,et),ir=g("Icosahedron",rt,st),nr=g("Lathe",nt,at),ar=g("Octahedron",ht,dt),or=g("Plane",ut,ct),hr=g("Polyhedron",ft,pt),dr=g("Ring",gt,vt),lr=g("Sphere",St,Pt),ur=g("Tetrahedron",xt,Mt);const Pi={text:{type:String,required:!0,default:"Text"},fontSrc:{type:String,required:!0},size:{type:Number,default:80},height:{type:Number,default:5},depth:{type:Number,default:1},curveSegments:{type:Number,default:12},bevelEnabled:{type:Boolean,default:!1},bevelThickness:{type:Number,default:10},bevelSize:{type:Number,default:8},bevelOffset:{type:Number,default:0},bevelSegments:{type:Number,default:5},align:{type:[Boolean,String],default:!1}};var cr=o({extends:H,props:Pi,setup(){return{}},created(){if(!this.fontSrc){console.error('Missing required prop: "font-src"');return}["text","size","height","curveSegments","bevelEnabled","bevelThickness","bevelSize","bevelOffset","bevelSegments","align"].forEach(r=>{l(()=>this[r],()=>{this.font&&this.refreshGeometry()})});const t=new As;this.loading=!0,t.load(this.fontSrc,r=>{this.loading=!1,this.font=r,this.createGeometry(),this.initMesh()})},methods:{createGeometry(){this.geometry=new Bs(this.text,{font:this.font,size:this.size,height:this.height,depth:this.depth,curveSegments:this.curveSegments,bevelEnabled:this.bevelEnabled,bevelThickness:this.bevelThickness,bevelSize:this.bevelSize,beve
    varying vec2 vUv;
    void main() {
      vUv = uv;
      gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
    }
  `,fragmentShader:`
    varying vec2 vUv;
    void main() {
      gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
    }
  `},$r={uniforms:{tDiffuse:{value:null},blurRadius:{value:0},gradientRadius:{value:0},start:{value:new T},end:{value:new T},delta:{value:new T},texSize:{value:new T}},vertexShader:Rr.vertexShader,fragmentShader:`
    uniform sampler2D tDiffuse;
    uniform float blurRadius;
    uniform float gradientRadius;
    uniform vec2 start;
    uniform vec2 end;
    uniform vec2 delta;
    uniform vec2 texSize;
    varying vec2 vUv;

    float random(vec3 scale, float seed) {
      /* use the fragment position for a different seed per-pixel */
      return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
    }

    void main() {
      vec4 color = vec4(0.0);
      float total = 0.0;

      /* randomize the lookup values to hide the fixed number of samples */
      float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);

      vec2 normal = normalize(vec2(start.y - end.y, end.x - start.x));
      float radius = smoothstep(0.0, 1.0, abs(dot(vUv * texSize - start, normal)) / gradientRadius) * blurRadius;
      for (float t = -30.0; t <= 30.0; t++) {
          float percent = (t + offset - 0.5) / 30.0;
          float weight = 1.0 - abs(percent);
          vec4 texel = texture2D(tDiffuse, vUv + delta / texSize * percent * radius);
          // vec4 texel2 = texture2D(tDiffuse, vUv + vec2(-delta.y, delta.x) / texSize * percent * radius);

          /* switch to pre-multiplied alpha to correctly blur transparent images */
          texel.rgb *= texel.a;
          // texel2.rgb *= texel2.a;

          color += texel * weight;
          total += 2.0 * weight;
      }

      gl_FragColor = color / total;

      /* switch back from pre-multiplied alpha */
      gl_FragColor.rgb /= gl_FragColor.a + 0.00001;
    }
  `};const wi={blurRadius:{type:Number,default:10},gradientRadius:{type:Number,default:100},start:{type:Object,default:()=>({x:0,y:100})},end:{type:Object,default:()=>({x:10,y:100})}};var zr=o({extends:k,props:wi,setup(){return{uniforms1:{},uniforms2:{}}},created(){if(!this.composer)return;this.pass1=new ie($r),this.pass2=new ie($r);const e=this.uniforms1=this.pass1.uniforms,t=this.uniforms2=this.pass2.uniforms;t.blurRadius=e.blurRadius,t.gradientRadius=e.gradientRadius,t.start=e.start,t.end=e.end,t.texSize=e.texSize,u(this,"blurRadius",e.blurRadius,"value"),u(this,"gradientRadius",e.gradientRadius,"value"),this.updateFocusLine(),["start","end"].forEach(r=>{l(()=>this[r],this.updateFocusLine,{deep:!0})}),this.pass1.setSize=(r,s)=>{e.texSize.value.set(r,s)},this.initEffectPass(this.pass1),this.composer.addPass(this.pass2)},unmounted(){this.composer&&this.pass2&&this.composer.removePass(this.pass2)},methods:{updateFocusLine(){this.uniforms1.start.value.copy(this.start),this.uniforms1.end.value.copy(this.end);const e=new T().copy(this.end).sub(this.start).normalize();this.uniforms1.delta.value.copy(e),this.uniforms2.delta.value.set(-e.y,e.x)}},__hmrId:"TiltShiftPass"});const Tr={strength:{type:Number,default:1.5},radius:{type:Number,default:0},threshold:{type:Number,default:0}};var Ir=o({extends:k,props:Tr,created(){if(!this.renderer)return;const e=new T(this.renderer.size.width,this.renderer.size.height),t=new hi(e,this.strength,this.radius,this.threshold);Object.keys(Tr).forEach(r=>{l(()=>this[r],s=>{t.uniforms[r].value=s})}),this.initEffectPass(t)},__hmrId:"UnrealBloomPass"}),xi={uniforms:{tDiffuse:{value:null},center:{value:new T(.5,.5)},strength:{value:0}},vertexShader:Rr.vertexShader,fragmentShader:`
    uniform sampler2D tDiffuse;
    uniform vec2 center;
    uniform float strength;
    varying vec2 vUv;

    float random(vec3 scale, float seed) {
      /* use the fragment position for a different seed per-pixel */
      return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
    }
    
    void main() {
      vec4 color = vec4(0.0);
      float total = 0.0;
      vec2 toCenter = center - vUv;
      
      /* randomize the lookup values to hide the fixed number of samples */
      float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
      
      for (float t = 0.0; t <= 40.0; t++) {
        float percent = (t + offset) / 40.0;
        float weight = 4.0 * (percent - percent * percent);
        vec4 texel = texture2D(tDiffuse, vUv + toCenter * percent * strength);

        /* switch to pre-multiplied alpha to correctly blur transparent images */
        texel.rgb *= texel.a;

        color += texel * weight;
        total += weight;
      }

      gl_FragColor = color / total;

      /* switch back from pre-multiplied alpha */
      gl_FragColor.rgb /= gl_FragColor.a + 0.00001;
    }
  `},Ar=o({extends:k,props:{center:{type:Object,default:()=>({x:.5,y:.5})},strength:{type:Number,default:.5}},created(){const e=new ie(xi);u(this,"center",e.uniforms.center,"value"),u(this,"strength",e.uniforms.strength,"value"),this.initEffectPass(e)},__hmrId:"ZoomBlurPass"}),Mi=Object.freeze({__proto__:null,Renderer:Re,RendererInjectionKey:G,OrthographicCamera:ze,PerspectiveCamera:ne,Camera:ne,Group:Ie,Scene:Te,SceneInjectionKey:ae,Object3D:I,Raycaster:Ae,CubeCamera:Be,BufferGeometry:oe,BoxGeometry:Ue,CircleGeometry:Ke,ConeGeometry:qe,CylinderGeometry:Je,DodecahedronGeometry:tt,IcosahedronGeometry:it,LatheGeometry:ot,OctahedronGeometry:lt,PlaneGeometry:mt,PolyhedronGeometry:yt,RingGeometry:bt,SphereGeometry:wt,TetrahedronGeometry:Ct,TorusGeometry:Gt,TorusKnotGeometry:Et,TubeGeometry:kt,AmbientLight:$t,DirectionalLight:zt,HemisphereLight:Tt,PointLight:It,RectAreaLight:At,SpotLight:Bt,Material:_,MaterialInjectionKey:he,BasicMaterial:Ft,LambertMaterial:Dt,MatcapMaterial:Ut,PhongMaterial:Ht,PhysicalMaterial:Kt,ShaderMaterial:Wt,StandardMaterial:ve,SubSurfaceMaterial:qt,ToonMaterial:Zt,Texture:be,CubeTexture:Yt,PointsMaterial:Jt,Mesh:H,MeshInjectionKey:q,Box:Qt,Circle:er,Cone:tr,Cylinder:rr,Dodecahedron:sr,Icosahedron:ir,Lathe:nr,Octahedron:ar,Plane:or,Polyhedron:hr,Ring:dr,Sphere:lr,Tetrahedron:ur,Text:cr,Torus:mr,TorusKnot:fr,Tube:pr,Image:yr,InstancedMesh:gr,Sprite:vr,Points:br,GLTFModel:Pr,FBXModel:wr,EffectComposer:xr,ComposerInjectionKey:de,RenderPass:Mr,BokehPass:Lr,FilmPass:Gr,FXAAPass:_r,HalftonePass:Er,SMAAPass:Or,SSAOPass:kr,TiltShiftPass:zr,UnrealBloomPass:Ir,ZoomBlurPass:Ar,setFromProp:V,bindProps:U,bindProp:u,propsValues:N,lerp:Ee,limit:Oe,getMatcapUrl:ye});const Br={install(e){["Camera","OrthographicCamera","PerspectiveCamera","Raycaster","Renderer","Scene","Group","CubeCamera","AmbientLight","DirectionalLight","HemisphereLight","PointLight","RectAreaLight","SpotLight","BasicMaterial","LambertMaterial","MatcapMaterial","PhongMaterial","PhysicalMaterial","PointsMaterial","ShaderMaterial","StandardMaterial","SubSurfaceMaterial","ToonMaterial","Texture","CubeTexture","BufferGeometry","Mesh","Box","BoxGeometry","Circle","CircleGeometry","Cone","ConeGeometry","Cylinder","CylinderGeometry","Dodecahedron","DodecahedronGeometry","Icosahedron","IcosahedronGeometry","Lathe","LatheGeometry","Octahedron","OctahedronGeometry","Plane","PlaneGeometry","Polyhedron","PolyhedronGeometry","Ring","RingGeometry","Sphere","SphereGeometry","Tetrahedron","TetrahedronGeometry","Text","Torus","TorusGeometry","TorusKnot","TorusKnotGeometry","Tube","TubeGeometry","Image","InstancedMesh","Points","Sprite","FBXModel","GLTFModel","BokehPass","EffectComposer","FilmPass","FXAAPass","HalftonePass","RenderPass","SAOPass","SMAAPass","SSAOPass","TiltShiftPass","UnrealBloomPass","ZoomBlurPass","GLTFViewer"].forEach(r=>{e.component(r,Mi[r])})}};function Ci(e){return Vs(e).use(Br)}function Li(){const e={loader:new J,count:0,textures:[],loadProgress:0,loadTextures:t,dispose:s};return e;function t(n,a){e.count=n.length,e.textures.splice(0),e.loadProgress=0,Promise.all(n.map(r)).then(a)}function r(n,a){return new Promise(i=>{e.loader.load(n.src,c=>{e.loadProgress+=1/e.count,e.textures[a]=c,i(c)})})}function s(){e.textures.forEach(n=>n.dispose())}}export{$t as AmbientLight,Ft as BasicMaterial,Lr as BokehPass,Qt as Box,Ue as BoxGeometry,oe as BufferGeometry,ne as Camera,er as Circle,Ke as CircleGeometry,de as ComposerInjectionKey,tr as Cone,qe as ConeGeometry,Be as CubeCamera,Yt as CubeTexture,rr as Cylinder,Je as CylinderGeometry,zt as DirectionalLight,sr as Dodecahedron,tt as DodecahedronGeometry,xr as EffectComposer,wr as FBXModel,_r as FXAAPass,Gr as FilmPass,Pr as GLTFModel,Ie as Group,Er as HalftonePass,Tt as HemisphereLight,ir as Icosahedron,it as IcosahedronGeometry,yr as Image,gr as InstancedMesh,Dt as LambertMaterial,nr as Lathe,ot as LatheGeometry,Ut as MatcapMaterial,_ as Material,he as MaterialInjectionKey,H as Mesh,q as MeshInjectionKey,I as Object3D,ar as Octahedron,lt as OctahedronGeometry,ze as OrthographicCamera,ne as PerspectiveCamer
//# sourceMappingURL=trois.module.min.js.map