20210191346

Committed 14 Dec 2025 03:32PM UTC coverage: 19.514% (-33.5%) from 53.061%

Build # 20210191346

Build Type

push

github

Committed by

rubensworks

Commit Message

Remove deprecations

Run Details

663 of 8728 branches covered (7.6%)

Branch coverage included in aggregate %.

6786 of 29445 relevant lines covered (23.05%)

1.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/java/org/cyclops/integrateddynamics/client/render/blockentity/RenderBlockEntityEnergyBattery.java

package org.cyclops.integrateddynamics.client.render.blockentity;

import com.mojang.blaze3d.vertex.PoseStack;
import net.minecraft.client.renderer.LevelRenderer;
import net.minecraft.client.renderer.RenderType;
import net.minecraft.client.renderer.SubmitNodeCollector;
import net.minecraft.client.renderer.blockentity.BlockEntityRenderer;
import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
import net.minecraft.client.renderer.blockentity.state.BlockEntityRenderState;
import net.minecraft.client.renderer.feature.ModelFeatureRenderer;
import net.minecraft.client.renderer.state.CameraRenderState;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.world.phys.Vec3;
import org.cyclops.cyclopscore.datastructure.EnumFacingMap;
import org.cyclops.integrateddynamics.blockentity.BlockEntityEnergyBattery;
import org.cyclops.integrateddynamics.blockentity.BlockEntityEnergyBatteryConfigClient;
import org.jetbrains.annotations.Nullable;

/**
 * Renderer for rendering the energy overlay on the {@link org.cyclops.integrateddynamics.block.BlockEnergyBattery}.
 *
 * @author rubensworks
 *
 */
public class RenderBlockEntityEnergyBattery implements BlockEntityRenderer<BlockEntityEnergyBattery, RenderBlockEntityEnergyBattery.RenderState> {

    private static final float OFFSET = 0.001F;
    private static final float MINY = 0F;
    private static final float MAXY = 1F;
    private static final float MIN = 0F - OFFSET;
    private static final float MAX = 1F + OFFSET;
    private static float[][][] coordinates = {
            { // DOWN
                    {MIN, MINY, MIN},
                    {MIN, MINY, MAX},
                    {MAX, MINY, MAX},
                    {MAX, MINY, MIN}
            },
            { // UP
                    {MIN, MAXY, MIN},
                    {MIN, MAXY, MAX},
                    {MAX, MAXY, MAX},
                    {MAX, MAXY, MIN}
            },
            { // NORTH
                    {MIN, MINY, MIN},
                    {MIN, MAXY, MIN},
                    {MAX, MAXY, MIN},
                    {MAX, MINY, MIN}
            },
            { // SOUTH
                    {MAX, MINY, MAX},
                    {MAX, MAXY, MAX},
                    {MIN, MAXY, MAX},
                    {MIN, MINY, MAX}
            },
            { // WEST
                    {MIN, MINY, MAX},
                    {MIN, MAXY, MAX},
                    {MIN, MAXY, MIN},
                    {MIN, MINY, MIN}
            },
            { // EAST
                    {MAX, MINY, MIN},
                    {MAX, MAXY, MIN},
                    {MAX, MAXY, MAX},
                    {MAX, MINY, MAX}
            }
    };

    public RenderBlockEntityEnergyBattery(BlockEntityRendererProvider.Context context) {

    }

    @Override
    public boolean shouldRender(BlockEntityEnergyBattery blockEntity, Vec3 cameraPos) {
        return blockEntity.getBlockPos() == BlockPos.ZERO || BlockEntityRenderer.super.shouldRender(blockEntity, cameraPos);
    }

    @Override
    public RenderState createRenderState() {
        return new RenderState();
    }

    @Override
    public void extractRenderState(BlockEntityEnergyBattery blockEntity, RenderState renderState, float partialTick, Vec3 cameraPosition, @Nullable ModelFeatureRenderer.CrumblingOverlay breakProgress) {
        BlockEntityRenderer.super.extractRenderState(blockEntity, renderState, partialTick, cameraPosition, breakProgress);
        renderState.energyStored = blockEntity.getEnergyStored();
        renderState.maxEnergyStored = blockEntity.getMaxEnergyStored();
        renderState.combinedLights = new EnumFacingMap<>();
        for(Direction side : Direction.Plane.HORIZONTAL) {
            renderState.combinedLights.put(side, LevelRenderer.getLightColor(blockEntity.getLevel(), blockEntity.getBlockPos().offset(side.getUnitVec3i())));
        }
        renderState.creative = blockEntity.isCreative();
        renderState.gameTime = blockEntity.getLevel().getGameTime();
    }

