V OpenGL sú textúry väčšinou obyčajné dvojrozmerné obrázky. Každá textúra sa potom nanáša na povrch trojuholníkov ako tapeta na stenu. Oproti tapete sa ale dá textúra pri mapovaní aj rôzne ponaťahovať. To ako sa má textúra nemapovať nám slúžia textúrovacie koordináty. V každom vrchole trojuholníka je potom určený súradnica bodu ktorý sa použije v danom vrchole.
Textúra pozostáva z jednotlivých pixelov. Obrázok má potom svoje rozmery v pixeloch. V OpenGL sa ale používa na adresovanie jednotlivých bodov obrázku súradnice v rozmedzí 0 až 1. Teda stred obrázka s rozmermi či už 256×256 pixelov alebo 1024×1024 je vždy na koordináte [0.5;0.5]. Ľavý dolný roh textúry má koordináty [0;0] pravý dollný [1;0] a pravý horný [1;1]. treba poznamenať že [0;0] je úplný roh textúry. Stred pixela leží na koordinátoch [0.5/w;0.5/h] kde w a h sú výška a šírka textúry. Na tento pol-pixelový posun treba pamätať ak chcete nakresliť na obrazovku niečo presne 1:1. Toto inak platí aj na obrazovku teda rohový pixel má taktiež súradnice v „clip space“ [-1+0.5/w;-1+0.5/h] kde w a h je výsška a šírka viewportu teda rozlíšenie obrazovky (viď glViewport()).
Na textúrovacie koordináty si teda vytvoríme ďalší buffer ktorý ich bude obsahovať. Do initGL() teda pridáme nasledujúce riadky.

texcoord = new GLbuffer;
float tex_coord[] = {0.0f, 0.0f,  1.0f, 0.0f,  0.0f, 1.0f,//texturovacie koordinaty
            0.0f, 1.0f,  1.0f, 0.0f,  1.0f, 1.0f};
texcoord->loadData(sizeof(tex_coord), tex_coord);
glEnableVertexAttribArray(2);//tretie pole na texturovacie koordinaty
        texcoord->bind();
        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, 0);
shader->bindAttribLocation(2, "in_texcoord");

Teda vytvoríme buffer, nahráme doňho dáta a nakoniec priradíme tretie vertex attrib pole k vstupu do vertex shaderu typu vec2.
Najprv treba vygenerovať meno textúry za pomoci jednej z ,mnohých glGen* funkcií glGenTextures(). Jej prvým parameterom je počet generovaných textúr a druhým je ukazovateľ na pole kam sa uložia vygenerované mená.

Texture::Texture(GLenum type, FILTERING filter)
{
    glGenTextures(1, &tex);//genreuje meno textury
    target = type;
    this->filter = filter;
}

Keď už textúru nepotrebujeme tak ju uvoľníme. Na to slúži ako ste už mohli uhádnuť glDeleteTextures(). Jej parametere sú rovnaké ako glGenTextures().

Texture::~Texture()
{
    glDeleteTextures(1, &tex);//uvolni texturu
}

Na to aby sme mohli použiť textúru pri vykresľovaní tak ju musíme priradiť do jednej z textúrovacých jednotiek. Takých jednotiek je dostupných v OpenGL 3 minimálne 48 a v OpenGL 4 až 80. V staršom OpenGL 2 bol tento limit nastavený len na 2 jednotky. Tento počet je ale súčet koľko je možné použiť vo všetkých stupňoch shaderov. Teda počet textúr ktoré sa použijú napr vo vertex a fragment shaderi nemože spolu presiahnuť tento počet. Malé upozornenie počet jednotiek vo vertex shaderi býva oproti fragment shader dosť obmendzené. I keď moderný HW podporujúci OpenGL 3.1 a novší musí podporovať 16 jednotiek pre každý typ shadera. Aj tá istá textúra použitá a priradená do tej istej textúrovacej jednotky vo vertex a fragment shader sa ale počíta ako dve použité jednotky.
Textúru môžeme priradiť podľa jej typu do rôzneho cieľa. Zatiaľ nám stačí že 1D textúry sa priraďujú do GL_TEXTURE_1D, dvoj rozmerné do GL_TEXTURE_2D a trojrozmerné do GL_TEXTURE_3D.

void Texture::bind(int unit)
{
    glActiveTexture(GL_TEXTURE0+unit);//urci ktoru texturovaciu jednotku ideme pouzit a ktora je aktivna
    glBindTexture(target, tex);//priradi texturu do aktivnej texturovacej jednotky
}

V loadTexture() ktorá má dokopy veľa parametrov. Prvým je interný formát dát ktoré má OpenGL použiť na uloženie dát. Medzi základné patrí GL_RGBA, GL_RGB, GL_RED, GL_RG, GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL.
Písmená sú odvodené od anglických názov základných farebných kanálov v obrázkoch.

• R – red – červená
• G – green – zelená
• B – blue – modrá
• A – alpha – alfa (prihľadnosť)

GL_DEPTH_COMPONENT je formát pre uloženie hĺbkových dát zo Z-buffera a GL_DEPTH_STENCIL je formát ktorý kombinuje hlbkové a dáta z stencil buffera do jedného. Okrem týchto základných formátov môžete presnejšie špecifikovať formát. Existujú aj varianty ktoré určia presný dátový typ ktorý sa má použiť. Je ich veľmi veľa preto uvedimlen zopár na ukážku. GL_RGBA8 môžete explicitne vyjadriť že chcete aby každý kanál obsahoval 8 bitov. Ďalej GL_RGBA32F aby sa farby uložili ako 32 bitové float čisla. Potom sú dostupné aj jedno, dvoj a troj kanálové varianty ktoré začínajú obsahujú len R, RG alebo RGB zložky.
Druhý až tretí parameter je jednoducho šírka, výška a hĺbka nahrávaného obrázka v pixeloch. Hĺbka sa používa ak sa nahráva aj 3D textúra ktorá je ako keby na sebe navrstvené 2D obrázky. Počet vrstiev potom určuje hĺbku. Piaty určuje formát nahrávaných dát. Tam može byť zase GL_RGB ale aj GL_BGR alebo GL_ABGR kedy sa proste určí poradie kanálov v dátach. Dátový typ dát určuje nasledujúci parameter. Možné hodnoty sú GL_BYTE, GL_SHORT, GL_INT, GL_HALF a GL_FLOAT plus pri celo číselných aj UNSIGNED varianty napr. GL_UNSIGNED_INT. Posledným parametrom je ukazateľ na samotné dáta. Ten môže byť aj NULL. Vtedy sa len alokuje pamäť pre textúru ale nekopírujú sa žiadne dáta. To je v určitých ideme do danej textúry kresliť za pomoci samotného OpenGL.

void Texture::loadTexture(GLint internal, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, void *data)
{
    glBindTexture(target, tex);//priradime texturu do texturovacej jednotky
    switch(target)//podla typu textury
    {
        case GL_TEXTURE_1D:glTexImage1D(target, 0, internal, width, 0, format, type, data);break;
        case GL_TEXTURE_2D:glTexImage2D(target, 0, internal, width, height, 0, format, type, data);break;
        case GL_TEXTURE_3D:glTexImage3D(target, 0, internal, width, height, depth, 0, format, type, data);break;
    }
    if(filter != NONE)glGenerateMipmap(target);//pouzijeme filtering preto treba vygenerovat mipmapy.
    setFiltering();//nastavy texturovacie filtry
}

Význam glBindTexture() už poznáte. Tie tri funkcie glTexImageND slúžia na nahratie samotných dát do OpenGL. Líšia sa jedine s počtom rozmerových parametrov kedy 1D varianta berie len šírku kým 3D šírku, výšku aj hĺbku. Druhý parameter určuje úroveň mipmapy ktorú chceme nahrať dáme nulu keďže nahrávame základnú úroveň. Potom ide interný formát nasledujú rozmery. Za nimi je hrúbka okraja. Zvyšné parametre sme si už vysvetlili. Ak sme sa rozhodli použiť filtráciu vtedy treba vygenerovať mipmapy. Mipmapy sú sada zmenšených verzii textúry vždy o polovicu. Teda ak má základná nultá úroveň rozmery 256×256 tak jednotková úroveň bude mat rozmery 128×128 dvojková 64×64 atď. Na to slúži ten druhý parameter funkcii glTexImage*() kedy môžete si ručne vytvoriť mipmapy a tie nahrať postupne so zvyšujúcou sa úrovňou. Toto necháme na OpenGL a glGenerateMipmap() sa o to postará.
setFiltering() nastavuje filtre ktoré sa použijú na textúru pri vykresľovaní. Nastavenie filtrov pozostáva z dvoch filtrov. Prvým je filter ktorý sa použije pri zväčšovaní a druhý je filter ktorý sa použije pri zmenšovaní.

