Fix viewer source codes.

example/pathtracing_example.cc

@@ -39,7 +39,7 @@ int main(int argc, char **argv) {
     // std::shared_ptr<Sampler> sampler = std::make_unique<Random>(0);
     std::shared_ptr<Sampler> sampler = std::make_unique<Halton>(200, true, 0);
 
-    cornellBox(&scene, nullptr, 0, 0);
+    cornellBox(&scene);
 
     Timer timer;
     timer.start();

example/sppm_example.cc

@@ -37,7 +37,7 @@ int main(int argc, char** argv) {
 
     std::shared_ptr<Sampler> sampler = std::make_unique<Random>(0);
 
-    cornellBox(&scene, nullptr, 0, 0);
+    cornellBox(&scene);
     // kittenBox(&scene, &camera, width, height);
     // kittenEnvmap(&scene, &camera, width, height);
 

include/spica.h

@@ -99,4 +99,10 @@
 #include "../sources/scenes/yaml_parser.h"
 #include "../sources/scenes/scene_loader.h"
 
+// --------------------------------------------
+// Viewer
+// --------------------------------------------
+
+#include "../sources/viewer/vbo.h"
+
 #endif  // _SPICA_H_

sources/camera/camera.h

@@ -30,6 +30,8 @@ class SPICA_EXPORTS Camera {
                          double* pdfDir = nullptr) const = 0;
 
     inline Film* film() const { return film_; }
+    inline const Transform& cameraToWorld() const { return cameraToWorld_; }
+    inline const Transform& cameraToScreen() const { return cameraToScreen_; }
 
 protected:
     // Private fields

sources/scenes/predefined_scenes.cc

@@ -18,27 +18,43 @@
 #include "../texture/constant.h"
 
 namespace spica {
-    void cornellBox(Scene* scene, Camera* camera, const int width, const int height) {
+    void cornellBox(Scene* scene,
+                    std::vector<Triangle>* tris,
+                    std::vector<Spectrum>* Kd) {
         std::vector<std::shared_ptr<Primitive>> primitives;
         std::vector<std::shared_ptr<Light>> lights;
 
+        if (tris) tris->clear();
+        if (Kd)   Kd->clear();
+
         // Light
         {
-            Point3d l00(-5.0, 9.99, -5.0);
-            Point3d l01(-5.0, 9.99,  5.0);
-            Point3d l10( 5.0, 9.99, -5.0);
-            Point3d l11( 5.0, 9.99,  5.0);
+            Point3d l00(-5.0, 9.9, -5.0);
+            Point3d l01(-5.0, 9.9,  5.0);
+            Point3d l10( 5.0, 9.9, -5.0);
+            Point3d l11( 5.0, 9.9,  5.0);
             Spectrum Le(8.0, 8.0, 8.0);
             auto t1 = std::make_shared<Triangle>(l00, l10, l11);
             auto t2 = std::make_shared<Triangle>(l00, l11, l01);
             auto l1 = std::make_shared<AreaLight>(t1, Transform(), Le);
             auto l2 = std::make_shared<AreaLight>(t2, Transform(), Le);
-            auto lightKd   = std::make_shared<ConstantTexture<Spectrum>>(Spectrum(0.99, 0.99, 0.99));
+            Spectrum kd = Spectrum(0.999, 0.999, 0.999);
+            auto lightKd   = std::make_shared<ConstantTexture<Spectrum>>(kd);
             auto lightMtrl = std::make_shared<LambertianMaterial>(lightKd); 
             primitives.emplace_back(new GeometricPrimitive(t1, lightMtrl, l1));
             primitives.emplace_back(new GeometricPrimitive(t2, lightMtrl, l2));
             lights.push_back(l1);
             lights.push_back(l2);
+
+            if (tris) {
+                tris->push_back(*t1.get());
+                tris->push_back(*t2.get());
+            }
+
+            if (Kd) {
+                Kd->push_back(kd);
+                Kd->push_back(kd);
+            }
         }
 
         Point3d v000(-10.0, -10.0, -10.0);
@@ -54,50 +70,107 @@ namespace spica {
         {
             auto t1 = std::make_shared<Triangle>(v010, v110, v111);
             auto t2 = std::make_shared<Triangle>(v010, v111, v011);
-            auto ceilKd   = std::make_shared<ConstantTexture<Spectrum>>(Spectrum(0.75, 0.75, 0.75));
+            Spectrum kd(0.75, 0.75, 0.75);
+            auto ceilKd   = std::make_shared<ConstantTexture<Spectrum>>(kd);
             auto ceilMtrl = std::make_shared<LambertianMaterial>(ceilKd);
             primitives.emplace_back(new GeometricPrimitive(t1, ceilMtrl, nullptr));
             primitives.emplace_back(new GeometricPrimitive(t2, ceilMtrl, nullptr));
+
+            if (tris) {
+                tris->push_back(*t1.get());
+                tris->push_back(*t2.get());
+            }
+
+            if (Kd) {
+                Kd->push_back(kd);
+                Kd->push_back(kd);
+            }
         }
 
         // Floor
         {
             auto t1 = std::make_shared<Triangle>(v000, v001, v101);
             auto t2 = std::make_shared<Triangle>(v000, v101, v100);
-            auto floorKd   = std::make_shared<ConstantTexture<Spectrum>>(Spectrum(0.75, 0.75, 0.75));
+            Spectrum kd(0.75, 0.75, 0.75);
+            auto floorKd   = std::make_shared<ConstantTexture<Spectrum>>(kd);
             auto floorMtrl = std::make_shared<LambertianMaterial>(floorKd);
             primitives.emplace_back(new GeometricPrimitive(t1, floorMtrl, nullptr));
             primitives.emplace_back(new GeometricPrimitive(t2, floorMtrl, nullptr));
+
+            if (tris) {
+                tris->push_back(*t1.get());
+                tris->push_back(*t2.get());
+            }
+
+            if (Kd) {
+                Kd->push_back(kd);
+                Kd->push_back(kd);
+            }
         }
 
         // Back
         {
             auto t1 = std::make_shared<Triangle>(v000, v100, v110);
             auto t2 = std::make_shared<Triangle>(v000, v110, v010);
-            auto backKd   = std::make_shared<ConstantTexture<Spectrum>>(Spectrum(0.75, 0.75, 0.75));
+            Spectrum kd(0.75, 0.75, 0.75);
+            auto backKd   = std::make_shared<ConstantTexture<Spectrum>>(kd);
             auto backMtrl = std::make_shared<LambertianMaterial>(backKd);
             primitives.emplace_back(new GeometricPrimitive(t1, backMtrl, nullptr));
             primitives.emplace_back(new GeometricPrimitive(t2, backMtrl, nullptr));
+
+            if (tris) {
+                tris->push_back(*t1.get());
+                tris->push_back(*t2.get());
+            }
+
+            if (Kd) {
+                Kd->push_back(kd);
+                Kd->push_back(kd);
+            }
+
         }
 
         // Left
         {
             auto t1 = std::make_shared<Triangle>(v000, v010, v011);
             auto t2 = std::make_shared<Triangle>(v000, v011, v001);
-            auto leftKd   = std::make_shared<ConstantTexture<Spectrum>>(Spectrum(0.75, 0.25, 0.25));
+            Spectrum kd(0.75, 0.25, 0.25);
+            auto leftKd   = std::make_shared<ConstantTexture<Spectrum>>(kd);
             auto leftMtrl = std::make_shared<LambertianMaterial>(leftKd);
             primitives.emplace_back(new GeometricPrimitive(t1, leftMtrl, nullptr));
             primitives.emplace_back(new GeometricPrimitive(t2, leftMtrl, nullptr));
+
+            if (tris) {
+                tris->push_back(*t1.get());
+                tris->push_back(*t2.get());
+            }
+
+            if (Kd) {
+                Kd->push_back(kd);
+                Kd->push_back(kd);
+            }
         }
 
         // Right
         {
             auto t1 = std::make_shared<Triangle>(v100, v101, v111);
             auto t2 = std::make_shared<Triangle>(v100, v111, v110);
-            auto rightKd   = std::make_shared<ConstantTexture<Spectrum>>(Spectrum(0.25, 0.75, 0.25));
+            Spectrum kd(0.25, 0.75, 0.25);
+            auto rightKd   = std::make_shared<ConstantTexture<Spectrum>>(kd);
             auto rightMtrl = std::make_shared<LambertianMaterial>(rightKd);
             primitives.emplace_back(new GeometricPrimitive(t1, rightMtrl, nullptr));
             primitives.emplace_back(new GeometricPrimitive(t2, rightMtrl, nullptr));
+
+            if (tris) {
+                tris->push_back(*t1.get());
+                tris->push_back(*t2.get());
+            }
+
+            if (Kd) {
+                Kd->push_back(kd);
+                Kd->push_back(kd);
+            }
+
         }
 
         // Mirror ball

sources/scenes/predefined_scenes.h

@@ -5,14 +5,18 @@
 #ifndef _SPICA_PREDEFINED_SCENES_H_
 #define _SPICA_PREDEFINED_SCENES_H_
 
+#include <vector>
+
 #include "../core/common.h"
+#include "../core/forward_decl.h"
+#include "../core/spectrum.h"
 
 namespace spica {
 
-    class Scene;
-    class Camera;
 
-    SPICA_EXPORTS void cornellBox(Scene* scene, Camera* camera, const int width, const int height);
+    SPICA_EXPORTS void cornellBox(Scene* scene,
+                                  std::vector<Triangle>* tris = nullptr,
+                                  std::vector<Spectrum>* Kd = nullptr);
 
     SPICA_EXPORTS void cornellBoxBunny(Scene* scene, Camera* camera, const int width, const int height);
 

sources/shape/triangle.cc

@@ -186,6 +186,16 @@ std::vector<Triangle> Triangle::triangulate() const {
     return std::move(tris);
 }
 
+const Normal3d& Triangle::normal(int i) const {
+    Assertion(i >= 0 && i <= 2, "Index out of bounds: %d specified.", i);
+    return normals_[i];
+}
+
+const Point2d& Triangle::uv(int i) const {
+    Assertion(i >= 0 && i <= 2, "Index out of bounds: %d specified.", i);
+    return uvs_[i];
+}
+
 Point3d Triangle::gravity() const {
     return (points_[0] + points_[1] + points_[2]) / 3.0;
 }

sources/viewer/main.cc

@@ -15,11 +15,11 @@ int main(int argc, char** argv) {
     std::unique_ptr<Filter> filter =
         std::make_unique<BoxFilter>(Vector2d(0.5, 0.5));
     auto film = std::make_unique<Film>(Point2i(width, height),
-                                       filter,
+                                       std::move(filter),
                                        kOutputDirectory + "pathtrace_%03d.png");
 
-    RectF screen(-2.5, -2.5, 5.0, 5.0);
-    double fov = PI / 24.0;
+    Bounds2d screen(-1.0, -1.0, 1.0, 1.0);
+    double fov = PI / 3.0;
 
     Point3d  eye(0.0, 0.0, 5.0 / tan(fov / 2.0));
     Point3d  look(0.0, 0.0, 0.0);
@@ -33,12 +33,14 @@ int main(int argc, char** argv) {
         Transform::lookAt(eye, look, up),
         screen, lensR, focal, fov, film.get());
 
-    cornellBox(&scene, nullptr, 640, 480);
+    std::vector<Triangle> tris;
+    std::vector<Spectrum> Kd;
+    cornellBox(&scene, &tris, &Kd);
 
     SceneViewer viewer;
     viewer.showMaximized();
 
-    viewer.setScene(scene, camera);
+    viewer.setScene(tris, Kd, camera);
 
     return app.exec();
 }

sources/viewer/qgl_render_widget.cc

@@ -36,18 +36,16 @@ namespace spica {
         delete shaderProgram;
     }
 
-    void QGLRenderWidget::setScene(const Scene& scene,
+    void QGLRenderWidget::setScene(const std::vector<spica::Triangle>& tris,
+                                   const std::vector<spica::Spectrum>& Kd,
                                    const std::shared_ptr<const Camera>& camera_) {
         this->camera = camera_;
 
         const Point2i res = camera_->film()->resolution();
         this->resize(res.x(), res.y());
-
-        /*
-        for (int i = 0; i < scene.numTriangles(); i++) {
-            vbo.add(scene.getTriangle(i), scene.getBsdf(i).reflectance());
+        for (int i = 0; i < tris.size(); i++) {
+            vbo.add(tris[i], Kd[i]);
         }
-        */
     }
 
     void QGLRenderWidget::initializeGL() {
@@ -84,17 +82,17 @@ namespace spica {
         if (camera->film()->resolution().x() == 0 ||
             camera->film()->resolution().y() == 0) return;
 
-        const Point3d  eye; //    = camera->;
-        const Point3d  lookTo; // = eye + camera.direction();
-        const Vector3d up; //     = camera.up();
-
         QMatrix4x4 projMat, viewMat, modelMat, normalMat;
-        cameraToProj(&projMat);
-
-        viewMat.lookAt(QVector3D(eye.x(), eye.y(), eye.z()),
-                       QVector3D(lookTo.x(), lookTo.y(), lookTo.z()),
-                       QVector3D(up.x(), up.y(), up.z()));
-
+
+        spica::Matrix4x4 c2s = camera->cameraToScreen().getMat();
+        spica::Matrix4x4 w2c = camera->cameraToWorld().getInvMat();
+        for (int i = 0; i < 4; i++) {
+            for (int j = 0; j < 4; j++) {
+                projMat(i, j) = c2s(i, j);
+                viewMat(i, j) = w2c(i, j);
+            }
+        }
+
         modelMat.setToIdentity();
         modelMat = modelMat * rotationMat;
         modelMat.scale(1.0 - _scrallDelta * 0.1);
@@ -160,29 +158,6 @@ namespace spica {
         return pt;
     }
 
-    void QGLRenderWidget::cameraToProj(QMatrix4x4* mat) const {
-        /*
-        ICamera* ptr = camera._ptr.get();    
-        if (typeid(*ptr) == typeid(OrthographicCamera)) {
-            OrthographicCamera* cam = reinterpret_cast<OrthographicCamera*>(ptr);
-            const Rect& rect = cam->rect();
-            QRect qrect(rect.x(), rect.y(), rect.width(), rect.height());
-            mat->ortho(qrect);
-        } else if (typeid(*ptr) == typeid(PerspectiveCamera)) {
-            PerspectiveCamera* cam = reinterpret_cast<PerspectiveCamera*>(ptr);
-            const double verticalAngle = 180.0 * cam->fov() / PI;
-            mat->perspective(verticalAngle, (float)width() / (float)height(), 1.0f, 1000.0f);
-        } else if (typeid(*ptr) == typeid(DoFCamera)) {
-            DoFCamera* cam = reinterpret_cast<DoFCamera*>(ptr);
-            const double verticalAngle = 360.0 / PI * atan(cam->sensorH() / (2.0 * cam->distSL()));
-            mat->perspective(verticalAngle, (float)width() / (float)height(), 1.0f, 1000.0f);
-        } else {
-            std::cerr << "[ERROR] unknown camera projection type detected: " << (typeid(*ptr).name()) << std::endl;
-            std::abort();
-        }
-        */
-    }
-
     void QGLRenderWidget::wheelEvent(QWheelEvent* e) {
         _scrallDelta += e->delta() / 1000.0;
     }

sources/viewer/qgl_render_widget.h

@@ -20,7 +20,8 @@ namespace spica {
         explicit QGLRenderWidget(QWidget *parent = 0);
         ~QGLRenderWidget();
 
-        void setScene(const Scene& scene,
+        void setScene(const std::vector<spica::Triangle>& tris,
+                      const std::vector<spica::Spectrum>& Kd,
                       const std::shared_ptr<const Camera>& camera);
 
     protected:
@@ -36,8 +37,6 @@ namespace spica {
         void updateMouse();
         QVector3D getArcBallVector(int x, int y);
 
-        void cameraToProj(QMatrix4x4* mat) const;
-
     protected slots:
         void animate();
 

sources/viewer/scene_viewer.cc

@@ -60,9 +60,10 @@ SceneViewer::~SceneViewer() {
     delete renderThread;
 }
 
-void SceneViewer::setScene(const Scene& scene,
+void SceneViewer::setScene(const std::vector<Triangle>& tris,
+                           const std::vector<Spectrum>& Kd,
                            const std::shared_ptr<const Camera>& camera) {
-    qglWidget->setScene(scene, camera);
+    qglWidget->setScene(tris, Kd, camera);
 }
 
 void SceneViewer::setSignalSlots() {

sources/viewer/scene_viewer.h

@@ -26,7 +26,8 @@ class SceneViewer : public QMainWindow {
     explicit SceneViewer(QWidget *parent = 0);
     ~SceneViewer();
 
-    void setScene(const Scene& scene,
+    void setScene(const std::vector<Triangle>& tris,
+                  const std::vector<Spectrum>& Kd,
                   const std::shared_ptr<const Camera>& camera);
 
 private: