Merge branch 'master' of https://github.com/worklist/hifi

Conflicts:
	interface/src/Application.cpp

interface/src/Application.cpp

@@ -148,6 +148,7 @@ Application::Application(int& argc, char** argv) :
         _paintOn(false),
         _dominantColor(0),
         _perfStatsOn(false),
+        _destructiveAddVoxel(false),
         _chatEntryOn(false),
         _oculusTextureID(0),
         _oculusProgram(0),
@@ -992,6 +993,10 @@ void Application::cycleFrustumRenderMode() {
     updateFrustumRenderModeAction();
 }
 
+void Application::setDestructivePaint(bool destructive) {
+    _destructiveAddVoxel = destructive;
+}
+
 void Application::setRenderWarnings(bool renderWarnings) {
     _voxels.setRenderPipelineWarnings(renderWarnings);
 }
@@ -1100,6 +1105,7 @@ void Application::initMenu() {
     QColor paintColor(128, 128, 128);
     _voxelPaintColor->setData(paintColor);
     _voxelPaintColor->setIcon(createSwatchIcon(paintColor));
+    toolsMenu->addAction("Create Voxel is Destructive", this, SLOT(setDestructivePaint(bool)))->setCheckable(true);
     
     QMenu* frustumMenu = menuBar->addMenu("Frustum");
     (_frustumOn = frustumMenu->addAction("Display Frustum"))->setCheckable(true); 
@@ -1320,7 +1326,8 @@ void Application::updateAvatar(float deltaTime) {
             _paintingVoxel.y >= 0.0 && _paintingVoxel.y <= 1.0 &&
             _paintingVoxel.z >= 0.0 && _paintingVoxel.z <= 1.0) {
 
-            sendVoxelEditMessage(PACKET_HEADER_SET_VOXEL, _paintingVoxel);
+            PACKET_HEADER message = (_destructiveAddVoxel ? PACKET_HEADER_SET_VOXEL_DESTRUCTIVE : PACKET_HEADER_SET_VOXEL);
+            sendVoxelEditMessage(message, _paintingVoxel);
         }
     }
 }
@@ -1902,19 +1909,21 @@ void Application::addVoxelInFrontOfAvatar() {
     detail.green = paintColor.green();
     detail.blue = paintColor.blue();
     
-    sendVoxelEditMessage(PACKET_HEADER_SET_VOXEL, detail);
+    PACKET_HEADER message = (_destructiveAddVoxel ? PACKET_HEADER_SET_VOXEL_DESTRUCTIVE : PACKET_HEADER_SET_VOXEL);
+    sendVoxelEditMessage(message, detail);
     
     // create the voxel locally so it appears immediately            
-    _voxels.createVoxel(detail.x, detail.y, detail.z, detail.s, detail.red, detail.green, detail.blue);
+    _voxels.createVoxel(detail.x, detail.y, detail.z, detail.s, detail.red, detail.green, detail.blue, _destructiveAddVoxel);
 }
 
 void Application::addVoxelUnderCursor() {
     if (_mouseVoxel.s != 0) {    
-        sendVoxelEditMessage(PACKET_HEADER_SET_VOXEL, _mouseVoxel);
+        PACKET_HEADER message = (_destructiveAddVoxel ? PACKET_HEADER_SET_VOXEL_DESTRUCTIVE : PACKET_HEADER_SET_VOXEL);
+        sendVoxelEditMessage(message, _mouseVoxel);
         
         // create the voxel locally so it appears immediately            
         _voxels.createVoxel(_mouseVoxel.x, _mouseVoxel.y, _mouseVoxel.z, _mouseVoxel.s,
-                           _mouseVoxel.red, _mouseVoxel.green, _mouseVoxel.blue);
+                           _mouseVoxel.red, _mouseVoxel.green, _mouseVoxel.blue, _destructiveAddVoxel);
     }
 }
 

interface/src/Application.h

@@ -76,6 +76,7 @@ private slots:
     void setFrustumOffset(bool frustumOffset);
     void cycleFrustumRenderMode();
     
+    void setDestructivePaint(bool destructive);
     void setRenderWarnings(bool renderWarnings);
     void doKillLocalVoxels();
     void doRandomizeVoxelColors();
