A new overview, available in our online help, explains how to use the solid primitive, including using visual cues such as the white silhouette edge and removal of back facing lines shown above.  The polyline and point batch primitive now have an optional outline with a unique size, color, and translucency.  This small feature adds a nice visual cue:

Download AGI Components 2010 r1 from ADN and give these new features a try.

All surface images in Insight3D are placed on the Earth where the edges of the image align with latitudinal and longitudinal lines and the top edge is north.  Several customers have asked if they could map an image where that is not the case, where they have the latitude and longitude coordinates of each corner.

Fig. 1 shows an image captured from the viewpoint of a simulated UAV camera.  While the image itself is exactly as it was, the image is not correctly positioned on the terrain.  As mentioned, the image edges align with latitudinal and longitudinal lines. 

Fig. 1

In fig. 2, the image’s corners have been mapped from their original coordinates to their actual coordinates. One can tell that the camera took this image from the southwest.

Fig. 2

This capability has been added to Insight3D’s  Surface Mesh Primitive for our upcoming r8 release.  I’ll wait until r8 is out to discuss the new interfaces and how this method differs from projecting an image onto the terrain.

In this post, I’ll discuss how we use OpenGL to remap the image of fig. 1 to that of fig. 2.

Perspective Texture Projection

The goal is to remap the texture coordinates from one trapezoid to another.  Let’s begin with an example.  Fig 3a shows an image, a blue square with a red border, mapped to a square, while the other figures show a remapping of that square to a trapezoid with an outline of the original square shown as reference.

a. Original                      b. Orthographic                   c. Perspective

Fig. 3

One obvious way to map to the trapezoid would be to just move the vertices.  In fig 3b, the vertex positions have been moved while the texture coordinates remain that same as in fig 3a.  This results in an orthographic projection where the texture coordinates are linearly interpolated across the trapezoid.  Given that we want a perspective projection, this is incorrect.

In fig 3c, the vertex positions have been moved, and the texture coordinates have been altered.  This trapezoid appears to be a rectangle closer to the viewer on the left side and farther away on the right; however,  the trapezoid is actually in a plane perpendicular to the viewer, i.e. flat to your display.  A perspective transform has been applied to the texture coordinates.  This is how the UAV image should be placed onto the terrain.  How is this transform computed?

The Texture Matrix

A texture coordinate is defined by the vector (s, t, r,  q).  Most graphics developers are familiar with using s and t to map a 2D texture to a triangle; in this case, r and q default to 0 and 1 respectively.  The value r is used for 3D textures and so is ignored here.  I’ll get to q in a moment.

In the OpenGL fixed function pipeline, each texture coordinate (s, t, r,  q) is multiplied by a 4x4 texture matrix as shown in eq. 1.

Eq. 1

Since OpenGL interprets (s’, t’, r’, q’) as a homogeneous coordinate, s’, t’,  and r’ are next divided by q’ as shown in eqs. 2, 3 and 4.  This is the perspective divide, and is necessary to produce fig 3c.

Eqs. 2, 3, 4

Coordinate (s’’, t’’, r’’) is used to sample the texture.  For a 2D texture, only s’’ and t’’ are used.

Computing the Texture Matrix

Remapping requires a texture matrix that maps (s, t) in fig 3c to (s’’, t’’) in fig. 3a.

Since only a 2D texture is being considered, the 3D components of the matrix and vectors are zeroed out; m₄₄ is set to 1 as this is a homogenous matrix; m₃₃ is inconsequential as that value is multiplied by 0 in the matrix multiplication.

Eq. 5

After multiplication,

Eqs. 6, 7 , 8

After multiplying both sides of eqs. 2 and 3 by q’, and then plugging in eqs. 6, 7, and 8,

Eqs. 9, 10

Eqs. 9 and 10 are rearranged to form two linear equations.

Eqs. 11, 12

There are eight unknown matrix components to solve.   The mapping for the corners to go from figs. 3c to 3a are:

Fig 4.

