angular-three-soba 1.14.1 → 2.0.0-beta.10

package/esm2022/performances/points/position-point.mjs

@@ -0,0 +1,54 @@
+import { ElementRef } from '@angular/core';
+import * as THREE from 'three';
+const _inverseMatrix = /*@__PURE__*/ new THREE.Matrix4();
+const _ray = /*@__PURE__*/ new THREE.Ray();
+const _sphere = /*@__PURE__*/ new THREE.Sphere();
+const _position = /*@__PURE__*/ new THREE.Vector3();
+export class PositionPoint extends THREE.Group {
+    constructor() {
+        super();
+        this.size = 0;
+        this.color = new THREE.Color('white');
+        this.instance = new ElementRef(undefined);
+        this.instanceKey = new ElementRef(undefined);
+    }
+    // This will allow the virtual instance have bounds
+    get geometry() {
+        return this.instance.nativeElement?.geometry;
+    }
+    raycast(raycaster, intersects) {
+        const parent = this.instance.nativeElement;
+        if (!parent || !parent.geometry)
+            return;
+        const instanceId = parent.userData['instances'].indexOf(this.instanceKey);
+        // If the instance wasn't found or exceeds the parents draw range, bail out
+        if (instanceId === -1 || instanceId > parent.geometry.drawRange.count)
+            return;
+        const threshold = raycaster.params.Points?.threshold ?? 1;
+        _sphere.set(this.getWorldPosition(_position), threshold);
+        if (raycaster.ray.intersectsSphere(_sphere) === false)
+            return;
+        _inverseMatrix.copy(parent.matrixWorld).invert();
+        _ray.copy(raycaster.ray).applyMatrix4(_inverseMatrix);
+        const localThreshold = threshold / ((this.scale.x + this.scale.y + this.scale.z) / 3);
+        const localThresholdSq = localThreshold * localThreshold;
+        const rayPointDistanceSq = _ray.distanceSqToPoint(this.position);
+        if (rayPointDistanceSq < localThresholdSq) {
+            const intersectPoint = new THREE.Vector3();
+            _ray.closestPointToPoint(this.position, intersectPoint);
+            intersectPoint.applyMatrix4(this.matrixWorld);
+            const distance = raycaster.ray.origin.distanceTo(intersectPoint);
+            if (distance < raycaster.near || distance > raycaster.far)
+                return;
+            intersects.push({
+                distance: distance,
+                distanceToRay: Math.sqrt(rayPointDistanceSq),
+                point: intersectPoint,
+                index: instanceId,
+                face: null,
+                object: this,
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/performances/segments/segment-object.mjs

@@ -0,0 +1,9 @@
+import * as THREE from 'three';
+export class SegmentObject {
+    constructor() {
+        this.color = new THREE.Color('white');
+        this.start = new THREE.Vector3(0, 0, 0);
+        this.end = new THREE.Vector3(0, 0, 0);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VnbWVudC1vYmplY3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvcGVyZm9ybWFuY2VzL3NyYy9zZWdtZW50cy9zZWdtZW50LW9iamVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssS0FBSyxNQUFNLE9BQU8sQ0FBQztBQUUvQixNQUFNLE9BQU8sYUFBYTtJQUl6QjtRQUNDLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxLQUFLLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ3RDLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDeEMsSUFBSSxDQUFDLEdBQUcsR0FBRyxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztJQUN2QyxDQUFDO0NBQ0QiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBUSFJFRSBmcm9tICd0aHJlZSc7XG5cbmV4cG9ydCBjbGFzcyBTZWdtZW50T2JqZWN0IHtcblx0Y29sb3I6IFRIUkVFLkNvbG9yO1xuXHRzdGFydDogVEhSRUUuVmVjdG9yMztcblx0ZW5kOiBUSFJFRS5WZWN0b3IzO1xuXHRjb25zdHJ1Y3RvcigpIHtcblx0XHR0aGlzLmNvbG9yID0gbmV3IFRIUkVFLkNvbG9yKCd3aGl0ZScpO1xuXHRcdHRoaXMuc3RhcnQgPSBuZXcgVEhSRUUuVmVjdG9yMygwLCAwLCAwKTtcblx0XHR0aGlzLmVuZCA9IG5ldyBUSFJFRS5WZWN0b3IzKDAsIDAsIDApO1xuXHR9XG59XG4iXX0=

package/esm2022/performances/segments/segments.mjs

@@ -0,0 +1,182 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, Injector, Input, NgZone, computed, effect, forwardRef, inject, signal, untracked, } from '@angular/core';
+import { NgtArgs, createInjectionToken, extend, injectBeforeRender, injectNgtRef, is, signalStore, } from 'angular-three';
+import * as THREE from 'three';
+import { Line2, LineMaterial, LineSegmentsGeometry } from 'three-stdlib';
+import { SegmentObject } from './segment-object';
+import * as i0 from "@angular/core";
+const normPos = (pos) => pos instanceof THREE.Vector3
+    ? pos
+    : new THREE.Vector3(...(typeof pos === 'number' ? [pos, pos, pos] : pos));
+extend({ SegmentObject });
+export const [injectNgtsSegmentsApi, provideNgtsSegmentsApi] = createInjectionToken((segments) => segments.api, { isRoot: false, deps: [forwardRef(() => NgtsSegments)] });
+export class NgtsSegment {
+    constructor() {
+        this.inputs = signalStore({});
+        this.segmentRef = injectNgtRef();
+        this.segmentsApi = injectNgtsSegmentsApi();
+        this.injector = inject(Injector);
+        this.zone = inject(NgZone);
+        this.start = this.inputs.select('start');
+        this.end = this.inputs.select('end');
+        this.normalizedStart = computed(() => normPos(this.start()));
+        this.normalizedEnd = computed(() => normPos(this.end()));
+        this.color = this.inputs.select('color');
+    }
+    set _start(start) {
+        this.inputs.set({ start });
+    }
+    set _end(end) {
+        this.inputs.set({ end });
+    }
+    set _color(color) {
+        this.inputs.set({ color });
+    }
+    ngOnInit() {
+        effect((onCleanup) => {
+            const cleanup = this.zone.runOutsideAngular(() => {
+                const api = this.segmentsApi();
+                return api.subscribe(this.segmentRef);
+            });
+            onCleanup(cleanup);
+        }, { injector: this.injector });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSegment, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsSegment, isStandalone: true, selector: "ngts-segment", inputs: { segmentRef: "segmentRef", _start: ["start", "_start"], _end: ["end", "_end"], _color: ["color", "_color"] }, ngImport: i0, template: `
+		<ngt-segment-object [ref]="segmentRef" [color]="color()" [start]="normalizedStart()" [end]="normalizedEnd()" />
+	`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSegment, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-segment',
+                    standalone: true,
+                    template: `
+		<ngt-segment-object [ref]="segmentRef" [color]="color()" [start]="normalizedStart()" [end]="normalizedEnd()" />
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { segmentRef: [{
+                type: Input
+            }], _start: [{
+                type: Input,
+                args: [{ alias: 'start' }]
+            }], _end: [{
+                type: Input,
+                args: [{ alias: 'end' }]
+            }], _color: [{
+                type: Input,
+                args: [{ alias: 'color' }]
+            }] } });
+export class NgtsSegments {
+    set _limit(limit) {
+        this.inputs.set({ limit });
+    }
+    set _lineWidth(lineWidth) {
+        this.inputs.set({ lineWidth });
+    }
+    constructor() {
+        this.inputs = signalStore({ limit: 1000, lineWidth: 1 });
+        this.segmentsRef = injectNgtRef();
+        this.segments = signal([]);
+        this.limit = this.inputs.select('limit');
+        this.positions = computed(() => Array(this.limit() * 6).fill(0));
+        this.colors = computed(() => Array(this.limit() * 6).fill(0));
+        this.resolution = new THREE.Vector2(512, 512);
+        this.lineWidth = this.inputs.select('lineWidth');
+        this.line = new Line2();
+        this.material = new LineMaterial();
+        this.geometry = new LineSegmentsGeometry();
+        this.api = computed(() => ({
+            subscribe: (segmentRef) => {
+                untracked(() => {
+                    this.segments.update((s) => [...s, segmentRef]);
+                });
+                return () => {
+                    untracked(() => {
+                        this.segments.update((s) => s.filter((segment) => segment !== segmentRef));
+                    });
+                };
+            },
+        }));
+        this.beforeRender();
+    }
+    beforeRender() {
+        injectBeforeRender(() => {
+            const [segments, limit, positions, colors] = [
+                this.segments(),
+                this.limit(),
+                this.positions(),
+                this.colors(),
+            ];
+            for (let i = 0; i < limit; i++) {
+                const segmentRef = segments[i];
+                const segment = is.ref(segmentRef) ? segmentRef.nativeElement : segmentRef;
+                if (segment) {
+                    positions[i * 6 + 0] = segment.start.x;
+                    positions[i * 6 + 1] = segment.start.y;
+                    positions[i * 6 + 2] = segment.start.z;
+                    positions[i * 6 + 3] = segment.end.x;
+                    positions[i * 6 + 4] = segment.end.y;
+                    positions[i * 6 + 5] = segment.end.z;
+                    colors[i * 6 + 0] = segment.color.r;
+                    colors[i * 6 + 1] = segment.color.g;
+                    colors[i * 6 + 2] = segment.color.b;
+                    colors[i * 6 + 3] = segment.color.r;
+                    colors[i * 6 + 4] = segment.color.g;
+                    colors[i * 6 + 5] = segment.color.b;
+                }
+            }
+            this.geometry.setColors(colors);
+            this.geometry.setPositions(positions);
+            this.line.computeLineDistances();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSegments, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsSegments, isStandalone: true, selector: "ngts-segments", inputs: { segmentsRef: "segmentsRef", _limit: ["limit", "_limit"], _lineWidth: ["lineWidth", "_lineWidth"] }, providers: [provideNgtsSegmentsApi()], ngImport: i0, template: `
+		<ngt-primitive *args="[line]" [ref]="segmentsRef">
+			<ngt-primitive *args="[geometry]" attach="geometry" />
+			<ngt-primitive
+				*args="[material]"
+				attach="material"
+				ngtCompound
+				[vertexColors]="true"
+				[resolution]="resolution"
+				[linewidth]="lineWidth()"
+			/>
+			<ng-content />
+		</ngt-primitive>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsSegments, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-segments',
+                    standalone: true,
+                    template: `
+		<ngt-primitive *args="[line]" [ref]="segmentsRef">
+			<ngt-primitive *args="[geometry]" attach="geometry" />
+			<ngt-primitive
+				*args="[material]"
+				attach="material"
+				ngtCompound
+				[vertexColors]="true"
+				[resolution]="resolution"
+				[linewidth]="lineWidth()"
+			/>
+			<ng-content />
+		</ngt-primitive>
+	`,
+                    imports: [NgtArgs],
+                    providers: [provideNgtsSegmentsApi()],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { segmentsRef: [{
+                type: Input
+            }], _limit: [{
+                type: Input,
+                args: [{ alias: 'limit' }]
+            }], _lineWidth: [{
+                type: Input,
+                args: [{ alias: 'lineWidth' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"segments.js","sourceRoot":"","sources":["../../../../../../libs/soba/performances/src/segments/segments.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tComponent,\n\tInjector,\n\tInput,\n\tNgZone,\n\tOnInit,\n\tcomputed,\n\teffect,\n\tforwardRef,\n\tinject,\n\tsignal,\n\tuntracked,\n} from '@angular/core';\nimport {\n\tNgtArgs,\n\tNgtRef,\n\tcreateInjectionToken,\n\textend,\n\tinjectBeforeRender,\n\tinjectNgtRef,\n\tis,\n\tsignalStore,\n\ttype NgtColor,\n\ttype NgtVector3,\n} from 'angular-three';\nimport * as THREE from 'three';\nimport { Line2, LineMaterial, LineSegmentsGeometry } from 'three-stdlib';\nimport { SegmentObject } from './segment-object';\n\nexport type NgtsSegmentState = {\n\tstart?: NgtVector3;\n\tend?: NgtVector3;\n\tcolor?: NgtColor;\n};\n\nexport type NgtsSegmentsState = {\n\tlimit: number;\n\tlineWidth: number;\n};\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t'ngt-segment-object': SegmentObject;\n\t\t'ngts-segment': NgtsSegmentState;\n\t\t'ngts-segments': NgtsSegmentsState;\n\t}\n}\n\nconst normPos = (pos: NgtsSegmentState['start']): SegmentObject['start'] =>\n\tpos instanceof THREE.Vector3\n\t\t? pos\n\t\t: new THREE.Vector3(...((typeof pos === 'number' ? [pos, pos, pos] : pos) as [number, number, number]));\n\nextend({ SegmentObject });\n\nexport const [injectNgtsSegmentsApi, provideNgtsSegmentsApi] = createInjectionToken(\n\t(segments: NgtsSegments) => segments.api,\n\t{ isRoot: false, deps: [forwardRef(() => NgtsSegments)] },\n);\n\n@Component({\n\tselector: 'ngts-segment',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-segment-object [ref]=\"segmentRef\" [color]=\"color()\" [start]=\"normalizedStart()\" [end]=\"normalizedEnd()\" />\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsSegment implements OnInit {\n\tprivate inputs = signalStore<NgtsSegmentState>({});\n\n\t@Input() segmentRef = injectNgtRef<SegmentObject>();\n\n\t@Input({ alias: 'start' }) set _start(start: NgtVector3) {\n\t\tthis.inputs.set({ start });\n\t}\n\n\t@Input({ alias: 'end' }) set _end(end: NgtVector3) {\n\t\tthis.inputs.set({ end });\n\t}\n\n\t@Input({ alias: 'color' }) set _color(color: NgtColor) {\n\t\tthis.inputs.set({ color });\n\t}\n\n\tprivate segmentsApi = injectNgtsSegmentsApi();\n\tprivate injector = inject(Injector);\n\tprivate zone = inject(NgZone);\n\n\tprivate start = this.inputs.select('start');\n\tprivate end = this.inputs.select('end');\n\n\tnormalizedStart = computed(() => normPos(this.start()));\n\tnormalizedEnd = computed(() => normPos(this.end()));\n\tcolor = this.inputs.select('color');\n\n\tngOnInit() {\n\t\teffect(\n\t\t\t(onCleanup) => {\n\t\t\t\tconst cleanup = this.zone.runOutsideAngular(() => {\n\t\t\t\t\tconst api = this.segmentsApi();\n\t\t\t\t\treturn api.subscribe(this.segmentRef);\n\t\t\t\t});\n\t\t\t\tonCleanup(cleanup);\n\t\t\t},\n\t\t\t{ injector: this.injector },\n\t\t);\n\t}\n}\n\n@Component({\n\tselector: 'ngts-segments',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-primitive *args=\"[line]\" [ref]=\"segmentsRef\">\n\t\t\t<ngt-primitive *args=\"[geometry]\" attach=\"geometry\" />\n\t\t\t<ngt-primitive\n\t\t\t\t*args=\"[material]\"\n\t\t\t\tattach=\"material\"\n\t\t\t\tngtCompound\n\t\t\t\t[vertexColors]=\"true\"\n\t\t\t\t[resolution]=\"resolution\"\n\t\t\t\t[linewidth]=\"lineWidth()\"\n\t\t\t/>\n\t\t\t<ng-content />\n\t\t</ngt-primitive>\n\t`,\n\timports: [NgtArgs],\n\tproviders: [provideNgtsSegmentsApi()],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsSegments {\n\tprivate inputs = signalStore<NgtsSegmentsState>({ limit: 1000, lineWidth: 1 });\n\n\t@Input() segmentsRef = injectNgtRef<Line2>();\n\n\t@Input({ alias: 'limit' }) set _limit(limit: number) {\n\t\tthis.inputs.set({ limit });\n\t}\n\n\t@Input({ alias: 'lineWidth' }) set _lineWidth(lineWidth: number) {\n\t\tthis.inputs.set({ lineWidth });\n\t}\n\n\tprivate segments = signal<NgtRef<SegmentObject>[]>([]);\n\tprivate limit = this.inputs.select('limit');\n\n\tprivate positions = computed(() => Array(this.limit() * 6).fill(0));\n\tprivate colors = computed(() => Array(this.limit() * 6).fill(0));\n\n\tresolution = new THREE.Vector2(512, 512);\n\tlineWidth = this.inputs.select('lineWidth');\n\tline = new Line2();\n\tmaterial = new LineMaterial();\n\tgeometry = new LineSegmentsGeometry();\n\n\tapi = computed(() => ({\n\t\tsubscribe: (segmentRef: NgtRef<SegmentObject>) => {\n\t\t\tuntracked(() => {\n\t\t\t\tthis.segments.update((s) => [...s, segmentRef]);\n\t\t\t});\n\n\t\t\treturn () => {\n\t\t\t\tuntracked(() => {\n\t\t\t\t\tthis.segments.update((s) => s.filter((segment) => segment !== segmentRef));\n\t\t\t\t});\n\t\t\t};\n\t\t},\n\t}));\n\n\tconstructor() {\n\t\tthis.beforeRender();\n\t}\n\n\tprivate beforeRender() {\n\t\tinjectBeforeRender(() => {\n\t\t\tconst [segments, limit, positions, colors] = [\n\t\t\t\tthis.segments(),\n\t\t\t\tthis.limit(),\n\t\t\t\tthis.positions(),\n\t\t\t\tthis.colors(),\n\t\t\t];\n\t\t\tfor (let i = 0; i < limit; i++) {\n\t\t\t\tconst segmentRef = segments[i];\n\t\t\t\tconst segment = is.ref(segmentRef) ? segmentRef.nativeElement : segmentRef;\n\t\t\t\tif (segment) {\n\t\t\t\t\tpositions[i * 6 + 0] = segment.start.x;\n\t\t\t\t\tpositions[i * 6 + 1] = segment.start.y;\n\t\t\t\t\tpositions[i * 6 + 2] = segment.start.z;\n\n\t\t\t\t\tpositions[i * 6 + 3] = segment.end.x;\n\t\t\t\t\tpositions[i * 6 + 4] = segment.end.y;\n\t\t\t\t\tpositions[i * 6 + 5] = segment.end.z;\n\n\t\t\t\t\tcolors[i * 6 + 0] = segment.color.r;\n\t\t\t\t\tcolors[i * 6 + 1] = segment.color.g;\n\t\t\t\t\tcolors[i * 6 + 2] = segment.color.b;\n\n\t\t\t\t\tcolors[i * 6 + 3] = segment.color.r;\n\t\t\t\t\tcolors[i * 6 + 4] = segment.color.g;\n\t\t\t\t\tcolors[i * 6 + 5] = segment.color.b;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.geometry.setColors(colors);\n\t\t\tthis.geometry.setPositions(positions);\n\t\t\tthis.line.computeLineDistances();\n\t\t});\n\t}\n}\n"]}

package/esm2022/shaders/angular-three-soba-shaders.mjs

@@ -2,4 +2,4 @@
  * Generated bundle index. Do not edit.
  */
 export * from './index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1zb2JhLXNoYWRlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdGhyZWUtc29iYS9zaGFkZXJzL3NyYy9hbmd1bGFyLXRocmVlLXNvYmEtc2hhZGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1zb2JhLXNoYWRlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvc2hhZGVycy9zcmMvYW5ndWxhci10aHJlZS1zb2JhLXNoYWRlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/shaders/blur-pass/blur-pass.mjs

@@ -0,0 +1,61 @@
+import { BufferAttribute, BufferGeometry, HalfFloatType, LinearFilter, Mesh, PerspectiveCamera, Scene, Vector2, WebGLRenderTarget, } from 'three';
+import { ConvolutionMaterial } from '../convolution-material/convolution-material';
+export class BlurPass {
+    constructor({ gl, resolution, width = 500, height = 500, minDepthThreshold = 0, maxDepthThreshold = 1, depthScale = 0, depthToBlurRatioBias = 0.25, }) {
+        this.renderToScreen = false;
+        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.0 / width, 1.0 / height);
+        this.convolutionMaterial.setResolution(new Vector2(width, height));
+        this.scene = new Scene();
+        this.camera = new PerspectiveCamera();
+        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;
+        const vertices = new Float32Array([-1, -1, 0, 3, -1, 0, -1, 3, 0]);
+        const uvs = new Float32Array([0, 0, 2, 0, 0, 2]);
+        const geometry = new BufferGeometry();
+        geometry.setAttribute('position', new BufferAttribute(vertices, 3));
+        geometry.setAttribute('uv', new BufferAttribute(uvs, 2));
+        this.screen = new Mesh(geometry, this.convolutionMaterial);
+        this.screen.frustumCulled = false;
+        this.scene.add(this.screen);
+    }
+    render(renderer, inputBuffer, outputBuffer) {
+        const scene = this.scene;
+        const camera = this.camera;
+        const renderTargetA = this.renderTargetA;
+        const renderTargetB = this.renderTargetB;
+        let material = this.convolutionMaterial;
+        let uniforms = material.uniforms;
+        uniforms['depthBuffer'].value = inputBuffer.depthTexture;
+        const kernel = material.kernel;
+        let lastRT = inputBuffer;
+        let destRT;
+        let i, l;
+        // Apply the multi-pass blur.
+        for (i = 0, l = kernel.length - 1; i < l; ++i) {
+            // Alternate between targets.
+            destRT = (i & 1) === 0 ? renderTargetA : renderTargetB;
+            uniforms['kernel'].value = kernel[i];
+            uniforms['inputBuffer'].value = lastRT.texture;
+            renderer.setRenderTarget(destRT);
+            renderer.render(scene, camera);
+            lastRT = destRT;
+        }
+        uniforms['kernel'].value = kernel[i];
+        uniforms['inputBuffer'].value = lastRT.texture;
+        renderer.setRenderTarget(this.renderToScreen ? null : outputBuffer);
+        renderer.render(scene, camera);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blur-pass.js","sourceRoot":"","sources":["../../../../../../libs/soba/shaders/src/blur-pass/blur-pass.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tBufferAttribute,\n\tBufferGeometry,\n\tCamera,\n\tHalfFloatType,\n\tLinearFilter,\n\tMesh,\n\tPerspectiveCamera,\n\tScene,\n\tVector2,\n\tWebGLRenderTarget,\n\tWebGLRenderer,\n} from 'three';\n\nimport { ConvolutionMaterial } from '../convolution-material/convolution-material';\n\nexport interface BlurPassProps {\n\tgl: WebGLRenderer;\n\tresolution: number;\n\twidth?: number;\n\theight?: number;\n\tminDepthThreshold?: number;\n\tmaxDepthThreshold?: number;\n\tdepthScale?: number;\n\tdepthToBlurRatioBias?: number;\n}\n\nexport class BlurPass {\n\treadonly renderTargetA: WebGLRenderTarget;\n\treadonly renderTargetB: WebGLRenderTarget;\n\treadonly convolutionMaterial: ConvolutionMaterial;\n\treadonly scene: Scene;\n\treadonly camera: Camera;\n\treadonly screen: Mesh;\n\trenderToScreen: boolean = false;\n\n\tconstructor({\n\t\tgl,\n\t\tresolution,\n\t\twidth = 500,\n\t\theight = 500,\n\t\tminDepthThreshold = 0,\n\t\tmaxDepthThreshold = 1,\n\t\tdepthScale = 0,\n\t\tdepthToBlurRatioBias = 0.25,\n\t}: BlurPassProps) {\n\t\tthis.renderTargetA = new WebGLRenderTarget(resolution, resolution, {\n\t\t\tminFilter: LinearFilter,\n\t\t\tmagFilter: LinearFilter,\n\t\t\tstencilBuffer: false,\n\t\t\tdepthBuffer: false,\n\t\t\ttype: HalfFloatType,\n\t\t});\n\t\tthis.renderTargetB = this.renderTargetA.clone();\n\t\tthis.convolutionMaterial = new ConvolutionMaterial();\n\t\tthis.convolutionMaterial.setTexelSize(1.0 / width, 1.0 / height);\n\t\tthis.convolutionMaterial.setResolution(new Vector2(width, height));\n\t\tthis.scene = new Scene();\n\t\tthis.camera = new PerspectiveCamera();\n\t\tthis.convolutionMaterial.uniforms['minDepthThreshold'].value = minDepthThreshold;\n\t\tthis.convolutionMaterial.uniforms['maxDepthThreshold'].value = maxDepthThreshold;\n\t\tthis.convolutionMaterial.uniforms['depthScale'].value = depthScale;\n\t\tthis.convolutionMaterial.uniforms['depthToBlurRatioBias'].value = depthToBlurRatioBias;\n\t\tthis.convolutionMaterial.defines['USE_DEPTH'] = depthScale > 0;\n\t\tconst vertices = new Float32Array([-1, -1, 0, 3, -1, 0, -1, 3, 0]);\n\t\tconst uvs = new Float32Array([0, 0, 2, 0, 0, 2]);\n\t\tconst geometry = new BufferGeometry();\n\t\tgeometry.setAttribute('position', new BufferAttribute(vertices, 3));\n\t\tgeometry.setAttribute('uv', new BufferAttribute(uvs, 2));\n\t\tthis.screen = new Mesh(geometry, this.convolutionMaterial);\n\t\tthis.screen.frustumCulled = false;\n\t\tthis.scene.add(this.screen);\n\t}\n\n\trender(renderer: WebGLRenderer, inputBuffer: WebGLRenderTarget, outputBuffer: WebGLRenderTarget) {\n\t\tconst scene = this.scene;\n\t\tconst camera = this.camera;\n\t\tconst renderTargetA = this.renderTargetA;\n\t\tconst renderTargetB = this.renderTargetB;\n\t\tlet material = this.convolutionMaterial;\n\t\tlet uniforms = material.uniforms;\n\t\tuniforms['depthBuffer'].value = inputBuffer.depthTexture;\n\t\tconst kernel = material.kernel;\n\t\tlet lastRT = inputBuffer;\n\t\tlet destRT;\n\t\tlet i, l;\n\t\t// Apply the multi-pass blur.\n\t\tfor (i = 0, l = kernel.length - 1; i < l; ++i) {\n\t\t\t// Alternate between targets.\n\t\t\tdestRT = (i & 1) === 0 ? renderTargetA : renderTargetB;\n\t\t\tuniforms['kernel'].value = kernel[i];\n\t\t\tuniforms['inputBuffer'].value = lastRT.texture;\n\t\t\trenderer.setRenderTarget(destRT);\n\t\t\trenderer.render(scene, camera);\n\t\t\tlastRT = destRT;\n\t\t}\n\t\tuniforms['kernel'].value = kernel[i];\n\t\tuniforms['inputBuffer'].value = lastRT.texture;\n\t\trenderer.setRenderTarget(this.renderToScreen ? null : outputBuffer);\n\t\trenderer.render(scene, camera);\n\t}\n}\n"]}

package/esm2022/shaders/caustics/caustics-material.mjs

@@ -0,0 +1,130 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '../shader-material/shader-material';
+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,
+}, 
+/* glsl */ `
+  varying vec2 vUv;
+  void main() {
+      vUv = uv;
+      gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }`, 
+/* glsl */ `
+  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;
+    // Perspective division
+    viewSpacePosition /= viewSpacePosition.w;
+    vec4 worldSpacePosition = cameraMatrixWorld * viewSpacePosition;
+    return worldSpacePosition.xyz;
+  }
+  float sdPlane( vec3 p, vec3 n, float h ) {
+    // n must be normalized
+    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() {
+    // Each sample consists of random offset in the x and y direction
+    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(rand() - 0.5, rand() - 0.5);
+    vec2 offset2 = vec2(-0.5, 0.5);//vec2(rand() - 0.5, rand() - 0.5);
+    vec2 offset3 = vec2(0.5, 0.5);//vec2(rand() - 0.5, rand() - 0.5);
+    vec2 offset4 = vec2(0.5, -0.5);//vec2(rand() - 0.5, rand() - 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;
+    // Sanity check the depths
+    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);
+    // Calculate the area of the triangle in light spaces
+    gl_FragColor = vec4(vec3(max(caustic, 0.0)), 1.0);
+  }`);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"caustics-material.js","sourceRoot":"","sources":["../../../../../../libs/soba/shaders/src/caustics/caustics-material.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE,MAAM,CAAC,MAAM,gBAAgB,GAAG,cAAc,CAC7C;IACC,iBAAiB,EAAE,IAAI,KAAK,CAAC,OAAO,EAAE;IACtC,yBAAyB,EAAE,IAAI,KAAK,CAAC,OAAO,EAAE;IAC9C,aAAa,EAAE,IAAI;IACnB,YAAY,EAAE,IAAI;IAClB,QAAQ,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACpC,gBAAgB,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAC5C,kBAAkB,EAAE,CAAC;IACrB,IAAI,EAAE,GAAG;IACT,GAAG,EAAE,GAAG;IACR,WAAW,EAAE,IAAI,KAAK,CAAC,OAAO,EAAE;IAChC,WAAW,EAAE,CAAC,GAAG,EAAE;IACnB,GAAG,EAAE,GAAG;IACR,OAAO,EAAE,CAAC;IACV,UAAU,EAAE,IAAI;IAChB,IAAI,EAAE,EAAE;IACR,SAAS,EAAE,GAAG;CACd;AACD,UAAU,CAAC;;;;;IAKR;AACH,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsGR,CACH,CAAC","sourcesContent":["import * as THREE from 'three';\nimport { shaderMaterial } from '../shader-material/shader-material';\n\nexport const CausticsMaterial = shaderMaterial(\n\t{\n\t\tcameraMatrixWorld: new THREE.Matrix4(),\n\t\tcameraProjectionMatrixInv: new THREE.Matrix4(),\n\t\tnormalTexture: null,\n\t\tdepthTexture: null,\n\t\tlightDir: new THREE.Vector3(0, 1, 0),\n\t\tlightPlaneNormal: new THREE.Vector3(0, 1, 0),\n\t\tlightPlaneConstant: 0,\n\t\tnear: 0.1,\n\t\tfar: 100,\n\t\tmodelMatrix: new THREE.Matrix4(),\n\t\tworldRadius: 1 / 40,\n\t\tior: 1.1,\n\t\tbounces: 0,\n\t\tresolution: 1024,\n\t\tsize: 10,\n\t\tintensity: 0.5,\n\t},\n\t/* glsl */ `\n  varying vec2 vUv;\n  void main() {\n      vUv = uv;\n      gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n  }`,\n\t/* glsl */ `\n  uniform mat4 cameraMatrixWorld;\n  uniform mat4 cameraProjectionMatrixInv;\n  uniform vec3 lightDir;\n  uniform vec3 lightPlaneNormal;\n  uniform float lightPlaneConstant;\n  uniform float near;\n  uniform float far;\n  uniform float time;\n  uniform float worldRadius;\n  uniform float resolution;\n  uniform float size;\n  uniform float intensity;\n  uniform float ior;\n  precision highp isampler2D;\n  precision highp usampler2D;\n  uniform sampler2D normalTexture;\n  uniform sampler2D depthTexture;\n  uniform float bounces;\n  varying vec2 vUv;\n  vec3 WorldPosFromDepth(float depth, vec2 coord) {\n    float z = depth * 2.0 - 1.0;\n    vec4 clipSpacePosition = vec4(coord * 2.0 - 1.0, z, 1.0);\n    vec4 viewSpacePosition = cameraProjectionMatrixInv * clipSpacePosition;\n    // Perspective division\n    viewSpacePosition /= viewSpacePosition.w;\n    vec4 worldSpacePosition = cameraMatrixWorld * viewSpacePosition;\n    return worldSpacePosition.xyz;\n  }\n  float sdPlane( vec3 p, vec3 n, float h ) {\n    // n must be normalized\n    return dot(p,n) + h;\n  }\n  float planeIntersect( vec3 ro, vec3 rd, vec4 p ) {\n    return -(dot(ro,p.xyz)+p.w)/dot(rd,p.xyz);\n  }\n  vec3 totalInternalReflection(vec3 ro, vec3 rd, vec3 pos, vec3 normal, float ior, out vec3 rayOrigin, out vec3 rayDirection) {\n    rayOrigin = ro;\n    rayDirection = rd;\n    rayDirection = refract(rayDirection, normal, 1.0 / ior);\n    rayOrigin = pos + rayDirection * 0.1;\n    return rayDirection;\n  }\n  void main() {\n    // Each sample consists of random offset in the x and y direction\n    float caustic = 0.0;\n    float causticTexelSize = (1.0 / resolution) * size * 2.0;\n    float texelsNeeded = worldRadius / causticTexelSize;\n    float sampleRadius = texelsNeeded / resolution;\n    float sum = 0.0;\n    if (texture2D(depthTexture, vUv).x == 1.0) {\n      gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);\n      return;\n    }\n    vec2 offset1 = vec2(-0.5, -0.5);//vec2(rand() - 0.5, rand() - 0.5);\n    vec2 offset2 = vec2(-0.5, 0.5);//vec2(rand() - 0.5, rand() - 0.5);\n    vec2 offset3 = vec2(0.5, 0.5);//vec2(rand() - 0.5, rand() - 0.5);\n    vec2 offset4 = vec2(0.5, -0.5);//vec2(rand() - 0.5, rand() - 0.5);\n    vec2 uv1 = vUv + offset1 * sampleRadius;\n    vec2 uv2 = vUv + offset2 * sampleRadius;\n    vec2 uv3 = vUv + offset3 * sampleRadius;\n    vec2 uv4 = vUv + offset4 * sampleRadius;\n    vec3 normal1 = texture2D(normalTexture, uv1, -10.0).rgb * 2.0 - 1.0;\n    vec3 normal2 = texture2D(normalTexture, uv2, -10.0).rgb * 2.0 - 1.0;\n    vec3 normal3 = texture2D(normalTexture, uv3, -10.0).rgb * 2.0 - 1.0;\n    vec3 normal4 = texture2D(normalTexture, uv4, -10.0).rgb * 2.0 - 1.0;\n    float depth1 = texture2D(depthTexture, uv1, -10.0).x;\n    float depth2 = texture2D(depthTexture, uv2, -10.0).x;\n    float depth3 = texture2D(depthTexture, uv3, -10.0).x;\n    float depth4 = texture2D(depthTexture, uv4, -10.0).x;\n    // Sanity check the depths\n    if (depth1 == 1.0 || depth2 == 1.0 || depth3 == 1.0 || depth4 == 1.0) {\n      gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);\n      return;\n    }\n    vec3 pos1 = WorldPosFromDepth(depth1, uv1);\n    vec3 pos2 = WorldPosFromDepth(depth2, uv2);\n    vec3 pos3 = WorldPosFromDepth(depth3, uv3);\n    vec3 pos4 = WorldPosFromDepth(depth4, uv4);\n    vec3 originPos1 = WorldPosFromDepth(0.0, uv1);\n    vec3 originPos2 = WorldPosFromDepth(0.0, uv2);\n    vec3 originPos3 = WorldPosFromDepth(0.0, uv3);\n    vec3 originPos4 = WorldPosFromDepth(0.0, uv4);\n    vec3 endPos1, endPos2, endPos3, endPos4;\n    vec3 endDir1, endDir2, endDir3, endDir4;\n    totalInternalReflection(originPos1, lightDir, pos1, normal1, ior, endPos1, endDir1);\n    totalInternalReflection(originPos2, lightDir, pos2, normal2, ior, endPos2, endDir2);\n    totalInternalReflection(originPos3, lightDir, pos3, normal3, ior, endPos3, endDir3);\n    totalInternalReflection(originPos4, lightDir, pos4, normal4, ior, endPos4, endDir4);\n    float lightPosArea = length(cross(originPos2 - originPos1, originPos3 - originPos1)) + length(cross(originPos3 - originPos1, originPos4 - originPos1));\n    float t1 = planeIntersect(endPos1, endDir1, vec4(lightPlaneNormal, lightPlaneConstant));\n    float t2 = planeIntersect(endPos2, endDir2, vec4(lightPlaneNormal, lightPlaneConstant));\n    float t3 = planeIntersect(endPos3, endDir3, vec4(lightPlaneNormal, lightPlaneConstant));\n    float t4 = planeIntersect(endPos4, endDir4, vec4(lightPlaneNormal, lightPlaneConstant));\n    vec3 finalPos1 = endPos1 + endDir1 * t1;\n    vec3 finalPos2 = endPos2 + endDir2 * t2;\n    vec3 finalPos3 = endPos3 + endDir3 * t3;\n    vec3 finalPos4 = endPos4 + endDir4 * t4;\n    float finalArea = length(cross(finalPos2 - finalPos1, finalPos3 - finalPos1)) + length(cross(finalPos3 - finalPos1, finalPos4 - finalPos1));\n    caustic += intensity * (lightPosArea / finalArea);\n    // Calculate the area of the triangle in light spaces\n    gl_FragColor = vec4(vec3(max(caustic, 0.0)), 1.0);\n  }`,\n);\n"]}

package/esm2022/shaders/caustics/caustics-projection-material.mjs

@@ -0,0 +1,31 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '../shader-material/shader-material';
+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() {
+    // Apply caustics
+    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 <${parseInt(THREE.REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+   }`);
+//# sourceMappingURL=data:application/json;base64,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