    @Override
    public void submit(RenderState renderState, PoseStack poseStack, SubmitNodeCollector submitNodeCollector, CameraRenderState cameraRenderState) {
        if(renderState.energyStored > 0) {
            // Re-scale height to [0.125, 0.875] range as the energy bar does not take up 100% of the height.
            float height = (((float) renderState.energyStored / renderState.maxEnergyStored) * 12 / 16) + 0.125F;;

            poseStack.pushPose();

            for(Direction side : Direction.Plane.HORIZONTAL) {
                int combinedLight = renderState.combinedLights.get(side);
                TextureAtlasSprite icon = BlockEntityEnergyBatteryConfigClient.ICON_OVERLAY;

                float[][] c = coordinates[side.ordinal()];
                float replacedMaxV = icon.getV1();
                float replacedMinV = (icon.getV0() - icon.getV1()) * height + icon.getV1();

                float r;
                float g;
                float b;
                if (renderState.creative) {
                    float tickFactor = (((float) renderState.gameTime % 20) / 10);
                    if (tickFactor > 1) {
                        tickFactor = -tickFactor + 1;
                    }
                    r = 0.8F + 0.2F * tickFactor;
                    g = 0.42F;
                    b = 0.60F + 0.40F * tickFactor;
                } else {
                    b = 1.0F;
                    g = 1.0F;
                    r = 1.0F;
                }

                submitNodeCollector.submitCustomGeometry(poseStack, RenderType.text(icon.atlasLocation()), (pose, vb) -> {
                    vb.addVertex(pose, c[0][0], c[0][1] * height, c[0][2]).setColor(r, g, b, 1).setUv(icon.getU0(), replacedMaxV).setLight(combinedLight);
                    vb.addVertex(pose, c[1][0], c[1][1] * height, c[1][2]).setColor(r, g, b, 1).setUv(icon.getU0(), replacedMinV).setLight(combinedLight);
                    vb.addVertex(pose, c[2][0], c[2][1] * height, c[2][2]).setColor(r, g, b, 1).setUv(icon.getU1(), replacedMinV).setLight(combinedLight);
                    vb.addVertex(pose, c[3][0], c[3][1] * height, c[3][2]).setColor(r, g, b, 1).setUv(icon.getU1(), replacedMaxV).setLight(combinedLight);
                });
            }

            poseStack.popPose();
        }
    }

    public static class RenderState extends BlockEntityRenderState {
        public int energyStored;
        public int maxEnergyStored;
        public EnumFacingMap<Integer> combinedLights;
        public boolean creative;
        public long gameTime;
    }

}

