resolve conflicts on merge with master

interface/src/Cube.cpp

@@ -1,80 +0,0 @@
-//
-//  Cube.cpp
-//  interface
-//
-//  Created by Philip on 12/31/12.
-//  Copyright (c) 2012 High Fidelity, Inc. All rights reserved.
-//
-
-#include "Cube.h"
-
-#define MAX_CUBES 250000
-#define SMALLEST_CUBE 0.2
-
-float cubes_position[MAX_CUBES*3];
-float cubes_scale[MAX_CUBES];
-float cubes_color[MAX_CUBES*3];
-int cube_count = 0;
-
-void makeCubes2D(float location[3], float scale, int * index,
-               float * cubes_position, float * cubes_scale, float * cubes_color) {
-    int i;
-    float spot[3];
-    float distance = powf(location[0]*location[0] + location[2]*location[2], 0.5);
-    
-    if (*index >= MAX_CUBES) return;
-    if ((scale <= SMALLEST_CUBE) || (scale/distance < 0.025) || ((scale < 0.1) && (randFloat()<0.01))) {
-        //  Make a cube
-        for (i = 0; i < 3; i++) cubes_position[*index*3 + i] = location[i]+scale/2.0;
-        //glm::vec2 noisepoint(location[0], location[2]);
-        //float color = glm::noise(noisepoint);
-        float color = 0.3 + randFloat()*0.7;
-        cubes_scale[*index] = scale;
-        cubes_color[*index*3] = color;
-        cubes_color[*index*3 + 1] = color;
-        cubes_color[*index*3 + 2] = color;
-        *index += 1;
-    } else {
-        for (i = 0; i < 4; i++) {
-            spot[0] = location[0] + (i%2)*scale/2.0;
-            spot[2] = location[2] + ((i/2)%2)*scale/2.0;
-            spot[1] = sinf(location[0])*0.15 + cosf(location[2]/0.2)*0.10 + randFloat()*0.005;
-            makeCubes2D(spot, scale/2.0, index, cubes_position, cubes_scale, cubes_color);
-        }
-    }
-}
-
-VoxelSystem::VoxelSystem(int num,
-                         glm::vec3 box) {
-     
-    float location[] = {0,0,0};
-    float scale = 10.0;
-    int j = 0;
-    int index = 0;
-    if (num > 0)
-        makeCubes2D(location, scale, &index, cubes_position, cubes_scale, cubes_color);
-    std::cout << "Run " << j << " Made " << index << " cubes\n";
-    cube_count = index;
-     
-}
-
-void VoxelSystem::render() {
-    int i = 0;
-    while (i < cube_count) {
-        glPushMatrix();
-        glTranslatef(cubes_position[i*3], cubes_position[i*3+1], cubes_position[i*3+2]);
-        glColor3fv(&cubes_color[i*3]);
-        glutSolidCube(cubes_scale[i]);
-        glPopMatrix();
-        i++;
-    }
-}
-
-void VoxelSystem::simulate(float deltaTime) {
-    
-}
-
-
-
-
-

interface/src/Cube.h

@@ -1,33 +0,0 @@
-//
-//  Cube.h
-//  interface
-//
-//  Created by Philip on 12/31/12.
-//  Copyright (c) 2012 High Fidelity, Inc. All rights reserved.
-//
-
-#ifndef __interface__Cube__
-#define __interface__Cube__
-
-#include <glm/glm.hpp>
-#include "Util.h"
-#include "world.h"
-#include "InterfaceConfig.h"
-#include <iostream>
-
-class VoxelSystem {
-public:
-    VoxelSystem(int num,
-                   glm::vec3 box);
-    void simulate(float deltaTime);
-    void render();
-private:
-    struct Voxel {
-        glm::vec3 color;
-        bool hasChildren;
-        Voxel * children;
-    } *voxels;    
-};
-
-
-#endif

interface/src/Head.cpp

@@ -219,7 +219,7 @@ void Head::render(int faceToFace, float * myLocation)
     //std::cout << distanceToCamera << "\n";
     
     //  Don't render a head if it is really close to your location, because that is your own head!
