Virtual Earth 3D team blog : Code

Hosting VE3D in native code

NikolaiF — Thu, 24 Sep 2009 21:54:00 GMT

Sorry for the glut of posts this week. I hadn't been able to write much, but there were still interesting topics and questions coming up and I'm trying to address that backlog now. So, without further ado:

It is possible to host VE3D in a variety of contexts, and so far we've seen WinForms, WPF, and the browser. It is also possible to host in straight native code. In this sample, I address the COM interactions needed to host VE3D, and use OpenGL as an example hosting environment.

Download the code here.

This sample demonstrates four concepts:

Interaction with native code.
Back buffer retrieval.
Direct camera control.
OpenGL integration.

Native code:

Managed code provides easy and convenient methods for exposing your code to COM, and hence to native callers.
From the managed side, check "Register for COM interop" in your project's Build tab. Decorate an interface
with ComVisible(true) and provide a guid, and the backing class with the interface type as shown. Your types
are now visible and callable.

On the native side, you can now instantiate your managed code using typical COM calls, as shown. It can then
be called similarly to any other object.

To add a new function to the interface, simply add it to the interface file and the backing .cs file, then
recompile. By designing your interface in appropriately, you can then decide whether to do most of your logic
in native or managed code, depending on where you feel more comfortable.

Backbuffer retrieval:

The Render function provides the most efficient way of pulling VE3D's back buffer into main memory. In general
it is better to not do this, rather let the hardware render to the screen directly, but some situations demand
using the scene in some other fashion. Here, we get the memory as a direct pointer. Note that this approach
assumes that you are handling any format and stride issues yourself.

It is also possible to get a graphics object from systemMemorySurface, an HDC from that, and then use functions
like BitBlt to copy out data and handle some of these issues for you.

Direct camera control:

Most samples thus far have demonstrated use of bindings and actions, or deriving camera controller. The
CameraController class here shows how to write a controller that can react directly to user input, modifying
camera values directly. The "best practices" method is to wrap your input device in a EventSource, and use
bindings and actions to communicate the information to your controller. These structures provide simple
remapping of inputs, if necessary, and handle any threading or marshalling issues.

However, it is also possible and sometimes appropriate to take the simpler approach used here.

OpenGL integration:

It is possible to integrate VE3D into an existing OpenGL application. Using the Render method described above,
the pointer produced is suitable for direct consumption by OpenGL. There are differences in how textures are
handled by the two APIs, but these are fairly simple to overcome, and are described in DrawOpenGLWindow().

Note that there is nothing that limits this sample to OpenGL, anything that can consume the buffer as provided
can host VE3D in the exact same manner.

Note on debugging:

The Visual Studio debugger requires some direction on how to deal with mixed native and managed code.
In the VE3DOpenGL properties page, expand Configuration Properties, click Debugging, then choose Debugger
Type. You can elect to only attach to native, only to managed, or to both ("mixed"). "Auto" in this case
will be native-only. If you find your breakpoints are not hitting, it is likely this setting.

Note on glut.h:

For some reason, in the release version only, I managed to get it thinking that it needed glut and I haven't
been able to figure out why. If you encounter problems while compiling due to glut, just run in debug mode.
This is a problem that is specific to the sample app, not the methodology used.

Enjoy, and as usual please let me know about any questions or problems you may have.

GraphicsProxy RenderState

NikolaiF — Tue, 22 Sep 2009 23:03:00 GMT

I've gotten a few questions lately about how to do some alpha effects using models, specifically MeshGraphicsObject. After you create the GraphicsObject, it has a RenderState object available on it. The fields on this object will be familiar to those experienced with DirectX, but here's a rundown of a few especially useful ones:

Allow your model to cast shadows on the ground.

newMesh.RenderState.Lighting.CastShadows = true;

Allow your model to have directional shading (you can adjust the direction of the light using Host.WorldEngine.Environment.SunPosition).

newMesh.RenderState.Lighting.DirectionalLightEnabled = true;

Allow your model to use transparency, whether from vertex colors, textures, or TextureFactor (see below).

            newMesh.RenderState.Alpha.Enabled = true;
            newMesh.RenderState.Alpha.SourceBlend = Blend.SourceAlpha;
            newMesh.RenderState.Alpha.DestinationBlend = Blend.InvSourceAlpha;

