You have to care for your environment...

Before I will release further details about the project's folders, assemblies, classes, resource files and all that is connected with that structures, I am posting a short list with my "weapons of choice":

Visual C# Express for a little coding

FxCop for complicating the coding process and annoying the coder

Lutz Roeder's Reflector for gaining insight

NUnit for unit-testi... Nah, I think' I will leave that out

Subversion and TortoiseSVN for keeping track of bad code bloating up to be really bad and fat code

WinMerge for blending together only the best ingredients

NAnt for any build related scripting (as soon as necessary)

NProf as a profiler although it is hard to find information in its pretty non-visual interface - but it seems to be the only free .NET-Profiler around... UPDATE: The newest Version 0.9 is way more useable, but the default sourceforge donload is v.0.1

NCover, with NCoverExplorer or NCoverBrowser for "code coverage" studies - may or may not be useful (with unit testing) .

ILMerge for combining different exe and dll files into one assembly.

DocMounter for "external" code documentation

... more to come here, too

Off we go...

Although I am still kind of clueless how this whole project will evolve and what steps it will successfully pass until I'm too bored or busy to further work on it and abandon efiRay... I prepared for the optimistic case - a longer period of work. :D

Three brand new books (displayed on the right hand side) will assist and guide me through the design and development phase of efiRay.


Here's a short list of things that will probably be implemented or adopted in efiRay:

r.a.d.RibbonBar for storing the vast amount of functionality of efiRay and providing quick access to all the views, buttons and other resources... (In short words: "eye candy"- pseudo-usability-increasing eye-candy...)

A MS Application Block for professional logging that could (or could not) be used even for monitoring network rendering. Or:
log4net as part of a homebrew logging solution.

Piccolo, a discontinued, but incredibly useful 2D-graphics framework that could be easily used to provide node-map-views for connecting multiple render passes to a rendering pipeline or for stacking and combining procedural textures from their generators. (Maybe also to generate more flexible TreeView "component")

Something like this to get the overheads of XML (disk space) and compression algorithms (time) out of scene files.

Command Management to separate UI from functionality and to make several occurrences of the same command possible without having additional logic or double passages to implement

This Library and controls collection could provide useful functionality such as a picture preview, a syntax highlighted editor, visual studio like document tabs and maybe much more.

...more thoughts to come!

Mindmap pre-alpha

As I am progressing with efiRay, I now reached the point where further development would result in a program that is hard to change, extend and maintain. So I decided to skip the current program as a POCP (proof of concept prototype) and go on creating an extensible application framework for any scene- and ray-tracer-related code to rest in.

That means building base classes, commandProcessors, eventPipelines, messageQueues and lots of other stuff prior to even implement a cube primitive. That's annoying me to some extent but I know that this is a wise step to take at an early state of the project.

This is what I see as necessary points so far: This mind map will of course grow significantly in the next few days.
(And get rid of the writing mistakes that are probably in it.)

When it is nearly comprehensive I will start to UMLize it. Then I will design and construct some framework necessities. And after that the efiRay core functionality will be extended. (OK, from that time on I will start to implement "core functionality" at all.)

Here comes a little status update with some images attached and a list of things planned (or just dreamed of).


I recently introduced the following new features:

• Basic Colors
• Anti-aliasing by uniform oversampling
• Composite transparency
• "EternalPlane" primitive to support the "Sphere" primitive
• Rendering in an extra Window
• Pseudo shading through scalar product gradient (to be replaced soon)

Things to come in the near future:

• Rendering in Threads
• Hitpoint calculation, "z-Buffer"
• Normals at hitpoint --> real shading
• Better camera viewport model(s) for fisheye view and the like
  

Things to come after that:

• Lights & Shadows (Light source mapped, fully ray traced or mixed)
• Load & save XML scene files
• More primitives
• Fog
• Materials with basic procedural shaders
• Reflections (probably with bias limit termination rather than limited reflection depht)
• Tesalliaton for flat-sided parametric and for non-parametric objects

Long-term goals:

• Shader Framework
• Panorama rendering
• CSG
• Simple NURBS objects from splines or formulas
• Surface smoothing (normal interpolation or subdivision)
• UVW/Textruring support
• HDRI/Tonemapping functionality
• Import and export for popular (object) formats

Even-longer-term goals:

• Full parametric objects and splines support
• Radiosity / Caustics / Photon Mapping / Final Gathering / Metropolis Light Transport andstuff like that
• Scripting framework, Animations
• Motion Blur / DOF
• Optimized, multi-threaded program code
• Import and export for various object- and scene-formats, maybe also export to (non-RIB/RAYES)-renderes

And so much more...

It's halfway done!

Almost...

Who needs shading? Or z-order? Or colors?

Math Toolkits

Well, I have been pretty aware of the fact that a raytracer contains about 100% math, and I took the challenge anyways.

I always wanted to get all involved with the complicated calculations, but nevertheless still wondered if there are any means to bypass the basic stuf. Not that my "Vector3D" class did not function correctly, it is the sole question of optimisation and efficiency that let me consider to use an external library for covering the basic math functionality.

The following addresses link to some math-related assemblies for .NET that seemed to fit my needs:

http://www.codeplex.com/Wiki/View.aspx?ProjectName=Sharp3D
http://www.cdrnet.net/projects/nmath/
http://www.dnanalytics.net

But they are unfortunately not as useful to me as they seemed. So I have to go on with straightfoward self-coded but unoptimized arithmetics.

Hey, seems like I'm going to write the worls's slowest raytracer ever!

Yet another bad idea - Yet another hobby raytracer to be created.

This is a placeholder for the Project description. - Preface, Motivation and other Blah-blah to come...

Links to remember for that time:

http://winosi.onlinehome.de/
http://www.slimeland.com/raytrace/