Cppcheck report - Fission: libs/fsRenderer/impl/cocos2d-x/vertexStream/fsCVertexRenderer-v3.cpp

#include "fsCVertexRenderer-v3.h"

#if defined fsVertexRenderer

#include <base/CCDirector.h>
#include <2d/CCLayer.h>
#include <2d/CCCamera.h>
#include <renderer/CCRenderer.h>
#include <renderer/ccGLStateCache.h>

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

#include <fs3d/fsC3dSprite.h>
#include <fs3d/fsC3dCamera.h>
#include <fs3d/fsC3dSceneSprite.h>

#include "../../../renderer/fsISpriteRenderData.h"
#include "../../../renderer/fsILineRenderData.h"
#include "../../../renderer/fsITextEntryRenderData.h"
#include "../../../renderer/fsCMaterial.h"

#if defined fsPLATFORM_CX_V3
	#include "../vertexStream/fsCVertexStreamTextSpriteRenderData-v3.h"
#else
	#include "../vertexStream/fsCVertexStreamTextSpriteRenderData.h"
#endif

#include "../fsCTexture.h"
#include "../fsCFont.h"


#if defined fs3d

void fsCRenderer::sprite3dBatchRender(fsC3dSceneSprite* const p3dScene)
{
	prepareFor3d();
	p3dScene->renderScene();
}

#endif

void fsCRenderer::frameStartDo()
{
}

void fsCRenderer::begin2dDo()
{
	mSpriteIndex = 0;
	mTxtSprIndex = 0;
	mLineBatch = 0;
}

void fsCRenderer::blendModeSet(fsS32 pBlendMode)<--- The member function 'fsCRenderer::blendModeSet' can be static.
{
	switch (pBlendMode)
	{
		case fsCMaterial::eALPHA_NONE:
			cocos2d::GL::blendFunc(cocos2d::BlendFunc::DISABLE.src, cocos2d::BlendFunc::DISABLE.dst);
			break;

		case fsCMaterial::eALPHA_ADD:
			cocos2d::GL::blendFunc(cocos2d::BlendFunc::ADDITIVE.src, cocos2d::BlendFunc::ADDITIVE.dst);
			break;
		
		case fsCMaterial::eALPHA_SUB:
			cocos2d::GL::blendFunc(cocos2d::BlendFunc::DISABLE.src, cocos2d::BlendFunc::DISABLE.dst);
			break;

		case fsCMaterial::eALPHA_BLEND:
			//If pre multiplied textures are used then....
			//cocos2d::GL::blendFunc(cocos2d::BlendFunc::ALPHA_PREMULTIPLIED.src, cocos2d::BlendFunc::ALPHA_PREMULTIPLIED.dst);
			cocos2d::GL::blendFunc(cocos2d::BlendFunc::ALPHA_NON_PREMULTIPLIED.src, cocos2d::BlendFunc::ALPHA_NON_PREMULTIPLIED.dst);
			break;	
	}
}

void fsCRenderer::spriteBatchRender(fsS32 pFirstMaterialIndex, fsS32 pLastMaterialIndex)
{
    blendModeSet(fsCMaterial::eALPHA_BLEND);
	for (fsS32 material = pFirstMaterialIndex; material <= pLastMaterialIndex; ++material)
	{
		spriteBatchDataAllocateFromCache(numVertsGet(material));
		spriteBatchDataPopulate(material);
		spriteBatchDataRender(material);
	}
}

void fsCRenderer::spriteBatchDataAllocateFromCache(fsS32 pNumVerts)
{
	mRenderBuffers.mBatchedVerts.init((pNumVerts+2) * 2);
	mRenderBuffers.mBatchedUVs.init(pNumVerts * 2);
	mRenderBuffers.mBatchedColours.init(pNumVerts * 4);
}

void fsCRenderer::spriteBatchDataPopulate(fsS32 pMaterial)
{
	fsRenderBuffersPtr buf(mRenderBuffers);
	eSPRITE_STRIP_PLACE pos = eFIRST;
	for (fsS32 sprite = 0 ; sprite < mSpritesPerMaterial[ pMaterial ] ; ++sprite)
 	{
 		const fsISpriteRenderData* const sprRenData = mSpriteRenderData[mSpriteIndex++];
		sprRenData->batchDataPopulate(&buf, pos);
		(sprite + 1 == mSpritesPerMaterial[pMaterial]) ? pos = eLAST : pos = eSTRIPPED;
	}
}

void fsCRenderer::spriteBatchDataRender(fsS32 pMaterial)
{
	if (const fsCTexture * const texPtr = static_cast<const fsCTexture*>(mMaterials[pMaterial]->texturePtrGet()))
	{
		cocos2d::Texture2D* const texImpl = texPtr->textureGet();

		cocos2d::GLProgramState* const glState = cocos2d::GLProgramState::getOrCreateWithGLProgramName(
			cocos2d::GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR, texImpl);

		glState->getGLProgram()->use();
		glState->getGLProgram()->setUniformsForBuiltins();

		cocos2d::GL::bindTexture2D(texImpl->getName());
		blendModeSet(mMaterials[pMaterial]->alphaBlendGet());

        glEnableVertexAttribArray(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION);
		glEnableVertexAttribArray(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR);
		glEnableVertexAttribArray(cocos2d::GLProgram::VERTEX_ATTRIB_TEX_COORD);

		glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, mRenderBuffers.mBatchedVerts.mBuffer);
		glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, mRenderBuffers.mBatchedColours.mBuffer);
		glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, 0, mRenderBuffers.mBatchedUVs.mBuffer);

		glDrawArrays(GL_TRIANGLE_STRIP, 0, numVertsGet(pMaterial));
	}
	else
	{
		cocos2d::GLProgramState* const glState = cocos2d::GLProgramState::getOrCreateWithGLProgramName(
			cocos2d::GLProgram::SHADER_NAME_POSITION_COLOR);


        glState->getGLProgram()->use();
        glState->getGLProgram()->setUniformsForBuiltins();
		blendModeSet(mMaterials[pMaterial]->alphaBlendGet());

        glEnableVertexAttribArray(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION);
		glEnableVertexAttribArray(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR);

        glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, mRenderBuffers.mBatchedVerts.mBuffer);
		glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, mRenderBuffers.mBatchedColours.mBuffer);

		glDrawArrays(GL_TRIANGLE_STRIP, 0, numVertsGet(pMaterial));
	}
}