This yields eight equations with eight unknowns. Using a linear equation solver, the texture matrix can be computed.

Applying the Texture Matrix

If you are using the OpenGL fixed function pipeline, after loading this matrix to the OpenGL matrix stack, there are two basic ways to render the texture and geometry.

You can move the vertex positions and use the (s, t) texture coordinates.

Alternatively, you could keep the original vertex positions and (s’’, t’’) texture coordinates.  You will have to specify a border color for the texture.

float borderColor[4] = {126.0f, 126.0f, 126.0f, 0.0f};
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);

When rendering, you must enable the alpha test.

glAlphaFunc(GL_GREATER, 0.0f);
glEnable(GL_ALPHA_TEST);

If you do not, the texture will bleed beyond its border as shown in fig. 5.

Fig. 5

Of course if you are using shaders instead of the fixed function pipeline, you can still easily do either way.  There are various other combinations that will work too.

Our unique method for rendering the surface mesh primitive requires that we use the second method.

Footnoticed

Benjamin Supnik’s blog posts on this topic here and here were very helpful.  He explains much of what I have and more.  Hopefully though, I have added to understanding this topic.

The second example orients a satellite model in orbit:

Orienting using Reference Frames

In many cases, particularly those where a model is stationary on the ground, a model can be oriented by simply setting its ReferenceFrame property.  The following example loads a launch pad model at Cape Canaveral.  What is going on with its default orientation?

Cartographic position = new Cartographic(Trig.DegreesToRadians(-80.577778), Trig.DegreesToRadians(28.488889), 0);
ModelPrimitive model = new ModelPrimitive("delta4-lp.mdl");
model.PositionCartographic = position;
SceneManager.Primitives.Add(model);

Since the model primitive, like all primitives, has a default reference frame of the Earth's fixed frame.  The model is oriented using the Earth's fixed frame's axes.  In this case, the tower is aligned with +z.  How do I know that?  I used the handy ReferenceFrameGraphics helper class that is available in the HowTo:

EarthCentralBody earth = CentralBodiesFacet.GetFromContext().Earth;
PointCartographic origin = new PointCartographic(earth, position);
ReferenceFrame referenceFrame = new ReferenceFrame(origin, model.ReferenceFrame.Axes);
new ReferenceFrameGraphics(referenceFrame, 45);

The ReferenceFrameGraphics object created a visualization of the primitive's reference frame's axes using the primitive's position as the origin.   If you're curious, the Earth's fixed frame with its normal origin, looks like this:

So if the model was positioned at the North Pole, it would be oriented correctly.  I'm no rocket scientist but last time I checked, no one launches from the North Pole, so we are going to stick with our current launch position and change the model's orientation.  A quick look at the AGI Components documentation shows that AxesEastNorthUp has the orientation we want.

To orient the model correctly, we create a reference frame with an origin of the model's desired position and east-north-up axes.  Note that the model's position is no longer explicitly set.  It is left as its default of Cartesian.Zero, since it is at the origin of its reference frame.

EarthCentralBody earth = CentralBodiesFacet.GetFromContext().Earth;
Cartographic position = new Cartographic(Trig.DegreesToRadians(-80.577778), Trig.DegreesToRadians(28.488889), 0);
PointCartographic origin = new PointCartographic(earth, position);
Axes axes = new AxesEastNorthUp(earth, origin);
ReferenceFrame referenceFrame = new ReferenceFrame(origin, axes);
new ReferenceFrameGraphics(referenceFrame, 45);

ModelPrimitive model = new ModelPrimitive("delta4-lp.mdl");
model.ReferenceFrame = referenceFrame;
SceneManager.Primitives.Add(model);

Other commonly used axes include AxesNorthEastDown and AxesAlignedConstrained.

Orienting using Rotations

Sometimes you don't want to use a primitive's ReferenceFrame alone to orient it.  Perhaps, you are concerned about performance, and you want several primitives to share the same ReferenceFrame; or you set the model's ReferenceFrame, but the model needs further adjustments to look right.  For these cases, use the model's Orientation property.