Allow use of TextureFactor to control the overall color of the model. For example, you can create a model that has a texture with a white patch, and then create two models, one red and one blue, both using the same texture but differing on the value of TextureFactor.

            newMesh.RenderState.Stages[0].Blending.ColorArgument1 = TextureArgument.TextureColor;
            newMesh.RenderState.Stages[0].Blending.ColorArgument2 = TextureArgument.TFactor;
            newMesh.RenderState.Stages[0].Blending.ColorOperation = TextureOperation.Modulate;

Allow use of TextureFactor to control the overall opacity of the model. This is great for fading effects, as changing the TextureFactor per-frame is cheap.

            newMesh.RenderState.Stages[0].Blending.AlphaArgument1 = TextureArgument.TextureColor;
            newMesh.RenderState.Stages[0].Blending.AlphaArgument2 = TextureArgument.TFactor;
            newMesh.RenderState.Stages[0].Blending.AlphaOperation = TextureOperation.Modulate;

Change the filtering used for textures. For example, in the XFile sample, if you zoom in close to the model the texture gets blocky. Dropping this code in improves the situation.

newMesh.RenderState.Stages[0].Sampler.MagnificationFilter = TextureFilter.Linear;
newMesh.RenderState.Stages[0].Sampler.MinificationFilter = TextureFilter.Linear;

The TextureFactor value mentioned above. This value would make the model ghostly transparent and red-tinged. This (and other values in RenderState) can be cheaply changed every frame.

newMesh.RenderState.TextureFactor.Value = Color.FromArgb(128, Color.Red);

One additional note: to use alpha, you must also call AddAlphaRenderable in your actor's Render function instead of just AddRenderable. The distance is a sorting function that lets the renderer know what order to draw the alpha in (affects blending). A constant value works in some situations, but if you find things look wrong, especially when one of your models occludes another, try using a value based on the distance between the model and the camera.

Here's a few shots to demonstrate the effects of these switches:

Everyone's favorite XFile sample model.

The same model, with shadows and directional lighting (the sun is above and a bit behind, if you move it the shading and shadows move appropriately).

The same again, with an alternate texture that contains transparency and the various alpha switches on. Note one detail: the shadow casting code does not account for transparency.

Same again, with all switches described above turned on. The texture filtering is improved (look for blockiness in the center of the body in the previous shot), the color is shifted red, and the whole model is somewhat transparent, even parts where the texture is opaque.

WMS Data

NikolaiF — Tue, 09 Jun 2009 20:21:00 GMT

I was having a discussion with Kurt Guenther from Infusion yesterday on the topic of WMS servers and VE3D. There is a large amount of very interesting spatial data out there served by Web Map Services, or WMS servers. VE3D is able to process this data using ConnectionParameter-based DataSources. Setting it up is pretty easy:

ConnectionParameters cp = new ConnectionParameters(http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/Portland/Portland_ESRI_Neighborhoods_AGO/MapServer/export?bbox={16},{17},{18},{19}&bboxSR=4326&layers=&layersDefs=&size=256,256&imageSR=102113&format=png&transparent=true&dpi=&f=image);

string connectionParameters = cp.ToString();

DataSourceLayerData layerData = new DataSourceLayerData(LayerName, Name, connectionParameters, DataSourceUsage.TextureMap);

Host.DataSources.Add(layerData);

Drop this in to your Activate (plug-in) or Initialized handler (winforms etc) app and fly to Portland, OR to see the data (thanks to ArcGIS for the sample data and Kurt for the pointer).

