Rename ByteBuffer to DirectMemory

buildSrc/src/main/kotlin/codegen/Types.kt

@@ -20,7 +20,7 @@ import com.squareup.kotlinpoet.MemberName
 
 
 internal val VIRTUAL_STACK = ClassName("com.kgl.core", "VirtualStack")
-internal val BYTE_BUFFER = ClassName("com.kgl.core", "ByteBuffer")
+internal val DIRECT_BUFFER = ClassName("com.kgl.core", "DirectMemory")
 internal val C_OPAQUE_POINTER = ClassName("kotlinx.cinterop", "COpaquePointer")
 internal val BYTE_VAR = ClassName("kotlinx.cinterop", "ByteVar")
 

buildSrc/src/main/kotlin/codegen/vulkan/GenerateVulkan.kt

@@ -845,7 +845,7 @@ open class GenerateVulkan : DefaultTask() {
 					1 -> {
 						when(typeName) {
 							"char" -> STRING
-							"void" -> if (len.isNotEmpty()) BYTE_BUFFER else LONG
+							"void" -> if (len.isNotEmpty()) DIRECT_BUFFER else LONG
 							else -> {
 								val mainType = kglClassMap[typeName] ?: TODO("$type has no KGL representation.")
 								arrayClassesMap[typeName] ?: collectionType.parameterizedBy(mainType)
@@ -1458,7 +1458,7 @@ open class GenerateVulkan : DefaultTask() {
 									}
 									val isOptional = member.optional || lengthParam?.optional == true
 									if (lengthParam != null) {
-										addParameter(memberNameKt, BYTE_BUFFER.copy(nullable = isOptional))
+										addParameter(memberNameKt, DIRECT_BUFFER.copy(nullable = isOptional))
 
 										val assert = if (isOptional) "?" else ""
 										if (platform == Platform.JVM) {

kgl-core/src/commonMain/kotlin/com/kgl/core/DirectMemory.kt

@@ -0,0 +1,20 @@
+package com.kgl.core
+
+expect class DirectMemory {
+	val size: Long
+
+	operator fun get(offset: Long): Byte
+	operator fun set(offset: Long, value: Byte)
+
+	fun get(dst: ByteArray, srcOffset: Long = 0L, dstOffset: Long = 0L, length: Long = dst.size.toLong())
+	fun set(src: ByteArray, srcOffset: Long = 0L, dstOffset: Long = 0L, length: Long = src.size.toLong())
+
+	fun copyTo(dst: DirectMemory, srcOffset: Long = 0L, dstOffset: Long = 0L, length: Long = dst.size - dstOffset)
+	fun slice(offset: Long, length: Long): DirectMemory
+}
+
+@Suppress("NOTHING_TO_INLINE")
+internal inline fun DirectMemory.checkBounds(offset: Long, length: Long) {
+	require(offset in 0 until this.size)
+	require(length in 0 until (this.size - offset))
+}

kgl-core/src/commonMain/kotlin/com/kgl/core/MemUtils.kt

@@ -0,0 +1,4 @@
+package com.kgl.core
+
+
+expect inline fun <T> withMemory(length: Long, block: (DirectMemory) -> T): T

kgl-core/src/jsMain/kotlin/com/kgl/core/DirectMemory.kt

@@ -0,0 +1,42 @@
+package com.kgl.core
+
+import org.khronos.webgl.DataView
+
+actual class DirectMemory(private val ptr: DataView) {
+	actual val size: Long get() = ptr.byteLength.toLong()
+
+	actual operator fun get(offset: Long): Byte {
+		return ptr.getInt8(offset.toInt())
+	}
+
+	actual operator fun set(offset: Long, value: Byte) {
+		ptr.setInt8(offset.toInt(), value)
+	}
+
+	actual fun get(dst: ByteArray, srcOffset: Long, dstOffset: Long, length: Long) {
+		checkBounds(srcOffset, length)
+		for (i in 0 until length) {
+			dst[(dstOffset + i).toInt()] = get(srcOffset + i)
+		}
+	}
+
+	actual fun set(src: ByteArray, srcOffset: Long, dstOffset: Long, length: Long) {
+		checkBounds(dstOffset, length)
+		for (i in 0 until length) {
+			this[dstOffset + i] = src[(srcOffset + i).toInt()]
+		}
+	}
+
+	actual fun copyTo(dst: DirectMemory, srcOffset: Long, dstOffset: Long, length: Long) {
+		checkBounds(srcOffset, length)
+		dst.checkBounds(dstOffset, length)
+		for (i in 0 until length) {
+			dst[dstOffset + i] = get(srcOffset + i)
+		}
+	}
+
+	actual fun slice(offset: Long, length: Long): DirectMemory {
+		checkBounds(offset, length)
+		return DirectMemory(DataView(ptr.buffer, ptr.byteOffset + offset.toInt(), length.toInt()))
+	}
+}

kgl-core/src/jsMain/kotlin/com/kgl/core/MemUtils.kt

@@ -0,0 +1,11 @@
+package com.kgl.core
+
+import org.khronos.webgl.DataView
+import org.khronos.webgl.Int8Array
+
+actual inline fun <T> withMemory(length: Long, block: (DirectMemory) -> T): T {
+	val array = ByteArray(length.toInt())
+	val jsArray = array.unsafeCast<Int8Array>()
+	val view = DataView(jsArray.buffer, jsArray.byteOffset, jsArray.byteLength)
+	return block(DirectMemory(view))
+}

kgl-core/src/jvmMain/kotlin/com/kgl/core/DirectMemory.kt

@@ -0,0 +1,50 @@
+package com.kgl.core
+
+import org.lwjgl.system.MemoryUtil
+import org.lwjgl.system.jni.JNINativeInterface
+import java.nio.ByteBuffer as JvmByteBuffer
+
+actual class DirectMemory(private val ptr: Long, actual val size: Long) {
+
+	constructor(buffer: JvmByteBuffer) : this(MemoryUtil.memAddress(buffer), buffer.capacity().toLong())
+
+	actual operator fun get(offset: Long): Byte {
+		return MemoryUtil.memGetByte(ptr + (offset * Byte.SIZE_BYTES))
+	}
+
+	actual operator fun set(offset: Long, value: Byte) {
+		MemoryUtil.memPutByte(ptr + (offset * Byte.SIZE_BYTES), value)
+	}
+
+	actual fun get(dst: ByteArray, srcOffset: Long, dstOffset: Long, length: Long) {
+		checkBounds(srcOffset, length)
+
+		JNINativeInterface.nSetByteArrayRegion(dst, dstOffset.toInt(), length.toInt(), ptr + (srcOffset * Byte.SIZE_BYTES))
+	}
+
+	actual fun set(src: ByteArray, srcOffset: Long, dstOffset: Long, length: Long) {
+		checkBounds(dstOffset, length)
+		JNINativeInterface.nGetByteArrayRegion(src, srcOffset.toInt(), length.toInt(), ptr + (dstOffset * Byte.SIZE_BYTES))
+	}
+
+	actual fun copyTo(dst: DirectMemory, srcOffset: Long, dstOffset: Long, length: Long) {
+		checkBounds(srcOffset, length)
+		dst.checkBounds(dstOffset, length)
+
+		MemoryUtil.memCopy(
+				ptr + (srcOffset * Byte.SIZE_BYTES),
+				dst.ptr + (dstOffset * Byte.SIZE_BYTES),
+				length
+		)
+	}
+
+	actual fun slice(offset: Long, length: Long): DirectMemory {
+		checkBounds(offset, length)
+
+		return DirectMemory(ptr + (offset * Byte.SIZE_BYTES), length)
+	}
+
+	fun asJvmByteBuffer(): JvmByteBuffer {
+		return MemoryUtil.memByteBuffer(ptr, size.toInt())
+	}
+}

kgl-core/src/jvmMain/kotlin/com/kgl/core/BufferUtils.kt → kgl-core/src/jvmMain/kotlin/com/kgl/core/MemUtils.kt

@@ -3,10 +3,10 @@ package com.kgl.core
 import org.lwjgl.system.MemoryUtil
 
 
-actual inline fun <T> withByteBuffer(length: Long, block: (ByteBuffer) -> T): T {
+actual inline fun <T> withMemory(length: Long, block: (DirectMemory) -> T): T {
 	val jvmBuffer = MemoryUtil.memAlloc(length.toInt())
 	try {
-		return block(ByteBuffer(jvmBuffer))
+		return block(DirectMemory(jvmBuffer))
 	} finally {
 		MemoryUtil.memFree(jvmBuffer)
 	}