From 86cc48dd8912c2f7e0e74277b2ef19b6c6e466db Mon Sep 17 00:00:00 2001 From: LEGALISE_PIRACY Date: Sun, 5 May 2024 21:05:59 +0000 Subject: [PATCH] Add semag/125/ cheerpj-natives/natives/lwjgl.js --- semag/125/ cheerpj-natives/natives/lwjgl.js | 1465 +++++++++++++++++++ 1 file changed, 1465 insertions(+) create mode 100644 semag/125/ cheerpj-natives/natives/lwjgl.js diff --git a/semag/125/ cheerpj-natives/natives/lwjgl.js b/semag/125/ cheerpj-natives/natives/lwjgl.js new file mode 100644 index 00000000..77bc81e6 --- /dev/null +++ b/semag/125/ cheerpj-natives/natives/lwjgl.js @@ -0,0 +1,1465 @@ +// Load the glMatrix library +await import("https://cdnjs.cloudflare.com/ajax/libs/gl-matrix/3.4.2/gl-matrix-min.js"); + +const glCanvas = window.lwjglCanvasElement; +if (!(glCanvas instanceof HTMLCanvasElement)) throw new Error("window.lwjglCanvasElement is not set or is not a canvas"); +const glCtx = glCanvas.getContext("webgl2", {antialias: false, alpha: false}); + +var vertexShaderSrc = ` + attribute vec4 aVertexPosition; + attribute vec4 aColor; + attribute vec2 aTexCoord; + uniform mat4 modelView; + uniform mat4 projection; + varying vec2 vTexCoord; + varying vec4 vColor; + void main() { + gl_Position = projection * modelView * aVertexPosition; + vTexCoord = aTexCoord; + vColor = aColor; + } +`; +// NOTE: Only the default GL_MODULATE texEnv is supported here +var fragmentShaderSrc = ` + precision mediump float; + uniform float uTextureMask; + uniform sampler2D uSampler; + uniform sampler2D uSampler2; // Additional texture sampler + varying vec2 vTexCoord; + varying vec4 vColor; + void main() { + vec4 texSample = texture2D(uSampler, vTexCoord) * uTextureMask; + vec4 texSample2 = texture2D(uSampler2, vTexCoord); + vec4 colorValue = vColor; + gl_FragColor = mix(texSample, colorValue, texSample2); + } +`; +var vertexShader = glCtx.createShader(glCtx.VERTEX_SHADER); +glCtx.shaderSource(vertexShader, vertexShaderSrc); +glCtx.compileShader(vertexShader); +var fragmentShader = glCtx.createShader(glCtx.FRAGMENT_SHADER); +glCtx.shaderSource(fragmentShader, fragmentShaderSrc); +glCtx.compileShader(fragmentShader); +var program = glCtx.createProgram(); +glCtx.attachShader(program, vertexShader); +glCtx.attachShader(program, fragmentShader); +glCtx.linkProgram(program); +glCtx.useProgram(program); +var vertexBuffer = glCtx.createBuffer(); +var colorBuffer = glCtx.createBuffer(); +var texCoordBuffer = glCtx.createBuffer(); +var vertexPosition = glCtx.getAttribLocation(program, "aVertexPosition"); +var colorLocation = glCtx.getAttribLocation(program, "aColor"); +var texCoord = glCtx.getAttribLocation(program, "aTexCoord"); +var mvLocation = glCtx.getUniformLocation(program, "modelView"); +var projLocation = glCtx.getUniformLocation(program, "projection"); +var samplerLocation = glCtx.getUniformLocation(program, "uSampler"); +var samplerLocation2 = glCtx.getUniformLocation(program, "uSampler2"); +var texMaskLocation = glCtx.getUniformLocation(program, "uTextureMask"); +var vertexData = +{ + enabled: false, + size: 0, + type: 0, + stride: 0, + pointer: 0, + buf: null +}; +var normalData = +{ + enabled: false, + size: 0, + type: 0, + stride: 0, + pointer: 0, + buf: null +}; +var colorData = +{ + enabled: false, + size: 0, + type: 0, + stride: 0, + pointer: 0, + buf: null +}; +var texCoordData = +{ + enabled: false, + size: 0, + type: 0, + stride: 0, + pointer: 0, + buf: null +}; +// TODO: Make buffers resizeable if needed +var immediateModeData = +{ + mode: 0, + vertexBuf: new Float32Array(32), + vertexPos: 0, + texCoordBuf: new Float32Array(32), + texCoordPos: 0 +}; +var verboseLog = false; +var frameCount = 0; +// Set to a non-zero value to stop after a certain number of frames +var frameLimit = 0; +// NOTE: These initializes to identity +var projMatrixStack = [glMatrix.mat4.create()]; +var modelViewMatrixStack = [glMatrix.mat4.create()]; +var textureMatrixStack = [glMatrix.mat4.create()]; +var curMatrixStack = modelViewMatrixStack; +function getCurMatrixTop() +{ + return curMatrixStack[curMatrixStack.length - 1]; +} +function setCurMatrixTop(m) +{ + curMatrixStack[curMatrixStack.length - 1] = m; +} +function uploadDataImpl(buf, buffer, attributeLocation, size, type, stride) +{ + glCtx.bindBuffer(glCtx.ARRAY_BUFFER, buffer); + glCtx.bufferData(glCtx.ARRAY_BUFFER, buf, glCtx.STATIC_DRAW); + glCtx.vertexAttribPointer(attributeLocation, size, type, type != glCtx.FLOAT, stride, 0); + glCtx.enableVertexAttribArray(attributeLocation); +} +function uploadData(v, data, buffer, attributeLocation, count) +{ + if(data.enabled) + { + assert(data.stride); + var buf = data.buf; + if(buf == null) + { + assert(v && data.pointer); + buf = new Uint8Array(v.buffer, data.pointer, data.stride * count); + } + uploadDataImpl(buf, buffer, attributeLocation, data.size, data.type, data.stride); + } + else + { + glCtx.disableVertexAttribArray(attributeLocation); + } +} +function captureData(v, data, count) +{ + var ret = { enabled: data.enabled, size: data.size, type: data.type, stride: data.stride, pointer: 0, buf: null }; + if(data.enabled) + { + assert(data.stride); + var buf = new Uint8Array(v.buffer, data.pointer, data.stride * count); + // Capture the current data + ret.buf = new Uint8Array(buf); + } + return ret; +} +function checkNoList(list) +{ + if(list != null) + throw new Error("Unsupported command in list"); +} +function pushInList(list, args, callee) +{ + // Not an elegant solution, but it works + // It would be nicer to extract the actual implementation from native interfaces + // to avoid bringing around the library object + list.push({f: callee, a: Array.from(args)}); +} +function callList(listId) +{ + var l = cmdLists[listId]; + for(var i=0;i { + let [x, y] = convertMousePos(evt.offsetX, evt.offsetY); + + // If the pointer is locked, we can't use offsetX/offsetY + if (lockedMousePos) { + x = lockedMousePos.x += evt.movementX; + y = lockedMousePos.y += evt.movementY; + + if (!document.pointerLockElement) { + // Game still wants the pointer locked, but it's not + Java_org_lwjgl_opengl_LinuxDisplay_nGrabPointer(); + } + } + + if (eventQueue[0]?.type == evt.type) { + // Update unhandled event + eventQueue[0].x = x; + eventQueue[0].y = y; + } else { + eventQueue.push({ type: evt.type, x, y }); + } +}); +function mouseHandler(evt) { + const [x, y] = convertMousePos(evt.offsetX, evt.offsetY); + eventQueue.push({ type: evt.type, x, y, button: convertMouseButton(evt.button) }); +} +glCanvas.addEventListener("mousedown", mouseHandler); +glCanvas.addEventListener("mouseup", mouseHandler); +glCanvas.addEventListener("contextmenu", evt => evt.preventDefault()); + +/** @param {KeyboardEvent} e */ +function keyHandler(e) +{ + // Convert to LinuxKeycodes.java keycodes + // https://github.com/LWJGL/lwjgl/blob/master/src/java/org/lwjgl/opengl/LinuxKeycodes.java + let keyCode = e.keyCode || e.key.charCodeAt(0); // most map to ASCII + switch (e.key) { + case "Escape": // note will have to press twice if pointer is locked + keyCode = 0xff1b; + break; + case "Shift": + keyCode = 0xffe1; + break; + case "Control": + keyCode = 0xffe3; + break; + case "Meta": + keyCode = 0xffe7; + break; + case "Alt": + keyCode = 0xffe9; + break; + } + console.log(e.key, keyCode); + + eventQueue.push({ type: e.type, keyCode }); + e.preventDefault(); +} +glCanvas.addEventListener("keydown", keyHandler); +glCanvas.addEventListener("keyup", keyHandler); +function Java_org_lwjgl_DefaultSysImplementation_getPointerSize() +{ + return 4; +} + +function Java_org_lwjgl_DefaultSysImplementation_getJNIVersion() +{ + return 19; +} + +function Java_org_lwjgl_DefaultSysImplementation_setDebug() +{ +} + +function Java_org_lwjgl_opengl_LinuxDisplay_nLockAWT() +{ +} + +function Java_org_lwjgl_opengl_LinuxDisplay_nUnlockAWT() +{ +} + +function Java_org_lwjgl_opengl_LinuxDisplay_setErrorHandler() +{ +} + +function Java_org_lwjgl_opengl_LinuxDisplay_openDisplay(lib) +{ +} + +function Java_org_lwjgl_opengl_LinuxDisplay_nInternAtom() +{ +} + +function Java_org_lwjgl_opengl_LinuxDisplay_nIsXrandrSupported() +{ + return 0; +} + +function Java_org_lwjgl_opengl_LinuxDisplay_nIsXF86VidModeSupported() +{ + return 1; +} + +function Java_org_lwjgl_opengl_LinuxDisplay_nGetDefaultScreen() +{ + return 0; +} + +async function Java_org_lwjgl_opengl_LinuxDisplay_nGetAvailableDisplayModes(lib) +{ + var DisplayMode = await lib.org.lwjgl.opengl.DisplayMode; + var d = await new DisplayMode(1000, 500); + return [d]; +} + +function Java_org_lwjgl_opengl_LinuxDisplay_nGetCurrentGammaRamp() +{ +} + +function Java_org_lwjgl_opengl_LinuxPeerInfo_createHandle() +{ +} + +function Java_org_lwjgl_opengl_GLContext_nLoadOpenGLLibrary() +{ +} + +function Java_org_lwjgl_opengl_LinuxDisplayPeerInfo_initDefaultPeerInfo() +{ +} + +function Java_org_lwjgl_opengl_LinuxDisplayPeerInfo_initDrawable() +{ +} + +function Java_org_lwjgl_opengl_AWTSurfaceLock_createHandle() +{ +} + +function Java_org_lwjgl_opengl_AWTSurfaceLock_lockAndInitHandle() +{ + return 1; +} + +function Java_org_lwjgl_opengl_LinuxAWTGLCanvasPeerInfo_getScreenFromSurfaceInfo() +{ +} + +function Java_org_lwjgl_opengl_LinuxAWTGLCanvasPeerInfo_nInitHandle() +{ +} + +function Java_org_lwjgl_opengl_AWTSurfaceLock_nUnlock() +{ +} + +function Java_org_lwjgl_opengl_LinuxPeerInfo_nGetDrawable() +{ +} + +function Java_org_lwjgl_opengl_LinuxDisplay_nCreateWindow() +{ +} + +function Java_org_lwjgl_opengl_LinuxDisplay_mapRaised() +{ +} + +function Java_org_lwjgl_opengl_LinuxDisplay_nCreateBlankCursor() +{ +} + +function Java_org_lwjgl_opengl_LinuxDisplay_nSetTitle() +{ +} + +function Java_org_lwjgl_opengl_LinuxMouse_nGetButtonCount() +{ + return 3; +} + +function Java_org_lwjgl_opengl_LinuxMouse_nQueryPointer() +{ +} + +function Java_org_lwjgl_opengl_LinuxMouse_nGetWindowHeight() +{ + return 500; +} + +function Java_org_lwjgl_opengl_LinuxKeyboard_getModifierMapping() +{ +} + +function Java_org_lwjgl_opengl_LinuxKeyboard_nSetDetectableKeyRepeat() +{ +} + +function Java_org_lwjgl_opengl_LinuxKeyboard_openIM() +{ +} + +function Java_org_lwjgl_opengl_LinuxKeyboard_allocateComposeStatus() +{ +} + +function Java_org_lwjgl_opengl_LinuxContextImplementation_nCreate() +{ +} + +function Java_org_lwjgl_opengl_LinuxContextImplementation_nMakeCurrent() +{ +} + +function Java_org_lwjgl_opengl_LinuxContextImplementation_nIsCurrent() +{ + return true; +} + +function Java_org_lwjgl_opengl_GLContext_ngetFunctionAddress(lib, stringPtr) +{ + // Return any non-zero address, methods are called by name anyway + return 1; +} + +function Java_org_lwjgl_opengl_GL11_nglGetString(lib, id, funcPtr) +{ + checkNoList(curList); + // Special case GL_EXTENSION for now + if(id == 0x1F03) + { + // TODO: Do we need any? + return ""; + } + else + { + return glCtx.getParameter(id); + } +} + +function Java_org_lwjgl_opengl_GL11_nglGetIntegerv(lib, id, memPtr, funcPtr) +{ + checkNoList(curList); + var v = lib.getJNIDataView(); + var buf = new Int32Array(v.buffer, Number(memPtr), 4); + if(id == /*GL_VIEWPORT*/0xba2) + { + buf[0] = 0; + buf[1] = 0; + buf[2] = 1000; + buf[3] = 500; + } + else if(verboseLog) + { + console.log("glGetInteger", id); + } +} + +function Java_org_lwjgl_opengl_GL11_nglGetError() +{ + checkNoList(curList); + // We like living dangerously + return 0; +} + +function Java_org_lwjgl_opengl_LinuxContextImplementation_nSetSwapInterval() +{ +} + +function Java_org_lwjgl_opengl_GL11_nglClearColor(lib, r, g, b, a, funcPtr) +{ + checkNoList(curList); + return glCtx.clearColor(r, g, b, a); +} + +function Java_org_lwjgl_opengl_GL11_nglClear(lib, a, funcPtr) +{ + checkNoList(curList); + glCtx.clear(a); +} + +function Java_org_lwjgl_opengl_LinuxContextImplementation_nSwapBuffers() +{ + if(verboseLog) + console.warn("SwapBuffer"); + glCtx.bindFramebuffer(glCtx.DRAW_FRAMEBUFFER, null); + glCtx.blitFramebuffer(0, 0, 1000, 500, 0, 0, 1000, 500, glCtx.COLOR_BUFFER_BIT, glCtx.NEAREST); + glCtx.bindFramebuffer(glCtx.DRAW_FRAMEBUFFER, mainFb); + frameCount++; + if(frameCount == frameLimit) + { + console.warn("Stopping"); + return new Promise(function(){}); + } + return new Promise(function(f, r) + { + requestAnimationFrame(f); + }); +} + +function Java_org_lwjgl_opengl_LinuxEvent_getPending() +{ + return eventQueue.length; +} + +function Java_org_lwjgl_opengl_GL11_nglMatrixMode(lib, matrixMode, funcPtr) +{ + if(curList) + return pushInList(curList, arguments, Java_org_lwjgl_opengl_GL11_nglMatrixMode); + if(matrixMode == 0x1700/*GL_MODELVIEW*/) + curMatrixStack = modelViewMatrixStack; + else if(matrixMode == 0x1701/*GL_PROJECTION*/) + curMatrixStack = projMatrixStack; + else if(matrixMode == 0x1702/*GL_TEXTURE*/) + curMatrixStack = textureMatrixStack; + else + debugger; +} + +function Java_org_lwjgl_opengl_GL11_nglLoadIdentity(lib, funcPtr) +{ + checkNoList(curList); + glMatrix.mat4.identity(getCurMatrixTop()); +} + +function Java_org_lwjgl_opengl_GL11_nglOrtho(lib, left, right, bottom, top, nearVal, farVal, funcPtr) +{ + checkNoList(curList); + var m = getCurMatrixTop(); + var o = glMatrix.mat4.create(); + glMatrix.mat4.ortho(o, left, right, bottom, top, nearVal, farVal); + var out = glMatrix.mat4.create(); + setCurMatrixTop(glMatrix.mat4.multiply(out, m, o)); +} + +function Java_org_lwjgl_opengl_GL11_nglTranslatef(lib, x, y, z, funcPtr) +{ + if(curList) + return pushInList(curList, arguments, Java_org_lwjgl_opengl_GL11_nglTranslatef); + var m = getCurMatrixTop(); + var out = glMatrix.mat4.create(); + setCurMatrixTop(glMatrix.mat4.translate(out, m, glMatrix.vec3.fromValues(x, y, z))); +} + +function Java_org_lwjgl_opengl_GL11_nglViewport(lib, x, y, width, height, funcPtr) +{ + checkNoList(curList); + glCtx.viewport(x, y, width, height); +} + +function Java_org_lwjgl_opengl_GL11_nglDisable(lib, a, funcPtr) +{ + checkNoList(curList); + if(a == glCtx.BLEND || a == glCtx.CULL_FACE || a == glCtx.DEPTH_TEST) + glCtx.disable(a); + else if(a == 0x806F/*GL_TEXTURE_3D*/) + { + glCtx.uniform1f(texMaskLocation, 0); + } + else if(verboseLog) + console.log("glDisable " + a.toString(16)); +} + +function Java_org_lwjgl_opengl_GL11_nglEnable(lib, a, funcPtr) +{ + checkNoList(curList); + if(a == glCtx.BLEND || a == glCtx.CULL_FACE || a == glCtx.DEPTH_TEST) + glCtx.enable(a); + else if(a == 0x806F/*GL_TEXTURE_3D*/) + { + glCtx.uniform1f(texMaskLocation, 1); + } + else if(verboseLog) + console.log("glEnable " + a.toString(16)); +} + +function Java_org_lwjgl_opengl_GL11_nglGenTextures(lib, n, memPtr, funcPtr) +{ + checkNoList(curList); + var v = lib.getJNIDataView(); + var buf = new Int32Array(v.buffer, Number(memPtr), n); + for(var i=0;i immediateModeData.texCoordBuf.length) + { + console.log("glTexCoord2f overflow"); + return; + } + immediateModeData.texCoordBuf[curPos] = x; + immediateModeData.texCoordBuf[curPos + 1] = y; + immediateModeData.texCoordPos = curPos + 2; +} + +function Java_org_lwjgl_opengl_GL11_nglVertex3f(lib, x, y, z, funcPtr) +{ + checkNoList(curList); + var curPos = immediateModeData.vertexPos; + if(curPos > immediateModeData.vertexBuf.length) + { + console.log("glVertex3f overflow"); + return; + } + immediateModeData.vertexBuf[curPos] = x; + immediateModeData.vertexBuf[curPos + 1] = y; + immediateModeData.vertexBuf[curPos + 2] = z; + immediateModeData.vertexPos = curPos + 3; +} + +function Java_org_lwjgl_opengl_GL11_nglEnd(lib, funcPtr) +{ + checkNoList(curList); + // Upload vertex data + uploadDataImpl(immediateModeData.vertexBuf.subarray(0, immediateModeData.vertexPos), vertexBuffer, vertexPosition, 3, glCtx.FLOAT, 3 * 4); + // TODO: Should we do something about color data? + // Upload tex coord data + uploadDataImpl(immediateModeData.texCoordBuf.subarray(0, immediateModeData.texCoordPos), texCoordBuffer, texCoord, 2, glCtx.FLOAT, 2 * 4); + // NOTE: We count vertices + drawArraysImpl(immediateModeData.mode, 0, immediateModeData.vertexPos / 3); +} + +// These stubs make sure audio creation fails sooner rather than later +function Java_org_lwjgl_openal_AL_nCreate() +{ +} + +function Java_org_lwjgl_openal_AL10_initNativeStubs() +{ +} + +function Java_org_lwjgl_openal_ALC10_initNativeStubs() +{ +} + +function Java_org_lwjgl_openal_ALC10_nalcOpenDevice() +{ +} + +function Java_org_lwjgl_openal_AL_resetNativeStubs() +{ +} + +function Java_org_lwjgl_openal_AL_nDestroy() +{ +} + +// Basic input support +async function Java_org_lwjgl_opengl_LinuxEvent_createEventBuffer(lib) +{ + // This is intended to represent a X11 event, but we are free to use any layout + var ByteBuffer = await lib.java.nio.ByteBuffer; + return await ByteBuffer.allocateDirect(4 * 8); +} + +async function Java_org_lwjgl_opengl_LinuxEvent_nNextEvent(lib, windowId, buffer) +{ + // Resolve the address and directly access the JNI memory + var bufferAddr = Number(await buffer.address()); + var v = lib.getJNIDataView(); + var e = eventQueue.shift(); + switch(e.type) + { + case "focus": + v.setInt32(0, /*FocusIn*/9, true); + break; + case "mousedown": + v.setInt32(0, /*ButtonPress*/4, true); + v.setInt32(4, e.x, true); + v.setInt32(8, e.y, true); + v.setInt32(12, e.button, true); + break; + case "mouseup": + v.setInt32(0, /*ButtonRelease*/5, true); + v.setInt32(4, e.x, true); + v.setInt32(8, e.y, true); + v.setInt32(12, e.button, true); + break; + case "mousemove": + v.setInt32(0, /*MotionNotify*/6, true); + v.setInt32(4, e.x, true); + v.setInt32(8, e.y, true); + break; + case "keydown": + v.setInt32(0, /*KeyPress*/2, true); + v.setInt32(4, e.keyCode, true); + break; + case "keyup": + v.setInt32(0, /*KeyRelease*/3, true); + v.setInt32(4, e.keyCode, true); + break; + default: + debugger; + } +} + +function Java_org_lwjgl_opengl_LinuxEvent_nGetWindow() +{ + // Only a single window is emulated + return 0; +} + +async function Java_org_lwjgl_opengl_LinuxEvent_nGetType(lib, buffer) +{ + var bufferAddr = Number(await buffer.address()); + var v = lib.getJNIDataView(); + return v.getInt32(0, true); +} + +function Java_org_lwjgl_opengl_LinuxEvent_nFilterEvent() +{ +} + +function Java_org_lwjgl_opengl_LinuxEvent_nGetButtonTime() +{ + // TODO: Event timestamps +} + +function Java_org_lwjgl_opengl_LinuxEvent_nGetButtonRoot() +{ +} + +async function Java_org_lwjgl_opengl_LinuxEvent_nGetButtonXRoot(lib, buffer) +{ + var bufferAddr = Number(await buffer.address()); + var v = lib.getJNIDataView(); + return v.getInt32(4, true); +} + +async function Java_org_lwjgl_opengl_LinuxEvent_nGetButtonYRoot(lib, buffer) +{ + var bufferAddr = Number(await buffer.address()); + var v = lib.getJNIDataView(); + return v.getInt32(8, true); +} + +async function Java_org_lwjgl_opengl_LinuxEvent_nGetButtonX(lib, buffer) +{ + var bufferAddr = Number(await buffer.address()); + var v = lib.getJNIDataView(); + return v.getInt32(4, true); +} + +async function Java_org_lwjgl_opengl_LinuxEvent_nGetButtonY(lib, buffer) +{ + var bufferAddr = Number(await buffer.address()); + var v = lib.getJNIDataView(); + return v.getInt32(8, true); +} + +function Java_org_lwjgl_opengl_LinuxEvent_nGetFocusDetail() +{ +} + +async function Java_org_lwjgl_opengl_LinuxEvent_nGetButtonType(lib, buffer) +{ + // Same as type, apparently + var bufferAddr = Number(await buffer.address()); + var v = lib.getJNIDataView(); + return v.getInt32(0, true); +} + +async function Java_org_lwjgl_opengl_LinuxEvent_nGetButtonButton(lib, buffer) +{ + const v = lib.getJNIDataView(); + return v.getInt32(12, true); +} + +function Java_org_lwjgl_opengl_LinuxDisplay_nGrabPointer() +{ + glCanvas.requestPointerLock(); + lockedMousePos = { x: 0, y: 0 }; +} + +function Java_org_lwjgl_opengl_LinuxDisplay_nUngrabPointer() +{ + document.exitPointerLock(); + lockedMousePos = null; +} + +function Java_org_lwjgl_opengl_LinuxDisplay_nDefineCursor() +{ +} + +function Java_org_lwjgl_opengl_LinuxMouse_nGetWindowWidth() +{ + return 1000; +} + +function Java_org_lwjgl_opengl_LinuxMouse_nSendWarpEvent() +{ +} + +function Java_org_lwjgl_opengl_LinuxMouse_nWarpCursor() +{ +} + +function Java_org_lwjgl_opengl_LinuxEvent_nSetWindow() +{ +} + +function Java_org_lwjgl_opengl_LinuxEvent_nSendEvent() +{ +} + +async function Java_org_lwjgl_opengl_LinuxEvent_nGetKeyAddress(lib, buffer) +{ + // Should probably be a pointer, cheat and use directly the value + var bufferAddr = Number(await buffer.address()); + var v = lib.getJNIDataView(); + return v.getInt32(4, true); +} + +function Java_org_lwjgl_opengl_LinuxEvent_nGetKeyTime() +{ + // TODO: Event timestamps +} + +async function Java_org_lwjgl_opengl_LinuxEvent_nGetKeyType(lib, buffer) +{ + // Same as type, apparently + var bufferAddr = Number(await buffer.address()); + var v = lib.getJNIDataView(); + return v.getInt32(0, true); +} + +async function Java_org_lwjgl_opengl_LinuxEvent_nGetKeyKeyCode(lib, buffer) +{ + var bufferAddr = Number(await buffer.address()); + var v = lib.getJNIDataView(); + return v.getInt32(4, true); +} + +function Java_org_lwjgl_opengl_LinuxEvent_nGetKeyState() +{ +} + +function Java_org_lwjgl_opengl_LinuxKeyboard_lookupKeysym(lib, eventPtr, index) +{ + return Number(eventPtr); +} + +async function Java_org_lwjgl_opengl_LinuxKeyboard_lookupString(lib, eventPtr, buffer) +{ + // Only support single chars + var bufferAddr = Number(await buffer.address()); + var v = lib.getJNIDataView(); + v.setInt8(bufferAddr, Number(eventPtr)); + return 1; +} + +export default { + Java_org_lwjgl_DefaultSysImplementation_getPointerSize, + Java_org_lwjgl_DefaultSysImplementation_getJNIVersion, + Java_org_lwjgl_DefaultSysImplementation_setDebug, + Java_org_lwjgl_opengl_LinuxDisplay_nLockAWT, + Java_org_lwjgl_opengl_LinuxDisplay_nUnlockAWT, + Java_org_lwjgl_opengl_LinuxDisplay_setErrorHandler, + Java_org_lwjgl_opengl_LinuxDisplay_openDisplay, + Java_org_lwjgl_opengl_LinuxDisplay_nInternAtom, + Java_org_lwjgl_opengl_LinuxDisplay_nIsXrandrSupported, + Java_org_lwjgl_opengl_LinuxDisplay_nIsXF86VidModeSupported, + Java_org_lwjgl_opengl_LinuxDisplay_nGetDefaultScreen, + Java_org_lwjgl_opengl_LinuxDisplay_nGetAvailableDisplayModes, + Java_org_lwjgl_opengl_LinuxDisplay_nGetCurrentGammaRamp, + Java_org_lwjgl_opengl_LinuxPeerInfo_createHandle, + Java_org_lwjgl_opengl_GLContext_nLoadOpenGLLibrary, + Java_org_lwjgl_opengl_LinuxDisplayPeerInfo_initDefaultPeerInfo, + Java_org_lwjgl_opengl_LinuxDisplayPeerInfo_initDrawable, + Java_org_lwjgl_opengl_AWTSurfaceLock_createHandle, + Java_org_lwjgl_opengl_AWTSurfaceLock_lockAndInitHandle, + Java_org_lwjgl_opengl_LinuxAWTGLCanvasPeerInfo_getScreenFromSurfaceInfo, + Java_org_lwjgl_opengl_LinuxAWTGLCanvasPeerInfo_nInitHandle, + Java_org_lwjgl_opengl_AWTSurfaceLock_nUnlock, + Java_org_lwjgl_opengl_LinuxPeerInfo_nGetDrawable, + Java_org_lwjgl_opengl_LinuxDisplay_nCreateWindow, + Java_org_lwjgl_opengl_LinuxDisplay_mapRaised, + Java_org_lwjgl_opengl_LinuxDisplay_nCreateBlankCursor, + Java_org_lwjgl_opengl_LinuxDisplay_nSetTitle, + Java_org_lwjgl_opengl_LinuxMouse_nGetButtonCount, + Java_org_lwjgl_opengl_LinuxMouse_nQueryPointer, + Java_org_lwjgl_opengl_LinuxMouse_nGetWindowHeight, + Java_org_lwjgl_opengl_LinuxKeyboard_getModifierMapping, + Java_org_lwjgl_opengl_LinuxKeyboard_nSetDetectableKeyRepeat, + Java_org_lwjgl_opengl_LinuxKeyboard_openIM, + Java_org_lwjgl_opengl_LinuxKeyboard_allocateComposeStatus, + Java_org_lwjgl_opengl_LinuxContextImplementation_nCreate, + Java_org_lwjgl_opengl_LinuxContextImplementation_nMakeCurrent, + Java_org_lwjgl_opengl_LinuxContextImplementation_nIsCurrent, + Java_org_lwjgl_opengl_GLContext_ngetFunctionAddress, + Java_org_lwjgl_opengl_GL11_nglGetString, + Java_org_lwjgl_opengl_GL11_nglGetIntegerv, + Java_org_lwjgl_opengl_GL11_nglGetError, + Java_org_lwjgl_opengl_LinuxContextImplementation_nSetSwapInterval, + Java_org_lwjgl_opengl_GL11_nglClearColor, + Java_org_lwjgl_opengl_GL11_nglClear, + Java_org_lwjgl_opengl_LinuxContextImplementation_nSwapBuffers, + Java_org_lwjgl_opengl_LinuxEvent_getPending, + Java_org_lwjgl_opengl_GL11_nglMatrixMode, + Java_org_lwjgl_opengl_GL11_nglLoadIdentity, + Java_org_lwjgl_opengl_GL11_nglOrtho, + Java_org_lwjgl_opengl_GL11_nglTranslatef, + Java_org_lwjgl_opengl_GL11_nglViewport, + Java_org_lwjgl_opengl_GL11_nglDisable, + Java_org_lwjgl_opengl_GL11_nglEnable, + Java_org_lwjgl_opengl_GL11_nglGenTextures, + Java_org_lwjgl_opengl_GL11_nglBindTexture, + Java_org_lwjgl_opengl_GL11_nglTexParameteri, + Java_org_lwjgl_opengl_GL11_nglTexImage2D, + Java_org_lwjgl_opengl_GL11_nglTexCoordPointer, + Java_org_lwjgl_opengl_GL11_nglEnableClientState, + Java_org_lwjgl_opengl_GL11_nglColorPointer, + Java_org_lwjgl_opengl_GL11_nglVertexPointer, + Java_org_lwjgl_opengl_GL11_nglDrawArrays, + Java_org_lwjgl_opengl_GL11_nglDisableClientState, + Java_org_lwjgl_opengl_GL11_nglColor4f, + Java_org_lwjgl_opengl_GL11_nglAlphaFunc, + Java_org_lwjgl_opengl_GL11_nglGenLists, + Java_org_lwjgl_opengl_GL11_nglNewList, + Java_org_lwjgl_opengl_GL11_nglEndList, + Java_org_lwjgl_opengl_GL11_nglColor3f, + Java_org_lwjgl_opengl_LinuxDisplay_nGetNativeCursorCapabilities, + Java_org_lwjgl_opengl_GL11_nglShadeModel, + Java_org_lwjgl_opengl_GL11_nglClearDepth, + Java_org_lwjgl_opengl_GL11_nglDepthFunc, + Java_org_lwjgl_opengl_GL11_nglCullFace, + Java_org_lwjgl_opengl_GL11_nglPushMatrix, + Java_org_lwjgl_opengl_GL11_nglPopMatrix, + Java_org_lwjgl_opengl_GL11_nglMultMatrixf, + Java_org_lwjgl_opengl_GL11_nglRotatef, + Java_org_lwjgl_opengl_GL11_nglDepthMask, + Java_org_lwjgl_opengl_GL11_nglBlendFunc, + Java_org_lwjgl_opengl_GL11_nglColorMask, + Java_org_lwjgl_opengl_GL11_nglCopyTexSubImage2D, + Java_org_lwjgl_opengl_GL11_nglScalef, + Java_org_lwjgl_opengl_GL11_nglCallLists, + Java_org_lwjgl_opengl_GL11_nglFlush, + Java_org_lwjgl_opengl_GL11_nglTexSubImage2D, + Java_org_lwjgl_opengl_GL11_nglGetFloatv, + Java_org_lwjgl_opengl_GL11_nglFogfv, + Java_org_lwjgl_opengl_GL11_nglNormal3f, + Java_org_lwjgl_opengl_GL11_nglFogi, + Java_org_lwjgl_opengl_GL11_nglFogf, + Java_org_lwjgl_opengl_GL11_nglColorMaterial, + Java_org_lwjgl_opengl_GL11_nglCallList, + Java_org_lwjgl_opengl_GL13_nglActiveTexture, + Java_org_lwjgl_opengl_GL11_nglLightfv, + Java_org_lwjgl_opengl_GL11_nglLightModelfv, + Java_org_lwjgl_opengl_GL11_nglNormalPointer, + Java_org_lwjgl_opengl_GL13_nglMultiTexCoord2f, + Java_org_lwjgl_opengl_GL13_nglClientActiveTexture, + Java_org_lwjgl_opengl_GL11_nglLineWidth, + Java_org_lwjgl_opengl_GL11_nglPolygonOffset, + Java_org_lwjgl_opengl_GL11_nglBegin, + Java_org_lwjgl_opengl_GL11_nglTexCoord2f, + Java_org_lwjgl_opengl_GL11_nglVertex3f, + Java_org_lwjgl_opengl_GL11_nglEnd, + Java_org_lwjgl_openal_AL_nCreate, + Java_org_lwjgl_openal_AL10_initNativeStubs, + Java_org_lwjgl_openal_ALC10_initNativeStubs, + Java_org_lwjgl_openal_ALC10_nalcOpenDevice, + Java_org_lwjgl_openal_AL_resetNativeStubs, + Java_org_lwjgl_openal_AL_nDestroy, + Java_org_lwjgl_opengl_LinuxEvent_createEventBuffer, + Java_org_lwjgl_opengl_LinuxEvent_nNextEvent, + Java_org_lwjgl_opengl_LinuxEvent_nGetWindow, + Java_org_lwjgl_opengl_LinuxEvent_nGetType, + Java_org_lwjgl_opengl_LinuxEvent_nFilterEvent, + Java_org_lwjgl_opengl_LinuxEvent_nGetButtonTime, + Java_org_lwjgl_opengl_LinuxEvent_nGetButtonRoot, + Java_org_lwjgl_opengl_LinuxEvent_nGetButtonXRoot, + Java_org_lwjgl_opengl_LinuxEvent_nGetButtonYRoot, + Java_org_lwjgl_opengl_LinuxEvent_nGetButtonX, + Java_org_lwjgl_opengl_LinuxEvent_nGetButtonY, + Java_org_lwjgl_opengl_LinuxEvent_nGetFocusDetail, + Java_org_lwjgl_opengl_LinuxEvent_nGetButtonType, + Java_org_lwjgl_opengl_LinuxEvent_nGetButtonButton, + Java_org_lwjgl_opengl_LinuxDisplay_nGrabPointer, + Java_org_lwjgl_opengl_LinuxDisplay_nUngrabPointer, + Java_org_lwjgl_opengl_LinuxDisplay_nDefineCursor, + Java_org_lwjgl_opengl_LinuxMouse_nGetWindowWidth, + Java_org_lwjgl_opengl_LinuxMouse_nSendWarpEvent, + Java_org_lwjgl_opengl_LinuxMouse_nWarpCursor, + Java_org_lwjgl_opengl_LinuxEvent_nSetWindow, + Java_org_lwjgl_opengl_LinuxEvent_nSendEvent, + Java_org_lwjgl_opengl_LinuxEvent_nGetKeyAddress, + Java_org_lwjgl_opengl_LinuxEvent_nGetKeyTime, + Java_org_lwjgl_opengl_LinuxEvent_nGetKeyType, + Java_org_lwjgl_opengl_LinuxEvent_nGetKeyKeyCode, + Java_org_lwjgl_opengl_LinuxEvent_nGetKeyState, + Java_org_lwjgl_opengl_LinuxKeyboard_lookupKeysym, + Java_org_lwjgl_opengl_LinuxKeyboard_lookupString, +} \ No newline at end of file