Implementing custom globe layers with dynamic feed

//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 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 you do not 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 dataset.
    ds.Tables.Add(m_table);
    ds.Tables.Add(clonedTextureMap);
    //Write the dataset 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 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 faces 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);