working on Scene::process*() functions to load the scene from a file

git-svn-id: svn://anubis/fart/trunk@164 7f9b0f55-74a9-4bce-be96-3c2cd072584d

main/Scene-load.cc

@@ -8,102 +8,105 @@
 
 using namespace std;
 
+typedef vector< refptr<Node> >::const_iterator Node_Iterator;
+
 void Scene::load(const char * filename)
 {
     /* TODO: parse file somehow */
 //    refptr<Node> node = parse(filename);
 //    processNode(node);
 
+    Transform transform;
 
     refptr<Material> m = new Material();
     m->setDiffuseColor(Color::white);
     m->setAmbientColor(Color::white);
     refptr<Shape> shape = new Plane(0, 0, 1, 2);
-    shape->setTransform(m_transform);
+    shape->setTransform(transform);
     shape->setMaterial(m);
     m_shapes.push_back(shape);
 
-    m_transform.translate(1.0, 5.0, 0.5);
+    transform.translate(1.0, 5.0, 0.5);
     m = new Material();
     m->setDiffuseColor(Color::red);
     m->setAmbientColor(Color::red);
     shape = new Sphere(1.0);
-    shape->setTransform(m_transform);
+    shape->setTransform(transform);
     shape->setMaterial(m);
     m_shapes.push_back(shape);
-    m_transform.translate(-1.0, -5.0, -0.5);
+    transform.translate(-1.0, -5.0, -0.5);
 
-    m_transform.translate(-1, 3, -0.5);
+    transform.translate(-1, 3, -0.5);
     refptr<Shape> shape1 = new Sphere(0.8);
     shape1->setMaterial(m);
-    shape1->setTransform(m_transform);
+    shape1->setTransform(transform);
     refptr<Shape> shape2 = new Box(new Vector(2, 2, 0.6));
     m = new Material();
     m->setDiffuseColor(Color::magenta);
     m->setAmbientColor(Color::magenta);
     shape2->setMaterial(m);
-    m_transform.rotate(20, 0, 1, 0);
+    transform.rotate(20, 0, 1, 0);
-    shape2->setTransform(m_transform);
+    shape2->setTransform(transform);
     shape = new Intersect(shape1, shape2);
     m_shapes.push_back(shape);
-    m_transform.rotate(-20, 0, 1, 0);
+    transform.rotate(-20, 0, 1, 0);
-    m_transform.translate(1, -3, 0.5);
+    transform.translate(1, -3, 0.5);
 
-    m_transform.translate(1.5, 3.2, -0.7);
+    transform.translate(1.5, 3.2, -0.7);
-    m_transform.rotate(15, 0, 0, 1);
+    transform.rotate(15, 0, 0, 1);
     m = new Material();
     m->setDiffuseColor(Color::magenta);
     m->setAmbientColor(Color::magenta);
     shape1 = new Box(new Vector(1, 1, 1));
     shape1->setMaterial(m);
-    shape1->setTransform(m_transform);
+    shape1->setTransform(transform);
     m = new Material();
     m->setDiffuseColor(Color::yellow);
     m->setAmbientColor(Color::yellow);
     shape2 = new Sphere(0.6);
-    m_transform.translate(-0.5, -0.5, 0.5);
+    transform.translate(-0.5, -0.5, 0.5);
-    shape2->setTransform(m_transform);
+    shape2->setTransform(transform);
     shape2->setMaterial(m);
     shape = new Subtract(shape1, shape2);
     m_shapes.push_back(shape);
-    m_transform.rotate(-15, 0, 0, 1);
+    transform.rotate(-15, 0, 0, 1);
-    m_transform.translate(-1.0, -2.7, 0.2);
+    transform.translate(-1.0, -2.7, 0.2);
 
-    m_transform.translate(1, 5, -1.5);
+    transform.translate(1, 5, -1.5);
     m = new Material();
     m->setDiffuseColor(Color::blue);
     m->setAmbientColor(Color::blue);
     shape = new Box(new Vector(1.8, 1.8, 0.5));
-    shape->setTransform(m_transform);
+    shape->setTransform(transform);
     shape->setMaterial(m);
     m_shapes.push_back(shape);
-    m_transform.translate(-1, -5, 1.5);
+    transform.translate(-1, -5, 1.5);
 
-    m_transform.translate(-0.5, 6.5, 1.5);
+    transform.translate(-0.5, 6.5, 1.5);
-    m_transform.rotate(45, 1, 0, 0);
+    transform.rotate(45, 1, 0, 0);
     m = new Material();
     m->setDiffuseColor(Color::cyan);
     m->setAmbientColor(Color::cyan);
     shape = new Cyl(1.0, 0.0, 2.0);
-    shape->setTransform(m_transform);
+    shape->setTransform(transform);
     shape->setMaterial(m);
     m_shapes.push_back(shape);
-    m_transform.rotate(-45, 1, 0, 0);
+    transform.rotate(-45, 1, 0, 0);
-    m_transform.translate(0.5, -6.5, -1.5);
+    transform.translate(0.5, -6.5, -1.5);
 
-    m_transform.translate(-2.0, 5.0, 1.5);
+    transform.translate(-2.0, 5.0, 1.5);
-    m_transform.rotate(45, 0, 0, 1);
+    transform.rotate(45, 0, 0, 1);
-    m_transform.rotate(45, 1, 0, 0);
+    transform.rotate(45, 1, 0, 0);
     m = new Material();
     m->setDiffuseColor(Color::yellow);
     m->setAmbientColor(Color::yellow);
     shape = new Box(new Vector(1, 1, 1));
-    shape->setTransform(m_transform);
+    shape->setTransform(transform);
     shape->setMaterial(m);
     m_shapes.push_back(shape);
-    m_transform.rotate(-45, 1, 0, 0);
+    transform.rotate(-45, 1, 0, 0);
-    m_transform.rotate(-45, 0, 0, 1);
+    transform.rotate(-45, 0, 0, 1);
-    m_transform.translate(2.0, -5.0, -1.5);
+    transform.translate(2.0, -5.0, -1.5);
 
     refptr<Light> light = new PointLight();
     light->setPosition(Vector(2, -1, 2));
@@ -123,6 +126,10 @@ void Scene::processNode(refptr<Node> node)
     {
         cout << "saw a box" << endl;
     }
+    else if ( typeid(*node) == typeid(MaterialNode) )
+    {
+        refptr<Material> mat = processMaterial(node);
+    }
     else if ( typeid(*node) == typeid(PlaneNode) )
     {
         cout << "saw a plane" << endl;
@@ -143,45 +150,132 @@ void Scene::processChildren(refptr<Node> node)
     }
 }
 
