Merge pull request #1208 from pirut/claude/upstream-perlin-floor

🤖 Agent: merged after verify passed and the integration run on the desktop (main 34c3c1cf + the 14 contributor PRs: workspace tests 1,869/0, launcher 113, parity --changed 320/0).
This commit is contained in:
Ludovic Marie
2026-10-22 19:54:05 +02:00
committed by GitHub
3 changed files with 74 additions and 12 deletions
+47 -1
View File
@@ -602,8 +602,18 @@ pub(crate) fn clamp(value: f64, min: f64, max: f64) -> f64 {
java_min(value, max)
}
}
/// `Mth.floor`, which is `(int) Math.floor(v)`: truncate, then step down for
/// negative fractions. A truncating conversion and a compare, where
/// `f64::floor` is a libm call on baseline x86-64. Both casts saturate (NaN is
/// 0), so the step down saturates too: below `i32::MIN` stays `i32::MIN`.
#[inline]
pub(crate) fn floor_i32(value: f64) -> i32 {
value.floor() as i32
let truncated = value as i32;
if value < f64::from(truncated) {
truncated.saturating_sub(1)
} else {
truncated
}
}
fn lerp(amount: f64, start: f64, end: f64) -> f64 {
start + amount * (end - start)
@@ -635,6 +645,42 @@ fn next_down(value: f64) -> f64 {
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn floor_i32_is_mths_floor() {
for v in [
0.0,
-0.0,
0.5,
-0.5,
1.0,
-1.0,
2.999,
-2.999,
1e-300,
-1e-300,
16_777_215.5,
-16_777_215.5,
// Past the i32 range `(int) Math.floor` saturates (vanilla 26.3's
// BlockCollisions and BlockPos.containing rely on it).
2_147_483_647.5,
2_147_483_648.0,
-2_147_483_648.0,
-2_147_483_648.5,
-2_147_483_649.0,
3e9,
-3e9,
f64::MAX,
f64::MIN,
f64::INFINITY,
f64::NEG_INFINITY,
] {
assert_eq!(floor_i32(v), v.floor() as i32, "{v}");
}
assert_eq!(floor_i32(f64::NAN), 0);
assert_eq!(floor_i32(-3e9), i32::MIN);
assert_eq!(floor_i32(-2_147_483_648.5), i32::MIN);
}
#[test]
fn ray_faces_and_half_open_bounds() {
let b = Aabb::block(BlockPos::new(0, 0, 0));
+20 -4
View File
@@ -61,8 +61,8 @@ impl GradientTable {
i32::from(self.permutations[(index & 255) as usize])
}
fn gradient(&self, index: i32) -> [i32; 3] {
GRADIENTS[(self.permute(index) & 15) as usize]
fn gradient(&self, index: i32) -> [f32; 3] {
PERLIN_GRADIENTS[(self.permute(index) & 15) as usize]
}
}
@@ -87,8 +87,24 @@ const GRADIENTS: [[i32; 3]; 16] = [
[0, -1, -1],
];
fn dot(gradient: [i32; 3], point: [f32; 3]) -> f32 {
gradient[0] as f32 * point[0] + gradient[1] as f32 * point[1] + gradient[2] as f32 * point[2]
/// [`GRADIENTS`] as floats, so a dot product needs no conversions: every
/// component is -1, 0 or 1, which a float holds exactly.
const PERLIN_GRADIENTS: [[f32; 3]; 16] = {
let mut out = [[0.0; 3]; 16];
let mut i = 0;
while i < 16 {
out[i] = [
GRADIENTS[i][0] as f32,
GRADIENTS[i][1] as f32,
GRADIENTS[i][2] as f32,
];
i += 1;
}
out
};
fn dot(gradient: [f32; 3], point: [f32; 3]) -> f32 {
gradient[0] * point[0] + gradient[1] * point[1] + gradient[2] * point[2]
}
/// Vanilla's periodic coordinate reduction with the normal Far Lands flag off.
+7 -7
View File
@@ -39,7 +39,7 @@ impl PerlinNoise {
)
}
fn gradients(&self, cell: [i32; 3]) -> [[i32; 3]; 8] {
fn gradients(&self, cell: [i32; 3]) -> [[f32; 3]; 8] {
self.gradients_at(
self.table.permute(cell[0]),
self.table.permute(cell[0].wrapping_add(1)),
@@ -52,7 +52,7 @@ impl PerlinNoise {
/// resolved. `add_volume` reuses one X column across every Y, so hoisting
/// the two X permutes out of that loop avoids repeating them per Y.
#[inline]
fn gradients_at(&self, p: i32, q: i32, cell_y: i32, cell_z: i32) -> [[i32; 3]; 8] {
fn gradients_at(&self, p: i32, q: i32, cell_y: i32, cell_z: i32) -> [[f32; 3]; 8] {
let lower = self.table.permute(p.wrapping_add(cell_y));
let upper = self.table.permute(p.wrapping_add(cell_y).wrapping_add(1));
let lower_x = self.table.permute(q.wrapping_add(cell_y));
@@ -66,7 +66,7 @@ impl PerlinNoise {
})
}
fn corner_values(gradients: [[i32; 3]; 8], point: [f32; 3]) -> [f32; 8] {
fn corner_values(gradients: [[f32; 3]; 8], point: [f32; 3]) -> [f32; 8] {
std::array::from_fn(|i| {
dot(
gradients[i],
@@ -99,7 +99,7 @@ impl PerlinNoise {
let values = Self::corner_values(gradients, point);
let fade = point.map(smoothstep);
let gradient =
std::array::from_fn::<_, 3, _>(|axis| lerp3(fade, gradients.map(|g| g[axis] as f32)));
std::array::from_fn::<_, 3, _>(|axis| lerp3(fade, gradients.map(|g| g[axis])));
let changes = [
lerp2(
fade[1],
@@ -211,9 +211,9 @@ impl PerlinNoise {
if previous_y != sample.cell {
let gradients = self.gradients_at(p, q, sample.cell, cell_z);
for i in 0..8 {
xz_dots[i] = gradients[i][0] as f32 * (dx - (i & 1) as f32)
+ gradients[i][2] as f32 * (dz - ((i >> 2) & 1) as f32);
y_gradients[i] = gradients[i][1] as f32;
xz_dots[i] = gradients[i][0] * (dx - (i & 1) as f32)
+ gradients[i][2] * (dz - ((i >> 2) & 1) as f32);
y_gradients[i] = gradients[i][1];
}
previous_y = sample.cell;
}