void Texture::setFiltering()
{
    int mag,min;
    float aniso = 0;
    switch(filter)
    {
        case NONE:
        mag = min = GL_NEAREST; break;
        case BILINEAR:
        mag = GL_LINEAR;
        min = GL_LINEAR_MIPMAP_NEAREST; break;
        case TRILINEAR:
        case ANISO2:
        case ANISO4:
        case ANISO8:
        case ANISO16:
        mag = GL_LINEAR;
        min = GL_LINEAR_MIPMAP_LINEAR; break;
    }

Pre zväčšovanie sú možné len dve možnosti a to GL_NEREST a GL_LIENEAR. Prvá možnosť vyberie najbližší pixel a jeho hodnota sa použije ako výstupná vzorka. Pri GL_LINEAR sa zoberú štyry najbližšie pixely a medzi nimi sa lineárne interpoluje výsledná vzorka. Pri zmenšovaní je možností viac. Najprv je tu GL_NEAREST a GL_LINEAR ktoré majú rovnaký efekt ako pri zvečšovaní. Potom sú tu ešte varianty pridaním k predchádzajúcim dvom _MIPMAP_NEAREST alebo _MIPMAP_LINEAR. Týmto sa zapína použitie mipmapingu. Prvé slovo potom určuje filtrovanie v rámci jednej úrovne mipmap a slovo za MIPMAP potom či sa má interpolovať aj medzi mipmapami. Teda napríklad GL_LINEAR_MIPMAP_NEAREST vyberie najbližšiu vhodnú mipmapu a v nej lineárne interpoluje zo štyroch pixelov ako vzorku. GL_LINEAR_MIPMAP_LINEAR navyše vyberie druhú najvhodnejšiu mipmapu z nej taktiež vyfiltruje a medzi týmito vzorkami sa lineárne interpoluje.

    switch(filter)
    {
        case ANISO2: aniso = 2; break;
        case ANISO4: aniso = 4; break;
        case ANISO8: aniso = 8; break;
        case ANISO16: aniso = 16; break;
        default: break;
    }

Anizotropné filtrovanie zapína ešte aj vytváranie mipmap ktoré sú zmenšované naraz iba v jednej ose. Teda z textúry 256×256 vytvorí ešte aj 256×128, 256×64 atď. To zvyšuje kvalitu pri naklonených povrchoch kedy klasicky mipmaping textúry v diaľke rozmazáva. Úroveň anizotropného filtrovania určuje koľko úrovní mipmap sa vytvorí.

    glTexParameteri(target, GL_TEXTURE_MAG_FILTER, mag);//filter ktory sa pouzije pri zvetsovani textury
    glTexParameteri(target, GL_TEXTURE_MIN_FILTER, min);//filter ktory sa pouzije pri zmensovani textury
    if(aniso)glTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, aniso);//nastavy level anizotropneho filtrovania
}

Na nastavenie parametrov textúr slúžia sada funkcií glTexParameter*(). Prvý parameter určuje cieľ ktorého priradená textúra bude ovplyvnená. Druhý parameter určuje ktorú vlastnosť ideme nastavovať. No a posledný je samotná hodnota ktorú nastavujeme. Okrem použitých parametrov ešte spomeniem aj GL_TEXTURE_WRAP_[S T R]. Ako tretí parameter môže byť potom použitý GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER, GL_REPEAT a GL_MIRRORED_REPEAT. Súvisí to s opakovaním textúr ak textúrovacie koordináty prekročia hranicu 0 až 1. Na nasledujúcich obrázkoch je pre S súradnicu nastavené GL_REPEAT a pre T GL_MIRRORED_REPEAT. Na druhom je to kombináci GL_CLAMP_TO_EDGE a GL_CLAMP_TO_BORDER.

Nakoniec ešte do initGL() pridáme vytvorenie samotnej textúry. Môžete si skúsiť meniť typ filtrovania a pozorovať aký to ma vplyv na kvalitu. Na načítanie použijeme loadBMP(). Táto funkcia využíva SDL na načítanie BMP obrázka a potom ho otočí hore nohami. OpenGL totiž očakáva že pixely obrazu ktoré sú na [0,0] dorazia ako prvé. SDL ale má konvenciu že [0,0] je hore a nie dole. Následne sa textúra priradí do tetúrovacej jednotky nula a v shadery sa taktiež nastavý číslo tejto jednotky.

        texture = new Texture(GL_TEXTURE_2D, Texture::TRILINEAR);
        SDL_Surface *tex = loadBMP("cb.bmp");
        texture->loadTexture(GL_RGB, tex->w, tex->h, 0, GL_BGR, GL_UNSIGNED_BYTE, tex->pixels);
        texture->bind(0);
        shader->setUniform("texture", 0);
        SDL_FreeSurface(tex);

Vo vertex shadery podáme ďalšiu vstupnú attribute premennú in_texcoord ktorú potom v tele main() len jednoducho predáme ďalej do výstupnej premennej texcoord.

in vec2 in_texcoord;
texcoord = in_texcoord;

V fragment shadery vykonáme trochu viacej zmien. Prvou je pridanie uniform premennej typu sampler2D. Existuje samozrejme aj 1D a 3D varianta. V initGL() je potrebné nastaviť jej hodnotu na číslo textúrovacej jednotky v ktorej je priradená textúra. Pozor nie meno textúry, toto je dosť častý omyl. Typ sampler musí byť samozrejme kompatibilný s typom priradenej textúry (kompatibilný pretože je možné napr. priradiť 3D textúru ako sampler2DArray).
Potom je už len funkcia texture() ktorá vracia vec4 obsahujúci farebné zložky. Jej druhým parametrom je vec2 určujúci odkiaľ sa má zobrať vzorka. Pokiaľ je sampler typu 1D tak berie iba skalár teda float a keď je sampler 3D tak berie vec3.

uniform sampler2D texture;//sampler z ktoreho budeme ziskavat vzorky

in vec3 color;
in vec2 texcoord;

void main()
{
    gl_FragColor = texture(texture, texcoord); //ziskame vzorku z textury a tu nasledne pouzijeme
    //gl_FragColor = texture(texture, vec2(texcoord.s, texcoord.t+sin(texcoord.s*20.0)/20.0)); //mozete skusit odkomentovat
}

Zdrojové kódy: lekcia04

Ak sa pozriete na súradnice ktoré sme použili tak sú 0,9 až 0,95 a potom zaberali takmer celú obrazovku. To je pretože vaša obrazovka ako keby tvorí stenu jednotkovej kocky. Takej kocky ktorej jeden roh má súradnice [-1;-1;-1] a protiľahlý [1;1;1].

jednotková kocka

Predná stena tejto kocky predstavuje plátno na ktoré sa premieta všetko čo je vnútri tejto kocky. Preto bod so xy-súradnicami [1;1] sa vykreslí v hornom pravom rohu. Tretí určuje hĺbku bodu tá neovplyvňuje výslednú pozíciu na obrazovke ale zaleží na nej ak sa nejaké dva objekty budu prekrývať. Zadávať ale súradnice v rozmedzí [-1;1] ale nie je príliš praktické. Na manipuláciu s bodmi a trojuholníkmi nám v OpenGL slúžia transformácie. Tieto transformácie sú vyjadrené pomocou matíc http://sk.wikipedia.org/wiki/Matica_%28matematika%29 v skratke je to množina čísel usporiadané do tabuľky. V OpenGL je to väčšinou štyri krát štyri. Toto číslo voláme dimenziou matice. Maticou dokážeme vyjadriť projekciu z jedného priestoru do iného. Teda keď máme súradnice v nejakej súradnicovej sústave dokážeme získať súradnice v inej sústave. Sústava súradníc je klasická karteziánska sústava troch na seba kolmích osí na ktorých vyjadríme šírku výšku a hĺbku.

Vystrite ukazovák a palec aby ste dostali L. K tomu ešte vystrite prostredník aby bol kolmo na dlaň. Tým dostane provizórnu karteziánskú sústavu. Ak si teraz zoberiete nejaký bod pri vašej ruke tak si ho môžete vyjadriť hneď v troch priestoroch. Relatívne voči vašej ruke tomu sa v OpenGL hovorí „model space“ teda priestor modelu. Ďalší priestor je absolútny kde ako osi môžete zobrať roh miestnosti a z neho vybiehajúce kúty ako osi tomu sa hovorí „world space“ alebo priestor sveta. No a nakoniec tu je priestor relatívne voči vašemu oku. To je takzvaný „eye space“ alebo priestor oka teda ako je daný bod vľavo-vpravo hore-dolu alebo ďaleko voči oku.

