Removing holoplay for now.

js/regl/lkgHelper.js

@@ -1,96 +0,0 @@
-// import HoloPlayCore from "holoplay-core";
-const HoloPlayCore = require("holoplay-core");
-
-const recordedDevice = {
-	buttons: [0, 0, 0, 0],
-	calibration: {
-		DPI: { value: 324 },
-		center: { value: 0.15018756687641144 },
-		configVersion: "3.0",
-		flipImageX: { value: 0 },
-		flipImageY: { value: 0 },
-		flipSubp: { value: 0 },
-		fringe: { value: 0 },
-		invView: { value: 1 },
-		pitch: { value: 52.58013153076172 },
-		screenH: { value: 2048 },
-		screenW: { value: 1536 },
-		slope: { value: -7.145165920257568 },
-		verticalAngle: { value: 0 },
-		viewCone: { value: 40 },
-	},
-	defaultQuilt: {
-		quiltAspect: 0.75,
-		quiltX: 3840,
-		quiltY: 3840,
-		tileX: 8,
-		tileY: 6,
-	},
-	hardwareVersion: "portrait",
-	hwid: "LKG-P11063",
-	index: 0,
-	joystickIndex: -1,
-	state: "ok",
-	unityIndex: 1,
-	windowCoords: [1440, 900],
-};
-
-const interpretDevice = (device) => {
-	if (device == null) {
-		return { enabled: false, tileX: 1, tileY: 1 };
-	}
-
-	const fov = 15;
-
-	const calibration = Object.fromEntries(
-		Object.entries(device.calibration)
-			.map(([key, value]) => [key, value.value])
-			.filter(([key, value]) => value != null),
-	);
-
-	const screenInches = calibration.screenW / calibration.DPI;
-	const pitch = calibration.pitch * screenInches * Math.cos(Math.atan(1.0 / calibration.slope));
-	const tilt =
-		(calibration.screenH / (calibration.screenW * calibration.slope)) *
-		-(calibration.flipImageX * 2 - 1);
-	const subp = 1 / (calibration.screenW * 3);
-
-	const defaultQuilt = device.defaultQuilt;
-
-	const quiltViewPortion = [
-		(Math.floor(defaultQuilt.quiltX / defaultQuilt.tileX) * defaultQuilt.tileX) /
-			defaultQuilt.quiltX,
-		(Math.floor(defaultQuilt.quiltY / defaultQuilt.tileY) * defaultQuilt.tileY) /
-			defaultQuilt.quiltY,
-	];
-
-	return {
-		...defaultQuilt,
-		...calibration,
-		pitch,
-		tilt,
-		subp,
-
-		quiltViewPortion,
-		fov,
-		enabled: true,
-	};
-};
-
-export default async (useHoloplay = false, useRecordedDevice = false) => {
-	if (!useHoloplay) {
-		return interpretDevice(null);
-	}
-	// const HoloPlayCore = await import("../../lib/holoplaycore.module.js");
-	const device = await new Promise(
-		(resolve, reject) =>
-			new HoloPlayCore.Client(
-				(data) => resolve(data.devices?.[0]),
-				(error) => resolve(null),
-			),
-	);
-	if (device == null && useRecordedDevice) {
-		return interpretDevice(recordedDevice);
-	}
-	return interpretDevice(device);
-};

js/regl/main.js

@@ -5,10 +5,8 @@ import makeBloomPass from "./bloomPass.js";
 import makePalettePass from "./palettePass.js";
 import makeStripePass from "./stripePass.js";
 import makeImagePass from "./imagePass.js";
-import makeQuiltPass from "./quiltPass.js";
 import makeMirrorPass from "./mirrorPass.js";
 import { setupCamera, cameraCanvas, cameraAspectRatio } from "../utils/camera.js";
