Completed new placement renderer. Closes #36.

robotgryphon · robotgryphon · commit 1a3686eb383a · 2021-11-24T02:43:47.000-05:00
diff --git a/src/main/java/dev/compactmods/crafting/client/ClientConfig.java b/src/main/java/dev/compactmods/crafting/client/ClientConfig.java
@@ -14,11 +14,13 @@ public class ClientConfig {
 
     private static ForgeConfigSpec.ConfigValue<String> PROJECTOR_COLOR;
     private static ForgeConfigSpec.ConfigValue<String> PROJECTOR_OFF_COLOR;
+    private static ForgeConfigSpec.IntValue PLACEMENT_TIME;
 
     public static ForgeConfigSpec.BooleanValue ENABLE_DEBUG_ON_F3;
 
     public static int projectorColor = 0xFFFFFFFF;
     public static int projectorOffColor = 0xFFFFFFFF;
+    public static int placementTime = 60;
 
     static {
         generateConfig();
@@ -50,6 +52,10 @@ private static void generateConfig() {
                 .comment("Whether or not activating F3 will enable debug renderers.")
                 .define("projectorDebugger", false);
 
+        PLACEMENT_TIME = builder
+                .comment("How long (ticks) the placement helper will show on right-clicking a projector.")
+                .defineInRange("placementTime", 160, 60, 240);
+
         builder.pop();
 
         CONFIG = builder.build();
@@ -59,6 +65,7 @@ private static void generateConfig() {
     public static void onLoad(final ModConfig.ModConfigEvent configEvent) {
         projectorColor = extractHexColor(PROJECTOR_COLOR.get(), 0x00FF6A00);
         projectorOffColor = extractHexColor(PROJECTOR_OFF_COLOR.get(), 0x00898989);
+        placementTime = PLACEMENT_TIME.get();
     }
 
     private static int extractHexColor(String hex, int def) {
diff --git a/src/main/java/dev/compactmods/crafting/client/ClientEventHandler.java b/src/main/java/dev/compactmods/crafting/client/ClientEventHandler.java
@@ -86,5 +86,7 @@ public static void onWorldRender(final RenderWorldLastEvent event) {
                                 stack.popPose();
                             });
                 });
+
+        buffers.endBatch();
     }
 }
diff --git a/src/main/java/dev/compactmods/crafting/client/render/ClientProjectorRenderInfo.java b/src/main/java/dev/compactmods/crafting/client/render/ClientProjectorRenderInfo.java
@@ -1,16 +1,22 @@
 package dev.compactmods.crafting.client.render;
 
+import java.util.HashMap;
+import java.util.Optional;
 import java.util.Set;
-import java.util.stream.Collectors;
 import com.mojang.blaze3d.matrix.MatrixStack;
 import dev.compactmods.crafting.Registration;
+import dev.compactmods.crafting.api.field.MiniaturizationFieldSize;
 import dev.compactmods.crafting.capability.IProjectorRenderInfo;
+import dev.compactmods.crafting.client.ClientConfig;
 import dev.compactmods.crafting.projector.FieldProjectorBlock;
 import dev.compactmods.crafting.projector.ProjectorHelper;
+import net.minecraft.block.AbstractBlock;
 import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.ActiveRenderInfo;
 import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.world.ClientWorld;
 import net.minecraft.util.Direction;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.vector.Vector3d;
