Zająłem się więc dodawać efekty

Efektem, który znacznie podnosi realizm gry są odbicia. Jako, że plansza będzie lekko wypolerowania, będzie w niej widać delikatne odbicia kostek. Poniżej krótki filmik pokazujący na zwykłej płaszczyźnie odbicia kostek.

Docelowo odbicia będą tylko na planszy. Pomyślę też nad “polerowaniem” pionków i innych elementów

Odbicie to jest prostym do osiągnięcia efektem, polegającym na przekształceniu elementów (w tym przypadku kostek), względem pewnej płaszczyzny, a następnie odrysowanie tej płaszczyzny z włączonym mieszaniem kolorów (GL_BLEND), czyli wykorzystaniem przezroczystości. W rzeczywistości każda kostka renderowana jest dwukrotnie (oryginalny obiekt + odbicie).

Miałem to zrobić jutro, ale z powodu bezsenności udało mi się przenieść efekt odbicia pionków na docelową planszę. Aktualnie odbicia są może zbyt widoczne, ale to tymczasowe rozwiązanie, żeby zaprezentować efekt Zapraszam do obejrzenia poniższego filmiku.

Share on Facebook

Mam też niewielki błąd (szumy) na krawędziach obiektów, co jest moim kolejnym zadaniem w tym projekcie.

Poniżej mały sample z bumpem i różnymi właściwościami powierzchni (połyskliwość).

Bump mapping

Share on Facebook

Dodane zostało teksturowanie.

Za mapowanie tekstury odpowiada następujący fragment kodu:

def getTexel(vp: Vector): Color = {
hasTexture match {
case false => color
case true =>
val vn = new Vector(0,-1,0)
val ve = new Vector(-1,0,0)
val phi = Math.acos(-vn.dot(vp))
val v = phi / Math.Pi
val theta = (Math.acos(vp.dot(ve) / Math.sin(phi))) /
            (2 * Math.Pi)
val u = vn.crossProduct(ve).dot(vp) > 0 match {
case true => theta
case false => 1 - theta
}
val color = new java.awt.Color(
    textureFile.getRGB(((u * _textureScale * textureFile.getWidth
    + _tPosX) % (textureFile.getWidth - 1)) .toInt,
    ((v * _textureScale * textureFile.getHeight + _tPosY) %
    (textureFile.getHeight - 1)).toInt))
new Color(color.getRed / 255.0, color.getGreen / 255.0,
    color.getBlue / 255.0)
}
}

Efekt załączony na poniższym rysunku:

Ray Tracing - Scala - tekstury

Kod projektu znajduje się w repozytorium: http://code.google.com/p/scala-raytracer/source/browse/

Share on Facebook

Scala jest językiem funkcyjnym, działającym na wirtualnej maszynie Javy. Fajnie integruje się ze standardowymi klasami Javy, co znacznie zwiększa jego funkcjonalność.

Silnik obsługuje na razie tylko prosty model oświetlenia Phonga oraz przecinanie promienia jedynie z kulami.

Scala Ray Tracing

Zamierzam dopisać do tego bump mapping, ale z czasem może być krucho i na zamiarach może się skończyć

Poniżej przykład wygenerowanego obrazu (zamierzam sprawić, że będzie to bardziej spektakularne )

Projekt hostowany jest na code.google.com i dostępny na licencji MIT.

Link do projektu: http://code.google.com/p/scala-raytracer/

W chwili wolnego czasu opiszę kawałki kodu, gdyż języki funkcyjne delikatnie różnią się od tych, w których najczęściej programujemy

Share on Facebook

Projekt oparty został o bibliotekę QT w wersji 4.5. Komunikacja odbywa się za pomocą socketów TCP.

Architektura tego rozwiązania opiera się o 3 elementy:

• Klient – program, w którym operuje użytkownik chcący wygenerować obraz metoda ray tracing.
• Serwer zarządzający – który rozsyła części obrazu do generowania przez serwery robocze
• Serwery robocze – pracujące nad generowaniem poszczególnych części obrazu.

Jak to bywa w projektach studenckich, także i ten jest napisany obecnie dość chaotycznie i zawiera na pewno wiele błędów. Będą one jednak usuwane z biegiem czasu, a w chwili obecnej istotne jest raczej to, że projekt mniej więcej działa

Na początek jeden screen klienta:

Projekt został wrzucony na code.google.com i znajduje się pod adresem: http://code.google.com/p/distributedraytracing/.

Sama biblioteka ray tracera jest osobną dll’ką i jest nieco niedopracowana. Postaram się, bliżej wakacji, poprawić wszystkie błędy w niej zawarte i wprowadzić obsługę standardowych formatów scen (obecnie stosowany jest system niestandardowy, lecz dorzucone są przykładowe sceny).

Postaram się w przyszłości opisać niektóre fragmenty tego rozwiązania.

Share on Facebook

Jak to zrobić?

Otóż, jeżeli mamy nasz promień w postaci

