mirror of
https://github.com/GTNewHorizons/Applied-Energistics-2-Unofficial.git
synced 2026-11-17 19:15:06 +00:00
621 lines
20 KiB
Java
621 lines
20 KiB
Java
/*
|
|
* This file is part of Applied Energistics 2. Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved. Applied
|
|
* Energistics 2 is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General
|
|
* Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
|
|
* later version. Applied Energistics 2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
|
|
* Public License for more details. You should have received a copy of the GNU Lesser General Public License along with
|
|
* Applied Energistics 2. If not, see <http://www.gnu.org/licenses/lgpl>.
|
|
*/
|
|
|
|
package appeng.client.render;
|
|
|
|
import java.util.EnumSet;
|
|
|
|
import javax.annotation.Nullable;
|
|
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.client.renderer.RenderBlocks;
|
|
import net.minecraft.client.renderer.Tessellator;
|
|
import net.minecraft.util.IIcon;
|
|
import net.minecraft.world.IBlockAccess;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
|
|
import com.google.common.base.Function;
|
|
import com.google.common.base.Optional;
|
|
|
|
import appeng.api.AEApi;
|
|
import appeng.api.exceptions.MissingDefinition;
|
|
import appeng.api.parts.IBoxProvider;
|
|
import appeng.api.parts.IPartCollisionHelper;
|
|
import appeng.api.parts.IPartRenderHelper;
|
|
import appeng.api.parts.ISimplifiedBundle;
|
|
import appeng.block.AEBaseBlock;
|
|
import appeng.block.networking.BlockCableBus;
|
|
import appeng.client.texture.FlippableIcon;
|
|
import appeng.client.texture.MissingIcon;
|
|
import appeng.core.AEConfig;
|
|
import appeng.core.features.AEFeature;
|
|
import appeng.tile.AEBaseTile;
|
|
import cpw.mods.fml.relauncher.Side;
|
|
import cpw.mods.fml.relauncher.SideOnly;
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
public final class BusRenderHelper implements IPartRenderHelper {
|
|
|
|
public static final ThreadLocal<BusRenderHelper> instances = ThreadLocal.withInitial(BusRenderHelper::new);
|
|
|
|
private static final int HEX_WHITE = 0xffffff;
|
|
|
|
private final BoundBoxCalculator bbc;
|
|
private final boolean noAlphaPass;
|
|
private final BaseBlockRender<AEBaseBlock, AEBaseTile> bbr;
|
|
private final Optional<Block> maybeBlock;
|
|
private final Optional<AEBaseBlock> maybeBaseBlock;
|
|
private int renderingForPass;
|
|
private int currentPass;
|
|
private int itemsRendered;
|
|
private double minX;
|
|
private double minY;
|
|
private double minZ;
|
|
private double maxX;
|
|
private double maxY;
|
|
private double maxZ;
|
|
private ForgeDirection ax;
|
|
private ForgeDirection ay;
|
|
private ForgeDirection az;
|
|
private int color;
|
|
|
|
public BusRenderHelper() {
|
|
this.bbc = new BoundBoxCalculator();
|
|
this.noAlphaPass = !AEConfig.instance.isFeatureEnabled(AEFeature.AlphaPass);
|
|
this.bbr = new BaseBlockRender<>();
|
|
this.renderingForPass = 0;
|
|
this.currentPass = 0;
|
|
this.itemsRendered = 0;
|
|
this.minX = 0;
|
|
this.minY = 0;
|
|
this.minZ = 0;
|
|
this.maxX = 16;
|
|
this.maxY = 16;
|
|
this.maxZ = 16;
|
|
this.ax = ForgeDirection.EAST;
|
|
this.az = ForgeDirection.SOUTH;
|
|
this.ay = ForgeDirection.UP;
|
|
this.color = HEX_WHITE;
|
|
this.maybeBlock = AEApi.instance().definitions().blocks().multiPart().maybeBlock();
|
|
this.maybeBaseBlock = this.maybeBlock.transform(new BaseBlockTransformFunction());
|
|
}
|
|
|
|
public int getItemsRendered() {
|
|
return this.itemsRendered;
|
|
}
|
|
|
|
public void setPass(final int pass) {
|
|
this.renderingForPass = 0;
|
|
this.currentPass = pass;
|
|
this.itemsRendered = 0;
|
|
}
|
|
|
|
public double getBound(final ForgeDirection side) {
|
|
return switch (side) {
|
|
default -> 0.5;
|
|
case DOWN -> this.minY;
|
|
case EAST -> this.maxX;
|
|
case NORTH -> this.minZ;
|
|
case SOUTH -> this.maxZ;
|
|
case UP -> this.maxY;
|
|
case WEST -> this.minX;
|
|
};
|
|
}
|
|
|
|
public void setRenderColor(final int color) {
|
|
for (final Block block : AEApi.instance().definitions().blocks().multiPart().maybeBlock().asSet()) {
|
|
final BlockCableBus cableBus = (BlockCableBus) block;
|
|
cableBus.setRenderColor(color);
|
|
}
|
|
}
|
|
|
|
public void setOrientation(final ForgeDirection dx, final ForgeDirection dy, final ForgeDirection dz) {
|
|
this.ax = dx == null ? ForgeDirection.EAST : dx;
|
|
this.ay = dy == null ? ForgeDirection.UP : dy;
|
|
this.az = dz == null ? ForgeDirection.SOUTH : dz;
|
|
}
|
|
|
|
public double[] getBounds() {
|
|
return new double[] { this.minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ };
|
|
}
|
|
|
|
public void setBounds(final double[] bounds) {
|
|
if (bounds == null || bounds.length != 6) {
|
|
return;
|
|
}
|
|
|
|
this.minX = bounds[0];
|
|
this.minY = bounds[1];
|
|
this.minZ = bounds[2];
|
|
this.maxX = bounds[3];
|
|
this.maxY = bounds[4];
|
|
this.maxZ = bounds[5];
|
|
}
|
|
|
|
private class BoundBoxCalculator implements IPartCollisionHelper {
|
|
|
|
private boolean started = false;
|
|
|
|
private float minX;
|
|
private float minY;
|
|
private float minZ;
|
|
|
|
private float maxX;
|
|
private float maxY;
|
|
private float maxZ;
|
|
|
|
@Override
|
|
public void addBox(final double minX, final double minY, final double minZ, final double maxX,
|
|
final double maxY, final double maxZ) {
|
|
if (this.started) {
|
|
this.minX = Math.min(this.minX, (float) minX);
|
|
this.minY = Math.min(this.minY, (float) minY);
|
|
this.minZ = Math.min(this.minZ, (float) minZ);
|
|
this.maxX = Math.max(this.maxX, (float) maxX);
|
|
this.maxY = Math.max(this.maxY, (float) maxY);
|
|
this.maxZ = Math.max(this.maxZ, (float) maxZ);
|
|
} else {
|
|
this.started = true;
|
|
this.minX = (float) minX;
|
|
this.minY = (float) minY;
|
|
this.minZ = (float) minZ;
|
|
this.maxX = (float) maxX;
|
|
this.maxY = (float) maxY;
|
|
this.maxZ = (float) maxZ;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ForgeDirection getWorldX() {
|
|
return BusRenderHelper.this.ax;
|
|
}
|
|
|
|
@Override
|
|
public ForgeDirection getWorldY() {
|
|
return BusRenderHelper.this.ay;
|
|
}
|
|
|
|
@Override
|
|
public ForgeDirection getWorldZ() {
|
|
return BusRenderHelper.this.az;
|
|
}
|
|
|
|
@Override
|
|
public boolean isBBCollision() {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public IBlockAccess getBlockAccess() {
|
|
return BusRenderHelper.this.getBlockAccess();
|
|
}
|
|
}
|
|
|
|
private static final class BaseBlockTransformFunction implements Function<Block, AEBaseBlock> {
|
|
|
|
@Nullable
|
|
@Override
|
|
public AEBaseBlock apply(final Block input) {
|
|
if (input instanceof AEBaseBlock) {
|
|
return ((AEBaseBlock) input);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void renderForPass(final int pass) {
|
|
this.renderingForPass = pass;
|
|
}
|
|
|
|
private boolean renderThis() {
|
|
if (this.renderingForPass == this.currentPass || this.noAlphaPass) {
|
|
this.itemsRendered++;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void normalRendering() {
|
|
final RenderBlocksWorkaround rbw = BusRenderer.INSTANCE.getRenderer();
|
|
rbw.setCalculations(true);
|
|
rbw.setUseTextures(true);
|
|
rbw.enableAO = false;
|
|
}
|
|
|
|
@Override
|
|
public ISimplifiedBundle useSimplifiedRendering(final int x, final int y, final int z, final IBoxProvider p,
|
|
final ISimplifiedBundle sim) {
|
|
final RenderBlocksWorkaround rbw = BusRenderer.INSTANCE.getRenderer();
|
|
|
|
if (sim != null && this.maybeBlock.isPresent()
|
|
&& rbw.similarLighting(this.maybeBlock.get(), rbw.blockAccess, x, y, z, sim)) {
|
|
rbw.populate(sim);
|
|
rbw.setFaces(EnumSet.allOf(ForgeDirection.class));
|
|
rbw.setCalculations(false);
|
|
rbw.setUseTextures(false);
|
|
|
|
return sim;
|
|
} else {
|
|
final boolean allFaces = rbw.renderAllFaces;
|
|
rbw.renderAllFaces = true;
|
|
rbw.setCalculations(true);
|
|
rbw.getFaces().clear();
|
|
|
|
this.bbc.started = false;
|
|
if (p == null) {
|
|
this.bbc.minX = this.bbc.minY = this.bbc.minZ = 0;
|
|
this.bbc.maxX = this.bbc.maxY = this.bbc.maxZ = 16;
|
|
} else {
|
|
p.getBoxes(this.bbc);
|
|
|
|
if (this.bbc.minX < 1) {
|
|
this.bbc.minX = 1;
|
|
}
|
|
if (this.bbc.minY < 1) {
|
|
this.bbc.minY = 1;
|
|
}
|
|
if (this.bbc.minZ < 1) {
|
|
this.bbc.minZ = 1;
|
|
}
|
|
|
|
if (this.bbc.maxX > 15) {
|
|
this.bbc.maxX = 15;
|
|
}
|
|
if (this.bbc.maxY > 15) {
|
|
this.bbc.maxY = 15;
|
|
}
|
|
if (this.bbc.maxZ > 15) {
|
|
this.bbc.maxZ = 15;
|
|
}
|
|
}
|
|
|
|
this.setBounds(this.bbc.minX, this.bbc.minY, this.bbc.minZ, this.bbc.maxX, this.bbc.maxY, this.bbc.maxZ);
|
|
|
|
this.bbr.renderBlockBounds(
|
|
rbw,
|
|
this.minX,
|
|
this.minY,
|
|
this.minZ,
|
|
this.maxX,
|
|
this.maxY,
|
|
this.maxZ,
|
|
this.ax,
|
|
this.ay,
|
|
this.az);
|
|
|
|
for (final Block block : this.maybeBlock.asSet()) {
|
|
rbw.renderStandardBlock(block, x, y, z);
|
|
}
|
|
|
|
rbw.setFaces(EnumSet.allOf(ForgeDirection.class));
|
|
rbw.renderAllFaces = allFaces;
|
|
rbw.setCalculations(false);
|
|
rbw.setUseTextures(false);
|
|
|
|
return rbw.getLightingCache();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setBounds(final float minX, final float minY, final float minZ, final float maxX, final float maxY,
|
|
final float maxZ) {
|
|
this.minX = minX;
|
|
this.minY = minY;
|
|
this.minZ = minZ;
|
|
this.maxX = maxX;
|
|
this.maxY = maxY;
|
|
this.maxZ = maxZ;
|
|
}
|
|
|
|
@Override
|
|
public void setInvColor(final int newColor) {
|
|
this.color = newColor;
|
|
}
|
|
|
|
@Override
|
|
public void setTexture(final IIcon ico) {
|
|
for (final AEBaseBlock baseBlock : this.maybeBaseBlock.asSet()) {
|
|
baseBlock.getRendererInstance().setTemporaryRenderIcon(ico);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setTexture(final IIcon down, final IIcon up, final IIcon north, final IIcon south, final IIcon west,
|
|
final IIcon east) {
|
|
final IIcon[] list = new IIcon[6];
|
|
|
|
list[0] = down;
|
|
list[1] = up;
|
|
list[2] = north;
|
|
list[3] = south;
|
|
list[4] = west;
|
|
list[5] = east;
|
|
|
|
for (final AEBaseBlock baseBlock : this.maybeBaseBlock.asSet()) {
|
|
baseBlock.getRendererInstance().setTemporaryRenderIcons(
|
|
list[this.mapRotation(ForgeDirection.UP).ordinal()],
|
|
list[this.mapRotation(ForgeDirection.DOWN).ordinal()],
|
|
list[this.mapRotation(ForgeDirection.SOUTH).ordinal()],
|
|
list[this.mapRotation(ForgeDirection.NORTH).ordinal()],
|
|
list[this.mapRotation(ForgeDirection.EAST).ordinal()],
|
|
list[this.mapRotation(ForgeDirection.WEST).ordinal()]);
|
|
}
|
|
}
|
|
|
|
private ForgeDirection mapRotation(final ForgeDirection dir) {
|
|
final ForgeDirection forward = this.az;
|
|
final ForgeDirection up = this.ay;
|
|
|
|
if (forward == null || up == null) {
|
|
return dir;
|
|
}
|
|
|
|
final int west_x = forward.offsetY * up.offsetZ - forward.offsetZ * up.offsetY;
|
|
final int west_y = forward.offsetZ * up.offsetX - forward.offsetX * up.offsetZ;
|
|
final int west_z = forward.offsetX * up.offsetY - forward.offsetY * up.offsetX;
|
|
|
|
ForgeDirection west = ForgeDirection.UNKNOWN;
|
|
for (final ForgeDirection dx : ForgeDirection.VALID_DIRECTIONS) {
|
|
if (dx.offsetX == west_x && dx.offsetY == west_y && dx.offsetZ == west_z) {
|
|
west = dx;
|
|
}
|
|
}
|
|
|
|
if (dir == forward) {
|
|
return ForgeDirection.SOUTH;
|
|
}
|
|
if (dir == forward.getOpposite()) {
|
|
return ForgeDirection.NORTH;
|
|
}
|
|
|
|
if (dir == up) {
|
|
return ForgeDirection.UP;
|
|
}
|
|
if (dir == up.getOpposite()) {
|
|
return ForgeDirection.DOWN;
|
|
}
|
|
|
|
if (dir == west) {
|
|
return ForgeDirection.WEST;
|
|
}
|
|
if (dir == west.getOpposite()) {
|
|
return ForgeDirection.EAST;
|
|
}
|
|
|
|
return ForgeDirection.UNKNOWN;
|
|
}
|
|
|
|
@Override
|
|
public void renderInventoryBox(final RenderBlocks renderer) {
|
|
renderer.setRenderBounds(
|
|
this.minX / 16.0,
|
|
this.minY / 16.0,
|
|
this.minZ / 16.0,
|
|
this.maxX / 16.0,
|
|
this.maxY / 16.0,
|
|
this.maxZ / 16.0);
|
|
|
|
for (final AEBaseBlock baseBlock : this.maybeBaseBlock.asSet()) {
|
|
this.bbr.renderInvBlock(
|
|
EnumSet.allOf(ForgeDirection.class),
|
|
baseBlock,
|
|
null,
|
|
Tessellator.instance,
|
|
this.color,
|
|
renderer);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void renderInventoryFace(final IIcon icon, final ForgeDirection face, final RenderBlocks renderer) {
|
|
renderer.setRenderBounds(
|
|
this.minX / 16.0,
|
|
this.minY / 16.0,
|
|
this.minZ / 16.0,
|
|
this.maxX / 16.0,
|
|
this.maxY / 16.0,
|
|
this.maxZ / 16.0);
|
|
this.setTexture(icon);
|
|
|
|
for (final AEBaseBlock baseBlock : this.maybeBaseBlock.asSet()) {
|
|
this.bbr.renderInvBlock(EnumSet.of(face), baseBlock, null, Tessellator.instance, this.color, renderer);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void renderBlock(final int x, final int y, final int z, final RenderBlocks renderer) {
|
|
if (!this.renderThis()) {
|
|
return;
|
|
}
|
|
|
|
for (final Block multiPart : AEApi.instance().definitions().blocks().multiPart().maybeBlock().asSet()) {
|
|
final AEBaseBlock block = (AEBaseBlock) multiPart;
|
|
|
|
final BlockRenderInfo info = block.getRendererInstance();
|
|
final ForgeDirection forward = BusRenderHelper.instances.get().az;
|
|
final ForgeDirection up = BusRenderHelper.instances.get().ay;
|
|
boolean isTemp = false;
|
|
if (!info.isValid() && !info.hasTemporaryRenderIcons()) {
|
|
final FlippableIcon i = new FlippableIcon(new MissingIcon(this));
|
|
info.setTemporaryRenderIcon(i);
|
|
isTemp = true;
|
|
}
|
|
renderer.uvRotateBottom = info.getTexture(ForgeDirection.DOWN)
|
|
.setFlip(BaseBlockRender.getOrientation(ForgeDirection.DOWN, forward, up));
|
|
renderer.uvRotateTop = info.getTexture(ForgeDirection.UP)
|
|
.setFlip(BaseBlockRender.getOrientation(ForgeDirection.UP, forward, up));
|
|
|
|
renderer.uvRotateEast = info.getTexture(ForgeDirection.EAST)
|
|
.setFlip(BaseBlockRender.getOrientation(ForgeDirection.EAST, forward, up));
|
|
renderer.uvRotateWest = info.getTexture(ForgeDirection.WEST)
|
|
.setFlip(BaseBlockRender.getOrientation(ForgeDirection.WEST, forward, up));
|
|
|
|
renderer.uvRotateNorth = info.getTexture(ForgeDirection.NORTH)
|
|
.setFlip(BaseBlockRender.getOrientation(ForgeDirection.NORTH, forward, up));
|
|
renderer.uvRotateSouth = info.getTexture(ForgeDirection.SOUTH)
|
|
.setFlip(BaseBlockRender.getOrientation(ForgeDirection.SOUTH, forward, up));
|
|
|
|
this.bbr.renderBlockBounds(
|
|
renderer,
|
|
this.minX,
|
|
this.minY,
|
|
this.minZ,
|
|
this.maxX,
|
|
this.maxY,
|
|
this.maxZ,
|
|
this.ax,
|
|
this.ay,
|
|
this.az);
|
|
|
|
renderer.renderStandardBlock(block, x, y, z);
|
|
if (isTemp) {
|
|
info.setTemporaryRenderIcon(null);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Block getBlock() {
|
|
for (final Block block : AEApi.instance().definitions().blocks().multiPart().maybeBlock().asSet()) {
|
|
return block;
|
|
}
|
|
|
|
throw new MissingDefinition("Tried to access the multi part block without it being defined.");
|
|
}
|
|
|
|
public void prepareBounds(final RenderBlocks renderer) {
|
|
this.bbr.renderBlockBounds(
|
|
renderer,
|
|
this.minX,
|
|
this.minY,
|
|
this.minZ,
|
|
this.maxX,
|
|
this.maxY,
|
|
this.maxZ,
|
|
this.ax,
|
|
this.ay,
|
|
this.az);
|
|
}
|
|
|
|
@Override
|
|
public void setFacesToRender(final EnumSet<ForgeDirection> faces) {
|
|
BusRenderer.INSTANCE.getRenderer().setRenderFaces(faces);
|
|
}
|
|
|
|
@Override
|
|
public void renderBlockCurrentBounds(final int x, final int y, final int z, final RenderBlocks renderer) {
|
|
if (!this.renderThis()) {
|
|
return;
|
|
}
|
|
|
|
for (final Block block : this.maybeBlock.asSet()) {
|
|
renderer.renderStandardBlock(block, x, y, z);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void renderFaceCutout(final int x, final int y, final int z, final IIcon ico, ForgeDirection face,
|
|
final float edgeThickness, final RenderBlocks renderer) {
|
|
if (!this.renderThis()) {
|
|
return;
|
|
}
|
|
|
|
switch (face) {
|
|
case DOWN:
|
|
face = this.ay.getOpposite();
|
|
break;
|
|
case EAST:
|
|
face = this.ax;
|
|
break;
|
|
case NORTH:
|
|
face = this.az.getOpposite();
|
|
break;
|
|
case SOUTH:
|
|
face = this.az;
|
|
break;
|
|
case UP:
|
|
face = this.ay;
|
|
break;
|
|
case WEST:
|
|
face = this.ax.getOpposite();
|
|
break;
|
|
case UNKNOWN:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
for (final AEBaseBlock block : this.maybeBaseBlock.asSet()) {
|
|
this.bbr.renderCutoutFace(block, ico, x, y, z, renderer, face, edgeThickness);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void renderFace(final int x, final int y, final int z, final IIcon ico, ForgeDirection face,
|
|
final RenderBlocks renderer) {
|
|
if (!this.renderThis()) {
|
|
return;
|
|
}
|
|
|
|
this.prepareBounds(renderer);
|
|
switch (face) {
|
|
case DOWN:
|
|
face = this.ay.getOpposite();
|
|
break;
|
|
case EAST:
|
|
face = this.ax;
|
|
break;
|
|
case NORTH:
|
|
face = this.az.getOpposite();
|
|
break;
|
|
case SOUTH:
|
|
face = this.az;
|
|
break;
|
|
case UP:
|
|
face = this.ay;
|
|
break;
|
|
case WEST:
|
|
face = this.ax.getOpposite();
|
|
break;
|
|
case UNKNOWN:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
for (final AEBaseBlock block : this.maybeBaseBlock.asSet()) {
|
|
this.bbr.renderFace(x, y, z, block, ico, renderer, face);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ForgeDirection getWorldX() {
|
|
return this.ax;
|
|
}
|
|
|
|
@Override
|
|
public ForgeDirection getWorldY() {
|
|
return this.ay;
|
|
}
|
|
|
|
@Override
|
|
public ForgeDirection getWorldZ() {
|
|
return this.az;
|
|
}
|
|
|
|
@Override
|
|
public IBlockAccess getBlockAccess() {
|
|
return BusRenderer.INSTANCE.getRenderer().blockAccess;
|
|
}
|
|
}
|