Cppcheck report - Fission: libs/fsRenderer/src/components/fsCSpriteComponent.cpp

#include "fsCSpriteComponent.h"

#include <fsAppCore/src/fsCEntity.h>

#include <fsCore/src/debug/fsAssert.h>
#include <fsCore/src/fsCResourceName.h>
#include <fsCore/src/fsCVariableTable.h>
#include <fsCore/src/fsNMaths.h>
#include <fsCore/fsRect.h>

#include "../fsCBrush.h"
#include "../fsCBrushManager.h"
#include "../fsCSprite.h"

#include <cfloat>

#ifdef COLLISION_OUTLINE_RENDERING
	#include <fsCore/fsSColour.h>
	#include <fsRenderer/src/fsCLine.h>
#endif


const fsCUniqueId fsCSpriteComponent::mTypeId("fsCSpriteComponent");

void fsCSpriteComponent::polyInfoSet(fsIRenderData::fsSPolyInfo const& pPolyInfo)
{
	mSprite->polyInfoSet(pPolyInfo);
}

fsBool fsCSpriteComponent::obscuredByBoundingBoxCheckDo(fsISpriteComponent* pOtherSprComp)
{
	fsAssert((parentGet()->scaleGet().x == 1.0f && pOtherSprComp->parentGet()->scaleGet().y == 1.0f),
	         "Sprite entities %s and %s must have a scale of 1.0f for this hit test.\n",
	         parentGet()->nameGet().utf8Get(), pOtherSprComp->parentGet()->nameGet().utf8Get());
	fsAssert((parentGet()->angleGet() == 0.0f && pOtherSprComp->parentGet()->angleGet() == 0.0f),
	         "Sprite entities %s and %s must have an angle of 0.0f for this hit test.\n",
	         parentGet()->nameGet().utf8Get(), pOtherSprComp->parentGet()->nameGet().utf8Get());

	const fsRect myRect(parentGet()->screenPositionGet(), mSprite->brushGet()->hitTestDimensionsGet().x,
	                    mSprite->brushGet()->hitTestDimensionsGet().y);
	const fsRect hisRect(pOtherSprComp->parentGet()->screenPositionGet(), pOtherSprComp->brushGet()->hitTestDimensionsGet().x,
	                     pOtherSprComp->brushGet()->hitTestDimensionsGet().y);

	return myRect.obscuredBy(hisRect);
}

fsRect getAABBFromTransformedCorners(fsVec2d const* pCorners, fsS32 pCount,
			      const fsAffineMtx2d& pMatrix)
{
	fsVec2d worldCorners[4];
	fsF32 minX = FLT_MAX, maxX = -FLT_MAX;
	fsF32 minY = FLT_MAX, maxY = -FLT_MAX;

	for (int i = 0; i < pCount; ++i)
	{
		pMatrix.fsVec2dTransform(pCorners[i], &worldCorners[i]);
		minX = fmin(minX, worldCorners[i].x);
		maxX = fmax(maxX, worldCorners[i].x);
		minY = fmin(minY, worldCorners[i].y);
		maxY = fmax(maxY, worldCorners[i].y);
	}

	return fsRect(
		static_cast<fsS32>(minX),
		static_cast<fsS32>(maxX),
		static_cast<fsS32>(minY),
		static_cast<fsS32>(maxY));
}

#ifdef COLLISION_OUTLINE_RENDERING

void fsCSpriteComponent::renderDebugCollisionOutline(const fsRect& intersect, const fsSColour4B& pColour) const
{
  mCollisionOutlineLine->colourSet(pColour);
  mCollisionOutlineLine->vertSet(
      std::vector<fsVec2d>{fsVec2d(intersect.lGet(), intersect.tGet()),
                           fsVec2d(intersect.rGet(), intersect.tGet()),
                           fsVec2d(intersect.rGet(), intersect.bGet()),
                           fsVec2d(intersect.lGet(), intersect.bGet()),
                           fsVec2d(intersect.lGet(), intersect.tGet())});
}

void fsCSpriteComponent::renderDebugMouseOverCollisionBox() const
{
	const fsF32 halfWidth = mSprite->widthGet() / 2.0f;
	const fsF32 halfHeight = mSprite->heightGet() / 2.0f;

	fsVec2d corners[4] = {<--- Variable 'corners' can be declared as const array
		fsVec2d(-halfWidth, -halfHeight),
		fsVec2d(halfWidth, -halfHeight),
		fsVec2d(halfWidth, halfHeight),
		fsVec2d(-halfWidth, halfHeight)
	};

	renderDebugCollisionOutline(
		getAABBFromTransformedCorners(corners, 4, parentGet()->renderMatrixGet()),
		fsSColour4B(255, 255, 0, 255));
}

void fsCSpriteComponent::clearDebugCollisionOutline() const
{
	renderDebugCollisionOutline(fsRect(), fsSColour4B(0, 0, 0, 0));
}

#endif

#ifdef OUTLINE_RENDERING

