dla każdego piksela na ekaranie       
{
 Końcowy kolor = 0;
 Promień = { punkt startowy, kierunek };
 Powtóż
 {
  dla kazdego obiektu w scenie 
  {
   wyznacz najblizszy promień obiekt/przecięcie;
  }
  Jezeli przecięcie istnieje
  {
   dla kazdego światła w scenie
   {
    Jeżeli światło nie jest w cieniu innego obiektu
    {
     to dodaj udział światła do policzonego koloru;
    }
   }
  }
  Końcowy kolor = Końcowy kolor + policzony kolor * poprzedni współczynnik odbicia;
  współczynnik odbicia = współczynnik odbicia * właściwości odbicia powierzchni;
  zwiększenie głębi;
 } wykonaj dopuki współczynnik odbicia jest 0 albo osiagnięta jest maksymalna głebia;
}

Obiektami są sfery, jako źródło światła przyjmujemy punkt.

Wysyłamy promień w każdy piksel aby określić jego kolor:

for (int y = 0, y <myScene.sizey; + + y) ( 
   for (int x = 0; x <myScene.sizex; + + x) ( 
   / / ... 
   ) 
   ) 

Po obliczeniu koloru zapisujemy go do pliku TGA

    imageFile.put (min (blue * 255.0f, 255.0f)). 
              put (min (green * 255.0f, 255.0f)). 
              put (min (red * 255.0f, 255.0f));

Nasze kolory są reprezentowane jako trzy liczby zmiennoprzecinkowe.

Punkt startowy znajduje się gdzieś na naszej scenie projekcji. Promienie są skierowane w jednym kierunku (w stronę dodatniej osi Z)

 ray viewRay = ((float (x), float (y),-1000.0f), (0.0f, 0.0f, 1.0f)); 

Jeden kierunek jest ważny ponieważ określa naszą projekcje. W naszym przypadku użyjemy projekcji prostopadłej (perpendicular projection lub orthographic projection). Typ projekcji określa w jaki sposób promienie są powiązane ze sobą. Jednak nie zmienia to zachowania pojedynczego promienia.

Promień jest zdefiniowany jako punkt startowy i kierunek. Parametr 't' jest to odległość dowolnego punktu promienia do punktu startowego promienia.

Rysunek 6.5. Definicja promienia

Przesuwamy tylko w jednym kierunku (z mniejszego t do większego t). Będziemy iterować przez każdy obiekt, sprawdzając czy istnieje punkt przecięcia, znajdziemy parametr t odpowiadający przecięciu, bieżemy najbliższy i jednocześnie najmniejszy jaki jest możliwy.

Rysunek 6.6. Przecięcie przez kilka obiektów

Obiektami są sfery więc będziemy mieli tylko takie przecięcia. Są to jedne z najprostszych przecięć jakie istnieją.

Wprowadzamy nasz parametr do równania przecięcia i daje nam to równanie drugiego stopnia z niewiadomą t.

Rysunek 6.7. Przecięcie przez sferę

Obliczamy Δ, jeśli Δ < 0 to nie ma przecięć, jeśli Δ >0 to mamy co najwyżej dwa przecięcia, bierzemy to najbliższe.

 vecteur dist = s.pos - r.start; 
    double B = r.dir * dist;
    double D = B*B - dist * dist + s.size * s.size; 
    if (D < 0.0f) 
        return false; 
    double t0 = B - sqrt(D); 
    double t1 = B + sqrt(D);
    bool retvalue = false;  
    if ((t0 > 0.1f) && (t0 < t)) 
    {
        t = (float)t0;
        retvalue = true; 
    } 
    if ((t1 > 0.1f) && (t1 < t)) 
    {
        t = (float)t1; 
        retvalue = true; 
    }

Bierzemy najbliższe, ale nie może ono być w tym samym położeniu co punkt startowy, dlatego porównujemy t0 i t1 do 0.1f.

Oświetlenie w jednym punkcie jest równe sumie składowych poszczególnych źródła światła. Jest to bardzo uproszczone dzięki zapewnieniu listy zdefiniowanych punktów światła.

Nie bierzemy światła, które nie jest widoczne z naszej strony powierzchni. Tak jest jeśli wychodząca normalna do naszej sfery i kierunek światła są w przeciwnym kierunku:

  // znak po wkonaniu działania pokazuje czy są w przeciwnym kierunku
  if ( n * dist <= 0.0f )
    continue;

Następnie sprawdzamy czy punkt jest w cieniu innego obiektu.

