Cppcheck report - Fission: libs/fsRenderer/src/particles/fsIParticle.cpp

#include "fsIParticle.h"

#include <fsCore/src/fsNMaths.h>

#include "fsCParticleParameter.h"
#include "fsCParticleRotateParameter.h"
#include "fsCParticleScaleParameter.h"


void fsIParticle::deactivate()
{
	visibilitySet(false);
	mActive = false;
}

std::shared_ptr<fsCBrush> fsIParticle::brushGet() const
{
	return brushGetDo();
}

fsBool fsIParticle::hitTest(const fsPoint& pLocalPos) const
{
	return hitTestDo(pLocalPos);
}

void fsIParticle::renderMatrixApply(const fsAffineMtx2d& pRenderMatrix)
{
	mRenderMtx = pRenderMatrix;
	mMtxDirty = true;
}

void fsIParticle::visibilitySet(fsBool pVisible)
{
	visibilitySetDo(pVisible);
}

void fsIParticle::posInitialise(const fsVec2d& pPos, const fsVec2d& pVel, const fsVec2d& pVelDelta,
                                const fsVec2d& pVelUV)
{
	mPos = pPos;
	mVel = pVel;
	mVelDelta = pVelDelta;
	mVelUV = pVelUV;
	mPosUV = {0, 0};
	mMtxDirty = true;
	if (mVelUV.x || mVelUV.y)
	{
		textureWrapSet();
	}
}

void fsIParticle::scaleInitialise()
{
	mScaleXParam->initialise();
	if (mScaleYParam)
	{
		mScaleYParam->initialise();
	}
	mMtxDirty = true;
}

void fsIParticle::angleInitialise()
{
	mAngleParam->initialise();
	mMtxDirty = true;
}

fsSColour4B fsIParticle::colourGraphValueGet(fsS32 pTime) const
{
	auto graphCol = mColourGraph->valueGet(pTime);
	return {
		static_cast<fsU8>(graphCol.redByteGet()),
		static_cast<fsU8>(graphCol.greenByteGet()),
		static_cast<fsU8>(graphCol.blueByteGet()),
		static_cast<fsU8>(graphCol.alphaByteGet())
	};
}

void fsIParticle::colourGraphInitialise(fsCGraph<fsSColour>* pColourGraph)
{
	mColourGraph = pColourGraph;
}

fsBool fsIParticle::activeGet() const
{
	if (mLifetimeMs < 0)
	{
		return fsNMaths::absS32(mLifetimeMs) != mElapsedTimeMs;
	}
	return mActive;
}

void fsIParticle::activate(fsS32 pLifeTimeMs)
{
	mLifetimeMs = pLifeTimeMs;
	mElapsedTimeMs = 0;
	colourGraphUpdate();
	mActive = true;
	visibilitySet(true);
	mMtxDirty = true;
	renderMatrixApply();
}

void fsIParticle::renderMatrixApply()
{
	if (mMtxDirty)
	{
		mMtxPos.x = mPos.x;
#if defined fsINVERTED_Y_AXIS
		mMtxPos.y = -mPos.y;
#else
		mMtxPos.y = mPos.y;
#endif
		mLocalMtx.calculate(mMtxPos,
		                    mScaleXParam->get(),
		                    mScaleYParam ? mScaleYParam->get() : mScaleXParam->get(),
		                    -mAngleParam->get());
		matrixApplyDo(mRenderMtx * mLocalMtx);
		mMtxDirty = false;
	}
}

fsBool fsIParticle::update(fsS32 pDeltaMs)
{
	if (mActive)
	{
		const fsS32 absLifeTime = fsNMaths::absS32(mLifetimeMs);
		if (absLifeTime && mElapsedTimeMs == absLifeTime)
		{
			return false;
		}

		mElapsedTimeMs += pDeltaMs;

		if (mLifetimeMs != 0 && mElapsedTimeMs >= absLifeTime)
		{
			if (mLifetimeMs > 0)
			{
				mActive = false;
				return true;
			}
			propertiesFinalise(pDeltaMs);
		}
		else
		{
			propertiesUpdate(pDeltaMs);
		}

		updateDo(pDeltaMs);
	}
	return false;
}

void fsIParticle::propertiesUpdate(fsS32 pDeltaMs)
{
	const fsF32 deltaTimeFloat = static_cast<fsF32>(pDeltaMs) / 1000.0f;

	positionUpdate(deltaTimeFloat);
	oscillationUpdate(pDeltaMs);
	scaleUpdate(pDeltaMs);
	angleUpdate(pDeltaMs);
	positionUVUpdate(pDeltaMs);
	colourGraphUpdate();
}

void fsIParticle::propertiesFinalise(fsS32 pDeltaMs)
{
	const fsS32 absLifeTime = fsNMaths::absS32(mLifetimeMs);
	mElapsedTimeMs = absLifeTime;

	scaleFinalise();
	angleFinalise();
	mElapsedTimeMs = absLifeTime - 1;
	colourGraphUpdate();
	++mElapsedTimeMs;
}

