3D API中，字体绘制的Batch优化

在3D引擎中绘制字符是很恶心的事情。一个个绘制吧又太慢。组成一个大mesh吧。
又太耗引擎的人品。而且还是得lock/unlock vb。
才绘制了一百多个字。 fps从600掉到80多。

经过跟别人的讨论。pos之类的数据用shader constant来传递会效率高一些。
于是做了这样个处理。
1. 做72个1x1大小的Quad。 （其实可以用一个，DrawInstance就好了）。
2. 将纹理相同的char集合起来。
3. 准备一个shader接受 72个字符的信息（pos , texture , color)。其实最多可以81个。 81x3 = 243 + 3 x 4 = 255(最多256个constant)
4. 将这些constant一次性传递过去。一次绘制72个字符。

这个好处是1 没有lock unlock vb。2. 一次绘制最多72个字符。效率更高。

这样处理后，绘制100个字符后， fps基本没有多大的变化。

BEGIN_NAMESPACE_XEVOL3D;
class xBatchFontDevice : public IFontRenderDevice
{
IRenderApi* m_pRenderApi;
eFontFilter m_filter;
IBlenderState* m_BlendState;
ISamplerState* m_pPointSampler;
ISamplerState* m_pLinearSampler;
HGpuProgram m_pDefFontShader;
HGpuProgram m_pUsrFontShader;
IDepthStencilState* m_pStencilState;


IVertexStream* m_pVertexStream;
IInputBuffer* m_pVertexBuffer;
IInputBuffer* m_pIdxBuffer ;
IInputAssembler* m_pAss ;
int m_nQuad ;


float4 m_FontColor[72];
float4 m_SrcRect [72];
float4 m_DstRect [72];
int m_iQuadIndex;
IBaseTexture* m_pTexture;
struct xBathFontVertex
{
xvec4 m_pos;
xvec2 m_uv[2];
};
public:
IMPL_REFCOUNT_OBJECT_INTERFACE(xBatchFontDevice);
xBatchFontDevice(IRenderApi* pRenderApi);
~xBatchFontDevice();
IRenderApi* renderApi(){return m_pRenderApi ; }
public:
virtual bool resetFontFilter() { return true ; }
virtual bool setUVLayer(int nUVLayer);
virtual bool setShaderProgram(HGpuProgram pProgram);
virtual bool init();
virtual bool setFontFilter(eFontFilter filter);
virtual bool beginFontRender();
virtual bool endFontRender();
virtual bool commit();
virtual bool drawRectf(IBaseTexture* pTexture, float vDestRect[4] , const xColor_4f& color);
virtual bool drawRectf(IBaseTexture* pTexture, float vDestRect[4] ,float vSrcRect[4] , const xColor_4f& color);
virtual IBaseTexture* createTexture(int w , int h , ePIXEL_FORMAT fmt , bool bReadable , eResourceUsage usage , int nMipMap = 1, int nArraySize = 1 );
virtual bool isTextureSupport(ePIXEL_FORMAT fmt , bool lockable = true);
};




bool xBatchFontDevice::setUVLayer(int nUVLayer)
{


return true;
}


bool xBatchFontDevice::setShaderProgram(HGpuProgram pProgram)
{
m_pUsrFontShader = pProgram;
return true;
}


