http://blogs.msdn.com/b/eternalcoding/archive/2011/09/01/silverlight-5-rc-what-s-new-in-the-3d-world.aspx

Silverlight 3D Model Importer Project

If you’re looking for a quick way to get a 3D model loaded using the Silverlight 5 Beta, check out the Silverlight 3D Model Importer project on CodePlex by Simon Ferquel. You can export content from an XNA GS4 project:

var interopModel = InteropModel.FromXnaModel(model);          

// and serializes it into a file
using (var fs = File.Create("model.bin"))
using (var writer = new BinaryWriter(fs))
{
  interopModel.Save(writer);
}

Then import it back into Silverlight using InteropModel.FromBinaryReader(). Here are some examples:

An animated Tank

A bump mapped Lizard

Babylon Project

Related, David Catuhe has added OBJ format and updated model support to the Babylon Toolkit. He blogged about the toolkit updates here.

Summary

This article explains key differences between shaders and effects and describes how to implement high-level “effect” functionality and why you might want to.

If you just want the code:

• Follow the procedure to setup the HLSL Build Task with Visual Studio Integration
• Download the Babylon Engine and look at the Effect class

Named Parameters vs. Registers

Silverlight provides pixel and vertex shader support in the core runtime instead of a high-level “effect” class. The shader model requires that you carefully assign constant parameters to specific registers in your HLSL so that you can set them from your application code. Consider the following HLSL.

// transform object vertices to world-space
float4x4 WorldMatrix : register(c0);

// transform object normals, tangents, & binormals to world-space
float4x4 WorldInverseTransposeMatrix : register(c4);

// transform object vertices to view space and project them in perspective
float4x4 WorldViewProjectionMatrix : register(c8);

By assigning specific registers to these variables, the constants are guaranteed to be in the specified positions so that they can be set from the application side.

device.SetVertexShaderConstantFloat4(8, ref WorldViewProjectionMatrix);

Wouldn’t it be nice if you didn’t have to manually allocate and track registers and could just refer to the parameter name “WorldViewProjectionMatrix” in your application?

effect.SetConstant("WorldViewProjectionMatrix", WorldViewProjectionMatrix);

Your HLSL could then look like this and the compiler could allocate registers as it sees fit:

// transform object vertices to world-space
float4x4 WorldMatrix;

// transform object normals, tangents, & binormals to world-space
float4x4 WorldInverseTransposeMatrix;

// transform object vertices to view space and project them in perspective
float4x4 WorldViewProjectionMatrix;

In order to make this work, you would need information about how the compiler is allocating registers to constant parameters. As it turns out this information can be obtained at compile-time from the shader compiler. However, Silverlight doesn’t ship a shader compiler with the runtime or the install size would increase considerably. A solution to this dilemma is to extract the information at compile-time into a format your application can read and then embed this as a resource alongside your compiled shader.

Export the Named Parameter to Register Map

For the first part of the process we need to do the following:

1. Compile HLSL to shader byte code
2. Extract the constants table during compilation and write it to an application readable format
3. Embed the shader byte code and the constants table file as resources in an assembly

Conveniently, I posted the previous article on the HLSL Build Task with Visual Studio Integration which does all of those. The constant table is exported to an XML file which looks like the following.

<?xml version="1.0" encoding="utf-8"?>
<ShaderConstants FileFormatVersion="1.0" Version="2.0" Constants="5"
Creator="Microsoft (R) HLSL Shader Compiler 9.29.952.3111">
  <Constant Index="0" Descriptions="1">
    <Description>
      <Name>TotalSeconds</Name>
      <RegisterSet>Float4</RegisterSet>
      <RegisterIndex>16</RegisterIndex>
      <RegisterCount>1</RegisterCount>
      <Rows>1</Rows>
      <Columns>1</Columns>
      <Elements>1</Elements>
      <StructMembers>0</StructMembers>
      <Bytes>4</Bytes>
      <Class>Scalar</Class>
      <Type>Float</Type>
    </Description>
  </Constant>
  …

This XML can be easily parsed by application code to determine which registers were allocated to a specific constant, and that’s what the rest of the article is about.

Effect Class

We’re going to create a new class to do the following:

• Load a vertex and pixel shader pair from an assembly – Implementing an effect typically means configuring both a vertex and pixel shader which collaborate to produce the final result, so it makes sense to group these together under a single “effect”.
  • Load shader byte code
  • Load shader constants map
• Set shader constants by name
• Configure the graphics device to use the loaded shaders

David Catuhe did exactly this for the Effect class in his Babylon Engine, and so I’m going to walk through what that looks like.

Create the Effect and Load the Shaders

