Following the official release of Kinect for Windows SDK 1.0 and Kinect Toolbox, I’m pleased to share with you two (useful ?) samples I wrote:

https://www.catuhe.com/msdn/kinecttools.zip

Kinect Keyboard Simulator

This tool allows you to send keys to a specified application when gestures are detected. An obvious usage is to change slides on Powerpoint when you make a swipe to left or to right.

Kinect Sabre

Kinect Sabre is THE mandatory tool for your Kinect!! It creates a reality augmented vision of yourself with a LIGHT SABER in your left hand!!! (Warning: You need to install XNA Game Studio 4.0 to use Kinect Sabre)

 

Hope you like these tools

 

After several months of coding, we are proud to announce the beta 2 of MishraReader. This version is a full rewrite of the beta1 to include MVVM and dependencies injection design patterns.

But the major feature of this version is the reshaping of the user interface to support METRO guidelines:

You can grab it freely here (MishraReader is available in french and english):

https://mishrareader.codeplex.com

To use it, just follow these instructions:

Connection

On this screen, you just have to type your Google Reader account information and click on [SIGN IN]:

Using MishraReader

Once connected, you are able to see unread/starred or all posts:

Using the [SHOW] dropdown menu, you can select only the subscription you want to read:

When you are reading a post, you can:

• Open the post inside your favorite browser by clicking on the post title or by using the icon.
• Mar a post as starred with the icon
• Mark the post as read by using the icon
• Share a post on Facebook and Twitter (new services will be available in beta 3) with the icon
• Bookmark a post with the icon (Currently no bookmark services are available but we will add new ones in the beta 3)

Configuring MishraReader

Using the settings menu, you can configure different options (don’t forget to click on [SAVE CHANGES]):

Account

In the account screen, you are able to disconnect current account and decide if you want to automatically mark items as read when you select them:

Sharing Services & Bookmark Services

With this screen, you can configure sharing and bookmark services.

Display

MishraReader can use 8 different accent colors that you can select using the Display screen.

You can also choose to:

• Show only posts summary (instead of using a web view of the full post) which is quicker to load
• Use a notification icon and in this case show or hide the main window in the taskbar

Network

The network screen allows you to select:

• the quantity of item downloaded per request (between 10 and 500)
• the automatic refresh interval (between 1 minute and 1 hour)

Conclusion

I hope you will like this version as we worked hard to make it the better feeds reader available!

Do not hesitate to give us your feedbacks using the https://mishrareader.codeplex.com site

 

The official Kinect for WIndows SDK is out and you can grab it here:

https://www.microsoft.com/en-us/kinectforwindows/develop/overview.aspx

 

 

The key points are:

• As long as you use a Kinect for Windows sensor (not the XBox360 one) and the official SDK, you can develop commercial applications using Kinect technologies.
• New near mode for depth values (no skeleton tracking in this version) which enables the depth camera to see objects as close as 40 centimeters
• Up to 4 sensors can be connected to the same computer

 

Alongside with the SDK a new sensor is available. If you want to buy it ($249.99), you can go there:

https://www.microsoft.com/en-us/kinectforwindows/purchase/

 

Of course the Kinect Toolbox 1.1.1 is also out and supports the final version of Kinect for Windows SDK:

https://kinecttoolbox.codeplex.com/

The NuGet package can be found there:

https://nuget.org/List/Packages/KinectToolbox

The power available in the cloud is growing every day. So I decided to use this raw CPU power to write a small raytracer.

I’m certainly not the first one to have had this idea as for example Pixar or GreenButton already use Azure to render pictures.

During this article, we will see how to write our own rendering system using Azure in order to be able to realize your own 3D rendered movie.

The article will be organized around the following axis:

1. Prerequisites
2. Architecture
3. Deploying to Azure
4. Defining a scene
5. Web server and workers roles
6. How it works?
7. JavaScript client
8. Conclusion
9. To go further

