Merge branch 'kotlin-1.10' into kotlin-1.11.2

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

@@ -70,13 +70,13 @@ data class Quad(val v1: Vertex, val v2: Vertex, val v3: Vertex, val v4: Vertex)
     fun clampUV(minU: Double = -0.5, maxU: Double = 0.5, minV: Double = -0.5, maxV: Double = 0.5) =
         transformV { it.copy(uv = it.uv.clamp(minU, maxU, minV, maxV)) }
     fun mirrorUV(mirrorU: Boolean, mirrorV: Boolean) = transformV { it.copy(uv = it.uv.mirror(mirrorU, mirrorV)) }
-    fun setAoShader(resolver: (Quad, Vertex)->Shader, predicate: (Vertex, Int)->Boolean = { v, vi -> true }) =
+    fun setAoShader(factory: ShaderFactory, predicate: (Vertex, Int)->Boolean = { v, vi -> true }) =
         transformVI { vertex, idx ->
-            if (!predicate(vertex, idx)) vertex else vertex.copy(aoShader = resolver(this@Quad, vertex))
+            if (!predicate(vertex, idx)) vertex else vertex.copy(aoShader = factory(this@Quad, vertex))
         }
-    fun setFlatShader(resolver: (Quad, Vertex)->Shader, predicate: (Vertex, Int)->Boolean = { v, vi -> true }) =
+    fun setFlatShader(factory: ShaderFactory, predicate: (Vertex, Int)->Boolean = { v, vi -> true }) =
         transformVI { vertex, idx ->
-            if (!predicate(vertex, idx)) vertex else vertex.copy(flatShader = resolver(this@Quad, vertex))
+            if (!predicate(vertex, idx)) vertex else vertex.copy(flatShader = factory(this@Quad, vertex))
         }
     fun setFlatShader(shader: Shader) = transformVI { vertex, idx -> vertex.copy(flatShader = shader) }
     val flipped: Quad get() = Quad(v4, v3, v2, v1)

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

@@ -7,7 +7,10 @@ import net.minecraft.client.renderer.texture.TextureAtlasSprite
 import net.minecraft.util.EnumFacing
 import net.minecraft.util.EnumFacing.*
 
