@octanejs/drei 0.0.1

package/src/materials/BlurPass.ts

@@ -0,0 +1,94 @@
+import {
+	BufferAttribute,
+	BufferGeometry,
+	Camera,
+	HalfFloatType,
+	LinearFilter,
+	Mesh,
+	Scene,
+	Vector2,
+	WebGLRenderTarget,
+	type WebGLRenderer,
+} from 'three';
+import { ConvolutionMaterial } from './ConvolutionMaterial.js';
+
+export interface BlurPassProps {
+	gl: WebGLRenderer;
+	resolution: number;
+	width?: number;
+	height?: number;
+	minDepthThreshold?: number;
+	maxDepthThreshold?: number;
+	depthScale?: number;
+	depthToBlurRatioBias?: number;
+}
+
+export class BlurPass {
+	readonly renderTargetA: WebGLRenderTarget;
+	readonly renderTargetB: WebGLRenderTarget;
+	readonly convolutionMaterial: ConvolutionMaterial;
+	readonly scene: Scene;
+	readonly camera: Camera;
+	readonly screen: Mesh;
+	renderToScreen = false;
+	constructor({
+		resolution,
+		width = 500,
+		height = 500,
+		minDepthThreshold = 0,
+		maxDepthThreshold = 1,
+		depthScale = 0,
+		depthToBlurRatioBias = 0.25,
+	}: BlurPassProps) {
+		this.renderTargetA = new WebGLRenderTarget(resolution, resolution, {
+			minFilter: LinearFilter,
+			magFilter: LinearFilter,
+			stencilBuffer: false,
+			depthBuffer: false,
+			type: HalfFloatType,
+		});
+		this.renderTargetB = this.renderTargetA.clone();
+		this.convolutionMaterial = new ConvolutionMaterial();
+		this.convolutionMaterial.setTexelSize(1 / width, 1 / height);
+		this.convolutionMaterial.setResolution(new Vector2(width, height));
+		this.convolutionMaterial.uniforms.minDepthThreshold.value = minDepthThreshold;
+		this.convolutionMaterial.uniforms.maxDepthThreshold.value = maxDepthThreshold;
+		this.convolutionMaterial.uniforms.depthScale.value = depthScale;
+		this.convolutionMaterial.uniforms.depthToBlurRatioBias.value = depthToBlurRatioBias;
+		this.convolutionMaterial.defines.USE_DEPTH = depthScale > 0;
+		this.scene = new Scene();
+		this.camera = new Camera();
+		const geometry = new BufferGeometry();
+		geometry.setAttribute(
+			'position',
+			new BufferAttribute(new Float32Array([-1, -1, 0, 3, -1, 0, -1, 3, 0]), 3),
+		);
+		geometry.setAttribute('uv', new BufferAttribute(new Float32Array([0, 0, 2, 0, 0, 2]), 2));
+		this.screen = new Mesh(geometry, this.convolutionMaterial);
+		this.screen.frustumCulled = false;
+		this.scene.add(this.screen);
+	}
+	render(
+		renderer: WebGLRenderer,
+		inputBuffer: WebGLRenderTarget,
+		outputBuffer: WebGLRenderTarget,
+	): void {
+		const uniforms = this.convolutionMaterial.uniforms;
+		uniforms.depthBuffer.value = inputBuffer.depthTexture;
+		let last = inputBuffer;
+		let destination: WebGLRenderTarget;
+		let index = 0;
+		for (; index < this.convolutionMaterial.kernel.length - 1; index++) {
+			destination = (index & 1) === 0 ? this.renderTargetA : this.renderTargetB;
+			uniforms.kernel.value = this.convolutionMaterial.kernel[index];
+			uniforms.inputBuffer.value = last.texture;
+			renderer.setRenderTarget(destination);
+			renderer.render(this.scene, this.camera);
+			last = destination;
+		}
+		uniforms.kernel.value = this.convolutionMaterial.kernel[index];
+		uniforms.inputBuffer.value = last.texture;
+		renderer.setRenderTarget(this.renderToScreen ? null : outputBuffer);
+		renderer.render(this.scene, this.camera);
+	}
+}

package/src/materials/CausticsMaterials.ts