Let's say we're trying to orient a satellite model defined using AxesLocalVerticalLocalHorizontal, like the "Camera -> Follow an Earth orbiting satellite" example in the HowTo.  Our first attempt is probably something like:

AxesLocalVerticalLocalHorizontal lvlhAxes = new AxesLocalVerticalLocalHorizontal(earth.InertialFrame, propagator.CreatePoint());
ReferenceFrame lvlhFrame = new ReferenceFrame(satellitePoint, lvlhAxes);

ModelPrimitive satellite = new ModelPrimitive("globalstar.mdl");
satellite.ReferenceFrame = lvlhFrame;
SceneManager.Primitives.Add(satellite);

// Debug code for visualizing LVLH axes
new ReferenceFrameGraphics(lvlhFrame, 25, Color.Orange);

Since we've learned the usefulness of ReferenceFrameGraphics, we created one to see the model's reference frame:

LVLH axes are oriented such that +Y is toward the velocity vector and +X is along the position vector.  This model was originally modeled with its solar panels spanning along the Y axis so the model's orientation is incorrect in this frame.  We really want the model to be oriented like this:

We need two rotations to get the satellite oriented correctly in this frame.  First let's apply a -90 degree rotation around the LVLH Y axis.  This makes the tops of the solar panels that were originally facing -Z face +X, or "up."

AxesLocalVerticalLocalHorizontal lvlhAxes = new AxesLocalVerticalLocalHorizontal(earth.InertialFrame, propagator.CreatePoint());
ReferenceFrame lvlhFrame = new ReferenceFrame(satellitePoint, lvlhAxes);

EulerSequence eulerSequence = new EulerSequence(-Constants.HalfPi, 0, 0, EulerSequenceIndicator.Euler213);
UnitQuaternion invertedQuaternion = new UnitQuaternion(eulerSequence.Invert());

ModelPrimitive satellite = new ModelPrimitive("globalstar.mdl");
satellite.ReferenceFrame = lvlhFrame;
satellite.Orientation = invertedQuaternion;
SceneManager.Primitives.Add(satellite);

// Debug code for visualizing LVLH axes and axes after -90 degree rotation
UnitQuaternion quaternion = new UnitQuaternion(eulerSequence);
AxesFixedOffset rotatedAxes = new AxesFixedOffset(lvlhAxes, quaternion);
ReferenceFrame rotatedFrame = new ReferenceFrame(lvlhFrame.Origin, rotatedAxes);
new ReferenceFrameGraphics(rotatedFrame, 25, Color.White, Color.Black);
new ReferenceFrameGraphics(lvlhFrame, 15, Color.Orange);

To rotate the model, first we create an EulerSequence with a -90 degree rotation around the Y axis.  The Euler sequence is then converted to a UnitQuaternion so it can be applied to the model's Orientation property.  Note that the Euler sequence is inverted when it is converted to the quaternion.  This is because we are determining the model's orientation by working from the LVLH frame to the model's frame, e.g. world to model.  The model's Orientation property expects a quaternion that goes from the model's frame to LVLH, e.g. model to world.

Also note that when the -90 degree rotation around Y is applied, the axes are also rotated.  The original LVLH axes are shown above in orange, and the rotated axes are shown in white.  Look at the rotated model, what rotation around what new axis is needed to get the model facing the desired direction?   90 degrees around Z:

AxesLocalVerticalLocalHorizontal lvlhAxes = new AxesLocalVerticalLocalHorizontal(earth.InertialFrame, propagator.CreatePoint());
ReferenceFrame lvlhFrame = new ReferenceFrame(satellitePoint, lvlhAxes);

EulerSequence eulerSequence = new EulerSequence(-Constants.HalfPi, 0, Constants.HalfPi, EulerSequenceIndicator.Euler213);
UnitQuaternion invertedQuaternion = new UnitQuaternion(eulerSequence.Invert());

