From 2f5d64cd3b74742897360f9dd90dd85dffddd30a Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Mon, 24 Jun 2024 15:00:04 -0400 Subject: [PATCH 01/48] add Inline as a dependency --- Common/build.gradle | 4 ++++ Fabric/build.gradle | 2 ++ Fabric/src/main/resources/fabric.mod.json | 3 ++- Forge/build.gradle | 4 ++++ Forge/src/main/resources/META-INF/mods.toml | 7 +++++++ gradle.properties | 2 ++ 6 files changed, 21 insertions(+), 1 deletion(-) diff --git a/Common/build.gradle b/Common/build.gradle index d5e6128c84..73b3b45a02 100644 --- a/Common/build.gradle +++ b/Common/build.gradle @@ -28,6 +28,8 @@ repositories { url = "https://modmaven.dev" } + maven { url "https://maven.shedaniel.me/" } + } dependencies { @@ -37,6 +39,8 @@ dependencies { compileOnly "at.petra-k.paucal:paucal-common-$minecraftVersion:$paucalVersion" compileOnly "vazkii.patchouli:Patchouli-xplat:$minecraftVersion-$patchouliVersion-SNAPSHOT" + compileOnly "com.samsthenerd.inline:inline-common:$minecraftVersion-$inlineVersion" + compileOnly "org.jetbrains:annotations:$jetbrainsAnnotationsVersion" testCompileOnly "org.jetbrains:annotations:$jetbrainsAnnotationsVersion" diff --git a/Fabric/build.gradle b/Fabric/build.gradle index aafe9a125d..9e60ab70d3 100644 --- a/Fabric/build.gradle +++ b/Fabric/build.gradle @@ -84,6 +84,8 @@ dependencies { modImplementation "at.petra-k.paucal:paucal-fabric-$minecraftVersion:$paucalVersion" modImplementation "vazkii.patchouli:Patchouli:$minecraftVersion-$patchouliVersion-FABRIC-SNAPSHOT" + modImplementation "com.samsthenerd.inline:inline-fabric:$minecraftVersion-$inlineVersion" + modImplementation "dev.onyxstudios.cardinal-components-api:cardinal-components-base:$cardinalComponentsVersion" // modImplementation "dev.onyxstudios.cardinal-components-api:cardinal-components-util:$cardinalComponentsVersion" modImplementation "dev.onyxstudios.cardinal-components-api:cardinal-components-entity:$cardinalComponentsVersion" diff --git a/Fabric/src/main/resources/fabric.mod.json b/Fabric/src/main/resources/fabric.mod.json index 4468af2380..315710f065 100644 --- a/Fabric/src/main/resources/fabric.mod.json +++ b/Fabric/src/main/resources/fabric.mod.json @@ -57,7 +57,8 @@ "cardinal-components-block": "~5.2.1", "paucal": ">=0.6.0-pre <0.7.0", "cloth-config": "11.1.*", - "patchouli": ">=1.20.1-80" + "patchouli": ">=1.20.1-80", + "inline": ">=1.20.1-0.0.1" }, "suggests": { "pehkui": ">=3.7.6", diff --git a/Forge/build.gradle b/Forge/build.gradle index c1942d6013..aee06cc27d 100644 --- a/Forge/build.gradle +++ b/Forge/build.gradle @@ -59,6 +59,8 @@ repositories { url = 'https://thedarkcolour.github.io/KotlinForForge/' content { includeGroup "thedarkcolour" } } + + maven { url "https://maven.shedaniel.me/" } } dependencies { @@ -80,6 +82,8 @@ dependencies { implementation fg.deobf("top.theillusivec4.caelus:caelus-forge:$caelusVersion") + implementation fg.deobf("com.samsthenerd.inline:inline-forge:$minecraftVersion-$inlineVersion") + // Optional interop compileOnly fg.deobf("mezz.jei:jei-$minecraftVersion-common-api:$jeiVersion") diff --git a/Forge/src/main/resources/META-INF/mods.toml b/Forge/src/main/resources/META-INF/mods.toml index 252e3f9273..133f8cd916 100644 --- a/Forge/src/main/resources/META-INF/mods.toml +++ b/Forge/src/main/resources/META-INF/mods.toml @@ -48,3 +48,10 @@ mandatory = true versionRange = "[3.1.0+1.20,)" ordering = "NONE" side = "BOTH" + +[[dependencies.hexcasting]] +modId = "inline" +mandatory = true +versionRange = "[1.20.1-0.0.1,)" +ordering = "NONE" +side = "BOTH" \ No newline at end of file diff --git a/gradle.properties b/gradle.properties index 88d13e374a..e050c38be5 100644 --- a/gradle.properties +++ b/gradle.properties @@ -17,3 +17,5 @@ patchouliVersion=83 jeiVersion=15.0.0.12 pehkuiVersion=3.7.7 + +inlineVersion=0.0.1 \ No newline at end of file From 8b96a334a5f9d6e5ff950dff0113a5c1127b674c Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Wed, 26 Jun 2024 01:57:36 -0400 Subject: [PATCH 02/48] add hex pattern codec for inline to use --- .../java/at/petrak/hexcasting/api/casting/math/HexDir.kt | 6 ++++++ .../at/petrak/hexcasting/api/casting/math/HexPattern.kt | 9 +++++++++ 2 files changed, 15 insertions(+) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/casting/math/HexDir.kt b/Common/src/main/java/at/petrak/hexcasting/api/casting/math/HexDir.kt index 514cb0e467..03f4ca5a56 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/casting/math/HexDir.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/casting/math/HexDir.kt @@ -1,6 +1,7 @@ package at.petrak.hexcasting.api.casting.math import at.petrak.hexcasting.api.utils.getSafe +import com.mojang.serialization.Codec enum class HexDir { NORTH_EAST, EAST, SOUTH_EAST, SOUTH_WEST, WEST, NORTH_WEST; @@ -26,6 +27,11 @@ enum class HexDir { } companion object { + val CODEC: Codec = Codec.STRING.xmap( + HexDir::fromString, + HexDir::name + ) + @JvmStatic fun fromString(key: String): HexDir { return values().getSafe(key, WEST) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/casting/math/HexPattern.kt b/Common/src/main/java/at/petrak/hexcasting/api/casting/math/HexPattern.kt index 096d0340df..c55cbb23d9 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/casting/math/HexPattern.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/casting/math/HexPattern.kt @@ -4,6 +4,8 @@ import at.petrak.hexcasting.api.utils.NBTBuilder import at.petrak.hexcasting.api.utils.coordToPx import at.petrak.hexcasting.api.utils.findCenter import at.petrak.hexcasting.api.utils.getSafe +import com.mojang.serialization.Codec +import com.mojang.serialization.codecs.RecordCodecBuilder import net.minecraft.nbt.CompoundTag import net.minecraft.nbt.Tag import net.minecraft.world.phys.Vec2 @@ -127,6 +129,13 @@ data class HexPattern(public val startDir: HexDir, public val angles: MutableLis const val TAG_START_DIR = "start_dir" const val TAG_ANGLES = "angles" + @JvmField + val CODEC: Codec = RecordCodecBuilder.create({instance -> instance.group( + Codec.STRING.fieldOf(TAG_START_DIR).forGetter(HexPattern::anglesSignature), + HexDir.CODEC.fieldOf(TAG_ANGLES).forGetter(HexPattern::startDir) + ).apply(instance, HexPattern::fromAngles) + }) + @JvmStatic fun isPattern(tag: CompoundTag): Boolean { return tag.contains(TAG_START_DIR, Tag.TAG_ANY_NUMERIC.toInt()) From 57fbe7262c95d38905549507d1c275b38511ad24 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Wed, 26 Jun 2024 01:58:21 -0400 Subject: [PATCH 03/48] depend on forge inline in common because vanillagradle is stupid and cringe --- Common/build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Common/build.gradle b/Common/build.gradle index 73b3b45a02..947b7269a9 100644 --- a/Common/build.gradle +++ b/Common/build.gradle @@ -39,7 +39,7 @@ dependencies { compileOnly "at.petra-k.paucal:paucal-common-$minecraftVersion:$paucalVersion" compileOnly "vazkii.patchouli:Patchouli-xplat:$minecraftVersion-$patchouliVersion-SNAPSHOT" - compileOnly "com.samsthenerd.inline:inline-common:$minecraftVersion-$inlineVersion" + compileOnly "com.samsthenerd.inline:inline-forge:$minecraftVersion-$inlineVersion" compileOnly "org.jetbrains:annotations:$jetbrainsAnnotationsVersion" testCompileOnly "org.jetbrains:annotations:$jetbrainsAnnotationsVersion" From d1dce0dcfcf67ede662f326b4ec08bf300d4815a Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Wed, 26 Jun 2024 02:55:06 -0400 Subject: [PATCH 04/48] add inline pattern data --- .../interop/inline/InlinePatternData.java | 46 +++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java new file mode 100644 index 0000000000..4beb9e21ad --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java @@ -0,0 +1,46 @@ +package at.petrak.hexcasting.interop.inline; + +import at.petrak.hexcasting.api.HexAPI; +import at.petrak.hexcasting.api.casting.math.HexPattern; +import com.mojang.serialization.Codec; +import com.samsthenerd.inline.api.InlineData; +import net.minecraft.resources.ResourceLocation; +import org.jetbrains.annotations.NotNull; + +public class InlinePatternData implements InlineData{ + + @NotNull + public final HexPattern pattern; + + public InlinePatternData(@NotNull HexPattern pattern){ + this.pattern = pattern; + } + + @Override + public InlinePatternDataType getType(){ + return InlinePatternDataType.INSTANCE; + } + + @Override + public ResourceLocation getRendererId(){ + return new ResourceLocation(HexAPI.MOD_ID, "pattern"); + } + + public static class InlinePatternDataType implements InlineDataType { + private static final ResourceLocation ID = new ResourceLocation(HexAPI.MOD_ID, "pattern"); + public static final InlinePatternDataType INSTANCE = new InlinePatternDataType(); + + @Override + public ResourceLocation getId(){ + return ID; + } + + @Override + public Codec getCodec(){ + return HexPattern.CODEC.xmap( + InlinePatternData::new, + data -> data.pattern + ); + } + } +} From 74c24a16206e46c5578ef6c41994a97a7e931130 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Fri, 28 Jun 2024 23:30:30 -0400 Subject: [PATCH 05/48] move worldly pattern renderers out of PatternTextureManager --- .../client/entity/WallScrollRenderer.java | 3 +- .../client/render/PatternTextureManager.java | 171 ---------------- .../render/WorldlyPatternRenderHelpers.java | 190 ++++++++++++++++++ .../BlockEntityAkashicBookshelfRenderer.java | 5 +- .../render/be/BlockEntitySlateRenderer.java | 3 +- 5 files changed, 196 insertions(+), 176 deletions(-) create mode 100644 Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java diff --git a/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java index 351acbef7a..85af0ba620 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java @@ -2,6 +2,7 @@ import at.petrak.hexcasting.client.render.PatternTextureManager; import at.petrak.hexcasting.client.render.RenderLib; +import at.petrak.hexcasting.client.render.WorldlyPatternRenderHelpers; import at.petrak.hexcasting.common.entities.EntityWallScroll; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.PoseStack; @@ -100,7 +101,7 @@ public void render(EntityWallScroll wallScroll, float yaw, float partialTicks, P ps.popPose(); if (PatternTextureManager.useTextures && wallScroll.points != null) - PatternTextureManager.renderPatternForScroll(wallScroll.points.pointsKey, ps, bufSource, light, wallScroll.points.zappyPoints, wallScroll.blockSize, wallScroll.getShowsStrokeOrder()); + WorldlyPatternRenderHelpers.renderPatternForScroll(wallScroll.points.pointsKey, ps, bufSource, light, wallScroll.points.zappyPoints, wallScroll.blockSize, wallScroll.getShowsStrokeOrder()); } //TODO: remove old rendering if not needed anymore for comparison diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java index c28116900f..0a86bcf200 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java @@ -1,29 +1,11 @@ package at.petrak.hexcasting.client.render; -import at.petrak.hexcasting.api.block.HexBlockEntity; -import at.petrak.hexcasting.api.casting.math.HexPattern; -import at.petrak.hexcasting.common.blocks.akashic.BlockAkashicBookshelf; -import at.petrak.hexcasting.common.blocks.akashic.BlockEntityAkashicBookshelf; -import at.petrak.hexcasting.common.blocks.circles.BlockEntitySlate; -import at.petrak.hexcasting.common.blocks.circles.BlockSlate; import com.mojang.blaze3d.platform.NativeImage; -import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.vertex.PoseStack; -import com.mojang.blaze3d.vertex.VertexConsumer; -import com.mojang.math.Axis; import net.minecraft.client.Minecraft; -import net.minecraft.client.renderer.GameRenderer; -import net.minecraft.client.renderer.MultiBufferSource; -import net.minecraft.client.renderer.RenderType; import net.minecraft.client.renderer.texture.DynamicTexture; -import net.minecraft.client.renderer.texture.OverlayTexture; import net.minecraft.resources.ResourceLocation; import net.minecraft.util.Tuple; -import net.minecraft.world.level.block.state.BlockState; -import net.minecraft.world.level.block.state.properties.AttachFace; import net.minecraft.world.phys.Vec2; -import org.joml.Matrix3f; -import org.joml.Matrix4f; import java.awt.*; import java.awt.image.BufferedImage; @@ -71,159 +53,6 @@ public static String getPointsKey(List zappyPoints) .collect(Collectors.joining(";")); } - public static HexPatternPoints generateHexPatternPoints(HexBlockEntity tile, HexPattern pattern, float flowIrregular) - { - var stupidHash = tile.getBlockPos().hashCode(); - var lines1 = pattern.toLines(1, Vec2.ZERO); - var zappyPoints = RenderLib.makeZappy(lines1, RenderLib.findDupIndices(pattern.positions()), - 10, 0.5f, 0f, flowIrregular, 0f, 1f, stupidHash); - return new HexPatternPoints(zappyPoints); - } - - public static void renderPatternForScroll(String pointsKey, PoseStack ps, MultiBufferSource bufSource, int light, List zappyPoints, int blockSize, boolean showStrokeOrder) - { - renderPattern(pointsKey, ps, bufSource, light, zappyPoints, blockSize, showStrokeOrder, false, true, false,false, true,-1); - } - public static void renderPatternForSlate(BlockEntitySlate tile, HexPattern pattern, PoseStack ps, MultiBufferSource buffer, int light, BlockState bs) - { - if(tile.points == null) - tile.points = generateHexPatternPoints(tile, pattern, 0.2f); - - boolean isOnWall = bs.getValue(BlockSlate.ATTACH_FACE) == AttachFace.WALL; - boolean isOnCeiling = bs.getValue(BlockSlate.ATTACH_FACE) == AttachFace.CEILING; - int facing = bs.getValue(BlockSlate.FACING).get2DDataValue(); - - renderPatternForBlockEntity(tile.points, ps, buffer, light, isOnWall, isOnCeiling, true, facing); - } - public static void renderPatternForAkashicBookshelf(BlockEntityAkashicBookshelf tile, HexPattern pattern, PoseStack ps, MultiBufferSource buffer, int light, BlockState bs) - { - if(tile.points == null) - tile.points = generateHexPatternPoints(tile, pattern, 0f); - - int facing = bs.getValue(BlockAkashicBookshelf.FACING).get2DDataValue(); - renderPatternForBlockEntity(tile.points, ps, buffer, light, true, false, false, facing); - } - - public static void renderPatternForBlockEntity(HexPatternPoints points, PoseStack ps, MultiBufferSource buffer, int light, boolean isOnWall, boolean isOnCeiling, boolean isSlate, int facing) - { - var oldShader = RenderSystem.getShader(); - ps.pushPose(); - RenderSystem.setShader(GameRenderer::getPositionTexShader); - renderPattern(points.pointsKey, ps, buffer, light, points.zappyPoints, 1, false, true, isOnWall, isOnCeiling, isSlate, false, facing); - ps.popPose(); - RenderSystem.setShader(() -> oldShader); - } - - public static void renderPattern(String pointsKey, PoseStack ps, MultiBufferSource bufSource, int light, List zappyPoints, int blockSize, boolean showStrokeOrder, boolean useFullSize, boolean isOnWall, boolean isOnCeiling, boolean isSlate, boolean isScroll, int facing) - { - ps.pushPose(); - - PoseStack.Pose last = ps.last(); - Matrix4f mat = last.pose(); - Matrix3f normal = last.normal(); - - float x = blockSize, y = blockSize, z = (-1f / 16f) - 0.01f; - float nx = 0, ny = 0, nz = 0; - - //TODO: refactor this mess of a method - - if(isOnWall) - { - if(isScroll) - { - ps.translate(-blockSize / 2f, -blockSize / 2f, 1f / 32f); - nz = -1; - } - else - { - ps.mulPose(Axis.ZP.rotationDegrees(180)); - - if(isSlate) - { - if(facing == 0) - ps.translate(0,-1,0); - if(facing == 1) - ps.translate(-1,-1,0); - if(facing == 2) - ps.translate(-1,-1,1); - if(facing == 3) - ps.translate(0,-1,1); - } - else - { - z = -0.01f; - if(facing == 0) - ps.translate(0,-1,1); - if(facing == 1) - ps.translate(0,-1,0); - if(facing == 2) - ps.translate(-1,-1,0); - if(facing == 3) - ps.translate(-1,-1,1); - } - - if(facing == 0) - ps.mulPose(Axis.YP.rotationDegrees(180)); - if(facing == 1) - ps.mulPose(Axis.YP.rotationDegrees(270)); - if(facing == 3) - ps.mulPose(Axis.YP.rotationDegrees(90)); - - if(facing == 0 || facing == 2) - nz = -1; - if(facing == 1 || facing == 3) - nx = -1; - ps.translate(0,0,0); - } - } - else //slates on the floor or ceiling - { - if(facing == 0) - ps.translate(0,0,0); - if(facing == 1) - ps.translate(1,0,0); - if(facing == 2) - ps.translate(1,0,1); - if(facing == 3) - ps.translate(0,0,1); - ps.mulPose(Axis.YP.rotationDegrees(facing*-90)); - - if(isOnCeiling) - { - ps.mulPose(Axis.XP.rotationDegrees(-90)); - ps.translate(0,-1,1); - } - else - ps.mulPose(Axis.XP.rotationDegrees(90)); - nz = -1; - } - - int lineWidth = otherLineWidth; - int outerColor = 0xff_d2c8c8; - int innerColor = 0xc8_322b33; - if(isScroll) - lineWidth = scrollLineWidth; - - ResourceLocation texture = getTexture(zappyPoints, pointsKey, blockSize, showStrokeOrder, lineWidth, useFullSize, new Color(innerColor), new Color(outerColor)); - VertexConsumer verts = bufSource.getBuffer(RenderType.entityCutout(texture)); - - vertex(mat, normal, light, verts, 0, 0, z, 0, 0, nx, ny, nz); - vertex(mat, normal, light, verts, 0, y, z, 0, 1, nx, ny, nz); - vertex(mat, normal, light, verts, x, y, z, 1, 1, nx, ny, nz); - vertex(mat, normal, light, verts, x, 0, z, 1, 0, nx, ny, nz); - - ps.popPose(); - } - - private static void vertex(Matrix4f mat, Matrix3f normal, int light, VertexConsumer verts, float x, float y, float z, - float u, float v, float nx, float ny, float nz) { - verts.vertex(mat, x, y, z) - .color(0xffffffff) - .uv(u, v).overlayCoords(OverlayTexture.NO_OVERLAY).uv2(light) - .normal(normal, nx, ny, nz) - .endVertex(); - } - public static ResourceLocation getTexture(List points, String pointsKey, int blockSize, boolean showsStrokeOrder, float lineWidth, boolean useFullSize, Color innerColor, Color outerColor) { if (patternTexturesToAdd.containsKey(pointsKey)) { var patternTexture = patternTexturesToAdd.remove(pointsKey); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java new file mode 100644 index 0000000000..d422fc9038 --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -0,0 +1,190 @@ +package at.petrak.hexcasting.client.render; + +import at.petrak.hexcasting.api.block.HexBlockEntity; +import at.petrak.hexcasting.api.casting.math.HexPattern; +import at.petrak.hexcasting.common.blocks.akashic.BlockAkashicBookshelf; +import at.petrak.hexcasting.common.blocks.akashic.BlockEntityAkashicBookshelf; +import at.petrak.hexcasting.common.blocks.circles.BlockEntitySlate; +import at.petrak.hexcasting.common.blocks.circles.BlockSlate; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.blaze3d.vertex.VertexConsumer; +import com.mojang.math.Axis; +import net.minecraft.client.renderer.GameRenderer; +import net.minecraft.client.renderer.MultiBufferSource; +import net.minecraft.client.renderer.RenderType; +import net.minecraft.client.renderer.texture.OverlayTexture; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.level.block.state.BlockState; +import net.minecraft.world.level.block.state.properties.AttachFace; +import net.minecraft.world.phys.Vec2; +import org.joml.Matrix3f; +import org.joml.Matrix4f; + +import java.awt.*; +import java.util.List; + +/** + * Helper methods for rendering patterns in the world. + */ +public class WorldlyPatternRenderHelpers { + public static void renderPatternForScroll(String pointsKey, PoseStack ps, MultiBufferSource bufSource, int light, List zappyPoints, int blockSize, boolean showStrokeOrder) + { + renderPattern(pointsKey, ps, bufSource, light, zappyPoints, blockSize, showStrokeOrder, false, true, false,false, true,-1); + } + + public static void renderPatternForSlate(BlockEntitySlate tile, HexPattern pattern, PoseStack ps, MultiBufferSource buffer, int light, BlockState bs) + { + if(tile.points == null) + tile.points = generateHexPatternPoints(tile, pattern, 0.2f); + + boolean isOnWall = bs.getValue(BlockSlate.ATTACH_FACE) == AttachFace.WALL; + boolean isOnCeiling = bs.getValue(BlockSlate.ATTACH_FACE) == AttachFace.CEILING; + int facing = bs.getValue(BlockSlate.FACING).get2DDataValue(); + + renderPatternForBlockEntity(tile.points, ps, buffer, light, isOnWall, isOnCeiling, true, facing); + } + + public static void renderPatternForAkashicBookshelf(BlockEntityAkashicBookshelf tile, HexPattern pattern, PoseStack ps, MultiBufferSource buffer, int light, BlockState bs) + { + if(tile.points == null) + tile.points = generateHexPatternPoints(tile, pattern, 0f); + + int facing = bs.getValue(BlockAkashicBookshelf.FACING).get2DDataValue(); + renderPatternForBlockEntity(tile.points, ps, buffer, light, true, false, false, facing); + } + + public static void renderPatternForBlockEntity(HexPatternPoints points, PoseStack ps, MultiBufferSource buffer, int light, boolean isOnWall, boolean isOnCeiling, boolean isSlate, int facing) + { + var oldShader = RenderSystem.getShader(); + ps.pushPose(); + RenderSystem.setShader(GameRenderer::getPositionTexShader); + renderPattern(points.pointsKey, ps, buffer, light, points.zappyPoints, 1, false, true, isOnWall, isOnCeiling, isSlate, false, facing); + ps.popPose(); + RenderSystem.setShader(() -> oldShader); + } + + /** + * Renders a pattern in world space based on the given transform requirements + */ + public static void renderPattern(String pointsKey, PoseStack ps, MultiBufferSource bufSource, int light, List zappyPoints, int blockSize, boolean showStrokeOrder, boolean useFullSize, boolean isOnWall, boolean isOnCeiling, boolean isSlate, boolean isScroll, int facing) + { + ps.pushPose(); + + PoseStack.Pose last = ps.last(); + Matrix4f mat = last.pose(); + Matrix3f normal = last.normal(); + + float x = blockSize, y = blockSize, z = (-1f / 16f) - 0.01f; + float nx = 0, ny = 0, nz = 0; + + //TODO: refactor this mess of a method + + if(isOnWall) + { + if(isScroll) + { + ps.translate(-blockSize / 2f, -blockSize / 2f, 1f / 32f); + nz = -1; + } + else + { + ps.mulPose(Axis.ZP.rotationDegrees(180)); + + if(isSlate) + { + if(facing == 0) + ps.translate(0,-1,0); + if(facing == 1) + ps.translate(-1,-1,0); + if(facing == 2) + ps.translate(-1,-1,1); + if(facing == 3) + ps.translate(0,-1,1); + } + else + { + z = -0.01f; + if(facing == 0) + ps.translate(0,-1,1); + if(facing == 1) + ps.translate(0,-1,0); + if(facing == 2) + ps.translate(-1,-1,0); + if(facing == 3) + ps.translate(-1,-1,1); + } + + if(facing == 0) + ps.mulPose(Axis.YP.rotationDegrees(180)); + if(facing == 1) + ps.mulPose(Axis.YP.rotationDegrees(270)); + if(facing == 3) + ps.mulPose(Axis.YP.rotationDegrees(90)); + + if(facing == 0 || facing == 2) + nz = -1; + if(facing == 1 || facing == 3) + nx = -1; + ps.translate(0,0,0); + } + } + else //slates on the floor or ceiling + { + if(facing == 0) + ps.translate(0,0,0); + if(facing == 1) + ps.translate(1,0,0); + if(facing == 2) + ps.translate(1,0,1); + if(facing == 3) + ps.translate(0,0,1); + ps.mulPose(Axis.YP.rotationDegrees(facing*-90)); + + if(isOnCeiling) + { + ps.mulPose(Axis.XP.rotationDegrees(-90)); + ps.translate(0,-1,1); + } + else + ps.mulPose(Axis.XP.rotationDegrees(90)); + nz = -1; + } + + int lineWidth = PatternTextureManager.otherLineWidth; + int outerColor = 0xff_d2c8c8; + int innerColor = 0xc8_322b33; + if(isScroll) + lineWidth = PatternTextureManager.scrollLineWidth; + + ResourceLocation texture = PatternTextureManager.getTexture(zappyPoints, pointsKey, blockSize, showStrokeOrder, lineWidth, useFullSize, new Color(innerColor), new Color(outerColor)); + VertexConsumer verts = bufSource.getBuffer(RenderType.entityCutout(texture)); + + vertex(mat, normal, light, verts, 0, 0, z, 0, 0, nx, ny, nz); + vertex(mat, normal, light, verts, 0, y, z, 0, 1, nx, ny, nz); + vertex(mat, normal, light, verts, x, y, z, 1, 1, nx, ny, nz); + vertex(mat, normal, light, verts, x, 0, z, 1, 0, nx, ny, nz); + + ps.popPose(); + } + + + + public static HexPatternPoints generateHexPatternPoints(HexBlockEntity tile, HexPattern pattern, float flowIrregular) + { + var stupidHash = tile.getBlockPos().hashCode(); + var lines1 = pattern.toLines(1, Vec2.ZERO); + var zappyPoints = RenderLib.makeZappy(lines1, RenderLib.findDupIndices(pattern.positions()), + 10, 0.5f, 0f, flowIrregular, 0f, 1f, stupidHash); + return new HexPatternPoints(zappyPoints); + } + + private static void vertex(Matrix4f mat, Matrix3f normal, int light, VertexConsumer verts, float x, float y, float z, + float u, float v, float nx, float ny, float nz) { + verts.vertex(mat, x, y, z) + .color(0xffffffff) + .uv(u, v).overlayCoords(OverlayTexture.NO_OVERLAY).uv2(light) + .normal(normal, nx, ny, nz) + .endVertex(); + } +} diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntityAkashicBookshelfRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntityAkashicBookshelfRenderer.java index e9064fb54c..f233ce6f4b 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntityAkashicBookshelfRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntityAkashicBookshelfRenderer.java @@ -3,6 +3,7 @@ import at.petrak.hexcasting.api.casting.math.HexPattern; import at.petrak.hexcasting.client.render.PatternTextureManager; import at.petrak.hexcasting.client.render.RenderLib; +import at.petrak.hexcasting.client.render.WorldlyPatternRenderHelpers; import at.petrak.hexcasting.common.blocks.akashic.BlockAkashicBookshelf; import at.petrak.hexcasting.common.blocks.akashic.BlockEntityAkashicBookshelf; import com.mojang.blaze3d.systems.RenderSystem; @@ -14,8 +15,6 @@ import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider; import net.minecraft.util.Mth; import net.minecraft.world.phys.Vec2; -import org.joml.AxisAngle4f; -import org.joml.Quaternionf; public class BlockEntityAkashicBookshelfRenderer implements BlockEntityRenderer { public BlockEntityAkashicBookshelfRenderer(BlockEntityRendererProvider.Context ctx) { @@ -33,7 +32,7 @@ public void render(BlockEntityAkashicBookshelf tile, float pPartialTick, PoseSta var bs = tile.getBlockState(); if(PatternTextureManager.useTextures) { - PatternTextureManager.renderPatternForAkashicBookshelf(tile, pattern, ps, buffer, light, bs); + WorldlyPatternRenderHelpers.renderPatternForAkashicBookshelf(tile, pattern, ps, buffer, light, bs); return; } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntitySlateRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntitySlateRenderer.java index 37a40babcd..803bb43cb1 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntitySlateRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntitySlateRenderer.java @@ -2,6 +2,7 @@ import at.petrak.hexcasting.client.render.PatternTextureManager; import at.petrak.hexcasting.client.render.RenderLib; +import at.petrak.hexcasting.client.render.WorldlyPatternRenderHelpers; import at.petrak.hexcasting.common.blocks.circles.BlockEntitySlate; import at.petrak.hexcasting.common.blocks.circles.BlockSlate; import com.mojang.blaze3d.systems.RenderSystem; @@ -31,7 +32,7 @@ public void render(BlockEntitySlate tile, float pPartialTick, PoseStack ps, var bs = tile.getBlockState(); if(PatternTextureManager.useTextures && !bs.getValue(BlockSlate.ENERGIZED)) { - PatternTextureManager.renderPatternForSlate(tile, tile.pattern, ps, buffer, light, bs); + WorldlyPatternRenderHelpers.renderPatternForSlate(tile, tile.pattern, ps, buffer, light, bs); return; } From 597ffd66db8e76c81879929793b0059008b37db9 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Fri, 28 Jun 2024 23:42:53 -0400 Subject: [PATCH 06/48] attempt/start (perhaps poorly) to clean up worldly pattern rendering --- .../render/WorldlyPatternRenderHelpers.java | 159 ++++++++++++------ 1 file changed, 107 insertions(+), 52 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index d422fc9038..a86a0962cf 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -18,6 +18,7 @@ import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.block.state.properties.AttachFace; import net.minecraft.world.phys.Vec2; +import net.minecraft.world.phys.Vec3; import org.joml.Matrix3f; import org.joml.Matrix4f; @@ -64,6 +65,8 @@ public static void renderPatternForBlockEntity(HexPatternPoints points, PoseStac RenderSystem.setShader(() -> oldShader); } + // TODO: clean up the args of this method, maybe make the whole PSTransformer thing less gross, move it to be just code in the methods or something maybe. + /** * Renders a pattern in world space based on the given transform requirements */ @@ -78,79 +81,37 @@ public static void renderPattern(String pointsKey, PoseStack ps, MultiBufferSour float x = blockSize, y = blockSize, z = (-1f / 16f) - 0.01f; float nx = 0, ny = 0, nz = 0; - //TODO: refactor this mess of a method + PSTransformer transformer; if(isOnWall) { if(isScroll) { - ps.translate(-blockSize / 2f, -blockSize / 2f, 1f / 32f); - nz = -1; + transformer = wallScrollTransformer; } else { - ps.mulPose(Axis.ZP.rotationDegrees(180)); - if(isSlate) { - if(facing == 0) - ps.translate(0,-1,0); - if(facing == 1) - ps.translate(-1,-1,0); - if(facing == 2) - ps.translate(-1,-1,1); - if(facing == 3) - ps.translate(0,-1,1); + transformer = wallSlateTransformer; } else { + transformer = wallBlockTransformer; z = -0.01f; - if(facing == 0) - ps.translate(0,-1,1); - if(facing == 1) - ps.translate(0,-1,0); - if(facing == 2) - ps.translate(-1,-1,0); - if(facing == 3) - ps.translate(-1,-1,1); } - - if(facing == 0) - ps.mulPose(Axis.YP.rotationDegrees(180)); - if(facing == 1) - ps.mulPose(Axis.YP.rotationDegrees(270)); - if(facing == 3) - ps.mulPose(Axis.YP.rotationDegrees(90)); - - if(facing == 0 || facing == 2) - nz = -1; - if(facing == 1 || facing == 3) - nx = -1; - ps.translate(0,0,0); } } else //slates on the floor or ceiling { - if(facing == 0) - ps.translate(0,0,0); - if(facing == 1) - ps.translate(1,0,0); - if(facing == 2) - ps.translate(1,0,1); - if(facing == 3) - ps.translate(0,0,1); - ps.mulPose(Axis.YP.rotationDegrees(facing*-90)); - - if(isOnCeiling) - { - ps.mulPose(Axis.XP.rotationDegrees(-90)); - ps.translate(0,-1,1); - } - else - ps.mulPose(Axis.XP.rotationDegrees(90)); - nz = -1; + transformer = isOnCeiling ? ceilSlateTransformer : floorSlateTransformer; } + Vec3 nVec = transformer.transform(ps, facing, blockSize); + nx = (float)nVec.x(); + ny = (float)nVec.y(); + nz = (float)nVec.z(); + int lineWidth = PatternTextureManager.otherLineWidth; int outerColor = 0xff_d2c8c8; int innerColor = 0xc8_322b33; @@ -187,4 +148,98 @@ private static void vertex(Matrix4f mat, Matrix3f normal, int light, VertexConsu .normal(normal, nx, ny, nz) .endVertex(); } + + + @FunctionalInterface + public interface PSTransformer{ + Vec3 transform(PoseStack ps, int facing, int blocksize); + } + + public static final PSTransformer wallScrollTransformer = (ps, facing, blockSize) -> { + ps.translate(-blockSize / 2f, -blockSize / 2f, 1f / 32f); + return new Vec3(0, 0, -1); + }; + + public static final PSTransformer floorSlateTransformer = (ps, facing, blockSize) -> { + if(facing == 0) + ps.translate(0,0,0); + if(facing == 1) + ps.translate(1,0,0); + if(facing == 2) + ps.translate(1,0,1); + if(facing == 3) + ps.translate(0,0,1); + + ps.mulPose(Axis.YP.rotationDegrees(facing*-90)); + ps.mulPose(Axis.XP.rotationDegrees(90)); + + return new Vec3(0, 0, -1); + }; + + public static final PSTransformer ceilSlateTransformer = (ps, facing, blockSize) -> { + if(facing == 0) + ps.translate(0,0,0); + if(facing == 1) + ps.translate(1,0,0); + if(facing == 2) + ps.translate(1,0,1); + if(facing == 3) + ps.translate(0,0,1); + + ps.mulPose(Axis.YP.rotationDegrees(facing*-90)); + ps.mulPose(Axis.XP.rotationDegrees(-90)); + ps.translate(0,-1,1); + + return new Vec3(0, 0, -1); + }; + + public static final PSTransformer wallSlateTransformer = (ps, facing, blocksize) -> { + ps.mulPose(Axis.ZP.rotationDegrees(180)); + + if(facing == 0){ + ps.translate(0,-1,0); + ps.mulPose(Axis.YP.rotationDegrees(180)); + return new Vec3(0, 0, -1); + } + if(facing == 1){ + ps.translate(-1,-1,0); + ps.mulPose(Axis.YP.rotationDegrees(270)); + return new Vec3(-1, 0, 0); + } + if(facing == 2){ + ps.translate(-1,-1,1); + return new Vec3(0, 0, -1); + } + if(facing == 3){ + ps.translate(0,-1,1); + ps.mulPose(Axis.YP.rotationDegrees(90)); + return new Vec3(-1, 0, 0); + } + return new Vec3(0,0,0); + }; + + public static final PSTransformer wallBlockTransformer = (ps, facing, blocksize) -> { + ps.mulPose(Axis.ZP.rotationDegrees(180)); + + if(facing == 0){ + ps.translate(0,-1,1); + ps.mulPose(Axis.YP.rotationDegrees(180)); + return new Vec3(0, 0, -1); + } + if(facing == 1){ + ps.translate(0,-1,0); + ps.mulPose(Axis.YP.rotationDegrees(270)); + return new Vec3(-1, 0, 0); + } + if(facing == 2){ + ps.translate(-1,-1,0); + return new Vec3(0, 0, -1); + } + if(facing == 3){ + ps.translate(-1,-1,1); + ps.mulPose(Axis.YP.rotationDegrees(90)); + return new Vec3(-1, 0, 0); + } + return new Vec3(0,0,0); + }; } From 5a07f3456c904485fa50f0e1ff37930eeb8d1eb4 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Mon, 1 Jul 2024 17:54:30 -0400 Subject: [PATCH 07/48] add pattern matcher and renderer skeleton --- .../petrak/hexcasting/interop/HexInterop.java | 5 + .../interop/inline/HexPatternMatcher.java | 91 +++++++++++++++++++ .../hexcasting/interop/inline/InlineHex.java | 9 ++ .../interop/inline/InlineHexClient.java | 11 +++ .../interop/inline/InlinePatternData.java | 17 +++- .../interop/inline/InlinePatternRenderer.java | 34 +++++++ 6 files changed, 166 insertions(+), 1 deletion(-) create mode 100644 Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java create mode 100644 Common/src/main/java/at/petrak/hexcasting/interop/inline/InlineHex.java create mode 100644 Common/src/main/java/at/petrak/hexcasting/interop/inline/InlineHexClient.java create mode 100644 Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/HexInterop.java b/Common/src/main/java/at/petrak/hexcasting/interop/HexInterop.java index 79220f4ab9..6ecbc2d40f 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/HexInterop.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/HexInterop.java @@ -1,5 +1,7 @@ package at.petrak.hexcasting.interop; +import at.petrak.hexcasting.interop.inline.InlineHex; +import at.petrak.hexcasting.interop.inline.InlineHexClient; import at.petrak.hexcasting.interop.pehkui.PehkuiInterop; import at.petrak.hexcasting.xplat.IClientXplatAbstractions; import at.petrak.hexcasting.xplat.IXplatAbstractions; @@ -30,10 +32,13 @@ public static void init() { } xplat.initPlatformSpecific(); + + InlineHex.init(); } public static void clientInit() { IClientXplatAbstractions.INSTANCE.initPlatformSpecific(); + InlineHexClient.init(); } private static void initPatchouli() { diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java new file mode 100644 index 0000000000..541cb45a98 --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java @@ -0,0 +1,91 @@ +package at.petrak.hexcasting.interop.inline; + +import at.petrak.hexcasting.api.HexAPI; +import at.petrak.hexcasting.api.casting.math.HexDir; +import at.petrak.hexcasting.api.casting.math.HexPattern; +import com.samsthenerd.inline.api.client.InlineMatch; +import com.samsthenerd.inline.api.client.MatcherInfo; +import com.samsthenerd.inline.api.client.matchers.RegexMatcher; +import net.minecraft.network.chat.Component; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.util.Tuple; +import org.jetbrains.annotations.NotNull; + +import javax.annotation.Nullable; +import java.util.HashMap; +import java.util.Map; +import java.util.regex.MatchResult; +import java.util.regex.Pattern; + +public class HexPatternMatcher implements RegexMatcher { + + private static final ResourceLocation patternMatcherID = HexAPI.modLoc("pattern"); + private static final MatcherInfo patternMatcherInfo = MatcherInfo.fromId(patternMatcherID); + + // thx kyra <3 + private static final Pattern PATTERN_PATTERN_REGEX = Pattern.compile("\\A(?\\\\?)(?:HexPattern)?[<(\\[{]\\s*(?[a-z_-]+)(?:\\s*[, ]\\s*(?[aqweds]+))?\\s*[>)\\]}]", Pattern.CASE_INSENSITIVE); + + public static HexPatternMatcher INSTANCE = new HexPatternMatcher(); + + public Pattern getRegex(){ + return PATTERN_PATTERN_REGEX; + } + + @NotNull + public Tuple getMatchAndGroup(MatchResult regexMatch) { + String escaped = regexMatch.group(1); + String dirString = regexMatch.group(2).toLowerCase().strip().replace("_", ""); + String angleSigs = regexMatch.group(3); + if(escaped == null){ + return new Tuple<>(new InlineMatch.TextMatch(Component.literal("")), 1); + } + // need to convert dirString to a HexDir + HexDir dir = dirMap.get(dirString); + if(dir == null) + return new Tuple<>(null, 0); + HexPattern pat; + try{ + pat = HexPattern.fromAngles(angleSigs, dir); + InlinePatternData patData = new InlinePatternData(pat); + return new Tuple<>(new InlineMatch.DataMatch(patData, patData.getExtraStyle()), 0); + } catch (Exception e){ + return new Tuple<>(null, 0); + } + } + + // not really used since we're doing escaping + @Nullable + public InlineMatch getMatch(MatchResult mr){ + return null; // nop + } + + public MatcherInfo getInfo(){ + return patternMatcherInfo; + } + + /** + * Get the ID for this matcher + * @return matcher's ID + */ + public ResourceLocation getId(){ + return patternMatcherID; + } + + private static final Map dirMap = new HashMap<>(); + + static { + dirMap.put("northwest", HexDir.NORTH_WEST); + dirMap.put("west", HexDir.WEST); + dirMap.put("southwest", HexDir.SOUTH_WEST); + dirMap.put("southeast", HexDir.SOUTH_EAST); + dirMap.put("east", HexDir.EAST); + dirMap.put("northeast", HexDir.NORTH_EAST); + dirMap.put("nw", HexDir.NORTH_WEST); + + dirMap.put("w", HexDir.WEST); + dirMap.put("sw", HexDir.SOUTH_WEST); + dirMap.put("se", HexDir.SOUTH_EAST); + dirMap.put("e", HexDir.EAST); + dirMap.put("ne", HexDir.NORTH_EAST); + } +} diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlineHex.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlineHex.java new file mode 100644 index 0000000000..fa9ce27a93 --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlineHex.java @@ -0,0 +1,9 @@ +package at.petrak.hexcasting.interop.inline; + +import com.samsthenerd.inline.api.InlineAPI; + +public class InlineHex { + public static void init(){ + InlineAPI.INSTANCE.addDataType(InlinePatternData.InlinePatternDataType.INSTANCE); + } +} diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlineHexClient.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlineHexClient.java new file mode 100644 index 0000000000..aa61b7e193 --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlineHexClient.java @@ -0,0 +1,11 @@ +package at.petrak.hexcasting.interop.inline; + +import com.samsthenerd.inline.api.client.InlineClientAPI; + +public class InlineHexClient { + + public static void init(){ + InlineClientAPI.INSTANCE.addMatcher(HexPatternMatcher.INSTANCE); + InlineClientAPI.INSTANCE.addRenderer(InlinePatternRenderer.INSTANCE); + } +} diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java index 4beb9e21ad..45bf77c6bb 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java @@ -1,14 +1,21 @@ package at.petrak.hexcasting.interop.inline; import at.petrak.hexcasting.api.HexAPI; +import at.petrak.hexcasting.api.casting.iota.PatternIota; import at.petrak.hexcasting.api.casting.math.HexPattern; +import at.petrak.hexcasting.common.lib.HexItems; import com.mojang.serialization.Codec; import com.samsthenerd.inline.api.InlineData; +import net.minecraft.network.chat.HoverEvent; +import net.minecraft.network.chat.Style; import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.item.ItemStack; import org.jetbrains.annotations.NotNull; public class InlinePatternData implements InlineData{ + public static final ResourceLocation rendererId = HexAPI.modLoc("pattern"); + @NotNull public final HexPattern pattern; @@ -23,7 +30,15 @@ public InlinePatternDataType getType(){ @Override public ResourceLocation getRendererId(){ - return new ResourceLocation(HexAPI.MOD_ID, "pattern"); + return rendererId; + } + + public Style getExtraStyle() { + ItemStack scrollStack = new ItemStack(HexItems.SCROLL_MEDIUM); + HexItems.SCROLL_MEDIUM.writeDatum(scrollStack, new PatternIota(pattern)); + HoverEvent he = new HoverEvent(HoverEvent.Action.SHOW_ITEM, new HoverEvent.ItemStackInfo(scrollStack)); + // TODO: add copy click event + return Style.EMPTY.withHoverEvent(he); } public static class InlinePatternDataType implements InlineDataType { diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java new file mode 100644 index 0000000000..2c37ed3395 --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -0,0 +1,34 @@ +package at.petrak.hexcasting.interop.inline; + +import at.petrak.hexcasting.api.casting.iota.PatternIota; +import at.petrak.hexcasting.common.lib.HexItems; +import com.samsthenerd.inline.api.client.InlineRenderer; +import com.samsthenerd.inline.api.client.renderers.InlineItemRenderer; +import com.samsthenerd.inline.api.data.ItemInlineData; +import net.minecraft.client.gui.GuiGraphics; +import net.minecraft.network.chat.Style; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.item.ItemStack; + +public class InlinePatternRenderer implements InlineRenderer { + + public static final InlinePatternRenderer INSTANCE = new InlinePatternRenderer(); + + public ResourceLocation getId(){ + return InlinePatternData.rendererId; + } + + public int render(InlinePatternData data, GuiGraphics drawContext, int index, Style style, int codepoint, TextRenderingContext trContext){ + ItemStack scrollStack = new ItemStack(HexItems.SCROLL_MEDIUM); + HexItems.SCROLL_MEDIUM.writeDatum(scrollStack, new PatternIota(data.pattern)); + // placeholder to test that matcher works + return InlineItemRenderer.INSTANCE.render(new ItemInlineData(scrollStack), drawContext, index, style, codepoint, trContext); + } + + public int charWidth(InlinePatternData data, Style style, int codepoint){ + ItemStack scrollStack = new ItemStack(HexItems.SCROLL_MEDIUM); + HexItems.SCROLL_MEDIUM.writeDatum(scrollStack, new PatternIota(data.pattern)); + // placeholder to test that matcher works + return InlineItemRenderer.INSTANCE.charWidth(new ItemInlineData(scrollStack), style, codepoint); + } +} From 5624440f3a51fbf4b9929338d18fdf901cad47d0 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Mon, 1 Jul 2024 22:32:02 -0400 Subject: [PATCH 08/48] inline patterns mostly working + general pattern render function started --- .../client/render/PatternRenderSettings.java | 122 ++++++++++++++++ .../client/render/PatternRenderer.java | 133 ++++++++++++++++++ .../interop/inline/HexPatternMatcher.java | 2 +- .../interop/inline/InlinePatternRenderer.java | 23 ++- 4 files changed, 266 insertions(+), 14 deletions(-) create mode 100644 Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java create mode 100644 Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java new file mode 100644 index 0000000000..de4f0a9538 --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java @@ -0,0 +1,122 @@ +package at.petrak.hexcasting.client.render; + +/* +TODO: + - handle padding, full size (for inline) vs normal + - it's actually more about scaling + - it's all the same for a square pattern, but we need to account for non-square patterns. + - ie, does it get fit to a specific axis (like inline fits to vertical and stretches as needed horizontally) + or does it fit on both/smaller fit like a scroll does. + - figure out how much is decided alongside zappy point list vs given from before -- all size stuff varies by like, + - figure out main render args + */ + +/** + * Immutable data class for informing how a pattern is rendered. + * + * (it's a pain but this isn't a record or kotlin data class because i want it non-final) + */ +public class PatternRenderSettings { + protected boolean drawOuter; + + protected FitAxis fitAxis; // which axes the pattern needs to be fit to. + + // all measurements are in the scale of whatever pose stack is given to the renderer. + protected double baseScale; // length between 2 adjacent points if not squished by any fit. + // TODO: consider doing a min size too, although that assumes there's a base scale already + protected double minWidth; + protected double minHeight; + + // height and with are only relevant if it's set to fit on that axis. + protected double spaceWidth = 1.0; + protected double spaceHeight = 1.0; + + // horizontal and vertical padding. used no matter the fit axis. + protected double hPadding; + protected double vPadding; + + // TODO: these should maybe be functions that take ?? something ?? + protected float innerWidth; + protected float outerWidth; + + // colors + protected int innerStartColor; + protected int innerEndColor; + protected int outerStartColor; + protected int outerEndColor; + + // zappy settings -- unused if you pass points instead of a pattern + protected int hops = 10; + protected float variance = 0.5f; + protected float speed; + protected float flowIrregular = 0.2f; + protected float readabilityOffset; + protected float lastSegmentLenProportion = 1f; + + + public PatternRenderSettings( + + ){ + + } + + // TODO: make this actually copy. + public PatternRenderSettings copy(){ + return this; + } + + public int getInnerStartColor(){ return innerStartColor; } + public int getInnerEndColor(){ return innerEndColor; } + public int getOuterStartColor(){ return outerStartColor; } + public int getOuterEndColor(){ return outerEndColor; } + + public PatternRenderSettings withColors(Integer startInner, Integer endInner, Integer startOuter, Integer endOuter){ + PatternRenderSettings newSettings = copy(); + newSettings.innerStartColor = (startInner == null) ? innerStartColor : startInner; + newSettings.innerEndColor = (endInner == null) ? innerEndColor : endInner; + newSettings.outerStartColor = (startOuter == null) ? outerStartColor : startOuter; + newSettings.outerEndColor = (endOuter == null) ? outerEndColor : endOuter; + return newSettings; + } + + public PatternRenderSettings withSizings(FitAxis fitAxis, Double spaceWidth, Double spaceHeight, Double hPadding, + Double vPadding, Double baseScale, Double minWidth, Double minHeight){ + PatternRenderSettings newSettings = copy(); + newSettings.fitAxis = fitAxis == null ? this.fitAxis : fitAxis; + newSettings.spaceWidth = spaceWidth == null ? this.spaceWidth : spaceWidth; + newSettings.spaceHeight = spaceHeight == null ? this.spaceHeight : spaceHeight; + newSettings.hPadding = hPadding == null ? this.hPadding : hPadding; + newSettings.vPadding = vPadding == null ? this.vPadding : vPadding; + newSettings.baseScale = baseScale == null ? this.baseScale : baseScale; + newSettings.minWidth = minWidth == null ? this.minWidth : minWidth; + newSettings.minHeight = minHeight == null ? this.minHeight : minHeight; + return newSettings; + } + + public PatternRenderSettings withZappySettings(Integer hops, Float variance, Float speed, Float flowIrregular, + Float readabilityOffset, Float lastSegmentLenProportion){ + PatternRenderSettings newSettings = copy(); + newSettings.hops = hops == null ? this.hops : hops; + newSettings.variance = variance == null ? this.variance : variance; + newSettings.speed = speed == null ? this.speed : speed; + newSettings.flowIrregular = flowIrregular == null ? this.flowIrregular : flowIrregular; + newSettings.readabilityOffset = readabilityOffset == null ? this.readabilityOffset : readabilityOffset; + newSettings.lastSegmentLenProportion = lastSegmentLenProportion == null ? this.lastSegmentLenProportion : lastSegmentLenProportion; + return newSettings; + } + + public enum FitAxis{ + HOR(true, false), + VERT(false, true), + BOTH(true, true), + NONE(false, false); + + public final boolean horFit; + public final boolean vertFit; + + FitAxis(boolean horFit, boolean vertFit){ + this.horFit = horFit; + this.vertFit = vertFit; + } + } +} diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java new file mode 100644 index 0000000000..2a9ed14434 --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -0,0 +1,133 @@ +package at.petrak.hexcasting.client.render; + + +import at.petrak.hexcasting.api.casting.math.HexPattern; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.PoseStack; +import net.minecraft.client.renderer.GameRenderer; +import net.minecraft.world.phys.Vec2; + +import java.util.ArrayList; +import java.util.List; +import java.util.Set; + +public class PatternRenderer { + + public static void renderPattern(HexPattern pattern, PoseStack ps, PatternRenderSettings patSets, double seed){ + var oldShader = RenderSystem.getShader(); + RenderSystem.setShader(GameRenderer::getPositionColorShader); + RenderSystem.enableDepthTest(); + RenderSystem.disableCull(); + + ps.pushPose(); + + // Resolution is the number of sub-voxels in the block for rendering purposes, 16 is the default + // padding is the space to leave on the edges free of pattern +// int resolution = 16; +// int padding = resolution * PatternTextureManager.paddingByBlockSize / PatternTextureManager.resolutionByBlockSize; + +// // and now Z is out? +// ps.translate(0, 0, -0.5); +// ps.scale(1f / resolution, 1f / resolution, 1f / resolution); +// ps.translate(0, 0, 1.01); + + List lines1 = pattern.toLines(1, Vec2.ZERO); + Set dupIndices = RenderLib.findDupIndices(pattern.positions()); + List zappyPattern = RenderLib.makeZappy(lines1, dupIndices, + patSets.hops, patSets.variance, patSets.speed, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); + + // always do space calculations with the static version of the pattern + // so that it doesn't jump around resizing itself. + List zappyPatternSpace = RenderLib.makeZappy(lines1, dupIndices, + patSets.hops, patSets.variance, 0f, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); + + double minX = Double.MAX_VALUE, maxX = Double.MIN_VALUE, minY = Double.MAX_VALUE, maxY = Double.MIN_VALUE; + for (Vec2 point : zappyPatternSpace) + { + minX = Math.min(minX, point.x); + maxX = Math.max(maxX, point.x); + minY = Math.min(minY, point.y); + maxY = Math.max(maxY, point.y); + } + + double rangeX = maxX - minX; + double rangeY = maxY - minY; + + int patStepsX = (int)Math.round(rangeX / 1.5); + int patStepsY = (int)Math.round(rangeY / 1.7); + + /* + -- 2 up 1 across: rangeX: 1.7320507764816284 rangeY: 3.0 + -- flat, 3 across: rangeX: 5.196152210235596 rangeY: 0.06766534224152565 + -- single triangle: rangeX: 1.7320507764816284 rangeY: 1.5277782939374447 + */ +// HexAPI.LOGGER.info("rangeX: " + rangeX + " rangeY: " + rangeY); + + // scales the patterns so that each point is patSets.baseScale units apart + double baseScale = patSets.baseScale / 1.5; + + // size of the pattern in pose space with no other adjustments + double baseWidth = rangeX * baseScale; + double baseHeight = rangeY * baseScale; + + // make sure that the scale fits within our min sizes + double scale = Math.max(1.0, Math.max(patSets.minWidth / baseWidth, patSets.minHeight / baseHeight)); + + // scale down if needed to fit in vertical space + if(patSets.fitAxis.vertFit){ + scale = Math.min(scale, (patSets.spaceHeight - 2 * patSets.vPadding)/(baseHeight)); + } + + // scale down if needed to fit in horizontal space + if(patSets.fitAxis.horFit){ + scale = Math.min(scale, (patSets.spaceWidth - 2 * patSets.hPadding)/(baseWidth)); + } + +// +// double offsetX = ((- 2 * patSets.hPadding) - baseWidth * scale) / 2; +// double offsetY = ((- 2 * patSets.vPadding) - baseHeight * scale) / 2; + + List zappyRenderSpace = new ArrayList<>(); + + for (Vec2 point : zappyPattern) { + zappyRenderSpace.add(new Vec2( + (float) (((point.x - minX) * baseScale * scale) + patSets.hPadding), + (float) (((point.y - minY) * baseScale * scale) + patSets.vPadding) + )); + } + + RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, 1f, 0f, patSets.getOuterEndColor(), patSets.getOuterStartColor()); + RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, 1f, 0.01f, patSets.getInnerEndColor(), patSets.getInnerStartColor()); + + ps.popPose(); + RenderSystem.enableCull(); + RenderSystem.setShader(() -> oldShader); + } + + // TODO: make this not be duplicate code / figure out how to integrate it with render function / maybe cache some bits + public static double getPatternWHRatio(HexPattern pattern, PatternRenderSettings patSets, double seed){ + List lines1 = pattern.toLines(1, Vec2.ZERO); + Set dupIndices = RenderLib.findDupIndices(pattern.positions()); + List zappyPattern = RenderLib.makeZappy(lines1, dupIndices, + patSets.hops, patSets.variance, patSets.speed, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); + + // always do space calculations with the static version of the pattern + // so that it doesn't jump around resizing itself. + List zappyPatternSpace = RenderLib.makeZappy(lines1, dupIndices, + patSets.hops, patSets.variance, 0f, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); + + double minX = Double.MAX_VALUE, maxX = Double.MIN_VALUE, minY = Double.MAX_VALUE, maxY = Double.MIN_VALUE; + for (Vec2 point : zappyPatternSpace) + { + minX = Math.min(minX, point.x); + maxX = Math.max(maxX, point.x); + minY = Math.min(minY, point.y); + maxY = Math.max(maxY, point.y); + } + + double rangeX = maxX - minX; + double rangeY = maxY - minY; + + return rangeX/rangeY; + } +} diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java index 541cb45a98..8d02c0c583 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java @@ -23,7 +23,7 @@ public class HexPatternMatcher implements RegexMatcher { private static final MatcherInfo patternMatcherInfo = MatcherInfo.fromId(patternMatcherID); // thx kyra <3 - private static final Pattern PATTERN_PATTERN_REGEX = Pattern.compile("\\A(?\\\\?)(?:HexPattern)?[<(\\[{]\\s*(?[a-z_-]+)(?:\\s*[, ]\\s*(?[aqweds]+))?\\s*[>)\\]}]", Pattern.CASE_INSENSITIVE); + private static final Pattern PATTERN_PATTERN_REGEX = Pattern.compile("(?\\\\?)(?:HexPattern)?[<(\\[{]\\s*(?[a-z_-]+)(?:\\s*[, ]\\s*(?[aqweds]+))?\\s*[>)\\]}]", Pattern.CASE_INSENSITIVE); public static HexPatternMatcher INSTANCE = new HexPatternMatcher(); diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index 2c37ed3395..73a54b4faf 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -1,14 +1,11 @@ package at.petrak.hexcasting.interop.inline; -import at.petrak.hexcasting.api.casting.iota.PatternIota; -import at.petrak.hexcasting.common.lib.HexItems; +import at.petrak.hexcasting.client.render.PatternRenderSettings; +import at.petrak.hexcasting.client.render.PatternRenderer; import com.samsthenerd.inline.api.client.InlineRenderer; -import com.samsthenerd.inline.api.client.renderers.InlineItemRenderer; -import com.samsthenerd.inline.api.data.ItemInlineData; import net.minecraft.client.gui.GuiGraphics; import net.minecraft.network.chat.Style; import net.minecraft.resources.ResourceLocation; -import net.minecraft.world.item.ItemStack; public class InlinePatternRenderer implements InlineRenderer { @@ -18,17 +15,17 @@ public ResourceLocation getId(){ return InlinePatternData.rendererId; } + public static final PatternRenderSettings INLINE_RENDER_SETTINGS = new PatternRenderSettings() + .withSizings(PatternRenderSettings.FitAxis.VERT, 8.0, 8.0, 0.0, 0.0, 4.0, null, null) + .withColors(0xFF_FFFFFF, 0xFF_FFFFFF, null, null); + public int render(InlinePatternData data, GuiGraphics drawContext, int index, Style style, int codepoint, TextRenderingContext trContext){ - ItemStack scrollStack = new ItemStack(HexItems.SCROLL_MEDIUM); - HexItems.SCROLL_MEDIUM.writeDatum(scrollStack, new PatternIota(data.pattern)); - // placeholder to test that matcher works - return InlineItemRenderer.INSTANCE.render(new ItemInlineData(scrollStack), drawContext, index, style, codepoint, trContext); + PatternRenderer.renderPattern(data.pattern, drawContext.pose(), INLINE_RENDER_SETTINGS, 0); + + return (int)(8 * PatternRenderer.getPatternWHRatio(data.pattern, INLINE_RENDER_SETTINGS, 0)); } public int charWidth(InlinePatternData data, Style style, int codepoint){ - ItemStack scrollStack = new ItemStack(HexItems.SCROLL_MEDIUM); - HexItems.SCROLL_MEDIUM.writeDatum(scrollStack, new PatternIota(data.pattern)); - // placeholder to test that matcher works - return InlineItemRenderer.INSTANCE.charWidth(new ItemInlineData(scrollStack), style, codepoint); + return (int)(8 * PatternRenderer.getPatternWHRatio(data.pattern, INLINE_RENDER_SETTINGS, 0)); } } From 280270b867ddd083952d2270d26fd8cd553d674b Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Thu, 4 Jul 2024 00:56:14 -0400 Subject: [PATCH 09/48] horrible half broken code. Texture stuff is on the operating table, wires and organs everywhere. Moved pattern color settings out of general render settings. moved cooler render lib stuff out of wall scroll renderer. Added lighting support-ish for non-static renderer with a hacky workaround. Hooked worldly renderers up to new render system, seem to mostly work. Bunch of other little progress on render rework stuff --- .../client/entity/WallScrollRenderer.java | 220 ++++-------------- .../client/render/HexPatternPoints.java | 53 ++++- .../client/render/PatternColors.java | 30 +++ .../client/render/PatternRenderSettings.java | 66 +++--- .../client/render/PatternRenderer.java | 148 ++++++------ .../client/render/PatternTextureManager.java | 128 +++++----- .../client/render/TheCoolerRenderLib.java | 155 ++++++++++++ .../render/WorldlyPatternRenderHelpers.java | 82 ++++--- .../blocks/circles/BlockEntitySlate.java | 2 - .../common/entities/EntityWallScroll.java | 30 +-- .../interop/inline/InlinePatternRenderer.java | 18 +- .../client/AccessorLightTexturePixels.java | 12 + Common/src/main/resources/hexplat.mixins.json | 1 + 13 files changed, 549 insertions(+), 396 deletions(-) create mode 100644 Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java create mode 100644 Common/src/main/java/at/petrak/hexcasting/client/render/TheCoolerRenderLib.java create mode 100644 Common/src/main/java/at/petrak/hexcasting/mixin/accessor/client/AccessorLightTexturePixels.java diff --git a/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java index 85af0ba620..8e448fe2d7 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java @@ -1,7 +1,6 @@ package at.petrak.hexcasting.client.entity; import at.petrak.hexcasting.client.render.PatternTextureManager; -import at.petrak.hexcasting.client.render.RenderLib; import at.petrak.hexcasting.client.render.WorldlyPatternRenderHelpers; import at.petrak.hexcasting.common.entities.EntityWallScroll; import com.mojang.blaze3d.systems.RenderSystem; @@ -16,13 +15,9 @@ import net.minecraft.client.renderer.entity.EntityRendererProvider; import net.minecraft.client.renderer.texture.OverlayTexture; import net.minecraft.resources.ResourceLocation; -import net.minecraft.util.Mth; -import net.minecraft.world.phys.Vec2; import org.joml.Matrix3f; import org.joml.Matrix4f; -import java.util.List; - import static at.petrak.hexcasting.api.HexAPI.modLoc; public class WallScrollRenderer extends EntityRenderer { @@ -32,7 +27,6 @@ public class WallScrollRenderer extends EntityRenderer { private static final ResourceLocation ANCIENT_BG_LARGE = modLoc("textures/entity/scroll_ancient_large.png"); private static final ResourceLocation ANCIENT_BG_MEDIUM = modLoc("textures/entity/scroll_ancient_medium.png"); private static final ResourceLocation ANCIENT_BG_SMOL = modLoc("textures/block/ancient_scroll_paper.png"); - private static final ResourceLocation WHITE = modLoc("textures/entity/white.png"); public WallScrollRenderer(EntityRendererProvider.Context p_174008_) { super(p_174008_); @@ -100,43 +94,43 @@ public void render(EntityWallScroll wallScroll, float yaw, float partialTicks, P ps.popPose(); - if (PatternTextureManager.useTextures && wallScroll.points != null) - WorldlyPatternRenderHelpers.renderPatternForScroll(wallScroll.points.pointsKey, ps, bufSource, light, wallScroll.points.zappyPoints, wallScroll.blockSize, wallScroll.getShowsStrokeOrder()); + if (PatternTextureManager.useTextures) //&& wallScroll.points != null) + WorldlyPatternRenderHelpers.renderPatternForScroll(wallScroll.pattern, wallScroll, ps, bufSource, light, wallScroll.blockSize, wallScroll.getShowsStrokeOrder()); } //TODO: remove old rendering if not needed anymore for comparison - if (!PatternTextureManager.useTextures && wallScroll.points != null) { - var points = wallScroll.points.zappyPoints; - ps.pushPose(); - - ps.mulPose(Axis.YP.rotationDegrees(180f)); - ps.translate(0, 0, 1.1f / 16f); - // make smaller scrolls not be charlie kirk-sized - // i swear, learning about these functions with asymptotes where slope != 0 is the most useful thing - // I've ever learned in a math class - float unCharlieKirk = Mth.sqrt(wallScroll.blockSize * wallScroll.blockSize + 60); - float scale = 1f / 300f * unCharlieKirk; - ps.scale(scale, scale, 0.01f); - - var last = ps.last(); - var mat = last.pose(); - var norm = last.normal(); - var outer = 0xff_d2c8c8; - var inner = 0xc8_322b33; - var verts = bufSource.getBuffer(RenderType.entityCutout(WHITE)); - theCoolerDrawLineSeq(mat, norm, light, verts, points, wallScroll.blockSize * 5f / 3f, outer); - ps.translate(0, 0, 0.01); - theCoolerDrawLineSeq(mat, norm, light, verts, points, wallScroll.blockSize * 2f / 3f, inner); - - if (wallScroll.getShowsStrokeOrder()) { - ps.translate(0, 0, 0.01); - var spotFrac = 0.8f * wallScroll.blockSize; - theCoolerDrawSpot(mat, norm, light, verts, points.get(0), 2f / 3f * spotFrac, - 0xff_5b7bd7); - } - - ps.popPose(); - } +// if (!PatternTextureManager.useTextures && wallScroll.points != null) { +// var points = wallScroll.points.zappyPoints; +// ps.pushPose(); +// +// ps.mulPose(Axis.YP.rotationDegrees(180f)); +// ps.translate(0, 0, 1.1f / 16f); +// // make smaller scrolls not be charlie kirk-sized +// // i swear, learning about these functions with asymptotes where slope != 0 is the most useful thing +// // I've ever learned in a math class +// float unCharlieKirk = Mth.sqrt(wallScroll.blockSize * wallScroll.blockSize + 60); +// float scale = 1f / 300f * unCharlieKirk; +// ps.scale(scale, scale, 0.01f); +// +// var last = ps.last(); +// var mat = last.pose(); +// var norm = last.normal(); +// var outer = 0xff_d2c8c8; +// var inner = 0xc8_322b33; +// var verts = bufSource.getBuffer(RenderType.entityCutout(WHITE)); +// theCoolerDrawLineSeq(mat, norm, light, verts, points, wallScroll.blockSize * 5f / 3f, outer); +// ps.translate(0, 0, 0.01); +// theCoolerDrawLineSeq(mat, norm, light, verts, points, wallScroll.blockSize * 2f / 3f, inner); +// +// if (wallScroll.getShowsStrokeOrder()) { +// ps.translate(0, 0, 0.01); +// var spotFrac = 0.8f * wallScroll.blockSize; +// theCoolerDrawSpot(mat, norm, light, verts, points.get(0), 2f / 3f * spotFrac, +// 0xff_5b7bd7); +// } +// +// ps.popPose(); +// } ps.popPose(); super.render(wallScroll, yaw, partialTicks, ps, bufSource, packedLight); @@ -164,146 +158,12 @@ public ResourceLocation getTextureLocation(EntityWallScroll wallScroll) { } private static void vertex(Matrix4f mat, Matrix3f normal, int light, VertexConsumer verts, float x, float y, - float z, float u, - float v, float nx, float ny, float nz) { + float z, float u, + float v, float nx, float ny, float nz) { verts.vertex(mat, x, y, z) - .color(0xffffffff) - .uv(u, v).overlayCoords(OverlayTexture.NO_OVERLAY).uv2(light) - .normal(normal, nx, ny, nz) - .endVertex(); - } - - private static void vertexCol(Matrix4f mat, Matrix3f normal, int light, VertexConsumer verts, int col, Vec2 pos) { - verts.vertex(mat, -pos.x, pos.y, 0) - .color(col) - .uv(0, 0).overlayCoords(OverlayTexture.NO_OVERLAY).uv2(light) - .normal(normal, 0, 0, 1) - .endVertex(); - } - - private static void theCoolerDrawLineSeq(Matrix4f mat, Matrix3f normalMat, int light, VertexConsumer verts, - List points, float width, int color - ) { - if (points.size() <= 1) { - return; - } - - // TODO: abstract some of this out with RenderLib to stop WET code - var joinAngles = new float[points.size()]; - var joinOffsets = new float[points.size()]; - for (int i = 2; i < points.size(); i++) { - var p0 = points.get(i - 2); - var p1 = points.get(i - 1); - var p2 = points.get(i); - var prev = p1.add(p0.negated()); - var next = p2.add(p1.negated()); - var angle = (float) Mth.atan2( - prev.x * next.y - prev.y * next.x, - prev.x * next.x + prev.y * next.y); - joinAngles[i - 1] = angle; - var clamp = Math.min(prev.length(), next.length()) / (width * 0.5f); - joinOffsets[i - 1] = Mth.clamp(Mth.sin(angle) / (1 + Mth.cos(angle)), -clamp, clamp); - } - - for (var i = 0; i < points.size() - 1; i++) { - var p1 = points.get(i); - var p2 = points.get(i + 1); - - var tangent = p2.add(p1.negated()).normalized().scale(width * 0.5f); - var normal = new Vec2(-tangent.y, tangent.x); - - var jlow = joinOffsets[i]; - var jhigh = joinOffsets[i + 1]; - - var p1Down = p1.add(tangent.scale(Math.max(0f, jlow))).add(normal); - var p1Up = p1.add(tangent.scale(Math.max(0f, -jlow))).add(normal.negated()); - var p2Down = p2.add(tangent.scale(Math.max(0f, jhigh)).negated()).add(normal); - var p2Up = p2.add(tangent.scale(Math.max(0f, -jhigh)).negated()).add(normal.negated()); - - // Draw the chamfer hexagon as two trapezoids - // the points are in different orders to keep clockwise - vertexCol(mat, normalMat, light, verts, color, p1); - vertexCol(mat, normalMat, light, verts, color, p2); - vertexCol(mat, normalMat, light, verts, color, p2Up); - vertexCol(mat, normalMat, light, verts, color, p1Up); - - vertexCol(mat, normalMat, light, verts, color, p1); - vertexCol(mat, normalMat, light, verts, color, p1Down); - vertexCol(mat, normalMat, light, verts, color, p2Down); - vertexCol(mat, normalMat, light, verts, color, p2); - - if (i > 0) { - var sangle = joinAngles[i]; - var angle = Math.abs(sangle); - var rnormal = normal.negated(); - var joinSteps = Mth.ceil(angle * 180 / (RenderLib.CAP_THETA * Mth.PI)); - if (joinSteps < 1) continue; - - if (sangle < 0) { - var prevVert = new Vec2(p1.x - rnormal.x, p1.y - rnormal.y); - for (var j = 1; j <= joinSteps; j++) { - var fan = RenderLib.rotate(rnormal, -sangle * ((float) j / joinSteps)); - var fanShift = new Vec2(p1.x - fan.x, p1.y - fan.y); - - vertexCol(mat, normalMat, light, verts, color, p1); - vertexCol(mat, normalMat, light, verts, color, p1); - vertexCol(mat, normalMat, light, verts, color, fanShift); - vertexCol(mat, normalMat, light, verts, color, prevVert); - prevVert = fanShift; - } - } else { - var startFan = RenderLib.rotate(normal, -sangle); - var prevVert = new Vec2(p1.x - startFan.x, p1.y - startFan.y); - for (var j = joinSteps - 1; j >= 0; j--) { - var fan = RenderLib.rotate(normal, -sangle * ((float) j / joinSteps)); - var fanShift = new Vec2(p1.x - fan.x, p1.y - fan.y); - - vertexCol(mat, normalMat, light, verts, color, p1); - vertexCol(mat, normalMat, light, verts, color, p1); - vertexCol(mat, normalMat, light, verts, color, fanShift); - vertexCol(mat, normalMat, light, verts, color, prevVert); - prevVert = fanShift; - } - } - } - } - - for (var pair : new Vec2[][]{ - {points.get(0), points.get(1)}, - {points.get(points.size() - 1), points.get(points.size() - 2)} - }) { - var point = pair[0]; - var prev = pair[1]; - - var tangent = point.add(prev.negated()).normalized().scale(0.5f * width); - var normal = new Vec2(-tangent.y, tangent.x); - var joinSteps = Mth.ceil(180f / RenderLib.CAP_THETA); - for (int j = joinSteps; j > 0; j--) { - var fan0 = RenderLib.rotate(normal, -Mth.PI * ((float) j / joinSteps)); - var fan1 = RenderLib.rotate(normal, -Mth.PI * ((float) (j - 1) / joinSteps)); - - vertexCol(mat, normalMat, light, verts, color, point); - vertexCol(mat, normalMat, light, verts, color, point); - vertexCol(mat, normalMat, light, verts, color, point.add(fan1)); - vertexCol(mat, normalMat, light, verts, color, point.add(fan0)); - } - } - } - - private static void theCoolerDrawSpot(Matrix4f mat, Matrix3f normal, int light, VertexConsumer verts, - Vec2 point, float radius, int color) { - var fracOfCircle = 6; - for (int i = 0; i < fracOfCircle; i++) { - // We do need rects, irritatingly - // so we do fake triangles - vertexCol(mat, normal, light, verts, color, point); - vertexCol(mat, normal, light, verts, color, point); - for (int j = 0; j <= 1; j++) { - var theta = (i - j) / (float) fracOfCircle * Mth.TWO_PI; - var rx = Mth.cos(theta) * radius + point.x; - var ry = Mth.sin(theta) * radius + point.y; - vertexCol(mat, normal, light, verts, color, new Vec2(rx, ry)); - } - } + .color(0xffffffff) + .uv(u, v).overlayCoords(OverlayTexture.NO_OVERLAY).uv2(light) + .normal(normal, nx, ny, nz) + .endVertex(); } } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java index b033e8de36..a8d1a5cc1c 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java @@ -1,15 +1,60 @@ package at.petrak.hexcasting.client.render; +import at.petrak.hexcasting.api.casting.math.HexPattern; import net.minecraft.world.phys.Vec2; +import java.util.HashMap; import java.util.List; +import java.util.Set; public class HexPatternPoints { - public List zappyPoints = null; - public String pointsKey = null; //TODO: if a string key isnt performant enough override hashcode for points + public List zappyPoints; +// public String pointsKey = null; //TODO: if a string key isnt performant enough override hashcode for points - public HexPatternPoints(List zappyPoints) { + public double minX = Double.MAX_VALUE; + public double maxX = Double.MIN_VALUE; + public double minY = Double.MAX_VALUE; + public double maxY = Double.MIN_VALUE; + + public double rangeX; + public double rangeY; + + private static final HashMap CACHED_STATIC_POINTS = new HashMap<>(); + + private HexPatternPoints(List zappyPoints) { this.zappyPoints = zappyPoints; - pointsKey = PatternTextureManager.getPointsKey(zappyPoints); +// pointsKey = PatternTextureManager.getPointsKey(zappyPoints); + for (Vec2 point : zappyPoints) { + minX = Math.min(minX, point.x); + maxX = Math.max(maxX, point.x); + minY = Math.min(minY, point.y); + maxY = Math.max(maxY, point.y); + } + rangeX = maxX - minX; + rangeY = maxY - minY; + } + + + /** + * Gets the static points for the given pattern, settings, and seed. This is cached. + * + * This is used in rendering static patterns and positioning non-static patterns. + * + */ + public static HexPatternPoints getStaticPoints(HexPattern pattern, PatternRenderSettings patSets, double seed){ + + String cacheKey = patSets.getCacheKey(pattern, seed); + + return CACHED_STATIC_POINTS.computeIfAbsent(cacheKey, (key) -> { + List lines1 = pattern.toLines(1, Vec2.ZERO); + Set dupIndices = RenderLib.findDupIndices(pattern.positions()); + + // always do space calculations with the static version of the pattern + // so that it doesn't jump around resizing itself. + List zappyPatternSpace = RenderLib.makeZappy(lines1, dupIndices, + patSets.hops, patSets.variance, 0f, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); + + return new HexPatternPoints(zappyPatternSpace); + }); } } \ No newline at end of file diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java new file mode 100644 index 0000000000..ea851ade57 --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java @@ -0,0 +1,30 @@ +package at.petrak.hexcasting.client.render; + +/** + * An immutable wrapper for pattern colors. + * + * This is separate from PatternRenderSettings because it does not affect the shape of the pattern, so we can re-use + * those parts for different colors. + */ +public class PatternColors { + protected final int innerStartColor; + protected final int innerEndColor; + protected final int outerStartColor; + protected final int outerEndColor; + + public PatternColors(int innerStartColor, int innerEndColor, int outerStartColor, int outerEndColor){ + this.innerStartColor = innerStartColor; + this.innerEndColor = innerEndColor; + this.outerStartColor = outerStartColor; + this.outerEndColor = outerEndColor; + } + + public PatternColors(int innerColor, int outerColor){ + this(innerColor, innerColor, outerColor, outerColor); + } + + // single color + public PatternColors(int color){ + this(color, 0); + } +} diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java index de4f0a9538..8153773019 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java @@ -11,19 +11,24 @@ - figure out main render args */ +import at.petrak.hexcasting.api.casting.math.HexPattern; + +import java.util.UUID; +import java.util.function.UnaryOperator; + /** * Immutable data class for informing how a pattern is rendered. * * (it's a pain but this isn't a record or kotlin data class because i want it non-final) */ public class PatternRenderSettings { - protected boolean drawOuter; protected FitAxis fitAxis; // which axes the pattern needs to be fit to. + protected String id = "default"; + // all measurements are in the scale of whatever pose stack is given to the renderer. protected double baseScale; // length between 2 adjacent points if not squished by any fit. - // TODO: consider doing a min size too, although that assumes there's a base scale already protected double minWidth; protected double minHeight; @@ -35,15 +40,8 @@ public class PatternRenderSettings { protected double hPadding; protected double vPadding; - // TODO: these should maybe be functions that take ?? something ?? - protected float innerWidth; - protected float outerWidth; - - // colors - protected int innerStartColor; - protected int innerEndColor; - protected int outerStartColor; - protected int outerEndColor; + protected UnaryOperator innerWidthProvider = (scale) -> 0.1f; + protected UnaryOperator outerWidthProvider = (scale) -> 0.15f; // zappy settings -- unused if you pass points instead of a pattern protected int hops = 10; @@ -54,33 +52,35 @@ public class PatternRenderSettings { protected float lastSegmentLenProportion = 1f; - public PatternRenderSettings( + public PatternRenderSettings(){} + private PatternRenderSettings( + FitAxis fitAxis, double baseScale, double minWidth, double minHeight, double spaceWidth, double spaceHeight, + double hPadding, double vPadding, int hops, float variance, float speed, float flowIrregular, float readabilityOffset, + float lastSegmentLenProportion, UnaryOperator innerWidthProvider, UnaryOperator outerWidthProvider ){ - + this.fitAxis = fitAxis; this.baseScale = baseScale; this.minWidth = minWidth; this.minHeight = minHeight; + this.spaceWidth = spaceWidth; this.spaceHeight = spaceHeight; this.hPadding = hPadding; this.vPadding = vPadding; this.hops = hops; this.variance = variance; this.speed = speed; + this.flowIrregular = flowIrregular; this.readabilityOffset = readabilityOffset; this.lastSegmentLenProportion = lastSegmentLenProportion; + this.innerWidthProvider = innerWidthProvider; this.outerWidthProvider = outerWidthProvider; + // *dies* } - // TODO: make this actually copy. - public PatternRenderSettings copy(){ - return this; + public String getCacheKey(HexPattern pattern, double seed){ + return pattern.toString() + ";" + id + ";" + seed; } - public int getInnerStartColor(){ return innerStartColor; } - public int getInnerEndColor(){ return innerEndColor; } - public int getOuterStartColor(){ return outerStartColor; } - public int getOuterEndColor(){ return outerEndColor; } - - public PatternRenderSettings withColors(Integer startInner, Integer endInner, Integer startOuter, Integer endOuter){ - PatternRenderSettings newSettings = copy(); - newSettings.innerStartColor = (startInner == null) ? innerStartColor : startInner; - newSettings.innerEndColor = (endInner == null) ? innerEndColor : endInner; - newSettings.outerStartColor = (startOuter == null) ? outerStartColor : startOuter; - newSettings.outerEndColor = (endOuter == null) ? outerEndColor : endOuter; - return newSettings; + private PatternRenderSettings copy(){ + PatternRenderSettings newSets = new PatternRenderSettings(fitAxis, baseScale, minWidth, minHeight, spaceWidth, spaceHeight, hPadding, vPadding, + hops, variance, speed, flowIrregular, readabilityOffset, lastSegmentLenProportion, innerWidthProvider, outerWidthProvider); + // add a UUID attached to the id (or our best guess, it doesn't really matter this is just to get a unique different id) + newSets.id = id.substring(0, Math.max(id.indexOf('_'), 0)) + "_" + UUID.randomUUID(); + return newSets; } public PatternRenderSettings withSizings(FitAxis fitAxis, Double spaceWidth, Double spaceHeight, Double hPadding, - Double vPadding, Double baseScale, Double minWidth, Double minHeight){ + Double vPadding, Double baseScale, Double minWidth, Double minHeight, + UnaryOperator innerWidthProvider, UnaryOperator outerWidthProvider){ PatternRenderSettings newSettings = copy(); newSettings.fitAxis = fitAxis == null ? this.fitAxis : fitAxis; newSettings.spaceWidth = spaceWidth == null ? this.spaceWidth : spaceWidth; @@ -90,6 +90,8 @@ public PatternRenderSettings withSizings(FitAxis fitAxis, Double spaceWidth, Dou newSettings.baseScale = baseScale == null ? this.baseScale : baseScale; newSettings.minWidth = minWidth == null ? this.minWidth : minWidth; newSettings.minHeight = minHeight == null ? this.minHeight : minHeight; + newSettings.innerWidthProvider = innerWidthProvider == null ? this.innerWidthProvider : innerWidthProvider; + newSettings.outerWidthProvider = outerWidthProvider == null ? this.outerWidthProvider : outerWidthProvider; return newSettings; } @@ -105,6 +107,12 @@ public PatternRenderSettings withZappySettings(Integer hops, Float variance, Flo return newSettings; } + public PatternRenderSettings named(String id){ + PatternRenderSettings newSettings = copy(); + newSettings.id = id; + return newSettings; + } + public enum FitAxis{ HOR(true, false), VERT(false, true), diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index 2a9ed14434..61e6711b46 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -2,18 +2,33 @@ import at.petrak.hexcasting.api.casting.math.HexPattern; +import at.petrak.hexcasting.mixin.accessor.client.AccessorLightTexturePixels; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.blaze3d.vertex.VertexConsumer; +import net.minecraft.client.Minecraft; +import net.minecraft.client.multiplayer.ClientLevel; import net.minecraft.client.renderer.GameRenderer; +import net.minecraft.client.renderer.LightTexture; +import net.minecraft.util.FastColor; import net.minecraft.world.phys.Vec2; +import javax.annotation.Nullable; import java.util.ArrayList; import java.util.List; import java.util.Set; public class PatternRenderer { - public static void renderPattern(HexPattern pattern, PoseStack ps, PatternRenderSettings patSets, double seed){ + public static void renderPattern(HexPattern pattern, PoseStack ps, PatternRenderSettings patSets, PatternColors patColors, double seed) { + renderPattern(pattern, ps, null, patSets, patColors, seed, null); + } + + public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable VertexConsumer vc, PatternRenderSettings patSets, PatternColors patColors, double seed, Integer light){ + if(patSets.speed == 0){ + // try doing texture rendering + } + var oldShader = RenderSystem.getShader(); RenderSystem.setShader(GameRenderer::getPositionColorShader); RenderSystem.enableDepthTest(); @@ -21,58 +36,34 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, PatternRender ps.pushPose(); - // Resolution is the number of sub-voxels in the block for rendering purposes, 16 is the default - // padding is the space to leave on the edges free of pattern -// int resolution = 16; -// int padding = resolution * PatternTextureManager.paddingByBlockSize / PatternTextureManager.resolutionByBlockSize; + HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); -// // and now Z is out? -// ps.translate(0, 0, -0.5); -// ps.scale(1f / resolution, 1f / resolution, 1f / resolution); -// ps.translate(0, 0, 1.01); + List zappyPattern; - List lines1 = pattern.toLines(1, Vec2.ZERO); - Set dupIndices = RenderLib.findDupIndices(pattern.positions()); - List zappyPattern = RenderLib.makeZappy(lines1, dupIndices, + if(patSets.speed == 0) { + // re-use our static points if we're rendering a static pattern anyway + zappyPattern = staticPoints.zappyPoints; + } else { + List lines1 = pattern.toLines(1, Vec2.ZERO); + Set dupIndices = RenderLib.findDupIndices(pattern.positions()); + zappyPattern = RenderLib.makeZappy(lines1, dupIndices, patSets.hops, patSets.variance, patSets.speed, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); - - // always do space calculations with the static version of the pattern - // so that it doesn't jump around resizing itself. - List zappyPatternSpace = RenderLib.makeZappy(lines1, dupIndices, - patSets.hops, patSets.variance, 0f, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); - - double minX = Double.MAX_VALUE, maxX = Double.MIN_VALUE, minY = Double.MAX_VALUE, maxY = Double.MIN_VALUE; - for (Vec2 point : zappyPatternSpace) - { - minX = Math.min(minX, point.x); - maxX = Math.max(maxX, point.x); - minY = Math.min(minY, point.y); - maxY = Math.max(maxY, point.y); } - double rangeX = maxX - minX; - double rangeY = maxY - minY; - - int patStepsX = (int)Math.round(rangeX / 1.5); - int patStepsY = (int)Math.round(rangeY / 1.7); - - /* - -- 2 up 1 across: rangeX: 1.7320507764816284 rangeY: 3.0 - -- flat, 3 across: rangeX: 5.196152210235596 rangeY: 0.06766534224152565 - -- single triangle: rangeX: 1.7320507764816284 rangeY: 1.5277782939374447 - */ -// HexAPI.LOGGER.info("rangeX: " + rangeX + " rangeY: " + rangeY); + int patStepsX = (int)Math.round(staticPoints.rangeX / 1.5); + int patStepsY = (int)Math.round(staticPoints.rangeY / 1.7); // scales the patterns so that each point is patSets.baseScale units apart double baseScale = patSets.baseScale / 1.5; // size of the pattern in pose space with no other adjustments - double baseWidth = rangeX * baseScale; - double baseHeight = rangeY * baseScale; + double baseWidth = staticPoints.rangeX * baseScale; + double baseHeight = staticPoints.rangeY * baseScale; // make sure that the scale fits within our min sizes double scale = Math.max(1.0, Math.max(patSets.minWidth / baseWidth, patSets.minHeight / baseHeight)); + // scale down if needed to fit in vertical space if(patSets.fitAxis.vertFit){ scale = Math.min(scale, (patSets.spaceHeight - 2 * patSets.vPadding)/(baseHeight)); @@ -83,51 +74,62 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, PatternRender scale = Math.min(scale, (patSets.spaceWidth - 2 * patSets.hPadding)/(baseWidth)); } -// -// double offsetX = ((- 2 * patSets.hPadding) - baseWidth * scale) / 2; -// double offsetY = ((- 2 * patSets.vPadding) - baseHeight * scale) / 2; + + // either the space given or however long it goes if it's not fitted. + double fullWidth = (baseWidth * scale) + 2 * patSets.hPadding; + double fullHeight = (baseHeight * scale) + 2 * patSets.vPadding; + + if(patSets.fitAxis.horFit) fullWidth = Math.max(patSets.spaceWidth, fullWidth); + if(patSets.fitAxis.vertFit) fullHeight = Math.max(patSets.spaceHeight, fullHeight); + + double offsetX = (fullWidth - baseWidth * scale) / 2; + double offsetY = (fullHeight - baseHeight * scale) / 2; List zappyRenderSpace = new ArrayList<>(); for (Vec2 point : zappyPattern) { zappyRenderSpace.add(new Vec2( - (float) (((point.x - minX) * baseScale * scale) + patSets.hPadding), - (float) (((point.y - minY) * baseScale * scale) + patSets.vPadding) + (float) (((point.x - staticPoints.minX) * baseScale * scale) + offsetX), + (float) (((point.y - staticPoints.minY) * baseScale * scale) + offsetY) )); } - RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, 1f, 0f, patSets.getOuterEndColor(), patSets.getOuterStartColor()); - RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, 1f, 0.01f, patSets.getInnerEndColor(), patSets.getInnerStartColor()); - - ps.popPose(); - RenderSystem.enableCull(); - RenderSystem.setShader(() -> oldShader); - } - - // TODO: make this not be duplicate code / figure out how to integrate it with render function / maybe cache some bits - public static double getPatternWHRatio(HexPattern pattern, PatternRenderSettings patSets, double seed){ - List lines1 = pattern.toLines(1, Vec2.ZERO); - Set dupIndices = RenderLib.findDupIndices(pattern.positions()); - List zappyPattern = RenderLib.makeZappy(lines1, dupIndices, - patSets.hops, patSets.variance, patSets.speed, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); - // always do space calculations with the static version of the pattern - // so that it doesn't jump around resizing itself. - List zappyPatternSpace = RenderLib.makeZappy(lines1, dupIndices, - patSets.hops, patSets.variance, 0f, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); - - double minX = Double.MAX_VALUE, maxX = Double.MIN_VALUE, minY = Double.MAX_VALUE, maxY = Double.MIN_VALUE; - for (Vec2 point : zappyPatternSpace) - { - minX = Math.min(minX, point.x); - maxX = Math.max(maxX, point.x); - minY = Math.min(minY, point.y); - maxY = Math.max(maxY, point.y); + // TODO: tweak this to suck less or rewrite drawLineSeq to support light -- they're yellow?? in dark lighting?? + if(light != null){ + ClientLevel cLevel = Minecraft.getInstance().level; +// float blockBrightness = LightTexture.getBrightness(cLevel.dimensionType(), LightTexture.block(light)); +// float skyBlockBrightness = LightTexture.getBrightness(cLevel.dimensionType(), LightTexture.sky(light)); +// float skyBrightness = cLevel.getSkyDarken(Minecraft.getInstance().getFrameTime()); + +// float brightness = (float)Math.min(1.0,((skyBrightness * skyBlockBrightness) + blockBrightness) / 1.5); + // get brightness straight from the texture. + int bri = ((AccessorLightTexturePixels)Minecraft.getInstance().gameRenderer.lightTexture()).getLightPixels().getPixelRGBA( + LightTexture.block(light), LightTexture.sky(light)); + RenderSystem.setShaderColor( + FastColor.ARGB32.red(bri)/255f, + FastColor.ARGB32.red(bri)/255f, + FastColor.ARGB32.red(bri)/255f, + 1f); } - double rangeX = maxX - minX; - double rangeY = maxY - minY; - return rangeX/rangeY; + RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(scale * baseScale)), 0.005f, patColors.outerEndColor, patColors.outerStartColor); + RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.innerWidthProvider.apply((float)(scale * baseScale)), 0f, patColors.innerEndColor, patColors.innerStartColor); + // 2D -- supports gradient stroke (goes through tessellator) +// if(vc == null){ +// } else { // 3D -- goes through vc, supports lighting -- kinda +// ps.mulPoseMatrix(new Matrix4f().scaling(-1.0f, 1.0f, 1.0f)); +// ps.pushPose(); +// ps.translate(0, 0, 0.005f); +// TheCoolerRenderLib.theCoolerDrawLineSeq(ps.last().pose(), ps.last().normal(), light, vc, zappyRenderSpace, patSets.outerWidthProvider.apply((float)(scale * baseScale)), patColors.outerStartColor); +// ps.popPose(); +// TheCoolerRenderLib.theCoolerDrawLineSeq(ps.last().pose(), ps.last().normal(), light, vc, zappyRenderSpace, patSets.innerWidthProvider.apply((float)(scale * baseScale)), patColors.innerStartColor); +// } + + ps.popPose(); +// RenderSystem.enableCull(); + RenderSystem.setShaderColor(1f, 1f, 1f, 1f); + RenderSystem.setShader(() -> oldShader); } } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java index 0a86bcf200..bbb12475d6 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java @@ -1,6 +1,8 @@ package at.petrak.hexcasting.client.render; +import at.petrak.hexcasting.api.casting.math.HexPattern; import com.mojang.blaze3d.platform.NativeImage; +import com.mojang.blaze3d.vertex.PoseStack; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.texture.DynamicTexture; import net.minecraft.resources.ResourceLocation; @@ -9,8 +11,8 @@ import java.awt.*; import java.awt.image.BufferedImage; -import java.util.HashMap; import java.util.List; +import java.util.*; import java.util.concurrent.*; import java.util.stream.Collectors; @@ -53,82 +55,104 @@ public static String getPointsKey(List zappyPoints) .collect(Collectors.joining(";")); } - public static ResourceLocation getTexture(List points, String pointsKey, int blockSize, boolean showsStrokeOrder, float lineWidth, boolean useFullSize, Color innerColor, Color outerColor) { - if (patternTexturesToAdd.containsKey(pointsKey)) { - var patternTexture = patternTexturesToAdd.remove(pointsKey); - var oldPatternTexture = patternTextures.put(pointsKey, patternTexture); + public static Optional getTexture(HexPattern pattern, PoseStack ps, PatternRenderSettings patSets, PatternColors patColors, double seed, boolean innerOrOuter) { +// public static ResourceLocation getTexture(List points, String pointsKey, int blockSize, boolean showsStrokeOrder, float lineWidth, boolean useFullSize, Color innerColor, Color outerColor) { + String patCacheKey = patSets.getCacheKey(pattern, seed) + (innerOrOuter ? "_inner" : "_outer"); + + // move textures from concurrent map to normal hashmap as needed + if (patternTexturesToAdd.containsKey(patCacheKey)) { + var patternTexture = patternTexturesToAdd.remove(patCacheKey); + var oldPatternTexture = patternTextures.put(patCacheKey, patternTexture); if (oldPatternTexture != null) Minecraft.getInstance().getTextureManager().getTexture(oldPatternTexture).close(); - return patternTexture; + return Optional.of(patternTexture); } - if (patternTextures.containsKey(pointsKey)) - return patternTextures.get(pointsKey); + if (patternTextures.containsKey(patCacheKey)) + return Optional.of(patternTextures.get(patCacheKey)); // render a higher-resolution texture in a background thread so it eventually becomes all nice nice and pretty executor.submit(() -> { - var slowTexture = createTexture(points, blockSize, showsStrokeOrder, lineWidth, useFullSize, innerColor, outerColor, false); + var slowTextures = createTextures(pattern, patSets, seed, false); // TextureManager#register doesn't look very thread-safe, so move back to the main thread after the slow part is done - Minecraft.getInstance().execute(() -> registerTexture(points, pointsKey, slowTexture, true)); + Minecraft.getInstance().execute(() -> { + for(Map.Entry textureEntry : slowTextures.entrySet()){ + registerTexture(patCacheKey + "_" + textureEntry.getKey(), textureEntry.getValue(), true); + } + }); }); - - // quickly create and cache a low-resolution texture so the client has something to look at - var fastTexture = createTexture(points, blockSize, showsStrokeOrder, lineWidth, useFullSize, innerColor, outerColor, true); - return registerTexture(points, pointsKey, fastTexture, false); + return Optional.empty(); } - private static DynamicTexture createTexture(List points, int blockSize, boolean showsStrokeOrder, float lineWidth, boolean useFullSize, Color innerColor, Color outerColor, boolean fastRender) + private static Map createTextures(HexPattern pattern, PatternRenderSettings patSets, double seed, boolean fastRender) +// private static DynamicTexture createTexture(List points, int blockSize, boolean showsStrokeOrder, float lineWidth, boolean useFullSize, Color innerColor, Color outerColor, boolean fastRender) { - int resolution = resolutionByBlockSize * blockSize; - int padding = paddingByBlockSize * blockSize; +// int resolution = resolutionByBlockSize * blockSize; +// int padding = paddingByBlockSize * blockSize; + + int resolution = resolutionByBlockSize; + int padding = paddingByBlockSize; if (fastRender) { resolution /= fastRenderScaleFactor; padding /= fastRenderScaleFactor; - lineWidth /= (float)fastRenderScaleFactor; +// lineWidth /= (float)fastRenderScaleFactor; } - double minX = Double.MAX_VALUE, maxX = Double.MIN_VALUE, minY = Double.MAX_VALUE, maxY = Double.MIN_VALUE; - for (Vec2 point : points) - { - minX = Math.min(minX, point.x); - maxX = Math.max(maxX, point.x); - minY = Math.min(minY, point.y); - maxY = Math.max(maxY, point.y); + HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); + + double baseScale = patSets.baseScale / 1.5; + + // size of the pattern in pose space with no other adjustments + double baseWidth = staticPoints.rangeX * baseScale; + double baseHeight = staticPoints.rangeY * baseScale; + + // make sure that the scale fits within our min sizes + double scale = Math.max(1.0, Math.max(patSets.minWidth / baseWidth, patSets.minHeight / baseHeight)); + + // scale down if needed to fit in vertical space + if(patSets.fitAxis.vertFit){ + scale = Math.min(scale, (patSets.spaceHeight - 2 * patSets.vPadding)/(baseHeight)); } - double rangeX = maxX - minX; - double rangeY = maxY - minY; + // scale down if needed to fit in horizontal space + if(patSets.fitAxis.horFit){ + scale = Math.min(scale, (patSets.spaceWidth - 2 * patSets.hPadding)/(baseWidth)); + } - double scale = Math.min((resolution - 2 * padding) / rangeX, (resolution - 2 * padding) / rangeY); + List zappyRenderSpace = new ArrayList<>(); - double limit = blockSize * scaleLimit; - if (!useFullSize && scale > limit) - scale = limit; + for (Vec2 point : staticPoints.zappyPoints) { + zappyRenderSpace.add(new Vec2( + (float) (((point.x - staticPoints.minX) * baseScale * scale) + patSets.hPadding), + (float) (((point.y - staticPoints.minY) * baseScale * scale) + patSets.vPadding) + )); + } - double offsetX = ((resolution - 2 * padding) - rangeX * scale) / 2; - double offsetY = ((resolution - 2 * padding) - rangeY * scale) / 2; +// +// double offsetX = ((resolution - 2 * padding) - rangeX * scale) / 2; +// double offsetY = ((resolution - 2 * padding) - rangeY * scale) / 2; BufferedImage img = new BufferedImage(resolution, resolution, BufferedImage.TYPE_INT_ARGB); Graphics2D g2d = img.createGraphics(); g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); - g2d.setColor(outerColor); - g2d.setStroke(new BasicStroke((blockSize * 5f / 3f) * lineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); - drawLines(g2d, points, minX, minY, scale, offsetX, offsetY, padding); - - g2d.setColor(innerColor); - g2d.setStroke(new BasicStroke((blockSize * 2f / 3f) * lineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); - drawLines(g2d, points, minX, minY, scale, offsetX, offsetY, padding); - - - if (showsStrokeOrder) { - g2d.setColor(new Color(0xff_d77b5b)); - Tuple point = getTextureCoordinates(points.get(0), minX, minY, scale, offsetX, offsetY, padding); - int spotRadius = circleRadiusByBlockSize * blockSize; - drawHexagon(g2d, point.getA(), point.getB(), spotRadius); - } +// g2d.setColor(outerColor); +// g2d.setStroke(new BasicStroke((blockSize * 5f / 3f) * lineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); +// drawLines(g2d, points, minX, minY, scale, offsetX, offsetY, padding); +// +// g2d.setColor(innerColor); +// g2d.setStroke(new BasicStroke((blockSize * 2f / 3f) * lineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); +// drawLines(g2d, points, minX, minY, scale, offsetX, offsetY, padding); +// +// +// if (showsStrokeOrder) { +// g2d.setColor(new Color(0xff_d77b5b)); +// Tuple point = getTextureCoordinates(points.get(0), minX, minY, scale, offsetX, offsetY, padding); +// int spotRadius = circleRadiusByBlockSize * blockSize; +// drawHexagon(g2d, point.getA(), point.getB(), spotRadius); +// } g2d.dispose(); @@ -137,16 +161,16 @@ private static DynamicTexture createTexture(List points, int blockSize, bo for (int x = 0; x < img.getWidth(); x++) nativeImage.setPixelRGBA(x, y, img.getRGB(x, y)); - return new DynamicTexture(nativeImage); + return new HashMap<>(); // temporary } - private static ResourceLocation registerTexture(List points, String pointsKey, DynamicTexture dynamicTexture, boolean isSlow) { + private static ResourceLocation registerTexture(String patTextureKey, DynamicTexture dynamicTexture, boolean isSlow) { // isSlow used to register different textures for the low-resolution, fastly rendered version of each texture // and the high-resolution, slowly rendered version (this means the slow doesn't replace the fast in the texture manager, // which causes occasional visual stuttering for a frame). - String name = "hex_pattern_texture_" + points.hashCode() + "_" + repaintIndex + "_" + (isSlow ? "slow" : "fast") + ".png"; + String name = "hex_pattern_texture_" + patTextureKey + "_" + repaintIndex + "_" + (isSlow ? "slow" : "fast") + ".png"; ResourceLocation resourceLocation = Minecraft.getInstance().getTextureManager().register(name, dynamicTexture); - patternTexturesToAdd.put(pointsKey, resourceLocation); + patternTexturesToAdd.put(patTextureKey, resourceLocation); return resourceLocation; } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/TheCoolerRenderLib.java b/Common/src/main/java/at/petrak/hexcasting/client/render/TheCoolerRenderLib.java new file mode 100644 index 0000000000..dc78179aad --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/TheCoolerRenderLib.java @@ -0,0 +1,155 @@ +package at.petrak.hexcasting.client.render; + +import com.mojang.blaze3d.vertex.VertexConsumer; +import net.minecraft.client.renderer.texture.OverlayTexture; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.util.Mth; +import net.minecraft.world.phys.Vec2; +import org.joml.Matrix3f; +import org.joml.Matrix4f; + +import java.util.List; + +import static at.petrak.hexcasting.api.HexAPI.modLoc; + +/** + * Entity/quad based render functions. Should probably be in RenderLib, but I don't want to rewrite to kotlin rn. + */ +public class TheCoolerRenderLib { + + public static final ResourceLocation WHITE = modLoc("textures/entity/white.png"); + + private static void vertexCol(Matrix4f mat, Matrix3f normal, int light, VertexConsumer verts, int col, Vec2 pos) { + verts.vertex(mat, -pos.x, pos.y, 0) + .color(col) + .uv(0, 0).overlayCoords(OverlayTexture.NO_OVERLAY).uv2(light) + .normal(normal, 0, 0, 1) + .endVertex(); + } + + public static void theCoolerDrawLineSeq(Matrix4f mat, Matrix3f normalMat, int light, VertexConsumer verts, + List points, float width, int color + ) { + if (points.size() <= 1) { + return; + } + + // TODO: abstract some of this out with RenderLib to stop WET code + var joinAngles = new float[points.size()]; + var joinOffsets = new float[points.size()]; + for (int i = 2; i < points.size(); i++) { + var p0 = points.get(i - 2); + var p1 = points.get(i - 1); + var p2 = points.get(i); + var prev = p1.add(p0.negated()); + var next = p2.add(p1.negated()); + var angle = (float) Mth.atan2( + prev.x * next.y - prev.y * next.x, + prev.x * next.x + prev.y * next.y); + joinAngles[i - 1] = angle; + var clamp = Math.min(prev.length(), next.length()) / (width * 0.5f); + joinOffsets[i - 1] = Mth.clamp(Mth.sin(angle) / (1 + Mth.cos(angle)), -clamp, clamp); + } + + for (var i = 0; i < points.size() - 1; i++) { + var p1 = points.get(i); + var p2 = points.get(i + 1); + + var tangent = p2.add(p1.negated()).normalized().scale(width * 0.5f); + var normal = new Vec2(-tangent.y, tangent.x); + + var jlow = joinOffsets[i]; + var jhigh = joinOffsets[i + 1]; + + var p1Down = p1.add(tangent.scale(Math.max(0f, jlow))).add(normal); + var p1Up = p1.add(tangent.scale(Math.max(0f, -jlow))).add(normal.negated()); + var p2Down = p2.add(tangent.scale(Math.max(0f, jhigh)).negated()).add(normal); + var p2Up = p2.add(tangent.scale(Math.max(0f, -jhigh)).negated()).add(normal.negated()); + + // Draw the chamfer hexagon as two trapezoids + // the points are in different orders to keep clockwise + vertexCol(mat, normalMat, light, verts, color, p1); + vertexCol(mat, normalMat, light, verts, color, p2); + vertexCol(mat, normalMat, light, verts, color, p2Up); + vertexCol(mat, normalMat, light, verts, color, p1Up); + + vertexCol(mat, normalMat, light, verts, color, p1); + vertexCol(mat, normalMat, light, verts, color, p1Down); + vertexCol(mat, normalMat, light, verts, color, p2Down); + vertexCol(mat, normalMat, light, verts, color, p2); + + if (i > 0) { + var sangle = joinAngles[i]; + var angle = Math.abs(sangle); + var rnormal = normal.negated(); + var joinSteps = Mth.ceil(angle * 180 / (RenderLib.CAP_THETA * Mth.PI)); + if (joinSteps < 1) continue; + + if (sangle < 0) { + var prevVert = new Vec2(p1.x - rnormal.x, p1.y - rnormal.y); + for (var j = 1; j <= joinSteps; j++) { + var fan = RenderLib.rotate(rnormal, -sangle * ((float) j / joinSteps)); + var fanShift = new Vec2(p1.x - fan.x, p1.y - fan.y); + + vertexCol(mat, normalMat, light, verts, color, p1); + vertexCol(mat, normalMat, light, verts, color, p1); + vertexCol(mat, normalMat, light, verts, color, fanShift); + vertexCol(mat, normalMat, light, verts, color, prevVert); + prevVert = fanShift; + } + } else { + var startFan = RenderLib.rotate(normal, -sangle); + var prevVert = new Vec2(p1.x - startFan.x, p1.y - startFan.y); + for (var j = joinSteps - 1; j >= 0; j--) { + var fan = RenderLib.rotate(normal, -sangle * ((float) j / joinSteps)); + var fanShift = new Vec2(p1.x - fan.x, p1.y - fan.y); + + vertexCol(mat, normalMat, light, verts, color, p1); + vertexCol(mat, normalMat, light, verts, color, p1); + vertexCol(mat, normalMat, light, verts, color, fanShift); + vertexCol(mat, normalMat, light, verts, color, prevVert); + prevVert = fanShift; + } + } + } + } + + for (var pair : new Vec2[][]{ + {points.get(0), points.get(1)}, + {points.get(points.size() - 1), points.get(points.size() - 2)} + }) { + var point = pair[0]; + var prev = pair[1]; + + var tangent = point.add(prev.negated()).normalized().scale(0.5f * width); + var normal = new Vec2(-tangent.y, tangent.x); + var joinSteps = Mth.ceil(180f / RenderLib.CAP_THETA); + for (int j = joinSteps; j > 0; j--) { + var fan0 = RenderLib.rotate(normal, -Mth.PI * ((float) j / joinSteps)); + var fan1 = RenderLib.rotate(normal, -Mth.PI * ((float) (j - 1) / joinSteps)); + + vertexCol(mat, normalMat, light, verts, color, point); + vertexCol(mat, normalMat, light, verts, color, point); + vertexCol(mat, normalMat, light, verts, color, point.add(fan1)); + vertexCol(mat, normalMat, light, verts, color, point.add(fan0)); + } + } + } + + public static void theCoolerDrawSpot(Matrix4f mat, Matrix3f normal, int light, VertexConsumer verts, + Vec2 point, float radius, int color) { + var fracOfCircle = 6; + for (int i = 0; i < fracOfCircle; i++) { + // We do need rects, irritatingly + // so we do fake triangles + vertexCol(mat, normal, light, verts, color, point); + vertexCol(mat, normal, light, verts, color, point); + for (int j = 0; j <= 1; j++) { + var theta = (i - j) / (float) fracOfCircle * Mth.TWO_PI; + var rx = Mth.cos(theta) * radius + point.x; + var ry = Mth.sin(theta) * radius + point.y; + vertexCol(mat, normal, light, verts, color, new Vec2(rx, ry)); + } + } + } +} diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index a86a0962cf..fad069fda7 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -6,61 +6,72 @@ import at.petrak.hexcasting.common.blocks.akashic.BlockEntityAkashicBookshelf; import at.petrak.hexcasting.common.blocks.circles.BlockEntitySlate; import at.petrak.hexcasting.common.blocks.circles.BlockSlate; +import at.petrak.hexcasting.common.entities.EntityWallScroll; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.PoseStack; import com.mojang.blaze3d.vertex.VertexConsumer; import com.mojang.math.Axis; import net.minecraft.client.renderer.GameRenderer; +import net.minecraft.client.renderer.LightTexture; import net.minecraft.client.renderer.MultiBufferSource; import net.minecraft.client.renderer.RenderType; import net.minecraft.client.renderer.texture.OverlayTexture; -import net.minecraft.resources.ResourceLocation; import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.block.state.properties.AttachFace; -import net.minecraft.world.phys.Vec2; import net.minecraft.world.phys.Vec3; import org.joml.Matrix3f; import org.joml.Matrix4f; -import java.awt.*; -import java.util.List; - /** * Helper methods for rendering patterns in the world. */ public class WorldlyPatternRenderHelpers { - public static void renderPatternForScroll(String pointsKey, PoseStack ps, MultiBufferSource bufSource, int light, List zappyPoints, int blockSize, boolean showStrokeOrder) + + public static final PatternRenderSettings WORLDLY_RENDER_SETTINGS = new PatternRenderSettings() + .withSizings(PatternRenderSettings.FitAxis.BOTH, 1.0, 1.0, 1.0/16, 1.0/16, 0.25, null, null, + (scale) -> 0.4f/16, (scale) -> 0.8f/16) + .named("worldly"); + + public static final PatternRenderSettings SCROLL_RENDER_SETTINGS = WORLDLY_RENDER_SETTINGS.withSizings(null, null, null, + 2.0/16, 2.0/16, null, null, null, null, null) + .named("wallscroll"); + + public static final PatternRenderSettings READABLE_SCROLL_RENDER_SETTINGS = SCROLL_RENDER_SETTINGS.withZappySettings( + null, null, null, null, RenderLib.DEFAULT_READABILITY_OFFSET, RenderLib.DEFAULT_LAST_SEGMENT_LEN_PROP + ) + .named("wallscroll_readable"); + + public static final PatternColors DEFAULT_PATTERN_COLOR = new PatternColors(0xc8_322b33, 0xff_d2c8c8); + + public static void renderPatternForScroll(HexPattern pattern, EntityWallScroll scroll, PoseStack ps, MultiBufferSource bufSource, int light, int blockSize, boolean showStrokeOrder) { - renderPattern(pointsKey, ps, bufSource, light, zappyPoints, blockSize, showStrokeOrder, false, true, false,false, true,-1); + ps.pushPose(); + renderPattern(pattern, showStrokeOrder ? READABLE_SCROLL_RENDER_SETTINGS : SCROLL_RENDER_SETTINGS, DEFAULT_PATTERN_COLOR, scroll.getPos().hashCode(), ps, bufSource, light, blockSize, true, false,false, true,-1); + ps.popPose(); } public static void renderPatternForSlate(BlockEntitySlate tile, HexPattern pattern, PoseStack ps, MultiBufferSource buffer, int light, BlockState bs) { - if(tile.points == null) - tile.points = generateHexPatternPoints(tile, pattern, 0.2f); boolean isOnWall = bs.getValue(BlockSlate.ATTACH_FACE) == AttachFace.WALL; boolean isOnCeiling = bs.getValue(BlockSlate.ATTACH_FACE) == AttachFace.CEILING; int facing = bs.getValue(BlockSlate.FACING).get2DDataValue(); - renderPatternForBlockEntity(tile.points, ps, buffer, light, isOnWall, isOnCeiling, true, facing); + renderPatternForBlockEntity(pattern, tile, ps, buffer, light, isOnWall, isOnCeiling, true, facing); } public static void renderPatternForAkashicBookshelf(BlockEntityAkashicBookshelf tile, HexPattern pattern, PoseStack ps, MultiBufferSource buffer, int light, BlockState bs) { - if(tile.points == null) - tile.points = generateHexPatternPoints(tile, pattern, 0f); - int facing = bs.getValue(BlockAkashicBookshelf.FACING).get2DDataValue(); - renderPatternForBlockEntity(tile.points, ps, buffer, light, true, false, false, facing); + renderPatternForBlockEntity(pattern, tile, ps, buffer, LightTexture.FULL_BRIGHT, true, false, false, facing); } - public static void renderPatternForBlockEntity(HexPatternPoints points, PoseStack ps, MultiBufferSource buffer, int light, boolean isOnWall, boolean isOnCeiling, boolean isSlate, int facing) + public static void renderPatternForBlockEntity(HexPattern pattern, HexBlockEntity tile, PoseStack ps, MultiBufferSource buffer, int light, boolean isOnWall, boolean isOnCeiling, boolean isSlate, int facing) { var oldShader = RenderSystem.getShader(); ps.pushPose(); RenderSystem.setShader(GameRenderer::getPositionTexShader); - renderPattern(points.pointsKey, ps, buffer, light, points.zappyPoints, 1, false, true, isOnWall, isOnCeiling, isSlate, false, facing); + renderPattern(pattern, WORLDLY_RENDER_SETTINGS, DEFAULT_PATTERN_COLOR, tile.getBlockPos().hashCode(), ps, buffer, light, 1, isOnWall, isOnCeiling, isSlate, false, facing); ps.popPose(); RenderSystem.setShader(() -> oldShader); } @@ -70,7 +81,7 @@ public static void renderPatternForBlockEntity(HexPatternPoints points, PoseStac /** * Renders a pattern in world space based on the given transform requirements */ - public static void renderPattern(String pointsKey, PoseStack ps, MultiBufferSource bufSource, int light, List zappyPoints, int blockSize, boolean showStrokeOrder, boolean useFullSize, boolean isOnWall, boolean isOnCeiling, boolean isSlate, boolean isScroll, int facing) + public static void renderPattern(HexPattern pattern, PatternRenderSettings patSets, PatternColors patColors, double seed, PoseStack ps, MultiBufferSource bufSource, int light, int blockSize, boolean isOnWall, boolean isOnCeiling, boolean isSlate, boolean isScroll, int facing) { ps.pushPose(); @@ -98,7 +109,7 @@ public static void renderPattern(String pointsKey, PoseStack ps, MultiBufferSour else { transformer = wallBlockTransformer; - z = -0.01f; + z = -0.02f; } } } @@ -112,33 +123,40 @@ public static void renderPattern(String pointsKey, PoseStack ps, MultiBufferSour ny = (float)nVec.y(); nz = (float)nVec.z(); + ps.scale(blockSize, blockSize, 1); + int lineWidth = PatternTextureManager.otherLineWidth; int outerColor = 0xff_d2c8c8; int innerColor = 0xc8_322b33; if(isScroll) lineWidth = PatternTextureManager.scrollLineWidth; - ResourceLocation texture = PatternTextureManager.getTexture(zappyPoints, pointsKey, blockSize, showStrokeOrder, lineWidth, useFullSize, new Color(innerColor), new Color(outerColor)); - VertexConsumer verts = bufSource.getBuffer(RenderType.entityCutout(texture)); +// ps.scale(x, y, z); + ps.translate(0,0, z); + VertexConsumer verts = bufSource.getBuffer(RenderType.entityCutout(TheCoolerRenderLib.WHITE)); + PatternRenderer.renderPattern(pattern, ps, verts, patSets, patColors, seed, light); - vertex(mat, normal, light, verts, 0, 0, z, 0, 0, nx, ny, nz); - vertex(mat, normal, light, verts, 0, y, z, 0, 1, nx, ny, nz); - vertex(mat, normal, light, verts, x, y, z, 1, 1, nx, ny, nz); - vertex(mat, normal, light, verts, x, 0, z, 1, 0, nx, ny, nz); +// ResourceLocation texture = PatternTextureManager.getTexture(zappyPoints, pointsKey, blockSize, showStrokeOrder, lineWidth, useFullSize, new Color(innerColor), new Color(outerColor)); +// VertexConsumer verts = bufSource.getBuffer(RenderType.entityCutout(texture)); +// +// vertex(mat, normal, light, verts, 0, 0, z, 0, 0, nx, ny, nz); +// vertex(mat, normal, light, verts, 0, y, z, 0, 1, nx, ny, nz); +// vertex(mat, normal, light, verts, x, y, z, 1, 1, nx, ny, nz); +// vertex(mat, normal, light, verts, x, 0, z, 1, 0, nx, ny, nz); ps.popPose(); } - public static HexPatternPoints generateHexPatternPoints(HexBlockEntity tile, HexPattern pattern, float flowIrregular) - { - var stupidHash = tile.getBlockPos().hashCode(); - var lines1 = pattern.toLines(1, Vec2.ZERO); - var zappyPoints = RenderLib.makeZappy(lines1, RenderLib.findDupIndices(pattern.positions()), - 10, 0.5f, 0f, flowIrregular, 0f, 1f, stupidHash); - return new HexPatternPoints(zappyPoints); - } +// public static HexPatternPoints generateHexPatternPoints(HexBlockEntity tile, HexPattern pattern, float flowIrregular) +// { +// var stupidHash = tile.getBlockPos().hashCode(); +// var lines1 = pattern.toLines(1, Vec2.ZERO); +// var zappyPoints = RenderLib.makeZappy(lines1, RenderLib.findDupIndices(pattern.positions()), +// 10, 0.5f, 0f, flowIrregular, 0f, 1f, stupidHash); +// return new HexPatternPoints(zappyPoints); +// } private static void vertex(Matrix4f mat, Matrix3f normal, int light, VertexConsumer verts, float x, float y, float z, float u, float v, float nx, float ny, float nz) { diff --git a/Common/src/main/java/at/petrak/hexcasting/common/blocks/circles/BlockEntitySlate.java b/Common/src/main/java/at/petrak/hexcasting/common/blocks/circles/BlockEntitySlate.java index 63489e8c0e..9a0ec965bc 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/blocks/circles/BlockEntitySlate.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/blocks/circles/BlockEntitySlate.java @@ -2,7 +2,6 @@ import at.petrak.hexcasting.api.block.HexBlockEntity; import at.petrak.hexcasting.api.casting.math.HexPattern; -import at.petrak.hexcasting.client.render.HexPatternPoints; import at.petrak.hexcasting.common.lib.HexBlockEntities; import net.minecraft.core.BlockPos; import net.minecraft.nbt.CompoundTag; @@ -15,7 +14,6 @@ public class BlockEntitySlate extends HexBlockEntity { @Nullable public HexPattern pattern; - public HexPatternPoints points; public BlockEntitySlate(BlockPos pos, BlockState state) { super(HexBlockEntities.SLATE_TILE, pos, state); diff --git a/Common/src/main/java/at/petrak/hexcasting/common/entities/EntityWallScroll.java b/Common/src/main/java/at/petrak/hexcasting/common/entities/EntityWallScroll.java index cd9ab651cb..a4f1f38047 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/entities/EntityWallScroll.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/entities/EntityWallScroll.java @@ -3,8 +3,6 @@ import at.petrak.hexcasting.api.casting.math.HexPattern; import at.petrak.hexcasting.api.utils.HexUtils; import at.petrak.hexcasting.api.utils.NBTHelper; -import at.petrak.hexcasting.client.render.HexPatternPoints; -import at.petrak.hexcasting.client.render.RenderLib; import at.petrak.hexcasting.common.items.storage.ItemScroll; import at.petrak.hexcasting.common.lib.HexItems; import at.petrak.hexcasting.common.lib.HexSounds; @@ -32,12 +30,9 @@ import net.minecraft.world.item.ItemStack; import net.minecraft.world.level.GameRules; import net.minecraft.world.level.Level; -import net.minecraft.world.phys.Vec2; import net.minecraft.world.phys.Vec3; import org.jetbrains.annotations.Nullable; -import java.util.List; - public class EntityWallScroll extends HangingEntity { private static final EntityDataAccessor SHOWS_STROKE_ORDER = SynchedEntityData.defineId( EntityWallScroll.class, @@ -48,9 +43,6 @@ public class EntityWallScroll extends HangingEntity { public HexPattern pattern; public boolean isAncient; public int blockSize; - // Client-side only! - @Nullable - public HexPatternPoints points; public EntityWallScroll(EntityType type, Level world) { super(type, world); @@ -72,21 +64,21 @@ public void recalculateDisplay() { CompoundTag patternTag = NBTHelper.getCompound(scroll, ItemScroll.TAG_PATTERN); if (patternTag != null) { this.pattern = HexPattern.fromNBT(patternTag); - if (this.level().isClientSide) { - var pair = RenderLib.getCenteredPattern(pattern, 128f / 3 * blockSize, 128f / 3 * blockSize, - 16f / 3 * blockSize); - var dots = pair.getSecond(); - var readOffset = this.getShowsStrokeOrder() ? RenderLib.DEFAULT_READABILITY_OFFSET : 0f; - var lastProp = this.getShowsStrokeOrder() ? RenderLib.DEFAULT_LAST_SEGMENT_LEN_PROP : 1f; - var zappyPoints = RenderLib.makeZappy(dots, RenderLib.findDupIndices(pattern.positions()), 10, 0.4f, - 0f, 0f, readOffset, lastProp, this.getId()); - this.points = new HexPatternPoints(zappyPoints); - } +// if (this.level().isClientSide) { +// var pair = RenderLib.getCenteredPattern(pattern, 128f / 3 * blockSize, 128f / 3 * blockSize, +// 16f / 3 * blockSize); +// var dots = pair.getSecond(); +// var readOffset = this.getShowsStrokeOrder() ? RenderLib.DEFAULT_READABILITY_OFFSET : 0f; +// var lastProp = this.getShowsStrokeOrder() ? RenderLib.DEFAULT_LAST_SEGMENT_LEN_PROP : 1f; +// var zappyPoints = RenderLib.makeZappy(dots, RenderLib.findDupIndices(pattern.positions()), 10, 0.4f, +// 0f, 0f, readOffset, lastProp, this.getId()); +// this.points = new HexPatternPoints(zappyPoints); +// } this.isAncient = NBTHelper.hasString(scroll, ItemScroll.TAG_OP_ID); } else { this.pattern = null; - this.points = null; +// this.points = null; this.isAncient = false; } } diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index 73a54b4faf..7aa4eaba6d 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -1,5 +1,7 @@ package at.petrak.hexcasting.interop.inline; +import at.petrak.hexcasting.client.render.HexPatternPoints; +import at.petrak.hexcasting.client.render.PatternColors; import at.petrak.hexcasting.client.render.PatternRenderSettings; import at.petrak.hexcasting.client.render.PatternRenderer; import com.samsthenerd.inline.api.client.InlineRenderer; @@ -16,16 +18,22 @@ public ResourceLocation getId(){ } public static final PatternRenderSettings INLINE_RENDER_SETTINGS = new PatternRenderSettings() - .withSizings(PatternRenderSettings.FitAxis.VERT, 8.0, 8.0, 0.0, 0.0, 4.0, null, null) - .withColors(0xFF_FFFFFF, 0xFF_FFFFFF, null, null); + .withSizings(PatternRenderSettings.FitAxis.VERT, 8.0, 8.0, 0.0, 0.0, 4.0, null, null, + (scale) -> 0.5f, (scale) -> 1f) + .named("inline"); + + public static final PatternColors FLAT_WHITE_PATTERN_COLOR = new PatternColors(0xFF_FFFFFF); public int render(InlinePatternData data, GuiGraphics drawContext, int index, Style style, int codepoint, TextRenderingContext trContext){ - PatternRenderer.renderPattern(data.pattern, drawContext.pose(), INLINE_RENDER_SETTINGS, 0); + PatternRenderer.renderPattern(data.pattern, drawContext.pose(), INLINE_RENDER_SETTINGS, FLAT_WHITE_PATTERN_COLOR, 0); - return (int)(8 * PatternRenderer.getPatternWHRatio(data.pattern, INLINE_RENDER_SETTINGS, 0)); + HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(data.pattern, INLINE_RENDER_SETTINGS, 0); + return (int)Math.ceil(8.0 * staticPoints.rangeX / staticPoints.rangeY); } public int charWidth(InlinePatternData data, Style style, int codepoint){ - return (int)(8 * PatternRenderer.getPatternWHRatio(data.pattern, INLINE_RENDER_SETTINGS, 0)); + + HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(data.pattern, INLINE_RENDER_SETTINGS, 0); + return (int)Math.ceil(8.0 * staticPoints.rangeX / staticPoints.rangeY); } } diff --git a/Common/src/main/java/at/petrak/hexcasting/mixin/accessor/client/AccessorLightTexturePixels.java b/Common/src/main/java/at/petrak/hexcasting/mixin/accessor/client/AccessorLightTexturePixels.java new file mode 100644 index 0000000000..ab54cdcb1e --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/mixin/accessor/client/AccessorLightTexturePixels.java @@ -0,0 +1,12 @@ +package at.petrak.hexcasting.mixin.accessor.client; + +import com.mojang.blaze3d.platform.NativeImage; +import net.minecraft.client.renderer.LightTexture; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.gen.Accessor; + +@Mixin(LightTexture.class) +public interface AccessorLightTexturePixels { + @Accessor("lightPixels") + public NativeImage getLightPixels(); +} diff --git a/Common/src/main/resources/hexplat.mixins.json b/Common/src/main/resources/hexplat.mixins.json index 1d2ac13000..95624916bc 100644 --- a/Common/src/main/resources/hexplat.mixins.json +++ b/Common/src/main/resources/hexplat.mixins.json @@ -23,6 +23,7 @@ "accessor.client.AccessorBlockEntityRenderDispatcher", "accessor.client.AccessorCompositeRenderType", "accessor.client.AccessorEmptyTextureStateShard", + "accessor.client.AccessorLightTexturePixels", "accessor.client.AccessorMouseHandler", "accessor.client.AccessorRenderStateShard", "accessor.client.AccessorRenderType", From 50899de2022633a09587a80bf9164f85ca7d2e76 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Thu, 4 Jul 2024 01:53:09 -0400 Subject: [PATCH 10/48] inline-ify pattern's Display call for showing in the stack and whatnot --- .../hexcasting/api/casting/iota/ListIota.java | 5 ++++- .../hexcasting/api/casting/iota/PatternIota.java | 11 ++++++++--- .../hexcasting/client/render/PatternRenderer.java | 1 + .../interop/inline/InlinePatternData.java | 7 +++++++ .../interop/inline/InlinePatternRenderer.java | 13 ++++++++----- 5 files changed, 28 insertions(+), 9 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/ListIota.java b/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/ListIota.java index 255d54662f..251c4e161d 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/ListIota.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/ListIota.java @@ -107,7 +107,10 @@ public Component display(Tag tag) { out.append(IotaType.getDisplay(csub)); - if (i < list.size() - 1) { + // only add a comma between 2 non-patterns (commas don't look good with Inline patterns) + // TODO: maybe add a config? maybe add a method on IotaType to allow it to opt out of commas + if (i < list.size() - 1 && (IotaType.getTypeFromTag(csub) != PatternIota.TYPE + || IotaType.getTypeFromTag(HexUtils.downcast(list.get(i+1), CompoundTag.TYPE)) != PatternIota.TYPE)) { out.append(", "); } } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/PatternIota.java b/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/PatternIota.java index 6a3ec539d1..63131cee8c 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/PatternIota.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/PatternIota.java @@ -14,12 +14,12 @@ import at.petrak.hexcasting.api.casting.mishaps.MishapEvalTooMuch; import at.petrak.hexcasting.api.casting.mishaps.MishapInvalidPattern; import at.petrak.hexcasting.api.casting.mishaps.MishapUnenlightened; -import at.petrak.hexcasting.api.mod.HexConfig; import at.petrak.hexcasting.api.mod.HexTags; import at.petrak.hexcasting.api.utils.HexUtils; import at.petrak.hexcasting.common.casting.PatternRegistryManifest; import at.petrak.hexcasting.common.lib.hex.HexEvalSounds; import at.petrak.hexcasting.common.lib.hex.HexIotaTypes; +import at.petrak.hexcasting.interop.inline.InlinePatternData; import at.petrak.hexcasting.xplat.IXplatAbstractions; import net.minecraft.ChatFormatting; import net.minecraft.nbt.CompoundTag; @@ -162,6 +162,11 @@ public static PatternIota deserialize(Tag tag) throws IllegalArgumentException { } public static Component display(HexPattern pat) { + return (new InlinePatternData(pat)).asText(true); + } + + // keep around just in case it's needed. + public static Component displayNonInline(HexPattern pat){ var bob = new StringBuilder(); bob.append(pat.getStartDir()); @@ -171,7 +176,7 @@ public static Component display(HexPattern pat) { bob.append(sig); } return Component.translatable("hexcasting.tooltip.pattern_iota", - Component.literal(bob.toString()).withStyle(ChatFormatting.WHITE)) - .withStyle(ChatFormatting.GOLD); + Component.literal(bob.toString()).withStyle(ChatFormatting.WHITE)) + .withStyle(ChatFormatting.GOLD); } } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index 61e6711b46..f4a6b90864 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -116,6 +116,7 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Ver RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(scale * baseScale)), 0.005f, patColors.outerEndColor, patColors.outerStartColor); RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.innerWidthProvider.apply((float)(scale * baseScale)), 0f, patColors.innerEndColor, patColors.innerStartColor); + // TODO: probably want to have option to render little dots and stuff. // 2D -- supports gradient stroke (goes through tessellator) // if(vc == null){ // } else { // 3D -- goes through vc, supports lighting -- kinda diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java index 45bf77c6bb..48b4079e4a 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java @@ -6,6 +6,7 @@ import at.petrak.hexcasting.common.lib.HexItems; import com.mojang.serialization.Codec; import com.samsthenerd.inline.api.InlineData; +import net.minecraft.network.chat.Component; import net.minecraft.network.chat.HoverEvent; import net.minecraft.network.chat.Style; import net.minecraft.resources.ResourceLocation; @@ -33,6 +34,7 @@ public ResourceLocation getRendererId(){ return rendererId; } + @Override public Style getExtraStyle() { ItemStack scrollStack = new ItemStack(HexItems.SCROLL_MEDIUM); HexItems.SCROLL_MEDIUM.writeDatum(scrollStack, new PatternIota(pattern)); @@ -41,6 +43,11 @@ public Style getExtraStyle() { return Style.EMPTY.withHoverEvent(he); } + @Override + public Component asText(boolean withExtra) { + return Component.literal(pattern.toString()).withStyle(asStyle(withExtra)); + } + public static class InlinePatternDataType implements InlineDataType { private static final ResourceLocation ID = new ResourceLocation(HexAPI.MOD_ID, "pattern"); public static final InlinePatternDataType INSTANCE = new InlinePatternDataType(); diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index 7aa4eaba6d..712433a84b 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -18,8 +18,8 @@ public ResourceLocation getId(){ } public static final PatternRenderSettings INLINE_RENDER_SETTINGS = new PatternRenderSettings() - .withSizings(PatternRenderSettings.FitAxis.VERT, 8.0, 8.0, 0.0, 0.0, 4.0, null, null, - (scale) -> 0.5f, (scale) -> 1f) + .withSizings(PatternRenderSettings.FitAxis.VERT, 8.0, 8.0, 1.0, 0.0, 4.0, null, null, + (scale) -> 1f, null) .named("inline"); public static final PatternColors FLAT_WHITE_PATTERN_COLOR = new PatternColors(0xFF_FFFFFF); @@ -27,13 +27,16 @@ public ResourceLocation getId(){ public int render(InlinePatternData data, GuiGraphics drawContext, int index, Style style, int codepoint, TextRenderingContext trContext){ PatternRenderer.renderPattern(data.pattern, drawContext.pose(), INLINE_RENDER_SETTINGS, FLAT_WHITE_PATTERN_COLOR, 0); - HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(data.pattern, INLINE_RENDER_SETTINGS, 0); - return (int)Math.ceil(8.0 * staticPoints.rangeX / staticPoints.rangeY); + return charWidth(data, style, codepoint); } public int charWidth(InlinePatternData data, Style style, int codepoint){ HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(data.pattern, INLINE_RENDER_SETTINGS, 0); - return (int)Math.ceil(8.0 * staticPoints.rangeX / staticPoints.rangeY); + + double baseScale = 4.0 / 1.5; + double baseHeight = staticPoints.rangeY * baseScale; + + return (int)Math.round(0.2 + Math.min(baseHeight, 8.0) * staticPoints.rangeX / staticPoints.rangeY) + 2; // (+2 for padding) } } From f791a11d79bd07824aca2f9e716338fdfe886e66 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Mon, 8 Jul 2024 13:12:06 -0400 Subject: [PATCH 11/48] idk why that folder exists but let's git ignore it! --- .gitignore | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.gitignore b/.gitignore index 2da9d42dbf..dc8ca90ac5 100644 --- a/.gitignore +++ b/.gitignore @@ -29,6 +29,10 @@ eclipse run .DS_Store +# Idk what prompted gradle to create this folder +Fabric/Fabric + + # MacOS moment .DS_Store From 7b355340303ed869b663e38c7b5ea2157611eb3b Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Mon, 8 Jul 2024 13:24:32 -0400 Subject: [PATCH 12/48] still very very broken code. making progress, texture renderer is taped back together with some more settings, but many quirks still. lots of messy code. --- .../client/entity/WallScrollRenderer.java | 4 +- .../client/render/HexPatternPoints.java | 59 +++++++- .../client/render/PatternRenderSettings.java | 3 +- .../client/render/PatternRenderer.java | 124 +++++++++------ .../client/render/PatternTextureManager.java | 142 +++++++++--------- .../render/WorldlyPatternRenderHelpers.java | 6 +- 6 files changed, 204 insertions(+), 134 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java index 8e448fe2d7..04c9988360 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java @@ -1,6 +1,5 @@ package at.petrak.hexcasting.client.entity; -import at.petrak.hexcasting.client.render.PatternTextureManager; import at.petrak.hexcasting.client.render.WorldlyPatternRenderHelpers; import at.petrak.hexcasting.common.entities.EntityWallScroll; import com.mojang.blaze3d.systems.RenderSystem; @@ -94,8 +93,7 @@ public void render(EntityWallScroll wallScroll, float yaw, float partialTicks, P ps.popPose(); - if (PatternTextureManager.useTextures) //&& wallScroll.points != null) - WorldlyPatternRenderHelpers.renderPatternForScroll(wallScroll.pattern, wallScroll, ps, bufSource, light, wallScroll.blockSize, wallScroll.getShowsStrokeOrder()); + WorldlyPatternRenderHelpers.renderPatternForScroll(wallScroll.pattern, wallScroll, ps, bufSource, light, wallScroll.blockSize, wallScroll.getShowsStrokeOrder()); } //TODO: remove old rendering if not needed anymore for comparison diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java index a8d1a5cc1c..17cf7cc508 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java @@ -3,10 +3,15 @@ import at.petrak.hexcasting.api.casting.math.HexPattern; import net.minecraft.world.phys.Vec2; -import java.util.HashMap; import java.util.List; import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; +/** + * static points making up a hex pattern to be rendered. It's used primarily for positioning, so we keep a + * number of extra values here to avoid recomputing them. + */ public class HexPatternPoints { public List zappyPoints; // public String pointsKey = null; //TODO: if a string key isnt performant enough override hashcode for points @@ -19,9 +24,19 @@ public class HexPatternPoints { public double rangeX; public double rangeY; - private static final HashMap CACHED_STATIC_POINTS = new HashMap<>(); + public double offsetX; + public double offsetY; - private HexPatternPoints(List zappyPoints) { + public double baseScale; + public double scale; + public double finalScale; + + public double fullWidth; + public double fullHeight; + + private static final ConcurrentMap CACHED_STATIC_POINTS = new ConcurrentHashMap<>(); + + private HexPatternPoints(List zappyPoints, PatternRenderSettings patSets) { this.zappyPoints = zappyPoints; // pointsKey = PatternTextureManager.getPointsKey(zappyPoints); for (Vec2 point : zappyPoints) { @@ -32,6 +47,42 @@ private HexPatternPoints(List zappyPoints) { } rangeX = maxX - minX; rangeY = maxY - minY; + + int patStepsX = (int)Math.round(rangeX / 1.5); + int patStepsY = (int)Math.round(rangeY / 1.7); + + // scales the patterns so that each point is patSets.baseScale units apart + baseScale = patSets.baseScale / 1.5; + + // size of the pattern in pose space with no other adjustments + double baseWidth = rangeX * baseScale; + double baseHeight = rangeY * baseScale; + + // make sure that the scale fits within our min sizes + scale = Math.max(1.0, Math.max(patSets.minWidth / baseWidth, patSets.minHeight / baseHeight)); + + + // scale down if needed to fit in vertical space + if(patSets.fitAxis.vertFit){ + scale = Math.min(scale, (patSets.spaceHeight - 2 * patSets.vPadding)/(baseHeight)); + } + + // scale down if needed to fit in horizontal space + if(patSets.fitAxis.horFit){ + scale = Math.min(scale, (patSets.spaceWidth - 2 * patSets.hPadding)/(baseWidth)); + } + + finalScale = baseScale * scale; + + // either the space given or however long it goes if it's not fitted. + fullWidth = (baseWidth * scale) + 2 * patSets.hPadding; + fullHeight = (baseHeight * scale) + 2 * patSets.vPadding; + + if(patSets.fitAxis.horFit) fullWidth = Math.max(patSets.spaceWidth, fullWidth); + if(patSets.fitAxis.vertFit) fullHeight = Math.max(patSets.spaceHeight, fullHeight); + + offsetX = (fullWidth - baseWidth * scale) / 2; + offsetY = (fullHeight - baseHeight * scale) / 2; } @@ -54,7 +105,7 @@ public static HexPatternPoints getStaticPoints(HexPattern pattern, PatternRender List zappyPatternSpace = RenderLib.makeZappy(lines1, dupIndices, patSets.hops, patSets.variance, 0f, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); - return new HexPatternPoints(zappyPatternSpace); + return new HexPatternPoints(zappyPatternSpace, patSets); }); } } \ No newline at end of file diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java index 8153773019..7ee4d55c2e 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java @@ -51,7 +51,6 @@ public class PatternRenderSettings { protected float readabilityOffset; protected float lastSegmentLenProportion = 1f; - public PatternRenderSettings(){} private PatternRenderSettings( @@ -67,7 +66,7 @@ private PatternRenderSettings( } public String getCacheKey(HexPattern pattern, double seed){ - return pattern.toString() + ";" + id + ";" + seed; + return (pattern.getStartDir().toString() + "-" + pattern.anglesSignature() + "-" + id + "-" + seed).toLowerCase(); } private PatternRenderSettings copy(){ diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index f4a6b90864..4e61daaf71 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -4,29 +4,30 @@ import at.petrak.hexcasting.api.casting.math.HexPattern; import at.petrak.hexcasting.mixin.accessor.client.AccessorLightTexturePixels; import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.vertex.PoseStack; -import com.mojang.blaze3d.vertex.VertexConsumer; +import com.mojang.blaze3d.vertex.*; import net.minecraft.client.Minecraft; import net.minecraft.client.multiplayer.ClientLevel; -import net.minecraft.client.renderer.GameRenderer; -import net.minecraft.client.renderer.LightTexture; +import net.minecraft.client.renderer.*; +import net.minecraft.client.renderer.texture.OverlayTexture; +import net.minecraft.resources.ResourceLocation; import net.minecraft.util.FastColor; import net.minecraft.world.phys.Vec2; +import net.minecraft.world.phys.Vec3; import javax.annotation.Nullable; -import java.util.ArrayList; -import java.util.List; -import java.util.Set; +import java.util.*; public class PatternRenderer { public static void renderPattern(HexPattern pattern, PoseStack ps, PatternRenderSettings patSets, PatternColors patColors, double seed) { - renderPattern(pattern, ps, null, patSets, patColors, seed, null); + renderPattern(pattern, ps, null, patSets, patColors, seed, null, new Vec3(0,0,1)); } - public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable VertexConsumer vc, PatternRenderSettings patSets, PatternColors patColors, double seed, Integer light){ - if(patSets.speed == 0){ + public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable MultiBufferSource provider, PatternRenderSettings patSets, PatternColors patColors, double seed, Integer light, Vec3 normalVec){ + if(patSets.speed == 0 && PatternTextureManager.useTextures){ // try doing texture rendering + boolean didRender = renderPatternTexture(pattern, ps, provider, patSets, patColors, seed, (light != null) ? light : LightTexture.FULL_BRIGHT, normalVec); + if(didRender) return; } var oldShader = RenderSystem.getShader(); @@ -50,47 +51,12 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Ver patSets.hops, patSets.variance, patSets.speed, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); } - int patStepsX = (int)Math.round(staticPoints.rangeX / 1.5); - int patStepsY = (int)Math.round(staticPoints.rangeY / 1.7); - - // scales the patterns so that each point is patSets.baseScale units apart - double baseScale = patSets.baseScale / 1.5; - - // size of the pattern in pose space with no other adjustments - double baseWidth = staticPoints.rangeX * baseScale; - double baseHeight = staticPoints.rangeY * baseScale; - - // make sure that the scale fits within our min sizes - double scale = Math.max(1.0, Math.max(patSets.minWidth / baseWidth, patSets.minHeight / baseHeight)); - - - // scale down if needed to fit in vertical space - if(patSets.fitAxis.vertFit){ - scale = Math.min(scale, (patSets.spaceHeight - 2 * patSets.vPadding)/(baseHeight)); - } - - // scale down if needed to fit in horizontal space - if(patSets.fitAxis.horFit){ - scale = Math.min(scale, (patSets.spaceWidth - 2 * patSets.hPadding)/(baseWidth)); - } - - - // either the space given or however long it goes if it's not fitted. - double fullWidth = (baseWidth * scale) + 2 * patSets.hPadding; - double fullHeight = (baseHeight * scale) + 2 * patSets.vPadding; - - if(patSets.fitAxis.horFit) fullWidth = Math.max(patSets.spaceWidth, fullWidth); - if(patSets.fitAxis.vertFit) fullHeight = Math.max(patSets.spaceHeight, fullHeight); - - double offsetX = (fullWidth - baseWidth * scale) / 2; - double offsetY = (fullHeight - baseHeight * scale) / 2; - List zappyRenderSpace = new ArrayList<>(); for (Vec2 point : zappyPattern) { zappyRenderSpace.add(new Vec2( - (float) (((point.x - staticPoints.minX) * baseScale * scale) + offsetX), - (float) (((point.y - staticPoints.minY) * baseScale * scale) + offsetY) + (float) (((point.x - staticPoints.minX) * staticPoints.finalScale) + staticPoints.offsetX), + (float) (((point.y - staticPoints.minY) * staticPoints.finalScale) + staticPoints.offsetY) )); } @@ -114,8 +80,8 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Ver } - RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(scale * baseScale)), 0.005f, patColors.outerEndColor, patColors.outerStartColor); - RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.innerWidthProvider.apply((float)(scale * baseScale)), 0f, patColors.innerEndColor, patColors.innerStartColor); + RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), 0.005f, patColors.outerEndColor, patColors.outerStartColor); + RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.innerWidthProvider.apply((float)(staticPoints.finalScale)), 0f, patColors.innerEndColor, patColors.innerStartColor); // TODO: probably want to have option to render little dots and stuff. // 2D -- supports gradient stroke (goes through tessellator) // if(vc == null){ @@ -133,4 +99,64 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Ver RenderSystem.setShaderColor(1f, 1f, 1f, 1f); RenderSystem.setShader(() -> oldShader); } + + private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @Nullable MultiBufferSource provider, PatternRenderSettings patSets, PatternColors patColors, double seed, int light, Vec3 normalVec){ + Optional> maybeTextures = PatternTextureManager.getTextures(pattern, patSets, seed); + if(maybeTextures.isEmpty()){ + return false; + } + ShaderInstance oldShader = RenderSystem.getShader(); + + Map textures = maybeTextures.get(); + + + HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); + + RenderSystem.enableDepthTest(); + + VertexConsumer vc = setupVC(provider, textures.get("outer")); + + textureVertex(vc, ps, 0, 0, 0, 0, 0, normalVec, light, patColors.outerStartColor); + textureVertex(vc, ps, 0, (float)staticPoints.fullHeight, 0, 0, 1, normalVec, light, patColors.outerStartColor); + textureVertex(vc, ps, (float)staticPoints.fullWidth, (float)staticPoints.fullHeight, 0, 1, 1, normalVec, light, patColors.outerStartColor); + textureVertex(vc, ps, (float)staticPoints.fullWidth, 0, 0, 1, 0, normalVec, light, patColors.outerStartColor); + + if(provider == null) Tesselator.getInstance().end(); + vc = setupVC(provider, textures.get("inner")); + + textureVertex(vc, ps, 0, 0, 0.001f, 0, 0, normalVec, light, patColors.innerStartColor); + textureVertex(vc, ps, 0, (float)staticPoints.fullHeight, 0.001f, 0, 1, normalVec, light, patColors.innerStartColor); + textureVertex(vc, ps, (float)staticPoints.fullWidth, (float)staticPoints.fullHeight, 0.001f, 1, 1, normalVec, light, patColors.innerStartColor); + textureVertex(vc, ps, (float)staticPoints.fullWidth, 0, 0.001f, 1, 0, normalVec, light, patColors.innerStartColor); + + + if(provider == null) Tesselator.getInstance().end(); + + RenderSystem.setShader(() -> oldShader); + + return true; + } + + private static VertexConsumer setupVC(@Nullable MultiBufferSource provider, ResourceLocation texture){ + VertexConsumer vc; + + if(provider == null){ + Tesselator.getInstance().getBuilder().begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.NEW_ENTITY); + vc = Tesselator.getInstance().getBuilder(); + RenderSystem.setShaderTexture(0, texture); + RenderSystem.setShader(GameRenderer::getRendertypeEntityTranslucentShader); + } else { + vc = provider.getBuffer(RenderType.entityTranslucentCull(texture)); + } + + return vc; + } + + private static void textureVertex(VertexConsumer vc, PoseStack ps, float x, float y, float z, float u, float v, Vec3 normals, int light, int color){ + vc.vertex(ps.last().pose(), x, y, 0) + .color(color) + .uv(u, v).overlayCoords(OverlayTexture.NO_OVERLAY).uv2(light) + .normal(ps.last().normal(), (float)normals.x, (float)normals.y, (float)normals.z) + .endVertex(); + } } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java index bbb12475d6..44d4ce93b0 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java @@ -2,7 +2,6 @@ import at.petrak.hexcasting.api.casting.math.HexPattern; import com.mojang.blaze3d.platform.NativeImage; -import com.mojang.blaze3d.vertex.PoseStack; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.texture.DynamicTexture; import net.minecraft.resources.ResourceLocation; @@ -41,12 +40,13 @@ public static void setResolutionScaler(int resolutionScaler) { otherLineWidth = 4 * resolutionScaler; } - private static final ConcurrentMap patternTexturesToAdd = new ConcurrentHashMap<>(); + private static final ConcurrentMap> patternTexturesToAdd = new ConcurrentHashMap<>(); + private static final Set inProgressPatterns = new HashSet<>(); // basically newCachedThreadPool, but with a max pool size private static final ExecutorService executor = new ThreadPoolExecutor(0, 16, 60L, TimeUnit.SECONDS, new LinkedBlockingDeque<>()); - private static final HashMap patternTextures = new HashMap<>(); + private static final HashMap> patternTextures = new HashMap<>(); public static String getPointsKey(List zappyPoints) { @@ -55,16 +55,18 @@ public static String getPointsKey(List zappyPoints) .collect(Collectors.joining(";")); } - public static Optional getTexture(HexPattern pattern, PoseStack ps, PatternRenderSettings patSets, PatternColors patColors, double seed, boolean innerOrOuter) { + public static Optional> getTextures(HexPattern pattern, PatternRenderSettings patSets, double seed) { // public static ResourceLocation getTexture(List points, String pointsKey, int blockSize, boolean showsStrokeOrder, float lineWidth, boolean useFullSize, Color innerColor, Color outerColor) { - String patCacheKey = patSets.getCacheKey(pattern, seed) + (innerOrOuter ? "_inner" : "_outer"); + String patCacheKey = patSets.getCacheKey(pattern, seed); // move textures from concurrent map to normal hashmap as needed if (patternTexturesToAdd.containsKey(patCacheKey)) { var patternTexture = patternTexturesToAdd.remove(patCacheKey); var oldPatternTexture = patternTextures.put(patCacheKey, patternTexture); - if (oldPatternTexture != null) - Minecraft.getInstance().getTextureManager().getTexture(oldPatternTexture).close(); + inProgressPatterns.remove(patCacheKey); + if (oldPatternTexture != null) // TODO: is this needed? when does this ever happen? + for(ResourceLocation oldPatternTextureSingle : oldPatternTexture.values()) + Minecraft.getInstance().getTextureManager().getTexture(oldPatternTextureSingle).close(); return Optional.of(patternTexture); } @@ -72,16 +74,17 @@ public static Optional getTexture(HexPattern pattern, PoseStac return Optional.of(patternTextures.get(patCacheKey)); // render a higher-resolution texture in a background thread so it eventually becomes all nice nice and pretty - executor.submit(() -> { - var slowTextures = createTextures(pattern, patSets, seed, false); - - // TextureManager#register doesn't look very thread-safe, so move back to the main thread after the slow part is done - Minecraft.getInstance().execute(() -> { - for(Map.Entry textureEntry : slowTextures.entrySet()){ - registerTexture(patCacheKey + "_" + textureEntry.getKey(), textureEntry.getValue(), true); - } + if(!inProgressPatterns.contains(patCacheKey)){ + inProgressPatterns.add(patCacheKey); + executor.submit(() -> { + var slowTextures = createTextures(pattern, patSets, seed, false); + + // TextureManager#register doesn't look very thread-safe, so move back to the main thread after the slow part is done + Minecraft.getInstance().execute(() -> { + registerTextures(patCacheKey, slowTextures); + }); }); - }); + } return Optional.empty(); } @@ -90,62 +93,43 @@ private static Map createTextures(HexPattern pattern, Pa { // int resolution = resolutionByBlockSize * blockSize; // int padding = paddingByBlockSize * blockSize; +// +// int resolution = resolutionByBlockSize; +// int padding = paddingByBlockSize; +// +// if (fastRender) { +// resolution /= fastRenderScaleFactor; +// padding /= fastRenderScaleFactor; +//// lineWidth /= (float)fastRenderScaleFactor; +// } - int resolution = resolutionByBlockSize; - int padding = paddingByBlockSize; - - if (fastRender) { - resolution /= fastRenderScaleFactor; - padding /= fastRenderScaleFactor; -// lineWidth /= (float)fastRenderScaleFactor; - } HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); - double baseScale = patSets.baseScale / 1.5; - - // size of the pattern in pose space with no other adjustments - double baseWidth = staticPoints.rangeX * baseScale; - double baseHeight = staticPoints.rangeY * baseScale; - - // make sure that the scale fits within our min sizes - double scale = Math.max(1.0, Math.max(patSets.minWidth / baseWidth, patSets.minHeight / baseHeight)); - - // scale down if needed to fit in vertical space - if(patSets.fitAxis.vertFit){ - scale = Math.min(scale, (patSets.spaceHeight - 2 * patSets.vPadding)/(baseHeight)); - } - - // scale down if needed to fit in horizontal space - if(patSets.fitAxis.horFit){ - scale = Math.min(scale, (patSets.spaceWidth - 2 * patSets.hPadding)/(baseWidth)); - } - List zappyRenderSpace = new ArrayList<>(); for (Vec2 point : staticPoints.zappyPoints) { zappyRenderSpace.add(new Vec2( - (float) (((point.x - staticPoints.minX) * baseScale * scale) + patSets.hPadding), - (float) (((point.y - staticPoints.minY) * baseScale * scale) + patSets.vPadding) + (float) (((point.x - staticPoints.minX) * staticPoints.finalScale) + staticPoints.offsetX), + (float) (((point.y - staticPoints.minY) * staticPoints.finalScale) + staticPoints.offsetY) )); } -// -// double offsetX = ((resolution - 2 * padding) - rangeX * scale) / 2; -// double offsetY = ((resolution - 2 * padding) - rangeY * scale) / 2; + Map patTexts = new HashMap<>(); - BufferedImage img = new BufferedImage(resolution, resolution, BufferedImage.TYPE_INT_ARGB); - Graphics2D g2d = img.createGraphics(); - g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); + NativeImage innerLines = drawLines(zappyRenderSpace, staticPoints, patSets.innerWidthProvider.apply((float)(staticPoints.finalScale)), 128); + patTexts.put("inner", new DynamicTexture(innerLines)); + + NativeImage outerLines = drawLines(zappyRenderSpace, staticPoints, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), 128); + patTexts.put("outer", new DynamicTexture(outerLines)); + + // TODO: handle start hexagon and grid bits. // g2d.setColor(outerColor); // g2d.setStroke(new BasicStroke((blockSize * 5f / 3f) * lineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); // drawLines(g2d, points, minX, minY, scale, offsetX, offsetY, padding); // -// g2d.setColor(innerColor); -// g2d.setStroke(new BasicStroke((blockSize * 2f / 3f) * lineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); -// drawLines(g2d, points, minX, minY, scale, offsetX, offsetY, padding); -// + // // if (showsStrokeOrder) { // g2d.setColor(new Color(0xff_d77b5b)); @@ -154,37 +138,49 @@ private static Map createTextures(HexPattern pattern, Pa // drawHexagon(g2d, point.getA(), point.getB(), spotRadius); // } - g2d.dispose(); - - NativeImage nativeImage = new NativeImage(img.getWidth(), img.getHeight(), true); - for (int y = 0; y < img.getHeight(); y++) - for (int x = 0; x < img.getWidth(); x++) - nativeImage.setPixelRGBA(x, y, img.getRGB(x, y)); - return new HashMap<>(); // temporary + return patTexts; } - private static ResourceLocation registerTexture(String patTextureKey, DynamicTexture dynamicTexture, boolean isSlow) { + private static Map registerTextures(String patTextureKeyBase, Map dynamicTextures) { // isSlow used to register different textures for the low-resolution, fastly rendered version of each texture // and the high-resolution, slowly rendered version (this means the slow doesn't replace the fast in the texture manager, // which causes occasional visual stuttering for a frame). - String name = "hex_pattern_texture_" + patTextureKey + "_" + repaintIndex + "_" + (isSlow ? "slow" : "fast") + ".png"; - ResourceLocation resourceLocation = Minecraft.getInstance().getTextureManager().register(name, dynamicTexture); - patternTexturesToAdd.put(patTextureKey, resourceLocation); - return resourceLocation; + Map resLocs = new HashMap<>(); + for(Map.Entry textureEntry : dynamicTextures.entrySet()){ + String name = "hex_pattern_texture_" + patTextureKeyBase + "_" + textureEntry.getKey() + "_" + repaintIndex + ".png"; + ResourceLocation resourceLocation = Minecraft.getInstance().getTextureManager().register(name, textureEntry.getValue()); + resLocs.put(textureEntry.getKey(), resourceLocation); + } + patternTexturesToAdd.put(patTextureKeyBase, resLocs); + return resLocs; } - private static void drawLines(Graphics2D g2d, List points, double minX, double minY, double scale, double offsetX, double offsetY, int padding) { + private static NativeImage drawLines(List points, HexPatternPoints staticPoints, float unscaledLineWidth, int resPerUnit) { + BufferedImage img = new BufferedImage((int)(staticPoints.fullWidth*resPerUnit), (int)(staticPoints.fullHeight*resPerUnit), BufferedImage.TYPE_INT_ARGB); + Graphics2D g2d = img.createGraphics(); + g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); + + g2d.setColor(new Color(0xFF_FFFFFF)); // set it to white so we can reuse the texture with different colors + g2d.setStroke(new BasicStroke(unscaledLineWidth * resPerUnit, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); for (int i = 0; i < points.size() - 1; i++) { - Tuple pointFrom = getTextureCoordinates(points.get(i), minX, minY, scale, offsetX, offsetY, padding); - Tuple pointTo = getTextureCoordinates(points.get(i+1), minX, minY, scale, offsetX, offsetY, padding); + Tuple pointFrom = getTextureCoordinates(points.get(i), staticPoints, resPerUnit); + Tuple pointTo = getTextureCoordinates(points.get(i+1), staticPoints, resPerUnit); g2d.drawLine(pointFrom.getA(), pointFrom.getB(), pointTo.getA(), pointTo.getB()); } + g2d.dispose(); + NativeImage nativeImage = new NativeImage(img.getWidth(), img.getHeight(), true); + for (int y = 0; y < img.getHeight(); y++) + for (int x = 0; x < img.getWidth(); x++) + nativeImage.setPixelRGBA(x, y, img.getRGB(x, y)); + return nativeImage; } - private static Tuple getTextureCoordinates(Vec2 point, double minX, double minY, double scale, double offsetX, double offsetY, int padding) { - int x = (int) ((point.x - minX) * scale + offsetX) + padding; - int y = (int) ((point.y - minY) * scale + offsetY) + padding; + private static Tuple getTextureCoordinates(Vec2 point, HexPatternPoints staticPoints, int resPerUnit) { +// int x = (int) ( ((point.x - staticPoints.minX) * staticPoints.finalScale + staticPoints.offsetX) * resPerUnit); +// int y = (int) ( ((point.y - staticPoints.minY) * staticPoints.finalScale + staticPoints.offsetY) * resPerUnit); + int x = (int) ( point.x * resPerUnit); + int y = (int) ( point.y * resPerUnit); return new Tuple<>(x, y); } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index fad069fda7..99c6b0e77d 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -14,7 +14,6 @@ import net.minecraft.client.renderer.GameRenderer; import net.minecraft.client.renderer.LightTexture; import net.minecraft.client.renderer.MultiBufferSource; -import net.minecraft.client.renderer.RenderType; import net.minecraft.client.renderer.texture.OverlayTexture; import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.block.state.properties.AttachFace; @@ -133,8 +132,9 @@ public static void renderPattern(HexPattern pattern, PatternRenderSettings patSe // ps.scale(x, y, z); ps.translate(0,0, z); - VertexConsumer verts = bufSource.getBuffer(RenderType.entityCutout(TheCoolerRenderLib.WHITE)); - PatternRenderer.renderPattern(pattern, ps, verts, patSets, patColors, seed, light); +// VertexConsumer verts = bufSource.getBuffer(RenderType.entityCutout(TheCoolerRenderLib.WHITE)); +// PatternRenderer.renderPattern(pattern, ps, bufSource, patSets, patColors, seed, light, nVec); + PatternRenderer.renderPattern(pattern, ps, null, patSets, patColors, seed, light, nVec); // ResourceLocation texture = PatternTextureManager.getTexture(zappyPoints, pointsKey, blockSize, showStrokeOrder, lineWidth, useFullSize, new Color(innerColor), new Color(outerColor)); // VertexConsumer verts = bufSource.getBuffer(RenderType.entityCutout(texture)); From e371e96973abe54b2bf4425e6eaa1585d29dc352 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Mon, 8 Jul 2024 14:34:33 -0400 Subject: [PATCH 13/48] slates are looking good ! --- .../client/entity/WallScrollRenderer.java | 4 +- .../client/render/PatternRenderer.java | 25 +++-- .../render/WorldlyPatternRenderHelpers.java | 23 ++-- .../render/be/BlockEntitySlateRenderer.java | 101 +----------------- 4 files changed, 38 insertions(+), 115 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java index 04c9988360..e29d68b322 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java @@ -58,7 +58,9 @@ public void render(EntityWallScroll wallScroll, float yaw, float partialTicks, P var mat = last.pose(); var norm = last.normal(); - var verts = bufSource.getBuffer(RenderType.entityCutout(this.getTextureLocation(wallScroll))); + RenderType layer = RenderType.entityCutout(this.getTextureLocation(wallScroll)); + + var verts = bufSource.getBuffer(layer); // Remember: CCW // Front face vertex(mat, norm, light, verts, 0, 0, dz, 0, 0, 0, 0, -1); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index 4e61daaf71..ef4d7dbb1d 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -116,12 +116,12 @@ private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @N VertexConsumer vc = setupVC(provider, textures.get("outer")); - textureVertex(vc, ps, 0, 0, 0, 0, 0, normalVec, light, patColors.outerStartColor); - textureVertex(vc, ps, 0, (float)staticPoints.fullHeight, 0, 0, 1, normalVec, light, patColors.outerStartColor); + textureVertex(vc, ps, 0, 0, 0.0005f, 0, 0, normalVec, light, patColors.outerStartColor); + textureVertex(vc, ps, 0, (float)staticPoints.fullHeight, 0.0005f, 0, 1, normalVec, light, patColors.outerStartColor); textureVertex(vc, ps, (float)staticPoints.fullWidth, (float)staticPoints.fullHeight, 0, 1, 1, normalVec, light, patColors.outerStartColor); - textureVertex(vc, ps, (float)staticPoints.fullWidth, 0, 0, 1, 0, normalVec, light, patColors.outerStartColor); + textureVertex(vc, ps, (float)staticPoints.fullWidth, 0, 0.0005f, 1, 0, normalVec, light, patColors.outerStartColor); - if(provider == null) Tesselator.getInstance().end(); + endDraw(provider, textures.get("outer"), vc); vc = setupVC(provider, textures.get("inner")); textureVertex(vc, ps, 0, 0, 0.001f, 0, 0, normalVec, light, patColors.innerStartColor); @@ -130,7 +130,7 @@ private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @N textureVertex(vc, ps, (float)staticPoints.fullWidth, 0, 0.001f, 1, 0, normalVec, light, patColors.innerStartColor); - if(provider == null) Tesselator.getInstance().end(); + endDraw(provider, textures.get("inner"), vc); RenderSystem.setShader(() -> oldShader); @@ -140,18 +140,27 @@ private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @N private static VertexConsumer setupVC(@Nullable MultiBufferSource provider, ResourceLocation texture){ VertexConsumer vc; + RenderType layer = RenderType.entityTranslucentCull(texture); + if(provider == null){ Tesselator.getInstance().getBuilder().begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.NEW_ENTITY); vc = Tesselator.getInstance().getBuilder(); RenderSystem.setShaderTexture(0, texture); - RenderSystem.setShader(GameRenderer::getRendertypeEntityTranslucentShader); + RenderSystem.setShader(GameRenderer::getRendertypeEntityTranslucentCullShader); } else { - vc = provider.getBuffer(RenderType.entityTranslucentCull(texture)); + vc = provider.getBuffer(layer); } - + layer.setupRenderState(); return vc; } + private static void endDraw(@Nullable MultiBufferSource provider, ResourceLocation texture, VertexConsumer vc){ + if(provider == null){ + RenderType layer = RenderType.entityTranslucentCull(texture); + layer.end(Tesselator.getInstance().getBuilder(), VertexSorting.ORTHOGRAPHIC_Z); + } + } + private static void textureVertex(VertexConsumer vc, PoseStack ps, float x, float y, float z, float u, float v, Vec3 normals, int light, int color){ vc.vertex(ps.last().pose(), x, y, 0) .color(color) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index 99c6b0e77d..e005e04868 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -40,8 +40,14 @@ public class WorldlyPatternRenderHelpers { ) .named("wallscroll_readable"); + public static final PatternRenderSettings SLATE_WOMBLY_SETTINGS = WORLDLY_RENDER_SETTINGS.withZappySettings( + null, 2.5f, 0.1f, null, null, null) + .named("slate_wobbly"); + public static final PatternColors DEFAULT_PATTERN_COLOR = new PatternColors(0xc8_322b33, 0xff_d2c8c8); + public static final PatternColors SLATE_WOBBLY_COLOR = new PatternColors(RenderLib.screenCol(0xff_64c8ff), 0xff_64c8ff); + public static void renderPatternForScroll(HexPattern pattern, EntityWallScroll scroll, PoseStack ps, MultiBufferSource bufSource, int light, int blockSize, boolean showStrokeOrder) { ps.pushPose(); @@ -56,21 +62,26 @@ public static void renderPatternForSlate(BlockEntitySlate tile, HexPattern patte boolean isOnCeiling = bs.getValue(BlockSlate.ATTACH_FACE) == AttachFace.CEILING; int facing = bs.getValue(BlockSlate.FACING).get2DDataValue(); - renderPatternForBlockEntity(pattern, tile, ps, buffer, light, isOnWall, isOnCeiling, true, facing); + boolean wombly = bs.getValue(BlockSlate.ENERGIZED); + + renderPatternForBlockEntity(pattern, tile, + wombly ? SLATE_WOMBLY_SETTINGS : WORLDLY_RENDER_SETTINGS, + wombly ? SLATE_WOBBLY_COLOR : DEFAULT_PATTERN_COLOR, + ps, buffer, light, isOnWall, isOnCeiling, true, facing); } public static void renderPatternForAkashicBookshelf(BlockEntityAkashicBookshelf tile, HexPattern pattern, PoseStack ps, MultiBufferSource buffer, int light, BlockState bs) { int facing = bs.getValue(BlockAkashicBookshelf.FACING).get2DDataValue(); - renderPatternForBlockEntity(pattern, tile, ps, buffer, LightTexture.FULL_BRIGHT, true, false, false, facing); + renderPatternForBlockEntity(pattern, tile, WORLDLY_RENDER_SETTINGS, DEFAULT_PATTERN_COLOR, ps, buffer, LightTexture.FULL_BRIGHT, true, false, false, facing); } - public static void renderPatternForBlockEntity(HexPattern pattern, HexBlockEntity tile, PoseStack ps, MultiBufferSource buffer, int light, boolean isOnWall, boolean isOnCeiling, boolean isSlate, int facing) + public static void renderPatternForBlockEntity(HexPattern pattern, HexBlockEntity tile, PatternRenderSettings patSets, PatternColors patColors, PoseStack ps, MultiBufferSource buffer, int light, boolean isOnWall, boolean isOnCeiling, boolean isSlate, int facing) { var oldShader = RenderSystem.getShader(); ps.pushPose(); RenderSystem.setShader(GameRenderer::getPositionTexShader); - renderPattern(pattern, WORLDLY_RENDER_SETTINGS, DEFAULT_PATTERN_COLOR, tile.getBlockPos().hashCode(), ps, buffer, light, 1, isOnWall, isOnCeiling, isSlate, false, facing); + renderPattern(pattern, patSets, patColors, tile.getBlockPos().hashCode(), ps, buffer, light, 1, isOnWall, isOnCeiling, isSlate, false, facing); ps.popPose(); RenderSystem.setShader(() -> oldShader); } @@ -133,8 +144,8 @@ public static void renderPattern(HexPattern pattern, PatternRenderSettings patSe // ps.scale(x, y, z); ps.translate(0,0, z); // VertexConsumer verts = bufSource.getBuffer(RenderType.entityCutout(TheCoolerRenderLib.WHITE)); -// PatternRenderer.renderPattern(pattern, ps, bufSource, patSets, patColors, seed, light, nVec); - PatternRenderer.renderPattern(pattern, ps, null, patSets, patColors, seed, light, nVec); + PatternRenderer.renderPattern(pattern, ps, bufSource, patSets, patColors, seed, light, nVec); +// PatternRenderer.renderPattern(pattern, ps, null, patSets, patColors, seed, light, nVec); // ResourceLocation texture = PatternTextureManager.getTexture(zappyPoints, pointsKey, blockSize, showStrokeOrder, lineWidth, useFullSize, new Color(innerColor), new Color(outerColor)); // VertexConsumer verts = bufSource.getBuffer(RenderType.entityCutout(texture)); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntitySlateRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntitySlateRenderer.java index 803bb43cb1..7fbf43ffc6 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntitySlateRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntitySlateRenderer.java @@ -1,22 +1,11 @@ package at.petrak.hexcasting.client.render.be; -import at.petrak.hexcasting.client.render.PatternTextureManager; -import at.petrak.hexcasting.client.render.RenderLib; import at.petrak.hexcasting.client.render.WorldlyPatternRenderHelpers; import at.petrak.hexcasting.common.blocks.circles.BlockEntitySlate; -import at.petrak.hexcasting.common.blocks.circles.BlockSlate; -import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.PoseStack; -import com.mojang.math.Axis; -import net.minecraft.client.renderer.GameRenderer; import net.minecraft.client.renderer.MultiBufferSource; import net.minecraft.client.renderer.blockentity.BlockEntityRenderer; import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider; -import net.minecraft.util.Mth; -import net.minecraft.world.level.block.state.properties.AttachFace; -import net.minecraft.world.phys.Vec2; - -import java.util.ArrayList; public class BlockEntitySlateRenderer implements BlockEntityRenderer { public BlockEntitySlateRenderer(BlockEntityRendererProvider.Context ctx) { @@ -31,94 +20,6 @@ public void render(BlockEntitySlate tile, float pPartialTick, PoseStack ps, var bs = tile.getBlockState(); - if(PatternTextureManager.useTextures && !bs.getValue(BlockSlate.ENERGIZED)) { - WorldlyPatternRenderHelpers.renderPatternForSlate(tile, tile.pattern, ps, buffer, light, bs); - return; - } - - //TODO: remove old rendering if not needed anymore for comparison - - var oldShader = RenderSystem.getShader(); - RenderSystem.setShader(GameRenderer::getPositionColorShader); - RenderSystem.enableDepthTest(); - - ps.pushPose(); - - ps.translate(0.5, 0.5, 0.5); - var attchFace = bs.getValue(BlockSlate.ATTACH_FACE); - if (attchFace == AttachFace.WALL) { - var quarters = (-bs.getValue(BlockSlate.FACING).get2DDataValue()) % 4; - ps.mulPose(Axis.YP.rotation(Mth.HALF_PI * quarters)); - ps.mulPose(Axis.ZP.rotation(Mth.PI)); - } else { - var neg = attchFace == AttachFace.FLOOR ? -1 : 1; - ps.mulPose(Axis.XP.rotation(neg * Mth.HALF_PI)); - var quarters = (bs.getValue(BlockSlate.FACING).get2DDataValue() + 2) % 4; - ps.mulPose(Axis.ZP.rotation(neg * Mth.HALF_PI * quarters)); - } - - // Resolution is the number of sub-voxels in the block for rendering purposes, 16 is the default - // padding is the space to leave on the edges free of pattern - var resolution = 16; - var padding = resolution * PatternTextureManager.paddingByBlockSize / PatternTextureManager.resolutionByBlockSize; - - // and now Z is out? - ps.translate(0, 0, -0.5); - ps.scale(1f / resolution, 1f / resolution, 1f / resolution); - ps.translate(0, 0, 1.01); - - var isLit = bs.getValue(BlockSlate.ENERGIZED); - var variance = isLit ? 2.5f : 0.5f; - var speed = isLit ? 0.1f : 0f; - - var lines1 = tile.pattern.toLines(1, Vec2.ZERO); - var stupidHash = tile.getBlockPos().hashCode(); - var zappyPattern = RenderLib.makeZappy(lines1, RenderLib.findDupIndices(tile.pattern.positions()), - 10, variance, speed, 0.2f, 0f, 1f, stupidHash); - - // always do space calculations with the static version of the pattern - // so that it doesn't jump around resizing itself. - var zappyPatternSpace = RenderLib.makeZappy(lines1, RenderLib.findDupIndices(tile.pattern.positions()), - 10, 0.5f, 0f, 0.2f, 0f, 1f, stupidHash); - - double minX = Double.MAX_VALUE, maxX = Double.MIN_VALUE, minY = Double.MAX_VALUE, maxY = Double.MIN_VALUE; - for (Vec2 point : zappyPatternSpace) - { - minX = Math.min(minX, point.x); - maxX = Math.max(maxX, point.x); - minY = Math.min(minY, point.y); - maxY = Math.max(maxY, point.y); - } - - double rangeX = maxX - minX; - double rangeY = maxY - minY; - - double scale = Math.min((resolution - 2 * padding) / rangeX, (resolution - 2 * padding) / rangeY); - - double offsetX = ((- 2 * padding) - rangeX * scale) / 2; - double offsetY = ((- 2 * padding) - rangeY * scale) / 2; - - var zappyRenderSpace = new ArrayList(); - - for (Vec2 point : zappyPattern) { - zappyRenderSpace.add(new Vec2( - (float) (((point.x - minX) * scale + offsetX) + padding), - (float) (((point.y - minY) * scale + offsetY) + padding) - )); - } - - // For some reason it is mirrored left to right and i can't seem to posestack-fu it into shape - for (int i = 0; i < zappyRenderSpace.size(); i++) { - var v = zappyRenderSpace.get(i); - zappyRenderSpace.set(i, new Vec2(-v.x, v.y)); - } - - int outer = isLit ? 0xff_64c8ff : 0xff_d2c8c8; - int inner = isLit ? RenderLib.screenCol(outer) : 0xc8_322b33; - RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, 1f, 0f, outer, outer); - RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, 0.4f, 0.01f, inner, inner); - - ps.popPose(); - RenderSystem.setShader(() -> oldShader); + WorldlyPatternRenderHelpers.renderPatternForSlate(tile, tile.pattern, ps, buffer, light, bs); } } \ No newline at end of file From df9a7c3f63e40d9433b44914c5a8b7bb98766e7f Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Tue, 9 Jul 2024 15:23:04 -0400 Subject: [PATCH 14/48] some progress on cleaning up inline patterns - hitting an issue with depth buffer? add texture resargs --- .../client/render/PatternRenderer.java | 39 ++++++++----------- .../client/render/PatternTextureManager.java | 38 +++--------------- .../render/WorldlyPatternRenderHelpers.java | 2 +- .../interop/inline/InlinePatternRenderer.java | 19 +++++++-- 4 files changed, 38 insertions(+), 60 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index ef4d7dbb1d..55a1c4f15c 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -6,7 +6,6 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.*; import net.minecraft.client.Minecraft; -import net.minecraft.client.multiplayer.ClientLevel; import net.minecraft.client.renderer.*; import net.minecraft.client.renderer.texture.OverlayTexture; import net.minecraft.resources.ResourceLocation; @@ -19,14 +18,15 @@ public class PatternRenderer { - public static void renderPattern(HexPattern pattern, PoseStack ps, PatternRenderSettings patSets, PatternColors patColors, double seed) { - renderPattern(pattern, ps, null, patSets, patColors, seed, null, new Vec3(0,0,1)); + public static void renderPattern(HexPattern pattern, PoseStack ps, PatternRenderSettings patSets, PatternColors patColors, double seed, int resPerUnit) { + renderPattern(pattern, ps, null, patSets, patColors, seed, null, null, resPerUnit); } - public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable MultiBufferSource provider, PatternRenderSettings patSets, PatternColors patColors, double seed, Integer light, Vec3 normalVec){ - if(patSets.speed == 0 && PatternTextureManager.useTextures){ - // try doing texture rendering - boolean didRender = renderPatternTexture(pattern, ps, provider, patSets, patColors, seed, (light != null) ? light : LightTexture.FULL_BRIGHT, normalVec); + public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable MultiBufferSource provider, PatternRenderSettings patSets, PatternColors patColors, double seed, Integer light, Vec3 normalVec, int resPerUnit){ + // only do texture rendering if it's static and has solid colors + if(patSets.speed == 0 && PatternTextureManager.useTextures && patColors.innerStartColor == patColors.innerEndColor + && patColors.outerStartColor == patColors.outerEndColor){ + boolean didRender = renderPatternTexture(pattern, ps, provider, patSets, patColors, seed, light == null ? LightTexture.FULL_BRIGHT : light, normalVec, resPerUnit); if(didRender) return; } @@ -60,16 +60,8 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Mul )); } - // TODO: tweak this to suck less or rewrite drawLineSeq to support light -- they're yellow?? in dark lighting?? if(light != null){ - ClientLevel cLevel = Minecraft.getInstance().level; -// float blockBrightness = LightTexture.getBrightness(cLevel.dimensionType(), LightTexture.block(light)); -// float skyBlockBrightness = LightTexture.getBrightness(cLevel.dimensionType(), LightTexture.sky(light)); -// float skyBrightness = cLevel.getSkyDarken(Minecraft.getInstance().getFrameTime()); - -// float brightness = (float)Math.min(1.0,((skyBrightness * skyBlockBrightness) + blockBrightness) / 1.5); - // get brightness straight from the texture. int bri = ((AccessorLightTexturePixels)Minecraft.getInstance().gameRenderer.lightTexture()).getLightPixels().getPixelRGBA( LightTexture.block(light), LightTexture.sky(light)); RenderSystem.setShaderColor( @@ -95,16 +87,18 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Mul // } ps.popPose(); -// RenderSystem.enableCull(); RenderSystem.setShaderColor(1f, 1f, 1f, 1f); RenderSystem.setShader(() -> oldShader); } - private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @Nullable MultiBufferSource provider, PatternRenderSettings patSets, PatternColors patColors, double seed, int light, Vec3 normalVec){ - Optional> maybeTextures = PatternTextureManager.getTextures(pattern, patSets, seed); + private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @Nullable MultiBufferSource provider, PatternRenderSettings patSets, PatternColors patColors, double seed, int light, Vec3 normalVec, int resPerUnit){ + Optional> maybeTextures = PatternTextureManager.getTextures(pattern, patSets, seed, resPerUnit); if(maybeTextures.isEmpty()){ return false; } + + if(normalVec == null) normalVec = new Vec3(1f, 1f, 1f); + ShaderInstance oldShader = RenderSystem.getShader(); Map textures = maybeTextures.get(); @@ -129,7 +123,6 @@ private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @N textureVertex(vc, ps, (float)staticPoints.fullWidth, (float)staticPoints.fullHeight, 0.001f, 1, 1, normalVec, light, patColors.innerStartColor); textureVertex(vc, ps, (float)staticPoints.fullWidth, 0, 0.001f, 1, 0, normalVec, light, patColors.innerStartColor); - endDraw(provider, textures.get("inner"), vc); RenderSystem.setShader(() -> oldShader); @@ -141,16 +134,14 @@ private static VertexConsumer setupVC(@Nullable MultiBufferSource provider, Reso VertexConsumer vc; RenderType layer = RenderType.entityTranslucentCull(texture); - + layer.setupRenderState(); if(provider == null){ Tesselator.getInstance().getBuilder().begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.NEW_ENTITY); vc = Tesselator.getInstance().getBuilder(); - RenderSystem.setShaderTexture(0, texture); RenderSystem.setShader(GameRenderer::getRendertypeEntityTranslucentCullShader); } else { vc = provider.getBuffer(layer); } - layer.setupRenderState(); return vc; } @@ -164,7 +155,9 @@ private static void endDraw(@Nullable MultiBufferSource provider, ResourceLocati private static void textureVertex(VertexConsumer vc, PoseStack ps, float x, float y, float z, float u, float v, Vec3 normals, int light, int color){ vc.vertex(ps.last().pose(), x, y, 0) .color(color) - .uv(u, v).overlayCoords(OverlayTexture.NO_OVERLAY).uv2(light) + .uv(u, v) + .overlayCoords(OverlayTexture.NO_OVERLAY) + .uv2(light) .normal(ps.last().normal(), (float)normals.x, (float)normals.y, (float)normals.z) .endVertex(); } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java index 44d4ce93b0..6f4baa3f5e 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java @@ -13,7 +13,6 @@ import java.util.List; import java.util.*; import java.util.concurrent.*; -import java.util.stream.Collectors; public class PatternTextureManager { @@ -48,16 +47,8 @@ public static void setResolutionScaler(int resolutionScaler) { private static final HashMap> patternTextures = new HashMap<>(); - public static String getPointsKey(List zappyPoints) - { - return zappyPoints.stream() - .map(p -> String.format("(%f,%f)", p.x, p.y)) - .collect(Collectors.joining(";")); - } - - public static Optional> getTextures(HexPattern pattern, PatternRenderSettings patSets, double seed) { -// public static ResourceLocation getTexture(List points, String pointsKey, int blockSize, boolean showsStrokeOrder, float lineWidth, boolean useFullSize, Color innerColor, Color outerColor) { - String patCacheKey = patSets.getCacheKey(pattern, seed); + public static Optional> getTextures(HexPattern pattern, PatternRenderSettings patSets, double seed, int resPerUnit) { + String patCacheKey = patSets.getCacheKey(pattern, seed) + "_" + resPerUnit; // move textures from concurrent map to normal hashmap as needed if (patternTexturesToAdd.containsKey(patCacheKey)) { @@ -77,7 +68,7 @@ public static Optional> getTextures(HexPattern pat if(!inProgressPatterns.contains(patCacheKey)){ inProgressPatterns.add(patCacheKey); executor.submit(() -> { - var slowTextures = createTextures(pattern, patSets, seed, false); + var slowTextures = createTextures(pattern, patSets, seed, resPerUnit); // TextureManager#register doesn't look very thread-safe, so move back to the main thread after the slow part is done Minecraft.getInstance().execute(() -> { @@ -88,22 +79,7 @@ public static Optional> getTextures(HexPattern pat return Optional.empty(); } - private static Map createTextures(HexPattern pattern, PatternRenderSettings patSets, double seed, boolean fastRender) -// private static DynamicTexture createTexture(List points, int blockSize, boolean showsStrokeOrder, float lineWidth, boolean useFullSize, Color innerColor, Color outerColor, boolean fastRender) - { -// int resolution = resolutionByBlockSize * blockSize; -// int padding = paddingByBlockSize * blockSize; -// -// int resolution = resolutionByBlockSize; -// int padding = paddingByBlockSize; -// -// if (fastRender) { -// resolution /= fastRenderScaleFactor; -// padding /= fastRenderScaleFactor; -//// lineWidth /= (float)fastRenderScaleFactor; -// } - - + private static Map createTextures(HexPattern pattern, PatternRenderSettings patSets, double seed, int resPerUnit) { HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); List zappyRenderSpace = new ArrayList<>(); @@ -117,10 +93,10 @@ private static Map createTextures(HexPattern pattern, Pa Map patTexts = new HashMap<>(); - NativeImage innerLines = drawLines(zappyRenderSpace, staticPoints, patSets.innerWidthProvider.apply((float)(staticPoints.finalScale)), 128); + NativeImage innerLines = drawLines(zappyRenderSpace, staticPoints, patSets.innerWidthProvider.apply((float)(staticPoints.finalScale)), resPerUnit); patTexts.put("inner", new DynamicTexture(innerLines)); - NativeImage outerLines = drawLines(zappyRenderSpace, staticPoints, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), 128); + NativeImage outerLines = drawLines(zappyRenderSpace, staticPoints, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), resPerUnit); patTexts.put("outer", new DynamicTexture(outerLines)); // TODO: handle start hexagon and grid bits. @@ -177,8 +153,6 @@ private static NativeImage drawLines(List points, HexPatternPoints staticP } private static Tuple getTextureCoordinates(Vec2 point, HexPatternPoints staticPoints, int resPerUnit) { -// int x = (int) ( ((point.x - staticPoints.minX) * staticPoints.finalScale + staticPoints.offsetX) * resPerUnit); -// int y = (int) ( ((point.y - staticPoints.minY) * staticPoints.finalScale + staticPoints.offsetY) * resPerUnit); int x = (int) ( point.x * resPerUnit); int y = (int) ( point.y * resPerUnit); return new Tuple<>(x, y); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index e005e04868..9d610227a3 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -144,7 +144,7 @@ public static void renderPattern(HexPattern pattern, PatternRenderSettings patSe // ps.scale(x, y, z); ps.translate(0,0, z); // VertexConsumer verts = bufSource.getBuffer(RenderType.entityCutout(TheCoolerRenderLib.WHITE)); - PatternRenderer.renderPattern(pattern, ps, bufSource, patSets, patColors, seed, light, nVec); + PatternRenderer.renderPattern(pattern, ps, bufSource, patSets, patColors, seed, light, nVec, blockSize * PatternTextureManager.resolutionByBlockSize); // PatternRenderer.renderPattern(pattern, ps, null, patSets, patColors, seed, light, nVec); // ResourceLocation texture = PatternTextureManager.getTexture(zappyPoints, pointsKey, blockSize, showStrokeOrder, lineWidth, useFullSize, new Color(innerColor), new Color(outerColor)); diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index 712433a84b..809d077ad2 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -8,6 +8,7 @@ import net.minecraft.client.gui.GuiGraphics; import net.minecraft.network.chat.Style; import net.minecraft.resources.ResourceLocation; +import net.minecraft.util.FastColor; public class InlinePatternRenderer implements InlineRenderer { @@ -18,15 +19,25 @@ public ResourceLocation getId(){ } public static final PatternRenderSettings INLINE_RENDER_SETTINGS = new PatternRenderSettings() - .withSizings(PatternRenderSettings.FitAxis.VERT, 8.0, 8.0, 1.0, 0.0, 4.0, null, null, + .withSizings(PatternRenderSettings.FitAxis.VERT, 8.0, 9.0, 1.0, 0.5, 4.0, null, null, (scale) -> 1f, null) + .withZappySettings(null, 0f, 0f, 0f, 0f, null) .named("inline"); - public static final PatternColors FLAT_WHITE_PATTERN_COLOR = new PatternColors(0xFF_FFFFFF); + public static final int INLINE_TEXTURE_RES = 8; // 64px is probably fine for such small images ? - public int render(InlinePatternData data, GuiGraphics drawContext, int index, Style style, int codepoint, TextRenderingContext trContext){ - PatternRenderer.renderPattern(data.pattern, drawContext.pose(), INLINE_RENDER_SETTINGS, FLAT_WHITE_PATTERN_COLOR, 0); + public static final PatternColors FLAT_WHITE_PATTERN_COLOR = new PatternColors(0xFF_000000); + public int render(InlinePatternData data, GuiGraphics drawContext, int index, Style style, int codepoint, TextRenderingContext trContext){ + drawContext.pose().pushPose(); + drawContext.pose().translate(0f, -0.5f, 0f); + int trColor = FastColor.ARGB32.color((int)(255*trContext.alpha), (int)(255*trContext.red), + (int)(255*trContext.green), (int)(255*trContext.blue)); + int color = style.getColor() == null ? trColor : style.getColor().getValue(); + PatternRenderer.renderPattern(data.pattern, drawContext.pose(), null, INLINE_RENDER_SETTINGS, + new PatternColors(color), 0, trContext.light, null, INLINE_TEXTURE_RES); + + drawContext.pose().popPose(); return charWidth(data, style, codepoint); } From 8bf0031f1f813dec4e510ae29eaaf000d572faa6 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Tue, 9 Jul 2024 17:03:29 -0400 Subject: [PATCH 15/48] make patterns white in lists --- .../at/petrak/hexcasting/api/casting/iota/PatternIota.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/PatternIota.java b/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/PatternIota.java index 63131cee8c..7fae3f5e79 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/PatternIota.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/PatternIota.java @@ -25,6 +25,7 @@ import net.minecraft.nbt.CompoundTag; import net.minecraft.nbt.Tag; import net.minecraft.network.chat.Component; +import net.minecraft.network.chat.Style; import net.minecraft.resources.ResourceKey; import net.minecraft.server.level.ServerLevel; import org.jetbrains.annotations.NotNull; @@ -162,7 +163,8 @@ public static PatternIota deserialize(Tag tag) throws IllegalArgumentException { } public static Component display(HexPattern pat) { - return (new InlinePatternData(pat)).asText(true); + Component text = (new InlinePatternData(pat)).asText(true); + return text.copy().withStyle(text.getStyle().applyTo(Style.EMPTY.withColor(ChatFormatting.WHITE))); } // keep around just in case it's needed. From 3b31e2dac7ef4879a058dce37eb1d33843f2c05e Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Tue, 9 Jul 2024 18:29:50 -0400 Subject: [PATCH 16/48] add slate and scroll pattern labels for hotbar viewing --- .../common/items/storage/ItemScroll.java | 9 ++++- .../common/items/storage/ItemSlate.java | 35 ++++++++++--------- 2 files changed, 27 insertions(+), 17 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/common/items/storage/ItemScroll.java b/Common/src/main/java/at/petrak/hexcasting/common/items/storage/ItemScroll.java index 4ed6093a46..d1bed2504f 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/items/storage/ItemScroll.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/items/storage/ItemScroll.java @@ -9,6 +9,7 @@ import at.petrak.hexcasting.common.entities.EntityWallScroll; import at.petrak.hexcasting.common.lib.hex.HexIotaTypes; import at.petrak.hexcasting.common.misc.PatternTooltip; +import at.petrak.hexcasting.interop.inline.InlinePatternData; import net.minecraft.core.BlockPos; import net.minecraft.core.Direction; import net.minecraft.nbt.CompoundTag; @@ -127,7 +128,13 @@ public Component getName(ItemStack pStack) { return Component.translatable(descID + ".of", Component.translatable("hexcasting.action." + ResourceLocation.tryParse(ancientId))); } else if (NBTHelper.hasCompound(pStack, TAG_PATTERN)) { - return Component.translatable(descID); + var compound = NBTHelper.getCompound(pStack, ItemScroll.TAG_PATTERN); + var patternLabel = Component.literal(""); + if (compound != null) { + var pattern = HexPattern.fromNBT(compound); + patternLabel = Component.literal(": ").append(new InlinePatternData(pattern).asText(false)); + } + return Component.translatable(descID).append(patternLabel); } else { return Component.translatable(descID + ".empty"); } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/items/storage/ItemSlate.java b/Common/src/main/java/at/petrak/hexcasting/common/items/storage/ItemSlate.java index 3821a83e99..cd2454e9e1 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/items/storage/ItemSlate.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/items/storage/ItemSlate.java @@ -11,6 +11,7 @@ import at.petrak.hexcasting.common.blocks.circles.BlockEntitySlate; import at.petrak.hexcasting.common.lib.hex.HexIotaTypes; import at.petrak.hexcasting.common.misc.PatternTooltip; +import at.petrak.hexcasting.interop.inline.InlinePatternData; import net.minecraft.nbt.CompoundTag; import net.minecraft.nbt.Tag; import net.minecraft.network.chat.Component; @@ -38,16 +39,27 @@ public ItemSlate(Block pBlock, Properties pProperties) { @Override public Component getName(ItemStack pStack) { var key = "block." + HexAPI.MOD_ID + ".slate." + (hasPattern(pStack) ? "written" : "blank"); - return Component.translatable(key); + Component patternText = getPattern(pStack) + .map(pat -> Component.literal(": ").append(new InlinePatternData(pat).asText(false))) + .orElse(Component.literal("")); + return Component.translatable(key).append(patternText); } - public static boolean hasPattern(ItemStack stack) { + public static Optional getPattern(ItemStack stack){ var bet = NBTHelper.getCompound(stack, "BlockEntityTag"); - if (bet != null) { - return bet.contains(BlockEntitySlate.TAG_PATTERN, Tag.TAG_COMPOUND) && - !bet.getCompound(BlockEntitySlate.TAG_PATTERN).isEmpty(); + + if (bet != null && bet.contains(BlockEntitySlate.TAG_PATTERN, Tag.TAG_COMPOUND)) { + var patTag = bet.getCompound(BlockEntitySlate.TAG_PATTERN); + if (!patTag.isEmpty()) { + var pattern = HexPattern.fromNBT(patTag); + return Optional.of(pattern); + } } - return false; + return Optional.empty(); + } + + public static boolean hasPattern(ItemStack stack) { + return getPattern(stack).isPresent(); } @SoftImplement("IForgeItem") @@ -107,15 +119,6 @@ public void writeDatum(ItemStack stack, Iota datum) { @Override public Optional getTooltipImage(ItemStack stack) { - var bet = NBTHelper.getCompound(stack, "BlockEntityTag"); - - if (bet != null && bet.contains(BlockEntitySlate.TAG_PATTERN, Tag.TAG_COMPOUND)) { - var patTag = bet.getCompound(BlockEntitySlate.TAG_PATTERN); - if (!patTag.isEmpty()) { - var pattern = HexPattern.fromNBT(patTag); - return Optional.of(new PatternTooltip(pattern, PatternTooltipComponent.SLATE_BG)); - } - } - return Optional.empty(); + return getPattern(stack).map(pat -> new PatternTooltip(pat, PatternTooltipComponent.SLATE_BG)); } } From 5555044ecf2816f27cabc25efacac449aa174d25 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Fri, 12 Jul 2024 15:43:03 -0400 Subject: [PATCH 17/48] working on getting renderlib drawlineseq to accept other shaders/formats, not going super well --- .../client/render/PatternRenderer.java | 125 +++++++++++++----- .../hexcasting/client/render/RenderLib.kt | 86 ++++++------ .../hexcasting/client/render/VCDrawHelper.kt | 31 +++++ .../interop/inline/InlinePatternData.java | 20 +++ .../interop/inline/InlinePatternRenderer.java | 8 +- 5 files changed, 194 insertions(+), 76 deletions(-) create mode 100644 Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index 55a1c4f15c..7b7f33013f 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -2,19 +2,19 @@ import at.petrak.hexcasting.api.casting.math.HexPattern; -import at.petrak.hexcasting.mixin.accessor.client.AccessorLightTexturePixels; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.*; -import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.*; import net.minecraft.client.renderer.texture.OverlayTexture; import net.minecraft.resources.ResourceLocation; -import net.minecraft.util.FastColor; import net.minecraft.world.phys.Vec2; import net.minecraft.world.phys.Vec3; +import org.jetbrains.annotations.NotNull; +import org.joml.Matrix4f; import javax.annotation.Nullable; import java.util.*; +import java.util.function.Supplier; public class PatternRenderer { @@ -31,9 +31,6 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Mul } var oldShader = RenderSystem.getShader(); - RenderSystem.setShader(GameRenderer::getPositionColorShader); - RenderSystem.enableDepthTest(); - RenderSystem.disableCull(); ps.pushPose(); @@ -60,34 +57,12 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Mul )); } - // TODO: tweak this to suck less or rewrite drawLineSeq to support light -- they're yellow?? in dark lighting?? - if(light != null){ - int bri = ((AccessorLightTexturePixels)Minecraft.getInstance().gameRenderer.lightTexture()).getLightPixels().getPixelRGBA( - LightTexture.block(light), LightTexture.sky(light)); - RenderSystem.setShaderColor( - FastColor.ARGB32.red(bri)/255f, - FastColor.ARGB32.red(bri)/255f, - FastColor.ARGB32.red(bri)/255f, - 1f); - } - - - RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), 0.005f, patColors.outerEndColor, patColors.outerStartColor); - RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.innerWidthProvider.apply((float)(staticPoints.finalScale)), 0f, patColors.innerEndColor, patColors.innerStartColor); - // TODO: probably want to have option to render little dots and stuff. - // 2D -- supports gradient stroke (goes through tessellator) -// if(vc == null){ -// } else { // 3D -- goes through vc, supports lighting -- kinda -// ps.mulPoseMatrix(new Matrix4f().scaling(-1.0f, 1.0f, 1.0f)); -// ps.pushPose(); -// ps.translate(0, 0, 0.005f); -// TheCoolerRenderLib.theCoolerDrawLineSeq(ps.last().pose(), ps.last().normal(), light, vc, zappyRenderSpace, patSets.outerWidthProvider.apply((float)(scale * baseScale)), patColors.outerStartColor); -// ps.popPose(); -// TheCoolerRenderLib.theCoolerDrawLineSeq(ps.last().pose(), ps.last().normal(), light, vc, zappyRenderSpace, patSets.innerWidthProvider.apply((float)(scale * baseScale)), patColors.innerStartColor); -// } + RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), + patColors.outerEndColor, patColors.outerStartColor, new SillyVCHelper(provider, ps, light, normalVec, 0.005f)); + RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.innerWidthProvider.apply((float)(staticPoints.finalScale)), + patColors.innerEndColor, patColors.innerStartColor, new SillyVCHelper(provider, ps, light, normalVec, 0f)); ps.popPose(); - RenderSystem.setShaderColor(1f, 1f, 1f, 1f); RenderSystem.setShader(() -> oldShader); } @@ -103,11 +78,8 @@ private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @N Map textures = maybeTextures.get(); - HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); - RenderSystem.enableDepthTest(); - VertexConsumer vc = setupVC(provider, textures.get("outer")); textureVertex(vc, ps, 0, 0, 0.0005f, 0, 0, normalVec, light, patColors.outerStartColor); @@ -135,6 +107,9 @@ private static VertexConsumer setupVC(@Nullable MultiBufferSource provider, Reso RenderType layer = RenderType.entityTranslucentCull(texture); layer.setupRenderState(); + if(provider instanceof MultiBufferSource.BufferSource immediate){ + immediate.endBatch(); + } if(provider == null){ Tesselator.getInstance().getBuilder().begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.NEW_ENTITY); vc = Tesselator.getInstance().getBuilder(); @@ -161,4 +136,84 @@ private static void textureVertex(VertexConsumer vc, PoseStack ps, float x, floa .normal(ps.last().normal(), (float)normals.x, (float)normals.y, (float)normals.z) .endVertex(); } + + private static class SillyVCHelper implements VCDrawHelper{ + + private final MultiBufferSource provider; + private final Integer light; + private final Vec3 normVec; + private final float z; + private final PoseStack ps; + + private final boolean usesLight; + private final boolean usesNorm; + private final int modeIndex; + + private static final RenderType rType = RenderType.solid(); + + private static final VertexFormat[] formatsList = { + DefaultVertexFormat.POSITION_COLOR, // no light no normals + DefaultVertexFormat.POSITION_COLOR_LIGHTMAP, // yes light no normals + DefaultVertexFormat.BLOCK // yes light yes normals + }; + + private static final List> shadersList = List.of( + GameRenderer::getPositionColorShader, // no light no normals + GameRenderer::getPositionColorLightmapShader, // yes light no normals + GameRenderer::getRendertypeSolidShader // yes light yes normals + ); + + // need pose stack for normal matrix + public SillyVCHelper(@Nullable MultiBufferSource provider, PoseStack ps, Integer light, Vec3 normVec, float z){ + this.provider = provider; + this.light = light; + this.normVec = normVec; + this.z = z; + this.ps = ps; + + usesLight = light != null; + usesNorm = normVec != null && ps != null && usesLight; // doesn't really make sense to have norms without lighting? + modeIndex = (usesLight ? 1 : 0) + (usesNorm ? 1 : 0); // index of formats/shaders to use + } + + @NotNull + @Override + public VertexConsumer vcSetupAndSupply(@NotNull VertexFormat.Mode vertMode) { + // we're not actually using provider here because i don't see a render layer that actually supports this? + // TODOish: make our own render layer/type for it i guess if we really care, i don't think i do. + + if(provider instanceof MultiBufferSource.BufferSource immediate){ + immediate.endBatch(); + } + + Tesselator.getInstance().getBuilder().begin(vertMode, formatsList[modeIndex]); + if(usesNorm){ + RenderSystem.setShaderTexture(0, TheCoolerRenderLib.WHITE); + rType.setupRenderState(); + } + RenderSystem.setShader( shadersList.get(modeIndex)); + return Tesselator.getInstance().getBuilder(); + } + + @Override + public void vertex(@NotNull VertexConsumer vc, int color, @NotNull Vec2 pos, @NotNull Matrix4f matrix) { + + vc.vertex(matrix, pos.x, pos.y, z) + .color(color); + + if (usesNorm) vc.uv(1, 1); // block format needs a texture, we just set it to plain white + if (usesLight) vc.uv2(light); + if (usesNorm) vc.normal(ps.last().normal(), (float)normVec.x, (float)normVec.y, (float)normVec.z); + + vc.endVertex(); + } + + @Override + public void vcEndDrawer(@NotNull VertexConsumer vc) { + if(usesNorm){ + rType.clearRenderState(); + } + Tesselator.getInstance().end(); + } + } } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/RenderLib.kt b/Common/src/main/java/at/petrak/hexcasting/client/render/RenderLib.kt index 38d70fdfa8..bfb873a620 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/RenderLib.kt +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/RenderLib.kt @@ -4,7 +4,7 @@ package at.petrak.hexcasting.client.render import at.petrak.hexcasting.api.casting.math.HexPattern import at.petrak.hexcasting.api.mod.HexConfig -import at.petrak.hexcasting.api.utils.* +import at.petrak.hexcasting.api.utils.TAU import at.petrak.hexcasting.client.ClientTickCounter import at.petrak.hexcasting.client.gui.GuiSpellcasting import com.mojang.blaze3d.vertex.DefaultVertexFormat @@ -16,8 +16,8 @@ import net.minecraft.client.Minecraft import net.minecraft.client.gui.GuiGraphics import net.minecraft.client.gui.screens.Screen import net.minecraft.client.renderer.MultiBufferSource -import net.minecraft.core.BlockPos import net.minecraft.util.FastColor +import net.minecraft.util.FastColor.ARGB32 import net.minecraft.util.Mth import net.minecraft.world.entity.Entity import net.minecraft.world.level.Level @@ -42,6 +42,18 @@ const val CAP_THETA = 180f / 10f const val DEFAULT_READABILITY_OFFSET = 0.2f const val DEFAULT_LAST_SEGMENT_LEN_PROP = 0.8f + +fun drawLineSeq( + mat: Matrix4f, + points: List, + width: Float, + z: Float, + tail: Int, + head: Int +) { + return drawLineSeq(mat, points, width, tail, head, VCDrawHelper.Basic(z)) +} + /** * Draw a sequence of linePoints spanning the given points. * @@ -51,9 +63,9 @@ fun drawLineSeq( mat: Matrix4f, points: List, width: Float, - z: Float, tail: Int, head: Int, + vcHelper: VCDrawHelper ) { if (points.size <= 1) return @@ -61,6 +73,7 @@ fun drawLineSeq( val g1 = FastColor.ARGB32.green(tail).toFloat() val b1 = FastColor.ARGB32.blue(tail).toFloat() val a = FastColor.ARGB32.alpha(tail) + val a1 = a.toFloat() val headSource = if (Screen.hasControlDown() != HexConfig.client().ctrlTogglesOffStrokeOrder()) head else @@ -68,10 +81,9 @@ fun drawLineSeq( val r2 = FastColor.ARGB32.red(headSource).toFloat() val g2 = FastColor.ARGB32.green(headSource).toFloat() val b2 = FastColor.ARGB32.blue(headSource).toFloat() + val a2 = FastColor.ARGB32.alpha(headSource).toFloat() - // they spell it wrong at mojang lmao - val tess = Tesselator.getInstance() - val buf = tess.builder + var vc = vcHelper.vcSetupAndSupply(VertexFormat.Mode.TRIANGLES) val n = points.size val joinAngles = FloatArray(n) @@ -90,10 +102,6 @@ fun drawLineSeq( joinOffsets[i - 1] = Mth.clamp(Mth.sin(angle) / (1 + Mth.cos(angle)), -clamp, clamp) } - fun vertex(color: BlockPos, pos: Vec2) = - buf.vertex(mat, pos.x, pos.y, z).color(color.x, color.y, color.z, a).endVertex() - - buf.begin(VertexFormat.Mode.TRIANGLES, DefaultVertexFormat.POSITION_COLOR) for (i in 0 until points.size - 1) { val p1 = points[i] val p2 = points[i + 1] @@ -103,8 +111,9 @@ fun drawLineSeq( val tangent = p2.add(p1.negated()).normalized().scale(width * 0.5f) val normal = Vec2(-tangent.y, tangent.x) - fun color(time: Float): BlockPos = - BlockPos(Mth.lerp(time, r1, r2).toInt(), Mth.lerp(time, g1, g2).toInt(), Mth.lerp(time, b1, b2).toInt()) + fun color(time: Float): Int = + FastColor.ARGB32.color(Mth.lerp(time, a1, a2).toInt(), Mth.lerp(time, r1, r2).toInt(), + Mth.lerp(time, g1, g2).toInt(), Mth.lerp(time, b1, b2).toInt()) val color1 = color(i.toFloat() / n) val color2 = color((i + 1f) / n) @@ -118,21 +127,21 @@ fun drawLineSeq( val p2Down = p2.add(tangent.scale(Math.max(0f, jhigh)).negated()).add(normal) val p2Up = p2.add(tangent.scale(Math.max(0f, -jhigh)).negated()).add(normal.negated()) - vertex(color1, p1Down) - vertex(color1, p1) - vertex(color1, p1Up) + vcHelper.vertex(vc, color1, p1Down, mat) + vcHelper.vertex(vc, color1, p1, mat) + vcHelper.vertex(vc, color1, p1Up, mat) - vertex(color1, p1Down) - vertex(color1, p1Up) - vertex(color2, p2Up) + vcHelper.vertex(vc, color1, p1Down, mat) + vcHelper.vertex(vc, color1, p1Up, mat) + vcHelper.vertex(vc, color2, p2Up, mat) - vertex(color1, p1Down) - vertex(color2, p2Up) - vertex(color2, p2) + vcHelper.vertex(vc, color1, p1Down, mat) + vcHelper.vertex(vc, color2, p2Up, mat) + vcHelper.vertex(vc, color2, p2, mat) - vertex(color1, p1Down) - vertex(color2, p2) - vertex(color2, p2Down) + vcHelper.vertex(vc, color1, p1Down, mat) + vcHelper.vertex(vc, color2, p2, mat) + vcHelper.vertex(vc, color2, p2Down, mat) if (i > 0) { // Draw the connector to the next line segment @@ -150,9 +159,9 @@ fun drawLineSeq( val fan = rotate(rnormal, -sangle * (j.toFloat() / joinSteps)) val fanShift = Vec2(p1.x - fan.x, p1.y - fan.y) - vertex(color1, p1) - vertex(color1, prevVert) - vertex(color1, fanShift) + vcHelper.vertex(vc, color1, p1, mat) + vcHelper.vertex(vc, color1, prevVert, mat) + vcHelper.vertex(vc, color1, fanShift, mat) prevVert = fanShift } } else { @@ -162,32 +171,33 @@ fun drawLineSeq( val fan = rotate(normal, -sangle * (j.toFloat() / joinSteps)) val fanShift = Vec2(p1.x - fan.x, p1.y - fan.y) - vertex(color1, p1) - vertex(color1, prevVert) - vertex(color1, fanShift) + vcHelper.vertex(vc, color1, p1, mat) + vcHelper.vertex(vc, color1, prevVert, mat) + vcHelper.vertex(vc, color1, fanShift, mat) prevVert = fanShift } } } } - tess.end() + vcHelper.vcEndDrawer(vc) - fun drawCaps(color: BlockPos, point: Vec2, prev: Vec2) { + fun drawCaps(color: Int, point: Vec2, prev: Vec2) { val tangent = point.add(prev.negated()).normalized().scale(0.5f * width) val normal = Vec2(-tangent.y, tangent.x) val joinSteps = Mth.ceil(180f / CAP_THETA) - buf.begin(VertexFormat.Mode.TRIANGLE_FAN, DefaultVertexFormat.POSITION_COLOR) - vertex(color, point) + vc = vcHelper.vcSetupAndSupply(VertexFormat.Mode.TRIANGLE_FAN) + vcHelper.vertex(vc, color, point, mat) for (j in joinSteps downTo 0) { val fan = rotate(normal, -Mth.PI * (j.toFloat() / joinSteps)) - buf.vertex(mat, point.x + fan.x, point.y + fan.y, z).color(color.x, color.y, color.z, a).endVertex() + vcHelper.vertex(vc, color, Vec2(point.x + fan.x, point.y + fan.y), mat) } - tess.end() + vcHelper.vcEndDrawer(vc) } - drawCaps(BlockPos(r1.toInt(), g1.toInt(), b1.toInt()), points[0], points[1]) - drawCaps(BlockPos(r2.toInt(), g2.toInt(), b2.toInt()), points[n - 1], points[n - 2]) + drawCaps(ARGB32.color(a1.toInt(), r1.toInt(), g1.toInt(), b1.toInt()), points[0], points[1]) + drawCaps(ARGB32.color(a2.toInt(), r2.toInt(), g2.toInt(), b2.toInt()), points[n - 1], points[n - 2]) } + fun rotate(vec: Vec2, theta: Float): Vec2 { val cos = Mth.cos(theta) val sin = Mth.sin(theta) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt b/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt new file mode 100644 index 0000000000..77992f111a --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt @@ -0,0 +1,31 @@ +package at.petrak.hexcasting.client.render + +import com.mojang.blaze3d.vertex.DefaultVertexFormat +import com.mojang.blaze3d.vertex.Tesselator +import com.mojang.blaze3d.vertex.VertexConsumer +import com.mojang.blaze3d.vertex.VertexFormat +import net.minecraft.world.phys.Vec2 +import org.joml.Matrix4f + + +interface VCDrawHelper { + fun vcSetupAndSupply(vertMode: VertexFormat.Mode): VertexConsumer + fun vertex(vc: VertexConsumer, color: Int, pos: Vec2, matrix: Matrix4f) + fun vcEndDrawer(vc: VertexConsumer) + + class Basic(val z: Float) : VCDrawHelper { + + override fun vcSetupAndSupply(vertMode: VertexFormat.Mode): VertexConsumer{ + val tess = Tesselator.getInstance() + val buf = tess.builder + buf.begin(vertMode, DefaultVertexFormat.POSITION_COLOR) + return buf + } + override fun vertex(vc: VertexConsumer, color: Int, pos: Vec2, matrix: Matrix4f){ + vc.vertex(matrix, pos.x, pos.y, z).color(color).endVertex() + } + override fun vcEndDrawer(vc: VertexConsumer){ + Tesselator.getInstance().end() + } + } +} \ No newline at end of file diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java index 48b4079e4a..1fa3fc735d 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java @@ -1,11 +1,14 @@ package at.petrak.hexcasting.interop.inline; import at.petrak.hexcasting.api.HexAPI; +import at.petrak.hexcasting.api.casting.PatternShapeMatch; import at.petrak.hexcasting.api.casting.iota.PatternIota; import at.petrak.hexcasting.api.casting.math.HexPattern; +import at.petrak.hexcasting.common.casting.PatternRegistryManifest; import at.petrak.hexcasting.common.lib.HexItems; import com.mojang.serialization.Codec; import com.samsthenerd.inline.api.InlineData; +import net.minecraft.ChatFormatting; import net.minecraft.network.chat.Component; import net.minecraft.network.chat.HoverEvent; import net.minecraft.network.chat.Style; @@ -38,11 +41,28 @@ public ResourceLocation getRendererId(){ public Style getExtraStyle() { ItemStack scrollStack = new ItemStack(HexItems.SCROLL_MEDIUM); HexItems.SCROLL_MEDIUM.writeDatum(scrollStack, new PatternIota(pattern)); + scrollStack.setHoverName(getPatternName(pattern).copy().withStyle(ChatFormatting.WHITE)); HoverEvent he = new HoverEvent(HoverEvent.Action.SHOW_ITEM, new HoverEvent.ItemStackInfo(scrollStack)); // TODO: add copy click event return Style.EMPTY.withHoverEvent(he); } + public static Component getPatternName(HexPattern pattern){ + try { + PatternShapeMatch shapeMatch = PatternRegistryManifest.matchPattern(pattern, null, false); + if(shapeMatch instanceof PatternShapeMatch.Normal normMatch){ + return HexAPI.instance().getActionI18n(normMatch.key, false); + } + // TODO: this doesn't actually ever hit because it errors out with server castinv env stuff first :( + if(shapeMatch instanceof PatternShapeMatch.Special specialMatch){ + return HexAPI.instance().getSpecialHandlerI18n(specialMatch.key); + } + } catch (Exception e){ + // nop + } + return PatternIota.displayNonInline(pattern); + } + @Override public Component asText(boolean withExtra) { return Component.literal(pattern.toString()).withStyle(asStyle(withExtra)); diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index 809d077ad2..07bf5572f4 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -26,15 +26,17 @@ public ResourceLocation getId(){ public static final int INLINE_TEXTURE_RES = 8; // 64px is probably fine for such small images ? - public static final PatternColors FLAT_WHITE_PATTERN_COLOR = new PatternColors(0xFF_000000); - public int render(InlinePatternData data, GuiGraphics drawContext, int index, Style style, int codepoint, TextRenderingContext trContext){ drawContext.pose().pushPose(); drawContext.pose().translate(0f, -0.5f, 0f); int trColor = FastColor.ARGB32.color((int)(255*trContext.alpha), (int)(255*trContext.red), (int)(255*trContext.green), (int)(255*trContext.blue)); int color = style.getColor() == null ? trColor : style.getColor().getValue(); - PatternRenderer.renderPattern(data.pattern, drawContext.pose(), null, INLINE_RENDER_SETTINGS, + // some places (like tooltips) give an alpha of 0, but we don't want to kill the alpha value entirely. + if(FastColor.ARGB32.alpha(color) == 0){ + color |= 0xFF_000000; + } + PatternRenderer.renderPattern(data.pattern, drawContext.pose(), trContext.vertexConsumers, INLINE_RENDER_SETTINGS, new PatternColors(color), 0, trContext.light, null, INLINE_TEXTURE_RES); drawContext.pose().popPose(); From a74887922d2eb1dde131d2d1408638a7706cc76a Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Fri, 12 Jul 2024 18:59:44 -0400 Subject: [PATCH 18/48] add chat feedback to texture debug commands --- .../common/command/PatternTexturesCommand.java | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/common/command/PatternTexturesCommand.java b/Common/src/main/java/at/petrak/hexcasting/common/command/PatternTexturesCommand.java index e653759aef..2ac11403b1 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/command/PatternTexturesCommand.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/command/PatternTexturesCommand.java @@ -5,27 +5,34 @@ import com.mojang.brigadier.builder.LiteralArgumentBuilder; import net.minecraft.commands.CommandSourceStack; import net.minecraft.commands.Commands; +import net.minecraft.network.chat.Component; public class PatternTexturesCommand { public static void add(LiteralArgumentBuilder cmd) { + // TODO: do we want these in release ?? cmd.then(Commands.literal("textureToggle") .requires(dp -> dp.hasPermission(Commands.LEVEL_ADMINS)) .executes(ctx -> { PatternTextureManager.useTextures = !PatternTextureManager.useTextures; + String log = (PatternTextureManager.useTextures ? "Enabled" : "Disabled") + " pattern texture rendering. This is meant for debugging."; + ctx.getSource().sendSuccess(() -> Component.literal(log), true); return 1; })); cmd.then(Commands.literal("textureRepaint") .requires(dp -> dp.hasPermission(Commands.LEVEL_ADMINS)) .executes(ctx -> { PatternTextureManager.repaint(); + ctx.getSource().sendSuccess(() -> Component.literal("Repainting pattern textures. This is meant for debugging."), true); return 1; })); cmd.then(Commands.literal("textureSetResolutionScaler") .requires(dp -> dp.hasPermission(Commands.LEVEL_ADMINS)) .then(Commands.argument("integer", IntegerArgumentType.integer()).executes(ctx -> { - PatternTextureManager.setResolutionScaler(IntegerArgumentType.getInteger(ctx, "integer")); + int newRes = IntegerArgumentType.getInteger(ctx, "integer"); + PatternTextureManager.setResolutionScaler(newRes); PatternTextureManager.repaint(); + ctx.getSource().sendSuccess(() -> Component.literal("Setting pattern resolution scaler to " + newRes + ". This is meant for debugging."), true); return 1; }))); } From df420f3dab706ac1dfea4272376b37d8f3c14edb Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Fri, 12 Jul 2024 19:00:42 -0400 Subject: [PATCH 19/48] texture and dynamic renderers are almost identical. dynamic has weird z fighting overlay issues --- .../client/render/PatternRenderer.java | 94 ++++++++++++++----- 1 file changed, 68 insertions(+), 26 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index 7b7f33013f..d546f6747c 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -2,11 +2,14 @@ import at.petrak.hexcasting.api.casting.math.HexPattern; +import com.mojang.blaze3d.platform.GlStateManager; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.*; +import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.*; import net.minecraft.client.renderer.texture.OverlayTexture; import net.minecraft.resources.ResourceLocation; +import net.minecraft.util.FastColor; import net.minecraft.world.phys.Vec2; import net.minecraft.world.phys.Vec3; import org.jetbrains.annotations.NotNull; @@ -57,10 +60,14 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Mul )); } - RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), - patColors.outerEndColor, patColors.outerStartColor, new SillyVCHelper(provider, ps, light, normalVec, 0.005f)); - RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.innerWidthProvider.apply((float)(staticPoints.finalScale)), - patColors.innerEndColor, patColors.innerStartColor, new SillyVCHelper(provider, ps, light, normalVec, 0f)); + if(FastColor.ARGB32.alpha(patColors.outerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.outerStartColor) != 0){ + RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), + patColors.outerEndColor, patColors.outerStartColor, new SillyVCHelper(provider, ps, light, normalVec, 0.001f, patColors.outerStartColor)); + } + if(FastColor.ARGB32.alpha(patColors.innerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.innerStartColor) != 0) { + RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.innerWidthProvider.apply((float) (staticPoints.finalScale)), + patColors.innerEndColor, patColors.innerStartColor, new SillyVCHelper(provider, ps, light, normalVec, 0.0005f, patColors.innerStartColor)); + } ps.popPose(); RenderSystem.setShader(() -> oldShader); @@ -80,23 +87,29 @@ private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @N HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); - VertexConsumer vc = setupVC(provider, textures.get("outer")); - textureVertex(vc, ps, 0, 0, 0.0005f, 0, 0, normalVec, light, patColors.outerStartColor); - textureVertex(vc, ps, 0, (float)staticPoints.fullHeight, 0.0005f, 0, 1, normalVec, light, patColors.outerStartColor); - textureVertex(vc, ps, (float)staticPoints.fullWidth, (float)staticPoints.fullHeight, 0, 1, 1, normalVec, light, patColors.outerStartColor); - textureVertex(vc, ps, (float)staticPoints.fullWidth, 0, 0.0005f, 1, 0, normalVec, light, patColors.outerStartColor); + VertexConsumer vc; + if(FastColor.ARGB32.alpha(patColors.outerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.outerStartColor) != 0) { + vc = setupVC(provider, textures.get("outer")); - endDraw(provider, textures.get("outer"), vc); - vc = setupVC(provider, textures.get("inner")); + textureVertex(vc, ps, 0, 0, 0.0005f, 0, 0, normalVec, light, patColors.outerStartColor); + textureVertex(vc, ps, 0, (float) staticPoints.fullHeight, 0.0005f, 0, 1, normalVec, light, patColors.outerStartColor); + textureVertex(vc, ps, (float) staticPoints.fullWidth, (float) staticPoints.fullHeight, 0, 1, 1, normalVec, light, patColors.outerStartColor); + textureVertex(vc, ps, (float) staticPoints.fullWidth, 0, 0.0005f, 1, 0, normalVec, light, patColors.outerStartColor); - textureVertex(vc, ps, 0, 0, 0.001f, 0, 0, normalVec, light, patColors.innerStartColor); - textureVertex(vc, ps, 0, (float)staticPoints.fullHeight, 0.001f, 0, 1, normalVec, light, patColors.innerStartColor); - textureVertex(vc, ps, (float)staticPoints.fullWidth, (float)staticPoints.fullHeight, 0.001f, 1, 1, normalVec, light, patColors.innerStartColor); - textureVertex(vc, ps, (float)staticPoints.fullWidth, 0, 0.001f, 1, 0, normalVec, light, patColors.innerStartColor); + endDraw(provider, textures.get("outer"), vc); + } - endDraw(provider, textures.get("inner"), vc); + if(FastColor.ARGB32.alpha(patColors.innerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.innerStartColor) != 0) { + vc = setupVC(provider, textures.get("inner")); + textureVertex(vc, ps, 0, 0, 0.001f, 0, 0, normalVec, light, patColors.innerStartColor); + textureVertex(vc, ps, 0, (float) staticPoints.fullHeight, 0.001f, 0, 1, normalVec, light, patColors.innerStartColor); + textureVertex(vc, ps, (float) staticPoints.fullWidth, (float) staticPoints.fullHeight, 0.001f, 1, 1, normalVec, light, patColors.innerStartColor); + textureVertex(vc, ps, (float) staticPoints.fullWidth, 0, 0.001f, 1, 0, normalVec, light, patColors.innerStartColor); + + endDraw(provider, textures.get("inner"), vc); + } RenderSystem.setShader(() -> oldShader); return true; @@ -149,31 +162,34 @@ private static class SillyVCHelper implements VCDrawHelper{ private final boolean usesNorm; private final int modeIndex; + private final int alpha; + private static final RenderType rType = RenderType.solid(); private static final VertexFormat[] formatsList = { DefaultVertexFormat.POSITION_COLOR, // no light no normals DefaultVertexFormat.POSITION_COLOR_LIGHTMAP, // yes light no normals - DefaultVertexFormat.BLOCK // yes light yes normals + DefaultVertexFormat.NEW_ENTITY // yes light yes normals }; private static final List> shadersList = List.of( GameRenderer::getPositionColorShader, // no light no normals GameRenderer::getPositionColorLightmapShader, // yes light no normals - GameRenderer::getRendertypeSolidShader // yes light yes normals + GameRenderer::getRendertypeEntityTranslucentCullShader // yes light yes normals ); // need pose stack for normal matrix - public SillyVCHelper(@Nullable MultiBufferSource provider, PoseStack ps, Integer light, Vec3 normVec, float z){ + public SillyVCHelper(@Nullable MultiBufferSource provider, PoseStack ps, Integer light, Vec3 normVec, float z, int color){ this.provider = provider; this.light = light; - this.normVec = normVec; + this.normVec = normVec != null ? normVec : new Vec3(1,1,1); this.z = z; this.ps = ps; usesLight = light != null; - usesNorm = normVec != null && ps != null && usesLight; // doesn't really make sense to have norms without lighting? + usesNorm = this.normVec != null && ps != null && usesLight; // doesn't really make sense to have norms without lighting? modeIndex = (usesLight ? 1 : 0) + (usesNorm ? 1 : 0); // index of formats/shaders to use + alpha = FastColor.ARGB32.alpha(color); } @NotNull @@ -189,7 +205,19 @@ public VertexConsumer vcSetupAndSupply(@NotNull VertexFormat.Mode vertMode) { Tesselator.getInstance().getBuilder().begin(vertMode, formatsList[modeIndex]); if(usesNorm){ RenderSystem.setShaderTexture(0, TheCoolerRenderLib.WHITE); - rType.setupRenderState(); +// rType.setupRenderState(); + } + RenderSystem.enableDepthTest(); + RenderSystem.disableCull(); + if(usesLight) { + Minecraft.getInstance().gameRenderer.lightTexture().turnOnLightLayer(); + } + if(usesNorm){ + RenderSystem.enableBlend(); + RenderSystem.blendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA); + if (Minecraft.useShaderTransparency()) { + Minecraft.getInstance().levelRenderer.getTranslucentTarget().bindWrite(false); + } } RenderSystem.setShader( shadersList.get(modeIndex)); return Tesselator.getInstance().getBuilder(); @@ -199,9 +227,10 @@ public VertexConsumer vcSetupAndSupply(@NotNull VertexFormat.Mode vertMode) { public void vertex(@NotNull VertexConsumer vc, int color, @NotNull Vec2 pos, @NotNull Matrix4f matrix) { vc.vertex(matrix, pos.x, pos.y, z) - .color(color); + .color(color | 0xFF_000000); - if (usesNorm) vc.uv(1, 1); // block format needs a texture, we just set it to plain white + if (usesNorm) vc.uv(pos.x, pos.y); // block format needs a texture, we just set it to plain white + if (usesNorm) vc.overlayCoords(OverlayTexture.NO_OVERLAY); if (usesLight) vc.uv2(light); if (usesNorm) vc.normal(ps.last().normal(), (float)normVec.x, (float)normVec.y, (float)normVec.z); @@ -210,10 +239,23 @@ public void vertex(@NotNull VertexConsumer vc, int color, @NotNull Vec2 pos, @No @Override public void vcEndDrawer(@NotNull VertexConsumer vc) { + RenderSystem.setShaderColor(1f, 1f, 1f, alpha/255f); + Tesselator.getInstance().end(); + RenderSystem.setShaderColor(1f, 1f, 1f, 1f); + if(usesLight){ + Minecraft.getInstance().gameRenderer.lightTexture().turnOffLightLayer(); + } if(usesNorm){ - rType.clearRenderState(); + RenderSystem.disableBlend(); + RenderSystem.defaultBlendFunc(); + if (Minecraft.useShaderTransparency()) { + Minecraft.getInstance().getMainRenderTarget().bindWrite(false); + } } - Tesselator.getInstance().end(); + RenderSystem.enableCull(); +// if(usesNorm){ +// rType.clearRenderState(); +// } } } } From 85d7a8418e2df0e8fff63e8470456969e33f2321 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Tue, 16 Jul 2024 13:15:49 -0400 Subject: [PATCH 20/48] make entity iota display inline - it's kinda icky rn though --- .../api/casting/iota/EntityIota.java | 28 +++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/EntityIota.java b/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/EntityIota.java index fe2ee51f45..abefacc4af 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/EntityIota.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/EntityIota.java @@ -7,8 +7,10 @@ import net.minecraft.nbt.NbtUtils; import net.minecraft.nbt.Tag; import net.minecraft.network.chat.Component; +import net.minecraft.network.chat.MutableComponent; import net.minecraft.server.level.ServerLevel; import net.minecraft.world.entity.Entity; +import net.minecraft.world.entity.player.Player; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -38,13 +40,34 @@ public boolean isTruthy() { Tag serialize() { var out = new CompoundTag(); out.putUUID("uuid", this.getEntity().getUUID()); - out.putString("name", Component.Serializer.toJson(this.getEntity().getName())); + out.putString("name", Component.Serializer.toJson(getEntityNameWithInline(true))); return out; } @Override public Component display() { - return this.getEntity().getName().copy().withStyle(ChatFormatting.AQUA); + return getEntityNameWithInline(false).copy().withStyle(ChatFormatting.AQUA); + } + + private Component getEntityNameWithInline(boolean fearSerializer){ + MutableComponent baseName = this.getEntity().getName().copy(); + // TODO: Inline is a bit broken, serialization doesn't seem to actually work so we have placeholder raw text for now + Component inlineEnt = null; + if(this.getEntity() instanceof Player player){ +// inlineEnt = new PlayerHeadData(player.getGameProfile()).asText(!fearSerializer); + inlineEnt = Component.literal("[face:" + player.getGameProfile().getName() + "]"); + } else{ +// if(fearSerializer){ // we don't want to have to serialize an entity just to display it +// inlineEnt = EntityInlineData.fromType(this.getEntity().getType()).asText(!fearSerializer); +// } else { +// inlineEnt = EntityInlineData.fromEntity(this.getEntity()).asText(!fearSerializer); +// } +// inlineEnt = Component.literal("[entity:" + EntityType.getKey(this.getEntity().getType()).toString() + "]"); + } + if(inlineEnt != null){ + baseName.append(Component.literal(": ")).append(inlineEnt); + } + return baseName; } public static IotaType TYPE = new IotaType<>() { @@ -73,6 +96,7 @@ public Component display(Tag tag) { return Component.translatable("hexcasting.spelldata.entity.whoknows"); } var nameJson = ctag.getString("name"); +// return Component.literal(nameJson); return Component.Serializer.fromJsonLenient(nameJson).withStyle(ChatFormatting.AQUA); } From 221a2a541ff703ea6e00c981be3229205417f178 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Tue, 16 Jul 2024 13:16:52 -0400 Subject: [PATCH 21/48] fix-ish the z fighting, move some more logic into points class --- .../client/entity/WallScrollRenderer.java | 3 +- .../client/render/HexPatternPoints.java | 40 +++++++++++++------ .../client/render/PatternRenderer.java | 14 +++---- .../client/render/PatternTextureManager.java | 9 +---- .../render/WorldlyPatternRenderHelpers.java | 3 +- 5 files changed, 38 insertions(+), 31 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java index e29d68b322..02a626e776 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java @@ -95,7 +95,8 @@ public void render(EntityWallScroll wallScroll, float yaw, float partialTicks, P ps.popPose(); - WorldlyPatternRenderHelpers.renderPatternForScroll(wallScroll.pattern, wallScroll, ps, bufSource, light, wallScroll.blockSize, wallScroll.getShowsStrokeOrder()); + if(wallScroll.pattern != null) + WorldlyPatternRenderHelpers.renderPatternForScroll(wallScroll.pattern, wallScroll, ps, bufSource, light, wallScroll.blockSize, wallScroll.getShowsStrokeOrder()); } //TODO: remove old rendering if not needed anymore for comparison diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java index 17cf7cc508..0af57627df 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java @@ -3,6 +3,7 @@ import at.petrak.hexcasting.api.casting.math.HexPattern; import net.minecraft.world.phys.Vec2; +import java.util.ArrayList; import java.util.List; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; @@ -36,7 +37,17 @@ public class HexPatternPoints { private static final ConcurrentMap CACHED_STATIC_POINTS = new ConcurrentHashMap<>(); - private HexPatternPoints(List zappyPoints, PatternRenderSettings patSets) { + private HexPatternPoints(HexPattern pattern, PatternRenderSettings patSets, double seed) { + + List dots = pattern.toLines(1, Vec2.ZERO); + Set dupIndices = RenderLib.findDupIndices(pattern.positions()); + + // always do space calculations with the static version of the pattern + // so that it doesn't jump around resizing itself. + List zappyPoints = RenderLib.makeZappy(dots, dupIndices, + patSets.hops, patSets.variance, 0f, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); + + this.zappyPoints = zappyPoints; // pointsKey = PatternTextureManager.getPointsKey(zappyPoints); for (Vec2 point : zappyPoints) { @@ -85,6 +96,21 @@ private HexPatternPoints(List zappyPoints, PatternRenderSettings patSets) offsetY = (fullHeight - baseHeight * scale) / 2; } + public Vec2 scaleVec(Vec2 point){ + return new Vec2( + (float) (((point.x - this.minX) * this.finalScale) + this.offsetX), + (float) (((point.y - this.minY) * this.finalScale) + this.offsetY) + ); + } + + public List scaleVecs(List points){ + List scaledPoints = new ArrayList<>(); + for (Vec2 point : points) { + scaledPoints.add(scaleVec(point)); + } + return scaledPoints; + } + /** * Gets the static points for the given pattern, settings, and seed. This is cached. @@ -96,16 +122,6 @@ public static HexPatternPoints getStaticPoints(HexPattern pattern, PatternRender String cacheKey = patSets.getCacheKey(pattern, seed); - return CACHED_STATIC_POINTS.computeIfAbsent(cacheKey, (key) -> { - List lines1 = pattern.toLines(1, Vec2.ZERO); - Set dupIndices = RenderLib.findDupIndices(pattern.positions()); - - // always do space calculations with the static version of the pattern - // so that it doesn't jump around resizing itself. - List zappyPatternSpace = RenderLib.makeZappy(lines1, dupIndices, - patSets.hops, patSets.variance, 0f, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); - - return new HexPatternPoints(zappyPatternSpace, patSets); - }); + return CACHED_STATIC_POINTS.computeIfAbsent(cacheKey, (key) -> new HexPatternPoints(pattern, patSets, seed) ); } } \ No newline at end of file diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index d546f6747c..af8f91176b 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -16,7 +16,10 @@ import org.joml.Matrix4f; import javax.annotation.Nullable; -import java.util.*; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; import java.util.function.Supplier; public class PatternRenderer { @@ -51,14 +54,7 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Mul patSets.hops, patSets.variance, patSets.speed, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); } - List zappyRenderSpace = new ArrayList<>(); - - for (Vec2 point : zappyPattern) { - zappyRenderSpace.add(new Vec2( - (float) (((point.x - staticPoints.minX) * staticPoints.finalScale) + staticPoints.offsetX), - (float) (((point.y - staticPoints.minY) * staticPoints.finalScale) + staticPoints.offsetY) - )); - } + List zappyRenderSpace = staticPoints.scaleVecs(zappyPattern); if(FastColor.ARGB32.alpha(patColors.outerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.outerStartColor) != 0){ RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java index 6f4baa3f5e..114013315b 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java @@ -82,14 +82,7 @@ public static Optional> getTextures(HexPattern pat private static Map createTextures(HexPattern pattern, PatternRenderSettings patSets, double seed, int resPerUnit) { HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); - List zappyRenderSpace = new ArrayList<>(); - - for (Vec2 point : staticPoints.zappyPoints) { - zappyRenderSpace.add(new Vec2( - (float) (((point.x - staticPoints.minX) * staticPoints.finalScale) + staticPoints.offsetX), - (float) (((point.y - staticPoints.minY) * staticPoints.finalScale) + staticPoints.offsetY) - )); - } + List zappyRenderSpace = staticPoints.scaleVecs(staticPoints.zappyPoints); Map patTexts = new HashMap<>(); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index 9d610227a3..e984582c16 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -44,7 +44,8 @@ public class WorldlyPatternRenderHelpers { null, 2.5f, 0.1f, null, null, null) .named("slate_wobbly"); - public static final PatternColors DEFAULT_PATTERN_COLOR = new PatternColors(0xc8_322b33, 0xff_d2c8c8); + // using an opaque inner color based on 0xc8_322b33 because worldly pattern renderer is funky + public static final PatternColors DEFAULT_PATTERN_COLOR = new PatternColors(0xff_554d54, 0xff_d2c8c8); public static final PatternColors SLATE_WOBBLY_COLOR = new PatternColors(RenderLib.screenCol(0xff_64c8ff), 0xff_64c8ff); From 1c339fc80e963d3573366f34b1548ba916db642e Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Tue, 16 Jul 2024 17:36:15 -0400 Subject: [PATCH 22/48] add dot colors --- .../client/render/PatternColors.java | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java index ea851ade57..c96c610cbc 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java @@ -12,19 +12,32 @@ public class PatternColors { protected final int outerStartColor; protected final int outerEndColor; - public PatternColors(int innerStartColor, int innerEndColor, int outerStartColor, int outerEndColor){ + protected final int startingDotColor; + protected final int gridDotsColor; + + public PatternColors(int innerStartColor, int innerEndColor, int outerStartColor, int outerEndColor, + int startingDotsColor, int gridDotsColor){ this.innerStartColor = innerStartColor; this.innerEndColor = innerEndColor; this.outerStartColor = outerStartColor; this.outerEndColor = outerEndColor; + this.startingDotColor = startingDotsColor; + this.gridDotsColor = gridDotsColor; } + // no gradient public PatternColors(int innerColor, int outerColor){ - this(innerColor, innerColor, outerColor, outerColor); + this(innerColor, innerColor, outerColor, outerColor, 0, 0); } - // single color + // single color -- no outer layer public PatternColors(int color){ this(color, 0); } + + // add dots -- note, this is how you tell the renderer to make dots + public PatternColors withDotColors(int startingDotColor, int gridDotsColor){ + return new PatternColors(this.innerStartColor, this.innerEndColor, this.outerStartColor, this.outerEndColor, + startingDotColor, gridDotsColor); + } } From e5f9325e7a0ef5b6a26f366e91c4a4b62298b645 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Tue, 16 Jul 2024 17:36:29 -0400 Subject: [PATCH 23/48] make dots work! --- .../client/render/HexPatternPoints.java | 54 ++++++----- .../client/render/PatternRenderSettings.java | 40 +++++--- .../client/render/PatternRenderer.java | 91 ++++++++++++------- .../hexcasting/client/render/RenderLib.kt | 16 ++-- .../render/WorldlyPatternRenderHelpers.java | 25 ++++- .../interop/inline/InlinePatternRenderer.java | 4 +- 6 files changed, 144 insertions(+), 86 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java index 0af57627df..83c2f7daaf 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java @@ -1,6 +1,7 @@ package at.petrak.hexcasting.client.render; import at.petrak.hexcasting.api.casting.math.HexPattern; +import com.google.common.collect.ImmutableList; import net.minecraft.world.phys.Vec2; import java.util.ArrayList; @@ -14,32 +15,35 @@ * number of extra values here to avoid recomputing them. */ public class HexPatternPoints { - public List zappyPoints; -// public String pointsKey = null; //TODO: if a string key isnt performant enough override hashcode for points + public final ImmutableList zappyPoints; + public final ImmutableList zappyPointsScaled; - public double minX = Double.MAX_VALUE; - public double maxX = Double.MIN_VALUE; - public double minY = Double.MAX_VALUE; - public double maxY = Double.MIN_VALUE; + public final ImmutableList dotsScaled; - public double rangeX; - public double rangeY; + public final double rangeX; + public final double rangeY; + public final double finalScale; - public double offsetX; - public double offsetY; + public final double fullWidth; + public final double fullHeight; - public double baseScale; - public double scale; - public double finalScale; + private double minX = Double.MAX_VALUE; + private double maxX = Double.MIN_VALUE; + private double minY = Double.MAX_VALUE; + private double maxY = Double.MIN_VALUE; - public double fullWidth; - public double fullHeight; + private double offsetX; + private double offsetY; + + private double baseScale; + private double scale; private static final ConcurrentMap CACHED_STATIC_POINTS = new ConcurrentHashMap<>(); private HexPatternPoints(HexPattern pattern, PatternRenderSettings patSets, double seed) { List dots = pattern.toLines(1, Vec2.ZERO); + Set dupIndices = RenderLib.findDupIndices(pattern.positions()); // always do space calculations with the static version of the pattern @@ -48,7 +52,7 @@ private HexPatternPoints(HexPattern pattern, PatternRenderSettings patSets, doub patSets.hops, patSets.variance, 0f, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); - this.zappyPoints = zappyPoints; + this.zappyPoints = ImmutableList.copyOf(zappyPoints); // pointsKey = PatternTextureManager.getPointsKey(zappyPoints); for (Vec2 point : zappyPoints) { minX = Math.min(minX, point.x); @@ -86,14 +90,20 @@ private HexPatternPoints(HexPattern pattern, PatternRenderSettings patSets, doub finalScale = baseScale * scale; // either the space given or however long it goes if it's not fitted. - fullWidth = (baseWidth * scale) + 2 * patSets.hPadding; - fullHeight = (baseHeight * scale) + 2 * patSets.vPadding; + double fullWidthTmp = (baseWidth * scale) + 2 * patSets.hPadding; + double fullHeightTmp = (baseHeight * scale) + 2 * patSets.vPadding; + + if(patSets.fitAxis.horFit) fullWidthTmp = Math.max(patSets.spaceWidth, fullWidthTmp); + if(patSets.fitAxis.vertFit) fullHeightTmp = Math.max(patSets.spaceHeight, fullHeightTmp); + + this.fullWidth = fullWidthTmp; + this.fullHeight = fullHeightTmp; - if(patSets.fitAxis.horFit) fullWidth = Math.max(patSets.spaceWidth, fullWidth); - if(patSets.fitAxis.vertFit) fullHeight = Math.max(patSets.spaceHeight, fullHeight); + offsetX = (fullWidthTmp - baseWidth * scale) / 2; + offsetY = (fullHeightTmp - baseHeight * scale) / 2; - offsetX = (fullWidth - baseWidth * scale) / 2; - offsetY = (fullHeight - baseHeight * scale) / 2; + this.zappyPointsScaled = ImmutableList.copyOf(scaleVecs(zappyPoints)); + this.dotsScaled = ImmutableList.copyOf(scaleVecs(dots)); } public Vec2 scaleVec(Vec2 point){ diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java index 7ee4d55c2e..a970043a74 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java @@ -1,16 +1,5 @@ package at.petrak.hexcasting.client.render; -/* -TODO: - - handle padding, full size (for inline) vs normal - - it's actually more about scaling - - it's all the same for a square pattern, but we need to account for non-square patterns. - - ie, does it get fit to a specific axis (like inline fits to vertical and stretches as needed horizontally) - or does it fit on both/smaller fit like a scroll does. - - figure out how much is decided alongside zappy point list vs given from before -- all size stuff varies by like, - - figure out main render args - */ - import at.petrak.hexcasting.api.casting.math.HexPattern; import java.util.UUID; @@ -20,6 +9,7 @@ * Immutable data class for informing how a pattern is rendered. * * (it's a pain but this isn't a record or kotlin data class because i want it non-final) + * */ public class PatternRenderSettings { @@ -43,6 +33,9 @@ public class PatternRenderSettings { protected UnaryOperator innerWidthProvider = (scale) -> 0.1f; protected UnaryOperator outerWidthProvider = (scale) -> 0.15f; + protected UnaryOperator startingDotRadiusProvider = (scale) -> this.innerWidthProvider.apply(scale) * 0.8f; + protected UnaryOperator gridDotsRadiusProvider = (scale) -> this.innerWidthProvider.apply(scale) * 0.4f; + // zappy settings -- unused if you pass points instead of a pattern protected int hops = 10; protected float variance = 0.5f; @@ -56,12 +49,14 @@ public PatternRenderSettings(){} private PatternRenderSettings( FitAxis fitAxis, double baseScale, double minWidth, double minHeight, double spaceWidth, double spaceHeight, double hPadding, double vPadding, int hops, float variance, float speed, float flowIrregular, float readabilityOffset, - float lastSegmentLenProportion, UnaryOperator innerWidthProvider, UnaryOperator outerWidthProvider + float lastSegmentLenProportion, UnaryOperator innerWidthProvider, UnaryOperator outerWidthProvider, + UnaryOperator startingDotRadiusProvider, UnaryOperator gridDotsRadiusProvider ){ this.fitAxis = fitAxis; this.baseScale = baseScale; this.minWidth = minWidth; this.minHeight = minHeight; this.spaceWidth = spaceWidth; this.spaceHeight = spaceHeight; this.hPadding = hPadding; this.vPadding = vPadding; this.hops = hops; this.variance = variance; this.speed = speed; this.flowIrregular = flowIrregular; this.readabilityOffset = readabilityOffset; this.lastSegmentLenProportion = lastSegmentLenProportion; this.innerWidthProvider = innerWidthProvider; this.outerWidthProvider = outerWidthProvider; + this.startingDotRadiusProvider = startingDotRadiusProvider; this.gridDotsRadiusProvider = gridDotsRadiusProvider; // *dies* } @@ -71,15 +66,15 @@ public String getCacheKey(HexPattern pattern, double seed){ private PatternRenderSettings copy(){ PatternRenderSettings newSets = new PatternRenderSettings(fitAxis, baseScale, minWidth, minHeight, spaceWidth, spaceHeight, hPadding, vPadding, - hops, variance, speed, flowIrregular, readabilityOffset, lastSegmentLenProportion, innerWidthProvider, outerWidthProvider); + hops, variance, speed, flowIrregular, readabilityOffset, lastSegmentLenProportion, innerWidthProvider, outerWidthProvider, + startingDotRadiusProvider, gridDotsRadiusProvider); // add a UUID attached to the id (or our best guess, it doesn't really matter this is just to get a unique different id) newSets.id = id.substring(0, Math.max(id.indexOf('_'), 0)) + "_" + UUID.randomUUID(); return newSets; } public PatternRenderSettings withSizings(FitAxis fitAxis, Double spaceWidth, Double spaceHeight, Double hPadding, - Double vPadding, Double baseScale, Double minWidth, Double minHeight, - UnaryOperator innerWidthProvider, UnaryOperator outerWidthProvider){ + Double vPadding, Double baseScale, Double minWidth, Double minHeight){ PatternRenderSettings newSettings = copy(); newSettings.fitAxis = fitAxis == null ? this.fitAxis : fitAxis; newSettings.spaceWidth = spaceWidth == null ? this.spaceWidth : spaceWidth; @@ -89,11 +84,26 @@ public PatternRenderSettings withSizings(FitAxis fitAxis, Double spaceWidth, Dou newSettings.baseScale = baseScale == null ? this.baseScale : baseScale; newSettings.minWidth = minWidth == null ? this.minWidth : minWidth; newSettings.minHeight = minHeight == null ? this.minHeight : minHeight; + return newSettings; + } + + public PatternRenderSettings withWidths(UnaryOperator innerWidthProvider, UnaryOperator outerWidthProvider, + UnaryOperator startingDotRadiusProvider, UnaryOperator gridDotsRadiusProvider){ + PatternRenderSettings newSettings = copy(); newSettings.innerWidthProvider = innerWidthProvider == null ? this.innerWidthProvider : innerWidthProvider; newSettings.outerWidthProvider = outerWidthProvider == null ? this.outerWidthProvider : outerWidthProvider; + newSettings.startingDotRadiusProvider = startingDotRadiusProvider == null ? this.startingDotRadiusProvider : startingDotRadiusProvider; + newSettings.gridDotsRadiusProvider = gridDotsRadiusProvider == null ? this.gridDotsRadiusProvider : gridDotsRadiusProvider; return newSettings; } + public PatternRenderSettings withWidths(UnaryOperator innerWidthProvider, UnaryOperator outerWidthProvider){ + return withWidths(innerWidthProvider, outerWidthProvider, + innerWidthProvider != null ? (scale) -> innerWidthProvider.apply(scale) * 0.8f : null, + innerWidthProvider != null ? (scale) -> innerWidthProvider.apply(scale) * 0.4f : null + ); + } + public PatternRenderSettings withZappySettings(Integer hops, Float variance, Float speed, Float flowIrregular, Float readabilityOffset, Float lastSegmentLenProportion){ PatternRenderSettings newSettings = copy(); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index af8f91176b..c0738f52bb 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -29,43 +29,61 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, PatternRender } public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable MultiBufferSource provider, PatternRenderSettings patSets, PatternColors patColors, double seed, Integer light, Vec3 normalVec, int resPerUnit){ + var oldShader = RenderSystem.getShader(); + HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); + + boolean shouldRenderDynamic = true; + // only do texture rendering if it's static and has solid colors if(patSets.speed == 0 && PatternTextureManager.useTextures && patColors.innerStartColor == patColors.innerEndColor && patColors.outerStartColor == patColors.outerEndColor){ boolean didRender = renderPatternTexture(pattern, ps, provider, patSets, patColors, seed, light == null ? LightTexture.FULL_BRIGHT : light, normalVec, resPerUnit); - if(didRender) return; + if(didRender) shouldRenderDynamic = false; } + if(shouldRenderDynamic){ + List zappyPattern; + + if(patSets.speed == 0) { + // re-use our static points if we're rendering a static pattern anyway + zappyPattern = staticPoints.zappyPoints; + } else { + List lines1 = pattern.toLines(1, Vec2.ZERO); + Set dupIndices = RenderLib.findDupIndices(pattern.positions()); + zappyPattern = RenderLib.makeZappy(lines1, dupIndices, + patSets.hops, patSets.variance, patSets.speed, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); + } - var oldShader = RenderSystem.getShader(); - - ps.pushPose(); + List zappyRenderSpace = staticPoints.scaleVecs(zappyPattern); - HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); + if(FastColor.ARGB32.alpha(patColors.outerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.outerStartColor) != 0){ + RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), + patColors.outerEndColor, patColors.outerStartColor, new SillyVCHelper(provider, ps, light, normalVec, 0.001f, patColors.outerStartColor)); + } + if(FastColor.ARGB32.alpha(patColors.innerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.innerStartColor) != 0) { + RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.innerWidthProvider.apply((float) (staticPoints.finalScale)), + patColors.innerEndColor, patColors.innerStartColor, new SillyVCHelper(provider, ps, light, normalVec, 0.0005f, patColors.innerStartColor)); + } + } - List zappyPattern; + // render dots and grid dynamically for now - if(patSets.speed == 0) { - // re-use our static points if we're rendering a static pattern anyway - zappyPattern = staticPoints.zappyPoints; - } else { - List lines1 = pattern.toLines(1, Vec2.ZERO); - Set dupIndices = RenderLib.findDupIndices(pattern.positions()); - zappyPattern = RenderLib.makeZappy(lines1, dupIndices, - patSets.hops, patSets.variance, patSets.speed, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); - } + if(provider == null) provider.getBuffer(RenderType.solid()); // just to try to refresh it - List zappyRenderSpace = staticPoints.scaleVecs(zappyPattern); + float dotZ = 0.0004f; - if(FastColor.ARGB32.alpha(patColors.outerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.outerStartColor) != 0){ - RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), - patColors.outerEndColor, patColors.outerStartColor, new SillyVCHelper(provider, ps, light, normalVec, 0.001f, patColors.outerStartColor)); + if(FastColor.ARGB32.alpha(patColors.startingDotColor) != 0) { + RenderLib.drawSpot(ps.last().pose(), staticPoints.dotsScaled.get(0), patSets.startingDotRadiusProvider.apply((float) (staticPoints.finalScale)), + patColors.startingDotColor, new SillyVCHelper(provider, ps, light, normalVec, dotZ, patColors.innerStartColor)); } - if(FastColor.ARGB32.alpha(patColors.innerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.innerStartColor) != 0) { - RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.innerWidthProvider.apply((float) (staticPoints.finalScale)), - patColors.innerEndColor, patColors.innerStartColor, new SillyVCHelper(provider, ps, light, normalVec, 0.0005f, patColors.innerStartColor)); + + if(FastColor.ARGB32.alpha(patColors.gridDotsColor) != 0) { + for(int i = 1; i < staticPoints.dotsScaled.size(); i++){ + Vec2 gridDot = staticPoints.dotsScaled.get(i); + RenderLib.drawSpot(ps.last().pose(), gridDot, patSets.gridDotsRadiusProvider.apply((float) (staticPoints.finalScale)), + patColors.gridDotsColor, new SillyVCHelper(provider, ps, light, normalVec, dotZ, patColors.innerStartColor)); + } } - ps.popPose(); RenderSystem.setShader(() -> oldShader); } @@ -83,26 +101,29 @@ private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @N HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); - VertexConsumer vc; - if(FastColor.ARGB32.alpha(patColors.outerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.outerStartColor) != 0) { + + float outerZ = 0.001f; + float innerZ = 0.0005f; + + if(FastColor.ARGB32.alpha(patColors.outerStartColor) != 0) { vc = setupVC(provider, textures.get("outer")); - textureVertex(vc, ps, 0, 0, 0.0005f, 0, 0, normalVec, light, patColors.outerStartColor); - textureVertex(vc, ps, 0, (float) staticPoints.fullHeight, 0.0005f, 0, 1, normalVec, light, patColors.outerStartColor); - textureVertex(vc, ps, (float) staticPoints.fullWidth, (float) staticPoints.fullHeight, 0, 1, 1, normalVec, light, patColors.outerStartColor); - textureVertex(vc, ps, (float) staticPoints.fullWidth, 0, 0.0005f, 1, 0, normalVec, light, patColors.outerStartColor); + textureVertex(vc, ps, 0, 0, outerZ, 0, 0, normalVec, light, patColors.outerStartColor); + textureVertex(vc, ps, 0, (float) staticPoints.fullHeight, outerZ, 0, 1, normalVec, light, patColors.outerStartColor); + textureVertex(vc, ps, (float) staticPoints.fullWidth, (float) staticPoints.fullHeight, outerZ, 1, 1, normalVec, light, patColors.outerStartColor); + textureVertex(vc, ps, (float) staticPoints.fullWidth, 0, outerZ, 1, 0, normalVec, light, patColors.outerStartColor); endDraw(provider, textures.get("outer"), vc); } - if(FastColor.ARGB32.alpha(patColors.innerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.innerStartColor) != 0) { + if(FastColor.ARGB32.alpha(patColors.innerStartColor) != 0) { vc = setupVC(provider, textures.get("inner")); - textureVertex(vc, ps, 0, 0, 0.001f, 0, 0, normalVec, light, patColors.innerStartColor); - textureVertex(vc, ps, 0, (float) staticPoints.fullHeight, 0.001f, 0, 1, normalVec, light, patColors.innerStartColor); - textureVertex(vc, ps, (float) staticPoints.fullWidth, (float) staticPoints.fullHeight, 0.001f, 1, 1, normalVec, light, patColors.innerStartColor); - textureVertex(vc, ps, (float) staticPoints.fullWidth, 0, 0.001f, 1, 0, normalVec, light, patColors.innerStartColor); + textureVertex(vc, ps, 0, 0, innerZ, 0, 0, normalVec, light, patColors.innerStartColor); + textureVertex(vc, ps, 0, (float) staticPoints.fullHeight, innerZ, 0, 1, normalVec, light, patColors.innerStartColor); + textureVertex(vc, ps, (float) staticPoints.fullWidth, (float) staticPoints.fullHeight, innerZ, 1, 1, normalVec, light, patColors.innerStartColor); + textureVertex(vc, ps, (float) staticPoints.fullWidth, 0, innerZ, 1, 0, normalVec, light, patColors.innerStartColor); endDraw(provider, textures.get("inner"), vc); } @@ -137,7 +158,7 @@ private static void endDraw(@Nullable MultiBufferSource provider, ResourceLocati } private static void textureVertex(VertexConsumer vc, PoseStack ps, float x, float y, float z, float u, float v, Vec3 normals, int light, int color){ - vc.vertex(ps.last().pose(), x, y, 0) + vc.vertex(ps.last().pose(), x, y, z) .color(color) .uv(u, v) .overlayCoords(OverlayTexture.NO_OVERLAY) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/RenderLib.kt b/Common/src/main/java/at/petrak/hexcasting/client/render/RenderLib.kt index bfb873a620..823068439f 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/RenderLib.kt +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/RenderLib.kt @@ -353,12 +353,12 @@ fun findDupIndices(pts: Iterable): Set { * include primitive drawing code... */ fun drawSpot(mat: Matrix4f, point: Vec2, radius: Float, r: Float, g: Float, b: Float, a: Float) { - val tess = Tesselator.getInstance() - val buf = tess.builder - // https://stackoverflow.com/questions/20394727/gl-triangle-strip-vs-gl-triangle-fan - // Starting point is the center - buf.begin(VertexFormat.Mode.TRIANGLE_FAN, DefaultVertexFormat.POSITION_COLOR) - buf.vertex(mat, point.x, point.y, 1f).color(r, g, b, a).endVertex() + drawSpot(mat, point, radius, ARGB32.color((a*255).toInt(), (r*255).toInt(), (g*255).toInt(), (b*255).toInt()), VCDrawHelper.Basic(1f)) +} + +fun drawSpot(mat: Matrix4f, point: Vec2, radius: Float, color: Int, vcHelper: VCDrawHelper) { + var vc = vcHelper.vcSetupAndSupply(VertexFormat.Mode.TRIANGLE_FAN); + vcHelper.vertex(vc, color, point, mat) // https://github.com/not-fl3/macroquad/blob/master/src/shapes.rs#L98 // yes they are gonna be little hexagons fite me @@ -368,10 +368,10 @@ fun drawSpot(mat: Matrix4f, point: Vec2, radius: Float, r: Float, g: Float, b: F val theta = i.toFloat() / fracOfCircle * TAU.toFloat() val rx = Mth.cos(theta) * radius + point.x val ry = Mth.sin(theta) * radius + point.y - buf.vertex(mat, rx, ry, 1f).color(r, g, b, a).endVertex() + vcHelper.vertex(vc, color, Vec2(rx, ry), mat) } - tess.end() + vcHelper.vcEndDrawer(vc) } fun screenCol(n: Int): Int { diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index e984582c16..3021764cfe 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -27,12 +27,12 @@ public class WorldlyPatternRenderHelpers { public static final PatternRenderSettings WORLDLY_RENDER_SETTINGS = new PatternRenderSettings() - .withSizings(PatternRenderSettings.FitAxis.BOTH, 1.0, 1.0, 1.0/16, 1.0/16, 0.25, null, null, - (scale) -> 0.4f/16, (scale) -> 0.8f/16) + .withSizings(PatternRenderSettings.FitAxis.BOTH, 1.0, 1.0, 1.0/16, 1.0/16, 0.25, null, null) + .withWidths((scale) -> 0.4f/16, (scale) -> 0.8f/16) .named("worldly"); public static final PatternRenderSettings SCROLL_RENDER_SETTINGS = WORLDLY_RENDER_SETTINGS.withSizings(null, null, null, - 2.0/16, 2.0/16, null, null, null, null, null) + 2.0/16, 2.0/16, null, null, null) .named("wallscroll"); public static final PatternRenderSettings READABLE_SCROLL_RENDER_SETTINGS = SCROLL_RENDER_SETTINGS.withZappySettings( @@ -47,12 +47,17 @@ public class WorldlyPatternRenderHelpers { // using an opaque inner color based on 0xc8_322b33 because worldly pattern renderer is funky public static final PatternColors DEFAULT_PATTERN_COLOR = new PatternColors(0xff_554d54, 0xff_d2c8c8); + // partially for testing + public static final PatternColors READABLE_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDotColors(0xff_5b7bd7, 0); + public static final PatternColors SLATE_WOBBLY_COLOR = new PatternColors(RenderLib.screenCol(0xff_64c8ff), 0xff_64c8ff); public static void renderPatternForScroll(HexPattern pattern, EntityWallScroll scroll, PoseStack ps, MultiBufferSource bufSource, int light, int blockSize, boolean showStrokeOrder) { ps.pushPose(); - renderPattern(pattern, showStrokeOrder ? READABLE_SCROLL_RENDER_SETTINGS : SCROLL_RENDER_SETTINGS, DEFAULT_PATTERN_COLOR, scroll.getPos().hashCode(), ps, bufSource, light, blockSize, true, false,false, true,-1); + renderPattern(pattern, showStrokeOrder ? READABLE_SCROLL_RENDER_SETTINGS : SCROLL_RENDER_SETTINGS, + showStrokeOrder ? READABLE_SCROLL_COLORS : DEFAULT_PATTERN_COLOR, + scroll.getPos().hashCode(), ps, bufSource, light, blockSize, true, false,false, true,-1); ps.popPose(); } @@ -187,6 +192,18 @@ public interface PSTransformer{ public static final PSTransformer wallScrollTransformer = (ps, facing, blockSize) -> { ps.translate(-blockSize / 2f, -blockSize / 2f, 1f / 32f); + if(facing == 0){ + return new Vec3(0, 0, -1); + } + if(facing == 1){ + return new Vec3(-1, 0, 0); + } + if(facing == 2){ + return new Vec3(0, 0, -1); + } + if(facing == 3){ + return new Vec3(-1, 0, 0); + } return new Vec3(0, 0, -1); }; diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index 07bf5572f4..7894235bf8 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -19,8 +19,8 @@ public ResourceLocation getId(){ } public static final PatternRenderSettings INLINE_RENDER_SETTINGS = new PatternRenderSettings() - .withSizings(PatternRenderSettings.FitAxis.VERT, 8.0, 9.0, 1.0, 0.5, 4.0, null, null, - (scale) -> 1f, null) + .withSizings(PatternRenderSettings.FitAxis.VERT, 8.0, 9.0, 1.0, 0.5, 4.0, null, null) + .withWidths((scale) -> 1f, null) .withZappySettings(null, 0f, 0f, 0f, 0f, null) .named("inline"); From 95a44b8c75b983e449c6399724adf7179a7f6064 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Wed, 17 Jul 2024 20:11:24 -0400 Subject: [PATCH 24/48] add cloth config to forge runtime so inline is happy and datagen is fixed --- Fabric/gradle.properties | 1 - .../19f2b40f78e342d65a8cb499a41e3fcb2eadaca3 | 116 ++--- .../2ba8da2cf2d44ff18dc72cc891b094eca6836a5c | 50 +- .../3cb4ab563deee432e7d307024048f57946bafb1c | 8 +- .../812fdb58b7018b2d5c5af7da57a2b1857fa66794 | 64 +-- .../c70ef2fe5da52437c1f53bcc9ea0e416f16bcc0b | 436 +++++++++--------- Forge/build.gradle | 3 + gradle.properties | 3 +- 8 files changed, 342 insertions(+), 339 deletions(-) diff --git a/Fabric/gradle.properties b/Fabric/gradle.properties index 403ee97acd..912673b4a7 100644 --- a/Fabric/gradle.properties +++ b/Fabric/gradle.properties @@ -11,7 +11,6 @@ emiVersion=1.0.4+1.20.1 #gravityApiVersion=1.0.6 trinketsVersion=3.7.0 -clothConfigVersion=11.1.106 modmenuVersion=7.0.1 # Optimizations diff --git a/Fabric/src/generated/resources/.cache/19f2b40f78e342d65a8cb499a41e3fcb2eadaca3 b/Fabric/src/generated/resources/.cache/19f2b40f78e342d65a8cb499a41e3fcb2eadaca3 index 8c5031dfbe..b5b89b78ec 100644 --- a/Fabric/src/generated/resources/.cache/19f2b40f78e342d65a8cb499a41e3fcb2eadaca3 +++ b/Fabric/src/generated/resources/.cache/19f2b40f78e342d65a8cb499a41e3fcb2eadaca3 @@ -1,58 +1,58 @@ -// 1.20.1 2024-06-13T19:17:10.5236232 Hex Casting/Loot Tables -b19ac49146149555038e6d2e06200d514df1ef43 data\hexcasting\loot_tables\blocks\akashic_bookshelf.json -b6c23fdde4f2c22c81f008604d5ff1c32ca8eb61 data\hexcasting\loot_tables\blocks\amethyst_tiles.json -df5496da8e48b61a171bc7a3936495c016cc002e data\hexcasting\loot_tables\blocks\directrix\empty.json -74159c21634679a6ab1dde1c181433db8b31c6ae data\hexcasting\loot_tables\blocks\edified_log_citrine.json -cc7313cc33609fe1120baa7b4db631eaa29fbba1 data\hexcasting\loot_tables\blocks\citrine_edified_leaves.json -847bc3ead8a88a8f210a24e7732c28d50aa2f5dc data\hexcasting\loot_tables\blocks\edified_planks.json -49940d1cb2599212e2837d7ed66c6c66e54f80f8 data\hexcasting\loot_tables\blocks\akashic_record.json -7123b1a0469d7bd5bf8a2772182d222bf354df1a data\hexcasting\loot_tables\blocks\slate_bricks_small.json -95be0cf7f277257671631929462131b6d611119a data\hexcasting\loot_tables\inject\amethyst_cluster.json -d16fa9e366d48646686470c2d1f9bda4db3a1afa data\hexcasting\loot_tables\blocks\ancient_scroll_paper.json -2902c4dae60875a1b2daf0a948a49a3419d8ec9d data\hexcasting\loot_tables\blocks\edified_log.json -b706c8a064f717c57104c48ea42aa860b45cf7a4 data\hexcasting\loot_tables\blocks\amethyst_dust_block.json -c81a5cb81141ab1fe09dd5dd3a0968b69dfffbd7 data\hexcasting\loot_tables\blocks\stripped_edified_log.json -0b734693c926045b60fb515814b7a6695d0295fc data\hexcasting\loot_tables\blocks\impetus\look.json -6c35afda4ca349f3506fe08f86f0afe58a6f2c44 data\hexcasting\loot_tables\blocks\quenched_allay.json -9ff760d5db5628328ea9274c98e18a08f1ab983e data\hexcasting\loot_tables\blocks\slate_block.json -ecaeb4d5703a7aa206627ed38ee71aeb7e93d688 data\hexcasting\loot_tables\blocks\impetus\rightclick.json -44658abcf122575878834d276ebcf5d8a6b7b398 data\hexcasting\loot_tables\blocks\aventurine_edified_leaves.json -4efd95d408d050c36ff21b18f3c37116491fef92 data\hexcasting\loot_tables\blocks\directrix\redstone.json -434c2a6d2645e56e9a6ca56249ffa84645558e3b data\hexcasting\loot_tables\blocks\quenched_allay_bricks_small.json -bedbc2bd04f79372aedea64214ba2ea49cde9640 data\hexcasting\loot_tables\blocks\amethyst_edified_leaves.json -ab86e126a704550d3f21c0b43f99fdc2665e4b09 data\hexcasting\loot_tables\blocks\slate_amethyst_tiles.json -6eecc98b606d7ea5ec6f4c1fa4f63f7c1eba9223 data\hexcasting\loot_tables\blocks\slate_amethyst_bricks.json -2ac70e3c3600c88b2544d9755fc634216a7a523c data\hexcasting\loot_tables\blocks\edified_wood.json -92331eb19422730ffda0a3e52427a75aa1f7aff2 data\hexcasting\loot_tables\blocks\ancient_scroll_paper_lantern.json -c426245d51f1e0fa0db7c4bfb454284d75506c9c data\hexcasting\loot_tables\blocks\quenched_allay_bricks.json -dc4c6d270b8e93d05ac8ddeb1b9dd1d64828ac5d data\hexcasting\loot_tables\blocks\stripped_edified_wood.json -1dd4268edf7d6fa247013ab45541c7bfb915eef8 data\hexcasting\loot_tables\blocks\amethyst_bricks_small.json -849afa706e7479d1c11bb40ae223ae5833e71286 data\hexcasting\loot_tables\blocks\scroll_paper_lantern.json -45ae0ec668a07aa5b33d491377b2978f69f9f019 data\hexcasting\loot_tables\blocks\edified_panel.json -e6ff979aa47877c1b807075c448defd249cd3484 data\hexcasting\loot_tables\blocks\slate_amethyst_pillar.json -65fe724d4c4ba8b0ab7d7a11bf37687413d9119d data\hexcasting\loot_tables\blocks\edified_fence.json -a4e0194d8966a24531e43e04437cdb2a96456898 data\hexcasting\loot_tables\blocks\edified_tile.json -509ecbb9731e75b63638c6012b2f986f131fd42f data\hexcasting\loot_tables\blocks\slate_amethyst_bricks_small.json -601384d888edab27efe4a33027bb557eb7cb6ca2 data\hexcasting\loot_tables\blocks\edified_log_purple.json -1a1236e54c24b5aeff05919c73c76151da2cf115 data\hexcasting\loot_tables\blocks\amethyst_sconce.json -5f8d09e8c759d05cf9c2265ae28ea942cfbbe2be data\hexcasting\loot_tables\blocks\edified_pressure_plate.json -147e0739a712a9050856cebcad1757b3f418f647 data\hexcasting\loot_tables\blocks\edified_trapdoor.json -55f265961463a89c243ec8ac1970c70185f064a6 data\hexcasting\loot_tables\blocks\edified_button.json -f1145860d80ff053970b1ad4f3b2f5d9f28e7c73 data\hexcasting\loot_tables\blocks\directrix\boolean.json -2ab674e834184b4e17dc002556d4473cac137445 data\hexcasting\loot_tables\blocks\edified_slab.json -c15d3ced89c882dfe552f84435fcdd560b729567 data\hexcasting\loot_tables\blocks\scroll_paper.json -8c6c0486170537d73b923a2b9f83722107fc8716 data\hexcasting\loot_tables\blocks\edified_log_aventurine.json -6920654f50532b5e557646e34edc4872339eb79f data\hexcasting\loot_tables\blocks\edified_log_amethyst.json -9905b767be7849e02a8e4ec4170af1bdde4e7fab data\hexcasting\loot_tables\blocks\edified_stairs.json -30f06db8c1ea74c9f4d95474e412336d065ac888 data\hexcasting\loot_tables\blocks\edified_door.json -2ad288784b0dc106ace2e6e0a40669f83476c414 data\hexcasting\loot_tables\blocks\slate.json -92528799c8ee13ff26c3c505e4dfb286c30f97c7 data\hexcasting\loot_tables\blocks\akashic_connector.json -8ea8fd68719a960c2e132df441564a70c0e376a8 data\hexcasting\loot_tables\blocks\amethyst_pillar.json -45dc91d820caa5c421fe6f2afc7f71e45d6acd4d data\hexcasting\loot_tables\blocks\slate_pillar.json -10cb1b94596ac7131efe3bd5c36c1543ddba9302 data\hexcasting\loot_tables\blocks\impetus\redstone.json -499af9f15cf0a7f16fd2939e5d3af60a8089cc3e data\hexcasting\loot_tables\blocks\slate_bricks.json -2c9af74a82ca462e5986354966d5a0a1fd5a2083 data\hexcasting\loot_tables\blocks\slate_tiles.json -cf6ff1ed1ee6fdbb05af16468a0a0ced79ac334e data\hexcasting\loot_tables\blocks\amethyst_bricks.json -7c9c94d5b6b570d25eff32d4fa2ecc1e842e5231 data\hexcasting\loot_tables\blocks\quenched_allay_tiles.json -a62ffbcec2aa40172e05cd9fcd8e70e295d008e9 data\hexcasting\loot_tables\blocks\edified_fence_gate.json -1c6b077aae560e780be29e74ddcd4b0ca10ce3cf data\hexcasting\loot_tables\blocks\impetus\empty.json +// 1.20.1 2024-07-17T19:52:53.355984 Hex Casting/Loot Tables +c81a5cb81141ab1fe09dd5dd3a0968b69dfffbd7 data/hexcasting/loot_tables/blocks/stripped_edified_log.json +b706c8a064f717c57104c48ea42aa860b45cf7a4 data/hexcasting/loot_tables/blocks/amethyst_dust_block.json +6c35afda4ca349f3506fe08f86f0afe58a6f2c44 data/hexcasting/loot_tables/blocks/quenched_allay.json +8c6c0486170537d73b923a2b9f83722107fc8716 data/hexcasting/loot_tables/blocks/edified_log_aventurine.json +4efd95d408d050c36ff21b18f3c37116491fef92 data/hexcasting/loot_tables/blocks/directrix/redstone.json +601384d888edab27efe4a33027bb557eb7cb6ca2 data/hexcasting/loot_tables/blocks/edified_log_purple.json +847bc3ead8a88a8f210a24e7732c28d50aa2f5dc data/hexcasting/loot_tables/blocks/edified_planks.json +b19ac49146149555038e6d2e06200d514df1ef43 data/hexcasting/loot_tables/blocks/akashic_bookshelf.json +5f8d09e8c759d05cf9c2265ae28ea942cfbbe2be data/hexcasting/loot_tables/blocks/edified_pressure_plate.json +45ae0ec668a07aa5b33d491377b2978f69f9f019 data/hexcasting/loot_tables/blocks/edified_panel.json +ecaeb4d5703a7aa206627ed38ee71aeb7e93d688 data/hexcasting/loot_tables/blocks/impetus/rightclick.json +c15d3ced89c882dfe552f84435fcdd560b729567 data/hexcasting/loot_tables/blocks/scroll_paper.json +45dc91d820caa5c421fe6f2afc7f71e45d6acd4d data/hexcasting/loot_tables/blocks/slate_pillar.json +dc4c6d270b8e93d05ac8ddeb1b9dd1d64828ac5d data/hexcasting/loot_tables/blocks/stripped_edified_wood.json +49940d1cb2599212e2837d7ed66c6c66e54f80f8 data/hexcasting/loot_tables/blocks/akashic_record.json +74159c21634679a6ab1dde1c181433db8b31c6ae data/hexcasting/loot_tables/blocks/edified_log_citrine.json +0b734693c926045b60fb515814b7a6695d0295fc data/hexcasting/loot_tables/blocks/impetus/look.json +1c6b077aae560e780be29e74ddcd4b0ca10ce3cf data/hexcasting/loot_tables/blocks/impetus/empty.json +d16fa9e366d48646686470c2d1f9bda4db3a1afa data/hexcasting/loot_tables/blocks/ancient_scroll_paper.json +b6c23fdde4f2c22c81f008604d5ff1c32ca8eb61 data/hexcasting/loot_tables/blocks/amethyst_tiles.json +10cb1b94596ac7131efe3bd5c36c1543ddba9302 data/hexcasting/loot_tables/blocks/impetus/redstone.json +8ea8fd68719a960c2e132df441564a70c0e376a8 data/hexcasting/loot_tables/blocks/amethyst_pillar.json +434c2a6d2645e56e9a6ca56249ffa84645558e3b data/hexcasting/loot_tables/blocks/quenched_allay_bricks_small.json +30f06db8c1ea74c9f4d95474e412336d065ac888 data/hexcasting/loot_tables/blocks/edified_door.json +95be0cf7f277257671631929462131b6d611119a data/hexcasting/loot_tables/inject/amethyst_cluster.json +65fe724d4c4ba8b0ab7d7a11bf37687413d9119d data/hexcasting/loot_tables/blocks/edified_fence.json +849afa706e7479d1c11bb40ae223ae5833e71286 data/hexcasting/loot_tables/blocks/scroll_paper_lantern.json +2902c4dae60875a1b2daf0a948a49a3419d8ec9d data/hexcasting/loot_tables/blocks/edified_log.json +a62ffbcec2aa40172e05cd9fcd8e70e295d008e9 data/hexcasting/loot_tables/blocks/edified_fence_gate.json +509ecbb9731e75b63638c6012b2f986f131fd42f data/hexcasting/loot_tables/blocks/slate_amethyst_bricks_small.json +2ac70e3c3600c88b2544d9755fc634216a7a523c data/hexcasting/loot_tables/blocks/edified_wood.json +9905b767be7849e02a8e4ec4170af1bdde4e7fab data/hexcasting/loot_tables/blocks/edified_stairs.json +1dd4268edf7d6fa247013ab45541c7bfb915eef8 data/hexcasting/loot_tables/blocks/amethyst_bricks_small.json +2ad288784b0dc106ace2e6e0a40669f83476c414 data/hexcasting/loot_tables/blocks/slate.json +55f265961463a89c243ec8ac1970c70185f064a6 data/hexcasting/loot_tables/blocks/edified_button.json +bedbc2bd04f79372aedea64214ba2ea49cde9640 data/hexcasting/loot_tables/blocks/amethyst_edified_leaves.json +a4e0194d8966a24531e43e04437cdb2a96456898 data/hexcasting/loot_tables/blocks/edified_tile.json +9ff760d5db5628328ea9274c98e18a08f1ab983e data/hexcasting/loot_tables/blocks/slate_block.json +92331eb19422730ffda0a3e52427a75aa1f7aff2 data/hexcasting/loot_tables/blocks/ancient_scroll_paper_lantern.json +6eecc98b606d7ea5ec6f4c1fa4f63f7c1eba9223 data/hexcasting/loot_tables/blocks/slate_amethyst_bricks.json +2c9af74a82ca462e5986354966d5a0a1fd5a2083 data/hexcasting/loot_tables/blocks/slate_tiles.json +7c9c94d5b6b570d25eff32d4fa2ecc1e842e5231 data/hexcasting/loot_tables/blocks/quenched_allay_tiles.json +c426245d51f1e0fa0db7c4bfb454284d75506c9c data/hexcasting/loot_tables/blocks/quenched_allay_bricks.json +2ab674e834184b4e17dc002556d4473cac137445 data/hexcasting/loot_tables/blocks/edified_slab.json +ab86e126a704550d3f21c0b43f99fdc2665e4b09 data/hexcasting/loot_tables/blocks/slate_amethyst_tiles.json +92528799c8ee13ff26c3c505e4dfb286c30f97c7 data/hexcasting/loot_tables/blocks/akashic_connector.json +7123b1a0469d7bd5bf8a2772182d222bf354df1a data/hexcasting/loot_tables/blocks/slate_bricks_small.json +44658abcf122575878834d276ebcf5d8a6b7b398 data/hexcasting/loot_tables/blocks/aventurine_edified_leaves.json +e6ff979aa47877c1b807075c448defd249cd3484 data/hexcasting/loot_tables/blocks/slate_amethyst_pillar.json +6920654f50532b5e557646e34edc4872339eb79f data/hexcasting/loot_tables/blocks/edified_log_amethyst.json +df5496da8e48b61a171bc7a3936495c016cc002e data/hexcasting/loot_tables/blocks/directrix/empty.json +cc7313cc33609fe1120baa7b4db631eaa29fbba1 data/hexcasting/loot_tables/blocks/citrine_edified_leaves.json +f1145860d80ff053970b1ad4f3b2f5d9f28e7c73 data/hexcasting/loot_tables/blocks/directrix/boolean.json +499af9f15cf0a7f16fd2939e5d3af60a8089cc3e data/hexcasting/loot_tables/blocks/slate_bricks.json +147e0739a712a9050856cebcad1757b3f418f647 data/hexcasting/loot_tables/blocks/edified_trapdoor.json +cf6ff1ed1ee6fdbb05af16468a0a0ced79ac334e data/hexcasting/loot_tables/blocks/amethyst_bricks.json +1a1236e54c24b5aeff05919c73c76151da2cf115 data/hexcasting/loot_tables/blocks/amethyst_sconce.json diff --git a/Fabric/src/generated/resources/.cache/2ba8da2cf2d44ff18dc72cc891b094eca6836a5c b/Fabric/src/generated/resources/.cache/2ba8da2cf2d44ff18dc72cc891b094eca6836a5c index 4ab33a45b7..b5e4f501e8 100644 --- a/Fabric/src/generated/resources/.cache/2ba8da2cf2d44ff18dc72cc891b094eca6836a5c +++ b/Fabric/src/generated/resources/.cache/2ba8da2cf2d44ff18dc72cc891b094eca6836a5c @@ -1,25 +1,25 @@ -// 1.20.1 2024-06-13T19:17:10.5291355 Hex Casting/Tags for minecraft:item -20183cd61968ff6548df2dde1100b6378d68d64b data\minecraft\tags\items\buttons.json -e186f43ed06770e698c886691f91b2c6acdb5a2a data\hexcasting\tags\items\seal_materials.json -38d781b60c5c37dc025d4c7e9ec5aa680f2a5835 data\c\tags\items\gems.json -c562b4be24d0b6b13f3c65599d3bfa3bf2c4ce21 data\minecraft\tags\items\logs.json -5bbfd513fd2eb2090b0c2d1ec33504deb79d53b9 data\minecraft\tags\items\slabs.json -c72a147bc65d26424df199388969ebd11119aed3 data\hexcasting\tags\items\brainswept_circle_components.json -20183cd61968ff6548df2dde1100b6378d68d64b data\minecraft\tags\items\wooden_buttons.json -c562b4be24d0b6b13f3c65599d3bfa3bf2c4ce21 data\minecraft\tags\items\logs_that_burn.json -e5df19a1dc6eadf14cd9b0f0fe45a74330b745e9 data\minecraft\tags\items\planks.json -5216ba5c57db29b8dee9aebc63a2e3b17c97dc17 data\minecraft\tags\items\wooden_trapdoors.json -e5df19a1dc6eadf14cd9b0f0fe45a74330b745e9 data\hexcasting\tags\items\edified_planks.json -c562b4be24d0b6b13f3c65599d3bfa3bf2c4ce21 data\hexcasting\tags\items\edified_logs.json -9d18fb7a889031a704ca0e553600e1d6f8c3759d data\hexcasting\tags\items\directrices.json -24145229528668829a1bcecf18a6377ebd07ccf8 data\hexcasting\tags\items\grants_root_advancement.json -5216ba5c57db29b8dee9aebc63a2e3b17c97dc17 data\minecraft\tags\items\trapdoors.json -37cff4ce449b8069b59b2327d78e073fc026d348 data\minecraft\tags\items\wooden_pressure_plates.json -4461ef6db41a675fd077dd833cfd0ea537e755be data\c\tags\items\amethyst_dusts.json -5bbfd513fd2eb2090b0c2d1ec33504deb79d53b9 data\minecraft\tags\items\wooden_slabs.json -5f3b600b4fd98744bd08c993ce7bcb9c2f195cd2 data\minecraft\tags\items\leaves.json -fdb48f194d7937ab6b423fa4b90a4d438bf6dd90 data\minecraft\tags\items\doors.json -fdb48f194d7937ab6b423fa4b90a4d438bf6dd90 data\minecraft\tags\items\wooden_doors.json -bdb90cee0e88e02f0b98f12d5dd212adfaca9afd data\hexcasting\tags\items\impeti.json -5928bad07d3872bb60f29ef4f3c885c8e1967c20 data\hexcasting\tags\items\phial_base.json -30780136e6469a01369d7e278998edb6d7f6a16b data\hexcasting\tags\items\staves.json +// 1.20.1 2024-07-17T19:52:53.358996 Hex Casting/Tags for minecraft:item +e186f43ed06770e698c886691f91b2c6acdb5a2a data/hexcasting/tags/items/seal_materials.json +5bbfd513fd2eb2090b0c2d1ec33504deb79d53b9 data/minecraft/tags/items/wooden_slabs.json +c562b4be24d0b6b13f3c65599d3bfa3bf2c4ce21 data/hexcasting/tags/items/edified_logs.json +5928bad07d3872bb60f29ef4f3c885c8e1967c20 data/hexcasting/tags/items/phial_base.json +20183cd61968ff6548df2dde1100b6378d68d64b data/minecraft/tags/items/wooden_buttons.json +30780136e6469a01369d7e278998edb6d7f6a16b data/hexcasting/tags/items/staves.json +9d18fb7a889031a704ca0e553600e1d6f8c3759d data/hexcasting/tags/items/directrices.json +37cff4ce449b8069b59b2327d78e073fc026d348 data/minecraft/tags/items/wooden_pressure_plates.json +bdb90cee0e88e02f0b98f12d5dd212adfaca9afd data/hexcasting/tags/items/impeti.json +38d781b60c5c37dc025d4c7e9ec5aa680f2a5835 data/c/tags/items/gems.json +c72a147bc65d26424df199388969ebd11119aed3 data/hexcasting/tags/items/brainswept_circle_components.json +fdb48f194d7937ab6b423fa4b90a4d438bf6dd90 data/minecraft/tags/items/doors.json +4461ef6db41a675fd077dd833cfd0ea537e755be data/c/tags/items/amethyst_dusts.json +e5df19a1dc6eadf14cd9b0f0fe45a74330b745e9 data/minecraft/tags/items/planks.json +c562b4be24d0b6b13f3c65599d3bfa3bf2c4ce21 data/minecraft/tags/items/logs.json +fdb48f194d7937ab6b423fa4b90a4d438bf6dd90 data/minecraft/tags/items/wooden_doors.json +24145229528668829a1bcecf18a6377ebd07ccf8 data/hexcasting/tags/items/grants_root_advancement.json +5f3b600b4fd98744bd08c993ce7bcb9c2f195cd2 data/minecraft/tags/items/leaves.json +c562b4be24d0b6b13f3c65599d3bfa3bf2c4ce21 data/minecraft/tags/items/logs_that_burn.json +5216ba5c57db29b8dee9aebc63a2e3b17c97dc17 data/minecraft/tags/items/trapdoors.json +e5df19a1dc6eadf14cd9b0f0fe45a74330b745e9 data/hexcasting/tags/items/edified_planks.json +20183cd61968ff6548df2dde1100b6378d68d64b data/minecraft/tags/items/buttons.json +5bbfd513fd2eb2090b0c2d1ec33504deb79d53b9 data/minecraft/tags/items/slabs.json +5216ba5c57db29b8dee9aebc63a2e3b17c97dc17 data/minecraft/tags/items/wooden_trapdoors.json diff --git a/Fabric/src/generated/resources/.cache/3cb4ab563deee432e7d307024048f57946bafb1c b/Fabric/src/generated/resources/.cache/3cb4ab563deee432e7d307024048f57946bafb1c index b98bee8dbf..25b80572fb 100644 --- a/Fabric/src/generated/resources/.cache/3cb4ab563deee432e7d307024048f57946bafb1c +++ b/Fabric/src/generated/resources/.cache/3cb4ab563deee432e7d307024048f57946bafb1c @@ -1,4 +1,4 @@ -// 1.20.1 2024-06-13T19:17:10.5351337 Hex Casting/Tags for hexcasting:action -6fe30f41e2bcd48589caab26d210a513dce1ab7c data\hexcasting\tags\action\requires_enlightenment.json -6fe30f41e2bcd48589caab26d210a513dce1ab7c data\hexcasting\tags\action\per_world_pattern.json -6fe30f41e2bcd48589caab26d210a513dce1ab7c data\hexcasting\tags\action\can_start_enlighten.json +// 1.20.1 2024-07-17T19:52:53.362581 Hex Casting/Tags for hexcasting:action +6fe30f41e2bcd48589caab26d210a513dce1ab7c data/hexcasting/tags/action/per_world_pattern.json +6fe30f41e2bcd48589caab26d210a513dce1ab7c data/hexcasting/tags/action/requires_enlightenment.json +6fe30f41e2bcd48589caab26d210a513dce1ab7c data/hexcasting/tags/action/can_start_enlighten.json diff --git a/Fabric/src/generated/resources/.cache/812fdb58b7018b2d5c5af7da57a2b1857fa66794 b/Fabric/src/generated/resources/.cache/812fdb58b7018b2d5c5af7da57a2b1857fa66794 index cb9ce27405..3c4302f8b1 100644 --- a/Fabric/src/generated/resources/.cache/812fdb58b7018b2d5c5af7da57a2b1857fa66794 +++ b/Fabric/src/generated/resources/.cache/812fdb58b7018b2d5c5af7da57a2b1857fa66794 @@ -1,32 +1,32 @@ -// 1.20.1 2024-06-13T19:17:10.5266238 Hex Casting/Tags for minecraft:block -c562b4be24d0b6b13f3c65599d3bfa3bf2c4ce21 data\minecraft\tags\blocks\logs_that_burn.json -7e1e353cb7f561f086898f991ece48e047991934 data\minecraft\tags\blocks\fence_gates.json -e5df19a1dc6eadf14cd9b0f0fe45a74330b745e9 data\hexcasting\tags\blocks\edified_planks.json -7e1e353cb7f561f086898f991ece48e047991934 data\minecraft\tags\blocks\unstable_bottom_center.json -357eddf3cee6f16725bed0701d57b2ca3097d74d data\minecraft\tags\blocks\mineable\shovel.json -c562b4be24d0b6b13f3c65599d3bfa3bf2c4ce21 data\minecraft\tags\blocks\logs.json -37cff4ce449b8069b59b2327d78e073fc026d348 data\minecraft\tags\blocks\wooden_pressure_plates.json -37cff4ce449b8069b59b2327d78e073fc026d348 data\minecraft\tags\blocks\pressure_plates.json -20183cd61968ff6548df2dde1100b6378d68d64b data\minecraft\tags\blocks\wooden_buttons.json -7acae0c88f5ead65339db1b11b16f60214434c86 data\minecraft\tags\blocks\wooden_fences.json -5216ba5c57db29b8dee9aebc63a2e3b17c97dc17 data\minecraft\tags\blocks\trapdoors.json -5bbfd513fd2eb2090b0c2d1ec33504deb79d53b9 data\minecraft\tags\blocks\wooden_slabs.json -fdb48f194d7937ab6b423fa4b90a4d438bf6dd90 data\minecraft\tags\blocks\wooden_doors.json -c562b4be24d0b6b13f3c65599d3bfa3bf2c4ce21 data\hexcasting\tags\blocks\edified_logs.json -6ae561f7399e39ffa0e97bd0569aeffa9eabff6a data\hexcasting\tags\blocks\water_plants.json -e8d5ef7eabb567228b279b2419e4f042082d7491 data\minecraft\tags\blocks\fences.json -c72a147bc65d26424df199388969ebd11119aed3 data\hexcasting\tags\blocks\brainswept_circle_components.json -8cd7a960fd719f200b0bf38100cd17c73b66d39c data\minecraft\tags\blocks\mineable\pickaxe.json -5f3b600b4fd98744bd08c993ce7bcb9c2f195cd2 data\minecraft\tags\blocks\mineable\hoe.json -fdb48f194d7937ab6b423fa4b90a4d438bf6dd90 data\minecraft\tags\blocks\doors.json -e5df19a1dc6eadf14cd9b0f0fe45a74330b745e9 data\minecraft\tags\blocks\planks.json -5f3b600b4fd98744bd08c993ce7bcb9c2f195cd2 data\minecraft\tags\blocks\leaves.json -281cb08b9b68ef049820c4f3f36b40820044681e data\minecraft\tags\blocks\stairs.json -9d18fb7a889031a704ca0e553600e1d6f8c3759d data\hexcasting\tags\blocks\directrices.json -281cb08b9b68ef049820c4f3f36b40820044681e data\minecraft\tags\blocks\wooden_stairs.json -6f52ca5e42991af6d7b829f626010ce304277464 data\minecraft\tags\blocks\crystal_sound_blocks.json -5216ba5c57db29b8dee9aebc63a2e3b17c97dc17 data\minecraft\tags\blocks\wooden_trapdoors.json -20183cd61968ff6548df2dde1100b6378d68d64b data\minecraft\tags\blocks\buttons.json -bdb90cee0e88e02f0b98f12d5dd212adfaca9afd data\hexcasting\tags\blocks\impeti.json -5bbfd513fd2eb2090b0c2d1ec33504deb79d53b9 data\minecraft\tags\blocks\slabs.json -643994ee757a533cfb5001689e0f0263956b8a35 data\minecraft\tags\blocks\mineable\axe.json +// 1.20.1 2024-07-17T19:52:53.358037 Hex Casting/Tags for minecraft:block +c72a147bc65d26424df199388969ebd11119aed3 data/hexcasting/tags/blocks/brainswept_circle_components.json +e5df19a1dc6eadf14cd9b0f0fe45a74330b745e9 data/minecraft/tags/blocks/planks.json +37cff4ce449b8069b59b2327d78e073fc026d348 data/minecraft/tags/blocks/wooden_pressure_plates.json +5bbfd513fd2eb2090b0c2d1ec33504deb79d53b9 data/minecraft/tags/blocks/slabs.json +7e1e353cb7f561f086898f991ece48e047991934 data/minecraft/tags/blocks/unstable_bottom_center.json +8cd7a960fd719f200b0bf38100cd17c73b66d39c data/minecraft/tags/blocks/mineable/pickaxe.json +5f3b600b4fd98744bd08c993ce7bcb9c2f195cd2 data/minecraft/tags/blocks/leaves.json +281cb08b9b68ef049820c4f3f36b40820044681e data/minecraft/tags/blocks/wooden_stairs.json +281cb08b9b68ef049820c4f3f36b40820044681e data/minecraft/tags/blocks/stairs.json +e5df19a1dc6eadf14cd9b0f0fe45a74330b745e9 data/hexcasting/tags/blocks/edified_planks.json +7acae0c88f5ead65339db1b11b16f60214434c86 data/minecraft/tags/blocks/wooden_fences.json +20183cd61968ff6548df2dde1100b6378d68d64b data/minecraft/tags/blocks/wooden_buttons.json +c562b4be24d0b6b13f3c65599d3bfa3bf2c4ce21 data/hexcasting/tags/blocks/edified_logs.json +5f3b600b4fd98744bd08c993ce7bcb9c2f195cd2 data/minecraft/tags/blocks/mineable/hoe.json +6f52ca5e42991af6d7b829f626010ce304277464 data/minecraft/tags/blocks/crystal_sound_blocks.json +6ae561f7399e39ffa0e97bd0569aeffa9eabff6a data/hexcasting/tags/blocks/water_plants.json +20183cd61968ff6548df2dde1100b6378d68d64b data/minecraft/tags/blocks/buttons.json +37cff4ce449b8069b59b2327d78e073fc026d348 data/minecraft/tags/blocks/pressure_plates.json +5bbfd513fd2eb2090b0c2d1ec33504deb79d53b9 data/minecraft/tags/blocks/wooden_slabs.json +9d18fb7a889031a704ca0e553600e1d6f8c3759d data/hexcasting/tags/blocks/directrices.json +5216ba5c57db29b8dee9aebc63a2e3b17c97dc17 data/minecraft/tags/blocks/trapdoors.json +357eddf3cee6f16725bed0701d57b2ca3097d74d data/minecraft/tags/blocks/mineable/shovel.json +e8d5ef7eabb567228b279b2419e4f042082d7491 data/minecraft/tags/blocks/fences.json +5216ba5c57db29b8dee9aebc63a2e3b17c97dc17 data/minecraft/tags/blocks/wooden_trapdoors.json +c562b4be24d0b6b13f3c65599d3bfa3bf2c4ce21 data/minecraft/tags/blocks/logs_that_burn.json +643994ee757a533cfb5001689e0f0263956b8a35 data/minecraft/tags/blocks/mineable/axe.json +fdb48f194d7937ab6b423fa4b90a4d438bf6dd90 data/minecraft/tags/blocks/wooden_doors.json +c562b4be24d0b6b13f3c65599d3bfa3bf2c4ce21 data/minecraft/tags/blocks/logs.json +7e1e353cb7f561f086898f991ece48e047991934 data/minecraft/tags/blocks/fence_gates.json +bdb90cee0e88e02f0b98f12d5dd212adfaca9afd data/hexcasting/tags/blocks/impeti.json +fdb48f194d7937ab6b423fa4b90a4d438bf6dd90 data/minecraft/tags/blocks/doors.json diff --git a/Fabric/src/generated/resources/.cache/c70ef2fe5da52437c1f53bcc9ea0e416f16bcc0b b/Fabric/src/generated/resources/.cache/c70ef2fe5da52437c1f53bcc9ea0e416f16bcc0b index c07a79c63a..d946b09b08 100644 --- a/Fabric/src/generated/resources/.cache/c70ef2fe5da52437c1f53bcc9ea0e416f16bcc0b +++ b/Fabric/src/generated/resources/.cache/c70ef2fe5da52437c1f53bcc9ea0e416f16bcc0b @@ -1,218 +1,218 @@ -// 1.20.1 2024-06-13T19:17:10.5301427 Hex Casting/Recipes -7522be58b09554a3f1a54d5b2343c3eab01447a3 data\hexcasting\recipes\dye_colorizer_magenta.json -8b7136c206b799a2e394aa02316b0509674ff64f data\hexcasting\advancements\recipes\tools\staff\bamboo.json -92bdf87687d8823036fae6bd01782c653831286b data\hexcasting\recipes\brainsweep\impetus_look.json -5e28e2c352366720ce91b73f8c8c38e217f7198d data\hexcasting\recipes\edified_fence_gate.json -ea63e49709bd80cb9f4cd1fe13e9bd0281101c9a data\hexcasting\recipes\slate.json -3608f0ec056f2c5d29a9a89305218497fd2c4383 data\hexcasting\recipes\stonecutting\amethyst_tiles.json -0f2e63a9361d18aac764f6a4a4f13b9b862ac2ee data\hexcasting\recipes\compat\create\crushing\amethyst_shard.json -12bd3d04c791ef16aad5e992f038d6726229a436 data\hexcasting\advancements\recipes\tools\artifact.json -45915b542d8070f2502a4047218679b08033b12d data\hexcasting\advancements\recipes\decorations\scroll_paper_lantern.json -2c292e12b5e85b1701740c222e5c5465799ad1dc data\hexcasting\recipes\pride_colorizer_aroace.json -78958099bf4337ad281580d90f434b3074ad18c8 data\hexcasting\recipes\pride_colorizer_genderqueer.json -b84c113ef5321c9df9ac9080de03e8d8639feab2 data\hexcasting\advancements\recipes\misc\pride_colorizer_genderqueer.json -c2ef04b311251b4eb22320b2f5313c54533a9974 data\hexcasting\advancements\recipes\tools\staff\birch.json -499c5c09e3772989350f9ab3264b8692449a6dea data\hexcasting\advancements\recipes\misc\pride_colorizer_gay.json -f08a0aee92b281ae325d907e6fe4a3b03980f2aa data\hexcasting\advancements\recipes\tools\staff\edified.json -42b8e462de1d7006de3a7658757377450e773107 data\hexcasting\advancements\recipes\misc\dye_colorizer_blue.json -838b91c33a72a58aa286607eaaa17cdd6b4c90ba data\hexcasting\recipes\amethyst_sconce.json -8f7b81add0153ad94900acc66cd8174ae7115f64 data\hexcasting\advancements\recipes\building_blocks\slate_block_from_slates.json -b624d103d944a8a1d4d8a9e85c198a5492b476f8 data\hexcasting\advancements\recipes\redstone\edified_trapdoor.json -0e792d49c81d2164e827d1bdedaa0fa358dfc437 data\hexcasting\advancements\recipes\misc\pride_colorizer_aromantic.json -151875101066f7af5788c7a2e1c6b342971a546a data\hexcasting\recipes\compat\farmersdelight\cutting\akashic_wood.json -7f2f29981df2ca4464ee0250180e670f5331f65b data\hexcasting\recipes\dye_colorizer_pink.json -2fff80cd3dabd2bc1744eecd72b2364b0f91c7c1 data\hexcasting\advancements\recipes\misc\dye_colorizer_yellow.json -71d38559bf455ea343ac0237a57db4d3f0833a7c data\hexcasting\advancements\recipes\misc\dye_colorizer_magenta.json -b7084f131b0cdb9c2c698a3c5b3450d69e788d6e data\hexcasting\recipes\dye_colorizer_yellow.json -40ed21dc80d39236ca0e6d2cea60861c637cf931 data\hexcasting\advancements\recipes\misc\pride_colorizer_nonbinary.json -203b7035125390abb4ed77b3a4dca8f8f8f57bc5 data\hexcasting\recipes\dye_colorizer_light_gray.json -2003fed3aa4eb622b6b07a9e65946fb40be14420 data\hexcasting\advancements\recipes\brainsweep\brainsweep\impetus_rightclick.json -fb852d8e4bcfa7b75f41a6ac7dc1e76b00d95fb1 data\hexcasting\advancements\recipes\misc\dye_colorizer_red.json -e9166f40c8797cdbf3d8062dfa35c74f850f1000 data\hexcasting\advancements\recipes\misc\dye_colorizer_white.json -04902d4eca30560bc601a8196d82f74f3fa5b191 data\hexcasting\recipes\dynamicseal_spellbook.json -fb486df96798724da2fcc0df5706f19bc1ff94dc data\hexcasting\advancements\recipes\misc\dye_colorizer_light_blue.json -ed5c690324e3d9b55599f00f078ae225072a2e7f data\hexcasting\recipes\brainsweep\impetus_rightclick.json -98c0843e6a83b91820f1c720e206295eec20ff95 data\hexcasting\recipes\ancient_scroll_paper.json -9ea4fe5272ce2241d98f30359f55cfc1936c7b48 data\hexcasting\advancements\recipes\tools\staff\cherry.json -e6a592721234448f2ee7ec402bca10a9b78b4677 data\hexcasting\advancements\recipes\decorations\slate.json -775560efa36581389c0319435bda035be262ed4f data\hexcasting\advancements\recipes\building_blocks\edified_stairs.json -bc8fe4d2f55fe119b0b146a71782a3d4788380b1 data\create\recipes\crushing\amethyst_block.json -31ec6474ddae967a6c1dadf9be8292d375510364 data\hexcasting\advancements\recipes\building_blocks\edified_tile.json -5401828f85e709b5817ecc8464dc63e536a730dc data\hexcasting\recipes\staff\cherry.json -4aaefc65af5fe69d312247fdda7d983edf8dcd9a data\hexcasting\recipes\pride_colorizer_intersex.json -410bfde90cb977db3f13814e94484fa11fca7cfc data\hexcasting\recipes\thought_knot.json -011f8daf15148d4b77686c6d382d8f5c288a333d data\hexcasting\advancements\recipes\building_blocks\ancient_scroll_paper.json -c1541738df1ee41c362ad3b9c3a9f0e181bd5c62 data\hexcasting\recipes\pride_colorizer_plural.json -8815ea5d8d7379062e050adc5736cc579c3bdd9e data\hexcasting\recipes\edified_stairs.json -1ad54df5eaee3d1e810d2c91bd03f626084e30b6 data\hexcasting\recipes\edified_trapdoor.json -903cbe4d4c4e5abcd5e006f9d0237e8c596228ba data\hexcasting\recipes\edified_tile.json -5a90084c03d6e8424872870c8b65f4771b447f03 data\hexcasting\recipes\brainsweep\budding_amethyst.json -27dc4a1647f264c45b27f5552fd9403a02853484 data\hexcasting\advancements\recipes\tools\spellbook.json -09096a40275b6c49d4b4e6984869aa43b34712c3 data\hexcasting\recipes\dynamicseal_focus.json -b300f7729e75614fce412457f6717686680f81da data\hexcasting\recipes\sub_sandwich.json -eb9ebf77f0daa32f665a60888fcda19c940f0b2f data\hexcasting\advancements\recipes\misc\pride_colorizer_demigirl.json -5d6d73e16a36da5f9df6a7b8ac859181d401766d data\hexcasting\recipes\uuid_colorizer.json -de38d15e7a91c77df24c1dc954b3e98ee197876f data\hexcasting\recipes\focus.json -8e48c680b38666c2e7da71fbe4ceddf5d99a5cbc data\hexcasting\advancements\recipes\food\sub_sandwich.json -0038883bd294cc8a1b324d6782478d5e37b4dbf9 data\hexcasting\advancements\recipes\misc\dye_colorizer_pink.json -55ea553a96e1d6a54385890f7c48fe7b2bed6871 data\hexcasting\advancements\recipes\tools\trinket.json -f0e71ae8c6a9170669f44096a55a875d11497c56 data\hexcasting\recipes\staff\warped.json -93ed0491548920bc75797d18501c750ef07fe3ea data\hexcasting\advancements\recipes\misc\pride_colorizer_bisexual.json -49e706193bb57a957091e419bd0d8aa58135da1f data\hexcasting\recipes\dye_colorizer_green.json -648f1862fde1dd8ade80b2991b8c8e3991389e95 data\hexcasting\recipes\dye_colorizer_light_blue.json -a3130e3098e35b75afae4f31996d9ab7468e0bc3 data\hexcasting\advancements\recipes\tools\thought_knot.json -daa7b13d5370f4306f8cdf3037fc346e8918950a data\hexcasting\recipes\dye_colorizer_brown.json -db5ae3a2fda235cf1c83fd83e0026a262e668217 data\hexcasting\advancements\recipes\building_blocks\edified_slab.json -0b951ce7b9d1bfb07ae012b12225b595d36c6e66 data\hexcasting\recipes\amethyst_dust_packing.json -c4b985635c3b1a519d7a83da65daba5bdd3a5f59 data\hexcasting\advancements\recipes\decorations\ageing_scroll_paper_lantern.json -095aeb2882c6849f10fb6536e7c780790778e5e7 data\hexcasting\recipes\staff\jungle.json -2c56c267e23e75d5a3b9358d424d69642e001b50 data\hexcasting\recipes\decompose_quenched_shard\dust.json -7aa3bf4a3d6fb92743b29dfe89d50537fefc0db9 data\hexcasting\advancements\recipes\misc\pride_colorizer_intersex.json -3bf96944a8eed8b8d3f5d96b609297727c078cb7 data\hexcasting\advancements\recipes\misc\dye_colorizer_purple.json -a0b87b1b21506708d09c9295b7afc13de6b1fce6 data\hexcasting\recipes\pride_colorizer_aromantic.json -e0609202271e402d8ae58e4f8eaf11dcdda10a9e data\hexcasting\recipes\brainsweep\akashic_record.json -e765ee2bd324240e8ed3d625be431de3281f0070 data\hexcasting\recipes\dye_colorizer_gray.json -dcc9bf721dd40724abcc69f1f7e8a1610dbf88f3 data\hexcasting\recipes\compat\farmersdelight\cutting\akashic_door.json -afb422ad4a918ee0161bf077f09475bb1da2b4eb data\hexcasting\recipes\amethyst_dust_unpacking.json -7baf0777533737aef68bcac36944943b77138d29 data\hexcasting\recipes\edified_button.json -a8d604ba059d54502837809815d3ac9bbcaa89bf data\hexcasting\advancements\recipes\redstone\akashic_bookshelf.json -1b570b35288be9f6faab1536d6e45cb52eb088c0 data\hexcasting\advancements\recipes\tools\staff\dark_oak.json -b6720c1c73455ad817bac9b5ca2ca045c5c4050c data\hexcasting\recipes\pride_colorizer_agender.json -c43fb770003c8d882fd9c1e7d1ecb5f196cba1ab data\hexcasting\recipes\cypher.json -3b03fdae3896212a0b8b9b3a2d4880d197e67d2d data\hexcasting\recipes\jeweler_hammer.json -7166cd4355d11c209bc7749bc862caddcfd795fb data\hexcasting\recipes\dye_colorizer_cyan.json -ef96ae9709ec931ce6b6af8a539f9bc483236449 data\hexcasting\recipes\scroll_medium.json -6f2634e5588aede8e29157ecc859652d8a9f4065 data\hexcasting\advancements\recipes\misc\dye_colorizer_orange.json -41a570f970c9af8229cb1140a11a5220fac00957 data\hexcasting\advancements\recipes\tools\staff\spruce.json -8f515bf8ccea70b3d88845ed83966dc0c66082f6 data\hexcasting\advancements\recipes\tools\staff\oak.json -30352d8ad510768770bb1b2d378959b7a502f825 data\hexcasting\advancements\recipes\brainsweep\brainsweep\impetus_look.json -ea46e570a43cd3ea1cc78c51d9da45d93944730a data\hexcasting\advancements\recipes\redstone\directrix\empty.json -cedc2889c4f327b18755bbe8c3c595d302e2a9d0 data\hexcasting\recipes\decompose_quenched_shard\shard.json -7ca0f9fc6e8ae1ad08ef5c29a0b279b891f7d8d4 data\hexcasting\advancements\recipes\misc\pride_colorizer_aroace.json -923e7cd200518042f11474713eca9ccad126dab7 data\hexcasting\recipes\staff\spruce.json -6e2dc32f975d987b8dfd329507334f647bceadc0 data\hexcasting\advancements\recipes\tools\staff\mangrove.json -7552df3fc726cc4cdaa88aa4823eff6ce069fb75 data\hexcasting\recipes\slate_block_from_slates.json -5e66982df6a1074c81f381898033b521ca337695 data\hexcasting\recipes\staff\quenched.json -b94bc4dd4a63db10af86c524ba00eae157c1824b data\hexcasting\advancements\recipes\building_blocks\edified_fence_gate.json -1093cccc6b1c45eb91f7c1680ef575a7bffb2744 data\hexcasting\advancements\recipes\building_blocks\edified_planks.json -36d26f34d0405ff2d1e728e5b5174502686e3590 data\hexcasting\advancements\recipes\brainsweep\brainsweep\budding_amethyst.json -441f336edb635e5d8c2a7183906fed1c501f06fd data\hexcasting\recipes\pride_colorizer_bisexual.json -51b047601368a103be166d907633b196d2d8a4e8 data\hexcasting\recipes\compat\farmersdelight\cutting\edified_log.json -ea87956c49dcfabb0d39af45c016130d258181da data\hexcasting\recipes\staff\birch.json -0654e70ed1ed8be20ae3dd9f4955cd14f9fa40d0 data\hexcasting\advancements\recipes\tools\staff\jungle.json -846baaef37844216b57bb9b35e52b1bb6b56b413 data\hexcasting\advancements\recipes\decorations\scroll_small.json -4d941fc399c6b7a470513a572ecd88982823da84 data\hexcasting\advancements\recipes\building_blocks\edified_wood.json -5889e2df2fb4e1ea29f2590b96bb3aa94961a09a data\hexcasting\recipes\scroll.json -ce9d0b976f7cc8ad4a0815bbea6c43115addb90f data\hexcasting\advancements\recipes\building_blocks\scroll_paper.json -b5946314683e5a823b577a18d13fb437a35aafd5 data\hexcasting\recipes\decompose_quenched_shard\charged.json -97062771a426f6e4b9e3bfd6daa62b1d4b3c7039 data\hexcasting\recipes\abacus.json -f482a4349786388cc8f11d5550548f7d60265438 data\hexcasting\recipes\staff\mangrove.json -f4c56ea7143ce92a0ae0b663310e53644a7309f7 data\hexcasting\advancements\recipes\misc\pride_colorizer_pansexual.json -2aa7d74e29a7c5ee4f1b8835cf7c6109eed81d77 data\hexcasting\recipes\brainsweep\quench_allay.json -862f1a61a296a834df8a93dbd5a6cdfa2df15721 data\hexcasting\advancements\recipes\tools\staff\acacia.json -23eff6111b0385b66d3ad5fbabfc625f426517a6 data\hexcasting\advancements\recipes\brainsweep\brainsweep\directrix_redstone.json -af8fe74b624df4a31727347b9826614a66092b0a data\hexcasting\advancements\recipes\misc\pride_colorizer_agender.json -9b7c5220fbaf3e84fa9e81eae322eed5d37b22d3 data\hexcasting\recipes\pride_colorizer_transgender.json -1a9dd55a24f56a4e9467f1117e0898f7e71ade67 data\hexcasting\advancements\recipes\decorations\amethyst_sconce.json -6493676f8ca93a7be8d70e25d69ddad935b3f16b data\hexcasting\advancements\recipes\tools\lens.json -c8f2ad363e4d20054f4e56fde02c8775a45a7169 data\hexcasting\recipes\artifact.json -552c235dc58a46a3e57913c9b9faf3f21abeae32 data\hexcasting\advancements\recipes\building_blocks\stripped_edified_wood.json -b6fa898369ac52cdd9d7f91e3b8a2cb881c3829f data\hexcasting\advancements\recipes\decorations\scroll_medium.json -641d8c38b8109665314fccbebd9068ba10b04118 data\hexcasting\advancements\recipes\misc\dye_colorizer_gray.json -54335e0004423899ad37763a1d8456cc0a6e72a7 data\hexcasting\advancements\recipes\misc\decompose_quenched_shard\charged.json -af9a260c24e0a65eea321f0dd9dd2fa7d648707f data\hexcasting\advancements\recipes\building_blocks\amethyst_dust_packing.json -2b64261bd4aefdc55d35400f25835434f88856cf data\hexcasting\recipes\amethyst_tiles.json -b20be6eb5a8b60567871444e65d773ec9a67ece1 data\hexcasting\recipes\staff\crimson.json -fd2f25b0a71806c96af5a307fad76f66de6210a4 data\hexcasting\advancements\recipes\building_blocks\slate_block.json -5e98cec2084f0cfbb959c3ec39bd85a3369f443b data\hexcasting\advancements\recipes\tools\abacus.json -b10d590e918e35b16578a8b739a1c4e7e2202e16 data\hexcasting\advancements\recipes\misc\dye_colorizer_cyan.json -e536791d0c6fb48206e6e30d56879eaf0a9e4bd7 data\hexcasting\recipes\akashic_bookshelf.json -e11aeded7f5d3fdd224627c67661bbd993901703 data\hexcasting\recipes\edified_pressure_plate.json -b16ff5314d457bc7e9e224e102d1e04ce3a62361 data\hexcasting\recipes\brainsweep\directrix_redstone.json -f1bae034d27d218bf262a8c777b787d232489f16 data\hexcasting\recipes\lens.json -a8cab28cffdf495253a320094d202fccc5aeb113 data\hexcasting\advancements\recipes\decorations\ancient_scroll_paper_lantern.json -157ee5fba985bbd01a87f44578890dab5489a8e5 data\hexcasting\advancements\recipes\misc\dye_colorizer_green.json -494aa470790ae46baebbf24ee5b76f5885c1af1a data\hexcasting\recipes\ageing_scroll_paper_lantern.json -a1f9df0537c0ef33a1164cf94e8ff4b1094f889f data\hexcasting\advancements\recipes\tools\staff\warped.json -d6b7a9392320c11866b3f139f97977dc9f55bc47 data\hexcasting\recipes\scroll_small.json -1d1e73244fb3da633d8a5f84bad93c6022a94368 data\hexcasting\advancements\recipes\misc\pride_colorizer_demiboy.json -f64fa00d85a9abb24e89b0d2c9f818001371f5e6 data\hexcasting\recipes\slate_block.json -0864e8b86bdad0bf9ab2ddeb0cd5a182808b5a0a data\hexcasting\recipes\default_colorizer.json -5fab1b9c93304a53a4c305b511704458e4593444 data\hexcasting\recipes\pride_colorizer_demigirl.json -72447ac69a0d85f91064180d3c852040a9e33832 data\hexcasting\recipes\pride_colorizer_asexual.json -8c52917fc7041c483fb6dfe8d16c90f096f2beaf data\hexcasting\recipes\compat\farmersdelight\cutting\edified_log_amethyst.json -d47352426739a0fc500a385d820d767a307e1d16 data\hexcasting\advancements\recipes\misc\dye_colorizer_black.json -c03c81dc123294472e8bb6f836c319e96f8db4f5 data\hexcasting\advancements\recipes\building_blocks\edified_fence.json -233aeedc73173427e7b2287772a4f914f97b072c data\hexcasting\recipes\dye_colorizer_red.json -7d71eb93bbb0856167cf4521283e39f0048078ee data\hexcasting\advancements\recipes\redstone\edified_button.json -bd63b845e02ee4b1b9abe168a196335ccbed1ca5 data\hexcasting\recipes\scroll_paper_lantern.json -14f3b217e150efbbff329d67aec96f818a1da99c data\hexcasting\recipes\dye_colorizer_purple.json -170af3c83a45f9550827cc48e4bb5a621d06d685 data\hexcasting\advancements\recipes\misc\pride_colorizer_transgender.json -d7de5d626fd799a2522af36f0c62c52fe490e6d2 data\hexcasting\recipes\edified_door.json -ee5db13cbb33d9c62bcb1eb645e2c4bea97ad44a data\hexcasting\advancements\recipes\building_blocks\amethyst_dust_unpacking.json -417695497a95436186c1a4ed842d7975d754f9eb data\hexcasting\recipes\stripped_edified_wood.json -aa7558ec1baf6070efbe448d886e20e964e33f96 data\hexcasting\advancements\recipes\brainsweep\brainsweep\quench_allay.json -06402fb37fe4bb05918d13dbfdb89f4c2b67f3ec data\hexcasting\advancements\recipes\tools\cypher.json -7e1a5a873d655e0efba80f22ae9b1de4f248e67a data\hexcasting\advancements\recipes\misc\decompose_quenched_shard\shard.json -0aaf55492e850d2bb1ec2f9986406ca61fde4cfd data\hexcasting\recipes\dye_colorizer_lime.json -1e51cd4f527b3aea4d61d91829e47c191c9c05bb data\hexcasting\recipes\pride_colorizer_gay.json -4a803e049915fd3c7144155ae3a1b05a917ea290 data\hexcasting\recipes\pride_colorizer_pansexual.json -1a0d55e6824c078453c1d44e885a1c51ba707a41 data\hexcasting\recipes\dye_colorizer_white.json -ad647a2078099344ea7f9836a68e1bf8e8119277 data\hexcasting\advancements\recipes\misc\dye_colorizer_brown.json -63189af501442318a90c16d6951e51c0c5d6d4f3 data\hexcasting\recipes\compat\farmersdelight\cutting\edified_log_purple.json -06ca609ba1a32f094cf6edbc989bc9ddaf9d342c data\hexcasting\advancements\recipes\misc\pride_colorizer_genderfluid.json -f77518b6993fe8e31de10af286c33ab72c0f9077 data\hexcasting\advancements\recipes\redstone\impetus\empty.json -c3f7b03fe184ed5e54a8ae06d130adf507b7683d data\hexcasting\recipes\staff\bamboo.json -4003f297be29810cebde4995fb2838c2c68a25ea data\hexcasting\recipes\pride_colorizer_lesbian.json -505eb9192df0b48867e58e09ce36b2259dc6d3e8 data\hexcasting\advancements\recipes\decorations\scroll.json -bc729ac7cf84d29a99cd34d50c152c0b9d20bd7a data\hexcasting\advancements\recipes\brainsweep\brainsweep\akashic_record.json -4680e9dafcf9b60b3485609519d66eefcfd539bc data\hexcasting\recipes\staff\dark_oak.json -0bd7c9f4a9bf29c1b63b2f9378f0a7e2f594b7b7 data\hexcasting\recipes\pride_colorizer_nonbinary.json -963d87d2738686e5398a178b8b369228ff067403 data\hexcasting\recipes\spellbook.json -e691130641b11c0a030a51c71dee0ba356f3b5bd data\hexcasting\recipes\compat\farmersdelight\cutting\edified_log_aventurine.json -faaa9c39dbcdd131c5fbec9ac6a26d6dc5e72053 data\hexcasting\advancements\recipes\misc\dye_colorizer_light_gray.json -f8ee073c1c03f1c11147e4801eeba1f86e5459ba data\hexcasting\recipes\dye_colorizer_blue.json -77369113dc54d1c64b9101861dd8a1930bf1c1c4 data\hexcasting\recipes\edified_wood.json -f81053a3269c1b371be3f8057bad4803056ee0f9 data\hexcasting\recipes\dye_colorizer_orange.json -a366ea3750adc0d336ab8f318c40baed3f9c3eb7 data\hexcasting\recipes\brainsweep\impetus_storedplayer.json -61fafd43af83bdca6720d0993ab71f40a8bebd40 data\hexcasting\advancements\recipes\redstone\akashic_connector.json -0b172aef920da7ba63fe152903ce005c1f5df5f1 data\hexcasting\recipes\staff\acacia.json -9269b17eaae3217422352354fc6006c9808b398c data\hexcasting\recipes\dye_colorizer_black.json -7c479398bbc7185a2c3efd568ad266d8109245bf data\hexcasting\advancements\recipes\redstone\edified_door.json -071e5875b13b60aac33bc97e408d2ca710ac5d02 data\hexcasting\advancements\recipes\building_blocks\stonecutting\amethyst_tiles.json -b29f9d9c14e60ded1148680e2e0ef405b5a3c845 data\hexcasting\advancements\recipes\misc\uuid_colorizer.json -8bea75fdc5e64c464dcf5f85166e767ff44e6dc2 data\hexcasting\advancements\recipes\misc\pride_colorizer_lesbian.json -17a1adf747b99848381ca8e7c5e2cd9dd96c014f data\hexcasting\advancements\recipes\misc\default_colorizer.json -664ce1a38c9b1c9ec21b7e078631e181fc0b2498 data\hexcasting\recipes\staff\edified.json -c6228d72ca800a7dd336e82bbb9b4f20f89de29d data\hexcasting\advancements\recipes\redstone\edified_pressure_plate.json -72f70637aea1c11683e9ee91d83c2807c6ec33a9 data\hexcasting\recipes\compat\farmersdelight\cutting\akashic_trapdoor.json -b6e762c198b9632defd7f8b11287702abecd681d data\hexcasting\recipes\staff\mindsplice.json -2eacf53894ae97712dc3874777e29dce0a0e5540 data\hexcasting\advancements\recipes\misc\pride_colorizer_asexual.json -c1846dd794f5cc5814b8a839291e82512a02ba12 data\hexcasting\advancements\recipes\misc\pride_colorizer_plural.json -71f821f5d24b0bf9ecd860d51e055628fe4af50c data\hexcasting\recipes\edified_panel.json -61e53f02baefd31308e99407d56403dfc18e36e1 data\hexcasting\recipes\akashic_connector.json -8c043c7f6a7911b67324e2fd42f0b3b19a792af3 data\hexcasting\recipes\ancient_scroll_paper_lantern.json -c2a0a489967db4064dfbe1ee6367e132665f3c00 data\hexcasting\recipes\edified_slab.json -004e0694b3bf53140be7df89a4defc255b800619 data\hexcasting\advancements\recipes\tools\focus_rotated.json -8f8773a541bc6a4a6c55a23f4f98b5da4f61a031 data\hexcasting\recipes\scroll_paper.json -55602e415fc1b797439b674050887e9e388558c9 data\hexcasting\advancements\recipes\building_blocks\edified_panel.json -68ab70e0b4e432a3492767c5597ecd836f106714 data\hexcasting\advancements\recipes\tools\staff\mindsplice.json -1b092acfc3115702c74e141492e649d58512f259 data\hexcasting\recipes\staff\oak.json -aa1caae7eba6aede0f179619488e2253b3b723dd data\hexcasting\recipes\focus_rotated.json -2cea013887734cbc4971bcd57e7e4f6a2b25c8e1 data\hexcasting\advancements\recipes\tools\focus.json -5f216dbb7b89fd837e2dd73e3ed41c8d412de234 data\hexcasting\advancements\recipes\misc\decompose_quenched_shard\dust.json -b1f8375aaf0d66035dee720ea59605f69fc0a154 data\hexcasting\recipes\edified_fence.json -ae88fcdecbfbdd0a0fe778467421a3b32d7ed735 data\create\recipes\crushing\amethyst_cluster.json -0ead307e47242ba140584f6bd20088a1fa7c2909 data\hexcasting\recipes\directrix\empty.json -946cde51bbfc2af344b078f6b39389ffc44462f4 data\hexcasting\advancements\recipes\brainsweep\brainsweep\impetus_storedplayer.json -f80dbf59957be175fbcd63224005e09c4cd1a122 data\hexcasting\recipes\compat\farmersdelight\cutting\edified_log_citrine.json -a72a0fcc0f3a81d31b30a7a626aef537796ca73b data\hexcasting\advancements\recipes\tools\staff\quenched.json -a85cfbd7988f5df0b18d160591605aea8e6808d2 data\hexcasting\recipes\trinket.json -24c244e53c7e47b85845d2ee36b1665410cf495a data\hexcasting\recipes\edified_planks.json -fd7c8325fcaa6a718e90c09251b447fb365523d4 data\hexcasting\recipes\pride_colorizer_demiboy.json -2a2f60fb0f63ee278b74c418acf04575304c521f data\hexcasting\advancements\recipes\tools\jeweler_hammer.json -f347f4ce869207e62a7887df1252505a3432e12a data\hexcasting\recipes\pride_colorizer_genderfluid.json -996c8361766377a70e0b5a5caff3076fc6031b0a data\hexcasting\recipes\impetus\empty.json -b90ad4cbffc2e3c01671dfe8bda5e42d9b8a685c data\hexcasting\advancements\recipes\tools\staff\crimson.json -a9111ff52513200af47b79cf98b2e545699497bb data\hexcasting\advancements\recipes\building_blocks\amethyst_tiles.json -4d5e4a6374731b2d0a90c70a5d489703fd966977 data\hexcasting\advancements\recipes\misc\dye_colorizer_lime.json +// 1.20.1 2024-07-17T19:52:53.359621 Hex Casting/Recipes +4003f297be29810cebde4995fb2838c2c68a25ea data/hexcasting/recipes/pride_colorizer_lesbian.json +fb852d8e4bcfa7b75f41a6ac7dc1e76b00d95fb1 data/hexcasting/advancements/recipes/misc/dye_colorizer_red.json +c2ef04b311251b4eb22320b2f5313c54533a9974 data/hexcasting/advancements/recipes/tools/staff/birch.json +f347f4ce869207e62a7887df1252505a3432e12a data/hexcasting/recipes/pride_colorizer_genderfluid.json +6f2634e5588aede8e29157ecc859652d8a9f4065 data/hexcasting/advancements/recipes/misc/dye_colorizer_orange.json +e691130641b11c0a030a51c71dee0ba356f3b5bd data/hexcasting/recipes/compat/farmersdelight/cutting/edified_log_aventurine.json +4a803e049915fd3c7144155ae3a1b05a917ea290 data/hexcasting/recipes/pride_colorizer_pansexual.json +151875101066f7af5788c7a2e1c6b342971a546a data/hexcasting/recipes/compat/farmersdelight/cutting/akashic_wood.json +41a570f970c9af8229cb1140a11a5220fac00957 data/hexcasting/advancements/recipes/tools/staff/spruce.json +12bd3d04c791ef16aad5e992f038d6726229a436 data/hexcasting/advancements/recipes/tools/artifact.json +e11aeded7f5d3fdd224627c67661bbd993901703 data/hexcasting/recipes/edified_pressure_plate.json +04902d4eca30560bc601a8196d82f74f3fa5b191 data/hexcasting/recipes/dynamicseal_spellbook.json +a85cfbd7988f5df0b18d160591605aea8e6808d2 data/hexcasting/recipes/trinket.json +846baaef37844216b57bb9b35e52b1bb6b56b413 data/hexcasting/advancements/recipes/decorations/scroll_small.json +8815ea5d8d7379062e050adc5736cc579c3bdd9e data/hexcasting/recipes/edified_stairs.json +24c244e53c7e47b85845d2ee36b1665410cf495a data/hexcasting/recipes/edified_planks.json +5e98cec2084f0cfbb959c3ec39bd85a3369f443b data/hexcasting/advancements/recipes/tools/abacus.json +71f821f5d24b0bf9ecd860d51e055628fe4af50c data/hexcasting/recipes/edified_panel.json +552c235dc58a46a3e57913c9b9faf3f21abeae32 data/hexcasting/advancements/recipes/building_blocks/stripped_edified_wood.json +c8f2ad363e4d20054f4e56fde02c8775a45a7169 data/hexcasting/recipes/artifact.json +1b092acfc3115702c74e141492e649d58512f259 data/hexcasting/recipes/staff/oak.json +f8ee073c1c03f1c11147e4801eeba1f86e5459ba data/hexcasting/recipes/dye_colorizer_blue.json +233aeedc73173427e7b2287772a4f914f97b072c data/hexcasting/recipes/dye_colorizer_red.json +c03c81dc123294472e8bb6f836c319e96f8db4f5 data/hexcasting/advancements/recipes/building_blocks/edified_fence.json +5889e2df2fb4e1ea29f2590b96bb3aa94961a09a data/hexcasting/recipes/scroll.json +51b047601368a103be166d907633b196d2d8a4e8 data/hexcasting/recipes/compat/farmersdelight/cutting/edified_log.json +a1f9df0537c0ef33a1164cf94e8ff4b1094f889f data/hexcasting/advancements/recipes/tools/staff/warped.json +93ed0491548920bc75797d18501c750ef07fe3ea data/hexcasting/advancements/recipes/misc/pride_colorizer_bisexual.json +0ead307e47242ba140584f6bd20088a1fa7c2909 data/hexcasting/recipes/directrix/empty.json +0038883bd294cc8a1b324d6782478d5e37b4dbf9 data/hexcasting/advancements/recipes/misc/dye_colorizer_pink.json +e536791d0c6fb48206e6e30d56879eaf0a9e4bd7 data/hexcasting/recipes/akashic_bookshelf.json +bc729ac7cf84d29a99cd34d50c152c0b9d20bd7a data/hexcasting/advancements/recipes/brainsweep/brainsweep/akashic_record.json +7f2f29981df2ca4464ee0250180e670f5331f65b data/hexcasting/recipes/dye_colorizer_pink.json +b84c113ef5321c9df9ac9080de03e8d8639feab2 data/hexcasting/advancements/recipes/misc/pride_colorizer_genderqueer.json +499c5c09e3772989350f9ab3264b8692449a6dea data/hexcasting/advancements/recipes/misc/pride_colorizer_gay.json +09096a40275b6c49d4b4e6984869aa43b34712c3 data/hexcasting/recipes/dynamicseal_focus.json +afb422ad4a918ee0161bf077f09475bb1da2b4eb data/hexcasting/recipes/amethyst_dust_unpacking.json +ea46e570a43cd3ea1cc78c51d9da45d93944730a data/hexcasting/advancements/recipes/redstone/directrix/empty.json +2cea013887734cbc4971bcd57e7e4f6a2b25c8e1 data/hexcasting/advancements/recipes/tools/focus.json +923e7cd200518042f11474713eca9ccad126dab7 data/hexcasting/recipes/staff/spruce.json +2003fed3aa4eb622b6b07a9e65946fb40be14420 data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_rightclick.json +72f70637aea1c11683e9ee91d83c2807c6ec33a9 data/hexcasting/recipes/compat/farmersdelight/cutting/akashic_trapdoor.json +ea63e49709bd80cb9f4cd1fe13e9bd0281101c9a data/hexcasting/recipes/slate.json +996c8361766377a70e0b5a5caff3076fc6031b0a data/hexcasting/recipes/impetus/empty.json +49e706193bb57a957091e419bd0d8aa58135da1f data/hexcasting/recipes/dye_colorizer_green.json +06402fb37fe4bb05918d13dbfdb89f4c2b67f3ec data/hexcasting/advancements/recipes/tools/cypher.json +42b8e462de1d7006de3a7658757377450e773107 data/hexcasting/advancements/recipes/misc/dye_colorizer_blue.json +d7de5d626fd799a2522af36f0c62c52fe490e6d2 data/hexcasting/recipes/edified_door.json +72447ac69a0d85f91064180d3c852040a9e33832 data/hexcasting/recipes/pride_colorizer_asexual.json +a9111ff52513200af47b79cf98b2e545699497bb data/hexcasting/advancements/recipes/building_blocks/amethyst_tiles.json +862f1a61a296a834df8a93dbd5a6cdfa2df15721 data/hexcasting/advancements/recipes/tools/staff/acacia.json +b94bc4dd4a63db10af86c524ba00eae157c1824b data/hexcasting/advancements/recipes/building_blocks/edified_fence_gate.json +946cde51bbfc2af344b078f6b39389ffc44462f4 data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_storedplayer.json +a8cab28cffdf495253a320094d202fccc5aeb113 data/hexcasting/advancements/recipes/decorations/ancient_scroll_paper_lantern.json +1b570b35288be9f6faab1536d6e45cb52eb088c0 data/hexcasting/advancements/recipes/tools/staff/dark_oak.json +441f336edb635e5d8c2a7183906fed1c501f06fd data/hexcasting/recipes/pride_colorizer_bisexual.json +9b7c5220fbaf3e84fa9e81eae322eed5d37b22d3 data/hexcasting/recipes/pride_colorizer_transgender.json +3b03fdae3896212a0b8b9b3a2d4880d197e67d2d data/hexcasting/recipes/jeweler_hammer.json +e9166f40c8797cdbf3d8062dfa35c74f850f1000 data/hexcasting/advancements/recipes/misc/dye_colorizer_white.json +3608f0ec056f2c5d29a9a89305218497fd2c4383 data/hexcasting/recipes/stonecutting/amethyst_tiles.json +ee5db13cbb33d9c62bcb1eb645e2c4bea97ad44a data/hexcasting/advancements/recipes/building_blocks/amethyst_dust_unpacking.json +fb486df96798724da2fcc0df5706f19bc1ff94dc data/hexcasting/advancements/recipes/misc/dye_colorizer_light_blue.json +1ad54df5eaee3d1e810d2c91bd03f626084e30b6 data/hexcasting/recipes/edified_trapdoor.json +9269b17eaae3217422352354fc6006c9808b398c data/hexcasting/recipes/dye_colorizer_black.json +a366ea3750adc0d336ab8f318c40baed3f9c3eb7 data/hexcasting/recipes/brainsweep/impetus_storedplayer.json +417695497a95436186c1a4ed842d7975d754f9eb data/hexcasting/recipes/stripped_edified_wood.json +5f216dbb7b89fd837e2dd73e3ed41c8d412de234 data/hexcasting/advancements/recipes/misc/decompose_quenched_shard/dust.json +30352d8ad510768770bb1b2d378959b7a502f825 data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_look.json +0b172aef920da7ba63fe152903ce005c1f5df5f1 data/hexcasting/recipes/staff/acacia.json +f4c56ea7143ce92a0ae0b663310e53644a7309f7 data/hexcasting/advancements/recipes/misc/pride_colorizer_pansexual.json +c1541738df1ee41c362ad3b9c3a9f0e181bd5c62 data/hexcasting/recipes/pride_colorizer_plural.json +1a9dd55a24f56a4e9467f1117e0898f7e71ade67 data/hexcasting/advancements/recipes/decorations/amethyst_sconce.json +b6720c1c73455ad817bac9b5ca2ca045c5c4050c data/hexcasting/recipes/pride_colorizer_agender.json +838b91c33a72a58aa286607eaaa17cdd6b4c90ba data/hexcasting/recipes/amethyst_sconce.json +bd63b845e02ee4b1b9abe168a196335ccbed1ca5 data/hexcasting/recipes/scroll_paper_lantern.json +963d87d2738686e5398a178b8b369228ff067403 data/hexcasting/recipes/spellbook.json +b16ff5314d457bc7e9e224e102d1e04ce3a62361 data/hexcasting/recipes/brainsweep/directrix_redstone.json +45915b542d8070f2502a4047218679b08033b12d data/hexcasting/advancements/recipes/decorations/scroll_paper_lantern.json +55602e415fc1b797439b674050887e9e388558c9 data/hexcasting/advancements/recipes/building_blocks/edified_panel.json +5401828f85e709b5817ecc8464dc63e536a730dc data/hexcasting/recipes/staff/cherry.json +3bf96944a8eed8b8d3f5d96b609297727c078cb7 data/hexcasting/advancements/recipes/misc/dye_colorizer_purple.json +f08a0aee92b281ae325d907e6fe4a3b03980f2aa data/hexcasting/advancements/recipes/tools/staff/edified.json +6e2dc32f975d987b8dfd329507334f647bceadc0 data/hexcasting/advancements/recipes/tools/staff/mangrove.json +0bd7c9f4a9bf29c1b63b2f9378f0a7e2f594b7b7 data/hexcasting/recipes/pride_colorizer_nonbinary.json +505eb9192df0b48867e58e09ce36b2259dc6d3e8 data/hexcasting/advancements/recipes/decorations/scroll.json +b90ad4cbffc2e3c01671dfe8bda5e42d9b8a685c data/hexcasting/advancements/recipes/tools/staff/crimson.json +ed5c690324e3d9b55599f00f078ae225072a2e7f data/hexcasting/recipes/brainsweep/impetus_rightclick.json +8e48c680b38666c2e7da71fbe4ceddf5d99a5cbc data/hexcasting/advancements/recipes/food/sub_sandwich.json +8bea75fdc5e64c464dcf5f85166e767ff44e6dc2 data/hexcasting/advancements/recipes/misc/pride_colorizer_lesbian.json +e765ee2bd324240e8ed3d625be431de3281f0070 data/hexcasting/recipes/dye_colorizer_gray.json +8f515bf8ccea70b3d88845ed83966dc0c66082f6 data/hexcasting/advancements/recipes/tools/staff/oak.json +5e28e2c352366720ce91b73f8c8c38e217f7198d data/hexcasting/recipes/edified_fence_gate.json +2b64261bd4aefdc55d35400f25835434f88856cf data/hexcasting/recipes/amethyst_tiles.json +5e66982df6a1074c81f381898033b521ca337695 data/hexcasting/recipes/staff/quenched.json +ce9d0b976f7cc8ad4a0815bbea6c43115addb90f data/hexcasting/advancements/recipes/building_blocks/scroll_paper.json +494aa470790ae46baebbf24ee5b76f5885c1af1a data/hexcasting/recipes/ageing_scroll_paper_lantern.json +0654e70ed1ed8be20ae3dd9f4955cd14f9fa40d0 data/hexcasting/advancements/recipes/tools/staff/jungle.json +61fafd43af83bdca6720d0993ab71f40a8bebd40 data/hexcasting/advancements/recipes/redstone/akashic_connector.json +c4b985635c3b1a519d7a83da65daba5bdd3a5f59 data/hexcasting/advancements/recipes/decorations/ageing_scroll_paper_lantern.json +2eacf53894ae97712dc3874777e29dce0a0e5540 data/hexcasting/advancements/recipes/misc/pride_colorizer_asexual.json +071e5875b13b60aac33bc97e408d2ca710ac5d02 data/hexcasting/advancements/recipes/building_blocks/stonecutting/amethyst_tiles.json +ef96ae9709ec931ce6b6af8a539f9bc483236449 data/hexcasting/recipes/scroll_medium.json +71d38559bf455ea343ac0237a57db4d3f0833a7c data/hexcasting/advancements/recipes/misc/dye_colorizer_magenta.json +40ed21dc80d39236ca0e6d2cea60861c637cf931 data/hexcasting/advancements/recipes/misc/pride_colorizer_nonbinary.json +af9a260c24e0a65eea321f0dd9dd2fa7d648707f data/hexcasting/advancements/recipes/building_blocks/amethyst_dust_packing.json +23eff6111b0385b66d3ad5fbabfc625f426517a6 data/hexcasting/advancements/recipes/brainsweep/brainsweep/directrix_redstone.json +8c52917fc7041c483fb6dfe8d16c90f096f2beaf data/hexcasting/recipes/compat/farmersdelight/cutting/edified_log_amethyst.json +61e53f02baefd31308e99407d56403dfc18e36e1 data/hexcasting/recipes/akashic_connector.json +c43fb770003c8d882fd9c1e7d1ecb5f196cba1ab data/hexcasting/recipes/cypher.json +55ea553a96e1d6a54385890f7c48fe7b2bed6871 data/hexcasting/advancements/recipes/tools/trinket.json +f81053a3269c1b371be3f8057bad4803056ee0f9 data/hexcasting/recipes/dye_colorizer_orange.json +0f2e63a9361d18aac764f6a4a4f13b9b862ac2ee data/hexcasting/recipes/compat/create/crushing/amethyst_shard.json +c1846dd794f5cc5814b8a839291e82512a02ba12 data/hexcasting/advancements/recipes/misc/pride_colorizer_plural.json +775560efa36581389c0319435bda035be262ed4f data/hexcasting/advancements/recipes/building_blocks/edified_stairs.json +ea87956c49dcfabb0d39af45c016130d258181da data/hexcasting/recipes/staff/birch.json +faaa9c39dbcdd131c5fbec9ac6a26d6dc5e72053 data/hexcasting/advancements/recipes/misc/dye_colorizer_light_gray.json +8c043c7f6a7911b67324e2fd42f0b3b19a792af3 data/hexcasting/recipes/ancient_scroll_paper_lantern.json +b300f7729e75614fce412457f6717686680f81da data/hexcasting/recipes/sub_sandwich.json +77369113dc54d1c64b9101861dd8a1930bf1c1c4 data/hexcasting/recipes/edified_wood.json +2fff80cd3dabd2bc1744eecd72b2364b0f91c7c1 data/hexcasting/advancements/recipes/misc/dye_colorizer_yellow.json +e0609202271e402d8ae58e4f8eaf11dcdda10a9e data/hexcasting/recipes/brainsweep/akashic_record.json +68ab70e0b4e432a3492767c5597ecd836f106714 data/hexcasting/advancements/recipes/tools/staff/mindsplice.json +2c56c267e23e75d5a3b9358d424d69642e001b50 data/hexcasting/recipes/decompose_quenched_shard/dust.json +c6228d72ca800a7dd336e82bbb9b4f20f89de29d data/hexcasting/advancements/recipes/redstone/edified_pressure_plate.json +0b951ce7b9d1bfb07ae012b12225b595d36c6e66 data/hexcasting/recipes/amethyst_dust_packing.json +fd7c8325fcaa6a718e90c09251b447fb365523d4 data/hexcasting/recipes/pride_colorizer_demiboy.json +1093cccc6b1c45eb91f7c1680ef575a7bffb2744 data/hexcasting/advancements/recipes/building_blocks/edified_planks.json +54335e0004423899ad37763a1d8456cc0a6e72a7 data/hexcasting/advancements/recipes/misc/decompose_quenched_shard/charged.json +e6a592721234448f2ee7ec402bca10a9b78b4677 data/hexcasting/advancements/recipes/decorations/slate.json +1a0d55e6824c078453c1d44e885a1c51ba707a41 data/hexcasting/recipes/dye_colorizer_white.json +4d5e4a6374731b2d0a90c70a5d489703fd966977 data/hexcasting/advancements/recipes/misc/dye_colorizer_lime.json +d47352426739a0fc500a385d820d767a307e1d16 data/hexcasting/advancements/recipes/misc/dye_colorizer_black.json +27dc4a1647f264c45b27f5552fd9403a02853484 data/hexcasting/advancements/recipes/tools/spellbook.json +b20be6eb5a8b60567871444e65d773ec9a67ece1 data/hexcasting/recipes/staff/crimson.json +a3130e3098e35b75afae4f31996d9ab7468e0bc3 data/hexcasting/advancements/recipes/tools/thought_knot.json +eb9ebf77f0daa32f665a60888fcda19c940f0b2f data/hexcasting/advancements/recipes/misc/pride_colorizer_demigirl.json +7c479398bbc7185a2c3efd568ad266d8109245bf data/hexcasting/advancements/recipes/redstone/edified_door.json +78958099bf4337ad281580d90f434b3074ad18c8 data/hexcasting/recipes/pride_colorizer_genderqueer.json +f77518b6993fe8e31de10af286c33ab72c0f9077 data/hexcasting/advancements/recipes/redstone/impetus/empty.json +aa7558ec1baf6070efbe448d886e20e964e33f96 data/hexcasting/advancements/recipes/brainsweep/brainsweep/quench_allay.json +af8fe74b624df4a31727347b9826614a66092b0a data/hexcasting/advancements/recipes/misc/pride_colorizer_agender.json +f1bae034d27d218bf262a8c777b787d232489f16 data/hexcasting/recipes/lens.json +7d71eb93bbb0856167cf4521283e39f0048078ee data/hexcasting/advancements/recipes/redstone/edified_button.json +dcc9bf721dd40724abcc69f1f7e8a1610dbf88f3 data/hexcasting/recipes/compat/farmersdelight/cutting/akashic_door.json +1e51cd4f527b3aea4d61d91829e47c191c9c05bb data/hexcasting/recipes/pride_colorizer_gay.json +bc8fe4d2f55fe119b0b146a71782a3d4788380b1 data/create/recipes/crushing/amethyst_block.json +a0b87b1b21506708d09c9295b7afc13de6b1fce6 data/hexcasting/recipes/pride_colorizer_aromantic.json +7522be58b09554a3f1a54d5b2343c3eab01447a3 data/hexcasting/recipes/dye_colorizer_magenta.json +004e0694b3bf53140be7df89a4defc255b800619 data/hexcasting/advancements/recipes/tools/focus_rotated.json +011f8daf15148d4b77686c6d382d8f5c288a333d data/hexcasting/advancements/recipes/building_blocks/ancient_scroll_paper.json +b6fa898369ac52cdd9d7f91e3b8a2cb881c3829f data/hexcasting/advancements/recipes/decorations/scroll_medium.json +9ea4fe5272ce2241d98f30359f55cfc1936c7b48 data/hexcasting/advancements/recipes/tools/staff/cherry.json +203b7035125390abb4ed77b3a4dca8f8f8f57bc5 data/hexcasting/recipes/dye_colorizer_light_gray.json +8b7136c206b799a2e394aa02316b0509674ff64f data/hexcasting/advancements/recipes/tools/staff/bamboo.json +8f8773a541bc6a4a6c55a23f4f98b5da4f61a031 data/hexcasting/recipes/scroll_paper.json +4d941fc399c6b7a470513a572ecd88982823da84 data/hexcasting/advancements/recipes/building_blocks/edified_wood.json +1d1e73244fb3da633d8a5f84bad93c6022a94368 data/hexcasting/advancements/recipes/misc/pride_colorizer_demiboy.json +ad647a2078099344ea7f9836a68e1bf8e8119277 data/hexcasting/advancements/recipes/misc/dye_colorizer_brown.json +f482a4349786388cc8f11d5550548f7d60265438 data/hexcasting/recipes/staff/mangrove.json +5a90084c03d6e8424872870c8b65f4771b447f03 data/hexcasting/recipes/brainsweep/budding_amethyst.json +db5ae3a2fda235cf1c83fd83e0026a262e668217 data/hexcasting/advancements/recipes/building_blocks/edified_slab.json +36d26f34d0405ff2d1e728e5b5174502686e3590 data/hexcasting/advancements/recipes/brainsweep/brainsweep/budding_amethyst.json +f0e71ae8c6a9170669f44096a55a875d11497c56 data/hexcasting/recipes/staff/warped.json +06ca609ba1a32f094cf6edbc989bc9ddaf9d342c data/hexcasting/advancements/recipes/misc/pride_colorizer_genderfluid.json +410bfde90cb977db3f13814e94484fa11fca7cfc data/hexcasting/recipes/thought_knot.json +0e792d49c81d2164e827d1bdedaa0fa358dfc437 data/hexcasting/advancements/recipes/misc/pride_colorizer_aromantic.json +641d8c38b8109665314fccbebd9068ba10b04118 data/hexcasting/advancements/recipes/misc/dye_colorizer_gray.json +5d6d73e16a36da5f9df6a7b8ac859181d401766d data/hexcasting/recipes/uuid_colorizer.json +095aeb2882c6849f10fb6536e7c780790778e5e7 data/hexcasting/recipes/staff/jungle.json +0864e8b86bdad0bf9ab2ddeb0cd5a182808b5a0a data/hexcasting/recipes/default_colorizer.json +92bdf87687d8823036fae6bd01782c653831286b data/hexcasting/recipes/brainsweep/impetus_look.json +4680e9dafcf9b60b3485609519d66eefcfd539bc data/hexcasting/recipes/staff/dark_oak.json +7166cd4355d11c209bc7749bc862caddcfd795fb data/hexcasting/recipes/dye_colorizer_cyan.json +7baf0777533737aef68bcac36944943b77138d29 data/hexcasting/recipes/edified_button.json +14f3b217e150efbbff329d67aec96f818a1da99c data/hexcasting/recipes/dye_colorizer_purple.json +b29f9d9c14e60ded1148680e2e0ef405b5a3c845 data/hexcasting/advancements/recipes/misc/uuid_colorizer.json +daa7b13d5370f4306f8cdf3037fc346e8918950a data/hexcasting/recipes/dye_colorizer_brown.json +2a2f60fb0f63ee278b74c418acf04575304c521f data/hexcasting/advancements/recipes/tools/jeweler_hammer.json +b5946314683e5a823b577a18d13fb437a35aafd5 data/hexcasting/recipes/decompose_quenched_shard/charged.json +7aa3bf4a3d6fb92743b29dfe89d50537fefc0db9 data/hexcasting/advancements/recipes/misc/pride_colorizer_intersex.json +cedc2889c4f327b18755bbe8c3c595d302e2a9d0 data/hexcasting/recipes/decompose_quenched_shard/shard.json +7e1a5a873d655e0efba80f22ae9b1de4f248e67a data/hexcasting/advancements/recipes/misc/decompose_quenched_shard/shard.json +664ce1a38c9b1c9ec21b7e078631e181fc0b2498 data/hexcasting/recipes/staff/edified.json +903cbe4d4c4e5abcd5e006f9d0237e8c596228ba data/hexcasting/recipes/edified_tile.json +157ee5fba985bbd01a87f44578890dab5489a8e5 data/hexcasting/advancements/recipes/misc/dye_colorizer_green.json +b10d590e918e35b16578a8b739a1c4e7e2202e16 data/hexcasting/advancements/recipes/misc/dye_colorizer_cyan.json +6493676f8ca93a7be8d70e25d69ddad935b3f16b data/hexcasting/advancements/recipes/tools/lens.json +c3f7b03fe184ed5e54a8ae06d130adf507b7683d data/hexcasting/recipes/staff/bamboo.json +b1f8375aaf0d66035dee720ea59605f69fc0a154 data/hexcasting/recipes/edified_fence.json +f64fa00d85a9abb24e89b0d2c9f818001371f5e6 data/hexcasting/recipes/slate_block.json +63189af501442318a90c16d6951e51c0c5d6d4f3 data/hexcasting/recipes/compat/farmersdelight/cutting/edified_log_purple.json +de38d15e7a91c77df24c1dc954b3e98ee197876f data/hexcasting/recipes/focus.json +648f1862fde1dd8ade80b2991b8c8e3991389e95 data/hexcasting/recipes/dye_colorizer_light_blue.json +7ca0f9fc6e8ae1ad08ef5c29a0b279b891f7d8d4 data/hexcasting/advancements/recipes/misc/pride_colorizer_aroace.json +d6b7a9392320c11866b3f139f97977dc9f55bc47 data/hexcasting/recipes/scroll_small.json +5fab1b9c93304a53a4c305b511704458e4593444 data/hexcasting/recipes/pride_colorizer_demigirl.json +b6e762c198b9632defd7f8b11287702abecd681d data/hexcasting/recipes/staff/mindsplice.json +97062771a426f6e4b9e3bfd6daa62b1d4b3c7039 data/hexcasting/recipes/abacus.json +7552df3fc726cc4cdaa88aa4823eff6ce069fb75 data/hexcasting/recipes/slate_block_from_slates.json +ae88fcdecbfbdd0a0fe778467421a3b32d7ed735 data/create/recipes/crushing/amethyst_cluster.json +2aa7d74e29a7c5ee4f1b8835cf7c6109eed81d77 data/hexcasting/recipes/brainsweep/quench_allay.json +2c292e12b5e85b1701740c222e5c5465799ad1dc data/hexcasting/recipes/pride_colorizer_aroace.json +8f7b81add0153ad94900acc66cd8174ae7115f64 data/hexcasting/advancements/recipes/building_blocks/slate_block_from_slates.json +b7084f131b0cdb9c2c698a3c5b3450d69e788d6e data/hexcasting/recipes/dye_colorizer_yellow.json +170af3c83a45f9550827cc48e4bb5a621d06d685 data/hexcasting/advancements/recipes/misc/pride_colorizer_transgender.json +a72a0fcc0f3a81d31b30a7a626aef537796ca73b data/hexcasting/advancements/recipes/tools/staff/quenched.json +aa1caae7eba6aede0f179619488e2253b3b723dd data/hexcasting/recipes/focus_rotated.json +4aaefc65af5fe69d312247fdda7d983edf8dcd9a data/hexcasting/recipes/pride_colorizer_intersex.json +31ec6474ddae967a6c1dadf9be8292d375510364 data/hexcasting/advancements/recipes/building_blocks/edified_tile.json +0aaf55492e850d2bb1ec2f9986406ca61fde4cfd data/hexcasting/recipes/dye_colorizer_lime.json +17a1adf747b99848381ca8e7c5e2cd9dd96c014f data/hexcasting/advancements/recipes/misc/default_colorizer.json +fd2f25b0a71806c96af5a307fad76f66de6210a4 data/hexcasting/advancements/recipes/building_blocks/slate_block.json +a8d604ba059d54502837809815d3ac9bbcaa89bf data/hexcasting/advancements/recipes/redstone/akashic_bookshelf.json +98c0843e6a83b91820f1c720e206295eec20ff95 data/hexcasting/recipes/ancient_scroll_paper.json +b624d103d944a8a1d4d8a9e85c198a5492b476f8 data/hexcasting/advancements/recipes/redstone/edified_trapdoor.json +c2a0a489967db4064dfbe1ee6367e132665f3c00 data/hexcasting/recipes/edified_slab.json +f80dbf59957be175fbcd63224005e09c4cd1a122 data/hexcasting/recipes/compat/farmersdelight/cutting/edified_log_citrine.json diff --git a/Forge/build.gradle b/Forge/build.gradle index aee06cc27d..78be55d9aa 100644 --- a/Forge/build.gradle +++ b/Forge/build.gradle @@ -84,6 +84,9 @@ dependencies { implementation fg.deobf("com.samsthenerd.inline:inline-forge:$minecraftVersion-$inlineVersion") + // needed for inline to run + runtimeOnly fg.deobf("me.shedaniel.cloth:cloth-config-forge:$clothConfigVersion") + // Optional interop compileOnly fg.deobf("mezz.jei:jei-$minecraftVersion-common-api:$jeiVersion") diff --git a/gradle.properties b/gradle.properties index e050c38be5..b418b53c8e 100644 --- a/gradle.properties +++ b/gradle.properties @@ -18,4 +18,5 @@ patchouliVersion=83 jeiVersion=15.0.0.12 pehkuiVersion=3.7.7 -inlineVersion=0.0.1 \ No newline at end of file +inlineVersion=0.0.1 +clothConfigVersion=11.1.106 \ No newline at end of file From 0307f1110527623cd1ebec2c8b14a4f503fed05f Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Wed, 17 Jul 2024 22:29:36 -0400 Subject: [PATCH 25/48] consolidate vc helper-y stuff --- .../client/render/PatternRenderer.java | 209 ++++-------------- .../hexcasting/client/render/VCDrawHelper.kt | 107 ++++++++- .../render/WorldlyPatternRenderHelpers.java | 3 +- .../interop/inline/InlinePatternRenderer.java | 4 +- 4 files changed, 142 insertions(+), 181 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index c0738f52bb..ae622efd86 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -2,33 +2,30 @@ import at.petrak.hexcasting.api.casting.math.HexPattern; -import com.mojang.blaze3d.platform.GlStateManager; import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.vertex.*; -import net.minecraft.client.Minecraft; -import net.minecraft.client.renderer.*; -import net.minecraft.client.renderer.texture.OverlayTexture; +import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.blaze3d.vertex.VertexConsumer; +import com.mojang.blaze3d.vertex.VertexFormat; +import net.minecraft.client.renderer.MultiBufferSource; +import net.minecraft.client.renderer.ShaderInstance; import net.minecraft.resources.ResourceLocation; import net.minecraft.util.FastColor; import net.minecraft.world.phys.Vec2; import net.minecraft.world.phys.Vec3; -import org.jetbrains.annotations.NotNull; -import org.joml.Matrix4f; import javax.annotation.Nullable; import java.util.List; import java.util.Map; import java.util.Optional; import java.util.Set; -import java.util.function.Supplier; public class PatternRenderer { public static void renderPattern(HexPattern pattern, PoseStack ps, PatternRenderSettings patSets, PatternColors patColors, double seed, int resPerUnit) { - renderPattern(pattern, ps, null, patSets, patColors, seed, null, null, resPerUnit); + renderPattern(pattern, ps, null, patSets, patColors, seed, resPerUnit); } - public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable MultiBufferSource provider, PatternRenderSettings patSets, PatternColors patColors, double seed, Integer light, Vec3 normalVec, int resPerUnit){ + public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable WorldlyBits worldlyBits, PatternRenderSettings patSets, PatternColors patColors, double seed, int resPerUnit){ var oldShader = RenderSystem.getShader(); HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); @@ -37,7 +34,7 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Mul // only do texture rendering if it's static and has solid colors if(patSets.speed == 0 && PatternTextureManager.useTextures && patColors.innerStartColor == patColors.innerEndColor && patColors.outerStartColor == patColors.outerEndColor){ - boolean didRender = renderPatternTexture(pattern, ps, provider, patSets, patColors, seed, light == null ? LightTexture.FULL_BRIGHT : light, normalVec, resPerUnit); + boolean didRender = renderPatternTexture(pattern, ps, worldlyBits, patSets, patColors, seed, resPerUnit); if(didRender) shouldRenderDynamic = false; } if(shouldRenderDynamic){ @@ -57,42 +54,46 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Mul if(FastColor.ARGB32.alpha(patColors.outerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.outerStartColor) != 0){ RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), - patColors.outerEndColor, patColors.outerStartColor, new SillyVCHelper(provider, ps, light, normalVec, 0.001f, patColors.outerStartColor)); + patColors.outerEndColor, patColors.outerStartColor, VCDrawHelper.getHelper(worldlyBits, ps,0.001f, TheCoolerRenderLib.WHITE)); } if(FastColor.ARGB32.alpha(patColors.innerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.innerStartColor) != 0) { RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.innerWidthProvider.apply((float) (staticPoints.finalScale)), - patColors.innerEndColor, patColors.innerStartColor, new SillyVCHelper(provider, ps, light, normalVec, 0.0005f, patColors.innerStartColor)); + patColors.innerEndColor, patColors.innerStartColor, VCDrawHelper.getHelper(worldlyBits, ps,0.0005f, TheCoolerRenderLib.WHITE)); } } // render dots and grid dynamically for now - if(provider == null) provider.getBuffer(RenderType.solid()); // just to try to refresh it +// if(provider == null) provider.getBuffer(RenderType.solid()); // just to try to refresh it float dotZ = 0.0004f; if(FastColor.ARGB32.alpha(patColors.startingDotColor) != 0) { RenderLib.drawSpot(ps.last().pose(), staticPoints.dotsScaled.get(0), patSets.startingDotRadiusProvider.apply((float) (staticPoints.finalScale)), - patColors.startingDotColor, new SillyVCHelper(provider, ps, light, normalVec, dotZ, patColors.innerStartColor)); + patColors.startingDotColor, VCDrawHelper.getHelper(worldlyBits, ps, dotZ, TheCoolerRenderLib.WHITE)); } if(FastColor.ARGB32.alpha(patColors.gridDotsColor) != 0) { for(int i = 1; i < staticPoints.dotsScaled.size(); i++){ Vec2 gridDot = staticPoints.dotsScaled.get(i); RenderLib.drawSpot(ps.last().pose(), gridDot, patSets.gridDotsRadiusProvider.apply((float) (staticPoints.finalScale)), - patColors.gridDotsColor, new SillyVCHelper(provider, ps, light, normalVec, dotZ, patColors.innerStartColor)); + patColors.gridDotsColor, VCDrawHelper.getHelper(worldlyBits, ps, dotZ, TheCoolerRenderLib.WHITE)); } } RenderSystem.setShader(() -> oldShader); } - private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @Nullable MultiBufferSource provider, PatternRenderSettings patSets, PatternColors patColors, double seed, int light, Vec3 normalVec, int resPerUnit){ + private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @Nullable WorldlyBits worldlyBits, PatternRenderSettings patSets, PatternColors patColors, double seed, int resPerUnit){ Optional> maybeTextures = PatternTextureManager.getTextures(pattern, patSets, seed, resPerUnit); if(maybeTextures.isEmpty()){ return false; } + Vec3 normalVec = worldlyBits.normal(); + int light = worldlyBits.light(); + MultiBufferSource provider = worldlyBits.provider(); + if(normalVec == null) normalVec = new Vec3(1f, 1f, 1f); ShaderInstance oldShader = RenderSystem.getShader(); @@ -107,172 +108,36 @@ private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @N float innerZ = 0.0005f; if(FastColor.ARGB32.alpha(patColors.outerStartColor) != 0) { - vc = setupVC(provider, textures.get("outer")); + VCDrawHelper vcHelper = VCDrawHelper.getHelper(worldlyBits, ps, outerZ, textures.get("outer")); + vc = vcHelper.vcSetupAndSupply(VertexFormat.Mode.QUADS); + + int cl = patColors.outerStartColor; - textureVertex(vc, ps, 0, 0, outerZ, 0, 0, normalVec, light, patColors.outerStartColor); - textureVertex(vc, ps, 0, (float) staticPoints.fullHeight, outerZ, 0, 1, normalVec, light, patColors.outerStartColor); - textureVertex(vc, ps, (float) staticPoints.fullWidth, (float) staticPoints.fullHeight, outerZ, 1, 1, normalVec, light, patColors.outerStartColor); - textureVertex(vc, ps, (float) staticPoints.fullWidth, 0, outerZ, 1, 0, normalVec, light, patColors.outerStartColor); + vcHelper.vertex(vc, cl, new Vec2(0, 0), new Vec2(0, 0), ps.last().pose()); + vcHelper.vertex(vc, cl, new Vec2(0, (float) staticPoints.fullHeight), new Vec2(0, 1), ps.last().pose()); + vcHelper.vertex(vc, cl, new Vec2((float) staticPoints.fullWidth, (float) staticPoints.fullHeight), new Vec2(1, 1), ps.last().pose()); + vcHelper.vertex(vc, cl, new Vec2((float) staticPoints.fullWidth, 0), new Vec2(1, 0), ps.last().pose()); - endDraw(provider, textures.get("outer"), vc); + vcHelper.vcEndDrawer(vc); } if(FastColor.ARGB32.alpha(patColors.innerStartColor) != 0) { - vc = setupVC(provider, textures.get("inner")); + VCDrawHelper vcHelper = VCDrawHelper.getHelper(worldlyBits, ps, innerZ, textures.get("inner")); + vc = vcHelper.vcSetupAndSupply(VertexFormat.Mode.QUADS); + + int cl = patColors.innerStartColor; - textureVertex(vc, ps, 0, 0, innerZ, 0, 0, normalVec, light, patColors.innerStartColor); - textureVertex(vc, ps, 0, (float) staticPoints.fullHeight, innerZ, 0, 1, normalVec, light, patColors.innerStartColor); - textureVertex(vc, ps, (float) staticPoints.fullWidth, (float) staticPoints.fullHeight, innerZ, 1, 1, normalVec, light, patColors.innerStartColor); - textureVertex(vc, ps, (float) staticPoints.fullWidth, 0, innerZ, 1, 0, normalVec, light, patColors.innerStartColor); + vcHelper.vertex(vc, cl, new Vec2(0, 0), new Vec2(0, 0), ps.last().pose()); + vcHelper.vertex(vc, cl, new Vec2(0, (float) staticPoints.fullHeight), new Vec2(0, 1), ps.last().pose()); + vcHelper.vertex(vc, cl, new Vec2((float) staticPoints.fullWidth, (float) staticPoints.fullHeight), new Vec2(1, 1), ps.last().pose()); + vcHelper.vertex(vc, cl, new Vec2((float) staticPoints.fullWidth, 0), new Vec2(1, 0), ps.last().pose()); - endDraw(provider, textures.get("inner"), vc); + vcHelper.vcEndDrawer(vc); } RenderSystem.setShader(() -> oldShader); return true; } - private static VertexConsumer setupVC(@Nullable MultiBufferSource provider, ResourceLocation texture){ - VertexConsumer vc; - - RenderType layer = RenderType.entityTranslucentCull(texture); - layer.setupRenderState(); - if(provider instanceof MultiBufferSource.BufferSource immediate){ - immediate.endBatch(); - } - if(provider == null){ - Tesselator.getInstance().getBuilder().begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.NEW_ENTITY); - vc = Tesselator.getInstance().getBuilder(); - RenderSystem.setShader(GameRenderer::getRendertypeEntityTranslucentCullShader); - } else { - vc = provider.getBuffer(layer); - } - return vc; - } - - private static void endDraw(@Nullable MultiBufferSource provider, ResourceLocation texture, VertexConsumer vc){ - if(provider == null){ - RenderType layer = RenderType.entityTranslucentCull(texture); - layer.end(Tesselator.getInstance().getBuilder(), VertexSorting.ORTHOGRAPHIC_Z); - } - } - - private static void textureVertex(VertexConsumer vc, PoseStack ps, float x, float y, float z, float u, float v, Vec3 normals, int light, int color){ - vc.vertex(ps.last().pose(), x, y, z) - .color(color) - .uv(u, v) - .overlayCoords(OverlayTexture.NO_OVERLAY) - .uv2(light) - .normal(ps.last().normal(), (float)normals.x, (float)normals.y, (float)normals.z) - .endVertex(); - } - - private static class SillyVCHelper implements VCDrawHelper{ - - private final MultiBufferSource provider; - private final Integer light; - private final Vec3 normVec; - private final float z; - private final PoseStack ps; - - private final boolean usesLight; - private final boolean usesNorm; - private final int modeIndex; - - private final int alpha; - - private static final RenderType rType = RenderType.solid(); - - private static final VertexFormat[] formatsList = { - DefaultVertexFormat.POSITION_COLOR, // no light no normals - DefaultVertexFormat.POSITION_COLOR_LIGHTMAP, // yes light no normals - DefaultVertexFormat.NEW_ENTITY // yes light yes normals - }; - - private static final List> shadersList = List.of( - GameRenderer::getPositionColorShader, // no light no normals - GameRenderer::getPositionColorLightmapShader, // yes light no normals - GameRenderer::getRendertypeEntityTranslucentCullShader // yes light yes normals - ); - - // need pose stack for normal matrix - public SillyVCHelper(@Nullable MultiBufferSource provider, PoseStack ps, Integer light, Vec3 normVec, float z, int color){ - this.provider = provider; - this.light = light; - this.normVec = normVec != null ? normVec : new Vec3(1,1,1); - this.z = z; - this.ps = ps; - - usesLight = light != null; - usesNorm = this.normVec != null && ps != null && usesLight; // doesn't really make sense to have norms without lighting? - modeIndex = (usesLight ? 1 : 0) + (usesNorm ? 1 : 0); // index of formats/shaders to use - alpha = FastColor.ARGB32.alpha(color); - } - - @NotNull - @Override - public VertexConsumer vcSetupAndSupply(@NotNull VertexFormat.Mode vertMode) { - // we're not actually using provider here because i don't see a render layer that actually supports this? - // TODOish: make our own render layer/type for it i guess if we really care, i don't think i do. - - if(provider instanceof MultiBufferSource.BufferSource immediate){ - immediate.endBatch(); - } - - Tesselator.getInstance().getBuilder().begin(vertMode, formatsList[modeIndex]); - if(usesNorm){ - RenderSystem.setShaderTexture(0, TheCoolerRenderLib.WHITE); -// rType.setupRenderState(); - } - RenderSystem.enableDepthTest(); - RenderSystem.disableCull(); - if(usesLight) { - Minecraft.getInstance().gameRenderer.lightTexture().turnOnLightLayer(); - } - if(usesNorm){ - RenderSystem.enableBlend(); - RenderSystem.blendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA); - if (Minecraft.useShaderTransparency()) { - Minecraft.getInstance().levelRenderer.getTranslucentTarget().bindWrite(false); - } - } - RenderSystem.setShader( shadersList.get(modeIndex)); - return Tesselator.getInstance().getBuilder(); - } - - @Override - public void vertex(@NotNull VertexConsumer vc, int color, @NotNull Vec2 pos, @NotNull Matrix4f matrix) { - - vc.vertex(matrix, pos.x, pos.y, z) - .color(color | 0xFF_000000); - - if (usesNorm) vc.uv(pos.x, pos.y); // block format needs a texture, we just set it to plain white - if (usesNorm) vc.overlayCoords(OverlayTexture.NO_OVERLAY); - if (usesLight) vc.uv2(light); - if (usesNorm) vc.normal(ps.last().normal(), (float)normVec.x, (float)normVec.y, (float)normVec.z); - - vc.endVertex(); - } - - @Override - public void vcEndDrawer(@NotNull VertexConsumer vc) { - RenderSystem.setShaderColor(1f, 1f, 1f, alpha/255f); - Tesselator.getInstance().end(); - RenderSystem.setShaderColor(1f, 1f, 1f, 1f); - if(usesLight){ - Minecraft.getInstance().gameRenderer.lightTexture().turnOffLightLayer(); - } - if(usesNorm){ - RenderSystem.disableBlend(); - RenderSystem.defaultBlendFunc(); - if (Minecraft.useShaderTransparency()) { - Minecraft.getInstance().getMainRenderTarget().bindWrite(false); - } - } - RenderSystem.enableCull(); -// if(usesNorm){ -// rType.clearRenderState(); -// } - } - } + public record WorldlyBits(@Nullable MultiBufferSource provider, Integer light, Vec3 normal){}; } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt b/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt index 77992f111a..ee7b35b97c 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt @@ -1,18 +1,41 @@ package at.petrak.hexcasting.client.render -import com.mojang.blaze3d.vertex.DefaultVertexFormat -import com.mojang.blaze3d.vertex.Tesselator -import com.mojang.blaze3d.vertex.VertexConsumer -import com.mojang.blaze3d.vertex.VertexFormat +import at.petrak.hexcasting.client.render.PatternRenderer.WorldlyBits +import com.ibm.icu.impl.CurrencyData.provider +import com.mojang.blaze3d.platform.GlStateManager +import com.mojang.blaze3d.systems.RenderSystem +import com.mojang.blaze3d.vertex.* +import net.minecraft.client.Minecraft +import net.minecraft.client.renderer.GameRenderer +import net.minecraft.client.renderer.LightTexture +import net.minecraft.client.renderer.MultiBufferSource +import net.minecraft.client.renderer.RenderType +import net.minecraft.client.renderer.texture.OverlayTexture +import net.minecraft.resources.ResourceLocation import net.minecraft.world.phys.Vec2 +import net.minecraft.world.phys.Vec3 import org.joml.Matrix4f interface VCDrawHelper { fun vcSetupAndSupply(vertMode: VertexFormat.Mode): VertexConsumer - fun vertex(vc: VertexConsumer, color: Int, pos: Vec2, matrix: Matrix4f) + fun vertex(vc: VertexConsumer, color: Int, pos: Vec2, matrix: Matrix4f){ + vertex(vc, color, pos, Vec2(0f,0f), matrix) + } + fun vertex(vc: VertexConsumer, color: Int, pos: Vec2, uv: Vec2, matrix: Matrix4f) + fun vcEndDrawer(vc: VertexConsumer) + companion object { + @JvmStatic + fun getHelper(worldlyBits: WorldlyBits?, ps: PoseStack, z: Float, texture: ResourceLocation) : VCDrawHelper{ + if(worldlyBits != null){ + return Worldly(worldlyBits, ps, z, texture) + } + return Basic(z) + } + } + class Basic(val z: Float) : VCDrawHelper { override fun vcSetupAndSupply(vertMode: VertexFormat.Mode): VertexConsumer{ @@ -21,11 +44,83 @@ interface VCDrawHelper { buf.begin(vertMode, DefaultVertexFormat.POSITION_COLOR) return buf } - override fun vertex(vc: VertexConsumer, color: Int, pos: Vec2, matrix: Matrix4f){ + override fun vertex(vc: VertexConsumer, color: Int, pos: Vec2, uv: Vec2, matrix: Matrix4f){ vc.vertex(matrix, pos.x, pos.y, z).color(color).endVertex() } override fun vcEndDrawer(vc: VertexConsumer){ Tesselator.getInstance().end() } } + + class Worldly(val worldlyBits: WorldlyBits, val ps: PoseStack, val z: Float, val texture: ResourceLocation) : VCDrawHelper { + + var lastVertMode: VertexFormat.Mode ?= null // i guess this assumes that the vcHelper is only used once at a time? maybe reconsider that + + override fun vcSetupAndSupply(vertMode: VertexFormat.Mode): VertexConsumer{ + val provider = worldlyBits.provider + if (provider is MultiBufferSource.BufferSource) { + // tells it to draw whatever was here before so that we don't get depth buffer weirdness + provider.endBatch() + } + lastVertMode = vertMode + val buf = Tesselator.getInstance().builder + if(vertMode == VertexFormat.Mode.QUADS){ + val layer = RenderType.entityTranslucentCull(texture) + layer.setupRenderState() + if (provider == null) { + buf.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.NEW_ENTITY) + RenderSystem.setShader { GameRenderer.getRendertypeEntityTranslucentCullShader() } + return buf + } else { + return provider.getBuffer(layer) + } + } + buf.begin( vertMode, DefaultVertexFormat.NEW_ENTITY ) + // Generally this would be handled by a RenderLayer, but that doesn't seem to actually work here,, + RenderSystem.setShaderTexture(0, TheCoolerRenderLib.WHITE) + RenderSystem.enableDepthTest() + RenderSystem.disableCull() + Minecraft.getInstance().gameRenderer.lightTexture().turnOnLightLayer() + RenderSystem.enableBlend() + RenderSystem.blendFuncSeparate( GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, + GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA ) + if (Minecraft.useShaderTransparency()) { + Minecraft.getInstance().levelRenderer.translucentTarget!!.bindWrite(false) + } + RenderSystem.setShader( GameRenderer::getRendertypeEntityTranslucentCullShader ) + return buf + } + + override fun vertex(vc: VertexConsumer, color: Int, pos: Vec2, uv: Vec2, matrix: Matrix4f){ + val nv = worldlyBits.normal?: Vec3(1.0, 1.0, 1.0) + vc.vertex(matrix, pos.x, pos.y, z) + .color(color) + .uv(uv.x, uv.y) + .overlayCoords(OverlayTexture.NO_OVERLAY) + .uv2(worldlyBits.light?: LightTexture.FULL_BRIGHT ) + .normal(ps.last().normal(), nv.x.toFloat(), nv.y.toFloat(), nv.z.toFloat()) + + vc.endVertex() + } + override fun vcEndDrawer(vc: VertexConsumer){ + if(lastVertMode == VertexFormat.Mode.QUADS){ + if (provider == null) { + val layer = RenderType.entityTranslucentCull(texture) + layer.end(Tesselator.getInstance().builder, VertexSorting.ORTHOGRAPHIC_Z) + } + } else { + Tesselator.getInstance().end() + Minecraft.getInstance().gameRenderer.lightTexture().turnOffLightLayer() + RenderSystem.disableBlend() + RenderSystem.defaultBlendFunc() + if (Minecraft.useShaderTransparency()) { + Minecraft.getInstance().mainRenderTarget.bindWrite(false) + } + RenderSystem.enableCull() + } + lastVertMode = null + } + } + + } \ No newline at end of file diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index 3021764cfe..44935597fc 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -150,7 +150,8 @@ public static void renderPattern(HexPattern pattern, PatternRenderSettings patSe // ps.scale(x, y, z); ps.translate(0,0, z); // VertexConsumer verts = bufSource.getBuffer(RenderType.entityCutout(TheCoolerRenderLib.WHITE)); - PatternRenderer.renderPattern(pattern, ps, bufSource, patSets, patColors, seed, light, nVec, blockSize * PatternTextureManager.resolutionByBlockSize); + PatternRenderer.renderPattern(pattern, ps, new PatternRenderer.WorldlyBits(bufSource, light, nVec), + patSets, patColors, seed, blockSize * PatternTextureManager.resolutionByBlockSize); // PatternRenderer.renderPattern(pattern, ps, null, patSets, patColors, seed, light, nVec); // ResourceLocation texture = PatternTextureManager.getTexture(zappyPoints, pointsKey, blockSize, showStrokeOrder, lineWidth, useFullSize, new Color(innerColor), new Color(outerColor)); diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index 7894235bf8..e371bd1bb5 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -36,8 +36,8 @@ public int render(InlinePatternData data, GuiGraphics drawContext, int index, St if(FastColor.ARGB32.alpha(color) == 0){ color |= 0xFF_000000; } - PatternRenderer.renderPattern(data.pattern, drawContext.pose(), trContext.vertexConsumers, INLINE_RENDER_SETTINGS, - new PatternColors(color), 0, trContext.light, null, INLINE_TEXTURE_RES); + PatternRenderer.renderPattern(data.pattern, drawContext.pose(), new PatternRenderer.WorldlyBits(trContext.vertexConsumers, trContext.light, null), + INLINE_RENDER_SETTINGS, new PatternColors(color), 0, INLINE_TEXTURE_RES); drawContext.pose().popPose(); return charWidth(data, style, codepoint); From b65434af61be8e6f5a567e9d12bc03477ffb05c4 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Wed, 17 Jul 2024 22:58:39 -0400 Subject: [PATCH 26/48] remove some dead code --- .../client/render/PatternRenderer.java | 25 +-- .../client/render/PatternTextureManager.java | 1 + .../client/render/TheCoolerRenderLib.java | 155 ------------------ .../hexcasting/client/render/VCDrawHelper.kt | 12 +- .../render/WorldlyPatternRenderHelpers.java | 53 +----- 5 files changed, 20 insertions(+), 226 deletions(-) delete mode 100644 Common/src/main/java/at/petrak/hexcasting/client/render/TheCoolerRenderLib.java diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index ae622efd86..2362683678 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -7,7 +7,6 @@ import com.mojang.blaze3d.vertex.VertexConsumer; import com.mojang.blaze3d.vertex.VertexFormat; import net.minecraft.client.renderer.MultiBufferSource; -import net.minecraft.client.renderer.ShaderInstance; import net.minecraft.resources.ResourceLocation; import net.minecraft.util.FastColor; import net.minecraft.world.phys.Vec2; @@ -54,30 +53,28 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Wor if(FastColor.ARGB32.alpha(patColors.outerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.outerStartColor) != 0){ RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), - patColors.outerEndColor, patColors.outerStartColor, VCDrawHelper.getHelper(worldlyBits, ps,0.001f, TheCoolerRenderLib.WHITE)); + patColors.outerEndColor, patColors.outerStartColor, VCDrawHelper.getHelper(worldlyBits, ps,0.001f)); } if(FastColor.ARGB32.alpha(patColors.innerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.innerStartColor) != 0) { RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.innerWidthProvider.apply((float) (staticPoints.finalScale)), - patColors.innerEndColor, patColors.innerStartColor, VCDrawHelper.getHelper(worldlyBits, ps,0.0005f, TheCoolerRenderLib.WHITE)); + patColors.innerEndColor, patColors.innerStartColor, VCDrawHelper.getHelper(worldlyBits, ps,0.0005f)); } } - // render dots and grid dynamically for now - -// if(provider == null) provider.getBuffer(RenderType.solid()); // just to try to refresh it + // render dots and grid dynamically float dotZ = 0.0004f; if(FastColor.ARGB32.alpha(patColors.startingDotColor) != 0) { RenderLib.drawSpot(ps.last().pose(), staticPoints.dotsScaled.get(0), patSets.startingDotRadiusProvider.apply((float) (staticPoints.finalScale)), - patColors.startingDotColor, VCDrawHelper.getHelper(worldlyBits, ps, dotZ, TheCoolerRenderLib.WHITE)); + patColors.startingDotColor, VCDrawHelper.getHelper(worldlyBits, ps, dotZ)); } if(FastColor.ARGB32.alpha(patColors.gridDotsColor) != 0) { for(int i = 1; i < staticPoints.dotsScaled.size(); i++){ Vec2 gridDot = staticPoints.dotsScaled.get(i); RenderLib.drawSpot(ps.last().pose(), gridDot, patSets.gridDotsRadiusProvider.apply((float) (staticPoints.finalScale)), - patColors.gridDotsColor, VCDrawHelper.getHelper(worldlyBits, ps, dotZ, TheCoolerRenderLib.WHITE)); + patColors.gridDotsColor, VCDrawHelper.getHelper(worldlyBits, ps, dotZ)); } } @@ -90,16 +87,7 @@ private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @N return false; } - Vec3 normalVec = worldlyBits.normal(); - int light = worldlyBits.light(); - MultiBufferSource provider = worldlyBits.provider(); - - if(normalVec == null) normalVec = new Vec3(1f, 1f, 1f); - - ShaderInstance oldShader = RenderSystem.getShader(); - Map textures = maybeTextures.get(); - HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); VertexConsumer vc; @@ -134,10 +122,9 @@ private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @N vcHelper.vcEndDrawer(vc); } - RenderSystem.setShader(() -> oldShader); return true; } - public record WorldlyBits(@Nullable MultiBufferSource provider, Integer light, Vec3 normal){}; + public record WorldlyBits(@Nullable MultiBufferSource provider, Integer light, Vec3 normal){} } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java index 114013315b..66f9a2737a 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java @@ -151,6 +151,7 @@ private static Tuple getTextureCoordinates(Vec2 point, HexPatt return new Tuple<>(x, y); } + // keeping this around just in case we ever decide to put the dots in the textures instead of dynamic private static void drawHexagon(Graphics2D g2d, int x, int y, int radius) { int fracOfCircle = 6; Polygon hexagon = new Polygon(); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/TheCoolerRenderLib.java b/Common/src/main/java/at/petrak/hexcasting/client/render/TheCoolerRenderLib.java deleted file mode 100644 index dc78179aad..0000000000 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/TheCoolerRenderLib.java +++ /dev/null @@ -1,155 +0,0 @@ -package at.petrak.hexcasting.client.render; - -import com.mojang.blaze3d.vertex.VertexConsumer; -import net.minecraft.client.renderer.texture.OverlayTexture; -import net.minecraft.resources.ResourceLocation; -import net.minecraft.util.Mth; -import net.minecraft.world.phys.Vec2; -import org.joml.Matrix3f; -import org.joml.Matrix4f; - -import java.util.List; - -import static at.petrak.hexcasting.api.HexAPI.modLoc; - -/** - * Entity/quad based render functions. Should probably be in RenderLib, but I don't want to rewrite to kotlin rn. - */ -public class TheCoolerRenderLib { - - public static final ResourceLocation WHITE = modLoc("textures/entity/white.png"); - - private static void vertexCol(Matrix4f mat, Matrix3f normal, int light, VertexConsumer verts, int col, Vec2 pos) { - verts.vertex(mat, -pos.x, pos.y, 0) - .color(col) - .uv(0, 0).overlayCoords(OverlayTexture.NO_OVERLAY).uv2(light) - .normal(normal, 0, 0, 1) - .endVertex(); - } - - public static void theCoolerDrawLineSeq(Matrix4f mat, Matrix3f normalMat, int light, VertexConsumer verts, - List points, float width, int color - ) { - if (points.size() <= 1) { - return; - } - - // TODO: abstract some of this out with RenderLib to stop WET code - var joinAngles = new float[points.size()]; - var joinOffsets = new float[points.size()]; - for (int i = 2; i < points.size(); i++) { - var p0 = points.get(i - 2); - var p1 = points.get(i - 1); - var p2 = points.get(i); - var prev = p1.add(p0.negated()); - var next = p2.add(p1.negated()); - var angle = (float) Mth.atan2( - prev.x * next.y - prev.y * next.x, - prev.x * next.x + prev.y * next.y); - joinAngles[i - 1] = angle; - var clamp = Math.min(prev.length(), next.length()) / (width * 0.5f); - joinOffsets[i - 1] = Mth.clamp(Mth.sin(angle) / (1 + Mth.cos(angle)), -clamp, clamp); - } - - for (var i = 0; i < points.size() - 1; i++) { - var p1 = points.get(i); - var p2 = points.get(i + 1); - - var tangent = p2.add(p1.negated()).normalized().scale(width * 0.5f); - var normal = new Vec2(-tangent.y, tangent.x); - - var jlow = joinOffsets[i]; - var jhigh = joinOffsets[i + 1]; - - var p1Down = p1.add(tangent.scale(Math.max(0f, jlow))).add(normal); - var p1Up = p1.add(tangent.scale(Math.max(0f, -jlow))).add(normal.negated()); - var p2Down = p2.add(tangent.scale(Math.max(0f, jhigh)).negated()).add(normal); - var p2Up = p2.add(tangent.scale(Math.max(0f, -jhigh)).negated()).add(normal.negated()); - - // Draw the chamfer hexagon as two trapezoids - // the points are in different orders to keep clockwise - vertexCol(mat, normalMat, light, verts, color, p1); - vertexCol(mat, normalMat, light, verts, color, p2); - vertexCol(mat, normalMat, light, verts, color, p2Up); - vertexCol(mat, normalMat, light, verts, color, p1Up); - - vertexCol(mat, normalMat, light, verts, color, p1); - vertexCol(mat, normalMat, light, verts, color, p1Down); - vertexCol(mat, normalMat, light, verts, color, p2Down); - vertexCol(mat, normalMat, light, verts, color, p2); - - if (i > 0) { - var sangle = joinAngles[i]; - var angle = Math.abs(sangle); - var rnormal = normal.negated(); - var joinSteps = Mth.ceil(angle * 180 / (RenderLib.CAP_THETA * Mth.PI)); - if (joinSteps < 1) continue; - - if (sangle < 0) { - var prevVert = new Vec2(p1.x - rnormal.x, p1.y - rnormal.y); - for (var j = 1; j <= joinSteps; j++) { - var fan = RenderLib.rotate(rnormal, -sangle * ((float) j / joinSteps)); - var fanShift = new Vec2(p1.x - fan.x, p1.y - fan.y); - - vertexCol(mat, normalMat, light, verts, color, p1); - vertexCol(mat, normalMat, light, verts, color, p1); - vertexCol(mat, normalMat, light, verts, color, fanShift); - vertexCol(mat, normalMat, light, verts, color, prevVert); - prevVert = fanShift; - } - } else { - var startFan = RenderLib.rotate(normal, -sangle); - var prevVert = new Vec2(p1.x - startFan.x, p1.y - startFan.y); - for (var j = joinSteps - 1; j >= 0; j--) { - var fan = RenderLib.rotate(normal, -sangle * ((float) j / joinSteps)); - var fanShift = new Vec2(p1.x - fan.x, p1.y - fan.y); - - vertexCol(mat, normalMat, light, verts, color, p1); - vertexCol(mat, normalMat, light, verts, color, p1); - vertexCol(mat, normalMat, light, verts, color, fanShift); - vertexCol(mat, normalMat, light, verts, color, prevVert); - prevVert = fanShift; - } - } - } - } - - for (var pair : new Vec2[][]{ - {points.get(0), points.get(1)}, - {points.get(points.size() - 1), points.get(points.size() - 2)} - }) { - var point = pair[0]; - var prev = pair[1]; - - var tangent = point.add(prev.negated()).normalized().scale(0.5f * width); - var normal = new Vec2(-tangent.y, tangent.x); - var joinSteps = Mth.ceil(180f / RenderLib.CAP_THETA); - for (int j = joinSteps; j > 0; j--) { - var fan0 = RenderLib.rotate(normal, -Mth.PI * ((float) j / joinSteps)); - var fan1 = RenderLib.rotate(normal, -Mth.PI * ((float) (j - 1) / joinSteps)); - - vertexCol(mat, normalMat, light, verts, color, point); - vertexCol(mat, normalMat, light, verts, color, point); - vertexCol(mat, normalMat, light, verts, color, point.add(fan1)); - vertexCol(mat, normalMat, light, verts, color, point.add(fan0)); - } - } - } - - public static void theCoolerDrawSpot(Matrix4f mat, Matrix3f normal, int light, VertexConsumer verts, - Vec2 point, float radius, int color) { - var fracOfCircle = 6; - for (int i = 0; i < fracOfCircle; i++) { - // We do need rects, irritatingly - // so we do fake triangles - vertexCol(mat, normal, light, verts, color, point); - vertexCol(mat, normal, light, verts, color, point); - for (int j = 0; j <= 1; j++) { - var theta = (i - j) / (float) fracOfCircle * Mth.TWO_PI; - var rx = Mth.cos(theta) * radius + point.x; - var ry = Mth.sin(theta) * radius + point.y; - vertexCol(mat, normal, light, verts, color, new Vec2(rx, ry)); - } - } - } -} diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt b/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt index ee7b35b97c..9372ad3d0b 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt @@ -1,5 +1,6 @@ package at.petrak.hexcasting.client.render +import at.petrak.hexcasting.api.HexAPI import at.petrak.hexcasting.client.render.PatternRenderer.WorldlyBits import com.ibm.icu.impl.CurrencyData.provider import com.mojang.blaze3d.platform.GlStateManager @@ -27,6 +28,10 @@ interface VCDrawHelper { fun vcEndDrawer(vc: VertexConsumer) companion object { + + @JvmStatic + val WHITE: ResourceLocation = HexAPI.modLoc("textures/entity/white.png") + @JvmStatic fun getHelper(worldlyBits: WorldlyBits?, ps: PoseStack, z: Float, texture: ResourceLocation) : VCDrawHelper{ if(worldlyBits != null){ @@ -34,6 +39,11 @@ interface VCDrawHelper { } return Basic(z) } + + @JvmStatic + fun getHelper(worldlyBits: WorldlyBits?, ps: PoseStack, z: Float) : VCDrawHelper{ + return getHelper(worldlyBits, ps, z, WHITE) + } } class Basic(val z: Float) : VCDrawHelper { @@ -77,7 +87,7 @@ interface VCDrawHelper { } buf.begin( vertMode, DefaultVertexFormat.NEW_ENTITY ) // Generally this would be handled by a RenderLayer, but that doesn't seem to actually work here,, - RenderSystem.setShaderTexture(0, TheCoolerRenderLib.WHITE) + RenderSystem.setShaderTexture(0, texture) RenderSystem.enableDepthTest() RenderSystem.disableCull() Minecraft.getInstance().gameRenderer.lightTexture().turnOnLightLayer() diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index 44935597fc..3c06a64313 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -9,17 +9,13 @@ import at.petrak.hexcasting.common.entities.EntityWallScroll; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.PoseStack; -import com.mojang.blaze3d.vertex.VertexConsumer; import com.mojang.math.Axis; import net.minecraft.client.renderer.GameRenderer; import net.minecraft.client.renderer.LightTexture; import net.minecraft.client.renderer.MultiBufferSource; -import net.minecraft.client.renderer.texture.OverlayTexture; import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.block.state.properties.AttachFace; import net.minecraft.world.phys.Vec3; -import org.joml.Matrix3f; -import org.joml.Matrix4f; /** * Helper methods for rendering patterns in the world. @@ -101,12 +97,8 @@ public static void renderPattern(HexPattern pattern, PatternRenderSettings patSe { ps.pushPose(); - PoseStack.Pose last = ps.last(); - Matrix4f mat = last.pose(); - Matrix3f normal = last.normal(); - float x = blockSize, y = blockSize, z = (-1f / 16f) - 0.01f; - float nx = 0, ny = 0, nz = 0; + float z = (-1f / 16f) - 0.01f; PSTransformer transformer; @@ -135,57 +127,16 @@ public static void renderPattern(HexPattern pattern, PatternRenderSettings patSe } Vec3 nVec = transformer.transform(ps, facing, blockSize); - nx = (float)nVec.x(); - ny = (float)nVec.y(); - nz = (float)nVec.z(); ps.scale(blockSize, blockSize, 1); - - int lineWidth = PatternTextureManager.otherLineWidth; - int outerColor = 0xff_d2c8c8; - int innerColor = 0xc8_322b33; - if(isScroll) - lineWidth = PatternTextureManager.scrollLineWidth; - -// ps.scale(x, y, z); ps.translate(0,0, z); -// VertexConsumer verts = bufSource.getBuffer(RenderType.entityCutout(TheCoolerRenderLib.WHITE)); + PatternRenderer.renderPattern(pattern, ps, new PatternRenderer.WorldlyBits(bufSource, light, nVec), patSets, patColors, seed, blockSize * PatternTextureManager.resolutionByBlockSize); -// PatternRenderer.renderPattern(pattern, ps, null, patSets, patColors, seed, light, nVec); - -// ResourceLocation texture = PatternTextureManager.getTexture(zappyPoints, pointsKey, blockSize, showStrokeOrder, lineWidth, useFullSize, new Color(innerColor), new Color(outerColor)); -// VertexConsumer verts = bufSource.getBuffer(RenderType.entityCutout(texture)); -// -// vertex(mat, normal, light, verts, 0, 0, z, 0, 0, nx, ny, nz); -// vertex(mat, normal, light, verts, 0, y, z, 0, 1, nx, ny, nz); -// vertex(mat, normal, light, verts, x, y, z, 1, 1, nx, ny, nz); -// vertex(mat, normal, light, verts, x, 0, z, 1, 0, nx, ny, nz); ps.popPose(); } - - -// public static HexPatternPoints generateHexPatternPoints(HexBlockEntity tile, HexPattern pattern, float flowIrregular) -// { -// var stupidHash = tile.getBlockPos().hashCode(); -// var lines1 = pattern.toLines(1, Vec2.ZERO); -// var zappyPoints = RenderLib.makeZappy(lines1, RenderLib.findDupIndices(pattern.positions()), -// 10, 0.5f, 0f, flowIrregular, 0f, 1f, stupidHash); -// return new HexPatternPoints(zappyPoints); -// } - - private static void vertex(Matrix4f mat, Matrix3f normal, int light, VertexConsumer verts, float x, float y, float z, - float u, float v, float nx, float ny, float nz) { - verts.vertex(mat, x, y, z) - .color(0xffffffff) - .uv(u, v).overlayCoords(OverlayTexture.NO_OVERLAY).uv2(light) - .normal(normal, nx, ny, nz) - .endVertex(); - } - - @FunctionalInterface public interface PSTransformer{ Vec3 transform(PoseStack ps, int facing, int blocksize); From 4ba222b335707665769b78807130d632b86dee2f Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Thu, 18 Jul 2024 01:11:18 -0400 Subject: [PATCH 27/48] clean up worldly renderers - get rid of icky ps transformer stuff --- .../render/WorldlyPatternRenderHelpers.java | 203 +++++------------- 1 file changed, 51 insertions(+), 152 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index 3c06a64313..0050a6503b 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -1,22 +1,21 @@ package at.petrak.hexcasting.client.render; -import at.petrak.hexcasting.api.block.HexBlockEntity; import at.petrak.hexcasting.api.casting.math.HexPattern; import at.petrak.hexcasting.common.blocks.akashic.BlockAkashicBookshelf; import at.petrak.hexcasting.common.blocks.akashic.BlockEntityAkashicBookshelf; import at.petrak.hexcasting.common.blocks.circles.BlockEntitySlate; import at.petrak.hexcasting.common.blocks.circles.BlockSlate; import at.petrak.hexcasting.common.entities.EntityWallScroll; -import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.PoseStack; import com.mojang.math.Axis; -import net.minecraft.client.renderer.GameRenderer; -import net.minecraft.client.renderer.LightTexture; import net.minecraft.client.renderer.MultiBufferSource; +import net.minecraft.core.Vec3i; import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.block.state.properties.AttachFace; import net.minecraft.world.phys.Vec3; +import javax.annotation.Nullable; + /** * Helper methods for rendering patterns in the world. */ @@ -51,12 +50,18 @@ public class WorldlyPatternRenderHelpers { public static void renderPatternForScroll(HexPattern pattern, EntityWallScroll scroll, PoseStack ps, MultiBufferSource bufSource, int light, int blockSize, boolean showStrokeOrder) { ps.pushPose(); + ps.translate(-blockSize / 2f, -blockSize / 2f, 1f / 32f); renderPattern(pattern, showStrokeOrder ? READABLE_SCROLL_RENDER_SETTINGS : SCROLL_RENDER_SETTINGS, showStrokeOrder ? READABLE_SCROLL_COLORS : DEFAULT_PATTERN_COLOR, - scroll.getPos().hashCode(), ps, bufSource, light, blockSize, true, false,false, true,-1); + scroll.getPos().hashCode(), ps, bufSource, null, null, light, blockSize); ps.popPose(); } + private static final int[] WALL_ROTATIONS = {180, 270, 0, 90}; + private static final Vec3i[] SLATE_FACINGS = {new Vec3i(0, -1, 0), new Vec3i(-1, -1, 0), new Vec3i(-1, -1, 1), new Vec3i(0, -1 , 1)}; + private static final Vec3[] WALL_NORMALS = {new Vec3(0, 0, -1), new Vec3(-1, 0, 0), new Vec3(0, 0, -1), new Vec3(-1, 0, 0)}; + private static final Vec3i[] SLATE_FLOORCEIL_FACINGS = {new Vec3i(0,0,0), new Vec3i(1,0,0), new Vec3i(1,0,1), new Vec3i(0,0,1)}; + public static void renderPatternForSlate(BlockEntitySlate tile, HexPattern pattern, PoseStack ps, MultiBufferSource buffer, int light, BlockState bs) { @@ -66,179 +71,73 @@ public static void renderPatternForSlate(BlockEntitySlate tile, HexPattern patte boolean wombly = bs.getValue(BlockSlate.ENERGIZED); - renderPatternForBlockEntity(pattern, tile, + ps.pushPose(); + + Vec3 normal = null; + if(isOnWall){ + ps.mulPose(Axis.ZP.rotationDegrees(180)); + Vec3i tV = SLATE_FACINGS[facing % 4]; + ps.translate(tV.getX(), tV.getY(), tV.getZ()); + ps.mulPose(Axis.YP.rotationDegrees(WALL_ROTATIONS[facing % 4])); + normal = WALL_NORMALS[facing % 4]; + } else { + Vec3i tV = SLATE_FLOORCEIL_FACINGS[facing % 4]; + ps.translate(tV.getX(), tV.getY(), tV.getZ()); + + ps.mulPose(Axis.YP.rotationDegrees(facing*-90)); + ps.mulPose(Axis.XP.rotationDegrees(90 * (isOnCeiling ? -1 : 1))); + if(isOnCeiling) ps.translate(0,-1,1); + + normal = new Vec3(0, 0, -1); + } + + renderPattern(pattern, wombly ? SLATE_WOMBLY_SETTINGS : WORLDLY_RENDER_SETTINGS, wombly ? SLATE_WOBBLY_COLOR : DEFAULT_PATTERN_COLOR, - ps, buffer, light, isOnWall, isOnCeiling, true, facing); + tile.getBlockPos().hashCode(), ps, buffer, normal, null, light, 1); + ps.popPose(); } + private static final Vec3i[] BLOCK_FACINGS = {new Vec3i(0, -1, 1), new Vec3i(0, -1, 0), new Vec3i(-1, -1, 0), new Vec3i(-1, -1, 1)}; + public static void renderPatternForAkashicBookshelf(BlockEntityAkashicBookshelf tile, HexPattern pattern, PoseStack ps, MultiBufferSource buffer, int light, BlockState bs) { + int facing = bs.getValue(BlockAkashicBookshelf.FACING).get2DDataValue(); - renderPatternForBlockEntity(pattern, tile, WORLDLY_RENDER_SETTINGS, DEFAULT_PATTERN_COLOR, ps, buffer, LightTexture.FULL_BRIGHT, true, false, false, facing); - } - public static void renderPatternForBlockEntity(HexPattern pattern, HexBlockEntity tile, PatternRenderSettings patSets, PatternColors patColors, PoseStack ps, MultiBufferSource buffer, int light, boolean isOnWall, boolean isOnCeiling, boolean isSlate, int facing) - { - var oldShader = RenderSystem.getShader(); ps.pushPose(); - RenderSystem.setShader(GameRenderer::getPositionTexShader); - renderPattern(pattern, patSets, patColors, tile.getBlockPos().hashCode(), ps, buffer, light, 1, isOnWall, isOnCeiling, isSlate, false, facing); + ps.mulPose(Axis.ZP.rotationDegrees(180)); + + Vec3i tV = BLOCK_FACINGS[facing % 4]; + ps.translate(tV.getX(), tV.getY(), tV.getZ()); + ps.mulPose(Axis.YP.rotationDegrees(WALL_ROTATIONS[facing % 4])); + + renderPattern(pattern, WORLDLY_RENDER_SETTINGS, DEFAULT_PATTERN_COLOR, + tile.getBlockPos().hashCode(), ps, buffer, WALL_NORMALS[facing % 4], -0.02f, light, 1); ps.popPose(); - RenderSystem.setShader(() -> oldShader); } - // TODO: clean up the args of this method, maybe make the whole PSTransformer thing less gross, move it to be just code in the methods or something maybe. - /** * Renders a pattern in world space based on the given transform requirements */ - public static void renderPattern(HexPattern pattern, PatternRenderSettings patSets, PatternColors patColors, double seed, PoseStack ps, MultiBufferSource bufSource, int light, int blockSize, boolean isOnWall, boolean isOnCeiling, boolean isSlate, boolean isScroll, int facing) + public static void renderPattern(HexPattern pattern, PatternRenderSettings patSets, PatternColors patColors, + double seed, PoseStack ps, MultiBufferSource bufSource, Vec3 normal, @Nullable Float zOffset, + int light, int blockSize) { + ps.pushPose(); - float z = (-1f / 16f) - 0.01f; - - PSTransformer transformer; - - if(isOnWall) - { - if(isScroll) - { - transformer = wallScrollTransformer; - } - else - { - if(isSlate) - { - transformer = wallSlateTransformer; - } - else - { - transformer = wallBlockTransformer; - z = -0.02f; - } - } - } - else //slates on the floor or ceiling - { - transformer = isOnCeiling ? ceilSlateTransformer : floorSlateTransformer; - } + float z = zOffset != null ? zOffset : ((-1f / 16f) - 0.01f); - Vec3 nVec = transformer.transform(ps, facing, blockSize); + normal = normal != null ? normal : new Vec3(0, 0, -1); ps.scale(blockSize, blockSize, 1); ps.translate(0,0, z); - PatternRenderer.renderPattern(pattern, ps, new PatternRenderer.WorldlyBits(bufSource, light, nVec), + PatternRenderer.renderPattern(pattern, ps, new PatternRenderer.WorldlyBits(bufSource, light, normal), patSets, patColors, seed, blockSize * PatternTextureManager.resolutionByBlockSize); ps.popPose(); } - - @FunctionalInterface - public interface PSTransformer{ - Vec3 transform(PoseStack ps, int facing, int blocksize); - } - - public static final PSTransformer wallScrollTransformer = (ps, facing, blockSize) -> { - ps.translate(-blockSize / 2f, -blockSize / 2f, 1f / 32f); - if(facing == 0){ - return new Vec3(0, 0, -1); - } - if(facing == 1){ - return new Vec3(-1, 0, 0); - } - if(facing == 2){ - return new Vec3(0, 0, -1); - } - if(facing == 3){ - return new Vec3(-1, 0, 0); - } - return new Vec3(0, 0, -1); - }; - - public static final PSTransformer floorSlateTransformer = (ps, facing, blockSize) -> { - if(facing == 0) - ps.translate(0,0,0); - if(facing == 1) - ps.translate(1,0,0); - if(facing == 2) - ps.translate(1,0,1); - if(facing == 3) - ps.translate(0,0,1); - - ps.mulPose(Axis.YP.rotationDegrees(facing*-90)); - ps.mulPose(Axis.XP.rotationDegrees(90)); - - return new Vec3(0, 0, -1); - }; - - public static final PSTransformer ceilSlateTransformer = (ps, facing, blockSize) -> { - if(facing == 0) - ps.translate(0,0,0); - if(facing == 1) - ps.translate(1,0,0); - if(facing == 2) - ps.translate(1,0,1); - if(facing == 3) - ps.translate(0,0,1); - - ps.mulPose(Axis.YP.rotationDegrees(facing*-90)); - ps.mulPose(Axis.XP.rotationDegrees(-90)); - ps.translate(0,-1,1); - - return new Vec3(0, 0, -1); - }; - - public static final PSTransformer wallSlateTransformer = (ps, facing, blocksize) -> { - ps.mulPose(Axis.ZP.rotationDegrees(180)); - - if(facing == 0){ - ps.translate(0,-1,0); - ps.mulPose(Axis.YP.rotationDegrees(180)); - return new Vec3(0, 0, -1); - } - if(facing == 1){ - ps.translate(-1,-1,0); - ps.mulPose(Axis.YP.rotationDegrees(270)); - return new Vec3(-1, 0, 0); - } - if(facing == 2){ - ps.translate(-1,-1,1); - return new Vec3(0, 0, -1); - } - if(facing == 3){ - ps.translate(0,-1,1); - ps.mulPose(Axis.YP.rotationDegrees(90)); - return new Vec3(-1, 0, 0); - } - return new Vec3(0,0,0); - }; - - public static final PSTransformer wallBlockTransformer = (ps, facing, blocksize) -> { - ps.mulPose(Axis.ZP.rotationDegrees(180)); - - if(facing == 0){ - ps.translate(0,-1,1); - ps.mulPose(Axis.YP.rotationDegrees(180)); - return new Vec3(0, 0, -1); - } - if(facing == 1){ - ps.translate(0,-1,0); - ps.mulPose(Axis.YP.rotationDegrees(270)); - return new Vec3(-1, 0, 0); - } - if(facing == 2){ - ps.translate(-1,-1,0); - return new Vec3(0, 0, -1); - } - if(facing == 3){ - ps.translate(-1,-1,1); - ps.mulPose(Axis.YP.rotationDegrees(90)); - return new Vec3(-1, 0, 0); - } - return new Vec3(0,0,0); - }; } From 414d14097b6ce96a7e38a24c181feebcd7412ac7 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Thu, 18 Jul 2024 01:14:32 -0400 Subject: [PATCH 28/48] delete old render code from bookshelves and scrolls --- .../client/entity/WallScrollRenderer.java | 34 --------- .../BlockEntityAkashicBookshelfRenderer.java | 70 +------------------ 2 files changed, 1 insertion(+), 103 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java index 02a626e776..d17e617cd9 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/entity/WallScrollRenderer.java @@ -99,40 +99,6 @@ public void render(EntityWallScroll wallScroll, float yaw, float partialTicks, P WorldlyPatternRenderHelpers.renderPatternForScroll(wallScroll.pattern, wallScroll, ps, bufSource, light, wallScroll.blockSize, wallScroll.getShowsStrokeOrder()); } - //TODO: remove old rendering if not needed anymore for comparison -// if (!PatternTextureManager.useTextures && wallScroll.points != null) { -// var points = wallScroll.points.zappyPoints; -// ps.pushPose(); -// -// ps.mulPose(Axis.YP.rotationDegrees(180f)); -// ps.translate(0, 0, 1.1f / 16f); -// // make smaller scrolls not be charlie kirk-sized -// // i swear, learning about these functions with asymptotes where slope != 0 is the most useful thing -// // I've ever learned in a math class -// float unCharlieKirk = Mth.sqrt(wallScroll.blockSize * wallScroll.blockSize + 60); -// float scale = 1f / 300f * unCharlieKirk; -// ps.scale(scale, scale, 0.01f); -// -// var last = ps.last(); -// var mat = last.pose(); -// var norm = last.normal(); -// var outer = 0xff_d2c8c8; -// var inner = 0xc8_322b33; -// var verts = bufSource.getBuffer(RenderType.entityCutout(WHITE)); -// theCoolerDrawLineSeq(mat, norm, light, verts, points, wallScroll.blockSize * 5f / 3f, outer); -// ps.translate(0, 0, 0.01); -// theCoolerDrawLineSeq(mat, norm, light, verts, points, wallScroll.blockSize * 2f / 3f, inner); -// -// if (wallScroll.getShowsStrokeOrder()) { -// ps.translate(0, 0, 0.01); -// var spotFrac = 0.8f * wallScroll.blockSize; -// theCoolerDrawSpot(mat, norm, light, verts, points.get(0), 2f / 3f * spotFrac, -// 0xff_5b7bd7); -// } -// -// ps.popPose(); -// } - ps.popPose(); super.render(wallScroll, yaw, partialTicks, ps, bufSource, packedLight); } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntityAkashicBookshelfRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntityAkashicBookshelfRenderer.java index f233ce6f4b..5bc52dc211 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntityAkashicBookshelfRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/be/BlockEntityAkashicBookshelfRenderer.java @@ -1,20 +1,12 @@ package at.petrak.hexcasting.client.render.be; import at.petrak.hexcasting.api.casting.math.HexPattern; -import at.petrak.hexcasting.client.render.PatternTextureManager; -import at.petrak.hexcasting.client.render.RenderLib; import at.petrak.hexcasting.client.render.WorldlyPatternRenderHelpers; -import at.petrak.hexcasting.common.blocks.akashic.BlockAkashicBookshelf; import at.petrak.hexcasting.common.blocks.akashic.BlockEntityAkashicBookshelf; -import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.PoseStack; -import com.mojang.math.Axis; -import net.minecraft.client.renderer.GameRenderer; import net.minecraft.client.renderer.MultiBufferSource; import net.minecraft.client.renderer.blockentity.BlockEntityRenderer; import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider; -import net.minecraft.util.Mth; -import net.minecraft.world.phys.Vec2; public class BlockEntityAkashicBookshelfRenderer implements BlockEntityRenderer { public BlockEntityAkashicBookshelfRenderer(BlockEntityRendererProvider.Context ctx) { @@ -31,66 +23,6 @@ public void render(BlockEntityAkashicBookshelf tile, float pPartialTick, PoseSta var bs = tile.getBlockState(); - if(PatternTextureManager.useTextures) { - WorldlyPatternRenderHelpers.renderPatternForAkashicBookshelf(tile, pattern, ps, buffer, light, bs); - return; - } - - //TODO: remove old rendering if not needed anymore for comparison - - var oldShader = RenderSystem.getShader(); - RenderSystem.setShader(GameRenderer::getPositionColorShader); - RenderSystem.enableDepthTest(); - - ps.pushPose(); - - ps.translate(0.5, 0.5, 0.5); - var quarters = (-bs.getValue(BlockAkashicBookshelf.FACING).get2DDataValue()) % 4; - ps.mulPose(Axis.YP.rotation(Mth.HALF_PI * quarters)); - ps.mulPose(Axis.ZP.rotation(Mth.PI)); - - // and now Z is out? - ps.translate(0, 0, 0.5); - ps.scale(1 / 16f, 1 / 16f, 1 / 16f); - ps.translate(0, 0, 0.01); - - // yoink code from the pattern greeble - // Do two passes: one with a random size to find a good COM and one with the real calculation - var com1 = pattern.getCenter(1); - var lines1 = pattern.toLines(1, Vec2.ZERO); - - var maxDx = -1f; - var maxDy = -1f; - for (var dot : lines1) { - var dx = Mth.abs(dot.x - com1.x); - if (dx > maxDx) { - maxDx = dx; - } - var dy = Mth.abs(dot.y - com1.y); - if (dy > maxDy) { - maxDy = dy; - } - } - var scale = Math.min(3.8f, Math.min(16 / 2.5f / maxDx, 16 / 2.5f / maxDy)); - - var com2 = pattern.getCenter(scale); - var lines2 = pattern.toLines(scale, com2.negated()); - // For some reason it is mirrored left to right and i can't seem to posestack-fu it into shape - for (int j = 0; j < lines2.size(); j++) { - var v = lines2.get(j); - lines2.set(j, new Vec2(-v.x, v.y)); - } - - var stupidHash = tile.getBlockPos().hashCode(); - var zappy = RenderLib.makeZappy(lines2, RenderLib.findDupIndices(pattern.positions()), 10, 0.5f, 0f, 0f, 0f, - 1f, stupidHash); - - int outer = 0xff_d2c8c8; - int inner = 0xc8_322b33; - RenderLib.drawLineSeq(ps.last().pose(), zappy, 1f, 0f, outer, outer); - RenderLib.drawLineSeq(ps.last().pose(), zappy, 0.4f, 0.01f, inner, inner); - - ps.popPose(); - RenderSystem.setShader(() -> oldShader); + WorldlyPatternRenderHelpers.renderPatternForAkashicBookshelf(tile, pattern, ps, buffer, light, bs); } } From 9bfb48e9e77e7a5ed93f3ca3eaf89cab7f1dba3c Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Fri, 19 Jul 2024 00:11:03 -0400 Subject: [PATCH 29/48] make tooltips use the new system. make circles purple. tweaks with normals and whatnot --- .../client/gui/PatternTooltipComponent.java | 61 ++++++------------- .../client/render/PatternRenderer.java | 12 ++-- .../hexcasting/client/render/VCDrawHelper.kt | 16 +++-- .../render/WorldlyPatternRenderHelpers.java | 18 ++++-- .../interop/inline/InlinePatternRenderer.java | 2 +- 5 files changed, 51 insertions(+), 58 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java b/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java index 42d768ddda..7ae61b387f 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java @@ -1,24 +1,17 @@ package at.petrak.hexcasting.client.gui; import at.petrak.hexcasting.api.casting.math.HexPattern; -import at.petrak.hexcasting.client.render.RenderLib; +import at.petrak.hexcasting.client.render.PatternRenderer; +import at.petrak.hexcasting.client.render.WorldlyPatternRenderHelpers; import at.petrak.hexcasting.common.misc.PatternTooltip; -import com.mojang.blaze3d.platform.GlStateManager; import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.vertex.PoseStack; import net.minecraft.client.gui.Font; import net.minecraft.client.gui.GuiGraphics; import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent; -import net.minecraft.client.renderer.GameRenderer; -import net.minecraft.client.renderer.entity.ItemRenderer; import net.minecraft.resources.ResourceLocation; import net.minecraft.world.inventory.tooltip.TooltipComponent; -import net.minecraft.world.phys.Vec2; import org.jetbrains.annotations.Nullable; -import java.util.List; -import java.util.stream.Collectors; - import static at.petrak.hexcasting.api.HexAPI.modLoc; // https://github.com/VazkiiMods/Botania/blob/95bd2d3fbc857b7c102687554e1d1b112f8af436/Xplat/src/main/java/vazkii/botania/client/gui/ManaBarTooltipComponent.java @@ -36,23 +29,23 @@ public class PatternTooltipComponent implements ClientTooltipComponent { private static final int TEXTURE_SIZE = 48; private final HexPattern pattern; - private final List zappyPoints; - private final List pathfinderDots; - private final float scale; +// private final List zappyPoints; +// private final List pathfinderDots; +// private final float scale; private final ResourceLocation background; public PatternTooltipComponent(PatternTooltip tt) { this.pattern = tt.pattern(); this.background = tt.background(); - var pair = RenderLib.getCenteredPattern(pattern, RENDER_SIZE, RENDER_SIZE, 16f); - this.scale = pair.getFirst(); - var dots = pair.getSecond(); - this.zappyPoints = RenderLib.makeZappy( - dots, RenderLib.findDupIndices(pattern.positions()), - 10, 0.8f, 0f, 0f, RenderLib.DEFAULT_READABILITY_OFFSET, RenderLib.DEFAULT_LAST_SEGMENT_LEN_PROP, - 0.0); - this.pathfinderDots = dots.stream().distinct().collect(Collectors.toList()); +// var pair = RenderLib.getCenteredPattern(pattern, RENDER_SIZE, RENDER_SIZE, 16f); +// this.scale = pair.getFirst(); +// var dots = pair.getSecond(); +// this.zappyPoints = RenderLib.makeZappy( +// dots, RenderLib.findDupIndices(pattern.positions()), +// 10, 0.8f, 0f, 0f, RenderLib.DEFAULT_READABILITY_OFFSET, RenderLib.DEFAULT_LAST_SEGMENT_LEN_PROP, +// 0.0); +// this.pathfinderDots = dots.stream().distinct().collect(Collectors.toList()); } @Nullable @@ -65,9 +58,6 @@ public static ClientTooltipComponent tryConvert(TooltipComponent cmp) { @Override public void renderImage(Font font, int mouseX, int mouseY, GuiGraphics graphics) { - var width = this.getWidth(font); - var height = this.getHeight(); - var ps = graphics.pose(); // far as i can tell "mouseX" and "mouseY" are actually the positions of the corner of the tooltip @@ -80,27 +70,14 @@ public void renderImage(Font font, int mouseX, int mouseY, GuiGraphics graphics) // RenderSystem.disableBlend(); ps.translate(0, 0, 100); - RenderSystem.setShader(GameRenderer::getPositionColorShader); - RenderSystem.disableCull(); - RenderSystem.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, - GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA); - ps.translate(width / 2f, height / 2f, 1); - - var mat = ps.last().pose(); - var outer = 0xff_d2c8c8; - var innerLight = 0xc8_aba2a2; - var innerDark = 0xc8_322b33; - RenderLib.drawLineSeq(mat, this.zappyPoints, 6f, 0, - outer, outer); - RenderLib.drawLineSeq(mat, this.zappyPoints, 6f * 0.4f, 0, - innerDark, innerLight); - RenderLib.drawSpot(mat, this.zappyPoints.get(0), 2.5f, 1f, 0.1f, 0.15f, 0.6f); - - for (var dot : this.pathfinderDots) { - RenderLib.drawSpot(mat, dot, 1.5f, 0.82f, 0.8f, 0.8f, 0.5f); - } + ps.pushPose(); + ps.scale(RENDER_SIZE, RENDER_SIZE, 1); + + PatternRenderer.renderPattern(pattern, ps, WorldlyPatternRenderHelpers.READABLE_SCROLL_RENDER_SETTINGS, + WorldlyPatternRenderHelpers.READABLE_GRID_SCROLL_COLORS, 0, 512); ps.popPose(); + ps.popPose(); } private static void renderBG(GuiGraphics graphics, ResourceLocation background) { diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index 2362683678..70351ad18c 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -53,17 +53,17 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Wor if(FastColor.ARGB32.alpha(patColors.outerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.outerStartColor) != 0){ RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), - patColors.outerEndColor, patColors.outerStartColor, VCDrawHelper.getHelper(worldlyBits, ps,0.001f)); + patColors.outerEndColor, patColors.outerStartColor, VCDrawHelper.getHelper(worldlyBits, ps,outerZ)); } if(FastColor.ARGB32.alpha(patColors.innerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.innerStartColor) != 0) { RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.innerWidthProvider.apply((float) (staticPoints.finalScale)), - patColors.innerEndColor, patColors.innerStartColor, VCDrawHelper.getHelper(worldlyBits, ps,0.0005f)); + patColors.innerEndColor, patColors.innerStartColor, VCDrawHelper.getHelper(worldlyBits, ps,innerZ)); } } // render dots and grid dynamically - float dotZ = 0.0004f; + float dotZ = 0.0011f; if(FastColor.ARGB32.alpha(patColors.startingDotColor) != 0) { RenderLib.drawSpot(ps.last().pose(), staticPoints.dotsScaled.get(0), patSets.startingDotRadiusProvider.apply((float) (staticPoints.finalScale)), @@ -81,6 +81,9 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Wor RenderSystem.setShader(() -> oldShader); } + private static final float outerZ = 0.0005f; + private static final float innerZ = 0.001f; + private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @Nullable WorldlyBits worldlyBits, PatternRenderSettings patSets, PatternColors patColors, double seed, int resPerUnit){ Optional> maybeTextures = PatternTextureManager.getTextures(pattern, patSets, seed, resPerUnit); if(maybeTextures.isEmpty()){ @@ -92,9 +95,6 @@ private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @N VertexConsumer vc; - float outerZ = 0.001f; - float innerZ = 0.0005f; - if(FastColor.ARGB32.alpha(patColors.outerStartColor) != 0) { VCDrawHelper vcHelper = VCDrawHelper.getHelper(worldlyBits, ps, outerZ, textures.get("outer")); vc = vcHelper.vcSetupAndSupply(VertexFormat.Mode.QUADS); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt b/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt index 9372ad3d0b..fb6c734e5f 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/VCDrawHelper.kt @@ -37,7 +37,7 @@ interface VCDrawHelper { if(worldlyBits != null){ return Worldly(worldlyBits, ps, z, texture) } - return Basic(z) + return Basic(z, texture) } @JvmStatic @@ -46,16 +46,23 @@ interface VCDrawHelper { } } - class Basic(val z: Float) : VCDrawHelper { + class Basic(val z: Float, val texture: ResourceLocation = WHITE) : VCDrawHelper { override fun vcSetupAndSupply(vertMode: VertexFormat.Mode): VertexConsumer{ val tess = Tesselator.getInstance() val buf = tess.builder - buf.begin(vertMode, DefaultVertexFormat.POSITION_COLOR) + buf.begin(vertMode, DefaultVertexFormat.POSITION_COLOR_TEX) + RenderSystem.setShader(GameRenderer::getPositionColorTexShader); + RenderSystem.disableCull() + RenderSystem.enableDepthTest() + RenderSystem.enableBlend() + RenderSystem.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, + GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA) + RenderSystem.setShaderTexture(0, texture) return buf } override fun vertex(vc: VertexConsumer, color: Int, pos: Vec2, uv: Vec2, matrix: Matrix4f){ - vc.vertex(matrix, pos.x, pos.y, z).color(color).endVertex() + vc.vertex(matrix, pos.x, pos.y, z).color(color).uv(uv.x, uv.y).endVertex() } override fun vcEndDrawer(vc: VertexConsumer){ Tesselator.getInstance().end() @@ -94,6 +101,7 @@ interface VCDrawHelper { RenderSystem.enableBlend() RenderSystem.blendFuncSeparate( GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA ) + RenderSystem.setShaderColor(1f, 1f, 1f, 1f); if (Minecraft.useShaderTransparency()) { Minecraft.getInstance().levelRenderer.translucentTarget!!.bindWrite(false) } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index 0050a6503b..f022409286 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -45,10 +45,15 @@ public class WorldlyPatternRenderHelpers { // partially for testing public static final PatternColors READABLE_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDotColors(0xff_5b7bd7, 0); + public static final PatternColors READABLE_GRID_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDotColors(0xff_5b7bd7, 0x80_d2c8c8); + public static final PatternColors SLATE_WOBBLY_COLOR = new PatternColors(RenderLib.screenCol(0xff_64c8ff), 0xff_64c8ff); + public static final PatternColors SLATE_WOBBLY_PURPLE_COLOR = new PatternColors(RenderLib.screenCol(0xff_cfa0f3), 0xff_cfa0f3); + public static void renderPatternForScroll(HexPattern pattern, EntityWallScroll scroll, PoseStack ps, MultiBufferSource bufSource, int light, int blockSize, boolean showStrokeOrder) { + // TODO: I think scroll normals are maybe slightly messed up or something?? idk, look into that maybe ps.pushPose(); ps.translate(-blockSize / 2f, -blockSize / 2f, 1f / 32f); renderPattern(pattern, showStrokeOrder ? READABLE_SCROLL_RENDER_SETTINGS : SCROLL_RENDER_SETTINGS, @@ -87,13 +92,11 @@ public static void renderPatternForSlate(BlockEntitySlate tile, HexPattern patte ps.mulPose(Axis.YP.rotationDegrees(facing*-90)); ps.mulPose(Axis.XP.rotationDegrees(90 * (isOnCeiling ? -1 : 1))); if(isOnCeiling) ps.translate(0,-1,1); - - normal = new Vec3(0, 0, -1); } renderPattern(pattern, wombly ? SLATE_WOMBLY_SETTINGS : WORLDLY_RENDER_SETTINGS, - wombly ? SLATE_WOBBLY_COLOR : DEFAULT_PATTERN_COLOR, + wombly ? SLATE_WOBBLY_PURPLE_COLOR : DEFAULT_PATTERN_COLOR, tile.getBlockPos().hashCode(), ps, buffer, normal, null, light, 1); ps.popPose(); } @@ -113,7 +116,7 @@ public static void renderPatternForAkashicBookshelf(BlockEntityAkashicBookshelf ps.mulPose(Axis.YP.rotationDegrees(WALL_ROTATIONS[facing % 4])); renderPattern(pattern, WORLDLY_RENDER_SETTINGS, DEFAULT_PATTERN_COLOR, - tile.getBlockPos().hashCode(), ps, buffer, WALL_NORMALS[facing % 4], -0.02f, light, 1); + tile.getBlockPos().hashCode(), ps, buffer, WALL_NORMALS[facing % 4].multiply(-1, -1, -1), -0.02f, light, 1); ps.popPose(); } @@ -132,8 +135,13 @@ public static void renderPattern(HexPattern pattern, PatternRenderSettings patSe normal = normal != null ? normal : new Vec3(0, 0, -1); - ps.scale(blockSize, blockSize, 1); ps.translate(0,0, z); + ps.scale(blockSize, blockSize, 1); + + + PoseStack noNormalInv = new PoseStack(); + noNormalInv.scale(1, 1, -1); + ps.mulPoseMatrix(noNormalInv.last().pose()); PatternRenderer.renderPattern(pattern, ps, new PatternRenderer.WorldlyBits(bufSource, light, normal), patSets, patColors, seed, blockSize * PatternTextureManager.resolutionByBlockSize); diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index e371bd1bb5..5228cfac0a 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -24,7 +24,7 @@ public ResourceLocation getId(){ .withZappySettings(null, 0f, 0f, 0f, 0f, null) .named("inline"); - public static final int INLINE_TEXTURE_RES = 8; // 64px is probably fine for such small images ? + public static final int INLINE_TEXTURE_RES = 16; // 128px so it looks good and pretty on up close signs and whatnot public int render(InlinePatternData data, GuiGraphics drawContext, int index, Style style, int codepoint, TextRenderingContext trContext){ drawContext.pose().pushPose(); From a9be061415f77881bc9892a8a3c753067827fbc2 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Mon, 22 Jul 2024 17:11:22 -0400 Subject: [PATCH 30/48] refactor pattern settings to be a bit more modular and easy to use --- .../client/gui/PatternTooltipComponent.java | 2 +- .../client/render/HexPatternPoints.java | 37 +++-- .../client/render/PatternColors.java | 2 +- .../client/render/PatternRenderSettings.java | 139 ------------------ .../client/render/PatternRenderer.java | 21 +-- .../client/render/PatternSettings.java | 109 ++++++++++++++ .../client/render/PatternTextureManager.java | 8 +- .../render/WorldlyPatternRenderHelpers.java | 48 +++--- .../interop/inline/InlinePatternRenderer.java | 17 ++- 9 files changed, 184 insertions(+), 199 deletions(-) delete mode 100644 Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java create mode 100644 Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java diff --git a/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java b/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java index 7ae61b387f..5aca32f52c 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java @@ -73,7 +73,7 @@ public void renderImage(Font font, int mouseX, int mouseY, GuiGraphics graphics) ps.pushPose(); ps.scale(RENDER_SIZE, RENDER_SIZE, 1); - PatternRenderer.renderPattern(pattern, ps, WorldlyPatternRenderHelpers.READABLE_SCROLL_RENDER_SETTINGS, + PatternRenderer.renderPattern(pattern, ps, WorldlyPatternRenderHelpers.READABLE_SCROLL_SETTINGS, WorldlyPatternRenderHelpers.READABLE_GRID_SCROLL_COLORS, 0, 512); ps.popPose(); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java index 83c2f7daaf..6e9bd63d29 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java @@ -40,7 +40,7 @@ public class HexPatternPoints { private static final ConcurrentMap CACHED_STATIC_POINTS = new ConcurrentHashMap<>(); - private HexPatternPoints(HexPattern pattern, PatternRenderSettings patSets, double seed) { + private HexPatternPoints(HexPattern pattern, PatternSettings patSets, double seed) { List dots = pattern.toLines(1, Vec2.ZERO); @@ -49,7 +49,8 @@ private HexPatternPoints(HexPattern pattern, PatternRenderSettings patSets, doub // always do space calculations with the static version of the pattern // so that it doesn't jump around resizing itself. List zappyPoints = RenderLib.makeZappy(dots, dupIndices, - patSets.hops, patSets.variance, 0f, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); + patSets.getHops(), patSets.getVariance(), 0f, patSets.getFlowIrregular(), + patSets.getReadabilityOffset(), patSets.getLastSegmentProp(), seed); this.zappyPoints = ImmutableList.copyOf(zappyPoints); @@ -67,40 +68,46 @@ private HexPatternPoints(HexPattern pattern, PatternRenderSettings patSets, doub int patStepsY = (int)Math.round(rangeY / 1.7); // scales the patterns so that each point is patSets.baseScale units apart - baseScale = patSets.baseScale / 1.5; + baseScale = patSets.getBaseScale() / 1.5; // size of the pattern in pose space with no other adjustments double baseWidth = rangeX * baseScale; double baseHeight = rangeY * baseScale; // make sure that the scale fits within our min sizes - scale = Math.max(1.0, Math.max(patSets.minWidth / baseWidth, patSets.minHeight / baseHeight)); + scale = Math.max(1.0, Math.max( + (patSets.getMinWidth() - patSets.getStrokeWidthGuess()) / baseWidth, + (patSets.getMinHeight() - patSets.getStrokeWidthGuess()) / baseHeight) + ); + boolean vertFit = patSets.getVertAlignment() != PatternSettings.AxisAlignment.NONE; + boolean horFit = patSets.getHorAlignment() != PatternSettings.AxisAlignment.NONE; // scale down if needed to fit in vertical space - if(patSets.fitAxis.vertFit){ - scale = Math.min(scale, (patSets.spaceHeight - 2 * patSets.vPadding)/(baseHeight)); + if(vertFit){ + scale = Math.min(scale, (patSets.getTargetHeight() - 2 * patSets.getVertPadding() - patSets.getStrokeWidthGuess())/(baseHeight)); } // scale down if needed to fit in horizontal space - if(patSets.fitAxis.horFit){ - scale = Math.min(scale, (patSets.spaceWidth - 2 * patSets.hPadding)/(baseWidth)); + if(horFit){ + scale = Math.min(scale, (patSets.getTargetWidth() - 2 * patSets.getHorPadding() - patSets.getStrokeWidthGuess())/(baseWidth)); } finalScale = baseScale * scale; + double finalStroke = patSets.getStrokeWidth(finalScale); // either the space given or however long it goes if it's not fitted. - double fullWidthTmp = (baseWidth * scale) + 2 * patSets.hPadding; - double fullHeightTmp = (baseHeight * scale) + 2 * patSets.vPadding; + double fullWidthTmp = (baseWidth * scale) + 2 * patSets.getHorPadding() + finalStroke; + double fullHeightTmp = (baseHeight * scale) + 2 * patSets.getVertPadding() + finalStroke; - if(patSets.fitAxis.horFit) fullWidthTmp = Math.max(patSets.spaceWidth, fullWidthTmp); - if(patSets.fitAxis.vertFit) fullHeightTmp = Math.max(patSets.spaceHeight, fullHeightTmp); + if(horFit) fullWidthTmp = Math.max(patSets.getTargetWidth(), fullWidthTmp); + if(vertFit) fullHeightTmp = Math.max(patSets.getTargetHeight(), fullHeightTmp); this.fullWidth = fullWidthTmp; this.fullHeight = fullHeightTmp; - offsetX = (fullWidthTmp - baseWidth * scale) / 2; - offsetY = (fullHeightTmp - baseHeight * scale) / 2; + offsetX = (fullWidthTmp - baseWidth * scale - finalStroke) / 2; + offsetY = (fullHeightTmp - baseHeight * scale - finalStroke) / 2; this.zappyPointsScaled = ImmutableList.copyOf(scaleVecs(zappyPoints)); this.dotsScaled = ImmutableList.copyOf(scaleVecs(dots)); @@ -128,7 +135,7 @@ public List scaleVecs(List points){ * This is used in rendering static patterns and positioning non-static patterns. * */ - public static HexPatternPoints getStaticPoints(HexPattern pattern, PatternRenderSettings patSets, double seed){ + public static HexPatternPoints getStaticPoints(HexPattern pattern, PatternSettings patSets, double seed){ String cacheKey = patSets.getCacheKey(pattern, seed); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java index c96c610cbc..3710c71be3 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java @@ -32,7 +32,7 @@ public PatternColors(int innerColor, int outerColor){ // single color -- no outer layer public PatternColors(int color){ - this(color, 0); + this(0, color); } // add dots -- note, this is how you tell the renderer to make dots diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java deleted file mode 100644 index a970043a74..0000000000 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderSettings.java +++ /dev/null @@ -1,139 +0,0 @@ -package at.petrak.hexcasting.client.render; - -import at.petrak.hexcasting.api.casting.math.HexPattern; - -import java.util.UUID; -import java.util.function.UnaryOperator; - -/** - * Immutable data class for informing how a pattern is rendered. - * - * (it's a pain but this isn't a record or kotlin data class because i want it non-final) - * - */ -public class PatternRenderSettings { - - protected FitAxis fitAxis; // which axes the pattern needs to be fit to. - - protected String id = "default"; - - // all measurements are in the scale of whatever pose stack is given to the renderer. - protected double baseScale; // length between 2 adjacent points if not squished by any fit. - protected double minWidth; - protected double minHeight; - - // height and with are only relevant if it's set to fit on that axis. - protected double spaceWidth = 1.0; - protected double spaceHeight = 1.0; - - // horizontal and vertical padding. used no matter the fit axis. - protected double hPadding; - protected double vPadding; - - protected UnaryOperator innerWidthProvider = (scale) -> 0.1f; - protected UnaryOperator outerWidthProvider = (scale) -> 0.15f; - - protected UnaryOperator startingDotRadiusProvider = (scale) -> this.innerWidthProvider.apply(scale) * 0.8f; - protected UnaryOperator gridDotsRadiusProvider = (scale) -> this.innerWidthProvider.apply(scale) * 0.4f; - - // zappy settings -- unused if you pass points instead of a pattern - protected int hops = 10; - protected float variance = 0.5f; - protected float speed; - protected float flowIrregular = 0.2f; - protected float readabilityOffset; - protected float lastSegmentLenProportion = 1f; - - public PatternRenderSettings(){} - - private PatternRenderSettings( - FitAxis fitAxis, double baseScale, double minWidth, double minHeight, double spaceWidth, double spaceHeight, - double hPadding, double vPadding, int hops, float variance, float speed, float flowIrregular, float readabilityOffset, - float lastSegmentLenProportion, UnaryOperator innerWidthProvider, UnaryOperator outerWidthProvider, - UnaryOperator startingDotRadiusProvider, UnaryOperator gridDotsRadiusProvider - ){ - this.fitAxis = fitAxis; this.baseScale = baseScale; this.minWidth = minWidth; this.minHeight = minHeight; - this.spaceWidth = spaceWidth; this.spaceHeight = spaceHeight; this.hPadding = hPadding; this.vPadding = vPadding; this.hops = hops; this.variance = variance; this.speed = speed; - this.flowIrregular = flowIrregular; this.readabilityOffset = readabilityOffset; this.lastSegmentLenProportion = lastSegmentLenProportion; - this.innerWidthProvider = innerWidthProvider; this.outerWidthProvider = outerWidthProvider; - this.startingDotRadiusProvider = startingDotRadiusProvider; this.gridDotsRadiusProvider = gridDotsRadiusProvider; - // *dies* - } - - public String getCacheKey(HexPattern pattern, double seed){ - return (pattern.getStartDir().toString() + "-" + pattern.anglesSignature() + "-" + id + "-" + seed).toLowerCase(); - } - - private PatternRenderSettings copy(){ - PatternRenderSettings newSets = new PatternRenderSettings(fitAxis, baseScale, minWidth, minHeight, spaceWidth, spaceHeight, hPadding, vPadding, - hops, variance, speed, flowIrregular, readabilityOffset, lastSegmentLenProportion, innerWidthProvider, outerWidthProvider, - startingDotRadiusProvider, gridDotsRadiusProvider); - // add a UUID attached to the id (or our best guess, it doesn't really matter this is just to get a unique different id) - newSets.id = id.substring(0, Math.max(id.indexOf('_'), 0)) + "_" + UUID.randomUUID(); - return newSets; - } - - public PatternRenderSettings withSizings(FitAxis fitAxis, Double spaceWidth, Double spaceHeight, Double hPadding, - Double vPadding, Double baseScale, Double minWidth, Double minHeight){ - PatternRenderSettings newSettings = copy(); - newSettings.fitAxis = fitAxis == null ? this.fitAxis : fitAxis; - newSettings.spaceWidth = spaceWidth == null ? this.spaceWidth : spaceWidth; - newSettings.spaceHeight = spaceHeight == null ? this.spaceHeight : spaceHeight; - newSettings.hPadding = hPadding == null ? this.hPadding : hPadding; - newSettings.vPadding = vPadding == null ? this.vPadding : vPadding; - newSettings.baseScale = baseScale == null ? this.baseScale : baseScale; - newSettings.minWidth = minWidth == null ? this.minWidth : minWidth; - newSettings.minHeight = minHeight == null ? this.minHeight : minHeight; - return newSettings; - } - - public PatternRenderSettings withWidths(UnaryOperator innerWidthProvider, UnaryOperator outerWidthProvider, - UnaryOperator startingDotRadiusProvider, UnaryOperator gridDotsRadiusProvider){ - PatternRenderSettings newSettings = copy(); - newSettings.innerWidthProvider = innerWidthProvider == null ? this.innerWidthProvider : innerWidthProvider; - newSettings.outerWidthProvider = outerWidthProvider == null ? this.outerWidthProvider : outerWidthProvider; - newSettings.startingDotRadiusProvider = startingDotRadiusProvider == null ? this.startingDotRadiusProvider : startingDotRadiusProvider; - newSettings.gridDotsRadiusProvider = gridDotsRadiusProvider == null ? this.gridDotsRadiusProvider : gridDotsRadiusProvider; - return newSettings; - } - - public PatternRenderSettings withWidths(UnaryOperator innerWidthProvider, UnaryOperator outerWidthProvider){ - return withWidths(innerWidthProvider, outerWidthProvider, - innerWidthProvider != null ? (scale) -> innerWidthProvider.apply(scale) * 0.8f : null, - innerWidthProvider != null ? (scale) -> innerWidthProvider.apply(scale) * 0.4f : null - ); - } - - public PatternRenderSettings withZappySettings(Integer hops, Float variance, Float speed, Float flowIrregular, - Float readabilityOffset, Float lastSegmentLenProportion){ - PatternRenderSettings newSettings = copy(); - newSettings.hops = hops == null ? this.hops : hops; - newSettings.variance = variance == null ? this.variance : variance; - newSettings.speed = speed == null ? this.speed : speed; - newSettings.flowIrregular = flowIrregular == null ? this.flowIrregular : flowIrregular; - newSettings.readabilityOffset = readabilityOffset == null ? this.readabilityOffset : readabilityOffset; - newSettings.lastSegmentLenProportion = lastSegmentLenProportion == null ? this.lastSegmentLenProportion : lastSegmentLenProportion; - return newSettings; - } - - public PatternRenderSettings named(String id){ - PatternRenderSettings newSettings = copy(); - newSettings.id = id; - return newSettings; - } - - public enum FitAxis{ - HOR(true, false), - VERT(false, true), - BOTH(true, true), - NONE(false, false); - - public final boolean horFit; - public final boolean vertFit; - - FitAxis(boolean horFit, boolean vertFit){ - this.horFit = horFit; - this.vertFit = vertFit; - } - } -} diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index 70351ad18c..9b88e7ef65 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -20,18 +20,18 @@ public class PatternRenderer { - public static void renderPattern(HexPattern pattern, PoseStack ps, PatternRenderSettings patSets, PatternColors patColors, double seed, int resPerUnit) { + public static void renderPattern(HexPattern pattern, PoseStack ps, PatternSettings patSets, PatternColors patColors, double seed, int resPerUnit) { renderPattern(pattern, ps, null, patSets, patColors, seed, resPerUnit); } - public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable WorldlyBits worldlyBits, PatternRenderSettings patSets, PatternColors patColors, double seed, int resPerUnit){ + public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable WorldlyBits worldlyBits, PatternSettings patSets, PatternColors patColors, double seed, int resPerUnit){ var oldShader = RenderSystem.getShader(); HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); boolean shouldRenderDynamic = true; // only do texture rendering if it's static and has solid colors - if(patSets.speed == 0 && PatternTextureManager.useTextures && patColors.innerStartColor == patColors.innerEndColor + if(patSets.getSpeed() == 0 && PatternTextureManager.useTextures && patColors.innerStartColor == patColors.innerEndColor && patColors.outerStartColor == patColors.outerEndColor){ boolean didRender = renderPatternTexture(pattern, ps, worldlyBits, patSets, patColors, seed, resPerUnit); if(didRender) shouldRenderDynamic = false; @@ -39,24 +39,25 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Wor if(shouldRenderDynamic){ List zappyPattern; - if(patSets.speed == 0) { + if(patSets.getSpeed() == 0) { // re-use our static points if we're rendering a static pattern anyway zappyPattern = staticPoints.zappyPoints; } else { List lines1 = pattern.toLines(1, Vec2.ZERO); Set dupIndices = RenderLib.findDupIndices(pattern.positions()); zappyPattern = RenderLib.makeZappy(lines1, dupIndices, - patSets.hops, patSets.variance, patSets.speed, patSets.flowIrregular, patSets.readabilityOffset, patSets.lastSegmentLenProportion, seed); + patSets.getHops(), patSets.getVariance(), patSets.getSpeed(), patSets.getFlowIrregular(), + patSets.getReadabilityOffset(), patSets.getLastSegmentProp(), seed); } List zappyRenderSpace = staticPoints.scaleVecs(zappyPattern); if(FastColor.ARGB32.alpha(patColors.outerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.outerStartColor) != 0){ - RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), + RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, (float)patSets.getOuterWidth(staticPoints.finalScale), patColors.outerEndColor, patColors.outerStartColor, VCDrawHelper.getHelper(worldlyBits, ps,outerZ)); } if(FastColor.ARGB32.alpha(patColors.innerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.innerStartColor) != 0) { - RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, patSets.innerWidthProvider.apply((float) (staticPoints.finalScale)), + RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, (float)patSets.getInnerWidth(staticPoints.finalScale), patColors.innerEndColor, patColors.innerStartColor, VCDrawHelper.getHelper(worldlyBits, ps,innerZ)); } } @@ -66,14 +67,14 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Wor float dotZ = 0.0011f; if(FastColor.ARGB32.alpha(patColors.startingDotColor) != 0) { - RenderLib.drawSpot(ps.last().pose(), staticPoints.dotsScaled.get(0), patSets.startingDotRadiusProvider.apply((float) (staticPoints.finalScale)), + RenderLib.drawSpot(ps.last().pose(), staticPoints.dotsScaled.get(0), (float)patSets.getStartDotRadius(staticPoints.finalScale), patColors.startingDotColor, VCDrawHelper.getHelper(worldlyBits, ps, dotZ)); } if(FastColor.ARGB32.alpha(patColors.gridDotsColor) != 0) { for(int i = 1; i < staticPoints.dotsScaled.size(); i++){ Vec2 gridDot = staticPoints.dotsScaled.get(i); - RenderLib.drawSpot(ps.last().pose(), gridDot, patSets.gridDotsRadiusProvider.apply((float) (staticPoints.finalScale)), + RenderLib.drawSpot(ps.last().pose(), gridDot, (float)patSets.getGridDotsRadius(staticPoints.finalScale), patColors.gridDotsColor, VCDrawHelper.getHelper(worldlyBits, ps, dotZ)); } } @@ -84,7 +85,7 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Wor private static final float outerZ = 0.0005f; private static final float innerZ = 0.001f; - private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @Nullable WorldlyBits worldlyBits, PatternRenderSettings patSets, PatternColors patColors, double seed, int resPerUnit){ + private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @Nullable WorldlyBits worldlyBits, PatternSettings patSets, PatternColors patColors, double seed, int resPerUnit){ Optional> maybeTextures = PatternTextureManager.getTextures(pattern, patSets, seed, resPerUnit); if(maybeTextures.isEmpty()){ return false; diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java new file mode 100644 index 0000000000..792be72ea9 --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java @@ -0,0 +1,109 @@ +package at.petrak.hexcasting.client.render; + +import at.petrak.hexcasting.api.casting.math.HexPattern; + +/** + * A class holding settings for shaping and positioning patterns. + * + * By default, it's a simple wrapper of 3 records, however some use cases may require extending and overriding getters. + * This is done to keep the complexity of the records a bit lower. + */ +public class PatternSettings { + + public PatternSettings(String name, PositionSettings posSets, StrokeSettings strokeSets, ZappySettings zapSets){ + this.name = name; + this.posSets = posSets; + this.strokeSets = strokeSets; + this.zapSets = zapSets; + } + + public record PositionSettings(double spaceWidth, double spaceHeight, double hPadding, double vPadding, + AxisAlignment hAxis, AxisAlignment vAxis, double baseScale, double minWidth, double minHeight){ + /** + * Makes settings ideal for rendering in a square. This helper exists because this is the most common positioning + * pattern. + * @param padding a value 0-0.5 for how much padding should go on each side. + * @return a PositionSettings object in a 1x1 space with the given padding value such that the pattern is centered + */ + public static PositionSettings paddedSquare(double padding){ + return paddedSquare(padding, 0.25, 0); + } + + public static PositionSettings paddedSquare(double padding, double baseScale, double minSize){ + return new PositionSettings(1.0, 1.0, padding, padding, AxisAlignment.CENTER, AxisAlignment.CENTER, baseScale, minSize, minSize); + } + } + + public record StrokeSettings(double innerWidth, double outerWidth, + double startDotRadius, double gridDotsRadius){ + public static StrokeSettings fromStroke(double stroke){ + return new StrokeSettings(stroke * 2.0/5.0, stroke, 0.8 * stroke * 2.0 / 5.0, 0.4 * stroke * 2.0 / 5.0); + } + } + + public record ZappySettings(int hops, float variance, float speed, float flowIrregular, float readabilityOffset, float lastSegmentLenProportion){ + public static float READABLE_OFFSET = 0.2f; + public static float READABLE_SEGMENT = 0.8f; + public static ZappySettings STATIC = new ZappySettings(10, 0.5f, 0f, 0.2f, 0, 1f); + public static ZappySettings READABLE = new ZappySettings(10, 0.5f, 0f, 0.2f, READABLE_OFFSET, READABLE_SEGMENT); + public static ZappySettings WOBBLY = new ZappySettings(10, 2.5f, 0.1f, 0.2f, 0, 1f); + } + + public String getCacheKey(HexPattern pattern, double seed){ + return (pattern.getStartDir() + "-" + pattern.anglesSignature() + "-" + getName() + "-" + seed).toLowerCase(); + } + + // determines how the pattern is fit and aligned on a given axis + public enum AxisAlignment{ + // aligns the pattern if there's extra space. these 3 are the same when the pattern needs to be scaled down to fit + BEGIN, + CENTER, + END, + // NONE ignores target space requirements when fitting on this axis. + NONE + } + + private final String name; + private final PositionSettings posSets; + private final StrokeSettings strokeSets; + private final ZappySettings zapSets; + + public String getName(){ return name; } + + public double getTargetWidth(){ return posSets.spaceWidth; } + public double getTargetHeight(){ return posSets.spaceHeight; } + + public double getHorPadding(){ return posSets.hPadding; } + public double getVertPadding(){ return posSets.vPadding; } + + public AxisAlignment getHorAlignment(){ return posSets.hAxis; } + public AxisAlignment getVertAlignment(){ return posSets.vAxis; } + + public double getBaseScale(){ return posSets.baseScale; } + public double getMinWidth(){ return posSets.minWidth; } + public double getMinHeight(){ return posSets.minHeight; } + + /* these sizing getters take in the final pattern scale so that patterns can vary their stroke width when squished. + * the records keep a static value since that's fine for *most* use cases, override these methods if you need to use them. + * note that these widths are still in pose space units. + */ + + public double getInnerWidth(double scale){ return strokeSets.innerWidth; } + public double getOuterWidth(double scale){ return strokeSets.outerWidth; } + + public double getStartDotRadius(double scale){ return strokeSets.startDotRadius; } + public double getGridDotsRadius(double scale){ return strokeSets.gridDotsRadius; } + + public double getStrokeWidth(double scale){ return Math.max(getOuterWidth(scale), getInnerWidth(scale)); } + + // we have a stroke guess getter so that we can *try* to account for the stroke size when fitting the pattern. + public double getStrokeWidthGuess(){ return Math.max(strokeSets.outerWidth, strokeSets.innerWidth); } + + public int getHops(){ return zapSets.hops; } + public float getVariance(){ return zapSets.variance; } + public float getFlowIrregular(){ return zapSets.flowIrregular; } + public float getReadabilityOffset(){ return zapSets.readabilityOffset; } + public float getLastSegmentProp(){ return zapSets.lastSegmentLenProportion; } + + public float getSpeed(){ return zapSets.speed; } +} diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java index 66f9a2737a..c28d90a507 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java @@ -47,7 +47,7 @@ public static void setResolutionScaler(int resolutionScaler) { private static final HashMap> patternTextures = new HashMap<>(); - public static Optional> getTextures(HexPattern pattern, PatternRenderSettings patSets, double seed, int resPerUnit) { + public static Optional> getTextures(HexPattern pattern, PatternSettings patSets, double seed, int resPerUnit) { String patCacheKey = patSets.getCacheKey(pattern, seed) + "_" + resPerUnit; // move textures from concurrent map to normal hashmap as needed @@ -79,17 +79,17 @@ public static Optional> getTextures(HexPattern pat return Optional.empty(); } - private static Map createTextures(HexPattern pattern, PatternRenderSettings patSets, double seed, int resPerUnit) { + private static Map createTextures(HexPattern pattern, PatternSettings patSets, double seed, int resPerUnit) { HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); List zappyRenderSpace = staticPoints.scaleVecs(staticPoints.zappyPoints); Map patTexts = new HashMap<>(); - NativeImage innerLines = drawLines(zappyRenderSpace, staticPoints, patSets.innerWidthProvider.apply((float)(staticPoints.finalScale)), resPerUnit); + NativeImage innerLines = drawLines(zappyRenderSpace, staticPoints, (float)patSets.getInnerWidth((staticPoints.finalScale)), resPerUnit); patTexts.put("inner", new DynamicTexture(innerLines)); - NativeImage outerLines = drawLines(zappyRenderSpace, staticPoints, patSets.outerWidthProvider.apply((float)(staticPoints.finalScale)), resPerUnit); + NativeImage outerLines = drawLines(zappyRenderSpace, staticPoints, (float)patSets.getOuterWidth((staticPoints.finalScale)), resPerUnit); patTexts.put("outer", new DynamicTexture(outerLines)); // TODO: handle start hexagon and grid bits. diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index f022409286..9e7bc601c4 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -21,23 +21,29 @@ */ public class WorldlyPatternRenderHelpers { - public static final PatternRenderSettings WORLDLY_RENDER_SETTINGS = new PatternRenderSettings() - .withSizings(PatternRenderSettings.FitAxis.BOTH, 1.0, 1.0, 1.0/16, 1.0/16, 0.25, null, null) - .withWidths((scale) -> 0.4f/16, (scale) -> 0.8f/16) - .named("worldly"); - - public static final PatternRenderSettings SCROLL_RENDER_SETTINGS = WORLDLY_RENDER_SETTINGS.withSizings(null, null, null, - 2.0/16, 2.0/16, null, null, null) - .named("wallscroll"); - - public static final PatternRenderSettings READABLE_SCROLL_RENDER_SETTINGS = SCROLL_RENDER_SETTINGS.withZappySettings( - null, null, null, null, RenderLib.DEFAULT_READABILITY_OFFSET, RenderLib.DEFAULT_LAST_SEGMENT_LEN_PROP - ) - .named("wallscroll_readable"); - - public static final PatternRenderSettings SLATE_WOMBLY_SETTINGS = WORLDLY_RENDER_SETTINGS.withZappySettings( - null, 2.5f, 0.1f, null, null, null) - .named("slate_wobbly"); + public static final PatternSettings SCROLL_SETTINGS = new PatternSettings("scroll", + PatternSettings.PositionSettings.paddedSquare(2.0/16), + PatternSettings.StrokeSettings.fromStroke(0.8/16), + PatternSettings.ZappySettings.STATIC + ); + + public static final PatternSettings READABLE_SCROLL_SETTINGS = new PatternSettings("scroll_readable", + PatternSettings.PositionSettings.paddedSquare(2.0/16), + PatternSettings.StrokeSettings.fromStroke(0.8/16), + PatternSettings.ZappySettings.STATIC + ); + + public static final PatternSettings WORLDLY_SETTINGS = new PatternSettings("worldly", + PatternSettings.PositionSettings.paddedSquare(2.0/16), + PatternSettings.StrokeSettings.fromStroke(0.8/16), + PatternSettings.ZappySettings.STATIC + ); + + public static final PatternSettings WORLDLY_SETTINGS_WOBBLY = new PatternSettings("wobbly_world", + PatternSettings.PositionSettings.paddedSquare(2.0/16), + PatternSettings.StrokeSettings.fromStroke(0.8/16), + PatternSettings.ZappySettings.WOBBLY + ); // using an opaque inner color based on 0xc8_322b33 because worldly pattern renderer is funky public static final PatternColors DEFAULT_PATTERN_COLOR = new PatternColors(0xff_554d54, 0xff_d2c8c8); @@ -56,7 +62,7 @@ public static void renderPatternForScroll(HexPattern pattern, EntityWallScroll s // TODO: I think scroll normals are maybe slightly messed up or something?? idk, look into that maybe ps.pushPose(); ps.translate(-blockSize / 2f, -blockSize / 2f, 1f / 32f); - renderPattern(pattern, showStrokeOrder ? READABLE_SCROLL_RENDER_SETTINGS : SCROLL_RENDER_SETTINGS, + renderPattern(pattern, showStrokeOrder ? READABLE_SCROLL_SETTINGS : SCROLL_SETTINGS, showStrokeOrder ? READABLE_SCROLL_COLORS : DEFAULT_PATTERN_COLOR, scroll.getPos().hashCode(), ps, bufSource, null, null, light, blockSize); ps.popPose(); @@ -95,7 +101,7 @@ public static void renderPatternForSlate(BlockEntitySlate tile, HexPattern patte } renderPattern(pattern, - wombly ? SLATE_WOMBLY_SETTINGS : WORLDLY_RENDER_SETTINGS, + wombly ? WORLDLY_SETTINGS_WOBBLY : WORLDLY_SETTINGS, wombly ? SLATE_WOBBLY_PURPLE_COLOR : DEFAULT_PATTERN_COLOR, tile.getBlockPos().hashCode(), ps, buffer, normal, null, light, 1); ps.popPose(); @@ -115,7 +121,7 @@ public static void renderPatternForAkashicBookshelf(BlockEntityAkashicBookshelf ps.translate(tV.getX(), tV.getY(), tV.getZ()); ps.mulPose(Axis.YP.rotationDegrees(WALL_ROTATIONS[facing % 4])); - renderPattern(pattern, WORLDLY_RENDER_SETTINGS, DEFAULT_PATTERN_COLOR, + renderPattern(pattern, WORLDLY_SETTINGS , DEFAULT_PATTERN_COLOR, tile.getBlockPos().hashCode(), ps, buffer, WALL_NORMALS[facing % 4].multiply(-1, -1, -1), -0.02f, light, 1); ps.popPose(); } @@ -123,7 +129,7 @@ public static void renderPatternForAkashicBookshelf(BlockEntityAkashicBookshelf /** * Renders a pattern in world space based on the given transform requirements */ - public static void renderPattern(HexPattern pattern, PatternRenderSettings patSets, PatternColors patColors, + public static void renderPattern(HexPattern pattern, PatternSettings patSets, PatternColors patColors, double seed, PoseStack ps, MultiBufferSource bufSource, Vec3 normal, @Nullable Float zOffset, int light, int blockSize) { diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index 5228cfac0a..449bd073b6 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -2,8 +2,8 @@ import at.petrak.hexcasting.client.render.HexPatternPoints; import at.petrak.hexcasting.client.render.PatternColors; -import at.petrak.hexcasting.client.render.PatternRenderSettings; import at.petrak.hexcasting.client.render.PatternRenderer; +import at.petrak.hexcasting.client.render.PatternSettings; import com.samsthenerd.inline.api.client.InlineRenderer; import net.minecraft.client.gui.GuiGraphics; import net.minecraft.network.chat.Style; @@ -18,11 +18,12 @@ public ResourceLocation getId(){ return InlinePatternData.rendererId; } - public static final PatternRenderSettings INLINE_RENDER_SETTINGS = new PatternRenderSettings() - .withSizings(PatternRenderSettings.FitAxis.VERT, 8.0, 9.0, 1.0, 0.5, 4.0, null, null) - .withWidths((scale) -> 1f, null) - .withZappySettings(null, 0f, 0f, 0f, 0f, null) - .named("inline"); + public static final PatternSettings INLINE_SETTINGS = new PatternSettings("inline", + new PatternSettings.PositionSettings(8.0, 9.0, 1.0, 0.5, + PatternSettings.AxisAlignment.NONE, PatternSettings.AxisAlignment.CENTER, 4.0, 0, 0), + PatternSettings.StrokeSettings.fromStroke(1.0), + PatternSettings.ZappySettings.STATIC + ); public static final int INLINE_TEXTURE_RES = 16; // 128px so it looks good and pretty on up close signs and whatnot @@ -37,7 +38,7 @@ public int render(InlinePatternData data, GuiGraphics drawContext, int index, St color |= 0xFF_000000; } PatternRenderer.renderPattern(data.pattern, drawContext.pose(), new PatternRenderer.WorldlyBits(trContext.vertexConsumers, trContext.light, null), - INLINE_RENDER_SETTINGS, new PatternColors(color), 0, INLINE_TEXTURE_RES); + INLINE_SETTINGS, new PatternColors(color), 0, INLINE_TEXTURE_RES); drawContext.pose().popPose(); return charWidth(data, style, codepoint); @@ -45,7 +46,7 @@ public int render(InlinePatternData data, GuiGraphics drawContext, int index, St public int charWidth(InlinePatternData data, Style style, int codepoint){ - HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(data.pattern, INLINE_RENDER_SETTINGS, 0); + HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(data.pattern, INLINE_SETTINGS, 0); double baseScale = 4.0 / 1.5; double baseHeight = staticPoints.rangeY * baseScale; From 3eb283c695f30ff46e2621ef89d64f4ff9b92cfd Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Mon, 22 Jul 2024 17:38:30 -0400 Subject: [PATCH 31/48] clean up pattern color stuff a little --- .../client/gui/PatternTooltipComponent.java | 3 +- .../client/render/PatternColors.java | 50 +++++++++++-------- .../render/WorldlyPatternRenderHelpers.java | 18 ++----- .../interop/inline/InlinePatternRenderer.java | 2 +- 4 files changed, 34 insertions(+), 39 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java b/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java index 5aca32f52c..d1b54083a2 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java @@ -1,6 +1,7 @@ package at.petrak.hexcasting.client.gui; import at.petrak.hexcasting.api.casting.math.HexPattern; +import at.petrak.hexcasting.client.render.PatternColors; import at.petrak.hexcasting.client.render.PatternRenderer; import at.petrak.hexcasting.client.render.WorldlyPatternRenderHelpers; import at.petrak.hexcasting.common.misc.PatternTooltip; @@ -74,7 +75,7 @@ public void renderImage(Font font, int mouseX, int mouseY, GuiGraphics graphics) ps.scale(RENDER_SIZE, RENDER_SIZE, 1); PatternRenderer.renderPattern(pattern, ps, WorldlyPatternRenderHelpers.READABLE_SCROLL_SETTINGS, - WorldlyPatternRenderHelpers.READABLE_GRID_SCROLL_COLORS, 0, 512); + PatternColors.READABLE_GRID_SCROLL_COLORS, 0, 512); ps.popPose(); ps.popPose(); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java index 3710c71be3..bda15cd96e 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java @@ -2,37 +2,43 @@ /** * An immutable wrapper for pattern colors. - * + *

* This is separate from PatternRenderSettings because it does not affect the shape of the pattern, so we can re-use * those parts for different colors. */ -public class PatternColors { - protected final int innerStartColor; - protected final int innerEndColor; - protected final int outerStartColor; - protected final int outerEndColor; - - protected final int startingDotColor; - protected final int gridDotsColor; - - public PatternColors(int innerStartColor, int innerEndColor, int outerStartColor, int outerEndColor, - int startingDotsColor, int gridDotsColor){ - this.innerStartColor = innerStartColor; - this.innerEndColor = innerEndColor; - this.outerStartColor = outerStartColor; - this.outerEndColor = outerEndColor; - this.startingDotColor = startingDotsColor; - this.gridDotsColor = gridDotsColor; - } +public record PatternColors(int innerStartColor, int innerEndColor, int outerStartColor, int outerEndColor, + int startingDotColor, int gridDotsColor){ + + public static final PatternColors DEFAULT_PATTERN_COLOR = new PatternColors(0xff_554d54, 0xff_d2c8c8); + + public static final PatternColors READABLE_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDotColors(0xff_5b7bd7, 0); + public static final PatternColors READABLE_GRID_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDotColors(0xff_5b7bd7, 0x80_d2c8c8); + + public static final PatternColors SLATE_WOBBLY_COLOR = glowyStroke( 0xff_64c8ff); // old blue color + public static final PatternColors SLATE_WOBBLY_PURPLE_COLOR = glowyStroke(0xff_cfa0f3); // shiny new purple one :) // no gradient public PatternColors(int innerColor, int outerColor){ this(innerColor, innerColor, outerColor, outerColor, 0, 0); } - // single color -- no outer layer - public PatternColors(int color){ - this(0, color); + // single color -- no inner layer + public static PatternColors singleStroke(int color){ + return new PatternColors(0, color); + } + + // makes a stroke color similar to the glowy effect that slates have. + public static PatternColors glowyStroke(int color){ + return new PatternColors(RenderLib.screenCol(color), color); + } + + public static PatternColors gradientStrokes(int innerStartColor, int innerEndColor, int outerStartColor, int outerEndColor){ + return new PatternColors(innerStartColor, innerEndColor, outerStartColor, outerEndColor, 0, 0); + } + + // a single stroke with a gradient -- no inner layer. + public static PatternColors gradientStroke(int startColor, int endColor){ + return PatternColors.gradientStrokes(0, 0, startColor, endColor); } // add dots -- note, this is how you tell the renderer to make dots diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index 9e7bc601c4..8a52b775e6 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -45,25 +45,13 @@ public class WorldlyPatternRenderHelpers { PatternSettings.ZappySettings.WOBBLY ); - // using an opaque inner color based on 0xc8_322b33 because worldly pattern renderer is funky - public static final PatternColors DEFAULT_PATTERN_COLOR = new PatternColors(0xff_554d54, 0xff_d2c8c8); - - // partially for testing - public static final PatternColors READABLE_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDotColors(0xff_5b7bd7, 0); - - public static final PatternColors READABLE_GRID_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDotColors(0xff_5b7bd7, 0x80_d2c8c8); - - public static final PatternColors SLATE_WOBBLY_COLOR = new PatternColors(RenderLib.screenCol(0xff_64c8ff), 0xff_64c8ff); - - public static final PatternColors SLATE_WOBBLY_PURPLE_COLOR = new PatternColors(RenderLib.screenCol(0xff_cfa0f3), 0xff_cfa0f3); - public static void renderPatternForScroll(HexPattern pattern, EntityWallScroll scroll, PoseStack ps, MultiBufferSource bufSource, int light, int blockSize, boolean showStrokeOrder) { // TODO: I think scroll normals are maybe slightly messed up or something?? idk, look into that maybe ps.pushPose(); ps.translate(-blockSize / 2f, -blockSize / 2f, 1f / 32f); renderPattern(pattern, showStrokeOrder ? READABLE_SCROLL_SETTINGS : SCROLL_SETTINGS, - showStrokeOrder ? READABLE_SCROLL_COLORS : DEFAULT_PATTERN_COLOR, + showStrokeOrder ? PatternColors.READABLE_SCROLL_COLORS : PatternColors.DEFAULT_PATTERN_COLOR, scroll.getPos().hashCode(), ps, bufSource, null, null, light, blockSize); ps.popPose(); } @@ -102,7 +90,7 @@ public static void renderPatternForSlate(BlockEntitySlate tile, HexPattern patte renderPattern(pattern, wombly ? WORLDLY_SETTINGS_WOBBLY : WORLDLY_SETTINGS, - wombly ? SLATE_WOBBLY_PURPLE_COLOR : DEFAULT_PATTERN_COLOR, + wombly ? PatternColors.SLATE_WOBBLY_PURPLE_COLOR : PatternColors.DEFAULT_PATTERN_COLOR, tile.getBlockPos().hashCode(), ps, buffer, normal, null, light, 1); ps.popPose(); } @@ -121,7 +109,7 @@ public static void renderPatternForAkashicBookshelf(BlockEntityAkashicBookshelf ps.translate(tV.getX(), tV.getY(), tV.getZ()); ps.mulPose(Axis.YP.rotationDegrees(WALL_ROTATIONS[facing % 4])); - renderPattern(pattern, WORLDLY_SETTINGS , DEFAULT_PATTERN_COLOR, + renderPattern(pattern, WORLDLY_SETTINGS , PatternColors.DEFAULT_PATTERN_COLOR, tile.getBlockPos().hashCode(), ps, buffer, WALL_NORMALS[facing % 4].multiply(-1, -1, -1), -0.02f, light, 1); ps.popPose(); } diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index 449bd073b6..58ac036ba7 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -38,7 +38,7 @@ public int render(InlinePatternData data, GuiGraphics drawContext, int index, St color |= 0xFF_000000; } PatternRenderer.renderPattern(data.pattern, drawContext.pose(), new PatternRenderer.WorldlyBits(trContext.vertexConsumers, trContext.light, null), - INLINE_SETTINGS, new PatternColors(color), 0, INLINE_TEXTURE_RES); + INLINE_SETTINGS, PatternColors.singleStroke(color), 0, INLINE_TEXTURE_RES); drawContext.pose().popPose(); return charWidth(data, style, codepoint); From 705f60f7edc0df7a398adae4d15b23e354a07b9b Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Tue, 23 Jul 2024 16:47:34 -0400 Subject: [PATCH 32/48] switch patchi renders over to new system --- .../client/gui/PatternTooltipComponent.java | 16 ----- .../client/render/HexPatternPoints.java | 4 +- .../client/render/PatternColors.java | 13 +++- .../client/render/PatternRenderer.java | 28 ++++----- .../render/WorldlyPatternRenderHelpers.java | 2 +- .../interop/inline/InlinePatternRenderer.java | 4 +- .../patchouli/AbstractPatternComponent.java | 61 +++++++++++++------ .../patchouli/LookupPatternComponent.java | 6 +- .../patchouli/ManualPatternComponent.java | 9 +-- .../interop/utils/PatternDrawingUtil.java | 2 +- 10 files changed, 77 insertions(+), 68 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java b/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java index d1b54083a2..6e1e2f4641 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java @@ -30,23 +30,11 @@ public class PatternTooltipComponent implements ClientTooltipComponent { private static final int TEXTURE_SIZE = 48; private final HexPattern pattern; -// private final List zappyPoints; -// private final List pathfinderDots; -// private final float scale; private final ResourceLocation background; public PatternTooltipComponent(PatternTooltip tt) { this.pattern = tt.pattern(); this.background = tt.background(); - -// var pair = RenderLib.getCenteredPattern(pattern, RENDER_SIZE, RENDER_SIZE, 16f); -// this.scale = pair.getFirst(); -// var dots = pair.getSecond(); -// this.zappyPoints = RenderLib.makeZappy( -// dots, RenderLib.findDupIndices(pattern.positions()), -// 10, 0.8f, 0f, 0f, RenderLib.DEFAULT_READABILITY_OFFSET, RenderLib.DEFAULT_LAST_SEGMENT_LEN_PROP, -// 0.0); -// this.pathfinderDots = dots.stream().distinct().collect(Collectors.toList()); } @Nullable @@ -68,17 +56,13 @@ public void renderImage(Font font, int mouseX, int mouseY, GuiGraphics graphics) renderBG(graphics, this.background); // renderText happens *before* renderImage for some asinine reason -// RenderSystem.disableBlend(); ps.translate(0, 0, 100); - - ps.pushPose(); ps.scale(RENDER_SIZE, RENDER_SIZE, 1); PatternRenderer.renderPattern(pattern, ps, WorldlyPatternRenderHelpers.READABLE_SCROLL_SETTINGS, PatternColors.READABLE_GRID_SCROLL_COLORS, 0, 512); ps.popPose(); - ps.popPose(); } private static void renderBG(GuiGraphics graphics, ResourceLocation background) { diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java index 6e9bd63d29..118f5f0cfe 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java @@ -106,8 +106,8 @@ private HexPatternPoints(HexPattern pattern, PatternSettings patSets, double see this.fullWidth = fullWidthTmp; this.fullHeight = fullHeightTmp; - offsetX = (fullWidthTmp - baseWidth * scale - finalStroke) / 2; - offsetY = (fullHeightTmp - baseHeight * scale - finalStroke) / 2; + offsetX = (fullWidthTmp - baseWidth * scale) / 2; + offsetY = (fullHeightTmp - baseHeight * scale) / 2; this.zappyPointsScaled = ImmutableList.copyOf(scaleVecs(zappyPoints)); this.dotsScaled = ImmutableList.copyOf(scaleVecs(dots)); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java index bda15cd96e..a81ae9191d 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java @@ -9,10 +9,14 @@ public record PatternColors(int innerStartColor, int innerEndColor, int outerStartColor, int outerEndColor, int startingDotColor, int gridDotsColor){ + // keep some handy frequently used colors here. public static final PatternColors DEFAULT_PATTERN_COLOR = new PatternColors(0xff_554d54, 0xff_d2c8c8); - public static final PatternColors READABLE_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDotColors(0xff_5b7bd7, 0); - public static final PatternColors READABLE_GRID_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDotColors(0xff_5b7bd7, 0x80_d2c8c8); + public static final int STARTING_DOT = 0xff_5b7bd7; + public static final int GRID_DOTS = 0x80_d2c8c8; + + public static final PatternColors READABLE_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDotColors(STARTING_DOT, 0); + public static final PatternColors READABLE_GRID_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDotColors(STARTING_DOT, GRID_DOTS); public static final PatternColors SLATE_WOBBLY_COLOR = glowyStroke( 0xff_64c8ff); // old blue color public static final PatternColors SLATE_WOBBLY_PURPLE_COLOR = glowyStroke(0xff_cfa0f3); // shiny new purple one :) @@ -46,4 +50,9 @@ public PatternColors withDotColors(int startingDotColor, int gridDotsColor){ return new PatternColors(this.innerStartColor, this.innerEndColor, this.outerStartColor, this.outerEndColor, startingDotColor, gridDotsColor); } + + // adds dots with the default colors. + public PatternColors withDots(boolean startingDot, boolean gridDots){ + return withDotColors(startingDot ? STARTING_DOT : 0, gridDots ? GRID_DOTS : 0); + } } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index 9b88e7ef65..1f0696352c 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -31,8 +31,8 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Wor boolean shouldRenderDynamic = true; // only do texture rendering if it's static and has solid colors - if(patSets.getSpeed() == 0 && PatternTextureManager.useTextures && patColors.innerStartColor == patColors.innerEndColor - && patColors.outerStartColor == patColors.outerEndColor){ + if(patSets.getSpeed() == 0 && PatternTextureManager.useTextures && patColors.innerStartColor() == patColors.innerEndColor() + && patColors.outerStartColor() == patColors.outerEndColor()){ boolean didRender = renderPatternTexture(pattern, ps, worldlyBits, patSets, patColors, seed, resPerUnit); if(didRender) shouldRenderDynamic = false; } @@ -52,13 +52,13 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Wor List zappyRenderSpace = staticPoints.scaleVecs(zappyPattern); - if(FastColor.ARGB32.alpha(patColors.outerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.outerStartColor) != 0){ + if(FastColor.ARGB32.alpha(patColors.outerEndColor()) != 0 && FastColor.ARGB32.alpha(patColors.outerStartColor()) != 0){ RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, (float)patSets.getOuterWidth(staticPoints.finalScale), - patColors.outerEndColor, patColors.outerStartColor, VCDrawHelper.getHelper(worldlyBits, ps,outerZ)); + patColors.outerEndColor(), patColors.outerStartColor(), VCDrawHelper.getHelper(worldlyBits, ps,outerZ)); } - if(FastColor.ARGB32.alpha(patColors.innerEndColor) != 0 && FastColor.ARGB32.alpha(patColors.innerStartColor) != 0) { + if(FastColor.ARGB32.alpha(patColors.innerEndColor()) != 0 && FastColor.ARGB32.alpha(patColors.innerStartColor()) != 0) { RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, (float)patSets.getInnerWidth(staticPoints.finalScale), - patColors.innerEndColor, patColors.innerStartColor, VCDrawHelper.getHelper(worldlyBits, ps,innerZ)); + patColors.innerEndColor(), patColors.innerStartColor(), VCDrawHelper.getHelper(worldlyBits, ps,innerZ)); } } @@ -66,16 +66,16 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Wor float dotZ = 0.0011f; - if(FastColor.ARGB32.alpha(patColors.startingDotColor) != 0) { + if(FastColor.ARGB32.alpha(patColors.startingDotColor()) != 0) { RenderLib.drawSpot(ps.last().pose(), staticPoints.dotsScaled.get(0), (float)patSets.getStartDotRadius(staticPoints.finalScale), - patColors.startingDotColor, VCDrawHelper.getHelper(worldlyBits, ps, dotZ)); + patColors.startingDotColor(), VCDrawHelper.getHelper(worldlyBits, ps, dotZ)); } - if(FastColor.ARGB32.alpha(patColors.gridDotsColor) != 0) { + if(FastColor.ARGB32.alpha(patColors.gridDotsColor()) != 0) { for(int i = 1; i < staticPoints.dotsScaled.size(); i++){ Vec2 gridDot = staticPoints.dotsScaled.get(i); RenderLib.drawSpot(ps.last().pose(), gridDot, (float)patSets.getGridDotsRadius(staticPoints.finalScale), - patColors.gridDotsColor, VCDrawHelper.getHelper(worldlyBits, ps, dotZ)); + patColors.gridDotsColor(), VCDrawHelper.getHelper(worldlyBits, ps, dotZ)); } } @@ -96,11 +96,11 @@ private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @N VertexConsumer vc; - if(FastColor.ARGB32.alpha(patColors.outerStartColor) != 0) { + if(FastColor.ARGB32.alpha(patColors.outerStartColor()) != 0) { VCDrawHelper vcHelper = VCDrawHelper.getHelper(worldlyBits, ps, outerZ, textures.get("outer")); vc = vcHelper.vcSetupAndSupply(VertexFormat.Mode.QUADS); - int cl = patColors.outerStartColor; + int cl = patColors.outerStartColor(); vcHelper.vertex(vc, cl, new Vec2(0, 0), new Vec2(0, 0), ps.last().pose()); vcHelper.vertex(vc, cl, new Vec2(0, (float) staticPoints.fullHeight), new Vec2(0, 1), ps.last().pose()); @@ -110,11 +110,11 @@ private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @N vcHelper.vcEndDrawer(vc); } - if(FastColor.ARGB32.alpha(patColors.innerStartColor) != 0) { + if(FastColor.ARGB32.alpha(patColors.innerStartColor()) != 0) { VCDrawHelper vcHelper = VCDrawHelper.getHelper(worldlyBits, ps, innerZ, textures.get("inner")); vc = vcHelper.vcSetupAndSupply(VertexFormat.Mode.QUADS); - int cl = patColors.innerStartColor; + int cl = patColors.innerStartColor(); vcHelper.vertex(vc, cl, new Vec2(0, 0), new Vec2(0, 0), ps.last().pose()); vcHelper.vertex(vc, cl, new Vec2(0, (float) staticPoints.fullHeight), new Vec2(0, 1), ps.last().pose()); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index 8a52b775e6..13aa852bd0 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -30,7 +30,7 @@ public class WorldlyPatternRenderHelpers { public static final PatternSettings READABLE_SCROLL_SETTINGS = new PatternSettings("scroll_readable", PatternSettings.PositionSettings.paddedSquare(2.0/16), PatternSettings.StrokeSettings.fromStroke(0.8/16), - PatternSettings.ZappySettings.STATIC + PatternSettings.ZappySettings.READABLE ); public static final PatternSettings WORLDLY_SETTINGS = new PatternSettings("worldly", diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index 58ac036ba7..1c7dd5f890 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -19,7 +19,7 @@ public ResourceLocation getId(){ } public static final PatternSettings INLINE_SETTINGS = new PatternSettings("inline", - new PatternSettings.PositionSettings(8.0, 9.0, 1.0, 0.5, + new PatternSettings.PositionSettings(8.0, 9.0, 0, 0.5, PatternSettings.AxisAlignment.NONE, PatternSettings.AxisAlignment.CENTER, 4.0, 0, 0), PatternSettings.StrokeSettings.fromStroke(1.0), PatternSettings.ZappySettings.STATIC @@ -51,6 +51,6 @@ public int charWidth(InlinePatternData data, Style style, int codepoint){ double baseScale = 4.0 / 1.5; double baseHeight = staticPoints.rangeY * baseScale; - return (int)Math.round(0.2 + Math.min(baseHeight, 8.0) * staticPoints.rangeX / staticPoints.rangeY) + 2; // (+2 for padding) + return (int)Math.ceil(Math.min(baseHeight, 8.0) * staticPoints.rangeX / staticPoints.rangeY) + 1; // (+2 for padding) } } diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java b/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java index 4165756417..17d51df24d 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java @@ -1,14 +1,11 @@ package at.petrak.hexcasting.interop.patchouli; -import at.petrak.hexcasting.api.casting.math.HexCoord; import at.petrak.hexcasting.api.casting.math.HexPattern; -import at.petrak.hexcasting.client.render.RenderLib; -import at.petrak.hexcasting.interop.utils.PatternDrawingUtil; -import at.petrak.hexcasting.interop.utils.PatternEntry; +import at.petrak.hexcasting.client.render.PatternColors; +import at.petrak.hexcasting.client.render.PatternRenderer; +import at.petrak.hexcasting.client.render.PatternSettings; import com.mojang.blaze3d.vertex.PoseStack; -import com.mojang.datafixers.util.Pair; import net.minecraft.client.gui.GuiGraphics; -import net.minecraft.world.phys.Vec2; import vazkii.patchouli.api.IComponentRenderContext; import vazkii.patchouli.api.ICustomComponent; import vazkii.patchouli.api.IVariable; @@ -23,8 +20,7 @@ abstract public class AbstractPatternComponent implements ICustomComponent { protected transient int x, y; protected transient float hexSize; - private transient List patterns; - private transient List zappyPoints; + private transient List patterns; /** * Pass -1, -1 to center it. @@ -35,29 +31,54 @@ public void build(int x, int y, int pagenum) { this.y = y == -1 ? 70 : y; } - public abstract List> getPatterns(UnaryOperator lookup); + public abstract List getPatterns(UnaryOperator lookup); public abstract boolean showStrokeOrder(); + public static final PatternColors GREAT_COLOR = new PatternColors(0xFF_B4AAAA, 0xff_d2c8c8).withDots(false, true); + @Override public void render(GuiGraphics graphics, IComponentRenderContext context, float pticks, int mouseX, int mouseY) { - PatternDrawingUtil.drawPattern(graphics, this.x, this.y, this.patterns, this.zappyPoints, - this.showStrokeOrder(), - 0xff_d2c8c8, 0xc8_aba2a2, 0xc8_322b33, 0x80_d1cccc); + PoseStack ps = graphics.pose(); + // want to position x: [0, 116], y: [16, 80] + ps.pushPose(); + + int cols = (int)Math.ceil(Math.sqrt(patterns.size())); + int rows = (int)Math.ceil(patterns.size()/(double)cols); + + double cellW = 116 / (double)cols; + double cellH = 64 / (double)rows; + + PatternSettings patSets = new PatternSettings("book" + patterns.size() + (showStrokeOrder() ? "" : "r"), + new PatternSettings.PositionSettings(cellW, cellH, 2, 2, + PatternSettings.AxisAlignment.CENTER, PatternSettings.AxisAlignment.CENTER, 16, 0, 0), + PatternSettings.StrokeSettings.fromStroke(4), + showStrokeOrder() ? PatternSettings.ZappySettings.READABLE : PatternSettings.ZappySettings.STATIC + ); + + for(int p = 0; p < patterns.size(); p++){ + + int r = p / cols; + int c = p % cols; + HexPattern pattern = patterns.get(p); + + ps.pushPose(); + ps.translate(cellW * c, cellH * r + 16, 100); + + PatternRenderer.renderPattern(pattern, graphics.pose(), patSets, + showStrokeOrder() ? PatternColors.READABLE_GRID_SCROLL_COLORS : GREAT_COLOR + , 0, 4); + ps.popPose(); + } + ps.popPose(); } @Override public void onVariablesAvailable(UnaryOperator lookup) { - var patterns = this.getPatterns(lookup); - var data = PatternDrawingUtil.loadPatterns( - patterns, - this.showStrokeOrder() ? RenderLib.DEFAULT_READABILITY_OFFSET : 0f, - this.showStrokeOrder() ? RenderLib.DEFAULT_LAST_SEGMENT_LEN_PROP : 1f); - this.hexSize = data.hexSize(); - this.patterns = data.patterns(); - this.zappyPoints = data.pathfinderDots(); + this.patterns = this.getPatterns(lookup); } + // used for deserialization from patchi protected static class RawPattern { protected String startdir; protected String signature; diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/LookupPatternComponent.java b/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/LookupPatternComponent.java index 7f5517b361..632c7abf79 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/LookupPatternComponent.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/LookupPatternComponent.java @@ -1,11 +1,9 @@ package at.petrak.hexcasting.interop.patchouli; -import at.petrak.hexcasting.api.casting.math.HexCoord; import at.petrak.hexcasting.api.casting.math.HexPattern; import at.petrak.hexcasting.api.mod.HexTags; import at.petrak.hexcasting.xplat.IXplatAbstractions; import com.google.gson.annotations.SerializedName; -import com.mojang.datafixers.util.Pair; import net.minecraft.resources.ResourceKey; import net.minecraft.resources.ResourceLocation; import vazkii.patchouli.api.IVariable; @@ -24,13 +22,13 @@ public class LookupPatternComponent extends AbstractPatternComponent { protected boolean strokeOrder; @Override - public List> getPatterns(UnaryOperator lookup) { + public List getPatterns(UnaryOperator lookup) { var key = ResourceKey.create(IXplatAbstractions.INSTANCE.getActionRegistry().key(), this.opName); var entry = IXplatAbstractions.INSTANCE.getActionRegistry().get(key); this.strokeOrder = !IXplatAbstractions.INSTANCE.getActionRegistry().getHolderOrThrow(key).is(HexTags.Actions.PER_WORLD_PATTERN); - return List.of(new Pair<>(entry.prototype(), HexCoord.getOrigin())); + return List.of(entry.prototype()); } @Override diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/ManualPatternComponent.java b/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/ManualPatternComponent.java index f03946384c..06f77903ba 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/ManualPatternComponent.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/ManualPatternComponent.java @@ -1,12 +1,10 @@ package at.petrak.hexcasting.interop.patchouli; -import at.petrak.hexcasting.api.casting.math.HexCoord; import at.petrak.hexcasting.api.casting.math.HexDir; import at.petrak.hexcasting.api.casting.math.HexPattern; import com.google.gson.Gson; import com.google.gson.JsonElement; import com.google.gson.annotations.SerializedName; -import com.mojang.datafixers.util.Pair; import vazkii.patchouli.api.IVariable; import java.util.ArrayList; @@ -25,19 +23,18 @@ public class ManualPatternComponent extends AbstractPatternComponent { protected transient boolean strokeOrder; @Override - public List> getPatterns(UnaryOperator lookup) { + public List getPatterns(UnaryOperator lookup) { this.strokeOrder = lookup.apply(IVariable.wrap(this.strokeOrderRaw)).asBoolean(true); var patsRaw = lookup.apply(IVariable.wrap(patternsRaw)).asListOrSingleton(); - var out = new ArrayList>(); + var out = new ArrayList(); for (var ivar : patsRaw) { JsonElement json = ivar.unwrap(); RawPattern raw = new Gson().fromJson(json, RawPattern.class); var dir = HexDir.fromString(raw.startdir); var pat = HexPattern.fromAngles(raw.signature, dir); - var origin = new HexCoord(raw.q, raw.r); - out.add(new Pair<>(pat, origin)); + out.add(pat); } return out; diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java b/Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java index 0829937b58..2aab4955cf 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java @@ -6,7 +6,6 @@ import at.petrak.hexcasting.client.render.RenderLib; import com.mojang.blaze3d.platform.GlStateManager; import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.vertex.PoseStack; import com.mojang.datafixers.util.Pair; import net.minecraft.client.gui.GuiGraphics; import net.minecraft.client.renderer.GameRenderer; @@ -26,6 +25,7 @@ public static void drawPattern(GuiGraphics graphics, int x, int y, List Date: Tue, 23 Jul 2024 18:39:42 -0400 Subject: [PATCH 33/48] re-add stroke gradient --- .../client/gui/PatternTooltipComponent.java | 4 +++- .../hexcasting/client/render/PatternColors.java | 14 ++++++++++++-- .../hexcasting/client/render/PatternRenderer.java | 10 ++++++++-- .../interop/inline/InlinePatternRenderer.java | 13 +++++++++++-- .../patchouli/AbstractPatternComponent.java | 13 ++++++++----- 5 files changed, 42 insertions(+), 12 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java b/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java index 6e1e2f4641..c6f7da11d8 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipComponent.java @@ -60,7 +60,9 @@ public void renderImage(Font font, int mouseX, int mouseY, GuiGraphics graphics) ps.scale(RENDER_SIZE, RENDER_SIZE, 1); PatternRenderer.renderPattern(pattern, ps, WorldlyPatternRenderHelpers.READABLE_SCROLL_SETTINGS, - PatternColors.READABLE_GRID_SCROLL_COLORS, 0, 512); + (PatternRenderer.shouldDoStrokeGradient() ? PatternColors.DEFAULT_GRADIENT_COLOR : PatternColors.DEFAULT_PATTERN_COLOR) + .withDots(true, true), + 0, 512); ps.popPose(); } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java index a81ae9191d..fb64669834 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternColors.java @@ -11,12 +11,14 @@ public record PatternColors(int innerStartColor, int innerEndColor, int outerSta // keep some handy frequently used colors here. public static final PatternColors DEFAULT_PATTERN_COLOR = new PatternColors(0xff_554d54, 0xff_d2c8c8); + public static final PatternColors DIMMED_COLOR = new PatternColors(0xFF_B4AAAA, 0xff_d2c8c8); + public static final PatternColors DEFAULT_GRADIENT_COLOR = DEFAULT_PATTERN_COLOR.withGradientEnds(DIMMED_COLOR); public static final int STARTING_DOT = 0xff_5b7bd7; public static final int GRID_DOTS = 0x80_d2c8c8; - public static final PatternColors READABLE_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDotColors(STARTING_DOT, 0); - public static final PatternColors READABLE_GRID_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDotColors(STARTING_DOT, GRID_DOTS); + public static final PatternColors READABLE_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDots(true, false); + public static final PatternColors READABLE_GRID_SCROLL_COLORS = DEFAULT_PATTERN_COLOR.withDots(true, true); public static final PatternColors SLATE_WOBBLY_COLOR = glowyStroke( 0xff_64c8ff); // old blue color public static final PatternColors SLATE_WOBBLY_PURPLE_COLOR = glowyStroke(0xff_cfa0f3); // shiny new purple one :) @@ -45,6 +47,14 @@ public static PatternColors gradientStroke(int startColor, int endColor){ return PatternColors.gradientStrokes(0, 0, startColor, endColor); } + public PatternColors withGradientEnds(int endColorInner, int endColorOuter){ + return new PatternColors(this.innerStartColor, endColorInner, this.outerStartColor, endColorOuter, this.startingDotColor, this.gridDotsColor); + } + + public PatternColors withGradientEnds(PatternColors end){ + return withGradientEnds(end.innerEndColor, end.outerEndColor); + } + // add dots -- note, this is how you tell the renderer to make dots public PatternColors withDotColors(int startingDotColor, int gridDotsColor){ return new PatternColors(this.innerStartColor, this.innerEndColor, this.outerStartColor, this.outerEndColor, diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index 1f0696352c..0b699ac461 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -6,6 +6,7 @@ import com.mojang.blaze3d.vertex.PoseStack; import com.mojang.blaze3d.vertex.VertexConsumer; import com.mojang.blaze3d.vertex.VertexFormat; +import net.minecraft.client.gui.screens.Screen; import net.minecraft.client.renderer.MultiBufferSource; import net.minecraft.resources.ResourceLocation; import net.minecraft.util.FastColor; @@ -54,11 +55,11 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Wor if(FastColor.ARGB32.alpha(patColors.outerEndColor()) != 0 && FastColor.ARGB32.alpha(patColors.outerStartColor()) != 0){ RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, (float)patSets.getOuterWidth(staticPoints.finalScale), - patColors.outerEndColor(), patColors.outerStartColor(), VCDrawHelper.getHelper(worldlyBits, ps,outerZ)); + patColors.outerStartColor(), patColors.outerEndColor(), VCDrawHelper.getHelper(worldlyBits, ps,outerZ)); } if(FastColor.ARGB32.alpha(patColors.innerEndColor()) != 0 && FastColor.ARGB32.alpha(patColors.innerStartColor()) != 0) { RenderLib.drawLineSeq(ps.last().pose(), zappyRenderSpace, (float)patSets.getInnerWidth(staticPoints.finalScale), - patColors.innerEndColor(), patColors.innerStartColor(), VCDrawHelper.getHelper(worldlyBits, ps,innerZ)); + patColors.innerStartColor(), patColors.innerEndColor(), VCDrawHelper.getHelper(worldlyBits, ps,innerZ)); } } @@ -127,5 +128,10 @@ private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @N return true; } + // TODO did we want to un-hardcode this for accessibility reasons ? + public static boolean shouldDoStrokeGradient(){ + return Screen.hasControlDown(); + } + public record WorldlyBits(@Nullable MultiBufferSource provider, Integer light, Vec3 normal){} } diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index 1c7dd5f890..b24ba86a5b 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -22,8 +22,17 @@ public ResourceLocation getId(){ new PatternSettings.PositionSettings(8.0, 9.0, 0, 0.5, PatternSettings.AxisAlignment.NONE, PatternSettings.AxisAlignment.CENTER, 4.0, 0, 0), PatternSettings.StrokeSettings.fromStroke(1.0), - PatternSettings.ZappySettings.STATIC - ); + new PatternSettings.ZappySettings(10, 0, 0, 0, + PatternSettings.ZappySettings.READABLE_OFFSET, 0.8f) + ){ + @Override + public double getOuterWidth(double scale){ + if(scale >= 1) return 1; + if(scale >= 0.75) return 0.75; + if(scale >= 0.5) return 0.5; + return 0.25; + } + }; public static final int INLINE_TEXTURE_RES = 16; // 128px so it looks good and pretty on up close signs and whatnot diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java b/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java index 17d51df24d..dcb19020a5 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java @@ -35,8 +35,6 @@ public void build(int x, int y, int pagenum) { public abstract boolean showStrokeOrder(); - public static final PatternColors GREAT_COLOR = new PatternColors(0xFF_B4AAAA, 0xff_d2c8c8).withDots(false, true); - @Override public void render(GuiGraphics graphics, IComponentRenderContext context, float pticks, int mouseX, int mouseY) { PoseStack ps = graphics.pose(); @@ -56,6 +54,13 @@ public void render(GuiGraphics graphics, IComponentRenderContext context, float showStrokeOrder() ? PatternSettings.ZappySettings.READABLE : PatternSettings.ZappySettings.STATIC ); + PatternColors patCols = PatternColors.DIMMED_COLOR.withDots(false, true); + + if(showStrokeOrder()){ + patCols = PatternRenderer.shouldDoStrokeGradient() ? PatternColors.DEFAULT_GRADIENT_COLOR.withDots(true, true) + : PatternColors.READABLE_GRID_SCROLL_COLORS; + } + for(int p = 0; p < patterns.size(); p++){ int r = p / cols; @@ -65,9 +70,7 @@ public void render(GuiGraphics graphics, IComponentRenderContext context, float ps.pushPose(); ps.translate(cellW * c, cellH * r + 16, 100); - PatternRenderer.renderPattern(pattern, graphics.pose(), patSets, - showStrokeOrder() ? PatternColors.READABLE_GRID_SCROLL_COLORS : GREAT_COLOR - , 0, 4); + PatternRenderer.renderPattern(pattern, graphics.pose(), patSets, patCols, 0, 4); ps.popPose(); } ps.popPose(); From bf0ed928e282f51a485cb928c002ec4c1b653423 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Sat, 27 Jul 2024 20:09:32 -0400 Subject: [PATCH 34/48] switch emi/jei pattern tab icons over to new system --- .../client/render/PatternSettings.java | 7 +- .../interop/utils/PatternDrawingUtil.java | 128 ------------------ .../interop/utils/PatternEntry.java | 11 -- .../interop/emi/PatternRendererEMI.java | 45 +++--- .../forge/interop/jei/PatternDrawable.java | 50 ++++--- 5 files changed, 60 insertions(+), 181 deletions(-) delete mode 100644 Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java delete mode 100644 Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternEntry.java diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java index 792be72ea9..1996b6e327 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java @@ -64,9 +64,10 @@ public enum AxisAlignment{ } private final String name; - private final PositionSettings posSets; - private final StrokeSettings strokeSets; - private final ZappySettings zapSets; + // leaving these public for more convenient chaining. Should prefer using the getters for overrideability. + public final PositionSettings posSets; + public final StrokeSettings strokeSets; + public final ZappySettings zapSets; public String getName(){ return name; } diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java b/Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java deleted file mode 100644 index 2aab4955cf..0000000000 --- a/Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java +++ /dev/null @@ -1,128 +0,0 @@ -package at.petrak.hexcasting.interop.utils; - -import at.petrak.hexcasting.api.casting.math.HexCoord; -import at.petrak.hexcasting.api.casting.math.HexPattern; -import at.petrak.hexcasting.api.utils.HexUtils; -import at.petrak.hexcasting.client.render.RenderLib; -import com.mojang.blaze3d.platform.GlStateManager; -import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.datafixers.util.Pair; -import net.minecraft.client.gui.GuiGraphics; -import net.minecraft.client.renderer.GameRenderer; -import net.minecraft.util.FastColor; -import net.minecraft.util.Mth; -import net.minecraft.world.phys.Vec2; - -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; - -public final class PatternDrawingUtil { - public static void drawPattern(GuiGraphics graphics, int x, int y, List patterns, List dots, - boolean strokeOrder, int outer, int innerLight, int innerDark, - int dotColor) { - var poseStack = graphics.pose(); - poseStack.pushPose(); - poseStack.translate(x, y, 1); - var mat = poseStack.last().pose(); - - var prevShader = RenderSystem.getShader(); - RenderSystem.setShader(GameRenderer::getPositionColorShader); -// RenderSystem.disableDepthTest(); - RenderSystem.disableCull(); - RenderSystem.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA); - - // mark center -// RenderLib.drawSpot(mat, Vec2.ZERO, 0f, 0f, 0f, 1f); - - for (var pat : patterns) { - RenderLib.drawLineSeq(mat, pat.zappyPoints(), 5f, 0, outer, outer); - RenderLib.drawLineSeq(mat, pat.zappyPoints(), 2f, 0, - strokeOrder ? innerDark : innerLight, innerLight); - - if (strokeOrder) { - RenderLib.drawSpot(mat, pat.zappyPoints().get(0), 2.5f, 1f, 0.1f, 0.15f, 0.6f); - } - } - - float dotR = FastColor.ARGB32.red(dotColor) / 255f; - float dotG = FastColor.ARGB32.green(dotColor) / 255f; - float dotB = FastColor.ARGB32.blue(dotColor) / 255f; - float dotA = FastColor.ARGB32.alpha(dotColor) / 255f; - - for (var dot : dots) { - RenderLib.drawSpot(mat, dot, 1.5f, dotR, dotG, dotB, dotA); - } - - RenderSystem.defaultBlendFunc(); - RenderSystem.setShader(() -> prevShader); - - RenderSystem.enableCull(); - - poseStack.popPose(); - } - - public static PatternRenderingData loadPatterns(List> patterns, - float readabilityOffset, float lastLineLenProp) { - var patternEntries = new ArrayList(patterns.size()); - - var fakeScale = 1; - var seenFakePoints = new ArrayList(); - var seenCoords = new HashSet(); - for (var pair : patterns) { - var pattern = pair.getFirst(); - var origin = pair.getSecond(); - for (var pos : pattern.positions(origin)) { - var px = HexUtils.coordToPx(pos, fakeScale, Vec2.ZERO); - seenFakePoints.add(px); - } - - // And while we're looping add the (COORD ONLY) things internally - patternEntries.add(new PatternEntry(pattern, origin, new ArrayList<>())); - seenCoords.addAll(pattern.positions(origin)); - } - var fakeCom = HexUtils.findCenter(seenFakePoints); - - var maxDx = -1f; - var maxDy = -1f; - for (var dot : seenFakePoints) { - var dx = Mth.abs(dot.x - fakeCom.x); - if (dx > maxDx) { - maxDx = dx; - } - var dy = Mth.abs(dot.y - fakeCom.y); - if (dy > maxDy) { - maxDy = dy; - } - } - var hexSize = Math.min(12, Math.min(120 / 2.5f / maxDx, 70 / 2.5f / maxDy)); - - var seenRealPoints = new ArrayList(); - for (var pat : patternEntries) { - for (var pos : pat.pattern().positions(pat.origin())) { - var px = HexUtils.coordToPx(pos, hexSize, Vec2.ZERO); - seenRealPoints.add(px); - } - } - var realCom = HexUtils.findCenter(seenRealPoints); - - // and NOW for real! - for (int i = 0; i < patternEntries.size(); i++) { - PatternEntry pat = patternEntries.get(i); - var localOrigin = HexUtils.coordToPx(pat.origin(), hexSize, realCom.negated()); - var points = pat.pattern().toLines(hexSize, localOrigin); - pat.zappyPoints() - .addAll(RenderLib.makeZappy(points, RenderLib.findDupIndices(pat.pattern().positions()), 10, 0.8f, 0f, - 0f, readabilityOffset, lastLineLenProp, i)); - } - - var pathfinderDots = seenCoords.stream() - .map(coord -> HexUtils.coordToPx(coord, hexSize, realCom.negated())).toList(); - - return new PatternRenderingData(patternEntries, pathfinderDots, hexSize); - } - - public record PatternRenderingData(List patterns, List pathfinderDots, float hexSize) { - // NO-OP - } -} diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternEntry.java b/Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternEntry.java deleted file mode 100644 index b2c717d126..0000000000 --- a/Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternEntry.java +++ /dev/null @@ -1,11 +0,0 @@ -package at.petrak.hexcasting.interop.utils; - -import at.petrak.hexcasting.api.casting.math.HexCoord; -import at.petrak.hexcasting.api.casting.math.HexPattern; -import net.minecraft.world.phys.Vec2; - -import java.util.List; - -public record PatternEntry(HexPattern pattern, HexCoord origin, List zappyPoints) { - // NO-OP -} diff --git a/Fabric/src/main/java/at/petrak/hexcasting/fabric/interop/emi/PatternRendererEMI.java b/Fabric/src/main/java/at/petrak/hexcasting/fabric/interop/emi/PatternRendererEMI.java index 3f27fff2ea..af23651d27 100644 --- a/Fabric/src/main/java/at/petrak/hexcasting/fabric/interop/emi/PatternRendererEMI.java +++ b/Fabric/src/main/java/at/petrak/hexcasting/fabric/interop/emi/PatternRendererEMI.java @@ -1,19 +1,18 @@ package at.petrak.hexcasting.fabric.interop.emi; -import at.petrak.hexcasting.api.casting.math.HexCoord; +import at.petrak.hexcasting.api.casting.math.HexPattern; import at.petrak.hexcasting.api.mod.HexTags; import at.petrak.hexcasting.api.utils.HexUtils; -import at.petrak.hexcasting.interop.utils.PatternDrawingUtil; -import at.petrak.hexcasting.interop.utils.PatternEntry; +import at.petrak.hexcasting.client.render.PatternColors; +import at.petrak.hexcasting.client.render.PatternRenderer; +import at.petrak.hexcasting.client.render.PatternSettings; +import at.petrak.hexcasting.client.render.PatternSettings.PositionSettings; +import at.petrak.hexcasting.client.render.PatternSettings.StrokeSettings; +import at.petrak.hexcasting.client.render.PatternSettings.ZappySettings; import at.petrak.hexcasting.xplat.IXplatAbstractions; -import com.mojang.blaze3d.vertex.PoseStack; -import com.mojang.datafixers.util.Pair; import dev.emi.emi.api.render.EmiRenderable; import net.minecraft.client.gui.GuiGraphics; import net.minecraft.resources.ResourceLocation; -import net.minecraft.world.phys.Vec2; - -import java.util.List; public class PatternRendererEMI implements EmiRenderable { @@ -25,19 +24,21 @@ public class PatternRendererEMI implements EmiRenderable { private boolean strokeOrder; - private final List patterns; - private final List pathfinderDots; + private final HexPattern pat; + private PatternSettings patSets; public PatternRendererEMI(ResourceLocation pattern, int w, int h) { var regi = IXplatAbstractions.INSTANCE.getActionRegistry(); var entry = regi.get(pattern); this.strokeOrder = HexUtils.isOfTag(regi, pattern, HexTags.Actions.PER_WORLD_PATTERN); - var data = PatternDrawingUtil.loadPatterns(List.of(new Pair<>(entry.prototype(), HexCoord.getOrigin())), 0f, - 1f); - this.patterns = data.patterns(); - this.pathfinderDots = data.pathfinderDots(); + this.pat = entry.prototype(); this.width = w; this.height = h; + this.patSets = new PatternSettings("pattern_drawable_" + w + "_" + h, + new PositionSettings(width, height, 0, 0, + PatternSettings.AxisAlignment.CENTER, PatternSettings.AxisAlignment.CENTER, Math.max(width, height), 0, 0), + StrokeSettings.fromStroke(0.075 * Math.min(width, height)), + ZappySettings.READABLE); } public PatternRendererEMI shift(int x, int y) { @@ -47,6 +48,13 @@ public PatternRendererEMI shift(int x, int y) { } public PatternRendererEMI strokeOrder(boolean order) { + if(order != strokeOrder){ + patSets = new PatternSettings("pattern_drawable_" + width + "_" + height + (order ? "" : "nostroke"), + patSets.posSets, + patSets.strokeSets, + order ? ZappySettings.READABLE : ZappySettings.STATIC + ); + } strokeOrder = order; return this; } @@ -55,10 +63,11 @@ public PatternRendererEMI strokeOrder(boolean order) { public void render(GuiGraphics graphics, int x, int y, float delta) { var ps = graphics.pose(); ps.pushPose(); - ps.translate(xOffset + x - 0.5f + width / 2f, yOffset + y + 1 + height / 2f, 0); - ps.scale(width / 64f, height / 64f, 1f); - PatternDrawingUtil.drawPattern(graphics, 0, 0, this.patterns, this.pathfinderDots, this.strokeOrder, - 0xff_333030, 0xff_191818, 0xc8_0c0a0c, 0x80_666363); + ps.translate(xOffset + x, yOffset + y + 1, 0); + PatternRenderer.renderPattern(pat, graphics.pose(), patSets, + new PatternColors(0xc8_0c0a0c, 0xff_333030).withDotColors(0x80_666363, 0), + 0, 10 + ); ps.popPose(); } } diff --git a/Forge/src/main/java/at/petrak/hexcasting/forge/interop/jei/PatternDrawable.java b/Forge/src/main/java/at/petrak/hexcasting/forge/interop/jei/PatternDrawable.java index 62417e5e28..38f377fb40 100644 --- a/Forge/src/main/java/at/petrak/hexcasting/forge/interop/jei/PatternDrawable.java +++ b/Forge/src/main/java/at/petrak/hexcasting/forge/interop/jei/PatternDrawable.java @@ -1,40 +1,40 @@ package at.petrak.hexcasting.forge.interop.jei; -import at.petrak.hexcasting.api.casting.math.HexCoord; +import at.petrak.hexcasting.api.casting.math.HexPattern; import at.petrak.hexcasting.api.mod.HexTags; import at.petrak.hexcasting.api.utils.HexUtils; -import at.petrak.hexcasting.interop.utils.PatternDrawingUtil; -import at.petrak.hexcasting.interop.utils.PatternEntry; +import at.petrak.hexcasting.client.render.PatternColors; +import at.petrak.hexcasting.client.render.PatternRenderer; +import at.petrak.hexcasting.client.render.PatternSettings; +import at.petrak.hexcasting.client.render.PatternSettings.PositionSettings; +import at.petrak.hexcasting.client.render.PatternSettings.StrokeSettings; +import at.petrak.hexcasting.client.render.PatternSettings.ZappySettings; import at.petrak.hexcasting.xplat.IXplatAbstractions; -import com.mojang.datafixers.util.Pair; import mezz.jei.api.gui.drawable.IDrawable; import net.minecraft.client.gui.GuiGraphics; import net.minecraft.resources.ResourceLocation; -import net.minecraft.world.phys.Vec2; - -import java.util.List; public class PatternDrawable implements IDrawable { private final int width; private final int height; private boolean strokeOrder; + private final HexPattern pat; - private final List patterns; - private final List pathfinderDots; + private PatternSettings patSets; public PatternDrawable(ResourceLocation pattern, int w, int h) { var regi = IXplatAbstractions.INSTANCE.getActionRegistry(); var entry = regi.get(pattern); this.strokeOrder = !HexUtils.isOfTag(regi, pattern, HexTags.Actions.PER_WORLD_PATTERN); - var data = PatternDrawingUtil.loadPatterns( - List.of(new Pair<>(entry.prototype(), HexCoord.getOrigin())), - 0f, - 1f); - this.patterns = data.patterns(); - this.pathfinderDots = data.pathfinderDots(); + this.pat = entry.prototype(); this.width = w; this.height = h; + this.patSets = new PatternSettings("pattern_drawable_" + w + "_" + h, + new PositionSettings(width, height, 0, 0, + PatternSettings.AxisAlignment.CENTER, PatternSettings.AxisAlignment.CENTER, Math.max(width, height), 0, 0), + StrokeSettings.fromStroke(0.075 * Math.min(width, height)), + ZappySettings.READABLE); } @Override @@ -48,18 +48,26 @@ public int getHeight() { } public PatternDrawable strokeOrder(boolean order) { + if(order != strokeOrder){ + patSets = new PatternSettings("pattern_drawable_" + width + "_" + height + (order ? "" : "nostroke"), + patSets.posSets, + patSets.strokeSets, + order ? ZappySettings.READABLE : ZappySettings.STATIC + ); + } strokeOrder = order; return this; } @Override - public void draw(GuiGraphics guiGraphics, int xOffset, int yOffset) { - var ps = guiGraphics.pose(); + public void draw(GuiGraphics graphics, int x, int y) { + var ps = graphics.pose(); ps.pushPose(); - ps.translate(xOffset - 0.5f + width / 2f, yOffset + height / 2f, 0); - ps.scale(width / 64f, height / 64f, 1f); - PatternDrawingUtil.drawPattern(guiGraphics, 0, 0, this.patterns, this.pathfinderDots, this.strokeOrder, - 0xff_333030, 0xff_191818, 0xc8_0c0a0c, 0x80_666363); + ps.translate(x, y + 1, 0); + PatternRenderer.renderPattern(pat, graphics.pose(), patSets, + new PatternColors(0xc8_0c0a0c, 0xff_333030).withDotColors(0x80_666363, 0), + 0, 10 + ); ps.popPose(); } } From 0a7fd12e7a493b72c2d3de7240a85464fa120d6d Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Sat, 27 Jul 2024 21:50:07 -0400 Subject: [PATCH 35/48] fix akashic bookshelf lighting (fix #587) --- .../client/render/WorldlyPatternRenderHelpers.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index 13aa852bd0..2b562cdc52 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -8,6 +8,7 @@ import at.petrak.hexcasting.common.entities.EntityWallScroll; import com.mojang.blaze3d.vertex.PoseStack; import com.mojang.math.Axis; +import net.minecraft.client.renderer.LevelRenderer; import net.minecraft.client.renderer.MultiBufferSource; import net.minecraft.core.Vec3i; import net.minecraft.world.level.block.state.BlockState; @@ -109,8 +110,10 @@ public static void renderPatternForAkashicBookshelf(BlockEntityAkashicBookshelf ps.translate(tV.getX(), tV.getY(), tV.getZ()); ps.mulPose(Axis.YP.rotationDegrees(WALL_ROTATIONS[facing % 4])); + int actualLight = LevelRenderer.getLightColor(tile.getLevel(), tile.getBlockPos().relative(bs.getValue(BlockAkashicBookshelf.FACING))); + renderPattern(pattern, WORLDLY_SETTINGS , PatternColors.DEFAULT_PATTERN_COLOR, - tile.getBlockPos().hashCode(), ps, buffer, WALL_NORMALS[facing % 4].multiply(-1, -1, -1), -0.02f, light, 1); + tile.getBlockPos().hashCode(), ps, buffer, WALL_NORMALS[facing % 4].multiply(-1, -1, -1), -0.02f, actualLight, 1); ps.popPose(); } From 1400256eac802990a53de97dd66199b2a441a7be Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Sat, 27 Jul 2024 22:16:56 -0400 Subject: [PATCH 36/48] hopefully fix placement flickering (#567) and also remove resolution scaling stuff since it was barely being used still --- .../client/render/PatternTextureManager.java | 41 +------------------ .../command/PatternTexturesCommand.java | 10 ----- 2 files changed, 1 insertion(+), 50 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java index c28d90a507..d4311ce7d8 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java @@ -19,32 +19,12 @@ public class PatternTextureManager { //TODO: remove if not needed anymore for comparison public static boolean useTextures = true; public static int repaintIndex = 0; - public static int resolutionScaler = 4; - public static int fastRenderScaleFactor = 8; // e.g. this is 8, resolution is 1024, so render at 1024/8 = 128 - - public static int resolutionByBlockSize = 128 * resolutionScaler; - public static int paddingByBlockSize = 16 * resolutionScaler; - public static int circleRadiusByBlockSize = 2 * resolutionScaler; - public static int scaleLimit = 4 * resolutionScaler; - public static int scrollLineWidth = 3 * resolutionScaler; - public static int otherLineWidth = 4 * resolutionScaler; - - public static void setResolutionScaler(int resolutionScaler) { - PatternTextureManager.resolutionScaler = resolutionScaler; - resolutionByBlockSize = 128 * resolutionScaler; - paddingByBlockSize = 16 * resolutionScaler; - circleRadiusByBlockSize = 2 * resolutionScaler; - scaleLimit = 4 * resolutionScaler; - scrollLineWidth = 3 * resolutionScaler; - otherLineWidth = 4 * resolutionScaler; - } private static final ConcurrentMap> patternTexturesToAdd = new ConcurrentHashMap<>(); private static final Set inProgressPatterns = new HashSet<>(); // basically newCachedThreadPool, but with a max pool size private static final ExecutorService executor = new ThreadPoolExecutor(0, 16, 60L, TimeUnit.SECONDS, new LinkedBlockingDeque<>()); - private static final HashMap> patternTextures = new HashMap<>(); public static Optional> getTextures(HexPattern pattern, PatternSettings patSets, double seed, int resPerUnit) { @@ -59,7 +39,7 @@ public static Optional> getTextures(HexPattern pat for(ResourceLocation oldPatternTextureSingle : oldPatternTexture.values()) Minecraft.getInstance().getTextureManager().getTexture(oldPatternTextureSingle).close(); - return Optional.of(patternTexture); + return Optional.empty(); // try not giving it immediately to avoid flickering? } if (patternTextures.containsKey(patCacheKey)) return Optional.of(patternTextures.get(patCacheKey)); @@ -92,29 +72,10 @@ private static Map createTextures(HexPattern pattern, Pa NativeImage outerLines = drawLines(zappyRenderSpace, staticPoints, (float)patSets.getOuterWidth((staticPoints.finalScale)), resPerUnit); patTexts.put("outer", new DynamicTexture(outerLines)); - // TODO: handle start hexagon and grid bits. - -// g2d.setColor(outerColor); -// g2d.setStroke(new BasicStroke((blockSize * 5f / 3f) * lineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); -// drawLines(g2d, points, minX, minY, scale, offsetX, offsetY, padding); -// - -// -// if (showsStrokeOrder) { -// g2d.setColor(new Color(0xff_d77b5b)); -// Tuple point = getTextureCoordinates(points.get(0), minX, minY, scale, offsetX, offsetY, padding); -// int spotRadius = circleRadiusByBlockSize * blockSize; -// drawHexagon(g2d, point.getA(), point.getB(), spotRadius); -// } - - return patTexts; } private static Map registerTextures(String patTextureKeyBase, Map dynamicTextures) { - // isSlow used to register different textures for the low-resolution, fastly rendered version of each texture - // and the high-resolution, slowly rendered version (this means the slow doesn't replace the fast in the texture manager, - // which causes occasional visual stuttering for a frame). Map resLocs = new HashMap<>(); for(Map.Entry textureEntry : dynamicTextures.entrySet()){ String name = "hex_pattern_texture_" + patTextureKeyBase + "_" + textureEntry.getKey() + "_" + repaintIndex + ".png"; diff --git a/Common/src/main/java/at/petrak/hexcasting/common/command/PatternTexturesCommand.java b/Common/src/main/java/at/petrak/hexcasting/common/command/PatternTexturesCommand.java index 2ac11403b1..868f02e2de 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/command/PatternTexturesCommand.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/command/PatternTexturesCommand.java @@ -1,7 +1,6 @@ package at.petrak.hexcasting.common.command; import at.petrak.hexcasting.client.render.PatternTextureManager; -import com.mojang.brigadier.arguments.IntegerArgumentType; import com.mojang.brigadier.builder.LiteralArgumentBuilder; import net.minecraft.commands.CommandSourceStack; import net.minecraft.commands.Commands; @@ -26,14 +25,5 @@ public static void add(LiteralArgumentBuilder cmd) { ctx.getSource().sendSuccess(() -> Component.literal("Repainting pattern textures. This is meant for debugging."), true); return 1; })); - cmd.then(Commands.literal("textureSetResolutionScaler") - .requires(dp -> dp.hasPermission(Commands.LEVEL_ADMINS)) - .then(Commands.argument("integer", IntegerArgumentType.integer()).executes(ctx -> { - int newRes = IntegerArgumentType.getInteger(ctx, "integer"); - PatternTextureManager.setResolutionScaler(newRes); - PatternTextureManager.repaint(); - ctx.getSource().sendSuccess(() -> Component.literal("Setting pattern resolution scaler to " + newRes + ". This is meant for debugging."), true); - return 1; - }))); } } \ No newline at end of file From 33e5b2424d987e74cd0329ea355792a6d2c928b9 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Tue, 30 Jul 2024 11:34:56 -0400 Subject: [PATCH 37/48] restore non hex-grid/pattern rendering. start lore doc --- .../client/render/HexPatternLike.java | 64 +++++++++++++++++++ .../client/render/HexPatternPoints.java | 16 ++--- .../client/render/PATTERN_RENDER_LORE.md | 20 ++++++ .../client/render/PatternRenderer.java | 22 ++++--- .../client/render/PatternSettings.java | 6 +- .../client/render/PatternTextureManager.java | 11 ++-- .../render/WorldlyPatternRenderHelpers.java | 2 +- .../interop/inline/InlinePatternRenderer.java | 7 +- 8 files changed, 113 insertions(+), 35 deletions(-) create mode 100644 Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternLike.java create mode 100644 Common/src/main/java/at/petrak/hexcasting/client/render/PATTERN_RENDER_LORE.md diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternLike.java b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternLike.java new file mode 100644 index 0000000000..55b33705bb --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternLike.java @@ -0,0 +1,64 @@ +package at.petrak.hexcasting.client.render; + +import at.petrak.hexcasting.api.casting.math.HexPattern; +import net.minecraft.world.phys.Vec2; + +import java.util.List; +import java.util.Objects; +import java.util.Set; + +public interface HexPatternLike { + List getNonZappyPoints(); + + String getName(); + + Set getDups(); + + static HexPatternLike of(HexPattern pat){ + return new HexPatternLikeBecauseItsActuallyAHexPattern(pat); + } + + static HexPatternLike of(List lines, String name){ + return new PureLines(lines, name); + } + + record HexPatternLikeBecauseItsActuallyAHexPattern(HexPattern pat) implements HexPatternLike{ + public List getNonZappyPoints(){ + return pat.toLines(1, Vec2.ZERO); + } + + public String getName(){ + return pat.getStartDir() + "-" + pat.anglesSignature(); + } + + public Set getDups(){ + return RenderLib.findDupIndices(pat.positions()); + } + } + + record PureLines(List lines, String name) implements HexPatternLike{ + + public List getNonZappyPoints(){ + return lines; + } + + public String getName(){ + return name; + } + + public Set getDups(){ + return RenderLib.findDupIndices( + lines().stream().map(p -> + // I hate mojang + new Vec2(p.x, p.y){ + @Override public boolean equals(Object other){ + if(other instanceof Vec2 otherVec) return p.equals(otherVec); + return false; + } + + @Override public int hashCode(){ return Objects.hash(p.x, p.y); } + }).toList() + ); + } + } +} diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java index 118f5f0cfe..163cdc0109 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java @@ -1,12 +1,10 @@ package at.petrak.hexcasting.client.render; -import at.petrak.hexcasting.api.casting.math.HexPattern; import com.google.common.collect.ImmutableList; import net.minecraft.world.phys.Vec2; import java.util.ArrayList; import java.util.List; -import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; @@ -40,15 +38,13 @@ public class HexPatternPoints { private static final ConcurrentMap CACHED_STATIC_POINTS = new ConcurrentHashMap<>(); - private HexPatternPoints(HexPattern pattern, PatternSettings patSets, double seed) { + private HexPatternPoints(HexPatternLike patternlike, PatternSettings patSets, double seed) { - List dots = pattern.toLines(1, Vec2.ZERO); - - Set dupIndices = RenderLib.findDupIndices(pattern.positions()); + List dots = patternlike.getNonZappyPoints(); // always do space calculations with the static version of the pattern // so that it doesn't jump around resizing itself. - List zappyPoints = RenderLib.makeZappy(dots, dupIndices, + List zappyPoints = RenderLib.makeZappy(dots, patternlike.getDups(), patSets.getHops(), patSets.getVariance(), 0f, patSets.getFlowIrregular(), patSets.getReadabilityOffset(), patSets.getLastSegmentProp(), seed); @@ -135,10 +131,10 @@ public List scaleVecs(List points){ * This is used in rendering static patterns and positioning non-static patterns. * */ - public static HexPatternPoints getStaticPoints(HexPattern pattern, PatternSettings patSets, double seed){ + public static HexPatternPoints getStaticPoints(HexPatternLike patternlike, PatternSettings patSets, double seed){ - String cacheKey = patSets.getCacheKey(pattern, seed); + String cacheKey = patSets.getCacheKey(patternlike, seed); - return CACHED_STATIC_POINTS.computeIfAbsent(cacheKey, (key) -> new HexPatternPoints(pattern, patSets, seed) ); + return CACHED_STATIC_POINTS.computeIfAbsent(cacheKey, (key) -> new HexPatternPoints(patternlike, patSets, seed) ); } } \ No newline at end of file diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PATTERN_RENDER_LORE.md b/Common/src/main/java/at/petrak/hexcasting/client/render/PATTERN_RENDER_LORE.md new file mode 100644 index 0000000000..6fce68ee0b --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PATTERN_RENDER_LORE.md @@ -0,0 +1,20 @@ +# Pattern Rendering Lore + +This is an overview of the new pattern rendering systems introduced alongside the Inline pattern rendering + +## Brief History / Motivations + +In v0.10.3 (and probably before) the pattern rendering was well known for causing lag if many patterns were rendered at once. +The pattern code was also duplicated *a lot*, pretty much anywhere that did pattern rendering needed to do it slightly different and so the rendering/positioning code got copy-pasted all around, frequently with a lot of magic numbers. + +During 1.20 development, we [added texture based rendering](https://github.com/FallingColors/HexMod/pull/555), and switched most static rendering over to it. There was still a fair bit of duplicate code though, especially with pattern positioning. + +Now with the new system, all of the rendering is contained to a few classes and outside users (such as slates for example) can specify how they want patterns to be rendered using PatternSettings and PatternColors. + +## System Walkthrough + +### PatternRenderer + +This is the main entrypoint for pattern rendering. It has 2 main methods, both called `renderPattern`. The only difference is that one has a `WorldlyBits` argument used for passing in lighting, vc providers, and normals, that are generally only used for in-world rendering, as opposed to UI rendering. + +Generally the idea here is that you shouldn't need to worry about whether the pattern will be rendered as a texture or dynamically, the `PatternRenderer` will make that decision, prefering the texture renderer when it can. \ No newline at end of file diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index 0b699ac461..0255eeaf04 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -25,16 +25,20 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, PatternSettin renderPattern(pattern, ps, null, patSets, patColors, seed, resPerUnit); } - public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable WorldlyBits worldlyBits, PatternSettings patSets, PatternColors patColors, double seed, int resPerUnit){ + public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable WorldlyBits worldlyBits, PatternSettings patSets, PatternColors patColors, double seed, int resPerUnit) { + renderPattern(HexPatternLike.of(pattern), ps, worldlyBits, patSets, patColors, seed, resPerUnit); + } + + public static void renderPattern(HexPatternLike patternlike, PoseStack ps, @Nullable WorldlyBits worldlyBits, PatternSettings patSets, PatternColors patColors, double seed, int resPerUnit){ var oldShader = RenderSystem.getShader(); - HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); + HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(patternlike, patSets, seed); boolean shouldRenderDynamic = true; // only do texture rendering if it's static and has solid colors if(patSets.getSpeed() == 0 && PatternTextureManager.useTextures && patColors.innerStartColor() == patColors.innerEndColor() && patColors.outerStartColor() == patColors.outerEndColor()){ - boolean didRender = renderPatternTexture(pattern, ps, worldlyBits, patSets, patColors, seed, resPerUnit); + boolean didRender = renderPatternTexture(patternlike, ps, worldlyBits, patSets, patColors, seed, resPerUnit); if(didRender) shouldRenderDynamic = false; } if(shouldRenderDynamic){ @@ -44,9 +48,9 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Wor // re-use our static points if we're rendering a static pattern anyway zappyPattern = staticPoints.zappyPoints; } else { - List lines1 = pattern.toLines(1, Vec2.ZERO); - Set dupIndices = RenderLib.findDupIndices(pattern.positions()); - zappyPattern = RenderLib.makeZappy(lines1, dupIndices, + List nonzappyLines = patternlike.getNonZappyPoints(); + Set dupIndices = RenderLib.findDupIndices(nonzappyLines); + zappyPattern = RenderLib.makeZappy(nonzappyLines, dupIndices, patSets.getHops(), patSets.getVariance(), patSets.getSpeed(), patSets.getFlowIrregular(), patSets.getReadabilityOffset(), patSets.getLastSegmentProp(), seed); } @@ -86,14 +90,14 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Wor private static final float outerZ = 0.0005f; private static final float innerZ = 0.001f; - private static boolean renderPatternTexture(HexPattern pattern, PoseStack ps, @Nullable WorldlyBits worldlyBits, PatternSettings patSets, PatternColors patColors, double seed, int resPerUnit){ - Optional> maybeTextures = PatternTextureManager.getTextures(pattern, patSets, seed, resPerUnit); + private static boolean renderPatternTexture(HexPatternLike patternlike, PoseStack ps, @Nullable WorldlyBits worldlyBits, PatternSettings patSets, PatternColors patColors, double seed, int resPerUnit){ + Optional> maybeTextures = PatternTextureManager.getTextures(patternlike, patSets, seed, resPerUnit); if(maybeTextures.isEmpty()){ return false; } Map textures = maybeTextures.get(); - HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); + HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(patternlike, patSets, seed); VertexConsumer vc; diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java index 1996b6e327..9dcaf4329e 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java @@ -1,7 +1,5 @@ package at.petrak.hexcasting.client.render; -import at.petrak.hexcasting.api.casting.math.HexPattern; - /** * A class holding settings for shaping and positioning patterns. * @@ -49,8 +47,8 @@ public record ZappySettings(int hops, float variance, float speed, float flowIrr public static ZappySettings WOBBLY = new ZappySettings(10, 2.5f, 0.1f, 0.2f, 0, 1f); } - public String getCacheKey(HexPattern pattern, double seed){ - return (pattern.getStartDir() + "-" + pattern.anglesSignature() + "-" + getName() + "-" + seed).toLowerCase(); + public String getCacheKey(HexPatternLike patternlike, double seed){ + return (patternlike.getName() + "-" + getName() + "-" + seed).toLowerCase(); } // determines how the pattern is fit and aligned on a given axis diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java index d4311ce7d8..8486124920 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternTextureManager.java @@ -1,6 +1,5 @@ package at.petrak.hexcasting.client.render; -import at.petrak.hexcasting.api.casting.math.HexPattern; import com.mojang.blaze3d.platform.NativeImage; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.texture.DynamicTexture; @@ -27,8 +26,8 @@ public class PatternTextureManager { private static final HashMap> patternTextures = new HashMap<>(); - public static Optional> getTextures(HexPattern pattern, PatternSettings patSets, double seed, int resPerUnit) { - String patCacheKey = patSets.getCacheKey(pattern, seed) + "_" + resPerUnit; + public static Optional> getTextures(HexPatternLike patternlike, PatternSettings patSets, double seed, int resPerUnit) { + String patCacheKey = patSets.getCacheKey(patternlike, seed) + "_" + resPerUnit; // move textures from concurrent map to normal hashmap as needed if (patternTexturesToAdd.containsKey(patCacheKey)) { @@ -48,7 +47,7 @@ public static Optional> getTextures(HexPattern pat if(!inProgressPatterns.contains(patCacheKey)){ inProgressPatterns.add(patCacheKey); executor.submit(() -> { - var slowTextures = createTextures(pattern, patSets, seed, resPerUnit); + var slowTextures = createTextures(patternlike, patSets, seed, resPerUnit); // TextureManager#register doesn't look very thread-safe, so move back to the main thread after the slow part is done Minecraft.getInstance().execute(() -> { @@ -59,8 +58,8 @@ public static Optional> getTextures(HexPattern pat return Optional.empty(); } - private static Map createTextures(HexPattern pattern, PatternSettings patSets, double seed, int resPerUnit) { - HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(pattern, patSets, seed); + private static Map createTextures(HexPatternLike patternlike, PatternSettings patSets, double seed, int resPerUnit) { + HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(patternlike, patSets, seed); List zappyRenderSpace = staticPoints.scaleVecs(staticPoints.zappyPoints); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index 2b562cdc52..345a61618b 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -141,7 +141,7 @@ public static void renderPattern(HexPattern pattern, PatternSettings patSets, Pa ps.mulPoseMatrix(noNormalInv.last().pose()); PatternRenderer.renderPattern(pattern, ps, new PatternRenderer.WorldlyBits(bufSource, light, normal), - patSets, patColors, seed, blockSize * PatternTextureManager.resolutionByBlockSize); + patSets, patColors, seed, blockSize * 512); ps.popPose(); } diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index b24ba86a5b..a0e8efccb8 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -1,9 +1,6 @@ package at.petrak.hexcasting.interop.inline; -import at.petrak.hexcasting.client.render.HexPatternPoints; -import at.petrak.hexcasting.client.render.PatternColors; -import at.petrak.hexcasting.client.render.PatternRenderer; -import at.petrak.hexcasting.client.render.PatternSettings; +import at.petrak.hexcasting.client.render.*; import com.samsthenerd.inline.api.client.InlineRenderer; import net.minecraft.client.gui.GuiGraphics; import net.minecraft.network.chat.Style; @@ -55,7 +52,7 @@ public int render(InlinePatternData data, GuiGraphics drawContext, int index, St public int charWidth(InlinePatternData data, Style style, int codepoint){ - HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(data.pattern, INLINE_SETTINGS, 0); + HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(HexPatternLike.of(data.pattern), INLINE_SETTINGS, 0); double baseScale = 4.0 / 1.5; double baseHeight = staticPoints.rangeY * baseScale; From 300407551e6f3f04dbb0bba4842a37e9e0423fcf Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Tue, 30 Jul 2024 15:29:37 -0400 Subject: [PATCH 38/48] actually implement alignment options properly --- .../client/render/HexPatternPoints.java | 42 ++++++++----------- .../client/render/PatternSettings.java | 24 +++++++---- .../interop/inline/InlinePatternRenderer.java | 4 +- .../patchouli/AbstractPatternComponent.java | 2 +- .../interop/emi/PatternRendererEMI.java | 2 +- .../forge/interop/jei/PatternDrawable.java | 2 +- 6 files changed, 40 insertions(+), 36 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java index 163cdc0109..1a55d06b5e 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternPoints.java @@ -26,15 +26,10 @@ public class HexPatternPoints { public final double fullHeight; private double minX = Double.MAX_VALUE; - private double maxX = Double.MIN_VALUE; private double minY = Double.MAX_VALUE; - private double maxY = Double.MIN_VALUE; - private double offsetX; - private double offsetY; - - private double baseScale; - private double scale; + private final double offsetX; + private final double offsetY; private static final ConcurrentMap CACHED_STATIC_POINTS = new ConcurrentHashMap<>(); @@ -50,7 +45,8 @@ private HexPatternPoints(HexPatternLike patternlike, PatternSettings patSets, do this.zappyPoints = ImmutableList.copyOf(zappyPoints); -// pointsKey = PatternTextureManager.getPointsKey(zappyPoints); + double maxY = Double.MIN_VALUE; + double maxX = Double.MIN_VALUE; for (Vec2 point : zappyPoints) { minX = Math.min(minX, point.x); maxX = Math.max(maxX, point.x); @@ -60,24 +56,21 @@ private HexPatternPoints(HexPatternLike patternlike, PatternSettings patSets, do rangeX = maxX - minX; rangeY = maxY - minY; - int patStepsX = (int)Math.round(rangeX / 1.5); - int patStepsY = (int)Math.round(rangeY / 1.7); - // scales the patterns so that each point is patSets.baseScale units apart - baseScale = patSets.getBaseScale() / 1.5; + double baseScale = patSets.getBaseScale() / 1.5; // size of the pattern in pose space with no other adjustments double baseWidth = rangeX * baseScale; double baseHeight = rangeY * baseScale; // make sure that the scale fits within our min sizes - scale = Math.max(1.0, Math.max( + double scale = Math.max(1.0, Math.max( (patSets.getMinWidth() - patSets.getStrokeWidthGuess()) / baseWidth, (patSets.getMinHeight() - patSets.getStrokeWidthGuess()) / baseHeight) ); - boolean vertFit = patSets.getVertAlignment() != PatternSettings.AxisAlignment.NONE; - boolean horFit = patSets.getHorAlignment() != PatternSettings.AxisAlignment.NONE; + boolean vertFit = patSets.getVertAlignment().fit; + boolean horFit = patSets.getHorAlignment().fit; // scale down if needed to fit in vertical space if(vertFit){ @@ -92,18 +85,19 @@ private HexPatternPoints(HexPatternLike patternlike, PatternSettings patSets, do finalScale = baseScale * scale; double finalStroke = patSets.getStrokeWidth(finalScale); - // either the space given or however long it goes if it's not fitted. - double fullWidthTmp = (baseWidth * scale) + 2 * patSets.getHorPadding() + finalStroke; - double fullHeightTmp = (baseHeight * scale) + 2 * patSets.getVertPadding() + finalStroke; + double inherentWidth = (baseWidth * scale) + 2 * patSets.getHorPadding() + finalStroke; + double inherentHeight = (baseHeight * scale) + 2 * patSets.getVertPadding() + finalStroke; - if(horFit) fullWidthTmp = Math.max(patSets.getTargetWidth(), fullWidthTmp); - if(vertFit) fullHeightTmp = Math.max(patSets.getTargetHeight(), fullHeightTmp); + // this is the amount of actual wiggle room we have for configurable position-ing. + double widthDiff = Math.max(patSets.getTargetWidth() - inherentWidth, 0); + double heightDiff = Math.max(patSets.getTargetHeight() - inherentHeight, 0); - this.fullWidth = fullWidthTmp; - this.fullHeight = fullHeightTmp; + this.fullWidth = inherentWidth + widthDiff; + this.fullHeight = inherentHeight + heightDiff; - offsetX = (fullWidthTmp - baseWidth * scale) / 2; - offsetY = (fullHeightTmp - baseHeight * scale) / 2; + // center in inherent space and put extra space according to alignment stuff + offsetX = ((inherentWidth - baseWidth * scale) / 2) + (widthDiff * patSets.getHorAlignment().amtInFront / 2); + offsetY = ((inherentHeight - baseHeight * scale) / 2) + (heightDiff * patSets.getVertAlignment().amtInFront / 2); this.zappyPointsScaled = ImmutableList.copyOf(scaleVecs(zappyPoints)); this.dotsScaled = ImmutableList.copyOf(scaleVecs(dots)); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java index 9dcaf4329e..707584c953 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java @@ -28,7 +28,7 @@ public static PositionSettings paddedSquare(double padding){ } public static PositionSettings paddedSquare(double padding, double baseScale, double minSize){ - return new PositionSettings(1.0, 1.0, padding, padding, AxisAlignment.CENTER, AxisAlignment.CENTER, baseScale, minSize, minSize); + return new PositionSettings(1.0, 1.0, padding, padding, AxisAlignment.CENTER_FIT, AxisAlignment.CENTER_FIT, baseScale, minSize, minSize); } } @@ -53,12 +53,22 @@ public String getCacheKey(HexPatternLike patternlike, double seed){ // determines how the pattern is fit and aligned on a given axis public enum AxisAlignment{ - // aligns the pattern if there's extra space. these 3 are the same when the pattern needs to be scaled down to fit - BEGIN, - CENTER, - END, - // NONE ignores target space requirements when fitting on this axis. - NONE + // These 3 scale the pattern down to fit if needed. + BEGIN_FIT(true, 0), + CENTER_FIT(true, 1), + END_FIT(true, 2), + // these 3 do *not* scale the pattern down, it will overflow if needed. + BEGIN(false, 0), + CENTER(false, 1), + END(false, 2); + + public final boolean fit; + public final int amtInFront; // how many halves go in front. yes it's a weird way to do it. + + AxisAlignment(boolean fit, int amtInFront){ + this.fit = fit; + this.amtInFront = amtInFront; + } } private final String name; diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index a0e8efccb8..78d3a3912f 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -16,8 +16,8 @@ public ResourceLocation getId(){ } public static final PatternSettings INLINE_SETTINGS = new PatternSettings("inline", - new PatternSettings.PositionSettings(8.0, 9.0, 0, 0.5, - PatternSettings.AxisAlignment.NONE, PatternSettings.AxisAlignment.CENTER, 4.0, 0, 0), + new PatternSettings.PositionSettings(1.0, 9.0, 0, 0.5, + PatternSettings.AxisAlignment.CENTER, PatternSettings.AxisAlignment.CENTER_FIT, 4.0, 0, 0), PatternSettings.StrokeSettings.fromStroke(1.0), new PatternSettings.ZappySettings(10, 0, 0, 0, PatternSettings.ZappySettings.READABLE_OFFSET, 0.8f) diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java b/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java index dcb19020a5..997bb09411 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java @@ -49,7 +49,7 @@ public void render(GuiGraphics graphics, IComponentRenderContext context, float PatternSettings patSets = new PatternSettings("book" + patterns.size() + (showStrokeOrder() ? "" : "r"), new PatternSettings.PositionSettings(cellW, cellH, 2, 2, - PatternSettings.AxisAlignment.CENTER, PatternSettings.AxisAlignment.CENTER, 16, 0, 0), + PatternSettings.AxisAlignment.CENTER_FIT, PatternSettings.AxisAlignment.CENTER_FIT, 16, 0, 0), PatternSettings.StrokeSettings.fromStroke(4), showStrokeOrder() ? PatternSettings.ZappySettings.READABLE : PatternSettings.ZappySettings.STATIC ); diff --git a/Fabric/src/main/java/at/petrak/hexcasting/fabric/interop/emi/PatternRendererEMI.java b/Fabric/src/main/java/at/petrak/hexcasting/fabric/interop/emi/PatternRendererEMI.java index af23651d27..da699de7a9 100644 --- a/Fabric/src/main/java/at/petrak/hexcasting/fabric/interop/emi/PatternRendererEMI.java +++ b/Fabric/src/main/java/at/petrak/hexcasting/fabric/interop/emi/PatternRendererEMI.java @@ -36,7 +36,7 @@ public PatternRendererEMI(ResourceLocation pattern, int w, int h) { this.height = h; this.patSets = new PatternSettings("pattern_drawable_" + w + "_" + h, new PositionSettings(width, height, 0, 0, - PatternSettings.AxisAlignment.CENTER, PatternSettings.AxisAlignment.CENTER, Math.max(width, height), 0, 0), + PatternSettings.AxisAlignment.CENTER_FIT, PatternSettings.AxisAlignment.CENTER_FIT, Math.max(width, height), 0, 0), StrokeSettings.fromStroke(0.075 * Math.min(width, height)), ZappySettings.READABLE); } diff --git a/Forge/src/main/java/at/petrak/hexcasting/forge/interop/jei/PatternDrawable.java b/Forge/src/main/java/at/petrak/hexcasting/forge/interop/jei/PatternDrawable.java index 38f377fb40..bf96781a00 100644 --- a/Forge/src/main/java/at/petrak/hexcasting/forge/interop/jei/PatternDrawable.java +++ b/Forge/src/main/java/at/petrak/hexcasting/forge/interop/jei/PatternDrawable.java @@ -32,7 +32,7 @@ public PatternDrawable(ResourceLocation pattern, int w, int h) { this.height = h; this.patSets = new PatternSettings("pattern_drawable_" + w + "_" + h, new PositionSettings(width, height, 0, 0, - PatternSettings.AxisAlignment.CENTER, PatternSettings.AxisAlignment.CENTER, Math.max(width, height), 0, 0), + PatternSettings.AxisAlignment.CENTER_FIT, PatternSettings.AxisAlignment.CENTER_FIT, Math.max(width, height), 0, 0), StrokeSettings.fromStroke(0.075 * Math.min(width, height)), ZappySettings.READABLE); } From 179c3d4a2f045a432026d0aa3453c104ff7f0f02 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Tue, 30 Jul 2024 17:50:23 -0400 Subject: [PATCH 39/48] joyous - i think it's done --- .../client/render/HexPatternLike.java | 6 +++ .../client/render/PATTERN_RENDER_LORE.md | 38 +++++++++++++++++-- .../client/render/PatternRenderer.java | 10 +++++ .../client/render/PatternSettings.java | 24 ++++++++++++ 4 files changed, 75 insertions(+), 3 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternLike.java b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternLike.java index 55b33705bb..1b82992398 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternLike.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/HexPatternLike.java @@ -7,6 +7,12 @@ import java.util.Objects; import java.util.Set; +/** + * A simple wrapper around the parts of HexPattern that are actually used for rendering. + * + * This lets the pattern renderer work on arbitrary lists of vecs - this is never used in base hex but is included + * to future-proof and for if addons or something wants to use it. + */ public interface HexPatternLike { List getNonZappyPoints(); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PATTERN_RENDER_LORE.md b/Common/src/main/java/at/petrak/hexcasting/client/render/PATTERN_RENDER_LORE.md index 6fce68ee0b..fdeb3eb6e1 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PATTERN_RENDER_LORE.md +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PATTERN_RENDER_LORE.md @@ -11,10 +11,42 @@ During 1.20 development, we [added texture based rendering](https://github.com/F Now with the new system, all of the rendering is contained to a few classes and outside users (such as slates for example) can specify how they want patterns to be rendered using PatternSettings and PatternColors. -## System Walkthrough +## System Walkthrough (External) ### PatternRenderer -This is the main entrypoint for pattern rendering. It has 2 main methods, both called `renderPattern`. The only difference is that one has a `WorldlyBits` argument used for passing in lighting, vc providers, and normals, that are generally only used for in-world rendering, as opposed to UI rendering. +This is the main entrypoint for pattern rendering. It has 3 main methods, all called `renderPattern`. One is the driver method and the others are convenience wrappers. -Generally the idea here is that you shouldn't need to worry about whether the pattern will be rendered as a texture or dynamically, the `PatternRenderer` will make that decision, prefering the texture renderer when it can. \ No newline at end of file +Generally the idea here is that you shouldn't need to worry about whether the pattern will be rendered as a texture or dynamically, the `PatternRenderer` will make that decision, prefering the texture renderer when it can. The dynamic renderer will be used if the pattern is moving (speed != 0), if the pattern has a gradient stroke, or if the texture isn't ready yet. + +### PatternSettings + +This is where the vast majority of the rendering configuration happens. Arguably it is overkill. + +It's a class with many getters constructed from 3 records: `PositionSettings`, `StrokeSettings`, and `ZappySettings`. The getters can be overridden when/if needed, the records are more for user convenience. See javadocs for details on what can be configured here. + +Pattern textures are also generated based on settings, so it's **VERY ENCOURAGED** to re-use pattern settings when you can. + +### PatternColors + +This is just a simple record holding colors for different parts of pattern drawing. It has probably too many helpers. The main thing to note here is that you can set the alpha to 0 to skip rendering a section (such as dots or innerStroke). Transparent colors for strokes are **discouraged** due to the dynamic renderer having a sort of internal overlapping that is only noticeable with transparent strokes. + +### WorldlyPatternRenderHelpers + +This is where all the worldly base-hex renders ended up. Good to look at for examples of using the renderer and some pattern settings that could be re-used. + +## System Walkthrough (Internal) + +### HexPatternPoints + +This is where the positioning actually happens. It generates dots and zappy points based on the pattern and PatternSettings passed in. This object is then cached to prevent needing to calculate it all each frame. Note that this includes scaling and all that, the returned zappy points are in pose units. + +### VCDrawHelper (& RenderLib changes) + +We do a silly with this one lol. This allows us to separate the lower level vertex handling from the higher level 'drawing'. + +Previously `RenderLib.drawLineSeq(..)` drew straight to the tesselator with the `POSITION_COLOR` shader/format. Now it just passes color and position data to the `VCDrawHelper` that we give it, allowing us to create and push a vertex however we want to wherever we want. This lets us draw to other vertex consumers and use other shaders/formats, like the `EntityTranslucentCull` that we use for worldly rendering with light and normals. + +To maintain API stability we have the previous `RenderLib.drawLineSeq(..)` method signature just call the new version using the `Basic` draw helper. + +Conveniently we can also use this for drawing our textures! \ No newline at end of file diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java index 0255eeaf04..8fd307a9a4 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternRenderer.java @@ -29,6 +29,16 @@ public static void renderPattern(HexPattern pattern, PoseStack ps, @Nullable Wor renderPattern(HexPatternLike.of(pattern), ps, worldlyBits, patSets, patColors, seed, resPerUnit); } + /** + * Renders a pattern (or rather a pattern-like) according to the given settings. + * @param patternlike the pattern (or more generally the lines) to render. + * @param ps pose/matrix stack to render based on. (0,0) is treated as the top left corner. The size of the render is determined by patSets. + * @param worldlyBits used for rendering with light/normals/render-layers if possible. This is optional and probably shouldn't be used for UI rendering. + * @param patSets settings that control how the pattern is drawn. + * @param patColors colors to use for drawing the pattern and dots. + * @param seed seed to use for zappy wobbles. + * @param resPerUnit the texture resolution per pose unit space to be used *if* the texture renderer is used. + */ public static void renderPattern(HexPatternLike patternlike, PoseStack ps, @Nullable WorldlyBits worldlyBits, PatternSettings patSets, PatternColors patColors, double seed, int resPerUnit){ var oldShader = RenderSystem.getShader(); HexPatternPoints staticPoints = HexPatternPoints.getStaticPoints(patternlike, patSets, seed); diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java index 707584c953..4cb223f6f6 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/PatternSettings.java @@ -15,6 +15,16 @@ public PatternSettings(String name, PositionSettings posSets, StrokeSettings str this.zapSets = zapSets; } + /** + * Settings for positioning the pattern and defining its general size/render area. All values are in 'pose units', + * meaning we use them directly with the pose/matrix stack given to the renderer. + * + *

+ * We do a first pass at the pattern scale using baseScale. We then make sure it's larger than minWidth and + * minHeight. Then on each axis, if that axis is has a FIT alignment then we may scale down the pattern to make sure it + * fits. Note that the padding is not scaled and is always respected. + *

+ */ public record PositionSettings(double spaceWidth, double spaceHeight, double hPadding, double vPadding, AxisAlignment hAxis, AxisAlignment vAxis, double baseScale, double minWidth, double minHeight){ /** @@ -32,6 +42,10 @@ public static PositionSettings paddedSquare(double padding, double baseScale, do } } + /** + * Settings for stroke and dot sizings. If you want to *not* render dots or inner/outer you should prefer setting + * alpha to 0 in PatternColors. + */ public record StrokeSettings(double innerWidth, double outerWidth, double startDotRadius, double gridDotsRadius){ public static StrokeSettings fromStroke(double stroke){ @@ -39,6 +53,16 @@ public static StrokeSettings fromStroke(double stroke){ } } + /** + * Controls how the pattern is zappified. + * + * @param hops number of little pulses + * @param variance how jumpy/distorting the pulses are + * @param speed how fast the pulses go + * @param flowIrregular randomness of pulse travel + * @param readabilityOffset how curved inward the corners are + * @param lastSegmentLenProportion length of the last segment relative to the others. used for increased readability. + */ public record ZappySettings(int hops, float variance, float speed, float flowIrregular, float readabilityOffset, float lastSegmentLenProportion){ public static float READABLE_OFFSET = 0.2f; public static float READABLE_SEGMENT = 0.8f; From 5817f80163279bab132ba9323b2dc28afed6028e Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Wed, 31 Jul 2024 20:48:24 -0400 Subject: [PATCH 40/48] add inline pattern matcher lang --- .../assets/hexcasting/lang/en_us.flatten.json5 | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/Common/src/main/resources/assets/hexcasting/lang/en_us.flatten.json5 b/Common/src/main/resources/assets/hexcasting/lang/en_us.flatten.json5 index 2047c39c47..b3eb1308fc 100644 --- a/Common/src/main/resources/assets/hexcasting/lang/en_us.flatten.json5 +++ b/Common/src/main/resources/assets/hexcasting/lang/en_us.flatten.json5 @@ -427,7 +427,15 @@ "fail.already": "%s is already empty", }, }, - + + // === Inline ! === + "matcher.hexcasting.pattern": { + "title": "Hex Pattern", + "title.styled": "Hex Pattern ", + "description": "Visual Hex Casting Patterns", + "example": "" + }, + hexcasting: { "pattern.unknown": "Unknown pattern resource location %s", From fa3d126483660a8d577382fe7f79ba99ff30be4d Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Wed, 31 Jul 2024 20:50:42 -0400 Subject: [PATCH 41/48] make inline patterns not have shortened end bit - personal choice, up for debate --- .../petrak/hexcasting/interop/inline/InlinePatternRenderer.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index 78d3a3912f..3d8d5feef8 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -20,7 +20,7 @@ public ResourceLocation getId(){ PatternSettings.AxisAlignment.CENTER, PatternSettings.AxisAlignment.CENTER_FIT, 4.0, 0, 0), PatternSettings.StrokeSettings.fromStroke(1.0), new PatternSettings.ZappySettings(10, 0, 0, 0, - PatternSettings.ZappySettings.READABLE_OFFSET, 0.8f) + PatternSettings.ZappySettings.READABLE_OFFSET, 1f) ){ @Override public double getOuterWidth(double scale){ From 005b91e153065b67caa1bc4deb7f2766af0af24a Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Sat, 28 Sep 2024 20:38:12 -0400 Subject: [PATCH 42/48] update to inline 1.0.0 --- .../interop/inline/HexPatternMatcher.java | 13 ++++++++----- .../interop/inline/InlinePatternRenderer.java | 11 ++--------- gradle.properties | 2 +- 3 files changed, 11 insertions(+), 15 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java index 8d02c0c583..b0dc5804ea 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java @@ -3,9 +3,10 @@ import at.petrak.hexcasting.api.HexAPI; import at.petrak.hexcasting.api.casting.math.HexDir; import at.petrak.hexcasting.api.casting.math.HexPattern; -import com.samsthenerd.inline.api.client.InlineMatch; -import com.samsthenerd.inline.api.client.MatcherInfo; -import com.samsthenerd.inline.api.client.matchers.RegexMatcher; +import com.samsthenerd.inline.api.matching.InlineMatch; +import com.samsthenerd.inline.api.matching.MatchContext; +import com.samsthenerd.inline.api.matching.MatcherInfo; +import com.samsthenerd.inline.api.matching.RegexMatcher; import net.minecraft.network.chat.Component; import net.minecraft.resources.ResourceLocation; import net.minecraft.util.Tuple; @@ -31,8 +32,9 @@ public Pattern getRegex(){ return PATTERN_PATTERN_REGEX; } + @Override @NotNull - public Tuple getMatchAndGroup(MatchResult regexMatch) { + public Tuple getMatchAndGroup(MatchResult regexMatch, MatchContext ctx) { String escaped = regexMatch.group(1); String dirString = regexMatch.group(2).toLowerCase().strip().replace("_", ""); String angleSigs = regexMatch.group(3); @@ -54,8 +56,9 @@ public Tuple getMatchAndGroup(MatchResult regexMatch) { } // not really used since we're doing escaping + @Override @Nullable - public InlineMatch getMatch(MatchResult mr){ + public InlineMatch getMatch(MatchResult mr, MatchContext ctx){ return null; // nop } diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index 3d8d5feef8..45912862d6 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -5,7 +5,6 @@ import net.minecraft.client.gui.GuiGraphics; import net.minecraft.network.chat.Style; import net.minecraft.resources.ResourceLocation; -import net.minecraft.util.FastColor; public class InlinePatternRenderer implements InlineRenderer { @@ -36,14 +35,8 @@ public double getOuterWidth(double scale){ public int render(InlinePatternData data, GuiGraphics drawContext, int index, Style style, int codepoint, TextRenderingContext trContext){ drawContext.pose().pushPose(); drawContext.pose().translate(0f, -0.5f, 0f); - int trColor = FastColor.ARGB32.color((int)(255*trContext.alpha), (int)(255*trContext.red), - (int)(255*trContext.green), (int)(255*trContext.blue)); - int color = style.getColor() == null ? trColor : style.getColor().getValue(); - // some places (like tooltips) give an alpha of 0, but we don't want to kill the alpha value entirely. - if(FastColor.ARGB32.alpha(color) == 0){ - color |= 0xFF_000000; - } - PatternRenderer.renderPattern(data.pattern, drawContext.pose(), new PatternRenderer.WorldlyBits(trContext.vertexConsumers, trContext.light, null), + int color = trContext.usableColor(); + PatternRenderer.renderPattern(data.pattern, drawContext.pose(), new PatternRenderer.WorldlyBits(drawContext.bufferSource(), trContext.light(), null), INLINE_SETTINGS, PatternColors.singleStroke(color), 0, INLINE_TEXTURE_RES); drawContext.pose().popPose(); diff --git a/gradle.properties b/gradle.properties index b418b53c8e..c03207cc77 100644 --- a/gradle.properties +++ b/gradle.properties @@ -18,5 +18,5 @@ patchouliVersion=83 jeiVersion=15.0.0.12 pehkuiVersion=3.7.7 -inlineVersion=0.0.1 +inlineVersion=1.0.0 clothConfigVersion=11.1.106 \ No newline at end of file From e7c3e8f86f2a63131b708bf66656fc1094ad169f Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Sat, 28 Sep 2024 21:08:58 -0400 Subject: [PATCH 43/48] fix scroll normals --- .../hexcasting/client/render/WorldlyPatternRenderHelpers.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java index 345a61618b..68c00d5d92 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/render/WorldlyPatternRenderHelpers.java @@ -14,6 +14,7 @@ import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.block.state.properties.AttachFace; import net.minecraft.world.phys.Vec3; +import org.joml.Matrix3f; import javax.annotation.Nullable; @@ -48,9 +49,10 @@ public class WorldlyPatternRenderHelpers { public static void renderPatternForScroll(HexPattern pattern, EntityWallScroll scroll, PoseStack ps, MultiBufferSource bufSource, int light, int blockSize, boolean showStrokeOrder) { - // TODO: I think scroll normals are maybe slightly messed up or something?? idk, look into that maybe ps.pushPose(); ps.translate(-blockSize / 2f, -blockSize / 2f, 1f / 32f); + // there's almost certainly a better way to do this, but we're just flipping the y and z axes to fix normals + ps.last().normal().mul(new Matrix3f(1, 0, 0, 0, 0, 1, 0, 1, 0)); renderPattern(pattern, showStrokeOrder ? READABLE_SCROLL_SETTINGS : SCROLL_SETTINGS, showStrokeOrder ? PatternColors.READABLE_SCROLL_COLORS : PatternColors.DEFAULT_PATTERN_COLOR, scroll.getPos().hashCode(), ps, bufSource, null, null, light, blockSize); From 0b284d773a97c2e84eb50355ca668935f67862d3 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Sat, 28 Sep 2024 23:17:43 -0400 Subject: [PATCH 44/48] make inline patterns glow nice on signs --- .../interop/inline/InlinePatternRenderer.java | 33 +++++++++++++++++-- 1 file changed, 30 insertions(+), 3 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java index 45912862d6..eb7b798487 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternRenderer.java @@ -1,7 +1,9 @@ package at.petrak.hexcasting.interop.inline; import at.petrak.hexcasting.client.render.*; +import com.samsthenerd.inline.api.client.GlowHandling; import com.samsthenerd.inline.api.client.InlineRenderer; +import com.samsthenerd.inline.impl.InlineStyle; import net.minecraft.client.gui.GuiGraphics; import net.minecraft.network.chat.Style; import net.minecraft.resources.ResourceLocation; @@ -19,7 +21,7 @@ public ResourceLocation getId(){ PatternSettings.AxisAlignment.CENTER, PatternSettings.AxisAlignment.CENTER_FIT, 4.0, 0, 0), PatternSettings.StrokeSettings.fromStroke(1.0), new PatternSettings.ZappySettings(10, 0, 0, 0, - PatternSettings.ZappySettings.READABLE_OFFSET, 1f) + PatternSettings.ZappySettings.READABLE_OFFSET, 0.7f) ){ @Override public double getOuterWidth(double scale){ @@ -30,14 +32,39 @@ public double getOuterWidth(double scale){ } }; + public static final PatternSettings INLINE_SETTINGS_GLOWY = new PatternSettings("inlineglowy", + new PatternSettings.PositionSettings(1.0, 11.0, 0, 0.5, + PatternSettings.AxisAlignment.CENTER, PatternSettings.AxisAlignment.CENTER_FIT, 4.0, 0, 0), + new PatternSettings.StrokeSettings(1, 3, 0.8 * 1 * 2.0 / 5.0, 0.4 * 1 * 2.0 / 5.0), + INLINE_SETTINGS.zapSets + ){ + @Override + public double getInnerWidth(double scale){ + if(scale >= 1) return 1; + if(scale >= 0.75) return 0.75; + if(scale >= 0.5) return 0.5; + return 0.25; + } + }; + + @Override + public GlowHandling getGlowPreference(InlinePatternData forData) { + return new GlowHandling.None(); + } + public static final int INLINE_TEXTURE_RES = 16; // 128px so it looks good and pretty on up close signs and whatnot public int render(InlinePatternData data, GuiGraphics drawContext, int index, Style style, int codepoint, TextRenderingContext trContext){ + if(trContext.isGlowy()) return charWidth(data, style, codepoint); + int glowyParentColor = ((InlineStyle) style).getComponent(InlineStyle.GLOWY_PARENT_COMP); + boolean isGlowy = glowyParentColor != -1; drawContext.pose().pushPose(); - drawContext.pose().translate(0f, -0.5f, 0f); + drawContext.pose().translate(isGlowy ? -1f : 0, isGlowy ? -1.5f : -0.5f, 0f); int color = trContext.usableColor(); PatternRenderer.renderPattern(data.pattern, drawContext.pose(), new PatternRenderer.WorldlyBits(drawContext.bufferSource(), trContext.light(), null), - INLINE_SETTINGS, PatternColors.singleStroke(color), 0, INLINE_TEXTURE_RES); + isGlowy ? INLINE_SETTINGS_GLOWY : INLINE_SETTINGS, + isGlowy ? new PatternColors(color, 0xFF_000000 | glowyParentColor) : PatternColors.singleStroke(color), + 0, INLINE_TEXTURE_RES); drawContext.pose().popPose(); return charWidth(data, style, codepoint); From 26bf80a5b77950050868cb348e50e6ad072118aa Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Sun, 29 Sep 2024 02:11:40 -0400 Subject: [PATCH 45/48] make pattern renders size-changable --- .../interop/inline/HexPatternMatcher.java | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java index b0dc5804ea..8b9492c1b7 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/HexPatternMatcher.java @@ -3,11 +3,13 @@ import at.petrak.hexcasting.api.HexAPI; import at.petrak.hexcasting.api.casting.math.HexDir; import at.petrak.hexcasting.api.casting.math.HexPattern; +import com.samsthenerd.inline.api.InlineAPI; import com.samsthenerd.inline.api.matching.InlineMatch; import com.samsthenerd.inline.api.matching.MatchContext; import com.samsthenerd.inline.api.matching.MatcherInfo; import com.samsthenerd.inline.api.matching.RegexMatcher; import net.minecraft.network.chat.Component; +import net.minecraft.network.chat.Style; import net.minecraft.resources.ResourceLocation; import net.minecraft.util.Tuple; import org.jetbrains.annotations.NotNull; @@ -24,7 +26,7 @@ public class HexPatternMatcher implements RegexMatcher { private static final MatcherInfo patternMatcherInfo = MatcherInfo.fromId(patternMatcherID); // thx kyra <3 - private static final Pattern PATTERN_PATTERN_REGEX = Pattern.compile("(?\\\\?)(?:HexPattern)?[<(\\[{]\\s*(?[a-z_-]+)(?:\\s*[, ]\\s*(?[aqweds]+))?\\s*[>)\\]}]", Pattern.CASE_INSENSITIVE); + private static final Pattern PATTERN_PATTERN_REGEX = Pattern.compile("(?\\\\?)(?:HexPattern)?[<(\\[{]\\s*(?[a-z_-]+)(?:\\s*(?[,!+:; ])\\s*(?[aqweds]+))?\\s*[>)\\]}]", Pattern.CASE_INSENSITIVE); public static HexPatternMatcher INSTANCE = new HexPatternMatcher(); @@ -37,7 +39,8 @@ public Pattern getRegex(){ public Tuple getMatchAndGroup(MatchResult regexMatch, MatchContext ctx) { String escaped = regexMatch.group(1); String dirString = regexMatch.group(2).toLowerCase().strip().replace("_", ""); - String angleSigs = regexMatch.group(3); + String sizeModString = regexMatch.group(3); + String angleSigs = regexMatch.group(4); if(escaped == null){ return new Tuple<>(new InlineMatch.TextMatch(Component.literal("")), 1); } @@ -49,7 +52,12 @@ public Tuple getMatchAndGroup(MatchResult regexMatch, Matc try{ pat = HexPattern.fromAngles(angleSigs, dir); InlinePatternData patData = new InlinePatternData(pat); - return new Tuple<>(new InlineMatch.DataMatch(patData, patData.getExtraStyle()), 0); + Style patDataStyle = patData.getExtraStyle(); + if(sizeModString.equals("+")) + patDataStyle = InlineAPI.INSTANCE.withSizeModifier(patDataStyle, 2); + if(sizeModString.equals("!")) + patDataStyle = InlineAPI.INSTANCE.withSizeModifier(patDataStyle, 1.5); + return new Tuple<>(new InlineMatch.DataMatch(patData,patDataStyle ), 0); } catch (Exception e){ return new Tuple<>(null, 0); } From 9d3d4f552f906e6a02742ac079ba79ccba670c98 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Sun, 29 Sep 2024 02:28:17 -0400 Subject: [PATCH 46/48] give pattern inlines click events again --- .../petrak/hexcasting/interop/inline/InlinePatternData.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java index 1fa3fc735d..5dc2dba2ff 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/inline/InlinePatternData.java @@ -9,6 +9,7 @@ import com.mojang.serialization.Codec; import com.samsthenerd.inline.api.InlineData; import net.minecraft.ChatFormatting; +import net.minecraft.network.chat.ClickEvent; import net.minecraft.network.chat.Component; import net.minecraft.network.chat.HoverEvent; import net.minecraft.network.chat.Style; @@ -43,8 +44,8 @@ public Style getExtraStyle() { HexItems.SCROLL_MEDIUM.writeDatum(scrollStack, new PatternIota(pattern)); scrollStack.setHoverName(getPatternName(pattern).copy().withStyle(ChatFormatting.WHITE)); HoverEvent he = new HoverEvent(HoverEvent.Action.SHOW_ITEM, new HoverEvent.ItemStackInfo(scrollStack)); - // TODO: add copy click event - return Style.EMPTY.withHoverEvent(he); + ClickEvent ce = new ClickEvent(ClickEvent.Action.COPY_TO_CLIPBOARD, pattern.toString()); + return Style.EMPTY.withHoverEvent(he).withClickEvent(ce); } public static Component getPatternName(HexPattern pattern){ From 8c00eeb24f5bb520358ac08cb9101e82f8462524 Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Sun, 29 Sep 2024 02:30:19 -0400 Subject: [PATCH 47/48] bleh inline broken again, gotta go fix that --- .../api/casting/iota/EntityIota.java | 20 +++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/EntityIota.java b/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/EntityIota.java index abefacc4af..a8c883647e 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/EntityIota.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/EntityIota.java @@ -2,6 +2,8 @@ import at.petrak.hexcasting.api.utils.HexUtils; import at.petrak.hexcasting.common.lib.hex.HexIotaTypes; +import com.samsthenerd.inline.api.data.EntityInlineData; +import com.samsthenerd.inline.api.data.PlayerHeadData; import net.minecraft.ChatFormatting; import net.minecraft.nbt.CompoundTag; import net.minecraft.nbt.NbtUtils; @@ -51,17 +53,19 @@ public Component display() { private Component getEntityNameWithInline(boolean fearSerializer){ MutableComponent baseName = this.getEntity().getName().copy(); - // TODO: Inline is a bit broken, serialization doesn't seem to actually work so we have placeholder raw text for now Component inlineEnt = null; if(this.getEntity() instanceof Player player){ -// inlineEnt = new PlayerHeadData(player.getGameProfile()).asText(!fearSerializer); - inlineEnt = Component.literal("[face:" + player.getGameProfile().getName() + "]"); + inlineEnt = new PlayerHeadData(player.getGameProfile()).asText(!fearSerializer); +// inlineEnt = Component.literal("[face:" + player.getGameProfile().getName() + "]"); } else{ -// if(fearSerializer){ // we don't want to have to serialize an entity just to display it -// inlineEnt = EntityInlineData.fromType(this.getEntity().getType()).asText(!fearSerializer); -// } else { -// inlineEnt = EntityInlineData.fromEntity(this.getEntity()).asText(!fearSerializer); -// } + if(fearSerializer){ // we don't want to have to serialize an entity just to display it + inlineEnt = EntityInlineData.fromType(this.getEntity().getType()).asText(!fearSerializer); + } else { +// CompoundTag tag = new CompoundTag(); +// this.getEntity().save(tag); +// inlineEnt = EntityInlineData.fromNbt(tag).asText(!fearSerializer); + inlineEnt = EntityInlineData.fromEntity(this.getEntity()).asText(!fearSerializer); + } // inlineEnt = Component.literal("[entity:" + EntityType.getKey(this.getEntity().getType()).toString() + "]"); } if(inlineEnt != null){ From d7814e5ad75fc9b44f475d7ae1213dd0418680af Mon Sep 17 00:00:00 2001 From: SamsTheNerd Date: Sun, 29 Sep 2024 03:23:05 -0400 Subject: [PATCH 48/48] update to inline 1.0.1 and add player/entity renders on entity iotas --- .../hexcasting/api/casting/iota/EntityIota.java | 12 +++--------- gradle.properties | 2 +- 2 files changed, 4 insertions(+), 10 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/EntityIota.java b/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/EntityIota.java index a8c883647e..2a8023cf01 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/EntityIota.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/casting/iota/EntityIota.java @@ -2,6 +2,7 @@ import at.petrak.hexcasting.api.utils.HexUtils; import at.petrak.hexcasting.common.lib.hex.HexIotaTypes; +import com.samsthenerd.inline.api.InlineAPI; import com.samsthenerd.inline.api.data.EntityInlineData; import com.samsthenerd.inline.api.data.PlayerHeadData; import net.minecraft.ChatFormatting; @@ -56,22 +57,15 @@ private Component getEntityNameWithInline(boolean fearSerializer){ Component inlineEnt = null; if(this.getEntity() instanceof Player player){ inlineEnt = new PlayerHeadData(player.getGameProfile()).asText(!fearSerializer); -// inlineEnt = Component.literal("[face:" + player.getGameProfile().getName() + "]"); + inlineEnt = inlineEnt.plainCopy().withStyle(InlineAPI.INSTANCE.withSizeModifier(inlineEnt.getStyle(), 1.5)); } else{ if(fearSerializer){ // we don't want to have to serialize an entity just to display it inlineEnt = EntityInlineData.fromType(this.getEntity().getType()).asText(!fearSerializer); } else { -// CompoundTag tag = new CompoundTag(); -// this.getEntity().save(tag); -// inlineEnt = EntityInlineData.fromNbt(tag).asText(!fearSerializer); inlineEnt = EntityInlineData.fromEntity(this.getEntity()).asText(!fearSerializer); } -// inlineEnt = Component.literal("[entity:" + EntityType.getKey(this.getEntity().getType()).toString() + "]"); } - if(inlineEnt != null){ - baseName.append(Component.literal(": ")).append(inlineEnt); - } - return baseName; + return baseName.append(Component.literal(": ")).append(inlineEnt); } public static IotaType TYPE = new IotaType<>() { diff --git a/gradle.properties b/gradle.properties index c03207cc77..015fb53ab5 100644 --- a/gradle.properties +++ b/gradle.properties @@ -18,5 +18,5 @@ patchouliVersion=83 jeiVersion=15.0.0.12 pehkuiVersion=3.7.7 -inlineVersion=1.0.0 +inlineVersion=1.0.1 clothConfigVersion=11.1.106 \ No newline at end of file