//Declaration of a graphic layer.
private IGlobeGraphicsLayer m_globeGraphicsLayer  = null;

//Create the graphic layer.
m_globeGraphicsLayer = new GlobeGraphicsLayerClass();
((ILayer)m_globeGraphicsLayer).Name = "DynamicObjects";

IScene scene = (IScene)m_globeDisplay.Globe;

//Add the new graphic layer to the globe.
scene.AddLayer((ILayer)m_globeGraphicsLayer, false);

//Activate the graphic layer.
scene.ActiveGraphicsLayer = (ILayer)m_globeGraphicsLayer;

//Create the element’s geometry.
IPoint point = new PointClass();
(IZAware(point)).ZAware = true;
point.PutCoords(position.longitude, position.latitude);
point.Z = position.altitude;

//Create the element’s color (red).
IRgbColor color = new RgbColorClass();
color.Red = 255;
color.Green = 0;
color.Blue = 0;

//Create the element’s symbol.
IMarkerSymbol markerSymbol = new SimpleMarker3DSymbolClass();
//Set the marker symbol's style and resolution.
((ISimpleMarker3DSymbol)markerSymbol).Style = esriSimple3DMarkerStyle.esriS3DMSSphere;
((ISimpleMarker3DSymbol)markerSymbol).ResolutionQuality = 1.0;
markerSymbol.Size = 700;
markerSymbol.Color = color as IColor;

//Create the new marker symbol’s element.
IElement trackElement = new MarkerElementClass();

//Set the element's symbol and geometry (location and shape).
((IMarkerElement)trackElement).Symbol = markerSymbol;
trackElement.Geometry = point as IPoint;

//Add the element to the graphic layer.
((IGraphicsContainer)globeGraphicsLayer).AddElement(trackElement, 0);

//Get the element by its index.
IElement elem = ((IGraphicsContainer3D)m_globeGraphicsLayer).get_Element(m_trackObjectIndex);

//Get the geometry of the element.
IPoint point = elem.Geometry as IPoint;

//Update the element's position.
point.PutCorrds(position.longitude, position.latitude);
point.Z = position.altitude; 
elem.Geometry = (IGeometry)point;

//Update the element in the graphic layer.
m_globeGraphicsLayer.UpdateElementByIndex(m_trackObjectIndex)

//Start listening to globe display events.
((IGlobeDisplayEvents_Event)m_globeDisplay).AfterDraw += new 
IGlobeDisplayEvents_AfterDrawEventHandler(OnAfterDraw);