ModelPrimitive satellite = new ModelPrimitive("globalstar.mdl");
satellite.ReferenceFrame = lvlhFrame;
satellite.Orientation = invertedQuaternion;
SceneManager.Primitives.Add(satellite);

// Debug code for visualizing LVLH axes and axes after -90 degree rotation
UnitQuaternion quaternion = new UnitQuaternion(eulerSequence);
AxesFixedOffset rotatedAxes = new AxesFixedOffset(lvlhAxes, quaternion);
ReferenceFrame rotatedFrame = new ReferenceFrame(lvlhFrame.Origin, rotatedAxes);
new ReferenceFrameGraphics(rotatedFrame, 25, Color.White, Color.Black);
new ReferenceFrameGraphics(lvlhFrame, 15, Color.Orange);

The model is now oriented correctly.  All that was required was two Euler angle rotations:  first -90 degrees around Y, then 90 degrees around Z.  Here is the final model without the rotated axes shown:

In summary, use a model's ReferenceFrame and Orientation property to get it oriented the way you want it.  When in doubt, experiment using ReferenceFrameGraphics to help visualize what is happening.

Make sure to check out the "Primitives -> Model -> Orient a model" example in the HowTo.  It was updated to use a reference frame based on the model's position and east-north-up axes.  This means the model's position can just be Cartesian.Zero, which is its default.  The model's orientation no longer needs to be set since the model is orientated appropriately in this reference frame as shown above.

The other HowTo example to check out is "Camera -> Follow an Earth orbiting satellite."  The model's reference frame is now based on the Sgp4Propagator used to propagate the satellite.  This means the model's position is no longer manually set when the animation time changes.

The reference frame axes shown in the above two images are visualized using a helper class in the HowTo:  ReferenceFrameGraphics.  Its constructor simply takes the reference frame you want to visualize and the length to make the axes.  I'm sure you will find this a useful visualization and debugging tool.

Best Practices

To close this entry, here are a few best practices for using reference frames with primitives.

• Avoid manually converting lots of data between reference frames for use with primitives.  For example, if you have 10,000 points to visualize with PointBatchPrimitive, set the primitive's ReferenceFrame property appropriately, instead of converting the points manually.  This is especially true if the points are moving and the manual conversion would have to be done over and over again.
• Avoid using tons of reference frames for visualization.  There is a small, fixed amount of rendering overhead per reference frame.  This will only become an issue if a lot of primitives are created, each with their own unique reference frame.  For example, it is more efficient to create 1,000 model primitives with the same reference frame and set their Position and Orientation properties than to create the same models, each with a unique reference frame to position and orientate them.  This is especially true if the models aren't moving in the common reference frame.
• Use ReferenceFrameGraphics to visualize your reference frames, especially during debugging or to help orientate a model.

Next, navigate to the Framework and References property panel, and add the AGI.Foundation.Graphics assembly to the References section of the panel. The AGI.Foundation.Graphics.dll can be found in the Assemblies directory of the AGI Components install location. You can also add references to other AGI Components assemblies if you want to use them within your application:

Before you can use the Windows Forms Interop framework for Qt, you need to initialize it. You can do this by adding the line highlighted below to the entry point for your application:

#include <qtwinforms.h>
...
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    QtWinFormsUtils::initWindowsFormsForQt();
    ...
}

In the QWidget that will host the Insight3D control, add members for the Insight3D control and a QtControlHost widget:

#include <QWidget>
#include <qtwinformscontrolhost.h>

class Insight3DWidget : public QWidget
{
    Q_OBJECT
public:
    Insight3DWidget();

private:
    gcroot<AGI::Foundation::Graphics::Insight3D ^> Insight3D;
    QtControlHost *Insight3DHost;
};

Then, when you are ready to instantiate the Insight3D control, you can activate your AGI Components license, create a new Insight3D control, and construct a QtControlHost widget with the Insight3D control and the parent widget:

#include "mainwindow.h"
#include <QVBoxLayout>