The final solution can be downloaded here and if you want to see the final result, please go there: https://azureraytracer.cloudapp.net/

You can use a default scene or create your own scene definition (we will see later how to do that).

The rendered pictures are limited to a 512×512 resolution (you can of course change this settings).

Prerequisites

To be able to use the project, you must have:

• a Visual Studio 2010 version (Express version is supported): https://www.microsoft.com/visualstudio/en-us/products/2010-editions
• Windows Azure SDK: https://www.windowsazure.com/en-us/develop/downloads/

You will also need an Azure account. You can get a free one just there: https://www.windowsazure.com/en-us/pricing/free-trial/

Architecture

Our architecture can be defined using the following schema:

The client will connect to a web server composed of one or more web roles (in my case, there are 2 web roles). The web roles will provide the web pages and a web service used to get the status of a request. When an user wants to render a picture, the associated web role will write a render message in an Azure queue. A farm of worker roles will read the same queue and will process any incoming render message. Azure queues are transactionals and atomic so only one worker role will grab the order. The first available worker will read and remove the message. As queues are transactionals, if the worker role crashes the render message is reintroduced in order to avoid losing your work.

In our sample, I decided to use a semaphore in order to limit the maximum number of requests executed concurrently. Indeed, I prefer not to overload my workers in order to give maximum CPU power to each render task.

Deploying to Azure

After opening the solution, you will be able to launch it directly from Visual Studio inside the Azure Emulator. You will be so able to debug and fine tune your code before sending it to the production stage.

Once you’re ready, you can deploy your package on your Azure account using the following procedure:

• Open the “AzureRaytracer.sln” __solution inside Visual Studio
• Configure your Azure account: to do so, right click on the “AzureRaytracer” project and choose “Publish” menu. You will get the following screen:

• Using this screen, please choose “Sign in to download credentials” option which will let you download an automatic configuration file on your Azure account :

• Once the file is downloaded, we will import it inside the :

• After importing the information, Visual Studio will ask you to give a name for the service:

• The next screen will present a summary of all selected options:

• Before publishing, we must change some parameters to prepare our package to the production stage. First of all, we have to go the Azure portal: https://windows.azure.com. Go the the storage accounts tab to grab required information:

• On the right pane, you can get the primary access key:

• With this information, you can go to your project:

• On every role, you have to go to the settings menu in order to define the Azure connection string (you will use here the information grabbed on the Azure portal):

• You must change the “AzureStorage” value using the “…” button:

• In the Configuration tab, you can change the instance count for each role:

• For more information about instance sizes: https://msdn.microsoft.com/en-US/library/ee814754.aspx)
• Finally you will be able to publish your package:

Your raytracer is now ONLINE !!! We will no see how to use it

Defining a scene

To define a scene, you have to specify it using an xml file. Here is a sample scene:

The file structure is the following:

• A [scene] tag is used as root tag and allows you to define the following parameters:
• FogStart / FogEnd : Define the range of the fog from the camera.
• FogColor : RGB color of the fog
• ClearColor : Background RGB color

• AmbientColor : Ambient RGB

• A [objects] tag which contains the objects list

• A [lights] tag which contains the lights list
• A [camera] tag which define the scene camera. It is our point of view, defined by the following parameters:
• Position : Camera position (X,Y,Z)
• Target : Camera target (X, Y, Z)

All objects are defined by a name and can be of one of the following type:

• sphere : Sphere defined by its center and radius
• ground : Plane representing the ground defined by its offset from 0 and the direction of its normal
• mesh : Complex object defined by a list of vertices and faces. It can be manipulated with 3 vectors:Position, Rotation and Scaling:

Faces are indexes to vertices. A face contains 3 vertices and each vertex is defined by two vectors: position (X, Y, Z) and normal (Nx, Ny, Nz).

Objects can have a child node used to define the applied materials:

