src/noise.cpp

   1 #include "noise.hpp"
   2
   3 #include <cmath>
   4
   5
   6 namespace {
   7
   8 constexpr float one_third = 1.0f/3.0f;
   9 constexpr float one_sixth = 1.0f/6.0f;
  10
  11 }
  12
  13 namespace blank {
  14
  15 SimplexNoise::SimplexNoise(unsigned int seed)
  16 : grad({
  17         {  1.0f,  1.0f,  0.0f },
  18         { -1.0f,  1.0f,  0.0f },
  19         {  1.0f, -1.0f,  0.0f },
  20         { -1.0f, -1.0f,  0.0f },
  21         {  1.0f,  0.0f,  1.0f },
  22         { -1.0f,  0.0f,  1.0f },
  23         {  1.0f,  0.0f, -1.0f },
  24         { -1.0f,  0.0f, -1.0f },
  25         {  0.0f,  1.0f,  1.0f },
  26         {  0.0f, -1.0f,  1.0f },
  27         {  0.0f,  1.0f, -1.0f },
  28         {  0.0f, -1.0f, -1.0f },
  29 }) {
  30         unsigned int val = seed;
  31         for (size_t i = 0; i < 256; ++i) {
  32                 val = 2346765 * val + 6446345;
  33                 perm[i] = val % 256;
  34                 perm[i + 256] = perm[i];
  35         }
  36 }
  37
  38
  39 float SimplexNoise::operator ()(const glm::vec3 &in) const {
  40         float skew = (in.x + in.y + in.z) * one_third;
  41
  42         glm::vec3 skewed(glm::floor(in + skew));
  43         float tr = (skewed.x + skewed.y + skewed.z) * one_sixth;
  44
  45         glm::vec3 unskewed(skewed - tr);
  46         glm::vec3 offset[4];
  47         offset[0] = in - unskewed;
  48
  49         glm::vec3 second, third;
  50
  51         if (offset[0].x >= offset[0].y) {
  52                 if (offset[0].y >= offset[0].z) {
  53                         second = { 1.0f, 0.0f, 0.0f };
  54                         third = { 1.0f, 1.0f, 0.0f };
  55                 } else if (offset[0].x >= offset[0].z) {
  56                         second = { 1.0f, 0.0f, 0.0f };
  57                         third = { 1.0f, 0.0f, 1.0f };
  58                 } else {
  59                         second = { 0.0f, 0.0f, 1.0f };
  60                         third = { 1.0f, 0.0f, 1.0f };
  61                 }
  62         } else if (offset[0].y < offset[0].z) {
  63                 second = { 0.0f, 0.0f, 1.0f };
  64                 third = { 0.0f, 1.0f, 1.0f };
  65         } else if (offset[0].x < offset[0].z) {
  66                 second = { 0.0f, 1.0f, 0.0f };
  67                 third = { 0.0f, 1.0f, 1.0f };
  68         } else {
  69                 second = { 0.0f, 1.0f, 0.0f };
  70                 third = { 1.0f, 1.0f, 0.0f };
  71         }
  72
  73         offset[1] = offset[0] - second + one_sixth;
  74         offset[2] = offset[0] - third + one_third;
  75         offset[3] = offset[0] - 0.5f;
  76
  77         unsigned char index[3] = {
  78                 (unsigned char)(skewed.x),
  79                 (unsigned char)(skewed.y),
  80                 (unsigned char)(skewed.z),
  81         };
  82         size_t corner[4] = {
  83                 Perm(index[0] + Perm(index[1] + Perm(index[2]))),
  84                 Perm(index[0] + second.x + Perm(index[1] + second.y + Perm(index[2] + second.z))),
  85                 Perm(index[0] + third.x + Perm(index[1] + third.y + Perm(index[2] + third.z))),
  86                 Perm(index[0] + 1 + Perm(index[1] + 1 + Perm(index[2] + 1))),
  87         };
  88         float n[4];
  89         float t[4];
  90         for (size_t i = 0; i < 4; ++i) {
  91                 t[i] = 0.6f - dot(offset[i], offset[i]);
  92                 if (t[i] < 0.0f) {
  93                         n[i] = 0.0f;
  94                 } else {
  95                         t[i] *= t[i];
  96                         n[i] = t[i] * t[i] * dot(Grad(corner[i]), offset[i]);
  97                 }
  98         }
  99
 100         return 32.0f * (n[0] + n[1] + n[2] + n[3]);
 101 }
 102
 103
 104 unsigned char SimplexNoise::Perm(size_t idx) const {
 105         return perm[idx];
 106 }
 107
 108 const glm::vec3 &SimplexNoise::Grad(size_t idx) const {
 109         return grad[idx % 12];
 110 }
 111
 112
 113 WorleyNoise::WorleyNoise(unsigned int seed)
 114 : seed(seed)
 115 , num_points(8) {
 116
 117 }
 118
 119 float WorleyNoise::operator ()(const glm::vec3 &in) const {
 120         glm::vec3 center = floor(in);
 121
 122         float closest = 4.0f;
 123
 124         for (int z = -1; z <= 1; ++z) {
 125                 for (int y = -1; y <= 1; ++y) {
 126                         for (int x = -1; x <= 1; ++x) {
 127                                 glm::tvec3<int> cube(center.x + x, center.y + y, center.z + z);
 128                                 unsigned int cube_rand =
 129                                         (cube.x * 130223) ^
 130                                         (cube.y * 159899) ^
 131                                         (cube.z * 190717) ^
 132                                         seed;
 133
 134                                 for (int i = 0; i < num_points; ++i) {
 135                                         glm::vec3 point(cube);
 136                                         cube_rand = 190667 * cube_rand + 109807;
 137                                         point.x += float(cube_rand % 200000) / 200000.0f;
 138                                         cube_rand = 135899 * cube_rand + 189169;
 139                                         point.y += float(cube_rand % 200000) / 200000.0f;
 140                                         cube_rand = 159739 * cube_rand + 112139;
 141                                         point.z += float(cube_rand % 200000) / 200000.0f;
 142
 143                                         glm::vec3 diff(in - point);
 144                                         float distance = dot(diff, diff);
 145                                         if (distance < closest) {
 146                                                 closest = distance;
 147                                         }
 148                                 }
 149                         }
 150                 }
 151         }
 152
 153         return closest;
 154 }
 155
 156 }