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

#include "fsCParticleData.h"

#include <fsCore/src/fsNRnd.h>

#include <fsAudio/fsIAudioManager.h>

#include "../components/fsCSpriteComponent.h"
#include "../animatingSprite/fsCAnimationDataManager.h"

#include "../fsCBrushManager.h"
#include "../fsCMaterial.h"

#include "fsCSpriteParticle.h"
#include "fsCAnimationParticle.h"
#include "fsCParticleRotateParameter.h"
#include "fsCParticleScaleParameter.h"
#include "fsCParticleParticle.h"
#include "fsCParticleDataManager.h"


fsS32 fsCParticleData::fsSOscillationGraph::periodGet() const
{
	return static_cast<fsS32>(static_cast<fsF32>(mGraph->periodGet()) * mTimeOffset);	
}

fsF32 fsCParticleData::fsSOscillationGraph::valueGet(fsS32 pTime)
{
	return mGraph->valueGet(static_cast<fsF32>(pTime) * mTimeOffset) * mOscillationOffset;
}

void fsCParticleData::fsSOscillationGraph::dataAdd(fsS32 pDuration, fsF32 pOffset)
{
	mGraph->dataAdd(pDuration, pOffset);
}

void fsCParticleData::fsSOscillationGraph::offsetSet()
{
	if ( 0.f == mTimeRange && 0.f == mOscillationRange)
	{
		return;
	}
	
	auto randomRange = [](fsF32 const range) -> fsF32
	{
		return (1 + fsNRnd::uInt32GetWithLimit(range * 100)) / 100.f;
	};
	
	if (mTimeRange)
	{
		mTimeOffset = randomRange(mTimeRange);
	}

	if (mOscillationRange)
	{
		mOscillationOffset = randomRange(mOscillationRange);
	}
}

void fsCParticleData::fsSOscillationGraph::rangeSet(fsF32 pOscillationRange, fsF32 pTimeRange)
{
	mOscillationRange = pOscillationRange;
	mTimeRange = pTimeRange;
}

fsCParticleData::fsSOscillationGraph::fsSOscillationGraph():
mGraph(std::shared_ptr<fsCGraph<fsF32>>(nullptr)),
mOscillationRange(0.0f),
mTimeRange(0.0f),
mOscillationOffset(1.0f),
mTimeOffset(1.0f)
{
}

void fsCParticleData::scaleYCreate()
{
	if (!mScaleY)
	{
		mScaleY = new fsCParticleScaleParameter();
	}
}

std::unique_ptr<fsIParticle> fsCParticleData::spriteParticleCreate() const
{
	return std::make_unique<fsCSpriteParticle>(*mCurrentSprBrush,
		mAlphaBlendMode,
		mColour,
		mPivot,
		fsIParticle::sCreateParmas(mHorizontalOscillationGraph, mVerticalOscillationGraph, mColourGraph, mScaleX, mScaleY, mAngle));
	
}

std::unique_ptr<fsIParticle> fsCParticleData::animationParticleCreate() const
{
	return std::make_unique<fsCAnimationParticle>(mAnimData,
		fsIParticle::sCreateParmas(mHorizontalOscillationGraph, mVerticalOscillationGraph, mColourGraph, mScaleX, mScaleY, mAngle));
}

std::unique_ptr<fsIParticle> fsCParticleData::particleParticleCreate() const
{
	auto ret = std::make_unique<fsCParticleParticle>(mParticleParticleData,
		mSprBrush.empty() ? nullptr : *mCurrentSprBrush,
		mAnimData,
		fsIParticle::sCreateParmas(mHorizontalOscillationGraph, mVerticalOscillationGraph, mColourGraph, mScaleX, mScaleY, mAngle));
    ret->initialise();
    return ret;
}

