Stay tuned (for another 4 years?)

Small update...

Hi there.

Revision 71 is here and it has the following key features implemented:

The scene editor is now highlighting C# sourcecode. That makes sense beacause I implemented the necessary routines to assemble scene objects from C# sources using the CodeProvider and Compiler Objects. (Actually "using" Microsoft.CSharp; System.CodeDom;  System.CodeDom.Compiler; and System.Reflection; :D )

The next step will be to create open and save routines for the scene's code and settings. Best would be to have both in one file. And maybe to compress this file, because as soon as I will have vertices for polygons and the like to store, the file size will surely explode. This leads me to another idea: Having polygonal data in "resource file" like structures - so the scene code remains clean and the models (maybe in a standard format like obj) remain viewable (and maybe editable) by third-party programs. But there's still a long way to go until efiRay will render 3d models.

Well. Now, the fact that efiRay can build scene objects from code may be nice but is not that impressive, I guess. The other good news are: The renderer is back! ("Back" in terms of "entirely written from scratch")

Take a look at it here - It features a rendering pipeline, image transparency and live preview updates:

The screenshot shows the rendering-in-progress of the above listed sourcecode. I am currently working on the first raytracing module that will be used as preview renderer for materials. The next modules for the pipeline will be ambient occlusion and depth renderers, since they are not too hard to implement, I hope.

But befor that I need new primitives. Spheres only are not really satisfying.

So stay tuned!

new BlogWrapper("http://efiray.blogspot.com",BlogService.GoogleBlogger).BeginInvoke(update);

After a relatively short time with a large effort put on efiRay, there followed a relatively long time with only few work units completed.

But a few things have evolved out of the primordial soup since the last blog entry was posted.

So what's new in "Revision 59"? (The version counter is somewhere between 0.01 and 0.05...)

Well, many important features have been added, like the aplha channel enabled splash screen (picture above) and a bunch of new icons (picture below)

The icons are still work in progress, so the following overview is just a small part of the final library (that will not only be limited to icons needed and used by efiRay). I plan to release the icons for free use as soon as they have a certain number and quality. Until then I will only post preview versions. Like this one:

But also some real code has been written. New base classes, interface descriptions and abstract template classes have were introduced. (I know, this is no "real" code either...) But I implemented a commandline parameter handler and some fundamental parts for a plugin system. And the routines for thread-safe UI commands have also been further refined. 

The plugin list

Next steps will be about SceneFile saving and opening, Logging and ApplicationSettings and maybe a simple scene description language + simlpe renderer (as stupid as the one from the early alpha)

OK. That's it for today. Another status update will follow before the end of this year, hopefully. Just in case you were curious: This is efiRay:

And this is the efiRay repository:

programming || programming

Yes, you guessed it right: This blog entry will be all about parallel programming. Using the GPU (and maybe soon multiprocessor systems)!

And this entry looks very short. Seems odd to you? Because parallel programming is all complicated and weird and a lot to explain?

:D That's generally true and so I am happy that the guys at Microsoft did some nice research and came up with the "Microsoft Research Accelerator" - a library for .NET that lets you perform parallel operations on simple typed arrays. Sounds pretty cool, eh? Read the paper to get an idea of the whole power that it bears.

I won't use it for the efiRay core, but some special rendering algorithms (which I plan to implement as "modules") might benefit heavily from parallel computing.

The best: It's free for non-commercial use. And what could be more non-commercial than efiRay? (, that will come - set that it WILL come - "...without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE ...")

There's only one flaw: It does not (yet) run on my machine. So I will keep it in mind, wait for new versions (of Accelerator and my dev-machine :D ) and... do some basic stuff that is necessary anyways before doing optimizations like using parallel GPU calculations.

Cinema 4D as my sandbox

I am constantly trying to avoid structural mistakes in the efiRay back end. So I decided to dive a bit deeper into geometry and shader programming prior to even starting to implement them.

Drawing paper sketches and coding single-topic-prototypes is a bit too far away from the matter as to be useful in understanding pretty complicated aspects of 3D calculations.

I needed something "ready" to play with. And found it in my "old friend" Cinema 4D. (I possess version 6 CE which is and looks in fact "old" compared with the current version R10)

There are two ways to program for and extend this excellent piece of software: Writing a c++ library (complicated but producing fast plug-ins) and using their proprietary c++-like extension language "C.O.F.F.E.E." (much easier to handle but slower). As computer hardware gets faster and faster these days, but my available time is very limited, I decided to get me a cup of COFFEE.

With a little help from a kind C4D-plug-in guru ;-) I managed to get my hands on the old COFFEE-SDK-chm-file. That one was really a great benefit for me since it saved me from analyzing dozens of other people's plug-ins to get answers to the basic questions...

The provided screenshot shows a scene, created and rendered in C4D using some built-in, self-made, third-party or SDK-originated shaders. It is amazing what level of enhancement those plug-ins can bring!

Besides writing fancy shaders I plan to implement a Menger Sponge generator. I hope to get inspiration on how to realize vertices, polygons (along with their normal vectors), edges and the like in efiRay.

Basic Make-Up

Low-class appliations can easily get popular as soon as they have a neat UI. So I choose only the best (free) UI components for efiRay.

My choice so far:

Telerik RibbonBar (as mentioned earlier it's free for registered MSVC#Express-users)

SteepValley XPCommonControls (free XP-alike controls - for example a very nice ItemList)

ComponentFactory Krypton Toolkit (free skinned - i.e. e.g. Office2007-ish - controls for grouping and displaying basic controls)

The Ghengis Project (free Functionality for covering various smaller issues)

Skybound Components (free controls - for example an enhanced tooltip provider)

Empty Project Files

Just a small status update here:

I set up a SubVersion server and filled my new repository with an empty core framework of EfiRay.

As you can see on the first picture, everything is working smoothly - even with all the third-party UI-controls ;-)

Oh, and my Vector3D-class got a struct. For efficiency reasons, I think. Basically beacause FxCop adviced me to do so.