Merge branch 'kotlin-1.10' into kotlin-1.11.2

build.gradle

@@ -2,7 +2,7 @@ apply plugin: "net.minecraftforge.gradle.forge"
 apply plugin: 'kotlin'
 
 group = 'com.github.octarine-noise'
-version = "2.1.5"
+version = "2.1.6"
 archivesBaseName = rootProject.name + '-MC1.11.2'
 
 buildscript {

src/main/kotlin/mods/betterfoliage/client/Hooks.kt

@@ -4,10 +4,7 @@ package mods.betterfoliage.client
 
 import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.render.EntityFallingLeavesFX
+import mods.betterfoliage.client.render.*
-import mods.betterfoliage.client.render.EntityRisingSoulFX
-import mods.betterfoliage.client.render.down1
-import mods.betterfoliage.client.render.up1
 import mods.octarinecore.client.render.blockContext
 import mods.octarinecore.client.resource.LoadModelDataEvent
 import mods.octarinecore.common.plus
@@ -76,23 +73,17 @@ fun renderWorldBlock(dispatcher: BlockRendererDispatcher,
                      worldRenderer: VertexBuffer,
                      layer: BlockRenderLayer
 ): Boolean {
-    val isCutout = layer == CUTOUT_MIPPED || layer == CUTOUT
-    val needsCutout = state.block.canRenderInLayer(state, CUTOUT_MIPPED) || state.block.canRenderInLayer(state, CUTOUT)
-    val canRender = (isCutout && needsCutout) || state.block.canRenderInLayer(state, layer)
-
     blockContext.let { ctx ->
         ctx.set(blockAccess, pos)
         Client.renderers.forEach { renderer ->
             if (renderer.isEligible(ctx)) {
-                return if (renderer.moveToCutout) {
+                if (state.canRenderInLayer(layer) || (layer.isCutout && renderer.addToCutout)) {
-                    if (isCutout) renderer.render(ctx, dispatcher, worldRenderer, layer) else false
+                    return renderer.render(ctx, dispatcher, worldRenderer, layer)
-                } else {
-                    renderer.render(ctx, dispatcher, worldRenderer, layer)
                 }
             }
         }
     }
-    return if (canRender) dispatcher.renderBlock(state, pos, blockAccess, worldRenderer) else false
+    return if (state.canRenderInLayer(layer)) dispatcher.renderBlock(state, pos, blockAccess, worldRenderer) else false
 }
 
 fun canRenderBlockInLayer(block: Block, state: IBlockState, layer: BlockRenderLayer): Boolean {

src/main/kotlin/mods/betterfoliage/client/render/RenderAlgae.kt

@@ -37,7 +37,9 @@ class RenderAlgae : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
         noise[ctx.pos] < Config.algae.population
 
     override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
-        renderWorldBlockBase(ctx, dispatcher, renderer, null)
+        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, layer)
+        if (!layer.isCutout) return baseRender
+
         modelRenderer.updateShading(Int3.zero, allFaces)
 
         val rand = ctx.semiRandomArray(3)

src/main/kotlin/mods/betterfoliage/client/render/RenderCactus.kt

@@ -93,6 +93,9 @@ class RenderCactus : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
         Config.blocks.cactus.matchesClass(ctx.block)
 
     override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
+        // render the whole block on the cutout layer
+        if (!layer.isCutout) return false
+
         // get AO data
         modelRenderer.updateShading(Int3.zero, allFaces)
         val icons = cactusTextures[ctx.blockState(Int3.zero)] ?: return renderWorldBlockBase(ctx, dispatcher, renderer, null)

src/main/kotlin/mods/betterfoliage/client/render/RenderConnectedGrass.kt

@@ -24,12 +24,12 @@ class RenderConnectedGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_
 
     override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
         // if the block sides are not visible anyway, render normally
-        if (forgeDirsHorizontal.all { ctx.blockState(it.offset).isOpaqueCube }) return renderWorldBlockBase(ctx, dispatcher, renderer, null)
+        if (forgeDirsHorizontal.all { ctx.blockState(it.offset).isOpaqueCube }) return renderWorldBlockBase(ctx, dispatcher, renderer, layer)
 
         if (ctx.isSurroundedBy { it.isOpaqueCube } ) return false
         return ctx.withOffset(Int3.zero, up1) {
             ctx.withOffset(up1, up2) {
-                renderWorldBlockBase(ctx, dispatcher, renderer, null)
+                renderWorldBlockBase(ctx, dispatcher, renderer, layer)
             }
         }
     }

src/main/kotlin/mods/betterfoliage/client/render/RenderConnectedGrassLog.kt

@@ -31,10 +31,10 @@ class RenderConnectedGrassLog : AbstractBlockRenderingHandler(BetterFoliageMod.M
 
         return if (grassDir != null) {
             ctx.withOffset(Int3.zero, grassDir.offset) {
-                renderWorldBlockBase(ctx, dispatcher, renderer, null)
+                renderWorldBlockBase(ctx, dispatcher, renderer, layer)
             }
         } else {
-            renderWorldBlockBase(ctx, dispatcher, renderer, null)
+            renderWorldBlockBase(ctx, dispatcher, renderer, layer)
         }
     }
 }

src/main/kotlin/mods/betterfoliage/client/render/RenderCoral.kt

@@ -55,7 +55,9 @@ class RenderCoral : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
         noise[ctx.pos] < Config.coral.population
 
     override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
