mirror of
https://github.com/Armored-Dragon/overte.git
synced 2025-03-11 16:13:16 +01:00
263 lines
9.6 KiB
C++
263 lines
9.6 KiB
C++
//
|
|
// Cube.cpp
|
|
// interface
|
|
//
|
|
// Created by Philip on 12/31/12.
|
|
// Copyright (c) 2012 High Fidelity, Inc. All rights reserved.
|
|
//
|
|
|
|
#include "VoxelSystem.h"
|
|
|
|
const float MAX_Y_AXIS = 2.0;
|
|
const float MAX_X_AXIS = 20.0;
|
|
const float MAX_Z_AXIS = 20.0;
|
|
|
|
const int VERTICES_PER_VOXEL = 8;
|
|
const int VERTEX_POINTS_PER_VOXEL = 3 * VERTICES_PER_VOXEL;
|
|
const int COLOR_VALUES_PER_VOXEL = 3 * VERTICES_PER_VOXEL;
|
|
const int INDICES_PER_VOXEL = 3 * 12;
|
|
|
|
GLfloat identityVertices[] = { -1, -1, 1,
|
|
1, -1, 1,
|
|
1, -1, -1,
|
|
-1, -1, -1,
|
|
1, 1, 1,
|
|
-1, 1, 1,
|
|
-1, 1, -1,
|
|
1, 1, -1 };
|
|
|
|
GLubyte identityIndices[] = { 0,1,2, 0,2,3,
|
|
0,4,1, 0,4,5,
|
|
0,3,6, 0,5,6,
|
|
1,2,4, 2,4,7,
|
|
2,3,6, 2,6,7,
|
|
4,5,6, 4,6,7 };
|
|
|
|
|
|
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;
|
|
}
|
|
|
|
float randomFloat(float maximumValue) {
|
|
return ((float) rand() / ((float) RAND_MAX / maximumValue));
|
|
}
|
|
|
|
void VoxelSystem::init(int numberOfRandomVoxels) {
|
|
// create the arrays needed to pass to glDrawElements later
|
|
// position / color are random for now
|
|
|
|
voxelsRendered = numberOfRandomVoxels;
|
|
|
|
// there are 3 points for each vertices, 24 vertices in each cube
|
|
GLfloat *verticesArray = new GLfloat[VERTEX_POINTS_PER_VOXEL * numberOfRandomVoxels];
|
|
|
|
// we need a color for each vertex in each voxel
|
|
GLfloat *colorsArray = new GLfloat[COLOR_VALUES_PER_VOXEL * numberOfRandomVoxels];
|
|
|
|
// there are 12 triangles in each cube, with three indices for each triangle
|
|
GLuint *indicesArray = new GLuint[INDICES_PER_VOXEL * numberOfRandomVoxels];
|
|
|
|
// new seed based on time now so voxels are different each time
|
|
srand((unsigned)time(0));
|
|
|
|
for (int n = 0; n < numberOfRandomVoxels; n++) {
|
|
// pick a random point for the center of the cube
|
|
const float DEATH_STAR_RADIUS = 4.0;
|
|
const float MAX_CUBE = 0.05;
|
|
float azimuth = randFloat()*2*PI;
|
|
float altitude = randFloat()*PI - PI/2;
|
|
float radius = DEATH_STAR_RADIUS;
|
|
float thisScale = MAX_CUBE*1/(float)(rand()%8 + 1);
|
|
float radius_twiddle = (DEATH_STAR_RADIUS/100)*powf(2, (float)(rand()%8));
|
|
radius += radius_twiddle + (randFloat()*DEATH_STAR_RADIUS/12 - DEATH_STAR_RADIUS/24);
|
|
glm::vec3 position = glm::vec3(
|
|
radius * cosf(azimuth) * cosf(altitude),
|
|
radius * sinf(azimuth) * cosf(altitude),
|
|
radius * sinf(altitude)
|
|
);
|
|
|
|
// fill the vertices array, and scale the voxels
|
|
GLfloat *currentVerticesPos = verticesArray + (n * VERTEX_POINTS_PER_VOXEL);
|
|
for (int v = 0; v < VERTEX_POINTS_PER_VOXEL; v++) {
|
|
currentVerticesPos[v] = position[v % 3] + (identityVertices[v] * thisScale);
|
|
}
|
|
|
|
// fill the colors array
|
|
const float MIN_BRIGHTNESS = 0.25;
|
|
GLfloat *currentColorPos = colorsArray + (n * COLOR_VALUES_PER_VOXEL);
|
|
float voxelR = MIN_BRIGHTNESS + randomFloat(1)*(1.0 - MIN_BRIGHTNESS);
|
|
float voxelG = voxelR;
|
|
float voxelB = voxelR;
|
|
|
|
for (int c = 0; c < VERTICES_PER_VOXEL; c++) {
|
|
currentColorPos[0 + (c * 3)] = voxelR;
|
|
currentColorPos[1 + (c * 3)] = voxelG;
|
|
currentColorPos[2 + (c * 3)] = voxelB;
|
|
}
|
|
|
|
// fill the indices array
|
|
int voxelIndexOffset = n * INDICES_PER_VOXEL;
|
|
GLuint *currentIndicesPos = indicesArray + voxelIndexOffset;
|
|
int startIndex = (n * VERTICES_PER_VOXEL);
|
|
|
|
for (int i = 0; i < INDICES_PER_VOXEL; i++) {
|
|
// add indices for this side of the cube
|
|
currentIndicesPos[i] = startIndex + identityIndices[i];
|
|
}
|
|
}
|
|
|
|
// VBO for the verticesArray
|
|
glGenBuffers(1, &vboVerticesID);
|
|
glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID);
|
|
glBufferData(GL_ARRAY_BUFFER, VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat) * numberOfRandomVoxels, verticesArray, GL_STATIC_DRAW);
|
|
|
|
// VBO for colorsArray
|
|
glGenBuffers(1, &vboColorsID);
|
|
glBindBuffer(GL_ARRAY_BUFFER, vboColorsID);
|
|
glBufferData(GL_ARRAY_BUFFER, COLOR_VALUES_PER_VOXEL * sizeof(GLfloat) * numberOfRandomVoxels, colorsArray, GL_STATIC_DRAW);
|
|
|
|
// VBO for the indicesArray
|
|
glGenBuffers(1, &vboIndicesID);
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID);
|
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, numberOfRandomVoxels * INDICES_PER_VOXEL * sizeof(GLuint), indicesArray, GL_STATIC_DRAW);
|
|
|
|
// delete the verticesArray, indicesArray
|
|
delete[] verticesArray;
|
|
delete[] indicesArray;
|
|
delete[] colorsArray;
|
|
}
|
|
|
|
//
|
|
// 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::render() {
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glEnableClientState(GL_COLOR_ARRAY);
|
|
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID);
|
|
glVertexPointer(3, GL_FLOAT, 0, 0);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, vboColorsID);
|
|
glColorPointer(3, GL_FLOAT, 0, 0);
|
|
|
|
glNormal3f(0, 1, 0);
|
|
|
|
glDrawElements(GL_TRIANGLES, 36 * voxelsRendered, GL_UNSIGNED_INT, 0);
|
|
|
|
// deactivate vertex and color arrays after drawing
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
glDisableClientState(GL_COLOR_ARRAY);
|
|
|
|
// bind with 0 to switch back to normal operation
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
|
|
}
|
|
|
|
void VoxelSystem::simulate(float deltaTime) {
|
|
|
|
}
|
|
|