-refptr<Material> processMaterial(refptr<Node> node)
+refptr<Material> Scene::processMaterial(refptr<Node> node)
 {
-    if (typeid(*node) != typeid(MaterialNode))
-        return refptr<Material>(NULL);
-
     refptr<Material> material = new Material();
 
-    /* TODO: finish */
+    for (Node_Iterator it = node->getChildren().begin();
+         it != node->getChildren().end();
+         it++)
+    {
+        if      ( typeid(**it) == typeid(ColorNode) )
+        {
+            material->setDiffuseColor(Color((*it)->getVector()));
+            material->setAmbientColor(Color((*it)->getVector()));
+        }
+        else if ( typeid(**it) == typeid(AmbientNode) )
+        {
+            material->setAmbientColor(Color((*it)->getVector()));
+        }
+        else if ( typeid(**it) == typeid(DiffuseNode) )
+        {
+            material->setDiffuseColor(Color((*it)->getVector()));
+        }
+        else if ( typeid(**it) == typeid(SpecularNode) )
+        {
+            material->setSpecularColor(Color((*it)->getVector()));
+        }
+        else if ( typeid(**it) == typeid(ReflectanceNode) )
+        {
+            material->setReflectance((*it)->getNumber());
+        }
+        else if ( typeid(**it) == typeid(ShininessNode) )
+        {
+            material->setShininess((*it)->getNumber());
+        }
+    }
 
     return material;
 }
 
-refptr<Shape> processBox(refptr<Node> node)
+refptr<Shape> Scene::processBox(refptr<Node> node)
+{
+    Vector size(1, 1, 1);
+    refptr<Material> material;
+
+    bool restore_transform = processTransforms(node);
+
+    for (Node_Iterator it = node->getChildren().begin();
+         it != node->getChildren().end();
+         it++)
+    {
+        if      ( typeid(**it) == typeid(SizeNode) )
+        {
+            size = *(*it)->getVector();
+        }
+        else if ( typeid(**it) == typeid(MaterialNode) )
+        {
+            material = processMaterial(*it);
+        }
+    }
+    
+    if (restore_transform)
+        m_transforms.pop();
+
+    return refptr<Shape>(NULL);
+}
+
+refptr<Shape> Scene::processCyl(refptr<Node> node)
 {
     /* TODO: finish */
     return refptr<Shape>(NULL);
 }
 
-refptr<Shape> processCyl(refptr<Node> node)
+refptr<Light> Scene::processLight(refptr<Node> node)
-{
-    /* TODO: finish */
-    return refptr<Shape>(NULL);
-}
-
-refptr<Light> processLight(refptr<Node> node)
 {
     /* TODO: finish */
     return refptr<Light>(NULL);
 }
 
-refptr<Shape> processPlane(refptr<Node> node)
+refptr<Shape> Scene::processPlane(refptr<Node> node)
 {
     /* TODO: finish */
     return refptr<Shape>(NULL);
 }
 