So súradnicami v eye space sa následne vykonajú ešte dve operácie. Perspektívne delenie a transformácia na rozmery obrazovky. V OpenGL používajú homogénne súradnice. To znamená že okrem troch priestorových súradníc x,y,z sa pridáva ešte štvrtá w. Tá vetšinou nadobúda hodnotu 1,0 a občas 0,0. Ako sme si už povedali ak je vo vstupnom VBO definované menej zložiek ako je deklarovaných pre vstup vertex shader tak sa zvyšné zložky automaticky dopĺňajú kde x,y,z sú automaticky 0 a w 1.

Perspektívne delenie je potom vydelenie celého vektora w. Teda výsledný vektor bude x/w, y/w, z/w, w/w. Ako je vidno tak potom má w hodnotu 1. Súradnice x,y,z ktoré sú potom v rozsahu [-1;1] sú potom viditeľné.

Keď som popisoval transformáciu medzi jednotlivými súradnicovými sústavami na ktoré slúžia matice 4×4 tak pri týchto transformáciách sa nemení w. Tá sa zmení až pri poslednou projekčnou maticou. Tým sa dosiahne perspektíva teda zbiehanie rovnobežiek v jenom bode na obrazovke.

Ak máme súradne v rozsahu [-1;1] tak poslednou vecou ktorá sa urobý je na-mapovanie týchto rozmerov na fyzické rozmery obrazovky a pixely.

jednotková matica

Hore je zobrazená jednotková matica ktorá nemá žiadny účinok. V OpenGL sa matice zapisujú sprava doľava. Teda ak máme zapísané čo znamená že vektor v najprv transformujeme maticou M a následne P. Druhý priamočiarejší pohľad je vynásobiť matice P a M a nimi následne násobiť vektor. Násobenie matíc je totiž asociatívne teda že (A*B)*C = A*(B*C) (vektor je taktiež matica) ale pozor okrem určitých prípadov. Taktiež nie je možné násobiť akékoľvek matice. Ich rozmery musia byť KxM a NxK teda počet stĺpcov prvej matice musí byť rovnaký ako počet riadkov druhej. Výsledná matica bude potom NxM. V matematickej literatúre sa môžete stretnúť s opačným značením teda MxN znamená matica s M riadkami a N stĺpcami.

V programoh budeme využívať vlastnú triedu Matrix na prácu s maticami. Prvou o ktorej sipovieme je perspective() keďže na koniec initGL() pridáme tento kód.

        Matrix m; // vytvorime si jednu maticu
        m.perspective(50, (float)WIDTH/HEIGHT, 0.1, 100); //vytvorime maticu perspektivnej projekcie
        shader->setUniform("projection", m);//nastavime maticu do shaderu

Ako prvé si vytvoríme objekt matice. Štandardne obsahuje takáto matica jednotkovú maticu teda maticu ktorá ma diagonále jednotky a všade inde nuly. Ďalej sa zavolá metóda perspektive() ktorá vytvorí maticu perspektívnej projekcie. Táto matica nám zabezpečí premietanie 3D objektov na 2D plochu našej obrazovky rovnako ako premieta šošovka vo fotoaparáte svet pred ním na film. Prvým parameter určuje koľko stupňov na výšku uvidí naša kamera teda zorné pole. Druhým je pomer strán obrazu. A nakoniec je tu vzdialenosť k blízkej a vzdialenej orezávacej rovine. Všetko čo kamera uvidí bude musieť byť v zkosenom ihlane. To je ihlan ktorý ma odrezaný vrchol. Nakoniec obsah matice nastavíme do uniform premennej vertex shadery.

Do OpenGL teda matice ktoré si vypočítame dostaneme ako uniform premennú v shadery. Teda k vecx typom si ešte pridamé matMxN kde M a N môžu byť v rozmedzí 2 až 4. M označuje počet stĺpcov a N počet riadkov. Na nastavenie hodnoty týchto uniform nám potom slúžia funkcie glUniformMatrixMfv(int location, sizei count, bool transpose, const float *value) a glUniformMatrixMxNfv() kde M a N môžu byť zase 2 až 4. Funkcie ako ich názov napovedá k nastaveniu hodnoty zodpovedných typov matíc. Funkcie glUniformMatrixMfv() slúžia na nastavenie štvorcových matíc o rozmeroch M krát M. Ich parametre sú podobné ako pri prechádzajúcich funkciách. Prvý parameter je lokácia ktorú získame s pomocou glGetUniformLocation(). Nasleduje počet matíc ktoré nahrávame. Potom či sa má matica pred nahratím transponovať teda otočiť okolo diagonály, spomeňte si že OpenGL uchováva matice v stĺpcovom poradí takže tu môžete poslať maticu v riadkovom usporiadaní a potom dať tento parameter true. Nakoniec ukazovateľ na pole obsahujúce hodnoty prvkov matíc.
Na začiatok metódy draw() si dáme nasledovný kód.

        Matrix m;
        m.lookAt(0, 0, 4, 0, 0, 0);
        m.rotate(rott, 1, 0, 0);
        m.rotate(rott*1.74, 0, 1, 0);
        rott += 0.2;
        shader->setUniform("modelview", m);

Zase vytvoríme jednu maticu. Metódou lookAt() sa posunieme na pozíciu určenú prvými troma parametrami určujúcimi X,Y a Z súradnice v priestore. Nasledujúce tri parametre určujú bod kam sa bude kamera pozerať. V tomto prípade je to počiatok súradnicovej sústavy. A nakoniec sa dajú nastaviť posledné tri parametre ktoré majú implicitnú hodnotu [0;1;0]. Tieto čísla určujú smer nahor v tomto prípade v smere osi y. Kedže máme bod kam sa pozeráme a odkiaľ sa pozeráme chýba nám ešte orientácia okolo osi tvorenej týmito dvoma bodmi.
Nasleduje metóda rotate() ktorá otočí objekt. Jej prvým parametrom je uhol o ktorý sa má otočiť. Ďalšie tri parametre určujú vektor okolo ktorého sa bude otáčať. Tu môžete vidieť tri transformácie. Každá je reprezentovaná jednou maticou ktorá sa vytvorí pri volaní metód lookAt(),rotate() a aj perspective(). Každá takto vytvorená matica sa následne vynásobí s aktuálnou maticou a použije sa tá. Teda ak máme maticu M tak pri volaní metód sa vytvorí matica C. Vo výsledku potom matica M’ bude obsahovať M*C. Teda napr. v našom prípade sa najprv vytvorí jednotková matica E. Potom lookAt() vytvorí L a dve rotate() R a S. Vo výsledku vznikne matica M = E*L*R*S. Touto maticou sa budú následne transformovať vrcholy teda násobiť L*R*S*v (jednotkovú maticu môžeme ignorovať keďže je to rovnako ako keď vynásobíte 1*5). Ako si môžete všimnúť tak sa matice skladajú postupne po sebe a teda transformácia ktorú aplikujeme v kóde ako prvú sa vykoná ako posledná.
Na tieto transformácie sa dá aj nazerať ako na posúvanie sveta okolo vás. Teda na začiatku je kamera v bode [0;0;0] a pozerá smerom do mínus Z. Prvé lookAt() potom presunie počiatok súradnicovej sústavy na zadanú pozíciu. Nasledujúce rotate() otočí súradnicovú sústavu okolo osi X o daný počet stupňov. Smer otáčania je v smere hodinových ručičiek pri pohľade v smere vektora otáčania. Ako keby ste zakrúcali vývrtku a tá smeruje v osi vektora. Druhá rotácia otočí sústavu zase okolo osi Y. Tu treba spomenúť jednu veľmi dôležitú vec. Všetky tieto transformácie, rotácie a posuny sú vykonávané relatívne k danej súradnicovej osi. Teda prvé rotate() otáča okolo osi ktorá je vtedy už mimo. A ešte k tomu následné druhé rotate() okolo osi Y už otáča už okolo lokálnej osi Y ktorá je pootočená predchádzajúcou rotáciou. Teda keď robíte akúkoľvek transformáciu musíte myslieť relatívne a nie voči nejakému absolútnemu počiatku.
Náš vertex shader musíme teraz upraviť nasledovne.

uniform mat4 modelview; // uniform premenna na model view maticu
uniform mat4 projection; // uniform premenna na projekcnu maticu

