897 lines
27 KiB
JavaScript
897 lines
27 KiB
JavaScript
"use strict";
|
|
import { Constants } from "./Constants.js";
|
|
|
|
// Instantiation guard
|
|
const GUARD = Symbol();
|
|
|
|
|
|
|
|
///////////////////////////////// DasmConfig //////////////////////////////////
|
|
|
|
// Disassembler option settings
|
|
class DasmConfig {
|
|
|
|
// Instance fields
|
|
#bcondNotation;
|
|
#conditionCase;
|
|
#conditionCL;
|
|
#conditionEZ;
|
|
#conditionNotation;
|
|
#hexCase;
|
|
#hexNotation;
|
|
#memoryNotation;
|
|
#mnemonicCase;
|
|
#operandOrder;
|
|
#programCase;
|
|
#programNotation;
|
|
#setfNotation;
|
|
#systemCase;
|
|
#systemNotation;
|
|
|
|
|
|
|
|
///////////////////////// Initialization Methods //////////////////////////
|
|
|
|
constructor() {
|
|
this.#bcondNotation = Constants.VBU.JOINED;
|
|
this.#conditionCase = Constants.VBU.LOWER;
|
|
this.#conditionCL = Constants.VBU.L;
|
|
this.#conditionEZ = Constants.VBU.Z;
|
|
this.#conditionNotation = Constants.VBU.NAMES;
|
|
this.#hexCase = Constants.VBU.UPPER;
|
|
this.#hexNotation = Constants.VBU["0X"];
|
|
this.#memoryNotation = Constants.VBU.OUTSIDE;
|
|
this.#mnemonicCase = Constants.VBU.UPPER;
|
|
this.#operandOrder = Constants.VBU.DEST_LAST;
|
|
this.#programCase = Constants.VBU.LOWER;
|
|
this.#programNotation = Constants.VBU.NAMES;
|
|
this.#setfNotation = Constants.VBU.SPLIT;
|
|
this.#systemCase = Constants.VBU.LOWER;
|
|
this.#systemNotation = Constants.VBU.NAMES;
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////// Property Accessors ////////////////////////////
|
|
|
|
get bcondNotation() { return this.#bcondNotation; }
|
|
set bcondNotation(value) {
|
|
switch (value) {
|
|
case Constants.VBU.JOINED:
|
|
case Constants.VBU.SPLIT : break;
|
|
default: return;
|
|
}
|
|
this.#bcondNotation = value;
|
|
}
|
|
|
|
get conditionCase() { return this.#conditionCase; }
|
|
set conditionCase(value) {
|
|
switch (value) {
|
|
case Constants.VBU.LOWER:
|
|
case Constants.VBU.UPPER: break;
|
|
default: return;
|
|
}
|
|
this.#conditionCase = value;
|
|
}
|
|
|
|
get conditionCL() { return this.#conditionCL; }
|
|
set conditionCL(value) {
|
|
switch (value) {
|
|
case Constants.VBU.C:
|
|
case Constants.VBU.L: break;
|
|
default: return;
|
|
}
|
|
this.#conditionCL = value;
|
|
}
|
|
|
|
get conditionEZ() { return this.#conditionEZ; }
|
|
set conditionEZ(value) {
|
|
switch (value) {
|
|
case Constants.VBU.E:
|
|
case Constants.VBU.Z: break;
|
|
default: return;
|
|
}
|
|
this.#conditionEZ = value;
|
|
}
|
|
|
|
get conditionNotation() { return this.#conditionNotation; }
|
|
set conditionNotation(value) {
|
|
switch (value) {
|
|
case Constants.VBU.NAMES :
|
|
case Constants.VBU.NUMBERS: break;
|
|
default: return;
|
|
}
|
|
this.#conditionNotation = value;
|
|
}
|
|
|
|
get hexCase() { return this.#hexCase; }
|
|
set hexCase(value) {
|
|
switch (value) {
|
|
case Constants.VBU.LOWER:
|
|
case Constants.VBU.UPPER: break;
|
|
default: return;
|
|
}
|
|
this.#hexCase = value;
|
|
}
|
|
|
|
get hexNotation() { return this.#hexNotation; }
|
|
set hexNotation(value) {
|
|
switch (value) {
|
|
case Constants.VBU["0X"] :
|
|
case Constants.VBU.DOLLAR:
|
|
case Constants.VBU.H : break;
|
|
default: return;
|
|
}
|
|
this.#hexNotation = value;
|
|
}
|
|
|
|
get memoryNotation() { return this.#memoryNotation; }
|
|
set memoryNotation(value) {
|
|
switch (value) {
|
|
case Constants.VBU.INSIDE :
|
|
case Constants.VBU.OUTSIDE: break;
|
|
default: return;
|
|
}
|
|
this.#memoryNotation = value;
|
|
}
|
|
|
|
get mnemonicCase() { return this.#mnemonicCase; }
|
|
set mnemonicCase(value) {
|
|
switch (value) {
|
|
case Constants.VBU.LOWER:
|
|
case Constants.VBU.UPPER: break;
|
|
default: return;
|
|
}
|
|
this.#mnemonicCase = value;
|
|
}
|
|
|
|
get operandOrder() { return this.#operandOrder; }
|
|
set operandOrder(value) {
|
|
switch (value) {
|
|
case Constants.VBU.DEST_FIRST:
|
|
case Constants.VBU.DEST_LAST : break;
|
|
default: return;
|
|
}
|
|
this.#operandOrder = value;
|
|
}
|
|
|
|
get programCase() { return this.#programCase; }
|
|
set programCase(value) {
|
|
switch (value) {
|
|
case Constants.VBU.LOWER:
|
|
case Constants.VBU.UPPER: break;
|
|
default: return;
|
|
}
|
|
this.#programCase = value;
|
|
}
|
|
|
|
get programNotation() { return this.#programNotation; }
|
|
set programNotation(value) {
|
|
switch (value) {
|
|
case Constants.VBU.NAMES :
|
|
case Constants.VBU.NUMBERS: break;
|
|
default: return;
|
|
}
|
|
this.#programNotation = value;
|
|
}
|
|
|
|
get setfNotation() { return this.#setfNotation; }
|
|
set setfNotation(value) {
|
|
switch (value) {
|
|
case Constants.VBU.JOINED:
|
|
case Constants.VBU.SPLIT : break;
|
|
default: return;
|
|
}
|
|
this.#setfNotation = value;
|
|
}
|
|
|
|
get systemCase() { return this.#systemCase; }
|
|
set systemCase(value) {
|
|
switch (value) {
|
|
case Constants.VBU.LOWER:
|
|
case Constants.VBU.UPPER: break;
|
|
default: return;
|
|
}
|
|
this.#systemCase = value;
|
|
}
|
|
|
|
get systemNotation() { return this.#systemNotation; }
|
|
set systemNotation(value) {
|
|
switch (value) {
|
|
case Constants.VBU.NAMES :
|
|
case Constants.VBU.NUMBERS: break;
|
|
default: return;
|
|
}
|
|
this.#systemNotation = value;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////// DasmLine ///////////////////////////////////
|
|
|
|
// One line of disassembler output
|
|
class DasmLine {
|
|
|
|
// Instance fields
|
|
#address;
|
|
#addressText;
|
|
#code;
|
|
#codeText;
|
|
#isPC;
|
|
#mnemonicText;
|
|
#operandText;
|
|
|
|
|
|
|
|
///////////////////////// Initialization Methods //////////////////////////
|
|
|
|
constructor() {
|
|
if (arguments[0] != GUARD)
|
|
throw new Error("Cannot be instantiated.");
|
|
let line = arguments[1];
|
|
this.#address = line.address;
|
|
this.#addressText = line.text.address;
|
|
this.#code = line.code;
|
|
this.#codeText = line.text.code;
|
|
this.#isPC = line.isPC;
|
|
this.#mnemonicText = line.text.mnemonic;
|
|
this.#operandText = line.text.operands;
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////// Property Accessors ////////////////////////////
|
|
|
|
get address() { return this.#address; }
|
|
get code () { return this.#code.slice(); }
|
|
get isPC () { return this.#isPC; }
|
|
get text () {
|
|
return {
|
|
address : this.#addressText,
|
|
code : this.#codeText.slice(),
|
|
mnemonic: this.#mnemonicText,
|
|
operands: this.#operandText.slice()
|
|
};
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////// Public Methods //////////////////////////////
|
|
|
|
// Express self as a plain object
|
|
toObject() {
|
|
return {
|
|
address: this.address,
|
|
code : Array.from(this.#code),
|
|
isPC : this.isPC,
|
|
text : this.text
|
|
};
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////// Sim /////////////////////////////////////
|
|
|
|
// Simulation instance
|
|
class Sim extends HTMLElement {
|
|
|
|
// Instance fields
|
|
#anaglyph; // Anaglyph color values
|
|
#canvas; // Canvas element
|
|
#core; // Core proxy
|
|
#emulating; // Current emulation status
|
|
#keys; // Controller state
|
|
#peer; // Communication peer
|
|
#pointer; // Pointer in core memory
|
|
#volume; // Audio output volume
|
|
|
|
|
|
|
|
///////////////////////// Initialization Methods //////////////////////////
|
|
|
|
constructor() {
|
|
if (arguments[0] != GUARD)
|
|
throw new Error("Must be created via VB.create()");
|
|
super();
|
|
this.proxy = {
|
|
construct : (core, pointer)=>this.#construct(core, pointer),
|
|
isEmulating : ()=>this.#emulating,
|
|
setEmulating: e =>this.#emulating = e,
|
|
setPeer : p =>this.#peer = p
|
|
};
|
|
}
|
|
|
|
// Asynchronous constructor
|
|
async #construct(core, pointer) {
|
|
|
|
// Configure instance fields
|
|
this.#anaglyph = [ VB.STEREO_RED, VB.STEREO_CYAN ];
|
|
this.#core = core;
|
|
this.#emulating = false;
|
|
this.#keys = Constants.VB.SGN;
|
|
this.#peer = null;
|
|
this.#pointer = pointer;
|
|
this.#volume = 1;
|
|
delete this.proxy;
|
|
|
|
// Create a <canvas> for the video image
|
|
let canvas = this.#canvas = document.createElement("canvas");
|
|
Object.assign(canvas, { width: 384, height: 224 });
|
|
canvas.style.imageRendering = "pixelated";
|
|
|
|
// Configure elements
|
|
Object.assign(this.style, {
|
|
display : "inline-block",
|
|
height : "224px",
|
|
position: "relative",
|
|
width : "384px"
|
|
});
|
|
Object.assign(canvas.style, {
|
|
height : "100%",
|
|
imageRendering: "pixelated",
|
|
left : "0",
|
|
position : "absolute",
|
|
top : "0",
|
|
width : "100%"
|
|
});
|
|
this.append(canvas);
|
|
|
|
// Send control of the canvas to the core worker
|
|
let offscreen = canvas.transferControlToOffscreen();
|
|
await core.toCore({
|
|
command : "setCanvas",
|
|
promised : true,
|
|
sim : pointer,
|
|
canvas : offscreen,
|
|
transfers: [ offscreen ]
|
|
});
|
|
|
|
return this;
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////// Property Accessors ////////////////////////////
|
|
|
|
get anaglyph() { return this.#anaglyph.slice(); }
|
|
get core () { return this.#core.core; }
|
|
get keys () { return this.#keys; }
|
|
get peer () { return this.#peer; }
|
|
get volume () { return this.#volume; }
|
|
|
|
|
|
|
|
///////////////////////////// Public Methods //////////////////////////////
|
|
|
|
// Delete the sim
|
|
async delete() {
|
|
// Unlink peer
|
|
// Deallocate memory
|
|
// Unlink core
|
|
}
|
|
|
|
// Disassemble from a simulation
|
|
async disassemble(address, config, length, line) {
|
|
|
|
// Error checking
|
|
if (!Number.isSafeInteger(address) ||
|
|
address < 0 || address > 0xFFFFFFFF)
|
|
throw new RangeError("Address must conform to Uint32.");
|
|
if (config != null && !(config instanceof DasmConfig))
|
|
throw new TypeError("Config must be an instance of DasmConfig.");
|
|
if (!Number.isSafeInteger(address) || length < 0)
|
|
throw new RangeError("Length must be nonnegative.");
|
|
if (!Number.isSafeInteger(line))
|
|
throw new TypeError("Line must be a safe integer.");
|
|
|
|
// Request disassembly from the core
|
|
let response = await this.#core.toCore({
|
|
command : "disassemble",
|
|
promised: true,
|
|
sim : this.#pointer,
|
|
address : address,
|
|
length : length,
|
|
line : line,
|
|
config : config == null ? null : {
|
|
bcondNotation : config.bcondNotation,
|
|
conditionCase : config.conditionCase,
|
|
conditionCL : config.conditionCL,
|
|
conditionEZ : config.conditionEZ,
|
|
conditionNotation: config.conditionNotation,
|
|
hexCase : config.hexCase,
|
|
hexNotation : config.hexNotation,
|
|
memoryNotation : config.memoryNotation,
|
|
mnemonicCase : config.mnemonicCase,
|
|
operandOrder : config.operandOrder,
|
|
programCase : config.programCase,
|
|
programNotation : config.programNotation,
|
|
setfNotation : config.setfNotation,
|
|
systemCase : config.systemCase,
|
|
systemNotation : config.systemNotation
|
|
}
|
|
});
|
|
|
|
// Process the response
|
|
return !response.success ? null :
|
|
response.lines.map(l=>new DasmLine(GUARD, l));
|
|
}
|
|
|
|
// Specify anaglyph colors
|
|
async setAnaglyph(left, right) {
|
|
|
|
// Error checking
|
|
if (!Number.isSafeInteger(left ) || left < 0 || left > 0xFFFFFF)
|
|
throw new RangeError("Left must conform to Uint24.");
|
|
if (!Number.isSafeInteger(right) || right < 0 || right > 0xFFFFFF)
|
|
throw new RangeError("Right must conform to Uint24.");
|
|
if (
|
|
left & 0xFF0000 && right & 0xFF0000 ||
|
|
left & 0x00FF00 && right & 0x00FF00 ||
|
|
left & 0x0000FF && right & 0x0000FF
|
|
) throw new RangeError("Left and right overlap RGB channels.");
|
|
|
|
// Configure instance fields
|
|
this.#anaglyph[0] = left;
|
|
this.#anaglyph[1] = right;
|
|
|
|
// Send the colors to the core
|
|
await this.#core.toCore({
|
|
command : "setAnaglyph",
|
|
promised: true,
|
|
sim : this.#pointer,
|
|
left : left,
|
|
right : right
|
|
});
|
|
}
|
|
|
|
// Specify a game pak RAM buffer
|
|
setCartRAM(wram) {
|
|
return this.#setCartMemory("setCartRAM", wram);
|
|
}
|
|
|
|
// Specify a game pak ROM buffer
|
|
setCartROM(rom) {
|
|
return this.#setCartMemory("setCartROM", rom);
|
|
}
|
|
|
|
// Specify new game pad keys
|
|
async setKeys(keys) {
|
|
|
|
// Error checking
|
|
if (!Number.isSafeInteger(keys) || keys < 0 || keys > 0xFFFF)
|
|
throw new RangeError("Keys must conform to Uint16.");
|
|
if (keys == this.#keys)
|
|
return;
|
|
|
|
// Configure instance fields
|
|
this.#keys = keys;
|
|
|
|
// Send the keys to the core
|
|
await this.#core.toCore({
|
|
command : "setKeys",
|
|
promised: true,
|
|
sim : this.#pointer,
|
|
keys : keys
|
|
});
|
|
}
|
|
|
|
// Specify a new communication peer
|
|
async setPeer(peer = null) {
|
|
|
|
// Error checking
|
|
if (peer !== null && peer.#core != this.#core)
|
|
throw new RangeError("Peer sim must belong to the same core.");
|
|
|
|
// Configure peers on the core
|
|
if (peer != this.#peer)
|
|
await this.#core.setPeer(this, peer);
|
|
}
|
|
|
|
// Specify audio volume
|
|
async setVolume(volume) {
|
|
|
|
// Error checking
|
|
if (!Number.isFinite(volume) ||volume < 0 || volume > 10) {
|
|
throw new RangeError(
|
|
"Volume must be a number from 0\u00d7 to 10\u00d7.");
|
|
}
|
|
|
|
// Configure instance fields
|
|
this.#volume = volume;
|
|
|
|
// Send the volume to the core
|
|
await this.#core.toCore({
|
|
command : "setVolume",
|
|
promised: true,
|
|
sim : this.#pointer,
|
|
volume : volume
|
|
});
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////// Private Methods /////////////////////////////
|
|
|
|
// Specify a game pak memory buffer
|
|
async #setCartMemory(command, mem) {
|
|
|
|
// Validation
|
|
if (mem instanceof ArrayBuffer)
|
|
mem = new Uint8Array(mem);
|
|
if (
|
|
!(mem instanceof Uint8Array) &&
|
|
!(mem instanceof Uint8ClampedArray)
|
|
) mem = Uint8Array.from(mem);
|
|
|
|
// Send the memory to the core
|
|
let response = await this.#core.toCore({
|
|
command : command,
|
|
promised : true,
|
|
sim : this.#pointer,
|
|
data : mem.buffer,
|
|
transfers: [ mem.buffer ]
|
|
});
|
|
return response.success;
|
|
}
|
|
|
|
}
|
|
customElements.define("shrooms-vb", Sim);
|
|
|
|
|
|
|
|
///////////////////////////////////// VB //////////////////////////////////////
|
|
|
|
// Emulation core interface
|
|
class VB {
|
|
|
|
// Static fields
|
|
static get DasmConfig() { return DasmConfig; }
|
|
static get DasmLine () { return DasmLine; }
|
|
static get Sim () { return Sim; }
|
|
|
|
// Instance fields
|
|
#audio; // Audio worklet
|
|
#automatic; // Current automatic emulation group
|
|
#commands; // Computed method table
|
|
#core; // Core worker
|
|
#proxy; // Self proxy for sim access
|
|
#sims; // All sims
|
|
#state; // Operations state
|
|
|
|
|
|
|
|
//////////////////////////////// Constants ////////////////////////////////
|
|
|
|
// Operations states
|
|
static #SUSPENDED = Symbol();
|
|
static #RESUMING = Symbol();
|
|
static #EMULATING = Symbol();
|
|
static #SUSPENDING = Symbol();
|
|
|
|
// System registers
|
|
static get ADTRE() { return Constants.VB.ADTRE; }
|
|
static get CHCW () { return Constants.VB.CHCW ; }
|
|
static get ECR () { return Constants.VB.ECR ; }
|
|
static get EIPC () { return Constants.VB.EIPC ; }
|
|
static get EIPSW() { return Constants.VB.EIPSW; }
|
|
static get FEPC () { return Constants.VB.FEPC ; }
|
|
static get FEPSW() { return Constants.VB.FEPSW; }
|
|
static get PIR () { return Constants.VB.PIR ; }
|
|
static get PSW () { return Constants.VB.PSW ; }
|
|
static get TKCW () { return Constants.VB.TKCW ; }
|
|
|
|
// Memory access data types
|
|
static get S8 () { return Constants.VB.S8 ; }
|
|
static get U8 () { return Constants.VB.U8 ; }
|
|
static get S16() { return Constants.VB.S16; }
|
|
static get U16() { return Constants.VB.U16; }
|
|
static get S32() { return Constants.VB.S32; }
|
|
|
|
// Option keys
|
|
static get PSEUDO_HALT() { return Constants.VB.PSEUDO_HALT; }
|
|
|
|
// Controller buttons
|
|
static get PWR() { return Constants.VB.PWR; }
|
|
static get SGN() { return Constants.VB.SGN; }
|
|
static get A () { return Constants.VB.A ; }
|
|
static get B () { return Constants.VB.B ; }
|
|
static get RT () { return Constants.VB.RT ; }
|
|
static get LT () { return Constants.VB.LT ; }
|
|
static get RU () { return Constants.VB.RU ; }
|
|
static get RR () { return Constants.VB.RR ; }
|
|
static get LR () { return Constants.VB.LR ; }
|
|
static get LL () { return Constants.VB.LL ; }
|
|
static get LD () { return Constants.VB.LD ; }
|
|
static get LU () { return Constants.VB.LU ; }
|
|
static get STA() { return Constants.VB.STA; }
|
|
static get SEL() { return Constants.VB.SEL; }
|
|
static get RL () { return Constants.VB.RL ; }
|
|
static get RD () { return Constants.VB.RD ; }
|
|
|
|
// Disassembler options
|
|
static get ["0X"] () { return Constants.VBU["0X"] ; }
|
|
static get ABSOLUTE () { return Constants.VBU.ABSOLUTE ; }
|
|
static get C () { return Constants.VBU.C ; }
|
|
static get DEST_FIRST() { return Constants.VBU.DEST_FIRST; }
|
|
static get DEST_LAST () { return Constants.VBU.DEST_LAST ; }
|
|
static get DOLLAR () { return Constants.VBU.DOLLAR ; }
|
|
static get E () { return Constants.VBU.E ; }
|
|
static get H () { return Constants.VBU.H ; }
|
|
static get INSIDE () { return Constants.VBU.INSIDE ; }
|
|
static get JOINED () { return Constants.VBU.JOINED ; }
|
|
static get L () { return Constants.VBU.L ; }
|
|
static get LOWER () { return Constants.VBU.LOWER ; }
|
|
static get NAMES () { return Constants.VBU.NAMES ; }
|
|
static get NUMBERS () { return Constants.VBU.NUMBERS ; }
|
|
static get OUTSIDE () { return Constants.VBU.OUTSIDE ; }
|
|
static get RELATIVE () { return Constants.VBU.RELATIVE ; }
|
|
static get SPLIT () { return Constants.VBU.SPLIT ; }
|
|
static get UPPER () { return Constants.VBU.UPPER ; }
|
|
static get Z () { return Constants.VBU.Z ; }
|
|
|
|
// Anaglyph colors
|
|
static get STEREO_CYAN () { return Constants.web.STEREO_CYAN ; }
|
|
static get STEREO_GREEN () { return Constants.web.STEREO_GREEN ; }
|
|
static get STEREO_MAGENTA() { return Constants.web.STEREO_MAGENTA; }
|
|
static get STEREO_RED () { return Constants.web.STEREO_RED ; }
|
|
|
|
|
|
|
|
///////////////////////////// Static Methods //////////////////////////////
|
|
|
|
// Create a core instance
|
|
static async create(options) {
|
|
return await new VB(GUARD).#construct(options);
|
|
}
|
|
|
|
|
|
|
|
///////////////////////// Initialization Methods //////////////////////////
|
|
|
|
constructor() {
|
|
if (arguments[0] != GUARD)
|
|
throw new Error("Must be created via VB.create()");
|
|
}
|
|
|
|
// Asynchronous constructor
|
|
async #construct(options) {
|
|
|
|
// Configure instance fields
|
|
this.#automatic = null;
|
|
this.#sims = new Map();
|
|
this.#state = VB.#SUSPENDED;
|
|
|
|
// Ensure default options
|
|
options ??= {};
|
|
options.audioUrl ??= import.meta.resolve("./Audio.js");
|
|
options.coreUrl ??= import.meta.resolve("./Core.js");
|
|
options.wasmUrl ??= import.meta.resolve("./core.wasm");
|
|
|
|
// Core<->audio communications
|
|
let channel = new MessageChannel();
|
|
|
|
// Audio output context
|
|
let audio = new AudioContext({
|
|
latencyHint: "interactive",
|
|
sampleRate : 41700
|
|
});
|
|
await audio.suspend();
|
|
|
|
// Audio node
|
|
await audio.audioWorklet.addModule(options.audioUrl);
|
|
audio = this.#audio = new AudioWorkletNode(audio, "shrooms-vb", {
|
|
numberOfInputs : 0,
|
|
numberOfOutputs : 1,
|
|
outputChannelCount: [2]
|
|
});
|
|
audio.connect(audio.context.destination);
|
|
|
|
// Send one message channel port to the audio worklet
|
|
await new Promise(resolve=>{
|
|
audio.port.onmessage = resolve;
|
|
audio.port.postMessage({
|
|
core: channel.port1
|
|
}, [channel.port1]);
|
|
});
|
|
audio.port.onmessage = null;//e=>this.#onAudio(e.data);
|
|
|
|
// Core worker
|
|
let core = this.#core = new Worker(options.coreUrl, {type: "module"});
|
|
core.promises = [];
|
|
|
|
// Send the other message channel port to the core worker
|
|
await new Promise(resolve=>{
|
|
core.onmessage = resolve;
|
|
core.postMessage({
|
|
audio : channel.port2,
|
|
wasmUrl: options.wasmUrl
|
|
}, [ channel.port2 ]);
|
|
});
|
|
core.onmessage = e=>this.#onCore(e.data);
|
|
|
|
// Establish a concealed proxy for sim objects
|
|
this.#proxy = {
|
|
core : this,
|
|
setPeer: (a,b)=>this.#setPeer(a,b),
|
|
toCore : m=>this.#toCore(m)
|
|
};
|
|
|
|
// Configure command table
|
|
this.#commands = {
|
|
// Will be used with subscriptions
|
|
};
|
|
|
|
return this;
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////// Public Methods //////////////////////////////
|
|
|
|
// Create one or more sims
|
|
async create(count = null) {
|
|
|
|
// Error checking
|
|
if (count !== null && (!Number.isSafeInteger(count) || count < 1)) {
|
|
throw new RangeError(
|
|
"Count must be a safe integer and at least 1.");
|
|
}
|
|
|
|
// Allocate memory in the core
|
|
let response = await this.#toCore({
|
|
command : "createSims",
|
|
promised: true,
|
|
count : count ?? 1
|
|
});
|
|
|
|
// Produce Sim elements for each instance
|
|
let sims = response.sims;
|
|
for (let x = 0; x < (count ?? 1); x++) {
|
|
let proxy = new Sim(GUARD).proxy;
|
|
proxy.pointer = sims[x];
|
|
proxy.sim = sims[x] =
|
|
await proxy.construct(this.#proxy, sims[x]);
|
|
this.#sims.set(sims[x], proxy);
|
|
this.#sims.set(proxy.pointer, proxy);
|
|
}
|
|
return count === null ? sims[0] : sims;
|
|
}
|
|
|
|
// Begin emulation
|
|
async emulate(sims, clocks) {
|
|
|
|
// Error checking
|
|
if (sims instanceof Sim)
|
|
sims = [sims];
|
|
if (
|
|
!Array.isArray(sims) ||
|
|
sims.length == 0 ||
|
|
sims.find(s=>!this.#sims.has(s))
|
|
) {
|
|
throw new TypeError("Must specify a Sim or array of Sims " +
|
|
"that belong to this core.");
|
|
}
|
|
if (sims.find(s=>this.#sims.get(s).isEmulating()))
|
|
throw new Error("Sims cannot already be part of emulation.");
|
|
if (
|
|
clocks !== true &&
|
|
!(Number.isSafeInteger(clocks) && clocks >= 0)
|
|
) {
|
|
throw new RangeError(
|
|
"Clocks must be true or a nonnegative safe integer.");
|
|
}
|
|
|
|
// Cannot resume automatic emulation
|
|
if (clocks === true && this.#state != VB.#SUSPENDED)
|
|
return false;
|
|
|
|
// Manage sims
|
|
let proxies = sims .map(s=>this.#sims.get(s));
|
|
let pointers = proxies.map(p=>p.pointer);
|
|
for (let sim of proxies)
|
|
sim.setEmulating(true);
|
|
|
|
// Clocked emulation
|
|
if (clocks !== true) {
|
|
let response = await this.#toCore({
|
|
command : "emulateClocked",
|
|
promised: true,
|
|
sims : pointers,
|
|
clocks : clocks
|
|
});
|
|
for (let sim of proxies)
|
|
sim.setEmulating(false);
|
|
return {
|
|
broke : response.broke,
|
|
clocks: response.clocks
|
|
};
|
|
}
|
|
|
|
// Resume automatic emulation
|
|
this.#automatic = proxies;
|
|
this.#state = VB.#RESUMING;
|
|
if (this.#audio.context.state == "suspended")
|
|
await this.#audio.context.resume();
|
|
await this.#toCore({
|
|
command : "emulateAutomatic",
|
|
promised: true,
|
|
sims : pointers
|
|
});
|
|
this.#state = VB.#EMULATING;
|
|
return true;
|
|
}
|
|
|
|
// Suspend automatic emulation
|
|
async suspend() {
|
|
|
|
// Error checking
|
|
if (this.#state != VB.#EMULATING)
|
|
return false;
|
|
|
|
// Tell the core to stop emulating
|
|
this.#state = VB.#SUSPENDING;
|
|
await this.#toCore({
|
|
command : "suspend",
|
|
promised: true
|
|
});
|
|
|
|
// Configure state
|
|
this.#state = VB.#SUSPENDED;
|
|
for (let sim of this.#automatic)
|
|
sim.setEmulating(false);
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////// Private Methods /////////////////////////////
|
|
|
|
// Message received from core worker
|
|
#onCore(message) {
|
|
if (message.promised)
|
|
this.#core.promises.shift()(message);
|
|
if ("command" in message)
|
|
this.#commands[message.command](message);
|
|
}
|
|
|
|
// Specify a new communication peer
|
|
async #setPeer(sim, peer) {
|
|
|
|
// Associate the peers on the core
|
|
let response = await this.#toCore({
|
|
command : "setPeer",
|
|
promised: true,
|
|
sim : this.#sims.get(sim).pointer,
|
|
peer : peer == null ? 0 : this.#sims.get(peer).pointer
|
|
});
|
|
|
|
// Link sims
|
|
this.#sims.get(sim).setPeer(peer);
|
|
if (peer != null)
|
|
this.#sims.get(peer).setPeer(sim);
|
|
|
|
// Unlink orphaned sims
|
|
for (let pointer of response.orphaned)
|
|
this.#sims.get(pointer).setPeer(null);
|
|
}
|
|
|
|
// Send a message to the core worker
|
|
async #toCore(message) {
|
|
let transfers = message.transfers;
|
|
if (transfers != null)
|
|
delete message.transfers;
|
|
return await new Promise(resolve=>{
|
|
if (message.promised)
|
|
this.#core.promises.push(resolve);
|
|
this.#core.postMessage(message, transfers ?? []);
|
|
});
|
|
}
|
|
|
|
}
|
|
|
|
export { VB };
|