• defaultShader : Default material defined by:
• Diffuse : Base RGB color
• Ambient : Ambiant RGB color
• Specular : Specular RGB color
• Emissive : Emissive RGB color
• SpecularPower : Sharpness of the specular
• RefractionIndex : Refraction index (you must also define OpacityLevel to use it)
• OpacityLevel : Opacity level (you must also define RefractionIndex to use it)

• ReflectionLevel : Reflection level (0 = no reflection)

• checkerBoard : material defining a checkerboard with the following properties:

• WhiteDiffuse : “White” square diffuse color
• WhiteAmbient : “White” square ambient color
• WhiteReflectionLevel : “White” square reflection level
• BlackDiffuse : “Black” square diffuse color
• BlackAmbient : “Black” square ambient color
• BlackReflectionLevel : “Black” square reflection color

Lights are defined via the [light] tag which can have Position and Color attributes. Lights are omnidirectionals.

Finally, if we use this scene file:

We will obtain the following picture:

Web server and worker roles

The web server is running under ASP.Net and will provide two functionalities:

• Connection to worker roles using the queue in order to launch a rendering:

As you can see, the web server will generate for each request a GUID to identify the rendering job. Subsequently, the description of the scene (the xml file) is copied to a blob (with the GUID as name) in order to allow the worker roles to access it. Finally a message is sent to the queue and a blob is created to give a feedback on the request progress.

• Publish a web service to expose requests progress:

The web service will get the content of the blob and return the result. If the request is queued, the value will be –1 and if the request is finished the value will be 101 (and in this case the blob will be deleted).

The worker roles will read the content of the queue and when a message is available, a worker will get it and will handle it:

Once the scene is loaded, the worker will update the progress state (using the associated blob) and will create a WorkingUnit which will be in charge of producing asynchronously the picture. It will raise a OnFinished event when the render is done in order to clean and dispose all associated resources.

We can also see here the usage of the semaphore in order to limit the number of concurrent renders.

The WorkingUnit is mainly defined like this:

The WorkingUnit works according to the following algorithm:

• Loading the scene
• Creating the raytracer
• Generating the picture and accessing the bytes array
• When the picture is rendered, we can save it in a blob and we update the job progress state
• Launching the render

The raytracer

The raytracer is entirely written in C# 4.0 and uses TPL (Task Parallel Libray) to enable parallel code execution.

The following functionalities are supported (but as Yoda said “Obvious is the code”, so do not hesitate to browse the code):

• Fog
• Diffuse
• Ambient
• Transparency
• Reflection
• Refraction
• Shadows
• Complex objects
• Unlimited light sources
• Antialiasing
• Parallel rendering
• Octrees

The interesting point with a raytracer is that it is a massively parallelizable process. Indeed, a raytracer will execute strictly the same code for each pixel of the screen.

So the central point of the raytracer is:

So for each line, we will execute the following method in parallel on all CPU cores of the computer:

The main part is the TraceRay method which will cast a ray for each pixel of a line:

If the ray intersects no object then the color of the background is returned (ClearColor). In the other case, we will have to evaluate the color of the intersected object:

The ComputeShading method will compute the base color of the object (taking in account all light sources). If the object is transparent or uses refraction or reflection, a new ray must be casted to compute the induced color.

At the end, the fog is added and the final color is returned.

As you can see, computing each pixel is really resource consuming. So having a huge raw power can drastically improve the rendering speed.

The client

The front client is written using HTML with a small part of JavaScript in order to make it a bit more dynamic:

If the web service returns –1,the request is queued. If the returned value is between 0 and 100, we can update the progress bar et if the value is –1, we can get and display the rendered picture.

Conclusion

As we can see, Azure gives us all the required tools to develop and debug for the cloud.

I sincerely invite you to install the SDK to develop your own raytracer !

To go further

Some useful links:

• https://blogs.msdn.com/b/windowsazure/
• https://www.windowsazure.com/en-us/develop/downloads/

It’s a really big pleasure for me to announce that Silverlight 5 is finally available:

https://www.microsoft.com/silverlight/

Links

