CornellBox.cc

Go to the documentation of this file.

#include <gra/scene/CornellBox.h>
#include <esg/geometry/Polygon.h>
#include <esg/geometry/Rectangle.h>
#include <esg/DirLight.h>
#include <esg/Material.h>
#include <esg/RefrCoefs.h>

using namespace gra;

#define KB_CORNER 1.0

const int     CornellBox::_upperLeftFar   = 0;
const int     CornellBox::_upperLeftNear  = 1;
const int     CornellBox::_upperRightNear = 2;
const int     CornellBox::_upperRightFar  = 3;
const int     CornellBox::_lowerLeftNear  = 4;
const int     CornellBox::_lowerLeftFar   = 5;
const int     CornellBox::_lowerRightFar  = 6;
const int     CornellBox::_lowerRightNear = 7;

const float   CornellBox::_lightScale = .35;

const Vector3 CornellBox::_box [8] = {
    Vector3(-KB_CORNER, KB_CORNER,-KB_CORNER),
    Vector3(-KB_CORNER, KB_CORNER, KB_CORNER),
    Vector3( KB_CORNER, KB_CORNER, KB_CORNER),
    Vector3( KB_CORNER, KB_CORNER,-KB_CORNER),
    Vector3(-KB_CORNER,-KB_CORNER, KB_CORNER),
    Vector3(-KB_CORNER,-KB_CORNER,-KB_CORNER),
    Vector3( KB_CORNER,-KB_CORNER,-KB_CORNER),
    Vector3( KB_CORNER,-KB_CORNER, KB_CORNER)
};

void CornellBox::_build_walls()
{
    Vector3 wLeft [4] = { _box[_lowerLeftFar], 
                          _box[_lowerLeftNear],
                          _box[_upperLeftNear],
                          _box[_upperLeftFar] };
    Vector3 wFront [4] = { _box[_lowerLeftNear], 
                           _box[_lowerRightNear],
                           _box[_upperRightNear],
                           _box[_upperLeftNear] };
    Vector3 wRight [4] = { _box[_lowerRightNear], 
                           _box[_lowerRightFar],
                           _box[_upperRightFar],
                           _box[_upperRightNear] };
    Vector3 wBack [4] = { _box[_lowerRightFar], 
                          _box[_lowerLeftFar],
                          _box[_upperLeftFar],
                          _box[_upperRightFar] };
    Vector3 wTop [4] = { _box[_upperLeftNear], 
                         _box[_upperRightNear],
                         _box[_upperRightFar],
                         _box[_upperLeftFar] };
    Vector3 wBottom [4] = { _box[_lowerLeftNear], 
                            _box[_lowerLeftFar],
                            _box[_lowerRightFar],
                            _box[_lowerRightNear] };
    
    
    Shape * pWall;

    pWall = new Shape(++_lastOID, "Left Wall");
    pWall->setPrivateGeometry(new esg::Polygon(wLeft, NULL, NULL, 4,
                                          Vector3(1,0,0), true));
    pWall->appendPrivateMaterial(new Specular(0,0,0));
    pWall->appendPrivateMaterial(new Diffuse(1.,.0,.0));
    pWall->appendPrivateMaterial(new Ambient(0,0,0));
    //pWall->appendPrivateMaterial(new Reflection(1.));
    appendObject(pWall);

    pWall = new Shape(++_lastOID, "Front Wall");
    pWall->setPrivateGeometry(new esg::Polygon(wFront, NULL, NULL, 4,
                                          Vector3(0,0,-1), true));
    pWall->appendPrivateMaterial(new Specular(0,0,0));
    pWall->appendPrivateMaterial(new Diffuse(.0,.0,.0));
    pWall->appendPrivateMaterial(new Ambient(0,0,0));
    //pWall->appendPrivateMaterial(new Reflection(1.));
    appendObject(pWall);

    pWall = new Shape(++_lastOID, "Right Wall");
    pWall->setPrivateGeometry(new esg::Polygon(wRight, NULL, NULL, 4,
                                          Vector3(-1,0,0), true));
    pWall->appendPrivateMaterial(new Specular(0,0,0));
    pWall->appendPrivateMaterial(new Diffuse(.0,.0,1.));
    pWall->appendPrivateMaterial(new Ambient(0,0,0));
    //pWall->appendPrivateMaterial(new Reflection(1.));
    appendObject(pWall);
    
    pWall = new Shape(++_lastOID, "Back Wall");
    pWall->setPrivateGeometry(new esg::Polygon(wBack, NULL, NULL, 4,
                                          Vector3(0,0,1), true));
    pWall->appendPrivateMaterial(new Specular(0,0,0));
    pWall->appendPrivateMaterial(new Diffuse(1.,1.,1.));
    pWall->appendPrivateMaterial(new Ambient(0,0,0));
    //pWall->appendPrivateMaterial(new Reflection(1.));
    appendObject(pWall);

    pWall = new Shape(++_lastOID, "Top Wall");
    pWall->setPrivateGeometry(new esg::Polygon(wTop, NULL, NULL, 4,
                                          Vector3(0,-1,0), true));
    pWall->appendPrivateMaterial(new Specular(0,0,0));
    pWall->appendPrivateMaterial(new Diffuse(1.,1.,1.));
    pWall->appendPrivateMaterial(new Ambient(0,0,0));
    //pWall->appendPrivateMaterial(new Reflection(1.));
    appendObject(pWall);
    
    pWall = new Shape(++_lastOID, "Bottom Wall");
    pWall->setPrivateGeometry(new esg::Polygon(wBottom, NULL, NULL, 4,
                                          Vector3(0,1,0), true));
    pWall->appendPrivateMaterial(new Specular(0,0,0));
    pWall->appendPrivateMaterial(new Diffuse(1.,1.,1.));
    pWall->appendPrivateMaterial(new Ambient(0,0,0));
    //pWall->appendPrivateMaterial(new Reflection(1.));
    appendObject(pWall);
}

