merded/minecraft-src
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
minecraft-src/net/minecraft/client/renderer/block/ModelBlockRenderer.java
Sergey 647c903435 1.21.5
2025-07-04 03:45:38 +03:00

986 lines
37 KiB
Java
Raw Permalink Blame History

package net.minecraft.client.renderer.block;
import com.mojang.blaze3d.vertex.PoseStack;
import com.mojang.blaze3d.vertex.VertexConsumer;
import it.unimi.dsi.fastutil.longs.Long2FloatLinkedOpenHashMap;
import it.unimi.dsi.fastutil.longs.Long2IntLinkedOpenHashMap;
import java.util.List;
import net.fabricmc.api.EnvType;
import net.fabricmc.api.Environment;
import net.minecraft.CrashReport;
import net.minecraft.CrashReportCategory;
import net.minecraft.ReportedException;
import net.minecraft.Util;
import net.minecraft.client.Minecraft;
import net.minecraft.client.color.block.BlockColors;
import net.minecraft.client.renderer.LevelRenderer;
import net.minecraft.client.renderer.block.ModelBlockRenderer.Cache.1;
import net.minecraft.client.renderer.block.ModelBlockRenderer.Cache.2;
import net.minecraft.client.renderer.block.model.BakedQuad;
import net.minecraft.client.renderer.block.model.BlockModelPart;
import net.minecraft.client.renderer.block.model.BlockStateModel;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.util.ARGB;
import net.minecraft.util.Mth;
import net.minecraft.util.RandomSource;
import net.minecraft.world.level.BlockAndTintGetter;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.state.BlockState;
@Environment(EnvType.CLIENT)
public class ModelBlockRenderer {
private static final Direction[] DIRECTIONS = Direction.values();
private final BlockColors blockColors;
private static final int CACHE_SIZE = 100;
static final ThreadLocal<ModelBlockRenderer.Cache> CACHE = ThreadLocal.withInitial(ModelBlockRenderer.Cache::new);
public ModelBlockRenderer(BlockColors blockColors) {
this.blockColors = blockColors;
}
public void tesselateBlock(
BlockAndTintGetter level,
List<BlockModelPart> parts,
BlockState state,
BlockPos pos,
PoseStack poseStack,
VertexConsumer consumer,
boolean checkSides,
int packedOverlay
) {
if (!parts.isEmpty()) {
boolean bl = Minecraft.useAmbientOcclusion() && state.getLightEmission() == 0 && ((BlockModelPart)parts.getFirst()).useAmbientOcclusion();
poseStack.translate(state.getOffset(pos));
try {
if (bl) {
this.tesselateWithAO(level, parts, state, pos, poseStack, consumer, checkSides, packedOverlay);
} else {
this.tesselateWithoutAO(level, parts, state, pos, poseStack, consumer, checkSides, packedOverlay);
}
} catch (Throwable var13) {
CrashReport crashReport = CrashReport.forThrowable(var13, "Tesselating block model");
CrashReportCategory crashReportCategory = crashReport.addCategory("Block model being tesselated");
CrashReportCategory.populateBlockDetails(crashReportCategory, level, pos, state);
crashReportCategory.setDetail("Using AO", bl);
throw new ReportedException(crashReport);
}
}
}
private static boolean shouldRenderFace(BlockAndTintGetter level, BlockState state, boolean checkSides, Direction face, BlockPos pos) {
if (!checkSides) {
return true;
} else {
BlockState blockState = level.getBlockState(pos);
return Block.shouldRenderFace(state, blockState, face);
}
}
public void tesselateWithAO(
BlockAndTintGetter level,
List<BlockModelPart> parts,
BlockState state,
BlockPos pos,
PoseStack poseStack,
VertexConsumer consumer,
boolean checkSides,
int packedOverlay
) {
ModelBlockRenderer.AmbientOcclusionRenderStorage ambientOcclusionRenderStorage = new ModelBlockRenderer.AmbientOcclusionRenderStorage();
int i = 0;
int j = 0;
for (BlockModelPart blockModelPart : parts) {
for (Direction direction : DIRECTIONS) {
int k = 1 << direction.ordinal();
boolean bl = (i & k) == 1;
boolean bl2 = (j & k) == 1;
if (!bl || bl2) {
List<BakedQuad> list = blockModelPart.getQuads(direction);
if (!list.isEmpty()) {
if (!bl) {
bl2 = shouldRenderFace(level, state, checkSides, direction, ambientOcclusionRenderStorage.scratchPos.setWithOffset(pos, direction));
i |= k;
if (bl2) {
j |= k;
}
}
if (bl2) {
this.renderModelFaceAO(level, state, pos, poseStack, consumer, list, ambientOcclusionRenderStorage, packedOverlay);
}
}
}
}
List<BakedQuad> list2 = blockModelPart.getQuads(null);
if (!list2.isEmpty()) {
this.renderModelFaceAO(level, state, pos, poseStack, consumer, list2, ambientOcclusionRenderStorage, packedOverlay);
}
}
}
public void tesselateWithoutAO(
BlockAndTintGetter level,
List<BlockModelPart> parts,
BlockState state,
BlockPos pos,
PoseStack poseStack,
VertexConsumer consumer,
boolean checkSides,
int packedOverlay
) {
ModelBlockRenderer.CommonRenderStorage commonRenderStorage = new ModelBlockRenderer.CommonRenderStorage();
int i = 0;
int j = 0;
for (BlockModelPart blockModelPart : parts) {
for (Direction direction : DIRECTIONS) {
int k = 1 << direction.ordinal();
boolean bl = (i & k) == 1;
boolean bl2 = (j & k) == 1;
if (!bl || bl2) {
List<BakedQuad> list = blockModelPart.getQuads(direction);
if (!list.isEmpty()) {
BlockPos blockPos = commonRenderStorage.scratchPos.setWithOffset(pos, direction);
if (!bl) {
bl2 = shouldRenderFace(level, state, checkSides, direction, blockPos);
i |= k;
if (bl2) {
j |= k;
}
}
if (bl2) {
int l = commonRenderStorage.cache.getLightColor(state, level, blockPos);
this.renderModelFaceFlat(level, state, pos, l, packedOverlay, false, poseStack, consumer, list, commonRenderStorage);
}
}
}
}
List<BakedQuad> list2 = blockModelPart.getQuads(null);
if (!list2.isEmpty()) {
this.renderModelFaceFlat(level, state, pos, -1, packedOverlay, true, poseStack, consumer, list2, commonRenderStorage);
}
}
}
private void renderModelFaceAO(
BlockAndTintGetter level,
BlockState state,
BlockPos pos,
PoseStack poseStack,
VertexConsumer consumer,
List<BakedQuad> quads,
ModelBlockRenderer.AmbientOcclusionRenderStorage renderStorage,
int packedOverlay
) {
for (BakedQuad bakedQuad : quads) {
calculateShape(level, state, pos, bakedQuad.vertices(), bakedQuad.direction(), renderStorage);
renderStorage.calculate(level, state, pos, bakedQuad.direction(), bakedQuad.shade());
this.putQuadData(level, state, pos, consumer, poseStack.last(), bakedQuad, renderStorage, packedOverlay);
}
}
private void putQuadData(
BlockAndTintGetter level,
BlockState state,
BlockPos pos,
VertexConsumer consumer,
PoseStack.Pose pose,
BakedQuad quad,
ModelBlockRenderer.CommonRenderStorage renderStorage,
int packedOverlay
) {
int i = quad.tintIndex();
float f;
float g;
float h;
if (i != -1) {
int j;
if (renderStorage.tintCacheIndex == i) {
j = renderStorage.tintCacheValue;
} else {
j = this.blockColors.getColor(state, level, pos, i);
renderStorage.tintCacheIndex = i;
renderStorage.tintCacheValue = j;
}
f = ARGB.redFloat(j);
g = ARGB.greenFloat(j);
h = ARGB.blueFloat(j);
} else {
f = 1.0F;
g = 1.0F;
h = 1.0F;
}
consumer.putBulkData(pose, quad, renderStorage.brightness, f, g, h, 1.0F, renderStorage.lightmap, packedOverlay, true);
}
private static void calculateShape(
BlockAndTintGetter level, BlockState state, BlockPos pos, int[] verticies, Direction direction, ModelBlockRenderer.CommonRenderStorage renderStorage
) {
float f = 32.0F;
float g = 32.0F;
float h = 32.0F;
float i = -32.0F;
float j = -32.0F;
float k = -32.0F;
for (int l = 0; l < 4; l++) {
float m = Float.intBitsToFloat(verticies[l * 8]);
float n = Float.intBitsToFloat(verticies[l * 8 + 1]);
float o = Float.intBitsToFloat(verticies[l * 8 + 2]);
f = Math.min(f, m);
g = Math.min(g, n);
h = Math.min(h, o);
i = Math.max(i, m);
j = Math.max(j, n);
k = Math.max(k, o);
}
if (renderStorage instanceof ModelBlockRenderer.AmbientOcclusionRenderStorage ambientOcclusionRenderStorage) {
ambientOcclusionRenderStorage.faceShape[ModelBlockRenderer.SizeInfo.WEST.index] = f;
ambientOcclusionRenderStorage.faceShape[ModelBlockRenderer.SizeInfo.EAST.index] = i;
ambientOcclusionRenderStorage.faceShape[ModelBlockRenderer.SizeInfo.DOWN.index] = g;
ambientOcclusionRenderStorage.faceShape[ModelBlockRenderer.SizeInfo.UP.index] = j;
ambientOcclusionRenderStorage.faceShape[ModelBlockRenderer.SizeInfo.NORTH.index] = h;
ambientOcclusionRenderStorage.faceShape[ModelBlockRenderer.SizeInfo.SOUTH.index] = k;
ambientOcclusionRenderStorage.faceShape[ModelBlockRenderer.SizeInfo.FLIP_WEST.index] = 1.0F - f;
ambientOcclusionRenderStorage.faceShape[ModelBlockRenderer.SizeInfo.FLIP_EAST.index] = 1.0F - i;
ambientOcclusionRenderStorage.faceShape[ModelBlockRenderer.SizeInfo.FLIP_DOWN.index] = 1.0F - g;
ambientOcclusionRenderStorage.faceShape[ModelBlockRenderer.SizeInfo.FLIP_UP.index] = 1.0F - j;
ambientOcclusionRenderStorage.faceShape[ModelBlockRenderer.SizeInfo.FLIP_NORTH.index] = 1.0F - h;
ambientOcclusionRenderStorage.faceShape[ModelBlockRenderer.SizeInfo.FLIP_SOUTH.index] = 1.0F - k;
}
float p = 1.0E-4F;
float m = 0.9999F;
renderStorage.facePartial = switch (direction) {
case DOWN, UP -> f >= 1.0E-4F || h >= 1.0E-4F || i <= 0.9999F || k <= 0.9999F;
case NORTH, SOUTH -> f >= 1.0E-4F || g >= 1.0E-4F || i <= 0.9999F || j <= 0.9999F;
case WEST, EAST -> g >= 1.0E-4F || h >= 1.0E-4F || j <= 0.9999F || k <= 0.9999F;
};
renderStorage.faceCubic = switch (direction) {
case DOWN -> g == j && (g < 1.0E-4F || state.isCollisionShapeFullBlock(level, pos));
case UP -> g == j && (j > 0.9999F || state.isCollisionShapeFullBlock(level, pos));
case NORTH -> h == k && (h < 1.0E-4F || state.isCollisionShapeFullBlock(level, pos));
case SOUTH -> h == k && (k > 0.9999F || state.isCollisionShapeFullBlock(level, pos));
case WEST -> f == i && (f < 1.0E-4F || state.isCollisionShapeFullBlock(level, pos));
case EAST -> f == i && (i > 0.9999F || state.isCollisionShapeFullBlock(level, pos));
};
}
/**
* @param repackLight {@code true} if packed light should be re-calculated
*/
private void renderModelFaceFlat(
BlockAndTintGetter level,
BlockState state,
BlockPos pos,
int packedLight,
int packedOverlay,
boolean repackLight,
PoseStack poseStack,
VertexConsumer consumer,
List<BakedQuad> quads,
ModelBlockRenderer.CommonRenderStorage renderStorage
) {
for (BakedQuad bakedQuad : quads) {
if (repackLight) {
calculateShape(level, state, pos, bakedQuad.vertices(), bakedQuad.direction(), renderStorage);
BlockPos blockPos = (BlockPos)(renderStorage.faceCubic ? renderStorage.scratchPos.setWithOffset(pos, bakedQuad.direction()) : pos);
packedLight = renderStorage.cache.getLightColor(state, level, blockPos);
}
float f = level.getShade(bakedQuad.direction(), bakedQuad.shade());
renderStorage.brightness[0] = f;
renderStorage.brightness[1] = f;
renderStorage.brightness[2] = f;
renderStorage.brightness[3] = f;
renderStorage.lightmap[0] = packedLight;
renderStorage.lightmap[1] = packedLight;
renderStorage.lightmap[2] = packedLight;
renderStorage.lightmap[3] = packedLight;
this.putQuadData(level, state, pos, consumer, poseStack.last(), bakedQuad, renderStorage, packedOverlay);
}
}
public static void renderModel(
PoseStack.Pose pose, VertexConsumer consumer, BlockStateModel model, float red, float green, float blue, int packedLight, int packedOverlay
) {
for (BlockModelPart blockModelPart : model.collectParts(RandomSource.create(42L))) {
for (Direction direction : DIRECTIONS) {
renderQuadList(pose, consumer, red, green, blue, blockModelPart.getQuads(direction), packedLight, packedOverlay);
}
renderQuadList(pose, consumer, red, green, blue, blockModelPart.getQuads(null), packedLight, packedOverlay);
}
}
private static void renderQuadList(
PoseStack.Pose pose, VertexConsumer consumer, float red, float green, float blue, List<BakedQuad> quads, int packedLight, int packedOverlay
) {
for (BakedQuad bakedQuad : quads) {
float f;
float g;
float h;
if (bakedQuad.isTinted()) {
f = Mth.clamp(red, 0.0F, 1.0F);
g = Mth.clamp(green, 0.0F, 1.0F);
h = Mth.clamp(blue, 0.0F, 1.0F);
} else {
f = 1.0F;
g = 1.0F;
h = 1.0F;
}
consumer.putBulkData(pose, bakedQuad, f, g, h, 1.0F, packedLight, packedOverlay);
}
}
public static void enableCaching() {
((ModelBlockRenderer.Cache)CACHE.get()).enable();
}
public static void clearCache() {
((ModelBlockRenderer.Cache)CACHE.get()).disable();
}
@Environment(EnvType.CLIENT)
protected static enum AdjacencyInfo {
DOWN(
new Direction[]{Direction.WEST, Direction.EAST, Direction.NORTH, Direction.SOUTH},
0.5F,
true,
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.FLIP_WEST,
ModelBlockRenderer.SizeInfo.SOUTH,
ModelBlockRenderer.SizeInfo.FLIP_WEST,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.WEST,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.WEST,
ModelBlockRenderer.SizeInfo.SOUTH
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.FLIP_WEST,
ModelBlockRenderer.SizeInfo.NORTH,
ModelBlockRenderer.SizeInfo.FLIP_WEST,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.WEST,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.WEST,
ModelBlockRenderer.SizeInfo.NORTH
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.FLIP_EAST,
ModelBlockRenderer.SizeInfo.NORTH,
ModelBlockRenderer.SizeInfo.FLIP_EAST,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.EAST,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.EAST,
ModelBlockRenderer.SizeInfo.NORTH
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.FLIP_EAST,
ModelBlockRenderer.SizeInfo.SOUTH,
ModelBlockRenderer.SizeInfo.FLIP_EAST,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.EAST,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.EAST,
ModelBlockRenderer.SizeInfo.SOUTH
}
),
UP(
new Direction[]{Direction.EAST, Direction.WEST, Direction.NORTH, Direction.SOUTH},
1.0F,
true,
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.EAST,
ModelBlockRenderer.SizeInfo.SOUTH,
ModelBlockRenderer.SizeInfo.EAST,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.FLIP_EAST,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.FLIP_EAST,
ModelBlockRenderer.SizeInfo.SOUTH
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.EAST,
ModelBlockRenderer.SizeInfo.NORTH,
ModelBlockRenderer.SizeInfo.EAST,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.FLIP_EAST,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.FLIP_EAST,
ModelBlockRenderer.SizeInfo.NORTH
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.WEST,
ModelBlockRenderer.SizeInfo.NORTH,
ModelBlockRenderer.SizeInfo.WEST,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.FLIP_WEST,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.FLIP_WEST,
ModelBlockRenderer.SizeInfo.NORTH
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.WEST,
ModelBlockRenderer.SizeInfo.SOUTH,
ModelBlockRenderer.SizeInfo.WEST,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.FLIP_WEST,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.FLIP_WEST,
ModelBlockRenderer.SizeInfo.SOUTH
}
),
NORTH(
new Direction[]{Direction.UP, Direction.DOWN, Direction.EAST, Direction.WEST},
0.8F,
true,
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.FLIP_WEST,
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.WEST,
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.WEST,
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.FLIP_WEST
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.FLIP_EAST,
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.EAST,
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.EAST,
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.FLIP_EAST
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.FLIP_EAST,
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.EAST,
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.EAST,
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.FLIP_EAST
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.FLIP_WEST,
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.WEST,
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.WEST,
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.FLIP_WEST
}
),
SOUTH(
new Direction[]{Direction.WEST, Direction.EAST, Direction.DOWN, Direction.UP},
0.8F,
true,
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.FLIP_WEST,
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.FLIP_WEST,
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.WEST,
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.WEST
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.FLIP_WEST,
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.FLIP_WEST,
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.WEST,
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.WEST
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.FLIP_EAST,
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.FLIP_EAST,
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.EAST,
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.EAST
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.FLIP_EAST,
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.FLIP_EAST,
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.EAST,
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.EAST
}
),
WEST(
new Direction[]{Direction.UP, Direction.DOWN, Direction.NORTH, Direction.SOUTH},
0.6F,
true,
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.SOUTH,
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.SOUTH
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.NORTH,
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.NORTH
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.NORTH,
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.NORTH
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.SOUTH,
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.SOUTH
}
),
EAST(
new Direction[]{Direction.DOWN, Direction.UP, Direction.NORTH, Direction.SOUTH},
0.6F,
true,
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.SOUTH,
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.SOUTH
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.NORTH,
ModelBlockRenderer.SizeInfo.FLIP_DOWN,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.DOWN,
ModelBlockRenderer.SizeInfo.NORTH
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.NORTH,
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.FLIP_NORTH,
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.NORTH
},
new ModelBlockRenderer.SizeInfo[]{
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.SOUTH,
ModelBlockRenderer.SizeInfo.FLIP_UP,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.FLIP_SOUTH,
ModelBlockRenderer.SizeInfo.UP,
ModelBlockRenderer.SizeInfo.SOUTH
}
);
final Direction[] corners;
final boolean doNonCubicWeight;
final ModelBlockRenderer.SizeInfo[] vert0Weights;
final ModelBlockRenderer.SizeInfo[] vert1Weights;
final ModelBlockRenderer.SizeInfo[] vert2Weights;
final ModelBlockRenderer.SizeInfo[] vert3Weights;
private static final ModelBlockRenderer.AdjacencyInfo[] BY_FACING = Util.make(new ModelBlockRenderer.AdjacencyInfo[6], adjacencyInfos -> {
adjacencyInfos[Direction.DOWN.get3DDataValue()] = DOWN;
adjacencyInfos[Direction.UP.get3DDataValue()] = UP;
adjacencyInfos[Direction.NORTH.get3DDataValue()] = NORTH;
adjacencyInfos[Direction.SOUTH.get3DDataValue()] = SOUTH;
adjacencyInfos[Direction.WEST.get3DDataValue()] = WEST;
adjacencyInfos[Direction.EAST.get3DDataValue()] = EAST;
});
/**
* @param shadeBrightness the shade brightness for this direction
*/
private AdjacencyInfo(
final Direction[] corners,
final float shadeBrightness,
final boolean doNonCubicWeight,
final ModelBlockRenderer.SizeInfo[] vert0Weights,
final ModelBlockRenderer.SizeInfo[] vert1Weights,
final ModelBlockRenderer.SizeInfo[] vert2Weights,
final ModelBlockRenderer.SizeInfo[] vert3Weights
) {
this.corners = corners;
this.doNonCubicWeight = doNonCubicWeight;
this.vert0Weights = vert0Weights;
this.vert1Weights = vert1Weights;
this.vert2Weights = vert2Weights;
this.vert3Weights = vert3Weights;
}
public static ModelBlockRenderer.AdjacencyInfo fromFacing(Direction facing) {
return BY_FACING[facing.get3DDataValue()];
}
}
@Environment(EnvType.CLIENT)
static class AmbientOcclusionRenderStorage extends ModelBlockRenderer.CommonRenderStorage {
final float[] faceShape = new float[ModelBlockRenderer.SizeInfo.COUNT];
public AmbientOcclusionRenderStorage() {
}
public void calculate(BlockAndTintGetter level, BlockState state, BlockPos pos, Direction direction, boolean shade) {
BlockPos blockPos = this.faceCubic ? pos.relative(direction) : pos;
ModelBlockRenderer.AdjacencyInfo adjacencyInfo = ModelBlockRenderer.AdjacencyInfo.fromFacing(direction);
BlockPos.MutableBlockPos mutableBlockPos = this.scratchPos;
mutableBlockPos.setWithOffset(blockPos, adjacencyInfo.corners[0]);
BlockState blockState = level.getBlockState(mutableBlockPos);
int i = this.cache.getLightColor(blockState, level, mutableBlockPos);
float f = this.cache.getShadeBrightness(blockState, level, mutableBlockPos);
mutableBlockPos.setWithOffset(blockPos, adjacencyInfo.corners[1]);
BlockState blockState2 = level.getBlockState(mutableBlockPos);
int j = this.cache.getLightColor(blockState2, level, mutableBlockPos);
float g = this.cache.getShadeBrightness(blockState2, level, mutableBlockPos);
mutableBlockPos.setWithOffset(blockPos, adjacencyInfo.corners[2]);
BlockState blockState3 = level.getBlockState(mutableBlockPos);
int k = this.cache.getLightColor(blockState3, level, mutableBlockPos);
float h = this.cache.getShadeBrightness(blockState3, level, mutableBlockPos);
mutableBlockPos.setWithOffset(blockPos, adjacencyInfo.corners[3]);
BlockState blockState4 = level.getBlockState(mutableBlockPos);
int l = this.cache.getLightColor(blockState4, level, mutableBlockPos);
float m = this.cache.getShadeBrightness(blockState4, level, mutableBlockPos);
BlockState blockState5 = level.getBlockState(mutableBlockPos.setWithOffset(blockPos, adjacencyInfo.corners[0]).move(direction));
boolean bl = !blockState5.isViewBlocking(level, mutableBlockPos) || blockState5.getLightBlock() == 0;
BlockState blockState6 = level.getBlockState(mutableBlockPos.setWithOffset(blockPos, adjacencyInfo.corners[1]).move(direction));
boolean bl2 = !blockState6.isViewBlocking(level, mutableBlockPos) || blockState6.getLightBlock() == 0;
BlockState blockState7 = level.getBlockState(mutableBlockPos.setWithOffset(blockPos, adjacencyInfo.corners[2]).move(direction));
boolean bl3 = !blockState7.isViewBlocking(level, mutableBlockPos) || blockState7.getLightBlock() == 0;
BlockState blockState8 = level.getBlockState(mutableBlockPos.setWithOffset(blockPos, adjacencyInfo.corners[3]).move(direction));
boolean bl4 = !blockState8.isViewBlocking(level, mutableBlockPos) || blockState8.getLightBlock() == 0;
float n;
int o;
if (!bl3 && !bl) {
n = f;
o = i;
} else {
mutableBlockPos.setWithOffset(blockPos, adjacencyInfo.corners[0]).move(adjacencyInfo.corners[2]);
BlockState blockState9 = level.getBlockState(mutableBlockPos);
n = this.cache.getShadeBrightness(blockState9, level, mutableBlockPos);
o = this.cache.getLightColor(blockState9, level, mutableBlockPos);
}
float p;
int q;
if (!bl4 && !bl) {
p = f;
q = i;
} else {
mutableBlockPos.setWithOffset(blockPos, adjacencyInfo.corners[0]).move(adjacencyInfo.corners[3]);
BlockState blockState9 = level.getBlockState(mutableBlockPos);
p = this.cache.getShadeBrightness(blockState9, level, mutableBlockPos);
q = this.cache.getLightColor(blockState9, level, mutableBlockPos);
}
float r;
int s;
if (!bl3 && !bl2) {
r = f;
s = i;
} else {
mutableBlockPos.setWithOffset(blockPos, adjacencyInfo.corners[1]).move(adjacencyInfo.corners[2]);
BlockState blockState9 = level.getBlockState(mutableBlockPos);
r = this.cache.getShadeBrightness(blockState9, level, mutableBlockPos);
s = this.cache.getLightColor(blockState9, level, mutableBlockPos);
}
float t;
int u;
if (!bl4 && !bl2) {
t = f;
u = i;
} else {
mutableBlockPos.setWithOffset(blockPos, adjacencyInfo.corners[1]).move(adjacencyInfo.corners[3]);
BlockState blockState9 = level.getBlockState(mutableBlockPos);
t = this.cache.getShadeBrightness(blockState9, level, mutableBlockPos);
u = this.cache.getLightColor(blockState9, level, mutableBlockPos);
}
int v = this.cache.getLightColor(state, level, pos);
mutableBlockPos.setWithOffset(pos, direction);
BlockState blockState10 = level.getBlockState(mutableBlockPos);
if (this.faceCubic || !blockState10.isSolidRender()) {
v = this.cache.getLightColor(blockState10, level, mutableBlockPos);
}
float w = this.faceCubic
? this.cache.getShadeBrightness(level.getBlockState(blockPos), level, blockPos)
: this.cache.getShadeBrightness(level.getBlockState(pos), level, pos);
ModelBlockRenderer.AmbientVertexRemap ambientVertexRemap = ModelBlockRenderer.AmbientVertexRemap.fromFacing(direction);
if (this.facePartial && adjacencyInfo.doNonCubicWeight) {
float x = (m + f + p + w) * 0.25F;
float y = (h + f + n + w) * 0.25F;
float z = (h + g + r + w) * 0.25F;
float aa = (m + g + t + w) * 0.25F;
float ab = this.faceShape[adjacencyInfo.vert0Weights[0].index] * this.faceShape[adjacencyInfo.vert0Weights[1].index];
float ac = this.faceShape[adjacencyInfo.vert0Weights[2].index] * this.faceShape[adjacencyInfo.vert0Weights[3].index];
float ad = this.faceShape[adjacencyInfo.vert0Weights[4].index] * this.faceShape[adjacencyInfo.vert0Weights[5].index];
float ae = this.faceShape[adjacencyInfo.vert0Weights[6].index] * this.faceShape[adjacencyInfo.vert0Weights[7].index];
float af = this.faceShape[adjacencyInfo.vert1Weights[0].index] * this.faceShape[adjacencyInfo.vert1Weights[1].index];
float ag = this.faceShape[adjacencyInfo.vert1Weights[2].index] * this.faceShape[adjacencyInfo.vert1Weights[3].index];
float ah = this.faceShape[adjacencyInfo.vert1Weights[4].index] * this.faceShape[adjacencyInfo.vert1Weights[5].index];
float ai = this.faceShape[adjacencyInfo.vert1Weights[6].index] * this.faceShape[adjacencyInfo.vert1Weights[7].index];
float aj = this.faceShape[adjacencyInfo.vert2Weights[0].index] * this.faceShape[adjacencyInfo.vert2Weights[1].index];
float ak = this.faceShape[adjacencyInfo.vert2Weights[2].index] * this.faceShape[adjacencyInfo.vert2Weights[3].index];
float al = this.faceShape[adjacencyInfo.vert2Weights[4].index] * this.faceShape[adjacencyInfo.vert2Weights[5].index];
float am = this.faceShape[adjacencyInfo.vert2Weights[6].index] * this.faceShape[adjacencyInfo.vert2Weights[7].index];
float an = this.faceShape[adjacencyInfo.vert3Weights[0].index] * this.faceShape[adjacencyInfo.vert3Weights[1].index];
float ao = this.faceShape[adjacencyInfo.vert3Weights[2].index] * this.faceShape[adjacencyInfo.vert3Weights[3].index];
float ap = this.faceShape[adjacencyInfo.vert3Weights[4].index] * this.faceShape[adjacencyInfo.vert3Weights[5].index];
float aq = this.faceShape[adjacencyInfo.vert3Weights[6].index] * this.faceShape[adjacencyInfo.vert3Weights[7].index];
this.brightness[ambientVertexRemap.vert0] = Math.clamp(x * ab + y * ac + z * ad + aa * ae, 0.0F, 1.0F);
this.brightness[ambientVertexRemap.vert1] = Math.clamp(x * af + y * ag + z * ah + aa * ai, 0.0F, 1.0F);
this.brightness[ambientVertexRemap.vert2] = Math.clamp(x * aj + y * ak + z * al + aa * am, 0.0F, 1.0F);
this.brightness[ambientVertexRemap.vert3] = Math.clamp(x * an + y * ao + z * ap + aa * aq, 0.0F, 1.0F);
int ar = blend(l, i, q, v);
int as = blend(k, i, o, v);
int at = blend(k, j, s, v);
int au = blend(l, j, u, v);
this.lightmap[ambientVertexRemap.vert0] = blend(ar, as, at, au, ab, ac, ad, ae);
this.lightmap[ambientVertexRemap.vert1] = blend(ar, as, at, au, af, ag, ah, ai);
this.lightmap[ambientVertexRemap.vert2] = blend(ar, as, at, au, aj, ak, al, am);
this.lightmap[ambientVertexRemap.vert3] = blend(ar, as, at, au, an, ao, ap, aq);
} else {
float x = (m + f + p + w) * 0.25F;
float y = (h + f + n + w) * 0.25F;
float z = (h + g + r + w) * 0.25F;
float aa = (m + g + t + w) * 0.25F;
this.lightmap[ambientVertexRemap.vert0] = blend(l, i, q, v);
this.lightmap[ambientVertexRemap.vert1] = blend(k, i, o, v);
this.lightmap[ambientVertexRemap.vert2] = blend(k, j, s, v);
this.lightmap[ambientVertexRemap.vert3] = blend(l, j, u, v);
this.brightness[ambientVertexRemap.vert0] = x;
this.brightness[ambientVertexRemap.vert1] = y;
this.brightness[ambientVertexRemap.vert2] = z;
this.brightness[ambientVertexRemap.vert3] = aa;
}
float x = level.getShade(direction, shade);
for (int av = 0; av < this.brightness.length; av++) {
this.brightness[av] = this.brightness[av] * x;
}
}
private static int blend(int color1, int color2, int color3, int currentBlockColor) {
if (color1 == 0) {
color1 = currentBlockColor;
}
if (color2 == 0) {
color2 = currentBlockColor;
}
if (color3 == 0) {
color3 = currentBlockColor;
}
return color1 + color2 + color3 + currentBlockColor >> 2 & 16711935;
}
private static int blend(
int color1, int color2, int color3, int blockLight, float color1Weight, float color2Weight, float color3Weight, float blockLightWeight
) {
int i = (int)(
(color1 >> 16 & 0xFF) * color1Weight
+ (color2 >> 16 & 0xFF) * color2Weight
+ (color3 >> 16 & 0xFF) * color3Weight
+ (blockLight >> 16 & 0xFF) * blockLightWeight
)
& 0xFF;
int j = (int)((color1 & 0xFF) * color1Weight + (color2 & 0xFF) * color2Weight + (color3 & 0xFF) * color3Weight + (blockLight & 0xFF) * blockLightWeight)
& 0xFF;
return i << 16 | j;
}
}
@Environment(EnvType.CLIENT)
static enum AmbientVertexRemap {
DOWN(0, 1, 2, 3),
UP(2, 3, 0, 1),
NORTH(3, 0, 1, 2),
SOUTH(0, 1, 2, 3),
WEST(3, 0, 1, 2),
EAST(1, 2, 3, 0);
final int vert0;
final int vert1;
final int vert2;
final int vert3;
private static final ModelBlockRenderer.AmbientVertexRemap[] BY_FACING = Util.make(new ModelBlockRenderer.AmbientVertexRemap[6], ambientVertexRemaps -> {
ambientVertexRemaps[Direction.DOWN.get3DDataValue()] = DOWN;
ambientVertexRemaps[Direction.UP.get3DDataValue()] = UP;
ambientVertexRemaps[Direction.NORTH.get3DDataValue()] = NORTH;
ambientVertexRemaps[Direction.SOUTH.get3DDataValue()] = SOUTH;
ambientVertexRemaps[Direction.WEST.get3DDataValue()] = WEST;
ambientVertexRemaps[Direction.EAST.get3DDataValue()] = EAST;
});
private AmbientVertexRemap(final int vert0, final int vert1, final int vert2, final int vert3) {
this.vert0 = vert0;
this.vert1 = vert1;
this.vert2 = vert2;
this.vert3 = vert3;
}
public static ModelBlockRenderer.AmbientVertexRemap fromFacing(Direction facing) {
return BY_FACING[facing.get3DDataValue()];
}
}
@Environment(EnvType.CLIENT)
static class Cache {
private boolean enabled;
private final Long2IntLinkedOpenHashMap colorCache = Util.make(() -> {
Long2IntLinkedOpenHashMap long2IntLinkedOpenHashMap = new 1(this, 100, 0.25F);
long2IntLinkedOpenHashMap.defaultReturnValue(Integer.MAX_VALUE);
return long2IntLinkedOpenHashMap;
});
private final Long2FloatLinkedOpenHashMap brightnessCache = Util.make(() -> {
Long2FloatLinkedOpenHashMap long2FloatLinkedOpenHashMap = new 2(this, 100, 0.25F);
long2FloatLinkedOpenHashMap.defaultReturnValue(Float.NaN);
return long2FloatLinkedOpenHashMap;
});
private final LevelRenderer.BrightnessGetter cachedBrightnessGetter = (blockAndTintGetter, blockPos) -> {
long l = blockPos.asLong();
int i = this.colorCache.get(l);
if (i != Integer.MAX_VALUE) {
return i;
} else {
int j = LevelRenderer.BrightnessGetter.DEFAULT.packedBrightness(blockAndTintGetter, blockPos);
if (this.colorCache.size() == 100) {
this.colorCache.removeFirstInt();
}
this.colorCache.put(l, j);
return j;
}
};
private Cache() {
}
public void enable() {
this.enabled = true;
}
public void disable() {
this.enabled = false;
this.colorCache.clear();
this.brightnessCache.clear();
}
public int getLightColor(BlockState state, BlockAndTintGetter level, BlockPos pos) {
return LevelRenderer.getLightColor(this.enabled ? this.cachedBrightnessGetter : LevelRenderer.BrightnessGetter.DEFAULT, level, state, pos);
}
public float getShadeBrightness(BlockState state, BlockAndTintGetter level, BlockPos pos) {
long l = pos.asLong();
if (this.enabled) {
float f = this.brightnessCache.get(l);
if (!Float.isNaN(f)) {
return f;
}
}
float f = state.getShadeBrightness(level, pos);
if (this.enabled) {
if (this.brightnessCache.size() == 100) {
this.brightnessCache.removeFirstFloat();
}
this.brightnessCache.put(l, f);
}
return f;
}
}
@Environment(EnvType.CLIENT)
static class CommonRenderStorage {
public final BlockPos.MutableBlockPos scratchPos = new BlockPos.MutableBlockPos();
public boolean faceCubic;
public boolean facePartial;
public final float[] brightness = new float[4];
public final int[] lightmap = new int[4];
public int tintCacheIndex = -1;
public int tintCacheValue;
public final ModelBlockRenderer.Cache cache = (ModelBlockRenderer.Cache)ModelBlockRenderer.CACHE.get();
}
@Environment(EnvType.CLIENT)
protected static enum SizeInfo {
DOWN(0),
UP(1),
NORTH(2),
SOUTH(3),
WEST(4),
EAST(5),
FLIP_DOWN(6),
FLIP_UP(7),
FLIP_NORTH(8),
FLIP_SOUTH(9),
FLIP_WEST(10),
FLIP_EAST(11);
public static final int COUNT = values().length;
final int index;
private SizeInfo(final int index) {
this.index = index;
}
}
}
Reference in a new issue View git blame Copy permalink