////  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 <PerfStat.h>#include <OctalCode.h>#include <pthread.h>#include "Log.h"#include "VoxelConstants.h" #include "VoxelSystem.h" 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() {    _voxelsInReadArrays = _voxelsInWriteArrays = _voxelsUpdated = 0;    _renderFullVBO = true;    _tree = new VoxelTree();    pthread_mutex_init(&_bufferWriteLock, NULL);} VoxelSystem::~VoxelSystem() {    delete[] _readVerticesArray;    delete[] _writeVerticesArray;    delete[] _readColorsArray;    delete[] _writeColorsArray;    delete[] _voxelDirtyArray;    delete _tree;    pthread_mutex_destroy(&_bufferWriteLock);} void VoxelSystem::loadVoxelsFile(const char* fileName, bool wantColorRandomizer) {    _tree->loadVoxelsFile(fileName, 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();} int VoxelSystem::parseData(unsigned char* sourceBuffer, int numBytes) {     unsigned char command = *sourceBuffer;    unsigned char *voxelData = sourceBuffer + 1;     switch(command) {        case PACKET_HEADER_VOXEL_DATA:        {            PerformanceWarning warn(_renderWarningsOn, "readBitstreamToTree()");            // 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();                    _voxelsInReadArrays = _voxelsInWriteArrays = 0; // better way to do this??                }                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() {    PerformanceWarning warn(_renderWarningsOn, "setupNewVoxelsForDrawing()"); // would like to include _voxelsInArrays, _voxelsUpdated    double start = usecTimestampNow();    double sinceLastTime = (start - _setupNewVoxelsForDrawingLastFinished) / 1000.0;     bool iAmDebugging = false;  // if you're debugging set this to true, so you won't get skipped for slow debugging    if (!iAmDebugging && sinceLastTime <= std::max(_setupNewVoxelsForDrawingLastElapsed, SIXTY_FPS_IN_MILLISECONDS)) {        return; // bail early, it hasn't been long enough since the last time we ran    }     double sinceLastViewCulling = (start - _lastViewCulling) / 1000.0;    // If the view frustum has changed, since last time, then remove nodes that are out of view    if ((sinceLastViewCulling >= std::max(_lastViewCullingElapsed, VIEW_CULLING_RATE_IN_MILLISECONDS)) && hasViewChanged()) {        _lastViewCulling = start;         // When we call removeOutOfView() voxels, we don't actually remove the voxels from the VBOs, but we do remove        // them from tree, this makes our tree caclulations faster, but doesn't require us to fully rebuild the VBOs (which        // can be expensive).        removeOutOfView();                // Once we call cleanupRemovedVoxels() we do need to rebuild our VBOs (if anything was actually removed). So,        // we should consider putting this someplace else... as this might be able to occur less frequently, and save us on        // VBO reubuilding. Possibly we should do this only if our actual VBO usage crosses some lower boundary.        cleanupRemovedVoxels();         double endViewCulling = usecTimestampNow();        _lastViewCullingElapsed = (endViewCulling - start) / 1000.0;    }            if (_tree->isDirty()) {        static char buffer[64] = { 0 };        if (_renderWarningsOn) {             sprintf(buffer, "newTreeToArrays() _renderFullVBO=%s", (_renderFullVBO ? "yes" : "no"));         };        PerformanceWarning warn(_renderWarningsOn, buffer);        _callsToTreesToArrays++;        if (_renderFullVBO) {            _voxelsInWriteArrays = 0; // reset our VBO        }        _voxelsUpdated = newTreeToArrays(_tree->rootNode);        _tree->clearDirtyBit(); // after we pull the trees into the array, we can consider the tree clean                // since we called treeToArrays, we can assume that our VBO is in sync, and so partial updates to the VBOs are        // ok again, until/unless we call removeOutOfView()         _renderFullVBO = false;     } else {        _voxelsUpdated = 0;    }    if (_voxelsUpdated) {        _voxelsDirty=true;    }     // copy the newly written data to the arrays designated for reading, only does something if _voxelsDirty && _voxelsUpdated    copyWrittenDataToReadArrays();     double end = usecTimestampNow();    double elapsedmsec = (end - start) / 1000.0;    _setupNewVoxelsForDrawingLastFinished = end;    _setupNewVoxelsForDrawingLastElapsed = elapsedmsec;} void VoxelSystem::cleanupRemovedVoxels() {    PerformanceWarning warn(_renderWarningsOn, "cleanupRemovedVoxels()");    if (!_removedVoxels.isEmpty()) {        while (!_removedVoxels.isEmpty()) {            delete _removedVoxels.extract();        }        _renderFullVBO = true; // if we remove voxels, we must update our full VBOs    }} void VoxelSystem::copyWrittenDataToReadArrays() {    PerformanceWarning warn(_renderWarningsOn, "copyWrittenDataToReadArrays()"); // would like to include _voxelsInArrays, _voxelsUpdated    if (_voxelsDirty && _voxelsUpdated) {        // lock on the buffer write lock so we can't modify the data when the GPU is reading it        pthread_mutex_lock(&_bufferWriteLock);        int bytesOfVertices = (_voxelsInWriteArrays * VERTEX_POINTS_PER_VOXEL) * sizeof(GLfloat);        int bytesOfColors   = (_voxelsInWriteArrays * VERTEX_POINTS_PER_VOXEL) * sizeof(GLubyte);        memcpy(_readVerticesArray, _writeVerticesArray, bytesOfVertices);        memcpy(_readColorsArray,   _writeColorsArray,   bytesOfColors  );        _voxelsInReadArrays = _voxelsInWriteArrays;        pthread_mutex_unlock(&_bufferWriteLock);    }} int VoxelSystem::newTreeToArrays(VoxelNode* node) {    assert(_viewFrustum); // you must set up _viewFrustum before calling this    int   voxelsUpdated   = 0;    bool  shouldRender    = false; // assume we don't need to render it    // if it's colored, we might need to render it!    if (node->isColored()) {        float distanceToNode  = node->distanceToCamera(*_viewFrustum);        float boundary        = boundaryDistanceForRenderLevel(node->getLevel());        float childBoundary   = boundaryDistanceForRenderLevel(node->getLevel() + 1);        bool  inBoundary      = (distanceToNode <= boundary);        bool  inChildBoundary = (distanceToNode <= childBoundary);        shouldRender = (node->isLeaf() && inChildBoundary) || (inBoundary && !inChildBoundary);    }    node->setShouldRender(shouldRender);    // let children figure out their renderness    for (int i = 0; i < NUMBER_OF_CHILDREN; i++) {        if (node->getChildAtIndex(i)) {            voxelsUpdated += newTreeToArrays(node->getChildAtIndex(i));        }    }    if (_renderFullVBO) {        voxelsUpdated += updateNodeInArraysAsFullVBO(node);    } else {        voxelsUpdated += updateNodeInArraysAsPartialVBO(node);    }    node->clearDirtyBit(); // always clear the dirty bit, even if it doesn't need to be rendered    return voxelsUpdated;} int VoxelSystem::updateNodeInArraysAsFullVBO(VoxelNode* node) {    // If we've run out of room, then just bail...    if (_voxelsInWriteArrays >= MAX_VOXELS_PER_SYSTEM) {        return 0;    }        if (node->getShouldRender()) {        glm::vec3 startVertex = node->getCorner();        float voxelScale = node->getScale();        glBufferIndex nodeIndex = _voxelsInWriteArrays;         // 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++ ) {            GLfloat* writeVerticesAt = _writeVerticesArray + (nodeIndex * VERTEX_POINTS_PER_VOXEL);            GLubyte* writeColorsAt   = _writeColorsArray   + (nodeIndex * VERTEX_POINTS_PER_VOXEL);            *(writeVerticesAt+j) = startVertex[j % 3] + (identityVertices[j] * voxelScale);            *(writeColorsAt  +j) = node->getColor()[j % 3];        }        node->setBufferIndex(nodeIndex);        _voxelsInWriteArrays++; // our know vertices in the arrays        return 1; // rendered    }        return 0; // not-rendered} int VoxelSystem::updateNodeInArraysAsPartialVBO(VoxelNode* node) {    // If we've run out of room, then just bail...    if (_voxelsInWriteArrays >= MAX_VOXELS_PER_SYSTEM) {        return 0;    }        // Now, if we've changed any attributes (our renderness, our color, etc) then update the Arrays... for us    if (node->isDirty() && (node->getShouldRender() || node->isKnownBufferIndex())) {        glm::vec3 startVertex;        float voxelScale = 0;        // If we're should render, use our legit location and scale,         if (node->getShouldRender()) {            startVertex = node->getCorner();            voxelScale = node->getScale();        } else {            // if we shouldn't render then set out location to some infinitely distant location,             // and our scale as infinitely small            startVertex[0] = startVertex[1] = startVertex[2] = FLT_MAX;            voxelScale = 0;        }         // If this node has not yet been written to the array, then add it to the end of the array.        glBufferIndex nodeIndex;        if (node->isKnownBufferIndex()) {            nodeIndex = node->getBufferIndex();        } else {            nodeIndex = _voxelsInWriteArrays;        }                _voxelDirtyArray[nodeIndex] = true;         // 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++ ) {            GLfloat* writeVerticesAt = _writeVerticesArray + (nodeIndex * VERTEX_POINTS_PER_VOXEL);            GLubyte* writeColorsAt   = _writeColorsArray   + (nodeIndex * VERTEX_POINTS_PER_VOXEL);            *(writeVerticesAt+j) = startVertex[j % 3] + (identityVertices[j] * voxelScale);            *(writeColorsAt  +j) = node->getColor()[j % 3];        }        if (!node->isKnownBufferIndex()) {            node->setBufferIndex(nodeIndex);            _voxelsInWriteArrays++; // our know vertices in the arrays        }        return 1; // updated!    }    return 0; // not-updated} 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() {     _renderWarningsOn = false;    _callsToTreesToArrays = 0;    _setupNewVoxelsForDrawingLastFinished = 0;    _setupNewVoxelsForDrawingLastElapsed = 0;    _lastViewCullingElapsed = _lastViewCulling = 0;     // When we change voxels representations in the arrays, we'll update this    _voxelsDirty = false;    _voxelsInWriteArrays = 0;    _voxelsInReadArrays = 0;    _unusedArraySpace = 0;     // we will track individual dirty sections with this array of bools    _voxelDirtyArray = new bool[MAX_VOXELS_PER_SYSTEM];    memset(_voxelDirtyArray, false, MAX_VOXELS_PER_SYSTEM * sizeof(bool));     // prep the data structures for incoming voxel data    _writeVerticesArray = new GLfloat[VERTEX_POINTS_PER_VOXEL * MAX_VOXELS_PER_SYSTEM];    _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::updateFullVBOs() {    glBufferIndex segmentStart = 0;    glBufferIndex segmentEnd = _voxelsInWriteArrays;     int segmentLength = (segmentEnd - segmentStart) + 1;    GLintptr   segmentStartAt   = segmentStart * VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat);    GLsizeiptr segmentSizeBytes = segmentLength * VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat);    GLfloat* readVerticesFrom   = _readVerticesArray + (segmentStart * VERTEX_POINTS_PER_VOXEL);    glBindBuffer(GL_ARRAY_BUFFER, _vboVerticesID);    glBufferSubData(GL_ARRAY_BUFFER, segmentStartAt, segmentSizeBytes, readVerticesFrom);    segmentStartAt          = segmentStart * VERTEX_POINTS_PER_VOXEL * sizeof(GLubyte);    segmentSizeBytes        = segmentLength * VERTEX_POINTS_PER_VOXEL * sizeof(GLubyte);    GLubyte* readColorsFrom = _readColorsArray   + (segmentStart * VERTEX_POINTS_PER_VOXEL);    glBindBuffer(GL_ARRAY_BUFFER, _vboColorsID);    glBufferSubData(GL_ARRAY_BUFFER, segmentStartAt, segmentSizeBytes, readColorsFrom);        // consider the _voxelDirtyArray[] clean!    memset(_voxelDirtyArray, false, MAX_VOXELS_PER_SYSTEM * sizeof(bool));} void VoxelSystem::updatePartialVBOs() {    int segmentCount = 0;    glBufferIndex segmentStart = 0;    glBufferIndex segmentEnd = 0;    bool inSegment = false;    for (glBufferIndex i = 0; i < _voxelsInWriteArrays; i++) {        bool thisVoxelDirty = _voxelDirtyArray[i];        if (!inSegment) {            if (thisVoxelDirty) {                segmentStart = i;                inSegment = true;                _voxelDirtyArray[i] = false; // consider us clean!            }        } else {            if (!thisVoxelDirty) {                // If we got here because because this voxel is NOT dirty, so the last dirty voxel was the one before                // this one and so that's where the "segment" ends                segmentEnd = i - 1;                 inSegment = false;                int segmentLength = (segmentEnd - segmentStart) + 1;                GLintptr   segmentStartAt   = segmentStart * VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat);                GLsizeiptr segmentSizeBytes = segmentLength * VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat);                GLfloat* readVerticesFrom   = _readVerticesArray + (segmentStart * VERTEX_POINTS_PER_VOXEL);                glBindBuffer(GL_ARRAY_BUFFER, _vboVerticesID);                glBufferSubData(GL_ARRAY_BUFFER, segmentStartAt, segmentSizeBytes, readVerticesFrom);                segmentStartAt          = segmentStart * VERTEX_POINTS_PER_VOXEL * sizeof(GLubyte);                segmentSizeBytes        = segmentLength * VERTEX_POINTS_PER_VOXEL * sizeof(GLubyte);                GLubyte* readColorsFrom = _readColorsArray   + (segmentStart * VERTEX_POINTS_PER_VOXEL);                glBindBuffer(GL_ARRAY_BUFFER, _vboColorsID);                glBufferSubData(GL_ARRAY_BUFFER, segmentStartAt, segmentSizeBytes, readColorsFrom);                 // debug                segmentCount++;                printLog("updatePartialVBOs() start=%ld, end=%ld, length=%ld, segmentCount=%d \n",                     segmentStart, segmentEnd, segmentLength, segmentCount);            }            _voxelDirtyArray[i] = false; // consider us clean!        }    }        // if we got to the end of the array, and we're in an active dirty segment...    if (inSegment) {        segmentEnd = _voxelsInWriteArrays - 1;         inSegment = false;        int segmentLength = (segmentEnd - segmentStart) + 1;        GLintptr   segmentStartAt   = segmentStart * VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat);        GLsizeiptr segmentSizeBytes = segmentLength * VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat);        GLfloat* readVerticesFrom   = _readVerticesArray + (segmentStart * VERTEX_POINTS_PER_VOXEL);        glBindBuffer(GL_ARRAY_BUFFER, _vboVerticesID);        glBufferSubData(GL_ARRAY_BUFFER, segmentStartAt, segmentSizeBytes, readVerticesFrom);        segmentStartAt          = segmentStart * VERTEX_POINTS_PER_VOXEL * sizeof(GLubyte);        segmentSizeBytes        = segmentLength * VERTEX_POINTS_PER_VOXEL * sizeof(GLubyte);        GLubyte* readColorsFrom = _readColorsArray   + (segmentStart * VERTEX_POINTS_PER_VOXEL);        glBindBuffer(GL_ARRAY_BUFFER, _vboColorsID);        glBufferSubData(GL_ARRAY_BUFFER, segmentStartAt, segmentSizeBytes, readColorsFrom);         // debug        segmentCount++;        printLog("updatePartialVBOs() start=%ld, end=%ld, length=%ld, segmentCount=%d \n",             segmentStart, segmentEnd, segmentLength, segmentCount);    }} void debugOpenGLError(const char* label) {    GLenum error = glGetError();    const char* errorMessage;    switch (error) {        case GL_NO_ERROR:            return;        case GL_INVALID_ENUM:            errorMessage = "GL_INVALID_ENUM";

Lines 1–500 of 889. Load more