OSGTextNode::OSGTextNode(QObject *parent) : osgQtQuick::OSGNode(parent), h(new Hidden) { osg::ref_ptr<osgText::Font> textFont = createFont(QFont("Times")); h->text = createText(osg::Vec3(-100, 20, 0), "The osgQtQuick :-)\n" "И даже по русски!", 20.0f, textFont.get()); osg::ref_ptr<osg::Geode> textGeode = new osg::Geode(); h->text->setColor(osg::Vec4(0.0f, 1.0f, 0.0f, 1.0f)); textGeode->addDrawable(h->text.get()); #if 0 h->text->setAutoRotateToScreen(true); setNode(textGeode.get()); #else osg::Camera *camera = createHUDCamera(-100, 100, -100, 100); camera->addChild(textGeode.get()); camera->getOrCreateStateSet()->setMode( GL_LIGHTING, osg::StateAttribute::OFF); setNode(camera); #endif }
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); } }
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 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( int argc, char **argv ) { osg::ArgumentParser arguments(&argc, argv); arguments.getApplicationUsage()->setDescription(arguments.getApplicationName() + " is the example which demonstrates how to enable/disable blending on specified draw buffers in multi-rendering-target cases."); std::vector<osg::Texture*> textures; bool useGlobalBlending = false; if ( arguments.read("--no-draw-buffers") ) useGlobalBlending = true; osg::ref_ptr<osg::Node> cessna = osgDB::readRefNodeFile("cessna.osgt"); if (!cessna) { OSG_NOTICE<<"Cannot not find model 'cessna.osg' to render"<<std::endl; return 1; } // Create a camera to output multi-rendering-targets (MRT) osg::ref_ptr<osg::Camera> mrtCam = createMRTCamera( textures ); mrtCam->addChild( cessna ); // Create shader program to be used const char* mrtFragmentCode = { "void main() {\n" " gl_FragData[0] = gl_Color * vec4(1.0, 1.0, 1.0, 0.7);\n" " gl_FragData[1] = vec4(0.0, 1.0, 1.0, 0.0);\n" " gl_FragData[2] = vec4(1.0, 0.0, 1.0, 0.3);\n" " gl_FragData[3] = vec4(1.0, 1.0, 0.0, 1.0);\n" "}\n" }; osg::ref_ptr<osg::Program> program = new osg::Program; program->addShader( new osg::Shader(osg::Shader::FRAGMENT, mrtFragmentCode) ); osg::ref_ptr<osg::StateSet> ss = mrtCam->getOrCreateStateSet(); ss->setAttributeAndModes( program ); // Apply blending to the original scene in MRT if ( !useGlobalBlending ) { // Only enable blending on the first draw buffer so other three outputs are // totally opaque, which is important for MRT cases ss->setAttribute( new osg::Enablei(GL_BLEND, 0) ); ss->setAttribute( new osg::Disablei(GL_BLEND, 1) ); ss->setAttribute( new osg::Disablei(GL_BLEND, 2) ); ss->setAttribute( new osg::Disablei(GL_BLEND, 3) ); // Accept different blend/colormask attributes on multiple render targets osg::ref_ptr<osg::BlendFunci> blend0 = new osg::BlendFunci(0, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); osg::ref_ptr<osg::ColorMaski> colormask3 = new osg::ColorMaski(3, false, true, false, true); ss->setAttribute( blend0 ); ss->setAttributeAndModes( colormask3 ); } else { // When separated blending is disabled, all rendering targets will be affected // by its alpha channel and you will see each output blended with the background. // // This causes a big program in situations like deferred shading because we may // have to save different scene data to MRT 'GBuffer', in which alpha channels are // used to store certain attributes rather than opacity. These attributes can be // reused in following post-processing steps. // // For such targets, alpha blending must be disabled; otherwise it will mess the // output. That is why this example exists! osg::ref_ptr<osg::BlendFunc> blend = new osg::BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); ss->setAttributeAndModes( blend.get() ); } // Create some quads to be shown on screen to contain the MRT result osg::ref_ptr<osg::Geode> quad = new osg::Geode; for ( unsigned int i=0; i<textures.size(); ++i ) { osg::Geometry* geom = osg::createTexturedQuadGeometry( osg::Vec3((float)i/(float)textures.size(), 0.0f, 0.0f), osg::Vec3(1.0f/(float)textures.size()-0.01f,0.0f,0.0f), osg::Vec3(0.0f,1.0f,0.0f) ); geom->getOrCreateStateSet()->setTextureAttributeAndModes( 0, textures[i] ); quad->addDrawable( geom ); } osg::Camera* hudCam = createHUDCamera( 0.0, 1.0, 0.0, 1.0 ); hudCam->addChild( quad.get() ); // Construct scene graph and viewer osg::ref_ptr<osg::Group> root = new osg::Group; root->addChild( mrtCam ); root->addChild( hudCam ); osgViewer::Viewer viewer; viewer.setSceneData( root.get() ); return viewer.run(); }
int main( int argc, char** argv ) { osg::ArgumentParser arguments( &argc, argv ); osg::ref_ptr<osg::MatrixTransform> scene = new osg::MatrixTransform; scene->addChild( osgDB::readNodeFile("sponza.ive") ); // Create MRT camera and setup draw callback int w = 1600, h = 900; std::vector<osg::Texture2D*> textures; osg::Camera* mrtCam = createMRTCamera( textures, w, h ); mrtCam->addChild( scene.get() ); osg::ref_ptr<HBAODrawCallback> vxgi = new HBAODrawCallback; vxgi->setInputNormalTexture( textures[0] ); vxgi->setInputDepthTexture( textures[1] ); mrtCam->setPostDrawCallback( vxgi.get() ); osg::ref_ptr<osg::Texture2D> outputTex = new osg::Texture2D; outputTex->setTextureSize( w, h ); outputTex->setSourceType( GL_UNSIGNED_BYTE ); outputTex->setSourceFormat( GL_RGBA ); outputTex->setInternalFormat( GL_RGBA ); outputTex->setWrap( osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE ); outputTex->setWrap( osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE ); outputTex->setFilter( osg::Texture2D::MIN_FILTER, osg::Texture2D::NEAREST ); outputTex->setFilter( osg::Texture2D::MAG_FILTER, osg::Texture2D::NEAREST ); vxgi->setOutputTexture( outputTex.get() ); // Create shader program to be used const char* mrtVertexCode = { "varying vec4 vecInEye;\n" "void main() {\n" " vecInEye = gl_ModelViewMatrix * gl_Vertex;\n" " gl_Position = ftransform();\n" "}\n" }; const char* mrtFragmentCode = { "uniform mat4 osg_ViewMatrixInverse;\n" "varying vec4 vecInEye;\n" "void main() {\n" " vec3 normal = normalize(cross(dFdx(vecInEye.xyz), dFdy(vecInEye.xyz)));\n" " normal = mat3(osg_ViewMatrixInverse) * vec3(normal.x, -normal.y, -normal.z);\n" " gl_FragColor = vec4(normal * 0.5 + vec3(0.5), 1.0);\n" "}\n" }; osg::ref_ptr<osg::Program> program = new osg::Program; program->addShader( new osg::Shader(osg::Shader::VERTEX, mrtVertexCode) ); program->addShader( new osg::Shader(osg::Shader::FRAGMENT, mrtFragmentCode) ); osg::StateSet* ss = mrtCam->getOrCreateStateSet(); ss->setAttributeAndModes( program.get() ); // Create screen quad to contain the MRT result osg::ref_ptr<osg::Geode> quad = new osg::Geode; quad->addDrawable( osg::createTexturedQuadGeometry( osg::Vec3(), osg::Vec3(0.5f, 0.0f, 0.0f), osg::Vec3(0.0f, 1.0f, 0.0f), 0.0f, 0.0f, 0.5f, 1.0f) ); osg::Camera* hudCam = createHUDCamera( 0.0, 1.0, 0.0, 1.0 ); hudCam->getOrCreateStateSet()->setTextureAttributeAndModes( 0, outputTex.get() ); hudCam->addChild( quad.get() ); // Construct scene graph and viewer osg::ref_ptr<osg::Group> root = new osg::Group; root->addChild( mrtCam ); root->addChild( hudCam ); root->addChild( scene.get() ); osgViewer::Viewer viewer; viewer.setSceneData( root.get() ); //viewer.getCamera()->setProjectionMatrixAsPerspective( 30.0f, 16.0f/9.0f, 0.1f, 1000.0f ); //viewer.getCamera()->setComputeNearFarMode( osg::Camera::DO_NOT_COMPUTE_NEAR_FAR ); viewer.addEventHandler( new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()) ); viewer.addEventHandler( new osgViewer::StatsHandler ); viewer.addEventHandler( new osgViewer::WindowSizeHandler ); viewer.setCameraManipulator( new osgGA::TrackballManipulator ); viewer.setUpViewOnSingleScreen( 0 ); viewer.run(); return 0; }