lg_perlin_noise.h

/*
 *      LibGame - Copyright (C) Emmanuel Thomas-Maurin 2011-2025
 *      All rights reserved
 */
 
#ifndef LG_PERLIN_NOISE_H
#define LG_PERLIN_NOISE_H
 
// === NOTE: FOLLOWING CODE IS COPYRIGHT(C) 2023 JORDAN PECK ===
 
/*
 * Fast Noise Lite
 * Copyright(c) 2023 Jordan Peck ([email protected])
 * Copyright(c) 2023 Contributors
 * MIT License
 */
 
// Switch between using floats or doubles for input position
typedef float FNLfloat;
//typedef double FNLfloat;
 
// Enums
typedef enum
{
        FNL_NOISE_OPENSIMPLEX2,
        FNL_NOISE_OPENSIMPLEX2S,
        FNL_NOISE_CELLULAR,
        FNL_NOISE_PERLIN,
        FNL_NOISE_VALUE_CUBIC,
        FNL_NOISE_VALUE
} fnl_noise_type;
 
typedef enum
{
        FNL_ROTATION_NONE,
        FNL_ROTATION_IMPROVE_XY_PLANES,
        FNL_ROTATION_IMPROVE_XZ_PLANES
} fnl_rotation_type_3d;
 
typedef enum
{
        FNL_FRACTAL_NONE,
        FNL_FRACTAL_FBM,
        FNL_FRACTAL_RIDGED,
        FNL_FRACTAL_PINGPONG,
        FNL_FRACTAL_DOMAIN_WARP_PROGRESSIVE,
        FNL_FRACTAL_DOMAIN_WARP_INDEPENDENT
} fnl_fractal_type;
 
typedef enum
{
        FNL_CELLULAR_DISTANCE_EUCLIDEAN,
        FNL_CELLULAR_DISTANCE_EUCLIDEANSQ,
        FNL_CELLULAR_DISTANCE_MANHATTAN,
        FNL_CELLULAR_DISTANCE_HYBRID
} fnl_cellular_distance_func;
 
typedef enum
{
        FNL_CELLULAR_RETURN_TYPE_CELLVALUE,
        FNL_CELLULAR_RETURN_TYPE_DISTANCE,
        FNL_CELLULAR_RETURN_TYPE_DISTANCE2,
        FNL_CELLULAR_RETURN_TYPE_DISTANCE2ADD,
        FNL_CELLULAR_RETURN_TYPE_DISTANCE2SUB,
        FNL_CELLULAR_RETURN_TYPE_DISTANCE2MUL,
        FNL_CELLULAR_RETURN_TYPE_DISTANCE2DIV,
} fnl_cellular_return_type;
 
typedef enum
{
        FNL_DOMAIN_WARP_OPENSIMPLEX2,
        FNL_DOMAIN_WARP_OPENSIMPLEX2_REDUCED,
        FNL_DOMAIN_WARP_BASICGRID
} fnl_domain_warp_type;
 
typedef struct fnl_state
{
        int seed;
 
        float frequency;
 
        fnl_noise_type noise_type;
 
        fnl_rotation_type_3d rotation_type_3d;
 
        fnl_fractal_type fractal_type;
 
        int octaves;
 
        float lacunarity;
 
        float gain;
 
        float weighted_strength;
 
        float ping_pong_strength;
 
        fnl_cellular_distance_func cellular_distance_func;
 
        fnl_cellular_return_type cellular_return_type;
 
        float cellular_jitter_mod;
 
        fnl_domain_warp_type domain_warp_type;
 
        float domain_warp_amp;
} fnl_state;
 
fnl_state       fnlCreateState();
 
float           fnlGetNoise2D(fnl_state *, FNLfloat, FNLfloat);
 
float           fnlGetNoise3D(fnl_state *, FNLfloat, FNLfloat, FNLfloat);
 
void            fnlDomainWarp2D(fnl_state *, FNLfloat *, FNLfloat *);
 
void            fnlDomainWarp3D(fnl_state *, FNLfloat *, FNLfloat *, FNLfloat *);
 
#endif /* LG_PERLIN_NOISE_H */