GlobeCore

Supported with:
  • Engine with 3D Analyst
  • ArcGIS for Desktop Basic with 3D Analyst
  • ArcGIS for Desktop Standard with 3D Analyst
  • ArcGIS for Desktop Advanced with 3D Analyst
  • Server with 3D Analyst
Library dependencies: Version, System, SystemUI, Geometry, GraphicsCore, Display, Server, Output, Geodatabase, GISClient, DataSourcesFile, DataSourcesGDB, DataSourcesOleDB, DataSourcesRaster, DataSourcesNetCDF, GeoDatabaseDistributed, GeoDatabaseExtensions, Carto, NetworkAnalysis, Location, GeoAnalyst, Animation, Maplex, Geoprocessing, NetworkAnalyst, Schematic, SpatialAnalyst, 3DAnalyst

Additional library information: Contents, Object Model Diagram

The GlobeCore library is the major library for working with the ArcGlobe application in ArcGIS 3D Analyst for three-dimensional (3D) visualization of multiresolution global data. The GlobeCore library contains objects for working with two-dimensional (2D) and 3D data displayed on the surface of a globe, similar to the Carto library containing objects for working with 2D maps.

See the following sections for more information about this namespace:

Globe
The Globe object is one of the main objects of the GlobeCore library. It's the container for data layers, similar to the Map object. The GlobeDisplay object, analogous to the SceneGraph coclass of the 3DAnalyst library, is a container for data caching and for events that occur in the globe. These events include those that occur when there is a change in the active view to those that trigger a notify data caching state. The GlobeDisplay object has a central role in that it also manages, specifies, and controls different optimization schemes of the application.
The GlobeCore library is also host to the GlobeCamera object that specifies the perspective of a 3D globe display rendering to define the positioning of the globe relative to the observer. In ArcGlobe, the 3D display window is represented by the GlobeViewer object. It is similar in its function and properties to the SceneViewer object in the 3DAnalyst library.
The GlobeLayerProperties class is one of the more important globe-specific layer extension classes that specifies, among other things, layer drawing priority on the surface of the globe. It also controls cache data removal behavior, cache data compression options and quality, image resampling modes, feature level of detail, and feature data drawing mode (raster versus vector), as well as suggests symbology scaling factor, estimates visibility distance thresholds, and determines data caching mode (on-demand versus full data cache). The GlobeHeightProperties class provides access to members that manipulate the height properties of a globe layer including those specific to feature layers (as vectors) such as extrusion, Z factor applied to elevation layers, and offset that can be applied to any layer. The GlobeAdvancedOptions object is the class that allows you to set advanced globe properties such as whether to use disk cache, control near and far clipping planes, control application level of detail that is applied at draw time only, the target frame rate for automatic control of display level of detail, and various attributes stored in the registry.
In addition, as with the Scene object, the Globe coclass contains AnimationTrack objects to make real time animation or video output by manipulating globe display and layer properties. There can be zero or more AnimationTrack objects in the Globe, which further contain one or more GlobeKeyframe objects. The AnimationTrack contains an AnimationType object. Through these objects, you can control the behavior and type of animations. 
The Globe coclass is detailed in the following diagram:
GlobeControl and a set of globe commands exist in the Controls library, together with ToolbarControl, TOCControl, and helper objects for creating custom commands.
Globe functionality
There are similarities between the Scene and Globe coclasses. The Globe object has properties that operate on all layers within the globe—spatial reference, scale, and so on—along with methods that manipulate the globe's layers. One major difference between the Globe object and Scene (and Map) object is that as a prerequisite, any layer to be used in the application must have a spatial reference defined to it.
There are many types of layers that can be added to the globe. Different data sources often have an associated layer responsible for displaying the data on the globe; vector features are handled by the FeatureLayer object, raster data (both image and surface data) by the RasterLayer, and so on. Layers can, if required, handle all the drawing operations for their associated data, but it is more common for layers to have an associated renderer object. The properties of the renderer object control how the data is displayed in the globe. Renderers commonly use symbols from the Display library for the actual drawing, the renderer simply matches a particular symbol with the properties of the entity that is to be drawn.
Similar to the Carto library, the GlobeCore library also contains support for annotation and globe tips. The Globe coclass is a container for display and manipulation of data on the surface of the globe. The Globe object contains one major interface, IGlobe, along with many other important inherited interfaces required for manipulation and access of data, such as IBasicMap, IBasicScene, IScene, ISceneBookmarks, and IAnimationTracks.
The IGlobe interface gives you access to basic globe properties and methods, such as GlobeLayers, and to properties and methods of the globe itself. Use this interface to add layer types (AddLayerType) according to their category—floating, draped, or elevation (esriGlobeLayerType); access globe background options (DefaultGlobeBackgroundOption), including sky and space colors (GetDefaultHighBackgroundColor, GetDefaultLowBackgroundColor, SetDefaultHighBackgroundColor, and SetDefaultLowBackgroundColor); show fading transition values (GetDefaultBackgTransitionDistances and SetDefaultBackgTransitionDistances); show globe tips (ShowGlobeTips); and designate the linear units used in the globe (GlobeUnits).

