fixed a couple crashes and cleaned up some code

ZappoMan committed 13 years ago

Commit 4be07ec1 parent 53e24863 files · +54 −32Browse files

Showing the changes to interface/src/VoxelSystem.cpp (1 of 3 files). Show all

Unified · Split

 }
 void VoxelSystem::voxelDeleted(VoxelNode* node) {
-    if (node->isKnownBufferIndex() && (node->getVoxelSystem() == this)) {
+    if (node->getVoxelSystem() == this) {
-        forceRemoveNodeFromArrays(node);
+        if (_voxelsInWriteArrays != 0) {
+            forceRemoveNodeFromArrays(node);
+        } else {
+            if (Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings)) {
+                printf("VoxelSystem::voxelDeleted() while _voxelsInWriteArrays==0, is that expected? \n");
+            }
+        }
     }
 }
 // This will run through the list of _freeIndexes and reset their VBO array values to be "invisible".
 void VoxelSystem::clearFreeBufferIndexes() {
     PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), "###### clearFreeBufferIndexes()");
+    _voxelsInWriteArrays = 0; // reset our VBO
+    _abandonedVBOSlots = 0;
+    // clear out freeIndexes
     pthread_mutex_lock(&_freeIndexLock);
     _freeIndexes.clear();
-    _abandonedVBOSlots = 0;
     pthread_mutex_unlock(&_freeIndexLock);
+    clearAllNodesBufferIndex();
 }
 VoxelSystem::~VoxelSystem() {
         // Global Normals mode uses a technique of not including normals on any voxel vertices, and instead
         // rendering the voxel faces in 6 passes that use a global call to glNormal3f()
-        qDebug("Using Global Normals...\n");
         setupFaceIndices(_vboIndicesTop,    identityIndicesTop);
         setupFaceIndices(_vboIndicesBottom, identityIndicesBottom);
         setupFaceIndices(_vboIndicesLeft,   identityIndicesLeft);
             while (totalLength <= numBytes) {
                 if (0==strcmp(command,(char*)"erase all")) {
-                    qDebug("got Z message == erase all\n");
+                    qDebug("got Z message == erase all - NOT SUPPORTED ON INTERFACE\n");
-                    pthread_mutex_lock(&_treeLock);
-                    _tree->eraseAllVoxels();
-                    pthread_mutex_unlock(&_treeLock);
-                    _voxelsInReadArrays = _voxelsInWriteArrays = 0; // better way to do this??
                 }
                 if (0==strcmp(command,(char*)"add scene")) {
                     qDebug("got Z message == add scene - NOT SUPPORTED ON INTERFACE\n");
         PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), buffer);
         _callsToTreesToArrays++;
         if (_writeRenderFullVBO) {
-            printf("resetting _freeIndexes and _voxelsInWriteArrays\n");
-            _voxelsInWriteArrays = 0; // reset our VBO
             clearFreeBufferIndexes();
         }
         _voxelsUpdated = newTreeToArrays(_tree->rootNode);
             updateArraysDetails(nodeIndex, startVertex, voxelScale, node->getColor());
             return 1; // updated!
         } else {
-            // If we shouldn't render, but we did have a known index, then we will need to release our index
+            // If we shouldn't render, and we're in reuseIndex mode, then free our index, this only operates
-            if (reuseIndex && node->isKnownBufferIndex()) {
+            // on nodes with known index values, so it's safe to call for any node.
-                forceRemoveNodeFromArrays(node);
+            if (reuseIndex) {
-                return 1; // updated!
+                return forceRemoveNodeFromArrays(node);
             }
         }
     }
 int VoxelSystem::_nodeCount = 0;
 void VoxelSystem::killLocalVoxels() {
+    pthread_mutex_lock(&_treeLock);
     _tree->eraseAllVoxels();
-    _voxelsInWriteArrays = _voxelsInReadArrays = 0; // better way to do this??
+    pthread_mutex_unlock(&_treeLock);
+    clearFreeBufferIndexes();
+    _voxelsInReadArrays = 0; // do we need to do this?
     setupNewVoxelsForDrawing();
 }
 void VoxelSystem::clearAllNodesBufferIndex() {
     _nodeCount = 0;
+    pthread_mutex_lock(&_treeLock);
     _tree->recurseTreeWithOperation(clearAllNodesBufferIndexOperation);
-    qDebug("clearing buffer index of %d nodes\n", _nodeCount);
+    pthread_mutex_unlock(&_treeLock);
+    if (Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings)) {
+        qDebug("clearing buffer index of %d nodes\n", _nodeCount);
+    }
 }
 bool VoxelSystem::forceRedrawEntireTreeOperation(VoxelNode* node, void* extraData) {
     if (node->isKnownBufferIndex()) {
         args->nodesRemoved++;
         VoxelSystem* thisVoxelSystem = args->thisVoxelSystem;
-        thisVoxelSystem->forceRemoveNodeFromArrays(node);
+        thisVoxelSystem->_voxelsUpdated += thisVoxelSystem->forceRemoveNodeFromArrays(node);
-        thisVoxelSystem->_voxelsUpdated++;
         thisVoxelSystem->setupNewVoxelsForDrawingSingleNode();
     }
     args->nodesInside++;
     if (node->getShouldRender() && !node->isKnownBufferIndex()) {
-        node->setDirtyBit(); // will this make it draw?
+        node->setDirtyBit(); // will this make it draw!
     }
-    return true;
+    return true; // keep recursing!
 }
 class collectStatsForTreesAndVBOsArgs {
 public:
-    collectStatsForTreesAndVBOsArgs() :
+    collectStatsForTreesAndVBOsArgs(int maxVoxels) :
         totalNodes(0),
         dirtyNodes(0),
         shouldRenderNodes(0),
         duplicateVBOIndex(0),
         leafNodes(0)
         {
-            memset(hasIndexFound, false, DEFAULT_MAX_VOXELS_PER_SYSTEM * sizeof(bool));
+            hasIndexFound = new bool[maxVoxels];
+            memset(hasIndexFound, false, maxVoxels * sizeof(bool));
         };
+    ~collectStatsForTreesAndVBOsArgs() {
+        delete[] hasIndexFound;
+    }
     unsigned long totalNodes;
     unsigned long dirtyNodes;
     unsigned long expectedMax;
-    bool hasIndexFound[DEFAULT_MAX_VOXELS_PER_SYSTEM];
+    bool* hasIndexFound;
 };
 bool VoxelSystem::collectStatsForTreesAndVBOsOperation(VoxelNode* node, void* extraData) {
         }
     }
