DepthPeelingStageDataTransitPtr
DepthPeelingStage::setupStageData(Int32 iPixelWidth,
Int32 iPixelHeight)
{
DepthPeelingStageDataTransitPtr returnValue =
DepthPeelingStageData::createLocal();
if(returnValue == NULL)
return returnValue;
OSG::Thread::setCurrentLocalFlags();
//Depth, Blend chunks and Background in Data?
DepthChunkUnrecPtr pDepthOffChunk = DepthChunk::createLocal();
pDepthOffChunk->setEnable(false);
DepthChunkUnrecPtr pDepthOnChunk = DepthChunk::createLocal();
pDepthOnChunk->setEnable(true);
returnValue->setDepthChunk(pDepthOnChunk);
ShaderProgramVariableChunkUnrecPtr pSPVChunk1 =
ShaderProgramVariableChunk::createLocal();
pSPVChunk1->addUniformVariable("uIsPeelPass", true);
returnValue->setSpvIsPeelChunk(pSPVChunk1);
ShaderProgramVariableChunkUnrecPtr pSPVChunk2 =
ShaderProgramVariableChunk::createLocal();
pSPVChunk2->addUniformVariable("uIsPeelPass", false);
returnValue->setSpvIsInitialChunk(pSPVChunk2);
BlendChunkUnrecPtr pBlendChunk = BlendChunk::createLocal();
pBlendChunk->setSrcFactor(GL_DST_ALPHA);
pBlendChunk->setDestFactor(GL_ONE);
pBlendChunk->setAlphaSrcFactor(GL_ZERO);
pBlendChunk->setAlphaDestFactor(GL_ONE_MINUS_SRC_ALPHA);
pBlendChunk->setEquation(GL_FUNC_ADD);
SolidBackgroundUnrecPtr pSolidBackground = SolidBackground::createLocal();
pSolidBackground->setColor(Color3f(0.f, 0.f, 0.f));
pSolidBackground->setAlpha(0.f);
returnValue->setBackground(pSolidBackground);
SimpleSHLChunkUnrecPtr pQuadShader = SimpleSHLChunk::createLocal();
pQuadShader->setFragmentProgram(std::string(blendFS));
pQuadShader->addUniformVariable("uSampler", 0);
//2 FBOs (Ping-Pong)
FrameBufferObjectUnrecPtr pPeelFBOs[2];
TextureBufferUnrecPtr pPeelColorTexBuffers[2];
TextureBufferUnrecPtr pPeelDepthTexBuffers[2];
TextureObjChunkUnrecPtr pColorTexs[2];
ImageUnrecPtr pColorImgs[2];
TextureObjChunkUnrecPtr pDepthTexs[2];
ImageUnrecPtr pDepthImgs[2];
for (int i=0; i<2; ++i)
{
//Color textures
pColorTexs[i] = TextureObjChunk::createLocal();
pColorImgs[i] = Image ::createLocal();
pColorImgs[i]->set(Image::OSG_RGBA_PF,
iPixelWidth,
iPixelHeight,
1,
1,
1,
0.0,
0,
Image::OSG_FLOAT32_IMAGEDATA,
false);
pColorTexs[i] ->setImage (pColorImgs[i] );
pColorTexs[i] ->setMinFilter (GL_NEAREST );
pColorTexs[i] ->setMagFilter (GL_NEAREST );
pColorTexs[i] ->setWrapS (GL_CLAMP_TO_EDGE );
pColorTexs[i] ->setWrapT (GL_CLAMP_TO_EDGE );
pColorTexs[i] ->setInternalFormat(GL_RGBA8);
pPeelColorTexBuffers[i] = TextureBuffer::createLocal();
pPeelColorTexBuffers[i]->setTexture(pColorTexs[i]);
//Depth textures
pDepthTexs[i] = TextureObjChunk::createLocal();
pDepthImgs[i] = Image ::createLocal();
pDepthImgs[i]->set(Image::OSG_DEPTH_PF,
iPixelWidth,
iPixelHeight,
1,
1,
1,
0.0,
0,
Image::OSG_FLOAT32_IMAGEDATA,
false);
pDepthTexs[i] ->setImage (pDepthImgs[i] );
pDepthTexs[i] ->setMinFilter (GL_NEAREST );
pDepthTexs[i] ->setMagFilter (GL_NEAREST );
pDepthTexs[i] ->setWrapS (GL_CLAMP_TO_EDGE );
pDepthTexs[i] ->setWrapT (GL_CLAMP_TO_EDGE );
pDepthTexs[i] ->setInternalFormat(GL_DEPTH_COMPONENT32F);
pDepthTexs[i] ->setExternalFormat(GL_DEPTH_COMPONENT);
pPeelDepthTexBuffers[i] = TextureBuffer::createLocal();
pPeelDepthTexBuffers[i]->setTexture(pDepthTexs[i]);
pPeelFBOs[i] = FrameBufferObject::createLocal();
pPeelFBOs[i]->setSize(iPixelWidth, iPixelHeight);
pPeelFBOs[i]->setColorAttachment(pPeelColorTexBuffers[i], 0);
pPeelFBOs[i]->setDepthAttachment(pPeelDepthTexBuffers[i]);
pPeelFBOs[i]->editMFDrawBuffers()->push_back(GL_COLOR_ATTACHMENT0_EXT);
//Peel material for Quad (!)
ChunkMaterialUnrecPtr pPeelMat = ChunkMaterial ::createLocal();
pPeelMat->addChunk(pQuadShader, 0);
pPeelMat->addChunk(pColorTexs[i], 0);
pPeelMat->addChunk(pDepthOffChunk);
pPeelMat->addChunk(pBlendChunk);
if (i == 0)
{
returnValue->setPeelPingFBO(pPeelFBOs[i]);
returnValue->setPeelPingMaterial(pPeelMat);
}
else
{
returnValue->setPeelPongFBO(pPeelFBOs[i]);
returnValue->setPeelPongMaterial(pPeelMat);
}
}
// The final color blend target
FrameBufferObjectUnrecPtr pBlendFBO = FrameBufferObject::createLocal();
//Color texture
TextureObjChunkUnrecPtr pBlendColorTex = TextureObjChunk::createLocal();
ImageUnrecPtr pBlendColorImg = Image ::createLocal();
pBlendColorImg->set(Image::OSG_RGBA_PF,
iPixelWidth,
iPixelHeight,
1,
1,
1,
0.0,
0,
Image::OSG_FLOAT32_IMAGEDATA,
false);
pBlendColorTex->setImage (pBlendColorImg );
pBlendColorTex->setMinFilter (GL_NEAREST );
pBlendColorTex->setMagFilter (GL_NEAREST );
pBlendColorTex->setWrapS (GL_CLAMP_TO_EDGE );
pBlendColorTex->setWrapT (GL_CLAMP_TO_EDGE );
pBlendColorTex->setInternalFormat(GL_RGBA8);
TextureBufferUnrecPtr pBlendColorTexBuffer = TextureBuffer::createLocal();
pBlendColorTexBuffer->setTexture(pBlendColorTex);
TextureBufferUnrecPtr pBlendDepthTexBuffer = TextureBuffer::createLocal();
pBlendDepthTexBuffer->setTexture(pDepthTexs[0]);
pBlendFBO->setSize(iPixelWidth, iPixelHeight);
pBlendFBO->setColorAttachment(pBlendColorTexBuffer, 0);
pBlendFBO->setDepthAttachment(pBlendDepthTexBuffer);
pBlendFBO->editMFDrawBuffers()->push_back(GL_COLOR_ATTACHMENT0_EXT);
returnValue->setBlendFBO(pBlendFBO);
// Blend Final Material
ChunkMaterialUnrecPtr pBlendFinalMat = ChunkMaterial::createLocal();
pBlendFinalMat->addChunk(pDepthOffChunk);
pBlendFinalMat->addChunk(pBlendColorTex, 0);
SimpleSHLChunkUnrecPtr pBlendFinalShader = SimpleSHLChunk::createLocal();
pBlendFinalShader->setFragmentProgram(std::string(blendFinalFS));
pBlendFinalShader->addUniformVariable("uSampler", 0);
pBlendFinalMat->addChunk(pBlendFinalShader, 0);
returnValue->setBlendFinalMaterial(pBlendFinalMat);
OSG::Thread::resetCurrentLocalFlags();
Thread::getCurrentChangeList()->commitChanges();
return returnValue;
}
PostShaderStageDataTransitPtr
PostShaderStage::setupStageData(Int32 iPixelWidth,
Int32 iPixelHeight)
{
PostShaderStageDataTransitPtr returnValue =
PostShaderStageData::createLocal();
if(returnValue == NULL)
return returnValue;
OSG::Thread::setCurrentLocalFlags();
// Scene Target
FrameBufferObjectUnrecPtr pSceneFBO = FrameBufferObject::createLocal();
//Depth texture
_pSceneDepthTex = TextureObjChunk::createLocal();
TextureEnvChunkUnrecPtr pSceneDepthTexEnv = TextureEnvChunk::createLocal();
ImageUnrecPtr pDepthImg = Image ::createLocal();
pDepthImg->set(Image::OSG_L_PF,
iPixelWidth,
iPixelHeight,
1,
1,
1,
0.0,
NULL,
Image::OSG_UINT8_IMAGEDATA,
false);
_pSceneDepthTex ->setImage (pDepthImg );
_pSceneDepthTex ->setMinFilter (GL_LINEAR );
_pSceneDepthTex ->setMagFilter (GL_LINEAR );
_pSceneDepthTex ->setWrapS (GL_CLAMP_TO_EDGE );
_pSceneDepthTex ->setWrapT (GL_CLAMP_TO_EDGE );
_pSceneDepthTex ->setInternalFormat(GL_DEPTH_COMPONENT);
_pSceneDepthTex ->setExternalFormat(GL_DEPTH_COMPONENT);
pSceneDepthTexEnv->setEnvMode (GL_REPLACE );
TextureBufferUnrecPtr pDepthBuffer = TextureBuffer::createLocal();
//pDepthBuffer->setInternalFormat(GL_DEPTH_COMPONENT24 );
pDepthBuffer->setTexture(_pSceneDepthTex);
//Color Buffer
_pSceneTex = TextureObjChunk::createLocal();
TextureEnvChunkUnrecPtr pSceneTexEnv = TextureEnvChunk::createLocal();
ImageUnrecPtr pImg = Image ::createLocal();
pImg->set(Image::OSG_RGB_PF,
iPixelWidth,
iPixelHeight,
1,
1,
1,
0.0,
0,
Image::OSG_UINT8_IMAGEDATA,
false);
_pSceneTex ->setImage (pImg );
_pSceneTex ->setMinFilter (GL_LINEAR );
_pSceneTex ->setMagFilter (GL_LINEAR );
_pSceneTex ->setWrapS (GL_CLAMP_TO_EDGE );
_pSceneTex ->setWrapT (GL_CLAMP_TO_EDGE );
_pSceneTex ->setInternalFormat(getColorBufferFormat());
pSceneTexEnv->setEnvMode (GL_REPLACE );
TextureBufferUnrecPtr pSceneTexBuffer = TextureBuffer::createLocal();
pSceneTexBuffer->setTexture(_pSceneTex);
pSceneFBO->setSize(iPixelWidth, iPixelHeight);
pSceneFBO->setColorAttachment(pSceneTexBuffer, 0);
pSceneFBO->setDepthAttachment(pDepthBuffer );
pSceneFBO->editMFDrawBuffers()->push_back(GL_COLOR_ATTACHMENT0_EXT);
setRenderTarget(pSceneFBO);
// general mat chunk
//Init all of the render passes
_vPostProcessPasses.clear();
UInt32 NumPasses = getNumPasses();
for(UInt32 i =0; i != NumPasses ; ++i)
{
_vPostProcessPasses.push_back(
RenderPassData::create( getVertexShaders(i),
getFragmentShaders(i),
(i == NumPasses-1),
i,
iPixelWidth,
iPixelHeight,
returnValue.get(),
getPassSizes(i),
_pSceneTex,
_pSceneDepthTex,
_vPostProcessPasses,
pSceneFBO));
}
OSG::Thread::resetCurrentLocalFlags();
Thread::getCurrentChangeList()->commitChanges();
return returnValue;
}
CubeMapGeneratorStageDataTransitPtr CubeMapGenerator::setupStageData(
RenderActionBase *pAction)
{
CubeMapGeneratorStageDataTransitPtr returnValue =
CubeMapGeneratorStageData::createLocal();
if(returnValue == NULL)
return returnValue;
FrameBufferObjectUnrecPtr pCubeTarget = NULL;
RenderBufferUnrecPtr pDepthBuffer = NULL;
if(this->getRenderTarget() == NULL)
{
pCubeTarget = FrameBufferObject::createLocal();
pDepthBuffer = RenderBuffer ::createLocal();
pDepthBuffer->setInternalFormat (GL_DEPTH_COMPONENT24);
pCubeTarget ->setDepthAttachment(pDepthBuffer );
returnValue ->setRenderTarget (pCubeTarget );
}
else
{
pCubeTarget = this->getRenderTarget();
}
TextureObjChunkUnrecPtr pCubeTex = NULL;
if(0x0000 != (_sfSetupMode.getValue() & SetupTexture))
{
pCubeTex = TextureObjChunk::createLocal();
ImageUnrecPtr pImg = Image::createLocal();
pImg->set(Image::OSG_RGB_PF,
getWidth (),
getHeight(),
1,
1,
1,
0.0,
0,
Image::OSG_UINT8_IMAGEDATA,
false,
6);
pCubeTex ->setImage (pImg );
pCubeTex ->setMinFilter (GL_LINEAR );
pCubeTex ->setMagFilter (GL_LINEAR );
pCubeTex ->setWrapS (GL_CLAMP_TO_EDGE );
pCubeTex ->setWrapT (GL_CLAMP_TO_EDGE );
pCubeTex ->setWrapR (GL_CLAMP_TO_EDGE );
pCubeTex ->setInternalFormat(getTextureFormat());
}
else
{
pCubeTex = _sfTexture.getValue();
}
TextureEnvChunkUnrecPtr pCubeTexEnv = NULL;
if(0x0000 != (_sfSetupMode.getValue() & SetupTexEnv))
{
pCubeTexEnv = TextureEnvChunk::createLocal();
pCubeTexEnv->setEnvMode (GL_REPLACE );
}
TexGenChunkUnrecPtr pCubeTexGen = NULL;
TextureTransformChunkUnrecPtr pCubeTexTrans = NULL;
if(0x0000 != (_sfSetupMode.getValue() & SetupTexGen))
{
pCubeTexGen = TexGenChunk::createLocal();
pCubeTexGen->setGenFuncS(GL_REFLECTION_MAP);
pCubeTexGen->setGenFuncT(GL_REFLECTION_MAP);
pCubeTexGen->setGenFuncR(GL_REFLECTION_MAP);
pCubeTexTrans = TextureTransformChunk::createLocal();
pCubeTexTrans->setUseCameraBeacon(true);
}
static GLenum targets[6] =
{
GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB,
GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB,
GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB,
GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB
};
for(UInt32 i = 0; i < 6; ++i)
{
TextureBufferUnrecPtr pCubeTexBuffer = TextureBuffer::createLocal();
pCubeTexBuffer->setTexture (pCubeTex );
pCubeTexBuffer->setTexTarget(targets[i]);
pCubeTarget->setColorAttachment(pCubeTexBuffer, i);
}
pCubeTarget->setSize(getWidth (),
getHeight());
if(0x0000 != (_sfSetupMode.getValue() & OverrideTex))
{
returnValue->addChunk(pCubeTex,
getTexUnit());
}
if(0x0000 != (_sfSetupMode.getValue() & SetupTexEnv))
{
returnValue->addChunk(pCubeTexEnv,
getTexUnit());
}
if(0x0000 != (_sfSetupMode.getValue() & SetupTexGen))
{
returnValue->addChunk(pCubeTexGen,
getTexUnit());
returnValue->addChunk(pCubeTexTrans,
getTexUnit());
returnValue->setTexTransform(pCubeTexTrans);
}
if(this->getCamera() == NULL)
{
PerspectiveCameraUnrecPtr pCam = PerspectiveCamera::createLocal();
pCam->setNear(pAction->getCamera()->getNear());
pCam->setFar (pAction->getCamera()->getFar ());
pCam->setFov (osgDegree2Rad(90.f));
returnValue->setCamera(pCam);
}
return returnValue;
}
HDRStageDataTransitPtr HDRStage::setupStageData(Int32 iPixelWidth,
Int32 iPixelHeight)
{
HDRStageDataTransitPtr returnValue = HDRStageData::createLocal();
if(returnValue == NULL)
return returnValue;
OSG::Thread::setCurrentLocalFlags();
// Scene Target
FrameBufferObjectUnrecPtr pSceneFBO = FrameBufferObject::createLocal();
RenderBufferUnrecPtr pDepthBuffer = RenderBuffer ::createLocal();
pDepthBuffer->setInternalFormat(GL_DEPTH_COMPONENT24 );
TextureObjChunkUnrecPtr pSceneTex = TextureObjChunk::createLocal();
TextureEnvChunkUnrecPtr pSceneTexEnv = TextureEnvChunk::createLocal();
ImageUnrecPtr pImg = Image ::createLocal();
pImg->set(Image::OSG_RGB_PF,
iPixelWidth,
iPixelHeight,
1,
1,
1,
0.0,
0,
Image::OSG_FLOAT32_IMAGEDATA,
false);
pSceneTex ->setImage (pImg );
pSceneTex ->setMinFilter (GL_LINEAR );
pSceneTex ->setMagFilter (GL_LINEAR );
pSceneTex ->setWrapS (GL_CLAMP_TO_EDGE );
pSceneTex ->setWrapT (GL_CLAMP_TO_EDGE );
pSceneTex ->setInternalFormat(getBufferFormat());
pSceneTexEnv->setEnvMode (GL_REPLACE );
TextureBufferUnrecPtr pSceneTexBuffer = TextureBuffer::createLocal();
pSceneTexBuffer->setTexture(pSceneTex);
pSceneFBO->setSize(iPixelWidth, iPixelHeight);
pSceneFBO->setColorAttachment(pSceneTexBuffer, 0);
pSceneFBO->setDepthAttachment(pDepthBuffer );
pSceneFBO->editMFDrawBuffers()->push_back(GL_COLOR_ATTACHMENT0_EXT);
setRenderTarget(pSceneFBO);
// Shrink Target (w/2, h/2)
FrameBufferObjectUnrecPtr pShrinkFBO = FrameBufferObject::createLocal();
TextureObjChunkUnrecPtr pShrinkTex = TextureObjChunk::createLocal();
TextureEnvChunkUnrecPtr pShrinkTexEnv = TextureEnvChunk::createLocal();
pImg = Image ::createLocal();
pImg->set(Image::OSG_RGB_PF,
iPixelWidth / 2,
iPixelHeight / 2,
1,
1,
1,
0.0,
0,
Image::OSG_FLOAT32_IMAGEDATA,
false);
pShrinkTex ->setImage (pImg );
pShrinkTex ->setMinFilter (GL_LINEAR );
pShrinkTex ->setMagFilter (GL_LINEAR );
pShrinkTex ->setWrapS (GL_CLAMP_TO_EDGE );
pShrinkTex ->setWrapT (GL_CLAMP_TO_EDGE );
pShrinkTex ->setInternalFormat(getBufferFormat());
pShrinkTexEnv->setEnvMode (GL_REPLACE );
TextureBufferUnrecPtr pShrinkTexBuffer = TextureBuffer::createLocal();
pShrinkTexBuffer->setTexture(pShrinkTex);
pShrinkFBO->setSize(iPixelWidth / 2, iPixelHeight / 2);
pShrinkFBO->setColorAttachment(pShrinkTexBuffer, 0);
pShrinkFBO->editMFDrawBuffers()->push_back(GL_COLOR_ATTACHMENT0_EXT);
returnValue->setShrinkRenderTarget(pShrinkFBO);
// blur (w/4, h/4)
FrameBufferObjectUnrecPtr pBlurFBO = FrameBufferObject::createLocal();
TextureObjChunkUnrecPtr pBlurTex1 = TextureObjChunk ::createLocal();
TextureEnvChunkUnrecPtr pBlurTex1Env = TextureEnvChunk ::createLocal();
pImg = Image::createLocal();
pImg->set(Image::OSG_RGB_PF,
iPixelWidth / 4,
iPixelHeight / 4,
1,
1,
1,
0.0,
0,
Image::OSG_FLOAT32_IMAGEDATA,
false);
pBlurTex1 ->setImage (pImg );
pBlurTex1 ->setMinFilter (GL_LINEAR );
pBlurTex1 ->setMagFilter (GL_LINEAR );
pBlurTex1 ->setWrapS (GL_CLAMP_TO_EDGE );
pBlurTex1 ->setWrapT (GL_CLAMP_TO_EDGE );
pBlurTex1 ->setInternalFormat(getBufferFormat());
pBlurTex1Env->setEnvMode (GL_REPLACE );
TextureBufferUnrecPtr pBlurTexBuffer1 = TextureBuffer::createLocal();
pBlurTexBuffer1->setTexture(pBlurTex1);
TextureObjChunkUnrecPtr pBlurTex2 = TextureObjChunk::createLocal();
TextureEnvChunkUnrecPtr pBlurTex2Env = TextureEnvChunk::createLocal();
pImg = Image::createLocal();
pImg->set(Image::OSG_RGB_PF,
iPixelWidth / 4,
iPixelHeight / 4,
1,
1,
1,
0.0,
0,
Image::OSG_FLOAT32_IMAGEDATA,
false);
pBlurTex2 ->setImage (pImg );
pBlurTex2 ->setMinFilter (GL_LINEAR );
pBlurTex2 ->setMagFilter (GL_LINEAR );
pBlurTex2 ->setWrapS (GL_CLAMP_TO_EDGE );
pBlurTex2 ->setWrapT (GL_CLAMP_TO_EDGE );
pBlurTex2 ->setInternalFormat(getBufferFormat());
pBlurTex2Env->setEnvMode (GL_REPLACE );
TextureBufferUnrecPtr pBlurTexBuffer2 = TextureBuffer::createLocal();
pBlurTexBuffer2->setTexture(pBlurTex2);
pBlurFBO->setSize(iPixelWidth / 4,
iPixelHeight / 4);
pBlurFBO->setColorAttachment(pBlurTexBuffer1, 0);
pBlurFBO->setColorAttachment(pBlurTexBuffer2, 1);
returnValue->setBlurRenderTarget(pBlurFBO);
// general mat chunk
MaterialChunkUnrecPtr pMatChunk = MaterialChunk::createLocal();
pMatChunk->setLit(false);
// tone map material
ChunkMaterialUnrecPtr pTonemapMat = ChunkMaterial ::createLocal();
pTonemapMat->addChunk(pMatChunk );
pTonemapMat->addChunk(pSceneTex, 0);
pTonemapMat->addChunk(pSceneTexEnv, 0);
pTonemapMat->addChunk(pBlurTex1, 1);
pTonemapMat->addChunk(pBlurTex1Env, 1);
SimpleSHLChunkUnrecPtr pTonemapShader = generateHDRFragmentProgram();
pTonemapShader->addUniformVariable("sceneTex", 0);
pTonemapShader->addUniformVariable("blurTex", 1);
pTonemapShader->addUniformVariable("blurAmount", getBlurAmount ());
pTonemapShader->addUniformVariable("exposure", getExposure ());
pTonemapShader->addUniformVariable("effectAmount", getEffectAmount());
pTonemapShader->addUniformVariable("gamma", getGamma ());
pTonemapMat->addChunk(pTonemapShader, 0);
returnValue->setToneMappingMaterial(pTonemapMat);
// Shrink material
ChunkMaterialUnrecPtr pShrinkMat = ChunkMaterial::createLocal();
pShrinkMat->addChunk(pMatChunk );
pShrinkMat->addChunk(pSceneTex, 0);
pShrinkMat->addChunk(pSceneTexEnv, 0);
SimpleSHLChunkUnrecPtr pShrinkShader = generate2DShrinkHalfFilterFP();
pShrinkShader->addUniformVariable("inputTex", 0);
pShrinkMat->addChunk(pShrinkShader, 0);
returnValue->setShrinkMaterial(pShrinkMat);
// Blur material
ChunkMaterialUnrecPtr pBlurMat = ChunkMaterial::createLocal();
pBlurMat->addChunk(pMatChunk );
pBlurMat->addChunk(pShrinkTex, 0);
pBlurMat->addChunk(pShrinkTexEnv, 0);
pBlurMat->addChunk(pBlurTex1, 1);
pBlurMat->addChunk(pBlurTex1Env, 1);
pBlurMat->addChunk(pBlurTex2, 2);
pBlurMat->addChunk(pBlurTex2Env, 2);
pBlurMat->addChunk(pShrinkShader, 0);
returnValue->setBlurMaterial(pBlurMat);
// generate blur fragment programs
SimpleSHLChunkUnrecPtr pHBlurShader =
generate1DConvolutionFilterFP(getBlurWidth(),
false,
true,
iPixelWidth / 2,
iPixelHeight / 2);
pHBlurShader->addUniformVariable("inputTex", 0);
returnValue->setHBlurShader(pHBlurShader);
// VBlur Override
SimpleSHLChunkUnrecPtr pVBlurShader =
generate1DConvolutionFilterFP(getBlurWidth(),
true,
true,
iPixelWidth / 2,
iPixelHeight / 2);
pVBlurShader->addUniformVariable("inputTex", 1);
returnValue->setVBlurShader(pVBlurShader);
OSG::Thread::resetCurrentLocalFlags();
Thread::getCurrentChangeList()->commitChanges();
return returnValue;
}
DisplayFilterStageDataTransitPtr
DisplayFilterStage::setupStageData(Int32 iPixelWidth,
Int32 iPixelHeight)
{
DisplayFilterStageDataTransitPtr returnValue =
DisplayFilterStageData::createLocal();
if(returnValue == NULL)
return returnValue;
// Scene Buffer
FrameBufferObjectUnrecPtr pFBO = FrameBufferObject::createLocal();
RenderBufferUnrecPtr pDBuffer = RenderBuffer ::createLocal();
TextureBufferUnrecPtr pTBuffer = TextureBuffer ::createLocal();
TextureObjChunkUnrecPtr pTex = TextureObjChunk ::createLocal();
ImageUnrecPtr pImg = Image ::createLocal();
pImg->set(Image::OSG_RGB_PF,
iPixelWidth,
iPixelHeight,
1,
1,
1,
0.0,
0,
Image::OSG_UINT8_IMAGEDATA,
false);
pTex ->setImage (pImg );
pTex ->setMinFilter (GL_NEAREST );
pTex ->setMagFilter (GL_NEAREST );
pTex ->setWrapS (GL_CLAMP_TO_EDGE );
pTex ->setWrapT (GL_CLAMP_TO_EDGE );
pTBuffer->setTexture(pTex);
pDBuffer->setInternalFormat(GL_DEPTH_COMPONENT24);
pFBO->setSize(iPixelWidth, iPixelHeight);
pFBO->setColorAttachment(pTBuffer, 0);
pFBO->setDepthAttachment(pDBuffer );
pFBO->editMFDrawBuffers()->push_back(GL_COLOR_ATTACHMENT0_EXT);
pFBO->setEnableMultiSample (this->getEnableMultiSample ());
pFBO->setColorSamples (this->getColorSamples ());
pFBO->setCoverageSamples (this->getCoverageSamples ());
pFBO->setFixedSampleLocation(this->getFixedSampleLocation());
returnValue->setTarget(pFBO);
ChunkMaterialUnrecPtr pCMat = ChunkMaterial::createLocal();
pCMat->addChunk(pTex);
returnValue->setBaseMaterial(pCMat);
returnValue->setWidth (iPixelWidth );
returnValue->setHeight(iPixelHeight);
commitChanges();
return returnValue;
}
