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 privateTablice#
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 sizeOpró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 elementTyp 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:
- Publiczne właściwości
X,Y,Ztypufloat. - Publiczny konstruktor przyjmujący trzy wartości, przypisujący je do właściwości.
- 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
WidthiHeighttypuint. - 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ążonegooperatora[]z C++. W akcesorzegetpowinien zwrócić piksel z tablicyPixels[x, y], a w akcesorzesetprzypisać 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:
- Magiczny ciąg znaków
P3(zbieżność z nazwą przedmiotu Programowanie 3 przypadkowa). - Szerokość i wysokość obrazka (oddzielone spacją).
- Maksymalna wartość dla koloru (w naszym przypadku
255). - 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 0Twoim 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:
- Utwórz instancję obrazu
Imageo rozdzielczości np. 1920x1080. - W zagnieżdżonej pętli wypełnij piksele dowolnym wzorem (np. gradientem, gdzie składowa czerwona to
r = (float)i / image.Width, zielona tog = (float)j / image.Height, a niebieska to stała lub funkcja sinus). - 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.ppmWygenerowane 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
*.ppmdo pliku.gitignore.
Etap 1#
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
Vector3wymaga matematycznej rozbudowy. W C# operatory matematyczne przeciąża się, definiując publiczne, statyczne metody z użyciem słowa kluczowegooperator. 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:
- 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). - Metody
LengthSquared()(zwracającą kwadrat długości wektora) orazLength()(obliczającą długość wektora). Pierwiastek kwadratowy znajdziesz w statycznej klasieMathF, która zawiera funkcje matematyczne (np.MathF.Sqrt(),MathF.Tan()) dla liczb typufloat. - Statyczną metodę
Dot()do obliczania iloczynu skalarnego. - Statyczną metodę
Cross()do obliczania iloczynu wektorowego. - 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 OriginorazVector3 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ą.
(Ź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ę:
- 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)) orazfloat Fov(90.0f). WłaściwośćTargetokreśla punkt w przestrzeni, w którym znajduje się środek rzutni kamery. Każdy akcesorsetw wymienionych właściwościach musi wywoływać metodęRecalculate(). - Zadeklaruj prywatne pola przechowujące parametry rzutni oraz kamery:
int _imageHeight,Vector3 _pixelDu,Vector3 _pixelDvorazVector3 _viewportCorner. - Dodaj bezparametrowy konstruktor, który jednorazowo wywoła metodę
Recalculate()do inicjalizacji obiektu.
Zaimplementuj prywatną metodę Recalculate(), wyznaczającą geometrię rzutni:
- Wymiary obrazu: Oblicz wysokość w pikselach:
_imageHeight = (int)(ImageWidth / AspectRatio). - Fizyczny rozmiar rzutni: Przelicz kąt pola widzenia na radiany
theta = Fov * MathF.PI / 180.0foraz połowę wysokości rzutnih = MathF.Tan(theta / 2.0f). Odległość do rzutni todistanceToViewport = (Position - Target).Length(). Wymiary wirtualnego ekranu wynoszą:- Wysokość:
viewportHeight = 2.0f * h * distanceToViewport - Szerokość:
viewportWidth = viewportHeight * AspectRatio
- Wysokość:
- 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).
- Wektor kierunku:
- 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 / ImageWidthoraz_pixelDv = viewportV / _imageHeight.
- Rozpiętość pozioma rzutni:
- Ś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ąc0.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:
- Zdefiniuj publiczne pola:
Vector3 Position,Vector3 Normal,float Torazbool FrontFace. - 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), aNormalprzyjmuje wartośćoutwardNormal. - W przeciwnym razie promień trafia od wewnątrz (
FrontFace = false), aNormalnależy odwrócić (-outwardNormal).
- Sprawdź iloczyn skalarny kierunku promienia i wektora
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 wynikbool, 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 Centerorazfloat Radius. - Zdefiniuj konstruktor inicjalizujący właściwości.
- Zaimplementuj metodę
Hit:- Wyznacz wektor od środka kuli do początku promienia:
oc = ray.Origin - Center. - Wyznacz współczynniki równania kwadratowego:
a = ray.Direction.LengthSquared()halfB = Vector3.Dot(oc, ray.Direction)c = oc.LengthSquared() - Radius * Radius
- Oblicz zredukowaną deltę równania:
discriminant = halfB * halfB - a * c. Jeślidiscriminant < 0, brak przecięcia – zwróćfalse. - Znajdź mniejszy pierwiastek
(-halfB ± MathF.Sqrt(discriminant)) / ależący w przedziale[tMin, tMax]. Jeśli żaden z pierwiastków nie mieści się w zadanym zakresie, zwróćfalse. - Wypełnij
hitInfo: parametrT = root, punkt uderzeniaPosition = ray.At(root), wyznacz wektor normalny(Position - Center) / Radiusi przekaż doSetFaceNormal(ray, outwardNormal). Zwróćtrue. (Więcej szczegółów matematycznych znajdziesz w książce).
- Wyznacz wektor od środka kuli do początku promienia:
Utwórz klasę Plane (plik Plane.cs) implementującą interfejs IHittable, reprezentującą płaszczyznę.
- Dodaj właściwości
Vector3 PointorazVector3 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 metodzieHit:- Oblicz mianownik powyższego ułamka:
denom = Vector3.Dot(Normal, ray.Direction). - Jeśli wartość bezwzględna mianownika jest bliska zeru (
MathF.Abs(denom) < 1e-6f), promień jest równoległy do płaszczyzny – zwróćfalse. - W przeciwnym razie oblicz wartość parametru:
t = Vector3.Dot(Point - ray.Origin, Normal) / denom. - Jeśli parametr
tmieści się w przedziale(tMin, tMax), uzupełnij strukturęhitInfo(parametrT = t, punkt przecięciaPosition = ray.At(t), wektor normalny przezSetFaceNormal(ray, Normal)) i zwróćtrue. W przeciwnym razie zwróćfalse.
- Oblicz mianownik powyższego ułamka:
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ąforeachprzez wszystkie elementy wObjects. Za każdym razem przy zlokalizowaniu trafienia, nadpisuj zmienną określającą górny próg poszukiwań parametrutMaxwynikiem tego trafienia. Dzięki temu, w wynikowymhitInfoznajdzie się struktura z danymi najbliższego trafionego obiektu. Zwróć zmienną typuboolinformują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):
- Oblicz pozycję środka bieżącego piksela na wirtualnej rzutni:
Vector3 pixelCenter = _viewportCorner + (i * _pixelDu) + (j * _pixelDv); - Wyznacz kierunek promienia jako wektor od pozycji obserwatora do punktu na rzutni:
Vector3 rayDirection = pixelCenter - Position; - 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:
- Utwórz obiekt
Scenei dodaj sferę w punkcie(0, 0, -1)o promieniu0.5oraz płaszczyznę w punkcie(0, -0.5, 0)z wektorem normalnym(0, 1, 0). - Skonfiguruj kamerę:
Positionna(0, 0, 1)orazTargetna(0, 0, -1). - 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.ppmEtap 3#
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 (typbool) 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 Colorinicjalizowaną przez konstruktor. - Metodę
Scatter, która zwracafalse(wskazując brak dalszego odbicia promienia) oraz przypisuje domyślne wartości do zmiennych wyjściowychout. - 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:
- W pliku
HitInfo.csdodaj do struktury polepublic Material Mat;. - W klasach
SphereiPlanedodaj właściwośćpublic Material Mat { get; set; }i przypisz jej wartość z konstruktora. - W metodach
Hitdla 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):
- Warunek stopu: jeśli limit głębokości został wyczerpany (
depth <= 0), przerwij rekurencję i zwróć kolor czarny[0, 0, 0]. - Sprawdź trafienie w obiekty sceny za pomocą
world.Hit(ray, 0.001f, float.PositiveInfinity, out HitInfo hitInfo). Jeśli brak kolizji, zwróć kolor czarny. - Pobierz światło emitowane przez materiał trafionego obiektu (
hitInfo.Mat.Emit()). - Wywołaj metodę
Scatter(...). Jeżeli materiał obiektu odbija promień (true), zwróć sumę światła emitowanego oraz rekurencyjnego wywołaniaRayColor(scattered, depth - 1, world)pomnożonego przezattenuation. - W przeciwnym razie (brak odbicia) zwróć wyłącznie kolor wyemitowany.
Wartość
tMinw wywołaniu funkcjiHitzostała ustawiona na0.001fw 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#
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:
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.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).RandomUnitVector(): Metoda zwracająca jednostkowy wektor. Wynikiem działania powinno być zwrócenie znormalizowanego niezerowego wektora pobranego z metodyRandomInUnitSphere().
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 metodyRandomUnitVector()). - 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
Albedodo zmiennejattenuation. 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:
- Wylosuj przesunięcie punktu na siatce piksela w osi X oraz Y (zmienne
offsetXioffsetYz przedziału[-0.5, 0.5)). - Oblicz pozycję wirtualnego punktu rzutni dla aktualnej iteracji próbkowania, dodając wylosowane przesunięcia do standardowych współrzędnych
iorazjprzed wymnożeniem ich przez wektory kroku_pixelDui_pixelDv. - Skonstruuj promień wychodzący z pozycji kamery przechodzący przez wylosowany punkt i dodaj wynik wywołania
RayColordo 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#
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ęć.



