Tutorial 3: Podstawy C##

Zakres tego laboratorium obejmuje podstawy języka C# (składnia, system typów, typy podstawowe, tablice, parametry) oraz tworzenie własnych typów (klasy, struktury, interfejsy, dziedziczenie, typy wyliczeniowe).

Jako że znasz już język C++, wiele konstrukcji w C# wyda Ci się znajomych. Przed rozpoczęciem zadania, omówimy najważniejsze różnice i zagadnienia. Przede wszystkim w C# nie rozdzielamy deklaracji od implementacji (brak podziału na pliki nagłówkowe .h i źródłowe .cpp) – cały kod klas i struktur definiuje się bezpośrednio w plikach .cs.

Przestrzenie nazw#

Podobnie jak w C++, w C# używasz przestrzeni nazw, aby grupować powiązany kod i unikać konfliktów nazw. W C# kropki (.) używasz do odwoływania się do przestrzeni nazw oraz składowych klas i struktur (np. System.Console.WriteLine).

Dyrektywa using pozwala importować przestrzeń nazw do obecnego pliku, co pozwala na bezpośrednie korzystanie z jej typów bez podawania pełnej ścieżki (np. using System;). W nowszych wersjach C# powszechnie stosuje się przestrzenie nazw o zasięgu pliku (file-scoped namespace), co pozwala uniknąć dodatkowego poziomu wcięć:

namespace MyApp.Core;

// All code in this file belongs to MyApp.Core
public class Calculator 
{
    // ...
}

Klasy i Struktury#

W C++ różnica między class a struct sprowadza się jedynie do domyślnej widoczności składowych. W C# ta różnica dotyczy sposobu zarządzania pamięcią.

  • Klasy (class) to typy referencyjne. Są alokowane na stercie, a ich cyklem życia zarządza Garbage Collector. Zmienna przechowująca klasę przechowuje referencję do obiektu. Klasy są przeznaczone dla złożonych obiektów, które posiadają swoją tożsamość, wymagają dłuższego cyklu życia lub korzystają z dziedziczenia.
  • Struktury (struct) to typy bezpośrednie. Są alokowane na stosie lub osadzone bezpośrednio wewnątrz innych obiektów. Przypisanie struktury do innej zmiennej lub przekazanie jej jako argument do metody domyślnie tworzy jej pełną kopię. Struktury stosuje się do małych typów danych (zazwyczaj do ok. 16 bajtów).

Właściwości (Properties)#

Enkapsulacja jest jednym z założeń programowania obiektowego. Aby ukryć pola klasy, często tworzy się metody dostępowe, tzw. gettery i settery (np. float GetX(), void SetX(float v)). C# wspiera koncepcję enkapsulacji poprzez Właściwości (Properties). Z zewnątrz używasz ich jak zwykłych zmiennych, ale pod spodem kompilator sam generuje ukryte metody odczytu i zapisu:

public struct Point3
{
    // Private, backing field
    private float x;

    // Classic property
    public float X 
    {
        get { return x; }
        set { x = value; } // 'value' is the implicit setter parameter
    }

    // Auto-property - compiler generates the backing field
    public float Y { get; set; }
    
    // Read-only property from the outside
    public float Z { get; private set; }
}

Odwoływanie się do zdefiniowanych właściwości wygląda następująco:

Point3 p = new Point3();
p.X = 5.0f;       // Uses setter
float val = p.X;  // Uses getter

// p.Z = 2.0f;    // Error: setter is private

Tablice#

W C# tablice są typami referencyjnymi i zawsze znają swój rozmiar (Length). C# kontroluje granice tablicy – wyjście poza jej zakres kończy się rzuceniem wyjątku IndexOutOfRangeException.

// Create an array of 100 elements (initialized to default values, 0 for int)
int[] numbers = new int[100];
int length = numbers.Length; // Array knows its size

Oprócz tablic jednowymiarowych (oraz tablic tablic, czyli tzw. tablic poszarpanych/jagged arrays), C# obsługuje też wbudowane, spójne pamięciowo tablice wielowymiarowe:

// 2D array [width, height]
float[,] grid = new float[800, 600];
grid[0, 0] = 1.5f; // Access specific element

Typ object i metoda ToString()#

W systemie typów C# każdy typ (zarówno referencyjny, jak i bezpośredni) dziedziczy po klasie System.Object (w skrócie object), co oznacza, że każda instancja posiada pewien standardowy zestaw metod.

Często używaną metodą jest wirtualna metoda ToString(), która zwraca tekstową reprezentację obiektu. Domyślnie zwraca nazwę typu, ale zazwyczaj chcesz ją nadpisać. Używasz do tego słowa kluczowego override:

public struct Point3
{
    public float X { get; set; }
    public float Y { get; set; }
    public float Z { get; set; }

    // Override the built-in ToString() method from object
    public override string ToString()
    {
        // String interpolation
        return $"[{X}, {Y}, {Z}]";
    }
}

Przykładowe użycie tej metody w praktyce:

using System;

// Object initialization syntax
Point3 p = new Point3 { X = 1.0f, Y = 2.0f, Z = 3.0f };

// Automatically calls ToString() under the hood
Console.WriteLine(p); // Output: [1, 2, 3]