The Silverlight 5 Toolkit was also updated to support the RTM: https://silverlight.codeplex.com/releases/view/78435 

And don’t forget to have a look to my blog about all the new features of the toolkit: https://blogs.msdn.com/b/eternalcoding/archive/2011/12/10/silverlight-toolkit-september-2011-for-silverlight-5-what-s-new.aspx)

 

And of course, Babylon was updated for the RTM too: https://code.msdn.microsoft.com/Babylon-3D-engine-f0404ace

 

For all the downloads and the features list, please go to: https://www.silverlight.net/learn/overview/what’s-new-in-silverlight-5

Security and 3D

First of all, please read this article: https://blogs.msdn.com/b/eternalcoding/archive/2011/10/18/some-reasons-why-my-3d-is-not-working-with-silverlight-5.aspx

By the way, you may experience security errors with Silverlight 5 RTM when you want to use the wonderful new 3D feature. In fact, some graphics drivers may allow malicious code to execute. That may lead to an unwanted hard reset or a blue screen.

Starting with the beta version, to protect users for this kind of trouble, we initiate a first scenario where all Windows XP Display Driver Model (XPDM) drivers on Windows XP, Windows Vista, and Windows 7 will be blocked by default. Permission will be granted automatically in elevated trust scenarios and Windows Display Driver Model (WDDM) drivers will not require user consent at run-time.

But as always, features, including security features, continue to be refined and added during post-beta development.

And for the RTM version, there were a number of approaches considered to further improve security and stability, but the solution to block 3D in partial trust by default was the best option for this release. Permission is still granted automatically in elevated trust scenarios.

To grant 3D permissions, you just have to right click on your Silverlight plugin, go to the Permissions tab and allow your application:

 

You can of course help your users detect and understand this by using the following code in order to tailor an good user experience:

It is really important to explain your users why the 3D is deactivated. As there is a potential security hole, it is their responsibility to allow 3D experience.

Support and lifecyle

The support status for Silverlight is now updated for SL5:

https://support.microsoft.com/gp/lifean45#sl5

Here is the extract for Silverlight 5:

“Silverlight 5 – Microsoft will provide assisted and unassisted no charge support for customers using versions of Silverlight 5. Paid support options are available to customers requiring support with issues beyond install and upgrade issues. Microsoft will continue to ship updates to the Silverlight 5 runtime or Silverlight 5 SDK, including updates for security vulnerabilities as determined by the MSRC. Developers using the Silverlight 5 development tools and developing applications for Silverlight 5 can use paid assisted-support options to receive development support.

Silverlight 5 will support the browser versions listed on this page through 10/12/2021, or though the support lifecycle of the underlying browsers, whichever is shorter. As browsers evolve, the support page will be updated to reflect levels of compatibility with newer browser versions.”

The new version of the Silverlight Toolkit (December 2011) for Silverlight 5 is out and you can grab it here:

https://silverlight.codeplex.com/releases/view/78435

Update: Babylon Engine now uses Silverlight 5 Toolkit: https://code.msdn.microsoft.com/Babylon-3D-engine-f0404ace

I had the pleasure of working on this version and I’m pleased to write this article to help you discover how the Toolkit enhances Silverlight 5 with the following features:

1. Seamless integration of 3D models and other assets with the Content Pipeline
2. New Visual Studio templates for creating:
   1. Silverlight 3D Application
   2. Silverlight 3D Library
   3. Silverlight Effect
3. New samples to demo these features

Seamless integration with the Content Pipeline

The toolkit comes with a new assembly : Microsoft.Xna.Framework.Content.dll. This assembly allows you to load assets from the .xnb file format (produced by the Content Pipeline).

Using the new Visual Studio templates (which I will describe later), you can now easily port existing 3D projects directly to Silverlight 5!

Microsoft.Xna.Framework.Content.dll assembly will add the following classes to Silverlight 5:

• ContentManager
• Model
• SpriteFont and SpriteBatch

