120 lines
5.1 KiB
Kotlin
120 lines
5.1 KiB
Kotlin
package mods.betterfoliage.render.block.vanilla
|
|
|
|
import mods.betterfoliage.BetterFoliage
|
|
import mods.betterfoliage.chunk.BasicBlockCtx
|
|
import mods.betterfoliage.render.SNOW_MATERIALS
|
|
import mods.betterfoliage.render.ShadersModIntegration
|
|
import mods.betterfoliage.render.lighting.withLighting
|
|
import mods.betterfoliage.render.lighting.roundLeafLighting
|
|
import mods.betterfoliage.render.particle.LeafParticleRegistry
|
|
import mods.betterfoliage.util.Atlas
|
|
import mods.betterfoliage.resource.discovery.*
|
|
import mods.betterfoliage.resource.generated.GeneratedLeafSprite
|
|
import mods.betterfoliage.model.*
|
|
import mods.betterfoliage.util.*
|
|
import net.fabricmc.fabric.api.renderer.v1.material.BlendMode
|
|
import net.fabricmc.fabric.api.renderer.v1.model.FabricBakedModel
|
|
import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
|
|
import net.minecraft.block.BlockState
|
|
import net.minecraft.client.render.model.BakedModel
|
|
import net.minecraft.util.Identifier
|
|
import net.minecraft.util.math.BlockPos
|
|
import net.minecraft.util.math.Direction.*
|
|
import net.minecraft.world.BlockRenderView
|
|
import java.util.*
|
|
import java.util.function.Consumer
|
|
import java.util.function.Supplier
|
|
|
|
interface LeafKey : BlockRenderKey {
|
|
val roundLeafTexture: Identifier
|
|
|
|
/** Type of the leaf block (configurable by user). */
|
|
val leafType: String
|
|
|
|
/** Average color of the round leaf texture. */
|
|
val overrideColor: Int?
|
|
}
|
|
|
|
object StandardLeafDiscovery : ConfigurableModelDiscovery() {
|
|
override val logger = BetterFoliage.logDetail
|
|
override val matchClasses: ConfigurableBlockMatcher get() = BetterFoliage.blockConfig.leafBlocks
|
|
override val modelTextures: List<ModelTextureList> get() = BetterFoliage.blockConfig.leafModels.modelList
|
|
|
|
override fun processModel(state: BlockState, textures: List<Identifier>, atlas: Consumer<Identifier>) =
|
|
defaultRegisterLeaf(textures[0], atlas)
|
|
|
|
}
|
|
|
|
fun HasLogger.defaultRegisterLeaf(sprite: Identifier, atlas: Consumer<Identifier>): BlockRenderKey? {
|
|
val leafType = LeafParticleRegistry.typeMappings.getType(sprite) ?: "default"
|
|
val leafId = GeneratedLeafSprite(sprite, leafType).register(BetterFoliage.generatedPack)
|
|
atlas.accept(leafId)
|
|
|
|
log(" leaf texture $sprite")
|
|
log(" particle $leafType")
|
|
|
|
return NormalLeavesModel.Key(
|
|
leafId, leafType,
|
|
getAndLogColorOverride(leafId, Atlas.BLOCKS, BetterFoliage.config.shortGrass.saturationThreshold)
|
|
)
|
|
}
|
|
|
|
fun HasLogger.getAndLogColorOverride(sprite: Identifier, atlas: Atlas, threshold: Double): Int? {
|
|
val hsb = resourceManager.averageImageColorHSB(sprite, atlas)
|
|
return if (hsb.saturation >= threshold) {
|
|
log(" brightness ${hsb.brightness}")
|
|
log(" saturation ${hsb.saturation} >= ${threshold}, using texture color")
|
|
hsb.copy(brightness = 0.9f.coerceAtMost(hsb.brightness * 2.0f)).asColor
|
|
} else {
|
|
log(" saturation ${hsb.saturation} < ${threshold}, using block color")
|
|
null
|
|
}
|
|
}
|
|
|
|
class NormalLeavesModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wrapped), FabricBakedModel {
|
|
|
|
val leafNormal by leafModelsNormal.delegate(key)
|
|
val leafSnowed by leafModelsSnowed.delegate(key)
|
|
val leafLighting = roundLeafLighting()
|
|
|
|
override fun emitBlockQuads(blockView: BlockRenderView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
|
|
ShadersModIntegration.leaves(context, BetterFoliage.config.leaves.shaderWind) {
|
|
super.emitBlockQuads(blockView, state, pos, randomSupplier, context)
|
|
if (!BetterFoliage.config.enabled || !BetterFoliage.config.leaves.enabled) return
|
|
|
|
val ctx = BasicBlockCtx(blockView, pos)
|
|
val stateAbove = ctx.state(UP)
|
|
val isSnowed = stateAbove.material in SNOW_MATERIALS
|
|
|
|
val random = randomSupplier.get()
|
|
context.withLighting(leafLighting) {
|
|
it.accept(leafNormal[random])
|
|
if (isSnowed) it.accept(leafSnowed[random])
|
|
}
|
|
}
|
|
}
|
|
|
|
data class Key(
|
|
override val roundLeafTexture: Identifier,
|
|
override val leafType: String,
|
|
override val overrideColor: Int?
|
|
) : LeafKey {
|
|
override fun replace(model: BakedModel, state: BlockState) = NormalLeavesModel(this, meshifyStandard(model, state, blendModeOverride = BlendMode.CUTOUT_MIPPED))
|
|
}
|
|
|
|
companion object {
|
|
val leafSpritesSnowed by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
|
|
Identifier(BetterFoliage.MOD_ID, "blocks/better_leaves_snowed_$idx")
|
|
}
|
|
val leafModelsBase = LazyMap(BetterFoliage.modelReplacer) { key: LeafKey ->
|
|
BetterFoliage.config.leaves.let { crossModelsRaw(64, it.size, it.hOffset, it.vOffset) }
|
|
}
|
|
val leafModelsNormal = LazyMap(BetterFoliage.modelReplacer) { key: LeafKey ->
|
|
crossModelsTextured(leafModelsBase[key], key.overrideColor, true) { Atlas.BLOCKS.atlas[key.roundLeafTexture]!! }
|
|
}
|
|
val leafModelsSnowed = LazyMap(BetterFoliage.modelReplacer) { key: LeafKey ->
|
|
crossModelsTextured(leafModelsBase[key], Color.white.asInt, false) { leafSpritesSnowed[it] }
|
|
}
|
|
}
|
|
}
|