in vec4 in_position; //prvy vstupny atribut pozicia vrchola
in vec3 in_color; //druhy atribut farba vrchola

out vec3 color; //vystup z shadera

void main()
{
	gl_Position = projection * (modelview * in_position); //stupny vertex nasobime najprv modelview a potom projection maticou
	color = in_color; //zapiseme farbu
}

Na začiatku pribudli dve uniform premenné. Maticu projection nastavujeme v initGL() a modelview pri každom volaní draw(). Možno ste si už všimli. Uniform premenné netreba nastavovať neustále. Celý program si pamätá všetky uniform premenné.
Nasleduje deklarácia per vertex premenných. V samotnom shadery sa zmenilo len to že teraz je vstupný vertex násobený obidvoma maticami. Tie zátvorky tam nie sú nutné ale je to optimalizácia pre rýchlosť. Inak by sa totiž najprv vynásobili tie dve matice a až potom vektor s maticou. A násobenie dvoch matíc je omnoho náročnejšie ako dve vynásobenia vektor matica.
Najpr sa teda aplikuje modelview matica ktorá nám dostane vertex do „eye space“ teda relatívne voči kamere. Teda súradnica X vyjadruje či je bod vľavo vpravo,Y hore dole a Z vpredu alebo vzadu. Projekčná matica nakoniec prevedie tieto súradnice do „clip space“ teda do jednotkovej kocky.
Odporúčam sa pohrať sa s dosadením vlastných hodnôt do funkcií rotate(), lookAt() a ešte translate(). Tú som síce nepoužil ale jej použitie je jednoduché. Jej tri parametre vyjadrujú posun po osiach X,Y,Z. Takže skúste si tam pridať aj m.translate(1, 0, 0).

lekcia03

• Vertex shader
• Tessellation control shader – core v OpenGL 4.0
• Tessellation evaluation shader – core v OpenGL 4.0
• Geometry shader – core v OpenGL 3.2
• Fragmet shader

Vstupom do tejto reťazcov ako som už povedal sú vrcholy. Výstupom sú fragmenty teda jednotlivé pixeli výsledného obrazu. Tieto shadery sa zlučujú do programov ktoré sa následne aktivujú. Jeden program môže obsahovať všetky typy shaderov alebo iba jeden vertex shader ktorý je povinný. Všetky ostatné sú nepovinné bude sa len kresliť všetko čierne. V dnešnej časti si vysvetlíme len vertex a fragment shader. Ostatné typy si necháme na inokedy.
Shadery sú krátke programčeky ktoré sa vykonávajú nad jedným vrcholom v prípade vertex shadera a nad jedným fragmentom v prípade fragment shaderov. Shader sa píše v GLSL (OpenGL Shading Language). Syntaxou je veľmi podobné klasickému C. Tak ako v C sú aj GLSL základné dátové typy float, int, uint, double. Okrem toho sú definované aj vektorové typy týchto typov. Vektor obsahujúci float su vec2, vec3 a vec4. Taktiež sú definované matice matN a matMxN kde N a M sú čísla 2,3 a 4. Matica je prakticky tabuľka čísel s N krát N čísel respéktíve M stĺpcov a N riadkov. Význam matíc vysvetlím v nasledujúcej časti. Ešte spomeniem ivec, uvec, bvec a dvec pre deklarovanie vektorov z typov int, uint, bool a double.
Shader sa dá rozdeliť na tri časti. Deklaráciu rozhrania, funkcie a nakoniec samotné telo shadera v main() funkcii.
Teraz si ukážeme jednoduchý vertex shader. Hneď na začiatku shadera treba deklarovať verziu GLSL ktorú použijeme. Jednotlivé verzie sú nasledovné.

• OpenGL 3.0 – 1.30
• OpenGL 3.1 – 1.40
• OpenGL 3.2 – 1.50
• OpenGL 3.3 – 3.00
• OpenGL 4.0 – 4.00

Takže v označení sa vynechá bodka a tým sa deklaruje použitá verzia. Dal som tam 1.30 aby sa to dalo spustiť aj na kartách čo podporujú len OpenGL 3.0 a oproti 4.00 nie je žiadny rozdiel. Nasleduje deklarácia rozhrania shadera. Rozhranie predstavujú premenné koré slúžia ako vstup výstup z shadera. Ako prvá je uniform float premenná. Uniform premenná zostáva nemenná pre všetky vrcholy počas kreslenia. Jej hodnota sa nastavuje v OpenGL pomocou glUniform{1,2,3,4}{ifd}().Teda je potrebné nastaviť všetky uniform pred volaním akéhokoľvek kreslenia. Štandardne sú nastavené všetky uniform premenné na nulu.
Premenné ktoré sú deklarované s kvalifikátorom in sú vstupné premenné do shaderu z predchádzajúcich stupňov a out sú zase výstupné premenné do ďalšieho stupňa.

#version 130 //verzia GLSL

uniform float mul; //uniform vstupn premenna

in vec4 in_position; //prvy vstupny atribut pozicia vrchola
in vec3 in_color; //druhy atribut farba vrchola

out vec3 color; //vystup z shadera

Najlepšie to ozrejmí obrázok.
Teraz už samotné telo shadera. To je rovnako ako v C funkcia main() ktorá nič nevracia je teda typu void a nemá žiadne parametre. Je to veľmi jednoduchý shader ktorý len prekopíruje vstupné hodnoty z vstupných premenných do výstupných. Jednou z pevne daných výstupných premenných je gl_Position ktorá je typu vec4. Je to kvôli nasledujúcim operáciám ktoré sa vykonávajú nad vrcholom ako je zostavenie primitíva, orez a následná rasterizácia.

void main()
{
	gl_Position = in_position; //gl_Postion je deklarovany ako
							//out vec4
	color = in_color; //zapiseme farbu
}

To bol vertex shader. Jeho výstupné premenné sú potom vstupom pre nasledujúci shader. V tomto prípade to bude fragment shader. Tieto výstupné sú potom interpolovaní naprieč celým primitívom. Ako si spomínate v prvej časti sme kreslili dva trojuholníky. V každom rohu mali inú farbu a medzi vrcholmi sa plynulo menilo z jednej farby do druhej. Táto interpolácia sa dá ovplyvniť pomocou pridania kľúčového slova pred deklaráciu vstupno/výstupnej premennej. Sú možné tri slová: smooth, flat, noperspective. Ak nie je uvedené žiadne berie je to rovnaké ako keby bolo uvedené smooth. To znamená peknú plynulú interpoláciu naprieč primitívom. Flat znamená žiadnu interpoláciu. To znamená že naprieč celým primitívom bude mať daná premenná hodnotu akú priradil posledný vrchol daného primitíva. Skúste si to sami a pridajte flat pred color v obidvoch shaderoch takto flat vec3 color. Noperspective podobne ako smooth interpoluje ale bez perspektívnej korekcie. Používa sa to ale iba málokedy.
Takže teraz si ukážeme jednoduchý fragment shader. Na začiatku je zase uvedená verzi GLSL. Nasleduje deklarácia vstupných premenných. V tomto prípade iba jedna a to farba. Potom je zase telo shadera a v ňom jediný riadok v ktorom zapíšeme výslednú farbu pixela. Tú treba zase zapísať do peven danej premennej gl_FragColor.

#version 130

in vec3 color;

void main()
{
    gl_FragColor = vec4(color, 0.0);
}

gl_FragColor je typu vec4 kde máme tri zložky farieb RGB (červená, zelená, modrá) a ešte A (alfu alebo aj priehľadnosť). Color sme ale deklarovali ako vec3 preto je potrebné doplniť štvrtú zložku ktorú dáme teraz nula.
S vektormi sa dajú robiť rôzne operácie. Môžete pristupovať k jednotlivým zložkám vektora pomocou bodky a písmenok (x, y, z, w), (r, g, b, a), (s, t, p, q) rovnako ako sa pristupuje k prvkom štruktúry v C. Dôvod prečo sa sú tri sady je ten že to súži ako pomôcka na rozlíšenie na čo daný vektor slúži. Pre súradnice v prisestore sa používa xyzw, pre vektor reprezentujúci farbu rgba a stpq sa používa pri vektoroch reprezentujúce textúrovacie koordináty.

color.a = color.r + color.g + color.b; // scitame vsetky farby
vec2 x;
x = color.xy; //dajú sa aj takto jednoducho kombinovať.
color.rz;//CHYBA nie je možné kombinovať xyzw, rgba, stpq medzi sebou

