void OculusViewConfig::configure(osgViewer::View& view) const
{
m_device->setNearClip(m_nearClip);
m_device->setFarClip(m_farClip);
m_device->setSensorPredictionEnabled(m_useSensorPrediction);
m_device->setSensorPredictionDelta(m_predictionDelta);
if (m_useCustomScaleFactor) {
m_device->setCustomScaleFactor(m_customScaleFactor);
}
// Create screen with match the Oculus Rift resolution
osg::GraphicsContext::WindowingSystemInterface* wsi = osg::GraphicsContext::getWindowingSystemInterface();
if (!wsi) {
osg::notify(osg::NOTICE)<<"Error, no WindowSystemInterface available, cannot create windows."<<std::endl;
return;
}
// Get the screen identifiers set in environment variable DISPLAY
osg::GraphicsContext::ScreenIdentifier si;
si.readDISPLAY();
// If displayNum has not been set, reset it to 0.
if (si.displayNum < 0) si.displayNum = 0;
// If screenNum has not been set, reset it to 0.
if (si.screenNum < 0) si.screenNum = 0;
//test by Shao
si.displayNum = _displayNum;
si.screenNum = _screenNum;
unsigned int width, height;
wsi->getScreenResolution(si, width, height);
osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
traits->hostName = si.hostName;
traits->screenNum = si.screenNum;
traits->displayNum = si.displayNum;
traits->windowDecoration = false;
traits->x = 0;
traits->y = 0;
traits->width = m_device->hScreenResolution();
traits->height = m_device->vScreenResolution();
traits->doubleBuffer = true;
traits->sharedContext = 0;
traits->vsync = true; // VSync should always be enabled for Oculus Rift applications
// Create a graphic context based on our desired traits
osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits);
if (!gc) {
osg::notify(osg::NOTICE) << "Error, GraphicsWindow has not been created successfully" << std::endl;
return;
}
_main_camera = view.getCamera();
_main_camera->setName("Main");
// Disable scene rendering for main camera
_main_camera->setCullMask(~m_sceneNodeMask);
_main_camera->setGraphicsContext(gc);
// Use full view port
_main_camera->setViewport(new osg::Viewport(0, 0, traits->width, traits->height));
// Disable automatic computation of near and far plane on main camera, will propagate to slave cameras
_main_camera->setComputeNearFarMode( osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR );
const int textureWidth = m_device->scaleFactor() * m_device->hScreenResolution()/2;
const int textureHeight = m_device->scaleFactor() * m_device->vScreenResolution();
// master projection matrix
_main_camera->setProjectionMatrix(m_device->projectionCenterMatrix());
// Create textures for RTT cameras
osg::ref_ptr<osg::Texture2D> textureLeft = new osg::Texture2D;
textureLeft->setTextureSize( textureWidth, textureHeight );
textureLeft->setInternalFormat( GL_RGBA );
osg::ref_ptr<osg::Texture2D> textureRight = new osg::Texture2D;
textureRight->setTextureSize( textureWidth, textureHeight );
textureRight->setInternalFormat( GL_RGBA );
// Create RTT (Rendering to Texture) cameras and attach textures
osg::ref_ptr<osg::Camera> cameraRTTLeft = createRTTCamera(textureLeft, gc);
osg::ref_ptr<osg::Camera> cameraRTTRight = createRTTCamera(textureRight, gc);
cameraRTTLeft->setName("LeftRTT");
cameraRTTRight->setName("RightRTT");
cameraRTTLeft->setCullMask(m_sceneNodeMask);
cameraRTTRight->setCullMask(m_sceneNodeMask);
// Create HUD cameras for left eye
osg::ref_ptr<osg::Camera> cameraHUDLeft = createHUDCamera(0.0, 1.0, 0.0, 1.0, gc);
cameraHUDLeft->setName("LeftHUD");
cameraHUDLeft->setViewport(new osg::Viewport(0, 0,
m_device->hScreenResolution() / 2.0f, m_device->vScreenResolution()));
// Create HUD cameras for right eye
osg::ref_ptr<osg::Camera> cameraHUDRight = createHUDCamera(0.0, 1.0, 0.0, 1.0, gc);
cameraHUDRight->setName("RightHUD");
cameraHUDRight->setViewport(new osg::Viewport(m_device->hScreenResolution() / 2.0f, 0,
m_device->hScreenResolution() / 2.0f, m_device->vScreenResolution()));
// Create quads for each camera
osg::ref_ptr<osg::Geode> leftQuad = createHUDQuad(1.0f, 1.0f);
cameraHUDLeft->addChild(leftQuad);
osg::ref_ptr<osg::Geode> rightQuad = createHUDQuad(1.0f, 1.0f);
cameraHUDRight->addChild(rightQuad);
// Set up shaders from the Oculus SDK documentation
osg::ref_ptr<osg::Program> program = new osg::Program;
osg::ref_ptr<osg::Shader> vertexShader = new osg::Shader(osg::Shader::VERTEX);
vertexShader->loadShaderSourceFromFile(osgDB::findDataFile("warp.vert"));
osg::ref_ptr<osg::Shader> fragmentShader = new osg::Shader(osg::Shader::FRAGMENT);
// Fragment shader with or without correction for chromatic aberration
if (m_useChromaticAberrationCorrection) {
fragmentShader->loadShaderSourceFromFile(osgDB::findDataFile("warpWithChromeAb.frag"));
} else {
fragmentShader->loadShaderSourceFromFile(osgDB::findDataFile("warpWithoutChromeAb.frag"));
}
program->addShader(vertexShader);
program->addShader(fragmentShader);
// Attach shaders to each HUD
osg::StateSet* leftEyeStateSet = leftQuad->getOrCreateStateSet();
osg::StateSet* rightEyeStateSet = rightQuad->getOrCreateStateSet();
applyShaderParameters(leftEyeStateSet, program.get(), textureLeft.get(), OculusDevice::LEFT_EYE);
applyShaderParameters(rightEyeStateSet, program.get(), textureRight.get(), OculusDevice::RIGHT_EYE);
// Add RTT cameras as slaves, specifying offsets for the projection
view.addSlave(cameraRTTLeft,
m_device->projectionOffsetMatrix(OculusDevice::LEFT_EYE),
m_device->viewMatrix(OculusDevice::LEFT_EYE),
true);
view.addSlave(cameraRTTRight,
m_device->projectionOffsetMatrix(OculusDevice::RIGHT_EYE),
m_device->viewMatrix(OculusDevice::RIGHT_EYE),
true);
// Add HUD cameras as slaves
view.addSlave(cameraHUDLeft, false);
view.addSlave(cameraHUDRight, false);
view.setName("Oculus");
// Connect main camera to node callback that get HMD orientation
if (m_useOrientations) {
_main_camera->setDataVariance(osg::Object::DYNAMIC);
_callback = new OculusViewConfigOrientationCallback(cameraRTTLeft, cameraRTTRight, m_device);
_main_camera->setUpdateCallback(_callback);
}
}
void OculusViewConfig::configure(osgViewer::View& view) const
{
m_dev->setNearClip(m_nearClip);
m_dev->setFarClip(m_farClip);
m_dev->setSensorPredictionEnabled(m_useSensorPrediction);
m_dev->setSensorPredictionDelta(m_predictionDelta);
if (m_useCustomScaleFactor) {
m_dev->setCustomScaleFactor(m_customScaleFactor);
}
// Create screen with match the Oculus Rift resolution
osg::GraphicsContext::WindowingSystemInterface* wsi = osg::GraphicsContext::getWindowingSystemInterface();
if (!wsi) {
osg::notify(osg::NOTICE)<<"Error, no WindowSystemInterface available, cannot create windows."<<std::endl;
return;
}
unsigned int width, height;
wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), width, height);
osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
traits->windowDecoration = false;
traits->x = 0;
traits->y = 0;
traits->width = m_dev->hScreenResolution();
traits->height = m_dev->vScreenResolution();
traits->doubleBuffer = true;
traits->sharedContext = 0;
traits->sampleBuffers = true;
traits->samples = 4;
traits->vsync = true;
osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits);
osg::ref_ptr<osg::Camera> camera = view.getCamera();
camera->setGraphicsContext(gc);
// Use full viewport
camera->setViewport(new osg::Viewport(0, 0, traits->width, traits->height));
// Disable automatic computation of near and far plane on main camera, will propagate to slave cameras
camera->setComputeNearFarMode( osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR );
const int textureWidth = m_dev->scaleFactor() * m_dev->hScreenResolution()/2;
const int textureHeight = m_dev->scaleFactor() * m_dev->vScreenResolution();
// master projection matrix
camera->setProjectionMatrix(m_dev->projectionCenterMatrix());
osg::ref_ptr<osg::Texture2D> l_tex = new osg::Texture2D;
l_tex->setTextureSize( textureWidth, textureHeight );
l_tex->setInternalFormat( GL_RGBA );
osg::ref_ptr<osg::Texture2D> r_tex = new osg::Texture2D;
r_tex->setTextureSize( textureWidth, textureHeight );
r_tex->setInternalFormat( GL_RGBA );
osg::ref_ptr<osg::Camera> l_rtt = createRTTCamera(osg::Camera::COLOR_BUFFER, l_tex, gc);
osg::ref_ptr<osg::Camera> r_rtt = createRTTCamera(osg::Camera::COLOR_BUFFER, r_tex, gc);
// Create HUD cameras for each eye
osg::ref_ptr<osg::Camera> l_hud = createHUDCamera(0.0, 1.0, 0.0, 1.0, gc);
l_hud->setViewport(new osg::Viewport(0, 0, m_dev->hScreenResolution() / 2.0f, m_dev->vScreenResolution()));
osg::ref_ptr<osg::Camera> r_hud = createHUDCamera(0.0, 1.0, 0.0, 1.0, gc);
r_hud->setViewport(new osg::Viewport(m_dev->hScreenResolution() / 2.0f, 0,
m_dev->hScreenResolution() / 2.0f, m_dev->vScreenResolution()));
// Create quads on each camera
osg::ref_ptr<osg::Geode> leftQuad = createHUDQuad(1.0f, 1.0f);
l_hud->addChild(leftQuad);
osg::ref_ptr<osg::Geode> rightQuad = createHUDQuad(1.0f, 1.0f);
r_hud->addChild(rightQuad);
// Set up shaders from the Oculus SDK documentation
osg::ref_ptr<osg::Program> program = new osg::Program;
osg::ref_ptr<osg::Shader> vertexShader = new osg::Shader(osg::Shader::VERTEX);
vertexShader->loadShaderSourceFromFile(osgDB::findDataFile("warp.vert"));
osg::ref_ptr<osg::Shader> fragmentShader = new osg::Shader(osg::Shader::FRAGMENT);
// Fragment shader with or without correction for chromatic aberration
if (m_useChromaticAberrationCorrection) {
fragmentShader->loadShaderSourceFromFile(osgDB::findDataFile("warpWithChromeAb.frag"));
} else {
fragmentShader->loadShaderSourceFromFile(osgDB::findDataFile("warpWithoutChromeAb.frag"));
}
program->addShader(vertexShader);
program->addShader(fragmentShader);
// Configure state sets for both eyes
osg::StateSet* leftEyeStateSet = leftQuad->getOrCreateStateSet();
leftEyeStateSet->setTextureAttributeAndModes(0, l_tex, osg::StateAttribute::ON);
leftEyeStateSet->setAttributeAndModes( program, osg::StateAttribute::ON );
leftEyeStateSet->addUniform( new osg::Uniform("WarpTexture", 0) );
leftEyeStateSet->addUniform( new osg::Uniform("LensCenter", m_dev->lensCenter(OculusDevice::LEFT_EYE)));
leftEyeStateSet->addUniform( new osg::Uniform("ScreenCenter", m_dev->screenCenter()));
leftEyeStateSet->addUniform( new osg::Uniform("Scale", m_dev->scale()));
leftEyeStateSet->addUniform( new osg::Uniform("ScaleIn", m_dev->scaleIn()));
leftEyeStateSet->addUniform( new osg::Uniform("HmdWarpParam", m_dev->warpParameters()));
leftEyeStateSet->addUniform( new osg::Uniform("ChromAbParam", m_dev->chromAbParameters()));
osg::StateSet* rightEyeStateSet = rightQuad->getOrCreateStateSet();
rightEyeStateSet->setTextureAttributeAndModes(0, r_tex, osg::StateAttribute::ON);
rightEyeStateSet->setAttributeAndModes( program, osg::StateAttribute::ON );
rightEyeStateSet->addUniform( new osg::Uniform("WarpTexture", 0) );
rightEyeStateSet->addUniform( new osg::Uniform("LensCenter", m_dev->lensCenter(OculusDevice::RIGHT_EYE)));
rightEyeStateSet->addUniform( new osg::Uniform("ScreenCenter", m_dev->screenCenter()));
rightEyeStateSet->addUniform( new osg::Uniform("Scale", m_dev->scale()));
rightEyeStateSet->addUniform( new osg::Uniform("ScaleIn", m_dev->scaleIn()));
rightEyeStateSet->addUniform( new osg::Uniform("HmdWarpParam", m_dev->warpParameters()));
rightEyeStateSet->addUniform( new osg::Uniform("ChromAbParam", m_dev->chromAbParameters()));
// Add cameras as slaves, specifying offsets for the projection
view.addSlave(l_rtt, m_dev->projectionOffsetMatrix(OculusDevice::LEFT_EYE), m_dev->viewMatrix(OculusDevice::LEFT_EYE), true);
view.addSlave(r_rtt, m_dev->projectionOffsetMatrix(OculusDevice::RIGHT_EYE), m_dev->viewMatrix(OculusDevice::RIGHT_EYE), true);
view.addSlave(l_hud, false);
view.addSlave(r_hud, false);
// Connect main camera to node callback that get HMD orientation
if (m_useOrientations) {
camera->setDataVariance(osg::Object::DYNAMIC);
camera->setUpdateCallback(new OculusViewConfigOrientationCallback(l_rtt, r_rtt, m_dev));
}
}
int main(void){
osg::DisplaySettings::instance()->setNumMultiSamples( 4 );
viewer.setUpViewInWindow( 100, 50, 800, 600 );
viewer.getCamera()->setClearColor( osg::Vec4( 0.5,0.5,0.5,1) );
viewer.addEventHandler(new osgViewer::StatsHandler);
osg::Group* scene = new osg::Group;
// Création d'une boîte centrée à l'origine, de dimensions 2x3x4:
osg::Box* boite = new osg::Box(osg::Vec3(-10, 0, 0), 2,3,4);
osg::ShapeDrawable* boiteDrawable = new osg::ShapeDrawable(boite);
osg::Geode* geodeBoite = new osg::Geode();
geodeBoite->addDrawable(boiteDrawable);
osg::Sphere* sphere = new osg::Sphere( osg::Vec3(10,0,0), 1.0);
osg::ShapeDrawable* sphereDrawable = new osg::ShapeDrawable(sphere);
osg::Geode* geodeSphere = new osg::Geode();
geodeSphere->addDrawable(sphereDrawable);
osg::Capsule* capsule = new osg::Capsule(osg::Vec3(0, 0, 0), 1.0, 3.0);
osg::ShapeDrawable* capsuleDrawable = new osg::ShapeDrawable(capsule);
osg::Geode* geodeCapsule = new osg::Geode();
geodeCapsule->addDrawable(capsuleDrawable);
osg::Cone* cone = new osg::Cone(osg::Vec3(0, 10, 0), 1, 2);
osg::ShapeDrawable* coneDrawable = new osg::ShapeDrawable(cone);
osg::Geode* geodeCone= new osg::Geode();
geodeCone->addDrawable(coneDrawable);
osg::Material* matBoite = new osg::Material;
matBoite->setAmbient (osg::Material::FRONT_AND_BACK, osg::Vec4(0.5, 0.0, 0.0, 1.0));
matBoite->setDiffuse (osg::Material::FRONT_AND_BACK, osg::Vec4(0.9, 0.0, 0.0, 1.0));
matBoite->setSpecular(osg::Material::FRONT_AND_BACK, osg::Vec4(0.2, 0.2, 0.2, 1.0));
matBoite->setShininess(osg::Material::FRONT_AND_BACK, 64);
osg::Material* matCone = new osg::Material;
matCone->setAmbient (osg::Material::FRONT_AND_BACK, osg::Vec4(0.5, 0.0, 0.5, 1.0));
matCone->setDiffuse (osg::Material::FRONT_AND_BACK, osg::Vec4(0.9, 0.0, 0.9, 1.0));
matCone->setSpecular(osg::Material::FRONT_AND_BACK, osg::Vec4(0.2, 0.2, 0.2, 1.0));
matCone->setShininess(osg::Material::FRONT_AND_BACK, 64);
osg::Node* aregne = osgDB::readNodeFile("cow_high.3ds");
transformAregne->setPosition(osg::Vec3(5, 0, 0));
transformAregne->setScale(osg::Vec3(0.2, 0.2, 0.2));
transformAregne->getOrCreateStateSet()->setMode(GL_NORMALIZE,osg::StateAttribute::ON);
transformAregne->addChild(aregne);
boiteDrawable->getOrCreateStateSet()->setAttributeAndModes(matBoite);
coneDrawable->getOrCreateStateSet()->setAttributeAndModes(matCone);
/*scene->addChild(geodeCapsule);
scene->addChild(geodeCone);
scene->addChild(geodeBoite);
scene->addChild(geodeSphere);
scene->addChild(transformAregne);*/
scene->addChild(aregne);
// Création d'une texture
osg::ref_ptr<osg::Texture2D> tex2D = new osg::Texture2D;
tex2D->setTextureSize(1024, 1024);
tex2D->setInternalFormat(GL_RGBA);
// Création d'une caméra qui effectuera son rendu dans la texture
osg::ref_ptr<osg::Camera> rttCamera =
createRTTCamera(osg::Camera::COLOR_BUFFER, tex2D.get());
// On indique la partie du graphe que la caméra devra rendre, ici toute la scène :
rttCamera->addChild(scene);
// Création d'une caméra permettant d'afficher un HUD qui couvrira tout l'écran
osg::ref_ptr<osg::Camera> hudCamera = createHUDCamera();
osg::Geode* screenQuad = createScreenQuad();
hudCamera->addChild(screenQuad);
osg::StateSet* stateset = screenQuad->getOrCreateStateSet();
stateset->setTextureAttributeAndModes(0, tex2D.get());
// VOUS METTREZ ICI LE CODE DE LA QUESTION 7
// Création d'une nouvelle racine du graphe, à laquelle on rattache la caméra
// de rendu dans une texture, la caméra du HUD et la racine du graphe de la scène
osg::ref_ptr<osg::Group> root = new osg::Group;
root->addChild(rttCamera.get());
root->addChild(hudCamera.get());
root->addChild(scene);
// Indique au viewer la scène à affich
trackCone->setTrackNode(geodeCone);
trackCone->setTrackerMode(osgGA::NodeTrackerManipulator::NODE_CENTER);
trackBoite->setTrackNode(geodeBoite);
trackBoite->setTrackerMode(osgGA::NodeTrackerManipulator::NODE_CENTER);
trackSphere->setTrackNode(geodeSphere);
trackSphere->setTrackerMode(osgGA::NodeTrackerManipulator::NODE_CENTER);
transformAregne->setUpdateCallback(new Deplacement);
viewer.setSceneData(scene);
osg::ref_ptr<GestionEvenements> gestionnaire = new GestionEvenements();
viewer.addEventHandler(gestionnaire.get());
return viewer.run();
}
void RenderPipeline::initialize(osg::Group *scene, int width, int height)
{
if(mGraph.valid())
deinitialize();
mScreenWidth = mTextureWidth = width;
mScreenHeight = mTextureHeight = height;
mGBufferColors = createTextureRect(mTextureWidth, mTextureHeight, GL_RGBA16F, GL_RGBA, GL_FLOAT);
mGBufferNormals = createTextureRect(mTextureWidth, mTextureHeight, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE);
mGBufferPositions = createTextureRect(mTextureWidth, mTextureHeight, GL_RGBA16F, GL_RGBA, GL_FLOAT);
mDepthStencil = createTextureRect(mTextureWidth, mTextureHeight, GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
mDiffuseLight = createTextureRect(mTextureWidth, mTextureHeight, GL_RGBA16F, GL_RGBA, GL_FLOAT);
mSpecularLight = createTextureRect(mTextureWidth, mTextureHeight, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE);
mFinalBuffer = createTextureRect(mTextureWidth, mTextureHeight, GL_RGBA16F, GL_RGBA, GL_FLOAT);
int pre_render_pass = 0;
// Clear pass (clears specular and depth buffers)
mClearPass = createRTTCamera(osg::Camera::COLOR_BUFFER, mSpecularLight.get());
mClearPass->setNodeMask(Renderer::Mask_RTT);
mClearPass->attach(osg::Camera::PACKED_DEPTH_STENCIL_BUFFER, mDepthStencil.get());
mClearPass->setRenderOrder(osg::Camera::PRE_RENDER, pre_render_pass++);
// Main pass (generates colors, normals, positions, and emissive diffuse lighting).
mMainPass = createRTTCamera(osg::Camera::COLOR_BUFFER0, mGBufferColors.get());
mMainPass->attach(osg::Camera::COLOR_BUFFER1, mGBufferNormals.get());
mMainPass->attach(osg::Camera::COLOR_BUFFER2, mGBufferPositions.get());
mMainPass->attach(osg::Camera::COLOR_BUFFER3, mDiffuseLight.get());
mMainPass->attach(osg::Camera::PACKED_DEPTH_STENCIL_BUFFER, mDepthStencil.get());
// FIXME: Once sky rendering is implemented, don't clear buffers here
//mMainPass->setClearMask(GL_NONE);
mMainPass->setRenderOrder(osg::Camera::PRE_RENDER, pre_render_pass++);
osg::StateSet *ss = mMainPass->getOrCreateStateSet();
ss->addUniform(new osg::Uniform("illumination_color", osg::Vec4()));
{
// Make sure to clear stencil bit 0x1 by default (geometry that doesn't
// want external lighting should set bit 0x1 on z-pass).
osg::ref_ptr<osg::Stencil> stencil = new osg::Stencil();
stencil->setWriteMask(~0);
stencil->setFunction(osg::Stencil::ALWAYS, 0x00, 0x01);
stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP, osg::Stencil::REPLACE);
ss->setAttributeAndModes(stencil.get());
}
mMainPass->addChild(scene);
// Lighting pass (generates diffuse and specular).
mLightPass = createRTTCamera(osg::Camera::COLOR_BUFFER0, mDiffuseLight.get());
mLightPass->setNodeMask(Renderer::Mask_RTT);
mLightPass->attach(osg::Camera::COLOR_BUFFER1, mSpecularLight.get());
mLightPass->attach(osg::Camera::PACKED_DEPTH_STENCIL_BUFFER, mDepthStencil.get());
mLightPass->setClearMask(GL_NONE);
mLightPass->setRenderOrder(osg::Camera::PRE_RENDER, pre_render_pass++);
mLightPass->setCullingMode(osg::CullSettings::NO_CULLING);
mLightPass->setProjectionResizePolicy(osg::Camera::FIXED);
mLightPass->setProjectionMatrixAsOrtho2D(0.0, 1.0, 0.0, 1.0);
ss = mLightPass->getOrCreateStateSet();
ss->setAttributeAndModes(new osg::BlendFunc(GL_ONE, GL_ONE));
ss->setAttributeAndModes(new osg::Depth(osg::Depth::GEQUAL, 0.0, 1.0, false));
ss->setTextureAttribute(0, mGBufferColors.get());
ss->setTextureAttribute(1, mGBufferNormals.get());
ss->setTextureAttribute(2, mGBufferPositions.get());
ss->addUniform(new osg::Uniform("ColorTex", 0));
ss->addUniform(new osg::Uniform("NormalTex", 1));
ss->addUniform(new osg::Uniform("PosTex", 2));
// Default light values
ss->addUniform(new osg::Uniform("ambient_color", osg::Vec4f(0.2f, 0.2f, 0.2f, 1.0f)));
ss->addUniform(new osg::Uniform("diffuse_color", osg::Vec4f(1.0f, 1.0f, 1.0f, 1.0f)));
ss->addUniform(new osg::Uniform("specular_color", osg::Vec4f(1.0f, 1.0f, 1.0f, 1.0f)));
{
// Skip lighting for pixels that have stencil bit 0x1 set
osg::ref_ptr<osg::Stencil> stencil = new osg::Stencil();
stencil->setWriteMask(0);
stencil->setFunction(osg::Stencil::EQUAL, 0x0, 0x1);
stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP, osg::Stencil::KEEP);
ss->setAttributeAndModes(stencil.get());
}
// Combiner pass (combines colors, diffuse, and specular).
mCombinerPass = createRTTCamera(osg::Camera::COLOR_BUFFER, mFinalBuffer.get());
mCombinerPass->setNodeMask(Renderer::Mask_RTT);
mCombinerPass->attach(osg::Camera::PACKED_DEPTH_STENCIL_BUFFER, mDepthStencil.get());
mCombinerPass->setClearMask(GL_NONE);
mCombinerPass->setRenderOrder(osg::Camera::PRE_RENDER, pre_render_pass++);
mCombinerPass->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
mCombinerPass->setProjectionResizePolicy(osg::Camera::FIXED);
mCombinerPass->setProjectionMatrix(osg::Matrix::ortho2D(0.0, 1.0, 0.0, 1.0));
ss = setShaderProgram(mCombinerPass.get(), "shaders/combiner.vert", "shaders/combiner.frag");
ss->setAttributeAndModes(new osg::Depth(osg::Depth::ALWAYS, 0.0, 1.0, false),
osg::StateAttribute::OFF);
ss->setTextureAttribute(0, mGBufferColors.get());
ss->setTextureAttribute(1, mDiffuseLight.get());
ss->setTextureAttribute(2, mSpecularLight.get());
ss->addUniform(new osg::Uniform("ColorTex", 0));
ss->addUniform(new osg::Uniform("DiffuseTex", 1));
ss->addUniform(new osg::Uniform("SpecularTex", 2));
mCombinerPass->addChild(createScreenQuad(osg::Vec2f(), 1.0f, 1.0f, mTextureWidth, mTextureHeight));
// Final output to back buffer
mOutputPass = new osg::Camera();
mOutputPass->setNodeMask(Renderer::Mask_RTT);
mOutputPass->setClearMask(GL_NONE);
mOutputPass->setRenderOrder(osg::Camera::POST_RENDER, -1);
mOutputPass->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
mOutputPass->setProjectionResizePolicy(osg::Camera::FIXED);
mOutputPass->setProjectionMatrix(osg::Matrix::ortho2D(0.0, 1.0, 0.0, 1.0));
mOutputPass->setViewport(0, 0, mScreenWidth, mScreenHeight);
mOutputPass->setAllowEventFocus(false);
ss = setShaderProgram(mOutputPass.get(), "shaders/quad_rect.vert", "shaders/quad_rect.frag");
ss->setTextureAttribute(0, mFinalBuffer.get());
ss->addUniform(new osg::Uniform("ImageTex", 0));
ss->setAttributeAndModes(new osg::Depth(osg::Depth::ALWAYS, 0.0, 1.0, false),
osg::StateAttribute::OFF);
mOutputPass->addChild(createScreenQuad(osg::Vec2f(), 1.0f, 1.0f, mTextureWidth, mTextureHeight));
// Graph.
mGraph = new osg::Group();
mGraph->addChild(mClearPass.get());
mGraph->addChild(mMainPass.get());
mGraph->addChild(mLightPass.get());
mGraph->addChild(mCombinerPass.get());
mGraph->addChild(mOutputPass.get());
}
