Merge remote-tracking branch 'origin/main'

src/main/kotlin/org/neoflock/neocomputers/NeoComputers.kt

@@ -17,6 +17,7 @@ import net.minecraft.server.level.ServerPlayer
 import org.neoflock.neocomputers.block.NodeBlock
 import org.neoflock.neocomputers.block.NodeBlockEntity
 import org.neoflock.neocomputers.block.NodeSynchronizer
+import org.neoflock.neocomputers.gui.render.ScreenRenderer
 import org.neoflock.neocomputers.item.Items
 import org.neoflock.neocomputers.item.Tabs
 import org.neoflock.neocomputers.network.Networking
@@ -40,24 +41,18 @@ object NeoComputers {
         BlockEntities.BLOCKENTITIES.register()
         BlockEntities.registerPowerBlocks()
         Menus.MENUS.register()
-        Menus.registerScreens()
         Tabs.TABS.register()
 
         ClientLifecycleEvent.CLIENT_SETUP.register {
-            MenuRegistry.registerScreenFactory(Menus.SCREEN_MENU.get(), ::ScreenScreen)
+            Menus.registerScreens()
         }
         ClientLifecycleEvent.CLIENT_STARTED.register {
             FontProvider.load(ResourceLocation.fromNamespaceAndPath(MODID, "font/unscii.hex"))
-
-            val buffer: ArrayList<BufferRenderer.GPUChar> = arrayListOf(BufferRenderer.GPUChar('h'), BufferRenderer.GPUChar('a'), BufferRenderer.GPUChar('i'))
-            for (i in 0..<(400-3)) {
-                buffer.add(BufferRenderer.GPUChar(' '))
+            ScreenRenderer.genUnboundTex();
         }
-            val bufferRenderer = BufferRenderer(20, 20, ResourceLocation.fromNamespaceAndPath(MODID, "screen/test"), buffer)
-            bufferRenderer.drawBuffer()
-            // bufferRenderer.dump("/home/mewhenthe/code/NeoComputers/dump.png") // NOTE: CHANGE THIS BEFORE RUNNING!!!!
-            bufferRenderer.clean()
 
+        ClientLifecycleEvent.CLIENT_STOPPING.register {
+            ScreenRenderer.cleanUnboundTex()
         }
 
         TickEvent.SERVER_POST.register {

src/main/kotlin/org/neoflock/neocomputers/block/ScreenBlock.kt

@@ -20,6 +20,7 @@ import org.neoflock.neocomputers.NeoComputers
 import org.neoflock.neocomputers.entity.BlockEntities
 import org.neoflock.neocomputers.entity.ScreenEntity
 import org.neoflock.neocomputers.gui.menu.Menus
+import org.neoflock.neocomputers.gui.menu.ScreenMenu
 import org.neoflock.neocomputers.network.Networking
 
 class ScreenBlock() : NodeBlock() {

src/main/kotlin/org/neoflock/neocomputers/gui/menu/Menus.kt

@@ -11,6 +11,7 @@ import net.minecraft.world.inventory.MenuType
 import org.neoflock.neocomputers.NeoComputers
 import org.neoflock.neocomputers.gui.menu.ScreenMenu
 import org.neoflock.neocomputers.gui.screen.CombustionGeneratorScreen
+import org.neoflock.neocomputers.gui.screen.ScreenScreen
 
 object Menus {
     val MENUS: DeferredRegister<MenuType<*>> = DeferredRegister.create(NeoComputers.MODID, Registries.MENU)
@@ -20,5 +21,6 @@ object Menus {
 
     fun registerScreens() {
         MenuScreens.register(Menus.COMBUSTGEN_MENU.get(), {m: CombustionGeneratorMenu, u, comp -> CombustionGeneratorScreen(m, u, comp)})
+        MenuScreens.register(Menus.SCREEN_MENU.get(), ::ScreenScreen)
     }
 }

src/main/kotlin/org/neoflock/neocomputers/gui/menu/ScreenMenu.kt

@@ -6,8 +6,9 @@ import net.minecraft.world.entity.player.Player
 import net.minecraft.world.inventory.AbstractContainerMenu
 import net.minecraft.world.inventory.MenuType
 import net.minecraft.world.item.ItemStack
+import org.neoflock.neocomputers.utils.GenericContainerMenu
 
-class ScreenMenu(i: Int, inv: Inventory) : AbstractContainerMenu(Menus.SCREEN_MENU.get(), i) {
+class ScreenMenu(i: Int, inv: Inventory) : GenericContainerMenu(Menus.SCREEN_MENU.get(), i, null) {
 
     override fun stillValid(player: Player) = true // TODO: implement this properly
     override fun quickMoveStack(player: Player, i: Int): ItemStack = ItemStack.EMPTY // there's no container here anyways

src/main/kotlin/org/neoflock/neocomputers/gui/render/BufferRenderer.kt

@@ -11,15 +11,10 @@ import java.io.File
 import kotlin.experimental.and
 import kotlin.experimental.xor
 
-class BufferRenderer(width: Int, height: Int, id: ResourceLocation, buffer: MutableList<GPUChar>) { // TODO: NN buffer
+class BufferRenderer(private var width: Int, private var height: Int, private var id: ResourceLocation, private var buffer: MutableList<GPUChar>) { // TODO: NN buffer
     val CHARW = 8
     val CHARH = 16
 
-    private var width: Int = width;
-    private var height: Int = height;
-    private var id: ResourceLocation = id;
-    private var buffer: MutableList<GPUChar> = buffer;
-
     private var texwidth: Int = width*CHARW;
     private var texheight: Int = height*CHARH;
     private var image: NativeImage = NativeImage(texwidth, texheight, true); // idk what the boolean is
@@ -64,7 +59,7 @@ class BufferRenderer(width: Int, height: Int, id: ResourceLocation, buffer: Muta
         buffer[y*width+x] = c
     }
 
-    fun register() {  // i would love to do this in the constructor but kotlin quirks blahblah
+    fun register() {
         Minecraft.getInstance().textureManager.register(this.id, tex) // also idk how to unregister this
     }
 

src/main/kotlin/org/neoflock/neocomputers/gui/render/ScreenRenderer.kt

@@ -0,0 +1,96 @@
+package org.neoflock.neocomputers.gui.render;
+
+import com.mojang.blaze3d.platform.GlConst
+import com.mojang.blaze3d.platform.NativeImage
+import com.mojang.blaze3d.systems.RenderSystem
+import com.mojang.blaze3d.vertex.BufferBuilder
+import com.mojang.blaze3d.vertex.BufferUploader
+import com.mojang.blaze3d.vertex.DefaultVertexFormat
+import com.mojang.blaze3d.vertex.Tesselator
+import com.mojang.blaze3d.vertex.VertexFormat
+import net.minecraft.client.Minecraft
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.renderer.GameRenderer
+import net.minecraft.client.renderer.texture.DynamicTexture
+import net.minecraft.resources.ResourceLocation
+import org.neoflock.neocomputers.NeoComputers
+
+class ScreenRenderer { 
+    val BORDERS: ResourceLocation = ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "textures/gui/borders.png")
+    var bound: ResourceLocation = ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "screen/unbound")
+
+    val bordersize = 10
+
+    fun render(graphics: GuiGraphics, x: Int, y: Int, width: Int, height: Int) {
+        RenderSystem.setShader { GameRenderer.getPositionTexShader() }
+        RenderSystem.setShaderTexture(0, BORDERS);
+        // borders
+        val bordersize = 8; // TODO: this should scale i think
+        // top left corner, uv (0, 0) to (6,6)
+        // graphics.blit
+        drawQuad(graphics, x-bordersize, y-bordersize, bordersize, bordersize, 0F, 0F, 6F, 6F);
+        // top border, uv (7,0) to (8,6)
+        drawQuad(graphics, x, y-bordersize, width, bordersize, 7F, 0F, 8F, 6F); // x+bordersize-bordersize
+        // top right corner, uv (9,0) to (15, 6)
+        drawQuad(graphics, x+width, y-bordersize, bordersize, bordersize, 9F, 0F, 15F, 6F);
+        
+        // left border, uv (0,7) to (6, 8)
+        drawQuad(graphics, x-bordersize, y, bordersize, height, 0F, 7F, 6F, 8F);
+        // middle, uv (7, 7) to (8, 8)
+        // drawQuad(graphics, x+bordersize, y+bordersize, width-bordersize, height-bordersize, 7, 7, 8, 8);
+        // right border uv (9, 7) to (15, 8)
+        drawQuad(graphics, x+width, y, bordersize, height, 9F, 7F, 15F, 8F);
+        
+        // bottom left corner, uv (0, 9) to (6, 15)
+        drawQuad(graphics, x-bordersize, y+height, bordersize, bordersize, 0F, 9F, 6F, 15F);
+        // bottom border, uv (7, 9) to (8, 15)
+        drawQuad(graphics, x, y+height, width, bordersize, 7F, 9F, 8F, 15F);
+        // bottom right corner, uv (9, 9) to (15, 15)
+        drawQuad(graphics, x+width, y+height, bordersize, bordersize, 9F, 9F, 15F, 15F);
+
+        RenderSystem.setShaderTexture(0, bound);
+        RenderSystem.texParameter(GlConst.GL_TEXTURE_2D, GlConst.GL_TEXTURE_MIN_FILTER, GlConst.GL_NEAREST);
+        RenderSystem.texParameter(GlConst.GL_TEXTURE_2D, GlConst.GL_TEXTURE_MAG_FILTER, GlConst.GL_NEAREST);
+        
+        drawQuad(graphics, x, y, width, height, 0F, 0F, 15F, 15F);
+
+    }
+
+    private fun drawQuad(graphics: GuiGraphics, x: Int, y: Int, width: Int, height: Int, u1: Float, v1: Float, u2: Float, v2: Float) {
+        var t: Tesselator = Tesselator.getInstance()
+        var builder: BufferBuilder = t.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX)
+
+        builder.addVertex(x.toFloat(), (y+height).toFloat(), 1f).setUv(u1/15F, v2/15F)
+        builder.addVertex((x+width).toFloat(), (y+height).toFloat(), 1f).setUv(u2/15F, v2/15F)
+        builder.addVertex((x+width).toFloat(), y.toFloat(), 1f).setUv(u2/15F, v1/15F)
+        builder.addVertex(x.toFloat(), y.toFloat(), 1f).setUv(u1/15F,v1/15F)
+
+        BufferUploader.drawWithShader(builder.build()!!)
+    }
+
+    fun bind(id: ResourceLocation) {
+        bound = id
+    }
+
+    fun unbind() {
+        bound = ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "screen/unbound")
+    }
+
+    companion object Static {
+        val img: NativeImage = NativeImage(1, 1, false)
+        val tex: DynamicTexture = DynamicTexture(img)
+
+        fun genUnboundTex() {
+            img.fillRect(0, 0, 1, 1, 0xFF000000.toInt())
+            tex.upload()
+
+            Minecraft.getInstance().textureManager.register(ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "screen/unbound"), tex)
+        }
+
+        fun cleanUnboundTex() {
+            img.close()
+            tex.close()
+            Minecraft.getInstance().textureManager.release(ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "screen/unbound"))
+        }
+    }
+}

src/main/kotlin/org/neoflock/neocomputers/gui/screen/CombustionGeneratorScreen.kt

@@ -6,12 +6,14 @@ import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.network.chat.Component
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.entity.player.Inventory
+import org.neoflock.neocomputers.NeoComputers
 import org.neoflock.neocomputers.entity.BlockEntities
 import org.neoflock.neocomputers.gui.menu.CombustionGeneratorMenu
 import org.neoflock.neocomputers.utils.GenericContainerScreen
 
 class CombustionGeneratorScreen(abstractContainerMenu: CombustionGeneratorMenu, inventory: Inventory, component: Component) : GenericContainerScreen<CombustionGeneratorMenu>(abstractContainerMenu, inventory, component) {
-    override fun findMenuTexture(): ResourceLocation = ResourceLocation.withDefaultNamespace("textures/gui/container/dispenser.png")
+    // override fun findMenuTexture(): ResourceLocation = ResourceLocation.withDefaultNamespace("textures/gui/container/dispenser.png")
+    override fun findMenuTexture(): ResourceLocation = ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "textures/gui/combustgui.png")
 
     var energy: Long = 0
     var energyCapacity: Long = 1

src/main/kotlin/org/neoflock/neocomputers/gui/screen/ScreenScreen.kt

@@ -7,12 +7,36 @@ import com.mojang.blaze3d.vertex.VertexFormat
 import net.minecraft.client.gui.GuiGraphics
 import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen
 import net.minecraft.network.chat.Component
+import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.entity.player.Inventory
+import org.neoflock.neocomputers.NeoComputers
+import org.neoflock.neocomputers.gui.buffer.BufferRenderer
 import org.neoflock.neocomputers.gui.menu.ScreenMenu
+import org.neoflock.neocomputers.gui.render.ScreenRenderer
 
-class ScreenScreen(abstractContainerMenu: ScreenMenu, inventory: Inventory, component: Component) : AbstractContainerScreen<ScreenMenu>(abstractContainerMenu, inventory, component) {
+class ScreenScreen : AbstractContainerScreen<ScreenMenu>{
+    private var renderer: ScreenRenderer = ScreenRenderer();
+
+    private var bufferRenderer: BufferRenderer? = null;
+    constructor(abstractContainerMenu: ScreenMenu, inventory: Inventory, component: Component) : super(abstractContainerMenu, inventory, component) {
+        val buffer: ArrayList<BufferRenderer.GPUChar> = arrayListOf(BufferRenderer.GPUChar('h'), BufferRenderer.GPUChar('a'), BufferRenderer.GPUChar('i'))
+        for (i in 0..<(400-3)) {
+            buffer.add(BufferRenderer.GPUChar(' '))
+        }
+        bufferRenderer = BufferRenderer(20, 20, ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "screen/test"), buffer)
+        bufferRenderer!!.register()
+        bufferRenderer!!.drawBuffer()
+        
+        renderer.bind(ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "screen/test"))
+        NeoComputers.LOGGER.info("created")
+    }
     override fun renderBg(guiGraphics: GuiGraphics, f: Float, i: Int, j: Int) {}
     override fun render(graphics: GuiGraphics, mouseX: Int, mouseY: Int, something: Float) {
         super.render(graphics, mouseX, mouseY, something)
+        renderer.render(graphics, 50, 50, 100, 200)
+    }
+
+    override fun onClose() {
+        bufferRenderer!!.clean()
     }
 }

src/main/kotlin/org/neoflock/neocomputers/utils/GenericContainer.kt

@@ -60,7 +60,7 @@ interface GenericContainer : Container {
     }
 }
 
-abstract class GenericContainerMenu(menuType: MenuType<*>, id: Int, var container: Container): AbstractContainerMenu(menuType, id) {
+abstract class GenericContainerMenu(menuType: MenuType<*>, id: Int, var container: Container?): AbstractContainerMenu(menuType, id) {
     fun addInventorySlots(inventory: Inventory, x: Int, y: Int) {
         // Based off the code in ChestMenu
         for (i in 0..2) {
@@ -86,7 +86,7 @@ abstract class GenericContainerMenu(menuType: MenuType<*>, id: Int, var containe
 
         val stack = slot.item
         val copied = stack.copy()
-        val contSize = container.containerSize
+        val contSize = container!!.containerSize
 
         if(i < contSize) {
             if(!this.moveItemStackTo(stack, contSize, slots.size, true)) {
@@ -106,7 +106,7 @@ abstract class GenericContainerMenu(menuType: MenuType<*>, id: Int, var containe
     }
 
     override fun stillValid(player: Player): Boolean {
-        return container.stillValid(player)
+        return container!!.stillValid(player)
     }
 }