Zadanie 1 - Śledzenie promieni#

W ramach tego zadania stworzysz prostą aplikację do śledzenia promieni. Zadanie to opiera się na materiałach z książki Raytracing in One Weekend. Będzie się ona składała z pojedynczego projektu - aplikacji wykonywalnej.

Śledzenie promieni (ang. ray tracing) to technika generowania obrazów. W metodzie tej rzucamy promienie od obserwatora (kamery) przez każdy piksel rzutni w głąb sceny. Następnie algorytm sprawdza, z jakimi obiektami przecina się dany promień i na tej podstawie oblicza kolor piksela.

Etap 1: Reprezentacja kolorów i generowanie obrazu#

Naszą pracę zaczniemy od zdefiniowania dwóch typów: struktury opisującej wektor (użyjemy go również do reprezentacji punktów i koloru) oraz klasy reprezentującej obraz.

Struktura Vector3#

Użyjemy struktury agregującej trzy liczby, której poszczególne składniki (X, Y, Z) mogą odpowiadać kanałom RGB (Red, Green, Blue) lub współrzędnym w przestrzeni. Utwórz plik Vector3.cs i zdefiniuj:

  1. Publiczne właściwości X, Y, Z typu float.
  2. Publiczny konstruktor przyjmujący trzy wartości, przypisujący je do właściwości.
  3. Nadpisaną metodę ToString(), zwracającą składniki wektora oddzielone spacją (np. "1.5 0.2 0.8").

Klasa Image i format PPM#

Obraz traktujemy jako dwuwymiarową tablicę pikseli. Utwórz klasę Image (plik Image.cs). Klasa powinna zawierać:

  • Publiczne właściwości tylko do odczytu Width i Height typu int.
  • Prywatną tablicę dwuwymiarową Vector3[,] Pixels.
  • Konstruktor przyjmujący szerokość i wysokość, który na ich podstawie zainicjalizuje dwuwymiarową tablicę.
  • Dwuwymiarowy indeksator (public Vector3 this[int x, int y]), stanowiący odpowiednik przeciążonego operatora[] z C++. W akcesorze get powinien zwrócić piksel z tablicy Pixels[x, y], a w akcesorze set przypisać do niego przekazaną wartość (value). Posłuży on do wygodnego odczytywania i modyfikowania pikseli (np. image[x, y] = color).

Aby wyeksportować wygenerowany obraz, wykorzystamy prosty, tekstowy format PPM. Nie będziemy implementować osobnej metody zapisującej obraz do pliku. Zamiast tego zaimplementujemy proces generowania zawartości PPM wewnątrz nadpisanej metody ToString(). Wywołanie Console.WriteLine(image) wypisze obraz w formie tekstowej na standardowe wyjście, które przekierujemy do pliku.

Struktura formatu PPM wygląda następująco:

  1. Magiczny ciąg znaków P3 (zbieżność z nazwą przedmiotu Programowanie 3 przypadkowa).
  2. Szerokość i wysokość obrazka (oddzielone spacją).
  3. Maksymalna wartość dla koloru (w naszym przypadku 255).
  4. Całkowitoliczbowe wartości R, G, B pikseli (od lewego górnego rogu). Ich ułożenie w wierszach jest dowolne, ważne jedynie, aby wartości były oddzielone białymi znakami.

Poniżej znajduje się przykładowy plik dla obrazka o wymiarach 3x2:

P3
3 2
255
255   0   0     0 255   0     0   0 255
255 255   0   255 255 255     0   0   0

Twoim zadaniem jest zaimplementowanie metody ToString(). Dodaj do tworzonego tekstu odpowiedni nagłówek, a następnie – za pomocą zagnieżdżonych pętli – przeiteruj po wszystkich pikselach na obrazie. Składowe każdego wektora (float) zmapuj na format RGB (zakres [0, 255]). Upewnij się, że wartości nie wykraczają poza ten przedział, np. używając Math.Clamp.

Ponieważ będziemy generować ciąg tekstowy dla milionów wartości, użycie konkatenacji stringów (operator +) w pętli byłoby bardzo niewydajne z uwagi na ciągłą alokację nowych obiektów. Do optymalnego zbudowania wyniku wykorzystaj klasę StringBuilder (zdefiniowaną w przestrzeni nazw System.Text).

Generowanie pierwszego obrazka#

W metodzie Main pliku Program.cs:

  1. Utwórz instancję obrazu Image o rozdzielczości np. 1920x1080.
  2. W zagnieżdżonej pętli wypełnij piksele dowolnym wzorem (np. gradientem, gdzie składowa czerwona to r = (float)i / image.Width, zielona to g = (float)j / image.Height, a niebieska to stała lub funkcja sinus).
  3. Wypisz obiekt obrazu do konsoli za pomocą Console.WriteLine(image).

Aby zapisać obrazek, przekieruj standardowe wyjście do pliku. Uruchom program poleceniem:

dotnet run > image.ppm

Wygenerowane pliki obrazów w formacie PPM zajmują dużo miejsca na dysku (nawet kilkadziesiąt megabajtów) i nie powinny trafiać do repozytorium. Pamiętaj, aby dodać wzorzec *.ppm do pliku .gitignore.