private void OnAfterDraw(ISceneViewer pViewer)
{  
  //Test whether in drawing mode. 
  if(false == m_bDrawPoint)
    return;

  //Convert the mouse coordinate into a geocentric (OpenGL) coordinate system.
  double glX, glY, glZ;
  m_globeViewUtil.WindowToGeocentric(m_globeDisplay, m_sceneViewer, 
                                     m_srcX, m_srcY, true,
                                     out glX, out glY, out glZ);

  //Draw the converted point on the surface of the globe.
  GL.glPointSize(15.0f);
  GL.glColor3ub(255, 0, 0);
  GL.glBegin(GL.GL_POINTS);
     GL.glVertex3f((float)glX, (float)glY, (float)glZ);
  GL.glEnd();

public override void OnClick()
{
m_globeDisplay = (IGlobeDisplay3)m_globeHookHelper.GlobeDisplay;
//Start listening to globe display events.
((IGlobeDisplayEvents_Event)m_globeDisplay).AfterDraw += new IGlobeDisplayEvents_AfterDrawEventHandler(OnAfterDraw);
}

/// <summary>
/// GlobeDisplay's AfterDraw event handler.
/// </summary>
/// <param name="pViewer"></param>
private void OnAfterDraw(ISceneViewer pViewer)
{
 //AfterDraw event handler logic goes here.
}

//Loading 3D model from file.
IMarker3DSymbol marker3DSymbol = new Marker3DSymbolClass();
marker3DSymbol.CreateFromFile(path);

//Create a new 3D marker symbol.
IMarkerSymbol markerSymbol = new SimpleMarker3DSymbolClass();

//Set the marker symbol's style and resolution.
((ISimpleMarker3DSymbol)markerSymbol).Style = esriSimple3DMarkerStyle.esriS3DMSSphere;
((ISimpleMarker3DSymbol)markerSymbol).ResolutionQuality = 1.0;

//Set the symbol's size and color.
markerSymbol.Size = 700;
markerSymbol.Color = color as IColor;

private uint CreateDisplayList(IMarker3DSymbol marker3DSymbol)
{
   m_globeDisplay.DirectOpenGLDraw = true;
   GL.glMatrixMode(GL.GL_MODELVIEW);

   IDisplay display = (IDisplay)m_globeDisplay;
   IGlobeDisplayRendering globeDisplayRendering = (IGlobeDisplayRendering)m_globeDisplay;
   double globeRadiusMeters = globeDisplayRendering.GlobeRadius;

   //Calculate the symbol scale.
   double scale = 1.0 / globeRadiusMeters; //Normalized by the Globe Radius.

   uint intSymbolDisplayList = GL.glGenLists(1);
   GL.glNewList(intSymbolDisplayList, GL.GL_COMPILE);
   {
     GL.glDisable(GL.GL_COLOR_MATERIAL);
     GL.glPushMatrix();
     {
       GL.glScaled(scale, scale, scale);
       display.SetSymbol((ISymbol)marker3DSymbol);
     }
     GL.glPopMatrix();
     GL.glEnable(GL.GL_COLOR_MATERIAL);
   }
   GL.glEndList();

    m_globeDisplay.DirectOpenGLDraw = false;

    return intSymbolDisplayList;
}

IGlobeDisplayRendering globeDisplayRendering = (IGlobeDisplayRendering)m_globeDisplay;
double globeRadiusMeters = globeDisplayRendering.GlobeRadius;
double scale = 1.0 / globeRadiusMeters; //Normalized by the Globe Radius.

//Declaring the GlobeViewUtil.
private IGlobeViewUtil m_globeViewUtil = null;

//Cast GlobeViewUtil from the globe camera.
m_globeViewUtil = sceneViewer.Camera as IGlobeViewUtil;

//Convert a geographic coordinate to geocentric.
m_ipGlobeViewUtil.GeographicToGeocentric(longitude, latitude, altitudeMeters, 
out X, out Y, out Z);

//Convert geocentric to geographic.
m_ipGlobeViewUtil.GeocentricToGeographic(X, Y, Z, 
out longitude, out latitude, out altitudeMeters);

//Convert geocentric to window.
int winX, winY;
m_globeViewUtil.GeocentricToWindow(x, y, z, out winX, out winY);

//Convert window to geographic.
m_globeViewUtil.WindowToGeographic(m_globeDisplay, m_sceneViewer, X, Y, true, 
out lon, out lat, out alt);

private void CalculateSymbolOrientation(ISceneViewer sceneViewer, double glX, double glY, 
double glZ, out WKSPointZ orientation)
{
  m_vector3D.SetComponents(glX, glY, glZ);
  double inclination = m_vector3D.Inclination;
  double azimuth = m_vector3D.Azimuth;

  orientation.X = (-1.0 * inclination*(180.0/Math.PI)) + 180.0;
  orientation.Y = 0.0;
  orientation.Z = 180.0 - azimuth*(180.0/Math.PI);
}

void TranslateAndRotate(double glX, double glY, double glZ, WKSPointZ symbolOrientation, 
double udfAzimuth)
{
  GL.glTranslated(glX, glY, glZ);
  GL.glRotated(symbolOrientation.Z, 0.0, 0.0, 1.0);
  GL.glRotated(symbolOrientation.X, 1.0, 0.0, 0.0);
  GL.glRotated(symbolOrientation.Y, 0.0, 1.0, 0.0);
  GL.glRotated(udfAzimuth, 0.0, 1.0, 0.0);
}

public override void DrawImmediate(IGlobeViewer pGlobeViewer)
{   
   //Ensure the layer is visible and valid.
   if (!m_bVisible || !m_bValid)
      return;

   //Only once, create display lists and do other initializations.
   if (!m_bDisplayListCreated)
   {
      CreateDisplayLists();
   }

   //Get the GlobeDisplay.
   IGlobeDisplay globeDisplay = pGlobeViewer.GlobeDisplay;

   //Get the active viewer. 
   SceneViewer sceneViewer = globeDisplay.ActiveViewer;

   //Calculate the scale.
   IGlobeDisplayRendering globeDisplayRendering = IGlobeDisplayRendering)m_globeDisplay;
   double globeRadiusMeters = globeDisplayRendering.GlobeRadius;
   double scale = 1.0 / globeRadiusMeters;

   IGlobeDisplayRenderingPtr ipGlobeDisplayRend(pGlobeDisplay);

     double glX, glY, glZ;
   WKSPointZ wksSymbolOrientation;

   . . .

     //Translate the object into place.
   GL.glPushMatrix();
   {
     //Get the object’s OpenGL coordinate. 
     m_ipGlobeViewUtil.GeographicToGeocentric(obj.dLongitude, 
                                               obj.dLatitude, 
                                               obj.dAltitudeMeters, 
                                               out glX, out glY, out glZ);
     //Calculate the object’s orientation.
     CalculateSymbolOrientation(ipSceneViewer, glX, glY, glZ, 
                                wksSymbolOrientation);  

     //Translate the object into place and orient it.
     TranslateAndRotate(glX, glY, glZ, wksSymbolOrientation ,dblSymbolAngle); 

     //Set the object’s scale.
     GL.glScaled(dScale,dScale,dScale);

     //Draw the object.
     GL.glCallList(m_intMainSymbolDisplayList);       
   }
   GL.glPopMatrix();  
}

