void DepthPeelingStage::postProcess(DrawEnv *pEnv, bool isPing)
{
Window *win = pEnv->getWindow();
if(win->hasExtOrVersion(_uiFramebufferObjectExt, 0x0300, 0x0200) == false)
{
FNOTICE(("Framebuffer objects not supported on Window %p!\n", win));
return;
}
DepthPeelingStageData *pData =
pEnv->getData<DepthPeelingStageData *>(_iDataSlotId);
if(!pData)
return;
FrameBufferObject *pBlendFBO = pData->getBlendFBO();
pBlendFBO->activate(pEnv);
ChunkMaterial *pMaterial;
if (isPing)
pMaterial = pData->getPeelPingMaterial();
else
pMaterial = pData->getPeelPongMaterial();
pEnv->activateState(pMaterial->getState(), NULL);
drawQuad();
pEnv->deactivateState();
pBlendFBO->deactivate(pEnv);
}
void HDRStage::updateData(RenderAction *pAction,
Int32 iVPWidth,
Int32 iVPHeight)
{
HDRStageDataUnrecPtr pData = pAction->getData<HDRStageData *>(_iDataSlotId);
if(pData == NULL)
{
initData(pAction, iVPWidth, iVPHeight);
pData = pAction->getData<HDRStageData *>(_iDataSlotId);
}
else if((pData->getWidth () != iVPWidth ) ||
(pData->getHeight() != iVPHeight) )
{
resizeStageData(pData,
iVPWidth,
iVPHeight);
pData->setWidth (iVPWidth );
pData->setHeight(iVPHeight);
}
ChunkMaterial* pTonemapMat = pData->getToneMappingMaterial();
BlendChunk* pBlendChunk = static_cast<BlendChunk*>(
pTonemapMat->find(BlendChunk::getClassType()));
if(pBlendChunk != NULL)
pBlendChunk->setIgnore(!getCombineBlend());
}
ActionBase::ResultE MaterialChunkOverrideGroup::renderEnter(Action *action)
{
RenderAction *pAction = dynamic_cast<RenderAction *>(action);
Material *pMaterial = this->getMaterial();
if(pAction != NULL && pMaterial != NULL)
{
pMaterial = pMaterial->finalize(pAction->getRenderProperties(),
pAction->getWindow ());
if(pMaterial)
{
ChunkMaterial *pChunkMaterial =
dynamic_cast<ChunkMaterial*>(pMaterial);
if(pChunkMaterial != NULL)
{
const MFUnrecStateChunkPtr *chunks =
pChunkMaterial->getMFChunks();
const MFInt32 *slots =
pChunkMaterial->getMFSlots();
for(unsigned int i = 0; i < chunks->size(); ++i)
{
int slot = i < slots->size() ?
(*slots)[i] :
State::AutoSlotReplace;
StateChunk *chunk = (*chunks)[i];
if(chunk != NULL)
this->addChunk(chunk, slot);
}
return Inherited::renderEnter(action);
}
else
{
Action::ResultE r = Group::renderEnter(action);
// ok all children are culled away so we leave
// immediately and don't set the material!
if(r == Action::Skip)
return r;
pAction->overrideMaterial(pMaterial, pAction->getActNode());
return r;
}
}
}
return Group::renderEnter(action);
}
void ChunkMaterialBase::execSyncV( FieldContainer &oFrom,
ConstFieldMaskArg whichField,
AspectOffsetStore &oOffsets,
ConstFieldMaskArg syncMode,
const UInt32 uiSyncInfo)
{
ChunkMaterial *pThis = static_cast<ChunkMaterial *>(this);
pThis->execSync(static_cast<ChunkMaterial *>(&oFrom),
whichField,
oOffsets,
syncMode,
uiSyncInfo);
}
void ChunkMaterialBase::onCreate(const ChunkMaterial *source)
{
Inherited::onCreate(source);
if(source != NULL)
{
ChunkMaterial *pThis = static_cast<ChunkMaterial *>(this);
MFUnrecStateChunkPtr::const_iterator ChunksIt =
source->_mfChunks.begin();
MFUnrecStateChunkPtr::const_iterator ChunksEnd =
source->_mfChunks.end ();
while(ChunksIt != ChunksEnd)
{
pThis->pushToChunks(*ChunksIt);
++ChunksIt;
}
}
}
void ColorDisplayFilter::process(DisplayFilterStageData *pData)
{
SimpleSHLChunk *pShader = pData->getColorFilterShader();
if(pShader == NULL || this->getFilterShader() != pShader)
{
pShader = this->getFilterShader();
OSG_ASSERT(pShader != NULL);
ChunkMaterial *pCMat = pData->getBaseMaterial();
OSG_ASSERT(pCMat != NULL);
pCMat->addChunk(pShader);
commitChanges();
pData->setColorFilterShader(pShader);
}
TextureObjChunk *pColTex = pData->getColorFilterTexture();
if(pData->getInitColTableFrom() != this)
{
if(pColTex == NULL)
{
TextureObjChunkUnrecPtr pTex = TextureObjChunk::createLocal();
pTex->setMinFilter(GL_LINEAR );
pTex->setMagFilter(GL_LINEAR );
pTex->setWrapS (GL_CLAMP_TO_EDGE );
pTex->setWrapT (GL_CLAMP_TO_EDGE );
pTex->setWrapR (GL_CLAMP_TO_EDGE );
pData->setColorFilterTexture(pTex);
ChunkMaterial *pCMat = pData->getBaseMaterial();
OSG_ASSERT(pCMat != NULL);
pCMat->addChunk(pTex, 1);
pColTex = pTex;
}
pData->setInitColTableFrom(this);
pColTex->setImage(this->getTableImage());
commitChanges();
}
OSG_ASSERT(pShader != NULL);
OSG_ASSERT(pColTex != NULL);
pShader->setIgnore(false);
pColTex->setIgnore(false);
}
void HDRStage::postProcess(DrawEnv *pEnv)
{
Window *win = pEnv->getWindow();
if(win->hasExtension(_uiFramebuffer_object_extension) == false)
{
FNOTICE(("Framebuffer objects not supported on Window %p!\n", win));
return;
}
GLDrawBuffersEXTProcT glDrawBuffersEXTProc =
reinterpret_cast<GLDrawBuffersEXTProcT>(
win->getFunction(_uiFuncDrawBuffers));
glColor3f(1.f, 1.f, 1.f);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
HDRStageData *pData = pEnv->getData<HDRStageData *>(_iDataSlotId);
if(pData == NULL)
{
return;
}
if((pData->getWidth () != pEnv->getPixelWidth() ) ||
(pData->getHeight() != pEnv->getPixelHeight()) )
{
resizeStageData(pData,
pEnv->getPixelWidth(),
pEnv->getPixelHeight());
}
// Shrink to w/2 h/2
FrameBufferObject *pShrinkTarget = pData->getShrinkRenderTarget();
ChunkMaterial *pSHM = pData->getShrinkMaterial();
pShrinkTarget->activate(pEnv);
glViewport(0,
0,
pEnv->getPixelWidth () / 2,
pEnv->getPixelHeight() / 2);
State *pShrinkState = pSHM->getState();
pEnv->activateState(pShrinkState, NULL);
glBegin(GL_QUADS);
{
glTexCoord2f(0.00, 0.00);
glVertex2f (0.00, 0.00);
glTexCoord2f(1.00, 0.00);
glVertex2f (1.00, 0.00);
glTexCoord2f(1.00, 1.00);
glVertex2f (1.00, 1.00);
glTexCoord2f(0.00, 1.00);
glVertex2f (0.00, 1.00);
}
glEnd();
pShrinkTarget->deactivate(pEnv);
// Shrink to w/4 h/4
FrameBufferObject *pBlurTarget = pData->getBlurRenderTarget();
pBlurTarget->editMFDrawBuffers()->clear();
pBlurTarget->editMFDrawBuffers()->push_back(GL_COLOR_ATTACHMENT0_EXT);
pBlurTarget->activate(pEnv);
glViewport(0,
0,
pEnv->getPixelWidth () / 4,
pEnv->getPixelHeight() / 4);
ChunkMaterial *pBLM = pData->getBlurMaterial();
State *pBlurState = pBLM->getState();
pEnv->activateState(pBlurState, NULL);
glBegin(GL_QUADS);
{
glTexCoord2f(0.00, 0.00);
glVertex2f (0.00, 0.00);
glTexCoord2f(1.00, 0.00);
glVertex2f (1.00, 0.00);
glTexCoord2f(1.00, 1.00);
glVertex2f (1.00, 1.00);
glTexCoord2f(0.00, 1.00);
glVertex2f (0.00, 1.00);
}
glEnd();
// HBlur
StateOverride oOverride;
GLenum aDrawBuffers[] = { GL_COLOR_ATTACHMENT1_EXT };
oOverride.addOverride(pData->getHBlurShader()->getClassId(),
pData->getHBlurShader());
pEnv->activateState(pBlurState, &oOverride);
glDrawBuffersEXTProc(1, aDrawBuffers);
glBegin(GL_QUADS);
{
glTexCoord2f(0.00, 0.00);
glVertex2f (0.00, 0.00);
glTexCoord2f(1.00, 0.00);
glVertex2f (1.00, 0.00);
glTexCoord2f(1.00, 1.00);
glVertex2f (1.00, 1.00);
glTexCoord2f(0.00, 1.00);
glVertex2f (0.00, 1.00);
}
glEnd();
// VBlur
StateOverride oOverride1;
oOverride1.addOverride(pData->getVBlurShader()->getClassId(),
pData->getVBlurShader());
pEnv->activateState(pBlurState, &oOverride1);
aDrawBuffers[0] = GL_COLOR_ATTACHMENT0_EXT;
glDrawBuffersEXTProc(1, aDrawBuffers);
glBegin(GL_QUADS);
{
glTexCoord2f(0.00, 0.00);
glVertex2f (0.00, 0.00);
glTexCoord2f(1.00, 0.00);
glVertex2f (1.00, 0.00);
glTexCoord2f(1.00, 1.00);
glVertex2f (1.00, 1.00);
glTexCoord2f(0.00, 1.00);
glVertex2f (0.00, 1.00);
}
glEnd();
pBlurTarget->deactivate(pEnv);
// Tonemap pass
glDisable(GL_DEPTH_TEST);
glViewport(pEnv->getPixelLeft (),
pEnv->getPixelBottom(),
pEnv->getPixelWidth (),
pEnv->getPixelHeight());
ChunkMaterial *pTCM = pData->getToneMappingMaterial();
State *pTState = pTCM->getState();
pEnv->activateState(pTState, NULL);
glBegin(GL_QUADS);
{
glTexCoord2f(0.00, 0.00);
glVertex2f (0.00, 0.00);
glTexCoord2f(1.00, 0.00);
glVertex2f (1.00, 0.00);
glTexCoord2f(1.00, 1.00);
glVertex2f (1.00, 1.00);
glTexCoord2f(0.00, 1.00);
glVertex2f (0.00, 1.00);
}
glEnd();
glEnable(GL_DEPTH_TEST);
pEnv->deactivateState();
glPopMatrix();
}
static Action::ResultE modifyMaterial(Node * const node)
{
MaterialGroup *mg = dynamic_cast<MaterialGroup *>(node->getCore());
if(mg == NULL)
return Action::Continue;
ChunkMaterial *cmat = dynamic_cast<ChunkMaterial *>(mg->getMaterial());
if(cmat == NULL)
return Action::Continue;
TextureObjChunk *texc =
dynamic_cast<TextureObjChunk *>(
cmat->find(TextureObjChunk::getClassType()));
if(texc == NULL)
return Action::Continue;
MaterialChunk *matc =
dynamic_cast<MaterialChunk *>(
cmat->find(MaterialChunk::getClassType()));
TextureEnvChunkUnrecPtr texe =
dynamic_cast<TextureEnvChunk *>(
cmat->find(TextureEnvChunk::getClassType()));
if(texe == NULL)
{
texe = TextureEnvChunk::create();
cmat->addChunk(texe);
}
if(matc == NULL)
{
// no material chunk so we use the replace mode.
texe->setEnvMode(GL_REPLACE);
return Action::Continue;
}
if(matc != NULL)
{
Image *img = texc->getImage();
texe->setEnvMode(GL_MODULATE);
if(img != NULL && img->getBpp() > 2)
{
// for color textures the texture replaces only the diffuse part.
matc->setDiffuse(Color4f(1.0f, 1.0f, 1.0f, 1.0f));
}
// check for textures with alpha
if(!matc->isTransparent() &&
img != NULL &&
img->getBpp() == 4 )
{
BlendChunkUnrecPtr blendc =
dynamic_cast<BlendChunk *>(
cmat->find(BlendChunk::getClassType()));
if(blendc == NULL)
{
blendc = OSG::BlendChunk::create();
blendc->setSrcFactor (GL_SRC_ALPHA);
blendc->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
cmat->addChunk(blendc);
}
}
}
return Action::Continue;
}
void HDRStage::postProcess(DrawEnv *pEnv)
{
UInt32 uiActiveFBO = pEnv->getActiveFBO();
Window *win = pEnv->getWindow();
if(win->hasExtOrVersion(_uiFramebufferObjectExt, 0x0300, 0x0200) == false)
{
FNOTICE(("Framebuffer objects not supported on Window %p!\n",
static_cast<void *>(win)));
return;
}
OSGGETGLFUNCBYID_GL3( glDrawBuffers,
osgGlDrawBuffers,
_uiFuncDrawBuffers,
win);
glColor3f(1.f, 1.f, 1.f);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
HDRStageData *pData = pEnv->getData<HDRStageData *>(_iDataSlotId);
if(pData == NULL)
{
return;
}
// Shrink to w/2 h/2
FrameBufferObject *pShrinkTarget = pData->getShrinkRenderTarget();
ChunkMaterial *pSHM = pData->getShrinkMaterial();
pShrinkTarget->activate(pEnv);
glViewport(0,
0,
pEnv->getPixelWidth () / 2,
pEnv->getPixelHeight() / 2);
State *pShrinkState = pSHM->getState();
pEnv->activateState(pShrinkState, NULL);
this->renderQuad();
pShrinkTarget->deactivate(pEnv);
// Shrink to w/4 h/4
FrameBufferObject *pBlurTarget = pData->getBlurRenderTarget();
pBlurTarget->editMFDrawBuffers()->clear();
pBlurTarget->editMFDrawBuffers()->push_back(GL_COLOR_ATTACHMENT0_EXT);
pBlurTarget->activate(pEnv);
glViewport(0,
0,
pEnv->getPixelWidth () / 4,
pEnv->getPixelHeight() / 4);
ChunkMaterial *pBLM = pData->getBlurMaterial();
State *pBlurState = pBLM->getState();
pEnv->activateState(pBlurState, NULL);
this->renderQuad();
GLenum aDrawBuffers[] = { GL_COLOR_ATTACHMENT0_EXT };
// HBlur
pBlurTarget->activate(pEnv);
glViewport(0,
0,
pEnv->getPixelWidth () / 4,
pEnv->getPixelHeight() / 4);
#define OVERSHADER 1
#if OVERSHADER
StateOverride oOverride;
oOverride.addOverride(pData->getHBlurShader()->getClassId(),
pData->getHBlurShader());
pEnv->activateState(pBlurState, &oOverride);
#else
pData->getHBlurShader()->activate(pEnv);
#endif
aDrawBuffers[0] = GL_COLOR_ATTACHMENT1_EXT;
osgGlDrawBuffers(1, aDrawBuffers);
this->renderQuad();
#if !OVERSHADER
pData->getHBlurShader()->deactivate(pEnv);
#endif
// VBlur
#if OVERSHADER
StateOverride oOverride1;
oOverride1.addOverride(pData->getVBlurShader()->getClassId(),
pData->getVBlurShader());
pEnv->activateState(pBlurState, &oOverride1);
#else
pData->getVBlurShader()->activate(pEnv);
#endif
aDrawBuffers[0] = GL_COLOR_ATTACHMENT0_EXT;
osgGlDrawBuffers(1, aDrawBuffers);
this->renderQuad();
#if !OVERSHADER
pData->getVBlurShader()->deactivate(pEnv);
#endif
if(uiActiveFBO == 0)
{
pBlurTarget->deactivate(pEnv);
}
else
{
FrameBufferObject::activateFBOById(pEnv, uiActiveFBO);
}
// Tonemap pass
glDisable(GL_DEPTH_TEST);
glViewport(pEnv->getPixelLeft (),
pEnv->getPixelBottom(),
pEnv->getPixelWidth (),
pEnv->getPixelHeight());
ChunkMaterial *pTCM = pData->getToneMappingMaterial();
State *pTState = pTCM->getState();
pEnv->activateState(pTState, NULL);
this->renderQuad();
glEnable(GL_DEPTH_TEST);
pEnv->deactivateState();
glPopMatrix();
}
void TrapezoidalShadowMapEngine::updateLightPassMaterial(
TSMEngineData *data, UInt16 faceIdx, const Matrixr &matNT)
{
if(data->getMFLightPassMaterials()->size() < 6)
data->editMFLightPassMaterials()->resize(6, NULL);
ChunkMaterial *lightPassMat = data->getLightPassMaterials(faceIdx);
if(lightPassMat == NULL)
{
ColorMaskChunkUnrecPtr newCMaskChunk = ColorMaskChunk::create();
newCMaskChunk->setMaskR(false);
newCMaskChunk->setMaskG(false);
newCMaskChunk->setMaskB(false);
newCMaskChunk->setMaskA(false);
#ifdef OSG_TSME_LIGHTPASS_EXACT
ShaderProgramUnrecPtr newLightPassVP = ShaderProgram::createLocal();
newLightPassVP->setShaderType(GL_VERTEX_SHADER);
newLightPassVP->setProgram (_lightPassVPCode);
newLightPassVP->addUniformVariable("TSME_matNT", matNT);
ShaderProgramUnrecPtr newLightPassFP = ShaderProgram::createLocal();
newLightPassFP->setShaderType(GL_FRAGMENT_SHADER);
newLightPassFP->setProgram (_lightPassFPCode );
newLightPassFP->addUniformVariable("TSME_offsetFactor", getOffsetFactor());
newLightPassFP->addUniformVariable("TSME_offsetBias", getOffsetBias ());
ShaderProgramChunkUnrecPtr newLightPassSHChunk =
ShaderProgramChunk::createLocal();
newLightPassSHChunk->addVertexShader (newLightPassVP);
newLightPassSHChunk->addFragmentShader(newLightPassFP);
ChunkMaterialUnrecPtr newLightPassMat = ChunkMaterial::createLocal();
newLightPassMat->addChunk(newCMaskChunk );
newLightPassMat->addChunk(newLightPassSHChunk);
lightPassMat = newLightPassMat;
data->editMFLightPassMaterials()->replace(faceIdx, newLightPassMat);
#else
PolygonChunkUnrecPtr newPolyChunk = PolygonChunk::createLocal();
newPolyChunk->setOffsetFill (true );
newPolyChunk->setOffsetFactor(getOffsetFactor());
newPolyChunk->setOffsetBias (getOffsetBias ());
ShaderProgramUnrecPtr newLightPassVP = ShaderProgram::createLocal();
newLightPassVP->setShaderType (GL_VERTEX_SHADER );
newLightPassVP->setProgram (_lightPassVPCode );
newLightPassVP->addUniformVariable("TSME_matNT", matNT);
ShaderProgramChunkUnrecPtr newLightPassSHChunk =
ShaderProgramChunk::createLocal();
newLightPassSHChunk->addVertexShader(newLightPassVP);
ChunkMaterialUnrecPtr newLightPassMat = ChunkMaterial::createLocal();
newLightPassMat->addChunk(newCMaskChunk );
newLightPassMat->addChunk(newPolyChunk );
newLightPassMat->addChunk(newLightPassSHChunk);
lightPassMat = newLightPassMat;
(*data->editMFLightPassMaterials())[faceIdx] = newLightPassMat;
#endif
}
else
{
ShaderProgramChunk *lightPassSHChunk =
dynamic_cast<ShaderProgramChunk *>(
lightPassMat->find(ShaderProgramChunk::getClassType()));
if(lightPassSHChunk != NULL)
{
ShaderProgram *lightPassVP = lightPassSHChunk->getVertexShader(0);
lightPassVP->updateUniformVariable("TSME_matNT", matNT);
}
}
}
void DisplayFilterStage::postProcess(DrawEnv *pEnv)
{
DisplayFilterStageData *pData =
pEnv->getData<DisplayFilterStageData *>(_iDataSlotId);
if(pData == NULL)
return;
ColorDisplayFilter *pColFilter = pData->getColFilter ();
DistortionDisplayFilter *pDistFilter = pData->getDistFilter();
ChunkMaterial *pSourceMat = pData->getBaseMaterial();
State *pSourceState = pSourceMat->getState();
glClearColor(0.f, 0.f, 0.f, 1.f);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.f, 0.f, 0.f);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
if(pColFilter != NULL)
{
pColFilter->process(pData);
}
pEnv->activateState(pSourceState, NULL);
if(pColFilter == NULL)
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}
if(pDistFilter != NULL)
{
pDistFilter->process(pData);
}
else
{
glBegin(GL_QUADS);
{
glTexCoord2f(0.00, 0.00);
glVertex2f (0.00, 0.00);
glTexCoord2f(1.00, 0.00);
glVertex2f (1.00, 0.00);
glTexCoord2f(1.00, 1.00);
glVertex2f (1.00, 1.00);
glTexCoord2f(0.00, 1.00);
glVertex2f (0.00, 1.00);
}
glEnd();
}
if(pColFilter == NULL)
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
pEnv->deactivateState();
glPopMatrix();
}
