Cppcheck report - Fission: libs/fsAppCore/fsIDisplay.cpp

#include "fsIDisplay.h"

#include <fsCore/fsIHardware.h>
#include <fsCore/src/debug/fsTrace.h>
#include <fsCore/src/fsNCoreUtils.h>
#include <fsCore/src/fsCUserSavedData.h>
#include <fsCore/src/fsCAppSettings.h>

#include <fsAppCore/src/fsCProfileManager.h>

#if defined fsFRAMEWORK_CX
	#include <fsRenderer/impl/cocos2d-x/fsCDisplay.h>
#elif defined fsFRAMEWORK_AX
	#include <fsRenderer/impl/axmol/fsCDisplay.h>
#elif defined fsFRAMEWORK_MG
	#include <fsRenderer/impl/magnum/fsCDisplay.h>
#elif defined fsFRAMEWORK_RL
    #include <fsRenderer/impl/raylib/fsCDisplay.h>
#elif defined fsFRAMEWORK_BF
    #include <fsRenderer/impl/bgfx/fsCDisplay.h>
#else
	#error Unhandled platform.
#endif

#include "src/fsCGuiMessageDispatcher.h"
#include "src/fsCAppCoreMain.h"

const fsCUniqueId fsIDisplay::mEventFullScreenToggleMsg("FullScreenToggle");
const fsStr fsIDisplay::mAppCanvasWKey("appCanvasW");
const fsStr fsIDisplay::mAppCanvasHKey("appCanvasH");


void fsIDisplay::defaultCameraFlagSet(fsU32 pFlag)
{
    defaultCameraFlagSetDo(pFlag);
}

fsBool fsIDisplay::fixedAspectGet()
{
	return fsCAppCoreMain::instanceGet()->settingsGet()->boolGetWithDefault("fixedAspect", false);
}

fsBool fsIDisplay::windowModeAvailableGet() const
{
#if defined fsFRAMEWORK_CX || defined fsFRAMEWORK_AX || defined fsFRAMEWORK_RL || defined fsFRAMEWORK_BF
	return true;
#else
 	return mStartupDimensions.x >= mDesignedDisplayMode.widthGet() &&
 		mStartupDimensions.y >= (mDesignedDisplayMode.heightGet() + 32); // bit extra for the title bar..
#endif
}

void fsIDisplay::fullScreenToggle()
{
#if !defined fsRELEASE
	if (mSimulatingFixedDisplay)
	{
		return;
	}
#endif

	if (fsCAppCoreMain::instanceGet()->hardwareGet()->windowedModePossibleGet())
	{
		const fsBool newFullScreenSetting = !fsCProfileManager::instanceGet()->userSavedDataGet()->boolGet(
			fsCUserSavedData::mFullScreenKey);
		screenModeSet(newFullScreenSetting);
		fsCProfileManager::instanceGet()->userSavedDataGet()->boolSet(fsCUserSavedData::mFullScreenKey,
		                                                              newFullScreenSetting);
		fsCGuiMessageDispatcher::instanceGet()->messageDispatch(mEventFullScreenToggleMsg,
		                                                        fsIMessageDispatcher::mNullParam);
	}
}

fsS32 fsIDisplay::designCanvasWidthGet() const
{
	return mDesignedDisplayMode.widthGet();
}

fsS32 fsIDisplay::designCanvasHeightGet() const
{
	return mDesignedDisplayMode.heightGet();
}

fsS32 fsIDisplay::visibleCanvasWidthGet() const
{
	if (displayTypeIsDesktopGet())
	{
		if (!mFullScreen)
		{
			return mDesktopWindowDisplayMode.widthGet() / retinaScaleFactorGet();
		}
	}
	return mBestDeviceDisplayMode->widthGet() / retinaScaleFactorGet();
}

fsS32 fsIDisplay::visibleCanvasHeightGet() const
{
	if (displayTypeIsDesktopGet())
	{
		if (!mFullScreen)
		{
			return mDesktopWindowDisplayMode.heightGet() / retinaScaleFactorGet();
		}
	}
	return mBestDeviceDisplayMode->heightGet() / retinaScaleFactorGet();
}