1	package org.cyclops.integrateddynamics.client.render.blockentity;
2
3	import com.mojang.blaze3d.vertex.PoseStack;
4	import net.minecraft.client.renderer.LevelRenderer;
5	import net.minecraft.client.renderer.RenderType;
6	import net.minecraft.client.renderer.SubmitNodeCollector;
7	import net.minecraft.client.renderer.blockentity.BlockEntityRenderer;
8	import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
9	import net.minecraft.client.renderer.blockentity.state.BlockEntityRenderState;
10	import net.minecraft.client.renderer.feature.ModelFeatureRenderer;
11	import net.minecraft.client.renderer.state.CameraRenderState;
12	import net.minecraft.client.renderer.texture.TextureAtlasSprite;
13	import net.minecraft.core.BlockPos;
14	import net.minecraft.core.Direction;
15	import net.minecraft.world.phys.Vec3;
16	import org.cyclops.cyclopscore.datastructure.EnumFacingMap;
17	import org.cyclops.integrateddynamics.blockentity.BlockEntityEnergyBattery;
18	import org.cyclops.integrateddynamics.blockentity.BlockEntityEnergyBatteryConfigClient;
19	import org.jetbrains.annotations.Nullable;
20
21	/**
22	* Renderer for rendering the energy overlay on the {@link org.cyclops.integrateddynamics.block.BlockEnergyBattery}.
23	*
24	* @author rubensworks
25	*
26	*/
27	public class RenderBlockEntityEnergyBattery implements BlockEntityRenderer<BlockEntityEnergyBattery, RenderBlockEntityEnergyBattery.RenderState> {
28
29	private static final float OFFSET = 0.001F;
30	private static final float MINY = 0F;
31	private static final float MAXY = 1F;
32	private static final float MIN = 0F - OFFSET;
33	private static final float MAX = 1F + OFFSET;
34	private static float[][][] coordinates = {	×
35	{ // DOWN
36	{MIN, MINY, MIN},
37	{MIN, MINY, MAX},
38	{MAX, MINY, MAX},
39	{MAX, MINY, MIN}
40	},
41	{ // UP
42	{MIN, MAXY, MIN},
43	{MIN, MAXY, MAX},
44	{MAX, MAXY, MAX},
45	{MAX, MAXY, MIN}
46	},
47	{ // NORTH
48	{MIN, MINY, MIN},
49	{MIN, MAXY, MIN},
50	{MAX, MAXY, MIN},
51	{MAX, MINY, MIN}
52	},
53	{ // SOUTH
54	{MAX, MINY, MAX},
55	{MAX, MAXY, MAX},
56	{MIN, MAXY, MAX},
57	{MIN, MINY, MAX}
58	},
59	{ // WEST
60	{MIN, MINY, MAX},
61	{MIN, MAXY, MAX},
62	{MIN, MAXY, MIN},
63	{MIN, MINY, MIN}
64	},
65	{ // EAST
66	{MAX, MINY, MIN},
67	{MAX, MAXY, MIN},
68	{MAX, MAXY, MAX},
69	{MAX, MINY, MAX}
70	}
71	};
72
73	public RenderBlockEntityEnergyBattery(BlockEntityRendererProvider.Context context) {	×
74
75	}	×
76
77	@Override
78	public boolean shouldRender(BlockEntityEnergyBattery blockEntity, Vec3 cameraPos) {
79	return blockEntity.getBlockPos() == BlockPos.ZERO \|\| BlockEntityRenderer.super.shouldRender(blockEntity, cameraPos);	×
80	}
81
82	@Override
83	public RenderState createRenderState() {
84	return new RenderState();	×
85	}
86
87	@Override
88	public void extractRenderState(BlockEntityEnergyBattery blockEntity, RenderState renderState, float partialTick, Vec3 cameraPosition, @Nullable ModelFeatureRenderer.CrumblingOverlay breakProgress) {
89	BlockEntityRenderer.super.extractRenderState(blockEntity, renderState, partialTick, cameraPosition, breakProgress);	×
90	renderState.energyStored = blockEntity.getEnergyStored();	×
91	renderState.maxEnergyStored = blockEntity.getMaxEnergyStored();	×
92	renderState.combinedLights = new EnumFacingMap<>();	×
93	for(Direction side : Direction.Plane.HORIZONTAL) {	×
94	renderState.combinedLights.put(side, LevelRenderer.getLightColor(blockEntity.getLevel(), blockEntity.getBlockPos().offset(side.getUnitVec3i())));	×
95	}	×
96	renderState.creative = blockEntity.isCreative();	×
97	renderState.gameTime = blockEntity.getLevel().getGameTime();	×
98	}	×
99
100	@Override
101	public void submit(RenderState renderState, PoseStack poseStack, SubmitNodeCollector submitNodeCollector, CameraRenderState cameraRenderState) {
102	if(renderState.energyStored > 0) {	×
103	// Re-scale height to [0.125, 0.875] range as the energy bar does not take up 100% of the height.
104	float height = (((float) renderState.energyStored / renderState.maxEnergyStored) * 12 / 16) + 0.125F;;	×
105
106	poseStack.pushPose();	×
107
108	for(Direction side : Direction.Plane.HORIZONTAL) {	×
109	int combinedLight = renderState.combinedLights.get(side);	×
110	TextureAtlasSprite icon = BlockEntityEnergyBatteryConfigClient.ICON_OVERLAY;	×
111
112	float[][] c = coordinates[side.ordinal()];	×
113	float replacedMaxV = icon.getV1();	×
114	float replacedMinV = (icon.getV0() - icon.getV1()) * height + icon.getV1();	×
115
116	float r;
117	float g;
118	float b;
119	if (renderState.creative) {	×
120	float tickFactor = (((float) renderState.gameTime % 20) / 10);	×
121	if (tickFactor > 1) {	×
122	tickFactor = -tickFactor + 1;	×
123	}
124	r = 0.8F + 0.2F * tickFactor;	×
125	g = 0.42F;	×
126	b = 0.60F + 0.40F * tickFactor;	×
127	} else {	×
128	b = 1.0F;	×
129	g = 1.0F;	×
130	r = 1.0F;	×
131	}
132
133	submitNodeCollector.submitCustomGeometry(poseStack, RenderType.text(icon.atlasLocation()), (pose, vb) -> {	×
134	vb.addVertex(pose, c[0][0], c[0][1] * height, c[0][2]).setColor(r, g, b, 1).setUv(icon.getU0(), replacedMaxV).setLight(combinedLight);	×
135	vb.addVertex(pose, c[1][0], c[1][1] * height, c[1][2]).setColor(r, g, b, 1).setUv(icon.getU0(), replacedMinV).setLight(combinedLight);	×
136	vb.addVertex(pose, c[2][0], c[2][1] * height, c[2][2]).setColor(r, g, b, 1).setUv(icon.getU1(), replacedMinV).setLight(combinedLight);	×
137	vb.addVertex(pose, c[3][0], c[3][1] * height, c[3][2]).setColor(r, g, b, 1).setUv(icon.getU1(), replacedMaxV).setLight(combinedLight);	×
138	});	×
139	}	×
140
141	poseStack.popPose();	×
142	}
143	}	×
144
145	public static class RenderState extends BlockEntityRenderState {	×
146	public int energyStored;
147	public int maxEnergyStored;
148	public EnumFacingMap<Integer> combinedLights;
149	public boolean creative;
150	public long gameTime;
151	}
152
153	}

CyclopsMC / IntegratedDynamics / 20210191346

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous