mirror of
https://github.com/overte-org/overte.git
synced 2025-06-21 13:20:58 +02:00
356 lines
12 KiB
C++
356 lines
12 KiB
C++
//
|
|
// Cube.cpp
|
|
// interface
|
|
//
|
|
// Created by Philip on 12/31/12.
|
|
// Copyright (c) 2012 High Fidelity, Inc. All rights reserved.
|
|
//
|
|
|
|
#include <cstring>
|
|
#include <cmath>
|
|
#include <iostream> // to load voxels from file
|
|
#include <fstream> // to load voxels from file
|
|
#include <SharedUtil.h>
|
|
#include <OctalCode.h>
|
|
#include "VoxelSystem.h"
|
|
|
|
const int MAX_VOXELS_PER_SYSTEM = 250000;
|
|
|
|
const int VERTICES_PER_VOXEL = 8;
|
|
const int VERTEX_POINTS_PER_VOXEL = 3 * VERTICES_PER_VOXEL;
|
|
const int INDICES_PER_VOXEL = 3 * 12;
|
|
|
|
float identityVertices[] = { 0, 0, 0,
|
|
1, 0, 0,
|
|
1, 1, 0,
|
|
0, 1, 0,
|
|
0, 0, 1,
|
|
1, 0, 1,
|
|
1, 1, 1,
|
|
0, 1, 1 };
|
|
|
|
GLubyte identityIndices[] = { 0,1,2, 0,2,3,
|
|
0,1,5, 0,4,5,
|
|
0,3,7, 0,4,7,
|
|
1,2,6, 1,5,6,
|
|
2,3,7, 2,6,7,
|
|
4,5,6, 4,6,7 };
|
|
|
|
VoxelSystem::VoxelSystem() {
|
|
voxelsRendered = 0;
|
|
tree = new VoxelTree();
|
|
}
|
|
|
|
VoxelSystem::~VoxelSystem() {
|
|
delete[] verticesArray;
|
|
delete[] colorsArray;
|
|
delete tree;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// Method: VoxelSystem::loadVoxelsFile()
|
|
// Description: Loads HiFidelity encoded Voxels from a binary file. The current file
|
|
// format is a stream of single voxels with NO color data. Currently
|
|
// colors are set randomly
|
|
// Complaints: Brad :)
|
|
// To Do: Need to add color data to the file.
|
|
void VoxelSystem::loadVoxelsFile(char* fileName) {
|
|
|
|
std::ifstream file(fileName, std::ios::in|std::ios::binary);
|
|
|
|
char octets;
|
|
unsigned int lengthInBytes;
|
|
|
|
int totalBytesRead = 0;
|
|
if(file.is_open())
|
|
{
|
|
while (!file.eof()) {
|
|
file.get(octets);
|
|
totalBytesRead++;
|
|
lengthInBytes = (octets*3/8)+1;
|
|
unsigned char * voxelData = new unsigned char[lengthInBytes+1+3];
|
|
voxelData[0]=octets;
|
|
char byte;
|
|
|
|
for (size_t i = 0; i < lengthInBytes; i++) {
|
|
file.get(byte);
|
|
totalBytesRead++;
|
|
voxelData[i+1] = byte;
|
|
}
|
|
// random color data
|
|
voxelData[lengthInBytes+1] = randomColorValue(65);
|
|
voxelData[lengthInBytes+2] = randomColorValue(65);
|
|
voxelData[lengthInBytes+3] = randomColorValue(65);
|
|
|
|
tree->readCodeColorBufferToTree(voxelData);
|
|
delete voxelData;
|
|
}
|
|
file.close();
|
|
}
|
|
|
|
// reset the verticesEndPointer so we're writing to the beginning of the array
|
|
verticesEndPointer = verticesArray;
|
|
// call recursive function to populate in memory arrays
|
|
// it will return the number of voxels added
|
|
voxelsRendered = treeToArrays(tree->rootNode);
|
|
// set the boolean if there are any voxels to be rendered so we re-fill the VBOs
|
|
voxelsToRender = (voxelsRendered > 0);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// Method: VoxelSystem::createSphere()
|
|
// Description: Creates a sphere of voxels in the local system at a given location/radius
|
|
// To Do: Move this function someplace better? I put it here because we need a
|
|
// mechanism to tell the system to redraw it's arrays after voxels are done
|
|
// being added. This is a concept mostly only understood by VoxelSystem.
|
|
// Complaints: Brad :)
|
|
void VoxelSystem::createSphere(float r,float xc, float yc, float zc, float s, bool solid)
|
|
{
|
|
// About the color of the sphere... we're going to make this sphere be a gradient
|
|
// between two RGB colors. We will do the gradient along the phi spectrum
|
|
unsigned char r1 = randomColorValue(165);
|
|
unsigned char g1 = randomColorValue(165);
|
|
unsigned char b1 = randomColorValue(165);
|
|
unsigned char r2 = randomColorValue(65);
|
|
unsigned char g2 = randomColorValue(65);
|
|
unsigned char b2 = randomColorValue(65);
|
|
|
|
// we don't want them to match!!
|
|
if (r1==r2 && g1==g2 && b1==b2)
|
|
{
|
|
r2=r1/2;
|
|
g2=g1/2;
|
|
b2=b1/2;
|
|
}
|
|
|
|
/**
|
|
std::cout << "creatSphere COLORS ";
|
|
std::cout << " r1=" << (int)r1;
|
|
std::cout << " g1=" << (int)g1;
|
|
std::cout << " b1=" << (int)b1;
|
|
std::cout << " r2=" << (int)r2;
|
|
std::cout << " g2=" << (int)g2;
|
|
std::cout << " b2=" << (int)b2;
|
|
std::cout << std::endl;
|
|
**/
|
|
|
|
// Psuedocode for creating a sphere:
|
|
//
|
|
// for (theta from 0 to 2pi):
|
|
// for (phi from 0 to pi):
|
|
// x = xc+r*cos(theta)*sin(phi)
|
|
// y = yc+r*sin(theta)*sin(phi)
|
|
// z = zc+r*cos(phi)
|
|
|
|
int t=0; // total points
|
|
|
|
// We want to make sure that as we "sweep" through our angles
|
|
// we use a delta angle that's small enough to not skip any voxels
|
|
// we can calculate theta from our desired arc length
|
|
//
|
|
// lenArc = ndeg/360deg * 2pi*R
|
|
// lenArc = theta/2pi * 2pi*R
|
|
// lenArc = theta*R
|
|
// theta = lenArc/R
|
|
// theta = g/r
|
|
float angleDelta = (s/r);
|
|
|
|
// assume solid for now
|
|
float ri = 0.0;
|
|
if (!solid)
|
|
{
|
|
ri=r; // just the outer surface
|
|
}
|
|
// If you also iterate form the interior of the sphere to the radius, makeing
|
|
// larger and larger sphere's you'd end up with a solid sphere. And lots of voxels!
|
|
for (; ri <= r; ri+=s)
|
|
{
|
|
for (float theta=0.0; theta <= 2*M_PI; theta += angleDelta)
|
|
{
|
|
for (float phi=0.0; phi <= M_PI; phi += angleDelta)
|
|
{
|
|
t++; // total voxels
|
|
float x = xc+r*cos(theta)*sin(phi);
|
|
float y = yc+r*sin(theta)*sin(phi);
|
|
float z = zc+r*cos(phi);
|
|
/*
|
|
std::cout << " r=" << r;
|
|
std::cout << " theta=" << theta;
|
|
std::cout << " phi=" << phi;
|
|
std::cout << " x=" << x;
|
|
std::cout << " y=" << y;
|
|
std::cout << " z=" << z;
|
|
std::cout << " t=" << t;
|
|
std::cout << std::endl;
|
|
*/
|
|
|
|
// gradient color data
|
|
float gradient = (phi/M_PI);
|
|
unsigned char red = r1+((r2-r1)*gradient);
|
|
unsigned char green = g1+((g2-g1)*gradient);
|
|
unsigned char blue = b1+((b2-b1)*gradient);
|
|
|
|
unsigned char* voxelData = pointToVoxel(x,y,z,s,red,green,blue);
|
|
tree->readCodeColorBufferToTree(voxelData);
|
|
delete voxelData;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
// reset the verticesEndPointer so we're writing to the beginning of the array
|
|
verticesEndPointer = verticesArray;
|
|
// call recursive function to populate in memory arrays
|
|
// it will return the number of voxels added
|
|
voxelsRendered = treeToArrays(tree->rootNode);
|
|
// set the boolean if there are any voxels to be rendered so we re-fill the VBOs
|
|
voxelsToRender = (voxelsRendered > 0);
|
|
}
|
|
|
|
|
|
void VoxelSystem::parseData(void *data, int size) {
|
|
// output the bits received from the voxel server
|
|
unsigned char *voxelData = (unsigned char *) data + 1;
|
|
|
|
printf("Received a packet of %d bytes from VS\n", size);
|
|
|
|
// ask the VoxelTree to read the bitstream into the tree
|
|
tree->readBitstreamToTree(voxelData, size - 1);
|
|
|
|
// reset the verticesEndPointer so we're writing to the beginning of the array
|
|
verticesEndPointer = verticesArray;
|
|
|
|
// call recursive function to populate in memory arrays
|
|
// it will return the number of voxels added
|
|
voxelsRendered = treeToArrays(tree->rootNode);
|
|
|
|
// set the boolean if there are any voxels to be rendered so we re-fill the VBOs
|
|
voxelsToRender = (voxelsRendered > 0);
|
|
}
|
|
|
|
int VoxelSystem::treeToArrays(VoxelNode *currentNode) {
|
|
int voxelsAdded = 0;
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
// check if there is a child here
|
|
if (currentNode->children[i] != NULL) {
|
|
voxelsAdded += treeToArrays(currentNode->children[i]);
|
|
}
|
|
}
|
|
|
|
// if we didn't get any voxels added then we're a leaf
|
|
// add our vertex and color information to the interleaved array
|
|
if (voxelsAdded == 0 && currentNode->color[3] == 1) {
|
|
float * startVertex = firstVertexForCode(currentNode->octalCode);
|
|
float voxelScale = 1 / powf(2, *currentNode->octalCode);
|
|
|
|
// populate the array with points for the 8 vertices
|
|
// and RGB color for each added vertex
|
|
for (int j = 0; j < VERTEX_POINTS_PER_VOXEL; j++ ) {
|
|
*verticesEndPointer = startVertex[j % 3] + (identityVertices[j] * voxelScale);
|
|
*(colorsArray + (verticesEndPointer - verticesArray)) = currentNode->color[j % 3];
|
|
|
|
verticesEndPointer++;
|
|
}
|
|
|
|
voxelsAdded++;
|
|
|
|
delete [] startVertex;
|
|
}
|
|
|
|
return voxelsAdded;
|
|
}
|
|
|
|
VoxelSystem* VoxelSystem::clone() const {
|
|
// this still needs to be implemented, will need to be used if VoxelSystem is attached to agent
|
|
return NULL;
|
|
}
|
|
|
|
void VoxelSystem::init() {
|
|
// prep the data structures for incoming voxel data
|
|
verticesArray = new GLfloat[VERTEX_POINTS_PER_VOXEL * MAX_VOXELS_PER_SYSTEM];
|
|
colorsArray = new GLubyte[VERTEX_POINTS_PER_VOXEL * MAX_VOXELS_PER_SYSTEM];
|
|
|
|
GLuint *indicesArray = new GLuint[INDICES_PER_VOXEL * MAX_VOXELS_PER_SYSTEM];
|
|
|
|
// populate the indicesArray
|
|
// this will not change given new voxels, so we can set it all up now
|
|
for (int n = 0; n < MAX_VOXELS_PER_SYSTEM; n++) {
|
|
// 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) * MAX_VOXELS_PER_SYSTEM, NULL, GL_DYNAMIC_DRAW);
|
|
|
|
// VBO for colorsArray
|
|
glGenBuffers(1, &vboColorsID);
|
|
glBindBuffer(GL_ARRAY_BUFFER, vboColorsID);
|
|
glBufferData(GL_ARRAY_BUFFER, VERTEX_POINTS_PER_VOXEL * sizeof(GLubyte) * MAX_VOXELS_PER_SYSTEM, NULL, GL_DYNAMIC_DRAW);
|
|
|
|
// VBO for the indicesArray
|
|
glGenBuffers(1, &vboIndicesID);
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID);
|
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, INDICES_PER_VOXEL * sizeof(GLuint) * MAX_VOXELS_PER_SYSTEM, indicesArray, GL_STATIC_DRAW);
|
|
|
|
// delete the indices array that is no longer needed
|
|
delete[] indicesArray;
|
|
}
|
|
|
|
void VoxelSystem::render() {
|
|
|
|
glPushMatrix();
|
|
|
|
if (voxelsToRender) {
|
|
glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID);
|
|
glBufferData(GL_ARRAY_BUFFER, VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat) * MAX_VOXELS_PER_SYSTEM, NULL, GL_DYNAMIC_DRAW);
|
|
glBufferSubData(GL_ARRAY_BUFFER, 0, (verticesEndPointer - verticesArray) * sizeof(GLfloat), verticesArray);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, vboColorsID);
|
|
glBufferData(GL_ARRAY_BUFFER, VERTEX_POINTS_PER_VOXEL * sizeof(GLubyte) * MAX_VOXELS_PER_SYSTEM, NULL, GL_DYNAMIC_DRAW);
|
|
glBufferSubData(GL_ARRAY_BUFFER, 0, (verticesEndPointer - verticesArray) * sizeof(GLubyte), colorsArray);
|
|
|
|
voxelsToRender = false;
|
|
}
|
|
|
|
// tell OpenGL where to find vertex and color information
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glEnableClientState(GL_COLOR_ARRAY);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID);
|
|
glVertexPointer(3, GL_FLOAT, 0, 0);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, vboColorsID);
|
|
glColorPointer(3, GL_UNSIGNED_BYTE, 0, 0);
|
|
|
|
// draw the number of voxels we have
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID);
|
|
glScalef(10, 10, 10);
|
|
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);
|
|
|
|
// scale back down to 1 so heads aren't massive
|
|
glPopMatrix();
|
|
}
|
|
|
|
void VoxelSystem::simulate(float deltaTime) {
|
|
|
|
}
|
|
|
|
|