The toolkit comes also with the Microsoft.Xna.Framework.Tookit.dll assembly which will add the following classes to Silverlight 5:

• SilverlightEffect
• Mouse, MouseState
• Keyboard, KeyboardState

ContentManager

The documentation for this class can be found here:
https://msdn.microsoft.com/en-us/library/microsoft.xna.framework.content.contentmanager.aspx

The ContentManager class is the representative for the Content Pipeline inside your code. It is responsible for loading objects from .xnb files.

To create a ContentManager you just have to call the following code:

There are restrictions for this class : The ContentManager for Silverlight can only support one Content project and the RootDirectory must be set to “Content”

Using it is really simple because it provides a simple Load method which can be used to create your objects:

Model

The documentation for this class can be found here:
https://msdn.microsoft.com/en-us/library/microsoft.xna.framework.graphics.model.aspx

The model class has the same API as in XNA 4 and it will allow you to load and render 3D models from XNB files:

You can also use bones if your model supports them:

You can import models using .x or .fbx format:

And thanks to the FBX importer, you can also import .3ds, .obj, .dxf and even Collada.

SpriteFont & SpriteBatch

The documentation for these classes can be found here:
https://msdn.microsoft.com/en-us/library/microsoft.xna.framework.graphics.spritebatch.aspx
https://msdn.microsoft.com/en-us/library/microsoft.xna.framework.graphics.spritefont.aspx

The SpriteBatch class is used to display 2D textures on top of the render. You can use them for displaying a UI or sprites.

As you can see, SpriteBatch only needs a texture to display.

SpriteFont allows you to use sprites to display text.

SpriteFont relies on SpriteBatch to draw and needs a font definition from the ContentManager:

SilverlightEffect

The toolkit introduces a new class called SilverlightEffect which can be used to apply .fx files.

It also support .slfx which is the default extension. There is no difference between .slfx and .fx but as XNA Effect Processor is already associated with .fx, the Silverlight Content Pipeline had to select another one.

You can now define a complete effect inside a Content project and use it for rendering your models.

To do so:

• Create a .fx file with a least one technique
• Shader entry points must be parameterless
• Define render states

For example here is a simple .fx file:

The Toolkit will add required processors to the Content Pipeline in order to create the .xnb file for this effect:

To use this effect, you just have to instantiate a new SilverlightEffect inside your code:

Then, you can retrieve effect’s parameters:

To render an object with your effect, it is the same code as in XNA 4:

Texture2D, TextureCube & SoundEffect

Silverlight 5 provides Texture2D, TextureCube and SoundEffect classes. With the Toolkit, you will be able to load them from the ContentManager:

Mouse and Keyboard

In order to facilitate porting existing 3D applications and to accommodate polling input application models, we also added partial support for Microsoft.Xna.Framework.Input namespace.

So you will be able to request MouseState and KeyboardState everywhere you want:

However, there is a slight difference from original XNA on other endpoints: you have to register the root control which will provide the events for Mouse and Keyboard. The MouseState positions will be relative to the upper left corner of this control:

The MouseState and KeyboardState are similar to XNA versions:

• https://msdn.microsoft.com/en-us/library/microsoft.xna.framework.input.mousestate.aspx
• https://msdn.microsoft.com/en-us/library/microsoft.xna.framework.input.keyboardstate.aspx

Extensibility

Silverlight Content Pipeline can be extended the same way as the XNA Content Pipeline on other endpoints. You can provide your own implementation for loading assets from elsewhere than the embedded .xnb files.

For example you can write a class that will stream .xnb from the network. To do so, you have to  inherit from ContentManager and provide your own implementation for OpenStream:

You can also provide our own type reader. Here is for example the custom type reader for SilverlightEffect:

 

New Visual Studio templates

The toolkit will install two new project templates and a new item template:

Silverlight3DApp

This template will produce a full working Silverlight 3D application.

The new solution will be composed of 4 projects:

