Skip to content

Commit bae5a7c

Browse files
Bigfoot71Bigfoot71
authored
[C] Align C API with C++ const correctness and fix header guard (#160)
* add const qualifiers to state pointer parameters * separate `FNL_IMPL` conditional from header include guard
1 parent 72f4ef7 commit bae5a7c

File tree

1 file changed

+48
-40
lines changed

1 file changed

+48
-40
lines changed

‎C/FastNoiseLite.h‎

Lines changed: 48 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -56,10 +56,6 @@
5656
typedef float FNLfloat;
5757
//typedef double FNLfloat;
5858

59-
#if defined(__cplusplus)
60-
extern "C" {
61-
#endif
62-
6359
#include <math.h>
6460
#include <stdint.h>
6561
#include <stdbool.h>
@@ -219,6 +215,10 @@ typedef struct fnl_state
219215
float domain_warp_amp;
220216
} fnl_state;
221217

218+
#if defined(__cplusplus)
219+
extern "C" {
220+
#endif
221+
222222
/**
223223
* Creates a noise state with default values.
224224
* @param seed Optionally set the state seed.
@@ -229,13 +229,13 @@ fnl_state fnlCreateState();
229229
* 2D noise at given position using the state settings
230230
* @returns Noise output bounded between -1 and 1.
231231
*/
232-
float fnlGetNoise2D(fnl_state *state, FNLfloat x, FNLfloat y);
232+
float fnlGetNoise2D(const fnl_state *state, FNLfloat x, FNLfloat y);
233233

234234
/**
235235
* 3D noise at given position using the state settings
236236
* @returns Noise output bounded between -1 and 1.
237237
*/
238-
float fnlGetNoise3D(fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z);
238+
float fnlGetNoise3D(const fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z);
239239

240240
/**
241241
* 2D warps the input position using current domain warp settings.
@@ -246,7 +246,7 @@ float fnlGetNoise3D(fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z);
246246
* noise = fnlGetNoise2D(&state, x, y);
247247
* ```
248248
*/
249-
void fnlDomainWarp2D(fnl_state *state, FNLfloat *x, FNLfloat *y);
249+
void fnlDomainWarp2D(const fnl_state *state, FNLfloat *x, FNLfloat *y);
250250

251251
/**
252252
* 3D warps the input position using current domain warp settings.
@@ -257,14 +257,24 @@ void fnlDomainWarp2D(fnl_state *state, FNLfloat *x, FNLfloat *y);
257257
* noise = fnlGetNoise3D(&state, x, y, z);
258258
* ```
259259
*/
260-
void fnlDomainWarp3D(fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z);
260+
void fnlDomainWarp3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z);
261+
262+
#if defined(__cplusplus)
263+
}
264+
#endif
265+
266+
#endif // FASTNOISELITE_H
261267

262268
// ====================
263269
// Below this line is the implementation
264270
// ====================
265271

266272
#if defined(FNL_IMPL)
267273

274+
#if defined(__cplusplus)
275+
extern "C" {
276+
#endif
277+
268278
// Constants
269279

270280
static const float GRADIENTS_2D[] =
@@ -458,7 +468,7 @@ static inline float _fnlPingPong(float t)
458468
return t < 1 ? t : 2 - t;
459469
}
460470

461-
static float _fnlCalculateFractalBounding(fnl_state *state)
471+
static float _fnlCalculateFractalBounding(const fnl_state *state)
462472
{
463473
float gain = _fnlFastAbs(state->gain);
464474
float amp = gain;
@@ -585,16 +595,16 @@ static float _fnlSingleSimplex2D(int seed, FNLfloat x, FNLfloat y);
585595
static float _fnlSingleOpenSimplex23D(int seed, FNLfloat x, FNLfloat y, FNLfloat z);
586596
static float _fnlSingleOpenSimplex2S2D(int seed, FNLfloat x, FNLfloat y);
587597
static float _fnlSingleOpenSimplex2S3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z);
588-
static float _fnlSingleCellular2D(fnl_state *state, int seed, FNLfloat x, FNLfloat y);
589-
static float _fnlSingleCellular3D(fnl_state *state, int seed, FNLfloat x, FNLfloat y, FNLfloat z);
598+
static float _fnlSingleCellular2D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y);
599+
static float _fnlSingleCellular3D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y, FNLfloat z);
590600
static float _fnlSinglePerlin2D(int seed, FNLfloat x, FNLfloat y);
591601
static float _fnlSinglePerlin3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z);
592602
static float _fnlSingleValueCubic2D(int seed, FNLfloat x, FNLfloat y);
593603
static float _fnlSingleValueCubic3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z);
594604
static float _fnlSingleValue2D(int seed, FNLfloat x, FNLfloat y);
595605
static float _fnlSingleValue3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z);
596606

