I've attached a compiled version of the XLE tools to the Github repo.

This is still an early build -- and hasn't be extensively tested on different hardware. So some features may not work on configurations. If you run in problems, or if you find it interesting, I recommended downloading the source and compiling for yourself.

Download

XLE v0.04.1: XLE v0.04.1 Windows x64

You will need Visual C++ Redistributable Packages for Visual Studio 2013.

For older versions of Windows, you will also need to install the .Net runtime.

Edit -- updated to link to v0.04.1 (which fixes a problem locating the shader compiler dll on some versions of windows).

Documentation

I've included a couple of "Getting Started" docs:

1. Getting Started Exporting
2. Getting Started with Terrain

Along with the tools improvements, I've added a few features to make the "Environment" sample a little easier to use.

Exporting to the Environment sample

1. Start a new world
2. Find the "palette" window and drag these objects into the main viewport:
   • CharacterSpawn
   • AmbientSettings
   • DirLight
     
3. You may want to position the character spawn and directional light using the move manipulator
4. Save your world to some location (with "File/Save As"). The next step will create an export relative to this location.
5. Do an "Export to game":
   • in the level editor, the world is stored as large XML tree. But this isn't loaded into the environment sample. Instead we have a number of small configuration files.
     
6. Now execute the environment sample:
   

Here's a rundown of some of the latest improvements to the tools. These are just a few additions and improvements made over about a week's time.

Search and Replace for placements

Find placements using complex queries:

Once found, they can be selected from the results menu (or run a replace operation).

Sometimes it's useful to search for placements that use a specific model:

Grouping support for placements

Group together objects to make them easier to use. Support for hierarchical groups. Use the “Any Object (ignore groups)” filter to ignore groups when selecting.

Randomize transforms

I've been playing with the transmitted specular implementation for IBL, and working on getting the right balance and visual impression for glass.

Background textures from http://www.hdrlabs.com/sibl/archive.html

It's curious to think about how terms have changed over the last few years. "Specular transmission" is the term I've been using to talk about what we might have previously called "refraction mapping", and "specular IBL" is the new term for "reflection mapping." The new terms show how real-time methods are now encompassing ideas previously only used in ray tracers.

Basic method

I've using the basic method from the GGX paper, "Microfacet Models for Refraction through Rough Surfaces" from Walter, et al. This matches our reflection implementation, of course, because the math for our reflection method is also based on that paper.

I've been able to adapt the math to the split-term concept used for reflected specular IBL. It works just the same way; we have one lookup-table that tell us the brightness of the refraction, and a cubemap that is pre-blurred according to the shape of our lighting equation.

See the page on Improved IBL for more information that that split-term stuff.

The basic principles are simple. But followed blindly, the results do not quite feel right. It turns out that specular transmission is more complicated than specular reflections. I'll talk about some of the complications involved in the implementation...

Relationship between "specular" and index of refraction

It's important to remember that there is a relationship between the "specular" material parameter and the index of refraction.

I've been working on improving the accuracy of the Imaged Based Lighting (IBL) solution for XLE. This is the technology that allows us to load in a background panorama map and use it for both diffuse and specular lighting.

The best way to do this is by comparing our real-time result to other renderers. So, for example, I've been experimenting with Substance Designer (more on that later). It has nVidia's "IRay" raytracer built-in -- so we can compare the non-real-time results from IRay with real-time XLE. I have other ways to do this, also -- for example, the shader in ToolsHelper/BRDFSlice.sh can generate textures directly comparable with Disney's BRDFExplorer tool.

While doing this (and working on the specular transmission stuff), I've found some interesting improvements to the IBL solution!

Conclusion

This is a really long post; so I'll start with the conclusion. I've made a number of improvements that make the IBL solution appear more realistic, and more similar to ray tracers.

"Jamie Gnome" model from here: http://www.turbosquid.com/3d-models/free-obj-mode-jamie-hyneman-gnome/789391

I found some errors in some source material I referenced and fixed some incorrect assumptions I made. Each change is small. But when added up, they make a big difference. The IBL specular is has a lot much punch, things are jumping off the screen better.

Now, I'll go into detail about what's changed.

IBL basis