Big bang

src/magnum_render.cpp

@@ -0,0 +1,149 @@
+#include <Corrade/Utility/DebugStl.h>
+#include <Magnum/GL/Framebuffer.h>
+#include <Magnum/GL/Renderer.h>
+#include <Magnum/Math/Color.h>
+#include <Magnum/MeshTools/Compile.h>
+#include <Magnum/Platform/GLContext.h>
+#include <Magnum/Primitives/Cube.h>
+#include <Magnum/Primitives/Grid.h>
+#include <Magnum/Trade/MeshData.h>
+#include "magnum_render.h"
+
+using namespace Magnum;
+using namespace Math::Literals;
+
+static const auto HUE_BG = 210.0_degf;
+static const auto COLOR_BG = Color4::fromHsv({HUE_BG, .3f, .9f}, 1.f);
+static const auto COLOR_GRID = Color4::fromHsv({HUE_BG, .3f, .7f}, 1.f);
+
+MagnumRenderer::MagnumRenderer() {}
+
+MagnumRenderer::~MagnumRenderer() {}
+
+void MagnumRenderer::t(const float t) {
+  if (m_subjectObject != nullptr) {
+    m_subjectObject->resetTransformation();
+    m_subjectObject->translate(Vector3{0.f, 1.f, 0.f});
+    m_subjectObject->rotateY(Rad(t*Math::Constants<float>::pi()));
+  }
+}
+
+void MagnumRenderer::hue(float hue) {
+  if (m_subjectShader.id()) {
+    auto const color = Color3::fromHsv({Rad(hue), 1.f, 1.f});
+    m_subjectShader
+        .setDiffuseColor(color)
+        .setAmbientColor(Color3::fromHsv({color.hue(), 1.0f, 0.3f}));
+  }
+}
+
+void MagnumRenderer::count(int count) {
+  m_count = count;
+}
+
+void MagnumRenderer::lazyInitialize() {
+  if (m_init) return;
+
+  // The Cube
+  {
+    m_subject = MeshTools::compile(Primitives::cubeSolid());
+    m_subjectObject = new Object3D{&m_scene};
+    (*m_subjectObject).translate(Vector3{0.f, 1.f, 0.f});
+
+    m_subjectShader = Shaders::Phong{};
+    m_subjectShader
+      .setShininess(20.f)
+      .setLightColor(Color3{1.f})
+      .setLightPosition(Vector3{-100.f, 100.f, 50.f});
+
+    new SubjectDrawable{*m_subjectObject, m_subjectShader, m_subject, m_drawables};
+  }
+
+  // The Grid
+  {
+    m_grid = MeshTools::compile(Primitives::grid3DWireframe({15, 15}));
+    auto obj = new Object3D{&m_scene};
+    (*obj).rotateX(90.0_degf).scale(Vector3{8.0f});
+
+    m_gridShader = Shaders::Flat3D{};
+    m_gridShader.setColor(COLOR_GRID);
+
+    new GridDrawable{*obj, m_gridShader, m_grid, m_drawables};
+  }
+
+  // The Camera
+  {
+    const Vector3 eye{-10.0f, 8.f, -6.f};
+    const Vector3 center{0.f, 1.f, 0.f};
+    const Vector3 up = Vector3::yAxis();
+    m_camera.emplace(m_scene, eye, center, up,  45.0_degf,
+                     Vector2i{100, 100}, Vector2i{100, 100});
+  }
+
+  m_init = true;
+}
+
+void MagnumRenderer::reset(Platform::GLContext *ctx,
+                           GL::Framebuffer fbo,
+                           Vector2i windowSize,
+                           Vector2i viewportSize) {
+  lazyInitialize();
+  m_camera->reshape(windowSize, viewportSize);
+  m_FBO = std::move(fbo);
+  m_ctx = ctx;
+}
+
+void MagnumRenderer::prepGLState() {
+  GL::Renderer::setClearColor(COLOR_BG);
+  GL::Renderer::enable(GL::Renderer::Feature::DepthTest);
+  GL::Renderer::enable(GL::Renderer::Feature::FaceCulling);
+  GL::Renderer::enable(GL::Renderer::Feature::Multisampling);
+
+  GL::Renderer::setDepthFunction(GL::Renderer::DepthFunction::LessOrEqual);
+  GL::Renderer::setBlendEquation(GL::Renderer::BlendEquation::Add,
+                                 GL::Renderer::BlendEquation::Add);
+  GL::Renderer::setBlendFunction(
+      GL::Renderer::BlendFunction::One,
+      GL::Renderer::BlendFunction::OneMinusSourceAlpha);
+  GL::Renderer::enable(GL::Renderer::Feature::Blending);
+}
+
+void MagnumRenderer::render() {
+  m_ctx->resetState(GL::Context::State::ExitExternal);
+  prepGLState();
+  // ---
+
+  m_FBO.bind();
+  m_FBO.clear(GL::FramebufferClear::Color |
+              GL::FramebufferClear::Depth);
+
+  m_camera->update();
+  m_camera->draw(m_drawables);
+
+  /** Use instead this to limit rendering to camera changes
+   *  bool cameraChanged = m_camera->update();
+   *  m_camera->draw(m_drawables);
+   *  if (cameraChanged) {
+   *    redraw();
+   *  } */
+
+  // ---
+  m_ctx->resetState(GL::Context::State::EnterExternal);
+}
+
+void GridDrawable::draw(const Matrix4 &transformation,
+                        SceneGraph::Camera3D &camera) {
+  m_shader
+      .setTransformationProjectionMatrix(
+        camera.projectionMatrix()*transformation)
+      .draw(m_mesh);
+}
+
+void SubjectDrawable::draw(const Matrix4 &transformation,
+                           SceneGraph::Camera3D &camera) {
+  m_shader
+      .setTransformationMatrix(transformation)
+      .setNormalMatrix(transformation.normalMatrix())
+      .setProjectionMatrix(camera.projectionMatrix())
+      .draw(m_mesh);
+}