számítógépes grafika

Számítógépes Grafika

OpenGL 4 shaderek, GLSL

OpenGL 4

A következő programozható fázisok vannak a 4.x-es OpenGL-ben: Vertex shader Tesselation control shader Tesselation evaluation shader Geometry shader Fragment shader

OpenGL 4 pipeline

Vertex és pixel shader

Vertex shader

A vertex shader programunkban végezzük el a bejövő geometria csúcspontjainak transzformációját

glDrawArrays/glDrawElements hívásban hivatkozott csúcspontok lesznek a bemenetei

A vertex shader bemeneti változóihoz (in módosító) a hozzárendelést a programból csináljuk

A csúcspontbeli attribútumoknál ritkábban változó bemenetet uniform változókon keresztül adhatjuk át (uniform = a kirajzolás hívás idejére konstans)

Vertex shader

A bejövő csúcspont koordinátáit clip space-be ( -1 <= x,y,z <= 1) kell transzformálni és a beépített gl_Position változónak átadni – ezt a pipeline nem programozható részeinek is kell gl_Position =

gl_MVPMatrix * bejövő_vertex_pos4 Ezen kívül azt csinálunk „amit akarunk” (minden out-tal megjelölt változónak adhatunk értéket és továbbküldhetjük a következő programozható fázisnak)

Vertex shader

A következő beépített kimeneti változók írhatóak a vertex shaderből:

vec4 gl_Position: a transzformált homogén koordinátái a bejövő vertex-nek. Ebbe írnia kell a VS-nek.

float gl_PointSize: a kirajzolandó pont mérete pixelben (point sprite-okhoz). Opcionális.

vec4 gl_ClipVertex: felhasználói vágósíkokhoz. Opcionális.

És ezeken kívül minden, amit mi is felveszünk...

Fragment shader

vec4 gl_FragColor: a fragment színe, de ha nem írun bele viszont van kimeneti vec4, az lesz ez vec4 glFragData[gl_MaxDrawBuffers]: ha több color attachment-je van az aktív FBO-nak, akkor ezen keresztül írhatunk rájuk float gl_FragDepth: fragment mélységi értéke (ha módosítanánk, mint a raycasterben) vec4 gl_FragCoord: csak olvasható, a fragment homogén koordinátái (4. koord 1/w) bool gl_FrontFacing: előrefelé néz-e a fragment lapja

Vertex shader

#version 400

in vec3 VertexPosition;

in vec3 VertexColor;

out vec3 Color;

void main()

{

Color = VertexColor;

gl_Position = vec4(VertexPosition,1.0);

}

Fragment shader

#version 400

in vec3 Color;

out vec4 FragColor;

void main()

{

FragColor = vec4(Color, 1.0);

}

Program-shader megfeleltetések

Vertex attribútumok és a shader bemeneti változóinak összerendelés:

glBindAttribLocation(programHandle, // shader prog0, // index"VertexPosition"); // sh-s nev

glBindAttribLocation(programHandle, 1, "VertexColor");


glGenVertexArrays( 1, &vaoHandle );

glBindVertexArray(vaoHandle);

glEnableVertexAttribArray(0); // Vertex position

glEnableVertexAttribArray(1); // Vertex color

glBindBuffer(GL_ARRAY_BUFFER, positionBufferHandle);

glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 0, (GLubyte *)NULL );

glBindBuffer(GL_ARRAY_BUFFER, colorBufferHandle);

glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, 0, (GLubyte *)NULL );


Lényegében tehát általános, indexekkel azonosított csatornákon keresztül megy az információátadás

A csatornák száma a GL_MAX_VERTEX_ATTRIBS segítségével kérhetőek le

Layout

A shader oldalon is megcsinálhatjuk a bejövő csatornák „index-esítését”, és nem kell bind-olni az attrib location-öket:

layout (location = 0) in vec3 VertexPosition;

layout (location = 1) in vec3 VertexColor;

Ezt a kimeneti változóknál is lehet használni:layout (location = 0) out vec4 FragColor;

Uniform változók

A shaderen belül read-only-k (konstansok), de kezdeti értéket kaphatnak uniform mat4 MVP

Típusok:, n = 2,3,4 mat<n>: n x n-es mátrix vec<n>: n dim vektor

Uniform változók

Először meg kell tudnunk az OpenGL-es azonosítóját a uniform változónak: GLuint mvpInShader = glGetUniformLocation(programHandle, "MVP");

Ezután már típusának megfelelő fv-vel értéket adhatunk neki: GlUniformMatrix4fv(

mvpInShader, 1, GL_FALSE, &app_mvp[0][0]);

Többiek: http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml

http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml

http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml

Uniform változók

Alaptípusok tömbjét is megjelölhetünk uniform-ként

Ekkor pl. egy mátrixtömb konkrét indexen lévő mátrixának azonosítóját megkapjuk így:

GLuint location = glGetUniformLocation( programHandle, "MyArray[1]" );

Uniform block

Több shader változó használhatja a program szempontjából ugyanazon uniform változókat

Ezeket mégis külön-külön kellene feltöltenünk stb., mert ugyanannak a uniform változónak más lesz a címe a különböző shader programokban

A uniform block segítségével ezen segíthetünk (csak használjunk shared layout-ot)

Uniform block – a shaderben

uniform BlobSettings

{vec4 InnerColor;

vec4 OuterColor;

float RadiusInner;

float RadiusOuter;

};

Uniform block