@@ -0,0 +1,197 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '../core/shaderMaterial.js';
+
+export type CausticsMaterialType = THREE.ShaderMaterial & {
+	cameraMatrixWorld?: THREE.Matrix4;
+	cameraProjectionMatrixInv?: THREE.Matrix4;
+	lightPlaneNormal?: THREE.Vector3;
+	lightPlaneConstant?: number;
+	normalTexture?: THREE.Texture | null;
+	depthTexture?: THREE.Texture | null;
+	lightDir?: THREE.Vector3;
+	near?: number;
+	far?: number;
+	modelMatrix?: THREE.Matrix4;
+	worldRadius?: number;
+	ior?: number;
+	bounces?: number;
+	resolution?: number;
+	size?: number;
+	intensity?: number;
+};
+
+export type CausticsProjectionMaterialType = THREE.ShaderMaterial & {
+	color?: THREE.Color;
+	causticsTexture?: THREE.Texture;
+	causticsTextureB?: THREE.Texture;
+	lightProjMatrix?: THREE.Matrix4;
+	lightViewMatrix?: THREE.Matrix4;
+};
+
+export type NormalMaterialType = THREE.MeshNormalMaterial & {
+	viewMatrix: { value: THREE.Matrix4 };
+};
+
+export function createNormalMaterial(side: THREE.Side = THREE.FrontSide) {
+	const viewMatrix = { value: new THREE.Matrix4() };
+	return Object.assign(new THREE.MeshNormalMaterial({ side }) as NormalMaterialType, {
+		viewMatrix,
+		onBeforeCompile: (shader: THREE.WebGLProgramParametersWithUniforms) => {
+			shader.uniforms.viewMatrix = viewMatrix;
+			shader.fragmentShader =
+				`vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
+				return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
+			}\n` +
+				shader.fragmentShader.replace(
+					'#include <normal_fragment_maps>',
+					`#include <normal_fragment_maps>
+				normal = inverseTransformDirection( normal, viewMatrix );\n`,
+				);
+		},
+	});
+}
+
+export const CausticsProjectionMaterial = shaderMaterial(
+	{
+		causticsTexture: null,
+		causticsTextureB: null,
+		color: new THREE.Color(),
+		lightProjMatrix: new THREE.Matrix4(),
+		lightViewMatrix: new THREE.Matrix4(),
+	},
+	`varying vec3 vWorldPosition;
+	void main() {
+		gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position, 1.);
+		vec4 worldPosition = modelMatrix * vec4(position, 1.);
+		vWorldPosition = worldPosition.xyz;
+	}`,
+	`varying vec3 vWorldPosition;
+	uniform vec3 color;
+	uniform sampler2D causticsTexture;
+	uniform sampler2D causticsTextureB;
+	uniform mat4 lightProjMatrix;
+	uniform mat4 lightViewMatrix;
+	void main() {
+		vec4 lightSpacePos = lightProjMatrix * lightViewMatrix * vec4(vWorldPosition, 1.0);
+		lightSpacePos.xyz /= lightSpacePos.w;
+		lightSpacePos.xyz = lightSpacePos.xyz * 0.5 + 0.5;
+		vec3 front = texture2D(causticsTexture, lightSpacePos.xy).rgb;
+		vec3 back = texture2D(causticsTextureB, lightSpacePos.xy).rgb;
+		gl_FragColor = vec4((front + back) * color, 1.0);
+		#include <tonemapping_fragment>
+		#include <colorspace_fragment>
+	}`,
+);
+
+export const CausticsMaterial = shaderMaterial(
+	{
+		cameraMatrixWorld: new THREE.Matrix4(),
+		cameraProjectionMatrixInv: new THREE.Matrix4(),
+		normalTexture: null,
+		depthTexture: null,
+		lightDir: new THREE.Vector3(0, 1, 0),
+		lightPlaneNormal: new THREE.Vector3(0, 1, 0),
+		lightPlaneConstant: 0,
+		near: 0.1,
+		far: 100,
+		modelMatrix: new THREE.Matrix4(),
+		worldRadius: 1 / 40,
+		ior: 1.1,
+		bounces: 0,
+		resolution: 1024,
+		size: 10,
+		intensity: 0.5,
+	},
+	`varying vec2 vUv;
+	void main() {
+		vUv = uv;
+		gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+	}`,
+	`uniform mat4 cameraMatrixWorld;
+	uniform mat4 cameraProjectionMatrixInv;
+	uniform vec3 lightDir;
+	uniform vec3 lightPlaneNormal;
+	uniform float lightPlaneConstant;
+	uniform float near;
+	uniform float far;
+	uniform float time;
+	uniform float worldRadius;
+	uniform float resolution;
+	uniform float size;
+	uniform float intensity;
+	uniform float ior;
+	precision highp isampler2D;
+	precision highp usampler2D;
+	uniform sampler2D normalTexture;
+	uniform sampler2D depthTexture;
+	uniform float bounces;
+	varying vec2 vUv;
+	vec3 WorldPosFromDepth(float depth, vec2 coord) {
+		float z = depth * 2.0 - 1.0;
+		vec4 clipSpacePosition = vec4(coord * 2.0 - 1.0, z, 1.0);
+		vec4 viewSpacePosition = cameraProjectionMatrixInv * clipSpacePosition;
+		viewSpacePosition /= viewSpacePosition.w;
+		vec4 worldSpacePosition = cameraMatrixWorld * viewSpacePosition;
+		return worldSpacePosition.xyz;
+	}
+	float sdPlane(vec3 p, vec3 n, float h) { return dot(p,n) + h; }
+	float planeIntersect(vec3 ro, vec3 rd, vec4 p) { return -(dot(ro,p.xyz)+p.w)/dot(rd,p.xyz); }
+	vec3 totalInternalReflection(vec3 ro, vec3 rd, vec3 pos, vec3 normal, float ior, out vec3 rayOrigin, out vec3 rayDirection) {
+		rayOrigin = ro;
+		rayDirection = rd;
+		rayDirection = refract(rayDirection, normal, 1.0 / ior);
+		rayOrigin = pos + rayDirection * 0.1;
+		return rayDirection;
+	}
+	void main() {
+		float caustic = 0.0;
+		float causticTexelSize = (1.0 / resolution) * size * 2.0;
+		float texelsNeeded = worldRadius / causticTexelSize;
+		float sampleRadius = texelsNeeded / resolution;
+		float sum = 0.0;
+		if (texture2D(depthTexture, vUv).x == 1.0) { gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0); return; }
+		vec2 offset1 = vec2(-0.5, -0.5);
+		vec2 offset2 = vec2(-0.5, 0.5);
+		vec2 offset3 = vec2(0.5, 0.5);
+		vec2 offset4 = vec2(0.5, -0.5);
+		vec2 uv1 = vUv + offset1 * sampleRadius;
+		vec2 uv2 = vUv + offset2 * sampleRadius;
+		vec2 uv3 = vUv + offset3 * sampleRadius;
+		vec2 uv4 = vUv + offset4 * sampleRadius;
+		vec3 normal1 = texture2D(normalTexture, uv1, -10.0).rgb * 2.0 - 1.0;
+		vec3 normal2 = texture2D(normalTexture, uv2, -10.0).rgb * 2.0 - 1.0;
+		vec3 normal3 = texture2D(normalTexture, uv3, -10.0).rgb * 2.0 - 1.0;
+		vec3 normal4 = texture2D(normalTexture, uv4, -10.0).rgb * 2.0 - 1.0;
+		float depth1 = texture2D(depthTexture, uv1, -10.0).x;
+		float depth2 = texture2D(depthTexture, uv2, -10.0).x;
+		float depth3 = texture2D(depthTexture, uv3, -10.0).x;
+		float depth4 = texture2D(depthTexture, uv4, -10.0).x;
+		if (depth1 == 1.0 || depth2 == 1.0 || depth3 == 1.0 || depth4 == 1.0) { gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0); return; }
+		vec3 pos1 = WorldPosFromDepth(depth1, uv1);
+		vec3 pos2 = WorldPosFromDepth(depth2, uv2);
+		vec3 pos3 = WorldPosFromDepth(depth3, uv3);
+		vec3 pos4 = WorldPosFromDepth(depth4, uv4);
+		vec3 originPos1 = WorldPosFromDepth(0.0, uv1);
+		vec3 originPos2 = WorldPosFromDepth(0.0, uv2);
+		vec3 originPos3 = WorldPosFromDepth(0.0, uv3);
+		vec3 originPos4 = WorldPosFromDepth(0.0, uv4);
+		vec3 endPos1, endPos2, endPos3, endPos4;
+		vec3 endDir1, endDir2, endDir3, endDir4;
+		totalInternalReflection(originPos1, lightDir, pos1, normal1, ior, endPos1, endDir1);
+		totalInternalReflection(originPos2, lightDir, pos2, normal2, ior, endPos2, endDir2);
+		totalInternalReflection(originPos3, lightDir, pos3, normal3, ior, endPos3, endDir3);
+		totalInternalReflection(originPos4, lightDir, pos4, normal4, ior, endPos4, endDir4);
+		float lightPosArea = length(cross(originPos2 - originPos1, originPos3 - originPos1)) + length(cross(originPos3 - originPos1, originPos4 - originPos1));
+		float t1 = planeIntersect(endPos1, endDir1, vec4(lightPlaneNormal, lightPlaneConstant));
+		float t2 = planeIntersect(endPos2, endDir2, vec4(lightPlaneNormal, lightPlaneConstant));
+		float t3 = planeIntersect(endPos3, endDir3, vec4(lightPlaneNormal, lightPlaneConstant));
+		float t4 = planeIntersect(endPos4, endDir4, vec4(lightPlaneNormal, lightPlaneConstant));
+		vec3 finalPos1 = endPos1 + endDir1 * t1;
+		vec3 finalPos2 = endPos2 + endDir2 * t2;
+		vec3 finalPos3 = endPos3 + endDir3 * t3;
+		vec3 finalPos4 = endPos4 + endDir4 * t4;
+		float finalArea = length(cross(finalPos2 - finalPos1, finalPos3 - finalPos1)) + length(cross(finalPos3 - finalPos1, finalPos4 - finalPos1));
+		caustic += intensity * (lightPosArea / finalArea);
+		gl_FragColor = vec4(vec3(max(caustic, 0.0)), 1.0);
+	}`,
+);

