Du bist nicht angemeldet.

Werbeanzeige

1

28.08.2012, 15:08

3D Grafik mit CUDA - Wie schnell ein Wellenmodell visualisieren?

Ich hoffe mal ich bin hier richtig, generell erstmal ein großes Hallo von mir. :D

Ich komm dnan gleich mal zum Punkt. Mein Arbeitgeber bekommt demnächst ein CUDA-programm welches ein dynamisches Wellenbild für seinen Simulator generiert. Dieses Wellenbild wird in Form eines 3D-Grits aktuell noch unbekanntem Format ausgegeben.

Nun möchte er auf einen Grafikkartenrechner (welcher auch das Wellenmodell berechnet wird,Nvidia Tesla Reihe neuester Generation) auch eine Visualisierung dieses Grits haben und das möglichst in 3d.

Ich habe mich jetzt die letzten Wochen intensiv mit C, C++, WinAPI und Cuda beschäftigt. Ich bin kein Profiprogrammierer und mache vermutlich noch viele Anfängerfehler, konnte das ganze aber schon als 2D-Darstellung einmal mit WinAPi und mit Cuda realisieren wobei letzteres aufgrund einer ziemlich alten Grafikkarte eher unperformant läuft.

Nun musste ich aber feststellen das es zum erstellen einer 3D Engine mit CUDA wirklich absolut garkeine Hilfen gibt. In der Theorie ist zumindest auf basis der Voxel-Engine alles klar. Die Array definieren, Daten aufbauen die Array Punkte in Voxel umwandeln, Kamera positionen, Voxel darstellen, raytracing rüberlaufen lassen und das so entstandene Bild ausgeben. Zumnidest vermute ich das mal. :S

problem ist das es dazu wirklich garkeine Hilfsmaterialien im Internet gibt. Und da das NVIDIA Cuda Forum auf unbestimmte Zeit geschlossen ist dachte ich ich frag mal hier nach. :ninja:

Auf Wunsch kann ich euch meine Aktuellen Quellcodes gerne geben. :)

Gruß
Larkis

MitgliedXYZ

Alter Hase

Beiträge: 1 375

Wohnort: Bayern

  • Private Nachricht senden

2

28.08.2012, 15:18

Und da steht auch nix passendes?
http://developer.nvidia.com/category/zone/cuda-zone

3

28.08.2012, 15:23

Leider nicht.

Sind eher allgemein gehaltene Erklärungen bzw. fast eher Werbung was mit CUDA alles möglich ist, aber über das genaue WIE schweigt sich das ganze aus.

Bei den CUDA Paketen sind auch spiele dabei z.B: für eine richtig tolle Ozeansimulation. Dummerweise ist der Source-code der mitgeliefert wurde völlig unübersichtlich, ohne größere Kommentare und dazu unvollständig so das man es als Anfänger nicht selbst ausprobieren kann. Es wird zwar überall toll gezeigt was man alles machen kann aber nirgendswo wie. :S

dot

Supermoderator

Beiträge: 9 833

Wohnort: Graz

  • Private Nachricht senden

4

28.08.2012, 16:22

Ich denk, dein Problem ist, dass CUDA nicht ist, was du für die Darstellung eigentlich verwenden willst. ;)
Deine 3D Darstellung willst du wohl eher mit OpenGL bzw. Direct3D machen. Schau dir mal folgende Samples im CUDA SDK an (am einfachsten über den CUDA Samples Browser in deinem Startmenü):
  • Simple OpenGL
  • Simple Direct3D9 (Vertex Arrays)
  • Simple Direct3D10 (Vertex Array)

Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von »dot« (28.08.2012, 16:29)


5

29.08.2012, 09:50

Danke für die Antwort. :)

Scheinbar ist das wirklich so, ich bin gerade dabei das mit meinem Arbeitgeber abzuklären ob das mit dem Umstieg auf DirectX klargeht.