Insight3DWidget::Insight3DWidget()
{
    AGI::Foundation::Licensing::ActivateLicense("Cut and paste the contents of your .lic file here");
    Insight3D = gcnew AGI::Foundation::Graphics::Insight3D();
    Insight3DHost = new QtControlHost(Insight3D, this);

    QVBoxLayout *vl = new QVBoxLayout();
    vl->addWidget(Insight3DHost);
    setLayout(vl);
}

At this point, when you construct your widget, you are able to fully use and interact with the Insight3D control in your Qt application.  You can continue to build your application utilizing AGI Components as you would with any C++/CLI application.

While there are various technologies that allow for Insight3D to be run in a web browser, we are going to focus on a particular one in this entry: XAML Browser Applications (or XBAPs.) There are many advantages to XBAPs over other web technologies.

For instance, deployment is simplified through Microsoft ClickOnce, allowing any prerequisites for a web application to be pushed out over your intranet or installed with a simple client side installer.  Insight3D, in the form of a client side plug-in installer, is only 12 megabytes.  The experience is also clean for your end users – there is no information bar or security warnings when the web application is run; clients can click on an html link and be interacting with a full Insight3D application in their web browser in seconds.  Also, once the plug-in is installed, XBAPs allows you to update your application logic and push out the updates to your hosting server. When clients connect to your Insight3D web application, the update is automatically deployed without any further install, and the transition to newer versions of your application is completely transparent to your clients.

To get started, let’s create a new XBAP project. Create a new project in Microsoft Visual Studio and select the WPF Browser Application template under the language of your choice.  WPF Browser Application projects are available starting with the .NET 3.0 framework.  In this walk-through, we’ll build our web application using C#, as seen below.

In your project references, add references to the AGI.Foundation.Graphics and AGI.Foundation.Core assemblies, which can be found in the Assemblies directory of your AGI Components install location. In addition, since we will be hosting the Windows Forms based Insight3D control in our web application, add references to the .NET assemblies WindowsFormsIntegration and System.Windows.Forms.

We will also configure the ClickOnce Security Settings for our XBAP project. Since this walkthrough is for intranet deployment, in the project properties, navigate to the Security category and select the “This is a full trust application” option, as seen below:

Next, let's add the Insight3D control. Open the XAML text editor for Page1.xaml, and add the two lines shown below. As you type the code for the second line, an event handler should be added to your application to notify us when the page hosting our application has loaded:

xmlns:my="clr-namespace:System.Windows.Forms.Integration;assembly=WindowsFormsIntegration"
Loaded="Page_Loaded"

Also, let's add a DockPanel container to hold the WindowsFormsHost that will host our Insight3D control:

<DockPanel>
    <my:WindowsFormsHost DockPanel.Dock="Top" Name="Insight3DHost"/>
</DockPanel>

Your final Page1.xaml code will look similar to:

<Page x:Class="Insight3DWebApplication.Page1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:my="clr-namespace:System.Windows.Forms.Integration;assembly=WindowsFormsIntegration"
    Loaded="Page_Loaded"
    Title="Page1">
    <DockPanel>
        <my:WindowsFormsHost DockPanel.Dock="Top" Name="Insight3DHost"/>
    </DockPanel>
</Page>

Next, open Page1.xaml.cs and add a member for the Insight3D control to the Page1 class as follows:

AGI.Foundation.Graphics.Insight3D Insight3D = null;

We will instantiate the Insight3D control when the page loads, so add the following two lines to the Page_Loaded event handler:

Insight3D = new AGI.Foundation.Graphics.Insight3D();
Insight3DHost.Child = Insight3D;

Finally, since we will eventually be deploying our application over the web, we need to activate the appropriate license. We can add a static constructor to our Page1 class, and then call the ActivateLicense method with a string containing the contents of our .lic file:

public partial class Page1 : Page
{
    AGI.Foundation.Graphics.Insight3D Insight3D = null;

    static Page1()
    {
        AGI.Foundation.Licensing.ActivateLicense(
            @"Copy and paste the contents of your .lic file here");
    }
    public Page1()
    {
        InitializeComponent();
    }

