fart/main/Scene.cc

#include "Scene.h"
#include <stdlib.h>
#include <string>
#include <vector>
#include <utility>              /* pair */
#include <map>
#include <algorithm>            /* sort() */
#include <functional>           /* binary_function */
#include <typeinfo>             /* typeid operator support */
#include <math.h>
#include "BMP.h"
#include "util/Color.h"
#include "shapes/Shape.h"
#include "PointLight.h"
#include "Lighting.h"

#include "parser/parser.h"
#include "parser/nodes.h"

using namespace std;

Scene::Scene(const map<string, const char *> & options,
             const char * filename)
{
    m_width = 800;
    m_height = 600;
    m_multisample_level = 1;
    m_output_file_name = "fart.bmp";
    m_vfov = 60.0;
    m_verbose = false;
    m_data = NULL;
    m_ambient_light = Color(0.1, 0.1, 0.1);

    load(filename);

    /* after loading the scene file, apply any command-line render options */
    for (map<const string, const char *>::const_iterator it = options.begin();
         it != options.end();
         it++)
    {
        if (it->first == "width")
        {
            m_width = atoi(it->second);
        }
        else if (it->first == "height")
        {
            m_height = atoi(it->second);
        }
        else if (it->first == "multisample")
        {
            m_multisample_level = atoi(it->second);
        }
        else if (it->first == "field-of-view")
        {
            m_vfov = atof(it->second);
        }
        else if (it->first == "output-file")
        {
            m_output_file_name = it->second;
        }
        else if (it->first == "verbose")
        {
            m_verbose = true;
        }
    }

    /* view plane distance is calculated based on the field of view */
    m_view_plane_dist = (m_height / 2.0) / tan(M_PI * m_vfov / 360.0);
    m_sample_span = 1.0 / m_multisample_level;
    m_half_sample_span = m_sample_span / 2.0;
    m_multisample_level_squared = m_multisample_level * m_multisample_level;
}

Scene::~Scene()
{
    if (m_data != NULL)
        delete m_data;
}

void Scene::processNode(refptr<Node> node)
{
    if (node.isNull())
        return;

    if      ( typeid(*node) == typeid(SceneNode) )
    {
        processChildren(node);
    }
    else if ( typeid(*node) == typeid(BoxNode) )
    {
        cout << "saw a box" << endl;
    }
    else if ( typeid(*node) == typeid(PlaneNode) )
    {
        cout << "saw a plane" << endl;
    }
    else if ( typeid(*node) == typeid(SphereNode) )
    {
        cout << "saw a sphere" << endl;
    }

}

void Scene::processChildren(refptr<Node> node)
{
    std::vector< refptr<Node> > & children = node->getChildren();
    for (int i = 0, sz = children.size(); i < sz; i++)
    {
        processNode(children[i]);
    }
}

void Scene::load(const char * filename)
{
    refptr<Node> node = parse(filename);
    processNode(node);


    /* TODO: parse file somehow */
    refptr<Shape> plane = new Plane(0, 0, 1, -2);
    m_shapes.push_back(plane);

    refptr<Material> m = new Material();
    m->setDiffuseColor(Color::red);
    m->setAmbientColor(Color::red);

    refptr<Shape> shape = new Sphere(1.0);
    m_transform.translate(1.0, 5.0, 0.5);
    shape->setTransform(m_transform);
    shape->setMaterial(m);
    m_shapes.push_back(shape);

    m = new Material();
    m->setDiffuseColor(Color::blue);
    m->setAmbientColor(Color::blue);

    shape = new Box(new Vector(1.8, 1.8, 0.5));
    m_transform.translate(0, 0, -2.0);
    shape->setTransform(m_transform);
    shape->setMaterial(m);
    m_shapes.push_back(shape);

    m = new Material();
    m->setDiffuseColor(Color::cyan);
    m->setAmbientColor(Color::cyan);

    shape = new Cyl(1.0, 0.0, 2.0);
    m_transform.translate(-1.3, 2.5, 3.5);
    m_transform.rotate(45, 1, 0, 0);
    shape->setTransform(m_transform);
    shape->setMaterial(m);
    m_shapes.push_back(shape);

    m = new Material();
    m->setDiffuseColor(Color::yellow);
    m->setAmbientColor(Color::yellow);

    shape = new Box(new Vector(1, 1, 1));
    m_transform.rotate(-45, 1, 0, 0);
    m_transform.translate(-1.7, -0.5, -2.0);
    m_transform.rotate(45, 0, 0, 1);
    m_transform.rotate(45, 1, 0, 0);
    shape->setTransform(m_transform);
    shape->setMaterial(m);
    m_shapes.push_back(shape);

    refptr<Light> light = new PointLight();
    light->setPosition(Vector(2, -1, 2));
    m_lights.push_back(light);
}