-    if ((distanceToCamera > 0.1) || faceToFace) {
+    if ((distanceToCamera > 1.0) || faceToFace) {
         glEnable(GL_DEPTH_TEST);
         glPushMatrix();
 

interface/src/VoxelSystem.cpp

@@ -0,0 +1,128 @@
+//
+//  Cube.cpp
+//  interface
+//
+//  Created by Philip on 12/31/12.
+//  Copyright (c) 2012 High Fidelity, Inc. All rights reserved.
+//
+
+#include "VoxelSystem.h"
+
+
+bool onSphereShell(float radius, float scale, glm::vec3 * position) {
+    float vRadius = glm::length(*position);
+    return ((vRadius + scale/2.0 > radius) && (vRadius - scale/2.0 < radius));
+}
+
+void VoxelSystem::init() {
+    root = new Voxel;
+}
+
+//
+//  Recursively initialize the voxel tree
+//
+int VoxelSystem::initVoxels(Voxel * voxel, float scale, glm::vec3 * position) {
+    glm::vec3 averageColor(0,0,0);
+    int childrenCreated = 0;
+    int newVoxels = 0;
+    if (voxel == NULL) voxel = root;
+    averageColor[0] = averageColor[1] = averageColor[2] = 0.0;
+    
+    const float RADIUS = 3.9;
+    
+    //
+    //  First, randomly decide whether to stop here without recursing for children 
+    //
+    if (onSphereShell(RADIUS, scale, position) && (scale < 0.25) && (randFloat() < 0.01))
+    {
+        voxel->color.x = 0.1;
+        voxel->color.y = 0.5 + randFloat()*0.5;
+        voxel->color.z = 0.1;
+        for (unsigned char i = 0; i < NUM_CHILDREN; i++) voxel->children[i] = NULL;
+        return 0;
+    } else {
+        // Decide whether to make kids, recurse into them 
+        for (unsigned char i = 0; i < NUM_CHILDREN; i++) {
+            if  (scale > 0.01)              {
+                glm::vec3 shift(scale/2.0*((i&4)>>2)-scale/4.0,
+                                scale/2.0*((i&2)>>1)-scale/4.0,
+                                scale/2.0*(i&1)-scale/4.0);
+                *position += shift;
+                //  Test to see whether the child is also on edge of sphere
+                if (onSphereShell(RADIUS, scale/2.0, position)) {
+                    voxel->children[i] = new Voxel;
+                    newVoxels++;
+                    childrenCreated++;
+                    newVoxels += initVoxels(voxel->children[i], scale/2.0, position);
+                    averageColor += voxel->children[i]->color;
+                } else voxel->children[i] = NULL;
+                *position -= shift;
+            } else {
+                //  No child made: Set pointer to null, nothing to see here. 
+                voxel->children[i] = NULL;
+            }
+        }
+        if (childrenCreated > 0) {
+            //  If there were children created, the color of this voxel node is average of children
+            averageColor *= 1.0/childrenCreated;
+            voxel->color = averageColor;
+            return newVoxels;
+        } else {
+            //  Tested and didn't make any children, so choose my color as a leaf, return
+            voxel->color.x = voxel->color.y = voxel->color.z = 0.5 + randFloat()*0.5;
+            for (unsigned char i = 0; i < NUM_CHILDREN; i++) voxel->children[i] = NULL;
+            return 0;
+
+        }
+    }
+}
+
+//
+//  The Render Discard is the ratio of the size of the voxel to the distance from the camera
+//  at which the voxel will no longer be shown.  Smaller = show more detail.  
+//  
+
+const float RENDER_DISCARD = 0.04;  //0.01;
+
+//
+//  Returns the total number of voxels actually rendered
+//
+int VoxelSystem::render(Voxel * voxel, float scale, glm::vec3 * distance) {
+    // If null passed in, start at root
+    if (voxel == NULL) voxel = root;    
+    unsigned char i;
+    bool renderedChildren = false;
+    int vRendered = 0;
+    // Recursively render children
+    for (i = 0; i < NUM_CHILDREN; i++) {
+        glm::vec3 shift(scale/2.0*((i&4)>>2)-scale/4.0,
+                        scale/2.0*((i&2)>>1)-scale/4.0,
+                        scale/2.0*(i&1)-scale/4.0);
+        if ((voxel->children[i] != NULL) && (scale / glm::length(*distance) > RENDER_DISCARD)) {
+            glTranslatef(shift.x, shift.y, shift.z);
+            *distance += shift;
+            vRendered += render(voxel->children[i], scale/2.0, distance);
+            *distance -= shift;
+            glTranslatef(-shift.x, -shift.y, -shift.z);
+            renderedChildren = true;
+        }
+    }
+    //  Render this voxel if the children were not rendered 
+    if (!renderedChildren)
+    {
+        //  This is the place where we need to copy this data to a VBO to make this FAST
+        glColor4f(voxel->color.x, voxel->color.y, voxel->color.z, 1.0);
+        glutSolidCube(scale);
+        vRendered++;
+    }
+    return vRendered;
+}
+
+void VoxelSystem::simulate(float deltaTime) {
+    
+}
+
+
+
+
+

interface/src/VoxelSystem.h

@@ -0,0 +1,38 @@
+//
+//  Cube.h
+//  interface
+//
+//  Created by Philip on 12/31/12.
+//  Copyright (c) 2012 High Fidelity, Inc. All rights reserved.
+//
+
+#ifndef __interface__Cube__
+#define __interface__Cube__
+
+#include <glm/glm.hpp>
+#include "Util.h"
+#include "world.h"
+#include "InterfaceConfig.h"
+#include <iostream>
+
+const int NUM_CHILDREN = 8;
+
+struct Voxel {
+    glm::vec3 color;
+    Voxel * children[NUM_CHILDREN];
+};
+
+class VoxelSystem {
+public:
+    void simulate(float deltaTime);
+    int render(Voxel * voxel, float scale, glm::vec3 * distance);
+    void init();
+    int initVoxels(Voxel * root, float scale, glm::vec3 * position);
+    void setVoxelsRendered(int v) {voxelsRendered = v;};
+    int getVoxelsRendered() {return voxelsRendered;};
+    Voxel * root;
+private:
+    int voxelsRendered;
+};
+
+#endif

interface/src/main.cpp

@@ -38,7 +38,7 @@
 #include "Texture.h"
 #include "Cloud.h"
 #include "AgentList.h"
-#include "Cube.h"
+#include "VoxelSystem.h"
 #include "Lattice.h"
 #include "Finger.h"
 #include "Oscilloscope.h"
@@ -101,7 +101,7 @@ Cloud cloud(0,                             //  Particles
             false                          //  Wrap
             );
 
-VoxelSystem voxels(1000, box);
+VoxelSystem voxels;
 
 Lattice lattice(160,100);
 Finger myFinger(WIDTH, HEIGHT);
@@ -274,10 +274,16 @@ void display_stats(void)
 //    }
 //    drawtext(10,50,0.10, 0, 1.0, 0, (char *)pingTimes.str().c_str());
 
+    std::stringstream voxelStats;
+    voxelStats << "Voxels Rendered: " << voxels.getVoxelsRendered();
+    drawtext(10,70,0.10, 0, 1.0, 0, (char *)voxelStats.str().c_str());
 
+    
+    /*
     std::stringstream angles;
     angles << "render_yaw: " << myHead.getRenderYaw() << ", Yaw: " << myHead.getYaw();
     drawtext(10,50,0.10, 0, 1.0, 0, (char *)angles.str().c_str());
+    */
     
     /*
     char adc[200];
@@ -308,6 +314,11 @@ void initDisplay(void)
 
 void init(void)
 {
+    voxels.init();
+    glm::vec3 position(0,0,0);
+    int voxelsMade = voxels.initVoxels(NULL, 10.0, &position);
+    std::cout << voxelsMade << " voxels made. \n";
+    
     myHead.setRenderYaw(start_yaw);
 
     head_mouse_x = WIDTH/2;
@@ -395,7 +406,7 @@ void update_pos(float frametime)
     if (powf(measured_yaw_rate*measured_yaw_rate + 
              measured_pitch_rate*measured_pitch_rate, 0.5) > MIN_MOUSE_RATE)
     {
-        head_mouse_x -= measured_yaw_rate*MOUSE_SENSITIVITY;
+        head_mouse_x += measured_yaw_rate*MOUSE_SENSITIVITY;
         head_mouse_y += measured_pitch_rate*MOUSE_SENSITIVITY*(float)HEIGHT/(float)WIDTH; 
     }
     head_mouse_x = max(head_mouse_x, 0);
@@ -418,18 +429,18 @@ void update_pos(float frametime)
     */
                        
     //  Update render direction (pitch/yaw) based on measured gyro rates
-    const int MIN_YAW_RATE = 3000;
+    const int MIN_YAW_RATE = 100;
-    const float YAW_SENSITIVITY = 0.03;
+    const float YAW_SENSITIVITY = 0.08;
-    const int MIN_PITCH_RATE = 3000;
+    const int MIN_PITCH_RATE = 100;
     
     const float PITCH_SENSITIVITY = 0.04;
     
     if (fabs(measured_yaw_rate) > MIN_YAW_RATE)  
     {   
         if (measured_yaw_rate > 0)
-            render_yaw_rate -= (measured_yaw_rate - MIN_YAW_RATE) * YAW_SENSITIVITY * frametime;
+            render_yaw_rate += (measured_yaw_rate - MIN_YAW_RATE) * YAW_SENSITIVITY * frametime;
         else 
-            render_yaw_rate -= (measured_yaw_rate + MIN_YAW_RATE) * YAW_SENSITIVITY * frametime;
+            render_yaw_rate += (measured_yaw_rate + MIN_YAW_RATE) * YAW_SENSITIVITY * frametime;
     }
     if (fabs(measured_pitch_rate) > MIN_PITCH_RATE) 
     {
@@ -549,13 +560,24 @@ void display(void)
         glRotatef(myHead.getRenderYaw(), 0, 1, 0);
         glTranslatef(location[0], location[1], location[2]);
     
+        glColor3f(1,0,0);
+        glutSolidSphere(0.25, 15, 15);
+    
         //  Draw cloud of dots
         glDisable( GL_POINT_SPRITE_ARB );
         glDisable( GL_TEXTURE_2D );
         if (!display_head) cloud.render();
     
         //  Draw voxels
-        voxels.render();
+        glPushMatrix();
+        glTranslatef(WORLD_SIZE/2.0, WORLD_SIZE/2.0, WORLD_SIZE/2.0);
+        glm::vec3 distance(5.0 + location[0], 5.0 + location[1], 5.0 + location[2]);
+        //std::cout << "length: " << glm::length(distance) << "\n";
+        int voxelsRendered = voxels.render(NULL, 10.0, &distance);
+        voxels.setVoxelsRendered(voxelsRendered);
+        //glColor4f(0,0,1,0.5);
+        //glutSolidCube(10.0);
+        glPopMatrix();
     
         //  Draw field vectors
         if (display_field) field.render();