GPU Programmierung 12. Vorlesung Photorealistische Computergrafik

Transkript

1 GPU Programmierung 12. Vorlesung Photorealistische Computergrafik Thorsten Grosch

2 Standard OpenGL Pipeline verändern Bisher: Jeder glvertex( ) Punkt durchläuft die Standard OpenGL Pipeline Jetzt: Funktionalität verschiedener Stufen der Pipeline kann verändert werden Veränderungen sind möglich auf Ebene von (Eck-)Punkten (Vertex-Program) Grafikprimitiven (Geometry-Program) Pixeln (Fragment-Program) Thorsten Grosch - 2 -

3 Die programmierbare Pipeline Vertex Program (Vertex Shader) Programm pro Eckpunkt Geometry Program (Geometry Shader) Programm pro Grafikprimitiv Fragment Program (Pixel Shader) Programm pro Pixel Thorsten Grosch - 3 -

4 Eigenschaften Vertex Program Arbeitet nur auf einem Eckpunkt Keine Information über Topologie (andere Eckpunkte) Keine Punkte erzeugen oder löschen Wahlfreier Zugriff auf Texturspeicher Auslesen des abgespeicherten Wertes an einer beliebigen Position innerhalb einer Textur (Textur = 2D Array mit Daten) Thorsten Grosch - 4 -

5 Normale Normale Aufgaben Vertex Program Eckpunkttransformation Weltkoordinaten in Kamerakoordinaten (Modelview) Transformation in kanonisches Volumen (Projection) Normalentransformation Transponierte Inverse Beleuchtung in Kamerakoordinaten Automatische Generierung von Texturkoordinaten... Thorsten Grosch - 5 -

6 Was gehört nicht ins Vertex Program Clipping am kanonischen Volumen (-w +w) Perspektivische Division (x/w, y/w, z/w) (Color Clamping an [0,1]) Thorsten Grosch - 6 -

7 Vertex Program schematisch Texturspeicher Position (Welt) Position (kan.vol. w..+w) Farbe Normale Vertex Farbe Texturkoordinaten Program Texturkoordinaten Benutzerdefinierte Benutzerdefinierte Attribute t Attribute OpenGL State (Lichtquellen, Materialien, Matrizen) Benutzerdefinierte (uniform) Daten Thorsten Grosch - 7 -

8 Eigenschaften Fragment Program Fragment Program Vertex Rasterizer Fragment Processor Processor Arbeitet am Ende der Pipeline Wird für jedes zu zeichnende e Fragment (Pixel) aufgerufen Arbeitet nur auf aktuellem Fragment (Pixel) Kein Lesen oder Schreiben auf andere Pixel im Framebuffer Eingabe: Interpolierte Werte aus Eckpunkten Wahlfreier Zugriff auf Texturspeicher Thorsten Grosch - 8 -

9 Fragment Program Normale Aufgaben Fragment Program Farbe des Pixels festlegen Texturzugriff Effekte (z.b. Nebel) Was ein Fragment-Program nicht leistet Depth-Test Stencil-Test Alpha-Blending Wird nach den Fragment- Programmen durchgeführt Thorsten Grosch - 9 -

10 Fragment Program schematisch Texturspeicher Interpolierte Farbe Interpolierte Texturkoordinaten Interpolierte benutzerdefinierte Attribute Fragment Program Pixelfarbe (Tiefenwert) OpenGL State (Lichtquellen, Materialien, Matrizen) Benutzerdefinierte (uniform) Daten Thorsten Grosch

11 GPU programmieren - Damals Programmierung in Maschinensprache Programme werden sehr schnell unübersichtlich... vs.1.0 def c94, 0.18f, 0.18f, 0.18f, 0.18f m4x4 opos, v0, c16 mov ot0.xy, v7 ; Scalar for cube map adjustment ; OutPos = ObjSpacePos * Composite WVP-Matrix ;Passthrough texcoord 0 for bump map addressing add r8, c28, -v0 ;View direction m3x3 r9, r8, c20 ;Transform view vector from object space to env space dp3 r11.x, r9, r9 ;Magnitude^2 rsq r11.y, r11.x ;1/mag mul ot4.xyz, r9, r11.y ;Normalize... Thorsten Grosch