void CornellBox::_build_lights()
{
    Vector3 lp(_box[_upperLeftNear]);
    lp.add(_box[_upperRightFar]);
    lp.scale(.5);
    lp.y = KB_CORNER - .01;

    Vector3 ud(_box[_upperRightNear]);
    ud.sub(_box[_upperLeftNear]);
    ud.scale(_lightScale);

    Vector3 vd(_box[_upperRightNear]);
    vd.sub(_box[_upperRightFar]);
    vd.scale(_lightScale);

    Vector3 cp(lp);
    cp.x -= ud.length() / 2.;
    cp.z -= vd.length() / 2.;
    cp.y += .005;

    cp.z -= .4;

    DirLight * pLight = new DirLight(lp,
                                     Vector3(0,-1,0),
                                     Vector3(1,1,1),
                                     0, // fade distance
                                     1.5, // fade power
                                     ++_lastOID,
                                     "Light Source");
    pLight->setPrivateGeometry(new esg::Rectangle(cp, ud, vd,
                                                  NULL,
                                                  true,
                                                  Vector3(0,-1,0)));
    appendLight(pLight);
}

void CornellBox::_create_sf_object_set(Vector3 objset[9])
{
    /*
     * Create the set of 9 vectors needed to generate the sphere set.
     * Uses global 'objset'
     */

    Vector3 axis, trio_dir[3];
    double  dist;
    Matrix4 mx;
        
    dist = 1.0 / sqrt((double)2.0);
        
    trio_dir[0].set(dist, dist,   0.0);
    trio_dir[1].set(dist,  0.0, -dist);
    trio_dir[2].set( 0.0, dist, -dist);
        
    axis.set(dist, -dist, 0.0);
    
    mx.rotationGL(asin((double)(2.0/sqrt((double)6.0))), axis);
        
    for (int i = 0; i < 3; i++) mx.transform(trio_dir[i]);
        
    for (int i = 0; i < 3; i++) {
        mx.rotZ(i*2.0*PI/3.0);
        for (int j = 0; j < 3; j++) mx.transform(trio_dir[j], objset[i*3+j]);
    }
}