const fsVec2d& fsIDisplay::scaleGet() const
{
	return fsINode::scaleGet();
}

const fsAffineMtx2d& fsIDisplay::renderMatrixGet() const
{
	return fsINode::renderMatrixGet();
}

void fsIDisplay::desktopScreenModesEnumerate()
{
	desktopScreenModesEnumerateDo();
	mScreenModes.sort(fsCDisplayMode::sortFuncLowestResolutionFirst);
}

void fsIDisplay::initialise()
{
	fsTrace("Start display initialise")

	if (displayTypeIsDesktopGet())
	{
		desktopScreenModesEnumerate();

		if (!simulatedFixedDisplayConfigure())
		{
			designedScreenModeDetermine();
			displayModeLocate(mBestDeviceDisplayMode, &fsIDisplay::desktopResolutionCriteria, false);
			fsLogMsg("Best desktop resolution located as:%dx%d.",
			         mBestDeviceDisplayMode->widthGet(), mBestDeviceDisplayMode->heightGet());

			windowModeLocate();
			fsLogMsg("Best window resolution located as:%dx%d.",
			         mDesktopWindowDisplayMode.widthGet(), mDesktopWindowDisplayMode.heightGet());

			screenModeSet(
				fsCProfileManager::instanceGet()->userSavedDataGet()->boolGet(fsCUserSavedData::mFullScreenKey));
		}
	}
	else
	{
		const fsPoint fixedDisplaySize = fixedDisplaySizeGet();
		screenModeAdd(fixedDisplaySize.x, fixedDisplaySize.y, 32);
		designedScreenModeDetermine();
		mBestDeviceDisplayMode = mScreenModes.back();
	}

	fsTrace("End display initialise")
}

fsBool fsIDisplay::wideScreenGet() const
{
	if (mFullScreen)
	{
		return mBestDeviceDisplayMode->isWideScreenGet();
	}
	return mDesktopWindowDisplayMode.isWideScreenGet();
}

fsBool fsIDisplay::screenModeSet(fsBool pFullScreen)
{
	fsTrace("Start screen mode set")
	if (displayTypeIsDesktopGet())
	{
#if !defined fsRELEASE
		if (mSimulatingFixedDisplay)
		{
			mFullScreen = false;
			desktopScreenModeSetDo(mBestDeviceDisplayMode, false);
			matrixSetForDisplaySize(mBestDeviceDisplayMode);
		}
		else
#endif
		if (pFullScreen)
		{
			mFullScreen = true;
			desktopScreenModeSetDo(mBestDeviceDisplayMode, true);
			matrixSetForDisplaySize(mBestDeviceDisplayMode);
		}
		else
		{
			mFullScreen = false;
			desktopScreenModeSetDo(&mDesktopWindowDisplayMode, false);
			matrixSetForDisplaySize(&mDesktopWindowDisplayMode);
		}
	}
	else
	{
		matrixSetForDisplaySize(mBestDeviceDisplayMode);
	}

#if defined fsScreenTextureEffect
	fsCAppCoreMain::instanceGet()->renderTargetResize();
#endif

	fsTrace("End screen mode set")<--- syntax error
	return false;
}

fsBool fsIDisplay::failSafeResolutionCriteria(fsCDisplayMode* const pScreenMode) const
{
	return mDesignedDisplayMode.widthGet() <= pScreenMode->widthGet() &&
		mDesignedDisplayMode.heightGet() <= pScreenMode->heightGet();
}

fsBool fsIDisplay::desktopResolutionCriteria(fsCDisplayMode* const pScreenMode) const
{
	return mDesignedDisplayMode.isWideScreenGet() == pScreenMode->isWideScreenGet() &&
		mDesignedDisplayMode.widthGet() <= pScreenMode->widthGet() &&
		mDesignedDisplayMode.heightGet() <= pScreenMode->heightGet();
}