void Scene::render()
{
    if (m_verbose)
    {
        cout << " *** Beginning scene render ***" << endl;
        cout << "Parameters:" << endl;
        cout << "----------------------------------------" << endl;
        cout << "    Width: " << m_width << endl;
        cout << "    Height: " << m_height << endl;
        cout << "    Multisample Level: " << m_multisample_level << endl;
        cout << "    Vertical Field of View: " << m_vfov << endl;
        cout << "----------------------------------------" << endl;
    }

    m_data = new unsigned char[m_width * m_height * 3];

    for (int i = 0; i < m_height; i++)
    {
        for (int j = 0; j < m_width; j++)
        {
            renderPixel(j, i, &m_data[3 * (m_width * i + j)]);
        }
    }

    if (m_verbose)
    {
        cout << " *** Ending scene render ***" << endl;
        cout << "Writing output file '" << m_output_file_name << '\'' << endl;
    }
    BMP outputImage(m_output_file_name.c_str(), m_width, m_height, m_data);
}

void Scene::renderPixel(int x, int y, unsigned char * pixel)
{
    /* calculate the ray going from the camera through this pixel */
    Color finalColor;
    for (int i = 0; i < m_multisample_level; i++)
    {
        for (int j = 0; j < m_multisample_level; j++)
        {
            double rx = (x + i * m_sample_span + m_half_sample_span)
                      - (m_width / 2.0);
            double rz = (m_height / 2.0)
                      - (y + j * m_sample_span + m_half_sample_span);

            Ray ray(Vector(0, 0, 0), Vector(rx, m_view_plane_dist, rz));

            finalColor += traceRay(ray);
        }
    }

    /* take the average of all the samples as the final pixel value */
    pixel[BMP_RED] = (unsigned char)
        (0xFF * finalColor.r / m_multisample_level_squared);
    pixel[BMP_GREEN] = (unsigned char)
        (0xFF * finalColor.g / m_multisample_level_squared);
    pixel[BMP_BLUE] = (unsigned char)
        (0xFF * finalColor.b / m_multisample_level_squared);
}

Color Scene::traceRay(const Ray & ray)
{
    Color color;

    vector<ShapeDistance> hits = getRayHits(ray);

    for (vector<ShapeDistance>::const_iterator it = hits.begin();
         it != hits.end();
         it++)
    {
        /* compute the Phong lighting for each hit */
        refptr<Material> material = it->first->getMaterial();

        Vector surfacePoint = ray[it->second];

        color = Lighting::computePhong(material,
                                       m_lights,
                                       ray,
                                       surfacePoint,
                                       it->first->getNormalAt(surfacePoint),
                                       m_ambient_light);
    }

    return color;
}

vector<Scene::ShapeDistance> Scene::getRayHits(const Ray & ray)
{
    vector<ShapeDistance> hits;
    double minSolidDist = 0.0;

    /* loop through all shapes in the scene */
    for (vector< refptr<Shape> >::iterator it = m_shapes.begin();
         it != m_shapes.end();
         it++)
    {
        Shape::IntersectList intersections = (*it)->intersect(ray);

        for (int i = 0, num_results = intersections.size();
             i < num_results;
             i++)
        {
            Vector normal = (*it)->getNormalAt(intersections[i]);
            double dot = normal % ray.getDirection();
            double intersect_dist = (intersections[i] - ray.getOrigin()).mag();
            if (dot < 0.0) /* cull back faces */
            {
                double transparency = (*it)->getTransparency();
                if (transparency == 0.0 &&
                        (minSolidDist == 0.0 || minSolidDist > intersect_dist))
                {
                    minSolidDist = intersect_dist;
                }
                if (minSolidDist == 0.0 || minSolidDist >= intersect_dist)
                {
                    hits.push_back(ShapeDistance(*it, intersect_dist));
                }
            }
        }
    }

    /* now that we have ALL the hits, sort them by distance */
    sort(hits.begin(), hits.end());

    double transparency = 1.0;
    /* now go through them all until we get to the maximum number
     * of hits, or until the transparency left is below the threshold */
    for (unsigned int hits_index = 0, sz = hits.size();
         hits_index < sz;
         hits_index++)
    {
        transparency *= hits[hits_index].first->getTransparency();
        if (hits_index >= (SCENE_MAX_TRANSPARENT_HITS - 1)
         || transparency < SCENE_TRANSPARENCY_THRESHOLD)
        {
            /* delete the rest of the hits */
            for (int i = 0, num_to_del = sz - hits_index - 1;
                 i < num_to_del;
                 i++)
            {
                hits.pop_back();
            }
            break;
        }
    }

    return hits;
}

bool operator<(const Scene::ShapeDistance & sd1,
               const Scene::ShapeDistance & sd2)
{
    return sd1.second < sd2.second;
}