/**
* CABT::renderTree
* @date Modified Apr 17, 2006
*/
void CABT::renderTree(CFrustum& oFrustum, SABTNode* pNode, bool bContained)
{
ACEASSERT(pNode);
// Process subnodes
CFrustum::EFrustumTest eTest = CFrustum::TEST_IN;
eTest = oFrustum.containsAABB(pNode->m_oAABB);
if(eTest == CFrustum::TEST_OUT)
return;
// Draw geometry, if the node is a leaf.
if(pNode->m_bIsLeaf)
{
for(size_t v = 0; v < pNode->m_nVertCount/3; ++v)
m_pRenderQueue->addRenderable(&pNode->m_pTris[v]);
m_nNumTrianglesRendered += pNode->m_nVertCount / 3;
#ifdef _DEBUG
static int i = 0;
if(true)
{
drawBoundingBox(pNode->m_oAABB, D3DCOLOR_XRGB(255, 0, 0));
}
#endif
}
if(pNode->m_pLeft) renderTree(oFrustum, pNode->m_pLeft, eTest == CFrustum::TEST_IN);
if(pNode->m_pRight) renderTree(oFrustum, pNode->m_pRight, eTest == CFrustum::TEST_IN);
}
void LLDrawPoolTree::render(S32 pass)
{
LLFastTimer t(LLPipeline::sShadowRender ? FTM_SHADOW_TREE : FTM_RENDER_TREES);
if (mDrawFace.empty())
{
return;
}
LLGLEnable test(GL_ALPHA_TEST);
LLOverrideFaceColor color(this, 1.f, 1.f, 1.f, 1.f);
if (gSavedSettings.getBOOL("RenderAnimateTrees"))
{
renderTree();
}
else
{
gGL.getTexUnit(sDiffTex)->bind(mTexturep);
for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
iter != mDrawFace.end(); iter++)
{
LLFace *face = *iter;
LLVertexBuffer* buff = face->getVertexBuffer();
if(buff)
{
buff->setBuffer(LLDrawPoolTree::VERTEX_DATA_MASK);
buff->drawRange(LLRender::TRIANGLES, 0, buff->getRequestedVerts()-1, buff->getRequestedIndices(), 0);
gPipeline.addTrianglesDrawn(buff->getRequestedIndices());
}
}
}
}
void LLDrawPoolTree::renderForSelect()
{
if (mDrawFace.empty())
{
return;
}
LLOverrideFaceColor color(this, 1.f, 1.f, 1.f, 1.f);
LLGLSObjectSelectAlpha gls_alpha;
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
gGL.setSceneBlendType(LLRender::BT_REPLACE);
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f);
gGL.getTexUnit(0)->setTextureColorBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_PREV_COLOR);
gGL.getTexUnit(0)->setTextureAlphaBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_ALPHA, LLTexUnit::TBS_VERT_ALPHA);
renderTree(TRUE);
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
}
void RedBlackTree::render( sf::RenderWindow *w)
{
if(raiz!=NULL)
renderTree(w,raiz);
this->message->render(w);
}
/**
* CABT::renderTree
* @date Modified Apr 17, 2006
*/
void CABT::renderTree(CFrustum& oFrustum)
{
if(!m_pRoot)
return;
m_nNumTrianglesRendered = 0;
renderTree(oFrustum, m_pRoot);
m_pRenderQueue->renderAll(oFrustum.getViewPosition());
}
void LLDrawPoolTree::renderForSelect()
{
if (mDrawFace.empty())
{
return;
}
LLOverrideFaceColor color(this, 1.f, 1.f, 1.f, 1.f);
LLGLSObjectSelectAlpha gls_alpha;
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
gGL.setSceneBlendType(LLRender::BT_REPLACE);
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f);
gGL.getTexUnit(0)->setTextureColorBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_PREV_COLOR);
gGL.getTexUnit(0)->setTextureAlphaBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_ALPHA, LLTexUnit::TBS_VERT_ALPHA);
if (gSavedSettings.getBOOL("RenderAnimateTrees"))
{
renderTree(TRUE);
}
else
{
gGL.getTexUnit(sDiffTex)->bind(mTexturep);
for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
iter != mDrawFace.end(); iter++)
{
LLFace *face = *iter;
LLDrawable *drawablep = face->getDrawable();
if (drawablep->isDead() || face->mVertexBuffer.isNull())
{
continue;
}
// Render each of the trees
LLVOTree *treep = (LLVOTree *)drawablep->getVObj().get();
LLColor4U color(255,255,255,255);
if (treep->mGLName != 0)
{
S32 name = treep->mGLName;
color = LLColor4U((U8)(name >> 16), (U8)(name >> 8), (U8)name, 255);
LLFacePool::LLOverrideFaceColor col(this, color);
face->mVertexBuffer->setBuffer(LLDrawPoolTree::VERTEX_DATA_MASK);
face->mVertexBuffer->drawRange(LLRender::TRIANGLES, 0, face->mVertexBuffer->getRequestedVerts()-1, face->mVertexBuffer->getRequestedIndices(), 0);
gPipeline.addTrianglesDrawn(face->mVertexBuffer->getRequestedIndices()/3);
}
}
}
void RedBlackTree::renderTree(sf::RenderWindow *w, Node*n)
{
if(n==NULL)
return;
n->render(w);
if(n->izquierdo!=NULL)
{
renderTree(w,n->izquierdo);
}
if(n->derecho!=NULL)
{
renderTree(w,n->derecho);
}
}
void LLDrawPoolTree::render(S32 pass)
{
LLFastTimer t(LLFastTimer::FTM_RENDER_TREES);
if (mDrawFace.empty())
{
return;
}
LLGLEnable test(GL_ALPHA_TEST);
LLOverrideFaceColor color(this, 1.f, 1.f, 1.f, 1.f);
renderTree();
}
void Canvas::doFrame(bool bPythonAvailable)
{
emitPreRenderSignal();
if (!m_pPlayer->isStopping()) {
ScopeTimer Timer(RenderProfilingZone);
Player::get()->startTraversingTree();
if (bPythonAvailable) {
Py_BEGIN_ALLOW_THREADS;
try {
renderTree();
} catch(...) {
Py_BLOCK_THREADS;
Player::get()->endTraversingTree();
throw;
}
Py_END_ALLOW_THREADS;
} else {
renderTree();
}
Player::get()->endTraversingTree();
}
emitFrameEndSignal();
}
void LLDrawPoolTree::render(S32 pass)
{
LLFastTimer t(LLFastTimer::FTM_RENDER_TREES);
if (mDrawFace.empty())
{
return;
}
gPipeline.enableLightsDynamic(1.f);
LLGLSPipelineAlpha gls_pipeline_alpha;
LLOverrideFaceColor color(this, 1.f, 1.f, 1.f, 1.f);
renderTree();
}
void LLDrawPoolTree::render(S32 pass)
{
LLFastTimer t(LLPipeline::sShadowRender ? FTM_SHADOW_TREE : FTM_RENDER_TREES);
if (mDrawFace.empty())
{
return;
}
LLGLState test(GL_ALPHA_TEST, LLGLSLShader::sNoFixedFunction ? 0 : 1);
LLOverrideFaceColor color(this, 1.f, 1.f, 1.f, 1.f);
static LLCachedControl<bool> sRenderAnimateTrees("RenderAnimateTrees", false);
if (sRenderAnimateTrees)
{
renderTree();
}
else
gGL.getTexUnit(sDiffTex)->bind(mTexturep);
for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
iter != mDrawFace.end(); iter++)
{
LLFace *face = *iter;
LLVertexBuffer* buff = face->getVertexBuffer();
if(buff)
{
LLMatrix4* model_matrix = &(face->getDrawable()->getRegion()->mRenderMatrix);
if (model_matrix != gGLLastMatrix)
{
gGLLastMatrix = model_matrix;
gGL.loadMatrix(gGLModelView);
if (model_matrix)
{
llassert(gGL.getMatrixMode() == LLRender::MM_MODELVIEW);
gGL.multMatrix((GLfloat*) model_matrix->mMatrix);
}
gPipeline.mMatrixOpCount++;
}
buff->setBuffer(LLDrawPoolTree::VERTEX_DATA_MASK);
buff->drawRange(LLRender::TRIANGLES, 0, buff->getNumVerts()-1, buff->getNumIndices(), 0);
gPipeline.addTrianglesDrawn(buff->getNumIndices());
}
}
}
/**
* Deals with screen events. Must be called every time the screen is redraw.
*/
void display( void )
{
glClearColor( fabs( colorGrid - 1.0 ), fabs( colorGrid - 1.0 ), fabs( colorGrid - 1.0 ), 1.0 );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
renderGrid( );
glPushMatrix( );
{
path = 0;
renderEnvironment( );
renderTree( env.getValidPaths()->_root, 0);
}
glPopMatrix( );
glutSwapBuffers( );
}
void LLDrawPoolTree::renderForSelect()
{
if (mDrawFace.empty())
{
return;
}
glEnableClientState (GL_VERTEX_ARRAY);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
LLOverrideFaceColor color(this, 1.f, 1.f, 1.f, 1.f);
LLGLSObjectSelectAlpha gls_alpha;
glBlendFunc(GL_ONE, GL_ZERO);
glAlphaFunc(GL_GREATER, 0.5f);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_PRIMARY_COLOR_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA);
renderTree(TRUE);
glAlphaFunc(GL_GREATER, 0.01f);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
}
/**
* Renders the beam tree, showing all paths.
*
* @param root The beam tree root.
* @param p1 The end point of the first ray.
* @param p2 The end point of the second ray.
*/
void renderTree( TreeNode* root, int depth)
{
if (depth != 0)
{
if (depth == 1)
{
glColor3f( 1, 1, 1 );
glBegin( GL_LINES );
// First ray
glVertex2f( env.getSource().getPosition().x, env.getSource().getPosition().y );
glVertex2f( root->getPoint(1).x, root->getPoint(1).y );
// Second ray
glVertex2f( env.getSource().getPosition().x, env.getSource().getPosition().y );
glVertex2f( root->getPoint(2).x, root->getPoint(2).y );
glEnd( );
}
glEnable( GL_TEXTURE_1D );
{
glTexCoord1d( (double) depth / maximumDepth );
glBegin( GL_LINES );
// First ray
glVertex2f( root->getSourcePosition().x, root->getSourcePosition().y );
glVertex2f( root->getPoint(1).x, root->getPoint(1).y );
// Second ray
glVertex2f( root->getSourcePosition().x, root->getSourcePosition().y );
glVertex2f( root->getPoint(2).x, root->getPoint(2).y );
glEnd( );
}
glDisable( GL_TEXTURE_1D );
}
std::vector<TreeNode*> c = root->getChildren();
for (unsigned int i = 0; i < c.size(); i++)
{
renderTree(c[i], depth+1);
}
}
