103 lines
3.6 KiB
Kotlin
103 lines
3.6 KiB
Kotlin
package mods.betterfoliage.util
|
|
|
|
import net.minecraft.util.math.Direction
|
|
import net.minecraft.util.math.Direction.*
|
|
|
|
fun Pair<Direction, Direction>.ccwWinding() = arrayOf(first to second, first.opposite to second, first.opposite to second.opposite, first to second.opposite)
|
|
|
|
typealias BoxCorner = Triple<Direction, Direction, Direction>
|
|
fun BoxCorner.equalsUnordered(other: BoxCorner) = contains(other.first) && contains(other.second) && contains(other.third)
|
|
|
|
fun BoxCorner.contains(dir: Direction) = first == dir || second == dir || third == dir
|
|
|
|
fun Array<BoxCorner>.findIdx(corner: BoxCorner): Int? {
|
|
forEachIndexed { idx, test -> if (test.contains(corner.first) && test.contains(corner.second) && test.contains(corner.third)) return idx }
|
|
return null
|
|
}
|
|
fun Array<BoxCorner>.findIdx(predicate: (BoxCorner)->Boolean): Int? {
|
|
forEachIndexed { idx, test -> if (predicate(test)) return idx }
|
|
return null
|
|
}
|
|
|
|
/**
|
|
* Decribes the winding order for vanilla AO data.
|
|
* 1st index: light face ordinal
|
|
* 2nd index: index in AO data array
|
|
* value: pair of [Direction]s that along with light face fully describe the corner
|
|
* the AO data belongs to
|
|
*/
|
|
val aoWinding = allDirections.map { when(it) {
|
|
DOWN -> (SOUTH to WEST).ccwWinding()
|
|
UP -> (SOUTH to EAST).ccwWinding()
|
|
NORTH -> (WEST to UP).ccwWinding()
|
|
SOUTH -> (UP to WEST).ccwWinding()
|
|
WEST -> (SOUTH to UP).ccwWinding()
|
|
EAST -> (SOUTH to DOWN).ccwWinding()
|
|
} }.toTypedArray()
|
|
|
|
/**
|
|
* Indexing for undirected box corners (component order does not matter).
|
|
* Array contains [Direction] triplets fully defining the corner.
|
|
*/
|
|
val cornersUndir = Array(8) { idx -> Triple(
|
|
if (idx and 1 != 0) EAST else WEST,
|
|
if (idx and 2 != 0) UP else DOWN,
|
|
if (idx and 4 != 0) SOUTH else NORTH
|
|
) }
|
|
|
|
/**
|
|
* Reverse lookup for [cornersUndir]. Index 3 times with the corner's cardinal directions.
|
|
* A null value indicates an invalid corner (multiple indexing along the same axis)
|
|
*/
|
|
val cornersUndirIdx = Array(6) { idx1 -> Array(6) { idx2 -> Array(6) { idx3 ->
|
|
cornersUndir.findIdx(BoxCorner(byId(idx1), byId(idx2), byId(idx3)))
|
|
} } }
|
|
|
|
/**
|
|
* Get corner index for vertex coordinates
|
|
*/
|
|
fun getCornerUndir(x: Float, y: Float, z: Float): Int {
|
|
var result = 0
|
|
if (x > 0.5f) result += 1
|
|
if (y > 0.5f) result += 2
|
|
if (z > 0.5f) result += 4
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Indexing scheme for directed box corners.
|
|
* The first direction - the face - matters, the other two are unordered.
|
|
* 1:1 correspondence with possible AO values.
|
|
* Array contains triplets defining the corner fully.
|
|
*/
|
|
val cornersDir = Array(24) { idx ->
|
|
val faceIdx = idx / 4
|
|
val windingIdx = idx % 4
|
|
val winding = aoWinding[faceIdx][windingIdx]
|
|
BoxCorner(byId(faceIdx), winding.first, winding.second)
|
|
}
|
|
|
|
/**
|
|
* Reverse lookup for [cornersDir].
|
|
* 1st index: primary face
|
|
* 2nd index: undirected corner index.
|
|
* value: directed corner index
|
|
* A null value indicates an invalid corner (primary face not shared by corner).
|
|
*/
|
|
val cornerDirFromUndir = Array(6) { faceIdx -> Array(8) { undirIdx ->
|
|
val face = byId(faceIdx); val corner = cornersUndir[undirIdx]
|
|
if (!corner.contains(face)) null else cornersDir.findIdx { it.first == face && it.equalsUnordered(corner) }
|
|
} }
|
|
|
|
/**
|
|
* Reverse lookup for [cornersDir].
|
|
* 1st index: primary face
|
|
* 2nd index: AO value index on the face.
|
|
* value: directed corner index
|
|
*/
|
|
val cornerDirFromAo = Array(6) { faceIdx -> IntArray(4) { aoIdx ->
|
|
val face = byId(faceIdx); val corner = aoWinding[face.ordinal][aoIdx].let { Triple(face, it.first, it.second) }
|
|
cornersDir.findIdx { it.first == face && it.equalsUnordered(corner) }!!
|
|
} }
|
|
|