"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 Reflector = /* @__PURE__ */ (() => { const _Reflector = class extends THREE.Mesh { constructor(geometry, options = {}) { super(geometry); this.isReflector = true; this.type = "Reflector"; 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 || _Reflector.ReflectorShader; const multisample = options.multisample !== void 0 ? options.multisample : 4; const reflectorPlane = new THREE.Plane(); const normal = new THREE.Vector3(); const reflectorWorldPosition = new THREE.Vector3(); const cameraWorldPosition = new THREE.Vector3(); const rotationMatrix = new THREE.Matrix4(); const lookAtPosition = new THREE.Vector3(0, 0, -1); const clipPlane = new THREE.Vector4(); const view = new THREE.Vector3(); const target = new THREE.Vector3(); const q = new THREE.Vector4(); const textureMatrix = new THREE.Matrix4(); const virtualCamera = this.camera; const renderTarget = new THREE.WebGLRenderTarget(textureWidth, textureHeight, { samples: multisample, type: THREE.HalfFloatType }); const material = new THREE.ShaderMaterial({ uniforms: THREE.UniformsUtils.clone(shader.uniforms), fragmentShader: shader.fragmentShader, vertexShader: shader.vertexShader }); material.uniforms["tDiffuse"].value = renderTarget.texture; material.uniforms["color"].value = color; material.uniforms["textureMatrix"].value = textureMatrix; this.material = material; this.onBeforeRender = function(renderer, scene, camera) { reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld); cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld); rotationMatrix.extractRotation(scope.matrixWorld); normal.set(0, 0, 1); normal.applyMatrix4(rotationMatrix); view.subVectors(reflectorWorldPosition, cameraWorldPosition); if (view.dot(normal) > 0) return; view.reflect(normal).negate(); view.add(reflectorWorldPosition); rotationMatrix.extractRotation(camera.matrixWorld); lookAtPosition.set(0, 0, -1); lookAtPosition.applyMatrix4(rotationMatrix); lookAtPosition.add(cameraWorldPosition); target.subVectors(reflectorWorldPosition, lookAtPosition); target.reflect(normal).negate(); target.add(reflectorWorldPosition); virtualCamera.position.copy(view); virtualCamera.up.set(0, 1, 0); virtualCamera.up.applyMatrix4(rotationMatrix); virtualCamera.up.reflect(normal); virtualCamera.lookAt(target); virtualCamera.far = camera.far; virtualCamera.updateMatrixWorld(); virtualCamera.projectionMatrix.copy(camera.projectionMatrix); 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(virtualCamera.projectionMatrix); textureMatrix.multiply(virtualCamera.matrixWorldInverse); textureMatrix.multiply(scope.matrixWorld); reflectorPlane.setFromNormalAndCoplanarPoint(normal, reflectorWorldPosition); reflectorPlane.applyMatrix4(virtualCamera.matrixWorldInverse); clipPlane.set( reflectorPlane.normal.x, reflectorPlane.normal.y, reflectorPlane.normal.z, reflectorPlane.constant ); const projectionMatrix = virtualCamera.projectionMatrix; q.x = (Math.sign(clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0]; q.y = (Math.sign(clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5]; q.z = -1; q.w = (1 + projectionMatrix.elements[10]) / projectionMatrix.elements[14]; clipPlane.multiplyScalar(2 / clipPlane.dot(q)); projectionMatrix.elements[2] = clipPlane.x; projectionMatrix.elements[6] = clipPlane.y; projectionMatrix.elements[10] = clipPlane.z + 1 - clipBias; projectionMatrix.elements[14] = clipPlane.w; 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); renderer.state.buffers.depth.setMask(true); if (renderer.autoClear === false) renderer.clear(); renderer.render(scene, virtualCamera); renderer.xr.enabled = currentXrEnabled; renderer.shadowMap.autoUpdate = currentShadowAutoUpdate; renderer.toneMapping = currentToneMapping; if ("outputColorSpace" in renderer) renderer.outputColorSpace = isSRGB ? "srgb" : "srgb-linear"; else renderer.outputEncoding = isSRGB ? 3001 : 3e3; renderer.setRenderTarget(currentRenderTarget); const viewport = camera.viewport; if (viewport !== void 0) { renderer.state.viewport(viewport); } scope.visible = true; }; this.getRenderTarget = function() { return renderTarget; }; this.dispose = function() { renderTarget.dispose(); scope.material.dispose(); }; } }; let Reflector2 = _Reflector; __publicField(Reflector2, "ReflectorShader", { uniforms: { color: { value: null }, tDiffuse: { value: null }, textureMatrix: { value: null } }, vertexShader: ( /* glsl */ ` uniform mat4 textureMatrix; varying vec4 vUv; #include #include void main() { vUv = textureMatrix * vec4( position, 1.0 ); gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 ); #include }` ), fragmentShader: ( /* glsl */ ` uniform vec3 color; uniform sampler2D tDiffuse; varying vec4 vUv; #include 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() { #include vec4 base = texture2DProj( tDiffuse, vUv ); gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 ); #include #include <${constants.version >= 154 ? "colorspace_fragment" : "encodings_fragment"}> }` ) }); return Reflector2; })(); exports.Reflector = Reflector; //# sourceMappingURL=Reflector.cjs.map