Reworked color class:

- renamed to RgbColor
- using operators instead of methods
- replaced usages

Author: danmunteanu

Editors/EditorMaterial.cs

@@ -12,7 +12,7 @@ public EditorMaterial()
 
         public override void ResetState()
         {
-            //  TBD: Color
+            panelColor.BackColor = System.Drawing.Color.White;
             numGloss.Value = 0;
             numSpecular.Value = 0;
             numReflection.Value = 0;
@@ -31,9 +31,9 @@ public override void LoadState(object item)
             if (obj.Material == null)
                 return;
 
-            int r = (int)(obj.Material.Color.r * 255);
-            int g = (int)(obj.Material.Color.g * 255);
-            int b = (int)(obj.Material.Color.b * 255);
+            int r = (int)(obj.Material.Color.R * 255);
+            int g = (int)(obj.Material.Color.G * 255);
+            int b = (int)(obj.Material.Color.B * 255);
             panelColor.BackColor = System.Drawing.Color.FromArgb(r, g, b);
 
             numGloss.Value = (decimal)obj.Material.Gloss;
@@ -51,9 +51,9 @@ public override void SaveState(object item)
 
             // take color from panel and store back into Material.Color
             var c = panelColor.BackColor;
-            obj.Material.Color.r = c.R / 255f;
-            obj.Material.Color.g = c.G / 255f;
-            obj.Material.Color.b = c.B / 255f;
+            obj.Material.Color.R = c.R / 255f;
+            obj.Material.Color.R = c.G / 255f;
+            obj.Material.Color.R = c.B / 255f;
 
             // save numeric values back into material
             obj.Material.Gloss = (float)numGloss.Value;

Engine/Raytracer.cs

@@ -49,19 +49,20 @@ private struct RayTraversalResult
 
         public Raytracer() { }
 
-        private Color computeSpecular(float vDotR, float mGls, Color sourceSpec, float matSpec)
+        private RgbColor computeSpecular(float vDotR, float mGls, RgbColor sourceSpec, float matSpec)
         {
-            return sourceSpec.Multiply((float)Math.Pow(vDotR, mGls) * matSpec);
+            float factor = (float)Math.Pow(vDotR, mGls) * matSpec;
+            return sourceSpec * factor;
         }
 
-        private Color computeDiffuse(float nDotL, Color sourceDiff, Color matDiff)
+        private RgbColor computeDiffuse(float nDotL, RgbColor sourceDiff, RgbColor matDiff)
         {
-            return sourceDiff.Multiply(nDotL).Multiply(matDiff);
+            return sourceDiff * nDotL * matDiff;
         }
 
-        private Color trace(Ray ray, int depth)
+        private RgbColor trace(Ray ray, int depth)
         {
-            if (Scene == null) return Color.black;
+            if (Scene == null) return RgbColor.Black;
 
             mIntersector.Ray = ray;
 
@@ -86,7 +87,7 @@ private Color trace(Ray ray, int depth)
                 }
             }
 
-            Color lit = Color.black;
+            RgbColor lit = RgbColor.Black;
 
             if (closest != null && mIntersector.Result == Intersector.IntersectionResult.Hit)
             {
@@ -114,26 +115,26 @@ private Color trace(Ray ray, int depth)
                     if (ComputeSpecular)
                     {
                         float vDotR = v.Dot(r);
-                        Color spec = (vDotR > 0)
+                        RgbColor spec = (vDotR > 0)
                             ? computeSpecular(vDotR, mat.Gloss, light.getColor(), mat.Specular)
-                            : Color.black;
-                        lit = lit.Add(spec);
+                            : RgbColor.Black;
+                        lit = lit + spec;
                     }
 
                     if (ComputeDiffuse)
                     {
                         float nDotL = n.Dot(l);
-                        Color diff = (nDotL > 0)
+                        RgbColor diff = (nDotL > 0)
                             ? computeDiffuse(nDotL, light.getColor(), mat.Color)
-                            : Color.black;
-                        lit = lit.Add(diff);
+                            : RgbColor.Black;
+                        lit = lit + diff;
                     }
 
                     if (GlobalReflection && refl > 0 && depth < TraceDepth)
                     {
                         Ray reflected = new Ray(intersectionPoint, r);
-                        Color acc = trace(reflected, depth + 1);
-                        lit = lit.Add(acc.Multiply(refl).Multiply(mat.Color));
+                        RgbColor acc = trace(reflected, depth + 1);
+                        lit += acc * refl * mat.Color;
                     }
                 }
             }