Ak chceme vytvoriť vektor a priradiť mu hodnotu treba na to použiť konštruktor.

vec4 a;
vec3 b;
vec2 c;
a = vec4(1.0);//všetky zložky budú rovné jednej
b = vec3(a);//štvrtá zložka sa zahodí
b = vec3(1.0, 2.0, 3.0);//b.x==1.0 b.y == 2.0 b.z == 3.0
a = vec4(1.0, b);
a = vec4(c, c);
b.w = 4.0;//CHYBA w je mimo rozsahu

Teraz ako vytvoriť shader v OpenGL. Spravíme si na to zase triedu ktorá bude zapuzdrovať prácu s shadermi. Najprv máme mená pre jednotlivé prvky tvoriace shader. Najprv sú to podobne ako v prípade GLbuffer mená pre program obsahujúci shadery a mená pre vertex a fragment shader. Nasleduje C++ reťazec do ktorého si budeme ukladať výstup kompilátoru. Shadery treba rovnako ako C++ program preloži. Tu nám to ale preloží až prekladač v OpenGL ovládači.

class Shader
{
    GLuint program,vertex,fragment;
    string log;

Prvé máme funkciu ktorá načíta celý obsah súboru do reťazca. Je to potrebne pretože preklad z GLSL je až za behu programu.

    string loadFile(string filename)
    {
        string ret;//retazec kam sa načíta obsah suboru
        ifstream fr(filename.c_str(), ios::in);//otvorime subor
        if(!fr.good())return ret;//nenastala chyba?
        int len;//dlzka suboru

        fr.seekg(0, ios::end);//posunieme sa na koniec suboru
        len = fr.tellg();//kolko bajtov je od zaciatku?
        fr.seekg(0, ios::beg);//zase na zaciatok
        char *data = new char[len+1];//alokujeme si buffer pre data
        fr.read(data, len);//precitame cely subor do buffera
        data[len] = 0;//na koniec pridame nulu. dost casto sa na to zabuda
        ret = data;//vlozime data do C++ retazca
        delete [] data;//uvolnime pamet
        fr.close();//zatvorime subor
        return ret;//vratime retazec
    }

V konštruktore sa vytvorí program a k nemu prislúchajúce shadery. Tu sa dopúštam malej nepresnosti názvoslovia kedy označujem za shader vertex, fargment shader a aj cely program pozostávajúci z vertex,fragment shaderov. Postup vytvárania celého shaderu je celkom priamočiary. Najprv sa vytvorí program ku ktorému sa budú pridávať jednotlivé shadery. Do každého shaderu je potrebné nahrať zdrojový kód shaderu a ten následne kompilovať. Nakoniec sa jednotlivé shadery navzájom zlinkujú.

    public:
    Shader(string filename)
    {
        GLchar infolog[10000];//docasne ulozisko pre log
        const char *src;
        program = vertex = fragment = 0;
        program = glCreateProgram();//vytvorime program
        string vertex_source = loadFile(filename+".vert");//nacitame zdrojovy kod vertex shadera
        if(vertex_source.length())//nie je prazdny?
        {

Na vytvorenie shadera slúži glCreateShader() jej parametrom je typ shadera ktorý chceme vytvoriť. Na to aby sme do shadera nahrali zdrojový kód je glShaderSource(). Jej prvý parameter je meno shader a do ktorého chceme nahrať kód. Druhým parametrom je počet reťazcov zdrojového kódu. To preto že tretím parametrom je pole reťazcov my ale budeme dávať iba jeden. Posledný parameter je pole na dĺžky jednotlivých reťazcov v bajtoch. Može byť NULL ak sú reťazce ukončenené znakom ako klasický C reťazec.

            vertex = glCreateShader(GL_VERTEX_SHADER);//vytvor vertex shader
            src = vertex_source.c_str();
            glShaderSource(vertex, 1, (const GLchar**)&src, NULL);//nahrajeme zdrojovy kod do shadera

Potom sa pripojí shader k programu. Parametre sú meno programu kam sa má pripojiť ktorý shader. Potom sa skompiluje. Nakoniec sa získa výstup z kompilátora. Ten je veľmi užitočný keďže obsahuje informácie o chybách pri preklade.

            glAttachShader(program, vertex);//pripoj shader k programu
            glCompileShader(vertex);//skompiluj shader
            glGetShaderInfoLog(vertex, 9999, NULL, infolog);//ziskaj log z kompilacie
            log += infolog;//pripoj ziskany log
        }

Potom sa pripojí shader k programu. Parametre sú meno programu kam sa má pripojiť ktorý shader. Potom sa skompiluje. Nakoniec sa získa výstup z kompilátora. Ten je veľmi užitočný keďže obsahuje informácie o chybách pri preklade.

            glAttachShader(program, vertex);//pripoj shader k programu
            glCompileShader(vertex);//skompiluj shader
            glGetShaderInfoLog(vertex, 9999, NULL, infolog);//ziskaj log z kompilacie
            log += infolog;//pripoj ziskany log
        }

Rovnako sa postupuje aj v prípade fragment shader. Jediný rozdiel je v type vytvárnehé shaera v glCreateShader().

        string fragment_source = loadFile(filename+".frag");//zopakujeme podobne aj pre fragment shader
        if(fragment_source.length())
        {
            fragment = glCreateShader(GL_FRAGMENT_SHADER);
            src = fragment_source.c_str();
            glShaderSource(fragment, 1, (const GLchar**)&src, NULL);
            glAttachShader(program, fragment);
            glCompileShader(fragment);
            glGetShaderInfoLog(fragment, 9999, NULL, infolog);
            log += infolog;
        }
        glLinkProgram(program);//nakoniec treba jednotlive shadery zlinkovat dohromady
        glGetProgramInfoLog(program, 9999, NULL, infolog);
        log += infolog;
    }

Klasický destruktor v C++. Vymaže shader ak ho už nebudme potrebovať.

    ~Shader()
    {
        //vymazeme jednotlive shadery
        glDeleteShader(vertex);
        glDeleteShader(fragment);
        glDeleteProgram(program);
    }

Ak si spomínate v prvej časti sme definovali vstupné atribúty cez glVertexAttribPointer(). Jej prvým parametrom bol index. Tento index je potrebné zviazať s menom vstupnej premennej vo veretx shadery. Po nastavení je potrebne program znovu zlinkovať.

    void bindAttribLocation(GLuint index, const char *name)
    {
        glBindAttribLocation(program, index, name);//priradi meno vstupnej premennej vertex shaderu k indexu vstupneho atributu
    }

Na čo nám slúži nasledovná metóda ktorá proste len zavolá linkvanie nad programom.

    void link()
    {
        glLinkProgram(program);//likovanie programu
    }
    string& getLog(){ return log; }

Nato aby sa shader použil pri vykresľovaní je to potrebné OpenGl povedať. Na to je glUseProgram() ktorej parameter je meno programu ktorý chceme používať. V aplikácii môžeme mať viacero shaderov ktoré budú vykreslovať rôzne objekty. Napr jeden shader bude vykreslovať terén a druhý vodu.

    void useProgram()
    {
        glUseProgram(program);//zacni pouzivat program
    }

Na to aby sme mohli nastaviť uniform premenné je potrebné najprv získať ich lokáciu. Na to slúži glGetUniformLocation() ktorej parametre sú meno programu a názov premennej vo forme reťazca. Tá vracia -1 pokiaľ sa daná premenná v programe nenachádza. To sa môže stať aj keď je v kóde uvedená. Ale ak sa stane že daná uniform premenná nemá vplyv na výstup tak ju kompilátor od-optimalizuje preč a teda odstráni.

    void setUniform(const char *name, float x)
    {
        GLint loc = glGetUniformLocation(program, name);//zisakj poziciu uniform premennej
        if(loc>=0)glUniform1f(loc, x);//nastav jej hodnotu
    }

Množina funkcií glUniform*() slúži na nastavovanie hodnôt uniform premenných. Číslo v názve označuje koľko zložkový vektor chceme nastaviť či obyčasjný float,int, dvoj, troj alebo štvor zložkový vektor.

    void setUniform(const char *name, float x, float y)
    {
        GLint loc = glGetUniformLocation(program, name);//zisakj poziciu uniform premennej
        if(loc>=0)glUniform2f(loc, x, y);//nastav jej hodnotu
    }

Za čislom nasleduje písmeno ktoré označuje typ premennej. Písmeno f označuje float,vecn písmeno i int, ivecn, u oznacuje uint,uvecn a nakoniec d označuje double,dvecn.

    void setUniform(const char *name, float x, float y, float z)
    {
        GLint loc = glGetUniformLocation(program, name);//zisakj poziciu uniform premennej
        if(loc>=0)glUniform3f(loc, x, y, z);//nastav jej hodnotu
    }