A uniform változók adatait tartalmazó puffer objektum a uniform buffer object

A változókra hivatkozásnál elég az adattag nevét írni, nem kell prefixelni az UBO nevével (tehát pl. elég az InnerColor, nem kell BlobSettings.InnerColor)

Uniform block

GLuint blockIndex = glGetUniformBlockIndex( programHandle, "BlobSettings");

GLint blockSize;

glGetActiveUniformBlockiv( programHandle, blockIndex,GL_UNIFORM_BLOCK_DATA_SIZE, &blockSize);

GLubyte * blockBuffer= (GLubyte *)malloc(blockSize);

Uniform block

const GLchar *names[] = { "InnerColor", "OuterColor",

"RadiusInner", "RadiusOuter" };

GLuint indices[4];

glGetUniformIndices(programHandle, 4, names, indices);

GLint offset[4];

glGetActiveUniformsiv(programHandle, 4, indices,GL_UNIFORM_OFFSET, offset);

Uniform block

GLfloat outerColor[] = {0.0f, 0.0f, 0.0f, 0.0f};

GLfloat innerColor[] = {1.0f, 1.0f, 0.75f, 1.0f};

GLfloat innerRadius = 0.25f, outerRadius = 0.45f;

memcpy(blockBuffer + offset[0], innerColor, 4 * sizeof(GLfloat));

memcpy(blockBuffer + offset[1], outerColor, 4 * sizeof(GLfloat));

memcpy(blockBuffer + offset[2], &innerRadius, sizeof(GLfloat));

memcpy(blockBuffer + offset[3], &outerRadius, sizeof(GLfloat));

Uniform block

GLuint uboHandle;

glGenBuffers( 1, &uboHandle );

glBindBuffer( GL_UNIFORM_BUFFER,uboHandle );

glBufferData( GL_UNIFORM_BUFFER, blockSize,blockBuffer, GL_DYNAMIC_DRAW );

glBindBufferBase( GL_UNIFORM_BUFFER, blockIndex, uboHandle );

Fragment shader

#version 400

in vec3 Color;

out vec4 FragColor;

void main()

{

FragColor = vec4(Color, 1.0);

}

Az összes shader

Az összes shader

Az összes shader opcionális, pass-through-ként működnek ha nincs saját hozzárendelve

Ha van akár geometry, akár tesszelációs shader, akkor kell legyen vertex shader is

Geometry shader

Meglévő geometria módosítására, törlésére, bővítésére

Bemenete a transzformált vertexekből képezett primitívekből áll

Kimenete 0, 1, vagy több primitív A kimenő primitív típus különbözhet a bejövőtől! De csak egyféle típusú lehet a kimenet

Geometry shader

Minden primitívre egyszer fut le A primitív összes csúcspontját eléri, a

csúcspontokban tárolt összes információval együtt

Lehet akár culling-ot is csinálni benne

Geometry shader

EmitVertex: ha kész vagyunk a primitív egyik csúcspontjához tartozó attribútumok kitöltésével, ezzel az utasítással adhatjuk tovább a pipeline-nak Ha nincs EmitVertex, akkor implicit eldobódik

csúcspont EmitPrimitive: ha elkészült a primitív összes

csúcspontja, akkor EmitPrimitive-vel tudjuk visszadobni a pipeline-ba Ha nincs EmitPrimitive, akkor a GS lefutásakor

implicit hívódik egy

Tesszellációs shader

Ha aktiválva van, akkor csak egyetlen rajzolási primitívünk van: GL_PATCHES

A patch primitív tetszőleges geometriai és egyéb információk halmaza, ami alapján a tesszelációs shader az inkrementális képszintézisnek megfelelő primitíveket hoz létre

Maximális „csúcsok” száma egy patch-ben: GL_MAX_PATCH_VERTICES


A kirajzolandó patch-adathalmaz csúcspontjainak száma: glPatchParameteri(

GL_PATCH_VERTICES, num); Például Bézier kontrollpontok száma


A patch primitívet nem rajzoljuk ki, a tesselation control és tesselation evaluator számára szolgáltat adatokat

A tényleges pipeline-ba bekerülő primitíveket a tesselation primitive generator állítja elő (ez a TCS és TES között van a pipelineban)

TCS

A TPG-t konfigurálja, hogy az miképp készítsen primitíveket (mennyit és melyik beépített algoritmussal)

Ezen kívül per-vertex kimeneti attribútumokat állíthat elő

TES

A TPG által létrehozott primitívek minden egyes (paramétertérbeli) csúcspontjára meghívódik

Lényegében: a görbe- vagy felületséma kiértékelése a feladata

Fő feladat: a pozíció meghatározása

Geometry shader példa

Geometry shader - bemenet

• A következő típusú bemenetek lehetnek:

points (1)

lines (2)

lines_adjacency (4)

triangles (3)

triangles_adjacency (6)

Primitívenként 1, 2, 4, 3, 6 csúcspontokkal


A szomszédossági adatos primitívek OpenGL kliens oldali kódjában a következők:

GL_LINES_ADJACENCY

GL_LINE_STRIP_ADJACENCY

GL_TRIANGLES_ADJACENCY

GL_TRIANGLE_STRIP_ADJECENCY


A többi primitív típusból pedig a pipeline csinálja meg a GS bemenetet

Ami tehát mindig 1 primitívből áll, amihez tartozhat szomszédossági információ is

Hogyan kapja ezt meg?

Geometry shader – bemenet, kimenet

számítógépes grafika

Documents