bool xBatchFontDevice::init()
{
xInputLayoutDesc InputDesc;
InputDesc.addElement(SHADER_SEMANTIC_POSITION , SHADERVARTYPE_FLOAT4 );
InputDesc.addElement(SHADER_SEMANTIC_TEXCOORD , SHADERVARTYPE_FLOAT2 , 0);
InputDesc.addElement(SHADER_SEMANTIC_TEXCOORD , SHADERVARTYPE_FLOAT2 , 1);
InputDesc.addBufferDesc(RESOURCE_USAGE_DEFAULT , RESOURCE_ACCESS_NONE);


m_pAss = m_pRenderApi->createInputAssembler(L"BatchFont", InputDesc);
m_pVertexStream = m_pAss->createVertexStream();


m_nQuad = m_pRenderApi->intCapsValue(L"FontBatchCount" , 72 );
if(m_nQuad > 72) m_nQuad = 72;
xFaceIndex16_U indices[ 72 * 2 ];
for(int i = 0 ; i < m_nQuad ; i ++)
{
int baseIndex = i * 4;
indices[i * 2 ].v1 = 0 + baseIndex;
indices[i * 2 ].v2 = 2 + baseIndex;
indices[i * 2 ].v3 = 1 + baseIndex;


indices[i * 2 + 1].v1 = 2 + baseIndex;
indices[i * 2 + 1].v2 = 0 + baseIndex;
indices[i * 2 + 1].v3 = 3 + baseIndex;
}
xInputBufferDesc idxBufDesc;
idxBufDesc.m_usage = RESOURCE_USAGE_DEFAULT;
idxBufDesc.m_accessFlage = RESOURCE_ACCESS_NONE;
idxBufDesc.m_bindtype = BIND_AS_INDEX_BUFFER;
m_pIdxBuffer = m_pRenderApi->createInputBuffer(72 * 6 , 2 , &idxBufDesc,indices);
//////////////////////////////////////////////////////////////////////////
xInputBufferDesc vBufDesc;
vBufDesc.m_usage = RESOURCE_USAGE_DEFAULT;
vBufDesc.m_accessFlage = RESOURCE_ACCESS_NONE;
vBufDesc.m_bindtype = BIND_AS_VERTEX_BUFFER;


xBathFontVertex batchVertex[72 * 4];
float _zValue = m_pRenderApi->get2DZValue();
for(int i = 0 ; i < 72 ; i ++)
{
xBathFontVertex* Vertex = batchVertex + i * 4;
Vertex[0].m_uv[0] = Vertex[0].m_uv[1] = xvec2(0.0f , 1.0f);
Vertex[1].m_uv[0] = Vertex[1].m_uv[1] = xvec2(0.0f , 0.0f);
Vertex[2].m_uv[0] = Vertex[2].m_uv[1] = xvec2(1.0f , 0.0f);
Vertex[3].m_uv[0] = Vertex[3].m_uv[1] = xvec2(1.0f , 1.0f);

Vertex[0].m_pos = xvec4(0.0f , 1.0f , _zValue , i);
Vertex[1].m_pos = xvec4(0.0f , 0.0f , _zValue , i);
Vertex[2].m_pos = xvec4(1.0f , 0.0f , _zValue , i);
Vertex[3].m_pos = xvec4(1.0f , 1.0f , _zValue , i);
}


m_pVertexStream->createInputBuffer( 0 , 4 * m_nQuad , &batchVertex , &vBufDesc );
m_pVertexBuffer = m_pVertexStream->getInputBuffer(0);
m_pVertexBuffer->update(eLock_WriteDiscard , batchVertex , sizeof(xBathFontVertex) * 4 * 72);




m_iQuadIndex = 0;


m_filter = eFontFilter_Point;


if(m_pDefFontShader.isHandle() == false)
{
HGpuProgram hGpuProgram = m_pRenderApi->gpuProgramManager()->load(L"batchFont.vertex", L"font.pixel");
m_pDefFontShader = hGpuProgram;
}


if(m_pStencilState == NULL) { m_pStencilState = m_pRenderApi->createDepthStencilState(L"Overlay");}
if(m_pPointSampler == NULL) { m_pPointSampler = m_pRenderApi->createSamplerState(L"FontPoint"); }
if(m_pLinearSampler == NULL) { m_pLinearSampler = m_pRenderApi->createSamplerState(L"FontLinear"); }
if(m_BlendState == NULL) { m_BlendState = m_pRenderApi->createBlendState(L"Font.Blend"); }
return true;
}


bool xBatchFontDevice::setFontFilter(eFontFilter filter)
{
m_filter = filter;
if(m_filter == eFontFilter_Point)
{
return m_pRenderApi->setSamplerState(eShader_PixelShader , 0 , m_pPointSampler );
}
else if(m_filter == eFontFilter_Linear)
{
return m_pRenderApi->setSamplerState(eShader_PixelShader , 0 , m_pLinearSampler );
}
return false;
}


xBatchFontDevice::xBatchFontDevice(IRenderApi* pRenderApi)
{
m_filter = eFontFilter_Point;
m_pStencilState = NULL;
m_pDefFontShader.setNULL();
m_pRenderApi = pRenderApi;
m_pPointSampler = NULL;
m_pLinearSampler = NULL;
m_BlendState = NULL;
m_pUsrFontShader.setNULL();
m_pTexture = NULL;


m_pVertexStream= NULL;
m_pVertexBuffer= NULL;
m_pIdxBuffer = NULL;
m_pAss = NULL;
m_nQuad = 0;
m_iQuadIndex = 0;


}


xBatchFontDevice::~xBatchFontDevice()
{


}