void fsCSpriteComponent::debugOutlineUpdate() const
{
	const fsF32 halfWidth = mSprite->widthGet() / 2.0f;
	const fsF32 halfHeight = mSprite->heightGet() / 2.0f;

	std::vector<fsVec2d> verts =
	{
		fsVec2d(-halfWidth, -halfHeight),
		fsVec2d(halfWidth, -halfHeight),

		fsVec2d(halfWidth, -halfHeight),
		fsVec2d(halfWidth, halfHeight),

		fsVec2d(halfWidth, halfHeight),
		fsVec2d(-halfWidth, halfHeight),

		fsVec2d(-halfWidth, halfHeight),
		fsVec2d(-halfWidth, -halfHeight)
	};
	mLine->colourSet(fsSColour4B(0, 255, 0, 255));
	mLine->vertSet(verts);
}

#endif

fsBool fsCSpriteComponent::hitTestDo(fsISpriteComponent* pOtherSprComp, fsBool pRequireHitMap) const {
	// Instead of using brush dimensions directly, transform the corners
	// through the render matrix to get the actual world-space bounding box

	if (!parentGet()->visibleGet())
	{
		return false;
	}

	const fsAffineMtx2d myRenderMtx = parentGet()->renderMatrixGet();
	const fsAffineMtx2d hisRenderMtx = pOtherSprComp->parentGet()->renderMatrixGet();

	fsS32 myBrushW = mSprite->brushGet()->hitTestDimensionsGet().x;
	fsS32 myBrushH = mSprite->brushGet()->hitTestDimensionsGet().y;
	fsS32 hisBrushW = pOtherSprComp->brushGet()->hitTestDimensionsGet().x;
	fsS32 hisBrushH = pOtherSprComp->brushGet()->hitTestDimensionsGet().y;

	// Corners in centered local space (origin at sprite centre, matching fsCSprite::hitTest convention)
	const fsF32 myHalfW = myBrushW / 2.0f;
	const fsF32 myHalfH = myBrushH / 2.0f;
	const fsF32 hisHalfW = hisBrushW / 2.0f;
	const fsF32 hisHalfH = hisBrushH / 2.0f;

	fsVec2d myCorners[4] = {<--- Variable 'myCorners' can be declared as const array
	    fsVec2d(-myHalfW, -myHalfH),
	    fsVec2d( myHalfW, -myHalfH),
	    fsVec2d( myHalfW,  myHalfH),
	    fsVec2d(-myHalfW,  myHalfH)
	};

	fsVec2d hisCorners[4] = {<--- Variable 'hisCorners' can be declared as const array
	    fsVec2d(-hisHalfW, -hisHalfH),
	    fsVec2d( hisHalfW, -hisHalfH),
	    fsVec2d( hisHalfW,  hisHalfH),
	    fsVec2d(-hisHalfW,  hisHalfH)
	};

	// Transform corners to world space and compute AABB
	fsRect myWorldRect = getAABBFromTransformedCorners(myCorners, 4, myRenderMtx);
	fsRect hisWorldRect = getAABBFromTransformedCorners(hisCorners, 4, hisRenderMtx);

	// Now compute intersection in world space
	const fsRect intersect = myWorldRect.intersectGet(hisWorldRect);
	if (!intersect.isValidGet())
	    return false;

	if (!pRequireHitMap)
		return true;

	// Get inverse matrices for transforming world pixels back to local texture space
	const fsAffineMtx2d myInvMtx = myRenderMtx.inverseGet();
	const fsAffineMtx2d hisInvMtx = hisRenderMtx.inverseGet();

	std::shared_ptr<fsCBrush> myBrush = mSprite->brushGet();
	std::shared_ptr<fsCBrush> hisBrush = pOtherSprComp->brushGet();

	// Per-pixel collision detection
	for (fsS32 testY = intersect.tGet(); testY < intersect.bGet(); ++testY)
	{
	    for (fsS32 testX = intersect.lGet(); testX < intersect.rGet(); ++testX)
	    {
	        const fsVec2d worldPos(static_cast<fsF32>(testX), static_cast<fsF32>(testY));
	        fsVec2d localMy;
	        fsVec2d localHis;

	        // Transform world pixel to centered local space, then shift to texture space.
	        // Y is flipped because the render matrix uses Y-up convention but textures are Y-down.
	        myInvMtx.fsVec2dTransform(worldPos, &localMy);
	        hisInvMtx.fsVec2dTransform(worldPos, &localHis);

	    	localMy.x += myHalfW;
	    	localMy.y = myHalfH - localMy.y;

	    	localHis.x += hisHalfW;
	    	localHis.y = hisHalfH - localHis.y;
		        // Perform hit test on both brushes at transformed local coordinates
	        if (myBrush->hitTest(localMy) && hisBrush->hitTest(localHis))
	        {
#ifdef COLLISION_OUTLINE_RENDERING
		    renderDebugCollisionOutline(intersect, fsSColour4B(0, 255, 0, 255));
#endif
	        	fsLogMsg("Pixel collision detected between %s and %s.\n",
				parentGet()->nameGet().utf8Get(),
	        		pOtherSprComp->parentGet()->nameGet().utf8Get()
				);
	            return true;
	        }
	    }
	}

#ifdef COLLISION_OUTLINE_RENDERING
	renderDebugCollisionOutline(intersect, fsSColour4B(255, 0, 0, 255));
#endif

	return false;
}