    private void Page_Loaded(object sender, RoutedEventArgs e)
    {
        Insight3D = new AGI.Foundation.Graphics.Insight3D();
        Insight3DHost.Child = Insight3D;
    }
}

At this point, when you run your project, you should see the Insight3D globe running in a web browser. You can continue to develop your web application as you would a normal Insight3D application.

In future parts of this series, I will discuss deployment and security, upcoming improvements to our web technology, and how to make your Insight3D web application run in virtually any browser on Windows.

We tend to spend most of our time in SIGGRAPH courses.  This year, my favorite one was Advances in Real-Time Rendering.   Wolfgang Engel gave a good talk on deferred shading and light pre-pass.  Deferred shading showed up just about everywhere at SIGGRAPH this year, and rightfully so, since it is such a cool technique.  Currently, Insight3D uses so-called forward shading to allow support for a wide array of video cards.

Out of all the talks in the real-time rendering course, I enjoyed Alex Evan's talk on LittleBIGPlanet the most.  Overall, Little Big Planet is a very impressive engine for "1.5 graphics programmers over 3 years."  Although they tried to avoid it, they wound up using deferred shading and a MSAA hack to get 2 layer translucency (translucency is difficult in deferred shading since only a single z value is available during shading).  I also liked: "give artists too many knobs and they will ignore them."  I think the same is true of developers; if your API is overwhelming, developers will avoid it.  We've tried to balance flexibility and simplicity with our interfaces for Insight3D.

An Introduction to Shader-Based OpenGL Programming was a more polished version of last year's OpenGL course.

As usual, there was your fair share of interactive ray tracing.  This year, there was a trend toward real-time ray tracing APIs, such as NVIDIA's OptiX and Caustic Graphics' CausticGL.  As I've briefly mentioned before, we've architected Insight3D so all the OpenGL calls are isolated behind a renderer interface.  Although we don't have any immediate plans to do so, it's very likely that we could implement our renderer using a ray tracing API.

The OpenGL BOF was crowded as always.  This included information on OpenGL 3.2 and GLSL 1.5.  I'm happy to see that geometry shaders are core in 3.2.  I hope we get improved hardware support for them since they have several uses in Insight3D, including the SurfaceMeshPrimitive and MarkerBatchPrimitive.  Both of these primitives will fallback to vertex shaders to support older hardware.  I like the API Quick Reference Card that was handed out at the BOF.  References like this are handy, especially when you are searching for GLSL functions.  The OpenGL BOF was the first time I heard anything about WebGL.  I think bringing 3D to the web is great.  WebGL is an interesting approach, but I feel that OpenGL is pretty low level for JavaScript.  As they said at the BOF, development of higher level libraries is going to be key.  Insight3D is becoming web-enabled (although not using WebGL), keep your eyes open for more information.

Last year, I really enjoyed Beyond Programmable Shading.  I was pleasantly surprised to see that the course contained almost all new content this year.  Kayvon Fatahalian's overview of GPU architecture was even better than it was last year.  He provided insight into things like why branches and shader length affect performance.  Deferred shading showed up again when Johan Andersson showed a DX11 Compute Shader implementation in his presentation.  Also of interest to the Insight3D team was J.M.P. van Waveren's presentation on id Tech 5 where he provided some details on virtual texturing.  Techniques to handle massive amounts of textures are also useful to Insight3D's support for high resolution imagery.  Parallelism was a common theme throughout all the engine talks in this course.  Insight3D has some parallelism built in; for example, terrain and imagery disk reads occur in separate threads.  There are other areas we can add parallelism to in the future; for example, culling and rendering can be done in a producer-consumer style.

One of my favorite parts of SIGGRAPH is browsing all the new computer graphics books.  I am excited about Graphics Shaders:  Theory and Practice and Game Engine Architecture, both from A K Peters.  Although not new this year, I really like Mobile 3D Graphics with OpenGL ES and M3G from Morgan Kaufmann.  The chapters on scene management and performance describe many of the techniques we use in Insight3D.  Even though the book is targeted at moblie devices, much of the content is applicable to PCs.

