fsNAxmolRenderView.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           fsNAxmolRenderView.h
*
*       Purpose:        Shared Axmol RenderView helpers.
*
*********************************************************************/
 
#ifndef fsNAxmolRenderViewhdr
#define fsNAxmolRenderViewhdr
 
#ifdef AXMOL_V3
        #include <platform/RenderViewCore.h>
#else
        #include <platform/RenderView.h>
#endif
 
#include <fsCore/fsBaseTypes.h>
 
namespace fsNAxmolRenderView
{
#ifdef AXMOL_V3
using fsTRenderView = ax::RenderViewCore;
#else
using fsTRenderView = ax::RenderView;
#endif
 
struct fsSAspectFitRect
{
        fsF32 x = 0.0f;
        fsF32 y = 0.0f;
        fsF32 w = 0.0f;
        fsF32 h = 0.0f;
};
 
// Fit a target aspect ratio inside a container, centred (letterbox/pillarbox).
inline fsSAspectFitRect aspectFitRectGet(const fsF32 pTargetAspect, const fsF32 pContainerW, const fsF32 pContainerH)
{
        fsSAspectFitRect rect;
        rect.w = pContainerW;
        rect.h = pContainerH;
        if (pContainerW <= 0.0f || pContainerH <= 0.0f || pTargetAspect <= 0.0f)
        {
                return rect;
        }
 
        const fsF32 containerAspect = pContainerW / pContainerH;
        if (containerAspect < pTargetAspect)
        {
                rect.h = pContainerW / pTargetAspect;
                rect.y = (pContainerH - rect.h) / 2.0f;
        }
        else if (containerAspect > pTargetAspect)
        {
                rect.w = pContainerH * pTargetAspect;
                rect.x = (pContainerW - rect.w) / 2.0f;
        }
        return rect;
}
 
inline const ax::Rect& viewportRectGet(fsTRenderView* const pRenderView)
{
#ifdef AXMOL_V3
        return pRenderView->getViewportRect();
#else
        return pRenderView->getViewPortRect();
#endif
}
 
inline void pixelScaleGet(fsTRenderView* const pRenderView, fsF32& pScaleX, fsF32& pScaleY)
{
        pScaleX = 1.0f;
        pScaleY = 1.0f;
        if (!pRenderView)
        {
                return;
        }
 
#ifndef AXMOL_V3
        // Desktop Axmol v2 reports frame/visible sizes in points, so their ratio
        // can remain 1 even when the backing framebuffer is Retina-scaled.
        const fsF32 retinaScale = static_cast<fsF32>(pRenderView->getRetinaFactor());
        if (retinaScale > 0.0f)
        {
                pScaleX = retinaScale;
                pScaleY = retinaScale;
        }
#endif
 
        const auto visibleSize = pRenderView->getVisibleSize();
#ifdef AXMOL_V3
        const auto frameSize = pRenderView->getWindowSize();
#else
        const auto frameSize = pRenderView->getFrameSize();
#endif
        if (visibleSize.width > 0.0f && frameSize.width > 0.0f)
        {
                const fsF32 frameScaleX = static_cast<fsF32>(frameSize.width / visibleSize.width);
                if (frameScaleX > pScaleX)
                {
                        pScaleX = frameScaleX;
                }
        }
        if (visibleSize.height > 0.0f && frameSize.height > 0.0f)
        {
                const fsF32 frameScaleY = static_cast<fsF32>(frameSize.height / visibleSize.height);
                if (frameScaleY > pScaleY)
                {
                        pScaleY = frameScaleY;
                }
        }
 
#ifdef AXMOL_V3
        if (pRenderView->getRenderScale() > 0.0f)
        {
                pScaleX = pRenderView->getRenderScale();
                pScaleY = pRenderView->getRenderScale();
        }
#endif
}
}
 
#endif