refactor(noise): fix naming issues / file organisation #221
Conversation
WalkthroughThe changes in this pull request involve modifications to the Changes
Possibly related PRs
🪧 TipsChatThere are 3 ways to chat with CodeRabbit:
Note: Be mindful of the bot's finite context window. It's strongly recommended to break down tasks such as reading entire modules into smaller chunks. For a focused discussion, use review comments to chat about specific files and their changes, instead of using the PR comments. CodeRabbit Commands (Invoked using PR comments)
Other keywords and placeholders
CodeRabbit Configuration File (
|
|
I also renamed the |
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 1
🧹 Outside diff range and nitpick comments (11)
noise/noise.v (1)
Line range hint
1-18: Well-structured foundation for noise generationThe Generator struct and its methods provide a clean, well-encapsulated foundation for both Perlin and Simplex noise implementations. The consistent naming and clear separation of concerns support the PR's goal of better file organization.
noise/perlin_test.v (1)
6-13: Consider enhancing test coverage and documentation.While the test implementation is correct, consider these improvements:
- Add test cases for edge cases (e.g., 0.0, 1.0, negative values)
- Document the derivation of the expected value
- Define the tolerance as a named constant
+const tolerance = 1.0e-6 + fn test_perlin_2d() { + // Fixed seed for reproducible test results rand.seed([u32(3155200429), u32(3208395956)]) mut gen := Generator.new() gen.randomize() + // Test case: Known value at (0.125, 0.125) + // Expected value derived from reference implementation result := gen.perlin_2d(0.125, 0.125) expected := 0.4948387311305851 - assert float64.tolerance(result, expected, 1.0e-6) + assert float64.tolerance(result, expected, tolerance) + + // Additional test cases for edge conditions + edge_cases := [ + (0.0, 0.0), + (1.0, 1.0), + (-0.5, 0.5) + ] + for point in edge_cases { + _ := gen.perlin_2d(point.0, point.1) // Ensure no panics + } }noise/simplex.v (1)
Line range hint
166-387: Consider improving readability of long gradient function calls.While the parameter renaming and implementation are correct, some gradient function calls span multiple lines and could be formatted more readably. Consider introducing intermediate variables for the permission calculations.
Example for lines 237-238:
- n0 = t0 * t0 * simplex_grad_3d(gen.perm[ii + gen.perm[jj + gen.perm[kk]]], x0, - y0, z0) + perm_index := gen.perm[ii + gen.perm[jj + gen.perm[kk]]] + n0 = t0 * t0 * simplex_grad_3d(perm_index, x0, y0, z0)This pattern could be applied to similar instances throughout the 3D and 4D implementations to improve code clarity.
noise/perlin.v (8)
3-3: Correct grammatical error in function commentIn the comment for
perlin_2d, "return" should be "returns" for correct grammar.Apply this diff to correct the comment:
-// perlin_2d is a function that return a single value of perlin gen for a given 2d position +// perlin_2d is a function that returns a single value of Perlin noise for a given 2D position
28-28: Correct grammatical error in function commentIn the comment for
perlin_3d, "return" should be "returns" for correct grammar.Apply this diff to correct the comment:
-// perlin_3d is a function that return a single value of perlin gen for a given 3d position +// perlin_3d is a function that returns a single value of Perlin noise for a given 3D position
93-93: Correct grammatical error in function commentIn the comment for
lerp, "return" should be "returns" for correct grammar.Apply this diff to correct the comment:
-// lerp is a function that return a linear interpolation value for 2 given values and a factor +// lerp is a function that returns a linear interpolation value between two given values based on a factor
99-99: Correct grammatical error in function commentIn the comment for
fade, "return" should be "returns" for correct grammar.Apply this diff to correct the comment:
-// fade is a function that return a fade value for a given value +// fade is a function that returns a fade value for a given input
105-105: Correct grammatical error in function commentIn the comment for
perlin_grad_2d, "return" should be "returns" for correct grammar.Apply this diff to correct the comment:
-// perlin_grad_2d is a function that return a gradient value for a given hash and 2d position +// perlin_grad_2d is a function that returns a gradient value for a given hash and 2D position
72-90: Simplify duplicate cases inperlin_grad_3dmatch statementThere are duplicate return values in the
matchstatement ofperlin_grad_3d, which can be combined to reduce redundancy and improve readability.For example, you can combine cases that have the same return value:
fn perlin_grad_3d(hash int, x f64, y f64, z f64) f64 { match hash & 0xF { - 0x0 { return x + y } - 0x1 { return -x + y } - 0x2 { return x - y } - 0x3 { return -x - y } - 0x4 { return x + z } - 0x5 { return -x + z } - 0x6 { return x - z } - 0x7 { return -x - z } - 0x8 { return y + z } - 0x9 { return -y + z } - 0xA { return y - z } - 0xB { return -y - z } - 0xC { return y + x } - 0xD { return -y + z } - 0xE { return y - x } - 0xF { return -y - z } + 0x0, 0xC { return x + y } + 0x1 { return -x + y } + 0x2 { return x - y } + 0x3 { return -x - y } + 0x4 { return x + z } + 0x5 { return -x + z } + 0x6 { return x - z } + 0x7 { return -x - z } + 0x8 { return y + z } + 0x9, 0xD { return -y + z } + 0xA { return y - z } + 0xB, 0xF { return -y - z } + 0xE { return y - x } else { return 0 } } }
107-125: Simplify duplicate cases inperlin_grad_2dmatch statementSeveral cases in the
matchstatement ofperlin_grad_2dreturn the same value. Combining these cases can make the code cleaner.For example:
fn perlin_grad_2d(hash int, x f64, y f64) f64 { match hash & 0xF { - 0x0 { return x + y } - 0x1 { return -x + y } - 0x2 { return x - y } - 0x3 { return -x - y } - 0x4 { return x } - 0x5 { return -x } - 0x6 { return x } - 0x7 { return -x } - 0x8 { return y } - 0x9 { return -y } - 0xA { return y } - 0xB { return -y } - 0xC { return y + x } - 0xD { return -y } - 0xE { return y - x } - 0xF { return -y } + 0x0 { return x + y } + 0x1 { return -x + y } + 0x2 { return x - y } + 0x3 { return -x - y } + 0x4, 0x6 { return x } + 0x5, 0x7 { return -x } + 0x8, 0xA { return y } + 0x9, 0xB, 0xD, 0xF { return -y } + 0xC { return y + x } + 0xE { return y - x } else { return 0 } } }
40-55: Improve variable naming for clarity inperlin_3dfunctionThe variable names like
pxi_yi,pxi_yi1,aaa,aba, etc., can be hard to understand. Consider using more descriptive names to enhance readability.For example:
- pxi := gen.perm[xi] - pxi_yi := gen.perm[pxi + yi] - pxi_yi1 := gen.perm[pxi + yi + 1] - pxi1 := gen.perm[xi + 1] - pxi1_yi := gen.perm[pxi1 + yi] - pxi1_yi1 := gen.perm[pxi1 + yi + 1] + perm_xi := gen.perm[xi] + perm_xi_yi := gen.perm[perm_xi + yi] + perm_xi_yi1 := gen.perm[perm_xi + yi + 1] + perm_xi1 := gen.perm[xi + 1] + perm_xi1_yi := gen.perm[perm_xi1 + yi] + perm_xi1_yi1 := gen.perm[perm_xi1 + yi + 1] - aaa := gen.perm[pxi_yi + zi] - aba := gen.perm[pxi_yi1 + zi] - aab := gen.perm[pxi_yi + zi + 1] - abb := gen.perm[pxi_yi1 + zi + 1] - baa := gen.perm[pxi1_yi + zi] - bba := gen.perm[pxi1_yi1 + zi] - bab := gen.perm[pxi1_yi + zi + 1] - bbb := gen.perm[pxi1_yi1 + zi + 1] + hash_aaa := gen.perm[perm_xi_yi + zi] + hash_aba := gen.perm[perm_xi_yi1 + zi] + hash_aab := gen.perm[perm_xi_yi + zi + 1] + hash_abb := gen.perm[perm_xi_yi1 + zi + 1] + hash_baa := gen.perm[perm_xi1_yi + zi] + hash_bba := gen.perm[perm_xi1_yi1 + zi] + hash_bab := gen.perm[perm_xi1_yi + zi + 1] + hash_bbb := gen.perm[perm_xi1_yi1 + zi + 1]
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
📒 Files selected for processing (9)
noise/noise.v(1 hunks)noise/perlin.v(1 hunks)noise/perlin2d.v(0 hunks)noise/perlin2d_test.v(0 hunks)noise/perlin3d.v(0 hunks)noise/perlin3d_test.v(0 hunks)noise/perlin_test.v(1 hunks)noise/simplex.v(16 hunks)noise/simplex_test.v(1 hunks)
💤 Files with no reviewable changes (4)
- noise/perlin2d.v
- noise/perlin2d_test.v
- noise/perlin3d.v
- noise/perlin3d_test.v
✅ Files skipped from review due to trivial changes (1)
- noise/simplex_test.v
🔇 Additional comments (5)
noise/noise.v (1)
17-18: LGTM! Parameter rename improves clarity
The change from generator to gen for the receiver parameter follows V's idiomatic conventions for receiver parameter naming. This makes the code more consistent with the rest of the codebase while maintaining clear readability.
noise/perlin_test.v (2)
1-5: LGTM! Module declaration and imports are well-structured.
The imports are appropriate for the testing requirements, and the module name follows the new organization structure.
1-22: Verify file organization and naming consistency.
Let's ensure this file organization aligns with the PR objectives and check for any remaining naming inconsistencies.
✅ Verification successful
File organization and naming patterns are consistent
The verification shows that:
- Test files follow a consistent organization pattern within the
noisemodule - Function naming follows a clear and consistent pattern (
perlin_2d,perlin_3d, etc.) - Implementation and test files are properly separated (
perlin.v,perlin_test.v) - No legacy files or inconsistent naming patterns were found
🏁 Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash
# Description: Check file organization and naming patterns
# Check if old files still exist
echo "Checking for old file structure..."
fd "perlin_(2|3)d.*\.v$"
# Check for inconsistent naming patterns
echo "Checking for inconsistent function naming patterns..."
rg "perlin.*d|simplex.*d" --type v
# Check test file organization
echo "Checking test file organization..."
fd "test\.v$" -d 2
Length of output: 1109
Script:
#!/bin/bash
# Let's check the content of both noise test files and the implementation files
echo "Checking noise module test and implementation files..."
rg "fn.*perlin.*d|fn.*simplex.*d" -A 2
# Check for any potential old implementation files
echo "Checking for implementation files..."
fd "^(perlin|simplex).*\.v$" --exclude "*test.v"
Length of output: 3053
noise/simplex.v (2)
Line range hint 28-91: Well-structured gradient function renaming!
The addition of the 'simplex_' prefix to gradient functions improves clarity and maintains consistency with the module's naming conventions. The documentation and implementation remain clear and correct.
Line range hint 94-163: Consistent parameter renaming in 1D and 2D implementations.
The parameter renaming from 'generator' to 'gen' improves code conciseness while maintaining readability. The gradient function calls have been correctly updated to use the new names.
There was a problem hiding this comment.
Actionable comments posted: 1
🧹 Nitpick comments (2)
noise/perlin_test.v (1)
13-25: Enhance test coverage with additional test cases.While the current tests verify specific points, consider adding:
- Edge cases (0.0, 1.0, negative values)
- Property-based tests to verify noise characteristics
- Documentation explaining the source/derivation of expected values
Example enhancement for
test_perlin_2d:fn test_perlin_2d() { gen := setup_generator()! // Test known reference value result := gen.perlin_2d(0.125, 0.125) expected := 0.4948387311305851 assert float64.tolerance(result, expected, 1.0e-6) // Test edge cases edge_cases := [ (0.0, 0.0), (1.0, 1.0), (-0.5, 0.5) ] for point in edge_cases { _ := gen.perlin_2d(point.0, point.1) // Ensure no panics } // Test basic noise properties // Values should be in [-1, 1] range for x in [-1.0, -0.5, 0.0, 0.5, 1.0] { for y in [-1.0, -0.5, 0.0, 0.5, 1.0] { value := gen.perlin_2d(x, y) assert value >= -1.0 && value <= 1.0 } } }noise/simplex_test.v (1)
13-39: Standardize test points across noise implementations.The test points differ between Perlin and Simplex noise tests. Consider:
- Using consistent test points to enable direct comparison
- Adding similar edge cases and property tests as suggested for Perlin
- Documenting why these specific test points were chosen
Additionally, consider adding noise-specific property tests. For example, Simplex noise should exhibit:
- Continuous gradients
- Lower directional artifacts compared to Perlin
- Approximately uniform distribution in [-1, 1]
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (2)
noise/perlin_test.v(1 hunks)noise/simplex_test.v(1 hunks)
⏰ Context from checks skipped due to timeout of 90000ms (6)
- GitHub Check: run-tests-on-linux (ubuntu-20.04, --prod)
- GitHub Check: run-tests-on-linux (ubuntu-20.04)
- GitHub Check: run-tests-on-linux (ubuntu-22.04, --prod)
- GitHub Check: run-tests-on-macos (macos-latest, --prod)
- GitHub Check: run-tests-on-linux (ubuntu-22.04)
- GitHub Check: run-tests-on-macos (macos-latest)
🔇 Additional comments (1)
noise/perlin_test.v (1)
6-11: Great implementation of the suggested helper function!The
setup_generator()function effectively reduces code duplication across tests by extracting the common setup logic, as suggested in the previous review.
There was a problem hiding this comment.
Actionable comments posted: 1
🧹 Nitpick comments (2)
noise/perlin.v (2)
15-36: Consider optimizing redundant gradient patternsThe gradient function contains some repetitive patterns where multiple cases return the same value:
- Cases 0x4 and 0x6 both return
x- Cases 0x5 and 0x7 both return
-x- Cases 0x8 and 0xA both return
y- Cases 0x9 and 0xB both return
-yAlso, the
elsecase is unnecessary since the match already covers all possible values ofhash & 0xF.fn perlin_grad_2d(hash int, x f64, y f64) f64 { match hash & 0xF { 0x0 { return x + y } 0x1 { return -x + y } 0x2 { return x - y } 0x3 { return -x - y } 0x4, 0x6 { return x } 0x5, 0x7 { return -x } 0x8, 0xA { return y } 0x9, 0xB { return -y } 0xC { return y + x } 0xD { return -y } 0xE { return y - x } 0xF { return -y } - else { return 0 } } }
86-126: Well-implemented 3D Perlin noise function with minor formatting issuesThe 3D Perlin noise implementation correctly extends the algorithm to handle three dimensions. However, there are some line breaks in the middle of function calls (lines 114-117 and 120-122) that could be improved for readability.
Consider reformatting the long lines to avoid breaking in the middle of function parameters:
- mut x1 := lerp(perlin_grad_3d(aaa, xf, yf, zf), perlin_grad_3d(baa, xf - 1, yf, zf), - u) + mut x1 := lerp( + perlin_grad_3d(aaa, xf, yf, zf), + perlin_grad_3d(baa, xf - 1, yf, zf), + u + )
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (1)
noise/perlin.v(1 hunks)
⏰ Context from checks skipped due to timeout of 90000ms (8)
- GitHub Check: run-tests-on-linux (ubuntu-20.04, --prod)
- GitHub Check: run-tests-on-linux (ubuntu-20.04)
- GitHub Check: run-tests-on-linux (ubuntu-24.04, --prod)
- GitHub Check: run-tests-on-linux (ubuntu-22.04)
- GitHub Check: run-tests-on-linux (ubuntu-22.04, --prod)
- GitHub Check: run-tests-on-linux (ubuntu-24.04)
- GitHub Check: run-tests-on-macos (macos-latest)
- GitHub Check: run-tests-on-macos (macos-latest, --prod)
🔇 Additional comments (3)
noise/perlin.v (3)
3-13: Good implementation of utility functionsThe
lerpandfadefunctions are correctly implemented with the standard formulas used in Perlin noise generation. The@[inline]attribute is appropriately used for these small, frequently called functions.
61-84: Well-implemented 2D Perlin noise functionThe
perlin_2dfunction correctly implements the standard Perlin noise algorithm. The code is clean, efficient, and follows the established pattern for 2D noise generation with proper gradient interpolation.
1-127: Overall: Good consolidation of Perlin noise functionalityThis new file successfully consolidates 2D and 3D Perlin noise functionality into a single file, with consistent naming conventions using underscores (e.g.,
perlin_2dinstead ofperlin2d). The implementation follows standard Perlin noise algorithms and provides a clean API for noise generation.These changes align well with the PR objectives to fix naming issues and improve file organization.
There was a problem hiding this comment.
Actionable comments posted: 1
🧹 Nitpick comments (1)
noise/perlin.v (1)
39-59: The 3D gradient function fixes have been applied correctlyThe issues mentioned in the previous review comment have been addressed:
- Case 0xD now returns
-y + xinstead of the incorrect-y + z- Case 0xF now returns
-y - xinstead of the duplicate-y - zHowever, the redundant
else { return 0 }case is still present and could be removed, as hash & 0xF will always result in a value between 0 and 15.fn perlin_grad_3d(hash int, x f64, y f64, z f64) f64 { match hash & 0xF { 0x0 { return x + y } 0x1 { return -x + y } 0x2 { return x - y } 0x3 { return -x - y } 0x4 { return x + z } 0x5 { return -x + z } 0x6 { return x - z } 0x7 { return -x - z } 0x8 { return y + z } 0x9 { return -y + z } 0xA { return y - z } 0xB { return -y - z } 0xC { return y + x } 0xD { return -y + x } 0xE { return y - x } 0xF { return -y - x } - else { return 0 } } }
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (1)
noise/perlin.v(1 hunks)
⏰ Context from checks skipped due to timeout of 90000ms (8)
- GitHub Check: run-tests-on-linux (ubuntu-20.04, --prod)
- GitHub Check: run-tests-on-linux (ubuntu-20.04)
- GitHub Check: run-tests-on-linux (ubuntu-22.04, --prod)
- GitHub Check: run-tests-on-linux (ubuntu-24.04)
- GitHub Check: run-tests-on-linux (ubuntu-22.04)
- GitHub Check: run-tests-on-linux (ubuntu-24.04, --prod)
- GitHub Check: run-tests-on-macos (macos-latest)
- GitHub Check: run-tests-on-macos (macos-latest, --prod)
🔇 Additional comments (4)
noise/perlin.v (4)
3-7: LGTM: Linear interpolation function is well-implementedThe
lerpfunction is correctly implemented for linear interpolation, and the@[inline]annotation is appropriate for this small utility function that will be called frequently during noise generation.
9-13: LGTM: Fade function uses standard quintic curveThe
fadefunction correctly implements the standard quintic curve (6t⁵-15t⁴+10t³) used in Perlin noise to smooth interpolation between lattice points. The@[inline]annotation is appropriate here as well.
62-84: LGTM: Clean implementation of 2D Perlin noiseThe
perlin_2dfunction correctly implements the standard 2D Perlin noise algorithm:
- Calculates integer and fractional parts of coordinates
- Applies the fade function for smooth interpolation
- Uses the permutation array to determine gradient values
- Performs linear interpolation to compute the final noise value
- Normalizes the result to the [0,1] range
The implementation is clean and efficient.
87-126: LGTM: 3D Perlin noise implementation follows correct algorithmThe
perlin_3dfunction properly extends the 2D implementation to 3D space. The additional dimension is handled correctly with appropriate variable naming and interpolation across all three axes. The code is well-structured despite the increased complexity required for 3D noise generation.
There was a problem hiding this comment.
Actionable comments posted: 0
🧹 Nitpick comments (2)
noise/perlin.v (2)
38-59: Redundant else case in perlin_grad_3d functionThe gradient function looks good with the previously suggested fixes implemented, but the
else { 0 }case is redundant sincehash & 0xFwill always result in a value between 0 and 15.fn perlin_grad_3d(hash int, x f64, y f64, z f64) f64 { return match hash & 0xF { 0x0 { x + y } 0x1 { -x + y } 0x2 { x - y } 0x3 { -x - y } 0x4 { x + z } 0x5 { -x + z } 0x6 { x - z } 0x7 { -x - z } 0x8 { y + z } 0x9 { -y + z } 0xA { y - z } 0xB { -y - z } 0xC { y + x } 0xD { -y + x } 0xE { y - x } 0xF { -y - x } - else { 0 } } }
114-124: Inconsistent use ofmutkeyword with variablesThere's an inconsistency in how variables are declared in the
perlin_3dfunction. The variablesx1andx2are declared withmut, buty1andy2are not, even though they serve similar roles in the interpolation logic.Either all of these variables should be declared with
mut(if they might be modified later) or none of them should (if they're only assigned once). Sincey1andy2are only assigned once and not modified, it would be more consistent to remove themutfromx1andx2.- mut x1 := lerp(perlin_grad_3d(aaa, xf, yf, zf), perlin_grad_3d(baa, xf - 1, yf, zf), + x1 := lerp(perlin_grad_3d(aaa, xf, yf, zf), perlin_grad_3d(baa, xf - 1, yf, zf), u) - mut x2 := lerp(perlin_grad_3d(aba, xf, yf - 1, zf), perlin_grad_3d(bba, xf - 1, yf - 1, + x2 := lerp(perlin_grad_3d(aba, xf, yf - 1, zf), perlin_grad_3d(bba, xf - 1, yf - 1, zf), u) y1 := lerp(x1, x2, v) x1 = lerp(perlin_grad_3d(aab, xf, yf, zf - 1), perlin_grad_3d(bab, xf - 1, yf, zf - 1), u) x2 = lerp(perlin_grad_3d(abb, xf, yf - 1, zf - 1), perlin_grad_3d(bbb, xf - 1, yf - 1, zf - 1), u) y2 := lerp(x1, x2, v)
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (1)
noise/perlin.v(1 hunks)
⏰ Context from checks skipped due to timeout of 90000ms (3)
- GitHub Check: run-tests-on-linux (ubuntu-20.04)
- GitHub Check: run-tests-on-linux (ubuntu-22.04)
- GitHub Check: run-tests-on-linux (ubuntu-24.04)
🔇 Additional comments (4)
noise/perlin.v (4)
15-36: Inconsistencies and duplications in 2D gradient function need attentionThe
perlin_grad_2dfunction has several issues that should be addressed:
There are duplicated cases:
- Cases 0x4 and 0x6 both return
x- Cases 0x5 and 0x7 both return
-x- Cases 0x8 and 0xA both return
y- Cases 0x9 and 0xB both return
-yThere are asymmetries in the pattern:
- Case 0xC returns
y + xbut case 0xD only returns-y- Case 0xE returns
y - xbut case 0xF only returns-yThe
else { 0 }case is redundant sincehash & 0xFwill always result in a value between 0 and 15fn perlin_grad_2d(hash int, x f64, y f64) f64 { return match hash & 0xF { 0x0 { x + y } 0x1 { -x + y } 0x2 { x - y } 0x3 { -x - y } 0x4 { x } 0x5 { -x } 0x6 { x } 0x7 { -x } 0x8 { y } 0x9 { -y } 0xA { y } 0xB { -y } 0xC { y + x } - 0xD { -y } + 0xD { -y + x } 0xE { y - x } - 0xF { -y } + 0xF { -y - x } - else { 0 } } }
61-84: The 2D Perlin noise implementation looks goodThe implementation of the
perlin_2dfunction uses the correct approach for generating Perlin noise. It properly calculates grid indices, interpolation factors, and applies gradient functions to compute the final noise value.
86-126: The 3D Perlin noise implementation looks goodThe implementation of the
perlin_3dfunction correctly extends the 2D approach to the third dimension. The interpolation logic and gradient functions are properly applied to generate 3D Perlin noise.
3-13: Well-implemented utility functions with good optimizationsThe
lerpandfadefunctions are correctly implemented and appropriately marked with the@[inline]attribute for performance optimization. These are standard implementations for Perlin noise generation.
This PR cleans up some naming issues that slipped through when I added Perlin and Simplex noise.
Some functions were named like noisetype_dimension, while others used noisetypedimensions without underscore. It got a bit confusing, so I’ve fixed everything to be consistent now.
I also combined the perlin_2d and perlin_3d files into a single perlin file to match how the Simplex code is organized. Same thing for the test files.
Summary by CodeRabbit
New Features
Bug Fixes
Chores