Etap 1#

Stage 1 Render

Etap 2: Kamera i Promienie#

W tym etapie rozbudujemy strukturę Vector3 oraz stworzymy mechanizm wirtualnej kamery i strukturę promienia (Ray).

Przeciążanie operatorów w C##

Zanim stworzymy kamerę, nasza struktura Vector3 wymaga matematycznej rozbudowy. W C# operatory matematyczne przeciąża się, definiując publiczne, statyczne metody z użyciem słowa kluczowego operator. Poniżej znajduje się przykład przeciążenia operatora dodawania dwóch wektorów z wykorzystaniem notacji strzałkowej:

public static Vector3 operator +(Vector3 u, Vector3 v) => new Vector3(u.X + v.X, u.Y + v.Y, u.Z + v.Z);

Rozbudowa struktury Vector3#

W pliku Vector3.cs zaimplementuj:

  1. Przeciążenia operatorów: unarnego - (odwrócenie wektora), dodawania + i odejmowania - dwóch wektorów, mnożenia * i dzielenia / wektora przez skalar (float), a także mnożenia dwóch wektorów przez siebie * (mnożącego odpowiadające sobie składowe: u.X * v.X, u.Y * v.Y, u.Z * v.Z).
  2. Metody LengthSquared() (zwracającą kwadrat długości wektora) oraz Length() (obliczającą długość wektora). Pierwiastek kwadratowy znajdziesz w statycznej klasie MathF, która zawiera funkcje matematyczne (np. MathF.Sqrt(), MathF.Tan()) dla liczb typu float.
  3. Statyczną metodę Dot() do obliczania iloczynu skalarnego.
  4. Statyczną metodę Cross() do obliczania iloczynu wektorowego.
  5. Metodę Normalize(), która znormalizuje wektor.

Struktura Promienia (Ray)#

Każdy wypuszczony z kamery promień to półprosta, którą można opisać funkcją \( P(t) = A + t \cdot b \), gdzie \( A \) to początek promienia (Origin), \( b \) to jego kierunek (Direction), a parametr \( t \) oznacza dystans przebyty wzdłuż tego kierunku.

Utwórz nową strukturę Ray (plik Ray.cs) i zdefiniuj w niej:

  • Właściwości tylko do odczytu: Vector3 Origin oraz Vector3 Direction.
  • Konstruktor przyjmujący i przypisujący ich wartości początkowe.
  • Metodę Vector3 At(float t), wyznaczającą wartość funkcji \( P(t) \) (pozycję punktu na promieniu w przestrzeni) dla danego parametru \( t \).

Klasa Kamery#

Będziemy posługiwali się modelem kamery, w którym wypuszczamy promienie z pozycji obserwatora prosto, przepuszczając je przez piksele wirtualnego ekranu (rzutni) zawieszonego przed kamerą.

Model Kamery (Źródło: Ray Tracing in One Weekend)

Każda zmiana parametru fizycznego (pozycja kamery, pozycja rzutni, czy kąt widzenia FoV) wymaga przeliczenia od nowa parametrów siatki rzutni. Z tego powodu, właściwości konfigurujące kamerę oprzemy o prywatne pola klasy (tzw. backing field), co pozwoli nam na umieszczenie w bloku set dodatkowej logiki odpowiadającej za aktualizację stanu kamery.

public class Camera
{
    private float _fov = 90.0f; // Private field with default value

    public float Fov 
    { 
        get => _fov; 
        set 
        { 
            _fov = value; 
            Recalculate(); // Recalculate other parameters on change
        } 
    }
    // ...
}

Utwórz plik Camera.cs definiujący kamerę:

  1. Zdefiniuj właściwości i powiąż je z prywatnymi polami o przypisanych wartościach domyślnych: float AspectRatio (16.0f / 9.0f), int ImageWidth (1280), Vector3 Position (new Vector3(0,0,0)), Vector3 Target (new Vector3(0,0,-1)) oraz float Fov (90.0f). Właściwość Target określa punkt w przestrzeni, w którym znajduje się środek rzutni kamery. Każdy akcesor set w wymienionych właściwościach musi wywoływać metodę Recalculate().
  2. Zadeklaruj prywatne pola przechowujące parametry rzutni oraz kamery: int _imageHeight, Vector3 _pixelDu, Vector3 _pixelDv oraz Vector3 _viewportCorner.
  3. Dodaj bezparametrowy konstruktor, który jednorazowo wywoła metodę Recalculate() do inicjalizacji obiektu.