void fsIParticle::oscillationUpdate(fsS32 pDeltaMs)
{
	if (mHorizontalOscillationGraph == nullptr && mVerticalOscillationGraph == nullptr)
	{
		return;
	}

	auto wrappedRound = [&](fsCParticleData::fsSOscillationGraph const* const graph) -> fsBool
	{
		return (mElapsedTimeMs / graph->periodGet()) != ((mElapsedTimeMs - pDeltaMs) / graph->periodGet());
	};

	auto oscillate = [&](fsCParticleData::fsSOscillationGraph* const graph, fsF32& pos) -> void
	{
		pos -= graph->valueGet((mElapsedTimeMs - pDeltaMs) % graph->periodGet());
		if (wrappedRound(graph))
		{
			graph->offsetSet();
		}
		pos += graph->valueGet(mElapsedTimeMs % graph->periodGet());
	};
	
	if (mHorizontalOscillationGraph != nullptr)
	{
		oscillate(mHorizontalOscillationGraph.get(), mPos.x);
	}

	if (mVerticalOscillationGraph != nullptr)
	{
		oscillate(mVerticalOscillationGraph.get(), mPos.y);
	}
}

void fsIParticle::positionUpdate(fsF32 pDeltaFloat)
{
	mPos.x += (mVel.x * pDeltaFloat);
	mPos.y += (mVel.y * pDeltaFloat);

	if (mMtxPos.x != mPos.x ||
		mMtxPos.y != mPos.y)
	{
		mMtxDirty = true;
	}

	mVel.x += (mVelDelta.x * pDeltaFloat);
	mVel.y += (mVelDelta.y * pDeltaFloat);
}

void fsIParticle::positionUVUpdate(fsF32 pDeltaFloat)
{
	if (mVelUV.x || mVelUV.y)
	{
		mPosUV.x += (mVelUV.x * pDeltaFloat);
		mPosUV.y += (mVelUV.y * pDeltaFloat);
		if (mPosUV.x > 1.0f)
		{
			mPosUV.x -= 1.0f;
		}
		if (mPosUV.y > 1.0f)
		{
			mPosUV.y -= 1.0f;
		}
		uvApply(mPosUV);
	}
}

void fsIParticle::scaleUpdate(fsS32 pDeltaMs)
{
	mScaleXParam->update(mElapsedTimeMs, pDeltaMs);
	if (mScaleYParam)
	{
		mScaleYParam->update(mElapsedTimeMs, pDeltaMs);
	}
	mMtxDirty = true;
}

void fsIParticle::angleUpdate(fsS32 pDeltaMs)
{
	mAngleParam->update(mElapsedTimeMs, pDeltaMs);
	mMtxDirty = true;
}

void fsIParticle::scaleFinalise()
{
	mScaleXParam->finalise(mElapsedTimeMs);
	if (mScaleYParam)
	{
		mScaleYParam->finalise(mElapsedTimeMs);
	}
	mMtxDirty = true;
}

void fsIParticle::angleFinalise()
{
	mAngleParam->finalise(mElapsedTimeMs);
	mMtxDirty = true;
}

void fsIParticle::render()
{
	if (mActive)
	{
		renderDo();
	}
}

fsIParticle::fsIParticle(const sCreateParmas& pParams) :
	mActive(false),
	mLifetimeMs(0),
	mElapsedTimeMs(0),
	mMtxDirty(false),
	mScaleXParam(fsCParticleScaleParameter::clone(pParams.mScale)),
	mScaleYParam(nullptr),
	mAngleParam(fsCParticleRotateParameter::clone(pParams.mRotate)),
	mColourGraph(pParams.mColourGraph)
{
	if (pParams.mScaleY)
	{
		mScaleYParam = fsCParticleScaleParameter::clone(pParams.mScaleY);
	}

	if (pParams.mHorizontalOscillationGraph)
	{
		mHorizontalOscillationGraph = std::make_unique<fsCParticleData::fsSOscillationGraph>((*pParams.mHorizontalOscillationGraph.get()));
		mHorizontalOscillationGraph->offsetSet();
	}

	if (pParams.mVerticalOscillationGraph)
	{
		mVerticalOscillationGraph = std::make_unique<fsCParticleData::fsSOscillationGraph>((*pParams.mVerticalOscillationGraph.get()));
		mVerticalOscillationGraph->offsetSet();
	}
}

fsIParticle::~fsIParticle()
{
	delete mScaleXParam;<--- Class 'fsIParticle' does not have a copy constructor which is recommended since it has dynamic memory/resource management.<--- Class 'fsIParticle' does not have a operator= which is recommended since it has dynamic memory/resource management.
	delete mScaleYParam;
	delete mAngleParam;
}