Integrate Perlin noise switch

Also make Perlin noise ground wider and less ugly

Ball.cpp

@@ -42,7 +42,6 @@ void Ball::_compute_pos(double dt) {
     }
     Center.x += dt * v_x;
     Center.z += dt * v_z;
-    std::cout << (*this) <<"\n";
     surface.update_center_pos(Center);
     surface.check_ground_collision(ground);
 }
@@ -89,10 +88,6 @@ void Ball::_compute_parameters() {
         _compute_v_x(normal);
         _compute_v_z(normal);
         min_height = fmin(radius, min_height + 0.2 * (radius - min_height));
-        std::cout << "U:" << U << "\n";
-        std::cout << "B:" << B << "\n";
-        std::cout << "A:" << A << "\n";
-        std::cout << "T:" << T << "\n";
 }
 
 void Ball::update_pos(double dt) {

GroundFlatMesh.cpp

@@ -0,0 +1,45 @@
+#include "GroundFlatMesh.hpp"
+
+#include <vector>
+
+const int GroundFlatMesh::MIN_I = -40;
+const int GroundFlatMesh::MAX_I = 100;
+const int GroundFlatMesh::MIN_J = -40;
+const int GroundFlatMesh::MAX_J = 100;
+
+GroundFlatMesh::GroundFlatMesh(const Point& center, double decay_speed)
+    : center(center), decay_speed(decay_speed)
+{
+    std::vector<std::vector<size_t> > vertice_at(MAX_I - MIN_I + 1,
+            std::vector<size_t>(MAX_J - MIN_J + 1));
+
+    for(int i=MIN_I; i < MAX_I + 1; ++i) {
+        for(int j=MIN_J; j < MAX_J + 1; ++j) {
+            vertice_at[i - MIN_I][j - MIN_J] =
+                output.add_vertice(
+                        tile_position(i, j),
+                        Point(0., 1., 0.));
+        }
+    }
+
+    for(int i=MIN_I; i < MAX_I; ++i) {
+        for(int j=MIN_J; j < MAX_J; ++j) {
+            output.add_face(Face(
+                        vertice_at[i - MIN_I][j - MIN_J],
+                        vertice_at[i - MIN_I][j + 1 - MIN_J],
+                        vertice_at[i + 1 - MIN_I][j + 1 - MIN_J]));
+            output.add_face(Face(
+                        vertice_at[i - MIN_I][j - MIN_J],
+                        vertice_at[i + 1 - MIN_I][j + 1 - MIN_J],
+                        vertice_at[i + 1- MIN_I][j - MIN_J]));
+        }
+    }
+}
+
+double GroundFlatMesh::ith_dist(int i) const {
+    return ((i < 0) ? -1 : 1) * decay_speed * i * i;
+}
+
+Point GroundFlatMesh::tile_position(int i, int j) const {
+    return Point(ith_dist(i), 0., ith_dist(j));
+}

GroundFlatMesh.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "Mesh.hpp"
+
+class GroundFlatMesh {
+    public:
+        GroundFlatMesh(const Point& center, double decay_speed);
+
+        Mesh* get_mesh() { return &output; }
+
+    private: //meth
+        double ith_dist(int i) const;
+        Point tile_position(int i, int j) const;
+
+    private:
+        static const int MIN_I, MAX_I, MIN_J, MAX_J;
+        Mesh output;
+        const Point& center;
+        double decay_speed;
+};

Implicit.hpp

@@ -8,11 +8,16 @@ class ImplicitSurface {
         double operator()(const Point& pt) const;
         Point getCenter() const { return center;}
 
+        const Color& get_color() const { return color; }
+        void set_color(const Color& _color) { color = _color; }
+
         virtual Point location_hint() const = 0;
 
         /// Compute the normal vector to the isosurface at `pt`
         Point normal_at(const Point& pt) const;
     protected:
         Point center;
+        Color color;
+
         ImplicitSurface(Point _center) : center(_center) {}
 };

Makefile

@@ -19,6 +19,7 @@ OBJS=Implicit.o \
 	 MarchingCubes.o \
 	 _gen/marching_cubes_data.o \
 	 periodic_updates.o \
+	 GroundFlatMesh.o \
 	 tests/TestImplicitSphere.o \
 	 render/GlutRender.o
 

MarchingCubes.cpp

@@ -24,6 +24,8 @@ MarchingCubes& MarchingCubes::add_hint(const Point& hint) {
 Mesh MarchingCubes::operator()() {
     Mesh output;
 
+    output.set_color(surface.get_color());
+
     perf_counter = 0;
 
     if(hints.empty())
@@ -31,7 +33,9 @@ Mesh MarchingCubes::operator()() {
     else
         with_hints(output);
 
-    printf("Explored cubes: %ld\n", perf_counter);
+#ifdef MC_SHOW_PERF
+    fprintf(stderr, "Explored cubes: %ld\n", perf_counter);
+#endif // MC_SHOW_PERF
 
     output.translate(surface.getCenter());
 

Mesh.hpp

@@ -41,6 +41,9 @@ class Mesh {
         /// Gets the various faces
         const std::vector<Face>& get_faces() const;
 
+        const Color& get_color() const { return color; }
+        void set_color(const Color& _color) { color = _color; }
+
     private: //struct
         struct NormalVect {
             NormalVect(const Point& vect, bool manual=false)
@@ -63,4 +66,5 @@ class Mesh {
         std::vector<std::vector<size_t> > faces_with_vert;
 
         Point center;
+        Color color;
 };

common_structures.hpp

@@ -152,6 +152,20 @@ class Cuboid {
         Point lowBound, highBound;
 };
 
+struct Color {
+    Color() : r(0), g(0), b(0) {}
+    Color(double r, double g, double b) : r(r), g(g), b(b) {}
+    double r, g, b;
+    double operator[](int i) const {
+        switch(i % 3) {
+            case 0: return r;
+            case 1: return g;
+            case 2: return b;
+        }
+        return 0; // won't happen
+    }
+};
+
 namespace std {
 	template<> struct hash<Face>
     {

main_bounce.cpp

@@ -2,28 +2,57 @@
  * bouncing implicit-surface defined sphere.
  **/
 
+#include <cstring>
+
 #include "render/GlutRender.hpp"
 #include "Ball.hpp"
 #include "FlatGround.hpp"
 #include "MarchingCubes.hpp"
+#include "GroundFlatMesh.hpp"
 
 #include "periodic_updates.hpp"
 
 int main(int argc, char** argv) {
+    bool perlin = false;
+    for(int pos=1; pos < argc; ++pos) {
+        if(strcmp(argv[pos], "-perlin") == 0)
+            perlin = true;
+    }
+
+    // Last minute switch, this code is ugly, please close your eyes until
+    // stated otherwise.
+    PerlinGround perlin_ground;
+    FlatGround flat_ground;
+    GroundFlatMesh ground_mesh(Point(0., 0., 0.), 0.05);
+    Ground* ball_ground = nullptr;
+    if(perlin)
+        ball_ground = &perlin_ground;
+    else
+        ball_ground = &flat_ground;
+    // You can open your eyes, now.
 
-    FlatGround* flat = new FlatGround();
     GlutRender& render = GlutRender::get_instance();
     render.init(&argc, argv, 640, 480, "Bouncing stuff");
 
-    Ball ball(Point(0, 5, 0), flat, 0.75, -0.5, -0.7, 1, 1);
+    Ball ball(Point(0, 5, 0), ball_ground, 0.55, -.5, -.7, 1, 1);
+    ball.get_surface()->set_color(Color(1., 0., 0.));
 
     Cuboid bbox = ball.get_surface()->max_bounding_box();
-    Cuboid bbox_2(Point(-2, -1, -2), Point(2,1,2));
+    Cuboid bbox_2(Point(-20, -2, -20), Point(20,2,20));
     printf("%.2lf %.2lf %.2lf | %.2lf %.2lf %.2lf\n",
             bbox.low(0), bbox.low(1), bbox.low(2),
             bbox.high(0), bbox.high(1), bbox.high(2));
     render.add_surface(ball.get_surface(), bbox);
 
+    if(perlin) {
+        perlin_ground.get_surface()->set_color(Color(0.13, 0.82, 0.21));
+        render.add_surface(perlin_ground.get_surface(), bbox_2, 1);
+    }
+    else {
+        ground_mesh.get_mesh()->set_color(Color(0.13, 0.82, 0.21));
+        render.add_mesh(ground_mesh.get_mesh());
+    }
+
     render.set_idle_func(periodic_update);
     init_periodic_static(&ball);
     render.run();

render/GlutRender.cpp

@@ -31,10 +31,10 @@ void GlutRender::init(int* argc, char** argv,
     glutReshapeFunc(reshape_handle);
 
     // ==== Lighting ====
-    GLfloat light0_pos[] = {10., 15., 10.};
+    GLfloat light0_pos[] = {30., 35., 20., 0.};
     GLfloat light0_ambient[] = {0., 0., 0., 1.};
-    GLfloat light0_diffuse[] = {1., 1., .65, 1.};
-    GLfloat light0_specular[] = {5., 5., .33, 1.};
+    GLfloat light0_diffuse[] = {1., 1., .85, 1.};
+    GLfloat light0_specular[] = {5., 5., .43, 1.};
     glLightfv(GL_LIGHT0, GL_POSITION, light0_pos);
     glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
     glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
@@ -47,15 +47,16 @@ void GlutRender::init(int* argc, char** argv,
     glEnable(GL_LIGHT0);
     glShadeModel(GL_SMOOTH); // Enable smooth shading
 
+    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
     GLfloat material_specular[] = {1., 1., 1., 1.};
     GLfloat material_emission[] = {0., 0., 0., 1.};
-    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material_specular);
     glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, material_emission);
     glEnable(GL_COLOR_MATERIAL);
 
     // ==== Misc ====
-    glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // Background color
+    //glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // Background color
+    glClearColor(0.15f, 0.08f, 0.5f, 1.0f); // Background color
     glClearDepth(1.0f);                   // Set background depth to farthest
     glEnable(GL_DEPTH_TEST);
     glDepthFunc(GL_LEQUAL);
@@ -73,12 +74,14 @@ void GlutRender::remove_mesh(Mesh* mesh) {
     meshes.erase(mesh);
 }
 
-void GlutRender::add_surface(ImplicitSurface* surf, const Cuboid& box) {
-    surfaces.insert(SurfaceDetails(surf, box));
+void GlutRender::add_surface(ImplicitSurface* surf, const Cuboid& box,
+        double resolution)
+{
+    surfaces.insert(SurfaceDetails(surf, box, resolution));
 }
 
 void GlutRender::remove_surface(ImplicitSurface* surf) {
-    surfaces.erase(SurfaceDetails(surf, Cuboid::empty()));
+    surfaces.erase(SurfaceDetails(surf, Cuboid::empty(), 0.1));
 }
 
 void GlutRender::run() {
@@ -149,8 +152,15 @@ void GlutRender::display_mesh(Mesh& mesh) const {
 #endif // DEBUG_DISPLAY_WIREFRAME
 
 
+    const Color& color = mesh.get_color();
+    GLfloat material_specular[] = {
+        (float)color[0],
+        (float)color[1],
+        (float)color[2],
+        1.};
     glBegin(GL_TRIANGLES);
-    glColor3f(1., 1., 1.);
+    glColor3f(color[0], color[1], color[2]);
+    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material_specular);
     for(const Face& face: mesh.get_faces()) {
         Point p0 = face.pt(0, points) + mesh_center,
               p1 = face.pt(1, points) + mesh_center,
@@ -182,7 +192,8 @@ void GlutRender::display() {
     }
 
     for(const SurfaceDetails& surface: surfaces) {
-        Mesh mesh = MarchingCubes(*surface.surface, surface.box)
+        Mesh mesh = MarchingCubes(*surface.surface, surface.box,
+                surface.resolution)
             .add_hint(surface.surface->location_hint())
             ();
         display_mesh(mesh);

render/GlutRender.hpp

@@ -18,7 +18,8 @@ class GlutRender {
         void cleanup();
         void add_mesh(Mesh* mesh);
         void remove_mesh(Mesh* mesh);
-        void add_surface(ImplicitSurface* surf, const Cuboid& box);
+        void add_surface(ImplicitSurface* surf, const Cuboid& box,
+                double resolution=0.1);
         void remove_surface(ImplicitSurface* surf);
         void run();
 
@@ -26,11 +27,13 @@ class GlutRender {
 
     private:
         struct SurfaceDetails {
-            SurfaceDetails(ImplicitSurface* surf, const Cuboid& box):
-                surface(surf), box(box) {}
+            SurfaceDetails(ImplicitSurface* surf, const Cuboid& box,
+                    double resolution):
+                surface(surf), box(box), resolution(resolution) {}
 
             ImplicitSurface* surface;
             Cuboid box;
+            double resolution;
 
             bool operator<(const SurfaceDetails& oth) const {
                 return surface < oth.surface;