12 GPU programmieren - Heute Programmierung in einer Hochsprache Compiler zur Übersetzung in Maschinensprache Erste Shading-Languages RenderMan (Pixar 1988) Stanford Real-Time Shading Language (2001) Aktuell Cg (NVIDIA, OpenGL und DirectX) HLSL (Microsoft, DirectX) OpenGL Shading Language (GLSL) Weitere (GPGPU) Cuda (NVIDIA), CTM (ATI) Brook, Sh Thorsten Grosch

13 OpenGL Shading Language (GLSL) Teil des OpenGL 2.0 Standards Syntax orientiert sich an C / C++ Funktionen Einfache Datentypen (float, int, bool) Strukturen Arrays Bedingungen Schleifen Aber: Keine Zeiger Beliebige Länge der Shader-Programme Thorsten Grosch

14 Sprachmerkmale von GLSL Vektoren und Matrizen vec4 (Vektor bestehend aus 4 float-werten), mat4 (4x4 float-matrix), Operationen auf Vektoren und Matrizen (SIMD) o = m * n (Matrixmultiplikation) mat4 n, m, o; u = v + w (Vektoraddition) vec4 u, v, w; u = cross(v,w) (Kreuzprodukt) float f; f = dot(u,v) (Skalarprodukt) u = mod(v, w) (komp.weises Modulo % für float Vektoren) Viele weitere mathematische h Funktionen sin(x), cos(x), tan(x), p g p p g _quickref.pdf Thorsten Grosch

15 Swizzle / Masking Swizzle (Komponenten eines Vektors vertauschen) Rechte Seite der Zuweisung u = v.zxyw u = v u = v x z y x u = v z y u = v Masking (Nur in bestimmte Komponenten schreiben) Linke Seite der Zuweisung v.xy = v + n v v + n = v = v + n v, v x x y y y z w Skalare Werte mehrfach zuweisen x u.xy = dot(v.xyz,w.xyz) u = u = v w + v w + v w x y x x y y z z u, u z u w unverändert w w unverändert Thorsten Grosch

16 Typkonvertierung Typkonvertierung Anders als in C int i; float f = float(i); // Fehler bei f = i Konvertierung muß meist von Hand gemacht werden Beispiel vec4 v = vec4(1.0, 2.0, 3.0, 1.0); vec3 v2 = v.xyz; // Fehler bei v2 = v Thorsten Grosch

17 Ein- und Ausgabe bei Shader Programmen Zugriff auf Eigenschaften des aktuellen Eckpunktes bzw. Fragments über vordefinierte Variablen Ausgabe der Shader-Programme über vordefinierte Ausgabe-Variablen Ausgabe bei Vertex-Programmen Werte werden linear interpoliert Farbe, Texturkoordinaten, Zugriff in Fragment Shader auf interpolierte Werte Zusätzlich eigene Ausgabe-Variablen varying variables später mehr dazu Thorsten Grosch

