Пример #1
0
ossimPlanetLatLonHud::ossimPlanetLatLonHud()
{
   setUpdateCallback(new ossimPlanetLatLonHudUpdateCallback);
   theInitializedFlag = false;
   theAutoUpdateFlag = true;
   theFontName = "arial.ttf";
   theFont = osgText::readFontFile(theFontName.c_str());
   theFontChanged = true;

   theCharacterSize = 16;
   theCharacterSizeDirtyFlag = true;
   theLookLabel  = "Look At:  ";
   theEyeLabel   = "Eye:      ";
   theRangeLabel = "Range:    ";
   theLatDisplayString = "dd.ddddddddddddC";
   theLonDisplayString = "ddd.ddddddddddddC";

   theCompass = new ossimPlanetCompass;
   theCompass->setRotateByViewMatrix(true);
   theCompass->buildCompass();
   theCompass->getOrCreateStateSet()->setAttribute(new osg::PolygonMode(), 
                                                   osg::StateAttribute::PROTECTED); // don't allow to go to wireframe

   theViewportChangedFlag = false;
}
Пример #2
0
SilverLiningNode::SilverLiningNode( const char* licenseUser, const char* licenseKey )
:   _initialized(false)
{
    _sky = new SkyDrawable(this);
    _sky->setUseVertexBufferObjects( false );
    _sky->setUseDisplayList( false );
    _sky->getOrCreateStateSet()->setRenderBinDetails( 98, "RenderBin" );
    _sky->getOrCreateStateSet()->setAttributeAndModes(
        new osg::Depth(osg::Depth::LEQUAL, 0.0, 1.0, false) );
    addDrawable( _sky.get() );
    
    _cloud = new CloudDrawable(this);
    _cloud->setUseVertexBufferObjects( false );
    _cloud->setUseDisplayList( false );
    _cloud->getOrCreateStateSet()->setRenderBinDetails( 99, "RenderBin" );
    _cloud->setCullCallback( new AlwaysKeepCallback );  // This seems to avoid cloud to twinkle sometimes
    addDrawable( _cloud.get() );
    
    AtmosphereUpdater* updater = new AtmosphereUpdater;
    setUpdateCallback( updater );
    setCullCallback( updater );
    setCullingActive( false );
    getOrCreateStateSet()->setRenderBinDetails( 100, "RenderBin" );
    
    _atmosphere = new SilverLining::Atmosphere( licenseUser, licenseKey );
    _atmosphere->DisableFarCulling( true );
    _atmosphere->EnableLensFlare( true );
    
    const char* slPath = getenv( "SILVERLINING_PATH" );
    if ( slPath )
        _resourcePath = osgDB::convertFileNameToNativeStyle(std::string(slPath) + "/resources/");
}
Пример #3
0
RigGeometry::RigGeometry()
    : mSkeleton(nullptr)
    , mLastFrameNumber(0)
    , mBoundsFirstFrame(true)
{
    setUpdateCallback(new osg::Callback); // dummy to make sure getNumChildrenRequiringUpdateTraversal() is correct
                                          // update done in accept(NodeVisitor&)
}
Пример #4
0
//==============================================================================
WorldNode::WorldNode(std::shared_ptr<dart::simulation::World> _world)
  : mWorld(_world),
    mSimulating(false),
    mNumStepsPerCycle(1),
    mViewer(nullptr)
{
  setUpdateCallback(new WorldNodeCallback);
}
Пример #5
0
TextShape::TextShape(std::string command, std::string name) 
{
    // check for changed values
    createParameter("pos", new Vec3Type());
    createParameter("color", new Vec4Type());
    createParameter("bcolor", new Vec4Type());
    createParameter("enableOutline", new BoolType());
    createParameter("size", new FloatType());
    createParameter("label", new StringType());
    createParameter("font", new StringType());

    _type = SimpleShape::TEXT;

    BasicShape::setName(name);
    
    // default color is white for font
    setColor(osg::Vec4(1.0, 1.0, 1.0, 1.0));

    // set a default background color
    setBackdropColor(osg::Vec4(0.0, 0.0, 0.0, 1.0));

    setCharacterSize(10.0f);
    setFontResolution(40,40);

    osgText::Font* font = NULL;

    // check if fontMap has been constucted
    if ( _fontMap == NULL )
        _fontMap = new ThreadMap< std::string, osgText::Font* >();

    // check if font exists in map else load it and add it
    if( ! _fontMap->get(std::string("/usr/share/fonts/liberation/LiberationSans-Regular.ttf"), font) )
    {
        font = osgText::readFontFile("/usr/share/fonts/liberation/LiberationSans-Regular.ttf");
        _fontMap->add(std::string("/usr/share/fonts/liberation/LiberationSans-Regular.ttf"), font);
    }

    setFont(font);

    if( Globals::G_ROTAXIS )
        setAxisAlignment(osgText::TextBase::XY_PLANE);
    else
        setAxisAlignment(osgText::TextBase::XZ_PLANE);

    // off by default
    setBackdropType(osgText::Text::NONE);

    osg::StateSet* state = osgText::Text::getOrCreateStateSet();
    state->setMode(GL_BLEND, osg::StateAttribute::ON);
    state->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
    //osg::Material* mat = new osg::Material();
    //mat->setColorMode(osg::Material::AMBIENT_AND_DIFFUSE);
    //state->setAttributeAndModes(mat, osg::StateAttribute::ON);
   
    setUpdateCallback(new TextUpdateCallback());
    
    update(command);
}
Пример #6
0
Level::Level(const std::string &mapfile) :
    _numDeaths(0),
    _reachedFinish(false)
{
    _shadowedScene = new osgShadow::ShadowedScene;
    _shadowedScene->setReceivesShadowTraversalMask(RECEIVE_SHADOW_MASK);
	_shadowedScene->setCastsShadowTraversalMask(CAST_SHADOW_MASK);
	_shadowedScene->setShadowTechnique(new osgShadow::ShadowMap);
 
    addChild(_shadowedScene);

    _headUpDisplay = new HeadUpDisplay();
    addChild(_headUpDisplay->getCamera());
    addChild((new Sky())->getCamera());
    
    initializePhysicsWorld();
    
    // load map from file
    loadMapFromFile(mapfile);
    
    // add player to level
    _shadowedScene->addChild(Player::getInstance());
    addChild(Player::getInstance()->getParticleEffects());
	
    // add player ghost object to world
    _physicsWorld->addCollisionObject(Player::getInstance()->getGhostObject(),
                               btBroadphaseProxy::CharacterFilter,
                               btBroadphaseProxy::StaticFilter | btBroadphaseProxy::DefaultFilter);
                               
    // register player controller
    _physicsWorld->addAction(Player::getInstance()->getController());
    
    // initialize members
    LazyCameraManipulator *cameraManipulator = new LazyCameraManipulator();
    
    // setup manipulator to track the player
    cameraManipulator->setTrackNode(Player::getInstance());
    cameraManipulator->setHomePosition(LEVEL_CAMERA_HOME_EYE, LEVEL_CAMERA_HOME_CENTER, LEVEL_CAMERA_HOME_UP);

    // player must be updated after physic is updated
    Player::getInstance()->setUpdateCallback(new PlayerUpdater());
    
    // set _cameraManipulator as manipulator for the scene
    viewer.setCameraManipulator(cameraManipulator);
                
    LevelUpdater *stepCallback = new LevelUpdater(this);
    setUpdateCallback(stepCallback);
    
    // player keyboard control
    _keyboardHandler = new LevelKeyboardHandler();
    viewer.addEventHandler(_keyboardHandler);
    
    initializeLighting();
    
    Sound::getInstance()->stop(MENU_MUSIC_FILE);
    Sound::getInstance()->playInLoop(LEVEL_MUSIC_FILE);    
}
void QuadPrimitive::applyLineShader(osg::StateSet* stateSet)
{
	const std::string vertexSource =
		"#version 330 \n"
		" \n"
		"uniform vec3 center; \n"
		"uniform mat4 osg_ModelViewProjectionMatrix; \n"
		"uniform vec4 mat_diffuse; \n"
		" \n"
		"layout (location = 0) in vec4 Position; \n"
		"layout (location = 1) in vec3 osg_Normal; \n"
		"layout (location = 2) in vec4 osg_Color; \n"
		"layout (location = 3) in vec2 osg_Texcoord; \n"
		"out vec4 color; \n"
		"out vec2 Texcoord; \n"
		" \n"
		"void main() \n"
		"{ \n"
		//"    vec3 ecNormal = normalize( osg_NormalMatrix * osg_Normal ); \n"
		//"    float diffuse = max( dot( ecLightDir, ecNormal ), 0. ); \n"
		//"    color = vec4( diffuse * mat_diffuse.rgb, mat_diffuse.a ); \n"//
		"    color = osg_Color; \n"//
		"    Texcoord = osg_Texcoord;\n"
		"    gl_Position = osg_ModelViewProjectionMatrix * (Position + vec4(center, 0)); \n"
		"} \n";
	osg::Shader* vShader = new osg::Shader(osg::Shader::VERTEX, vertexSource);

	const std::string fragmentSource =
		"#version 330 \n"
		//"uniform sampler2D gDiffuseMap;\n"
		"in vec4 color; \n"
		"in vec2 Texcoord; \n"
		"out vec4 fragData; \n"
		" \n"
		"void main() \n"
		"{ \n"
		"    fragData = color; \n"
		//"    fragData = color*texture(gDiffuseMap, Texcoord); \n"
		"} \n";
	osg::Shader* fShader = new osg::Shader(osg::Shader::FRAGMENT, fragmentSource);

	osg::Program* program = new osg::Program;
	program->addShader(vShader);
	program->addShader(fShader);
	stateSet->setAttribute(program);

	auto uni = new osg::Uniform("center", m_center);
	uni->setUpdateCallback(new UniformUpdater([this](osg::Uniform* uni, unsigned int /*frameNum*/){
		uni->set(m_center);
	}));
	stateSet->addUniform(uni);
}
Пример #8
0
Renderable::Renderable(void)
  :read_write_lock_(QReadWriteLock::NonRecursive),
  content_root_(new osg::MatrixTransform),
  expired_(true),
  hidden_(false)
{
  addChild(content_root_);

  setUpdateCallback(new UpdateCallback);
  setDataVariance(Object::DYNAMIC);

  return;
}
Пример #9
0
    Refraction()
    {
        unsigned int rttSize = Settings::Manager::getInt("rtt size", "Water");
        setRenderOrder(osg::Camera::PRE_RENDER);
        setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT);
        setReferenceFrame(osg::Camera::RELATIVE_RF);
        setSmallFeatureCullingPixelSize(Settings::Manager::getInt("small feature culling pixel size", "Water"));
        setName("RefractionCamera");

        setCullMask(Mask_Effect|Mask_Scene|Mask_Terrain|Mask_Actor|Mask_ParticleSystem|Mask_Sky|Mask_Sun|Mask_Player|Mask_Lighting);
        setNodeMask(Mask_RenderToTexture);
        setViewport(0, 0, rttSize, rttSize);

        // No need for Update traversal since the scene is already updated as part of the main scene graph
        // A double update would mess with the light collection (in addition to being plain redundant)
        setUpdateCallback(new NoTraverseCallback);

        // No need for fog here, we are already applying fog on the water surface itself as well as underwater fog
        // assign large value to effectively turn off fog
        // shaders don't respect glDisable(GL_FOG)
        osg::ref_ptr<osg::Fog> fog (new osg::Fog);
        fog->setStart(10000000);
        fog->setEnd(10000000);
        getOrCreateStateSet()->setAttributeAndModes(fog, osg::StateAttribute::OFF|osg::StateAttribute::OVERRIDE);

        mClipCullNode = new ClipCullNode;
        addChild(mClipCullNode);

        mRefractionTexture = new osg::Texture2D;
        mRefractionTexture->setTextureSize(rttSize, rttSize);
        mRefractionTexture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
        mRefractionTexture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
        mRefractionTexture->setInternalFormat(GL_RGB);
        mRefractionTexture->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
        mRefractionTexture->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);

        attach(osg::Camera::COLOR_BUFFER, mRefractionTexture);

        mRefractionDepthTexture = new osg::Texture2D;
        mRefractionDepthTexture->setSourceFormat(GL_DEPTH_COMPONENT);
        mRefractionDepthTexture->setInternalFormat(GL_DEPTH_COMPONENT24);
        mRefractionDepthTexture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
        mRefractionDepthTexture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
        mRefractionDepthTexture->setSourceType(GL_UNSIGNED_INT);
        mRefractionDepthTexture->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
        mRefractionDepthTexture->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);

        attach(osg::Camera::DEPTH_BUFFER, mRefractionDepthTexture);
    }