-    collectStatsForTreesAndVBOsArgs args;
+    collectStatsForTreesAndVBOsArgs args(_maxVoxels);
     args.expectedMax = _voxelsInWriteArrays;
     qDebug("CALCULATING Local Voxel Tree Statistics >>>>>>>>>>>>\n");
     glBufferIndex minInVBO = GLBUFFER_INDEX_UNKNOWN;
     glBufferIndex maxInVBO = 0;
-    for (glBufferIndex i = 0; i < DEFAULT_MAX_VOXELS_PER_SYSTEM; i++) {
+    for (glBufferIndex i = 0; i < _maxVoxels; i++) {
         if (args.hasIndexFound[i]) {
             minInVBO = std::min(minInVBO,i);
             maxInVBO = std::max(maxInVBO,i);
 void VoxelSystem::deleteVoxelAt(float x, float y, float z, float s) {
     pthread_mutex_lock(&_treeLock);
     _tree->deleteVoxelAt(x, y, z, s);
+    pthread_mutex_unlock(&_treeLock);
     // redraw!
     setupNewVoxelsForDrawing();  // do we even need to do this? Or will the next network receive kick in?
-    pthread_mutex_unlock(&_treeLock);
 };
 VoxelNode* VoxelSystem::getVoxelAt(float x, float y, float z, float s) const {
         if (_voxelServerCount > 0) {
             // Kill any voxels from the local tree that match this nodeID
+            pthread_mutex_lock(&_treeLock);
             _tree->recurseTreeWithOperation(killSourceVoxelsOperation, &nodeID);
+            pthread_mutex_unlock(&_treeLock);
             _tree->setDirtyBit();
+            setupNewVoxelsForDrawing();
         } else {
             // Last server, take the easy way and kill all the local voxels!
-            _tree->eraseAllVoxels();
+            killLocalVoxels();
-            _voxelsInWriteArrays = _voxelsInReadArrays = 0; // better way to do this??
         }
-        setupNewVoxelsForDrawing();
     }
 }
+void VoxelSystem::domainChanged(QString domain) {
+    killLocalVoxels();
+}
 unsigned long VoxelSystem::getFreeMemoryGPU() {
     // We can't ask all GPUs how much memory they have in use, but we can ask them about how much is free.