@@ -202,6 +203,7 @@ private:
     VoxelDetail _paintingVoxel;   // The voxel we're painting if we're painting 
     
     bool _perfStatsOn; //  Do we want to display perfStats? 
+    bool _destructiveAddVoxel; // when doing voxel editing do we want them to be destructive
     
     ChatEntry _chatEntry; // chat entry field 
     bool _chatEntryOn;    // Whether to show the chat entry 

interface/src/VoxelSystem.cpp

@@ -1020,22 +1020,24 @@ VoxelNode* VoxelSystem::getVoxelAt(float x, float y, float z, float s) const {
     return _tree->getVoxelAt(x, y, z, s); 
 };
 
-void VoxelSystem::createVoxel(float x, float y, float z, float s, unsigned char red, unsigned char green, unsigned char blue) {
+void VoxelSystem::createVoxel(float x, float y, float z, float s, 
+                              unsigned char red, unsigned char green, unsigned char blue, bool destructive) {
     pthread_mutex_lock(&_treeLock);
     
     //printLog("VoxelSystem::createVoxel(%f,%f,%f,%f)\n",x,y,z,s);
-    _tree->createVoxel(x, y, z, s, red, green, blue); 
+    _tree->createVoxel(x, y, z, s, red, green, blue, destructive); 
     setupNewVoxelsForDrawing(); 
     
     pthread_mutex_unlock(&_treeLock);
 };
 
-void VoxelSystem::createLine(glm::vec3 point1, glm::vec3 point2, float unitSize, rgbColor color) { 
+void VoxelSystem::createLine(glm::vec3 point1, glm::vec3 point2, float unitSize, rgbColor color, bool destructive) { 
-    _tree->createLine(point1, point2, unitSize, color); 
+    _tree->createLine(point1, point2, unitSize, color, destructive); 
     setupNewVoxelsForDrawing(); 
 };
 
-void VoxelSystem::createSphere(float r,float xc, float yc, float zc, float s, bool solid, creationMode mode, bool debug) { 
+void VoxelSystem::createSphere(float r,float xc, float yc, float zc, float s, bool solid, 
-    _tree->createSphere(r, xc, yc, zc, s, solid, mode, debug); 
+                               creationMode mode, bool destructive, bool debug) { 
+    _tree->createSphere(r, xc, yc, zc, s, solid, mode, destructive, debug); 
     setupNewVoxelsForDrawing(); 
 };

interface/src/VoxelSystem.h

@@ -73,9 +73,11 @@ public:
 
     void deleteVoxelAt(float x, float y, float z, float s);
     VoxelNode* getVoxelAt(float x, float y, float z, float s) const;
-    void createVoxel(float x, float y, float z, float s, unsigned char red, unsigned char green, unsigned char blue);
+    void createVoxel(float x, float y, float z, float s, 
-    void createLine(glm::vec3 point1, glm::vec3 point2, float unitSize, rgbColor color);
+                     unsigned char red, unsigned char green, unsigned char blue, bool destructive = false);
-    void createSphere(float r,float xc, float yc, float zc, float s, bool solid, creationMode mode, bool debug = false);
+    void createLine(glm::vec3 point1, glm::vec3 point2, float unitSize, rgbColor color, bool destructive = false);
+    void createSphere(float r,float xc, float yc, float zc, float s, bool solid, 
+                      creationMode mode, bool destructive = false, bool debug = false);
     
 private:
     int  _callsToTreesToArrays;

libraries/shared/src/PacketHeaders.h

@@ -21,6 +21,7 @@ const PACKET_HEADER PACKET_HEADER_HEAD_DATA = 'H';
 const PACKET_HEADER PACKET_HEADER_Z_COMMAND = 'Z';
 const PACKET_HEADER PACKET_HEADER_INJECT_AUDIO = 'I';
 const PACKET_HEADER PACKET_HEADER_SET_VOXEL = 'S';
+const PACKET_HEADER PACKET_HEADER_SET_VOXEL_DESTRUCTIVE = 'O';
 const PACKET_HEADER PACKET_HEADER_ERASE_VOXEL = 'E';
 const PACKET_HEADER PACKET_HEADER_VOXEL_DATA = 'V';
 const PACKET_HEADER PACKET_HEADER_VOXEL_DATA_MONOCHROME = 'v';

libraries/voxels/src/VoxelTree.cpp

@@ -293,7 +293,7 @@ void VoxelTree::eraseAllVoxels() {
     _isDirty = true;
 }
 
-void VoxelTree::readCodeColorBufferToTree(unsigned char *codeColorBuffer) {
+void VoxelTree::readCodeColorBufferToTree(unsigned char *codeColorBuffer, bool destructive) {
     VoxelNode* lastCreatedNode = nodeForOctalCode(rootNode, codeColorBuffer, NULL);
 
     // create the node if it does not exist
@@ -303,10 +303,17 @@ void VoxelTree::readCodeColorBufferToTree(unsigned char *codeColorBuffer) {
     } else {
         // if it does exist, make sure it has no children
         for (int i = 0; i < 8; i++) {
+            if (lastCreatedNode->getChildAtIndex(i)) {
+                if (destructive) {
                     lastCreatedNode->deleteChildAtIndex(i);
+                } else {
+                    printLog("WARNING! operation would require deleting child at index %d, add Voxel ignored!\n ", i);
+                }
+            }
         }
     }
 
+    if (lastCreatedNode->isLeaf()) {
         // give this node its color
         int octalCodeBytes = bytesRequiredForCodeLength(*codeColorBuffer);
 
@@ -318,6 +325,7 @@ void VoxelTree::readCodeColorBufferToTree(unsigned char *codeColorBuffer) {
             _isDirty = true;
         }
     }
+}
 
 void VoxelTree::processRemoveVoxelBitstream(unsigned char * bitstream, int bufferSizeBytes) {
 	// XXXBHG: validate buffer is at least 4 bytes long? other guards??
@@ -469,14 +477,15 @@ VoxelNode* VoxelTree::getVoxelAt(float x, float y, float z, float s) const {
     return node;
 }
 
-void VoxelTree::createVoxel(float x, float y, float z, float s, unsigned char red, unsigned char green, unsigned char blue) {
+void VoxelTree::createVoxel(float x, float y, float z, float s, 
+                            unsigned char red, unsigned char green, unsigned char blue, bool destructive) {
     unsigned char* voxelData = pointToVoxel(x,y,z,s,red,green,blue);
-    this->readCodeColorBufferToTree(voxelData);
+    this->readCodeColorBufferToTree(voxelData, destructive);
     delete voxelData;
 }
 
 
-void VoxelTree::createLine(glm::vec3 point1, glm::vec3 point2, float unitSize, rgbColor color) {
+void VoxelTree::createLine(glm::vec3 point1, glm::vec3 point2, float unitSize, rgbColor color, bool destructive) {
     glm::vec3 distance = point2 - point1;
     glm::vec3 items = distance / unitSize;
     int maxItems = std::max(items.x, std::max(items.y, items.z));
@@ -484,14 +493,12 @@ void VoxelTree::createLine(glm::vec3 point1, glm::vec3 point2, float unitSize, r
     glm::vec3 pointAt = point1;
     for (int i = 0; i <= maxItems; i++ ) {
         pointAt += increment;
-        unsigned char* voxelData = pointToVoxel(pointAt.x,pointAt.y,pointAt.z,unitSize,color[0],color[1],color[2]);
+        createVoxel(pointAt.x, pointAt.y, pointAt.z, unitSize, color[0], color[1], color[2], destructive);
-        readCodeColorBufferToTree(voxelData);
-        delete voxelData;
     }
 }
 
 void VoxelTree::createSphere(float radius, float xc, float yc, float zc, float voxelSize, 
-        bool solid, creationMode mode, bool debug) {
+        bool solid, creationMode mode, bool destructive, bool debug) {
         
     bool wantColorRandomizer = (mode == RANDOM);
     bool wantNaturalSurface  = (mode == NATURAL);
@@ -607,13 +614,13 @@ void VoxelTree::createSphere(float radius, float xc, float yc, float zc, float v
                             x = xc + (thisRadius + i * subVoxelScale) * cos(theta) * sin(phi);
                             y = yc + (thisRadius + i * subVoxelScale) * sin(theta) * sin(phi);
                             z = zc + (thisRadius + i * subVoxelScale) * cos(phi);
-                            this->createVoxel(x, y, z, subVoxelScale, red, green, blue);
+                            this->createVoxel(x, y, z, subVoxelScale, red, green, blue, destructive);
                         }
                         naturalSurfaceRendered = true;
                     }
                 }
                 if (!naturalSurfaceRendered) {
-                    this->createVoxel(x, y, z, thisVoxelSize, red, green, blue);
+                    this->createVoxel(x, y, z, thisVoxelSize, red, green, blue, destructive);
                 }
             }
         }

libraries/voxels/src/VoxelTree.h

@@ -41,16 +41,18 @@ public:
 
     void processRemoveVoxelBitstream(unsigned char * bitstream, int bufferSizeBytes);
     void readBitstreamToTree(unsigned char * bitstream,  unsigned long int bufferSizeBytes, bool includeColor = true);
-    void readCodeColorBufferToTree(unsigned char *codeColorBuffer);
+    void readCodeColorBufferToTree(unsigned char *codeColorBuffer, bool destructive = false);
     void deleteVoxelCodeFromTree(unsigned char *codeBuffer, bool stage = false);
     void printTreeForDebugging(VoxelNode *startNode);
     void reaverageVoxelColors(VoxelNode *startNode);
 
     void deleteVoxelAt(float x, float y, float z, float s, bool stage = false);
     VoxelNode* getVoxelAt(float x, float y, float z, float s) const;
-    void createVoxel(float x, float y, float z, float s, unsigned char red, unsigned char green, unsigned char blue);
+    void createVoxel(float x, float y, float z, float s, 
-    void createLine(glm::vec3 point1, glm::vec3 point2, float unitSize, rgbColor color);
+                     unsigned char red, unsigned char green, unsigned char blue, bool destructive = false);
-	void createSphere(float r,float xc, float yc, float zc, float s, bool solid, creationMode mode, bool debug = false);
+    void createLine(glm::vec3 point1, glm::vec3 point2, float unitSize, rgbColor color, bool destructive = false);
+    void createSphere(float r,float xc, float yc, float zc, float s, bool solid, 
+                      creationMode mode, bool destructive = false, bool debug = false);
 
     void recurseTreeWithOperation(RecurseVoxelTreeOperation operation, void* extraData=NULL);
 

voxel-server/src/main.cpp

@@ -503,9 +503,11 @@ int main(int argc, const char * argv[])
     
         if (agentList->getAgentSocket().receive(&agentPublicAddress, packetData, &receivedBytes)) {
         	// XXXBHG: Hacked in support for 'S' SET command
-            if (packetData[0] == PACKET_HEADER_SET_VOXEL) {
+            if (packetData[0] == PACKET_HEADER_SET_VOXEL || packetData[0] == PACKET_HEADER_SET_VOXEL_DESTRUCTIVE) {
+                bool destructive = (packetData[0] == PACKET_HEADER_SET_VOXEL_DESTRUCTIVE);
             	unsigned short int itemNumber = (*((unsigned short int*)&packetData[1]));
-            	printf("got I - insert voxels - command from client receivedBytes=%ld itemNumber=%d\n",
+            	printf("got %s - command from client receivedBytes=%ld itemNumber=%d\n",
+            	    destructive ? "PACKET_HEADER_SET_VOXEL_DESTRUCTIVE" : "PACKET_HEADER_SET_VOXEL",
             		receivedBytes,itemNumber);
             	int atByte = 3;
             	unsigned char* pVoxelData = (unsigned char*)&packetData[3];
@@ -534,7 +536,7 @@ int main(int argc, const char * argv[])
             		printf("inserting voxel at: %f,%f,%f\n",vertices[0],vertices[1],vertices[2]);
             		delete []vertices;
             		
-		            randomTree.readCodeColorBufferToTree(pVoxelData);
+		            randomTree.readCodeColorBufferToTree(pVoxelData, destructive);
             		// skip to next
             		pVoxelData+=voxelDataSize;
             		atByte+=voxelDataSize;