void Canvas::renderWindow(WindowPtr pWindow, MCFBOPtr pFBO, const IntRect& viewport)
{
GLContext* pContext = pWindow->getGLContext();
pContext->activate();
GLContextManager::get()->uploadDataForContext();
renderFX(pContext);
glm::mat4 projMat;
if (pFBO) {
pFBO->activate(pContext);
glm::vec2 size = m_pRootNode->getSize();
projMat = glm::ortho(0.f, size.x, 0.f, size.y);
glViewport(0, 0, GLsizei(size.x), GLsizei(size.y));
} else {
glproc::BindFramebuffer(GL_FRAMEBUFFER, 0);
projMat = glm::ortho(float(viewport.tl.x), float(viewport.br.x),
float(viewport.br.y), float(viewport.tl.y));
IntPoint windowSize = pWindow->getSize();
glViewport(0, 0, windowSize.x, windowSize.y);
}
{
ScopeTimer Timer(VATransferProfilingZone);
m_pVertexArray->update(pContext);
}
clearGLBuffers(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT,
!pFBO);
GLContext::checkError("Canvas::renderWindow: glViewport()");
m_pVertexArray->activate(pContext);
{
ScopeTimer timer(RootRenderProfilingZone);
m_pRootNode->maybeRender(pContext, projMat);
}
renderOutlines(pContext, projMat);
}
void RasterNode::renderFX()
{
if (m_bFXDirty || m_pSurface->isDirty() || m_pFXNode->isDirty()) {
ScopeTimer Timer(FXProfilingZone);
GLContext* pContext = GLContext::getCurrent();
StandardShader::get()->setAlpha(1.0f);
m_pSurface->activate(getMediaSize());
m_pFBO->activate();
clearGLBuffers(GL_COLOR_BUFFER_BIT, false);
bool bPremultipliedAlpha = m_pSurface->isPremultipliedAlpha();
if (bPremultipliedAlpha) {
glproc::BlendColor(1.0f, 1.0f, 1.0f, 1.0f);
}
pContext->setBlendMode(GLContext::BLEND_BLEND, bPremultipliedAlpha);
m_pImagingProjection->setColor(m_Color);
m_pImagingProjection->draw(StandardShader::get()->getShader());
/*
static int i=0;
stringstream ss;
ss << "node" << i << ".png";
BitmapPtr pBmp = m_pFBO->getImage(0);
pBmp->save(ss.str());
*/
m_pFXNode->apply(m_pFBO->getTex()->getCurTex());
/*
stringstream ss1;
ss1 << "nodefx" << i << ".png";
i++;
m_pFXNode->getImage()->save(ss1.str());
*/
}
}
void MeshObj::restoreDataFmFile(void) {
clearGLBuffers(); clearMeshObjLists(); initMeshStructure();
#if SHOW
printVertexData();
#endif
checkError("MeshObj::restoreDataFmFile");
} // end restoreDataFmFile
void MeshObj::reverseNormals(void) {
clearGLBuffers();
for(GLuint i = 0, size = vertList.size(); size > i; ++i)
vertList[i].calcNorm = -vertList[i].calcNorm;
for(GLuint i = 0, size = normArrObj.size(); size > i; ++i)
normArrObj[i] = -normArrObj[i];
initBufObjs();
#if SHOW
printVertexData();
#endif
checkError("MeshObj::reverseNormals");
} // end reverseNormals
void Canvas::render(IntPoint windowSize, bool bUpsideDown, FBOPtr pFBO,
ProfilingZoneID& renderProfilingZone)
{
{
ScopeTimer Timer(PreRenderProfilingZone);
m_pRootNode->preRender();
}
if (pFBO) {
pFBO->activate();
} else {
glproc::BindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
GLContext::getCurrent()->checkError("Canvas::render: BindFramebuffer()");
}
if (m_MultiSampleSamples > 1) {
glEnable(GL_MULTISAMPLE);
GLContext::getCurrent()->checkError(
"Canvas::render: glEnable(GL_MULTISAMPLE)");
} else {
glDisable(GL_MULTISAMPLE);
GLContext::getCurrent()->checkError(
"Canvas::render: glDisable(GL_MULTISAMPLE)");
}
clearGLBuffers(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, windowSize.x, windowSize.y);
GLContext::getCurrent()->checkError("Canvas::render: glViewport()");
glMatrixMode(GL_PROJECTION);
GLContext::getCurrent()->checkError("Canvas::render: glMatrixMode()");
glLoadIdentity();
GLContext::getCurrent()->checkError("Canvas::render: glLoadIdentity()");
glm::vec2 size = m_pRootNode->getSize();
if (bUpsideDown) {
gluOrtho2D(0, size.x, 0, size.y);
} else {
gluOrtho2D(0, size.x, size.y, 0);
}
GLContext::getCurrent()->checkError("Canvas::render: gluOrtho2D()");
glMatrixMode(GL_MODELVIEW);
{
ScopeTimer Timer(renderProfilingZone);
m_pRootNode->maybeRender();
renderOutlines();
}
}
void MeshObj::recalculateVertexNormals(void) {
clearGLBuffers(); clearMeshObjLists();
for(GLuint i = 0, size = vPosArr.size(); size > i; ++i) {
struct vertex vert;
vert.idx = i;
vertList.push_back(vert);
}
for(GLuint i = 0, size = vIdxArr.size(); size > i; ++i)
idxArrObj.push_back(vIdxArr[i]);
for(GLuint i = 0, size = vIdxArr.size(); size > i; i += 3) {
GLuint idx0 = idxArrObj[i], idx1 = idxArrObj[i + 1],
idx2 = idxArrObj[i + 2];
if (0 != vTexArr.size()) {
vertList[idx0].texUV = vTexArr[vTexIdxArr[i]];
vertList[idx1].texUV = vTexArr[vTexIdxArr[i + 1]];
vertList[idx2].texUV = vTexArr[vTexIdxArr[i + 2]];
}
glm::vec3 v1 = vPosArr[vertList[idx1].idx] -
vPosArr[vertList[idx0].idx];
glm::vec3 v2 = vPosArr[vertList[idx2].idx] -
vPosArr[vertList[idx0].idx];
glm::vec3 normal = glm::normalize(glm::cross(v1, v2));
vertList[idx0].calcNorm += normal;
vertList[idx1].calcNorm += normal;
vertList[idx2].calcNorm += normal;
}
for (GLuint i = 0, size = vertList.size(); size > i; ++i) {
vertArrObj.push_back(vPosArr[vertList[i].idx]);
if (0 != vTexArr.size())
texArrObj.push_back(vertList[i].texUV);
normArrObj.push_back(vertList[i].calcNorm);
}
initBufObjs();
#if SHOW
printVertexData();
#endif
checkError("MeshObj::recalculateVertexNormals");
} // end recalculateVertexNormals
void Canvas::render(IntPoint windowSize, bool bOffscreen)
{
clearGLBuffers(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT,
!bOffscreen);
glViewport(0, 0, windowSize.x, windowSize.y);
GLContext::checkError("Canvas::render: glViewport()");
glm::vec2 size = m_pRootNode->getSize();
glm::mat4 projMat;
if (bOffscreen) {
projMat = glm::ortho(0.f, size.x, 0.f, size.y);
} else {
projMat = glm::ortho(0.f, size.x, size.y, 0.f);
}
m_pVertexArray->activate();
m_pRootNode->maybeRender(projMat);
renderOutlines(projMat);
}