-class ModelRenderer() : ShadingContext() {
+typealias QuadIconResolver = (ShadingContext, Int, Quad) -> TextureAtlasSprite?
+typealias PostProcessLambda = RenderVertex.(ShadingContext, Int, Quad, Int, Vertex) -> Unit
+
+class ModelRenderer : ShadingContext() {
 
     /** Holds final vertex data before it goes to the [Tessellator]. */
     val temp = RenderVertex()
@@ -25,14 +28,15 @@ class ModelRenderer() : ShadingContext() {
      * @param[rotateUV] lambda to get amount of UV rotation for each quad
      * @param[postProcess] lambda to perform arbitrary modifications on the [RenderVertex] just before it goes to the [Tessellator]
      */
-    inline fun render(
+    fun render(
         worldRenderer: VertexBuffer,
         model: Model,
-        rot: Rotation,
+        rot: Rotation = Rotation.identity,
         trans: Double3 = blockContext.blockCenter,
         forceFlat: Boolean = false,
-        icon: (ShadingContext, Int, Quad) -> TextureAtlasSprite?,
-        postProcess: RenderVertex.(ShadingContext, Int, Quad, Int, Vertex) -> Unit
+        quadFilter: (Int, Quad) -> Boolean = { _, _ -> true },
+        icon: QuadIconResolver,
+        postProcess: PostProcessLambda
     ) {
         rotation = rot
         aoEnabled = Minecraft.isAmbientOcclusionEnabled()
@@ -41,21 +45,23 @@ class ModelRenderer() : ShadingContext() {
         worldRenderer.ensureSpaceForQuads(model.quads.size + 1)
 
         model.quads.forEachIndexed { quadIdx, quad ->
-            val drawIcon = icon(this, quadIdx, quad)
-            if (drawIcon != null) {
-                quad.verts.forEachIndexed { vertIdx, vert ->
-                    temp.init(vert).rotate(rotation).translate(trans)
-                    val shader = if (aoEnabled && !forceFlat) vert.aoShader else vert.flatShader
-                    shader.shade(this, temp)
-                    temp.postProcess(this, quadIdx, quad, vertIdx, vert)
-                    temp.setIcon(drawIcon)
+            if (quadFilter(quadIdx, quad)) {
+                val drawIcon = icon(this, quadIdx, quad)
+                if (drawIcon != null) {
+                    quad.verts.forEachIndexed { vertIdx, vert ->
+                        temp.init(vert).rotate(rotation).translate(trans)
+                        val shader = if (aoEnabled && !forceFlat) vert.aoShader else vert.flatShader
+                        shader.shade(this, temp)
+                        temp.postProcess(this, quadIdx, quad, vertIdx, vert)
+                        temp.setIcon(drawIcon)
 
-                    worldRenderer
-                        .pos(temp.x, temp.y, temp.z)
-                        .color(temp.red, temp.green, temp.blue, 1.0f)
-                        .tex(temp.u, temp.v)
-                        .lightmap(temp.brightness shr 16 and 65535, temp.brightness and 65535)
-                        .endVertex()
+                        worldRenderer
+                            .pos(temp.x, temp.y, temp.z)
+                            .color(temp.red, temp.green, temp.blue, 1.0f)
+                            .tex(temp.u, temp.v)
+                            .lightmap(temp.brightness shr 16 and 65535, temp.brightness and 65535)
+                            .endVertex()
+                    }
                 }
             }
         }
@@ -167,4 +173,4 @@ val allFaces: (EnumFacing) -> Boolean = { true }
 val topOnly: (EnumFacing) -> Boolean = { it == UP }
 
 /** Perform no post-processing */
-val noPost: RenderVertex.(ShadingContext, Int, Quad, Int, Vertex) -> Unit = { ctx, qi, q, vi, v -> }
+val noPost: PostProcessLambda = { _, _, _, _, _ -> }

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

@@ -10,7 +10,7 @@ const val defaultEdgeDimming = 0.8f
 // ================================
 // Shader instantiation lambdas
 // ================================
-fun cornerAo(fallbackAxis: EnumFacing.Axis): (EnumFacing, EnumFacing, EnumFacing)->Shader = { face, dir1, dir2 ->
+fun cornerAo(fallbackAxis: EnumFacing.Axis): CornerShaderFactory = { face, dir1, dir2 ->
     val fallbackDir = listOf(face, dir1, dir2).find { it.axis == fallbackAxis }!!
     CornerSingleFallback(face, dir1, dir2, fallbackDir)
 }
@@ -20,7 +20,7 @@ fun cornerAoTri(func: (AoData, AoData)-> AoData) = { face: EnumFacing, dir1: Enu
 }
 val cornerAoMaxGreen = cornerAoTri { s1, s2 -> if (s1.green > s2.green) s1 else s2 }
 
-fun cornerInterpolate(edgeAxis: EnumFacing.Axis, weight: Float, dimming: Float): (EnumFacing, EnumFacing, EnumFacing)->Shader = { dir1, dir2, dir3 ->
+fun cornerInterpolate(edgeAxis: EnumFacing.Axis, weight: Float, dimming: Float): CornerShaderFactory = { dir1, dir2, dir3 ->
     val edgeDir = listOf(dir1, dir2, dir3).find { it.axis == edgeAxis }!!
     val faceDirs = listOf(dir1, dir2, dir3).filter { it.axis != edgeAxis }
     CornerInterpolateDimming(faceDirs[0], faceDirs[1], edgeDir, weight, dimming)

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

@@ -10,6 +10,10 @@ import net.minecraft.util.EnumFacing.*
 import java.lang.Math.min
 import java.util.*
 
+typealias EdgeShaderFactory = (EnumFacing, EnumFacing) -> Shader
+typealias CornerShaderFactory = (EnumFacing, EnumFacing, EnumFacing) -> Shader
+typealias ShaderFactory = (Quad, Vertex) -> Shader
+
 /** Holds shading values for block corners as calculated by vanilla Minecraft rendering. */
 class AoData() {
     var valid = false
@@ -140,8 +144,8 @@ interface Shader {
  * @param[edge] shader instantiation lambda for edge midpoint vertices
  */
 fun faceOrientedAuto(overrideFace: EnumFacing? = null,
-                     corner: ((EnumFacing, EnumFacing, EnumFacing)->Shader)? = null,
-                     edge: ((EnumFacing, EnumFacing)->Shader)? = null) =
+                     corner: CornerShaderFactory? = null,
+                     edge: EdgeShaderFactory? = null) =
     fun(quad: Quad, vertex: Vertex): Shader {
         val quadFace = overrideFace ?: quad.normal.nearestCardinal
         val nearestCorner = nearestPosition(vertex.xyz, faceCorners[quadFace.ordinal].asList) {
@@ -167,7 +171,7 @@ fun faceOrientedAuto(overrideFace: EnumFacing? = null,
  * @param[corner] shader instantiation lambda
  */
 fun edgeOrientedAuto(overrideEdge: Pair<EnumFacing, EnumFacing>? = null,
-                     corner: (EnumFacing, EnumFacing, EnumFacing)->Shader) =
+                     corner: CornerShaderFactory) =
     fun(quad: Quad, vertex: Vertex): Shader {
         val edgeDir = overrideEdge ?: nearestAngle(quad.normal, boxEdges) { it.first.vec + it.second.vec }.first
         val nearestFace = nearestPosition(vertex.xyz, edgeDir.toList()) { it.vec }.first