fix DEFAULT_VOXEL_DATA, recompress voxel data when a script calls setVoxel. Use provided transform when rendering.

libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp

@@ -121,7 +121,7 @@ void RenderablePolyVoxEntityItem::setVoxelVolumeSize(glm::vec3 voxelVolumeSize)
     _volData->setBorderValue(255);
 
     #ifdef WANT_DEBUG
-    qDebug() << " new size is" << _volData->getWidth() << _volData->getHeight() << _volData->getDepth();
+    qDebug() << " new voxel-space size is" << _volData->getWidth() << _volData->getHeight() << _volData->getDepth();
     #endif
 
     // I'm not sure this is needed... the docs say that each element is initialized with its default
@@ -220,12 +220,15 @@ uint8_t RenderablePolyVoxEntityItem::getVoxel(int x, int y, int z) {
     return _volData->getVoxelAt(x, y, z);
 }
 
-void RenderablePolyVoxEntityItem::setVoxel(int x, int y, int z, uint8_t toValue) {
+void RenderablePolyVoxEntityItem::setVoxelInternal(int x, int y, int z, uint8_t toValue) {
+    // set a voxel without recompressing the voxel data
     assert(_volData);
     if (!inUserBounds(_volData, _voxelSurfaceStyle, x, y, z)) {
         return;
     }
 
+    updateOnCount(x, y, z, toValue);
+
     if (_voxelSurfaceStyle == SURFACE_EDGED_CUBIC) {
         _volData->setVoxelAt(x + 1, y + 1, z + 1, toValue);
     } else {
@@ -234,6 +237,11 @@ void RenderablePolyVoxEntityItem::setVoxel(int x, int y, int z, uint8_t toValue)
 }
 
 
+void RenderablePolyVoxEntityItem::setVoxel(int x, int y, int z, uint8_t toValue) {
+    setVoxelInternal(x, y, z, toValue);
+    compressVolumeData();
+}
+
 void RenderablePolyVoxEntityItem::updateOnCount(int x, int y, int z, uint8_t toValue) {
     // keep _onCount up to date
     if (!inUserBounds(_volData, _voxelSurfaceStyle, x, y, z)) {
@@ -259,7 +267,7 @@ void RenderablePolyVoxEntityItem::setAll(uint8_t toValue) {
         for (int y = 0; y < _voxelVolumeSize.y; y++) {
             for (int x = 0; x < _voxelVolumeSize.x; x++) {
                 updateOnCount(x, y, z, toValue);
-                setVoxel(x, y, z, toValue);
+                setVoxelInternal(x, y, z, toValue);
             }
         }
     }
@@ -267,7 +275,7 @@ void RenderablePolyVoxEntityItem::setAll(uint8_t toValue) {
 }
 
 void RenderablePolyVoxEntityItem::setVoxelInVolume(glm::vec3 position, uint8_t toValue) {
-    updateOnCount(position.x, position.y, position.z, toValue);
+    // same as setVoxel but takes a vector rather than 3 floats.
     setVoxel(position.x, position.y, position.z, toValue);
 }
 
@@ -283,7 +291,7 @@ void RenderablePolyVoxEntityItem::setSphereInVolume(glm::vec3 center, float radi
                 // If the current voxel is less than 'radius' units from the center then we make it solid.
                 if (fDistToCenter <= radius) {
                     updateOnCount(x, y, z, toValue);
-                    setVoxel(x, y, z, toValue);
+                    setVoxelInternal(x, y, z, toValue);
                 }
             }
         }
@@ -380,10 +388,7 @@ void RenderablePolyVoxEntityItem::render(RenderArgs* args) {
         getModel();
     }
 
-    Transform transform;
-    transform.setTranslation(getPosition() - getRegistrationPoint() * getDimensions());
-    transform.setRotation(getRotation());
-    transform.setScale(getDimensions() / _voxelVolumeSize);
+    Transform transform(voxelToWorldMatrix());
 
     auto mesh = _modelGeometry.getMesh();
     Q_ASSERT(args->_batch);
@@ -514,6 +519,11 @@ void RenderablePolyVoxEntityItem::compressVolumeData() {
 
     QByteArray newVoxelData;
     QDataStream writer(&newVoxelData, QIODevice::WriteOnly | QIODevice::Truncate);
+
+    #ifdef WANT_DEBUG
+    qDebug() << "compressing voxel data of size:" << voxelXSize << voxelYSize << voxelZSize;
+    #endif
+
     writer << voxelXSize << voxelYSize << voxelZSize;
 
     QByteArray compressedData = qCompress(uncompressedData, 9);
@@ -573,7 +583,7 @@ void RenderablePolyVoxEntityItem::decompressVolumeData() {
             for (int x = 0; x < voxelXSize; x++) {
                 int uncompressedIndex = (z * voxelYSize * voxelXSize) + (y * voxelZSize) + x;
                 updateOnCount(x, y, z, uncompressedData[uncompressedIndex]);
-                setVoxel(x, y, z, uncompressedData[uncompressedIndex]);
+                setVoxelInternal(x, y, z, uncompressedData[uncompressedIndex]);
             }
         }
     }

libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h

@@ -73,11 +73,12 @@ public:
     virtual void setVoxelInVolume(glm::vec3 position, uint8_t toValue);
 
     SIMPLE_RENDERABLE();
-    
+
 private:
     // The PolyVoxEntityItem class has _voxelData which contains dimensions and compressed voxel data.  The dimensions
     // may not match _voxelVolumeSize.
 
+    void setVoxelInternal(int x, int y, int z, uint8_t toValue);
     void compressVolumeData();
     void decompressVolumeData();
 

libraries/entities/src/PolyVoxEntityItem.cpp

@@ -23,7 +23,7 @@
 
 const glm::vec3 PolyVoxEntityItem::DEFAULT_VOXEL_VOLUME_SIZE = glm::vec3(32, 32, 32);
 const float PolyVoxEntityItem::MAX_VOXEL_DIMENSION = 32.0f;
-const QByteArray PolyVoxEntityItem::DEFAULT_VOXEL_DATA(qCompress(QByteArray(0), 9)); // XXX
+const QByteArray PolyVoxEntityItem::DEFAULT_VOXEL_DATA(PolyVoxEntityItem::makeEmptyVoxelData());
 const PolyVoxEntityItem::PolyVoxSurfaceStyle PolyVoxEntityItem::DEFAULT_VOXEL_SURFACE_STYLE =
     PolyVoxEntityItem::SURFACE_MARCHING_CUBES;
 
@@ -31,6 +31,25 @@ EntityItemPointer PolyVoxEntityItem::factory(const EntityItemID& entityID, const
     return EntityItemPointer(new PolyVoxEntityItem(entityID, properties));
 }
 
+
+
+
+QByteArray PolyVoxEntityItem::makeEmptyVoxelData(quint16 voxelXSize, quint16 voxelYSize, quint16 voxelZSize) {
+    int rawSize = voxelXSize * voxelYSize * voxelZSize;
+
+    QByteArray uncompressedData = QByteArray(rawSize, '\0');
+    QByteArray newVoxelData;
+    QDataStream writer(&newVoxelData, QIODevice::WriteOnly | QIODevice::Truncate);
+    writer << voxelXSize << voxelYSize << voxelZSize;
+
+    QByteArray compressedData = qCompress(uncompressedData, 9);
+    writer << compressedData;
+
+    return newVoxelData;
+}
+
+
+
 PolyVoxEntityItem::PolyVoxEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
     EntityItem(entityItemID),
     _voxelVolumeSize(PolyVoxEntityItem::DEFAULT_VOXEL_VOLUME_SIZE),

libraries/entities/src/PolyVoxEntityItem.h

@@ -12,14 +12,14 @@
 #ifndef hifi_PolyVoxEntityItem_h
 #define hifi_PolyVoxEntityItem_h
 
-#include "EntityItem.h" 
+#include "EntityItem.h"
 
 class PolyVoxEntityItem : public EntityItem {
  public:
     static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
 
     PolyVoxEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);
-    
+
     ALLOW_INSTANTIATION // This class can be instantiated
 
     // methods for getting/setting all properties of an entity
@@ -29,22 +29,22 @@ class PolyVoxEntityItem : public EntityItem {
     // TODO: eventually only include properties changed since the params.lastViewFrustumSent time
     virtual EntityPropertyFlags getEntityProperties(EncodeBitstreamParams& params) const;
 
-    virtual void appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params, 
+    virtual void appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
                                     EntityTreeElementExtraEncodeData* modelTreeElementExtraEncodeData,
                                     EntityPropertyFlags& requestedProperties,
                                     EntityPropertyFlags& propertyFlags,
                                     EntityPropertyFlags& propertiesDidntFit,
-                                    int& propertyCount, 
+                                    int& propertyCount,
                                     OctreeElement::AppendState& appendState) const;
 
-    virtual int readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead, 
+    virtual int readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
                                                  ReadBitstreamToTreeParams& args,
                                                  EntityPropertyFlags& propertyFlags, bool overwriteLocalData);
-    
+
     // never have a ray intersection pick a PolyVoxEntityItem.
     virtual bool supportsDetailedRayIntersection() const { return true; }
     virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                         bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
+                         bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face,
                          void** intersectedObject, bool precisionPicking) const { return false; }
 
     virtual void debugDump() const;
@@ -58,12 +58,12 @@ class PolyVoxEntityItem : public EntityItem {
     enum PolyVoxSurfaceStyle {
         SURFACE_MARCHING_CUBES,
         SURFACE_CUBIC,
-	SURFACE_EDGED_CUBIC
+        SURFACE_EDGED_CUBIC
     };
 
     virtual void setVoxelSurfaceStyle(PolyVoxSurfaceStyle voxelSurfaceStyle) { _voxelSurfaceStyle = voxelSurfaceStyle; }
     virtual void setVoxelSurfaceStyle(uint16_t voxelSurfaceStyle) {
-	setVoxelSurfaceStyle((PolyVoxSurfaceStyle) voxelSurfaceStyle);
+        setVoxelSurfaceStyle((PolyVoxSurfaceStyle) voxelSurfaceStyle);
     }
     virtual PolyVoxSurfaceStyle getVoxelSurfaceStyle() const { return _voxelSurfaceStyle; }
 
@@ -82,15 +82,17 @@ class PolyVoxEntityItem : public EntityItem {
     virtual void setAll(uint8_t toValue) {}
 
     virtual void setVoxelInVolume(glm::vec3 position, uint8_t toValue) {}
-    
+
     virtual uint8_t getVoxel(int x, int y, int z) { return 0; }
     virtual void setVoxel(int x, int y, int z, uint8_t toValue) {}
 
+    static QByteArray makeEmptyVoxelData(quint16 voxelXSize = 16, quint16 voxelYSize = 16, quint16 voxelZSize = 16);
 
  protected:
     glm::vec3 _voxelVolumeSize; // this is always 3 bytes
     QByteArray _voxelData;
     PolyVoxSurfaceStyle _voxelSurfaceStyle;
+
 };
 
 #endif // hifi_PolyVoxEntityItem_h