Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-04-20 03:44:02 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

resolve conflicts on merge with master

Browse source
This commit is contained in:
Stephen Birarda 2013-02-21 13:00:02 -08:00
commit ea43988173
6 changed files with 199 additions and 124 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

80
interface/src/Cube.cpp
View file

@ -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) {
}

33
interface/src/Cube.h
View file

@ -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

2
interface/src/Head.cpp
View file

@ -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();

128
interface/src/VoxelSystem.cpp Normal file
View file

@ -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) {
}

38
interface/src/VoxelSystem.h Normal file
View file

@ -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

42
interface/src/main.cpp
View file

@ -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,11 +274,17 @@ 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];
sprintf(adc, "location = %3.1f,%3.1f,%3.1f, angle_to(origin) = %3.1f, head yaw = %3.1f, render_yaw = %3.1f",
@ -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 float YAW_SENSITIVITY = 0.03;
const int MIN_PITCH_RATE = 3000;
const int MIN_YAW_RATE = 100;
const float YAW_SENSITIVITY = 0.08;
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();