From: Brendan Hansen Date: Mon, 31 Aug 2020 22:42:18 +0000 (-0500) Subject: refactoring core libraries X-Git-Url: https://git.brendanfh.com/?a=commitdiff_plain;h=6168403e0ded41d19147ef3d256c51ec08f9ff7f;p=onyx.git refactoring core libraries --- diff --git a/Makefile b/Makefile index 0dbd8ab9..4778e4be 100644 --- a/Makefile +++ b/Makefile @@ -21,7 +21,7 @@ LIBS= TARGET=./onyx # These aren't working yet -INSTALL_FOLDER=/usr/share/onyx/core +INSTALL_FOLDER=/usr/share/onyx DEFINES=-DCORE_INSTALLATION=$(INSTALL_FOLDER) ifeq ($(RELEASE), 1) @@ -38,7 +38,7 @@ $(TARGET): $(OBJ_FILES) install: $(TARGET) core/* cp $(TARGET) /usr/bin/ - cp -r core/* $(INSTALL_FOLDER) + cp -r core/ $(INSTALL_FOLDER)/ install_syntax: misc/onyx.vim misc/onyx.sublime-syntax cp ./misc/onyx_compiler.vim /usr/share/vim/vim82/compiler/onyx.vim diff --git a/core/alloc.onyx b/core/alloc.onyx index 2d82bae8..72cfa6cf 100644 --- a/core/alloc.onyx +++ b/core/alloc.onyx @@ -1,10 +1,7 @@ -package memory +package core -#include_file "memory" -#include_file "intrinsics" - -use package builtin -use package intrinsics { memory_size, memory_grow } +#include_file "core/memory" +#include_file "core/intrinsics" heap_allocator : Allocator; diff --git a/core/core.onyx b/core/core.onyx deleted file mode 100644 index 45346071..00000000 --- a/core/core.onyx +++ /dev/null @@ -1,8 +0,0 @@ -package core - -#include_file "alloc" -#include_file "intrinsics" -#include_file "memory" -#include_file "printing" -#include_file "random" -#include_file "string" diff --git a/core/file.onyx b/core/file.onyx index b36ea634..70ac2683 100644 --- a/core/file.onyx +++ b/core/file.onyx @@ -1,9 +1,10 @@ -package file +package core_file // Many of these functions will be improved when // multiple return values are implemented. use package builtin +use package core use package wasi OpenMode :: enum { diff --git a/core/intrinsics.onyx b/core/intrinsics.onyx index 3d727272..38aa0f00 100644 --- a/core/intrinsics.onyx +++ b/core/intrinsics.onyx @@ -1,4 +1,4 @@ -package intrinsics +package core memory_size :: proc -> i32 #intrinsic --- memory_grow :: proc (val: i32) -> i32 #intrinsic --- diff --git a/core/js/webgl.js b/core/js/webgl.js new file mode 100644 index 00000000..16b971e2 --- /dev/null +++ b/core/js/webgl.js @@ -0,0 +1,266 @@ +WebGl_Wasm = { + init(name, namelen) { + const decoder = new TextDecoder(); + const str = new Uint8Array(WASM_MEMORY.buffer, name, namelen); + const canvasname = decoder.decode(str); + + this.programs = []; + this.shaders = []; + this.buffers = []; + this.framebuffers = []; + this.renderbuffers = []; + this.textures = []; + this.uniformlocs = []; + + this.canvas = document.getElementById(canvasname); + if (this.canvas == null) return 0; + + this.gl = this.canvas.getContext("webgl2"); + if (this.gl == null) return 0; + + return 1; + }, + + activeTexture(texture) { this.gl.activeTexture(texture); }, + attachShader(program, shader) { this.gl.attachShader(this.programs[program], this.shaders[shader]); return this.programs[program]; }, + bindAttribLocation(program, index, name, namelen) { console.log("NOT IMPLEMENTED!"); }, + bindBuffer(target, buffer) { + if (buffer == -1) { + this.gl.bindBuffer(target, null); + } else { + this.gl.bindBuffer(target, this.buffers[buffer]); + } + }, + bindFramebuffer(target, framebuffer) { this.gl.bindFramebuffer(target, this.framebuffers[framebuffer]); }, + bindRenderbuffer(target, renderbuffer) { this.gl.bindRenderbuffer(target, this.renderbuffers[renderbuffer]); }, + bindTexture(target, texture) { this.gl.bindTexture(target, this.textures[texture]); }, + blendColor(red, green, blue, alpha) { this.gl.blendColor(red, green, blue, alpha); }, + blendEquation(mode) { this.gl.blendEquation(mode); }, + blendEquationSeparate(modeRGB, modeAlpha) { this.gl.blendEquationSeparate(modeRGB, modeAlpha); }, + blendFunc(sfactor, dfactor) { this.gl.blendFunc(sfactor, dfactor); }, + blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha) { this.gl.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); }, + + blitFramebuffer(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1, mask, filter) { + this.gl.blitFramebuffer(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1, mask, filter); + }, + + bufferDataWithData(target, bufferdata, bufferlen, usage) { + const data = new DataView(WASM_MEMORY.buffer, bufferdata, bufferlen); + this.gl.bufferData(target, data, usage); + }, + + bufferDataNoData(target, size, usage) { this.gl.bufferData(target, size, usage); }, + bufferSubData(target, offset, bufferdata, bufferlen) { + const data = new DataView(WASM_MEMORY.buffer, bufferdata, bufferlen); + this.gl.bufferSubData(target, offset, data); + }, + checkFrameBufferStatus(target) { return this.gl.checkFrameBufferStatus(target); }, + clear(bit) { this.gl.clear(bit); }, + clearColor(r, g, b, a) { this.gl.clearColor(r, g, b, a); }, + clearDepth(depth) { this.gl.clearDepth(depth); }, + clearStencil(stencil) { this.gl.clearStencil(stencil); }, + colorMask(r, g, b, a) { this.gl.colorMask(r, g, b, a); }, + compileShader(shader) { this.gl.compileShader(this.shaders[shader]); }, + compressedTexImage2D(target, level, internalformat, width, height, border, data, datalen) { + const pixels = new DataView(WASM_MEMORY.buffer, data, datalen); + this.gl.compressedTexImage2D(target, level, internalformat, width, height, border, pixels); + }, + compressedTexSubImage2D(target, level, internalformat, xoff, yoff, width, height, format, data, datalen) { + const pixels = new DataView(WASM_MEMORY.buffer, data, datalen); + this.gl.compressedSubTexImage2D(target, level, internalformat, xoff, yoff, width, height, format, pixels); + }, + copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size) { this.gl.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); }, + copyTexImage2D(target, level, internalforamt, x, y, width, height, border) { + this.gl.copyTexImage2D(target, level, internalforamt, x, y, width, height, border); + }, + copyTexSubImage2D(target, level, xoff, yoff, x, y, width, height) { + this.gl.copyTexSubImage2D(target, level, xoff, yoff, x, y, width, height); + }, + createBuffer() { + const buf = this.gl.createBuffer(); + if (buf == null) return -1; + + this.buffers.push(buf); + return this.buffers.length - 1; + }, + createFramebuffer() { + const buf = this.gl.createFramebuffer(); + if (buf == null) return -1; + + this.framebuffers.push(buf); + return this.framebuffers.length - 1; + }, + createProgram() { + const prog = this.gl.createProgram(); + if (prog == null) return -1; + + this.programs.push(prog); + return this.programs.length - 1; + }, + createRenderbuffer() { + const buf = this.gl.createRenderbuffer(); + if (buf == null) return -1; + + this.renderbuffers.push(buf); + return this.renderbuffers.length - 1; + }, + createShader(type) { + const shader = this.gl.createShader(type); + if (shader == null) return -1; + + this.shaders.push(shader); + return this.shaders.length - 1; + }, + createTexture() { + const texture = this.gl.createTexture(); + if (texture == null) return -1; + + this.textures.push(texture); + return this.textures.length - 1; + }, + cullFace(mode) { this.gl.cullFace(mode); }, + deleteBuffer(buffer) { this.gl.deleteBuffer(this.buffers[buffer]); }, + deleteFramebuffer(framebuffer) { this.gl.deleteFramebuffer(this.framebuffers[framebuffer]); }, + deleteProgram(program) { this.gl.deleteProgram(this.programs[program]); }, + deleteRenderbuffer(renderbuffer) { this.gl.deleteRenderbuffer(this.renderbuffers[renderbuffer]); }, + deleteShader(shader) { this.gl.deleteShader(this.shaders[shader]); }, + deleteTexture(texture) { this.gl.deleteTexture(this.textures[texture]); }, + depthFunc(func) { this.gl.depthFunc(func); }, + depthMask(flag) { this.gl.depthMask(flag); }, + depthRange(znear, zfar) { this.gl.depthRange(znear, zfar); }, + detachShader(program, shader) { this.gl.detachShader(this.programs[program], this.shaders[shader]); }, + disable(cap) { this.gl.disable(cap); }, + disableVertexAttribArray(index) { this.gl.disableVertexAttribArray(index); }, + drawArrays(mode, first, count) { this.gl.drawArrays(mode, first, count); }, + drawElements(mode, count, type, offset) { this.gl.drawElements(mode, count, type, offset); }, + enable(cap) { this.gl.enable(cap); }, + enableVertexAttribArray(index) { this.gl.enableVertexAttribArray(index); }, + finish() { this.gl.finish(); }, + flush() { this.gl.flush(); }, + framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) { + this.gl.framebufferRenderbuffer(target, attachment, renderbuffertarget, this.renderbuffers[renderbuffer]); + }, + framebufferTexture2D(target, attachment, texttarget, texture, level) { + this.gl.framebufferTexture2D(target, attachment, texttarget, this.textures[texture], level); + }, + framebufferTextureLayer(target, attachment, texture, level, layer) { this.gl.framebufferTextureLayer(target, attachment, this.textures[texture], level, layer); }, + frontFace(mode) { this.gl.frontFace(mode); }, + generateMipmap(target) { this.gl.generateMipmap(target); }, + getActiveAttrib(program, index, out) { + const loc = this.gl.getActiveAttrib(this.programs[program], index); + const data = new Int32Array(WASM_MEMORY.buffer, out, 2); + data[0] = loc.size; + data[1] = loc.type; + }, + getActiveUniform(program, index, out) { + const loc = this.gl.getActiveUniform(this.programs[program], index); + const data = new Int32Array(WASM_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(WASM_MEMORY.buffer, name, namelen); + const attribname = decoder.decode(str); + + return this.gl.getAttribLocation(this.programs[program], attribname); + }, + // getBufferParameter() { console.log("NOT IMPLEMENTED!"); }, + getBufferSubData(target, srcbyteoffset, dstbufferdata, dstbufferlen, dstoffset, length) { + const dst = new DataView(WASM_MEMORY.buffer, dstbufferdata, dstbufferlen); + this.gl.getBufferSubData(target, srcbyteoffset, dst, dstoffset, length); + }, + getError() { return this.gl.getError(); }, + getInternalformatParameter(target, internalformat, pname) { return this.gl.getInternalformatParameter(target, internalformat, pname); }, + // many of the 'gets() { console.log("NOT IMPLEMENTED!"); }, + getShaderParameter(shader, param) { return this.gl.getShaderParameter(this.shaders[shader], param); }, + getProgramParameter(program, param) { return this.gl.getProgramParameter(this.programs[program], param); }, + getUniformLocation(program, name, namelen) { + const decoder = new TextDecoder(); + const str = new Int8Array(WASM_MEMORY.buffer, name, namelen); + const uniname = decoder.decode(str); + + this.uniformlocs.push(this.gl.getUniformLocation(this.programs[program], uniname)); + return this.uniformlocs.length - 1; + }, + getVertexAttribOffset(index, pname) { return this.gl.getVertexAttribOffset(index, pname); }, + hint(target, mode) { this.gl.hint(target, mode); }, + isEnabled(cap) { return this.gl.isEnabled(cap); }, + invalidateFramebuffer(target, attachdata, attachlen) { + const attachments = new Int32Array(WASM_MEMORY.buffer, attachdata, attachlen); + this.gl.invalidateFramebuffer(target, attacements); + }, + invalidateSubFramebuffer(target, attachdata, attachlen, x, y, width, height) { + const attachments = new Int32Array(WASM_MEMORY.buffer, attachdata, attachlen); + this.gl.invalidateFramebuffer(target, attacements, x, y, width, height); + }, + lineWidth(width) { this.gl.lineWidth(width); }, + linkProgram(program) { this.gl.linkProgram(this.programs[program]); }, + pixelStorei(pname, param) { this.gl.pixelStorei(pname, param); }, + polygonOffset(factor, units) { this.gl.polygonOffset(factor, units); }, + printProgramInfoLog(program) { console.log(this.gl.getProgramInfoLog(this.programs[program])); }, + printShaderInfoLog(shader) { console.log(this.gl.getShaderInfoLog(this.shaders[shader])); }, + readPixels(x, y, width, height, format, type, pixels, pixelslen) { + const pixeldata = new Uint8Array(WASM_MEMORY.buffer, pixels, pixelslen); + this.gl.readPixels(x, y, width, height, format, type, pixeldata); + }, + readBuffer(src) { this.gl.readBuffer(src); }, + renderbufferStorageMultisample(target, samples, internalforamt, width, height) { + this.gl.renderbufferStorageMultisample(target, samples, internalforamt, width, height); + }, + sampleCoverage(value, invert) { this.gl.sampleCoverage(value, invert); }, + scissor(x, y, width, height) { this.gl.scissor(x, y, width, height); }, + shaderSource(shader, source, sourcelen) { + const decoder = new TextDecoder(); + const str = new Int8Array(WASM_MEMORY.buffer, source, sourcelen); + const sourcedata = decoder.decode(str); + + this.gl.shaderSource(this.shaders[shader], sourcedata); + }, + stencilFunc(func, ref, mask) { this.gl.stencilFunc(func, ref, mask); }, + stencilFuncSeparate(face, func, ref, mask) { this.gl.stencilFuncSeparate(face, func, ref, mask); }, + stencilMask(mask) { this.gl.stencilMask(mask); }, + stencilMaskSeparate(face, mask) { this.gl.stencilMaskSeparate(face, mask); }, + stencilOp(fail, zfail, mask) { this.gl.stencilOp(fail, zfail, mask); }, + stencilOpSeparate(face, fail, zfail, zpass) { this.gl.stencilOpSeparate(face, fail, zfail, zpass); }, + texImage2D(target, level, internalforamt, width, height, border, format, type, pixels, pixelslen) { + const data = new DataView(WASM_MEMORY.buffer, pixels, pixelslen); + this.gl.texImage2D(target, level, internalforamt, width, height, border, format, type, data); + }, + texParameterf(target, pname, param) { this.gl.texParameterf(target, pname, param); }, + texParameteri(target, pname, param) { this.gl.texParameteri(target, pname, param); }, + texSubImage2D(target, level, xoff, yoff, width, height, format, type, pixels, pixelslen) { + const data = new Uint8Array(WASM_MEMORY.buffer, pixels, pixelslen); + this.gl.texSubImage2D(target, level, xoff, yoff, width, height, format, type, data); + }, + uniform1f(loc, x) { this.gl.uniform1f(this.uniformlocs[loc], x); }, + uniform1i(loc, x) { this.gl.uniform1i(this.uniformlocs[loc], x); }, + uniform2f(loc, x, y) { this.gl.uniform2f(this.uniformlocs[loc], x, y); }, + uniform2i(loc, x, y) { this.gl.uniform2i(this.uniformlocs[loc], x, y); }, + uniform3f(loc, x, y, z) { this.gl.uniform3f(this.uniformlocs[loc], x, y, z); }, + uniform3i(loc, x, y, z) { this.gl.uniform3i(this.uniformlocs[loc], x, y, z); }, + uniform4f(loc, x, y, z, w) { this.gl.uniform4f(this.uniformlocs[loc], x, y, z, w); }, + uniform4i(loc, x, y, z, w) { this.gl.uniform4i(this.uniformlocs[loc], x, y, z, w); }, + uniformMatrix2(loc, transpose, valueptr) { + const data = new Float32Array(WASM_MEMORY.buffer, valueptr, 4); + this.gl.uniformMatrix2fv(this.uniformlocs[loc], transpose, data); + }, + uniformMatrix3(loc, transpose, valueptr) { + const data = new Float32Array(WASM_MEMORY.buffer, valueptr, 9); + this.gl.uniformMatrix3fv(this.uniformlocs[loc], transpose, data); + }, + uniformMatrix4(loc, transpose, valueptr) { + const data = new Float32Array(WASM_MEMORY.buffer, valueptr, 16); + this.gl.uniformMatrix4fv(this.uniformlocs[loc], transpose, data); + }, + useProgram(program) { this.gl.useProgram(this.programs[program]); }, + validateProgram(program) { this.gl.validateProgram(this.program[program]); }, + vertexAttrib1f(idx, x) { this.gl.vertexAttrib1f(idx, x); }, + vertexAttrib2f(idx, x, y) { this.gl.vertexAttrib2f(idx, x, y); }, + vertexAttrib3f(idx, x, y, z) { this.gl.vertexAttrib3f(idx, x, y, z); }, + vertexAttrib4f(idx, x, y, z, w) { this.gl.vertexAttrib4f(idx, x, y, z, w); }, + vertexAttribPointer(idx, size, type, normalized, stride, offset) { this.gl.vertexAttribPointer(idx, size, type, normalized, stride, offset); }, + viewport(x, y, width, height) { this.gl.viewport(x, y, width, height); }, + +}; diff --git a/core/js/webgl.onyx b/core/js/webgl.onyx new file mode 100644 index 00000000..738f8b12 --- /dev/null +++ b/core/js/webgl.onyx @@ -0,0 +1,841 @@ +package gl +// To be used with the corresponding gl.js + +use package builtin + +// ClearBufferMask +DEPTH_BUFFER_BIT :: 0x00000100 +STENCIL_BUFFER_BIT :: 0x00000400 +COLOR_BUFFER_BIT :: 0x00004000 + +// BeginMode +POINTS :: 0x0000 +LINES :: 0x0001 +LINE_LOOP :: 0x0002 +LINE_STRIP :: 0x0003 +TRIANGLES :: 0x0004 +TRIANGLE_STRIP :: 0x0005 +TRIANGLE_FAN :: 0x0006 + +// AlphaFunction (not supported in ES20) +// NEVER +// LESS +// EQUAL +// LEQUAL +// GREATER +// NOTEQUAL +// GEQUAL +// ALWAYS + +// BlendingFactorDest +ZERO :: 0 +ONE :: 1 +SRC_COLOR :: 0x0300 +ONE_MINUS_SRC_COLOR :: 0x0301 +SRC_ALPHA :: 0x0302 +ONE_MINUS_SRC_ALPHA :: 0x0303 +DST_ALPHA :: 0x0304 +ONE_MINUS_DST_ALPHA :: 0x0305 + +// BlendingFactorSrc +// ZERO +// ONE +DST_COLOR :: 0x0306 +ONE_MINUS_DST_COLOR :: 0x0307 +SRC_ALPHA_SATURATE :: 0x0308 +// SRC_ALPHA +// ONE_MINUS_SRC_ALPHA +// DST_ALPHA +// ONE_MINUS_DST_ALPHA + +// BlendEquationSeparate +FUNC_ADD :: 0x8006 +BLEND_EQUATION :: 0x8009 +BLEND_EQUATION_RGB :: 0x8009 // same as BLEND_EQUATION +BLEND_EQUATION_ALPHA :: 0x883D + +// BlendSubtract +FUNC_SUBTRACT :: 0x800A +FUNC_REVERSE_SUBTRACT :: 0x800B + +// Separate Blend Functions +BLEND_DST_RGB :: 0x80C8 +BLEND_SRC_RGB :: 0x80C9 +BLEND_DST_ALPHA :: 0x80CA +BLEND_SRC_ALPHA :: 0x80CB +CONSTANT_COLOR :: 0x8001 +ONE_MINUS_CONSTANT_COLOR :: 0x8002 +CONSTANT_ALPHA :: 0x8003 +ONE_MINUS_CONSTANT_ALPHA :: 0x8004 +BLEND_COLOR :: 0x8005 + +// Buffer Objects +ARRAY_BUFFER :: 0x8892 +ELEMENT_ARRAY_BUFFER :: 0x8893 +ARRAY_BUFFER_BINDING :: 0x8894 +ELEMENT_ARRAY_BUFFER_BINDING :: 0x8895 + +STREAM_DRAW :: 0x88E0 +STATIC_DRAW :: 0x88E4 +DYNAMIC_DRAW :: 0x88E8 + +BUFFER_SIZE :: 0x8764 +BUFFER_USAGE :: 0x8765 + +CURRENT_VERTEX_ATTRIB :: 0x8626 + +// CullFaceMode +FRONT :: 0x0404 +BACK :: 0x0405 +FRONT_AND_BACK :: 0x0408 + +// DepthFunction +// NEVER +// LESS +// EQUAL +// LEQUAL +// GREATER +// NOTEQUAL +// GEQUAL +// ALWAYS + +// EnableCap +// TEXTURE_2D +CULL_FACE :: 0x0B44 +BLEND :: 0x0BE2 +DITHER :: 0x0BD0 +STENCIL_TEST :: 0x0B90 +DEPTH_TEST :: 0x0B71 +SCISSOR_TEST :: 0x0C11 +POLYGON_OFFSET_FILL :: 0x8037 +SAMPLE_ALPHA_TO_COVERAGE :: 0x809E +SAMPLE_COVERAGE :: 0x80A0 + +// ErrorCode +NO_ERROR :: 0 +INVALID_ENUM :: 0x0500 +INVALID_VALUE :: 0x0501 +INVALID_OPERATION :: 0x0502 +OUT_OF_MEMORY :: 0x0505 + +// FrontFaceDirection +CW :: 0x0900 +CCW :: 0x0901 + +// GetPName +LINE_WIDTH :: 0x0B21 +ALIASED_POINT_SIZE_RANGE :: 0x846D +ALIASED_LINE_WIDTH_RANGE :: 0x846E +CULL_FACE_MODE :: 0x0B45 +FRONT_FACE :: 0x0B46 +DEPTH_RANGE :: 0x0B70 +DEPTH_WRITEMASK :: 0x0B72 +DEPTH_CLEAR_VALUE :: 0x0B73 +DEPTH_FUNC :: 0x0B74 +STENCIL_CLEAR_VALUE :: 0x0B91 +STENCIL_FUNC :: 0x0B92 +STENCIL_FAIL :: 0x0B94 +STENCIL_PASS_DEPTH_FAIL :: 0x0B95 +STENCIL_PASS_DEPTH_PASS :: 0x0B96 +STENCIL_REF :: 0x0B97 +STENCIL_VALUE_MASK :: 0x0B93 +STENCIL_WRITEMASK :: 0x0B98 +STENCIL_BACK_FUNC :: 0x8800 +STENCIL_BACK_FAIL :: 0x8801 +STENCIL_BACK_PASS_DEPTH_FAIL :: 0x8802 +STENCIL_BACK_PASS_DEPTH_PASS :: 0x8803 +STENCIL_BACK_REF :: 0x8CA3 +STENCIL_BACK_VALUE_MASK :: 0x8CA4 +STENCIL_BACK_WRITEMASK :: 0x8CA5 +VIEWPORT :: 0x0BA2 +SCISSOR_BOX :: 0x0C10 +// SCISSOR_TEST +COLOR_CLEAR_VALUE :: 0x0C22 +COLOR_WRITEMASK :: 0x0C23 +UNPACK_ALIGNMENT :: 0x0CF5 +PACK_ALIGNMENT :: 0x0D05 +MAX_TEXTURE_SIZE :: 0x0D33 +MAX_VIEWPORT_DIMS :: 0x0D3A +SUBPIXEL_BITS :: 0x0D50 +RED_BITS :: 0x0D52 +GREEN_BITS :: 0x0D53 +BLUE_BITS :: 0x0D54 +ALPHA_BITS :: 0x0D55 +DEPTH_BITS :: 0x0D56 +STENCIL_BITS :: 0x0D57 +POLYGON_OFFSET_UNITS :: 0x2A00 +// POLYGON_OFFSET_FILL +POLYGON_OFFSET_FACTOR :: 0x8038 +TEXTURE_BINDING_2D :: 0x8069 +SAMPLE_BUFFERS :: 0x80A8 +SAMPLES :: 0x80A9 +SAMPLE_COVERAGE_VALUE :: 0x80AA +SAMPLE_COVERAGE_INVERT :: 0x80AB + +// GetTextureParameter +// TEXTURE_MAG_FILTER +// TEXTURE_MIN_FILTER +// TEXTURE_WRAP_S +// TEXTURE_WRAP_T + +COMPRESSED_TEXTURE_FORMATS :: 0x86A3 + +// HintMode +DONT_CARE :: 0x1100 +FASTEST :: 0x1101 +NICEST :: 0x1102 + +// HintTarget +GENERATE_MIPMAP_HINT :: 0x8192 + +// DataType +BYTE :: 0x1400 +UNSIGNED_BYTE :: 0x1401 +SHORT :: 0x1402 +UNSIGNED_SHORT :: 0x1403 +INT :: 0x1404 +UNSIGNED_INT :: 0x1405 +FLOAT :: 0x1406 + +// PixelFormat +DEPTH_COMPONENT :: 0x1902 +ALPHA :: 0x1906 +RGB :: 0x1907 +RGBA :: 0x1908 +LUMINANCE :: 0x1909 +LUMINANCE_ALPHA :: 0x190A + +// PixelType +// UNSIGNED_BYTE +UNSIGNED_SHORT_4_4_4_4 :: 0x8033 +UNSIGNED_SHORT_5_5_5_1 :: 0x8034 +UNSIGNED_SHORT_5_6_5 :: 0x8363 + +// Shaders +FRAGMENT_SHADER :: 0x8B30 +VERTEX_SHADER :: 0x8B31 +MAX_VERTEX_ATTRIBS :: 0x8869 +MAX_VERTEX_UNIFORM_VECTORS :: 0x8DFB +MAX_VARYING_VECTORS :: 0x8DFC +MAX_COMBINED_TEXTURE_IMAGE_UNITS :: 0x8B4D +MAX_VERTEX_TEXTURE_IMAGE_UNITS :: 0x8B4C +MAX_TEXTURE_IMAGE_UNITS :: 0x8872 +MAX_FRAGMENT_UNIFORM_VECTORS :: 0x8DFD +SHADER_TYPE :: 0x8B4F +DELETE_STATUS :: 0x8B80 +LINK_STATUS :: 0x8B82 +VALIDATE_STATUS :: 0x8B83 +ATTACHED_SHADERS :: 0x8B85 +ACTIVE_UNIFORMS :: 0x8B86 +ACTIVE_ATTRIBUTES :: 0x8B89 +SHADING_LANGUAGE_VERSION :: 0x8B8C +CURRENT_PROGRAM :: 0x8B8D + +// StencilFunction +NEVER :: 0x0200 +LESS :: 0x0201 +EQUAL :: 0x0202 +LEQUAL :: 0x0203 +GREATER :: 0x0204 +NOTEQUAL :: 0x0205 +GEQUAL :: 0x0206 +ALWAYS :: 0x0207 + +// StencilOp +// ZERO +KEEP :: 0x1E00 +REPLACE :: 0x1E01 +INCR :: 0x1E02 +DECR :: 0x1E03 +INVERT :: 0x150A +INCR_WRAP :: 0x8507 +DECR_WRAP :: 0x8508 + +// StringName +VENDOR :: 0x1F00 +RENDERER :: 0x1F01 +VERSION :: 0x1F02 + +// TextureMagFilter +NEAREST :: 0x2600 +LINEAR :: 0x2601 + +// TextureMinFilter +// NEAREST +// LINEAR +NEAREST_MIPMAP_NEAREST :: 0x2700 +LINEAR_MIPMAP_NEAREST :: 0x2701 +NEAREST_MIPMAP_LINEAR :: 0x2702 +LINEAR_MIPMAP_LINEAR :: 0x2703 + +// TextureParameterName +TEXTURE_MAG_FILTER :: 0x2800 +TEXTURE_MIN_FILTER :: 0x2801 +TEXTURE_WRAP_S :: 0x2802 +TEXTURE_WRAP_T :: 0x2803 + +// TextureTarget +TEXTURE_2D :: 0x0DE1 +TEXTURE :: 0x1702 + +TEXTURE_CUBE_MAP :: 0x8513 +TEXTURE_BINDING_CUBE_MAP :: 0x8514 +TEXTURE_CUBE_MAP_POSITIVE_X :: 0x8515 +TEXTURE_CUBE_MAP_NEGATIVE_X :: 0x8516 +TEXTURE_CUBE_MAP_POSITIVE_Y :: 0x8517 +TEXTURE_CUBE_MAP_NEGATIVE_Y :: 0x8518 +TEXTURE_CUBE_MAP_POSITIVE_Z :: 0x8519 +TEXTURE_CUBE_MAP_NEGATIVE_Z :: 0x851A +MAX_CUBE_MAP_TEXTURE_SIZE :: 0x851C + +// TextureUnit +TEXTURE0 :: 0x84C0 +TEXTURE1 :: 0x84C1 +TEXTURE2 :: 0x84C2 +TEXTURE3 :: 0x84C3 +TEXTURE4 :: 0x84C4 +TEXTURE5 :: 0x84C5 +TEXTURE6 :: 0x84C6 +TEXTURE7 :: 0x84C7 +TEXTURE8 :: 0x84C8 +TEXTURE9 :: 0x84C9 +TEXTURE10 :: 0x84CA +TEXTURE11 :: 0x84CB +TEXTURE12 :: 0x84CC +TEXTURE13 :: 0x84CD +TEXTURE14 :: 0x84CE +TEXTURE15 :: 0x84CF +TEXTURE16 :: 0x84D0 +TEXTURE17 :: 0x84D1 +TEXTURE18 :: 0x84D2 +TEXTURE19 :: 0x84D3 +TEXTURE20 :: 0x84D4 +TEXTURE21 :: 0x84D5 +TEXTURE22 :: 0x84D6 +TEXTURE23 :: 0x84D7 +TEXTURE24 :: 0x84D8 +TEXTURE25 :: 0x84D9 +TEXTURE26 :: 0x84DA +TEXTURE27 :: 0x84DB +TEXTURE28 :: 0x84DC +TEXTURE29 :: 0x84DD +TEXTURE30 :: 0x84DE +TEXTURE31 :: 0x84DF +ACTIVE_TEXTURE :: 0x84E0 + +// TextureWrapMode +REPEAT :: 0x2901 +CLAMP_TO_EDGE :: 0x812F +MIRRORED_REPEAT :: 0x8370 + +// Uniform Types +FLOAT_VEC2 :: 0x8B50 +FLOAT_VEC3 :: 0x8B51 +FLOAT_VEC4 :: 0x8B52 +INT_VEC2 :: 0x8B53 +INT_VEC3 :: 0x8B54 +INT_VEC4 :: 0x8B55 +BOOL :: 0x8B56 +BOOL_VEC2 :: 0x8B57 +BOOL_VEC3 :: 0x8B58 +BOOL_VEC4 :: 0x8B59 +FLOAT_MAT2 :: 0x8B5A +FLOAT_MAT3 :: 0x8B5B +FLOAT_MAT4 :: 0x8B5C +SAMPLER_2D :: 0x8B5E +SAMPLER_CUBE :: 0x8B60 + +// Vertex Arrays +VERTEX_ATTRIB_ARRAY_ENABLED :: 0x8622 +VERTEX_ATTRIB_ARRAY_SIZE :: 0x8623 +VERTEX_ATTRIB_ARRAY_STRIDE :: 0x8624 +VERTEX_ATTRIB_ARRAY_TYPE :: 0x8625 +VERTEX_ATTRIB_ARRAY_NORMALIZED :: 0x886A +VERTEX_ATTRIB_ARRAY_POINTER :: 0x8645 +VERTEX_ATTRIB_ARRAY_BUFFER_BINDING :: 0x889F + +// Read Format +IMPLEMENTATION_COLOR_READ_TYPE :: 0x8B9A +IMPLEMENTATION_COLOR_READ_FORMAT :: 0x8B9B + +// Shader Source +COMPILE_STATUS :: 0x8B81 + +// Shader Precision-Specified Types +LOW_FLOAT :: 0x8DF0 +MEDIUM_FLOAT :: 0x8DF1 +HIGH_FLOAT :: 0x8DF2 +LOW_INT :: 0x8DF3 +MEDIUM_INT :: 0x8DF4 +HIGH_INT :: 0x8DF5 + +// Framebuffer Object. +FRAMEBUFFER :: 0x8D40 +RENDERBUFFER :: 0x8D41 + +RGBA4 :: 0x8056 +RGB5_A1 :: 0x8057 +RGB565 :: 0x8D62 +DEPTH_COMPONENT16 :: 0x81A5 +STENCIL_INDEX :: 0x1901 +STENCIL_INDEX8 :: 0x8D48 +DEPTH_STENCIL :: 0x84F9 + +RENDERBUFFER_WIDTH :: 0x8D42 +RENDERBUFFER_HEIGHT :: 0x8D43 +RENDERBUFFER_INTERNAL_FORMAT :: 0x8D44 +RENDERBUFFER_RED_SIZE :: 0x8D50 +RENDERBUFFER_GREEN_SIZE :: 0x8D51 +RENDERBUFFER_BLUE_SIZE :: 0x8D52 +RENDERBUFFER_ALPHA_SIZE :: 0x8D53 +RENDERBUFFER_DEPTH_SIZE :: 0x8D54 +RENDERBUFFER_STENCIL_SIZE :: 0x8D55 + +FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE :: 0x8CD0 +FRAMEBUFFER_ATTACHMENT_OBJECT_NAME :: 0x8CD1 +FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL :: 0x8CD2 +FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE :: 0x8CD3 + +COLOR_ATTACHMENT0 :: 0x8CE0 +DEPTH_ATTACHMENT :: 0x8D00 +STENCIL_ATTACHMENT :: 0x8D20 +DEPTH_STENCIL_ATTACHMENT :: 0x821A + +NONE :: 0 + +FRAMEBUFFER_COMPLETE :: 0x8CD5 +FRAMEBUFFER_INCOMPLETE_ATTACHMENT :: 0x8CD6 +FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT :: 0x8CD7 +FRAMEBUFFER_INCOMPLETE_DIMENSIONS :: 0x8CD9 +FRAMEBUFFER_UNSUPPORTED :: 0x8CDD + +FRAMEBUFFER_BINDING :: 0x8CA6 +RENDERBUFFER_BINDING :: 0x8CA7 +MAX_RENDERBUFFER_SIZE :: 0x84E8 + +INVALID_FRAMEBUFFER_OPERATION :: 0x0506 + +READ_BUFFER :: 0x0C02 +UNPACK_ROW_LENGTH :: 0x0CF2 +UNPACK_SKIP_ROWS :: 0x0CF3 +UNPACK_SKIP_PIXELS :: 0x0CF4 +PACK_ROW_LENGTH :: 0x0D02 +PACK_SKIP_ROWS :: 0x0D03 +PACK_SKIP_PIXELS :: 0x0D04 +COLOR :: 0x1800 +DEPTH :: 0x1801 +STENCIL :: 0x1802 +RED :: 0x1903 +RGB8 :: 0x8051 +RGBA8 :: 0x8058 +RGB10_A2 :: 0x8059 +TEXTURE_BINDING_3D :: 0x806A +UNPACK_SKIP_IMAGES :: 0x806D +UNPACK_IMAGE_HEIGHT :: 0x806E +TEXTURE_3D :: 0x806F +TEXTURE_WRAP_R :: 0x8072 +MAX_3D_TEXTURE_SIZE :: 0x8073 +UNSIGNED_INT_2_10_10_10_REV :: 0x8368 +MAX_ELEMENTS_VERTICES :: 0x80E8 +MAX_ELEMENTS_INDICES :: 0x80E9 +TEXTURE_MIN_LOD :: 0x813A +TEXTURE_MAX_LOD :: 0x813B +TEXTURE_BASE_LEVEL :: 0x813C +TEXTURE_MAX_LEVEL :: 0x813D +MIN :: 0x8007 +MAX :: 0x8008 +DEPTH_COMPONENT24 :: 0x81A6 +MAX_TEXTURE_LOD_BIAS :: 0x84FD +TEXTURE_COMPARE_MODE :: 0x884C +TEXTURE_COMPARE_FUNC :: 0x884D +CURRENT_QUERY :: 0x8865 +QUERY_RESULT :: 0x8866 +QUERY_RESULT_AVAILABLE :: 0x8867 +STREAM_READ :: 0x88E1 +STREAM_COPY :: 0x88E2 +STATIC_READ :: 0x88E5 +STATIC_COPY :: 0x88E6 +DYNAMIC_READ :: 0x88E9 +DYNAMIC_COPY :: 0x88EA +MAX_DRAW_BUFFERS :: 0x8824 +DRAW_BUFFER0 :: 0x8825 +DRAW_BUFFER1 :: 0x8826 +DRAW_BUFFER2 :: 0x8827 +DRAW_BUFFER3 :: 0x8828 +DRAW_BUFFER4 :: 0x8829 +DRAW_BUFFER5 :: 0x882A +DRAW_BUFFER6 :: 0x882B +DRAW_BUFFER7 :: 0x882C +DRAW_BUFFER8 :: 0x882D +DRAW_BUFFER9 :: 0x882E +DRAW_BUFFER10 :: 0x882F +DRAW_BUFFER11 :: 0x8830 +DRAW_BUFFER12 :: 0x8831 +DRAW_BUFFER13 :: 0x8832 +DRAW_BUFFER14 :: 0x8833 +DRAW_BUFFER15 :: 0x8834 +MAX_FRAGMENT_UNIFORM_COMPONENTS :: 0x8B49 +MAX_VERTEX_UNIFORM_COMPONENTS :: 0x8B4A +SAMPLER_3D :: 0x8B5F +SAMPLER_2D_SHADOW :: 0x8B62 +FRAGMENT_SHADER_DERIVATIVE_HINT :: 0x8B8B +PIXEL_PACK_BUFFER :: 0x88EB +PIXEL_UNPACK_BUFFER :: 0x88EC +PIXEL_PACK_BUFFER_BINDING :: 0x88ED +PIXEL_UNPACK_BUFFER_BINDING :: 0x88EF +FLOAT_MAT2x3 :: 0x8B65 +FLOAT_MAT2x4 :: 0x8B66 +FLOAT_MAT3x2 :: 0x8B67 +FLOAT_MAT3x4 :: 0x8B68 +FLOAT_MAT4x2 :: 0x8B69 +FLOAT_MAT4x3 :: 0x8B6A +SRGB :: 0x8C40 +SRGB8 :: 0x8C41 +SRGB8_ALPHA8 :: 0x8C43 +COMPARE_REF_TO_TEXTURE :: 0x884E +RGBA32F :: 0x8814 +RGB32F :: 0x8815 +RGBA16F :: 0x881A +RGB16F :: 0x881B +VERTEX_ATTRIB_ARRAY_INTEGER :: 0x88FD +MAX_ARRAY_TEXTURE_LAYERS :: 0x88FF +MIN_PROGRAM_TEXEL_OFFSET :: 0x8904 +MAX_PROGRAM_TEXEL_OFFSET :: 0x8905 +MAX_VARYING_COMPONENTS :: 0x8B4B +TEXTURE_2D_ARRAY :: 0x8C1A +TEXTURE_BINDING_2D_ARRAY :: 0x8C1D +R11F_G11F_B10F :: 0x8C3A +UNSIGNED_INT_10F_11F_11F_REV :: 0x8C3B +RGB9_E5 :: 0x8C3D +UNSIGNED_INT_5_9_9_9_REV :: 0x8C3E +TRANSFORM_FEEDBACK_BUFFER_MODE :: 0x8C7F +MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS :: 0x8C80 +TRANSFORM_FEEDBACK_VARYINGS :: 0x8C83 +TRANSFORM_FEEDBACK_BUFFER_START :: 0x8C84 +TRANSFORM_FEEDBACK_BUFFER_SIZE :: 0x8C85 +TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN :: 0x8C88 +RASTERIZER_DISCARD :: 0x8C89 +MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS :: 0x8C8A +MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS :: 0x8C8B +INTERLEAVED_ATTRIBS :: 0x8C8C +SEPARATE_ATTRIBS :: 0x8C8D +TRANSFORM_FEEDBACK_BUFFER :: 0x8C8E +TRANSFORM_FEEDBACK_BUFFER_BINDING :: 0x8C8F +RGBA32UI :: 0x8D70 +RGB32UI :: 0x8D71 +RGBA16UI :: 0x8D76 +RGB16UI :: 0x8D77 +RGBA8UI :: 0x8D7C +RGB8UI :: 0x8D7D +RGBA32I :: 0x8D82 +RGB32I :: 0x8D83 +RGBA16I :: 0x8D88 +RGB16I :: 0x8D89 +RGBA8I :: 0x8D8E +RGB8I :: 0x8D8F +RED_INTEGER :: 0x8D94 +RGB_INTEGER :: 0x8D98 +RGBA_INTEGER :: 0x8D99 +SAMPLER_2D_ARRAY :: 0x8DC1 +SAMPLER_2D_ARRAY_SHADOW :: 0x8DC4 +SAMPLER_CUBE_SHADOW :: 0x8DC5 +UNSIGNED_INT_VEC2 :: 0x8DC6 +UNSIGNED_INT_VEC3 :: 0x8DC7 +UNSIGNED_INT_VEC4 :: 0x8DC8 +INT_SAMPLER_2D :: 0x8DCA +INT_SAMPLER_3D :: 0x8DCB +INT_SAMPLER_CUBE :: 0x8DCC +INT_SAMPLER_2D_ARRAY :: 0x8DCF +UNSIGNED_INT_SAMPLER_2D :: 0x8DD2 +UNSIGNED_INT_SAMPLER_3D :: 0x8DD3 +UNSIGNED_INT_SAMPLER_CUBE :: 0x8DD4 +UNSIGNED_INT_SAMPLER_2D_ARRAY :: 0x8DD7 +DEPTH_COMPONENT32F :: 0x8CAC +DEPTH32F_STENCIL8 :: 0x8CAD +FLOAT_32_UNSIGNED_INT_24_8_REV :: 0x8DAD +FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING :: 0x8210 +FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE :: 0x8211 +FRAMEBUFFER_ATTACHMENT_RED_SIZE :: 0x8212 +FRAMEBUFFER_ATTACHMENT_GREEN_SIZE :: 0x8213 +FRAMEBUFFER_ATTACHMENT_BLUE_SIZE :: 0x8214 +FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE :: 0x8215 +FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE :: 0x8216 +FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE :: 0x8217 +FRAMEBUFFER_DEFAULT :: 0x8218 +UNSIGNED_INT_24_8 :: 0x84FA +DEPTH24_STENCIL8 :: 0x88F0 +UNSIGNED_NORMALIZED :: 0x8C17 +DRAW_FRAMEBUFFER_BINDING :: 0x8CA6 +READ_FRAMEBUFFER :: 0x8CA8 +DRAW_FRAMEBUFFER :: 0x8CA9 +READ_FRAMEBUFFER_BINDING :: 0x8CAA +RENDERBUFFER_SAMPLES :: 0x8CAB +FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER :: 0x8CD4 +MAX_COLOR_ATTACHMENTS :: 0x8CDF +COLOR_ATTACHMENT1 :: 0x8CE1 +COLOR_ATTACHMENT2 :: 0x8CE2 +COLOR_ATTACHMENT3 :: 0x8CE3 +COLOR_ATTACHMENT4 :: 0x8CE4 +COLOR_ATTACHMENT5 :: 0x8CE5 +COLOR_ATTACHMENT6 :: 0x8CE6 +COLOR_ATTACHMENT7 :: 0x8CE7 +COLOR_ATTACHMENT8 :: 0x8CE8 +COLOR_ATTACHMENT9 :: 0x8CE9 +COLOR_ATTACHMENT10 :: 0x8CEA +COLOR_ATTACHMENT11 :: 0x8CEB +COLOR_ATTACHMENT12 :: 0x8CEC +COLOR_ATTACHMENT13 :: 0x8CED +COLOR_ATTACHMENT14 :: 0x8CEE +COLOR_ATTACHMENT15 :: 0x8CEF +FRAMEBUFFER_INCOMPLETE_MULTISAMPLE :: 0x8D56 +MAX_SAMPLES :: 0x8D57 +HALF_FLOAT :: 0x140B +RG :: 0x8227 +RG_INTEGER :: 0x8228 +R8 :: 0x8229 +RG8 :: 0x822B +R16F :: 0x822D +R32F :: 0x822E +RG16F :: 0x822F +RG32F :: 0x8230 +R8I :: 0x8231 +R8UI :: 0x8232 +R16I :: 0x8233 +R16UI :: 0x8234 +R32I :: 0x8235 +R32UI :: 0x8236 +RG8I :: 0x8237 +RG8UI :: 0x8238 +RG16I :: 0x8239 +RG16UI :: 0x823A +RG32I :: 0x823B +RG32UI :: 0x823C +VERTEX_ARRAY_BINDING :: 0x85B5 +R8_SNORM :: 0x8F94 +RG8_SNORM :: 0x8F95 +RGB8_SNORM :: 0x8F96 +RGBA8_SNORM :: 0x8F97 +SIGNED_NORMALIZED :: 0x8F9C +COPY_READ_BUFFER :: 0x8F36 +COPY_WRITE_BUFFER :: 0x8F37 +COPY_READ_BUFFER_BINDING :: 0x8F36 +COPY_WRITE_BUFFER_BINDING :: 0x8F37 +UNIFORM_BUFFER :: 0x8A11 +UNIFORM_BUFFER_BINDING :: 0x8A28 +UNIFORM_BUFFER_START :: 0x8A29 +UNIFORM_BUFFER_SIZE :: 0x8A2A +MAX_VERTEX_UNIFORM_BLOCKS :: 0x8A2B +MAX_FRAGMENT_UNIFORM_BLOCKS :: 0x8A2D +MAX_COMBINED_UNIFORM_BLOCKS :: 0x8A2E +MAX_UNIFORM_BUFFER_BINDINGS :: 0x8A2F +MAX_UNIFORM_BLOCK_SIZE :: 0x8A30 +MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS :: 0x8A31 +MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS :: 0x8A33 +UNIFORM_BUFFER_OFFSET_ALIGNMENT :: 0x8A34 +ACTIVE_UNIFORM_BLOCKS :: 0x8A36 +UNIFORM_TYPE :: 0x8A37 +UNIFORM_SIZE :: 0x8A38 +UNIFORM_BLOCK_INDEX :: 0x8A3A +UNIFORM_OFFSET :: 0x8A3B +UNIFORM_ARRAY_STRIDE :: 0x8A3C +UNIFORM_MATRIX_STRIDE :: 0x8A3D +UNIFORM_IS_ROW_MAJOR :: 0x8A3E +UNIFORM_BLOCK_BINDING :: 0x8A3F +UNIFORM_BLOCK_DATA_SIZE :: 0x8A40 +UNIFORM_BLOCK_ACTIVE_UNIFORMS :: 0x8A42 +UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES :: 0x8A43 +UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER :: 0x8A44 +UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER :: 0x8A46 +INVALID_INDEX :: 0xFFFFFFF +MAX_VERTEX_OUTPUT_COMPONENTS :: 0x9122 +MAX_FRAGMENT_INPUT_COMPONENTS :: 0x9125 +MAX_SERVER_WAIT_TIMEOUT :: 0x9111 +OBJECT_TYPE :: 0x9112 +SYNC_CONDITION :: 0x9113 +SYNC_STATUS :: 0x9114 +SYNC_FLAGS :: 0x9115 +SYNC_FENCE :: 0x9116 +SYNC_GPU_COMMANDS_COMPLETE :: 0x9117 +UNSIGNALED :: 0x9118 +SIGNALED :: 0x9119 +ALREADY_SIGNALED :: 0x911A +TIMEOUT_EXPIRED :: 0x911B +CONDITION_SATISFIED :: 0x911C +WAIT_FAILED :: 0x911D +SYNC_FLUSH_COMMANDS_BIT :: 0x0000001 +VERTEX_ATTRIB_ARRAY_DIVISOR :: 0x88FE +ANY_SAMPLES_PASSED :: 0x8C2F +ANY_SAMPLES_PASSED_CONSERVATIVE :: 0x8D6A +SAMPLER_BINDING :: 0x8919 +RGB10_A2UI :: 0x906F +INT_2_10_10_10_REV :: 0x8D9F +TRANSFORM_FEEDBACK :: 0x8E22 +TRANSFORM_FEEDBACK_PAUSED :: 0x8E23 +TRANSFORM_FEEDBACK_ACTIVE :: 0x8E24 +TRANSFORM_FEEDBACK_BINDING :: 0x8E25 +TEXTURE_IMMUTABLE_FORMAT :: 0x912F +MAX_ELEMENT_INDEX :: 0x8D6B +TEXTURE_IMMUTABLE_LEVELS :: 0x82DF +TIMEOUT_IGNORED :: -1 + +// WebGL-specific enums +UNPACK_FLIP_Y_WEBGL :: 0x9240 +UNPACK_PREMULTIPLY_ALPHA_WEBGL :: 0x9241 +CONTEXT_LOST_WEBGL :: 0x9242 +UNPACK_COLORSPACE_CONVERSION_WEBGL :: 0x9243 +BROWSER_DEFAULT_WEBGL :: 0x9244 +MAX_CLIENT_WAIT_TIMEOUT_WEBGL :: 0x9247 + +GLenum :: #type u32 +GLboolean :: #type bool +GLbitfield :: #type u32 +GLbyte :: #type i8 +GLshort :: #type i16 +GLint :: #type i32 +GLsizei :: #type i32 +GLintptr :: #type i64 +GLsizeiptr :: #type i64 +GLubyte :: #type u8 +GLushort :: #type u16 +GLuint :: #type u32 +GLfloat :: #type f32 +GLclampf :: #type f32 + +GLProgram :: #type i32 +GLShader :: #type i32 +GLFramebuffer :: #type i32 +GLRenderbuffer :: #type i32 +GLTexture :: #type i32 +GLBuffer :: #type i32 +GLUniformLocation :: #type i32 + +GLActiveInfo :: struct { + size : GLint; + type : GLenum; + + // Not used + name : ^u8; +} + +GLMat2 :: #type [4] GLfloat +GLMat3 :: #type [9] GLfloat +GLMat4 :: #type [16] GLfloat + +activeTexture :: proc (texture: GLenum) #foreign "gl" "activeTexture" --- +attachShader :: proc (program: GLProgram, shader: GLShader) -> GLProgram #foreign "gl" "attachShader" --- +bindAttribLocation :: proc (program: GLProgram, index: GLuint, name: string) #foreign "gl" "bindAttribLocation" --- +bindBuffer :: proc (target: GLenum, buffer: GLBuffer) #foreign "gl" "bindBuffer" --- +bindFramebuffer :: proc (target: GLenum, framebuffer: GLFramebuffer) #foreign "gl" "bindFramebuffer" --- +bindRenderbuffer :: proc (target: GLenum, renderbuffer: GLRenderbuffer) #foreign "gl" "bindRenderbuffer" --- +bindTexture :: proc (target: GLenum, texture: GLTexture) #foreign "gl" "bindTexture" --- +blendColor :: proc (red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf) #foreign "gl" "blendColor" --- +blendEquation :: proc (mode: GLenum) #foreign "gl" "blendEquation" --- +blendEquationSeparate :: proc (modeRGB: GLenum, modeAlpha: GLenum) #foreign "gl" "blendEquationSeparate" --- +blendFunc :: proc (sfactor: GLenum, dfactor: GLenum) #foreign "gl" "blendFunc" --- +blendFuncSeparate :: proc (srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum) #foreign "gl" "blendFuncSeparate" --- +blitFramebuffer :: proc (sx0: GLint, sy0: GLint, sx1: GLint, sy1: GLint, dx0: GLint, dy0: GLint, dx1: GLint, dy1: GLint, mask: GLbitfield, filter: GLenum) #foreign "gl" "blitFramebuffer" --- +bufferDataWithData :: proc (target: GLenum, buffer: Buffer, usage: GLenum) #foreign "gl" "bufferDataWithData" --- +bufferDataNoData :: proc (target: GLenum, size: GLsizeiptr, usage: GLenum) #foreign "gl" "bufferDataNoData" --- +bufferData :: proc #overloaded { bufferDataWithData, bufferDataNoData } +bufferSubData :: proc (target: GLenum, offset: GLintptr, data: string) #foreign "gl" "bufferSubData" --- +checkFrameBufferStatus :: proc (target: GLenum) -> GLenum #foreign "gl" "checkFrameBufferStatus" --- +clear :: proc (mask: GLbitfield) #foreign "gl" "clear" --- +clearColor :: proc (red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf) #foreign "gl" "clearColor" --- +clearDepth :: proc (depth: GLclampf) #foreign "gl" "clearDepth" --- +clearStencil :: proc (s: GLint) #foreign "gl" "clearStencil" --- +colorMask :: proc (red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean) #foreign "gl" "colorMask" --- +compileShader :: proc (shader: GLShader) #foreign "gl" "compileShader" --- +compressedTexImage2D :: proc (target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, data: string) #foreign "gl" "compressedTexImage2D" --- +compressedTexSubImage2D :: proc (target: GLenum, level: GLint, internalformat: GLenum, xoff: GLint, yoff: GLint, width: GLsizei, height: GLsizei, format: GLenum, data: string) #foreign "gl" "compressedTexSubImage2D" --- +copyBufferSubData :: proc (readTarget: GLenum, writeTarget: GLenum, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr) #foreign "gl" "copyBufferSubData" --- +copyTexImage2D :: proc (target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint) #foreign "gl" "copyTexImage2D" --- +copyTexSubImage2D :: proc (target: GLenum, level: GLint, xoff: GLint, yoff: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) #foreign "gl" "copyTexSubImage2D" --- +createBuffer :: proc -> GLBuffer #foreign "gl" "createBuffer" --- +createFramebuffer :: proc -> GLFramebuffer #foreign "gl" "createFramebuffer" --- +createProgram :: proc -> GLProgram #foreign "gl" "createProgram" --- +createRenderbuffer :: proc -> GLRenderbuffer #foreign "gl" "createRenderbuffer" --- +createShader :: proc (type: GLenum) -> GLShader #foreign "gl" "createShader" --- +createTexture :: proc -> GLTexture #foreign "gl" "createTexture" --- +cullFace :: proc (mode: GLenum) #foreign "gl" "cullFace" --- +deleteBuffer :: proc (buffer: GLBuffer) #foreign "gl" "deleteBuffer" --- +deleteFramebuffer :: proc (framebuffer: GLFramebuffer) #foreign "gl" "deleteFramebuffer" --- +deleteProgram :: proc (program: GLProgram) #foreign "gl" "deleteProgram" --- +deleteRenderbuffer :: proc (renderbuffer: GLRenderbuffer) #foreign "gl" "deleteRenderbuffer" --- +deleteShader :: proc (shader: GLShader) #foreign "gl" "deleteShader" --- +deleteTexture :: proc (texture: GLTexture) #foreign "gl" "deleteTexture" --- +depthFunc :: proc (func: GLenum) #foreign "gl" "depthFunc" --- +depthMask :: proc (flag: GLboolean) #foreign "gl" "depthMask" --- +depthRange :: proc (zNear: GLclampf, zFar: GLclampf) #foreign "gl" "depthRange" --- +detachShader :: proc (program: GLProgram, shader: GLShader) #foreign "gl" "detachShader" --- +disable :: proc (cap: GLenum) #foreign "gl" "disable" --- +disableVertexAttribArray :: proc (index: GLuint) #foreign "gl" "disableVertexAttribArray" --- +drawArrays :: proc (mode: GLenum, first: GLint, count: GLsizei) #foreign "gl" "drawArrays" --- +drawElements :: proc (mode: GLenum, count: GLsizei, type: GLenum, offset: GLint) #foreign "gl" "drawElements" --- +enable :: proc (cap: GLenum) #foreign "gl" "enable" --- +enableVertexAttribArray :: proc (index: GLuint) #foreign "gl" "enableVertexAttribArray" --- +finish :: proc #foreign "gl" "finish" --- +flush :: proc #foreign "gl" "flush" --- +framebufferRenderbuffer :: proc (target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLRenderbuffer) #foreign "gl" "framebufferRenderbuffer" --- +framebufferTexture2D :: proc (target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLTexture, level: GLint) #foreign "gl" "framebufferTexture2D" --- +framebufferTextureLayer :: proc (target: GLenum, attachment: GLenum, texture: GLTexture, level: GLint, layer: GLint) #foreign "gl" "framebufferTextureLayer" --- +frontFace :: proc (mode: GLenum) #foreign "gl" "frontFace" --- +generateMipmap :: proc (target: GLenum) #foreign "gl" "generateMipmap" --- +getActiveAttrib :: proc (program: GLProgram, index: GLuint, out: ^GLActiveInfo) #foreign "gl" "getActiveAttrib" --- +getActiveUniform :: proc (program: GLProgram, index: GLuint, out: ^GLActiveInfo) #foreign "gl" "getActiveUniform" --- +// getAttachedShaders does not work yet because we can't return a list of things +getAttribLocation :: proc (program: GLProgram, name: string) -> GLint #foreign "gl" "getAttribLocation" --- +getBufferSubData :: proc (target: GLenum, srcByteOffset: GLintptr, dstBuffer: string, dstOffset: GLuint, length: GLuint) #foreign "gl" "getBufferSubData" --- +// getBufferParameter and getParameter do not work +getError :: proc -> GLenum #foreign "gl" "getError" --- +getInternalformatParameter :: proc (target: GLenum, internalFormat: GLenum, pname: GLenum) -> GLenum #foreign "gl" "getInternalformatParameter" --- +// many of the 'gets' don't work yet because they return very javascripty things +getProgramParameter :: proc (program: GLProgram, pname: GLenum) -> GLenum #foreign "gl" "getProgramParameter" --- +getShaderParameter :: proc (shader: GLShader, pname: GLenum) -> GLenum #foreign "gl" "getShaderParameter" --- +getUniformLocation :: proc (program: GLProgram, name: string) -> GLUniformLocation #foreign "gl" "getUniformLocation" --- +getVertexAttribOffset :: proc (index: GLuint, pname: GLenum) #foreign "gl" "getVertexAttribOffset" --- +hint :: proc (target: GLenum, mode: GLenum) #foreign "gl" "hint" --- +init :: proc (canvasname: string) -> GLboolean #foreign "gl" "init" --- +invalidateFramebuffer :: proc (target: GLenum, attachments: string) #foreign "gl" "invalidateFramebuffer" --- +invalidateSubFramebuffer :: proc (target: GLenum, attachments: string, x: GLint, y: GLint, width: GLsizei, height: GLsizei) #foreign "gl" "invalidateSubFramebuffer" --- +isEnabled :: proc (cap: GLenum) -> GLboolean #foreign "gl" "isEnabled" --- +lineWidth :: proc (width: GLfloat) #foreign "gl" "lineWidth" --- +linkProgram :: proc (program: GLProgram) #foreign "gl" "linkProgram" --- +pixelStorei :: proc (pname: GLenum, param: GLenum) #foreign "gl" "pixelStorei" --- +polygonOffset :: proc (factor: GLfloat, units: GLfloat) #foreign "gl" "polygonOffset" --- +printProgramInfoLog :: proc (program: GLProgram) #foreign "gl" "printProgramInfoLog" --- +printShaderInfoLog :: proc (shader: GLShader) #foreign "gl" "printShaderInfoLog" --- +readBuffer :: proc (src: GLenum) #foreign "gl" "readBuffer" --- +readPixels :: proc (x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: string) #foreign "gl" "readPixels" --- +renderbufferStorageMultisample :: proc (target: GLenum, samples: GLsizei, internalforamt: GLenum, width: GLsizei, height: GLsizei) #foreign "gl" "renderbufferStorageMultisample" --- +sampleCoverage :: proc (value: GLclampf, invert: GLboolean) #foreign "gl" "sampleCoverage" --- +scissor :: proc (x: GLint, y: GLint, width: GLsizei, height: GLsizei) #foreign "gl" "scissor" --- +shaderSource :: proc (shader: GLShader, source: string) #foreign "gl" "shaderSource" --- +stencilFunc :: proc (func: GLenum, ref: GLint, mask: GLuint) #foreign "gl" "stencilFunc" --- +stencilFuncSeparate :: proc (face: GLenum, func: GLenum, ref: GLint, mask: GLuint) #foreign "gl" "stencilFuncSeparate" --- +stencilMask :: proc (mask: GLuint) #foreign "gl" "stencilMask" --- +stencilMaskSeparate :: proc (face: GLenum, mask: GLenum) #foreign "gl" "stencilMaskSeparate" --- +stencilOp :: proc (fail: GLenum, zfail: GLenum, zpass: GLenum) #foreign "gl" "stencilOp" --- +stencilOpSeparate :: proc (face: GLenum, fail: GLenum, zfail: GLenum, zpass: GLenum) #foreign "gl" "stencilOpSeparate" --- +texImage2D :: proc (target: GLenum, level: GLint, internalFormat: GLenum, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: string) #foreign "gl" "texImage2D" --- +texParameterf :: proc (target: GLenum, pname: GLenum, param: GLfloat) #foreign "gl" "texParameterf" --- +texParameteri :: proc (target: GLenum, pname: GLenum, param: GLint) #foreign "gl" "texParameteri" --- +texSubImage2D :: proc (target: GLenum, level: GLint, xoff: GLint, yoff: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: string) #foreign "gl" "texSubImage2D" --- +uniform1f :: proc (loc: GLUniformLocation, x: GLfloat) #foreign "gl" "uniform1f" --- +uniform1i :: proc (loc: GLUniformLocation, x: GLint) #foreign "gl" "uniform1i" --- +uniform2f :: proc (loc: GLUniformLocation, x: GLfloat, y: GLfloat) #foreign "gl" "uniform2f" --- +uniform2i :: proc (loc: GLUniformLocation, x: GLint, y: GLint) #foreign "gl" "uniform2i" --- +uniform3f :: proc (loc: GLUniformLocation, x: GLfloat, y: GLfloat, z: GLfloat) #foreign "gl" "uniform3f" --- +uniform3i :: proc (loc: GLUniformLocation, x: GLint, y: GLint, z: GLint) #foreign "gl" "uniform3i" --- +uniform4f :: proc (loc: GLUniformLocation, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) #foreign "gl" "uniform4f" --- +uniform4i :: proc (loc: GLUniformLocation, x: GLint, y: GLint, z: GLint, w: GLint) #foreign "gl" "uniform4i" --- +uniformMatrix2 :: proc (loc: GLUniformLocation, transpose: GLboolean, value: GLMat2) #foreign "gl" "uniformMatrix2" --- +uniformMatrix3 :: proc (loc: GLUniformLocation, transpose: GLboolean, value: GLMat3) #foreign "gl" "uniformMatrix3" --- +uniformMatrix4 :: proc (loc: GLUniformLocation, transpose: GLboolean, value: GLMat4) #foreign "gl" "uniformMatrix4" --- +useProgram :: proc (program: GLProgram) #foreign "gl" "useProgram" --- +validateProgram :: proc (program: GLProgram) #foreign "gl" "validateProgram" --- +vertexAttrib1f :: proc (idx: GLuint, x: GLfloat) #foreign "gl" "vertexAttrib1f" --- +vertexAttrib2f :: proc (idx: GLuint, x: GLfloat, y: GLfloat) #foreign "gl" "vertexAttrib2f" --- +vertexAttrib3f :: proc (idx: GLuint, x: GLfloat, y: GLfloat, z: GLfloat) #foreign "gl" "vertexAttrib3f" --- +vertexAttrib4f :: proc (idx: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) #foreign "gl" "vertexAttrib4f" --- +vertexAttribPointer :: proc (idx: GLuint, size: GLint, type: GLenum, normalized: GLboolean, stride: GLsizei, offset: GLint) #foreign "gl" "vertexAttribPointer" --- +viewport :: proc (x: GLint, y: GLint, width: GLsizei, height: GLsizei) #foreign "gl" "viewport" --- diff --git a/core/math.onyx b/core/math.onyx index 8151c32d..9c222850 100644 --- a/core/math.onyx +++ b/core/math.onyx @@ -1,4 +1,4 @@ -package math +package core PI :: 3.14159265f; TAU :: 6.28318330f; diff --git a/core/memory.onyx b/core/memory.onyx index aa6ff6e5..c1223d88 100644 --- a/core/memory.onyx +++ b/core/memory.onyx @@ -1,4 +1,4 @@ -package memory +package core memory_copy :: proc (dst_: rawptr, src_: rawptr, len: u32) { dst := cast(^u8) dst_; diff --git a/core/printing.onyx b/core/printing.onyx deleted file mode 100644 index 9569ed3e..00000000 --- a/core/printing.onyx +++ /dev/null @@ -1,124 +0,0 @@ -package printing - -print_bool :: proc (value: bool) #foreign "host" "print" --- -print_i32 :: proc (value: i32) #foreign "host" "print" --- -print_f32 :: proc (value: f32) #foreign "host" "print" --- -print_i64 :: proc (value: i64) #foreign "host" "print" --- -print_f64 :: proc (value: f64) #foreign "host" "print" --- - -PrintableArray :: struct { - data: ^u8; - len: i32; -} - -print_i32arr :: proc (arr: [] i32, len: i32) { - for i: 0, len do print(arr[i]); -} - -print_i64arr :: proc (arr: [] i64, len: i32) { - for i: 0, len do print(arr[i]); -} - -print_f32arr :: proc (arr: [] f32, len: i32) { - for i: 0, len do print(arr[i]); -} - -print_f64arr :: proc (arr: [] f64, len: i32) { - for i: 0, len do print(arr[i]); -} - -// NOTE: print null-terminated string -print_str_by_byte :: proc (str: ^u8) { - c := str; - while *c != cast(u8) 0 { - print(cast(i32) (*c)); - c += 1; - } -} - -print_str :: proc (str: ^u8) #foreign "host" "print_str" --- - -print_str_len :: proc (str: [] u8, len: i32) { - for i: 0, len do print(cast(i32) str[i]); -} - -print_u64_with_base :: proc (n_: u64, base: u64) { - n := n_; - str: [128] u8; - for i: 0, 128 do str[i] = #char "\0"; - - c := cast(^u8) ^str[127]; - *c = #char "\0"; - c -= 1; - - if n == 0l { - *c = #char "0"; - c -= 1; - } else { - while n > 0l { - m :: n % base; - - ch := cast(u8) 0; - - // TODO: Replace with array lookup when array literals are added - if m == 0l do ch = #char "0"; - elseif m == 1l do ch = #char "1"; - elseif m == 2l do ch = #char "2"; - elseif m == 3l do ch = #char "3"; - elseif m == 4l do ch = #char "4"; - elseif m == 5l do ch = #char "5"; - elseif m == 6l do ch = #char "6"; - elseif m == 7l do ch = #char "7"; - elseif m == 8l do ch = #char "8"; - elseif m == 9l do ch = #char "9"; - elseif m == 10l do ch = #char "A"; - elseif m == 11l do ch = #char "B"; - elseif m == 12l do ch = #char "C"; - elseif m == 13l do ch = #char "D"; - elseif m == 14l do ch = #char "E"; - elseif m == 15l do ch = #char "F"; - - *c = ch; - c -= 1; - - n /= base; - } - } - - if base == 16l { - *c = #char "x"; - c -= 1; - *c = #char "0"; - c -= 1; - } - - if base == 2l { - *c = #char "b"; - c -= 1; - *c = #char "0"; - c -= 1; - } - - print(c + 1); -} - -print_u64 :: proc (n: u64) do print_u64_with_base(n, 10l); -print_hex :: proc (n: u64) do print_u64_with_base(n, 16l); -print_bin :: proc (n: u64) do print_u64_with_base(n, 2l); -print_ptr :: proc (p: rawptr) do print_hex(cast(u64) p); - -print :: proc #overloaded { - print_bool, - print_i32, - print_f32, - print_i64, - print_f64, - - print_i32arr, - print_i64arr, - print_f32arr, - print_f64arr, - - print_str, - print_str_len, -} diff --git a/core/random.onyx b/core/random.onyx index ab515814..fd4a557d 100644 --- a/core/random.onyx +++ b/core/random.onyx @@ -1,4 +1,4 @@ -package random +package core #private seed := 8675309 diff --git a/core/std/js.onyx b/core/std/js.onyx new file mode 100644 index 00000000..df151685 --- /dev/null +++ b/core/std/js.onyx @@ -0,0 +1,15 @@ +package core + +use package builtin + +#include_file "core/alloc" +#include_file "core/intrinsics" +#include_file "core/math" +#include_file "core/memory" +#include_file "core/random" +#include_file "core/stdio" +#include_file "core/string" + +#include_file "core/sys/js" + + diff --git a/core/std/wasi.onyx b/core/std/wasi.onyx new file mode 100644 index 00000000..13c24ffb --- /dev/null +++ b/core/std/wasi.onyx @@ -0,0 +1,17 @@ +package core + +use package builtin + +#include_file "core/alloc" +#include_file "core/file" +#include_file "core/intrinsics" +#include_file "core/math" +#include_file "core/memory" +#include_file "core/random" +#include_file "core/stdio" +#include_file "core/string" +#include_file "core/wasi" + +#include_file "core/sys/wasi" + + diff --git a/core/stdio.onyx b/core/stdio.onyx index d9360c75..a0f0794b 100644 --- a/core/stdio.onyx +++ b/core/stdio.onyx @@ -1,19 +1,32 @@ -package stdio +package core -use package builtin -use package core -use package wasi +// It is expected that a file will be included that will be part +// of the system package +use package system as system + +#private +print_buffer : StringBuilder; + +stdio_init :: proc { + print_buffer = string_builder_make(2048); +} print_string :: proc (s: string) { - string_builder_append(^cout_state.sb, s); - if s.data[s.count - 1] == #char "\n" do print_flush(); + string_builder_append(^print_buffer, s); + if s.data[s.count - 1] == #char "\n" do print_buffer_flush(); } -print_cstring :: proc (s: cstring) do string_builder_append(^cout_state.sb, s); -print_i64 :: proc (n: i64, base := 10l) do string_builder_append(^cout_state.sb, n, base); -print_i32 :: proc (n: i32, base := 10) do string_builder_append(^cout_state.sb, cast(i64) n, cast(u64) base); -print_bool :: proc (b: bool) do string_builder_append(^cout_state.sb, b); -print_ptr :: proc (p: rawptr) do string_builder_append(^cout_state.sb, cast(i64) p, 16l); +print_cstring :: proc (s: cstring) do string_builder_append(^print_buffer, s); +print_i64 :: proc (n: i64, base := 10l) do string_builder_append(^print_buffer, n, base); +print_i32 :: proc (n: i32, base := 10) do string_builder_append(^print_buffer, cast(i64) n, cast(u64) base); +print_bool :: proc (b: bool) do string_builder_append(^print_buffer, b); +print_ptr :: proc (p: rawptr) do string_builder_append(^print_buffer, cast(i64) p, 16l); + +print :: proc #overloaded { + print_string, print_cstring, + print_i64, print_i32, + print_bool, print_ptr, +} // This works on both slices and arrays print_array :: proc (arr: $T, sep := " ") { @@ -25,38 +38,11 @@ print_array :: proc (arr: $T, sep := " ") { print("\n"); } -print :: proc #overloaded { - print_string, - print_cstring, - print_i64, - print_i32, - print_bool, - print_ptr, +print_buffer_flush :: proc { + ^print_buffer + |> string_builder_to_string() + |> system.output_string(); + + ^print_buffer |> string_builder_clear(); } -print_flush :: proc { - ^cout_state.sb |> string_builder_to_string() |> raw_print(cout_state.fd); - ^cout_state.sb |> string_builder_clear(); -} - -#private -raw_print :: proc (s: string, fd: FileDescriptor) -> u32 { - vec := IOVec.{ buf = s.data, len = s.count }; - tmp : Size; - fd_write(fd, IOVecArray.{ ^vec, 1 }, ^tmp); - fd_datasync(fd); - return tmp; -} - -ConsoleOutput :: struct { - sb : StringBuilder; - fd : FileDescriptor; -} - -#private -cout_state : ConsoleOutput - -stdio_init :: proc { - cout_state.fd = cast(FileDescriptor) 1; - cout_state.sb = string_builder_make(2048); -} \ No newline at end of file diff --git a/core/string.onyx b/core/string.onyx index 5ee643ae..b81b6227 100644 --- a/core/string.onyx +++ b/core/string.onyx @@ -1,9 +1,5 @@ package core -use package builtin -use package memory -use package wasi - string_make :: proc #overloaded { string_make_from_cstring } #private diff --git a/core/sys/js.onyx b/core/sys/js.onyx new file mode 100644 index 00000000..69d47149 --- /dev/null +++ b/core/sys/js.onyx @@ -0,0 +1,26 @@ +package system + +use package builtin +use package core +use package main as main + +output_string :: proc (s: string) -> u32 #foreign "host" "print_str" --- + +// The builtin _start proc. +// Sets up everything needed for execution. +proc #export "_start" { + memory_init(); + + context.allocator = heap_allocator; + context.temp_allocator = heap_allocator; + + stdio_init(); + + args : [] cstring; + args.data = null; + args.count = 0; + + main.main(args); + + print_buffer_flush(); +} diff --git a/core/sys/wasi.onyx b/core/sys/wasi.onyx new file mode 100644 index 00000000..828aefb7 --- /dev/null +++ b/core/sys/wasi.onyx @@ -0,0 +1,43 @@ +package system + +#include_file "core/wasi" + +use package builtin +use package wasi +use package core +use package main as main + +STDOUT_FILENO :: 1 + +output_string :: proc (s: string) -> u32 { + vec := IOVec.{ buf = s.data, len = s.count }; + tmp : Size; + fd_write(STDOUT_FILENO, IOVecArray.{ ^vec, 1 }, ^tmp); + fd_datasync(STDOUT_FILENO); + return tmp; +} + +// The builtin _start proc. +// Sets up everything needed for execution. +proc #export "_start" { + memory_init(); + + context.allocator = heap_allocator; + context.temp_allocator = heap_allocator; + + argc : Size; + argv_buf_size : Size; + + args_sizes_get(^argc, ^argv_buf_size); + + argv := cast(^cstring) calloc(sizeof cstring * argc); + argv_buf := cast(cstring) calloc(argv_buf_size); + + args_get(argv, argv_buf); + + stdio_init(); + + main.main(argv[0 : argc]); + + print_buffer_flush(); +} diff --git a/core/wasi.onyx b/core/wasi.onyx index d96d67ba..088192e6 100644 --- a/core/wasi.onyx +++ b/core/wasi.onyx @@ -1,11 +1,14 @@ package wasi -#include_file "stdio" +use package builtin +use package core { + memory_init, + stdio_init, + print_buffer_flush, + heap_allocator +} use package main as main -use package builtin -use package memory -use package stdio as io Size :: #type u32; Filesize :: #type u64; @@ -425,27 +428,3 @@ sock_shutdown :: proc (fd: FileDescriptor, how: SDFlags) -> Errno #foreign "wasi -// The builtin _start proc. -// Sets up everything needed for execution. -proc #export "_start" { - memory_init(); - - context.allocator = heap_allocator; - context.temp_allocator = heap_allocator; - - argc : Size; - argv_buf_size : Size; - - args_sizes_get(^argc, ^argv_buf_size); - - argv := cast(^cstring) calloc(sizeof cstring * argc); - argv_buf := cast(cstring) calloc(argv_buf_size); - - args_get(argv, argv_buf); - - io.stdio_init(); - - main.main(argv[0 : argc]); - - io.print_flush(); -} diff --git a/misc/onyx.sublime-build b/misc/onyx.sublime-build index fcf81eac..a910832d 100644 --- a/misc/onyx.sublime-build +++ b/misc/onyx.sublime-build @@ -1,6 +1,6 @@ { "target": "exec", - "shell_cmd": "/usr/bin/onyx -o \"${folder}/${file_base_name}.wasm\" \"$file\"", + "shell_cmd": "/usr/bin/onyx -verbose -o \"${folder}/${file_base_name}.wasm\" \"$file\"", "working_dir": "${folder}", "selector": "source.onyx", "file_regex": "^\\(([^:]+):([0-9]+),([0-9]+)\\) (.*)", diff --git a/onyx b/onyx index a791f6af..421c6822 100755 Binary files a/onyx and b/onyx differ diff --git a/progs/poly_test.onyx b/progs/poly_test.onyx index a83027a7..8feafe2e 100644 --- a/progs/poly_test.onyx +++ b/progs/poly_test.onyx @@ -1,20 +1,9 @@ package main -#include_file "wasi" -#include_file "alloc" -#include_file "intrinsics" -#include_file "random" -#include_file "string" -#include_file "file" +#include_file "core/std/wasi" use package builtin use package core -use package memory -use package wasi -use package intrinsics -use package random -use package file -use package stdio print_arr_details :: proc (arr: ^[..] $T) { print("\nArray details:\n\tSize: "); diff --git a/src/onyx.c b/src/onyx.c index 0cd33f76..b1628aa6 100644 --- a/src/onyx.c +++ b/src/onyx.c @@ -15,7 +15,7 @@ #ifndef CORE_INSTALLATION #ifdef __unix__ - #define CORE_INSTALLATION "/usr/share/onyx/core" + #define CORE_INSTALLATION "/usr/share/onyx" #endif #endif @@ -150,7 +150,7 @@ static void compiler_state_init(CompilerState* compiler_state, OnyxCompileOption bh_arr_new(opts->allocator, compiler_state->queued_files, 4); - bh_arr_push(compiler_state->queued_files, lookup_included_file(compiler_state, "builtin")); + bh_arr_push(compiler_state->queued_files, lookup_included_file(compiler_state, "core/builtin")); // NOTE: Add all files passed by command line to the queue bh_arr_each(const char *, filename, opts->files) diff --git a/src/onyxsymres.c b/src/onyxsymres.c index e048f544..23ba952f 100644 --- a/src/onyxsymres.c +++ b/src/onyxsymres.c @@ -461,6 +461,8 @@ void symres_function(AstFunction* func) { bh_arr_each(AstParam, param, func->params) { if (param->default_value != NULL) { symres_expression(¶m->default_value); + if (onyx_has_errors()) return; + if (check_expression(¶m->default_value)) return; } }