Powierzchnia ma współczynnik odbicia. Jeżeli wartość tego współczynnika wynosi 0, wówczas powierzchnia nie odbija w ogóle i możemy zatrzymać iteracje dla tego piksela i przejść do następnego. Jeśli współczynnik ten jest większy niż 0 to cześć światła dla tej powierzchni będzie obliczona poprzez wysłanie nowego promienia z nowego punktu startowego na powierzchni.

 float reflet = 2.0f * (viewRay.dir * n);
 viewRay.start = newStart;
 viewRay.dir = viewRay.dir - reflet * n;

Oczywiście ograniczmy liczbę odbić dla jednego piksela żeby uniknąć nieskończonej pętli.

Supersampling to metoda która ma na celu zmniejszyc efekt aliasingu (efekt schodkowania linii prostych) poprzez uzyskanie większej ilości próbek kolorów. Jeżli będziemy chcieli uzyskać efekt supersampling 4x, to dla obrazu o rodzielczość X,Y renderujemy wiekszy obraz X*2, Y*2 i bierzemy średnią z danej próbki żeby uzyskac kolor dla okerślonego piksela.

for (int y = 0; y < myScene.sizey; ++y) 
 for (int x = 0; x < myScene.sizex; ++x) 
 {
   float coef = 0.25f;
   float red = 0, green = 0, blue = 0; 
   for(float fragmentx = x; fragmentx < x + 1.0f; fragmentx += 0.5f)
   for(float fragmenty = y; fragmenty < y + 1.0f; fragmenty += 0.5f)
   {
     // Każdy promień to 1/4 wartości całego piksela.
      
    float sampleRatio=0.25f;  
   }
   // Udział każdego promienia jest dodawany i wynik jest zapisywany do pliku.
   red += sampleRatio * red;
   green += sampleRatio * green;
   blue += sampleRatio * blue;
 }

Rysunek 6.8. Obraz wynikowy po użyciu antialiasingu.

Rysunek 6.9. Obraz wynikowy po użyciu antialiasingu (wewnątrz prostokąta obraz bez antialiasingu).

Program uruchamiany na PPU wczytuje plik sceny zawierający listę obiektów, świateł i materiałów. Otrzymujemy strukturę zawierającą całą scenę.

        scene myScene;
        if (!init(argv[1], myScene))
        {
         cout << "Failure when reading the Scene file." << endl;
         return -1;
        }

Funkcja init wczytuje plik sceny podany jako parametr do programu. Zwraca strukturę zawierającą całą scenę.

Po inicjalizacji SPU wysyłany jest do niego kontekst zawierający dane wejściowe. Natomiast dla danych wyjściowych na PPU tworzona jest tablica, a jej adres wysyłany jest do poszczególnych SPU.

        rc = posix_memalign ((void**)(&out_data), 128, myScene.sizex * myScene.sizey * 3 * sizeof(float)); 
        if (rc != 0)
        {
         fprintf (stderr, "Failed allocating space for output data array\n");
         exit (1);
        }

        memset (out_data, 0, myScene.sizex * myScene.sizey * 3 * sizeof (float));

NAstępnie obliczana jest część ekranu którą ma wyrenderować pojedynczy SPU.

        part = myScene.sizey/spu_num

Jest to obliczane na podstawie wysokości sceny i zadanej ilości SPU (domyślnie 6).

Następnie w pętli wykonywanej tyle razy ile jest SPU, do kontekstu zapisywane są informacje o współrzędnych renderowanego fragmentu. Dodawany jest również adres tablicy wyjściowej, generowany na podstawie wielkości sceny, ilości SPU i obliczonej wcześniej części. Ponieważ struktura sceny zawiera wektory struktur opisujących obiekty , światła i materiały. Nie da się tego przesłać poprzez kontekst do SPU, trzeba było przekształcić wektor na tablice i w tej formie go przesłać. Dodatkowe zmienne w kontekście zawierają długości wektorów sceny. Następnie zapisywany jest aktualny czas, tworzony jest wątek na SPU oraz oczekiwanie na jego zakończenie i zatrzymywany czas.

        for(i=0;i<spu_num;i++)
        {
         ctxs[i].Xstart = 0;
         ctxs[i].Xend = myScene.sizex;
         ctxs[i].Ystart = part*i;
         ctxs[i].Yend = part*(i+1);
         ctxs[i].spid = i;
         ctxs[i].out_addr = (unsigned long long)out_data + (unsigned long long)(i* part * myScene.sizex * 3 * sizeof(float));
         for(int j=0;j<30;j++)
         {
          ctxs[i].mCont[j] = myScene.materialContainer[j];
          ctxs[i].sCont[j] = myScene.sphereContainer[j];
          ctxs[i].lCont[j] = myScene.lightContainer[j];
         }
         ctxs[i].mSize = myScene.materialContainer.size();
         ctxs[i].sSize = myScene.sphereContainer.size();
         ctxs[i].lSize = myScene.lightContainer.size();

         gettimeofday(&time,NULL);
         tstart=time.tv_sec +(time.tv_usec/1000000);
         pthread_create(&pthreads[i], NULL, &pthread_run_spe, &ctxs[i]);

         pthread_join (pthreads[i], NULL);
         gettimeofday(&time,NULL);
         tend=time.tv_sec +(time.tv_usec/1000000);
        }

