renderer.h

Go to the documentation of this file.

/*****************************************************************************
    The renderer assumes a right handed coordinate system:
    - X goes right
    - Y goes top
    - Z goes backward
******************************************************************************/

#ifndef LE_RENDERER_H
#define LE_RENDERER_H

#include "global.h"
#include "config.h"

#include "color.h"
#include "geometry.h"
#include "mesh.h"
#include "bset.h"
#include "rasterizer.h"
#include "trilist.h"
#include "verlist.h"

/*****************************************************************************/
typedef enum {
    LE_BACKCULLING_NONE = 0,        
    LE_BACKCULLING_CCW,             
    LE_BACKCULLING_CW,              
    LE_BACKCULLING_CCW_ALPHA,       
    LE_BACKCULLING_CW_ALPHA,        
} LE_BACKCULLING_MODES;

/*****************************************************************************/
class LeRenderer
{
public:
    LeRenderer(int width = LE_RESOX_DEFAULT, int height = LE_RESOY_DEFAULT);
    ~LeRenderer();

    void render(const LeMesh * mesh);
    void render(const LeBSet * bset);
    void flush();

    int getViewportCoordinates(const LeVertex & pos, LeVertex & viewCoords);

    void setViewPosition(const LeVertex & pos);
    void setViewAngle(const LeVertex & angleYZX);
    void updateViewMatrix();

    void setViewMatrix(const LeMatrix & view);

    void setViewport(int left, int top, int right, int bottom);
    void setViewClipping(float near, float far);
    void setViewProjection(float fov);
    void setViewOffset(float offset);

    void setBackcullingMode(LE_BACKCULLING_MODES mode);

    void setFog(bool enable);
    void setFogProperties(LeColor color, float near, float far);

    void setMipmapping(bool enable);

    void setTriangleList(LeTriList * trilist);
    LeTriList * getTriangleList();

private:
    bool checkMemory(int noVertexes, int noTriangles);

    int build(const LeMesh * mesh, LeVertex vertexes[], LeTriangle tris[], int indices[]);
    int build(const LeBSet * bset, LeVertex vertexes[], LeTriangle tris[], int indices[]);

    void updateFrustrum();

    void transform(const LeMatrix &matrix, const LeVertex srcVertexes[], LeVertex dstVertexes[], int nb);
    int project(LeTriangle tris[], const int srcIndices[], int dstIndices[], int nb);
    int clip3D(LeTriangle tris[], const int srcIndices[], int dstIndices[], int nb, LePlane &plane);
    int clip2D(LeTriangle tris[], const int srcIndices[], int dstIndices[], int nb, LeAxis &axis);
    int backculling(LeTriangle tris[], const int srcIndices[], int dstIndices[], int nb);

    LeVerList intVerlist;               
    LeTriList intTrilist;               
    LeVerList * usedVerlist;            
    LeTriList * usedTrilist;            
    int extra;                          
    int extraMax;                       
    LeColor * colors;                   
    LeVertex viewPosition;              
    LeVertex viewAngle;                 
    LeMatrix viewMatrix;                
    LePlane viewFrontPlan;              
    LePlane viewBackPlan;               
    LePlane viewLeftPlan;               
    LePlane viewRightPlan;              
    LePlane viewTopPlan;                    
    LePlane viewBotPlan;                    
    LeAxis viewLeftAxis;                
    LeAxis viewRightAxis;               
    LeAxis viewTopAxis;                 
    LeAxis viewBottomAxis;              
    float viewFov;                      
    float ztx;                          
    float zty;                          
    float vOffset;                      
    LE_BACKCULLING_MODES backMode;      
    bool mipmappingEnable;              
    bool fogEnable;                     
};

#endif // LE_RENDERER_H