fsIRenderer.h

Go to the documentation of this file.

/***********************************************************************************
*
*       File:           fsIRenderer.h
*
*       Purpose:        Batch rendering interface.
*
*
* Rendering
* ---------
* 
* fsIRenderableQuantum - simplest things we can render, a sprite, a line, a text entry.
* Each renderable quantum has renderable data which is created dependent on the
* renderable data factory that is active. The factory currently creates vertex stream
* data, or native data objects. This render data is per quantum.
*
* All components run their render command each frame. If they have a renderable
* quantum then the renderable quanta's renderable data member gets processed by the
* renderer which batches up similar render calls - all sprites in the same
* texture, lines together, text together to reduce the number of render / draw calls.
* This produces a list of render jobs where like rendering is batched together.
* 
* e.g.  render job 1 - 10 sprites in texture page 1
*               render job 2 - 5 text sprites
*               render job 3 - 2 sprites in texture page 2
*
* These render jobs are then rendered at the end of the frame by the renderer when
* flush is called. For the native renderer this means basically nothing but calling
* render for the render data which is just native engine objects as the render
* command for native render data hands the object off to the native renderer to
* cache and render - passToEngineRenderer. (so we don't need to batch native data)
*
*
* Vertex rendering
* ----------------
* 
* When the end of frame render jobs are rendered the passToEngineRenderer
* for the render data calls the renderer which gets a command from the cache
* and populates it with the data from the render data. This command is then
* instantly executed.
* 
* fsIRenderData -> fsIVertexRenderData -> fsISpriteRenderData
*                       -> fsCVertexStreamSpriteRenderData
*                       -> (fsINative -> fsCNativeSpriteRenderData)
*
***********************************************************************************/
 
#ifndef fsIRendererhdr
#define fsIRendererhdr
 
#include <vector>
 
#include <fsCore/fsBaseTypes.h>
#include <fsCore/fsStr.h>
 
class fsISpriteRenderData;
class fsITextRenderData;
class fsILineRenderData;
class fsITextEntryRenderData;
class fsI3dSpriteRenderData;
class fsIRenderTextureRenderData;
class fsCMaterial;
class fsIRenderJob;
class fsCUniqueId;
class fsIFont;
class fsAffineMtx2d;
struct fsVec3d;
class fsC3dSceneSprite;
class fsCRenderTexture;
 
class fsI3dLight;
 
class fsIRenderer
{
        friend class fsCRenderJobRenderTextures;
        friend class fsCRenderJobSprites;
        friend class fsCRenderJobText;
        friend class fsCRenderJobLine;
        friend class fsCRenderJobTextEntry;
        friend class fsCRenderJobSprite3d;
 
        friend class fsIRenderTextureRenderData;
        friend class fsISpriteRenderData;
        friend class fsITextRenderData;
        friend class fsILineRenderData;
 
public:
 
        enum eSPRITE_STRIP_PLACE
        {
                eFIRST,
                eSTRIPPED,
                eLAST
        };
 
#if defined fsCacheCheck
        virtual void cacheSizeReset() {}
        virtual fsS32 freeCachePercentageGet() const { return 0; }
#endif
 
#if defined fs3d
        void sprite3dAddToBatch(fsC3dSceneSprite* const pScene);
#endif
 
        void renderTexturedAddToBatch(fsIRenderTextureRenderData* const pRenderTextureRenderData);
        void spriteAddToBatch(fsISpriteRenderData* pSprRenderData);
        void textAddToBatch(fsITextRenderData* pTxtRenderData);
        void textEntryAddToBatch(fsITextEntryRenderData* pTxtEntry);
        void lineAddToBatch(fsILineRenderData* pLineRenderData);
 
        void prepareFor2d();
        void prepareFor3d();
        void frameStart();
        void frameEnd();
        void flush();
 
        static fsIRenderer* instanceGet();
        static void create(fsS32 pMaxSprites, fsS32 pMaxMaterialChanges);
        static void destroy();
 
        virtual ~fsIRenderer();
 
        void begin2d();
 
protected:
 
        enum eRENDER_STATE
        {
                eNONE = 0,
                eDRAW_2D,
                eDRAW_TO_TEXTURE_2D,
                eDRAW_3D
        };
 
        virtual void initialise();
        virtual void uninitialise();
 
        virtual void frameStartDo() = 0;
        virtual void begin2dDo() = 0;
        virtual void end2dDo() = 0;
        virtual void begin3dDo() = 0;
        virtual void end3dDo() = 0;
        virtual void frameEndDo() = 0;
 
        virtual void initialiseDo() = 0;
        virtual void uninitialiseDo() = 0;
 
        fsIRenderer(fsS32 pMaxSprites, fsS32 pMaxMaterialChanges);
 
        std::vector<fsIRenderJob*> mRenderJobs;
 
        eRENDER_STATE mState;
 
        static fsIRenderer* mInstance;
 
        const fsISpriteRenderData** mSpriteRenderData;
        const fsCMaterial** mMaterials;
        fsS32* mSpritesPerMaterial;
 
        fsITextRenderData** mTextRenderData;
        const fsIFont** mFonts;
        fsS32* mTextStringsPerFont;
 
        const fsILineRenderData** mLineRenderData;
        fsS32* mLinesPerBatch;
 
        fsS32 mCurrentSprite;
        fsS32 mCurrentMaterial;
 
        fsS32 mCurrentTextSprite;
        fsS32 mCurrentFont;
 
        fsS32 mCurrentLine;
        fsS32 mCurrentLineBatch;
 
        const fsS32 mMaxSprites;
        const fsS32 mMaxMaterials;
 
private:
 
        void end2d();
        void begin3d();
        void end3d();
 
        virtual void spriteBatchRender(fsS32 pFirstMaterialIndex, fsS32 pLastMaterialIndex) = 0;
        virtual void textBatchRender(fsS32 pFirstFontIndex, fsS32 pLastFontIndex) = 0;
        virtual void lineBatchRender(fsS32 pFirstMaterialIndex) = 0;
        virtual void textEntryBatchRender(fsITextEntryRenderData* const pTextEntry) {}
        virtual void renderTextureBatchRender(fsIRenderTextureRenderData* const pRenderTextureEntry) {}
 
#if defined fs3d
        virtual void sprite3dBatchRender(fsC3dSceneSprite* const p3dScene) = 0;
#endif
        
        fsBool batchJobSwitchCheck(const fsCUniqueId& pJobTypeId) const;
 
        void materialIncrementIfChanged(const fsISpriteRenderData* pSprRenderData);
        void fontIncrementIfChanged(const fsITextRenderData* pTxtRenderData);
 
        void buffersCreate();
        void buffersDestroy() const;
};
 
#endif