Po zakończeniu pracy wszystkich SPU otrzymujemy tablice zawierającą opis pliku wynikowego. Uruchamiana jest funkcja Draw która zapisuje tablice jako plik graficzny w formacie TGA.

Na koniec programu wyświetlany jest czas samego renderowania

Struktura kontekstu:

        struct context{
         int spid;
         int Xstart,Xend,Ystart,Yend;
         int mSize,sSize,lSize;
         material mCont[30];
         sphere sCont[30];
         light lCont[30];
         unsigned long long out_addr;
        }__attribute__((aligned(16)));

Na początku definiowana jest lokalna tablica w której przechowywana jest paczka zawierająca wyrenderowane piksele. SPU nie odsyła całego wyrenderowanego fragmentu tylko dzieli go na mniejsze paczki. SPU odbiera przesłany z PPU kontekst.

        mfc_get(&ctx, parm, sizeof(ctx), tag,0,0);
        mfc_write_tag_mask(1<<tag);
        mfc_read_tag_status_all();

Jak wyżej zostało opisane scena została wysłana jako tablica i teraz należy tablice z powrotem włożyć do wektora struktur.

        std::vector<material> materialki(ctx.mSize);
        std::vector<sphere> sfery(ctx.sSize);
        std::vector<light> swiatla(ctx.lSize);

        for(i=0;i<ctx.mSize;i++)
        {
         materialki[i].reflection = ctx.mCont[i].reflection;
         materialki[i].red = ctx.mCont[i].red;
         materialki[i].green = ctx.mCont[i].green;
         materialki[i].blue = ctx.mCont[i].blue;
        }

        for(i=0;i<ctx.sSize;i++)
         {
          sfery[i].pos.x = ctx.sCont[i].pos.x;
          sfery[i].pos.y = ctx.sCont[i].pos.y;
          sfery[i].pos.z = ctx.sCont[i].pos.z;
          sfery[i].size = ctx.sCont[i].size;
          sfery[i].materialId = ctx.sCont[i].materialId;
         }

         for(i=0;i<ctx.lSize;i++)
         {
          swiatla[i].pos.x = ctx.lCont[i].pos.x;
          swiatla[i].pos.y = ctx.lCont[i].pos.y;
          swiatla[i].pos.z = ctx.lCont[i].pos.z;
          swiatla[i].red = ctx.lCont[i].red;
          swiatla[i].green = ctx.lCont[i].green;
          swiatla[i].blue = ctx.lCont[i].blue;
         }

         myScene.materialContainer = materialki;
         myScene.sphereContainer = sfery;
         myScene.lightContainer = swiatla;

Gdy scena jest już poskładana i ma strukture taką samą jak przed podziałem następuje renderowanie. Po wygenerowaniu trzech subpikseli są one zapisywane w zdefiniowanej wcześniej tablicy lokalnej. Następnie sprawdzane jest czy lokalna tablica jest pełna, jeżeli tak tablica przesyłana jest w wyznaczone miejsce do tablicy głównej na PPU

        local_buffer[pos] = blue;
        pos++;
        local_buffer[pos] = green;
        pos++;
        local_buffer[pos] = red;
        pos++;
        num+=3;

        if(pos >= 3072)
        {
         out_addr = ctx.out_addr + (page * 3072 * sizeof(float));
         mfc_put (local_buffer, out_addr, 3072 * sizeof(float), tag, 0, 0);
         mfc_write_tag_mask (1 << tag);
         mfc_read_tag_status_all ();
         pos = 0;
         page++;
        }

W projekcie została także wykorzystana wektoryzacja, to z założenia powinno przyspieszyć obliczenia.

Kod który został zwektoryzowany:

red += sampleRatio * red;
green += sampleRatio * green;
blue += sampleRatio * blue;

Kod po zmianach:

vector float kolor;
vector float kolory;
vector float coefTemp = (vector float){0.25f, 0.25f, 0.25f, 0.25f};
.
.
kolory = (vector float){red, green, blue, 0.0f}; // przypisanie kolorow do wektora
.
.
kolor = spu_madd(kolory,coefTemp,kolor); // mnozenie i dodawanie kolorow