public bool AddItem(long zipCode, double lat, double lon) 
{
 double X = 0.0, Y = 0.0, Z = 0.0;    
 . . .
 DataRow r = m_table.Rows.Find(zipCode);
 if (null != r) //If the record with this ZIP Code already exists.
 {
   //Cache the item’s geocentric coordinate to save the calculation inside method 
DrawImmediate ().
   globeViewUtil.GeographicToGeocentric(lon, lat, 1000.0, out X, out Y, out Z);

   //Update the record.
   r[3] = lat;
   r[4] = lon;
   r[5] = X;
   r[6] = Y;
   r[7] = Z;

   lock (m_table)
   {
      r.AcceptChanges();
   }
 }
. . .
}

double dblObsX, dblObsY, dblObsZ, dMagnitude;
ICamera camera = pGlobeViewer.GlobeDisplay.ActiveViewer.Camera;

//Get the camera location in a geocentric coordinate (OpenGL coordsystem).
camera.Observer.QueryCoords(out dblObsX, out dblObsY);
dblObsZ = camera.Observer.Z;
      
IGlobeDisplayRendering globeDisplayRendering = IGlobeDisplayRendering)m_globeDisplay;
double baseExaggeration = globeDisplayRendering.BaseExaggeration;

double X = 0.0, Y = 0.0, Z = 0.0;
X = Convert.ToDouble(rec[5]);
Y = Convert.ToDouble(rec[6]);
Z = Convert.ToDouble(rec[7]);

m_ipVector3D.SetComponents(dblObsX - X, 
                           dblObsY - Y, 
                           dblObsZ - Z);

dMagnitude = m_ipVector3D.Magnitude;

double scale = dblMagnitude * baseExagFactor;

//If far away from the object, draw it as a simple OpenGL point.
if(scale > 2.5)
{
   GL.glPointSize(5.0f);
   GL.glColor3ub(0, 255, 0);
   GL.glBegin(GL.GL_POINTS);
      GL.glVertex3f(Convert.ToSingle(X), Convert.ToSingle(Y), Convert.ToSingle(Z));
   GL.glEnd();

}
else //When close enough, draw the full symbol.
{
  GL.glPushMatrix();
  {
     //Translate and orient the object into place.
     TranslateAndRotate(X,Y, Z, wksSymbolOrientation, dSymbolAngle);

     //Scale the object.
     GL.glScaled(dObjScale, dObjScale, dObjScale); 
      
     //Draw the object.       
     GL.glCallList(m_intMainSymbolDisplayList);
  }
  GL.glPopMatrix();  
}