void fsIDisplay::windowModeLocate()
{
	if (mBestDeviceDisplayMode->widthGet() >= mDesignedDisplayMode.widthGet()
		&& mBestDeviceDisplayMode->heightGet() > mDesignedDisplayMode.heightGet() + 32)
	{
		mDesktopWindowDisplayMode.sizeSet(mDesignedDisplayMode.widthGet(), mDesignedDisplayMode.heightGet());
	}
	else
	{
		const fsF32 aspectRatio = mDesignedDisplayMode.isWideScreenGet() ? 9.0f / 16.0f : 3.0f / 4.0f;
		const fsF32 windowScaleFactor = 8.0f / 10.0f;
		mDesktopWindowDisplayMode.sizeSet(
			static_cast<fsS32>(mBestDeviceDisplayMode->widthGet() * windowScaleFactor),
			static_cast<fsS32>(mBestDeviceDisplayMode->widthGet() * windowScaleFactor * aspectRatio));
	}
}

void fsIDisplay::displayModeLocate(fsCDisplayMode*& pMode, fsTDistlayMemCriteriaFnc pCriteria, fsBool pFirstMatch)
{
	std::list<fsCDisplayMode*>::iterator scrMode = mScreenModes.begin();
	while (mScreenModes.end() != scrMode)
	{
		if (CALL_MEMBER_FNC(this, pCriteria)(*scrMode))
		{
			pMode = *scrMode;
			if (pFirstMatch)
			{
				return;
			}
		}
		++scrMode;
	}

	if (!pMode)
	{
		if (pCriteria != &fsIDisplay::failSafeResolutionCriteria)
		{
			displayModeLocate(pMode, &fsIDisplay::failSafeResolutionCriteria, pFirstMatch);
		}
		else
		{
			pMode = mScreenModes.back();
		}
	}
}

void fsIDisplay::screenModeAdd(fsS32 pW, fsS32 pH, fsS32 pBitDepth)
{
	fsCDisplayMode* const mode = new fsCDisplayMode(pW, pH, pBitDepth);
	fsLogMsg("SUPPORTED SCREEN MODE: %d, %d %dbpp", pW, pH, pBitDepth)
	mScreenModes.push_back(mode);
}

void fsIDisplay::designedScreenModeDetermine(const fsCDisplayMode* const pMode/* = nullptr*/)
{
	const fsCAppSettings* appSett = fsCAppCoreMain::instanceGet()->settingsGet();
	mDesignedDisplayMode.sizeSet(appSett->s32Get(mAppCanvasWKey), appSett->s32Get(mAppCanvasHKey));
	mDeviceOriginalDisplayMode.sizeSet(appSett->s32Get(mAppCanvasWKey), appSett->s32Get(mAppCanvasHKey));

	if (fixedAspectGet())
	{
		return;
	}

	if (
#if !defined fsRELEASE
		(fsCAppCoreMain::instanceGet()->hardwareGet()->smallDeviceGet() && !mDesignedDisplayMode.isWideScreenGet()) ||
#endif
		(mDesignedDisplayMode.isWideScreenGet() &&
			((pMode && !pMode->isWideScreenGet())
				|| (!displayIsWideScreenGet())))
	)
	{
		mDesignedDisplayMode.convertTo4to3();
	}
}

fsBool fsIDisplay::displayIsWideScreenGet() const
{
	if (1 == mScreenModes.size() || mSimulatingFixedDisplay)
	{
		return (mScreenModes.back())->isWideScreenGet();
	}

	for (auto mode : mScreenModes)
	{
		if (mode->isWideScreenGet() &&
			mode->widthGet() >= mDesignedDisplayMode.widthGet() &&
			mode->heightGet() >= mDesignedDisplayMode.heightGet())
		{
			return true;
		}
	}
	return false;
}

void fsIDisplay::fixedAspectCalculate(
    fsF32& scaleX,
    fsF32& scaleY,
    const fsCDisplayMode* const pDisplayMode)
{
	if (!fixedAspectGet())
	{
		return;
	}

	const auto dispW = static_cast<fsF32>(pDisplayMode->widthGet());
	const auto dispH = static_cast<fsF32>(pDisplayMode->heightGet());

	const auto designedW = static_cast<fsF32>(mDesignedDisplayMode.widthGet());
	const auto designedH = static_cast<fsF32>(mDesignedDisplayMode.heightGet());

	const fsF32 targetAspect = 16.0f / 9.0f;
	const fsF32 displayAspect = dispW / dispH;

	if (displayAspect < targetAspect)
	{	// Display too narrow: fit width, reduce effective height.
		const fsF32 fittedH = dispW / targetAspect;
		scaleY = fittedH / designedH;
	}
	else if (displayAspect > targetAspect)
	{	// Display too wide: fit height, reduce effective width.
		const fsF32 fittedW = dispH * targetAspect;
		scaleX = fittedW / designedW;
	}
}

