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 GroundEyeshot::onDraw(bool bWholeGround)
{
PP_BY_NAME_START("GroundEyeshot::onDraw::m_groundRenderQueue.RenderDistance");
// 绘制远景；
int nViewTopX = m_Eyeshot.getViewTopX();
int nViewTopY = m_Eyeshot.getViewTopY();
if (m_pDistanceTexture != NULL)
{
m_groundRenderQueue.RenderDistance(m_nMapWidth, m_nMapHeight, m_nViewWidth, m_nViewHeight, nViewTopX, nViewTopY,
m_pDistanceTexture);
}
PP_BY_NAME_STOP();
PP_BY_NAME_START("GroundEyeshot::onDraw::m_groundRenderQueue.render");
// 绘制Tile；
m_groundRenderQueue.reset();
if(bWholeGround)
{
for(int i = 0;i < m_nTotalGridX;i++)
for(int j = 0;j < m_nTotalGridY;j++)
{
GroundTile *pTile = static_cast<GroundTile*>(getGroundTile(i,j));
m_groundRenderQueue.addTile(pTile);
}
}
else
{
int col = (nViewTopX + m_nViewWidth - 1) / m_nGridWidth - nViewTopX / m_nGridWidth + 1;
int row = (nViewTopY + m_nViewHeight - 1) / m_nGridHeight - nViewTopY / m_nGridHeight + 1;
if(col == 0 || row == 0)
return;
int nGridTopX = nViewTopX / m_nGridWidth;
int nGridTopY = nViewTopY / m_nGridHeight;
// 尝试解决如下问题：将工具栏上的“显示地表线框”按钮按下后，“新建地图”功能表现不正常；
// 此处原有实现没有进行越界保护；
for(int i = nGridTopX; (i < nGridTopX + col) && (i < m_nTotalGridX); i++)
{
for(int j = nGridTopY; (j < nGridTopY + row) && (j < m_nTotalGridY); j++)
{
GroundTile *pTile = static_cast<GroundTile*>(getGroundTile(i,j));
m_groundRenderQueue.addTile(pTile);
}
}
}
m_groundRenderQueue.render();
PP_BY_NAME_STOP();
// 绘制网格线；
if(m_bDrawTileLine)
{
PP_BY_NAME_START("m_groundRenderQueue.renderTileLine");
m_groundRenderQueue.renderTileLine(nViewTopX, nViewTopY);
PP_BY_NAME_STOP();
}
}
void MaterialLayer::endPass(IRenderSystem *pRenderSystem)
{
PP_BY_NAME("MaterialLayer::endPass");
PP_BY_NAME_START("MaterialLayer::endPass::loadContext");
loadContext(pRenderSystem);
PP_BY_NAME_STOP();
}
bool BoneAnimationSet::decode(xs::Stream * data)
{
if( !data) return false;
xs::DataChunk chunk;
xs::DataChunk::stChunk * pChunk = chunk.beginChunk(data);
while( pChunk)
{
if( pChunk->m_ui32DataSize == 0 )
{
pChunk = chunk.nextChunk(data);
continue;
}
xs::MemoryStream stream( (uchar*)pChunk->m_pData, pChunk->m_ui32ChunkSize);
switch( pChunk->m_ui32Type)
{
case 'MVER':
{
stream.read(&m_version, sizeof(m_version));
if( m_version <= 0 ) return false;
}
break;
case 'MANM':
{
uint32 nAnims;
stream.read(&nAnims,sizeof(nAnims));
MODELANIMATION *pAnims = (MODELANIMATION *)(stream.getBuffer() + stream.getPosition());
for(uint i = 0;i < nAnims;i++)
{
uchar AnimnameLen;
stream.read(&AnimnameLen,sizeof(AnimnameLen));
char str[64];
stream.read(str,AnimnameLen);
str[AnimnameLen] = 0;
uint startTime,endTime;
stream.read(&startTime,sizeof(startTime));
stream.read(&endTime,sizeof(endTime));
Animation *pAnimation = new Animation(startTime,endTime,true,str);
if( pAnimation)
{
m_vAnimations.push_back(pAnimation);
if( pAnimation && m_AnimationMap.find(pAnimation->getName() ) == m_AnimationMap.end() )
m_AnimationMap[pAnimation->getName() ] = pAnimation;
}
}
}
break;
case 'MBON':
{
uint nBones;
stream.read(&nBones,sizeof(nBones));
for(uint i = 0;i < nBones;i++)
{
int id;
stream.read(&id,sizeof(id));
uchar JointnameLen;
stream.read(&JointnameLen,sizeof(JointnameLen));
char str[81];
stream.read(str,JointnameLen);
str[JointnameLen] = 0;
int parent;
stream.read(&parent,sizeof(parent));
Vector3 pivot;
stream.read(&pivot,sizeof(pivot));
BoneData *pData = new BoneData;
//读取模型的初始变换
float _t[3],_r[4],_s[3];
stream.read(_t, sizeof(float)*3);
stream.read(_r, sizeof(float)*4);
stream.read(_s, sizeof(float)*3);
pData->initTrans = Vector3(_t[0],_t[1],_t[2]);
pData->initQuat = Quaternion(_r[0],_r[1],_r[2],_r[3]);
//pData->initQuat = Quaternion(_r[0],-_r[2],_r[1],_r[3]);//按3dmax9的方式，这种方式不适合本引擎
pData->initScale = Vector3(_s[0],_s[1],_s[2]);
pData->billboarded = false;
pData->billboardedLockX = false;
pData->billboardedLockY =false;
pData->billboardedLockZ = false;
pData->cameraAnchored = false;
pData->dontInheritRotation = false;
pData->dontInheritScaling = false;
pData->dontInheritTranslation = false;
strcpy(pData->name,str);
pData->objectId = id;
pData->parentId = parent;
pData->pivotPoint = pivot;
pData->pivotRotation = false;
pData->translation.setInterpolationType(INTERPOLATION_NONE);
pData->rotation.setInterpolationType(INTERPOLATION_NONE);
pData->scale.setInterpolationType(INTERPOLATION_NONE);
//pData->translation.setInterpolationType(INTERPOLATION_LINEAR);
//pData->rotation.setInterpolationType(INTERPOLATION_LINEAR);
//pData->scale.setInterpolationType(INTERPOLATION_LINEAR);
uint nKeyframes;
stream.read(&nKeyframes,sizeof(nKeyframes));
for(uint j = 0;j < nKeyframes;j++)
{
ModelKeyframeTranslation kf;
stream.read(&kf,sizeof(kf));
KeyFrame<Vector3> kfTranslation(kf.time,Vector3(kf.v[0],kf.v[1],kf.v[2]));
pData->translation.addKeyFrame(kfTranslation);
}
stream.read(&nKeyframes,sizeof(nKeyframes));
for(uint j = 0;j < nKeyframes;j++)
{
ModelKeyframeRotation kf;
stream.read(&kf,sizeof(kf));
KeyFrame<Quaternion> kfRotation(kf.time,Quaternion(kf.q[0],kf.q[1],kf.q[2],kf.q[3]));
pData->rotation.addKeyFrame(kfRotation);
}
stream.read(&nKeyframes,sizeof(nKeyframes));
for(uint j = 0;j < nKeyframes;j++)
{
ModelKeyframeScale kf;
stream.read(&kf,sizeof(kf));
KeyFrame<Vector3> kfScale(kf.time,Vector3(kf.v[0],kf.v[1],kf.v[2]));
pData->scale.addKeyFrame(kfScale);
}
m_vBones.push_back(pData);
}
}
break;
}
pChunk = chunk.nextChunk(data);
}
//创建骨架
PP_BY_NAME_START("BoneAnimationSet::decode::createCoreSkeleton");
createCoreSkeleton();
PP_BY_NAME_STOP();
m_memorySize += sizeof(*this);
m_memorySize += m_skeleton.getMemeorySize();
m_memorySize += m_vAnimations.size() * sizeof(Animation);
size_t size = m_vBones.size();
for( size_t i =0; i < size; ++i)
m_memorySize += m_vBones[i]->getMemorySize();
return true;
}
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();
}
