Cppcheck report - Fission: libs/fsSpriter/src/fsCAnimatingSpriteSpriter.cpp

#include "fsCAnimatingSpriteSpriter.h"

#include <algorithm>
#include <limits>

#include <fsCore/src/debug/fsAssert.h>
#include <fsCore/fsPoint.h>
#include <fsCore/fsAffineMtx2d.h>
#include <fsCore/fsRect.h>
#include <fsCore/src/fsCResourceName.h>
#include <fsRenderer/src/fsCSprite.h>
#include <fsRenderer/src/animatingSprite/fsCAnimationDataManager.h>

#include "fsCAnimationDataSpriter.h"

#include "../impl/spriterengine/override/imagefile.h"
#include "../impl/spriterengine/override/sfmlspriteobjectinfo.h"
#include "fsAppCore/src/fsCAppCoreMain.h"

namespace
{
	fsRect aabbFromSprite(fsCSprite* const pSprite)
	{
		const fsF32 halfWidth = static_cast<fsF32>(pSprite->widthGet()) / 2.0f;
		const fsF32 halfHeight = static_cast<fsF32>(pSprite->heightGet()) / 2.0f;

		fsVec2d corners[4] = {
			fsVec2d(-halfWidth, -halfHeight),
			fsVec2d(halfWidth, -halfHeight),
			fsVec2d(halfWidth, halfHeight),
			fsVec2d(-halfWidth, halfHeight)
		};

		const fsAffineMtx2d& renderMtx = pSprite->renderMatrixGet();
		fsVec2d transformed;

		fsF32 minX = std::numeric_limits<fsF32>::max();
		fsF32 minY = std::numeric_limits<fsF32>::max();
		fsF32 maxX = -std::numeric_limits<fsF32>::max();
		fsF32 maxY = -std::numeric_limits<fsF32>::max();

		for (fsVec2d& corner : corners)
		{
			renderMtx.fsVec2dTransform(corner, &transformed);
			minX = std::min(minX, transformed.x);
			minY = std::min(minY, transformed.y);
			maxX = std::max(maxX, transformed.x);
			maxY = std::max(maxY, transformed.y);
		}

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


// std::shared_ptr<fsCBrush> fsCAnimatingSpriteSpriter::brushGetDo() const
// {
// 	return std::shared_ptr<fsCBrush>();
// }

void fsCAnimatingSpriteSpriter::activeSet(fsBool pVisibility)
{
	if (mAnimationData)
	{
		mActive = pVisibility;
	}
}

void fsCAnimatingSpriteSpriter::animationPlayDo(const fsStr& pAnimation)
{
	mInst->setCurrentAnimation(pAnimation.utf8Get());
	reset();
}

void fsCAnimatingSpriteSpriter::colourApplyToSpriteFrames(const fsSColour4B& pColour)
{
	mInst->setColour(pColour);
}

fsS32 fsCAnimatingSpriteSpriter::currentFrameHeightGetDo() const
{
	return mInst->getSize().y;
}

fsPoint fsCAnimatingSpriteSpriter::currentFramePosGetDo() const
{
	return fsPoint(0, 0);
}

fsBool fsCAnimatingSpriteSpriter::hitTestDo(const fsPoint& pPoint, fsBool pRequireHitMap) const
{
	if (!mActive || !mInst)
	{
		return false;
	}

	auto* const zOrder = mInst->getZOrder();
	if (!zOrder)
	{
		return false;
	}

	const fsVec2d worldPos(static_cast<fsF32>(pPoint.x), static_cast<fsF32>(pPoint.y));

	for (auto* const objectInfo : *zOrder)
	{
		if (!objectInfo)
		{
			continue;
		}

		fsCSprite* const sprite = objectInfo->link();
		if (!sprite || !sprite->brushGet())
		{
			continue;
		}

		const fsRect spriteBounds = aabbFromSprite(sprite);
		if (pPoint.x < spriteBounds.lGet() || pPoint.x >= spriteBounds.rGet()
			|| pPoint.y < spriteBounds.tGet() || pPoint.y >= spriteBounds.bGet())
		{
			continue;
		}

		if (!pRequireHitMap)
		{
			return true;
		}

		fsVec2d localPos;
		if (!sprite->renderMatrixGet().fsVec2DInverseTransform(worldPos, &localPos))
		{
			continue;
		}

		if (sprite->hitTest(fsPoint(static_cast<fsS32>(localPos.x), static_cast<fsS32>(localPos.y)), true))
		{
			return true;
		}
	}

	return false;
}

//fsBool fsCAnimatingSpriteSpriter::pixelCollisionCheckDo( fsISpriteRef pTarget ) = 0;

fsS32 fsCAnimatingSpriteSpriter::currentFrameGetDo() const
{
	return 0;
}

void fsCAnimatingSpriteSpriter::updateDo(fsS32 pDeltaMS)
{
	mInst->setTimeElapsed(pDeltaMS);
	if (mInst->animationJustFinished())
	{
		mActive = false;
	}
	mInst->update();
}

void fsCAnimatingSpriteSpriter::renderDo()
{
	mInst->render();
}

fsBool fsCAnimatingSpriteSpriter::loopingGetDo() const
{
	return false;
}

void fsCAnimatingSpriteSpriter::matrixApplyDo(const fsAffineMtx2d& pRenderMtx)
{
// 	mInst->setPosition(SpriterEngine::point(pRenderMtx.get(0, 2), -pRenderMtx.get(1, 2)));
// 	const fsVec2d scale = pRenderMtx.scaleGet();
// 	mInst->setScale(SpriterEngine::point(scale.x, scale.y));
// 	mInst->setAngle(0.0f);
	mAnimationRootSprt->matrixApply(pRenderMtx);
	mInst->update();
}

void fsCAnimatingSpriteSpriter::resetDo()
{
	mInst->setCurrentTime(0);
	mActive = (mInst != nullptr);
}

void fsCAnimatingSpriteSpriter::rootSpriteRegister()
{
	if (auto z = mInst->getZOrder())
	{
		for (auto ent = z->begin(); ent != z->end(); ++ent)
		{
			static_cast<SpriterEngine::SfmlSpriteObjectInfo*>((*ent))->rootSpriteSet(mAnimationRootSprt);
		}
	}
}

void fsCAnimatingSpriteSpriter::instanceCreate()
{
    if ((mInst = mAnimationData->mModel->getNewEntityInstance(0)))
    {
    	reset();
        mInst->setCurrentAnimation(0);
        mInst->setPosition(SpriterEngine::point(0.0f, 0.0f));
        mInst->setScale(SpriterEngine::point(1.0f, 1.0f));
        mInst->setAngle(0.0f);
        updateDo(0);

        rootSpriteRegister();
    }
}

void fsCAnimatingSpriteSpriter::animationDataSetDo(std::shared_ptr<fsIAnimationData> pAnimData)
{
    mAnimationData = std::dynamic_pointer_cast<fsCAnimationDataSpriter>(pAnimData);
    instanceCreate();
}

fsCAnimatingSpriteSpriter::fsCAnimatingSpriteSpriter(const fsCResourceName& pFileName, fsBool pHitMap, fsCSprite* const pAnimatingRootSprt) :
fsIAnimatingSprite(pFileName, pHitMap, pAnimatingRootSprt),
mAnimationData(nullptr),
mInst(nullptr)
{
	mAnimationData = std::dynamic_pointer_cast<fsCAnimationDataSpriter>(fsCAppCoreMain::instanceGet()->animationManagerGet()->get(pFileName, pHitMap));
<--- Variable 'mAnimationData' is assigned in constructor body. Consider performing initialization in initialization list. [+]
When an object of a class is created, the constructors of all member variables are called consecutively in the order the variables are declared, even if you don't explicitly write them to the initialization list. You could avoid assigning 'mAnimationData' a value by passing the value to the constructor in the initialization list.
    instanceCreate();
}

fsCAnimatingSpriteSpriter::fsCAnimatingSpriteSpriter(fsCSprite* const pAnimatingRootSprt):
fsIAnimatingSprite(pAnimatingRootSprt),
mAnimationData(nullptr),
mInst(nullptr)
{
}

fsCAnimatingSpriteSpriter::~fsCAnimatingSpriteSpriter()
{
	delete mInst;
}