Raytracer Implementation In C-Sharp

My License Thesis at the Computer Science University was a custom-made Raytracer.

I wrote it in Java. Now Java is not the best choice for writing a Raytracer, to be honest.

I should’ve chosen C or C++ at the time, but that’s what my past self decided to go with.

Anyway, the code was much easier to port to C# this time, as all the primitives and raytracing engine were already there.

[RAYTRACER PIC]

I think it looks neat. While it does look simple - you can render only a few spheres and change their color and material properties.

Fractals are special geometrical shapes created through iteration.

You take a simple starting rule and apply it over and over again.

One of the most famous fractals is the Mandelbrot set.

Here it is in action:

Beautiful and mysterious, isn’t it?

If you’re looking to build your own implementation, have a look at the windows forms app to draw fractals I built.

Use it as a starting point or inspiration, feel free to use or mis-use the code.

There are other fractal types, such as

Koch’s snowflake

Sierpinsky’s carpet

Julia Sets

The Julia set is derived from the Mandelbrot fractal.

Back in 2009, I’d already implemented a fractal painter for Symbian S60, as a simple exercise. But it was incredibly slow, running on old hardware with no graphical acceleration.

The 2D Transform Toolkit

What I was really proud of though, was the Toolkit I’d developed. It was capable of transforming 2D coordinates from screen (application) space to 2D space (that’s where fractals live).

It was doing this using 2D transformation matrices.

I’d written my own Matrix2D and Complex classes to handle geometrical transformations in 2D space.

With the proper setup, this toolkit was capable of transforming every point from screen space to 2D coordinates.

Screen space (where pixels live) and the 2D world are two separate universes.

Fractals or any other geometrical objects live in 2D space. They have real coordinates and obey mathematical rules. They can be shrunk, grown, rotated, or moved up or down any axis.

But you need coordinates for that, both negative and positive, on both the X and the Y axes, respectively.

Objects in screen space have coordinates that go between 0 and the width of the screen (or drawing buffer). You can’t do much with an object limited between 0 and 640 pixels.

In 2D space, you’re free to do whatever you want with mathematical entities living there.

That’s why we need a way to transform pixels to and from the two worlds. And that’s what the Toolkit does.

Porting Challenges

Here are the challenges I had with the App:

• porting the C++ Symbian S60 code to C#
• implementing a parallel rendering algorithm I could re-use in other projects
• rendering multiple unrelated fractal types, besides the Mandelbrot set.
• implementing a dynamic properties editor

I wanted a base class so I could render multiple fractals dynamically.

I wanted a fractal editor for every type of fractal.

Now the biggest challenge with the fractal painter was parallel rendering.

Since I’d already implemented the algorithm 15 years ago, I thought I’d speed up things and use ChatGPT to speed up the translation from C++ to C#. While I do use AI, I also like to take ownership of the code it gives, to “make it mine”.

TBD: Link to CS_GRAPHICS instead

Now, at the time of the writing, a few issues remain:

• not all fractal types are implemented
• progress bar does not work yet
• updating the world view coordinates does not work
• would be nice to have a zoom-in function
• rendering takes a bit too long, even with multi-threading
• the application remains unresponsive while rendering the fractal

The best part is that I’ve put the rendering algorithm in a separate class so that I could re-use it for…

I wanted to re-use the DialogSelectTransform component from COMMON_FORMS.

I’m already successfully using in another projects and it works perfectly.

Here it is in action.

On the left, you configure a condition, (e.g. ConditionHasExtension).

And on the right, you select an action to apply when the condition is met. (e.g. ActionAddYaml to add yaml front-matter data to your files).

This dialog should be re-usable.

And I thought it was.

But, when I wanted to use it with a different set of Transforms, compilation failed.

Why?

Well, in MASS_YAML, I’m adding and editing string transforms - Transform<string>.

And in MEMPHIS_SHARP, I wanted to edit Transform<Token>.

The actual class is generic - Transform<T>

So, I made the dialog class generic:

public partial class DialogSelectTransform<T> : Form

Simple, no?

Wrong:

Turns out, the Designer can’t edit generic classes, even if they inherit Form or UserControl.

Bummer.

Now what?

Well, ChatGPT suggested I create a concrete class DialogSelectTransform<string> which inherits from the generic base class DialogSelectTransform<T>.

And that should work.

No, it didn’t. Bad GPT!

Although ChatGPT insisted it should, confidently.

But when I questioned it, it admitted he was wrong.

The approach wouldn’t work. I wonder who feeds it with data, honestly.

And if you question it, it says “you are right, it won’t work”.

Anyways, I can use the dialog with Transform<Token>

But I can’t edit it anymore.

So, I have to find a solution that allows me to still edit the dialog and keep the generic aspect of it.

Honestly, I’m up for the challenge!

Until next time.

