Subversion Repositories gelsvn

#include <GEL/Geometry/BSPTree.h>

#include "scene.h"

#include "mesh.h"

using namespace Geometry;

using namespace CGLA;

scene::scene(void) : cam_(0)

{

    accel_ = new BSPTree;

}

scene::~scene(void)

{

    delete accel_;

}

void scene::insert(const luminaire* obj)

{

    objs_.push_back(obj);

}

size_t scene::luminaires(void) const

{

    return objs_.size();

}

const luminaire* scene::get_luminaire(size_t i) const

{

    return objs_.at(i);

}

bool scene::intersect(const ray& r)

{

    Ray s;

    s.direction = r.direction;

    s.origin = r.origin;

    s.dist = r.distance;

    s.trace_depth = r.depth;

    return accel_->intersect(s);

}

bool scene::intersect(const ray& r, hit_info& hi)

{

    Ray s;

    s.direction = r.direction;

    s.origin = r.origin;

    s.trace_depth = r.depth;

    s.dist = r.distance;

    bool hit = accel_->intersect(s);

    if (hit)

    {

        //find the mesh which was hit

        const mesh& msh = dynamic_cast<const mesh&>(*objs_[s.id]);

        //set hit position and normals

        hi.distance = s.dist;

        hi.position = s.hit_pos;

        hi.shading_normal = s.hit_normal;

        const IndexedFaceSet& geometry = msh.get_trimesh().geometry;

        const Vec3i& f  = geometry.face(s.hit_face_id);

        const Vec3f p0 = geometry.vertex(f[0]);

        const Vec3f a  = geometry.vertex(f[1]) - p0;

        const Vec3f b  = geometry.vertex(f[2]) - p0;

        Vec3f face_normal = cross(a,b);

        float l = sqr_length(face_normal);

        if(l > 0.0f)

            face_normal /= sqrt(l);

        hi.geometric_normal = msh.transform().mul_3D_vector(face_normal);

        //hi.geometric_normal = msh.triangle_normal(s.hit_face_id);

        hi.inside = dot(hi.geometric_normal, -s.direction) < 0.f;

        if (hi.inside)

        {

            hi.geometric_normal = -hi.geometric_normal;

            hi.shading_normal = -hi.shading_normal;

        }

        bool has_texcoords = msh.get_trimesh().texcoords.no_faces() > 0;

        if (has_texcoords)

        {

            //compute texture coords..

            const IndexedFaceSet& texcoords = msh.get_trimesh().texcoords;

            const Vec3i& t = texcoords.face(s.hit_face_id);

            Vec3f uv0 = texcoords.vertex(t[0]);

            Vec3f uv1 = texcoords.vertex(t[1]);

            Vec3f uv2 = texcoords.vertex(t[2]);

            hi.texcoords(0) = (1.f-s.u-s.v)*uv0(0) + s.u*uv1(0) + s.v*uv2(0);

            hi.texcoords(1) = (1.f-s.u-s.v)*uv0(1) + s.u*uv1(1) + s.v*uv2(1);

            //compute tangent vectors..

        }

        else

        {

            //hmm.. no uvs. not good!

            hi.texcoords = Vec2f(0.f);

            //orthogonal(hi.shading_normal, hi.tangent, hi.bitangent);

        }

        //sample material to get bsdf

        const material* mat = msh.get_material();

        if (mat)

            mat->sample(r, hi);

        //convert from radiant exitance to radiance

        if (!hi.inside)

            hi.emitted = msh.exitance() / float(M_PI);

    }

    return hit;

}

const camera* scene::get_camera(void) const

{

    return cam_;

}

void scene::set_camera(const camera* c)

{

    cam_ = c;

}

void scene::initialize(int mo, int md)

{

    assert(cam_);

    assert(!objs_.empty());

    std::cout << "Building BSP tree.." << std::endl;

    std::vector<const TriMesh*> msh;

    std::vector<Mat4x4f> trs;

    std::vector<const luminaire*>::iterator it;

    for (it=objs_.begin(); it!=objs_.end(); ++it)

    {

        const luminaire* obj = *it;

        const mesh* mxx = dynamic_cast<const mesh*>(obj);

        if (!mxx)

            continue;

        msh.push_back(&mxx->get_trimesh());

        trs.push_back(mxx->transform());

    }

    accel_->init(msh, trs, mo, md);

    accel_->build();

    std::cout << "Done!" << std::endl;

}

//02566 framework, Anders Wang Kristensen, awk@imm.dtu.dk, 2007