Functions — github.com/KdotJPG/OpenSimplex2

CodeHub MCPcopy Create free account

hub / github.com/KdotJPG/OpenSimplex2 / functions

Functions291 in github.com/KdotJPG/OpenSimplex2

⨍ Functions 291◇ Types & classes 76

↓ 53 callersMethodextrapolate

(int xsb, int ysb, double dx, double dy)

_old/java/legacy_unoptimized/OpenSimplexUnoptimized.java:2109

↓ 44 callersFunctionfastFloor

_old/c/OpenSimplex2F.c:583

↓ 25 callersMethodgrad

(long seed, long xsvp, long ysvp, float dx, float dy)

java/OpenSimplex2S.java:541

↓ 16 callersFunctionnoise4_Base

* 4D OpenSimplex2F noise base. * Current implementation not fully optimized by lookup tables. * But still comes out slightly ahead of Gustavson's Si

_old/c/OpenSimplex2F.c:757

↓ 14 callersFunctiongrad3

( seed: Wrapping<i64>, xrvp: Wrapping<i64>, yrvp: Wrapping<i64>, zrvp: Wrapping<i64>, dx:

rust/smooth.rs:741

↓ 13 callersFunctionfastFloor

rust/smooth.rs:777

↓ 13 callersMethodfastFloor

_old/java/OpenSimplex2S.java:313

↓ 13 callersMethodfastFloor

java/OpenSimplex2S.java:565

↓ 12 callersFunctionnoise3_BCC

* Generate overlapping cubic lattices for 3D Re-oriented BCC noise. * Lookup table implementation inspired by DigitalShadow. * It was actually faste

_old/c/OpenSimplex2F.c:633

↓ 10 callersFunctiongrad2

(seed: Wrapping<i64>, xsvp: Wrapping<i64>, ysvp: Wrapping<i64>, dx: f32, dy: f32)

rust/smooth.rs:732

↓ 9 callersMethodfastFloor

_old/java/OpenSimplex2F.java:380

↓ 9 callersMethodfastFloor

_old/java/legacy/OpenSimplex.java:355

↓ 9 callersMethodfastFloor

_old/java/legacy_unoptimized/OpenSimplexUnoptimized.java:2127

↓ 9 callersMethodgrad

(long seed, long xsvp, long ysvp, float dx, float dy)

java/OpenSimplex2.java:445

↓ 8 callersFunctionnew_LatticePoint3D

_old/c/OpenSimplex2F.c:77

↓ 8 callersFunctionnoise2_Base

* 2D Simplex noise base. * Lookup table implementation inspired by DigitalShadow. */

_old/c/OpenSimplex2F.c:593

↓ 6 callersFunctionfastFloor

rust/fast.rs:561

↓ 6 callersMethodfastFloor

java/OpenSimplex2.java:469

↓ 5 callersFunctionnoise4_UnskewedBase

4D OpenSimplex2 noise base. */

rust/fast.rs:414

↓ 5 callersFunctionnoise4_UnskewedBase

4D SuperSimplex noise base. Using ultra-simple 4x4x4x4 lookup partitioning. This isn't as elegant or SIMD/GPU/etc. portable as other approache

rust/smooth.rs:662

↓ 5 callersMethodnoise4_UnskewedBase

4D OpenSimplex2 noise base.

java/OpenSimplex2.java:360

↓ 5 callersMethodnoise4_UnskewedBase

4D SuperSimplex noise base. Using ultra-simple 4x4x4x4 lookup partitioning. This isn't as elegant or SIMD/GPU/etc. portable as other approaches, but i

java/OpenSimplex2S.java:500

↓ 4 callersMethodeval4_Base

(double xs, double ys, double zs, double ws)

_old/java/legacy/OpenSimplex.java:220

↓ 4 callersMethodeval4_Base

(double xs, double ys, double zs, double ws)

_old/java/legacy_unoptimized/OpenSimplexUnoptimized.java:809

↓ 4 callersFunctiongetStaticData

rust/smooth.rs:829

↓ 4 callersFunctiongrad2

(seed: Wrapping<i64>, xsvp: Wrapping<i64>, ysvp: Wrapping<i64>, dx: f32, dy: f32)

rust/fast.rs:516

↓ 4 callersFunctiongrad3

( seed: Wrapping<i64>, xrvp: Wrapping<i64>, yrvp: Wrapping<i64>, zrvp: Wrapping<i64>, dx:

rust/fast.rs:525

↓ 4 callersFunctionnew_LatticePoint2D

_old/c/OpenSimplex2F.c:60

↓ 4 callersMethodnoise4_Base

4D SuperSimplex noise base. Using ultra-simple 4x4x4x4 lookup partitioning. This isn't as elegant or SIMD/GPU/etc. portable as other approaches, but i

_old/java/OpenSimplex2S.java:275

↓ 4 callersMethodnoise4_Base

4D OpenSimplex2F noise base. Current implementation not fully optimized by lookup tables. But still comes out slightly ahead of Gustavson's Simplex in

_old/java/OpenSimplex2F.java:268

↓ 3 callersFunctionOpenSimplex2F_noise4_Classic

* 4D OpenSimplex2F noise, classic lattice orientation. */

_old/c/OpenSimplex2F.c:869

↓ 3 callersMethodeval3_Base

(double xs, double ys, double zs)

_old/java/legacy/OpenSimplex.java:133

↓ 3 callersMethodeval3_Base

(double xs, double ys, double zs)

_old/java/legacy_unoptimized/OpenSimplexUnoptimized.java:222

↓ 3 callersFunctionfastRound

rust/fast.rs:570

↓ 3 callersMethodfastRound

java/OpenSimplex2.java:474

↓ 3 callersFunctiongetGradients

rust/fast.rs:590

↓ 3 callersMethodnoise3_BCC

Generate overlapping cubic lattices for 3D Re-oriented BCC noise. Lookup table implementation inspired by DigitalShadow. It was actually faster to nar

_old/java/OpenSimplex2S.java:183

↓ 3 callersMethodnoise3_BCC

Generate overlapping cubic lattices for 3D Re-oriented BCC noise. Lookup table implementation inspired by DigitalShadow. It was actually faster to nar

_old/java/OpenSimplex2F.java:177

↓ 3 callersFunctionnoise3_UnrotatedBase

Generate overlapping cubic lattices for 3D OpenSimplex2 noise. */

rust/fast.rs:204

↓ 3 callersFunctionnoise3_UnrotatedBase

Generate overlapping cubic lattices for 3D Re-oriented BCC noise. Lookup table implementation inspired by DigitalShadow. It was actually faste

rust/smooth.rs:274

↓ 3 callersMethodnoise3_UnrotatedBase

Generate overlapping cubic lattices for 3D OpenSimplex2 noise.

java/OpenSimplex2.java:195

↓ 3 callersMethodnoise3_UnrotatedBase

Generate overlapping cubic lattices for 3D Re-oriented BCC noise. Lookup table implementation inspired by DigitalShadow. It was actually faster to nar

java/OpenSimplex2S.java:250

↓ 3 callersFunctionwrite_png_image

_old/c/test_OpenSimplex2F.c:16

↓ 2 callersFunctionOpenSimplex2F_free

_old/c/OpenSimplex2F.c:521

↓ 2 callersFunctioninitGradients

rust/fast.rs:599

↓ 2 callersFunctionnoise2

2D Simplex noise, standard lattice orientation. */

rust/fast.rs:49

↓ 2 callersMethodnoise2_Base

2D SuperSimplex noise base. Lookup table implementation inspired by DigitalShadow.

_old/java/OpenSimplex2S.java:79

↓ 2 callersMethodnoise2_Base

2D Simplex noise base. Lookup table implementation inspired by DigitalShadow.

_old/java/OpenSimplex2F.java:78

↓ 2 callersFunctionnoise2_ImproveX

2D Simplex noise, with Y pointing down the main diagonal. Might be better for a 2D sandbox style game, where Y is vertical. Probably slightly

rust/fast.rs:65

↓ 2 callersFunctionnoise2_UnskewedBase

2D Simplex noise base. */

rust/fast.rs:76

↓ 2 callersFunctionnoise2_UnskewedBase

2D OpenSimplex2S/SuperSimplex noise base. */

rust/smooth.rs:74

↓ 2 callersMethodnoise2_UnskewedBase

2D Simplex noise base.

java/OpenSimplex2.java:78

↓ 2 callersMethodnoise2_UnskewedBase

2D OpenSimplex2S/SuperSimplex noise base.

java/OpenSimplex2S.java:75

↓ 2 callersFunctionnoise3_Fallback

3D OpenSimplex2 noise, fallback rotation option Use noise3_ImproveXY or noise3_ImproveXZ instead, wherever appropriate. They have less diagona

rust/fast.rs:189

↓ 2 callersFunctionnoise3_ImproveXY

3D OpenSimplex2 noise, with better visual isotropy in (X, Y). Recommended for 3D terrain and time-varied animations. The Z coordinate should a

rust/fast.rs:146

↓ 2 callersFunctionnoise3_ImproveXZ

3D OpenSimplex2 noise, with better visual isotropy in (X, Z). Recommended for 3D terrain and time-varied animations. The Y coordinate should a

rust/fast.rs:169

↓ 2 callersFunctionnoise4_Fallback

4D OpenSimplex2 noise, fallback lattice orientation. */

rust/fast.rs:400

↓ 2 callersFunctionnoise4_ImproveXYZ

4D OpenSimplex2 noise, with XYZ oriented like noise3_Fallback and W for an extra degree of freedom. W repeats eventually. Recommended for time

rust/fast.rs:369

↓ 2 callersFunctionnoise4_ImproveXYZ_ImproveXY

4D OpenSimplex2 noise, with XYZ oriented like noise3_ImproveXY and W for an extra degree of freedom. W repeats eventually. Recommended for tim

rust/fast.rs:331

↓ 2 callersFunctionnoise4_ImproveXYZ_ImproveXZ

4D OpenSimplex2 noise, with XYZ oriented like noise3_ImproveXZ and W for an extra degree of freedom. W repeats eventually. Recommended for tim

rust/fast.rs:350

↓ 2 callersFunctionnoise4_ImproveXY_ImproveZW

4D OpenSimplex2 noise, with XY and ZW forming orthogonal triangular-based planes. Recommended for 3D terrain, where X and Y (or Z and W) are horiz

rust/fast.rs:386

↓ 1 callersFunctionOpenSimplex2F

_old/c/OpenSimplex2F.c:534

↓ 1 callersFunctionOpenSimplex2F_noise2

* 2D Simplex noise, standard lattice orientation. */

_old/c/OpenSimplex2F.c:668

↓ 1 callersFunctionOpenSimplex2F_noise3_Classic

* 3D Re-oriented 4-point BCC noise, classic orientation. * Proper substitute for 3D Simplex in light of Forbidden Formulae. * Use noise3_XYBeforeZ o

_old/c/OpenSimplex2F.c:696

↓ 1 callersFunctionOpenSimplex2F_shutdown

Free up all the LatticePoint stuff allocated in setup_lattice_points() */

_old/c/OpenSimplex2F.c:486

↓ 1 callersFunctionfind_unique_pointers

_old/c/OpenSimplex2F.c:86

↓ 1 callersFunctionfree_LatticePoint3D

_old/c/OpenSimplex2F.c:107

↓ 1 callersFunctiongrad4

( seed: Wrapping<i64>, xsvp: Wrapping<i64>, ysvp: Wrapping<i64>, zsvp: Wrapping<i64>, wsvp

rust/fast.rs:542

↓ 1 callersFunctiongrad4

( seed: Wrapping<i64>, xsvp: Wrapping<i64>, ysvp: Wrapping<i64>, zsvp: Wrapping<i64>, wsvp

rust/smooth.rs:758

↓ 1 callersFunctioninitStaticData

rust/smooth.rs:838

↓ 1 callersFunctionnew_LatticePoint4D

_old/c/OpenSimplex2F.c:122

↓ 1 callersFunctionsetup_gradients

_old/c/OpenSimplex2F.c:398

↓ 1 callersFunctionsetup_lattice_points

_old/c/OpenSimplex2F.c:429

MethodContribution2

(double multiplier, int xsb, int ysb)

_old/csharp/legacy/OpenSimplex.cs:677

MethodContribution2

(double multiplier, int xsb, int ysb)

_old/java/legacy/OpenSimplex.java:284

MethodContribution3

(double multiplier, int xsb, int ysb, int zsb)

_old/csharp/legacy/OpenSimplex.cs:692

MethodContribution3

(double multiplier, int xsb, int ysb, int zsb)

_old/java/legacy/OpenSimplex.java:297

MethodContribution4

(double multiplier, int xsb, int ysb, int zsb, int wsb)

_old/csharp/legacy/OpenSimplex.cs:709

MethodContribution4

(double multiplier, int xsb, int ysb, int zsb, int wsb)

_old/java/legacy/OpenSimplex.java:312

(double x, double y)

_old/csharp/legacy/OpenSimplex.cs:465

MethodEvaluate3_XYBeforeZ

Not as good as in SuperSimplex/OpenSimplex2S, since there are more visible differences between different slices. The Z coordinate should always be the

_old/csharp/legacy/OpenSimplex.cs:525

MethodEvaluate3_XZBeforeY

Similar to the above, except the Y coordinate should always be the "different" coordinate in your use case.

_old/csharp/legacy/OpenSimplex.cs:538

MethodFastFloor

_old/csharp/legacy/OpenSimplex.cs:426

MethodFastFloor

csharp/OpenSimplex2S.cs:592

MethodFastFloor

csharp/OpenSimplex2.cs:482

MethodFastRound

csharp/OpenSimplex2.cs:489

(long seed, long xsvp, long ysvp, float dx, float dy)

csharp/OpenSimplex2S.cs:562

(long seed, long xsvp, long ysvp, float dx, float dy)

csharp/OpenSimplex2.cs:452

(double dx, double dy)

_old/csharp/OpenSimplex2S.cs:1039

(double dx, double dy)

_old/csharp/OpenSimplex2F.cs:825

(double dx, double dy)

_old/csharp/legacy/OpenSimplex.cs:725

(double dx, double dy)

_old/java/OpenSimplex2S.java:723

(double dx, double dy)

_old/java/OpenSimplex2F.java:491

(double dx, double dy)

_old/java/legacy/OpenSimplex.java:326

(double dx, double dy)

_old/java/legacy_unoptimized/OpenSimplexUnoptimized.java:2134

(double dx, double dy, double dz)

_old/csharp/OpenSimplex2S.cs:1048

(double dx, double dy, double dz)

_old/csharp/OpenSimplex2F.cs:834

(double dx, double dy, double dz)

_old/csharp/legacy/OpenSimplex.cs:735

(double dx, double dy, double dz)

_old/java/OpenSimplex2S.java:730

(double dx, double dy, double dz)

_old/java/OpenSimplex2F.java:498

next →1–100 of 291, ranked by callers