Für den Lernprozess habe ich dabei an die Bücher von dem Autor dieser Seite gedacht. Wobei diese einige schlechte Kritiken bei Amazon haben was die aktualität und Funktionsweise der Beispiele angeht. Daher die Frage wie es damit aussieht und ob man eher mit DX 9 oder DX10 anfangen sollte. (Wobei ich persönlich einer ein Freund von Dx9 bin)

dot

Supermoderator

Beiträge: 9 833

Wohnort: Graz

  • Private Nachricht senden

6

29.08.2012, 11:39

Naja, es geht ja nicht wirklich darum, auf Direct3D "umzusteigen". Mit CUDA gibt es keine Möglichkeit einer Grafikausgabe. Selbst wenn du das komplette Rendering in CUDA in Software machen würdest, bräuchtest du immer noch eine Grafik API um die Ergebnisse anzuzeigen. Deine CUDA Komponente liefert dir als Output wohl ein Höhenfeld oder sowas!? CUDA bietet nun eben Möglichkeiten, von OpenGL bzw. Direct3D aus auf CUDA Daten zuzugreifen.

Direct3D 9 ist absolut veraltet. Aber wenn du noch gar keine Erfahrung mit 3D Grafik hast, bietet es, wie auch OpenGL, wohl einen sehr viel sanfteren Einstieg als Direct3D 11. Der wesentliche Unterschied ist eben, dass du in Direct3D 9 noch ohne Shader was auf den Bildschirm bekommst. Wobei das in deinem Fall vermutlich nicht so eine große Rolle spielen dürfte, da du in dieser Sache, je nachdem wie der Output der CUDA Komponente aussieht, um Shader möglicherweise sowieso nicht wirklich herumkommen wirst. Ich denk, ich würde dir also fast eher zu Direct3D 11 raten. Für Direct3D 11 dürfte das im Moment eines der besten Einsteigerbücher sein (hab's aber nicht selbst gelesen): http://www.amazon.de/Introduction-3D-Gam…46232849&sr=8-4

Direct3D 10 ist seit dem Tag da Direct3D 11 verfügbar ist uninteressant. Du kannst es dir wie den Prototyp zu Direct3D 11 vorstellen.

Dieser Beitrag wurde bereits 6 mal editiert, zuletzt von »dot« (29.08.2012, 11:51)


7

29.08.2012, 11:52

Danke für die Antwort. :)

Ich habe mir jetzt das DirectX-9 Buch von David Scherfgen bestellt. Dank Expresslieferung kommt es morgen Vormittag an und ich kann direkt loslegen. :search:

Eine Frage mal n die Experten. :D

Da ich das auf Arbeit nutze habe ich bis nächsten Freitag täglich 8 Stunden um mich nur damit zu beschäftigen. Wie hoch ist die Wahrscheinlichkeit in der Zeit ein rudimentäres Wellenmodell auf Voxel Basis oder sogar Vertex-Basis hinzukriegen? Mit rudemntär meine ich festen Kamerawinkel und einfach nur das 3D-Array in Punkt/Netzform darzustellen wobei sich nur z nach einer festen Funktion her ändert sowie die Farbe abhängig von Z.

Also quasi der folgende Code nur eben 3D. Wobei es nicht sauber oder perfekt sein muss, sondern eben halt einfach in der Darstellung funktionieren muss das man was zeigen kann.

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include "../common/cpu_bitmap.h"
#include "../common/cpu_anim.h"
#include "../common/book.h"
#include "math.h"
#include "stdio.h"
const int DIM = 500;


struct DataBlock {
    unsigned char *dev_bitmap;
    CPUAnimBitmap *bitmap;
};
__device__ float cosinus( float y1) {
    return cos(y1 / 2000);
}

__device__ float sinus( float x1) {
    return sin(x1 / 500);
}

__device__ float rechnung1( float z1) {
    z1 = 1400 - z1;
    return (150 - z1 / 10) / 150;
}

__device__ float rechnung2() {
    return 255 / 2;
}

__device__ float formel1(float zahl1, float sin1, float cos1, float zahl2 ) {
    return  (zahl1 * (sin1 * cos1) * zahl2);
}