Úplne nakoniec sú funkcie glUniform*v() ktoré nastavujú pole uniform. Ich použitie je nasledovné float c[] = {1, 2, 3, 4, 5}; glUniform1fv(program, 5, c);

    void setUniform(const char *name, float x, float y, float z, float w)
    {
        GLint loc = glGetUniformLocation(program, name);//zisakj poziciu uniform premennej
        if(loc>=0)glUniform4f(loc, x, y, z, w);//nastav jej hodnotu
    }
};

Na koniec initGL() pridáme nasledujúci kód. Najprv vytvoríme samotný shader zo súborov shader.vert a shader.frag. Následne priradíme index k menu vstupnej premennej. Na to je potrebné znova zlinkovať program aby sa toto priradenie prejavilo. Nakoniec povieme OpenGL že chceme daný program používať aby sme mohli nastaviť uniform premenné a vypíšeme log. To je dôležité aby bol daný shader používaný keď sa mu nastavujú uniform premenné.

        shader = new Shader("shader");
        shader->bindAttribLocation(0, "in_position");
        shader->bindAttribLocation(1, "in_color");
        shader->link();
        shader->useProgram();
        shader->setUniform("mul", 1.0f);
        cout < < "=== BUILD LOG ===n" <getLog();

Téma shaderov je obrovská a dnes zabezpečujú 80% percent grafických operácií. Dnešnou časťou sme ich len zaryli na povrchu.

Zdrojový kód

Nebudem tu vysvetľovať ako vytvoriť projekt keďže to nie je obsahom tohto článku. Ako naištalovat SDL a ako ho používať si môžete prečítať na root.cz. Pri GLEW je to podobne tiež je potrebne nastaviť cesty k rozbalenému archívu ktorý obsahuje adresáre include a lib.

V OpenGL je potrebné všetky dáta ktoré chceme použiť pri vykresľovaní uložiť do buffer (okrem textúr ktoré sú ale tiež už len špeciálnym typom normálneho buffer). Na vytvorenie buffer nám slúži funkcia glGenBuffers(). Tá ma dva parametre prvým je počet buffer a druhým je pole kam sa majú uložiť vygenerované mená. Meno v OpenGL je obyčajný celo-číselný uint reprezentujúci akýkoľvek objekt v OpenGL od textúr cez VBO až po shadery.

Takže začneme s triedou na buffery. Tá obsahuje dve položky meno buffera a jeho typ teda cieľ kam sa bude priraďovať.

class GLbuffer
{
    GLuint buf;//obsahuje buffer
    GLenum target;//typ buffera
    public:

V konštruktore si teda vygenerujeme jeden buffer a nastavíme cieľ kam sa bude priraďovať. Týchto cieľov je viacero a každý je parametrom pre určitú skupinu funkcií. My budeme najčastejšie používať GL_ARRAY_BUFFER. Prakticky každý objekt v OpenGL treba predtým než sa s ním začne pracovať priradiť do cieľa. Na to slúžia funkcie začínajúce na glBind. Následne na to každá funkcia ktorá má ako parameter cieľ pracuje s daným objektom ktorý je aktuálne priradený k danému cieľu. Priradenie k cieľom je nezávislé teda zmena jedného cieľa neovplyvní ostatné a jeden objekt môže byť priradený k viacerým cieľom naraz.

    GLbuffer(GLenum type = GL_ARRAY_BUFFER)
    {
        glGenBuffers(1, &buf);//vygenerujeme si jeden buffer
        target = type;//nastavime si typ buffera. standartne to bude GL_ARRAY_BUFFER
    }

V tejto metóde sa budu nahrávať dáta z poľa obsahujúce napríklad súradnice vrcholov do samotného buffera. Najprv teda priradíme buffer do cieľa ktorý je v tomto prípade štandardne GL_ARRAY_BUFFER. Funkcia glBufferData() nahráva dáta do buffera ktorý je priradený do cieľa ktorý je uvedený ako prvý parameter. Druhým parametrom je veľkosť dát v bajtoch. Tretím je ukazovateľ na samotné dáta. Ten môže byť aj NULL kedy sa vytvorí buffer o danej veľkosti len náhodnými dátami. Nakoniec naše zamýšlané použitie. Použitie je kombinácia z týchto možností. Na prvé miesto je možné dať STREAM, STATIC, DYNAMIC. Na druhé miesto je možné dat DRAW, READ, COPY. Slúži to ovládaču ako pomôcka na optimalizáciu či sa budú dáta často meniť alebo budu menené. Alebo či ich budeme používať na kreslenie alebo ako zdroj pre čitanie alebo cieľ pre zápis.

    void loadData(size_t size, void *data = NULL, GLenum usage = GL_STATIC_DRAW)
    {
        glBindBuffer(target, buf);//nastavime buffer s ktorym sa bude pracovat
        glBufferData(target, size, data, usage);//nahratie dat do buffera. data moze byt aj NULL
    }
    void bind()
    {
        glBindBuffer(target, buf);//priradenie aktivneho buffera
    }
};

Teraz si rozoberieme druhú triedu ktorá bude obhospodarovať okno a vykresľovanie. Prvou premennou je screen ktorý ukazuje na aktuálnu obrazovku. Nasledujú dva buffery ktorú budu obsahovať súradnice vrcholov a farby jednotlivých vrcholov.

class GLwindow
{
    SDL_Surface* screen;
    GLbuffer *vbo;//buffer ktory bude obsahovat suradnice vrcholov
    GLbuffer *color;//buffer ktory bude obsahovat farby vrcholov
    bool done;//premenná ktorá sluzi na vyskocenie z nekonecnej slucky
    public:

Konštruktor vytvorí okno čo je vďaka SDL úplne jednoduché. Tento návod si síce kladie za cieľ zoznámiť Vás s Core profilom z OpenGL 3/4. Tu spravíme prvú obchádzku v tom že SDL 1.2 podporuje len klasické vytváranie OpenGL okna ktoré vráti poslednú verziu OpenGL ktorá je kompatibilná s verziou 1.0 čo prakticky znamená kompatibilný profil. Na to aby sme dostali Core profil je potrebné použiť novšiu metódu. SDL_SetVideoMode() má len zopár parametrov. prvými dvoma sú šírka a výška vytvoreného okna. Tretím je bitová farebná hĺbka ktorá sa má použiť. Posledným parametrom sú príznaky mi použijeme jediný a to že chceme aby výsledné okno obsahovalo OpenGL okno. Nasleduje nastavenie titulka okna. glewInit() inicializuje všetky rozšírenia ktoré podporuje aktuálne OpenGL na ktorom beží program. Na Linuxe je definované makro ktoré toto volanie odstráni keďže nie je nutné tak ako cele GLEW. Nakoniec sa inicializuje samotné OpenGL.

    GLwindow()
    {
        screen = SDL_SetVideoMode(WIDTH, HEIGHT, 32, SDL_OPENGL);//jednoduche vytvorenie okna za pomoci SDL
        SDL_WM_SetCaption("Lekcia 1", NULL);
        glewInit();
        done = false;//este sme neskoncily
        initGL();//nastavime vsetko potrebne na zaciatok
    }

V inicializácii OpenGL robíme zatiaľ minimum vecí. Prvou vecou je nastavenie rozmerov viewportu. To znamená x,y súradnice dolného ľavého rohu a pravého horného v pixeloch. Nasleduje nastavenie Vertex Array Object. O tom niekedy v budúcnosti teraz len poviem že to obaľuje nastavovanie okolo vertex bufferov.

