diff --git a/.idea/artifacts/TSVM_Executable.xml b/.idea/artifacts/TerranBASIC.xml similarity index 94% rename from .idea/artifacts/TSVM_Executable.xml rename to .idea/artifacts/TerranBASIC.xml index 75f8f4b..9e4dfec 100644 --- a/.idea/artifacts/TSVM_Executable.xml +++ b/.idea/artifacts/TerranBASIC.xml @@ -1,13 +1,32 @@ - - $PROJECT_DIR$/out/artifacts/TSVM_Executable - - + + $PROJECT_DIR$/out/artifacts/TerranBASIC + - + - + + + + + + + + + + + + + + + + + + + + + @@ -45,25 +64,7 @@ - - - - - - - - - - - - - - - - - - - + \ No newline at end of file diff --git a/.idea/artifacts/TerrarumTSVM.xml b/.idea/artifacts/TerrarumTSVM.xml new file mode 100644 index 0000000..de20b74 --- /dev/null +++ b/.idea/artifacts/TerrarumTSVM.xml @@ -0,0 +1,8 @@ + + + $PROJECT_DIR$/out/artifacts/TerrarumTSVM + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml index 3b2904e..25177de 100644 --- a/.idea/modules.xml +++ b/.idea/modules.xml @@ -2,7 +2,10 @@ - + + + + \ No newline at end of file diff --git a/.idea/runConfigurations.xml b/.idea/runConfigurations.xml new file mode 100644 index 0000000..797acea --- /dev/null +++ b/.idea/runConfigurations.xml @@ -0,0 +1,10 @@ + + + + + + \ No newline at end of file diff --git a/.idea/uiDesigner.xml b/.idea/uiDesigner.xml new file mode 100644 index 0000000..e96534f --- /dev/null +++ b/.idea/uiDesigner.xml @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/TerranBASICexecutable/META-INF/MANIFEST.MF b/TerranBASICexecutable/META-INF/MANIFEST.MF new file mode 100644 index 0000000..191d8f6 --- /dev/null +++ b/TerranBASICexecutable/META-INF/MANIFEST.MF @@ -0,0 +1,3 @@ +Manifest-Version: 1.0 +Main-Class: net.torvald.tsvm.TerranBASIC + diff --git a/tsvm.iml b/TerranBASICexecutable/TerranBASICexecutable.iml similarity index 96% rename from tsvm.iml rename to TerranBASICexecutable/TerranBASICexecutable.iml index 7165379..d54dca1 100644 --- a/tsvm.iml +++ b/TerranBASICexecutable/TerranBASICexecutable.iml @@ -7,16 +7,17 @@ - - - + - - - - + + + + + + + \ No newline at end of file diff --git a/TerranBASICexecutable/src/net/torvald/tsvm/TerranBASIC.java b/TerranBASICexecutable/src/net/torvald/tsvm/TerranBASIC.java new file mode 100644 index 0000000..3368baa --- /dev/null +++ b/TerranBASICexecutable/src/net/torvald/tsvm/TerranBASIC.java @@ -0,0 +1,32 @@ +package net.torvald.tsvm; + +import com.badlogic.gdx.backends.lwjgl3.Lwjgl3Application; +import com.badlogic.gdx.backends.lwjgl3.Lwjgl3ApplicationConfiguration; +import com.badlogic.gdx.graphics.glutils.ShaderProgram; +import net.torvald.tsvm.peripheral.*; + +public class TerranBASIC { + + public static String appTitle = "TerranBASIC"; + public static Lwjgl3ApplicationConfiguration appConfig; + + public static int WIDTH = 640; + public static int HEIGHT = 480; + + public static void main(String[] args) { + ShaderProgram.pedantic = false; + + appConfig = new Lwjgl3ApplicationConfiguration(); + appConfig.setIdleFPS(60); + appConfig.setForegroundFPS(60); + appConfig.useVsync(false); + appConfig.setResizable(false); + appConfig.setTitle(appTitle); + + appConfig.setWindowedMode(WIDTH, HEIGHT); + + VM tbasvm = new VM(64 << 10, new TheRealWorld(), new VMProgramRom[]{TBASRelBios.INSTANCE}); + EmulInstance tbasrunner = new EmulInstance(tbasvm, "net.torvald.tsvm.peripheral.ReferenceGraphicsAdapter", "assets/disk0", 560, 448); + new Lwjgl3Application(new VMGUI(tbasrunner, WIDTH, HEIGHT), appConfig); + } +} diff --git a/TerranBASICexecutable/src/net/torvald/tsvm/VMGUI.kt b/TerranBASICexecutable/src/net/torvald/tsvm/VMGUI.kt new file mode 100644 index 0000000..4b24884 --- /dev/null +++ b/TerranBASICexecutable/src/net/torvald/tsvm/VMGUI.kt @@ -0,0 +1,264 @@ +package net.torvald.tsvm + +import com.badlogic.gdx.ApplicationAdapter +import com.badlogic.gdx.Gdx +import com.badlogic.gdx.graphics.* +import com.badlogic.gdx.graphics.g2d.SpriteBatch +import kotlinx.coroutines.* +import net.torvald.tsvm.peripheral.* +import java.io.File + +class EmulInstance( + val vm: VM, + val display: String?, + val diskPath: String = "assets/disk0", + val drawWidth: Int, + val drawHeight: Int, +) { + + var extraPeripherals: List> = listOf(); private set + + constructor( + vm: VM, + display: String?, + diskPath: String = "assets/disk0", + drawWidth: Int, + drawHeight: Int, + extraPeripherals: List> + ) : this(vm, display, diskPath, drawWidth, drawHeight) { + this.extraPeripherals = extraPeripherals + } + +} + +class VMGUI(val loaderInfo: EmulInstance, val viewportWidth: Int, val viewportHeight: Int) : ApplicationAdapter() { + + val vm = loaderInfo.vm + + lateinit var batch: SpriteBatch + lateinit var camera: OrthographicCamera + + var gpu: GraphicsAdapter? = null + lateinit var vmRunner: VMRunner + lateinit var coroutineJob: Job + lateinit var fullscreenQuad: Mesh + + override fun create() { + super.create() + + fullscreenQuad = Mesh( + true, 4, 6, + VertexAttribute.Position(), + VertexAttribute.ColorUnpacked(), + VertexAttribute.TexCoords(0) + ) + updateFullscreenQuad(TerranBASIC.WIDTH, TerranBASIC.HEIGHT) + + batch = SpriteBatch() + camera = OrthographicCamera(TerranBASIC.WIDTH.toFloat(), TerranBASIC.HEIGHT.toFloat()) + camera.setToOrtho(false) + camera.update() + batch.projectionMatrix = camera.combined + + + init() + } + + private fun init() { + if (loaderInfo.display != null) { + val loadedClass = Class.forName(loaderInfo.display) + val loadedClassConstructor = loadedClass.getConstructor(vm::class.java) + val loadedClassInstance = loadedClassConstructor.newInstance(vm) + gpu = (loadedClassInstance as GraphicsAdapter) + + vm.getIO().blockTransferPorts[0].attachDevice(TestDiskDrive(vm, 0, File(loaderInfo.diskPath))) + + vm.peripheralTable[1] = PeripheralEntry( + gpu, + GraphicsAdapter.VRAM_SIZE, + 16, + 0 + ) + + vm.getPrintStream = { gpu!!.getPrintStream() } + vm.getErrorStream = { gpu!!.getErrorStream() } + vm.getInputStream = { gpu!!.getInputStream() } + } + else { + vm.getPrintStream = { System.out } + vm.getErrorStream = { System.err } + vm.getInputStream = { System.`in` } + } + + loaderInfo.extraPeripherals.forEach { (port, peri) -> + val typeargs = peri.args.map { it.javaClass }.toTypedArray() + + val loadedClass = Class.forName(peri.peripheralClassname) + val loadedClassConstructor = loadedClass.getConstructor(*typeargs) + val loadedClassInstance = loadedClassConstructor.newInstance(*peri.args) + + vm.peripheralTable[port] = PeripheralEntry( + loadedClassInstance as PeriBase, + peri.memsize, + peri.mmioSize, + peri.interruptCount + ) + } + + Gdx.input.inputProcessor = vm.getIO() + + + vmRunner = VMRunnerFactory(vm, "js") + coroutineJob = GlobalScope.launch { + vmRunner.executeCommand(vm.roms[0]!!.readAll()) + } + } + + private var rebootRequested = false + + private fun reboot() { + vmRunner.close() + coroutineJob.cancel("reboot requested") + + vm.init() + init() + } + + private var updateAkku = 0.0 + private var updateRate = 1f / 60f + + override fun render() { + gdxClearAndSetBlend(.094f, .094f, .094f, 0f) + setCameraPosition(0f, 0f) + + // update window title with contents of the 'built-in status display' + val msg = (1024L until 1048L).map { cp437toUni[vm.getIO().mmio_read(it)!!.toInt().and(255)] }.joinToString("").trim() + Gdx.graphics.setTitle("$msg $EMDASH F: ${Gdx.graphics.framesPerSecond}") + + super.render() + + val dt = Gdx.graphics.rawDeltaTime + updateAkku += dt + + var i = 0L + while (updateAkku >= updateRate) { + updateGame(updateRate) + updateAkku -= updateRate + i += 1 + } + + renderGame(dt) + } + + private fun updateGame(delta: Float) { + if (!vm.resetDown && rebootRequested) { + reboot() + rebootRequested = false + } + + vm.update(delta) + + if (vm.resetDown) rebootRequested = true + } + + fun poke(addr: Long, value: Byte) = vm.poke(addr, value) + + private val defaultGuiBackgroundColour = Color(0x444444ff) + + private fun renderGame(delta: Float) { + val clearCol = gpu?.getBackgroundColour() ?: defaultGuiBackgroundColour + Gdx.gl.glClearColor(clearCol.r, clearCol.g, clearCol.b, clearCol.a) + Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT) + gpu?.render(delta, batch, (viewportWidth - loaderInfo.drawWidth).div(2).toFloat(), (viewportHeight - loaderInfo.drawHeight).div(2).toFloat()) + + vm.findPeribyType("oled")?.let { + val disp = it.peripheral as ExtDisp + + disp.render(batch, + (viewportWidth - loaderInfo.drawWidth).div(2).toFloat() + (gpu?.config?.width ?: 0), + (viewportHeight - loaderInfo.drawHeight).div(2).toFloat()) + } + } + + private fun setCameraPosition(newX: Float, newY: Float) { + camera.position.set((-newX + TerranBASIC.WIDTH / 2), (-newY + TerranBASIC.HEIGHT / 2), 0f) // deliberate integer division + camera.update() + batch.setProjectionMatrix(camera.combined) + } + + private fun gdxClearAndSetBlend(r: Float, g: Float, b: Float, a: Float) { + Gdx.gl.glClearColor(r,g,b,a) + Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT) + Gdx.gl.glEnable(GL20.GL_TEXTURE_2D) + Gdx.gl.glEnable(GL20.GL_BLEND) + } + + private fun updateFullscreenQuad(WIDTH: Int, HEIGHT: Int) { // NOT y-flipped quads! + fullscreenQuad.setVertices(floatArrayOf( + 0f, 0f, 0f, 1f, 1f, 1f, 1f, 0f, 1f, + WIDTH.toFloat(), 0f, 0f, 1f, 1f, 1f, 1f, 1f, 1f, + WIDTH.toFloat(), HEIGHT.toFloat(), 0f, 1f, 1f, 1f, 1f, 1f, 0f, + 0f, HEIGHT.toFloat(), 0f, 1f, 1f, 1f, 1f, 0f, 0f + )) + fullscreenQuad.setIndices(shortArrayOf(0, 1, 2, 2, 3, 0)) + } + + override fun dispose() { + super.dispose() + batch.dispose() + fullscreenQuad.dispose() + coroutineJob.cancel() + vm.dispose() + } + + companion object { + val cp437toUni = hashMapOf( + 0 to 32.toChar(), + 1 to 0x263A.toChar(), + 2 to 0x263B.toChar(), + 3 to 0x2665.toChar(), + 4 to 0x2666.toChar(), + 5 to 0x2663.toChar(), + 6 to 0x2660.toChar(), + 7 to 0x2022.toChar(), + 8 to 0x25D8.toChar(), + 9 to 0x25CB.toChar(), + 10 to 0x25D9.toChar(), + 11 to 0x2642.toChar(), + 12 to 0x2640.toChar(), + 13 to 0x266A.toChar(), + 14 to 0x266B.toChar(), + 15 to 0x00A4.toChar(), + + 16 to 0x25BA.toChar(), + 17 to 0x25C4.toChar(), + 18 to 0x2195.toChar(), + 19 to 0x203C.toChar(), + 20 to 0x00B6.toChar(), + 21 to 0x00A7.toChar(), + 22 to 0x25AC.toChar(), + 23 to 0x21A8.toChar(), + 24 to 0x2191.toChar(), + 25 to 0x2193.toChar(), + 26 to 0x2192.toChar(), + 27 to 0x2190.toChar(), + 28 to 0x221F.toChar(), + 29 to 0x2194.toChar(), + 30 to 0x25B2.toChar(), + 31 to 0x25BC.toChar(), + + 127 to 0x2302.toChar(), + + 158 to 0x2610.toChar(), + 159 to 0x2611.toChar() + ) + + init { + for (k in 32..126) { + cp437toUni[k] = k.toChar() + } + } + } +} + +const val EMDASH = 0x2014.toChar() \ No newline at end of file diff --git a/src/net/torvald/random/HQRNG.java b/src/net/torvald/random/HQRNG.java deleted file mode 100644 index 1ead5a0..0000000 --- a/src/net/torvald/random/HQRNG.java +++ /dev/null @@ -1,194 +0,0 @@ -package net.torvald.random; - -import java.util.Random; - -/** - * Xoroshiro128 - * - * Note: low 4 bits are considered "dirty"; avoid these bits for making random set of booleans - * - * see https://github.com/SquidPony/SquidLib/blob/master/squidlib-util/src/main/java/squidpony/squidmath/XoRoRNG.java - */ -public class HQRNG extends Random { - - private static final long DOUBLE_MASK = (1L << 53) - 1; - private static final double NORM_53 = 1. / (1L << 53); - private static final long FLOAT_MASK = (1L << 24) - 1; - private static final double NORM_24 = 1. / (1L << 24); - - private static final long serialVersionUID = 1018744536171610262L; - - private long state0, state1; - - public long getState0() { - return state0; - } - - public long getState1() { - return state1; - } - - /** - * Creates a new generator seeded using four calls to Math.random(). - */ - public HQRNG() { - this((long) ((Math.random() - 0.5) * 0x10000000000000L) - ^ (long) (((Math.random() - 0.5) * 2.0) * 0x8000000000000000L), - (long) ((Math.random() - 0.5) * 0x10000000000000L) - ^ (long) (((Math.random() - 0.5) * 2.0) * 0x8000000000000000L)); - } - /** - * Constructs this XoRoRNG by dispersing the bits of seed using {@link #setSeed(long)} across the two parts of state - * this has. - * @param seed a long that won't be used exactly, but will affect both components of state - */ - public HQRNG(final long seed) { - setSeed(seed); - } - /** - * Constructs this XoRoRNG by calling {@link #setSeed(long, long)} on the arguments as given; see that method for - * the specific details (stateA and stateB are kept as-is unless they are both 0). - * @param stateA the number to use as the first part of the state; this will be 1 instead if both seeds are 0 - * @param stateB the number to use as the second part of the state - */ - public HQRNG(final long stateA, final long stateB) { - setSeed(stateA, stateB); - } - - @Override - public final int next(int bits) { - final long s0 = state0; - long s1 = state1; - final int result = (int)(s0 + s1) >>> (32 - bits); - s1 ^= s0; - state0 = (s0 << 55 | s0 >>> 9) ^ s1 ^ (s1 << 14); // a, b - state1 = (s1 << 36 | s1 >>> 28); // c - return result; - } - - @Override - public final long nextLong() { - final long s0 = state0; - long s1 = state1; - final long result = s0 + s1; - - s1 ^= s0; - state0 = (s0 << 55 | s0 >>> 9) ^ s1 ^ (s1 << 14); // a, b - state1 = (s1 << 36 | s1 >>> 28); // c - /* - state0 = Long.rotateLeft(s0, 55) ^ s1 ^ (s1 << 14); // a, b - state1 = Long.rotateLeft(s1, 36); // c - */ - return result; - } - - /** - * Can return any int, positive or negative, of any size permissible in a 32-bit signed integer. - * @return any int, all 32 bits are random - */ - public int nextInt() { - return (int)nextLong(); - } - - /** - * Exclusive on the outer bound; the inner bound is 0. The bound may be negative, which will produce a non-positive - * result. - * @param bound the outer exclusive bound; may be positive or negative - * @return a random int between 0 (inclusive) and bound (exclusive) - */ - public int nextInt(final int bound) { - return (int) ((bound * (nextLong() >>> 33)) >> 31); - } - /** - * Inclusive lower, exclusive upper. - * @param inner the inner bound, inclusive, can be positive or negative - * @param outer the outer bound, exclusive, should be positive, should usually be greater than inner - * @return a random int that may be equal to inner and will otherwise be between inner and outer - */ - public int nextInt(final int inner, final int outer) { - return inner + nextInt(outer - inner); - } - - /** - * Exclusive on the outer bound; the inner bound is 0. The bound may be negative, which will produce a non-positive - * result. - * @param bound the outer exclusive bound; may be positive or negative - * @return a random long between 0 (inclusive) and bound (exclusive) - */ - public long nextLong(long bound) { - long rand = nextLong(); - final long randLow = rand & 0xFFFFFFFFL; - final long boundLow = bound & 0xFFFFFFFFL; - rand >>>= 32; - bound >>= 32; - final long z = (randLow * boundLow >> 32); - long t = rand * boundLow + z; - final long tLow = t & 0xFFFFFFFFL; - t >>>= 32; - return rand * bound + t + (tLow + randLow * bound >> 32) - (z >> 63) - (bound >> 63); - } - /** - * Inclusive inner, exclusive outer; both inner and outer can be positive or negative. - * @param inner the inner bound, inclusive, can be positive or negative - * @param outer the outer bound, exclusive, can be positive or negative and may be greater than or less than inner - * @return a random long that may be equal to inner and will otherwise be between inner and outer - */ - public long nextLong(final long inner, final long outer) { - return inner + nextLong(outer - inner); - } - - public double nextDouble() { - return (nextLong() & DOUBLE_MASK) * NORM_53; - } - - public float nextFloat() { - return (float) ((nextLong() & FLOAT_MASK) * NORM_24); - } - - public boolean nextBoolean() { - return nextLong() < 0L; - } - - public void nextBytes(final byte[] bytes) { - int i = bytes.length, n = 0; - while (i != 0) { - n = Math.min(i, 8); - for (long bits = nextLong(); n-- != 0; bits >>>= 8) { - bytes[--i] = (byte) bits; - } - } - } - - /** - * Sets the seed of this generator using one long, running that through LightRNG's algorithm twice to get the state. - * @param seed the number to use as the seed - */ - public void setSeed(final long seed) { - - long state = seed + 0x9E3779B97F4A7C15L, - z = state; - z = (z ^ (z >>> 30)) * 0xBF58476D1CE4E5B9L; - z = (z ^ (z >>> 27)) * 0x94D049BB133111EBL; - state0 = z ^ (z >>> 31); - state += 0x9E3779B97F4A7C15L; - z = state; - z = (z ^ (z >>> 30)) * 0xBF58476D1CE4E5B9L; - z = (z ^ (z >>> 27)) * 0x94D049BB133111EBL; - state1 = z ^ (z >>> 31); - } - - /** - * Sets the seed of this generator using two longs, using them without changes unless both are 0 (then it makes the - * state variable corresponding to stateA 1 instead). - * @param stateA the number to use as the first part of the state; this will be 1 instead if both seeds are 0 - * @param stateB the number to use as the second part of the state - */ - public void setSeed(final long stateA, final long stateB) { - - state0 = stateA; - state1 = stateB; - if((stateA | stateB) == 0L) - state0 = 1L; - } - -} diff --git a/src/main/resources/META-INF/services/javax.script.ScriptEngineFactory b/tsvm_core/src/main/resources/META-INF/services/javax.script.ScriptEngineFactory similarity index 100% rename from src/main/resources/META-INF/services/javax.script.ScriptEngineFactory rename to tsvm_core/src/main/resources/META-INF/services/javax.script.ScriptEngineFactory diff --git a/src/net/torvald/tsvm/Base64Delegate.kt b/tsvm_core/src/net/torvald/tsvm/Base64Delegate.kt similarity index 100% rename from src/net/torvald/tsvm/Base64Delegate.kt rename to tsvm_core/src/net/torvald/tsvm/Base64Delegate.kt diff --git a/src/net/torvald/util/CircularArray.kt b/tsvm_core/src/net/torvald/tsvm/CircularArray.kt similarity index 97% rename from src/net/torvald/util/CircularArray.kt rename to tsvm_core/src/net/torvald/tsvm/CircularArray.kt index 6c6f0ad..a8bc746 100644 --- a/src/net/torvald/util/CircularArray.kt +++ b/tsvm_core/src/net/torvald/tsvm/CircularArray.kt @@ -1,4 +1,4 @@ -package net.torvald.util +package net.torvald.tsvm import java.util.* @@ -13,7 +13,7 @@ import java.util.* * * Created by minjaesong on 2017-01-22. */ -class CircularArray(val size: Int, val overwriteOnOverflow: Boolean): Iterable { +internal class CircularArray(val size: Int, val overwriteOnOverflow: Boolean): Iterable { /** * What to do RIGHT BEFORE old element is being overridden by the new element (only makes sense when ```overwriteOnOverflow = true```) diff --git a/src/net/torvald/tsvm/CompressorDelegate.kt b/tsvm_core/src/net/torvald/tsvm/CompressorDelegate.kt similarity index 100% rename from src/net/torvald/tsvm/CompressorDelegate.kt rename to tsvm_core/src/net/torvald/tsvm/CompressorDelegate.kt diff --git a/src/net/torvald/tsvm/DMADelegate.kt b/tsvm_core/src/net/torvald/tsvm/DMADelegate.kt similarity index 100% rename from src/net/torvald/tsvm/DMADelegate.kt rename to tsvm_core/src/net/torvald/tsvm/DMADelegate.kt diff --git a/src/net/torvald/tsvm/FilesystemDelegate.kt b/tsvm_core/src/net/torvald/tsvm/FilesystemDelegate.kt similarity index 100% rename from src/net/torvald/tsvm/FilesystemDelegate.kt rename to tsvm_core/src/net/torvald/tsvm/FilesystemDelegate.kt diff --git a/src/net/torvald/tsvm/GraphicsJSR223Delegate.kt b/tsvm_core/src/net/torvald/tsvm/GraphicsJSR223Delegate.kt similarity index 100% rename from src/net/torvald/tsvm/GraphicsJSR223Delegate.kt rename to tsvm_core/src/net/torvald/tsvm/GraphicsJSR223Delegate.kt diff --git a/tsvm_core/src/net/torvald/tsvm/LoadShader.kt b/tsvm_core/src/net/torvald/tsvm/LoadShader.kt new file mode 100644 index 0000000..08d1183 --- /dev/null +++ b/tsvm_core/src/net/torvald/tsvm/LoadShader.kt @@ -0,0 +1,18 @@ +package net.torvald.tsvm + +import com.badlogic.gdx.graphics.glutils.ShaderProgram + +/** + * Created by minjaesong on 2021-12-03. + */ +internal object LoadShader { + operator fun invoke(vert: String, frag: String): ShaderProgram { + val s = ShaderProgram(vert, frag) + + if (s.log.toLowerCase().contains("error")) { + throw Error(String.format("Shader program loaded with %s, %s failed:\n%s", vert, frag, s.log)) + } + + return s + } +} \ No newline at end of file diff --git a/src/net/torvald/tsvm/SerialHelper.kt b/tsvm_core/src/net/torvald/tsvm/SerialHelper.kt similarity index 100% rename from src/net/torvald/tsvm/SerialHelper.kt rename to tsvm_core/src/net/torvald/tsvm/SerialHelper.kt diff --git a/src/net/torvald/terrarumsansbitmap/gdx/TextureRegionPack.kt b/tsvm_core/src/net/torvald/tsvm/TextureRegionPack.kt similarity index 98% rename from src/net/torvald/terrarumsansbitmap/gdx/TextureRegionPack.kt rename to tsvm_core/src/net/torvald/tsvm/TextureRegionPack.kt index 52a3e5a..e4a456a 100755 --- a/src/net/torvald/terrarumsansbitmap/gdx/TextureRegionPack.kt +++ b/tsvm_core/src/net/torvald/tsvm/TextureRegionPack.kt @@ -22,7 +22,7 @@ * SOFTWARE. */ -package net.torvald.terrarumsansbitmap.gdx +package net.torvald.tsvm import com.badlogic.gdx.files.FileHandle import com.badlogic.gdx.graphics.Texture diff --git a/src/net/torvald/tsvm/UnsafePtr.kt b/tsvm_core/src/net/torvald/tsvm/UnsafePtr.kt similarity index 100% rename from src/net/torvald/tsvm/UnsafePtr.kt rename to tsvm_core/src/net/torvald/tsvm/UnsafePtr.kt diff --git a/src/net/torvald/tsvm/VM.kt b/tsvm_core/src/net/torvald/tsvm/VM.kt similarity index 97% rename from src/net/torvald/tsvm/VM.kt rename to tsvm_core/src/net/torvald/tsvm/VM.kt index da6187c..3d03b3c 100644 --- a/src/net/torvald/tsvm/VM.kt +++ b/tsvm_core/src/net/torvald/tsvm/VM.kt @@ -34,7 +34,7 @@ class VM( val peripheralTable = Array(8) { PeripheralEntry() } - internal fun getIO(): IOSpace = peripheralTable[0].peripheral as IOSpace + fun getIO(): IOSpace = peripheralTable[0].peripheral as IOSpace //lateinit var printStream: OutputStream //lateinit var errorStream: OutputStream @@ -121,7 +121,7 @@ class VM( } } - internal fun poke(addr: Long, value: Byte) { + fun poke(addr: Long, value: Byte) { val (memspace, offset) = translateAddr(addr) if (memspace == null) throw ErrorIllegalAccess(this, addr) @@ -135,7 +135,7 @@ class VM( (memspace as PeriBase).poke(offset, value) } - internal fun peek(addr:Long): Byte? { + fun peek(addr:Long): Byte? { val (memspace, offset) = translateAddr(addr) return if (memspace == null) null diff --git a/src/net/torvald/tsvm/VMJSR223Delegate.kt b/tsvm_core/src/net/torvald/tsvm/VMJSR223Delegate.kt similarity index 100% rename from src/net/torvald/tsvm/VMJSR223Delegate.kt rename to tsvm_core/src/net/torvald/tsvm/VMJSR223Delegate.kt diff --git a/src/net/torvald/tsvm/VMRunnerFactory.kt b/tsvm_core/src/net/torvald/tsvm/VMRunnerFactory.kt similarity index 96% rename from src/net/torvald/tsvm/VMRunnerFactory.kt rename to tsvm_core/src/net/torvald/tsvm/VMRunnerFactory.kt index 1996ef8..2bb80de 100644 --- a/src/net/torvald/tsvm/VMRunnerFactory.kt +++ b/tsvm_core/src/net/torvald/tsvm/VMRunnerFactory.kt @@ -1,7 +1,5 @@ package net.torvald.tsvm -import net.torvald.tsvm.peripheral.GraphicsAdapter -import net.torvald.tsvm.vdc.Videotron2K import org.graalvm.polyglot.Context import org.graalvm.polyglot.HostAccess import java.io.FileReader @@ -27,7 +25,7 @@ object VMRunnerFactory { } return when (extension) { - "vt2" -> { + /*"vt2" -> { object : VMRunner(extension) { val engine = @@ -45,7 +43,7 @@ object VMRunnerFactory { TODO("Not yet implemented") } } - } + }*/ "js" -> { object : VMRunner(extension) { private val context = Context.newBuilder("js") diff --git a/src/net/torvald/tsvm/WorldInterface.kt b/tsvm_core/src/net/torvald/tsvm/WorldInterface.kt similarity index 100% rename from src/net/torvald/tsvm/WorldInterface.kt rename to tsvm_core/src/net/torvald/tsvm/WorldInterface.kt diff --git a/src/net/torvald/tsvm/peripheral/BlockTransferInterface.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/BlockTransferInterface.kt similarity index 96% rename from src/net/torvald/tsvm/peripheral/BlockTransferInterface.kt rename to tsvm_core/src/net/torvald/tsvm/peripheral/BlockTransferInterface.kt index 3c95247..0cca5d5 100644 --- a/src/net/torvald/tsvm/peripheral/BlockTransferInterface.kt +++ b/tsvm_core/src/net/torvald/tsvm/peripheral/BlockTransferInterface.kt @@ -96,4 +96,6 @@ fun ByteArray.trimNull(): ByteArray { cnt -= 1 } return this.sliceArray(0..cnt) -} \ No newline at end of file +} + +fun ByteArray.startsWith(other: ByteArray) = this.sliceArray(other.indices).contentEquals(other) diff --git a/src/net/torvald/tsvm/peripheral/BlockTransferPort.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/BlockTransferPort.kt similarity index 100% rename from src/net/torvald/tsvm/peripheral/BlockTransferPort.kt rename to tsvm_core/src/net/torvald/tsvm/peripheral/BlockTransferPort.kt diff --git a/src/net/torvald/tsvm/peripheral/CharacterLCDdisplay.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/CharacterLCDdisplay.kt similarity index 98% rename from src/net/torvald/tsvm/peripheral/CharacterLCDdisplay.kt rename to tsvm_core/src/net/torvald/tsvm/peripheral/CharacterLCDdisplay.kt index 49683b9..131aafe 100644 --- a/src/net/torvald/tsvm/peripheral/CharacterLCDdisplay.kt +++ b/tsvm_core/src/net/torvald/tsvm/peripheral/CharacterLCDdisplay.kt @@ -4,7 +4,7 @@ import com.badlogic.gdx.graphics.Color import com.badlogic.gdx.graphics.Texture import com.badlogic.gdx.graphics.g2d.SpriteBatch import net.torvald.terrarum.modulecomputers.virtualcomputer.tvd.toUlong -import net.torvald.terrarumsansbitmap.gdx.TextureRegionPack +import net.torvald.tsvm.TextureRegionPack import net.torvald.tsvm.VM class CharacterLCDdisplay(vm: VM) : GraphicsAdapter(vm, AdapterConfig( diff --git a/src/net/torvald/tsvm/peripheral/ExtDisp.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/ExtDisp.kt similarity index 96% rename from src/net/torvald/tsvm/peripheral/ExtDisp.kt rename to tsvm_core/src/net/torvald/tsvm/peripheral/ExtDisp.kt index c2893f5..a7e0325 100644 --- a/src/net/torvald/tsvm/peripheral/ExtDisp.kt +++ b/tsvm_core/src/net/torvald/tsvm/peripheral/ExtDisp.kt @@ -5,7 +5,7 @@ import com.badlogic.gdx.graphics.Pixmap import com.badlogic.gdx.graphics.Texture import com.badlogic.gdx.graphics.g2d.SpriteBatch import com.badlogic.gdx.math.Matrix4 -import net.torvald.tsvm.AppLoader +import net.torvald.tsvm.LoadShader import net.torvald.tsvm.VM /** @@ -28,7 +28,7 @@ class ExtDisp(val vm: VM, val width: Int, val height: Int) : PeriBase { internal val framebuffer = Pixmap(width, height, Pixmap.Format.Alpha) private val outFBObatch = SpriteBatch() - protected val drawShader = AppLoader.loadShaderInline(GraphicsAdapter.DRAW_SHADER_VERT, OLED_PAL_SHADER) + protected val drawShader = LoadShader(GraphicsAdapter.DRAW_SHADER_VERT, OLED_PAL_SHADER) init { // no orthographic camera, must be "raw" Matrix4 diff --git a/src/net/torvald/tsvm/peripheral/GlassTty.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/GlassTty.kt similarity index 100% rename from src/net/torvald/tsvm/peripheral/GlassTty.kt rename to tsvm_core/src/net/torvald/tsvm/peripheral/GlassTty.kt diff --git a/src/net/torvald/tsvm/peripheral/GraphicsAdapter.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/GraphicsAdapter.kt similarity index 99% rename from src/net/torvald/tsvm/peripheral/GraphicsAdapter.kt rename to tsvm_core/src/net/torvald/tsvm/peripheral/GraphicsAdapter.kt index 0fe293a..574236a 100644 --- a/src/net/torvald/tsvm/peripheral/GraphicsAdapter.kt +++ b/tsvm_core/src/net/torvald/tsvm/peripheral/GraphicsAdapter.kt @@ -11,7 +11,7 @@ import com.badlogic.gdx.math.Matrix4 import com.badlogic.gdx.utils.GdxRuntimeException import net.torvald.UnsafeHelper import net.torvald.terrarum.modulecomputers.virtualcomputer.tvd.toUint -import net.torvald.tsvm.AppLoader +import net.torvald.tsvm.LoadShader import net.torvald.tsvm.VM import net.torvald.tsvm.kB import net.torvald.tsvm.peripheral.GraphicsAdapter.Companion.DRAW_SHADER_FRAG @@ -79,8 +79,8 @@ open class GraphicsAdapter(val vm: VM, val config: AdapterConfig, val sgr: Super internal val textArea = UnsafeHelper.allocate(7682) internal val unusedArea = UnsafeHelper.allocate(1024) - protected val paletteShader = AppLoader.loadShaderInline(DRAW_SHADER_VERT, config.paletteShader) - protected val textShader = AppLoader.loadShaderInline(DRAW_SHADER_VERT, config.fragShader) + protected val paletteShader = LoadShader(DRAW_SHADER_VERT, config.paletteShader) + protected val textShader = LoadShader(DRAW_SHADER_VERT, config.fragShader) override var blinkCursor = true override var ttyRawMode = false diff --git a/src/net/torvald/tsvm/peripheral/IOSpace.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/IOSpace.kt similarity index 99% rename from src/net/torvald/tsvm/peripheral/IOSpace.kt rename to tsvm_core/src/net/torvald/tsvm/peripheral/IOSpace.kt index 6bc142c..53355a3 100644 --- a/src/net/torvald/tsvm/peripheral/IOSpace.kt +++ b/tsvm_core/src/net/torvald/tsvm/peripheral/IOSpace.kt @@ -4,9 +4,8 @@ import com.badlogic.gdx.Gdx import com.badlogic.gdx.Input import com.badlogic.gdx.InputProcessor import net.torvald.UnsafeHelper +import net.torvald.tsvm.CircularArray import net.torvald.tsvm.VM -import net.torvald.util.CircularArray -import java.io.File import kotlin.experimental.and class IOSpace(val vm: VM) : PeriBase, InputProcessor { diff --git a/src/net/torvald/tsvm/peripheral/PeriBase.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/PeriBase.kt similarity index 100% rename from src/net/torvald/tsvm/peripheral/PeriBase.kt rename to tsvm_core/src/net/torvald/tsvm/peripheral/PeriBase.kt diff --git a/src/net/torvald/tsvm/peripheral/TTY.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/TTY.kt similarity index 100% rename from src/net/torvald/tsvm/peripheral/TTY.kt rename to tsvm_core/src/net/torvald/tsvm/peripheral/TTY.kt diff --git a/src/net/torvald/tsvm/peripheral/TermSim.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/TermSim.kt similarity index 100% rename from src/net/torvald/tsvm/peripheral/TermSim.kt rename to tsvm_core/src/net/torvald/tsvm/peripheral/TermSim.kt diff --git a/src/net/torvald/tsvm/peripheral/TestDiskDrive.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/TestDiskDrive.kt similarity index 100% rename from src/net/torvald/tsvm/peripheral/TestDiskDrive.kt rename to tsvm_core/src/net/torvald/tsvm/peripheral/TestDiskDrive.kt diff --git a/src/net/torvald/tsvm/peripheral/TestFunctionGenerator.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/TestFunctionGenerator.kt similarity index 100% rename from src/net/torvald/tsvm/peripheral/TestFunctionGenerator.kt rename to tsvm_core/src/net/torvald/tsvm/peripheral/TestFunctionGenerator.kt diff --git a/src/net/torvald/tsvm/peripheral/TexticsAdapter.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/TexticsAdapter.kt similarity index 100% rename from src/net/torvald/tsvm/peripheral/TexticsAdapter.kt rename to tsvm_core/src/net/torvald/tsvm/peripheral/TexticsAdapter.kt diff --git a/src/net/torvald/tsvm/peripheral/VMProgramRom.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/VMProgramRom.kt similarity index 97% rename from src/net/torvald/tsvm/peripheral/VMProgramRom.kt rename to tsvm_core/src/net/torvald/tsvm/peripheral/VMProgramRom.kt index 0f05fd8..3e4d9b8 100644 --- a/src/net/torvald/tsvm/peripheral/VMProgramRom.kt +++ b/tsvm_core/src/net/torvald/tsvm/peripheral/VMProgramRom.kt @@ -3,7 +3,6 @@ package net.torvald.tsvm.peripheral import net.torvald.tsvm.CompressorDelegate import net.torvald.tsvm.CompressorDelegate.GZIP_HEADER import net.torvald.tsvm.VM -import net.torvald.tsvm.startsWith import java.io.File open class VMProgramRom(path: String) { diff --git a/src/net/torvald/tsvm/vdc/V2kParserTest.kt b/tsvm_core/src/net/torvald/tsvm/vdc/V2kParserTest.kt similarity index 100% rename from src/net/torvald/tsvm/vdc/V2kParserTest.kt rename to tsvm_core/src/net/torvald/tsvm/vdc/V2kParserTest.kt diff --git a/src/net/torvald/tsvm/vdc/V2kRunTest.kt b/tsvm_core/src/net/torvald/tsvm/vdc/V2kRunTest.kt similarity index 87% rename from src/net/torvald/tsvm/vdc/V2kRunTest.kt rename to tsvm_core/src/net/torvald/tsvm/vdc/V2kRunTest.kt index 572c101..5465f05 100644 --- a/src/net/torvald/tsvm/vdc/V2kRunTest.kt +++ b/tsvm_core/src/net/torvald/tsvm/vdc/V2kRunTest.kt @@ -39,11 +39,11 @@ class V2kRunTest : ApplicationAdapter() { ) batch = SpriteBatch() - camera = OrthographicCamera(AppLoader.WIDTH.toFloat(), AppLoader.WIDTH.toFloat()) + camera = OrthographicCamera(net.torvald.tsvm.AppLoader.WIDTH.toFloat(), net.torvald.tsvm.AppLoader.WIDTH.toFloat()) camera.setToOrtho(false) camera.update() batch.projectionMatrix = camera.combined - Gdx.gl20.glViewport(0, 0, AppLoader.WIDTH, AppLoader.HEIGHT) + Gdx.gl20.glViewport(0, 0, net.torvald.tsvm.AppLoader.WIDTH, net.torvald.tsvm.AppLoader.HEIGHT) vm.getPrintStream = { gpu.getPrintStream() } vm.getErrorStream = { gpu.getErrorStream() } @@ -64,7 +64,7 @@ class V2kRunTest : ApplicationAdapter() { private var updateRate = 1f / 60f override fun render() { - Gdx.graphics.setTitle("${AppLoader.appTitle} $EMDASH F: ${Gdx.graphics.framesPerSecond} $EMDASH VF: ${(1.0 / vdc.statsFrameTime).toInt()}") + Gdx.graphics.setTitle("${net.torvald.tsvm.AppLoader.appTitle} $EMDASH F: ${Gdx.graphics.framesPerSecond} $EMDASH VF: ${(1.0 / vdc.statsFrameTime).toInt()}") super.render() diff --git a/src/net/torvald/tsvm/vdc/Videotron2K.kt b/tsvm_core/src/net/torvald/tsvm/vdc/Videotron2K.kt similarity index 99% rename from src/net/torvald/tsvm/vdc/Videotron2K.kt rename to tsvm_core/src/net/torvald/tsvm/vdc/Videotron2K.kt index eb7b2d5..6bebd24 100644 --- a/src/net/torvald/tsvm/vdc/Videotron2K.kt +++ b/tsvm_core/src/net/torvald/tsvm/vdc/Videotron2K.kt @@ -1,7 +1,7 @@ package net.torvald.tsvm.vdc import net.torvald.UnsafeHelper -import net.torvald.random.HQRNG +import torvald.random.HQRNG import net.torvald.tsvm.peripheral.GraphicsAdapter import java.lang.NumberFormatException import java.util.* @@ -149,7 +149,7 @@ class Videotron2K(var gpu: GraphicsAdapter?) { private val infoPrint = true private val debugPrint = false - private val rng = HQRNG() + private val rng = torvald.random.HQRNG() fun eval(command: String) { val rootStatements = parseCommands(command) diff --git a/tsvm_core/tsvm_core.iml b/tsvm_core/tsvm_core.iml new file mode 100644 index 0000000..01c580f --- /dev/null +++ b/tsvm_core/tsvm_core.iml @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tsvm_dummymodule.iml b/tsvm_dummymodule.iml new file mode 100644 index 0000000..d6ebd48 --- /dev/null +++ b/tsvm_dummymodule.iml @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/tsvm_executable.iml b/tsvm_executable.iml new file mode 100644 index 0000000..9a4360f --- /dev/null +++ b/tsvm_executable.iml @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/net/torvald/terrarum/modulecomputers/tsvmperipheral/WorldRadar.kt b/tsvm_executable/src/net/torvald/terrarum/modulecomputers/tsvmperipheral/WorldRadar.kt similarity index 100% rename from src/net/torvald/terrarum/modulecomputers/tsvmperipheral/WorldRadar.kt rename to tsvm_executable/src/net/torvald/terrarum/modulecomputers/tsvmperipheral/WorldRadar.kt diff --git a/src/net/torvald/tsvm/AppLoader.java b/tsvm_executable/src/net/torvald/tsvm/AppLoader.java similarity index 74% rename from src/net/torvald/tsvm/AppLoader.java rename to tsvm_executable/src/net/torvald/tsvm/AppLoader.java index bd48378..c2aa3c8 100644 --- a/src/net/torvald/tsvm/AppLoader.java +++ b/tsvm_executable/src/net/torvald/tsvm/AppLoader.java @@ -34,18 +34,13 @@ public class AppLoader { // VM vm = new VM(64 << 10, new TheRealWorld(), new VMProgramRom[]{TandemBios.INSTANCE, BasicRom.INSTANCE}); // VM vm = new VM(128 << 10, new TheRealWorld(), new VMProgramRom[]{BasicBios.INSTANCE, WPBios.INSTANCE}); VM vm = new VM(2048 << 10, new TheRealWorld(), new VMProgramRom[]{TsvmBios.INSTANCE}); - VM pipvm = new VM(4096, new TheRealWorld(), new VMProgramRom[]{PipBios.INSTANCE, PipROM.INSTANCE}); - // uncomment to target the TerranBASIC runner -// VM vm = new VM(64 << 10, new TheRealWorld(), new VMProgramRom[]{TBASRelBios.INSTANCE}); - EmulInstance reference = new EmulInstance(vm, "net.torvald.tsvm.peripheral.ReferenceGraphicsAdapter", "assets/disk0", 560, 448); EmulInstance reference2 = new EmulInstance(vm, "net.torvald.tsvm.peripheral.ReferenceLikeLCD", "assets/disk0", 560, 448); EmulInstance term = new EmulInstance(vm, "net.torvald.tsvm.peripheral.Term", "assets/disk0", 720, 480); EmulInstance portable = new EmulInstance(vm, "net.torvald.tsvm.peripheral.CharacterLCDdisplay", "assets/disk0", 628, 302); EmulInstance wp = new EmulInstance(vm, "net.torvald.tsvm.peripheral.WpTerm", "assets/wpdisk", 810, 360); - EmulInstance pip = new EmulInstance(pipvm, null, "assets/disk0", 640, 480, CollectionsKt.listOf(new Pair(1, new PeripheralEntry2( 32768L, 1, @@ -56,24 +51,4 @@ public class AppLoader { new Lwjgl3Application(new VMGUI(pip, WIDTH, HEIGHT), appConfig); } - - public static ShaderProgram loadShaderFromFile(String vert, String frag) { - ShaderProgram s = new ShaderProgram(Gdx.files.internal(vert), Gdx.files.internal(frag)); - - if (s.getLog().toLowerCase().contains("error")) { - throw new Error(String.format("Shader program loaded with %s, %s failed:\n%s", vert, frag, s.getLog())); - } - - return s; - } - - public static ShaderProgram loadShaderInline(String vert, String frag) { - ShaderProgram s = new ShaderProgram(vert, frag); - - if (s.getLog().toLowerCase().contains("error")) { - throw new Error(String.format("Shader program loaded with %s, %s failed:\n%s", vert, frag, s.getLog())); - } - - return s; - } } diff --git a/src/net/torvald/tsvm/Memvwr.kt b/tsvm_executable/src/net/torvald/tsvm/Memvwr.kt similarity index 100% rename from src/net/torvald/tsvm/Memvwr.kt rename to tsvm_executable/src/net/torvald/tsvm/Memvwr.kt diff --git a/src/net/torvald/tsvm/VMGUI.kt b/tsvm_executable/src/net/torvald/tsvm/VMGUI.kt similarity index 96% rename from src/net/torvald/tsvm/VMGUI.kt rename to tsvm_executable/src/net/torvald/tsvm/VMGUI.kt index ea680fd..b187f36 100644 --- a/src/net/torvald/tsvm/VMGUI.kt +++ b/tsvm_executable/src/net/torvald/tsvm/VMGUI.kt @@ -6,12 +6,9 @@ import com.badlogic.gdx.graphics.* import com.badlogic.gdx.graphics.g2d.SpriteBatch import kotlinx.coroutines.* import net.torvald.terrarum.modulecomputers.tsvmperipheral.WorldRadar -import net.torvald.tsvm.CompressorDelegate.GZIP_HEADER import net.torvald.tsvm.peripheral.* import java.io.File -fun ByteArray.startsWith(other: ByteArray) = this.sliceArray(other.indices).contentEquals(other) - class EmulInstance( val vm: VM, val display: String?, @@ -97,7 +94,13 @@ class VMGUI(val loaderInfo: EmulInstance, val viewportWidth: Int, val viewportHe vm.getInputStream = { System.`in` } } - vm.getIO().blockTransferPorts[1].attachDevice(WorldRadar(Gdx.files.internal("test_assets/test_terrain.png"))) + vm.getIO().blockTransferPorts[1].attachDevice( + WorldRadar( + Gdx.files.internal( + "test_assets/test_terrain.png" + ) + ) + ) loaderInfo.extraPeripherals.forEach { (port, peri) -> val typeargs = peri.args.map { it.javaClass }.toTypedArray()