vertex color support in ModelScriptingInterface

libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp

@@ -1663,6 +1663,7 @@ bool RenderablePolyVoxEntityItem::getMeshes(MeshProxyList& result) {
             // the mesh will be in voxel-space.  transform it into object-space
             meshProxy = new SimpleMeshProxy(
                 _mesh->map([=](glm::vec3 position){ return glm::vec3(transform * glm::vec4(position, 1.0f)); },
+                           [=](glm::vec3 color){ return color; },
                            [=](glm::vec3 normal){ return glm::normalize(glm::vec3(transform * glm::vec4(normal, 0.0f))); },
                            [&](uint32_t index){ return index; }));
             result << meshProxy;

libraries/model/src/model/Geometry.cpp

@@ -11,8 +11,6 @@
 
 #include "Geometry.h"
 
-#include <QDebug>
-
 using namespace model;
 
 Mesh::Mesh() :
@@ -136,11 +134,13 @@ Box Mesh::evalPartsBound(int partStart, int partEnd) const {
 
 
 model::MeshPointer Mesh::map(std::function<glm::vec3(glm::vec3)> vertexFunc,
+                             std::function<glm::vec3(glm::vec3)> colorFunc,
                              std::function<glm::vec3(glm::vec3)> normalFunc,
                              std::function<uint32_t(uint32_t)> indexFunc) const {
     // vertex data
     const gpu::BufferView& vertexBufferView = getVertexBuffer();
     gpu::BufferView::Index numVertices = (gpu::BufferView::Index)getNumVertices();
+
     gpu::Resource::Size vertexSize = numVertices * sizeof(glm::vec3);
     unsigned char* resultVertexData = new unsigned char[vertexSize];
     unsigned char* vertexDataCursor = resultVertexData;
@@ -151,6 +151,23 @@ model::MeshPointer Mesh::map(std::function<glm::vec3(glm::vec3)> vertexFunc,
         vertexDataCursor += sizeof(pos);
     }
 
+    // color data
+    // static const gpu::Element COLOR_ELEMENT { gpu::VEC4, gpu::NUINT8, gpu::RGBA };
+    // int attributeTypeColor = gpu::Stream::InputSlot::COLOR; // libraries/gpu/src/gpu/Stream.h
+    int attributeTypeColor = gpu::Stream::COLOR;
+    const gpu::BufferView& colorsBufferView = getAttributeBuffer(attributeTypeColor);
+    gpu::BufferView::Index numColors = (gpu::BufferView::Index)colorsBufferView.getNumElements();
+
+    gpu::Resource::Size colorSize = numColors * sizeof(glm::vec3);
+    unsigned char* resultColorData = new unsigned char[colorSize];
+    unsigned char* colorDataCursor = resultColorData;
+
+    for (gpu::BufferView::Index i = 0; i < numColors; i++) {
+        glm::vec3 color = colorFunc(colorsBufferView.get<glm::vec3>(i));
+        memcpy(colorDataCursor, &color, sizeof(color));
+        colorDataCursor += sizeof(color);
+    }
+
     // normal data
     int attributeTypeNormal = gpu::Stream::InputSlot::NORMAL; // libraries/gpu/src/gpu/Stream.h
     const gpu::BufferView& normalsBufferView = getAttributeBuffer(attributeTypeNormal);
@@ -187,6 +204,12 @@ model::MeshPointer Mesh::map(std::function<glm::vec3(glm::vec3)> vertexFunc,
     gpu::BufferView resultVertexBufferView(resultVertexBufferPointer, vertexElement);
     result->setVertexBuffer(resultVertexBufferView);
 
+    gpu::Element colorElement = gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ);
+    gpu::Buffer* resultColorsBuffer = new gpu::Buffer(colorSize, resultColorData);
+    gpu::BufferPointer resultColorsBufferPointer(resultColorsBuffer);
+    gpu::BufferView resultColorsBufferView(resultColorsBufferPointer, colorElement);
+    result->addAttribute(attributeTypeColor, resultColorsBufferView);
+
     gpu::Element normalElement = gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ);
     gpu::Buffer* resultNormalsBuffer = new gpu::Buffer(normalSize, resultNormalData);
     gpu::BufferPointer resultNormalsBufferPointer(resultNormalsBuffer);
@@ -215,6 +238,7 @@ model::MeshPointer Mesh::map(std::function<glm::vec3(glm::vec3)> vertexFunc,
 
 
 void Mesh::forEach(std::function<void(glm::vec3)> vertexFunc,
+                   std::function<void(glm::vec3)> colorFunc,
                    std::function<void(glm::vec3)> normalFunc,
                    std::function<void(uint32_t)> indexFunc) {
     // vertex data
@@ -224,6 +248,15 @@ void Mesh::forEach(std::function<void(glm::vec3)> vertexFunc,
         vertexFunc(vertexBufferView.get<glm::vec3>(i));
     }
 
+    // color data
+    int attributeTypeColor = gpu::Stream::InputSlot::COLOR; // libraries/gpu/src/gpu/Stream.h
+    // int attributeTypeColor = gpu::Stream::COLOR;
+    const gpu::BufferView& colorsBufferView = getAttributeBuffer(attributeTypeColor);
+    gpu::BufferView::Index numColors =  (gpu::BufferView::Index)colorsBufferView.getNumElements();
+    for (gpu::BufferView::Index i = 0; i < numColors; i++) {
+        colorFunc(colorsBufferView.get<glm::vec3>(i));
+    }
+
     // normal data
     int attributeTypeNormal = gpu::Stream::InputSlot::NORMAL; // libraries/gpu/src/gpu/Stream.h
     const gpu::BufferView& normalsBufferView = getAttributeBuffer(attributeTypeNormal);

libraries/model/src/model/Geometry.h

@@ -123,10 +123,12 @@ public:
 
     // create a copy of this mesh after passing its vertices, normals, and indexes though the provided functions
     MeshPointer map(std::function<glm::vec3(glm::vec3)> vertexFunc,
+                    std::function<glm::vec3(glm::vec3)> colorFunc,
                     std::function<glm::vec3(glm::vec3)> normalFunc,
                     std::function<uint32_t(uint32_t)> indexFunc) const;
 
     void forEach(std::function<void(glm::vec3)> vertexFunc,
+                 std::function<void(glm::vec3)> colorFunc,
                  std::function<void(glm::vec3)> normalFunc,
                  std::function<void(uint32_t)> indexFunc);
 

libraries/render-utils/src/Model.cpp

@@ -483,11 +483,13 @@ MeshProxyList Model::getMeshes() {
         }
 
         MeshProxy* meshProxy = new SimpleMeshProxy(
-            mesh->map([=](glm::vec3 position) {
+            mesh->map(
-                return glm::vec3(offsetMat * glm::vec4(position, 1.0f));
+                [=](glm::vec3 position) {
-            },
+                    return glm::vec3(offsetMat * glm::vec4(position, 1.0f));
-            [=](glm::vec3 normal){ return glm::normalize(glm::vec3(offsetMat * glm::vec4(normal, 0.0f))); },
+                },
-            [&](uint32_t index){ return index; }));
+                [=](glm::vec3 color) { return color; },
+                [=](glm::vec3 normal) { return glm::normalize(glm::vec3(offsetMat * glm::vec4(normal, 0.0f))); },
+                [&](uint32_t index) { return index; }));
         result << meshProxy;
     }
 

libraries/script-engine/src/ModelScriptingInterface.cpp

@@ -38,16 +38,22 @@ QString ModelScriptingInterface::meshToOBJ(MeshProxyList in) {
 QScriptValue ModelScriptingInterface::appendMeshes(MeshProxyList in) {
     // figure out the size of the resulting mesh
     size_t totalVertexCount { 0 };
-    size_t totalAttributeCount { 0 };
+    size_t totalColorCount { 0 };
+    size_t totalNormalCount { 0 };
     size_t totalIndexCount { 0 };
     foreach (const MeshProxy* meshProxy, in) {
         MeshPointer mesh = meshProxy->getMeshPointer();
         totalVertexCount += mesh->getNumVertices();
 
+        int attributeTypeColor = gpu::Stream::InputSlot::COLOR; // libraries/gpu/src/gpu/Stream.h
+        const gpu::BufferView& colorsBufferView = mesh->getAttributeBuffer(attributeTypeColor);
+        gpu::BufferView::Index numColors = (gpu::BufferView::Index)colorsBufferView.getNumElements();
+        totalColorCount += numColors;
+
         int attributeTypeNormal = gpu::Stream::InputSlot::NORMAL; // libraries/gpu/src/gpu/Stream.h
         const gpu::BufferView& normalsBufferView = mesh->getAttributeBuffer(attributeTypeNormal);
         gpu::BufferView::Index numNormals = (gpu::BufferView::Index)normalsBufferView.getNumElements();
-        totalAttributeCount += numNormals;
+        totalNormalCount += numNormals;
 
         totalIndexCount += mesh->getNumIndices();
     }
@@ -57,7 +63,11 @@ QScriptValue ModelScriptingInterface::appendMeshes(MeshProxyList in) {
     unsigned char* combinedVertexData  = new unsigned char[combinedVertexSize];
     unsigned char* combinedVertexDataCursor = combinedVertexData;
 
-    gpu::Resource::Size combinedNormalSize = totalAttributeCount * sizeof(glm::vec3);
+    gpu::Resource::Size combinedColorSize = totalColorCount * sizeof(glm::vec3);
+    unsigned char* combinedColorData  = new unsigned char[combinedColorSize];
+    unsigned char* combinedColorDataCursor = combinedColorData;
+
+    gpu::Resource::Size combinedNormalSize = totalNormalCount * sizeof(glm::vec3);
     unsigned char* combinedNormalData  = new unsigned char[combinedNormalSize];
     unsigned char* combinedNormalDataCursor = combinedNormalData;
 
@@ -74,6 +84,10 @@ QScriptValue ModelScriptingInterface::appendMeshes(MeshProxyList in) {
                 memcpy(combinedVertexDataCursor, &position, sizeof(position));
                 combinedVertexDataCursor += sizeof(position);
             },
+            [&](glm::vec3 color){
+                memcpy(combinedColorDataCursor, &color, sizeof(color));
+                combinedColorDataCursor += sizeof(color);
+            },
             [&](glm::vec3 normal){
                 memcpy(combinedNormalDataCursor, &normal, sizeof(normal));
                 combinedNormalDataCursor += sizeof(normal);
@@ -96,6 +110,13 @@ QScriptValue ModelScriptingInterface::appendMeshes(MeshProxyList in) {
     gpu::BufferView combinedVertexBufferView(combinedVertexBufferPointer, vertexElement);
     result->setVertexBuffer(combinedVertexBufferView);
 
+    int attributeTypeColor = gpu::Stream::InputSlot::COLOR; // libraries/gpu/src/gpu/Stream.h
+    gpu::Element colorElement = gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ);
+    gpu::Buffer* combinedColorsBuffer = new gpu::Buffer(combinedColorSize, combinedColorData);
+    gpu::BufferPointer combinedColorsBufferPointer(combinedColorsBuffer);
+    gpu::BufferView combinedColorsBufferView(combinedColorsBufferPointer, colorElement);
+    result->addAttribute(attributeTypeColor, combinedColorsBufferView);
+
     int attributeTypeNormal = gpu::Stream::InputSlot::NORMAL; // libraries/gpu/src/gpu/Stream.h
     gpu::Element normalElement = gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ);
     gpu::Buffer* combinedNormalsBuffer = new gpu::Buffer(combinedNormalSize, combinedNormalData);
@@ -132,6 +153,7 @@ QScriptValue ModelScriptingInterface::transformMesh(glm::mat4 transform, MeshPro
     }
 
     model::MeshPointer result = mesh->map([&](glm::vec3 position){ return glm::vec3(transform * glm::vec4(position, 1.0f)); },
+                                          [&](glm::vec3 color){ return color; },
                                           [&](glm::vec3 normal){ return glm::vec3(transform * glm::vec4(normal, 0.0f)); },
                                           [&](uint32_t index){ return index; });
     MeshProxy* resultProxy = new SimpleMeshProxy(result);