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); 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->getNumVerts()-1, buff->getNumIndices(), 0); gPipeline.addTrianglesDrawn(buff->getNumIndices()); } } }
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()); } } }
Wavefront::Wavefront(LLFace* face, LLPolyMesh* mesh, const LLXform* transform, const LLXform* transform_normals) : name("") { LLVertexBuffer* vb = face->getVertexBuffer(); if (!vb) return; LLStrider<LLVector3> getVerts; LLStrider<LLVector3> getNorms; LLStrider<LLVector2> getCoord; LLStrider<U16> getIndices; face->getGeometry(getVerts, getNorms, getCoord, getIndices); const U16 start = face->getGeomStart(); const U32 end = start + (mesh ? mesh->getNumVertices() : vb->getNumVerts()) - 1; //vertices for (U32 i = start; i <= end; ++i) vertices.push_back(std::make_pair(getVerts[i], getCoord[i])); if (transform) Transform(vertices, transform); for (U32 i = start; i <= end; ++i) normals.push_back(getNorms[i]); if (transform_normals) Transform(normals, transform_normals); const U32 pcount = mesh ? mesh->getNumFaces() : (vb->getNumIndices()/3); //indices const U16 offset = face->getIndicesStart(); //indices for (U32 i = 0; i < pcount; ++i) { triangles.push_back(tri(getIndices[i * 3 + offset] + start, getIndices[i * 3 + 1 + offset] + start, getIndices[i * 3 + 2 + offset] + start)); } }
//split every triangle in LLVertexBuffer into even fourths (assumes index triangle lists) void subdivide(LLVertexBuffer& in, LLVertexBuffer* ret) { S32 tri_in = in.getNumIndices()/3; ret->allocateBuffer(tri_in*4*3, tri_in*4*3, TRUE); LLStrider<LLVector3> vin, vout; LLStrider<U16> indin, indout; ret->getVertexStrider(vout); in.getVertexStrider(vin); ret->getIndexStrider(indout); in.getIndexStrider(indin); for (S32 i = 0; i < tri_in; i++) { LLVector3 v0 = vin[*indin++]; LLVector3 v1 = vin[*indin++]; LLVector3 v2 = vin[*indin++]; LLVector3 v3 = (v0 + v1) * 0.5f; LLVector3 v4 = (v1 + v2) * 0.5f; LLVector3 v5 = (v2 + v0) * 0.5f; *vout++ = v0; *vout++ = v3; *vout++ = v5; *vout++ = v3; *vout++ = v4; *vout++ = v5; *vout++ = v3; *vout++ = v1; *vout++ = v4; *vout++ = v5; *vout++ = v4; *vout++ = v2; } for (S32 i = 0; i < ret->getNumIndices(); i++) { *indout++ = i; } }
void chop(LLVertexBuffer& in, LLVertexBuffer* out) { //chop off all triangles below horizon F32 d = LLWLParamManager::sParamMgr->getDomeOffset() * LLWLParamManager::sParamMgr->getDomeRadius(); std::vector<LLVector3> vert; LLStrider<LLVector3> vin; LLStrider<U16> index; in.getVertexStrider(vin); in.getIndexStrider(index); U32 tri_count = in.getNumIndices()/3; for (U32 i = 0; i < tri_count; i++) { LLVector3 &v1 = vin[index[i*3+0]]; LLVector3 &v2 = vin[index[i*3+1]]; LLVector3 &v3 = vin[index[i*3+2]]; if (v1.mV[1] > d || v2.mV[1] > d || v3.mV[1] > d) { v1.mV[1] = llmax(v1.mV[1], d); v2.mV[1] = llmax(v1.mV[1], d); v3.mV[1] = llmax(v1.mV[1], d); vert.push_back(v1); vert.push_back(v2); vert.push_back(v3); } } out->allocateBuffer(vert.size(), vert.size(), TRUE); LLStrider<LLVector3> vout; out->getVertexStrider(vout); out->getIndexStrider(index); for (U32 i = 0; i < vert.size(); i++) { *vout++ = vert[i]; *index++ = i; } }
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); gGL.getTexUnit(sDiffTex)->bind(mTexturep); for (std::vector<LLFace*>::iterator iter = mDrawFace.begin(); iter != mDrawFace.end(); iter++) { LLFace *face = *iter; if(face->getViewerObject()) { LLVOTree* pTree = dynamic_cast<LLVOTree*>(face->getViewerObject()); if(pTree && !pTree->mDrawList.empty() ) { LLMatrix4a* model_matrix = &(face->getDrawable()->getRegion()->mRenderMatrix); gGL.loadMatrix(gGLModelView); gGL.multMatrix(*model_matrix); gPipeline.mMatrixOpCount++; for(std::vector<LLPointer<LLDrawInfo> >::iterator iter2 = pTree->mDrawList.begin(); iter2 != pTree->mDrawList.end(); iter2++) { LLDrawInfo& params = *iter2->get(); gGL.pushMatrix(); gGL.multMatrix(*params.mModelMatrix); gPipeline.mMatrixOpCount++; params.mVertexBuffer->setBuffer(LLDrawPoolTree::VERTEX_DATA_MASK); params.mVertexBuffer->drawRange(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset); gGL.popMatrix(); } continue; } } LLVertexBuffer* buff = face->getVertexBuffer(); if(buff) { LLMatrix4a* model_matrix = &(face->getDrawable()->getRegion()->mRenderMatrix); if(model_matrix && model_matrix->isIdentity()) { model_matrix = NULL; } if (model_matrix != gGLLastMatrix) { gGLLastMatrix = model_matrix; gGL.loadMatrix(gGLModelView); if (model_matrix) { llassert(gGL.getMatrixMode() == LLRender::MM_MODELVIEW); gGL.multMatrix(*model_matrix); } gPipeline.mMatrixOpCount++; } buff->setBuffer(LLDrawPoolTree::VERTEX_DATA_MASK); buff->drawRange(LLRender::TRIANGLES, 0, buff->getNumVerts()-1, buff->getNumIndices(), 0); gPipeline.addTrianglesDrawn(buff->getNumIndices()); } } }