pipeline.cpp File Reference

#include <cstdio>
#include <cmath>
#include "vec.h"
#include "mat.h"
#include "mesh.h"
#include "image.h"
#include "image_io.h"
#include "orbiter.h"
#include "wavefront.h"

Go to the source code of this file.

Classes
struct	ZBuffer
struct	Fragment
struct	Pipeline
struct	BasicPipeline

Functions
float	area (const Point p, const Point a, const Point b)
bool	visible (const Point p)
int	main (int argc, char **argv)

Function Documentation

area()

float area	(	const Point	p,
		const Point	a,
		const Point	b )

Definition at line 107 of file pipeline.cpp.

{
    Vector pa= Vector(p, a); pa.z= 0;
    Vector pb= Vector(p, b); pb.z= 0;
    return cross(pa, pb).z;
}

visible()

bool visible

(

const Point

p

)

Definition at line 115 of file pipeline.cpp.

{
    if(p.x < -1 || p.x > 1) return false;
    if(p.y < -1 || p.y > 1) return false;
    if(p.z < -1 || p.z > 1) return false;
    return true;
}

main()

int main	(	int	argc,
		char **	argv )

Definition at line 124 of file pipeline.cpp.

{
    Image color(640, 320);
    ZBuffer depth(color.width(), color.height());
    
    Mesh mesh= read_mesh("data/bigguy.obj");
    if(mesh == Mesh::error())
        return 1;
    printf("  %d positions\n", mesh.vertex_count());
    printf("  %d indices\n", mesh.index_count());
    
    // regle le point de vue de la camera pour observer l'objet
    Point pmin, pmax;
    mesh.bounds(pmin, pmax);
    Orbiter camera(pmin, pmax);
 
    BasicPipeline pipeline( 
        mesh, 
        Identity(), 
        camera.view(), 
        camera.projection(color.width(), color.height(), 45) );
    
    Transform viewport= Viewport(color.width(), color.height());
    
    // draw(pipeline, mesh.vertex_count());
    for(unsigned int i= 0; i +2 < (unsigned int) mesh.vertex_count(); i= i +3)
    {
        // transforme les 3 sommets du triangle
        Point a= pipeline.vertex_shader(i);
        Point b= pipeline.vertex_shader(i+1);
        Point c= pipeline.vertex_shader(i+2);
        
        // visibilite
        if(visible(a) == false && visible(b) == false && visible(c) == false)
            continue;
        // faux dans pas mal de cas...
        // question : comment faire un test correct ?
        // indication : si tous les sommets sont du meme cote d'une face de la region observee par la camera, on est sur que le triangle n'est pas visible.
        // comment definir la region observee par la camera ? quelle est sa forme (dans quel repere) ? les coordonnees de ses sommets ?
        
        // passage dans le repere image
        a= viewport(a);
        b= viewport(b);
        c= viewport(c);
        
        // question: comment ne pas dessiner le triangle s'il est mal oriente ?
        // aire du triangle abc
        float n= area(a, b, c);
        if(n < 0)
            continue;
        
        // dessiner le triangle
        // solution naive, parcours tous les pixels de l'image
        // question : comment eviter de tester tous les pixels ? 
        // indice : il est sans doute possible de determiner que le triangle ne touche pas un bloc de pixels en ne testant que les 4 coins du bloc...
        // question : dessiner de tout petits triangles est tres long. comment gagner du temps en determinant qu'un triangle est suffisament petit/etire pour "passer" entre les pixels ?
        // (remarque: oui, ca arrive tout le temps...)
        for(int y= 0; y < color.height(); y++)
        for(int x= 0; x < color.width(); x++)
        {
            // fragment 
            Fragment frag;
            frag.u= area(Point(x, y, 0), a, b);      // distance c / ab
            frag.v= area(Point(x, y, 0), b, c);      // distance a / bc
            frag.w= area(Point(x, y, 0), c, a);      // distance b / ac
            
            if(frag.u > 0 && frag.v > 0 && frag.w > 0)
            {
                // normalise les coordonnees barycentriques du fragment
                frag.u= frag.u / n;
                frag.v= frag.v / n;
                frag.w= frag.w / n;
                
                frag.x= x;
                frag.y= y;
                // interpole z
                frag.z= frag.u * c.z + frag.v * a.z + frag.w * b.z;
                
                // evalue la couleur du fragment du triangle
                Color frag_color= pipeline.fragment_shader(i/3, frag);
                
                // ztest
                if(frag.z < depth(x, y))
                {
                    color(x, y)= Color(frag_color, 1);
                    depth(x, y)= frag.z;
                }
                
                // question : pour quelle raison le ztest est-il fait apres l'execution du fragment shader ? est-ce obligatoire ?
                // question : peut on eviter d'executer le fragment shader sur un bloc de pixels couverts par le triangle ? 
                //      dans quelles conditions sait-on qu'il n'y a rien a dessiner dans un bloc de pixels ?
                //      == aucun fragment du triangle appartenant au bloc, ne peut modifier l'image et le zbuffer ?
            }
        }
    }
    
    write_image(color, "render.png");
    return 0;
}