tuto_rayons.cpp File Reference

#include <vector>
#include <cfloat>
#include <chrono>
#include "vec.h"
#include "mat.h"
#include "color.h"
#include "image.h"
#include "image_io.h"
#include "image_hdr.h"
#include "orbiter.h"
#include "mesh.h"
#include "wavefront.h"

Go to the source code of this file.

Classes
struct	Ray
	rayon. More...
struct	Hit
	intersection avec un triangle. More...
struct	Triangle
	triangle pour le bvh, cf fonction bounds() et intersect(). More...

Functions
Vector	normal (const Mesh &mesh, const Hit &hit)
int	main (const int argc, const char **argv)

Function Documentation

normal()

Vector normal	(	const Mesh &	mesh,
		const Hit &	hit )

Definition at line 86 of file tuto_rayons.cpp.

{
    // recuperer le triangle du mesh
    const TriangleData& data= mesh.triangle(hit.triangle_id);
    
    // interpoler la normale avec les coordonnées barycentriques du point d'intersection
    float w= 1 - hit.u - hit.v;
    Vector n= w * Vector(data.na) + hit.u * Vector(data.nb) + hit.v * Vector(data.nc);
    return normalize(n);
}

main()

int main	(	const int	argc,
		const char **	argv )

Definition at line 97 of file tuto_rayons.cpp.

{
    const char *mesh_filename= "data/cornell.obj";
    if(argc > 1)
        mesh_filename= argv[1];
        
    const char *orbiter_filename= "data/cornell_orbiter.txt";
    if(argc > 2)
        orbiter_filename= argv[2];
    
    Orbiter camera;
    if(camera.read_orbiter(orbiter_filename) < 0)
        return 1;
 
    Mesh mesh= read_mesh(mesh_filename);
    
    // recupere les triangles dans le mesh
    std::vector<Triangle> triangles;
    {
        int n= mesh.triangle_count();
        for(int i= 0; i < n; i++)
            triangles.emplace_back(mesh.triangle(i), i);
    }
 
    //
    Image image(1024, 768);
 
    // recupere les transformations pour generer les rayons
    camera.projection(image.width(), image.height(), 45);
    Transform model= Identity();
    Transform view= camera.view();
    Transform projection= camera.projection();
    Transform viewport= camera.viewport();
    Transform inv= Inverse(viewport * projection * view * model);
    
auto start= std::chrono::high_resolution_clock::now();
    
    // parcours tous les pixels de l'image
    for(unsigned y= 0; y < image.height(); y++)
    for(unsigned x= 0; x < image.width(); x++)
    {
        // generer le rayon au centre du pixel
        Point origine= inv(Point(x + float(0.5), y + float(0.5), 0));
        Point extremite= inv(Point(x + float(0.5), y + float(0.5), 1));
        Ray ray(origine, extremite);
        
        // calculer les intersections avec tous les triangles
        Hit hit;                // proprietes de l'intersection
        float tmax= ray.tmax;   // extremite du rayon
        for(int i= 0; i < int(triangles.size()); i++)
        {
            if(Hit h= triangles[i].intersect(ray, tmax))
            {
                // ne conserve que l'intersection *valide* la plus proche de l'origine du rayon
                assert(h.t > 0);
                hit= h;
                tmax= h.t;
            }
        }
        
    #if 0
        if(hit)
            // coordonnees barycentriques de l'intersection
            image(x, y)= Color(1 - hit.u - hit.v, hit.u, hit.v);
    #endif
 
    #if 1
        if(hit)
        {
            Vector n= normal(mesh, hit);
            // normale interpolee a l'intersection
            image(x, y)= Color(std::abs(n.x), std::abs(n.y), std::abs(n.z));
        }
    #endif
    }
 
auto stop= std::chrono::high_resolution_clock::now();
    int cpu= std::chrono::duration_cast<std::chrono::milliseconds>(stop - start).count();
    printf("%dms\n", cpu);
    
    write_image(image, "render.png");
    write_image_hdr(image, "render.hdr");
    return 0;
}