void fsCParticleData::particleCacheCreate(std::vector<std::unique_ptr<fsIParticle>>& pParticleCache, fsS32 pMaxParticles)
{
	fsAssert(pParticleCache.empty(), "Expected the particle cache to be empty.\n");

	// pointer to member function
	std::unique_ptr<fsIParticle> (fsCParticleData::*particleCreate)() const = &fsCParticleData::spriteParticleCreate;
	if (mParticleParticleData.get())
	{
		particleCreate = &fsCParticleData::particleParticleCreate;
	}
	else if (mAnimData)
	{
		particleCreate = &fsCParticleData::animationParticleCreate;
	}

	for (fsS32 p = 0; p < pMaxParticles; ++p)
	{
		pParticleCache.push_back(std::move((this->*particleCreate)()));
		if (mSprBrush.size() > 1)
		{
			if (++mCurrentSprBrush == mSprBrush.end())
			{
				mCurrentSprBrush = mSprBrush.begin();
			}
		}
	}
}

fsS32 fsCParticleData::particlesEmit(const fsSParticleEmmitParams& pEmmitParams) const
{
	fsS32 particlesEmitted = 0;
	for (std::unique_ptr<fsIParticle>& particle : pEmmitParams.mParticleCache)
	{
		if (!particle->activeGet())
		{
            auto index = std::distance(pEmmitParams.mParticleCache.begin(), std::find(pEmmitParams.mParticleCache.begin(), pEmmitParams.mParticleCache.end(), particle));
			particleReset(particle.get(), index, pEmmitParams);
			particle->activate(mParticleLifeMs);
			if (++particlesEmitted == pEmmitParams.mNumToEmit)
			{
				break;
			}
		}
	}
	return particlesEmitted;
}

void fsCParticleData::particleReset(fsIParticle* pParticle, fsS32 pIndex, const fsSParticleEmmitParams& pEmmitParams) const
{
	particlePosReset(pParticle, pIndex, pEmmitParams);
	particleScaleReset(pParticle);
	particleAngleReset(pParticle);
	if (!pEmmitParams.mPreRunPhase && !mSFXFileName.emptyGet())
	{
		fsIAudioManager::instanceGet()->
			effectPlay(fsCResourceName(mSFXFileName, fsCResourceName::eRES_LOCATION_ASSETS));
	}
}

fsVec2d fsCParticleData::parentEntBasedStartPosGet(fsCEntity* const pParentEnt) const
{
	fsVec2d startPos = mEmitPos;
	fsPoint range;

	fsISpriteComponent* const sp = pParentEnt->spriteComponentGet();<--- Variable 'sp' can be declared as pointer to const
	range.x = sp->widthGet();
	range.y = sp->heightGet();

	startPos.x = startPos.x - range.x / 2.0f + fsNRnd::uInt32GetWithLimit(range.x);
	startPos.y = startPos.y + range.y / 2.0f;

	return startPos;
}

void fsCParticleData::particlePosReset(fsIParticle* pParticle, fsS32 pIndex, const fsSParticleEmmitParams& pEmmitParams) const
{
	fsVec2d startPos;

	if (pEmmitParams.mParentEnt)
	{
		startPos = parentEntBasedStartPosGet(pEmmitParams.mParentEnt);
	}
	else if (pEmmitParams.mSpawnCloud)
	{
        if (mPulse)
        {
            startPos = pEmmitParams.mSpawnCloud->indexedPosFromSpawnCloudGet(pIndex);
        }
        else
        {
            startPos = pEmmitParams.mSpawnCloud->posFromSpawnCloudGet();
        }
	}
	else
	{
		startPos = rndVec2Get(mEmitPosRange) + mEmitPos;
	}

	startPos.x += pEmmitParams.mSpawnPosition.x;
	startPos.y += pEmmitParams.mSpawnPosition.y;

	pParticle->posInitialise(startPos,
	                         mVelocity + rndVec2Get(mVelocityRange),
	                         mVelocityDelta + rndVec2Get(mVelocityDeltaRange), mVelocityUV);
}

void fsCParticleData::particleScaleReset(fsIParticle* const pParticle) const<--- The member function 'fsCParticleData::particleScaleReset' can be static.
{
	pParticle->scaleInitialise();
}

void fsCParticleData::particleAngleReset(fsIParticle* const pParticle) const<--- The member function 'fsCParticleData::particleAngleReset' can be static.
{
	pParticle->angleInitialise();
}