@@ -227,13 +228,13 @@ private void RenderChunk(Point start, Point end, byte[] pixels, int stride)
                 dir.Normalize();
                 Ray ray = new Ray(Camera.Eye, dir);
 
-                Color c = trace(ray, 1);
+                RgbColor c = trace(ray, 1);
 
                 // Write into pixel array (thread-safe)
                 int index = iter.Cursor.Y * stride + iter.Cursor.X * 4;
-                pixels[index + 0] = (byte)(c.b * 255);
-                pixels[index + 1] = (byte)(c.g * 255);
-                pixels[index + 2] = (byte)(c.r * 255);
+                pixels[index + 0] = (byte)(c.B * 255);
+                pixels[index + 1] = (byte)(c.G * 255);
+                pixels[index + 2] = (byte)(c.R * 255);
                 pixels[index + 3] = 255; // full opacity
 
                 // Thread-safe progress update

MainForm.cs

@@ -57,7 +57,7 @@ private void BuildScene()
 
             Sphere s1 = new Sphere();
             s1.Origin = new Vector(-3.5f, 0, 0);
-            s1.Material.Color = Color.blue;
+            s1.Material.Color = RgbColor.Blue;
             s1.Material.Gloss = 30;
             s1.Material.Specular = 1.0f;
             s1.Material.Reflection = 1.0f;
@@ -67,7 +67,7 @@ private void BuildScene()
 
             Sphere s2 = new Sphere();
             s2.Origin = new Vector(3, 0, 0);
-            s2.Material.Color = Color.red;
+            s2.Material.Color = RgbColor.Red;
             s2.Material.Gloss = 10;
             s2.Material.Specular = 0.8f;
             s2.Material.Reflection = 0.0f;
@@ -78,7 +78,7 @@ private void BuildScene()
 
             Sphere s3 = new Sphere();
             s3.Origin = new Vector(0, 0, 0);
-            s3.Material.Color = Color.green;
+            s3.Material.Color = RgbColor.Green;
             s3.Material.Gloss = 10;
             s3.Material.Specular = 0;
             s3.Material.Reflection = 0;
@@ -87,12 +87,12 @@ private void BuildScene()
             mScene.AddObject(s3);
 
             Plane pln = new();
-            pln.Material.Color = Color.yellow;
+            pln.Material.Color = RgbColor.Yellow;
             mScene.AddObject(pln);
 
             PointLight p = new PointLight();
             p.setPosition(new Vector(0, 15, 35));
-            p.setColor(Color.white);
+            p.setColor(RgbColor.White);
             p.setName("Point Light");
             p.setEnabled(true);
 

Model/Color.cs

@@ -7,7 +7,7 @@ public Material()
         {
         }
 
-        public Color Color { get; set; } = new(0, 0, 0);
+        public RgbColor Color { get; set; } = new(0, 0, 0);
 
         //  the "Phong" exponent;
         //  small => large hotspot, gradual fallof;

Model/Material.cs

@@ -3,7 +3,7 @@ namespace UnilightRaytracer
     public class PointLight
     {
         private Vector position = new Vector();
-        private Color color = new Color(1, 1, 1);    //  same color used for diffuse and specular
+        private RgbColor color = new RgbColor(1, 1, 1);    //  same color used for diffuse and specular
         private String name = "Point light";
         private bool enabled = true;
 
@@ -21,12 +21,12 @@ public Vector getPosition()
             return position;
         }
 