Пример #10
0
TritonNode::TritonNode( const char* licenseUser, const char* licenseKey )
:   _resourceLoader(0), _environment(0), _ocean(0), _atmosphere(0),
    _licenseName(licenseUser), _licenseKey(licenseKey), _initialized(false)
{
    _oceanDrawable = new OceanDrawable(this);
    _oceanDrawable->setUseVertexBufferObjects( false );
    _oceanDrawable->setUseDisplayList( false );
    addDrawable( _oceanDrawable.get() );
    
    OceanUpdater* updater = new OceanUpdater;
    setUpdateCallback( updater );
    setCullCallback( updater );
    getOrCreateStateSet()->setAttribute( new osg::Program );
    
    const char* slPath = getenv( "TRITON_PATH" );
    if ( slPath )
        _resourcePath = osgDB::convertFileNameToNativeStyle(std::string(slPath) + "/resources/");
}
Пример #11
0
Tiled2DGraphics::Tiled2DGraphics(const osg::Vec2& size, const osg::Vec4& constraining_rect, double tile_width, double tile_height, const Options& options)
:	osg::MatrixTransform(),
	_size(size),
	_constrainingRect(constraining_rect),
	_minZoomLevel(computeMinZoomLevel()),
	_maxZoomLevel(_minZoomLevel),
	_currentZoomLevel(0.0f),
    _currentVisibleLevel(NULL),
    _scrollDelta(0,0),
    _visibleTiles(),
    _tilesToHide(),
	_tileWidth(tile_width),
	_tileHeight(tile_height),
	_origin(osg::Image::BOTTOM_LEFT),
    _zoomRegistrationPoint(),
    _clampingPolicy(ClampSoft),
    _useCache(true),
    _debug(options.debug),
    _debugTiles(options.debugTiles),
    _tilesComputed(false),
    _lastLevelId(0),
    _enabled(true)
{
	_tilesToHideCache = new TilesToHideCache(options.tilesCacheLifeTime);
    _mergeController = new MergeController(this, options.numTilesToMergePerFrame);
    
    setUpdateCallback(new Tiled2DGraphicsUpdateCallback(this));
	setZoomLevel(_minZoomLevel);
	updateOffset(ClampHard);
    
	setZoomRegistrationPoint(cefix::Rect::getCenter(constraining_rect));
    
    
    
    if (_debug) {
        cefix::DebugGeometryFactory::enable("tiles_2d");
        cefix::DebugGeometryFactory::enable("tiles_2d_overlay");
        cefix::DebugGeometryFactory::get("tiles_2d")->setLocZ(1);
        addChild(cefix::DebugGeometryFactory::get("tiles_2d")->getOrCreateNode());
    }
}
Пример #12
0
AbstractHimmel::AbstractHimmel()
:   osg::MatrixTransform()
,   m_timef(NULL)
,   m_autoUpdateTime(false)

