From a0ac8ee2c4ce14a23deedeccf9911977e119749d Mon Sep 17 00:00:00 2001
From: Wilhem Barbier <nounoursheureux@openmailbox.org>
Date: Wed, 28 Jun 2017 15:29:56 +0200
Subject: [PATCH] Add more image generation functions: radial gradient and
 perlin noise

---
 examples/textures/gen                         | Bin 0 -> 13112 bytes
 examples/textures/textures_image_generation.c |  12 +-
 src/external/stb_perlin.h                     | 316 ++++++++++++++++++
 src/raylib.h                                  |   2 +
 src/textures.c                                |  55 +++
 5 files changed, 381 insertions(+), 4 deletions(-)
 create mode 100755 examples/textures/gen
 create mode 100644 src/external/stb_perlin.h

diff --git a/examples/textures/gen b/examples/textures/gen
new file mode 100755
index 0000000000000000000000000000000000000000..a0f5bf619c28430f3e5fcfb966ce406e83437381
GIT binary patch
literal 13112
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
J*dP*JKLBX893cPz

literal 0
HcmV?d00001

diff --git a/examples/textures/textures_image_generation.c b/examples/textures/textures_image_generation.c
index 9db64ef76..7525e8a28 100644
--- a/examples/textures/textures_image_generation.c
+++ b/examples/textures/textures_image_generation.c
@@ -11,7 +11,7 @@
 
 #include "raylib.h"
 
