diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index fc72aa63bd..95d40eec12 100755
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -1363,8 +1363,10 @@ void Application::exportVoxels() {
 
 void Application::importVoxels() {
     QString desktopLocation = QDesktopServices::storageLocation(QDesktopServices::DesktopLocation);
-    QString fileNameString = QFileDialog::getOpenFileName(_glWidget, tr("Import Voxels"), desktopLocation, 
-                                                          tr("Sparse Voxel Octree Files, Square PNG, Schematic Files (*.svo *.png *.schematic)"));
+    QString fileNameString = QFileDialog::getOpenFileName(
+                _glWidget, tr("Import Voxels"), desktopLocation,
+                tr("Sparse Voxel Octree Files, Square PNG, Schematic Files (*.svo *.png *.schematic)"));
+
     QByteArray fileNameAscii = fileNameString.toAscii();
     const char* fileName = fileNameAscii.data();
     
diff --git a/libraries/voxels/src/Tags.cpp b/libraries/voxels/src/Tags.cpp
index 13e8795197..0cbfa1a37c 100644
--- a/libraries/voxels/src/Tags.cpp
+++ b/libraries/voxels/src/Tags.cpp
@@ -1,3 +1,11 @@
+//
+//  Tags.h
+//  hifi
+//
+//  Created by Clement Brisset on 7/3/13.
+//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
+//
+
 #include "Tags.h"
 #include <Log.h>
 
@@ -8,10 +16,9 @@
 
 Tag::Tag(int tagId, std::stringstream &ss) : _tagId(tagId) {
     int size = ss.get() << 8 | ss.get();
-  
+
     _name.clear();
-    for (int i = 0; i < size; ++i) {
-        _name += ss.get();
+    for (int i = 0; i < size; ++i) {        _name += ss.get();
     }
 }
 
@@ -46,22 +53,22 @@ Tag* Tag::readTag(int tagId, std::stringstream &ss) {
 }
 
 TagByte::TagByte(std::stringstream &ss) : Tag(TAG_Byte, ss) {
-  _data = ss.get();
+    _data = ss.get();
 }
 
 TagShort::TagShort(std::stringstream &ss) : Tag(TAG_Short, ss) {
-  _data = ss.get() << 8 | ss.get();
+    _data = ss.get() << 8 | ss.get();
 }
 
 TagInt::TagInt(std::stringstream &ss) : Tag(TAG_Int, ss) {
-  _data = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get();
+    _data = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get();
 }
 
 TagLong::TagLong(std::stringstream &ss) : Tag(TAG_Long, ss) {
-  _data = (((int64_t) ss.get()) << 56 | ((int64_t) ss.get()) << 48
-          |((int64_t) ss.get()) << 40 | ((int64_t) ss.get()) << 32
-          |           ss.get()  << 24 |            ss.get()  << 16
-          |           ss.get()  << 8  |            ss.get());
+    _data = (((int64_t) ss.get()) << 56 | ((int64_t) ss.get()) << 48
+             |((int64_t) ss.get()) << 40 | ((int64_t) ss.get()) << 32
+             |           ss.get()  << 24 |            ss.get()  << 16
+             |           ss.get()  << 8  |            ss.get());
 }
 
 // We don't need Float and double, so we just ignore the bytes
@@ -74,31 +81,32 @@ TagDouble::TagDouble(std::stringstream &ss) : Tag(TAG_Double, ss) {
 }
 
 TagByteArray::TagByteArray(std::stringstream &ss) : Tag(TAG_Byte_Array, ss) {
-  _size = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get();
-  
-  _data = new char[_size];
-  for (int i = 0; i < _size; ++i) {
-    _data[i] = ss.get();
-  }
+    _size = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get();
+
+    _data = new char[_size];
+    for (int i = 0; i < _size; ++i) {
+        _data[i] = ss.get();
+    }
 }
 
 TagString::TagString(std::stringstream &ss) : Tag(TAG_String, ss) {
-  _size = ss.get() << 8 | ss.get();
-  
-  for (int i = 0; i < _size; ++i) {
-    _data += ss.get();
-  }
+    _size = ss.get() << 8 | ss.get();
+
+    for (int i = 0; i < _size; ++i) {
+        _data += ss.get();
+    }
 }
 
 TagList::TagList(std::stringstream &ss) :
     Tag(TAG_List, ss) {
-  _tagId = ss.get();
-  _size  = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get();
+    _tagId = ss.get();
+    _size  = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get();
 
-  for (int i = 0; i < _size; ++i) {
-    ss.putback(0); ss.putback(0);
-    _data.push_back(readTag(_tagId, ss));
-  }
+    for (int i = 0; i < _size; ++i) {
+        ss.putback(0);
+        ss.putback(0);
+        _data.push_back(readTag(_tagId, ss));
+    }
 }
 
 TagCompound::TagCompound(std::stringstream &ss) :
@@ -139,96 +147,99 @@ TagCompound::TagCompound(std::stringstream &ss) :
 }
 
 TagIntArray::TagIntArray(std::stringstream &ss) : Tag(TAG_Int_Array, ss) {
-  _size = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get();
-  
-  _data = new int[_size];
-  for (int i = 0; i < _size; ++i) {
-    _data[i] = ss.get();
-  }
+    _size = ss.get() << 24 | ss.get() << 16 | ss.get() << 8 | ss.get();
+
+    _data = new int[_size];
+    for (int i = 0; i < _size; ++i) {
+        _data[i] = ss.get();
+    }
 }
 
 int retrieveData(std::string filename, std::stringstream &ss) {
     std::ifstream file(filename.c_str(), std::ios::binary);
 
-  int type = file.peek();
-  if (0x0A == type) {
-    ss.flush();
-    ss << file;
-    return 0;
-  }
-  if (0x1F == type) {
-    return ungzip(file, ss);
-  }
+    int type = file.peek();
+    if (type == 0x0A) {
+        ss.flush();
+        ss << file;
+        return 0;
+    }
+    if (type == 0x1F) {
+        return ungzip(file, ss);
+    }
 
-  return 1;
+    return 1;
 }
 
 int ungzip(std::ifstream &file, std::stringstream &ss) {
-  std::string gzipedBytes;
-  gzipedBytes.clear();
-  ss.flush();
+    std::string gzipedBytes;
+    gzipedBytes.clear();
+    ss.flush();
 
-  while (!file.eof()) {
-    gzipedBytes += (char) file.get();
-  }
-  file.close();
+    while (!file.eof()) {
+        gzipedBytes += (char) file.get();
+    }
+    file.close();
 
-  if ( gzipedBytes.size() == 0 ) {
-    ss << gzipedBytes;
-    return 0;
-  }
-
-  unsigned int full_length  = gzipedBytes.size();
-  unsigned int half_length  = gzipedBytes.size()/2;
-  unsigned int uncompLength = full_length;
-
-  char* uncomp = (char*) calloc(sizeof(char), uncompLength);
-
-  z_stream strm;
-  strm.next_in   = (Bytef *) gzipedBytes.c_str();
-  strm.avail_in  = full_length;
-  strm.total_out = 0;
-  strm.zalloc    = Z_NULL;
-  strm.zfree     = Z_NULL;
-
-  bool done = false;
-
-  if (inflateInit2(&strm, (16 + MAX_WBITS)) != Z_OK) {
-    free(uncomp);
-    return 1;
-  }
-
-  while (!done) {
-    // If our output buffer is too small
-    if (strm.total_out >= uncompLength) {
-      // Increase size of output buffer
-      char* uncomp2 = (char*) calloc(sizeof(char), uncompLength + half_length);
-      memcpy(uncomp2, uncomp, uncompLength);
-      uncompLength += half_length;
-      free(uncomp);
-      uncomp = uncomp2;
+    if (gzipedBytes.size() == 0) {
+        ss << gzipedBytes;
+        return 0;
     }
 
-    strm.next_out  = (Bytef *) (uncomp + strm.total_out);
-    strm.avail_out = uncompLength - strm.total_out;
+    unsigned int full_length  = gzipedBytes.size();
+    unsigned int half_length  = gzipedBytes.size()/2;
+    unsigned int uncompLength = full_length;
 
-    // Inflate another chunk.
-    int err = inflate (&strm, Z_SYNC_FLUSH);
-    if (err == Z_STREAM_END) done = true;
-    else if (err != Z_OK)    break;
-  }
+    char* uncomp = (char*) calloc(sizeof(char), uncompLength);
 
-  if (inflateEnd (&strm) != Z_OK) {
+    z_stream strm;
+    strm.next_in   = (Bytef *) gzipedBytes.c_str();
+    strm.avail_in  = full_length;
+    strm.total_out = 0;
+    strm.zalloc    = Z_NULL;
+    strm.zfree     = Z_NULL;
+
+    bool done = false;
+
+    if (inflateInit2(&strm, (16 + MAX_WBITS)) != Z_OK) {
+        free(uncomp);
+        return 1;
+    }
+
+    while (!done) {
+        // If our output buffer is too small
+        if (strm.total_out >= uncompLength) {
+            // Increase size of output buffer
+            char* uncomp2 = (char*) calloc(sizeof(char), uncompLength + half_length);
+            memcpy(uncomp2, uncomp, uncompLength);
+            uncompLength += half_length;
+            free(uncomp);
+            uncomp = uncomp2;
+        }
+
+        strm.next_out  = (Bytef *) (uncomp + strm.total_out);
+        strm.avail_out = uncompLength - strm.total_out;
+
+        // Inflate another chunk.
+        int err = inflate (&strm, Z_SYNC_FLUSH);
+        if (err == Z_STREAM_END) {
+            done = true;
+        } else if (err != Z_OK) {
+            break;
+        }
+    }
+
+    if (inflateEnd (&strm) != Z_OK) {
+        free(uncomp);
+        return 1;
+    }
+
+    for (size_t i = 0; i < strm.total_out; ++i) {
+        ss << uncomp[i];
+    }
     free(uncomp);
-    return 1;
-  }
 
-  for (size_t i = 0; i < strm.total_out; ++i) {
-    ss << uncomp[i];
-  }
-  free(uncomp);
-
-  return 0;
+    return 0;
 }
 
 
diff --git a/libraries/voxels/src/Tags.h b/libraries/voxels/src/Tags.h
index be45e2dc86..a005095142 100644
--- a/libraries/voxels/src/Tags.h
+++ b/libraries/voxels/src/Tags.h
@@ -1,3 +1,14 @@
+//
+//  Tags.h
+//  hifi
+//
+//  Created by Clement Brisset on 7/3/13.
+//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
+//
+
+#ifndef __hifi__Tags__
+#define __hifi__Tags__
+
 #include <cstdlib>
 #include <cstring>
 
@@ -22,141 +33,143 @@ int retrieveData(std::string filename, std::stringstream &ss);
 int ungzip(std::ifstream &file, std::stringstream &ss);
 
 class Tag {
- protected:
-  int         _tagId;
-  std::string _name;
-  
- public:
-  Tag(int tagId, std::stringstream &ss);
-  
-  int         getTagId() const {return _tagId;}
-  std::string getName () const {return _name; }
-  
-  static Tag* readTag(int tagId, std::stringstream &ss);
+public:
+    Tag(int tagId, std::stringstream &ss);
+
+    int         getTagId() const {return _tagId;}
+    std::string getName () const {return _name; }
+
+    static Tag* readTag(int tagId, std::stringstream &ss);
+
+protected:
+    int         _tagId;
+    std::string _name;
 };
 
 class TagByte : public Tag  {
- private:
-  int8_t _data;
-  
- public:
-  TagByte(std::stringstream &ss);
-  
-  int8_t getData() const {return _data;}
+public:
+    TagByte(std::stringstream &ss);
+
+    int8_t getData() const {return _data;}
+
+private:
+    int8_t _data;
 };
 
 class TagShort : public Tag  {
- private:
-  int16_t _data;
-  
- public:
-  TagShort(std::stringstream &ss);
-  
-  int16_t getData() const {return _data;}
+public:
+    TagShort(std::stringstream &ss);
+
+    int16_t getData() const {return _data;}
+
+private:
+    int16_t _data;
 };
 
 class TagInt : public Tag  {
- private:
-  int32_t _data;
-  
- public:
-  TagInt(std::stringstream &ss);
-  
-  int32_t getData() const {return _data;}
+public:
+    TagInt(std::stringstream &ss);
+
+    int32_t getData() const {return _data;}
+
+private:
+    int32_t _data;
 };
 
 class TagLong : public Tag  {
- private:
-  int64_t _data;
-  
- public:
-  TagLong(std::stringstream &ss);
-  
-  int64_t getData() const {return _data;}
+public:
+    TagLong(std::stringstream &ss);
+
+    int64_t getData() const {return _data;}
+
+private:
+    int64_t _data;
 };
 
 class TagFloat : public Tag  {
- public:
-  TagFloat(std::stringstream &ss);
+public:
+    TagFloat(std::stringstream &ss);
 };
 
 class TagDouble : public Tag  {
- public:
-  TagDouble(std::stringstream &ss);
+public:
+    TagDouble(std::stringstream &ss);
 };
 
 class TagByteArray : public Tag {
- private:
-  int   _size;
-  char* _data;
-  
- public:
-  TagByteArray(std::stringstream &ss);
-  
-  int   getSize() const {return _size;}
-  char* getData() const {return _data;}
+public:
+    TagByteArray(std::stringstream &ss);
+
+    int   getSize() const {return _size;}
+    char* getData() const {return _data;}
+
+private:
+    int   _size;
+    char* _data;
 };
 
 class TagString : public Tag {
- private:
-  int         _size;
-  std::string _data;
+public:
+    TagString(std::stringstream &ss);
 
- public:
-  TagString(std::stringstream &ss);
-  
-  int         getSize() const {return _size;}
-  std::string getData() const {return _data;}
+    int         getSize() const {return _size;}
+    std::string getData() const {return _data;}
+
+private:
+    int         _size;
+    std::string _data;
 };
 
 class TagList : public Tag {
- private:
-  int             _tagId;
-  int             _size;
-  std::list<Tag*> _data;
-  
- public:
-  TagList(std::stringstream &ss);
-  
-  int             getTagId() const {return _tagId;}
-  int             getSize () const {return _size; }
-  std::list<Tag*> getData () const {return _data; }
+public:
+    TagList(std::stringstream &ss);
+
+    int             getTagId() const {return _tagId;}
+    int             getSize () const {return _size; }
+    std::list<Tag*> getData () const {return _data; }
+
+private:
+    int             _tagId;
+    int             _size;
+    std::list<Tag*> _data;
 };
 
 class TagCompound : public Tag {
- private:
-  int             _size;
-  std::list<Tag*> _data;
-  
-  // Specific to schematics file
-  int   _width;
-  int   _length;
-  int   _height;
-  char* _blocksData;
-  char* _blocksId;
+public:
+    TagCompound(std::stringstream &ss);
 
- public:
-  TagCompound(std::stringstream &ss);
-  
-  int             getSize      () const {return _size;      }
-  std::list<Tag*> getData      () const {return _data;      }
+    int             getSize      () const {return _size;      }
+    std::list<Tag*> getData      () const {return _data;      }
 
-  int             getWidth     () const {return _width;     }
-  int             getLength    () const {return _length;    }
-  int             getHeight    () const {return _height;    }
-  char*           getBlocksId  () const {return _blocksId;  }
-  char*           getBlocksData() const {return _blocksData;}
+    int             getWidth     () const {return _width;     }
+    int             getLength    () const {return _length;    }
+    int             getHeight    () const {return _height;    }
+    char*           getBlocksId  () const {return _blocksId;  }
+    char*           getBlocksData() const {return _blocksData;}
+
+private:
+    int             _size;
+    std::list<Tag*> _data;
+
+    // Specific to schematics file
+    int   _width;
+    int   _length;
+    int   _height;
+    char* _blocksData;
+    char* _blocksId;
 };
 
 class TagIntArray : public Tag {
- private:
-  int  _size;
-  int* _data;
+public:
+    TagIntArray(std::stringstream &ss);
+    ~TagIntArray() {delete _data;}
 
- public:
-  TagIntArray(std::stringstream &ss);
-  ~TagIntArray() {delete _data;}
-  
-  int  getSize() const {return _size;}
-  int* getData() const {return _data;}
+    int  getSize() const {return _size;}
+    int* getData() const {return _data;}
+
+private:
+    int  _size;
+    int* _data;
 };
+
+#endif /* defined(__hifi__Tags__) */
diff --git a/libraries/voxels/src/VoxelTree.cpp b/libraries/voxels/src/VoxelTree.cpp
index 6189c04cbb..d4b7ec831e 100644
--- a/libraries/voxels/src/VoxelTree.cpp
+++ b/libraries/voxels/src/VoxelTree.cpp
@@ -802,7 +802,7 @@ void VoxelTree::createSphere(float radius, float xc, float yc, float zc, float v
                         if (debug) {
                             printLog("perlin=%f gradient=%f color=(%d,%d,%d)\n",perlin, gradient, red, green, blue);
                         }
-                    } break;
+                        } break;
                     }
                     if (wantNaturalSurface) {
                         // for natural surfaces, we will render up to 16 voxel's above the surface of the sphere
@@ -1460,7 +1460,7 @@ bool VoxelTree::readFromSquareARGB32Pixels(const uint32_t* pixels, int dimension
 bool VoxelTree::readFromSchematicsFile(const char *fileName) {
     std::stringstream ss;
     int err = retrieveData(fileName, ss);
-    if (err && TAG_Compound != ss.get()) {
+    if (err && ss.get() != TAG_Compound) {
         printLog("[ERROR] Invalid schematic file.\n");
         return false;
     }
@@ -1476,7 +1476,7 @@ bool VoxelTree::readFromSchematicsFile(const char *fileName) {
     max = (max > schematics.getHeight()) ? max : schematics.getHeight();
 
     int scale = 1;
-    while (max > scale) scale *= 2;
+    while (max > scale) {scale *= 2;}
     float size = 1.0f / scale;
 
     int create = 1;
@@ -1491,41 +1491,41 @@ bool VoxelTree::readFromSchematicsFile(const char *fileName) {
                 int data = schematics.getBlocksData()[pos];
 
                 create = 1;
-                computeBlockColor(id, data, &red, &green, &blue, &create);
+                computeBlockColor(id, data, red, green, blue, create);
 
                 switch (create) {
-                case 1:
-                    createVoxel(size * x, size * y, size * z, size, red, green, blue, true);
-                    ++count;
-                    break;
-                case 2:
-                    switch (data) {
-                    case 0:
-                        createVoxel(size * x + size / 2, size * y + size / 2, size * z           , size / 2, red, green, blue, true);
-                        createVoxel(size * x + size / 2, size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
-                        break;
                     case 1:
-                        createVoxel(size * x           , size * y + size / 2, size * z           , size / 2, red, green, blue, true);
-                        createVoxel(size * x           , size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
+                        createVoxel(size * x, size * y, size * z, size, red, green, blue, true);
+                        ++count;
                         break;
                     case 2:
-                        createVoxel(size * x           , size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
-                        createVoxel(size * x + size / 2, size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
-                        break;
+                        switch (data) {
+                            case 0:
+                                createVoxel(size * x + size / 2, size * y + size / 2, size * z           , size / 2, red, green, blue, true);
+                                createVoxel(size * x + size / 2, size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
+                                break;
+                            case 1:
+                                createVoxel(size * x           , size * y + size / 2, size * z           , size / 2, red, green, blue, true);
+                                createVoxel(size * x           , size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
+                                break;
+                            case 2:
+                                createVoxel(size * x           , size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
+                                createVoxel(size * x + size / 2, size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
+                                break;
+                            case 3:
+                                createVoxel(size * x           , size * y + size / 2, size * z           , size / 2, red, green, blue, true);
+                                createVoxel(size * x + size / 2, size * y + size / 2, size * z           , size / 2, red, green, blue, true);
+                                break;
+                        }
+                        count += 2;
+                        // There's no break on purpose.
                     case 3:
-                        createVoxel(size * x           , size * y + size / 2, size * z           , size / 2, red, green, blue, true);
-                        createVoxel(size * x + size / 2, size * y + size / 2, size * z           , size / 2, red, green, blue, true);
+                        createVoxel(size * x           , size * y, size * z           , size / 2, red, green, blue, true);
+                        createVoxel(size * x + size / 2, size * y, size * z           , size / 2, red, green, blue, true);
+                        createVoxel(size * x           , size * y, size * z + size / 2, size / 2, red, green, blue, true);
+                        createVoxel(size * x + size / 2, size * y, size * z + size / 2, size / 2, red, green, blue, true);
+                        count += 4;
                         break;
-                    }
-                    count += 2;
-                    // There's no break on purpose.
-                case 3:
-                    createVoxel(size * x           , size * y, size * z           , size / 2, red, green, blue, true);
-                    createVoxel(size * x + size / 2, size * y, size * z           , size / 2, red, green, blue, true);
-                    createVoxel(size * x           , size * y, size * z + size / 2, size / 2, red, green, blue, true);
-                    createVoxel(size * x + size / 2, size * y, size * z + size / 2, size / 2, red, green, blue, true);
-                    count += 4;
-                    break;
                 }
             }
         }
@@ -1620,160 +1620,155 @@ void VoxelTree::copyFromTreeIntoSubTree(VoxelTree* sourceTree, VoxelNode* destin
     }
 }
 
-void VoxelTree::computeBlockColor(int id, int data, int* r, int* g, int* b, int* create) {
-    int red = *r, green = *g, blue = *b;
+void VoxelTree::computeBlockColor(int id, int data, int& red, int& green, int& blue, int& create) {
 
     switch (id) {
-    case   1:
-    case  14:
-    case  15:
-    case  16:
-    case  21:
-    case  56:
-    case  73:
-    case  74:
-    case  97:
-    case 129: red = 128; green = 128; blue = 128; break;
-    case   2: red =  77; green = 117; blue =  66; break;
-    case   3:
-    case  60: red = 116; green =  83; blue =  56; break;
-    case   4: red =  71; green =  71; blue =  71; break;
-    case   5:
-    case 125: red = 133; green =  94; blue =  62; break;
-    case   7: red =  35; green =  35; blue =  35; break;
-    case   8:
-    case   9: red = 100; green = 109; blue = 185; break;
-    case  10:
-    case  11: red = 192; green =  64; blue =   8; break;
-    case  12: red = 209; green = 199; blue = 155; break;
-    case  13: red =  96; green =  94; blue =  93; break;
-    case  17: red =  71; green =  56; blue =  35; break;
-    case  18: red =  76; green = 104; blue =  64; break;
-    case  19: red = 119; green = 119; blue =  37; break;
-    case  22: red =  22; green =  44; blue =  86; break;
-    case  23:
-    case  29:
-    case  33:
-    case  61:
-    case  62:
-    case 158: red =  61; green =  61; blue =  61; break;
-    case  24: red = 209; green = 202; blue = 156; break;
-    case  25:
-    case  58:
-    case  84:
-    case 137: red =  57; green =  38; blue =  25; break;
-    case  35:
-        switch (data) {
-        case  0: red = 234; green = 234; blue = 234; break;
-        case  1: red = 224; green = 140; blue =  84; break;
-        case  2: red = 185; green =  90; blue = 194; break;
-        case  3: red = 124; green = 152; blue = 208; break;
-        case  4: red = 165; green = 154; blue =  35; break;
-        case  5: red =  70; green = 187; blue =  61; break;
-        case  6: red = 206; green = 124; blue = 145; break;
-        case  7: red =  66; green =  66; blue =  66; break;
-        case  8: red = 170; green = 176; blue = 176; break;
-        case  9: red =  45; green = 108; blue =  35; break;
-        case 10: red = 130; green =  62; blue =   8; break;
-        case 11: red =  43; green =  51; blue =  29; break;
-        case 12: red =  73; green =  47; blue =  29; break;
-        case 13: red =  57; green =  76; blue =  36; break;
-        case 14: red = 165; green =  58; blue =  53; break;
-        case 15: red =  24; green =  24; blue =  24; break;
-        default:
-            *create = 0;
+        case   1:
+        case  14:
+        case  15:
+        case  16:
+        case  21:
+        case  56:
+        case  73:
+        case  74:
+        case  97:
+        case 129: red = 128; green = 128; blue = 128; break;
+        case   2: red =  77; green = 117; blue =  66; break;
+        case   3:
+        case  60: red = 116; green =  83; blue =  56; break;
+        case   4: red =  71; green =  71; blue =  71; break;
+        case   5:
+        case 125: red = 133; green =  94; blue =  62; break;
+        case   7: red =  35; green =  35; blue =  35; break;
+        case   8:
+        case   9: red = 100; green = 109; blue = 185; break;
+        case  10:
+        case  11: red = 192; green =  64; blue =   8; break;
+        case  12: red = 209; green = 199; blue = 155; break;
+        case  13: red =  96; green =  94; blue =  93; break;
+        case  17: red =  71; green =  56; blue =  35; break;
+        case  18: red =  76; green = 104; blue =  64; break;
+        case  19: red = 119; green = 119; blue =  37; break;
+        case  22: red =  22; green =  44; blue =  86; break;
+        case  23:
+        case  29:
+        case  33:
+        case  61:
+        case  62:
+        case 158: red =  61; green =  61; blue =  61; break;
+        case  24: red = 209; green = 202; blue = 156; break;
+        case  25:
+        case  58:
+        case  84:
+        case 137: red =  57; green =  38; blue =  25; break;
+        case  35:
+            switch (data) {
+                case  0: red = 234; green = 234; blue = 234; break;
+                case  1: red = 224; green = 140; blue =  84; break;
+                case  2: red = 185; green =  90; blue = 194; break;
+                case  3: red = 124; green = 152; blue = 208; break;
+                case  4: red = 165; green = 154; blue =  35; break;
+                case  5: red =  70; green = 187; blue =  61; break;
+                case  6: red = 206; green = 124; blue = 145; break;
+                case  7: red =  66; green =  66; blue =  66; break;
+                case  8: red = 170; green = 176; blue = 176; break;
+                case  9: red =  45; green = 108; blue =  35; break;
+                case 10: red = 130; green =  62; blue =   8; break;
+                case 11: red =  43; green =  51; blue =  29; break;
+                case 12: red =  73; green =  47; blue =  29; break;
+                case 13: red =  57; green =  76; blue =  36; break;
+                case 14: red = 165; green =  58; blue =  53; break;
+                case 15: red =  24; green =  24; blue =  24; break;
+                default:
+                    create = 0;
+                    break;
+            }
             break;
-        }
-        break;
-    case  41: red = 239; green = 238; blue = 105; break;
-    case  42: red = 146; green = 146; blue = 146; break;
-    case  43:
-    case  98: red = 161; green = 161; blue = 161; break;
-    case  44:
-        *create = 3;
+        case  41: red = 239; green = 238; blue = 105; break;
+        case  42: red = 146; green = 146; blue = 146; break;
+        case  43:
+        case  98: red = 161; green = 161; blue = 161; break;
+        case  44:
+            create = 3;
 
-        switch (data) {
-        case 0: red = 161; green = 161; blue = 161; break;
-        case 1: red = 209; green = 202; blue = 156; break;
-        case 2: red = 133; green =  94; blue =  62; break;
-        case 3: red =  71; green =  71; blue =  71; break;
-        case 4: red = 121; green =  67; blue =  53; break;
-        case 5: red = 161; green = 161; blue = 161; break;
-        case 6: red =  45; green =  22; blue =  26; break;
-        case 7: red = 195; green = 192; blue = 185; break;
-        default:
-            *create = 0;
+            switch (data) {
+                case 0: red = 161; green = 161; blue = 161; break;
+                case 1: red = 209; green = 202; blue = 156; break;
+                case 2: red = 133; green =  94; blue =  62; break;
+                case 3: red =  71; green =  71; blue =  71; break;
+                case 4: red = 121; green =  67; blue =  53; break;
+                case 5: red = 161; green = 161; blue = 161; break;
+                case 6: red =  45; green =  22; blue =  26; break;
+                case 7: red = 195; green = 192; blue = 185; break;
+                default:
+                    create = 0;
+                    break;
+            }
             break;
-        }
-        break;
-    case  45: red = 121; green =  67; blue =  53; break;
-    case  46: red = 118; green =  36; blue =  13; break;
-    case  47: red = 155; green = 127; blue =  76; break;
-    case  48: red =  61; green =  79; blue =  61; break;
-    case  49: red =  52; green =  41; blue =  74; break;
-    case  52: red =  12; green =  66; blue =  71; break;
-    case  53:
-    case  67:
-    case 108:
-    case 109:
-    case 114:
-    case 128:
-    case 134:
-    case 135:
-    case 136:
-    case 156:
-        *create = 2;
-
-        switch (id) {
+        case  45: red = 121; green =  67; blue =  53; break;
+        case  46: red = 118; green =  36; blue =  13; break;
+        case  47: red = 155; green = 127; blue =  76; break;
+        case  48: red =  61; green =  79; blue =  61; break;
+        case  49: red =  52; green =  41; blue =  74; break;
+        case  52: red =  12; green =  66; blue =  71; break;
         case  53:
+        case  67:
+        case 108:
+        case 109:
+        case 114:
+        case 128:
         case 134:
         case 135:
-        case 136: red = 133; green =  94; blue =  62; break;
-        case  67: red =  71; green =  71; blue =  71; break;
-        case 108: red = 121; green =  67; blue =  53; break;
-        case 109: red = 161; green = 161; blue = 161; break;
-        case 114: red =  45; green =  22; blue =  26; break;
-        case 128: red = 209; green = 202; blue = 156; break;
-        case 156: red = 195; green = 192; blue = 185; break;
-        default:
-            *create = 0;
-            break;
-        }
-        break;
-    case  54:
-    case  95:
-    case 146: red = 155; green = 105; blue =  32; break;
-    case  57: red = 145; green = 219; blue = 215; break;
-    case  79: red = 142; green = 162; blue = 195; break;
-    case  80: red = 255; green = 255; blue = 255; break;
-    case  81: red =   8; green =  64; blue =  15; break;
-    case  82: red = 150; green = 155; blue = 166; break;
-    case  86:
-    case  91: red = 179; green = 108; blue =  17; break;
-    case  87:
-    case 153: red =  91; green =  31; blue =  30; break;
-    case  88: red =  68; green =  49; blue =  38; break;
-    case  89: red = 180; green = 134; blue =  65; break;
-    case 103: red = 141; green = 143; blue =  36; break;
-    case 110: red = 103; green =  92; blue =  95; break;
-    case 112: red =  45; green =  22; blue =  26; break;
-    case 121: red = 183; green = 178; blue = 129; break;
-    case 123: red = 101; green =  59; blue =  31; break;
-    case 124: red = 213; green = 178; blue = 123; break;
-    case 130: red =  38; green =  54; blue =  56; break;
-    case 133: red =  53; green =  84; blue =  85; break;
-    case 152: red = 131; green =  22; blue =   7; break;
-    case 155: red = 195; green = 192; blue = 185; break;
-    case 159: red = 195; green = 165; blue = 150; break;
-    case 170: red = 168; green = 139; blue =  15; break;
-    case 172: red = 140; green =  86; blue =  61; break;
-    case 173: red =   9; green =   9; blue =   9; break;
-    default:
-        *create = 0;
-        break;
-    }
+        case 136:
+        case 156:
+            create = 2;
 
-    *r = red;
-    *g = green;
-    *b = blue;
+            switch (id) {
+                case  53:
+                case 134:
+                case 135:
+                case 136: red = 133; green =  94; blue =  62; break;
+                case  67: red =  71; green =  71; blue =  71; break;
+                case 108: red = 121; green =  67; blue =  53; break;
+                case 109: red = 161; green = 161; blue = 161; break;
+                case 114: red =  45; green =  22; blue =  26; break;
+                case 128: red = 209; green = 202; blue = 156; break;
+                case 156: red = 195; green = 192; blue = 185; break;
+                default:
+                    create = 0;
+                    break;
+            }
+            break;
+        case  54:
+        case  95:
+        case 146: red = 155; green = 105; blue =  32; break;
+        case  57: red = 145; green = 219; blue = 215; break;
+        case  79: red = 142; green = 162; blue = 195; break;
+        case  80: red = 255; green = 255; blue = 255; break;
+        case  81: red =   8; green =  64; blue =  15; break;
+        case  82: red = 150; green = 155; blue = 166; break;
+        case  86:
+        case  91: red = 179; green = 108; blue =  17; break;
+        case  87:
+        case 153: red =  91; green =  31; blue =  30; break;
+        case  88: red =  68; green =  49; blue =  38; break;
+        case  89: red = 180; green = 134; blue =  65; break;
+        case 103: red = 141; green = 143; blue =  36; break;
+        case 110: red = 103; green =  92; blue =  95; break;
+        case 112: red =  45; green =  22; blue =  26; break;
+        case 121: red = 183; green = 178; blue = 129; break;
+        case 123: red = 101; green =  59; blue =  31; break;
+        case 124: red = 213; green = 178; blue = 123; break;
+        case 130: red =  38; green =  54; blue =  56; break;
+        case 133: red =  53; green =  84; blue =  85; break;
+        case 152: red = 131; green =  22; blue =   7; break;
+        case 155: red = 195; green = 192; blue = 185; break;
+        case 159: red = 195; green = 165; blue = 150; break;
+        case 170: red = 168; green = 139; blue =  15; break;
+        case 172: red = 140; green =  86; blue =  61; break;
+        case 173: red =   9; green =   9; blue =   9; break;
+        default:
+            create = 0;
+            break;
+    }
 }
diff --git a/libraries/voxels/src/VoxelTree.h b/libraries/voxels/src/VoxelTree.h
index 56d0e1120e..d4fe888535 100644
--- a/libraries/voxels/src/VoxelTree.h
+++ b/libraries/voxels/src/VoxelTree.h
@@ -136,7 +136,7 @@ public:
     // reads voxels from square image with alpha as a Y-axis
     bool readFromSquareARGB32Pixels(const uint32_t* pixels, int dimension);
     bool readFromSchematicsFile(const char* filename);
-    void computeBlockColor(int id, int data, int* r, int* g, int* b, int* create);
+    void computeBlockColor(int id, int data, int& r, int& g, int& b, int& create);
 
     unsigned long getVoxelCount();