-refptr<Shape> processSphere(refptr<Node> node)
+refptr<Shape> Scene::processSphere(refptr<Node> node)
 {
     /* TODO: finish */
     return refptr<Shape>(NULL);
 }
 
+bool Scene::processTransforms(refptr<Node> node)
+{
+    bool did_any = false;
+
+    for (Node_Iterator it = node->getChildren().begin();
+         it != node->getChildren().end();
+         it++)
+    {
+        if      ( typeid(**it) == typeid(TranslateNode) )
+        {
+            if (did_any == false)
+            {
+                m_transforms.push(m_transforms.top());
+                did_any = true;
+            }
+            m_transforms.top().translate((*it)->getVector());
+        }
+        else if ( typeid(**it) == typeid(RotateNode) )
+        {
+            if (did_any == false)
+            {
+                m_transforms.push(m_transforms.top());
+                did_any = true;
+            }
+            m_transforms.top().rotate((*it)->getNumber(),
+                                      (*it)->getVector());
+        }
+        else if ( typeid(**it) == typeid(ScaleNode) )
+        {
+            if (did_any == false)
+            {
+                m_transforms.push(m_transforms.top());
+                did_any = true;
+            }
+            m_transforms.top().scale((*it)->getVector());
+        }
+    }
+
+    return did_any;
+}

main/Scene.cc

@@ -29,6 +29,7 @@ Scene::Scene(const map<string, const char *> & options,
     m_data = NULL;
     m_ambient_light = Color(0.1, 0.1, 0.1);
     m_max_depth = 10;
+    m_transforms.push(Transform());
 
     load(filename);
 

main/Scene.h

@@ -6,6 +6,7 @@
 #include <map>
 #include <vector>
 #include <utility>
+#include <stack>
 #include "util/refptr.h"
 #include "util/Ray.h"
 #include "util/Color.h"
@@ -45,7 +46,6 @@ class Scene
         void setMultisampleLevel(int level) { m_multisample_level = level; }
         void setVFOV(double vfov) { m_vfov = vfov; }
         void setAmbientLight(const Color & al) { m_ambient_light = al; }
-        Transform & getTransform() { return m_transform; }
 
     protected:
         /* private methods */
@@ -64,6 +64,7 @@ class Scene
         refptr<Light> processLight(refptr<Node> node);
         refptr<Shape> processPlane(refptr<Node> node);
         refptr<Shape> processSphere(refptr<Node> node);
+        bool processTransforms(refptr<Node> node);
 
         /* rendering parameters */
         int m_width;
@@ -78,7 +79,7 @@ class Scene
         /* private data */
         std::vector< refptr<Shape> > m_shapes;
         std::vector< refptr<Light> > m_lights;
-        Transform m_transform;
+        std::stack<Transform> m_transforms;
         double m_view_plane_dist;
         int m_multisample_level_squared;
         double m_sample_span;

util/Color.cc

@@ -29,6 +29,13 @@ Color::Color(const Vector & v)
     b = v[2];
 }
 
+Color::Color(refptr<Vector> v)
+{
+    r = (*v)[0];
+    g = (*v)[1];
+    b = (*v)[2];
+}
+
 Color Color::operator*(const Color & other) const
 {
     Color result;

util/Color.h

@@ -2,6 +2,7 @@
 #ifndef COLOR_H
 #define COLOR_H COLOR_H
 
+#include "refptr.h"
 #include <iostream>
 #include "util/Vector.h"
 
@@ -13,6 +14,7 @@ class Color
         Color();
         Color(double r, double g, double b);
         Color(const Vector & v);
+        Color(refptr<Vector> v);
 
         Color operator*(const Color & other) const;
         Color operator*(double scale) const;

util/Transform.h

@@ -2,6 +2,7 @@
 #ifndef TRANSFORM_H
 #define TRANSFORM_H TRANSFORM_H
 
+#include "refptr.h"
 #include "Matrix.h"
 #include "Ray.h"
 #include "Vector.h"
@@ -16,8 +17,20 @@ class Transform
                     const Vector & focus,
                     const Vector & up);
         void translate(double x, double y, double z);
+        void translate(refptr<Vector> vec)
+        {
+            translate((*vec)[0], (*vec)[1], (*vec)[2]);
+        }
         void rotate(double angle, double xv, double yv, double zv);
+        void rotate(double angle, refptr<Vector> vec)
+        {
+            rotate(angle, (*vec)[0], (*vec)[1], (*vec)[2]);
+        }
         void scale(double xs, double ys, double zs);
+        void scale(refptr<Vector> vec)
+        {
+            scale((*vec)[0], (*vec)[1], (*vec)[2]);
+        }
         Matrix & getMatrix() { return m_matrix; }
         Vector transform_point(const Vector & v);
         Vector transform_direction(const Vector & v);