This constructor loads the shader byte code from the named assembly and loads the constants XML file.

public Effect(GraphicsDevice device, string assemblyName,
  string vertexRootName, string pixelRootName)
{
  this.device = device;

  // Uri
  string vertexRootUri = string.Format(@"/{0};component/{1}.vs",
    assemblyName, vertexRootName);
  string pixelRootUri = string.Format(@"/{0};component/{1}.ps",
    assemblyName, pixelRootName);

  // Shaders
  Stream vertexShaderStream = Application.GetResourceStream(
    new Uri(vertexRootUri, UriKind.Relative)).Stream;
  Stream pixelShaderStream = Application.GetResourceStream(
    new Uri(pixelRootUri, UriKind.Relative)).Stream;

  vertexShader = VertexShader.FromStream(Device, vertexShaderStream);
  pixelShader = PixelShader.FromStream(Device, pixelShaderStream);

  vertexShaderStream.Dispose();
  pixelShaderStream.Dispose();

  // Constant tables
  ExtractConstantsRegisters(vertexRootUri + ".constants", stringsToIndexesVS);
  ExtractConstantsRegisters(pixelRootUri + ".constants", stringsToIndexesPS);
}

Parse Constants Table

The constants file contains all of the information needed to determine which register a named parameter is in. This implementation stores the values in a dictionary for later reference when setting a named constant. It also allows the parameter to be referenced directly using the EffectParameter pattern to avoid dictionary lookups for greater performance.

void ExtractConstantsRegisters(string rootUri, bool isForPixelShader)
{
    using (Stream stream = Application.GetResourceStream(new Uri(rootUri, UriKind.Relative)).Stream)
    {
        XmlReader xmlReader = XmlReader.Create(stream);

        while (xmlReader.ReadToFollowing("Constant"))
        {
            xmlReader.ReadToDescendant("Name");
            string name = xmlReader.ReadElementContentAsString();

            EffectParameter effectParameter;
            if (parameters.ContainsKey(name))
            {
                effectParameter = parameters[name];
            }
            else
            {
                effectParameter = new EffectParameter(device, name);
                parameters.Add(name, effectParameter);
            }

            xmlReader.ReadToNextSibling("RegisterIndex");
            int index = xmlReader.ReadElementContentAsInt();

            if (isForPixelShader)
                effectParameter.PixelShaderRegisterIndex = index;
            else
                effectParameter.VertexShaderRegisterIndex = index;

            xmlReader.ReadToNextSibling("RegisterCount");
            effectParameter.RegisterCount = xmlReader.ReadElementContentAsInt();
        }

        xmlReader.Close();
    }
}

Set Constant

With the mapping loaded, it becomes very easy to set a constant by  name.

public void SetConstant(string propertyName, Vector4 vector4)
{
    EffectParameter effectParameter = GetParameter(propertyName);

    if (effectParameter != null)
        effectParameter.SetValue(vector4);
}

Configure Device

Finally, we can configure the graphics device to use the pixel and vertex shader in the effect and apply the constants.

public class Effect : IDisposable
{
    // Apply
    public virtual void Apply()
    {
        // Shaders
        Device.SetVertexShader(vertexShader);
        Device.SetPixelShader(pixelShader);

        // Parameters
        foreach (EffectParameter effectParameter in parameters.Values)
        {
            effectParameter.Apply();
        }
    }
}

public class EffectParameter
{
    internal void Apply()
    {
        if (data == null)
            return;

        int size = Math.Min(RegisterCount, data.Length);

        for (int index = 0; index < size; index++)
        {
            if (VertexShaderRegisterIndex >= 0)
                device.SetVertexShaderConstantFloat4(VertexShaderRegisterIndex + index, ref data[index]);
            if (PixelShaderRegisterIndex >= 0)
                device.SetPixelShaderConstantFloat4(PixelShaderRegisterIndex + index, ref data[index]);
        }
    }
}

Example

Putting it all together, you can use the effect like this.

var effect = new Effect(device, "MyAssembly", "Shaders/MyShader");
effect.SetConstant("World", World);
effect.SetConstant("Levels", 1.0f, 0.5f, 0, 1.3f);
effect.Apply();

So there you go, no more messing about with manual register allocation!

Do you wish Visual Studio would compile your HLSL files automatically for you? With this build task it can! This is especially useful for taking advantage of the new 3D Graphics support in Silverlight 5.

Grab the build task on the MSDN Code Gallery. Both the source code and the installer are included.

Building

To compile the solution you will need to install the DirectX SDK and the Visual Studio SDK. Afterwards you can open the ShaderBuildTask solution in Visual Studio to build.

