302 lines
10 KiB
Java
302 lines
10 KiB
Java
package net.minecraft.client.renderer.block.model;
|
|
|
|
import com.mojang.math.Transformation;
|
|
import net.fabricmc.api.EnvType;
|
|
import net.fabricmc.api.Environment;
|
|
import net.minecraft.client.renderer.FaceInfo;
|
|
import net.minecraft.client.renderer.FaceInfo.Constants;
|
|
import net.minecraft.client.renderer.FaceInfo.VertexInfo;
|
|
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
|
|
import net.minecraft.client.resources.model.ModelState;
|
|
import net.minecraft.core.BlockMath;
|
|
import net.minecraft.core.Direction;
|
|
import net.minecraft.core.Vec3i;
|
|
import net.minecraft.util.Mth;
|
|
import org.jetbrains.annotations.Nullable;
|
|
import org.joml.Matrix3f;
|
|
import org.joml.Matrix4f;
|
|
import org.joml.Quaternionf;
|
|
import org.joml.Vector3f;
|
|
import org.joml.Vector4f;
|
|
|
|
@Environment(EnvType.CLIENT)
|
|
public class FaceBakery {
|
|
public static final int VERTEX_INT_SIZE = 8;
|
|
private static final float RESCALE_22_5 = 1.0F / (float)Math.cos((float) (Math.PI / 8)) - 1.0F;
|
|
private static final float RESCALE_45 = 1.0F / (float)Math.cos((float) (Math.PI / 4)) - 1.0F;
|
|
public static final int VERTEX_COUNT = 4;
|
|
private static final int COLOR_INDEX = 3;
|
|
public static final int UV_INDEX = 4;
|
|
|
|
public static BakedQuad bakeQuad(
|
|
Vector3f posFrom,
|
|
Vector3f posTo,
|
|
BlockElementFace face,
|
|
TextureAtlasSprite sprite,
|
|
Direction facing,
|
|
ModelState transform,
|
|
@Nullable BlockElementRotation rotation,
|
|
boolean shade,
|
|
int lightEmission
|
|
) {
|
|
BlockFaceUV blockFaceUV = face.uv();
|
|
if (transform.isUvLocked()) {
|
|
blockFaceUV = recomputeUVs(face.uv(), facing, transform.getRotation());
|
|
}
|
|
|
|
float[] fs = new float[blockFaceUV.uvs.length];
|
|
System.arraycopy(blockFaceUV.uvs, 0, fs, 0, fs.length);
|
|
float f = sprite.uvShrinkRatio();
|
|
float g = (blockFaceUV.uvs[0] + blockFaceUV.uvs[0] + blockFaceUV.uvs[2] + blockFaceUV.uvs[2]) / 4.0F;
|
|
float h = (blockFaceUV.uvs[1] + blockFaceUV.uvs[1] + blockFaceUV.uvs[3] + blockFaceUV.uvs[3]) / 4.0F;
|
|
blockFaceUV.uvs[0] = Mth.lerp(f, blockFaceUV.uvs[0], g);
|
|
blockFaceUV.uvs[2] = Mth.lerp(f, blockFaceUV.uvs[2], g);
|
|
blockFaceUV.uvs[1] = Mth.lerp(f, blockFaceUV.uvs[1], h);
|
|
blockFaceUV.uvs[3] = Mth.lerp(f, blockFaceUV.uvs[3], h);
|
|
int[] is = makeVertices(blockFaceUV, sprite, facing, setupShape(posFrom, posTo), transform.getRotation(), rotation);
|
|
Direction direction = calculateFacing(is);
|
|
System.arraycopy(fs, 0, blockFaceUV.uvs, 0, fs.length);
|
|
if (rotation == null) {
|
|
recalculateWinding(is, direction);
|
|
}
|
|
|
|
return new BakedQuad(is, face.tintIndex(), direction, sprite, shade, lightEmission);
|
|
}
|
|
|
|
public static BlockFaceUV recomputeUVs(BlockFaceUV uv, Direction facing, Transformation rotation) {
|
|
Matrix4f matrix4f = BlockMath.getUVLockTransform(rotation, facing).getMatrix();
|
|
float f = uv.getU(uv.getReverseIndex(0));
|
|
float g = uv.getV(uv.getReverseIndex(0));
|
|
Vector4f vector4f = matrix4f.transform(new Vector4f(f / 16.0F, g / 16.0F, 0.0F, 1.0F));
|
|
float h = 16.0F * vector4f.x();
|
|
float i = 16.0F * vector4f.y();
|
|
float j = uv.getU(uv.getReverseIndex(2));
|
|
float k = uv.getV(uv.getReverseIndex(2));
|
|
Vector4f vector4f2 = matrix4f.transform(new Vector4f(j / 16.0F, k / 16.0F, 0.0F, 1.0F));
|
|
float l = 16.0F * vector4f2.x();
|
|
float m = 16.0F * vector4f2.y();
|
|
float n;
|
|
float o;
|
|
if (Math.signum(j - f) == Math.signum(l - h)) {
|
|
n = h;
|
|
o = l;
|
|
} else {
|
|
n = l;
|
|
o = h;
|
|
}
|
|
|
|
float p;
|
|
float q;
|
|
if (Math.signum(k - g) == Math.signum(m - i)) {
|
|
p = i;
|
|
q = m;
|
|
} else {
|
|
p = m;
|
|
q = i;
|
|
}
|
|
|
|
float r = (float)Math.toRadians(uv.rotation);
|
|
Matrix3f matrix3f = new Matrix3f(matrix4f);
|
|
Vector3f vector3f = matrix3f.transform(new Vector3f(Mth.cos(r), Mth.sin(r), 0.0F));
|
|
int s = Math.floorMod(-((int)Math.round(Math.toDegrees(Math.atan2(vector3f.y(), vector3f.x())) / 90.0)) * 90, 360);
|
|
return new BlockFaceUV(new float[]{n, p, o, q}, s);
|
|
}
|
|
|
|
private static int[] makeVertices(
|
|
BlockFaceUV uvs,
|
|
TextureAtlasSprite sprite,
|
|
Direction orientation,
|
|
float[] posDiv16,
|
|
Transformation transformation,
|
|
@Nullable BlockElementRotation partRotation
|
|
) {
|
|
int[] is = new int[32];
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
bakeVertex(is, i, orientation, uvs, posDiv16, sprite, transformation, partRotation);
|
|
}
|
|
|
|
return is;
|
|
}
|
|
|
|
private static float[] setupShape(Vector3f min, Vector3f max) {
|
|
float[] fs = new float[Direction.values().length];
|
|
fs[Constants.MIN_X] = min.x() / 16.0F;
|
|
fs[Constants.MIN_Y] = min.y() / 16.0F;
|
|
fs[Constants.MIN_Z] = min.z() / 16.0F;
|
|
fs[Constants.MAX_X] = max.x() / 16.0F;
|
|
fs[Constants.MAX_Y] = max.y() / 16.0F;
|
|
fs[Constants.MAX_Z] = max.z() / 16.0F;
|
|
return fs;
|
|
}
|
|
|
|
private static void bakeVertex(
|
|
int[] vertexData,
|
|
int vertexIndex,
|
|
Direction facing,
|
|
BlockFaceUV blockFaceUV,
|
|
float[] posDiv16,
|
|
TextureAtlasSprite sprite,
|
|
Transformation transformation,
|
|
@Nullable BlockElementRotation partRotation
|
|
) {
|
|
VertexInfo vertexInfo = FaceInfo.fromFacing(facing).getVertexInfo(vertexIndex);
|
|
Vector3f vector3f = new Vector3f(posDiv16[vertexInfo.xFace], posDiv16[vertexInfo.yFace], posDiv16[vertexInfo.zFace]);
|
|
applyElementRotation(vector3f, partRotation);
|
|
applyModelRotation(vector3f, transformation);
|
|
fillVertex(vertexData, vertexIndex, vector3f, sprite, blockFaceUV);
|
|
}
|
|
|
|
private static void fillVertex(int[] vertexData, int vertexIndex, Vector3f vector, TextureAtlasSprite sprite, BlockFaceUV blockFaceUV) {
|
|
int i = vertexIndex * 8;
|
|
vertexData[i] = Float.floatToRawIntBits(vector.x());
|
|
vertexData[i + 1] = Float.floatToRawIntBits(vector.y());
|
|
vertexData[i + 2] = Float.floatToRawIntBits(vector.z());
|
|
vertexData[i + 3] = -1;
|
|
vertexData[i + 4] = Float.floatToRawIntBits(sprite.getU(blockFaceUV.getU(vertexIndex) / 16.0F));
|
|
vertexData[i + 4 + 1] = Float.floatToRawIntBits(sprite.getV(blockFaceUV.getV(vertexIndex) / 16.0F));
|
|
}
|
|
|
|
private static void applyElementRotation(Vector3f vec, @Nullable BlockElementRotation partRotation) {
|
|
if (partRotation != null) {
|
|
Vector3f vector3f;
|
|
Vector3f vector3f2;
|
|
switch (partRotation.axis()) {
|
|
case X:
|
|
vector3f = new Vector3f(1.0F, 0.0F, 0.0F);
|
|
vector3f2 = new Vector3f(0.0F, 1.0F, 1.0F);
|
|
break;
|
|
case Y:
|
|
vector3f = new Vector3f(0.0F, 1.0F, 0.0F);
|
|
vector3f2 = new Vector3f(1.0F, 0.0F, 1.0F);
|
|
break;
|
|
case Z:
|
|
vector3f = new Vector3f(0.0F, 0.0F, 1.0F);
|
|
vector3f2 = new Vector3f(1.0F, 1.0F, 0.0F);
|
|
break;
|
|
default:
|
|
throw new IllegalArgumentException("There are only 3 axes");
|
|
}
|
|
|
|
Quaternionf quaternionf = new Quaternionf().rotationAxis(partRotation.angle() * (float) (Math.PI / 180.0), vector3f);
|
|
if (partRotation.rescale()) {
|
|
if (Math.abs(partRotation.angle()) == 22.5F) {
|
|
vector3f2.mul(RESCALE_22_5);
|
|
} else {
|
|
vector3f2.mul(RESCALE_45);
|
|
}
|
|
|
|
vector3f2.add(1.0F, 1.0F, 1.0F);
|
|
} else {
|
|
vector3f2.set(1.0F, 1.0F, 1.0F);
|
|
}
|
|
|
|
rotateVertexBy(vec, new Vector3f(partRotation.origin()), new Matrix4f().rotation(quaternionf), vector3f2);
|
|
}
|
|
}
|
|
|
|
private static void applyModelRotation(Vector3f pos, Transformation transform) {
|
|
if (transform != Transformation.identity()) {
|
|
rotateVertexBy(pos, new Vector3f(0.5F, 0.5F, 0.5F), transform.getMatrix(), new Vector3f(1.0F, 1.0F, 1.0F));
|
|
}
|
|
}
|
|
|
|
private static void rotateVertexBy(Vector3f pos, Vector3f origin, Matrix4f transform, Vector3f scale) {
|
|
Vector4f vector4f = transform.transform(new Vector4f(pos.x() - origin.x(), pos.y() - origin.y(), pos.z() - origin.z(), 1.0F));
|
|
vector4f.mul(new Vector4f(scale, 1.0F));
|
|
pos.set(vector4f.x() + origin.x(), vector4f.y() + origin.y(), vector4f.z() + origin.z());
|
|
}
|
|
|
|
private static Direction calculateFacing(int[] faceData) {
|
|
Vector3f vector3f = new Vector3f(Float.intBitsToFloat(faceData[0]), Float.intBitsToFloat(faceData[1]), Float.intBitsToFloat(faceData[2]));
|
|
Vector3f vector3f2 = new Vector3f(Float.intBitsToFloat(faceData[8]), Float.intBitsToFloat(faceData[9]), Float.intBitsToFloat(faceData[10]));
|
|
Vector3f vector3f3 = new Vector3f(Float.intBitsToFloat(faceData[16]), Float.intBitsToFloat(faceData[17]), Float.intBitsToFloat(faceData[18]));
|
|
Vector3f vector3f4 = new Vector3f(vector3f).sub(vector3f2);
|
|
Vector3f vector3f5 = new Vector3f(vector3f3).sub(vector3f2);
|
|
Vector3f vector3f6 = new Vector3f(vector3f5).cross(vector3f4).normalize();
|
|
if (!vector3f6.isFinite()) {
|
|
return Direction.UP;
|
|
} else {
|
|
Direction direction = null;
|
|
float f = 0.0F;
|
|
|
|
for (Direction direction2 : Direction.values()) {
|
|
Vec3i vec3i = direction2.getUnitVec3i();
|
|
Vector3f vector3f7 = new Vector3f(vec3i.getX(), vec3i.getY(), vec3i.getZ());
|
|
float g = vector3f6.dot(vector3f7);
|
|
if (g >= 0.0F && g > f) {
|
|
f = g;
|
|
direction = direction2;
|
|
}
|
|
}
|
|
|
|
return direction == null ? Direction.UP : direction;
|
|
}
|
|
}
|
|
|
|
private static void recalculateWinding(int[] vertices, Direction direction) {
|
|
int[] is = new int[vertices.length];
|
|
System.arraycopy(vertices, 0, is, 0, vertices.length);
|
|
float[] fs = new float[Direction.values().length];
|
|
fs[Constants.MIN_X] = 999.0F;
|
|
fs[Constants.MIN_Y] = 999.0F;
|
|
fs[Constants.MIN_Z] = 999.0F;
|
|
fs[Constants.MAX_X] = -999.0F;
|
|
fs[Constants.MAX_Y] = -999.0F;
|
|
fs[Constants.MAX_Z] = -999.0F;
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
int j = 8 * i;
|
|
float f = Float.intBitsToFloat(is[j]);
|
|
float g = Float.intBitsToFloat(is[j + 1]);
|
|
float h = Float.intBitsToFloat(is[j + 2]);
|
|
if (f < fs[Constants.MIN_X]) {
|
|
fs[Constants.MIN_X] = f;
|
|
}
|
|
|
|
if (g < fs[Constants.MIN_Y]) {
|
|
fs[Constants.MIN_Y] = g;
|
|
}
|
|
|
|
if (h < fs[Constants.MIN_Z]) {
|
|
fs[Constants.MIN_Z] = h;
|
|
}
|
|
|
|
if (f > fs[Constants.MAX_X]) {
|
|
fs[Constants.MAX_X] = f;
|
|
}
|
|
|
|
if (g > fs[Constants.MAX_Y]) {
|
|
fs[Constants.MAX_Y] = g;
|
|
}
|
|
|
|
if (h > fs[Constants.MAX_Z]) {
|
|
fs[Constants.MAX_Z] = h;
|
|
}
|
|
}
|
|
|
|
FaceInfo faceInfo = FaceInfo.fromFacing(direction);
|
|
|
|
for (int jx = 0; jx < 4; jx++) {
|
|
int k = 8 * jx;
|
|
VertexInfo vertexInfo = faceInfo.getVertexInfo(jx);
|
|
float hx = fs[vertexInfo.xFace];
|
|
float l = fs[vertexInfo.yFace];
|
|
float m = fs[vertexInfo.zFace];
|
|
vertices[k] = Float.floatToRawIntBits(hx);
|
|
vertices[k + 1] = Float.floatToRawIntBits(l);
|
|
vertices[k + 2] = Float.floatToRawIntBits(m);
|
|
|
|
for (int n = 0; n < 4; n++) {
|
|
int o = 8 * n;
|
|
float p = Float.intBitsToFloat(is[o]);
|
|
float q = Float.intBitsToFloat(is[o + 1]);
|
|
float r = Float.intBitsToFloat(is[o + 2]);
|
|
if (Mth.equal(hx, p) && Mth.equal(l, q) && Mth.equal(m, r)) {
|
|
vertices[k + 4] = is[o + 4];
|
|
vertices[k + 4 + 1] = is[o + 4 + 1];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|