Exemple #1
0
int main()
{
    Frustum frustum;

    osgViewer::CompositeViewer viewer;
    viewer.setThreadingModel(osgViewer::ViewerBase::SingleThreaded);

    // Circle
    Circle c;
    c.normal = osg::Vec3d(1,1,1);
    c.normal.normalize();

    c.center = osg::Vec3d(1,3,4);
    c.radius = 25;
    auto gp_circle = BuildCircle(c,osg::Vec4(0.5,0.5,0.5,1.0));

    // View0 root
    osg::ref_ptr<osg::Group> gp_root0 = new osg::Group;
    gp_root0->addChild(gp_circle);

    // View1 root
    osg::ref_ptr<osg::Group> gp_root1 = new osg::Group;
    gp_root1->addChild(gp_circle);

    // disable lighting and enable blending
    gp_root0->getOrCreateStateSet()->setMode( GL_LIGHTING,osg::StateAttribute::OFF);
    gp_root0->getOrCreateStateSet()->setMode( GL_BLEND,osg::StateAttribute::ON);
    gp_root0->getOrCreateStateSet()->setMode( GL_DEPTH_TEST,osg::StateAttribute::OFF);

    gp_root1->getOrCreateStateSet()->setMode( GL_LIGHTING,osg::StateAttribute::OFF);
    gp_root1->getOrCreateStateSet()->setMode( GL_BLEND,osg::StateAttribute::ON);
    gp_root1->getOrCreateStateSet()->setMode( GL_DEPTH_TEST,osg::StateAttribute::OFF);

    // Create View 0
    {
        osgViewer::View* view = new osgViewer::View;
        viewer.addView( view );

        view->setUpViewInWindow( 10, 10, 640, 480 );
        view->setSceneData( gp_root0.get() );
        view->getCamera()->setClearColor(osg::Vec4(0.1,0.1,0.1,1.0));

        osg::ref_ptr<osgGA::TrackballManipulator> view_manip =
                new osgGA::TrackballManipulator;
        view_manip->setMinimumDistance(100);

        view->setCameraManipulator(view_manip);

    }

    // Create view 1 (this view shows View0's frustum)
    {
        osgViewer::View* view = new osgViewer::View;
        viewer.addView( view );

        view->setUpViewInWindow( 10, 510, 640, 480 );
        view->setSceneData( gp_root1.get() );
        view->getCamera()->setClearColor(osg::Vec4(0.1,0.1,0.1,1.0));

        osg::ref_ptr<osgGA::TrackballManipulator> view_manip =
                new osgGA::TrackballManipulator;
        view_manip->setMinimumDistance(100);

        view->setCameraManipulator(view_manip);
    }

    while(!viewer.done())
    {
        osg::Camera * camera = viewer.getView(0)->getCamera();
        osg::Vec3d eye,vpt,up;
        double fovy,ar,near,far;
        camera->getViewMatrixAsLookAt(eye,vpt,up);
        camera->getProjectionMatrixAsPerspective(fovy,ar,near,far);
        osg::Vec3d viewdirn = vpt-eye;
        viewdirn.normalize();

        // new frustum
        auto new_frustum = BuildFrustumNode(camera,frustum);

        // new viewdirn
        auto new_viewdirn = BuildLine(eye,eye+(viewdirn*far),K_COLOR_GRAY);
        new_viewdirn->setName("viewdirn");

        // new closest point circle/point
        osg::Vec3d const cp_circle_pt = ClosestPointCirclePoint(c,eye);
        auto new_cp_circle_pt = BuildFacingCircle(cp_circle_pt,
                                                  eye.length()/150.0,
                                                  8,K_COLOR_RED);
        new_cp_circle_pt->setName("cp_circle_pt");

        // Update gp_root0
        {
            for(size_t i=0; i < gp_root0->getNumChildren(); i++) {
                std::string const name = gp_root0->getChild(i)->getName();
                // Remove prev camera node
                if(name == "cp_circle_pt") {
                    gp_root0->removeChild(i);
                    i--;
                }
            }
            // Add new nodes
            gp_root0->addChild(new_cp_circle_pt);
        }

        // Update gp_root1
        {
            for(size_t i=0; i < gp_root1->getNumChildren(); i++) {
                std::string const name = gp_root1->getChild(i)->getName();
                // Remove prev camera node
                if(name == "frustum") {
                    gp_root1->removeChild(i);
                    i--;
                }
                else if(name == "viewdirn") {
                    gp_root1->removeChild(i);
                    i--;
                }
                else if(name == "cp_circle_pt") {
                    gp_root1->removeChild(i);
                    i--;
                }
            }
            // Add new nodes
            gp_root1->addChild(new_frustum);
            gp_root1->addChild(new_viewdirn);
            gp_root1->addChild(new_cp_circle_pt);
        }

        viewer.frame();

    }
    return 0;
}
Exemple #2
0
int main()
{
    Frustum frustum;
    Plane horizon_plane;

    // Celestial body geometry
    auto gp_celestial = BuildCelestialSurfaceNode();

    // Base view extents
    std::vector<VxTile*> list_base_vx_tiles = BuildBaseViewExtents(5);

    osgViewer::CompositeViewer viewer;
    viewer.setThreadingModel(osgViewer::ViewerBase::SingleThreaded);

    // View0 root
    osg::ref_ptr<osg::Group> gp_root0 = new osg::Group;
    gp_root0->addChild(gp_celestial);

    // View1 root
    osg::ref_ptr<osg::Group> gp_root1 = new osg::Group;
    gp_root1->addChild(gp_celestial);

    // disable lighting and enable blending
    gp_root0->getOrCreateStateSet()->setMode( GL_LIGHTING,osg::StateAttribute::OFF);
    gp_root0->getOrCreateStateSet()->setMode( GL_BLEND,osg::StateAttribute::ON);
    gp_root0->getOrCreateStateSet()->setMode( GL_DEPTH_TEST,osg::StateAttribute::OFF);

    gp_root1->getOrCreateStateSet()->setMode( GL_LIGHTING,osg::StateAttribute::OFF);
    gp_root1->getOrCreateStateSet()->setMode( GL_BLEND,osg::StateAttribute::ON);
    gp_root1->getOrCreateStateSet()->setMode( GL_DEPTH_TEST,osg::StateAttribute::OFF);

    // Create View 0
    {
        osgViewer::View* view = new osgViewer::View;
        viewer.addView( view );

        view->setUpViewInWindow( 10, 10, 640, 480 );
        view->setSceneData( gp_root0.get() );
        view->getCamera()->setClearColor(osg::Vec4(0.1,0.1,0.1,1.0));
        view->setCameraManipulator( new osgGA::TrackballManipulator );
    }

    // Create view 1 (this view shows View0's frustum)
    {
        osgViewer::View* view = new osgViewer::View;
        viewer.addView( view );

        view->setUpViewInWindow( 10, 510, 640, 480 );
        view->setSceneData( gp_root1.get() );
        view->getCamera()->setClearColor(osg::Vec4(0.1,0.1,0.1,1.0));
        view->setCameraManipulator( new osgGA::TrackballManipulator );
    }

    while(!viewer.done())
    {
        osg::Camera * camera = viewer.getView(0)->getCamera();

        osg::Vec3d eye,vpt,up;
        camera->getViewMatrixAsLookAt(eye,vpt,up);

        // new camera frustum node
        auto new_frustum = BuildFrustumNode(camera,frustum);

        // new horizon plane node
        auto new_horizon = BuildHorizonPlaneNode(camera,horizon_plane);

        // new lod rings
        auto new_lodrings = BuildLodRingsNode(eye);

        // new min cam dist line node
        auto new_mincamdistline = BuildMinCamDistLineNode(eye);

        // new vxtiles
        BuildViewExtents(list_base_vx_tiles,frustum,horizon_plane);
        auto new_vxtiles = BuildViewExtentsNode(list_base_vx_tiles);
//        auto new_vxtilesobb = BuildViewExtentsOBBNode(list_base_vx_tiles);

        // temp new frustumobbproj
        // auto new_frustumobbproj = BuildFrustumOBBProjNode(frustum,list_base_vx_tiles[0]->obb);

        // Update gp_root0
        {
            for(size_t i=0; i < gp_root0->getNumChildren(); i++) {
                std::string const name = gp_root0->getChild(i)->getName();
                if(name == "vxtiles") {
                    gp_root0->removeChild(i);
                    i--;
                }
                else if(name == "vxtilesobb") {
                    gp_root0->removeChild(i);
                    i--;
                }
                else if(name == "horizonplane") {
                    gp_root0->removeChild(i);
                    i--;
                }
            }
            gp_root0->addChild(new_vxtiles);
//            gp_root0->addChild(new_vxtilesobb);
            gp_root0->addChild(new_horizon);
        }

        // Update gp_root1
        {
            for(size_t i=0; i < gp_root1->getNumChildren(); i++) {
                std::string const name = gp_root1->getChild(i)->getName();
                // Remove prev camera node
                if(name == "frustum") {
                    gp_root1->removeChild(i);
                    i--;
                }
                else if(name == "mincamdistline") {
                    gp_root1->removeChild(i);
                    i--;
                }
                else if(name == "lodrings") {
                    gp_root1->removeChild(i);
                    i--;
                }
                else if(name == "vxtiles") {
                    gp_root1->removeChild(i);
                    i--;
                }
                else if(name == "vxtilesobb") {
                    gp_root1->removeChild(i);
                    i--;
                }
                else if(name == "horizonplane") {
                    gp_root1->removeChild(i);
                    i--;
                }
                else if(name == "frustumobbproj") {
                    gp_root1->removeChild(i);
                    i--;
                }
            }
            // Add new nodes
            gp_root1->addChild(new_frustum);
            gp_root1->addChild(new_mincamdistline);
            gp_root1->addChild(new_lodrings);
            gp_root1->addChild(new_vxtiles);
//            gp_root1->addChild(new_vxtilesobb);
            gp_root1->addChild(new_horizon);
            //gp_root1->addChild(new_frustumobbproj);
        }

        viewer.frame();
    }

    return 0;
}
void TileSetLLByPixelArea::UpdateTileSet(osg::Camera const * cam,
                                         std::vector<uint64_t> &list_tiles_add,
                                         std::vector<uint64_t> &list_tiles_upd,
                                         std::vector<uint64_t> &list_tiles_rem)
{
    // update view data
    m_cam = cam;
    m_mvp = cam->getViewMatrix()*
            cam->getProjectionMatrix();

    osg::Vec3d eye,vpt,up;
    cam->getViewMatrixAsLookAt(eye,vpt,up);
    m_view_dirn = vpt-eye;
    m_view_dirn.normalize();

    m_near_plane.n = m_view_dirn;
    m_near_plane.n.normalize();

    m_near_plane.p = eye + m_near_plane.n*100.0;
    m_near_plane.d = m_near_plane.n*m_near_plane.p;

    double ar,fovy,z_near,z_far;
    cam->getProjectionMatrixAsPerspective(fovy,ar,z_near,z_far);

    Frustum frustum;
    {
        auto osg_frustum = BuildFrustumNode(
                    "frustum",cam,frustum,z_near,z_far);
    }

    Plane horizon_plane = CalcHorizonPlane(eye);

    // TODO check calcprojfrustumpoly is successful
    CalcProjFrustumPoly(frustum,horizon_plane,m_list_frustum_ecef);

    m_list_frustum_bounds.clear();
    m_list_frustum_lla = ConvListECEFToLLA(m_list_frustum_ecef);
    CalcMinGeoBoundsFromLLAPoly(ConvECEFToLLA(eye),
                                m_list_frustum_lla,
                                m_list_frustum_bounds);

    if(m_list_frustum_bounds.empty()) {
        return;
    }

    m_frustum_pole = 0;
    for(auto const &bounds : m_list_frustum_bounds) {
        if(bounds.maxLat == 90.0) {
            m_frustum_pole = 1;
            break;
        }

        if(bounds.minLat == -90.0) {
            m_frustum_pole = 2;
            break;
        }
    }

    m_list_frustum_tri_planes =
            calcFrustumPolyTriPlanes(m_list_frustum_ecef,true);


    // rebuild the tileset with the new view data
    m_tile_count = m_list_root_tiles.size();
    std::map<uint64_t,Tile const *> list_tileset_new;
    for(auto & root_tile : m_list_root_tiles) {
        buildTileSet(root_tile,m_tile_count);
        buildTileSetList(root_tile,list_tileset_new);
    }

    // get tileset lists as sorted lists of tile ids
    std::vector<uint64_t> list_tiles_new;
    list_tiles_new.reserve(list_tileset_new.size());
    for(auto it = list_tileset_new.begin();
        it != list_tileset_new.end(); ++it)
    {
        list_tiles_new.push_back(it->first);
    }

    std::vector<uint64_t> list_tiles_old;
    list_tiles_old.reserve(m_list_tileset.size());
    for(auto it = m_list_tileset.begin();
        it != m_list_tileset.end(); ++it)
    {
        list_tiles_old.push_back(it->first);
    }

    // split the new and old tile sets into
    // tiles added, removed and common
    SplitSets(list_tiles_new,
              list_tiles_old,
              list_tiles_add,  // tiles added
              list_tiles_rem,  // tiles removed
              list_tiles_upd); // tiles common

    // TEMP TODO
    list_tiles_upd.clear();

    m_list_tileset = list_tileset_new;
}
Exemple #4
0
int main(int argc, const char *argv[])
{
    (void)argc;
    (void)argv;

    // triangle model
    std::vector<osg::Vec3d> list_tri_vx(3);
    list_tri_vx[0] = osg::Vec3d(1,0,0);
    list_tri_vx[1] = osg::Vec3d(0,1,0);
    list_tri_vx[2] = osg::Vec3d(0,0,1);

    std::vector<osg::Vec3d> list_tri_edges;
    std::vector<osg::Vec3d> list_tri_face_norms;
    auto gp_triangle = BuildTriangleNode(list_tri_vx[0],
                                         list_tri_vx[1],
                                         list_tri_vx[2],
                                         list_tri_face_norms,
                                         list_tri_edges);

    // View0 root
    osg::ref_ptr<osg::Group> gp_root0 = new osg::Group;
    gp_root0->addChild(gp_triangle);

    // View1 root
    osg::ref_ptr<osg::Group> gp_root1 = new osg::Group;
    gp_root1->addChild(gp_triangle);

    // disable lighting and enable blending
    gp_root0->getOrCreateStateSet()->setMode( GL_LIGHTING,osg::StateAttribute::OFF);
    gp_root0->getOrCreateStateSet()->setMode( GL_BLEND,osg::StateAttribute::ON);
    gp_root0->getOrCreateStateSet()->setMode( GL_DEPTH_TEST,osg::StateAttribute::OFF);

    gp_root1->getOrCreateStateSet()->setMode( GL_LIGHTING,osg::StateAttribute::OFF);
    gp_root1->getOrCreateStateSet()->setMode( GL_BLEND,osg::StateAttribute::ON);
    gp_root1->getOrCreateStateSet()->setMode( GL_DEPTH_TEST,osg::StateAttribute::OFF);


    osgViewer::CompositeViewer viewer;
    viewer.setThreadingModel(osgViewer::ViewerBase::SingleThreaded);

    // Create View 0
    {
        osgViewer::View* view = new osgViewer::View;
        viewer.addView( view );

        view->setUpViewInWindow( 10, 10, 640, 480 );
        view->setSceneData( gp_root0.get() );
        view->getCamera()->setClearColor(osg::Vec4(0.1,0.1,0.1,1.0));
        view->setCameraManipulator( new osgGA::TrackballManipulator );
    }

    // Create view 1 (this view shows View0's frustum)
    {
        osgViewer::View* view = new osgViewer::View;
        viewer.addView( view );

//        view->addEventHandler(new KeyboardEventHandler());
        view->setUpViewInWindow( 10, 510, 640, 480 );
        view->setSceneData( gp_root1.get() );
        view->getCamera()->setClearColor(osg::Vec4(0.1,0.1,0.1,1.0));
        view->setCameraManipulator( new osgGA::TrackballManipulator );
    }

    // Create the fixed base VxTiles we use to
    // calculate view extents

    while (!viewer.done())
    {
        osg::Camera * camera = viewer.getView(0)->getCamera();

        // Create a new camera frustum node
        auto new_frustum = BuildFrustumNode(camera);

        // Update geometry color based on SAT result
        if(CalcPolysIntersectSAT(list_tri_vx,
                                 list_tri_face_norms,
                                 list_tri_edges,
                                 g_list_frustum_vx,
                                 g_list_frustum_plane_norms,
                                 g_list_frustum_edges))
        {
            UpdateTriangleNode(gp_triangle,osg::Vec4(0,1,0,1));
        }
        else {
            UpdateTriangleNode(gp_triangle,osg::Vec4(1,0,0,1));
        }


        // Update gp_root0
        {
//            for(size_t i=0; i < gp_root0->getNumChildren(); i++) {
//                std::string const name = gp_root0->getChild(i)->getName();
//            }
        }

        // Update gp_root1
        {
            for(size_t i=0; i < gp_root1->getNumChildren(); i++) {
                std::string const name = gp_root1->getChild(i)->getName();
                // Remove prev camera node
                if(name == "frustum") {
                    gp_root1->removeChild(i);
                    i--;
                }
            }
            // Add new nodes
            gp_root1->addChild(new_frustum);
        }
        viewer.frame();
    }
    return 0;
}