//// Cube.cpp// interface//// Created by Philip on 12/31/12.// Copyright (c) 2012 High Fidelity, Inc. All rights reserved.//#ifdef _WIN32#define _timeval_#define _USE_MATH_DEFINES#endif#include <cstring>#include <cmath>#include <iostream> // to load voxels from file#include <fstream> // to load voxels from file#include <SharedUtil.h>#include <PacketHeaders.h>#include <OctalCode.h>#include <pthread.h>#include "Log.h" #include "VoxelSystem.h" const int MAX_VOXELS_PER_SYSTEM = 250000; const int VERTICES_PER_VOXEL = 24;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, 0,0,0, 1,0,0, 1,1,0, 0,1,0, 0,0,1, 1,0,1, 1,1,1, 0,1,1, 0,0,0, 1,0,0, 1,1,0, 0,1,0, 0,0,1, 1,0,1, 1,1,1, 0,1,1 }; GLfloat identityNormals[] = { 0,0,-1, 0,0,-1, 0,0,-1, 0,0,-1, 0,0,+1, 0,0,+1, 0,0,+1, 0,0,+1, 0,-1,0, 0,-1,0, 0,+1,0, 0,+1,0, 0,-1,0, 0,-1,0, 0,+1,0, 0,+1,0, -1,0,0, +1,0,0, +1,0,0, -1,0,0, -1,0,0, +1,0,0, +1,0,0, -1,0,0 }; GLubyte identityIndices[] = { 0,2,1, 0,3,2, // Z- . 8,9,13, 8,13,12, // Y- 16,23,19, 16,20,23, // X- 17,18,22, 17,22,21, // X+ 10,11,15, 10,15,14, // Y+ 4,5,6, 4,6,7 }; // Z+ . VoxelSystem::VoxelSystem() { voxelsRendered = 0; tree = new VoxelTree(); pthread_mutex_init(&bufferWriteLock, NULL);} VoxelSystem::~VoxelSystem() { delete[] readVerticesArray; delete[] writeVerticesArray; delete[] readColorsArray; delete[] writeColorsArray; delete tree; pthread_mutex_destroy(&bufferWriteLock);} void VoxelSystem::setViewerAvatar(Avatar *newViewerAvatar) { viewerAvatar = newViewerAvatar;} //////////////////////////////////////////////////////////////////////////////////////////// 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(const char* fileName, bool wantColorRandomizer) { tree->loadVoxelsFile(fileName,wantColorRandomizer); copyWrittenDataToReadArrays();} //////////////////////////////////////////////////////////////////////////////////////////// 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, bool wantColorRandomizer) { tree->createSphere(r,xc,yc,zc,s,solid,wantColorRandomizer); setupNewVoxelsForDrawing();} long int VoxelSystem::getVoxelsCreated() { return tree->voxelsCreated;} float VoxelSystem::getVoxelsCreatedPerSecondAverage() { return (1 / tree->voxelsCreatedStats.getEventDeltaAverage());} long int VoxelSystem::getVoxelsColored() { return tree->voxelsColored;} float VoxelSystem::getVoxelsColoredPerSecondAverage() { return (1 / tree->voxelsColoredStats.getEventDeltaAverage());} long int VoxelSystem::getVoxelsBytesRead() { return tree->voxelsBytesRead;} float VoxelSystem::getVoxelsBytesReadPerSecondAverage() { return tree->voxelsBytesReadStats.getAverageSampleValuePerSecond();} bool pickAorB = false; int VoxelSystem::parseData(unsigned char* sourceBuffer, int numBytes) { unsigned char command = *sourceBuffer; unsigned char *voxelData = sourceBuffer + 1; switch(command) { case PACKET_HEADER_VOXEL_DATA: { /***************** TEMPORARY CODE ********************************************************************************* // YES! Stephen - I have intentionally placed this horrible UGLY LINE across your screen! I did it so you and I // would make a point of removing this code when all this work is done. But in the mean time, I need it here for // debugging purposes... When you do the code review... DO NOT tell me to remove it. :) Thank you! // unsigned char fakeBuffer[18] = { 86, // V 2,0, // octcode for root 136, // child color bits 0,0,255, // child 128 color 0,255,0, // child 8 color 0, // child tree bits - none // now some extra bits, what happens??? 2,252, // octcode for root 1, // child color bits 255,0,0, // child 1 color 0 // child tree bits }; //printf("loading fake data! fakeBuffer \n"); tree->readBitstreamToTree((unsigned char*)&fakeBuffer[1], sizeof(fakeBuffer)-1); unsigned char fakeBuffer[11] = { 86, // V 2,0, // octcode for root 136, // child color bits 0,0,255, // child 128 color 0,255,0, // child 8 color 0 // child tree bits - none }; printf("loading fake data! fakeBuffer \n"); tree->readBitstreamToTree((unsigned char*)&fakeBuffer[1], sizeof(fakeBuffer)-1); unsigned char fakeBufferA[11] = { 86, // V 0, // octcode for root 0, // child color bits? 128, // child exists bits 0, // child color bits 128, // child exists 128, // child color bits 0,0,255, // child color 0 // child exists bits }; unsigned char fakeBufferB[11] = { 86, // V 0, // octcode for root 0, // child color bits? 128, // child exists bits 0, // child color bits 128, // child exists 16, // child color bits 0,255,0, // child color?? 0 // child exists bits }; // trim off the "V" printf("loading fake data! pickAorB=%s\n", (pickAorB ? "A" : "B") ); if (pickAorB) { tree->readBitstreamToTree((unsigned char*)&fakeBufferA[1], sizeof(fakeBufferA)-1); } else { tree->readBitstreamToTree((unsigned char*)&fakeBufferB[1], sizeof(fakeBufferB)-1); } pickAorB = !pickAorB; ***** END OF TEMPORARY CODE ***************************************************************************************/ // ask the VoxelTree to read the bitstream into the tree tree->readBitstreamToTree(voxelData, numBytes - 1); } break; case PACKET_HEADER_ERASE_VOXEL: // ask the tree to read the "remove" bitstream tree->processRemoveVoxelBitstream(sourceBuffer, numBytes); break; case PACKET_HEADER_Z_COMMAND: // the Z command is a special command that allows the sender to send high level semantic // requests, like erase all, or add sphere scene, different receivers may handle these // messages differently char* packetData = (char *)sourceBuffer; char* command = &packetData[1]; // start of the command int commandLength = strlen(command); // commands are null terminated strings int totalLength = 1+commandLength+1; printLog("got Z message len(%d)= %s\n", numBytes, command); while (totalLength <= numBytes) { if (0==strcmp(command,(char*)"erase all")) { printLog("got Z message == erase all\n"); tree->eraseAllVoxels(); } if (0==strcmp(command,(char*)"add scene")) { printLog("got Z message == add scene - NOT SUPPORTED ON INTERFACE\n"); } totalLength += commandLength+1; } break; } setupNewVoxelsForDrawing(); return numBytes;} void VoxelSystem::setupNewVoxelsForDrawing() { // reset the verticesEndPointer so we're writing to the beginning of the array writeVerticesEndPointer = writeVerticesArray; // call recursive function to populate in memory arrays // it will return the number of voxels added glm::vec3 treeRoot = glm::vec3(0,0,0); voxelsRendered = treeToArrays(tree->rootNode, treeRoot); // copy the newly written data to the arrays designated for reading copyWrittenDataToReadArrays();} void VoxelSystem::copyWrittenDataToReadArrays() { // lock on the buffer write lock so we can't modify the data when the GPU is reading it pthread_mutex_lock(&bufferWriteLock); // store a pointer to the current end so it doesn't change during copy GLfloat *endOfCurrentVerticesData = writeVerticesEndPointer; // copy the vertices and colors memcpy(readVerticesArray, writeVerticesArray, (endOfCurrentVerticesData - writeVerticesArray) * sizeof(GLfloat)); memcpy(readColorsArray, writeColorsArray, (endOfCurrentVerticesData - writeVerticesArray) * sizeof(GLubyte)); // set the read vertices end pointer to the correct spot so the GPU knows how much to pull readVerticesEndPointer = readVerticesArray + (endOfCurrentVerticesData - writeVerticesArray); pthread_mutex_unlock(&bufferWriteLock);} int VoxelSystem::treeToArrays(VoxelNode *currentNode, const glm::vec3& nodePosition) { int voxelsAdded = 0; float halfUnitForVoxel = powf(0.5, *currentNode->octalCode) * (0.5 * TREE_SCALE); glm::vec3 viewerPosition = viewerAvatar->getPosition(); // debug LOD code glm::vec3 debugNodePosition; copyFirstVertexForCode(currentNode->octalCode,(float*)&debugNodePosition); //printf("-----------------\n"); //printf("halfUnitForVoxel=%f\n",halfUnitForVoxel); //printf("viewer.x=%f y=%f z=%f \n", viewerPosition.x, viewerPosition.y, viewerPosition.z); //printf("node.x=%f y=%f z=%f \n", nodePosition[0], nodePosition[1], nodePosition[2]); //printf("debugNodePosition.x=%f y=%f z=%f \n", debugNodePosition[0], debugNodePosition[1], debugNodePosition[2]); float distanceToVoxelCenter = sqrtf(powf(viewerPosition.x - nodePosition[0] - halfUnitForVoxel, 2) + powf(viewerPosition.y - nodePosition[1] - halfUnitForVoxel, 2) + powf(viewerPosition.z - nodePosition[2] - halfUnitForVoxel, 2)); int renderLevel = *currentNode->octalCode + 1; int boundaryPosition = boundaryDistanceForRenderLevel(renderLevel); //printLog("treeToArrays() renderLevel=%d distanceToVoxelCenter=%f boundaryPosition=%d\n", // renderLevel,distanceToVoxelCenter,boundaryPosition); bool alwaysDraw = false; // XXXBHG - temporary debug code. Flip this to true to disable LOD blurring if (alwaysDraw || distanceToVoxelCenter < boundaryPosition) { for (int i = 0; i < 8; i++) { // check if there is a child here if (currentNode->children[i] != NULL) { glm::vec3 childNodePosition; copyFirstVertexForCode(currentNode->children[i]->octalCode,(float*)&childNodePosition); childNodePosition *= (float)TREE_SCALE; // scale it up /**** disabled ************************************************************************************************ // Note: Stephen, I intentionally left this in so you would talk to me about it. Here's the deal, this code // doesn't seem to work correctly. It returns X and Z flipped and the values are negative. Since we use the // firstVertexForCode() function below to calculate the child vertex and that DOES work, I've decided to use // that function to calculate our position for LOD handling. // // calculate the child's position based on the parent position for (int j = 0; j < 3; j++) { childNodePosition[j] = nodePosition[j]; if (oneAtBit(branchIndexWithDescendant(currentNode->octalCode,currentNode->children[i]->octalCode),(7 - j))) { childNodePosition[j] -= (powf(0.5, *currentNode->children[i]->octalCode) * TREE_SCALE); } } **** disabled ************************************************************************************************/ voxelsAdded += treeToArrays(currentNode->children[i], childNodePosition); } } } // 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->isColored()) { float startVertex[3]; copyFirstVertexForCode(currentNode->octalCode,(float*)&startVertex); 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++ ) { *writeVerticesEndPointer = startVertex[j % 3] + (identityVertices[j] * voxelScale); *(writeColorsArray + (writeVerticesEndPointer - writeVerticesArray)) = currentNode->getColor()[j % 3]; writeVerticesEndPointer++; } voxelsAdded++; } 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 writeVerticesEndPointer = writeVerticesArray = new GLfloat[VERTEX_POINTS_PER_VOXEL * MAX_VOXELS_PER_SYSTEM]; readVerticesEndPointer = readVerticesArray = new GLfloat[VERTEX_POINTS_PER_VOXEL * MAX_VOXELS_PER_SYSTEM]; writeColorsArray = new GLubyte[VERTEX_POINTS_PER_VOXEL * MAX_VOXELS_PER_SYSTEM]; readColorsArray = 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]; } } GLfloat *normalsArray = new GLfloat[VERTEX_POINTS_PER_VOXEL * MAX_VOXELS_PER_SYSTEM]; GLfloat *normalsArrayEndPointer = normalsArray; // populate the normalsArray for (int n = 0; n < MAX_VOXELS_PER_SYSTEM; n++) { for (int i = 0; i < VERTEX_POINTS_PER_VOXEL; i++) { *(normalsArrayEndPointer++) = identityNormals[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 the normalsArray glGenBuffers(1, &vboNormalsID); glBindBuffer(GL_ARRAY_BUFFER, vboNormalsID); glBufferData(GL_ARRAY_BUFFER, VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat) * MAX_VOXELS_PER_SYSTEM, normalsArray, GL_STATIC_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 and normals arrays that are no longer needed delete[] indicesArray; delete[] normalsArray;} void VoxelSystem::render() { glPushMatrix(); if (readVerticesEndPointer != readVerticesArray) { // try to lock on the buffer write // just avoid pulling new data if it is currently being written if (pthread_mutex_trylock(&bufferWriteLock) == 0) { glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID); glBufferSubData(GL_ARRAY_BUFFER, 0, (readVerticesEndPointer - readVerticesArray) * sizeof(GLfloat), readVerticesArray); glBindBuffer(GL_ARRAY_BUFFER, vboColorsID); glBufferSubData(GL_ARRAY_BUFFER, 0, (readVerticesEndPointer - readVerticesArray) * sizeof(GLubyte), readColorsArray); readVerticesEndPointer = readVerticesArray; pthread_mutex_unlock(&bufferWriteLock); } } // tell OpenGL where to find vertex and color information glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID); glVertexPointer(3, GL_FLOAT, 0, 0); glBindBuffer(GL_ARRAY_BUFFER, vboNormalsID); glNormalPointer(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_NORMAL_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) { } int VoxelSystem::_nodeCount = 0; bool VoxelSystem::randomColorOperation(VoxelNode* node, bool down, void* extraData) { // we do our operations on the way up! if (down) { return true; } _nodeCount++; if (node->isColored()) { nodeColor newColor = { 0,0,0,1 }; newColor[0] = randomColorValue(150); newColor[1] = randomColorValue(150); newColor[1] = randomColorValue(150); //printf("randomize color node %d was %x,%x,%x NOW %x,%x,%x\n", // _nodeCount,node->getTrueColor()[0],node->getTrueColor()[1],node->getTrueColor()[2], // newColor[0],newColor[1],newColor[2]); node->setColor(newColor); } else { //printf("not randomizing color node of %d since it has no color\n",_nodeCount); } return true;} void VoxelSystem::randomizeVoxelColors() { _nodeCount = 0; tree->recurseTreeWithOperation(randomColorOperation); printf("setting randomized true color for %d nodes\n",_nodeCount); setupNewVoxelsForDrawing();} bool VoxelSystem::falseColorizeRandomOperation(VoxelNode* node, bool down, void* extraData) { // we do our operations on the way up! if (down) { return true; } _nodeCount++;Lines 1–500 of 734. Load more
// // Cube.cpp // interface // // Created by Philip on 12/31/12. // Copyright (c) 2012 High Fidelity, Inc. All rights reserved. // #ifdef _WIN32 #define _timeval_ #define _USE_MATH_DEFINES #endif #include <cstring> #include <cmath> #include <iostream> // to load voxels from file #include <fstream> // to load voxels from file #include <SharedUtil.h> #include <PacketHeaders.h> #include <OctalCode.h> #include <pthread.h> #include "Log.h" #include "VoxelSystem.h" const int MAX_VOXELS_PER_SYSTEM = 250000; const int VERTICES_PER_VOXEL = 24; 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, 0,0,0, 1,0,0, 1,1,0, 0,1,0, 0,0,1, 1,0,1, 1,1,1, 0,1,1, 0,0,0, 1,0,0, 1,1,0, 0,1,0, 0,0,1, 1,0,1, 1,1,1, 0,1,1 }; GLfloat identityNormals[] = { 0,0,-1, 0,0,-1, 0,0,-1, 0,0,-1, 0,0,+1, 0,0,+1, 0,0,+1, 0,0,+1, 0,-1,0, 0,-1,0, 0,+1,0, 0,+1,0, 0,-1,0, 0,-1,0, 0,+1,0, 0,+1,0, -1,0,0, +1,0,0, +1,0,0, -1,0,0, -1,0,0, +1,0,0, +1,0,0, -1,0,0 }; GLubyte identityIndices[] = { 0,2,1, 0,3,2, // Z- . 8,9,13, 8,13,12, // Y- 16,23,19, 16,20,23, // X- 17,18,22, 17,22,21, // X+ 10,11,15, 10,15,14, // Y+ 4,5,6, 4,6,7 }; // Z+ . VoxelSystem::VoxelSystem() { voxelsRendered = 0; tree = new VoxelTree(); pthread_mutex_init(&bufferWriteLock, NULL); } VoxelSystem::~VoxelSystem() { delete[] readVerticesArray; delete[] writeVerticesArray; delete[] readColorsArray; delete[] writeColorsArray; delete tree; pthread_mutex_destroy(&bufferWriteLock); } void VoxelSystem::setViewerAvatar(Avatar *newViewerAvatar) { viewerAvatar = newViewerAvatar; } ////////////////////////////////////////////////////////////////////////////////////////// // 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(const char* fileName, bool wantColorRandomizer) { tree->loadVoxelsFile(fileName,wantColorRandomizer); copyWrittenDataToReadArrays(); } ////////////////////////////////////////////////////////////////////////////////////////// // 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, bool wantColorRandomizer) { tree->createSphere(r,xc,yc,zc,s,solid,wantColorRandomizer); setupNewVoxelsForDrawing(); } long int VoxelSystem::getVoxelsCreated() { return tree->voxelsCreated; } float VoxelSystem::getVoxelsCreatedPerSecondAverage() { return (1 / tree->voxelsCreatedStats.getEventDeltaAverage()); } long int VoxelSystem::getVoxelsColored() { return tree->voxelsColored; } float VoxelSystem::getVoxelsColoredPerSecondAverage() { return (1 / tree->voxelsColoredStats.getEventDeltaAverage()); } long int VoxelSystem::getVoxelsBytesRead() { return tree->voxelsBytesRead; } float VoxelSystem::getVoxelsBytesReadPerSecondAverage() { return tree->voxelsBytesReadStats.getAverageSampleValuePerSecond(); } bool pickAorB = false; int VoxelSystem::parseData(unsigned char* sourceBuffer, int numBytes) { unsigned char command = *sourceBuffer; unsigned char *voxelData = sourceBuffer + 1; switch(command) { case PACKET_HEADER_VOXEL_DATA: { /***************** TEMPORARY CODE ********************************************************************************* // YES! Stephen - I have intentionally placed this horrible UGLY LINE across your screen! I did it so you and I // would make a point of removing this code when all this work is done. But in the mean time, I need it here for // debugging purposes... When you do the code review... DO NOT tell me to remove it. :) Thank you! // unsigned char fakeBuffer[18] = { 86, // V 2,0, // octcode for root 136, // child color bits 0,0,255, // child 128 color 0,255,0, // child 8 color 0, // child tree bits - none // now some extra bits, what happens??? 2,252, // octcode for root 1, // child color bits 255,0,0, // child 1 color 0 // child tree bits }; //printf("loading fake data! fakeBuffer \n"); tree->readBitstreamToTree((unsigned char*)&fakeBuffer[1], sizeof(fakeBuffer)-1); unsigned char fakeBuffer[11] = { 86, // V 2,0, // octcode for root 136, // child color bits 0,0,255, // child 128 color 0,255,0, // child 8 color 0 // child tree bits - none }; printf("loading fake data! fakeBuffer \n"); tree->readBitstreamToTree((unsigned char*)&fakeBuffer[1], sizeof(fakeBuffer)-1); unsigned char fakeBufferA[11] = { 86, // V 0, // octcode for root 0, // child color bits? 128, // child exists bits 0, // child color bits 128, // child exists 128, // child color bits 0,0,255, // child color 0 // child exists bits }; unsigned char fakeBufferB[11] = { 86, // V 0, // octcode for root 0, // child color bits? 128, // child exists bits 0, // child color bits 128, // child exists 16, // child color bits 0,255,0, // child color?? 0 // child exists bits }; // trim off the "V" printf("loading fake data! pickAorB=%s\n", (pickAorB ? "A" : "B") ); if (pickAorB) { tree->readBitstreamToTree((unsigned char*)&fakeBufferA[1], sizeof(fakeBufferA)-1); } else { tree->readBitstreamToTree((unsigned char*)&fakeBufferB[1], sizeof(fakeBufferB)-1); } pickAorB = !pickAorB; ***** END OF TEMPORARY CODE ***************************************************************************************/ // ask the VoxelTree to read the bitstream into the tree tree->readBitstreamToTree(voxelData, numBytes - 1); } break; case PACKET_HEADER_ERASE_VOXEL: // ask the tree to read the "remove" bitstream tree->processRemoveVoxelBitstream(sourceBuffer, numBytes); break; case PACKET_HEADER_Z_COMMAND: // the Z command is a special command that allows the sender to send high level semantic // requests, like erase all, or add sphere scene, different receivers may handle these // messages differently char* packetData = (char *)sourceBuffer; char* command = &packetData[1]; // start of the command int commandLength = strlen(command); // commands are null terminated strings int totalLength = 1+commandLength+1; printLog("got Z message len(%d)= %s\n", numBytes, command); while (totalLength <= numBytes) { if (0==strcmp(command,(char*)"erase all")) { printLog("got Z message == erase all\n"); tree->eraseAllVoxels(); } if (0==strcmp(command,(char*)"add scene")) { printLog("got Z message == add scene - NOT SUPPORTED ON INTERFACE\n"); } totalLength += commandLength+1; } break; } setupNewVoxelsForDrawing(); return numBytes; } void VoxelSystem::setupNewVoxelsForDrawing() { // reset the verticesEndPointer so we're writing to the beginning of the array writeVerticesEndPointer = writeVerticesArray; // call recursive function to populate in memory arrays // it will return the number of voxels added glm::vec3 treeRoot = glm::vec3(0,0,0); voxelsRendered = treeToArrays(tree->rootNode, treeRoot); // copy the newly written data to the arrays designated for reading copyWrittenDataToReadArrays(); } void VoxelSystem::copyWrittenDataToReadArrays() { // lock on the buffer write lock so we can't modify the data when the GPU is reading it pthread_mutex_lock(&bufferWriteLock); // store a pointer to the current end so it doesn't change during copy GLfloat *endOfCurrentVerticesData = writeVerticesEndPointer; // copy the vertices and colors memcpy(readVerticesArray, writeVerticesArray, (endOfCurrentVerticesData - writeVerticesArray) * sizeof(GLfloat)); memcpy(readColorsArray, writeColorsArray, (endOfCurrentVerticesData - writeVerticesArray) * sizeof(GLubyte)); // set the read vertices end pointer to the correct spot so the GPU knows how much to pull readVerticesEndPointer = readVerticesArray + (endOfCurrentVerticesData - writeVerticesArray); pthread_mutex_unlock(&bufferWriteLock); } int VoxelSystem::treeToArrays(VoxelNode *currentNode, const glm::vec3& nodePosition) { int voxelsAdded = 0; float halfUnitForVoxel = powf(0.5, *currentNode->octalCode) * (0.5 * TREE_SCALE); glm::vec3 viewerPosition = viewerAvatar->getPosition(); // debug LOD code glm::vec3 debugNodePosition; copyFirstVertexForCode(currentNode->octalCode,(float*)&debugNodePosition); //printf("-----------------\n"); //printf("halfUnitForVoxel=%f\n",halfUnitForVoxel); //printf("viewer.x=%f y=%f z=%f \n", viewerPosition.x, viewerPosition.y, viewerPosition.z); //printf("node.x=%f y=%f z=%f \n", nodePosition[0], nodePosition[1], nodePosition[2]); //printf("debugNodePosition.x=%f y=%f z=%f \n", debugNodePosition[0], debugNodePosition[1], debugNodePosition[2]); float distanceToVoxelCenter = sqrtf(powf(viewerPosition.x - nodePosition[0] - halfUnitForVoxel, 2) + powf(viewerPosition.y - nodePosition[1] - halfUnitForVoxel, 2) + powf(viewerPosition.z - nodePosition[2] - halfUnitForVoxel, 2)); int renderLevel = *currentNode->octalCode + 1; int boundaryPosition = boundaryDistanceForRenderLevel(renderLevel); //printLog("treeToArrays() renderLevel=%d distanceToVoxelCenter=%f boundaryPosition=%d\n", // renderLevel,distanceToVoxelCenter,boundaryPosition); bool alwaysDraw = false; // XXXBHG - temporary debug code. Flip this to true to disable LOD blurring if (alwaysDraw || distanceToVoxelCenter < boundaryPosition) { for (int i = 0; i < 8; i++) { // check if there is a child here if (currentNode->children[i] != NULL) { glm::vec3 childNodePosition; copyFirstVertexForCode(currentNode->children[i]->octalCode,(float*)&childNodePosition); childNodePosition *= (float)TREE_SCALE; // scale it up /**** disabled ************************************************************************************************ // Note: Stephen, I intentionally left this in so you would talk to me about it. Here's the deal, this code // doesn't seem to work correctly. It returns X and Z flipped and the values are negative. Since we use the // firstVertexForCode() function below to calculate the child vertex and that DOES work, I've decided to use // that function to calculate our position for LOD handling. // // calculate the child's position based on the parent position for (int j = 0; j < 3; j++) { childNodePosition[j] = nodePosition[j]; if (oneAtBit(branchIndexWithDescendant(currentNode->octalCode,currentNode->children[i]->octalCode),(7 - j))) { childNodePosition[j] -= (powf(0.5, *currentNode->children[i]->octalCode) * TREE_SCALE); } } **** disabled ************************************************************************************************/ voxelsAdded += treeToArrays(currentNode->children[i], childNodePosition); } } } // 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->isColored()) { float startVertex[3]; copyFirstVertexForCode(currentNode->octalCode,(float*)&startVertex); 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++ ) { *writeVerticesEndPointer = startVertex[j % 3] + (identityVertices[j] * voxelScale); *(writeColorsArray + (writeVerticesEndPointer - writeVerticesArray)) = currentNode->getColor()[j % 3]; writeVerticesEndPointer++; } voxelsAdded++; } 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 writeVerticesEndPointer = writeVerticesArray = new GLfloat[VERTEX_POINTS_PER_VOXEL * MAX_VOXELS_PER_SYSTEM]; readVerticesEndPointer = readVerticesArray = new GLfloat[VERTEX_POINTS_PER_VOXEL * MAX_VOXELS_PER_SYSTEM]; writeColorsArray = new GLubyte[VERTEX_POINTS_PER_VOXEL * MAX_VOXELS_PER_SYSTEM]; readColorsArray = 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]; } } GLfloat *normalsArray = new GLfloat[VERTEX_POINTS_PER_VOXEL * MAX_VOXELS_PER_SYSTEM]; GLfloat *normalsArrayEndPointer = normalsArray; // populate the normalsArray for (int n = 0; n < MAX_VOXELS_PER_SYSTEM; n++) { for (int i = 0; i < VERTEX_POINTS_PER_VOXEL; i++) { *(normalsArrayEndPointer++) = identityNormals[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 the normalsArray glGenBuffers(1, &vboNormalsID); glBindBuffer(GL_ARRAY_BUFFER, vboNormalsID); glBufferData(GL_ARRAY_BUFFER, VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat) * MAX_VOXELS_PER_SYSTEM, normalsArray, GL_STATIC_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 and normals arrays that are no longer needed delete[] indicesArray; delete[] normalsArray; } void VoxelSystem::render() { glPushMatrix(); if (readVerticesEndPointer != readVerticesArray) { // try to lock on the buffer write // just avoid pulling new data if it is currently being written if (pthread_mutex_trylock(&bufferWriteLock) == 0) { glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID); glBufferSubData(GL_ARRAY_BUFFER, 0, (readVerticesEndPointer - readVerticesArray) * sizeof(GLfloat), readVerticesArray); glBindBuffer(GL_ARRAY_BUFFER, vboColorsID); glBufferSubData(GL_ARRAY_BUFFER, 0, (readVerticesEndPointer - readVerticesArray) * sizeof(GLubyte), readColorsArray); readVerticesEndPointer = readVerticesArray; pthread_mutex_unlock(&bufferWriteLock); } } // tell OpenGL where to find vertex and color information glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID); glVertexPointer(3, GL_FLOAT, 0, 0); glBindBuffer(GL_ARRAY_BUFFER, vboNormalsID); glNormalPointer(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_NORMAL_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) { } int VoxelSystem::_nodeCount = 0; bool VoxelSystem::randomColorOperation(VoxelNode* node, bool down, void* extraData) { // we do our operations on the way up! if (down) { return true; } _nodeCount++; if (node->isColored()) { nodeColor newColor = { 0,0,0,1 }; newColor[0] = randomColorValue(150); newColor[1] = randomColorValue(150); newColor[1] = randomColorValue(150); //printf("randomize color node %d was %x,%x,%x NOW %x,%x,%x\n", // _nodeCount,node->getTrueColor()[0],node->getTrueColor()[1],node->getTrueColor()[2], // newColor[0],newColor[1],newColor[2]); node->setColor(newColor); } else { //printf("not randomizing color node of %d since it has no color\n",_nodeCount); } return true; } void VoxelSystem::randomizeVoxelColors() { _nodeCount = 0; tree->recurseTreeWithOperation(randomColorOperation); printf("setting randomized true color for %d nodes\n",_nodeCount); setupNewVoxelsForDrawing(); } bool VoxelSystem::falseColorizeRandomOperation(VoxelNode* node, bool down, void* extraData) { // we do our operations on the way up! if (down) { return true; } _nodeCount++;