laRenderer.h

/*

Jump'n'Run Engine
http://www.atanaslaskov.com/jnr/

BSD LICENSE
Copyright (c) 2007-2013, Atanas Laskov
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL ATANAS LASKOV BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/
#ifndef M_RENDERER_H
#define M_RENDERER_H




//
class laTextureParams{
public:
    unsigned nType;     


    M_BOOL bWrapU;
    M_BOOL bWrapV;

    laTextureParams(unsigned type=M_TEX_SIMPLE, M_BOOL wrapu=M_TRUE, M_BOOL wrapv=M_TRUE) {
        nType  = type;
        bWrapU = wrapu;
        bWrapV = wrapv;
    }

};

//
class laOutline
{
public:

    M_BOOL bEnabled;    
    laColor color;      
    double dWidth;      
    M_BOOL bTopmost;    

    unsigned id;        

    // Renderer flags
    M_BOOL bPass1_Enabled;
    M_BOOL bPass2_Enabled;

    //
    laOutline( M_BOOL bOn = M_TRUE,
        const laColor &col  = laColor(), const double &width    = 1, M_BOOL topmosy = M_FALSE)
    {
        bEnabled = bOn;
        color    = col;
        dWidth   = width;
        bTopmost = topmosy;

        id = 1;
        bPass1_Enabled = bPass2_Enabled = M_TRUE;
    }
};

//
class laRenderer
{
protected:
    M_BOOL _bShowProfiler;

    laFontManager   _fontman;       
    laColor         _rgbBg;         
    laOutline       _outline;       


    class laTexture*    _pVarTex;
    double              _dDetailTex_Scale;
    laPoint3            _ptVarTexOffset;

    // NOTE: Only the laSystemIntegrator ccan access create and discard
    virtual void create() = 0;
    virtual void discard() = 0;
    friend class laSystemIntegrator;

    // NOTE: Texture loading calls are to be used directly only by the laTexutre class;
    // They don't implement checks if the texture is already loaded but only provide the necessary grpahics code.
    //
    friend class laTexture;
    virtual laTexture texLoad(std::string strFile, laTextureParams params)=0;
    virtual void texUse(laTexture *pTex)=0;


    static laPoint3* _arQuadData;   
    static laPoint2* _arQuadUV;     
    static laColor* _arQuadRGB;     
    static unsigned _nMaxQuads;

    //
    unsigned _nW, _nH;                      
    laPoint2 _ptCamAng;                     
    laPoint2 _ptCamAngX_sc, _ptCamAngY_sc;  


public:
    laRenderer();           
    ~laRenderer(void);

    virtual laPoint3 getCameraAngles() = 0;


    virtual void modeInterface() =0;                                                    
    virtual void modeWorld(const laPoint3 &pos, const laPoint3 &ang = laPoint3()) =0;   

    virtual void commit() =0;   



    virtual void modeDepthBuffer(M_BOOL bOn) =0;    
    virtual void modeTexture(M_BOOL bOn) =0;        
    virtual void modeLight(M_BOOL bOn) =0;          
    virtual void modeFog(M_BOOL bOn) =0;            
    virtual void modeBlend(M_BOOL bOn) =0;          

    virtual double modeBlendFilter(const double &dMinVisisbleAlpha) =0;

    virtual void modeOutline(const laOutline &outline) { _outline = outline; }


    virtual void modeProfiler(M_BOOL bOn) { _bShowProfiler = bOn; } 
    M_BOOL isProfilerOn() { return _bShowProfiler; }                


    //        This is a tiled texture displayed on top of the usual object texture. It is suitable
    //        for adding cracks, vegetation and other detail to rendered terrains.
    virtual void vtex(laTexture* pTex = NULL, double scale = 0.2) = 0;  //<! Set detail texture (or invalidate if null)
    virtual void vtexOffset(laPoint3 ofs) { _ptVarTexOffset = ofs; }    


    inline laFont* font(char* strName) { return _fontman.get(strName); }


    virtual void lightMakeProjector(unsigned nLight, const laPoint3 &pos, const laPoint3 &dir, const double &angle=360) = 0;
    virtual void lightMakeSunlight(unsigned nLight, const laPoint3 &pos) = 0;

    virtual void lightAmbient(unsigned nLight, const laColor &rgb) = 0;
    virtual void lightDiffuse(unsigned nLight, const laColor &rgb) = 0;
    virtual void lightSpecular(unsigned nLight, const laColor &rgb) = 0;
    virtual void lightAttenuation(unsigned nLight, double a) = 0;

    virtual void lightSetCount(unsigned n)=0;


    virtual void fogColor(const laColor &rgb) =0;
    virtual void fogRange(const double &start, const double &end) =0;
    virtual M_BOOL getFogMode()=0;


    virtual void styleSet(const laColor &diffuse, const laColor &specular=laColor(255,255,255,255)) =0;
    virtual void styleShininess(unsigned s)=0;
    virtual void styleLine(double dWidth)=0;

    virtual unsigned styleShaderLoad(char* strShaderName) =0;
    virtual void     styleShader(unsigned ShaderID) =0;

    virtual void styleBackground(const laColor &bg) {_rgbBg=bg;};


    virtual void transTranslate(const laPoint3 &pos)=0;
    virtual void transRotate(const double &ang, const laPoint3 &axis)=0;
    virtual void transScale(const laPoint3 &sz)=0;

    virtual void transPush()=0;
    virtual void transPop()=0;


    virtual unsigned compiledActivate(M_BOOL bOn) = 0;
    virtual void compiledDraw(unsigned nID) =0;

    //
    // Volatile" quads are an array of vertex data (4 points per quad) accessible by all objects;
    // Objects that need to change vertex data on every frame (eg. particle Fx, Fonts) can use VQ as a way to save memory
    // and speed up rendering; VQ don't require the client of the renderer to store any fertex data and also all VQ are
    // commited to the rendering device together.
    //

    inline unsigned vquadsCount()  const{ return _nMaxQuads; }

    inline void vquadsAllocate( unsigned nMaxQuads )
    {
        ASSERT(_nMaxQuads<nMaxQuads, "Wrong argument");
        laPoint3 *pv    = new laPoint3[ nMaxQuads*4 ];
        laPoint2 *pt    = new laPoint2[ nMaxQuads*4 ];
        laColor  *pc    = new laColor[ nMaxQuads*4 ];

        if(_arQuadData) {
            memcpy(pv, _arQuadData, sizeof(laPoint3)*_nMaxQuads*4);
            memcpy(pt, _arQuadUV, sizeof(laPoint2)*_nMaxQuads*4);
            memcpy(pc, _arQuadRGB, sizeof(laColor)*_nMaxQuads*4);

            delete [] _arQuadData;
            delete [] _arQuadUV;
            delete [] _arQuadRGB;
        }
        _arQuadData = pv; _arQuadUV = pt; _arQuadRGB = pc;

        _nMaxQuads  = nMaxQuads;
        MLOG("VQ array resized %d", _nMaxQuads);
    }

    inline laPoint3* vquadsData(unsigned nQuad, unsigned nCount = 1) {
        if( (nQuad+nCount)>=_nMaxQuads ) vquadsAllocate( nQuad + nCount + 20 );
        return _arQuadData + nQuad*4;
    }

    inline laPoint2* vquadsTexCoord(unsigned nQuad, unsigned nCount = 1) {
        if( (nQuad+nCount)>=_nMaxQuads ) vquadsAllocate( nQuad + nCount + 20 );
        return _arQuadUV + nQuad*4;
    }

    inline laColor* vquadsCol(unsigned nQuad, unsigned nCount = 1) {
        if( (nQuad+nCount)>=_nMaxQuads ) vquadsAllocate( nQuad + nCount + 20 );
        return _arQuadRGB + nQuad*4;
    }

    virtual void vquadsDraw(unsigned nQuads, laPoint2 *ar_uv = NULL, laColor *ar_color = NULL,
                            M_BOOL bBillboards = M_FALSE, M_BOOL bUseColorArrays = M_FALSE) = 0;

    virtual void vquadsDrawSingle(laPoint2 *ar_uv = NULL) = 0;

    inline void vquadsMakeBillboards(unsigned nQuads, laPoint3 *ar_pos, double *ar_size)
    {
        // Use camera info to buld camera-facing billboards
        // NOTE: The derived class is responsible for keeping track fo camera angles
        //
        PROFILE_REN(laRenderer_vquadsMakeBillboards);
        static double sz;
        laPoint3 *ppt = vquadsData(0, nQuads);

        laPoint3 qv[4] = { laPoint3(-0.5*_ptCamAngY_sc(1), -0.5, -0.5*_ptCamAngY_sc(0)),
                            laPoint3(+0.5*_ptCamAngY_sc(1), -0.5, +0.5*_ptCamAngY_sc(0)),
                            laPoint3(+0.5*_ptCamAngY_sc(1), +0.5, +0.5*_ptCamAngY_sc(0)),
                            laPoint3(-0.5*_ptCamAngY_sc(1), +0.5, -0.5*_ptCamAngY_sc(0)) };

        for(unsigned i=0; i<nQuads; i++) {
            sz = ar_size[i];

            *(ppt++) = qv[0]*sz + ar_pos[i];
            *(ppt++) = qv[1]*sz + ar_pos[i];
            *(ppt++) = qv[2]*sz + ar_pos[i];
            *(ppt++) = qv[3]*sz + ar_pos[i];
        }
    }

    inline void vquadsMakeXYRect( unsigned nIndex,
        const laPoint3 &pos, const laPoint3 &sz, const laPoint2 &uv, const laPoint2 &uv_sz )
    {
        PROFILE_REN(laRenderer_vquadsMakeXYRect);
        laPoint3 *pquad = vquadsData(nIndex);
        laPoint2 *puv = vquadsTexCoord(nIndex);

        *(pquad++) = pos;
        *(pquad++) = pos + laPoint3(sz.x(), 0);
        *(pquad++) = pos + laPoint3(sz);
        *(pquad++) = pos + laPoint3(0, sz.y());

        *(puv++) = uv + laPoint2(0, uv_sz.y());
        *(puv++) = uv + uv_sz;
        *(puv++) = uv + laPoint2(uv_sz.x(), 0);
        *(puv++) = uv;

    }

    // Misc unused
    //
    virtual void trianglesDraw( laPoint3* ar_v, laPoint2* ar_tv, laPoint3* ar_n, unsigned nvert )=0;

   virtual void drawRect(const laPoint3 &pos, const laPoint3 &sz, const laPoint2 &uv, const laPoint2 &uv_sz,
        double an1=0, double an2=0, M_BOOL bAlignX=M_TRUE)=0;

   virtual void drawLine(const laPoint3 &a, const laPoint3 &b)=0;

    virtual void drawEllipse2(laPoint3 a, laPoint3 b, double z=0, bool flat=true, bool lighten=true) =0;

    //Misc
    //
    //unsigned     displayGetW(){return _nW;};
    //unsigned     displayGetH(){return _nH;};
    //void         displaySetScale(double s){_dScale=s;};
    //double       displayGetScale(){return _dScale;};
    //virtual void displayClip(laPoint3 a, laPoint3 b)=0;
    //virtual void displayGetClip(double *x1, double *y1, double *x2, double *y2);

    //double displayGetIntensity() {return _dIntensity;}
    //void displaySetIntensity(double i);
    //double displayGetBrightness() {return _dBrightness;}
    //void displaySetBrightness(double b);

    static M_BOOL _bDbgEnable;
    static double _dDbgOfsX;
    static double _dDbgOfsY;
};
#endif //#ifndef M_RENDERER_H