jvmMain.earth.worldwind.util.kgl.JoglKgl.kt Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of worldwind-jvm Show documentation
The WorldWind Kotlin SDK (WWK) includes the library, examples and tutorials for building multiplatform 3D virtual globe applications for Android, Web and Java.
The newest version!
package earth.worldwind.util.kgl

import com.jogamp.opengl.GL3ES3
import java.nio.ByteBuffer
import java.nio.FloatBuffer
import java.nio.IntBuffer
import java.nio.ShortBuffer

class JoglKgl(private val gl: GL3ES3) : Kgl {
    private val arrI = IntArray(16)
    private val arrF = FloatArray(16)

    override val hasMaliOOMBug = false

    override fun getParameteri(pname: Int): Int {
        gl.glGetIntegerv(pname, arrI, 0)
        return arrI[0]
    }

    override fun getParameterf(pname: Int): Float {
        gl.glGetFloatv(pname, arrF, 0)
        return arrF[0]
    }

    override fun getParameteriv(pname: Int): IntArray {
        gl.glGetIntegerv(pname, arrI, 0)
        return arrI
    }

    override fun getParameterfv(pname: Int): FloatArray {
        gl.glGetFloatv(pname, arrF, 0)
        return arrF
    }

    override fun createShader(type: Int) = KglShader(gl.glCreateShader(type))

    override fun shaderSource(shader: KglShader, source: String) {
        arrI[0] = source.length
        gl.glShaderSource(shader.id, 1, arrayOf(source), IntBuffer.wrap(arrI))
    }

    override fun compileShader(shader: KglShader) = gl.glCompileShader(shader.id)

    override fun deleteShader(shader: KglShader) = gl.glDeleteShader(shader.id)

    override fun getShaderParameteri(shader: KglShader, pname: Int): Int {
        gl.glGetShaderiv(shader.id, pname, arrI, 0)
        return arrI[0]
    }

    override fun getProgramInfoLog(program: KglProgram): String {
        val bufSize = 1024
        val buffer = ByteArray(bufSize)
        gl.glGetProgramInfoLog(program.id, bufSize, arrI, 0, buffer, 0)
        return buffer.decodeToString(0, arrI[0])
    }

    override fun getShaderInfoLog(shader: KglShader): String {
        val bufSize = 1024
        val buffer = ByteArray(bufSize)
        gl.glGetShaderInfoLog(shader.id, bufSize, arrI, 0, buffer, 0)
        return buffer.decodeToString(0, arrI[0])
    }

    override fun createProgram() = KglProgram(gl.glCreateProgram())

    override fun deleteProgram(program: KglProgram) = gl.glDeleteShader(program.id)

    override fun attachShader(program: KglProgram, shader: KglShader) = gl.glAttachShader(program.id, shader.id)

    override fun linkProgram(program: KglProgram) = gl.glLinkProgram(program.id)

    override fun useProgram(program: KglProgram) = gl.glUseProgram(program.id)

    override fun getProgramParameteri(program: KglProgram, pname: Int): Int {
        gl.glGetProgramiv(program.id, pname, arrI, 0)
        return arrI[0]
    }

    override fun getUniformLocation(program: KglProgram, name: String) =
        KglUniformLocation(gl.glGetUniformLocation(program.id, name))

    override fun bindAttribLocation(program: KglProgram, index: Int, name: String) =
        gl.glBindAttribLocation(program.id, index, name)

    override fun createBuffer(): KglBuffer {
        gl.glGenBuffers(1, arrI, 0)
        return KglBuffer(arrI[0])
    }

    override fun bindBuffer(target: Int, buffer: KglBuffer) = gl.glBindBuffer(target, buffer.id)

    override fun bufferData(target: Int, size: Int, sourceData: ShortArray?, usage: Int, offset: Int) =
        gl.glBufferData(target, size.toLong(), sourceData?.let { ShortBuffer.wrap(it, offset, sourceData.size - offset) }, usage)

