C++ ref_ptr::get方法代码示例

 void init(osg::Geometry* geom) {
   _geom = geom;
   _array = static_cast<osg::Vec3Array*>(geom->getVertexArray());
   if (!_geom->getNumPrimitiveSets()) {
     _dw = new osg::DrawArrays(osg::PrimitiveSet::TRIANGLES,0,0);
     geom->addPrimitiveSet(_dw.get());
   } else {
     _dw = dynamic_cast<osg::DrawArrays*>(_geom->getPrimitiveSet(_geom->getNumPrimitiveSets()-1));
   }
 }

  void GridVisualizationBase::loadImageAsRectangle(osg::ref_ptr<osg::Geode> geode,
						   osg::ref_ptr<osg::Image> image,
						   float pos_x1,float pos_y1,float pos_x2,float pos_y2)const
  {
    if(! (image.valid()))
    {
      std::cout << "Error Loading Texture: Image is not valid " << std::endl;
      exit(0);
    }
    // Create a Geometry object.
    osg::ref_ptr<osg::Geometry> geom = new osg::Geometry;
    
    //full color display
    osg::ref_ptr<osg::Vec4Array> c = new osg::Vec4Array;
    geom->setColorArray( c.get() );
    geom->setColorBinding( osg::Geometry::BIND_OVERALL );
    c->push_back( osg::Vec4( 1.0f, 1.0f, 1.0f, 1.0f ) );
    
    //set texture coordinates
    osg::ref_ptr<osg::Vec2dArray>  texture_coordinates = new osg::Vec2dArray;
    texture_coordinates->push_back(osg::Vec2d(0,0));
    texture_coordinates->push_back(osg::Vec2d(1,0));
    texture_coordinates->push_back(osg::Vec2d(1,1));
    texture_coordinates->push_back(osg::Vec2d(0,1));
    geom->setTexCoordArray(0, texture_coordinates.get());
    
    // Specify the vertices:
    osg::ref_ptr<osg::Vec3Array>  vertice_array = new osg::Vec3Array;
    vertice_array->push_back(osg::Vec3(pos_x1,pos_y1,0));
    vertice_array->push_back(osg::Vec3(pos_x2,pos_y1,0));
    vertice_array->push_back(osg::Vec3(pos_x2,pos_y2,0));
    vertice_array->push_back(osg::Vec3(pos_x1,pos_y2,0));
    // Associate this set of vertices with the geometry associated with the geode 
    geom->setVertexArray(vertice_array);
   
     // Create a QUAD primitive by specifying the 
     // vertices from our vertex list that make up this QUAD:

    // Add primitive to the geometry
    geom->addPrimitiveSet(new osg::DrawArrays( osg::PrimitiveSet::POLYGON, 0, vertice_array->size() ) );
    
    // Attach the image in a Texture2D object
    osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D;
    texture->setImage( image.get() );

    osg::StateSet *state = geom->getOrCreateStateSet();
    
    //apply texture to geom
    state->setTextureAttributeAndModes(0, texture.get());
    
    //remove old drawables
    while(geode->removeDrawables(0));
    //add a mew one
    geode->addDrawable(geom.get());  
  }

