@@ -2148,72 +2149,74 @@
+
+
@@ -2326,6 +2329,21 @@ Debug
/>
+
+ 
+
quakeSceneMount.isPointInPlayerView(point, QUAKE_MONSTER_MOUNT_VIEW_DOT_MIN),
leafIndexAt: world.leafIndexAt,
monsterRuntimeEnabled: () => QUAKE_MONSTER_RUNTIME_ENABLED && !QUAKE_MULTIPLAYER_ENABLED && !quakeEnemiesDisabled,
+ onDestroyed: (entity) => {
+ if (entity.classname.startsWith("monster_")) quakeLevelStats.markMonsterKilled(entity.index);
+ },
pointToPoly: quakeCameraView.pointToPoly,
shouldSpawn: shouldSpawnQuakeShootableForCurrentMode,
pixelate: world.pixelate,
@@ -1862,6 +1878,7 @@ quakePointerGameplay = createQuakePointerGameplayFlow({
pointerLockElement: () => document.pointerLockElement,
queueCrosshairTargetSync: queueQuakeCrosshairTargetSync,
renderSupersample: QUAKE_RENDER_SUPERSAMPLE,
+ requestIntermissionAdvance: requestQuakeIntermissionAdvance,
respawnPlayerFromDeath: respawnQuakePlayerFromDeath,
rotation: () => ({
rotX: scene.camera.state.rotX ?? 88,
@@ -2052,7 +2069,10 @@ const quakeLoading = createQuakeLoadingFlow({
trace: markQuakeTrace,
});
const quakeSceneMount = createQuakeSceneMountFlow({
- afterMountScene: startQuakeMultiplayerScene,
+ afterMountScene: () => {
+ resetQuakeLevelStatsForCurrentScene();
+ startQuakeMultiplayerScene();
+ },
audio,
beforeDisposeScene: () => stopQuakeMultiplayerScene("scene-dispose"),
clearPlayerDeath: clearQuakePlayerDeath,
@@ -2115,9 +2135,14 @@ quakeEntityActivation = createQuakeEntityActivationFlow({
currentGameLogic: () => currentResult?.gameLogic,
entities: () => entityByIndex,
getOrigin: () => controls.getOrigin(),
+ intermission: {
+ show: () => quakeIntermission.show(quakeLevelStats.freeze()),
+ syncCamera: syncQuakeIntermissionCamera,
+ },
loadMap: loadQuakeMap,
mapExists: quakeAssetCatalog.mapExists,
movers,
+ onSecretActivated: (entity) => quakeLevelStats.markSecret(entity.index),
pickups: getPickups(),
player: getPlayer,
pointToPoly: quakeCameraView.pointToPoly,
@@ -2129,6 +2154,7 @@ quakeEntityActivation = createQuakeEntityActivationFlow({
targets: targetSystem,
text: {
centerPrint: (message) => quakeTextPresentation.centerPrint(message),
+ clearCenterPrint: () => quakeTextPresentation.clearCenterPrint(),
hasUseTargetsMessageText: (entity) => quakeTextPresentation.hasUseTargetsMessageText(entity),
setCenterPrint: (message) => quakeTextPresentation.setCenterPrint(message),
showDirectCenterPrintMessageText: (entity) => quakeTextPresentation.showDirectCenterPrintMessageText(entity),
@@ -2433,9 +2459,19 @@ function clearQuakeLevelLoadTimer(): void {
}
function clearQuakeLevelComplete(): void {
+ quakeIntermission.clear();
quakePlayerLifecycle.clearLevelComplete();
}
+function requestQuakeIntermissionAdvance(): boolean {
+ return quakeEntityActivation.requestIntermissionAdvance();
+}
+
+function requestQuakeIntermissionAdvanceFromKey(event: KeyboardEvent): boolean {
+ if (event.code !== "Space" || quakeGameplayInput.isEditableTarget(event.target)) return false;
+ return requestQuakeIntermissionAdvance();
+}
+
function isQuakeDeathUnlockControlsEndTraceSuppressed(now = performance.now()): boolean {
return quakePlayerLifecycle.isDeathUnlockControlsEndTraceSuppressed(now);
}
@@ -3903,6 +3939,64 @@ function completeQuakeLevel(entity: QuakeEntity): void {
quakeEntityActivation.completeLevel(entity);
}
+function resetQuakeLevelStatsForCurrentScene(): void {
+ quakeLevelStats.reset(currentMapName, quakeLevelStatsTotalsForEntities(currentResult?.entities ?? []));
+}
+
+function syncQuakeIntermissionCamera(): void {
+ const point = quakeIntermissionPointForCurrentScene();
+ if (!point) return;
+ const origin = quakeCameraView.pointToPoly(point.origin);
+ const { rotX, rotY } = quakeIntermissionCameraRotation(point);
+ quakeCameraView.syncSceneCameraAt(origin, rotX, rotY);
+ shootables.syncVisibility(origin as [number, number, number], true);
+ world.syncVisibilityAt(origin as [number, number, number], true);
+ syncQuakeCrosshairTarget();
+}
+
+function quakeIntermissionPointForCurrentScene(): QuakeEntityManifestPoint | null {
+ const manifestPoint = currentResult?.entityManifest.intermissions?.[0];
+ if (manifestPoint) return manifestPoint;
+ const entity = currentResult?.entities
+ .filter((candidate) => candidate.classname.startsWith("info_intermission") && candidate.origin)
+ .sort((a, b) => a.index - b.index)[0];
+ if (!entity?.origin) return null;
+ return {
+ entityIndex: entity.index,
+ classname: entity.classname,
+ origin: entity.origin,
+ spawnflags: 0,
+ ...(entity.angle !== undefined ? { angle: entity.angle } : {}),
+ ...quakeEntityMangleProperties(entity),
+ ...(entity.properties.targetname ? { targetname: entity.properties.targetname } : {}),
+ };
+}
+
+function quakeIntermissionCameraRotation(point: QuakeEntityManifestPoint): { rotX: number; rotY: number } {
+ if (point.mangle) {
+ return {
+ rotX: 90 - point.mangle.x,
+ rotY: (180 + point.mangle.y + 360) % 360,
+ };
+ }
+ return {
+ rotX: 90,
+ rotY: (180 + (point.angle ?? 0) + 360) % 360,
+ };
+}
+
+function quakeEntityMangleProperties(entity: QuakeEntity): { mangle?: QuakeVertex } {
+ const mangle = quakeParseEntityVector(entity.properties.mangle);
+ return mangle ? { mangle } : {};
+}
+
+function quakeParseEntityVector(value: string | undefined): QuakeVertex | null {
+ if (!value) return null;
+ const parts = value.trim().split(/\s+/).map((part) => Number.parseFloat(part));
+ if (parts.length < 3 || parts.some((part) => !Number.isFinite(part))) return null;
+ return { x: parts[0], y: parts[1], z: parts[2] };
+}
+
function activateSolidTouch(touch: QuakeTouchedTrigger): void {
const entity = entityByIndex.get(touch.entityIndex);
if (entity?.classname === "func_button" && requestQuakeMultiplayerTouchIntent(entity.index, "touch")) return;
@@ -4288,6 +4382,7 @@ const quakeInput = createQuakeAppInputController({
menuIsMainOpen: () => menu.isMainMenuOpen(),
menuIsPanelOpen: () => menu.isMenuPanelOpen(),
parentKeyRelay: quakeGameplayInput.parentKeyRelay,
+ requestIntermissionAdvance: requestQuakeIntermissionAdvanceFromKey,
shouldOpenMainMenuOnEscape: shouldOpenQuakeMainMenuOnControlsEnd,
shouldPreventGameplayKeyDefault: quakeGameplayInput.shouldPreventGameplayKeyDefault,
showMainMenu: () => menu.showMainMenu(),
diff --git a/src/assets/id-software-logo.svg b/src/assets/id-software-logo.svg
new file mode 100644
index 0000000..bdfd208
--- /dev/null
+++ b/src/assets/id-software-logo.svg
@@ -0,0 +1 @@
+
diff --git a/src/prepare/assets.mjs b/src/prepare/assets.mjs
index 9a0189c..6dc99bb 100644
--- a/src/prepare/assets.mjs
+++ b/src/prepare/assets.mjs
@@ -87,6 +87,9 @@ const mainMenuOutputPath = path.join(quakeOutputDir, "main-menu.png");
const mainMenuPlaqueOutputPath = path.join(quakeOutputDir, "main-menu-plaque.png");
const mainMenuTitleOutputPath = path.join(quakeOutputDir, "main-menu-title.png");
const mainMenuMultiplayerOutputPath = path.join(quakeOutputDir, "main-menu-multiplayer.png");
+const intermissionCompleteOutputPath = path.join(quakeOutputDir, "intermission-complete.png");
+const intermissionLabelsOutputPath = path.join(quakeOutputDir, "intermission-labels.png");
+const intermissionNumbersOutputPath = path.join(quakeOutputDir, "intermission-numbers.png");
const mainMenuActiveOutputPath = path.join(quakeOutputDir, "main-menu-active.png");
const mainMenuActiveOutputPaths = [
mainMenuActiveOutputPath,
@@ -231,7 +234,7 @@ const QUAKE_MAIN_MENU_LEVEL_LABEL = "LEVEL SELECT";
const QUAKE_MAIN_MENU_LEVEL_LABEL_SCALE = 2;
const QUAKE_PICKUP_MODEL_SCALE = QUAKE_UNIT_SCALE;
const QUAKE_WEAPON_MODEL_PIVOT = parseQuakeWeaponModelPivot(process.env.QUAKE_WEAPON_MODEL_PIVOT);
-const QUAKE_ENEMY_ALIAS_MODEL_RENDER_SCALE = 4;
+const QUAKE_ENEMY_ALIAS_MODEL_RENDER_SCALE = 8;
const QUAKE_PLAYER_ALIAS_MODEL_RENDER_SCALE = 4;
const QUAKE_ANIMATION_FRAME_SET_MIN_COMMON_LEAF_RATIO = 0.95;
const QUAKE_ALIAS_MERGE_MAX_NONPLANAR_DISTANCE = 0.03;
@@ -848,6 +851,9 @@ try {
await writeFile(mainMenuPlaqueOutputPath, await buildPakQpicCropPng(uiAssets, "gfx/qplaque.lmp", 0, 0, 32, 144));
await writeFile(mainMenuTitleOutputPath, await buildPakQpicCropPng(uiAssets, "gfx/ttl_main.lmp", 0, 0, 96, 24));
await writeFile(mainMenuMultiplayerOutputPath, await buildQuakeMainMenuMultiplayerPng(uiAssets));
+ await writeFile(intermissionCompleteOutputPath, await buildPakQpicPng(uiAssets, "gfx/complete.lmp"));
+ await writeFile(intermissionLabelsOutputPath, await buildPakQpicPng(uiAssets, "gfx/inter.lmp"));
+ await writeFile(intermissionNumbersOutputPath, await buildQuakeIntermissionNumbersPng(uiAssets));
});
const menuTitlePaletteColors = buildQuakeMenuTitlePaletteColors(uiAssets);
const mainMenuActivePngs = await buildQuakeMainMenuActivePngs(uiAssets);
@@ -940,6 +946,9 @@ try {
console.log(`Wrote ${path.relative(projectRoot, mainMenuPlaqueOutputPath)}`);
console.log(`Wrote ${path.relative(projectRoot, mainMenuTitleOutputPath)}`);
console.log(`Wrote ${path.relative(projectRoot, mainMenuMultiplayerOutputPath)}`);
+ console.log(`Wrote ${path.relative(projectRoot, intermissionCompleteOutputPath)}`);
+ console.log(`Wrote ${path.relative(projectRoot, intermissionLabelsOutputPath)}`);
+ console.log(`Wrote ${path.relative(projectRoot, intermissionNumbersOutputPath)}`);
for (const outputPath of mainMenuActiveOutputPaths) {
console.log(`Wrote ${path.relative(projectRoot, outputPath)}`);
}
@@ -2873,6 +2882,33 @@ async function buildQuakeHudNumbersPng(assets, options = {}) {
}).png().toBuffer();
}
+async function buildQuakeIntermissionNumbersPng(assets) {
+ const qpics = [
+ "num_0",
+ "num_1",
+ "num_2",
+ "num_3",
+ "num_4",
+ "num_5",
+ "num_6",
+ "num_7",
+ "num_8",
+ "num_9",
+ "num_colon",
+ "num_slash",
+ "num_minus",
+ ];
+ const width = 24 * qpics.length;
+ const height = 24;
+ const rgba = Buffer.alloc(width * height * 4);
+ for (let index = 0; index < qpics.length; index++) {
+ drawWadQpicTo(rgba, assets, qpics[index], index * 24, 0, width, height, QUAKE_HUD_TRANSPARENT);
+ }
+ return sharp(rgba, {
+ raw: { width, height, channels: 4 },
+ }).png().toBuffer();
+}
+
function tintQuakeHudDamageNumbers(rgba) {
for (let index = 0; index < rgba.length; index += 4) {
if (rgba[index + 3] === 0) continue;
diff --git a/src/prepare/deterministicAtlas.mjs b/src/prepare/deterministicAtlas.mjs
index 1aed1e5..3117ca1 100644
--- a/src/prepare/deterministicAtlas.mjs
+++ b/src/prepare/deterministicAtlas.mjs
@@ -32,6 +32,7 @@ const BSP_LUMP_COUNT = 15;
const BSP_HEADER_SIZE = 4 + BSP_LUMP_COUNT * 8;
const QUAKE_PLAYER_MINS_Z = -24;
const QUAKE_DETERMINISTIC_ATLAS_PAGE_PADDING = 1;
+const QUAKE_DETERMINISTIC_ATLAS_PVS_PACK_CAPACITY_RATIO = 0.955;
const QUAKE_DETERMINISTIC_ATLAS_PAGE_SIZE = normalizeDeterministicAtlasPageSize(
process.env.QUAKE_DETERMINISTIC_ATLAS_PAGE_SIZE,
);
@@ -321,7 +322,7 @@ export async function replaceQuakeRenderBundleWorldAtlas({
}
});
const pages = withDeterministicAtlasTimingSync(timing, "atlas.packPages", () =>
- packDeterministicAtlasTiles(atlasTiles));
+ packDeterministicAtlasTiles(atlasTiles, { visibility }));
const coverageFallbackLeaves = tiles.reduce((total, tile) => total + (tile.coverageFallback ? 1 : 0), 0);
const derivedUvAffineLeaves = tiles.reduce((total, tile) => total + (tile.derivedUvAffine ? 1 : 0), 0);
const mergedSourceLeaves = tiles.reduce((total, tile) => total + (tile.mergedSourceFaces > 1 ? 1 : 0), 0);
@@ -392,6 +393,14 @@ export async function replaceQuakeRenderBundleWorldAtlas({
await withDeterministicAtlasTiming(timing, "mesh.compactAssets", () =>
compactRenderBundleBackgroundAssets(renderBundle, outputDir, publicPath));
completeDeterministicRenderBundleAssetUrls(renderBundle, leafImageTiles, tiles);
+ const atlasResidency = await withDeterministicAtlasTiming(timing, "atlas.residency", () =>
+ buildDeterministicAtlasResidency(renderBundle, visibility, outputDir, publicPath));
+ if (atlasResidency) {
+ renderBundle.atlasResidency = atlasResidency;
+ renderBundle.meshHtml = stripRenderBundleBackgroundVars(renderBundle.meshHtml);
+ } else {
+ delete renderBundle.atlasResidency;
+ }
const oldBytes = await withDeterministicAtlasTiming(timing, "oldAssetScan", () =>
referencedAssetBytes(originalAssetUrls, outputDir, publicPath));
@@ -418,6 +427,7 @@ export async function replaceQuakeRenderBundleWorldAtlas({
skipSamples: serializeSkipSamples(skipSamples),
imagePolicyBuckets: Object.fromEntries([...imagePolicyBuckets.entries()].sort()),
oldAtlasBytesStillReferenced: oldBytes,
+ ...(atlasResidency ? { atlasResidencyPageCount: atlasResidency.pages.length } : {}),
};
logDeterministicAtlasTiming(timing, stats);
return stats;
@@ -446,6 +456,114 @@ function completeDeterministicRenderBundleAssetUrls(renderBundle, leafImageTiles
renderBundle.assetUrlsComplete = true;
}
+async function buildDeterministicAtlasResidency(renderBundle, visibility, outputDir, publicPath) {
+ if (!visibility?.metadata?.leaves?.length || !Array.isArray(visibility.candidates)) return null;
+ const leafPageIndexes = renderBundleLeafPageIndexes(renderBundle.meshHtml, renderBundle.leafMetadata.length);
+ const usedPageIndexes = [...new Set(leafPageIndexes.filter((index) => Number.isInteger(index) && index >= 0))]
+ .sort((a, b) => a - b);
+ if (!usedPageIndexes.length) return null;
+
+ const sourceFaceToPages = new Map();
+ for (let leafIndex = 0; leafIndex < leafPageIndexes.length; leafIndex++) {
+ const pageIndex = leafPageIndexes[leafIndex];
+ if (!Number.isInteger(pageIndex) || pageIndex < 0) continue;
+ const renderFaceIndex = renderBundle.leafMetadata[leafIndex]?.f;
+ if (!Number.isInteger(renderFaceIndex)) continue;
+ for (const sourceFaceIndex of visibility.candidates[renderFaceIndex]?.sourceFaceIndices ?? []) {
+ let pages = sourceFaceToPages.get(sourceFaceIndex);
+ if (!pages) {
+ pages = new Set();
+ sourceFaceToPages.set(sourceFaceIndex, pages);
+ }
+ pages.add(pageIndex);
+ }
+ }
+
+ const maxLeafIndex = visibility.metadata.leaves.reduce((max, leaf) => Math.max(max, leaf.leafIndex), 0);
+ const visibilityLeafPages = Array.from({ length: maxLeafIndex + 1 }, () => []);
+ const visibilityLeafPrewarmPages = Array.from({ length: maxLeafIndex + 1 }, () => []);
+ const pagesByLeaf = new Map();
+ for (const leaf of visibility.metadata.leaves) {
+ const pages = new Set();
+ for (const sourceFaceIndex of leaf.visibleFaceIndexes ?? []) {
+ for (const pageIndex of sourceFaceToPages.get(sourceFaceIndex) ?? []) pages.add(pageIndex);
+ }
+ const list = [...pages].sort((a, b) => a - b);
+ visibilityLeafPages[leaf.leafIndex] = list;
+ pagesByLeaf.set(leaf.leafIndex, list);
+ }
+ for (const leaf of visibility.metadata.leaves) {
+ const prewarm = new Set(pagesByLeaf.get(leaf.leafIndex) ?? []);
+ for (const adjacentLeafIndex of leaf.adjacentLeafIndexes ?? []) {
+ for (const pageIndex of pagesByLeaf.get(adjacentLeafIndex) ?? []) prewarm.add(pageIndex);
+ }
+ visibilityLeafPrewarmPages[leaf.leafIndex] = [...prewarm].sort((a, b) => a - b);
+ }
+
+ const pages = [];
+ for (const index of usedPageIndexes) {
+ const url = renderBundle.assetUrls[index];
+ if (!url) continue;
+ const outputPath = renderBundleAssetOutputPath(url, outputDir, publicPath);
+ let bytes;
+ let width;
+ let height;
+ if (outputPath) {
+ try {
+ const fileStat = await stat(outputPath);
+ bytes = fileStat.size;
+ const metadata = await sharp(outputPath).metadata();
+ width = metadata.width;
+ height = metadata.height;
+ } catch {
+ bytes = undefined;
+ }
+ }
+ pages.push({
+ index,
+ varName: `--bg${index}`,
+ url,
+ ...(Number.isFinite(bytes) ? { bytes } : {}),
+ ...(Number.isFinite(width) ? { width } : {}),
+ ...(Number.isFinite(height) ? { height } : {}),
+ });
+ }
+ if (!pages.length) return null;
+ return {
+ version: 1,
+ mode: "pvs-pages",
+ pageSize: QUAKE_DETERMINISTIC_ATLAS_PAGE_SIZE,
+ pages,
+ leafPageIndexes,
+ visibilityLeafPages,
+ visibilityLeafPrewarmPages,
+ };
+}
+
+function renderBundleLeafPageIndexes(html, expectedLeafCount) {
+ const leafPageIndexes = [];
+ for (const match of String(html ?? "").matchAll(/]*)>/g)) {
+ const attrs = attributes(match[1]);
+ const style = attrs.style ?? "";
+ const background = styleDeclarationValue(style, "background");
+ const pageMatch = background.match(/var\(--bg(\d+)\)/);
+ leafPageIndexes.push(pageMatch ? Number(pageMatch[1]) : -1);
+ }
+ while (leafPageIndexes.length < expectedLeafCount) leafPageIndexes.push(-1);
+ return leafPageIndexes.slice(0, expectedLeafCount);
+}
+
+function stripRenderBundleBackgroundVars(html) {
+ const root = String(html ?? "").match(/^]*)>/);
+ if (!root) return html;
+ const attrs = attributes(root[1]);
+ const style = attrs.style ?? "";
+ if (!style) return html;
+ const nextStyle = removeRenderBundleBackgroundVarDeclarations(style);
+ if (nextStyle) return html.replace(`style="${style}"`, `style="${nextStyle}"`);
+ return html.replace(/\sstyle="[^"]*"/, "");
+}
+
function collectDeterministicRenderBundleLiteralAssetUrls(urls, text) {
if (!text) return;
if (text.includes("url(")) {
@@ -548,7 +666,9 @@ async function deterministicLeafTile({ bspData, context, leaf, polygons, visibil
leaf,
plan,
polygon,
+ renderFaceIndex,
source,
+ sourceFaceIndices,
sourceSample,
sources,
});
@@ -774,6 +894,8 @@ async function deterministicLeafTile({ bspData, context, leaf, polygons, visibil
matrix: planMatrix,
rgba,
...(runtimeTextureImages ? { runtimeTextureImages } : {}),
+ renderFaceIndex,
+ sourceFaceIndices: [...sourceFaceIndices],
sourceTexture: source.texture.name,
transformCompensationX: leaf.transformCompensationX,
transformCompensationY: leaf.transformCompensationY,
@@ -788,7 +910,9 @@ async function deterministicPreparedTextureLeafTile({
leaf,
plan,
polygon,
+ renderFaceIndex,
source,
+ sourceFaceIndices,
sourceSample,
sources,
}) {
@@ -877,6 +1001,8 @@ async function deterministicPreparedTextureLeafTile({
mergedSourceFaces: sources.length,
matrix: planMatrix,
rgba,
+ renderFaceIndex,
+ sourceFaceIndices: [...sourceFaceIndices],
sourceTexture: source.texture.name,
transformCompensationX: leaf.transformCompensationX,
transformCompensationY: leaf.transformCompensationY,
@@ -2241,7 +2367,12 @@ function paletteBuffer(palette) {
return out;
}
-function packDeterministicAtlasTiles(tiles) {
+function packDeterministicAtlasTiles(tiles, options = {}) {
+ return packDeterministicAtlasTilesPvsAware(tiles, options.visibility) ??
+ packDeterministicAtlasTilesShelf(tiles);
+}
+
+function packDeterministicAtlasTilesShelf(tiles) {
const pages = [];
let page = null;
const newPage = () => {
@@ -2289,6 +2420,414 @@ function packDeterministicAtlasTiles(tiles) {
return pages.filter((item) => item.tiles.length);
}
+function packDeterministicAtlasTilesPvsAware(tiles, visibility) {
+ if (!tiles.length || !visibility?.metadata?.leaves?.length || !Array.isArray(visibility.candidates)) return null;
+ const context = deterministicAtlasPvsContext(tiles, visibility);
+ if (!context) return null;
+ const totalPackArea = tiles.reduce((total, tile) => total + deterministicAtlasTilePackArea(tile), 0);
+ const minPages = Math.max(
+ 1,
+ Math.ceil(totalPackArea / (QUAKE_DETERMINISTIC_ATLAS_PAGE_SIZE ** 2 * QUAKE_DETERMINISTIC_ATLAS_PVS_PACK_CAPACITY_RATIO)),
+ );
+ let best = null;
+ for (let pageCount = minPages; pageCount <= minPages + 5; pageCount++) {
+ for (const mode of ["spawn-bfs", "tilecount-desc", "area-desc"]) {
+ const seeded = seedDeterministicAtlasPvsAssignment(tiles, context, pageCount, mode);
+ if (!seeded) continue;
+ const assignment = optimizeDeterministicAtlasPvsAssignment(tiles, context, seeded, pageCount);
+ const packed = packDeterministicAtlasAssignedPages(tiles, assignment, pageCount);
+ if (!packed) continue;
+ const metrics = deterministicAtlasPvsAssignmentMetrics(context, assignment, pageCount);
+ const score = metrics.pageMean + metrics.oneHopMean * 0.08 + metrics.edgeNewMean * 0.15 + pageCount * 0.015;
+ if (!best || score < best.score) {
+ best = { assignment, mode, metrics, packed, pageCount, score };
+ }
+ }
+ if (best) break;
+ }
+ if (!best) return null;
+ for (let pageIndex = 0; pageIndex < best.packed.length; pageIndex++) {
+ const page = best.packed[pageIndex];
+ for (const tile of page.tiles) {
+ tile.page = page;
+ tile.pageIndex = pageIndex;
+ }
+ }
+ return best.packed;
+}
+
+function deterministicAtlasPvsContext(tiles, visibility) {
+ const usefulLeaves = [];
+ const rawLeafToUseful = new Map();
+ const pvsTiles = [];
+ const tileMembers = new Map(tiles.map((tile) => [tile, []]));
+ const sourceFaceToTiles = new Map();
+ for (const tile of tiles) {
+ const sourceFaceIndices = Array.isArray(tile.sourceFaceIndices) && tile.sourceFaceIndices.length
+ ? tile.sourceFaceIndices
+ : visibility.candidates?.[tile.renderFaceIndex]?.sourceFaceIndices ?? [];
+ for (const sourceFaceIndex of sourceFaceIndices) {
+ let bucket = sourceFaceToTiles.get(sourceFaceIndex);
+ if (!bucket) {
+ bucket = [];
+ sourceFaceToTiles.set(sourceFaceIndex, bucket);
+ }
+ bucket.push(tile);
+ }
+ }
+ for (const leaf of visibility.metadata.leaves) {
+ const set = new Set();
+ for (const sourceFaceIndex of leaf.visibleFaceIndexes ?? []) {
+ for (const tile of sourceFaceToTiles.get(sourceFaceIndex) ?? []) set.add(tile);
+ }
+ if (!set.size) continue;
+ const usefulIndex = usefulLeaves.length;
+ usefulLeaves.push(leaf);
+ rawLeafToUseful.set(leaf.leafIndex, usefulIndex);
+ const list = [...set];
+ pvsTiles.push(list);
+ for (const tile of list) tileMembers.get(tile)?.push(usefulIndex);
+ }
+ if (!usefulLeaves.length) return null;
+ const pvsArea = pvsTiles.map((list) => list.reduce((total, tile) => total + deterministicAtlasTilePackArea(tile), 0));
+ return { pvsArea, pvsTiles, rawLeafToUseful, tileMembers, usefulLeaves };
+}
+
+function seedDeterministicAtlasPvsAssignment(tiles, context, pageCount, mode) {
+ const capacity = deterministicAtlasPvsPageCapacity();
+ const assignment = new Map();
+ const loads = Array(pageCount).fill(0);
+ const pageLeafCounts = Array.from(
+ { length: context.usefulLeaves.length },
+ () => Array(pageCount).fill(0),
+ );
+ const order = Array.from({ length: context.usefulLeaves.length }, (_item, index) => index);
+ if (mode === "area-desc") {
+ order.sort((a, b) => context.pvsArea[b] - context.pvsArea[a]);
+ } else if (mode === "tilecount-desc") {
+ order.sort((a, b) => context.pvsTiles[b].length - context.pvsTiles[a].length);
+ } else if (mode === "spawn-bfs") {
+ const out = [];
+ const seen = new Set([0]);
+ const queue = [0];
+ while (queue.length) {
+ const usefulIndex = queue.shift();
+ out.push(usefulIndex);
+ const adjacent = (context.usefulLeaves[usefulIndex]?.adjacentLeafIndexes ?? [])
+ .map((leafIndex) => context.rawLeafToUseful.get(leafIndex))
+ .filter((item) => item !== undefined && !seen.has(item))
+ .sort((a, b) => context.pvsArea[b] - context.pvsArea[a]);
+ for (const next of adjacent) {
+ seen.add(next);
+ queue.push(next);
+ }
+ }
+ for (const usefulIndex of order) {
+ if (!seen.has(usefulIndex)) out.push(usefulIndex);
+ }
+ order.splice(0, order.length, ...out);
+ }
+
+ for (const usefulIndex of order) {
+ const list = [...context.pvsTiles[usefulIndex]]
+ .sort((a, b) => deterministicAtlasTilePackArea(b) - deterministicAtlasTilePackArea(a));
+ const assignedCounts = Array(pageCount).fill(0);
+ for (const tile of list) {
+ const pageIndex = assignment.get(tile);
+ if (pageIndex !== undefined) assignedCounts[pageIndex]++;
+ }
+ for (const tile of list) {
+ if (assignment.has(tile)) continue;
+ const tileArea = deterministicAtlasTilePackArea(tile);
+ let bestPage = -1;
+ let bestScore = -Infinity;
+ for (let pageIndex = 0; pageIndex < pageCount; pageIndex++) {
+ if (loads[pageIndex] + tileArea > capacity) continue;
+ let score = assignedCounts[pageIndex] * 1000 - loads[pageIndex] / capacity;
+ for (const member of context.tileMembers.get(tile) ?? []) {
+ if (pageLeafCounts[member][pageIndex] > 0) score += 2;
+ }
+ if (score > bestScore) {
+ bestScore = score;
+ bestPage = pageIndex;
+ }
+ }
+ if (bestPage < 0) return null;
+ assignment.set(tile, bestPage);
+ loads[bestPage] += tileArea;
+ assignedCounts[bestPage]++;
+ for (const member of context.tileMembers.get(tile) ?? []) pageLeafCounts[member][bestPage]++;
+ }
+ }
+ for (const tile of tiles) {
+ if (assignment.has(tile)) continue;
+ const tileArea = deterministicAtlasTilePackArea(tile);
+ let bestPage = -1;
+ let bestLoad = Infinity;
+ for (let pageIndex = 0; pageIndex < pageCount; pageIndex++) {
+ if (loads[pageIndex] + tileArea > capacity) continue;
+ if (loads[pageIndex] < bestLoad) {
+ bestLoad = loads[pageIndex];
+ bestPage = pageIndex;
+ }
+ }
+ if (bestPage < 0) return null;
+ assignment.set(tile, bestPage);
+ loads[bestPage] += tileArea;
+ }
+ return assignment;
+}
+
+function optimizeDeterministicAtlasPvsAssignment(tiles, context, assignment, pageCount) {
+ const capacity = deterministicAtlasPvsPageCapacity();
+ const loads = Array(pageCount).fill(0);
+ for (const tile of tiles) loads[assignment.get(tile)] += deterministicAtlasTilePackArea(tile);
+ const counts = deterministicAtlasPvsPageCounts(context, assignment, pageCount);
+ const order = [...tiles].sort((a, b) => deterministicAtlasTilePackArea(b) - deterministicAtlasTilePackArea(a));
+ for (let pass = 0; pass < 10; pass++) {
+ let moved = 0;
+ for (const tile of order) {
+ const from = assignment.get(tile);
+ const tileArea = deterministicAtlasTilePackArea(tile);
+ let bestPage = from;
+ let bestDelta = 0;
+ let bestBalance = 0;
+ for (let to = 0; to < pageCount; to++) {
+ if (to === from) continue;
+ if (loads[to] + tileArea > capacity) continue;
+ let delta = 0;
+ for (const member of context.tileMembers.get(tile) ?? []) {
+ if (counts[member][from] === 1) delta--;
+ if (counts[member][to] === 0) delta++;
+ }
+ const balance =
+ Math.abs((loads[from] - tileArea) - (loads[to] + tileArea)) -
+ Math.abs(loads[from] - loads[to]);
+ if (
+ delta < bestDelta ||
+ (delta === bestDelta && delta <= 0 && balance < bestBalance - 50000)
+ ) {
+ bestDelta = delta;
+ bestPage = to;
+ bestBalance = balance;
+ }
+ }
+ if (bestPage === from) continue;
+ assignment.set(tile, bestPage);
+ loads[from] -= tileArea;
+ loads[bestPage] += tileArea;
+ for (const member of context.tileMembers.get(tile) ?? []) {
+ counts[member][from]--;
+ counts[member][bestPage]++;
+ }
+ moved++;
+ }
+ if (!moved) break;
+ }
+ return assignment;
+}
+
+function deterministicAtlasPvsPageCounts(context, assignment, pageCount) {
+ const counts = Array.from(
+ { length: context.usefulLeaves.length },
+ () => Array(pageCount).fill(0),
+ );
+ for (const [tile, pageIndex] of assignment) {
+ for (const member of context.tileMembers.get(tile) ?? []) counts[member][pageIndex]++;
+ }
+ return counts;
+}
+
+function deterministicAtlasPvsAssignmentMetrics(context, assignment, pageCount) {
+ const counts = deterministicAtlasPvsPageCounts(context, assignment, pageCount);
+ const pageSets = counts.map((leafCounts) => leafCounts.flatMap((count, index) => count > 0 ? [index] : []));
+ const pageCounts = pageSets.map((set) => set.length);
+ const edgeNew = [];
+ const oneHopCounts = [];
+ const seenEdges = new Set();
+ for (let usefulIndex = 0; usefulIndex < context.usefulLeaves.length; usefulIndex++) {
+ const oneHop = new Set(pageSets[usefulIndex]);
+ for (const adjacentLeafIndex of context.usefulLeaves[usefulIndex]?.adjacentLeafIndexes ?? []) {
+ const adjacentUsefulIndex = context.rawLeafToUseful.get(adjacentLeafIndex);
+ if (adjacentUsefulIndex === undefined) continue;
+ for (const page of pageSets[adjacentUsefulIndex]) oneHop.add(page);
+ const key = usefulIndex < adjacentUsefulIndex
+ ? `${usefulIndex}:${adjacentUsefulIndex}`
+ : `${adjacentUsefulIndex}:${usefulIndex}`;
+ if (seenEdges.has(key)) continue;
+ seenEdges.add(key);
+ const current = new Set(pageSets[usefulIndex]);
+ const adjacent = new Set(pageSets[adjacentUsefulIndex]);
+ let currentNew = 0;
+ let adjacentNew = 0;
+ for (const page of adjacent) {
+ if (!current.has(page)) currentNew++;
+ }
+ for (const page of current) {
+ if (!adjacent.has(page)) adjacentNew++;
+ }
+ edgeNew.push(Math.max(currentNew, adjacentNew));
+ }
+ oneHopCounts.push(oneHop.size);
+ }
+ return {
+ pageMean: mean(pageCounts),
+ oneHopMean: mean(oneHopCounts),
+ edgeNewMean: mean(edgeNew),
+ };
+}
+
+function packDeterministicAtlasAssignedPages(tiles, assignment, pageCount) {
+ const pages = [];
+ for (let pageIndex = 0; pageIndex < pageCount; pageIndex++) {
+ const pageTiles = tiles.filter((tile) => assignment.get(tile) === pageIndex);
+ const placed = packDeterministicAtlasMaxRectsPage(pageTiles);
+ if (!placed) return null;
+ const page = { height: 1, tiles: [], width: 1 };
+ for (const item of placed) {
+ const tile = item.tile;
+ tile.x = item.x;
+ tile.y = item.y;
+ page.tiles.push(tile);
+ page.width = Math.max(page.width, tile.x + tile.width + QUAKE_DETERMINISTIC_ATLAS_PAGE_PADDING);
+ page.height = Math.max(page.height, tile.y + tile.height + QUAKE_DETERMINISTIC_ATLAS_PAGE_PADDING);
+ }
+ pages.push(page);
+ }
+ return pages.filter((page) => page.tiles.length);
+}
+
+function packDeterministicAtlasMaxRectsPage(tiles) {
+ for (const mode of ["height", "width", "area", "maxside"]) {
+ const packed = tryPackDeterministicAtlasMaxRectsPage(tiles, mode);
+ if (packed) return packed;
+ }
+ return null;
+}
+
+function tryPackDeterministicAtlasMaxRectsPage(tiles, mode) {
+ const sorted = [...tiles].sort((a, b) => deterministicAtlasTileSortScore(b, mode) - deterministicAtlasTileSortScore(a, mode) ||
+ deterministicAtlasTilePackArea(b) - deterministicAtlasTilePackArea(a) ||
+ a.leafIndex - b.leafIndex);
+ let free = [{ x: 0, y: 0, width: QUAKE_DETERMINISTIC_ATLAS_PAGE_SIZE, height: QUAKE_DETERMINISTIC_ATLAS_PAGE_SIZE }];
+ const placed = [];
+ for (const tile of sorted) {
+ const packWidth = deterministicAtlasTilePackWidth(tile);
+ const packHeight = deterministicAtlasTilePackHeight(tile);
+ let bestIndex = -1;
+ let bestShortSide = Infinity;
+ let bestLongSide = Infinity;
+ for (let index = 0; index < free.length; index++) {
+ const rect = free[index];
+ if (packWidth > rect.width || packHeight > rect.height) continue;
+ const leftoverWidth = rect.width - packWidth;
+ const leftoverHeight = rect.height - packHeight;
+ const shortSide = Math.min(leftoverWidth, leftoverHeight);
+ const longSide = Math.max(leftoverWidth, leftoverHeight);
+ if (shortSide < bestShortSide || (shortSide === bestShortSide && longSide < bestLongSide)) {
+ bestIndex = index;
+ bestShortSide = shortSide;
+ bestLongSide = longSide;
+ }
+ }
+ if (bestIndex < 0) return null;
+ const rect = free[bestIndex];
+ const used = { x: rect.x, y: rect.y, width: packWidth, height: packHeight };
+ placed.push({ tile, x: rect.x, y: rect.y });
+ const nextFree = [];
+ for (const freeRect of free) nextFree.push(...splitDeterministicAtlasFreeRect(freeRect, used));
+ free = pruneDeterministicAtlasFreeRects(nextFree);
+ }
+ return placed;
+}
+
+function splitDeterministicAtlasFreeRect(rect, used) {
+ if (
+ used.x >= rect.x + rect.width ||
+ used.x + used.width <= rect.x ||
+ used.y >= rect.y + rect.height ||
+ used.y + used.height <= rect.y
+ ) {
+ return [rect];
+ }
+ const out = [];
+ if (used.x > rect.x) {
+ out.push({ x: rect.x, y: rect.y, width: used.x - rect.x, height: rect.height });
+ }
+ if (used.x + used.width < rect.x + rect.width) {
+ out.push({
+ x: used.x + used.width,
+ y: rect.y,
+ width: rect.x + rect.width - (used.x + used.width),
+ height: rect.height,
+ });
+ }
+ if (used.y > rect.y) {
+ out.push({ x: rect.x, y: rect.y, width: rect.width, height: used.y - rect.y });
+ }
+ if (used.y + used.height < rect.y + rect.height) {
+ out.push({
+ x: rect.x,
+ y: used.y + used.height,
+ width: rect.width,
+ height: rect.y + rect.height - (used.y + used.height),
+ });
+ }
+ return out.filter((item) => item.width > 0 && item.height > 0);
+}
+
+function pruneDeterministicAtlasFreeRects(rects) {
+ const out = [...rects];
+ for (let a = 0; a < out.length; a++) {
+ for (let b = a + 1; b < out.length; b++) {
+ if (deterministicAtlasRectContains(out[b], out[a])) {
+ out.splice(a, 1);
+ a--;
+ break;
+ }
+ if (deterministicAtlasRectContains(out[a], out[b])) {
+ out.splice(b, 1);
+ b--;
+ }
+ }
+ }
+ return out;
+}
+
+function deterministicAtlasRectContains(outer, inner) {
+ return inner.x >= outer.x &&
+ inner.y >= outer.y &&
+ inner.x + inner.width <= outer.x + outer.width &&
+ inner.y + inner.height <= outer.y + outer.height;
+}
+
+function deterministicAtlasTileSortScore(tile, mode) {
+ if (mode === "height") return deterministicAtlasTilePackHeight(tile) * 100000 + deterministicAtlasTilePackWidth(tile);
+ if (mode === "width") return deterministicAtlasTilePackWidth(tile) * 100000 + deterministicAtlasTilePackHeight(tile);
+ if (mode === "maxside") return Math.max(deterministicAtlasTilePackWidth(tile), deterministicAtlasTilePackHeight(tile));
+ return deterministicAtlasTilePackArea(tile);
+}
+
+function deterministicAtlasTilePackWidth(tile) {
+ return tile.width + QUAKE_DETERMINISTIC_ATLAS_PAGE_PADDING;
+}
+
+function deterministicAtlasTilePackHeight(tile) {
+ return tile.height + QUAKE_DETERMINISTIC_ATLAS_PAGE_PADDING;
+}
+
+function deterministicAtlasTilePackArea(tile) {
+ return deterministicAtlasTilePackWidth(tile) * deterministicAtlasTilePackHeight(tile);
+}
+
+function deterministicAtlasPvsPageCapacity() {
+ return QUAKE_DETERMINISTIC_ATLAS_PAGE_SIZE ** 2 * QUAKE_DETERMINISTIC_ATLAS_PVS_PACK_CAPACITY_RATIO;
+}
+
+function mean(values) {
+ return values.length ? values.reduce((total, value) => total + value, 0) / values.length : 0;
+}
+
async function renderDeterministicAtlasPage(page, timing = null) {
const pageRgba = withDeterministicAtlasTimingSync(timing, "image.compose.atlasPage", () => {
const rgba = Buffer.alloc(page.width * page.height * 4);
diff --git a/src/prepare/entities.ts b/src/prepare/entities.ts
index 60bb31f..396795c 100644
--- a/src/prepare/entities.ts
+++ b/src/prepare/entities.ts
@@ -43,6 +43,7 @@ export function buildEntityManifest(entities: QuakeEntity[]): QuakeEntityManifes
movers: [],
teleporters: [],
exits: [],
+ intermissions: [],
lights: [],
counters: [],
secrets: [],
@@ -92,6 +93,7 @@ export function buildEntityManifest(entities: QuakeEntity[]): QuakeEntityManifes
if (category === "player-start" && point) manifest.starts.push(point);
if (category === "pickup" && point) manifest.pickups.push(point);
if (category === "monster" && point) manifest.monsters.push(point);
+ if (entity.classname.startsWith("info_intermission") && point) manifest.intermissions?.push(point);
if (category === "light" && entity.origin) manifest.lights.push(quakeManifestLight(entity, spawnflags));
if (entity.classname.startsWith("trigger_")) {
@@ -153,6 +155,7 @@ export function cloneEntityManifest(manifest: QuakeEntityManifest): QuakeEntityM
...(exit.modelIndex !== undefined ? { modelIndex: exit.modelIndex } : {}),
...(exit.map ? { map: exit.map } : {}),
})),
+ intermissions: (manifest.intermissions ?? []).map(cloneEntityManifestPoint),
lights: manifest.lights.map((light) => ({
entityIndex: light.entityIndex,
classname: light.classname,
@@ -305,12 +308,14 @@ function isQuakeDamageableBrushClassname(classname: string): boolean {
function quakeManifestPoint(entity: QuakeEntity, spawnflags: number): QuakeEntityManifestPoint | null {
if (!entity.origin) return null;
+ const mangle = quakeManifestVector(entity.properties.mangle);
return {
entityIndex: entity.index,
classname: entity.classname,
origin: { ...entity.origin },
spawnflags,
...(entity.angle !== undefined ? { angle: entity.angle } : {}),
+ ...(mangle ? { mangle } : {}),
...(entity.properties.targetname ? { targetname: entity.properties.targetname } : {}),
};
}
@@ -388,6 +393,7 @@ function cloneEntityManifestPoint(point: QuakeEntityManifestPoint): QuakeEntityM
origin: { ...point.origin },
spawnflags: point.spawnflags,
...(point.angle !== undefined ? { angle: point.angle } : {}),
+ ...(point.mangle ? { mangle: { ...point.mangle } } : {}),
...(point.targetname ? { targetname: point.targetname } : {}),
};
}
diff --git a/src/prepare/scene.ts b/src/prepare/scene.ts
index 26f860b..47191b0 100644
--- a/src/prepare/scene.ts
+++ b/src/prepare/scene.ts
@@ -326,6 +326,7 @@ export interface QuakeEntityManifestPoint {
origin: QuakeVertex;
spawnflags: number;
angle?: number;
+ mangle?: QuakeVertex;
targetname?: string;
}
@@ -397,6 +398,7 @@ export interface QuakeEntityManifest {
movers: QuakeEntityManifestMover[];
teleporters: QuakeEntityManifestTeleporter[];
exits: QuakeEntityManifestExit[];
+ intermissions?: QuakeEntityManifestPoint[];
lights: QuakeEntityManifestLight[];
counters: QuakeEntityManifestTrigger[];
secrets: QuakeEntityManifestTrigger[];
@@ -548,6 +550,25 @@ export type QuakeSerializedPolygon = Omit & {
texture?: number | string;
};
+export interface QuakeRenderBundleAtlasResidencyPage {
+ index: number;
+ varName: string;
+ url: string;
+ bytes?: number;
+ width?: number;
+ height?: number;
+}
+
+export interface QuakeRenderBundleAtlasResidency {
+ version: 1;
+ mode: "pvs-pages";
+ pageSize: number;
+ pages: QuakeRenderBundleAtlasResidencyPage[];
+ leafPageIndexes: number[];
+ visibilityLeafPages: number[][];
+ visibilityLeafPrewarmPages: number[][];
+}
+
export interface QuakePreparedRenderBundle {
version: 1;
kind: "polycss-mesh";
@@ -574,6 +595,7 @@ export interface QuakePreparedRenderBundle {
polygonCount: number;
leafCount: number;
atlasLeafCount: number;
+ atlasResidency?: QuakeRenderBundleAtlasResidency;
}
export type QuakeRenderBundleLeafFrameStyle = [
diff --git a/src/quake.css b/src/quake.css
index 69f1b1b..4c64a1c 100644
--- a/src/quake.css
+++ b/src/quake.css
@@ -44,9 +44,11 @@ body {
#quake-app .polycss-mesh s {
background-repeat: no-repeat !important;
}
+body.quake-debug-no-textures#quake-app .polycss-mesh:not(.quake-debug-outline-atlas-ready) s,
body.quake-debug-no-textures #quake-app .polycss-mesh:not(.quake-debug-outline-atlas-ready) s {
background: none !important;
}
+body.quake-static-lighting#quake-app .quake-lightstyle-mesh,
body.quake-static-lighting #quake-app .quake-lightstyle-mesh {
display: none;
}
@@ -57,18 +59,23 @@ body.quake-static-lighting #quake-app .quake-lightstyle-mesh {
#quake-app .player-lightning-beam :is(b, i, s, u) {
box-shadow: 0 0 8px #84ffff;
}
+body.quake-debug-outlines#quake-app .polycss-mesh :is(b, i, s, u),
body.quake-debug-outlines #quake-app .polycss-mesh :is(b, i, s, u) {
--quake-debug-label-color: green;
}
+body.quake-debug-outlines#quake-app .polycss-mesh.pickup :is(b, i, s, u),
body.quake-debug-outlines #quake-app .polycss-mesh.pickup :is(b, i, s, u) {
--quake-debug-label-color: yellow;
}
+body.quake-debug-outlines#quake-app .polycss-mesh.shootable:not(.enemy) :is(b, i, s, u),
body.quake-debug-outlines #quake-app .polycss-mesh.shootable:not(.enemy) :is(b, i, s, u) {
--quake-debug-label-color: yellow;
}
+body.quake-debug-outlines#quake-app .polycss-mesh.shootable.enemy :is(b, i, s, u),
body.quake-debug-outlines #quake-app .polycss-mesh.shootable.enemy :is(b, i, s, u) {
--quake-debug-label-color: red;
}
+body.quake-debug-labels#quake-app .polycss-mesh :is(b, i, s, u)[data-qpid]::after,
body.quake-debug-labels #quake-app .polycss-mesh :is(b, i, s, u)[data-qpid]::after {
content: attr(data-qpid);
position: absolute;
@@ -341,10 +348,18 @@ body.quake-menu-open .quake-css-logo {
height: 40px;
filter: drop-shadow(0 1px 0 #000000);
}
-.quake-css-logo:hover {
+.quake-id-software-logo {
+ display: block;
+ width: 40px;
+ height: 40px;
+ filter: invert(1) drop-shadow(0 1px 0 #000000);
+}
+.quake-css-logo:hover,
+.quake-id-software-link:hover {
opacity: 0.8;
}
-.quake-css-logo:focus-visible {
+.quake-css-logo:focus-visible,
+.quake-id-software-link:focus-visible {
outline: 2px solid #f0ad5c;
outline-offset: 3px;
}
@@ -603,6 +618,128 @@ body.quake-menu-open #quake-notify {
#quake-centerprint .quake-bitmap-glyph {
filter: drop-shadow(2px 2px 0 #000000);
}
+#quake-intermission {
+ --quake-intermission-px: min(2px, calc(100vw / 320), calc(100dvh / 200));
+ position: absolute;
+ z-index: 9;
+ inset: 0;
+ width: 100%;
+ height: 100%;
+ pointer-events: none;
+}
+#quake-intermission[hidden] {
+ display: none;
+}
+.quake-intermission-scrim {
+ position: absolute;
+ inset: 0;
+ z-index: 0;
+ background: rgba(0, 0, 0, 0.65);
+}
+.quake-intermission-canvas {
+ position: absolute;
+ left: 50%;
+ top: 50%;
+ z-index: 1;
+ width: calc(320 * var(--quake-intermission-px));
+ height: calc(200 * var(--quake-intermission-px));
+ transform: translate(-50%, -50%);
+}
+.quake-intermission-complete {
+ position: absolute;
+ left: calc(64 * var(--quake-intermission-px));
+ top: calc(24 * var(--quake-intermission-px));
+ display: flex;
+ justify-content: center;
+ width: calc(192 * var(--quake-intermission-px));
+ min-height: calc(24 * var(--quake-intermission-px));
+}
+.quake-intermission-complete-art {
+ position: absolute;
+ inset: 0;
+ display: block;
+ width: calc(192 * var(--quake-intermission-px));
+ height: calc(24 * var(--quake-intermission-px));
+ image-rendering: pixelated;
+}
+.quake-intermission-title {
+ display: flex;
+ justify-content: center;
+ align-items: center;
+ min-height: calc(24 * var(--quake-intermission-px));
+}
+.quake-intermission-complete-source-ready .quake-intermission-title {
+ display: none;
+}
+.quake-intermission-stats {
+ position: absolute;
+ left: 0;
+ top: calc(56 * var(--quake-intermission-px));
+ width: calc(320 * var(--quake-intermission-px));
+ height: calc(144 * var(--quake-intermission-px));
+}
+.quake-intermission-label-art {
+ position: absolute;
+ left: calc(var(--quake-intermission-label-x) * var(--quake-intermission-px));
+ top: 0;
+ display: block;
+ width: calc(160 * var(--quake-intermission-px));
+ height: calc(144 * var(--quake-intermission-px));
+ image-rendering: pixelated;
+}
+.quake-intermission-row {
+ position: absolute;
+ left: 0;
+ top: calc(var(--quake-intermission-row-y) * var(--quake-intermission-px));
+ width: calc(320 * var(--quake-intermission-px));
+ height: calc(24 * var(--quake-intermission-px));
+}
+.quake-intermission-label,
+.quake-intermission-value {
+ position: absolute;
+}
+.quake-intermission-label {
+ left: calc(var(--quake-intermission-label-x) * var(--quake-intermission-px));
+ top: 0;
+ display: flex;
+ align-items: center;
+ width: calc(160 * var(--quake-intermission-px));
+ min-height: calc(24 * var(--quake-intermission-px));
+}
+.quake-intermission-value {
+ left: calc((var(--quake-intermission-value-right) - var(--quake-intermission-value-width)) * var(--quake-intermission-px));
+ top: 0;
+ display: flex;
+ align-items: flex-start;
+ width: calc(var(--quake-intermission-value-width) * var(--quake-intermission-px));
+ height: calc(24 * var(--quake-intermission-px));
+}
+.quake-intermission-label-source-ready .quake-intermission-label {
+ visibility: hidden;
+}
+.quake-intermission-value-glyph {
+ flex: 0 0 calc(24 * var(--quake-intermission-px));
+ width: calc(24 * var(--quake-intermission-px));
+ height: calc(24 * var(--quake-intermission-px));
+}
+.quake-intermission-value-glyph {
+ background-image: url("/q/intermission-numbers.png");
+ background-repeat: no-repeat;
+ background-position-x: calc(var(--quake-intermission-value-glyph-index) * -24 * var(--quake-intermission-px));
+ background-position-y: 0;
+ background-size: calc(312 * var(--quake-intermission-px)) calc(24 * var(--quake-intermission-px));
+ image-rendering: pixelated;
+}
+#quake-intermission .quake-bitmap-text {
+ --quake-bitmap-glyph-size: max(16px, calc(16 * var(--quake-intermission-px)));
+ --quake-bitmap-sheet-size: calc(var(--quake-bitmap-glyph-size) * 16);
+ --quake-bitmap-space-size: var(--quake-bitmap-glyph-size);
+ flex-wrap: nowrap;
+ gap: 0;
+}
+#quake-intermission .quake-bitmap-glyph {
+ filter: drop-shadow(2px 2px 0 #000000);
+}
@media (orientation: portrait) {
body.quake-menu-open #quake-notify {
top: max(var(--quake-notify-top), 43dvh);
@@ -667,7 +804,7 @@ body.quake-menu-open #quake-notify {
padding: 0;
border: 0;
appearance: none;
- background: rgba(0, 0, 0, 0.75);
+ background: rgba(0, 0, 0, 0.65);
outline: none;
pointer-events: auto;
-webkit-tap-highlight-color: transparent;
@@ -1631,6 +1768,10 @@ body.quake-menu-open:not(.quake-gameplay-started) .quake-menu-panel {
#quake-debug-menu-panel .quake-option-toggle {
min-height: var(--quake-menu-row-text-size);
}
+#quake-debug-menu-panel .quake-debug-menu-divider {
+ height: calc(8 * var(--quake-menu-px));
+ margin: calc(4 * var(--quake-menu-px)) 0;
+}
.quake-option-toggle input {
position: absolute;
width: 1px;
@@ -2153,6 +2294,18 @@ body.quake-dead #quake-crosshair,
body.quake-dead #quake-classic-hud {
display: none;
}
+body.quake-level-complete #quake-crosshair,
+body.quake-level-complete #quake-classic-hud,
+body.quake-level-complete #quake-viewmodel-layer {
+ display: none;
+}
+body.quake-level-complete .cssquake-logo,
+body.quake-level-complete .cssquake-version,
+body.quake-level-complete .quake-id-software-link,
+body.quake-level-complete .dn-stats-overlay,
+body.quake-level-complete #quake-debug-stack {
+ display: none !important;
+}
body.quake-dead #quake-viewmodel-layer {
opacity: 0;
}
diff --git a/src/runtime/app/cameraFeedbackFlow.ts b/src/runtime/app/cameraFeedbackFlow.ts
index f27adb6..c61b16f 100644
--- a/src/runtime/app/cameraFeedbackFlow.ts
+++ b/src/runtime/app/cameraFeedbackFlow.ts
@@ -247,14 +247,14 @@ export function createQuakeCameraFeedbackFlow(
if (baseRotX === null) {
baseRotX = currentRotX - weaponViewPunchOffset;
} else if (Math.abs(currentRotX - (baseRotX + weaponViewPunchOffset)) > QUAKE_WEAPON_VIEW_PUNCH_EXTERNAL_EPSILON_DEG) {
- baseRotX = currentRotX;
+ baseRotX = currentRotX - weaponViewPunchOffset;
}
baseRotX = clampNumber(baseRotX, QUAKE_CAMERA_ROT_X_MIN, QUAKE_CAMERA_ROT_X_MAX);
weaponViewPunchOffset = nextOffset;
weaponViewPunchBaseRotX = nextOffset > 0 ? baseRotX : null;
applyAt(
- currentRenderOrigin(),
+ cameraRenderOrigin,
clampNumber(baseRotX + nextOffset, QUAKE_CAMERA_ROT_X_MIN, QUAKE_CAMERA_ROT_X_MAX),
rotY,
);
diff --git a/src/runtime/app/dom.ts b/src/runtime/app/dom.ts
index f3e8073..4510f78 100644
--- a/src/runtime/app/dom.ts
+++ b/src/runtime/app/dom.ts
@@ -62,6 +62,7 @@ export interface QuakeAppDomElements {
damageOverlay: HTMLElement | null;
notify: HTMLElement | null;
centerPrint: HTMLElement | null;
+ intermission: HTMLElement | null;
}
export function queryQuakeAppDom(): QuakeAppDomElements {
@@ -133,6 +134,7 @@ export function queryQuakeAppDom(): QuakeAppDomElements {
damageOverlay: quakeElement("quake-damage-overlay"),
notify: quakeElement("quake-notify"),
centerPrint: quakeElement("quake-centerprint"),
+ intermission: quakeElement("quake-intermission"),
};
}
diff --git a/src/runtime/app/entityActivationFlow.ts b/src/runtime/app/entityActivationFlow.ts
index a89d896..ce625de 100644
--- a/src/runtime/app/entityActivationFlow.ts
+++ b/src/runtime/app/entityActivationFlow.ts
@@ -26,7 +26,8 @@ import type { QuakeTriggersController } from "../triggers";
import type { QuakeViewmodelController } from "../viewmodel";
import type { QuakeWorldController } from "../world";
-const QUAKE_CHANGELEVEL_DELAY_MS = 850;
+const QUAKE_INTERMISSION_AUTO_ADVANCE_MS = 3000;
+const QUAKE_INTERMISSION_MIN_ADVANCE_MS = 1000;
const QUAKE_SHAREWARE_REGISTERED = false;
const QUAKE_TRAP_SPIKE_RANGE = 2048 * QUAKE_COLLISION_UNIT_SCALE;
const QUAKE_TRAP_SPIKE_RADIUS = 36 * QUAKE_COLLISION_UNIT_SCALE;
@@ -50,7 +51,9 @@ export interface QuakeEntityActivationFlowOptions {
getOrigin(): [number, number, number];
loadMap(mapName: string, options: { loadingStatus: string; resumeGameplay: boolean }): Promise;
mapExists(mapName: string): boolean;
+ intermission: QuakeEntityActivationIntermission;
movers: Pick;
+ onSecretActivated?(entity: QuakeEntity): void;
pickups: Pick;
player(): Pick;
pointToPoly(point: { x: number; y: number; z: number }): Vec3;
@@ -71,8 +74,14 @@ interface QuakeEntityActivationPickups {
syncCollision(origin: [number, number, number], eyeHeight: number, stepHeight: number): void;
}
+interface QuakeEntityActivationIntermission {
+ show(): void;
+ syncCamera(): void;
+}
+
interface QuakeEntityActivationText {
centerPrint(message: string): void;
+ clearCenterPrint(): void;
hasUseTargetsMessageText(entity: QuakeEntity): boolean;
setCenterPrint(message: string): void;
showDirectCenterPrintMessageText(entity: QuakeEntity): boolean;
@@ -80,7 +89,7 @@ interface QuakeEntityActivationText {
export interface QuakeEntityActivationFlow {
activateEntity(entityIndex: number, sourceEntityIndex?: number): boolean;
- activateSecretTrigger(entity: QuakeEntity): void;
+ activateSecretTrigger(entity: QuakeEntity): boolean;
activateSolidTouch(touch: QuakeTouchedTrigger): void;
activateSpecialTrigger(entity: QuakeEntity): boolean;
activateTeleport(trigger: QuakeEntity): boolean;
@@ -90,6 +99,7 @@ export interface QuakeEntityActivationFlow {
completeLevel(entity: QuakeEntity): void;
fireTarget(targetname: string, sourceEntityIndex?: number): void;
isLevelLoadPending(): boolean;
+ requestIntermissionAdvance(): boolean;
triggerCounter(entity: QuakeEntity): void;
triggerOneShot(entity: QuakeEntity, fallback: boolean): boolean;
triggerWait(entity: QuakeEntity, fallback: number): number;
@@ -100,6 +110,9 @@ export function createQuakeEntityActivationFlow(
): QuakeEntityActivationFlow {
let skill = 1;
let levelLoadTimer: number | null = null;
+ let intermissionActive = false;
+ let intermissionAdvanceAt = Infinity;
+ let intermissionNextMap: string | null = null;
function activateTeleport(trigger: QuakeEntity): boolean {
const destination = quakeTriggerTeleportDestination(trigger, {
@@ -138,14 +151,24 @@ export function createQuakeEntityActivationFlow(
options.audio.playEvent("levelExit", { volume: 0.58 });
const nextMap = quakeTriggerChangelevelMap(entity, options.currentGameLogic());
if (!nextMap) options.text.setCenterPrint("EXIT REACHED");
- if (!nextMap || !options.mapExists(nextMap)) return;
+ if (!nextMap) return;
+ options.text.clearCenterPrint();
+ intermissionActive = true;
+ intermissionAdvanceAt = performance.now() + QUAKE_INTERMISSION_MIN_ADVANCE_MS;
+ syncIntermissionCamera();
+ options.intermission.show();
+ if (!options.mapExists(nextMap)) return;
+ intermissionNextMap = nextMap;
levelLoadTimer = window.setTimeout(() => {
- levelLoadTimer = null;
- void options.loadMap(nextMap, { loadingStatus: "Loading", resumeGameplay: true }).catch((error) => {
- console.error(error);
- options.text.setCenterPrint(`COULD NOT LOAD ${nextMap.toUpperCase()}`);
- });
- }, QUAKE_CHANGELEVEL_DELAY_MS);
+ void advanceIntermission("auto");
+ }, QUAKE_INTERMISSION_AUTO_ADVANCE_MS);
+ }
+
+ function syncIntermissionCamera(): void {
+ options.intermission.syncCamera();
+ queueMicrotask(() => {
+ if (intermissionActive) options.intermission.syncCamera();
+ });
}
function activateSolidTouch(touch: QuakeTouchedTrigger): void {
@@ -314,11 +337,13 @@ export function createQuakeEntityActivationFlow(
}
}
- function activateSecretTrigger(entity: QuakeEntity): void {
+ function activateSecretTrigger(entity: QuakeEntity): boolean {
const activation = quakeTriggerSecretActivation(entity, options.currentGameLogic());
- if (!activation) return;
+ if (!activation) return false;
if (!options.text.hasUseTargetsMessageText(entity)) options.text.centerPrint(activation.message);
options.audio.playSound(activation.sound, { volume: 0.58 });
+ options.onSecretActivated?.(entity);
+ return true;
}
function triggerOneShot(entity: QuakeEntity, fallback: boolean): boolean {
@@ -366,10 +391,41 @@ export function createQuakeEntityActivationFlow(
window.clearTimeout(levelLoadTimer);
levelLoadTimer = null;
}
+ intermissionActive = false;
+ intermissionNextMap = null;
+ intermissionAdvanceAt = Infinity;
}
function isLevelLoadPending(): boolean {
- return levelLoadTimer !== null;
+ return levelLoadTimer !== null || intermissionActive || intermissionNextMap !== null;
+ }
+
+ function requestIntermissionAdvance(): boolean {
+ if (!intermissionActive) return false;
+ if (!intermissionNextMap) return true;
+ if (performance.now() < intermissionAdvanceAt) return true;
+ void advanceIntermission("input");
+ return true;
+ }
+
+ async function advanceIntermission(reason: "auto" | "input"): Promise {
+ const nextMap = intermissionNextMap;
+ if (!nextMap) return false;
+ if (reason === "input" && performance.now() < intermissionAdvanceAt) return true;
+ if (levelLoadTimer !== null) {
+ window.clearTimeout(levelLoadTimer);
+ levelLoadTimer = null;
+ }
+ intermissionNextMap = null;
+ intermissionAdvanceAt = Infinity;
+ intermissionActive = false;
+ try {
+ await options.loadMap(nextMap, { loadingStatus: "Loading", resumeGameplay: true });
+ } catch (error) {
+ console.error(error);
+ options.text.setCenterPrint(`COULD NOT LOAD ${nextMap.toUpperCase()}`);
+ }
+ return true;
}
function getEntity(entityIndex: number): QuakeEntity | undefined {
@@ -388,6 +444,7 @@ export function createQuakeEntityActivationFlow(
completeLevel,
fireTarget,
isLevelLoadPending,
+ requestIntermissionAdvance,
triggerCounter,
triggerOneShot,
triggerWait,
diff --git a/src/runtime/app/input.ts b/src/runtime/app/input.ts
index 90e267a..32070a0 100644
--- a/src/runtime/app/input.ts
+++ b/src/runtime/app/input.ts
@@ -25,6 +25,7 @@ export interface QuakeAppInputControllerOptions {
menuIsMainOpen(): boolean;
menuIsPanelOpen(): boolean;
parentKeyRelay(event: KeyboardEvent, pressed: boolean): void;
+ requestIntermissionAdvance(event: KeyboardEvent): boolean;
shouldOpenMainMenuOnEscape(): boolean;
shouldPreventGameplayKeyDefault(event: KeyboardEvent): boolean;
showMainMenu(): void;
@@ -62,6 +63,14 @@ export function createQuakeAppInputController(options: QuakeAppInputControllerOp
options.toggleDebugMode();
return;
}
+ if (!event.repeat && options.requestIntermissionAdvance(event)) {
+ event.preventDefault();
+ event.stopPropagation();
+ options.clearMoveInput();
+ options.clearCrouchInput();
+ options.clearAttackInput();
+ return;
+ }
if (options.handleMenuKeyDown(event)) {
options.clearMoveInput();
options.clearCrouchInput();
diff --git a/src/runtime/app/intermissionFlow.ts b/src/runtime/app/intermissionFlow.ts
new file mode 100644
index 0000000..5053ace
--- /dev/null
+++ b/src/runtime/app/intermissionFlow.ts
@@ -0,0 +1,206 @@
+export interface QuakeIntermissionStats {
+ elapsedSeconds: number;
+ mapName: string;
+ monstersKilled: number;
+ secretsFound: number;
+ totalMonsters: number;
+ totalSecrets: number;
+}
+
+export interface QuakeIntermissionFlowOptions {
+ renderBitmapText(root: HTMLElement): void;
+ root: HTMLElement | null;
+}
+
+export interface QuakeIntermissionFlow {
+ active(): boolean;
+ clear(): void;
+ show(stats: QuakeIntermissionStats): void;
+}
+
+const QUAKE_INTERMISSION_COMPLETE_ART = {
+ className: "quake-intermission-complete-art",
+ height: 24,
+ src: "/q/intermission-complete.png",
+ width: 192,
+} as const;
+
+const QUAKE_INTERMISSION_LABEL_ART = {
+ className: "quake-intermission-label-art",
+ height: 144,
+ src: "/q/intermission-labels.png",
+ width: 160,
+} as const;
+
+const QUAKE_INTERMISSION_NUMBER_ART = {
+ glyphs: "0123456789:/-",
+ height: 24,
+ src: "/q/intermission-numbers.png",
+ width: 24,
+} as const;
+
+export function createQuakeIntermissionFlow(
+ options: QuakeIntermissionFlowOptions,
+): QuakeIntermissionFlow {
+ let visible = false;
+
+ function clear(): void {
+ visible = false;
+ if (!options.root) return;
+ options.root.replaceChildren();
+ options.root.hidden = true;
+ }
+
+ function show(stats: QuakeIntermissionStats): void {
+ visible = true;
+ if (!options.root) return;
+ options.root.replaceChildren(
+ intermissionScrim(),
+ intermissionCanvas(stats),
+ );
+ options.root.hidden = false;
+ options.renderBitmapText(options.root);
+ }
+
+ return {
+ active: () => visible,
+ clear,
+ show,
+ };
+}
+
+function intermissionScrim(): HTMLElement {
+ const scrim = document.createElement("div");
+ scrim.className = "quake-intermission-scrim";
+ return scrim;
+}
+
+function intermissionCanvas(stats: QuakeIntermissionStats): HTMLElement {
+ const canvas = document.createElement("div");
+ canvas.className = "quake-intermission-canvas";
+ canvas.append(
+ intermissionCompleteTitle(),
+ intermissionStatsRows(stats),
+ );
+ return canvas;
+}
+
+function intermissionCompleteTitle(): HTMLElement {
+ const title = document.createElement("div");
+ title.className = "quake-intermission-complete";
+ title.append(
+ intermissionSourceArt(
+ QUAKE_INTERMISSION_COMPLETE_ART,
+ () => title.classList.add("quake-intermission-complete-source-ready"),
+ ),
+ intermissionText("COMPLETED", "quake-intermission-title"),
+ );
+ return title;
+}
+
+function intermissionStatsRows(stats: QuakeIntermissionStats): HTMLElement {
+ const values = {
+ kills: formatQuakeIntermissionRatio(stats.monstersKilled, stats.totalMonsters),
+ secrets: formatQuakeIntermissionRatio(stats.secretsFound, stats.totalSecrets),
+ time: formatQuakeIntermissionTime(stats.elapsedSeconds),
+ };
+ const layout = intermissionStatsLayout([values.time, values.secrets, values.kills]);
+ const rows = document.createElement("div");
+ rows.className = "quake-intermission-stats";
+ rows.style.setProperty("--quake-intermission-label-x", String(layout.labelX));
+ rows.style.setProperty("--quake-intermission-value-right", String(layout.valueRight));
+ rows.append(
+ intermissionSourceArt(
+ QUAKE_INTERMISSION_LABEL_ART,
+ () => rows.classList.add("quake-intermission-label-source-ready"),
+ ),
+ intermissionRow("TIME", values.time, 8),
+ intermissionRow("SECRETS", values.secrets, 48),
+ intermissionRow("KILLS", values.kills, 88),
+ );
+ return rows;
+}
+
+function intermissionRow(label: string, value: string, y: number): HTMLElement {
+ const row = document.createElement("div");
+ row.className = "quake-intermission-row";
+ row.style.setProperty("--quake-intermission-row-y", String(y));
+ row.append(
+ intermissionText(label, "quake-intermission-label"),
+ intermissionValueText(value),
+ );
+ return row;
+}
+
+function intermissionText(text: string, className: string): HTMLElement {
+ const element = document.createElement("span");
+ element.className = `${className} quake-bm quake-bm-alt`;
+ element.textContent = text;
+ return element;
+}
+
+function intermissionValueText(text: string): HTMLElement {
+ const value = document.createElement("span");
+ value.className = "quake-intermission-value";
+ value.style.setProperty("--quake-intermission-value-width", String(intermissionTextWidth(text)));
+ value.dataset.value = text;
+
+ const source = document.createElement("span");
+ source.className = "quake-intermission-value-text quake-bitmap-source";
+ source.textContent = text;
+ value.append(source);
+
+ for (const char of text) {
+ if (char === " ") continue;
+
+ const index = QUAKE_INTERMISSION_NUMBER_ART.glyphs.indexOf(char);
+ if (index < 0) continue;
+ const glyph = document.createElement("span");
+ glyph.className = "quake-intermission-value-glyph";
+ glyph.style.setProperty("--quake-intermission-value-glyph-index", String(index));
+ value.append(glyph);
+ }
+
+ return value;
+}
+
+function intermissionSourceArt(
+ art: { className: string; height: number; src: string; width: number },
+ onReady: () => void,
+): HTMLImageElement {
+ const image = document.createElement("img");
+ image.alt = "";
+ image.className = art.className;
+ image.decoding = "async";
+ image.draggable = false;
+ image.height = art.height;
+ image.width = art.width;
+ image.addEventListener("load", onReady, { once: true });
+ image.addEventListener("error", () => { image.hidden = true; }, { once: true });
+ image.src = art.src;
+ return image;
+}
+
+function intermissionStatsLayout(values: string[]): { labelX: number; valueRight: number } {
+ const widestValue = Math.max(...values.map(intermissionTextWidth));
+ const total = Math.min(320, QUAKE_INTERMISSION_LABEL_ART.width + QUAKE_INTERMISSION_NUMBER_ART.width + widestValue);
+ return {
+ labelX: 160 - total / 2,
+ valueRight: 160 + total / 2,
+ };
+}
+
+function intermissionTextWidth(text: string): number {
+ return text.length * QUAKE_INTERMISSION_NUMBER_ART.width;
+}
+
+function formatQuakeIntermissionTime(elapsedSeconds: number): string {
+ const total = Math.max(0, Math.floor(elapsedSeconds));
+ const minutes = Math.floor(total / 60);
+ const seconds = total % 60;
+ return `${minutes}:${String(seconds).padStart(2, "0")}`;
+}
+
+function formatQuakeIntermissionRatio(value: number, total: number): string {
+ return `${Math.trunc(value)}/${String(Math.trunc(total)).padStart(2, " ")}`;
+}
diff --git a/src/runtime/app/levelStatsFlow.ts b/src/runtime/app/levelStatsFlow.ts
new file mode 100644
index 0000000..a08f7d4
--- /dev/null
+++ b/src/runtime/app/levelStatsFlow.ts
@@ -0,0 +1,96 @@
+import type { QuakeIntermissionStats } from "./intermissionFlow";
+import type { QuakeEntity } from "../../types/quake";
+import { shouldSpawnQuakeEntityForCurrentGame } from "../entities";
+
+export interface QuakeLevelStatsTotals {
+ monsters: number;
+ secrets: number;
+}
+
+export interface QuakeLevelStatsFlowOptions {
+ now?: () => number;
+}
+
+export interface QuakeLevelStatsFlow {
+ freeze(): QuakeIntermissionStats;
+ markMonsterKilled(entityIndex: number): void;
+ markSecret(entityIndex: number): void;
+ reset(mapName: string, totals: QuakeLevelStatsTotals): void;
+ snapshot(): QuakeIntermissionStats;
+}
+
+export function createQuakeLevelStatsFlow(
+ options: QuakeLevelStatsFlowOptions = {},
+): QuakeLevelStatsFlow {
+ const now = options.now ?? (() => performance.now());
+ let mapName = "";
+ let startedAt = now();
+ let totalSecrets = 0;
+ let totalMonsters = 0;
+ let frozen: QuakeIntermissionStats | null = null;
+ const secretEntityIndexes = new Set();
+ const killedMonsterEntityIndexes = new Set();
+
+ function reset(nextMapName: string, totals: QuakeLevelStatsTotals): void {
+ mapName = nextMapName;
+ startedAt = now();
+ totalSecrets = nonNegativeInteger(totals.secrets);
+ totalMonsters = nonNegativeInteger(totals.monsters);
+ frozen = null;
+ secretEntityIndexes.clear();
+ killedMonsterEntityIndexes.clear();
+ }
+
+ function markSecret(entityIndex: number): void {
+ if (frozen) return;
+ if (Number.isInteger(entityIndex)) secretEntityIndexes.add(entityIndex);
+ }
+
+ function markMonsterKilled(entityIndex: number): void {
+ if (frozen) return;
+ if (Number.isInteger(entityIndex)) killedMonsterEntityIndexes.add(entityIndex);
+ }
+
+ function snapshot(): QuakeIntermissionStats {
+ return frozen ?? buildStats(now());
+ }
+
+ function freeze(): QuakeIntermissionStats {
+ if (!frozen) frozen = buildStats(now());
+ return frozen;
+ }
+
+ function buildStats(finishedAt: number): QuakeIntermissionStats {
+ return {
+ elapsedSeconds: Math.max(0, Math.floor((finishedAt - startedAt) / 1000)),
+ mapName,
+ monstersKilled: Math.min(killedMonsterEntityIndexes.size, totalMonsters),
+ secretsFound: Math.min(secretEntityIndexes.size, totalSecrets),
+ totalMonsters,
+ totalSecrets,
+ };
+ }
+
+ return {
+ freeze,
+ markMonsterKilled,
+ markSecret,
+ reset,
+ snapshot,
+ };
+}
+
+export function quakeLevelStatsTotalsForEntities(entities: readonly QuakeEntity[]): QuakeLevelStatsTotals {
+ let monsters = 0;
+ let secrets = 0;
+ for (const entity of entities) {
+ if (!shouldSpawnQuakeEntityForCurrentGame(entity)) continue;
+ if (entity.classname.startsWith("monster_")) monsters++;
+ if (entity.classname === "trigger_secret") secrets++;
+ }
+ return { monsters, secrets };
+}
+
+function nonNegativeInteger(value: number): number {
+ return Math.max(0, Math.floor(Number.isFinite(value) ? value : 0));
+}
diff --git a/src/runtime/app/pointerGameplayFlow.ts b/src/runtime/app/pointerGameplayFlow.ts
index 9de0d11..659e960 100644
--- a/src/runtime/app/pointerGameplayFlow.ts
+++ b/src/runtime/app/pointerGameplayFlow.ts
@@ -53,6 +53,7 @@ export interface QuakePointerGameplayFlowOptions {
pointerLockElement(): Element | null;
queueCrosshairTargetSync(): void;
renderSupersample: number;
+ requestIntermissionAdvance(): boolean;
respawnPlayerFromDeath(): boolean;
rotation(): { rotX: number; rotY: number };
setAnalogMove(x: number, y: number): void;
@@ -158,6 +159,14 @@ export function createQuakePointerGameplayFlow(
});
return;
}
+ if (options.requestIntermissionAdvance()) {
+ options.trace("host-pointerdown-intermission-advance", { pointerId: event.pointerId });
+ event.preventDefault();
+ event.stopPropagation();
+ clearAttackInput();
+ options.audioUnlock();
+ return;
+ }
if (options.isPlayerDead()) {
options.trace("host-pointerdown-respawn", { pointerId: event.pointerId });
event.preventDefault();
@@ -303,6 +312,11 @@ export function createQuakePointerGameplayFlow(
function handleMobileFirePointerDown(event: PointerEvent): boolean {
options.audioUnlock();
+ if (options.requestIntermissionAdvance()) {
+ clearAttackInput();
+ markQuakeTrace("mobile-fire-intermission-advance", { pointerId: event.pointerId });
+ return false;
+ }
if (options.isPlayerDead()) {
clearAttackInput();
options.respawnPlayerFromDeath();
diff --git a/src/runtime/loadingConsole.ts b/src/runtime/loadingConsole.ts
index 0c5cbe9..3645968 100644
--- a/src/runtime/loadingConsole.ts
+++ b/src/runtime/loadingConsole.ts
@@ -3,9 +3,12 @@ export const QUAKE_ASSETS_REGENERATING_ACTION =
"Wait for pnpm prepare:quake to finish, then reload.";
export const QUAKE_LOADING_CONSOLE_PAK_LINE = "Assets from id1/pak0.pak";
+declare const __POLYCSS_VERSION__: string;
+
const QUAKE_LOADING_CONSOLE_BOOT_LINES = [
"Quake (C) 1996 id Software, Inc.",
"Shareware version 1.06",
+ `Using PolyCSS renderer v${__POLYCSS_VERSION__}`,
"Host_Init",
] as const;
const QUAKE_LOADING_CONSOLE_LINE_DELAY_MS = 55;
diff --git a/src/runtime/menu.ts b/src/runtime/menu.ts
index dc66516..5b1aa47 100644
--- a/src/runtime/menu.ts
+++ b/src/runtime/menu.ts
@@ -62,6 +62,8 @@ const QUAKE_MAIN_MENU_NOTE_CLASS = "quake-main-menu-note";
const QUAKE_MAIN_MENU_COMING_SOON_CLASS = "quake-main-menu-note-coming-soon";
const QUAKE_BITMAP_LABEL_CLASS = "quake-bm-label";
const QUAKE_BITMAP_ALT_CLASS = "quake-bm-alt";
+const QUAKE_MAIN_MENU_PENDING_CLASS = "quake-main-menu-pending";
+const QUAKE_MAIN_MENU_DEFERRED_CLASS = "quake-main-menu-deferred";
export function createQuakeMenuController({
enabled,
@@ -125,6 +127,7 @@ export function createQuakeMenuController({
function hideMainMenu(): void {
if (!mainMenu) return;
controls.update({ moveEnabled: true });
+ clearPendingMainMenu();
mainMenu.hidden = true;
singlePlayerPanel?.setAttribute("hidden", "");
multiplayerPanel?.setAttribute("hidden", "");
@@ -139,6 +142,29 @@ export function createQuakeMenuController({
syncCrosshairTarget();
}
+ function clearPendingMainMenu(): void {
+ document.body.classList.remove(QUAKE_MAIN_MENU_PENDING_CLASS);
+ }
+
+ function showPendingMainMenu(): void {
+ if (!mainMenu) return;
+ controls.update({ moveEnabled: false });
+ updateMainMenuCursor();
+ singlePlayerPanel?.setAttribute("hidden", "");
+ multiplayerPanel?.setAttribute("hidden", "");
+ levelPanel?.setAttribute("hidden", "");
+ aboutPanel?.setAttribute("hidden", "");
+ optionsPanel?.setAttribute("hidden", "");
+ debugPanel?.setAttribute("hidden", "");
+ mainMenu.hidden = false;
+ document.body.classList.remove(QUAKE_MAIN_MENU_DEFERRED_CLASS);
+ document.body.classList.add("quake-menu-open", QUAKE_MAIN_MENU_PENDING_CLASS);
+ onMenuVisibilityChange?.(true);
+ onMenuPauseChange?.(true);
+ clearCrosshairTarget();
+ mainMenu.focus({ preventScroll: true });
+ }
+
function startFromMainMenu(): void {
controls.lock();
hideMainMenu();
@@ -151,15 +177,18 @@ export function createQuakeMenuController({
}
if (startingNewGame) return;
startingNewGame = true;
+ showPendingMainMenu();
Promise.resolve(onSelectNewGame())
.then(() => {
startingNewGame = false;
+ clearPendingMainMenu();
controls.lock();
hideMainMenu();
})
.catch((error: unknown) => {
console.error(error);
startingNewGame = false;
+ clearPendingMainMenu();
showMainMenu();
});
}
diff --git a/src/runtime/renderBundleMesh.ts b/src/runtime/renderBundleMesh.ts
index 531a241..79f9140 100644
--- a/src/runtime/renderBundleMesh.ts
+++ b/src/runtime/renderBundleMesh.ts
@@ -194,6 +194,7 @@ export function mountQuakeRenderBundleMesh(
throw new Error("Quake render bundle did not contain a .polycss-mesh root.");
}
applyQuakeRenderBundleLeafFrameStyles(element, renderBundle);
+ removeQuakeRenderBundleAtlasResidencyRootVars(element, renderBundle);
const leaves = element.querySelectorAll("b,i,s,u");
const leafCount = leaves.length;
if (leafCount !== renderBundle.leafCount) {
@@ -744,6 +745,43 @@ export async function preloadQuakeRenderBundleAssets(
}
}
+export function exposeQuakeRenderBundleAtlasPages(
+ element: HTMLElement,
+ renderBundle: QuakePreparedRenderBundle,
+ pageIndexes: readonly number[],
+): number {
+ const pageByIndex = quakeRenderBundleAtlasResidencyPageMap(renderBundle);
+ if (!pageByIndex?.size || !pageIndexes.length) return 0;
+ const managedNames = new Set(renderBundleElementRootVarNames.get(element) ?? []);
+ let changed = 0;
+ for (const pageIndex of new Set(pageIndexes)) {
+ const page = pageByIndex.get(pageIndex);
+ if (!page?.url || !page.varName) continue;
+ const value = quakeRenderBundleCssUrl(page.url);
+ if (element.style.getPropertyValue(page.varName) !== value) {
+ element.style.setProperty(page.varName, value);
+ changed++;
+ }
+ managedNames.add(page.varName);
+ }
+ renderBundleElementRootVarNames.set(element, managedNames);
+ return changed;
+}
+
+export async function preloadQuakeRenderBundleAtlasPages(
+ renderBundle: QuakePreparedRenderBundle,
+ pageIndexes: readonly number[],
+): Promise {
+ const pageByIndex = quakeRenderBundleAtlasResidencyPageMap(renderBundle);
+ if (!pageByIndex?.size || !pageIndexes.length) return;
+ const urls: string[] = [];
+ for (const pageIndex of new Set(pageIndexes)) {
+ const url = pageByIndex.get(pageIndex)?.url;
+ if (url) urls.push(url);
+ }
+ await preloadQuakeRenderBundleAssetUrls(urls);
+}
+
export interface QuakeRenderBundleDebugOutlineOptions {
hideTextures?: boolean;
}
@@ -1604,6 +1642,34 @@ function syncQuakeRenderBundleRootVars(element: HTMLElement, renderBundle: Quake
renderBundleElementRootVarNames.set(element, new Set(nextVars.keys()));
}
+function removeQuakeRenderBundleAtlasResidencyRootVars(
+ element: HTMLElement,
+ renderBundle: QuakePreparedRenderBundle,
+): void {
+ const pages = renderBundle.atlasResidency?.pages;
+ if (renderBundle.atlasResidency?.mode !== "pvs-pages" || !pages?.length) return;
+ for (const page of pages) {
+ if (page.varName) element.style.removeProperty(page.varName);
+ }
+}
+
+function quakeRenderBundleAtlasResidencyPageMap(
+ renderBundle: QuakePreparedRenderBundle,
+): Map | null {
+ const pages = renderBundle.atlasResidency?.pages;
+ if (renderBundle.atlasResidency?.mode !== "pvs-pages" || !pages?.length) return null;
+ const pageByIndex = new Map();
+ for (const page of pages) {
+ if (!Number.isInteger(page.index) || !page.url || !page.varName) continue;
+ pageByIndex.set(page.index, {
+ index: page.index,
+ url: page.url,
+ varName: page.varName,
+ });
+ }
+ return pageByIndex;
+}
+
function quakeRenderBundleRootVars(renderBundle: QuakePreparedRenderBundle): Map {
const existing = renderBundleRootVarsCache.get(renderBundle);
if (existing) return existing;
diff --git a/src/runtime/shootables.ts b/src/runtime/shootables.ts
index fdd00c3..7e83f28 100644
--- a/src/runtime/shootables.ts
+++ b/src/runtime/shootables.ts
@@ -300,6 +300,7 @@ export interface QuakeShootablesControllerOptions {
damagePlayer(amount: number, context?: QuakePlayerDamageContext): boolean;
contentsAt?(point: Vec3): number | null;
dropBackpack?: (drop: QuakeMonsterBackpackDropRuntime) => boolean | void;
+ onDestroyed?: (entity: QuakeEntity) => void;
enemyAnimationsEnabled?: () => boolean;
enemiesFrozen?: () => boolean;
enemyAttacksEnabled?: () => boolean;
@@ -465,6 +466,7 @@ export function createQuakeShootablesController({
damagePlayer,
contentsAt,
dropBackpack,
+ onDestroyed,
enemyAnimationsEnabled,
enemiesFrozen,
enemyAttacksEnabled,
@@ -1124,6 +1126,7 @@ export function createQuakeShootablesController({
if (!shootable || shootable.dead) return false;
shootable.dead = true;
destroyedEntityIndexes.add(entityIndex);
+ onDestroyed?.(shootable.entity);
applyShootableDeathRadiusDamage(shootable, context);
clearEnemyAttackState(shootable);
const deathAnimationMs = deathState.playDeathAnimation(shootable, performance.now());
diff --git a/src/runtime/world.ts b/src/runtime/world.ts
index 4626bbd..aa138f2 100644
--- a/src/runtime/world.ts
+++ b/src/runtime/world.ts
@@ -22,7 +22,9 @@ import {
} from "./debug/churnStats";
import { markQuakeTrace } from "./debug/traceMarks";
import {
+ exposeQuakeRenderBundleAtlasPages,
mountQuakeRenderBundleMesh,
+ preloadQuakeRenderBundleAtlasPages,
registerQuakeRenderBundleDebugOutlineLeaves,
stripPolyMeshMetadata,
syncQuakeRenderBundleDebugOutlineLeaves,
@@ -141,6 +143,7 @@ export interface QuakeWorldController {
mount: (result: QuakeScene) => void;
pixelate: (handle?: PolyMeshHandle | null) => void;
schedulePresentationResync: (handle?: PolyMeshHandle | null) => Promise;
+ syncVisibilityAt: (origin: [number, number, number], force?: boolean) => void;
syncVisibility: (force?: boolean) => void;
visibleLeavesAt: (origin: [number, number, number]) => Set | null;
}
@@ -179,6 +182,7 @@ interface QuakePresentationResyncTask {
export function createQuakeWorldController(options: QuakeWorldControllerOptions): QuakeWorldController {
let currentHandle: PolyMeshHandle | null = null;
+ let currentRenderBundle: QuakePreparedRenderBundle | null = null;
let currentLightstyleOverlayHandle: PolyMeshHandle | null = null;
let currentVisibility: QuakeVisibility | null = null;
let faceLeaves = new Map();
@@ -204,6 +208,7 @@ export function createQuakeWorldController(options: QuakeWorldControllerOptions)
currentHandle?.remove();
currentLightstyleOverlayHandle?.remove();
currentHandle = null;
+ currentRenderBundle = null;
currentLightstyleOverlayHandle = null;
currentVisibility = null;
faceLeaves = new Map();
@@ -289,15 +294,19 @@ export function createQuakeWorldController(options: QuakeWorldControllerOptions)
};
const syncVisibility = (force = false): void => {
+ syncVisibilityAt(options.getOrigin(), force);
+ };
+
+ const syncVisibilityAt = (origin: [number, number, number], force = false): void => {
const startedAt = performance.now();
if (!currentHandle) {
recordQuakeWorldVisibilitySync(visibilityChurn, "no-handle", startedAt, { force });
return;
}
- const origin = options.getOrigin();
options.syncPickupsVisibility(origin);
const nextLeafIndexValue = currentVisibility?.leafIndexAt(origin);
const nextLeafIndex = Number.isInteger(nextLeafIndexValue) ? nextLeafIndexValue : null;
+ syncWorldAtlasResidencyPages(nextLeafIndex);
const prevLeafIndex = visibleLeafIndex;
const prevVisibleFaceKey = visibleFaceKey || null;
const visibleFaceGroup = currentVisibility?.visibleFaceGroupAt(origin) ?? null;
@@ -1023,6 +1032,7 @@ export function createQuakeWorldController(options: QuakeWorldControllerOptions)
const addQuakeRenderBundleMesh = (renderBundle: QuakePreparedRenderBundle): PolyMeshHandle => {
const handle = mountQuakeRenderBundleMesh(options.sceneElement, renderBundle);
+ currentRenderBundle = renderBundle;
const element = handle.element;
stripQuakeWorldMeshMetadata(element);
faceLeaves = indexQuakeFaceLeaves(handle, renderBundle, new Map(), true, "world");
@@ -1030,6 +1040,22 @@ export function createQuakeWorldController(options: QuakeWorldControllerOptions)
return handle;
};
+ const syncWorldAtlasResidencyPages = (leafIndex: number | null): void => {
+ const atlasResidency = currentRenderBundle?.atlasResidency;
+ if (!currentHandle || !currentRenderBundle || atlasResidency?.mode !== "pvs-pages") return;
+ const allPages = atlasResidency.pages.map((page) => page.index);
+ const currentPages = leafIndex === null
+ ? allPages
+ : atlasResidency.visibilityLeafPages[leafIndex] ?? [];
+ const prewarmPages = leafIndex === null
+ ? currentPages
+ : atlasResidency.visibilityLeafPrewarmPages[leafIndex] ?? currentPages;
+ const exposedPages = currentPages.length ? currentPages : allPages;
+ const warmPages = prewarmPages.length ? prewarmPages : exposedPages;
+ exposeQuakeRenderBundleAtlasPages(currentHandle.element, currentRenderBundle, exposedPages);
+ void preloadQuakeRenderBundleAtlasPages(currentRenderBundle, warmPages);
+ };
+
const addQuakeLightstyleRenderBundleMesh = (renderBundle: QuakePreparedRenderBundle): PolyMeshHandle => {
const handle = mountQuakeRenderBundleMesh(options.sceneElement, renderBundle);
handle.element.classList.add("quake-lightstyle-mesh");
@@ -1167,6 +1193,7 @@ export function createQuakeWorldController(options: QuakeWorldControllerOptions)
mount,
pixelate,
schedulePresentationResync,
+ syncVisibilityAt,
syncVisibility,
visibleLeavesAt: (origin: [number, number, number]) => currentVisibility?.visibleLeavesAt(origin) ?? null,
};
diff --git a/src/types/quake.ts b/src/types/quake.ts
index dad925c..c28136e 100644
--- a/src/types/quake.ts
+++ b/src/types/quake.ts
@@ -69,6 +69,7 @@ export interface QuakeEntityManifestPoint {
origin: QuakeVertex;
spawnflags: number;
angle?: number;
+ mangle?: QuakeVertex;
targetname?: string;
}
@@ -140,6 +141,7 @@ export interface QuakeEntityManifest {
movers: QuakeEntityManifestMover[];
teleporters: QuakeEntityManifestTeleporter[];
exits: QuakeEntityManifestExit[];
+ intermissions?: QuakeEntityManifestPoint[];
lights: QuakeEntityManifestLight[];
counters: QuakeEntityManifestTrigger[];
secrets: QuakeEntityManifestTrigger[];
@@ -267,6 +269,25 @@ export type QuakeSerializedPolygon = Omit & {
texture?: number | string;
};
+export interface QuakeRenderBundleAtlasResidencyPage {
+ index: number;
+ varName: string;
+ url: string;
+ bytes?: number;
+ width?: number;
+ height?: number;
+}
+
+export interface QuakeRenderBundleAtlasResidency {
+ version: 1;
+ mode: "pvs-pages";
+ pageSize: number;
+ pages: QuakeRenderBundleAtlasResidencyPage[];
+ leafPageIndexes: number[];
+ visibilityLeafPages: number[][];
+ visibilityLeafPrewarmPages: number[][];
+}
+
export interface QuakePreparedRenderBundle {
version: 1;
kind: "polycss-mesh";
@@ -293,6 +314,7 @@ export interface QuakePreparedRenderBundle {
polygonCount: number;
leafCount: number;
atlasLeafCount: number;
+ atlasResidency?: QuakeRenderBundleAtlasResidency;
}
export type QuakeRenderBundleLeafFrameStyle = [
diff --git a/test/cameraFeedbackFlow.test.mjs b/test/cameraFeedbackFlow.test.mjs
new file mode 100644
index 0000000..3d4c7a9
--- /dev/null
+++ b/test/cameraFeedbackFlow.test.mjs
@@ -0,0 +1,173 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { importTsModule } from "./importTsModule.mjs";
+
+const {
+ createQuakeCameraFeedbackFlow,
+} = await importTsModule("src/runtime/app/cameraFeedbackFlow.ts");
+
+test("weapon view punch clears to the player look base after look input during recoil", () => {
+ const previousPerformance = globalThis.performance;
+ const previousWindow = globalThis.window;
+ let nextFrameId = 1;
+ const frames = new Map();
+
+ Object.defineProperty(globalThis, "performance", {
+ configurable: true,
+ value: { now: () => 1000 },
+ });
+ Object.defineProperty(globalThis, "window", {
+ configurable: true,
+ value: {
+ cancelAnimationFrame: (frameId) => { frames.delete(frameId); },
+ requestAnimationFrame: (callback) => {
+ const frameId = nextFrameId++;
+ frames.set(frameId, callback);
+ return frameId;
+ },
+ },
+ });
+
+ try {
+ const scene = {
+ camera: {
+ perspectiveStyle: "900px",
+ state: {
+ rotX: 88,
+ rotY: 270,
+ },
+ update: ({ rotX, rotY }) => {
+ scene.camera.state.rotX = rotX;
+ scene.camera.state.rotY = rotY;
+ },
+ },
+ applyCamera: () => undefined,
+ };
+ let fireAnimations = 0;
+ const flow = createQuakeCameraFeedbackFlow({
+ canUseGameplayInput: () => true,
+ cameraPerspectiveStyle: () => "900px",
+ controls: {
+ getOrigin: () => [0, 0, 1.72],
+ },
+ hasCurrentScene: () => true,
+ isDisposed: () => false,
+ queueCrosshairTargetSync: () => undefined,
+ scene,
+ viewmodel: {
+ playFireAnimation: () => { fireAnimations++; },
+ syncTransform: () => undefined,
+ },
+ });
+
+ flow.playWeaponFireFeedback();
+ assert.equal(fireAnimations, 1);
+ assert.equal(scene.camera.state.rotX, 90);
+
+ scene.camera.state.rotX = 91;
+ flow.clearWeaponViewPunch();
+
+ assert.equal(scene.camera.state.rotX, 89);
+ assert.equal(frames.size, 0);
+ } finally {
+ if (previousPerformance === undefined) {
+ delete globalThis.performance;
+ } else {
+ Object.defineProperty(globalThis, "performance", {
+ configurable: true,
+ value: previousPerformance,
+ });
+ }
+ if (previousWindow === undefined) {
+ delete globalThis.window;
+ } else {
+ Object.defineProperty(globalThis, "window", {
+ configurable: true,
+ value: previousWindow,
+ });
+ }
+ }
+});
+
+test("weapon view punch does not reapply render origin policy to an already adjusted origin", () => {
+ const previousPerformance = globalThis.performance;
+ const previousWindow = globalThis.window;
+ let nextFrameId = 1;
+ const frames = new Map();
+
+ Object.defineProperty(globalThis, "performance", {
+ configurable: true,
+ value: { now: () => 1000 },
+ });
+ Object.defineProperty(globalThis, "window", {
+ configurable: true,
+ value: {
+ cancelAnimationFrame: (frameId) => { frames.delete(frameId); },
+ requestAnimationFrame: (callback) => {
+ const frameId = nextFrameId++;
+ frames.set(frameId, callback);
+ return frameId;
+ },
+ },
+ });
+
+ try {
+ const scene = {
+ camera: {
+ perspectiveStyle: "900px",
+ state: {
+ rotX: 88,
+ rotY: 270,
+ },
+ update: ({ rotX, rotY, target }) => {
+ scene.camera.state.rotX = rotX;
+ scene.camera.state.rotY = rotY;
+ scene.camera.state.target = target;
+ },
+ },
+ applyCamera: () => undefined,
+ };
+ const flow = createQuakeCameraFeedbackFlow({
+ canUseGameplayInput: () => true,
+ cameraPerspectiveStyle: () => "900px",
+ controls: {
+ getOrigin: () => [1, 2, 1.72],
+ },
+ hasCurrentScene: () => true,
+ isDisposed: () => false,
+ queueCrosshairTargetSync: () => undefined,
+ renderOriginPolicy: (origin) => [origin[0] + 10, origin[1], origin[2]],
+ scene,
+ viewmodel: {
+ playFireAnimation: () => undefined,
+ syncTransform: () => undefined,
+ },
+ });
+
+ flow.resetStepSmoothing([1, 2, 1.72]);
+ flow.applyAt([1, 2, 1.72], 88, 270);
+ assert.deepEqual(flow.currentRenderOrigin(), [11, 2, 1.72]);
+
+ flow.playWeaponFireFeedback();
+
+ assert.deepEqual(flow.currentRenderOrigin(), [11, 2, 1.72]);
+ } finally {
+ if (previousPerformance === undefined) {
+ delete globalThis.performance;
+ } else {
+ Object.defineProperty(globalThis, "performance", {
+ configurable: true,
+ value: previousPerformance,
+ });
+ }
+ if (previousWindow === undefined) {
+ delete globalThis.window;
+ } else {
+ Object.defineProperty(globalThis, "window", {
+ configurable: true,
+ value: previousWindow,
+ });
+ }
+ }
+});
diff --git a/test/intermissionFlow.test.mjs b/test/intermissionFlow.test.mjs
new file mode 100644
index 0000000..fcafbbf
--- /dev/null
+++ b/test/intermissionFlow.test.mjs
@@ -0,0 +1,303 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { Window } from "happy-dom";
+
+import { importTsModule } from "./importTsModule.mjs";
+
+const {
+ createQuakeIntermissionFlow,
+} = await importTsModule("src/runtime/app/intermissionFlow.ts");
+const {
+ createQuakeEntityActivationFlow,
+} = await importTsModule("src/runtime/app/entityActivationFlow.ts");
+const {
+ createQuakeLevelStatsFlow,
+ quakeLevelStatsTotalsForEntities,
+} = await importTsModule("src/runtime/app/levelStatsFlow.ts");
+const {
+ buildEntityManifest,
+} = await importTsModule("src/prepare/entities.ts");
+
+test("level stat totals count active monsters and trigger secrets only", () => {
+ assert.deepEqual(quakeLevelStatsTotalsForEntities([
+ { classname: "monster_grunt", index: 1, properties: { classname: "monster_grunt" } },
+ { classname: "monster_ogre", index: 2, properties: { classname: "monster_ogre", spawnflags: "256" } },
+ { classname: "trigger_secret", index: 3, properties: { classname: "trigger_secret" } },
+ { classname: "trigger_secret", index: 4, properties: { classname: "trigger_secret", spawnflags: "256" } },
+ { classname: "func_door_secret", index: 5, properties: { classname: "func_door_secret" } },
+ ]), {
+ monsters: 1,
+ secrets: 1,
+ });
+});
+
+test("entity manifest preserves info_intermission mangle", () => {
+ const manifest = buildEntityManifest([
+ {
+ classname: "info_intermission",
+ index: 12,
+ origin: { x: -112, y: 704, z: 56 },
+ properties: {
+ classname: "info_intermission",
+ mangle: "20 45 0",
+ origin: "-112 704 56",
+ },
+ },
+ ]);
+
+ assert.deepEqual(manifest.intermissions?.[0], {
+ classname: "info_intermission",
+ entityIndex: 12,
+ mangle: { x: 20, y: 45, z: 0 },
+ origin: { x: -112, y: 704, z: 56 },
+ spawnflags: 0,
+ });
+});
+
+test("level stats freeze at intermission completion", () => {
+ let now = 1000;
+ const stats = createQuakeLevelStatsFlow({ now: () => now });
+
+ stats.reset("e1m1", { monsters: 2, secrets: 1 });
+ stats.markMonsterKilled(10);
+ stats.markMonsterKilled(10);
+ stats.markSecret(20);
+ now = 61_000;
+
+ const frozen = stats.freeze();
+
+ assert.deepEqual(frozen, {
+ elapsedSeconds: 60,
+ mapName: "e1m1",
+ monstersKilled: 1,
+ secretsFound: 1,
+ totalMonsters: 2,
+ totalSecrets: 1,
+ });
+
+ stats.markMonsterKilled(11);
+ now = 90_000;
+ assert.deepEqual(stats.snapshot(), frozen);
+});
+
+test("intermission flow renders classic completion rows and clears them", () => {
+ const previousDocument = globalThis.document;
+ const window = new Window();
+ Object.defineProperty(globalThis, "document", {
+ configurable: true,
+ value: window.document,
+ });
+
+ try {
+ const root = document.createElement("div");
+ let renderedRoot = null;
+ const intermission = createQuakeIntermissionFlow({
+ renderBitmapText: (element) => { renderedRoot = element; },
+ root,
+ });
+
+ intermission.show({
+ elapsedSeconds: 65,
+ mapName: "e1m1",
+ monstersKilled: 3,
+ secretsFound: 1,
+ totalMonsters: 10,
+ totalSecrets: 2,
+ });
+
+ assert.equal(intermission.active(), true);
+ assert.equal(root.hidden, false);
+ assert.equal(root.textContent, "COMPLETEDTIME1:05SECRETS1/ 2KILLS3/10");
+ assert.equal(root.querySelector(".quake-intermission-scrim") instanceof window.HTMLElement, true);
+ assert.equal(root.querySelector(".quake-intermission-canvas") instanceof window.HTMLElement, true);
+ assert.equal(root.querySelectorAll(".quake-intermission-row").length, 3);
+ assert.equal(root.querySelector(".quake-intermission-complete-art")?.getAttribute("src"), "/q/intermission-complete.png");
+ assert.equal(root.querySelector(".quake-intermission-label-art")?.getAttribute("src"), "/q/intermission-labels.png");
+ assert.equal(root.querySelector(".quake-intermission-stats")?.style.getPropertyValue("--quake-intermission-label-x"), "20");
+ assert.equal(root.querySelector(".quake-intermission-stats")?.style.getPropertyValue("--quake-intermission-value-right"), "300");
+ assert.deepEqual(
+ [...root.querySelectorAll(".quake-intermission-value")].map((value) => value.dataset.value),
+ ["1:05", "1/ 2", "3/10"],
+ );
+ assert.equal(root.querySelectorAll(".quake-intermission-value-glyph").length, 11);
+ assert.equal(root.querySelectorAll(".quake-intermission-value-space").length, 0);
+ assert.equal(renderedRoot, root);
+
+ root.querySelector(".quake-intermission-complete-art")?.dispatchEvent(new window.Event("load"));
+ root.querySelector(".quake-intermission-label-art")?.dispatchEvent(new window.Event("load"));
+ assert.equal(root.querySelector(".quake-intermission-complete")?.classList.contains("quake-intermission-complete-source-ready"), true);
+ assert.equal(root.querySelector(".quake-intermission-stats")?.classList.contains("quake-intermission-label-source-ready"), true);
+
+ intermission.clear();
+
+ assert.equal(intermission.active(), false);
+ assert.equal(root.hidden, true);
+ assert.equal(root.children.length, 0);
+ } finally {
+ if (previousDocument === undefined) {
+ delete globalThis.document;
+ } else {
+ Object.defineProperty(globalThis, "document", {
+ configurable: true,
+ value: previousDocument,
+ });
+ }
+ }
+});
+
+test("level intermission input advance is gated by a minimum dwell", async () => {
+ const previousPerformance = globalThis.performance;
+ const previousWindow = globalThis.window;
+ let now = 1000;
+ let nextTimerId = 1;
+ const timers = new Map();
+ const loaded = [];
+ let shown = 0;
+ let syncedCamera = 0;
+
+ Object.defineProperty(globalThis, "performance", {
+ configurable: true,
+ value: { now: () => now },
+ });
+ Object.defineProperty(globalThis, "window", {
+ configurable: true,
+ value: {
+ clearTimeout: (timerId) => { timers.delete(timerId); },
+ setTimeout: (callback, ms) => {
+ const timerId = nextTimerId++;
+ timers.set(timerId, { callback, ms });
+ return timerId;
+ },
+ },
+ });
+
+ try {
+ const flow = createQuakeEntityActivationFlow({
+ addBodyClasses: () => undefined,
+ audio: { playEvent: () => undefined, playSound: () => undefined },
+ clearAttackInput: () => undefined,
+ currentCollisionWorld: () => null,
+ currentGameLogic: () => null,
+ entities: () => new Map(),
+ getOrigin: () => [0, 0, 0],
+ intermission: {
+ show: () => { shown++; },
+ syncCamera: () => { syncedCamera++; },
+ },
+ loadMap: async (mapName, options) => {
+ loaded.push({ mapName, options });
+ },
+ mapExists: (mapName) => mapName === "e1m2",
+ movers: {
+ activateEntity: () => false,
+ forceDoorsDownAfter: () => undefined,
+ get: () => null,
+ },
+ pickups: { syncCollision: () => undefined },
+ player: () => ({
+ clearLevelState: () => undefined,
+ currentOrigin: () => [0, 0, 0],
+ damage: () => false,
+ eyeHeight: () => 1,
+ push: () => undefined,
+ teleportTo: () => false,
+ }),
+ pointToPoly: (point) => [point.x, point.y, point.z],
+ publishWorldChanged: () => undefined,
+ shootables: {
+ activate: () => false,
+ destroy: () => false,
+ has: () => false,
+ triggerBossLightning: () => false,
+ },
+ syncCrosshairTarget: () => undefined,
+ syncSceneCamera: () => undefined,
+ syncTouchedTriggers: () => [],
+ targets: {
+ disableEntity: () => undefined,
+ entityIndexesFor: () => [],
+ fire: () => undefined,
+ isDisabled: () => false,
+ useTargets: () => false,
+ },
+ text: {
+ centerPrint: () => undefined,
+ clearCenterPrint: () => undefined,
+ hasUseTargetsMessageText: () => false,
+ setCenterPrint: () => undefined,
+ showDirectCenterPrintMessageText: () => false,
+ },
+ transitionSerialIncrement: () => undefined,
+ triggers: {
+ activateCounterEntity: () => undefined,
+ activateTeleporterEntity: () => false,
+ setActive: () => undefined,
+ },
+ viewmodel: {
+ clearFireAnimation: () => undefined,
+ syncTransform: () => undefined,
+ },
+ world: { syncVisibility: () => undefined },
+ });
+
+ flow.completeLevel({
+ classname: "trigger_changelevel",
+ index: 1,
+ properties: { map: "e1m2" },
+ });
+
+ assert.equal(shown, 1);
+ assert.equal(syncedCamera, 1);
+ assert.equal(timers.size, 1);
+ assert.equal([...timers.values()][0].ms, 3000);
+ assert.deepEqual(loaded, []);
+
+ assert.equal(flow.requestIntermissionAdvance(), true);
+ assert.equal(timers.size, 1);
+ assert.deepEqual(loaded, []);
+
+ now = 2001;
+ assert.equal(flow.requestIntermissionAdvance(), true);
+ await Promise.resolve();
+
+ assert.equal(timers.size, 0);
+ assert.deepEqual(loaded, [{
+ mapName: "e1m2",
+ options: { loadingStatus: "Loading", resumeGameplay: true },
+ }]);
+ assert.equal(flow.requestIntermissionAdvance(), false);
+
+ flow.completeLevel({
+ classname: "trigger_changelevel",
+ index: 2,
+ properties: { map: "end" },
+ });
+
+ assert.equal(shown, 2);
+ assert.equal(syncedCamera, 2);
+ assert.equal(timers.size, 0);
+ assert.equal(flow.isLevelLoadPending(), true);
+ assert.equal(flow.requestIntermissionAdvance(), true);
+ now = 5000;
+ assert.equal(flow.requestIntermissionAdvance(), true);
+ await Promise.resolve();
+ assert.deepEqual(loaded, [{
+ mapName: "e1m2",
+ options: { loadingStatus: "Loading", resumeGameplay: true },
+ }]);
+ } finally {
+ Object.defineProperty(globalThis, "performance", {
+ configurable: true,
+ value: previousPerformance,
+ });
+ if (previousWindow === undefined) {
+ delete globalThis.window;
+ } else {
+ Object.defineProperty(globalThis, "window", {
+ configurable: true,
+ value: previousWindow,
+ });
+ }
+ }
+});
Debug
/> + +
+
quakeSceneMount.isPointInPlayerView(point, QUAKE_MONSTER_MOUNT_VIEW_DOT_MIN),
leafIndexAt: world.leafIndexAt,
monsterRuntimeEnabled: () => QUAKE_MONSTER_RUNTIME_ENABLED && !QUAKE_MULTIPLAYER_ENABLED && !quakeEnemiesDisabled,
+ onDestroyed: (entity) => {
+ if (entity.classname.startsWith("monster_")) quakeLevelStats.markMonsterKilled(entity.index);
+ },
pointToPoly: quakeCameraView.pointToPoly,
shouldSpawn: shouldSpawnQuakeShootableForCurrentMode,
pixelate: world.pixelate,
@@ -1862,6 +1878,7 @@ quakePointerGameplay = createQuakePointerGameplayFlow({
pointerLockElement: () => document.pointerLockElement,
queueCrosshairTargetSync: queueQuakeCrosshairTargetSync,
renderSupersample: QUAKE_RENDER_SUPERSAMPLE,
+ requestIntermissionAdvance: requestQuakeIntermissionAdvance,
respawnPlayerFromDeath: respawnQuakePlayerFromDeath,
rotation: () => ({
rotX: scene.camera.state.rotX ?? 88,
@@ -2052,7 +2069,10 @@ const quakeLoading = createQuakeLoadingFlow({
trace: markQuakeTrace,
});
const quakeSceneMount = createQuakeSceneMountFlow({
- afterMountScene: startQuakeMultiplayerScene,
+ afterMountScene: () => {
+ resetQuakeLevelStatsForCurrentScene();
+ startQuakeMultiplayerScene();
+ },
audio,
beforeDisposeScene: () => stopQuakeMultiplayerScene("scene-dispose"),
clearPlayerDeath: clearQuakePlayerDeath,
@@ -2115,9 +2135,14 @@ quakeEntityActivation = createQuakeEntityActivationFlow({
currentGameLogic: () => currentResult?.gameLogic,
entities: () => entityByIndex,
getOrigin: () => controls.getOrigin(),
+ intermission: {
+ show: () => quakeIntermission.show(quakeLevelStats.freeze()),
+ syncCamera: syncQuakeIntermissionCamera,
+ },
loadMap: loadQuakeMap,
mapExists: quakeAssetCatalog.mapExists,
movers,
+ onSecretActivated: (entity) => quakeLevelStats.markSecret(entity.index),
pickups: getPickups(),
player: getPlayer,
pointToPoly: quakeCameraView.pointToPoly,
@@ -2129,6 +2154,7 @@ quakeEntityActivation = createQuakeEntityActivationFlow({
targets: targetSystem,
text: {
centerPrint: (message) => quakeTextPresentation.centerPrint(message),
+ clearCenterPrint: () => quakeTextPresentation.clearCenterPrint(),
hasUseTargetsMessageText: (entity) => quakeTextPresentation.hasUseTargetsMessageText(entity),
setCenterPrint: (message) => quakeTextPresentation.setCenterPrint(message),
showDirectCenterPrintMessageText: (entity) => quakeTextPresentation.showDirectCenterPrintMessageText(entity),
@@ -2433,9 +2459,19 @@ function clearQuakeLevelLoadTimer(): void {
}
function clearQuakeLevelComplete(): void {
+ quakeIntermission.clear();
quakePlayerLifecycle.clearLevelComplete();
}
+function requestQuakeIntermissionAdvance(): boolean {
+ return quakeEntityActivation.requestIntermissionAdvance();
+}
+
+function requestQuakeIntermissionAdvanceFromKey(event: KeyboardEvent): boolean {
+ if (event.code !== "Space" || quakeGameplayInput.isEditableTarget(event.target)) return false;
+ return requestQuakeIntermissionAdvance();
+}
+
function isQuakeDeathUnlockControlsEndTraceSuppressed(now = performance.now()): boolean {
return quakePlayerLifecycle.isDeathUnlockControlsEndTraceSuppressed(now);
}
@@ -3903,6 +3939,64 @@ function completeQuakeLevel(entity: QuakeEntity): void {
quakeEntityActivation.completeLevel(entity);
}
+function resetQuakeLevelStatsForCurrentScene(): void {
+ quakeLevelStats.reset(currentMapName, quakeLevelStatsTotalsForEntities(currentResult?.entities ?? []));
+}
+
+function syncQuakeIntermissionCamera(): void {
+ const point = quakeIntermissionPointForCurrentScene();
+ if (!point) return;
+ const origin = quakeCameraView.pointToPoly(point.origin);
+ const { rotX, rotY } = quakeIntermissionCameraRotation(point);
+ quakeCameraView.syncSceneCameraAt(origin, rotX, rotY);
+ shootables.syncVisibility(origin as [number, number, number], true);
+ world.syncVisibilityAt(origin as [number, number, number], true);
+ syncQuakeCrosshairTarget();
+}
+
+function quakeIntermissionPointForCurrentScene(): QuakeEntityManifestPoint | null {
+ const manifestPoint = currentResult?.entityManifest.intermissions?.[0];
+ if (manifestPoint) return manifestPoint;
+ const entity = currentResult?.entities
+ .filter((candidate) => candidate.classname.startsWith("info_intermission") && candidate.origin)
+ .sort((a, b) => a.index - b.index)[0];
+ if (!entity?.origin) return null;
+ return {
+ entityIndex: entity.index,
+ classname: entity.classname,
+ origin: entity.origin,
+ spawnflags: 0,
+ ...(entity.angle !== undefined ? { angle: entity.angle } : {}),
+ ...quakeEntityMangleProperties(entity),
+ ...(entity.properties.targetname ? { targetname: entity.properties.targetname } : {}),
+ };
+}
+
+function quakeIntermissionCameraRotation(point: QuakeEntityManifestPoint): { rotX: number; rotY: number } {
+ if (point.mangle) {
+ return {
+ rotX: 90 - point.mangle.x,
+ rotY: (180 + point.mangle.y + 360) % 360,
+ };
+ }
+ return {
+ rotX: 90,
+ rotY: (180 + (point.angle ?? 0) + 360) % 360,
+ };
+}
+
+function quakeEntityMangleProperties(entity: QuakeEntity): { mangle?: QuakeVertex } {
+ const mangle = quakeParseEntityVector(entity.properties.mangle);
+ return mangle ? { mangle } : {};
+}
+
+function quakeParseEntityVector(value: string | undefined): QuakeVertex | null {
+ if (!value) return null;
+ const parts = value.trim().split(/\s+/).map((part) => Number.parseFloat(part));
+ if (parts.length < 3 || parts.some((part) => !Number.isFinite(part))) return null;
+ return { x: parts[0], y: parts[1], z: parts[2] };
+}
+
function activateSolidTouch(touch: QuakeTouchedTrigger): void {
const entity = entityByIndex.get(touch.entityIndex);
if (entity?.classname === "func_button" && requestQuakeMultiplayerTouchIntent(entity.index, "touch")) return;
@@ -4288,6 +4382,7 @@ const quakeInput = createQuakeAppInputController({
menuIsMainOpen: () => menu.isMainMenuOpen(),
menuIsPanelOpen: () => menu.isMenuPanelOpen(),
parentKeyRelay: quakeGameplayInput.parentKeyRelay,
+ requestIntermissionAdvance: requestQuakeIntermissionAdvanceFromKey,
shouldOpenMainMenuOnEscape: shouldOpenQuakeMainMenuOnControlsEnd,
shouldPreventGameplayKeyDefault: quakeGameplayInput.shouldPreventGameplayKeyDefault,
showMainMenu: () => menu.showMainMenu(),
diff --git a/src/assets/id-software-logo.svg b/src/assets/id-software-logo.svg
new file mode 100644
index 0000000..bdfd208
--- /dev/null
+++ b/src/assets/id-software-logo.svg
@@ -0,0 +1 @@
+
diff --git a/src/prepare/assets.mjs b/src/prepare/assets.mjs
index 9a0189c..6dc99bb 100644
--- a/src/prepare/assets.mjs
+++ b/src/prepare/assets.mjs
@@ -87,6 +87,9 @@ const mainMenuOutputPath = path.join(quakeOutputDir, "main-menu.png");
const mainMenuPlaqueOutputPath = path.join(quakeOutputDir, "main-menu-plaque.png");
const mainMenuTitleOutputPath = path.join(quakeOutputDir, "main-menu-title.png");
const mainMenuMultiplayerOutputPath = path.join(quakeOutputDir, "main-menu-multiplayer.png");
+const intermissionCompleteOutputPath = path.join(quakeOutputDir, "intermission-complete.png");
+const intermissionLabelsOutputPath = path.join(quakeOutputDir, "intermission-labels.png");
+const intermissionNumbersOutputPath = path.join(quakeOutputDir, "intermission-numbers.png");
const mainMenuActiveOutputPath = path.join(quakeOutputDir, "main-menu-active.png");
const mainMenuActiveOutputPaths = [
mainMenuActiveOutputPath,
@@ -231,7 +234,7 @@ const QUAKE_MAIN_MENU_LEVEL_LABEL = "LEVEL SELECT";
const QUAKE_MAIN_MENU_LEVEL_LABEL_SCALE = 2;
const QUAKE_PICKUP_MODEL_SCALE = QUAKE_UNIT_SCALE;
const QUAKE_WEAPON_MODEL_PIVOT = parseQuakeWeaponModelPivot(process.env.QUAKE_WEAPON_MODEL_PIVOT);
-const QUAKE_ENEMY_ALIAS_MODEL_RENDER_SCALE = 4;
+const QUAKE_ENEMY_ALIAS_MODEL_RENDER_SCALE = 8;
const QUAKE_PLAYER_ALIAS_MODEL_RENDER_SCALE = 4;
const QUAKE_ANIMATION_FRAME_SET_MIN_COMMON_LEAF_RATIO = 0.95;
const QUAKE_ALIAS_MERGE_MAX_NONPLANAR_DISTANCE = 0.03;
@@ -848,6 +851,9 @@ try {
await writeFile(mainMenuPlaqueOutputPath, await buildPakQpicCropPng(uiAssets, "gfx/qplaque.lmp", 0, 0, 32, 144));
await writeFile(mainMenuTitleOutputPath, await buildPakQpicCropPng(uiAssets, "gfx/ttl_main.lmp", 0, 0, 96, 24));
await writeFile(mainMenuMultiplayerOutputPath, await buildQuakeMainMenuMultiplayerPng(uiAssets));
+ await writeFile(intermissionCompleteOutputPath, await buildPakQpicPng(uiAssets, "gfx/complete.lmp"));
+ await writeFile(intermissionLabelsOutputPath, await buildPakQpicPng(uiAssets, "gfx/inter.lmp"));
+ await writeFile(intermissionNumbersOutputPath, await buildQuakeIntermissionNumbersPng(uiAssets));
});
const menuTitlePaletteColors = buildQuakeMenuTitlePaletteColors(uiAssets);
const mainMenuActivePngs = await buildQuakeMainMenuActivePngs(uiAssets);
@@ -940,6 +946,9 @@ try {
console.log(`Wrote ${path.relative(projectRoot, mainMenuPlaqueOutputPath)}`);
console.log(`Wrote ${path.relative(projectRoot, mainMenuTitleOutputPath)}`);
console.log(`Wrote ${path.relative(projectRoot, mainMenuMultiplayerOutputPath)}`);
+ console.log(`Wrote ${path.relative(projectRoot, intermissionCompleteOutputPath)}`);
+ console.log(`Wrote ${path.relative(projectRoot, intermissionLabelsOutputPath)}`);
+ console.log(`Wrote ${path.relative(projectRoot, intermissionNumbersOutputPath)}`);
for (const outputPath of mainMenuActiveOutputPaths) {
console.log(`Wrote ${path.relative(projectRoot, outputPath)}`);
}
@@ -2873,6 +2882,33 @@ async function buildQuakeHudNumbersPng(assets, options = {}) {
}).png().toBuffer();
}
+async function buildQuakeIntermissionNumbersPng(assets) {
+ const qpics = [
+ "num_0",
+ "num_1",
+ "num_2",
+ "num_3",
+ "num_4",
+ "num_5",
+ "num_6",
+ "num_7",
+ "num_8",
+ "num_9",
+ "num_colon",
+ "num_slash",
+ "num_minus",
+ ];
+ const width = 24 * qpics.length;
+ const height = 24;
+ const rgba = Buffer.alloc(width * height * 4);
+ for (let index = 0; index < qpics.length; index++) {
+ drawWadQpicTo(rgba, assets, qpics[index], index * 24, 0, width, height, QUAKE_HUD_TRANSPARENT);
+ }
+ return sharp(rgba, {
+ raw: { width, height, channels: 4 },
+ }).png().toBuffer();
+}
+
function tintQuakeHudDamageNumbers(rgba) {
for (let index = 0; index < rgba.length; index += 4) {
if (rgba[index + 3] === 0) continue;
diff --git a/src/prepare/deterministicAtlas.mjs b/src/prepare/deterministicAtlas.mjs
index 1aed1e5..3117ca1 100644
--- a/src/prepare/deterministicAtlas.mjs
+++ b/src/prepare/deterministicAtlas.mjs
@@ -32,6 +32,7 @@ const BSP_LUMP_COUNT = 15;
const BSP_HEADER_SIZE = 4 + BSP_LUMP_COUNT * 8;
const QUAKE_PLAYER_MINS_Z = -24;
const QUAKE_DETERMINISTIC_ATLAS_PAGE_PADDING = 1;
+const QUAKE_DETERMINISTIC_ATLAS_PVS_PACK_CAPACITY_RATIO = 0.955;
const QUAKE_DETERMINISTIC_ATLAS_PAGE_SIZE = normalizeDeterministicAtlasPageSize(
process.env.QUAKE_DETERMINISTIC_ATLAS_PAGE_SIZE,
);
@@ -321,7 +322,7 @@ export async function replaceQuakeRenderBundleWorldAtlas({
}
});
const pages = withDeterministicAtlasTimingSync(timing, "atlas.packPages", () =>
- packDeterministicAtlasTiles(atlasTiles));
+ packDeterministicAtlasTiles(atlasTiles, { visibility }));
const coverageFallbackLeaves = tiles.reduce((total, tile) => total + (tile.coverageFallback ? 1 : 0), 0);
const derivedUvAffineLeaves = tiles.reduce((total, tile) => total + (tile.derivedUvAffine ? 1 : 0), 0);
const mergedSourceLeaves = tiles.reduce((total, tile) => total + (tile.mergedSourceFaces > 1 ? 1 : 0), 0);
@@ -392,6 +393,14 @@ export async function replaceQuakeRenderBundleWorldAtlas({
await withDeterministicAtlasTiming(timing, "mesh.compactAssets", () =>
compactRenderBundleBackgroundAssets(renderBundle, outputDir, publicPath));
completeDeterministicRenderBundleAssetUrls(renderBundle, leafImageTiles, tiles);
+ const atlasResidency = await withDeterministicAtlasTiming(timing, "atlas.residency", () =>
+ buildDeterministicAtlasResidency(renderBundle, visibility, outputDir, publicPath));
+ if (atlasResidency) {
+ renderBundle.atlasResidency = atlasResidency;
+ renderBundle.meshHtml = stripRenderBundleBackgroundVars(renderBundle.meshHtml);
+ } else {
+ delete renderBundle.atlasResidency;
+ }
const oldBytes = await withDeterministicAtlasTiming(timing, "oldAssetScan", () =>
referencedAssetBytes(originalAssetUrls, outputDir, publicPath));
@@ -418,6 +427,7 @@ export async function replaceQuakeRenderBundleWorldAtlas({
skipSamples: serializeSkipSamples(skipSamples),
imagePolicyBuckets: Object.fromEntries([...imagePolicyBuckets.entries()].sort()),
oldAtlasBytesStillReferenced: oldBytes,
+ ...(atlasResidency ? { atlasResidencyPageCount: atlasResidency.pages.length } : {}),
};
logDeterministicAtlasTiming(timing, stats);
return stats;
@@ -446,6 +456,114 @@ function completeDeterministicRenderBundleAssetUrls(renderBundle, leafImageTiles
renderBundle.assetUrlsComplete = true;
}
+async function buildDeterministicAtlasResidency(renderBundle, visibility, outputDir, publicPath) {
+ if (!visibility?.metadata?.leaves?.length || !Array.isArray(visibility.candidates)) return null;
+ const leafPageIndexes = renderBundleLeafPageIndexes(renderBundle.meshHtml, renderBundle.leafMetadata.length);
+ const usedPageIndexes = [...new Set(leafPageIndexes.filter((index) => Number.isInteger(index) && index >= 0))]
+ .sort((a, b) => a - b);
+ if (!usedPageIndexes.length) return null;
+
+ const sourceFaceToPages = new Map();
+ for (let leafIndex = 0; leafIndex < leafPageIndexes.length; leafIndex++) {
+ const pageIndex = leafPageIndexes[leafIndex];
+ if (!Number.isInteger(pageIndex) || pageIndex < 0) continue;
+ const renderFaceIndex = renderBundle.leafMetadata[leafIndex]?.f;
+ if (!Number.isInteger(renderFaceIndex)) continue;
+ for (const sourceFaceIndex of visibility.candidates[renderFaceIndex]?.sourceFaceIndices ?? []) {
+ let pages = sourceFaceToPages.get(sourceFaceIndex);
+ if (!pages) {
+ pages = new Set();
+ sourceFaceToPages.set(sourceFaceIndex, pages);
+ }
+ pages.add(pageIndex);
+ }
+ }
+
+ const maxLeafIndex = visibility.metadata.leaves.reduce((max, leaf) => Math.max(max, leaf.leafIndex), 0);
+ const visibilityLeafPages = Array.from({ length: maxLeafIndex + 1 }, () => []);
+ const visibilityLeafPrewarmPages = Array.from({ length: maxLeafIndex + 1 }, () => []);
+ const pagesByLeaf = new Map();
+ for (const leaf of visibility.metadata.leaves) {
+ const pages = new Set();
+ for (const sourceFaceIndex of leaf.visibleFaceIndexes ?? []) {
+ for (const pageIndex of sourceFaceToPages.get(sourceFaceIndex) ?? []) pages.add(pageIndex);
+ }
+ const list = [...pages].sort((a, b) => a - b);
+ visibilityLeafPages[leaf.leafIndex] = list;
+ pagesByLeaf.set(leaf.leafIndex, list);
+ }
+ for (const leaf of visibility.metadata.leaves) {
+ const prewarm = new Set(pagesByLeaf.get(leaf.leafIndex) ?? []);
+ for (const adjacentLeafIndex of leaf.adjacentLeafIndexes ?? []) {
+ for (const pageIndex of pagesByLeaf.get(adjacentLeafIndex) ?? []) prewarm.add(pageIndex);
+ }
+ visibilityLeafPrewarmPages[leaf.leafIndex] = [...prewarm].sort((a, b) => a - b);
+ }
+
+ const pages = [];
+ for (const index of usedPageIndexes) {
+ const url = renderBundle.assetUrls[index];
+ if (!url) continue;
+ const outputPath = renderBundleAssetOutputPath(url, outputDir, publicPath);
+ let bytes;
+ let width;
+ let height;
+ if (outputPath) {
+ try {
+ const fileStat = await stat(outputPath);
+ bytes = fileStat.size;
+ const metadata = await sharp(outputPath).metadata();
+ width = metadata.width;
+ height = metadata.height;
+ } catch {
+ bytes = undefined;
+ }
+ }
+ pages.push({
+ index,
+ varName: `--bg${index}`,
+ url,
+ ...(Number.isFinite(bytes) ? { bytes } : {}),
+ ...(Number.isFinite(width) ? { width } : {}),
+ ...(Number.isFinite(height) ? { height } : {}),
+ });
+ }
+ if (!pages.length) return null;
+ return {
+ version: 1,
+ mode: "pvs-pages",
+ pageSize: QUAKE_DETERMINISTIC_ATLAS_PAGE_SIZE,
+ pages,
+ leafPageIndexes,
+ visibilityLeafPages,
+ visibilityLeafPrewarmPages,
+ };
+}
+
+function renderBundleLeafPageIndexes(html, expectedLeafCount) {
+ const leafPageIndexes = [];
+ for (const match of String(html ?? "").matchAll(/