Introduction

Display conditions are a very useful Insight3D feature that allow the user to specify when a primitive, globe overlay, or screen overlay is rendered.  There are a number of different types of display conditions that can be used, and what's even better is that they can be combined and used together to create fancy rules for when to display an object.  In this article, I will show some example uses of display conditions.

To start off, let's say we want to display a circle on the Earth around New York City when the camera is at an altitude of one million meters or less.  For this, we assign the AltitudeDisplayCondition (which becomes active when the camera's altitude above the surface is within a specified interval) to a PolyLinePrimitive.   Here is the code:

CentralBody earth = CentralBodiesFacet.GetFromContext().GetByName("Earth");
Cartographic newYork = new Cartographic(Trig.DegreesToRadians(-74), Trig.DegreesToRadians(40.75), 0);
SurfaceShapesResult shape = SurfaceShapes.ComputeCircleCartographic(earth, newYork, 10000);

PolylinePrimitive line = new PolylinePrimitive(shape.PolylineType, SetHint.Infrequent);
line.Set(shape.Positions);
line.Color = Color.White;

AltitudeDisplayCondition condition = new AltitudeDisplayCondition(0, 1000000);
line.DisplayCondition = condition;

SceneManager.Primitives.Add(line);

As you can see in the images below, the circle is visible only when the camera is below this altitude.

Layering

Sometimes the user might want to see an object at a higher level of detail when it is close and at a lower level of detail when it is far away.  In this case, we can use display conditions to create layers at which different levels of detail are shown.  If we create an AltitudeDisplayCondition for each layer, we can limit at which altitudes each layer shows up.  This way, at low altitudes, we can show the more detailed layers and at high altitudes, we can show the less detailed layers.  The images below show an example of this:

Zoomed in close, each object is a 3D model.

At a medium zoom, the models become markers.

When zoomed far away, the markers become points.

Note that this level of detail scheme has two distinct benefits.  First of all, there is a significant performance gain.  When the models get replaced with simple markers or points, they are rendered much faster.  Second, there is a visual benefit.  When zoomed out far, the models become very small and hard to see or click on.  Since we are replacing them with markers or points of a constant pixel size, it makes them much easier to see and interact with.

Aggregation/De-aggregation

Often, when looking at large collections of objects, the user might like to see a hierarchical way of presenting such a collection so that when viewing from far away, there is less information to analyze.  For example, let's say we have two armies somewhere in Iraq, and we want to display the information about each specific soldier.  This is useful when the user is zoomed in very close, but as the user zooms out, we might want to aggregate soldiers into squads, squads into platoons, platoons into companies, and so on.  This can be implemented quite easily using display conditions.  In fact, I did this during my first week here!  We would simply have to create a set of DistanceDisplayConditions, which become active for objects within a specified distance from the camera.  Each display condition would apply to an organizational element.  These would be layered so that when one ends, the next one starts.  The image below shows what this might look like:

As you can see, the markers closest to the camera are individual soldiers (represented by 2525B symbology).  The markers that are further away are squads.  As we get even further away, squads are aggregated into platoons.  This way, the user can see the most detail about the elements that are nearby and less detailed representations of elements that are far away.

Object Descriptions

Another cool use of display conditions is to pop up a screen overlay with a description of an object when the camera gets close enough to that object.  In this case, we use the DistanceToPositionDisplayCondition, which becomes active when the camera's distance away from a specified position (in this case, the primitive's position) is within a defined interval.  Here is an example:

When zoomed in close to this model, a descriptive screen overlay appears.

As we zoom further away, this overlay disappears.

Keep in mind that this is a simple example.  The screen overlay could also be used as an object-specific user interface, such as a toolbar that acts on the object.

Conclusion

As you can see, display conditions are a powerful and extremely useful tool for developing 3D applications.  I've only mentioned a few example uses here, but you can check out the Display Conditions documentation for more information.