From 8f82fefbb7416a6c5c27501e3a02a321d559cd91 Mon Sep 17 00:00:00 2001 From: octarine-noise Date: Fri, 14 May 2021 14:40:07 +0200 Subject: [PATCH] Port to 1.16.5 Kottle -> KotlinForForge --- build.gradle.kts | 18 ++++--- gradle.properties | 10 ++-- settings.gradle.kts | 2 +- .../mods/betterfoliage/mixin/MixinBlock.java | 2 +- .../mixin/MixinBlockModelRenderer.java | 12 ++--- .../betterfoliage/mixin/MixinBlockState.java | 12 +++-- .../betterfoliage/mixin/MixinClientWorld.java | 10 ++-- .../mixin/MixinForgeBlockModelRenderer.java | 12 ++--- .../betterfoliage/mixin/MixinModelBakery.java | 8 +-- .../mods/betterfoliage/BetterFoliage.kt | 3 +- .../mods/betterfoliage/BetterFoliageMod.kt | 6 +-- .../kotlin/mods/betterfoliage/CommonRefs.kt | 6 +-- src/main/kotlin/mods/betterfoliage/Hooks.kt | 16 +++--- .../mods/betterfoliage/chunk/BlockContext.kt | 17 +++--- .../mods/betterfoliage/chunk/Overlay.kt | 22 +++----- .../mods/betterfoliage/config/Config.kt | 1 + .../mods/betterfoliage/config/MiscDefaults.kt | 6 ++- .../integration/OptifineCustomColors.kt | 2 +- .../integration/ShadersModIntegration.kt | 10 ++-- .../mods/betterfoliage/model/HalfBaked.kt | 20 +++---- .../model/SpecialRenderModels.kt | 12 +---- .../mods/betterfoliage/model/SpriteSets.kt | 2 +- .../render/block/vanilla/Dirt.kt | 25 ++++----- .../render/block/vanilla/Mycelium.kt | 2 +- .../render/block/vanilla/Netherrack.kt | 6 +-- .../render/block/vanilla/RoundLog.kt | 15 +++--- .../render/block/vanilla/Sand.kt | 4 +- .../render/column/ColumnOverlayLayer.kt | 8 +-- .../render/lighting/VanillaAoCalculation.kt | 24 ++++----- .../render/lighting/VanillaVertexLighter.kt | 2 +- .../render/particle/AbstractParticle.kt | 54 +++++++++---------- .../render/particle/FallingLeaves.kt | 40 +++++++------- .../render/particle/LeafParticleRegistry.kt | 4 +- .../render/particle/RisingSouls.kt | 15 +++--- .../render/pipeline/RenderCtxBase.kt | 10 ++-- .../render/pipeline/RenderCtxForge.kt | 12 ++--- .../render/pipeline/RenderCtxVanilla.kt | 12 ++--- .../resource/VeryEarlyReloadListener.kt | 2 +- .../resource/discovery/BakingLifecycle.kt | 16 +++--- .../resource/discovery/Matchers.kt | 9 ++-- .../resource/discovery/ModelDiscovery.kt | 27 +++++----- .../resource/discovery/VanillaWrappers.kt | 6 +-- .../resource/generated/ResourceGeneration.kt | 22 ++++---- .../kotlin/mods/betterfoliage/util/Blocks.kt | 9 ---- .../mods/betterfoliage/util/Geometry.kt | 28 +++++----- .../kotlin/mods/betterfoliage/util/Gui.kt | 26 ++++----- .../mods/betterfoliage/util/Resources.kt | 7 --- .../kotlin/mods/betterfoliage/util/Sprites.kt | 7 ++- src/main/resources/META-INF/mods.toml | 6 +-- .../assets/betterfoliage/lang/en_us.lang | 2 + .../betterfoliage/log_blocks_default.cfg | 2 +- .../betterfoliage/log_models_default.cfg | 2 +- 52 files changed, 299 insertions(+), 314 deletions(-) delete mode 100644 src/main/kotlin/mods/betterfoliage/util/Blocks.kt diff --git a/build.gradle.kts b/build.gradle.kts index f9881ef..f95699e 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,26 +1,28 @@ plugins { - kotlin("jvm").version("1.3.61") - id("net.minecraftforge.gradle").version("3.0.194") + kotlin("jvm").version("1.4.20") + id("net.minecraftforge.gradle").version("4.1.12") id("org.spongepowered.mixin").version("0.7-SNAPSHOT") } -apply(plugin = "org.spongepowered.mixin") +//apply(plugin = "org.spongepowered.mixin") repositories { - maven("http://files.minecraftforge.net/maven") + maven("https://files.minecraftforge.net/maven") maven("https://repo.spongepowered.org/maven") maven("https://minecraft.curseforge.com/api/maven") maven("https://maven.shedaniel.me/") maven("https://www.cursemaven.com") + maven("https://thedarkcolour.github.io/KotlinForForge/") } dependencies { "minecraft"("net.minecraftforge:forge:${properties["mcVersion"]}-${properties["forgeVersion"]}") - "api"(fg.deobf("curse.maven:clothconfig-348521:2938583")) +// "api"(fg.deobf("curse.maven:clothconfig-348521:2938583")) - "implementation"(fg.deobf("curse.maven:biomesoplenty-220318:2988999")) - "implementation"("kottle:Kottle:${properties["kottleVersion"]}") -// "implementation"("org.spongepowered:mixin:0.8-SNAPSHOT") +// "implementation"(fg.deobf("curse.maven:biomesoplenty-220318:2988999")) + "implementation"("thedarkcolour:kotlinforforge:1.7.0") + + "implementation"("org.spongepowered:mixin:0.8-SNAPSHOT") } configurations["annotationProcessor"].extendsFrom(configurations["implementation"]) diff --git a/gradle.properties b/gradle.properties index 260aca7..08ea55e 100644 --- a/gradle.properties +++ b/gradle.properties @@ -6,9 +6,9 @@ jarName = BetterFoliage-Forge version = 2.6.1 -mcVersion = 1.15.2 -forgeVersion = 31.2.44 -mappingsChannel = snapshot -mappingsVersion = 20200514-1.15.1 +mcVersion = 1.16.5 +forgeVersion = 36.1.17 +mappingsChannel = official +mappingsVersion = 1.16.5 -kottleVersion = 1.4.0 +#kottleVersion = 1.4.0 diff --git a/settings.gradle.kts b/settings.gradle.kts index 080fa38..1faf5d5 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -1,6 +1,6 @@ pluginManagement { repositories { - maven("http://files.minecraftforge.net/maven") + maven("https://files.minecraftforge.net/maven") maven("https://repo.spongepowered.org/maven") gradlePluginPortal() } diff --git a/src/main/java/mods/betterfoliage/mixin/MixinBlock.java b/src/main/java/mods/betterfoliage/mixin/MixinBlock.java index cd4c519..b1e613f 100644 --- a/src/main/java/mods/betterfoliage/mixin/MixinBlock.java +++ b/src/main/java/mods/betterfoliage/mixin/MixinBlock.java @@ -21,7 +21,7 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; */ @Mixin(Block.class) public class MixinBlock { - private static final String shouldSideBeRendered = "Lnet/minecraft/block/Block;shouldSideBeRendered(Lnet/minecraft/block/BlockState;Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/Direction;)Z"; + private static final String shouldSideBeRendered = "Lnet/minecraft/block/Block;shouldRenderFace(Lnet/minecraft/block/BlockState;Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/Direction;)Z"; private static final String getVoxelShape = "Lnet/minecraft/block/BlockState;func_215702_a(Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/Direction;)Lnet/minecraft/util/math/shapes/VoxelShape;"; private static final String getFaceOcclusionShape = "Lnet/minecraft/block/BlockState;getFaceOcclusionShape(Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/Direction;)Lnet/minecraft/util/math/shapes/VoxelShape;"; private static final String isOpaqueCube = "Lnet/minecraft/block/Block;isOpaqueCube(Lnet/minecraft/block/BlockState;Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;)Z"; diff --git a/src/main/java/mods/betterfoliage/mixin/MixinBlockModelRenderer.java b/src/main/java/mods/betterfoliage/mixin/MixinBlockModelRenderer.java index eac0d80..1b1adea 100644 --- a/src/main/java/mods/betterfoliage/mixin/MixinBlockModelRenderer.java +++ b/src/main/java/mods/betterfoliage/mixin/MixinBlockModelRenderer.java @@ -8,7 +8,7 @@ import net.minecraft.block.BlockState; import net.minecraft.client.renderer.BlockModelRenderer; import net.minecraft.client.renderer.model.IBakedModel; import net.minecraft.util.math.BlockPos; -import net.minecraft.world.ILightReader; +import net.minecraft.world.IBlockDisplayReader; import net.minecraftforge.client.model.data.IModelData; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; @@ -19,12 +19,12 @@ import java.util.Random; @Mixin(BlockModelRenderer.class) public class MixinBlockModelRenderer { - private static final String renderModel = "Lnet/minecraft/client/renderer/BlockModelRenderer;renderModel(Lnet/minecraft/world/ILightReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z"; - private static final String renderModelFlat = "Lnet/minecraft/client/renderer/BlockModelRenderer;renderModelFlat(Lnet/minecraft/world/ILightReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z"; - private static final String renderModelSmooth = "Lnet/minecraft/client/renderer/BlockModelRenderer;renderModelSmooth(Lnet/minecraft/world/ILightReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z"; + private static final String renderModel = "Lnet/minecraft/client/renderer/BlockModelRenderer;renderModel(Lnet/minecraft/world/IBlockDisplayReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z"; + private static final String renderModelFlat = "Lnet/minecraft/client/renderer/BlockModelRenderer;renderModelFlat(Lnet/minecraft/world/IBlockDisplayReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z"; + private static final String renderModelSmooth = "Lnet/minecraft/client/renderer/BlockModelRenderer;renderModelSmooth(Lnet/minecraft/world/IBlockDisplayReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z"; @Redirect(method = renderModel, at = @At(value = "INVOKE", target = renderModelSmooth), remap = false) - public boolean onRenderModelSmooth(BlockModelRenderer renderer, ILightReader world, IBakedModel model, BlockState state, BlockPos pos, MatrixStack matrixStack, IVertexBuilder buffer, boolean checkSides, Random random, long rand, int combinedOverlay, IModelData modelData) { + public boolean onRenderModelSmooth(BlockModelRenderer renderer, IBlockDisplayReader world, IBakedModel model, BlockState state, BlockPos pos, MatrixStack matrixStack, IVertexBuilder buffer, boolean checkSides, Random random, long rand, int combinedOverlay, IModelData modelData) { if (model instanceof SpecialRenderModel) return RenderCtxVanilla.render(renderer, world, (SpecialRenderModel) model, state, pos, matrixStack, buffer, checkSides, random, rand, combinedOverlay, modelData, true); else @@ -32,7 +32,7 @@ public class MixinBlockModelRenderer { } @Redirect(method = renderModel, at = @At(value = "INVOKE", target = renderModelFlat), remap = false) - public boolean onRenderModelFlat(BlockModelRenderer renderer, ILightReader world, IBakedModel model, BlockState state, BlockPos pos, MatrixStack matrixStack, IVertexBuilder buffer, boolean checkSides, Random random, long rand, int combinedOverlay, IModelData modelData) { + public boolean onRenderModelFlat(BlockModelRenderer renderer, IBlockDisplayReader world, IBakedModel model, BlockState state, BlockPos pos, MatrixStack matrixStack, IVertexBuilder buffer, boolean checkSides, Random random, long rand, int combinedOverlay, IModelData modelData) { if (model instanceof SpecialRenderModel) return RenderCtxVanilla.render(renderer, world, (SpecialRenderModel) model, state, pos, matrixStack, buffer, checkSides, random, rand, combinedOverlay, modelData, false); else diff --git a/src/main/java/mods/betterfoliage/mixin/MixinBlockState.java b/src/main/java/mods/betterfoliage/mixin/MixinBlockState.java index b1c9a53..f389998 100644 --- a/src/main/java/mods/betterfoliage/mixin/MixinBlockState.java +++ b/src/main/java/mods/betterfoliage/mixin/MixinBlockState.java @@ -1,12 +1,15 @@ package mods.betterfoliage.mixin; import mods.betterfoliage.Hooks; +import net.minecraft.block.AbstractBlock; import net.minecraft.block.Block; import net.minecraft.block.BlockState; import net.minecraft.util.math.BlockPos; import net.minecraft.world.IBlockReader; +import org.spongepowered.asm.mixin.Debug; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Coerce; import org.spongepowered.asm.mixin.injection.Redirect; /** @@ -14,14 +17,15 @@ import org.spongepowered.asm.mixin.injection.Redirect; * * Needed to avoid excessive darkening of Round Logs at the corners, now that they are not full blocks. */ -@Mixin(BlockState.class) +@Mixin(AbstractBlock.AbstractBlockState.class) @SuppressWarnings({"deprecation"}) public class MixinBlockState { - private static final String callFrom = "Lnet/minecraft/block/BlockState;getAmbientOcclusionLightValue(Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;)F"; - private static final String callTo = "Lnet/minecraft/block/Block;getAmbientOcclusionLightValue(Lnet/minecraft/block/BlockState;Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;)F"; + private static final String callFrom = "Lnet/minecraft/block/AbstractBlock$AbstractBlockState;getShadeBrightness(Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;)F"; + // why is the INVOKEVIRTUAL target class Block in the bytecode, not AbstractBlock? + private static final String callTo = "Lnet/minecraft/block/Block;getShadeBrightness(Lnet/minecraft/block/BlockState;Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;)F"; @Redirect(method = callFrom, at = @At(value = "INVOKE", target = callTo)) float getAmbientOcclusionValue(Block block, BlockState state, IBlockReader reader, BlockPos pos) { - return Hooks.getAmbientOcclusionLightValueOverride(block.getAmbientOcclusionLightValue(state, reader, pos), state); + return Hooks.getAmbientOcclusionLightValueOverride(block.getShadeBrightness(state, reader, pos), state); } } diff --git a/src/main/java/mods/betterfoliage/mixin/MixinClientWorld.java b/src/main/java/mods/betterfoliage/mixin/MixinClientWorld.java index 00b8329..e3238d6 100644 --- a/src/main/java/mods/betterfoliage/mixin/MixinClientWorld.java +++ b/src/main/java/mods/betterfoliage/mixin/MixinClientWorld.java @@ -17,18 +17,18 @@ import java.util.Random; @Mixin(ClientWorld.class) public class MixinClientWorld { - private static final String worldAnimateTick = "Lnet/minecraft/client/world/ClientWorld;animateTick(IIIILjava/util/Random;ZLnet/minecraft/util/math/BlockPos$Mutable;)V"; + private static final String worldAnimateTick = "Lnet/minecraft/client/world/ClientWorld;doAnimateTick(IIIILjava/util/Random;ZLnet/minecraft/util/math/BlockPos$Mutable;)V"; private static final String blockAnimateTick = "Lnet/minecraft/block/Block;animateTick(Lnet/minecraft/block/BlockState;Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Ljava/util/Random;)V"; - private static final String worldNotify = "Lnet/minecraft/client/world/ClientWorld;notifyBlockUpdate(Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/BlockState;Lnet/minecraft/block/BlockState;I)V"; - private static final String rendererNotify = "Lnet/minecraft/client/renderer/WorldRenderer;notifyBlockUpdate(Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/BlockState;Lnet/minecraft/block/BlockState;I)V"; + private static final String worldNotify = "Lnet/minecraft/client/world/ClientWorld;sendBlockUpdated(Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/BlockState;Lnet/minecraft/block/BlockState;I)V"; + private static final String rendererNotify = "Lnet/minecraft/client/renderer/WorldRenderer;blockChanged(Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/BlockState;Lnet/minecraft/block/BlockState;I)V"; /** * Inject a callback to call for every random display tick. Used for adding custom particle effects to blocks. */ @Redirect(method = worldAnimateTick, at = @At(value = "INVOKE", target = blockAnimateTick)) void onAnimateTick(Block block, BlockState state, World world, BlockPos pos, Random random) { - Hooks.onRandomDisplayTick(block, state, world, pos, random); + Hooks.onRandomDisplayTick(block, state, (ClientWorld) world, pos, random); block.animateTick(state, world, pos, random); } @@ -39,6 +39,6 @@ public class MixinClientWorld { @Redirect(method = worldNotify, at = @At(value = "INVOKE", target = rendererNotify)) void onClientBlockChanged(WorldRenderer renderer, IBlockReader world, BlockPos pos, BlockState oldState, BlockState newState, int flags) { Hooks.onClientBlockChanged((ClientWorld) world, pos, oldState, newState, flags); - renderer.notifyBlockUpdate(world, pos, oldState, newState, flags); + renderer.blockChanged(world, pos, oldState, newState, flags); } } diff --git a/src/main/java/mods/betterfoliage/mixin/MixinForgeBlockModelRenderer.java b/src/main/java/mods/betterfoliage/mixin/MixinForgeBlockModelRenderer.java index d88a15d..5643ed3 100644 --- a/src/main/java/mods/betterfoliage/mixin/MixinForgeBlockModelRenderer.java +++ b/src/main/java/mods/betterfoliage/mixin/MixinForgeBlockModelRenderer.java @@ -1,12 +1,12 @@ package mods.betterfoliage.mixin; import com.mojang.blaze3d.matrix.MatrixStack; -import mods.betterfoliage.render.pipeline.RenderCtxForge; import mods.betterfoliage.model.SpecialRenderModel; +import mods.betterfoliage.render.pipeline.RenderCtxForge; import net.minecraft.block.BlockState; import net.minecraft.client.renderer.model.IBakedModel; import net.minecraft.util.math.BlockPos; -import net.minecraft.world.ILightReader; +import net.minecraft.world.IBlockDisplayReader; import net.minecraftforge.client.model.data.IModelData; import net.minecraftforge.client.model.pipeline.ForgeBlockModelRenderer; import net.minecraftforge.client.model.pipeline.VertexLighterFlat; @@ -19,14 +19,14 @@ import java.util.Random; @Mixin(ForgeBlockModelRenderer.class) public class MixinForgeBlockModelRenderer { - private static final String renderModelFlat = "renderModelFlat(Lnet/minecraft/world/ILightReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z"; - private static final String renderModelSmooth = "renderModelSmooth(Lnet/minecraft/world/ILightReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z"; - private static final String render = "Lnet/minecraftforge/client/model/pipeline/ForgeBlockModelRenderer;render(Lnet/minecraftforge/client/model/pipeline/VertexLighterFlat;Lnet/minecraft/world/ILightReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;ZLjava/util/Random;JLnet/minecraftforge/client/model/data/IModelData;)Z"; + private static final String renderModelFlat = "Lnet/minecraftforge/client/model/pipeline/ForgeBlockModelRenderer;renderModelFlat(Lnet/minecraft/world/IBlockDisplayReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z"; + private static final String renderModelSmooth = "Lnet/minecraftforge/client/model/pipeline/ForgeBlockModelRenderer;renderModelSmooth(Lnet/minecraft/world/IBlockDisplayReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z"; + private static final String render = "Lnet/minecraftforge/client/model/pipeline/ForgeBlockModelRenderer;render(Lnet/minecraftforge/client/model/pipeline/VertexLighterFlat;Lnet/minecraft/world/IBlockDisplayReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;ZLjava/util/Random;JLnet/minecraftforge/client/model/data/IModelData;)Z"; @Redirect(method = {renderModelFlat, renderModelSmooth}, at = @At(value = "INVOKE", target = render), remap = false) public boolean render( VertexLighterFlat lighter, - ILightReader world, + IBlockDisplayReader world, IBakedModel model, BlockState state, BlockPos pos, diff --git a/src/main/java/mods/betterfoliage/mixin/MixinModelBakery.java b/src/main/java/mods/betterfoliage/mixin/MixinModelBakery.java index a17df01..37cd6a0 100644 --- a/src/main/java/mods/betterfoliage/mixin/MixinModelBakery.java +++ b/src/main/java/mods/betterfoliage/mixin/MixinModelBakery.java @@ -20,13 +20,13 @@ abstract public class MixinModelBakery { private static final String processLoading = "Lnet/minecraft/client/renderer/model/ModelBakery;processLoading(Lnet/minecraft/profiler/IProfiler;I)V"; private static final String stitch = "Lnet/minecraft/client/renderer/texture/AtlasTexture;stitch(Lnet/minecraft/resources/IResourceManager;Ljava/util/stream/Stream;Lnet/minecraft/profiler/IProfiler;I)Lnet/minecraft/client/renderer/texture/AtlasTexture$SheetData;"; - private static final String profilerSection = "Lnet/minecraft/profiler/IProfiler;endStartSection(Ljava/lang/String;)V"; + private static final String profilerSection = "Lnet/minecraft/profiler/IProfiler;popPush(Ljava/lang/String;)V"; private static final String getBakedModel = "Lnet/minecraft/client/renderer/model/ModelBakery;getBakedModel(Lnet/minecraft/util/ResourceLocation;Lnet/minecraft/client/renderer/model/IModelTransform;Ljava/util/function/Function;)Lnet/minecraft/client/renderer/model/IBakedModel;"; - private static final String bakeModel = "Lnet/minecraft/client/renderer/model/IUnbakedModel;bakeModel(Lnet/minecraft/client/renderer/model/ModelBakery;Ljava/util/function/Function;Lnet/minecraft/client/renderer/model/IModelTransform;Lnet/minecraft/util/ResourceLocation;)Lnet/minecraft/client/renderer/model/IBakedModel;"; + private static final String bakeModel = "Lnet/minecraft/client/renderer/model/IUnbakedModel;bake(Lnet/minecraft/client/renderer/model/ModelBakery;Ljava/util/function/Function;Lnet/minecraft/client/renderer/model/IModelTransform;Lnet/minecraft/util/ResourceLocation;)Lnet/minecraft/client/renderer/model/IBakedModel;"; @Inject(method = processLoading, at = @At(value = "INVOKE", target = profilerSection, ordinal = 4)) void onBeforeTextures(IProfiler profiler, int maxMipmapLevel, CallbackInfo ci) { - profiler.endStartSection("betterfoliage"); + profiler.popPush("betterfoliage"); BetterFoliageMod.INSTANCE.getBus().post(new ModelDefinitionsLoadedEvent(ModelBakery.class.cast(this))); } @@ -34,7 +34,7 @@ abstract public class MixinModelBakery { IBakedModel onBakeModel( IUnbakedModel unbaked, ModelBakery bakery, - Function spriteGetter, + Function spriteGetter, IModelTransform transform, ResourceLocation locationIn ) { diff --git a/src/main/kotlin/mods/betterfoliage/BetterFoliage.kt b/src/main/kotlin/mods/betterfoliage/BetterFoliage.kt index ec4d2c6..5b67b90 100644 --- a/src/main/kotlin/mods/betterfoliage/BetterFoliage.kt +++ b/src/main/kotlin/mods/betterfoliage/BetterFoliage.kt @@ -31,6 +31,7 @@ import mods.betterfoliage.resource.discovery.ModelDefinitionsLoadedEvent import mods.betterfoliage.resource.generated.GeneratedTexturePack import mods.betterfoliage.render.particle.LeafParticleRegistry import mods.betterfoliage.render.particle.RisingSoulParticle +import mods.betterfoliage.util.resourceManager import net.minecraft.block.BlockState import net.minecraft.client.Minecraft import net.minecraft.resources.IReloadableResourceManager @@ -51,7 +52,7 @@ object BetterFoliage { // discoverers BetterFoliageMod.bus.register(BakeWrapperManager) BetterFoliageMod.bus.register(LeafParticleRegistry) - (Minecraft.getInstance().resourceManager as IReloadableResourceManager).addReloadListener(LeafParticleRegistry) + resourceManager.registerReloadListener(LeafParticleRegistry) ChunkOverlayManager.layers.add(RoundLogOverlayLayer) diff --git a/src/main/kotlin/mods/betterfoliage/BetterFoliageMod.kt b/src/main/kotlin/mods/betterfoliage/BetterFoliageMod.kt index 196ce4a..989c1b2 100644 --- a/src/main/kotlin/mods/betterfoliage/BetterFoliageMod.kt +++ b/src/main/kotlin/mods/betterfoliage/BetterFoliageMod.kt @@ -2,7 +2,6 @@ package mods.betterfoliage import mods.betterfoliage.config.BlockConfig import mods.betterfoliage.config.Config -import net.alexwells.kottle.FMLKotlinModLoadingContext import net.minecraft.client.Minecraft import net.minecraftforge.fml.ModLoadingContext import net.minecraftforge.fml.common.Mod @@ -11,6 +10,7 @@ import org.apache.logging.log4j.Level import org.apache.logging.log4j.LogManager import org.apache.logging.log4j.simple.SimpleLogger import org.apache.logging.log4j.util.PropertiesUtil +import thedarkcolour.kotlinforforge.forge.MOD_BUS import java.io.File import java.io.PrintStream import java.util.Properties @@ -19,7 +19,7 @@ import java.util.Properties object BetterFoliageMod { const val MOD_ID = "betterfoliage" - val bus = FMLKotlinModLoadingContext.get().modEventBus + val bus = MOD_BUS val detailLogStream = PrintStream(File("logs/betterfoliage.log").apply { parentFile.mkdirs() @@ -33,7 +33,7 @@ object BetterFoliageMod { init { ModLoadingContext.get().registerConfig(ModConfig.Type.CLIENT, Config.build()) - Minecraft.getInstance().resourcePackList.addPackFinder(BetterFoliage.generatedPack.finder) + Minecraft.getInstance().resourcePackRepository.addPackFinder(BetterFoliage.generatedPack.finder) bus.register(BlockConfig) BetterFoliage.init() } diff --git a/src/main/kotlin/mods/betterfoliage/CommonRefs.kt b/src/main/kotlin/mods/betterfoliage/CommonRefs.kt index a3344c1..a47c62d 100644 --- a/src/main/kotlin/mods/betterfoliage/CommonRefs.kt +++ b/src/main/kotlin/mods/betterfoliage/CommonRefs.kt @@ -17,11 +17,11 @@ import net.minecraft.client.renderer.model.ModelBakery import net.minecraft.client.renderer.texture.TextureAtlasSprite import net.minecraft.util.ResourceLocation import net.minecraft.util.math.BlockPos +import net.minecraft.world.IBlockDisplayReader import net.minecraft.world.IBlockReader -import net.minecraft.world.ILightReader import net.minecraftforge.client.model.pipeline.BlockInfo import net.minecraftforge.client.model.pipeline.VertexLighterFlat -import java.util.* +import java.util.Random // Java val String = ClassRef("java.lang.String") @@ -32,7 +32,7 @@ fun mapRefMutable() = ClassRef>("java.util.Map") // Minecraft val IBlockReader = ClassRef("net.minecraft.world.IBlockReader") -val ILightReader = ClassRef("net.minecraft.world.ILightReader") +val ILightReader = ClassRef("net.minecraft.world.IBlockDisplayReader") val BlockState = ClassRef("net.minecraft.block.BlockState") val BlockPos = ClassRef("net.minecraft.util.math.BlockPos") val Block = ClassRef("net.minecraft.block.Block") diff --git a/src/main/kotlin/mods/betterfoliage/Hooks.kt b/src/main/kotlin/mods/betterfoliage/Hooks.kt index 0491fa4..995288a 100644 --- a/src/main/kotlin/mods/betterfoliage/Hooks.kt +++ b/src/main/kotlin/mods/betterfoliage/Hooks.kt @@ -20,8 +20,8 @@ import net.minecraft.util.Direction.UP import net.minecraft.util.math.BlockPos import net.minecraft.util.math.shapes.VoxelShape import net.minecraft.util.math.shapes.VoxelShapes +import net.minecraft.world.IBlockDisplayReader import net.minecraft.world.IBlockReader -import net.minecraft.world.ILightReader import net.minecraft.world.World import java.util.Random @@ -35,11 +35,11 @@ fun onClientBlockChanged(worldClient: ClientWorld, pos: BlockPos, oldState: Bloc ChunkOverlayManager.onBlockChange(worldClient, pos) } -fun onRandomDisplayTick(block: Block, state: BlockState, world: World, pos: BlockPos, random: Random) { +fun onRandomDisplayTick(block: Block, state: BlockState, world: ClientWorld, pos: BlockPos, random: Random) { if (Config.enabled && Config.risingSoul.enabled && state.block == Blocks.SOUL_SAND && - world.isAirBlock(pos.offset(UP)) && + world.getBlockState(pos.relative(UP)).isAir && Math.random() < Config.risingSoul.chance) { RisingSoulParticle(world, pos).addIfValid() } @@ -47,7 +47,7 @@ fun onRandomDisplayTick(block: Block, state: BlockState, world: World, pos: Bloc if (Config.enabled && Config.fallingLeaves.enabled && random.nextDouble() < Config.fallingLeaves.chance && - world.isAirBlock(pos.offset(DOWN)) + world.getBlockState(pos.relative(DOWN)).isAir ) { (getActualRenderModel(world, pos, state, random) as? LeafBlockModel)?.let { leafModel -> val blockColor = Minecraft.getInstance().blockColors.getColor(state, world, pos, 0) @@ -63,13 +63,13 @@ fun getVoxelShapeOverride(state: BlockState, reader: IBlockReader, pos: BlockPos } fun shouldForceSideRenderOF(state: BlockState, world: IBlockReader, pos: BlockPos, face: Direction) = - world.getBlockState(pos.offset(face)).let { neighbor -> BetterFoliage.blockTypes.hasTyped(neighbor) } + world.getBlockState(pos.relative(face)).let { neighbor -> BetterFoliage.blockTypes.hasTyped(neighbor) } -fun getActualRenderModel(world: ILightReader, pos: BlockPos, state: BlockState, random: Random): SpecialRenderModel? { - val model = Minecraft.getInstance().blockRendererDispatcher.blockModelShapes.getModel(state) as? SpecialRenderModel +fun getActualRenderModel(world: IBlockDisplayReader, pos: BlockPos, state: BlockState, random: Random): SpecialRenderModel? { + val model = Minecraft.getInstance().blockRenderer.blockModelShaper.getBlockModel(state) as? SpecialRenderModel ?: return null if (model is WeightedModelWrapper) { - random.setSeed(state.getPositionRandom(pos)) + random.setSeed(state.getSeed(pos)) return model.getModel(random).model } return model diff --git a/src/main/kotlin/mods/betterfoliage/chunk/BlockContext.kt b/src/main/kotlin/mods/betterfoliage/chunk/BlockContext.kt index 78140ef..eab7fc6 100644 --- a/src/main/kotlin/mods/betterfoliage/chunk/BlockContext.kt +++ b/src/main/kotlin/mods/betterfoliage/chunk/BlockContext.kt @@ -1,7 +1,6 @@ package mods.betterfoliage.chunk import mods.betterfoliage.util.Int3 -import mods.betterfoliage.util.allDirections import mods.betterfoliage.util.offset import mods.betterfoliage.util.plus import mods.betterfoliage.util.semiRandom @@ -10,7 +9,7 @@ import net.minecraft.block.BlockState import net.minecraft.client.renderer.chunk.ChunkRenderCache import net.minecraft.util.Direction import net.minecraft.util.math.BlockPos -import net.minecraft.world.ILightReader +import net.minecraft.world.IBlockDisplayReader import net.minecraft.world.IWorldReader import net.minecraft.world.biome.Biome import net.minecraft.world.level.ColorResolver @@ -20,7 +19,7 @@ import net.minecraft.world.level.ColorResolver * block-relative coordinates. */ interface BlockCtx { - val world: ILightReader + val world: IBlockDisplayReader val pos: BlockPos fun offset(dir: Direction) = offset(dir.offset) @@ -35,13 +34,13 @@ interface BlockCtx { val biome: Biome? get() = (world as? IWorldReader)?.getBiome(pos) ?: - (world as? ChunkRenderCache)?.world?.getBiome(pos) + (world as? ChunkRenderCache)?.level?.getBiome(pos) - val isNormalCube: Boolean get() = state.isNormalCube(world, pos) + val isFullBlock: Boolean get() = state.isCollisionShapeFullBlock(world, pos) - fun isNeighborSolid(dir: Direction) = offset(dir).let { it.state.isSolidSide(it.world, it.pos, dir.opposite) } + fun isNeighborSturdy(dir: Direction) = offset(dir).let { it.state.isFaceSturdy(it.world, it.pos, dir.opposite) } - fun shouldSideBeRendered(side: Direction) = Block.shouldSideBeRendered(state, world, pos, side) + fun shouldSideBeRendered(side: Direction) = Block.shouldRenderFace(state, world, pos, side) /** Get a semi-random value based on the block coordinate and the given seed. */ fun semiRandom(seed: Int) = pos.semiRandom(seed) @@ -49,11 +48,11 @@ interface BlockCtx { /** Get an array of semi-random values based on the block coordinate. */ fun semiRandomArray(num: Int): Array = Array(num) { semiRandom(it) } - fun color(resolver: ColorResolver) = world.getBlockColor(pos, resolver) + fun color(resolver: ColorResolver) = world.getBlockTint(pos, resolver) } class BasicBlockCtx( - override val world: ILightReader, + override val world: IBlockDisplayReader, override val pos: BlockPos ) : BlockCtx { override val state: BlockState = world.getBlockState(pos) diff --git a/src/main/kotlin/mods/betterfoliage/chunk/Overlay.kt b/src/main/kotlin/mods/betterfoliage/chunk/Overlay.kt index 7c8f208..4c7884e 100644 --- a/src/main/kotlin/mods/betterfoliage/chunk/Overlay.kt +++ b/src/main/kotlin/mods/betterfoliage/chunk/Overlay.kt @@ -1,32 +1,26 @@ package mods.betterfoliage.chunk -import mods.octarinecore.ChunkCacheOF import mods.betterfoliage.util.get import mods.betterfoliage.util.isInstance +import mods.octarinecore.ChunkCacheOF import net.minecraft.client.renderer.chunk.ChunkRenderCache import net.minecraft.client.world.ClientWorld import net.minecraft.util.math.BlockPos import net.minecraft.util.math.ChunkPos -import net.minecraft.world.ILightReader +import net.minecraft.world.DimensionType +import net.minecraft.world.IBlockDisplayReader import net.minecraft.world.IWorldReader -import net.minecraft.world.dimension.DimensionType import net.minecraftforge.common.MinecraftForge import net.minecraftforge.event.world.ChunkEvent import net.minecraftforge.event.world.WorldEvent import net.minecraftforge.eventbus.api.SubscribeEvent import java.util.* -import kotlin.collections.List -import kotlin.collections.MutableMap -import kotlin.collections.associateWith -import kotlin.collections.forEach -import kotlin.collections.mutableListOf -import kotlin.collections.mutableMapOf import kotlin.collections.set -val ILightReader.dimType: DimensionType get() = when { - this is IWorldReader -> dimension.type - this is ChunkRenderCache -> world.dimension.type - this.isInstance(ChunkCacheOF) -> this[ChunkCacheOF.chunkCache].world.dimension.type +val IBlockDisplayReader.dimType: DimensionType get() = when { + this is IWorldReader -> dimensionType() + this is ChunkRenderCache -> level.dimensionType() + this.isInstance(ChunkCacheOF) -> this[ChunkCacheOF.chunkCache].level.dimensionType() else -> throw IllegalArgumentException("DimensionType of world with class ${this::class.qualifiedName} cannot be determined!") } @@ -35,7 +29,7 @@ val ILightReader.dimType: DimensionType get() = when { */ interface ChunkOverlayLayer { fun calculate(ctx: BlockCtx): T - fun onBlockUpdate(world: ILightReader, pos: BlockPos) + fun onBlockUpdate(world: IBlockDisplayReader, pos: BlockPos) } /** diff --git a/src/main/kotlin/mods/betterfoliage/config/Config.kt b/src/main/kotlin/mods/betterfoliage/config/Config.kt index 552127f..b619620 100644 --- a/src/main/kotlin/mods/betterfoliage/config/Config.kt +++ b/src/main/kotlin/mods/betterfoliage/config/Config.kt @@ -55,6 +55,7 @@ object Config : DelegatingConfig(BetterFoliageMod.MOD_ID, BetterFoliageMod.MOD_I object roundLogs : ConfigCategory(){ val enabled by featureEnable() + val plantsOnly by boolean(true) val radiusSmall by double(max=0.5, default=0.25) val radiusLarge by double(max=0.5, default=0.44) val dimming by double(default = 0.7) diff --git a/src/main/kotlin/mods/betterfoliage/config/MiscDefaults.kt b/src/main/kotlin/mods/betterfoliage/config/MiscDefaults.kt index 29ab431..93151ba 100644 --- a/src/main/kotlin/mods/betterfoliage/config/MiscDefaults.kt +++ b/src/main/kotlin/mods/betterfoliage/config/MiscDefaults.kt @@ -14,5 +14,7 @@ val MYCELIUM_BLOCKS = listOf(Blocks.MYCELIUM) val SALTWATER_BIOMES = listOf(Biome.Category.BEACH, Biome.Category.OCEAN) -val SNOW_MATERIALS = listOf(Material.SNOW_BLOCK, Material.SNOW) -val BlockState.isSnow: Boolean get() = material in SNOW_MATERIALS \ No newline at end of file +val SNOW_MATERIALS = listOf(Material.TOP_SNOW, Material.SNOW) +val BlockState.isSnow: Boolean get() = material in SNOW_MATERIALS + +val ACCEPTED_ROUND_LOG_MATERIALS = listOf(Material.WOOD, Material.GRASS) diff --git a/src/main/kotlin/mods/betterfoliage/integration/OptifineCustomColors.kt b/src/main/kotlin/mods/betterfoliage/integration/OptifineCustomColors.kt index 906ca70..6e7c3ed 100644 --- a/src/main/kotlin/mods/betterfoliage/integration/OptifineCustomColors.kt +++ b/src/main/kotlin/mods/betterfoliage/integration/OptifineCustomColors.kt @@ -34,7 +34,7 @@ object OptifineCustomColors { val fakeQuad = BakedQuad(IntArray(0), 1, UP, null, true) fun getBlockColor(ctx: BlockCtx, resolver: ColorResolver): Int { - val ofColor = if (isColorAvailable && Minecraft.getInstance().gameSettings.reflectField("ofCustomColors") == true) { + val ofColor = if (isColorAvailable && Minecraft.getInstance().options.reflectField("ofCustomColors") == true) { renderEnv.reset(ctx.state, ctx.pos) CustomColors.getColorMultiplier.invokeStatic(fakeQuad, ctx.state, ctx.world, ctx.pos, renderEnv.wrapped) as? Int } else null diff --git a/src/main/kotlin/mods/betterfoliage/integration/ShadersModIntegration.kt b/src/main/kotlin/mods/betterfoliage/integration/ShadersModIntegration.kt index 7b7a050..a4de3c9 100644 --- a/src/main/kotlin/mods/betterfoliage/integration/ShadersModIntegration.kt +++ b/src/main/kotlin/mods/betterfoliage/integration/ShadersModIntegration.kt @@ -1,8 +1,6 @@ package mods.betterfoliage.integration -import mods.betterfoliage.config.BlockConfig import mods.betterfoliage.render.pipeline.RenderCtxBase -import mods.betterfoliage.render.pipeline.RenderCtxForge import mods.betterfoliage.render.pipeline.RenderCtxVanilla import mods.betterfoliage.util.HasLogger import mods.betterfoliage.util.allAvailable @@ -14,7 +12,7 @@ import net.minecraft.block.BlockState import net.minecraft.block.Blocks import net.minecraft.client.renderer.BufferBuilder import net.minecraft.util.math.BlockPos -import net.minecraft.world.ILightReader +import net.minecraft.world.IBlockDisplayReader import org.apache.logging.log4j.Level.INFO /** @@ -23,14 +21,14 @@ import org.apache.logging.log4j.Level.INFO object ShadersModIntegration : HasLogger() { @JvmStatic val isAvailable = allAvailable(SVertexBuilder, SVertexBuilder.pushState, SVertexBuilder.popState, BlockAliases.getAliasBlockId) - val defaultLeaves = Blocks.OAK_LEAVES.defaultState - val defaultGrass = Blocks.GRASS.defaultState + val defaultLeaves = Blocks.OAK_LEAVES.defaultBlockState() + val defaultGrass = Blocks.GRASS.defaultBlockState() /** * Called from transformed ShadersMod code. * @see mods.betterfoliage.loader.BetterFoliageTransformer */ - @JvmStatic fun getBlockStateOverride(state: BlockState, world: ILightReader, pos: BlockPos): BlockState { + @JvmStatic fun getBlockStateOverride(state: BlockState, world: IBlockDisplayReader, pos: BlockPos): BlockState { // if (LeafRegistry[state, world, pos] != null) return defaultLeaves // if (BlockConfig.crops.matchesClass(state.block)) return defaultGrass return state diff --git a/src/main/kotlin/mods/betterfoliage/model/HalfBaked.kt b/src/main/kotlin/mods/betterfoliage/model/HalfBaked.kt index 631cf0b..8288f3b 100644 --- a/src/main/kotlin/mods/betterfoliage/model/HalfBaked.kt +++ b/src/main/kotlin/mods/betterfoliage/model/HalfBaked.kt @@ -68,8 +68,8 @@ fun List.bake(applyDiffuseLighting: Boolean) = map { quad -> ) // don't fill lightmap UV coords element.usage == VertexFormatElement.Usage.UV && element.type == VertexFormatElement.Type.FLOAT -> builder.put(idx, - quad.sprite.minU + (quad.sprite.maxU - quad.sprite.minU) * (vertex.uv.u + 0.5).toFloat(), - quad.sprite.minV + (quad.sprite.maxV - quad.sprite.minV) * (vertex.uv.v + 0.5).toFloat(), + quad.sprite.u0 + (quad.sprite.u1 - quad.sprite.u0) * (vertex.uv.u + 0.5).toFloat(), + quad.sprite.v0 + (quad.sprite.v1 - quad.sprite.v0) * (vertex.uv.v + 0.5).toFloat(), 0.0f, 1.0f ) element.usage == VertexFormatElement.Usage.COLOR -> builder.put(idx, @@ -96,18 +96,18 @@ fun Array>.bake(applyDiffuseLighting: Boolean) = mapArray { it.bake(a fun BakedQuad.unbake(): HalfBakedQuad { val size = DefaultVertexFormats.BLOCK.integerSize val verts = Array(4) { vIdx -> - val x = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 0]) - val y = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 1]) - val z = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 2]) - val color = vertexData[vIdx * size + 3] - val u = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 4]) - val v = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 5]) + val x = java.lang.Float.intBitsToFloat(vertices[vIdx * size + 0]) + val y = java.lang.Float.intBitsToFloat(vertices[vIdx * size + 1]) + val z = java.lang.Float.intBitsToFloat(vertices[vIdx * size + 2]) + val color = vertices[vIdx * size + 3] + val u = java.lang.Float.intBitsToFloat(vertices[vIdx * size + 4]) + val v = java.lang.Float.intBitsToFloat(vertices[vIdx * size + 5]) Vertex(Double3(x, y, z), UV(u.toDouble(), v.toDouble()), Color(color)) } val unbaked = Quad( verts[0], verts[1], verts[2], verts[3], - colorIndex = if (hasTintIndex()) tintIndex else -1, - face = face + colorIndex = if (isTinted) tintIndex else -1, + face = direction ) return HalfBakedQuad(unbaked, this) } diff --git a/src/main/kotlin/mods/betterfoliage/model/SpecialRenderModels.kt b/src/main/kotlin/mods/betterfoliage/model/SpecialRenderModels.kt index bb1a050..a0e67b3 100644 --- a/src/main/kotlin/mods/betterfoliage/model/SpecialRenderModels.kt +++ b/src/main/kotlin/mods/betterfoliage/model/SpecialRenderModels.kt @@ -1,17 +1,9 @@ package mods.betterfoliage.model import mods.betterfoliage.render.pipeline.RenderCtxBase -import mods.betterfoliage.util.HasLogger import net.minecraft.client.renderer.model.IBakedModel -import net.minecraft.client.renderer.model.Material -import net.minecraft.client.renderer.model.ModelBakery -import net.minecraft.client.renderer.model.VariantList -import net.minecraft.client.renderer.texture.TextureAtlasSprite -import net.minecraft.util.ResourceLocation import net.minecraft.util.WeightedRandom -import org.apache.logging.log4j.Level.WARN import java.util.Random -import java.util.function.Function /** * Model that makes use of advanced rendering features. @@ -24,9 +16,9 @@ class WeightedModelWrapper( val models: List, baseModel: SpecialRenderModel ): IBakedModel by baseModel, SpecialRenderModel { class WeightedModel(val model: SpecialRenderModel, weight: Int) : WeightedRandom.Item(weight) - val totalWeight = models.sumBy { it.itemWeight } + val totalWeight = models.sumBy { it.weight } - fun getModel(random: Random) = WeightedRandom.getRandomItem(models, random.nextInt(totalWeight)) + fun getModel(random: Random) = WeightedRandom.getWeightedItem(models, random.nextInt(totalWeight)) override fun render(ctx: RenderCtxBase, noDecorations: Boolean) { getModel(ctx.random).model.render(ctx, noDecorations) diff --git a/src/main/kotlin/mods/betterfoliage/model/SpriteSets.kt b/src/main/kotlin/mods/betterfoliage/model/SpriteSets.kt index c928e57..bedfb08 100644 --- a/src/main/kotlin/mods/betterfoliage/model/SpriteSets.kt +++ b/src/main/kotlin/mods/betterfoliage/model/SpriteSets.kt @@ -59,7 +59,7 @@ class SpriteSetDelegate( @SubscribeEvent fun handlePreStitch(event: TextureStitchEvent.Pre) { - if (event.map.textureLocation != Atlas.BLOCKS.resourceId) return + if (event.map.location() != Atlas.BLOCKS.resourceId) return spriteSet = null idList = (0 until 16) .map(idFunc) diff --git a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Dirt.kt b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Dirt.kt index 1694aed..27e2c0d 100644 --- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Dirt.kt +++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Dirt.kt @@ -1,10 +1,11 @@ package mods.betterfoliage.render.block.vanilla -import mods.betterfoliage.BetterFoliageMod import mods.betterfoliage.BetterFoliage +import mods.betterfoliage.BetterFoliageMod import mods.betterfoliage.config.Config import mods.betterfoliage.config.DIRT_BLOCKS import mods.betterfoliage.config.SALTWATER_BIOMES +import mods.betterfoliage.config.isSnow import mods.betterfoliage.integration.ShadersModIntegration import mods.betterfoliage.model.HalfBakedSpecialWrapper import mods.betterfoliage.model.HalfBakedWrapperKey @@ -15,7 +16,6 @@ import mods.betterfoliage.model.tuftModelSet import mods.betterfoliage.model.tuftShapeSet import mods.betterfoliage.render.lighting.LightingPreferredFace import mods.betterfoliage.render.pipeline.RenderCtxBase -import mods.betterfoliage.render.pipeline.RenderCtxVanilla import mods.betterfoliage.resource.discovery.AbstractModelDiscovery import mods.betterfoliage.resource.discovery.BakeWrapperManager import mods.betterfoliage.resource.discovery.ModelBakingContext @@ -27,20 +27,18 @@ import mods.betterfoliage.util.LazyInvalidatable import mods.betterfoliage.util.get import mods.betterfoliage.util.offset import mods.betterfoliage.util.randomI -import net.minecraft.block.Blocks import net.minecraft.block.material.Material import net.minecraft.client.renderer.RenderType import net.minecraft.client.renderer.RenderTypeLookup import net.minecraft.client.renderer.model.BlockModel import net.minecraft.util.Direction.UP import net.minecraft.util.ResourceLocation -import net.minecraft.world.biome.Biome object StandardDirtDiscovery : AbstractModelDiscovery() { fun canRenderInLayer(layer: RenderType) = when { - !Config.enabled -> layer == RenderType.getSolid() - !Config.connectedGrass.enabled && !Config.algae.enabled && !Config.reed.enabled -> layer == RenderType.getSolid() - else -> layer == RenderType.getCutoutMipped() + !Config.enabled -> layer == RenderType.solid() + !Config.connectedGrass.enabled && !Config.algae.enabled && !Config.reed.enabled -> layer == RenderType.solid() + else -> layer == RenderType.cutoutMipped() } override fun processModel(ctx: ModelDiscoveryContext) { @@ -67,9 +65,12 @@ class StandardDirtModel( val stateUp = ctx.state(UP) val state2Up = ctx.state(Int3(0, 2, 0)) - val isConnectedGrass = Config.connectedGrass.enabled && stateUp in BetterFoliage.blockTypes.grass + val isConnectedGrass = Config.connectedGrass.enabled && + stateUp in BetterFoliage.blockTypes.grass && + (Config.connectedGrass.snowEnabled || !state2Up.isSnow) + if (isConnectedGrass) { - (ctx.blockModelShapes.getModel(stateUp) as? SpecialRenderModel)?.let { grassModel -> + (ctx.blockModelShapes.getBlockModel(stateUp) as? SpecialRenderModel)?.let { grassModel -> ctx.renderMasquerade(UP.offset) { grassModel.render(ctx, true) } @@ -81,9 +82,9 @@ class StandardDirtModel( super.render(ctx, false) val isWater = stateUp.material == Material.WATER - val isDeepWater = isWater && ctx.offset(Int3(2 to UP)).state.material == Material.WATER - val isShallowWater = isWater && ctx.offset(Int3(2 to UP)).state.isAir - val isSaltWater = isWater && ctx.biome?.category in SALTWATER_BIOMES + val isDeepWater = isWater && state2Up.material == Material.WATER + val isShallowWater = isWater && state2Up.isAir + val isSaltWater = isWater && ctx.biome?.biomeCategory in SALTWATER_BIOMES if (Config.algae.enabled(ctx.random) && isDeepWater) { ctx.vertexLighter = vanillaTuftLighting diff --git a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Mycelium.kt b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Mycelium.kt index a43877a..420e406 100644 --- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Mycelium.kt +++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Mycelium.kt @@ -31,7 +31,7 @@ object StandardMyceliumDiscovery : AbstractModelDiscovery() { override fun processModel(ctx: ModelDiscoveryContext) { if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in MYCELIUM_BLOCKS) { ctx.addReplacement(StandardMyceliumKey) - RenderTypeLookup.setRenderLayer(ctx.blockState.block, RenderType.getCutout()) + RenderTypeLookup.setRenderLayer(ctx.blockState.block, RenderType.cutout()) } super.processModel(ctx) } diff --git a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Netherrack.kt b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Netherrack.kt index 168e07e..3ab10b6 100644 --- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Netherrack.kt +++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Netherrack.kt @@ -32,9 +32,9 @@ import net.minecraft.util.ResourceLocation object StandardNetherrackDiscovery : AbstractModelDiscovery() { fun canRenderInLayer(layer: RenderType) = when { - !Config.enabled -> layer == RenderType.getSolid() - !Config.netherrack.enabled -> layer == RenderType.getSolid() - else -> layer == RenderType.getCutoutMipped() + !Config.enabled -> layer == RenderType.solid() + !Config.netherrack.enabled -> layer == RenderType.solid() + else -> layer == RenderType.cutoutMipped() } override fun processModel(ctx: ModelDiscoveryContext) { diff --git a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/RoundLog.kt b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/RoundLog.kt index a9e31ea..5783420 100644 --- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/RoundLog.kt +++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/RoundLog.kt @@ -1,9 +1,9 @@ package mods.betterfoliage.render.block.vanilla import mods.betterfoliage.BetterFoliage +import mods.betterfoliage.config.ACCEPTED_ROUND_LOG_MATERIALS import mods.betterfoliage.config.BlockConfig import mods.betterfoliage.config.Config -import mods.betterfoliage.resource.discovery.ModelTextureList import mods.betterfoliage.model.HalfBakedWrapperKey import mods.betterfoliage.model.SpecialRenderModel import mods.betterfoliage.render.column.ColumnBlockKey @@ -16,11 +16,12 @@ import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery import mods.betterfoliage.resource.discovery.ModelBakingContext import mods.betterfoliage.resource.discovery.ModelBakingKey import mods.betterfoliage.resource.discovery.ModelDiscoveryContext +import mods.betterfoliage.resource.discovery.ModelTextureList import mods.betterfoliage.util.Atlas import mods.betterfoliage.util.LazyMapInvalidatable import mods.betterfoliage.util.tryDefault import net.minecraft.block.BlockState -import net.minecraft.block.LogBlock +import net.minecraft.block.RotatedPillarBlock import net.minecraft.util.Direction.Axis import net.minecraft.util.ResourceLocation import org.apache.logging.log4j.Level.INFO @@ -43,13 +44,15 @@ object StandardRoundLogDiscovery : ConfigurableModelDiscovery() { override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List) { val axis = getAxis(ctx.blockState) - detailLogger.log(INFO, " axis $axis") - ctx.addReplacement(StandardRoundLogKey(axis, textureMatch[0], textureMatch[1])) + + detailLogger.log(INFO, " axis $axis, material ${ctx.blockState.material}") + if (!Config.roundLogs.plantsOnly || ctx.blockState.material in ACCEPTED_ROUND_LOG_MATERIALS) + ctx.addReplacement(StandardRoundLogKey(axis, textureMatch[0], textureMatch[1])) } fun getAxis(state: BlockState): Axis? { - val axis = tryDefault(null) { state.get(LogBlock.AXIS).toString() } ?: - state.values.entries.find { it.key.getName().toLowerCase() == "axis" }?.value?.toString() + val axis = tryDefault(null) { state.getValue(RotatedPillarBlock.AXIS).toString() } ?: + state.values.entries.find { it.key.name.toLowerCase() == "axis" }?.value?.toString() return when (axis) { "x" -> Axis.X "y" -> Axis.Y diff --git a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Sand.kt b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Sand.kt index 41bfd48..e34996d 100644 --- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Sand.kt +++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Sand.kt @@ -43,7 +43,7 @@ object StandardSandDiscovery : AbstractModelDiscovery() { if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in SAND_BLOCKS) { BetterFoliage.blockTypes.dirt.add(ctx.blockState) ctx.addReplacement(StandardSandKey) - RenderTypeLookup.setRenderLayer(ctx.blockState.block, RenderType.getCutoutMipped()) + RenderTypeLookup.setRenderLayer(ctx.blockState.block, RenderType.cutoutMipped()) } super.processModel(ctx) } @@ -61,7 +61,7 @@ class StandardSandModel( override fun render(ctx: RenderCtxBase, noDecorations: Boolean) { super.render(ctx, noDecorations) if (noDecorations || !Config.enabled || !Config.coral.enabled(ctx.random)) return - if (ctx.biome?.category !in SALTWATER_BIOMES) return + if (ctx.biome?.biomeCategory !in SALTWATER_BIOMES) return allDirections.filter { ctx.random.nextInt(64) < Config.coral.chance }.forEach { face -> val isWater = ctx.state(face).material == Material.WATER diff --git a/src/main/kotlin/mods/betterfoliage/render/column/ColumnOverlayLayer.kt b/src/main/kotlin/mods/betterfoliage/render/column/ColumnOverlayLayer.kt index 7344abb..8fe727f 100644 --- a/src/main/kotlin/mods/betterfoliage/render/column/ColumnOverlayLayer.kt +++ b/src/main/kotlin/mods/betterfoliage/render/column/ColumnOverlayLayer.kt @@ -23,7 +23,7 @@ import net.minecraft.block.BlockState import net.minecraft.util.Direction import net.minecraft.util.Direction.Axis import net.minecraft.util.math.BlockPos -import net.minecraft.world.ILightReader +import net.minecraft.world.IBlockDisplayReader /** Index of SOUTH-EAST quadrant. */ const val SE = 0 @@ -83,13 +83,13 @@ abstract class ColumnRenderLayer : ChunkOverlayLayer { val allNeighborOffsets = (-1..1).flatMap { offsetX -> (-1..1).flatMap { offsetY -> (-1..1).map { offsetZ -> Int3(offsetX, offsetY, offsetZ) }}} - override fun onBlockUpdate(world: ILightReader, pos: BlockPos) { + override fun onBlockUpdate(world: IBlockDisplayReader, pos: BlockPos) { allNeighborOffsets.forEach { offset -> ChunkOverlayManager.clear(world.dimType, this, pos + offset) } } override fun calculate(ctx: BlockCtx): ColumnLayerData { // TODO detect round logs - if (allDirections.all { dir -> ctx.offset(dir).let { it.isNormalCube } }) return ColumnLayerData.SkipRender + if (allDirections.all { dir -> ctx.offset(dir).let { it.isFullBlock } }) return ColumnLayerData.SkipRender val columnTextures = getColumnKey(ctx.state) ?: return ColumnLayerData.ResolveError // if log axis is not defined and "Default to vertical" config option is not set, render normally @@ -185,7 +185,7 @@ abstract class ColumnRenderLayer : ChunkOverlayLayer { val offsetRot = offset.rotate(rotation) val key = getColumnKey(state(offsetRot)) return if (key == null) { - if (offset(offsetRot).isNormalCube) SOLID else NONSOLID + if (offset(offsetRot).isFullBlock) SOLID else NONSOLID } else { (key.axis ?: if (Config.roundLogs.defaultY) Axis.Y else null)?.let { if (it == axis) PARALLEL else PERPENDICULAR diff --git a/src/main/kotlin/mods/betterfoliage/render/lighting/VanillaAoCalculation.kt b/src/main/kotlin/mods/betterfoliage/render/lighting/VanillaAoCalculation.kt index d2eb5e7..fb0feeb 100644 --- a/src/main/kotlin/mods/betterfoliage/render/lighting/VanillaAoCalculation.kt +++ b/src/main/kotlin/mods/betterfoliage/render/lighting/VanillaAoCalculation.kt @@ -5,7 +5,7 @@ import net.minecraft.block.BlockState import net.minecraft.client.renderer.BlockModelRenderer import net.minecraft.util.Direction import net.minecraft.util.math.BlockPos -import net.minecraft.world.ILightReader +import net.minecraft.world.IBlockDisplayReader data class LightingData( @JvmField var packedLight: Int = 0, @@ -29,7 +29,7 @@ data class LightingData( * Not thread-safe, always use a [ThreadLocal] instance */ class VanillaAoCalculator { - lateinit var world: ILightReader + lateinit var world: IBlockDisplayReader /** [blockPos] is used to get block-related information (i.e. tint, opacity, etc.) * [lightPos] is used to get light-related information @@ -37,7 +37,7 @@ class VanillaAoCalculator { lateinit var blockPos: BlockPos lateinit var lightPos: BlockPos - private val probe = LightProbe(BlockModelRenderer.CACHE_COMBINED_LIGHT.get()) + private val probe = LightProbe(BlockModelRenderer.CACHE.get()) val isValid = BooleanArray(6) val aoData = Array(24) { LightingData() } @@ -70,13 +70,13 @@ class VanillaAoCalculator { // Bit 0 of the bitset in vanilla calculations // true if the block model is planar with the block boundary - val isFullBlock = forceFull ?: world.getBlockState(blockPos).isCollisionShapeOpaque(world, blockPos) + val isFullBlock = forceFull ?: world.getBlockState(blockPos).isCollisionShapeFullBlock(world, blockPos) - val lightOrigin = if (isFullBlock) lightPos.offset(lightFace) else lightPos + val lightOrigin = if (isFullBlock) lightPos.relative(lightFace) else lightPos // AO calculation for the face center - probe.position { setPos(lightOrigin) }.writeTo(centerAo) - if (!isFullBlock && !probe.position { move(lightFace) }.state.isOpaqueCube(world, probe.pos)) { + probe.position { set(lightOrigin) }.writeTo(centerAo) + if (!isFullBlock && !probe.position { move(lightFace) }.state.isSolidRender(world, probe.pos)) { // if the neighboring block in the lightface direction is // transparent (non-opaque), use its packed light instead of our own // (if our block is a full block, we are already using this value) @@ -86,7 +86,7 @@ class VanillaAoCalculator { // AO calculation for the 4 sides sideHelper.sides.forEachIndexed { sideIdx, sideDir -> // record light data in the block 1 step to the side - probe.position { setPos(lightOrigin).move(sideDir) }.writeTo(sideAo[sideIdx]) + probe.position { set(lightOrigin).move(sideDir) }.writeTo(sideAo[sideIdx]) // side is considered occluded if the block 1 step to that side and // 1 step forward (in the lightface direction) is not fully transparent isOccluded[sideIdx] = probe.position { move(lightFace) }.isNonTransparent @@ -103,7 +103,7 @@ class VanillaAoCalculator { else { // lookup actual packed light from the cornering block in the world probe.position { - setPos(lightOrigin) + set(lightOrigin) .move(sideHelper.sides[sideIndices.first]) .move(sideHelper.sides[sideIndices.second]) }.writeTo(cornerAo[cornerIdx]) @@ -129,9 +129,9 @@ class VanillaAoCalculator { lateinit var state: BlockState val pos = BlockPos.Mutable() - val packedLight: Int get() = cache.getPackedLight(state, world, pos) - val colorMultiplier: Float get() = cache.getBrightness(state, world, pos) - val isNonTransparent: Boolean get() = state.getOpacity(world, pos) > 0 + val packedLight: Int get() = cache.getLightColor(state, world, pos) + val colorMultiplier: Float get() = cache.getShadeBrightness(state, world, pos) + val isNonTransparent: Boolean get() = state.getLightBlock(world, pos) > 0 fun writeTo(data: LightingData) { data.packedLight = packedLight diff --git a/src/main/kotlin/mods/betterfoliage/render/lighting/VanillaVertexLighter.kt b/src/main/kotlin/mods/betterfoliage/render/lighting/VanillaVertexLighter.kt index 69435c4..fbe46c5 100644 --- a/src/main/kotlin/mods/betterfoliage/render/lighting/VanillaVertexLighter.kt +++ b/src/main/kotlin/mods/betterfoliage/render/lighting/VanillaVertexLighter.kt @@ -69,7 +69,7 @@ object VanillaFullBlockLighting : VanillaVertexLighter() { lighting.calc.fillLightData(face, true) lighting.updateWithCornerAo(quad) { nearestCornerOnFace(it, face) } lighting.updateBlockTint(quad.baked.tintIndex) - if (quad.baked.shouldApplyDiffuseLighting()) lighting.applyDiffuseLighting(face) + if (quad.baked.isShade) lighting.applyDiffuseLighting(face) } } diff --git a/src/main/kotlin/mods/betterfoliage/render/particle/AbstractParticle.kt b/src/main/kotlin/mods/betterfoliage/render/particle/AbstractParticle.kt index d06be4c..f95d516 100644 --- a/src/main/kotlin/mods/betterfoliage/render/particle/AbstractParticle.kt +++ b/src/main/kotlin/mods/betterfoliage/render/particle/AbstractParticle.kt @@ -5,12 +5,12 @@ import mods.betterfoliage.util.Double3 import net.minecraft.client.Minecraft import net.minecraft.client.particle.SpriteTexturedParticle import net.minecraft.client.renderer.ActiveRenderInfo -import net.minecraft.client.renderer.Vector3f import net.minecraft.client.renderer.texture.TextureAtlasSprite +import net.minecraft.client.world.ClientWorld import net.minecraft.util.math.MathHelper -import net.minecraft.world.World +import net.minecraft.util.math.vector.Vector3f -abstract class AbstractParticle(world: World, x: Double, y: Double, z: Double) : SpriteTexturedParticle(world, x, y, z) { +abstract class AbstractParticle(world: ClientWorld, x: Double, y: Double, z: Double) : SpriteTexturedParticle(world, x, y, z) { companion object { // @JvmStatic val sin = Array(64) { idx -> Math.sin(PI2 / 64.0 * idx) } @@ -24,12 +24,12 @@ abstract class AbstractParticle(world: World, x: Double, y: Double, z: Double) : override fun tick() { super.tick() - currentPos.setTo(posX, posY, posZ) - prevPos.setTo(prevPosX, prevPosY, prevPosZ) - velocity.setTo(motionX, motionY, motionZ) + currentPos.setTo(x, y, z) + prevPos.setTo(xo, yo, zo) + velocity.setTo(xd, yd, zd) update() - posX = currentPos.x; posY = currentPos.y; posZ = currentPos.z; - motionX = velocity.x; motionY = velocity.y; motionZ = velocity.z; + x = currentPos.x; y = currentPos.y; z = currentPos.z; + xd = velocity.x; yd = velocity.y; zd = velocity.z; } /** Update particle on world tick. */ @@ -39,10 +39,10 @@ abstract class AbstractParticle(world: World, x: Double, y: Double, z: Double) : abstract val isValid: Boolean /** Add the particle to the effect renderer if it is valid. */ - fun addIfValid() { if (isValid) Minecraft.getInstance().particles.addEffect(this) } + fun addIfValid() { if (isValid) Minecraft.getInstance().particleEngine.add(this) } - override fun renderParticle(vertexBuilder: IVertexBuilder, camera: ActiveRenderInfo, tickDelta: Float) { - super.renderParticle(vertexBuilder, camera, tickDelta) + override fun render(vertexBuilder: IVertexBuilder, camera: ActiveRenderInfo, tickDelta: Float) { + super.render(vertexBuilder, camera, tickDelta) } /** @@ -63,39 +63,39 @@ abstract class AbstractParticle(world: World, x: Double, y: Double, z: Double) : tickDelta: Float, currentPos: Double3 = this.currentPos, prevPos: Double3 = this.prevPos, - size: Double = particleScale.toDouble(), - currentAngle: Float = this.particleAngle, - prevAngle: Float = this.prevParticleAngle, + size: Double = quadSize.toDouble(), + currentAngle: Float = this.roll, + prevAngle: Float = this.oRoll, sprite: TextureAtlasSprite = this.sprite, - alpha: Float = this.particleAlpha) { + alpha: Float = this.alpha) { val center = Double3.lerp(tickDelta.toDouble(), prevPos, currentPos) val angle = MathHelper.lerp(tickDelta, prevAngle, currentAngle) - val rotation = camera.rotation.copy().apply { multiply(Vector3f.ZP.rotation(angle)) } - val lightmapCoord = getBrightnessForRender(tickDelta) + val rotation = camera.rotation().copy().apply { mul(Vector3f.ZP.rotation(angle)) } + val lightmapCoord = getLightColor(tickDelta) val coords = arrayOf( Double3(-1.0, -1.0, 0.0), Double3(-1.0, 1.0, 0.0), Double3(1.0, 1.0, 0.0), Double3(1.0, -1.0, 0.0) - ).map { it.rotate(rotation).mul(size).add(center).sub(camera.projectedView.x, camera.projectedView.y, camera.projectedView.z) } + ).map { it.rotate(rotation).mul(size).add(center).sub(camera.position.x, camera.position.y, camera.position.z) } fun renderVertex(vertex: Double3, u: Float, v: Float) = vertexConsumer - .pos(vertex.x, vertex.y, vertex.z).tex(u, v) - .color(particleRed, particleGreen, particleBlue, alpha).lightmap(lightmapCoord) + .vertex(vertex.x, vertex.y, vertex.z).uv(u, v) + .color(rCol, gCol, bCol, alpha).uv2(lightmapCoord) .endVertex() - renderVertex(coords[0], sprite.maxU, sprite.maxV) - renderVertex(coords[1], sprite.maxU, sprite.minV) - renderVertex(coords[2], sprite.minU, sprite.minV) - renderVertex(coords[3], sprite.minU, sprite.maxV) + renderVertex(coords[0], sprite.u1, sprite.v1) + renderVertex(coords[1], sprite.u1, sprite.v0) + renderVertex(coords[2], sprite.u0, sprite.v0) + renderVertex(coords[3], sprite.u0, sprite.v1) } fun setColor(color: Int) { - particleBlue = (color and 255) / 256.0f - particleGreen = ((color shr 8) and 255) / 256.0f - particleRed = ((color shr 16) and 255) / 256.0f + bCol = (color and 255) / 256.0f + gCol = ((color shr 8) and 255) / 256.0f + rCol = ((color shr 16) and 255) / 256.0f } } diff --git a/src/main/kotlin/mods/betterfoliage/render/particle/FallingLeaves.kt b/src/main/kotlin/mods/betterfoliage/render/particle/FallingLeaves.kt index 4030397..e1d8a89 100644 --- a/src/main/kotlin/mods/betterfoliage/render/particle/FallingLeaves.kt +++ b/src/main/kotlin/mods/betterfoliage/render/particle/FallingLeaves.kt @@ -8,22 +8,22 @@ import mods.betterfoliage.util.randomB import mods.betterfoliage.util.randomD import mods.betterfoliage.util.randomF import mods.betterfoliage.util.randomI -import net.minecraft.client.Minecraft import net.minecraft.client.particle.IParticleRenderType +import net.minecraft.client.world.ClientWorld import net.minecraft.util.math.BlockPos import net.minecraft.util.math.MathHelper import net.minecraft.world.World import net.minecraftforge.common.MinecraftForge import net.minecraftforge.event.TickEvent -import net.minecraftforge.event.world.WorldEvent import net.minecraftforge.eventbus.api.SubscribeEvent +import net.minecraftforge.fml.LogicalSide import java.util.Random import kotlin.math.abs import kotlin.math.cos import kotlin.math.sin class FallingLeafParticle( - world: World, pos: BlockPos, leaf: LeafParticleKey, blockColor: Int, random: Random + world: ClientWorld, pos: BlockPos, leaf: LeafParticleKey, blockColor: Int, random: Random ) : AbstractParticle( world, pos.x.toDouble() + 0.5, pos.y.toDouble(), pos.z.toDouble() + 0.5 ) { @@ -37,13 +37,13 @@ class FallingLeafParticle( var wasCollided = false init { - particleAngle = random.randomF(max = PI2) - prevParticleAngle = particleAngle - rotationSpeed + roll = random.randomF(max = PI2) + oRoll = roll - rotationSpeed - maxAge = MathHelper.floor(randomD(0.6, 1.0) * Config.fallingLeaves.lifetime * 20.0) - motionY = -Config.fallingLeaves.speed + lifetime = MathHelper.floor(randomD(0.6, 1.0) * Config.fallingLeaves.lifetime * 20.0) + yd = -Config.fallingLeaves.speed - particleScale = Config.fallingLeaves.size.toFloat() * 0.1f + quadSize = Config.fallingLeaves.size.toFloat() * 0.1f setColor(leaf.overrideColor?.asInt ?: blockColor) sprite = LeafParticleRegistry[leaf.leafType][randomI(max = 1024)] } @@ -52,21 +52,21 @@ class FallingLeafParticle( override fun update() { - if (rand.nextFloat() > 0.95f) rotationSpeed *= -1.0f - if (age > maxAge - 20) particleAlpha = 0.05f * (maxAge - age) + if (random.nextFloat() > 0.95f) rotationSpeed *= -1.0f + if (age > lifetime - 20) alpha = 0.05f * (lifetime - age) if (onGround || wasCollided) { velocity.setTo(0.0, 0.0, 0.0) if (!wasCollided) { - age = age.coerceAtLeast(maxAge - 20) + age = age.coerceAtLeast(lifetime - 20) wasCollided = true } } else { - val cosRotation = cos(particleAngle).toDouble(); val sinRotation = sin(particleAngle).toDouble() + val cosRotation = cos(roll).toDouble(); val sinRotation = sin(roll).toDouble() velocity.setTo(cosRotation, 0.0, sinRotation).mul(Config.fallingLeaves.perturb) .add(LeafWindTracker.current).add(0.0, -1.0, 0.0).mul(Config.fallingLeaves.speed) - prevParticleAngle = particleAngle - particleAngle += rotationSpeed + oRoll = roll + roll += rotationSpeed } } @@ -84,7 +84,7 @@ object LeafWindTracker { } fun changeWind(world: World) { - nextChange = world.worldInfo.gameTime + 120 + random.nextInt(80) + nextChange = world.gameTime + 120 + random.nextInt(80) val direction = PI2 * random.nextDouble() val speed = abs(random.nextGaussian()) * Config.fallingLeaves.windStrength + (if (!world.isRaining) 0.0 else abs(random.nextGaussian()) * Config.fallingLeaves.stormStrength) @@ -92,10 +92,10 @@ object LeafWindTracker { } @SubscribeEvent - fun handleWorldTick(event: TickEvent.ClientTickEvent) { - if (event.phase == TickEvent.Phase.START) Minecraft.getInstance().world?.let { world -> + fun handleWorldTick(event: TickEvent.WorldTickEvent) { + if (event.phase == TickEvent.Phase.START && event.side == LogicalSide.CLIENT) event.world.let { world -> // change target wind speed - if (world.worldInfo.dayTime >= nextChange) changeWind(world) + if (world.dayTime >= nextChange) changeWind(world) // change current wind speed val changeRate = if (world.isRaining) 0.015 else 0.005 @@ -107,6 +107,6 @@ object LeafWindTracker { } } - @SubscribeEvent - fun handleWorldLoad(event: WorldEvent.Load) { if (event.world.isRemote) changeWind(event.world.world) } +// @SubscribeEvent +// fun handleWorldLoad(event: WorldEvent.Load) { if (event.world.isClientSide) changeWind(event.world) } } \ No newline at end of file diff --git a/src/main/kotlin/mods/betterfoliage/render/particle/LeafParticleRegistry.kt b/src/main/kotlin/mods/betterfoliage/render/particle/LeafParticleRegistry.kt index 06f527b..0a766eb 100644 --- a/src/main/kotlin/mods/betterfoliage/render/particle/LeafParticleRegistry.kt +++ b/src/main/kotlin/mods/betterfoliage/render/particle/LeafParticleRegistry.kt @@ -41,7 +41,7 @@ object LeafParticleRegistry : HasLogger(), VeryEarlyReloadListener { @SubscribeEvent fun handlePreStitch(event: TextureStitchEvent.Pre) { - if (event.map.textureLocation == Atlas.PARTICLES.resourceId) { + if (event.map.location() == Atlas.PARTICLES.resourceId) { allTypes.forEach { leafType -> val locations = (0 until 16).map { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "particle/falling_leaf_${leafType}_$idx") @@ -55,7 +55,7 @@ object LeafParticleRegistry : HasLogger(), VeryEarlyReloadListener { @SubscribeEvent fun handlePostStitch(event: TextureStitchEvent.Post) { - if (event.map.textureLocation == Atlas.PARTICLES.resourceId) { + if (event.map.location() == Atlas.PARTICLES.resourceId) { (typeMappings.mappings.map { it.type } + "default").distinct().forEach { leafType -> val sprites = (0 until 16).map { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "particle/falling_leaf_${leafType}_$idx") diff --git a/src/main/kotlin/mods/betterfoliage/render/particle/RisingSouls.kt b/src/main/kotlin/mods/betterfoliage/render/particle/RisingSouls.kt index 96a1017..ccdd188 100644 --- a/src/main/kotlin/mods/betterfoliage/render/particle/RisingSouls.kt +++ b/src/main/kotlin/mods/betterfoliage/render/particle/RisingSouls.kt @@ -13,6 +13,7 @@ import mods.betterfoliage.util.randomD import mods.betterfoliage.util.randomI import net.minecraft.client.particle.IParticleRenderType import net.minecraft.client.renderer.ActiveRenderInfo +import net.minecraft.client.world.ClientWorld import net.minecraft.util.ResourceLocation import net.minecraft.util.math.BlockPos import net.minecraft.util.math.MathHelper @@ -23,7 +24,7 @@ import kotlin.math.cos import kotlin.math.sin class RisingSoulParticle( - world: World, pos: BlockPos + world: ClientWorld, pos: BlockPos ) : AbstractParticle( world, pos.x.toDouble() + 0.5, pos.y.toDouble() + 1.0, pos.z.toDouble() + 0.5 ) { @@ -32,10 +33,10 @@ class RisingSoulParticle( val initialPhase = randomD(max = PI2) init { - motionY = 0.1 - particleGravity = 0.0f + yd = 0.1 + gravity = 0.0f sprite = headIcons[randomI(max = 1024)] - maxAge = MathHelper.floor((0.6 + 0.4 * randomD()) * Config.risingSoul.lifetime * 20.0) + lifetime = MathHelper.floor((0.6 + 0.4 * randomD()) * Config.risingSoul.lifetime * 20.0) } override val isValid: Boolean get() = true @@ -49,12 +50,12 @@ class RisingSoulParticle( particleTrail.addFirst(currentPos.copy()) while (particleTrail.size > Config.risingSoul.trailLength) particleTrail.removeLast() - if (!Config.enabled) setExpired() + if (!Config.enabled) remove() } - override fun renderParticle(vertexBuilder: IVertexBuilder, camera: ActiveRenderInfo, tickDelta: Float) { + override fun render(vertexBuilder: IVertexBuilder, camera: ActiveRenderInfo, tickDelta: Float) { var alpha = Config.risingSoul.opacity.toFloat() - if (age > maxAge - 40) alpha *= (maxAge - age) / 40.0f + if (age > lifetime - 40) alpha *= (lifetime - age) / 40.0f renderParticleQuad( vertexBuilder, camera, tickDelta, diff --git a/src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxBase.kt b/src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxBase.kt index 60178b9..bccd9f3 100644 --- a/src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxBase.kt +++ b/src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxBase.kt @@ -3,18 +3,18 @@ package mods.betterfoliage.render.pipeline import com.mojang.blaze3d.matrix.MatrixStack import mods.betterfoliage.chunk.BasicBlockCtx import mods.betterfoliage.chunk.BlockCtx +import mods.betterfoliage.model.HalfBakedQuad import mods.betterfoliage.model.SpecialRenderModel import mods.betterfoliage.render.lighting.VanillaFullBlockLighting import mods.betterfoliage.render.lighting.VanillaQuadLighting import mods.betterfoliage.render.lighting.VanillaVertexLighter -import mods.betterfoliage.model.HalfBakedQuad import mods.betterfoliage.util.Int3 import mods.betterfoliage.util.plus import net.minecraft.block.Block import net.minecraft.client.Minecraft import net.minecraft.util.Direction import net.minecraft.util.math.BlockPos -import net.minecraft.world.ILightReader +import net.minecraft.world.IBlockDisplayReader import net.minecraftforge.client.model.data.IModelData import java.util.Random @@ -25,7 +25,7 @@ import java.util.Random * push-based partial rendering pipeline for [SpecialRenderModel] instances. */ abstract class RenderCtxBase( - world: ILightReader, + world: IBlockDisplayReader, pos: BlockPos, val matrixStack: MatrixStack, var checkSides: Boolean, @@ -36,14 +36,14 @@ abstract class RenderCtxBase( abstract fun renderQuad(quad: HalfBakedQuad) var hasRendered = false - val blockModelShapes = Minecraft.getInstance().blockRendererDispatcher.blockModelShapes + val blockModelShapes = Minecraft.getInstance().blockRenderer.blockModelShaper var vertexLighter: VanillaVertexLighter = VanillaFullBlockLighting protected val lightingData = RenderCtxBase.lightingData.get().apply { calc.reset(this@RenderCtxBase) blockColors = Minecraft.getInstance().blockColors } - inline fun Direction?.shouldRender() = this == null || !checkSides || Block.shouldSideBeRendered(state, world, pos, this) + inline fun Direction?.shouldRender() = this == null || !checkSides || Block.shouldRenderFace(state, world, pos, this) fun renderQuads(quads: Iterable) { quads.forEach { quad -> diff --git a/src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxForge.kt b/src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxForge.kt index d538d7a..f2b5359 100644 --- a/src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxForge.kt +++ b/src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxForge.kt @@ -1,20 +1,20 @@ package mods.betterfoliage.render.pipeline import com.mojang.blaze3d.matrix.MatrixStack +import mods.betterfoliage.model.HalfBakedQuad import mods.betterfoliage.model.SpecialRenderModel import mods.betterfoliage.render.lighting.ForgeVertexLighter import mods.betterfoliage.render.lighting.ForgeVertexLighterAccess -import mods.betterfoliage.model.HalfBakedQuad import net.minecraft.block.BlockState import net.minecraft.client.renderer.LightTexture import net.minecraft.util.math.BlockPos -import net.minecraft.world.ILightReader +import net.minecraft.world.IBlockDisplayReader import net.minecraftforge.client.model.data.IModelData import net.minecraftforge.client.model.pipeline.VertexLighterFlat import java.util.Random class RenderCtxForge( - world: ILightReader, + world: IBlockDisplayReader, pos: BlockPos, val lighter: VertexLighterFlat, matrixStack: MatrixStack, @@ -33,8 +33,8 @@ class RenderCtxForge( var vIdx = 0 override fun updateVertexLightmap(normal: FloatArray, lightmap: FloatArray, x: Float, y: Float, z: Float) { lightingData.packedLight[vIdx].let { packedLight -> - lightmap[0] = LightTexture.getLightBlock(packedLight) / 0xF.toFloat() - lightmap[1] = LightTexture.getLightSky(packedLight) / 0xF.toFloat() + lightmap[0] = LightTexture.block(packedLight) / 0xF.toFloat() + lightmap[1] = LightTexture.sky(packedLight) / 0xF.toFloat() } } @@ -49,7 +49,7 @@ class RenderCtxForge( @JvmStatic fun render( lighter: VertexLighterFlat, - world: ILightReader, + world: IBlockDisplayReader, model: SpecialRenderModel, state: BlockState, pos: BlockPos, diff --git a/src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxVanilla.kt b/src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxVanilla.kt index acae093..0e06fe5 100644 --- a/src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxVanilla.kt +++ b/src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxVanilla.kt @@ -2,18 +2,18 @@ package mods.betterfoliage.render.pipeline import com.mojang.blaze3d.matrix.MatrixStack import com.mojang.blaze3d.vertex.IVertexBuilder -import mods.betterfoliage.model.SpecialRenderModel import mods.betterfoliage.model.HalfBakedQuad +import mods.betterfoliage.model.SpecialRenderModel import net.minecraft.block.BlockState import net.minecraft.client.renderer.BlockModelRenderer import net.minecraft.util.math.BlockPos -import net.minecraft.world.ILightReader +import net.minecraft.world.IBlockDisplayReader import net.minecraftforge.client.model.data.IModelData import java.util.Random class RenderCtxVanilla( val renderer: BlockModelRenderer, - world: ILightReader, + world: IBlockDisplayReader, pos: BlockPos, val buffer: IVertexBuilder, val combinedOverlay: Int, @@ -27,8 +27,8 @@ class RenderCtxVanilla( override fun renderQuad(quad: HalfBakedQuad) { vertexLighter.updateLightmapAndColor(quad, lightingData) - buffer.addQuad( - matrixStack.last, quad.baked, + buffer.putBulkData( + matrixStack.last(), quad.baked, lightingData.colorMultiplier, lightingData.tint[0], lightingData.tint[1], lightingData.tint[2], lightingData.packedLight, combinedOverlay, true @@ -39,7 +39,7 @@ class RenderCtxVanilla( @JvmStatic fun render( renderer: BlockModelRenderer, - world: ILightReader, + world: IBlockDisplayReader, model: SpecialRenderModel, state: BlockState, pos: BlockPos, diff --git a/src/main/kotlin/mods/betterfoliage/resource/VeryEarlyReloadListener.kt b/src/main/kotlin/mods/betterfoliage/resource/VeryEarlyReloadListener.kt index 220d23d..67f9135 100644 --- a/src/main/kotlin/mods/betterfoliage/resource/VeryEarlyReloadListener.kt +++ b/src/main/kotlin/mods/betterfoliage/resource/VeryEarlyReloadListener.kt @@ -20,7 +20,7 @@ interface VeryEarlyReloadListener : IFutureReloadListener { gameExecutor: Executor ): CompletableFuture { onReloadStarted() - return stage.markCompleteAwaitingOthers(null) + return stage.wait(null) } fun onReloadStarted() {} diff --git a/src/main/kotlin/mods/betterfoliage/resource/discovery/BakingLifecycle.kt b/src/main/kotlin/mods/betterfoliage/resource/discovery/BakingLifecycle.kt index 8927172..94090e0 100644 --- a/src/main/kotlin/mods/betterfoliage/resource/discovery/BakingLifecycle.kt +++ b/src/main/kotlin/mods/betterfoliage/resource/discovery/BakingLifecycle.kt @@ -8,8 +8,8 @@ import net.minecraft.block.BlockState import net.minecraft.client.renderer.model.IBakedModel import net.minecraft.client.renderer.model.IModelTransform import net.minecraft.client.renderer.model.IUnbakedModel -import net.minecraft.client.renderer.model.Material import net.minecraft.client.renderer.model.ModelBakery +import net.minecraft.client.renderer.model.RenderMaterial import net.minecraft.client.renderer.texture.TextureAtlasSprite import net.minecraft.util.ResourceLocation import net.minecraftforge.client.event.ModelBakeEvent @@ -30,7 +30,7 @@ data class ModelDefinitionsLoadedEvent( interface ModelBakingKey { fun bake(ctx: ModelBakingContext): IBakedModel? = - ctx.getUnbaked().bakeModel(ctx.bakery, ctx.spriteGetter, ctx.transform, ctx.location) + ctx.getUnbaked().bake(ctx.bakery, ctx.spriteGetter, ctx.transform, ctx.location) } interface ModelDiscovery { @@ -49,7 +49,7 @@ data class ModelDiscoveryContext( val replacements: MutableMap, val logger: Logger ) { - fun getUnbaked(location: ResourceLocation = modelLocation) = bakery.getUnbakedModel(location) + fun getUnbaked(location: ResourceLocation = modelLocation) = bakery.getModel(location) fun addReplacement(key: ModelBakingKey, addToStateKeys: Boolean = true) { replacements[modelLocation] = key if (addToStateKeys) BetterFoliage.blockTypes.stateKeys[blockState] = key @@ -59,12 +59,12 @@ data class ModelDiscoveryContext( data class ModelBakingContext( val bakery: ModelBakery, - val spriteGetter: Function, + val spriteGetter: Function, val location: ResourceLocation, val transform: IModelTransform, val logger: Logger ) { - fun getUnbaked() = bakery.getUnbakedModel(location) + fun getUnbaked() = bakery.getModel(location) fun getBaked() = bakery.getBakedModel(location, transform, spriteGetter) } @@ -94,7 +94,7 @@ object BakeWrapperManager : Invalidator, HasLogger() { @SubscribeEvent fun handleStitch(event: TextureStitchEvent.Pre) { - if (event.map.textureLocation == Atlas.BLOCKS.resourceId) { + if (event.map.location() == Atlas.BLOCKS.resourceId) { logger.log(INFO, "Adding ${sprites.size} sprites to block atlas") sprites.forEach { event.addSprite(it) } sprites.clear() @@ -109,7 +109,7 @@ object BakeWrapperManager : Invalidator, HasLogger() { fun onBake( unbaked: IUnbakedModel, bakery: ModelBakery, - spriteGetter: Function, + spriteGetter: Function, transform: IModelTransform, location: ResourceLocation ): IBakedModel? { @@ -124,6 +124,6 @@ object BakeWrapperManager : Invalidator, HasLogger() { logger.log(WARN, "Error while baking $replacement", e) } } - return unbaked.bakeModel(bakery, spriteGetter, transform, location) + return unbaked.bake(bakery, spriteGetter, transform, location) } } diff --git a/src/main/kotlin/mods/betterfoliage/resource/discovery/Matchers.kt b/src/main/kotlin/mods/betterfoliage/resource/discovery/Matchers.kt index b6c2dd8..5223502 100644 --- a/src/main/kotlin/mods/betterfoliage/resource/discovery/Matchers.kt +++ b/src/main/kotlin/mods/betterfoliage/resource/discovery/Matchers.kt @@ -1,6 +1,5 @@ package mods.betterfoliage.resource.discovery -import mods.betterfoliage.BetterFoliageMod import mods.betterfoliage.util.HasLogger import mods.betterfoliage.util.getJavaClass import mods.betterfoliage.util.getLines @@ -45,8 +44,8 @@ class ConfigurableBlockMatcher(val location: ResourceLocation) : HasLogger(), IB fun readDefaults() { blackList.clear() whiteList.clear() - resourceManager.getAllResources(location).forEach { resource -> - detailLogger.log(INFO, "Reading block class configuration $location from pack ${resource.packName}") + resourceManager.getResources(location).forEach { resource -> + detailLogger.log(INFO, "Reading block class configuration $location from pack ${resource.sourceName}") resource.getLines().map{ it.trim() }.filter { !it.startsWith("//") && it.isNotEmpty() }.forEach { line -> if (line.startsWith("-")) getJavaClass(line.substring(1))?.let { blackList.add(it) } else getJavaClass(line)?.let { whiteList.add(it) } @@ -63,8 +62,8 @@ data class ModelTextureList(val modelLocation: ResourceLocation, val textureName class ModelTextureListConfiguration(val location: ResourceLocation) : HasLogger() { val modelList = mutableListOf() fun readDefaults() { - resourceManager.getAllResources(location).forEach { resource -> - detailLogger.log(INFO, "Reading model/texture configuration $location from pack ${resource.packName}") + resourceManager.getResources(location).forEach { resource -> + detailLogger.log(INFO, "Reading model/texture configuration $location from pack ${resource.sourceName}") resource.getLines().map{ it.trim() }.filter { !it.startsWith("//") && it.isNotEmpty() }.forEach { line -> val elements = line.split(",") modelList.add(ModelTextureList(ResourceLocation(elements.first()), elements.drop(1))) diff --git a/src/main/kotlin/mods/betterfoliage/resource/discovery/ModelDiscovery.kt b/src/main/kotlin/mods/betterfoliage/resource/discovery/ModelDiscovery.kt index eb3fb2b..35b1af1 100644 --- a/src/main/kotlin/mods/betterfoliage/resource/discovery/ModelDiscovery.kt +++ b/src/main/kotlin/mods/betterfoliage/resource/discovery/ModelDiscovery.kt @@ -18,9 +18,9 @@ abstract class AbstractModelDiscovery : HasLogger(), ModelDiscovery { replacements: MutableMap ) { ForgeRegistries.BLOCKS - .flatMap { block -> block.stateContainer.validStates } + .flatMap { block -> block.stateDefinition.possibleStates } .forEach { state -> - val location = BlockModelShapes.getModelLocation(state) + val location = BlockModelShapes.stateToModelLocation(state) val ctx = ModelDiscoveryContext(bakery, state, location, sprites, replacements, detailLogger) try { processModel(ctx) @@ -38,7 +38,7 @@ abstract class AbstractModelDiscovery : HasLogger(), ModelDiscovery { // per-location replacements need to be scoped to the variant list, as replacement models // may need information from the BlockState which is not available at baking time val scopedReplacements = mutableMapOf() - model.variantList.forEach { variant -> + model.variants.forEach { variant -> processModel(ctx.copy(modelLocation = variant.modelLocation, replacements = scopedReplacements)) } if (scopedReplacements.isNotEmpty()) { @@ -73,15 +73,18 @@ abstract class ConfigurableModelDiscovery : AbstractModelDiscovery() { matches.forEach { match -> detailLogger.log(Level.INFO, " model $model matches ${match.modelLocation}") - val materials = match.textureNames.map { it to model.resolveTextureName(it) } - val texMapString = Joiner.on(", ").join(materials.map { "${it.first}=${it.second.textureLocation}" }) - detailLogger.log(Level.INFO, " sprites [$texMapString]") + val materials = match.textureNames.map { it to model.getMaterial(it) } + val texMapString = Joiner.on(", ").join(materials.map { "${it.first}=${it.second.texture()}" }) + detailLogger.log(Level.INFO, " sprites [$texMapString]") - if (materials.all { it.second.textureLocation != MissingTextureSprite.getLocation() }) { - // found a valid model (all required textures exist) - processModel(ctx, materials.map { it.second.textureLocation }) - } + if (materials.all { it.second.texture() != MissingTextureSprite.getLocation() }) { + // found a valid model (all required textures exist) + processModel(ctx, materials.map { it.second.texture() }) } + } + if (matches.isEmpty()) { + detailLogger.log(Level.INFO, " no matches for model ${ctx.modelLocation}, inheritance chain ${ancestry.joinToString(" -> ")}") + } } return super.processModel(ctx) } @@ -90,12 +93,12 @@ abstract class ConfigurableModelDiscovery : AbstractModelDiscovery() { fun ModelBakery.modelDerivesFrom(model: BlockModel, location: ResourceLocation, target: ResourceLocation): Boolean = if (location == target) true else model.parentLocation - ?.let { getUnbakedModel(it) as? BlockModel } + ?.let { getModel(it) as? BlockModel } ?.let { parent -> modelDerivesFrom(parent, model.parentLocation!!, target) } ?: false fun ModelBakery.getAncestry(location: ResourceLocation): List { - val model = getUnbakedModel(location) as? BlockModel ?: return listOf(location) + val model = getModel(location) as? BlockModel ?: return listOf(location) val parentAncestry = model.parentLocation?.let { getAncestry(it) } ?: emptyList() return listOf(location) + parentAncestry } \ No newline at end of file diff --git a/src/main/kotlin/mods/betterfoliage/resource/discovery/VanillaWrappers.kt b/src/main/kotlin/mods/betterfoliage/resource/discovery/VanillaWrappers.kt index 22a3920..064c067 100644 --- a/src/main/kotlin/mods/betterfoliage/resource/discovery/VanillaWrappers.kt +++ b/src/main/kotlin/mods/betterfoliage/resource/discovery/VanillaWrappers.kt @@ -20,7 +20,7 @@ class WeightedUnbakedKey( if (unbaked !is VariantList) return super.bake(ctx) // bake all variants, replace as needed - val bakedModels = unbaked.variantList.mapNotNull { + val bakedModels = unbaked.variants.mapNotNull { val variantCtx = ctx.copy(location = it.modelLocation, transform = it) val replacement = replacements[it.modelLocation] val baked = replacement?.let { replacement -> @@ -40,10 +40,10 @@ class WeightedUnbakedKey( // let it through unchanged if (bakedModels.isEmpty()) return super.bake(ctx) - if (bakedModels.size < unbaked.variantList.size) { + if (bakedModels.size < unbaked.variants.size) { detailLogger.log( WARN, - "Dropped ${unbaked.variantList.size - bakedModels.size} variants from model ${ctx.location}" + "Dropped ${unbaked.variants.size - bakedModels.size} variants from model ${ctx.location}" ) } val weightedSpecials = bakedModels.map { (variant, model) -> diff --git a/src/main/kotlin/mods/betterfoliage/resource/generated/ResourceGeneration.kt b/src/main/kotlin/mods/betterfoliage/resource/generated/ResourceGeneration.kt index b0c3cb2..4615cb5 100644 --- a/src/main/kotlin/mods/betterfoliage/resource/generated/ResourceGeneration.kt +++ b/src/main/kotlin/mods/betterfoliage/resource/generated/ResourceGeneration.kt @@ -1,10 +1,8 @@ package mods.betterfoliage.resource.generated -import mods.betterfoliage.BetterFoliageMod import mods.betterfoliage.util.Atlas import mods.betterfoliage.util.HasLogger import net.minecraft.client.Minecraft -import net.minecraft.client.resources.ClientResourcePackInfo import net.minecraft.resources.* import net.minecraft.resources.ResourcePackType.CLIENT_RESOURCES import net.minecraft.resources.data.IMetadataSectionSerializer @@ -12,6 +10,7 @@ import net.minecraft.util.ResourceLocation import net.minecraft.util.text.StringTextComponent import org.apache.logging.log4j.Level.INFO import java.util.* +import java.util.function.Consumer import java.util.function.Predicate import java.util.function.Supplier @@ -25,10 +24,10 @@ class GeneratedTexturePack( val nameSpace: String, val packName: String ) : HasLogger(), IResourcePack { override fun getName() = packName - override fun getResourceNamespaces(type: ResourcePackType) = setOf(nameSpace) - override fun getMetadata(deserializer: IMetadataSectionSerializer) = null - override fun getRootResourceStream(id: String) = null - override fun getAllResourceLocations(type: ResourcePackType, namespace:String, path: String, maxDepth: Int, filter: Predicate) = emptyList() + override fun getNamespaces(type: ResourcePackType) = setOf(nameSpace) + override fun getMetadataSection(deserializer: IMetadataSectionSerializer) = null + override fun getRootResource(id: String) = null + override fun getResources(type: ResourcePackType, namespace:String, path: String, maxDepth: Int, filter: Predicate) = emptyList() override fun close() {} @@ -49,21 +48,22 @@ class GeneratedTexturePack( return id } - override fun getResourceStream(type: ResourcePackType, id: ResourceLocation) = + override fun getResource(type: ResourcePackType, id: ResourceLocation) = if (type != CLIENT_RESOURCES) null else resources[id]?.inputStream() - override fun resourceExists(type: ResourcePackType, id: ResourceLocation) = + override fun hasResource(type: ResourcePackType, id: ResourceLocation) = type == CLIENT_RESOURCES && resources.containsKey(id) val finder = object : IPackFinder { - val packInfo = ClientResourcePackInfo( + val packInfo = ResourcePackInfo( packName, true, Supplier { this@GeneratedTexturePack }, StringTextComponent(packName), StringTextComponent("Generated block textures resource pack"), PackCompatibility.COMPATIBLE, ResourcePackInfo.Priority.TOP, true, null, true ) - override fun addPackInfosToMap(nameToPackMap: MutableMap, packInfoFactory: ResourcePackInfo.IFactory) { - (nameToPackMap as MutableMap).put(packName, packInfo) + + override fun loadPacks(p0: Consumer, p1: ResourcePackInfo.IFactory) { + p0.accept(packInfo) } } } diff --git a/src/main/kotlin/mods/betterfoliage/util/Blocks.kt b/src/main/kotlin/mods/betterfoliage/util/Blocks.kt deleted file mode 100644 index e1d3429..0000000 --- a/src/main/kotlin/mods/betterfoliage/util/Blocks.kt +++ /dev/null @@ -1,9 +0,0 @@ -package mods.betterfoliage.util - -import net.minecraft.block.BlockState -import net.minecraft.block.Blocks -import net.minecraft.block.material.Material - - - -val DIRT_BLOCKS = listOf(Blocks.DIRT, Blocks.COARSE_DIRT) \ No newline at end of file diff --git a/src/main/kotlin/mods/betterfoliage/util/Geometry.kt b/src/main/kotlin/mods/betterfoliage/util/Geometry.kt index 0b73bc0..2d1fa14 100644 --- a/src/main/kotlin/mods/betterfoliage/util/Geometry.kt +++ b/src/main/kotlin/mods/betterfoliage/util/Geometry.kt @@ -1,12 +1,12 @@ package mods.betterfoliage.util -import net.minecraft.client.renderer.Quaternion import net.minecraft.util.Direction import net.minecraft.util.Direction.* import net.minecraft.util.Direction.Axis.* import net.minecraft.util.Direction.AxisDirection.NEGATIVE import net.minecraft.util.Direction.AxisDirection.POSITIVE import net.minecraft.util.math.BlockPos +import net.minecraft.util.math.vector.Quaternion val EPSILON_ZERO = 0.05 val EPSILON_ONE = 0.95 @@ -55,15 +55,15 @@ val ROTATION_MATRIX: Array get() = arrayOf( // Vectors // ================================ operator fun Direction.times(scale: Double) = - Double3(directionVec.x.toDouble() * scale, directionVec.y.toDouble() * scale, directionVec.z.toDouble() * scale) -val Direction.vec: Double3 get() = Double3(directionVec.x.toDouble(), directionVec.y.toDouble(), directionVec.z.toDouble()) + Double3(normal.x.toDouble() * scale, normal.y.toDouble() * scale, normal.z.toDouble() * scale) +val Direction.vec: Double3 get() = Double3(normal.x.toDouble(), normal.y.toDouble(), normal.z.toDouble()) operator fun BlockPos.plus(other: Int3) = BlockPos(x + other.x, y + other.y, z + other.z) /** 3D vector of [Double]s. Offers both mutable operations, and immutable operations in operator notation. */ data class Double3(var x: Double, var y: Double, var z: Double) { constructor(x: Float, y: Float, z: Float) : this(x.toDouble(), y.toDouble(), z.toDouble()) - constructor(dir: Direction) : this(dir.directionVec.x.toDouble(), dir.directionVec.y.toDouble(), dir.directionVec.z.toDouble()) + constructor(dir: Direction) : this(dir.normal.x.toDouble(), dir.normal.y.toDouble(), dir.normal.z.toDouble()) companion object { val zero: Double3 get() = Double3(0.0, 0.0, 0.0) fun weight(v1: Double3, weight1: Double, v2: Double3, weight2: Double) = @@ -88,9 +88,9 @@ data class Double3(var x: Double, var y: Double, var z: Double) { /** Rotate vector by the given [Quaternion] */ fun rotate(quat: Quaternion) = quat.copy() - .apply { multiply(Quaternion(x, y, z, 0.0F)) } - .apply { multiply(quat.copy().apply(Quaternion::conjugate)) } - .let { Double3(it.x, it.y, it.z) } + .apply { mul(Quaternion(x.toFloat(), y.toFloat(), z.toFloat(), 0.0F)) } + .apply { mul(quat.copy().apply(Quaternion::conj)) } + .let { Double3(it.i().toDouble(), it.j().toDouble(), it.k().toDouble()) } // mutable operations fun setTo(other: Double3): Double3 { x = other.x; y = other.y; z = other.z; return this } @@ -120,11 +120,11 @@ data class Double3(var x: Double, var y: Double, var z: Double) { /** 3D vector of [Int]s. Offers both mutable operations, and immutable operations in operator notation. */ data class Int3(var x: Int, var y: Int, var z: Int) { - constructor(dir: Direction) : this(dir.directionVec.x, dir.directionVec.y, dir.directionVec.z) + constructor(dir: Direction) : this(dir.normal.x, dir.normal.y, dir.normal.z) constructor(offset: Pair) : this( - offset.first * offset.second.directionVec.x, - offset.first * offset.second.directionVec.y, - offset.first * offset.second.directionVec.z + offset.first * offset.second.normal.x, + offset.first * offset.second.normal.y, + offset.first * offset.second.normal.z ) companion object { val zero = Int3(0, 0, 0) @@ -133,9 +133,9 @@ data class Int3(var x: Int, var y: Int, var z: Int) { // immutable operations operator fun plus(other: Int3) = Int3(x + other.x, y + other.y, z + other.z) operator fun plus(other: Pair) = Int3( - x + other.first * other.second.directionVec.x, - y + other.first * other.second.directionVec.y, - z + other.first * other.second.directionVec.z + x + other.first * other.second.normal.x, + y + other.first * other.second.normal.y, + z + other.first * other.second.normal.z ) operator fun unaryMinus() = Int3(-x, -y, -z) operator fun minus(other: Int3) = Int3(x - other.x, y - other.y, z - other.z) diff --git a/src/main/kotlin/mods/betterfoliage/util/Gui.kt b/src/main/kotlin/mods/betterfoliage/util/Gui.kt index bd2bd35..c8c73ed 100644 --- a/src/main/kotlin/mods/betterfoliage/util/Gui.kt +++ b/src/main/kotlin/mods/betterfoliage/util/Gui.kt @@ -7,16 +7,16 @@ import net.minecraft.util.text.TextFormatting import net.minecraft.util.text.TextFormatting.AQUA import net.minecraft.util.text.TextFormatting.GRAY -fun stripTooltipDefaultText(tooltip: MutableList) { - var defaultRows = false - val iter = tooltip.iterator() - while (iter.hasNext()) { - if (iter.next().startsWith(AQUA.toString())) defaultRows = true - if (defaultRows) iter.remove() - } -} - -fun textComponent(msg: String, color: TextFormatting = GRAY): StringTextComponent { - val style = Style().apply { this.color = color } - return StringTextComponent(msg).apply { this.style = style } -} \ No newline at end of file +//fun stripTooltipDefaultText(tooltip: MutableList) { +// var defaultRows = false +// val iter = tooltip.iterator() +// while (iter.hasNext()) { +// if (iter.next().startsWith(AQUA.toString())) defaultRows = true +// if (defaultRows) iter.remove() +// } +//} +// +//fun textComponent(msg: String, color: TextFormatting = GRAY): StringTextComponent { +// val style = Style().apply { this.color = color } +// return StringTextComponent(msg).apply { this.style = style } +//} \ No newline at end of file diff --git a/src/main/kotlin/mods/betterfoliage/util/Resources.kt b/src/main/kotlin/mods/betterfoliage/util/Resources.kt index 6656cb3..16ec075 100644 --- a/src/main/kotlin/mods/betterfoliage/util/Resources.kt +++ b/src/main/kotlin/mods/betterfoliage/util/Resources.kt @@ -1,8 +1,6 @@ package mods.betterfoliage.util import net.minecraft.client.Minecraft -import net.minecraft.client.renderer.model.Material -import net.minecraft.client.renderer.texture.AtlasTexture import net.minecraft.resources.IReloadableResourceManager import net.minecraft.resources.IResource import net.minecraft.resources.IResourceManager @@ -19,11 +17,6 @@ operator fun ResourceLocation.plus(str: String) = ResourceLocation(namespace, pa fun ResourceLocation.prependLocation(basePath: String) = ResourceLocation(namespace, basePath.stripEnd("/").let { "$it/$path" }) -val ResourceLocation.asBlockMaterial: Material get() = Material( - AtlasTexture.LOCATION_BLOCKS_TEXTURE, - this -) - /** Index operator to get a resource. */ operator fun IResourceManager.get(domain: String, path: String): IResource? = get(ResourceLocation(domain, path)) /** Index operator to get a resource. */ diff --git a/src/main/kotlin/mods/betterfoliage/util/Sprites.kt b/src/main/kotlin/mods/betterfoliage/util/Sprites.kt index 36dc113..ecb0881 100644 --- a/src/main/kotlin/mods/betterfoliage/util/Sprites.kt +++ b/src/main/kotlin/mods/betterfoliage/util/Sprites.kt @@ -3,7 +3,6 @@ package mods.betterfoliage.util import mods.betterfoliage.model.Color import mods.betterfoliage.model.HSB import net.minecraft.client.Minecraft -import net.minecraft.client.renderer.model.Material import net.minecraft.client.renderer.texture.AtlasTexture import net.minecraft.client.renderer.texture.TextureAtlasSprite import net.minecraft.resources.IResource @@ -20,8 +19,8 @@ import kotlin.math.cos import kotlin.math.sin enum class Atlas(val resourceId: ResourceLocation) { - BLOCKS(AtlasTexture.LOCATION_BLOCKS_TEXTURE), - PARTICLES(AtlasTexture.LOCATION_PARTICLES_TEXTURE); + BLOCKS(AtlasTexture.LOCATION_BLOCKS), + PARTICLES(AtlasTexture.LOCATION_PARTICLES); /** Get the fully-qualified resource name for sprites belonging to this atlas */ fun file(resource: ResourceLocation) = ResourceLocation(resource.namespace, "textures/${resource.path}.png") @@ -33,7 +32,7 @@ enum class Atlas(val resourceId: ResourceLocation) { operator fun get(location: ResourceLocation) = atlas.getSprite(location) } -val Material.atlas: Atlas get() = Atlas.values().find { it.resourceId == atlasLocation } ?: Atlas.BLOCKS +//val Spr.atlas: Atlas get() = Atlas.values().find { it.resourceId == atlasLocation } ?: Atlas.BLOCKS inline operator fun AtlasTexture.get(res: ResourceLocation): TextureAtlasSprite? = this.getSprite(res) inline operator fun AtlasTexture.get(name: String): TextureAtlasSprite? = get(ResourceLocation(name)) diff --git a/src/main/resources/META-INF/mods.toml b/src/main/resources/META-INF/mods.toml index 66386ef..4b9cf0e 100644 --- a/src/main/resources/META-INF/mods.toml +++ b/src/main/resources/META-INF/mods.toml @@ -1,7 +1,7 @@ -modLoader="kotlinfml" -loaderVersion="[1.4,)" +modLoader="kotlinforforge" +loaderVersion="[1,)" issueTrackerURL="https://github.com/octarine-noise/BetterFoliage/issues" - +license="MIT" [[mods]] modId="betterfoliage" version="${version}" diff --git a/src/main/resources/assets/betterfoliage/lang/en_us.lang b/src/main/resources/assets/betterfoliage/lang/en_us.lang index 2012834..55a5dab 100644 --- a/src/main/resources/assets/betterfoliage/lang/en_us.lang +++ b/src/main/resources/assets/betterfoliage/lang/en_us.lang @@ -230,6 +230,8 @@ betterfoliage.connectedGrass.enabled.tooltip=If there is a grass block on top of betterfoliage.roundLogs=Round Logs betterfoliage.roundLogs.tooltip=Connect round blocks to solid full blocks? +betterfoliage.roundLogs.plantsOnly=Plant materials only +betterfoliage.roundLogs.plantsOnly.tooltip=Only apply to wood and hay, not all column blocks? betterfoliage.roundLogs.connectSolids=Connect to solid betterfoliage.roundLogs.connectSolids.tooltip=Connect round blocks to solid full blocks? betterfoliage.roundLogs.connectPerpendicular=Connect to perpendicular logs diff --git a/src/main/resources/assets/betterfoliage/log_blocks_default.cfg b/src/main/resources/assets/betterfoliage/log_blocks_default.cfg index b71b073..e5a51cb 100644 --- a/src/main/resources/assets/betterfoliage/log_blocks_default.cfg +++ b/src/main/resources/assets/betterfoliage/log_blocks_default.cfg @@ -1,2 +1,2 @@ // Vanilla -net.minecraft.block.LogBlock +net.minecraft.block.RotatedPillarBlock diff --git a/src/main/resources/assets/betterfoliage/log_models_default.cfg b/src/main/resources/assets/betterfoliage/log_models_default.cfg index a6ef581..cf385b7 100644 --- a/src/main/resources/assets/betterfoliage/log_models_default.cfg +++ b/src/main/resources/assets/betterfoliage/log_models_default.cfg @@ -1,4 +1,4 @@ // Vanilla -block/column_side,side,end block/cube_column,side,end +block/cube_column_horizontal,side,end block/cube_all,all,all