"use strict"; import { Constants } from "./Constants.js"; //////////////////////////////////// Core ///////////////////////////////////// // Emulation processor new class Core { // Instance fields audio; // Audio communication automatic; // Automatic emulation state clocked; // Clocked emulation state dom; // DOM communication mallocs; // Memory allocations by pointer pointerType; // TypedArray for WebAssembly pointers sims; // Simulations by pointer ///////////////////////// Initialization Methods ////////////////////////// constructor() { onmessage = async e=>{ await this.#construct(e.data.audio, e.data.wasmUrl); this.dom.postMessage(0); }; } // Asynchronous constructor async #construct(audio, wasmUrl) { // Configure instance fields this.mallocs = new Map(); this.sims = new Map(); // DOM thread communication this.dom = globalThis; this.dom.onmessage = e=>this[e.data.command](e.data); // Instantiate the WebAssembly module this.wasm = (await WebAssembly.instantiateStreaming( fetch(wasmUrl), { env: { emscripten_notify_memory_growth: ()=>this.#onGrowth() } })); Object.assign(this, this.wasm.instance.exports); this.pointerType = this.PointerSize() == 8 ? BigUint64Array : Uint32Array; // Configure audio state this.audio = audio; audio.buffers = [0,0,0].map(v=>new Float32Array(41700 / 50 * 2)); audio.samples = this.#malloc(41700 / 50 * 2, audio, "samples", Float32Array); audio.onmessage = e=>this.#onAudio(e.data); // Configure emulation states this.automatic = { emulating: false }; this.clocked = {}; for (let s of [ this.automatic, this.clocked ]) { s.clocks = this.#malloc(1, s, "clocks" , Uint32Array); s.pointers = this.#malloc(1, s, "pointers", this.pointerType); s.sims = []; } } ////////////////////////////// Core Commands ////////////////////////////// // Instantiate sims createSims(message) { let sims = new Array(message.count); let size = this.vbSizeOf(); // Process all sims for (let x = 0; x < message.count; x++) { let sim = { canvas : null, keys : Constants.VB.SGN, pointer : sims[x] = this.CreateSim(), volume : 1 }; this.sims.set(sim.pointer, sim); // Video this.SetAnaglyph(sim.pointer, Constants.web.STEREO_RED, Constants.web.STEREO_CYAN); sim.pixels = this.#noalloc( this.GetExt(sim.pointer, Constants.web.EXT_PIXELS), 384*224*4, sim, "pixels", Uint8ClampedArray ); sim.image = new ImageData(sim.pixels, 384, 224); // Audio sim.samples = this.#noalloc( this.GetExt(sim.pointer, Constants.web.EXT_SAMPLES), 41700 / 50 * 2, sim, "samples", Float32Array ); } this.dom.postMessage({ sims : sims, promised: true }); } // Produce disassembly from a sim disassemble(message) { // Disassemble from the simulation let dasm = message.config == null ? this.vbuDisassemble( message.sim, message.address, 0, message.length, message.line ) : this.Disassemble( message.config.bcondNotation, message.config.conditionCase, message.config.conditionCL, message.config.conditionEZ, message.config.conditionNotation, message.config.hexCase, message.config.hexNotation, message.config.memoryNotation, message.config.mnemonicCase, message.config.operandOrder, message.config.programCase, message.config.programNotation, message.config.setfNotation, message.config.systemCase, message.config.systemNotation, message.sim, message.address, message.length, message.line ) ; // A memory error occurred if (dasm == 0) { this.dom.postMessage({ promised: message.promised, success : false }); return; } // Retrieve all disassembly data into a working buffer let pointer = this.Realloc(0, message.length * 17 * 4); let buffer = new Uint32Array( this.memory.buffer, pointer, message.length * 17); this.GetDasm(pointer, dasm, message.length); // Consume output lines let lines = new Array(message.length); for (let x = 0, z = 0; x < lines.length; x++) { let line = lines[x] = { text: {} }; line.address = buffer[z++]; line.code = new Array(buffer[z++]); for (let y = 0; y < line.code.length; y++) line.code[y] = buffer[z++]; z += 4 - line.code.length; line.isPC = buffer[z++] != 0; line.text.address = this.#string(dasm + buffer[z++], true); line.text.code = new Array(line.code.length); for (let y = 0; y < line.code.length; y++) line.text.code[y] = this.#string(dasm + buffer[z++], true); z += 4 - line.code.length; line.text.mnemonic = this.#string(dasm + buffer[z++], true); line.text.operands = new Array(buffer[z++]); for (let y = 0; y < line.text.operands.length; y++) line.text.operands[y] = this.#string(dasm + buffer[z++], true); z += 3 - line.text.operands.length; } // Memory cleanup this.Realloc(pointer, 0); this.Realloc(dasm , 0); // Send response this.dom.postMessage({ success : true, lines : lines, promised: message.promised }); } // Emulate automatically emulateAutomatic(message) { // Configure sims this.automatic.pointers = this.#realloc( this.automatic.pointers, message.sims.length); for (let x = 0; x < message.sims.length; x++) { this.automatic.pointers[x] = message.sims[x]; this.automatic.sims [x] = this.sims.get(message.sims[x]); } // Notify the DOM thread this.dom.postMessage({ promised: true }); // Begin automatic emulation this.automatic.emulating = true; this.#autoEmulate(); } // Emulate for a given number of clocks emulateClocked(message) { // Configure sims this.clocked.pointers = this.#realloc( this.clocked.pointers, message.sims.length); for (let x = 0; x < message.sims.length; x++) { this.clocked.pointers[x] = message.sims[x]; this.clocked.sims [x] = this.sims.get(message.sims[x]); } // Process simulations let broke = false; this.clocked.clocks[0] = message.clocks; while (!broke && this.clocked.clocks[0] != 0) { // Process simulations until a suspension this.Emulate( this.clocked.pointers.pointer, message.sims.length, this.clocked.clocks.pointer ); // Monitor break conditions for (let x = 0; x < message.sims.length; x++) { let sim = this.clocked.sims[x]; sim.breaks = this.GetBreaks(sim.pointer); if (breaks & Constants.web.BREAK_POINT) broke = true; } } // Update images for (let sim of this.clocked.sims) { if (!(sim.breaks & Constants.web.BREAK_FRAME)) continue; this.GetPixels(sim.pointer); sim.context.putImageData(sim.image, 0, 0); } // Notify DOM thread this.dom.postMessage({ promised: true, broke : broke, clocks : this.clocked.clocks[0] }); } // Specify anaglyph colors setAnaglyph(message) { this.SetAnaglyph(message.sim, message.left, message.right); this.dom.postMessage({ promised: true }); } // Specify the OffscreenCanvas that goes with a sim setCanvas(message) { let sim = this.sims.get(message.sim); sim.canvas = message.canvas; sim.context = sim.canvas.getContext("2d"); sim.context.putImageData(sim.image, 0, 0); this.dom.postMessage({ promised: true }); } // Specify a game pak RAM buffer setCartRAM(message) { this.#setCartMemory(message.sim, message.data, this.vbGetCartRAM, this.vbSetCartRAM); } // Specify a game pak ROM buffer setCartROM(message) { this.#setCartMemory(message.sim, message.data, this.vbGetCartROM, this.vbSetCartROM); } // Specify new game pad keys setKeys(message) { this.vbSetKeys(message.sim, message.keys); this.dom.postMessage({ promised: true }); } // Specify a new communication peer setPeer(message) { let orphaned = []; let prev = this.vbGetPeer(message.sim); if (prev != message.peer) { if (prev != 0) // Sim's previous peer has been orphaned orphaned.push(prev); if (message.peer != 0) { prev = this.vbGetPeer(message.peer); if (prev != null) // Peer's previous peer has been orphaned orphaned.push(prev); } this.vbSetPeer(message.sim, message.peer); } this.dom.postMessage({ orphaned: orphaned, promised: true }); } // Specify audio volume setVolume(message) { this.sims.get(message.sim).volume = message.volume; this.dom.postMessage({ promised: true }); } // Suspend automatic emulation suspend(message) { this.automatic.emulating = false; this.dom.postMessage({ promised: true }); } ///////////////////////////// Event Handlers ////////////////////////////// // Message from audio thread #onAudio(e) { // Output staged images if (this.automatic.emulating && this.audio.buffers.length == 0) { for (let sim of this.automatic.sims) sim.context.putImageData(sim.image, 0, 0); } // Acquire the emptied buffers and resume emulation this.audio.buffers.push(... e.map(b=>new Float32Array(b))); this.#autoEmulate(); } // WebAssembly memory has grown #onGrowth() { for (let prev of this.mallocs.values()) { let buffer = new prev.constructor( this.memory.buffer, prev.pointer, prev.size); Object.assign(buffer, { assign : prev.assign, pointer: prev.pointer, size : prev.size, target : prev.target }); this.mallocs.set(buffer.pointer, buffer); this.#updateTarget(buffer); } for (let sim of this.sims) sim.image = new ImageData(sim.pixels, 384, 224); } ///////////////////////////// Private Methods ///////////////////////////// // Automatic emulation processing #autoEmulate() { // Error checking if (!this.automatic.emulating) return; // Process all remaining audio buffers while (this.audio.buffers.length != 0) { // Reset sample output for (let sim of this.automatic.sims) { this.vbSetSamples(sim.pointer, sim.samples.pointer, Constants.VB.F32, 41700 / 50); } // Process all clocks this.automatic.clocks[0] = 400000; // 0.02s while (this.automatic.clocks[0] != 0) { this.Emulate( this.automatic.pointers.pointer, this.automatic.sims.length, this.automatic.clocks.pointer ); // Too many buffers left to output video if (this.audio.buffers.length > 2) continue; // Stage the next video image for (let sim of this.automatic.sims) { let breaks = this.GetBreaks(sim.pointer); if (breaks & Constants.web.BREAK_FRAME) this.GetPixels(sim.pointer); } } // Mix and output audio samples let buffer = this.audio.buffers.shift(); if (this.automatic.sims.length > 1) { for (let x = 0; x < buffer.length; x++) buffer[x] = 0; for (let sim of this.automatic.sims) for (let x = 0; x < buffer.length; x++) buffer[x] += sim.samples[x] * sim.volume; for (let x = 0; x < buffer.length; x++) buffer[x] = Math.min(Math.max(-1, buffer[x]), +1); } else { for (let x = 0; x < buffer.length; x++) buffer[x] = this.automatic.sims[0].samples[x]; } this.audio.postMessage(buffer.buffer, [ buffer.buffer ]); // Output staged images if there's one audio buffer to go if (this.audio.buffers.length != 1) continue; for (let sim of this.automatic.sims) sim.context.putImageData(sim.image, 0, 0); } } // Delete an allocated buffer in WebAssembly memory #free(buffer) { this.mallocs.delete(buffer.pointer); this.Realloc(buffer.pointer, 0); } // Allocate memory in WebAssembly and register the buffer #malloc(count, target = null, assign = null, type = Uint8ClampedArray) { return this.#noalloc( this.Realloc(0, count * type.BYTES_PER_ELEMENT), count, target, assign, type ); } // Register a buffer in WebAssembly memory without allocating it #noalloc(pointer, count, target=null, assign=null, type=Uint8ClampedArray){ let buffer = new type(this.memory.buffer, pointer, count); Object.assign(buffer, { assign : assign?.split("."), count : count, pointer: pointer, target : target }); this.mallocs.set(pointer, buffer); return buffer; } // Resize a previously allocated buffer in WebAssembly memory #realloc(prev, count) { this.mallocs.delete(prev.pointer); let pointer = this.Realloc(prev.pointer, count * prev.constructor.prototype.BYTES_PER_ELEMENT); let buffer = new prev.constructor(this.memory.buffer, pointer, count); Object.assign(buffer, { assign : prev.assign, count : count, pointer: pointer, target : prev.target }); this.mallocs.set(pointer, buffer); this.#updateTarget(buffer); return buffer; } // Compute anaglyph color values #setAnaglyph(sim, left, right) { // Split out the RGB channels let color = left | right; let stereo = [ color >> 16 & 0xFF, color >> 8 & 0xFF, color & 0xFF ]; // Compute scaled RGB values by output level sim.anaglyph = new Array(256); for (let x = 0; x < 256; x++) { let level = sim.anaglyph[x] = new Array(3); for (let y = 0; y < 3; y++) level[y] = Math.round(x * stereo[y] / 255.0); } // Determine which channels are in each eye sim.anaglyph.left = []; sim.anaglyph.right = []; for (let x = 0, y = 16; x < 3; x++, y -= 8) { if (left >> y & 0xFF) sim.anaglyph.left .push(x); if (right >> y & 0xFF) sim.anaglyph.right.push(x); } } // Specify a game pak memory buffer #setCartMemory(sim, mem, getter, setter) { // Working variables let cart = new Uint8Array(mem); let prev = getter(sim); let cur = this.Realloc(0, cart.length); mem = new Uint8Array(this.memory.buffer, cur, cart.length); // Transfer the data into core memory for (let x = 0; x < mem.length; x++) mem[x] = cart[x]; // Assign the ROM to the simulation let success = setter(sim, cur, mem.length) == 0; if (success) { if (prev != 0) this.Realloc(prev, 0); } else this.Realloc(cur, 0); // Reply to the DOM thread this.dom.postMessage({ success : success, promised: true }); } // Read a C string from WebAssembly memory #string(address, indirect = false) { if (address == 0) return null; if (indirect) { let next = new this.pointerType(this.memory.buffer, address, 1)[0]; address = next; } let length = 0; let memory = new Uint8Array(this.memory.buffer); for (let addr = address; memory[addr++] != 0; length++); return (Array.from(memory.slice(address, address + length)) .map(b=>String.fromCodePoint(b)).join("")); } // Update an allocated buffer's assignment in its monitor object #updateTarget(buffer) { if (buffer.target == null) return; let obj = buffer.target; let assign = buffer.assign.slice(); while (assign.length > 1) obj = obj[assign.shift()]; obj[assign[0]] = buffer; } }();