-import getLKG from "./lkgHelper.js";
 
 const effects = {
 	none: null,

js/regl/quiltPass.js

@@ -1,9 +1,8 @@
-import { makePassFBO, makePass } from "./utils.js";
-import quiltPassFrag from "../../shaders/glsl/quiltPass.frag.glsl";
+import { loadText, makePassFBO, makePass } from "./utils.js";
 
 // Multiplies the rendered rain and bloom by a loaded in image
 
-export default ({ regl, config, lkg }, inputs) => {
+export default ({ regl, cache, config, lkg }, inputs) => {
 	if (!lkg.enabled) {
 		return makePass({
 			primary: inputs.primary,
@@ -12,6 +11,7 @@ export default ({ regl, config, lkg }, inputs) => {
 
 	const output = makePassFBO(regl, config.useHalfFloat);
 
+	const quiltPassFrag = loadText(cache, "shaders/glsl/quiltPass.frag.glsl");
 	const render = regl({
 		frag: regl.prop("frag"),
 		uniforms: {
@@ -24,11 +24,11 @@ export default ({ regl, config, lkg }, inputs) => {
 		{
 			primary: output,
 		},
-		null,
+		quiltPassFrag.loaded,
 		(w, h) => output.resize(w, h),
 		(shouldRender) => {
 			if (shouldRender) {
-				render({ frag: quiltPassFrag });
+				render({ frag: quiltPassFrag.text() });
 			}
 		},
 	);

js/regl/rainPass.js

@@ -161,6 +161,8 @@ export default ({ regl, cache, config, lkg }) => {
 	const glintMSDF = loadImage(cache, regl, config.glintMSDFURL);
 	const baseTexture = loadImage(cache, regl, config.baseTextureURL, true);
 	const glintTexture = loadImage(cache, regl, config.glintTextureURL, true);
+	const rainPassVert = loadText(cache, "shaders/glsl/rainPass.vert.glsl");
+	const rainPassFrag = loadText(cache, "shaders/glsl/rainPass.frag.glsl");
 	const output = makePassFBO(regl, config.useHalfFloat);
 	const renderUniforms = {
 		...commonUniforms,
@@ -242,17 +244,11 @@ export default ({ regl, cache, config, lkg }) => {
 		mat4.rotateY(transform, transform, (Math.PI * 1) / 4);
 		mat4.translate(transform, transform, vec3.fromValues(0, 0, -1));
 		mat4.scale(transform, transform, vec3.fromValues(1, 1, 2));
-	} else if (lkg.enabled) {
-		mat4.translate(transform, transform, vec3.fromValues(0, 0, -1.1));
-		mat4.scale(transform, transform, vec3.fromValues(1, 1, 1));
-		mat4.scale(transform, transform, vec3.fromValues(0.15, 0.15, 0.15));
 	} else {
 		mat4.translate(transform, transform, vec3.fromValues(0, 0, -1));
 	}
 	const camera = mat4.create();
 
-	const vantagePoints = [];
-
 	return makePass(
 		{
 			primary: output,
@@ -262,51 +258,21 @@ export default ({ regl, cache, config, lkg }) => {
 			output.resize(w, h);
 			const aspectRatio = w / h;
 
-			const [numTileColumns, numTileRows] = [lkg.tileX, lkg.tileY];
+			const [numTileColumns, numTileRows] = [1, 1];
 			const numVantagePoints = numTileRows * numTileColumns;
 			const tileWidth = Math.floor(w / numTileColumns);
 			const tileHeight = Math.floor(h / numTileRows);
-			vantagePoints.length = 0;
-			for (let row = 0; row < numTileRows; row++) {
-				for (let column = 0; column < numTileColumns; column++) {
-					const index = column + row * numTileColumns;
-					const camera = mat4.create();
 
-					if (volumetric && config.isometric) {
-						if (aspectRatio > 1) {
-							mat4.ortho(camera, -1.5 * aspectRatio, 1.5 * aspectRatio, -1.5, 1.5, -1000, 1000);
-						} else {
-							mat4.ortho(camera, -1.5, 1.5, -1.5 / aspectRatio, 1.5 / aspectRatio, -1000, 1000);
-						}
-					} else if (lkg.enabled) {
-						mat4.perspective(camera, (Math.PI / 180) * lkg.fov, lkg.quiltAspect, 0.0001, 1000);
-
-						const distanceToTarget = -1; // TODO: Get from somewhere else
-						let vantagePointAngle =
-							(Math.PI / 180) * lkg.viewCone * (index / (numVantagePoints - 1) - 0.5);
-						if (isNaN(vantagePointAngle)) {
-							vantagePointAngle = 0;
-						}
-						const xOffset = distanceToTarget * Math.tan(vantagePointAngle);
-
-						mat4.translate(camera, camera, vec3.fromValues(xOffset, 0, 0));
-
-						camera[8] =
-							-xOffset /
-							(distanceToTarget * Math.tan((Math.PI / 180) * 0.5 * lkg.fov) * lkg.quiltAspect); // Is this right??
-					} else {
-						mat4.perspective(camera, (Math.PI / 180) * 90, aspectRatio, 0.0001, 1000);
-					}
-
-					const viewport = {
-						x: column * tileWidth,
-						y: row * tileHeight,
-						width: tileWidth,
-						height: tileHeight,
-					};
-					vantagePoints.push({ camera, viewport });
+			if (volumetric && config.isometric) {
+				if (aspectRatio > 1) {
+					mat4.ortho(camera, -1.5 * aspectRatio, 1.5 * aspectRatio, -1.5, 1.5, -1000, 1000);
+				} else {
+					mat4.ortho(camera, -1.5, 1.5, -1.5 / aspectRatio, 1.5 / aspectRatio, -1000, 1000);
 				}
+			} else {
+				mat4.perspective(camera, (Math.PI / 180) * 90, aspectRatio, 0.0001, 1000);
 			}
+
 			[screenSize[0], screenSize[1]] = aspectRatio > 1 ? [1, aspectRatio] : [1 / aspectRatio, 1];
 		},
 		(shouldRender) => {
@@ -322,16 +288,14 @@ export default ({ regl, cache, config, lkg }) => {
 					framebuffer: output,
 				});
 
-				for (const vantagePoint of vantagePoints) {
-					render({
-						...vantagePoint,
-						transform,
-						screenSize,
-						vert: rainPassVert,
-						frag: rainPassFrag,
-						glyphTransform: [1, 0, 0, 1],
-					});
-				}
+				render({
+					transform,
+					camera,
+					screenSize,
+					vert: rainPassVert,
+					frag: rainPassFrag,
+					glyphTransform: [1, 0, 0, 1],
+				});
 			}
 		},
 	);

js/utils/config.js

@@ -142,7 +142,6 @@ const defaults = {
 	renderer: "regl", // The preferred web graphics API
 	suppressWarnings: false, // Whether to show warnings to visitors on load
 	isometric: false,
-	useHoloplay: false,
 	loops: false,
 	skipIntro: true,
 	testFix: null,
@@ -370,40 +369,6 @@ const versions = {
 		],
 	},
 
-	holoplay: {
-		font: "resurrections",
-		glintTexture: "metal",
-		glyphEdgeCrop: 0.1,
-		cursorColor: hsl(0.292, 1, 0.8),
-		cursorIntensity: 2,
-		isolateGlint: true,
-		glintColor: hsl(0.131, 1, 0.6),
-		glintIntensity: 3,
-		glintBrightness: -0.5,
-		glintContrast: 1.5,
-		baseBrightness: -0.4,
-		baseContrast: 1.5,
-		highPassThreshold: 0,
-		cycleSpeed: 0.03,
-		bloomStrength: 0.7,
-		fallSpeed: 0.3,
-		palette: [
-			{ color: hsl(0.37, 0.6, 0.0), at: 0.0 },
-			{ color: hsl(0.37, 0.6, 0.5), at: 1.0 },
-		],
-		cycleSpeed: 0.01,
-		raindropLength: 0.3,
-
-		renderer: "regl",
-		numColumns: 20,
-		ditherMagnitude: 0,
-		bloomStrength: 0,
-		volumetric: true,
-		forwardSpeed: 0,
-		density: 3,
-		useHoloplay: true,
-	},
-
 	["3d"]: {
 		volumetric: true,
 		fallSpeed: 0.5,