I won't go into all the details of the WMS spec here, but I will call out a few important parts. First, in order for this to work you must specify the bbox to be in Geographic coordinates (4326). This is usually the default. Second, you must pay attention to the returned projection. In the above case, we have instructed the server to return 102113, which is Web Mercator, VE3D's native image projection. This data can be consumed directly with very little overhead. However, different servers support only certain formats and projections, and you must be careful for any particular server (it is possible to query this using WMS's GetCapabilities). Nearly all support returning images in Geographic coordinates, 4326. It is possible to instruct VE3D to reproject this to Web Mercator (this is the only reprojection VE3D will do for you, fortunately it will work for the majority of data).

Now, to look at ConnectionParameters and what it can do for you. First, there's the big url. Notice that the bbox has string.Format replacement variables in it: {16}, {17}, etc. Requests to the server are made on a per-tile basis (the T key is useful here). For each request, these variables are replaced with data specific to the tile in question. Here is a list of available parameters:

0 Reserved

1 Map Style

2 Round-robin integer

3 Reserved

4 Quadkey

5 Extension

6 Generation

7 Stripe (0-3)

8 Tile Host

9 App Host

10 Language code

11 Region code

12 Tile LOD

13 Tile X

14 Tile Y

15 Low order stripe (0-1)

16 MinLong

17 MinLat

18 MaxLong

19 MaxLat

20 RequestToken

21 Culture name

The most interesting ones are 4 (the main quad-key, very useful for already-tiled data), 12, 13, 14, and and 16-19. To see some of this in action, check out the TerrainImages sample (also available in the sample code of course). Programatically, you can investigate these values using the TileId class, using GetRequestCode, GetPosition, and GetLatLonBoundingBox.

As for other values on ConnectionParameters, you can control reprojection (if your data is in Geographic, specify CoordinateReferenceSystem = WGS84CoordinateReferenceSystem.Instance, as noted before this is the only reprojection natively supported, so otherwise leave this field uninitialized), the bounds of where the data is valid is terms of Lat/Long and LOD (useful to reducing unnecessary network requests), and caching behavior.

Caching behavior deserves special discussion, because WMS servers are often quite slow. By default, data loaded using ConnectionParameters is not cached locally. Once it moves out of memory, it must be re-queried. If you set CacheRetention however, the data will be kept locally for the period of time specified (unless it is evicted due to space restrictions in the interim). If you set CacheRetention = new TimeSpan(24, 0, 0), for example, for 24 hours from the time of query a given tile will not be re-queried. Note that some servers are dynamic, such as weather data, so it's important to use an appropriate value here.

And just to give Kurt a poke in the ribs, please remember to only add DataSources after/during the Initialized event!

Update:

John Fletcher from Latitude Geographics pointed out that the example I give above isn't actually WMS compliant in its query parameters. He suggests an alternate sample, of the British Columbia, CA area:

ConnectionParameters p = new ConnectionParameters("http://openmaps.gov.bc.ca/mapserver/libcwms2?SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap&LAYERS=DBM_7H_MIL_BATHYMETRIC_POLY,BC_LABEL,DBM_7H_MIL_DRAINAGE_LINE,DBM_7H_MIL_DRAINAGE_POLY,DBM_7H_MIL_ROADS_LINE,DBM_7H_MIL_POLITICAL_POLY_PS,DBM_7H_MIL_POPULATION_POINT&STYLES=,,,,,,&SRS=EPSG:4326&BBOX={16},{17},{18},{19}&WIDTH=256&HEIGHT=256&FORMAT=image/png&TRANSPARENT=TRUE&EXCEPTIONS=application/vnd.ogc.se_inimage&");

p.CoordinateReferenceSystem = Microsoft.MapPoint.CoordinateSystems.Wgs84CoordinateReferenceSystem.Instance;

Host.DataSources.Add(new DataSourceLayerData("foo", "bar", p.ToString(), DataSourceUsage.TextureMap));

John also provided a link to the WMS spec repository (http://www.opengeospatial.org/standards/wms). Note that the sample above is for WMS 1.1.1. The most current version is 1.3.0, but many servers use the older, or support both. No matter which you use (or even for something a little off spec like my original example) the interface with VE3D is the same.

Manual Rendering

NikolaiF — Sun, 19 Apr 2009 23:25:00 GMT

Folks have really reacted to my mention of manual rendering, so I've made a sample for it. Good thing, too, because to be frank there are a few warts. On the upside, however, it is possible to work around all of them and the code required is not too scary.

Get the code!

In this sample, I host a GlobeControl on a form like normal, but instead of using the built-in render thread I render on the UI thread using the manual render API. If you are content to let WinForms present to the screen for you, you're done at this point.

But it is common in these situations to want to get the rendered surface to make a movie, present in some other context like WPF, etc. I include an example of the most basic way to do this, which is the only official way to currently do it (WorldEngine.CaptureScreenShot). If this isn't good enough, and you're a bit more daring, it is possible to get our rendering surface and do more clever things with it. That's what the good folks at Infostrat did for their WPF code, and for the time being I actually recommend using their wrapper if you want to use WPF.

I've labelled all the warts and their workarounds with the tag "WORKAROUND" in the code so you can look more closely if you like, but you should also just be able to copy and paste the sample and get your code to work as it should. Also, this is not actually an an official part of the sample pack, but something similar to it will be.

Anisotropic Filtering

NikolaiF — Sun, 19 Apr 2009 20:11:00 GMT

Anisotropic has been a bit of a frustration for us because while it is very easy to do (it's really just a flag to DirectX), the compatibility issue I mentioned before made it a pain to actually get it in to the control. It's a shame we couldn't turn it on by default, but at least it's there. The effect of it is really quite dramatic, as you can see below. I took these images at this location, near the 405 and 90 interchange in Bellevue.

With anisotropic filtering enabled:

Without:

To turn it on in the website, click "options" in the upper right corner, then "3D settings", and finally check "Use anisotropic filtering". To turn it on in code:

plugIn.Host.RenderEngine.Graphics.Settings.UseAnisotropicFiltering = true;

These settings are remembered in the user.config file for future runs of the control. The perf penalty for this on cards that are even remotely modern is almost zero, so go turn it on now!

New Version Released!

NikolaiF — Fri, 10 Apr 2009 01:46:00 GMT

Our new version has gone live. Head on over to maps.live.com and click "3D" to upgrade. This release is billed primarily as a perf and bug release because it doesn't add a lot of new features at the end-user level (though I think you will be pleased with the perf improvements), but we did have time to throw in some good stuff for the devs.

I've updated the Samples entry, and clicking on the link should get you the new sample set. As usual, please pass along any problems in comments or blog feedback. The samples are mostly the same, with a few new additions, but they have been cleaned up for best practices and new features. I do recommend that you take a glance at them even if you're already familiar with the API. The Camera sample is most changed, and hopefully should help explain the flow of camera control a little better.

Get the code!

Here's a sampling of new and expanded areas:

Initialized event
A new event on RenderEngine that simplifies the startup scenario. Check out SimpleForm to see it. Remember that use of this event or FirstFrameRendered is now required!

Anisotropic Filtering
Greatly improves the appearance of terrain when at an angle. It's off by default, since there are some graphics cards that don't play nice with it (usually old and rare, but still). You can turn this on through the website in the options box, or you can set it programmatically. See SimpleForm.

Dem Data
The ability to supply custom DEM data, and have it automatically stitched into existing data. Previously DEM datasources did not work very well, mostly because we did not automatically stitch. They are still a bit trickier than imagery, but there's a new sample DemData to help you out.

ILocationListener
An interface that allows automatic and efficient query of a location to determine elevation as data changes. ActorDataSource now uses it. Essentially, you register this object and report its Lat/Lon position. If the ground or other solid object moves or changes there, you will get a call to update.

Manual Rendering
Manual render functions that allow use your own thread as the render thread, good for offline rendering or incorporation into another product. RenderEngine.ManuallyInitializeRender and ManuallyRenderNextFrame.

Datasource ConnectionParameters
Helper function for specifying data sources without a content manifest. The string parameter was very hard to use, this is nicer. There are also a few new options, like allowing caching of data specified this way. See TerrainImages.

CelestialStyle
Allow display of a stylized sky with constellations. This is used on the website in Road Mode, but you can set it yourself. See SimpleForm.

Versioning
Support for running code built against previous control versions, if it meets certain requirements. I've outlined this in http://blogs.msdn.com/virtualearth3d/archive/2009/04/01/upcoming-new-version.aspx. To show it working, I've set up a page with samples built from the previous version and from the new version. Both sets work just fine with the new release.

Pixel-width lines
GeometryManager supports pixel-width 3D lines (previously only single-pixel or meter-width). See the Camera sample. We also now have nice looking text labels. See the XFile sample.

Constant value datasources
Helper functions for supplying flat color or elevation data. The Mandelbrot sample uses one to display flat elevation. Please note that a DEM and an Imagery datasource are actually required for proper display. These constant value sources are useful for this case.

Terrain Scaling
WorldEngine.Min/MaxElevationScaling. It is actually possible to have varying scale based on your altitude, but there is some cost associated and I recommend that you set the two values equal to each other. Our default value is 1.0, unscaled.

Override Loading Screen
You can now render (or suppress) the loading screen (affectionately known as "The Circle Of Hope" since our first version, back when the startup flow was a bit less stable than it is now). In the very simplest case, write this:

class MyControl : GlobeControl
{
    protected override void OnPaintLoading(...)
    {
    }
}

This will get you a black screen. You can also grab a reference to the control's Graphics object from the PaintEventArgs and draw anything you like.

Building culling value
Allows control of how many buildings are displayed, based on distance and size of the buildings. WorldEngine.BuildingCulling. The effectiveness of this varies on hardware -- some hardware benefits a great deal, some very little.

Turn on/off street level navigation
Can turn off some of the special navigation effects that occur when right next to the ground, such as sticking to the ground, and the screen drag regions on the sides of the screen when at low altitude. WorldEngine.Enable*.

We have not yet updated the docs. However, we did not make many fundamental changes to the code from an API perspective, and in fact existing code is as much as possible exactly the same. So it is just lacking detail on the new features, and still a good reference.

Logging

NikolaiF — Mon, 06 Apr 2009 00:21:00 GMT

At times it can be useful to know when and if errors are occurring in VE3D. When instructed, VE3D produces a log file that can be helpful for diagnosis. This requires editing the user.config file and adding an entry:

The user.config file is located at:

(Vista) C:\Users\{username}\AppData\LocalLow\Microsoft\Virtual Earth 3D

(XP) C:\Documents and Settings\{username}\Application Data\Microsoft\Virtual Earth 3D

Log files are generated at:

(Vista) C:\Users\{username}\AppData\LocalLow\Microsoft\Virtual Earth 3D

(XP) C:\Documents and Settings\{username}\Local Settings\Application Data\Microsoft\Virtual Earth 3D

To increase the verbosity of logs, add another entry to user.config:

The values are like so:

0: Critical errors only. These errors may affect users.
1: Warnings only. These are errors that are handled internally and should not affect users.
2: Informational. These are not errors, but can be useful in some cases for debugging.

Information Pop-ups in WinForms

NikolaiF — Tue, 25 Nov 2008 00:47:00 GMT

We've had several questions about how to do a pop-up form in WinForms, similar to the one on the website. The website pop-up is implemented entirely within the browser, using an IFrame. Therefore, the functionality does not exist by default in the managed code alone. However, the events you need are provided, and creating your own pop-up is not difficult.

The event you need is EngineEvents.OnHover, accessed via the CommunicationManager. It will fire when the mouse hovers over any GeometryManager object that has hit detection on. The event arguments (CommunicationParameters) tell you which item was hovered and where on the screen it is. I used the Tag property on WorldGeometry to hold the name and description I wish to display, so when I get the hover event I retrieve the item back again and pass the tag to my Popup form.

The next step is to render the form. There are two behaviors we want: first, the auto-closing. This was pretty simple to do using a Timer. When you get an OnHoverEnd (another EngineEvent), start a timer. If the mouse moves into the popup, stop the timer. When the mouse leaves it, start the timer again. The second behavior is rendering HTML. This was trivial on the website, but a little tricker in winforms. Fortunately Windows ships with mshtml, which has a ready-made browser window. I based my work on this, and had it working in just a few minutes.

I'm certain all of this could be done more attractively and elegantly, but it should get you started. I updated the main samples package to have the new HtmlForm project. Just grab the zip file again and pull out that project directory.

Get the code!

P.S. If you want to open an ERO from a plug-in without having to go through the JS API first, do this:

CommunicationParameterSet set = new CommunicationParameterSet(8);
set.Add("layerId", null);
set.Add("pushpinId", null);
set.Add("rX1", p.X);
set.Add("rY1", p.Y);
set.Add("rX2", p.X);
set.Add("rY2", p.Y);
set.Add("header", name);
set.Add("content", desc == null ? string.Empty : desc);
Host.CommunicationManager.FireEvent(EngineEvents.Group, EngineEvents.OnHover, set);

p is the location on the screen you want it, name is the title, and desc is your html content.

Animated Textures

NikolaiF — Wed, 19 Nov 2008 03:55:00 GMT

In addition to using dynamic buffers to animate geometry, you can also animate the textures on geometry. This is accomplished by using BitmapProvider. A BitmapProvider at its simplest is just a wrapper for a Bitmap, which can be used as the icon for a pushpin or the data for a texture that should be applied to geometry that you create in an Actor. In fact, if you just have a single image you can use SingleBitmapProvider. You expose this Bitmap via the CurrentImage property. You also have to provide the size of the image upfront using ImageSize. If you want to change the texture, the system polls the NewImageAvailable property. If you return true, the system re-reads CurrentImage and copies data into the display texture. When it is done, it calls OperationCompleted.

See it in action!

In this sample, we use a pushpin created with our own BitmapProvider. This provider reads the previous screen buffer, creating an infinite mirror effect. We could actually clean this sample up a bit in two ways: by implementing HasFrequentUpdates to return true (causing it to animate continuously) and removing the call to Host.NeedUpdate, and by implementing OperationCompleted to dispose current.

In a more realistic example, we might have a thread that periodically queries the url of a traffic cam. When the image data arrives, set NewImageAvailable to true, provide the new image, and in OperationCompleted signal the query thread to get a new image.

For a demonstration of how to do this using Actors, copy the ScreenshotProvider class from AnimatedPins to BezierSurface, and change SurfacePlugIn.cs, line 91, to:

Texture t = Texture.FromBitmapProvider(new ScreenshotProvider(this.Host));

and presto! you get the same effect.

Finally, SingleImageProvider has code built in to deal with animated gifs. Simply create a bitmap with the animated gif, hand it to SingleImageProvider, that to your pin or Texture, and everything should go on its own from there.

Get the code!

Actors and DataSources

NikolaiF — Mon, 27 Oct 2008 23:51:00 GMT

In this sample, we create a DataSource, which is a class that can be used for large-scale data sets. It provides hooks into the system's spatial index, memory cache, and background data threads. Data from the DataSource will only be requested when it is in view, and will be automatically cached according to how often it is used and how much memory it consumes. The DataSource we create is a purely generated one consisting of a large number of animated bunnies spread evenly across the globe, and would be impossibly large to try to deal with all at once.

See it in action!

When the PlugIn is Activated, the ActorDataSource is created and added to the system. When we create the DataSource we set up its Ontology, which is a system for defining the type of data the DataSource contains.

The next time the Camera Query runs, a set of areas in the Spatial Index that are in view are determined, called tiles. Each tile is sent as a lat/long bounding box to the Data Threads, which call all added DataSources, including ours. The entry point here is QueryPrimitivesInternal. In this function we would normally do some sort of query to a backend, such as a SQL database or the network, but for simplicity we simply create a BunnyPrimitive in the center of the query region. A primitive is a piece of data that represents a thing in the world, in the case a Bunny, but is not itself an Actor. When we return the Primitive, it is passed to our ActorBuilder, called BunnyBuilder. This creates actual Actors which can render or react to the data represented by each Primitive. Each Actor also needs an ActorBounds, which represents a spatial area that, when in view, should cause it to render. When this happens each Actor's Update and Render functions are called on the Render Thread just like normal Actors.

Get the code!

Controlling Time

NikolaiF — Sun, 05 Oct 2008 22:11:00 GMT

Today we show a little of the "Time" sample. It demonstrates how to use the concepts of rendering time and world time.

In any rendering or simulation engine it is important to understand the system's concepts of time. VE3D uses two time concepts. The first is "rendering time", which is a time value specified at the beginning of each frame that should be used for all animation that frame. This value enables synchronization of all animation in the system, and accounts for things like changes in frame rate. The second is "world time", which is the time of day that is used in the system. Using this value enables everything that depends on time of day to be synchronized.

Both values can also be overridden. Rendering time can be overridden by replacing the "TimeStep" with a custom step. This is useful when, for example, recording a movie of an expensive animation. Smooth animation and framerate can be achieved despite the fact that the animation itself may be too expensive to render in realtime. Demonstrated in this sample is overriding world time to affect the sun and stars.

Click here to see it in action.

There are two modes to this sample page. The first simply speeds up time. The second rapidly changes the day, but not the time of day, so, you will see the position of the sun at 9 am as the seasons change. Fun things to notice: the stars move (the constellations are correct, too), the sun moves, shadows move, clouds change color, and there are pretty sunsets and sunrises. All this goodness is built in to the new version, but you can only get them if you play with time through the managed control.

Get the code

Current Samples

NikolaiF — Thu, 25 Sep 2008 20:28:00 GMT

Here's the newest, most whiz-bang sample set we've got right at the moment.

Download The Samples!

See The Samples!

For the future, whenever we update the sample set we will update this post, to save you (and us) from having to slog through out-of-date links.

Updated April 9, 2009.

Current Control Version: 4.0

New Version of VE3D

NikolaiF — Thu, 25 Sep 2008 20:03:00 GMT

You may have noticed that we have not blogged recently, and that’s because we’ve been hard at work on the next version of Virtual Earth 3D. The new version features some rendering improvements for the general user, but the most exciting part is for devs (well, that's what we think, but we ARE devs). We have enabled partial trust plug-ins, which means you can put your plug-in on the web, create a page that references it, and users can go see it without having to install anything more than the basic VE3D control.

Behind the scenes, we load your plug-in’s dll to the client and execute it with a limited set of permissions. For example, the plug-in cannot access the file system on its own, but you can still do custom rendering and control like you could before. We’ve updated all the samples you’ve seen so far to run like this, except for the x file loader and the shortcut key (which was an example of how to install one, and is still a valid scenario in some cases). We’ve also added a few new samples to show some new functionality and demonstrate some stuff that’s been there for awhile but we hadn’t gotten a chance to show yet.

Existing code built against VE3D will need to be recompiled, and in some cases we’ve moved a few properties around. The samples should cover most of these changes, but please comment or send us feedback on items that you have trouble with.

Get the new version!

Get the new samples!

Animation

NikolaiF — Wed, 09 Jul 2008 00:26:00 GMT

Note: this entry references code for an older version of VE3D. The newest code samples are here.

Smoothly animated objects make for a more compelling 3D world, and in this entry we'll learn about using them. In the X File entry, the model that we loaded could be rotated around a point. This is pretty easy, but is limited. You can move the model around, rotate it, make it bigger or smaller, but can't change its basic shape and appearance. For complex animations like that, you may need to change the actual vertices or indices used to draw the model. To support that, we have the concept of dynamic buffers. These are buffers that are expected to be frequently recalculated, and are internally handled to make that more efficient. The attached sample shows how to use this in SurfaceActor, but it's pretty much the same as using static buffers. The only difference is that we Set the values in the buffer in every call to Update rather than just Add them once.

Get The Code.

Video: Bezier Surface in Virtual Earth 3D

When the code is normally running it does not draw a new frame as frequently as it could. This is to conserve CPU and other resources on the client machine when nothing is really happening. But when animating, this presents a problem because the aniamtion can look stuttery and inconsistent. The solution is to tell the system it needs to draw more frequently by calling

Host.NeedUpdate();

This can be called as many times per frame as you like, and simply sets a flag telling the system to render the next frame as soon as possible. It's a good idea to only call this when you have an animation actively running. In this case, it is called only when a ControlPoint is actually changing.

This sample also has some code demonstrating more usage of bindings to control user input in a custom fashion, similar to the Geometry sample but a little more complex.

New Intellisense Files

NikolaiF — Wed, 09 Jul 2008 00:18:00 GMT

Note: this entry references code for an older version of VE3D. The newest code samples are here.

Some entries were missing or incomplete from the xml intellisense files in the samples zip in the first post of this blog. I've posted a zip of the new xml files, and updated the samples zip itself. Just unzip the file and drop the new xml files in Program Files/Virtual Earth 3D. You'll need to restart Visual Studio to see them.