private bool InsideViewport(double x, double y, double z, double clipNear, uint mode)
{

bool inside = true;

   //In selection mode, the projection matrix is changed.
   //Therefore, use the GlobeViewUtil because calling gluProject gives unexpected results.
   if (GL.GL_SELECT == mode)
   {
     int winX, winY;
     m_globeViewUtil.GeocentricToWindow(x, y, z, out winX, out winY);
     
     inside = (winX >= m_viewport[0] && winX <= m_viewport[2]) && 
              (winY >= m_viewport[1] && winY <= m_viewport[3]);

   }
   else
   {
        
      //Use gluProject to convert into the window’s coordinate.
      
unsafe
      {
         double winx, winy, winz;
         GLU.gluProject(x, y, z, 
                        m_modelViewMatrix, 
                        m_projMatrix, 
                        m_viewport, 
                        &winx, &winy, &winz);

         inside = (winx >= m_viewport[0] && winx <= m_viewport[2]) &&
                  (winy >= m_viewport[1] && winy <= m_viewport[3] &&
                  (winz >= clipNear && winz <= 1.0));
        }        
   }

   return inside;
}

//Get the OpenGL matrices.
GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX, m_modelViewMatrix);
GL.glGetIntegerv(GL.GL_VIEWPORT, m_viewport);
GL.glGetDoublev(GL.GL_PROJECTION_MATRIX, m_projMatrix);

//Get the OpenGL rendering mode.
uint mode;
unsafe
{
   int m;
   GL.glGetIntegerv(GL.GL_RENDER_MODE, &m);
   mode = (uint)m;
}

//Get the globe’s near clipping plane. The ClipNear value is required for the viewport filtering 
(since we don’t want to draw an item beyond the clipping planes).
IGlobeAdvancedOptions advOpt = m_globeDisplay.AdvancedOptions;

double clipNear = advOpt.ClipNear;

//Ensure the object is within the viewport.
if (!InsideViewport(X, Y, Z, clipNear, mode))
   continue;
//Continue with the drawings here.
. . .

//Class definition.
public abstract class GlobeCustomLayerBase : Control,
                                             ILayer,
                                             IGeoDataset,
                                             . . .
   //Class constructor.
   public GlobeCustomLayerBase()
   {  
      //Call CreateControl to create the handle.
      this.CreateControl();
   }

. . .

//Redraw delegate invokes the timer's event handler on the main thread.
private delegate void RedrawEventHandler();

//Set the layer’s redraw timer.
private System.Timers.Timer m_redrawTimer = null;

//Initialize the redraw timer.
m_redrawTimer = new System.Timers.Timer(200);
m_redrawTimer.Enabled = false;
//Wire the timer’s elapsed event handler.
m_redrawTimer.Elapsed += new ElapsedEventHandler(OnRedrawUpdateTimer);

//Redraw the timer’s elapsed event handler.
private void OnRedrawUpdateTimer(object sender, ElapsedEventArgs e)
{
   //Since this is the timer’s event handler, it gets executed on a different thread than the 
main one. Therefore, the Invoke call is required to force the call on the main thread 
and prevent cross apartment calls.
   if(m_bTimerIsRunning)
      base.Invoke(new RedrawEventHandler(OnRedrawEvent));  
}

//This method invoked by the timer’s elapsed event handler and gets executed on the 
main thread.
void OnRedrawEvent()
{
   m_globeDisplay.RefreshViewers();
}

//Declare the global timer.
private IGlobalTimer m_globalTimer = null;