PropertyReflection* RefosgPolygonOffset::getProperty(const std::string &name) {
	if (name == "_userData") {
		// Getter overloaded, must specify one type
		typedef Referenced * (osg::Object::*getUserDataFN)() ;
		return new GetterSetterProperty<Referenced*, osg::Object>("_userData", _object.get(), (getUserDataFN)&osg::PolygonOffset::getUserData, &osg::PolygonOffset::setUserData);
	}
	if (name == "_units") {
		// Getter overloaded, must specify one type
		typedef float (osg::PolygonOffset::*getUnitsFN)() const;
		// Setter overloaded, must specify one type
		typedef void (osg::PolygonOffset::*setUnitsFN)(float) ;
		return new GetterSetterProperty<float, osg::PolygonOffset>("_units", _object.get(), (getUnitsFN)&osg::PolygonOffset::getUnits, (setUnitsFN)&osg::PolygonOffset::setUnits);
	}
	if (name == "_factor") {
		// Getter overloaded, must specify one type
		typedef float (osg::PolygonOffset::*getFactorFN)() const;
		// Setter overloaded, must specify one type
		typedef void (osg::PolygonOffset::*setFactorFN)(float) ;
		return new GetterSetterProperty<float, osg::PolygonOffset>("_factor", _object.get(), (getFactorFN)&osg::PolygonOffset::getFactor, (setFactorFN)&osg::PolygonOffset::setFactor);
	}
	if (name == "_name") {
		// Getter overloaded, must specify one type
		typedef const std::string & (osg::Object::*getNameFN)() const;
		// Setter overloaded, must specify one type
		typedef void (osg::Object::*setNameFN)(const std::string &) ;
		return new GetterSetterProperty<std::string, osg::Object>("_name", _object.get(), (getNameFN)&osg::PolygonOffset::getName, (setNameFN)&osg::PolygonOffset::setName);
	}
	if (name == "_updateCallback") {
		// Getter overloaded, must specify one type
		typedef osg::StateAttribute::Callback * (osg::StateAttribute::*getUpdateCallbackFN)() ;
		return new GetterSetterProperty<osg::StateAttribute::Callback*, osg::StateAttribute>("_updateCallback", _object.get(), (getUpdateCallbackFN)&osg::PolygonOffset::getUpdateCallback, &osg::PolygonOffset::setUpdateCallback);
	}
	if (name == "_dataVariance") {
		return new GetterSetterEnumProperty<osg::Object::DataVariance, osg::Object>("_dataVariance", _object.get(), &osg::PolygonOffset::getDataVariance, &osg::PolygonOffset::setDataVariance, osg_object_datavariance);
	}
	if (name == "_eventCallback") {
		// Getter overloaded, must specify one type
		typedef osg::StateAttribute::Callback * (osg::StateAttribute::*getEventCallbackFN)() ;
		return new GetterSetterProperty<osg::StateAttribute::Callback*, osg::StateAttribute>("_eventCallback", _object.get(), (getEventCallbackFN)&osg::PolygonOffset::getEventCallback, &osg::PolygonOffset::setEventCallback);
	}
	throw PropertyNotFoundException(name);
}

void ossimPlanetClientThread::removeConnection(osg::ref_ptr<ossimPlanetClientConnection> connection)
{
   OpenThreads::ScopedLock<OpenThreads::Mutex> lock(theConnectionListMutex);
   ossimPlanetClientThreadConnectionList::iterator iter = std::find(theClientConnectionList.begin(),
                                                                    theClientConnectionList.end(),
                                                                    connection.get());
   if(iter != theClientConnectionList.end())
   {
      theClientConnectionList.erase(iter);
   }
}

bool ossimPlanetViewer::addAnnotation(osg::ref_ptr<ossimPlanetAnnotationLayerNode> annotation)
{
   bool result = false;
   
   if(theAnnotationLayer.valid())
   {
      result = theAnnotationLayer->addChild(annotation.get());
   }
   
   return result;
}

void World::setUpViewer() {
    _viewer.setUpViewInWindow( 150.0f, 150.0f, 1024.0f, 768.0f );
    _viewer.setSceneData( _root_node.get() );
    
    _camera = _viewer.getCamera();
//    _camera->setProjectionMatrixAsPerspective( 70.0f, 1024.0f/768.0f, 1.0f, 10000.0f );
//    _camera->setViewMatrixAsLookAt(vec3( 1000.0f, 0.0f, -1000.0f ), vec3( 0.0f, 0.0f, 0.0f ), vec3( 0.0f, 0.0f, -1.0f ) );
    
    _viewer.setCameraManipulator(new osgGA::TrackballManipulator);
    
    _viewer.realize();
}