void fsCSpriteComponent::initialiseFromVariableTableDo(const fsCVariableTable& pVars)
{
	fsISpriteComponent::initialiseFromVariableTableDo(pVars);

	const fsStr& texFileName = pVars.strGet("image");
	if (!texFileName.emptyGet())
	{
		const fsBool hitMap = pVars.strGet("hitMap") == "true";
		brushSet(fsCBrushManager::instanceGet()->get(
			fsCResourceName(texFileName, fsCResourceName::eRES_LOCATION_ASSETS), hitMap));
	}

	const fsS32 rectW = pVars.s32Get("width");
	if (rectW)
	{
		widthSet(rectW);
	}

	const fsS32 rectH = pVars.s32Get("height");
	if (rectH)
	{
		heightSet(rectH);
	}

	const fsS32 rot = pVars.s32Get("rotation");
	if (rot)
	{
		parentGet()->angleSet(rot * fsNMaths::fsPI / 180.0f);
	}

	const fsF32 scale = pVars.f32Get("scale");
	if (scale)
	{
		parentGet()->scaleSet(fsVec2d(scale, scale));
	}
}

fsBool fsCSpriteComponent::hitTestDo(const fsPoint& pScreenPos, fsBool pRequireHitMap) const
{
	if (!parentGet()->visibleGet())
	{
		return false;
	}

	fsVec2d localPos;
	if (!parentGet()->screenCoordConvertToLocal(pScreenPos, localPos))
	{
		return false;
	}
	const fsBool hit = mSprite->hitTest(localPos, pRequireHitMap);
#ifdef COLLISION_OUTLINE_RENDERING
	if (hit)
	{
		renderDebugMouseOverCollisionBox();
	}
	else
	{
		clearDebugCollisionOutline();
	}
#endif
	return hit;
}

void fsCSpriteComponent::renderDo()
{
	mSprite->render();
#ifdef COLLISION_OUTLINE_RENDERING
	mCollisionOutlineLine->render();
#endif
#ifdef OUTLINE_RENDERING
	mLine->render();
#endif
}

void fsCSpriteComponent::matrixApplyDo()
{
	mSprite->matrixApply(parentGet()->renderMatrixGet());
#ifdef COLLISION_OUTLINE_RENDERING
	// Collision outlines are populated in world space by renderDebugCollisionOutline().
	// Applying the sprite matrix here would transform the intersection twice.
#endif
#ifdef OUTLINE_RENDERING
	mLine->matrixApply(parentGet()->renderMatrixGet());
#endif
}


void fsCSpriteComponent::brushSetDo(const std::shared_ptr<fsCBrush> pBrush)
{
	mSprite->brushSet(pBrush);
	matrixApplyDo();

#ifdef OUTLINE_RENDERING
	debugOutlineUpdate();
#endif
}

std::shared_ptr<fsCBrush> fsCSpriteComponent::brushGetDo() const
{
	return mSprite->brushGet();
}

void fsCSpriteComponent::alphaBlendSetDo(fsS32 pBlend)
{
	mSprite->alphaBlendModeSet(pBlend);
}

void fsCSpriteComponent::colourSetDo(const fsSColour4B& pColour)
{
	mSprite->colourSet(pColour);
}

fsS32 fsCSpriteComponent::widthGetDo() const
{
	return mSprite->widthGet();
}

fsS32 fsCSpriteComponent::heightGetDo() const
{
	return mSprite->heightGet();
}

void fsCSpriteComponent::widthSetDo(fsS32 pWidth, fsBool pModifyRenderData /*= true*/)
{
	mSprite->widthSet(pWidth, pModifyRenderData);
#ifdef OUTLINE_RENDERING
	debugOutlineUpdate();
#endif
}

void fsCSpriteComponent::heightSetDo(fsS32 pHeight, fsBool pModifyRenderData /*= true*/)
{
	mSprite->heightSet(pHeight, pModifyRenderData);
#ifdef OUTLINE_RENDERING
	debugOutlineUpdate();
#endif
}

fsIComponent* fsCSpriteComponent::create(fsCEntity* pParent)
{
	return new fsCSpriteComponent(pParent);
}

fsCSpriteComponent::fsCSpriteComponent(fsCEntity* const pParent) :
	fsISpriteComponent(pParent),
	mSprite(new fsCSprite())
#ifdef OUTLINE_RENDERING
,mLine(new fsCLine(std::vector<fsVec2d>()))
#endif
{
#ifdef COLLISION_OUTLINE_RENDERING
	mCollisionOutlineLine = new fsCLine(std::vector<fsVec2d>());
#endif
}

fsCSpriteComponent::~fsCSpriteComponent()
{
	delete mSprite;
#ifdef OUTLINE_RENDERING
	delete mLine;
#endif
#ifdef COLLISION_OUTLINE_RENDERING
	delete mCollisionOutlineLine;
#endif
}