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 GaloisLFSR::GaloisLFSR(std::uint64_t seed)
  16 : state(seed) {
  17
  18 }
  19
  20 bool GaloisLFSR::operator ()() {
  21         bool result = state & 1;
  22         state >>= 1;
  23         if (result) {
  24                 state |= 0x8000000000000000;
  25                 state ^= mask;
  26         } else {
  27                 state &= 0x7FFFFFFFFFFFFFFF;
  28         }
  29         return result;
  30 }
  31
  32
  33 SimplexNoise::SimplexNoise(unsigned int seed)
  34 : grad({
  35         {  1.0f,  1.0f,  0.0f },
  36         { -1.0f,  1.0f,  0.0f },
  37         {  1.0f, -1.0f,  0.0f },
  38         { -1.0f, -1.0f,  0.0f },
  39         {  1.0f,  0.0f,  1.0f },
  40         { -1.0f,  0.0f,  1.0f },
  41         {  1.0f,  0.0f, -1.0f },
  42         { -1.0f,  0.0f, -1.0f },
  43         {  0.0f,  1.0f,  1.0f },
  44         {  0.0f, -1.0f,  1.0f },
  45         {  0.0f,  1.0f, -1.0f },
  46         {  0.0f, -1.0f, -1.0f },
  47 }) {
  48         unsigned int val = seed;
  49         for (size_t i = 0; i < 256; ++i) {
  50                 val = 2346765 * val + 6446345;
  51                 perm[i] = val % 256;
  52                 perm[i + 256] = perm[i];
  53         }
  54 }
  55
  56
  57 float SimplexNoise::operator ()(const glm::vec3 &in) const {
  58         float skew = (in.x + in.y + in.z) * one_third;
  59
  60         glm::vec3 skewed(glm::floor(in + skew));
  61         float tr = (skewed.x + skewed.y + skewed.z) * one_sixth;
  62
  63         glm::vec3 unskewed(skewed - tr);
  64         glm::vec3 offset[4];
  65         offset[0] = in - unskewed;
  66
  67         glm::vec3 second, third;
  68
  69         if (offset[0].x >= offset[0].y) {
  70                 if (offset[0].y >= offset[0].z) {
  71                         second = { 1.0f, 0.0f, 0.0f };
  72                         third = { 1.0f, 1.0f, 0.0f };
  73                 } else if (offset[0].x >= offset[0].z) {
  74                         second = { 1.0f, 0.0f, 0.0f };
  75                         third = { 1.0f, 0.0f, 1.0f };
  76                 } else {
  77                         second = { 0.0f, 0.0f, 1.0f };
  78                         third = { 1.0f, 0.0f, 1.0f };
  79                 }
  80         } else if (offset[0].y < offset[0].z) {
  81                 second = { 0.0f, 0.0f, 1.0f };
  82                 third = { 0.0f, 1.0f, 1.0f };
  83         } else if (offset[0].x < offset[0].z) {
  84                 second = { 0.0f, 1.0f, 0.0f };
  85                 third = { 0.0f, 1.0f, 1.0f };
  86         } else {
  87                 second = { 0.0f, 1.0f, 0.0f };
  88                 third = { 1.0f, 1.0f, 0.0f };
  89         }
  90
  91         offset[1] = offset[0] - second + one_sixth;
  92         offset[2] = offset[0] - third + one_third;
  93         offset[3] = offset[0] - 0.5f;
  94
  95         unsigned char index[3] = {
  96                 (unsigned char)(skewed.x),
  97                 (unsigned char)(skewed.y),
  98                 (unsigned char)(skewed.z),
  99         };
 100         size_t corner[4] = {
 101                 Perm(index[0] + Perm(index[1] + Perm(index[2]))),
 102                 Perm(index[0] + second.x + Perm(index[1] + second.y + Perm(index[2] + second.z))),
 103                 Perm(index[0] + third.x + Perm(index[1] + third.y + Perm(index[2] + third.z))),
 104                 Perm(index[0] + 1 + Perm(index[1] + 1 + Perm(index[2] + 1))),
 105         };
 106         float n[4];
 107         float t[4];
 108         for (size_t i = 0; i < 4; ++i) {
 109                 t[i] = 0.6f - dot(offset[i], offset[i]);
 110                 if (t[i] < 0.0f) {
 111                         n[i] = 0.0f;
 112                 } else {
 113                         t[i] *= t[i];
 114                         n[i] = t[i] * t[i] * dot(Grad(corner[i]), offset[i]);
 115                 }
 116         }
 117
 118         return 32.0f * (n[0] + n[1] + n[2] + n[3]);
 119 }
 120
 121
 122 unsigned char SimplexNoise::Perm(size_t idx) const {
 123         return perm[idx];
 124 }
 125
 126 const glm::vec3 &SimplexNoise::Grad(size_t idx) const {
 127         return grad[idx % 12];
 128 }
 129
 130
 131 WorleyNoise::WorleyNoise(unsigned int seed)
 132 : seed(seed)
 133 , num_points(8) {
 134
 135 }
 136
 137 float WorleyNoise::operator ()(const glm::vec3 &in) const {
 138         glm::vec3 center = floor(in);
 139
 140         float closest = 1.0f;  // cannot be farther away than 1.0
 141
 142         for (int z = -1; z <= 1; ++z) {
 143                 for (int y = -1; y <= 1; ++y) {
 144                         for (int x = -1; x <= 1; ++x) {
 145                                 glm::tvec3<int> cube(center.x + x, center.y + y, center.z + z);
 146                                 unsigned int cube_rand =
 147                                         (cube.x * 130223) ^
 148                                         (cube.y * 159899) ^
 149                                         (cube.z * 190717) ^
 150                                         seed;
 151
 152                                 for (int i = 0; i < num_points; ++i) {
 153                                         glm::vec3 point(cube);
 154                                         cube_rand = 190667 * cube_rand + 109807;
 155                                         point.x += float(cube_rand % 200000) / 200000.0f;
 156                                         cube_rand = 135899 * cube_rand + 189169;
 157                                         point.y += float(cube_rand % 200000) / 200000.0f;
 158                                         cube_rand = 159739 * cube_rand + 112139;
 159                                         point.z += float(cube_rand % 200000) / 200000.0f;
 160
 161                                         glm::vec3 diff(in - point);
 162                                         float distance = sqrt(dot(diff, diff));
 163                                         if (distance < closest) {
 164                                                 closest = distance;
 165                                         }
 166                                 }
 167                         }
 168                 }
 169         }
 170
 171         // closest ranges (0, 1), so normalizing to (-1,1) is trivial
 172         // though heavily biased towards lower numbers
 173         return 2.0f * closest - 1.0f;
 174 }
 175
 176 }