Cppcheck report - Fission: libs/fsRenderer/fsITexture.cpp

#include "fsITexture.h"

#include <fsCore/src/debug/fsAssert.h>
#include <fsCore/fsPoint.h>

#include <fsCore/fsBuildConfig.h>

#include "fsIImage.h"

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


void fsITexture::filterModeSet(fsFilterMode pNewMode)
{
	filterModeSetDo(pNewMode);
}

void fsITexture::wrapModeSet(fsWrapMode pNewMode)
{
	wrapModeSetDo(pNewMode);
}

std::shared_ptr<fsITexture> fsITexture::cloneSubSection(fsCBrush const* const pBlend, fsPoint const& pOffset)
{
	return doCloneSubSection(pBlend, pOffset);
}

void fsITexture::blend(fsCBrush const* const pBlend, fsPoint const& pOffset)
{
	return doBlend(pBlend, pOffset);
}

void fsITexture::finalise()
{
	if (mImage)
	{
		createFromImage(mImage.get());
		mImage.reset();
	}
}

fsSColour4B fsITexture::pixelGet(fsS32 pU, fsS32 pV, fsS32 pCol, fsS32 pRow)
{
	return pixelGetDo(pU, pV, pCol, pRow);
}

void fsITexture::pixelSet(fsS32 pU, fsS32 pV, fsS32 pCol, fsS32 pRow, fsSColour4B const& pPixel)
{
	doPixelSet(pU, pV, pCol, pRow, pPixel);
}

void fsITexture::textureCopyThroughStencil(std::shared_ptr<fsITexture> pSrc, std::shared_ptr<fsITexture> pStencil,
                                           fsS32 pU, fsS32 pV, fsS32 pX, fsS32 pY, fsS32 pAlphaHitMaskThreshold)
{
	doTextureCopyThroughStencil(pSrc, pStencil, pU, pV, pX, pY, pAlphaHitMaskThreshold);
}

void fsITexture::textureCopyInto(std::shared_ptr<fsITexture> pSrc, fsS32 pU, fsS32 pV, fsS32 pX, fsS32 pY)
{
	doTextureCopyInto(pSrc, pU, pV, pX, pY);
}

std::shared_ptr<fsITexture> fsITexture::createWithEmptyImage(fsS32 pWidth, fsS32 pHeight)
{
	std::shared_ptr<fsITexture> ret = std::shared_ptr<fsITexture>(new fsCTexture());
	ret->emptyImageCreate(pWidth, pHeight);
	return ret;
}

std::shared_ptr<fsITexture> fsITexture::createFromImageFile(fsSOptions const& pOptions)
{
	std::shared_ptr<fsITexture> ret = std::shared_ptr<fsITexture>(new fsCTexture());

	ret->imageFileLoad(pOptions.mImageFilename, pOptions.mUVAnimation);

	if (pOptions.mMultiMask)
	{
		ret->imageFileLoad(pOptions.mImageFilename, pOptions.mUVAnimation);
	}

	if (pOptions.mCreateHitMap)
	{
		ret->hitMapStore();
	}

	if (!pOptions.mDeferedUpload)
	{
		ret->finalise();
	}
	return ret;
}

std::shared_ptr<fsITexture> fsITexture::createAlpha8FromTextureWithHitmap(
	std::shared_ptr<fsITexture> const pTextureWithHitmap,
	fsS32 pU, fsS32 pV, fsS32 pW, fsS32 pH)
{
	fsPoint potDimensions{roundToPow2(pW), roundToPow2(pH)};
	std::vector<fsU8> alpha8Data(potDimensions.x * potDimensions.y, 0);

	pTextureWithHitmap->alpha8TexDataGet(pTextureWithHitmap, alpha8Data, pU, pV, pW, pH, potDimensions);

	std::shared_ptr<fsITexture> ret = std::shared_ptr<fsITexture>(new fsCTexture());
	ret->createFromAlpha8Data(alpha8Data, pW, pH, potDimensions);

	return ret;
}