• Silverlight3DApp : The main project
• Silverlight3DAppContent : The content project attached with the main project
• Silverlight3DWeb : The web site that will display the main project
• Silverlight3DWebContent : A content project attached to the website if you want to stream your .xnb from the website instead of using embedded ones. This will allow you distribute a smaller .xap.

The main project (Silverlight3DApp) is built around two objects:

• A sceneobject which
  • Create the ContentManager
  • Handle the DrawingSurface Draw event
• A cubeobject
  • Create a vertex buffer and index buffer
  • Use the ContentManager to retrieve a SilverlightEffect (Customeffect.slfx) from the content project
  • Configure and use the SilverlightEffect to render

Silverlight3DLib

This template will produce a Silverlight Library without any content but with all Microsoft.Xna.Framework references set:

And the resulting project will look like:

SilverlightEffect

This item template can be used inside a Content project to add a custom .slfx file that will work with SilverlightEffect class:

The file content will be the following:

New samples to demo these features

Finally, to help you discover and learn all these features, we added some cools samples:

Bloom

This sample shows you how to use sprites to accomplish post-processing effects such as “bloom”. It also uses the Content Pipeline to import a tank model from a .fbx file.

CustomModelEffect

This sample shows you how custom effects can be applied to a model using the Content Pipeline.

Generated geometry

This sample shows how 3D models can be generated by code during the Content Pipeline build process.

Particles

This sample introduces the concept of a particle system, and shows how to draw particle effects using SpriteBatch. Two particle effects are demonstrated: an explosion and a rising plume of smoke:

Primitives3D

This sample provides easily reusable code for drawing basic geometric primitives:

Platformer

This sample is a complete game with 3 levels provided (you can easily add yours). It shows the usage of SpriteBatch, SpriteFont and SoundEffect inside a platform game. It also uses Keyboard class to control the player.

SimpleAnimation

This sample shows how to apply program controlled rigid body animation to a 3D model loaded with the ContentManager:

Skinning

This sample shows how to process and render a skinned character model using the Content Pipeline.

Conclusion

As you noticed, all these new additions to the Silverlight Toolkit are made to make it easy to get started with new Silverlight 3D features by providing developer tools to improve usability and productivity.

You can now easily start a new project that leverages both concepts of XNA and Silverlight. It becomes easy to work with 3D concepts and resources like shaders, model, sprites, effects, etc…

We also try to reduce the effort to port existing 3D applications to Silverlight.

So now it’s up to you to discover the wonderful world of 3D using Silverlight 5!

(Woow what a funny title!)

Some Silverlight 5 Toolkit users send me mails about this error message:

Error 1 Compile error -2147024770
(0, 0): error : Unknown compile error (check flags against DX version) (myfile.slfx)

 

To correct the problem, you just have to install the latest DirectX Runtime:

https://www.microsoft.com/download/en/details.aspx?id=8109

 

This error is generated by the Silverlight effect file compiler which wants to use the DirectX Effect compiler and don’t manage to locate it.

The DirectX Effect compiler is located in a library called d3dx9_xx.dll. The “_xx_” part may vary according to the version of the DirectX SDK used (in the case of Silverlight 5 Toolkit, we used the June 2010 version which relies on d3dx9_43.dll).

The problem is that this library is not installed by default on Windows (but a lot of applications installed it). That’s why you may be required to installed the DirectX Runtime which comes with all versions of the library.

The new site for Kinect for Windows and the new beta of the SDK are out!

This new version focuses on stability and performance:

• Faster and improved skeletal tracking
• Status change support
• Improved joint tracking
• 64-bit support
• Audio can be used from UI thread

We also announce the release date of the commercial version for early 2012.

Faster and improved skeletal tracking

With updates to the multi-core exemplar, Kinect for Windows is now 20% faster than it was in the last release (beta 1 refresh). Also, the accuracy rate of skeletal tracking and joint recognition and been substantially improved.

When using 2 Kinects, you can now specify which one is used for skeletal tracking.

Status change support