-        public void setColor(Color c)
+        public void setColor(RgbColor c)
         {
             color = c;
         }
 
-        public Color getColor()
+        public RgbColor getColor()
         {
             return color;
         }

Model/PointLight.cs

@@ -0,0 +1,94 @@
+/*
+ * RgbColor.cs
+ * 
+ * Represents an RGB color with float components in the range [0, 1].
+ * 
+ * Features:
+ *   - Predefined static colors: Black, Red, Green, Blue, White, Yellow, Cyan, Magenta
+ *   - Safe mutable properties (R, G, B) with automatic clamping
+ *   - Arithmetic operators: +, -, * (with both scalars and other colors)
+ *   - Linear interpolation (Lerp) with clamped interpolation factor
+ *   - ToString() override for debugging output
+ * 
+ * Usage:
+ *   var c1 = new RgbColor(0.5f, 0.2f, 0.7f);   // create a custom color
+ *   c1.R = 2.0f;                               // clamped to 1.0
+ *   var mix = RgbColor.Lerp(RgbColor.Red, RgbColor.Blue, 0.5f); // purple
+ *
+ * Author: Dan Munteanu
+ * Date: 28-Sep-2025
+ */
+
+namespace UnilightRaytracer
+{
+    public class RgbColor
+    {
+        private float r, g, b;
+
+        public float R
+        {
+            get => r;
+            set => r = Clamp(value);
+        }
+
+        public float G
+        {
+            get => g;
+            set => g = Clamp(value);
+        }
+
+        public float B
+        {
+            get => b;
+            set => b = Clamp(value);
+        }
+
+        // Predefined colors
+        public static readonly RgbColor Black = new(0, 0, 0);
+        public static readonly RgbColor Red = new(1, 0, 0);
+        public static readonly RgbColor Green = new(0, 1, 0);
+        public static readonly RgbColor Blue = new(0, 0, 1);
+        public static readonly RgbColor White = new(1, 1, 1);
+        public static readonly RgbColor Yellow = new(1, 1, 0);
+        public static readonly RgbColor Cyan = new(0, 1, 1);
+        public static readonly RgbColor Magenta = new(1, 0, 1);
+
+        public RgbColor(float r, float g, float b)
+        {
+            R = r;
+            G = g;
+            B = b;
+        }
+
+        private static float Clamp(float value, float min = 0f, float max = 1f) =>
+            value < min ? min : (value > max ? max : value);
+
+        // Operators
+        public static RgbColor operator +(RgbColor a, RgbColor b) =>
+            new(Clamp(a.R + b.R), Clamp(a.G + b.G), Clamp(a.B + b.B));
+
+        public static RgbColor operator -(RgbColor a, RgbColor b) =>
+            new(Clamp(a.R - b.R), Clamp(a.G - b.G), Clamp(a.B - b.B));
+
+        public static RgbColor operator *(RgbColor a, RgbColor b) =>
+            new(Clamp(a.R * b.R), Clamp(a.G * b.G), Clamp(a.B * b.B));
+
+        public static RgbColor operator *(RgbColor a, float k) =>
+            new(Clamp(a.R * k), Clamp(a.G * k), Clamp(a.B * k));
+
+        // Linear interpolation with clamped t
+        public static RgbColor Lerp(RgbColor a, RgbColor b, float t)
+        {
+            if (t < 0f) t = 0f;
+            if (t > 1f) t = 1f;
+
+            return new RgbColor(
+                a.R + (b.R - a.R) * t,
+                a.G + (b.G - a.G) * t,
+                a.B + (b.B - a.B) * t
+            );
+        }
+
+        public override string ToString() => $"RgbColor({R:0.##}, {G:0.##}, {B:0.##})";
+    }
+}