Installing

The easiest way to install is to build and run ShaderBuildTaskSetup which will copy the build task to the GAC. The MSI installer is included in the download if you don’t want to build it.

Adding to a Project

Once installed, you can update a project to support the task by adding the following to the .csproj file after the Import element for Microsoft.Silverlight.CSharp.target.

<ItemGroup Condition="'$(BuildingInsideVisualStudio)'=='true'">
    <AvailableItemName Include="VertexShader">
      <Visible>false</Visible>
    </AvailableItemName>
    <AvailableItemName Include="PixelShader">
      <Visible>false</Visible>
    </AvailableItemName>
  </ItemGroup>
  <UsingTask TaskName="ShaderBuildTask.ShaderCompile" AssemblyName=
"ShaderBuildTask, Version=1.0.3072.18169, Culture=neutral, PublicKeyToken=44e467d1687af125" />
  <Target Name="VertexShaderCompile" Condition="'@(VertexShader)' != '' "
BeforeTargets="Build">
    <ShaderCompile Sources="@(VertexShader)" ShaderProfile="vs_2_0"
IntermediateOutputPath="$(IntermediateOutputPath)">
      <Output TaskParameter="Outputs" ItemName="Resource" />
    </ShaderCompile>
  </Target>
  <Target Name="PixelShaderCompile" Condition="'@(PixelShader)' != '' "
BeforeTargets="Build">
    <ShaderCompile Sources="@(PixelShader)" ShaderProfile="ps_2_0"
IntermediateOutputPath="$(IntermediateOutputPath)">
      <Output TaskParameter="Outputs" ItemName="Resource" />
    </ShaderCompile>
  </Target>
  <PropertyGroup>
    <PrepareResourcesDependsOn>VertexShaderCompile;PixelShaderCompile;
$(PrepareResourcesDependsOn)</PrepareResourcesDependsOn>
  </PropertyGroup>

Visual Studio

From Visual Studio, you can change the Build Action of HLSL files to either PixelShader or VertexShader. After building the project, shaders will be compiled and included in the final assembly as a resource.

Use Application.GetResourceStream() to access resources, keeping in mind that the relative path of the containing folder is preserved. For example:

var earthVertexShader = VertexShader.FromStream(
GraphicsDeviceManager.Current.GraphicsDevice,
Application.GetResourceStream(
    new Uri(@"/SolarWind;component/Shaders/Earth_vs.vs", UriKind.Relative)).Stream);

Parameters

The build task supports the following parameters.

• ShaderProfile – The profile to use (vs_2_0, ps_2_0, etc.). This is a required parameter.
• EntryPoint – The default entry point is “main” but can be overidden.
• PackMatrixRowOrder – A boolean that indicates whether to pack matrices in row major order (true) or column major (false).
• OptimizationLevel – This is only supported on new compilers (specify a value 0 to 3).
• Debug – Include debug information (default is false).
• ExportConstants – In addition to exporting a compiled shader, also export an XML file with information about the constants in the shader (default is true).
• IntermediateOutputPath – The path to export compiled shaders and constants to.

Constants Files

By default, constants are exported to an XML file with the same name as the compiled shader with “.constants” appended. This data can be used to map named variables on the application side to constant registers on the shader side.

A sample file snippet is below.

<?xml version="1.0" encoding="utf-8"?>
<ShaderConstants FileFormatVersion="1.0" Version="2.0" Constants="5"
Creator="Microsoft (R) HLSL Shader Compiler 9.29.952.3111">
  <Constant Index="0" Descriptions="1">
    <Description>
      <Name>TotalSeconds</Name>
      <RegisterSet>Float4</RegisterSet>
      <RegisterIndex>16</RegisterIndex>
      <RegisterCount>1</RegisterCount>
      <Rows>1</Rows>
      <Columns>1</Columns>
      <Elements>1</Elements>
      <StructMembers>0</StructMembers>
      <Bytes>4</Bytes>
      <Class>Scalar</Class>
      <Type>Float</Type>
    </Description>
  </Constant>
  <Constant Index="1" Descriptions="1">
    <Description>
      <Name>ViewInverseMatrix</Name>
      <RegisterSet>Float4</RegisterSet>
      <RegisterIndex>12</RegisterIndex>
      <RegisterCount>4</RegisterCount>
      <Rows>4</Rows>
      <Columns>4</Columns>
      <Elements>1</Elements>
      <StructMembers>0</StructMembers>
      <Bytes>64</Bytes>
      <Class>Rows</Class>
      <Type>Float</Type>
    </Description>
  </Constant>
  …

More Information