void fsIDisplay::matrixSetForDisplaySize(const fsCDisplayMode* const pDisplayMode)
{
	mLocalMtx.identitySet();

	auto scaleX = static_cast<fsF32>(pDisplayMode->sizeGet().x) / mDesignedDisplayMode.sizeGet().x;
	auto scaleY = static_cast<fsF32>(pDisplayMode->sizeGet().y) / mDesignedDisplayMode.sizeGet().y;

	fsPoint pos(mDesignedDisplayMode.sizeGet().x / 2.0f * scaleX,
#if defined fsINVERTED_Y_AXIS
	-mDesignedDisplayMode.sizeGet().y / 2.0f * scaleY);
#else
	mDesignedDisplayMode.sizeGet().y / 2.0f * scaleY);
#endif

	fixedAspectCalculate(scaleX, scaleY, pDisplayMode);
	scaleSet(fsVec2d(scaleX, scaleY));
	clipWindowSet(pDisplayMode);


#if !defined fsFRAMEWORK_MG
	posSet(pos);
#endif
}

void fsIDisplay::clipWindowSet(const fsCDisplayMode* const pDisplayMode)
{
	if (fixedAspectGet())
	{
		clipWindowSetDo(pDisplayMode);
	}
}

fsS32 fsIDisplay::retinaScaleFactorGet() const
{
	return retinaScaleFactorGetDo();
}

fsIDisplay* fsIDisplay::create()
{
	auto display = new fsCDisplay();
	display->mStartupDimensions = fsCAppCoreMain::instanceGet()->hardwareGet()->currentDisplayModeResolutionGet();
	display->initialise();
	return display;
}

fsIDisplay* fsIDisplay::instanceGet()
{
	return fsCAppCoreMain::instanceGet()->displayGet();
}

fsBool fsIDisplay::simulatedFixedDisplayConfigure()
{
#if !defined fsRELEASE
	const fsStr screenResKey = fsCAppCoreMain::instanceGet()->settingsGet()->debugSettingsGet()->strGet("screenResolution");
	if ( !screenResKey.emptyGet() )
	{
		fsStr screenResVal = fsCAppCoreMain::instanceGet()->settingsGet()->debugSettingsGet()->strGet(screenResKey);
		if (screenResVal.emptyGet())
		{
			screenResVal = screenResKey;
		}

		const fsS32 forceW = screenResVal.chomp("x").toS32();
		const fsS32 forceH = screenResVal.toS32();

		if (forceW > 0 && forceH > 0)
		{
			mSimulatingFixedDisplay = true;
			screenModeAdd(forceW, forceH, 32);
			designedScreenModeDetermine();
			mBestDeviceDisplayMode = mScreenModes.back();
			mDesktopWindowDisplayMode = *mBestDeviceDisplayMode;
			screenModeSet(fsCProfileManager::instanceGet()->userSavedDataGet()->boolGet(fsCUserSavedData::mFullScreenKey));
		}
	}
#else
	if ("none" != fsCAppCoreMain::instanceGet()->settingsGet()->strGetWithDefault("autoTest", "none"))
	{
		mSimulatingFixedDisplay = true;
		screenModeAdd(800, 600, 32);
		designedScreenModeDetermine();
		mBestDeviceDisplayMode = mScreenModes.back();
		mDesktopWindowDisplayMode = *mBestDeviceDisplayMode;
	}
#endif
	return mSimulatingFixedDisplay;
}

fsIDisplay::fsIDisplay() :
	fsINode("AppDisplay"),
	mSimulatingFixedDisplay(false),
	mFullScreen(false),
	mBestDeviceDisplayMode(nullptr)
{
}

fsIDisplay::~fsIDisplay()
{
	fsNCoreUtils::clearSequenceContainerOfPtrs(mScreenModes);
}