You can now plug and unplug your Kinect without losing work. API support for detecting and managing device status changes, such as device unplugged, device plugged in, power unplugged, etc. Apps can reconnect to the Kinect device after it is plugged in, after the computer returns from suspend, etc..

Improved joint tracking

Substantially improve the accuracy rate of joint recognition and tracking.

64-bit support

The SDK can be used to build 64-bit applications. Previously, only 32-bit applications could be built.

Audio can be used from UI thread

Developers using the audio within WPF no longer need to access the DMO from a separate thread. You can create the KinectAudioSource on the UI thread and simplify your code.

Additional information

Furthermore, this new version now supports Windows ”8” (Desktop side)

The new site and the sdk can be found here:

https://www.kinectforwindows.org

To use this new version you only need to recompile your code as no breaking changes were introduced. 

Kinect Toolbox

The Kinect Toolbox was obviously updated to support the new SDK:

https://kinecttoolbox.codeplex.com/

The nuGet package can be found here:

https://nuget.org/List/Packages/KinectToolbox

The aim of this post is to give you some tricks to enable 3D experiences with Silverlight 5 for your applications.

But first of all, let’s see how you can activate accelerated 3D support inside a Silverlight 5 project.

Standard way

To activate accelerated 3D support, the host of Silverlight must activate it using a param named “enableGPUAcceleration”:

By doing this, you will allow Silverlight to use the graphic card’s power to render XAML elements. And at the same time, you will activate the accelerated 3D support.

Troubleshooting

You can detect if 3D is activated or not in your code through the GraphicsDeviceManager class:

The RenderMode property will be set to Unavailable when 3D is not activated.

In this case, the property GraphicsDeviceManager.Current.RenderModeReason will be set to one of these values:

• Not3DCapable
• GPUAccelerationDisabled
• SecurityBlocked
• TemporarilyUnavailable

 

Not3DCapable

You will get this reason when your graphic card is too old to support 3D required features such as shader model 2.0.

GPUAccelerationDisabled

You forgot to set enableGPUAcceleration to true in the hosting HTML page.

SecurityBlocked

When you launch your application, a specific domain entry for 3D can be set to the Permissions tab of the Silverlight Configuration panel.

You will not see this entry unless your domain group policy set it (and in this case you have to ask permissions to your administrator) or you run your Silverlight application under Windows XP.

When you run a Silverlight application under Windows XP, the following behavior happen:

• 3D is enabled automatically in elevated trust (out of browser)
• The first time a user runs a non-elevated 3D application, a domain entry set to Deny is added to the Permissions tab of the Silverlight Configuration panel

To use a 3D application under Windows XP in a non-elevated context, you must change the pre-created Deny entry to Allow.

TemporarilyUnavailable

This happen when the device is lost (for example under lock screen on Windows XP.  It doesn’t happen much in WDDM) where Silverlight expects the rendering surface to return at some point.

Additional tips

One other important point to know is that 3D won’t work correctly inside windowless mode. In this case, the draw event will be driven from the UI thread and so will be fired only during UI events such as page scroll for example.

Conclusion

I hope this post was useful to help you use the wonderful accelerated 3D experience of Silverlight 5.

As you can see, the better solution to handle 3D support is to use GraphicsDeviceManager.Current.RenderModeReason.

Useful links

• Silverlight 5 downloads
• Silverlight 5 Toolkit
• Silverlight 5 RC–What’s new in the 3D world-
• Silverlight Toolkit (September 2011) for Silverlight 5–What’s new-
• New version of Babylon engine for Silverlight 5 and Silverlight 5 Toolkit

I’ve just updated the source of Babylon engine. You can grab the bits here:

https://code.msdn.microsoft.com/silverlight/Babylon-3D-engine-f0404ace

This new version uses the new content pipeline of the toolkit and is compiled using Silverlight 5 RC.

You can play with the exposed shaders using the new SilverlightEffect class.

It is now time to unleash the power of accelerated 3D!!