Zaimplementuj prywatną metodę Recalculate(), wyznaczającą geometrię rzutni:

  1. Wymiary obrazu: Oblicz wysokość w pikselach: _imageHeight = (int)(ImageWidth / AspectRatio).
  2. Fizyczny rozmiar rzutni: Przelicz kąt pola widzenia na radiany theta = Fov * MathF.PI / 180.0f oraz połowę wysokości rzutni h = MathF.Tan(theta / 2.0f). Odległość do rzutni to distanceToViewport = (Position - Target).Length(). Wymiary wirtualnego ekranu wynoszą:
    • Wysokość: viewportHeight = 2.0f * h * distanceToViewport
    • Szerokość: viewportWidth = viewportHeight * AspectRatio
  3. Ortonormalna baza wektorów kamery (front, right, up):
    • Wektor kierunku: w = (Position - Target).Normalize() (zwrócony przeciwnie do celu w układzie prawoskrętnym).
    • Wektor w prawo: u = Vector3.Cross(new Vector3(0, 1, 0), w).Normalize().
    • Wektor w górę: v = Vector3.Cross(w, u).
  4. Wektory kroków piksela:
    • Rozpiętość pozioma rzutni: viewportU = viewportWidth * u.
    • Rozpiętość pionowa rzutni: viewportV = viewportHeight * -v (skierowana w dół, zgodnie z numeracją wierszy w obrazie).
    • Wektory kroku pojedynczego piksela: _pixelDu = viewportU / ImageWidth oraz _pixelDv = viewportV / _imageHeight.
  5. Środek pierwszego piksela: Wyznacz lewy górny róg rzutni: _viewportCorner = Position - (distanceToViewport * w) - viewportU / 2.0f - viewportV / 2.0f, a następnie przesuń go na środek pierwszego piksela, dodając 0.5f * (_pixelDu + _pixelDv).

Etap 2#

Etap 3: Przecinanie promieni z obiektami#

W tym etapie zaimplementujemy wykrywanie przecięć promieni z geometrią na scenie.

Informacje o przecięciu (HitInfo)#

Gdy promień przecina obiekt, musimy zebrać kilka informacji: pozycję uderzenia, wektor normalny powierzchni w miejscu trafienia oraz wartość parametru \( t \) promienia, dla której nastąpiło trafienie. Informacje te będą nam przydatne później przy obliczaniu koloru promienia i dalszych odbić.

Utwórz plik HitInfo.cs ze strukturą przechowującą wynik uderzenia:

  1. Zdefiniuj publiczne pola: Vector3 Position, Vector3 Normal, float T oraz bool FrontFace.
  2. Zdefiniuj metodę SetFaceNormal(Ray r, Vector3 outwardNormal). Do poprawnego obliczenia oświetlenia wektor normalny musi być skierowany przeciwnie do promienia:
    • Sprawdź iloczyn skalarny kierunku promienia i wektora outwardNormal.
    • Jeżeli wynik jest ujemny, promień uderza z zewnątrz (FrontFace = true), a Normal przyjmuje wartość outwardNormal.
    • W przeciwnym razie promień trafia od wewnątrz (FrontFace = false), a Normal należy odwrócić (-outwardNormal).

Interfejsy w C##

Interfejsy to abstrakcyjne typy definiujące kontrakt, czyli zbiór metod i właściwości, które klasa musi zaimplementować. Nie posiadają one własnego stanu (pól) ani implementacji. W naszym programie każdy obiekt, w który może uderzyć promień, będzie implementował wspólny interfejs, co pozwoli na polimorficzną obsługę różnych kształtów na scenie.

Modyfikator “out”#

Jednym ze sposobów na zwrócenie wielu wartości z metody w C# jest użycie słowa kluczowego out. Wymusza ono zainicjowanie przekazanej w ten sposób zmiennej przed opuszczeniem metody (np. metoda sprawdzająca trafienie promienia może zwrócić jako wynik bool, a przez argument zwrócić wygenerowaną strukturę HitInfo).

Interfejs IHittable#

