slide1 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
GPU PowerPoint Presentation
Download Presentation
GPU

Loading in 2 Seconds...

play fullscreen
1 / 43

GPU - PowerPoint PPT Presentation


  • 161 Views
  • Uploaded on

GPU. Szirmay-Kalos László. GPU. Vertex Shader. Fragment Shader. CPU. Interfész. cs úcspont. Transzformáció+ Illumináció. Geometry Shader. primitív. Vágás + Viewport transzf . + Raszterizáció + interpoláció. Textúrázás. Textúra memória. fragmens.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'GPU' - phil


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide1

GPU

Szirmay-Kalos László

slide2

GPU

Vertex

Shader

Fragment

Shader

CPU

Interfész

csúcspont

Transzformáció+

Illumináció

Geometry

Shader

primitív

Vágás + Viewport transzf. + Raszterizáció+ interpoláció

Textúrázás

Textúra

memória

fragmens

Kompozitálás (mélység, átlátszóság)

Bufferek: szín, z, …

pixel

slide3

Vertex shader és környezete

glBegin(GL_TRIANGLES)

glVertex

glNormal

glColor

glTextCoord

CPU

glEnd( )

GPU

POSITION, NORMAL, COLOR0, TEXTCOORD0,…

Állapot

Transzformációk

Fényforrások

Anyagok

*MV

*MVIT

Vertex shader

*MVP

Illumináció

POSITION, COLOR0, TEXTCOORD0,… háromszögre

Geometry shader

Vágás: -w<X<w, -w<Y<w, -w<Z<w

Homogén osztás: X=X/w, Y=Y/w, Z=Z/w

+ viewport transzformáció

slide4

“Standard” vertex shader (Cg, Shader Model 3.0)

void main(

infloat4position : POSITION,

in float3 normal : NORMAL,

in float4 color : COLOR0,

in float2 texcoord : TEXCOORD0,

uniform float4x4 modelviewproj : state.matrix.mvp,

out float4 hposition : POSITION,

out float4 ocolor : COLOR0,

out float2 otexcoord : TEXCOORD0)

{

hposition = mul(modelviewproj, position);

otexcoord = texcoord;

ocolor = color;

}

Változó

bemenet

Uniform

Változó

kimenet

glDisable(GL_LIGHTING );

Mezők elérése:

v.x, v.y, v.z, v.w, v.xy, v.wxx

c.r, c.rgb, c.ar, …

slide5

glEnable(GL_LIGHTING );

main( in float4 position : POSITION,

in float4normal: NORMAL,

uniform float4x4 modelview,modelviewIT,modelviewproj,

uniform float4 lightpos, Idiff, Iamb, Ispec,

uniform float4 em, ka, kd, ks, 

uniform float shininess,

out float4 hposition: POSITION,

out float4 ocolor : COLOR0

) {

hposition = mul(modelviewproj, position);

float3 N = mul(modelviewIT, normal).xyz;

N = normalize(N); // glEnable(GL_NORMALIZE)

float3 cpos = mul(modelview, position).xyz;

float3 L = normalize(lightpos – cpos);

float costheta = dot(N, L); if (costheta < 0) costheta = 0;

float3 V = normalize(-cpos);

float3 H = normalize(L + V);

float cosdelta = dot(N, H); if (cosdelta < 0) cosdelta = 0;

ocolor = em + Iamb * ka + Idiff * kd * costheta +

Ispec * ks * pow(cosdelta, shininess);

}

L

N

V

slide6

Pixel shader és környezete

POSITION, COLOR0, TEXTCOORD0,…háromszög csúcsokra

Háromszög kitöltés és interpoláció

POSITION, COLOR0, TEXTCOORD0,… pixelekre

Állapot

Textúra azonosító és paraméterek

Fragment shader

Textúrázás

POSITION, COLOR

Textúra memória

Kompozitálás: blending, z-bufferelés

Rasztertár (szín, mélység, …)

slide7

“Standard” pixel shader

void main( in float4 color : COLOR0,

out float4 ocolor : COLOR)

{

ocolor = color;

}

void main(in float2 texcoord : TEXCOORD0,

in float3 color: COLOR0,

uniform sampler2D texture_map,

out float4 ocolor : COLOR )

{

ocolor = tex2D(texture_map, texcoord);

}

glDisable(GL_TEXTURE_2D);

*color;

glEnable(GL_TEXTURE_2D);

glTexEnvi(GL_TEXTURE_ENV,

GL_TEXTURE_ENV_MODE, GL_MODULATE);

glEnable(GL_TEXTURE_2D);