-#define TEXTURES_NUM 5 // for now we have 5 generation algorithms
+#define TEXTURES_NUM 7 // for now we have 7 generation algorithms
 
 int main()
 {
@@ -22,16 +22,20 @@ int main()
 
     Image verticalGradient = GenImageGradientV(screenWidth, screenHeight, RED, BLUE);
     Image horizontalGradient = GenImageGradientH(screenWidth, screenHeight, RED, BLUE);
+    Image radialGradient = GenImageRadialGradient(screenWidth, screenHeight, WHITE, BLACK);
     Image checked = GenImageChecked(screenWidth, screenHeight, 32, 32, RED, BLUE);
     Image whiteNoise = GenImageWhiteNoise(screenWidth, screenHeight, 0.5f);
+    Image perlinNoise = GenImagePerlinNoise(screenWidth, screenHeight, 8.f);
     Image cellular = GenImageCellular(screenWidth, screenHeight, 32);
 
     Texture2D textures[TEXTURES_NUM];
     textures[0] = LoadTextureFromImage(verticalGradient);
     textures[1] = LoadTextureFromImage(horizontalGradient);
-    textures[2] = LoadTextureFromImage(checked);
-    textures[3] = LoadTextureFromImage(whiteNoise);
-    textures[4] = LoadTextureFromImage(cellular);
+    textures[2] = LoadTextureFromImage(radialGradient);
+    textures[3] = LoadTextureFromImage(checked);
+    textures[4] = LoadTextureFromImage(whiteNoise);
+    textures[5] = LoadTextureFromImage(perlinNoise);
+    textures[6] = LoadTextureFromImage(cellular);
 
     int currentTexture = 0;
 
diff --git a/src/external/stb_perlin.h b/src/external/stb_perlin.h
new file mode 100644
index 000000000..5d7622209
--- /dev/null
+++ b/src/external/stb_perlin.h
@@ -0,0 +1,316 @@
+// stb_perlin.h - v0.3 - perlin noise
+// public domain single-file C implementation by Sean Barrett
+//
+// LICENSE
+//
+//   See end of file.
+//
+//
+// to create the implementation,
+//     #define STB_PERLIN_IMPLEMENTATION
+// in *one* C/CPP file that includes this file.
+//
+//
+// Documentation:
+//
+// float  stb_perlin_noise3( float x,
+//                           float y,
+//                           float z,
+//                           int   x_wrap=0,
+//                           int   y_wrap=0,
+//                           int   z_wrap=0)
+//
+// This function computes a random value at the coordinate (x,y,z).
+// Adjacent random values are continuous but the noise fluctuates
+// its randomness with period 1, i.e. takes on wholly unrelated values
+// at integer points. Specifically, this implements Ken Perlin's
+// revised noise function from 2002.
+//
+// The "wrap" parameters can be used to create wraparound noise that
+// wraps at powers of two. The numbers MUST be powers of two. Specify
+// 0 to mean "don't care". (The noise always wraps every 256 due
+// details of the implementation, even if you ask for larger or no
+// wrapping.)
+//
+// Fractal Noise:
+//
+// Three common fractal noise functions are included, which produce 
+// a wide variety of nice effects depending on the parameters 
+// provided. Note that each function will call stb_perlin_noise3 
+// 'octaves' times, so this parameter will affect runtime.
+//
+// float stb_perlin_ridge_noise3(float x, float y, float z,
+//                               float lacunarity, float gain, float offset, int octaves,
+//                               int x_wrap, int y_wrap, int z_wrap);
+//
+// float stb_perlin_fbm_noise3(float x, float y, float z,
+//                             float lacunarity, float gain, int octaves,
+//                             int x_wrap, int y_wrap, int z_wrap);
+//
+// float stb_perlin_turbulence_noise3(float x, float y, float z,
+//                                    float lacunarity, float gain,int octaves,
+//                                    int x_wrap, int y_wrap, int z_wrap);
+//
+// Typical values to start playing with:
+//     octaves    =   6     -- number of "octaves" of noise3() to sum
+//     lacunarity = ~ 2.0   -- spacing between successive octaves (use exactly 2.0 for wrapping output)
+//     gain       =   0.5   -- relative weighting applied to each successive octave
+//     offset     =   1.0?  -- used to invert the ridges, may need to be larger, not sure
+//    
+//
+// Contributors:
+//    Jack Mott - additional noise functions
+//
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap);
+extern float stb_perlin_ridge_noise3(float x, float y, float z,float lacunarity, float gain, float offset, int octaves,int x_wrap, int y_wrap, int z_wrap);
+extern float stb_perlin_fbm_noise3(float x, float y, float z,float lacunarity, float gain, int octaves,int x_wrap, int y_wrap, int z_wrap);
+extern float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves,int x_wrap, int y_wrap, int z_wrap);
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef STB_PERLIN_IMPLEMENTATION
+
+// not same permutation table as Perlin's reference to avoid copyright issues;
+// Perlin's table can be found at http://mrl.nyu.edu/~perlin/noise/
+// @OPTIMIZE: should this be unsigned char instead of int for cache?
+static unsigned char stb__perlin_randtab[512] =
+{
+   23, 125, 161, 52, 103, 117, 70, 37, 247, 101, 203, 169, 124, 126, 44, 123, 
+   152, 238, 145, 45, 171, 114, 253, 10, 192, 136, 4, 157, 249, 30, 35, 72, 
+   175, 63, 77, 90, 181, 16, 96, 111, 133, 104, 75, 162, 93, 56, 66, 240, 
+   8, 50, 84, 229, 49, 210, 173, 239, 141, 1, 87, 18, 2, 198, 143, 57, 
+   225, 160, 58, 217, 168, 206, 245, 204, 199, 6, 73, 60, 20, 230, 211, 233, 
+   94, 200, 88, 9, 74, 155, 33, 15, 219, 130, 226, 202, 83, 236, 42, 172, 
+   165, 218, 55, 222, 46, 107, 98, 154, 109, 67, 196, 178, 127, 158, 13, 243, 
+   65, 79, 166, 248, 25, 224, 115, 80, 68, 51, 184, 128, 232, 208, 151, 122, 
+   26, 212, 105, 43, 179, 213, 235, 148, 146, 89, 14, 195, 28, 78, 112, 76, 
+   250, 47, 24, 251, 140, 108, 186, 190, 228, 170, 183, 139, 39, 188, 244, 246, 
+   132, 48, 119, 144, 180, 138, 134, 193, 82, 182, 120, 121, 86, 220, 209, 3, 
+   91, 241, 149, 85, 205, 150, 113, 216, 31, 100, 41, 164, 177, 214, 153, 231, 
+   38, 71, 185, 174, 97, 201, 29, 95, 7, 92, 54, 254, 191, 118, 34, 221, 
+   131, 11, 163, 99, 234, 81, 227, 147, 156, 176, 17, 142, 69, 12, 110, 62, 
+   27, 255, 0, 194, 59, 116, 242, 252, 19, 21, 187, 53, 207, 129, 64, 135, 
+   61, 40, 167, 237, 102, 223, 106, 159, 197, 189, 215, 137, 36, 32, 22, 5,  
+
+   // and a second copy so we don't need an extra mask or static initializer
+   23, 125, 161, 52, 103, 117, 70, 37, 247, 101, 203, 169, 124, 126, 44, 123, 
+   152, 238, 145, 45, 171, 114, 253, 10, 192, 136, 4, 157, 249, 30, 35, 72, 
+   175, 63, 77, 90, 181, 16, 96, 111, 133, 104, 75, 162, 93, 56, 66, 240, 
+   8, 50, 84, 229, 49, 210, 173, 239, 141, 1, 87, 18, 2, 198, 143, 57, 
+   225, 160, 58, 217, 168, 206, 245, 204, 199, 6, 73, 60, 20, 230, 211, 233, 
+   94, 200, 88, 9, 74, 155, 33, 15, 219, 130, 226, 202, 83, 236, 42, 172, 
+   165, 218, 55, 222, 46, 107, 98, 154, 109, 67, 196, 178, 127, 158, 13, 243, 
+   65, 79, 166, 248, 25, 224, 115, 80, 68, 51, 184, 128, 232, 208, 151, 122, 
+   26, 212, 105, 43, 179, 213, 235, 148, 146, 89, 14, 195, 28, 78, 112, 76, 
+   250, 47, 24, 251, 140, 108, 186, 190, 228, 170, 183, 139, 39, 188, 244, 246, 
+   132, 48, 119, 144, 180, 138, 134, 193, 82, 182, 120, 121, 86, 220, 209, 3, 
+   91, 241, 149, 85, 205, 150, 113, 216, 31, 100, 41, 164, 177, 214, 153, 231, 
+   38, 71, 185, 174, 97, 201, 29, 95, 7, 92, 54, 254, 191, 118, 34, 221, 
+   131, 11, 163, 99, 234, 81, 227, 147, 156, 176, 17, 142, 69, 12, 110, 62, 
+   27, 255, 0, 194, 59, 116, 242, 252, 19, 21, 187, 53, 207, 129, 64, 135, 
+   61, 40, 167, 237, 102, 223, 106, 159, 197, 189, 215, 137, 36, 32, 22, 5,  
+};
+
+static float stb__perlin_lerp(float a, float b, float t)
+{
+   return a + (b-a) * t;
+}
+
+static int stb__perlin_fastfloor(float a)
+{
+	int ai = (int) a;
+	return (a < ai) ? ai-1 : ai;
+}
+
+// different grad function from Perlin's, but easy to modify to match reference
+static float stb__perlin_grad(int hash, float x, float y, float z)
+{
+   static float basis[12][4] =
+   {
+      {  1, 1, 0 },
+      { -1, 1, 0 },
+      {  1,-1, 0 },
+      { -1,-1, 0 },
+      {  1, 0, 1 },
+      { -1, 0, 1 },
+      {  1, 0,-1 },
+      { -1, 0,-1 },
+      {  0, 1, 1 },
+      {  0,-1, 1 },
+      {  0, 1,-1 },
+      {  0,-1,-1 },
+   };
+
+   // perlin's gradient has 12 cases so some get used 1/16th of the time
+   // and some 2/16ths. We reduce bias by changing those fractions
+   // to 5/64ths and 6/64ths, and the same 4 cases get the extra weight.
+   static unsigned char indices[64] =
+   {
+      0,1,2,3,4,5,6,7,8,9,10,11,
+      0,9,1,11,
+      0,1,2,3,4,5,6,7,8,9,10,11,
+      0,1,2,3,4,5,6,7,8,9,10,11,
+      0,1,2,3,4,5,6,7,8,9,10,11,
+      0,1,2,3,4,5,6,7,8,9,10,11,
+   };
+
+   // if you use reference permutation table, change 63 below to 15 to match reference
+   // (this is why the ordering of the table above is funky)
+   float *grad = basis[indices[hash & 63]];
+   return grad[0]*x + grad[1]*y + grad[2]*z;
+}
+
+float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap)
+{
+   float u,v,w;
+   float n000,n001,n010,n011,n100,n101,n110,n111;
+   float n00,n01,n10,n11;
+   float n0,n1;
+
+   unsigned int x_mask = (x_wrap-1) & 255;
+   unsigned int y_mask = (y_wrap-1) & 255;
+   unsigned int z_mask = (z_wrap-1) & 255;
+   int px = stb__perlin_fastfloor(x);
+   int py = stb__perlin_fastfloor(y);
+   int pz = stb__perlin_fastfloor(z);
+   int x0 = px & x_mask, x1 = (px+1) & x_mask;
+   int y0 = py & y_mask, y1 = (py+1) & y_mask;
+   int z0 = pz & z_mask, z1 = (pz+1) & z_mask;
+   int r0,r1, r00,r01,r10,r11;
+
+   #define stb__perlin_ease(a)   (((a*6-15)*a + 10) * a * a * a)
+
+   x -= px; u = stb__perlin_ease(x);
+   y -= py; v = stb__perlin_ease(y);
+   z -= pz; w = stb__perlin_ease(z);
+
+   r0 = stb__perlin_randtab[x0];
+   r1 = stb__perlin_randtab[x1];
+
+   r00 = stb__perlin_randtab[r0+y0];
+   r01 = stb__perlin_randtab[r0+y1];
+   r10 = stb__perlin_randtab[r1+y0];
+   r11 = stb__perlin_randtab[r1+y1];
+
+   n000 = stb__perlin_grad(stb__perlin_randtab[r00+z0], x  , y  , z   );
+   n001 = stb__perlin_grad(stb__perlin_randtab[r00+z1], x  , y  , z-1 );
+   n010 = stb__perlin_grad(stb__perlin_randtab[r01+z0], x  , y-1, z   );
+   n011 = stb__perlin_grad(stb__perlin_randtab[r01+z1], x  , y-1, z-1 );
+   n100 = stb__perlin_grad(stb__perlin_randtab[r10+z0], x-1, y  , z   );
+   n101 = stb__perlin_grad(stb__perlin_randtab[r10+z1], x-1, y  , z-1 );
+   n110 = stb__perlin_grad(stb__perlin_randtab[r11+z0], x-1, y-1, z   );
+   n111 = stb__perlin_grad(stb__perlin_randtab[r11+z1], x-1, y-1, z-1 );
+
+   n00 = stb__perlin_lerp(n000,n001,w);
+   n01 = stb__perlin_lerp(n010,n011,w);
+   n10 = stb__perlin_lerp(n100,n101,w);
+   n11 = stb__perlin_lerp(n110,n111,w);
+
+   n0 = stb__perlin_lerp(n00,n01,v);
+   n1 = stb__perlin_lerp(n10,n11,v);
+
+   return stb__perlin_lerp(n0,n1,u);
+}
+
+float stb_perlin_ridge_noise3(float x, float y, float z,float lacunarity, float gain, float offset, int octaves,int x_wrap, int y_wrap, int z_wrap)
+{
+   int i;
+   float frequency = 1.0f;
+   float prev = 1.0f;
+   float amplitude = 0.5f;
+   float sum = 0.0f;
+
+   for (i = 0; i < octaves; i++) {
+      float r = (float)(stb_perlin_noise3(x*frequency,y*frequency,z*frequency,x_wrap,y_wrap,z_wrap));
+      r = r<0 ? -r : r; // fabs()
+      r = offset - r;
+      r = r*r;
+      sum += r*amplitude*prev;
+      prev = r;
+      frequency *= lacunarity;
+      amplitude *= gain;
+   }
+   return sum;
+}
+
+float stb_perlin_fbm_noise3(float x, float y, float z,float lacunarity, float gain, int octaves,int x_wrap, int y_wrap, int z_wrap)
+{
+   int i;
+   float frequency = 1.0f;
+   float amplitude = 1.0f;
+   float sum = 0.0f;
+   
+   for (i = 0; i < octaves; i++) {
+      sum += stb_perlin_noise3(x*frequency,y*frequency,z*frequency,x_wrap,y_wrap,z_wrap)*amplitude;
+      frequency *= lacunarity;
+      amplitude *= gain;
+   }
+   return sum;
+}
+
+float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves,int x_wrap, int y_wrap, int z_wrap)
+{
+   int i;
+   float frequency = 1.0f;
+   float amplitude = 1.0f;
+   float sum = 0.0f;
+   
+   for (i = 0; i < octaves; i++) {
+      float r = stb_perlin_noise3(x*frequency,y*frequency,z*frequency,x_wrap,y_wrap,z_wrap)*amplitude;
+      r = r<0 ? -r : r; // fabs()
+      sum += r;
+      frequency *= lacunarity;
+      amplitude *= gain;
+   }
+   return sum;
+}
+
+#endif  // STB_PERLIN_IMPLEMENTATION
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do 
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this 
+software, either in source code form or as a compiled binary, for any purpose, 
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this 
+software dedicate any and all copyright interest in the software to the public 
+domain. We make this dedication for the benefit of the public at large and to 
+the detriment of our heirs and successors. We intend this dedication to be an 
+overt act of relinquishment in perpetuity of all present and future rights to 
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/
diff --git a/src/raylib.h b/src/raylib.h
index 29cc57289..828c2fe90 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -876,8 +876,10 @@ RLAPI void ImageColorBrightness(Image *image, int brightness);
 // Image generation functions
 RLAPI Image GenImageGradientV(int width, int height, Color top, Color bottom);                           // Generate image: vertical gradient
 RLAPI Image GenImageGradientH(int width, int height, Color left, Color right);                           // Generate image: horizontal gradient
