Dziś wpadł mi w ręce PhysX Visual Debugger firmy NVidia. Aplikacja ta zdalnie debuguje scenę stworzoną przy użyciu silnika Physx. Wizualizuje ona zarówno aktorów (obiekty, z którymi liczone są kolizje) jak i wiele innych parametrów, w tym:

• bryły otaczające – bryły, z którymi przeprowadzane są uproszczone testy kolizji
• wektory prędkości
• stan obiektu – pokazuje, czy obiekt jest uśpiony, czy występuje kolizja z innym obiektem itd.
• itd.

Dodatkowo debugger pokazuje wszystkie parametry aktorów, dzięki czemu możemy w łatwy sposób wychwycić błąd.

Dzięki tej aplikacji udało mi się zauważyć błąd w tworzonej obecnie grze backgammon, którego nie dało się zauważyć inaczej, a który powodował dziwne zachowywanie się pionków.

Poniżej krótkie wideo z testowania gry z wykorzystaniem Physx Visual Debugger.

PhysX Remote Debugger dostępny jest do ściągnięcia na stronie: http://developer.nvidia.com/object/pvd_home.html

Po kilku miesiącach przerwy zasiadłem do pracy ponownie. Zacząłem bawić się silnikiem Physx firmy NVidia, aby gra była bardziej realna. Jak to bywa, co chwilę napotykam na problemy, z którymi męczę się przez kilka godzin, a rozwiązanie okazuje się banalne Poniżej 2 filmiki z etapów tworzenia gry To dopiero sam początek, więc za bardzo nie ma czym się zachwycać, ale pokazują one mniej więcej, jak będzie wyglądać gra.

Poniższe filmiki pokazują działanie silnika fizycznego do obsługi kostek. Na razie nie są brane pod uwagę kolizje z planszą, a jedynie pomiędzy kostkami. Kolejnym etapem są kolizje z planszą oraz z pionkami.

Etap 1

Etap 2

Nie wiem kiedy powstanie etap 3, ale mam nadzieję, że niedługo..

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.

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.