Download 404.html from LostBeard/spawngen: direct link, hf CLI and curl.
- Browser
- Download file 15.7 kB
-
https://huggingface.co/spaces/LostBeard/spawngen/resolve/main/404.html
- Command line
-
hf download hf://spaces/LostBeard/spawngen/404.html
-
curl -L -o 404.html https://huggingface.co/spaces/LostBeard/spawngen/resolve/main/404.html
15.7 kB
| <html lang="en"> | |
| <head> | |
| <meta charset="utf-8" /> | |
| <meta name="viewport" content="width=device-width, initial-scale=1.0" /> | |
| <title>SpawnGen Studio</title> | |
| <base href="/" /> | |
| <link rel="icon" href="data:," /> | |
| <link rel="stylesheet" href="css/app.css" /> | |
| </head> | |
| <body> | |
| <div id="app"> | |
| <div class="boot">Loading SpawnGen Studio...</div> | |
| </div> | |
| <div id="blazor-error-ui"> | |
| An unhandled error has occurred. | |
| <a href="." class="reload">Reload</a> | |
| <span class="dismiss">x</span> | |
| </div> | |
| <script> | |
| // Lets files be dropped on the editor: they go to the page (OnFileDropped) as bytes. | |
| window.spawngenEnableDrop = function (dotnetRef, selector) { | |
| const el = document.querySelector(selector); | |
| el.addEventListener("dragover", e => e.preventDefault()); | |
| el.addEventListener("drop", async e => { | |
| e.preventDefault(); | |
| const node = e.dataTransfer.getData("text/spawngen-node"); | |
| if (node) { const r = el.getBoundingClientRect(); await dotnetRef.invokeMethodAsync("OnNodeDropped", node, e.clientX - r.left, e.clientY - r.top); return; } | |
| for (const f of e.dataTransfer.files) | |
| await dotnetRef.invokeMethodAsync("OnFileDropped", f.name, new Uint8Array(await f.arrayBuffer())); | |
| }); | |
| }; | |
| // A node dragged out of the library carries its class name. | |
| document.addEventListener("dragstart", e => { | |
| const n = e.target.closest && e.target.closest("[data-node]"); | |
| if (n) { e.dataTransfer.setData("text/spawngen-node", n.dataset.node); e.dataTransfer.effectAllowed = "copy"; } | |
| }); | |
| // The mask editor: paint over a picture, get it back as a PNG whose painted pixels are transparent (what Load Image turns into its mask). | |
| // Resolves with the PNG bytes, or null when cancelled or the picture cannot be read. | |
| window.spawngenMaskEditor = function (imageUrl) { | |
| return new Promise(async resolve => { | |
| const img = new Image(); | |
| img.src = imageUrl; | |
| try { await img.decode(); } catch (e) { resolve(null); return; } | |
| const w = img.naturalWidth, h = img.naturalHeight; | |
| if (!w || !h) { resolve(null); return; } | |
| const root = document.createElement("div"); | |
| root.className = "maskeditor"; | |
| root.innerHTML = '<div class="me-bar"><span>Mask editor</span>' + | |
| '<label>Brush <input class="me-size" type="range" min="2" max="200" value="40"></label>' + | |
| '<button class="me-mode" data-mode="paint">Paint</button><button class="me-mode" data-mode="erase">Erase</button>' + | |
| '<button class="me-clear">Clear</button><button class="me-invert">Invert</button>' + | |
| '<span class="me-spacer"></span><button class="me-cancel">Cancel</button><button class="me-save">Save</button></div>' + | |
| '<div class="me-stage"><div class="me-stack"><canvas class="me-base"></canvas><canvas class="me-mask"></canvas></div></div>'; | |
| document.body.appendChild(root); | |
| const base = root.querySelector(".me-base"), mask = root.querySelector(".me-mask"); | |
| base.width = mask.width = w; base.height = mask.height = h; | |
| const bctx = base.getContext("2d"), mctx = mask.getContext("2d"); | |
| bctx.drawImage(img, 0, 0); | |
| // An existing mask (transparent pixels of the picture) comes back as paint. | |
| const pix = bctx.getImageData(0, 0, w, h); | |
| const init = mctx.createImageData(w, h); | |
| for (let i = 0; i < pix.data.length; i += 4) { | |
| if (pix.data[i + 3] < 128) { init.data[i] = 255; init.data[i + 1] = 59; init.data[i + 2] = 59; init.data[i + 3] = 255; } | |
| pix.data[i + 3] = 255; | |
| } | |
| bctx.putImageData(pix, 0, 0); | |
| mctx.putImageData(init, 0, 0); | |
| let mode = "paint", drawing = false, last = null; | |
| const modes = root.querySelectorAll(".me-mode"); | |
| const setMode = m => { mode = m; modes.forEach(b => b.classList.toggle("on", b.dataset.mode === m)); }; | |
| setMode("paint"); | |
| modes.forEach(b => b.onclick = () => setMode(b.dataset.mode)); | |
| const size = root.querySelector(".me-size"); | |
| const at = e => { const r = mask.getBoundingClientRect(); return { x: (e.clientX - r.left) * w / r.width, y: (e.clientY - r.top) * h / r.height }; }; | |
| const stroke = (a, b) => { | |
| mctx.globalCompositeOperation = mode === "erase" ? "destination-out" : "source-over"; | |
| mctx.strokeStyle = "#ff3b3b"; mctx.fillStyle = "#ff3b3b"; | |
| mctx.lineWidth = +size.value; mctx.lineCap = "round"; mctx.lineJoin = "round"; | |
| mctx.beginPath(); mctx.moveTo(a.x, a.y); mctx.lineTo(b.x + 0.01, b.y); mctx.stroke(); | |
| }; | |
| mask.onpointerdown = e => { drawing = true; mask.setPointerCapture(e.pointerId); last = at(e); stroke(last, last); }; | |
| mask.onpointermove = e => { if (!drawing) return; const p = at(e); stroke(last, p); last = p; }; | |
| mask.onpointerup = mask.onpointercancel = () => { drawing = false; }; | |
| root.querySelector(".me-clear").onclick = () => mctx.clearRect(0, 0, w, h); | |
| root.querySelector(".me-invert").onclick = () => { | |
| const d = mctx.getImageData(0, 0, w, h); | |
| for (let i = 0; i < d.data.length; i += 4) { const on = d.data[i + 3] > 127; d.data[i] = 255; d.data[i + 1] = 59; d.data[i + 2] = 59; d.data[i + 3] = on ? 0 : 255; } | |
| mctx.putImageData(d, 0, 0); | |
| }; | |
| const finish = result => { document.removeEventListener("keydown", onKey); root.remove(); resolve(result); }; | |
| const onKey = e => { if (e.key === "Escape") { e.preventDefault(); finish(null); } }; | |
| document.addEventListener("keydown", onKey); | |
| root.querySelector(".me-cancel").onclick = () => finish(null); | |
| root.querySelector(".me-save").onclick = async () => { | |
| const out = document.createElement("canvas"); out.width = w; out.height = h; | |
| const octx = out.getContext("2d"); | |
| octx.drawImage(base, 0, 0); | |
| octx.globalCompositeOperation = "destination-out"; | |
| // Anything painted by more than half counts as masked: the soft edge of a stroke is not a half-transparent hole. | |
| const d = mctx.getImageData(0, 0, w, h); | |
| for (let i = 0; i < d.data.length; i += 4) d.data[i + 3] = d.data[i + 3] > 127 ? 255 : 0; | |
| const tmp = document.createElement("canvas"); tmp.width = w; tmp.height = h; | |
| tmp.getContext("2d").putImageData(d, 0, 0); | |
| octx.drawImage(tmp, 0, 0); | |
| out.toBlob(async blob => finish(blob ? new Uint8Array(await blob.arrayBuffer()) : null), "image/png"); | |
| }; | |
| }); | |
| }; | |
| // Browser storage for the open workflows (tabs, autosave). It can be missing or full: every call is allowed to fail quietly. | |
| window.spawngenStoreGet = function (key) { try { return localStorage.getItem(key); } catch (e) { return null; } }; | |
| window.spawngenSetTheme = function (id) { document.documentElement.dataset.theme = id === 'light' ? 'light' : 'dark'; }; | |
| // Applied before the app boots, so a light page does not flash dark first. | |
| try { window.spawngenSetTheme(JSON.parse(localStorage.getItem('spawngen.settings') || '{}').Palette); } catch (e) { } | |
| window.spawngenStoreSet = function (key, value) { try { localStorage.setItem(key, value); return true; } catch (e) { return false; } }; | |
| // The workflow library when no server serves the Studio: files in IndexedDB (database spawngen-userdata, store files, {path, text, modified, | |
| // created}). Each call is one transaction; results are strings ("done", "exists", "missing") or JSON text. | |
| window.spawngenFiles = (function () { | |
| let db = null; | |
| function open() { | |
| return db ??= new Promise((resolve, reject) => { | |
| const r = indexedDB.open("spawngen-userdata", 1); | |
| r.onupgradeneeded = () => r.result.createObjectStore("files", { keyPath: "path" }); | |
| r.onsuccess = () => resolve(r.result); | |
| r.onerror = () => { db = null; reject(r.error); }; | |
| }); | |
| } | |
| async function run(mode, body) { | |
| const store = (await open()).transaction("files", mode).objectStore("files"); | |
| return new Promise((resolve, reject) => { | |
| store.transaction.onerror = () => reject(store.transaction.error); | |
| body(store, resolve); | |
| }); | |
| } | |
| const get = (store, path, then) => { const r = store.get(path); r.onsuccess = () => then(r.result ?? null); }; | |
| return { | |
| list: () => run("readonly", (s, done) => { | |
| const r = s.getAll(); | |
| r.onsuccess = () => done(JSON.stringify(r.result.map(f => ({ path: f.path, size: new Blob([f.text]).size, modified: f.modified })))); | |
| }), | |
| read: path => run("readonly", (s, done) => get(s, path, f => done(f ? f.text : null))), | |
| write: (path, text, overwrite) => run("readwrite", (s, done) => get(s, path, old => { | |
| if (old && !overwrite) { done("exists"); return; } | |
| const now = Date.now(); | |
| s.put({ path, text, modified: now, created: old ? old.created : now }).onsuccess = () => done("done"); | |
| })), | |
| move: (from, to, overwrite) => run("readwrite", (s, done) => get(s, from, f => { | |
| if (!f) { done("missing"); return; } | |
| if (from === to) { done("done"); return; } | |
| get(s, to, old => { | |
| if (old && !overwrite) { done("exists"); return; } | |
| s.put({ ...f, path: to }); | |
| s.delete(from).onsuccess = () => done("done"); | |
| }); | |
| })), | |
| remove: path => run("readwrite", (s, done) => get(s, path, f => { | |
| if (!f) { done("missing"); return; } | |
| s.delete(path).onsuccess = () => done("done"); | |
| })), | |
| }; | |
| })(); | |
| // Ctrl+O: the toolbar's Open file picker (called while the key press still counts as the user's action). | |
| window.spawngenOpenWorkflowFile = function () { | |
| const input = document.querySelector('.toolbar input[type=file][accept=".json,.png"]'); | |
| if (input) input.click(); | |
| }; | |
| // Plays an animated picture (Save Animated WEBP / PNG, a GIF) on a canvas of its own, which the node canvas draws every frame: a canvas | |
| // drawImage of an animated <img> shows only its first frame (the HTML spec's rule; TJ 2026-11-19: the LTX example's WEBP sat still). | |
| // WebCodecs' ImageDecoder decodes one frame at a time, so only one frame is held. Returns null where ImageDecoder is missing; the canvas | |
| // stays 0 x 0 for a still picture or a type the browser cannot decode (the caller then shows the <img> as before). | |
| window.spawngenAnimate = function (url) { | |
| if (typeof ImageDecoder === "undefined") return null; | |
| const canvas = document.createElement("canvas"); | |
| canvas.width = 0; canvas.height = 0; | |
| (async () => { | |
| const blob = await (await fetch(url)).blob(); | |
| if (!blob.type || !(await ImageDecoder.isTypeSupported(blob.type))) return; | |
| const decoder = new ImageDecoder({ data: blob.stream(), type: blob.type }); | |
| try { | |
| await decoder.tracks.ready; | |
| const track = decoder.tracks.selectedTrack; | |
| if (!track || !track.animated) return; | |
| await decoder.completed; | |
| const ctx = canvas.getContext("2d"); | |
| for (let index = 0; !canvas.spawngenStop; index = (index + 1) % track.frameCount) { | |
| const frame = (await decoder.decode({ frameIndex: index })).image; | |
| if (canvas.width !== frame.displayWidth || canvas.height !== frame.displayHeight) { canvas.width = frame.displayWidth; canvas.height = frame.displayHeight; } | |
| ctx.drawImage(frame, 0, 0); | |
| const ms = frame.duration ? frame.duration / 1000 : 100; | |
| frame.close(); | |
| await new Promise(r => setTimeout(r, Math.max(16, ms))); | |
| } | |
| } finally { decoder.close(); } | |
| })().catch(e => console.warn("spawngenAnimate", e)); | |
| return canvas; | |
| }; | |
| window.spawngenAnimateStop = function (canvas) { if (canvas) canvas.spawngenStop = true; }; | |
| // Saves a picture (a data, blob or same-origin URL) as a file download. | |
| window.spawngenDownloadUrl = function (name, url) { | |
| const a = document.createElement("a"); | |
| a.href = url; a.download = name; document.body.appendChild(a); a.click(); a.remove(); | |
| }; | |
| // Saves text as a file download (the workflow JSON). | |
| window.spawngenDownload = function (name, text) { | |
| const url = URL.createObjectURL(new Blob([text], { type: "application/json" })); | |
| const a = document.createElement("a"); | |
| a.href = url; a.download = name; document.body.appendChild(a); a.click(); a.remove(); | |
| setTimeout(() => URL.revokeObjectURL(url), 1000); | |
| }; | |
| </script> | |
| <script src="js/glbviewer.js"></script> | |
| <script src="_framework/blazor.webassembly.js" autostart="false"></script> | |
| <script> | |
| // GitHub Pages serves files exactly as stored: off localhost every boot resource except the JS modules is fetched as its precompressed .gz copy | |
| // and inflated by the browser's own DecompressionStream. The AOT runtime (dotnet.native.wasm) is over 100 MB raw and about 3.5x smaller this way. | |
| Blazor.start({ | |
| loadBootResource: function (type, name, defaultUri, integrity) { | |
| if (type === 'dotnetjs' || type === 'configuration' || type === 'manifest' || location.hostname === 'localhost' || typeof DecompressionStream === 'undefined') | |
| return null; | |
| return (async function () { | |
| const r = await fetch(defaultUri + '.gz'); | |
| if (!r.ok) return fetch(defaultUri); // no compressed copy: the original | |
| const contentType = type === 'dotnetwasm' ? 'application/wasm' : 'application/octet-stream'; | |
| // a server that already sent it with Content-Encoding: gzip had the browser inflate it | |
| const body = r.headers.get('content-encoding') ? r.body : r.body.pipeThrough(new DecompressionStream('gzip')); | |
| return new Response(body, { headers: { 'content-type': contentType } }); | |
| })(); | |
| } | |
| }); | |
| </script> | |
| </body> | |
| </html> | |