fsCBgfx2d.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           fsCBgfx2d.h
*
*       Purpose:        Shared 2d drawing context for the bgfx backend.
*
*                               bgfx has no immediate-mode 2d drawing, so this owns the
*                               one shader program (the embedded imgui pos/uv/colour
*                               shaders that ship precompiled for every bgfx renderer),
*                               the vertex layout and a white fallback texture, and
*                               submits textured quads through transient buffers.
*
*                               Vertices are supplied in sprite-local space and
*                               transformed on the CPU by the sprite's render matrix -
*                               the embedded shader only applies u_viewProj, which the
*                               renderer sets to a top-left-origin ortho each frame.
*
*********************************************************************/
 
#ifndef fsCBgfx2dhdr
#define fsCBgfx2dhdr
 
#include <vector>
 
#include <bgfx/bgfx.h>
 
#include <fsCore/fsBaseTypes.h>
#include <fsCore/fsVec2d.h>
 
namespace fsNBgfx2d
{
        static const bgfx::ViewId mViewId2d = 0;
 
        struct fsSVertex2d
        {
                fsF32 mX;
                fsF32 mY;
                fsF32 mU;
                fsF32 mV;
                fsU32 mAbgr;
        };
 
        void initialise();
        void uninitialise();
 
        // Vsync is OFF by default: it paces to whatever display the window sits
        // on (a 4K/5K screen over HDMI may be 30Hz, capping the game at 30fps).
        // FSBGFX_VSYNC=1 opts back in. When off, the renderer paces the loop to
        // targetFpsGet() (default 60, FSBGFX_FPS overrides, 0 = uncapped).
        fsU32 resetFlagsGet();
        fsS32 targetFpsGet();
 
        bgfx::TextureHandle whiteTextureGet();
 
        fsU32 abgrGet(fsU8 pR, fsU8 pG, fsU8 pB, fsU8 pA);
 
        void quadSubmit(const fsF32* pModelMtx, bgfx::TextureHandle pTexture, fsU32 pSamplerFlags,
                        fsF32 pX, fsF32 pY, fsF32 pW, fsF32 pH,
                        fsF32 pU0, fsF32 pV0, fsF32 pU1, fsF32 pV1,
                        fsU32 pColourAbgr);
 
        void lineStripSubmit(const fsF32* pModelMtx, const std::vector<fsVec2d>& pVerts, fsU32 pColourAbgr);
 
        // Batched path - the preferred way to draw. Quads are transformed by their
        // sprite's matrix immediately and accumulate while consecutive draws share
        // the same texture/sampler, going to the GPU as one draw call per run.
        // Per-quad submits (sprites, particles, glyphs) otherwise dominate frame
        // time on busy scenes. Draw order is preserved: the batch flushes itself
        // whenever the texture changes, and must be flushed explicitly before any
        // non-batched draw (lines) and at frame end.
        void batchQuad(const fsF32* pModelMtx, bgfx::TextureHandle pTexture, fsU32 pSamplerFlags,
                       fsF32 pX, fsF32 pY, fsF32 pW, fsF32 pH,
                       fsF32 pU0, fsF32 pV0, fsF32 pU1, fsF32 pV1,
                       fsU32 pColourAbgr);
 
        void batchFlush();
}
 
#endif