bool xBatchFontDevice::beginFontRender()
{
if(m_pDefFontShader.isHandle() == false )
return false;
m_pRenderApi->setDepthStencilState(m_pStencilState);
m_pRenderApi->setBlendState(m_BlendState);
IGpuProgramParamTable* pShaderTable = NULL;
if(m_pUsrFontShader)
{
m_pRenderApi->setGpuProgram(m_pUsrFontShader);// pushGpuProgram(m_pUsrFontShader);
pShaderTable = m_pUsrFontShader->getParamTable();// pushGpuProgram(m_pUsrFontShader);
}
else
{
m_pRenderApi->setGpuProgram(m_pDefFontShader) ; // pushGpuProgram(m_pDefFontShader);
pShaderTable = m_pDefFontShader->getParamTable(); // pushGpuProgram(m_pDefFontShader);
}


float4x4 matWorld;
float4x4 matProject;
float4x4 matView;
m_pRenderApi->getCamera()->toMatrix(matView , matProject);
m_pRenderApi->getMatrix(matWorld.data , MATRIXMODE_World );


pShaderTable->setParamater(L"_matWorld" , matWorld , eShader_VertexShader);
pShaderTable->setParamater(L"_matView" , matView , eShader_VertexShader);
pShaderTable->setParamater(L"_matProject" , matProject , eShader_VertexShader);


m_iQuadIndex = 0;
return true;
}


bool xBatchFontDevice::endFontRender()
{
commit();
return true;
}


bool xBatchFontDevice::drawRectf(IBaseTexture* pTexture, float vDestRect[4] , const xColor_4f& color)
{
if(m_pRenderApi)
{
assert(0);
return false;
}
return false;
}


bool xBatchFontDevice::commit()
{
if(m_iQuadIndex == 0)
return true ;


IGpuProgramParamTable* pShaderTable = NULL;
if(m_pUsrFontShader)
{
pShaderTable = m_pUsrFontShader->getParamTable();// pushGpuProgram(m_pUsrFontShader);
}
else
{
pShaderTable = m_pDefFontShader->getParamTable(); // pushGpuProgram(m_pDefFontShader);
}

m_pRenderApi->setTextureByLayer(0 , m_pTexture);
pShaderTable->setParamater(L"SrcRect" , m_SrcRect , m_iQuadIndex , 0 , eShader_VertexShader);
pShaderTable->setParamater(L"DstRect" , m_DstRect , m_iQuadIndex , 0 , eShader_VertexShader);
pShaderTable->setParamater(L"RectColor" , m_FontColor , m_iQuadIndex , 0 , eShader_VertexShader);


m_pRenderApi->setVertexBuffer(m_pVertexBuffer , 0 , sizeof(xBathFontVertex) );
m_pRenderApi->setInputAssembler( m_pAss );
m_pRenderApi->draw(m_pIdxBuffer , m_iQuadIndex * 6 );


m_iQuadIndex = 0;
return true;
}


bool xBatchFontDevice::drawRectf(IBaseTexture* pTexture, float vDestRect[4] ,float vSrcRect[4] , const xColor_4f& color)
{
if(m_pRenderApi)
{
if(m_pTexture != NULL && m_pTexture != pTexture)
commit();


m_pTexture = pTexture;
const xTextureDesc& textDesc = pTexture->desc();
xvec4& dstRect = *((xvec4*)vDestRect);
xvec4 srcRect = *((xvec4*)vSrcRect);
const xTextureDesc& desc = pTexture->desc();


srcRect.rect.x /= desc.m_width;
srcRect.rect.w /= desc.m_width;


//////////////////////////////////////////////////////////////////////////
srcRect.rect.y /= desc.m_height;
srcRect.rect.h /= desc.m_height;


m_SrcRect[m_iQuadIndex] = srcRect;
m_DstRect[m_iQuadIndex] = dstRect;
m_FontColor[m_iQuadIndex] = float4(color.r, color.g,color.b,color.a);
m_iQuadIndex ++;
if(m_iQuadIndex >= m_nQuad )
{
commit();
}
}
return false;
}


IBaseTexture* xBatchFontDevice::createTexture(int w , int h , ePIXEL_FORMAT fmt , bool bReadable, eResourceUsage usage , int nMipMap, int nArraySize)
{
if(m_pRenderApi)
{
xTextureInitDesc texInitDesc(w , h , fmt);
texInitDesc.m_bReadable = bReadable;//;
texInitDesc.m_TextureDesc.m_nMipmap = nMipMap;
texInitDesc.m_TextureDesc.m_nArraySize = nArraySize;
texInitDesc.m_usage = usage;
if(texInitDesc.m_usage == RESOURCE_USAGE_DEFAULT)
{
texInitDesc.m_access = 0;
}
return m_pRenderApi->createTexture(texInitDesc , NULL , 0);
}
return false;
}


bool xBatchFontDevice::isTextureSupport(ePIXEL_FORMAT fmt , bool lockable)
{
if(m_pRenderApi)
{
return m_pRenderApi->isTextureSupport(fmt , lockable);
}
return false;
}


END_NAMESPACE_XEVOL3D;