18 Ein- und Ausgabeparameter Vertex Shader Eingabe Ausgabe Position (gl_vertex) (g_ Position (gl_position) Farbe (gl_color) Farbe (gl_frontcolor) Normale (gl_normal) Texturkoordinaten (gl_texcoord[]) Texturkoordinaten (gl_multitexcoordn) Fragment Shader Eingabe Ausgabe Farbe (gl_color) Texturkoordinaten (gl_texcoord[]) Pixelfarbe (gl_fragcolor) Tiefenwert (gl_fragdepth) Komplette Liste Thorsten Grosch

19 GLSL Programmierung Shader Objekt erzeugen vertexshader = glcreateshader(gl_vertex_shader); Source-Code bereitstellen Quelltext aus Textdatei einlesen und übergeben glshadersource(vertexshader, 1, &sourceptr, NULL); sourceptr vom Typ char*( string ) Shader compilieren glcompileshader(vertexshader); Thorsten Grosch

20 GLSL Programmierung Shader Program Objekt erzeugen program = glcreateprogram(); Shader Program mit Shadern bestücken glattachshader(program,vertexshader); Program linken gllinkprogram(program); Program benutzen gluseprogram(program); Zurück zur OpenGL Fixed-Function Pipeline gluseprogram(0); Fehlerabfrage: siehe Beispielprogramme Shader Program Vertex Shader Geometry Shader Fragment Shader Thorsten Grosch

21 Uniform Variablen Benutzerdefinierte Daten in Shader laden Innerhalb von Shadern nur Lesezugriff Wert konstant für Grafikprimitiv Parameter mit seltener Änderung, z.b. Timer Applikation (OpenGL Programm) // Program muss aktiv sein Shader gluseprogram(shader); uniform float Time; // Speicherstelle innerhalb void main() // Shader-Program abfragen { GLuint loc; loc=glgetuniformlocation(shader, "Time"); } // Wert setzen gluniform1f(loc, 2.314); Wenn der String nicht gefunden wird, dann wird loc = -1 zurückgegeben Thorsten Grosch

22 Zugriff auf OpenGL-State Zugriff über vordefinierte Uniform-Variablen Werden automatisch gesetzt Beispiele gl_modelviewmatrix gl_modelviewprojectionmatrix gl_projectionmatrix gl_modelviewmatrixinversetranspose gl_lightsource[0..n] gl_frontmaterial Thorsten Grosch

23 Minimales GLSL-Programm Vertex-Shader void main() { gl_position = gl_modelviewprojectionmatrix * gl_vertex; gl_frontcolor = gl_color; } Fragment-Shader void main() { gl_fragcolor = gl_color; } Thorsten Grosch

24 Einfache Beleuchtung mit GLSL Beleuchtung passiert im Standard OpenGL Vertex Program Bei eigenem Vertex Program muss Beleuchtung selbst programmiert werden Normale Beleuchtung mit OpenGL Transformation in Kamerakoordinaten Transformation der Normalen mit transponierter Inverse Beleuchtung pro Eckpunkt in Kamerakoordinaten Vereinfachte Variante 1 Licht Beleuchtung in Weltkoordinaten Nur diffuse Beleuchtung Thorsten Grosch

25 Gouraud Shading im Vertex Program Szenario: N Eckpunkt lightvec Lichtquelle void odmain() { vec3 normal = normalize(gl_normal); // Falls nicht normiert vec3 lightvec = gl_lightsource[0].position.xyz // Vektor zur gl_vertex.xyz; // Lichtquelle lightvec = normalize(lightvec); // Normalisieren float cosinus = dot(normal, lightvec); // Empfängercosinus gl_frontcolor = gl_frontmaterial.diffuse * // Farbe berechnen gl_lightsource[0].diffuse * cosinus; gl_position = ftransform(); // Transformation in kanonisches Volumen } ftransform(): Fixed-Function-Pipeline-Transform Entspricht gl_modelviewprojectionmatrix * gl_vertex, aber evtl. andere Rundungsgenauigkeit Thorsten Grosch

26 Phong Shading Beleuchtung pro Pixel im Fragment Program Normalen müssen interpoliert werden Problem mit OpenGL Normalen werden nach der ModelView-Transformation weggeworfen Position des Eckpunktes wird nach dem Clipping weggeworfen Normalen und Position müssen an Fragment Program weitergegeben werden Nur wie? Thorsten Grosch

27 Werteübergabe von Vertex Program an Fragment Program GLSL Cg Normalen und Position in varying variables ablegen varying variables Benutzerdefinierte Variablen Können beliebige Werte enthalten (Geschwindigkeit, ) Lineare Interpolation zwischen den Eckpunkten varying variables existieren dort nicht Normale und Position in Texturkoordinaten ablegen Texturkoordinaten t werden analog zu den varying variables zwischen den Eckpunkten interpoliert Thorsten Grosch

28 Phong Shading Vertex Program varying vec4 position; varying vec3 normal; void main() { position = gl_vertex; normal = gl_normal; gl_position = gl_modelviewprojectionmatrix * gl_vertex; } Thorsten Grosch

29 Phong Shading Fragment Program varying vec4 position; varying vec3 normal; void main() { vec3 normal = normalize(normal); vec3 lightvec = gl_lightsource[0].position.xyz iti - position.xyz; lightvec = normalize(lightvec); float cosinus = dot(normal, lightvec); } gl_fragcolor = gl_frontmaterial.diffuse * gl_lightsource[0].diffuse * cosinus; Thorsten Grosch

30 Vergleich Gouraud Phong Shading Thorsten Grosch

31 Texturen Im Rahmen der GPU-ProgrammierungProgrammierung nicht nur zur Speicherung von Farbinformationen gedacht Normalen (Bump-Mapping) Tiefeninformationen (Depth-Peeling) Strahlen (Ray-Tracing) Eigener Datentyp in GLSL sampler1d, sampler2d, sampler3d (1,2 und 3D-Texturen) samplercube (Cube Maps) sampler1dshadow, sampler2dshadow (Depth Maps) Textur wird per uniform-variable i an Shader übergeben Thorsten Grosch

32 Zugriff auf Texturen Texturzugriff in (Fragment) Shader an Position gl_texcoord[0].st uniform sampler2d simpletexture; void main() { vec3 value = texture2d(simpletexture, gl_texcoord[0].st).xyz; } Thorsten Grosch

33 Zugriff auf Texturen Alternativ: Texturzugriff über Integer Pixel Koordinaten (funktioniert nur bei neueren Grafikkarten) gl_fragcoord.xy ist die Pixelposition des aktuellen Fragments Typischer Zugriff bei Deep Framebuffer uniform sampler2d simpletexture; void main() { ivec2 pixelcoords = ivec2(gl _ FragCoord.xy); vec3 value = texelfetch2d(simpletexture, pixelcoords,0); } Thorsten Grosch

34 Texturen an Shader übergeben Textur generieren und ggf. mit Daten füllen (Applikation) glgentextures(1, &texture); glbindtexture(gl_texture_2d, texture); gltexparameterf(gl_texture_2d,gl_texture_wrap_s,gl_clamp); TEXTURE TEXTURE gltexparameteri(gl_texture_2d, GL_TEXTURE_MAG_FILTER, GL_LINEAR); LINEAR); Textur binden und an Shader übergeben (Applikation) glbindtexture(gl_texture_2d, texture); GLint location = glgetuniformlocation(shaderprogram, "simpletexture"); gluniform1i(location, 0); Sieht komisch aus Übergibt aktuell gebundene Textur Thorsten Grosch

35 Mehrere Texturen übergeben glgentextures (1, &positiontextureid); glbindtexture (GL_TEXTURE_2D, positiontextureid); gltexparameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); gltexparameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glgentextures (1, &normaltextureid); glbindtexture (GL_TEXTURE_2D, normaltextureid); gltexparameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); gltexparameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glactivetexture(gl_texture0); glbindtexture (GL_TEXTURE_2D, positiontextureid); glactivetexture(gl_texture1); TEXTURE1); glbindtexture (GL_TEXTURE_2D, normaltextureid); Aktuelle Textureinheit festlegen Thorsten Grosch