597-
static float _fnlGenNoiseSingle2D(fnl_state *state, int seed, FNLfloat x, FNLfloat y)
607+
static float _fnlGenNoiseSingle2D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y)
598608
{
599609
switch (state->noise_type)
600610
{
@@ -615,7 +625,7 @@ static float _fnlGenNoiseSingle2D(fnl_state *state, int seed, FNLfloat x, FNLflo
615625
}
616626
}
617627

618-
static float _fnlGenNoiseSingle3D(fnl_state *state, int seed, FNLfloat x, FNLfloat y, FNLfloat z)
628+
static float _fnlGenNoiseSingle3D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y, FNLfloat z)
619629
{
620630
switch (state->noise_type)
621631
{
@@ -638,7 +648,7 @@ static float _fnlGenNoiseSingle3D(fnl_state *state, int seed, FNLfloat x, FNLflo
638648

639649
// Noise Coordinate Transforms (frequency, and possible skew or rotation)
640650

641-
static void _fnlTransformNoiseCoordinate2D(fnl_state *state, FNLfloat *x, FNLfloat *y)
651+
static void _fnlTransformNoiseCoordinate2D(const fnl_state *state, FNLfloat *x, FNLfloat *y)
642652
{
643653
*x *= state->frequency;
644654
*y *= state->frequency;
@@ -660,7 +670,7 @@ static void _fnlTransformNoiseCoordinate2D(fnl_state *state, FNLfloat *x, FNLflo
660670
}
661671
}
662672

663-
static void _fnlTransformNoiseCoordinate3D(fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z)
673+
static void _fnlTransformNoiseCoordinate3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z)
664674
{
665675
*x *= state->frequency;
666676
*y *= state->frequency;
@@ -709,7 +719,7 @@ static void _fnlTransformNoiseCoordinate3D(fnl_state *state, FNLfloat *x, FNLflo
709719

710720
// Domain Warp Coordinate Transforms
711721

712-
static void _fnlTransformDomainWarpCoordinate2D(fnl_state *state, FNLfloat *x, FNLfloat *y)
722+
static void _fnlTransformDomainWarpCoordinate2D(const fnl_state *state, FNLfloat *x, FNLfloat *y)
713723
{
714724
switch (state->domain_warp_type)
715725
{
@@ -728,7 +738,7 @@ static void _fnlTransformDomainWarpCoordinate2D(fnl_state *state, FNLfloat *x, F
728738
}
729739
}
730740

731-
static void _fnlTransformDomainWarpCoordinate3D(fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z)
741+
static void _fnlTransformDomainWarpCoordinate3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z)
732742
{
733743
switch (state->rotation_type_3d)
734744
{
@@ -772,7 +782,7 @@ static void _fnlTransformDomainWarpCoordinate3D(fnl_state *state, FNLfloat *x, F
772782
}
773783

774784
// Fractal FBm
775-
static float _fnlGenFractalFBM2D(fnl_state *state, FNLfloat x, FNLfloat y)
785+
static float _fnlGenFractalFBM2D(const fnl_state *state, FNLfloat x, FNLfloat y)
776786
{
777787
int seed = state->seed;
778788
float sum = 0;
@@ -792,7 +802,7 @@ static float _fnlGenFractalFBM2D(fnl_state *state, FNLfloat x, FNLfloat y)
792802
return sum;
793803
}
794804

795-
static float _fnlGenFractalFBM3D(fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z)
805+
static float _fnlGenFractalFBM3D(const fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z)
796806
{
797807
int seed = state->seed;
798808
float sum = 0;
@@ -815,7 +825,7 @@ static float _fnlGenFractalFBM3D(fnl_state *state, FNLfloat x, FNLfloat y, FNLfl
815825

816826
// Fractal Ridged
817827

818-
static float _fnlGenFractalRidged2D(fnl_state *state, FNLfloat x, FNLfloat y)
828+
static float _fnlGenFractalRidged2D(const fnl_state *state, FNLfloat x, FNLfloat y)
819829
{
820830
int seed = state->seed;
821831
float sum = 0;
@@ -835,7 +845,7 @@ static float _fnlGenFractalRidged2D(fnl_state *state, FNLfloat x, FNLfloat y)
835845
return sum;
836846
}
837847

838-
static float _fnlGenFractalRidged3D(fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z)
848+
static float _fnlGenFractalRidged3D(const fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z)
839849
{
840850
int seed = state->seed;
841851
float sum = 0;
@@ -858,7 +868,7 @@ static float _fnlGenFractalRidged3D(fnl_state *state, FNLfloat x, FNLfloat y, FN
858868

859869
// Fractal PingPong
860870

861-
static float _fnlGenFractalPingPong2D(fnl_state *state, FNLfloat x, FNLfloat y)
871+
static float _fnlGenFractalPingPong2D(const fnl_state *state, FNLfloat x, FNLfloat y)
862872
{
863873
int seed = state->seed;
864874
float sum = 0;
@@ -878,7 +888,7 @@ static float _fnlGenFractalPingPong2D(fnl_state *state, FNLfloat x, FNLfloat y)
878888
return sum;
879889
}
880890

881-
static float _fnlGenFractalPingPong3D(fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z)
891+
static float _fnlGenFractalPingPong3D(const fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z)
882892
{
883893
int seed = state->seed;
884894
float sum = 0;
@@ -1399,7 +1409,7 @@ static float _fnlSingleOpenSimplex2S3D(int seed, FNLfloat x, FNLfloat y, FNLfloa
13991409

14001410
// Cellular Noise
14011411

1402-
static float _fnlSingleCellular2D(fnl_state *state, int seed, FNLfloat x, FNLfloat y)
1412+
static float _fnlSingleCellular2D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y)
14031413
{
14041414
int xr = _fnlFastRound(x);
14051415
int yr = _fnlFastRound(y);
@@ -1524,7 +1534,7 @@ static float _fnlSingleCellular2D(fnl_state *state, int seed, FNLfloat x, FNLflo
15241534
}
15251535
}
15261536

1527-
static float _fnlSingleCellular3D(fnl_state *state, int seed, FNLfloat x, FNLfloat y, FNLfloat z)
1537+
static float _fnlSingleCellular3D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y, FNLfloat z)
15281538
{
15291539
int xr = _fnlFastRound(x);
15301540
int yr = _fnlFastRound(y);
@@ -1875,7 +1885,7 @@ static void _fnlSingleDomainWarpBasicGrid3D(int seed, float warpAmp, float frequ
18751885
static void _fnlSingleDomainWarpSimplexGradient(int seed, float warpAmp, float frequency, FNLfloat x, FNLfloat y, FNLfloat *xr, FNLfloat *yr, bool outGradOnly);
18761886
static void _fnlSingleDomainWarpOpenSimplex2Gradient(int seed, float warpAmp, float frequency, FNLfloat x, FNLfloat y, FNLfloat z, FNLfloat *xr, FNLfloat *yr, FNLfloat *zr, bool outGradOnly);
18771887

1878-
static inline void _fnlDoSingleDomainWarp2D(fnl_state *state, int seed, float amp, float freq, FNLfloat x, FNLfloat y, FNLfloat *xp, FNLfloat *yp)
1888+
static inline void _fnlDoSingleDomainWarp2D(const fnl_state *state, int seed, float amp, float freq, FNLfloat x, FNLfloat y, FNLfloat *xp, FNLfloat *yp)
18791889
{
18801890
switch (state->domain_warp_type)
18811891
{
@@ -1891,7 +1901,7 @@ static inline void _fnlDoSingleDomainWarp2D(fnl_state *state, int seed, float am
18911901
}
18921902
}
18931903

1894-
static inline void _fnlDoSingleDomainWarp3D(fnl_state *state, int seed, float amp, float freq, FNLfloat x, FNLfloat y, FNLfloat z, FNLfloat *xp, FNLfloat *yp, FNLfloat *zp)
1904+
static inline void _fnlDoSingleDomainWarp3D(const fnl_state *state, int seed, float amp, float freq, FNLfloat x, FNLfloat y, FNLfloat z, FNLfloat *xp, FNLfloat *yp, FNLfloat *zp)
18951905
{
18961906
switch (state->domain_warp_type)
18971907
{
@@ -1909,7 +1919,7 @@ static inline void _fnlDoSingleDomainWarp3D(fnl_state *state, int seed, float am
19091919

19101920
// Domain Warp Single Wrapper
19111921

1912-
static void _fnlDomainWarpSingle2D(fnl_state *state, FNLfloat *x, FNLfloat *y)
1922+
static void _fnlDomainWarpSingle2D(const fnl_state *state, FNLfloat *x, FNLfloat *y)
19131923
{
19141924
int seed = state->seed;
19151925
float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state);
@@ -1922,7 +1932,7 @@ static void _fnlDomainWarpSingle2D(fnl_state *state, FNLfloat *x, FNLfloat *y)
19221932
_fnlDoSingleDomainWarp2D(state, seed, amp, freq, xs, ys, x, y);
19231933
}
19241934

1925-
static void _fnlDomainWarpSingle3D(fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z)
1935+
static void _fnlDomainWarpSingle3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z)
19261936
{
19271937
int seed = state->seed;
19281938
float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state);
@@ -1938,7 +1948,7 @@ static void _fnlDomainWarpSingle3D(fnl_state *state, FNLfloat *x, FNLfloat *y, F
19381948

19391949
// Domain Warp Fractal Progressive
19401950

1941-
static void _fnlDomainWarpFractalProgressive2D(fnl_state *state, FNLfloat *x, FNLfloat *y)
1951+
static void _fnlDomainWarpFractalProgressive2D(const fnl_state *state, FNLfloat *x, FNLfloat *y)
19421952
{
19431953
int seed = state->seed;
19441954
float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state);
@@ -1958,7 +1968,7 @@ static void _fnlDomainWarpFractalProgressive2D(fnl_state *state, FNLfloat *x, FN
19581968
}
19591969
}
19601970

1961-
static void _fnlDomainWarpFractalProgressive3D(fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z)
1971+
static void _fnlDomainWarpFractalProgressive3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z)
19621972
{
19631973
int seed = state->seed;
19641974
float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state);
@@ -1981,7 +1991,7 @@ static void _fnlDomainWarpFractalProgressive3D(fnl_state *state, FNLfloat *x, FN
19811991

19821992
// Domain Warp Fractal Independent
19831993

1984-
static void _fnlDomainWarpFractalIndependent2D(fnl_state *state, FNLfloat *x, FNLfloat *y)
1994+
static void _fnlDomainWarpFractalIndependent2D(const fnl_state *state, FNLfloat *x, FNLfloat *y)
19851995
{
19861996
FNLfloat xs = *x;
19871997
FNLfloat ys = *y;
@@ -2001,7 +2011,7 @@ static void _fnlDomainWarpFractalIndependent2D(fnl_state *state, FNLfloat *x, FN
20012011
}
20022012
}
20032013

2004-
static void _fnlDomainWarpFractalIndependent3D(fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z)
2014+
static void _fnlDomainWarpFractalIndependent3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z)
20052015
{
20062016
FNLfloat xs = *x;
20072017
FNLfloat ys = *y;
@@ -2357,7 +2367,7 @@ fnl_state fnlCreateState()
23572367
return newState;
23582368
}
23592369

2360-
float fnlGetNoise2D(fnl_state *state, FNLfloat x, FNLfloat y)
2370+
float fnlGetNoise2D(const fnl_state *state, FNLfloat x, FNLfloat y)
23612371
{
23622372
_fnlTransformNoiseCoordinate2D(state, &x, &y);
23632373

@@ -2374,7 +2384,7 @@ float fnlGetNoise2D(fnl_state *state, FNLfloat x, FNLfloat y)
23742384
}
23752385
}
23762386

2377-
float fnlGetNoise3D(fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z)
2387+
float fnlGetNoise3D(const fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z)
23782388
{
23792389
_fnlTransformNoiseCoordinate3D(state, &x, &y, &z);
23802390

@@ -2392,7 +2402,7 @@ float fnlGetNoise3D(fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z)
23922402
}
23932403
}
23942404

2395-
void fnlDomainWarp2D(fnl_state *state, FNLfloat *x, FNLfloat *y)
2405+
void fnlDomainWarp2D(const fnl_state *state, FNLfloat *x, FNLfloat *y)
23962406
{
23972407
switch (state->fractal_type)
23982408
{
@@ -2408,7 +2418,7 @@ void fnlDomainWarp2D(fnl_state *state, FNLfloat *x, FNLfloat *y)
24082418
}
24092419
}
24102420

2411-
void fnlDomainWarp3D(fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z)
2421+
void fnlDomainWarp3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z)
24122422
{
24132423
switch (state->fractal_type)
24142424
{
@@ -2424,10 +2434,8 @@ void fnlDomainWarp3D(fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z)
24242434
}
24252435
}
24262436

2427-
#endif // FNL_IMPL
2428-
24292437
#if defined(__cplusplus)
24302438
}
24312439
#endif
24322440

2433-
#endif // FASTNOISELITE_H
2441+
#endif // FNL_IMPL

0 commit comments

Comments
 (0)