fsS32 fsCRenderer::numVertsGet(fsS32 pMaterial) const
{
	return mSpritesPerMaterial[pMaterial] * 4 + (mSpritesPerMaterial[pMaterial] - 0) * 2; // quad => 4 verts plus 2 for degenerate join ups
}

void fsCRenderer::textBatchRender(fsS32 pFirstFontIndex, fsS32 pLastFontIndex)
{
	blendModeSet(fsCMaterial::eALPHA_BLEND);
	cocos2d::GLProgramState* glState = cocos2d::GLProgramState::getOrCreateWithGLProgramName(cocos2d::GLProgram::SHADER_NAME_LABEL_NORMAL);
    
    glState->getGLProgram()->use();
    glState->getGLProgram()->setUniformsForBuiltins();

    glEnableVertexAttribArray(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION);
    glEnableVertexAttribArray(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR);
    glEnableVertexAttribArray(cocos2d::GLProgram::VERTEX_ATTRIB_TEX_COORD);
    
    GLuint _uniformTextColor = glGetUniformLocation(glState->getGLProgram()->getProgram(), "u_textColor");

    for (fsS32 font = pFirstFontIndex; font <= pLastFontIndex; ++font)
	{
		for (fsS32 txtStr = 0; txtStr < mTextStringsPerFont[font]; ++ txtStr)
		{
            glState->getGLProgram()->setUniformLocationWith4f(_uniformTextColor, 1, 1, 1, 1);
			mTextRenderData[mTxtSprIndex]->implRender();
			++mTxtSprIndex;
		}
	}
}

void fsCRenderer::textEntryBatchRender(fsITextEntryRenderData* const pTextEntry)
{
//    pTextEntry->render();
}

void fsCRenderer::lineBatchRender(fsS32 pBatchIndex)
{
	lineBatchDataAllocateFromCache(pBatchIndex);
	lineBatchDataPopulate(pBatchIndex);
	lineBatchDataRender(pBatchIndex);
}

void fsCRenderer::lineBatchDataAllocateFromCache(fsS32 pBatchIndex)
{
	const fsS32 numVerts = mLinesPerBatch[pBatchIndex];
	mRenderBuffers.mBatchedVerts.init(numVerts * 2);
	mRenderBuffers.mBatchedColours.init(numVerts * 4);
}

void fsCRenderer::lineBatchDataPopulate(fsS32 pBatchIndex)
{
	fsRenderBuffersPtr buf(mRenderBuffers);
	const fsILineRenderData* const lineRenderData = mLineRenderData[mLineBatch++];
	lineRenderData->batchDataPopulate(&buf, eFIRST);
}

void fsCRenderer::lineBatchDataRender(fsS32 pBatchIndex)
{
	cocos2d::GLProgramState* glState = cocos2d::GLProgramState::getOrCreateWithGLProgramName(
		cocos2d::GLProgram::SHADER_NAME_POSITION_COLOR);

	glEnableVertexAttribArray(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION);
	glEnableVertexAttribArray(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR);
	glState->getGLProgram()->use();
	glState->getGLProgram()->setUniformsForBuiltins();

	glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, mRenderBuffers.mBatchedVerts.mBuffer);
	glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, mRenderBuffers.mBatchedColours.mBuffer);

	glDrawArrays(GL_LINES, 0, mLinesPerBatch[pBatchIndex]);
}

void fsCRenderer::end2dDo()
{
	cocos2d::Director::getInstance()->getRenderer()->render();
}

void fsCRenderer::begin3dDo()
{
}

void fsCRenderer::end3dDo()
{
	cocos2d::Director::getInstance()->getRenderer()->render();
}

void fsCRenderer::frameEndDo()
{
}

void fsCRenderer::initialiseDo()
{
}

void fsCRenderer::uninitialiseDo()
{
}

fsCRenderer::fsCRenderer( fsS32 pMaxSprites, fsS32 pMaxMaterialChanges ) :
fsIRenderer( pMaxSprites, pMaxMaterialChanges ),
mSpriteIndex( 0 ),
mTxtSprIndex(0),
mLineBatch(0),
mZoom(1.0f),
mTrackingScale(1.0f)
{
}

fsCRenderer::~fsCRenderer()
{
}

fsCRenderer::fsSF32VertBuffer::fsSF32VertBuffer() :
mSize(0),
mBuffer(nullptr) {}

fsCRenderer::fsSF32VertBuffer::~fsSF32VertBuffer()
{
	if (mSize)
	{
		delete mBuffer;<--- Struct 'fsSF32VertBuffer' does not have a copy constructor which is recommended since it has dynamic memory/resource management.<--- Struct 'fsSF32VertBuffer' does not have a operator= which is recommended since it has dynamic memory/resource management.
	}
}

void fsCRenderer::fsSF32VertBuffer::init(fsS32 pSize)
{
	if (pSize > mSize)
	{
		delete[]mBuffer;
		mBuffer = new fsF32[pSize];
		mSize = pSize;
	}
}

#endif