36 Mehrere Texturen übergeben GLint p_location = glgetuniformlocation(shaderprogram, positiontexture"); gluniform1i(p_location, 0); GLint n_location = glgetuniformlocation(shaderprogram, normaltexture"); gluniform1i(n_location, 1); Die Nummer i entspricht hier der Textur, die mit glactivetexture(gl_texture<i>) gesetzt wurde Thorsten Grosch

37 Multi-Pass Rendering Viele Algorithmen benötigen Zugriff auf die Nachbarn eines Pixels Filter in der Bildverarbeitung Post-Processing Processing Effekte (z.b. Glow-Effekt, siehe Übung) Zugriff auf benachbarte Pixel des Framebuffers innerhalb eines Fragment-Programs nicht möglich Lösung: Multi-Pass Rendering Ergebnis eines Rendering-Schrittes als Eingabe des folgenden Schrittes verwenden Das endgültige Bild entsteht erst nach mehreren Durchläufen Thorsten Grosch

38 Multi-Pass Rendering Szene normal rendern Framebuffer auslesen und in Textur kopieren Textur an Shader-Program übergeben Viewport auf Größe der Textur setzen Bildschirmfüllendes Rechteck zeichnen glbegin(gl_quads); gltexcoord2f(0,0); glvertex2f(-1,-1); gltexcoord2f(1,0); glvertex2f( 1,-1); glend() (-1,1) (0,1) (1,1) (1,1) (-1,-1) (0,0) (1,0) (1,-1) Für jedes Texel der Textur wird genau ein Fragment generiert Zugriff auf Nachbarpixel nun über Texturzugriff Thorsten Grosch

