Here’s another couple of examples, which show that we can apply our material to various shapes and are able to discard part of the output geometry based on a displacement threshold:

A glsl based ray-tracer that allow you to conjure beautiful images of you Minecraft worlds.

“But why was this created ?”  There is not a reason for everything in this world and it still remains a mystery why. But clearly someone has too much spare time..

To proceed please roll a dice 6 to test your luck!

If you are lucky and got a 6! go here.

Else bad luck go here.

Or if you find these kind of things anoying go here.

And by the way merry christmas to you all

We hope that you will enjoy working with procedurally generated effects as much as we do!

Come take a look at how the tool is used at our vimeo channel at http://vimeo.com/channels/elementacular

Interested in trying it out? – apply for the beta starting soon at http://www.elementacular.com

Furthermore, we have updated to tool to support much more varied looks as shown in the rock material collage below

If you want to participate by testing the plugin please contact jesper.borlum@alexandra.dk.

The image above shows the final results.

The participants of the workshop wanted to be able to model using traditional geometry, so we have created a plug-in for Maya which allows you to create a cloud from any input mesh. As an initial step in this plug-in, the geometry is voxelized in a desired resolution in real-time. The following videos demonstrate this voxelization:

In the following steps of creating a cloud, we compute a distance field from the surface of the input geometry and combine it with a noise field to compute a detailed and visually interesting cloud density. You can see the result of our real-time ray marching of the final cloud representation in the following images and video:

In the near future, we will start looking at improving the performance of the ray marching, and we will support more complex lighting. Also, we plan to support user-defined noise functions that depend on the cloud geometry to be able to support different kinds of clouds. Finally, we would like to explore incorporating vertex-defined attributes such per vertex colors, noise, etc. into the cloud generation.

The video below demonstrates how to work with the plug-in. If you would like to try out the plug-in, please contact us at jesper.borlum@alexandra.dk

Material presented in the talk:
Slides (pdf)
Demo 1: Motorcycle
Demo 2: Cornell box Xmas theme

Usage
Use the left mouse button and the keys “wasdqe” to control the camera.
Use the right mouse button to select objects in the scene. The active object can be translated with the gizmo and the material can be changed in the column on the right hand side.

Requirements
You should ensure that you have a web browser that supports WebGL with the OES_texture_float extension.
If you use Windows you will need a recent version Firefox (v17 has been tested) or Chrome (v23 has been tested) due to some optimizations in the shader compiler in the Angle layer. Alternatively you have to enable native opengl in your browser (in Firefox open about:config and set webgl.prefer-native-gl=true, in Chrome use the command line argument –use-gl=desktop).

You can also load your own 3d models. This feature was used for our Xmas competition which was won by this nice image created by Jonas Raagaard.

We would like to invite you to participate in our first open workshop with the purpose of qualifying the project direction and to anchor the project in more Danish companies.

The workshop is on the 13th march 2013 at 1PM – 4PM at the Alexandra Institutte in meeting room Ada-333.
Sign up: http://www.doodle.com/7hqft2934eqswdn3

The main focus of the project is to build a software platform on which new techniques are able to facilitate quality improvements and faster production in the danish creative industry. By using result-oriented 3D-software we enable the artists to work directly on the final visual result and by doing so we allow the artists to be more creative.
We are going to give an introduction to what it could mean to be working using result-oriented 3D-software. Afterwards we would like the participating companies to join in – and tell us about the challenges you see in 3D software today.
We hope you will participate in our workshop and by doing so help us target the challenges faced by your company.

More information about the project can be seen here:

Artikel på Alexandra.dk: Aarhusianere vil udvikle smarte skyer og flammer til film

Artikel i Jyllands-Posten: Penge, der går op i røg

We use a standard pathtracing algorithm with a binary bounding volume hierarchy (BVH) acceleration structure. We store one triangle in each leaf node of the BVH tree. Probably the most common and efficient way to do ray-triangle intersection tests with the BVH tree is to maintain a stack of pointers to nodes that need to be tested. The basic tree traversal algorithm is outlined in the code listing below. A nice property of this algorithm is that each node is never visited more than once.

closest_hit = infinity
stack.clear()
stack.push(root)
while(stack.size() > 0)
{
  currentnode = stack.pop()
  if (currentnode.is_leaf == true)
  {
    // Do ray primitive intersection and update hit record
    hit = ray_triangle_intersection(ray,currentnode.triangle)
    if ( hit < closest_hit )
      closest_hit = hit
  }
  else if ( ray_box_intersection(ray,currentnode.bbox) < closest_hit )
  {
    stack.push(currentnode.leftchild)
    stack.push(currentnode.rightchild)
  }
}

In GLSL it is not possible to implement a fully dynamics stack. However, in GLSL 3.3 it is straightforward to implement a fixed sized stack of pointers as an integer array with a stack counter, e.g.

int stack[16];
int stackcounter;
...
int currentnode = stack[stackcounter];
...
stack[stackcounter] = child;

Unfortunately, the OpenGL ES Shading Language 1.0 does not allow us to access an array element with a variable index, so a stack based approach is not feasible in WebGL. Thus, we implemented the stackless BVH traversal proposed in Ref. [1], which was reported to be about 30 % slower than the stack based traversal.

An additional problem with WebGL is that Windows browsers by default translates OpenGL calls to DirectX through a layer called ANGLE. Our experience with this translation is that loops in shaders get unrolled, and, hence, if we have shaders with very long loops, the shader compiler may run out of resources and fails to compile. With the typical scenes and BVH trees that we have tested, the ANGLE shader compiler can only compile a shader that traverses the tree a single time, i.e., we can only implement a pathtracer with a single bounce. Our solution to this problem is to run each bounce in a separate pass and save the state between the passes. This method will potentially involve some overhead because intermediate results must be read from and written to a texture. Additionally we must issue an additional draw instruction for each trace pass.

Linux and Mac browsers use the native OpenGL shader compiler. The Nvidia compiler that we have tested compiles the full pathtracer in a single shader without any problems.

Test setup
Nvidia GeForce 470 GTX
Intel E5620 2.4 GHz Quad Core
Linux Nvidia drivers version 304.43
Windows Nvidia drivers version 306.97

Our test scene consists of 8728 triangles. The figure shows the final pathtraced image.

Results
Our benchmark results are shown in the table and figure below. If we compare the stackless and stack based versions in GLSL 3.3, we see that the stackless version is almost 50% slower, which is somewhat disappointing compared to the results reported in [1]. WebGL/GLSL ES 1.0 seems to be slightly slower than GLSL 3.3 when we do the full pathtracing in a single shader. The WebGL multipass version does not seem to be affected much by storing intermediate results between the passes. In fact the fastest multipass results are comparable with the results obtained with GLSL 3.3.