    override fun bufferData(target: Int, size: Int, sourceData: IntArray?, usage: Int, offset: Int) =
        gl.glBufferData(target, size.toLong(), sourceData?.let { IntBuffer.wrap(it, offset, sourceData.size - offset) }, usage)

    override fun bufferData(target: Int, size: Int, sourceData: FloatArray?, usage: Int, offset: Int) =
        gl.glBufferData(target, size.toLong(), sourceData?.let { FloatBuffer.wrap(it, offset, sourceData.size - offset) }, usage)

    override fun bufferSubData(target: Int, offset: Int, size: Int, sourceData: ShortArray) =
        gl.glBufferSubData(target, offset.toLong(), size.toLong(), ShortBuffer.wrap(sourceData, 0, size / 2))

    override fun bufferSubData(target: Int, offset: Int, size: Int, sourceData: IntArray) =
        gl.glBufferSubData(target, offset.toLong(), size.toLong(), IntBuffer.wrap(sourceData, 0, size / 4))

    override fun bufferSubData(target: Int, offset: Int, size: Int, sourceData: FloatArray) =
        gl.glBufferSubData(target, offset.toLong(), size.toLong(), FloatBuffer.wrap(sourceData, 0, size / 4))

    override fun deleteBuffer(buffer: KglBuffer) {
        arrI[0] = buffer.id
        gl.glDeleteBuffers(1, arrI, 0)
    }

    override fun vertexAttribPointer(
        location: Int, size: Int, type: Int, normalized: Boolean, stride: Int, offset: Int
    ) = gl.glVertexAttribPointer(location, size, type, normalized, stride, offset.toLong())

    override fun enableVertexAttribArray(location: Int) = gl.glEnableVertexAttribArray(location)

    override fun disableVertexAttribArray(location: Int) = gl.glDisableVertexAttribArray(location)

    override fun enable(cap: Int) = gl.glEnable(cap)

    override fun disable(cap: Int) = gl.glDisable(cap)

    override fun uniform1f(location: KglUniformLocation, f: Float) = gl.glUniform1f(location.id, f)

    override fun uniform1fv(location: KglUniformLocation, count: Int, value: FloatArray, offset: Int) = gl.glUniform1fv(location.id, count, value, offset)

    override fun uniform1i(location: KglUniformLocation, i: Int) = gl.glUniform1i(location.id, i)

    override fun uniform2f(location: KglUniformLocation, x: Float, y: Float) = gl.glUniform2f(location.id, x, y)

    override fun uniform2fv(location: KglUniformLocation, count: Int, value: FloatArray, offset: Int) = gl.glUniform2fv(location.id, count, value, offset)

    override fun uniform2i(location: KglUniformLocation, x: Int, y: Int) = gl.glUniform2i(location.id, x, y)

    override fun uniform3f(location: KglUniformLocation, x: Float, y: Float, z: Float) = gl.glUniform3f(location.id, x, y, z)

    override fun uniform3fv(location: KglUniformLocation, count: Int, value: FloatArray, offset: Int) = gl.glUniform3fv(location.id, count, value, offset)

    override fun uniform3i(location: KglUniformLocation, x: Int, y: Int, z: Int) = gl.glUniform3i(location.id, x, y, z)

    override fun uniform4f(location: KglUniformLocation, x: Float, y: Float, z: Float, w: Float) = gl.glUniform4f(location.id, x, y, z, w)

    override fun uniform4fv(location: KglUniformLocation, count: Int, value: FloatArray, offset: Int) = gl.glUniform4fv(location.id, count, value, offset)

    override fun uniform4i(location: KglUniformLocation, x: Int, y: Int, z: Int, w: Int) = gl.glUniform4i(location.id, x, y, z, w)