    void initGL()
    {
        glViewport(0, 0, WIDTH, HEIGHT);

        GLuint vao;//VAO alebo Vertex Array Object zapuzruju vsetky nastavenia spojene s definovanim vrcholov
        glGenVertexArrays(1, &vao);//core profil vyzdauje aby jeden VAO bol vytvoreny.
        glBindVertexArray(vao);//priradime tento VAO a uz sa nestarame

Tu si vytvoríme dva buffery. Teda sa dvakrat zavolá glGenBuffer() v konštruktore triedy GLbuffer. Následne sa nahrajú naše dáta. Sú to obyčajné pole float. Každá trojica čísel predstavuje dáta pre jeden vrchol. V prvom poli sú to súradnice x,y,z v 3D priestore. Druhé pole obsahuje farby pre každý vrchol. Sú to klasické farebne zložky RGB modelu kedy je farba zložená z troch základných farieb červenej, zelenej a modrej. Budeme kresliť trojuholníky teda tri trojice ktoré sú na jednom riadku predstavujú vrcholy jedného trojuholníka. Potom sa zavolá metóda loadData() v ktorej sa buffer priradí do cieľa a následne zavola glBufferData(). Ako je vidno posielame veľkosť poľa a samotné pole.

        vbo = new GLbuffer;
        color = new GLbuffer;
        float vertexs[] = {-0.95f, -0.95f, 0.0f,  0.95f, -0.95f, 0.0f, -0.95f, 0.9f, 0.0f,
            -0.95f, 0.95f, 0.0f,  0.95f, -0.9f, 0.0f,  0.95f, 0.95f, 0.0f };
        float colors[] = {1.0f, 0.0f, 0.0f,  0.0f, 1.0f, 0.0f,  0.0f, 0.0f, 1.0f,//cervena zelena modra
        1.0f, 1.0f, 0.0f,  1.0f, 0.0f, 1.0f,  0.0f, 1.0f, 1.0f};//zlta purpurova tyrkysova
        vbo->loadData(sizeof(vertexs), vertexs);
        color->loadData(sizeof(colors), colors);

Tu je za-komentovaný “správny” postup ako špecifikovať ktoré vrcholy sa majú kresliť. Správny v tom že nižšie ukážem zastaralý spôsob ktorý už nie je v Core profile. Tento zastaralý spôsob použijem preto aby sme už v tejto časti dostali nejaký výstup. Vstupom pre kreslenie v OpenGL sú vrcholy jednotlivých primitív. primitíva sú body, čiary, trojuholníky, štvorce, polygóny a v najnovšom OpenGL 4 aj patches (ktoré sa nakoniec ale aj tak transformujú na skôr spomenuté primitíva). Pre každý vrchol treba určiť jeho polohu, farbu, textúrovacie koordináty a iné. Na to slúžia vstupné atribúty. V OpenGL je ich dostupných hneď niekoľko. My budeme zatiaľ definujeme dva atribúty a to polohu a farbu. Tieto vstupné atribúty sú identifikované indexmi od 0 až po GL_MAX_VERTEX_ATTRIBS-1. Na dnešnom hardvére to je maximálne 16 atribútov. Aby sa dáta z daného vstupu používali treba ho zapnúť. Na to slúži glEnableVertexAttribArray() ktorej parametrom je index atribútu ktorý chceme zapnúť. Následne priradíme do GL_VERTEX_ARRAY buffer s súradnicami vrcholov. Nezabudnime že pri vytváraní bufferov sa nastavil práve tento cieľ do premennej GLbuffer::target aby sa následne použil aj pri ostatných volaniach. Funkcia glVertexAttribPointer() určuje formát dát ktoré sú v buffery. Priradí buffer aktuálne priradený do GL_VERTEX_ARRAY ako vstupné dáta atribútov. Prvým parametrom je index atribútu ku ktorému sa má priradiť. Druhý je počet zložiek pre jeden vrchol. Môže to byť jedna až štyri. V našom prípade máme troj-zložkovú polohu. Ďaľsí parameter určuje typ dát ktoré posielame. Posielame float teda použijeme GL_FLOAT. Môžné hodnoty sú ešte GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT a GL_DOUBLE. Posledné dva parametre sú krok a odskok v bajtoch. Odskok a krok sa nastavuje vtedy ak by sme mali jeden buffer obsahujúci viacero atribútov ktoré by boli prekladané. Napríklad by bola v poli najprv trojica čísel označujúca polohu prvého vrcholu nasledovala by trojica čísel určujúca farbu prvého vrchola. Za nimi by bol určený druhý vrchol atď. Vtom prípade sa nastaví krok na počet bajtom medzi jednotlivými vrcholmi teda 6*sizeof(float) kedže jeden vrchol tvorí šesť float. Odskok určuje kde začínajú dáta atribútu. Pre farbu by to bolo teda 3*sizeof(float) kedže farba začína až za troma float. Ešte zopakujeme pre farbu len dáme druhy index.

        /*
        glEnableVertexAttribArray(0);//zapne prve pole s atributmi
        vbo->bind();//priradi aktualny buffer
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);//nastavy zdroj pre dene pole atributov

        glEnableVertexAttribArray(1);//zapnneme druhe pole
        color->bind();//priradim si buffer s farmabmi
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);//nastavim aby sa z aktualne priradeneho buffera braly data
        */

Tu je starý spôsob ktorý sa používal v OpenGL 2.1 a skorších. Je to prakticky to isté. Jediný rozdiel je v tom že namiesto indexov boli pevne dané vstupy ktoré mali pevne udaný spôsob použitia. Na to aby ale hore uvedený spôsob fungoval musíme mať aktívne shadery. Čo je druhá obchádzka ktorú použijem a tou je fixná pipeline bez shaderov.

        glEnableClientState(GL_VERTEX_ARRAY);
        vbo->bind();
        glVertexPointer(3, GL_FLOAT, 0, 0);

        glEnableClientState(GL_COLOR_ARRAY);
        color->bind();
        glColorPointer(3, GL_FLOAT, 0, 0);
    }

Teraz máme nastavené vstup pre samotné kreslenie. Kreslenie nám zabezpečí metóda draw(). Na začiatku vymažeme obrazovku aby na nej nič nebolo. Potom nám vykreslí dva trojuholníky funkcia glDrawArrays(). Jej prvý parameter určuje čo za primitívum chceme kresliť teda trojuholníky. Ešte máme dostupné napr. GL_QUADS, GL_POINTS, GL_LINES. Druhý parameter je číslo vrcholu od ktorého sa má začať kresliť. Počet určuje počet vrcholov ktoré sa majú spracovať. Vykreslí sa len toľko vrcholov koľko vytvorí celé primitívum. Teda ak zadáme napríklad 4 vykreslí sa len jeden trojuholník keďže sa dokáže skompletizovať len jeden. Potom sa už len skontroluje či nenastala niekde chyba. OpenGL je veľmi robustné a teda volania s nesprávnymi hodnotami sú ignorované. Výnimku tvoria volania ako sú glBufferData() kam sa posiela adresa do pamäte kde sa nedá ošetriť chyba a program dokáže spadnúť. Inak by sa nič nemalo diať okrem toho že sa niekedy nedeje nič pretože je niečo zle. Nakoniec prehodíme vykreslený obraz aby sa zobrazil na obrazovku. Kreslí sa na striedačku do dvoch obrazov aby sa zamedzilo blikaniu pri kreslení. To bolo v minulosti spôsobené tým že sa vymazala obrazovka a grafická karta následne začala vykreslovať na obrazovku takže ste mohli sledovať ako pribúdajú jednotlivé trojuholníky. Dnes sa ale už štandardne používa dvojitý buffering niekedy aj trojitý.

    void draw()
    {
        glClear(GL_COLOR_BUFFER_BIT);
        //samotne kreslenie stvorcov.
        glDrawArrays(GL_TRIANGLES, 0, 6);

        getGLError();
        SDL_GL_SwapBuffers();
    }

Zostáva už len posledné dve metódy. Prvá run nie je nič iné ako nekonečná slučka ktorá volá dookola spracovanie prichádzajúcich správ a vykresľovanie. Druhá je samotné spracovanie správ kedy sa kontroluje či sa nestlačil escape aby sa program ukončil

    void run()
    {
        while(!done)//nekonecna slucka
        {
            processEvents();//spracujeme udalosti
            draw();//vykreslime obraz
        }
    }
    void processEvents()
    {
        SDL_Event event;
        while(SDL_PollEvent(&event))
        {
            switch (event.type)
            {
                case SDL_QUIT://prisla sprava na ukoncenie. pouzivatel teda klikol na zatvorenie okna
                    done = true;//nastavime na true aby slucka skoncila
                    break;
                case SDL_KEYDOWN://bola stlacena klavesa
                    switch(event.key.keysym.sym)
                    {
                        case SDLK_ESCAPE://a je to escape
                            done = true;
                            break;
                        default:break;
                    }
                    break;
            }
        }
    }
};

V samotnej main() sa už len inicializuje samotné SDL a vytvorí GLwindow.

int main ( int argc, char** argv )
{
    SDL_Init(SDL_INIT_VIDEO);
    atexit(SDL_Quit);

    GLwindow window;
    window.run();

    return 0;
}