@@ -19,17 +25,18 @@
 public class ClientProjectorRenderInfo implements IProjectorRenderInfo {
 
     private final BlockState baseState;
-    private Set<BlockPos> remainingProjectors;
+    private final HashMap<BlockPos, Direction> remainingProjectors;
     private int renderTime;
 
 
     public ClientProjectorRenderInfo() {
+        this.remainingProjectors = new HashMap<>(4);
         this.baseState = Registration.FIELD_PROJECTOR_BLOCK.get().defaultBlockState();
     }
 
     @Override
     public Set<BlockPos> getMissingProjectors() {
-        return remainingProjectors;
+        return remainingProjectors.keySet();
     }
 
     @Override
@@ -39,48 +46,82 @@ public int getRenderTimeLeft() {
 
     @Override
     public void render(MatrixStack matrixStack) {
-        if(this.renderTime == 0) return;
-        if(this.remainingProjectors.isEmpty()) return;
+        if (this.renderTime == 0) return;
+        if (this.remainingProjectors.isEmpty()) return;
 
-        final IRenderTypeBuffer.Impl buffers = Minecraft.getInstance().renderBuffers().bufferSource();
-        final ActiveRenderInfo mainCamera = Minecraft.getInstance().gameRenderer.getMainCamera();
+        final Minecraft mc = Minecraft.getInstance();
+        final IRenderTypeBuffer.Impl buffers = mc.renderBuffers().bufferSource();
+        final ActiveRenderInfo mainCamera = mc.gameRenderer.getMainCamera();
+        final ClientWorld level = mc.level;
 
         matrixStack.pushPose();
         Vector3d projectedView = mainCamera.getPosition();
         matrixStack.translate(-projectedView.x, -projectedView.y, -projectedView.z);
 
-        remainingProjectors.forEach(pos -> {
+        remainingProjectors.forEach((pos, dir) -> {
             matrixStack.pushPose();
             matrixStack.translate(
-                    (double) pos.getX(),
-                    (double) pos.getY(),
-                    (double) pos.getZ()
+                    (double) pos.getX() + 0.05,
+                    (double) pos.getY() + 0.05,
+                    (double) pos.getZ() + 0.05
             );
 
-            GhostRenderer.renderTransparentBlock(baseState,  matrixStack, buffers);
+            matrixStack.scale(0.9f, 0.9f, 0.9f);
+
+            GhostRenderer.renderTransparentBlock(baseState.setValue(FieldProjectorBlock.FACING, dir), pos, matrixStack, buffers, renderTime);
             matrixStack.popPose();
+
+            for (int y = -1; y > -10; y--) {
+                BlockPos realPos = new BlockPos(pos.getX(), pos.getY() + y, pos.getZ());
+                if(!level.isStateAtPosition(realPos, AbstractBlock.AbstractBlockState::isAir))
+                    break;
+
+                matrixStack.pushPose();
+                matrixStack.translate(
+                        (double) pos.getX() + 0.15,
+                        (double) pos.getY() + 0.15 + y,
+                        (double) pos.getZ() + 0.15
+                );
+
+                matrixStack.scale(0.6f, 0.6f, 0.6f);
+                GhostRenderer.renderTransparentBlock(Blocks.BLACK_STAINED_GLASS.defaultBlockState(), null, matrixStack, buffers, renderTime);
+                matrixStack.popPose();
+            }
         });
 
         matrixStack.popPose();
+        buffers.endBatch();
     }
 
     @Override
     public void tick() {
-        if(renderTime > 0)
-            this.renderTime--;
-        if(renderTime < 0)
-            this.renderTime = 0;
+        if (renderTime > 0) this.renderTime--;
+        if (renderTime < 0) this.renderTime = 0;
     }
 
     @Override
     public void resetRenderTime() {
-        this.renderTime = 20 * 10;
+        this.renderTime = ClientConfig.placementTime;
     }
 
     @Override
     public void setProjector(World level, BlockPos initial) {
-        this.remainingProjectors = ProjectorHelper.getMissingProjectors(level, initial,
-                        FieldProjectorBlock.getDirection(level, initial).orElse(Direction.UP))
-                .collect(Collectors.toSet());
+        remainingProjectors.clear();
+
+        Optional<MiniaturizationFieldSize> fieldSize = ProjectorHelper.getClosestOppositeSize(level, initial);
+        final Direction initialFacing = FieldProjectorBlock.getDirection(level, initial).orElse(Direction.UP);
+        if(fieldSize.isPresent()) {
+            final BlockPos center = fieldSize.get().getCenterFromProjector(initial, initialFacing);
+            Direction.Plane.HORIZONTAL.stream()
+                    .forEach(dir -> {
+                        if(dir == initialFacing) return;
+                        
+                        final BlockPos location = fieldSize.get().getProjectorLocationForDirection(center, dir);
+                        remainingProjectors.put(location, dir.getOpposite());
+                    });
+        } else {
+            ProjectorHelper.getValidOppositePositions(initial, initialFacing)
+                    .forEach(pos -> this.remainingProjectors.put(pos, initialFacing.getOpposite()));
+        }
     }
 }
diff --git a/src/main/java/dev/compactmods/crafting/client/render/GhostRenderer.java b/src/main/java/dev/compactmods/crafting/client/render/GhostRenderer.java
@@ -1,30 +1,61 @@
 package dev.compactmods.crafting.client.render;
 
-import java.util.Arrays;
+import javax.annotation.Nullable;
 import java.util.Random;
 import com.mojang.blaze3d.matrix.MatrixStack;
 import com.mojang.blaze3d.vertex.IVertexBuilder;
 import net.minecraft.block.BlockState;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.IRenderTypeBuffer;
 import net.minecraft.client.renderer.LightTexture;
+import net.minecraft.client.renderer.color.BlockColors;
+import net.minecraft.client.renderer.model.BakedQuad;
 import net.minecraft.client.renderer.model.IBakedModel;
 import net.minecraft.client.renderer.texture.OverlayTexture;
+import net.minecraft.util.ColorHelper;
 import net.minecraft.util.Direction;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.MathHelper;
 import net.minecraftforge.client.model.data.EmptyModelData;
 
 public class GhostRenderer {
-    public static void renderTransparentBlock(BlockState state, MatrixStack matrix, IRenderTypeBuffer buffer) {
+    public static void renderTransparentBlock(BlockState state, @Nullable BlockPos pos, MatrixStack matrix, IRenderTypeBuffer buffer) {
+        renderTransparentBlock(state, pos, matrix, buffer, 100);
+    }
+
+    public static void renderTransparentBlock(BlockState state, @Nullable BlockPos pos, MatrixStack matrix, IRenderTypeBuffer buffer, int ticksLeft) {
+        final Minecraft mc = Minecraft.getInstance();
+        final BlockColors colors = mc.getBlockColors();
+
+        // clamp b/n 0-100, effective range 0 - 0.9f
+        final float alpha = ticksLeft >= 100 ? 0.9f : 0.9f * Math.max(ticksLeft / 100f, .1f);
+
         IVertexBuilder builder = buffer.getBuffer(CCRenderTypes.PHANTOM);
-        matrix.translate(0.1F, 0.1F, 0.1F);
-        matrix.scale(0.8F, 0.8F, 0.8F);
-        IBakedModel model = Minecraft.getInstance().getBlockRenderer().getBlockModel(state.getBlockState());
-        if(model != Minecraft.getInstance().getModelManager().getMissingModel()) {
-            Arrays.stream(Direction.values())
-                    .flatMap(direction -> model.getQuads(state.getBlockState(), direction, new Random(42L), EmptyModelData.INSTANCE).stream())
-                    .forEach(quad -> builder.addVertexData(matrix.last(), quad, 1.0F, 1.0F, 1.0F, 0.8F, LightTexture.pack(15, 15), OverlayTexture.NO_OVERLAY));
+        IBakedModel model = mc.getBlockRenderer().getBlockModel(state.getBlockState());
+        if (model != mc.getModelManager().getMissingModel()) {
+            for(Direction dir : Direction.values())
+                model.getQuads(state.getBlockState(), dir, new Random(42L), EmptyModelData.INSTANCE)
+                        .forEach(quad -> addQuad(state, pos, matrix, mc, colors, builder, quad, alpha));
+
             model.getQuads(state.getBlockState(), null, new Random(42L), EmptyModelData.INSTANCE)
-                    .forEach(quad -> builder.addVertexData(matrix.last(), quad, 1.0F, 1.0F, 1.0F, 0.8F, LightTexture.pack(15, 15), OverlayTexture.NO_OVERLAY));
+                    .forEach(quad -> addQuad(state, pos, matrix, mc, colors, builder, quad, alpha));
         }
     }
+
+    private static void addQuad(BlockState state, @Nullable BlockPos pos, MatrixStack matrix, Minecraft mc, BlockColors colors, IVertexBuilder builder, BakedQuad quad, float alpha) {
+        int color = quad.isTinted() ? colors.getColor(state, mc.level, pos, quad.getTintIndex()) :
+                ColorHelper.PackedColor.color(255, 255, 255, 255);
+
+        final float red = ColorHelper.PackedColor.red(color) / 255f;
+        final float green = ColorHelper.PackedColor.green(color) / 255f;
+        final float blue = ColorHelper.PackedColor.blue(color) / 255f;
+
+        final float trueAlpha = MathHelper.clamp(0.01f, alpha, 0.06f);
+        builder.addVertexData(matrix.last(), quad,
+                red,
+                green,
+                blue,
+                trueAlpha,
+                LightTexture.pack(15, 15), OverlayTexture.NO_OVERLAY);
+    }
 }
diff --git a/src/main/java/dev/compactmods/crafting/projector/FieldProjectorBlock.java b/src/main/java/dev/compactmods/crafting/projector/FieldProjectorBlock.java
@@ -16,7 +16,6 @@
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.BlockItemUseContext;
 import net.minecraft.particles.IParticleData;
-import net.minecraft.particles.ParticleTypes;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.state.DirectionProperty;
 import net.minecraft.state.EnumProperty;
@@ -169,9 +168,6 @@ public ActionResultType use(BlockState state, World world, BlockPos pos, PlayerE
             return ActionResultType.SUCCESS;
         }
 
-        ProjectorHelper.getMissingProjectors(world, pos, state.getValue(FACING))
-                .forEach(projPos -> spawnPlacementParticle((ServerWorld) world, projPos, ParticleTypes.BARRIER));
-
         // Uncomment for debug block placement
 //        Arrays.stream(FieldProjectionSize.values()).forEach(size -> {
 //            BlockPos center = size.getCenterFromProjector(pos, projectorFacing);

Original file line number	Diff line number	Diff line change
`@@ -86,5 +86,7 @@ public static void onWorldRender(final RenderWorldLastEvent event) {`
`86`	`86`	`stack.popPose();`
`87`	`87`	`});`
`88`	`88`	`});`
	`89`	`+`
	`90`	`+ buffers.endBatch();`
`89`	`91`	`}`
`90`	`92`	`}`