public void DrawImmediate(IGlobeViewer pGlobeViewer)
{
   if(!m_bVisible || !m_bValid)
      return;
   . . .

   if(null == m_globalTimer)
   {
      m_globalTimer = new GlobalTimerClass();
      m_globalTimer.GlobeDisplay = pGlobeViewer.GlobeDisplay;
      if(m_globalTimer.RedrawInterval > 200)
         m_globalTimer.RedrawInterval = 200;
      m_globalTimer.Start();
   }
   . . .

private DataTable m_table = null;

public GlobeCustomLayerBase()
{
  m_table = new DataTable("RECORDS");

  //Add columns to the table.
  m_table.Columns.Add("ID",       typeof(long));
  m_table.Columns.Add("ZIPCODE",  typeof(long));
  m_table.Columns.Add("CITYNAME", typeof(string));
  m_table.Columns.Add("LAT",      typeof(double));
  m_table.Columns.Add("LON",      typeof(double));
  m_table.Columns.Add("X",        typeof(double));
  m_table.Columns.Add("Y",        typeof(double));
  m_table.Columns.Add("Z",        typeof(double)); 
   . . .
  
   //Set the columns’ properties.
  m_table.Columns[0].AutoIncrement = true;
  m_table.Columns[0].ReadOnly = true; 
   
  //Set the ZIP Code primary key for the table.
  m_table.PrimaryKey = new DataColumn[] { m_table.Columns["ZIPCODE"] };
  . . .

//Sequential access.
foreach (DataRow rec in m_table.Rows)
{
   lat  =  Convert.ToDouble(rec[3]);
   lon  =  Convert.ToDouble(rec[4]);
   X    =  Convert.ToDouble(rec[5]);
   Y    =  Convert.ToDouble(rec[6]);
   Z    =  Convert.ToDouble(rec[7]);
   . . .
}

//Random access, first make sure the item exists. 
//To call the Find()method, set columns as a primary key. 
DataRow r = m_locations.Rows.Find(zip);
if (null == r)

 . . .

//Add the current location to the location table.
DataRow r = m_locations.Rows.Find(zip);
if (null == r)
{
   r = m_locations.NewRow();
   r[1] = zip;
   r[2] = cityName;

   //Lock the location table to prevent access from other
   threads while adding the new record to the table. 
   lock (m_locations)
   {
      m_locations.Rows.Add(r);
   }
}

private System.Timers.Timer m_timer = null;

//Declare the invoke delegate.
private delegate void MessageHandler(IMessage msg);

//Set the update timer interval to 10MS.
m_timer = new System.Timers.Timer(10);
m_timer.Enabled = false;

//Wire the timer’s elapsed event.
m_timer.Elapsed += new ElapsedEventHandler(OnTimer);

//Pull the messages from the server.
private void OnTimer(object sender, ElapsedEventArgs e)
{
   try
   { 
      IMessage msg = m_internetServerConnection.getMessage(0);
      if(msg == null)
         break;

//Process the incoming message.
      this.Invoke(new MessageHandler(HandleMessage), new object[] { msg });
    }
    catch(Exception ex)
    {
       System.Diagnostics.Trace.WriteLine(ex.Message);
    }
}


//Handle the incoming message.
private void HandleMessage(IMessage msg)
{
   IDataMessage dataMessage = (IDataMessage)msg;
   int flightId = Convert.ToInt32(dataMessage.getColumn(1));
   . . . 
}

void ESRI.ArcGIS.esriSystem.IPersistVariant.Save(IVariantStream Stream)
{
 Stream.Write(m_name);
 Stream.Write(m_bValid);
 Stream.Write(m_bCached);
 Stream.Write(m_dblMinScale);
 Stream.Write(m_dblMaxScale);
 Stream.Write(m_bDrawDirty);
 Stream.Write(m_bShowIcon);
                
  Stream.Write(m_spRef);
 Stream.Write(m_extent);

 Stream.Write(m_extensions);
} 

void ESRI.ArcGIS.esriSystem.IPersistVariant.Load(IVariantStream Stream)
{
 m_name              = (string)Stream.Read();
 m_bValid             = (bool)Stream.Read();
 m_bCached          = (bool)Stream.Read();
 m_dblMinScale      = (double)Stream.Read();
 m_dblMaxScale     = (double)Stream.Read();
 m_bDrawDirty       = (bool)Stream.Read();
 m_bShowIcon       = (bool)Stream.Read();

 m_spRef              = (ISpatialReference)Stream.Read();
 m_extent             = (IEnvelope)Stream.Read();

 m_extensions        = (ArrayList)Stream.WiringRead();

 //Allocate a new vector 3D, do not worry about writing and reading...
 m_vector3D          = new Vector3DClass();
}

/// <summary>
/// The main update thread of the layer.
/// </summary>
private void ThreadProc()
{
  . . .
  
   //Serialize the tables onto the local machine.
  DataSet ds = new DataSet();
  //Add the in-memory tables to the data set.
  ds.Tables.Add(m_table);
  ds.Tables.Add(clonedTextureMap);
  //Write the data set to the local machine.
  ds.WriteXml(m_weatherXmlFile);
  
   ds.Tables.Remove(m_table);
  ds.Tables.Remove(clonedTextureMap);
  clonedTextureMap.Dispose();
  ds.Dispose();
  GC.Collect();
}

. . .
//Load the name to implement the HitTest method.
GL.glLoadName((uint)lZipCode); 
//Draw the item.
GL.glCallList(m_billboardRectList);

//Get the owner.
object owner = pHit3D.Owner;
       
//Ensure the owner is a weather layer.
if (!(owner is RSSWeatherLayer3DClass))
 return;

//Get the record by the ZIP Code received from the selection buffer. 
DataRow[] rows = m_table.Select("ZIPCODE = " + hitObjectID.ToString());
if (rows.Length == 0)
  return;

//Get the hit point from the Hit3D.
IPoint hitPoint = pHit3D.Point;

//Ensure the hit point is initialized.
if (null == hitPoint)
{
   double lat, lon, alt;
   lat = Convert.ToDouble(r[3]);
   lon = Convert.ToDouble(r[4]);
   alt = 1000.0;

   IPoint point = new PointClass();
   ((IZAware)point).ZAware = true;
   point.PutCoords(lon, lat);
   point.Z = alt;

   pHit3D.Point = point;
}

//Create a new PropertySet instance.
IPropertySet propSet = new PropertySetClass();

//Add the object’s information to the PropertySet.
propSet.SetProperty("ZIPCODE",         r[1]);
propSet.SetProperty("CITYNAME",       r[2]);
propSet.SetProperty("LATITUDE",        r[3]);
propSet.SetProperty("LONGITUDE",      r[4]);
propSet.SetProperty("TEMPERATURE",  r[8]);
propSet.SetProperty("DESCRIPTION",   r[9]);
propSet.SetProperty("DAY",               r[11]);
propSet.SetProperty("DATE",             r[12]);
propSet.SetProperty("LOW",              r[13]);
propSet.SetProperty("HIGH",              r[14]);
propSet.SetProperty("UPDATED",        r[16]);

//Pass the PropertySet to the caller.
pHit3D.Object = propSet;

public IArray Identify(IGeometry pGeom)
{
. . .

}

IEnvelope inEnv;
IArray array = new ArrayClass();

//Get the envelope from the geometry.
if (pGeom.GeometryType == esriGeometryType.esriGeometryEnvelope)
  inEnv = pGeom.Envelope;
else
  inEnv = pGeom as IEnvelope;

if (inEnv.IsEmpty)
  return array;

//Get the envelope’s center coordinate.
double xMin, xMax, yMin, yMax, zMin, zMax;
inEnv.QueryCoords(out xMin, out yMin, out xMax, out yMax);
zMin = inEnv.ZMin;
zMax = inEnv.ZMax;

double xC, yC, zC;
xC = (xMin + xMax) * 0.5;
yC = (yMin + yMax) * 0.5;
zC = (zMin + zMax) * 0.5;

ISceneViewer sceneViewer = m_globeDisplay.ActiveViewer;
ICamera camera = sceneViewer,Camera;

//Convert the coordinate into the window’s coordinate.
ISceneViewer sceneViewer = m_globeDisplay.ActiveViewer;
IGlobeViewUtil globeViewUtil = (IGlobeViewUtil)sceneViewer.Camera;

int winX, winY;
globeViewUtil.GeographicToWindow(xC, yC, zC * 1000.0, out winX, out winY);

IHit3DSet hits;
//Locate all items that fall within the given location.
m_globeDisplay.LocateMultiple(sceneViewer, winX, winY, true, false, false, false, out hits);

if (null == hits)
   return array;

IHit3D           hit3D      = null;
IPropertySet     propSet    = null;
IIdentifyObj     idObj      = null;
IIdentifyObject  idObject   = null;
bool             bIdentify  = false;

//Get all the hits from the Hit3Dset.
IArray objArray   = hits.Hits;
int    nCount     = objArray.Count;

//Iterate through the hit items and create identify objects.
for (int i = 0; i < nCount; i++)
{
   hit3D = objArray.get_Element(i) as IHit3D;  
   
//Make sure that the hit object type is a PropertySet.
   propSet = hit3D.Object as IPropertySet;
   if (null != propSet)
   {
//Instantiate the identify object and add it to the array.
      idObj = new GlobeWeatherIdentifyObject();
      
//Test whether the layer can be identified.
      bIdentify = idObj.CanIdentify((ILayer)this);
      if (bIdentify)
      {
         idObject = idObj as IIdentifyObject;
         idObject.PropertySet = propSet;
         array.Add(idObj);
      }
   }
}

//Return the array with the identify objects.
return array;

GL.glPushMatrix();
   //Translate to the item’s location.
   GL.glTranslatef(Convert.ToSingle(X), Convert.ToSingle(Y), Convert.ToSingle(Z));
   
   //Orient the icon so that it will face the camera.
   OrientBillboard();

   //Scale the item (original size is 1 unit).
   double useScale = 0.04 * dMagnitude;
   GL.glScaled(useScale, useScale, 1.0);

   GL.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
   //Loads the zip code onto the name stack.

   GL.glLoadName((uint)lZipCode);
   //Draw the item.
   GL.glCallList(m_billboardRectList);

   //If the object is selected, draw a box around it.
   if (bIsSelected)
   {
      GL.glColor4ub(255, 255, 128, 255);
      GL.glCallList(m_selectionDisplayList);
   }

   . . .
GL.glPopMatrix();

public void Select(long zipCode, bool newSelection)
{
   //If it is a new selection, unselect any selected items.
   if (newSelection)
   {
   //Unselect all the currently selected items.
      lock (m_table)
      {
        foreach (DataRow r in m_table.Rows)
        {
          r["SELECTED"] = false;
        }
          m_table.AcceptChanges();
      }
   }
      
   //Get the record from the table.
   DataRow[] rows = m_table.Select("ZIPCODE = " + zipCode.ToString());
   
   //Make sure the record exists.
   if (rows.Length == 0)
     return;

   DataRow rec = rows[0];
   //Set the selection flag to true.
   lock (m_table)
   {
     rec["SELECTED"] = true;
     rec.AcceptChanges();
   }
}

public override void OnMouseDown(int Button, int Shift, int X, int Y)
{
if(null == m_weatherLayer)
   return;

object owner;
object obj;

IPoint hitPoint;
//Get the globe display.
IGlobeDisplay globedisplay = ((IGlobe)m_scene).GlobeDisplay;

ISceneViewer sceneViewer = globedisplay.ActiveViewer;

//Call locate to HitTest the element in the current window coordinate.
globedisplay.Locate(sceneViewer, X, Y, false, false, out hitPoint, out owner, out obj);

if(obj != null)
{
   //Make sure the returned object is indeed a PropertySet.
   if(!(obj is IPropertySet))
   {
     return;
   }
   //Cast the object into a PropertySet.
   IPropertySet propset = obj as IPropertySet;
   if(propset == null)
     return;
                     
    //Make sure the owner is the right layer.
   if(!(owner is RSSWeatherLayer3DClass))
     return;   
                        
      //Get the ZIP Code.
   object o = propset.GetProperty("ZIPCODE");
   long zipcode = Convert.ToInt64(o);

     //Select the object.
   m_weatherLayer.Select(zipcode, Shift != 1);
}
}

private long          m_lItemToFlash  = -1L;
private static int   m_flashCount    = 0;
private static bool m_flashDraw     = true;

//Flash the required object.
if (lZipCode == m_lItemToFlash)
{
  if (m_flashCount > 10)//quit flashing after 10 draw cycles
  {
      m_lItemToFlash = -1;
      m_flashDraw = true;
      m_flashCount = 0;
  }
  else //Draw the flash symbol.
  {
     //Draw only on even cycles.
     if (m_flashDraw == true)      
     {
        GL.glCallList(m_intFlashSymbolList);
     }
    
      //Set the counter. 
      m_flashCount++;

     //Alternate the flash drawing.
     m_flashDraw = !m_flashDraw;
  }
}

//Get the system time.
long ticks = DateTime.Now.Ticks;

//Get the cached last update time.
long ticksSinceUpdate = r["UPDATETIME"];

//Get the object’s speed.
double speed = ref["SPEED"];

//Calculate the distance to the next object position; time is in seconds. 
dDist = speed * ((double)(ticks - ticksSinceUpdate) / 1000.0);

r["UPDATETIME"] = ticks;
. . .

//Get the globe radius.
IGlobeDisplayRendering globeDisplayRendering = (IGlobeDisplayRendering)m_globeDisplay;
double globeRadiusMeters = globeDisplayRendering.GlobeRadius;

//Calculate the angular distance in radians. 
double dblDistDD = (dblDistMeters/(globeRadius + dblAltMeters));

//Convert the distance from radians to decimal degrees.
dblDistDD *= (180.0/ Math.PI);