fsVec2d fsCParticleData::rndVec2Get(const fsPoint& pRange)
{
	const fsVec2d ret(rndF32Get(pRange.x), rndF32Get(pRange.y));
	return ret;
}

fsF32 fsCParticleData::rndF32Get(fsS32 pRange)
{
	if (pRange > 0.0f)
	{
		return static_cast<fsF32>(fsNRnd::uInt32GetWithLimit(static_cast<fsU32>(pRange))) / 1024.0f;
	}
	return 0.0f;
}

void fsCParticleData::sfxFileNameSet(const fsStr& pFileName)
{
	mSFXFileName = pFileName;
}

void fsCParticleData::emmiterLoad(const fsCResourceName& pParticleDataFilename)
{
	mParticleParticleData = fsCAppCoreMain::instanceGet()->particleDataManagerGet()->get(pParticleDataFilename);
}

void fsCParticleData::brushLoad(const fsCResourceName& pBrushFileName)
{
	if (fsStr::npos != pBrushFileName.nameGet().find(","))
	{
		std::vector<fsStr> filenames;
		auto names = pBrushFileName.nameGet();
		while (fsStr::npos != names.find(","))
		{
			const fsStr keyName = names.chomp(",");
			filenames.emplace_back(fsStr(keyName));
		}

		for (auto& name: filenames)
		{
			mSprBrush.push_back(fsCBrushManager::instanceGet()->get(<--- Consider using std::transform algorithm instead of a raw loop.
				fsCResourceName(name, fsCResourceName::eRES_LOCATION_ASSETS), mCollectableCount != 0, false, true));
		}

	}
	else
	{
		mSprBrush.push_back(fsCBrushManager::instanceGet()->get(pBrushFileName, mCollectableCount != 0, false, true));
	}
	
	mCurrentSprBrush = mSprBrush.begin();
}

void fsCParticleData::animDataLoad(const fsCResourceName& pAnimFileName)
{
#if !defined fsRELEASE
	mFileName = pAnimFileName.nameGet();
#endif
	mAnimData = fsCAppCoreMain::instanceGet()->animationManagerGet()->get(pAnimFileName, mCollectableCount != 0);
}

fsCParticleData::fsCParticleData() :
<--- Member variable 'fsCParticleData::mCurrentSprBrush' is not initialized in the constructor. [+]
Member variable 'fsCParticleData::mCurrentSprBrush' is not initialized in the constructor. Member variables of native types, pointers, or references are left uninitialized when the class is instantiated. That may cause bugs or undefined behavior.
	mScaleX(new fsCParticleScaleParameter()),<--- Class 'fsCParticleData' does not have a operator= which is recommended since it has dynamic memory/resource management.
	mScaleY(nullptr),
	mAngle(new fsCParticleRotateParameter()),
    mPulse(false),
	mCollectableCount(0),
	mLinkToEmitter(false),
	mMaxParticles(0),
	mParticleLifeMs(0),
	mEmitSpeedPerSec(0.0f),
	mEmitPos(fsVec2d(0.0f, 0.0f)),
	mEmitPosRange(fsPoint(0, 0)),
	mVelocity(fsVec2d(0.0f, 0.0f)),
	mVelocityRange(fsPoint(0, 0)),
	mVelocityDelta(fsVec2d(0.0f, 0.0f)),
	mVelocityDeltaRange(fsPoint(0, 0)),
	mAlphaBlendMode(fsCMaterial::eALPHA_BLEND),
	mPrerunMs(0),
	mEmitterLifeMs(0),
	mColour(1.0f, 1.0f, 1.0f, 1.0f),
	mHorizontalOscillationGraph(std::shared_ptr<fsCParticleData::fsSOscillationGraph>(nullptr)),
	mVerticalOscillationGraph(std::shared_ptr<fsCParticleData::fsSOscillationGraph>(nullptr)),
	mColourGraph(nullptr),
	mAnimData(nullptr),
	mParticleParticleData(nullptr),
	mSFXFileName("")
{
}

fsCParticleData::~fsCParticleData()
{
	delete mColourGraph;
	delete mAngle;
	delete mScaleX;
	delete mScaleY;
}