39 Bsp. Multi-Pass Auf Original addieren (Bild aus GPU Gems) Glühende Teile in Textur rendern Horizontaler Filter auf Textur anwenden Vertikaler Filter auf Textur anwenden Ein Filter benötigt Informationen über Nachbarpixel Bild muß als Textur vorliegen, da kein Zugriff auf Nachbarpixel im Framebuffer möglich Glow Effect, siehe Übung Thorsten Grosch

40 Frame Buffer Objects Direktes Rendern in Textur Bild wird nicht angezeigt Kein Kopiervorgang nötig für Framebuffer Textur Die Alternative glcopyteximage2d( ) kopiert den Framebufferinhalt in eine Textur Bedingungen Mind. 1 Color Textur muß gesetzt sein Größe für alle Texturen muß definiert und gleich sein Thorsten Grosch

41 FrameBufferObjects // FBO generieren glgenframebuffersext (1, &myfb); // als aktuellen FBO setzen glbindframebufferext (GL_ FRAMEBUFFER_ EXT, myfb); // Textur zuweisen glframebuffertexture2dext (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, _ colortextureid, 0); glframebuffertexture2dext (GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, depthtextureid, 0);. glbindframebufferext (GL_FRAMEBUFFER_EXT, myfb); // FBO aktivieren // alles hier wird in die Textur gezeichnet (und ist nicht direkt sichtbar!) glbindframebufferext (GL_ FRAMEBUFFER_ EXT, 0); // FBO deaktivieren Thorsten Grosch

42 Beispiele für GPU Programmierung:Normal Mapping Unebenheiten auf Oberflächen durch Veränderungen der Normalen simulieren Oberflächendetails müssen nicht durch zusätzliche Geometrie dargestellt werden Normalen zur Beleuchtung pro Pixel aus Textur (Normal Map) auslesen Thorsten Grosch

43 Normal Mapping - Koordinatensystem Alle an der Beleuchtung beteiligten Vektoren Normale aus Textur (n r ) Vektor zur Lichtquelle (l r ) r Vektor zum Augpunkt (e) müssen im gleichen Koordinatensystem vorliegen In welchem Koordinatensystem soll n r liegen? Welt- oder Objektkoordinaten Bei Objektbewegungen müssen alle Normalen der Normal Map mit verschoben werden Normalen müssten zur Beleuchtung pro Pixel in Kamerakoordinaten umgerechnet werden Normal Map wäre nicht wiederverwendbar schlechte Wahl Niklas Henrich

44 Tangent Space Tangente (x-richtung) Binormale (y-richtung) Normale (z-richtung) Lokales Koordinatensystem pro Polygon Gleiches Koordinatensystem, in dem n r definiert ist Normal Map kann wiederverwendet werden Grober Ablauf Vertex Shader transformiert l r und e r in Tangent Space Vertex Shader übergibt transfomierte Vektoren an Fragment Shader (lineare Interpolation) Pixel Shader liest Normale n r aus Textur aus und führt Lichtberechnung mit interpolierten l r und e r durch Thorsten Grosch

45 Cube Mapping Eine Form des Environment Mappings Umgebung wird durch 6 Texturen beschrieben Kamera mit 90 Öffnungswinkel sieht nach vorne, hinten, oben, unten, links und rechts Texturen aus Media-Ordner der DirectX SDK March 2008 Microsoft Corp. Thorsten Grosch

46 Environment Mapping Simulation von Objekten, die deren Umgebung reflektieren Gespiegelten oder gebrochenen Strahl als look-up in die Cube Map benutzen i r n r r r Vertex Shader r = reflect(i, n); Fragment Shader envcolor = texturecube(envmap,r); t Cube Map Thorsten Grosch

47 Environment Mapping - Ergebnisse r = reflect(i, n) ersetzt durch r = refract(i, n, 1.1) Thorsten Grosch