bool ShaderContainer::addShaderNode( const std::string& name, osg::ref_ptr< osg::Group > node, osg::Group* p_parent )
{
    if ( _shaderNodes.find( name ) != _shaderNodes.end() )
        return false;

    _shaderNodes[ name ] = node;

    if ( p_parent )
        p_parent->addChild( node.get() );

    return true;
}

osg::StateSet* getSingletonLightPointSystemSet()
{
    static osg::ref_ptr<osg::StateSet> s_stateset = 0;
    if (!s_stateset)
    {
        s_stateset = new osg::StateSet;
        // force light point nodes to be drawn after everything else by picking a rendering bin number after
        // the transparent bin.
        s_stateset->setRenderBinDetails(20,"DepthSortedBin");
    }
    return s_stateset.get();
}

void GL_Window::getTexture(osg::ref_ptr<osg::Image> image){

    if(image != '\0'){
        texture->setImage(image.get());
        stateset->setTextureAttributeAndModes (0, texture.get(), osg::StateAttribute::ON);
    }
    else
    {
        stateset->setTextureAttributeAndModes (0, texture.get(), osg::StateAttribute::OFF);
    }
    redraw();
}

    void onClick( Control* control, int mouseButtonMask ) {
        
        //Remove the add point handler if it's valid
        if (s_addPointHandler.valid())
        {            
            osgEarth::removeEventHandler( s_viewer, s_addPointHandler.get() );
            s_addPointHandler = NULL;
        }        

        if (!s_editor.valid() && s_activeFeature.valid())
        {
            Style* style = _featureGraph->getStyles()->getDefaultStyle();
            if ( style )
            {
                style->get<LineSymbol>()->stroke()->stipple() = 0x00FF;
                _featureGraph->dirty();
            }
            s_editor = new FeatureEditor(s_activeFeature.get(), s_source.get(), s_mapNode.get());
            s_root->addChild( s_editor.get() );
        }
    }

 Camera::Camera(osg::ref_ptr<GLContextManager> pContext, osg::ref_ptr<osg::Texture2D> ptex)
     : pContext(pContext),
     ptex(ptex)
 {
     minimalz = 1.0;
     pContext->makeCurrent();
     CHECK_GL();
     fbo = new FBO(GL_TEXTURE_2D, pContext->getTextureID(ptex.get()), ptex->getTextureWidth(), ptex->getTextureHeight());
     fov = 30.0;
     aspectRatio = 4.0 / 3.0;
     bDoublePrecisionMode = false;
 }

