A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
feat(cook): textures encode on every core
esengine4d7f218f9dc4
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 89f836ce8..fdb575fcc 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -22,6 +22,7 @@ published separately; it ships inside the editor.- A connected development build can be asked for the whole frame it composited — every camera and the UI over them — as the player sees it: `device_screenshot` returns it as a PNG, read back by the device's own engine. The frame debugger's replay shows one pass of a captured frame.- Web and mini-game packages decode KTX2 textures under Zstandard supercompression, as the native host already did. UASTC textures made outside Estella usually are, and every one failed to decode; the transcoder module grows by about 21KB compressed, in packages that carry KTX2.- A KTX2 texture made outside Estella with a single level ships with a mip chain: the cook encodes the levels below it and keeps the file's own level 0 byte for byte, so it no longer shimmers into the distance. Bistro's 2048² textures each took about 0.3 s; the package grows by the chain's third.+- Exporting compresses textures on every core the machine lets it use instead of one: the encoder runs on worker threads, and the pool widens only while the memory its workers have measured fits in half the machine's. The ORCA Bistro exterior's first web export on a 20-thread Windows machine took 5 min 25 s; one core had managed 184 of its 200 textures in 47 minutes. The encoded bytes are the same either way. `ESTELLA_ENCODER_WORKERS` sets the width, and 0 encodes on the calling thread.- Exporting again is fast when the art has not changed: the cook keeps what it encoded under `.esengine/cache/cook/`, keyed by the source, the settings and the encoder. Re-exporting Bistro took 24 s against 131 s the first time.- A scene's preload logs what each asset type cost it — how many, their summed load time and the slowest one — and `preloadSceneAssets` returns the same as `timings` and `wallMs`. Bistro on a Windows machine: 132 materials 54 s, 107 textures 47 s and 1505 meshes 45 s of load time over 24 s of wall time.- KTX2 textures on the web and in the editor transcode on worker threads instead of the main thread, one to four of them by the machine's cores. Bistro's assets loaded in 14 s instead of 24 s on a Windows machine, and the page stays responsive while they do. A realm with no workers (a mini-game host) transcodes on the main thread as before, and so does one whose workers fail, which says so once.diff --git a/build-tools/basis/encoder.d.mts b/build-tools/basis/encoder.d.mtsindex bf4df632b..9c2eead59 100644--- a/build-tools/basis/encoder.d.mts+++ b/build-tools/basis/encoder.d.mts@@ -32,6 +32,8 @@ export interface EncodeOptions {}export const ENCODER_WASM: string;+/** How many calls the encoder runs at once (its worker pool's width). */+export const ENCODER_PARALLELISM: number;export interface RgbaResult {width: number;diff --git a/build-tools/basis/encoder.mjs b/build-tools/basis/encoder.mjsindex 6203c82a5..a77a89abd 100644--- a/build-tools/basis/encoder.mjs+++ b/build-tools/basis/encoder.mjs@@ -1,125 +1,153 @@// SPDX-License-Identifier: Apache-2.0// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team/**- * PNG/JPG/RGBA → KTX2 (Basis Universal) encoder for the build-time asset cook,- * over the vendored encoder wasm (see README.md). The runtime transcoder is a- * separate side module (sdk/src/asset/basisTranscoder.ts), and reads zstd- * supercompression whether or not this emits it.+ * PNG/JPG/RGBA → KTX2 (Basis Universal) for the asset cook. The wasm is single-+ * threaded, so concurrent calls run on worker threads, one instance each: up to+ * the cores this process may use, while the heaps they report fit the budget.+ * `ESTELLA_ENCODER_WORKERS` sets the width; 0 encodes on the calling thread.*/-import { createRequire } from 'node:module';+import { Worker } from 'node:worker_threads';import { fileURLToPath } from 'node:url';+import os from 'node:os';import path from 'node:path';+import * as core from './encoderCore.mjs';-const require = createRequire(import.meta.url);-const DIR = path.dirname(fileURLToPath(import.meta.url));+export { ENCODER_WASM, ImageType } from './encoderCore.mjs';-/** The encoder binary; what an encode cache keys "which encoder" by. */-export const ENCODER_WASM = path.join(DIR, 'basis_encoder.wasm');+// A path, not `new URL('./…', import.meta.url)`: bundlers rewrite that pattern as an+// asset (Vite made it an http URL), and a Worker given one never starts nor fails.+const WORKER = path.join(path.dirname(fileURLToPath(import.meta.url)), 'encoderWorker.mjs');-/** The wasm module is heavy to instantiate (~MBs); load + init it once. */-let modulePromise = null;-function loadModule() {- if (!modulePromise) {- const BASIS = require(path.join(DIR, 'basis_encoder.cjs'));- modulePromise = BASIS({ locateFile: (f) => path.join(DIR, f) }).then((m) => {- m.initializeBasis();- return m;- });- }- return modulePromise;-}--/** PNG IHDR width/height (big-endian u32 at byte offsets 16 / 20). */-function pngDimensions(png) {- const dv = new DataView(png.buffer, png.byteOffset, png.byteLength);- return { width: dv.getUint32(16), height: dv.getUint32(20) };+function workerLimit() {+ const set = process.env.ESTELLA_ENCODER_WORKERS;+ const n = set === undefined || set === '' ? os.availableParallelism() : Number(set);+ return Number.isInteger(n) && n >= 0 ? n : 1;}-export const ImageType = { PNG: 'png', JPG: 'jpg', RGBA: 'rgba' };+/** How many calls can run at once — what a caller sizes its own in-flight work by. */+export const ENCODER_PARALLELISM = Math.max(1, workerLimit());/**- * Encode a source image to KTX2 bytes; `source` and `opts` are typed in encoder.d.mts.- * yFlip defaults on: uncompressed uploads are row-flipped at load, compressed- * blocks cannot be, so the orientation is baked in here or the texture mirrors.+ * Half of physical memory, not `os.freemem()`: on macOS free memory leaves out+ * the reclaimable cache and reads a few hundred MB on a machine with gigabytes+ * to spare, which would hold the pool at one worker.*/-export async function encodeToKtx2(source, opts = {}) {- const {- mode = 'uastc', mipmaps = true, srgb = true,- perceptual = true, quality = 128, normalMap = false, yFlip = true, supercompress = false,- uastcLevel,- } = opts;- const m = await loadModule();+const HEAP_BUDGET = os.totalmem() / 2;- let width = source.width ?? 0;- let height = source.height ?? 0;- if (source.type === ImageType.PNG && (!width || !height)) {- ({ width, height } = pngDimensions(source.data));+class EncoderPool {+ /** @type {{ worker: Worker, job: object | null, heap: number }[]} */+ slots = [];+ queue = [];+ nextId = 0;+ /** Set once a worker cannot start; every call from then on runs in-thread. */+ broken = false;++ run(op, args) {+ return new Promise((resolve, reject) => {+ this.queue.push({ id: this.nextId++, op, args, resolve, reject });+ this.pump();+ });}- if (!width || !height) {- throw new Error('encodeToKtx2: width/height unknown (provide them for non-PNG sources)');++ pump() {+ while (this.queue.length > 0) {+ if (this.broken) {+ const job = this.queue.shift();+ core[job.op](...job.args).then(job.resolve, job.reject);+ continue;+ }+ const slot = this.slots.find((s) => !s.job) ?? (this.canGrow() ? this.spawn() : null);+ if (!slot) return;+ this.start(slot, this.queue.shift());+ }}- const imgType =- source.type === ImageType.PNG ? m.ldr_image_type.cPNGImage.value :- source.type === ImageType.JPG ? m.ldr_image_type.cJPGImage.value :- m.ldr_image_type.cRGBA32.value;+ /**+ * A worker's heap is only known once it has encoded something, and it grows to+ * the largest image it has seen. So the second worker waits for the first+ * report, and every later one must fit beside the largest heap reported so far.+ */+ canGrow() {+ if (this.slots.length >= workerLimit()) return false;+ if (this.slots.length === 0) return true;+ const largest = Math.max(...this.slots.map((s) => s.heap));+ return largest > 0 && (this.slots.length + 1) * largest <= HEAP_BUDGET;+ }- const enc = new m.BasisEncoder();- try {- enc.setCreateKTX2File(true);- enc.setKTX2UASTCSupercompression(supercompress);- enc.setKTX2AndBasisSRGBTransferFunc(srgb);- if (!enc.setSliceSourceImage(0, source.data, width, height, imgType)) {- throw new Error('encodeToKtx2: setSliceSourceImage failed (corrupt/unsupported source)');- }- if (mode === 'uastc') {- enc.setUASTC(true);- if (uastcLevel !== undefined) enc.setPackUASTCFlags(uastcLevel);- } else {- enc.setUASTC(false);- enc.setQualityLevel(quality);+ spawn() {+ let worker;+ try {+ worker = new Worker(WORKER);+ } catch {+ this.broken = true;+ return null;}- enc.setPerceptual(perceptual);- enc.setMipGen(mipmaps);- enc.setYFlip(yFlip);- if (normalMap) enc.setNormalMap();+ const slot = { worker, job: null, heap: 0 };+ worker.on('message', ({ id, ok, result, heap, message }) => {+ const job = slot.job;+ if (!job || job.id !== id) return;+ slot.job = null;+ slot.heap = heap ?? slot.heap;+ worker.unref();+ if (ok) job.resolve(result);+ else job.reject(new Error(message));+ this.pump();+ });+ const lost = (err) => {+ if (!this.slots.includes(slot)) return;+ this.slots = this.slots.filter((s) => s !== slot);+ const job = slot.job;+ slot.job = null;+ // A worker that never answered says workers do not run here: its job, and+ // every one after it, runs on this thread instead of failing.+ if (slot.heap === 0 && this.slots.every((s) => s.heap === 0)) {+ this.broken = true;+ if (job) this.queue.unshift(job);+ } else {+ job?.reject(err);+ }+ this.pump();+ };+ worker.on('error', lost);+ worker.on('exit', (code) => lost(new Error(`encoder worker exited with code ${code}`)));+ this.slots.push(slot);+ return slot;+ }- // RGBA8 is a safe upper bound for UASTC (1 B/px) + mips (~+1/3) + container.- const out = new Uint8Array(width * height * 4 + 65536);- const n = enc.encode(out);- if (n <= 0) throw new Error('encodeToKtx2: encoder produced 0 bytes');- return out.slice(0, n);- } finally {- enc.delete();+ start(slot, job) {+ slot.job = job;+ // A busy worker keeps the process alive; an idle one must not, or a CLI+ // that has finished its export would never exit.+ slot.worker.ref();+ slot.worker.postMessage({ id: job.id, op: job.op, args: job.args });}}+let pool = null;+function call(op, args) {+ if (workerLimit() === 0) return core[op](...args);+ pool ??= new EncoderPool();+ return pool.run(op, args);+}++/**+ * Encode a source image to KTX2 bytes; `source` and `opts` are typed in encoder.d.mts.+ * yFlip defaults on: uncompressed uploads are row-flipped at load, compressed+ * blocks cannot be, so the orientation is baked in here or the texture mirrors.+ */+export function encodeToKtx2(source, opts = {}) {+ return call('encodeToKtx2', [source, opts]);+}+/** Convenience: encode PNG bytes (dimensions read from the PNG header). */export function encodePngToKtx2(png, opts) {- return encodeToKtx2({ type: ImageType.PNG, data: png }, opts);+ return encodeToKtx2({ type: core.ImageType.PNG, data: png }, opts);}/*** Transcode a KTX2 back to RGBA8 (level 0) — validates encodes and round-trips* the pipeline. Returns { width, height, pixels: Uint8Array (w*h*4) }.*/-export async function transcodeKtx2ToRgba(ktx2) {- const m = await loadModule();- const file = new m.KTX2File(ktx2);- try {- if (!file.isValid()) throw new Error('transcodeKtx2ToRgba: invalid KTX2');- if (!file.startTranscoding()) throw new Error('transcodeKtx2ToRgba: startTranscoding failed');- const width = file.getWidth();- const height = file.getHeight();- const RGBA = m.transcoder_texture_format.cTFRGBA32.value;- const size = file.getImageTranscodedSizeInBytes(0, 0, 0, RGBA);- const dst = new Uint8Array(size);- if (!file.transcodeImage(dst, 0, 0, 0, RGBA, 0, -1, -1)) {- throw new Error('transcodeKtx2ToRgba: transcodeImage failed');- }- return { width, height, pixels: dst };- } finally {- file.close();- file.delete();- }+export function transcodeKtx2ToRgba(ktx2) {+ return call('transcodeKtx2ToRgba', [ktx2]);}diff --git a/build-tools/basis/encoderCore.mjs b/build-tools/basis/encoderCore.mjsnew file mode 100644index 000000000..5379d70fe--- /dev/null+++ b/build-tools/basis/encoderCore.mjs@@ -0,0 +1,130 @@+// SPDX-License-Identifier: Apache-2.0+// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team+/**+ * The encoder on the calling thread: one wasm instance, one image at a time.+ * encoder.mjs is the public face and runs this on worker threads; the cook+ * never imports it directly.+ */+import { createRequire } from 'node:module';+import { fileURLToPath } from 'node:url';+import path from 'node:path';++const require = createRequire(import.meta.url);+const DIR = path.dirname(fileURLToPath(import.meta.url));++/** The encoder binary; what an encode cache keys "which encoder" by. */+export const ENCODER_WASM = path.join(DIR, 'basis_encoder.wasm');++/** The wasm module is heavy to instantiate (~MBs); load + init it once. */+let modulePromise = null;+function loadModule() {+ if (!modulePromise) {+ const BASIS = require(path.join(DIR, 'basis_encoder.cjs'));+ modulePromise = BASIS({ locateFile: (f) => path.join(DIR, f) }).then((m) => {+ m.initializeBasis();+ return m;+ });+ }+ return modulePromise;+}++/** Bytes of wasm heap this thread's encoder holds — it grows to the largest image+ * seen and never gives memory back, which is what a pool must budget for. */+export async function heapBytes() {+ return (await loadModule()).HEAP8.length;+}++/** PNG IHDR width/height (big-endian u32 at byte offsets 16 / 20). */+function pngDimensions(png) {+ const dv = new DataView(png.buffer, png.byteOffset, png.byteLength);+ return { width: dv.getUint32(16), height: dv.getUint32(20) };+}++export const ImageType = { PNG: 'png', JPG: 'jpg', RGBA: 'rgba' };++/**+ * Encode a source image to KTX2 bytes; `source` and `opts` are typed in encoder.d.mts.+ * yFlip defaults on: uncompressed uploads are row-flipped at load, compressed+ * blocks cannot be, so the orientation is baked in here or the texture mirrors.+ */+export async function encodeToKtx2(source, opts = {}) {+ const {+ mode = 'uastc', mipmaps = true, srgb = true,+ perceptual = true, quality = 128, normalMap = false, yFlip = true, supercompress = false,+ uastcLevel,+ } = opts;+ const m = await loadModule();++ let width = source.width ?? 0;+ let height = source.height ?? 0;+ if (source.type === ImageType.PNG && (!width || !height)) {+ ({ width, height } = pngDimensions(source.data));+ }+ if (!width || !height) {+ throw new Error('encodeToKtx2: width/height unknown (provide them for non-PNG sources)');+ }++ const imgType =+ source.type === ImageType.PNG ? m.ldr_image_type.cPNGImage.value :+ source.type === ImageType.JPG ? m.ldr_image_type.cJPGImage.value :+ m.ldr_image_type.cRGBA32.value;++ const enc = new m.BasisEncoder();+ try {+ enc.setCreateKTX2File(true);+ enc.setKTX2UASTCSupercompression(supercompress);+ enc.setKTX2AndBasisSRGBTransferFunc(srgb);+ if (!enc.setSliceSourceImage(0, source.data, width, height, imgType)) {+ throw new Error('encodeToKtx2: setSliceSourceImage failed (corrupt/unsupported source)');+ }+ if (mode === 'uastc') {+ enc.setUASTC(true);+ if (uastcLevel !== undefined) enc.setPackUASTCFlags(uastcLevel);+ } else {+ enc.setUASTC(false);+ enc.setQualityLevel(quality);+ }+ enc.setPerceptual(perceptual);+ enc.setMipGen(mipmaps);+ enc.setYFlip(yFlip);+ if (normalMap) enc.setNormalMap();++ // RGBA8 is a safe upper bound for UASTC (1 B/px) + mips (~+1/3) + container.+ const out = new Uint8Array(width * height * 4 + 65536);+ const n = enc.encode(out);+ if (n <= 0) throw new Error('encodeToKtx2: encoder produced 0 bytes');+ return out.slice(0, n);+ } finally {+ enc.delete();+ }+}++/** Convenience: encode PNG bytes (dimensions read from the PNG header). */+export function encodePngToKtx2(png, opts) {+ return encodeToKtx2({ type: ImageType.PNG, data: png }, opts);+}++/**+ * Transcode a KTX2 back to RGBA8 (level 0) — validates encodes and round-trips+ * the pipeline. Returns { width, height, pixels: Uint8Array (w*h*4) }.+ */+export async function transcodeKtx2ToRgba(ktx2) {+ const m = await loadModule();+ const file = new m.KTX2File(ktx2);+ try {+ if (!file.isValid()) throw new Error('transcodeKtx2ToRgba: invalid KTX2');+ if (!file.startTranscoding()) throw new Error('transcodeKtx2ToRgba: startTranscoding failed');+ const width = file.getWidth();+ const height = file.getHeight();+ const RGBA = m.transcoder_texture_format.cTFRGBA32.value;+ const size = file.getImageTranscodedSizeInBytes(0, 0, 0, RGBA);+ const dst = new Uint8Array(size);+ if (!file.transcodeImage(dst, 0, 0, 0, RGBA, 0, -1, -1)) {+ throw new Error('transcodeKtx2ToRgba: transcodeImage failed');+ }+ return { width, height, pixels: dst };+ } finally {+ file.close();+ file.delete();+ }+}diff --git a/build-tools/basis/encoderWorker.mjs b/build-tools/basis/encoderWorker.mjsnew file mode 100644index 000000000..81203dc1e--- /dev/null+++ b/build-tools/basis/encoderWorker.mjs@@ -0,0 +1,18 @@+// SPDX-License-Identifier: Apache-2.0+// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team+/**+ * One thread of the encoder pool (encoder.mjs): runs encoderCore on its own wasm+ * instance and answers each job with its result and the heap it now holds.+ */+import { parentPort } from 'node:worker_threads';+import * as core from './encoderCore.mjs';++parentPort.on('message', async ({ id, op, args }) => {+ try {+ const result = await core[op](...args);+ const bytes = result instanceof Uint8Array ? result : result.pixels;+ parentPort.postMessage({ id, ok: true, result, heap: await core.heapBytes() }, [bytes.buffer]);+ } catch (err) {+ parentPort.postMessage({ id, ok: false, message: err instanceof Error ? err.message : String(err) });+ }+});diff --git a/pipeline/src/assets/cookAssets.ts b/pipeline/src/assets/cookAssets.tsindex cde4c04d4..20568075d 100644--- a/pipeline/src/assets/cookAssets.ts+++ b/pipeline/src/assets/cookAssets.ts@@ -221,6 +221,30 @@ interface BasisEncoderModule {transcodeKtx2ToRgba(ktx2: Uint8Array): Promise<{ width: number; height: number; pixels: Uint8Array }>;ImageType: { PNG: string; JPG: string; RGBA: string };ENCODER_WASM: string;+ ENCODER_PARALLELISM: number;+}++/** What cooking one asset reports, held apart so concurrent cooks merge in order. */+interface CookSink {+ warnings: string[];+ failed: string[];+ defeatedByFormat: string[];+ grewUnderEncoding: Array<{ path: string; saved: number }>;+ manifestEntries: CookManifestEntry[];+}++/** `fn` over `items` with at most `limit` running, results in the items' order. */+async function mapInOrder<T, R>(items: T[], limit: number, fn: (item: T) => Promise<R>): Promise<R[]> {+ const results = new Array<R>(items.length);+ let next = 0;+ const lane = async (): Promise<void> => {+ while (next < items.length) {+ const i = next++;+ results[i] = await fn(items[i]!);+ }+ };+ await Promise.all(Array.from({ length: Math.min(limit, items.length) }, lane));+ return results;}const KTX2_SCHEME_ZSTD = 2;@@ -674,9 +698,13 @@ export async function cookAssets(}}- for (const uuid of reachable) {+ // Each asset cooks on its own, and the encoder runs ENCODER_PARALLELISM images+ // at once, so that many are kept in flight. What each reports is merged back in+ // `reachable` order, which keeps the manifest and the warnings a serial cook's.+ const cookOne = async (uuid: string, { warnings, failed, defeatedByFormat, grewUnderEncoding,+ manifestEntries }: CookSink): Promise<void> => {const entry = byUuid.get(uuid);- if (!entry) continue;+ if (!entry) return;// Atlas-packed frame: the page is already staged; this entry just records// where the frame lives (page path + rect). Its physical identity IS the// page's (hash/size of the bytes actually served for this ref).@@ -712,7 +740,7 @@ export async function cookAssets(pageHeight: framePlan.pageHeight,},});- continue;+ return;}try {// Videos headed for transcode skip the eager read: ffmpeg streams the@@ -911,9 +939,9 @@ export async function cookAssets(}const dst = path.join(absOut, outRel);if (!staged.has(outRel)) {+ staged.add(outRel);await mkdir(path.dirname(dst), { recursive: true });await writeFile(dst, data);- staged.add(outRel);}manifestEntries.push({uuid: entry.uuid,@@ -940,8 +968,8 @@ export async function cookAssets(const audioHash = contentHashHex(videoAudio);const audioOutRel = useCA ? `${caBase}/${audioHash}.m4a` : `${outRel}.m4a`;if (!staged.has(audioOutRel)) {- await writeFile(path.join(absOut, audioOutRel), videoAudio);staged.add(audioOutRel);+ await writeFile(path.join(absOut, audioOutRel), videoAudio);}manifestEntries.push({uuid: `${entry.uuid}-audio`,@@ -959,6 +987,18 @@ export async function cookAssets(warnings.push(`copy failed ${entry.path}: ${why}`);failed.push(`${entry.path}: ${why}`);}+ };+ const sinks = await mapInOrder([...reachable], textureEnc?.ENCODER_PARALLELISM ?? 1, async (uuid) => {+ const sink: CookSink = { warnings: [], failed: [], defeatedByFormat: [], grewUnderEncoding: [], manifestEntries: [] };+ await cookOne(uuid, sink);+ return sink;+ });+ for (const sink of sinks) {+ warnings.push(...sink.warnings);+ failed.push(...sink.failed);+ defeatedByFormat.push(...sink.defeatedByFormat);+ grewUnderEncoding.push(...sink.grewUnderEncoding);+ manifestEntries.push(...sink.manifestEntries);}manifestEntries.sort((a, b) => a.path.localeCompare(b.path));diff --git a/pipeline/src/assets/cookCache.ts b/pipeline/src/assets/cookCache.tsindex 8eef0b009..4ab1f1adb 100644--- a/pipeline/src/assets/cookCache.ts+++ b/pipeline/src/assets/cookCache.ts@@ -29,6 +29,9 @@ export function encoderIdentity(encoderFile: string): string {* The bytes `produce` makes for these inputs, from the cache when an earlier* cook made them. A cache that cannot be written is only slower, never wrong.*/+/** Concurrent cooks in one process can produce the same key; each writes its own temp file. */+let tmpSerial = 0;+export async function cookCached(root: string, inputs: ReadonlyArray<Uint8Array | string>, produce: () => Promise<Uint8Array>,): Promise<{ bytes: Uint8Array; hit: boolean }> {@@ -42,7 +45,7 @@ export async function cookCached(const bytes = await produce();try {await mkdir(path.dirname(file), { recursive: true });- const tmp = `${file}.${process.pid}.tmp`;+ const tmp = `${file}.${process.pid}.${tmpSerial++}.tmp`;await writeFile(tmp, bytes);await rename(tmp, file);} catch { /* a read-only project cooks every time */ }diff --git a/tools/releaseNotes.mjs b/tools/releaseNotes.mjsindex 60a810bb0..14ac0d4fb 100644--- a/tools/releaseNotes.mjs+++ b/tools/releaseNotes.mjs@@ -1234,6 +1234,8 @@ export const NOTED = {{ note: 'Importing a model converts its DDS textures to PNG' },'feat(import): a model\'s specular map is read as its import settings say':{ note: 'An FBX model\'s specular map can be read as packed occlusion' },+ 'feat(cook): textures encode on every core':+ { note: 'Exporting compresses textures on every core' },'fix(eht): the generator writes LF on every platform':{ internal: 'The engine header tool is a repository generator; on Windows it rewrote every generated file with CRLF, which only a contributor there ever saw.' },};