Basic viewer and gl renderer

Author: Diego Jesus

conanfile.py

@@ -49,6 +49,7 @@ def requirements(self):
         self.requires("magic_enum/0.9.5")
         self.requires("imgui/cci.20220621+1.88.docking")
         self.requires("glfw/3.3.8")
+        self.requires("glew/2.2.0")
 
 
     def _configure_cmake(self):

src/bin/CMakeLists.txt

@@ -3,3 +3,9 @@ add_pagoda_executable(
   SOURCES     "pagoda.cpp"
   DEPENDENCIES Boost::program_options
 )
+
+add_pagoda_executable(
+  NAME        pgeditor
+  SOURCES     "pgeditor.cpp"
+  DEPENDENCIES pgframes Boost::program_options
+)

src/bin/pgeditor.cpp

@@ -22,7 +22,11 @@ class PagodaEditor {
     }
 
     instance.LoadAllPlugins();
+#ifdef PAGODA_OS_MACOS
     m_platform = pgframes::PlatformWindow::Get("metal");
+#else
+    m_platform = pgframes::PlatformWindow::Get("opengl3");
+#endif
     if (m_platform == nullptr) {
       LOG_ERROR("Unable to create platform window");
       return;
@@ -33,7 +37,8 @@ class PagodaEditor {
 
     m_platform->Startup();
 
-    m_windowManager->CreateWindow("WindowBrowser");
+    m_windowManager->CreateWindow("GraphEditor");
+    m_windowManager->CreateWindow("ViewerWindow");
 
     m_platform->RunMainLoop();
 
@@ -48,11 +53,9 @@ class PagodaEditor {
 int main(int argc, char *argv[]) {
   PagodaEditor p;
   p.ProcessArgs(argc, argv);
-  /*
   if (!p.Init()) {
     return 1;
   }
-  */
   p.Run();
   return 0;
 }

src/pagoda/scene/CMakeLists.txt

@@ -1,16 +1,14 @@
 set(SCENE_SRCS
   "camera.cpp"
-  "camera.h"
   "lens.cpp"
-  "lens.h"
   "path.cpp"
-  "path.h"
-  "scene_graph.h"
+  "render_target.cpp"
   "scene_graph.cpp"
-  "scene_node.h"
   "scene_node.cpp"
   "transformation.cpp"
-  "transformation.h"
+  "geometry.cpp"
+  "mesh.cpp"
+  "lines.cpp"
 )
 
 add_pagoda_module(

src/pagoda/scene/camera.cpp

@@ -2,6 +2,7 @@
 #include "transformation.h"
 
 #include <pagoda/common/instrument/profiler.h>
+#include <pagoda/math/degrees.h>
 
 #include <boost/qvm/gen/vec_operations2.hpp>
 #include <boost/qvm/gen/vec_operations4.hpp>
@@ -20,39 +21,9 @@ using namespace pagoda::math;
 
 using namespace boost;
 
-namespace pagoda::scene
-{
-Camera::Camera()
-  : m_position{0, 0, 0}, m_viewDirection{0, 0, -1}, m_viewMatrix(qvm::identity_mat<float, 4>()), m_viewMatrixDirty(true)
-{
-}
-
-void Camera::SetPosition(const math::Vec3F &pos)
-{
-	if (m_position != pos) {
-		m_position = pos;
-		m_viewMatrixDirty = true;
-	}
-}
-
-void Camera::SetViewDirection(const math::Vec3F &dir)
-{
-	DBG_ASSERT(qvm::mag_sqr(dir) > 0);
-	if (m_viewDirection != dir) {
-		m_viewDirection = qvm::normalized(dir);
-		m_viewMatrixDirty = true;
-	}
-}
-
-void Camera::SetTransformation(const Transformation &t)
-{
-	SetPosition(t.GetPosition());
-	SetViewDirection(t.GetFrontDirection());
-}
-
-void Camera::SetLens(const Lens &lens) { m_lens = lens; }
-Lens &Camera::GetLens() { return m_lens; }
+namespace pagoda::scene {
 
+namespace {
 template<typename T>
 qvm::mat<T, 4, 4> look_at(const qvm::vec<T, 3> &eye, const qvm::vec<T, 3> &target, const qvm::vec<T, 3> &upDirection)
 {
@@ -74,28 +45,54 @@ qvm::mat<T, 4, 4> look_at(const qvm::vec<T, 3> &eye, const qvm::vec<T, 3> &targe
 
 	return mat * translation_mat(-eye);
 }
+}
 
-const math::Vec3F &Camera::GetPosition() const { return m_position; }
-
-const math::Vec3F &Camera::GetViewDirection() const { return m_viewDirection; }
-math::Vec3F Camera::GetRightVector() const
+Camera::Camera()
 {
-	return normalized(qvm::cross(Transformation::upVector, GetViewDirection()));
+  m_viewMatrix = qvm::identity_mat<float, 4>();
 }
-math::Vec3F Camera::GetUpVector() const { return normalized(qvm::cross(GetViewDirection(), GetRightVector())); }
 
-const math::Mat4x4F &Camera::GetViewMatrix()
+void Camera::SetPosition(const math::Vec3F &pos) {
+  m_position = pos;
+}
+
+void Camera::SetTarget(const math::Vec3F &target) {
+  m_target = target;
+}
+
+const math::Vec3F& Camera::GetTarget() const { return m_target; }
+
+math::Vec3F Camera::GetViewDirection() const {
+  return XYZ(row<2>(m_viewMatrix));
+}
+
+math::Vec3F Camera::GetRightVector() const {
+  return XYZ(row<0>(m_viewMatrix));
+}
+
+math::Vec3F Camera::GetUpVector() const {
+  return XYZ(row<1>(m_viewMatrix));
+}
+
+void Camera::SetCameraView(const math::Vec3F& eye, const math::Vec3F& lookat)
 {
-	START_PROFILE;
+  m_position = eye;
+  m_target = lookat;
+}
 
-	if (m_viewMatrixDirty) {
-		math::Vec3F target = m_position + m_viewDirection;
-		m_viewMatrix = look_at(m_position, target, Transformation::upVector);
-		m_viewMatrixDirty = false;
-	}
+void Camera::SetLens(const Lens &lens) { m_lens = lens; }
+Lens &Camera::GetLens() { return m_lens; }
+
+math::Vec3F Camera::GetPosition() const {
+  return m_position;
+}
+
+math::Mat4x4F Camera::GetViewMatrix()
+{
+  m_viewMatrix = look_at(m_position, m_target, Transformation::upVector);
 	return m_viewMatrix;
 }
 
 const math::Mat4x4F &Camera::GetProjectionMatrix() { return m_lens.GetProjectionMatrix(); }
 
-}  // namespace pagoda::scene
+} // namespace pagoda::scene

src/pagoda/scene/camera.h

@@ -1,39 +1,54 @@
 #pragma once
 
 #include "lens.h"
-#include "transformation.h"
 
 #include <pagoda/math/matrix_base.h>
 #include <pagoda/math/vec_base.h>
 
 namespace pagoda::scene
 {
-class Camera final
+//! Represents a Camera in the 3D scene.
+class Camera
 {
-	public:
-	Camera();
-
-	void SetPosition(const boost::qvm::vec<float, 3> &pos);
-	void SetViewDirection(const boost::qvm::vec<float, 3> &dir);
-	void SetTransformation(const Transformation &t);
-
-	const math::Vec3F &GetPosition() const;
-	const math::Vec3F &GetViewDirection() const;
-	math::Vec3F GetRightVector() const;
-	math::Vec3F GetUpVector() const;
-
-	const math::Mat4x4F &GetViewMatrix();
-	const math::Mat4x4F &GetProjectionMatrix();
-
-	void SetLens(const Lens &lens);
-	Lens &GetLens();
-
-	private:
-	pagoda::math::Vec3F m_position;
-	pagoda::math::Vec3F m_viewDirection;
-
-	pagoda::math::Mat4x4F m_viewMatrix;
-	Lens m_lens;
-	bool m_viewMatrixDirty;
+public:
+  //! Constructs a camera in the origin of coordinates, looking towards
+  //! the negative z-axis.
+  Camera();
+
+  //! Sets the camera position.
+  void SetPosition(const math::Vec3F &pos);
+  //! Sets to where the camera is looking
+  void SetTarget(const math::Vec3F &target);
+  //! Returns the camera target.
+  const math::Vec3F& GetTarget() const;
+
+  //! Returns the camera position.
+  math::Vec3F GetPosition() const;
+  //! Returns the camera view direction.
+  math::Vec3F GetViewDirection() const;
+  //! Returns the camera right direction.
+  math::Vec3F GetRightVector() const;
+  //! Returns the camera up direction.
+  math::Vec3F GetUpVector() const;
+
+  void SetCameraView(const math::Vec3F& eye, const math::Vec3F& lookat);
+
+  //! Returns the view matrix.
+  math::Mat4x4F GetViewMatrix();
+  //! Returns the projection matrix which is provided by the Lens.
+  const math::Mat4x4F &GetProjectionMatrix();
+
+  //! Sets the camera Lens.
+  void SetLens(const Lens &lens);
+  //! Returns the camera Lens.
+  Lens &GetLens();
+
+private:
+  math::Vec3F m_position;       //< The camera position.
+  math::Vec3F m_target;         //< Where the camera is looking at.
+  math::Mat4x4F m_viewMatrix;   //< The view matrix.
+	Lens m_lens;                  //< The camera Lens.
 };
+
+using CameraPtr = std::shared_ptr<Camera>;
 }  // namespace pagoda::scene

src/pagoda/scene/geometry.cpp

@@ -0,0 +1,23 @@
+#include "geometry.h"
+
+namespace pagoda::scene
+{
+Geometry::Geometry(const std::vector<math::Vec3F>& verts,
+                   const std::vector<uint32_t>& indices)
+  : m_vertices{verts}
+  , m_indices{indices}
+{
+}
+
+const std::vector<math::Vec3F>& Geometry::GetVertices() const { return m_vertices; }
+const std::vector<uint32_t>& Geometry::GetIndices() const { return m_indices; }
+
+void Geometry::SetVertexColors(const std::vector<math::Vec4F>& colors) { m_vertexColors = colors; }
+const std::vector<math::Vec4F>& Geometry::GetVertexColors() {
+  if (m_vertexColors.empty()) {
+    m_vertexColors.resize(m_vertices.size());
+    std::fill(m_vertexColors.begin(), m_vertexColors.end(), math::Vec4F{0.18, 0.18, 0.18, 1.0});
+  }
+  return m_vertexColors;
+}
+}

src/pagoda/scene/geometry.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "pagoda/math/vec_base.h"
+#include "pagoda/scene/scene_node.h"
+
+namespace pagoda::scene
+{
+class Geometry : public SceneNode {
+public:
+  enum class PrimitiveType {
+    Triangles,
+    Lines,
+    LineStrip,
+    LineLoop
+  };
+
+  Geometry(const std::vector<math::Vec3F>& verts,
+           const std::vector<uint32_t>& indices);
+  ~Geometry() override = default;
+
+  const std::vector<math::Vec3F>& GetVertices() const;
+  const std::vector<uint32_t>& GetIndices() const;
+
+  void SetVertexColors(const std::vector<math::Vec4F>& colors);
+  const std::vector<math::Vec4F>& GetVertexColors();
+
+  virtual PrimitiveType GetPrimitiveType() const = 0;
+
+protected:
+  std::vector<math::Vec3F> m_vertices;
+  std::vector<uint32_t> m_indices;
+  std::vector<math::Vec4F> m_vertexColors;
+};
+}

src/pagoda/scene/lens.cpp

@@ -1,5 +1,7 @@
 #include "lens.h"
 
+#include "pagoda/math/degrees.h"
+#include "pagoda/math/radians.h"
 #include <pagoda/math/vec_base.h>
 
 #include <boost/qvm/map_mat_vec.hpp>
@@ -17,7 +19,10 @@ Lens::Lens() : m_projectionMatrix(qvm::diag_mat(boost::qvm::vec<float, 4>{1, 1,
 
 void Lens::SetPerspective(float fovY, float aspect, float near, float far)
 {
-	m_projectionMatrix = qvm::perspective_rh(fovY, aspect, near, far);
+  const math::Degrees<float> fovInDegrees(fovY);
+  const math::Radians<float> fovInRadians(fovInDegrees);
+	m_projectionMatrix = qvm::perspective_rh(
+      static_cast<float>(fovInRadians), aspect, near, far);
 }
 
 void Lens::SetOrthogonal(float left, float right, float top, float bottom)

src/pagoda/scene/lines.cpp

@@ -0,0 +1,20 @@
+#include "lines.h"
+
+namespace pagoda::scene {
+  namespace {
+    std::vector<uint32_t> computeIndices(const std::vector<math::Vec3F>& verts) {
+      std::vector<uint32_t> indices;
+      indices.reserve(verts.size());
+      for (uint32_t i = 0; i < verts.size(); /**/) {
+        indices.push_back(i++);
+        indices.push_back(i++);
+      }
+      return indices;
+    }
+  }
+
+  Lines::Lines(const std::vector<math::Vec3F>& linePoints)
+    : Geometry(linePoints, computeIndices(linePoints))
+  {
+  }
+}

src/pagoda/scene/lines.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "pagoda/math/vec_base.h"
+#include "pagoda/scene/geometry.h"
+
+#include <vector>
+
+namespace pagoda::scene {
+class Lines : public Geometry {
+public:
+  Lines(const std::vector<math::Vec3F>& linePoints);
+
+  PrimitiveType GetPrimitiveType() const override { return PrimitiveType::Lines; }
+};
+}

src/pagoda/scene/mesh.cpp

@@ -0,0 +1,9 @@
+#include "mesh.h"
+
+namespace pagoda::scene {
+
+Mesh::Mesh(const std::vector<math::Vec3F>& verts, const std::vector<uint32_t>& indices)
+  : Geometry(verts, indices)
+  {
+  }
+}