+RLAPI Image GenImageRadialGradient(int width, int height, Color inner, Color outer);                     // Generate image: radial gradient
 RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2);    // Generate image: checked
 RLAPI Image GenImageWhiteNoise(int width, int height, float factor);                                     // Generate image: white noise
+RLAPI Image GenImagePerlinNoise(int width, int height, float scale);                                     // Generate image: perlin noise
 RLAPI Image GenImageCellular(int width, int height, int tileSize);                                       // Generate image: cellular algorithm. Bigger tileSize means bigger cells
 
 // Texture2D configuration functions
diff --git a/src/textures.c b/src/textures.c
index 99392516b..be089a937 100644
--- a/src/textures.c
+++ b/src/textures.c
@@ -68,6 +68,9 @@
 
 #include "utils.h"              // Required for: fopen() Android mapping
 
+#define STB_PERLIN_IMPLEMENTATION
+#include "external/stb_perlin.h"// Required for: stb_perlin_fbm_noise3
+
 // Support only desired texture formats on stb_image
 #if !defined(SUPPORT_FILEFORMAT_BMP)
     #define STBI_NO_BMP
@@ -1477,6 +1480,34 @@ Image GenImageGradientH(int width, int height, Color left, Color right)
     return image;
 }
 
+// Generate image: radial gradient
+Image GenImageRadialGradient(int width, int height, Color inner, Color outer)
+{
+    Color *pixels = (Color*)malloc(width * height * sizeof(Color));
+    float radius = (width < height) ? (float)width / 2.f : (float)height / 2.f;
+
+    float center_x = (float)width / 2.f;
+    float center_y = (float)height / 2.f;
+    for (int y = 0; y < height; y++)
+    {
+        for (int x = 0; x < width; x++)
+        {
+            float dist = hypotf((float)x - center_x, (float)y - center_y);
+            float factor = dist / radius;
+            factor = fmin(factor, 1.f); // dist can be bigger than radius so we have to check
+            pixels[y*width + x].r = (int)((float)outer.r * factor + (float)inner.r * (1.f - factor));
+            pixels[y*width + x].g = (int)((float)outer.g * factor + (float)inner.g * (1.f - factor));
+            pixels[y*width + x].b = (int)((float)outer.b * factor + (float)inner.b * (1.f - factor));
+            pixels[y*width + x].a = (int)((float)outer.a * factor + (float)inner.a * (1.f - factor));
+        }
+    }
+
+    Image image = LoadImageEx(pixels, width, height);
+    free(pixels);
+
+    return image;
+}
+
 // Generate image: checked
 Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2)
 {
@@ -1514,6 +1545,30 @@ Image GenImageWhiteNoise(int width, int height, float factor)
     return image;
 }
 
+// Generate image: perlin noise
+Image GenImagePerlinNoise(int width, int height, float scale)
+{
+    Color *pixels = (Color*)malloc(width * height * sizeof(Color));
+
+    for (int y = 0; y < height; y++)
+    {
+        for (int x = 0; x < width; x++)
+        {
+            float nx = (float)x * scale / (float)width;
+            float ny = (float)y * scale / (float)height;
+            // we need to translate the data from [-1; 1] to [0; 1]
+            float p = (stb_perlin_fbm_noise3(nx, ny, 1.f, 2.f, 0.5f, 6, 0, 0, 0) + 1.f) / 2.f;
+            int intensity = (int)(p * 255.f);
+            pixels[y*width + x] = (Color){intensity, intensity, intensity, 255};
+        }
+    }
+
+    Image image = LoadImageEx(pixels, width, height);
+    free(pixels);
+
+    return image;
+}
+
 // Generate image: cellular algorithm. Bigger tileSize means bigger cells
 Image GenImageCellular(int width, int height, int tileSize)
 {