Create TRI(Turbo Render Interface)

Author: slmpc

build.gradle.kts

@@ -1,5 +1,7 @@
 @file:Suppress("PropertyName")
 
+import org.slf4j.event.Level
+
 plugins {
     id("java-library")
     id("maven-publish")
@@ -30,15 +32,17 @@ val parchment_minecraft_version: String by project
 version = mod_version
 group = mod_group_id
 
+val library: Configuration by configurations.creating {
+    configurations.implementation.get().extendsFrom(this)
+}
+
 repositories {
     // Add here additional repositories if required
     mavenCentral()
     mavenLocal()
 
-    maven {
-        name = "Kotlin for Forge"
-        url = uri("https://thedarkcolour.github.io/KotlinForForge/")
-    }
+    maven("https://thedarkcolour.github.io/KotlinForForge/")
+    maven("https://maven.luna5ama.dev/")
 }
 
 base {
@@ -80,7 +84,7 @@ neoForge {
 
         configureEach {
             systemProperty("forge.logging.markers", "REGISTRIES")
-            logLevel = org.slf4j.event.Level.DEBUG
+            logLevel = Level.DEBUG
         }
 
     }
@@ -104,8 +108,14 @@ configurations {
 }
 
 dependencies {
-    // Add dependencies here
     implementation("thedarkcolour:kotlinforforge-neoforge:5.9.0")
+
+    library("dev.luna5ama:kmogus-core:1.1-SNAPSHOT") {
+        exclude("org.jetbrains.kotlin", "kotlin-stdlib")
+    }
+    library("dev.luna5ama:kmogus-struct-api:1.1-SNAPSHOT") {
+        exclude("org.jetbrains.kotlin", "kotlin-stdlib")
+    }
 }
 
 val generateModMetadata by tasks.registering(ProcessResources::class) {
@@ -129,6 +139,7 @@ val generateModMetadata by tasks.registering(ProcessResources::class) {
 }
 
 sourceSets["main"].resources.srcDir(generateModMetadata)
+sourceSets["main"].compileClasspath += library
 
 neoForge.ideSyncTask(generateModMetadata)
 
@@ -145,6 +156,14 @@ publishing {
     }
 }
 
+tasks.jar {
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+
+    from(library.map { if (it.isDirectory) it else zipTree(it) })
+
+    exclude("META-INF/*.RSA", "META-INF/*.DSA", "META-INF/*.SF")
+}
+
 tasks.withType<JavaCompile>().configureEach {
     options.encoding = "UTF-8"
 }
@@ -155,3 +174,4 @@ idea {
         isDownloadJavadoc = true
     }
 }
+

src/main/kotlin/com/github/turboscript/TurboScript.kt

@@ -1,13 +1,21 @@
 package com.github.turboscript
 
 import com.github.turboscript.config.Configs
+import com.github.turboscript.graphics.TRenderSystem
+import com.github.turboscript.gui.ConfigGUI
+import com.mojang.blaze3d.platform.InputConstants
 import com.mojang.logging.LogUtils
+import net.minecraft.client.KeyMapping
 import net.neoforged.api.distmarker.Dist
 import net.neoforged.bus.api.IEventBus
 import net.neoforged.fml.ModContainer
 import net.neoforged.fml.common.Mod
 import net.neoforged.fml.config.ModConfig
 import net.neoforged.fml.event.lifecycle.FMLCommonSetupEvent
+import net.neoforged.neoforge.client.event.RegisterKeyMappingsEvent
+import net.neoforged.neoforge.client.settings.KeyConflictContext
+import net.neoforged.neoforge.common.NeoForge
+import org.lwjgl.glfw.GLFW
 import org.slf4j.Logger
 
 @Mod(TurboScript.MOD_ID, dist = [Dist.CLIENT])
@@ -16,23 +24,35 @@ class TurboScript(
     modContainer: ModContainer
 ) {
 
-    init {
-        NAMESPACE = modContainer.namespace
-        modEventBus.addListener(this::commonSetup)
+    companion object {
 
-        modContainer.registerConfig(ModConfig.Type.COMMON, Configs.spec)
-        JavaWrapper.registerExtensionPointConfig(modContainer)
-    }
+        internal const val MOD_ID = "turboscript"
+        internal val LOGGER: Logger = LogUtils.getLogger()
+
+        internal val uiKey by lazy { KeyMapping(
+            "turboscript.key.ui",
+            KeyConflictContext.IN_GAME,
+            InputConstants.Type.KEYSYM,
+            GLFW.GLFW_KEY_Y,
+            "key.categories.misc"
+        ) }
 
-    private fun commonSetup(event: FMLCommonSetupEvent) {
-        LOGGER.info("TurboScript is running!")
     }
 
-    companion object {
+    init {
+        modEventBus.addListener<FMLCommonSetupEvent> {
+            LOGGER.info("TurboScript is running!")
+        }
 
-        internal const val MOD_ID = "turboscript"
-        internal val LOGGER: Logger = LogUtils.getLogger()
-        internal lateinit var NAMESPACE: String; private set
+        modEventBus.addListener<RegisterKeyMappingsEvent> { event ->
+            event.register(uiKey)
+        }
 
+        NeoForge.EVENT_BUS.register(TRenderSystem)
+        NeoForge.EVENT_BUS.register(ConfigGUI)
+
+        modContainer.registerConfig(ModConfig.Type.COMMON, Configs.spec)
+        JavaWrapper.registerExtensionPointConfig(modContainer)
     }
+
 }

src/main/kotlin/com/github/turboscript/graphics/IRenderFunctions.kt

@@ -0,0 +1,9 @@
+package com.github.turboscript.graphics
+
+interface IRenderFunctions {
+
+    fun beginRender()
+
+    fun endRender()
+
+}

src/main/kotlin/com/github/turboscript/graphics/RenderContext.kt

@@ -0,0 +1,11 @@
+package com.github.turboscript.graphics
+
+class RenderContext {
+
+    companion object {
+
+        internal var instance: RenderContext? = null
+
+    }
+
+}

src/main/kotlin/com/github/turboscript/graphics/TRenderSystem.kt

@@ -2,23 +2,39 @@ package com.github.turboscript.graphics
 
 import com.github.turboscript.config.Configs
 import com.github.turboscript.config.RenderApi
-import com.github.turboscript.graphics.ogl.TOpenGlRenderSystem
+import com.github.turboscript.graphics.ogl.GlRenderFunctions
+import com.github.turboscript.graphics.IRenderFunctions
+import net.neoforged.bus.api.SubscribeEvent
+import net.neoforged.neoforge.client.event.RenderGuiEvent
 
 object TRenderSystem {
 
     internal val renderApi: RenderApi
         get() = Configs.get().renderApi.get()
 
-    internal fun beginRender() {
-        when (renderApi) {
-            RenderApi.OPENGL -> TOpenGlRenderSystem.beginRender()
-        }
+    private var renderFunctions: MutableMap<RenderApi, IRenderFunctions> = mutableMapOf()
+    private val currentRenderFunctions get() = renderFunctions[renderApi]
+
+    internal fun render(func: RenderContext.() -> Unit) {
+        beginRender()
+        RenderContext.instance?.let { func.invoke(it) }
+        endRender()
     }
 
-    internal fun endRender() {
-        when (renderApi) {
-            RenderApi.OPENGL -> TOpenGlRenderSystem.endRender()
+    @SubscribeEvent
+    fun onPreRenderGui(event: RenderGuiEvent.Pre) {
+        refreshRenderFunctions()
+    }
+
+    private fun refreshRenderFunctions() {
+        renderFunctions[renderApi]?.let { return }
+        renderFunctions.clear()
+        renderFunctions[renderApi] = when (renderApi) {
+            RenderApi.OPENGL -> GlRenderFunctions
         }
     }
 
+    private fun beginRender() { currentRenderFunctions?.beginRender() }
+    private fun endRender() { currentRenderFunctions?.endRender() }
+
 }

src/main/kotlin/com/github/turboscript/graphics/ogl/GlRenderFunctions.kt

@@ -0,0 +1,14 @@
+package com.github.turboscript.graphics.ogl
+
+import com.github.turboscript.graphics.IRenderFunctions
+
+object GlRenderFunctions: IRenderFunctions {
+
+    override fun beginRender() {
+        OpenGlState.reset()
+    }
+
+    override fun endRender() {
+    }
+
+}

…/turboscript/graphics/ogl/OpenGlState.kt …thub/turboscript/graphics/ogl/GlState.ktsrc/main/kotlin/com/github/turboscript/graphics/ogl/OpenGlState.kt renamed to src/main/kotlin/com/github/turboscript/graphics/ogl/GlState.kt src/main/kotlin/com/github/turboscript/graphics/ogl/OpenGlState.kt renamed to src/main/kotlin/com/github/turboscript/graphics/ogl/GlState.kt

@@ -10,13 +10,17 @@ object OpenGlState {
     private val blend0 = GlState(false) {
         if (it) {
             GlStateManager._enableBlend()
-            GlStateManager._blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
         } else {
             GlStateManager._disableBlend()
         }
     }
     var blend by blend0
 
+    private val blendFunc0 = GlState(GL_ONE_MINUS_SRC_ALPHA) {
+        GlStateManager._blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+    }
+    var blendFunc by blendFunc0
+
     private val depth0 = GlState(false) {
         if (it) GlStateManager._enableDepthTest()
         else GlStateManager._disableDepthTest()
@@ -46,6 +50,10 @@ object OpenGlState {
         GlStateManager._bindTexture(texture)
     }
 
+    fun bindBuffer(target: Int, buffer: Int) {
+        GlStateManager._glBindBuffer(target, buffer)
+    }
+
     private val vertexArray0 = GlState(0) { glBindVertexArray(it) }
     var vertexArray by vertexArray0
 

src/main/kotlin/com/github/turboscript/graphics/ogl/TOpenGlRenderSystem.kt

@@ -0,0 +1,45 @@
+package com.github.turboscript.graphics.ogl.buffer
+
+import com.github.turboscript.graphics.ogl.OpenGlState
+import com.github.turboscript.graphics.turboRender.buffer.TRIBuffer
+import dev.luna5ama.kmogus.Arr
+import dev.luna5ama.kmogus.MutableArr
+import dev.luna5ama.kmogus.asMutable
+import org.lwjgl.opengl.GL46.*
+import java.nio.ByteBuffer
+
+open class GlBuffer(
+    size: Long,
+    extraBits: Int = 0,
+    mapBits: Int = GL_READ_WRITE,
+): TRIBuffer {
+
+    val id: Int = glCreateBuffers()
+
+    private var lastTarget: Int? = null
+    protected val arr: MutableArr
+
+    override fun getMappedArr(): MutableArr {
+        return arr
+    }
+
+    init {
+        glNamedBufferStorage(id, size, GL_MAP_READ_BIT or extraBits)
+        arr = Arr.wrap(glMapNamedBufferRange(
+            id, 0L, size, mapBits
+        ) as ByteBuffer).asMutable()
+    }
+
+    fun bind(target: Int) {
+        lastTarget = target
+        OpenGlState.bindBuffer(target, id)
+    }
+
+    fun unbind() {
+        lastTarget?.let {
+            OpenGlState.bindBuffer(it, 0)
+            lastTarget = null
+        }
+    }
+
+}

src/main/kotlin/com/github/turboscript/graphics/ogl/buffer/GlBuffer.kt

@@ -0,0 +1,40 @@
+package com.github.turboscript.graphics.ogl.buffer
+
+import org.lwjgl.opengl.GL46.*
+
+/**
+ * Persistent & Coherent Mapped Buffer
+ * Automatically flushes the buffer when it reaches 3/4 of its size.
+ */
+class GlPersistentMappedBuffer(
+    size: Long,
+    private val stride: Int,
+): GlBuffer(size, GL_MAP_PERSISTENT_BIT or GL_MAP_COHERENT_BIT) {
+
+    var offset = 0L
+
+    fun end() {
+        offset = (arr.pos / stride)
+    }
+
+    private var sync = 0L
+
+    fun waitAndSync() {
+        // Check if the draw call is complete and reset the Buffer
+        if (sync == 0L) {
+            if (arr.pos >= arr.len / 4 * 3) {   // 3/4 of the buffer is full
+                sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0)
+            }
+        } else if (
+            IntArray(1).apply {
+                glGetSynciv(sync, GL_SYNC_STATUS, IntArray(1), this)
+            }[0] == GL_SIGNALED
+        ) {
+            glDeleteSync(sync)
+            sync = 0L
+            arr.pos = 0L
+            offset = 0
+        }
+    }
+
+}