Subversion Repositories gelsvn

#include "mesh.hpp"
#include "scene.hpp"

#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 = rand() % msh_->geometry.no_faces();
        float pface = 1.f / float(msh_->geometry.no_faces());

        //pick a random position in triangle
        float r1 = std::sqrt(random());
        float r2 = 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