From 80360f3f51fa2e3c6b4aebd19941682fd7583049 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 9 Nov 2021 18:26:42 +0000 Subject: [PATCH] Add vendor packages for the `js_wasm32` target --- vendor/wasm/README.md | 59 ++ vendor/wasm/WebGL/runtime.js | 1034 +++++++++++++++++++++++ vendor/wasm/WebGL/webgl.odin | 249 ++++++ vendor/wasm/WebGL/webgl2.odin | 182 ++++ vendor/wasm/WebGL/webgl2_constants.odin | 268 ++++++ vendor/wasm/WebGL/webgl_constants.odin | 420 +++++++++ vendor/wasm/js/runtime.js | 154 ++++ 7 files changed, 2366 insertions(+) create mode 100644 vendor/wasm/README.md create mode 100644 vendor/wasm/WebGL/runtime.js create mode 100644 vendor/wasm/WebGL/webgl.odin create mode 100644 vendor/wasm/WebGL/webgl2.odin create mode 100644 vendor/wasm/WebGL/webgl2_constants.odin create mode 100644 vendor/wasm/WebGL/webgl_constants.odin create mode 100644 vendor/wasm/js/runtime.js diff --git a/vendor/wasm/README.md b/vendor/wasm/README.md new file mode 100644 index 000000000..8567f2eab --- /dev/null +++ b/vendor/wasm/README.md @@ -0,0 +1,59 @@ +# WASM on the Web + +This directory is for use when targeting the `js_wasm32` target and the packages that rely on it. + +The `js_wasm32` target assumes that the WASM output will be ran within a web browser rather than a standalone VM. In the VM cases, either `wasi_wasm32` or `freestanding_wasm32` should be used accordingly. + +## Example + +```js +import {WasmMemoryInterface, odinSetupDefaultImports} from "./js/runtime.js"; +import {WebGLInterface} from "./WebGL/runtime.js"; + +const runWasm = async (wasm_path, webglCanvasElement, consoleElement) => { + let wasmMemoryInterface = new WasmMemoryInterface(); + + let imports = odinSetupDefaultImports(wasmMemoryInterface, consoleElement); + + if (webglCanvasElement !== undefined) { + let gl_context = new WebGLInterface( + wasmMemoryInterface, + webglCanvasElement, + {antialias: false}, + ); + if (!gl_context.ctx) { + return "WebGL is not available."; + } + imports["webgl"] = gl_context.getWebGL1Interface() + imports["webgl2"] = gl_context.getWebGL2Interface() + } + + const response = await fetch(wasm_path); + const file = await response.arrayBuffer(); + const wasm = await WebAssembly.instantiate(file, imports); + const exports = wasm.instance.exports; + wasmMemoryInterface.setMemory(exports.memory); + + exports._start(); + + if (exports.step) { + const odin_ctx = exports.default_context_ptr(); + + let prevTimeStamp = undefined; + const step = (currTimeStamp) => { + if (prevTimeStamp == undefined) { + prevTimeStamp = currTimeStamp; + } + + const dt = (currTimeStamp - prevTimeStamp)*0.001; + prevTimeStamp = currTimeStamp; + exports.step(dt, odin_ctx); + window.requestAnimationFrame(step); + }; + + window.requestAnimationFrame(step); + } + + return; +}; +``` \ No newline at end of file diff --git a/vendor/wasm/WebGL/runtime.js b/vendor/wasm/WebGL/runtime.js new file mode 100644 index 000000000..b6994a8ec --- /dev/null +++ b/vendor/wasm/WebGL/runtime.js @@ -0,0 +1,1034 @@ +class WebGLInterface { + constructor(wasmMemoryInterface, canvasElement, contextSettings) { + this.wasmMemoryInterface = wasmMemoryInterface; + this.ctx = null; + this.ctx_version = 1; + this.counter = 1; + this.lastError = 0; + this.buffers = []; + this.mappedBuffers = {}; + this.programs = []; + this.framebuffers = []; + this.renderbuffers = []; + this.textures = []; + this.uniforms = []; + this.shaders = []; + this.vaos = []; + this.contexts = []; + this.currentContext = null; + this.offscreenCanvases = {}; + this.timerQueriesEXT = []; + this.queries = []; + this.samplers = []; + this.transformFeedbacks = []; + this.syncs = []; + this.programInfos = {}; + + if (contextSettings === undefined) { + contextSettings = {antialias: false}; + } + + this.ctx = canvasElement.getContext("webgl2", contextSettings) || canvasElement.getContext("webgl", contextSettings); + if (!this.ctx) { + return; + } + if (this.ctx.getParameter(0x1F02).indexOf("WebGL 2.0") !== -1) { + this.ctx_version = 2.0; + } else { + this.ctx_version = 1.0; + } + } + + get mem() { + return this.wasmMemoryInterface + } + + assertWebGL2() { + if (this.ctx_version < 2) { + throw new Error("WebGL2 procedure called in a canvas without a WebGL2 context"); + } + } + getNewId(table) { + for (var ret = this.counter++, i = table.length; i < ret; i++) { + table[i] = null; + } + return ret; + } + recordError(errorCode) { + this.lastError || (this.lastError = errorCode); + } + populateUniformTable(program) { + let p = this.programs[program]; + this.programInfos[program] = { + uniforms: {}, + maxUniformLength: 0, + maxAttributeLength: -1, + maxUniformBlockNameLength: -1, + }; + for (let ptable = this.programInfos[program], utable = ptable.uniforms, numUniforms = this.ctx.getProgramParameter(p, this.ctx.ACTIVE_UNIFORMS), i = 0; i < numUniforms; ++i) { + let u = this.ctx.getActiveUniform(p, i); + let name = u.name; + if (ptable.maxUniformLength = Math.max(ptable.maxUniformLength, name.length + 1), name.indexOf("]", name.length - 1) !== -1) { + name = name.slice(0, name.lastIndexOf("[")); + } + let loc = this.ctx.getUniformLocation(p, name); + if (loc !== null) { + let id = this.getNewId(this.uniforms); + utable[name] = [u.size, id], this.uniforms[id] = loc; + for (let j = 1; j < u.size; ++j) { + let n = name + "[" + j + "]"; + let loc = this.ctx.getUniformLocation(p, n); + let id = this.getNewId(this.uniforms); + this.uniforms[id] = loc; + } + } + } + } + getSource(shader, strings_ptr, strings_length) { + const STRING_SIZE = 2*4; + let source = ""; + for (let i = 0; i < strings_length; i++) { + let ptr = this.mem.loadPtr(strings_ptr + i*STRING_SIZE); + let len = this.mem.loadPtr(strings_ptr + i*STRING_SIZE + 4); + let str = this.mem.loadString(ptr, len); + source += str; + } + return source; + } + + getWebGL1Interface() { + return { + DrawingBufferWidth: () => this.ctx.drawingBufferWidth, + DrawingBufferHeight: () => this.ctx.drawingBufferHeight, + + IsExtensionSupported: (name_ptr, name_len) => { + let name = this.mem.loadString(name_ptr, name_len); + let extensions = this.ctx.getSupportedExtensions(); + return extensions.indexOf(name) !== -1 + }, + + + GetError: () => { + let err = this.lastError; + this.recordError(0); + if (err) { + return err; + } + return this.ctx.getError(); + }, + + GetWebGLVersion: (major_ptr, minor_ptr) => { + let version = this.ctx.getParameter(0x1F02); + if (version.indexOf("WebGL 2.0") !== -1) { + this.mem.storeI32(major_ptr, 2); + this.mem.storeI32(minor_ptr, 0); + return; + } + + this.mem.storeI32(major_ptr, 1); + this.mem.storeI32(minor_ptr, 0); + }, + GetESVersion: (major_ptr, minor_ptr) => { + let version = this.ctx.getParameter(0x1F02); + if (version.indexOf("OpenGL ES 3.0") !== -1) { + this.mem.storeI32(major_ptr, 3); + this.mem.storeI32(minor_ptr, 0); + return; + } + + this.mem.storeI32(major_ptr, 2); + this.mem.storeI32(minor_ptr, 0); + }, + + + ActiveTexture: (x) => { + this.ctx.activeTexture(x); + }, + AttachShader: (program, shader) => { + this.ctx.attachShader(this.programs[program], this.shaders[shader]); + }, + BindAttribLocation: (program, index, name_ptr, name_len) => { + let name = this.mem.loadString(name_ptr, name_len); + this.ctx.bindAttribLocation(this.programs[program], index, name) + }, + BindBuffer: (target, buffer) => { + let bufferObj = buffer ? this.buffers[buffer] : null; + if (target == 35051) { + this.ctx.currentPixelPackBufferBinding = buffer; + } else { + if (target == 35052) { + this.ctx.currentPixelUnpackBufferBinding = buffer; + } + this.ctx.bindBuffer(target, bufferObj) + } + }, + BindFramebuffer: (target, buffer) => { + // TODO: BindFramebuffer + }, + BindTexture: (target, texture) => { + this.ctx.bindTexture(target, texture ? this.textures[texture] : null) + }, + BlendColor: (red, green, blue, alpha) => { + this.ctx.blendColor(red, green, blue, alpha); + }, + BlendEquation: (mode) => { + this.ctx.blendEquation(mode); + }, + BlendFunc: (sfactor, dfactor) => { + this.ctx.blendFunc(sfactor, dfactor); + }, + BlendFuncSeparate: (srcRGB, dstRGB, srcAlpha, dstAlpha) => { + this.ctx.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); + }, + + + BufferData: (target, size, data, usage) => { + if (data) { + this.ctx.bufferData(target, this.mem.loadBytes(data, size), usage); + } else { + this.ctx.bufferData(target, size, usage); + } + }, + BufferSubData: (target, offset, size, data) => { + if (data) { + this.ctx.bufferSubData(target, offset, this.mem.loadBytes(data, size)); + } else { + this.ctx.bufferSubData(target, offset, null); + } + }, + + + Clear: (x) => { + this.ctx.clear(x); + }, + ClearColor: (r, g, b, a) => { + this.ctx.clearColor(r, g, b, a); + }, + ClearDepth: (x) => { + this.ctx.clearDepth(x); + }, + ClearStencil: (x) => { + this.ctx.clearStencil(x); + }, + ColorMask: (r, g, b, a) => { + this.ctx.colorMask(!!r, !!g, !!b, !!a); + }, + CompileShader: (shader) => { + this.ctx.compileShader(this.shaders[shader]); + }, + + + CompressedTexImage2D: (target, level, internalformat, width, height, border, imageSize, data) => { + if (data) { + this.ctx.compressedTexImage2D(target, level, internalformat, width, height, border, this.mem.loadBytes(data, imageSize)); + } else { + this.ctx.compressedTexImage2D(target, level, internalformat, width, height, border, null); + } + }, + CompressedTexSubImage2D: (target, level, xoffset, yoffset, width, height, format, imageSize, data) => { + if (data) { + this.ctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, this.mem.loadBytes(data, imageSize)); + } else { + this.ctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, null); + } + }, + + CopyTexImage2D: (target, level, internalformat, x, y, width, height, border) => { + this.ctx.copyTexImage2D(target, level, internalformat, x, y, width, height, border); + }, + CopyTexSubImage2D: (target, level, xoffset, yoffset, x, y, width, height) => { + this.ctx.copyTexImage2D(target, level, xoffset, yoffset, x, y, width, height); + }, + + + CreateBuffer: () => { + let buffer = this.ctx.createBuffer(); + if (!buffer) { + this.recordError(1282); + return 0; + } + let id = this.getNewId(this.buffers); + buffer.name = id + this.buffers[id] = buffer; + return id; + }, + CreateFramebuffer: () => { + let buffer = this.ctx.createFramebuffer(); + let id = this.getNewId(this.framebuffers); + buffer.name = id + this.framebuffers[id] = buffer; + return id; + }, + CreateProgram: () => { + let program = this.ctx.createProgram(); + let id = this.getNewId(this.programs); + program.name = id; + this.programs[id] = program; + return id; + }, + CreateRenderbuffer: () => { + let buffer = this.ctx.createRenderbuffer(); + let id = this.getNewId(this.renderbuffers); + buffer.name = id; + this.renderbuffers[id] = buffer; + return id; + }, + CreateShader: (shaderType) => { + let shader = this.ctx.createShader(shaderType); + let id = this.getNewId(this.shaders); + shader.name = id; + this.shaders[id] = shader; + return id; + }, + CreateTexture: () => { + let texture = this.ctx.createTexture(); + if (!texture) { + this.recordError(1282) + return 0; + } + let id = this.getNewId(this.textures); + texture.name = id; + this.textures[id] = texture; + return id; + }, + + + CullFace: (mode) => { + this.ctx.cullFace(mode); + }, + + + DeleteBuffer: (id) => { + let obj = this.buffers[id]; + if (obj && id != 0) { + this.ctx.deleteBuffer(obj); + this.buffers[id] = null; + } + }, + DeleteFramebuffer: (id) => { + let obj = this.framebuffers[id]; + if (obj && id != 0) { + this.ctx.deleteFramebuffer(obj); + this.framebuffers[id] = null; + } + }, + DeleteProgram: (id) => { + let obj = this.programs[id]; + if (obj && id != 0) { + this.ctx.deleteProgram(obj); + this.programs[id] = null; + } + }, + DeleteRenderbuffer: (id) => { + let obj = this.renderbuffers[id]; + if (obj && id != 0) { + this.ctx.deleteRenderbuffer(obj); + this.renderbuffers[id] = null; + } + }, + DeleteShader: (id) => { + let obj = this.shaders[id]; + if (obj && id != 0) { + this.ctx.deleteShader(obj); + this.shaders[id] = null; + } + }, + DeleteTexture: (id) => { + let obj = this.textures[id]; + if (obj && id != 0) { + this.ctx.deleteTexture(obj); + this.textures[id] = null; + } + }, + + + DepthFunc: (func) => { + this.ctx.depthFunc(func); + }, + DepthMask: (flag) => { + this.ctx.depthMask(!!flag); + }, + DepthRange: (zNear, zFar) => { + this.ctx.depthRange(zNear, zFar); + }, + DetachShader: (program, shader) => { + this.ctx.detachShader(this.programs[program], this.shaders[shader]); + }, + Disable: (cap) => { + this.ctx.disable(cap); + }, + DisableVertexAttribArray: (index) => { + this.ctx.disableVertexAttribArray(index); + }, + DrawArrays: (mode, first, count) => { + this.ctx.drawArrays(mode, first, count); + }, + DrawElements: (mode, count, type, indices) => { + this.ctx.drawElements(mode, count, type, indices); + }, + + + Enable: (cap) => { + this.ctx.enable(cap); + }, + EnableVertexAttribArray: (index) => { + this.ctx.enableVertexAttribArray(index); + }, + Finish: () => { + this.ctx.finish(); + }, + Flush: () => { + this.ctx.flush(); + }, + FramebufferRenderBuffer: (target, attachment, renderbuffertarget, renderbuffer) => { + this.ctx.framebufferRenderBuffer(target, attachment, renderbuffertarget, this.renderbuffers[renderbuffer]); + }, + FramebufferTexture2D: (target, attachment, textarget, texture, level) => { + this.ctx.framebufferTexture2D(target, attachment, textarget, this.textures[texture], level); + }, + FrontFace: (mode) => { + this.ctx.frontFace(mode); + }, + + + GenerateMipmap: (target) => { + this.ctx.generateMipmap(target); + }, + + + GetAttribLocation: (program, name_ptr, name_len) => { + let name = this.mem.loadString(name_ptr, name_len); + return this.ctx.getAttribLocation(this.programs[program], name); + }, + + + + GetProgramParameter: (program, pname) => { + return this.ctx.getProgramParameter(this.programs[program], pname) + }, + GetProgramInfoLog: (program, buf_ptr, buf_len, length_ptr) => { + let log = this.ctx.getProgramInfoLog(this.programs[program]); + if (log === null) { + log = "(unknown error)"; + } + if (buf_len > 0 && buf_ptr) { + let n = Math.min(buf_len, log.length); + log = log.substring(0, n); + this.mem.loadBytes(buf_ptr, buf_len).set(new TextEncoder("utf-8").encode(log)) + + storeInt(length_ptr, n); + } + }, + GetShaderInfoLog: (shader, buf_ptr, buf_len, length_ptr) => { + let log = this.ctx.getShaderInfoLog(this.shaders[shader]); + if (log === null) { + log = "(unknown error)"; + } + if (buf_len > 0 && buf_ptr) { + let n = Math.min(buf_len, log.length); + log = log.substring(0, n); + this.mem.loadBytes(buf_ptr, buf_len).set(new TextEncoder("utf-8").encode(log)) + + storeInt(length_ptr, n); + } + }, + GetShaderiv: (shader, pname, p) => { + if (p) { + if (pname == 35716) { + let log = this.ctx.getShaderInfoLog(this.shaders[shader]); + if (log === null) { + log = "(unknown error)"; + } + storeInt(p, log.length+1); + } else if (pname == 35720) { + let source = this.ctx.getShaderSource(this.shaders[shader]); + let sourceLength = (source === null || source.length == 0) ? 0 : source.length+1; + storeInt(p, sourceLength); + } else { + let param = this.ctx.getShaderParameter(this.shaders[shader], pname); + this.mem.storeI32(p, param); + } + } else { + this.recordError(1281); + } + }, + + + GetUniformLocation: (program, name_ptr, name_len) => { + let name = this.mem.loadString(name_ptr, name_len); + let arrayOffset = 0; + if (name.indexOf("]", name.length - 1) !== -1) { + let ls = name.lastIndexOf("["), + arrayIndex = name.slice(ls + 1, -1); + if (arrayIndex.length > 0 && (arrayOffset = parseInt(arrayIndex)) < 0) { + return -1; + } + name = name.slice(0, ls) + } + var ptable = this.programInfos[program]; + if (!ptable) { + return -1; + } + var uniformInfo = ptable.uniforms[name]; + return (uniformInfo && arrayOffset < uniformInfo[0]) ? uniformInfo[1] + arrayOffset : -1 + }, + + + GetVertexAttribOffset: (index, pname) => { + return this.ctx.getVertexAttribOffset(index, pname); + }, + + + Hint: (target, mode) => { + this.ctx.hint(target, mode); + }, + + + IsBuffer: (buffer) => this.ctx.isBuffer(this.buffers[buffer]), + IsEnabled: (enabled) => this.ctx.isEnabled(this.enableds[enabled]), + IsFramebuffer: (framebuffer) => this.ctx.isFramebuffer(this.framebuffers[framebuffer]), + IsProgram: (program) => this.ctx.isProgram(this.programs[program]), + IsRenderbuffer: (renderbuffer) => this.ctx.isRenderbuffer(this.renderbuffers[renderbuffer]), + IsShader: (shader) => this.ctx.isShader(this.shaders[shader]), + IsTexture: (texture) => this.ctx.isTexture(this.textures[texture]), + + LineWidth: (width) => { + this.ctx.lineWidth(width); + }, + LinkProgram: (program) => { + this.ctx.linkProgram(this.programs[program]); + this.programInfos[program] = null; + this.populateUniformTable(program); + }, + PixelStorei: (pname, param) => { + this.ctx.pixelStorei(pname, param); + }, + PolygonOffset: (factor, units) => { + this.ctx.polygonOffset(factor, units); + }, + + + ReadnPixels: (x, y, width, height, format, type, bufSize, data) => { + this.ctx.readPixels(x, y, width, format, type, this.mem.loadBytes(data, bufSize)); + }, + RenderbufferStorage: (target, internalformat, width, height) => { + this.ctx.renderbufferStorage(target, internalformat, width, height); + }, + SampleCoverage: (value, invert) => { + this.ctx.sampleCoverage(value, !!invert); + }, + Scissor: (x, y, width, height) => { + this.ctx.scissor(x, y, width, height); + }, + ShaderSource: (shader, strings_ptr, strings_length) => { + let source = this.getSource(shader, strings_ptr, strings_length); + this.ctx.shaderSource(this.shaders[shader], source); + }, + + StencilFunc: (func, ref, mask) => { + this.ctx.stencilFunc(func, ref, mask); + }, + StencilFuncSeparate: (face, func, ref, mask) => { + this.ctx.stencilFuncSeparate(face, func, ref, mask); + }, + StencilMask: (mask) => { + this.ctx.stencilMask(mask); + }, + StencilMaskSeparate: (face, mask) => { + this.ctx.stencilMaskSeparate(face, mask); + }, + StencilOp: (fail, zfail, zpass) => { + this.ctx.stencilOp(fail, zfail, zpass); + }, + StencilOpSeparate: (face, fail, zfail, zpass) => { + this.ctx.stencilOpSeparate(face, fail, zfail, zpass); + }, + + + TexImage2D: (target, level, internalformat, width, height, border, format, type, size, data) => { + if (data) { + this.ctx.texImage2D(target, level, internalformat, width, height, border, format, type, this.mem.loadBytes(data, size)); + } else { + this.ctx.texImage2D(target, level, internalformat, width, height, border, format, type, null); + } + }, + TexParameterf: (target, pname, param) => { + this.ctx.texParameterf(target, pname, param); + }, + TexParameteri: (target, pname, param) => { + this.ctx.texParameteri(target, pname, param); + }, + TexSubImage2D: (target, level, xoffset, yoffset, width, height, format, type, size, data) => { + this.ctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, this.mem.loadBytes(data, size)); + }, + + + Uniform1f: (location, v0) => { this.ctx.uniform1f(this.uniforms[location], v0); }, + Uniform2f: (location, v0, v1) => { this.ctx.uniform2f(this.uniforms[location], v0, v1); }, + Uniform3f: (location, v0, v1, v2) => { this.ctx.uniform3f(this.uniforms[location], v0, v1, v2); }, + Uniform4f: (location, v0, v1, v2, v3) => { this.ctx.uniform4f(this.uniforms[location], v0, v1, v2, v3); }, + + Uniform1i: (location, v0) => { this.ctx.uniform1i(this.uniforms[location], v0); }, + Uniform2i: (location, v0, v1) => { this.ctx.uniform2i(this.uniforms[location], v0, v1); }, + Uniform3i: (location, v0, v1, v2) => { this.ctx.uniform3i(this.uniforms[location], v0, v1, v2); }, + Uniform4i: (location, v0, v1, v2, v3) => { this.ctx.uniform4i(this.uniforms[location], v0, v1, v2, v3); }, + + UniformMatrix2fv: (location, addr) => { + let array = this.mem.loadF32Array(addr, 2*2); + this.ctx.uniformMatrix4fv(this.uniforms[location], false, array); + }, + UniformMatrix3fv: (location, addr) => { + let array = this.mem.loadF32Array(addr, 3*3); + this.ctx.uniformMatrix4fv(this.uniforms[location], false, array); + }, + UniformMatrix4fv: (location, addr) => { + let array = this.mem.loadF32Array(addr, 4*4); + this.ctx.uniformMatrix4fv(this.uniforms[location], false, array); + }, + + UseProgram: (program) => { + this.ctx.useProgram(this.programs[program]); + }, + ValidateProgram: (program) => { + this.ctx.validateProgram(this.programs[program]); + }, + + + VertexAttrib1f: (index, x) => { + this.ctx.vertexAttrib1f(index, x); + }, + VertexAttrib2f: (index, x, y) => { + this.ctx.vertexAttrib2f(index, x, y); + }, + VertexAttrib3f: (index, x, y, z) => { + this.ctx.vertexAttrib3f(index, x, y, z); + }, + VertexAttrib4f: (index, x, y, z, w) => { + this.ctx.vertexAttrib4f(index, x, y, z, w); + }, + VertexAttribPointer: (index, size, type, normalized, stride, ptr) => { + this.ctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr); + }, + + Viewport: (x, y, w, h) => { + this.ctx.viewport(x, y, w, h); + }, + }; + } + + getWebGL2Interface() { + return { + /* Buffer objects */ + CopyBufferSubData: (readTarget, writeTarget, readOffset, writeOffset, size) => { + this.assertWebGL2(); + this.ctx.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); + }, + GetBufferSubData: (target, srcByteOffset, dst_buffer_ptr, dst_buffer_len, dstOffset, length) => { + this.assertWebGL2(); + this.ctx.getBufferSubData(target, srcByteOffset, this.mem.loadBytes(dst_buffer_ptr, dst_buffer_len), dstOffset, length); + }, + + /* Framebuffer objects */ + BlitFramebuffer: (srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter) => { + this.assertWebGL2(); + this.ctx.glitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); + }, + FramebufferTextureLayer: (target, attachment, texture, level, layer) => { + this.assertWebGL2(); + this.ctx.framebufferTextureLayer(target, attachment, this.textures[texture], level, layer); + }, + InvalidateFramebuffer: (target, attachments_ptr, attachments_len) => { + this.assertWebGL2(); + let attachments = this.mem.loadU32Array(attachments_ptr, attachments_len); + this.ctx.invalidateFramebuffer(target, attachments); + }, + InvalidateSubFramebuffer: (target, attachments_ptr, attachments_len, x, y, width, height) => { + this.assertWebGL2(); + let attachments = this.mem.loadU32Array(attachments_ptr, attachments_len); + this.ctx.invalidateSubFramebuffer(target, attachments, x, y, width, height); + }, + ReadBuffer: (src) => { + this.assertWebGL2(); + this.ctx.readBuffer(src); + }, + + /* Renderbuffer objects */ + RenderbufferStorageMultisample: (target, samples, internalformat, width, height) => { + this.assertWebGL2(); + this.ctx.renderbufferStorageMultisample(target, samples, internalformat, width, height); + }, + + /* Texture objects */ + + TexStorage3D: (target, levels, internalformat, width, height, depth) => { + this.assertWebGL2(); + this.ctx.texStorage3D(target, level, internalformat, width, heigh, depth); + }, + TexImage3D: (target, level, internalformat, width, height, depth, border, format, type, size, data) => { + this.assertWebGL2(); + if (data) { + this.ctx.texImage3D(target, level, internalformat, width, height, depth, border, format, type, this.mem.loadBytes(data, size)); + } else { + this.ctx.texImage3D(target, level, internalformat, width, height, depth, border, format, type, null); + } + }, + TexSubImage3D: (target, level, xoffset, yoffset, width, height, depth, format, type, size, data) => { + this.assertWebGL2(); + this.ctx.texSubImage3D(target, level, xoffset, yoffset, width, height, depth, format, type, this.mem.loadBytes(data, size)); + }, + CompressedTexImage3D: (target, level, internalformat, width, height, depth, border, imageSize, data) => { + this.assertWebGL2(); + if (data) { + this.ctx.compressedTexImage3D(target, level, internalformat, width, height, depth, border, this.mem.loadBytes(data, imageSize)); + } else { + this.ctx.compressedTexImage3D(target, level, internalformat, width, height, depth, border, null); + } + }, + CompressedTexSubImage3D: (target, level, xoffset, yoffset, width, height, depth, format, imageSize, data) => { + this.assertWebGL2(); + if (data) { + this.ctx.compressedTexSubImage3D(target, level, xoffset, yoffset, width, height, depth, format, this.mem.loadBytes(data, imageSize)); + } else { + this.ctx.compressedTexSubImage3D(target, level, xoffset, yoffset, width, height, depth, format, null); + } + }, + + CopyTexSubImage3D: (target, level, xoffset, yoffset, zoffset, x, y, width, height) => { + this.assertWebGL2(); + this.ctx.copyTexImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); + }, + + /* Programs and shaders */ + GetFragDataLocation: (program, name_ptr, name_len) => { + this.assertWebGL2(); + return this.ctx.getFragDataLocation(this.programs[program], this.mem.loadString(name_ptr, name_len)); + }, + + /* Uniforms */ + Uniform1ui: (location, v0) => { + this.assertWebGL2(); + this.ctx.uniform1ui(this.uniforms[location], v0); + }, + Uniform2ui: (location, v0, v1) => { + this.assertWebGL2(); + this.ctx.uniform2ui(this.uniforms[location], v0, v1); + }, + Uniform3ui: (location, v0, v1, v2) => { + this.assertWebGL2(); + this.ctx.uniform3ui(this.uniforms[location], v0, v1, v2); + }, + Uniform4ui: (location, v0, v1, v2, v3) => { + this.assertWebGL2(); + this.ctx.uniform4ui(this.uniforms[location], v0, v1, v2, v3); + }, + + UniformMatrix3x2fv: (location, addr) => { + this.assertWebGL2(); + let array = this.mem.loadF32Array(addr, 3*2); + this.ctx.uniformMatrix3x2fv(this.uniforms[location], false, array); + }, + UniformMatrix4x2fv: (location, addr) => { + this.assertWebGL2(); + let array = this.mem.loadF32Array(addr, 4*2); + this.ctx.uniformMatrix4x2fv(this.uniforms[location], false, array); + }, + UniformMatrix2x3fv: (location, addr) => { + this.assertWebGL2(); + let array = this.mem.loadF32Array(addr, 2*3); + this.ctx.uniformMatrix2x3fv(this.uniforms[location], false, array); + }, + UniformMatrix4x3fv: (location, addr) => { + this.assertWebGL2(); + let array = this.mem.loadF32Array(addr, 4*3); + this.ctx.uniformMatrix4x3fv(this.uniforms[location], false, array); + }, + UniformMatrix2x4fv: (location, addr) => { + this.assertWebGL2(); + let array = this.mem.loadF32Array(addr, 2*4); + this.ctx.uniformMatrix2x4fv(this.uniforms[location], false, array); + }, + UniformMatrix3x4fv: (location, addr) => { + this.assertWebGL2(); + let array = this.mem.loadF32Array(addr, 3*4); + this.ctx.uniformMatrix3x4fv(this.uniforms[location], false, array); + }, + + /* Vertex attribs */ + VertexAttribI4i: (index, x, y, z, w) => { + this.assertWebGL2(); + this.ctx.vertexAttribI4i(index, x, y, z, w); + }, + VertexAttribI4ui: (index, x, y, z, w) => { + this.assertWebGL2(); + this.ctx.vertexAttribI4ui(index, x, y, z, w); + }, + VertexAttribIPointer: (index, size, type, stride, offset) => { + this.assertWebGL2(); + this.ctx.vertexAttribIPointer(index, size, type, stride, offset); + }, + + /* Writing to the drawing buffer */ + VertexAttribDivisor: (index, divisor) => { + this.assertWebGL2(); + this.ctx.vertexAttribDivisor(index, divisor); + }, + DrawArraysInstanced: (mode, first, count, instanceCount) => { + this.assertWebGL2(); + this.ctx.drawArraysInstanced(mode, first, count, instanceCount); + }, + DrawElementsInstanced: (mode, count, type, offset, instanceCount) => { + this.assertWebGL2(); + this.ctx.drawElementsInstanced(mode, count, type, offset, instanceCount); + }, + DrawRangeElements: (mode, start, end, count, type, offset) => { + this.assertWebGL2(); + this.ctx.drawRangeElements(mode, start, end, count, type, offset); + }, + + /* Multiple Render Targets */ + DrawBuffers: (buffers_ptr, buffers_len) => { + this.assertWebGL2(); + let array = this.mem.loadU32Array(buffers_ptr, buffers_len); + this.ctx.drawBuffers(array); + }, + ClearBufferfv: (buffer, drawbuffer, values_ptr, values_len) => { + this.assertWebGL2(); + let array = this.mem.loadF32Array(values_ptr, values_len); + this.ctx.clearBufferfv(buffer, drawbuffer, array); + }, + ClearBufferiv: (buffer, drawbuffer, values_ptr, values_len) => { + this.assertWebGL2(); + let array = this.mem.loadI32Array(values_ptr, values_len); + this.ctx.clearBufferiv(buffer, drawbuffer, array); + }, + ClearBufferuiv: (buffer, drawbuffer, values_ptr, values_len) => { + this.assertWebGL2(); + let array = this.mem.loadU32Array(values_ptr, values_len); + this.ctx.clearBufferuiv(buffer, drawbuffer, array); + }, + ClearBufferfi: (buffer, drawbuffer, depth, stencil) => { + this.assertWebGL2(); + this.ctx.clearBufferfi(buffer, drawbuffer, depth, stencil); + }, + + /* Query Objects */ + CreateQuery: () => { + this.assertWebGL2(); + let query = this.ctx.createQuery(); + let id = this.getNewId(this.queries); + query.name = id; + this.queries[id] = query; + return id; + }, + DeleteQuery: (id) => { + this.assertWebGL2(); + let obj = this.querys[id]; + if (obj && id != 0) { + this.ctx.deleteQuery(obj); + this.querys[id] = null; + } + }, + IsQuery: (query) => { + this.assertWebGL2(); + return this.ctx.isQuery(this.queries[query]); + }, + BeginQuery: (target, query) => { + this.assertWebGL2(); + this.ctx.beginQuery(target, this.queries[query]) + }, + EndQuery: (target) => { + this.assertWebGL2(); + this.ctx.endQuery(target); + }, + GetQuery: (target, pname) => { + this.assertWebGL2(); + let query = this.ctx.getQuery(target, pname); + if (!query) { + return 0; + } + if (this.queries.indexOf(query) !== -1) { + return query.name; + } + let id = this.getNewId(this.queries); + query.name = id; + this.queries[id] = query; + return id; + }, + + /* Sampler Objects */ + CreateSampler: () => { + this.assertWebGL2(); + let sampler = this.ctx.createSampler(); + let id = this.getNewId(this.samplers); + sampler.name = id; + this.samplers[id] = sampler; + return id; + }, + DeleteSampler: (id) => { + this.assertWebGL2(); + let obj = this.samplers[id]; + if (obj && id != 0) { + this.ctx.deleteSampler(obj); + this.samplers[id] = null; + } + }, + IsSampler: (sampler) => { + this.assertWebGL2(); + return this.ctx.isSampler(this.samplers[sampler]); + }, + BindSampler: (unit, sampler) => { + this.assertWebGL2(); + this.ctx.bindSampler(unit, this.samplers[Sampler]); + }, + SamplerParameteri: (sampler, pname, param) => { + this.assertWebGL2(); + this.ctx.samplerParameteri(this.samplers[sampler], pname, param); + }, + SamplerParameterf: (sampler, pname, param) => { + this.assertWebGL2(); + this.ctx.samplerParameterf(this.samplers[sampler], pname, param); + }, + + /* Sync objects */ + FenceSync: (condition, flags) => { + this.assertWebGL2(); + let sync = this.ctx.fenceSync(condition, flags); + let id = this.getNewId(this.syncs); + sync.name = id; + this.syncs[id] = sync; + return id; + }, + IsSync: (sync) => { + this.assertWebGL2(); + return this.ctx.isSync(this.syncs[sync]); + }, + DeleteSync: (id) => { + this.assertWebGL2(); + let obj = this.syncs[id]; + if (obj && id != 0) { + this.ctx.deleteSampler(obj); + this.syncs[id] = null; + } + }, + ClientWaitSync: (sync, flags, timeout) => { + this.assertWebGL2(); + return this.ctx.clientWaitSync(this.syncs[sync], flags, timeout); + }, + WaitSync: (sync, flags, timeout) => { + this.assertWebGL2(); + this.ctx.waitSync(this.syncs[sync], flags, timeout) ; + }, + + + /* Transform Feedback */ + CreateTransformFeedback: () => { + this.assertWebGL2(); + let transformFeedback = this.ctx.createtransformFeedback(); + let id = this.getNewId(this.transformFeedbacks); + transformFeedback.name = id; + this.transformFeedbacks[id] = transformFeedback; + return id; + }, + DeleteTransformFeedback: (id) => { + this.assertWebGL2(); + let obj = this.transformFeedbacks[id]; + if (obj && id != 0) { + this.ctx.deleteTransformFeedback(obj); + this.transformFeedbacks[id] = null; + } + }, + IsTransformFeedback: (tf) => { + this.assertWebGL2(); + return this.ctx.isTransformFeedback(this.transformFeedbacks[tf]); + }, + BindTransformFeedback: (target, tf) => { + this.assertWebGL2(); + this.ctx.bindTransformFeedback(target, this.transformFeedbacks[tf]); + }, + BeginTransformFeedback: (primitiveMode) => { + this.assertWebGL2(); + this.ctx.beginTransformFeedback(primitiveMode); + }, + EndTransformFeedback: () => { + this.assertWebGL2(); + this.ctx.endTransformFeedback(); + }, + TransformFeedbackVaryings: (program, varyings_ptr, varyings_len, bufferMode) => { + this.assertWebGL2(); + let varyings = []; + for (let i = 0; i < varyings_len; i++) { + let ptr = this.mem.loadPtr(varyings_ptr + i*STRING_SIZE + 0*4); + let len = this.mem.loadPtr(varyings_ptr + i*STRING_SIZE + 1*4); + varyings.push(this.mem.loadString(ptr, len)); + } + this.ctx.transformFeedbackVaryings(this.programs[program], varyings, bufferMode); + }, + PauseTransformFeedback: () => { + this.assertWebGL2(); + this.ctx.pauseTransformFeedback(); + }, + ResumeTransformFeedback: () => { + this.assertWebGL2(); + this.ctx.resumeTransformFeedback(); + }, + + + /* Uniform Buffer Objects and Transform Feedback Buffers */ + BindBufferBase: (target, index, buffer) => { + this.assertWebGL2(); + this.ctx.bindBufferBase(target, index, this.buffers[buffer]); + }, + BindBufferRange: (target, index, buffer, offset, size) => { + this.assertWebGL2(); + this.ctx.bindBufferRange(target, index, this.buffers[buffer], offset, size); + }, + GetUniformBlockIndex: (program, uniformBlockName_ptr, uniformBlockName_len) => { + this.assertWebGL2(); + return this.ctx.getUniformBlockIndex(this.programs[program], this.mem.loadString(uniformBlockName_ptr, uniformBlockName_len)); + }, + // any getActiveUniformBlockParameter(WebGLProgram program, GLuint uniformBlockIndex, GLenum pname); + GetActiveUniformBlockName: (program, uniformBlockIndex, buf_ptr, buf_len, length_ptr) => { + this.assertWebGL2(); + let name = this.ctx.getActiveUniformBlockName(this.programs[program], uniformBlockIndex); + + let n = Math.min(buf_len, name.length); + name = name.substring(0, n); + this.mem.loadBytes(buf_ptr, buf_len).set(new TextEncoder("utf-8").encode(name)) + storeInt(length_ptr, n); + }, + UniformBlockBinding: (program, uniformBlockIndex, uniformBlockBinding) => { + this.assertWebGL2(); + this.ctx.uniformBlockBinding(this.programs[program], uniformBlockIndex, uniformBlockBinding); + }, + + /* Vertex Array Objects */ + CreateVertexArray: () => { + this.assertWebGL2(); + let vao = this.ctx.createVertexArray(); + let id = this.getNewId(this.vaos); + vao.name = id; + this.vaos[id] = vao; + return id; + }, + DeleteVertexArray: (id) => { + this.assertWebGL2(); + let obj = this.vaos[id]; + if (obj && id != 0) { + this.ctx.deleteVertexArray(obj); + this.vaos[id] = null; + } + }, + IsVertexArray: (vertexArray) => { + this.assertWebGL2(); + return this.ctx.isVertexArray(this.vaos[vertexArray]); + }, + BindVertexArray: (vertexArray) => { + this.assertWebGL2(); + this.ctx.bindVertexArray(this.vaos[vertexArray]); + }, + }; + } +}; + + +export {WebGLInterface}; \ No newline at end of file diff --git a/vendor/wasm/WebGL/webgl.odin b/vendor/wasm/WebGL/webgl.odin new file mode 100644 index 000000000..c211fc526 --- /dev/null +++ b/vendor/wasm/WebGL/webgl.odin @@ -0,0 +1,249 @@ +package webgl + +foreign import "webgl" + +import glm "core:math/linalg/glsl" + +Enum :: distinct u32 + +Buffer :: distinct u32 +Framebuffer :: distinct u32 +Program :: distinct u32 +Renderbuffer :: distinct u32 +Shader :: distinct u32 +Texture :: distinct u32 + +@(default_calling_convention="c") +foreign webgl { + DrawingBufferWidth :: proc() -> i32 --- + DrawingBufferHeight :: proc() -> i32 --- + + GetWebGLVersion :: proc(major, minor: ^i32) --- + GetESVersion :: proc(major, minor: ^i32) --- + + GetError :: proc() -> Enum --- + + IsExtensionSupported :: proc(name: string) -> bool --- + + ActiveTexture :: proc(x: Enum) --- + AttachShader :: proc(program: Program, shader: Shader) --- + BindAttribLocation :: proc(program: Program, index: i32, name: string) --- + BindBuffer :: proc(target: Enum, buffer: Buffer) --- + BindFramebuffer :: proc(target: Enum, buffer: Buffer) --- + BindTexture :: proc(target: Enum, texture: Texture) --- + BlendColor :: proc(red, green, blue, alpha: f32) --- + BlendEquation :: proc(mode: Enum) --- + BlendFunc :: proc(sfactor, dfactor: Enum) --- + BlendFuncSeparate :: proc(srcRGB, dstRGB, srcAlpha, dstAlpha: Enum) --- + + BufferData :: proc(target: Enum, size: int, data: rawptr, usage: Enum) --- + BufferSubData :: proc(target: Enum, offset: uintptr, size: int, data: rawptr) --- + + Clear :: proc(bits: Enum) --- + ClearColor :: proc(r, g, b, a: f32) --- + ClearDepth :: proc(x: Enum) --- + ClearStencil :: proc(x: Enum) --- + ClearMask :: proc(r, g, b, a: bool) --- + CompileShader :: proc(shader: Shader) --- + + CompressedTexImage2D :: proc(target: Enum, level: i32, internalformat: Enum, width, height: i32, border: i32, imageSize: int, data: rawptr) --- + CompressedTexSubImage2D :: proc(target: Enum, level: i32, xoffset, yoffset, width, height: i32, format: Enum, imageSize: int, data: rawptr) --- + CopyTexImage2D :: proc(target: Enum, level: i32, internalformat: Enum, x, y, width, height: i32, border: i32) --- + CopyTexSubImage2D :: proc(target: Enum, level: i32, xoffset, yoffset, x, y: i32, width, height: i32) --- + + + CreateBuffer :: proc() -> Buffer --- + CreateFramebuffer :: proc() -> Framebuffer --- + CreateProgram :: proc() -> Program --- + CreateRenderbuffer :: proc() -> Renderbuffer --- + CreateShader :: proc(shaderType: Enum) -> Shader --- + CreateTexture :: proc() -> Texture --- + + CullFace :: proc(mode: Enum) --- + + DeleteBuffer :: proc(buffer: Buffer) --- + DeleteFramebuffer :: proc(framebuffer: Framebuffer) --- + DeleteProgram :: proc(program: Program) --- + DeleteRenderbuffer :: proc(renderbuffer: Renderbuffer) --- + DeleteShader :: proc(shader: Shader) --- + DeleteTexture :: proc(texture: Texture) --- + + DepthFunc :: proc(func: Enum) --- + DepthMask :: proc(flag: bool) --- + DepthRange :: proc(zNear, zFar: f32) --- + DetachShader :: proc(program: Program, shader: Shader) --- + Disable :: proc(cap: Enum) --- + DisableVertexAttribArray :: proc(index: i32) --- + DrawArrays :: proc(mode: Enum, first, count: int) --- + DrawElements :: proc(mode: Enum, count: int, type: Enum, indices: rawptr) --- + + Enable :: proc(cap: Enum) --- + EnableVertexAttribArray :: proc(index: i32) --- + Finish :: proc() --- + Flush :: proc() --- + FramebufferRenderbuffer :: proc(target, attachment, renderbufertarget: Enum, renderbuffer: Renderbuffer) --- + FramebufferTexture2D :: proc(target, attachment, textarget: Enum, texture: Texture, level: i32) --- + FrontFace :: proc(mode: Enum) --- + + GenerateMipmap :: proc(target: Enum) --- + + GetAttribLocation :: proc(program: Program, name: string) -> i32 --- + GetUniformLocation :: proc(program: Program, name: string) -> i32 --- + GetVertexAttribOffset :: proc(index: i32, pname: Enum) -> uintptr --- + GetProgramParameter :: proc(program: Program, pname: Enum) -> i32 --- + + Hint :: proc(target: Enum, mode: Enum) --- + + IsBuffer :: proc(buffer: Buffer) -> bool --- + IsFramebuffer :: proc(framebuffer: Framebuffer) -> bool --- + IsProgram :: proc(program: Program) -> bool --- + IsRenderbuffer :: proc(renderbuffer: Renderbuffer) -> bool --- + IsShader :: proc(shader: Shader) -> bool --- + IsTexture :: proc(texture: Texture) -> bool --- + + LineWidth :: proc(width: f32) --- + LinkProgram :: proc(program: Program) --- + PixelStorei :: proc(pname: Enum, param: i32) --- + PolygonOffset :: proc(factor: f32, units: f32) --- + + ReadnPixels :: proc(x, y, width, height: i32, format: Enum, type: Enum, bufSize: int, data: rawptr) --- + RenderbufferStorage :: proc(target: Enum, internalformat: Enum, width, height: i32) --- + SampleCoverage :: proc(value: f32, invert: bool) --- + Scissor :: proc(x, y, width, height: i32) --- + ShaderSource :: proc(shader: Shader, strings: []string) --- + + StencilFunc :: proc(func: Enum, ref: i32, mask: u32) --- + StencilFuncSeparate :: proc(face, func: Enum, ref: i32, mask: u32) --- + StencilMask :: proc(mask: u32) --- + StencilMaskSeparate :: proc(face: Enum, mask: u32) --- + StencilOp :: proc(fail, zfail, zpass: Enum) --- + StencilOpSeparate :: proc(face, fail, zfail, zpass: Enum) --- + + TexImage2D :: proc(target: Enum, level: i32, internalformat: Enum, width, height: i32, border: i32, format, type: Enum, size: int, data: rawptr) --- + TexSubImage2D :: proc(target: Enum, level: i32, xoffset, yoffset, width, height: i32, format, type: Enum, size: int, data: rawptr) --- + + TexParameterf :: proc(target, pname: Enum, param: f32) --- + TexParameteri :: proc(target, pname: Enum, param: i32) --- + + Uniform1f :: proc(location: i32, v0: f32) --- + Uniform2f :: proc(location: i32, v0, v1: f32) --- + Uniform3f :: proc(location: i32, v0, v1, v2: f32) --- + Uniform4f :: proc(location: i32, v0, v1, v2, v3: f32) --- + + Uniform1i :: proc(location: i32, v0: i32) --- + Uniform2i :: proc(location: i32, v0, v1: i32) --- + Uniform3i :: proc(location: i32, v0, v1, v2: i32) --- + Uniform4i :: proc(location: i32, v0, v1, v2, v3: i32) --- + + UseProgram :: proc(program: Program) --- + ValidateProgram :: proc(program: Program) --- + + VertexAttrib1f :: proc(index: i32, x: f32) --- + VertexAttrib2f :: proc(index: i32, x, y: f32) --- + VertexAttrib3f :: proc(index: i32, x, y, z: f32) --- + VertexAttrib4f :: proc(index: i32, x, y, z, w: f32) --- + VertexAttribPointer :: proc(index: i32, size: int, type: Enum, normalized: bool, stride: int, ptr: uintptr) --- + + Viewport :: proc(x, y, w, h: i32) --- +} + +Uniform1fv :: proc "c" (location: i32, v: f32) { Uniform1f(location, v) } +Uniform2fv :: proc "c" (location: i32, v: glm.vec2) { Uniform2f(location, v.x, v.y) } +Uniform3fv :: proc "c" (location: i32, v: glm.vec3) { Uniform3f(location, v.x, v.y, v.z) } +Uniform4fv :: proc "c" (location: i32, v: glm.vec4) { Uniform4f(location, v.x, v.y, v.z, v.w) } +Uniform1iv :: proc "c" (location: i32, v: i32) { Uniform1i(location, v) } +Uniform2iv :: proc "c" (location: i32, v: glm.ivec2) { Uniform2i(location, v.x, v.y) } +Uniform3iv :: proc "c" (location: i32, v: glm.ivec3) { Uniform3i(location, v.x, v.y, v.z) } +Uniform4iv :: proc "c" (location: i32, v: glm.ivec4) { Uniform4i(location, v.x, v.y, v.z, v.w) } + +VertexAttrib1fv :: proc "c" (index: i32, v: f32) { VertexAttrib1f(index, v) } +VertexAttrib2fv :: proc "c" (index: i32, v: glm.vec2){ VertexAttrib2f(index, v.x, v.y) } +VertexAttrib3fv :: proc "c" (index: i32, v: glm.vec3){ VertexAttrib3f(index, v.x, v.y, v.z) } +VertexAttrib4fv :: proc "c" (index: i32, v: glm.vec4){ VertexAttrib4f(index, v.x, v.y, v.z, v.w) } + +UniformMatrix2fv :: proc "c" (location: i32, m: glm.mat2) { + foreign webgl { + @(link_name="UniformMatrix2fv") + _UniformMatrix2fv :: proc "c" (location: i32, value: [^]f32) --- + } + value := transmute([2*2]f32)m + _UniformMatrix2fv(location, &value[0]) +} +UniformMatrix3fv :: proc "c" (location: i32, m: glm.mat3) { + foreign webgl { + @(link_name="UniformMatrix3fv") + _UniformMatrix3fv :: proc "c" (location: i32, value: [^]f32) --- + } + value := transmute([3*3]f32)m + _UniformMatrix3fv(location, &value[0]) +} +UniformMatrix4fv :: proc "c" (location: i32, m: glm.mat4) { + foreign webgl { + @(link_name="UniformMatrix4fv") + _UniformMatrix4fv :: proc "c" (location: i32, value: [^]f32) --- + } + value := transmute([4*4]f32)m + _UniformMatrix4fv(location, &value[0]) +} + +GetShaderiv :: proc "c" (shader: Shader, pname: Enum) -> (p: i32) { + @(default_calling_convention="c") + foreign webgl { + @(link_name="GetShaderiv") + _GetShaderiv :: proc "c" (shader: Shader, pname: Enum, p: ^i32) --- + } + _GetShaderiv(shader, pname, &p) + return +} + + +GetProgramInfoLog :: proc "c" (program: Program, buf: []byte) -> string { + @(default_calling_convention="c") + foreign webgl { + @(link_name="GetProgramInfoLog") + _GetProgramInfoLog :: proc "c" (program: Program, buf: []byte, length: ^int) --- + } + + length: int + _GetProgramInfoLog(program, buf, &length) + return string(buf[:length]) +} + +GetShaderInfoLog :: proc "c" (shader: Shader, buf: []byte) -> string { + @(default_calling_convention="c") + foreign webgl { + @(link_name="GetShaderInfoLog") + _GetShaderInfoLog :: proc "c" (shader: Shader, buf: []byte, length: ^int) --- + } + + length: int + _GetShaderInfoLog(shader, buf, &length) + return string(buf[:length]) +} + + + +BufferDataSlice :: proc "c" (target: Enum, slice: $S/[]$E, usage: Enum) { + BufferData(target, len(slice)*size_of(E), raw_data(slice), usage) +} +BufferSubDataSlice :: proc "c" (target: Enum, offset: uintptr, slice: $S/[]$E) { + BufferSubData(target, offset, len(slice)*size_of(E), raw_data(slice), usage) +} + +CompressedTexImage2DSlice :: proc "c" (target: Enum, level: i32, internalformat: Enum, width, height: i32, border: i32, slice: $S/[]$E) { + CompressedTexImage2DSlice(target, level, internalformat, width, height, border, len(slice)*size_of(E), raw_data(slice)) +} +CompressedTexSubImage2DSlice :: proc "c" (target: Enum, level: i32, xoffset, yoffset, width, height: i32, format: Enum, slice: $S/[]$E) { + CompressedTexSubImage2DSlice(target, level, level, xoffset, yoffset, width, height, format, len(slice)*size_of(E), raw_data(slice)) +} + +ReadPixelsSlice :: proc "c" (x, y, width, height: i32, format: Enum, type: Enum, slice: $S/[]$E) { + ReadnPixels(x, y, width, height, format, type, len(slice)*size_of(E), raw_data(slice)) +} + +TexImage2DSlice :: proc "c" (target: Enum, level: i32, internalformat: Enum, width, height: i32, border: i32, format, type: Enum, slice: $S/[]$E) { + TexImage2D(target, level, internalformat, width, height, border, format, type, len(slice)*size_of(E), raw_data(slice)) +} +TexSubImage2DSlice :: proc "c" (target: Enum, level: i32, xoffset, yoffset, width, height: i32, format, type: Enum, slice: $S/[]$E) { + TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, len(slice)*size_of(E), raw_data(slice)) +} \ No newline at end of file diff --git a/vendor/wasm/WebGL/webgl2.odin b/vendor/wasm/WebGL/webgl2.odin new file mode 100644 index 000000000..a1d55b703 --- /dev/null +++ b/vendor/wasm/WebGL/webgl2.odin @@ -0,0 +1,182 @@ +package webgl + +foreign import "webgl2" + +import glm "core:math/linalg/glsl" + +Query :: distinct u32 +Sampler :: distinct u32 +Sync :: distinct u32 +TransformFeedback :: distinct u32 +VertexArrayObject :: distinct u32 + +IsWebGL2Supported :: proc "c" () -> bool { + major, minor: i32 + GetWebGLVersion(&major, &minor) + return major >= 2 +} + +@(default_calling_convention="c") +foreign webgl2 { + /* Buffer objects */ + CopyBufferSubData :: proc(readTarget, writeTarget: Enum, readOffset, writeOffset: int, size: int) --- + GetBufferSubData :: proc(target: Enum, srcByteOffset: int, dst_buffer: []byte, dstOffset: int = 0, length: int = 0) --- + + /* Framebuffer objects */ + BlitFramebuffer :: proc(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1: i32, mask: u32, filter: Enum) --- + FramebufferTextureLayer :: proc(target: Enum, attachment: Enum, texture: Texture, level: i32, layer: i32) --- + InvalidateFramebuffer :: proc(target: Enum, attachments: []Enum) --- + InvalidateSubFramebuffer :: proc(target: Enum, attachments: []Enum, x, y, width, height: i32) --- + ReadBuffer :: proc(src: Enum) --- + + /* Renderbuffer objects */ + RenderbufferStorageMultisample :: proc(target: Enum, samples: i32, internalformat: Enum, width, height: i32) --- + + /* Texture objects */ + TexStorage3D :: proc(target: Enum, levels: i32, internalformat: Enum, width, height, depth: i32) --- + TexImage3D :: proc(target: Enum, level: i32, internalformat: Enum, width, height, depth: i32, border: i32, format, type: Enum, size: int, data: rawptr) --- + TexSubImage3D :: proc(target: Enum, level: i32, xoffset, yoffset, width, height, depth: i32, format, type: Enum, size: int, data: rawptr) --- + CompressedTexImage3D :: proc(target: Enum, level: i32, internalformat: Enum, width, height, depth: i32, border: i32, imageSize: int, data: rawptr) --- + CompressedTexSubImage3D :: proc(target: Enum, level: i32, xoffset, yoffset: i32, width, height, depth: i32, format: Enum, imageSize: int, data: rawptr) --- + CopyTexSubImage3D :: proc(target: Enum, level: i32, xoffset, yoffset, zoffset: i32, x, y, width, height: i32) --- + + /* Programs and shaders */ + GetFragDataLocation :: proc(program: Program, name: string) -> i32 --- + + /* Uniforms */ + Uniform1ui :: proc(location: i32, v0: u32) --- + Uniform2ui :: proc(location: i32, v0: u32, v1: u32) --- + Uniform3ui :: proc(location: i32, v0: u32, v1: u32, v2: u32) --- + Uniform4ui :: proc(location: i32, v0: u32, v1: u32, v2: u32, v3: u32) --- + + /* Vertex attribs */ + VertexAttribI4i :: proc(index: i32, x, y, z, w: i32) --- + VertexAttribI4ui :: proc(index: i32, x, y, z, w: u32) --- + VertexAttribIPointer :: proc(index: i32, size: int, type: Enum, stride: int, offset: uintptr) --- + + /* Writing to the drawing buffer */ + VertexAttribDivisor :: proc(index: u32, divisor: u32) --- + DrawArraysInstanced :: proc(mode: Enum, first, count: int, instanceCount: int) --- + DrawElementsInstanced :: proc(mode: Enum, count: int, type: Enum, offset: int, instanceCount: int) --- + DrawRangeElements :: proc(mode: Enum, start, end, count: int, type: Enum, offset: int) --- + + /* Multiple Render Targets */ + DrawBuffers :: proc(buffers: []Enum) --- + ClearBufferfv :: proc(buffer: Enum, drawbuffer: i32, values: []f32) --- + ClearBufferiv :: proc(buffer: Enum, drawbuffer: i32, values: []i32) --- + ClearBufferuiv :: proc(buffer: Enum, drawbuffer: i32, values: []u32) --- + ClearBufferfi :: proc(buffer: Enum, drawbuffer: i32, depth: f32, stencil: i32) --- + + CreateQuery :: proc() -> Query --- + DeleteQuery :: proc(query: Query) --- + IsQuery :: proc(query: Query) -> bool --- + BeginQuery :: proc(target: Enum, query: Query) --- + EndQuery :: proc(target: Enum) --- + GetQuery :: proc(target, pname: Enum) --- + + CreateSampler :: proc() -> Sampler --- + DeleteSampler :: proc(sampler: Sampler) --- + IsSampler :: proc(sampler: Sampler) -> bool --- + BindSampler :: proc(unit: Enum, sampler: Sampler) --- + SamplerParameteri :: proc(sampler: Sampler, pname: Enum, param: i32) --- + SamplerParameterf :: proc(sampler: Sampler, pname: Enum, param: f32) --- + + FenceSync :: proc(condition: Enum, flags: u32) -> Sync --- + IsSync :: proc(sync: Sync) -> bool --- + DeleteSync :: proc(sync: Sync) --- + ClientWaitSync :: proc(sync: Sync, flags: u32, timeout: u64) --- + WaitSync :: proc(sync: Sync, flags: u32, timeout: i64) --- + + CreateTransformFeedback :: proc() -> TransformFeedback --- + DeleteTransformFeedback :: proc(tf: TransformFeedback) --- + IsTransformFeedback :: proc(tf: TransformFeedback) -> bool --- + BindTransformFeedback :: proc(target: Enum, tf: TransformFeedback) --- + BeginTransformFeedback :: proc(primitiveMode: Enum) --- + EndTransformFeedback :: proc() --- + TransformFeedbackVaryings :: proc(program: Program, varyings: []string, bufferMode: Enum) --- + PauseTransformFeedback :: proc() --- + ResumeTransformFeedback :: proc() --- + + BindBufferBase :: proc(target: Enum, index: i32, buffer: Buffer) --- + BindBufferRange :: proc(target: Enum, index: i32, buffer: Buffer, offset: int, size: int) --- + GetUniformBlockIndex :: proc(program: Program, uniformBlockName: string) -> i32 --- + UniformBlockBinding :: proc(program: Program, uniformBlockIndex: i32, uniformBlockBinding: i32) --- + + CreateVertexArray :: proc() -> VertexArrayObject --- + DeleteVertexArray :: proc(vertexArray: VertexArrayObject) --- + IsVertexArray :: proc(vertexArray: VertexArrayObject) -> bool --- + BindVertexArray :: proc(vertexArray: VertexArrayObject) --- +} + +GetActiveUniformBlockName :: proc(program: Program, uniformBlockIndex: i32, buf: []byte) -> string { + foreign webgl2 { + _GetActiveUniformBlockName :: proc(program: Program, uniformBlockIndex: i32, buf: []byte, length: ^int) --- + } + n: int + _GetActiveUniformBlockName(program, uniformBlockIndex, buf, &n) + return string(buf[:n]) +} + + +Uniform1uiv :: proc "c" (location: i32, v: u32) { + Uniform1ui(location, v) +} +Uniform2uiv :: proc "c" (location: i32, v: glm.uvec2) { + Uniform2ui(location, v.x, v.y) +} +Uniform3uiv :: proc "c" (location: i32, v: glm.uvec3) { + Uniform3ui(location, v.x, v.y, v.z) +} +Uniform4uiv :: proc "c" (location: i32, v: glm.uvec4) { + Uniform4ui(location, v.x, v.y, v.z, v.w) +} + +UniformMatrix3x2fv :: proc "c" (location: i32, m: glm.mat3x2) { + foreign webgl2 { + _UniformMatrix3x2fv :: proc "c" (location: i32, addr: [^]f32) --- + } + array := matrix_flatten(m) + _UniformMatrix3x2fv(location, &array[0]) +} +UniformMatrix4x2fv :: proc "c" (location: i32, m: glm.mat4x2) { + foreign webgl2 { + _UniformMatrix4x2fv :: proc "c" (location: i32, addr: [^]f32) --- + } + array := matrix_flatten(m) + _UniformMatrix4x2fv(location, &array[0]) +} +UniformMatrix2x3fv :: proc "c" (location: i32, m: glm.mat2x3) { + foreign webgl2 { + _UniformMatrix2x3fv :: proc "c" (location: i32, addr: [^]f32) --- + } + array := matrix_flatten(m) + _UniformMatrix2x3fv(location, &array[0]) +} +UniformMatrix4x3fv :: proc "c" (location: i32, m: glm.mat4x3) { + foreign webgl2 { + _UniformMatrix4x3fv :: proc "c" (location: i32, addr: [^]f32) --- + } + array := matrix_flatten(m) + _UniformMatrix4x3fv(location, &array[0]) +} +UniformMatrix2x4fv :: proc "c" (location: i32, m: glm.mat2x4) { + foreign webgl2 { + _UniformMatrix2x4fv :: proc "c" (location: i32, addr: [^]f32) --- + } + array := matrix_flatten(m) + _UniformMatrix2x4fv(location, &array[0]) +} +UniformMatrix3x4fv :: proc "c" (location: i32, m: glm.mat3x4) { + foreign webgl2 { + _UniformMatrix3x4fv :: proc "c" (location: i32, addr: [^]f32) --- + } + array := matrix_flatten(m) + _UniformMatrix3x4fv(location, &array[0]) +} + +VertexAttribI4iv :: proc "c" (index: i32, v: glm.ivec4) { + VertexAttribI4i(index, v.x, v.y, v.z, v.w) +} +VertexAttribI4uiv :: proc "c" (index: i32, v: glm.uvec4) { + VertexAttribI4ui(index, v.x, v.y, v.z, v.w) +} diff --git a/vendor/wasm/WebGL/webgl2_constants.odin b/vendor/wasm/WebGL/webgl2_constants.odin new file mode 100644 index 000000000..a8cc83b60 --- /dev/null +++ b/vendor/wasm/WebGL/webgl2_constants.odin @@ -0,0 +1,268 @@ +package webgl + +READ_BUFFER :: Enum(0x0C02) +UNPACK_ROW_LENGTH :: Enum(0x0CF2) +UNPACK_SKIP_ROWS :: Enum(0x0CF3) +UNPACK_SKIP_PIXELS :: Enum(0x0CF4) +PACK_ROW_LENGTH :: Enum(0x0D02) +PACK_SKIP_ROWS :: Enum(0x0D03) +PACK_SKIP_PIXELS :: Enum(0x0D04) +COLOR :: Enum(0x1800) +DEPTH :: Enum(0x1801) +STENCIL :: Enum(0x1802) +RED :: Enum(0x1903) +RGB8 :: Enum(0x8051) +RGBA8 :: Enum(0x8058) +RGB10_A2 :: Enum(0x8059) +TEXTURE_BINDING_3D :: Enum(0x806A) +UNPACK_SKIP_IMAGES :: Enum(0x806D) +UNPACK_IMAGE_HEIGHT :: Enum(0x806E) +TEXTURE_3D :: Enum(0x806F) +TEXTURE_WRAP_R :: Enum(0x8072) +MAX_3D_TEXTURE_SIZE :: Enum(0x8073) +UNSIGNED_INT_2_10_10_10_REV :: Enum(0x8368) +MAX_ELEMENTS_VERTICES :: Enum(0x80E8) +MAX_ELEMENTS_INDICES :: Enum(0x80E9) +TEXTURE_MIN_LOD :: Enum(0x813A) +TEXTURE_MAX_LOD :: Enum(0x813B) +TEXTURE_BASE_LEVEL :: Enum(0x813C) +TEXTURE_MAX_LEVEL :: Enum(0x813D) +MIN :: Enum(0x8007) +MAX :: Enum(0x8008) +DEPTH_COMPONENT24 :: Enum(0x81A6) +MAX_TEXTURE_LOD_BIAS :: Enum(0x84FD) +TEXTURE_COMPARE_MODE :: Enum(0x884C) +TEXTURE_COMPARE_FUNC :: Enum(0x884D) +CURRENT_QUERY :: Enum(0x8865) +QUERY_RESULT :: Enum(0x8866) +QUERY_RESULT_AVAILABLE :: Enum(0x8867) +STREAM_READ :: Enum(0x88E1) +STREAM_COPY :: Enum(0x88E2) +STATIC_READ :: Enum(0x88E5) +STATIC_COPY :: Enum(0x88E6) +DYNAMIC_READ :: Enum(0x88E9) +DYNAMIC_COPY :: Enum(0x88EA) +MAX_DRAW_BUFFERS :: Enum(0x8824) +DRAW_BUFFER0 :: Enum(0x8825) +DRAW_BUFFER1 :: Enum(0x8826) +DRAW_BUFFER2 :: Enum(0x8827) +DRAW_BUFFER3 :: Enum(0x8828) +DRAW_BUFFER4 :: Enum(0x8829) +DRAW_BUFFER5 :: Enum(0x882A) +DRAW_BUFFER6 :: Enum(0x882B) +DRAW_BUFFER7 :: Enum(0x882C) +DRAW_BUFFER8 :: Enum(0x882D) +DRAW_BUFFER9 :: Enum(0x882E) +DRAW_BUFFER10 :: Enum(0x882F) +DRAW_BUFFER11 :: Enum(0x8830) +DRAW_BUFFER12 :: Enum(0x8831) +DRAW_BUFFER13 :: Enum(0x8832) +DRAW_BUFFER14 :: Enum(0x8833) +DRAW_BUFFER15 :: Enum(0x8834) +MAX_FRAGMENT_UNIFORM_COMPONENTS :: Enum(0x8B49) +MAX_VERTEX_UNIFORM_COMPONENTS :: Enum(0x8B4A) +SAMPLER_3D :: Enum(0x8B5F) +SAMPLER_2D_SHADOW :: Enum(0x8B62) +FRAGMENT_SHADER_DERIVATIVE_HINT :: Enum(0x8B8B) +PIXEL_PACK_BUFFER :: Enum(0x88EB) +PIXEL_UNPACK_BUFFER :: Enum(0x88EC) +PIXEL_PACK_BUFFER_BINDING :: Enum(0x88ED) +PIXEL_UNPACK_BUFFER_BINDING :: Enum(0x88EF) +FLOAT_MAT2x3 :: Enum(0x8B65) +FLOAT_MAT2x4 :: Enum(0x8B66) +FLOAT_MAT3x2 :: Enum(0x8B67) +FLOAT_MAT3x4 :: Enum(0x8B68) +FLOAT_MAT4x2 :: Enum(0x8B69) +FLOAT_MAT4x3 :: Enum(0x8B6A) +SRGB :: Enum(0x8C40) +SRGB8 :: Enum(0x8C41) +SRGB8_ALPHA8 :: Enum(0x8C43) +COMPARE_REF_TO_TEXTURE :: Enum(0x884E) +RGBA32F :: Enum(0x8814) +RGB32F :: Enum(0x8815) +RGBA16F :: Enum(0x881A) +RGB16F :: Enum(0x881B) +VERTEX_ATTRIB_ARRAY_INTEGER :: Enum(0x88FD) +MAX_ARRAY_TEXTURE_LAYERS :: Enum(0x88FF) +MIN_PROGRAM_TEXEL_OFFSET :: Enum(0x8904) +MAX_PROGRAM_TEXEL_OFFSET :: Enum(0x8905) +MAX_VARYING_COMPONENTS :: Enum(0x8B4B) +TEXTURE_2D_ARRAY :: Enum(0x8C1A) +TEXTURE_BINDING_2D_ARRAY :: Enum(0x8C1D) +R11F_G11F_B10F :: Enum(0x8C3A) +UNSIGNED_INT_10F_11F_11F_REV :: Enum(0x8C3B) +RGB9_E5 :: Enum(0x8C3D) +UNSIGNED_INT_5_9_9_9_REV :: Enum(0x8C3E) +TRANSFORM_FEEDBACK_BUFFER_MODE :: Enum(0x8C7F) +MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS :: Enum(0x8C80) +TRANSFORM_FEEDBACK_VARYINGS :: Enum(0x8C83) +TRANSFORM_FEEDBACK_BUFFER_START :: Enum(0x8C84) +TRANSFORM_FEEDBACK_BUFFER_SIZE :: Enum(0x8C85) +TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN :: Enum(0x8C88) +RASTERIZER_DISCARD :: Enum(0x8C89) +MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS :: Enum(0x8C8A) +MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS :: Enum(0x8C8B) +INTERLEAVED_ATTRIBS :: Enum(0x8C8C) +SEPARATE_ATTRIBS :: Enum(0x8C8D) +TRANSFORM_FEEDBACK_BUFFER :: Enum(0x8C8E) +TRANSFORM_FEEDBACK_BUFFER_BINDING :: Enum(0x8C8F) +RGBA32UI :: Enum(0x8D70) +RGB32UI :: Enum(0x8D71) +RGBA16UI :: Enum(0x8D76) +RGB16UI :: Enum(0x8D77) +RGBA8UI :: Enum(0x8D7C) +RGB8UI :: Enum(0x8D7D) +RGBA32I :: Enum(0x8D82) +RGB32I :: Enum(0x8D83) +RGBA16I :: Enum(0x8D88) +RGB16I :: Enum(0x8D89) +RGBA8I :: Enum(0x8D8E) +RGB8I :: Enum(0x8D8F) +RED_INTEGER :: Enum(0x8D94) +RGB_INTEGER :: Enum(0x8D98) +RGBA_INTEGER :: Enum(0x8D99) +SAMPLER_2D_ARRAY :: Enum(0x8DC1) +SAMPLER_2D_ARRAY_SHADOW :: Enum(0x8DC4) +SAMPLER_CUBE_SHADOW :: Enum(0x8DC5) +UNSIGNED_INT_VEC2 :: Enum(0x8DC6) +UNSIGNED_INT_VEC3 :: Enum(0x8DC7) +UNSIGNED_INT_VEC4 :: Enum(0x8DC8) +INT_SAMPLER_2D :: Enum(0x8DCA) +INT_SAMPLER_3D :: Enum(0x8DCB) +INT_SAMPLER_CUBE :: Enum(0x8DCC) +INT_SAMPLER_2D_ARRAY :: Enum(0x8DCF) +UNSIGNED_INT_SAMPLER_2D :: Enum(0x8DD2) +UNSIGNED_INT_SAMPLER_3D :: Enum(0x8DD3) +UNSIGNED_INT_SAMPLER_CUBE :: Enum(0x8DD4) +UNSIGNED_INT_SAMPLER_2D_ARRAY :: Enum(0x8DD7) +DEPTH_COMPONENT32F :: Enum(0x8CAC) +DEPTH32F_STENCIL8 :: Enum(0x8CAD) +FLOAT_32_UNSIGNED_INT_24_8_REV :: Enum(0x8DAD) +FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING :: Enum(0x8210) +FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE :: Enum(0x8211) +FRAMEBUFFER_ATTACHMENT_RED_SIZE :: Enum(0x8212) +FRAMEBUFFER_ATTACHMENT_GREEN_SIZE :: Enum(0x8213) +FRAMEBUFFER_ATTACHMENT_BLUE_SIZE :: Enum(0x8214) +FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE :: Enum(0x8215) +FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE :: Enum(0x8216) +FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE :: Enum(0x8217) +FRAMEBUFFER_DEFAULT :: Enum(0x8218) +UNSIGNED_INT_24_8 :: Enum(0x84FA) +DEPTH24_STENCIL8 :: Enum(0x88F0) +UNSIGNED_NORMALIZED :: Enum(0x8C17) +DRAW_FRAMEBUFFER_BINDING :: FRAMEBUFFER_BINDING /* Same as FRAMEBUFFER_BINDING */ +READ_FRAMEBUFFER :: Enum(0x8CA8) +DRAW_FRAMEBUFFER :: Enum(0x8CA9) +READ_FRAMEBUFFER_BINDING :: Enum(0x8CAA) +RENDERBUFFER_SAMPLES :: Enum(0x8CAB) +FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER :: Enum(0x8CD4) +MAX_COLOR_ATTACHMENTS :: Enum(0x8CDF) +COLOR_ATTACHMENT1 :: Enum(0x8CE1) +COLOR_ATTACHMENT2 :: Enum(0x8CE2) +COLOR_ATTACHMENT3 :: Enum(0x8CE3) +COLOR_ATTACHMENT4 :: Enum(0x8CE4) +COLOR_ATTACHMENT5 :: Enum(0x8CE5) +COLOR_ATTACHMENT6 :: Enum(0x8CE6) +COLOR_ATTACHMENT7 :: Enum(0x8CE7) +COLOR_ATTACHMENT8 :: Enum(0x8CE8) +COLOR_ATTACHMENT9 :: Enum(0x8CE9) +COLOR_ATTACHMENT10 :: Enum(0x8CEA) +COLOR_ATTACHMENT11 :: Enum(0x8CEB) +COLOR_ATTACHMENT12 :: Enum(0x8CEC) +COLOR_ATTACHMENT13 :: Enum(0x8CED) +COLOR_ATTACHMENT14 :: Enum(0x8CEE) +COLOR_ATTACHMENT15 :: Enum(0x8CEF) +FRAMEBUFFER_INCOMPLETE_MULTISAMPLE :: Enum(0x8D56) +MAX_SAMPLES :: Enum(0x8D57) +HALF_FLOAT :: Enum(0x140B) +RG :: Enum(0x8227) +RG_INTEGER :: Enum(0x8228) +R8 :: Enum(0x8229) +RG8 :: Enum(0x822B) +R16F :: Enum(0x822D) +R32F :: Enum(0x822E) +RG16F :: Enum(0x822F) +RG32F :: Enum(0x8230) +R8I :: Enum(0x8231) +R8UI :: Enum(0x8232) +R16I :: Enum(0x8233) +R16UI :: Enum(0x8234) +R32I :: Enum(0x8235) +R32UI :: Enum(0x8236) +RG8I :: Enum(0x8237) +RG8UI :: Enum(0x8238) +RG16I :: Enum(0x8239) +RG16UI :: Enum(0x823A) +RG32I :: Enum(0x823B) +RG32UI :: Enum(0x823C) +VERTEX_ARRAY_BINDING :: Enum(0x85B5) +R8_SNORM :: Enum(0x8F94) +RG8_SNORM :: Enum(0x8F95) +RGB8_SNORM :: Enum(0x8F96) +RGBA8_SNORM :: Enum(0x8F97) +SIGNED_NORMALIZED :: Enum(0x8F9C) +COPY_READ_BUFFER :: Enum(0x8F36) +COPY_WRITE_BUFFER :: Enum(0x8F37) +COPY_READ_BUFFER_BINDING :: COPY_READ_BUFFER /* Same as COPY_READ_BUFFER */ +COPY_WRITE_BUFFER_BINDING :: COPY_WRITE_BUFFER /* Same as COPY_WRITE_BUFFER */ +UNIFORM_BUFFER :: Enum(0x8A11) +UNIFORM_BUFFER_BINDING :: Enum(0x8A28) +UNIFORM_BUFFER_START :: Enum(0x8A29) +UNIFORM_BUFFER_SIZE :: Enum(0x8A2A) +MAX_VERTEX_UNIFORM_BLOCKS :: Enum(0x8A2B) +MAX_FRAGMENT_UNIFORM_BLOCKS :: Enum(0x8A2D) +MAX_COMBINED_UNIFORM_BLOCKS :: Enum(0x8A2E) +MAX_UNIFORM_BUFFER_BINDINGS :: Enum(0x8A2F) +MAX_UNIFORM_BLOCK_SIZE :: Enum(0x8A30) +MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS :: Enum(0x8A31) +MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS :: Enum(0x8A33) +UNIFORM_BUFFER_OFFSET_ALIGNMENT :: Enum(0x8A34) +ACTIVE_UNIFORM_BLOCKS :: Enum(0x8A36) +UNIFORM_TYPE :: Enum(0x8A37) +UNIFORM_SIZE :: Enum(0x8A38) +UNIFORM_BLOCK_INDEX :: Enum(0x8A3A) +UNIFORM_OFFSET :: Enum(0x8A3B) +UNIFORM_ARRAY_STRIDE :: Enum(0x8A3C) +UNIFORM_MATRIX_STRIDE :: Enum(0x8A3D) +UNIFORM_IS_ROW_MAJOR :: Enum(0x8A3E) +UNIFORM_BLOCK_BINDING :: Enum(0x8A3F) +UNIFORM_BLOCK_DATA_SIZE :: Enum(0x8A40) +UNIFORM_BLOCK_ACTIVE_UNIFORMS :: Enum(0x8A42) +UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES :: Enum(0x8A43) +UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER :: Enum(0x8A44) +UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER :: Enum(0x8A46) +INVALID_INDEX :: Enum(0xFFFFFFFF) +MAX_VERTEX_OUTPUT_COMPONENTS :: Enum(0x9122) +MAX_FRAGMENT_INPUT_COMPONENTS :: Enum(0x9125) +MAX_SERVER_WAIT_TIMEOUT :: Enum(0x9111) +OBJECT_TYPE :: Enum(0x9112) +SYNC_CONDITION :: Enum(0x9113) +SYNC_STATUS :: Enum(0x9114) +SYNC_FLAGS :: Enum(0x9115) +SYNC_FENCE :: Enum(0x9116) +SYNC_GPU_COMMANDS_COMPLETE :: Enum(0x9117) +UNSIGNALED :: Enum(0x9118) +SIGNALED :: Enum(0x9119) +ALREADY_SIGNALED :: Enum(0x911A) +TIMEOUT_EXPIRED :: Enum(0x911B) +CONDITION_SATISFIED :: Enum(0x911C) +WAIT_FAILED :: Enum(0x911D) +SYNC_FLUSH_COMMANDS_BIT :: Enum(0x00000001) +VERTEX_ATTRIB_ARRAY_DIVISOR :: Enum(0x88FE) +ANY_SAMPLES_PASSED :: Enum(0x8C2F) +ANY_SAMPLES_PASSED_CONSERVATIVE :: Enum(0x8D6A) +SAMPLER_BINDING :: Enum(0x8919) +RGB10_A2UI :: Enum(0x906F) +INT_2_10_10_10_REV :: Enum(0x8D9F) +TRANSFORM_FEEDBACK :: Enum(0x8E22) +TRANSFORM_FEEDBACK_PAUSED :: Enum(0x8E23) +TRANSFORM_FEEDBACK_ACTIVE :: Enum(0x8E24) +TRANSFORM_FEEDBACK_BINDING :: Enum(0x8E25) +TEXTURE_IMMUTABLE_FORMAT :: Enum(0x912F) +MAX_ELEMENT_INDEX :: Enum(0x8D6B) +TEXTURE_IMMUTABLE_LEVELS :: Enum(0x82DF) + +TIMEOUT_IGNORED :: i64(-1) + +/* WebGL-specific enums */ +MAX_CLIENT_WAIT_TIMEOUT_WEBGL :: Enum(0x9247) diff --git a/vendor/wasm/WebGL/webgl_constants.odin b/vendor/wasm/WebGL/webgl_constants.odin new file mode 100644 index 000000000..10d04fa61 --- /dev/null +++ b/vendor/wasm/WebGL/webgl_constants.odin @@ -0,0 +1,420 @@ +package webgl + +/* ClearBufferMask */ +DEPTH_BUFFER_BIT :: Enum(0x00000100) +STENCIL_BUFFER_BIT :: Enum(0x00000400) +COLOR_BUFFER_BIT :: Enum(0x00004000) + +/* BeginMode */ +POINTS :: Enum(0x0000) +LINES :: Enum(0x0001) +LINE_LOOP :: Enum(0x0002) +LINE_STRIP :: Enum(0x0003) +TRIANGLES :: Enum(0x0004) +TRIANGLE_STRIP :: Enum(0x0005) +TRIANGLE_FAN :: Enum(0x0006) + +/* AlphaFunction (not supported in ES20) */ +/* NEVER */ +/* LESS */ +/* EQUAL */ +/* LEQUAL */ +/* GREATER */ +/* NOTEQUAL */ +/* GEQUAL */ +/* ALWAYS */ + +/* BlendingFactorDest */ +ZERO :: Enum(0) +ONE :: Enum(1) +SRC_COLOR :: Enum(0x0300) +ONE_MINUS_SRC_COLOR :: Enum(0x0301) +SRC_ALPHA :: Enum(0x0302) +ONE_MINUS_SRC_ALPHA :: Enum(0x0303) +DST_ALPHA :: Enum(0x0304) +ONE_MINUS_DST_ALPHA :: Enum(0x0305) + +/* BlendingFactorSrc */ +/* ZERO */ +/* ONE */ +DST_COLOR :: Enum(0x0306) +ONE_MINUS_DST_COLOR :: Enum(0x0307) +SRC_ALPHA_SATURATE :: Enum(0x0308) +/* SRC_ALPHA */ +/* ONE_MINUS_SRC_ALPHA */ +/* DST_ALPHA */ +/* ONE_MINUS_DST_ALPHA */ + +/* BlendEquationSeparate */ +FUNC_ADD :: Enum(0x8006) +BLEND_EQUATION :: Enum(0x8009) +BLEND_EQUATION_RGB :: Enum(0x8009 /* same as BLEND_EQUATION */) +BLEND_EQUATION_ALPHA :: Enum(0x883D) + +/* BlendSubtract */ +FUNC_SUBTRACT :: Enum(0x800A) +FUNC_REVERSE_SUBTRACT :: Enum(0x800B) + +/* Separate Blend Functions */ +BLEND_DST_RGB :: Enum(0x80C8) +BLEND_SRC_RGB :: Enum(0x80C9) +BLEND_DST_ALPHA :: Enum(0x80CA) +BLEND_SRC_ALPHA :: Enum(0x80CB) +CONSTANT_COLOR :: Enum(0x8001) +ONE_MINUS_CONSTANT_COLOR :: Enum(0x8002) +CONSTANT_ALPHA :: Enum(0x8003) +ONE_MINUS_CONSTANT_ALPHA :: Enum(0x8004) +BLEND_COLOR :: Enum(0x8005) + +/* Buffer Objects */ +ARRAY_BUFFER :: Enum(0x8892) +ELEMENT_ARRAY_BUFFER :: Enum(0x8893) +ARRAY_BUFFER_BINDING :: Enum(0x8894) +ELEMENT_ARRAY_BUFFER_BINDING :: Enum(0x8895) + +STREAM_DRAW :: Enum(0x88E0) +STATIC_DRAW :: Enum(0x88E4) +DYNAMIC_DRAW :: Enum(0x88E8) + +BUFFER_SIZE :: Enum(0x8764) +BUFFER_USAGE :: Enum(0x8765) + +CURRENT_VERTEX_ATTRIB :: Enum(0x8626) + +/* CullFaceMode */ +FRONT :: Enum(0x0404) +BACK :: Enum(0x0405) +FRONT_AND_BACK :: Enum(0x0408) + +/* DepthFunction */ +/* NEVER */ +/* LESS */ +/* EQUAL */ +/* LEQUAL */ +/* GREATER */ +/* NOTEQUAL */ +/* GEQUAL */ +/* ALWAYS */ + +/* EnableCap */ +/* TEXTURE_2D */ +CULL_FACE :: Enum(0x0B44) +BLEND :: Enum(0x0BE2) +DITHER :: Enum(0x0BD0) +STENCIL_TEST :: Enum(0x0B90) +DEPTH_TEST :: Enum(0x0B71) +SCISSOR_TEST :: Enum(0x0C11) +POLYGON_OFFSET_FILL :: Enum(0x8037) +SAMPLE_ALPHA_TO_COVERAGE :: Enum(0x809E) +SAMPLE_COVERAGE :: Enum(0x80A0) + +/* ErrorCode */ +NO_ERROR :: Enum(0) +INVALID_ENUM :: Enum(0x0500) +INVALID_VALUE :: Enum(0x0501) +INVALID_OPERATION :: Enum(0x0502) +OUT_OF_MEMORY :: Enum(0x0505) + +/* FrontFaceDirection */ +CW :: Enum(0x0900) +CCW :: Enum(0x0901) + +/* GetPName */ +LINE_WIDTH :: Enum(0x0B21) +ALIASED_POINT_SIZE_RANGE :: Enum(0x846D) +ALIASED_LINE_WIDTH_RANGE :: Enum(0x846E) +CULL_FACE_MODE :: Enum(0x0B45) +FRONT_FACE :: Enum(0x0B46) +DEPTH_RANGE :: Enum(0x0B70) +DEPTH_WRITEMASK :: Enum(0x0B72) +DEPTH_CLEAR_VALUE :: Enum(0x0B73) +DEPTH_FUNC :: Enum(0x0B74) +STENCIL_CLEAR_VALUE :: Enum(0x0B91) +STENCIL_FUNC :: Enum(0x0B92) +STENCIL_FAIL :: Enum(0x0B94) +STENCIL_PASS_DEPTH_FAIL :: Enum(0x0B95) +STENCIL_PASS_DEPTH_PASS :: Enum(0x0B96) +STENCIL_REF :: Enum(0x0B97) +STENCIL_VALUE_MASK :: Enum(0x0B93) +STENCIL_WRITEMASK :: Enum(0x0B98) +STENCIL_BACK_FUNC :: Enum(0x8800) +STENCIL_BACK_FAIL :: Enum(0x8801) +STENCIL_BACK_PASS_DEPTH_FAIL :: Enum(0x8802) +STENCIL_BACK_PASS_DEPTH_PASS :: Enum(0x8803) +STENCIL_BACK_REF :: Enum(0x8CA3) +STENCIL_BACK_VALUE_MASK :: Enum(0x8CA4) +STENCIL_BACK_WRITEMASK :: Enum(0x8CA5) +VIEWPORT :: Enum(0x0BA2) +SCISSOR_BOX :: Enum(0x0C10) +/* SCISSOR_TEST */ +COLOR_CLEAR_VALUE :: Enum(0x0C22) +COLOR_WRITEMASK :: Enum(0x0C23) +UNPACK_ALIGNMENT :: Enum(0x0CF5) +PACK_ALIGNMENT :: Enum(0x0D05) +MAX_TEXTURE_SIZE :: Enum(0x0D33) +MAX_VIEWPORT_DIMS :: Enum(0x0D3A) +SUBPIXEL_BITS :: Enum(0x0D50) +RED_BITS :: Enum(0x0D52) +GREEN_BITS :: Enum(0x0D53) +BLUE_BITS :: Enum(0x0D54) +ALPHA_BITS :: Enum(0x0D55) +DEPTH_BITS :: Enum(0x0D56) +STENCIL_BITS :: Enum(0x0D57) +POLYGON_OFFSET_UNITS :: Enum(0x2A00) +/* POLYGON_OFFSET_FILL */ +POLYGON_OFFSET_FACTOR :: Enum(0x8038) +TEXTURE_BINDING_2D :: Enum(0x8069) +SAMPLE_BUFFERS :: Enum(0x80A8) +SAMPLES :: Enum(0x80A9) +SAMPLE_COVERAGE_VALUE :: Enum(0x80AA) +SAMPLE_COVERAGE_INVERT :: Enum(0x80AB) + +/* GetTextureParameter */ +/* TEXTURE_MAG_FILTER */ +/* TEXTURE_MIN_FILTER */ +/* TEXTURE_WRAP_S */ +/* TEXTURE_WRAP_T */ + +COMPRESSED_TEXTURE_FORMATS :: Enum(0x86A3) + +/* HintMode */ +DONT_CARE :: Enum(0x1100) +FASTEST :: Enum(0x1101) +NICEST :: Enum(0x1102) + +/* HintTarget */ +GENERATE_MIPMAP_HINT :: Enum(0x8192) + +/* DataType */ +BYTE :: Enum(0x1400) +UNSIGNED_BYTE :: Enum(0x1401) +SHORT :: Enum(0x1402) +UNSIGNED_SHORT :: Enum(0x1403) +INT :: Enum(0x1404) +UNSIGNED_INT :: Enum(0x1405) +FLOAT :: Enum(0x1406) + +/* PixelFormat */ +DEPTH_COMPONENT :: Enum(0x1902) +ALPHA :: Enum(0x1906) +RGB :: Enum(0x1907) +RGBA :: Enum(0x1908) +LUMINANCE :: Enum(0x1909) +LUMINANCE_ALPHA :: Enum(0x190A) + +/* PixelType */ +/* UNSIGNED_BYTE */ +UNSIGNED_SHORT_4_4_4_4 :: Enum(0x8033) +UNSIGNED_SHORT_5_5_5_1 :: Enum(0x8034) +UNSIGNED_SHORT_5_6_5 :: Enum(0x8363) + +/* Shaders */ +FRAGMENT_SHADER :: Enum(0x8B30) +VERTEX_SHADER :: Enum(0x8B31) +MAX_VERTEX_ATTRIBS :: Enum(0x8869) +MAX_VERTEX_UNIFORM_VECTORS :: Enum(0x8DFB) +MAX_VARYING_VECTORS :: Enum(0x8DFC) +MAX_COMBINED_TEXTURE_IMAGE_UNITS :: Enum(0x8B4D) +MAX_VERTEX_TEXTURE_IMAGE_UNITS :: Enum(0x8B4C) +MAX_TEXTURE_IMAGE_UNITS :: Enum(0x8872) +MAX_FRAGMENT_UNIFORM_VECTORS :: Enum(0x8DFD) +SHADER_TYPE :: Enum(0x8B4F) +DELETE_STATUS :: Enum(0x8B80) +LINK_STATUS :: Enum(0x8B82) +VALIDATE_STATUS :: Enum(0x8B83) +ATTACHED_SHADERS :: Enum(0x8B85) +ACTIVE_UNIFORMS :: Enum(0x8B86) +ACTIVE_ATTRIBUTES :: Enum(0x8B89) +SHADING_LANGUAGE_VERSION :: Enum(0x8B8C) +CURRENT_PROGRAM :: Enum(0x8B8D) + +/* StencilFunction */ +NEVER :: Enum(0x0200) +LESS :: Enum(0x0201) +EQUAL :: Enum(0x0202) +LEQUAL :: Enum(0x0203) +GREATER :: Enum(0x0204) +NOTEQUAL :: Enum(0x0205) +GEQUAL :: Enum(0x0206) +ALWAYS :: Enum(0x0207) + +/* StencilOp */ +/* ZERO */ +KEEP :: Enum(0x1E00) +REPLACE :: Enum(0x1E01) +INCR :: Enum(0x1E02) +DECR :: Enum(0x1E03) +INVERT :: Enum(0x150A) +INCR_WRAP :: Enum(0x8507) +DECR_WRAP :: Enum(0x8508) + +/* StringName */ +VENDOR :: Enum(0x1F00) +RENDERER :: Enum(0x1F01) +VERSION :: Enum(0x1F02) + +/* TextureMagFilter */ +NEAREST :: Enum(0x2600) +LINEAR :: Enum(0x2601) + +/* TextureMinFilter */ +/* NEAREST */ +/* LINEAR */ +NEAREST_MIPMAP_NEAREST :: Enum(0x2700) +LINEAR_MIPMAP_NEAREST :: Enum(0x2701) +NEAREST_MIPMAP_LINEAR :: Enum(0x2702) +LINEAR_MIPMAP_LINEAR :: Enum(0x2703) + +/* TextureParameterName */ +TEXTURE_MAG_FILTER :: Enum(0x2800) +TEXTURE_MIN_FILTER :: Enum(0x2801) +TEXTURE_WRAP_S :: Enum(0x2802) +TEXTURE_WRAP_T :: Enum(0x2803) + +/* TextureTarget */ +TEXTURE_2D :: Enum(0x0DE1) +TEXTURE :: Enum(0x1702) + +TEXTURE_CUBE_MAP :: Enum(0x8513) +TEXTURE_BINDING_CUBE_MAP :: Enum(0x8514) +TEXTURE_CUBE_MAP_POSITIVE_X :: Enum(0x8515) +TEXTURE_CUBE_MAP_NEGATIVE_X :: Enum(0x8516) +TEXTURE_CUBE_MAP_POSITIVE_Y :: Enum(0x8517) +TEXTURE_CUBE_MAP_NEGATIVE_Y :: Enum(0x8518) +TEXTURE_CUBE_MAP_POSITIVE_Z :: Enum(0x8519) +TEXTURE_CUBE_MAP_NEGATIVE_Z :: Enum(0x851A) +MAX_CUBE_MAP_TEXTURE_SIZE :: Enum(0x851C) + +/* TextureUnit */ +TEXTURE0 :: Enum(0x84C0) +TEXTURE1 :: Enum(0x84C1) +TEXTURE2 :: Enum(0x84C2) +TEXTURE3 :: Enum(0x84C3) +TEXTURE4 :: Enum(0x84C4) +TEXTURE5 :: Enum(0x84C5) +TEXTURE6 :: Enum(0x84C6) +TEXTURE7 :: Enum(0x84C7) +TEXTURE8 :: Enum(0x84C8) +TEXTURE9 :: Enum(0x84C9) +TEXTURE10 :: Enum(0x84CA) +TEXTURE11 :: Enum(0x84CB) +TEXTURE12 :: Enum(0x84CC) +TEXTURE13 :: Enum(0x84CD) +TEXTURE14 :: Enum(0x84CE) +TEXTURE15 :: Enum(0x84CF) +TEXTURE16 :: Enum(0x84D0) +TEXTURE17 :: Enum(0x84D1) +TEXTURE18 :: Enum(0x84D2) +TEXTURE19 :: Enum(0x84D3) +TEXTURE20 :: Enum(0x84D4) +TEXTURE21 :: Enum(0x84D5) +TEXTURE22 :: Enum(0x84D6) +TEXTURE23 :: Enum(0x84D7) +TEXTURE24 :: Enum(0x84D8) +TEXTURE25 :: Enum(0x84D9) +TEXTURE26 :: Enum(0x84DA) +TEXTURE27 :: Enum(0x84DB) +TEXTURE28 :: Enum(0x84DC) +TEXTURE29 :: Enum(0x84DD) +TEXTURE30 :: Enum(0x84DE) +TEXTURE31 :: Enum(0x84DF) +ACTIVE_TEXTURE :: Enum(0x84E0) + +/* TextureWrapMode */ +REPEAT :: Enum(0x2901) +CLAMP_TO_EDGE :: Enum(0x812F) +MIRRORED_REPEAT :: Enum(0x8370) + +/* Uniform Types */ +FLOAT_VEC2 :: Enum(0x8B50) +FLOAT_VEC3 :: Enum(0x8B51) +FLOAT_VEC4 :: Enum(0x8B52) +INT_VEC2 :: Enum(0x8B53) +INT_VEC3 :: Enum(0x8B54) +INT_VEC4 :: Enum(0x8B55) +BOOL :: Enum(0x8B56) +BOOL_VEC2 :: Enum(0x8B57) +BOOL_VEC3 :: Enum(0x8B58) +BOOL_VEC4 :: Enum(0x8B59) +FLOAT_MAT2 :: Enum(0x8B5A) +FLOAT_MAT3 :: Enum(0x8B5B) +FLOAT_MAT4 :: Enum(0x8B5C) +SAMPLER_2D :: Enum(0x8B5E) +SAMPLER_CUBE :: Enum(0x8B60) + +/* Vertex Arrays */ +VERTEX_ATTRIB_ARRAY_ENABLED :: Enum(0x8622) +VERTEX_ATTRIB_ARRAY_SIZE :: Enum(0x8623) +VERTEX_ATTRIB_ARRAY_STRIDE :: Enum(0x8624) +VERTEX_ATTRIB_ARRAY_TYPE :: Enum(0x8625) +VERTEX_ATTRIB_ARRAY_NORMALIZED :: Enum(0x886A) +VERTEX_ATTRIB_ARRAY_POINTER :: Enum(0x8645) +VERTEX_ATTRIB_ARRAY_BUFFER_BINDING :: Enum(0x889F) + +/* Read Format */ +IMPLEMENTATION_COLOR_READ_TYPE :: Enum(0x8B9A) +IMPLEMENTATION_COLOR_READ_FORMAT :: Enum(0x8B9B) + +/* Shader Source */ +COMPILE_STATUS :: Enum(0x8B81) + +/* Shader Precision-Specified Types */ +LOW_FLOAT :: Enum(0x8DF0) +MEDIUM_FLOAT :: Enum(0x8DF1) +HIGH_FLOAT :: Enum(0x8DF2) +LOW_INT :: Enum(0x8DF3) +MEDIUM_INT :: Enum(0x8DF4) +HIGH_INT :: Enum(0x8DF5) + +/* Framebuffer Object. */ +FRAMEBUFFER :: Enum(0x8D40) +RENDERBUFFER :: Enum(0x8D41) + +RGBA4 :: Enum(0x8056) +RGB5_A1 :: Enum(0x8057) +RGB565 :: Enum(0x8D62) +DEPTH_COMPONENT16 :: Enum(0x81A5) +STENCIL_INDEX :: Enum(0x1901) +STENCIL_INDEX8 :: Enum(0x8D48) +DEPTH_STENCIL :: Enum(0x84F9) + +RENDERBUFFER_WIDTH :: Enum(0x8D42) +RENDERBUFFER_HEIGHT :: Enum(0x8D43) +RENDERBUFFER_INTERNAL_FORMAT :: Enum(0x8D44) +RENDERBUFFER_RED_SIZE :: Enum(0x8D50) +RENDERBUFFER_GREEN_SIZE :: Enum(0x8D51) +RENDERBUFFER_BLUE_SIZE :: Enum(0x8D52) +RENDERBUFFER_ALPHA_SIZE :: Enum(0x8D53) +RENDERBUFFER_DEPTH_SIZE :: Enum(0x8D54) +RENDERBUFFER_STENCIL_SIZE :: Enum(0x8D55) + +FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE :: Enum(0x8CD0) +FRAMEBUFFER_ATTACHMENT_OBJECT_NAME :: Enum(0x8CD1) +FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL :: Enum(0x8CD2) +FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE :: Enum(0x8CD3) + +COLOR_ATTACHMENT0 :: Enum(0x8CE0) +DEPTH_ATTACHMENT :: Enum(0x8D00) +STENCIL_ATTACHMENT :: Enum(0x8D20) +DEPTH_STENCIL_ATTACHMENT :: Enum(0x821A) + +NONE :: Enum(0) + +FRAMEBUFFER_COMPLETE :: Enum(0x8CD5) +FRAMEBUFFER_INCOMPLETE_ATTACHMENT :: Enum(0x8CD6) +FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT :: Enum(0x8CD7) +FRAMEBUFFER_INCOMPLETE_DIMENSIONS :: Enum(0x8CD9) +FRAMEBUFFER_UNSUPPORTED :: Enum(0x8CDD) + +FRAMEBUFFER_BINDING :: Enum(0x8CA6) +RENDERBUFFER_BINDING :: Enum(0x8CA7) +MAX_RENDERBUFFER_SIZE :: Enum(0x84E8) + +INVALID_FRAMEBUFFER_OPERATION :: Enum(0x0506) + +/* WebGL-specific enums */ +UNPACK_FLIP_Y_WEBGL :: Enum(0x9240) +UNPACK_PREMULTIPLY_ALPHA_WEBGL :: Enum(0x9241) +CONTEXT_LOST_WEBGL :: Enum(0x9242) +UNPACK_COLORSPACE_CONVERSION_WEBGL :: Enum(0x9243) +BROWSER_DEFAULT_WEBGL :: Enum(0x9244) diff --git a/vendor/wasm/js/runtime.js b/vendor/wasm/js/runtime.js new file mode 100644 index 000000000..42ee257eb --- /dev/null +++ b/vendor/wasm/js/runtime.js @@ -0,0 +1,154 @@ +class WasmMemoryInterface { + constructor() { + this.memory = null; + } + + setMemory(memory) { + this.memory = memory; + } + + get mem() { + return new DataView(this.memory.buffer); + } + + + loadF32Array(addr, len) { + let array = new Float32Array(this.memory.buffer, addr, len); + return array; + } + loadU32Array(addr, len) { + let array = new Uint32Array(this.memory.buffer, addr, len); + return array; + } + loadI32Array(addr, len) { + let array = new Int32Array(this.memory.buffer, addr, len); + return array; + } + + + loadU8(addr) { return this.mem.getUint8 (addr, true); } + loadI8(addr) { return this.mem.getInt8 (addr, true); } + loadU16(addr) { return this.mem.getUint16 (addr, true); } + loadI16(addr) { return this.mem.getInt16 (addr, true); } + loadU32(addr) { return this.mem.getUint32 (addr, true); } + loadI32(addr) { return this.mem.getInt32 (addr, true); } + loadU64(addr) { + const lo = this.mem.getUint32(addr + 0, true); + const hi = this.mem.getUint32(addr + 4, true); + return lo + hi*4294967296; + }; + loadI64(addr) { + // TODO(bill): loadI64 correctly + const lo = this.mem.getUint32(addr + 0, true); + const hi = this.mem.getUint32(addr + 4, true); + return lo + hi*4294967296; + }; + loadF32(addr) { return this.mem.getFloat32(addr, true); } + loadF64(addr) { return this.mem.getFloat64(addr, true); } + loadInt(addr) { return this.mem.getInt32 (addr, true); } + loadUint(addr) { return this.mem.getUint32 (addr, true); } + + loadPtr(addr) { return this.loadUint(addr); } + + loadBytes(ptr, len) { + return new Uint8Array(this.memory.buffer, ptr, len); + } + + loadString(ptr, len) { + const bytes = this.loadBytes(ptr, len); + return new TextDecoder("utf-8").decode(bytes); + } + + storeU8(addr, value) { this.mem.setUint8 (addr, value, true); } + storeI8(addr, value) { this.mem.setInt8 (addr, value, true); } + storeU16(addr, value) { this.mem.setUint16 (addr, value, true); } + storeI16(addr, value) { this.mem.setInt16 (addr, value, true); } + storeU32(addr, value) { this.mem.setUint32 (addr, value, true); } + storeI32(addr, value) { this.mem.setInt32 (addr, value, true); } + storeU64(addr, value) { + this.mem.setUint32(addr + 0, value, true); + this.mem.setUint32(addr + 4, Math.floor(value / 4294967296), true); + } + storeI64(addr, value) { + // TODO(bill): storeI64 correctly + this.mem.setUint32(addr + 0, value, true); + this.mem.setUint32(addr + 4, Math.floor(value / 4294967296), true); + } + storeF32(addr, value) { this.mem.setFloat32(addr, value, true); } + storeF64(addr, value) { this.mem.setFloat64(addr, value, true); } + storeInt(addr, value) { this.mem.setInt32 (addr, value, true); } + storeUint(addr, value) { this.mem.setUint32 (addr, value, true); } +}; + +function odinSetupDefaultImports(wasmMemoryInterface, consoleElement) { + const MAX_INFO_CONSOLE_LINES = 512; + let infoConsoleLines = new Array(); + const addConsoleLine = (line) => { + if (line === undefined) { + return; + } + if (line.endsWith("\n")) { + line = line.substring(0, line.length-1); + } else if (infoConsoleLines.length > 0) { + let prev_line = infoConsoleLines.pop(); + line = prev_line.concat(line); + } + infoConsoleLines.push(line); + + if (infoConsoleLines.length > MAX_INFO_CONSOLE_LINES) { + infoConsoleLines.shift(); + } + + let data = ""; + for (let i = 0; i < infoConsoleLines.length; i++) { + if (i != 0) { + data = data.concat("\n"); + } + data = data.concat(infoConsoleLines[i]); + } + + if (consoleElement !== undefined) { + let info = consoleElement; + info.innerHTML = data; + info.scrollTop = info.scrollHeight; + } + }; + + return { + "env": {}, + "odin_env": { + write: (fd, ptr, len) => { + const str = wasmMemoryInterface.loadString(ptr, len); + if (fd == 1) { + addConsoleLine(str); + return; + } else if (fd == 2) { + addConsoleLine(str); + return; + } else { + throw new Error("Invalid fd to 'write'" + stripNewline(str)); + } + }, + trap: () => { throw new Error() }, + alert: (ptr, len) => { alert(wasmMemoryInterface.loadString(ptr, len)) }, + abort: () => { Module.abort() }, + evaluate: (str_ptr, str_len) => { eval.call(null, wasmMemoryInterface.loadString(str_ptr, str_len)); }, + + time_now: () => { + return performance.now() * 1e6; + }, + + sqrt: (x) => Math.sqrt(x), + sin: (x) => Math.sin(x), + cos: (x) => Math.cos(x), + pow: (x) => Math.pow(x), + fmuladd: (x, y, z) => x*y + z, + ln: (x) => Math.log(x), + exp: (x) => Math.exp(x), + ldexp: (x) => Math.ldexp(x), + }, + }; +} + + +export {WasmMemoryInterface, odinSetupDefaultImports}; \ No newline at end of file