__global__ void kernel( unsigned char *ptr, int ticks, float d_wave[DIM][DIM]) {
    
    int x = threadIdx.x + blockIdx.x * blockDim.x;
    int y = threadIdx.y + blockIdx.y * blockDim.y;
    float x1 = threadIdx.x + blockIdx.x * blockDim.x + 530;
    float y1 = threadIdx.y + blockIdx.y * blockDim.y;
    float time = ticks;
    int offset = x + y * blockDim.x * gridDim.x; 
    __syncthreads(); 

    float sin1 = sinus(x1);
    float cos1 = cosinus(y1);
    float zahl1 = rechnung1(time);
    float zahl2 = rechnung2();
    __syncthreads();

    d_wave[x][y] = formel1(zahl1, sin1, cos1, zahl2);
    ptr[offset*4 + 0] = 0;
    ptr[offset*4 + 1] = 0;
    ptr[offset*4 + 2] = 255 * d_wave[x][y];
    ptr[offset*4 + 3] = 255;

}

void generate_frame( DataBlock *d, int ticks) {
    dim3 blocks(DIM,DIM);
    float wave[DIM][DIM];
    kernel<<<blocks,1>>>( d->dev_bitmap, ticks, wave);

    cudaMemcpy( d->bitmap->get_ptr(),
                d->dev_bitmap,
                d->bitmap->image_size(),
                cudaMemcpyDeviceToHost);
}


void cleanup( DataBlock *d) {
    cudaFree( d->dev_bitmap );
}

int main( void ) {
    DataBlock data;
    CPUAnimBitmap bitmap( DIM, DIM, &data );
    data.bitmap = &bitmap;
    cudaMalloc( (void**) &data.dev_bitmap, bitmap.image_size() );
 
    bitmap.anim_and_exit( (void (*) (void*,int))generate_frame, (void (*)(void*))cleanup );
    cudaFree( &data.dev_bitmap);


} 

dot

Supermoderator

Beiträge: 9 833

Wohnort: Graz

  • Private Nachricht senden

8

30.08.2012, 13:34

Ich denk das ist durchaus möglich. Ich weiß nicht, wieviel Einfluss du auf die CUDA Simulation hast. Im Idealfall könntest du natürlich direkt aus CUDA in einen Direct3D VertexBuffer schreiben, was im Prinzip 1:1 dem Simple Direct3D 9 Example aus dem CUDA SDK entspricht...

9

31.08.2012, 12:03

Ich denk das ist durchaus möglich. Ich weiß nicht, wieviel Einfluss du auf die CUDA Simulation hast. Im Idealfall könntest du natürlich direkt aus CUDA in einen Direct3D VertexBuffer schreiben, was im Prinzip 1:1 dem Simple Direct3D 9 Example aus dem CUDA SDK entspricht...

Ich denk das ist durchaus möglich. Ich weiß nicht, wieviel Einfluss du auf die CUDA Simulation hast. Im Idealfall könntest du natürlich direkt aus CUDA in einen Direct3D VertexBuffer schreiben, was im Prinzip 1:1 dem Simple Direct3D 9 Example aus dem CUDA SDK entspricht...
Also ansich hab ich vollen Einfluss, die Quellcodes sind mitgeliefert. Dummerweise nur die Quellcodes, es fehlen viele header auf die zwar verwiesen wird die aber nicht implementiert sind wie zum Beispiel bei dem viele d3dx9 Dateien in allen Formen und Größen.

Das ist recht ärgerlich das ich den Quellcode ansich meinen Wünschen anpassen kann aber ihn aufgrund der fehlenden header nicht compalieren kann.

meint ihr die Installation des Dx9SDK schafft abhilfe? DX11 ist auf dem Rechner jedenfalls installiert. :ninja:

10

31.08.2012, 12:40

Ja, die Runtime nützt dir nichts, du brauchst in jedem Falle das DX SDK. Wenn das Cuda Beispiel DX9 benutzt, sollte es das DX9SDK also tun.
Lieber dumm fragen, als dumm bleiben!

Werbeanzeige