GlobeDisplay
GlobeDisplay is a central object in ArcGlobe. It provides access to basic properties of the globe and layers to more advanced aspects of the application, including management of viewers, rendering, and data caching. The GlobeDisplay coclass has four major interfaces: IGlobeDisplay, IGlobeDisplayRendering, IGlobeDisplayLayers, and an inherited interface, IViewers3D.
Data tiling
ArcGlobe is an application that has highly optimized data tiling, level of detail management, and data caching architecture. Managed by the GlobeDisplay object and common to all datasets, there is a division of data in quadrilateral areas of the globe called tiles. At the lowest level, the entire globe is divided into six major areas called face tiles. These consist of four near the equator and two at the poles as shown in the following illustration:
Part of the application's notion of level of detail stems from the fact that these tiles are recursively subdivisible. At any particular level of detail, the area covered by any tile is equal to four levels at the next level to a maximum resolution of the data set. Each of the six major faces is then divided into multiple tiles at different levels of detail. This data organization is called data tiling. The ArcGlobe data tiling scheme is shown in the following illustration.
Data caching
The GlobeDisplay object has a central role in managing and controlling tile generation and in the subsequent storing of data tiles for future use, called data caching. Data tiles are always stored in a memory cache and, optionally, in a disk cache. The main advantage of data caching is the improvement of visualization performance, as well as the reduction of repetitive data requests from data sources. The tile generator, IGlobeDisplayLayers.GenerateTiles, is used to preprocess data both in off-line mode, called full caching, and in an interactive on-demand mode, called on demand data caching.
Each data tile will be stored into memory and optionally onto disk for future use. Using data caching improves visualization performance. The ArcGlobe data caching structure is shown in the following diagram:
General globe properties
General globe properties are accessed via the IGlobeDisplayRendering interface. Commonly used globe properties include vertical exaggeration, background color, and sun position. The IGlobeDisplayLayers interface provides access to globe-specific layer properties as well as general purpose functions. From GlobeDisplay, you gain access to one or more globe viewers being used by the application. These are the 3D display windows. You can change the perspective displayed in a globe viewer through its GlobeCamera. The GlobeDisplay can be acquired from an ArcGlobe document's Globe object via IGlobe.GlobeDisplay.
Most of the members from the IGlobeDisplayLayers interface are used for internal purposes. You should not use members from this interface; you should use methods and properties from IGlobeLayerProperties.
IViewers3D provides access to members that control the active viewer, indicates the 3D display navigation mode, controls redrawing into all viewers, as well us registers and unregisters additional viewers.

GlobeViewer
Similar to a scene viewer, the globe viewer is a 3D display window in ArcGlobe. See the Scene and globe viewer section in the 3DAnalyst library overview.