package/src/materials/ConvolutionMaterial.ts

@@ -0,0 +1,65 @@
+import * as THREE from 'three';
+
+export class ConvolutionMaterial extends THREE.ShaderMaterial {
+	readonly kernel: Float32Array;
+	constructor(texelSize = new THREE.Vector2()) {
+		super({
+			uniforms: {
+				inputBuffer: new THREE.Uniform(null),
+				depthBuffer: new THREE.Uniform(null),
+				resolution: new THREE.Uniform(new THREE.Vector2()),
+				texelSize: new THREE.Uniform(new THREE.Vector2()),
+				halfTexelSize: new THREE.Uniform(new THREE.Vector2()),
+				kernel: new THREE.Uniform(0),
+				scale: new THREE.Uniform(1),
+				cameraNear: new THREE.Uniform(0),
+				cameraFar: new THREE.Uniform(1),
+				minDepthThreshold: new THREE.Uniform(0),
+				maxDepthThreshold: new THREE.Uniform(1),
+				depthScale: new THREE.Uniform(0),
+				depthToBlurRatioBias: new THREE.Uniform(0.25),
+			},
+			fragmentShader: `#include <common>
+#include <dithering_pars_fragment>
+uniform sampler2D inputBuffer; uniform sampler2D depthBuffer; uniform float cameraNear; uniform float cameraFar;
+uniform float minDepthThreshold; uniform float maxDepthThreshold; uniform float depthScale; uniform float depthToBlurRatioBias;
+varying vec2 vUv; varying vec2 vUv0; varying vec2 vUv1; varying vec2 vUv2; varying vec2 vUv3;
+void main() {
+  float depthFactor = 0.0;
+  #ifdef USE_DEPTH
+    vec4 depth = texture2D(depthBuffer, vUv);
+    depthFactor = smoothstep(minDepthThreshold, maxDepthThreshold, 1.0-(depth.r * depth.a));
+    depthFactor *= depthScale; depthFactor = max(0.0, min(1.0, depthFactor + 0.25));
+  #endif
+  vec4 sum = texture2D(inputBuffer, mix(vUv0, vUv, depthFactor));
+  sum += texture2D(inputBuffer, mix(vUv1, vUv, depthFactor)); sum += texture2D(inputBuffer, mix(vUv2, vUv, depthFactor));
+  sum += texture2D(inputBuffer, mix(vUv3, vUv, depthFactor)); gl_FragColor = sum * 0.25;
+  #include <dithering_fragment>
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`,
+			vertexShader: `uniform vec2 texelSize; uniform vec2 halfTexelSize; uniform float kernel; uniform float scale;
+varying vec2 vUv; varying vec2 vUv0; varying vec2 vUv1; varying vec2 vUv2; varying vec2 vUv3;
+void main() {
+  vec2 uv = position.xy * 0.5 + 0.5; vUv = uv;
+  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);
+}`,
+			blending: THREE.NoBlending,
+			depthWrite: false,
+			depthTest: false,
+		});
+		this.toneMapped = false;
+		this.setTexelSize(texelSize.x, texelSize.y);
+		this.kernel = new Float32Array([0, 1, 2, 2, 3]);
+	}
+	setTexelSize(x: number, y: number): void {
+		this.uniforms.texelSize.value.set(x, y);
+		this.uniforms.halfTexelSize.value.set(x, y).multiplyScalar(0.5);
+	}
+	setResolution(resolution: THREE.Vector2): void {
+		this.uniforms.resolution.value.copy(resolution);
+	}
+}

package/src/materials/MeshReflectorMaterial.ts

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

package/src/materials/MeshRefractionMaterial.ts

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