    override fun uniformMatrix3fv(location: KglUniformLocation, count: Int, transpose: Boolean, value: FloatArray, offset: Int) =
        gl.glUniformMatrix3fv(location.id, count, transpose, value, offset)

    override fun uniformMatrix4fv(location: KglUniformLocation, count: Int, transpose: Boolean, value: FloatArray, offset: Int) =
        gl.glUniformMatrix4fv(location.id, count, transpose, value, offset)

    override fun lineWidth(width: Float) = gl.glLineWidth(width)

    override fun polygonOffset(factor: Float, units: Float) = gl.glPolygonOffset(factor, units)

    override fun cullFace(mode: Int) = gl.glCullFace(mode)

    override fun frontFace(mode: Int) = gl.glFrontFace(mode)

    override fun depthFunc(func: Int) = gl.glDepthFunc(func)

    override fun depthMask(mask: Boolean) = gl.glDepthMask(mask)

    override fun blendFunc(sFactor: Int, dFactor: Int) = gl.glBlendFunc(sFactor, dFactor)

    override fun colorMask(r: Boolean, g: Boolean, b: Boolean, a: Boolean) = gl.glColorMask(r, g, b, a)

    override fun viewport(x: Int, y: Int, width: Int, height: Int) = gl.glViewport(x, y, width, height)

    override fun clear(mask: Int) = gl.glClear(mask)

    override fun clearColor(r: Float, g: Float, b: Float, a: Float) = gl.glClearColor(r, g, b, a)

    override fun createTexture(): KglTexture {
        gl.glGenTextures(1, arrI, 0)
        return KglTexture(arrI[0])
    }

    override fun deleteTexture(texture: KglTexture) {
        arrI[0] = texture.id
        gl.glDeleteTextures(1, arrI, 0)
    }

    override fun texImage2D(
        target: Int, level: Int, internalFormat: Int, width: Int, height: Int, border: Int, format: Int, type: Int, buffer: ByteArray?
    ) = gl.glTexImage2D(target, level, internalFormat, width, height, border, format, type, buffer?.let { ByteBuffer.wrap(it) })

    override fun activeTexture(texture: Int) = gl.glActiveTexture(texture)

    override fun bindTexture(target: Int, texture: KglTexture) = gl.glBindTexture(target, texture.id)

    override fun generateMipmap(target: Int) = gl.glGenerateMipmap(target)

    override fun texParameteri(target: Int, pname: Int, value: Int) = gl.glTexParameteri(target, pname, value)

    override fun drawArrays(mode: Int, first: Int, count: Int) = gl.glDrawArrays(mode, first, count)

    override fun drawElements(mode: Int, count: Int, type: Int, offset: Int) = gl.glDrawElements(mode, count, type, offset.toLong())

    override fun getError() = gl.glGetError()

    override fun finish() = gl.glFinish()

    override fun bindFramebuffer(target: Int, framebuffer: KglFramebuffer) = gl.glBindFramebuffer(target, framebuffer.id)

    override fun createFramebuffer(): KglFramebuffer {
        gl.glGenFramebuffers(1, arrI, 0)
        return KglFramebuffer(arrI[0])
    }

    override fun deleteFramebuffer(framebuffer: KglFramebuffer) {
        arrI[0] = framebuffer.id
        gl.glDeleteFramebuffers(1, arrI, 0)
    }

    override fun checkFramebufferStatus(target: Int) = gl.glCheckFramebufferStatus(target)

    override fun framebufferTexture2D(target: Int, attachment: Int, textarget: Int, texture: KglTexture, level: Int) =
        gl.glFramebufferTexture2D(target, attachment, textarget, texture.id, level)

    override fun readPixels(
        x: Int, y: Int, width: Int, height: Int, format: Int, type: Int, buffer: ByteArray
    ) = gl.glReadPixels(x, y, width, height, format, type, ByteBuffer.wrap(buffer))

    override fun pixelStorei(pname: Int, param: Int) = gl.glPixelStorei(pname, param)
}