glTexEnvi(GL_TEXTURE_ENV,

GL_TEXTURE_ENV_MODE, GL_REPLACE);

slide8

Gouraud

Phong

Phong

Gouraudhelyett Phong árnyalásPer-vertex helyett per-pixel árnyalás

Gouraud

slide9

Gouraud (per-vertex) árnyalás

CPU

program

Illumináció

Raszterizáció

interpoláció

Pixel

shader

Vertex shader

pozíció

normálvektor

Transzformációk

Anyagok

Fényforrások

Interpolált

szín

Transzf. poz.

szín

slide10

Phong (per-pixel) árnyalás

CPU

program

Illumináció

Raszterizáció

interpoláció

Pixel

shader

Vertex shader

pozíció

normálvektor

Transzformációk

Fényforrás poz.

Interpolált

N,V,L

Transzf. poz.

N=Transzf.normál

V=Nézeti irány

L=Fény irány

Anyagok

Fény intenzitás

slide11

Programok (lábbal hajtós megoldás)

  • .cpp CPU program:
    • Shader environment létrehozás
    • GPU képesség beállítás (profile)
    • Vertex/fragment programbetöltés és fordítás: CREATE
    • Vertex/fragment program átadás a GPU-nak: LOAD
    • Vertex/fragment program kiválasztás: BIND
    • Uniform vertex/fragment input változó létrehozás
    • Uniform vertex/fragment változó értékadás
    • Változó input változó értékadás (glVertex, glColor, glTexCoord)
  • .cg vertex program
    • Fragment program változó input változó + homogén pozíció
  • .cg fragment program
    • Szín kimenet

Inicializálás

Display

slide12

CPU program - Inicializálás

#include <Cg/cgGL.h> // Cg függvények

CGparameter Lightpos, Shine, Ks, Kd; // uniform paraméterek a CPU-n

