Changeset 13376

Show
Ignore:
Timestamp:
11/09/15 17:13:03 (2 years ago)
Author:
robert
Message:

Release OpenSceneGraph-3.5.1

Location:
OpenSceneGraph/trunk
Files:
36 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/examples/osgcompositeviewer/osgcompositeviewer.cpp

    r12529 r13376  
    5555    ~PickHandler() {} 
    5656 
    57     bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa) 
     57    bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa) 
    5858    { 
    5959        osgViewer::View* view = dynamic_cast<osgViewer::View*>(&aa); 
     
    7272                if (_mx==ea.getX() && _my==ea.getY()) 
    7373                { 
    74                     pick(view, ea.getX(), ea.getY()); 
     74                    pick(view, ea); 
    7575                } 
    7676                break; 
     
    8282    } 
    8383 
    84     void pick(osgViewer::View* view, float x, float y) 
     84    void pick(osgViewer::View* view, const osgGA::GUIEventAdapter& event) 
    8585    { 
    8686        osg::Node* node = 0; 
     
    8888 
    8989        osgUtil::LineSegmentIntersector::Intersections intersections; 
    90         if (view->computeIntersections(x, y, intersections)) 
     90        if (view->computeIntersections(event, intersections)) 
    9191        { 
    9292            osgUtil::LineSegmentIntersector::Intersection intersection = *intersections.begin(); 
     
    9999        if (parent && node) 
    100100        { 
    101  
    102101            osgFX::Scribe* parentAsScribe = dynamic_cast<osgFX::Scribe*>(parent); 
    103102            if (!parentAsScribe) 
  • OpenSceneGraph/trunk/examples/osgkeystone/osgkeystone.cpp

    r13374 r13376  
    3636    Keystone(): 
    3737        keystoneEditingEnabled(false), 
     38        gridColour(1.0f,1.0f,1.0f,1.0f), 
    3839        bottom_left(-1.0,-1.0), 
    3940        bottom_right(1.0,-1.0), 
     
    5354        if (&rhs==this) return *this; 
    5455        keystoneEditingEnabled = rhs.keystoneEditingEnabled; 
     56        gridColour = rhs.gridColour; 
    5557        bottom_left = rhs.bottom_left; 
    5658        bottom_right = rhs.bottom_right; 
     
    6264    bool        keystoneEditingEnabled; 
    6365 
     66    osg::Vec4   gridColour; 
     67 
    6468    osg::Vec2d  bottom_left; 
    6569    osg::Vec2d  bottom_right; 
     
    98102    ~KeystoneHandler() {} 
    99103 
    100     bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa); 
     104    bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa, osg::Object* obj, osg::NodeVisitor* nv); 
    101105 
    102106    void setKeystoneEditingEnabled(bool enabled) { if (_currentControlPoints.valid()) _currentControlPoints->keystoneEditingEnabled = enabled; } 
     
    229233} 
    230234 
    231 bool KeystoneHandler::handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa) 
    232 { 
     235bool KeystoneHandler::handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa, osg::Object* obj, osg::NodeVisitor* nv) 
     236{ 
     237    osg::Camera* camera = dynamic_cast<osg::Camera*>(obj); 
     238    osg::Viewport* viewport = camera ?  camera->getViewport() : 0; 
     239 
     240    if (!viewport) return false; 
     241 
     242    bool haveCameraMatch = false; 
     243    float x = ea.getXnormalized(); 
     244    float y = ea.getYnormalized(); 
     245    for(unsigned int i=0; i<ea.getNumPointerData(); ++i) 
     246    { 
     247        const osgGA::PointerData* pd = ea.getPointerData(i); 
     248        if (pd->object==obj) 
     249        { 
     250            haveCameraMatch = true; 
     251            x = pd->getXnormalized(); 
     252            y = pd->getYnormalized(); 
     253            break; 
     254        } 
     255    } 
     256 
     257 
     258    if (!haveCameraMatch) return false; 
     259 
    233260    switch(ea.getEventType()) 
    234261    { 
     
    242269                    _selectedRegion = computeRegion(ea); 
    243270                    (*_startControlPoints) = (*_currentControlPoints); 
    244                     _startPosition.set(ea.getXnormalized(),ea.getYnormalized()); 
     271                    _startPosition.set(x,y); 
    245272                } 
    246273                else 
     
    258285                { 
    259286                    (*_currentControlPoints) = (*_startControlPoints); 
    260                     osg::Vec2d currentPosition(ea.getXnormalized(), ea.getYnormalized()); 
     287                    osg::Vec2d currentPosition(x, y); 
    261288                    osg::Vec2d delta(currentPosition-_startPosition); 
    262289                    osg::Vec2d scale = incrementScale(ea); 
     
    307334                else if (ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_7 || ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Home) 
    308335                { 
    309                     _currentControlPoints->top_left.set(ea.getXnormalized(), ea.getYnormalized()); 
     336                    _currentControlPoints->top_left.set(x, y); 
    310337                } 
    311338                else if (ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_9 || ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Page_Up) 
    312339                { 
    313                     _currentControlPoints->top_right.set(ea.getXnormalized(), ea.getYnormalized()); 
     340                    _currentControlPoints->top_right.set(x, y); 
    314341                } 
    315342                else if (ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_3 || ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Page_Down) 
    316343                { 
    317                     _currentControlPoints->bottom_right.set(ea.getXnormalized(), ea.getYnormalized()); 
     344                    _currentControlPoints->bottom_right.set(x, y); 
    318345                } 
    319346                else if (ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_1 || ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_End) 
    320347                { 
    321                     _currentControlPoints->bottom_left.set(ea.getXnormalized(), ea.getYnormalized()); 
     348                    _currentControlPoints->bottom_left.set(x, y); 
    322349                } 
    323350            } 
     
    472499 
    473500    osg::ref_ptr<osg::Vec4Array> colours = new osg::Vec4Array; 
    474     colours->push_back(osg::Vec4(1.0f,1.0f,1.0f,1.0f)); 
     501    colours->push_back(keystone->gridColour); 
    475502    geometry->setColorArray(colours.get()); 
    476503    geometry->setColorBinding(osg::Geometry::BIND_OVERALL); 
     
    580607osg::Camera* assignKeystoneRenderToTextureCamera(osgViewer::View* view, osg::GraphicsContext* gc, int width, int height, osg::Texture* texture) 
    581608{ 
    582     osg::Camera::RenderTargetImplementation renderTargetImplementation = osg::Camera::FRAME_BUFFER_OBJECT; 
    583     GLenum buffer = GL_FRONT; 
    584  
    585609    osg::ref_ptr<osg::Camera> camera = new osg::Camera; 
    586610    camera->setName("Render to texture camera"); 
    587611    camera->setGraphicsContext(gc); 
    588612    camera->setViewport(new osg::Viewport(0,0,width, height)); 
    589     camera->setDrawBuffer(buffer); 
    590     camera->setReadBuffer(buffer); 
     613    camera->setDrawBuffer(GL_FRONT); 
     614    camera->setReadBuffer(GL_FRONT); 
    591615    camera->setAllowEventFocus(false); 
    592     // tell the camera to use OpenGL frame buffer object where supported. 
    593     camera->setRenderTargetImplementation(renderTargetImplementation); 
     616    camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT); 
    594617 
    595618    // attach the texture and use it as the color buffer. 
     
    629652    camera->setReadBuffer(buffer); 
    630653    camera->setReferenceFrame(osg::Camera::ABSOLUTE_RF); 
    631     camera->setAllowEventFocus(false); 
    632654    camera->setInheritanceMask(camera->getInheritanceMask() & ~osg::CullSettings::CLEAR_COLOR & ~osg::CullSettings::COMPUTE_NEAR_FAR_MODE); 
    633655    //camera->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR); 
     
    822844 
    823845    ds->setUseSceneViewForStereoHint(false); 
     846 
     847 
     848    osg::ref_ptr<Keystone> keystone = new Keystone; 
    824849 
    825850    
     
    911936        { 
    912937            // left Camera red 
    913             { 
    914                 osg::ref_ptr<osg::Camera> camera = assignStereoCamera(view, ds, gc, 0, 0, traits->width, traits->height, traits->doubleBuffer ? GL_BACK : GL_FRONT, -1.0); 
    915                 camera->setClearMask(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); 
    916                 camera->getOrCreateStateSet()->setAttribute(new osg::ColorMask(true, false, false, true)); 
    917                 camera->setRenderOrder(osg::Camera::NESTED_RENDER, 0); 
    918             } 
     938            osg::ref_ptr<osg::Camera> left_camera = assignStereoCamera(view, ds, gc, 0, 0, traits->width, traits->height, traits->doubleBuffer ? GL_BACK : GL_FRONT, -1.0); 
     939            left_camera->setClearMask(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); 
     940            left_camera->getOrCreateStateSet()->setAttribute(new osg::ColorMask(true, false, false, true)); 
     941            left_camera->setRenderOrder(osg::Camera::NESTED_RENDER, 0); 
    919942 
    920943            // right Camera cyan 
    921             { 
    922                 osg::ref_ptr<osg::Camera> camera = assignStereoCamera(view, ds, gc, 0, 0, traits->width, traits->height, traits->doubleBuffer ? GL_BACK : GL_FRONT, 1.0); 
    923                 camera->setClearMask(GL_DEPTH_BUFFER_BIT); 
    924                 camera->getOrCreateStateSet()->setAttribute(new osg::ColorMask(false, true, true, true)); 
    925                 camera->setRenderOrder(osg::Camera::NESTED_RENDER, 1); 
    926             } 
    927  
    928             // for keystone: 
    929             // left camera to render to texture using red colour mask 
    930             // right camera to render to same texture using cyan colour mask 
    931             // keystone camera to render to whole screen without colour masks 
    932             // one keystone and editing for the one window 
     944            osg::ref_ptr<osg::Camera> right_camera = assignStereoCamera(view, ds, gc, 0, 0, traits->width, traits->height, traits->doubleBuffer ? GL_BACK : GL_FRONT, 1.0); 
     945            right_camera->setClearMask(GL_DEPTH_BUFFER_BIT); 
     946            right_camera->getOrCreateStateSet()->setAttribute(new osg::ColorMask(false, true, true, true)); 
     947            right_camera->setRenderOrder(osg::Camera::NESTED_RENDER, 1); 
     948 
     949            if (keystone.valid()) 
     950            { 
     951                // for keystone: 
     952                // left camera to render to texture using red colour mask 
     953                // right camera to render to same texture using cyan colour mask 
     954                // keystone camera to render to whole screen without colour masks 
     955                // one keystone and editing for the one window 
     956 
     957                // create distortion texture 
     958                osg::ref_ptr<osg::Texture> texture = createKestoneDistortionTexture(traits->width, traits->height); 
     959 
     960                // convert to RTT Camera 
     961                left_camera->setDrawBuffer(GL_FRONT); 
     962                left_camera->setReadBuffer(GL_FRONT); 
     963                left_camera->setAllowEventFocus(false); 
     964                left_camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT); 
     965 
     966                // attach the texture and use it as the color buffer. 
     967                left_camera->attach(osg::Camera::COLOR_BUFFER, texture.get()); 
     968 
     969 
     970                // convert to RTT Camera 
     971                right_camera->setDrawBuffer(GL_FRONT); 
     972                right_camera->setReadBuffer(GL_FRONT); 
     973                right_camera->setAllowEventFocus(false); 
     974                right_camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT); 
     975 
     976                // attach the texture and use it as the color buffer. 
     977                right_camera->attach(osg::Camera::COLOR_BUFFER, texture.get()); 
     978 
     979 
     980                // create Keystone distortion camera 
     981                osg::ref_ptr<osg::Camera> camera = assignKeystoneDistortionCamera(view, ds, gc.get(), 
     982                                                                                0, 0, traits->width, traits->height, 
     983                                                                                traits->doubleBuffer ? GL_BACK : GL_FRONT, 
     984                                                                                texture, keystone.get()); 
     985 
     986                camera->setRenderOrder(osg::Camera::NESTED_RENDER, 2); 
     987                 
     988                // attach Keystone editing event handler. 
     989                camera->addEventCallback(new KeystoneHandler(keystone.get())); 
     990            } 
    933991 
    934992            break; 
     
    937995        { 
    938996            // left viewport Camera 
    939             assignStereoCamera(view, ds, gc, 
     997            osg::ref_ptr<osg::Camera> left_camera = assignStereoCamera(view, ds, gc, 
    940998                               0, 0, traits->width/2, traits->height, traits->doubleBuffer ? GL_BACK : GL_FRONT, 
    941999                               (ds->getSplitStereoHorizontalEyeMapping()==osg::DisplaySettings::LEFT_EYE_LEFT_VIEWPORT) ? -1.0 : 1.0); 
    9421000 
    9431001            // right viewport Camera 
    944             assignStereoCamera(view, ds, gc, 
     1002            osg::ref_ptr<osg::Camera> right_camera = assignStereoCamera(view, ds, gc, 
    9451003                               traits->width/2,0, traits->width/2, traits->height, traits->doubleBuffer ? GL_BACK : GL_FRONT, 
    9461004                               (ds->getSplitStereoHorizontalEyeMapping()==osg::DisplaySettings::LEFT_EYE_RIGHT_VIEWPORT) ? -1.0 : 1.0); 
    9471005 
    948             // for keystone: 
    949             // left camera to render to left texture using whole viewport of left texture 
    950             // right camera to render to right texture using whole viewport of right texture 
    951             // left keystone camera to render to left viewport/window 
    952             // right keystone camera to render to right viewport/window 
    953             // two keystone, one for each of the left and right viewports/windows 
    954  
     1006            if (keystone.valid()) 
     1007            { 
     1008                // for keystone: 
     1009                // left camera to render to left texture using whole viewport of left texture 
     1010                // right camera to render to right texture using whole viewport of right texture 
     1011                // left keystone camera to render to left viewport/window 
     1012                // right keystone camera to render to right viewport/window 
     1013                // two keystone, one for each of the left and right viewports/windows 
     1014 
     1015                // create distortion texture 
     1016                osg::ref_ptr<osg::Texture> left_texture = createKestoneDistortionTexture(traits->width/2, traits->height); 
     1017 
     1018                // convert to RTT Camera 
     1019                left_camera->setViewport(0, 0, traits->width/2, traits->height); 
     1020                left_camera->setDrawBuffer(GL_FRONT); 
     1021                left_camera->setReadBuffer(GL_FRONT); 
     1022                left_camera->setAllowEventFocus(true); 
     1023                left_camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT); 
     1024 
     1025                // attach the texture and use it as the color buffer. 
     1026                left_camera->attach(osg::Camera::COLOR_BUFFER, left_texture.get()); 
     1027 
     1028 
     1029                // create distortion texture 
     1030                osg::ref_ptr<osg::Texture> right_texture = createKestoneDistortionTexture(traits->width/2, traits->height); 
     1031 
     1032                // convert to RTT Camera 
     1033                right_camera->setViewport(0, 0, traits->width/2, traits->height); 
     1034                right_camera->setDrawBuffer(GL_FRONT); 
     1035                right_camera->setReadBuffer(GL_FRONT); 
     1036                right_camera->setAllowEventFocus(true); 
     1037                right_camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT); 
     1038 
     1039                // attach the texture and use it as the color buffer. 
     1040                right_camera->attach(osg::Camera::COLOR_BUFFER, right_texture.get()); 
     1041                 
     1042 
     1043                // create Keystone left distortion camera 
     1044                keystone->gridColour.set(1.0f,0.0f,0.0,1.0); 
     1045                osg::ref_ptr<osg::Camera> left_keystone_camera = assignKeystoneDistortionCamera(view, ds, gc.get(), 
     1046                                                                                0, 0, traits->width/2, traits->height, 
     1047                                                                                traits->doubleBuffer ? GL_BACK : GL_FRONT, 
     1048                                                                                left_texture, keystone.get()); 
     1049 
     1050                left_keystone_camera->setRenderOrder(osg::Camera::NESTED_RENDER, 2); 
     1051 
     1052                // attach Keystone editing event handler. 
     1053                left_keystone_camera->addEventCallback(new KeystoneHandler(keystone.get())); 
     1054 
     1055 
     1056                osg::ref_ptr<Keystone> right_keystone = new Keystone; 
     1057                right_keystone->gridColour.set(0.0f,1.0f,0.0,1.0); 
     1058                 
     1059                // create Keystone right distortion camera 
     1060                osg::ref_ptr<osg::Camera> right_keystone_camera = assignKeystoneDistortionCamera(view, ds, gc.get(), 
     1061                                                                                traits->width/2, 0, traits->width/2, traits->height, 
     1062                                                                                traits->doubleBuffer ? GL_BACK : GL_FRONT, 
     1063                                                                                right_texture, right_keystone.get()); 
     1064 
     1065                right_keystone_camera->setRenderOrder(osg::Camera::NESTED_RENDER, 3); 
     1066 
     1067                // attach Keystone editing event handler. 
     1068                right_keystone_camera->addEventCallback(new KeystoneHandler(right_keystone.get())); 
     1069 
     1070                view->getCamera()->setAllowEventFocus(false); 
     1071                 
     1072            } 
     1073             
    9551074            break; 
    9561075        } 
  • OpenSceneGraph/trunk/examples/osglauncher/osglauncher.cpp

    r9655 r13376  
    6464    bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& us); 
    6565 
    66     std::string pick(float x, float y); 
     66    std::string pick(const osgGA::GUIEventAdapter& event); 
    6767     
    6868    void highlight(const std::string& name) 
     
    8484    case(osgGA::GUIEventAdapter::MOVE): 
    8585    { 
    86         //osg::notify(osg::NOTICE)<<"MOVE "<<ea.getX()<<ea.getY()<<std::endl; 
    87         std::string picked_name = pick(ea.getX(),ea.getY()); 
     86        // osg::notify(osg::NOTICE)<<"MOVE "<<ea.getX()<<", "<<ea.getY()<<std::endl; 
     87        std::string picked_name = pick(ea); 
    8888        highlight(picked_name); 
    8989        return false; 
     
    9191    case(osgGA::GUIEventAdapter::PUSH): 
    9292    { 
    93         //osg::notify(osg::NOTICE)<<"PUSH "<<ea.getX()<<ea.getY()<<std::endl; 
    94         std::string picked_name = pick(ea.getX(),ea.getY()); 
     93        // osg::notify(osg::NOTICE)<<"PUSH "<<ea.getX()<<", "<<ea.getY()<<std::endl; 
     94        std::string picked_name = pick(ea); 
    9595        if (!picked_name.empty()) 
    9696        { 
     
    109109 
    110110 
    111 std::string PickHandler::pick(float x, float y) 
     111std::string PickHandler::pick(const osgGA::GUIEventAdapter& event) 
    112112{ 
    113113    osgUtil::LineSegmentIntersector::Intersections intersections; 
    114     if (_viewer->computeIntersections(x, y, intersections)) 
     114    if (_viewer->computeIntersections(event, intersections)) 
    115115    { 
    116116        for(osgUtil::LineSegmentIntersector::Intersections::iterator hitr = intersections.begin(); 
  • OpenSceneGraph/trunk/examples/osgmovie/osgmovie.cpp

    r10925 r13376  
    149149                osgUtil::LineSegmentIntersector::Intersections intersections; 
    150150                bool foundIntersection = view==0 ? false : 
    151                     (nv==0 ? view->computeIntersections(ea.getX(), ea.getY(), intersections) : 
    152                              view->computeIntersections(ea.getX(), ea.getY(), nv->getNodePath(), intersections)); 
     151                    (nv==0 ? view->computeIntersections(ea, intersections) : 
     152                             view->computeIntersections(ea, nv->getNodePath(), intersections)); 
    153153 
    154154                if (foundIntersection) 
  • OpenSceneGraph/trunk/examples/osgmultiplemovies/osgmultiplemovies.cpp

    r13213 r13376  
    165165            osgViewer::View* view = dynamic_cast<osgViewer::View*>(&aa); 
    166166            osgUtil::LineSegmentIntersector::Intersections intersections; 
    167             bool foundIntersection = view==0 ? false : view->computeIntersections(ea.getX(), ea.getY(), intersections); 
     167            bool foundIntersection = view==0 ? false : view->computeIntersections(ea, intersections); 
    168168 
    169169            if (foundIntersection) 
  • OpenSceneGraph/trunk/examples/osgoccluder/osgoccluder.cpp

    r12529 r13376  
    7373                osgViewer::View* view = dynamic_cast<osgViewer::View*>(&aa); 
    7474                osgUtil::LineSegmentIntersector::Intersections intersections; 
    75                 if (view && view->computeIntersections(ea.getX(), ea.getY(), intersections)) 
     75                if (view && view->computeIntersections(ea, intersections)) 
    7676                { 
    7777                    const osgUtil::LineSegmentIntersector::Intersection& hit = *(intersections.begin()); 
  • OpenSceneGraph/trunk/examples/osgoscdevice/osgoscdevice.cpp

    r13331 r13376  
    123123    float x = ea.getX(); 
    124124    float y = ea.getY(); 
    125 #if 0 
    126     osg::ref_ptr< osgUtil::LineSegmentIntersector > picker = new osgUtil::LineSegmentIntersector(osgUtil::Intersector::WINDOW, x, y); 
    127     osgUtil::IntersectionVisitor iv(picker.get()); 
    128     view->getCamera()->accept(iv); 
    129     if (picker->containsIntersections()) 
    130     { 
    131         intersections = picker->getIntersections(); 
    132 #else 
    133     if (view->computeIntersections(x,y,intersections)) 
    134     { 
    135 #endif 
     125    if (view->computeIntersections(ea, intersections)) 
     126    { 
    136127        for(osgUtil::LineSegmentIntersector::Intersections::iterator hitr = intersections.begin(); 
    137128            hitr != intersections.end(); 
  • OpenSceneGraph/trunk/examples/osgparticleeffects/osgparticleeffects.cpp

    r12697 r13376  
    269269        osg::Group* root = dynamic_cast<osg::Group*>(viewer->getSceneData());        
    270270        if (!root) return; 
    271  
     271         
    272272        osgUtil::LineSegmentIntersector::Intersections intersections; 
    273         if (viewer->computeIntersections(ea.getX(),ea.getY(),intersections)) 
     273        if (viewer->computeIntersections(ea,intersections)) 
    274274        { 
    275275            const osgUtil::LineSegmentIntersector::Intersection& hit = *intersections.begin(); 
  • OpenSceneGraph/trunk/examples/osgpick/osgpick.cpp

    r12529 r13376  
    107107 
    108108    std::string gdlist=""; 
    109     float x = ea.getX(); 
    110     float y = ea.getY(); 
    111 #if 0 
    112     osg::ref_ptr< osgUtil::LineSegmentIntersector > picker = new osgUtil::LineSegmentIntersector(osgUtil::Intersector::WINDOW, x, y); 
    113     osgUtil::IntersectionVisitor iv(picker.get()); 
    114     view->getCamera()->accept(iv); 
    115     if (picker->containsIntersections()) 
    116     { 
    117         intersections = picker->getIntersections(); 
    118 #else 
    119     if (view->computeIntersections(x,y,intersections)) 
    120     { 
    121 #endif 
     109     
     110    if (view->computeIntersections(ea,intersections)) 
     111    { 
    122112        for(osgUtil::LineSegmentIntersector::Intersections::iterator hitr = intersections.begin(); 
    123113            hitr != intersections.end(); 
  • OpenSceneGraph/trunk/examples/osgwidgetbox/osgwidgetbox.cpp

    r12529 r13376  
    3939 
    4040    bool mouseOver(double x, double y, const osgWidget::WindowManager*) { 
     41         
    4142        osgWidget::Color c = getImageColorAtPointerXY(x, y); 
    4243 
     
    4647            return false; 
    4748        } 
    48  
    4949        return true; 
    5050    } 
  • OpenSceneGraph/trunk/include/osgGA/EventQueue

    r13041 r13376  
    6565        /** Set the graphics context associated with this event queue.*/ 
    6666        void setGraphicsContext(osg::GraphicsContext* context) { getCurrentEventState()->setGraphicsContext(context); } 
     67         
     68        osg::GraphicsContext* getGraphicsContext() { return getCurrentEventState()->getGraphicsContext(); } 
     69 
     70        const osg::GraphicsContext* getGraphicsContext() const { return getCurrentEventState()->getGraphicsContext(); } 
     71 
     72        /** Read the window record dimensions from the graphics context. */ 
     73        void syncWindowRectangleWithGraphcisContext(); 
    6774 
    6875 
  • OpenSceneGraph/trunk/include/osgGA/GUIEventAdapter

    r13160 r13376  
    2222namespace osgGA{ 
    2323 
    24  
     24struct PointerData : public osg::Referenced 
     25{ 
     26    PointerData(): 
     27        object(0), 
     28        x(0.0f), 
     29        xMin(-1.0f), 
     30        xMax(1.0f), 
     31        y(0.0f), 
     32        yMin(-1.0f), 
     33        yMax(1.0f) {} 
     34     
     35    PointerData(osg::Object* obj, float in_x, float in_xMin, float in_xMax, float in_y, float in_yMin, float in_yMax): 
     36        object(obj), 
     37        x(in_x), 
     38        xMin(in_xMin), 
     39        xMax(in_xMax), 
     40        y(in_y), 
     41        yMin(in_yMin), 
     42        yMax(in_yMax) {} 
     43     
     44    PointerData(const PointerData& pd): 
     45        object(pd.object), 
     46        x(pd.x), 
     47        xMin(pd.xMin), 
     48        xMax(pd.xMax), 
     49        y(pd.y), 
     50        yMin(pd.yMin), 
     51        yMax(pd.yMax) {} 
     52     
     53    PointerData& operator = (const PointerData& pd) 
     54    { 
     55        if (&pd==this) return *this; 
     56     
     57        object = pd.object; 
     58        x = pd.x; 
     59        xMin = pd.xMin; 
     60        xMax = pd.xMax; 
     61        y = pd.y; 
     62        yMin = pd.yMin; 
     63        yMax = pd.yMax; 
     64         
     65        return *this; 
     66    } 
     67     
     68    osg::observer_ptr<osg::Object> object; 
     69    float x, xMin, xMax; 
     70    float y, yMin, yMax; 
     71     
     72    float getXnormalized() const { return (x-xMin)/(xMax-xMin)*2.0f-1.0f; } 
     73    float getYnormalized() const { return (y-yMin)/(yMax-yMin)*2.0f-1.0f; } 
     74}; 
     75 
     76     
    2577/** Event class for storing Keyboard, mouse and window events. 
    2678*/ 
     
    426478 
    427479        void setGraphicsContext(osg::GraphicsContext* context) { _context = context; } 
     480        osg::GraphicsContext* getGraphicsContext() { return _context.get(); } 
    428481        const osg::GraphicsContext* getGraphicsContext() const { return _context.get(); } 
    429482 
     
    515568        float getY() const { return _my; } 
    516569 
     570#if 1 
     571        inline float getXnormalized() const 
     572        { 
     573            return _pointerDataList.size()>=1 ?  
     574                   _pointerDataList[_pointerDataList.size()-1]->getXnormalized(): 
     575                   2.0f*(getX()-getXmin())/(getXmax()-getXmin())-1.0f; 
     576        } 
     577 
     578        inline float getYnormalized() const 
     579        { 
     580            if (_pointerDataList.size()>=1) return _pointerDataList[_pointerDataList.size()-1]->getYnormalized(); 
     581            if (_mouseYOrientation==Y_INCREASING_UPWARDS) return 2.0f*(getY()-getYmin())/(getYmax()-getYmin())-1.0f; 
     582            else return -(2.0f*(getY()-getYmin())/(getYmax()-getYmin())-1.0f); 
     583        } 
     584#else 
    517585        /** 
    518586         * return the current mouse x value normalized to the range of -1 to 1. 
     
    534602            else return -(2.0f*(getY()-getYmin())/(getYmax()-getYmin())-1.0f); 
    535603        } 
    536  
     604#endif 
    537605        /// set mouse-Y orientation (mouse-Y increases upwards or downwards). 
    538606        void setMouseYOrientation(MouseYOrientation myo) { _mouseYOrientation = myo; } 
     
    616684        TouchData* getTouchData() const { return _touchData.get(); } 
    617685        bool isMultiTouchEvent() const { return (_touchData.valid()); } 
     686 
     687         
     688        typedef std::vector< osg::ref_ptr<PointerData> > PointerDataList; 
     689        void setPointerDataList(const PointerDataList& pdl) { _pointerDataList = pdl; } 
     690        PointerDataList& getPointerDataList() { return _pointerDataList; } 
     691        const PointerDataList& getPointerDataList() const { return _pointerDataList; } 
     692 
     693        unsigned int getNumPointerData() const { return _pointerDataList.size(); } 
     694        PointerData* getPointerData(unsigned int i) { return _pointerDataList[i].get(); } 
     695        const PointerData* getPointerData(unsigned int i) const { return _pointerDataList[i].get(); } 
     696 
     697        PointerData* getPointerData(osg::Object* obj) { for(unsigned int i=0;i<_pointerDataList.size(); ++i) { if (_pointerDataList[i]->object==obj) return _pointerDataList[i].get(); } return 0; } 
     698        const PointerData* getPointerData(osg::Object* obj) const { for(unsigned int i=0;i<_pointerDataList.size(); ++i) { if (_pointerDataList[i]->object==obj) return _pointerDataList[i].get(); } return 0; } 
     699        void addPointerData(PointerData* pd) { _pointerDataList.push_back(pd); } 
     700         
     701        void copyPointerDataFrom(const osgGA::GUIEventAdapter& sourceEvent); 
    618702 
    619703    protected: 
     
    665749 
    666750        osg::ref_ptr<TouchData> _touchData; 
     751 
     752 
     753        PointerDataList _pointerDataList; 
    667754}; 
    668755 
  • OpenSceneGraph/trunk/include/osgUtil/LineSegmentIntersector

    r12237 r13376  
    6464            const osg::Vec3& getLocalIntersectNormal() const { return localIntersectionNormal; } 
    6565            osg::Vec3 getWorldIntersectNormal() const { return matrix.valid() ? osg::Matrix::transform3x3(osg::Matrix::inverse(*matrix),localIntersectionNormal) : localIntersectionNormal; } 
     66 
     67            /** convinience function for mapping the intersection point to any textures assigned to the objects intersected. 
     68             *  Returns the Texture pointer and texture coords of object hit when a texture is available on the object, returns NULL otherwise.*/ 
     69            osg::Texture* getTextureLookUp(osg::Vec3& tc) const; 
     70             
    6671        }; 
    6772 
  • OpenSceneGraph/trunk/include/osgViewer/CompositeViewer

    r13041 r13376  
    124124        virtual void viewerInit(); 
    125125 
     126        void generateSlavePointerData(osg::Camera* camera, osgGA::GUIEventAdapter& event); 
     127        void generatePointerData(osgGA::GUIEventAdapter& event); 
     128        void reprojectPointerData(osgGA::GUIEventAdapter& source_event, osgGA::GUIEventAdapter& dest_event); 
     129 
    126130        typedef std::vector< osg::ref_ptr<osgViewer::View> > RefViews; 
    127131        RefViews _views; 
     
    136140        osg::observer_ptr<osg::Camera>      _cameraWithFocus; 
    137141        osg::observer_ptr<osgViewer::View>  _viewWithFocus; 
     142         
     143        osg::ref_ptr<osgGA::GUIEventAdapter> _previousEvent; 
    138144 
    139145}; 
  • OpenSceneGraph/trunk/include/osgViewer/View

    r13172 r13376  
    228228        bool containsCamera(const osg::Camera* camera) const; 
    229229 
    230         /** Get the camera which contains the pointer position x,y specified in the master camera's window/eye coordinates. 
    231           * Also passes back the local window coordinatess for the graphics context associated with the camera. */ 
     230         
     231        /** deprecated. */ 
    232232        const osg::Camera* getCameraContainingPosition(float x, float y, float& local_x, float& local_y) const; 
    233233 
    234         /** Compute intersections between a ray through the specified master camera's window/eye coordinates and a specified node. 
    235           * Note, when a master camera has slaves and no viewport itself, its coordinate frame will be in clip space i.e. -1,-1 to 1,1, 
    236           * while if it has a viewport the coordintates will be relative to its viewport dimensions. 
    237           * Mouse events handled by the view will automatically be attached to the master camera window/clip coordinates so that they can be passed 
    238           * directly to the computeIntersections method. */ 
     234        /** deprecated. */ 
    239235        bool computeIntersections(float x,float y, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask = 0xffffffff); 
    240236 
    241         /** Compute intersections between a ray through the specified master camera's window/eye coordinates and a specified nodePath's subgraph. */ 
     237        /** deprecated. */ 
    242238        bool computeIntersections(float x,float y, const osg::NodePath& nodePath, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask = 0xffffffff); 
    243239 
     240         
     241        /** Compute intersections of a ray, starting the current mouse position, through the specified camera. */ 
     242        bool computeIntersections(const osgGA::GUIEventAdapter& ea, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask = 0xffffffff); 
     243 
     244        /** Compute intersections of a ray, starting the current mouse position, through the specified master camera's window/eye coordinates and a specified nodePath's subgraph. */ 
     245        bool computeIntersections(const osgGA::GUIEventAdapter& ea, const osg::NodePath& nodePath, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask = 0xffffffff); 
     246 
     247         
     248        /** Compute intersections of a ray through the specified camera. */ 
     249        bool computeIntersections(const osg::Camera* camera, osgUtil::Intersector::CoordinateFrame cf, float x,float y, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask = 0xffffffff); 
     250 
     251        /** Compute intersections of a ray through the specified camera and a specified nodePath's subgraph. */ 
     252        bool computeIntersections(const osg::Camera* camera, osgUtil::Intersector::CoordinateFrame cf, float x,float y, const osg::NodePath& nodePath, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask = 0xffffffff); 
    244253 
    245254        virtual void requestRedraw(); 
  • OpenSceneGraph/trunk/include/osgViewer/Viewer

    r13041 r13376  
    9494        virtual void updateTraversal(); 
    9595 
    96         void setCameraWithFocus(osg::Camera* camera) { _cameraWithFocus = camera; } 
    97         osg::Camera* getCameraWithFocus() { return _cameraWithFocus.get(); } 
    98         const osg::Camera* getCameraWithFocus() const { return _cameraWithFocus.get(); } 
    99  
    10096        virtual void getCameras(Cameras& cameras, bool onlyActive=true); 
    10197 
     
    120116        virtual void viewerInit() { init(); } 
    121117 
    122         osg::observer_ptr<osg::Camera>              _cameraWithFocus; 
    123  
     118        void generateSlavePointerData(osg::Camera* camera, osgGA::GUIEventAdapter& event); 
     119        void generatePointerData(osgGA::GUIEventAdapter& event); 
     120        void reprojectPointerData(osgGA::GUIEventAdapter& source_event, osgGA::GUIEventAdapter& dest_event); 
    124121 
    125122}; 
  • OpenSceneGraph/trunk/include/osgViewer/ViewerEventHandlers

    r13041 r13376  
    529529 
    530530    bool mousePosition(osgViewer::View* view, osg::NodeVisitor* nv, const osgGA::GUIEventAdapter& ea, int& x, int &y) const; 
    531     bool computeIntersections(osgViewer::View* view, float x,float y, const osg::NodePath& nodePath, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask = 0xffffffff) const; 
    532531 
    533532    void resize(int width, int height); 
  • OpenSceneGraph/trunk/src/osgGA/EventQueue.cpp

    r13277 r13376  
    133133} 
    134134 
     135void EventQueue::syncWindowRectangleWithGraphcisContext() 
     136{ 
     137    const osg::GraphicsContext::Traits* traits = (getGraphicsContext()!=0) ? getGraphicsContext()->getTraits() : 0; 
     138    if (traits) _accumulateEventState->setWindowRectangle(traits->x, traits->y, traits->width, traits->height, !_useFixedMouseInputRange); 
     139} 
    135140 
    136141void EventQueue::windowResize(int x, int y, int width, int height, double time) 
     
    491496    event->setEventType(GUIEventAdapter::FRAME); 
    492497    event->setTime(time); 
     498     
     499    OSG_NOTICE<<"frame("<<time<<"), event->getX()="<<event->getX()<<", event->getY()="<<event->getY()<<", event->getXmin()="<<event->getXmin()<<", event->getYmin()="<<event->getYmin()<<", event->getXmax()="<<event->getXmax()<<", event->getYmax()="<<event->getYmax()<<std::endl; 
    493500 
    494501    addEvent(event); 
  • OpenSceneGraph/trunk/src/osgGA/GUIEventAdapter.cpp

    r13041 r13376  
    123123    _touchData->addTouchPoint(id, phase, x, y, tapCount); 
    124124} 
     125 
     126void GUIEventAdapter::copyPointerDataFrom(const osgGA::GUIEventAdapter& sourceEvent) 
     127{ 
     128    setGraphicsContext(const_cast<osg::GraphicsContext*>(sourceEvent.getGraphicsContext())); 
     129    setX(sourceEvent.getX()); 
     130    setY(sourceEvent.getY()); 
     131    setInputRange(sourceEvent.getXmin(), sourceEvent.getYmin(), sourceEvent.getXmax(), sourceEvent.getYmax()); 
     132    setButtonMask(sourceEvent.getButtonMask()); 
     133    setMouseYOrientation(sourceEvent.getMouseYOrientation()); 
     134    setPointerDataList(sourceEvent.getPointerDataList()); 
     135} 
  • OpenSceneGraph/trunk/src/osgManipulator/Dragger.cpp

    r13082 r13376  
    369369                _pointer.reset(); 
    370370 
    371                 if (view->computeIntersections(ea.getX(),ea.getY(),intersections, _intersectionMask)) 
     371                if (view->computeIntersections(ea ,intersections, _intersectionMask)) 
    372372                { 
    373373                    for(osgUtil::LineSegmentIntersector::Intersections::iterator hitr = intersections.begin(); 
  • OpenSceneGraph/trunk/src/osgPlugins/p3d/ReaderWriterP3D.cpp

    r13331 r13376  
    14201420        keyValue = itr->second; 
    14211421    } 
    1422     if (key.find("0x",0,2)!=std::string::npos) 
     1422    else if (key.find("0x",0,2)!=std::string::npos) 
    14231423    { 
    14241424        std::istringstream iss(key); 
     
    14391439    else 
    14401440    { 
    1441         OSG_NOTICE<<"Warning: invalid key used in <key>"<<key<<"</key>, ignoring tag."<<std::endl; 
     1441        OSG_NOTICE<<"Warning: invalid key used in <key>"<<key<<"</key>, ignoring tag. key=["<<key<<"]"<<std::endl; 
    14421442        return false; 
    14431443    } 
  • OpenSceneGraph/trunk/src/osgPresentation/PickEventHandler.cpp

    r13331 r13376  
    6767            osgViewer::Viewer* viewer = dynamic_cast<osgViewer::Viewer*>(&aa); 
    6868            osgUtil::LineSegmentIntersector::Intersections intersections; 
    69             if (viewer->computeIntersections(ea.getX(),ea.getY(), nv->getNodePath(), intersections)) 
     69            if (viewer->computeIntersections(ea, nv->getNodePath(), intersections)) 
    7070            { 
    7171                for(osgUtil::LineSegmentIntersector::Intersections::iterator hitr=intersections.begin(); 
  • OpenSceneGraph/trunk/src/osgQt/GraphicsWindowQt.cpp

    r13130 r13376  
    433433    } 
    434434 
     435    // make sure the event queue has the correct window rectangle size and input range 
     436    getEventQueue()->syncWindowRectangleWithGraphcisContext(); 
     437     
    435438    return true; 
    436439} 
     
    648651    _realized = true; 
    649652 
     653    // make sure the event queue has the correct window rectangle size and input range 
     654    getEventQueue()->syncWindowRectangleWithGraphcisContext(); 
     655     
    650656    // make this window's context not current 
    651657    // note: this must be done as we will probably make the context current from another thread 
  • OpenSceneGraph/trunk/src/osgUtil/LineSegmentIntersector.cpp

    r12237 r13376  
    2121#include <osg/KdTree> 
    2222#include <osg/Timer> 
     23#include <osg/TexMat> 
    2324 
    2425using namespace osgUtil; 
     
    614615    return true; 
    615616} 
     617 
     618osg::Texture* LineSegmentIntersector::Intersection::getTextureLookUp(osg::Vec3& tc) const 
     619{ 
     620    osg::Geometry* geometry = drawable.valid() ? drawable->asGeometry() : 0; 
     621    osg::Vec3Array* vertices = geometry ? dynamic_cast<osg::Vec3Array*>(geometry->getVertexArray()) : 0; 
     622     
     623    if (vertices) 
     624    { 
     625        if (indexList.size()==3 && ratioList.size()==3) 
     626        { 
     627            unsigned int i1 = indexList[0]; 
     628            unsigned int i2 = indexList[1]; 
     629            unsigned int i3 = indexList[2]; 
     630 
     631            float r1 = ratioList[0]; 
     632            float r2 = ratioList[1]; 
     633            float r3 = ratioList[2]; 
     634 
     635            osg::Array* texcoords = (geometry->getNumTexCoordArrays()>0) ? geometry->getTexCoordArray(0) : 0; 
     636            osg::FloatArray* texcoords_FloatArray = dynamic_cast<osg::FloatArray*>(texcoords); 
     637            osg::Vec2Array* texcoords_Vec2Array = dynamic_cast<osg::Vec2Array*>(texcoords); 
     638            osg::Vec3Array* texcoords_Vec3Array = dynamic_cast<osg::Vec3Array*>(texcoords); 
     639            if (texcoords_FloatArray) 
     640            { 
     641                // we have tex coord array so now we can compute the final tex coord at the point of intersection. 
     642                float tc1 = (*texcoords_FloatArray)[i1]; 
     643                float tc2 = (*texcoords_FloatArray)[i2]; 
     644                float tc3 = (*texcoords_FloatArray)[i3]; 
     645                tc.x() = tc1*r1 + tc2*r2 + tc3*r3; 
     646            } 
     647            else if (texcoords_Vec2Array) 
     648            { 
     649                // we have tex coord array so now we can compute the final tex coord at the point of intersection. 
     650                const osg::Vec2& tc1 = (*texcoords_Vec2Array)[i1]; 
     651                const osg::Vec2& tc2 = (*texcoords_Vec2Array)[i2]; 
     652                const osg::Vec2& tc3 = (*texcoords_Vec2Array)[i3]; 
     653                tc.x() = tc1.x()*r1 + tc2.x()*r2 + tc3.x()*r3; 
     654                tc.y() = tc1.y()*r1 + tc2.y()*r2 + tc3.y()*r3; 
     655            } 
     656            else if (texcoords_Vec3Array) 
     657            { 
     658                // we have tex coord array so now we can compute the final tex coord at the point of intersection. 
     659                const osg::Vec3& tc1 = (*texcoords_Vec3Array)[i1]; 
     660                const osg::Vec3& tc2 = (*texcoords_Vec3Array)[i2]; 
     661                const osg::Vec3& tc3 = (*texcoords_Vec3Array)[i3]; 
     662                tc.x() = tc1.x()*r1 + tc2.x()*r2 + tc3.x()*r3; 
     663                tc.y() = tc1.y()*r1 + tc2.y()*r2 + tc3.y()*r3; 
     664                tc.z() = tc1.z()*r1 + tc2.z()*r2 + tc3.z()*r3; 
     665            } 
     666            else 
     667            { 
     668                return 0; 
     669            } 
     670        } 
     671 
     672        const osg::TexMat* activeTexMat = 0; 
     673        const osg::Texture* activeTexture = 0; 
     674 
     675        if (drawable->getStateSet()) 
     676        { 
     677            const osg::TexMat* texMat = dynamic_cast<osg::TexMat*>(drawable->getStateSet()->getTextureAttribute(0,osg::StateAttribute::TEXMAT)); 
     678            if (texMat) activeTexMat = texMat; 
     679 
     680            const osg::Texture* texture = dynamic_cast<osg::Texture*>(drawable->getStateSet()->getTextureAttribute(0,osg::StateAttribute::TEXTURE)); 
     681            if (texture) activeTexture = texture; 
     682        } 
     683 
     684        for(osg::NodePath::const_reverse_iterator itr = nodePath.rbegin(); 
     685            itr != nodePath.rend() && (!activeTexMat || !activeTexture); 
     686            ++itr) 
     687        { 
     688            const osg::Node* node = *itr; 
     689            if (node->getStateSet()) 
     690            { 
     691                if (!activeTexMat) 
     692                { 
     693                    const osg::TexMat* texMat = dynamic_cast<const osg::TexMat*>(node->getStateSet()->getTextureAttribute(0,osg::StateAttribute::TEXMAT)); 
     694                    if (texMat) activeTexMat = texMat; 
     695                } 
     696 
     697                if (!activeTexture) 
     698                { 
     699                    const osg::Texture* texture = dynamic_cast<const osg::Texture*>(node->getStateSet()->getTextureAttribute(0,osg::StateAttribute::TEXTURE)); 
     700                    if (texture) activeTexture = texture; 
     701                } 
     702            } 
     703        } 
     704 
     705        if (activeTexMat) 
     706        { 
     707            osg::Vec4 tc_transformed = osg::Vec4(tc.x(), tc.y(), tc.z() ,0.0f) * activeTexMat->getMatrix(); 
     708            tc.x() = tc_transformed.x(); 
     709            tc.y() = tc_transformed.y(); 
     710            tc.z() = tc_transformed.z(); 
     711 
     712            if (activeTexture && activeTexMat->getScaleByTextureRectangleSize()) 
     713            { 
     714                tc.x() *= static_cast<float>(activeTexture->getTextureWidth()); 
     715                tc.y() *= static_cast<float>(activeTexture->getTextureHeight()); 
     716                tc.z() *= static_cast<float>(activeTexture->getTextureDepth()); 
     717            } 
     718        } 
     719 
     720        return const_cast<osg::Texture*>(activeTexture); 
     721         
     722    } 
     723    return 0; 
     724} 
  • OpenSceneGraph/trunk/src/osgViewer/CompositeViewer.cpp

    r13277 r13376  
    1313 
    1414#include <osg/GLExtensions> 
     15#include <osg/TextureRectangle> 
     16#include <osg/TextureCubeMap> 
     17 
    1518#include <osgGA/TrackballManipulator> 
    1619#include <osgViewer/CompositeViewer> 
     
    641644    } 
    642645 
    643     for(RefViews::iterator vitr = _views.begin(); 
    644         vitr != _views.end(); 
    645         ++vitr) 
    646     { 
    647         View* view = vitr->get(); 
    648  
    649         osgGA::GUIEventAdapter* eventState = view->getEventQueue()->getCurrentEventState(); 
    650         if (view->getCamera()->getViewport()) 
    651         { 
    652             osg::Viewport* viewport = view->getCamera()->getViewport(); 
    653             eventState->setInputRange( viewport->x(), viewport->y(), viewport->x() + viewport->width(), viewport->y() + viewport->height()); 
    654         } 
    655         else 
    656         { 
    657             eventState->setInputRange(-1.0, -1.0, 1.0, 1.0); 
    658         } 
    659  
    660  
    661         view->getEventQueue()->frame( getFrameStamp()->getReferenceTime() ); 
    662     } 
    663  
    664646 
    665647    if (getViewerStats() && getViewerStats()->collectStats("frame_rate")) 
     
    698680} 
    699681 
    700 void CompositeViewer::eventTraversal() 
    701 { 
    702     if (_done) return; 
    703  
    704     if (_views.empty()) return; 
    705  
    706     double cutOffTime = (_runFrameScheme==ON_DEMAND) ? DBL_MAX : _frameStamp->getReferenceTime(); 
    707  
    708     double beginEventTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick()); 
    709  
    710     // OSG_NOTICE<<"CompositeViewer::frameEventTraversal()."<<std::endl; 
    711  
    712     // need to copy events from the GraphicsWindow's into local EventQueue; 
    713  
    714     typedef std::map<osgViewer::View*, osgGA::EventQueue::Events> ViewEventsMap; 
    715     ViewEventsMap viewEventsMap; 
    716  
    717     Contexts contexts; 
    718     getContexts(contexts); 
    719  
    720     // set done if there are no windows 
    721     checkWindowStatus(contexts); 
    722     if (_done) return; 
    723  
    724     Scenes scenes; 
    725     getScenes(scenes); 
    726  
    727     osgViewer::View* masterView = getViewWithFocus() ? getViewWithFocus() : _views[0].get(); 
    728  
    729     osg::Camera* masterCamera = masterView->getCamera(); 
    730     osgGA::GUIEventAdapter* eventState = masterView->getEventQueue()->getCurrentEventState(); 
    731     osg::Matrix masterCameraVPW = masterCamera->getViewMatrix() * masterCamera->getProjectionMatrix(); 
    732     if (masterCamera->getViewport()) 
    733     { 
    734         osg::Viewport* viewport = masterCamera->getViewport(); 
    735         masterCameraVPW *= viewport->computeWindowMatrix(); 
    736     } 
    737  
    738     // get events from all windows attached to Viewer. 
    739     for(Contexts::iterator citr = contexts.begin(); 
    740         citr != contexts.end(); 
    741         ++citr) 
    742     { 
    743         osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(*citr); 
    744         if (gw) 
    745         { 
    746             gw->checkEvents(); 
    747  
    748             osgGA::EventQueue::Events gw_events; 
    749             gw->getEventQueue()->takeEvents(gw_events, cutOffTime); 
    750  
    751             osgGA::EventQueue::Events::iterator itr; 
    752             for(itr = gw_events.begin(); 
    753                 itr != gw_events.end(); 
    754                 ++itr) 
    755             { 
    756                 osgGA::GUIEventAdapter* event = itr->get(); 
    757  
    758                 //OSG_NOTICE<<"event->getGraphicsContext()="<<event->getGraphicsContext()<<std::endl; 
    759  
    760                 bool pointerEvent = false; 
    761  
    762                 float x = event->getX(); 
    763                 float y = event->getY(); 
    764  
    765                 bool invert_y = event->getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS; 
    766                 if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y; 
    767  
    768                 switch(event->getEventType()) 
     682 
     683void CompositeViewer::generateSlavePointerData(osg::Camera* camera, osgGA::GUIEventAdapter& event) 
     684{ 
     685    osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(event.getGraphicsContext()); 
     686    if (!gw) return; 
     687 
     688    // What type of Camera is it? 
     689    // 1) Master Camera : do nothin extra 
     690    // 2) Slave Camera, Relative RF, Same scene graph as master : transform coords into Master Camera and add to PointerData list 
     691    // 3) Slave Camera, Relative RF, Different scene graph from master : do nothing extra? 
     692    // 4) Slave Camera, Absolute RF, Same scene graph as master : do nothing extra? 
     693    // 5) Slave Camera, Absolute RF, Different scene graph : do nothing extra? 
     694    // 6) Slave Camera, Absolute RF, Different scene graph but a distortion correction subgraph depending upon RTT Camera (slave or master) 
     695    //                              : project ray into RTT Camera's clip space, and RTT Camera's is Relative RF and sharing same scene graph as master then transform coords. 
     696 
     697    // if camera isn't the master it must be a slave and could need reprojecting. 
     698     
     699     
     700    osgViewer::View* view = dynamic_cast<osgViewer::View*>(camera->getView()); 
     701    if (!view) return; 
     702     
     703    osg::Camera* view_masterCamera = view->getCamera(); 
     704    if (camera!=view_masterCamera) 
     705    { 
     706        float x = event.getX(); 
     707        float y = event.getY(); 
     708 
     709        bool invert_y = event.getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS; 
     710        if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y; 
     711 
     712        osg::Matrix masterCameraVPW = view_masterCamera->getViewMatrix() * view_masterCamera->getProjectionMatrix(); 
     713        if (view_masterCamera->getViewport()) 
     714        { 
     715            osg::Viewport* viewport = view_masterCamera->getViewport(); 
     716            masterCameraVPW *= viewport->computeWindowMatrix(); 
     717        } 
     718 
     719        // slave Camera tahnks to sharing the same View 
     720        osg::View::Slave* slave = view ? view->findSlaveForCamera(camera) : 0; 
     721        if (slave) 
     722        { 
     723            if (camera->getReferenceFrame()==osg::Camera::RELATIVE_RF && slave->_useMastersSceneData) 
     724            { 
     725                osg::Viewport* viewport = camera->getViewport(); 
     726                osg::Matrix localCameraVPW = camera->getViewMatrix() * camera->getProjectionMatrix(); 
     727                if (viewport) localCameraVPW *= viewport->computeWindowMatrix(); 
     728 
     729                osg::Matrix matrix( osg::Matrix::inverse(localCameraVPW) * masterCameraVPW ); 
     730                osg::Vec3d new_coord = osg::Vec3d(x,y,0.0) * matrix; 
     731                //OSG_NOTICE<<"    pointer event new_coord.x()="<<new_coord.x()<<" new_coord.y()="<<new_coord.y()<<std::endl; 
     732                event.addPointerData(new osgGA::PointerData(view_masterCamera, new_coord.x(), -1.0, 1.0, 
     733                                                                               new_coord.y(), -1.0, 1.0)); 
     734            } 
     735            else if (!slave->_useMastersSceneData) 
     736            { 
     737                // Are their any RTT Camera's that this Camera depends upon for textures? 
     738 
     739                osg::ref_ptr<osgUtil::LineSegmentIntersector> ray = new osgUtil::LineSegmentIntersector(osgUtil::Intersector::WINDOW, x,y); 
     740                osgUtil::IntersectionVisitor iv(ray.get()); 
     741                camera->accept(iv); 
     742                if (ray->containsIntersections()) 
    769743                { 
    770                     case(osgGA::GUIEventAdapter::RESIZE): 
    771                         setCameraWithFocus(0); 
    772                         break; 
    773                     case(osgGA::GUIEventAdapter::PUSH): 
    774                     case(osgGA::GUIEventAdapter::RELEASE): 
    775                     case(osgGA::GUIEventAdapter::DOUBLECLICK): 
    776                     case(osgGA::GUIEventAdapter::DRAG): 
    777                     case(osgGA::GUIEventAdapter::MOVE): 
     744                    osg::Vec3 tc; 
     745                    osg::Texture* texture = ray->getFirstIntersection().getTextureLookUp(tc); 
     746                    if (texture) 
    778747                    { 
    779                         pointerEvent = true; 
    780  
    781                         if (event->getEventType()!=osgGA::GUIEventAdapter::DRAG || !getCameraWithFocus()) 
     748                        // look up Texture in RTT Camera's. 
     749                        for(unsigned int i=0; i<view->getNumSlaves();++i) 
    782750                        { 
    783                             osg::GraphicsContext::Cameras& cameras = gw->getCameras(); 
    784                             for(osg::GraphicsContext::Cameras::iterator citr = cameras.begin(); 
    785                                 citr != cameras.end(); 
    786                                 ++citr) 
     751                            osg::Camera* slave_camera = view->getSlave(i)._camera; 
     752                            if (slave_camera) 
    787753                            { 
    788                                 osg::Camera* camera = *citr; 
    789                                 if ((camera->getNodeMask()!=0) && 
    790                                     camera->getView() && 
    791                                     camera->getAllowEventFocus() && 
    792                                     camera->getRenderTargetImplementation()==osg::Camera::FRAME_BUFFER) 
     754                                osg::Camera::BufferAttachmentMap::const_iterator ba_itr = slave_camera->getBufferAttachmentMap().find(osg::Camera::COLOR_BUFFER); 
     755                                if (ba_itr != slave_camera->getBufferAttachmentMap().end()) 
    793756                                { 
    794                                     osg::Viewport* viewport = camera ? camera->getViewport() : 0; 
    795                                     if (viewport && 
    796                                         x >= viewport->x() && y >= viewport->y() && 
    797                                         x <= (viewport->x()+viewport->width()) && y <= (viewport->y()+viewport->height()) ) 
     757                                    if (ba_itr->second._texture == texture) 
    798758                                    { 
    799                                         setCameraWithFocus(camera); 
    800  
    801                                         // If this camera is not a slave camera 
    802                                         if (camera->getView()->getCamera() == camera) 
     759                                        osg::TextureRectangle* tr = dynamic_cast<osg::TextureRectangle*>(ba_itr->second._texture.get()); 
     760                                        osg::TextureCubeMap* tcm = dynamic_cast<osg::TextureCubeMap*>(ba_itr->second._texture.get()); 
     761                                        if (tr) 
    803762                                        { 
    804                                             eventState->setGraphicsContext(gw); 
    805                                             eventState->setInputRange( viewport->x(), viewport->y(), 
    806                                                                     viewport->x()+viewport->width(), 
    807                                                                     viewport->y()+viewport->height()); 
    808  
     763                                            event.addPointerData(new osgGA::PointerData(slave_camera, tc.x(), 0.0f, static_cast<float>(tr->getTextureWidth()), 
     764                                                                                                           tc.y(), 0.0f, static_cast<float>(tr->getTextureHeight()))); 
     765                                        } 
     766                                        else if (tcm) 
     767                                        { 
     768                                            OSG_NOTICE<<"  Slave has matched texture cubemap"<<ba_itr->second._texture.get()<<", "<<ba_itr->second._face<<std::endl; 
    809769                                        } 
    810770                                        else 
    811771                                        { 
    812                                             eventState->setInputRange(-1.0, -1.0, 1.0, 1.0); 
    813                                         } 
    814  
    815                                         if (getViewWithFocus()!=masterView) 
    816                                         { 
    817                                             // need to reset the masterView 
    818                                             masterView = getViewWithFocus(); 
    819                                             masterCamera = masterView->getCamera(); 
    820                                             eventState = masterView->getEventQueue()->getCurrentEventState(); 
    821                                             masterCameraVPW = masterCamera->getViewMatrix() * masterCamera->getProjectionMatrix(); 
    822  
    823                                             if (masterCamera->getViewport()) 
    824                                             { 
    825                                                 osg::Viewport* viewport = masterCamera->getViewport(); 
    826                                                 masterCameraVPW *= viewport->computeWindowMatrix(); 
    827                                             } 
    828                                         } 
    829  
    830                                         // If this camera is not a slave camera 
    831                                         if (camera->getView()->getCamera() == camera) 
    832                                         { 
    833                                             eventState->setGraphicsContext(gw); 
    834                                             eventState->setInputRange( viewport->x(), viewport->y(), 
    835                                                                     viewport->x()+viewport->width(), 
    836                                                                     viewport->y()+viewport->height()); 
    837  
    838                                         } 
    839                                         else 
    840                                         { 
    841                                             eventState->setInputRange(-1.0, -1.0, 1.0, 1.0); 
     772                                            event.addPointerData(new osgGA::PointerData(slave_camera, tc.x(), 0.0f, 1.0f, 
     773                                                                                                           tc.y(), 0.0f, 1.0f)); 
    842774                                        } 
    843775                                    } 
     
    845777                            } 
    846778                        } 
    847  
    848                         break; 
    849779                    } 
    850                     default: 
    851                         break; 
    852780                } 
    853  
    854                 if (pointerEvent) 
     781            } 
     782        } 
     783    } 
     784} 
     785     
     786     
     787void CompositeViewer::generatePointerData(osgGA::GUIEventAdapter& event) 
     788{ 
     789    osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(event.getGraphicsContext()); 
     790    if (!gw) return; 
     791 
     792    float x = event.getX(); 
     793    float y = event.getY(); 
     794 
     795    bool invert_y = event.getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS; 
     796    if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y; 
     797     
     798    event.addPointerData(new osgGA::PointerData(gw, x, 0, gw->getTraits()->width, 
     799                                                    y, 0, gw->getTraits()->height)); 
     800 
     801    osg::GraphicsContext::Cameras& cameras = gw->getCameras(); 
     802    for(osg::GraphicsContext::Cameras::iterator citr = cameras.begin(); 
     803        citr != cameras.end(); 
     804        ++citr) 
     805    { 
     806        osg::Camera* camera = *citr; 
     807        if (camera->getAllowEventFocus() && 
     808            camera->getRenderTargetImplementation()==osg::Camera::FRAME_BUFFER) 
     809        { 
     810            osg::Viewport* viewport = camera ? camera->getViewport() : 0; 
     811            if (viewport && 
     812                x >= viewport->x() && y >= viewport->y() && 
     813                x <= (viewport->x()+viewport->width()) && y <= (viewport->y()+viewport->height()) ) 
     814            { 
     815                event.addPointerData(new osgGA::PointerData(camera, (x-viewport->x())/viewport->width()*2.0f-1.0f, -1.0, 1.0, 
     816                                                                    (y-viewport->y())/viewport->height()*2.0f-1.0f, -1.0, 1.0)); 
     817 
     818                osgViewer::View* view = dynamic_cast<osgViewer::View*>(camera->getView()); 
     819                osg::Camera* view_masterCamera = view ? view->getCamera() : 0; 
     820 
     821                // if camera isn't the master it must be a slave and could need reprojecting. 
     822                if (view && camera!=view_masterCamera) 
    855823                { 
    856                     if (getCameraWithFocus()) 
    857                     { 
    858                         osg::Viewport* viewport = getCameraWithFocus()->getViewport(); 
    859                         osg::Matrix localCameraVPW = getCameraWithFocus()->getViewMatrix() * getCameraWithFocus()->getProjectionMatrix(); 
    860                         if (viewport) localCameraVPW *= viewport->computeWindowMatrix(); 
    861  
    862                         osg::Matrix matrix( osg::Matrix::inverse(localCameraVPW) * masterCameraVPW ); 
    863  
    864                         osg::Vec3d new_coord = osg::Vec3d(x,y,0.0) * matrix; 
    865  
    866                         x = new_coord.x(); 
    867                         y = new_coord.y(); 
    868  
    869                         event->setInputRange(eventState->getXmin(), eventState->getYmin(), eventState->getXmax(), eventState->getYmax()); 
    870                         event->setX(x); 
    871                         event->setY(y); 
    872                         event->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS); 
    873  
    874                     } 
    875                     // pass along the new pointer events details to the eventState of the viewer 
    876                     eventState->setX(x); 
    877                     eventState->setY(y); 
    878                     eventState->setButtonMask(event->getButtonMask()); 
    879                     eventState->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS); 
    880  
     824                    generateSlavePointerData(camera, event); 
     825                } 
     826            } 
     827        } 
     828    } 
     829} 
     830 
     831void CompositeViewer::reprojectPointerData(osgGA::GUIEventAdapter& source_event, osgGA::GUIEventAdapter& dest_event) 
     832{ 
     833    osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(dest_event.getGraphicsContext()); 
     834    if (!gw) return; 
     835 
     836    float x = dest_event.getX(); 
     837    float y = dest_event.getY(); 
     838 
     839    bool invert_y = dest_event.getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS; 
     840    if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y; 
     841 
     842    dest_event.addPointerData(new osgGA::PointerData(gw, x, 0, gw->getTraits()->width, 
     843                                                         y, 0, gw->getTraits()->height)); 
     844 
     845    osg::Camera* camera = (source_event.getNumPointerData()>=2) ? dynamic_cast<osg::Camera*>(source_event.getPointerData(1)->object.get()) : 0; 
     846    osg::Viewport* viewport = camera ? camera->getViewport() : 0; 
     847 
     848    if (!viewport) return; 
     849     
     850    dest_event.addPointerData(new osgGA::PointerData(camera, (x-viewport->x())/viewport->width()*2.0f-1.0f, -1.0, 1.0, 
     851                                                             (y-viewport->y())/viewport->height()*2.0f-1.0f, -1.0, 1.0)); 
     852 
     853    osgViewer::View* view = dynamic_cast<osgViewer::View*>(camera->getView()); 
     854    osg::Camera* view_masterCamera = view ? view->getCamera() : 0; 
     855 
     856    // if camera isn't the master it must be a slave and could need reprojecting. 
     857    if (view && camera!=view_masterCamera) 
     858    { 
     859        generateSlavePointerData(camera, dest_event); 
     860    } 
     861} 
     862 
     863struct SortEvents 
     864{ 
     865    bool operator() (const osg::ref_ptr<osgGA::GUIEventAdapter>& lhs,const osg::ref_ptr<osgGA::GUIEventAdapter>& rhs) const 
     866    { 
     867        return lhs->getTime() < rhs->getTime(); 
     868    } 
     869}; 
     870 
     871void CompositeViewer::eventTraversal() 
     872{ 
     873    if (_done) return; 
     874 
     875    if (_views.empty()) return; 
     876 
     877    double cutOffTime = (_runFrameScheme==ON_DEMAND) ? DBL_MAX : _frameStamp->getReferenceTime(); 
     878 
     879    double beginEventTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick()); 
     880 
     881    // need to copy events from the GraphicsWindow's into local EventQueue for each view; 
     882    typedef std::map<osgViewer::View*, osgGA::EventQueue::Events> ViewEventsMap; 
     883    ViewEventsMap viewEventsMap; 
     884 
     885    Contexts contexts; 
     886    getContexts(contexts); 
     887 
     888    // set done if there are no windows 
     889    checkWindowStatus(contexts); 
     890    if (_done) return; 
     891     
     892    osgGA::EventQueue::Events all_events; 
     893     
     894    for(Contexts::iterator citr = contexts.begin(); 
     895        citr != contexts.end(); 
     896        ++citr) 
     897    { 
     898        osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(*citr); 
     899        if (gw) 
     900        { 
     901            gw->checkEvents(); 
     902 
     903            osgGA::EventQueue::Events gw_events; 
     904            gw->getEventQueue()->takeEvents(gw_events, cutOffTime); 
     905 
     906            for(osgGA::EventQueue::Events::iterator itr = gw_events.begin(); 
     907                itr != gw_events.end(); 
     908                ++itr) 
     909            { 
     910                (*itr)->setGraphicsContext(gw); 
     911            } 
     912 
     913            all_events.insert(all_events.end(), gw_events.begin(), gw_events.end()); 
     914        } 
     915    } 
     916 
     917    // sort all the events in time order so we can make sure we pass them all on in the correct order. 
     918    all_events.sort(SortEvents()); 
     919     
     920    // pass on pointer data onto non mouse events to keep the position data usable by all recipients of all events. 
     921    for(osgGA::EventQueue::Events::iterator itr = all_events.begin(); 
     922        itr != all_events.end(); 
     923        ++itr) 
     924    { 
     925        osgGA::GUIEventAdapter* event = itr->get(); 
     926 
     927        switch(event->getEventType()) 
     928        { 
     929            case(osgGA::GUIEventAdapter::PUSH): 
     930            case(osgGA::GUIEventAdapter::RELEASE): 
     931            case(osgGA::GUIEventAdapter::DOUBLECLICK): 
     932            case(osgGA::GUIEventAdapter::MOVE): 
     933            case(osgGA::GUIEventAdapter::DRAG): 
     934            { 
     935                if ((event->getEventType()!=osgGA::GUIEventAdapter::DRAG && event->getEventType()!=osgGA::GUIEventAdapter::RELEASE) || 
     936                    !_previousEvent || 
     937                    _previousEvent->getGraphicsContext()!=event->getGraphicsContext() || 
     938                    _previousEvent->getNumPointerData()<2) 
     939                { 
     940                    generatePointerData(*event); 
    881941                } 
    882942                else 
    883943                { 
    884                     event->setInputRange(eventState->getXmin(), eventState->getYmin(), eventState->getXmax(), eventState->getYmax()); 
    885                     event->setX(eventState->getX()); 
    886                     event->setY(eventState->getY()); 
    887                     event->setButtonMask(eventState->getButtonMask()); 
    888                     event->setMouseYOrientation(eventState->getMouseYOrientation()); 
     944                    reprojectPointerData(*_previousEvent, *event); 
    889945                } 
    890             } 
    891  
    892             for(itr = gw_events.begin(); 
    893                 itr != gw_events.end(); 
    894                 ++itr) 
    895             { 
    896                 osgGA::GUIEventAdapter* event = itr->get(); 
    897                 switch(event->getEventType()) 
     946 
     947#if 0                 
     948                // assign topmost PointeData settings as the events X,Y and InputRange 
     949                osgGA::PointerData* pd = event->getPointerData(event->getNumPointerData()-1); 
     950                event->setX(pd->x); 
     951                event->setY(pd->y); 
     952                event->setInputRange(pd->xMin, pd->yMin, pd->xMax, pd->yMax); 
     953                event->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS); 
     954#else                 
     955                if (event->getMouseYOrientation()!=osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS) 
    898956                { 
    899                     case(osgGA::GUIEventAdapter::CLOSE_WINDOW): 
    900                     { 
    901                         bool wasThreading = areThreadsRunning(); 
    902                         if (wasThreading) stopThreading(); 
    903  
    904                         gw->close(); 
    905  
    906                         if (wasThreading) startThreading(); 
    907  
    908                         break; 
    909                     } 
    910                     default: 
    911                         break; 
     957                    event->setY((event->getYmax()-event->getY())+event->getYmin()); 
     958                    event->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS); 
    912959                } 
    913             } 
    914  
    915             viewEventsMap[masterView].insert( viewEventsMap[masterView].end(), gw_events.begin(), gw_events.end() ); 
    916  
    917         } 
    918     } 
    919  
    920  
    921     // OSG_NOTICE<<"mouseEventState Xmin = "<<eventState->getXmin()<<" Ymin="<<eventState->getYmin()<<" xMax="<<eventState->getXmax()<<" Ymax="<<eventState->getYmax()<<std::endl; 
    922  
     960#endif                 
     961 
     962                _previousEvent = event; 
     963                 
     964                break; 
     965            } 
     966            default: 
     967                if (_previousEvent.valid()) event->copyPointerDataFrom(*_previousEvent); 
     968                break; 
     969        } 
     970 
     971        osgGA::PointerData* pd = event->getNumPointerData()>0 ? event->getPointerData(event->getNumPointerData()-1) : 0; 
     972        osg::Camera* camera = pd ? dynamic_cast<osg::Camera*>(pd->object.get()) : 0; 
     973        osgViewer::View* view = camera ? dynamic_cast<osgViewer::View*>(camera->getView()) : 0; 
     974         
     975        if (!view)  
     976        { 
     977            if (_viewWithFocus.valid())  
     978            { 
     979                // OSG_NOTICE<<"Falling back to using _viewWithFocus"<<std::endl; 
     980                view = _viewWithFocus.get(); 
     981            } 
     982            else if (!_views.empty())  
     983            { 
     984                // OSG_NOTICE<<"Falling back to using first view as one with focus"<<std::endl; 
     985                view = _views[0].get(); 
     986            } 
     987        } 
     988         
     989        // reassign view with focus 
     990        if (_viewWithFocus != view)  _viewWithFocus = view; 
     991 
     992        if (view)  
     993        { 
     994            viewEventsMap[view].push_back( event ); 
     995             
     996            osgGA::GUIEventAdapter* eventState = view->getEventQueue()->getCurrentEventState(); 
     997            eventState->copyPointerDataFrom(*event); 
     998        } 
     999 
     1000        _previousEvent = event; 
     1001    } 
     1002 
     1003    // handle any close windows 
     1004    for(osgGA::EventQueue::Events::iterator itr = all_events.begin(); 
     1005        itr != all_events.end(); 
     1006        ++itr) 
     1007    { 
     1008        osgGA::GUIEventAdapter* event = itr->get(); 
     1009        switch(event->getEventType()) 
     1010        { 
     1011            case(osgGA::GUIEventAdapter::CLOSE_WINDOW): 
     1012            { 
     1013                bool wasThreading = areThreadsRunning(); 
     1014                if (wasThreading) stopThreading(); 
     1015 
     1016                if (event->getGraphicsContext()) 
     1017                { 
     1018                    event->getGraphicsContext()->close(); 
     1019                } 
     1020 
     1021                if (wasThreading) startThreading(); 
     1022 
     1023                break; 
     1024            } 
     1025            default: 
     1026                break; 
     1027        } 
     1028    } 
     1029         
    9231030 
    9241031    for(RefViews::iterator vitr = _views.begin(); 
     
    9421049        } 
    9431050 
     1051        // generate frame event 
     1052        view->getEventQueue()->frame( getFrameStamp()->getReferenceTime() ); 
     1053 
    9441054        view->getEventQueue()->takeEvents(viewEventsMap[view], cutOffTime); 
    9451055    } 
    946  
    947  
    948     // OSG_NOTICE<<"Events "<<events.size()<<std::endl; 
    9491056 
    9501057    if ((_keyEventSetsDone!=0) || _quitEventSetsDone) 
     
    9881095        { 
    9891096            View* view = veitr->first; 
    990             _eventVisitor->setActionAdapter(view); 
    991  
    992             if (view->getSceneData()) 
    993             { 
     1097 
     1098            if (view && view->getSceneData()) 
     1099            { 
     1100                _eventVisitor->setActionAdapter(view); 
     1101 
    9941102                for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin(); 
    9951103                    itr != veitr->second.end(); 
     
    10791187    } 
    10801188 
    1081  
    1082  
    10831189    if (getViewerStats() && getViewerStats()->collectStats("event")) 
    10841190    { 
     
    10911197    } 
    10921198} 
    1093  
    10941199 
    10951200void CompositeViewer::updateTraversal() 
  • OpenSceneGraph/trunk/src/osgViewer/GraphicsWindowCarbon.cpp

    r13130 r13376  
    252252    _valid = (_pixelFormat != NULL); 
    253253    _initialized = true; 
     254     
     255    // make sure the event queue has the correct window rectangle size and input range 
     256    getEventQueue()->syncWindowRectangleWithGraphcisContext(); 
    254257} 
    255258 
     
    453456 
    454457    _realized = true; 
     458 
     459    // make sure the event queue has the correct window rectangle size and input range 
     460    getEventQueue()->syncWindowRectangleWithGraphcisContext(); 
     461     
    455462    return _realized; 
    456463} 
  • OpenSceneGraph/trunk/src/osgViewer/GraphicsWindowCocoa.mm

    r13130 r13376  
    10751075    _updateContext = false; 
    10761076    _valid = _initialized = true; 
     1077     
     1078    // make sure the event queue has the correct window rectangle size and input range 
     1079    getEventQueue()->syncWindowRectangleWithGraphcisContext(); 
    10771080} 
    10781081 
     
    12411244    // Cocoa's origin is bottom/left: 
    12421245    getEventQueue()->getCurrentEventState()->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS); 
     1246 
     1247    // make sure the event queue has the correct window rectangle size and input range 
     1248    getEventQueue()->syncWindowRectangleWithGraphcisContext(); 
    12431249 
    12441250    _valid = _initialized = _realized = true; 
  • OpenSceneGraph/trunk/src/osgViewer/GraphicsWindowIOS.mm

    r13277 r13376  
    728728    _viewContentScaleFactor = -1.0f; 
    729729    _valid = _initialized = true; 
     730 
     731    // make sure the event queue has the correct window rectangle size and input range 
     732    getEventQueue()->syncWindowRectangleWithGraphcisContext(); 
    730733} 
    731734 
     
    890893    // IOSs origin is top/left: 
    891894    getEventQueue()->getCurrentEventState()->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS); 
     895 
     896    // make sure the event queue has the correct window rectangle size and input range 
     897    getEventQueue()->syncWindowRectangleWithGraphcisContext(); 
    892898     
    893899    _valid = _initialized = _realized = true; 
  • OpenSceneGraph/trunk/src/osgViewer/GraphicsWindowWin32.cpp

    r13195 r13376  
    11851185    _initialized = _ownsWindow ? createWindow() : setWindow(windowHandle); 
    11861186    _valid       = _initialized; 
     1187     
     1188    // make sure the event queue has the correct window rectangle size and input range 
     1189    getEventQueue()->syncWindowRectangleWithGraphcisContext(); 
    11871190 
    11881191    // 2008/10/03 
     
    19861989 
    19871990    _realized = true; 
     1991 
     1992    // make sure the event queue has the correct window rectangle size and input range 
     1993    getEventQueue()->syncWindowRectangleWithGraphcisContext(); 
    19881994 
    19891995    return true; 
  • OpenSceneGraph/trunk/src/osgViewer/GraphicsWindowX11.cpp

    r13326 r13376  
    842842    } 
    843843 
    844  
    845  
     844    getEventQueue()->syncWindowRectangleWithGraphcisContext(); 
    846845} 
    847846 
     
    996995    XSync( _eventDisplay, 0 ); 
    997996    rescanModifierMapping(); 
    998  
     997     
    999998    return true; 
    1000999} 
     
    10571056    XMapWindow( _display, _window ); 
    10581057 
    1059 //    Window temp = _window; 
     1058    getEventQueue()->syncWindowRectangleWithGraphcisContext(); 
     1059 
     1060    //    Window temp = _window; 
    10601061//    XSetWMColormapWindows( _display, _window, &temp, 1); 
    10611062 
  • OpenSceneGraph/trunk/src/osgViewer/View.cpp

    r13202 r13376  
    10631063        camera->setReadBuffer(buffer); 
    10641064        camera->setReferenceFrame(osg::Camera::ABSOLUTE_RF); 
    1065         camera->setAllowEventFocus(false); 
     1065        camera->setAllowEventFocus(true); 
    10661066        camera->setInheritanceMask(camera->getInheritanceMask() & ~osg::CullSettings::CLEAR_COLOR & ~osg::CullSettings::COMPUTE_NEAR_FAR_MODE); 
    10671067        //camera->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR); 
     
    19571957{ 
    19581958    OSG_INFO<<"View::requestWarpPointer("<<x<<","<<y<<")"<<std::endl; 
    1959  
     1959     
    19601960    float local_x, local_y; 
    19611961    const osg::Camera* camera = getCameraContainingPosition(x, y, local_x, local_y); 
     
    19921992} 
    19931993 
     1994 
    19941995const osg::Camera* View::getCameraContainingPosition(float x, float y, float& local_x, float& local_y) const 
    19951996{ 
    19961997    const osgGA::GUIEventAdapter* eventState = getEventQueue()->getCurrentEventState(); 
    19971998    const osgViewer::GraphicsWindow* gw = dynamic_cast<const osgViewer::GraphicsWindow*>(eventState->getGraphicsContext()); 
    1998  
    19991999    bool view_invert_y = eventState->getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS; 
     2000     
     2001    // OSG_NOTICE<<"getCameraContainingPosition("<<x<<", "<<y<<") view_invert_y = "<<view_invert_y<<", Xmin() = "<<eventState->getXmin()<<", Xmax() = "<<eventState->getXmax()<<", Ymin() = "<<eventState->getYmin()<<", Ymax() = "<<eventState->getYmax()<<std::endl; 
    20002002 
    20012003    double epsilon = 0.5; 
    2002  
    2003     if (_camera->getGraphicsContext() && 
    2004         (!gw || _camera->getGraphicsContext()==gw) && 
    2005         _camera->getViewport()) 
    2006     { 
     2004     
     2005        
     2006    // if master camera has graphics context and eventState context matches then assume coordinates refer 
     2007    // to master camera 
     2008    bool masterActive = (_camera->getGraphicsContext()!=0 && _camera->getViewport()); 
     2009    bool eventStateMatchesMaster = (gw!=0) ? _camera->getGraphicsContext()==gw : false;  
     2010     
     2011    if (masterActive && eventStateMatchesMaster) 
     2012    { 
     2013        // OSG_NOTICE<<"Event state matches master"<<std::endl; 
    20072014        const osg::Viewport* viewport = _camera->getViewport(); 
    2008  
    2009         double new_x = x; 
    2010         double new_y = y; 
    2011  
    2012         if (!gw) 
    2013         { 
    2014             new_x = static_cast<double>(_camera->getGraphicsContext()->getTraits()->width) * (x - eventState->getXmin())/(eventState->getXmax()-eventState->getXmin()); 
    2015             new_y = view_invert_y ? 
    2016                        static_cast<double>(_camera->getGraphicsContext()->getTraits()->height) * (1.0 - (y- eventState->getYmin())/(eventState->getYmax()-eventState->getYmin())) : 
    2017                        static_cast<double>(_camera->getGraphicsContext()->getTraits()->height) * (y - eventState->getYmin())/(eventState->getYmax()-eventState->getYmin()); 
    2018         } 
    2019  
    2020         if (viewport && 
    2021             new_x >= (viewport->x()-epsilon) && new_y >= (viewport->y()-epsilon) && 
     2015         
     2016        // rescale mouse x,y first to 0 to 1 range 
     2017        double new_x = (x-eventState->getXmin())/(eventState->getXmax()-eventState->getXmin()); 
     2018        double new_y = (y-eventState->getYmin())/(eventState->getYmax()-eventState->getYmin()); 
     2019         
     2020        // flip y if required 
     2021        if (view_invert_y) new_y = 1.0f-new_y; 
     2022         
     2023        // rescale mouse x, y to window dimensions so we can check against master Camera's viewport 
     2024        new_x *= static_cast<double>(_camera->getGraphicsContext()->getTraits()->width); 
     2025        new_y *= static_cast<double>(_camera->getGraphicsContext()->getTraits()->height); 
     2026         
     2027        if (new_x >= (viewport->x()-epsilon) && new_y >= (viewport->y()-epsilon) && 
    20222028            new_x < (viewport->x()+viewport->width()-1.0+epsilon) && new_y <= (viewport->y()+viewport->height()-1.0+epsilon) ) 
    20232029        { 
     
    20252031            local_y = new_y; 
    20262032 
    2027             OSG_INFO<<"Returning master camera"<<std::endl; 
     2033            //OSG_NOTICE<<"Returning master camera"<<std::endl; 
    20282034 
    20292035            return _camera.get(); 
    20302036        } 
    2031     } 
    2032  
     2037        else 
     2038        { 
     2039            // OSG_NOTICE<<"master camera viewport not matched."<<std::endl; 
     2040        } 
     2041    } 
     2042     
    20332043    osg::Matrix masterCameraVPW = getCamera()->getViewMatrix() * getCamera()->getProjectionMatrix(); 
    20342044 
     
    20892099bool View::computeIntersections(float x,float y, osgUtil::LineSegmentIntersector::Intersections& intersections, osg::Node::NodeMask traversalMask) 
    20902100{ 
    2091     if (!_camera.valid()) return false; 
    2092  
    2093     float local_x, local_y = 0.0; 
     2101    float local_x, local_y; 
    20942102    const osg::Camera* camera = getCameraContainingPosition(x, y, local_x, local_y); 
    2095     if (!camera) camera = _camera.get(); 
    2096  
    2097  
    2098     osgUtil::LineSegmentIntersector::CoordinateFrame cf = camera->getViewport() ? osgUtil::Intersector::WINDOW : osgUtil::Intersector::PROJECTION; 
    2099     osg::ref_ptr< osgUtil::LineSegmentIntersector > picker = new osgUtil::LineSegmentIntersector(cf, local_x, local_y); 
    2100  
    2101 #if 0 
    2102     OSG_NOTICE<<"View::computeIntersections(x="<<x<<", y="<<y<<", local_x="<<local_x<<", local_y="<<local_y<<") "<<cf<<std::endl; 
    2103     OSG_NOTICE<<"  viewport ("<<camera->getViewport()->x()<<","<<camera->getViewport()->y()<<","<<camera->getViewport()->width()<<","<<camera->getViewport()->height()<<")"<<std::endl; 
    2104  
    2105     const osg::GraphicsContext::Traits* traits = camera->getGraphicsContext() ? camera->getGraphicsContext()->getTraits() : 0; 
    2106     if (traits) 
    2107     { 
    2108         OSG_NOTICE<<"  window ("<<traits->x<<","<<traits->y<<","<<traits->width<<","<<traits->height<<")"<<std::endl; 
     2103     
     2104    OSG_NOTICE<<"computeIntersections("<<x<<", "<<y<<") local_x="<<local_x<<", local_y="<<local_y<<std::endl; 
     2105     
     2106    if (camera) return computeIntersections(camera, (camera->getViewport()==0)?osgUtil::Intersector::PROJECTION : osgUtil::Intersector::WINDOW, local_x, local_y, intersections, traversalMask); 
     2107    else return false; 
     2108} 
     2109 
     2110bool View::computeIntersections(float x,float y, const osg::NodePath& nodePath, osgUtil::LineSegmentIntersector::Intersections& intersections, osg::Node::NodeMask traversalMask) 
     2111{ 
     2112    float local_x, local_y; 
     2113    const osg::Camera* camera = getCameraContainingPosition(x, y, local_x, local_y); 
     2114     
     2115    OSG_NOTICE<<"computeIntersections("<<x<<", "<<y<<") local_x="<<local_x<<", local_y="<<local_y<<std::endl; 
     2116 
     2117    if (camera) return computeIntersections(camera, (camera->getViewport()==0)?osgUtil::Intersector::PROJECTION : osgUtil::Intersector::WINDOW, local_x, local_y, nodePath, intersections, traversalMask); 
     2118    else return false; 
     2119} 
     2120 
     2121bool View::computeIntersections(const osgGA::GUIEventAdapter& ea, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask) 
     2122{ 
     2123#if 1 
     2124    if (ea.getNumPointerData()>=1) 
     2125    { 
     2126        const osgGA::PointerData* pd = ea.getPointerData(ea.getNumPointerData()-1); 
     2127        const osg::Camera* camera = dynamic_cast<const osg::Camera*>(pd->object.get()); 
     2128        if (camera)  
     2129        { 
     2130            return computeIntersections(camera, osgUtil::Intersector::PROJECTION, pd->getXnormalized(), pd->getYnormalized(), intersections, traversalMask); 
     2131        } 
    21092132    } 
    21102133#endif 
    2111  
     2134    return computeIntersections(ea.getX(), ea.getY(), intersections, traversalMask); 
     2135} 
     2136 
     2137bool View::computeIntersections(const osgGA::GUIEventAdapter& ea, const osg::NodePath& nodePath, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask) 
     2138{ 
     2139#if 1 
     2140    if (ea.getNumPointerData()>=1) 
     2141    { 
     2142        const osgGA::PointerData* pd = ea.getPointerData(ea.getNumPointerData()-1); 
     2143        const osg::Camera* camera = dynamic_cast<const osg::Camera*>(pd->object.get()); 
     2144        if (camera)  
     2145        { 
     2146            return computeIntersections(camera, osgUtil::Intersector::PROJECTION, pd->getXnormalized(), pd->getYnormalized(), nodePath, intersections, traversalMask); 
     2147        } 
     2148    } 
     2149#endif 
     2150    return computeIntersections(ea.getX(), ea.getY(), nodePath, intersections, traversalMask); 
     2151} 
     2152 
     2153bool View::computeIntersections(const osg::Camera* camera, osgUtil::Intersector::CoordinateFrame cf, float x,float y, osgUtil::LineSegmentIntersector::Intersections& intersections, osg::Node::NodeMask traversalMask) 
     2154{ 
     2155    if (!camera) return false; 
     2156 
     2157    osg::ref_ptr< osgUtil::LineSegmentIntersector > picker = new osgUtil::LineSegmentIntersector(cf, x, y); 
    21122158    osgUtil::IntersectionVisitor iv(picker.get()); 
    21132159    iv.setTraversalMask(traversalMask); 
    21142160 
    2115  
    2116 #if 1 
    21172161    const_cast<osg::Camera*>(camera)->accept(iv); 
    2118 #else 
    2119  
    2120     // timing test code paths for comparing KdTree based intersections vs conventional intersections 
    2121  
    2122     iv.setUseKdTreeWhenAvailable(true); 
    2123     iv.setDoDummyTraversal(true); 
    2124  
    2125     const_cast<osg::Camera*>(camera)->accept(iv); 
    2126  
    2127  
    2128     osg::Timer_t before = osg::Timer::instance()->tick(); 
    2129     const_cast<osg::Camera*>(camera)->accept(iv); 
    2130  
    2131     osg::Timer_t after_dummy = osg::Timer::instance()->tick(); 
    2132  
    2133     int intersectsBeforeKdTree = picker->getIntersections().size(); 
    2134  
    2135     iv.setDoDummyTraversal(false); 
    2136     const_cast<osg::Camera*>(camera)->accept(iv); 
    2137     osg::Timer_t after_kdTree_2 = osg::Timer::instance()->tick(); 
    2138  
    2139     int intersectsBeforeConventional = picker->getIntersections().size(); 
    2140  
    2141     iv.setUseKdTreeWhenAvailable(false); 
    2142     const_cast<osg::Camera*>(camera)->accept(iv); 
    2143     osg::Timer_t after = osg::Timer::instance()->tick(); 
    2144  
    2145     int intersectsAfterConventional = picker->getIntersections().size(); 
    2146  
    2147     double timeDummy = osg::Timer::instance()->delta_m(before, after_dummy); 
    2148     double timeKdTree = osg::Timer::instance()->delta_m(after_dummy, after_kdTree_2); 
    2149     double timeConventional = osg::Timer::instance()->delta_m(after_kdTree_2, after); 
    2150  
    2151     OSG_NOTICE<<"Using Dummy                    "<<timeDummy<<std::endl; 
    2152     OSG_NOTICE<<"      KdTrees                  "<<timeKdTree 
    2153                             <<"\tNum intersects = "<<intersectsBeforeConventional-intersectsBeforeKdTree<<std::endl; 
    2154     OSG_NOTICE<<"      KdTrees - Traversal      "<<timeKdTree-timeDummy<<std::endl; 
    2155     OSG_NOTICE<<"      Conventional             "<<timeConventional 
    2156                             <<"\tNum intersects = "<<intersectsAfterConventional-intersectsBeforeConventional<<std::endl; 
    2157     OSG_NOTICE<<"      Conventional - Traversal "<<timeConventional-timeDummy<<std::endl; 
    2158     OSG_NOTICE<<"      Delta                    "<<timeConventional/timeKdTree<<std::endl; 
    2159     OSG_NOTICE<<"      Delta sans Traversal     "<<(timeConventional-timeDummy)/(timeKdTree-timeDummy)<<std::endl; 
    2160     OSG_NOTICE<<std::endl; 
    2161 #endif 
    21622162 
    21632163    if (picker->containsIntersections()) 
     
    21732173} 
    21742174 
    2175 bool View::computeIntersections(float x,float y, const osg::NodePath& nodePath, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask) 
    2176 { 
    2177     if (!_camera.valid() || nodePath.empty()) return false; 
    2178  
    2179     float local_x, local_y = 0.0; 
    2180     const osg::Camera* camera = getCameraContainingPosition(x, y, local_x, local_y); 
    2181     if (!camera) camera = _camera.get(); 
     2175bool View::computeIntersections(const osg::Camera* camera, osgUtil::Intersector::CoordinateFrame cf, float x,float y, const osg::NodePath& nodePath, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask) 
     2176{ 
     2177    if (!camera || nodePath.empty()) return false; 
    21822178 
    21832179    osg::Matrixd matrix; 
     
    21932189    double zNear = -1.0; 
    21942190    double zFar = 1.0; 
    2195     if (camera->getViewport()) 
     2191    if (cf==osgUtil::Intersector::WINDOW && camera->getViewport()) 
    21962192    { 
    21972193        matrix.postMult(camera->getViewport()->computeWindowMatrix()); 
     
    22032199    inverse.invert(matrix); 
    22042200 
    2205     osg::Vec3d startVertex = osg::Vec3d(local_x,local_y,zNear) * inverse; 
    2206     osg::Vec3d endVertex = osg::Vec3d(local_x,local_y,zFar) * inverse; 
     2201    osg::Vec3d startVertex = osg::Vec3d(x,y,zNear) * inverse; 
     2202    osg::Vec3d endVertex = osg::Vec3d(x,y,zFar) * inverse; 
    22072203 
    22082204    osg::ref_ptr< osgUtil::LineSegmentIntersector > picker = new osgUtil::LineSegmentIntersector(osgUtil::Intersector::MODEL, startVertex, endVertex); 
     
    22242220} 
    22252221 
    2226  
    22272222void View::addDevice(osgGA::Device* eventSource) 
    22282223{ 
  • OpenSceneGraph/trunk/src/osgViewer/Viewer.cpp

    r13277 r13376  
    1717#include <osg/DeleteHandler> 
    1818#include <osg/io_utils> 
     19#include <osg/TextureRectangle> 
     20#include <osg/TextureCubeMap> 
    1921 
    2022#include <osgDB/Registry> 
     
    267269        _endRenderingDispatchBarrier = rhs_viewer->_endRenderingDispatchBarrier; 
    268270        _endDynamicDrawBlock = rhs_viewer->_endDynamicDrawBlock; 
    269         _cameraWithFocus = rhs_viewer->_cameraWithFocus; 
    270271        _eventVisitor = rhs_viewer->_eventVisitor; 
    271272        _updateOperations = rhs_viewer->_updateOperations; 
     
    280281        rhs_viewer->_endRenderingDispatchBarrier = 0; 
    281282        rhs_viewer->_endDynamicDrawBlock = 0; 
    282         rhs_viewer->_cameraWithFocus = 0; 
    283283        rhs_viewer->_eventVisitor = 0; 
    284284        rhs_viewer->_updateOperations = 0; 
     
    430430    //OSG_INFO<<"Viewer::realize()"<<std::endl; 
    431431 
    432     setCameraWithFocus(0); 
    433  
    434432    Contexts contexts; 
    435433    getContexts(contexts); 
     
    562560        } 
    563561    } 
    564  
     562#if 0 
    565563    osgGA::GUIEventAdapter* eventState = getEventQueue()->getCurrentEventState(); 
    566564    if (getCamera()->getViewport()) 
     
    573571        eventState->setInputRange(-1.0, -1.0, 1.0, 1.0); 
    574572    } 
     573#endif 
    575574} 
    576575 
     
    617616} 
    618617 
     618void Viewer::generateSlavePointerData(osg::Camera* camera, osgGA::GUIEventAdapter& event) 
     619{ 
     620    osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(event.getGraphicsContext()); 
     621    if (!gw) return; 
     622 
     623    // What type of Camera is it? 
     624    // 1) Master Camera : do nothin extra 
     625    // 2) Slave Camera, Relative RF, Same scene graph as master : transform coords into Master Camera and add to PointerData list 
     626    // 3) Slave Camera, Relative RF, Different scene graph from master : do nothing extra? 
     627    // 4) Slave Camera, Absolute RF, Same scene graph as master : do nothing extra? 
     628    // 5) Slave Camera, Absolute RF, Different scene graph : do nothing extra? 
     629    // 6) Slave Camera, Absolute RF, Different scene graph but a distortion correction subgraph depending upon RTT Camera (slave or master) 
     630    //                              : project ray into RTT Camera's clip space, and RTT Camera's is Relative RF and sharing same scene graph as master then transform coords. 
     631 
     632    // if camera isn't the master it must be a slave and could need reprojecting. 
     633    if (camera!=getCamera()) 
     634    { 
     635        float x = event.getX(); 
     636        float y = event.getY(); 
     637 
     638        bool invert_y = event.getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS; 
     639        if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y; 
     640 
     641        osg::Matrix masterCameraVPW = getCamera()->getViewMatrix() * getCamera()->getProjectionMatrix(); 
     642        if (getCamera()->getViewport()) 
     643        { 
     644            osg::Viewport* viewport = getCamera()->getViewport(); 
     645            masterCameraVPW *= viewport->computeWindowMatrix(); 
     646        } 
     647 
     648        // slave Camera tahnks to sharing the same View 
     649        osg::View::Slave* slave = findSlaveForCamera(camera); 
     650        if (slave) 
     651        { 
     652            if (camera->getReferenceFrame()==osg::Camera::RELATIVE_RF && slave->_useMastersSceneData) 
     653            { 
     654                osg::Viewport* viewport = camera->getViewport(); 
     655                osg::Matrix localCameraVPW = camera->getViewMatrix() * camera->getProjectionMatrix(); 
     656                if (viewport) localCameraVPW *= viewport->computeWindowMatrix(); 
     657 
     658                osg::Matrix matrix( osg::Matrix::inverse(localCameraVPW) * masterCameraVPW ); 
     659                osg::Vec3d new_coord = osg::Vec3d(x,y,0.0) * matrix; 
     660                //OSG_NOTICE<<"    pointer event new_coord.x()="<<new_coord.x()<<" new_coord.y()="<<new_coord.y()<<std::endl; 
     661                event.addPointerData(new osgGA::PointerData(getCamera(), new_coord.x(), -1.0, 1.0, 
     662                                                                         new_coord.y(), -1.0, 1.0)); 
     663            } 
     664            else if (!slave->_useMastersSceneData) 
     665            { 
     666                // Are their any RTT Camera's that this Camera depends upon for textures? 
     667 
     668                osg::ref_ptr<osgUtil::LineSegmentIntersector> ray = new osgUtil::LineSegmentIntersector(osgUtil::Intersector::WINDOW, x,y); 
     669                osgUtil::IntersectionVisitor iv(ray.get()); 
     670                camera->accept(iv); 
     671                if (ray->containsIntersections()) 
     672                { 
     673                    osg::Vec3 tc; 
     674                    osg::Texture* texture = ray->getFirstIntersection().getTextureLookUp(tc); 
     675                    if (texture) 
     676                    { 
     677                        // look up Texture in RTT Camera's. 
     678                        for(unsigned int i=0; i<getNumSlaves();++i) 
     679                        { 
     680                            osg::Camera* slave_camera = getSlave(i)._camera; 
     681                            if (slave_camera) 
     682                            { 
     683                                osg::Camera::BufferAttachmentMap::const_iterator ba_itr = slave_camera->getBufferAttachmentMap().find(osg::Camera::COLOR_BUFFER); 
     684                                if (ba_itr != slave_camera->getBufferAttachmentMap().end()) 
     685                                { 
     686                                    if (ba_itr->second._texture == texture) 
     687                                    { 
     688                                        osg::TextureRectangle* tr = dynamic_cast<osg::TextureRectangle*>(ba_itr->second._texture.get()); 
     689                                        osg::TextureCubeMap* tcm = dynamic_cast<osg::TextureCubeMap*>(ba_itr->second._texture.get()); 
     690                                        if (tr) 
     691                                        { 
     692                                            event.addPointerData(new osgGA::PointerData(slave_camera, tc.x(), 0.0f, static_cast<float>(tr->getTextureWidth()), 
     693                                                                                                      tc.y(), 0.0f, static_cast<float>(tr->getTextureHeight()))); 
     694                                        } 
     695                                        else if (tcm) 
     696                                        { 
     697                                            OSG_NOTICE<<"  Slave has matched texture cubemap"<<ba_itr->second._texture.get()<<", "<<ba_itr->second._face<<std::endl; 
     698                                        } 
     699                                        else 
     700                                        { 
     701                                            event.addPointerData(new osgGA::PointerData(slave_camera, tc.x(), 0.0f, 1.0f, 
     702                                                                                                      tc.y(), 0.0f, 1.0f)); 
     703                                        } 
     704                                    } 
     705                                } 
     706                            } 
     707                        } 
     708                    } 
     709                } 
     710            } 
     711        } 
     712    } 
     713} 
     714     
     715     
     716void Viewer::generatePointerData(osgGA::GUIEventAdapter& event) 
     717{ 
     718    osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(event.getGraphicsContext()); 
     719    if (!gw) return; 
     720 
     721    float x = event.getX(); 
     722    float y = event.getY(); 
     723 
     724    bool invert_y = event.getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS; 
     725    if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y; 
     726     
     727    event.addPointerData(new osgGA::PointerData(gw, x, 0, gw->getTraits()->width, 
     728                                                    y, 0, gw->getTraits()->height)); 
     729 
     730    // new code for populating the PointerData 
     731    osgViewer::View* this_view = dynamic_cast<osgViewer::View*>(this); 
     732    osg::GraphicsContext::Cameras& cameras = gw->getCameras(); 
     733    for(osg::GraphicsContext::Cameras::iterator citr = cameras.begin(); 
     734        citr != cameras.end(); 
     735        ++citr) 
     736    { 
     737        osg::Camera* camera = *citr; 
     738        if (camera->getView()==this_view && 
     739            camera->getAllowEventFocus() && 
     740            camera->getRenderTargetImplementation()==osg::Camera::FRAME_BUFFER) 
     741        { 
     742            osg::Viewport* viewport = camera ? camera->getViewport() : 0; 
     743            if (viewport && 
     744                x >= viewport->x() && y >= viewport->y() && 
     745                x <= (viewport->x()+viewport->width()) && y <= (viewport->y()+viewport->height()) ) 
     746            { 
     747                event.addPointerData(new osgGA::PointerData(camera, (x-viewport->x())/viewport->width()*2.0f-1.0f, -1.0, 1.0, 
     748                                                                    (y-viewport->y())/viewport->height()*2.0f-1.0f, -1.0, 1.0)); 
     749 
     750                // if camera isn't the master it must be a slave and could need reprojecting. 
     751                if (camera!=getCamera()) 
     752                { 
     753                    generateSlavePointerData(camera, event); 
     754                } 
     755            } 
     756        } 
     757    } 
     758} 
     759 
     760void Viewer::reprojectPointerData(osgGA::GUIEventAdapter& source_event, osgGA::GUIEventAdapter& dest_event) 
     761{ 
     762    osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(dest_event.getGraphicsContext()); 
     763    if (!gw) return; 
     764 
     765    float x = dest_event.getX(); 
     766    float y = dest_event.getY(); 
     767 
     768    bool invert_y = dest_event.getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS; 
     769    if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y; 
     770 
     771    dest_event.addPointerData(new osgGA::PointerData(gw, x, 0, gw->getTraits()->width, 
     772                                                         y, 0, gw->getTraits()->height)); 
     773 
     774    osg::Camera* camera = (source_event.getNumPointerData()>=2) ? dynamic_cast<osg::Camera*>(source_event.getPointerData(1)->object.get()) : 0; 
     775    osg::Viewport* viewport = camera ? camera->getViewport() : 0; 
     776 
     777    if (!viewport) return; 
     778     
     779    dest_event.addPointerData(new osgGA::PointerData(camera, (x-viewport->x())/viewport->width()*2.0f-1.0f, -1.0, 1.0, 
     780                                                             (y-viewport->y())/viewport->height()*2.0f-1.0f, -1.0, 1.0)); 
     781 
     782    // if camera isn't the master it must be a slave and could need reprojecting. 
     783    if (camera!=getCamera()) 
     784    { 
     785        generateSlavePointerData(camera, dest_event); 
     786    } 
     787} 
     788 
    619789void Viewer::eventTraversal() 
    620790{ 
     
    638808 
    639809    osgGA::GUIEventAdapter* eventState = getEventQueue()->getCurrentEventState(); 
    640     osg::Matrix masterCameraVPW = getCamera()->getViewMatrix() * getCamera()->getProjectionMatrix(); 
    641     if (getCamera()->getViewport()) 
    642     { 
    643         osg::Viewport* viewport = getCamera()->getViewport(); 
    644         masterCameraVPW *= viewport->computeWindowMatrix(); 
    645     } 
    646  
    647810 
    648811    // get events from user Devices attached to Viewer. 
     
    680843                osgGA::GUIEventAdapter* event = itr->get(); 
    681844 
    682                 bool pointerEvent = false; 
    683  
    684                 float x = event->getX(); 
    685                 float y = event->getY(); 
    686  
    687                 bool invert_y = event->getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS; 
    688                 if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y; 
     845                event->setGraphicsContext(gw); 
    689846 
    690847                switch(event->getEventType()) 
     
    693850                    case(osgGA::GUIEventAdapter::RELEASE): 
    694851                    case(osgGA::GUIEventAdapter::DOUBLECLICK): 
     852                    case(osgGA::GUIEventAdapter::MOVE): 
    695853                    case(osgGA::GUIEventAdapter::DRAG): 
    696                     case(osgGA::GUIEventAdapter::MOVE): 
    697854                    { 
    698                         pointerEvent = true; 
    699  
    700                         if (event->getEventType()!=osgGA::GUIEventAdapter::DRAG || !getCameraWithFocus()) 
     855                        if (event->getEventType()!=osgGA::GUIEventAdapter::DRAG || 
     856                            eventState->getGraphicsContext()!=event->getGraphicsContext() || 
     857                            eventState->getNumPointerData()<2) 
    701858                        { 
    702                             osg::GraphicsContext::Cameras& cameras = gw->getCameras(); 
    703                             for(osg::GraphicsContext::Cameras::iterator citr = cameras.begin(); 
    704                                 citr != cameras.end(); 
    705                                 ++citr) 
    706                             { 
    707                                 osg::Camera* camera = *citr; 
    708                                 if (camera->getView()==this && 
    709                                     camera->getAllowEventFocus() && 
    710                                     camera->getRenderTargetImplementation()==osg::Camera::FRAME_BUFFER) 
    711                                 { 
    712                                     osg::Viewport* viewport = camera ? camera->getViewport() : 0; 
    713                                     if (viewport && 
    714                                         x >= viewport->x() && y >= viewport->y() && 
    715                                         x <= (viewport->x()+viewport->width()) && y <= (viewport->y()+viewport->height()) ) 
    716                                     { 
    717                                         // OSG_NOTICE<<"setCamera with focus "<<camera->getName()<<" x="<<x<<" y="<<y<<std::endl; 
    718                                         setCameraWithFocus(camera); 
    719                                     } 
    720                                 } 
    721                             } 
     859                            generatePointerData(*event); 
    722860                        } 
    723  
     861                        else 
     862                        { 
     863                            reprojectPointerData(*eventState, *event); 
     864                        } 
     865 
     866#if 0 
     867                        // assign topmost PointeData settings as the events X,Y and InputRange 
     868                        osgGA::PointerData* pd = event->getPointerData(event->getNumPointerData()-1); 
     869                        event->setX(pd->x); 
     870                        event->setY(pd->y); 
     871                        event->setInputRange(pd->xMin, pd->yMin, pd->xMax, pd->yMax); 
     872                        event->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS); 
     873#else 
     874                        if (event->getMouseYOrientation()!=osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS) 
     875                        { 
     876                            event->setY((event->getYmax()-event->getY())+event->getYmin()); 
     877                            event->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS); 
     878                        } 
     879#endif 
     880 
     881                        eventState->copyPointerDataFrom(*event); 
     882                         
    724883                        break; 
    725884                    } 
    726885                    default: 
     886                        event->copyPointerDataFrom(*eventState); 
    727887                        break; 
    728888                } 
    729  
    730                 if (pointerEvent) 
    731                 { 
    732                     if (getCameraWithFocus()) 
    733                     { 
    734                         if (getCameraWithFocus()!=getCamera()) 
    735                         { 
    736                             osg::Viewport* viewport = getCameraWithFocus()->getViewport(); 
    737                             osg::Matrix localCameraVPW = getCameraWithFocus()->getViewMatrix() * getCameraWithFocus()->getProjectionMatrix(); 
    738                             if (viewport) localCameraVPW *= viewport->computeWindowMatrix(); 
    739  
    740                             osg::Matrix matrix( osg::Matrix::inverse(localCameraVPW) * masterCameraVPW ); 
    741  
    742                             osg::Vec3d new_coord = osg::Vec3d(x,y,0.0) * matrix; 
    743  
    744                             x = new_coord.x(); 
    745                             y = new_coord.y(); 
    746                         } 
    747  
    748                         // OSG_NOTICE<<"pointer event new_coord.x()="<<new_coord.x()<<" new_coord.y()="<<new_coord.y()<<std::endl; 
    749  
    750                         event->setInputRange(eventState->getXmin(), eventState->getYmin(), eventState->getXmax(), eventState->getYmax()); 
    751                         event->setX(x); 
    752                         event->setY(y); 
    753                         event->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS); 
    754  
    755                     } 
    756                     else 
    757                     { 
    758                         x = eventState->getXmin() + (x/double(gw->getTraits()->width))*(eventState->getXmax() - eventState->getXmin()); 
    759                         y = eventState->getYmin() + (y/double(gw->getTraits()->height))*(eventState->getYmax() - eventState->getYmin()); 
    760                         // OSG_NOTICE<<"new x = "<<x<<" new y = "<<y<<std::endl; 
    761  
    762                         event->setInputRange(eventState->getXmin(), eventState->getYmin(), eventState->getXmax(), eventState->getYmax()); 
    763                         event->setX(x); 
    764                         event->setY(y); 
    765                         event->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS); 
    766                     } 
    767  
    768                     // pass along the new pointer events details to the eventState of the viewer 
    769                     eventState->setX(x); 
    770                     eventState->setY(y); 
    771                     eventState->setButtonMask(event->getButtonMask()); 
    772                     eventState->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS); 
    773  
    774                 } 
    775                 else 
    776                 { 
    777                     event->setInputRange(eventState->getXmin(), eventState->getYmin(), eventState->getXmax(), eventState->getYmax()); 
    778                     event->setX(eventState->getX()); 
    779                     event->setY(eventState->getY()); 
    780                     event->setButtonMask(eventState->getButtonMask()); 
    781                     event->setMouseYOrientation(eventState->getMouseYOrientation()); 
    782                 } 
    783                 //OSG_NOTICE<<"   mouse x = "<<event->getX()<<" y="<<event->getY()<<std::endl; 
    784                 // OSG_NOTICE<<"   mouse Xmin = "<<event->getXmin()<<" Ymin="<<event->getYmin()<<" xMax="<<event->getXmax()<<" Ymax="<<event->getYmax()<<std::endl; 
    785             } 
    786  
     889                 
     890                events.push_back(event); 
     891            } 
     892             
    787893            for(itr = gw_events.begin(); 
    788894                itr != gw_events.end(); 
     
    809915            } 
    810916 
    811             events.insert(events.end(), gw_events.begin(), gw_events.end()); 
    812  
    813         } 
    814     } 
    815  
    816     // pass on the coorindates of the main camera to make sure the frame event is scaled appropriately. 
    817     if (getCamera()->getViewport()) 
    818     { 
    819         osg::Viewport* viewport = getCamera()->getViewport(); 
    820         eventState->setInputRange( viewport->x(), viewport->y(), viewport->x() + viewport->width(), viewport->y() + viewport->height()); 
    821     } 
    822     else 
    823     { 
    824         eventState->setInputRange(-1.0, -1.0, 1.0, 1.0); 
     917        } 
    825918    } 
    826919 
     
    831924 
    832925    _eventQueue->takeEvents(events, cutOffTime); 
    833  
    834  
    835 #if 0 
    836     // OSG_NOTICE<<"Events "<<events.size()<<std::endl; 
    837     for(osgGA::EventQueue::Events::iterator itr = events.begin(); 
    838         itr != events.end(); 
    839         ++itr) 
    840     { 
    841         osgGA::GUIEventAdapter* event = itr->get(); 
    842         switch(event->getEventType()) 
    843         { 
    844             case(osgGA::GUIEventAdapter::PUSH): 
    845                 OSG_NOTICE<<"  PUSH "<<event->getButton()<<" x="<<event->getX()<<" y="<<event->getY()<<std::endl; 
    846                 break; 
    847             case(osgGA::GUIEventAdapter::RELEASE): 
    848                 OSG_NOTICE<<"  RELEASE "<<event->getButton()<<" x="<<event->getX()<<" y="<<event->getY()<<std::endl; 
    849                 break; 
    850             case(osgGA::GUIEventAdapter::DRAG): 
    851                 OSG_NOTICE<<"  DRAG "<<event->getButtonMask()<<" x="<<event->getX()<<" y="<<event->getY()<<std::endl; 
    852                 break; 
    853             case(osgGA::GUIEventAdapter::MOVE): 
    854                 OSG_NOTICE<<"  MOVE "<<event->getButtonMask()<<" x="<<event->getX()<<" y="<<event->getY()<<std::endl; 
    855                 break; 
    856             case(osgGA::GUIEventAdapter::SCROLL): 
    857                 OSG_NOTICE<<"  SCROLL "<<event->getScrollingMotion()<<std::endl; 
    858                 break; 
    859             case(osgGA::GUIEventAdapter::KEYDOWN): 
    860                 OSG_NOTICE<<"  KEYDOWN '"<<(char)event->getKey()<<"'"<<std::endl; 
    861                 break; 
    862             case(osgGA::GUIEventAdapter::KEYUP): 
    863                 OSG_NOTICE<<"  KEYUP '"<<(char)event->getKey()<<"'"<<std::endl; 
    864                 break; 
    865             case(osgGA::GUIEventAdapter::RESIZE): 
    866                 OSG_NOTICE<<"  RESIZE "<<event->getWindowX()<<"/"<<event->getWindowY()<<" x "<<event->getWindowWidth()<<"/"<<event->getWindowHeight() << std::endl; 
    867                 break; 
    868             case(osgGA::GUIEventAdapter::QUIT_APPLICATION): 
    869                 OSG_NOTICE<<"  QUIT_APPLICATION " << std::endl; 
    870                 break; 
    871             case(osgGA::GUIEventAdapter::FRAME): 
    872                 // OSG_NOTICE<<"  FRAME "<<std::endl; 
    873                 break; 
    874             default: 
    875                 // OSG_NOTICE<<"  Event not handled"<<std::endl; 
    876                 break; 
    877         } 
    878     } 
    879 #endif 
    880926 
    881927    // OSG_NOTICE<<"Events "<<events.size()<<std::endl; 
  • OpenSceneGraph/trunk/src/osgViewer/ViewerEventHandlers.cpp

    r13245 r13376  
    717717} 
    718718 
    719 bool InteractiveImageHandler::computeIntersections(osgViewer::View* view, float x,float y, const osg::NodePath& nodePath, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask) const 
    720 { 
    721     float local_x, local_y = 0.0; 
    722     const osg::Camera* camera; 
    723     if (_fullscreen) 
    724     { 
    725         if (!_camera) return false; 
    726         camera = _camera.get(); 
    727         local_x = x; 
    728         local_y = y; 
    729     } 
    730     else 
    731     { 
    732         if (!view->getCamera() || nodePath.empty()) return false; 
    733         camera = view->getCameraContainingPosition(x, y, local_x, local_y); 
    734         if (!camera) camera = view->getCamera(); 
    735     } 
    736  
    737     osg::ref_ptr< osgUtil::LineSegmentIntersector > picker; 
    738     if (_fullscreen) 
    739     { 
    740         picker = new osgUtil::LineSegmentIntersector(osgUtil::Intersector::WINDOW, local_x, local_y); 
    741     } 
    742     else 
    743     { 
    744         osg::Matrixd matrix; 
    745         if (nodePath.size()>1) 
    746         { 
    747             osg::NodePath prunedNodePath(nodePath.begin(),nodePath.end()-1); 
    748             matrix = osg::computeLocalToWorld(prunedNodePath); 
    749         } 
    750  
    751         matrix.postMult(camera->getViewMatrix()); 
    752         matrix.postMult(camera->getProjectionMatrix()); 
    753  
    754         double zNear = -1.0; 
    755         double zFar = 1.0; 
    756         if (camera->getViewport()) 
    757         { 
    758             matrix.postMult(camera->getViewport()->computeWindowMatrix()); 
    759             zNear = 0.0; 
    760             zFar = 1.0; 
    761         } 
    762  
    763         osg::Matrixd inverse; 
    764         inverse.invert(matrix); 
    765  
    766         osg::Vec3d startVertex = osg::Vec3d(local_x,local_y,zNear) * inverse; 
    767         osg::Vec3d endVertex = osg::Vec3d(local_x,local_y,zFar) * inverse; 
    768  
    769         picker = new osgUtil::LineSegmentIntersector(osgUtil::Intersector::MODEL, startVertex, endVertex); 
    770     } 
    771  
    772     osgUtil::IntersectionVisitor iv(picker.get()); 
    773     iv.setTraversalMask(traversalMask); 
    774  
    775     if (_fullscreen) 
    776     { 
    777         const_cast<osg::Camera*>(camera)->accept(iv); 
    778     } 
    779     else 
    780     { 
    781         nodePath.back()->accept(iv); 
    782     } 
    783  
    784     if (picker->containsIntersections()) 
    785     { 
    786         intersections = picker->getIntersections(); 
    787         return true; 
    788     } 
    789     else 
    790     { 
    791         intersections.clear(); 
    792         return false; 
    793     } 
    794 } 
    795  
    796719bool InteractiveImageHandler::mousePosition(osgViewer::View* view, osg::NodeVisitor* nv, const osgGA::GUIEventAdapter& ea, int& x, int &y) const 
    797720{ 
     721    if (!view) return false; 
     722     
    798723    osgUtil::LineSegmentIntersector::Intersections intersections; 
    799     bool foundIntersection = view==0 ? false : 
    800         (nv==0 ? view->computeIntersections(ea.getX(), ea.getY(), intersections) : 
    801                  //view->computeIntersections(ea.getX(), ea.getY(), nv->getNodePath(), intersections)); 
    802                  computeIntersections(view, ea.getX(), ea.getY(), nv->getNodePath(), intersections)); 
     724    bool foundIntersection = (nv==0) ? view->computeIntersections(ea, intersections) : 
     725                                       view->computeIntersections(ea, nv->getNodePath(), intersections); 
    803726 
    804727    if (foundIntersection) 
  • OpenSceneGraph/trunk/src/osgWidget/ViewerEventHandlers.cpp

    r13041 r13376  
    2222        _wm->setScrollingMotion(gea.getScrollingMotion()); 
    2323 
    24         return (this->*ma)(gea.getX(), gea.getY(), gea.getButton()); 
     24        // osgWidget assumes origin is bottom left of window so make sure mouse coordinate are increaseing y upwards and are scaled to window size. 
     25        float x = (gea.getX()-gea.getXmin())/(gea.getXmax()-gea.getXmin())*static_cast<float>(gea.getWindowWidth()); 
     26        float y = (gea.getY()-gea.getYmin())/(gea.getYmax()-gea.getYmin())*static_cast<float>(gea.getWindowHeight()); 
     27        if (gea.getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS) y = static_cast<float>(gea.getWindowHeight())-y; 
     28 
     29        //OSG_NOTICE<<"MouseHandler(x="<<x<<", y="<<y<<")"<<std::endl; 
     30 
     31        return (this->*ma)(x, y, gea.getButton()); 
    2532    } 
    2633 
  • OpenSceneGraph/trunk/src/osgWidget/Widget.cpp

    r13041 r13376  
    512512 
    513513    point_type X = ((x / getWidth()) * width) + (*texs)[LL].x(); 
    514     point_type Y = (((getHeight() - y) / getHeight()) * height) + (*texs)[UR].y(); 
     514    point_type Y = ((y / getHeight()) * height) + (*texs)[LR].y(); 
     515     
     516    if (X<0.0 || X>1.0 || Y<0.0 || Y>1.0)  
     517    { 
     518        OSG_INFO<<"Widget::getImageColorAtXY("<<x<<", "<<y<<") Texture coordinate out of range, X="<<X<<", Y="<<Y<<std::endl; 
     519        return Color(); 
     520    } 
    515521 
    516522    return image->getColor(TexCoord(X, Y)); 
  • OpenSceneGraph/trunk/src/osgWidget/WindowManager.cpp

    r13041 r13376  
    209209 
    210210    ss 
    211         << "At XY Coords: " << x << ", " << _height - y 
     211        << "At XY Coords: " << x << ", " << y 
    212212        << " ( diff " << xdiff << ", " << ydiff << " )" 
    213213        << std::endl 
     
    297297// any intersections were found. It will break after processing the first pickable Window 
    298298// it finds. 
    299 bool WindowManager::pickAtXY(float x, float y, WidgetList& wl) { 
     299bool WindowManager::pickAtXY(float x, float y, WidgetList& wl) 
     300{ 
    300301    Intersections intr; 
    301302 
    302     if(_view->computeIntersections(x, y, intr, _nodeMask)) { 
     303     
     304    osg::Camera* camera = _view->getCamera(); 
     305    osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(camera->getGraphicsContext()); 
     306    if (gw) 
     307    { 
     308        _view->computeIntersections(camera, osgUtil::Intersector::WINDOW, x, y, intr, _nodeMask); 
     309    } 
     310         
     311    if (!intr.empty()) 
     312    { 
    303313        // Get the first Window at the XY coordinates; if you want a Window to be 
    304314        // non-pickable, set the NodeMask to something else. 
     
    348358} 
    349359 
    350 /* 
    351 bool WindowManager::pickAtXY(float x, float y, WidgetList& wl) { 
    352     Intersections intr; 
    353  
    354     if(!_view->computeIntersections(x, y, intr, _nodeMask)) return false; 
    355  
    356     typedef std::vector<osg::observer_ptr<Window> > WindowVector; 
    357  
    358     WindowVector windows; 
    359  
    360     Window* activeWin = 0; 
    361  
    362     for(Intersections::iterator i = intr.begin(); i != intr.end(); i++) { 
    363         Window* win = dynamic_cast<Window*>(i->nodePath.back()->getParent(0)); 
    364  
    365         if( 
    366             !win || 
    367             (win->getVisibilityMode() == Window::VM_PARTIAL && !win->isPointerXYWithinVisible(x, y)) 
    368         ) { 
    369             continue; 
    370         } 
    371  
    372         if(activeWin != win) { 
    373             activeWin = win; 
    374  
    375             windows.push_back(win); 
    376         } 
    377     } 
    378  
    379     if(!windows.size()) return false; 
    380  
    381     std::sort(windows.begin(), windows.end(), WindowBinNumberCompare()); 
    382  
    383     for(WindowVector::iterator i = windows.begin(); i != windows.end(); i++) { 
    384         warn() << "- " << i->get()->getName() << " " << i->get()->getOrCreateStateSet()->getBinNumber() << std::endl; 
    385     } 
    386  
    387     warn() << std::endl; 
    388  
    389     return false; 
    390 } 
    391 */ 
    392360 
    393361bool WindowManager::setFocused(Window* window) {