Later edit: Apparently, if I remove the generic <T> argument from both DialogSelectTransform.cs and DialogSelectTransform.Designer.cs, the form will load and will be editable. And when I’m done, I just have to add the <T>’s back. Huh.

In one of my projects, I have a class hierarchy sharing a common base class - Action<string>.

For simplicity, we’ll name it FileAction in the diagram below.

Multiple classes inherit and extend the base class:

There are more classes in the hierarchy. Additionally, any app using the class hierarchy can add their own Action implementation as needed.

I want to automate the creation of derived classes instances’, based on string identifier.

Also, I want any app using the class hierarchy to use the solution out of the box.

Something like

Action = Solution.Create (“ActionCopyFile”);

So, what’s the solution?

It’s a design pattern named The Factory Method.

Declaring A Generic C# Factory

The GenericFactory class will have:

• one generic argument TBase (the base class of the hierarchy)
• a dictionary to store associations between a string ID and a Creator method (mCreators)
• a register method to associate an ID with a Creator (Register)
• a create method to call the Creator associated with an ID (Create)

This way, we can use the generic factory with multiple class hierarchies.

A Creator is a delegate that will match any method returning a class instance derived from TBase.

We’re also making all class members and methods static.

This way, you won’t have instantiate the factory class every time you want to use it.

The Register Method

Simply adds a new entry to the dictionary.

Some additional checks are required before adding the pair:

• prevent an empty ID
• prevent and empty creator
• prevent duplicate entries

//  Registers a creator delegate by id
public static void Register(string id, Creator creator)
{
    //  TBD: Localize the exception messages
    const string KMsgNullId = "ID cannot be null or empty.";
    const string KErrDelegateNull = "The creator delegate cannot be null.";
    const string KErrCreatorAlreadyRegistered = "There is a creator already registered with ID {0}";

    if (string.IsNullOrWhiteSpace(id))
        throw new ArgumentException(KMsgNullId, nameof(id));
    
    if (creator == null)
        throw new ArgumentNullException(nameof(creator), KErrDelegateNull);

    if (!mCreators.TryAdd(id, creator))
        throw new InvalidOperationException(string.Format(KErrCreatorAlreadyRegistered, id));
}

Using the method looks something like

GenericFactory<string>.Register("actionCopy", () => new ActionCopyFile());

I’ve used a lamba expression as the 2nd argument to simply create a new instance of the ActionCopyFile;

But it can be any other method that matches the Creator delegate signature.

The Create Method Call

This method is responsible with finding and invoking the creator associated with and ID.

If no creator was found, an exception is thrown.

//  Calls the associated creator for the specified ID
public static TBase Create(string id)
{
    if (mCreators.TryGetValue(id, out var creator))
        return creator();
		
    throw new KeyNotFoundException($"There is no creator registered with the ID \"{id}\".");
}

Better readability with global usings

If I want to use the generic factory and pass it a generic argument of RealityFrameworks.Actions.Action, I have to write:

RealityFrameworks.GenericFactory<RealityFrameworks.Actions.Action<string> >;

There has to be an easier way than this!

Enter global usings.

I’ve created a GlobalUsings.cs file and added it to the project.

Inside it, I’ve put aliases:

// GlobalUsings.cs
global using FileCondition = RealityFrameworks.Conditions.Condition<string>;
global using FileAction = RealityFrameworks.Actions.Action<string>;

global using FileTransform = RealityFrameworks.Transform<string>;

global using FileConditionFactory = RealityFrameworks.GenericFactory<RealityFrameworks.Conditions.Condition<string>>;
global using FileActionFactory = RealityFrameworks.GenericFactory<RealityFrameworks.Actions.Action<string>>;

global using EditorFactory = RealityFrameworks.GenericFactory<CommonForms.EditorBase>;

It looks better and much faster to use, don’t you agree?

I’m much happier with the shorthand notation, thank you very much.

The only fallback? The aliases are visible only within the current assembly.

If I want to use those aliases in a different assembly, I must define them again, in their own GlobalUsings.cs file.

Registering multiple creators

In my main app, I’ve created a method to register all creators and calling it once, in the constructor of the main windows form.

private void RegisterCreators()
{
	//  REGISTER ACTION Creators from RealityFrameworks assembly
	FileActionFactory.Register(typeof(ActionCopyFile).Name, () => new ActionCopyFile(Path.GetTempPath()));
	FileActionFactory.Register(typeof(ActionAppendToFile).Name, () => new ActionAppendToFile());
	FileActionFactory.Register(typeof(ActionRenameFile).Name, () => new ActionRenameFile());
	FileActionFactory.Register(typeof(ActionGroup<string>).Name, () => new ActionGroup<string>());
}

Using the Create method

And this is how you use the Create method with a generic factory.

string actionId = typeof(ActionCopyFile).Name;	//	or any other valid action ID
var action = FileActionFactory.Create(actionId);

Simply pass a string identifier to the Create method of the factory.

Full Source Code

Download the full generic factory code here.