48 Multiple Render Targets (MRTs) Render Target Speicher, in den die Ausgabe des Fragment Shaders geschrieben wird (ähnlich dem Frame Buffer) Verschiedene Render Targets können gleichzeitig g als Ausgabe des Fragment Shaders gebunden werden Geometrie muß nur einmal durch die Pipeline Ermöglichen die Ausgabe verschiedener Informationen in einem Schritt Fragment Program Normale Render Target 1 Render Target 2 Render Target 3 Thorsten Grosch Deep Fram ebuffe r

49 Multiple Render Targets // MRT FBO for position/normal/color glgenframebuffersext (1, &mrtfb); glbindframebufferext (GL_FRAMEBUFFER_EXT, mrtfb); glframebuffertexture2dext (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, viewerpositiontextureid, 0); glframebuffertexture2dext (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, viewernormaltextureid, 0); glframebuffertexture2dext (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT2_EXT, GL_TEXTURE_2D, viewercolortextureid, 0); glframebuffertexture2dext (GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, depthtextureid, 0); GLenum buffers[3] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT}; gldrawbuffers(3, buffers); glbindframebufferext (GL_FRAMEBUFFER_EXT, 0); Reihenfolge der Buffer Thorsten Grosch

50 Multiple Render Targets // MRT Vertex Shader // MRT Fragment Shader varying vec4 position; varying vec4 position; varying vec3 normal; varying vec3 normal; varying vec4 color; varying vec4 color; void main() { position = gl_vertex; normal = gl_normal; color = gl_color; } gl_position = ftransform(); void main() { gl_fragdata[0] = position; gl_fragdata[1] = vec4(normal, 0.0); gl_fragdata[2] = color; } Thorsten Grosch

51 Literatur OpenGL Shading Language (2nd Edition) Rost et al., Addison-Wesley, 2006 Quick Reference df Tutorials, z.b. Was man sonst noch mit der GPU anstellen kann (General Purpose GPU) Lineare Algebra, Voxelisierung, Physik Simulation, Partikel, Thorsten Grosch

52 GLSL Funktionalität nutzbar machen GLSL ab OpenGL 2.0 verfügbar GLSL auch als OpenGL Extension verfügbar Damit es auch auf älteren Karten (hoffentlich) läuft Extension mit Hilfe von GLEW (OpenGL Extension Wrangler) nutzbar machen Einfach, bequem und plattformunabhängig Ablauf 1. GLEW includen (vor GLUT!) 2. GLUT initialisieren und Fenster anlegen 3. GLEW initialisieren 4. OpenGL 2.0 Support abfragen 5. Siehe ShaderFramework in der Übung! Thorsten Grosch

53 GLEW installieren - Visual Studio GLEW von laden 2. Binaries Version für Windows wählen 3. GLEW entpacken 4. Datei GLEW\bin\glew32.dll nach C:\Windows\System32 kopieren 5. Datei GLEW\lib\glew32.lib nach C:\Programme\Microsoft Visual Studio 8\VC\PlatformSDK\Lib 6. Dateien GLEW\include\GL\{glew.h wglew.h} g nach C:\Programme\Microsoft Visual Studio 8\VC\PlatformSDK\Include\GL Thorsten Grosch

54 GLEW installieren - Visual Studio GLEW von laden 2. Binaries Version für Windows wählen 3. GLEW entpacken 4. Datei GLEW\bin\glew32.dll nach C:\Windows\System32 kopieren 5. Datei GLEW\lib\glew32.lib nach C:\Program Files\Microsoft SDKs\Windows\v6.0A\Lib kopieren 6. Dateien GLEW\include\GL\{glew.h wglew.h} nach C:\Program Files\Microsoft SDKs\Windows\v6.0A\Include\GL kopieren Thorsten Grosch

55 GLEW Libs - Visual Studio 2005 & Projekt Eigenschaften 2. Konfiguration auf Alle Konfigurationen stellen 3. Konfigurationseigenschaften Linker Eingabe Zusätzliche Abhängigkeiten: glew32.lib eintragen Debugger für GLSL: glsldevil, Uni Stuttgart Thorsten Grosch