Utwórz plik IHittable.cs z definicją interfejsu (w C# nazwy interfejsów zwyczajowo zaczynamy od dużej litery I), deklarującego metodę:

bool Hit(Ray ray, float tMin, float tMax, out HitInfo hitInfo);

W C# wszystkie składowe zadeklarowane wewnątrz interfejsu są domyślnie publiczne (public), dlatego nie wymagają jawnego modyfikatora dostępu w deklaracji.

Implementacja IHittable (Sphere i Plane)#

Każdy obiekt na naszej scenie (włącznie z samą sceną) będzie implementował interfejs IHittable. Kontrakt ten oznacza wprost, że w dany obiekt można “strzelać” promieniami. Dzięki temu wszystkie elementy w świecie mogą być traktowane polimorficznie – kamera nie musi wiedzieć, czy strzela w pojedynczą kulę, całą scenę, czy trójkąt, o ile dany obiekt implementuje interfejs IHittable.

Utwórz klasę Sphere (plik Sphere.cs) implementującą interfejs IHittable (class Sphere : IHittable):

  • Dodaj właściwości Vector3 Center oraz float Radius.
  • Zdefiniuj konstruktor inicjalizujący właściwości.
  • Zaimplementuj metodę Hit:
    1. Wyznacz wektor od środka kuli do początku promienia: oc = ray.Origin - Center.
    2. Wyznacz współczynniki równania kwadratowego:
      • a = ray.Direction.LengthSquared()
      • halfB = Vector3.Dot(oc, ray.Direction)
      • c = oc.LengthSquared() - Radius * Radius
    3. Oblicz zredukowaną deltę równania: discriminant = halfB * halfB - a * c. Jeśli discriminant < 0, brak przecięcia – zwróć false.
    4. Znajdź mniejszy pierwiastek (-halfB ± MathF.Sqrt(discriminant)) / a leżący w przedziale [tMin, tMax]. Jeśli żaden z pierwiastków nie mieści się w zadanym zakresie, zwróć false.
    5. Wypełnij hitInfo: parametr T = root, punkt uderzenia Position = ray.At(root), wyznacz wektor normalny (Position - Center) / Radius i przekaż do SetFaceNormal(ray, outwardNormal). Zwróć true. (Więcej szczegółów matematycznych znajdziesz w książce).

Utwórz klasę Plane (plik Plane.cs) implementującą interfejs IHittable, reprezentującą płaszczyznę.

  • Dodaj właściwości Vector3 Point oraz Vector3 Normal. Matematycznie płaszczyzna opisana jest za pomocą dowolnego leżącego na niej punktu (właściwość Point) oraz wektora do niej prostopadłego (właściwość Normal). W konstruktorze zadbaj, by przypisywany wektor normalny został znormalizowany.
  • Zaimplementuj metodę Hit. Punkt \( P \) leży na płaszczyźnie, gdy spełnia równanie \( (P - P_0) \cdot n = 0 \). Podstawiając równanie promienia \( P(t) = A + t \cdot b \) i wyznaczając parametr \( t \), otrzymujemy: \( t = \frac{(P_0 - A) \cdot n}{b \cdot n} \) W metodzie Hit:
    1. Oblicz mianownik powyższego ułamka: denom = Vector3.Dot(Normal, ray.Direction).
    2. Jeśli wartość bezwzględna mianownika jest bliska zeru (MathF.Abs(denom) < 1e-6f), promień jest równoległy do płaszczyzny – zwróć false.
    3. W przeciwnym razie oblicz wartość parametru: t = Vector3.Dot(Point - ray.Origin, Normal) / denom.
    4. Jeśli parametr t mieści się w przedziale (tMin, tMax), uzupełnij strukturę hitInfo (parametr T = t, punkt przecięcia Position = ray.At(t), wektor normalny przez SetFaceNormal(ray, Normal)) i zwróć true. W przeciwnym razie zwróć false.

Scena#

Nasza scena będzie się składać ze zbioru obiektów. Do przechowywania elementów o dynamicznym rozmiarze użyjemy generycznej klasy List<T> (z przestrzeni nazw System.Collections.Generic).

Utwórz klasę Scene, implementującą interfejs IHittable. Zdefiniuj w niej:

  • Publiczną listę: public List<IHittable> Objects { get; } = new List<IHittable>();.
  • Metodę dodającą obiekt do listy: public void Add(IHittable obj) => Objects.Add(obj);.
  • Implementację metody Hit. Przeiteruj pętlą foreach przez wszystkie elementy w Objects. Za każdym razem przy zlokalizowaniu trafienia, nadpisuj zmienną określającą górny próg poszukiwań parametru tMax wynikiem tego trafienia. Dzięki temu, w wynikowym hitInfo znajdzie się struktura z danymi najbliższego trafionego obiektu. Zwróć zmienną typu bool informującą, czy wystąpiło jakiekolwiek trafienie.

Renderowanie obrazu#

W klasie Camera dodaj metodę Render, przyjmującą jako argument scenę (IHittable world) i zwracającą Image. Wewnątrz zagnieżdżonej pętli iterującej po pikselach obrazu (i po szerokości, j po wysokości):

  1. Oblicz pozycję środka bieżącego piksela na wirtualnej rzutni: Vector3 pixelCenter = _viewportCorner + (i * _pixelDu) + (j * _pixelDv);
  2. Wyznacz kierunek promienia jako wektor od pozycji obserwatora do punktu na rzutni: Vector3 rayDirection = pixelCenter - Position;
  3. Skonstruuj promień Ray(Position, rayDirection) i przetestuj trafienie w obiekty sceny (world.Hit(...)).

Jeśli promień trafi w obiekt, ustaw kolor piksela na czerwony ([1, 0, 0]). W przeciwnym razie ustaw kolor na czarny ([0, 0, 0]).

W metodzie Main pliku Program.cs:

  1. Utwórz obiekt Scene i dodaj sferę w punkcie (0, 0, -1) o promieniu 0.5 oraz płaszczyznę w punkcie (0, -0.5, 0) z wektorem normalnym (0, 1, 0).
  2. Skonfiguruj kamerę: Position na (0, 0, 1) oraz Target na (0, 0, -1).
  3. Wywołaj cam.Render(world) i wypisz wynik do konsoli za pomocą Console.Write(image).

Aby wygenerować obraz, uruchom program, przekierowując standardowe wyjście do pliku:

dotnet run > image.ppm

Etap 3#

Stage 3 Render

Etap 4: Materiały i rekursja#

W tym etapie dodamy obsługę materiałów, które będą definiować zachowanie promieni po trafieniu w obiekt.

Klasy abstrakcyjne#

Z klasy abstrakcyjnej nie można bezpośrednio utworzyć instancji. Służy ona jako definicja bazowa dla klas pochodnych. Może zawierać deklaracje metod abstrakcyjnych (odpowiednik funkcji czysto wirtualnych z C++, np. virtual void Method() = 0;), które nie posiadają implementacji i wymagają ich zdefiniowania w klasie pochodnej, oraz metod wirtualnych posiadających domyślną implementację, którą opcjonalnie można nadpisać.

Przekazywanie parametrów przez referencję#

Przekazywanie argumentów przez referencję pozwala uniknąć kopiowania struktur w pamięci podczas wywołań metod. W C# służą do tego trzy słowa kluczowe:

  • out – argument wyjściowy. Przekazywana zmienna nie musi być zainicjalizowana przed wywołaniem, jednak jej inicjalizacja wewnątrz metody przed zakończeniem wykonania jest wymagana przez kompilator.
  • ref – dwukierunkowa referencja. Zmienna musi zostać zainicjowana przed przekazaniem do metody.
  • in – referencja tylko do odczytu. Gwarantuje brak modyfikacji argumentu wewnątrz metody.

Klasa Material#

W pliku Material.cs zdefiniuj abstrakcyjną klasę Material:

  • Zadeklaruj metodę abstrakcyjną: public abstract bool Scatter(in Ray rIn, ref HitInfo hitInfo, out Vector3 attenuation, out Ray scattered);. Przyjmuje ona promień wejściowy (rIn) oraz informacje o trafieniu (hitInfo). Przez argumenty wyjściowe zwraca wektor tłumienia koloru (attenuation) oraz promień odbity (scattered), a jako wynik działania (typ bool) zwraca informację, czy promień uległ odbiciu.
  • Zadeklaruj metodę wirtualną Emit() zwracającą domyślnie wektor zerowy (new Vector3(0, 0, 0)).

EmissiveMaterial#

W pliku EmissiveMaterial.cs utwórz klasę EmissiveMaterial dziedziczącą po Material. Reprezentuje ona materiał emitujący własne światło. Zdefiniuj w niej:

  • Właściwość Vector3 Color inicjalizowaną przez konstruktor.
  • Metodę Scatter, która zwraca false (wskazując brak dalszego odbicia promienia) oraz przypisuje domyślne wartości do zmiennych wyjściowych out.
  • Metodę Emit() zwracającą właściwość Color.

Powiązanie materiałów z geometrią sceny#

Zaktualizuj struktury odpowiedzialne za przechowywanie danych o kolizjach tak, aby umożliwiały odczyt właściwości trafionego materiału:

  1. W pliku HitInfo.cs dodaj do struktury pole public Material Mat;.
  2. W klasach Sphere i Plane dodaj właściwość public Material Mat { get; set; } i przypisz jej wartość z konstruktora.
  3. W metodach Hit dla obu kształtów dodaj instrukcję przypisującą materiał do zwracanej struktury wyjściowej (np. hitInfo.Mat = Mat;).

Rekurencyjne wyliczanie koloru#

W klasie Camera dodaj właściwość public int MaxDepth { get; set; } = 50;. Określa ona dopuszczalny limit wywołań rekurencyjnych. Zabezpiecza to program przed zawieszeniem (np. w sytuacji, gdy promień odbija się w nieskończoność między dwoma lustrami).

Wewnętrzną pętlę w metodzie Render zmodyfikuj tak, aby używała rekurencyjnej metody RayColor:

image[i, j] = RayColor(ray, MaxDepth, world);

Zaimplementuj prywatną metodę RayColor(Ray ray, int depth, IHittable world):

  1. Warunek stopu: jeśli limit głębokości został wyczerpany (depth <= 0), przerwij rekurencję i zwróć kolor czarny [0, 0, 0].
  2. Sprawdź trafienie w obiekty sceny za pomocą world.Hit(ray, 0.001f, float.PositiveInfinity, out HitInfo hitInfo). Jeśli brak kolizji, zwróć kolor czarny.
  3. Pobierz światło emitowane przez materiał trafionego obiektu (hitInfo.Mat.Emit()).
  4. Wywołaj metodę Scatter(...). Jeżeli materiał obiektu odbija promień (true), zwróć sumę światła emitowanego oraz rekurencyjnego wywołania RayColor(scattered, depth - 1, world) pomnożonego przez attenuation.
  5. W przeciwnym razie (brak odbicia) zwróć wyłącznie kolor wyemitowany.

Wartość tMin w wywołaniu funkcji Hit została ustawiona na 0.001f w celu uniknięcia błędu precyzji zmiennoprzecinkowej. Zabezpiecza to przed sytuacją, w której wtórny promień wskutek zaokrągleń uderza bezpośrednio w tę samą powierzchnię, z której został wyemitowany (zjawisko shadow acne).

Weryfikacja etapu czwartego#

W pliku Program.cs zmodyfikuj inicjalizację obiektów sceny. Utwórz czerwoną sferę, białą płaszczyznę oraz błękitną sferę o promieniu 1000 otaczającą scenę, emitującą światło (tzw. skysphere), po czym wyrenderuj obraz.

world.Add(new Sphere(new Vector3(0, 0, 0), 1000.0f, new EmissiveMaterial(new Vector3(0.5f, 0.7f, 1.0f))));
world.Add(new Sphere(new Vector3(0, 0, -1), 0.5f, new EmissiveMaterial(new Vector3(1, 0, 0)))); 
world.Add(new Plane(new Vector3(0, -0.5f, 0), new Vector3(0, 1, 0), new EmissiveMaterial(new Vector3(1, 1, 1))));

Etap 4#

Stage 4 Render

Etap 5: Materiał matowy i wygładzanie krawędzi#

W tym etapie zaimplementujemy matowy materiał rozpraszający światło oraz wygładzanie krawędzi (antyaliasing).

Generowanie losowych wektorów#

Działanie materiału rozpraszającego światło polega na odbijaniu uderzającego w niego promienia w losowym kierunku, dlatego struktura Vector3 wymaga rozbudowy o generator losowych wektorów. Użyjemy wbudowanej właściwości System.Random.Shared, która zapewnia współdzieloną, bezpieczną w kontekście wielowątkowości instancję generatora liczb pseudolosowych.

W pliku Vector3.cs zaimplementuj trzy nowe metody:

  1. NearZero(): Metoda sprawdzająca, czy wektor jest bliski zera we wszystkich wymiarach. Wektor jest bliski zera, gdy wartość bezwzględna każdego z jego trzech wymiarów jest mniejsza niż z góry określony próg (np. 1e-8f). Będzie to przydatne do eliminacji błędów numerycznych przy wyliczaniu wektora odbicia.
  2. RandomInUnitSphere(): Metoda implementująca próbkowanie z odrzucaniem (rejection sampling). W nieskończonej pętli losuj współrzędne wektora w przedziale [-1, 1). Jeżeli kwadrat długości tego wektora jest mniejszy niż 1 (co oznacza, że wyznaczony punkt znajduje się wewnątrz kuli jednostkowej), przerwij pętlę i zwróć ten wektor. Do losowania wartości bazowych wykorzystaj metodę System.Random.Shared.NextDouble(), która zwraca wartość zmiennoprzecinkową w przedziale [0, 1).
  3. RandomUnitVector(): Metoda zwracająca jednostkowy wektor. Wynikiem działania powinno być zwrócenie znormalizowanego niezerowego wektora pobranego z metody RandomInUnitSphere().

Lambertian#

W pliku Lambertian.cs utwórz klasę Lambertian dziedziczącą po Material. Modeluje ona idealnie matową powierzchnię, która po uderzeniu rozprasza padające światło w różnych kierunkach ze zmienną intensywnością (zależną od kąta).

Fizycznie, w celu symulacji światła rozproszonego, materiał powinien wygenerować wiele odbitych promieni w różnych kierunkach dla każdego uderzenia. Rozgałęzianie promieni na każdym kroku spowodowałoby jednak wykładniczy wzrost ilości wykonywanych obliczeń (eksplozję promieni). Aby tego uniknąć, śledzenie promieni (path tracing) stosuje model stochastyczny – w miejscu uderzenia metoda Scatter generuje jeden promień odbity, za to w losowym kierunku. Brakujące rozproszone światło uśredni się samoistnie z upływem czasu na skutek wystrzelenia ogromnej puli promieni bazowych startujących z kamery dla jednego piksela (metoda Monte Carlo).

W klasie Lambertian zdefiniuj:

  • Właściwość Vector3 Albedo (określającą współczynnik odbicia, czyli bazowy kolor materiału), inicjalizowaną przez konstruktor.
  • Nadpisaną metodę Scatter. Wyznacza ona kierunek rozproszenia promienia (scatterDirection). Zgodnie z prawem Lamberta, światło rozprasza się z najwyższym prawdopodobieństwem w kierunku prostopadłym do powierzchni. Symuluje się to wyznaczając nowy wektor kierunku będący sumą wektora normalnego powierzchni i losowego wektora jednostkowego (z metody RandomUnitVector()).
  • Zabezpiecz wyliczony kierunek przy pomocy metody NearZero(). Jeżeli wylosowany wektor będzie idealnie przeciwny do wektora normalnego (ich suma jest bliska zeru), kierunek rozproszenia awaryjnie powinien przyjąć wartość wektora normalnego.
  • Zwróć promień wtórny oraz przypisz wartość z Albedo do zmiennej attenuation. Metoda powinna ostatecznie zwrócić true.

Antyaliasing#

Obecnie przez środek każdego piksela rzutni przepuszczany jest dokładnie jeden promień. Ponieważ promień stanowi punktowy wycinek, trafia on w geometrię zawsze zero-jedynkowo. Przy ograniczonej rozdzielczości ekranu skutkuje to ostrym, schodkowym podziałem na krawędziach nachodzących na siebie kształtów (zjawisko aliasingu). Aby to zniwelować, wysyła się wiele promieni lekko przesuniętych losowo w granicach pojedynczego piksela. Ostateczny kolor piksela stanowi uśredniony wynik kolorów zebranych przez wszystkie wystrzelone próbki.

W klasie Camera dodaj właściwość public int SamplesPerPixel { get; set; } = 100;. Określa ona liczbę promieni wysyłanych dla pojedynczego piksela ekranu.

Zmodyfikuj zawartość wewnętrznej pętli w metodzie Render. Zastąp pojedyncze wywołanie RayColor pętlą akumulującą kolor. W każdej iteracji:

  1. Wylosuj przesunięcie punktu na siatce piksela w osi X oraz Y (zmienne offsetX i offsetY z przedziału [-0.5, 0.5)).
  2. Oblicz pozycję wirtualnego punktu rzutni dla aktualnej iteracji próbkowania, dodając wylosowane przesunięcia do standardowych współrzędnych i oraz j przed wymnożeniem ich przez wektory kroku _pixelDu i _pixelDv.
  3. Skonstruuj promień wychodzący z pozycji kamery przechodzący przez wylosowany punkt i dodaj wynik wywołania RayColor do wektora sumy (akumulatora koloru).

Po wykonaniu nowej pętli dla wszystkich próbek, podziel wektor skumulowanego koloru przez ustaloną liczbę SamplesPerPixel i przypisz go docelowo do tablicy pikseli obrazu.

Efekt końcowy#

W pliku Program.cs zmodyfikuj kod dodający obiekty do sceny. Utwórz trzy sfery z materiałem Lambertian o różnych kolorach obok siebie oraz płaszczyznę w kolorze zielonym. Pozostaw instancję sfery z materiałem emitującym światło otaczającą scenę, służącą jako tło.

world.Add(new Sphere(new Vector3(0, 0, 0), 1000.0f, new EmissiveMaterial(new Vector3(0.5f, 0.7f, 1.0f))));
world.Add(new Sphere(new Vector3(0, 0, -1), 0.5f, new Lambertian(new Vector3(1, 0, 0)))); 
world.Add(new Sphere(new Vector3(-1.1f, 0, -1), 0.5f, new Lambertian(new Vector3(0, 0, 1)))); 
world.Add(new Sphere(new Vector3(1.1f, 0, -1), 0.5f, new Lambertian(new Vector3(1, 1, 0)))); 
world.Add(new Plane(new Vector3(0, -0.5f, 0), new Vector3(0, 1, 0), new Lambertian(new Vector3(0.2f, 0.8f, 0.2f))));

Wyrenderuj ostateczny obraz za pomocą polecenia dotnet run > image.ppm.

Etap 5#

Stage 5 Render

Korekcja gamma: Wypisane wartości kolorów znajdują się w przestrzeni liniowej. Ponieważ monitory komputerowe stosują nieliniową charakterystykę jasności (gamma), wyrenderowany obraz może wydawać się ciemniejszy w partiach cieniowych. Aby uzyskać prawidłowe odwzorowanie tonalne (tzw. przestrzeń sRGB / gamma ok. 2.2), przed zapisem wartości do pliku podnosi się każdą składową koloru do potęgi 1 / gamma (np. w najprostszym przybliżeniu dla gamma = 2 jest to po prostu pierwiastek kwadratowy: MathF.Sqrt(color)).

Kierunki dalszego rozwoju#

Napisana w ramach tutoriala aplikacja to dobra podstawa do dalszej rozbudowy. Poniżej zebraliśmy najważniejsze mechanizmy, które warto dodać w kolejnych krokach, aby rozwinąć projekt:

  • Inne materiały (Metal, Szkło): Obecnie światło rozprasza się losowo. Aby uzyskać efekt lustra, należy zaimplementować klasę wyliczającą wektor idealnego odbicia (kąt padania równy kątowi odbicia). Materiały przezroczyste (szkło, woda) wymagają z kolei dodania obsługi załamania światła (prawa Snella) i zależności odbicia od kąta patrzenia (tzw. aproksymacji Schlicka).
  • Obsługa trójkątów i ładowanie modeli 3D: Większość grafiki 3D opiera się na trójkątach. Dodanie kodu wyliczającego przecięcie promienia z trójkątem pozwala na ładowanie gotowych siatek wyeksportowanych m.in. z Blendera w powszechnych formatach tekstowych (np. OBJ).
  • Zapis do zewnętrznych formatów obrazu: Użyty format PPM jest łatwy we wdrożeniu, ale mało optymalny przy zapisie na dysk. W projektach .NET do obsługi obrazów PNG czy JPEG standardowo podłącza się zewnętrzne biblioteki, np. SixLabors.ImageSharp (odpowiednik biblioteki stb_image znanej z C/C++).
  • Optymalizacja za pomocą BVH: Przy tysiącach obiektów na scenie, sprawdzanie kolizji promienia z każdym elementem powoduje drastyczne spowolnienie. Struktura BVH (Bounding Volume Hierarchy) organizuje geometrię w drzewo brył otaczających. Jeżeli promień nie trafia w nadrzędną bryłę zbiorczą, algorytm natychmiast odrzuca całą zawartą w niej podgrupę obiektów, co w ogromnym stopniu przyspiesza renderowanie.
  • Obsługa tekstur: System wspiera na razie tylko jednolite materiały. Nałożenie na obiekt tekstury polega na przypisaniu do geometrii współrzędnych określających ułożenie tekstury (UV), a następnie odczytywaniu właściwego koloru z zewnętrznego pliku w momencie trafienia promienia w powierzchnię.

Przykładowe zadania#

Wykonaj przykładowe zadanie z poprzedniego roku. Jeżeli jesteś w stanie je wykonać w przeciągu 90 minut, oznacza to, że jesteś dobrze przygotowany do zajęć.