perlin noise based map generation

Camera.cpp

@@ -6,6 +6,8 @@ Camera::Camera() {
     position.y = 1.f;
     position.x = position.lx = position.angleVertical = position.ly = position.angle = position.deltaAngle = position.deltaAngleVertical = position.deltaMove = 0;
     position.lz = -10.f;
+    speed = 17.f;
+    rotationSpeed = 0.05f;
 }
 
 
@@ -59,10 +61,10 @@ void Camera::update(Action a, int key) {
     if (a == NORMAL_DOWN) {
         switch (key) {
             case 'w':
-                position.deltaMove = 2.f;
+                position.deltaMove = speed;
                 break;
             case 's':
-                position.deltaMove = -2.f;
+                position.deltaMove = -speed;
                 break;
         }
     }
@@ -77,16 +79,16 @@ void Camera::update(Action a, int key) {
     if (a == ARROW_DOWN) {
         switch (key) {
             case GLUT_KEY_LEFT:
-                position.deltaAngle = -0.02f;
+                position.deltaAngle = -rotationSpeed;
                 break;
             case GLUT_KEY_RIGHT:
-                position.deltaAngle = 0.02f;
+                position.deltaAngle = rotationSpeed;
                 break;
             case GLUT_KEY_UP:
-                position.deltaAngleVertical = 0.01f;
+                position.deltaAngleVertical = rotationSpeed;
                 break;
             case GLUT_KEY_DOWN:
-                position.deltaAngleVertical = -0.01f;
+                position.deltaAngleVertical = -rotationSpeed;
                 break;
         }
     }

Camera.h

@@ -20,6 +20,8 @@ class Camera {
         float deltaAngleVertical;
         float deltaMove;
     } position;
+
+    float speed, rotationSpeed;
 public:
     enum Action {NORMAL_UP, NORMAL_DOWN, ARROW_UP, ARROW_DOWN};
 

Labka03.vcxproj

@@ -84,6 +84,7 @@
     <ClCompile Include="gkom.cpp" />
     <ClCompile Include="Leaf.cpp" />
     <ClCompile Include="Map.cpp" />
+    <ClCompile Include="Perlin.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="BambooStick.h" />
@@ -92,6 +93,7 @@
     <ClInclude Include="Floor.h" />
     <ClInclude Include="Leaf.h" />
     <ClInclude Include="Map.h" />
+    <ClInclude Include="Perlin.h" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

Labka03.vcxproj.filters

@@ -36,6 +36,9 @@
     <ClCompile Include="Leaf.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Perlin.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="BambooStick.h">
@@ -56,5 +59,8 @@
     <ClInclude Include="Leaf.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Perlin.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

Map.cpp

@@ -1,22 +1,41 @@
 #include "Map.h"
-
+#include "Perlin.h"
+#include <iostream>
 
 Map::Map(std::default_random_engine * generator) {
     entities = new std::vector<Entity *>();
 
     qobj = gluNewQuadric();
     Entity * e;
 
-    e = new Floor(-2.f, 0.f, -30.f, 100.f, 100.f);
+    width = 300.f;
+    height = 310.f;
+    e = new Floor(-2.f, 0.f, -150.f, width, height);
     entities->push_back(e);
 
-    for (int x = -5; x < 5; x++) {
-        for (int z = -8; z < 2; z++) {
-            if ((z + 8) % 2)
-                e = new BambooStick(qobj, generator, 10 * x + 5, 0, 10 * z);
-            else
-                e = new BambooStick(qobj, generator,  10 * x, 0, 10 * z);
-
+    unsigned int seed = rand() % 256;
+    Perlin perlin(seed);
+    double px, py, n;
+    double pz = (float)(rand() % 1000) / 1000.f;
+
+    for (int x = -15; x < 15; x++) {
+        for (int z = 0; z < 30; z++) {
+            px = (double)(x*10.f) / ((double)width);
+            py = (double)(z*10.f) / ((double)height);
+
+            n = 13 * perlin.noise(px, py, pz);
+            n = n - floor(n);
+
+            if (n >= 0.55) {
+
+                float hi = (float)(10 * x) + 5.f;
+                float lo = (float)(10 * x) - 4.5f;
+                float genX = lo + static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / (hi - lo)));
+                hi = (float)(10 * z) + 5.f;
+                lo = (float)(10 * z) - 4.5f;
+                float genZ = lo + static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / (hi - lo)));
+                e = new BambooStick(qobj, generator, genX, 0, -genZ);
+            }
             entities->push_back(e);
         }
     }

Map.h

@@ -8,6 +8,7 @@ class Map {
 private:
     std::vector<Entity *> * entities;
     GLUquadric * qobj;
+    float width, height;
 public:
     Map(std::default_random_engine * generator);
     ~Map();

Perlin.cpp

@@ -0,0 +1,82 @@
+#include "Perlin.h"
+#include <iostream>
+#include <cmath>
+#include <random>
+#include <algorithm>
+#include <list>
+#include <numeric>
+#include <random>
+#include <vector>
+
+Perlin::Perlin() {
+
+    p = {
+        151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142,
+        8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117,
+        35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71,
+        134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41,
+        55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89,
+        18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226,
+        250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182,
+        189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167,
+        43, 172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246,
+        97, 228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239,
+        107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254,
+        138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180};
+    // Duplicate the permutation vector
+    p.insert(p.end(), p.begin(), p.end());
+}
+
+
+Perlin::Perlin(unsigned int seed) {
+    p.resize(256);
+    std::iota(p.begin(), p.end(), 0);
+    std::default_random_engine engine(seed);
+    std::shuffle(p.begin(), p.end(), engine);
+    p.insert(p.end(), p.begin(), p.end());
+}
+
+double Perlin::noise(double x, double y, double z) {
+    // Find the unit cube that contains the point
+    int X = (int)floor(x) & 255;
+    int Y = (int)floor(y) & 255;
+    int Z = (int)floor(z) & 255;
+
+    // Find relative x, y,z of point in cube
+    x -= floor(x);
+    y -= floor(y);
+    z -= floor(z);
+
+    // Compute fade curves for each of x, y, z
+    double u = fade(x);
+    double v = fade(y);
+    double w = fade(z);
+
+    // Hash coordinates of the 8 cube corners
+    int A = p[X] + Y;
+    int AA = p[A] + Z;
+    int AB = p[A + 1] + Z;
+    int B = p[X + 1] + Y;
+    int BA = p[B] + Z;
+    int BB = p[B + 1] + Z;
+
+    // Add blended results from 8 corners of cube
+    double res = lerp(w, lerp(v, lerp(u, grad(p[AA], x, y, z), grad(p[BA], x - 1, y, z)), lerp(u, grad(p[AB], x, y - 1, z), grad(p[BB], x - 1, y - 1, z))), lerp(v, lerp(u, grad(p[AA + 1], x, y, z - 1), grad(p[BA + 1], x - 1, y, z - 1)), lerp(u, grad(p[AB + 1], x, y - 1, z - 1), grad(p[BB + 1], x - 1, y - 1, z - 1))));
+    return (res + 1.0) / 2.0;
+}
+
+double Perlin::fade(double t) {
+    return t * t * t * (t * (t * 6 - 15) + 10);
+}
+
+double Perlin::lerp(double t, double a, double b) {
+    return a + t * (b - a);
+}
+
+double Perlin::grad(int hash, double x, double y, double z) {
+    int h = hash & 15;
+    // Convert lower 4 bits of hash inot 12 gradient directions
+    double u = h < 8 ? x : y,
+        v = h < 4 ? y : h == 12 || h == 14 ? x : z;
+    return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
+}

Perlin.h

@@ -0,0 +1,14 @@
+#pragma once
+#include <vector>
+
+class Perlin {
+    std::vector<int> p;
+public:
+    Perlin();
+    Perlin(unsigned int seed);
+    double noise(double x, double y, double z);
+private:
+    double fade(double t);
+    double lerp(double t, double a, double b);
+    double grad(int hash, double x, double y, double z);
+};