,   m_initialized(false)
,   m_dirty(false)

,   m_cameraHint(NULL)
,   m_widthHint(0u)
,   m_heightHint(0u)

,   m_lastElapsed(0.0)

,   m_referenceBoundingRadius(1.f)
{
    setupNode(getOrCreateStateSet());

    setUpdateCallback(new HimmelNodeCallback);

    setReferenceFrame(osg::Transform::ABSOLUTE_RF);
};
Пример #13
0
    Reflection()
    {
        setRenderOrder(osg::Camera::PRE_RENDER);
        setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT);
        setReferenceFrame(osg::Camera::RELATIVE_RF);
        setSmallFeatureCullingPixelSize(Settings::Manager::getInt("small feature culling pixel size", "Water"));
        setName("ReflectionCamera");

        bool reflectActors = Settings::Manager::getBool("reflect actors", "Water");

        setCullMask(Mask_Effect|Mask_Scene|Mask_Terrain|Mask_ParticleSystem|Mask_Sky|Mask_Player|Mask_Lighting|(reflectActors ? Mask_Actor : 0));
        setNodeMask(Mask_RenderToTexture);

        unsigned int rttSize = Settings::Manager::getInt("rtt size", "Water");
        setViewport(0, 0, rttSize, rttSize);

        // No need for Update traversal since the mSceneRoot is already updated as part of the main scene graph
        // A double update would mess with the light collection (in addition to being plain redundant)
        setUpdateCallback(new NoTraverseCallback);

        mReflectionTexture = new osg::Texture2D;
        mReflectionTexture->setInternalFormat(GL_RGB);
        mReflectionTexture->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
        mReflectionTexture->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
        mReflectionTexture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
        mReflectionTexture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);

        attach(osg::Camera::COLOR_BUFFER, mReflectionTexture);

        // XXX: should really flip the FrontFace on each renderable instead of forcing clockwise.
        osg::ref_ptr<osg::FrontFace> frontFace (new osg::FrontFace);
        frontFace->setMode(osg::FrontFace::CLOCKWISE);
        getOrCreateStateSet()->setAttributeAndModes(frontFace, osg::StateAttribute::ON);

        mClipCullNode = new ClipCullNode;
        addChild(mClipCullNode);
    }
