4396 lines
1.3 MiB
JavaScript
4396 lines
1.3 MiB
JavaScript
|
var oA=Object.create;var Pl=Object.defineProperty,aA=Object.defineProperties,lA=Object.getOwnPropertyDescriptor,cA=Object.getOwnPropertyDescriptors,uA=Object.getOwnPropertyNames,Ag=Object.getOwnPropertySymbols,hA=Object.getPrototypeOf,_g=Object.prototype.hasOwnProperty,dA=Object.prototype.propertyIsEnumerable;var Tg=(r,e,t)=>e in r?Pl(r,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):r[e]=t,Ue=(r,e)=>{for(var t in e||(e={}))_g.call(e,t)&&Tg(r,t,e[t]);if(Ag)for(var t of Ag(e))dA.call(e,t)&&Tg(r,t,e[t]);return r},tt=(r,e)=>aA(r,cA(e)),Eg=r=>Pl(r,"__esModule",{value:!0});var Ng=(r,e)=>()=>(e||r((e={exports:{}}).exports,e),e.exports),fA=(r,e)=>{Eg(r);for(var t in e)Pl(r,t,{get:e[t],enumerable:!0})},pA=(r,e,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of uA(e))!_g.call(r,n)&&n!=="default"&&Pl(r,n,{get:()=>e[n],enumerable:!(t=lA(e,n))||t.enumerable});return r},Cg=r=>pA(Eg(Pl(r!=null?oA(hA(r)):{},"default",r&&r.__esModule&&"default"in r?{get:()=>r.default,enumerable:!0}:{value:r,enumerable:!0})),r);var Y0=Ng($h=>{"use strict";$h.byteLength=Z2;$h.toByteArray=eI;$h.fromByteArray=iI;var yr=[],Li=[],Q2=typeof Uint8Array!="undefined"?Uint8Array:Array,Om="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";for(Po=0,X0=Om.length;Po<X0;++Po)yr[Po]=Om[Po],Li[Om.charCodeAt(Po)]=Po;var Po,X0;Li["-".charCodeAt(0)]=62;Li["_".charCodeAt(0)]=63;function q0(r){var e=r.length;if(e%4>0)throw new Error("Invalid string. Length must be a multiple of 4");var t=r.indexOf("=");t===-1&&(t=e);var n=t===e?0:4-t%4;return[t,n]}function Z2(r){var e=q0(r),t=e[0],n=e[1];return(t+n)*3/4-n}function $2(r,e,t){return(e+t)*3/4-t}function eI(r){var e,t=q0(r),n=t[0],i=t[1],s=new Q2($2(r,n,i)),o=0,a=i>0?n-4:n,l;for(l=0;l<a;l+=4)e=Li[r.charCodeAt(l)]<<18|Li[r.charCodeAt(l+1)]<<12|Li[r.charCodeAt(l+2)]<<6|Li[r.charCodeAt(l+3)],s[o++]=e>>16&255,s[o++]=e>>8&255,s[o++]=e&255;return i===2&&(e=Li[r.charCodeAt(l)]<<2|Li[r.charCodeAt(l+1)]>>4,s[o++]=e&255),i===1&&(e=Li[r.charCodeAt(l)]<<10|Li[r.charCodeAt(l+1)]<<4|Li[r.charCodeAt(l+2)]>>2,s[o++]=e>>8&255,s[o++]=e&255),s}function tI(r){return yr[r>>18&63]+yr[r>>12&63]+yr[r>>6&63]+yr[r&63]}function nI(r,e,t){for(var n,i=[],s=e;s<t;s+=3)n=(r[s]<<16&16711680)+(r[s+1]<<8&65280)+(r[s+2]&255),i.push(tI(n));return i.join("")}function iI(r){for(var e,t=r.length,n=t%3,i=[],s=16383,o=0,a=t-n;o<a;o+=s)i.push(nI(r,o,o+s>a?a:o+s));return n===1?(e=r[t-1],i.push(yr[e>>2]+yr[e<<4&63]+"==")):n===2&&(e=(r[t-2]<<8)+r[t-1],i.push(yr[e>>10]+yr[e>>4&63]+yr[e<<2&63]+"=")),i.join("")}});var tA=Ng((Xd,eA)=>{(function(r,e){typeof Xd=="object"&&typeof eA!="undefined"?e(Xd):typeof define=="function"&&define.amd?define(["exports"],e):e((r=typeof globalThis!="undefined"?globalThis:r||self).SVDJS={})})(Xd,function(r){"use strict";r.SVD=function(e,t,n,i,s){if(t=t===void 0||t,n=n===void 0||n,s=1e-64/(i=i||Math.pow(2,-52)),!e)throw new TypeError("Matrix a is not defined");var o,a,l,c,u,h,d,f,p,m,v,g,y=e[0].length,x=e.length;if(x<y)throw new TypeError("Invalid matrix: m < n");for(var b=[],w=[],_=[],S=t==="f"?x:y,A=m=d=0;A<x;A++)w[A]=new Array(S).fill(0);for(A=0;A<y;A++)_[A]=new Array(y).fill(0);var T,L=new Array(y).fill(0);for(A=0;A<x;A++)for(o=0;o<y;o++)w[A][o]=e[A][o];for(A=0;A<y;A++){for(b[A]=d,p=0,l=A+1,o=A;o<x;o++)p+=Math.pow(w[o][A],2);if(p<s)d=0;else for(f=(h=w[A][A])*(d=h<0?Math.sqrt(p):-Math.sqrt(p))-p,w[A][A]=h-d,o=l;o<y;o++){for(p=0,a=A;a<x;a++)p+=w[a][A]*w[a][o];for(h=p/f,a=A;a<x;a++)w[a][o]=w[a][o]+h*w[a][A]}for(L[A]=d,p=0,o=l;o<y;o++)p+=Math.pow(w[A][o],2);if(p<s)d=0;else{for(f=(h=w[A][A+1])*(d=h<0?Math.sqrt(p):-Math.sqrt(p))-p,w[A][A+1]=h-d,o=l;o<y;o++)b[o]=w[A][o]/f;for(o=l;o<x;o++){for(p=0,a=l;a<y;a++)p+=w[o][a]*w[A][a];for(a=l;a<y;a++)w[o][a]=w[o][a]+p*b[a]}}m<(v=Math.abs(L[A])+Math.abs(b[A]))&&(m=v)}if(n)for(A=y-1;0<=A;A--){if(d!==0){for(f=w[A][A+1]*d,o=l;o<y;o++)_[o][A]=w[A][o]/f;for(o=l;o<y;o++){for(p=0,a=l;a<y;a++)p+=w[A][a]*_[a][o];for(a=l;a<y;a++)_[a][o]=_[a][o]+p*_[a][A]}}for(o=l;o<y;o++)_[A][o]=0,_[o][A]=0;_[A][A]=1,d=b[A],l=A}if(t){if(t==="f")for(A=y;A<x;A++){for(o=y;o<x;o++)w[A][o]=0;w[A][A]=1}f
|
||
|
|
gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
|
||
|
|
}`,f1=`void main() {
|
||
|
|
gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );
|
||
|
|
}`,_t=class extends nn{constructor(e){super();this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader=d1,this.fragmentShader=f1,this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,e!==void 0&&(e.attributes!==void 0&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(e))}copy(e){return super.copy(e),this.fragmentShader=e.fragmentShader,this.vertexShader=e.vertexShader,this.uniforms=ca(e.uniforms),this.defines=Object.assign({},e.defines),this.wireframe=e.wireframe,this.wireframeLinewidth=e.wireframeLinewidth,this.lights=e.lights,this.clipping=e.clipping,this.extensions=Object.assign({},e.extensions),this.glslVersion=e.glslVersion,this}toJSON(e){let t=super.toJSON(e);t.glslVersion=this.glslVersion,t.uniforms={};for(let i in this.uniforms){let o=this.uniforms[i].value;o&&o.isTexture?t.uniforms[i]={type:"t",value:o.toJSON(e).uuid}:o&&o.isColor?t.uniforms[i]={type:"c",value:o.getHex()}:o&&o.isVector2?t.uniforms[i]={type:"v2",value:o.toArray()}:o&&o.isVector3?t.uniforms[i]={type:"v3",value:o.toArray()}:o&&o.isVector4?t.uniforms[i]={type:"v4",value:o.toArray()}:o&&o.isMatrix3?t.uniforms[i]={type:"m3",value:o.toArray()}:o&&o.isMatrix4?t.uniforms[i]={type:"m4",value:o.toArray()}:t.uniforms[i]={value:o}}Object.keys(this.defines).length>0&&(t.defines=this.defines),t.vertexShader=this.vertexShader,t.fragmentShader=this.fragmentShader;let n={};for(let i in this.extensions)this.extensions[i]===!0&&(n[i]=!0);return Object.keys(n).length>0&&(t.extensions=n),t}};_t.prototype.isShaderMaterial=!0;var Dr=class extends Ke{constructor(){super();this.type="Camera",this.matrixWorldInverse=new me,this.projectionMatrix=new me,this.projectionMatrixInverse=new me}copy(e,t){return super.copy(e,t),this.matrixWorldInverse.copy(e.matrixWorldInverse),this.projectionMatrix.copy(e.projectionMatrix),this.projectionMatrixInverse.copy(e.projectionMatrixInverse),this}getWorldDirection(e){this.updateWorldMatrix(!0,!1);let t=this.matrixWorld.elements;return e.set(-t[8],-t[9],-t[10]).normalize()}updateMatrixWorld(e){super.updateMatrixWorld(e),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(e,t){super.updateWorldMatrix(e,t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return new this.constructor().copy(this)}};Dr.prototype.isCamera=!0;var Vt=class extends Dr{constructor(e=50,t=1,n=.1,i=2e3){super();this.type="PerspectiveCamera",this.fov=e,this.zoom=1,this.near=n,this.far=i,this.focus=10,this.aspect=t,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(e,t){return super.copy(e,t),this.fov=e.fov,this.zoom=e.zoom,this.near=e.near,this.far=e.far,this.focus=e.focus,this.aspect=e.aspect,this.view=e.view===null?null:Object.assign({},e.view),this.filmGauge=e.filmGauge,this.filmOffset=e.filmOffset,this}setFocalLength(e){let t=.5*this.getFilmHeight()/e;this.fov=Ol*2*Math.atan(t),this.updateProjectionMatrix()}getFocalLength(){let e=Math.tan(Qo*.5*this.fov);return .5*this.getFilmHeight()/e}getEffectiveFOV(){return Ol*2*Math.atan(Math.tan(Qo*.5*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}setViewOffset(e,t,n,i,s,o){this.aspect=e/t,this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=e,this.view.fullHeight=t,this.view.offsetX=n,this.view.offsetY=i,this.view.width=s,this.view.height=o,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let e=this.near,t=e*Math.tan(Qo*.5*this.fov)/this.zoom,n=2*t,i=this.aspect*n,s=-.5*i,o=this.view;if(this.view!==null&&this.vie
|
||
|
|
|
||
|
|
varying vec3 vWorldDirection;
|
||
|
|
|
||
|
|
vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
|
||
|
|
|
||
|
|
return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
void main() {
|
||
|
|
|
||
|
|
vWorldDirection = transformDirection( position, modelMatrix );
|
||
|
|
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
|
||
|
|
}
|
||
|
|
`,fragmentShader:`
|
||
|
|
|
||
|
|
uniform sampler2D tEquirect;
|
||
|
|
|
||
|
|
varying vec3 vWorldDirection;
|
||
|
|
|
||
|
|
#include <common>
|
||
|
|
|
||
|
|
void main() {
|
||
|
|
|
||
|
|
vec3 direction = normalize( vWorldDirection );
|
||
|
|
|
||
|
|
vec2 sampleUV = equirectUv( direction );
|
||
|
|
|
||
|
|
gl_FragColor = texture2D( tEquirect, sampleUV );
|
||
|
|
|
||
|
|
}
|
||
|
|
`},i=new jn(5,5,5),s=new _t({name:"CubemapFromEquirect",uniforms:ca(n.uniforms),vertexShader:n.vertexShader,fragmentShader:n.fragmentShader,side:kt,blending:It});s.uniforms.tEquirect.value=t;let o=new gt(i,s),a=t.minFilter;return t.minFilter===Ai&&(t.minFilter=$e),new ju(1,10,this).update(e,o),t.minFilter=a,o.geometry.dispose(),o.material.dispose(),this}clear(e,t,n,i){let s=e.getRenderTarget();for(let o=0;o<6;o++)e.setRenderTarget(this,o),e.clear(t,n,i);e.setRenderTarget(s)}};Lf.prototype.isWebGLCubeRenderTarget=!0;var If=new M,p1=new M,m1=new Dt,ni=class{constructor(e=new M(1,0,0),t=0){this.normal=e,this.constant=t}set(e,t){return this.normal.copy(e),this.constant=t,this}setComponents(e,t,n,i){return this.normal.set(e,t,n),this.constant=i,this}setFromNormalAndCoplanarPoint(e,t){return this.normal.copy(e),this.constant=-t.dot(this.normal),this}setFromCoplanarPoints(e,t,n){let i=If.subVectors(n,t).cross(p1.subVectors(e,t)).normalize();return this.setFromNormalAndCoplanarPoint(i,e),this}copy(e){return this.normal.copy(e.normal),this.constant=e.constant,this}normalize(){let e=1/this.normal.length();return this.normal.multiplyScalar(e),this.constant*=e,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(e){return this.normal.dot(e)+this.constant}distanceToSphere(e){return this.distanceToPoint(e.center)-e.radius}projectPoint(e,t){return t.copy(this.normal).multiplyScalar(-this.distanceToPoint(e)).add(e)}intersectLine(e,t){let n=e.delta(If),i=this.normal.dot(n);if(i===0)return this.distanceToPoint(e.start)===0?t.copy(e.start):null;let s=-(e.start.dot(this.normal)+this.constant)/i;return s<0||s>1?null:t.copy(n).multiplyScalar(s).add(e.start)}intersectsLine(e){let t=this.distanceToPoint(e.start),n=this.distanceToPoint(e.end);return t<0&&n>0||n<0&&t>0}intersectsBox(e){return e.intersectsPlane(this)}intersectsSphere(e){return e.intersectsPlane(this)}coplanarPoint(e){return e.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(e,t){let n=t||m1.getNormalMatrix(e),i=this.coplanarPoint(If).applyMatrix4(e),s=this.normal.applyMatrix3(n).normalize();return this.constant=-i.dot(s),this}translate(e){return this.constant-=e.dot(this.normal),this}equals(e){return e.normal.equals(this.normal)&&e.constant===this.constant}clone(){return new this.constructor().copy(this)}};ni.prototype.isPlane=!0;var da=new ti,Wu=new M,Vl=class{constructor(e=new ni,t=new ni,n=new ni,i=new ni,s=new ni,o=new ni){this.planes=[e,t,n,i,s,o]}set(e,t,n,i,s,o){let a=this.planes;return a[0].copy(e),a[1].copy(t),a[2].copy(n),a[3].copy(i),a[4].copy(s),a[5].copy(o),this}copy(e){let t=this.planes;for(let n=0;n<6;n++)t[n].copy(e.planes[n]);return this}setFromProjectionMatrix(e){let t=this.planes,n=e.elements,i=n[0],s=n[1],o=n[2],a=n[3],l=n[4],c=n[5],u=n[6],h=n[7],d=n[8],f=n[9],p=n[10],m=n[11],v=n[12],g=n[13],y=n[14],x=n[15];return t[0].setComponents(a-i,h-l,m-d,x-v).normalize(),t[1].setComponents(a+i,h+l,m+d,x+v).normalize(),t[2].setComponents(a+s,h+c,m+f,x+g).normalize(),t[3].setComponents(a-s,h-c,m-f,x-g).normalize(),t[4].setComponents(a-o,h-u,m-p,x-y).normalize(),t[5].setComponents(a+o,h+u,m+p,x+y).normalize(),this}intersectsObject(e){let t=e.geometry;return t.boundingSphere===null&&t.computeBoundingSphere(),da.copy(t.boundingSphere).applyMatrix4(e.matrixWorld),this.intersectsSphere(da)}intersectsSprite(e){return da.center.set(0,0,0),da.radius=.7071067811865476,da.applyMatrix4(e.matrixWorld),this.intersectsSphere(da)}intersectsSphere(e){let t=this.planes,n=e.center,i=-e.radius;for(let s=0;s<6;s++)if(t[s].distanceToPoint(n)<i)return!1;return!0}intersectsBox(e){let t=this.planes;for(let n=0;n<6;n++){let i=t[n];if(Wu.x=i.normal.x>0?e.max.x:e.min.x,Wu.y=i.normal.y>0?e.max.y:e.min.y,Wu.z=i.normal.z>0?e.max.z:e.min.z,i.distanceToPoint(Wu)<0)return!1}return!0}containsPoint(e){let t=this.planes;for(let n=0;n<6;n++)if(t[n].distanceToPoint(e)<0)return!1;return!0}clone(){return new this.constructor().copy(this)}};function gy(){let r=null,e=!1,t=null,n=null;function i(s,o){t(s,o),n=r.requestAnimationFrame(i)}return{start:function(){e!==!0&&t!
|
||
|
|
diffuseColor.a *= texture2D( alphaMap, vUv ).g;
|
||
|
|
#endif`,v1=`#ifdef USE_ALPHAMAP
|
||
|
|
uniform sampler2D alphaMap;
|
||
|
|
#endif`,x1=`#ifdef ALPHATEST
|
||
|
|
if ( diffuseColor.a < ALPHATEST ) discard;
|
||
|
|
#endif`,b1=`#ifdef USE_AOMAP
|
||
|
|
float ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;
|
||
|
|
reflectedLight.indirectDiffuse *= ambientOcclusion;
|
||
|
|
#if defined( USE_ENVMAP ) && defined( STANDARD )
|
||
|
|
float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
|
||
|
|
reflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );
|
||
|
|
#endif
|
||
|
|
#endif`,w1=`#ifdef USE_AOMAP
|
||
|
|
uniform sampler2D aoMap;
|
||
|
|
uniform float aoMapIntensity;
|
||
|
|
#endif`,S1="vec3 transformed = vec3( position );",M1=`vec3 objectNormal = vec3( normal );
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
vec3 objectTangent = vec3( tangent.xyz );
|
||
|
|
#endif`,A1=`vec2 integrateSpecularBRDF( const in float dotNV, const in float roughness ) {
|
||
|
|
const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );
|
||
|
|
const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );
|
||
|
|
vec4 r = roughness * c0 + c1;
|
||
|
|
float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;
|
||
|
|
return vec2( -1.04, 1.04 ) * a004 + r.zw;
|
||
|
|
}
|
||
|
|
float punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
|
||
|
|
#if defined ( PHYSICALLY_CORRECT_LIGHTS )
|
||
|
|
float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );
|
||
|
|
if( cutoffDistance > 0.0 ) {
|
||
|
|
distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
|
||
|
|
}
|
||
|
|
return distanceFalloff;
|
||
|
|
#else
|
||
|
|
if( cutoffDistance > 0.0 && decayExponent > 0.0 ) {
|
||
|
|
return pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );
|
||
|
|
}
|
||
|
|
return 1.0;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
vec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {
|
||
|
|
return RECIPROCAL_PI * diffuseColor;
|
||
|
|
}
|
||
|
|
vec3 F_Schlick( const in vec3 f0, const in vec3 f90, const in float dotVH ) {
|
||
|
|
float fresnel = exp2( ( -5.55473 * dotVH - 6.98316 ) * dotVH );
|
||
|
|
return ( f90 - f0 ) * fresnel + f0;
|
||
|
|
}
|
||
|
|
vec3 F_Schlick_RoughnessDependent( const in vec3 F0, const in float dotNV, const in float roughness ) {
|
||
|
|
float fresnel = exp2( ( -5.55473 * dotNV - 6.98316 ) * dotNV );
|
||
|
|
vec3 Fr = max( vec3( 1.0 - roughness ), F0 ) - F0;
|
||
|
|
return Fr * fresnel + F0;
|
||
|
|
}
|
||
|
|
float G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {
|
||
|
|
float a2 = pow2( alpha );
|
||
|
|
float gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
|
||
|
|
float gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
|
||
|
|
return 1.0 / ( gl * gv );
|
||
|
|
}
|
||
|
|
float G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
|
||
|
|
float a2 = pow2( alpha );
|
||
|
|
float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
|
||
|
|
float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
|
||
|
|
return 0.5 / max( gv + gl, EPSILON );
|
||
|
|
}
|
||
|
|
float D_GGX( const in float alpha, const in float dotNH ) {
|
||
|
|
float a2 = pow2( alpha );
|
||
|
|
float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;
|
||
|
|
return RECIPROCAL_PI * a2 / pow2( denom );
|
||
|
|
}
|
||
|
|
vec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in vec3 f90, const in float roughness ) {
|
||
|
|
float alpha = pow2( roughness );
|
||
|
|
vec3 halfDir = normalize( incidentLight.direction + viewDir );
|
||
|
|
float dotNL = saturate( dot( normal, incidentLight.direction ) );
|
||
|
|
float dotNV = saturate( dot( normal, viewDir ) );
|
||
|
|
float dotNH = saturate( dot( normal, halfDir ) );
|
||
|
|
float dotLH = saturate( dot( incidentLight.direction, halfDir ) );
|
||
|
|
vec3 F = F_Schlick( f0, f90, dotLH );
|
||
|
|
float G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );
|
||
|
|
float D = D_GGX( alpha, dotNH );
|
||
|
|
return F * ( G * D );
|
||
|
|
}
|
||
|
|
vec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {
|
||
|
|
const float LUT_SIZE = 64.0;
|
||
|
|
const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;
|
||
|
|
const float LUT_BIAS = 0.5 / LUT_SIZE;
|
||
|
|
float dotNV = saturate( dot( N, V ) );
|
||
|
|
vec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );
|
||
|
|
uv = uv * LUT_SCALE + LUT_BIAS;
|
||
|
|
return uv;
|
||
|
|
}
|
||
|
|
float LTC_ClippedSphereFormFactor( const in vec3 f ) {
|
||
|
|
float l = length( f );
|
||
|
|
return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );
|
||
|
|
}
|
||
|
|
vec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {
|
||
|
|
float x = dot( v1, v2 );
|
||
|
|
float y = abs( x );
|
||
|
|
float a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;
|
||
|
|
float b = 3.4175940 + ( 4.1616724 + y ) * y;
|
||
|
|
float v = a / b;
|
||
|
|
float theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;
|
||
|
|
return cross( v1, v2 ) * theta_sintheta;
|
||
|
|
}
|
||
|
|
vec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {
|
||
|
|
vec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];
|
||
|
|
vec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];
|
||
|
|
vec3 lightNormal = cross( v1, v2 );
|
||
|
|
if( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );
|
||
|
|
vec3 T1, T2;
|
||
|
|
T1 = normalize( V - N * dot( V, N ) );
|
||
|
|
T2 = - cross( N, T1 );
|
||
|
|
mat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );
|
||
|
|
vec3 coords[ 4 ];
|
||
|
|
coords[ 0 ] = mat * ( rectCoords[ 0 ] - P );
|
||
|
|
coords[ 1 ] = mat * ( rectCoords[ 1 ] - P );
|
||
|
|
coords[ 2 ] = mat * ( rectCoords[ 2 ] - P );
|
||
|
|
coords[ 3 ] = mat * ( rectCoords[ 3 ] - P );
|
||
|
|
coords[ 0 ] = normalize( coords[ 0 ] );
|
||
|
|
coords[ 1 ] = normalize( coords[ 1 ] );
|
||
|
|
coords[ 2 ] = normalize( coords[ 2 ] );
|
||
|
|
coords[ 3 ] = normalize( coords[ 3 ] );
|
||
|
|
vec3 vectorFormFactor = vec3( 0.0 );
|
||
|
|
vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );
|
||
|
|
vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );
|
||
|
|
vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );
|
||
|
|
vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );
|
||
|
|
float result = LTC_ClippedSphereFormFactor( vectorFormFactor );
|
||
|
|
return vec3( result );
|
||
|
|
}
|
||
|
|
vec3 BRDF_Specular_GGX_Environment( const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {
|
||
|
|
float dotNV = saturate( dot( normal, viewDir ) );
|
||
|
|
vec2 brdf = integrateSpecularBRDF( dotNV, roughness );
|
||
|
|
return specularColor * brdf.x + brdf.y;
|
||
|
|
}
|
||
|
|
void BRDF_Specular_Multiscattering_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
|
||
|
|
float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
|
||
|
|
vec3 F = F_Schlick_RoughnessDependent( specularColor, dotNV, roughness );
|
||
|
|
vec2 brdf = integrateSpecularBRDF( dotNV, roughness );
|
||
|
|
vec3 FssEss = F * brdf.x + brdf.y;
|
||
|
|
float Ess = brdf.x + brdf.y;
|
||
|
|
float Ems = 1.0 - Ess;
|
||
|
|
vec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619; vec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );
|
||
|
|
singleScatter += FssEss;
|
||
|
|
multiScatter += Fms * Ems;
|
||
|
|
}
|
||
|
|
float G_BlinnPhong_Implicit( ) {
|
||
|
|
return 0.25;
|
||
|
|
}
|
||
|
|
float D_BlinnPhong( const in float shininess, const in float dotNH ) {
|
||
|
|
return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );
|
||
|
|
}
|
||
|
|
vec3 BRDF_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {
|
||
|
|
vec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );
|
||
|
|
float dotNH = saturate( dot( geometry.normal, halfDir ) );
|
||
|
|
float dotLH = saturate( dot( incidentLight.direction, halfDir ) );
|
||
|
|
vec3 F = F_Schlick( specularColor, vec3( 1.0 ), dotLH );
|
||
|
|
float G = G_BlinnPhong_Implicit( );
|
||
|
|
float D = D_BlinnPhong( shininess, dotNH );
|
||
|
|
return F * ( G * D );
|
||
|
|
}
|
||
|
|
float GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {
|
||
|
|
return ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );
|
||
|
|
}
|
||
|
|
float BlinnExponentToGGXRoughness( const in float blinnExponent ) {
|
||
|
|
return sqrt( 2.0 / ( blinnExponent + 2.0 ) );
|
||
|
|
}
|
||
|
|
#if defined( USE_SHEEN )
|
||
|
|
float D_Charlie(float roughness, float NoH) {
|
||
|
|
float invAlpha = 1.0 / roughness;
|
||
|
|
float cos2h = NoH * NoH;
|
||
|
|
float sin2h = max(1.0 - cos2h, 0.0078125); return (2.0 + invAlpha) * pow(sin2h, invAlpha * 0.5) / (2.0 * PI);
|
||
|
|
}
|
||
|
|
float V_Neubelt(float NoV, float NoL) {
|
||
|
|
return saturate(1.0 / (4.0 * (NoL + NoV - NoL * NoV)));
|
||
|
|
}
|
||
|
|
vec3 BRDF_Specular_Sheen( const in float roughness, const in vec3 L, const in GeometricContext geometry, vec3 specularColor ) {
|
||
|
|
vec3 N = geometry.normal;
|
||
|
|
vec3 V = geometry.viewDir;
|
||
|
|
vec3 H = normalize( V + L );
|
||
|
|
float dotNH = saturate( dot( N, H ) );
|
||
|
|
return specularColor * D_Charlie( roughness, dotNH ) * V_Neubelt( dot(N, V), dot(N, L) );
|
||
|
|
}
|
||
|
|
#endif`,_1=`#ifdef USE_BUMPMAP
|
||
|
|
uniform sampler2D bumpMap;
|
||
|
|
uniform float bumpScale;
|
||
|
|
vec2 dHdxy_fwd() {
|
||
|
|
vec2 dSTdx = dFdx( vUv );
|
||
|
|
vec2 dSTdy = dFdy( vUv );
|
||
|
|
float Hll = bumpScale * texture2D( bumpMap, vUv ).x;
|
||
|
|
float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;
|
||
|
|
float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;
|
||
|
|
return vec2( dBx, dBy );
|
||
|
|
}
|
||
|
|
vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {
|
||
|
|
vec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );
|
||
|
|
vec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );
|
||
|
|
vec3 vN = surf_norm;
|
||
|
|
vec3 R1 = cross( vSigmaY, vN );
|
||
|
|
vec3 R2 = cross( vN, vSigmaX );
|
||
|
|
float fDet = dot( vSigmaX, R1 ) * faceDirection;
|
||
|
|
vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );
|
||
|
|
return normalize( abs( fDet ) * surf_norm - vGrad );
|
||
|
|
}
|
||
|
|
#endif`,T1=`#if NUM_CLIPPING_PLANES > 0
|
||
|
|
vec4 plane;
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {
|
||
|
|
plane = clippingPlanes[ i ];
|
||
|
|
if ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
|
||
|
|
bool clipped = true;
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {
|
||
|
|
plane = clippingPlanes[ i ];
|
||
|
|
clipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
if ( clipped ) discard;
|
||
|
|
#endif
|
||
|
|
#endif`,E1=`#if NUM_CLIPPING_PLANES > 0
|
||
|
|
varying vec3 vClipPosition;
|
||
|
|
uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];
|
||
|
|
#endif`,N1=`#if NUM_CLIPPING_PLANES > 0
|
||
|
|
varying vec3 vClipPosition;
|
||
|
|
#endif`,C1=`#if NUM_CLIPPING_PLANES > 0
|
||
|
|
vClipPosition = - mvPosition.xyz;
|
||
|
|
#endif`,L1=`#if defined( USE_COLOR_ALPHA )
|
||
|
|
diffuseColor *= vColor;
|
||
|
|
#elif defined( USE_COLOR )
|
||
|
|
diffuseColor.rgb *= vColor;
|
||
|
|
#endif`,I1=`#if defined( USE_COLOR_ALPHA )
|
||
|
|
varying vec4 vColor;
|
||
|
|
#elif defined( USE_COLOR )
|
||
|
|
varying vec3 vColor;
|
||
|
|
#endif`,P1=`#if defined( USE_COLOR_ALPHA )
|
||
|
|
varying vec4 vColor;
|
||
|
|
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
|
||
|
|
varying vec3 vColor;
|
||
|
|
#endif`,D1=`#if defined( USE_COLOR_ALPHA )
|
||
|
|
vColor = vec4( 1.0 );
|
||
|
|
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
|
||
|
|
vColor = vec3( 1.0 );
|
||
|
|
#endif
|
||
|
|
#ifdef USE_COLOR
|
||
|
|
vColor *= color;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_INSTANCING_COLOR
|
||
|
|
vColor.xyz *= instanceColor.xyz;
|
||
|
|
#endif`,R1=`#define PI 3.141592653589793
|
||
|
|
#define PI2 6.283185307179586
|
||
|
|
#define PI_HALF 1.5707963267948966
|
||
|
|
#define RECIPROCAL_PI 0.3183098861837907
|
||
|
|
#define RECIPROCAL_PI2 0.15915494309189535
|
||
|
|
#define EPSILON 1e-6
|
||
|
|
#ifndef saturate
|
||
|
|
#define saturate(a) clamp( a, 0.0, 1.0 )
|
||
|
|
#endif
|
||
|
|
#define whiteComplement(a) ( 1.0 - saturate( a ) )
|
||
|
|
float pow2( const in float x ) { return x*x; }
|
||
|
|
float pow3( const in float x ) { return x*x*x; }
|
||
|
|
float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
|
||
|
|
float average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }
|
||
|
|
highp float rand( const in vec2 uv ) {
|
||
|
|
const highp float a = 12.9898, b = 78.233, c = 43758.5453;
|
||
|
|
highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
|
||
|
|
return fract(sin(sn) * c);
|
||
|
|
}
|
||
|
|
#ifdef HIGH_PRECISION
|
||
|
|
float precisionSafeLength( vec3 v ) { return length( v ); }
|
||
|
|
#else
|
||
|
|
float max3( vec3 v ) { return max( max( v.x, v.y ), v.z ); }
|
||
|
|
float precisionSafeLength( vec3 v ) {
|
||
|
|
float maxComponent = max3( abs( v ) );
|
||
|
|
return length( v / maxComponent ) * maxComponent;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
struct IncidentLight {
|
||
|
|
vec3 color;
|
||
|
|
vec3 direction;
|
||
|
|
bool visible;
|
||
|
|
};
|
||
|
|
struct ReflectedLight {
|
||
|
|
vec3 directDiffuse;
|
||
|
|
vec3 directSpecular;
|
||
|
|
vec3 indirectDiffuse;
|
||
|
|
vec3 indirectSpecular;
|
||
|
|
};
|
||
|
|
struct GeometricContext {
|
||
|
|
vec3 position;
|
||
|
|
vec3 normal;
|
||
|
|
vec3 viewDir;
|
||
|
|
#ifdef CLEARCOAT
|
||
|
|
vec3 clearcoatNormal;
|
||
|
|
#endif
|
||
|
|
};
|
||
|
|
vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
|
||
|
|
return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
|
||
|
|
}
|
||
|
|
vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
|
||
|
|
return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
|
||
|
|
}
|
||
|
|
vec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {
|
||
|
|
float distance = dot( planeNormal, point - pointOnPlane );
|
||
|
|
return - distance * planeNormal + point;
|
||
|
|
}
|
||
|
|
float sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {
|
||
|
|
return sign( dot( point - pointOnPlane, planeNormal ) );
|
||
|
|
}
|
||
|
|
vec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {
|
||
|
|
return lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;
|
||
|
|
}
|
||
|
|
mat3 transposeMat3( const in mat3 m ) {
|
||
|
|
mat3 tmp;
|
||
|
|
tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
|
||
|
|
tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
|
||
|
|
tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
|
||
|
|
return tmp;
|
||
|
|
}
|
||
|
|
float linearToRelativeLuminance( const in vec3 color ) {
|
||
|
|
vec3 weights = vec3( 0.2126, 0.7152, 0.0722 );
|
||
|
|
return dot( weights, color.rgb );
|
||
|
|
}
|
||
|
|
bool isPerspectiveMatrix( mat4 m ) {
|
||
|
|
return m[ 2 ][ 3 ] == - 1.0;
|
||
|
|
}
|
||
|
|
vec2 equirectUv( in vec3 dir ) {
|
||
|
|
float u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;
|
||
|
|
float v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;
|
||
|
|
return vec2( u, v );
|
||
|
|
}`,B1=`#ifdef ENVMAP_TYPE_CUBE_UV
|
||
|
|
#define cubeUV_maxMipLevel 8.0
|
||
|
|
#define cubeUV_minMipLevel 4.0
|
||
|
|
#define cubeUV_maxTileSize 256.0
|
||
|
|
#define cubeUV_minTileSize 16.0
|
||
|
|
float getFace( vec3 direction ) {
|
||
|
|
vec3 absDirection = abs( direction );
|
||
|
|
float face = - 1.0;
|
||
|
|
if ( absDirection.x > absDirection.z ) {
|
||
|
|
if ( absDirection.x > absDirection.y )
|
||
|
|
face = direction.x > 0.0 ? 0.0 : 3.0;
|
||
|
|
else
|
||
|
|
face = direction.y > 0.0 ? 1.0 : 4.0;
|
||
|
|
} else {
|
||
|
|
if ( absDirection.z > absDirection.y )
|
||
|
|
face = direction.z > 0.0 ? 2.0 : 5.0;
|
||
|
|
else
|
||
|
|
face = direction.y > 0.0 ? 1.0 : 4.0;
|
||
|
|
}
|
||
|
|
return face;
|
||
|
|
}
|
||
|
|
vec2 getUV( vec3 direction, float face ) {
|
||
|
|
vec2 uv;
|
||
|
|
if ( face == 0.0 ) {
|
||
|
|
uv = vec2( direction.z, direction.y ) / abs( direction.x );
|
||
|
|
} else if ( face == 1.0 ) {
|
||
|
|
uv = vec2( - direction.x, - direction.z ) / abs( direction.y );
|
||
|
|
} else if ( face == 2.0 ) {
|
||
|
|
uv = vec2( - direction.x, direction.y ) / abs( direction.z );
|
||
|
|
} else if ( face == 3.0 ) {
|
||
|
|
uv = vec2( - direction.z, direction.y ) / abs( direction.x );
|
||
|
|
} else if ( face == 4.0 ) {
|
||
|
|
uv = vec2( - direction.x, direction.z ) / abs( direction.y );
|
||
|
|
} else {
|
||
|
|
uv = vec2( direction.x, direction.y ) / abs( direction.z );
|
||
|
|
}
|
||
|
|
return 0.5 * ( uv + 1.0 );
|
||
|
|
}
|
||
|
|
vec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {
|
||
|
|
float face = getFace( direction );
|
||
|
|
float filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );
|
||
|
|
mipInt = max( mipInt, cubeUV_minMipLevel );
|
||
|
|
float faceSize = exp2( mipInt );
|
||
|
|
float texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );
|
||
|
|
vec2 uv = getUV( direction, face ) * ( faceSize - 1.0 );
|
||
|
|
vec2 f = fract( uv );
|
||
|
|
uv += 0.5 - f;
|
||
|
|
if ( face > 2.0 ) {
|
||
|
|
uv.y += faceSize;
|
||
|
|
face -= 3.0;
|
||
|
|
}
|
||
|
|
uv.x += face * faceSize;
|
||
|
|
if ( mipInt < cubeUV_maxMipLevel ) {
|
||
|
|
uv.y += 2.0 * cubeUV_maxTileSize;
|
||
|
|
}
|
||
|
|
uv.y += filterInt * 2.0 * cubeUV_minTileSize;
|
||
|
|
uv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );
|
||
|
|
uv *= texelSize;
|
||
|
|
vec3 tl = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;
|
||
|
|
uv.x += texelSize;
|
||
|
|
vec3 tr = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;
|
||
|
|
uv.y += texelSize;
|
||
|
|
vec3 br = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;
|
||
|
|
uv.x -= texelSize;
|
||
|
|
vec3 bl = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;
|
||
|
|
vec3 tm = mix( tl, tr, f.x );
|
||
|
|
vec3 bm = mix( bl, br, f.x );
|
||
|
|
return mix( tm, bm, f.y );
|
||
|
|
}
|
||
|
|
#define r0 1.0
|
||
|
|
#define v0 0.339
|
||
|
|
#define m0 - 2.0
|
||
|
|
#define r1 0.8
|
||
|
|
#define v1 0.276
|
||
|
|
#define m1 - 1.0
|
||
|
|
#define r4 0.4
|
||
|
|
#define v4 0.046
|
||
|
|
#define m4 2.0
|
||
|
|
#define r5 0.305
|
||
|
|
#define v5 0.016
|
||
|
|
#define m5 3.0
|
||
|
|
#define r6 0.21
|
||
|
|
#define v6 0.0038
|
||
|
|
#define m6 4.0
|
||
|
|
float roughnessToMip( float roughness ) {
|
||
|
|
float mip = 0.0;
|
||
|
|
if ( roughness >= r1 ) {
|
||
|
|
mip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;
|
||
|
|
} else if ( roughness >= r4 ) {
|
||
|
|
mip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;
|
||
|
|
} else if ( roughness >= r5 ) {
|
||
|
|
mip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;
|
||
|
|
} else if ( roughness >= r6 ) {
|
||
|
|
mip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;
|
||
|
|
} else {
|
||
|
|
mip = - 2.0 * log2( 1.16 * roughness ); }
|
||
|
|
return mip;
|
||
|
|
}
|
||
|
|
vec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {
|
||
|
|
float mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );
|
||
|
|
float mipF = fract( mip );
|
||
|
|
float mipInt = floor( mip );
|
||
|
|
vec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );
|
||
|
|
if ( mipF == 0.0 ) {
|
||
|
|
return vec4( color0, 1.0 );
|
||
|
|
} else {
|
||
|
|
vec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );
|
||
|
|
return vec4( mix( color0, color1, mipF ), 1.0 );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif`,O1=`vec3 transformedNormal = objectNormal;
|
||
|
|
#ifdef USE_INSTANCING
|
||
|
|
mat3 m = mat3( instanceMatrix );
|
||
|
|
transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );
|
||
|
|
transformedNormal = m * transformedNormal;
|
||
|
|
#endif
|
||
|
|
transformedNormal = normalMatrix * transformedNormal;
|
||
|
|
#ifdef FLIP_SIDED
|
||
|
|
transformedNormal = - transformedNormal;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;
|
||
|
|
#ifdef FLIP_SIDED
|
||
|
|
transformedTangent = - transformedTangent;
|
||
|
|
#endif
|
||
|
|
#endif`,F1=`#ifdef USE_DISPLACEMENTMAP
|
||
|
|
uniform sampler2D displacementMap;
|
||
|
|
uniform float displacementScale;
|
||
|
|
uniform float displacementBias;
|
||
|
|
#endif`,z1=`#ifdef USE_DISPLACEMENTMAP
|
||
|
|
transformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );
|
||
|
|
#endif`,G1=`#ifdef USE_EMISSIVEMAP
|
||
|
|
vec4 emissiveColor = texture2D( emissiveMap, vUv );
|
||
|
|
emissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;
|
||
|
|
totalEmissiveRadiance *= emissiveColor.rgb;
|
||
|
|
#endif`,U1=`#ifdef USE_EMISSIVEMAP
|
||
|
|
uniform sampler2D emissiveMap;
|
||
|
|
#endif`,k1="gl_FragColor = linearToOutputTexel( gl_FragColor );",V1=`
|
||
|
|
vec4 LinearToLinear( in vec4 value ) {
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
vec4 GammaToLinear( in vec4 value, in float gammaFactor ) {
|
||
|
|
return vec4( pow( value.rgb, vec3( gammaFactor ) ), value.a );
|
||
|
|
}
|
||
|
|
vec4 LinearToGamma( in vec4 value, in float gammaFactor ) {
|
||
|
|
return vec4( pow( value.rgb, vec3( 1.0 / gammaFactor ) ), value.a );
|
||
|
|
}
|
||
|
|
vec4 sRGBToLinear( in vec4 value ) {
|
||
|
|
return vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.a );
|
||
|
|
}
|
||
|
|
vec4 LinearTosRGB( in vec4 value ) {
|
||
|
|
return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );
|
||
|
|
}
|
||
|
|
vec4 RGBEToLinear( in vec4 value ) {
|
||
|
|
return vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );
|
||
|
|
}
|
||
|
|
vec4 LinearToRGBE( in vec4 value ) {
|
||
|
|
float maxComponent = max( max( value.r, value.g ), value.b );
|
||
|
|
float fExp = clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );
|
||
|
|
return vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );
|
||
|
|
}
|
||
|
|
vec4 RGBMToLinear( in vec4 value, in float maxRange ) {
|
||
|
|
return vec4( value.rgb * value.a * maxRange, 1.0 );
|
||
|
|
}
|
||
|
|
vec4 LinearToRGBM( in vec4 value, in float maxRange ) {
|
||
|
|
float maxRGB = max( value.r, max( value.g, value.b ) );
|
||
|
|
float M = clamp( maxRGB / maxRange, 0.0, 1.0 );
|
||
|
|
M = ceil( M * 255.0 ) / 255.0;
|
||
|
|
return vec4( value.rgb / ( M * maxRange ), M );
|
||
|
|
}
|
||
|
|
vec4 RGBDToLinear( in vec4 value, in float maxRange ) {
|
||
|
|
return vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );
|
||
|
|
}
|
||
|
|
vec4 LinearToRGBD( in vec4 value, in float maxRange ) {
|
||
|
|
float maxRGB = max( value.r, max( value.g, value.b ) );
|
||
|
|
float D = max( maxRange / maxRGB, 1.0 );
|
||
|
|
D = clamp( floor( D ) / 255.0, 0.0, 1.0 );
|
||
|
|
return vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );
|
||
|
|
}
|
||
|
|
const mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );
|
||
|
|
vec4 LinearToLogLuv( in vec4 value ) {
|
||
|
|
vec3 Xp_Y_XYZp = cLogLuvM * value.rgb;
|
||
|
|
Xp_Y_XYZp = max( Xp_Y_XYZp, vec3( 1e-6, 1e-6, 1e-6 ) );
|
||
|
|
vec4 vResult;
|
||
|
|
vResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;
|
||
|
|
float Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;
|
||
|
|
vResult.w = fract( Le );
|
||
|
|
vResult.z = ( Le - ( floor( vResult.w * 255.0 ) ) / 255.0 ) / 255.0;
|
||
|
|
return vResult;
|
||
|
|
}
|
||
|
|
const mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );
|
||
|
|
vec4 LogLuvToLinear( in vec4 value ) {
|
||
|
|
float Le = value.z * 255.0 + value.w;
|
||
|
|
vec3 Xp_Y_XYZp;
|
||
|
|
Xp_Y_XYZp.y = exp2( ( Le - 127.0 ) / 2.0 );
|
||
|
|
Xp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;
|
||
|
|
Xp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;
|
||
|
|
vec3 vRGB = cLogLuvInverseM * Xp_Y_XYZp.rgb;
|
||
|
|
return vec4( max( vRGB, 0.0 ), 1.0 );
|
||
|
|
}`,H1=`#ifdef USE_ENVMAP
|
||
|
|
#ifdef ENV_WORLDPOS
|
||
|
|
vec3 cameraToFrag;
|
||
|
|
if ( isOrthographic ) {
|
||
|
|
cameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
|
||
|
|
} else {
|
||
|
|
cameraToFrag = normalize( vWorldPosition - cameraPosition );
|
||
|
|
}
|
||
|
|
vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
|
||
|
|
#ifdef ENVMAP_MODE_REFLECTION
|
||
|
|
vec3 reflectVec = reflect( cameraToFrag, worldNormal );
|
||
|
|
#else
|
||
|
|
vec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );
|
||
|
|
#endif
|
||
|
|
#else
|
||
|
|
vec3 reflectVec = vReflect;
|
||
|
|
#endif
|
||
|
|
#ifdef ENVMAP_TYPE_CUBE
|
||
|
|
vec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
|
||
|
|
#elif defined( ENVMAP_TYPE_CUBE_UV )
|
||
|
|
vec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );
|
||
|
|
#else
|
||
|
|
vec4 envColor = vec4( 0.0 );
|
||
|
|
#endif
|
||
|
|
#ifndef ENVMAP_TYPE_CUBE_UV
|
||
|
|
envColor = envMapTexelToLinear( envColor );
|
||
|
|
#endif
|
||
|
|
#ifdef ENVMAP_BLENDING_MULTIPLY
|
||
|
|
outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );
|
||
|
|
#elif defined( ENVMAP_BLENDING_MIX )
|
||
|
|
outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );
|
||
|
|
#elif defined( ENVMAP_BLENDING_ADD )
|
||
|
|
outgoingLight += envColor.xyz * specularStrength * reflectivity;
|
||
|
|
#endif
|
||
|
|
#endif`,j1=`#ifdef USE_ENVMAP
|
||
|
|
uniform float envMapIntensity;
|
||
|
|
uniform float flipEnvMap;
|
||
|
|
uniform int maxMipLevel;
|
||
|
|
#ifdef ENVMAP_TYPE_CUBE
|
||
|
|
uniform samplerCube envMap;
|
||
|
|
#else
|
||
|
|
uniform sampler2D envMap;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#endif`,W1=`#ifdef USE_ENVMAP
|
||
|
|
uniform float reflectivity;
|
||
|
|
#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
|
||
|
|
#define ENV_WORLDPOS
|
||
|
|
#endif
|
||
|
|
#ifdef ENV_WORLDPOS
|
||
|
|
varying vec3 vWorldPosition;
|
||
|
|
uniform float refractionRatio;
|
||
|
|
#else
|
||
|
|
varying vec3 vReflect;
|
||
|
|
#endif
|
||
|
|
#endif`,J1=`#ifdef USE_ENVMAP
|
||
|
|
#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )
|
||
|
|
#define ENV_WORLDPOS
|
||
|
|
#endif
|
||
|
|
#ifdef ENV_WORLDPOS
|
||
|
|
|
||
|
|
varying vec3 vWorldPosition;
|
||
|
|
#else
|
||
|
|
varying vec3 vReflect;
|
||
|
|
uniform float refractionRatio;
|
||
|
|
#endif
|
||
|
|
#endif`,X1=`#ifdef USE_ENVMAP
|
||
|
|
#ifdef ENV_WORLDPOS
|
||
|
|
vWorldPosition = worldPosition.xyz;
|
||
|
|
#else
|
||
|
|
vec3 cameraToVertex;
|
||
|
|
if ( isOrthographic ) {
|
||
|
|
cameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
|
||
|
|
} else {
|
||
|
|
cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
|
||
|
|
}
|
||
|
|
vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
|
||
|
|
#ifdef ENVMAP_MODE_REFLECTION
|
||
|
|
vReflect = reflect( cameraToVertex, worldNormal );
|
||
|
|
#else
|
||
|
|
vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#endif`,q1=`#ifdef USE_FOG
|
||
|
|
fogDepth = - mvPosition.z;
|
||
|
|
#endif`,Y1=`#ifdef USE_FOG
|
||
|
|
varying float fogDepth;
|
||
|
|
#endif`,K1=`#ifdef USE_FOG
|
||
|
|
#ifdef FOG_EXP2
|
||
|
|
float fogFactor = 1.0 - exp( - fogDensity * fogDensity * fogDepth * fogDepth );
|
||
|
|
#else
|
||
|
|
float fogFactor = smoothstep( fogNear, fogFar, fogDepth );
|
||
|
|
#endif
|
||
|
|
gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
|
||
|
|
#endif`,Q1=`#ifdef USE_FOG
|
||
|
|
uniform vec3 fogColor;
|
||
|
|
varying float fogDepth;
|
||
|
|
#ifdef FOG_EXP2
|
||
|
|
uniform float fogDensity;
|
||
|
|
#else
|
||
|
|
uniform float fogNear;
|
||
|
|
uniform float fogFar;
|
||
|
|
#endif
|
||
|
|
#endif`,Z1=`#ifdef USE_GRADIENTMAP
|
||
|
|
uniform sampler2D gradientMap;
|
||
|
|
#endif
|
||
|
|
vec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {
|
||
|
|
float dotNL = dot( normal, lightDirection );
|
||
|
|
vec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );
|
||
|
|
#ifdef USE_GRADIENTMAP
|
||
|
|
return texture2D( gradientMap, coord ).rgb;
|
||
|
|
#else
|
||
|
|
return ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );
|
||
|
|
#endif
|
||
|
|
}`,$1=`#ifdef USE_LIGHTMAP
|
||
|
|
vec4 lightMapTexel= texture2D( lightMap, vUv2 );
|
||
|
|
reflectedLight.indirectDiffuse += PI * lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;
|
||
|
|
#endif`,eT=`#ifdef USE_LIGHTMAP
|
||
|
|
uniform sampler2D lightMap;
|
||
|
|
uniform float lightMapIntensity;
|
||
|
|
#endif`,tT=`vec3 diffuse = vec3( 1.0 );
|
||
|
|
GeometricContext geometry;
|
||
|
|
geometry.position = mvPosition.xyz;
|
||
|
|
geometry.normal = normalize( transformedNormal );
|
||
|
|
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
|
||
|
|
GeometricContext backGeometry;
|
||
|
|
backGeometry.position = geometry.position;
|
||
|
|
backGeometry.normal = -geometry.normal;
|
||
|
|
backGeometry.viewDir = geometry.viewDir;
|
||
|
|
vLightFront = vec3( 0.0 );
|
||
|
|
vIndirectFront = vec3( 0.0 );
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
vLightBack = vec3( 0.0 );
|
||
|
|
vIndirectBack = vec3( 0.0 );
|
||
|
|
#endif
|
||
|
|
IncidentLight directLight;
|
||
|
|
float dotNL;
|
||
|
|
vec3 directLightColor_Diffuse;
|
||
|
|
vIndirectFront += getAmbientLightIrradiance( ambientLightColor );
|
||
|
|
vIndirectFront += getLightProbeIrradiance( lightProbe, geometry );
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
vIndirectBack += getAmbientLightIrradiance( ambientLightColor );
|
||
|
|
vIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry );
|
||
|
|
#endif
|
||
|
|
#if NUM_POINT_LIGHTS > 0
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
|
||
|
|
getPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );
|
||
|
|
dotNL = dot( geometry.normal, directLight.direction );
|
||
|
|
directLightColor_Diffuse = PI * directLight.color;
|
||
|
|
vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#if NUM_SPOT_LIGHTS > 0
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
|
||
|
|
getSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );
|
||
|
|
dotNL = dot( geometry.normal, directLight.direction );
|
||
|
|
directLightColor_Diffuse = PI * directLight.color;
|
||
|
|
vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#if NUM_DIR_LIGHTS > 0
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
|
||
|
|
getDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );
|
||
|
|
dotNL = dot( geometry.normal, directLight.direction );
|
||
|
|
directLightColor_Diffuse = PI * directLight.color;
|
||
|
|
vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#if NUM_HEMI_LIGHTS > 0
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
|
||
|
|
vIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
vIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif`,nT=`uniform bool receiveShadow;
|
||
|
|
uniform vec3 ambientLightColor;
|
||
|
|
uniform vec3 lightProbe[ 9 ];
|
||
|
|
vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
|
||
|
|
float x = normal.x, y = normal.y, z = normal.z;
|
||
|
|
vec3 result = shCoefficients[ 0 ] * 0.886227;
|
||
|
|
result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;
|
||
|
|
result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
|
||
|
|
result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
|
||
|
|
result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;
|
||
|
|
result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;
|
||
|
|
result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );
|
||
|
|
result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;
|
||
|
|
result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
vec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in GeometricContext geometry ) {
|
||
|
|
vec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );
|
||
|
|
vec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );
|
||
|
|
return irradiance;
|
||
|
|
}
|
||
|
|
vec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {
|
||
|
|
vec3 irradiance = ambientLightColor;
|
||
|
|
#ifndef PHYSICALLY_CORRECT_LIGHTS
|
||
|
|
irradiance *= PI;
|
||
|
|
#endif
|
||
|
|
return irradiance;
|
||
|
|
}
|
||
|
|
#if NUM_DIR_LIGHTS > 0
|
||
|
|
struct DirectionalLight {
|
||
|
|
vec3 direction;
|
||
|
|
vec3 color;
|
||
|
|
};
|
||
|
|
uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];
|
||
|
|
void getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {
|
||
|
|
directLight.color = directionalLight.color;
|
||
|
|
directLight.direction = directionalLight.direction;
|
||
|
|
directLight.visible = true;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
#if NUM_POINT_LIGHTS > 0
|
||
|
|
struct PointLight {
|
||
|
|
vec3 position;
|
||
|
|
vec3 color;
|
||
|
|
float distance;
|
||
|
|
float decay;
|
||
|
|
};
|
||
|
|
uniform PointLight pointLights[ NUM_POINT_LIGHTS ];
|
||
|
|
void getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {
|
||
|
|
vec3 lVector = pointLight.position - geometry.position;
|
||
|
|
directLight.direction = normalize( lVector );
|
||
|
|
float lightDistance = length( lVector );
|
||
|
|
directLight.color = pointLight.color;
|
||
|
|
directLight.color *= punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );
|
||
|
|
directLight.visible = ( directLight.color != vec3( 0.0 ) );
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
#if NUM_SPOT_LIGHTS > 0
|
||
|
|
struct SpotLight {
|
||
|
|
vec3 position;
|
||
|
|
vec3 direction;
|
||
|
|
vec3 color;
|
||
|
|
float distance;
|
||
|
|
float decay;
|
||
|
|
float coneCos;
|
||
|
|
float penumbraCos;
|
||
|
|
};
|
||
|
|
uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];
|
||
|
|
void getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight ) {
|
||
|
|
vec3 lVector = spotLight.position - geometry.position;
|
||
|
|
directLight.direction = normalize( lVector );
|
||
|
|
float lightDistance = length( lVector );
|
||
|
|
float angleCos = dot( directLight.direction, spotLight.direction );
|
||
|
|
if ( angleCos > spotLight.coneCos ) {
|
||
|
|
float spotEffect = smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );
|
||
|
|
directLight.color = spotLight.color;
|
||
|
|
directLight.color *= spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );
|
||
|
|
directLight.visible = true;
|
||
|
|
} else {
|
||
|
|
directLight.color = vec3( 0.0 );
|
||
|
|
directLight.visible = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
#if NUM_RECT_AREA_LIGHTS > 0
|
||
|
|
struct RectAreaLight {
|
||
|
|
vec3 color;
|
||
|
|
vec3 position;
|
||
|
|
vec3 halfWidth;
|
||
|
|
vec3 halfHeight;
|
||
|
|
};
|
||
|
|
uniform sampler2D ltc_1; uniform sampler2D ltc_2;
|
||
|
|
uniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];
|
||
|
|
#endif
|
||
|
|
#if NUM_HEMI_LIGHTS > 0
|
||
|
|
struct HemisphereLight {
|
||
|
|
vec3 direction;
|
||
|
|
vec3 skyColor;
|
||
|
|
vec3 groundColor;
|
||
|
|
};
|
||
|
|
uniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];
|
||
|
|
vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in GeometricContext geometry ) {
|
||
|
|
float dotNL = dot( geometry.normal, hemiLight.direction );
|
||
|
|
float hemiDiffuseWeight = 0.5 * dotNL + 0.5;
|
||
|
|
vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
|
||
|
|
#ifndef PHYSICALLY_CORRECT_LIGHTS
|
||
|
|
irradiance *= PI;
|
||
|
|
#endif
|
||
|
|
return irradiance;
|
||
|
|
}
|
||
|
|
#endif`,iT=`#if defined( USE_ENVMAP )
|
||
|
|
#ifdef ENVMAP_MODE_REFRACTION
|
||
|
|
uniform float refractionRatio;
|
||
|
|
#endif
|
||
|
|
vec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {
|
||
|
|
vec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );
|
||
|
|
#ifdef ENVMAP_TYPE_CUBE
|
||
|
|
vec3 queryVec = vec3( flipEnvMap * worldNormal.x, worldNormal.yz );
|
||
|
|
#ifdef TEXTURE_LOD_EXT
|
||
|
|
vec4 envMapColor = textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );
|
||
|
|
#else
|
||
|
|
vec4 envMapColor = textureCube( envMap, queryVec, float( maxMIPLevel ) );
|
||
|
|
#endif
|
||
|
|
envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;
|
||
|
|
#elif defined( ENVMAP_TYPE_CUBE_UV )
|
||
|
|
vec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );
|
||
|
|
#else
|
||
|
|
vec4 envMapColor = vec4( 0.0 );
|
||
|
|
#endif
|
||
|
|
return PI * envMapColor.rgb * envMapIntensity;
|
||
|
|
}
|
||
|
|
float getSpecularMIPLevel( const in float roughness, const in int maxMIPLevel ) {
|
||
|
|
float maxMIPLevelScalar = float( maxMIPLevel );
|
||
|
|
float sigma = PI * roughness * roughness / ( 1.0 + roughness );
|
||
|
|
float desiredMIPLevel = maxMIPLevelScalar + log2( sigma );
|
||
|
|
return clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );
|
||
|
|
}
|
||
|
|
vec3 getLightProbeIndirectRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in int maxMIPLevel ) {
|
||
|
|
#ifdef ENVMAP_MODE_REFLECTION
|
||
|
|
vec3 reflectVec = reflect( -viewDir, normal );
|
||
|
|
reflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );
|
||
|
|
#else
|
||
|
|
vec3 reflectVec = refract( -viewDir, normal, refractionRatio );
|
||
|
|
#endif
|
||
|
|
reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
|
||
|
|
float specularMIPLevel = getSpecularMIPLevel( roughness, maxMIPLevel );
|
||
|
|
#ifdef ENVMAP_TYPE_CUBE
|
||
|
|
vec3 queryReflectVec = vec3( flipEnvMap * reflectVec.x, reflectVec.yz );
|
||
|
|
#ifdef TEXTURE_LOD_EXT
|
||
|
|
vec4 envMapColor = textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );
|
||
|
|
#else
|
||
|
|
vec4 envMapColor = textureCube( envMap, queryReflectVec, specularMIPLevel );
|
||
|
|
#endif
|
||
|
|
envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;
|
||
|
|
#elif defined( ENVMAP_TYPE_CUBE_UV )
|
||
|
|
vec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );
|
||
|
|
#endif
|
||
|
|
return envMapColor.rgb * envMapIntensity;
|
||
|
|
}
|
||
|
|
#endif`,rT=`ToonMaterial material;
|
||
|
|
material.diffuseColor = diffuseColor.rgb;`,sT=`varying vec3 vViewPosition;
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
varying vec3 vNormal;
|
||
|
|
#endif
|
||
|
|
struct ToonMaterial {
|
||
|
|
vec3 diffuseColor;
|
||
|
|
};
|
||
|
|
void RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
|
||
|
|
vec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;
|
||
|
|
#ifndef PHYSICALLY_CORRECT_LIGHTS
|
||
|
|
irradiance *= PI;
|
||
|
|
#endif
|
||
|
|
reflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );
|
||
|
|
}
|
||
|
|
void RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
|
||
|
|
reflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );
|
||
|
|
}
|
||
|
|
#define RE_Direct RE_Direct_Toon
|
||
|
|
#define RE_IndirectDiffuse RE_IndirectDiffuse_Toon
|
||
|
|
#define Material_LightProbeLOD( material ) (0)`,oT=`BlinnPhongMaterial material;
|
||
|
|
material.diffuseColor = diffuseColor.rgb;
|
||
|
|
material.specularColor = specular;
|
||
|
|
material.specularShininess = shininess;
|
||
|
|
material.specularStrength = specularStrength;`,aT=`varying vec3 vViewPosition;
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
varying vec3 vNormal;
|
||
|
|
#endif
|
||
|
|
struct BlinnPhongMaterial {
|
||
|
|
vec3 diffuseColor;
|
||
|
|
vec3 specularColor;
|
||
|
|
float specularShininess;
|
||
|
|
float specularStrength;
|
||
|
|
};
|
||
|
|
void RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
|
||
|
|
float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
|
||
|
|
vec3 irradiance = dotNL * directLight.color;
|
||
|
|
#ifndef PHYSICALLY_CORRECT_LIGHTS
|
||
|
|
irradiance *= PI;
|
||
|
|
#endif
|
||
|
|
reflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );
|
||
|
|
reflectedLight.directSpecular += irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess ) * material.specularStrength;
|
||
|
|
}
|
||
|
|
void RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
|
||
|
|
reflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );
|
||
|
|
}
|
||
|
|
#define RE_Direct RE_Direct_BlinnPhong
|
||
|
|
#define RE_IndirectDiffuse RE_IndirectDiffuse_BlinnPhong
|
||
|
|
#define Material_LightProbeLOD( material ) (0)`,lT=`PhysicalMaterial material;
|
||
|
|
material.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );
|
||
|
|
vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );
|
||
|
|
float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );
|
||
|
|
material.specularRoughness = max( roughnessFactor, 0.0525 );material.specularRoughness += geometryRoughness;
|
||
|
|
material.specularRoughness = min( material.specularRoughness, 1.0 );
|
||
|
|
#ifdef REFLECTIVITY
|
||
|
|
#ifdef SPECULAR
|
||
|
|
vec3 specularIntensityFactor = vec3( specularIntensity );
|
||
|
|
vec3 specularTintFactor = specularTint;
|
||
|
|
#ifdef USE_SPECULARINTENSITYMAP
|
||
|
|
specularIntensityFactor *= texture2D( specularIntensityMap, vUv ).a;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_SPECULARTINTMAP
|
||
|
|
specularTintFactor *= specularTintMapTexelToLinear( texture2D( specularTintMap, vUv ) ).rgb;
|
||
|
|
#endif
|
||
|
|
material.specularColorF90 = mix( specularIntensityFactor, vec3( 1.0 ), metalnessFactor );
|
||
|
|
#else
|
||
|
|
vec3 specularIntensityFactor = vec3( 1.0 );
|
||
|
|
vec3 specularTintFactor = vec3( 1.0 );
|
||
|
|
material.specularColorF90 = vec3( 1.0 );
|
||
|
|
#endif
|
||
|
|
material.specularColor = mix( min( vec3( MAXIMUM_SPECULAR_COEFFICIENT * pow2( reflectivity ) ) * specularTintFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );
|
||
|
|
#else
|
||
|
|
material.specularColor = mix( vec3( DEFAULT_SPECULAR_COEFFICIENT ), diffuseColor.rgb, metalnessFactor );
|
||
|
|
material.specularColorF90 = vec3( 1.0 );
|
||
|
|
#endif
|
||
|
|
#ifdef CLEARCOAT
|
||
|
|
material.clearcoat = clearcoat;
|
||
|
|
material.clearcoatRoughness = clearcoatRoughness;
|
||
|
|
#ifdef USE_CLEARCOATMAP
|
||
|
|
material.clearcoat *= texture2D( clearcoatMap, vUv ).x;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_CLEARCOAT_ROUGHNESSMAP
|
||
|
|
material.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;
|
||
|
|
#endif
|
||
|
|
material.clearcoat = saturate( material.clearcoat ); material.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );
|
||
|
|
material.clearcoatRoughness += geometryRoughness;
|
||
|
|
material.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );
|
||
|
|
#endif
|
||
|
|
#ifdef USE_SHEEN
|
||
|
|
material.sheenColor = sheen;
|
||
|
|
#endif`,cT=`struct PhysicalMaterial {
|
||
|
|
vec3 diffuseColor;
|
||
|
|
float specularRoughness;
|
||
|
|
vec3 specularColor;
|
||
|
|
vec3 specularColorF90;
|
||
|
|
#ifdef CLEARCOAT
|
||
|
|
float clearcoat;
|
||
|
|
float clearcoatRoughness;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_SHEEN
|
||
|
|
vec3 sheenColor;
|
||
|
|
#endif
|
||
|
|
};
|
||
|
|
#define MAXIMUM_SPECULAR_COEFFICIENT 0.16
|
||
|
|
#define DEFAULT_SPECULAR_COEFFICIENT 0.04
|
||
|
|
float clearcoatDHRApprox( const in float roughness, const in float dotNL ) {
|
||
|
|
return DEFAULT_SPECULAR_COEFFICIENT + ( 1.0 - DEFAULT_SPECULAR_COEFFICIENT ) * ( pow( 1.0 - dotNL, 5.0 ) * pow( 1.0 - roughness, 2.0 ) );
|
||
|
|
}
|
||
|
|
#if NUM_RECT_AREA_LIGHTS > 0
|
||
|
|
void RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
|
||
|
|
vec3 normal = geometry.normal;
|
||
|
|
vec3 viewDir = geometry.viewDir;
|
||
|
|
vec3 position = geometry.position;
|
||
|
|
vec3 lightPos = rectAreaLight.position;
|
||
|
|
vec3 halfWidth = rectAreaLight.halfWidth;
|
||
|
|
vec3 halfHeight = rectAreaLight.halfHeight;
|
||
|
|
vec3 lightColor = rectAreaLight.color;
|
||
|
|
float roughness = material.specularRoughness;
|
||
|
|
vec3 rectCoords[ 4 ];
|
||
|
|
rectCoords[ 0 ] = lightPos + halfWidth - halfHeight; rectCoords[ 1 ] = lightPos - halfWidth - halfHeight;
|
||
|
|
rectCoords[ 2 ] = lightPos - halfWidth + halfHeight;
|
||
|
|
rectCoords[ 3 ] = lightPos + halfWidth + halfHeight;
|
||
|
|
vec2 uv = LTC_Uv( normal, viewDir, roughness );
|
||
|
|
vec4 t1 = texture2D( ltc_1, uv );
|
||
|
|
vec4 t2 = texture2D( ltc_2, uv );
|
||
|
|
mat3 mInv = mat3(
|
||
|
|
vec3( t1.x, 0, t1.y ),
|
||
|
|
vec3( 0, 1, 0 ),
|
||
|
|
vec3( t1.z, 0, t1.w )
|
||
|
|
);
|
||
|
|
vec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );
|
||
|
|
reflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );
|
||
|
|
reflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
void RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
|
||
|
|
float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
|
||
|
|
vec3 irradiance = dotNL * directLight.color;
|
||
|
|
#ifndef PHYSICALLY_CORRECT_LIGHTS
|
||
|
|
irradiance *= PI;
|
||
|
|
#endif
|
||
|
|
#ifdef CLEARCOAT
|
||
|
|
float ccDotNL = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );
|
||
|
|
vec3 ccIrradiance = ccDotNL * directLight.color;
|
||
|
|
#ifndef PHYSICALLY_CORRECT_LIGHTS
|
||
|
|
ccIrradiance *= PI;
|
||
|
|
#endif
|
||
|
|
float clearcoatDHR = material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );
|
||
|
|
reflectedLight.directSpecular += ccIrradiance * material.clearcoat * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), vec3( 1.0 ), material.clearcoatRoughness );
|
||
|
|
#else
|
||
|
|
float clearcoatDHR = 0.0;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_SHEEN
|
||
|
|
reflectedLight.directSpecular += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_Sheen(
|
||
|
|
material.specularRoughness,
|
||
|
|
directLight.direction,
|
||
|
|
geometry,
|
||
|
|
material.sheenColor
|
||
|
|
);
|
||
|
|
#else
|
||
|
|
reflectedLight.directSpecular += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.normal, material.specularColor, material.specularColorF90, material.specularRoughness);
|
||
|
|
#endif
|
||
|
|
reflectedLight.directDiffuse += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );
|
||
|
|
}
|
||
|
|
void RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
|
||
|
|
reflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );
|
||
|
|
}
|
||
|
|
void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
|
||
|
|
#ifdef CLEARCOAT
|
||
|
|
float ccDotNV = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );
|
||
|
|
reflectedLight.indirectSpecular += clearcoatRadiance * material.clearcoat * BRDF_Specular_GGX_Environment( geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );
|
||
|
|
float ccDotNL = ccDotNV;
|
||
|
|
float clearcoatDHR = material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );
|
||
|
|
#else
|
||
|
|
float clearcoatDHR = 0.0;
|
||
|
|
#endif
|
||
|
|
float clearcoatInv = 1.0 - clearcoatDHR;
|
||
|
|
vec3 singleScattering = vec3( 0.0 );
|
||
|
|
vec3 multiScattering = vec3( 0.0 );
|
||
|
|
vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
|
||
|
|
BRDF_Specular_Multiscattering_Environment( geometry, material.specularColor, material.specularRoughness, singleScattering, multiScattering );
|
||
|
|
vec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );
|
||
|
|
reflectedLight.indirectSpecular += clearcoatInv * radiance * singleScattering;
|
||
|
|
reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;
|
||
|
|
reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;
|
||
|
|
}
|
||
|
|
#define RE_Direct RE_Direct_Physical
|
||
|
|
#define RE_Direct_RectArea RE_Direct_RectArea_Physical
|
||
|
|
#define RE_IndirectDiffuse RE_IndirectDiffuse_Physical
|
||
|
|
#define RE_IndirectSpecular RE_IndirectSpecular_Physical
|
||
|
|
float computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {
|
||
|
|
return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );
|
||
|
|
}`,uT=`
|
||
|
|
GeometricContext geometry;
|
||
|
|
geometry.position = - vViewPosition;
|
||
|
|
geometry.normal = normal;
|
||
|
|
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );
|
||
|
|
#ifdef CLEARCOAT
|
||
|
|
geometry.clearcoatNormal = clearcoatNormal;
|
||
|
|
#endif
|
||
|
|
IncidentLight directLight;
|
||
|
|
#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )
|
||
|
|
PointLight pointLight;
|
||
|
|
#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0
|
||
|
|
PointLightShadow pointLightShadow;
|
||
|
|
#endif
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
|
||
|
|
pointLight = pointLights[ i ];
|
||
|
|
getPointDirectLightIrradiance( pointLight, geometry, directLight );
|
||
|
|
#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )
|
||
|
|
pointLightShadow = pointLightShadows[ i ];
|
||
|
|
directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
|
||
|
|
#endif
|
||
|
|
RE_Direct( directLight, geometry, material, reflectedLight );
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )
|
||
|
|
SpotLight spotLight;
|
||
|
|
#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0
|
||
|
|
SpotLightShadow spotLightShadow;
|
||
|
|
#endif
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
|
||
|
|
spotLight = spotLights[ i ];
|
||
|
|
getSpotDirectLightIrradiance( spotLight, geometry, directLight );
|
||
|
|
#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
|
||
|
|
spotLightShadow = spotLightShadows[ i ];
|
||
|
|
directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
|
||
|
|
#endif
|
||
|
|
RE_Direct( directLight, geometry, material, reflectedLight );
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )
|
||
|
|
DirectionalLight directionalLight;
|
||
|
|
#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0
|
||
|
|
DirectionalLightShadow directionalLightShadow;
|
||
|
|
#endif
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
|
||
|
|
directionalLight = directionalLights[ i ];
|
||
|
|
getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );
|
||
|
|
#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
|
||
|
|
directionalLightShadow = directionalLightShadows[ i ];
|
||
|
|
directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
|
||
|
|
#endif
|
||
|
|
RE_Direct( directLight, geometry, material, reflectedLight );
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )
|
||
|
|
RectAreaLight rectAreaLight;
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {
|
||
|
|
rectAreaLight = rectAreaLights[ i ];
|
||
|
|
RE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#if defined( RE_IndirectDiffuse )
|
||
|
|
vec3 iblIrradiance = vec3( 0.0 );
|
||
|
|
vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );
|
||
|
|
irradiance += getLightProbeIrradiance( lightProbe, geometry );
|
||
|
|
#if ( NUM_HEMI_LIGHTS > 0 )
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
|
||
|
|
irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#if defined( RE_IndirectSpecular )
|
||
|
|
vec3 radiance = vec3( 0.0 );
|
||
|
|
vec3 clearcoatRadiance = vec3( 0.0 );
|
||
|
|
#endif`,hT=`#if defined( RE_IndirectDiffuse )
|
||
|
|
#ifdef USE_LIGHTMAP
|
||
|
|
vec4 lightMapTexel= texture2D( lightMap, vUv2 );
|
||
|
|
vec3 lightMapIrradiance = lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;
|
||
|
|
#ifndef PHYSICALLY_CORRECT_LIGHTS
|
||
|
|
lightMapIrradiance *= PI;
|
||
|
|
#endif
|
||
|
|
irradiance += lightMapIrradiance;
|
||
|
|
#endif
|
||
|
|
#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )
|
||
|
|
iblIrradiance += getLightProbeIndirectIrradiance( geometry, maxMipLevel );
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )
|
||
|
|
radiance += getLightProbeIndirectRadiance( geometry.viewDir, geometry.normal, material.specularRoughness, maxMipLevel );
|
||
|
|
#ifdef CLEARCOAT
|
||
|
|
clearcoatRadiance += getLightProbeIndirectRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness, maxMipLevel );
|
||
|
|
#endif
|
||
|
|
#endif`,dT=`#if defined( RE_IndirectDiffuse )
|
||
|
|
RE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );
|
||
|
|
#endif
|
||
|
|
#if defined( RE_IndirectSpecular )
|
||
|
|
RE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );
|
||
|
|
#endif`,fT=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
|
||
|
|
gl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;
|
||
|
|
#endif`,pT=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
|
||
|
|
uniform float logDepthBufFC;
|
||
|
|
varying float vFragDepth;
|
||
|
|
varying float vIsPerspective;
|
||
|
|
#endif`,mT=`#ifdef USE_LOGDEPTHBUF
|
||
|
|
#ifdef USE_LOGDEPTHBUF_EXT
|
||
|
|
varying float vFragDepth;
|
||
|
|
varying float vIsPerspective;
|
||
|
|
#else
|
||
|
|
uniform float logDepthBufFC;
|
||
|
|
#endif
|
||
|
|
#endif`,gT=`#ifdef USE_LOGDEPTHBUF
|
||
|
|
#ifdef USE_LOGDEPTHBUF_EXT
|
||
|
|
vFragDepth = 1.0 + gl_Position.w;
|
||
|
|
vIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );
|
||
|
|
#else
|
||
|
|
if ( isPerspectiveMatrix( projectionMatrix ) ) {
|
||
|
|
gl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;
|
||
|
|
gl_Position.z *= gl_Position.w;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
#endif`,yT=`#ifdef USE_MAP
|
||
|
|
vec4 texelColor = texture2D( map, vUv );
|
||
|
|
texelColor = mapTexelToLinear( texelColor );
|
||
|
|
diffuseColor *= texelColor;
|
||
|
|
#endif`,vT=`#ifdef USE_MAP
|
||
|
|
uniform sampler2D map;
|
||
|
|
#endif`,xT=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
|
||
|
|
vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_MAP
|
||
|
|
vec4 mapTexel = texture2D( map, uv );
|
||
|
|
diffuseColor *= mapTexelToLinear( mapTexel );
|
||
|
|
#endif
|
||
|
|
#ifdef USE_ALPHAMAP
|
||
|
|
diffuseColor.a *= texture2D( alphaMap, uv ).g;
|
||
|
|
#endif`,bT=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
|
||
|
|
uniform mat3 uvTransform;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_MAP
|
||
|
|
uniform sampler2D map;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_ALPHAMAP
|
||
|
|
uniform sampler2D alphaMap;
|
||
|
|
#endif`,wT=`float metalnessFactor = metalness;
|
||
|
|
#ifdef USE_METALNESSMAP
|
||
|
|
vec4 texelMetalness = texture2D( metalnessMap, vUv );
|
||
|
|
metalnessFactor *= texelMetalness.b;
|
||
|
|
#endif`,ST=`#ifdef USE_METALNESSMAP
|
||
|
|
uniform sampler2D metalnessMap;
|
||
|
|
#endif`,MT=`#ifdef USE_MORPHNORMALS
|
||
|
|
objectNormal *= morphTargetBaseInfluence;
|
||
|
|
objectNormal += morphNormal0 * morphTargetInfluences[ 0 ];
|
||
|
|
objectNormal += morphNormal1 * morphTargetInfluences[ 1 ];
|
||
|
|
objectNormal += morphNormal2 * morphTargetInfluences[ 2 ];
|
||
|
|
objectNormal += morphNormal3 * morphTargetInfluences[ 3 ];
|
||
|
|
#endif`,AT=`#ifdef USE_MORPHTARGETS
|
||
|
|
uniform float morphTargetBaseInfluence;
|
||
|
|
#ifndef USE_MORPHNORMALS
|
||
|
|
uniform float morphTargetInfluences[ 8 ];
|
||
|
|
#else
|
||
|
|
uniform float morphTargetInfluences[ 4 ];
|
||
|
|
#endif
|
||
|
|
#endif`,_T=`#ifdef USE_MORPHTARGETS
|
||
|
|
transformed *= morphTargetBaseInfluence;
|
||
|
|
transformed += morphTarget0 * morphTargetInfluences[ 0 ];
|
||
|
|
transformed += morphTarget1 * morphTargetInfluences[ 1 ];
|
||
|
|
transformed += morphTarget2 * morphTargetInfluences[ 2 ];
|
||
|
|
transformed += morphTarget3 * morphTargetInfluences[ 3 ];
|
||
|
|
#ifndef USE_MORPHNORMALS
|
||
|
|
transformed += morphTarget4 * morphTargetInfluences[ 4 ];
|
||
|
|
transformed += morphTarget5 * morphTargetInfluences[ 5 ];
|
||
|
|
transformed += morphTarget6 * morphTargetInfluences[ 6 ];
|
||
|
|
transformed += morphTarget7 * morphTargetInfluences[ 7 ];
|
||
|
|
#endif
|
||
|
|
#endif`,TT=`float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;
|
||
|
|
#ifdef FLAT_SHADED
|
||
|
|
vec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );
|
||
|
|
vec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );
|
||
|
|
vec3 normal = normalize( cross( fdx, fdy ) );
|
||
|
|
#else
|
||
|
|
vec3 normal = normalize( vNormal );
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
normal = normal * faceDirection;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
vec3 tangent = normalize( vTangent );
|
||
|
|
vec3 bitangent = normalize( vBitangent );
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
tangent = tangent * faceDirection;
|
||
|
|
bitangent = bitangent * faceDirection;
|
||
|
|
#endif
|
||
|
|
#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )
|
||
|
|
mat3 vTBN = mat3( tangent, bitangent, normal );
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
vec3 geometryNormal = normal;`,ET=`#ifdef OBJECTSPACE_NORMALMAP
|
||
|
|
normal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
|
||
|
|
#ifdef FLIP_SIDED
|
||
|
|
normal = - normal;
|
||
|
|
#endif
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
normal = normal * faceDirection;
|
||
|
|
#endif
|
||
|
|
normal = normalize( normalMatrix * normal );
|
||
|
|
#elif defined( TANGENTSPACE_NORMALMAP )
|
||
|
|
vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
|
||
|
|
mapN.xy *= normalScale;
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
normal = normalize( vTBN * mapN );
|
||
|
|
#else
|
||
|
|
normal = perturbNormal2Arb( -vViewPosition, normal, mapN, faceDirection );
|
||
|
|
#endif
|
||
|
|
#elif defined( USE_BUMPMAP )
|
||
|
|
normal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd(), faceDirection );
|
||
|
|
#endif`,NT=`#ifdef USE_NORMALMAP
|
||
|
|
uniform sampler2D normalMap;
|
||
|
|
uniform vec2 normalScale;
|
||
|
|
#endif
|
||
|
|
#ifdef OBJECTSPACE_NORMALMAP
|
||
|
|
uniform mat3 normalMatrix;
|
||
|
|
#endif
|
||
|
|
#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )
|
||
|
|
vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {
|
||
|
|
vec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );
|
||
|
|
vec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );
|
||
|
|
vec2 st0 = dFdx( vUv.st );
|
||
|
|
vec2 st1 = dFdy( vUv.st );
|
||
|
|
vec3 N = surf_norm;
|
||
|
|
vec3 q1perp = cross( q1, N );
|
||
|
|
vec3 q0perp = cross( N, q0 );
|
||
|
|
vec3 T = q1perp * st0.x + q0perp * st1.x;
|
||
|
|
vec3 B = q1perp * st0.y + q0perp * st1.y;
|
||
|
|
float det = max( dot( T, T ), dot( B, B ) );
|
||
|
|
float scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );
|
||
|
|
return normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );
|
||
|
|
}
|
||
|
|
#endif`,CT=`#ifdef CLEARCOAT
|
||
|
|
vec3 clearcoatNormal = geometryNormal;
|
||
|
|
#endif`,LT=`#ifdef USE_CLEARCOAT_NORMALMAP
|
||
|
|
vec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;
|
||
|
|
clearcoatMapN.xy *= clearcoatNormalScale;
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
clearcoatNormal = normalize( vTBN * clearcoatMapN );
|
||
|
|
#else
|
||
|
|
clearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN, faceDirection );
|
||
|
|
#endif
|
||
|
|
#endif`,IT=`#ifdef USE_CLEARCOATMAP
|
||
|
|
uniform sampler2D clearcoatMap;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_CLEARCOAT_ROUGHNESSMAP
|
||
|
|
uniform sampler2D clearcoatRoughnessMap;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_CLEARCOAT_NORMALMAP
|
||
|
|
uniform sampler2D clearcoatNormalMap;
|
||
|
|
uniform vec2 clearcoatNormalScale;
|
||
|
|
#endif`,PT=`vec3 packNormalToRGB( const in vec3 normal ) {
|
||
|
|
return normalize( normal ) * 0.5 + 0.5;
|
||
|
|
}
|
||
|
|
vec3 unpackRGBToNormal( const in vec3 rgb ) {
|
||
|
|
return 2.0 * rgb.xyz - 1.0;
|
||
|
|
}
|
||
|
|
const float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;
|
||
|
|
const vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );
|
||
|
|
const vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );
|
||
|
|
const float ShiftRight8 = 1. / 256.;
|
||
|
|
vec4 packDepthToRGBA( const in float v ) {
|
||
|
|
vec4 r = vec4( fract( v * PackFactors ), v );
|
||
|
|
r.yzw -= r.xyz * ShiftRight8; return r * PackUpscale;
|
||
|
|
}
|
||
|
|
float unpackRGBAToDepth( const in vec4 v ) {
|
||
|
|
return dot( v, UnpackFactors );
|
||
|
|
}
|
||
|
|
vec4 pack2HalfToRGBA( vec2 v ) {
|
||
|
|
vec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ));
|
||
|
|
return vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w);
|
||
|
|
}
|
||
|
|
vec2 unpackRGBATo2Half( vec4 v ) {
|
||
|
|
return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
|
||
|
|
}
|
||
|
|
float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
|
||
|
|
return ( viewZ + near ) / ( near - far );
|
||
|
|
}
|
||
|
|
float orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {
|
||
|
|
return linearClipZ * ( near - far ) - near;
|
||
|
|
}
|
||
|
|
float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
|
||
|
|
return (( near + viewZ ) * far ) / (( far - near ) * viewZ );
|
||
|
|
}
|
||
|
|
float perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {
|
||
|
|
return ( near * far ) / ( ( far - near ) * invClipZ - far );
|
||
|
|
}`,DT=`#ifdef PREMULTIPLIED_ALPHA
|
||
|
|
gl_FragColor.rgb *= gl_FragColor.a;
|
||
|
|
#endif`,RT=`vec4 mvPosition = vec4( transformed, 1.0 );
|
||
|
|
#ifdef USE_INSTANCING
|
||
|
|
mvPosition = instanceMatrix * mvPosition;
|
||
|
|
#endif
|
||
|
|
mvPosition = modelViewMatrix * mvPosition;
|
||
|
|
gl_Position = projectionMatrix * mvPosition;`,BT=`#ifdef DITHERING
|
||
|
|
gl_FragColor.rgb = dithering( gl_FragColor.rgb );
|
||
|
|
#endif`,OT=`#ifdef DITHERING
|
||
|
|
vec3 dithering( vec3 color ) {
|
||
|
|
float grid_position = rand( gl_FragCoord.xy );
|
||
|
|
vec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );
|
||
|
|
dither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );
|
||
|
|
return color + dither_shift_RGB;
|
||
|
|
}
|
||
|
|
#endif`,FT=`float roughnessFactor = roughness;
|
||
|
|
#ifdef USE_ROUGHNESSMAP
|
||
|
|
vec4 texelRoughness = texture2D( roughnessMap, vUv );
|
||
|
|
roughnessFactor *= texelRoughness.g;
|
||
|
|
#endif`,zT=`#ifdef USE_ROUGHNESSMAP
|
||
|
|
uniform sampler2D roughnessMap;
|
||
|
|
#endif`,GT=`#ifdef USE_SHADOWMAP
|
||
|
|
#if NUM_DIR_LIGHT_SHADOWS > 0
|
||
|
|
uniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];
|
||
|
|
varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
|
||
|
|
struct DirectionalLightShadow {
|
||
|
|
float shadowBias;
|
||
|
|
float shadowNormalBias;
|
||
|
|
float shadowRadius;
|
||
|
|
vec2 shadowMapSize;
|
||
|
|
};
|
||
|
|
uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
|
||
|
|
#endif
|
||
|
|
#if NUM_SPOT_LIGHT_SHADOWS > 0
|
||
|
|
uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];
|
||
|
|
varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
|
||
|
|
struct SpotLightShadow {
|
||
|
|
float shadowBias;
|
||
|
|
float shadowNormalBias;
|
||
|
|
float shadowRadius;
|
||
|
|
vec2 shadowMapSize;
|
||
|
|
};
|
||
|
|
uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
|
||
|
|
#endif
|
||
|
|
#if NUM_POINT_LIGHT_SHADOWS > 0
|
||
|
|
uniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];
|
||
|
|
varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
|
||
|
|
struct PointLightShadow {
|
||
|
|
float shadowBias;
|
||
|
|
float shadowNormalBias;
|
||
|
|
float shadowRadius;
|
||
|
|
vec2 shadowMapSize;
|
||
|
|
float shadowCameraNear;
|
||
|
|
float shadowCameraFar;
|
||
|
|
};
|
||
|
|
uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
|
||
|
|
#endif
|
||
|
|
float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {
|
||
|
|
return step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );
|
||
|
|
}
|
||
|
|
vec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {
|
||
|
|
return unpackRGBATo2Half( texture2D( shadow, uv ) );
|
||
|
|
}
|
||
|
|
float VSMShadow (sampler2D shadow, vec2 uv, float compare ){
|
||
|
|
float occlusion = 1.0;
|
||
|
|
vec2 distribution = texture2DDistribution( shadow, uv );
|
||
|
|
float hard_shadow = step( compare , distribution.x );
|
||
|
|
if (hard_shadow != 1.0 ) {
|
||
|
|
float distance = compare - distribution.x ;
|
||
|
|
float variance = max( 0.00000, distribution.y * distribution.y );
|
||
|
|
float softness_probability = variance / (variance + distance * distance ); softness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 ); occlusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );
|
||
|
|
}
|
||
|
|
return occlusion;
|
||
|
|
}
|
||
|
|
float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
|
||
|
|
float shadow = 1.0;
|
||
|
|
shadowCoord.xyz /= shadowCoord.w;
|
||
|
|
shadowCoord.z += shadowBias;
|
||
|
|
bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );
|
||
|
|
bool inFrustum = all( inFrustumVec );
|
||
|
|
bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );
|
||
|
|
bool frustumTest = all( frustumTestVec );
|
||
|
|
if ( frustumTest ) {
|
||
|
|
#if defined( SHADOWMAP_TYPE_PCF )
|
||
|
|
vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
|
||
|
|
float dx0 = - texelSize.x * shadowRadius;
|
||
|
|
float dy0 = - texelSize.y * shadowRadius;
|
||
|
|
float dx1 = + texelSize.x * shadowRadius;
|
||
|
|
float dy1 = + texelSize.y * shadowRadius;
|
||
|
|
float dx2 = dx0 / 2.0;
|
||
|
|
float dy2 = dy0 / 2.0;
|
||
|
|
float dx3 = dx1 / 2.0;
|
||
|
|
float dy3 = dy1 / 2.0;
|
||
|
|
shadow = (
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )
|
||
|
|
) * ( 1.0 / 17.0 );
|
||
|
|
#elif defined( SHADOWMAP_TYPE_PCF_SOFT )
|
||
|
|
vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
|
||
|
|
float dx = texelSize.x;
|
||
|
|
float dy = texelSize.y;
|
||
|
|
vec2 uv = shadowCoord.xy;
|
||
|
|
vec2 f = fract( uv * shadowMapSize + 0.5 );
|
||
|
|
uv -= f * texelSize;
|
||
|
|
shadow = (
|
||
|
|
texture2DCompare( shadowMap, uv, shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +
|
||
|
|
texture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +
|
||
|
|
mix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ),
|
||
|
|
texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),
|
||
|
|
f.x ) +
|
||
|
|
mix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ),
|
||
|
|
texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),
|
||
|
|
f.x ) +
|
||
|
|
mix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ),
|
||
|
|
texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),
|
||
|
|
f.y ) +
|
||
|
|
mix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ),
|
||
|
|
texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),
|
||
|
|
f.y ) +
|
||
|
|
mix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ),
|
||
|
|
texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),
|
||
|
|
f.x ),
|
||
|
|
mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ),
|
||
|
|
texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),
|
||
|
|
f.x ),
|
||
|
|
f.y )
|
||
|
|
) * ( 1.0 / 9.0 );
|
||
|
|
#elif defined( SHADOWMAP_TYPE_VSM )
|
||
|
|
shadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );
|
||
|
|
#else
|
||
|
|
shadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
return shadow;
|
||
|
|
}
|
||
|
|
vec2 cubeToUV( vec3 v, float texelSizeY ) {
|
||
|
|
vec3 absV = abs( v );
|
||
|
|
float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );
|
||
|
|
absV *= scaleToCube;
|
||
|
|
v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );
|
||
|
|
vec2 planar = v.xy;
|
||
|
|
float almostATexel = 1.5 * texelSizeY;
|
||
|
|
float almostOne = 1.0 - almostATexel;
|
||
|
|
if ( absV.z >= almostOne ) {
|
||
|
|
if ( v.z > 0.0 )
|
||
|
|
planar.x = 4.0 - v.x;
|
||
|
|
} else if ( absV.x >= almostOne ) {
|
||
|
|
float signX = sign( v.x );
|
||
|
|
planar.x = v.z * signX + 2.0 * signX;
|
||
|
|
} else if ( absV.y >= almostOne ) {
|
||
|
|
float signY = sign( v.y );
|
||
|
|
planar.x = v.x + 2.0 * signY + 2.0;
|
||
|
|
planar.y = v.z * signY - 2.0;
|
||
|
|
}
|
||
|
|
return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );
|
||
|
|
}
|
||
|
|
float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {
|
||
|
|
vec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );
|
||
|
|
vec3 lightToPosition = shadowCoord.xyz;
|
||
|
|
float dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear ); dp += shadowBias;
|
||
|
|
vec3 bd3D = normalize( lightToPosition );
|
||
|
|
#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )
|
||
|
|
vec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;
|
||
|
|
return (
|
||
|
|
texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +
|
||
|
|
texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +
|
||
|
|
texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +
|
||
|
|
texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +
|
||
|
|
texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +
|
||
|
|
texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +
|
||
|
|
texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +
|
||
|
|
texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +
|
||
|
|
texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )
|
||
|
|
) * ( 1.0 / 9.0 );
|
||
|
|
#else
|
||
|
|
return texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
#endif`,UT=`#ifdef USE_SHADOWMAP
|
||
|
|
#if NUM_DIR_LIGHT_SHADOWS > 0
|
||
|
|
uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];
|
||
|
|
varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
|
||
|
|
struct DirectionalLightShadow {
|
||
|
|
float shadowBias;
|
||
|
|
float shadowNormalBias;
|
||
|
|
float shadowRadius;
|
||
|
|
vec2 shadowMapSize;
|
||
|
|
};
|
||
|
|
uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
|
||
|
|
#endif
|
||
|
|
#if NUM_SPOT_LIGHT_SHADOWS > 0
|
||
|
|
uniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];
|
||
|
|
varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
|
||
|
|
struct SpotLightShadow {
|
||
|
|
float shadowBias;
|
||
|
|
float shadowNormalBias;
|
||
|
|
float shadowRadius;
|
||
|
|
vec2 shadowMapSize;
|
||
|
|
};
|
||
|
|
uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
|
||
|
|
#endif
|
||
|
|
#if NUM_POINT_LIGHT_SHADOWS > 0
|
||
|
|
uniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];
|
||
|
|
varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
|
||
|
|
struct PointLightShadow {
|
||
|
|
float shadowBias;
|
||
|
|
float shadowNormalBias;
|
||
|
|
float shadowRadius;
|
||
|
|
vec2 shadowMapSize;
|
||
|
|
float shadowCameraNear;
|
||
|
|
float shadowCameraFar;
|
||
|
|
};
|
||
|
|
uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
|
||
|
|
#endif
|
||
|
|
#endif`,kT=`#ifdef USE_SHADOWMAP
|
||
|
|
#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0
|
||
|
|
vec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
|
||
|
|
vec4 shadowWorldPosition;
|
||
|
|
#endif
|
||
|
|
#if NUM_DIR_LIGHT_SHADOWS > 0
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
|
||
|
|
shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );
|
||
|
|
vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#if NUM_SPOT_LIGHT_SHADOWS > 0
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
|
||
|
|
shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );
|
||
|
|
vSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#if NUM_POINT_LIGHT_SHADOWS > 0
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
|
||
|
|
shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );
|
||
|
|
vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#endif`,VT=`float getShadowMask() {
|
||
|
|
float shadow = 1.0;
|
||
|
|
#ifdef USE_SHADOWMAP
|
||
|
|
#if NUM_DIR_LIGHT_SHADOWS > 0
|
||
|
|
DirectionalLightShadow directionalLight;
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
|
||
|
|
directionalLight = directionalLightShadows[ i ];
|
||
|
|
shadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#if NUM_SPOT_LIGHT_SHADOWS > 0
|
||
|
|
SpotLightShadow spotLight;
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
|
||
|
|
spotLight = spotLightShadows[ i ];
|
||
|
|
shadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#if NUM_POINT_LIGHT_SHADOWS > 0
|
||
|
|
PointLightShadow pointLight;
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
|
||
|
|
pointLight = pointLightShadows[ i ];
|
||
|
|
shadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
return shadow;
|
||
|
|
}`,HT=`#ifdef USE_SKINNING
|
||
|
|
mat4 boneMatX = getBoneMatrix( skinIndex.x );
|
||
|
|
mat4 boneMatY = getBoneMatrix( skinIndex.y );
|
||
|
|
mat4 boneMatZ = getBoneMatrix( skinIndex.z );
|
||
|
|
mat4 boneMatW = getBoneMatrix( skinIndex.w );
|
||
|
|
#endif`,jT=`#ifdef USE_SKINNING
|
||
|
|
uniform mat4 bindMatrix;
|
||
|
|
uniform mat4 bindMatrixInverse;
|
||
|
|
#ifdef BONE_TEXTURE
|
||
|
|
uniform highp sampler2D boneTexture;
|
||
|
|
uniform int boneTextureSize;
|
||
|
|
mat4 getBoneMatrix( const in float i ) {
|
||
|
|
float j = i * 4.0;
|
||
|
|
float x = mod( j, float( boneTextureSize ) );
|
||
|
|
float y = floor( j / float( boneTextureSize ) );
|
||
|
|
float dx = 1.0 / float( boneTextureSize );
|
||
|
|
float dy = 1.0 / float( boneTextureSize );
|
||
|
|
y = dy * ( y + 0.5 );
|
||
|
|
vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );
|
||
|
|
vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );
|
||
|
|
vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );
|
||
|
|
vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );
|
||
|
|
mat4 bone = mat4( v1, v2, v3, v4 );
|
||
|
|
return bone;
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
uniform mat4 boneMatrices[ MAX_BONES ];
|
||
|
|
mat4 getBoneMatrix( const in float i ) {
|
||
|
|
mat4 bone = boneMatrices[ int(i) ];
|
||
|
|
return bone;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
#endif`,WT=`#ifdef USE_SKINNING
|
||
|
|
vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );
|
||
|
|
vec4 skinned = vec4( 0.0 );
|
||
|
|
skinned += boneMatX * skinVertex * skinWeight.x;
|
||
|
|
skinned += boneMatY * skinVertex * skinWeight.y;
|
||
|
|
skinned += boneMatZ * skinVertex * skinWeight.z;
|
||
|
|
skinned += boneMatW * skinVertex * skinWeight.w;
|
||
|
|
transformed = ( bindMatrixInverse * skinned ).xyz;
|
||
|
|
#endif`,JT=`#ifdef USE_SKINNING
|
||
|
|
mat4 skinMatrix = mat4( 0.0 );
|
||
|
|
skinMatrix += skinWeight.x * boneMatX;
|
||
|
|
skinMatrix += skinWeight.y * boneMatY;
|
||
|
|
skinMatrix += skinWeight.z * boneMatZ;
|
||
|
|
skinMatrix += skinWeight.w * boneMatW;
|
||
|
|
skinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;
|
||
|
|
objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
objectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;
|
||
|
|
#endif
|
||
|
|
#endif`,XT=`float specularStrength;
|
||
|
|
#ifdef USE_SPECULARMAP
|
||
|
|
vec4 texelSpecular = texture2D( specularMap, vUv );
|
||
|
|
specularStrength = texelSpecular.r;
|
||
|
|
#else
|
||
|
|
specularStrength = 1.0;
|
||
|
|
#endif`,qT=`#ifdef USE_SPECULARMAP
|
||
|
|
uniform sampler2D specularMap;
|
||
|
|
#endif`,YT=`#if defined( TONE_MAPPING )
|
||
|
|
gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
|
||
|
|
#endif`,KT=`#ifndef saturate
|
||
|
|
#define saturate(a) clamp( a, 0.0, 1.0 )
|
||
|
|
#endif
|
||
|
|
uniform float toneMappingExposure;
|
||
|
|
vec3 LinearToneMapping( vec3 color ) {
|
||
|
|
return toneMappingExposure * color;
|
||
|
|
}
|
||
|
|
vec3 ReinhardToneMapping( vec3 color ) {
|
||
|
|
color *= toneMappingExposure;
|
||
|
|
return saturate( color / ( vec3( 1.0 ) + color ) );
|
||
|
|
}
|
||
|
|
vec3 OptimizedCineonToneMapping( vec3 color ) {
|
||
|
|
color *= toneMappingExposure;
|
||
|
|
color = max( vec3( 0.0 ), color - 0.004 );
|
||
|
|
return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );
|
||
|
|
}
|
||
|
|
vec3 RRTAndODTFit( vec3 v ) {
|
||
|
|
vec3 a = v * ( v + 0.0245786 ) - 0.000090537;
|
||
|
|
vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;
|
||
|
|
return a / b;
|
||
|
|
}
|
||
|
|
vec3 ACESFilmicToneMapping( vec3 color ) {
|
||
|
|
const mat3 ACESInputMat = mat3(
|
||
|
|
vec3( 0.59719, 0.07600, 0.02840 ), vec3( 0.35458, 0.90834, 0.13383 ),
|
||
|
|
vec3( 0.04823, 0.01566, 0.83777 )
|
||
|
|
);
|
||
|
|
const mat3 ACESOutputMat = mat3(
|
||
|
|
vec3( 1.60475, -0.10208, -0.00327 ), vec3( -0.53108, 1.10813, -0.07276 ),
|
||
|
|
vec3( -0.07367, -0.00605, 1.07602 )
|
||
|
|
);
|
||
|
|
color *= toneMappingExposure / 0.6;
|
||
|
|
color = ACESInputMat * color;
|
||
|
|
color = RRTAndODTFit( color );
|
||
|
|
color = ACESOutputMat * color;
|
||
|
|
return saturate( color );
|
||
|
|
}
|
||
|
|
vec3 CustomToneMapping( vec3 color ) { return color; }`,QT=`#ifdef USE_TRANSMISSION
|
||
|
|
float transmissionFactor = transmission;
|
||
|
|
float thicknessFactor = thickness;
|
||
|
|
#ifdef USE_TRANSMISSIONMAP
|
||
|
|
transmissionFactor *= texture2D( transmissionMap, vUv ).r;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_THICKNESSMAP
|
||
|
|
thicknessFactor *= texture2D( thicknessMap, vUv ).g;
|
||
|
|
#endif
|
||
|
|
vec3 pos = vWorldPosition.xyz / vWorldPosition.w;
|
||
|
|
vec3 v = normalize( cameraPosition - pos );
|
||
|
|
vec3 n = inverseTransformDirection( normal, viewMatrix );
|
||
|
|
float ior = ( 1.0 + 0.4 * reflectivity ) / ( 1.0 - 0.4 * reflectivity );
|
||
|
|
vec3 transmission = transmissionFactor * getIBLVolumeRefraction(
|
||
|
|
n, v, roughnessFactor, material.diffuseColor, material.specularColor,
|
||
|
|
pos, modelMatrix, viewMatrix, projectionMatrix, ior, thicknessFactor,
|
||
|
|
attenuationTint, attenuationDistance );
|
||
|
|
totalDiffuse = mix( totalDiffuse, transmission, transmissionFactor );
|
||
|
|
#endif`,ZT=`#ifdef USE_TRANSMISSION
|
||
|
|
#ifdef USE_TRANSMISSIONMAP
|
||
|
|
uniform sampler2D transmissionMap;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_THICKNESSMAP
|
||
|
|
uniform sampler2D thicknessMap;
|
||
|
|
#endif
|
||
|
|
uniform vec2 transmissionSamplerSize;
|
||
|
|
uniform sampler2D transmissionSamplerMap;
|
||
|
|
uniform mat4 modelMatrix;
|
||
|
|
uniform mat4 projectionMatrix;
|
||
|
|
varying vec4 vWorldPosition;
|
||
|
|
vec3 getVolumeTransmissionRay(vec3 n, vec3 v, float thickness, float ior, mat4 modelMatrix) {
|
||
|
|
vec3 refractionVector = refract(-v, normalize(n), 1.0 / ior);
|
||
|
|
vec3 modelScale;
|
||
|
|
modelScale.x = length(vec3(modelMatrix[0].xyz));
|
||
|
|
modelScale.y = length(vec3(modelMatrix[1].xyz));
|
||
|
|
modelScale.z = length(vec3(modelMatrix[2].xyz));
|
||
|
|
return normalize(refractionVector) * thickness * modelScale;
|
||
|
|
}
|
||
|
|
float applyIorToRoughness(float roughness, float ior) {
|
||
|
|
return roughness * clamp(ior * 2.0 - 2.0, 0.0, 1.0);
|
||
|
|
}
|
||
|
|
vec3 getTransmissionSample(vec2 fragCoord, float roughness, float ior) {
|
||
|
|
float framebufferLod = log2(transmissionSamplerSize.x) * applyIorToRoughness(roughness, ior);
|
||
|
|
return texture2DLodEXT(transmissionSamplerMap, fragCoord.xy, framebufferLod).rgb;
|
||
|
|
}
|
||
|
|
vec3 applyVolumeAttenuation(vec3 radiance, float transmissionDistance, vec3 attenuationColor, float attenuationDistance) {
|
||
|
|
if (attenuationDistance == 0.0) {
|
||
|
|
return radiance;
|
||
|
|
} else {
|
||
|
|
vec3 attenuationCoefficient = -log(attenuationColor) / attenuationDistance;
|
||
|
|
vec3 transmittance = exp(-attenuationCoefficient * transmissionDistance); return transmittance * radiance;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
vec3 getIBLVolumeRefraction(vec3 n, vec3 v, float perceptualRoughness, vec3 baseColor, vec3 specularColor,
|
||
|
|
vec3 position, mat4 modelMatrix, mat4 viewMatrix, mat4 projMatrix, float ior, float thickness,
|
||
|
|
vec3 attenuationColor, float attenuationDistance) {
|
||
|
|
vec3 transmissionRay = getVolumeTransmissionRay(n, v, thickness, ior, modelMatrix);
|
||
|
|
vec3 refractedRayExit = position + transmissionRay;
|
||
|
|
vec4 ndcPos = projMatrix * viewMatrix * vec4(refractedRayExit, 1.0);
|
||
|
|
vec2 refractionCoords = ndcPos.xy / ndcPos.w;
|
||
|
|
refractionCoords += 1.0;
|
||
|
|
refractionCoords /= 2.0;
|
||
|
|
vec3 transmittedLight = getTransmissionSample(refractionCoords, perceptualRoughness, ior);
|
||
|
|
vec3 attenuatedColor = applyVolumeAttenuation(transmittedLight, length(transmissionRay), attenuationColor, attenuationDistance);
|
||
|
|
return (1.0 - specularColor) * attenuatedColor * baseColor;
|
||
|
|
}
|
||
|
|
#endif`,$T=`#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )
|
||
|
|
varying vec2 vUv;
|
||
|
|
#endif`,eE=`#ifdef USE_UV
|
||
|
|
#ifdef UVS_VERTEX_ONLY
|
||
|
|
vec2 vUv;
|
||
|
|
#else
|
||
|
|
varying vec2 vUv;
|
||
|
|
#endif
|
||
|
|
uniform mat3 uvTransform;
|
||
|
|
#endif`,tE=`#ifdef USE_UV
|
||
|
|
vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
|
||
|
|
#endif`,nE=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
|
||
|
|
varying vec2 vUv2;
|
||
|
|
#endif`,iE=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
|
||
|
|
attribute vec2 uv2;
|
||
|
|
varying vec2 vUv2;
|
||
|
|
uniform mat3 uv2Transform;
|
||
|
|
#endif`,rE=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
|
||
|
|
vUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;
|
||
|
|
#endif`,sE=`#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION )
|
||
|
|
vec4 worldPosition = vec4( transformed, 1.0 );
|
||
|
|
#ifdef USE_INSTANCING
|
||
|
|
worldPosition = instanceMatrix * worldPosition;
|
||
|
|
#endif
|
||
|
|
worldPosition = modelMatrix * worldPosition;
|
||
|
|
#endif`,oE=`uniform sampler2D t2D;
|
||
|
|
varying vec2 vUv;
|
||
|
|
void main() {
|
||
|
|
vec4 texColor = texture2D( t2D, vUv );
|
||
|
|
gl_FragColor = mapTexelToLinear( texColor );
|
||
|
|
#include <tonemapping_fragment>
|
||
|
|
#include <encodings_fragment>
|
||
|
|
}`,aE=`varying vec2 vUv;
|
||
|
|
uniform mat3 uvTransform;
|
||
|
|
void main() {
|
||
|
|
vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
|
||
|
|
gl_Position = vec4( position.xy, 1.0, 1.0 );
|
||
|
|
}`,lE=`#include <envmap_common_pars_fragment>
|
||
|
|
uniform float opacity;
|
||
|
|
varying vec3 vWorldDirection;
|
||
|
|
#include <cube_uv_reflection_fragment>
|
||
|
|
void main() {
|
||
|
|
vec3 vReflect = vWorldDirection;
|
||
|
|
#include <envmap_fragment>
|
||
|
|
gl_FragColor = envColor;
|
||
|
|
gl_FragColor.a *= opacity;
|
||
|
|
#include <tonemapping_fragment>
|
||
|
|
#include <encodings_fragment>
|
||
|
|
}`,cE=`varying vec3 vWorldDirection;
|
||
|
|
#include <common>
|
||
|
|
void main() {
|
||
|
|
vWorldDirection = transformDirection( position, modelMatrix );
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
gl_Position.z = gl_Position.w;
|
||
|
|
}`,uE=`#if DEPTH_PACKING == 3200
|
||
|
|
uniform float opacity;
|
||
|
|
#endif
|
||
|
|
#include <common>
|
||
|
|
#include <packing>
|
||
|
|
#include <uv_pars_fragment>
|
||
|
|
#include <map_pars_fragment>
|
||
|
|
#include <alphamap_pars_fragment>
|
||
|
|
#include <logdepthbuf_pars_fragment>
|
||
|
|
#include <clipping_planes_pars_fragment>
|
||
|
|
varying vec2 vHighPrecisionZW;
|
||
|
|
void main() {
|
||
|
|
#include <clipping_planes_fragment>
|
||
|
|
vec4 diffuseColor = vec4( 1.0 );
|
||
|
|
#if DEPTH_PACKING == 3200
|
||
|
|
diffuseColor.a = opacity;
|
||
|
|
#endif
|
||
|
|
#include <map_fragment>
|
||
|
|
#include <alphamap_fragment>
|
||
|
|
#include <alphatest_fragment>
|
||
|
|
#include <logdepthbuf_fragment>
|
||
|
|
float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;
|
||
|
|
#if DEPTH_PACKING == 3200
|
||
|
|
gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );
|
||
|
|
#elif DEPTH_PACKING == 3201
|
||
|
|
gl_FragColor = packDepthToRGBA( fragCoordZ );
|
||
|
|
#endif
|
||
|
|
}`,hE=`#include <common>
|
||
|
|
#include <uv_pars_vertex>
|
||
|
|
#include <displacementmap_pars_vertex>
|
||
|
|
#include <morphtarget_pars_vertex>
|
||
|
|
#include <skinning_pars_vertex>
|
||
|
|
#include <logdepthbuf_pars_vertex>
|
||
|
|
#include <clipping_planes_pars_vertex>
|
||
|
|
varying vec2 vHighPrecisionZW;
|
||
|
|
void main() {
|
||
|
|
#include <uv_vertex>
|
||
|
|
#include <skinbase_vertex>
|
||
|
|
#ifdef USE_DISPLACEMENTMAP
|
||
|
|
#include <beginnormal_vertex>
|
||
|
|
#include <morphnormal_vertex>
|
||
|
|
#include <skinnormal_vertex>
|
||
|
|
#endif
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <morphtarget_vertex>
|
||
|
|
#include <skinning_vertex>
|
||
|
|
#include <displacementmap_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
#include <logdepthbuf_vertex>
|
||
|
|
#include <clipping_planes_vertex>
|
||
|
|
vHighPrecisionZW = gl_Position.zw;
|
||
|
|
}`,dE=`#define DISTANCE
|
||
|
|
uniform vec3 referencePosition;
|
||
|
|
uniform float nearDistance;
|
||
|
|
uniform float farDistance;
|
||
|
|
varying vec3 vWorldPosition;
|
||
|
|
#include <common>
|
||
|
|
#include <packing>
|
||
|
|
#include <uv_pars_fragment>
|
||
|
|
#include <map_pars_fragment>
|
||
|
|
#include <alphamap_pars_fragment>
|
||
|
|
#include <clipping_planes_pars_fragment>
|
||
|
|
void main () {
|
||
|
|
#include <clipping_planes_fragment>
|
||
|
|
vec4 diffuseColor = vec4( 1.0 );
|
||
|
|
#include <map_fragment>
|
||
|
|
#include <alphamap_fragment>
|
||
|
|
#include <alphatest_fragment>
|
||
|
|
float dist = length( vWorldPosition - referencePosition );
|
||
|
|
dist = ( dist - nearDistance ) / ( farDistance - nearDistance );
|
||
|
|
dist = saturate( dist );
|
||
|
|
gl_FragColor = packDepthToRGBA( dist );
|
||
|
|
}`,fE=`#define DISTANCE
|
||
|
|
varying vec3 vWorldPosition;
|
||
|
|
#include <common>
|
||
|
|
#include <uv_pars_vertex>
|
||
|
|
#include <displacementmap_pars_vertex>
|
||
|
|
#include <morphtarget_pars_vertex>
|
||
|
|
#include <skinning_pars_vertex>
|
||
|
|
#include <clipping_planes_pars_vertex>
|
||
|
|
void main() {
|
||
|
|
#include <uv_vertex>
|
||
|
|
#include <skinbase_vertex>
|
||
|
|
#ifdef USE_DISPLACEMENTMAP
|
||
|
|
#include <beginnormal_vertex>
|
||
|
|
#include <morphnormal_vertex>
|
||
|
|
#include <skinnormal_vertex>
|
||
|
|
#endif
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <morphtarget_vertex>
|
||
|
|
#include <skinning_vertex>
|
||
|
|
#include <displacementmap_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
#include <worldpos_vertex>
|
||
|
|
#include <clipping_planes_vertex>
|
||
|
|
vWorldPosition = worldPosition.xyz;
|
||
|
|
}`,pE=`uniform sampler2D tEquirect;
|
||
|
|
varying vec3 vWorldDirection;
|
||
|
|
#include <common>
|
||
|
|
void main() {
|
||
|
|
vec3 direction = normalize( vWorldDirection );
|
||
|
|
vec2 sampleUV = equirectUv( direction );
|
||
|
|
vec4 texColor = texture2D( tEquirect, sampleUV );
|
||
|
|
gl_FragColor = mapTexelToLinear( texColor );
|
||
|
|
#include <tonemapping_fragment>
|
||
|
|
#include <encodings_fragment>
|
||
|
|
}`,mE=`varying vec3 vWorldDirection;
|
||
|
|
#include <common>
|
||
|
|
void main() {
|
||
|
|
vWorldDirection = transformDirection( position, modelMatrix );
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
}`,gE=`uniform vec3 diffuse;
|
||
|
|
uniform float opacity;
|
||
|
|
uniform float dashSize;
|
||
|
|
uniform float totalSize;
|
||
|
|
varying float vLineDistance;
|
||
|
|
#include <common>
|
||
|
|
#include <color_pars_fragment>
|
||
|
|
#include <fog_pars_fragment>
|
||
|
|
#include <logdepthbuf_pars_fragment>
|
||
|
|
#include <clipping_planes_pars_fragment>
|
||
|
|
void main() {
|
||
|
|
#include <clipping_planes_fragment>
|
||
|
|
if ( mod( vLineDistance, totalSize ) > dashSize ) {
|
||
|
|
discard;
|
||
|
|
}
|
||
|
|
vec3 outgoingLight = vec3( 0.0 );
|
||
|
|
vec4 diffuseColor = vec4( diffuse, opacity );
|
||
|
|
#include <logdepthbuf_fragment>
|
||
|
|
#include <color_fragment>
|
||
|
|
outgoingLight = diffuseColor.rgb;
|
||
|
|
gl_FragColor = vec4( outgoingLight, diffuseColor.a );
|
||
|
|
#include <tonemapping_fragment>
|
||
|
|
#include <encodings_fragment>
|
||
|
|
#include <fog_fragment>
|
||
|
|
#include <premultiplied_alpha_fragment>
|
||
|
|
}`,yE=`uniform float scale;
|
||
|
|
attribute float lineDistance;
|
||
|
|
varying float vLineDistance;
|
||
|
|
#include <common>
|
||
|
|
#include <color_pars_vertex>
|
||
|
|
#include <fog_pars_vertex>
|
||
|
|
#include <morphtarget_pars_vertex>
|
||
|
|
#include <logdepthbuf_pars_vertex>
|
||
|
|
#include <clipping_planes_pars_vertex>
|
||
|
|
void main() {
|
||
|
|
vLineDistance = scale * lineDistance;
|
||
|
|
#include <color_vertex>
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <morphtarget_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
#include <logdepthbuf_vertex>
|
||
|
|
#include <clipping_planes_vertex>
|
||
|
|
#include <fog_vertex>
|
||
|
|
}`,vE=`uniform vec3 diffuse;
|
||
|
|
uniform float opacity;
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
varying vec3 vNormal;
|
||
|
|
#endif
|
||
|
|
#include <common>
|
||
|
|
#include <dithering_pars_fragment>
|
||
|
|
#include <color_pars_fragment>
|
||
|
|
#include <uv_pars_fragment>
|
||
|
|
#include <uv2_pars_fragment>
|
||
|
|
#include <map_pars_fragment>
|
||
|
|
#include <alphamap_pars_fragment>
|
||
|
|
#include <aomap_pars_fragment>
|
||
|
|
#include <lightmap_pars_fragment>
|
||
|
|
#include <envmap_common_pars_fragment>
|
||
|
|
#include <envmap_pars_fragment>
|
||
|
|
#include <cube_uv_reflection_fragment>
|
||
|
|
#include <fog_pars_fragment>
|
||
|
|
#include <specularmap_pars_fragment>
|
||
|
|
#include <logdepthbuf_pars_fragment>
|
||
|
|
#include <clipping_planes_pars_fragment>
|
||
|
|
void main() {
|
||
|
|
#include <clipping_planes_fragment>
|
||
|
|
vec4 diffuseColor = vec4( diffuse, opacity );
|
||
|
|
#include <logdepthbuf_fragment>
|
||
|
|
#include <map_fragment>
|
||
|
|
#include <color_fragment>
|
||
|
|
#include <alphamap_fragment>
|
||
|
|
#include <alphatest_fragment>
|
||
|
|
#include <specularmap_fragment>
|
||
|
|
ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
|
||
|
|
#ifdef USE_LIGHTMAP
|
||
|
|
|
||
|
|
vec4 lightMapTexel= texture2D( lightMap, vUv2 );
|
||
|
|
reflectedLight.indirectDiffuse += lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;
|
||
|
|
#else
|
||
|
|
reflectedLight.indirectDiffuse += vec3( 1.0 );
|
||
|
|
#endif
|
||
|
|
#include <aomap_fragment>
|
||
|
|
reflectedLight.indirectDiffuse *= diffuseColor.rgb;
|
||
|
|
vec3 outgoingLight = reflectedLight.indirectDiffuse;
|
||
|
|
#include <envmap_fragment>
|
||
|
|
gl_FragColor = vec4( outgoingLight, diffuseColor.a );
|
||
|
|
#include <tonemapping_fragment>
|
||
|
|
#include <encodings_fragment>
|
||
|
|
#include <fog_fragment>
|
||
|
|
#include <premultiplied_alpha_fragment>
|
||
|
|
#include <dithering_fragment>
|
||
|
|
}`,xE=`#include <common>
|
||
|
|
#include <uv_pars_vertex>
|
||
|
|
#include <uv2_pars_vertex>
|
||
|
|
#include <envmap_pars_vertex>
|
||
|
|
#include <color_pars_vertex>
|
||
|
|
#include <fog_pars_vertex>
|
||
|
|
#include <morphtarget_pars_vertex>
|
||
|
|
#include <skinning_pars_vertex>
|
||
|
|
#include <logdepthbuf_pars_vertex>
|
||
|
|
#include <clipping_planes_pars_vertex>
|
||
|
|
void main() {
|
||
|
|
#include <uv_vertex>
|
||
|
|
#include <uv2_vertex>
|
||
|
|
#include <color_vertex>
|
||
|
|
#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )
|
||
|
|
#include <beginnormal_vertex>
|
||
|
|
#include <morphnormal_vertex>
|
||
|
|
#include <skinbase_vertex>
|
||
|
|
#include <skinnormal_vertex>
|
||
|
|
#include <defaultnormal_vertex>
|
||
|
|
#endif
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <morphtarget_vertex>
|
||
|
|
#include <skinning_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
#include <logdepthbuf_vertex>
|
||
|
|
#include <clipping_planes_vertex>
|
||
|
|
#include <worldpos_vertex>
|
||
|
|
#include <envmap_vertex>
|
||
|
|
#include <fog_vertex>
|
||
|
|
}`,bE=`uniform vec3 diffuse;
|
||
|
|
uniform vec3 emissive;
|
||
|
|
uniform float opacity;
|
||
|
|
varying vec3 vLightFront;
|
||
|
|
varying vec3 vIndirectFront;
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
varying vec3 vLightBack;
|
||
|
|
varying vec3 vIndirectBack;
|
||
|
|
#endif
|
||
|
|
#include <common>
|
||
|
|
#include <packing>
|
||
|
|
#include <dithering_pars_fragment>
|
||
|
|
#include <color_pars_fragment>
|
||
|
|
#include <uv_pars_fragment>
|
||
|
|
#include <uv2_pars_fragment>
|
||
|
|
#include <map_pars_fragment>
|
||
|
|
#include <alphamap_pars_fragment>
|
||
|
|
#include <aomap_pars_fragment>
|
||
|
|
#include <lightmap_pars_fragment>
|
||
|
|
#include <emissivemap_pars_fragment>
|
||
|
|
#include <envmap_common_pars_fragment>
|
||
|
|
#include <envmap_pars_fragment>
|
||
|
|
#include <cube_uv_reflection_fragment>
|
||
|
|
#include <bsdfs>
|
||
|
|
#include <lights_pars_begin>
|
||
|
|
#include <fog_pars_fragment>
|
||
|
|
#include <shadowmap_pars_fragment>
|
||
|
|
#include <shadowmask_pars_fragment>
|
||
|
|
#include <specularmap_pars_fragment>
|
||
|
|
#include <logdepthbuf_pars_fragment>
|
||
|
|
#include <clipping_planes_pars_fragment>
|
||
|
|
void main() {
|
||
|
|
#include <clipping_planes_fragment>
|
||
|
|
vec4 diffuseColor = vec4( diffuse, opacity );
|
||
|
|
ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
|
||
|
|
vec3 totalEmissiveRadiance = emissive;
|
||
|
|
#include <logdepthbuf_fragment>
|
||
|
|
#include <map_fragment>
|
||
|
|
#include <color_fragment>
|
||
|
|
#include <alphamap_fragment>
|
||
|
|
#include <alphatest_fragment>
|
||
|
|
#include <specularmap_fragment>
|
||
|
|
#include <emissivemap_fragment>
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
reflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;
|
||
|
|
#else
|
||
|
|
reflectedLight.indirectDiffuse += vIndirectFront;
|
||
|
|
#endif
|
||
|
|
#include <lightmap_fragment>
|
||
|
|
reflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;
|
||
|
|
#else
|
||
|
|
reflectedLight.directDiffuse = vLightFront;
|
||
|
|
#endif
|
||
|
|
reflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();
|
||
|
|
#include <aomap_fragment>
|
||
|
|
vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
|
||
|
|
#include <envmap_fragment>
|
||
|
|
gl_FragColor = vec4( outgoingLight, diffuseColor.a );
|
||
|
|
#include <tonemapping_fragment>
|
||
|
|
#include <encodings_fragment>
|
||
|
|
#include <fog_fragment>
|
||
|
|
#include <premultiplied_alpha_fragment>
|
||
|
|
#include <dithering_fragment>
|
||
|
|
}`,wE=`#define LAMBERT
|
||
|
|
varying vec3 vLightFront;
|
||
|
|
varying vec3 vIndirectFront;
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
varying vec3 vLightBack;
|
||
|
|
varying vec3 vIndirectBack;
|
||
|
|
#endif
|
||
|
|
#include <common>
|
||
|
|
#include <uv_pars_vertex>
|
||
|
|
#include <uv2_pars_vertex>
|
||
|
|
#include <envmap_pars_vertex>
|
||
|
|
#include <bsdfs>
|
||
|
|
#include <lights_pars_begin>
|
||
|
|
#include <color_pars_vertex>
|
||
|
|
#include <fog_pars_vertex>
|
||
|
|
#include <morphtarget_pars_vertex>
|
||
|
|
#include <skinning_pars_vertex>
|
||
|
|
#include <shadowmap_pars_vertex>
|
||
|
|
#include <logdepthbuf_pars_vertex>
|
||
|
|
#include <clipping_planes_pars_vertex>
|
||
|
|
void main() {
|
||
|
|
#include <uv_vertex>
|
||
|
|
#include <uv2_vertex>
|
||
|
|
#include <color_vertex>
|
||
|
|
#include <beginnormal_vertex>
|
||
|
|
#include <morphnormal_vertex>
|
||
|
|
#include <skinbase_vertex>
|
||
|
|
#include <skinnormal_vertex>
|
||
|
|
#include <defaultnormal_vertex>
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <morphtarget_vertex>
|
||
|
|
#include <skinning_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
#include <logdepthbuf_vertex>
|
||
|
|
#include <clipping_planes_vertex>
|
||
|
|
#include <worldpos_vertex>
|
||
|
|
#include <envmap_vertex>
|
||
|
|
#include <lights_lambert_vertex>
|
||
|
|
#include <shadowmap_vertex>
|
||
|
|
#include <fog_vertex>
|
||
|
|
}`,SE=`#define MATCAP
|
||
|
|
uniform vec3 diffuse;
|
||
|
|
uniform float opacity;
|
||
|
|
uniform sampler2D matcap;
|
||
|
|
varying vec3 vViewPosition;
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
varying vec3 vNormal;
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
varying vec3 vTangent;
|
||
|
|
varying vec3 vBitangent;
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#include <common>
|
||
|
|
#include <dithering_pars_fragment>
|
||
|
|
#include <color_pars_fragment>
|
||
|
|
#include <uv_pars_fragment>
|
||
|
|
#include <map_pars_fragment>
|
||
|
|
#include <alphamap_pars_fragment>
|
||
|
|
#include <fog_pars_fragment>
|
||
|
|
#include <bumpmap_pars_fragment>
|
||
|
|
#include <normalmap_pars_fragment>
|
||
|
|
#include <logdepthbuf_pars_fragment>
|
||
|
|
#include <clipping_planes_pars_fragment>
|
||
|
|
void main() {
|
||
|
|
#include <clipping_planes_fragment>
|
||
|
|
vec4 diffuseColor = vec4( diffuse, opacity );
|
||
|
|
#include <logdepthbuf_fragment>
|
||
|
|
#include <map_fragment>
|
||
|
|
#include <color_fragment>
|
||
|
|
#include <alphamap_fragment>
|
||
|
|
#include <alphatest_fragment>
|
||
|
|
#include <normal_fragment_begin>
|
||
|
|
#include <normal_fragment_maps>
|
||
|
|
vec3 viewDir = normalize( vViewPosition );
|
||
|
|
vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );
|
||
|
|
vec3 y = cross( viewDir, x );
|
||
|
|
vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;
|
||
|
|
#ifdef USE_MATCAP
|
||
|
|
vec4 matcapColor = texture2D( matcap, uv );
|
||
|
|
matcapColor = matcapTexelToLinear( matcapColor );
|
||
|
|
#else
|
||
|
|
vec4 matcapColor = vec4( 1.0 );
|
||
|
|
#endif
|
||
|
|
vec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;
|
||
|
|
gl_FragColor = vec4( outgoingLight, diffuseColor.a );
|
||
|
|
#include <tonemapping_fragment>
|
||
|
|
#include <encodings_fragment>
|
||
|
|
#include <fog_fragment>
|
||
|
|
#include <premultiplied_alpha_fragment>
|
||
|
|
#include <dithering_fragment>
|
||
|
|
}`,ME=`#define MATCAP
|
||
|
|
varying vec3 vViewPosition;
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
varying vec3 vNormal;
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
varying vec3 vTangent;
|
||
|
|
varying vec3 vBitangent;
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#include <common>
|
||
|
|
#include <uv_pars_vertex>
|
||
|
|
#include <color_pars_vertex>
|
||
|
|
#include <displacementmap_pars_vertex>
|
||
|
|
#include <fog_pars_vertex>
|
||
|
|
#include <morphtarget_pars_vertex>
|
||
|
|
#include <skinning_pars_vertex>
|
||
|
|
#include <logdepthbuf_pars_vertex>
|
||
|
|
#include <clipping_planes_pars_vertex>
|
||
|
|
void main() {
|
||
|
|
#include <uv_vertex>
|
||
|
|
#include <color_vertex>
|
||
|
|
#include <beginnormal_vertex>
|
||
|
|
#include <morphnormal_vertex>
|
||
|
|
#include <skinbase_vertex>
|
||
|
|
#include <skinnormal_vertex>
|
||
|
|
#include <defaultnormal_vertex>
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
vNormal = normalize( transformedNormal );
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
vTangent = normalize( transformedTangent );
|
||
|
|
vBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <morphtarget_vertex>
|
||
|
|
#include <skinning_vertex>
|
||
|
|
#include <displacementmap_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
#include <logdepthbuf_vertex>
|
||
|
|
#include <clipping_planes_vertex>
|
||
|
|
#include <fog_vertex>
|
||
|
|
vViewPosition = - mvPosition.xyz;
|
||
|
|
}`,AE=`#define TOON
|
||
|
|
uniform vec3 diffuse;
|
||
|
|
uniform vec3 emissive;
|
||
|
|
uniform float opacity;
|
||
|
|
#include <common>
|
||
|
|
#include <packing>
|
||
|
|
#include <dithering_pars_fragment>
|
||
|
|
#include <color_pars_fragment>
|
||
|
|
#include <uv_pars_fragment>
|
||
|
|
#include <uv2_pars_fragment>
|
||
|
|
#include <map_pars_fragment>
|
||
|
|
#include <alphamap_pars_fragment>
|
||
|
|
#include <aomap_pars_fragment>
|
||
|
|
#include <lightmap_pars_fragment>
|
||
|
|
#include <emissivemap_pars_fragment>
|
||
|
|
#include <gradientmap_pars_fragment>
|
||
|
|
#include <fog_pars_fragment>
|
||
|
|
#include <bsdfs>
|
||
|
|
#include <lights_pars_begin>
|
||
|
|
#include <lights_toon_pars_fragment>
|
||
|
|
#include <shadowmap_pars_fragment>
|
||
|
|
#include <bumpmap_pars_fragment>
|
||
|
|
#include <normalmap_pars_fragment>
|
||
|
|
#include <logdepthbuf_pars_fragment>
|
||
|
|
#include <clipping_planes_pars_fragment>
|
||
|
|
void main() {
|
||
|
|
#include <clipping_planes_fragment>
|
||
|
|
vec4 diffuseColor = vec4( diffuse, opacity );
|
||
|
|
ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
|
||
|
|
vec3 totalEmissiveRadiance = emissive;
|
||
|
|
#include <logdepthbuf_fragment>
|
||
|
|
#include <map_fragment>
|
||
|
|
#include <color_fragment>
|
||
|
|
#include <alphamap_fragment>
|
||
|
|
#include <alphatest_fragment>
|
||
|
|
#include <normal_fragment_begin>
|
||
|
|
#include <normal_fragment_maps>
|
||
|
|
#include <emissivemap_fragment>
|
||
|
|
#include <lights_toon_fragment>
|
||
|
|
#include <lights_fragment_begin>
|
||
|
|
#include <lights_fragment_maps>
|
||
|
|
#include <lights_fragment_end>
|
||
|
|
#include <aomap_fragment>
|
||
|
|
vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
|
||
|
|
gl_FragColor = vec4( outgoingLight, diffuseColor.a );
|
||
|
|
#include <tonemapping_fragment>
|
||
|
|
#include <encodings_fragment>
|
||
|
|
#include <fog_fragment>
|
||
|
|
#include <premultiplied_alpha_fragment>
|
||
|
|
#include <dithering_fragment>
|
||
|
|
}`,_E=`#define TOON
|
||
|
|
varying vec3 vViewPosition;
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
varying vec3 vNormal;
|
||
|
|
#endif
|
||
|
|
#include <common>
|
||
|
|
#include <uv_pars_vertex>
|
||
|
|
#include <uv2_pars_vertex>
|
||
|
|
#include <displacementmap_pars_vertex>
|
||
|
|
#include <color_pars_vertex>
|
||
|
|
#include <fog_pars_vertex>
|
||
|
|
#include <morphtarget_pars_vertex>
|
||
|
|
#include <skinning_pars_vertex>
|
||
|
|
#include <shadowmap_pars_vertex>
|
||
|
|
#include <logdepthbuf_pars_vertex>
|
||
|
|
#include <clipping_planes_pars_vertex>
|
||
|
|
void main() {
|
||
|
|
#include <uv_vertex>
|
||
|
|
#include <uv2_vertex>
|
||
|
|
#include <color_vertex>
|
||
|
|
#include <beginnormal_vertex>
|
||
|
|
#include <morphnormal_vertex>
|
||
|
|
#include <skinbase_vertex>
|
||
|
|
#include <skinnormal_vertex>
|
||
|
|
#include <defaultnormal_vertex>
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
vNormal = normalize( transformedNormal );
|
||
|
|
#endif
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <morphtarget_vertex>
|
||
|
|
#include <skinning_vertex>
|
||
|
|
#include <displacementmap_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
#include <logdepthbuf_vertex>
|
||
|
|
#include <clipping_planes_vertex>
|
||
|
|
vViewPosition = - mvPosition.xyz;
|
||
|
|
#include <worldpos_vertex>
|
||
|
|
#include <shadowmap_vertex>
|
||
|
|
#include <fog_vertex>
|
||
|
|
}`,TE=`#define PHONG
|
||
|
|
uniform vec3 diffuse;
|
||
|
|
uniform vec3 emissive;
|
||
|
|
uniform vec3 specular;
|
||
|
|
uniform float shininess;
|
||
|
|
uniform float opacity;
|
||
|
|
#include <common>
|
||
|
|
#include <packing>
|
||
|
|
#include <dithering_pars_fragment>
|
||
|
|
#include <color_pars_fragment>
|
||
|
|
#include <uv_pars_fragment>
|
||
|
|
#include <uv2_pars_fragment>
|
||
|
|
#include <map_pars_fragment>
|
||
|
|
#include <alphamap_pars_fragment>
|
||
|
|
#include <aomap_pars_fragment>
|
||
|
|
#include <lightmap_pars_fragment>
|
||
|
|
#include <emissivemap_pars_fragment>
|
||
|
|
#include <envmap_common_pars_fragment>
|
||
|
|
#include <envmap_pars_fragment>
|
||
|
|
#include <cube_uv_reflection_fragment>
|
||
|
|
#include <fog_pars_fragment>
|
||
|
|
#include <bsdfs>
|
||
|
|
#include <lights_pars_begin>
|
||
|
|
#include <lights_phong_pars_fragment>
|
||
|
|
#include <shadowmap_pars_fragment>
|
||
|
|
#include <bumpmap_pars_fragment>
|
||
|
|
#include <normalmap_pars_fragment>
|
||
|
|
#include <specularmap_pars_fragment>
|
||
|
|
#include <logdepthbuf_pars_fragment>
|
||
|
|
#include <clipping_planes_pars_fragment>
|
||
|
|
void main() {
|
||
|
|
#include <clipping_planes_fragment>
|
||
|
|
vec4 diffuseColor = vec4( diffuse, opacity );
|
||
|
|
ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
|
||
|
|
vec3 totalEmissiveRadiance = emissive;
|
||
|
|
#include <logdepthbuf_fragment>
|
||
|
|
#include <map_fragment>
|
||
|
|
#include <color_fragment>
|
||
|
|
#include <alphamap_fragment>
|
||
|
|
#include <alphatest_fragment>
|
||
|
|
#include <specularmap_fragment>
|
||
|
|
#include <normal_fragment_begin>
|
||
|
|
#include <normal_fragment_maps>
|
||
|
|
#include <emissivemap_fragment>
|
||
|
|
#include <lights_phong_fragment>
|
||
|
|
#include <lights_fragment_begin>
|
||
|
|
#include <lights_fragment_maps>
|
||
|
|
#include <lights_fragment_end>
|
||
|
|
#include <aomap_fragment>
|
||
|
|
vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;
|
||
|
|
#include <envmap_fragment>
|
||
|
|
gl_FragColor = vec4( outgoingLight, diffuseColor.a );
|
||
|
|
#include <tonemapping_fragment>
|
||
|
|
#include <encodings_fragment>
|
||
|
|
#include <fog_fragment>
|
||
|
|
#include <premultiplied_alpha_fragment>
|
||
|
|
#include <dithering_fragment>
|
||
|
|
}`,EE=`#define PHONG
|
||
|
|
varying vec3 vViewPosition;
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
varying vec3 vNormal;
|
||
|
|
#endif
|
||
|
|
#include <common>
|
||
|
|
#include <uv_pars_vertex>
|
||
|
|
#include <uv2_pars_vertex>
|
||
|
|
#include <displacementmap_pars_vertex>
|
||
|
|
#include <envmap_pars_vertex>
|
||
|
|
#include <color_pars_vertex>
|
||
|
|
#include <fog_pars_vertex>
|
||
|
|
#include <morphtarget_pars_vertex>
|
||
|
|
#include <skinning_pars_vertex>
|
||
|
|
#include <shadowmap_pars_vertex>
|
||
|
|
#include <logdepthbuf_pars_vertex>
|
||
|
|
#include <clipping_planes_pars_vertex>
|
||
|
|
void main() {
|
||
|
|
#include <uv_vertex>
|
||
|
|
#include <uv2_vertex>
|
||
|
|
#include <color_vertex>
|
||
|
|
#include <beginnormal_vertex>
|
||
|
|
#include <morphnormal_vertex>
|
||
|
|
#include <skinbase_vertex>
|
||
|
|
#include <skinnormal_vertex>
|
||
|
|
#include <defaultnormal_vertex>
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
vNormal = normalize( transformedNormal );
|
||
|
|
#endif
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <morphtarget_vertex>
|
||
|
|
#include <skinning_vertex>
|
||
|
|
#include <displacementmap_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
#include <logdepthbuf_vertex>
|
||
|
|
#include <clipping_planes_vertex>
|
||
|
|
vViewPosition = - mvPosition.xyz;
|
||
|
|
#include <worldpos_vertex>
|
||
|
|
#include <envmap_vertex>
|
||
|
|
#include <shadowmap_vertex>
|
||
|
|
#include <fog_vertex>
|
||
|
|
}`,NE=`#define STANDARD
|
||
|
|
#ifdef PHYSICAL
|
||
|
|
#define REFLECTIVITY
|
||
|
|
#define CLEARCOAT
|
||
|
|
#define SPECULAR
|
||
|
|
#endif
|
||
|
|
uniform vec3 diffuse;
|
||
|
|
uniform vec3 emissive;
|
||
|
|
uniform float roughness;
|
||
|
|
uniform float metalness;
|
||
|
|
uniform float opacity;
|
||
|
|
#ifdef USE_TRANSMISSION
|
||
|
|
uniform float transmission;
|
||
|
|
uniform float thickness;
|
||
|
|
uniform float attenuationDistance;
|
||
|
|
uniform vec3 attenuationTint;
|
||
|
|
#endif
|
||
|
|
#ifdef REFLECTIVITY
|
||
|
|
uniform float reflectivity;
|
||
|
|
#endif
|
||
|
|
#ifdef SPECULAR
|
||
|
|
uniform float specularIntensity;
|
||
|
|
uniform vec3 specularTint;
|
||
|
|
#ifdef USE_SPECULARINTENSITYMAP
|
||
|
|
uniform sampler2D specularIntensityMap;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_SPECULARTINTMAP
|
||
|
|
uniform sampler2D specularTintMap;
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#ifdef CLEARCOAT
|
||
|
|
uniform float clearcoat;
|
||
|
|
uniform float clearcoatRoughness;
|
||
|
|
#endif
|
||
|
|
#ifdef USE_SHEEN
|
||
|
|
uniform vec3 sheen;
|
||
|
|
#endif
|
||
|
|
varying vec3 vViewPosition;
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
varying vec3 vNormal;
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
varying vec3 vTangent;
|
||
|
|
varying vec3 vBitangent;
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#include <common>
|
||
|
|
#include <packing>
|
||
|
|
#include <dithering_pars_fragment>
|
||
|
|
#include <color_pars_fragment>
|
||
|
|
#include <uv_pars_fragment>
|
||
|
|
#include <uv2_pars_fragment>
|
||
|
|
#include <map_pars_fragment>
|
||
|
|
#include <alphamap_pars_fragment>
|
||
|
|
#include <aomap_pars_fragment>
|
||
|
|
#include <lightmap_pars_fragment>
|
||
|
|
#include <emissivemap_pars_fragment>
|
||
|
|
#include <bsdfs>
|
||
|
|
#include <transmission_pars_fragment>
|
||
|
|
#include <cube_uv_reflection_fragment>
|
||
|
|
#include <envmap_common_pars_fragment>
|
||
|
|
#include <envmap_physical_pars_fragment>
|
||
|
|
#include <fog_pars_fragment>
|
||
|
|
#include <lights_pars_begin>
|
||
|
|
#include <lights_physical_pars_fragment>
|
||
|
|
#include <shadowmap_pars_fragment>
|
||
|
|
#include <bumpmap_pars_fragment>
|
||
|
|
#include <normalmap_pars_fragment>
|
||
|
|
#include <clearcoat_pars_fragment>
|
||
|
|
#include <roughnessmap_pars_fragment>
|
||
|
|
#include <metalnessmap_pars_fragment>
|
||
|
|
#include <logdepthbuf_pars_fragment>
|
||
|
|
#include <clipping_planes_pars_fragment>
|
||
|
|
void main() {
|
||
|
|
#include <clipping_planes_fragment>
|
||
|
|
vec4 diffuseColor = vec4( diffuse, opacity );
|
||
|
|
ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
|
||
|
|
vec3 totalEmissiveRadiance = emissive;
|
||
|
|
#include <logdepthbuf_fragment>
|
||
|
|
#include <map_fragment>
|
||
|
|
#include <color_fragment>
|
||
|
|
#include <alphamap_fragment>
|
||
|
|
#include <alphatest_fragment>
|
||
|
|
#include <roughnessmap_fragment>
|
||
|
|
#include <metalnessmap_fragment>
|
||
|
|
#include <normal_fragment_begin>
|
||
|
|
#include <normal_fragment_maps>
|
||
|
|
#include <clearcoat_normal_fragment_begin>
|
||
|
|
#include <clearcoat_normal_fragment_maps>
|
||
|
|
#include <emissivemap_fragment>
|
||
|
|
#include <lights_physical_fragment>
|
||
|
|
#include <lights_fragment_begin>
|
||
|
|
#include <lights_fragment_maps>
|
||
|
|
#include <lights_fragment_end>
|
||
|
|
#include <aomap_fragment>
|
||
|
|
vec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;
|
||
|
|
vec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;
|
||
|
|
#include <transmission_fragment>
|
||
|
|
vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
|
||
|
|
gl_FragColor = vec4( outgoingLight, diffuseColor.a );
|
||
|
|
#include <tonemapping_fragment>
|
||
|
|
#include <encodings_fragment>
|
||
|
|
#include <fog_fragment>
|
||
|
|
#include <premultiplied_alpha_fragment>
|
||
|
|
#include <dithering_fragment>
|
||
|
|
}`,CE=`#define STANDARD
|
||
|
|
varying vec3 vViewPosition;
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
varying vec3 vNormal;
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
varying vec3 vTangent;
|
||
|
|
varying vec3 vBitangent;
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#ifdef USE_TRANSMISSION
|
||
|
|
varying vec4 vWorldPosition;
|
||
|
|
#endif
|
||
|
|
#include <common>
|
||
|
|
#include <uv_pars_vertex>
|
||
|
|
#include <uv2_pars_vertex>
|
||
|
|
#include <displacementmap_pars_vertex>
|
||
|
|
#include <color_pars_vertex>
|
||
|
|
#include <fog_pars_vertex>
|
||
|
|
#include <morphtarget_pars_vertex>
|
||
|
|
#include <skinning_pars_vertex>
|
||
|
|
#include <shadowmap_pars_vertex>
|
||
|
|
#include <logdepthbuf_pars_vertex>
|
||
|
|
#include <clipping_planes_pars_vertex>
|
||
|
|
void main() {
|
||
|
|
#include <uv_vertex>
|
||
|
|
#include <uv2_vertex>
|
||
|
|
#include <color_vertex>
|
||
|
|
#include <beginnormal_vertex>
|
||
|
|
#include <morphnormal_vertex>
|
||
|
|
#include <skinbase_vertex>
|
||
|
|
#include <skinnormal_vertex>
|
||
|
|
#include <defaultnormal_vertex>
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
vNormal = normalize( transformedNormal );
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
vTangent = normalize( transformedTangent );
|
||
|
|
vBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <morphtarget_vertex>
|
||
|
|
#include <skinning_vertex>
|
||
|
|
#include <displacementmap_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
#include <logdepthbuf_vertex>
|
||
|
|
#include <clipping_planes_vertex>
|
||
|
|
vViewPosition = - mvPosition.xyz;
|
||
|
|
#include <worldpos_vertex>
|
||
|
|
#include <shadowmap_vertex>
|
||
|
|
#include <fog_vertex>
|
||
|
|
#ifdef USE_TRANSMISSION
|
||
|
|
vWorldPosition = worldPosition;
|
||
|
|
#endif
|
||
|
|
}`,LE=`#define NORMAL
|
||
|
|
uniform float opacity;
|
||
|
|
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
|
||
|
|
varying vec3 vViewPosition;
|
||
|
|
#endif
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
varying vec3 vNormal;
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
varying vec3 vTangent;
|
||
|
|
varying vec3 vBitangent;
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#include <packing>
|
||
|
|
#include <uv_pars_fragment>
|
||
|
|
#include <bumpmap_pars_fragment>
|
||
|
|
#include <normalmap_pars_fragment>
|
||
|
|
#include <logdepthbuf_pars_fragment>
|
||
|
|
#include <clipping_planes_pars_fragment>
|
||
|
|
void main() {
|
||
|
|
#include <clipping_planes_fragment>
|
||
|
|
#include <logdepthbuf_fragment>
|
||
|
|
#include <normal_fragment_begin>
|
||
|
|
#include <normal_fragment_maps>
|
||
|
|
gl_FragColor = vec4( packNormalToRGB( normal ), opacity );
|
||
|
|
}`,IE=`#define NORMAL
|
||
|
|
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
|
||
|
|
varying vec3 vViewPosition;
|
||
|
|
#endif
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
varying vec3 vNormal;
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
varying vec3 vTangent;
|
||
|
|
varying vec3 vBitangent;
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#include <common>
|
||
|
|
#include <uv_pars_vertex>
|
||
|
|
#include <displacementmap_pars_vertex>
|
||
|
|
#include <morphtarget_pars_vertex>
|
||
|
|
#include <skinning_pars_vertex>
|
||
|
|
#include <logdepthbuf_pars_vertex>
|
||
|
|
#include <clipping_planes_pars_vertex>
|
||
|
|
void main() {
|
||
|
|
#include <uv_vertex>
|
||
|
|
#include <beginnormal_vertex>
|
||
|
|
#include <morphnormal_vertex>
|
||
|
|
#include <skinbase_vertex>
|
||
|
|
#include <skinnormal_vertex>
|
||
|
|
#include <defaultnormal_vertex>
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
vNormal = normalize( transformedNormal );
|
||
|
|
#ifdef USE_TANGENT
|
||
|
|
vTangent = normalize( transformedTangent );
|
||
|
|
vBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <morphtarget_vertex>
|
||
|
|
#include <skinning_vertex>
|
||
|
|
#include <displacementmap_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
#include <logdepthbuf_vertex>
|
||
|
|
#include <clipping_planes_vertex>
|
||
|
|
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
|
||
|
|
vViewPosition = - mvPosition.xyz;
|
||
|
|
#endif
|
||
|
|
}`,PE=`uniform vec3 diffuse;
|
||
|
|
uniform float opacity;
|
||
|
|
#include <common>
|
||
|
|
#include <color_pars_fragment>
|
||
|
|
#include <map_particle_pars_fragment>
|
||
|
|
#include <fog_pars_fragment>
|
||
|
|
#include <logdepthbuf_pars_fragment>
|
||
|
|
#include <clipping_planes_pars_fragment>
|
||
|
|
void main() {
|
||
|
|
#include <clipping_planes_fragment>
|
||
|
|
vec3 outgoingLight = vec3( 0.0 );
|
||
|
|
vec4 diffuseColor = vec4( diffuse, opacity );
|
||
|
|
#include <logdepthbuf_fragment>
|
||
|
|
#include <map_particle_fragment>
|
||
|
|
#include <color_fragment>
|
||
|
|
#include <alphatest_fragment>
|
||
|
|
outgoingLight = diffuseColor.rgb;
|
||
|
|
gl_FragColor = vec4( outgoingLight, diffuseColor.a );
|
||
|
|
#include <tonemapping_fragment>
|
||
|
|
#include <encodings_fragment>
|
||
|
|
#include <fog_fragment>
|
||
|
|
#include <premultiplied_alpha_fragment>
|
||
|
|
}`,DE=`uniform float size;
|
||
|
|
uniform float scale;
|
||
|
|
#include <common>
|
||
|
|
#include <color_pars_vertex>
|
||
|
|
#include <fog_pars_vertex>
|
||
|
|
#include <morphtarget_pars_vertex>
|
||
|
|
#include <logdepthbuf_pars_vertex>
|
||
|
|
#include <clipping_planes_pars_vertex>
|
||
|
|
void main() {
|
||
|
|
#include <color_vertex>
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <morphtarget_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
gl_PointSize = size;
|
||
|
|
#ifdef USE_SIZEATTENUATION
|
||
|
|
bool isPerspective = isPerspectiveMatrix( projectionMatrix );
|
||
|
|
if ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );
|
||
|
|
#endif
|
||
|
|
#include <logdepthbuf_vertex>
|
||
|
|
#include <clipping_planes_vertex>
|
||
|
|
#include <worldpos_vertex>
|
||
|
|
#include <fog_vertex>
|
||
|
|
}`,RE=`uniform vec3 color;
|
||
|
|
uniform float opacity;
|
||
|
|
#include <common>
|
||
|
|
#include <packing>
|
||
|
|
#include <fog_pars_fragment>
|
||
|
|
#include <bsdfs>
|
||
|
|
#include <lights_pars_begin>
|
||
|
|
#include <shadowmap_pars_fragment>
|
||
|
|
#include <shadowmask_pars_fragment>
|
||
|
|
void main() {
|
||
|
|
gl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );
|
||
|
|
#include <tonemapping_fragment>
|
||
|
|
#include <encodings_fragment>
|
||
|
|
#include <fog_fragment>
|
||
|
|
}`,BE=`#include <common>
|
||
|
|
#include <fog_pars_vertex>
|
||
|
|
#include <shadowmap_pars_vertex>
|
||
|
|
void main() {
|
||
|
|
#include <begin_vertex>
|
||
|
|
#include <project_vertex>
|
||
|
|
#include <worldpos_vertex>
|
||
|
|
#include <beginnormal_vertex>
|
||
|
|
#include <morphnormal_vertex>
|
||
|
|
#include <skinbase_vertex>
|
||
|
|
#include <skinnormal_vertex>
|
||
|
|
#include <defaultnormal_vertex>
|
||
|
|
#include <shadowmap_vertex>
|
||
|
|
#include <fog_vertex>
|
||
|
|
}`,OE=`uniform vec3 diffuse;
|
||
|
|
uniform float opacity;
|
||
|
|
#include <common>
|
||
|
|
#include <uv_pars_fragment>
|
||
|
|
#include <map_pars_fragment>
|
||
|
|
#include <alphamap_pars_fragment>
|
||
|
|
#include <fog_pars_fragment>
|
||
|
|
#include <logdepthbuf_pars_fragment>
|
||
|
|
#include <clipping_planes_pars_fragment>
|
||
|
|
void main() {
|
||
|
|
#include <clipping_planes_fragment>
|
||
|
|
vec3 outgoingLight = vec3( 0.0 );
|
||
|
|
vec4 diffuseColor = vec4( diffuse, opacity );
|
||
|
|
#include <logdepthbuf_fragment>
|
||
|
|
#include <map_fragment>
|
||
|
|
#include <alphamap_fragment>
|
||
|
|
#include <alphatest_fragment>
|
||
|
|
outgoingLight = diffuseColor.rgb;
|
||
|
|
gl_FragColor = vec4( outgoingLight, diffuseColor.a );
|
||
|
|
#include <tonemapping_fragment>
|
||
|
|
#include <encodings_fragment>
|
||
|
|
#include <fog_fragment>
|
||
|
|
}`,FE=`uniform float rotation;
|
||
|
|
uniform vec2 center;
|
||
|
|
#include <common>
|
||
|
|
#include <uv_pars_vertex>
|
||
|
|
#include <fog_pars_vertex>
|
||
|
|
#include <logdepthbuf_pars_vertex>
|
||
|
|
#include <clipping_planes_pars_vertex>
|
||
|
|
void main() {
|
||
|
|
#include <uv_vertex>
|
||
|
|
vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );
|
||
|
|
vec2 scale;
|
||
|
|
scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );
|
||
|
|
scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );
|
||
|
|
#ifndef USE_SIZEATTENUATION
|
||
|
|
bool isPerspective = isPerspectiveMatrix( projectionMatrix );
|
||
|
|
if ( isPerspective ) scale *= - mvPosition.z;
|
||
|
|
#endif
|
||
|
|
vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;
|
||
|
|
vec2 rotatedPosition;
|
||
|
|
rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;
|
||
|
|
rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;
|
||
|
|
mvPosition.xy += rotatedPosition;
|
||
|
|
gl_Position = projectionMatrix * mvPosition;
|
||
|
|
#include <logdepthbuf_vertex>
|
||
|
|
#include <clipping_planes_vertex>
|
||
|
|
#include <fog_vertex>
|
||
|
|
}`,at={alphamap_fragment:y1,alphamap_pars_fragment:v1,alphatest_fragment:x1,aomap_fragment:b1,aomap_pars_fragment:w1,begin_vertex:S1,beginnormal_vertex:M1,bsdfs:A1,bumpmap_pars_fragment:_1,clipping_planes_fragment:T1,clipping_planes_pars_fragment:E1,clipping_planes_pars_vertex:N1,clipping_planes_vertex:C1,color_fragment:L1,color_pars_fragment:I1,color_pars_vertex:P1,color_vertex:D1,common:R1,cube_uv_reflection_fragment:B1,defaultnormal_vertex:O1,displacementmap_pars_vertex:F1,displacementmap_vertex:z1,emissivemap_fragment:G1,emissivemap_pars_fragment:U1,encodings_fragment:k1,encodings_pars_fragment:V1,envmap_fragment:H1,envmap_common_pars_fragment:j1,envmap_pars_fragment:W1,envmap_pars_vertex:J1,envmap_physical_pars_fragment:iT,envmap_vertex:X1,fog_vertex:q1,fog_pars_vertex:Y1,fog_fragment:K1,fog_pars_fragment:Q1,gradientmap_pars_fragment:Z1,lightmap_fragment:$1,lightmap_pars_fragment:eT,lights_lambert_vertex:tT,lights_pars_begin:nT,lights_toon_fragment:rT,lights_toon_pars_fragment:sT,lights_phong_fragment:oT,lights_phong_pars_fragment:aT,lights_physical_fragment:lT,lights_physical_pars_fragment:cT,lights_fragment_begin:uT,lights_fragment_maps:hT,lights_fragment_end:dT,logdepthbuf_fragment:fT,logdepthbuf_pars_fragment:pT,logdepthbuf_pars_vertex:mT,logdepthbuf_vertex:gT,map_fragment:yT,map_pars_fragment:vT,map_particle_fragment:xT,map_particle_pars_fragment:bT,metalnessmap_fragment:wT,metalnessmap_pars_fragment:ST,morphnormal_vertex:MT,morphtarget_pars_vertex:AT,morphtarget_vertex:_T,normal_fragment_begin:TT,normal_fragment_maps:ET,normalmap_pars_fragment:NT,clearcoat_normal_fragment_begin:CT,clearcoat_normal_fragment_maps:LT,clearcoat_pars_fragment:IT,packing:PT,premultiplied_alpha_fragment:DT,project_vertex:RT,dithering_fragment:BT,dithering_pars_fragment:OT,roughnessmap_fragment:FT,roughnessmap_pars_fragment:zT,shadowmap_pars_fragment:GT,shadowmap_pars_vertex:UT,shadowmap_vertex:kT,shadowmask_pars_fragment:VT,skinbase_vertex:HT,skinning_pars_vertex:jT,skinning_vertex:WT,skinnormal_vertex:JT,specularmap_fragment:XT,specularmap_pars_fragment:qT,tonemapping_fragment:YT,tonemapping_pars_fragment:KT,transmission_fragment:QT,transmission_pars_fragment:ZT,uv_pars_fragment:$T,uv_pars_vertex:eE,uv_vertex:tE,uv2_pars_fragment:nE,uv2_pars_vertex:iE,uv2_vertex:rE,worldpos_vertex:sE,background_frag:oE,background_vert:aE,cube_frag:lE,cube_vert:cE,depth_frag:uE,depth_vert:hE,distanceRGBA_frag:dE,distanceRGBA_vert:fE,equirect_frag:pE,equirect_vert:mE,linedashed_frag:gE,linedashed_vert:yE,meshbasic_frag:vE,meshbasic_vert:xE,meshlambert_frag:bE,meshlambert_vert:wE,meshmatcap_frag:SE,meshmatcap_vert:ME,meshtoon_frag:AE,meshtoon_vert:_E,meshphong_frag:TE,meshphong_vert:EE,meshphysical_frag:NE,meshphysical_vert:CE,normal_frag:LE,normal_vert:IE,points_frag:PE,points_vert:DE,shadow_frag:RE,shadow_vert:BE,sprite_frag:OE,sprite_vert:FE},be={common:{diffuse:{value:new fe(16777215)},opacity:{value:1},map:{value:null},uvTransform:{value:new Dt},uv2Transform:{value:new Dt},alphaMap:{value:null}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},refractionRatio:{value:.98},maxMipLevel:{value:0}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new O(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new fe(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLight
|
||
|
|
|
||
|
|
precision mediump float;
|
||
|
|
precision mediump int;
|
||
|
|
|
||
|
|
varying vec3 vOutputDirection;
|
||
|
|
|
||
|
|
uniform sampler2D envMap;
|
||
|
|
uniform int samples;
|
||
|
|
uniform float weights[ n ];
|
||
|
|
uniform bool latitudinal;
|
||
|
|
uniform float dTheta;
|
||
|
|
uniform float mipInt;
|
||
|
|
uniform vec3 poleAxis;
|
||
|
|
|
||
|
|
${Bf()}
|
||
|
|
|
||
|
|
#define ENVMAP_TYPE_CUBE_UV
|
||
|
|
#include <cube_uv_reflection_fragment>
|
||
|
|
|
||
|
|
vec3 getSample( float theta, vec3 axis ) {
|
||
|
|
|
||
|
|
float cosTheta = cos( theta );
|
||
|
|
// Rodrigues' axis-angle rotation
|
||
|
|
vec3 sampleDirection = vOutputDirection * cosTheta
|
||
|
|
+ cross( axis, vOutputDirection ) * sin( theta )
|
||
|
|
+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );
|
||
|
|
|
||
|
|
return bilinearCubeUV( envMap, sampleDirection, mipInt );
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
void main() {
|
||
|
|
|
||
|
|
vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );
|
||
|
|
|
||
|
|
if ( all( equal( axis, vec3( 0.0 ) ) ) ) {
|
||
|
|
|
||
|
|
axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
axis = normalize( axis );
|
||
|
|
|
||
|
|
gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
|
||
|
|
gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );
|
||
|
|
|
||
|
|
for ( int i = 1; i < n; i++ ) {
|
||
|
|
|
||
|
|
if ( i >= samples ) {
|
||
|
|
|
||
|
|
break;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
float theta = dTheta * float( i );
|
||
|
|
gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
|
||
|
|
gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
gl_FragColor = linearToOutputTexel( gl_FragColor );
|
||
|
|
|
||
|
|
}
|
||
|
|
`,blending:It,depthTest:!1,depthWrite:!1})}function _y(){let r=new O(1,1);return new fa({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null},texelSize:{value:r},inputEncoding:{value:cr[ln]},outputEncoding:{value:cr[ln]}},vertexShader:Rf(),fragmentShader:`
|
||
|
|
|
||
|
|
precision mediump float;
|
||
|
|
precision mediump int;
|
||
|
|
|
||
|
|
varying vec3 vOutputDirection;
|
||
|
|
|
||
|
|
uniform sampler2D envMap;
|
||
|
|
uniform vec2 texelSize;
|
||
|
|
|
||
|
|
${Bf()}
|
||
|
|
|
||
|
|
#include <common>
|
||
|
|
|
||
|
|
void main() {
|
||
|
|
|
||
|
|
gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
|
||
|
|
|
||
|
|
vec3 outputDirection = normalize( vOutputDirection );
|
||
|
|
vec2 uv = equirectUv( outputDirection );
|
||
|
|
|
||
|
|
vec2 f = fract( uv / texelSize - 0.5 );
|
||
|
|
uv -= f * texelSize;
|
||
|
|
vec3 tl = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;
|
||
|
|
uv.x += texelSize.x;
|
||
|
|
vec3 tr = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;
|
||
|
|
uv.y += texelSize.y;
|
||
|
|
vec3 br = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;
|
||
|
|
uv.x -= texelSize.x;
|
||
|
|
vec3 bl = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;
|
||
|
|
|
||
|
|
vec3 tm = mix( tl, tr, f.x );
|
||
|
|
vec3 bm = mix( bl, br, f.x );
|
||
|
|
gl_FragColor.rgb = mix( tm, bm, f.y );
|
||
|
|
|
||
|
|
gl_FragColor = linearToOutputTexel( gl_FragColor );
|
||
|
|
|
||
|
|
}
|
||
|
|
`,blending:It,depthTest:!1,depthWrite:!1})}function Ty(){return new fa({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},inputEncoding:{value:cr[ln]},outputEncoding:{value:cr[ln]}},vertexShader:Rf(),fragmentShader:`
|
||
|
|
|
||
|
|
precision mediump float;
|
||
|
|
precision mediump int;
|
||
|
|
|
||
|
|
varying vec3 vOutputDirection;
|
||
|
|
|
||
|
|
uniform samplerCube envMap;
|
||
|
|
|
||
|
|
${Bf()}
|
||
|
|
|
||
|
|
void main() {
|
||
|
|
|
||
|
|
gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
|
||
|
|
gl_FragColor.rgb = envMapTexelToLinear( textureCube( envMap, vec3( - vOutputDirection.x, vOutputDirection.yz ) ) ).rgb;
|
||
|
|
gl_FragColor = linearToOutputTexel( gl_FragColor );
|
||
|
|
|
||
|
|
}
|
||
|
|
`,blending:It,depthTest:!1,depthWrite:!1})}function Rf(){return`
|
||
|
|
|
||
|
|
precision mediump float;
|
||
|
|
precision mediump int;
|
||
|
|
|
||
|
|
attribute vec3 position;
|
||
|
|
attribute vec2 uv;
|
||
|
|
attribute float faceIndex;
|
||
|
|
|
||
|
|
varying vec3 vOutputDirection;
|
||
|
|
|
||
|
|
// RH coordinate system; PMREM face-indexing convention
|
||
|
|
vec3 getDirection( vec2 uv, float face ) {
|
||
|
|
|
||
|
|
uv = 2.0 * uv - 1.0;
|
||
|
|
|
||
|
|
vec3 direction = vec3( uv, 1.0 );
|
||
|
|
|
||
|
|
if ( face == 0.0 ) {
|
||
|
|
|
||
|
|
direction = direction.zyx; // ( 1, v, u ) pos x
|
||
|
|
|
||
|
|
} else if ( face == 1.0 ) {
|
||
|
|
|
||
|
|
direction = direction.xzy;
|
||
|
|
direction.xz *= -1.0; // ( -u, 1, -v ) pos y
|
||
|
|
|
||
|
|
} else if ( face == 2.0 ) {
|
||
|
|
|
||
|
|
direction.x *= -1.0; // ( -u, v, 1 ) pos z
|
||
|
|
|
||
|
|
} else if ( face == 3.0 ) {
|
||
|
|
|
||
|
|
direction = direction.zyx;
|
||
|
|
direction.xz *= -1.0; // ( -1, v, -u ) neg x
|
||
|
|
|
||
|
|
} else if ( face == 4.0 ) {
|
||
|
|
|
||
|
|
direction = direction.xzy;
|
||
|
|
direction.xy *= -1.0; // ( -u, -1, v ) neg y
|
||
|
|
|
||
|
|
} else if ( face == 5.0 ) {
|
||
|
|
|
||
|
|
direction.z *= -1.0; // ( u, v, -1 ) neg z
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
return direction;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
void main() {
|
||
|
|
|
||
|
|
vOutputDirection = getDirection( uv, faceIndex );
|
||
|
|
gl_Position = vec4( position, 1.0 );
|
||
|
|
|
||
|
|
}
|
||
|
|
`}function Bf(){return`
|
||
|
|
|
||
|
|
uniform int inputEncoding;
|
||
|
|
uniform int outputEncoding;
|
||
|
|
|
||
|
|
#include <encodings_pars_fragment>
|
||
|
|
|
||
|
|
vec4 inputTexelToLinear( vec4 value ) {
|
||
|
|
|
||
|
|
if ( inputEncoding == 0 ) {
|
||
|
|
|
||
|
|
return value;
|
||
|
|
|
||
|
|
} else if ( inputEncoding == 1 ) {
|
||
|
|
|
||
|
|
return sRGBToLinear( value );
|
||
|
|
|
||
|
|
} else if ( inputEncoding == 2 ) {
|
||
|
|
|
||
|
|
return RGBEToLinear( value );
|
||
|
|
|
||
|
|
} else if ( inputEncoding == 3 ) {
|
||
|
|
|
||
|
|
return RGBMToLinear( value, 7.0 );
|
||
|
|
|
||
|
|
} else if ( inputEncoding == 4 ) {
|
||
|
|
|
||
|
|
return RGBMToLinear( value, 16.0 );
|
||
|
|
|
||
|
|
} else if ( inputEncoding == 5 ) {
|
||
|
|
|
||
|
|
return RGBDToLinear( value, 256.0 );
|
||
|
|
|
||
|
|
} else {
|
||
|
|
|
||
|
|
return GammaToLinear( value, 2.2 );
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
vec4 linearToOutputTexel( vec4 value ) {
|
||
|
|
|
||
|
|
if ( outputEncoding == 0 ) {
|
||
|
|
|
||
|
|
return value;
|
||
|
|
|
||
|
|
} else if ( outputEncoding == 1 ) {
|
||
|
|
|
||
|
|
return LinearTosRGB( value );
|
||
|
|
|
||
|
|
} else if ( outputEncoding == 2 ) {
|
||
|
|
|
||
|
|
return LinearToRGBE( value );
|
||
|
|
|
||
|
|
} else if ( outputEncoding == 3 ) {
|
||
|
|
|
||
|
|
return LinearToRGBM( value, 7.0 );
|
||
|
|
|
||
|
|
} else if ( outputEncoding == 4 ) {
|
||
|
|
|
||
|
|
return LinearToRGBM( value, 16.0 );
|
||
|
|
|
||
|
|
} else if ( outputEncoding == 5 ) {
|
||
|
|
|
||
|
|
return LinearToRGBD( value, 256.0 );
|
||
|
|
|
||
|
|
} else {
|
||
|
|
|
||
|
|
return LinearToGamma( value, 2.2 );
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
vec4 envMapTexelToLinear( vec4 color ) {
|
||
|
|
|
||
|
|
return inputTexelToLinear( color );
|
||
|
|
|
||
|
|
}
|
||
|
|
`}function qE(r){let e=new WeakMap,t=null;function n(a){if(a&&a.isTexture&&a.isRenderTargetTexture===!1){let l=a.mapping,c=l===vu||l===xu,u=l===js||l===Ws;if(c||u){if(e.has(a))return e.get(a).texture;{let h=a.image;if(c&&h&&h.height>0||u&&h&&i(h)){let d=r.getRenderTarget();t===null&&(t=new My(r));let f=c?t.fromEquirectangular(a):t.fromCubemap(a);return e.set(a,f),r.setRenderTarget(d),a.addEventListener("dispose",s),f.texture}else return null}}}return a}function i(a){let l=0,c=6;for(let u=0;u<c;u++)a[u]!==void 0&&l++;return l===c}function s(a){let l=a.target;l.removeEventListener("dispose",s);let c=e.get(l);c!==void 0&&(c.delete(l),c.dispose())}function o(){e=new WeakMap,t!==null&&(t.dispose(),t=null)}return{get:n,dispose:o}}function YE(r){let e={};function t(n){if(e[n]!==void 0)return e[n];let i;switch(n){case"WEBGL_depth_texture":i=r.getExtension("WEBGL_depth_texture")||r.getExtension("MOZ_WEBGL_depth_texture")||r.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":i=r.getExtension("EXT_texture_filter_anisotropic")||r.getExtension("MOZ_EXT_texture_filter_anisotropic")||r.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":i=r.getExtension("WEBGL_compressed_texture_s3tc")||r.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||r.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":i=r.getExtension("WEBGL_compressed_texture_pvrtc")||r.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:i=r.getExtension(n)}return e[n]=i,i}return{has:function(n){return t(n)!==null},init:function(n){n.isWebGL2?t("EXT_color_buffer_float"):(t("WEBGL_depth_texture"),t("OES_texture_float"),t("OES_texture_half_float"),t("OES_texture_half_float_linear"),t("OES_standard_derivatives"),t("OES_element_index_uint"),t("OES_vertex_array_object"),t("ANGLE_instanced_arrays")),t("OES_texture_float_linear"),t("EXT_color_buffer_half_float")},get:function(n){let i=t(n);return i===null&&console.warn("THREE.WebGLRenderer: "+n+" extension not supported."),i}}}function KE(r,e,t,n){let i={},s=new WeakMap;function o(h){let d=h.target;d.index!==null&&e.remove(d.index);for(let p in d.attributes)e.remove(d.attributes[p]);d.removeEventListener("dispose",o),delete i[d.id];let f=s.get(d);f&&(e.remove(f),s.delete(d)),n.releaseStatesOfGeometry(d),d.isInstancedBufferGeometry===!0&&delete d._maxInstanceCount,t.memory.geometries--}function a(h,d){return i[d.id]===!0||(d.addEventListener("dispose",o),i[d.id]=!0,t.memory.geometries++),d}function l(h){let d=h.attributes;for(let p in d)e.update(d[p],34962);let f=h.morphAttributes;for(let p in f){let m=f[p];for(let v=0,g=m.length;v<g;v++)e.update(m[v],34962)}}function c(h){let d=[],f=h.index,p=h.attributes.position,m=0;if(f!==null){let y=f.array;m=f.version;for(let x=0,b=y.length;x<b;x+=3){let w=y[x+0],_=y[x+1],S=y[x+2];d.push(w,_,_,S,S,w)}}else{let y=p.array;m=p.version;for(let x=0,b=y.length/3-1;x<b;x+=3){let w=x+0,_=x+1,S=x+2;d.push(w,_,_,S,S,w)}}let v=new(py(d)>65535?is:Mf)(d,1);v.version=m;let g=s.get(h);g&&e.remove(g),s.set(h,v)}function u(h){let d=s.get(h);if(d){let f=h.index;f!==null&&d.version<f.version&&c(h)}else c(h);return s.get(h)}return{get:a,update:l,getWireframeAttribute:u}}function QE(r,e,t,n){let i=n.isWebGL2,s;function o(d){s=d}let a,l;function c(d){a=d.type,l=d.bytesPerElement}function u(d,f){r.drawElements(s,f,a,d*l),t.update(f,s,1)}function h(d,f,p){if(p===0)return;let m,v;if(i)m=r,v="drawElementsInstanced";else if(m=e.get("ANGLE_instanced_arrays"),v="drawElementsInstancedANGLE",m===null){console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}m[v](s,f,a,d*l,p),t.update(f,s,p)}this.setMode=o,this.setIndex=c,this.render=u,this.renderInstances=h}function ZE(r){let e={geometries:0,textures:0},t={frame:0,calls:0,triangles:0,points:0,lines:0};function n(s,o,a){switch(t.calls++,o){case 4:t.triangles+=a*(s/3);break;case 1:t.lines+=a*(s/2);break;case 3:t.lines+=a*(s-1);break;case 2:t
|
||
|
|
`);for(let t=0;t<e.length;t++)e[t]=t+1+": "+e[t];return e.join(`
|
||
|
|
`)}function Gy(r){switch(r){case ln:return["Linear","( value )"];case Fi:return["sRGB","( value )"];case Rl:return["RGBE","( value )"];case Mu:return["RGBM","( value, 7.0 )"];case Au:return["RGBM","( value, 16.0 )"];case _u:return["RGBD","( value, 256.0 )"];case Qs:return["Gamma","( value, float( GAMMA_FACTOR ) )"];case F_:return["LogLuv","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",r),["Linear","( value )"]}}function Uy(r,e,t){let n=r.getShaderParameter(e,35713),i=r.getShaderInfoLog(e).trim();if(n&&i==="")return"";let s=r.getShaderSource(e);return"THREE.WebGLShader: gl.getShaderInfoLog() "+t+`
|
||
|
|
`+i+JN(s)}function va(r,e){let t=Gy(e);return"vec4 "+r+"( vec4 value ) { return "+t[0]+"ToLinear"+t[1]+"; }"}function XN(r,e){let t=Gy(e);return"vec4 "+r+"( vec4 value ) { return LinearTo"+t[0]+t[1]+"; }"}function qN(r,e){let t;switch(e){case zA:t="Linear";break;case GA:t="Reinhard";break;case UA:t="OptimizedCineon";break;case kA:t="ACESFilmic";break;case VA:t="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",e),t="Linear"}return"vec3 "+r+"( vec3 color ) { return "+t+"ToneMapping( color ); }"}function YN(r){return[r.extensionDerivatives||r.envMapCubeUV||r.bumpMap||r.tangentSpaceNormalMap||r.clearcoatNormalMap||r.flatShading||r.shaderID==="physical"?"#extension GL_OES_standard_derivatives : enable":"",(r.extensionFragDepth||r.logarithmicDepthBuffer)&&r.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",r.extensionDrawBuffers&&r.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(r.extensionShaderTextureLOD||r.envMap||r.transmission>0)&&r.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter(jl).join(`
|
||
|
|
`)}function KN(r){let e=[];for(let t in r){let n=r[t];n!==!1&&e.push("#define "+t+" "+n)}return e.join(`
|
||
|
|
`)}function QN(r,e){let t={},n=r.getProgramParameter(e,35721);for(let i=0;i<n;i++){let o=r.getActiveAttrib(e,i).name;t[o]=r.getAttribLocation(e,o)}return t}function jl(r){return r!==""}function ky(r,e){return r.replace(/NUM_DIR_LIGHTS/g,e.numDirLights).replace(/NUM_SPOT_LIGHTS/g,e.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,e.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,e.numPointLights).replace(/NUM_HEMI_LIGHTS/g,e.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,e.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,e.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,e.numPointLightShadows)}function Vy(r,e){return r.replace(/NUM_CLIPPING_PLANES/g,e.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,e.numClippingPlanes-e.numClipIntersection)}var ZN=/^[ \t]*#include +<([\w\d./]+)>/gm;function zf(r){return r.replace(ZN,$N)}function $N(r,e){let t=at[e];if(t===void 0)throw new Error("Can not resolve #include <"+e+">");return zf(t)}var eC=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,tC=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function Hy(r){return r.replace(tC,jy).replace(eC,nC)}function nC(r,e,t,n){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),jy(r,e,t,n)}function jy(r,e,t,n){let i="";for(let s=parseInt(e);s<parseInt(t);s++)i+=n.replace(/\[\s*i\s*\]/g,"[ "+s+" ]").replace(/UNROLLED_LOOP_INDEX/g,s);return i}function Wy(r){let e="precision "+r.precision+` float;
|
||
|
|
precision `+r.precision+" int;";return r.precision==="highp"?e+=`
|
||
|
|
#define HIGH_PRECISION`:r.precision==="mediump"?e+=`
|
||
|
|
#define MEDIUM_PRECISION`:r.precision==="lowp"&&(e+=`
|
||
|
|
#define LOW_PRECISION`),e}function iC(r){let e="SHADOWMAP_TYPE_BASIC";return r.shadowMapType===Pg?e="SHADOWMAP_TYPE_PCF":r.shadowMapType===qd?e="SHADOWMAP_TYPE_PCF_SOFT":r.shadowMapType===Dl&&(e="SHADOWMAP_TYPE_VSM"),e}function rC(r){let e="ENVMAP_TYPE_CUBE";if(r.envMap)switch(r.envMapMode){case js:case Ws:e="ENVMAP_TYPE_CUBE";break;case Js:case Ho:e="ENVMAP_TYPE_CUBE_UV";break}return e}function sC(r){let e="ENVMAP_MODE_REFLECTION";if(r.envMap)switch(r.envMapMode){case Ws:case Ho:e="ENVMAP_MODE_REFRACTION";break}return e}function oC(r){let e="ENVMAP_BLENDING_NONE";if(r.envMap)switch(r.combine){case yu:e="ENVMAP_BLENDING_MULTIPLY";break;case OA:e="ENVMAP_BLENDING_MIX";break;case FA:e="ENVMAP_BLENDING_ADD";break}return e}function aC(r,e,t,n){let i=r.getContext(),s=t.defines,o=t.vertexShader,a=t.fragmentShader,l=iC(t),c=rC(t),u=sC(t),h=oC(t),d=r.gammaFactor>0?r.gammaFactor:1,f=t.isWebGL2?"":YN(t),p=KN(s),m=i.createProgram(),v,g,y=t.glslVersion?"#version "+t.glslVersion+`
|
||
|
|
`:"";t.isRawShaderMaterial?(v=[p].filter(jl).join(`
|
||
|
|
`),v.length>0&&(v+=`
|
||
|
|
`),g=[f,p].filter(jl).join(`
|
||
|
|
`),g.length>0&&(g+=`
|
||
|
|
`)):(v=[Wy(t),"#define SHADER_NAME "+t.shaderName,p,t.instancing?"#define USE_INSTANCING":"",t.instancingColor?"#define USE_INSTANCING_COLOR":"",t.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define GAMMA_FACTOR "+d,"#define MAX_BONES "+t.maxBones,t.useFog&&t.fog?"#define USE_FOG":"",t.useFog&&t.fogExp2?"#define FOG_EXP2":"",t.map?"#define USE_MAP":"",t.envMap?"#define USE_ENVMAP":"",t.envMap?"#define "+u:"",t.lightMap?"#define USE_LIGHTMAP":"",t.aoMap?"#define USE_AOMAP":"",t.emissiveMap?"#define USE_EMISSIVEMAP":"",t.bumpMap?"#define USE_BUMPMAP":"",t.normalMap?"#define USE_NORMALMAP":"",t.normalMap&&t.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",t.normalMap&&t.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",t.clearcoatMap?"#define USE_CLEARCOATMAP":"",t.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",t.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",t.displacementMap&&t.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",t.specularMap?"#define USE_SPECULARMAP":"",t.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",t.specularTintMap?"#define USE_SPECULARTINTMAP":"",t.roughnessMap?"#define USE_ROUGHNESSMAP":"",t.metalnessMap?"#define USE_METALNESSMAP":"",t.alphaMap?"#define USE_ALPHAMAP":"",t.transmission?"#define USE_TRANSMISSION":"",t.transmissionMap?"#define USE_TRANSMISSIONMAP":"",t.thicknessMap?"#define USE_THICKNESSMAP":"",t.vertexTangents?"#define USE_TANGENT":"",t.vertexColors?"#define USE_COLOR":"",t.vertexAlphas?"#define USE_COLOR_ALPHA":"",t.vertexUvs?"#define USE_UV":"",t.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",t.flatShading?"#define FLAT_SHADED":"",t.skinning?"#define USE_SKINNING":"",t.useVertexTexture?"#define BONE_TEXTURE":"",t.morphTargets?"#define USE_MORPHTARGETS":"",t.morphNormals&&t.flatShading===!1?"#define USE_MORPHNORMALS":"",t.doubleSided?"#define DOUBLE_SIDED":"",t.flipSided?"#define FLIP_SIDED":"",t.shadowMapEnabled?"#define USE_SHADOWMAP":"",t.shadowMapEnabled?"#define "+l:"",t.sizeAttenuation?"#define USE_SIZEATTENUATION":"",t.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",t.logarithmicDepthBuffer&&t.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING"," attribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR"," attribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT"," attribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )"," attribute vec4 color;","#elif defined( USE_COLOR )"," attribute vec3 color;","#endif","#ifdef USE_MORPHTARGETS"," attribute vec3 morphTarget0;"," attribute vec3 morphTarget1;"," attribute vec3 morphTarget2;"," attribute vec3 morphTarget3;"," #ifdef USE_MORPHNORMALS"," attribute vec3 morphNormal0;"," attribute vec3 morphNormal1;"," attribute vec3 morphNormal2;"," attribute vec3 morphNormal3;"," #else"," attribute vec3 morphTarget4;"," attribute vec3 morphTarget5;"," attribute vec3 morphTarget6;"," attribute vec3 morphTarget7;"," #endif","#endif","#ifdef USE_SKINNING"," attribute vec4 skinIndex;"," attribute vec4 skinWeight;","#endif",`
|
||
|
|
`].filter(jl).join(`
|
||
|
|
`),g=[f,Wy(t),"#define SHADER_NAME "+t.shaderName,p,t.alphaTest?"#define ALPHATEST "+t.alphaTest+(t.alphaTest%1?"":".0"):"","#define GAMMA_FACTOR "+d,t.useFog&&t.fog?"#define USE_FOG":"",t.useFog&&t.fogExp2?"#define FOG_EXP2":"",t.map?"#define USE_MAP":"",t.matcap?"#define USE_MATCAP":"",t.envMap?"#define USE_ENVMAP":"",t.envMap?"#define "+c:"",t.envMap?"#define "+u:"",t.envMap?"#define "+h:"",t.lightMap?"#define USE_LIGHTMAP":"",t.aoMap?"#define USE_AOMAP":"",t.emissiveMap?"#define USE_EMISSIVEMAP":"",t.bumpMap?"#define USE_BUMPMAP":"",t.normalMap?"#define USE_NORMALMAP":"",t.normalMap&&t.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",t.normalMap&&t.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",t.clearcoatMap?"#define USE_CLEARCOATMAP":"",t.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",t.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",t.specularMap?"#define USE_SPECULARMAP":"",t.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",t.specularTintMap?"#define USE_SPECULARTINTMAP":"",t.roughnessMap?"#define USE_ROUGHNESSMAP":"",t.metalnessMap?"#define USE_METALNESSMAP":"",t.alphaMap?"#define USE_ALPHAMAP":"",t.sheen?"#define USE_SHEEN":"",t.transmission?"#define USE_TRANSMISSION":"",t.transmissionMap?"#define USE_TRANSMISSIONMAP":"",t.thicknessMap?"#define USE_THICKNESSMAP":"",t.vertexTangents?"#define USE_TANGENT":"",t.vertexColors||t.instancingColor?"#define USE_COLOR":"",t.vertexAlphas?"#define USE_COLOR_ALPHA":"",t.vertexUvs?"#define USE_UV":"",t.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",t.gradientMap?"#define USE_GRADIENTMAP":"",t.flatShading?"#define FLAT_SHADED":"",t.doubleSided?"#define DOUBLE_SIDED":"",t.flipSided?"#define FLIP_SIDED":"",t.shadowMapEnabled?"#define USE_SHADOWMAP":"",t.shadowMapEnabled?"#define "+l:"",t.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",t.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",t.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",t.logarithmicDepthBuffer&&t.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(t.extensionShaderTextureLOD||t.envMap)&&t.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",t.toneMapping!==Hs?"#define TONE_MAPPING":"",t.toneMapping!==Hs?at.tonemapping_pars_fragment:"",t.toneMapping!==Hs?qN("toneMapping",t.toneMapping):"",t.dithering?"#define DITHERING":"",at.encodings_pars_fragment,t.map?va("mapTexelToLinear",t.mapEncoding):"",t.matcap?va("matcapTexelToLinear",t.matcapEncoding):"",t.envMap?va("envMapTexelToLinear",t.envMapEncoding):"",t.emissiveMap?va("emissiveMapTexelToLinear",t.emissiveMapEncoding):"",t.specularTintMap?va("specularTintMapTexelToLinear",t.specularTintMapEncoding):"",t.lightMap?va("lightMapTexelToLinear",t.lightMapEncoding):"",XN("linearToOutputTexel",t.outputEncoding),t.depthPacking?"#define DEPTH_PACKING "+t.depthPacking:"",`
|
||
|
|
`].filter(jl).join(`
|
||
|
|
`)),o=zf(o),o=ky(o,t),o=Vy(o,t),a=zf(a),a=ky(a,t),a=Vy(a,t),o=Hy(o),a=Hy(a),t.isWebGL2&&t.isRawShaderMaterial!==!0&&(y=`#version 300 es
|
||
|
|
`,v=["#define attribute in","#define varying out","#define texture2D texture"].join(`
|
||
|
|
`)+`
|
||
|
|
`+v,g=["#define varying in",t.glslVersion===Zg?"":"out highp vec4 pc_fragColor;",t.glslVersion===Zg?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join(`
|
||
|
|
`)+`
|
||
|
|
`+g);let x=y+v+o,b=y+g+a,w=zy(i,35633,x),_=zy(i,35632,b);if(i.attachShader(m,w),i.attachShader(m,_),t.index0AttributeName!==void 0?i.bindAttribLocation(m,0,t.index0AttributeName):t.morphTargets===!0&&i.bindAttribLocation(m,0,"position"),i.linkProgram(m),r.debug.checkShaderErrors){let T=i.getProgramInfoLog(m).trim(),L=i.getShaderInfoLog(w).trim(),C=i.getShaderInfoLog(_).trim(),U=!0,P=!0;if(i.getProgramParameter(m,35714)===!1){U=!1;let R=Uy(i,w,"vertex"),G=Uy(i,_,"fragment");console.error("THREE.WebGLProgram: shader error: ",i.getError(),"35715",i.getProgramParameter(m,35715),"gl.getProgramInfoLog",T,R,G)}else T!==""?console.warn("THREE.WebGLProgram: gl.getProgramInfoLog()",T):(L===""||C==="")&&(P=!1);P&&(this.diagnostics={runnable:U,programLog:T,vertexShader:{log:L,prefix:v},fragmentShader:{log:C,prefix:g}})}i.deleteShader(w),i.deleteShader(_);let S;this.getUniforms=function(){return S===void 0&&(S=new us(i,m)),S};let A;return this.getAttributes=function(){return A===void 0&&(A=QN(i,m)),A},this.destroy=function(){n.releaseStatesOfProgram(this),i.deleteProgram(m),this.program=void 0},this.name=t.shaderName,this.id=WN++,this.cacheKey=e,this.usedTimes=1,this.program=m,this.vertexShader=w,this.fragmentShader=_,this}function lC(r,e,t,n,i,s,o){let a=[],l=i.isWebGL2,c=i.logarithmicDepthBuffer,u=i.floatVertexTextures,h=i.maxVertexUniforms,d=i.vertexTextures,f=i.precision,p={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"},m=["precision","isWebGL2","supportsVertexTextures","outputEncoding","instancing","instancingColor","map","mapEncoding","matcap","matcapEncoding","envMap","envMapMode","envMapEncoding","envMapCubeUV","lightMap","lightMapEncoding","aoMap","emissiveMap","emissiveMapEncoding","bumpMap","normalMap","objectSpaceNormalMap","tangentSpaceNormalMap","clearcoatMap","clearcoatRoughnessMap","clearcoatNormalMap","displacementMap","specularMap","specularIntensityMap","specularTintMap","specularTintMapEncoding","roughnessMap","metalnessMap","gradientMap","alphaMap","combine","vertexColors","vertexAlphas","vertexTangents","vertexUvs","uvsVertexOnly","fog","useFog","fogExp2","flatShading","sizeAttenuation","logarithmicDepthBuffer","skinning","maxBones","useVertexTexture","morphTargets","morphNormals","premultipliedAlpha","numDirLights","numPointLights","numSpotLights","numHemiLights","numRectAreaLights","numDirLightShadows","numPointLightShadows","numSpotLightShadows","shadowMapEnabled","shadowMapType","toneMapping","physicallyCorrectLights","alphaTest","doubleSided","flipSided","numClippingPlanes","numClipIntersection","depthPacking","dithering","sheen","transmission","transmissionMap","thicknessMap"];function v(S){let T=S.skeleton.bones;if(u)return 1024;{let C=Math.floor((h-20)/4),U=Math.min(C,T.length);return U<T.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+T.length+" bones. This GPU supports "+U+"."),0):U}}function g(S){let A;return S&&S.isTexture?A=S.encoding:S&&S.isWebGLRenderTarget?(console.warn("THREE.WebGLPrograms.getTextureEncodingFromMap: don't use render targets as textures. Use their .texture property instead."),A=S.texture.encoding):A=ln,A}function y(S,A,T,L,C){let U=L.fog,P=S.isMeshStandardMaterial?L.environment:null,R=(S.isMeshStandardMaterial?t:e).get(S.envMap||P),G=p[S.type],B=C.isSkinnedMesh?v(C):0;S.precision!==null&&(f=i.getMaxPrecision(S.precision),f!==S.precision&&console.warn("THREE.WebGLProgram.getParameters:",S.precision,"not supported, using",f,"instead."));let j,ne;if(G){let z=ar[G];j=z.vertexShader,ne=z.fragmentShader}else j=S.vertexShader,ne=S.fragmentShader;let le=r.getRenderTarget();return{isWebGL2:l,shaderID:G,shaderName:S.type,vertexShader:j,fragmentShader:ne,defines:S.defines,isRawShaderMaterial:S.isRawShaderMaterial===!0,
|
||
|
|
uniform vec2 resolution;
|
||
|
|
uniform float radius;
|
||
|
|
#include <packing>
|
||
|
|
void main() {
|
||
|
|
float mean = 0.0;
|
||
|
|
float squared_mean = 0.0;
|
||
|
|
float depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy ) / resolution ) );
|
||
|
|
for ( float i = -1.0; i < 1.0 ; i += SAMPLE_RATE) {
|
||
|
|
#ifdef HORIZONTAL_PASS
|
||
|
|
vec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( i, 0.0 ) * radius ) / resolution ) );
|
||
|
|
mean += distribution.x;
|
||
|
|
squared_mean += distribution.y * distribution.y + distribution.x * distribution.x;
|
||
|
|
#else
|
||
|
|
float depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, i ) * radius ) / resolution ) );
|
||
|
|
mean += depth;
|
||
|
|
squared_mean += depth * depth;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
mean = mean * HALF_SAMPLE_RATE;
|
||
|
|
squared_mean = squared_mean * HALF_SAMPLE_RATE;
|
||
|
|
float std_dev = sqrt( squared_mean - mean * mean );
|
||
|
|
gl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );
|
||
|
|
}`,xC=`void main() {
|
||
|
|
gl_Position = vec4( position, 1.0 );
|
||
|
|
}`;function Yy(r,e,t){let n=new Vl,i=new O,s=new O,o=new Qe,a=new Yu({depthPacking:z_}),l=new Ku,c={},u=t.maxTextureSize,h={0:kt,1:Oi,2:Xt},d=new _t({defines:{SAMPLE_RATE:2/8,HALF_SAMPLE_RATE:1/8},uniforms:{shadow_pass:{value:null},resolution:{value:new O},radius:{value:4}},vertexShader:xC,fragmentShader:vC}),f=d.clone();f.defines.HORIZONTAL_PASS=1;let p=new we;p.setAttribute("position",new Re(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));let m=new gt(p,d),v=this;this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=Pg,this.render=function(b,w,_){if(v.enabled===!1||v.autoUpdate===!1&&v.needsUpdate===!1||b.length===0)return;let S=r.getRenderTarget(),A=r.getActiveCubeFace(),T=r.getActiveMipmapLevel(),L=r.state;L.setBlending(It),L.buffers.color.setClear(1,1,1,1),L.buffers.depth.setTest(!0),L.setScissorTest(!1);for(let C=0,U=b.length;C<U;C++){let P=b[C],R=P.shadow;if(R===void 0){console.warn("THREE.WebGLShadowMap:",P,"has no shadow.");continue}if(R.autoUpdate===!1&&R.needsUpdate===!1)continue;i.copy(R.mapSize);let G=R.getFrameExtents();if(i.multiply(G),s.copy(R.mapSize),(i.x>u||i.y>u)&&(i.x>u&&(s.x=Math.floor(u/G.x),i.x=s.x*G.x,R.mapSize.x=s.x),i.y>u&&(s.y=Math.floor(u/G.y),i.y=s.y*G.y,R.mapSize.y=s.y)),R.map===null&&!R.isPointLightShadow&&this.type===Dl){let j={minFilter:$e,magFilter:$e,format:zt};R.map=new bt(i.x,i.y,j),R.map.texture.name=P.name+".shadowMap",R.mapPass=new bt(i.x,i.y,j),R.camera.updateProjectionMatrix()}if(R.map===null){let j={minFilter:Pt,magFilter:Pt,format:zt};R.map=new bt(i.x,i.y,j),R.map.texture.name=P.name+".shadowMap",R.camera.updateProjectionMatrix()}r.setRenderTarget(R.map),r.clear();let B=R.getViewportCount();for(let j=0;j<B;j++){let ne=R.getViewport(j);o.set(s.x*ne.x,s.y*ne.y,s.x*ne.z,s.y*ne.w),L.viewport(o),R.updateMatrices(P,j),n=R.getFrustum(),x(w,_,R.camera,P,this.type)}!R.isPointLightShadow&&this.type===Dl&&g(R,_),R.needsUpdate=!1}v.needsUpdate=!1,r.setRenderTarget(S,A,T)};function g(b,w){let _=e.update(m);d.uniforms.shadow_pass.value=b.map.texture,d.uniforms.resolution.value=b.mapSize,d.uniforms.radius.value=b.radius,r.setRenderTarget(b.mapPass),r.clear(),r.renderBufferDirect(w,null,_,d,m,null),f.uniforms.shadow_pass.value=b.mapPass.texture,f.uniforms.resolution.value=b.mapSize,f.uniforms.radius.value=b.radius,r.setRenderTarget(b.map),r.clear(),r.renderBufferDirect(w,null,_,f,m,null)}function y(b,w,_,S,A,T,L){let C=null,U=S.isPointLight===!0?b.customDistanceMaterial:b.customDepthMaterial;if(U!==void 0?C=U:C=S.isPointLight===!0?l:a,r.localClippingEnabled&&_.clipShadows===!0&&_.clippingPlanes.length!==0){let P=C.uuid,R=_.uuid,G=c[P];G===void 0&&(G={},c[P]=G);let B=G[R];B===void 0&&(B=C.clone(),G[R]=B),C=B}return C.visible=_.visible,C.wireframe=_.wireframe,L===Dl?C.side=_.shadowSide!==null?_.shadowSide:_.side:C.side=_.shadowSide!==null?_.shadowSide:h[_.side],C.clipShadows=_.clipShadows,C.clippingPlanes=_.clippingPlanes,C.clipIntersection=_.clipIntersection,C.wireframeLinewidth=_.wireframeLinewidth,C.linewidth=_.linewidth,S.isPointLight===!0&&C.isMeshDistanceMaterial===!0&&(C.referencePosition.setFromMatrixPosition(S.matrixWorld),C.nearDistance=A,C.farDistance=T),C}function x(b,w,_,S,A){if(b.visible===!1)return;if(b.layers.test(w.layers)&&(b.isMesh||b.isLine||b.isPoints)&&(b.castShadow||b.receiveShadow&&A===Dl)&&(!b.frustumCulled||n.intersectsObject(b))){b.modelViewMatrix.multiplyMatrices(_.matrixWorldInverse,b.matrixWorld);let C=e.update(b),U=b.material;if(Array.isArray(U)){let P=C.groups;for(let R=0,G=P.length;R<G;R++){let B=P[R],j=U[B.materialIndex];if(j&&j.visible){let ne=y(b,C,j,S,_.near,_.far,A);r.renderBufferDirect(_,null,C,ne,b,B)}}}else if(U.visible){let P=y(b,C,U,S,_.near,_.far,A);r.renderBufferDirect(_,null,C,P,b,null)}}let L=b.children;for(let C=0,U=L.length;C<U;C++)x(L[C],w,_,S,A)}}function bC(r,e,t){let n=t.isWebGL2;function i(){let J=!1,xe=new Qe,he=null,Ne=new Qe(0,0,0,0);return{setMask:function(Be){he!==Be&&!J&&(r.colorMask(Be,Be,Be,Be),he=Be)},setLocked:function(Be){J=Be},setClear:function(Be,ke,ht,ft,Bn){Bn===!0&&(Be*=ft,ke*=ft,ht*=ft),xe.set(Be,ke,ht,ft),Ne.eq
|
||
|
|
`)a=0,l-=s;else{let h=oL(u,i,a,l,t);a+=h.offsetX,o.push(h.path)}}return o}function oL(r,e,t,n,i){let s=i.glyphs[r]||i.glyphs["?"];if(!s){console.error('THREE.Font: character "'+r+'" does not exists in font family '+i.familyName+".");return}let o=new Vv,a,l,c,u,h,d,f,p;if(s.o){let m=s._cachedOutline||(s._cachedOutline=s.o.split(" "));for(let v=0,g=m.length;v<g;)switch(m[v++]){case"m":a=m[v++]*e+t,l=m[v++]*e+n,o.moveTo(a,l);break;case"l":a=m[v++]*e+t,l=m[v++]*e+n,o.lineTo(a,l);break;case"q":c=m[v++]*e+t,u=m[v++]*e+n,h=m[v++]*e+t,d=m[v++]*e+n,o.quadraticCurveTo(h,d,c,u);break;case"b":c=m[v++]*e+t,u=m[v++]*e+n,h=m[v++]*e+t,d=m[v++]*e+n,f=m[v++]*e+t,p=m[v++]*e+n,o.bezierCurveTo(h,d,f,p,c,u);break}}return{offsetX:s.ha*e,path:o}}_p.prototype.isFont=!0;var Tp=class extends fn{constructor(e){super(e)}load(e,t,n,i){let s=this,o=new Xn(this.manager);o.setPath(this.path),o.setRequestHeader(this.requestHeader),o.setWithCredentials(s.withCredentials),o.load(e,function(a){let l;try{l=JSON.parse(a)}catch(u){console.warn("THREE.FontLoader: typeface.js support is being deprecated. Use typeface.json instead."),l=JSON.parse(a.substring(65,a.length-2))}let c=s.parse(l);t&&t(c)},n,i)}parse(e){return new _p(e)}},xh,aL={getContext:function(){return xh===void 0&&(xh=new(window.AudioContext||window.webkitAudioContext)),xh},setContext:function(r){xh=r}},Hv=class extends fn{constructor(e){super(e)}load(e,t,n,i){let s=this,o=new Xn(this.manager);o.setResponseType("arraybuffer"),o.setPath(this.path),o.setRequestHeader(this.requestHeader),o.setWithCredentials(this.withCredentials),o.load(e,function(a){try{let l=a.slice(0);aL.getContext().decodeAudioData(l,function(u){t(u)})}catch(l){i?i(l):console.error(l),s.manager.itemError(e)}},n,i)}},jv=class extends dc{constructor(e,t,n=1){super(void 0,n);let i=new fe().set(e),s=new fe().set(t),o=new M(i.r,i.g,i.b),a=new M(s.r,s.g,s.b),l=Math.sqrt(Math.PI),c=l*Math.sqrt(.75);this.sh.coefficients[0].copy(o).add(a).multiplyScalar(l),this.sh.coefficients[1].copy(o).sub(a).multiplyScalar(c)}};jv.prototype.isHemisphereLightProbe=!0;var Wv=class extends dc{constructor(e,t=1){super(void 0,t);let n=new fe().set(e);this.sh.coefficients[0].set(n.r,n.g,n.b).multiplyScalar(2*Math.sqrt(Math.PI))}};Wv.prototype.isAmbientLightProbe=!0;var Ep=class{constructor(e=!0){this.autoStart=e,this.startTime=0,this.oldTime=0,this.elapsedTime=0,this.running=!1}start(){this.startTime=Jv(),this.oldTime=this.startTime,this.elapsedTime=0,this.running=!0}stop(){this.getElapsedTime(),this.running=!1,this.autoStart=!1}getElapsedTime(){return this.getDelta(),this.elapsedTime}getDelta(){let e=0;if(this.autoStart&&!this.running)return this.start(),0;if(this.running){let t=Jv();e=(t-this.oldTime)/1e3,this.oldTime=t,this.elapsedTime+=e}return e}};function Jv(){return(typeof performance=="undefined"?Date:performance).now()}var Xv=class extends Ke{constructor(e){super();this.type="Audio",this.listener=e,this.context=e.context,this.gain=this.context.createGain(),this.gain.connect(e.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(e){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=e,this.connect(),this}setMediaElementSource(e){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(e),this.connect(),this}setMediaStreamSource(e){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(e),this.connect(),this}setBuffer(e){return this.buffer=e,this.sourceType="buffer",this.autoplay&&this.play(),this}play(e=0){if(this.isPlaying===!0){console.warn("THREE.Audio: Audio is already playing.");return}if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}this._startedAt=thi
|
||
|
|
`)),GammaToLinear:new Le(["vec4 GammaToLinear( in vec4 value, in float gammaFactor ) {"," return vec4( pow( value.xyz, vec3( gammaFactor ) ), value.w );","}"].join(`
|
||
|
|
`)),LinearToGamma:new Le(["vec4 LinearToGamma( in vec4 value, in float gammaFactor ) {"," return vec4( pow( value.xyz, vec3( 1.0 / gammaFactor ) ), value.w );","}"].join(`
|
||
|
|
`)),sRGBToLinear:new Le(["vec4 sRGBToLinear( in vec4 value ) {"," return vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.w );","}"].join(`
|
||
|
|
`)),LinearTosRGB:new Le(["vec4 LinearTosRGB( in vec4 value ) {"," return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.w );","}"].join(`
|
||
|
|
`)),RGBEToLinear:new Le(["vec4 RGBEToLinear( in vec4 value ) {"," return vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );","}"].join(`
|
||
|
|
`)),LinearToRGBE:new Le(["vec4 LinearToRGBE( in vec4 value ) {"," float maxComponent = max( max( value.r, value.g ), value.b );"," float fExp = clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );"," return vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );","}"].join(`
|
||
|
|
`)),RGBMToLinear:new Le(["vec3 RGBMToLinear( in vec4 value, in float maxRange ) {"," return vec4( value.xyz * value.w * maxRange, 1.0 );","}"].join(`
|
||
|
|
`)),LinearToRGBM:new Le(["vec3 LinearToRGBM( in vec4 value, in float maxRange ) {"," float maxRGB = max( value.x, max( value.g, value.b ) );"," float M = clamp( maxRGB / maxRange, 0.0, 1.0 );"," M = ceil( M * 255.0 ) / 255.0;"," return vec4( value.rgb / ( M * maxRange ), M );","}"].join(`
|
||
|
|
`)),RGBDToLinear:new Le(["vec3 RGBDToLinear( in vec4 value, in float maxRange ) {"," return vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );","}"].join(`
|
||
|
|
`)),LinearToRGBD:new Le(["vec3 LinearToRGBD( in vec4 value, in float maxRange ) {"," float maxRGB = max( value.x, max( value.g, value.b ) );"," float D = max( maxRange / maxRGB, 1.0 );"," D = clamp( floor( D ) / 255.0, 0.0, 1.0 );"," return vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );","}"].join(`
|
||
|
|
`)),cLogLuvM:new rt("const mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );"),LinearToLogLuv:new Le(["vec4 LinearToLogLuv( in vec4 value ) {"," vec3 Xp_Y_XYZp = cLogLuvM * value.rgb;"," Xp_Y_XYZp = max(Xp_Y_XYZp, vec3(1e-6, 1e-6, 1e-6));"," vec4 vResult;"," vResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;"," float Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;"," vResult.w = fract(Le);"," vResult.z = (Le - (floor(vResult.w*255.0))/255.0)/255.0;"," return vResult;","}"].join(`
|
||
|
|
`),[new rt("const mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );")]),cLogLuvInverseM:new rt("const mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );"),LogLuvToLinear:new Le(["vec4 LogLuvToLinear( in vec4 value ) {"," float Le = value.z * 255.0 + value.w;"," vec3 Xp_Y_XYZp;"," Xp_Y_XYZp.y = exp2((Le - 127.0) / 2.0);"," Xp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;"," Xp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;"," vec3 vRGB = cLogLuvInverseM * Xp_Y_XYZp.rgb;"," return vec4( max(vRGB, 0.0), 1.0 );","}"].join(`
|
||
|
|
`),[new rt("const mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );")])},Bt.LINEAR_TO_LINEAR="LinearToLinear",Bt.GAMMA_TO_LINEAR="GammaToLinear",Bt.LINEAR_TO_GAMMA="LinearToGamma",Bt.SRGB_TO_LINEAR="sRGBToLinear",Bt.LINEAR_TO_SRGB="LinearTosRGB",Bt.RGBE_TO_LINEAR="RGBEToLinear",Bt.LINEAR_TO_RGBE="LinearToRGBE",Bt.RGBM_TO_LINEAR="RGBMToLinear",Bt.LINEAR_TO_RGBM="LinearToRGBM",Bt.RGBD_TO_LINEAR="RGBDToLinear",Bt.LINEAR_TO_RGBD="LinearToRGBD",Bt.LINEAR_TO_LOG_LUV="LinearToLogLuv",Bt.LOG_LUV_TO_LINEAR="LogLuvToLinear";var bi=class extends xt{toJSON(e){let t=super.toJSON(e),n=e===void 0||typeof e=="string";if(this.image!==void 0&&!n){let i=this.image;if(Array.isArray(i)){e.images[i.uuid].url=[];for(let s=0;s<i.length;s++)e.images[i.uuid].url[s]=xx(i[s])}else e.images[i.uuid].url=xx(i)}return t}};function xx(r){return typeof HTMLImageElement!="undefined"&&r instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&r instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&r instanceof ImageBitmap?SL(r):(console.warn("THREE.Texture: Unable to serialize Texture."),"")}var Oa;function SL(r){if(/^data:/i.test(r.src))return r.src;let e;if(r instanceof HTMLCanvasElement)e=r;else{Oa===void 0&&(Oa=document.createElement("canvas")),Oa.width=r.width,Oa.height=r.height;let n=Oa.getContext("2d");r instanceof ImageData?n.putImageData(r,0,0):n.drawImage(r,0,0,r.width,r.height),e=Oa}let t=r.src.startsWith("blob:")?r.fileName:r.src;return/\.jpe?g$/i.test(t)?e.toDataURL("image/jpeg",.6):e.toDataURL("image/png")}var kn=class extends Ct{constructor(e=new bi,t,n,i){super("v4",{shared:!0});this.nodeType="Texture";this.value=e,this.uv=t!=null?t:new bo,this.bias=n,this.project=i!==void 0?i:!1}getTexture(e,t){return super.generate(e,t,this.value.uuid,"t")}generate(e,t){var u;if(t==="sampler2D")return this.getTexture(e,t);let n=this.getTexture(e,t),i=this.uv.build(e,this.project?"v4":"v2"),s=this.bias?this.bias.build(e,"f"):void 0;s===void 0&&e.context.bias&&(s=e.context.bias.setTexture(this).build(e,"f"));let o,a;this.project?o="texture2DProj":o=s?"tex2DBias":"tex2D",s?a=o+"( "+n+", "+i+", "+s+" )":a=o+"( "+n+", "+i+" )";let l={include:e.isShader("vertex"),ignoreCache:!0},c=this.getType(e);return e.addContext(l),this.colorSpace=(u=this.colorSpace)!=null?u:new Bt(new yt("",c)),this.colorSpace.fromDecoding(e.getTextureEncodingFromMap(this.value)),this.colorSpace.input.parse(a),a=this.colorSpace.build(e,c),e.removeContext(),e.format(a,c,t)}copy(e){return super.copy(e),e.value.isRenderTargetTexture?this.value=e.value:this.value.copy(e.value),this.uv.copy(e.uv),e.bias?this.bias?this.bias.copy(e.bias):this.bias=e.bias.clone():this.bias=void 0,e.colorSpace?this.colorSpace?this.colorSpace.copy(e.colorSpace):this.colorSpace=e.colorSpace.clone():this.colorSpace=void 0,this.project=e.project,e.value.isRenderTargetTexture||(this.value.updateMatrix(),this.value.needsUpdate=!0),this}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),this.value&&(t.value=this.value.toJSON(e).uuid),t.uv=this.uv.toJSON(e).uuid,t.project=this.project,this.bias&&(t.bias=this.bias.toJSON(e).uuid)),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),this.project=e.project,e.value&&(this.value=t.getTexture(e.value),this.value.updateMatrix()),e.uv&&(this.uv=t.getNode(e.uv)),e.bias&&(this.bias=t.getNode(e.bias)),this}};var zr=class extends Ct{constructor(e){super("m3");this.nodeType="Matrix3";this.value=e!=null?e:new Dt}generateReadonly(e,t,n,i,s,o){return e.format("mat3("+this.value.elements.join(", ")+")",i,t)}copy(e){return super.copy(e),this.elements=e.elements,this}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.elements=this.value.elements.concat()),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.elements&&(this.elements=e.elements),this}get elements(){return this.value.elements}set elements(e){this.value.fromArray(e)}};var Fa;(function(i){i[i.UV=0]="UV",i[i.PLANAR=1]="PLANAR",i[i.SPHERICAL=2]="SPHERICAL",i[i.CYLINDRICAL=3]="CY
|
||
|
|
vec3 g${this.uuid.toString().replace(/-/g,"")}_planarTexture(sampler2D tex, vec2 textureSize, float crop, mat3 mat, vec2 size, float alpha, int mode, out float calpha) {
|
||
|
|
|
||
|
|
vec2 uvs = ( mat * vec3( (g${this.uuid.toString().replace(/-/g,"")}_vCustomUv * 2. - 1.) / (size * .5), 1. ) / 2. + 0.5 ).xy;
|
||
|
|
|
||
|
|
vec4 tmp = texture2D( tex, uvs );
|
||
|
|
|
||
|
|
vec3 col = tmp.rgb;
|
||
|
|
float lalpha = alpha * tmp.a;
|
||
|
|
if ( crop > 0.5 ) {
|
||
|
|
if ( uvs.x < 0.0 || uvs.x > 1.0 || uvs.y < 0.0 || uvs.y > 1.0 ) {
|
||
|
|
lalpha = 0.0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
calpha = lalpha / clamp( lalpha + accumAlpha, 0.00001, 1.0 );
|
||
|
|
accumAlpha += ( 1.0 - accumAlpha ) * lalpha;
|
||
|
|
return col;
|
||
|
|
}`);n=e.include(s);break;default:n=e.include(gc.Nodes.uv);break}if(this.projection.value===1&&this.firstTime){let s=`g${this.uuid.toString().replace(/-/g,"")}`;e.addVertexParsCode(`varying vec2 ${s}_vCustomUv;`),e.addFragmentParsCode(`varying vec2 ${s}_vCustomUv;`),e.addVertexFinalCode(`
|
||
|
|
vec3 ${s}_posN = transformed;
|
||
|
|
${this.axis.value===0?`
|
||
|
|
float ${s}_u = (1. + (${s}_posN.z)) / 2.;
|
||
|
|
float ${s}_v = (1. + (${s}_posN.y)) / 2.;
|
||
|
|
`:""}
|
||
|
|
|
||
|
|
${this.axis.value===1?`
|
||
|
|
float ${s}_u = (1. + (${s}_posN.x)) / 2.;
|
||
|
|
float ${s}_v = (1. - (${s}_posN.z)) / 2.;
|
||
|
|
`:""}
|
||
|
|
|
||
|
|
${this.axis.value===2?`
|
||
|
|
float ${s}_u = (1. + (${s}_posN.x)) / 2.;
|
||
|
|
float ${s}_v = (1. + (${s}_posN.y)) / 2.;
|
||
|
|
`:""}
|
||
|
|
|
||
|
|
${s}_vCustomUv = vec2(${s}_u, ${s}_v);
|
||
|
|
`)}e.addFragmentVariable(this.calpha,"float");let i=[];return i.push(this.texture.getTexture(e,"t")),i.push(this.textureSize.build(e,"v2")),i.push(this.crop.build(e,"f")),i.push(this.mat.build(e,"mat3")),i.push(this.size.build(e,"v2")),i.push(this.alpha.build(e,"f")),i.push(this.mode.build(e,"i")),i.push(this.calpha),this.firstTime=!this.firstTime,e.format(n+"("+i.join(",")+")",this.getType(e),t)}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.texture=this.texture.toJSON(e).uuid,t.textureSize=this.textureSize.toJSON(e).uuid,t.crop=this.crop.toJSON(e).uuid,t.projection=this.projection.toJSON(e).uuid,t.axis=this.axis.toJSON(e).uuid,t.size=this.size.toJSON(e).uuid,t.alpha=this.alpha.toJSON(e).uuid,t.mode=this.mode.toJSON(e).uuid,t.calpha=this.calpha),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.texture&&(this.texture=t.getNode(e.texture),this.texture.value.updateMatrix(),this.mat=new zr(this.texture.value.matrix)),e.textureSize&&(this.textureSize=t.getNode(e.textureSize)),e.crop&&(this.crop=t.getNode(e.crop)),e.projection&&(this.projection=t.getNode(e.projection)),e.axis&&(this.axis=t.getNode(e.axis)),e.size&&(this.size=t.getNode(e.size)),e.alpha&&(this.alpha=t.getNode(e.alpha)),e.mode&&(this.mode=t.getNode(e.mode)),e.calpha&&(this.calpha=e.calpha),this}copy(e){return super.copy(e),this.texture.copy(e.texture),this.textureSize=e.textureSize.clone(),this.crop=e.crop.clone(),this.projection=e.projection.clone(),this.axis=e.axis.clone(),this.size=e.size.clone(),this.alpha=e.alpha.clone(),this.mode=e.mode.clone(),this}},za=gc;za.Nodes=function(){let e=new Le(`
|
||
|
|
vec3 cylindricalTexture(sampler2D tex, vec2 textureSize, float crop, mat3 mat, vec2 size, float alpha, int mode, out float calpha) {
|
||
|
|
vec3 posN = normalize(position);
|
||
|
|
float u = 0.5 + atan(posN.z, posN.x) / (2.*3.1415);
|
||
|
|
float scaledHeight = position.y / (size.y * 0.5);
|
||
|
|
float v = (scaledHeight / 2.) + .5;
|
||
|
|
|
||
|
|
vec2 calculatedUv = vec2(u,v);
|
||
|
|
vec2 uvs = ( mat * vec3( calculatedUv * 2. - 1., 1. ) / 2. + 0.5 ).xy;
|
||
|
|
|
||
|
|
vec2 df = fwidth(uvs);
|
||
|
|
if(df.x > 0.5) df.x = 0.;
|
||
|
|
|
||
|
|
#ifdef GL_EXT_shader_texture_lod
|
||
|
|
vec4 tmp = texture2DLodEXT(tex, uvs, log2(max(df.x, df.y)*min(textureSize.x, textureSize.y)));
|
||
|
|
#else
|
||
|
|
vec4 tmp = textureLod(tex, uvs, log2(max(df.x, df.y)*min(textureSize.x, textureSize.y)));
|
||
|
|
#endif
|
||
|
|
|
||
|
|
vec3 col = tmp.rgb;
|
||
|
|
float lalpha = alpha * tmp.a;
|
||
|
|
if ( crop > 0.5 ) {
|
||
|
|
if ( uvs.x < 0.0 || uvs.x > 1.0 || uvs.y < 0.0 || uvs.y > 1.0 ) {
|
||
|
|
lalpha = 0.0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
calpha = lalpha / clamp( lalpha + accumAlpha, 0.00001, 1.0 );
|
||
|
|
accumAlpha += ( 1.0 - accumAlpha ) * lalpha;
|
||
|
|
return col;
|
||
|
|
}
|
||
|
|
`),t=new Le(`
|
||
|
|
vec3 sphericalTexture(sampler2D tex, vec2 textureSize, float crop, mat3 mat, vec2 size, float alpha, int mode, out float calpha) {
|
||
|
|
vec3 posN = normalize(vPosition);
|
||
|
|
float u = 0.5 + atan(posN.z, posN.x) / (2.*3.1415);
|
||
|
|
float v = 0.5 + asin(posN.y) / 3.1415;
|
||
|
|
|
||
|
|
vec2 calculatedUv = vec2(u,v);
|
||
|
|
vec2 uvs = ( mat * vec3( calculatedUv * 2. - 1., 1. ) / 2. + 0.5 ).xy;
|
||
|
|
|
||
|
|
vec2 df = fwidth(uvs);
|
||
|
|
if(df.x > 0.5) df.x = 0.;
|
||
|
|
#ifdef GL_EXT_shader_texture_lod
|
||
|
|
vec4 tmp = texture2DLodEXT(tex, uvs, log2(max(df.x, df.y)*min(textureSize.x, textureSize.y)));
|
||
|
|
#else
|
||
|
|
vec4 tmp = textureLod(tex, uvs, log2(max(df.x, df.y)*min(textureSize.x, textureSize.y)));
|
||
|
|
#endif
|
||
|
|
|
||
|
|
vec3 col = tmp.rgb;
|
||
|
|
float lalpha = alpha * tmp.a;
|
||
|
|
if ( crop > 0.5 ) {
|
||
|
|
if ( uvs.x < 0.0 || uvs.x > 1.0 || uvs.y < 0.0 || uvs.y > 1.0 ) {
|
||
|
|
lalpha = 0.0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
calpha = lalpha / clamp( lalpha + accumAlpha, 0.00001, 1.0 );
|
||
|
|
accumAlpha += ( 1.0 - accumAlpha ) * lalpha;
|
||
|
|
return col;
|
||
|
|
}
|
||
|
|
`),n=new Le(`vec3 uvTexture(sampler2D tex, vec2 textureSize, float crop, mat3 mat, vec2 size, float alpha, int mode, out float calpha) {
|
||
|
|
|
||
|
|
vec2 uvs = ( mat * vec3( vUv * 2. - 1., 1. ) / 2. + 0.5 ).xy;
|
||
|
|
vec4 tmp = texture2D( tex, uvs );
|
||
|
|
|
||
|
|
vec3 col = tmp.rgb;
|
||
|
|
|
||
|
|
float lalpha = alpha * tmp.a;
|
||
|
|
if ( crop > 0.5 ) {
|
||
|
|
if ( uvs.x < 0.0 || uvs.x > 1.0 || uvs.y < 0.0 || uvs.y > 1.0 ) {
|
||
|
|
lalpha = 0.0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
calpha = lalpha / clamp( lalpha + accumAlpha, 0.00001, 1.0 );
|
||
|
|
accumAlpha += ( 1.0 - accumAlpha ) * lalpha;
|
||
|
|
return col;
|
||
|
|
}`);return{cylindrical:e,spherical:t,uv:n}}();var Hp=class extends je{constructor(e,t,n,i,s,o,a){super("v3");this.nodeType="Fresnel";this.color=e,this.bias=t,this.scale=n,this.intensity=i,this.factor=s,this.alpha=o,this.mode=a,this.calpha=`g${this.uuid.toString().replace(/-/g,"")}_calpha`}generate(e,t){if(e.require("vWorldViewDir"),e.require("vWorldNormal"),e.isShader("fragment")){e.addFragmentVariable(this.calpha,"float");let n=e.include(Hp.Nodes.fresnel),i=[];return i.push(this.color.build(e,"c")),i.push(this.bias.build(e,"f")),i.push(this.scale.build(e,"f")),i.push(this.intensity.build(e,"f")),i.push(this.factor.build(e,"f")),i.push(this.alpha.build(e,"f")),i.push(this.mode.build(e,"i")),i.push(this.calpha),e.format(n+"("+i.join(",")+")",this.getType(e),t)}else return console.warn("FresnelNode is not compatible with "+e.shader+" shader."),e.format("vec3( 0.0 )",this.getType(e),t)}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.color=this.color.toJSON(e).uuid,t.bias=this.bias.toJSON(e).uuid,t.scale=this.scale.toJSON(e).uuid,t.intensity=this.intensity.toJSON(e).uuid,t.factor=this.factor.toJSON(e).uuid,t.alpha=this.alpha.toJSON(e).uuid,t.mode=this.mode.toJSON(e).uuid,t.calpha=this.calpha),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.color&&(this.color=t.getNode(e.color)),e.bias&&(this.bias=t.getNode(e.bias)),e.scale&&(this.scale=t.getNode(e.scale)),e.intensity&&(this.intensity=t.getNode(e.intensity)),e.factor&&(this.factor=t.getNode(e.factor)),e.alpha&&(this.alpha=t.getNode(e.alpha)),e.mode&&(this.mode=t.getNode(e.mode)),e.calpha&&(this.calpha=e.calpha),this}copy(e){return super.copy(e),this.color=e.color.clone(),this.bias=e.bias.clone(),this.scale=e.scale.clone(),this.intensity=e.intensity.clone(),this.factor=e.factor.clone(),this.alpha=e.alpha.clone(),this.mode=e.mode.clone(),this.calpha=e.calpha,this}},Ga=Hp;Ga.Nodes=function(){return{fresnel:new Le(`vec3 fresnel(vec3 color, float bias, float scale, float intensity, float factor, float alpha, int mode, out float calpha) {
|
||
|
|
float fresnel = bias + scale * pow( abs( factor + dot( normalize( vWorldViewDir ), normalize( vWorldNormal ) ) ), intensity );
|
||
|
|
|
||
|
|
float lalpha = clamp( fresnel, 0.0, 1.0 ) * alpha;
|
||
|
|
calpha = lalpha / clamp(lalpha + accumAlpha, 0.001, 1.0);
|
||
|
|
accumAlpha += (1.0 - accumAlpha) * lalpha;
|
||
|
|
return color;
|
||
|
|
}`)}}();var Ua;(function(s){s.SIMPLEX="simplex3d",s.SIMPLEX_FRACTAL="simplex3dFractal",s.ASHIMA="simplexAshima",s.FBM="fbm",s.PERLIN="perlin"})(Ua||(Ua={}));var si=function(){let r=5,e=new Le(`vec3 random3(vec3 c) {
|
||
|
|
float j = 4096.0*sin(dot(c,vec3(17.0, 59.4, 15.0)));
|
||
|
|
vec3 r;
|
||
|
|
r.z = fract(512.0*j);
|
||
|
|
j *= .125;
|
||
|
|
r.x = fract(512.0*j);
|
||
|
|
j *= .125;
|
||
|
|
r.y = fract(512.0*j);
|
||
|
|
return r-0.5;
|
||
|
|
}`),t=new Le(`float simplex3d(vec3 p) {
|
||
|
|
vec3 s = floor(p + dot(p, vec3(F3)));
|
||
|
|
vec3 x = p - s + dot(s, vec3(G3));
|
||
|
|
|
||
|
|
vec3 e = step(vec3(0.0), x - x.yzx);
|
||
|
|
vec3 i1 = e*(1.0 - e.zxy);
|
||
|
|
vec3 i2 = 1.0 - e.zxy*(1.0 - e);
|
||
|
|
|
||
|
|
vec3 x1 = x - i1 + G3;
|
||
|
|
vec3 x2 = x - i2 + 2.0*G3;
|
||
|
|
vec3 x3 = x - 1.0 + 3.0*G3;
|
||
|
|
|
||
|
|
vec4 w, d;
|
||
|
|
|
||
|
|
w.x = dot(x, x);
|
||
|
|
w.y = dot(x1, x1);
|
||
|
|
w.z = dot(x2, x2);
|
||
|
|
w.w = dot(x3, x3);
|
||
|
|
|
||
|
|
w = max(0.6 - w, 0.0);
|
||
|
|
|
||
|
|
d.x = dot(random3(s), x);
|
||
|
|
d.y = dot(random3(s + i1), x1);
|
||
|
|
d.z = dot(random3(s + i2), x2);
|
||
|
|
d.w = dot(random3(s + 1.0), x3);
|
||
|
|
|
||
|
|
w *= w;
|
||
|
|
w *= w;
|
||
|
|
d *= w;
|
||
|
|
|
||
|
|
return dot(d, vec4(52.0));
|
||
|
|
}`,[e]);t.keywords.F3=new rt("float F3 0.3333333"),t.keywords.G3=new rt("float G3 0.1666667");let n=new Le(`float simplex3dFractal(vec3 m) {
|
||
|
|
mat3 rot1 = mat3(-0.37, 0.36, 0.85,-0.14,-0.93, 0.34,0.92, 0.01,0.4);
|
||
|
|
mat3 rot2 = mat3(-0.55,-0.39, 0.74, 0.33,-0.91,-0.24,0.77, 0.12,0.63);
|
||
|
|
mat3 rot3 = mat3(-0.71, 0.52,-0.47,-0.08,-0.72,-0.68,-0.7,-0.45,0.56);
|
||
|
|
return 0.5333333 * simplex3d(m * rot1)
|
||
|
|
+ 0.2666667 * simplex3d(2.0 * m * rot2)
|
||
|
|
+ 0.1333333 * simplex3d(4.0 * m * rot3)
|
||
|
|
+ 0.0666667 * simplex3d(8.0 * m);
|
||
|
|
}`,[t]),i=new Le("vec4 permute(vec4 x){return mod(((x*34.0)+1.0)*x, 289.0);}"),s=new Le("vec4 taylorInvSqrt(vec4 r){return 1.79284291400159 - 0.85373472095314 * r;}"),o=new Le(`float simplexAshima(vec3 v) {
|
||
|
|
const vec2 C = vec2(1.0/6.0, 1.0/3.0) ;
|
||
|
|
const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);
|
||
|
|
vec3 i = floor(v + dot(v, C.yyy) );
|
||
|
|
vec3 x0 = v - i + dot(i, C.xxx) ;
|
||
|
|
vec3 g = step(x0.yzx, x0.xyz);
|
||
|
|
vec3 l = 1.0 - g;
|
||
|
|
vec3 i1 = min( g.xyz, l.zxy );
|
||
|
|
vec3 i2 = max( g.xyz, l.zxy );
|
||
|
|
vec3 x1 = x0 - i1 + 1.0 * C.xxx;
|
||
|
|
vec3 x2 = x0 - i2 + 2.0 * C.xxx;
|
||
|
|
vec3 x3 = x0 - 1. + 3.0 * C.xxx;
|
||
|
|
i = mod(i, 289.0 );
|
||
|
|
vec4 p = permute( permute( permute(
|
||
|
|
i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
|
||
|
|
+ i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
|
||
|
|
+ i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
|
||
|
|
float n_ = 1.0/7.0; // N=7
|
||
|
|
vec3 ns = n_ * D.wyz - D.xzx;
|
||
|
|
vec4 j = p - 49.0 * floor(p * ns.z *ns.z); // mod(p,N*N)
|
||
|
|
vec4 x_ = floor(j * ns.z);
|
||
|
|
vec4 y_ = floor(j - 7.0 * x_ ); // mod(j,N)
|
||
|
|
vec4 x = x_ *ns.x + ns.yyyy;
|
||
|
|
vec4 y = y_ *ns.x + ns.yyyy;
|
||
|
|
vec4 h = 1.0 - abs(x) - abs(y);
|
||
|
|
vec4 b0 = vec4( x.xy, y.xy );
|
||
|
|
vec4 b1 = vec4( x.zw, y.zw );
|
||
|
|
vec4 s0 = floor(b0)*2.0 + 1.0;
|
||
|
|
vec4 s1 = floor(b1)*2.0 + 1.0;
|
||
|
|
vec4 sh = -step(h, vec4(0.0));
|
||
|
|
vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
|
||
|
|
vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
|
||
|
|
vec3 p0 = vec3(a0.xy,h.x);
|
||
|
|
vec3 p1 = vec3(a0.zw,h.y);
|
||
|
|
vec3 p2 = vec3(a1.xy,h.z);
|
||
|
|
vec3 p3 = vec3(a1.zw,h.w);
|
||
|
|
vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
|
||
|
|
p0 *= norm.x;
|
||
|
|
p1 *= norm.y;
|
||
|
|
p2 *= norm.z;
|
||
|
|
p3 *= norm.w;
|
||
|
|
vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
|
||
|
|
m = m * m;
|
||
|
|
return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1),
|
||
|
|
dot(p2,x2), dot(p3,x3) ) );
|
||
|
|
}`,[i,s]),a=new Le("vec4 mod289(vec4 x){return x - floor(x * (1.0 / 289.0)) * 289.0;}"),l=new Le("vec4 perm(vec4 x){return mod289(((x * 34.0) + 1.0) * x);}",[a]),c=new Le(`float noise(vec3 p){
|
||
|
|
vec3 a = floor(p);
|
||
|
|
vec3 d = p - a;
|
||
|
|
d = d * d * (3.0 - 2.0 * d);
|
||
|
|
vec4 b = a.xxyy + vec4(0.0, 1.0, 0.0, 1.0);
|
||
|
|
vec4 k1 = perm(b.xyxy);
|
||
|
|
vec4 k2 = perm(k1.xyxy + b.zzww);
|
||
|
|
vec4 c = k2 + a.zzzz;
|
||
|
|
vec4 k3 = perm(c);
|
||
|
|
vec4 k4 = perm(c + 1.0);
|
||
|
|
vec4 o1 = fract(k3 * (1.0 / 41.0));
|
||
|
|
vec4 o2 = fract(k4 * (1.0 / 41.0));
|
||
|
|
vec4 o3 = o2 * d.z + o1 * (1.0 - d.z);
|
||
|
|
vec2 o4 = o3.yw * d.x + o3.xz * (1.0 - d.x);
|
||
|
|
return o4.y * d.y + o4.x * (1.0 - d.y);
|
||
|
|
}`,[l]),u=new Le(`float fbm(vec3 x) {
|
||
|
|
float v = 0.0;
|
||
|
|
float a = 0.5;
|
||
|
|
vec3 shift = vec3(100);
|
||
|
|
for (int i = 0; i < NUM_OCTAVES; ++i) {
|
||
|
|
v += a * noise(x);
|
||
|
|
x = x * 2.0 + shift;
|
||
|
|
a *= 0.5;
|
||
|
|
}
|
||
|
|
return v;
|
||
|
|
}`,[c]);u.keywords.NUM_OCTAVES=new rt(`int NUM_OCTAVES ${r}`);let h=new Le("vec3 fade(vec3 t) {return t*t*t*(t*(t*6.0-15.0)+10.0);}"),d=new Le(`float perlin(vec3 P){
|
||
|
|
vec3 Pi0 = floor(P);
|
||
|
|
vec3 Pi1 = Pi0 + vec3(1.0);
|
||
|
|
Pi0 = mod(Pi0, 289.0);
|
||
|
|
Pi1 = mod(Pi1, 289.0);
|
||
|
|
vec3 Pf0 = fract(P);
|
||
|
|
vec3 Pf1 = Pf0 - vec3(1.0);
|
||
|
|
vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
|
||
|
|
vec4 iy = vec4(Pi0.yy, Pi1.yy);
|
||
|
|
vec4 iz0 = Pi0.zzzz;
|
||
|
|
vec4 iz1 = Pi1.zzzz;
|
||
|
|
vec4 ixy = permute(permute(ix) + iy);
|
||
|
|
vec4 ixy0 = permute(ixy + iz0);
|
||
|
|
vec4 ixy1 = permute(ixy + iz1);
|
||
|
|
vec4 gx0 = ixy0 / 7.0;
|
||
|
|
vec4 gy0 = fract(floor(gx0) / 7.0) - 0.5;
|
||
|
|
gx0 = fract(gx0);
|
||
|
|
vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);
|
||
|
|
vec4 sz0 = step(gz0, vec4(0.0));
|
||
|
|
gx0 -= sz0 * (step(0.0, gx0) - 0.5);
|
||
|
|
gy0 -= sz0 * (step(0.0, gy0) - 0.5);
|
||
|
|
vec4 gx1 = ixy1 / 7.0;
|
||
|
|
vec4 gy1 = fract(floor(gx1) / 7.0) - 0.5;
|
||
|
|
gx1 = fract(gx1);
|
||
|
|
vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);
|
||
|
|
vec4 sz1 = step(gz1, vec4(0.0));
|
||
|
|
gx1 -= sz1 * (step(0.0, gx1) - 0.5);
|
||
|
|
gy1 -= sz1 * (step(0.0, gy1) - 0.5);
|
||
|
|
vec3 g000 = vec3(gx0.x,gy0.x,gz0.x);
|
||
|
|
vec3 g100 = vec3(gx0.y,gy0.y,gz0.y);
|
||
|
|
vec3 g010 = vec3(gx0.z,gy0.z,gz0.z);
|
||
|
|
vec3 g110 = vec3(gx0.w,gy0.w,gz0.w);
|
||
|
|
vec3 g001 = vec3(gx1.x,gy1.x,gz1.x);
|
||
|
|
vec3 g101 = vec3(gx1.y,gy1.y,gz1.y);
|
||
|
|
vec3 g011 = vec3(gx1.z,gy1.z,gz1.z);
|
||
|
|
vec3 g111 = vec3(gx1.w,gy1.w,gz1.w);
|
||
|
|
vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
|
||
|
|
g000 *= norm0.x;
|
||
|
|
g010 *= norm0.y;
|
||
|
|
g100 *= norm0.z;
|
||
|
|
g110 *= norm0.w;
|
||
|
|
vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
|
||
|
|
g001 *= norm1.x;
|
||
|
|
g011 *= norm1.y;
|
||
|
|
g101 *= norm1.z;
|
||
|
|
g111 *= norm1.w;
|
||
|
|
float n000 = dot(g000, Pf0);
|
||
|
|
float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));
|
||
|
|
float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));
|
||
|
|
float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));
|
||
|
|
float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));
|
||
|
|
float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));
|
||
|
|
float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));
|
||
|
|
float n111 = dot(g111, Pf1);
|
||
|
|
vec3 fade_xyz = fade(Pf0);
|
||
|
|
vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);
|
||
|
|
vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);
|
||
|
|
float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);
|
||
|
|
return 2.2 * n_xyz;
|
||
|
|
}`,[i,s,h]);return{simplex:t,simplexFractal:n,simplexAshima:o,fbm:u,perlin:d}}();var jp=class extends je{constructor(e,t,n,i,s,o,a){super("v3");this.nodeType="Rainbow";this.filmThickness=e,this.movement=t,this.wavelengths=n,this.noiseStrength=i,this.noiseScale=s,this.offset=o,this.alpha=a,this.calpha=`g${this.uuid.toString().replace(/-/g,"")}_calpha`}generate(e,t){if(e.isShader("fragment")){e.require("normal"),e.require("uv"),e.requires.uv=[!0],e.addFragmentVariable(this.calpha,"float");let n=e.include(jp.Nodes.rainbow),i=[];return i.push(this.filmThickness.build(e,"f")),i.push(this.movement.build(e,"f")),i.push(this.wavelengths.build(e,"v3")),i.push(this.noiseStrength.build(e,"f")),i.push(this.noiseScale.build(e,"f")),i.push(this.offset.build(e,"v3")),i.push(this.alpha.build(e,"f")),i.push(this.calpha),e.format(n+"("+i.join(",")+")",this.getType(e),t)}else return console.warn("RainbowNode is not compatible with "+e.shader+" shader."),e.format("vec3( 0.0 )",this.getType(e),t)}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.filmThickness=this.filmThickness.toJSON(e).uuid,t.movement=this.movement.toJSON(e).uuid,t.wavelengths=this.wavelengths.toJSON(e).uuid,t.noiseStrength=this.noiseStrength.toJSON(e).uuid,t.noiseScale=this.noiseScale.toJSON(e).uuid,t.offset=this.offset.toJSON(e).uuid,t.alpha=this.alpha.toJSON(e).uuid,t.calpha=this.calpha),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.filmThickness&&(this.filmThickness=t.getNode(e.filmThickness)),e.movement&&(this.movement=t.getNode(e.movement)),e.wavelengths&&(this.wavelengths=t.getNode(e.wavelengths)),e.noiseStrength&&(this.noiseStrength=t.getNode(e.noiseStrength)),e.noiseScale&&(this.noiseScale=t.getNode(e.noiseScale)),e.offset&&(this.offset=t.getNode(e.offset)),e.alpha&&(this.alpha=t.getNode(e.alpha)),e.calpha&&(this.calpha=e.calpha),this}copy(e){return super.copy(e),this.filmThickness=e.filmThickness.clone(),this.movement=e.movement.clone(),this.wavelengths=e.wavelengths.clone(),this.noiseStrength=e.noiseStrength.clone(),this.noiseScale=e.noiseScale.clone(),this.offset=e.offset.clone(),this.alpha=e.alpha.clone(),this.calpha=e.calpha,this}},ka=jp;ka.Nodes=function(){let e=new Le(`vec3 attenuation(vec3 wavelengths, float filmThickness, float movement, float noiseStrength, float noiseScale, vec3 offset) {
|
||
|
|
vec3 viewDir = normalize(-(cameraPosition + offset));
|
||
|
|
vec3 st = position / noiseScale;
|
||
|
|
vec3 q = vec3(simplex3d(st),
|
||
|
|
simplex3d(st + vec3(1.0)),
|
||
|
|
simplex3d(st + vec3(1.0)));
|
||
|
|
|
||
|
|
vec3 r = vec3(simplex3d(st + vec3(1.4, 1.3, 1.0) * q + vec3(1.7, 9.2, 1.0)),
|
||
|
|
simplex3d(st + vec3(2.0, 1.2, 1.0) * q + vec3(8.3, 2.8, 1.0)),
|
||
|
|
simplex3d(st * q));
|
||
|
|
|
||
|
|
float noise = simplex3d(st + r);
|
||
|
|
|
||
|
|
return .5 + .5 * cos((((filmThickness + (noise * noiseStrength)) / (vec3(wavelengths.r * 1.0, wavelengths.g * 0.8, wavelengths.b * 0.6) + 1.0)) * dot(normalize(vObjectNormal), viewDir)) + movement);
|
||
|
|
}`,[si.simplex]);return{rainbow:new Le(`vec3 rainbow(float filmThickness, float movement, vec3 wavelengths, float noiseStrength, float noiseScale, vec3 offset, float alpha, out float calpha) {
|
||
|
|
vec3 res = clamp(attenuation(wavelengths, filmThickness, movement, noiseStrength, noiseScale, offset), 0.0, 2.0);
|
||
|
|
|
||
|
|
float rainbowContribution = clamp(res.r + res.g + res.b, 0.0, 1.0);
|
||
|
|
float lalpha = alpha * rainbowContribution;
|
||
|
|
calpha = lalpha / clamp( lalpha + accumAlpha, 0.00001, 1.0 );
|
||
|
|
accumAlpha += ( 1.0 - accumAlpha ) * lalpha;
|
||
|
|
|
||
|
|
return res;
|
||
|
|
}`,[e])}}();var Wp=class extends je{constructor(e,t,n,i,s,o,a,l){super("v3");this.nodeType="Transmission";this.thickness=e,this.ior=t,this.roughness=n,this.transmissionSamplerSize=i,this.transmissionSamplerMap=s,this.transmissionDepthMap=o,this.aspectRatio=a,this.alpha=l,this.calpha=`g${this.uuid.toString().replace(/-/g,"")}_calpha`}generate(e,t){if(e.extensions.shaderTextureLOD=!0,e.extensions.derivatives=!0,e.isShader("fragment")){e.define("NUM_SAMPLES",30),e.require("worldPosition"),e.requires.worldNormal=!0,e.requires.modelMatrix=!0,e.requires.projectionMatrix=!0,e.addFragmentVariable(this.calpha,"float");let n=e.include(Wp.Nodes.transmission),i=[];return i.push(this.thickness.build(e,"f")),i.push(this.ior.build(e,"f")),i.push(this.roughness.build(e,"f")),i.push(this.transmissionSamplerSize.build(e,"v2")),i.push(this.transmissionSamplerMap.getTexture(e,"t")),i.push(this.transmissionDepthMap.getTexture(e,"t")),i.push(this.aspectRatio.build(e,"v2")),i.push("normal"),i.push(this.alpha.build(e,"f")),i.push(this.calpha),e.format(n+"("+i.join(",")+")",this.getType(e),t)}else return console.warn("TransmissionNode is not compatible with "+e.shader+" shader."),e.format("vec3( 0.0 )",this.getType(e),t)}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.thickness=this.thickness.toJSON(e).uuid,t.ior=this.ior.toJSON(e).uuid,t.roughness=this.roughness.toJSON(e).uuid,t.alpha=this.alpha.toJSON(e).uuid,t.calpha=this.calpha),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.thickness&&(this.thickness=t.getNode(e.thickness)),e.ior&&(this.ior=t.getNode(e.ior)),e.roughness&&(this.roughness=t.getNode(e.roughness)),e.alpha&&(this.alpha=t.getNode(e.alpha)),e.calpha&&(this.calpha=e.calpha),this}copy(e){return super.copy(this),this.thickness=e.thickness.clone(),this.ior=e.ior.clone(),this.roughness=e.roughness.clone(),this.transmissionSamplerSize=e.transmissionSamplerSize.clone(),this.transmissionSamplerMap=e.transmissionSamplerMap,this.transmissionDepthMap=e.transmissionDepthMap,this.alpha=e.alpha.clone(),this.calpha=e.calpha,this}},Va=Wp;Va.Nodes=function(){let e=new Le(`
|
||
|
|
float gaussian(vec2 i) {
|
||
|
|
const float sigma = float(NUM_SAMPLES) * .25;
|
||
|
|
return exp( -.5* dot(i/=sigma,i) ) / ( 6.28 * sigma*sigma );
|
||
|
|
}`),t=new Le(`
|
||
|
|
vec4 blur(sampler2D sp, vec2 U, vec2 scale, float lod, sampler2D dm, vec2 unrefractedU, vec2 aspectRatio) {
|
||
|
|
// Slightly modified version of this:
|
||
|
|
// https://www.shadertoy.com/view/ltScRG
|
||
|
|
|
||
|
|
const int LOD = 2;
|
||
|
|
const int sLOD = 4; // tile size = 2^LOD
|
||
|
|
|
||
|
|
vec4 O = vec4(0);
|
||
|
|
const int s = NUM_SAMPLES/sLOD;
|
||
|
|
for ( int i = 0; i < s*s; i++ ) {
|
||
|
|
int modulo = (i)-((i)/(s))*(s);
|
||
|
|
vec2 d = vec2(float(modulo), float(i/s))*float(sLOD) - float(NUM_SAMPLES)/2.;
|
||
|
|
vec2 uv = U + (scale * aspectRatio) * d;
|
||
|
|
// What is the depth of the opaque object we're trying to sample
|
||
|
|
float opaqueDepth = texture2D(dm, uv).r;
|
||
|
|
if (opaqueDepth < gl_FragCoord.z) {
|
||
|
|
uv = unrefractedU + ((scale * min(lod / 2., 1.)) * aspectRatio) * d;
|
||
|
|
lod = lod > 4.0 ? lod : lod / 2.0;
|
||
|
|
}
|
||
|
|
#ifdef TEXTURE_LOD_EXT
|
||
|
|
O += gaussian(d) * texture2DLodEXT( sp, uv, lod);
|
||
|
|
#else
|
||
|
|
O += gaussian(d) * textureLod( sp, uv, lod);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
return O / O.a;
|
||
|
|
}`,[e]),n=new Le(`
|
||
|
|
vec3 getVolumeTransmissionRay( vec3 n, vec3 v, float thickness, float ior, mat4 modelMatrix ) {
|
||
|
|
// Direction of refracted light.
|
||
|
|
vec3 refractionVector = refract( -v, n, 1.0 / ior );
|
||
|
|
// Compute rotation-independant scaling of the model matrix.
|
||
|
|
vec3 modelScale;
|
||
|
|
modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );
|
||
|
|
modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );
|
||
|
|
modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );
|
||
|
|
// The thickness is specified in local space.
|
||
|
|
return normalize( refractionVector ) * thickness * modelScale;
|
||
|
|
}`),i=new Le(`
|
||
|
|
float applyIorToRoughness( float roughness, float ior ) {
|
||
|
|
// Scale roughness with IOR so that an IOR of 1.0 results in no microfacet refraction and
|
||
|
|
// an IOR of 1.5 results in the default amount of microfacet refraction.
|
||
|
|
return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );
|
||
|
|
} `),s=new Le(`
|
||
|
|
vec4 getTransmissionSample( vec2 fragCoord, float roughness, float ior, vec2 transmissionSamplerSize, sampler2D transmissionSamplerMap, sampler2D transmissionDepthMap, vec2 unrefractedCoords, vec2 aspectRatio) {
|
||
|
|
float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
|
||
|
|
float lod = applyIorToRoughness(roughness, ior);
|
||
|
|
|
||
|
|
return blur(transmissionSamplerMap, fragCoord, vec2(lod / (transmissionSamplerSize.x / 2.)), min(framebufferLod / 5.5, 8.5), transmissionDepthMap, unrefractedCoords, aspectRatio);
|
||
|
|
}`,[i,t]),o=new Le(`
|
||
|
|
vec4 getIBLVolumeRefraction( vec3 n, vec3 v, float roughness, vec3 position, mat4 modelMatrix, mat4 viewMatrix, mat4 projMatrix, float ior, float thickness, vec2 transmissionSamplerSize, sampler2D transmissionSamplerMap, sampler2D transmissionDepthMap, vec2 aspectRatio ) {
|
||
|
|
vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );
|
||
|
|
vec3 refractedRayExit = position + transmissionRay;
|
||
|
|
|
||
|
|
// Project refracted vector on the framebuffer, while mapping to normalized device coordinates.
|
||
|
|
vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );
|
||
|
|
vec2 refractionCoords = ndcPos.xy / ndcPos.w;
|
||
|
|
refractionCoords += 1.0;
|
||
|
|
refractionCoords /= 2.0;
|
||
|
|
|
||
|
|
vec4 ndcPosUnrefracted = projMatrix * viewMatrix * vec4(position, 1.0 );
|
||
|
|
vec2 unrefractedCoords = ndcPosUnrefracted.xy / ndcPosUnrefracted.w;
|
||
|
|
unrefractedCoords += 1.0;
|
||
|
|
unrefractedCoords /= 2.0;
|
||
|
|
|
||
|
|
// Sample framebuffer to get pixel the refracted ray hits.
|
||
|
|
vec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior, transmissionSamplerSize, transmissionSamplerMap, transmissionDepthMap, unrefractedCoords, aspectRatio );
|
||
|
|
// Get the specular component.
|
||
|
|
return vec4( ( 1.0 ) * transmittedLight.rgb, transmittedLight.a );
|
||
|
|
}`,[s,n]);return{transmission:new Le(`
|
||
|
|
vec3 transmission(float thickness, float ior, float roughness, vec2 transmissionSamplerSize, sampler2D transmissionSamplerMap, sampler2D transmissionDepthMap, vec2 aspectRatio, vec3 normal, float alpha, out float calpha) {
|
||
|
|
vec3 v = vec3(0.);
|
||
|
|
if (isOrthographic) {
|
||
|
|
v = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
|
||
|
|
} else {
|
||
|
|
v = normalize(vWPosition - cameraPosition);
|
||
|
|
}
|
||
|
|
vec4 transmission = getIBLVolumeRefraction(vWNormal, -v, roughness, vWPosition, modelMatrix, viewMatrix, projectionMatrix, ior, thickness, transmissionSamplerSize, transmissionSamplerMap, transmissionDepthMap, aspectRatio );
|
||
|
|
float lalpha = alpha;
|
||
|
|
|
||
|
|
calpha = lalpha / clamp( lalpha + accumAlpha, 0.00001, 1.0 );
|
||
|
|
accumAlpha += ( 1.0 - accumAlpha ) * lalpha;
|
||
|
|
return transmission.rgb;
|
||
|
|
}`,[o])}}();var Jp=class extends je{constructor(e,t){super("v3");this.nodeType="CustomNormal";this.cnormal=e,this.alpha=t}generate(e,t){if(e.isShader("fragment")){let n=e.include(Jp.Nodes.customNormal),i=[];return i.push(this.cnormal.build(e,"v3")),i.push("normal"),i.push(this.alpha.build(e,"f")),e.format(n+"("+i.join(",")+")",this.getType(e),t)}else return console.warn("CustomNormalNode is not compatible with "+e.shader+" shader."),e.format("vec3( 0.0 )",this.getType(e),t)}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.cnormal=this.cnormal.toJSON(e).uuid,t.alpha=this.alpha.toJSON(e).uuid),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.cnormal&&(this.cnormal=t.getNode(e.cnormal)),e.alpha&&(this.alpha=t.getNode(e.alpha)),this}copy(e){return super.copy(e),this.cnormal.copy(e.cnormal),this.alpha.copy(e.alpha),this}},Ha=Jp;Ha.Nodes=function(){return{customNormal:new Le(`vec3 customNormal(vec3 cnormal, vec3 norm, float alpha) {
|
||
|
|
vec3 normal = packNormalToRGB( norm ).rgb;
|
||
|
|
normal *= step( vec3(0.5), cnormal );
|
||
|
|
|
||
|
|
accumAlpha += ( 1.0 - accumAlpha ) * alpha;
|
||
|
|
|
||
|
|
return normal;
|
||
|
|
}`)}}();var Xp=class extends je{constructor(e,t,n,i,s,o,a,l,c){super("v3");this.nodeType="Gradient";this.glType=e,this.num=t,this.smooth=n,this.colors=i,this.steps=s,this.offset=o,this.morph=a,this.angle=l,this.alpha=c,this.calpha=`g${this.uuid.toString().replace(/-/g,"")}_calpha`}generate(e,t){if(e.isShader("fragment")){e.define("GRAD_MAX",10),e.require("uv"),e.requires.uv=[!0],e.addFragmentVariable(this.calpha,"float");let n=e.include(Xp.Nodes.gradient),i=[];return i.push(this.glType.build(e,"i")),i.push(this.num.build(e,"i")),i.push(this.smooth.build(e,"b")),i.push(this.colors.build(e,"v4[]")),i.push(this.steps.build(e,"f[]")),i.push(this.offset.build(e,"v2")),i.push(this.morph.build(e,"v2")),i.push(this.angle.build(e,"f")),i.push(this.alpha.build(e,"f")),i.push(this.calpha),e.format(n+"("+i.join(",")+")",this.getType(e),t)}else return console.warn("GradientNode is not compatible with "+e.shader+" shader."),e.format("vec3( 0.0 )",this.getType(e),t)}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.glType=this.glType.toJSON(e).uuid,t.num=this.num.toJSON(e).uuid,t.smooth=this.smooth.toJSON(e).uuid,t.colors=this.colors.toJSON(e).uuid,t.steps=this.steps.toJSON(e).uuid,t.offset=this.offset.toJSON(e).uuid,t.morph=this.morph.toJSON(e).uuid,t.angle=this.angle.toJSON(e).uuid,t.alpha=this.alpha.toJSON(e).uuid,t.calpha=this.calpha),t.nodeType=this.nodeType,t}copy(e){return super.copy(e),this.glType=e.glType.clone(),this.num=e.num.clone(),this.smooth=e.smooth.clone(),this.colors=e.colors.clone(),this.steps=e.steps.clone(),this.offset=e.offset.clone(),this.morph=e.morph.clone(),this.angle=e.angle.clone(),this.alpha=e.alpha.clone(),this.calpha=e.calpha,this}fromJSON(e,t){return super.fromJSON(e,t),e.calpha&&(this.calpha=e.calpha),e.glType&&(this.glType=t.getNode(e.glType)),e.num&&(this.num=t.getNode(e.num)),e.smooth&&(this.smooth=t.getNode(e.smooth)),e.colors&&(this.colors=t.getNode(e.colors)),e.steps&&(this.steps=t.getNode(e.steps)),e.offset&&(this.offset=t.getNode(e.offset)),e.morph&&(this.morph=t.getNode(e.morph)),e.angle&&(this.angle=t.getNode(e.angle)),e.alpha&&(this.alpha=t.getNode(e.alpha)),this}},ja=Xp;ja.Nodes=function(){return{gradient:new Le(`vec3 gradient(int glType, int num, bool smoothed, vec4 colors[GRAD_MAX], float steps[GRAD_MAX], vec2 offset, vec2 morph, float angle, float alpha, out float calpha) {
|
||
|
|
vec4 color = colors[0];
|
||
|
|
vec2 m = morph / vUv.xy;
|
||
|
|
vec2 rot = vec2( 0.5 + m.x, m.y );
|
||
|
|
vec2 dt = vec2(
|
||
|
|
cos( angle ) * rot.x - sin( angle ) * rot.y,
|
||
|
|
sin( angle ) * rot.x + cos( angle ) * rot.y
|
||
|
|
);
|
||
|
|
vec2 pt = ( vUv - 0.5 + offset ) / 2.0 + dt / 2.0;
|
||
|
|
float t = dot( pt, dt ) / dot( dt, dt );
|
||
|
|
if ( glType == 1 ) {
|
||
|
|
t = distance (
|
||
|
|
( vUv + morph ) * 3.0,
|
||
|
|
( vUv + offset ) + 1.0
|
||
|
|
) + angle;
|
||
|
|
} else if ( glType == 2 ) {
|
||
|
|
float polar = atan(
|
||
|
|
vUv.x + morph.x - 0.5 + offset.x,
|
||
|
|
vUv.y + morph.y - 0.5 + offset.y
|
||
|
|
) * -1.0;
|
||
|
|
t = fract( ( angle / PI / -2.0 ) + 0.5 * ( polar / PI ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
float p;
|
||
|
|
if (smoothed) {
|
||
|
|
for ( int i = 1; i < GRAD_MAX; i++ ) {
|
||
|
|
p = clamp( ( t - steps[i-1] ) / ( steps[i] - steps[i-1] ), 0.0, 1.0 );
|
||
|
|
color = mix(color, colors[i], smoothstep(0.0, 1.0, p));
|
||
|
|
}
|
||
|
|
|
||
|
|
} else {
|
||
|
|
for ( int i = 1; i < GRAD_MAX; i++ ) {
|
||
|
|
p = clamp( ( t - steps[i-1] ) / ( steps[i] - steps[i-1] ), 0.0, 1.0 );
|
||
|
|
color = mix(color, colors[i], p);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
float lalpha = alpha * color.a;
|
||
|
|
calpha = lalpha / clamp( lalpha + accumAlpha, 0.00001, 1.0 );
|
||
|
|
accumAlpha += ( 1.0 - accumAlpha ) * lalpha;
|
||
|
|
|
||
|
|
return color.xyz;
|
||
|
|
}`)}}();var So;(function(t){t.NOISE="noise",t.MAP="map"})(So||(So={}));var qp=class extends je{constructor(e=new it(0),t,n,i,s,o){super("v3");this.nodeType="VertexDisplacement";this.displacementTypeIndex=e,this.intensity=t,this.movementOrTexture=n,Object.values(So)[this.displacementTypeIndex.value]===So.MAP&&(this.mat=new zr(this.movementOrTexture.value.matrix)),this.cropOrOffset=i,this.scale=s,this.noiseFunctionIndex=o}generate(e,t){if(e.isShader("vertex")){e.define("USE_LAYER_DISPLACE");let n,i=[];switch(i.push("displaced_position"),i.push("displaced_normal"),Object.values(So)[this.displacementTypeIndex.value]){case So.MAP:{n=e.include(qp.Nodes.map),i.push(this.movementOrTexture.getTexture(e,"t")),i.push("uv"),i.push(this.cropOrOffset.build(e,"f")),this.mat&&i.push(this.mat.build(e,"mat3"));break}case So.NOISE:{let o=Object.values(Ua)[this.noiseFunctionIndex.value],a=new Le(`vec3 orthogonal(vec3 v) {
|
||
|
|
return normalize(abs(v.x) > abs(v.z) ? vec3(-v.y, v.x, 0.0) : vec3(0.0, -v.z, v.y));
|
||
|
|
}`),l=new Le(`vec3 distorted(vec3 p, vec3 n, float scale, float intensity, vec3 offset, float neighbour_offset, float movement) {
|
||
|
|
return p + n * ${o}((p + offset) * scale * 0.001 + neighbour_offset + (movement * 0.1)) * intensity;
|
||
|
|
}`,[si.simplex,si.simplexFractal,si.simplexAshima,si.fbm,si.perlin]),c=new Le(`vec3 vertexDisplacementNoise(vec3 position, vec3 normal, float scale, vec3 offset, float movement, float intensity, out vec3 displaced_normal) {
|
||
|
|
vec3 displaced_position = distorted(position, normal, scale, intensity, offset, neighbor_offset, movement);
|
||
|
|
vec3 tangent1 = orthogonal(normal);
|
||
|
|
vec3 tangent2 = normalize(cross(normal, tangent1));
|
||
|
|
|
||
|
|
// TODO(Max): The distance to the neighbors was originally scaled by 0.1.
|
||
|
|
// This caused some small oval/circular visual artifacts in the lighting.
|
||
|
|
// For now, simply using neighbors further away betters the problem,
|
||
|
|
// but we should figure out the underlying cause when we have some time.
|
||
|
|
// Maybe its related to how we calculate the tangent and bitangent?
|
||
|
|
vec3 nearby1 = position + tangent1;
|
||
|
|
vec3 nearby2 = position + tangent2;
|
||
|
|
vec3 distorted1 = distorted(nearby1, normal, scale, intensity, offset, neighbor_offset, movement);
|
||
|
|
vec3 distorted2 = distorted(nearby2, normal, scale, intensity, offset, neighbor_offset, movement);
|
||
|
|
displaced_normal = normalize(cross(distorted1 - displaced_position, distorted2 - displaced_position));
|
||
|
|
return displaced_position;
|
||
|
|
}`,[l,a]);n=e.include(c),i.push(this.scale.build(e,"f")),i.push(this.cropOrOffset.build(e,"v3")),i.push(this.movementOrTexture.build(e,"f"));break}}return i.push(this.intensity.build(e,"f")),i.push("displaced_normal"),e.format(n+"("+i.join(",")+")",this.getType(e),t)}else return console.warn("VertexDisplacementNode is not compatible with "+e.shader+" shader."),e.format("vec3( 0.0 )",this.getType(e),t)}toJSON(e){var n;let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.intensity=this.intensity.toJSON(e).uuid,t.scale=(n=this.scale)==null?void 0:n.toJSON(e).uuid,t.movementOrTexture=this.movementOrTexture.toJSON(e).uuid,t.cropOrOffset=this.cropOrOffset.toJSON(e).uuid),t.displacementTypeIndex=this.displacementTypeIndex,t.noiseFunctionIndex=this.noiseFunctionIndex,t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),this.displacementTypeIndex=e.displacementTypeIndex,this.noiseFunctionIndex=e.noiseFunctionIndex,e.cropOrOffset&&(this.cropOrOffset=t.getNode(e.cropOrOffset)),e.intensity&&(this.intensity=t.getNode(e.intensity)),e.movementOrTexture&&(this.displacementTypeIndex.value===1?(this.movementOrTexture=t.getNode(e.movementOrTexture),this.movementOrTexture.value.updateMatrix(),this.mat=new zr(this.movementOrTexture.value.matrix)):this.displacementTypeIndex.value===0&&(this.movementOrTexture=t.getNode(e.movementOrTexture))),e.scale&&(this.scale=t.getNode(e.scale)),this}copy(e){var t,n;return super.copy(e),this.noiseFunctionIndex=(t=e.noiseFunctionIndex)==null?void 0:t.clone(),this.scale=(n=e.scale)==null?void 0:n.clone(),this.cropOrOffset=e.cropOrOffset.clone(),this.intensity=e.intensity.clone(),this.movementOrTexture=e.movementOrTexture.clone(),this}},Mo=qp;Mo.Nodes=function(){let e=new Le(`vec3 orthogonal(vec3 v) {
|
||
|
|
return normalize(abs(v.x) > abs(v.z) ? vec3(-v.y, v.x, 0.0) : vec3(0.0, -v.z, v.y));
|
||
|
|
}`),t=new Le(`float displacementMapTexture(sampler2D tex, float crop, vec2 uv, mat3 mat, vec2 offset) {
|
||
|
|
vec2 uvs = (mat * vec3(uv * 2.0 - 1.0, 1.0) / 2.0 + 0.5).xy + offset;
|
||
|
|
vec4 tmp = texture2D(tex, uvs);
|
||
|
|
vec3 col = tmp.rgb;
|
||
|
|
if (crop > 0.5) {
|
||
|
|
if ( uvs.x < 0.0 || uvs.x > 1.0 || uvs.y < 0.0 || uvs.y > 1.0 ) {
|
||
|
|
return 0.0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return col.r;
|
||
|
|
}`);return{map:new Le(`vec3 vertexDisplacementMap(vec3 position, vec3 normal, sampler2D tex, vec2 uv, float crop, mat3 mat, float intensity, out vec3 displaced_normal) {
|
||
|
|
vec3 displaced_position = position + normal * displacementMapTexture(tex, crop, uv, mat, vec2(0.0)) * intensity;
|
||
|
|
vec3 tangent1 = normalize(orthogonal(normal));
|
||
|
|
vec3 tangent2 = normalize(cross(normal, tangent1));
|
||
|
|
vec3 nearby1 = position + tangent1 * 0.1;
|
||
|
|
vec3 nearby2 = position + tangent2 * 0.1;
|
||
|
|
vec3 distorted1 = nearby1 + normal * displacementMapTexture(tex, crop, uv, mat, vec2(neighbor_offset)) * intensity;
|
||
|
|
vec3 distorted2 = nearby2 + normal * displacementMapTexture(tex, crop, uv, mat, vec2(neighbor_offset)) * intensity;
|
||
|
|
displaced_normal = normalize(cross(distorted1 - displaced_position, distorted2 - displaced_position));
|
||
|
|
return displaced_position;
|
||
|
|
}`,[e,t])}}();var Wa=class extends je{constructor(e=new ze,t=new ze,n=new ze,i=new ze,s=new ze,o=new ze,a=new ze,l=new ze,c=new ze,u=new ze,h=new ze,d=new ze,f=new ze,p=new ze,m=new ze,v=new ze){super("v3");this.nodeType="Noise";this.scale=e,this.size=t,this.move=n,this.fA=i,this.fB=s,this.distortion=o,this.colorA=a,this.colorB=l,this.colorC=c,this.colorD=u,this.intA=h,this.intB=d,this.intC=f,this.intD=p,this.alpha=m,this.noiseFunctionIndex=v}generate(e,t,n,i,s){e.require("uv"),e.requires.uv=[!0];let o=Object.values(Ua)[this.noiseFunctionIndex.value],a=new Le(`vec3 ${o}customNoise(float scale, vec3 size, float move, vec2 fA, vec2 fB, vec2 distortion, vec3 colorA, vec3 colorB, vec3 colorC, vec3 colorD, float intA, float intB, float intC, float intD, float alpha) {
|
||
|
|
vec3 st = position / size;
|
||
|
|
st /= scale;
|
||
|
|
vec3 q = vec3(${o}(st),
|
||
|
|
${o}(st + vec3(1.0)),
|
||
|
|
${o}(st + vec3(1.0)));
|
||
|
|
vec3 r = vec3(${o}(st + vec3(distortion, 1.0) * q + vec3(fA, 1.0) + move),
|
||
|
|
${o}(st + vec3(distortion, 1.0) * q + vec3(fB, 1.0) + move),
|
||
|
|
${o}(st * q));
|
||
|
|
float f = ${o}(st + r);
|
||
|
|
vec3 color;
|
||
|
|
color = mix(colorA * intA, colorB * intB, clamp((f * f) * 4.0, 0.0, 1.0));
|
||
|
|
color = mix(color, colorC * intC, clamp(length(q), 0.0, 1.0));
|
||
|
|
color = mix(color, colorD * intD, clamp(length(r.x), 0.0, 1.0));
|
||
|
|
accumAlpha += (1.0 - accumAlpha) * alpha;
|
||
|
|
return clamp(color, 0.0, 1.0);
|
||
|
|
}`,[si.simplex,si.simplexFractal,si.simplexAshima,si.fbm,si.perlin]),l=e.include(a),c=[];return c.push(this.scale.build(e,"f")),c.push(this.size.build(e,"v3")),c.push(this.move.build(e,"f")),c.push(this.fA.build(e,"v2")),c.push(this.fB.build(e,"v2")),c.push(this.distortion.build(e,"v2")),c.push(this.colorA.build(e,"c")),c.push(this.colorB.build(e,"c")),c.push(this.colorC.build(e,"c")),c.push(this.colorD.build(e,"c")),c.push(this.intA.build(e,"f")),c.push(this.intB.build(e,"f")),c.push(this.intC.build(e,"f")),c.push(this.intD.build(e,"f")),c.push(this.alpha.build(e,"f")),e.format(l+"("+c.join(",")+")",this.getType(e),t)}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.scale=this.scale.toJSON(e).uuid,t.size=this.size.toJSON(e).uuid,t.move=this.move.toJSON(e).uuid,t.fA=this.fA.toJSON(e).uuid,t.fB=this.fB.toJSON(e).uuid,t.distortion=this.distortion.toJSON(e).uuid,t.colorA=this.colorA.toJSON(e).uuid,t.colorB=this.colorB.toJSON(e).uuid,t.colorC=this.colorC.toJSON(e).uuid,t.colorD=this.colorD.toJSON(e).uuid,t.intA=this.intA.toJSON(e).uuid,t.intB=this.intB.toJSON(e).uuid,t.intC=this.intC.toJSON(e).uuid,t.intD=this.intD.toJSON(e).uuid,t.alpha=this.alpha.toJSON(e).uuid),t.noiseFunction=this.noiseFunctionIndex,t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.scale&&(this.scale=t.getNode(e.scale)),e.size&&(this.size=t.getNode(e.size)),e.move&&(this.move=t.getNode(e.move)),e.fA&&(this.fA=t.getNode(e.fA)),e.fB&&(this.fB=t.getNode(e.fB)),e.distortion&&(this.distortion=t.getNode(e.distortion)),e.colorA&&(this.colorA=t.getNode(e.colorA)),e.colorB&&(this.colorB=t.getNode(e.colorB)),e.colorC&&(this.colorC=t.getNode(e.colorC)),e.colorD&&(this.colorD=t.getNode(e.colorD)),e.intA&&(this.intA=t.getNode(e.intA)),e.intB&&(this.intB=t.getNode(e.intB)),e.intC&&(this.intC=t.getNode(e.intC)),e.intD&&(this.intD=t.getNode(e.intD)),e.alpha&&(this.alpha=t.getNode(e.alpha)),e.noiseFunctionIndex&&(this.noiseFunctionIndex=t.getNode(e.noiseFunctionIndex)),this}copy(e){return super.copy(e),this.scale.copy(e.scale),this.size.copy(e.size),this.move.copy(e.move),this.fA.copy(e.fA),this.fB.copy(e.fB),this.distortion.copy(e.distortion),this.colorA.copy(e.colorA),this.colorB.copy(e.colorB),this.colorC.copy(e.colorC),this.colorD.copy(e.colorD),this.intA.copy(e.intA),this.intB.copy(e.intB),this.intC.copy(e.intC),this.intD.copy(e.intD),this.alpha.copy(e.alpha),this.noiseFunctionIndex.copy(e.noiseFunctionIndex),this}};Wa.numOctaves=5;var Ja;(function(i){i.ADD="+",i.SUB="-",i.MUL="*",i.DIV="/"})(Ja||(Ja={}));var Yp=class extends je{constructor(e=new ze,t=new ze,n=Yp.ADD){super();this.nodeType="Operator";this.type=e.type,this.a=e,this.b=t,this.op=n}getType(e){let t=this.a.getType(e),n=this.b.getType(e);return e.isTypeMatrix(t)?"v4":e.getTypeLength(n)>e.getTypeLength(t)?n:t}generate(e,t){let n=this.getType(e);this.type=n;let i=this.a.build(e,n),s=this.b.build(e,n);return e.format("( "+i+" "+this.op+" "+s+" )",n,t)}copy(e){return super.copy(e),this.a.copy(e.a),this.b.copy(e.b),this.op=e.op,this}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.a=this.a.toJSON(e).uuid,t.b=this.b.toJSON(e).uuid,t.op=this.op),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.a&&(this.a=t.getNode(e.a)),e.b&&(this.b=t.getNode(e.b)),e.op&&(this.op=e.op),this}},Yn=Yp;Yn.ADD=Ja.ADD,Yn.SUB=Ja.SUB,Yn.MUL=Ja.MUL,Yn.DIV=Ja.DIV;var Xa=class extends je{constructor(e=new ze,t=new ze,n=new ze,i=new ze){super("v3");this.nodeType="Blend";this.a=e,this.b=t,this.alpha=n,this.mode=i}generate(e,t){if(e.isShader("fragment")){let n=[];return n.push(this.a.build(e,"c")),n.push(this.b.build(e,"c")),n.push(this.alpha.build(e,"f")),n.push(this.mode.build(e,"i")),e.format("spe_blend("+n.join(",")+")",this.getType(e),t)}else return console.warn("BlendNode is not compatible with "+e.shader+" shader."),e.format("vec3( 0.0 )",this.getType(e),t)}copy(e){return super.copy(e),this.a.copy(e.a),this.b.copy(e.b),this.alpha.copy(e.alpha),this.mode.copy(e.mode),this}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),
|
||
|
|
float dist;
|
||
|
|
if (isVector > 0.5) {
|
||
|
|
dist = (isWorldSpace > 0.5) ? length(vWPosition - origin) : length(position - origin);
|
||
|
|
} else {
|
||
|
|
dist = length (vWPosition - cameraPosition);
|
||
|
|
}
|
||
|
|
float dep = ( dist - near ) / ( far - near );
|
||
|
|
vec3 depth = mix( colorB, colorA, 1.0 - clamp( dep, 0., 1. ) );
|
||
|
|
|
||
|
|
accumAlpha += ( 1.0 - accumAlpha ) * alpha;
|
||
|
|
|
||
|
|
return depth;
|
||
|
|
}`)}}();var Qp=class extends je{constructor(e,t,n,i){super("v3");this.nodeType="Matcap";this.color=e,this.texture=t,this.alpha=n,this.mode=i,this.calpha=`g${this.uuid.toString().replace(/-/g,"")}_calpha`}generate(e,t){if(e.isShader("fragment")){e.addFragmentVariable(this.calpha,"float");let n=e.include(Qp.Nodes.matcap);e.require("normal"),e.requires.normal=!0;let i=[];return i.push(this.color.build(e,"v3")),i.push(this.texture.getTexture(e,"t")),i.push("normal"),i.push(this.alpha.build(e,"f")),i.push(this.mode.build(e,"i")),i.push(this.calpha),e.format(n+"("+i.join(",")+")",this.getType(e),t)}else return console.warn("MatcapNode is not compatible with "+e.shader+" shader."),e.format("vec3( 0.0 )",this.getType(e),t)}copy(e){return super.copy(e),this.texture=e.texture.clone(),this.color=e.color.clone(),this.alpha=e.alpha.clone(),this.mode=e.mode.clone(),this.calpha=e.calpha,this}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.texture=this.texture.toJSON(e).uuid,t.color=this.color.toJSON(e).uuid,t.alpha=this.alpha.toJSON(e).uuid,t.mode=this.mode.toJSON(e).uuid,t.calpha=this.calpha),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.calpha&&(this.calpha=e.calpha),e.alpha&&(this.alpha=t.getNode(e.alpha)),e.texture&&(this.texture=t.getNode(e.texture)),e.color&&(this.color=t.getNode(e.color)),e.mode&&(this.mode=t.getNode(e.mode)),this}},Ya=Qp;Ya.Nodes=function(){return{matcap:new Le(`vec3 matcap(vec3 color, sampler2D matcapTex, vec3 normal, float alpha, int mode, out float calpha) {
|
||
|
|
vec3 viewDir = normalize( vViewPosition );
|
||
|
|
vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );
|
||
|
|
vec3 y = cross( viewDir, x );
|
||
|
|
vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5; // 0.495 to remove artifacts caused by undersized matcap disks
|
||
|
|
vec4 matcapColor = texture2D( matcapTex, uv );
|
||
|
|
// matcapColor = matcapTexelToLinear( matcapColor );
|
||
|
|
matcapColor.rgb *= color;
|
||
|
|
|
||
|
|
calpha = alpha / clamp( alpha + accumAlpha, 0.00001, 1.0 );
|
||
|
|
accumAlpha += ( 1.0 - accumAlpha ) * alpha;
|
||
|
|
|
||
|
|
return matcapColor.rgb;
|
||
|
|
}
|
||
|
|
`)}}();var Kn=class{constructor(e){this.id=2,this.layerCount=2,this.uuid=Ee.generateUUID(),this.needsUpdate=!1,this._material=e,this._layerNodes=[];let t=this._createLayer({id:0,type:lt.COLOR});this._material.color=t.color,this._material.alpha===void 0&&(this._material.alpha=new Te(1));let n=new Te(1),i=new it(0);"shadingAlpha"in this._material&&"shadingBlend"in this._material&&(this._material.shadingAlpha=n,this._material.shadingBlend=i),this._layerNodes.push({id:0,type:Gt.COLOR,color:t.color,alpha:t.alpha,mode:t.mode}),this._layerNodes.push({id:1,type:Gt.LIGHTING,alpha:n,mode:i}),this.head=t.layer,this.head.next=new jt(1,{type:lt.LIGHTING,alpha:n,mode:i}),this.attachLightNodes()}get material(){return this._material}set material(e){this._material=e;let t,n,i=this.head;for(;i!==void 0;){if(i.type===lt.LIGHTING){t=i.uniforms[`f${i.id}_alpha`],n=i.uniforms[`f${i.id}_mode`];break}i=i.next}"shadingAlpha"in this._material&&"shadingBlend"in this._material&&(this._material.shadingAlpha=t,this._material.shadingBlend=n),this.attachLightNodes(),this.blendColors(),this.blendAfterColors(),this.blendPositions()}getLayersOfType(e){let t=[],n=this.head;for(;n;)n.type===e&&t.push(n),n=n.next;return t}addLayer(e){var i;if(e.id=(i=e.id)!=null?i:++this.id,this.layerCount++,e.type===lt.LIGHTING){let s=this.createLightLayer(e);return this.uuid=Ee.generateUUID(),this.blendColors(),this.blendAfterColors(),this.blendPositions(),s}let t=this._createLayer(e),n=t.layer;if(this.head===void 0)this.head=n;else{let s=this.head;for(;s.next!=null;)s=s.next;s.next=n}return t.color&&this._layerNodes.push({id:n.id,type:Gt.COLOR,color:t.color,alpha:t.alpha,mode:t.mode}),t.position&&this._layerNodes.push({id:n.id,type:Gt.POSITION,position:t.position}),this.uuid=Ee.generateUUID(),this.blendColors(),this.blendAfterColors(),this.blendPositions(),n}addLayerBeforeAt(e,t){var a;let n=this.head;e.id=(a=e.id)!=null?a:++this.id,this.layerCount++;let i=this._createLayer(e),s=i.layer;s.next=t;let o=0;if(n===t)this.head=s,i.color&&this._layerNodes.splice(0,0,{id:s.id,type:Gt.COLOR,color:i.color,alpha:i.alpha,mode:i.mode}),i.position&&this._layerNodes.splice(0,0,{id:s.id,type:Gt.POSITION,position:i.position});else{for(o=1;(n==null?void 0:n.next)!==t;)n=n==null?void 0:n.next,o++;n.next=s,i.color&&this._layerNodes.splice(o,0,{id:s.id,type:Gt.COLOR,color:i.color,alpha:i.alpha,mode:i.mode}),i.position&&this._layerNodes.splice(o,0,{id:s.id,type:Gt.POSITION,position:i.position})}return this.uuid=Ee.generateUUID(),this.blendColors(),this.blendAfterColors(),this.blendPositions(),s}addLayerAt(e,t){var s;t.id=(s=t.id)!=null?s:++this.id,this.layerCount++;let n=this._createLayer(t),i=n.layer;if(n.color&&this._layerNodes.splice(e,0,{id:i.id,type:Gt.COLOR,color:n.color,alpha:n.alpha,mode:n.mode}),n.position&&this._layerNodes.splice(e,0,{id:i.id,type:Gt.POSITION,position:n.position}),e==0)i.next=this.head,this.head=i;else{let o=this.head,a=this.head.next;for(let l=0;l<e-1;l++)o=a,a=a.next;i.next=a,o.next=i}return this.uuid=Ee.generateUUID(),this.blendColors(),this.blendAfterColors(),this.blendPositions(),i}removeLayer(e){let t=this.head,n,i=0;if((t==null?void 0:t.id)==e)this.head=t.next;else for(i=1,n=t,t=t==null?void 0:t.next;t!=null;){if(t.id==e){n.next=t.next;break}i++,n=t,t=t.next}return this.cleanupChangedLayer(t),this.blendColors(),this.blendAfterColors(),this.blendPositions(),this.uuid=Ee.generateUUID(),this.layerCount--,i}changeLayer(e,t){let n,i=this.head,s;if((i==null?void 0:i.id)==e){let o=this._createLayer(Ue({id:e},t));s=o.layer,s.next=i.next,this.head=s,o.color&&(this._layerNodes[0]={id:s.id,type:Gt.COLOR,color:o.color,alpha:o.alpha,mode:o.mode}),o.position&&(this._layerNodes[0]={id:s.id,type:Gt.POSITION,position:o.position}),s.uniforms[`f${e}_mode`].value=i.uniforms[`f${e}_mode`].value,s.uniforms[`f${e}_alpha`].value=i.uniforms[`f${e}_alpha`].value}else{n=i,i=i.next;let o=1;for(;i!=null;){if(i.id==e){let a=this._createLayer(Ue({id:e},t));s=a.layer,n.next=s,s.next=i.next,a.color&&(this._layerNodes[o]={id:s.id,type:Gt.COLOR,color:a.color,alpha:a.alpha,mode:a.m
|
||
|
|
)*?)}`,"gim"),AL=new RegExp("s*(w*?)s*(w*?)(=|;)","gim"),Ao=class extends je{constructor(e=""){super();this.inputs=[];this.src="";this.nodeType="Struct";this.parse(e)}getType(e){return e.getTypeByFormat(this.name)}getInputByName(e){let t=this.inputs.length;for(;t--;)if(this.inputs[t].name===e)return this.inputs[t]}generate(e,t,n,i,s){return t==="source"?this.src+";":e.format("( "+this.src+" )",this.getType(e),t)}parse(e=""){this.src=e,this.inputs=[];let t=ML.exec(e);if(t){let n=t[2],i;for(;i=AL.exec(n);)this.inputs.push({type:i[1],name:i[2]});this.name=t[1]}else this.name="";this.type=this.name}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.src=this.src),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.src&&(this.src=e.src,this.parse(this.src)),this}};var Ch=class extends je{constructor(e,t){super();this.inputs=[];this.nodeType="FunctionCall";this.value=e,this.inputs=t!=null?t:[]}getFunction(){return this.value}getType(e){return this.value.getType(e)}generate(e,t,n,i,s){i=this.getType(e);let o=this.value,a=o.build(e,t)+"( ",l=[];if(o.inputs){for(let c=0;c<o.inputs.length;c++){let u=o.inputs[c],h=this.inputs[c]||this.inputs[u.name];l.push(h.build(e,e.getTypeByFormat(u.type)))}a+=l.join(", ")+" )"}return e.format(a,i,t)}copy(e){return super.copy(e),this.value.copy(e.value),this.inputs=e.inputs.map(t=>t.clone()),this}toJSON(e){var n;let t=this.getJSONNode(e);if(!t){let i=this.value;if(t=this.createJSONNode(e),t.value=this.value.toJSON(e).uuid,(n=i.inputs)==null?void 0:n.length){t.inputs={};for(let s=0;s<i.inputs.length;s++){let o=i.inputs[s],a=this.inputs[s];t.inputs[o.name]=a.toJSON(e).uuid}}}return t}};var st;(function(D){D.RAD="radians",D.DEG="degrees",D.EXP="exp",D.EXP2="exp2",D.LOG="log",D.LOG2="log2",D.SQRT="sqrt",D.INV_SQRT="inversesqrt",D.FLOOR="floor",D.CEIL="ceil",D.NORMALIZE="normalize",D.FRACT="fract",D.SATURATE="saturate",D.SIN="sin",D.COS="cos",D.TAN="tan",D.ASIN="asin",D.ACOS="acos",D.ARCTAN="atan",D.ABS="abs",D.SIGN="sign",D.LENGTH="length",D.NEGATE="negate",D.INVERT="invert",D.MIN="min",D.MAX="max",D.MOD="mod",D.STEP="step",D.REFLECT="reflect",D.DISTANCE="distance",D.DOT="dot",D.CROSS="cross",D.POW="pow",D.MIX="mix",D.CLAMP="clamp",D.REFRACT="refract",D.SMOOTHSTEP="smoothstep",D.FACEFORWARD="faceforward"})(st||(st={}));var St=class extends je{constructor(e=new ze,t=St.ABS,n,i){super();this.nodeType="Math";this.a=e,typeof t!="string"?this.b=t:i=t,typeof n!="string"?this.c=n:i=n,this.method=i,this.hashProperties=["method"]}getNumInputs(e){switch(this.method){case St.MIX:case St.CLAMP:case St.REFRACT:case St.SMOOTHSTEP:case St.FACEFORWARD:return 3;case St.MIN:case St.MAX:case St.MOD:case St.STEP:case St.REFLECT:case St.DISTANCE:case St.DOT:case St.CROSS:case St.POW:return 2;default:return 1}}getInputType(e){let t=e.getTypeLength(this.a.getType(e)),n=this.b?e.getTypeLength(this.b.getType(e)):0,i=this.c?e.getTypeLength(this.c.getType(e)):0;return t>n&&t>i?this.a.getType(e):n>i?this.b.getType(e):this.c.getType(e)}getType(e){switch(this.method){case St.LENGTH:case St.DISTANCE:case St.DOT:return"f";case St.CROSS:return"v3"}return this.getInputType(e)}generate(e,t){let n,i,s,o=this.a?e.getTypeLength(this.a.getType(e)):0,a=this.b?e.getTypeLength(this.b.getType(e)):0,l=this.c?e.getTypeLength(this.c.getType(e)):0,c=this.getInputType(e),u=this.getType(e);switch(this.type=u,this.method){case St.NEGATE:return e.format("( -"+this.a.build(e,c)+" )",c,t);case St.INVERT:return e.format("( 1.0 - "+this.a.build(e,c)+" )",c,t);case St.CROSS:n=this.a.build(e,"v3"),i=this.b.build(e,"v3");break;case St.STEP:n=this.a.build(e,o===1?"f":c),i=this.b.build(e,c);break;case St.MIN:case St.MAX:case St.MOD:n=this.a.build(e,c),i=this.b.build(e,a===1?"f":c);break;case St.REFRACT:n=this.a.build(e,c),i=this.b.build(e,c),s=this.c.build(e,"f");break;case St.MIX:n=this.a.build(e,c),i=this.b.build(e,c),s=this.c.build(e,l===1?"f":c);break;default:n=this.a.build(e,c),this.b&&(i=this.b.build(e,c)),this.c&&(s=this.c.build(e,c));break}let h=[];h.push(n),i&&h.push(i),s&&h.push(s);let d=this.getNumInputs(e)
|
||
|
|
vec4 tl;
|
||
|
|
vec4 tr;
|
||
|
|
vec4 br;
|
||
|
|
vec4 bl;
|
||
|
|
vec2 f;
|
||
|
|
}`),t=new rt("float cubeUV_maxMipLevel 8.0",!0),n=new rt("float cubeUV_minMipLevel 4.0",!0),i=new rt("float cubeUV_maxTileSize 256.0",!0),s=new rt("float cubeUV_minTileSize 16.0",!0),o=new Le(`float getFace(vec3 direction) {
|
||
|
|
vec3 absDirection = abs(direction);
|
||
|
|
float face = -1.0;
|
||
|
|
if (absDirection.x > absDirection.z) {
|
||
|
|
if (absDirection.x > absDirection.y)
|
||
|
|
face = direction.x > 0.0 ? 0.0 : 3.0;
|
||
|
|
else
|
||
|
|
face = direction.y > 0.0 ? 1.0 : 4.0;
|
||
|
|
} else {
|
||
|
|
if (absDirection.z > absDirection.y)
|
||
|
|
face = direction.z > 0.0 ? 2.0 : 5.0;
|
||
|
|
else
|
||
|
|
face = direction.y > 0.0 ? 1.0 : 4.0;
|
||
|
|
}
|
||
|
|
return face;
|
||
|
|
}`);o.useKeywords=!1;let a=new Le(`vec2 getUV(vec3 direction, float face) {
|
||
|
|
vec2 uv;
|
||
|
|
if (face == 0.0) {
|
||
|
|
uv = vec2(direction.z, direction.y) / abs(direction.x); // pos x
|
||
|
|
} else if (face == 1.0) {
|
||
|
|
uv = vec2(-direction.x, -direction.z) / abs(direction.y); // pos y
|
||
|
|
} else if (face == 2.0) {
|
||
|
|
uv = vec2(-direction.x, direction.y) / abs(direction.z); // pos z
|
||
|
|
} else if (face == 3.0) {
|
||
|
|
uv = vec2(-direction.z, direction.y) / abs(direction.x); // neg x
|
||
|
|
} else if (face == 4.0) {
|
||
|
|
uv = vec2(-direction.x, direction.z) / abs(direction.y); // neg y
|
||
|
|
} else {
|
||
|
|
uv = vec2(direction.x, direction.y) / abs(direction.z); // neg z
|
||
|
|
}
|
||
|
|
return 0.5 * (uv + 1.0);
|
||
|
|
}`);a.useKeywords=!1;let l=new Le(`TextureCubeUVData bilinearCubeUV(sampler2D envMap, vec3 direction, float mipInt) {
|
||
|
|
float face = getFace(direction);
|
||
|
|
float filterInt = max(cubeUV_minMipLevel - mipInt, 0.0);
|
||
|
|
mipInt = max(mipInt, cubeUV_minMipLevel);
|
||
|
|
float faceSize = exp2(mipInt);
|
||
|
|
float texelSize = 1.0 / (3.0 * cubeUV_maxTileSize);
|
||
|
|
vec2 uv = getUV(direction, face) * (faceSize - 1.0);
|
||
|
|
vec2 f = fract(uv);
|
||
|
|
uv += 0.5 - f;
|
||
|
|
if (face > 2.0) {
|
||
|
|
uv.y += faceSize;
|
||
|
|
face -= 3.0;
|
||
|
|
}
|
||
|
|
uv.x += face * faceSize;
|
||
|
|
if(mipInt < cubeUV_maxMipLevel){
|
||
|
|
uv.y += 2.0 * cubeUV_maxTileSize;
|
||
|
|
}
|
||
|
|
uv.y += filterInt * 2.0 * cubeUV_minTileSize;
|
||
|
|
uv.x += 3.0 * max(0.0, cubeUV_maxTileSize - 2.0 * faceSize);
|
||
|
|
uv *= texelSize;
|
||
|
|
vec4 tl = texture2D(envMap, uv);
|
||
|
|
uv.x += texelSize;
|
||
|
|
vec4 tr = texture2D(envMap, uv);
|
||
|
|
uv.y += texelSize;
|
||
|
|
vec4 br = texture2D(envMap, uv);
|
||
|
|
uv.x -= texelSize;
|
||
|
|
vec4 bl = texture2D(envMap, uv);
|
||
|
|
return TextureCubeUVData( tl, tr, br, bl, f );
|
||
|
|
}`,[e,o,a,t,n,i,s]);l.useKeywords=!1;let c=new rt("float r0 1.0",!0),u=new rt("float v0 0.339",!0),h=new rt("float m0 -2.0",!0),d=new rt("float r1 0.8",!0),f=new rt("float v1 0.276",!0),p=new rt("float m1 -1.0",!0),m=new rt("float r4 0.4",!0),v=new rt("float v4 0.046",!0),g=new rt("float m4 2.0",!0),y=new rt("float r5 0.305",!0),x=new rt("float v5 0.016",!0),b=new rt("float m5 3.0",!0),w=new rt("float r6 0.21",!0),_=new rt("float v6 0.0038",!0),S=new rt("float m6 4.0",!0),A=[c,u,h,d,f,p,m,v,g,y,x,b,w,_,S],T=new Le(`float roughnessToMip(float roughness) {
|
||
|
|
float mip = 0.0;
|
||
|
|
if (roughness >= r1) {
|
||
|
|
mip = (r0 - roughness) * (m1 - m0) / (r0 - r1) + m0;
|
||
|
|
} else if (roughness >= r4) {
|
||
|
|
mip = (r1 - roughness) * (m4 - m1) / (r1 - r4) + m1;
|
||
|
|
} else if (roughness >= r5) {
|
||
|
|
mip = (r4 - roughness) * (m5 - m4) / (r4 - r5) + m4;
|
||
|
|
} else if (roughness >= r6) {
|
||
|
|
mip = (r5 - roughness) * (m6 - m5) / (r5 - r6) + m5;
|
||
|
|
} else {
|
||
|
|
mip = -2.0 * log2(1.16 * roughness);// 1.16 = 1.79^0.25
|
||
|
|
}
|
||
|
|
return mip;
|
||
|
|
}`,A);return{bilinearCubeUV:l,roughnessToMip:T,m0:h,cubeUV_maxMipLevel:t}}();var To=class extends je{constructor(e){super("v3");this.nodeType="Normal";this.scope=e!=null?e:To.VIEW}getShared(){return this.scope===To.WORLD}build(e,t,n,i){let s=e.context[this.scope+"Normal"];return s?s.build(e,t,n,i):super.build(e,t,n)}generate(e,t,n,i,s){let o;switch(this.scope){case To.VIEW:e.isShader("vertex")?o="transformedNormal":o="geometryNormal";break;case To.LOCAL:e.isShader("vertex")?o="objectNormal":(e.requires.normal=!0,o="vObjectNormal");break;case To.WORLD:e.isShader("vertex")?o="inverseTransformDirection( transformedNormal, viewMatrix ).xyz":(e.requires.worldNormal=!0,o="vWNormal");break}return e.format(o,this.getType(e),t)}copy(e){return super.copy(e),this.scope=e.scope,this}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.scope=this.scope),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.scope&&(this.scope=e.scope),this}},mn=To;mn.LOCAL="local",mn.WORLD="world",mn.VIEW="view",mn.NORMAL="normal";pn.addKeyword("viewNormal",function(){return new mn(mn.VIEW)});pn.addKeyword("localNormal",function(){return new mn(mn.NORMAL)});pn.addKeyword("worldNormal",function(){return new mn(mn.WORLD)});var dr=class extends je{constructor(e){super("v3");this.nodeType="Position";this.scope=e!=null?e:dr.LOCAL}getType(){switch(this.scope){case dr.PROJECTION:return"v4"}return this.type}getShader(){switch(this.scope){case dr.LOCAL:case dr.WORLD:return!1}return!0}generate(e,t,n,i,s){let o;switch(this.scope){case dr.LOCAL:e.isShader("vertex")?o="transformed":(e.requires.position=!0,o="vPosition");break;case dr.WORLD:if(e.isShader("vertex"))return"( modelMatrix * vec4( transformed, 1.0 ) ).xyz";e.requires.worldPosition=!0,o="vWPosition";break;case dr.VIEW:o=e.isShader("vertex")?"-mvPosition.xyz":"vViewPosition";break;case dr.PROJECTION:o=e.isShader("vertex")?"( projectionMatrix * modelViewMatrix * vec4( position, 1.0 ) )":"vec4( 0.0 )";break}return e.format(o,this.getType(),t)}copy(e){return super.copy(e),this.scope=e.scope,this}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.scope=this.scope),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.scope&&(this.scope=e.scope),this}},_n=dr;_n.LOCAL="local",_n.WORLD="world",_n.VIEW="view",_n.PROJECTION="projection";pn.addKeyword("position",function(){return new _n});pn.addKeyword("worldPosition",function(){return new _n(_n.WORLD)});pn.addKeyword("viewPosition",function(){return new _n(_n.VIEW)});var Zi=class extends je{constructor(e){super("v3");this.nodeType="Reflect";this.scope=e!=null?e:Zi.CUBE}getUnique(e){return!e.context.viewNormal}getType(){switch(this.scope){case Zi.SPHERE:return"v2"}return this.type}generate(e,t){let n=this.getUnique(e);if(e.isShader("fragment")){let i;switch(this.scope){case Zi.VECTOR:{let s=new mn(mn.VIEW),o=e.context.roughness,a=s.build(e,"v3"),l=new _n(_n.VIEW).build(e,"v3"),c=o?o.build(e,"f"):void 0,u=`reflect( -normalize( ${l} ), ${a} )`;c&&(u=`normalize( mix( ${u}, ${a}, ${c} * ${c} ) )`);let h=`inverseTransformDirection( ${u}, viewMatrix )`;n?(e.addNodeCode(`vec3 reflectVec = ${h};`),i="reflectVec"):i=h;break}case Zi.CUBE:{let s=new Zi(Zi.VECTOR).build(e,"v3"),o="vec3( -"+s+".x, "+s+".yz )";n?(e.addNodeCode(`vec3 reflectCubeVec = ${o};`),i="reflectCubeVec"):i=o;break}case Zi.SPHERE:{let s=new Zi(Zi.VECTOR).build(e,"v3"),o="normalize( ( viewMatrix * vec4( "+s+", 0.0 ) ).xyz + vec3( 0.0, 0.0, 1.0 ) ).xy * 0.5 + 0.5";n?(e.addNodeCode(`vec2 reflectSphereVec = ${o};`),i="reflectSphereVec"):i=o;break}}return e.format(i,this.getType(),t)}else return console.warn("ReflectNode is not compatible with "+e.shader+" shader."),e.format("vec3( 0.0 )",this.type,t)}copy(e){return super.copy(e),this.scope=e.scope,this}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.scope=this.scope),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.scope&&(this.scope=e.scope),this}},Qi=Zi;Qi.CUBE="cube",Qi.SPHERE="sphere",Qi.VECTOR="vector";var vc=class extends je{constr
|
||
|
|
`);return o}}();this.slots=[],this.caches=[],this.contexts=[],this.keywords={},this.nodeData={},this.fragmentVariables={},this.requires={uv:[],color:[],lights:!1,fog:!1,transparent:!1,irradiance:!1,position:!1,worldPosition:!1,normal:!1,worldNormal:!1,vWorldViewDir:!1,vWorldNormal:!1,modelMatrix:!1,viewMatrix:!1,projectionMatrix:!1},this.includes={consts:[],functions:[],structs:[]},this.attributes={},this.prefixCode=["#ifdef TEXTURE_LOD_EXT"," #define texCube(a, b) textureCube(a, b)"," #define texCubeBias(a, b, c) textureCubeLodEXT(a, b, c)"," #define tex2D(a, b) texture2D(a, b)"," #define tex2DBias(a, b, c) texture2DLodEXT(a, b, c)","#else"," #define texCube(a, b) textureCube(a, b)"," #define texCubeBias(a, b, c) textureCube(a, b, c)"," #define tex2D(a, b) texture2D(a, b)"," #define tex2DBias(a, b, c) texture2D(a, b, c)","#endif",`
|
||
|
|
// NOTE: Include Spline's blending modes. This could be part of BlendNode
|
||
|
|
#define SPE_BLENDING_NORMAL 0
|
||
|
|
#define SPE_BLENDING_MULTIPLY 1
|
||
|
|
#define SPE_BLENDING_SCREEN 2
|
||
|
|
#define SPE_BLENDING_OVERLAY 3
|
||
|
|
|
||
|
|
vec3 spe_normalBlend( vec3 a, vec3 b, float alpha ) {
|
||
|
|
return mix( a, b, alpha );
|
||
|
|
}
|
||
|
|
|
||
|
|
vec3 spe_multiplyBlend( vec3 a, vec3 b, float alpha ) {
|
||
|
|
return mix( a, a * b, alpha );
|
||
|
|
}
|
||
|
|
|
||
|
|
vec3 spe_screenBlend( vec3 a, vec3 b, float alpha ) {
|
||
|
|
vec3 tmp = 1.0 - ( 1.0 - a ) * ( 1.0 - b );
|
||
|
|
return mix( a, tmp, alpha );
|
||
|
|
}
|
||
|
|
|
||
|
|
vec3 spe_overlayBlend( vec3 a, vec3 b, float alpha ) {
|
||
|
|
vec3 tmp = mix( 1. - 2. * (1. - a) * (1. - b), 2. * a * b, step( a, vec3(.5) ) );
|
||
|
|
return clamp( mix( a, tmp, alpha ), 0.0, 1.0 );
|
||
|
|
}
|
||
|
|
|
||
|
|
vec3 spe_blend( vec3 a, vec3 b, float alpha, int mode ) {
|
||
|
|
if ( mode == SPE_BLENDING_NORMAL ) return spe_normalBlend( a, b, alpha );
|
||
|
|
else if ( mode == SPE_BLENDING_MULTIPLY ) return spe_multiplyBlend( a, b, alpha );
|
||
|
|
else if ( mode == SPE_BLENDING_SCREEN ) return spe_screenBlend( a, b, alpha );
|
||
|
|
else if ( mode == SPE_BLENDING_OVERLAY ) return spe_overlayBlend( a, b, alpha );
|
||
|
|
return vec3( 1.0 );
|
||
|
|
}
|
||
|
|
`,"#include <packing>","#include <common>"].join(`
|
||
|
|
`),this.parsCode={vertex:["float neighbor_offset = 0.0001;",""].join(`
|
||
|
|
`),fragment:["float accumAlpha = 0.0;",`void accumulateAlpha(float alpha) {
|
||
|
|
accumAlpha += (1.0 - accumAlpha) * alpha;
|
||
|
|
}`,""].join(`
|
||
|
|
`)},this.code={vertex:"",fragment:""},this.nodeCode={vertex:"",fragment:""},this.resultCode={vertex:"",fragment:""},this.finalCode={vertex:"",fragment:""},this.inputs={uniforms:{list:[],vertex:[],fragment:[]},arrayUniforms:{list:[],vertex:[],fragment:[]},vars:{varying:[],vertex:[],fragment:[]}},this.defines={},this.uniforms={},this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.updaters=[],this.nodes=[],this.analyzing=!1}build(e,t){this.buildShader("vertex",e),this.buildShader("fragment",t);for(let n=0;n<this.requires.uv.length;n++)if(this.requires.uv[n]){let i=n>0?n+1:"";this.addVaryCode("varying vec2 vUv"+i+";"),n>0&&this.addVertexParsCode("attribute vec2 uv"+i+";"),this.addVertexFinalCode("vUv"+i+" = uv"+i+";")}return this.requires.color[0]&&(this.addVaryCode("varying vec4 vColor;"),this.addVertexParsCode("attribute vec4 color;"),this.addVertexFinalCode("vColor = color;")),this.requires.color[1]&&(this.addVaryCode("varying vec4 vColor2;"),this.addVertexParsCode("attribute vec4 color2;"),this.addVertexFinalCode("vColor2 = color2;")),this.requires.position&&(this.addVaryCode("varying vec3 vPosition;"),this.addVertexFinalCode("vPosition = transformed;")),this.requires.worldPosition&&(this.addVaryCode("varying vec3 vWPosition;"),this.addVertexFinalCode("vWPosition = ( modelMatrix * vec4( transformed, 1.0 ) ).xyz;")),this.requires.normal&&(this.addVaryCode("varying vec3 vObjectNormal;"),this.addVertexFinalCode("vObjectNormal = normal;")),this.requires.modelMatrix&&this.addFragmentParsCode("uniform mat4 modelMatrix;"),this.requires.viewMatrix&&this.addFragmentParsCode("uniform mat4 viewMatrix;"),this.requires.projectionMatrix&&this.addFragmentParsCode("uniform mat4 projectionMatrix;"),this.requires.worldNormal&&(this.addVaryCode("varying vec3 vWNormal;"),this.addVertexFinalCode("vWNormal = inverseTransformDirection( transformedNormal, viewMatrix ).xyz;")),this.requires.vWorldViewDir&&(this.addVaryCode("varying vec3 vWorldViewDir;"),this.addVertexFinalCode("vWorldViewDir = isPerspectiveMatrix( projectionMatrix ) ? ( (modelMatrix * vec4(position, 1.0)).xyz - cameraPosition ) : vec3( -viewMatrix[0][2], -viewMatrix[1][2], -viewMatrix[2][2] );")),this.requires.vWorldNormal&&(this.addVaryCode("varying vec3 vWorldNormal;"),this.addVertexFinalCode("vWorldNormal = normalize( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );")),this}buildShader(e,t){this.resultCode[e]=t.build(this.setShader(e),"v4")}setMaterial(e,t){return this.material=e,this.renderer=t,this.requires.lights=e.lights,this.requires.fog=e.fog,this.mergeDefines(e.defines),this}addFlow(e,t,n){return this.addSlot(e).addCache(t).addContext(n)}removeFlow(){return this.removeSlot().removeCache().removeContext()}addCache(e){return this.cache=e!=null?e:"",this.caches.push(this.cache),this}removeCache(){return this.caches.pop(),this.cache=this.caches[this.caches.length-1]||"",this}addContext(e){return this.context=Object.assign({},this.context,e),this.context.extra=this.context.extra||{},this.contexts.push(this.context),this}removeContext(){return this.contexts.pop(),this.context=this.contexts[this.contexts.length-1]||{},this}addSlot(e){return this.slot=e||"",this.slots.push(this.slot),this}removeSlot(){return this.slots.pop(),this.slot=this.slots[this.slots.length-1]||"",this}addFragmentVariable(e,t){this.fragmentVariables[e]===void 0&&(this.addFragmentCode(`${t} ${e};`),this.fragmentVariables[e]="")}addVertexCode(e){this.addCode(e,"vertex")}addFragmentCode(e){this.addCode(e,"fragment")}addCode(e,t){this.code[t!=null?t:this.shader]+=e+`
|
||
|
|
`}addVertexNodeCode(e){this.addNodeCode(e,"vertex")}addFragmentNodeCode(e){this.addNodeCode(e,"fragment")}addNodeCode(e,t){this.nodeCode[t!=null?t:this.shader]+=e+`
|
||
|
|
`}clearNodeCode(e){e=e!=null?e:this.shader;let t=this.nodeCode[e];return this.nodeCode[e]="",t}clearVertexNodeCode(){return this.clearNodeCode("vertex")}clearFragmentNodeCode(){return this.clearNodeCode("fragment")}addVertexFinalCode(e){this.addFinalCode(e,"vertex")}addFragmentFinalCode(e){this.addFinalCode(e,"fragment")}addFinalCode(e,t){this.finalCode[t!=null?t:this.shader]+=e+`
|
||
|
|
`}addVertexParsCode(e){this.addParsCode(e,"vertex")}addFragmentParsCode(e){this.addParsCode(e,"fragment")}addParsCode(e,t){this.parsCode[t!=null?t:this.shader]+=e+`
|
||
|
|
`}addVaryCode(e){this.addVertexParsCode(e),this.addFragmentParsCode(e)}isCache(e){return this.caches.indexOf(e)!==-1}isSlot(e){return this.slots.indexOf(e)!==-1}define(e,t){this.defines[e]=t===void 0?1:t}require(e){this.requires[e]=!0}isDefined(e){return this.defines[e]!==void 0}getVar(e,t,n,i="varying",s="V",o=""){let a=this.getVars(i),l=a[e];if(!l){let c=a.length;l={name:n||"node"+s+c+(o?"_"+o:""),type:t},a.push(l),a[e]=l}return l}getTempVar(e,t,n,i){return this.getVar(e,t,n,this.shader,"T",i)}getAttribute(e,t){if(!this.attributes[e]){let n=this.getVar(e,t);this.addVertexParsCode("attribute "+t+" "+e+";"),this.addVertexFinalCode(n.name+" = "+e+";"),this.attributes[e]={varying:n,name:e,type:t}}return this.attributes[e]}getCode(e){return[this.prefixCode,this.parsCode[e],this.getVarListCode(this.getVars("varying"),"varying"),this.getVarListCode(this.inputs.uniforms[e],"uniform"),this.getVarListCode(this.inputs.arrayUniforms[e],"uniform"),this.getIncludesCode("consts",e),this.getIncludesCode("structs",e),this.getIncludesCode("functions",e),"void main() {",this.getVarListCode(this.getVars(e)),this.code[e],this.resultCode[e],this.finalCode[e],"}"].join(`
|
||
|
|
`)}getVarListCode(e,t){t=t!=null?t:"";let n="";for(let i=0,s=e.length;i<s;++i){let o=e[i],a=o.type,l=o.name,c=o.size,u=this.getFormatByType(a);if(u===void 0)throw new Error("Node pars "+u+" not found.");u.includes("[]")?n+=t+" "+u.substring(0,u.length-2)+" "+l+`[${c}];
|
||
|
|
`:n+=t+" "+u+" "+l+`;
|
||
|
|
`}return n}getVars(e){return this.inputs.vars[e!=null?e:this.shader]}getNodeData(e){let t=e instanceof ze?e.uuid:e;return this.nodeData[t]=this.nodeData[t]||{}}createUniform(e,t,n,i,s,o){if(t.includes("[]")){let a=this.inputs.arrayUniforms,l=a.list.length,c=new Nh({type:t,size:n.size,name:i||"nodeUA"+l+(o?"_"+o:""),node:n,needsUpdate:s});return a.list.push(c),a[e].push(c),a[e][c.name]=c,this.uniforms[c.name]=c,c}else{let a=this.inputs.uniforms,l=a.list.length,c=new Nh({type:t,name:i||"nodeU"+l+(o?"_"+o:""),node:n,needsUpdate:s});return a.list.push(c),a[e].push(c),a[e][c.name]=c,this.uniforms[c.name]=c,c}}createVertexUniform(e,t,n,i,s){return this.createUniform("vertex",e,t,n,i,s)}createFragmentUniform(e,t,n,i,s){return this.createUniform("fragment",e,t,n,i,s)}include(e,t,n){var o;let i;if(e=typeof e=="string"?pn.get(e):e,this.context.include===!1)return e.name;e instanceof Le?i=this.includes.functions:e instanceof rt?i=this.includes.consts:e instanceof Ao&&(i=this.includes.structs);let s=i[this.shader]=i[this.shader]||[];if(e){let a=s[e.name];if(a||(a=s[e.name]={node:e,deps:[]},s.push(a),a.src=e.build(this,"source")),e instanceof Le&&t&&s[t.name]&&s[t.name].deps.indexOf(e)==-1&&(s[t.name].deps.push(e),(o=e.includes)==null?void 0:o.length)){let l=0;do this.include(e.includes[l++],t);while(l<e.includes.length)}return n&&(a.src=n),e.name}else throw new Error("Include not found.")}colorToVectorProperties(e){return e.replace("r","x").replace("g","y").replace("b","z").replace("a","w")}colorToVector(e){return e.replace(/c/g,"v3")}getIncludes(e,t){return this.includes[e][t||this.shader]}getConstructorFromLength(e){return _L[e-1]}isTypeMatrix(e){return/^m/.test(e)}getTypeLength(e){return e==="f"?1:parseInt(this.colorToVector(e).substr(1))}getTypeFromLength(e){return e===1?"f":"v"+e}findNode(...e){for(let t=0;t<arguments.length;t++){let n=e[t];if(n==null?void 0:n.isNode)return n}}resolve(...e){for(let t=0;t<arguments.length;t++){let n=e[t];if(n!==void 0){if(n.isNode)return n;if(n.isTexture)switch(n.mapping){case js:case Ws:return new xc(n);case Js:case Ho:return new vc(new kn(n));default:return new kn(n)}else{if(n.isVector2)return new In(n);if(n.isVector3)return new Un(n);if(n.isVector4)return new yc(n)}}}}format(e,t,n){switch(this.colorToVector(n+" <- "+t)){case"f <- v2":return e+".x";case"f <- v3":return e+".x";case"f <- v4":return e+".x";case"f <- i":case"f <- b":return"float( "+e+" )";case"v2 <- f":return"vec2( "+e+" )";case"v2 <- v3":return e+".xy";case"v2 <- v4":return e+".xy";case"v2 <- i":case"v2 <- b":return"vec2( float( "+e+" ) )";case"v3 <- f":return"vec3( "+e+" )";case"v3 <- v2":return"vec3( "+e+", 0.0 )";case"v3 <- v4":return e+".xyz";case"v3 <- i":case"v3 <- b":return"vec2( float( "+e+" ) )";case"v4 <- f":return"vec4( "+e+" )";case"v4 <- v2":return"vec4( "+e+", 0.0, 1.0 )";case"v4 <- v3":return"vec4( "+e+", 1.0 )";case"v4 <- i":case"v4 <- b":return"vec4( float( "+e+" ) )";case"i <- f":case"i <- b":return"int( "+e+" )";case"i <- v2":return"int( "+e+".x )";case"i <- v3":return"int( "+e+".x )";case"i <- v4":return"int( "+e+".x )";case"b <- f":return"( "+e+" != 0.0 )";case"b <- v2":return"( "+e+" != vec2( 0.0 ) )";case"b <- v3":return"( "+e+" != vec3( 0.0 ) )";case"b <- v4":return"( "+e+" != vec4( 0.0 ) )";case"b <- i":return"( "+e+" != 0 )"}return e}getTypeByFormat(e){return TL[e]||e}getFormatByType(e){return EL[e]||e}getUUID(e,t){return t=t!==void 0?t:!0,t&&this.cache&&(e=this.cache+"-"+e),e}getElementByIndex(e){return bx[e]}getIndexByElement(e){return bx.indexOf(e)}isShader(e){return this.shader===e}setShader(e){return this.shader=e,this}mergeDefines(e){for(let t in e)this.defines[t]=e[t];return this.defines}mergeUniform(e){for(let t in e)this.uniforms[t]=e[t];return this.uniforms}getTextureEncodingFromMap(e){let t;return e?e.isTexture&&(t=e.encoding):t=ln,t===ln&&this.context.gamma&&(t=Qs),t}};var Qa=class extends ze{constructor(e=new ze){super("v4");this.nodeType="Raw";this.value=e}generate(e){let t=this.value.analyzeAndFlow(e,this.type),n=t.code+`
|
||
|
|
`;return e.isShader("vertex")?n+="gl_Position = "+t.result+";":n+="gl_FragColor = "+t.result+";",n}copy(e){return super.copy(e),this.value.copy(e.value),this}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),t.value=this.value.toJSON(e).uuid),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.value&&(this.value=t.getNode(e.value)),this}};var Ni=class extends _t{constructor(e,t,n){super(n);this.isNodeMaterial=!0;this.type="NodeMaterial";this.wireframeLinecap="";this.wireframeLinejoin="";this.uniformsBackup={};this.userData={type:"",category:"",nodeType:""};this.fog=!0,this.vertex=e!=null?e:new Qa(new _n(_n.PROJECTION)),this.fragment=t!=null?t:new Qa(new ct(5855577)),this.updaters=[],this.isDetached=!0,this.dithering=!0,this.onBeforeCompile=this._onBeforeCompile}getDefines(){return this.defines}getUniforms(){return this.uniforms}getVertexShader(){return this.vertexShader}getFragmentShader(){return this.fragmentShader}_onBeforeCompile(e,t){this.build({renderer:t}),e.defines=this.defines,e.uniforms=this.uniforms,e.vertexShader=this.vertexShader,e.fragmentShader=this.fragmentShader,e.extensionDerivatives=this.extensions.derivatives===!0,e.extensionFragDepth=this.extensions.fragDepth===!0,e.extensionDrawBuffers=this.extensions.drawBuffers===!0,e.extensionShaderTextureLOD=this.extensions.shaderTextureLOD===!0}_getLayerStack(e){let t=new Kn(this);return e&&(async()=>{for(;e.image===void 0;)await new Promise(n=>requestAnimationFrame(n));t.addLayerAt(1,{type:lt.TEXTURE,texture:e}),this.dispose()})(),t}clampUniformsForPreview(e,t){let n=(i,s,o)=>Math.min(Math.max(i,s),o);if(this.userData.layers){for(let i of this.userData.layers.getLayers())if(i.type==lt.DISPLACE){this.uniformsBackup[`f${i.id}_intensity`]=i.uniforms[`f${i.id}_intensity`].value;let s=n(i.uniforms[`f${i.id}_intensity`].value,e,t);i.uniforms[`f${i.id}_intensity`].value=s}}}restoreClampedUniforms(){if(this.userData.layers)for(let e of this.userData.layers.getLayers())e.type==lt.DISPLACE&&(e.uniforms[`f${e.id}_intensity`].value=this.uniformsBackup[`f${e.id}_intensity`])}customProgramCacheKey(){return this.getHash()}updateFrame(e){for(let t=0;t<this.updaters.length;++t)e.updateNode(this.updaters[t])}build(e){var n;e=e!=null?e:{};let t=(n=e.builder)!=null?n:new Zp;return t.setMaterial(this,e.renderer),t.build(this.vertex,this.fragment),this.vertexShader=t.getCode("vertex"),this.fragmentShader=t.getCode("fragment"),this.defines=t.defines,this.uniforms=t.uniforms,this.extensions=t.extensions,this.updaters=t.updaters,this.fog=t.requires.fog,this.lights=t.requires.lights,this.transparent=t.requires.transparent||this.blending>Vs,this}getHash(){let e="{";return e+='"vertex":'+this.vertex.getHash()+",",e+='"fragment":'+this.fragment.getHash(),e+="}",e}copy(e){let t=this.uuid;for(let n in e)this[n]=e[n];return this.uuid=t,e.userData!==void 0&&(this.userData=JSON.parse(JSON.stringify(e.userData))),this}toJSON(e){let t=this.userData.layers;this.userData.layers=void 0;let n=super.toJSON(e);return n.type="ShaderMaterial",n.userData={type:this.userData.type,category:this.userData.category,nodeType:this.type,layers:t.toJSON(e)},n.vertex=this.vertex.toJSON(e).uuid,n.fragment=this.fragment.toJSON(e).uuid,delete n.vertexShader,delete n.fragmentShader,delete n.color,delete n.shininess,delete n.specular,delete n.roughness,delete n.metalness,delete n.uniforms,e&&!e.materials[this.uuid]&&(e.materials[this.uuid]=n),this.userData.layers=t,n}fromJSON(e,t){var n;this.defines=(n=e.defines)!=null?n:{},this.depthFunc=e.depthFunc,this.depthWrite=e.depthWrite,this.side=e.side!==void 0?e.side:Oi,this.transparent=e.transparent,this.wireframeLinecap=e.wireframeLinecap,this.wireframeLinejoin=e.wireframeLinejoin,this.flatShading=e.flatShading,this.wireframe=e.wireframe,this.userData.layers.fromJSON(e.userData.layers,t,this)}};Object.defineProperties(Ni.prototype,{properties:{get:function(){return this.fragment.properties}},needsUpdate:{set:function(r){r===!0&&this.version++,this.needsCompile=r},get:function(){return this.needsCompile}}});var bc=class extends ze{con
|
||
|
|
`));let i=["#include <beginnormal_vertex>",`
|
||
|
|
#if !defined( USE_LAYER_DISPLACE )
|
||
|
|
#include <defaultnormal_vertex>
|
||
|
|
#endif
|
||
|
|
|
||
|
|
vec3 displaced_position = position;
|
||
|
|
vec3 displaced_normal = normal;
|
||
|
|
|
||
|
|
#if defined( USE_LAYER_DISPLACE )
|
||
|
|
vec3 transformed;
|
||
|
|
vec3 transformedNormal;
|
||
|
|
#endif
|
||
|
|
`,"#ifndef FLAT_SHADED"," vNormal = normalize( transformedNormal );","#endif",`
|
||
|
|
#if !defined( USE_LAYER_DISPLACE )
|
||
|
|
#include <begin_vertex>
|
||
|
|
#endif /* !USE_LAYER_DISPLACE */
|
||
|
|
`];n&&i.push(n.code,n.result?"displaced_position = "+n.result+";":""),i.push("transformed = displaced_position;","transformedNormal = normalMatrix * displaced_normal;","#ifndef FLAT_SHADED"," vNormal = transformedNormal;","#endif"),i.push("#include <project_vertex>","#include <fog_vertex>","#include <clipping_planes_vertex>"," vViewPosition = - mvPosition.xyz;","#include <worldpos_vertex>"),t=i.join(`
|
||
|
|
`)}else{this.color===void 0&&(this.color=new ct(5855577)),this.color.analyze(e,{slot:"color"}),this.alpha&&this.alpha.analyze(e),this.afterColor&&this.afterColor.analyze(e,{slot:"afterColor"});let n=this.color.flow(e,"c",{slot:"color"}),i=this.alpha?this.alpha.flow(e,"f"):void 0,s=this.afterColor?this.afterColor.flow(e,"c",{slot:"afterColor"}):void 0;e.requires.transparent=i!==void 0,e.addParsCode(["#include <fog_pars_fragment>","#include <dithering_pars_fragment>","varying vec3 vViewPosition;","#ifndef FLAT_SHADED"," varying vec3 vNormal;","#endif"].join(`
|
||
|
|
`));let o=["#include <normal_fragment_begin>",n.code];i&&o.push(i.code,"#ifdef ALPHATEST"," if ( "+i.result+" <= ALPHATEST ) discard;","#endif"),s?o.push(s.code,`vec3 outgoingLight = ${n.result};`,`vec3 finalColor = spe_blend(outgoingLight, ${s.result}, 1.0, SPE_BLENDING_NORMAL);`):o.push(`vec3 finalColor = ${n.result};`),i?o.push(`gl_FragColor = vec4( finalColor, accumAlpha * ${i.result} );`):o.push("gl_FragColor = vec4("+n.result+", 1.0 );"),o.push("#include <fog_fragment>","#include <dithering_fragment>"),t=o.join(`
|
||
|
|
`)}return t}copy(e){return super.copy(e),e.color&&(this.color=e.color.clone()),e.position&&(this.position=e.position.clone()),e.alpha&&(this.alpha=e.alpha.clone()),e.afterColor&&(this.afterColor=e.afterColor.clone()),e.shadingAlpha&&(this.shadingAlpha=e.shadingAlpha.clone()),e.shadingBlend&&(this.shadingBlend=e.shadingBlend.clone()),this}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),this.color&&(t.color=this.color.toJSON(e).uuid),this.position&&(t.position=this.position.toJSON(e).uuid),this.alpha&&(t.alpha=this.alpha.toJSON(e).uuid),this.afterColor&&(t.afterColor=this.afterColor.toJSON(e).uuid),this.shadingAlpha&&(t.shadingAlpha=this.shadingAlpha.toJSON(e).uuid),this.shadingBlend&&(t.shadingBlend=this.shadingBlend.toJSON(e).uuid)),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.position&&(this.position=t.getNode(e.position)),e.color&&(this.color=t.getNode(e.color)),e.alpha&&(this.alpha=t.getNode(e.alpha)),e.afterColor&&(this.afterColor=t.getNode(e.afterColor)),e.shadingAlpha&&(this.shadingAlpha=t.getNode(e.shadingAlpha)),e.shadingBlend&&(this.shadingBlend=t.getNode(e.shadingBlend)),this}};var $p=class extends Ni{get color(){return this.fragment.color}set color(e){this.fragment.color=e}get afterColor(){return this.fragment.afterColor}set afterColor(e){this.fragment.afterColor=e}get alpha(){return this.fragment.alpha}set alpha(e){this.fragment.alpha=e}get shadingAlpha(){return this.fragment.shadingAlpha}set shadingAlpha(e){this.fragment.shadingAlpha=e}get shadingBlend(){return this.fragment.shadingBlend}set shadingBlend(e){this.fragment.shadingBlend=e}get position(){return this.fragment.position}set position(e){this.fragment.position=e}constructor(e=new bc,t){super(e,e,t);this.type="BasicNodeMaterial",this.fragment=e}};var oi=class extends $p{constructor(e,t,n){super(t,e);this.userData.type="BasicMaterial",this.userData.category="Basic",this.userData.layers=n!=null?n:this._getLayerStack(e==null?void 0:e.map)}get layersList(){return this.userData.layers}set layersList(e){this.userData.layers=e}equals(e){return this.userData.type===e.userData.type&&this.userData.layers.uuid==e.userData.layers.uuid}copy(e){if(e.userData.layers!==void 0&&e.userData.layers instanceof Kn){let t=e.userData.layers,n=e.fragment;super.copy(e);let i=n.clone();this.fragment=i,this.vertex=i;let s=t.clone(this);this.userData.layers=s}else super.copy(e);return this}static fromJSON(e,t,n){let i=n.getNode(t.vertex),s=new oi(void 0,i);return s.fromJSON(t,n),s}static fromMaterial(e){let t=new oi(e.map?{map:e.map}:{}),n=t.fragment;return n.color.value.copy(e.color),n.alpha.value=e.opacity,t}dispose(){super.dispose()}};var wc=class extends ze{constructor(){super("phong");this.nodeType="Phong";this.color=new ct(5855577),this.specular=new ct(1118481),this.shininess=new Te(30),this.shadingAlpha=new Te(1),this.shadingBlend=new it(0)}build(e){let t;if(e.define("PHONG"),e.requires.lights=!0,e.extensions.derivatives=!0,e.isShader("vertex")){let n=this.position?this.position.analyzeAndFlow(e,"v3",{cache:"position"}):void 0;e.mergeUniform(ki.merge([be.fog,be.lights])),e.addParsCode(["varying vec3 vViewPosition;","#ifndef FLAT_SHADED"," varying vec3 vNormal;","#endif","#include <fog_pars_vertex>","#include <shadowmap_pars_vertex>","#include <clipping_planes_pars_vertex>"].join(`
|
||
|
|
`));let i=["#include <beginnormal_vertex>",`
|
||
|
|
#ifndef USE_LAYER_DISPLACE
|
||
|
|
#include <defaultnormal_vertex>
|
||
|
|
#endif
|
||
|
|
|
||
|
|
vec3 displaced_position = position;
|
||
|
|
vec3 displaced_normal = normal;
|
||
|
|
|
||
|
|
#ifdef USE_LAYER_DISPLACE
|
||
|
|
vec3 transformed;
|
||
|
|
vec3 transformedNormal;
|
||
|
|
#endif
|
||
|
|
`,"#ifndef FLAT_SHADED"," vNormal = normalize( transformedNormal );","#endif",`
|
||
|
|
#ifndef USE_LAYER_DISPLACE
|
||
|
|
#include <begin_vertex>
|
||
|
|
#endif
|
||
|
|
`];n&&i.push(n.code,n.result?"displaced_position = "+n.result+";":""),i.push("transformed = displaced_position;","transformedNormal = normalMatrix * displaced_normal;","#ifndef FLAT_SHADED"," vNormal = transformedNormal;","#endif"),i.push(" #include <project_vertex>"," #include <clipping_planes_vertex>"," vViewPosition = - mvPosition.xyz;"," #include <worldpos_vertex>"," #include <shadowmap_vertex>"," #include <fog_vertex>"),t=i.join(`
|
||
|
|
`)}else{this.color===void 0&&(this.color=new ct(5855577)),this.color.analyze(e,{slot:"color"}),this.specular.analyze(e),this.shininess.analyze(e),this.shadingAlpha.analyze(e),this.shadingBlend.analyze(e),this.afterColor&&this.afterColor.analyze(e,{slot:"afterColor"}),this.alpha&&this.alpha.analyze(e);let n=this.color.flow(e,"c",{slot:"color"}),i=this.specular.flow(e,"c"),s=this.shininess.flow(e,"f"),o=this.shadingAlpha.flow(e,"f"),a=this.shadingBlend.flow(e,"i"),l=this.afterColor?this.afterColor.flow(e,"c",{slot:"afterColor"}):void 0,c=this.alpha?this.alpha.flow(e,"f"):void 0;e.requires.transparent=c!==void 0,e.addParsCode(["#include <fog_pars_fragment>","#include <bsdfs>","#include <lights_pars_begin>","#include <lights_phong_pars_fragment>","#include <shadowmap_pars_fragment>","#include <dithering_pars_fragment>"].join(`
|
||
|
|
`));let u=["#include <normal_fragment_begin>",`
|
||
|
|
// NOTE: gl_FrontFacing alternative using face normal estimation.
|
||
|
|
vec3 viewdx = dFdx(vViewPosition);
|
||
|
|
vec3 viewdy = dFdy(vViewPosition);
|
||
|
|
vec3 faceNormal = normalize(cross(viewdx,viewdy));
|
||
|
|
if (dot(normal, faceNormal) < 0.0) {
|
||
|
|
normal *= -1.0;
|
||
|
|
}
|
||
|
|
`," BlinnPhongMaterial material;"];u.push(n.code," vec3 diffuseColor = "+n.result+";"," ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );",i.code," vec3 specular = "+i.result+";",s.code," float shininess = max( 0.0001, "+s.result+" );"," float specularStrength = 1.0;"),c&&u.push(c.code,"#ifdef ALPHATEST","if ( "+c.result+" <= ALPHATEST ) discard;","#endif"),u.push("material.diffuseColor = diffuseColor;"),u.push("material.specularColor = specular;","material.specularShininess = shininess;","material.specularStrength = specularStrength;","#include <lights_fragment_begin>","#include <lights_fragment_end>"),u.push("vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular;"),u.push(`
|
||
|
|
if (outgoingLight != diffuseColor) {
|
||
|
|
float lightAccu = clamp( length( reflectedLight.directSpecular + reflectedLight.indirectSpecular ), 0.0, 1.0 );
|
||
|
|
accumAlpha += ( 1.0 - accumAlpha ) * ${o.result} * lightAccu;
|
||
|
|
outgoingLight = spe_blend( diffuseColor, outgoingLight, ${o.result}, ${a.result} );
|
||
|
|
}
|
||
|
|
`),l&&u.push(l.code,`outgoingLight = spe_blend(outgoingLight, ${l.result}, 1.0, SPE_BLENDING_NORMAL);`),c?u.push(`gl_FragColor = vec4( outgoingLight, accumAlpha * ${c.result} );`):u.push("gl_FragColor = vec4( outgoingLight, 1.0 );"),u.push("#include <encodings_fragment>","#include <fog_fragment>","#include <dithering_fragment>"),t=u.join(`
|
||
|
|
`)}return t}copy(e){return super.copy(e),e.color&&(this.color=e.color.clone()),this.specular=e.specular.clone(),this.shininess=e.shininess.clone(),e.position&&(this.position=e.position.clone()),e.afterColor&&(this.afterColor=e.afterColor.clone()),e.alpha&&(this.alpha=e.alpha.clone()),e.shadingAlpha&&(this.shadingAlpha=e.shadingAlpha.clone()),e.shadingBlend&&(this.shadingBlend=e.shadingBlend.clone()),this}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),this.position&&(t.position=this.position.toJSON(e).uuid),this.color&&(t.color=this.color.toJSON(e).uuid),t.specular=this.specular.toJSON(e).uuid,t.shininess=this.shininess.toJSON(e).uuid,t.shadingAlpha=this.shadingAlpha.toJSON(e).uuid,t.shadingBlend=this.shadingBlend.toJSON(e).uuid,this.afterColor&&(t.afterColor=this.afterColor.toJSON(e).uuid),this.alpha&&(t.alpha=this.alpha.toJSON(e).uuid)),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.position&&(this.position=t.getNode(e.position)),e.color&&(this.color=t.getNode(e.color)),e.specular&&(this.specular=t.getNode(e.specular)),e.shininess&&(this.shininess=t.getNode(e.shininess)),e.alpha&&(this.alpha=t.getNode(e.alpha)),e.shadingAlpha&&(this.shadingAlpha=t.getNode(e.shadingAlpha)),e.shadingBlend&&(this.shadingBlend=t.getNode(e.shadingBlend)),e.afterColor&&(this.afterColor=t.getNode(e.afterColor)),this}};var em=class extends Ni{get color(){return this.fragment.color}set color(e){this.fragment.color=e}get afterColor(){return this.fragment.afterColor}set afterColor(e){this.fragment.afterColor=e}get alpha(){return this.fragment.alpha}set alpha(e){this.fragment.alpha=e}get shadingAlpha(){return this.fragment.shadingAlpha}set shadingAlpha(e){this.fragment.shadingAlpha=e}get shadingBlend(){return this.fragment.shadingBlend}set shadingBlend(e){this.fragment.shadingBlend=e}get position(){return this.fragment.position}set position(e){this.fragment.position=e}get specular(){return this.fragment.specular}set specular(e){this.fragment.specular=e}get shininess(){return this.fragment.shininess}set shininess(e){this.fragment.shininess=e}constructor(e=new wc,t){super(e,e,t);this.type="PhongNodeMaterial",this.fragment=e}};var Ci=class extends em{constructor(e,t,n){super(t,e);this.userData.type="PhongMaterial",this.userData.category="Phong",this.userData.layers=n!=null?n:this._getLayerStack(e==null?void 0:e.map)}get layersList(){return this.userData.layers}set layersList(e){this.userData.layers=e}equals(e){return this.userData.type===e.userData.type&&this.userData.layers.uuid==e.userData.layers.uuid}copy(e){if(e.userData.layers!==void 0&&e.userData.layers instanceof Kn){let t=e.userData.layers,n=e.fragment;super.copy(e);let i=n.clone();this.fragment=i,this.vertex=i;let s=t.clone(this);this.userData.layers=s,i.shadingAlpha.value=n.shadingAlpha.value,i.shadingBlend.value=n.shadingBlend.value}else super.copy(e);return this}static fromJSON(e,t,n){let i=n.getNode(t.vertex),s=new Ci(void 0,i);return s.fromJSON(t,n),s}static fromMaterial(e){let t=new Ci(e.map?{map:e.map}:{}),n=t.fragment;return n.color.value.copy(e.color),n.alpha.value=e.opacity,t}dispose(){super.dispose()}};var Sc=class extends ze{constructor(){super("lambert");this.nodeType="Lambert";this.color=new ct(5855577),this.emissive=new ct(0),this.emissiveIntensity=new Te(1),this.shadingAlpha=new Te(1),this.shadingBlend=new it(0)}build(e){let t;if(e.define("LAMBERT"),e.requires.lights=!0,e.extensions.derivatives=!0,e.isShader("vertex")){let n=this.position?this.position.analyzeAndFlow(e,"v3",{cache:"position"}):void 0;e.mergeUniform(ki.merge([be.fog,be.lights])),e.addParsCode(["varying vec3 vViewPosition;","varying vec3 vLightFront;","varying vec3 vIndirectFront;","#ifndef DOUBLE_SIDED"," #define DOUBLE_SIDED","#endif","#ifndef FLAT_SHADED"," varying vec3 vNormal;","#endif","#ifdef DOUBLE_SIDED"," varying vec3 vLightBack;"," varying vec3 vIndirectBack;","#endif","#include <bsdfs>","#include <lights_pars_begin>","#include <color_pars_vertex>","#include <fog_pars_vertex>","#include <shadowmap_pars_vertex>","#include <clipping_planes_pars_vertex>"
|
||
|
|
`));let i=["#include <beginnormal_vertex>",`
|
||
|
|
#ifndef USE_LAYER_DISPLACE
|
||
|
|
#include <defaultnormal_vertex>
|
||
|
|
#endif
|
||
|
|
|
||
|
|
vec3 displaced_position = position;
|
||
|
|
vec3 displaced_normal = normal;
|
||
|
|
|
||
|
|
#ifdef USE_LAYER_DISPLACE
|
||
|
|
vec3 transformed;
|
||
|
|
vec3 transformedNormal;
|
||
|
|
#endif
|
||
|
|
`,"#ifndef FLAT_SHADED"," vNormal = normalize( transformedNormal );","#endif",`
|
||
|
|
#ifndef USE_LAYER_DISPLACE
|
||
|
|
#include <begin_vertex>
|
||
|
|
#endif
|
||
|
|
`];n&&i.push(n.code,n.result?"displaced_position = "+n.result+";":""),i.push("transformed = displaced_position;","transformedNormal = normalMatrix * displaced_normal;","#ifndef FLAT_SHADED"," vNormal = transformedNormal;","#endif"),i.push(" #include <project_vertex>"," #include <clipping_planes_vertex>"," vViewPosition = - mvPosition.xyz;"," #include <worldpos_vertex>",`
|
||
|
|
vec3 diffuse = vec3( 1.0 );
|
||
|
|
GeometricContext geometry;
|
||
|
|
geometry.position = mvPosition.xyz;
|
||
|
|
geometry.normal = normalize( transformedNormal );
|
||
|
|
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
|
||
|
|
GeometricContext backGeometry;
|
||
|
|
backGeometry.position = geometry.position;
|
||
|
|
backGeometry.normal = -geometry.normal;
|
||
|
|
backGeometry.viewDir = geometry.viewDir;
|
||
|
|
vLightFront = vec3( 0.0 );
|
||
|
|
vIndirectFront = vec3( 0.0 );
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
vLightBack = vec3( 0.0 );
|
||
|
|
vIndirectBack = vec3( 0.0 );
|
||
|
|
#endif
|
||
|
|
IncidentLight directLight;
|
||
|
|
float dotNL;
|
||
|
|
vec3 directLightColor_Diffuse;
|
||
|
|
#if NUM_POINT_LIGHTS > 0
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
|
||
|
|
getPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );
|
||
|
|
dotNL = dot( geometry.normal, directLight.direction );
|
||
|
|
directLightColor_Diffuse = PI * directLight.color;
|
||
|
|
vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#if NUM_SPOT_LIGHTS > 0
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
|
||
|
|
getSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );
|
||
|
|
dotNL = dot( geometry.normal, directLight.direction );
|
||
|
|
directLightColor_Diffuse = PI * directLight.color;
|
||
|
|
vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#if NUM_DIR_LIGHTS > 0
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
|
||
|
|
getDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );
|
||
|
|
dotNL = dot( geometry.normal, directLight.direction );
|
||
|
|
directLightColor_Diffuse = PI * directLight.color;
|
||
|
|
vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
#if NUM_HEMI_LIGHTS > 0
|
||
|
|
#pragma unroll_loop_start
|
||
|
|
for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
|
||
|
|
vIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );
|
||
|
|
#ifdef DOUBLE_SIDED
|
||
|
|
vIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
#pragma unroll_loop_end
|
||
|
|
#endif
|
||
|
|
`," #include <shadowmap_vertex>"," #include <fog_vertex>"),t=i.join(`
|
||
|
|
`)}else{this.color===void 0&&(this.color=new ct(5855577)),this.color.analyze(e,{slot:"color"}),this.shadingAlpha.analyze(e),this.shadingBlend.analyze(e),this.afterColor&&this.afterColor.analyze(e,{slot:"afterColor"}),this.alpha&&this.alpha.analyze(e);let n=this.color.flow(e,"c",{slot:"color"}),i=this.emissive.flow(e,"c",{slot:"emissive"}),s=this.emissiveIntensity.flow(e,"f",{slot:"emissive"}),o=this.shadingAlpha.flow(e,"f"),a=this.shadingBlend.flow(e,"i"),l=this.afterColor?this.afterColor.flow(e,"c",{slot:"afterColor"}):void 0,c=this.alpha?this.alpha.flow(e,"f"):void 0;e.requires.transparent=c!==void 0,e.addParsCode(["varying vec3 vViewPosition;","varying vec3 vLightFront;","varying vec3 vIndirectFront;","#ifndef DOUBLE_SIDED"," #define DOUBLE_SIDED","#endif","#ifndef FLAT_SHADED"," varying vec3 vNormal;","#endif","#ifdef DOUBLE_SIDED"," varying vec3 vLightBack;"," varying vec3 vIndirectBack;","#endif","#include <bsdfs>","#include <lights_pars_begin>","#include <fog_pars_fragment>","#include <shadowmap_pars_fragment>","#include <shadowmask_pars_fragment>","#include <clipping_planes_pars_fragment>","#include <dithering_pars_fragment>"].join(`
|
||
|
|
`));let u=["#include <normal_fragment_begin>",`
|
||
|
|
// NOTE: gl_FrontFacing alternative using face normal estimation.
|
||
|
|
vec3 viewdx = dFdx(vViewPosition);
|
||
|
|
vec3 viewdy = dFdy(vViewPosition);
|
||
|
|
vec3 faceNormal = normalize(cross(viewdx, viewdy));
|
||
|
|
bool isFrontFacing = (dot(normal, faceNormal) >= 0.0);
|
||
|
|
`,"#include <clipping_planes_fragment>"];u.push(n.code,"vec3 diffuseColor = "+n.result+";","ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );"),c&&u.push(c.code,"#ifdef ALPHATEST","if ( "+c.result+" <= ALPHATEST ) discard;","#endif"),u.push("#ifdef DOUBLE_SIDED"," reflectedLight.indirectDiffuse += (isFrontFacing) ? vIndirectFront : vIndirectBack;","#else"," reflectedLight.indirectDiffuse += vIndirectFront;","#endif","#include <lightmap_fragment>","reflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );","#ifdef DOUBLE_SIDED"," reflectedLight.directDiffuse = (isFrontFacing) ? vLightFront : vLightBack;","#else"," reflectedLight.directDiffuse = vLightFront;","#endif","reflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();"),i&&u.push(i.code,"reflectedLight.directDiffuse += "+i.result+" * "+s.result+";"),u.push("vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;"),u.push(`
|
||
|
|
if (outgoingLight != diffuseColor) {
|
||
|
|
float lightAccu = clamp( length( reflectedLight.directSpecular + reflectedLight.indirectSpecular ), 0.0, 1.0 );
|
||
|
|
accumAlpha += ( 1.0 - accumAlpha ) * ${o.result} * lightAccu;
|
||
|
|
outgoingLight = spe_blend( diffuseColor, outgoingLight, ${o.result}, ${a.result} );
|
||
|
|
}
|
||
|
|
`),l&&u.push(l.code,`outgoingLight = spe_blend(outgoingLight, ${l.result}, 1.0, SPE_BLENDING_NORMAL);`),c?u.push(`gl_FragColor = vec4( outgoingLight, accumAlpha * ${c.result} );`):u.push("gl_FragColor = vec4( outgoingLight, 1.0 );"),u.push("#include <encodings_fragment>","#include <fog_fragment>","#include <dithering_fragment>"),t=u.join(`
|
||
|
|
`)}return t}copy(e){return super.copy(e),this.emissiveIntensity=e.emissiveIntensity.clone(),e.color&&(this.color=e.color.clone()),e.position&&(this.position=e.position.clone()),e.afterColor&&(this.afterColor=e.afterColor.clone()),e.alpha&&(this.alpha=e.alpha.clone()),e.shadingAlpha&&(this.shadingAlpha=e.shadingAlpha.clone()),e.shadingBlend&&(this.shadingBlend=e.shadingBlend.clone()),e.emissive&&(this.emissive=e.emissive.clone()),this}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),this.position&&(t.position=this.position.toJSON(e).uuid),this.color&&(t.color=this.color.toJSON(e).uuid),t.emissiveIntensity=this.emissiveIntensity.toJSON(e).uuid,t.shadingAlpha=this.shadingAlpha.toJSON(e).uuid,t.shadingBlend=this.shadingBlend.toJSON(e).uuid,this.afterColor&&(t.afterColor=this.afterColor.toJSON(e).uuid),this.alpha&&(t.alpha=this.alpha.toJSON(e).uuid),this.emissive&&(t.emissive=this.emissive.toJSON(e).uuid)),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.position&&(this.position=t.getNode(e.position)),e.color&&(this.color=t.getNode(e.color)),e.shadingAlpha&&(this.shadingAlpha=t.getNode(e.shadingAlpha)),e.shadingBlend&&(this.shadingBlend=t.getNode(e.shadingBlend)),e.afterColor&&(this.afterColor=t.getNode(e.afterColor)),e.alpha&&(this.alpha=t.getNode(e.alpha)),e.emissiveIntensity&&(this.emissiveIntensity=t.getNode(e.emissiveIntensity)),this}};var tm=class extends Ni{get color(){return this.fragment.color}set color(e){this.fragment.color=e}get afterColor(){return this.fragment.afterColor}set afterColor(e){this.fragment.afterColor=e}get alpha(){return this.fragment.alpha}set alpha(e){this.fragment.alpha=e}get shadingAlpha(){return this.fragment.shadingAlpha}set shadingAlpha(e){this.fragment.shadingAlpha=e}get shadingBlend(){return this.fragment.shadingBlend}set shadingBlend(e){this.fragment.shadingBlend=e}get position(){return this.fragment.position}set position(e){this.fragment.position=e}get emissive(){return this.fragment.emissive}set emissive(e){this.fragment.emissive=e}get emissiveIntensity(){return this.fragment.emissiveIntensity}set emissiveIntensity(e){this.fragment.emissiveIntensity=e}constructor(e=new Sc,t){super(e,e,t);this.type="LambertNodeMaterial",this.fragment=e}};var Mc=class extends tm{constructor(e,t,n){super(t,e);this.userData.type="LambertMaterial",this.userData.category="Lambert",this.userData.layers=n!=null?n:this._getLayerStack(e==null?void 0:e.map)}get layersList(){return this.userData.layers}set layersList(e){this.userData.layers=e}equals(e){return this.userData.type===e.userData.type&&this.userData.layers.uuid==e.userData.layers.uuid}copy(e){if(e.userData.layers!==void 0&&e.userData.layers instanceof Kn){let t=e.userData.layers,n=e.fragment;super.copy(e);let i=n.clone();this.fragment=i,this.vertex=i;let s=t.clone(this);this.userData.layers=s,i.shadingAlpha.value=n.shadingAlpha.value,i.shadingBlend.value=n.shadingBlend.value}else super.copy(e);return this}static fromJSON(e,t,n){let i=n.getNode(t.vertex),s=new Mc(void 0,i);return s.fromJSON(t,n),s}dispose(){super.dispose()}};var Ac=class extends ze{constructor(){super("toon");this.nodeType="Toon";this.color=new ct(5855577),this.specular=new ct(1118481),this.shininess=new Te(30),this.shadingAlpha=new Te(1),this.shadingBlend=new it(0)}build(e){let t;if(e.define("TOON"),e.requires.lights=!0,e.extensions.derivatives=!0,e.isShader("vertex")){let n=this.position?this.position.analyzeAndFlow(e,"v3",{cache:"position"}):void 0;e.mergeUniform(ki.merge([be.fog,be.lights])),e.addParsCode(["varying vec3 vViewPosition;","#ifndef FLAT_SHADED"," varying vec3 vNormal;","#endif","#include <fog_pars_vertex>","#include <shadowmap_pars_vertex>","#include <clipping_planes_pars_vertex>"].join(`
|
||
|
|
`));let i=["#include <beginnormal_vertex>",`
|
||
|
|
#ifndef USE_LAYER_DISPLACE
|
||
|
|
#include <defaultnormal_vertex>
|
||
|
|
#endif
|
||
|
|
|
||
|
|
vec3 displaced_position = position;
|
||
|
|
vec3 displaced_normal = normal;
|
||
|
|
|
||
|
|
#ifdef USE_LAYER_DISPLACE
|
||
|
|
vec3 transformed;
|
||
|
|
vec3 transformedNormal;
|
||
|
|
#endif
|
||
|
|
`,"#ifndef FLAT_SHADED"," vNormal = normalize( transformedNormal );","#endif",`
|
||
|
|
#ifndef USE_LAYER_DISPLACE
|
||
|
|
#include <begin_vertex>
|
||
|
|
#endif
|
||
|
|
`];n&&i.push(n.code,n.result?"displaced_position = "+n.result+";":""),i.push("transformed = displaced_position;","transformedNormal = normalMatrix * displaced_normal;","#ifndef FLAT_SHADED"," vNormal = transformedNormal;","#endif"),i.push(" #include <project_vertex>"," #include <fog_vertex>"," #include <clipping_planes_vertex>"," vViewPosition = - mvPosition.xyz;"," #include <worldpos_vertex>"," #include <shadowmap_vertex>"," #include <fog_vertex>"),t=i.join(`
|
||
|
|
`)}else{this.color===void 0&&(this.color=new ct(5855577)),this.color.analyze(e,{slot:"color"}),this.specular.analyze(e),this.shininess.analyze(e),this.shadingAlpha.analyze(e),this.shadingBlend.analyze(e),this.afterColor&&this.afterColor.analyze(e,{slot:"afterColor"}),this.alpha&&this.alpha.analyze(e);let n=this.color.flow(e,"c",{slot:"color"}),i=this.specular.flow(e,"c"),s=this.shininess.flow(e,"f"),o=this.shadingAlpha.flow(e,"f"),a=this.shadingBlend.flow(e,"i"),l=this.afterColor?this.afterColor.flow(e,"c",{slot:"afterColor"}):void 0,c=this.alpha?this.alpha.flow(e,"f"):void 0;e.requires.transparent=c!==void 0,e.addParsCode(["#include <gradientmap_pars_fragment>","#include <fog_pars_fragment>","#include <bsdfs>","#include <lights_pars_begin>","#include <dithering_pars_fragment>",`
|
||
|
|
varying vec3 vViewPosition;
|
||
|
|
#ifndef FLAT_SHADED
|
||
|
|
varying vec3 vNormal;
|
||
|
|
#endif
|
||
|
|
struct ToonMaterial {
|
||
|
|
vec3 diffuseColor;
|
||
|
|
vec3 specularColor;
|
||
|
|
float specularShininess;
|
||
|
|
float specularStrength;
|
||
|
|
};
|
||
|
|
void RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
|
||
|
|
vec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;
|
||
|
|
#ifndef PHYSICALLY_CORRECT_LIGHTS
|
||
|
|
irradiance *= PI;
|
||
|
|
#endif
|
||
|
|
reflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );
|
||
|
|
reflectedLight.directSpecular += irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess ) * material.specularStrength;
|
||
|
|
}
|
||
|
|
void RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
|
||
|
|
reflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );
|
||
|
|
}
|
||
|
|
#define RE_Direct RE_Direct_Toon
|
||
|
|
#define RE_IndirectDiffuse RE_IndirectDiffuse_Toon
|
||
|
|
#define Material_LightProbeLOD( material ) (0)
|
||
|
|
`,"#include <shadowmap_pars_fragment>","#include <bumpmap_pars_fragment>","#include <normalmap_pars_fragment>"].join(`
|
||
|
|
`));let u=["#include <normal_fragment_begin>",`
|
||
|
|
// NOTE: gl_FrontFacing alternative using face normal estimation.
|
||
|
|
vec3 viewdx = dFdx(vViewPosition);
|
||
|
|
vec3 viewdy = dFdy(vViewPosition);
|
||
|
|
vec3 faceNormal = normalize(cross(viewdx,viewdy));
|
||
|
|
if (dot(normal, faceNormal) < 0.0) {
|
||
|
|
normal *= -1.0;
|
||
|
|
}
|
||
|
|
`," ToonMaterial material;"];u.push(n.code," vec3 diffuseColor = "+n.result+";"," ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );",i.code," vec3 specular = "+i.result+";",s.code," float shininess = max( 0.0001, "+s.result+" );"," float specularStrength = 1.0;"),c&&u.push(c.code,"#ifdef ALPHATEST","if ( "+c.result+" <= ALPHATEST ) discard;","#endif"),u.push("material.diffuseColor = diffuseColor;"),u.push("material.specularColor = specular;","material.specularShininess = shininess;","material.specularStrength = specularStrength;","#include <lights_fragment_begin>","#include <lights_fragment_end>"),u.push("vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular;"),u.push(`
|
||
|
|
if (outgoingLight != diffuseColor) {
|
||
|
|
float lightAccu = clamp( length( reflectedLight.directSpecular + reflectedLight.indirectSpecular ), 0.0, 1.0 );
|
||
|
|
accumAlpha += ( 1.0 - accumAlpha ) * ${o.result} * lightAccu;
|
||
|
|
outgoingLight = spe_blend( diffuseColor, outgoingLight, ${o.result}, ${a.result} );
|
||
|
|
}
|
||
|
|
`),l&&u.push(l.code,`outgoingLight = spe_blend(outgoingLight, ${l.result}, 1.0, SPE_BLENDING_NORMAL);`),c?u.push(`gl_FragColor = vec4( outgoingLight, accumAlpha * ${c.result} );`):u.push("gl_FragColor = vec4( outgoingLight, 1.0 );"),u.push("#include <encodings_fragment>","#include <fog_fragment>","#include <dithering_fragment>"),t=u.join(`
|
||
|
|
`)}return t}copy(e){return super.copy(e),e.color&&(this.color=e.color.clone()),this.specular=e.specular.clone(),this.shininess=e.shininess.clone(),e.position&&(this.position=e.position.clone()),e.afterColor&&(this.afterColor=e.afterColor.clone()),e.alpha&&(this.alpha=e.alpha.clone()),e.shadingAlpha&&(this.shadingAlpha=e.shadingAlpha.clone()),e.shadingBlend&&(this.shadingBlend=e.shadingBlend.clone()),this}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),this.position&&(t.position=this.position.toJSON(e).uuid),this.color&&(t.color=this.color.toJSON(e).uuid),t.specular=this.specular.toJSON(e).uuid,t.shininess=this.shininess.toJSON(e).uuid,this.alpha&&(t.alpha=this.alpha.toJSON(e).uuid),this.shadingAlpha&&(t.shadingAlpha=this.shadingAlpha.toJSON(e).uuid),this.shadingBlend&&(t.shadingBlend=this.shadingBlend.toJSON(e).uuid),this.afterColor&&(t.afterColor=this.afterColor.toJSON(e).uuid)),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.position&&(this.position=t.getNode(e.position)),e.color&&(this.color=t.getNode(e.color)),e.specular&&(this.specular=t.getNode(e.specular)),e.shininess&&(this.shininess=t.getNode(e.shininess)),e.alpha&&(this.alpha=t.getNode(e.alpha)),e.shadingAlpha&&(this.shadingAlpha=t.getNode(e.shadingAlpha)),e.shadingBlend&&(this.shadingBlend=t.getNode(e.shadingBlend)),e.afterColor&&(this.afterColor=t.getNode(e.afterColor)),this}};var nm=class extends Ni{get color(){return this.fragment.color}set color(e){this.fragment.color=e}get afterColor(){return this.fragment.afterColor}set afterColor(e){this.fragment.afterColor=e}get alpha(){return this.fragment.alpha}set alpha(e){this.fragment.alpha=e}get shadingAlpha(){return this.fragment.shadingAlpha}set shadingAlpha(e){this.fragment.shadingAlpha=e}get shadingBlend(){return this.fragment.shadingBlend}set shadingBlend(e){this.fragment.shadingBlend=e}get position(){return this.fragment.position}set position(e){this.fragment.position=e}get specular(){return this.fragment.specular}set specular(e){this.fragment.specular=e}get shininess(){return this.fragment.shininess}set shininess(e){this.fragment.shininess=e}constructor(e=new Ac,t){super(e,e,t);this.type="ToonNodeMaterial",this.fragment=e}};var _c=class extends nm{constructor(e,t,n){super(t,e);this.userData.type="ToonMaterial",this.userData.category="Toon",this.userData.layers=n!=null?n:this._getLayerStack(e==null?void 0:e.map)}get layersList(){return this.userData.layers}set layersList(e){this.userData.layers=e}equals(e){return this.userData.type===e.userData.type&&this.userData.layers.uuid==e.userData.layers.uuid}copy(e){if(e.userData.layers!==void 0&&e.userData.layers instanceof Kn){let t=e.userData.layers,n=e.fragment;super.copy(e);let i=n.clone();this.fragment=i,this.vertex=i;let s=t.clone(this);this.userData.layers=s,i.shadingAlpha.value=n.shadingAlpha.value,i.shadingBlend.value=n.shadingBlend.value}else super.copy(e);return this}static fromJSON(e,t,n){let i=n.getNode(t.vertex),s=new _c(void 0,i);return s.fromJSON(t,n),s}dispose(){super.dispose()}};var Tc=class extends ze{constructor(){super("standard");this.nodeType="Standard";this.color=new ct(5855577),this.roughness=new Te(.3),this.metalness=new Te(0),this.reflectivity=new Te(.5),this.shadingAlpha=new Te(1),this.shadingBlend=new it(0)}build(e){let t;if(e.define("STANDARD"),e.requires.lights=!0,e.extensions.derivatives=!0,e.extensions.shaderTextureLOD=!0,e.isShader("vertex")){let n=this.position?this.position.analyzeAndFlow(e,"v3",{cache:"position"}):void 0;e.mergeUniform(ki.merge([be.fog,be.lights])),be.LTC_1&&(e.uniforms.ltc_1={value:void 0},e.uniforms.ltc_2={value:void 0}),e.addParsCode(["varying vec3 vViewPosition;","#ifndef FLAT_SHADED"," varying vec3 vNormal;","#endif","#include <fog_pars_vertex>","#include <shadowmap_pars_vertex>","#include <clipping_planes_pars_vertex>"].join(`
|
||
|
|
`));let i=["#include <beginnormal_vertex>",`
|
||
|
|
#if !defined( USE_LAYER_DISPLACE )
|
||
|
|
#include <defaultnormal_vertex>
|
||
|
|
#endif
|
||
|
|
|
||
|
|
vec3 displaced_position = position;
|
||
|
|
vec3 displaced_normal = normal;
|
||
|
|
|
||
|
|
#if defined( USE_LAYER_DISPLACE )
|
||
|
|
vec3 transformed;
|
||
|
|
vec3 transformedNormal;
|
||
|
|
#endif
|
||
|
|
`,"#ifndef FLAT_SHADED"," vNormal = normalize( transformedNormal );","#endif",`
|
||
|
|
#if !defined( USE_LAYER_DISPLACE )
|
||
|
|
#include <begin_vertex>
|
||
|
|
#endif /* !USE_LAYER_DISPLACE */
|
||
|
|
`];n&&i.push(n.code,n.result?"displaced_position = "+n.result+";":""),i.push("transformed = displaced_position;","transformedNormal = normalMatrix * displaced_normal;","#ifndef FLAT_SHADED"," vNormal = transformedNormal;","#endif"),i.push("#include <project_vertex>","#include <fog_vertex>","#include <clipping_planes_vertex>"," vViewPosition = - mvPosition.xyz;","#include <worldpos_vertex>","#include <shadowmap_vertex>"),t=i.join(`
|
||
|
|
`)}else{let n={gamma:!0};this.color===void 0&&(this.color=new ct(5855577)),this.color.analyze(e,{slot:"color",context:n}),this.roughness.analyze(e),this.metalness.analyze(e),this.shadingAlpha.analyze(e),this.shadingBlend.analyze(e),this.afterColor&&this.afterColor.analyze(e,{slot:"afterColor"}),this.alpha&&this.alpha.analyze(e),this.reflectivity&&this.reflectivity.analyze(e);let i=this.color.flow(e,"c",{slot:"color",context:n}),s=this.roughness.flow(e,"f"),o=this.metalness.flow(e,"f"),a=this.shadingAlpha.flow(e,"f"),l=this.shadingBlend.flow(e,"i"),c=this.afterColor?this.afterColor.flow(e,"c",{slot:"afterColor"}):void 0,u=this.alpha?this.alpha.flow(e,"f"):void 0,h=this.reflectivity?this.reflectivity.flow(e,"f"):void 0;e.requires.transparent=u!==void 0,e.addParsCode(["varying vec3 vViewPosition;","#ifndef FLAT_SHADED"," varying vec3 vNormal;","#endif","#include <dithering_pars_fragment>","#include <fog_pars_fragment>","#include <bsdfs>","#include <lights_pars_begin>","#include <lights_physical_pars_fragment>","#include <shadowmap_pars_fragment>"].join(`
|
||
|
|
`));let d=["#include <clipping_planes_fragment>"," #include <normal_fragment_begin>",`
|
||
|
|
// NOTE: gl_FrontFacing alternative using face normal estimation.
|
||
|
|
vec3 viewdx = dFdx(vViewPosition);
|
||
|
|
vec3 viewdy = dFdy(vViewPosition);
|
||
|
|
vec3 faceNormal = normalize(cross(viewdx,viewdy));
|
||
|
|
if (dot(normal, faceNormal) < 0.0) {
|
||
|
|
normal *= -1.0;
|
||
|
|
}
|
||
|
|
`," PhysicalMaterial material;"," material.diffuseColor = vec3( 1.0 );"];d.push(i.code," vec3 diffuseColor = "+i.result+";"," ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );",s.code," float roughnessFactor = "+s.result+";",o.code," float metalnessFactor = "+o.result+";"),u&&d.push(u.code,"#ifdef ALPHATEST"," if ( "+u.result+" <= ALPHATEST ) discard;","#endif"),d.push("vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );","float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );"),d.push("material.diffuseColor = diffuseColor * ( 1.0 - metalnessFactor );","material.specularRoughness = max( roughnessFactor, 0.0525 );","material.specularRoughness += geometryRoughness;","material.specularRoughness = min( material.specularRoughness, 1.0 );","material.specularRoughness = clamp( roughnessFactor, 0.04, 1.0 );"),h?d.push(h.code,"material.specularColor = mix( vec3( MAXIMUM_SPECULAR_COEFFICIENT * pow2( "+h.result+" ) ), diffuseColor, metalnessFactor );"):d.push("material.specularColor = mix( vec3( DEFAULT_SPECULAR_COEFFICIENT ), diffuseColor, metalnessFactor );"),d.push("#include <lights_fragment_begin>"),d.push("#include <lights_fragment_end>"),d.push("vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular;"),d.push(`
|
||
|
|
if (outgoingLight != diffuseColor) {
|
||
|
|
float lightAccu = clamp( length( reflectedLight.directSpecular + reflectedLight.indirectSpecular ), 0.0, 1.0 );
|
||
|
|
accumAlpha += ( 1.0 - accumAlpha ) * ${a.result} * lightAccu;
|
||
|
|
outgoingLight = spe_blend( diffuseColor, outgoingLight, ${a.result}, ${l.result} );
|
||
|
|
}
|
||
|
|
`),c&&d.push(c.code,`outgoingLight = spe_blend(outgoingLight, ${c.result}, 1.0, SPE_BLENDING_NORMAL);`),u?d.push(`gl_FragColor = vec4( outgoingLight, accumAlpha * ${u.result} );`):d.push("gl_FragColor = vec4( outgoingLight, 1.0 );"),d.push("#include <encodings_fragment>","#include <fog_fragment>","#include <dithering_fragment>"),t=d.join(`
|
||
|
|
`)}return t}copy(e){return super.copy(e),e.color&&(this.color=e.color.clone()),this.roughness=e.roughness.clone(),this.metalness=e.metalness.clone(),e.position&&(this.position=e.position.clone()),e.afterColor&&(this.afterColor=e.afterColor.clone()),e.alpha&&(this.alpha=e.alpha.clone()),e.reflectivity&&(this.reflectivity=e.reflectivity.clone()),e.shadingAlpha&&(this.shadingAlpha=e.shadingAlpha.clone()),e.shadingBlend&&(this.shadingBlend=e.shadingBlend.clone()),this}toJSON(e){let t=this.getJSONNode(e);return t||(t=this.createJSONNode(e),this.position&&(t.position=this.position.toJSON(e).uuid),this.color&&(t.color=this.color.toJSON(e).uuid),t.roughness=this.roughness.toJSON(e).uuid,t.metalness=this.metalness.toJSON(e).uuid,this.alpha&&(t.alpha=this.alpha.toJSON(e).uuid),this.reflectivity&&(t.reflectivity=this.reflectivity.toJSON(e).uuid),this.shadingAlpha&&(t.shadingAlpha=this.shadingAlpha.toJSON(e).uuid),this.shadingBlend&&(t.shadingBlend=this.shadingBlend.toJSON(e).uuid),this.afterColor&&(t.afterColor=this.afterColor.toJSON(e).uuid)),t.nodeType=this.nodeType,t}fromJSON(e,t){return super.fromJSON(e,t),e.position&&(this.position=t.getNode(e.position)),e.color&&(this.color=t.getNode(e.color)),e.roughness&&(this.roughness=t.getNode(e.roughness)),e.metalness&&(this.metalness=t.getNode(e.metalness)),e.alpha&&(this.alpha=t.getNode(e.alpha)),e.reflectivity&&(this.reflectivity=t.getNode(e.reflectivity)),e.shadingAlpha&&(this.shadingAlpha=t.getNode(e.shadingAlpha)),e.shadingBlend&&(this.shadingBlend=t.getNode(e.shadingBlend)),e.afterColor&&(this.afterColor=t.getNode(e.afterColor)),this}};var im=class extends Ni{get color(){return this.fragment.color}set color(e){this.fragment.color=e}get afterColor(){return this.fragment.afterColor}set afterColor(e){this.fragment.afterColor=e}get alpha(){return this.fragment.alpha}set alpha(e){this.fragment.alpha=e}get shadingAlpha(){return this.fragment.shadingAlpha}set shadingAlpha(e){this.fragment.shadingAlpha=e}get shadingBlend(){return this.fragment.shadingBlend}set shadingBlend(e){this.fragment.shadingBlend=e}get position(){return this.fragment.position}set position(e){this.fragment.position=e}get roughness(){return this.fragment.roughness}set roughness(e){this.fragment.roughness=e}get metalness(){return this.fragment.metalness}set metalness(e){this.fragment.metalness=e}get reflectivity(){return this.fragment.reflectivity}set reflectivity(e){this.fragment.reflectivity=e}constructor(e=new Tc,t){super(e,e,t);this.type="StandardNodeMaterial",this.fragment=e}};var Ec=class extends im{constructor(e,t,n){super(t,e);this.userData.type="PhysicalMaterial",this.userData.category="Physical",this.userData.layers=n!=null?n:this._getLayerStack(e==null?void 0:e.map)}get layersList(){return this.userData.layers}set layersList(e){this.userData.layers=e}equals(e){return this.userData.type===e.userData.type&&this.userData.layers.uuid==e.userData.layers.uuid}copy(e){if(e.userData.layers!==void 0&&e.userData.layers instanceof Kn){let t=e.userData.layers,n=e.fragment;super.copy(e);let i=n.clone();this.fragment=i,this.vertex=i;let s=t.clone(this);this.userData.layers=s,i.shadingAlpha.value=n.shadingAlpha.value,i.shadingBlend.value=n.shadingBlend.value}else super.copy(e);return this}static fromJSON(e,t,n){let i=n.getNode(t.vertex),s=new Ec(void 0,i);return s.fromJSON(t,n),s}dispose(){super.dispose()}};var wx={BasicMaterial:oi,PhongMaterial:Ci,LambertMaterial:Mc,ToonMaterial:_c,PhysicalMaterial:Ec};var Sx=class{static create(r){return this.build(this.normalizeInputs(r))}static normalizeInputs(r,e){var o,a,l,c,u;let t=Object.assign({},(o=e==null?void 0:e.parameters)!=null?o:{width:100,radialSegments:64,heightSegments:1,openEnded:!1,thetaStart:0,thetaLength:360,cornerRadius:0,cornerSegments:8,hollow:0},r.parameters),n=t.width/2,i=(a=t.radiusTop)!=null?a:n,s=(l=t.radiusBottom)!=null?l:n;return i===s?(i=n,s=n):i>s?(i=n,s=s*n/i):(i=i*n/s,s=n),{parameters:Object.assign(t,{width:Math.abs(t.width),height:Math.abs((c=t.height)!=null?c:t.width),depth:Math.abs((u=t.depth)!=null?u:t.width),radiusTop:i,radiusBottom:s})}}static b
|
||
|
|
`),n=["#ifdef USE_GLOSSINESSMAP"," uniform sampler2D glossinessMap;","#endif"].join(`
|
||
|
|
`),i=["vec3 specularFactor = specular;","#ifdef USE_SPECULARMAP"," vec4 texelSpecular = texture2D( specularMap, vUv );"," texelSpecular = sRGBToLinear( texelSpecular );"," // reads channel RGB, compatible with a glTF Specular-Glossiness (RGBA) texture"," specularFactor *= texelSpecular.rgb;","#endif"].join(`
|
||
|
|
`),s=["float glossinessFactor = glossiness;","#ifdef USE_GLOSSINESSMAP"," vec4 texelGlossiness = texture2D( glossinessMap, vUv );"," // reads channel A, compatible with a glTF Specular-Glossiness (RGBA) texture"," glossinessFactor *= texelGlossiness.a;","#endif"].join(`
|
||
|
|
`),o=["PhysicalMaterial material;","material.diffuseColor = diffuseColor.rgb * ( 1. - max( specularFactor.r, max( specularFactor.g, specularFactor.b ) ) );","vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );","float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );","material.specularRoughness = max( 1.0 - glossinessFactor, 0.0525 ); // 0.0525 corresponds to the base mip of a 256 cubemap.","material.specularRoughness += geometryRoughness;","material.specularRoughness = min( material.specularRoughness, 1.0 );","material.specularColor = specularFactor;"].join(`
|
||
|
|
`),a={specular:{value:new fe().setHex(16777215)},glossiness:{value:1},specularMap:{value:null},glossinessMap:{value:null}};this._extraUniforms=a,this.onBeforeCompile=function(l){for(let c in a)l.uniforms[c]=a[c];l.fragmentShader=l.fragmentShader.replace("uniform float roughness;","uniform vec3 specular;").replace("uniform float metalness;","uniform float glossiness;").replace("#include <roughnessmap_pars_fragment>",t).replace("#include <metalnessmap_pars_fragment>",n).replace("#include <roughnessmap_fragment>",i).replace("#include <metalnessmap_fragment>",s).replace("#include <lights_physical_fragment>",o)},Object.defineProperties(this,{specular:{get:function(){return a.specular.value},set:function(l){a.specular.value=l}},specularMap:{get:function(){return a.specularMap.value},set:function(l){a.specularMap.value=l,l?this.defines.USE_SPECULARMAP="":delete this.defines.USE_SPECULARMAP}},glossiness:{get:function(){return a.glossiness.value},set:function(l){a.glossiness.value=l}},glossinessMap:{get:function(){return a.glossinessMap.value},set:function(l){a.glossinessMap.value=l,l?(this.defines.USE_GLOSSINESSMAP="",this.defines.USE_UV=""):(delete this.defines.USE_GLOSSINESSMAP,delete this.defines.USE_UV)}}}),delete this.metalness,delete this.roughness,delete this.metalnessMap,delete this.roughnessMap,this.setValues(e)}copy(e){return super.copy(e),this.specularMap=e.specularMap,this.specular.copy(e.specular),this.glossinessMap=e.glossinessMap,this.glossiness=e.glossiness,delete this.metalness,delete this.roughness,delete this.metalnessMap,delete this.roughnessMap,this}},JS=class{constructor(){this.name=dt.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS,this.specularGlossinessParams=["color","map","lightMap","lightMapIntensity","aoMap","aoMapIntensity","emissive","emissiveIntensity","emissiveMap","bumpMap","bumpScale","normalMap","normalMapType","displacementMap","displacementScale","displacementBias","specularMap","specular","glossinessMap","glossiness","alphaMap","envMap","envMapIntensity","refractionRatio"]}getMaterialType(){return zd}extendParams(e,t,n){let i=t.extensions[this.name];e.color=new fe(1,1,1),e.opacity=1;let s=[];if(Array.isArray(i.diffuseFactor)){let o=i.diffuseFactor;e.color.fromArray(o),e.opacity=o[3]}if(i.diffuseTexture!==void 0&&s.push(n.assignTexture(e,"map",i.diffuseTexture)),e.emissive=new fe(0,0,0),e.glossiness=i.glossinessFactor!==void 0?i.glossinessFactor:1,e.specular=new fe(1,1,1),Array.isArray(i.specularFactor)&&e.specular.fromArray(i.specularFactor),i.specularGlossinessTexture!==void 0){let o=i.specularGlossinessTexture;s.push(n.assignTexture(e,"glossinessMap",o)),s.push(n.assignTexture(e,"specularMap",o))}return Promise.all(s)}createMaterial(e){let t=new zd(e);return t.fog=!0,t.color=e.color,t.map=e.map===void 0?null:e.map,t.lightMap=null,t.lightMapIntensity=1,t.aoMap=e.aoMap===void 0?null:e.aoMap,t.aoMapIntensity=1,t.emissive=e.emissive,t.emissiveIntensity=1,t.emissiveMap=e.emissiveMap===void 0?null:e.emissiveMap,t.bumpMap=e.bumpMap===void 0?null:e.bumpMap,t.bumpScale=1,t.normalMap=e.normalMap===void 0?null:e.normalMap,t.normalMapType=Qr,e.normalScale&&(t.normalScale=e.normalScale),t.displacementMap=null,t.displacementScale=1,t.displacementBias=0,t.specularMap=e.specularMap===void 0?null:e.specularMap,t.specular=e.specular,t.glossinessMap=e.glossinessMap===void 0?null:e.glossinessMap,t.glossiness=e.glossiness,t.alphaMap=null,t.envMap=e.envMap===void 0?null:e.envMap,t.envMapIntensity=1,t.refractionRatio=.98,t}},XS=class{constructor(){this.name=dt.KHR_MESH_QUANTIZATION}},Oo=class extends qi{constructor(e,t,n,i){super(e,t,n,i)}copySampleValue_(e){let t=this.resultBuffer,n=this.sampleValues,i=this.valueSize,s=e*i*3+i;for(let o=0;o!==i;o++)t[o]=n[s+o];return t}};Oo.prototype.beforeStart_=Oo.prototype.copySampleValue_;Oo.prototype.afterEnd_=Oo.prototype.copySampleValue_;Oo.prototype.interpolate_=function(r,e,t,n){let i=this.resultBuffer,s=this.sampleValues,o=this.valueSize,a=o*2,l=o*3,c=n-e,u=(t-e)/c,h=u*u,d=h*u,f=r*l,p=f-l,m=-2*d+3*h,v=d-h,g=1-m,y=v-h+u;for(let x=0;x!==o;x++){let b=s[p+x+o],w=s[p+x+a]*c,_=s[f+
|
||
|
|
uniform mediump sampler2D inputBuffer;
|
||
|
|
#else
|
||
|
|
uniform lowp sampler2D inputBuffer;
|
||
|
|
#endif
|
||
|
|
uniform lowp sampler2D cocBuffer;uniform vec2 texelSize;uniform float scale;
|
||
|
|
#if PASS == 1
|
||
|
|
uniform vec4 kernel64[32];
|
||
|
|
#else
|
||
|
|
uniform vec4 kernel16[8];
|
||
|
|
#endif
|
||
|
|
varying vec2 vUv;void main(){
|
||
|
|
#ifdef FOREGROUND
|
||
|
|
vec2 CoCNearFar=texture2D(cocBuffer,vUv).rg;float CoC=CoCNearFar.r*scale;
|
||
|
|
#else
|
||
|
|
float CoC=texture2D(cocBuffer,vUv).g*scale;
|
||
|
|
#endif
|
||
|
|
if(CoC==0.0){gl_FragColor=texture2D(inputBuffer,vUv);}else{
|
||
|
|
#ifdef FOREGROUND
|
||
|
|
vec2 step=texelSize*max(CoC,CoCNearFar.g*scale);
|
||
|
|
#else
|
||
|
|
vec2 step=texelSize*CoC;
|
||
|
|
#endif
|
||
|
|
#if PASS == 1
|
||
|
|
vec4 acc=vec4(0.0);for(int i=0;i<32;++i){vec4 kernel=kernel64[i];vec2 uv=step*kernel.xy+vUv;acc+=texture2D(inputBuffer,uv);uv=step*kernel.zw+vUv;acc+=texture2D(inputBuffer,uv);}gl_FragColor=acc/64.0;
|
||
|
|
#else
|
||
|
|
vec4 maxValue=texture2D(inputBuffer,vUv);for(int i=0;i<8;++i){vec4 kernel=kernel16[i];vec2 uv=step*kernel.xy+vUv;maxValue=max(texture2D(inputBuffer,uv),maxValue);uv=step*kernel.zw+vUv;maxValue=max(texture2D(inputBuffer,uv),maxValue);}gl_FragColor=maxValue;
|
||
|
|
#endif
|
||
|
|
}}`,Ud=class extends _t{constructor(r=!1,e=!1){super({type:"BokehMaterial",defines:{PASS:r?"2":"1"},uniforms:{kernel64:new Ae(null),kernel16:new Ae(null),inputBuffer:new Ae(null),cocBuffer:new Ae(null),texelSize:new Ae(new O),scale:new Ae(1)},fragmentShader:y3,vertexShader:iu,blending:It,depthWrite:!1,depthTest:!1});this.toneMapped=!1,e&&(this.defines.FOREGROUND="1"),this.generateKernel()}generateKernel(){let r=2.39996323,e=new Float32Array(128),t=new Float32Array(32),n=0,i=0;for(let a=0;a<80;++a){let l=a*r,c=Math.sqrt(a)/Math.sqrt(80),u=c*Math.cos(l),h=c*Math.sin(l);a%5==0?(t[i++]=u,t[i++]=h):(e[n++]=u,e[n++]=h)}let s=[],o=[];for(let a=0;a<128;)s.push(new Qe(e[a++],e[a++],e[a++],e[a++]));for(let a=0;a<32;)o.push(new Qe(t[a++],t[a++],t[a++],t[a++]));this.uniforms.kernel64.value=s,this.uniforms.kernel16.value=o}setTexelSize(r,e){this.uniforms.texelSize.value.set(r,e)}},v3=`#include <common>
|
||
|
|
#include <packing>
|
||
|
|
#ifdef GL_FRAGMENT_PRECISION_HIGH
|
||
|
|
uniform highp sampler2D depthBuffer;
|
||
|
|
#else
|
||
|
|
uniform mediump sampler2D depthBuffer;
|
||
|
|
#endif
|
||
|
|
uniform float focusDistance;uniform float focalLength;uniform float cameraNear;uniform float cameraFar;varying vec2 vUv;float readDepth(const in vec2 uv){
|
||
|
|
#if DEPTH_PACKING == 3201
|
||
|
|
return unpackRGBAToDepth(texture2D(depthBuffer,uv));
|
||
|
|
#else
|
||
|
|
return texture2D(depthBuffer,uv).r;
|
||
|
|
#endif
|
||
|
|
}void main(){float depth=readDepth(vUv);
|
||
|
|
#ifdef PERSPECTIVE_CAMERA
|
||
|
|
float viewZ=perspectiveDepthToViewZ(depth,cameraNear,cameraFar);float linearDepth=viewZToOrthographicDepth(viewZ,cameraNear,cameraFar);
|
||
|
|
#else
|
||
|
|
float linearDepth=depth;
|
||
|
|
#endif
|
||
|
|
float signedDistance=linearDepth-focusDistance;float magnitude=smoothstep(0.0,focalLength,abs(signedDistance));gl_FragColor.rg=vec2(step(signedDistance,0.0)*magnitude,step(0.0,signedDistance)*magnitude);}`,x3=class extends _t{constructor(r){super({type:"CircleOfConfusionMaterial",defines:{DEPTH_PACKING:"0"},uniforms:{depthBuffer:new Ae(null),focusDistance:new Ae(0),focalLength:new Ae(0),cameraNear:new Ae(.3),cameraFar:new Ae(1e3)},fragmentShader:v3,vertexShader:iu,blending:It,depthWrite:!1,depthTest:!1});this.toneMapped=!1,this.adoptCameraSettings(r)}get depthPacking(){return Number(this.defines.DEPTH_PACKING)}set depthPacking(r){this.defines.DEPTH_PACKING=r.toFixed(0),this.needsUpdate=!0}adoptCameraSettings(r=null){r!==null&&(this.uniforms.cameraNear.value=r.near,this.uniforms.cameraFar.value=r.far,r instanceof Vt?this.defines.PERSPECTIVE_CAMERA="1":delete this.defines.PERSPECTIVE_CAMERA,this.needsUpdate=!0)}},b3=`varying vec2 vUv;varying vec2 vUv0;varying vec2 vUv1;
|
||
|
|
#if EDGE_DETECTION_MODE != 0
|
||
|
|
varying vec2 vUv2;varying vec2 vUv3;varying vec2 vUv4;varying vec2 vUv5;
|
||
|
|
#endif
|
||
|
|
#if EDGE_DETECTION_MODE == 1
|
||
|
|
#include <common>
|
||
|
|
#endif
|
||
|
|
#if EDGE_DETECTION_MODE == 0 || PREDICATION_MODE == 1
|
||
|
|
#ifdef GL_FRAGMENT_PRECISION_HIGH
|
||
|
|
uniform highp sampler2D depthBuffer;
|
||
|
|
#else
|
||
|
|
uniform mediump sampler2D depthBuffer;
|
||
|
|
#endif
|
||
|
|
float readDepth(const in vec2 uv){
|
||
|
|
#if DEPTH_PACKING == 3201
|
||
|
|
return unpackRGBAToDepth(texture2D(depthBuffer,uv));
|
||
|
|
#else
|
||
|
|
return texture2D(depthBuffer,uv).r;
|
||
|
|
#endif
|
||
|
|
}vec3 gatherNeighbors(){float p=readDepth(vUv);float pLeft=readDepth(vUv0);float pTop=readDepth(vUv1);return vec3(p,pLeft,pTop);}
|
||
|
|
#elif PREDICATION_MODE == 2
|
||
|
|
uniform sampler2D predicationBuffer;vec3 gatherNeighbors(){float p=texture2D(predicationBuffer,vUv).r;float pLeft=texture2D(predicationBuffer,vUv0).r;float pTop=texture2D(predicationBuffer,vUv1).r;return vec3(p,pLeft,pTop);}
|
||
|
|
#endif
|
||
|
|
#if PREDICATION_MODE != 0
|
||
|
|
vec2 calculatePredicatedThreshold(){vec3 neighbours=gatherNeighbors();vec2 delta=abs(neighbours.xx-neighbours.yz);vec2 edges=step(PREDICATION_THRESHOLD,delta);return PREDICATION_SCALE*EDGE_THRESHOLD*(1.0-PREDICATION_STRENGTH*edges);}
|
||
|
|
#endif
|
||
|
|
#if EDGE_DETECTION_MODE != 0
|
||
|
|
uniform sampler2D inputBuffer;
|
||
|
|
#endif
|
||
|
|
void main(){
|
||
|
|
#if EDGE_DETECTION_MODE == 0
|
||
|
|
const vec2 threshold=vec2(DEPTH_THRESHOLD);
|
||
|
|
#elif PREDICATION_MODE != 0
|
||
|
|
vec2 threshold=calculatePredicatedThreshold();
|
||
|
|
#else
|
||
|
|
const vec2 threshold=vec2(EDGE_THRESHOLD);
|
||
|
|
#endif
|
||
|
|
#if EDGE_DETECTION_MODE == 0
|
||
|
|
vec3 neighbors=gatherNeighbors();vec2 delta=abs(neighbors.xx-vec2(neighbors.y,neighbors.z));vec2 edges=step(threshold,delta);if(dot(edges,vec2(1.0))==0.0){discard;}gl_FragColor=vec4(edges,0.0,1.0);
|
||
|
|
#elif EDGE_DETECTION_MODE == 1
|
||
|
|
float l=linearToRelativeLuminance(texture2D(inputBuffer,vUv).rgb);float lLeft=linearToRelativeLuminance(texture2D(inputBuffer,vUv0).rgb);float lTop=linearToRelativeLuminance(texture2D(inputBuffer,vUv1).rgb);vec4 delta;delta.xy=abs(l-vec2(lLeft,lTop));vec2 edges=step(threshold,delta.xy);if(dot(edges,vec2(1.0))==0.0){discard;}float lRight=linearToRelativeLuminance(texture2D(inputBuffer,vUv2).rgb);float lBottom=linearToRelativeLuminance(texture2D(inputBuffer,vUv3).rgb);delta.zw=abs(l-vec2(lRight,lBottom));vec2 maxDelta=max(delta.xy,delta.zw);float lLeftLeft=linearToRelativeLuminance(texture2D(inputBuffer,vUv4).rgb);float lTopTop=linearToRelativeLuminance(texture2D(inputBuffer,vUv5).rgb);delta.zw=abs(vec2(lLeft,lTop)-vec2(lLeftLeft,lTopTop));maxDelta=max(maxDelta.xy,delta.zw);float finalDelta=max(maxDelta.x,maxDelta.y);edges.xy*=step(finalDelta,LOCAL_CONTRAST_ADAPTATION_FACTOR*delta.xy);gl_FragColor=vec4(edges,0.0,1.0);
|
||
|
|
#elif EDGE_DETECTION_MODE == 2
|
||
|
|
vec4 delta;vec3 c=texture2D(inputBuffer,vUv).rgb;vec3 cLeft=texture2D(inputBuffer,vUv0).rgb;vec3 t=abs(c-cLeft);delta.x=max(max(t.r,t.g),t.b);vec3 cTop=texture2D(inputBuffer,vUv1).rgb;t=abs(c-cTop);delta.y=max(max(t.r,t.g),t.b);vec2 edges=step(threshold,delta.xy);if(dot(edges,vec2(1.0))==0.0){discard;}vec3 cRight=texture2D(inputBuffer,vUv2).rgb;t=abs(c-cRight);delta.z=max(max(t.r,t.g),t.b);vec3 cBottom=texture2D(inputBuffer,vUv3).rgb;t=abs(c-cBottom);delta.w=max(max(t.r,t.g),t.b);vec2 maxDelta=max(delta.xy,delta.zw);vec3 cLeftLeft=texture2D(inputBuffer,vUv4).rgb;t=abs(c-cLeftLeft);delta.z=max(max(t.r,t.g),t.b);vec3 cTopTop=texture2D(inputBuffer,vUv5).rgb;t=abs(c-cTopTop);delta.w=max(max(t.r,t.g),t.b);maxDelta=max(maxDelta.xy,delta.zw);float finalDelta=max(maxDelta.x,maxDelta.y);edges*=step(finalDelta,LOCAL_CONTRAST_ADAPTATION_FACTOR*delta.xy);gl_FragColor=vec4(edges,0.0,1.0);
|
||
|
|
#endif
|
||
|
|
}`,w3=`uniform vec2 texelSize;varying vec2 vUv;varying vec2 vUv0;varying vec2 vUv1;
|
||
|
|
#if EDGE_DETECTION_MODE != 0
|
||
|
|
varying vec2 vUv2;varying vec2 vUv3;varying vec2 vUv4;varying vec2 vUv5;
|
||
|
|
#endif
|
||
|
|
void main(){vUv=position.xy*0.5+0.5;vUv0=vUv+texelSize*vec2(-1.0,0.0);vUv1=vUv+texelSize*vec2(0.0,-1.0);
|
||
|
|
#if EDGE_DETECTION_MODE != 0
|
||
|
|
vUv2=vUv+texelSize*vec2(1.0,0.0);vUv3=vUv+texelSize*vec2(0.0,1.0);vUv4=vUv+texelSize*vec2(-2.0,0.0);vUv5=vUv+texelSize*vec2(0.0,-2.0);
|
||
|
|
#endif
|
||
|
|
gl_Position=vec4(position.xy,1.0,1.0);}`;var S3=`#include <common>
|
||
|
|
#include <dithering_pars_fragment>
|
||
|
|
#ifdef FRAMEBUFFER_PRECISION_HIGH
|
||
|
|
uniform mediump sampler2D inputBuffer;
|
||
|
|
#else
|
||
|
|
uniform lowp sampler2D inputBuffer;
|
||
|
|
#endif
|
||
|
|
varying vec2 vUv0;varying vec2 vUv1;varying vec2 vUv2;varying vec2 vUv3;void main(){vec4 sum=texture2D(inputBuffer,vUv0);sum+=texture2D(inputBuffer,vUv1);sum+=texture2D(inputBuffer,vUv2);sum+=texture2D(inputBuffer,vUv3);gl_FragColor=sum*0.25;
|
||
|
|
#include <dithering_fragment>
|
||
|
|
}`,M3="uniform vec2 texelSize;uniform vec2 halfTexelSize;uniform float kernel;uniform float scale;varying vec2 vUv0;varying vec2 vUv1;varying vec2 vUv2;varying vec2 vUv3;void main(){vec2 uv=position.xy*0.5+0.5;vec2 dUv=(texelSize*vec2(kernel)+halfTexelSize)*scale;vUv0=vec2(uv.x-dUv.x,uv.y+dUv.y);vUv1=vec2(uv.x+dUv.x,uv.y+dUv.y);vUv2=vec2(uv.x+dUv.x,uv.y-dUv.y);vUv3=vec2(uv.x-dUv.x,uv.y-dUv.y);gl_Position=vec4(position.xy,1.0,1.0);}",rM=class extends _t{constructor(r=new O){super({type:"ConvolutionMaterial",uniforms:{inputBuffer:new Ae(null),texelSize:new Ae(new O),halfTexelSize:new Ae(new O),kernel:new Ae(0),scale:new Ae(1)},fragmentShader:S3,vertexShader:M3,blending:It,depthWrite:!1,depthTest:!1});this.toneMapped=!1,this.setTexelSize(r.x,r.y),this.kernelSize=kd.LARGE}getKernel(){return A3[this.kernelSize]}setTexelSize(r,e){this.uniforms.texelSize.value.set(r,e),this.uniforms.halfTexelSize.value.set(r,e).multiplyScalar(.5)}},A3=[new Float32Array([0,0]),new Float32Array([0,1,1]),new Float32Array([0,1,1,2]),new Float32Array([0,1,2,2,3]),new Float32Array([0,1,2,3,4,4,5]),new Float32Array([0,1,2,3,4,5,7,8,9,10])],kd={VERY_SMALL:0,SMALL:1,MEDIUM:2,LARGE:3,VERY_LARGE:4,HUGE:5},_3=`#ifdef FRAMEBUFFER_PRECISION_HIGH
|
||
|
|
uniform mediump sampler2D inputBuffer;
|
||
|
|
#else
|
||
|
|
uniform lowp sampler2D inputBuffer;
|
||
|
|
#endif
|
||
|
|
uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuffer,vUv);gl_FragColor=opacity*texel;
|
||
|
|
#include <encodings_fragment>
|
||
|
|
}`,sM=class extends _t{constructor(){super({type:"CopyMaterial",uniforms:{inputBuffer:new Ae(null),opacity:new Ae(1)},fragmentShader:_3,vertexShader:iu,blending:It,depthWrite:!1,depthTest:!1});this.toneMapped=!1}};var T3=class extends _t{constructor(r=new O,e=Vd.COLOR){super({type:"EdgeDetectionMaterial",defines:{LOCAL_CONTRAST_ADAPTATION_FACTOR:"2.0",EDGE_THRESHOLD:"0.1",DEPTH_THRESHOLD:"0.01",PREDICATION_MODE:"0",PREDICATION_THRESHOLD:"0.01",PREDICATION_SCALE:"2.0",PREDICATION_STRENGTH:"1.0",DEPTH_PACKING:"0"},uniforms:{inputBuffer:new Ae(null),depthBuffer:new Ae(null),predicationBuffer:new Ae(null),texelSize:new Ae(r)},fragmentShader:b3,vertexShader:w3,blending:It,depthWrite:!1,depthTest:!1});this.toneMapped=!1,this.setEdgeDetectionMode(e)}get depthPacking(){return Number(this.defines.DEPTH_PACKING)}set depthPacking(r){this.defines.DEPTH_PACKING=r.toFixed(0),this.needsUpdate=!0}setEdgeDetectionMode(r){this.defines.EDGE_DETECTION_MODE=r.toFixed(0),this.needsUpdate=!0}setLocalContrastAdaptationFactor(r){this.defines.LOCAL_CONTRAST_ADAPTATION_FACTOR=r.toFixed("6"),this.needsUpdate=!0}setEdgeDetectionThreshold(r){this.defines.EDGE_THRESHOLD=r.toFixed("6"),this.defines.DEPTH_THRESHOLD=(r*.1).toFixed("6"),this.needsUpdate=!0}setPredicationMode(r){this.defines.PREDICATION_MODE=r.toFixed(0),this.needsUpdate=!0}setPredicationBuffer(r){this.uniforms.predicationBuffer.value=r}setPredicationThreshold(r){this.defines.PREDICATION_THRESHOLD=r.toFixed("6"),this.needsUpdate=!0}setPredicationScale(r){this.defines.PREDICATION_SCALE=r.toFixed("6"),this.needsUpdate=!0}setPredicationStrength(r){this.defines.PREDICATION_STRENGTH=r.toFixed("6"),this.needsUpdate=!0}},Vd={DEPTH:0,LUMA:1,COLOR:2},oM={DISABLED:0,DEPTH:1,CUSTOM:2},E3=`#include <common>
|
||
|
|
#include <packing>
|
||
|
|
#include <dithering_pars_fragment>
|
||
|
|
#ifdef FRAMEBUFFER_PRECISION_HIGH
|
||
|
|
uniform mediump sampler2D inputBuffer;
|
||
|
|
#else
|
||
|
|
uniform lowp sampler2D inputBuffer;
|
||
|
|
#endif
|
||
|
|
#ifdef GL_FRAGMENT_PRECISION_HIGH
|
||
|
|
uniform highp sampler2D depthBuffer;
|
||
|
|
#else
|
||
|
|
uniform mediump sampler2D depthBuffer;
|
||
|
|
#endif
|
||
|
|
uniform vec2 resolution;uniform vec2 texelSize;uniform float cameraNear;uniform float cameraFar;uniform float aspect;uniform float time;varying vec2 vUv;float readDepth(const in vec2 uv){
|
||
|
|
#if DEPTH_PACKING == 3201
|
||
|
|
return unpackRGBAToDepth(texture2D(depthBuffer,uv));
|
||
|
|
#else
|
||
|
|
return texture2D(depthBuffer,uv).r;
|
||
|
|
#endif
|
||
|
|
}float getViewZ(const in float depth){
|
||
|
|
#ifdef PERSPECTIVE_CAMERA
|
||
|
|
return perspectiveDepthToViewZ(depth,cameraNear,cameraFar);
|
||
|
|
#else
|
||
|
|
return orthographicDepthToViewZ(depth,cameraNear,cameraFar);
|
||
|
|
#endif
|
||
|
|
}FRAGMENT_HEADvoid main(){FRAGMENT_MAIN_UVvec4 color0=texture2D(inputBuffer,UV);vec4 color1=vec4(0.0);FRAGMENT_MAIN_IMAGEgl_FragColor=color0;
|
||
|
|
#ifdef ENCODE_OUTPUT
|
||
|
|
#include <encodings_fragment>
|
||
|
|
#endif
|
||
|
|
#include <dithering_fragment>
|
||
|
|
}`,N3="uniform vec2 resolution;uniform vec2 texelSize;uniform float cameraNear;uniform float cameraFar;uniform float aspect;uniform float time;varying vec2 vUv;VERTEX_HEADvoid main(){vUv=position.xy*0.5+0.5;VERTEX_MAIN_SUPPORTgl_Position=vec4(position.xy,1.0,1.0);}",C3=class extends _t{constructor(r=null,e=null,t=null,n,i=!1){super({type:"EffectMaterial",defines:{DEPTH_PACKING:"0",ENCODE_OUTPUT:"1"},uniforms:{inputBuffer:new Ae(null),depthBuffer:new Ae(null),resolution:new Ae(new O),texelSize:new Ae(new O),cameraNear:new Ae(.3),cameraFar:new Ae(1e3),aspect:new Ae(1),time:new Ae(0)},blending:It,depthWrite:!1,depthTest:!1,dithering:i});this.toneMapped=!1,r!==null&&this.setShaderParts(r),e!==null&&this.setDefines(e),t!==null&&this.setUniforms(t),this.adoptCameraSettings(n)}get depthPacking(){return Number(this.defines.DEPTH_PACKING)}set depthPacking(r){this.defines.DEPTH_PACKING=r.toFixed(0),this.needsUpdate=!0}setShaderParts(r){return this.fragmentShader=E3.replace(pt.FRAGMENT_HEAD,r.get(pt.FRAGMENT_HEAD)).replace(pt.FRAGMENT_MAIN_UV,r.get(pt.FRAGMENT_MAIN_UV)).replace(pt.FRAGMENT_MAIN_IMAGE,r.get(pt.FRAGMENT_MAIN_IMAGE)),this.vertexShader=N3.replace(pt.VERTEX_HEAD,r.get(pt.VERTEX_HEAD)).replace(pt.VERTEX_MAIN_SUPPORT,r.get(pt.VERTEX_MAIN_SUPPORT)),this.needsUpdate=!0,this}setDefines(r){for(let e of r.entries())this.defines[e[0]]=e[1];return this.needsUpdate=!0,this}setUniforms(r){for(let e of r.entries())this.uniforms[e[0]]=e[1];return this}adoptCameraSettings(r=null){r!==null&&(this.uniforms.cameraNear.value=r.near,this.uniforms.cameraFar.value=r.far,r instanceof Vt?this.defines.PERSPECTIVE_CAMERA="1":delete this.defines.PERSPECTIVE_CAMERA,this.needsUpdate=!0)}setSize(r,e){let t=Math.max(r,1),n=Math.max(e,1);this.uniforms.resolution.value.set(t,n),this.uniforms.texelSize.value.set(1/t,1/n),this.uniforms.aspect.value=t/n}},pt={FRAGMENT_HEAD:"FRAGMENT_HEAD",FRAGMENT_MAIN_UV:"FRAGMENT_MAIN_UV",FRAGMENT_MAIN_IMAGE:"FRAGMENT_MAIN_IMAGE",VERTEX_HEAD:"VERTEX_HEAD",VERTEX_MAIN_SUPPORT:"VERTEX_MAIN_SUPPORT"};var L3=`#include <common>
|
||
|
|
#ifdef FRAMEBUFFER_PRECISION_HIGH
|
||
|
|
uniform mediump sampler2D inputBuffer;
|
||
|
|
#else
|
||
|
|
uniform lowp sampler2D inputBuffer;
|
||
|
|
#endif
|
||
|
|
#ifdef RANGE
|
||
|
|
uniform vec2 range;
|
||
|
|
#elif defined(THRESHOLD)
|
||
|
|
uniform float threshold;uniform float smoothing;
|
||
|
|
#endif
|
||
|
|
varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuffer,vUv);float l=linearToRelativeLuminance(texel.rgb);
|
||
|
|
#ifdef RANGE
|
||
|
|
float low=step(range.x,l);float high=step(l,range.y);l*=low*high;
|
||
|
|
#elif defined(THRESHOLD)
|
||
|
|
l=smoothstep(threshold,threshold+smoothing,l);
|
||
|
|
#endif
|
||
|
|
#ifdef COLOR
|
||
|
|
gl_FragColor=vec4(texel.rgb*l,l);
|
||
|
|
#else
|
||
|
|
gl_FragColor=vec4(l);
|
||
|
|
#endif
|
||
|
|
}`,I3=class extends _t{constructor(r=!1,e=null){let t=e!==null;super({type:"LuminanceMaterial",uniforms:{inputBuffer:new Ae(null),threshold:new Ae(0),smoothing:new Ae(1),range:new Ae(t?e:new O)},fragmentShader:L3,vertexShader:iu,blending:It,depthWrite:!1,depthTest:!1});this.toneMapped=!1,this.colorOutput=r,this.useThreshold=!0,this.useRange=t}get threshold(){return this.uniforms.threshold.value}set threshold(r){this.uniforms.threshold.value=r}get smoothing(){return this.uniforms.smoothing.value}set smoothing(r){this.uniforms.smoothing.value=r}get useThreshold(){return this.defines.THRESHOLD!==void 0}set useThreshold(r){r?this.defines.THRESHOLD="1":delete this.defines.THRESHOLD,this.needsUpdate=!0}get colorOutput(){return this.defines.COLOR!==void 0}set colorOutput(r){r?this.defines.COLOR="1":delete this.defines.COLOR,this.needsUpdate=!0}setColorOutputEnabled(r){this.colorOutput=r}get useRange(){return this.defines.RANGE!==void 0}set useRange(r){r?this.defines.RANGE="1":delete this.defines.RANGE,this.needsUpdate=!0}get luminanceRange(){return this.useRange}set luminanceRange(r){this.useRange=r}setLuminanceRangeEnabled(r){this.useRange=r}},P3=`#ifdef FRAMEBUFFER_PRECISION_HIGH
|
||
|
|
uniform mediump sampler2D inputBuffer;
|
||
|
|
#else
|
||
|
|
uniform lowp sampler2D inputBuffer;
|
||
|
|
#endif
|
||
|
|
#ifdef MASK_PRECISION_HIGH
|
||
|
|
uniform mediump sampler2D maskTexture;
|
||
|
|
#else
|
||
|
|
uniform lowp sampler2D maskTexture;
|
||
|
|
#endif
|
||
|
|
#if MASK_FUNCTION != 0
|
||
|
|
uniform float strength;
|
||
|
|
#endif
|
||
|
|
varying vec2 vUv;void main(){
|
||
|
|
#if COLOR_CHANNEL == 0
|
||
|
|
float mask=texture2D(maskTexture,vUv).r;
|
||
|
|
#elif COLOR_CHANNEL == 1
|
||
|
|
float mask=texture2D(maskTexture,vUv).g;
|
||
|
|
#elif COLOR_CHANNEL == 2
|
||
|
|
float mask=texture2D(maskTexture,vUv).b;
|
||
|
|
#else
|
||
|
|
float mask=texture2D(maskTexture,vUv).a;
|
||
|
|
#endif
|
||
|
|
#if MASK_FUNCTION == 0
|
||
|
|
#ifdef INVERTED
|
||
|
|
mask=step(mask,0.0);
|
||
|
|
#else
|
||
|
|
mask=1.0-step(mask,0.0);
|
||
|
|
#endif
|
||
|
|
#else
|
||
|
|
mask=clamp(mask*strength,0.0,1.0);
|
||
|
|
#ifdef INVERTED
|
||
|
|
mask=1.0-mask;
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#if MASK_FUNCTION == 2
|
||
|
|
gl_FragColor=vec4(mask*texture2D(inputBuffer,vUv).rgb,mask);
|
||
|
|
#else
|
||
|
|
gl_FragColor=mask*texture2D(inputBuffer,vUv);
|
||
|
|
#endif
|
||
|
|
}`,D3=class extends _t{constructor(r=null){super({type:"MaskMaterial",uniforms:{maskTexture:new Ae(r),inputBuffer:new Ae(null),strength:new Ae(1)},fragmentShader:P3,vertexShader:iu,blending:It,depthWrite:!1,depthTest:!1});this.toneMapped=!1,this.colorChannel=iM.RED,this.maskFunction=aM.DISCARD}set maskTexture(r){this.uniforms.maskTexture.value=r,delete this.defines.MASK_PRECISION_HIGH,r.type!==At&&(this.defines.MASK_PRECISION_HIGH="1"),this.needsUpdate=!0}set colorChannel(r){this.defines.COLOR_CHANNEL=r.toFixed(0),this.needsUpdate=!0}set maskFunction(r){this.defines.MASK_FUNCTION=r.toFixed(0),this.needsUpdate=!0}get inverted(){return this.defines.INVERTED!==void 0}set inverted(r){this.inverted&&!r?delete this.defines.INVERTED:r&&(this.defines.INVERTED="1"),this.needsUpdate=!0}get strength(){return this.uniforms.strength.value}set strength(r){this.uniforms.strength.value=r}},aM={DISCARD:0,MULTIPLY:1,MULTIPLY_RGB_SET_ALPHA:2};var R3=`#define sampleLevelZeroOffset(t, coord, offset) texture2D(t, coord + offset * texelSize)
|
||
|
|
#if __VERSION__ < 300
|
||
|
|
#define round(v) floor(v + 0.5)
|
||
|
|
#endif
|
||
|
|
#ifdef FRAMEBUFFER_PRECISION_HIGH
|
||
|
|
uniform mediump sampler2D inputBuffer;
|
||
|
|
#else
|
||
|
|
uniform lowp sampler2D inputBuffer;
|
||
|
|
#endif
|
||
|
|
uniform lowp sampler2D areaTexture;uniform lowp sampler2D searchTexture;uniform vec2 texelSize;uniform vec2 resolution;varying vec2 vUv;varying vec4 vOffset[3];varying vec2 vPixCoord;void movec(const in bvec2 c,inout vec2 variable,const in vec2 value){if(c.x){variable.x=value.x;}if(c.y){variable.y=value.y;}}void movec(const in bvec4 c,inout vec4 variable,const in vec4 value){movec(c.xy,variable.xy,value.xy);movec(c.zw,variable.zw,value.zw);}vec2 decodeDiagBilinearAccess(in vec2 e){e.r=e.r*abs(5.0*e.r-5.0*0.75);return round(e);}vec4 decodeDiagBilinearAccess(in vec4 e){e.rb=e.rb*abs(5.0*e.rb-5.0*0.75);return round(e);}vec2 searchDiag1(const in vec2 texCoord,const in vec2 dir,out vec2 e){vec4 coord=vec4(texCoord,-1.0,1.0);vec3 t=vec3(texelSize,1.0);for(int i=0;i<MAX_SEARCH_STEPS_INT;++i){if(!(coord.z<float(MAX_SEARCH_STEPS_DIAG_INT-1)&&coord.w>0.9)){break;}coord.xyz=t*vec3(dir,1.0)+coord.xyz;e=texture2D(inputBuffer,coord.xy).rg;coord.w=dot(e,vec2(0.5));}return coord.zw;}vec2 searchDiag2(const in vec2 texCoord,const in vec2 dir,out vec2 e){vec4 coord=vec4(texCoord,-1.0,1.0);coord.x+=0.25*texelSize.x;vec3 t=vec3(texelSize,1.0);for(int i=0;i<MAX_SEARCH_STEPS_INT;++i){if(!(coord.z<float(MAX_SEARCH_STEPS_DIAG_INT-1)&&coord.w>0.9)){break;}coord.xyz=t*vec3(dir,1.0)+coord.xyz;e=texture2D(inputBuffer,coord.xy).rg;e=decodeDiagBilinearAccess(e);coord.w=dot(e,vec2(0.5));}return coord.zw;}vec2 areaDiag(const in vec2 dist,const in vec2 e,const in float offset){vec2 texCoord=vec2(AREATEX_MAX_DISTANCE_DIAG,AREATEX_MAX_DISTANCE_DIAG)*e+dist;texCoord=AREATEX_PIXEL_SIZE*texCoord+0.5*AREATEX_PIXEL_SIZE;texCoord.x+=0.5;texCoord.y+=AREATEX_SUBTEX_SIZE*offset;return texture2D(areaTexture,texCoord).rg;}vec2 calculateDiagWeights(const in vec2 texCoord,const in vec2 e,const in vec4 subsampleIndices){vec2 weights=vec2(0.0);vec4 d;vec2 end;if(e.r>0.0){d.xz=searchDiag1(texCoord,vec2(-1.0,1.0),end);d.x+=float(end.y>0.9);}else{d.xz=vec2(0.0);}d.yw=searchDiag1(texCoord,vec2(1.0,-1.0),end);if(d.x+d.y>2.0){vec4 coords=vec4(-d.x+0.25,d.x,d.y,-d.y-0.25)*texelSize.xyxy+texCoord.xyxy;vec4 c;c.xy=sampleLevelZeroOffset(inputBuffer,coords.xy,vec2(-1,0)).rg;c.zw=sampleLevelZeroOffset(inputBuffer,coords.zw,vec2(1,0)).rg;c.yxwz=decodeDiagBilinearAccess(c.xyzw);vec2 cc=vec2(2.0)*c.xz+c.yw;movec(bvec2(step(0.9,d.zw)),cc,vec2(0.0));weights+=areaDiag(d.xy,cc,subsampleIndices.z);}d.xz=searchDiag2(texCoord,vec2(-1.0,-1.0),end);if(sampleLevelZeroOffset(inputBuffer,texCoord,vec2(1,0)).r>0.0){d.yw=searchDiag2(texCoord,vec2(1.0),end);d.y+=float(end.y>0.9);}else{d.yw=vec2(0.0);}if(d.x+d.y>2.0){vec4 coords=vec4(-d.x,-d.x,d.y,d.y)*texelSize.xyxy+texCoord.xyxy;vec4 c;c.x=sampleLevelZeroOffset(inputBuffer,coords.xy,vec2(-1,0)).g;c.y=sampleLevelZeroOffset(inputBuffer,coords.xy,vec2(0,-1)).r;c.zw=sampleLevelZeroOffset(inputBuffer,coords.zw,vec2(1,0)).gr;vec2 cc=vec2(2.0)*c.xz+c.yw;movec(bvec2(step(0.9,d.zw)),cc,vec2(0.0));weights+=areaDiag(d.xy,cc,subsampleIndices.w).gr;}return weights;}float searchLength(const in vec2 e,const in float offset){vec2 scale=SEARCHTEX_SIZE*vec2(0.5,-1.0);vec2 bias=SEARCHTEX_SIZE*vec2(offset,1.0);scale+=vec2(-1.0,1.0);bias+=vec2(0.5,-0.5);scale*=1.0/SEARCHTEX_PACKED_SIZE;bias*=1.0/SEARCHTEX_PACKED_SIZE;return texture2D(searchTexture,scale*e+bias).r;}float searchXLeft(in vec2 texCoord,const in float end){vec2 e=vec2(0.0,1.0);for(int i=0;i<MAX_SEARCH_STEPS_INT;++i){if(!(texCoord.x>end&&e.g>0.8281&&e.r==0.0)){break;}e=texture2D(inputBuffer,texCoord).rg;texCoord=vec2(-2.0,0.0)*texelSize+texCoord;}float offset=-(255.0/127.0)*searchLength(e,0.0)+3.25;return texelSize.x*offset+texCoord.x;}float searchXRight(vec2 texCoord,const in float end){vec2 e=vec2(0.0,1.0);for(int i=0;i<MAX_SEARCH_STEPS_INT;++i){if(!(texCoord.x<end&&e.g>0.8281&&e.r==0.0)){break;}e=texture2D(inputBuffer,texCoord).rg;texCoord=vec2(2.0,0.0)*texelSize.xy+texCoord;}float offset=-(255.0/127.0)*searchLength(e,0.5)+3.25;return-texelSize.x*offset+texCoord.x;}float searchYUp(vec2 texCoord,const in float end){vec2 e=vec2(1.0,0.0);for(int i=0;i<MAX_SEARCH_STEPS_INT;++i){if(!(texCoord.y>end&&e.r>0.8281
|
||
|
|
#if !defined(DISABLE_CORNER_DETECTION)
|
||
|
|
vec2 leftRight=step(d.xy,d.yx);vec2 rounding=(1.0-CORNER_ROUNDING_NORM)*leftRight;rounding/=leftRight.x+leftRight.y;vec2 factor=vec2(1.0);factor.x-=rounding.x*sampleLevelZeroOffset(inputBuffer,texCoord.xy,vec2(0,1)).r;factor.x-=rounding.y*sampleLevelZeroOffset(inputBuffer,texCoord.zw,vec2(1,1)).r;factor.y-=rounding.x*sampleLevelZeroOffset(inputBuffer,texCoord.xy,vec2(0,-2)).r;factor.y-=rounding.y*sampleLevelZeroOffset(inputBuffer,texCoord.zw,vec2(1,-2)).r;weights*=clamp(factor,0.0,1.0);
|
||
|
|
#endif
|
||
|
|
}void detectVerticalCornerPattern(inout vec2 weights,const in vec4 texCoord,const in vec2 d){
|
||
|
|
#if !defined(DISABLE_CORNER_DETECTION)
|
||
|
|
vec2 leftRight=step(d.xy,d.yx);vec2 rounding=(1.0-CORNER_ROUNDING_NORM)*leftRight;rounding/=leftRight.x+leftRight.y;vec2 factor=vec2(1.0);factor.x-=rounding.x*sampleLevelZeroOffset(inputBuffer,texCoord.xy,vec2(1,0)).g;factor.x-=rounding.y*sampleLevelZeroOffset(inputBuffer,texCoord.zw,vec2(1,1)).g;factor.y-=rounding.x*sampleLevelZeroOffset(inputBuffer,texCoord.xy,vec2(-2,0)).g;factor.y-=rounding.y*sampleLevelZeroOffset(inputBuffer,texCoord.zw,vec2(-2,1)).g;weights*=clamp(factor,0.0,1.0);
|
||
|
|
#endif
|
||
|
|
}void main(){vec4 weights=vec4(0.0);vec4 subsampleIndices=vec4(0.0);vec2 e=texture2D(inputBuffer,vUv).rg;if(e.g>0.0){
|
||
|
|
#if !defined(DISABLE_DIAG_DETECTION)
|
||
|
|
weights.rg=calculateDiagWeights(vUv,e,subsampleIndices);if(weights.r==-weights.g){
|
||
|
|
#endif
|
||
|
|
vec2 d;vec3 coords;coords.x=searchXLeft(vOffset[0].xy,vOffset[2].x);coords.y=vOffset[1].y;d.x=coords.x;float e1=texture2D(inputBuffer,coords.xy).r;coords.z=searchXRight(vOffset[0].zw,vOffset[2].y);d.y=coords.z;d=round(resolution.xx*d+-vPixCoord.xx);vec2 sqrtD=sqrt(abs(d));float e2=sampleLevelZeroOffset(inputBuffer,coords.zy,vec2(1,0)).r;weights.rg=area(sqrtD,e1,e2,subsampleIndices.y);coords.y=vUv.y;detectHorizontalCornerPattern(weights.rg,coords.xyzy,d);
|
||
|
|
#if !defined(DISABLE_DIAG_DETECTION)
|
||
|
|
}else{e.r=0.0;}
|
||
|
|
#endif
|
||
|
|
}if(e.r>0.0){vec2 d;vec3 coords;coords.y=searchYUp(vOffset[1].xy,vOffset[2].z);coords.x=vOffset[0].x;d.x=coords.y;float e1=texture2D(inputBuffer,coords.xy).g;coords.z=searchYDown(vOffset[1].zw,vOffset[2].w);d.y=coords.z;d=round(resolution.yy*d-vPixCoord.yy);vec2 sqrtD=sqrt(abs(d));float e2=sampleLevelZeroOffset(inputBuffer,coords.xz,vec2(0,1)).g;weights.ba=area(sqrtD,e1,e2,subsampleIndices.x);coords.x=vUv.x;detectVerticalCornerPattern(weights.ba,coords.xyxz,d);}gl_FragColor=weights;}`,B3="uniform vec2 texelSize;uniform vec2 resolution;varying vec2 vUv;varying vec4 vOffset[3];varying vec2 vPixCoord;void main(){vUv=position.xy*0.5+0.5;vPixCoord=vUv*resolution;vOffset[0]=vUv.xyxy+texelSize.xyxy*vec4(-0.25,-0.125,1.25,-0.125);vOffset[1]=vUv.xyxy+texelSize.xyxy*vec4(-0.125,-0.25,-0.125,1.25);vOffset[2]=vec4(vOffset[0].xz,vOffset[1].yw)+vec4(-2.0,2.0,-2.0,2.0)*texelSize.xxyy*MAX_SEARCH_STEPS_FLOAT;gl_Position=vec4(position.xy,1.0,1.0);}",O3=class extends _t{constructor(r=new O,e=new O){super({type:"SMAAWeightsMaterial",defines:{MAX_SEARCH_STEPS_INT:"16",MAX_SEARCH_STEPS_FLOAT:"16.0",MAX_SEARCH_STEPS_DIAG_INT:"8",MAX_SEARCH_STEPS_DIAG_FLOAT:"8.0",CORNER_ROUNDING:"25",CORNER_ROUNDING_NORM:"0.25",AREATEX_MAX_DISTANCE:"16.0",AREATEX_MAX_DISTANCE_DIAG:"20.0",AREATEX_PIXEL_SIZE:"(1.0 / vec2(160.0, 560.0))",AREATEX_SUBTEX_SIZE:"(1.0 / 7.0)",SEARCHTEX_SIZE:"vec2(66.0, 33.0)",SEARCHTEX_PACKED_SIZE:"vec2(64.0, 16.0)"},uniforms:{inputBuffer:new Ae(null),areaTexture:new Ae(null),searchTexture:new Ae(null),texelSize:new Ae(r),resolution:new Ae(e)},fragmentShader:R3,vertexShader:B3,blending:It,depthWrite:!1,depthTest:!1});this.toneMapped=!1}setOrthogonalSearchSteps(r){let e=Math.min(Math.max(r,0),112);this.defines.MAX_SEARCH_STEPS_INT=e.toFixed("0"),this.defines.MAX_SEARCH_STEPS_FLOAT=e.toFixed("1"),this.needsUpdate=!0}setDiagonalSearchSteps(r){let e=Math.min(Math.max(r,0),20);this.defines.MAX_SEARCH_STEPS_DIAG_INT=e.toFixed("0"),this.defines.MAX_SEARCH_STEPS_DIAG_FLOAT=e.toFixed("1"),this.needsUpdate=!0}setCornerRounding(r){let e=Math.min(Math.max(r,0),100);this.defines.CORNER_ROUNDING=e.toFixed("4"),this.defines.CORNER_ROUNDING_NORM=(e/100).toFixed("4"),this.needsUpdate=!0}get diagonalDetection(){return this.defines.DISABLE_DIAG_DETECTION===void 0}set diagonalDetection(r){r?delete this.defines.DISABLE_DIAG_DETECTION:this.defines.DISABLE_DIAG_DETECTION="1",this.needsUpdate=!0}get cornerRounding(){return this.defines.DISABLE_CORNER_DETECTION===void 0}set cornerRounding(r){r?delete this.defines.DISABLE_CORNER_DETECTION:this.defines.DISABLE_CORNER_DETECTION="1",this.needsUpdate=!0}};var F3=new Dr,Fs=null;function z3(){if(Fs===null){let r=new Float32Array([-1,-1,0,3,-1,0,-1,3,0]),e=new Float32Array([0,0,2,0,0,2]);Fs=new we,Fs.setAttribute!==void 0?(Fs.setAttribute("position",new Re(r,3)),Fs.setAttribute("uv",new Re(e,2))):(Fs.addAttribute("position",new Re(r,3)),Fs.addAttribute("uv",new Re(e,2)))}return Fs}var Wr=class{constructor(r="Pass",e=new An,t=F3){this.name=r,this.scene=e,this.camera=t,this.screen=null,this.rtt=!0,this.needsSwap=!0,this.needsDepthTexture=!1,this.enabled=!0}get renderToScreen(){return!this.rtt}set renderToScreen(r){if(this.rtt===r){let e=this.getFullscreenMaterial();e!==null&&(e.needsUpdate=!0),this.rtt=!r}}getFullscreenMaterial(){return this.screen!==null?this.screen.material:null}setFullscreenMaterial(r){let e=this.screen;e!==null?e.material=r:(e=new gt(z3(),r),e.frustumCulled=!1,this.scene===null&&(this.scene=new An),this.scene.add(e),this.screen=e)}getDepthTexture(){return null}setDepthTexture(r,e=0){}render(r,e,t,n,i){throw new Error("Render method not implemented!")}setSize(r,e){}initialize(r,e,t){}dispose(){let r=this.getFullscreenMaterial();r!==null&&r.dispose();for(let e of Object.keys(this)){let t=this[e];if(t!==null&&typeof t.dispose=="function"){if(t instanceof An)continue;this[e].dispose()}}}},lM=class extends Wr{constructor(r,e=!0){super("SavePass");this.setFullscreenMaterial(new sM),this.needsSwap=!1,this.renderTarget=r,r===void 0&&(this.renderTarget=new bt(1,1,{minFilter:$e,magFilter:$e,stencilBuffer:!1,
|
||
|
|
`),m=!0),u.get("vertex")!==null&&/mainSupport/.test(u.get("vertex"))){let g=" "+r+"MainSupport(";/mainSupport *\([\w\s]*?uv\s*?\)/.test(u.get("vertex"))&&(g+="vUv"),g+=`);
|
||
|
|
`,t.set(pt.VERTEX_MAIN_SUPPORT,t.get(pt.VERTEX_MAIN_SUPPORT)+g),f=f.concat(og(l,u.get("vertex"))),p=p.concat(f).concat(og(a,u.get("vertex")))}if(p=p.concat(og(a,u.get("fragment"))).concat(Array.from(e.defines.keys()).map(g=>g.replace(/\([\w\s,]*\)/g,""))).concat(Array.from(e.uniforms.keys())),e.uniforms.forEach((g,y)=>s.set(r+y.charAt(0).toUpperCase()+y.slice(1),g)),e.defines.forEach((g,y)=>i.set(r+y.charAt(0).toUpperCase()+y.slice(1),g)),hM(r,p,i),hM(r,p,u),n.set(c.blendFunction,c),h){let g=/MainImage *\([\w\s,]*?depth[\w\s,]*?\)/,y=r+"MainImage(color0, UV, ";(o&ir.DEPTH)!=0&&g.test(u.get("fragment"))&&(y+="depth, ",v=!0),y+=`color1);
|
||
|
|
`;let x=r+"BlendOpacity";s.set(x,c.opacity),y+="color0 = blend"+c.getBlendFunction()+"(color0, color1, "+x+`);
|
||
|
|
|
||
|
|
`,t.set(pt.FRAGMENT_MAIN_IMAGE,t.get(pt.FRAGMENT_MAIN_IMAGE)+y),t.set(pt.FRAGMENT_HEAD,t.get(pt.FRAGMENT_HEAD)+"uniform float "+x+`;
|
||
|
|
|
||
|
|
`)}t.set(pt.FRAGMENT_HEAD,t.get(pt.FRAGMENT_HEAD)+u.get("fragment")+`
|
||
|
|
`),u.get("vertex")!==null&&t.set(pt.VERTEX_HEAD,t.get(pt.VERTEX_HEAD)+u.get("vertex")+`
|
||
|
|
`)}return{varyings:f,transformedUv:m,readDepth:v}}var Hd=class extends Wr{constructor(r,...e){super("EffectPass");this.setFullscreenMaterial(new C3(null,null,null,r)),this.effects=e.sort((t,n)=>n.attributes-t.attributes),this.skipRendering=!1,this.uniforms=0,this.varyings=0,this.minTime=1,this.maxTime=Number.POSITIVE_INFINITY}get encodeOutput(){return this.getFullscreenMaterial().defines.ENCODE_OUTPUT!==void 0}set encodeOutput(r){if(this.encodeOutput!==r){let e=this.getFullscreenMaterial();e.needsUpdate=!0,r?e.defines.ENCODE_OUTPUT="1":delete e.defines.ENCODE_OUTPUT}}get dithering(){return this.getFullscreenMaterial().dithering}set dithering(r){let e=this.getFullscreenMaterial();e.dithering!==r&&(e.dithering=r,e.needsUpdate=!0)}verifyResources(r){let e=r.capabilities,t=Math.min(e.maxFragmentUniforms,e.maxVertexUniforms);this.uniforms>t&&console.warn("The current rendering context doesn't support more than "+t+" uniforms, but "+this.uniforms+" were defined"),t=e.maxVaryings,this.varyings>t&&console.warn("The current rendering context doesn't support more than "+t+" varyings, but "+this.varyings+" were defined")}updateMaterial(){let r=/\bblend\b/g,e=new Map([[pt.FRAGMENT_HEAD,""],[pt.FRAGMENT_MAIN_UV,""],[pt.FRAGMENT_MAIN_IMAGE,""],[pt.VERTEX_HEAD,""],[pt.VERTEX_MAIN_SUPPORT,""]]),t=new Map,n=new Map,i=new Map,s=new Set,o=0,a=0,l=0,c=!1,u=!1,h;for(let f of this.effects)if(f.blendMode.getBlendFunction()===ut.SKIP)l|=f.getAttributes()&ir.DEPTH;else if((l&ir.CONVOLUTION)!=0&&(f.getAttributes()&ir.CONVOLUTION)!=0)console.error("Convolution effects cannot be merged",f);else if(l|=f.getAttributes(),h=oF("e"+o++,f,e,t,n,i,l),a+=h.varyings.length,c=c||h.transformedUv,u=u||h.readDepth,f.extensions!==null)for(let p of f.extensions)s.add(p);for(let f of t.values())e.set(pt.FRAGMENT_HEAD,e.get(pt.FRAGMENT_HEAD)+f.getShaderCode().replace(r,"blend"+f.getBlendFunction())+`
|
||
|
|
`);(l&ir.DEPTH)!=0?(u&&e.set(pt.FRAGMENT_MAIN_IMAGE,`float depth = readDepth(UV);
|
||
|
|
|
||
|
|
`+e.get(pt.FRAGMENT_MAIN_IMAGE)),this.needsDepthTexture=this.getDepthTexture()===null):this.needsDepthTexture=!1,c?(e.set(pt.FRAGMENT_MAIN_UV,`vec2 transformedUv = vUv;
|
||
|
|
`+e.get(pt.FRAGMENT_MAIN_UV)),n.set("UV","transformedUv")):n.set("UV","vUv"),e.forEach((f,p,m)=>m.set(p,f.trim().replace(/^#/,`
|
||
|
|
#`))),this.uniforms=i.size,this.varyings=a,this.skipRendering=o===0,this.needsSwap=!this.skipRendering;let d=this.getFullscreenMaterial();if(d.setShaderParts(e).setDefines(n).setUniforms(i),d.extensions={},s.size>0)for(let f of s)d.extensions[f]=!0;this.needsUpdate=!1}recompile(r){this.updateMaterial(),r!==void 0&&this.verifyResources(r)}getDepthTexture(){return this.getFullscreenMaterial().uniforms.depthBuffer.value}setDepthTexture(r,e=Kr){let t=this.getFullscreenMaterial();t.uniforms.depthBuffer.value=r,t.depthPacking=e,t.needsUpdate=!0;for(let n of this.effects)n.setDepthTexture(r,e)}render(r,e,t,n,i){let s=this.getFullscreenMaterial(),o=s.uniforms.time.value+n;this.needsUpdate&&this.recompile(r);for(let a of this.effects)a.update(r,e,n);(!this.skipRendering||this.renderToScreen)&&(s.uniforms.inputBuffer.value=e.texture,s.uniforms.time.value=o<=this.maxTime?o:this.minTime,r.setRenderTarget(this.renderToScreen?null:t),r.render(this.scene,this.camera))}setSize(r,e){this.getFullscreenMaterial().setSize(r,e);for(let t of this.effects)t.setSize(r,e)}initialize(r,e,t){for(let n of this.effects)n.initialize(r,e,t),n.addEventListener("change",i=>this.handleEvent(i));if(this.updateMaterial(),this.verifyResources(r),t!==void 0&&t!==At){let n=this.getFullscreenMaterial();n.defines.FRAMEBUFFER_PRECISION_HIGH="1"}}dispose(){super.dispose();for(let r of this.effects)r.dispose()}handleEvent(r){switch(r.type){case"change":this.needsUpdate=!0;break}}};var aF=class extends Wr{constructor({width:r=nr.AUTO_SIZE,height:e=nr.AUTO_SIZE,renderTarget:t,luminanceRange:n,colorOutput:i}={}){super("LuminancePass");this.setFullscreenMaterial(new I3(i,n)),this.needsSwap=!1,this.renderTarget=t,this.renderTarget===void 0&&(this.renderTarget=new bt(1,1,{minFilter:$e,magFilter:$e,format:i?zt:Qd,stencilBuffer:!1,depthBuffer:!1}),this.renderTarget.texture.name="LuminancePass.Target",this.renderTarget.texture.generateMipmaps=!1),this.resolution=new nr(this,r,e)}get texture(){return this.renderTarget.texture}render(r,e,t,n,i){let s=this.getFullscreenMaterial();s.uniforms.inputBuffer.value=e.texture,r.setRenderTarget(this.renderToScreen?null:this.renderTarget),r.render(this.scene,this.camera)}setSize(r,e){let t=this.resolution;t.base.set(r,e),this.renderTarget.setSize(t.width,t.height)}initialize(r,e,t){if(t!==void 0&&t!==At){let n=this.getFullscreenMaterial();n.defines.FRAMEBUFFER_PRECISION_HIGH="1"}}},lF=class extends Wr{constructor(r,e){super("MaskPass",r,e);this.needsSwap=!1,this.clearPass=new ig(!1,!1,!0),this.inverse=!1}get clear(){return this.clearPass.enabled}set clear(r){this.clearPass.enabled=r}render(r,e,t,n,i){let s=r.getContext(),o=r.state.buffers,a=this.scene,l=this.camera,c=this.clearPass,u=this.inverse?0:1,h=1-u;o.color.setMask(!1),o.depth.setMask(!1),o.color.setLocked(!0),o.depth.setLocked(!0),o.stencil.setTest(!0),o.stencil.setOp(s.REPLACE,s.REPLACE,s.REPLACE),o.stencil.setFunc(s.ALWAYS,u,4294967295),o.stencil.setClear(h),o.stencil.setLocked(!0),this.clear&&(this.renderToScreen?c.render(r,null):(c.render(r,e),c.render(r,t))),this.renderToScreen?(r.setRenderTarget(null),r.render(a,l)):(r.setRenderTarget(e),r.render(a,l),r.setRenderTarget(t),r.render(a,l)),o.color.setLocked(!1),o.depth.setLocked(!1),o.stencil.setLocked(!1),o.stencil.setFunc(s.EQUAL,1,4294967295),o.stencil.setOp(s.KEEP,s.KEEP,s.KEEP),o.stencil.setLocked(!0)}};var Xr=class extends Wr{constructor(r,e="inputBuffer"){super("ShaderPass");this.setFullscreenMaterial(r),this.uniform=null,this.setInput(e)}setInput(r){let e=this.getFullscreenMaterial();if(this.uniform=null,e!==null){let t=e.uniforms;t!==void 0&&t[r]!==void 0&&(this.uniform=t[r])}}render(r,e,t,n,i){this.uniform!==null&&e!==null&&(this.uniform.value=e.texture),r.setRenderTarget(this.renderToScreen?null:t),r.render(this.scene,this.camera)}initialize(r,e,t){if(t!==void 0&&t!==At){let n=this.getFullscreenMaterial();n.defines.FRAMEBUFFER_PRECISION_HIGH="1"}}},dM=class{constructor(r=null,{depthBuffer:e=!0,stencilBuffer:t=!1,alpha:n=!1,multisampling:i=0,frameBufferType:s}={}){this.renderer=r,this.inputBuffer=null,this.outputB
|
||
|
|
uniform mediump sampler2D map;
|
||
|
|
#else
|
||
|
|
uniform lowp sampler2D map;
|
||
|
|
#endif
|
||
|
|
uniform float intensity;void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){outputColor=clamp(texture2D(map,uv)*intensity,0.0,1.0);}`,fM=class extends Mr{constructor({blendFunction:r=ut.SCREEN,luminanceThreshold:e=.9,luminanceSmoothing:t=.025,resolutionScale:n=.5,intensity:i=1,width:s=nr.AUTO_SIZE,height:o=nr.AUTO_SIZE,kernelSize:a=kd.LARGE}={}){super("BloomEffect",cF,{blendFunction:r,uniforms:new Map([["map",new Ae(null)],["intensity",new Ae(i)]])});this.renderTarget=new bt(1,1,{minFilter:$e,magFilter:$e,stencilBuffer:!1,depthBuffer:!1}),this.renderTarget.texture.name="Bloom.Target",this.renderTarget.texture.generateMipmaps=!1,this.uniforms.get("map").value=this.renderTarget.texture,this.blurPass=new cM({resolutionScale:n,width:s,height:o,kernelSize:a}),this.blurPass.resolution.resizable=this,this.luminancePass=new aF({renderTarget:this.renderTarget,colorOutput:!0}),this.luminancePass.resolution=this.resolution,this.luminanceMaterial.threshold=e,this.luminanceMaterial.smoothing=t}get texture(){return this.renderTarget.texture}get luminanceMaterial(){return this.luminancePass.getFullscreenMaterial()}get resolution(){return this.blurPass.resolution}get width(){return this.resolution.width}set width(r){this.resolution.width=r}get height(){return this.resolution.height}set height(r){this.resolution.height=r}get dithering(){return this.blurPass.dithering}set dithering(r){this.blurPass.dithering=r}get kernelSize(){return this.blurPass.kernelSize}set kernelSize(r){this.blurPass.kernelSize=r}get distinction(){return console.warn(this.name,"The distinction field has been removed, use luminanceMaterial.threshold and luminanceMaterial.smoothing instead."),1}set distinction(r){console.warn(this.name,"The distinction field has been removed, use luminanceMaterial.threshold and luminanceMaterial.smoothing instead.")}get intensity(){return this.uniforms.get("intensity").value}set intensity(r){this.uniforms.get("intensity").value=r}getResolutionScale(){return this.resolution.scale}setResolutionScale(r){this.resolution.scale=r}update(r,e,t){let n=this.renderTarget;this.luminancePass.enabled?(this.luminancePass.render(r,e,n),this.blurPass.render(r,n,n)):this.blurPass.render(r,e,n)}setSize(r,e){this.blurPass.setSize(r,e),this.renderTarget.setSize(this.resolution.width,this.resolution.height)}initialize(r,e,t){this.blurPass.initialize(r,e,t),!e&&t===At&&(this.renderTarget.texture.format=Nt),t!==void 0&&(this.renderTarget.texture.type=t)}};var uF="uniform float brightness;uniform float contrast;void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){vec3 color=inputColor.rgb+vec3(brightness-0.5);if(contrast>0.0){color/=vec3(1.0-contrast);}else{color*=vec3(1.0+contrast);}outputColor=vec4(min(color+vec3(0.5),1.0),inputColor.a);}",pM=class extends Mr{constructor({blendFunction:r=ut.NORMAL,brightness:e=0,contrast:t=0}={}){super("BrightnessContrastEffect",uF,{blendFunction:r,uniforms:new Map([["brightness",new Ae(e)],["contrast",new Ae(t)]])})}},hF="void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){float sum=inputColor.r+inputColor.g+inputColor.b;outputColor=vec4(vec3(sum/3.0),inputColor.a);}",mM=class extends Mr{constructor(r=ut.NORMAL){super("ColorAverageEffect",hF,{blendFunction:r})}};var dF=`varying vec2 vUvR;varying vec2 vUvB;void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){vec4 color=inputColor;
|
||
|
|
#ifdef ALPHA
|
||
|
|
vec2 ra=texture2D(inputBuffer,vUvR).ra;vec2 ba=texture2D(inputBuffer,vUvB).ba;color.r=ra.x;color.b=ba.x;color.a=max(max(ra.y,ba.y),inputColor.a);
|
||
|
|
#else
|
||
|
|
color.r=texture2D(inputBuffer,vUvR).r;color.b=texture2D(inputBuffer,vUvB).b;
|
||
|
|
#endif
|
||
|
|
outputColor=color;}`,fF="uniform vec2 offset;varying vec2 vUvR;varying vec2 vUvB;void mainSupport(const in vec2 uv){vUvR=uv+offset;vUvB=uv-offset;}",gM=class extends Mr{constructor({blendFunction:r=ut.NORMAL,offset:e=new O(.001,5e-4)}={}){super("ChromaticAberrationEffect",dF,{vertexShader:fF,blendFunction:r,attributes:ir.CONVOLUTION,uniforms:new Map([["offset",new Ae(e)]])})}get offset(){return this.uniforms.get("offset").value}set offset(r){this.uniforms.get("offset").value=r}initialize(r,e,t){e?this.defines.set("ALPHA","1"):this.defines.delete("ALPHA")}};var pF=`#ifdef FRAMEBUFFER_PRECISION_HIGH
|
||
|
|
uniform mediump sampler2D nearColorBuffer;uniform mediump sampler2D farColorBuffer;
|
||
|
|
#else
|
||
|
|
uniform lowp sampler2D nearColorBuffer;uniform lowp sampler2D farColorBuffer;
|
||
|
|
#endif
|
||
|
|
uniform lowp sampler2D nearCoCBuffer;uniform float scale;void mainImage(const in vec4 inputColor,const in vec2 uv,const in float depth,out vec4 outputColor){vec4 colorNear=texture2D(nearColorBuffer,uv);vec4 colorFar=texture2D(farColorBuffer,uv);float CoCNear=texture2D(nearCoCBuffer,uv).r;CoCNear=min(CoCNear*scale,1.0);vec4 result=inputColor*(1.0-colorFar.a)+colorFar;result=mix(result,colorNear,CoCNear);outputColor=result;}`,yM=class extends Mr{constructor(r,{blendFunction:e=ut.NORMAL,focusDistance:t=0,focalLength:n=.1,bokehScale:i=1,width:s=nr.AUTO_SIZE,height:o=nr.AUTO_SIZE}={}){super("DepthOfFieldEffect",pF,{blendFunction:e,attributes:ir.DEPTH,uniforms:new Map([["nearColorBuffer",new Ae(null)],["farColorBuffer",new Ae(null)],["nearCoCBuffer",new Ae(null)],["scale",new Ae(1)]])});this.camera=r,this.renderTarget=new bt(1,1,{minFilter:$e,magFilter:$e,stencilBuffer:!1,depthBuffer:!1}),this.renderTarget.texture.name="DoF.Intermediate",this.renderTarget.texture.generateMipmaps=!1,this.renderTargetMasked=this.renderTarget.clone(),this.renderTargetMasked.texture.name="DoF.Masked.Far",this.renderTargetNear=this.renderTarget.clone(),this.renderTargetNear.texture.name="DoF.Bokeh.Near",this.uniforms.get("nearColorBuffer").value=this.renderTargetNear.texture,this.renderTargetFar=this.renderTarget.clone(),this.renderTargetFar.texture.name="DoF.Bokeh.Far",this.uniforms.get("farColorBuffer").value=this.renderTargetFar.texture,this.renderTargetCoC=this.renderTarget.clone(),this.renderTargetCoC.texture.format=Nt,this.renderTargetCoC.texture.name="DoF.CoC",this.renderTargetCoCBlurred=this.renderTargetCoC.clone(),this.renderTargetCoCBlurred.texture.name="DoF.CoC.Blurred",this.uniforms.get("nearCoCBuffer").value=this.renderTargetCoCBlurred.texture,this.cocPass=new Xr(new x3(r));let a=this.circleOfConfusionMaterial;a.uniforms.focusDistance.value=t,a.uniforms.focalLength.value=n,this.blurPass=new cM({width:s,height:o,kernelSize:kd.MEDIUM}),this.blurPass.resolution.resizable=this,this.maskPass=new Xr(new D3(this.renderTargetCoC.texture));let l=this.maskPass.getFullscreenMaterial();l.maskFunction=aM.MULTIPLY,l.colorChannel=iM.GREEN,this.bokehNearBasePass=new Xr(new Ud(!1,!0)),this.bokehNearFillPass=new Xr(new Ud(!0,!0)),this.bokehFarBasePass=new Xr(new Ud(!1,!1)),this.bokehFarFillPass=new Xr(new Ud(!0,!1)),this.bokehScale=i,this.target=null}get circleOfConfusionMaterial(){return this.cocPass.getFullscreenMaterial()}get resolution(){return this.blurPass.resolution}get bokehScale(){return this.uniforms.get("scale").value}set bokehScale(r){[this.bokehNearBasePass,this.bokehNearFillPass,this.bokehFarBasePass,this.bokehFarFillPass].map(t=>t.getFullscreenMaterial().uniforms.scale).forEach(t=>{t.value=r}),this.maskPass.getFullscreenMaterial().uniforms.strength.value=r,this.uniforms.get("scale").value=r}calculateFocusDistance(r){let e=this.camera,t=e.far-e.near,n=e.position.distanceTo(r);return Math.min(Math.max(n/t,0),1)}setDepthTexture(r,e=Kr){let t=this.circleOfConfusionMaterial;t.uniforms.depthBuffer.value=r,t.depthPacking=e}update(r,e,t){let n=this.renderTarget,i=this.renderTargetCoC,s=this.renderTargetCoCBlurred,o=this.renderTargetMasked,a=this.bokehFarBasePass,l=this.bokehFarFillPass,c=a.getFullscreenMaterial().uniforms,u=l.getFullscreenMaterial().uniforms,h=this.bokehNearBasePass,d=this.bokehNearFillPass,f=h.getFullscreenMaterial().uniforms,p=d.getFullscreenMaterial().uniforms;if(this.target!==null){let m=this.calculateFocusDistance(this.target);this.circleOfConfusionMaterial.uniforms.focusDistance.value=m}this.cocPass.render(r,null,i),this.blurPass.render(r,i,s),this.maskPass.render(r,e,o),c.cocBuffer.value=u.cocBuffer.value=i.texture,a.render(r,o,n),l.render(r,n,this.renderTargetFar),f.cocBuffer.value=p.cocBuffer.value=s.texture,h.render(r,e,n),d.render(r,n,this.renderTargetNear)}setSize(r,e){let t=this.resolution,n=[this.cocPass,this.blurPass,this.maskPass,this.bokehNearBasePass,this.bokehNearFillPass,this.bokehFarBasePass,this.bokehFarFillPass];n.push(this.renderTargetCoC,this.renderTargetMasked),n.forEach(a=>a.setSize(r,e));let i=t.width
|
||
|
|
#ifdef PREMULTIPLY
|
||
|
|
outputColor=vec4(min(inputColor.rgb*noise,vec3(1.0)),inputColor.a);
|
||
|
|
#else
|
||
|
|
outputColor=vec4(noise,inputColor.a);
|
||
|
|
#endif
|
||
|
|
}`,xM=class extends Mr{constructor({blendFunction:r=ut.SCREEN,premultiply:e=!1}={}){super("NoiseEffect",gF,{blendFunction:r});this.premultiply=e}get premultiply(){return this.defines.has("PREMULTIPLY")}set premultiply(r){this.premultiply!==r&&(r?this.defines.set("PREMULTIPLY","1"):this.defines.delete("PREMULTIPLY"),this.setChanged())}};var yF="uniform bool active;uniform vec2 d;void mainUv(inout vec2 uv){if(active){uv=vec2(d.x*(floor(uv.x/d.x)+0.5),d.y*(floor(uv.y/d.y)+0.5));}}",bM=class extends Mr{constructor(r=30){super("PixelationEffect",yF,{uniforms:new Map([["active",new Ae(!1)],["d",new Ae(new O)]])});this.resolution=new O,this.granularity=r}getGranularity(){return this.granularity}setGranularity(r){r=Math.floor(r),r%2>0&&(r+=1);let e=this.uniforms;e.get("active").value=r>0,e.get("d").value.set(r,r).divide(this.resolution),this.granularity=r}setSize(r,e){this.resolution.set(r,e),this.setGranularity(this.granularity)}};var G$=Math.PI*.5,U$=new M,k$=new M;var wM="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAAAQCAYAAACm53kpAAAAeElEQVRYR+2XSwqAMAxEJ168ePEqwRSKhIIiuHjJqiU0gWE+1CQdApcVAMUAuARaMGCX1MIL/Ow13++9lW2s3mW9MWvsnWc/2fvGygwPAN4E8QzAA4CXAB6AHjG4JTHYI1ey3pcx6FHnEfhLDOIBKAmUBK6/ANUDTlROXAHd9EC1AAAAAElFTkSuQmCC",SM="data:image/png;base64,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
|
||
|
|
#ifdef ESKIL
|
||
|
|
vec2 coord=(uv-center)*vec2(offset);color=mix(color,vec3(1.0-darkness),dot(coord,coord));
|
||
|
|
#else
|
||
|
|
float d=distance(uv,center);color*=smoothstep(0.8,offset*0.799,d*(darkness+offset));
|
||
|
|
#endif
|
||
|
|
outputColor=vec4(color,inputColor.a);}`,AM=class extends Mr{constructor(r={}){let e=Object.assign({blendFunction:ut.NORMAL,eskil:!1,offset:.5,darkness:.5},r);super("VignetteEffect",bF,{blendFunction:e.blendFunction,uniforms:new Map([["offset",new Ae(e.offset)],["darkness",new Ae(e.darkness)]])});this.eskil=e.eskil}get eskil(){return this.defines.has("ESKIL")}set eskil(r){this.eskil!==r&&(r?this.defines.set("ESKIL","1"):this.defines.delete("ESKIL"),this.setChanged())}},j$=[new Float32Array(3),new Float32Array(3)],W$=[new Float32Array(3),new Float32Array(3),new Float32Array(3),new Float32Array(3)],J$=[[new Float32Array([0,0,0]),new Float32Array([1,0,0]),new Float32Array([1,1,0]),new Float32Array([1,1,1])],[new Float32Array([0,0,0]),new Float32Array([1,0,0]),new Float32Array([1,0,1]),new Float32Array([1,1,1])],[new Float32Array([0,0,0]),new Float32Array([0,0,1]),new Float32Array([1,0,1]),new Float32Array([1,1,1])],[new Float32Array([0,0,0]),new Float32Array([0,1,0]),new Float32Array([1,1,0]),new Float32Array([1,1,1])],[new Float32Array([0,0,0]),new Float32Array([0,1,0]),new Float32Array([0,1,1]),new Float32Array([1,1,1])],[new Float32Array([0,0,0]),new Float32Array([0,0,1]),new Float32Array([0,1,1]),new Float32Array([1,1,1])]];var X$=[new Float32Array(2),new Float32Array(2)];var q$=new Float32Array([0,-.25,.25,-.125,.125,-.375,.375]),Y$=[new Float32Array([0,0]),new Float32Array([.25,-.25]),new Float32Array([-.25,.25]),new Float32Array([.125,-.125]),new Float32Array([-.125,.125])],K$=[new Uint8Array([0,0]),new Uint8Array([3,0]),new Uint8Array([0,3]),new Uint8Array([3,3]),new Uint8Array([1,0]),new Uint8Array([4,0]),new Uint8Array([1,3]),new Uint8Array([4,3]),new Uint8Array([0,1]),new Uint8Array([3,1]),new Uint8Array([0,4]),new Uint8Array([3,4]),new Uint8Array([1,1]),new Uint8Array([4,1]),new Uint8Array([1,4]),new Uint8Array([4,4])],Q$=[new Uint8Array([0,0]),new Uint8Array([1,0]),new Uint8Array([0,2]),new Uint8Array([1,2]),new Uint8Array([2,0]),new Uint8Array([3,0]),new Uint8Array([2,2]),new Uint8Array([3,2]),new Uint8Array([0,1]),new Uint8Array([1,1]),new Uint8Array([0,3]),new Uint8Array([1,3]),new Uint8Array([2,1]),new Uint8Array([3,1]),new Uint8Array([2,3]),new Uint8Array([3,3])];var Z$=new Map([[Hn(0,0,0,0),new Float32Array([0,0,0,0])],[Hn(0,0,0,1),new Float32Array([0,0,0,1])],[Hn(0,0,1,0),new Float32Array([0,0,1,0])],[Hn(0,0,1,1),new Float32Array([0,0,1,1])],[Hn(0,1,0,0),new Float32Array([0,1,0,0])],[Hn(0,1,0,1),new Float32Array([0,1,0,1])],[Hn(0,1,1,0),new Float32Array([0,1,1,0])],[Hn(0,1,1,1),new Float32Array([0,1,1,1])],[Hn(1,0,0,0),new Float32Array([1,0,0,0])],[Hn(1,0,0,1),new Float32Array([1,0,0,1])],[Hn(1,0,1,0),new Float32Array([1,0,1,0])],[Hn(1,0,1,1),new Float32Array([1,0,1,1])],[Hn(1,1,0,0),new Float32Array([1,1,0,0])],[Hn(1,1,0,1),new Float32Array([1,1,0,1])],[Hn(1,1,1,0),new Float32Array([1,1,1,0])],[Hn(1,1,1,1),new Float32Array([1,1,1,1])]]);function ag(r,e,t){return r+(e-r)*t}function Hn(r,e,t,n){let i=ag(r,e,1-.25),s=ag(t,n,1-.25);return ag(i,s,1-.125)}var _M=class extends fn{load(r=()=>{},e=null){arguments.length===4?(r=arguments[1],e=arguments[3]):(arguments.length===3||typeof arguments[0]!="function")&&(r=arguments[1],e=null);let t=this.manager,n=new yo;return new Promise((i,s)=>{let o=new Image,a=new Image;n.onError=l=>{t.itemError(l),e!==null?(e(`Failed to load ${l}`),i()):s(`Failed to load ${l}`)},n.onLoad=()=>{let l=[o,a];r(l),i(l)},o.addEventListener("error",l=>{n.itemError("smaa-search")}),a.addEventListener("error",l=>{n.itemError("smaa-area")}),o.addEventListener("load",()=>{t.itemEnd("smaa-search"),n.itemEnd("smaa-search")}),a.addEventListener("load",()=>{t.itemEnd("smaa-area"),n.itemEnd("smaa-area")}),t.itemStart("smaa-search"),t.itemStart("smaa-area"),n.itemStart("smaa-search"),n.itemStart("smaa-area"),o.src=wM,a.src=SM})}};var hn=class{constructor(e,t){this.enabled=!1;this.effect=new e(t),Object.defineProperty(this,"opacity",{enumerable:!0,set(n){this.effect.blendMode.opacity.value=n},get(){return this.effect.blendMode.opacity.value}}),Object.defineProperty(this,"blendFunction",{enumerable:!
|
||
|
|
`))}}();var NM={Int:it,Float:Te,Bool:mc,Vector2:In,Vector3:Un,Vector4:yc,Matrix3:zr,Matrix4:ug,FloatArray:Ba,Vector4Array:Ra,Normal:mn,Position:_n,Reflect:Qi,UV:bo,Attribute:lg,Const:rt,Struct:Ao,Varying:cg,SpecularMIPLevel:Wd,MaxMIPLevel:Tl,ColorSpace:Bt,Noise:Wa,TextureCubeUV:_o,TextureCube:vc,Operator:Yn,Math:Ye,Cond:rr,Fresnel:Ga,Rainbow:ka,Transmission:Va,Depth:qa,Blend:Xa,Raw:Qa,CubeTexture:xc,Texture:kn,CustomTexture:za,VertexDisplacement:Mo,CustomNormal:Ha,Gradient:ja,Matcap:Ya,Expression:yt,Color:ct,Phong:wc,Basic:bc,Lambert:Sc,Standard:Tc,Toon:Ac};var Jd=class{constructor(){this._nodes={};this._dataNodes={};this._textures={};this.uuid=Ee.generateUUID()}init(e,t){this._dataNodes=e,this._textures=t}clear(){this._nodes={},this._dataNodes={},this._textures={}}getNode(e){let t=this._nodes[e];return t||(t=this.createNode(e)),t}getNodeData(e){return this._dataNodes[e]}getTexture(e){let t=this._textures[e];return t||new bi}createNode(e){let t=this._dataNodes[e];if(!t)throw new Error("Failed to create Node from uuid: "+e+", its data does not seem to exist");let n=NM[t.nodeType];if(!n)throw new Error("Failed to create Node from uuid: "+e+" and nodeType: "+t.nodeType+", constructor for this not is not registered");let i=new n().fromJSON(t,this);return this._nodes[e]=i,i}};function CM(r){wF(r.geometries),SF(r.interactionStates),LM(r.object),MF(r.materials)}function wF(r){var e;if(r!==void 0){for(let t of r)if(((e=t.userData)==null?void 0:e.type)!==void 0){let n=t.userData.parameters;"extrudeDepth"in n||Object.assign(n,{extrudeDepth:0}),"extrudeBevelSize"in n||Object.assign(n,{extrudeBevelSize:0}),"extrudeBevelSegments"in n||Object.assign(n,{extrudeBevelSegments:1})}}}function SF(r){if(r!==void 0){for(let e of r)if(e.quaternion!==void 0){let t=new Tt().fromArray(e.quaternion);Object.assign(e,{rotation:new On().setFromQuaternion(t).toArray()})}}}function LM(r){var e,t,n,i;if(((e=r.userData)==null?void 0:e.type)===void 0)if(r.type==="OrthographicCamera"||r.type==="PerspectiveCamera"){let s=r;Object.assign(r,{objectType:"CombinedCamera",cameraType:s.type,isDefaultCamera:!0,hiddenMatrix:new me().toArray(),name:"Default Camera",far:1e5,zoomOrtho:s.zoom,zoomPersp:1,nearOrtho:-5e4,nearPersp:50}),delete r.type,s.typeCamera!==void 0&&(Object.assign(r,{cameraType:s.typeCamera}),delete r.typeCamera)}else r.type==="Scene"?(Object.assign(r,{objectType:r.type}),delete r.type):r.type==="HemisphereLight"?Object.assign(r,{isDefaultAmbientLight:!0}):r.type==="DirectionalLight"&&Object.assign(r,{isDefaultDirectionalLight:!0});if(r.userData!==void 0){let s=r.userData;s.type!==void 0&&(Object.assign(r,{objectType:s.type}),delete s.type),s.interaction!==void 0&&(Object.assign(r,{interaction:s.interaction}),delete s.interaction),s.isDefaultAmbientLight===!0?(Object.assign(r,{isDefaultAmbientLight:!0}),delete s.isDefaultAmbientLight):s.isDefaultDirectionalLight===!0?(Object.assign(r,{isDefaultDirectionalLight:!0}),delete s.isDefaultDirectionalLight):s.isDefaultCamera===!0&&(Object.assign(r,{isDefaultCamera:!0}),delete s.isDefaultCamera),Object.assign(r,{raycastLock:s.lock,scaleLock:s.scaleLock,hiddenMatrix:(n=(t=s.hiddenMatrix)==null?void 0:t.elements)!=null?n:new me().toArray()}),delete s.lock,delete s.scaleLock,delete s.hiddenMatrix,delete s.isEntity}if(((i=r.interaction)==null?void 0:i.events)!==void 0){for(let s of r.interaction.events)if(s.targets!==void 0)for(let o of s.targets)o.springControls!==void 0&&(Object.assign(o,{springParameters:{mass:o.springControls[0],stiffness:o.springControls[1],damping:o.springControls[2],velocity:o.springControls[3]}}),delete o.springControls)}if(r.children!==void 0)for(let s of r.children)LM(s)}function MF(r){if(r!==void 0)for(let e of r){let n=e.userData.layers.head;for(;n;){for(let i in n.uniforms){let s=`f${n.id}_tex`,o=`f${n.id}_texture`;i===s&&(n.uniforms[o]=n.uniforms[s],delete n.uniforms[s])}n=n.next}}}function IM(r){PM(r.object,r.object)}function PM(r,e){var t;if(r.type==="HemisphereLight"||r.isDefaultAmbientLight===!0?e.ambientLight=r.uuid:((t=r.userData)==null?void 0:t.isDefaultDirectionalLight)=
|
||
|
|
`);this.workerSourceURL=URL.createObjectURL(new Blob([o]))}),this.decoderPending}_getWorker(e,t){return this._initDecoder().then(()=>{if(this.workerPool.length<this.workerLimit){let i=new Worker(this.workerSourceURL);i._callbacks={},i._taskCosts={},i._taskLoad=0,i.postMessage({type:"init",decoderConfig:this.decoderConfig}),i.onmessage=function(s){let o=s.data;switch(o.type){case"decode":i._callbacks[o.id].resolve(o);break;case"error":i._callbacks[o.id].reject(o);break;default:console.error('THREE.DRACOLoader: Unexpected message, "'+o.type+'"')}},this.workerPool.push(i)}else this.workerPool.sort(function(i,s){return i._taskLoad>s._taskLoad?-1:1});let n=this.workerPool[this.workerPool.length-1];return n._taskCosts[e]=t,n._taskLoad+=t,n})}_releaseTask(e,t){e._taskLoad-=e._taskCosts[t],delete e._callbacks[t],delete e._taskCosts[t]}debug(){console.log("Task load: ",this.workerPool.map(e=>e._taskLoad))}dispose(){for(let e=0;e<this.workerPool.length;++e)this.workerPool[e].terminate();return this.workerPool.length=0,this}};function FF(){let r,e;onmessage=function(o){let a=o.data;switch(a.type){case"init":r=a.decoderConfig,e=new Promise(function(u){r.onModuleLoaded=function(h){u({draco:h})},DracoDecoderModule(r)});break;case"decode":let l=a.buffer,c=a.taskConfig;e.then(u=>{let h=u.draco,d=new h.Decoder,f=new h.DecoderBuffer;f.Init(new Int8Array(l),l.byteLength);try{let p=t(h,d,f,c),m=p.attributes.map(v=>v.array.buffer);p.index&&m.push(p.index.array.buffer),self.postMessage({type:"decode",id:a.id,geometry:p},m)}catch(p){console.error(p),self.postMessage({type:"error",id:a.id,error:p.message})}finally{h.destroy(f),h.destroy(d)}});break}};function t(o,a,l,c){let u=c.attributeIDs,h=c.attributeTypes,d,f,p=a.GetEncodedGeometryType(l);if(p===o.TRIANGULAR_MESH)d=new o.Mesh,f=a.DecodeBufferToMesh(l,d);else if(p===o.POINT_CLOUD)d=new o.PointCloud,f=a.DecodeBufferToPointCloud(l,d);else throw new Error("THREE.DRACOLoader: Unexpected geometry type.");if(!f.ok()||d.ptr===0)throw new Error("THREE.DRACOLoader: Decoding failed: "+f.error_msg());let m={index:null,attributes:[]};for(let v in u){let g=self[h[v]],y,x;if(c.useUniqueIDs)x=u[v],y=a.GetAttributeByUniqueId(d,x);else{if(x=a.GetAttributeId(d,o[u[v]]),x===-1)continue;y=a.GetAttribute(d,x)}m.attributes.push(i(o,a,d,v,g,y))}return p===o.TRIANGULAR_MESH&&(m.index=n(o,a,d)),o.destroy(d),m}function n(o,a,l){let u=l.num_faces()*3,h=u*4,d=o._malloc(h);a.GetTrianglesUInt32Array(l,h,d);let f=new Uint32Array(o.HEAPF32.buffer,d,u).slice();return o._free(d),{array:f,itemSize:1}}function i(o,a,l,c,u,h){let d=h.num_components(),p=l.num_points()*d,m=p*u.BYTES_PER_ELEMENT,v=s(o,u),g=o._malloc(m);a.GetAttributeDataArrayForAllPoints(l,h,v,m,g);let y=new u(o.HEAPF32.buffer,g,p).slice();return o._free(g),{name:c,array:y,itemSize:d}}function s(o,a){switch(a){case Float32Array:return o.DT_FLOAT32;case Int8Array:return o.DT_INT8;case Int16Array:return o.DT_INT16;case Int32Array:return o.DT_INT32;case Uint8Array:return o.DT_UINT8;case Uint16Array:return o.DT_UINT16;case Uint32Array:return o.DT_UINT32}}}function Cl(r){let e;return r instanceof Array?(e={},r.forEach(t=>{e[t.uuid]=t})):e=r,e}function rA(r,e){return r[e]===void 0&&console.warn("ObjectLoader > getGeometry: undefined geometry",e),r[e]}function sA(r,e){if(e!==void 0){if(e instanceof Array){let t=[];for(let n=0,i=e.length;n<i;n++){let s=e[n];r[s]===void 0&&console.warn("ObjectLoader > getMaterial: undefined material",s),t.push(r[s])}return t}return r[e]===void 0&&console.warn("ObjectLoader > getMaterial: undefined material",e),r[e]}}var wg=class extends gx(Ap){constructor(){super(...arguments);this.path="";this.resourcePath=""}async loadFromFile(e){var s;let t=await LS(e,this.manager,Ds.TEXT),{object:n,materials:i}=this.parse(JSON.parse(t));return n.name=(s=e.name.split(".").shift())!=null?s:e.name,this.manager.itemEnd(e.name),{scene:n,materials:i}}load(e,t,n,i){let s=this.path===""?Ei.extractUrlBase(e):this.path;this.resourcePath=this.resourcePath||s;let o=new Xn(this.manager);o.setPath(this.path),o.load(e,a=>{let l=null;try{l=JSON.parse(a)}catch(u){i!==
|