fart/main/Scene.cc

#include "Scene.h"
#include <stdlib.h>
#include <string>
#include <map>
#include <math.h>
#include "BMP.h"
#include "shapes/Shape.h"
#include "shapes/Sphere.h"
using namespace std;

Scene::Scene(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;

    load(filename);

    /* after loading the scene file, apply any command-line render options */
    for (map<string, const char *>::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;
    for (vector<Shape *>::iterator it = m_shapes.begin();
         it != m_shapes.end();
         it++)
    {
        delete (*it);
    }
}

void Scene::load(const char * filename)
{
    /* TODO: parse file somehow */
    Shape * shape = new Sphere(1.0);
    m_transform.translate(1.0, 5.0, 0.5);
    shape->setTransform(m_transform);
    m_shapes.push_back(shape);
}

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 */
    double red = 0.0, green = 0.0, blue = 0.0;
    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));

            Vector color = traceRay(ray);

            red += color[0];
            green += color[1];
            blue += color[2];
        }
    }

    /* take the average of all the samples as the final pixel value */
    pixel[BMP_RED] = (unsigned char) (0xFF * red / m_multisample_level_squared);
    pixel[BMP_GREEN] = (unsigned char) (0xFF * green / m_multisample_level_squared);
    pixel[BMP_BLUE] = (unsigned char) (0xFF * blue / m_multisample_level_squared);
}

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

    /* loop through all shapes in the scene */
    for (vector<Shape *>::iterator it = m_shapes.begin();
         it != m_shapes.end();
         it++)
    {
        /* transform the ray by the inverse of the shape's transform */
        Transform inv = (*it)->getTransform().getInverse();
        Ray local_ray = inv.transform_ray(ray);

        /* then intersect this inversely transformed ray with the shape */
        Solver::Result intersections = (*it)->intersect(local_ray);

        if (intersections.numResults > 0)
        {
            Vector local_normal =
                (*it)->getNormalAt(local_ray[intersections.results[0]]);
            double dot = local_ray.getDirection() % local_normal;
            dot = -dot;
            if (dot < 0.0)
                dot = 0.0;
#if 0
            color[0] = dot;
            color[1] = dot;
            color[2] = dot;
#endif
            color[0] = color[1] = color[2] = 1.0;
        }
        else
        {
            color[0] = 0.0;
            color[1] = 0.0;
            color[2] = 0.0;
        }
    }
    return color;
}