GlobeLayerProperties
The GlobeLayerProperties coclass is the layer extension that contains globe-specific layer properties, such as a layer drawing priority on the surface of the globe, exposed as IGlobeLayerProperties.BaseImageDrawingPriority. This value relates to the position of the layers that are part of the base globe (that is, draped layers and elevation layers) in the drawing order. To get an ordered list of layers in the base globe, use IGlobeDrawingOrder.OrderedLayers. 
Elevation layers are always on top of the ordered list followed by draped layers.
The GlobeLayerProperties object also controls the layer's cache data removal behavior via IGlobeLayerProperties.CacheRemovalOption. The default setting is the cache to be removed when exiting the application or removing the layer.
The IGlobeLayerProperties.IsDynamicallyRasterized property indicates if the feature data is to be rasterized. Feature layers will be treated as rasterized if this property is set to True. By default, all 2D feature data is rasterized, whereas 3D data (including multipatch feature classes) will be treated as vectors. One would get advanced symbology support (any symbology supported in ArcMap will be honored when a feature layer is treated as rasterized) as well as better draping of feature data onto the surface of the globe, especially if elevation data is present.
Symbol sizes that are usually expressed in terms of points will need to have a scaling factor when used in an application that uses real world units. The IGlobeLayerProperties.SymbologyScalingFactor property is the scaling factor of meters-per-point to be applied to symbol sizes during rasterization. This means that a symbol with a size of 8 points would be converted to real world units multiplied by the factor as suggested by IGlobeLayerProperties.SymbologyScalingFactor.
Visibility distance thresholds, IGlobeLayerProperties.MaximumDistance and IGlobeLayerProperties.MinimumDistance govern the distance where a layer becomes visible. These values are automatically set for feature data when the IGlobeLayerProperties.MaxFeatureLevelOfDetail property is set. You will be prompted to set this value when adding feature data to the application, especially if the data is to be treated as vector. Similarly, you need to explicitly set this property when adding feature data to the application. See the following code:
[C#] 
IGlobe glbDisplay;
IGlobeDisplayLayers globeDispLayers;
IGlobeLayerProperties globeLayerProps;
globeDispLayers = (IGlobeDisplayLayers)glbDisplay;
ILayer layer;
IEnumLayer enumLayer;
enumLayer = glbDisplay.get_GlobeLayers(null, false, true, true);
//Return all the layers in the base globe sorted by drawing priority.
layer = enumLayer.Next();
{
    globeLayerProps = globeDispLayers.FindGlobeProperties(layer);
    int maxLod = 0;
    int LOD = 2; //Set it to a preferred LOD value.
    while (layer != null)
        if (globeLayerProps.maxLOD ==  - 1)
    // A value of -1 indicates that the level of detail is not yet set.
            globeLayerProps.maxLOD = LOD;
    globeDispLayers.RefreshLayer(layer);
    layer = enumLayer.Next();
}
[VB.NET] 
Private glbDisplay As IGlobe
Private globeDispLayers As IGlobeDisplayLayers
Private globeLayerProps As IGlobeLayerProperties
globeDispLayers = CType(glbDisplay, IGlobeDisplayLayers)
Dim layer As ILayer
Dim enumLayer As IEnumLayer
enumLayer = glbDisplay.get_GlobeLayers(Nothing, False, True, True)
'Return all the layers in the base globe sorted by drawing priority.
layer = enumLayer.Next()
globeLayerProps = globeDispLayers.FindGlobeProperties(layer)
Dim maxLod As Integer = 0
Dim LOD As Integer = 2 'Set it to a preferred LOD value.
Do While Not layer Is Nothing
    If globeLayerProps.maxLOD = -1 Then ' A value of -1 indicates that the level of detail
        'is not yet set.
        globeLayerProps.maxLOD = LOD
    End If
Loop
globeDispLayers.RefreshLayer(layer)
layer = enumLayer.Next()

GlobeCamera
GlobeCamera defines the global and perspective viewing of data on the globe. Use the GlobeCamera object to obtain observer and target positions rather than the Camera object because GlobeCamera works with latitude and longitude values instead of a local coordinate system. IGlobeCamera is the major interface with properties and methods to control navigation orientation (IGlobeCamera.OrientationMode), the offset for the roll angle in degrees (IGlobeCamera.RollOffset), and to get and set observer and target positions as a combination of latitude and longitude in decimal degrees plus altitude in kilometers (IGlobeCamera.SetObserverLatLonAlt [latDD, lonDD, altKMs] and IGlobeCamera.SetTargetLatLonAlt [latDD, lonDD, altKMs]). In addition, IGlobeCamera.GetLocalOrientation (plocalAzi, pLocalIncl, pLocalRoll) gets the azimuth, inclination, and roll angles relative to the current target on surface. 

GlobeServer
The GlobeServer coclass gives you access to an ArcGIS Globe layer bound to a GlobeServer object. It also allows globe server layers to be queried and identified (via the Find and Identify methods). GlobeServer can be used in desktop or Internet development environments. In a desktop environment, GlobeServer objects can be created in-process within your application. GlobeServer objects are run within ArcGIS Server.
ArcGIS for Desktop and ArcGIS Engine developers can also consume server objects via the Server API. To work with the fine-grained ArcObjects, you must use the Server API. You can use GISServerConnection to connect to the geographic information system (GIS) server, or you can obtain a reference to ServerObjectManager through GISClient (TCP/IP connection only).
The GlobeServer coclass contains several important interfaces with basic functions for starting and stopping an ArcGIS Server (IObjectActivate), for initializing a globe server object from an ArcGlobe document (*.3dd file), and methods for defining the physical and virtual directories of a Web service (IGlobeServerSetup) as well as an interface (IGlobeServerObjects) for getting an ArcGIS globe layer.
The IGlobeServer interface contains methods for performing query and find on an ArcGIS globe server layer. In addition, IGlobeServer also contains methods for getting components of a globe server layer, such as animation files, tiles, and associated textures either as a uniform resource locator (URL) or as binary data. The GlobeServer coclass is also home to the IRequestHandler and IRequestHandler2 interfaces that provide access to members that control handling of request messages (binary or SOAP).

GlobeServerLayer
The GlobeServerLayer coclass allows you access to an ArcGIS globe server layer, which is the basic component of an ArcGIS globe service.
The GlobeServerLayer coclass contains several interfaces. Some of the more important ones include the following:
  • IGlobeServerLayer—Encapsulates methods for connecting to an ArcGIS Server and properties for querying layer properties.
  • ILayerEffects—Provides properties to manipulate layer transparency.
  • ICompositeLayer—Provides a Count property returning the exact layer count in GlobeServerLayer.
Unlike a map server layer, calls to get the layer count, or layer transparency, will be honored and applied. Since the working components of a globe server are layers, you have access to each individual layer's properties. Furthermore, GlobeServerLayer is different from MapServerLayer in that it supports being expanded via the Expanded property of ICompositeLayer2. This, in effect, enables globe server layers to be accessed pursuant to the layer level. This is an integral property of GlobeServerLayer because it allows you to "mix and match" layers from different globe services and consume them as separate entities. 
Other notable interfaces implemented by the GlobeServerLayer class include the following:
  • ILayerExtensions—Provides methods and properties to add layer extensions.
  • ILayerPosition—Provides a property to get or set a layer's drawing position in the globe.
  • IPublishLayer—Enables GlobeServerLayers to support publishing.

GlobeLayerInfo
The GlobeLayerInfo coclass can be considered the globe server layer equivalent of the GlobeLayerProperties class, which is an important layer extension object that contains globe-specific layer properties. The bulk of the properties of GlobeLayerInfo are members of IGlobeLayerInfo. Some of these members include layer drawing priority on the surface of the globe, exposed as IGlobeLayerInfo.BaseImageDrawingPriority and IGlobeLayerInfo.DataType, which describes the type of layer (raster, elevation, or feature data).
GlobeLayerInfos
GlobeLayerInfos is a container class for GlobeLayerInfo that provides detailed information about a globe server layer.

GlobeServerIdentifyResult, GlobeServerIdentifyResults, GlobeServerFindResult, and GlobeServerFindResults
The GlobeServerIdentifyResult coclass provides information about an identify result.
GlobeServerIdentifyResults is a container class for GlobeServerIdentifyResult that allows access to elements of GlobeServerIdentifyResult.
The GlobeServerFindResult coclass provides information about a find result.
GlobeServerFindResults is a container class for GlobeServerFindResult that provides a collection of find results.
GlobeServerLayerFactory
The GlobeServerLayerFactory coclass provides access to the available properties of a layer factory for globe server layers.

GlobeHeightProperties

The GlobeHeightProperties object is contained in the GlobeLayerProperties coclass. There is only one GlobeHeightProperties object at any time. Access to a layer's elevation property is obtained through the GlobeHeightProperties coclass. This coclass is important in that it's through this object that a layer gets its height property and, accordingly, its display location in the type tab of the application.
In ArcGlobe, there are three categories to which a layer can belong as shown in the following list:
  • Draped layers are layers that are draped on the surface of the globe. These can be feature layers or raster layers.
  • Floating layers are layers that do not drape onto the surface of the globe but have an offset. Offsets can be defined by a constant or expression. 
  • Elevation layers are raster layers that define the surface of the globe.
These layers are shown in the following screen shot:
 
 
IGlobeHeightProperties.Offset is a constant value that can be applied to any layer in the draped or floating layers categories. Neither feature layers nor raster images can have an offset if they are in the draped layers category. They need to be part of the floating layers category to use this property. Only feature layers treated as vectors honor IGlobeHeightProperties.Offset while still part of the draped layers category. Similarly, IGlobeHeightProperties.ElevationExpressionString and IGlobeHeightProperties.ElevationExpression, with a constant or an expression value to define any feature layer's elevation, apply to feature layers as vectors.
IGlobeHeightProperties.HasElevationValues, a Boolean that indicates whether the feature layer has Z values, is one of the properties that can be used to define a layer's Z placement. Feature layers (as vectors) can have extrusion factors to convert a 2D feature layer into a 3D object (multipatch) by applying a conversion factor via IGlobeHeightProperties.ExtrusionExpression or IGlobeHeightProperties.ExtrusionExpressionString. 

GlobeAdvancedOptions
The GlobeAdvancedOptions object is used to manipulate ArcGlobe’s advanced visualization and cache data management options.
Using the IGlobeAdvancedOptions interface, you can access the following properties and methods:
  • CachePath—The path to the globe data cache on the local machine.
  • ClipFarFactor—Far clipping plane that aids in performance optimization by clipping areas that do not fall within the application's view.
  • ClipNear—Near clipping plane that aids in performance optimization by clipping areas that do not fall within the application's view.
  • DefaultUse16ColorBits—Default value for image color compression.
  • DefaultUse16ElevBits—Default value for elevation compression. 
  • GetDefaultCompression—Gets default lossy compression option for a data type and its quality from 1 to 100.
  • GetUseCache—Gets disk cache option and cache size.
  • LevelOfDetail—The level of detail (LOD) of image and elevation layers that's applied during display.
  • ManualLOD—A Boolean that indicates if manual LOD control is on.
  • RestoreClipPlaneDefaults—Restores the default clipping plane settings.
  • RestoreLODDefaults—Restores the default LOD settings. 
  • SetDefaultCompression—Sets default lossy compression option for a data type and its quality from 1 to 100.
  • SetUseCache—Sets disk cache option and cache size.
  • TargetFrameRate—The target frame rate when using automatic control of LOD.
  • WriteToRegistry—Commits the changes to the system's registry.

GlobeLegendInfo and GlobeLegendInfos
The GlobeLegendInfo coclass provides information about a globe layer. The legend information provided by a layer is usually provided by the renderer.
GlobeLegendInfos is a container class for GlobeLegendInfo, which provides information about a globe layer.

GlobeLayer
The GlobeLayer coclass is used internally and you should not use it. It will be deprecated in future releases. You should use the abstract Layer class and add layer extensions, such as GlobeLayerProperties, and GlobeLayerHeight objects to a layer to access globe-specific properties.
The two ways to achieve that are as follows:
  • When a layer is added to an ArcGlobe application, the GlobeLayerProperties layer extension and GlobeLayerHeight object are automatically added to it with default values, and you can access the properties and methods available from these objects. See the following code:
[C#] 
IDocument document = null;
IScene scene = null;
IRasterLayer pRasLayer = null;
ILayer layer = null;
layer = pRasLayer;
IGlobe globe = null;
IGMxDocument gMxDoc = null;
gMxDoc = (IGMxDocument)document;
globe = (IGlobe)scene;
globe.AddLayerType(layer, esriGlobeLayerType.esriGlobeLayerTypeElevation);
[VB.NET] 
Dim document As IDocument
Dim scene As IScene
Dim pRasLayer As IRasterLayer
Dim layer As ILayer
layer = pRasLayer
Dim globe As IGlobe
Dim gMxDoc As IGMxDocument
gMxDoc = CType(document, IGMxDocument)
globe = CType(scene, IGlobe)
globe.AddLayerType(layer, esriGlobeLayerType.esriGlobeLayerTypeElevation)
  • After co-creating a layer, you must explicitly add the GlobeLayerProperties layer extension and GlobeLayerHeight object before adding the layer to the application. It is important to note that when adding a feature data pragmatically, especially feature data as vector, you need to set the LOD to a preferred value. When adding a layer from the application, users will be forced to set LOD values before displaying any feature data as vector. The following code shows how to add the GlobeLayerProperties layer extension and the GlobeLayerHeight object and illustrates how to set some of the globe-specific properties of a layer before adding it to an ArcGlobe application:
[C#] 
try
{
    //Open an ArcGlobe session, and add the layer to the application.
    IApplication application = null;
    IDocument document = null;

    //pDoc = New GMxDocument
    application = document.Parent;
    //Make the ArcGlobe session visible.
    application.Visible = true;
    IObjectFactory objectFactory = null;
    objectFactory = (IObjectFactory)application;
    UID pUID = new UID();
    string SID = null;
    IRasterLayer rasterLayer = null;

    SID = "esricarto.RasterLayer";
    pUID.Value = SID;
    rasterLayer = (IRasterLayer)(objectFactory.Create(pUID));
    rasterLayer.CreateFromFilePath("D:\\ArcGlobe\\redlands\\gdredlands");
    //Create the GlobeLayerProperties extension.
    IGlobeLayerProperties glbLyrPrp = null;
    SID = "esriglobecore.GlobeLayerProperties";
    glbLyrPrp = (IGlobeLayerProperties)(objectFactory.Create(SID));

    //Set some of the properties.
    glbLyrPrp.Type = esriGlobeDataType.esriGlobeDataElevation;
    //This will force the raster to be an elevation source.
    glbLyrPrp.ImageSamplingMode =
        esriGlobeImageSamplingMode.esriGlobeImageSamplingNearest;
    //Will not be honored for elevation data.
    glbLyrPrp.PutLossyCompressionOption(true, 70);
    glbLyrPrp.Use16ElevationBits = false;

    //Create GlobeHeightProperties.
    IGlobeHeightProperties glblyrHghtProp = null;
    SID = "esriglobecore.GlobeHeightProperties";
    glblyrHghtProp = (IGlobeHeightProperties)(objectFactory.Create(SID));
    //Set some of the properties.
    glblyrHghtProp.ZFactor = 0.0348; //Apply factor to convert from feet to meters.
    //Add the layer height properties.
    glbLyrPrp.HeightProperties = glblyrHghtProp;
    //Add the extension.
    ILayer layer = null;
    ILayerExtensions lyrExt = null;
    layer = rasterLayer;
    lyrExt = (ILayerExtensions)layer;
    lyrExt.AddExtension(glbLyrPrp);

    //Check to see if the extension was added.
    for (int j = 0; j < lyrExt.ExtensionCount; j++)
    {
        if (lyrExt.Extension[j] is IGlobeLayerProperties)
        {
            glbLyrPrp = (IGlobeLayerProperties)(lyrExt.Extension[j]);
            Debug.Print(System.Convert.ToString(lyrExt.ExtensionCount));
        }
    }
    IGlobeDisplay glbDisp = null;
    IGlobe globe = null;
    IScene scene = null;
    IGMxDocument gmxdoc = null;
    gmxdoc = (IGMxDocument)document;
    scene = gmxdoc.Scene;
    globe = (IGlobe)scene;
    glbDisp = globe.GlobeDisplay;
    IGlobeDisplayLayers glbdispLyr = null;
    glbdispLyr = (IGlobeDisplayLayers)glbDisp;
    IGlobeLayerProperties glbLyrPropsCurr = null;

    //Query to see if the GlobeLayer property, as set above, is honored.
    //By default, when a raster layer is added, it will be treated as an image.
    //However, since you set glbLyrPrp.Type = esriGlobeDataElevation, 
    //it should be added as an elevation layer.
    glbLyrPropsCurr = glbdispLyr.FindGlobeProperties(layer);
    esriGlobeDataType glbdatatype = null;
    glbdatatype = glbLyrPropsCurr.Type;
    Debug.Print(System.Convert.ToString(glbdatatype));
    gmxdoc.Addlayer(layer);
    return ;
}

catch (Exception ex)
{
    Debug.Print(ex.Message);
}
[VB.NET] 
Sub AddLyrExtension()
    
    Try
    'Open an ArcGlobe session, and add the layer to the application.
    Dim application As IApplication
    Dim document As IDocument
    
    'pDoc = New GMxDocument
    application = document.Parent
    'Make the ArcGlobe session visible.
    application.Visible = True
    Dim objectFactory As IObjectFactory
    objectFactory = CType(application, IObjectFactory)
    Dim pUID As New UID
    Dim SID As String
    Dim rasterLayer As IRasterLayer
    
    SID = "esricarto.RasterLayer"
    pUID.Value = SID
    rasterLayer = CType(objectFactory.Create(pUID), IRasterLayer)
    rasterLayer.CreateFromFilePath("D:\ArcGlobe\redlands\gdredlands")
    
    'Create the GlobeLayerProperties extension.
    Dim glbLyrPrp As IGlobeLayerProperties
    SID = "esriglobecore.GlobeLayerProperties"
    glbLyrPrp = CType(objectFactory.Create(SID), IGlobeLayerProperties)
    'Set some of the properties.
    glbLyrPrp.Type = esriGlobeDataType.esriGlobeDataElevation
    'This will force the raster to be an elevation source.
    glbLyrPrp.ImageSamplingMode = esriGlobeImageSamplingMode.esriGlobeImageSamplingNearest
    'Will not be honored for elevation data.
    glbLyrPrp.PutLossyCompressionOption(True, 70)
    glbLyrPrp.Use16ElevationBits = False
    'Create GlobeHeightProperties.
    Dim glblyrHghtProp As IGlobeHeightProperties
    SID = "esriglobecore.GlobeHeightProperties"
    glblyrHghtProp = CType(objectFactory.Create(SID), IGlobeHeightProperties)
    'Set some of the properties.
    glblyrHghtProp.ZFactor = 0.0348 'Apply factor to convert from feet to meters.
    'Add the layer height properties.
    glbLyrPrp.HeightProperties = glblyrHghtProp
    
    'Add the extension.
    Dim layer As ILayer
    Dim lyrExt As ILayerExtensions
    layer = rasterLayer
    lyrExt = CType(layer, ILayerExtensions)
    lyrExt.AddExtension(glbLyrPrp)
    
    'Check to see if the extension was added.
    For j As Integer = 0 To lyrExt.ExtensionCount - 1
        If TypeOf lyrExt.Extension(j) Is IGlobeLayerProperties Then
            glbLyrPrp = CType(lyrExt.Extension(j), IGlobeLayerProperties)
            Debug.Print(CStr(lyrExt.ExtensionCount))
        End If
    Next
    
    Dim glbDisp As IGlobeDisplay
    Dim globe As IGlobe
    Dim scene As IScene
    Dim gmxdoc As IGMxDocument
    gmxdoc = CType(document, IGMxDocument)
    scene = gmxdoc.Scene
    globe = CType(scene, IGlobe)
    glbDisp = globe.GlobeDisplay
    Dim glbdispLyr As IGlobeDisplayLayers
    glbdispLyr = CType(glbDisp, IGlobeDisplayLayers)
    Dim glbLyrPropsCurr As IGlobeLayerProperties
    
    'Query to see if the GlobeLayer property, as set above, is honored.
    'By default, when a raster layer is added, it will be treated as an image.
    'However, since you set glbLyrPrp.Type = esriGlobeDataElevation,
    'it should be added as an elevation layer.
    glbLyrPropsCurr = glbdispLyr.FindGlobeProperties(layer)
    Dim glbdatatype As esriGlobeDataType
    glbdatatype = glbLyrPropsCurr.Type
    Debug.Print(CStr(glbdatatype))
    gmxdoc.Addlayer(layer)
    Exit Sub
    Catch ex As Exception
    Debug.Print(ex.Message)
    End Try
    
End Sub