From: Brendan Hansen Date: Tue, 4 May 2021 18:55:50 +0000 (-0500) Subject: initial commit X-Git-Url: https://git.brendanfh.com/?a=commitdiff_plain;h=ee62d711392348e015b805909c45bb559b282684;p=tower.git initial commit --- ee62d711392348e015b805909c45bb559b282684 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0ea8bc1 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +*.4coder +*.sublime-project +*.sublime-workspace +*.wasm diff --git a/build.sh b/build.sh new file mode 100755 index 0000000..9953f84 --- /dev/null +++ b/build.sh @@ -0,0 +1,15 @@ +#!/bin/sh + +TARGET=site/tower.wasm +ONYX_INSTALLATION_FOLDER="/home/brendan/dev/c/onyx" + +echo "Starting build at $(date)" + +# Copy relative javascript modules from Onyx source directory +cp "$ONYX_INSTALLATION_FOLDER/bin/onyx-loader.js" ./site/js/onyx-loader.js +cp "$ONYX_INSTALLATION_FOLDER/modules/webgl2/webgl2.js" ./site/js/webgl2.js +cp "$ONYX_INSTALLATION_FOLDER/modules/js_events/js_events.js" ./site/js/js_events.js + +onyx -r js --use-post-mvp-features -V -o $TARGET \ + src/build.onyx \ + -I "$ONYX_INSTALLATION_FOLDER" # Include the folder that contains the "modules" diff --git a/site/index.html b/site/index.html new file mode 100644 index 0000000..eed4244 --- /dev/null +++ b/site/index.html @@ -0,0 +1,25 @@ + + + Tower Defense + + + + + + + + + + + + This browser does not support the Canvas API. + + diff --git a/site/js/game.js b/site/js/game.js new file mode 100644 index 0000000..08f959c --- /dev/null +++ b/site/js/game.js @@ -0,0 +1,15 @@ + +window.ONYX_MODULES = window.ONYX_MODULES || []; + +window.ONYX_MODULES.push({ + module_name: "game", + + start_loop: function() { + var loop = function(dt) { + window.ONYX_INSTANCE.exports.loop(); + window.requestAnimationFrame(loop); + }; + + window.requestAnimationFrame(loop); + }, +}); diff --git a/site/js/js_events.js b/site/js/js_events.js new file mode 100644 index 0000000..df3bb83 --- /dev/null +++ b/site/js/js_events.js @@ -0,0 +1,67 @@ +window.ONYX_MODULES = window.ONYX_MODULES || []; + +function push_event_to_buffer(esp, event_size, event_kind, data) { + let WASM_U32 = new Uint32Array(ONYX_MEMORY.buffer); + + if (WASM_U32[esp] >= WASM_U32[esp + 1]) { + console.log("Event buffer full!"); + return; + } + + WASM_U32[esp] += 1; + + let event_idx = esp + (WASM_U32[esp] - 1) * (event_size / 4) + 2; + WASM_U32[event_idx] = event_kind; + WASM_U32[event_idx + 1] = Date.now(); + + for (let i = 0; i < data.length; i++) { + WASM_U32[event_idx + 2 + i] = data[i]; + } +} + +window.ONYX_MODULES.push({ + module_name: "js_events", + + setup: function(esp, event_size) { + // Indicies into a Uint32Array are not based on bytes, + // but on the index. + esp /= 4; + + document.addEventListener("keydown", function (ev) { + if (ev.isComposing || ev.keyCode === 229) return; + push_event_to_buffer(esp, event_size, 0x04, [ ev.keyCode ]); + }); + + document.addEventListener("keyup", function (ev) { + if (ev.isComposing || ev.keyCode === 229) return; + push_event_to_buffer(esp, event_size, 0x05, [ ev.keyCode ]); + }); + + document.addEventListener("mousedown", function (ev) { + push_event_to_buffer(esp, event_size, 0x01, [ ev.clientX, ev.clientY, ev.button ]); + }); + + document.addEventListener("mouseup", function (ev) { + push_event_to_buffer(esp, event_size, 0x02, [ ev.clientX, ev.clientY, ev.button ]); + }); + + document.addEventListener("mousemove", function (ev) { + push_event_to_buffer(esp, event_size, 0x03, [ ev.clientX, ev.clientY, -1 ]); + }); + + document.addEventListener("wheel", function (ev) { + push_event_to_buffer(esp, event_size, 0x07, [ ev.clientX, ev.clientY, ev.deltaY >= 0 ? 0x04 : 0x03 ]); + }); + + window.addEventListener("resize", function (ev) { + push_event_to_buffer(esp, event_size, 0x06, [ window.innerWidth, window.innerHeight ]); + }); + + push_event_to_buffer(esp, event_size, 0x06, [ window.innerWidth, window.innerHeight ]); + + document.oncontextmenu = (e) => { + e.preventDefault = true; + return false; + }; + }, +}); diff --git a/site/js/onyx-loader.js b/site/js/onyx-loader.js new file mode 100644 index 0000000..bece7b7 --- /dev/null +++ b/site/js/onyx-loader.js @@ -0,0 +1,49 @@ + +window.ONYX_MODULES = window.ONYX_MODULES || []; +window.ONYX_MEMORY = null; +window.ONYX_INSTANCE = null; + +window.ONYX_MODULES.push({ + module_name: "host", + + print_str: function(ptr, len) { + var buffer = new Uint8Array(ONYX_MEMORY.buffer, ptr, len); + var string = new TextDecoder().decode(buffer); + console.log(string); + }, + + exit: function() { debugger; } +}); + +function launch_onyx_program(script_path, call_start) { + fetch(script_path) + .then(function(res) { return res.arrayBuffer(); }) + .then(function(wasm_code) { + var import_object = {}; + + for (var i = 0; i < window.ONYX_MODULES.length; i++) { + import_object[window.ONYX_MODULES[i].module_name] = window.ONYX_MODULES[i]; + } + + return WebAssembly.instantiate(wasm_code, import_object); + }) + .then(function(wasm_module) { + // @ROBUSTNESS: This only allows for 1 Onyx program to running at a time in the window. + // This probably iesn't a limitation that needs to be worried about, but it is a limitation. + window.ONYX_MEMORY = wasm_module.instance.exports.memory; + window.ONYX_INSTANCE = wasm_module.instance; + + wasm_module.instance.exports._start(); + }); +} + +window.onload = function() { + var script_tags = document.getElementsByTagName("script"); + + for (var i = 0; i < script_tags.length; i++) { + if (script_tags[i].getAttribute("type") == "application/onyx") { + // @ROBUSTNESS: It should be configurable which function is called on start up of a Onyx WASM module. + launch_onyx_program(script_tags[i].getAttribute("src"), true); + } + } +}; diff --git a/site/js/webgl2.js b/site/js/webgl2.js new file mode 100644 index 0000000..bd53399 --- /dev/null +++ b/site/js/webgl2.js @@ -0,0 +1,291 @@ +window.ONYX_MODULES = window.ONYX_MODULES || []; + +var programs = []; +var shaders = []; +var buffers = []; +var framebuffers = []; +var renderbuffers = []; +var textures = []; +var uniformlocs = []; +var vertexArrays = []; +var canvas = null; +var gl = null; + +window.ONYX_MODULES.push({ + module_name: "gl", + + init(name, namelen) { + const decoder = new TextDecoder(); + const str = new Uint8Array(window.ONYX_MEMORY.buffer, name, namelen); + const canvasname = decoder.decode(str); + + canvas = document.getElementById(canvasname); + if (canvas == null) return 0; + + gl = canvas.getContext("webgl2"); + if (gl == null) return 0; + + return 1; + }, + + activeTexture(texture) { gl.activeTexture(texture); }, + attachShader(program, shader) { gl.attachShader(programs[program], shaders[shader]); return programs[program]; }, + bindAttribLocation(program, index, name, namelen) { console.log("NOT IMPLEMENTED!"); }, + bindBuffer(target, buffer) { + if (buffer == -1) { + gl.bindBuffer(target, null); + } else { + gl.bindBuffer(target, buffers[buffer]); + } + }, + bindFramebuffer(target, framebuffer) { gl.bindFramebuffer(target, framebuffers[framebuffer]); }, + bindRenderbuffer(target, renderbuffer) { gl.bindRenderbuffer(target, renderbuffers[renderbuffer]); }, + bindTexture(target, texture) { gl.bindTexture(target, textures[texture]); }, + bindVertexArray(vertexArray) { gl.bindVertexArray(vertexArrays[vertexArray]); }, + + blendColor(red, green, blue, alpha) { gl.blendColor(red, green, blue, alpha); }, + blendEquation(mode) { gl.blendEquation(mode); }, + blendEquationSeparate(modeRGB, modeAlpha) { gl.blendEquationSeparate(modeRGB, modeAlpha); }, + blendFunc(sfactor, dfactor) { gl.blendFunc(sfactor, dfactor); }, + blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha) { gl.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); }, + + blitFramebuffer(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1, mask, filter) { + gl.blitFramebuffer(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1, mask, filter); + }, + + bufferDataWithData(target, bufferdata, bufferlen, usage) { + const data = new DataView(window.ONYX_MEMORY.buffer, bufferdata, bufferlen); + gl.bufferData(target, data, usage); + }, + + bufferDataNoData(target, size, usage) { gl.bufferData(target, size, usage); }, + bufferSubData(target, offset, bufferdata, bufferlen) { + const data = new DataView(window.ONYX_MEMORY.buffer, bufferdata, bufferlen); + gl.bufferSubData(target, offset, data); + }, + canvasSize(width, height) { + canvas.width = width; + canvas.height = height; + }, + checkFrameBufferStatus(target) { return gl.checkFrameBufferStatus(target); }, + clear(bit) { gl.clear(bit); }, + clearColor(r, g, b, a) { gl.clearColor(r, g, b, a); }, + clearDepth(depth) { gl.clearDepth(depth); }, + clearStencil(stencil) { gl.clearStencil(stencil); }, + colorMask(r, g, b, a) { gl.colorMask(r, g, b, a); }, + compileShader(shader) { gl.compileShader(shaders[shader]); }, + compressedTexImage2D(target, level, internalformat, width, height, border, data, datalen) { + const pixels = new DataView(window.ONYX_MEMORY.buffer, data, datalen); + gl.compressedTexImage2D(target, level, internalformat, width, height, border, pixels); + }, + compressedTexSubImage2D(target, level, internalformat, xoff, yoff, width, height, format, data, datalen) { + const pixels = new DataView(window.ONYX_MEMORY.buffer, data, datalen); + gl.compressedSubTexImage2D(target, level, internalformat, xoff, yoff, width, height, format, pixels); + }, + copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size) { gl.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); }, + copyTexImage2D(target, level, internalforamt, x, y, width, height, border) { + gl.copyTexImage2D(target, level, internalforamt, x, y, width, height, border); + }, + copyTexSubImage2D(target, level, xoff, yoff, x, y, width, height) { + gl.copyTexSubImage2D(target, level, xoff, yoff, x, y, width, height); + }, + createBuffer() { + const buf = gl.createBuffer(); + if (buf == null) return -1; + + buffers.push(buf); + return buffers.length - 1; + }, + createFramebuffer() { + const buf = gl.createFramebuffer(); + if (buf == null) return -1; + + framebuffers.push(buf); + return framebuffers.length - 1; + }, + createProgram() { + const prog = gl.createProgram(); + if (prog == null) return -1; + + programs.push(prog); + return programs.length - 1; + }, + createRenderbuffer() { + const buf = gl.createRenderbuffer(); + if (buf == null) return -1; + + renderbuffers.push(buf); + return renderbuffers.length - 1; + }, + createShader(type) { + const shader = gl.createShader(type); + if (shader == null) return -1; + + shaders.push(shader); + return shaders.length - 1; + }, + createTexture() { + const texture = gl.createTexture(); + if (texture == null) return -1; + + textures.push(texture); + return textures.length - 1; + }, + createVertexArray() { + const vao = gl.createVertexArray(); + if (vao == null) return -1; + + vertexArrays.push(vao); + return vertexArrays.length - 1; + }, + cullFace(mode) { gl.cullFace(mode); }, + deleteBuffer(buffer) { gl.deleteBuffer(buffers[buffer]); }, + deleteFramebuffer(framebuffer) { gl.deleteFramebuffer(framebuffers[framebuffer]); }, + deleteProgram(program) { gl.deleteProgram(programs[program]); }, + deleteRenderbuffer(renderbuffer) { gl.deleteRenderbuffer(renderbuffers[renderbuffer]); }, + deleteShader(shader) { gl.deleteShader(shaders[shader]); }, + deleteTexture(texture) { gl.deleteTexture(textures[texture]); }, + deleteVertexArray(vertexArray) { gl.deleteVertexArray(vertexArrays[vertexArray]); }, + depthFunc(func) { gl.depthFunc(func); }, + depthMask(flag) { gl.depthMask(flag); }, + depthRange(znear, zfar) { gl.depthRange(znear, zfar); }, + detachShader(program, shader) { gl.detachShader(programs[program], shaders[shader]); }, + disable(cap) { gl.disable(cap); }, + disableVertexAttribArray(index) { gl.disableVertexAttribArray(index); }, + drawArrays(mode, first, count) { gl.drawArrays(mode, first, count); }, + drawArraysInstanced(mode, first, count, instanceCount) { gl.drawArraysInstanced(mode, first, count, instanceCount); }, + drawElements(mode, count, type, offset) { gl.drawElements(mode, count, type, offset); }, + drawElementsInstanced(mode, count, type, offset, instanceCount) { gl.drawElementsInstanced(mode, count, type, offset, instanceCount); }, + enable(cap) { gl.enable(cap); }, + enableVertexAttribArray(index) { gl.enableVertexAttribArray(index); }, + finish() { gl.finish(); }, + flush() { gl.flush(); }, + framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) { + gl.framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffers[renderbuffer]); + }, + framebufferTexture2D(target, attachment, texttarget, texture, level) { + gl.framebufferTexture2D(target, attachment, texttarget, textures[texture], level); + }, + framebufferTextureLayer(target, attachment, texture, level, layer) { gl.framebufferTextureLayer(target, attachment, textures[texture], level, layer); }, + frontFace(mode) { gl.frontFace(mode); }, + generateMipmap(target) { gl.generateMipmap(target); }, + getActiveAttrib(program, index, out) { + const loc = gl.getActiveAttrib(programs[program], index); + const data = new Int32Array(window.ONYX_MEMORY.buffer, out, 2); + data[0] = loc.size; + data[1] = loc.type; + }, + getActiveUniform(program, index, out) { + const loc = gl.getActiveUniform(programs[program], index); + const data = new Int32Array(window.ONYX_MEMORY.buffer, out, 2); + data[0] = loc.size; + data[1] = loc.type; + }, + // getAttachedShaders() { console.log("NOT IMPLEMENTED!"); }, + getAttribLocation(program, name, namelen) { + const decoder = new TextDecoder(); + const str = new Uint8Array(window.ONYX_MEMORY.buffer, name, namelen); + const attribname = decoder.decode(str); + + return gl.getAttribLocation(programs[program], attribname); + }, + // getBufferParameter() { console.log("NOT IMPLEMENTED!"); }, + getBufferSubData(target, srcbyteoffset, dstbufferdata, dstbufferlen, dstoffset, length) { + const dst = new DataView(window.ONYX_MEMORY.buffer, dstbufferdata, dstbufferlen); + gl.getBufferSubData(target, srcbyteoffset, dst, dstoffset, length); + }, + getError() { return gl.getError(); }, + getInternalformatParameter(target, internalformat, pname) { return gl.getInternalformatParameter(target, internalformat, pname); }, + // many of the 'gets() { console.log("NOT IMPLEMENTED!"); }, + getShaderParameter(shader, param) { return gl.getShaderParameter(shaders[shader], param); }, + getProgramParameter(program, param) { return gl.getProgramParameter(programs[program], param); }, + getUniformLocation(program, name, namelen) { + const decoder = new TextDecoder(); + const str = new Int8Array(window.ONYX_MEMORY.buffer, name, namelen); + const uniname = decoder.decode(str); + + uniformlocs.push(gl.getUniformLocation(programs[program], uniname)); + return uniformlocs.length - 1; + }, + getVertexAttribOffset(index, pname) { return gl.getVertexAttribOffset(index, pname); }, + hint(target, mode) { gl.hint(target, mode); }, + isEnabled(cap) { return gl.isEnabled(cap); }, + invalidateFramebuffer(target, attachdata, attachlen) { + const attachments = new Int32Array(window.ONYX_MEMORY.buffer, attachdata, attachlen); + gl.invalidateFramebuffer(target, attacements); + }, + invalidateSubFramebuffer(target, attachdata, attachlen, x, y, width, height) { + const attachments = new Int32Array(window.ONYX_MEMORY.buffer, attachdata, attachlen); + gl.invalidateFramebuffer(target, attacements, x, y, width, height); + }, + lineWidth(width) { gl.lineWidth(width); }, + linkProgram(program) { gl.linkProgram(programs[program]); }, + pixelStorei(pname, param) { gl.pixelStorei(pname, param); }, + polygonOffset(factor, units) { gl.polygonOffset(factor, units); }, + printProgramInfoLog(program) { console.log(gl.getProgramInfoLog(programs[program])); }, + printShaderInfoLog(shader) { console.log(gl.getShaderInfoLog(shaders[shader])); }, + readPixels(x, y, width, height, format, type, pixels, pixelslen) { + const pixeldata = new Uint8Array(window.ONYX_MEMORY.buffer, pixels, pixelslen); + gl.readPixels(x, y, width, height, format, type, pixeldata); + }, + readBuffer(src) { gl.readBuffer(src); }, + renderbufferStorageMultisample(target, samples, internalforamt, width, height) { + gl.renderbufferStorageMultisample(target, samples, internalforamt, width, height); + }, + sampleCoverage(value, invert) { gl.sampleCoverage(value, invert); }, + scissor(x, y, width, height) { gl.scissor(x, y, width, height); }, + setSize(width, height) { canvas.width = width; canvas.height = height; }, + shaderSource(shader, source, sourcelen) { + const decoder = new TextDecoder(); + const str = new Int8Array(window.ONYX_MEMORY.buffer, source, sourcelen); + const sourcedata = decoder.decode(str); + + gl.shaderSource(shaders[shader], sourcedata); + }, + stencilFunc(func, ref, mask) { gl.stencilFunc(func, ref, mask); }, + stencilFuncSeparate(face, func, ref, mask) { gl.stencilFuncSeparate(face, func, ref, mask); }, + stencilMask(mask) { gl.stencilMask(mask); }, + stencilMaskSeparate(face, mask) { gl.stencilMaskSeparate(face, mask); }, + stencilOp(fail, zfail, mask) { gl.stencilOp(fail, zfail, mask); }, + stencilOpSeparate(face, fail, zfail, zpass) { gl.stencilOpSeparate(face, fail, zfail, zpass); }, + texImage2D(target, level, internalforamt, width, height, border, format, type, pixels, pixelslen) { + const data = new Uint8Array(window.ONYX_MEMORY.buffer, pixels, pixelslen); + gl.texImage2D(target, level, internalforamt, width, height, border, format, type, data); + }, + texParameterf(target, pname, param) { gl.texParameterf(target, pname, param); }, + texParameteri(target, pname, param) { gl.texParameteri(target, pname, param); }, + texSubImage2D(target, level, xoff, yoff, width, height, format, type, pixels, pixelslen) { + const data = new Uint8Array(window.ONYX_MEMORY.buffer, pixels, pixelslen); + gl.texSubImage2D(target, level, xoff, yoff, width, height, format, type, data); + }, + uniform1f(loc, x) { gl.uniform1f(uniformlocs[loc], x); }, + uniform1i(loc, x) { gl.uniform1i(uniformlocs[loc], x); }, + uniform2f(loc, x, y) { gl.uniform2f(uniformlocs[loc], x, y); }, + uniform2i(loc, x, y) { gl.uniform2i(uniformlocs[loc], x, y); }, + uniform3f(loc, x, y, z) { gl.uniform3f(uniformlocs[loc], x, y, z); }, + uniform3i(loc, x, y, z) { gl.uniform3i(uniformlocs[loc], x, y, z); }, + uniform4f(loc, x, y, z, w) { gl.uniform4f(uniformlocs[loc], x, y, z, w); }, + uniform4i(loc, x, y, z, w) { gl.uniform4i(uniformlocs[loc], x, y, z, w); }, + uniformMatrix2(loc, transpose, valueptr) { + const data = new Float32Array(window.ONYX_MEMORY.buffer, valueptr, 4); + gl.uniformMatrix2fv(uniformlocs[loc], transpose, data); + }, + uniformMatrix3(loc, transpose, valueptr) { + const data = new Float32Array(window.ONYX_MEMORY.buffer, valueptr, 9); + gl.uniformMatrix3fv(uniformlocs[loc], transpose, data); + }, + uniformMatrix4(loc, transpose, valueptr) { + const data = new Float32Array(window.ONYX_MEMORY.buffer, valueptr, 16); + gl.uniformMatrix4fv(uniformlocs[loc], transpose, data); + }, + useProgram(program) { gl.useProgram(programs[program]); }, + validateProgram(program) { gl.validateProgram(program[program]); }, + vertexAttrib1f(idx, x) { gl.vertexAttrib1f(idx, x); }, + vertexAttrib2f(idx, x, y) { gl.vertexAttrib2f(idx, x, y); }, + vertexAttrib3f(idx, x, y, z) { gl.vertexAttrib3f(idx, x, y, z); }, + vertexAttrib4f(idx, x, y, z, w) { gl.vertexAttrib4f(idx, x, y, z, w); }, + vertexAttribIPointer(idx, size, type, stride, offset) { gl.vertexAttribIPointer(idx, size, type, stride, offset); }, + vertexAttribPointer(idx, size, type, normalized, stride, offset) { gl.vertexAttribPointer(idx, size, type, normalized, stride, offset); }, + vertexAttribDivisor(idx, divisor) { gl.vertexAttribDivisor(idx, divisor); }, + viewport(x, y, width, height) { gl.viewport(x, y, width, height); }, +}); diff --git a/src/build.onyx b/src/build.onyx new file mode 100644 index 0000000..a2d3272 --- /dev/null +++ b/src/build.onyx @@ -0,0 +1,10 @@ +#if (package runtime).Runtime != (package runtime).Runtime_Js { + #error "Please run with '-r js'." +} + +#load "core/std" + +#load "modules/webgl2/module" +#load "modules/js_events/module" + +#load "src/tower" diff --git a/src/tower.onyx b/src/tower.onyx new file mode 100644 index 0000000..536bfb0 --- /dev/null +++ b/src/tower.onyx @@ -0,0 +1,6 @@ + +use package core + +main :: (args: [] cstr) { + println("Hello World!"); +}