Original WPF shader build task by Greg Schechter and Gerhard Schneider. Updated by Aaron Oneal to include configurable properties for shader profile, entrypoint, matrix pack order, optimization level, debug, intermediate output path, and shader constants export.

I was looking for a quick way to get syntax highlighting for HLSL inside VS 2010 and came across the NShader project. Install the extension, restart VS, and if you’re using the default VS color scheme you’re good to go.

I picked up a nice color scheme over at StudioStyles and wanted the HLSL highlighting to match. This required deleting the following key using the registry editor:

HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\10.0\FontAndColors\Cache

Then it was off to Tools/Options/Environment/Fonts and Colors to update the “Shader Language” color entries to match.

The 3D samples from my MIX11 session are now online. You can grab them on MSDN Code Gallery.

XNA Math Library – Math library from XNA which is planned for the SDK.

Triangle Sample – Draw a simple triangle by specifying vertices with position and color.

Color Cube Sample – Draw a rotating cube with solid or gradient color faces.

Animated Textured Cube Sample – Draw a rotating cube with texture shaded faces.

Controllable Textured Cube Sample – Draw a textured cube that can be rotated by Silverlight UI controls.

Solar Wind Sample – Draw the Earth with day and night transitions, atmosphere layers, and population density overlays. Demonstrates more advanced concepts like mipmaps, texture blending, multiple drawing passes, sampler states, and lighting.

Windows Café with the Babylon Engine – Make a virtual visit to the Windows Café in Paris. David Catuhe blogged about it here.

House Builder – John Papa wrote about this demo he showed in the keynote here.

I’ll be at MIX11 on Wednesday April 13th to talk about a fantastic new feature coming to Silverlight 5 – 3D Graphics! I hope you can make the session or check it out online.

After binding a workstation to Open Directory I was unable to change this setting using that dialog. Instead, you can change the name using the Terminal.

scutil --set ComputerName NewName

Age of Mythology: Including Titans Expansion is a great game, and since the Titan’s Expansion was never released for the Mac, running the PC version is a job for Parallels. Unfortunately, Age of Mythology doesn’t like the video driver Parallels uses.

This graphics card is not supported by Age of Mythology. Please check microsoft.com for a list of supported graphics cards. Age of Mythology will now exit.

Video Card 0: prl_vadd.dll Parallels Video Adapter Vendor(0x1AB8) Device(0×4005)

Fortunately, you can fix this by dropping some new driver definitions into the following folder:

C:\Program Files\Microsoft Games\Age of Mythology\gfxconfig2

The definitions are attached below and just need to be unzipped to that folder.

AoM Driver Definitions for Parallels

You may also want to modify your startup shortcut to skip intro cinematics and begin in widescreen.

“C:\Program Files\Microsoft Games\Age of Mythology\aomx.exe” +noIntroCinematics xres=1680 yres=1050 bpp=32

One thing I have struggled with through the years is getting computers to sleep and wake up like they’re supposed to. I have usually found the culprit to be one of the following:

• Outdated BIOS
• Hardware or expansion cards that never supported it in the first place
• USB device or HUB that wasn’t energy friendly
• Poorly tested device drivers
• Overactive or misbehaving software

After making sure I have the latest updates to everything, the general troubleshooting technique I follow is to strip the computer or OS down to the bare minimum. Remove all expansion cards and external devices, shutdown all applications, go over running processes with a fine toothed comb, log out, and then verify that the computer sleeps in this clean state.

If that still doesn’t work, to verify it’s not a software issue, sometimes I’ll boot a clean OS from alternate media.

After working perfectly fine for weeks, my new Mac was hit with a bout of insomnia. I could put the computer to sleep manually but it refused to honor the computer sleep timer in Energy Saver preferences. Those long, sleepless nights apparently drained my wireless keyboard and trackpad batteries in short order.

To troubleshoot, I dropped the sleep timer down to 1 minute and waited. The display would blank, but after 10 minutes the computer remained on. Now, under normal conditions, it still takes longer than 1 minute to sleep (more like 3 or so), but eventually it would.

I logged out and sure enough, after a couple minutes the computer slept. So, it had something to do with a running application. I quit all my apps, including those running in the background like Dropbox, Live Mesh, etc. After a few minutes, the computer went to sleep. Through process of elimination I determined that the culprit was Windows Live Mesh. I filed a bug with Microsoft, so hopefully we can troubleshoot this to determine the root cause.

If you’re experiencing a similar issue and are unable to identify it using these steps, you might want to check out a nice little utility called PleaseSleep. It didn’t work in my case, but I have heard overall it has good success forcing the computer to sleep when it is supposed to. The app also records some nice logging information to aid in troubleshooting.