void MaterialLayer::endPass(IRenderSystem *pRenderSystem)
{
PP_BY_NAME("MaterialLayer::endPass");
PP_BY_NAME_START("MaterialLayer::endPass::loadContext");
loadContext(pRenderSystem);
PP_BY_NAME_STOP();
}
void TxGuiRenderer::renderBatches(std::vector<RenderBatch>& v)
{
//默认是(SBF_SOURCE_ALPHA,SBF_ONE_MINUS_SOURCE_ALPHA)
SceneBlendFactor src,dst;
m_pRenderSystem->getSceneBlending(src,dst);
m_pRenderSystem->setSceneBlending(SBF_SOURCE_ALPHA,SBF_ONE_MINUS_SOURCE_ALPHA);
string blend1plus1("blend:1+1");
string blendaplus1("blend:a+1");
string dummy("");
PP_BY_NAME("TxGuiRenderer::renderBatches");
uint size = v.size();
for(uint i = 0;i < size;i++)
{
if( v[i].pTexture && v[i].pTexture->getCustomInfo(blend1plus1,dummy) )
m_pRenderSystem->setSceneBlending(SBF_ONE,SBF_ONE);
else if( v[i].pTexture && v[i].pTexture->getCustomInfo(blendaplus1,dummy) )
m_pRenderSystem->setSceneBlending(SBF_SOURCE_ALPHA,SBF_ONE);
else
m_pRenderSystem->setSceneBlending(SBF_SOURCE_ALPHA, SBF_ONE_MINUS_SOURCE_ALPHA);
PP_BY_NAME_START("TxGuiRenderer::renderBatches::m_pRenderSystem->setTexture");
m_pRenderSystem->setTexture(0,v[i].pTexture);
PP_BY_NAME_STOP();
PP_BY_NAME_START("TxGuiRenderer::renderBatches::m_pRenderSystem->drawPrimitive");
m_pRenderSystem->drawPrimitive(PT_TRIANGLES,v[i].ui32VertexStart,v[i].ui32NumVertices);
PP_BY_NAME_STOP();
}
d_bufferPos = 0;
d_vertex_start = 0;
v.clear();
//恢复场景混合
m_pRenderSystem->setSceneBlending(src,dst);
}
void Font::render2dByScale(float xx,float yy,float zz,const ColorValue& color,const wchar_t* pText,float fScale)
{
PP_BY_NAME("Font::render2d");
Matrix4 mtxWorldSave = m_pRenderSystem->getWorldMatrix();
Matrix4 mtxWorld;
mtxWorld.makeTrans(xx,yy,zz);
m_pRenderSystem->setWorldMatrix(mtxWorldSave * mtxWorld);
ColorValue colorSave = m_pRenderSystem->getColor();
m_pRenderSystem->setColor(color);
m_pFTFont->RenderByScale(pText,fScale);
m_pRenderSystem->setColor(colorSave);
m_pRenderSystem->setWorldMatrix(mtxWorldSave);
m_pRenderSystem->setTexture(0,0);
}
void MaterialLayer::saveContext(IRenderSystem *pRenderSystem)
{
PP_BY_NAME("MaterialLayer::saveContext");
pRenderSystem->getSceneBlending(m_sbfSrc,m_sbfDst);
m_alphaCheck = pRenderSystem->alphaCheckEnabled();
pRenderSystem->getAlphaFunction(m_alphaFunc,m_alphaCheckRef);
m_cullingMode = pRenderSystem->getCullingMode();
m_surfaceDiffuse = pRenderSystem->getSurfaceDiffuse();
m_bDepthCheck = pRenderSystem->isDepthBufferCheckEnabled();
m_bDepthWrite = pRenderSystem->isDepthBufferWriteEnabled();
m_bLightingEnabled = pRenderSystem->isLightingEnabled();
m_bFogEnabled = pRenderSystem->isFogEnabled();
m_depthFunction = pRenderSystem->getDepthBufferFunction();
}
void MaterialLayer::loadContext(IRenderSystem *pRenderSystem)
{
PP_BY_NAME("MaterialLayer::loadContext");
pRenderSystem->setTextureWrapS(0,TAM_WRAP);
pRenderSystem->setTextureWrapT(0,TAM_WRAP);
pRenderSystem->setTexture(0,0);
pRenderSystem->setTextureCoordCalculation(0,TEXCALC_NONE);
pRenderSystem->setSceneBlending(m_sbfSrc,m_sbfDst);
pRenderSystem->setAlphaCheckEnabled(m_alphaCheck);
pRenderSystem->setAlphaFunction(m_alphaFunc,m_alphaCheckRef);
pRenderSystem->setCullingMode(m_cullingMode);
pRenderSystem->setSurfaceDiffuse(m_surfaceDiffuse);
pRenderSystem->setDepthBufferCheckEnabled(m_bDepthCheck);
pRenderSystem->setDepthBufferWriteEnabled(m_bDepthWrite);
pRenderSystem->setLightingEnabled(m_bLightingEnabled);
pRenderSystem->enableFog(m_bFogEnabled);
pRenderSystem->setDepthBufferFunction(m_depthFunction);
}
void TxGuiRenderer::doRender()
{
PP_BY_NAME("TxGuiRenderer::doRender");
m_pRenderSystem->setTexcoordVertexBuffer(0,m_pVB,0);
m_pRenderSystem->setDiffuseVertexBuffer(m_pVB,8);
m_pRenderSystem->setVertexVertexBuffer(m_pVB,12);
bool bDepthBufferCheckEnabled = m_pRenderSystem->isDepthBufferCheckEnabled();
bool bDepthBufferWriteEnabled = m_pRenderSystem->isDepthBufferWriteEnabled();
SceneBlendFactor src,dst;
m_pRenderSystem->getSceneBlending(src,dst);
m_pRenderSystem->setSceneBlending(SBF_SOURCE_ALPHA,SBF_ONE_MINUS_SOURCE_ALPHA);
CompareFunction depthBufferFunc = m_pRenderSystem->getDepthBufferFunction();
//m_pRenderSystem->setDepthBufferFunction(CMPF_LESS);
m_pRenderSystem->setDepthBufferCheckEnabled(false);
m_pRenderSystem->setDepthBufferWriteEnabled(true);
//判断是否要移动x,y坐标
float coordinateShift = 0.0f;
if( m_renderSystemType == RS_D3D9 ) coordinateShift = -0.5f;
m_vBatches.clear();
d_vertex_start = 0;
d_currTexture = 0;
d_bufferPos = 0;
MyQuad *myBuff = (MyQuad*)m_pVB->lock(0,0,BL_DISCARD);
// iterate over each quad in the list
for (QuadList::iterator i = d_quadlist.begin(); i != d_quadlist.end(); ++i)
{
const QuadInfo& quad = (*i);
if(d_currTexture != quad.pTexture)
{
if(d_bufferPos)
{
RenderBatch rb;
rb.pTexture = d_currTexture;
rb.ui32VertexStart = d_vertex_start;
rb.ui32NumVertices = d_bufferPos - d_vertex_start;
m_vBatches.push_back(rb);
d_vertex_start = d_bufferPos;
}
d_currTexture = quad.pTexture;
}
//vert0
myBuff[d_bufferPos].vertex[0] = quad.position.d_left + coordinateShift;
myBuff[d_bufferPos].vertex[1] = quad.position.d_top + coordinateShift;
myBuff[d_bufferPos].vertex[2] = quad.z;
myBuff[d_bufferPos].color = quad.topLeftCol;
myBuff[d_bufferPos].tex[0] = quad.texPosition.d_left;
myBuff[d_bufferPos].tex[1] = quad.texPosition.d_top;
++d_bufferPos;
//vert1
myBuff[d_bufferPos].vertex[0] = quad.position.d_left + coordinateShift;
myBuff[d_bufferPos].vertex[1] = quad.position.d_bottom + coordinateShift;
myBuff[d_bufferPos].vertex[2] = quad.z;
myBuff[d_bufferPos].color = quad.bottomLeftCol;
myBuff[d_bufferPos].tex[0] = quad.texPosition.d_left;
myBuff[d_bufferPos].tex[1] = quad.texPosition.d_bottom;
++d_bufferPos;
//vert2
// top-left to bottom-right diagonal
if (quad.splitMode == xsgui::TopLeftToBottomRight)
{
myBuff[d_bufferPos].vertex[0] = quad.position.d_right + coordinateShift ;
myBuff[d_bufferPos].vertex[1] = quad.position.d_bottom + coordinateShift ;
myBuff[d_bufferPos].vertex[2] = quad.z;
myBuff[d_bufferPos].color = quad.bottomRightCol;
myBuff[d_bufferPos].tex[0] = quad.texPosition.d_right;
myBuff[d_bufferPos].tex[1] = quad.texPosition.d_bottom;
}
// bottom-left to top-right diagonal
else
{
myBuff[d_bufferPos].vertex[0] = quad.position.d_right + coordinateShift;
myBuff[d_bufferPos].vertex[1] = quad.position.d_top + coordinateShift;
myBuff[d_bufferPos].vertex[2] = quad.z;
myBuff[d_bufferPos].color = quad.topRightCol;
myBuff[d_bufferPos].tex[0] = quad.texPosition.d_right;
myBuff[d_bufferPos].tex[1] = quad.texPosition.d_top;
}
++d_bufferPos;
//vert3
myBuff[d_bufferPos].vertex[0] = quad.position.d_right + coordinateShift;
myBuff[d_bufferPos].vertex[1] = quad.position.d_top + coordinateShift;
myBuff[d_bufferPos].vertex[2] = quad.z;
myBuff[d_bufferPos].color = quad.topRightCol;
myBuff[d_bufferPos].tex[0] = quad.texPosition.d_right;
myBuff[d_bufferPos].tex[1] = quad.texPosition.d_top;
++d_bufferPos;
//vert4
// top-left to bottom-right diagonal
if (quad.splitMode == xsgui::TopLeftToBottomRight)
{
myBuff[d_bufferPos].vertex[0] = quad.position.d_left + coordinateShift;
myBuff[d_bufferPos].vertex[1] = quad.position.d_top + coordinateShift;
myBuff[d_bufferPos].vertex[2] = quad.z;
myBuff[d_bufferPos].color = quad.topLeftCol;
myBuff[d_bufferPos].tex[0] = quad.texPosition.d_left;
myBuff[d_bufferPos].tex[1] = quad.texPosition.d_top;
}
// bottom-left to top-right diagonal
else
{
myBuff[d_bufferPos].vertex[0] = quad.position.d_left + coordinateShift;
myBuff[d_bufferPos].vertex[1] = quad.position.d_bottom + coordinateShift;
myBuff[d_bufferPos].vertex[2] = quad.z;
myBuff[d_bufferPos].color = quad.bottomLeftCol;
myBuff[d_bufferPos].tex[0] = quad.texPosition.d_left;
myBuff[d_bufferPos].tex[1] = quad.texPosition.d_bottom;
}
++d_bufferPos;
//vert 5
myBuff[d_bufferPos].vertex[0] = quad.position.d_right + coordinateShift;
myBuff[d_bufferPos].vertex[1] = quad.position.d_bottom + coordinateShift;
myBuff[d_bufferPos].vertex[2] = quad.z;
myBuff[d_bufferPos].color = quad.bottomRightCol;
myBuff[d_bufferPos].tex[0] = quad.texPosition.d_right;
myBuff[d_bufferPos].tex[1] = quad.texPosition.d_bottom;
++d_bufferPos;
if(d_bufferPos > (VERTEXBUFFER_CAPACITY - VERTEX_PER_QUAD))
{
RenderBatch rb;
rb.pTexture = d_currTexture;
rb.ui32VertexStart = d_vertex_start;
rb.ui32NumVertices = d_bufferPos - d_vertex_start;
m_vBatches.push_back(rb);
m_pVB->unlock();
renderBatches(m_vBatches);
++i;
if(i != d_quadlist.end())
{
myBuff = (MyQuad*)m_pVB->lock(0,0,BL_DISCARD);
--i;
}
else break;
}
}
if(d_bufferPos > (int)d_vertex_start)
{
RenderBatch rb;
rb.pTexture = d_currTexture;
rb.ui32VertexStart = d_vertex_start;
rb.ui32NumVertices = d_bufferPos - d_vertex_start;
m_vBatches.push_back(rb);
}
d_vertex_start = d_bufferPos;
if(m_pVB->isLocked())m_pVB->unlock();
renderBatches(m_vBatches);
m_pRenderSystem->setDepthBufferFunction(depthBufferFunc);
m_pRenderSystem->setSceneBlending(src,dst);
m_pRenderSystem->setDepthBufferCheckEnabled(bDepthBufferCheckEnabled);
m_pRenderSystem->setDepthBufferWriteEnabled(bDepthBufferWriteEnabled);
m_pRenderSystem->setVertexVertexBuffer(0);
m_pRenderSystem->setDiffuseVertexBuffer(0);
m_pRenderSystem->setTexcoordVertexBuffer(0,0);
m_pRenderSystem->setTexture(0,0);
}
void SubModelInstance::renderForGLES2(IRenderSystem* pRenderSystem,bool useMtl)
{
PP_BY_NAME("SubModelInstance::renderCPUVertexBlend");
IVertexBuffer *pVB = m_pMI->getVertexBuffer();
if( pVB == 0)
return;
IIndexBuffer *pIndexBuffer = m_pMI->getIndexBuffer();
if( pIndexBuffer ==0 )
return;
IShaderProgram* pShader = pRenderSystem->getShaderProgram(ESP_V3_N_UV);
//pRenderSystem->bindCurrentShaderProgram(pShader);
if(pShader)
{
pShader->bind();
}
//索引缓冲从从vb的第0个开始技术，所以偏移，只偏移索引缓冲，不偏移vb缓冲
unsigned int vertex_offset = 0; //vertexStart * 12; //3*sizeof(float)
unsigned int tex_coord_offset = 0; //vertexStart * 8; //2*sizeof(float)
pRenderSystem->setIndexBuffer(pIndexBuffer);
pRenderSystem->setNormalVertexBuffer(pVB,m_pMI->getNumVertices() * 12 + vertex_offset);
//pRenderSystem->setTexcoordVertexBuffer(0,m_pMI->getVertexBufferTexcoord());
pRenderSystem->setVertexVertexBuffer(pVB,vertex_offset);
Matrix4 mtx = pRenderSystem->getWorldMatrix();
pRenderSystem->setWorldMatrix(mtx * getWorldTransform());
IndexType it = m_pMI->getIndexBuffer()->getType();
unsigned int indexoffset = indexStart << 1;
if(it == IT_32BIT)
indexoffset <<= 1;
if( useMtl)
{
if(m_pMI->isAnimatedTexCoord() )
{
int numLayer = m_mtl.numLayers();
for(int i = 0;i < numLayer;i++)
{
MaterialLayer *pLayer = m_mtl.getLayer(i);
if(pLayer->beginPass(pRenderSystem))
{
PP_BY_NAME_START("SubModelInstance::renderCPUVertexBlend::drawRangeIndexedPrimitive(useMtl=true,isAnimatedTexCoord=true)");
pRenderSystem->setTexcoordVertexBuffer(0, m_pMI->getTexCoordBuffer( i ),tex_coord_offset );
//pRenderSystem->drawRangeIndexedPrimitive(PT_TRIANGLES,m_pMI->getIndexBuffer()->getType(),indexStart,indexCount,vertexStart,vertexEnd);
pRenderSystem->drawIndexedPrimitive(PT_TRIANGLES,indexCount,it,(void*)indexoffset);
PP_BY_NAME_STOP();
pLayer->endPass(pRenderSystem);
}
}
}
else
{
pRenderSystem->setTexcoordVertexBuffer(0,m_pMI->getVertexBufferTexcoord(),tex_coord_offset);
int numLayer = m_mtl.numLayers();
for(int i = 0;i < numLayer;i++)
{
MaterialLayer *pLayer = m_mtl.getLayer(i);
if(pLayer->beginPass(pRenderSystem))
{
PP_BY_NAME_START("SubModelInstance::renderCPUVertexBlend::drawRangeIndexedPrimitive(useMtl=true,isAnimatedTexCoord=false)");
//pRenderSystem->drawRangeIndexedPrimitive(PT_TRIANGLES,m_pMI->getIndexBuffer()->getType(),indexStart,indexCount,vertexStart,vertexEnd);
pRenderSystem->drawIndexedPrimitive(PT_TRIANGLES,indexCount,it,(void*)indexoffset);
PP_BY_NAME_STOP();
pLayer->endPass(pRenderSystem);
}
}
}
}
else
{
PP_BY_NAME_START("SubModelInstance::renderCPUVertexBlend::drawRangeIndexedPrimitive(useMtl=false)");
IShaderProgram* pShaderProgram = pRenderSystem->getShaderProgramManager()->getCurrentShaderProgam();
if( 0 != pShaderProgram )
{
}
pRenderSystem->setTexcoordVertexBuffer(0,m_pMI->getVertexBufferTexcoord(),tex_coord_offset);
//pRenderSystem->drawRangeIndexedPrimitive(PT_TRIANGLES,m_pMI->getIndexBuffer()->getType(),indexStart,indexCount,vertexStart,vertexEnd);
pRenderSystem->drawIndexedPrimitive(PT_TRIANGLES,indexCount,it,(void*)indexoffset);
PP_BY_NAME_STOP();
}
pRenderSystem->setWorldMatrix(mtx);
pRenderSystem->setIndexBuffer(0);
pRenderSystem->setVertexVertexBuffer(0);
pRenderSystem->setNormalVertexBuffer(0);
pRenderSystem->setTexcoordVertexBuffer(0,0);
}
void SubModelInstance::renderGPUVertexBlend(IRenderSystem* pRenderSystem,bool useMtl)
{
PP_BY_NAME("SubModelInstance::renderGPUVertexBlend");
IVertexBuffer *pVB = m_pMI->getVertexBuffer();
if( pVB == 0)
return;
IIndexBuffer *pIndexBuffer = m_pMI->getIndexBuffer();
if( pIndexBuffer ==0 )
return;
IVertexBuffer * pBlendWeightBuffer = m_pMI->getBlendWeightBuffer();
if( 0 == pBlendWeightBuffer)
return;
IVertexBuffer * pBlendIndicesBuffer = m_pMI->getBlendIndicesBuffer( m_uiSubModelIndex);
if( 0 == pBlendIndicesBuffer)
return;
IShaderProgram * pProgram = m_pMI->getBlendShaderProgram();
if( 0 == pProgram) return;
if( SPT_LOWLEVEL != pProgram->getProgramType() ) return; //用Lowlevel的shader program
//if( SPT_HIGHLEVEL != pProgram->getProgramType() ) return; //用high level 的shader program
pRenderSystem->setIndexBuffer(pIndexBuffer);
pRenderSystem->setNormalVertexBuffer(pVB,m_pMI->getNumVertices() * 12);
//pRenderSystem->setTexcoordVertexBuffer(0,m_pMI->getVertexBufferTexcoord());
pRenderSystem->setVertexVertexBuffer(pVB);
pRenderSystem->setBlendWeightVertexBuffer( pBlendWeightBuffer, 0);
pRenderSystem->setBlendIndicesVertexBuffer( pBlendIndicesBuffer,0);
Matrix4 mtx = pRenderSystem->getWorldMatrix();
pRenderSystem->setWorldMatrix(mtx * getWorldTransform());
pProgram->bind();
//IHighLevelShaderProgram * pHighLevel = static_cast<IHighLevelShaderProgram*>(pProgram);
//pHighLevel->bindTransformMatrix(TMT_WORLD_VIEW_PROJECTION);
//pHighLevel->setUniformMatrixArray("g_blend_matrices_palette", VERTEX_BLEND_MATRICES_NUM, m_BindedBonesMatrices );
ILowLevelShaderProgram * pLowLevel = static_cast<ILowLevelShaderProgram*>(pProgram);
pLowLevel->setUniformFloatVector4(0,&m_BindedBonesMatricesF[0][0][0],VERTEX_BLEND_MATRICES_NUM * 3);
pLowLevel->bindTransformMatrix(249,TMT_WORLD_VIEW_PROJECTION);
if( useMtl)
{
if(m_pMI->isAnimatedTexCoord() )
{
int numLayer = m_mtl.numLayers();
for(int i = 0;i < numLayer;i++)
{
MaterialLayer *pLayer = m_mtl.getLayer(i);
if(pLayer->beginPass(pRenderSystem))
{
PP_BY_NAME_START("SubModelInstance::renderGPUVertexBlend::drawRangeIndexedPrimitive(useMtl=true, isAnimatedTexCoord=true)");
//设置颜色变量
xs::Vector4 fulldiffuse(pLayer->m_fullDiffuse.r, pLayer->m_fullDiffuse.g, pLayer->m_fullDiffuse.b, pLayer->m_fullDiffuse.a);
//pHighLevel->setUniformVector4("g_material_ambient", xs::Vector4(m_fullDiffuse.r, m_fullDiffuse.g, m_fullDiffuse.b, m_fullDiffuse.a));
//pHighLevel->setUniformVector4("g_material_diffuse", xs::Vector4(m_fullDiffuse.r, m_fullDiffuse.g, m_fullDiffuse.b, m_fullDiffuse.a));
pLowLevel->setUniformFloatVector4(253, fulldiffuse.val,1);
pRenderSystem->setTexcoordVertexBuffer(0, m_pMI->getTexCoordBuffer( i ) );
pRenderSystem->drawRangeIndexedPrimitive(PT_TRIANGLES,m_pMI->getIndexBuffer()->getType(),indexStart,indexCount,vertexStart,vertexEnd);
PP_BY_NAME_STOP();
pLayer->endPass(pRenderSystem);
}
}
}
else
{
pRenderSystem->setTexcoordVertexBuffer(0,m_pMI->getVertexBufferTexcoord());
int numLayer = m_mtl.numLayers();
for(int i = 0;i < numLayer;i++)
{
MaterialLayer *pLayer = m_mtl.getLayer(i);
if(pLayer->beginPass(pRenderSystem))
{
PP_BY_NAME_START("SubModelInstance::renderGPUVertexBlend::drawRangeIndexedPrimitive(useMtl=true,isAnimatedTexCoord=fale)");
//设置颜色变量
xs::Vector4 fulldiffuse(pLayer->m_fullDiffuse.r, pLayer->m_fullDiffuse.g, pLayer->m_fullDiffuse.b, pLayer->m_fullDiffuse.a);
//pHighLevel->setUniformVector4("g_material_ambient", fulldiffuse);
//pHighLevel->setUniformVector4("g_material_diffuse", fulldiffuse);
pLowLevel->setUniformFloatVector4(253, fulldiffuse.val,1);
pRenderSystem->drawRangeIndexedPrimitive(PT_TRIANGLES,m_pMI->getIndexBuffer()->getType(),indexStart,indexCount,vertexStart,vertexEnd);
PP_BY_NAME_STOP();
pLayer->endPass(pRenderSystem);
}
}
}
}
else
{
PP_BY_NAME_START("SubModelInstance::renderGPUVertexBlend::drawRangeIndexedPrimitive(useMtl=false)");
//设置颜色变量
xs::ColorValue color = pRenderSystem->getColor();
//pHighLevel->setUniformVector4("g_material_ambient", xs::Vector4(color.r, color.g, color.b, color.a));
//pHighLevel->setUniformVector4("g_material_diffuse", xs::Vector4(color.r, color.g, color.b, color.a));
pLowLevel->setUniformFloatVector4(253, color.val,1);
pRenderSystem->setTexcoordVertexBuffer(0,m_pMI->getVertexBufferTexcoord());
pRenderSystem->drawRangeIndexedPrimitive(PT_TRIANGLES,m_pMI->getIndexBuffer()->getType(),indexStart,indexCount,vertexStart,vertexEnd);
PP_BY_NAME_STOP();
}
pProgram->unbind();
pRenderSystem->setWorldMatrix(mtx);
pRenderSystem->setBlendIndicesVertexBuffer(0);
pRenderSystem->setBlendWeightVertexBuffer(0);
pRenderSystem->setIndexBuffer(0);
pRenderSystem->setVertexVertexBuffer(0);
pRenderSystem->setNormalVertexBuffer(0);
pRenderSystem->setTexcoordVertexBuffer(0,0);
}
void SubModelInstance::renderCPUVertexBlend(IRenderSystem* pRenderSystem,bool useMtl)
{
PP_BY_NAME("SubModelInstance::renderCPUVertexBlend");
IVertexBuffer *pVB = m_pMI->getVertexBuffer();
if( pVB == 0)
return;
IIndexBuffer *pIndexBuffer = m_pMI->getIndexBuffer();
if( pIndexBuffer ==0 )
return;
pRenderSystem->setIndexBuffer(pIndexBuffer);
pRenderSystem->setNormalVertexBuffer(pVB,m_pMI->getNumVertices() * 12);
//pRenderSystem->setTexcoordVertexBuffer(0,m_pMI->getVertexBufferTexcoord());
pRenderSystem->setVertexVertexBuffer(pVB);
Matrix4 mtx = pRenderSystem->getWorldMatrix();
pRenderSystem->setWorldMatrix(mtx * getWorldTransform());
if( useMtl)
{
if(m_pMI->isAnimatedTexCoord() )
{
int numLayer = m_mtl.numLayers();
for(int i = 0;i < numLayer;i++)
{
MaterialLayer *pLayer = m_mtl.getLayer(i);
if(pLayer->beginPass(pRenderSystem))
{
PP_BY_NAME_START("SubModelInstance::renderCPUVertexBlend::drawRangeIndexedPrimitive(useMtl=true,isAnimatedTexCoord=true)");
pRenderSystem->setTexcoordVertexBuffer(0, m_pMI->getTexCoordBuffer( i ) );
pRenderSystem->drawRangeIndexedPrimitive(PT_TRIANGLES,m_pMI->getIndexBuffer()->getType(),indexStart,indexCount,vertexStart,vertexEnd);
PP_BY_NAME_STOP();
pLayer->endPass(pRenderSystem);
}
}
}
else
{
pRenderSystem->setTexcoordVertexBuffer(0,m_pMI->getVertexBufferTexcoord());
int numLayer = m_mtl.numLayers();
for(int i = 0;i < numLayer;i++)
{
MaterialLayer *pLayer = m_mtl.getLayer(i);
if(pLayer->beginPass(pRenderSystem))
{
PP_BY_NAME_START("SubModelInstance::renderCPUVertexBlend::drawRangeIndexedPrimitive(useMtl=true,isAnimatedTexCoord=false)");
pRenderSystem->drawRangeIndexedPrimitive(PT_TRIANGLES,m_pMI->getIndexBuffer()->getType(),indexStart,indexCount,vertexStart,vertexEnd);
PP_BY_NAME_STOP();
pLayer->endPass(pRenderSystem);
}
}
}
}
else
{
PP_BY_NAME_START("SubModelInstance::renderCPUVertexBlend::drawRangeIndexedPrimitive(useMtl=false)");
IShaderProgram* pShaderProgram = pRenderSystem->getShaderProgramManager()->getCurrentShaderProgam();
if( 0 != pShaderProgram )
{
//绑定变换矩阵
if( pShaderProgram->getProgramType() == SPT_HIGHLEVEL)
static_cast<IHighLevelShaderProgram*>(pShaderProgram)->bindTransformMatrix(TMT_WORLD_VIEW_PROJECTION);
else
static_cast<ILowLevelShaderProgram*>(pShaderProgram)->bindTransformMatrix(0,TMT_WORLD_VIEW_PROJECTION);
}
pRenderSystem->setTexcoordVertexBuffer(0,m_pMI->getVertexBufferTexcoord());
pRenderSystem->drawRangeIndexedPrimitive(PT_TRIANGLES,m_pMI->getIndexBuffer()->getType(),indexStart,indexCount,vertexStart,vertexEnd);
PP_BY_NAME_STOP();
}
pRenderSystem->setWorldMatrix(mtx);
pRenderSystem->setIndexBuffer(0);
pRenderSystem->setVertexVertexBuffer(0);
pRenderSystem->setNormalVertexBuffer(0);
pRenderSystem->setTexcoordVertexBuffer(0,0);
}
bool MaterialLayer::beginPass(IRenderSystem *pRenderSystem)
{
PP_BY_NAME("MaterialLayer::beginPass");
if(!m_pTexture)return false;
PP_BY_NAME_START("MaterialLayer::beginPass::saveContext");
saveContext(pRenderSystem);
PP_BY_NAME_STOP();
pRenderSystem->setTexture(0,m_pTexture);
if(m_bClampS)
{
pRenderSystem->setTextureWrapS(0,TAM_CLAMP_TO_EDGE);
}
if(m_bClampT)
{
pRenderSystem->setTextureWrapT(0,TAM_CLAMP_TO_EDGE);
}
if(m_bTwoSide)
{
pRenderSystem->setCullingMode(CULL_NONE);
}
pRenderSystem->setSurfaceDiffuse(m_fullDiffuse);
if(m_bUnshaded)
{
pRenderSystem->setLightingEnabled(false);
}
else
{
pRenderSystem->setLightingEnabled(true);
}
if(m_bUnfogged)
{
pRenderSystem->enableFog(false);
}
if(m_SphereEnvironmentMap)
{
pRenderSystem->setTextureCoordCalculation(0,TEXCALC_ENVIRONMENT_MAP);
}
BlendMode bm = m_blendMode;
if((bm == BM_OPAQUE || bm == BM_TRANSPARENT || bm == BM_MODULATE2X || bm == BM_TRANSPARENT) && m_fullDiffuse.a < 1.0f)
bm = BM_ALPHA_BLEND;
switch(bm)
{
case BM_OPAQUE:
{
pRenderSystem->setSceneBlending(SBF_ONE,SBF_ZERO);
pRenderSystem->setAlphaCheckEnabled(false);
pRenderSystem->setDepthBufferCheckEnabled(true);
pRenderSystem->setDepthBufferWriteEnabled(true);
break;
}
case BM_TRANSPARENT:
{
pRenderSystem->setSceneBlending(SBF_ONE,SBF_ZERO);
pRenderSystem->setAlphaCheckEnabled(true);
pRenderSystem->setAlphaFunction(CMPF_GREATER_EQUAL,0.7f);
pRenderSystem->setDepthBufferCheckEnabled(true);
pRenderSystem->setDepthBufferWriteEnabled(true);
break;
}
case BM_ALPHA_BLEND:
{
pRenderSystem->setDepthBufferFunction(CMPF_LESS_EQUAL);
pRenderSystem->setAlphaCheckEnabled(false);
pRenderSystem->setSceneBlending(SBF_SOURCE_ALPHA,SBF_ONE_MINUS_SOURCE_ALPHA);
pRenderSystem->setDepthBufferCheckEnabled(true);
if(m_fullDiffuse.a < 1.0f)
pRenderSystem->setDepthBufferWriteEnabled(true);
else
pRenderSystem->setDepthBufferWriteEnabled(false);
break;
}
case BM_ADDITIVE:
{
pRenderSystem->setSceneBlending(SBF_SOURCE_COLOR,SBF_ONE);
pRenderSystem->setAlphaCheckEnabled(false);
pRenderSystem->setDepthBufferCheckEnabled(true);
pRenderSystem->setDepthBufferWriteEnabled(false);
break;
}
case BM_ADDITIVE_ALPHA:
{
pRenderSystem->setSceneBlending(SBF_SOURCE_ALPHA,SBF_ONE);
pRenderSystem->setAlphaCheckEnabled(false);
pRenderSystem->setDepthBufferCheckEnabled(true);
pRenderSystem->setDepthBufferWriteEnabled(false);
break;
}
case BM_MODULATE:
{
pRenderSystem->setSceneBlending(SBF_DEST_COLOR,SBF_SOURCE_COLOR);
pRenderSystem->setAlphaCheckEnabled(false);
pRenderSystem->setDepthBufferCheckEnabled(true);
pRenderSystem->setDepthBufferWriteEnabled(false);
break;
}
case BM_MODULATE2X:
{
pRenderSystem->setSceneBlending(SBF_DEST_COLOR,SBF_SOURCE_COLOR);
pRenderSystem->setAlphaCheckEnabled(false);
pRenderSystem->setDepthBufferCheckEnabled(true);
pRenderSystem->setDepthBufferWriteEnabled(false);
break;
}
case BM_OPAQUE_NOWRITEDEPTH:
{
pRenderSystem->setSceneBlending(SBF_ONE,SBF_ZERO);
pRenderSystem->setAlphaCheckEnabled(false);
pRenderSystem->setDepthBufferCheckEnabled(true);
pRenderSystem->setDepthBufferWriteEnabled(false);
break;
}
}
if(m_bNoDepthTest)
{
pRenderSystem->setDepthBufferCheckEnabled(false);
}
if(m_bNoDepthSet)
{
pRenderSystem->setDepthBufferWriteEnabled(false);
}
return true;
}
void ModelInstance::update(float tick,float tickDelta,IRenderSystem* pRenderSystem,const ColorValue& diffuse)
{
PP_BY_NAME("ModelInstance::update");
advanceTime(tickDelta);
//uint numBones = m_skeleton.getBoneCount();
//if(!numBones)return;
ulong now = xs::getTickCount();
// 这里33ms的检查会导致跳帧，先屏蔽掉，如果对游戏效率有影响再打开这个限制 [4/27/2011 zgz]
//if(m_lastUpdateTime == 0 || now - m_lastUpdateTime >= 33)
{
float lastUpdateTime = m_lastUpdateTime;
m_lastUpdateTime = now;
PP_BY_NAME_START("ModelInstance::update::m_skeleton.calcMatrix");
//if(m_pCurrentAnimation)m_skeleton.calcMatrix(pRenderSystem,&m_currentTime,m_pCurrentAnimation->getRangeIndex());
if(m_pCurrentAnimation)m_skeleton.calcMatrix(&m_currentTime,m_pCurrentAnimation->getRangeIndex());
PP_BY_NAME_STOP();
float tickDelta2 = now - lastUpdateTime;
PP_BY_NAME_START("ModelInstance::update::pRibbonSystem->update");
RibbonSystemList::iterator be = m_vRibbonSystem.begin();
RibbonSystemList::iterator ee = m_vRibbonSystem.end();
while(be != ee)
{
RibbonSystem* pRibbonSystem = (*be);
pRibbonSystem->setColor(diffuse);
pRibbonSystem->update(&m_currentTime,/*tickDelta*/tickDelta2,pRenderSystem);
++be;
}
PP_BY_NAME_STOP();
if( m_pBlendShaderProgram )//如果能够硬件混合
{
PP_BY_NAME_START("ModelInstance::update::pSubModel->updateBonesMatrix");
SubModelList::iterator begin = m_subModels.begin();
SubModelList::iterator end = m_subModels.end();
while(begin != end)
{
SubModelInstance* pSubModel = (*begin);
pSubModel->updateBonesMatrix(&m_skeleton);
++begin;
}
m_pVBVertexBlend = m_pModel->getOriginVertexBuffer();
PP_BY_NAME_STOP();
}
else
{
PP_BY_NAME_START("ModelInstance::update::m_pModel->vertexBlend");
m_pVBVertexBlend = m_pModel->vertexBlend(&m_skeleton,&m_currentTime);
PP_BY_NAME_STOP();
}
PP_BY_NAME_START("ModelInstance::update::m_pModel->texBlend");
m_pModel->texBlend(&m_currentTime);//added for uv animation 2009/07/24
PP_BY_NAME_STOP();
PP_BY_NAME_START("ModelInstance::update::pSubModel->update");
SubModelList::iterator begin = m_subModels.begin();
SubModelList::iterator end = m_subModels.end();
while(begin != end)
{
SubModelInstance* pSubModel = (*begin);
pSubModel->update(&m_currentTime,diffuse);
++begin;
}
PP_BY_NAME_STOP();
}
PP_BY_NAME_START("ModelInstance::update::pParticleSystem->update");
ParticleSystemList::iterator b = m_vParticleSystem.begin();
ParticleSystemList::iterator e = m_vParticleSystem.end();
while(b != e)
{
ParticleSystem* pParticleSystem = (*b);
pParticleSystem->setColor(diffuse);
pParticleSystem->update(&m_currentTime,tickDelta,pRenderSystem);
++b;
}
PP_BY_NAME_STOP();
PP_BY_NAME_START("ModelInstance::update::pMmParticleSystem->update");
MmParticleSystemList::iterator mb = m_vMmParticleSystem.begin();
MmParticleSystemList::iterator me = m_vMmParticleSystem.end();
while(mb != me)
{
MmParticleSystem* pParticleSystem = (*mb);
pParticleSystem->setColor(diffuse);
pParticleSystem->update(pRenderSystem, &m_currentTime,tickDelta,-1);
++mb;
}
PP_BY_NAME_STOP();
}
