296 lines
9.4 KiB
Java
296 lines
9.4 KiB
Java
package io.nanachiyo0721.shiroha.utils;
|
|
|
|
import io.nanachiyo0721.shiroha.config.modules.optimizations.FrustumFilteringTrackerConfig;
|
|
import net.minecraft.world.entity.player.Player;
|
|
import net.minecraft.world.phys.AABB;
|
|
import net.minecraft.world.phys.Vec3;
|
|
import org.jetbrains.annotations.Contract;
|
|
import org.jspecify.annotations.NonNull;
|
|
|
|
public class Culling {
|
|
private static final float VERTICAL_FOV_RAD = (float) Math.toRadians(120);
|
|
private static final float ASPECT = 1.0f;
|
|
private static final float NEAR = 0.1f;
|
|
private static final float FAR = 32.0f;
|
|
|
|
private float fov;
|
|
private float aspect;
|
|
private float near;
|
|
private float far;
|
|
|
|
private final Player player;
|
|
private float[] planes;
|
|
|
|
public static Culling fromConfig(Player player) {
|
|
return new Builder()
|
|
.fov((float) Math.toRadians(FrustumFilteringTrackerConfig.camera_fov))
|
|
.near(NEAR)
|
|
.aspect((float) FrustumFilteringTrackerConfig.aspect)
|
|
.far(FAR)
|
|
.build(player);
|
|
}
|
|
|
|
@Contract(value = "_ -> new", pure = true)
|
|
public static @NonNull Culling newDefault(Player player) {
|
|
return fromBuilder(new Builder(), player);
|
|
}
|
|
|
|
@Contract(value = "_, _ -> new", pure = true)
|
|
public static @NonNull Culling fromBuilder(@NonNull Builder builder, Player player) {
|
|
return new Culling(builder.fov, builder.aspect, builder.near, builder.far, player);
|
|
}
|
|
|
|
public static class Builder {
|
|
private float fov;
|
|
private float aspect;
|
|
private float near;
|
|
private float far;
|
|
|
|
|
|
public Builder() {
|
|
this.fov = VERTICAL_FOV_RAD;
|
|
this.aspect = ASPECT;
|
|
this.near = NEAR;
|
|
this.far = FAR;
|
|
}
|
|
|
|
public Builder fov(float fov) {
|
|
this.fov = fov;
|
|
return this;
|
|
}
|
|
|
|
public Builder aspect(float aspect) {
|
|
this.aspect = aspect;
|
|
return this;
|
|
}
|
|
|
|
public Builder near(float near) {
|
|
this.near = near;
|
|
return this;
|
|
}
|
|
|
|
public Builder far(float far) {
|
|
this.far = far;
|
|
return this;
|
|
}
|
|
|
|
public Culling build(Player player) {
|
|
return fromBuilder(this, player);
|
|
}
|
|
}
|
|
|
|
public Culling(float fov, float aspect, float near, float far, Player player) {
|
|
this.fov = fov;
|
|
this.aspect = aspect;
|
|
this.near = near;
|
|
this.far = far;
|
|
this.player = player;
|
|
}
|
|
|
|
public static float @NonNull [] buildFrustumPlanes(
|
|
float eyeX, float eyeY, float eyeZ,
|
|
float forwardX, float forwardY, float forwardZ,
|
|
float upX, float upY, float upZ,
|
|
float verticalFovRad, float aspect, float nearDist, float farDist) {
|
|
float lenF = (float) Math.sqrt(forwardX * forwardX + forwardY * forwardY + forwardZ * forwardZ);
|
|
float fx = forwardX / lenF;
|
|
float fy = forwardY / lenF;
|
|
float fz = forwardZ / lenF;
|
|
|
|
float rx = fy * upZ - fz * upY;
|
|
float ry = fz * upX - fx * upZ;
|
|
float rz = fx * upY - fy * upX;
|
|
float lenR = (float) Math.sqrt(rx * rx + ry * ry + rz * rz);
|
|
|
|
if (lenR < 1.0e-4f) {
|
|
float fallbackUpX = 0.0f, fallbackUpY = 0.0f, fallbackUpZ = 1.0f;
|
|
if (Math.abs(fz) > 0.999f) {
|
|
fallbackUpX = 1.0f;
|
|
fallbackUpY = 0.0f;
|
|
fallbackUpZ = 0.0f;
|
|
}
|
|
rx = fy * fallbackUpZ - fz * fallbackUpY;
|
|
ry = fz * fallbackUpX - fx * fallbackUpZ;
|
|
rz = fx * fallbackUpY - fy * fallbackUpX;
|
|
lenR = (float) Math.sqrt(rx * rx + ry * ry + rz * rz);
|
|
}
|
|
|
|
rx /= lenR;
|
|
ry /= lenR;
|
|
rz /= lenR;
|
|
|
|
float ux = ry * fz - rz * fy;
|
|
float uy = rz * fx - rx * fz;
|
|
float uz = rx * fy - ry * fx;
|
|
float lenU = (float) Math.sqrt(ux * ux + uy * uy + uz * uz);
|
|
ux /= lenU;
|
|
uy /= lenU;
|
|
uz /= lenU;
|
|
|
|
float tanHalf = (float) Math.tan(verticalFovRad * 0.5);
|
|
float halfVNear = tanHalf * nearDist;
|
|
float halfHNear = halfVNear * aspect;
|
|
float halfVFar = tanHalf * farDist;
|
|
float halfHFar = halfVFar * aspect;
|
|
|
|
float nearCX = eyeX + fx * nearDist;
|
|
float nearCY = eyeY + fy * nearDist;
|
|
float nearCZ = eyeZ + fz * nearDist;
|
|
|
|
float farCX = eyeX + fx * farDist;
|
|
float farCY = eyeY + fy * farDist;
|
|
float farCZ = eyeZ + fz * farDist;
|
|
|
|
float ntlX = nearCX + ux * halfVNear - rx * halfHNear;
|
|
float ntlY = nearCY + uy * halfVNear - ry * halfHNear;
|
|
float ntlZ = nearCZ + uz * halfVNear - rz * halfHNear;
|
|
|
|
float ntrX = nearCX + ux * halfVNear + rx * halfHNear;
|
|
float ntrY = nearCY + uy * halfVNear + ry * halfHNear;
|
|
float ntrZ = nearCZ + uz * halfVNear + rz * halfHNear;
|
|
|
|
float nblX = nearCX - ux * halfVNear - rx * halfHNear;
|
|
float nblY = nearCY - uy * halfVNear - ry * halfHNear;
|
|
float nblZ = nearCZ - uz * halfVNear - rz * halfHNear;
|
|
|
|
float nbrX = nearCX - ux * halfVNear + rx * halfHNear;
|
|
float nbrY = nearCY - uy * halfVNear + ry * halfHNear;
|
|
float nbrZ = nearCZ - uz * halfVNear + rz * halfHNear;
|
|
|
|
float ftlX = farCX + ux * halfVFar - rx * halfHFar;
|
|
float ftlY = farCY + uy * halfVFar - ry * halfHFar;
|
|
float ftlZ = farCZ + uz * halfVFar - rz * halfHFar;
|
|
|
|
float ftrX = farCX + ux * halfVFar + rx * halfHFar;
|
|
float ftrY = farCY + uy * halfVFar + ry * halfHFar;
|
|
float ftrZ = farCZ + uz * halfVFar + rz * halfHFar;
|
|
|
|
float fbrX = farCX - ux * halfVFar + rx * halfHFar;
|
|
float fbrY = farCY - uy * halfVFar + ry * halfHFar;
|
|
float fbrZ = farCZ - uz * halfVFar + rz * halfHFar;
|
|
|
|
float midDist = (nearDist + farDist) * 0.5f;
|
|
float refX = eyeX + fx * midDist;
|
|
float refY = eyeY + fy * midDist;
|
|
float refZ = eyeZ + fz * midDist;
|
|
|
|
float[] planes = new float[24];
|
|
|
|
int idx = 0;
|
|
|
|
idx = computePlane(planes, idx,
|
|
eyeX, eyeY, eyeZ,
|
|
ntlX, ntlY, ntlZ,
|
|
nblX, nblY, nblZ,
|
|
refX, refY, refZ);
|
|
|
|
idx = computePlane(planes, idx,
|
|
eyeX, eyeY, eyeZ,
|
|
nbrX, nbrY, nbrZ,
|
|
ntrX, ntrY, ntrZ,
|
|
refX, refY, refZ);
|
|
|
|
idx = computePlane(planes, idx,
|
|
eyeX, eyeY, eyeZ,
|
|
nblX, nblY, nblZ,
|
|
nbrX, nbrY, nbrZ,
|
|
refX, refY, refZ);
|
|
|
|
idx = computePlane(planes, idx,
|
|
eyeX, eyeY, eyeZ,
|
|
ntrX, ntrY, ntrZ,
|
|
ntlX, ntlY, ntlZ,
|
|
refX, refY, refZ);
|
|
|
|
idx = computePlane(planes, idx,
|
|
ntlX, ntlY, ntlZ,
|
|
ntrX, ntrY, ntrZ,
|
|
nblX, nblY, nblZ,
|
|
refX, refY, refZ);
|
|
|
|
idx = computePlane(planes, idx,
|
|
ftrX, ftrY, ftrZ,
|
|
ftlX, ftlY, ftlZ,
|
|
fbrX, fbrY, fbrZ,
|
|
refX, refY, refZ);
|
|
|
|
return planes;
|
|
}
|
|
|
|
private static int computePlane(float[] out, int start,
|
|
float p0x, float p0y, float p0z,
|
|
float p1x, float p1y, float p1z,
|
|
float p2x, float p2y, float p2z,
|
|
float refX, float refY, float refZ) {
|
|
float e1x = p1x - p0x, e1y = p1y - p0y, e1z = p1z - p0z;
|
|
float e2x = p2x - p0x, e2y = p2y - p0y, e2z = p2z - p0z;
|
|
|
|
float nx = e1y * e2z - e1z * e2y;
|
|
float ny = e1z * e2x - e1x * e2z;
|
|
float nz = e1x * e2y - e1y * e2x;
|
|
|
|
float d = -(nx * p0x + ny * p0y + nz * p0z);
|
|
float val = nx * refX + ny * refY + nz * refZ + d;
|
|
|
|
if (val < 0.0f) {
|
|
nx = -nx;
|
|
ny = -ny;
|
|
nz = -nz;
|
|
d = -d;
|
|
}
|
|
|
|
float len = (float) Math.sqrt(nx * nx + ny * ny + nz * nz);
|
|
nx /= len;
|
|
ny /= len;
|
|
nz /= len;
|
|
|
|
d = -(nx * p0x + ny * p0y + nz * p0z);
|
|
|
|
out[start] = nx;
|
|
out[start + 1] = ny;
|
|
out[start + 2] = nz;
|
|
out[start + 3] = d;
|
|
|
|
return start + 4;
|
|
}
|
|
|
|
public void apply(@NonNull Builder builder) {
|
|
this.fov = builder.fov;
|
|
this.aspect = builder.aspect;
|
|
this.near = builder.near;
|
|
this.far = builder.far;
|
|
}
|
|
|
|
public void updateFrustum() {
|
|
Vec3 eye = this.player.getEyePosition();
|
|
Vec3 look = this.player.getLookAngle();
|
|
this.planes = buildFrustumPlanes(
|
|
(float) eye.x, (float) eye.y, (float) eye.z,
|
|
(float) look.x, (float) look.y, (float) look.z,
|
|
0.0f, 1.0f, 0.0f,
|
|
this.fov, this.aspect, this.near, this.far
|
|
);
|
|
}
|
|
|
|
public void far(float far) {
|
|
this.far = far;
|
|
}
|
|
|
|
public boolean isVisibleFor(@NonNull AABB box) {
|
|
final float[] planes = this.planes;
|
|
|
|
for (int i = 0; i < 6; i++) {
|
|
int base = i << 2;
|
|
float nx = planes[base], ny = planes[base+1], nz = planes[base+2], d = planes[base+3];
|
|
float px = (nx >= 0) ? (float) box.maxX : (float) box.minX;
|
|
float py = (ny >= 0) ? (float) box.maxY : (float) box.minY;
|
|
float pz = (nz >= 0) ? (float) box.maxZ : (float) box.minZ;
|
|
|
|
if (nx * px + ny * py + nz * pz + d < 0) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
} |