feat: add cgal and viewport smooth normals

src/Engine/Operator/Geometry.cpp

@@ -3,7 +3,9 @@
 #include "Engine/Operator/AttributeHandle.h"
 #include "Engine/Types.h"
 #include <memory>
+#include <oneapi/tbb/task_group.h>
 #include <stdexcept>
+#include "icecream.hpp"
 
 using namespace enzo;
 geo::Geometry::Geometry()
@@ -13,6 +15,58 @@ geo::Geometry::Geometry()
     addIntAttribute(ga::AttrOwner::PRIMITIVE, "vertexCount");
 }
 
+enzo::geo::HeMesh geo::Geometry::computeHalfEdgeMesh()
+{
+    HeMesh heMesh;
+
+    std::shared_ptr<enzo::ga::Attribute> PAttr = getAttribByName(enzo::ga::AttrOwner::POINT, "P");
+    enzo::ga::AttributeHandleVector3 PAttrHandle = enzo::ga::AttributeHandleVector3(PAttr);
+    auto pointPositions = PAttrHandle.getAllValues();
+    
+    std::shared_ptr<enzo::ga::Attribute> pointAttr = getAttribByName(enzo::ga::AttrOwner::VERTEX, "point");
+    enzo::ga::AttributeHandleInt pointAttrHandle = enzo::ga::AttributeHandleInt(pointAttr);
+    auto vertexPointIndices = pointAttrHandle.getAllValues();
+
+    std::shared_ptr<enzo::ga::Attribute> vertexCountAttr = getAttribByName(enzo::ga::AttrOwner::PRIMITIVE, "vertexCount");
+    enzo::ga::AttributeHandleInt vertexCountHandle = enzo::ga::AttributeHandleInt(vertexCountAttr);
+    auto vertexCounts = vertexCountHandle.getAllValues();
+
+    int vertexIndex = 0;
+    std::vector<geo::vertexDescriptor> createdPoints;
+    createdPoints.reserve(pointPositions.size());
+    std::vector<geo::vertexDescriptor> facePoints;
+    facePoints.reserve(16);
+
+    for(auto pointPos : pointPositions)
+    {
+        enzo::geo::vertexDescriptor point = heMesh.add_vertex(geo::Point(pointPos.x(), pointPos.y(), pointPos.z()));
+        createdPoints.push_back(point);
+    }
+
+    // iterate through each prim
+    for(int primIndx=0; primIndx<vertexCounts.size(); ++primIndx)
+    {
+        facePoints.clear();
+
+        // represents how many vertices are in a primitive
+        auto vertexCount = vertexCounts[primIndx];
+
+        // create primtive vertices
+        for(int i=0; i<vertexCount; ++i)
+        {
+            auto pointIndex = vertexPointIndices.at(vertexIndex);
+            facePoints.push_back(createdPoints[pointIndex]);
+            ++vertexIndex;
+        }
+
+        heMesh.add_face(facePoints);
+    }
+
+
+    return heMesh;
+}
+
+
 ga::AttributeHandle<int> geo::Geometry::addIntAttribute(ga::AttributeOwner owner, std::string name)
 {
     auto newAttribute = std::make_shared<ga::Attribute>(name, ga::AttrType::intT);

src/Engine/Operator/Geometry.h

@@ -1,10 +1,23 @@
 #pragma once
 #include "Engine/Operator/Attribute.h"
 #include "Engine/Types.h"
+#include <CGAL/Surface_mesh/Surface_mesh.h>
+#include <CGAL/Simple_cartesian.h>
 #include <variant>
 
+
+
 namespace enzo::geo
 {
+using Kernel = CGAL::Simple_cartesian<double>;
+using Point  = Kernel::Point_3;
+using Vector   = Kernel::Vector_3;
+using HeMesh      = CGAL::Surface_mesh<Point>;
+using vertexDescriptor = HeMesh::Vertex_index;
+using faceDescriptor = HeMesh::Face_index;
+using V_index  = HeMesh::Vertex_index;
+using F_index  = HeMesh::Face_index;
+
 class Geometry
 {
 public:
@@ -12,6 +25,8 @@ public:
     ga::AttributeHandle<int> addIntAttribute(ga::AttributeOwner owner, std::string name);
     ga::AttributeHandle<bt::Vector3> addVector3Attribute(ga::AttributeOwner owner, std::string name);
     std::shared_ptr<ga::Attribute> getAttribByName(ga::AttributeOwner owner, std::string name);
+    std::vector<bt::Vector3> derivePointNormals();
+    HeMesh computeHalfEdgeMesh();
 private:
     using attribVector = std::vector<std::shared_ptr<ga::Attribute>>;
     attribVector& getAttributeStore(ga::AttributeOwner& owner);

src/Gui/Viewport/GLMesh.cpp

@@ -2,6 +2,8 @@
 #include <GL/gl.h>
 #include <iostream>
 #include "Engine/Operator/AttributeHandle.h"
+#include "Engine/Operator/Geometry.h"
+#include <CGAL/Polygon_mesh_processing/compute_normal.h>
 
 
 
@@ -55,14 +57,34 @@ void GLMesh::setPosBuffer(enzo::geo::Geometry& geometry)
     glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
     vertices.clear();
 
-    std::shared_ptr<enzo::ga::Attribute> PAttr = geometry.getAttribByName(enzo::ga::AttrOwner::POINT, "P");
-    enzo::ga::AttributeHandleVector3 PAttrHandle = enzo::ga::AttributeHandleVector3(PAttr);
-    auto pointPositions = PAttrHandle.getAllValues();
+    enzo::geo::HeMesh heMesh = geometry.computeHalfEdgeMesh();
 
-    for(auto position : pointPositions)
+    // compute mesh normals
+    auto vnormals = heMesh.add_property_map<enzo::geo::V_index, enzo::geo::Vector>("v:normals", CGAL::NULL_VECTOR).first;
+    auto fnormals = heMesh.add_property_map<enzo::geo::F_index, enzo::geo::Vector>("f:normals", CGAL::NULL_VECTOR).first;
+    namespace PMP = CGAL::Polygon_mesh_processing;
+
+    PMP::compute_normals(
+      heMesh, 
+      vnormals,
+      fnormals,
+      PMP::parameters::vertex_point_map(heMesh.points())
+    );
+
+
+    for (enzo::geo::V_index v : heMesh.vertices())
     {
-        vertices.push_back({{position.x(), position.y(), position.z()}, {position.x(), position.y(), position.z()}});
-        std::cout << position.x() << " " << position.y() << " " << position.z() << "\n";
+        const enzo::geo::Point  &p = heMesh.point(v);
+        const enzo::geo::Vector &n = vnormals[v];
+
+        vertices.push_back({
+            { p.x(),
+              p.y(),
+              p.z()},
+            { n.x(),
+              n.y(),
+              n.z()}
+        });
     }
 
     glBufferData(GL_ARRAY_BUFFER, vertices.size()*sizeof(Vertex), vertices.data(), GL_STATIC_DRAW);

src/Gui/Viewport/ViewportGLWidget.cpp

@@ -85,12 +85,21 @@ void ViewportGLWidget::initializeGL()
     #version 330 core
     in vec3 Normal;
 
-    out vec4 FragColor;
+    out vec4 color;
+
+    float remap(float value, float inMin, float inMax, float outMin, float outMax)
+    {
+        return outMin + (outMax - outMin) * (value - inMin) / (inMax - inMin);
+    }
 
     void main()
     {
         // FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);
-        FragColor = vec4(Normal, 1.0f);
+        // FragColor = vec4(Normal, 1.0f);
+        vec3 lightDir = normalize(vec3(1.0,1.0,1.0));
+        float brightness = remap(dot(Normal, lightDir), -1, 1, 0.5, 1);
+        color = vec4(vec3(brightness), 1.0f);
+
     }
     )";
     GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);