fix: dont calculate surface orientation for non-triangle geometry

thermion_dart/native/src/CustomGeometry.cpp

@@ -1,28 +1,24 @@
-#include <vector> 
 #include "math.h"
 #include <filament/Engine.h>
-#include <filament/TransformManager.h>
-#include <filament/Texture.h>
-#include <filament/RenderableManager.h>
-#include <filament/Viewport.h>
 #include <filament/Frustum.h>
+#include <filament/RenderableManager.h>
+#include <filament/Texture.h>
+#include <filament/TransformManager.h>
+#include <filament/Viewport.h>
 #include <filament/geometry/SurfaceOrientation.h>
+#include <vector>
 
-#include "Log.hpp"
 #include "CustomGeometry.hpp"
+#include "Log.hpp"
+
 
 namespace thermion {
 
 using namespace filament;
 
-CustomGeometry::CustomGeometry(
+CustomGeometry::CustomGeometry(float *vertices, uint32_t numVertices,
-    float* vertices, 
+                               float *normals, uint32_t numNormals, float *uvs,
-    uint32_t numVertices, 
+                               uint32_t numUvs, uint16_t *indices,
-    float* normals,
-    uint32_t numNormals,
-    float* uvs,
-    uint32_t numUvs,
-    uint16_t* indices, 
                                uint32_t numIndices,
                                RenderableManager::PrimitiveType primitiveType,
                                Engine *engine)
@@ -32,15 +28,11 @@ CustomGeometry::CustomGeometry(
   std::memcpy(this->vertices, vertices, numVertices * sizeof(float));
 
   if (numNormals > 0) {
-        Log("numNormals %d", numNormals);
     this->normals = new float[numNormals];
     std::memcpy(this->normals, normals, numNormals * sizeof(float));
-    } else { 
-        Log("no normals");
   }
 
   if (numUvs > 0) {
-        Log("numUvs %d", numUvs);
     this->uvs = new float[numUvs];
     std::memcpy(this->uvs, uvs, numUvs * sizeof(float));
   } else {
@@ -55,8 +47,7 @@ CustomGeometry::CustomGeometry(
 
 IndexBuffer *CustomGeometry::indexBuffer() const {
   IndexBuffer::BufferDescriptor::Callback indexCallback = [](void *buf, size_t,
-                                                               void *data)
+                                                             void *data) {
-    {
     //   free((void *)buf);
   };
 
@@ -65,18 +56,96 @@ IndexBuffer* CustomGeometry::indexBuffer() const {
                          .bufferType(IndexBuffer::IndexType::USHORT)
                          .build(*_engine);
 
-    indexBuffer->setBuffer(*_engine, IndexBuffer::BufferDescriptor(
+  indexBuffer->setBuffer(*_engine,
-        this->indices, indexBuffer->getIndexCount() * sizeof(uint16_t), indexCallback));
+                         IndexBuffer::BufferDescriptor(
+                             this->indices,
+                             indexBuffer->getIndexCount() * sizeof(uint16_t),
+                             indexCallback));
   return indexBuffer;
 }
 
 VertexBuffer *CustomGeometry::vertexBuffer() const {
-    VertexBuffer::BufferDescriptor::Callback vertexCallback = [](void *buf, size_t,
+  VertexBuffer::BufferDescriptor::Callback vertexCallback =
-                                                                 void *data)
+      [](void *buf, size_t, void *data) {
-    {
         //   free((void *)buf);
       };
 
+  // Use provided UVs or create dummy UV data
+  std::vector<filament::math::float2> *uvData;
+  if (this->uvs != nullptr) {
+    uvData = new std::vector<filament::math::float2>(
+        (filament::math::float2 *)this->uvs,
+        (filament::math::float2 *)(this->uvs + numVertices * 2));
+  } else {
+    uvData = new std::vector<filament::math::float2>(
+        numVertices, filament::math::float2{0.0f, 0.0f});
+  }
+
+  // Create dummy vertex color data (white color for all vertices)
+  auto dummyColors = new std::vector<filament::math::float4>(
+      numVertices, filament::math::float4{1.0f, 1.0f, 1.0f, 1.0f});
+
+  auto vertexBufferBuilder =
+      VertexBuffer::Builder()
+          .vertexCount(numVertices)
+          .attribute(VertexAttribute::POSITION, 0,
+                     VertexBuffer::AttributeType::FLOAT3)
+          .attribute(VertexAttribute::UV0, 1,
+                     VertexBuffer::AttributeType::FLOAT2)
+          .attribute(VertexAttribute::UV1, 2,
+                     VertexBuffer::AttributeType::FLOAT2)
+          .attribute(VertexAttribute::COLOR, 3,
+                     VertexBuffer::AttributeType::FLOAT4);
+
+  if (this->normals) {
+    vertexBufferBuilder.bufferCount(5).attribute(
+        VertexAttribute::TANGENTS, 4,
+        filament::VertexBuffer::AttributeType::FLOAT4);
+  } else {
+    vertexBufferBuilder = vertexBufferBuilder.bufferCount(4);
+  }
+  auto vertexBuffer = vertexBufferBuilder.build(*_engine);
+
+  vertexBuffer->setBufferAt(
+      *_engine, 0,
+      VertexBuffer::BufferDescriptor(
+          this->vertices, vertexBuffer->getVertexCount() * sizeof(math::float3),
+          vertexCallback));
+
+  // Set UV0 buffer
+  vertexBuffer->setBufferAt(
+      *_engine, 1,
+      VertexBuffer::BufferDescriptor(
+          uvData->data(), uvData->size() * sizeof(math::float2),
+          [](void *buf, size_t, void *data) {
+            delete static_cast<std::vector<math::float2> *>(data);
+          },
+          uvData));
+
+  // Set UV1 buffer (reusing UV0 data)
+  vertexBuffer->setBufferAt(*_engine, 2,
+                            VertexBuffer::BufferDescriptor(
+                                uvData->data(),
+                                uvData->size() * sizeof(math::float2),
+                                [](void *buf, size_t, void *data) {
+                                  // Do nothing here, as we're reusing the same
+                                  // data as UV0
+                                },
+                                nullptr));
+
+  // Set vertex color buffer
+  vertexBuffer->setBufferAt(
+      *_engine, 3,
+      VertexBuffer::BufferDescriptor(
+          dummyColors->data(), dummyColors->size() * sizeof(math::float4),
+          [](void *buf, size_t, void *data) {
+            delete static_cast<std::vector<math::float4> *>(data);
+          },
+          dummyColors));
+
+  if (this->normals) {
+
+    assert(this->primitiveType == RenderableManager::PrimitiveType::TRIANGLES);
     std::vector<filament::math::ushort3> triangles;
     for (int i = 0; i < numIndices; i += 3) {
       filament::math::ushort3 triangle;
@@ -101,65 +170,14 @@ VertexBuffer* CustomGeometry::vertexBuffer() const {
     auto quats = new std::vector<filament::math::quatf>(numVertices);
     orientation->getQuats(quats->data(), numVertices);
 
-    // Use provided UVs or create dummy UV data
+    vertexBuffer->setBufferAt(*_engine, 4,
-    std::vector<filament::math::float2>* uvData;
+                              VertexBuffer::BufferDescriptor(
-    if (this->uvs != nullptr) {
+                                  quats->data(),
-        uvData = new std::vector<filament::math::float2>((filament::math::float2*)this->uvs, (filament::math::float2*)(this->uvs + numVertices * 2));
+                                  quats->size() * sizeof(math::quatf),
-    } else {
-        uvData = new std::vector<filament::math::float2>(numVertices, filament::math::float2{0.0f, 0.0f});
-    }
-
-    // Create dummy vertex color data (white color for all vertices)
-    auto dummyColors = new std::vector<filament::math::float4>(numVertices, filament::math::float4{1.0f, 1.0f, 1.0f, 1.0f});
-
-    auto vertexBufferBuilder = VertexBuffer::Builder()
-        .vertexCount(numVertices)
-        .attribute(VertexAttribute::POSITION, 0, VertexBuffer::AttributeType::FLOAT3)
-        .attribute(VertexAttribute::UV0, 1, VertexBuffer::AttributeType::FLOAT2)
-        .attribute(VertexAttribute::UV1, 2, VertexBuffer::AttributeType::FLOAT2)
-        .attribute(VertexAttribute::COLOR, 3, VertexBuffer::AttributeType::FLOAT4);
-   
-    if(this->normals) {
-        vertexBufferBuilder
-            .bufferCount(5)
-            .attribute(VertexAttribute::TANGENTS, 4, filament::VertexBuffer::AttributeType::FLOAT4);
-    } else {
-        vertexBufferBuilder = vertexBufferBuilder.bufferCount(4);
-    }
-    auto vertexBuffer = vertexBufferBuilder
-        .build(*_engine);
-
-    vertexBuffer->setBufferAt(*_engine, 0, VertexBuffer::BufferDescriptor(
-        this->vertices, vertexBuffer->getVertexCount() * sizeof(math::float3), vertexCallback));
-
-    // Set UV0 buffer
-    vertexBuffer->setBufferAt(*_engine, 1, VertexBuffer::BufferDescriptor(
-        uvData->data(), uvData->size() * sizeof(math::float2), 
                                   [](void *buf, size_t, void *data) {
-            delete static_cast<std::vector<math::float2>*>(data);
-        }, uvData));
-
-    // Set UV1 buffer (reusing UV0 data)
-    vertexBuffer->setBufferAt(*_engine, 2, VertexBuffer::BufferDescriptor(
-        uvData->data(), uvData->size() * sizeof(math::float2), 
-        [](void* buf, size_t, void* data) {
-            // Do nothing here, as we're reusing the same data as UV0
-        }, nullptr));
-
-    // Set vertex color buffer
-    vertexBuffer->setBufferAt(*_engine, 3, VertexBuffer::BufferDescriptor(
-        dummyColors->data(), dummyColors->size() * sizeof(math::float4),
-        [](void* buf, size_t, void* data) {
-            delete static_cast<std::vector<math::float4>*>(data);
-        }, dummyColors));
-    
-    if(this->normals) {
-        vertexBuffer->setBufferAt(*_engine, 4, VertexBuffer::BufferDescriptor(
-            quats->data(), quats->size() * sizeof(math::quatf), [] (void *buf, size_t,
-                                                                    void *data)
-        {
                                     delete (std::vector<math::quatf> *)data;
-        }, (void*)quats));
+                                  },
+                                  (void *)quats));
   }
   return vertexBuffer;
 }
@@ -167,8 +185,10 @@ VertexBuffer* CustomGeometry::vertexBuffer() const {
 CustomGeometry::~CustomGeometry() {
   delete[] vertices;
   delete[] indices;
-    if (normals) delete[] normals;
+  if (normals)
-    if (uvs) delete[] uvs;
+    delete[] normals;
+  if (uvs)
+    delete[] uvs;
 }
 
 void CustomGeometry::computeBoundingBox() {
@@ -187,8 +207,6 @@ void CustomGeometry::computeBoundingBox() {
   boundingBox = Box{{minX, minY, minZ}, {maxX, maxY, maxZ}};
 }
 
-Box CustomGeometry::getBoundingBox() const {
+Box CustomGeometry::getBoundingBox() const { return boundingBox; }
-    return boundingBox;
-}
 
-}
+} // namespace thermion