bool
ShaderGenerator::processText(const osg::StateSet* ss, osg::ref_ptr<osg::StateSet>& replacement)
{
    // do nothing if there's no GLSL support
    if ( !_active )
        return false;

    // Capture the active current state:
    osg::ref_ptr<osg::StateSet> current = static_cast<StateEx*>(_state.get())->capture();

    // check for a real osg::Program. If it exists, bail out so that OSG
    // can use the program already in the graph
    osg::StateAttribute* program = current->getAttribute(osg::StateAttribute::PROGRAM);
    if ( dynamic_cast<osg::Program*>(program) != 0L )
        return false;

    // New state set. We never modify existing statesets.
    replacement = ss ? osg::clone(ss, osg::CopyOp::SHALLOW_COPY) : new osg::StateSet();

    // new VP:
    osg::ref_ptr<VirtualProgram> vp = VirtualProgram::cloneOrCreate(replacement.get());
    
    // give the VP a name if it needs one.
    if ( vp->getName().empty() )
    {
        vp->setName( _name );
    }

    std::string vertSrc =
        "#version " GLSL_VERSION_STR "\n" GLSL_PRECISION "\n"
        "varying " MEDIUMP "vec4 " TEX_COORD_TEXT ";\n"
        "void " VERTEX_FUNCTION "(inout vec4 vertexVIEW)\n"
        "{ \n"
        INDENT TEX_COORD_TEXT " = gl_MultiTexCoord0;\n"
        "} \n";

    std::string fragSrc =
        "#version " GLSL_VERSION_STR "\n" GLSL_PRECISION "\n"
        "uniform sampler2D " SAMPLER_TEXT ";\n"
        "varying " MEDIUMP "vec4 " TEX_COORD_TEXT ";\n"
        "void " FRAGMENT_FUNCTION "(inout vec4 color)\n"
        "{ \n"
        INDENT MEDIUMP "vec4 texel = texture2D(" SAMPLER_TEXT ", " TEX_COORD_TEXT ".xy);\n"
        //INDENT MEDIUMP "vec4 texel = texture2DLod(" SAMPLER_TEXT ", " TEX_COORD_TEXT ".xy, 0.0);\n"
        INDENT "color.a *= texel.a; \n"
        "}\n";

    vp->setFunction( VERTEX_FUNCTION,   vertSrc, ShaderComp::LOCATION_VERTEX_MODEL, 0.5f );
    vp->setFunction( FRAGMENT_FUNCTION, fragSrc, ShaderComp::LOCATION_FRAGMENT_COLORING, 0.5f );
    replacement->getOrCreateUniform( SAMPLER_TEXT, osg::Uniform::SAMPLER_2D )->set( 0 );

    return replacement.valid();
}

    osg::ref_ptr<osg::GraphicsContext> QtOsgMixGraphicsWidget::createWidgetContext(
                                                                                   void* parent,
                                                                                   osg::ref_ptr<osg::GraphicsContext::Traits> traits) {
      traits->windowDecoration = false;

#if defined(__APPLE__)
#if defined(USE_COCOA)
      wdata =  new WindowData(WindowData::CreateOnlyView);
      traits->inheritedWindowData = wdata;
      haveNSView = false;
#else
      traits->inheritedWindowData = new WindowData(HIViewGetWindow((HIViewRef)winId()));
#endif
#elif defined(WIN32) && !defined(__CYGWIN__)
      traits->inheritedWindowData = new WindowData((HWND)winId());
#else // all others
      traits->inheritedWindowData = new WindowData(winId());
#endif // __APPLE__

      osg::DisplaySettings* ds = osg::DisplaySettings::instance();
      if (ds->getStereo()) {
        switch(ds->getStereoMode()) {
        case(osg::DisplaySettings::QUAD_BUFFER):
          traits->quadBufferStereo = true;
          break;
        case(osg::DisplaySettings::VERTICAL_INTERLACE):
        case(osg::DisplaySettings::CHECKERBOARD):
        case(osg::DisplaySettings::HORIZONTAL_INTERLACE):
          traits->stencil = 8;
          break;
        default: break;
        }
      }

      osg::ref_ptr<osg::GraphicsContext> gc =
        osg::GraphicsContext::createGraphicsContext(traits.get());

      if (parent) {
        traits->x = ((QWidget*)parent)->x();
        traits->y = ((QWidget*)parent)->y();
        traits->width = ((QWidget*)parent)->width();
        traits->height = ((QWidget*)parent)->height();
      }
      else {
        traits->x = x();
        traits->y = y();
        traits->width = width();
        traits->height = height();
      }

      return gc;
    }

void CSVRender::InstanceMode::secondarySelectPressed (osg::ref_ptr<TagBase> tag)
{
    if (tag)
    {
        if (CSVRender::ObjectTag *objectTag = dynamic_cast<CSVRender::ObjectTag *> (tag.get()))
        {
            // hit an Object, toggle its selection state
            CSVRender::Object* object = objectTag->mObject;
            object->setSelected (!object->getSelected());
            return;
        }
    }
}

Registry* 
Registry::instance(bool erase)
{
    static osg::ref_ptr<Registry> s_registry = new Registry;

    if (erase) 
    {   
        s_registry->destruct();
        s_registry = 0;
    }

    return s_registry.get(); // will return NULL on erase
}