void fsITexture::alpha8TexDataGet(std::shared_ptr<fsITexture> const pTextureWithHitmap, std::vector<fsU8>& pAlphaData,
                                  fsS32 pU, fsS32 pV, fsS32 pW, fsS32 pH, fsPoint const& pPotDimensions) const
{
	fsAssert(!pTextureWithHitmap->mHitMap.empty(), "Source texture does not have a hitmap.\n");

	for (fsS32 row = 0; row < pH; ++row)
	{
		for (fsS32 col = 0; col < pW; ++col)
		{
			fsU8 const alphaValue = pTextureWithHitmap->hitTest(fsPoint(pU + col, pV + row)) ? 0xff : 0x00;
			pAlphaData[col + (row * pPotDimensions.x)] = alphaValue;
		}
	}
}

fsS32 fsITexture::roundToPow2(fsS32 pDimension)
{
	fsS32 pow2 = 16; // MW [11/4/2014|11:49]	- Smallest texture dimension on 3DS
	while (pow2 < pDimension)
	{
		pow2 *= 2;
	}
	return pow2;
}

void fsITexture::hitMapStore(fsU8 pAlphaThreshold/* = 0*/)
{
	const fsS32 imgW = imageWidthGet();
	const fsS32 imgH = imageHeightGet();

	int pixelCount = imgW * imgH;
	while ((pixelCount & mByteMask) != 0)
	{
		++pixelCount;
	}

	mHitMap.resize(scaleDownToBits(pixelCount));
	fsU32 curr = 0;

	unsigned char currByte = 0;
	int currBit = 0;

	for (int currRow = 0; currRow < imgH; ++currRow)
	{
		for (int currCol = 0; currCol < imgW; ++currCol)
		{
			if (alphaValueGet(currCol, currRow) > pAlphaThreshold)
			{
				currByte |= (1 << currBit);
			}

			if (++currBit > mByteMask)
			{
				mHitMap[curr++] = currByte;
				currByte = currBit = 0;
			}
		}
	}

	if (currBit)
	{
		mHitMap[curr] = currByte;
	}
}

fsBool fsITexture::hasHitMapGet() const
{
	return !mHitMap.empty();
}

fsBool fsITexture::hitTest(fsPoint const& pLocalPoint) const
{
	fsAssert(!mHitMap.empty(), "Attempting to perform a hit text on a fsITexture that does not have a hit map.\n");

	if (pLocalPoint.x < 0 || pLocalPoint.y < 0
		|| pLocalPoint.x >= imageWidthGet() || pLocalPoint.y >= imageHeightGet())
	{
		return false;
	}

	fsS32 dataOff = pLocalPoint.x + (pLocalPoint.y * imageWidthGet());
	fsS32 currBit = dataOff & mByteMask;
	dataOff = scaleDownToBits(dataOff);
	return ((mHitMap[dataOff] & (1 << currBit)) != 0);
}

fsS32 fsITexture::scaleDownToBits(fsS32 pVal)
{
	return pVal >> 3;
}

void fsITexture::emptyImageCreate(fsS32 pWidth, fsS32 pHeight)
{
	mImage = fsIImage::create({pWidth, pHeight});
	mWidth = pWidth;
	mHeight = pHeight;
}

void fsITexture::imageLoad(const fsCResourceName& pImageFileName)
{
	mImage = fsIImage::create(pImageFileName);
	mWidth = mImage->dimensionsGet().x;
	mHeight = mImage->dimensionsGet().y;
}

void fsITexture::imageFileLoad(const fsCResourceName& pImageFileName, fsBool pUVAnimation)
{
	imageLoad(pImageFileName);
}

void fsITexture::maskFileLoad(const fsCResourceName& pImageFileName, fsBool pUVAnimation)<--- The member function 'fsITexture::maskFileLoad' can be static.
{
	// fsStr filename = pImageFileName.nameGet();
	// filename.replaceAll(".png", "-m");
	// filename += ".png";

	// if (fsIFile::fileExistsGet(fsCResourceName(filename, pImageFileName.locationGet())))
	// {
	// 	mMaskImage = new ax::Image();
	// 	mMaskImage->initWithImageFile(filename.utf8Get());
	// }
}

fsITexture::fsITexture():
mWidth(0),
mHeight(0)
{
}

fsITexture::~fsITexture()
{
}