R = Origin + V * Direction

oraz równanie cylindra w postaci..

Share on Facebook

Khronos Group (twórca specyfikacji) chwali się tym, iż język ten ma zapewnić pełną niezależność języka od wykorzystanej technologii, a lista firm zaangażowanych w projekt, czyli: 3DLABS, Activision Blizzard, AMD, Apple, ARM, Barco, Broadcom, Codeplay, Electronic Arts, Ericsson, Freescale, HI, IBM, Intel, Imagination Technologies, Kestrel Institute, Motorola, Movidia, Nokia, NVIDIA, QNX, RapidMind, Samsung, Seaweed, Takumi, Texas Instruments i Umeå University uspokaja mnie, jeżeli chodzi o powodzenie tego projektu

Wcześniej zajmowałem się stricte technologią CUDA, ale z racji tego iż gdzieś na półce kurzy się moje PS3, to technologię tą zacznę wykorzystywać z jeszcze większą chęcią.

W najbliższym czasie postaram się opisać szerzej język OpenCL (jak tylko przeczytam specyfikację ), a także sprawdzę na ile język ten jest wygodny, elastyczny i.. czy działa.

A jeżeli zadziała, może być ciekawie

Share on Facebook

Dodawanie kolejnych par wektorów odbywa się na karcie graficznej. Odpowiada za to funkcja vecAdd z kwalifikatorem __global__.
Kwalifikator ten oznacza, że funkcja może być wykonywana zarówno jako host (CPU) jak i device (GPU).

Prosty kod odpowiadający za dodawanie 2 wektorów

#include <stdio.h>
#include <cutil.h>
__global__ void vecAdd (float3 a[10], float3 b[10]) {
int i = threadIdx.x;
a[i].x += b[i].x;
a[i].y += b[i].y;
a[i].z += b[i].z;
}

int main(int argc, char** argv) {

CUT_DEVICE_INIT(argc, argv); // inicjalizacja GPU

float3 *a_h, *b_h, *a_d, *b_d, *result;
int arraySize = 10;
int sizeInBytes = arraySize * sizeof(float3);
a_h = (float3*)malloc(sizeInBytes); // inicjalizacja tablic (na hoscie)
b_h = (float3*)malloc(sizeInBytes);
result = (float3*)malloc(sizeInBytes);

CUDA_SAFE_CALL(cudaMalloc((void**)&a_d, sizeInBytes)); // inicjalizacja tablic na GPU
CUDA_SAFE_CALL(cudaMalloc((void**)&b_d, sizeInBytes));

for(int i = 0; i < arraySize; i++) { // przykładowe dane
a_h[i].x = 100.0f + i;
a_h[i].y = 200.0f + i;
a_h[i].z = 300.0f + i;
b_h[i].x = 50.0f + i;
b_h[i].y = 50.0f + i;
b_h[i].z = 50.0f + i;
}

CUDA_SAFE_CALL(cudaMemcpy(a_d, a_h, sizeInBytes, cudaMemcpyHostToDevice));
// kopiujemy tablicę z hosta do GPU
CUDA_SAFE_CALL(cudaMemcpy(b_d, b_h, sizeInBytes, cudaMemcpyHostToDevice));

vecAdd<<<1, arraySize>>>(a_d, b_d); // wykonujemy dodawanie
CUDA_SAFE_CALL(cudaMemcpy(result, a_d, sizeInBytes, cudaMemcpyDeviceToHost));
// kopiujemy z powrotem

for(int i = 0; i < arraySize; i++){
printf("Wartość %d.elementu %f, %f, %f \n", i, result[i].x,
result[i].y, result[i].z); // wyswietlamy 
}

CUT_EXIT(0, NULL); // koniec
}

Wydaje się proste

W przyszłości postaram się opisać po kolei wszystkie szczegóły.

Share on Facebook

Postanowiłem zaopatrzyć się w sprzęt, który pozwoli w pełni wykorzystać technologię CUDA do obliczeń związanych z ray tracingiem. Zdecydowałem się na Asusa GTX260, który nie miał zbyt wygórowanej ceny, ale oferował to co misie lubią najbardziej, czyli dużo “thread proccessors”. Sprzęcik wygląda mniej więcej tak:

Asus GTX260

Jeżeli chodzi o mechanizm CUDA, początkowo (czego nie dotyczytałem wcześniej) okazało się, że funkcje __global__, __device__ (czyli te uruchamiane na karcie graficznej), nie obsługują rekursji! Więc algorytm rekursywnych testów przecięć się nie sprawdzi. Może jednak uda się zaimplementować równoległe przeprowadzanie testów cieni, co w przypadku scen z dużą liczbą świateł, może dość mocno przyspieszyć generowanie obrazu.

W kolejnych postach postaram się zaprezentować przykładowe zastosowanie CUDA do szybkich obliczeń, a także powiedzieć coś więcej o samej technologii.

Share on Facebook