-        renderWorldBlockBase(ctx, dispatcher, renderer, null)
+        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, layer)
+        if (!layer.isCutout) return baseRender
+
         modelRenderer.updateShading(Int3.zero, allFaces)
 
         forgeDirs.forEachIndexed { idx, face ->

src/main/kotlin/mods/betterfoliage/client/render/RenderGrass.kt

@@ -52,6 +52,9 @@ class RenderGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
         GrassRegistry[ctx, UP] != null
 
     override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
+        // render the whole block on the cutout layer
+        if (!layer.isCutout) return false
+
         val isConnected = ctx.block(down1).let {
             Config.blocks.dirt.matchesClass(it) ||
             Config.blocks.grassClasses.matchesClass(it)

src/main/kotlin/mods/betterfoliage/client/render/RenderLeaves.kt

@@ -55,11 +55,12 @@ class RenderLeaves : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
         if (leafInfo == null) {
             // shouldn't happen
             Client.logRenderError(ctx.blockState(Int3.zero), ctx.pos)
-            return renderWorldBlockBase(ctx, dispatcher, renderer, null)
+            return renderWorldBlockBase(ctx, dispatcher, renderer, layer)
         }
         val blockColor = ctx.blockData(Int3.zero).color
 
-        renderWorldBlockBase(ctx, dispatcher, renderer, null)
+        renderWorldBlockBase(ctx, dispatcher, renderer, layer)
+        if (!layer.isCutout) return true
 
         modelRenderer.updateShading(Int3.zero, allFaces)
         ShadersModIntegration.leaves(renderer) {

src/main/kotlin/mods/betterfoliage/client/render/RenderLilypad.kt

@@ -45,6 +45,9 @@ class RenderLilypad : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
         Config.blocks.lilypad.matchesClass(ctx.block)
 
     override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
+        // render the whole block on the cutout layer
+        if (!layer.isCutout) return false
+
         renderWorldBlockBase(ctx, dispatcher, renderer, null)
         modelRenderer.updateShading(Int3.zero, allFaces)
 

src/main/kotlin/mods/betterfoliage/client/render/RenderLog.kt

@@ -20,7 +20,7 @@ import net.minecraftforge.fml.relauncher.SideOnly
 
 class RenderLog : AbstractRenderColumn(BetterFoliageMod.MOD_ID) {
 
-    override val moveToCutout: Boolean get() = false
+    override val addToCutout: Boolean get() = false
 
     override fun isEligible(ctx: BlockContext) =
         Config.enabled && Config.roundLogs.enabled &&

src/main/kotlin/mods/betterfoliage/client/render/RenderMycelium.kt

@@ -34,6 +34,9 @@ class RenderMycelium : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
     }
 
     override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
+        // render the whole block on the cutout layer
+        if (!layer.isCutout) return false
+
         val isSnowed = ctx.blockState(up1).isSnow
 
         renderWorldBlockBase(ctx, dispatcher, renderer, null)

src/main/kotlin/mods/betterfoliage/client/render/RenderNetherrack.kt

@@ -40,8 +40,11 @@ class RenderNetherrack : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID)
     }
 
     override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
-        renderWorldBlockBase(ctx, dispatcher, renderer, null)
+        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, layer)
-        if (ctx.blockState(down1).isOpaqueCube) return true
+        if (!layer.isCutout) return baseRender
+
+        if (ctx.blockState(down1).isOpaqueCube) return baseRender
+
         modelRenderer.updateShading(Int3.zero, allFaces)
 
         val rand = ctx.semiRandomArray(2)

src/main/kotlin/mods/betterfoliage/client/render/RenderReeds.kt

@@ -54,7 +54,9 @@ class RenderReeds : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
         noise[ctx.pos] < Config.reed.population
 
     override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
-        renderWorldBlockBase(ctx, dispatcher, renderer, null)
+        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, layer)
+        if (!layer.isCutout) return baseRender
+
         modelRenderer.updateShading(Int3.zero, allFaces)
 
         val iconVar = ctx.random(1)

src/main/kotlin/mods/betterfoliage/client/render/Utils.kt

@@ -10,6 +10,7 @@ import mods.octarinecore.common.times
 import net.minecraft.block.Block
 import net.minecraft.block.material.Material
 import net.minecraft.block.state.IBlockState
+import net.minecraft.util.BlockRenderLayer
 import net.minecraft.util.EnumFacing
 import net.minecraft.util.EnumFacing.*
 
@@ -53,4 +54,8 @@ fun Model.mix(first: Model, second: Model, predicate: (Int)->Boolean) {
             if (predicate(3)) otherQuad.v4.copy() else quad.v4.copy()
         ).add()
     }
-}
+}
+
+val BlockRenderLayer.isCutout: Boolean get() = (this == BlockRenderLayer.CUTOUT) || (this == BlockRenderLayer.CUTOUT_MIPPED)
+
+fun IBlockState.canRenderInLayer(layer: BlockRenderLayer) = this.block.canRenderInLayer(this, layer)

src/main/kotlin/mods/octarinecore/client/render/AbstractBlockRenderingHandler.kt

@@ -33,7 +33,7 @@ val blockColors = ThreadLocal<BlockColors>()
 
 abstract class AbstractBlockRenderingHandler(modId: String) : ResourceHandler(modId) {
 
-    open val moveToCutout: Boolean get() = true
+    open val addToCutout: Boolean get() = true
 
     // ============================
     // Custom rendering

src/main/resources/assets/betterfoliage/log_blocks_default.cfg

@@ -30,3 +30,6 @@ ic2.core.block.BlockRubWood
 
 // TechReborn
 techreborn.blocks.BlockRubberLog
+
+//Better With Mods
+betterwithmods.blocks.BlockStump