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