Nakoniec tu máme zdrojové kódy na stiahnutie. Pre Windows je to projekt pre Visual Studio 2005 EE a pre linux klasické Makefile. Ako som už povedal pre na Windowse budete potrebovať mať nainštalované okrem VS spolu s PSDK aj SDL a GLEW a nastavené cesty. Na Linuxe stačí nainštalovať vývojársky balíček s SDL. GLEW nie je potrebné.
Zdrojový kód Windows
Zdrojový kód Linux

#!/bin/bash
if [ -z "$2" ]
   then
   echo "Usage: pdfsearch path [\"]phraze[\"]"
   exit
fi

if [ "`ls -la $1 | grep pdf$ | wc -l`" == "0" ]
   then
   echo "Path has no pdf files";
   exit
fi

FILES="$1/*.pdf";
for file in $FILES
   do
   echo $file
   pdftotext $file - | grep -n -i --color "$2"
   echo
done

Nezabudnite na koniec skriptu vložiť prázdy riadok.

Pribudol druhý if, ktorý zisťuje či sa v danej ceste nachádzajú pdf súbory.
Ak ich počet je rovný 0 tak vypíše hlášku a skript sa ukončí.

Ďalej som pridal prepínač -i a –color .

Originálna stránka je:

http://ubuntuforums.org/archive/index.php/t-13665.html

Toto je upravený skript:

#!/bin/sh
if [ -z "$2" ]
then
echo "Usage:  pdfsearch path [\"]phraze[\"]"
exit
fi

FILES="$1/*.pdf"
for file in $FILES
do
echo $file
pdftotext $file - | grep -n "$2"
echo
done

Pre správne použitie skopírujte text skriptu do súboru s názvom napríklad pdfsearch.
Spravte z neho spustiteľný súbor

chmod u+x pdfsearch


A spustite nasledovným príkazom:

./pdfsearch <cesta/ku/pdf/suborom> “hladana fraza”


Je potrebné aby ste mali na vašom systéme program pdftotext, ktorý konvertuje pdf na plain text.
Ako shell som predpokladal bash, alebo jeho modifikácie.

V originálnom článku bol použitý program pdf2text čo nie je veľký rozdiel.
Tu som ešte zmenil prehľadávanie tak aby nevytváral .txt súbory (druhý parameter -).

Pridal som úvodzovky pre grep aby sa dali vyhľadávať aj cele frázy s medzerami.Môžete si pridať aj farebné zvýraznenie prepínačom grepu –color (dve pomlčky).

Skript pracuje tak, že zobrazí každé prehľadávané pdf (aj keď v ňom nič nenájde).
Ak v ňom nájde hľadanú frázu, tak zobrazí celý riadok kde sa vyskytla (farebne vyznačí číslo riadku a frázu).

Skript sa dá jednoducho (dúfam) rozšíriť pre vaše potreby.

Ak chcete, môžete do komentárov napísať nejaké zlepšenie

Vi(m) editor je uznávaným editorom napríklad medzi programátormi.

Pomáha automatizovať rutinné úpravy textu.

Podporuje regulárne výrazy a najrôznejšie kombinácie všetkých príkazov.

Vitajte v prvom článku o vim-e

Budem sa ho snažiť udržiavať čo najstručnejší a zároveň prehľadný(podľa možností), aby sa dal rýchlo prečítať.
Kým začnete: Pre úplné začiatky vo vim-e odporúčam: Satrapova stránka o vim(po česky)
Prvá otázka ktorá Vás možno napadne: “Načo je vim dobrý?”
Je dobrý predovšetkým na rýchle vkladanie a úpravu textu.
(na čo nie je:) Neslúži však na dizajn, tj. upravuje sa iba plain text.
Napríklad pri písaní skriptov alebo programov v programovacom jazyku.

Veľmi ľahko sa pomocou rôznych konštrukcií vykonajú akcie, ktoré by bolo potrebné viacnásobne opakovať.
Je dobré mať po ruke zoznam používaných príkazov. Sú nutné na bežné jednoduché používanie.
Budem sa ich snažiť zoradiť podľa frekventovanosti používania.

, oddeľujem viac samostatných príkazov
^+<znak> znamená Control/Ctrl + niečo

Najprv základné riadkové príkazy:

A editačné príkazy:

Väčší zoznam je napríklad tu:
http://www.tuxfiles.org/linuxhelp/vimcheat.html

Po strávení tejto tabuľky sa môžete v ďalších dieloch dočítať:

• nahradzovanie textu
• makrá
• regulárne výrazy
• a iné samé dobré veci

Medzičasom sa môžete prehrabávať v tomto rozsiahlejšom článku :
http://www.yolinux.com/TUTORIALS/LinuxTutorialAdvanced_vi.html

Ak sa vo svete internetu aspoň trocha pohybujete, alebo ste používateľom OS Windows, je dosť možné, že ste sa s týmto vyhľadávačom už stretli. V nasledujúcich pár riadkoch by som chcel vyjadriť názor, prečo si myslím, že sa použitie tohoto vyhľadávača zvyšuje a prečo je to podľa mňa veľmi nečestné.

Krátky príbeh, ktorý kto nepozná, spozná

Jedného dňa zapnete Internet explorer a zrazu sa “automaticky” zmení nami nastavená vyhľadávacia stránka na bing. Prečo sa to automaticky stane a OS sa ma na túto zmenu aspoň nespýta? Internet explorer má bing, príbeh pokračuje. Nainštaloval som si Google Chrome, tak som sa tešil, že aspoň tam budem mať svoj obľúbený vyhľadávač. Dobrá nálada dlho netrvá, Windows mi po reštarte “automaticky” zasa strčí prsty do nastavenia iného prehliadača a ponúka aj v Chrome vyhľadávač bing. Podobne automatická inštalácia nebezpečného doplnku do Firefoxu. Win proste vie, čo používateľ chce(ironicky).

Čo to má vlastne znamenať??? Už len neželaná reklama tejto spoložnosti mi vadí, nie to ešte “automatické” zmenenie, čo som sám osobne zmenil. Za tento OS sa platí a ešte za to chrlí neželanou reklamou a obmedzuje používateľa vnucovaním ich technológii. Hovorí sa zákazník, náš pán. Nie ale všade to platí a tu je to zjavné porušenie pravidiel slušnosti a vidieť silnú monopolistickú politiku. A aby to nestačilo, v slávnom IE sa vôbec nedá triviálne zmeniť vyhľadávač spať na google. Dôvod, prečo to vravím je, že vačšina užívateľov vie prehliadač používať, ale ešte v živote ho nenastavovali a všetko nechávajú na default nastavenia a keď chcú, tak to aj tak nevedia zmeniť. Preto je Bing taký známy, hneď nahradil Live search a tiež yahoo.

Slová na záver

Bolo by dobré dať používateľovi možnosť výberu.
Keď už, tak by bolo vhodné sa spýtať používateľa, či by si náhodou nechcel dať ich vyhľadávač.
Ak používateľ povie, že nie, tak NIE.

Zaujíma ma aj váš názor a kľudne napíšte, čo si o tom myslíte.

Skript je pekne komentovaný a dúfam, že aj dostatočne bezpečný, takže by vám nemal nič pokaziť (mne nepokazil ) Ak nájdete chybu, alebo vylepšenie, napíšte to do komentára. Ďakujem.

Usage:

Stáčí ako bežne

chmod u+x subor.sh
sudo ./subor.sh

Samotný skript:

#!/bin/bash

#creates lib dependencies for QT or
# if you like, also lib dependencies for other programs, if you customize $libs variable
# author: Marcel Kanta
# licence: LGPL like QT 4.5

path="/usr/lib/" # change if you have to, or try default

#insert your required libraries from Compile Output, or shell query
libs='-lfreetype -lgobject-2.0 -lSM -lICE -pthread -pthread -lXrender -lfontconfig -lXext -lX11 -lQtCore -lm -pthread -lgthread-2.0 -lrt -lglib-2.0 -ldl -lpthread'

# dont't change anything under this line, only if you know,
# what you are doing.
#----------------------------------------------------------------

echo $libs |sed 's/-l/\n-l/g'|grep "^-l"|colrm 1 2|cut -d " " -f 1| while read f; do
	# here we have list of libs in format like "libfreetype"
	# here we check if the lib exist and if the answer is yes and
	# there doesn't exist .so extention, it creates a link.
	#it's rather safe.
	for i in $(seq 9 -1 0); do
		if [ -e $path"lib$f.so.$i" ]; then
			if [ ! -e $path"lib$f.so" ]; then
				echo $f to do;
				ln -s $path"lib"$f.so.$i $path"lib"$f.so;
				# what and where
			fi;
			continue;
		fi;
	done
done;

English version:

quick fix: see code above