Пример #14
0
TextShape::TextShape(std::string command, std::string name) 
{
    _type = SimpleShape::TEXT;

    BasicShape::setName(name);
    setColor(osg::Vec4(1.0, 1.0, 1.0, 1.0));
    setCharacterSize(10.0f);
    setFontResolution(40,40);
    setFont ("/usr/share/fonts/liberation/LiberationSans-Regular.ttf");
    setAxisAlignment(osgText::TextBase::XZ_PLANE);
    setBackdropType(osgText::Text::NONE);

    osg::StateSet* state = osgText::Text::getOrCreateStateSet();
    state->setMode(GL_BLEND, osg::StateAttribute::ON);
    state->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
    //osg::Material* mat = new osg::Material();
    //mat->setColorMode(osg::Material::AMBIENT_AND_DIFFUSE);
    //state->setAttributeAndModes(mat, osg::StateAttribute::ON);
   
    setUpdateCallback(new TextUpdateCallback());
    
    update(command);
}
Пример #15
0
LightManager::LightManager()
{
    setDataVariance(DYNAMIC);
    setUpdateCallback(Utils::makeNodeCallback(this, &LightManager::update));
}
LaserScanLineNode::LaserScanLineNode(URGCPPWrapper &urg) : laser_scan_line(new LaserScanLine(urg))
{
    setUpdateCallback(new LaserScanLineCallback);
    addDrawable(laser_scan_line);
}
Пример #17
0
void OrbitalBodyImposter::updatePhase(osg::Vec3 const &direction_to_sun, double ambient) {
	if (!getUpdateCallback()) {
		setUpdateCallback(m_PhaseShader->makeCallback(m_CoreTexture.get(), direction_to_sun, ambient));
	}
}