int main( ) {

CGcontext shaderContext = cgCreateContext();// árnyaló kontextus

CGprofile vertexProf = cgGLGetLatestProfile(CG_GL_VERTEX);

cgGLEnableProfile(vertexProf);

CGprogram vertexProgram = cgCreateProgramFromFile(

shaderContext,

CG_SOURCE, “vertex.cg",

vertexProf,NULL, NULL);

cgGLLoadProgram(vertexProgram);// GPU-ra töltés

cgGLBindProgram(vertexProgram);// ez legyen a futó program

// vertex program uniform paraméterek. CPU-n Lightpos; GPU-n clightpos

Lightpos = cgGetNamedParameter(VertexProgram, “clightpos");

Vertex shader betöltés

slide13

Fragmens árnyaló betöltés

CGprofile fragmentProf=cgGLGetLatestProfile(CG_GL_FRAGMENT);

cgGLEnableProfile(fragmentProf);

CGprogram fragmentProgram = cgCreateProgramFromFile(

shaderContext,

CG_SOURCE,“fragment.cg",

fragmentProf, NULL, NULL);

cgGLLoadProgram(fragmentProgram);// GPU-ra töltés

cgGLBindProgram(fragmentProgram);// ez a program fusson

// fragmens program uniform paraméterek

Shine = cgGetNamedParameter(fragmentProgram, "shininess");

Kd = cgGetNamedParameter(fragmentProgram, "kd");

Ks = cgGetNamedParameter(fragmentProgram, "ks");

… OpenGL inicializálás

slide14

CPU program - OpenGL display

void Display( ) {

// állapot (implicit uniform) paraméterek beállítása

glLoadIdentity();

gluLookAt(0, 0, -10, 0, 0, 0, 0, 1, 0);

glRotatef(angle, 0, 1, 0);

// explicit uniform paraméterek beállítása

cgGLSetParameter3f(Lightpos, 10, 20,30); // clightpos

cgGLSetParameter1f(Shine, 40); // shininess

cgGLSetParameter3f(Kd, 1, 0.8, 0.2); // kd

cgGLSetParameter3f(Ks, 2, 2, 2); // ks

// változó paraméterek, a PASS

glBegin( GL_TRIANGLES );

for( … ) {

glNormal3f(nx, ny, nz);// NORMAL regiszter

glVertex3f(x, y, z);// POSITION regiszter + trigger

}

glEnd();

}

slide15

Phong árnyalás: vertex shader

void main(

in float4 position : POSITION;

in float4 normal : NORMAL;

uniform float4x4 MVP: state.matrix.mvp,

uniform float4x4 MV: state.matrix.modelview,

uniform float4x4 MVIT : state.matrix.modelview.invtrans,

uniform float3 clightpos, // fényforrás poz. kamerak-ban

out float4 hposition : POSITION;

out float3 cnormal : TEXCOORD0;

out float3 cview : TEXCOORD1;

out float3 clight : TEXCOORD2;

)

{

hposition = mul(MVP, position);

float3 cpos = mul(MV, position).xyz;

cnormal = mul(MVIT, normal).xyz;

clight = clightpos - cpos;

cview = -cpos;

}

L

N

V

slide16

Phong árnyalás: fragment shader

void main( in float3 N : TEXCOORD0,

in float3 V : TEXCOORD1,

in float3 L : TEXCOORD2,

uniform float shininess,

uniform float3 kd,

uniform float3 ks,

out float3 ocolor: COLOR )

{

N = normalize( N );

V = normalize( V );

L = normalize( L );

float3 H = normalize(V + L);

ocolor =kd * max(dot(N, L), 0) +

ks * pow(max(dot(N,H), 0), shininess);

}

L

N

V

slide17
NPR

void main( in float3 N : TEXCOORD0,

in float3 V : TEXCOORD1,

in float3 L : TEXCOORD2,

uniform float3 kd,

out float3 ocolor: COLOR )

{

N = normalize( N );

V = normalize( V );

L = normalize( L );

float costheta = dot(N, L);

float y = (costheta >= 0) ?0.5f : 0.2f;

if (abs(dot(N, V)) < 0.1) ocolor = float3(0, 0, 0);

else ocolor = y * kd;

}

rny k t rk pek

Tl

Tv

Y

1. pass:

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

gluLookAt(lightx, lighty, lightz,

lookatx, lookaty, lookatz,

lupx, lupy, lupz);

Modellezési transzformáció

Képszintézis

Z-buffer -> textúra másolás (v. közv)

2. pass:

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

gluLookAt(eyex, eyey, eyez,

lookatx, lookaty, lookatz,

upx, upy, upz);

Modellezési transzformáció

Képszintézis + árnyék teszt

Árnyék térképek

Z

X

slide19

Képszintézis+árnyékteszt

DepthMap id

Pixel

shader

CPU

program

Vertex shader

Raszterizáció

Interpoláció

Pozíció

Szín

MVP, LMVP

transzformációk

Transzf. Poz.

Szem norm. képernyő

Fény norm. képernyő

Szín

DepthMap

texelek

slide20

Vertexshader

void main(in float4 position : POSITION,

in float4 color : COLOR0,

uniform float4x4 MVP,

uniform float4x4 LMVP,

out float4 hPosition : POSITION,

out float4 lPosition : TEXCOORD0,

out float4 ocolor : COLOR0) {

ocolor = color;

// model-space -> to light's (depth map's) clipping space

lPosition = mul(LMVP, position);

// model-space to eye's clipping space

hPosition = mul(MVP, position);

}

Vertex

Shader

hposition

lposition

position

slide21

1,1

Y

Y

X

X

Fragmentshader

Z

fragment

shader

Pixel

color

-1,-1

0, 0

void main(in float4lPosition : TEXCOORD0,

in float4 color : COLOR0,

uniform sampler2DdepthMap,

uniform float bias,

out float4 ocolor: COLOR )

{

float3 lPosCartesian = lPosition.xyz/lPosition.w;

float2 texcoord;

texcoord.x = (lPosCartesian.x + 1)/2;

texcoord.y = (lPosCartesian.y + 1)/2;

float this_depth = (lPosCartesian.z + 1)/2 - bias;

float stored_depth = tex2D(depthMap, texcoord);

bool vis = (this_depth <= stored_depth); // == kéne

ocolor = vis * color;

}

lposition

Clipping

space to

Texture

space

projekt v text r z s m trixa
Projektív textúrázás mátrixa

float3 lPosCartesian = lPosition.xyz/lPosition.w;

texcoord.x = (lPosCartesian.x + 1)/2;

texcoord.y = (-lPosCartesian.y + 1)/2;

float this_depth = (lPosCartesian.z + 1)/2 - bias;

Model

Light’s

camera

Light’s

perspective

½ 0 0 0

0 ½ 0 0

00 ½ 0

½½½-b1

X,Y,Z,1

slide23

Egyszerűbbárnyékteszt

voidSM_VS (in float4 position : POSITION,

in float4 color : COLOR0,

uniform float4x4 MVP,

uniform float4x4 LMVPT,

out float4 hPosition : POSITION,

out float4depthPos : TEXCOORD0,

out float4 ocolor : COLOR0) {

ocolor = color;

depthPos = mul(LMVPT, position);

hPosition = mul(MVP, position);

}

voidSM_FS (in float4 lPosition : TEXCOORD0,

in float4 color : COLOR0,

uniform sampler2DdepthMap,

out float4 ocolor: COLOR ){

ocolor = color * tex2Dproj(depthMap, lPosition);

}

Returns 0/1

If it is a depth texture

slide25

Classic shadow map

Variance shadow map

visszaver d s t r s sz m t s
Visszaverődés/törés számítás

Environment map id

Pixel

shader

CPU

program

Raszterizáció

Interpoláció

Vertex shader

Pozíció

Normál

Transzformációk

törésmutató

Transzf. Poz.

Világ normál

Világ nézet

Interpolált

normál

nézeti irány

Env.Map

texelek

slide28

Vertex shader

void main(in float4 position : POSITION,

in float4 normal : NORMAL,

uniform float4x4 MVP, // modelviewproj

uniform float4x4 M, // model

uniform float4x4 MIT, // IT of model

uniform float3eye, // eye in world

out float4 hPos : POSITION,

out float3 V: TEXCOORD0,// view in world

out float3 N: TEXCOORD1 // normal in world

)

{

hPos = mul(MVP, position);

float3 x = mul(M, position).xyz; // transform to world sp.

V = eye - x;

N = mul(MIT, normal).xyz;

}

slide29

Fragment shader

void main( in float3 V : TEXCOORD0,

in float3 N : TEXCOORD1,

uniform float n, // IOR

uniform samplerCUBE envMap,

out float3 color )

{

V = normalize(V);

N = normalize(N);

float3 T = refract(V, N, 1/n);

float3 R= reflect(V, N);

float3 refractedRad = texCUBE(envMap, T).rgb;

float3 reflectedRad = texCUBE(envMap, R).rgb;

float F0=(n-1)*(n-1)/(n+1)/(n+1);

float F=F0 + (1-F0) * pow(1-dot(N,V), 5);

color = F * reflectedRad + (1 – F) * refractedRad;

}

geometria rnyal
Geometria árnyaló

Procedurális

geometria

Catmull-Clark

subdivision

slide36

GPGPU

Az eredménytömb mely

elemeit számítjuk ki

Geometria:

„háromszögek”

Eredmény

tömb

Bemeneti

adat

Kimeneti kép

Képszintézis

Bemeneti kép

Textúra vagy

rasztertár

Textúrák

Minden kimeneti tömbelemre

ugyanaz az algoritmus,

más adatokra: SIMD

slide37

„Teljes képernyős” téglalap (CPU):

glViewport(0, 0, HRES, VRES)

glBegin(GL_QUADS);

glTexCoord2f(1,1); glVertex4f(-1,-1, 0, 1);

glTexCoord2f(1,0); glVertex4f(-1, 1, 0, 1);

glTexCoord2f(0,0); glVertex4f( 1, 1, 0, 1);

glTexCoord2f(0,1); glVertex4f( 1,-1, 0, 1);

glEnd( );

Vertex shader (Cg):

void main ( in float4 Pos : POSITION,

in float2 Tex : TEXCOORD0,

out float4 hPos : POSITION,

out float2 oTex : TEXCOORD0 ) {

hPos = Pos;

oTex = Tex;

}

Fragment shader (Cg):

voidmain ( in float2 Tex : TEXCOORD0 ,

uniform sampler2DbemAdat,

out float4 result : COLOR) {

result = Bemeneti képből számított adat a tex2D(bemAdat, f(Tex)) alapján;

}

Melyik

kimeneti

tömbelemet

számítjuk

Bemeneti

adat

Eredmény

tömb

slide38
CUDA

GPU

CPU +

Kernel program(ok):

Szálak

Szálblokk, szálblokk,

Nyüst, nyüst, …

Host

program

Szálblokk

Közös

gyors

memória

Közös

Utasítás

végrehajt

SIMD

slide39

Két N elemű vektor összeadása

GPU-n fut, CPU-ról hívható

__global__ void AddVectorGPU( float *C, float *A, float *B, int N ) {

int i = blockIdx.x*blockDim.x + threadIdx.x; // szálazonosító

if (i < N)

C[i] = A[i] + B[i];

}

float C[100000], A[100000], B[100000];

int main ( ) {

int N = 100000;

int blockDim = 256; // szálak száma egy blokkban: 128, 256, 512

int gridDim = (N + blockDim – 1) / blockDim; // szálblokkok száma

AddVectorGPU<<<gridDim, blockDim>>>(C, A, B, N);

}

0 ,…, gridDim.x-1

0 ,…, blockDim.x-1