Subversion Repositories gelsvn

#include "mesh.h"
#include "scene.h"

#include <Geometry/obj_load.h>

using namespace CGLA;
using namespace Geometry;

extern scene* current;

mesh::mesh(void)
{
    msh_ = new TriMesh;
    tangents_ = new IndexedFaceSet;
    mat_ = 0;
    exitance_ = Vec3f(0.f);
}

mesh::mesh(const std::string& fn)
{
    msh_ = new TriMesh;
    tangents_ = new IndexedFaceSet;
    mat_ = 0;
    exitance_ = Vec3f(0.f);

    TriMesh msh;
    obj_load(fn, msh);
    set_trimesh(msh);
}

mesh::~mesh(void)
{
    delete tangents_;
    delete msh_;
}

const CGLA::Vec3f& mesh::triangle_normal(size_t i) const
{
    return triangle_normals_.at(i);
}

const TriMesh& mesh::get_trimesh(void) const
{
    return *msh_;
}

void mesh::set_trimesh(const TriMesh& tm)
{
    *msh_ = tm;

    msh_->compute_normals();
    //
    //int tris = msh_->geometry.no_faces();

    //std::vector<Vec3f> tan1;
    //tan1.resize(tris);
    //triangle_normals_.resize(tris);

    //for (int t=0; t<tris; t++)
    //{
    //  const Vec3i& f  = msh_->geometry.face(t);
    //  const Vec3f p0 = msh_->geometry.vertex(f[0]);
    //  const Vec3f a  = msh_->geometry.vertex(f[1]) - p0;
    //  const Vec3f b  = msh_->geometry.vertex(f[2]) - p0;
    //  Vec3f tri_normal = cross(a,b);
    //  float l = sqr_length(tri_normal);
    //  if(l > 0.0f)
    //      tri_normal /= sqrt(l);
    //  triangle_normals_[t] = trs_.mul_3D_vector(tri_normal);

    //}
#if 0
    if (msh_->texcoords.no_faces() == 0)
        return;

    for (long a = 0; a < triangleCount; a++)
    {
        long i1 = triangle->index[0];
        long i2 = triangle->index[1];
        long i3 = triangle->index[2];

        const Point3D& v1 = vertex[i1];
        const Point3D& v2 = vertex[i2];
        const Point3D& v3 = vertex[i3];

        const Point2D& w1 = texcoord[i1];
        const Point2D& w2 = texcoord[i2];
        const Point2D& w3 = texcoord[i3];

        float x1 = v2.x - v1.x;
        float x2 = v3.x - v1.x;
        float y1 = v2.y - v1.y;
        float y2 = v3.y - v1.y;
        float z1 = v2.z - v1.z;
        float z2 = v3.z - v1.z;

        float s1 = w2.x - w1.x;
        float s2 = w3.x - w1.x;
        float t1 = w2.y - w1.y;
        float t2 = w3.y - w1.y;

        float r = 1.0F / (s1 * t2 - s2 * t1);
        Vector3D sdir((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r,
            (t2 * z1 - t1 * z2) * r);
        Vector3D tdir((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r,
            (s1 * z2 - s2 * z1) * r);

        tan1[i1] += sdir;
        tan1[i2] += sdir;
        tan1[i3] += sdir;

        tan2[i1] += tdir;
        tan2[i2] += tdir;
        tan2[i3] += tdir;

        triangle++;
    }
#endif
}

const material* mesh::get_material(void) const
{
    return mat_;
}

void mesh::set_material(const material* m)
{
    mat_ = m;
}

bool mesh::sample(const ray& r,
                  const hit_info& hi,
                  Vec3f& Li,
                  Vec3f& w) const
{
    //skip non-emitters
    if (intensity(exitance_) == 0.f)
        return false;

    //pick a random face
    int face = gel_rand() % msh_->geometry.no_faces();
    float pface = 1.f / float(msh_->geometry.no_faces());

    //pick a random position in triangle
    float r1 = std::sqrt(mt_random());
    float r2 = mt_random();
    Vec3f barycentric(1.f - r1, (1.f - r2) * r1, r1 * r2);

    //find position
    Vec3i fidx = msh_->geometry.face(face);
    Vec3f vertices[3];
    Vec3f light_pos(0.f);
    for (int i=0; i<3; ++i)
    {
        vertices[i] = msh_->geometry.vertex(fidx[i]);
        light_pos += barycentric[i] * msh_->geometry.vertex(fidx[i]);
    }

    light_pos = trs_.mul_3D_point(light_pos);

    float parea = 2.f / length(cross(vertices[2]-vertices[1], 
        vertices[0]-vertices[1]));

    //find normal
    Vec3i nidx = msh_->normals.face(face);
    Vec3f light_normal(0.f);
    for (int i=0; i<3; ++i)
        light_normal += barycentric[i] * msh_->normals.vertex(nidx[i]);
    light_normal = trs_.mul_3D_vector(light_normal);
    light_normal.normalize();

    //find w
    w = normalize(light_pos - hi.position);
    //float costheta1 = dot(hi.shading_normal, w);
    //if (costheta1 < 0.f)
    //  return false;

    float costheta2 = dot(light_normal, -w);
    if (costheta2 < 0.f)
        return false;

    float d2 = sqr_length(light_pos - hi.position);

    //trace shadow feeler..
    ray s;
    s.origin = hi.position + epsilon * w;
    s.direction = w;
    s.distance = std::sqrt(d2) - 2.f * epsilon;
    s.depth = r.depth + 1;
    if (current->intersect(s))
        return false;

    //compute emitted
    Li = exitance_ / float(M_PI) * costheta2 / (d2 * pface * parea);

    return true;
}

Vec3f mesh::exitance(void) const
{
    return exitance_;
}

void mesh::set_exitance(const CGLA::Vec3f& E)
{
    exitance_ = E;
}

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