221 lines
8.3 KiB
JavaScript
221 lines
8.3 KiB
JavaScript
"use strict";
|
|
var __defProp = Object.defineProperty;
|
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __publicField = (obj, key, value) => {
|
|
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
return value;
|
|
};
|
|
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
|
|
const THREE = require("three");
|
|
const constants = require("../_polyfill/constants.cjs");
|
|
const Refractor = /* @__PURE__ */ (() => {
|
|
const _Refractor = class extends THREE.Mesh {
|
|
constructor(geometry, options = {}) {
|
|
super(geometry);
|
|
this.isRefractor = true;
|
|
this.type = "Refractor";
|
|
this.camera = new THREE.PerspectiveCamera();
|
|
const scope = this;
|
|
const color = options.color !== void 0 ? new THREE.Color(options.color) : new THREE.Color(8355711);
|
|
const textureWidth = options.textureWidth || 512;
|
|
const textureHeight = options.textureHeight || 512;
|
|
const clipBias = options.clipBias || 0;
|
|
const shader = options.shader || _Refractor.RefractorShader;
|
|
const multisample = options.multisample !== void 0 ? options.multisample : 4;
|
|
const virtualCamera = this.camera;
|
|
virtualCamera.matrixAutoUpdate = false;
|
|
virtualCamera.userData.refractor = true;
|
|
const refractorPlane = new THREE.Plane();
|
|
const textureMatrix = new THREE.Matrix4();
|
|
const renderTarget = new THREE.WebGLRenderTarget(textureWidth, textureHeight, {
|
|
samples: multisample,
|
|
type: THREE.HalfFloatType
|
|
});
|
|
this.material = new THREE.ShaderMaterial({
|
|
uniforms: THREE.UniformsUtils.clone(shader.uniforms),
|
|
vertexShader: shader.vertexShader,
|
|
fragmentShader: shader.fragmentShader,
|
|
transparent: true
|
|
// ensures, refractors are drawn from farthest to closest
|
|
});
|
|
this.material.uniforms["color"].value = color;
|
|
this.material.uniforms["tDiffuse"].value = renderTarget.texture;
|
|
this.material.uniforms["textureMatrix"].value = textureMatrix;
|
|
const visible = function() {
|
|
const refractorWorldPosition = new THREE.Vector3();
|
|
const cameraWorldPosition = new THREE.Vector3();
|
|
const rotationMatrix = new THREE.Matrix4();
|
|
const view = new THREE.Vector3();
|
|
const normal = new THREE.Vector3();
|
|
return function visible2(camera) {
|
|
refractorWorldPosition.setFromMatrixPosition(scope.matrixWorld);
|
|
cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);
|
|
view.subVectors(refractorWorldPosition, cameraWorldPosition);
|
|
rotationMatrix.extractRotation(scope.matrixWorld);
|
|
normal.set(0, 0, 1);
|
|
normal.applyMatrix4(rotationMatrix);
|
|
return view.dot(normal) < 0;
|
|
};
|
|
}();
|
|
const updateRefractorPlane = function() {
|
|
const normal = new THREE.Vector3();
|
|
const position = new THREE.Vector3();
|
|
const quaternion = new THREE.Quaternion();
|
|
const scale = new THREE.Vector3();
|
|
return function updateRefractorPlane2() {
|
|
scope.matrixWorld.decompose(position, quaternion, scale);
|
|
normal.set(0, 0, 1).applyQuaternion(quaternion).normalize();
|
|
normal.negate();
|
|
refractorPlane.setFromNormalAndCoplanarPoint(normal, position);
|
|
};
|
|
}();
|
|
const updateVirtualCamera = function() {
|
|
const clipPlane = new THREE.Plane();
|
|
const clipVector = new THREE.Vector4();
|
|
const q = new THREE.Vector4();
|
|
return function updateVirtualCamera2(camera) {
|
|
virtualCamera.matrixWorld.copy(camera.matrixWorld);
|
|
virtualCamera.matrixWorldInverse.copy(virtualCamera.matrixWorld).invert();
|
|
virtualCamera.projectionMatrix.copy(camera.projectionMatrix);
|
|
virtualCamera.far = camera.far;
|
|
clipPlane.copy(refractorPlane);
|
|
clipPlane.applyMatrix4(virtualCamera.matrixWorldInverse);
|
|
clipVector.set(clipPlane.normal.x, clipPlane.normal.y, clipPlane.normal.z, clipPlane.constant);
|
|
const projectionMatrix = virtualCamera.projectionMatrix;
|
|
q.x = (Math.sign(clipVector.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0];
|
|
q.y = (Math.sign(clipVector.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5];
|
|
q.z = -1;
|
|
q.w = (1 + projectionMatrix.elements[10]) / projectionMatrix.elements[14];
|
|
clipVector.multiplyScalar(2 / clipVector.dot(q));
|
|
projectionMatrix.elements[2] = clipVector.x;
|
|
projectionMatrix.elements[6] = clipVector.y;
|
|
projectionMatrix.elements[10] = clipVector.z + 1 - clipBias;
|
|
projectionMatrix.elements[14] = clipVector.w;
|
|
};
|
|
}();
|
|
function updateTextureMatrix(camera) {
|
|
textureMatrix.set(0.5, 0, 0, 0.5, 0, 0.5, 0, 0.5, 0, 0, 0.5, 0.5, 0, 0, 0, 1);
|
|
textureMatrix.multiply(camera.projectionMatrix);
|
|
textureMatrix.multiply(camera.matrixWorldInverse);
|
|
textureMatrix.multiply(scope.matrixWorld);
|
|
}
|
|
function render(renderer, scene, camera) {
|
|
scope.visible = false;
|
|
const currentRenderTarget = renderer.getRenderTarget();
|
|
const currentXrEnabled = renderer.xr.enabled;
|
|
const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
|
|
const currentToneMapping = renderer.toneMapping;
|
|
let isSRGB = false;
|
|
if ("outputColorSpace" in renderer)
|
|
isSRGB = renderer.outputColorSpace === "srgb";
|
|
else
|
|
isSRGB = renderer.outputEncoding === 3001;
|
|
renderer.xr.enabled = false;
|
|
renderer.shadowMap.autoUpdate = false;
|
|
if ("outputColorSpace" in renderer)
|
|
renderer.outputColorSpace = "srgb-linear";
|
|
else
|
|
renderer.outputEncoding = 3e3;
|
|
renderer.toneMapping = THREE.NoToneMapping;
|
|
renderer.setRenderTarget(renderTarget);
|
|
if (renderer.autoClear === false)
|
|
renderer.clear();
|
|
renderer.render(scene, virtualCamera);
|
|
renderer.xr.enabled = currentXrEnabled;
|
|
renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
|
|
renderer.toneMapping = currentToneMapping;
|
|
renderer.setRenderTarget(currentRenderTarget);
|
|
if ("outputColorSpace" in renderer)
|
|
renderer.outputColorSpace = isSRGB ? "srgb" : "srgb-linear";
|
|
else
|
|
renderer.outputEncoding = isSRGB ? 3001 : 3e3;
|
|
const viewport = camera.viewport;
|
|
if (viewport !== void 0) {
|
|
renderer.state.viewport(viewport);
|
|
}
|
|
scope.visible = true;
|
|
}
|
|
this.onBeforeRender = function(renderer, scene, camera) {
|
|
if (camera.userData.refractor === true)
|
|
return;
|
|
if (!visible(camera) === true)
|
|
return;
|
|
updateRefractorPlane();
|
|
updateTextureMatrix(camera);
|
|
updateVirtualCamera(camera);
|
|
render(renderer, scene, camera);
|
|
};
|
|
this.getRenderTarget = function() {
|
|
return renderTarget;
|
|
};
|
|
this.dispose = function() {
|
|
renderTarget.dispose();
|
|
scope.material.dispose();
|
|
};
|
|
}
|
|
};
|
|
let Refractor2 = _Refractor;
|
|
__publicField(Refractor2, "RefractorShader", {
|
|
uniforms: {
|
|
color: {
|
|
value: null
|
|
},
|
|
tDiffuse: {
|
|
value: null
|
|
},
|
|
textureMatrix: {
|
|
value: null
|
|
}
|
|
},
|
|
vertexShader: (
|
|
/* glsl */
|
|
`
|
|
|
|
uniform mat4 textureMatrix;
|
|
|
|
varying vec4 vUv;
|
|
|
|
void main() {
|
|
|
|
vUv = textureMatrix * vec4( position, 1.0 );
|
|
gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
|
|
|
|
}`
|
|
),
|
|
fragmentShader: (
|
|
/* glsl */
|
|
`
|
|
|
|
uniform vec3 color;
|
|
uniform sampler2D tDiffuse;
|
|
|
|
varying vec4 vUv;
|
|
|
|
float blendOverlay( float base, float blend ) {
|
|
|
|
return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );
|
|
|
|
}
|
|
|
|
vec3 blendOverlay( vec3 base, vec3 blend ) {
|
|
|
|
return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ), blendOverlay( base.b, blend.b ) );
|
|
|
|
}
|
|
|
|
void main() {
|
|
|
|
vec4 base = texture2DProj( tDiffuse, vUv );
|
|
gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );
|
|
|
|
#include <tonemapping_fragment>
|
|
#include <${constants.version >= 154 ? "colorspace_fragment" : "encodings_fragment"}>
|
|
|
|
}`
|
|
)
|
|
});
|
|
return Refractor2;
|
|
})();
|
|
exports.Refractor = Refractor;
|
|
//# sourceMappingURL=Refractor.cjs.map
|