void CornellBox::_build_sphere_flake(unsigned       depth,
                                     const Vector4& center,
                                     const Vector4& direction,
                                     Vector3        objset[9])
{
    double   angle, scale;
    Matrix4  mx;
    Vector3  axis, z_axis;
    Vector4  child_pt, child_dir;

    Shape* pSphere = new Shape(++_lastOID, NULL);
    pSphere->setPrivateGeometry(new Sphere(center.x,
                                           center.y,
                                           center.z,
                                           center.w));
    
    pSphere->appendPrivateMaterial(new Specular(0,0,0));
    pSphere->appendPrivateMaterial(new Diffuse(0,0,0));
    pSphere->appendPrivateMaterial(new Ambient(0,0,0));
    //pSphere->appendPrivateMaterial(new Reflection(.12,.12,.12));
    //pSphere->appendPrivateMaterial(new Transparency(.88,.88,.88));
    pSphere->appendPrivateMaterial(new Transparency(1,1,1));
    pSphere->appendPrivateMaterial(new Roughness((float).3));
    pSphere->appendPrivateMaterial(new IndexOfRefraction(REFR_GLASS));
    (void) appendObject(pSphere);

    /* check if children should be generated */
    if (depth > 0) {
        --depth;
                
        /* rotation matrix to new axis from +Z axis */
        if (direction.z >= 1.0) {
            mx.setIdentity();
        } else if (direction.z <= -1.0) {
            mx.rotY(PI);
        } else {
            Vector3 aux(direction.x, direction.y, direction.z);
            z_axis.set(0.0, 0.0, 1.0);
            axis.cross(z_axis, aux);
            axis.normalize();
            angle = acos((double) z_axis.dot(aux));
            mx.rotationGL(angle, axis);
        }

        /* scale down location of new spheres */
        scale = center.w * (1.0 + direction.w);

        for (int i = 0 ; i < 9 ; i++) {
            mx.transform(objset[i], child_pt);
            child_pt.scaleAdd(scale, center);
            /* scale down radius */
            child_pt.w = center.w * direction.w;
            child_dir.set(child_pt);
            child_dir.sub(center);
            child_dir.x /= scale;
            child_dir.y /= scale;
            child_dir.z /= scale;
            child_dir.w = direction.w;
            _build_sphere_flake(depth,child_pt,child_dir,objset);
        }
    }
}


CornellBox::CornellBox(const SDS & proto)
    : Scene(proto)
{
    //float radius = .32;
    
    _build_walls();
    _build_lights();
}

void CornellBox::addMirrorSphere(float radius)
{
    Shape * pSphere = new Shape(++_lastOID, "Mirror Sphere");
    pSphere->setPrivateGeometry(new Sphere(-.51, radius-KB_CORNER,-.5,radius));
    pSphere->appendPrivateMaterial(new Specular(0,0,0));
    pSphere->appendPrivateMaterial(new Diffuse(0,0,0));
    pSphere->appendPrivateMaterial(new Ambient(0,0,0));
    pSphere->appendPrivateMaterial(new Reflection(1.,1.,1.));
    pSphere->appendPrivateMaterial(new Roughness((float)0.04));
    appendObject(pSphere);
}

void CornellBox::addCrystalicSphere(float radius)
{
    Shape * pSphere = new Shape(++_lastOID, "Crystalic Sphere");
    pSphere->setPrivateGeometry(new Sphere(.53, radius-KB_CORNER,-.1,radius));
    pSphere->appendPrivateMaterial(new Specular(0,0,0));
    pSphere->appendPrivateMaterial(new Diffuse(0,0,0));
    pSphere->appendPrivateMaterial(new Ambient(0,0,0));
    pSphere->appendPrivateMaterial(new Transparency(1,1,1));
    pSphere->appendPrivateMaterial(new Roughness((float).3));
    pSphere->appendPrivateMaterial(new IndexOfRefraction(REFR_GLASS));
    appendObject(pSphere);
}

void CornellBox::addSphereFlake(unsigned factor, float radius)
{
    Vector3 objset[9];
    Vector4 center(0.0, 0.0, 0.0, radius/2.0);
    Vector4 direction(0.0, 0.0, 1.0, 1.0/3.0);
    
    _create_sf_object_set(objset);
    _build_sphere_flake(factor, center, direction, objset);
}

---