Využití textur ve WebGL a OpenGL ES: zvětšování, zmenšování a blending

3D konvička wireframe
Autor: Hay Kranen, Wikimedia, podle licence: CC-BY
V sedmém článku o technologiích WebGL a OpenGL ES si popíšeme další možnosti, které nabízí texturovací subsystém Open GL ES. Popíšeme si filtraci textur při jejich zvětšování a/nebo zmenšování a využití blendingu.

Nastavování parametrů textur

Co se dozvíte v článku
  1. Nastavování parametrů textur
  2. Rozšířená podpora formátů textur
  3. Opakování textury na zobrazovaných stěnách těles
  4. Demonstrační příklad: vykreslení textury, která se opakuje
  5. Textury s malým rozlišením
  6. Bilineární interpolace
  7. Demonstrační příklad: vykreslení textury s využitím bilineární interpolace
  8. Role alfa složky, kterou obsahují texely
  9. Vygenerování textury s nastavenými alfa složkami texelů
  10. Demonstrační příklad: vykreslení textury s texely ve formáty RGBA obsahující různé hodnoty alfa složky
  11. Povolení blendingu a určení způsobu výpočtu výsledné barvy fragmentů
  12. Míchací rovnice použitá při blendingu
  13. Funkce blendFunc
  14. Význam předpřipravených míchacích faktorů
  15. Demonstrační příklad: vykreslení textury s texely ve formátu RGBA společně s výpočtem blendingu
  16. Vizuální chyby, které při texturování vznikají
  17. Textury s více úrovněmi detailu
  18. Podpora mipmap v OpenGL
  19. Repositář s demonstračními příklady
  20. Odkazy na Internetu

V předchozím článku jsme v demonstračních příkladech používali funkce určené pro nastavení parametrů textury. Tyto funkce však nebyly podrobněji popsány, což se dnes budeme snažit napravit.

Parametry textury (tj. například způsob, jakým je textura mapována na povrch vykreslovaného tělesa) lze nastavit voláním metody:

texParameterf(
    target,
    pname,
    value
);

nebo metody:

texParameteri(
    target,
    pname,
    value
);

Alternativně lze také zavolat metody, které jako svůj poslední parametr akceptují místo skalární hodnoty pole hodnot:

texParameterfv(
    target,
    pname,
    values
);
 
texParameteriv(
    target,
    pname,
    values
);

První parametr (target) může podle zvolené dimenze textury nabývat hodnot TEXTURE_1D (jednodimenzionální textura, tj. barevný přechod), TEXTURE_2D (nejběžnější, rastrová textura) nebo TEXTURE_3D (objemová textura). Hodnoty parametrů dalších dvou parametrů pname a value jsou uvedeny v následujícím seznamu:

  • Parametr TEXTURE_WRAP_S:
    tímto parametrem specifikujeme, zda se má při překročení rozsahu texturovací souřadnice ve směru osy s (tento rozsah je, jak víme z minulého dílu od 0 do 1) provést opakování motivu na textuře (value=REPEAT) nebo „protažení“ první či poslední hodnoty (value=CLAMP). Opakování motivu na textuře je vhodné použít v případech, že zobrazujeme různé na sebe navazující motivy, například cihlové zdi, podlahy apod. Protažením textury lze v některých případech zamezit vizuálním artefaktům, které by se mohly objevit při napojování textur. Překročení rozsahu uv-souřadnic není tedy v žádném případě chybou.
  • Parametr TEXTURE_WRAP_T:
    tento parametr má podobný význam jako parametr předchozí, ale s tím rozdílem, že se místo na souřadnici ve směru osy s vztahuje na souřadnici ve směru osy t. U 1D textur nemá hodnota tohoto parametru vliv na zobrazení textury, použitelný je pouze u 2D a 3D textur. Opakování resp. protažení textury lze pro souřadnice ve směrech s, t a r nastavovat nezávisle, což je patrné z demonstračních příkladů.
  • Parametr TEXTURE_WRAP_R:
    tento parametr má opět podobný význam jako předchozí dva parametry, ale vztahuje se na třetí souřadnici r, která je použita například u objemových textur.
  • Parametr TEXTURE_MIN_FILTER:
    tímto parametrem je možné zvolit filtr použitý při zmenšování textury, tj. tehdy, jestliže na plochu jednoho vykreslovaného pixelu musíme použít barvy několika sousedních texelů. Nejjednodušší a nejrychlejší filtr se volí hodnotou NEAREST. U tohoto filtru se barva vykreslovaného pixelu vypočte z barvy texelu, jehož souřadnice nejpřesněji odpovídají zadaným souřadnicím do textury. Poněkud sofistikovanější filtr se zadává hodnotou LINEAR, kdy se barva vykreslovaného pixelu spočítá pomocí bilineární interpolace z barev sousedních texelů. Další čtyři filtry (NEAREST_MIPMAP_NEAREST, NEAREST_MIPMAP_LINEAR, LINEAR_MIPMAP_NEAREST a LINEAR_MIPMAP_LINEAR) využívají takzvané mipmapy, tj. texturu uloženou ve formátu jakési pyramidy, kde jsou kromě základního rozlišení textury obsaženy i rozlišení nižší (vždy s polovičním počtem pixelů v horizontální i vertikální ose) až do nejmenší velikosti 1×1 pixel.
  • Parametr TEXTURE_MAX_FILTER:
    tímto parametrem se volí filtr použitý při zvětšování textury, tj. v případě, že vykreslovaný pixel obsahuje pouze malou plochu texelu. Možné hodnoty jsou NEAREST (použije se nejbližší texel) nebo LINEAR (použije se lineární interpolace mezi barvami sousedních texelů).
  • Parametr TEXTURE_BORDER_COLOR:
    tímto parametrem lze zvolit barvu rámečku okolo textury (pokud je rámeček použit, tj. má nenulovou šířku). V případě zadávání barvy je nutné použít příkazy texParameteriv() resp. texParameterfv(), protože barva se zadává jako vektor (pole) čtyř složek R, G, B a A. Implicitní barva rámečku je (0, 0, 0, 0), tedy černá.

Rozšířená podpora formátů textur

Kromě základních formátů textur, které jsme si popsali v minulém článku, je možné používat v OpenGL verze 1.2 a vyšších (i další rozšířené formáty. Jaká výhoda plyne z použití takových formátů? Především se jedná o to, že použitím některých formátů s malou nebo dostatečnou bitovou hloubkou můžeme ušetřit paměť alokovanou pro textury. Druhou výhodou je možnost použít textury načtené z různých externích souborů, které mají mnohdy exotický formát. V následující tabulce budou ukázány rozšířené formáty textur spolu se základním formátem a typem dat pro každou barevnou složku:

Rozšířený formát Základní formát R (bitů) G (bitů) B (bitů) A (bitů) L (bitů) I (bitů)
ALPHA4 ALPHA       4    
ALPHA8 ALPHA       8    
ALPHA12 ALPHA       12    
ALPHA16 ALPHA       16    
LUMINANCE4 LUMINANCE         4  
LUMINANCE8 LUMINANCE         8  
LUMINANCE12 LUMINANCE         12  
LUMINANCE16 LUMINANCE         16  
LUMINANCE4_ALPHA4 LUMINANCE_ALPHA       4 4  
LUMINANCE6_ALPHA2 LUMINANCE_ALPHA       2 6  
LUMINANCE8_ALPHA8 LUMINANCE_ALPHA       8 8  
LUMINANCE12_ALPHA4 LUMINANCE_ALPHA       4 12  
LUMINANCE12_ALPHA12 LUMINANCE_ALPHA       12 12  
LUMINANCE16_ALPHA16 LUMINANCE_ALPHA       16 16  
INTENSITY4 INTENSITY           4
INTENSITY8 INTENSITY           8
INTENSITY12 INTENSITY           12
INTENSITY16 INTENSITY           16
R3_G3_B2 RGB 3 3 2      
RGB4 RGB 4 4 4      
RGB5 RGB 5 5 5      
RGB8 RGB 8 8 8      
RGB10 RGB 10 10 10      
RGB12 RGB 12 12 12      
RGB16 RGB 16 16 16      
RGBA2 RGBA 2 2 2 2    
RGBA4 RGBA 4 4 4 4    
RGB5_A1 RGBA 5 5 5 1    
RGBA8 RGBA 8 8 8 8    
RGB10_A2 RGBA 10 10 10 2    
RGBA12 RGBA 12 12 12 12    
RGBA16 RGBA 16 16 16 16    
Poznámka: pravděpodobně je však v praxi dobré zůstat u formátu RGB a RGBA, kromě speciálních požadavků. Mnohé z vypsaných formátů jsou dnes spíše historickým reliktem.

Opakování textury na zobrazovaných stěnách těles

Připomeňme si, že v předchozím článku jsme parametry použité při nanášení textur nastavovali následujícím způsobem:

// způsob vykreslení textury
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);

Poslední dva parametry určovaly, že pokud uv-souřadnice (v prostoru textury) leží mimo čtverec omezený vrcholy [0, 0] a [1, 1], budou texely ležící mimo tyto meze obsahovat barvy získané z texelů umístěných na hranách textury. To například znamená, že barva texelu na souřadnicích [100, 0.5] bude získána z texelu na souřadnicích [1, 0.5] atd. Výsledek již známe: https://tisnik.github.io/tem­p/textures4.html.

Ovšem mnohdy se, například při opakování motivu (kameny, cihly atd.) vyplatí texturu zopakovat a vytvořit tak mozaiku. V OpenGL ES je možné toto opakování povolit pro směr souřadnice u nezávisle na souřadnici v, takže se vždy musí nastavit oba parametry:

// způsob vykreslení textury
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);

Demonstrační příklad: vykreslení textury, která se opakuje

V dnešním prvním demonstračním příkladu, který si můžete spustit z adresy https://tisnik.github.io/tem­p/textures6.html, je ukázáno, jakým způsobem je realizováno namapování textury s jejím opakováním:

const vertexShaderSource = `
    attribute vec2 position;
    attribute vec2 texcoord;
    varying vec2 vTexcoord;
 
    void main() {
        gl_Position = vec4(position, 0, 1);
        vTexcoord = texcoord;
    }
`
 
const fragmentShaderSource = `
    precision mediump float;
    varying vec2 vTexcoord;
    uniform sampler2D texture;
 
    void main() {
        gl_FragColor = texture2D(texture, vTexcoord);
    }
`
 
function print(message) {
    console.log(message);
}
 
function makeTexture(width, height) {
    const array = new Array(width*height*4);
 
    let index = 0;
    for (j=0; j<height; j++) {
        for (i=0; i<width; i++) {
            const c = ((i&0x20)==0^(j&0x20)==0) * 255;
            array[index++] = c;
            array[index++] = i;
            array[index++] = j;
            array[index++] = 255;            // alfa slozka
        }
    }
    return array;
}
 
// reference na objekt představující kreslicí plátno umístěné na webové stránce
const canvas = document.getElementById("web_gl_canvas");
if (!canvas) {
    throw new Error("Canvas with id 'web_gl_canvas' not found");
}
print("Canvas object retrieved");
 
// vytvoření a získání kontextu WebGL (3D grafika)
const gl = canvas.getContext("webgl");
if (!gl) {
    throw new Error("WebGL is not supported or context creation failed");
}
print("WebGL context created");
 
// vytvoření vertex shaderu
const vertexShader = gl.createShader(gl.VERTEX_SHADER);
if (!vertexShader) {
    throw new Error("Failed to create vertex shader.");
}
print("Vertex shader created");
 
// překlad vertex shaderu
gl.shaderSource(vertexShader, vertexShaderSource);
gl.compileShader(vertexShader);
if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
    const log = gl.getShaderInfoLog(vertexShader);
    gl.deleteShader(vertexShader);
    throw new Error(`Vertex shader compile failed: ${log}`);
}
print("Vertex shader compiled");
 
// vytvoření fragment shaderu
const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
if (!fragmentShader) {
    throw new Error("Failed to create fragment shader.");
}
print("Fragment shader created");
 
// překlad fragment shaderu
gl.shaderSource(fragmentShader, fragmentShaderSource);
gl.compileShader(fragmentShader);
if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
    const log = gl.getShaderInfoLog(fragmentShader);
    gl.deleteShader(fragmentShader);
    throw new Error(`fragment shader compile failed: ${log}`);
}
print("Fragment shader compiled");
 
// registrace obou shaderů
const program = gl.createProgram();
if (!program) {
    throw new Error("Failed to create program.");
}
print("Program created");
 
gl.attachShader(program, vertexShader);
gl.attachShader(program, fragmentShader);
print("Shaders attached to the program");
 
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
    const log = gl.getProgramInfoLog(program);
    gl.deleteProgram(program);
    throw new Error(`Program link failed: ${log}`);
}
print("Program linked");
 
const min_x = -0.9
const max_x = 0.9
const min_y = min_x
const max_y = max_x
 
// souřadnice vrcholů trojúhelníku + souřadnice v prostoru textury
const vertexes = [
  // x, y,   u, v
   min_x, min_y, 0.0, 0.0,
   min_x, max_y, 0.0, 1.0,
   max_x, max_y, 1.0, 1.0,
 
   min_x, min_y, 0.0, 0.0,
   max_x, max_y, 2.0, 2.0,
   max_x, min_y, 2.0, 0.0,
];
 
// buffer, do kterého se překopírují souřadnice bodu
const vertexBuffer = gl.createBuffer();
if (!vertexBuffer) {
    throw new Error("Failed to create buffer.");
}
print("Vertex buffer created");
gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
 
const data = new Float32Array(vertexes);
gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
print("Vertex buffer filled-in by vertexes");
 
// navázání na parametr předávaný do vertex shaderu
const p = gl.getAttribLocation(program, "position");
if (p === -1) {
    throw new Error("Attribute 'position' not found in shader program");
}
print("Attribute 'position' found in shader program")
 
// navázání na parametr předávaný do vertex shaderu
const texLoc = gl.getAttribLocation(program, "texcoord");
if (p === -1) {
    throw new Error("Attribute 'texcoord' not found in shader program");
}
print("Attribute 'texcoord' found in shader program")
 
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(p,
                       2,                                // počet prvků v každém atributu
                       gl.FLOAT,                         // typ prvků
                       gl.FALSE,                         // data nejsou normalizována
                       4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       0                                 // offset
);
gl.enableVertexAttribArray(p);
 
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(texLoc,
                       2,                                // počet prvků v každém atributu
                       gl.FLOAT,                         // typ prvků
                       gl.FALSE,                         // data nejsou normalizována
                       4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       2*Float32Array.BYTES_PER_ELEMENT  // offset
);
gl.enableVertexAttribArray(texLoc);
 
// textura (prozatím primitivní)
const texture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
 
const textureWidth = 256
const textureHeight = 256
 
// textura
textureArray = makeTexture(textureWidth, textureHeight);
const texels = new Uint8Array(textureArray);
 
gl.texImage2D(gl.TEXTURE_2D,      // typ textury: zde 2D textura
              0,                  // úroveň detailu
              gl.RGBA,            // počet barvových komponent (zde 4)
              textureWidth,       // horizontální rozlišení textury
              textureHeight,      // vertikální rozlišení textury
              0,                  // šířka okraje textury
              gl.RGBA,            // formát uložení texelů
              gl.UNSIGNED_BYTE,   // typ každé barvové složky texelu
              texels              // pole texelů
);
 
// způsob vykreslení textury
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
 
// navázání na atribut ve shaderech
const samplerLoc = gl.getUniformLocation(program, "texture");
gl.uniform1i(samplerLoc, 0);
 
// transformace souřadnic: z normalizovaných souřadnic na souřadnice na plátnu
gl.viewport(0, 0, canvas.width, canvas.height);
 
// nastavení barvy pro vymazání barvového bufferu
gl.clearColor(0, 0, 0, 1);
 
// vymazání barvového bufferu
gl.clear(gl.COLOR_BUFFER_BIT);
 
// spuštění programu
gl.useProgram(program);
 
// vykreslení dvojice trojúhelníků
gl.drawArrays(gl.TRIANGLES, 0, 6);

Pro úplnost ještě doplňuji mírně upravený příklad na adrese https://tisnik.github.io/tem­p/textures7.html, který v jednom směru texturu opakuje a ve směru druhém jen „prodlužuje“ její okraje.

const vertexShaderSource = `
    attribute vec2 position;
    attribute vec2 texcoord;
    varying vec2 vTexcoord;
 
    void main() {
        gl_Position = vec4(position, 0, 1);
        vTexcoord = texcoord;
    }
`
 
const fragmentShaderSource = `
    precision mediump float;
    varying vec2 vTexcoord;
    uniform sampler2D texture;
 
    void main() {
        gl_FragColor = texture2D(texture, vTexcoord);
    }
`
 
function print(message) {
    console.log(message);
}
 
function makeTexture(width, height) {
    const array = new Array(width*height*4);
 
    let index = 0;
    for (j=0; j<height; j++) {
        for (i=0; i<width; i++) {
            const c = ((i&0x20)==0^(j&0x20)==0) * 255;
            array[index++] = c;
            array[index++] = i;
            array[index++] = j;
            array[index++] = 255;            // alfa slozka
        }
    }
    return array;
}
 
// reference na objekt představující kreslicí plátno umístěné na webové stránce
const canvas = document.getElementById("web_gl_canvas");
if (!canvas) {
    throw new Error("Canvas with id 'web_gl_canvas' not found");
}
print("Canvas object retrieved");
 
// vytvoření a získání kontextu WebGL (3D grafika)
const gl = canvas.getContext("webgl");
if (!gl) {
    throw new Error("WebGL is not supported or context creation failed");
}
print("WebGL context created");
 
// vytvoření vertex shaderu
const vertexShader = gl.createShader(gl.VERTEX_SHADER);
if (!vertexShader) {
    throw new Error("Failed to create vertex shader.");
}
print("Vertex shader created");
 
// překlad vertex shaderu
gl.shaderSource(vertexShader, vertexShaderSource);
gl.compileShader(vertexShader);
if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
    const log = gl.getShaderInfoLog(vertexShader);
    gl.deleteShader(vertexShader);
    throw new Error(`Vertex shader compile failed: ${log}`);
}
print("Vertex shader compiled");
 
// vytvoření fragment shaderu
const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
if (!fragmentShader) {
    throw new Error("Failed to create fragment shader.");
}
print("Fragment shader created");
 
// překlad fragment shaderu
gl.shaderSource(fragmentShader, fragmentShaderSource);
gl.compileShader(fragmentShader);
if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
    const log = gl.getShaderInfoLog(fragmentShader);
    gl.deleteShader(fragmentShader);
    throw new Error(`fragment shader compile failed: ${log}`);
}
print("Fragment shader compiled");
 
// registrace obou shaderů
const program = gl.createProgram();
if (!program) {
    throw new Error("Failed to create program.");
}
print("Program created");
 
gl.attachShader(program, vertexShader);
gl.attachShader(program, fragmentShader);
print("Shaders attached to the program");
 
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
    const log = gl.getProgramInfoLog(program);
    gl.deleteProgram(program);
    throw new Error(`Program link failed: ${log}`);
}
print("Program linked");
 
const min_x = -0.9
const max_x = 0.9
const min_y = min_x
const max_y = max_x
 
// souřadnice vrcholů trojúhelníku + souřadnice v prostoru textury
const vertexes = [
  // x, y,   u, v
   min_x, min_y, 0.0, 0.0,
   min_x, max_y, 0.0, 1.0,
   max_x, max_y, 1.0, 1.0,
 
   min_x, min_y, 0.0, 0.0,
   max_x, max_y, 2.0, 2.0,
   max_x, min_y, 2.0, 0.0,
];
 
// buffer, do kterého se překopírují souřadnice bodu
const vertexBuffer = gl.createBuffer();
if (!vertexBuffer) {
    throw new Error("Failed to create buffer.");
}
print("Vertex buffer created");
gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
 
const data = new Float32Array(vertexes);
gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
print("Vertex buffer filled-in by vertexes");
 
// navázání na parametr předávaný do vertex shaderu
const p = gl.getAttribLocation(program, "position");
if (p === -1) {
    throw new Error("Attribute 'position' not found in shader program");
}
print("Attribute 'position' found in shader program")
 
// navázání na parametr předávaný do vertex shaderu
const texLoc = gl.getAttribLocation(program, "texcoord");
if (p === -1) {
    throw new Error("Attribute 'texcoord' not found in shader program");
}
print("Attribute 'texcoord' found in shader program")
 
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(p,
                       2,                                // počet prvků v každém atributu
                       gl.FLOAT,                         // typ prvků
                       gl.FALSE,                         // data nejsou normalizována
                       4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       0                                 // offset
);
gl.enableVertexAttribArray(p);
 
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(texLoc,
                       2,                                // počet prvků v každém atributu
                       gl.FLOAT,                         // typ prvků
                       gl.FALSE,                         // data nejsou normalizována
                       4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       2*Float32Array.BYTES_PER_ELEMENT  // offset
);
gl.enableVertexAttribArray(texLoc);
 
// textura (prozatím primitivní)
const texture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
 
const textureWidth = 256
const textureHeight = 256
 
// textura
textureArray = makeTexture(textureWidth, textureHeight);
const texels = new Uint8Array(textureArray);
 
gl.texImage2D(gl.TEXTURE_2D,      // typ textury: zde 2D textura
              0,                  // úroveň detailu
              gl.RGBA,            // počet barvových komponent (zde 4)
              textureWidth,       // horizontální rozlišení textury
              textureHeight,      // vertikální rozlišení textury
              0,                  // šířka okraje textury
              gl.RGBA,            // formát uložení texelů
              gl.UNSIGNED_BYTE,   // typ každé barvové složky texelu
              texels              // pole texelů
);
 
// způsob vykreslení textury
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
 
// navázání na atribut ve shaderech
const samplerLoc = gl.getUniformLocation(program, "texture");
gl.uniform1i(samplerLoc, 0);
 
// transformace souřadnic: z normalizovaných souřadnic na souřadnice na plátnu
gl.viewport(0, 0, canvas.width, canvas.height);
 
// nastavení barvy pro vymazání barvového bufferu
gl.clearColor(0, 0, 0, 1);
 
// vymazání barvového bufferu
gl.clear(gl.COLOR_BUFFER_BIT);
 
// spuštění programu
gl.useProgram(program);
 
// vykreslení dvojice trojúhelníků
gl.drawArrays(gl.TRIANGLES, 0, 6);

Textury s malým rozlišením

Rozlišení 2D textury je obecně odlišné od rozlišení stěny, která je vykreslena do výsledné scény. Mnohdy je rozlišení textury mnohem menší, což si ostatně můžeme poměrně snadno nasimulovat. Nejprve nepatrně pozměníme funkci makeTexture tak, aby se pro libovolnou požadovanou velikost textury vždy vygenerovala šachovnice 8×8 políček (výpočet nebude plně funkční pro textury menší než 8×8 texelů, to je však již extrém):

function makeTexture(width, height) {
    const array = new Array(width*height*4);
    const divider = width / 8;
 
    let index = 0;
    for (j=0; j<height; j++) {
        for (i=0; i<width; i++) {
            const c = ((i&divider)==0^(j&divider)==0) * 255;
            array[index++] = c;
            array[index++] = 256*i/width;
            array[index++] = 256*j/width;
            array[index++] = 255;            // alfa slozka
        }
    }
    return array;
}

Následně si necháme vygenerovat texturu s rozlišením pouhých 16×16 texelů:

const textureWidth = 16
const textureHeight = 16
 
// textura
textureArray = makeTexture(textureWidth, textureHeight);

Výsledek pokrytí stěny (dvou trojúhelníků) takovou texturou je dostupný na stránce https://tisnik.github.io/tem­p/textures8.html.

Bilineární interpolace

Zvětšování rastrových obrázků tak, aby lidský zrak zaznamenal co nejmenší vizuální chyby, je poměrně rozsáhlá problematika. Vlastně se v ní snažíme do obrázku přidat další detaily, ke kterým ovšem nemáme příslušné informace. Většina triků, která se používá, spočívá v odstranění hran, které vznikají při naivním zvětšování jednotlivých pixelů (původní ploška s konstantní barvou se tedy zvětšuje). Tyto hrany jsou pro lidský zrak rušivé. Nejrychlejší je lineární interpolace mezi dvěma sousedními pixely. Ovšem vzhledem k tomu, že provádíme zobrazení 2D mřížky, musí se provádět interpolace jak ve směru osy x, tak i ve směru osy y. Z tohoto důvodu se používá termín bilineární interpolace. A ta je podporována i v Open GL (ES) při nanášení textur. Povoluje se ovšem v prostoru textury, tedy pro souřadnice u a v. V dalším výpisu se konkrétně jedná o druhý řádek:

// způsob vykreslení textury
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);

Demonstrační příklad: vykreslení textury s využitím bilineární interpolace

Po zapnutí bilineární interpolace při zvětšování texelů (nikoli při jejich zmenšování) se na základě barev čtyř sousedních texelů a uv-souřadnic v texturovacím prostoru vypočte nová barva. U malých textur, které se hodně zvětšují, je výsledek kvůli provedené interpolaci značně rozmazaný, což je ostatně dobře viditelné, pokud si příklad spustíte z adresy

https://tisnik.github.io/tem­p/textures9.html.

Následuje výpis úplného zdrojového kódu tohoto demonstračního příkladu:

const vertexShaderSource = `
    attribute vec2 position;
    attribute vec2 texcoord;
    varying vec2 vTexcoord;
 
    void main() {
        gl_Position = vec4(position, 0, 1);
        vTexcoord = texcoord;
    }
`
 
const fragmentShaderSource = `
    precision mediump float;
    varying vec2 vTexcoord;
    uniform sampler2D texture;
 
    void main() {
        gl_FragColor = texture2D(texture, vTexcoord);
    }
`
 
function print(message) {
    console.log(message);
}
 
function makeTexture(width, height) {
    const array = new Array(width*height*4);
    const divider = width / 8;
 
    let index = 0;
    for (j=0; j<height; j++) {
        for (i=0; i<width; i++) {
            const c = ((i&divider)==0^(j&divider)==0) * 255;
            array[index++] = c;
            array[index++] = 256*i/width;
            array[index++] = 256*j/width;
            array[index++] = 255;            // alfa slozka
        }
    }
    return array;
}
 
// reference na objekt představující kreslicí plátno umístěné na webové stránce
const canvas = document.getElementById("web_gl_canvas");
if (!canvas) {
    throw new Error("Canvas with id 'web_gl_canvas' not found");
}
print("Canvas object retrieved");
 
// vytvoření a získání kontextu WebGL (3D grafika)
const gl = canvas.getContext("webgl");
if (!gl) {
    throw new Error("WebGL is not supported or context creation failed");
}
print("WebGL context created");
 
// vytvoření vertex shaderu
const vertexShader = gl.createShader(gl.VERTEX_SHADER);
if (!vertexShader) {
    throw new Error("Failed to create vertex shader.");
}
print("Vertex shader created");
 
// překlad vertex shaderu
gl.shaderSource(vertexShader, vertexShaderSource);
gl.compileShader(vertexShader);
if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
    const log = gl.getShaderInfoLog(vertexShader);
    gl.deleteShader(vertexShader);
    throw new Error(`Vertex shader compile failed: ${log}`);
}
print("Vertex shader compiled");
 
// vytvoření fragment shaderu
const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
if (!fragmentShader) {
    throw new Error("Failed to create fragment shader.");
}
print("Fragment shader created");
 
// překlad fragment shaderu
gl.shaderSource(fragmentShader, fragmentShaderSource);
gl.compileShader(fragmentShader);
if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
    const log = gl.getShaderInfoLog(fragmentShader);
    gl.deleteShader(fragmentShader);
    throw new Error(`fragment shader compile failed: ${log}`);
}
print("Fragment shader compiled");
 
// registrace obou shaderů
const program = gl.createProgram();
if (!program) {
    throw new Error("Failed to create program.");
}
print("Program created");
 
gl.attachShader(program, vertexShader);
gl.attachShader(program, fragmentShader);
print("Shaders attached to the program");
 
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
    const log = gl.getProgramInfoLog(program);
    gl.deleteProgram(program);
    throw new Error(`Program link failed: ${log}`);
}
print("Program linked");
 
const min_x = -0.9
const max_x = 0.9
const min_y = min_x
const max_y = max_x
 
// souřadnice vrcholů trojúhelníku + souřadnice v prostoru textury
const vertexes = [
  // x, y,   u, v
   min_x, min_y, 0.0, 0.0,
   min_x, max_y, 0.0, 1.0,
   max_x, max_y, 1.0, 1.0,
 
   min_x, min_y, 0.0, 0.0,
   max_x, max_y, 1.0, 1.0,
   max_x, min_y, 1.0, 0.0,
];
 
// buffer, do kterého se překopírují souřadnice bodu
const vertexBuffer = gl.createBuffer();
if (!vertexBuffer) {
    throw new Error("Failed to create buffer.");
}
print("Vertex buffer created");
gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
 
const data = new Float32Array(vertexes);
gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
print("Vertex buffer filled-in by vertexes");
 
// navázání na parametr předávaný do vertex shaderu
const p = gl.getAttribLocation(program, "position");
if (p === -1) {
    throw new Error("Attribute 'position' not found in shader program");
}
print("Attribute 'position' found in shader program")
 
// navázání na parametr předávaný do vertex shaderu
const texLoc = gl.getAttribLocation(program, "texcoord");
if (p === -1) {
    throw new Error("Attribute 'texcoord' not found in shader program");
}
print("Attribute 'texcoord' found in shader program")
 
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(p,
                       2,                                // počet prvků v každém atributu
                       gl.FLOAT,                         // typ prvků
                       gl.FALSE,                         // data nejsou normalizována
                       4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       0                                 // offset
);
gl.enableVertexAttribArray(p);
 
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(texLoc,
                       2,                                // počet prvků v každém atributu
                       gl.FLOAT,                         // typ prvků
                       gl.FALSE,                         // data nejsou normalizována
                       4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       2*Float32Array.BYTES_PER_ELEMENT  // offset
);
gl.enableVertexAttribArray(texLoc);
 
// textura (prozatím primitivní)
const texture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
 
const textureWidth = 16
const textureHeight = 16
 
// textura
textureArray = makeTexture(textureWidth, textureHeight);
const texels = new Uint8Array(textureArray);
 
gl.texImage2D(gl.TEXTURE_2D,      // typ textury: zde 2D textura
              0,                  // úroveň detailu
              gl.RGBA,            // počet barvových komponent (zde 4)
              textureWidth,       // horizontální rozlišení textury
              textureHeight,      // vertikální rozlišení textury
              0,                  // šířka okraje textury
              gl.RGBA,            // formát uložení texelů
              gl.UNSIGNED_BYTE,   // typ každé barvové složky texelu
              texels              // pole texelů
);
 
// způsob vykreslení textury
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
 
// navázání na atribut ve shaderech
const samplerLoc = gl.getUniformLocation(program, "texture");
gl.uniform1i(samplerLoc, 0);
 
// transformace souřadnic: z normalizovaných souřadnic na souřadnice na plátnu
gl.viewport(0, 0, canvas.width, canvas.height);
 
// nastavení barvy pro vymazání barvového bufferu
gl.clearColor(0, 0, 0, 1);
 
// vymazání barvového bufferu
gl.clear(gl.COLOR_BUFFER_BIT);
 
// spuštění programu
gl.useProgram(program);
 
// vykreslení dvojice trojúhelníků
gl.drawArrays(gl.TRIANGLES, 0, 6);

Role alfa složky, kterou obsahují texely

V předchozích článcích o OpenGL ES jsme se již několikrát setkali s formátem používaným při práci s barvami. Barvy jsou v tomto barvovém formátu (resp. přesněji řečeno v barvovém prostoru) popsány s využitím tří barvových složek R (red), G (green) a B (blue). K těmto složkám se často přidává ještě složka čtvrtá, nazývaná A (Alfa). Výsledný barevný model se z tohoto důvodu označuje zkratkou RGBA. Pomocí alfa složky (někdy také nazývané alfa-kanál) lze specifikovat míru průhlednosti resp. neprůhlednosti vybraných objektů nebo jejich plošek. Alfa složku lze také nastavit samostatně pro každý texel ve vykreslované textuře, čehož se využívá při programování mnoha grafických efektů, například výbuchů či „magických jevů“ (a možná je až nadužíván).

Při spuštění programu, který používá pro vykreslování grafickou knihovnu OpenGL, je vliv alfa složky na vykreslovanou plošku ve výchozím nastavení zakázán. Proto, pokud chceme programovat některé grafické efekty, musíme před vykreslením vhodně nastavit režim míchání již nakreslené části scény s nově vykreslovanými tělesy.

Vygenerování textury s nastavenými alfa složkami texelů

Pro ukázku vlivu hodnoty alfa složky jednotlivých texelů na způsob vykreslení textury upravíme funkci pro vyplnění texelů hodnotami RGBA. Namísto šachovnicového vzorku se vypočítá gradientní barvový přechod, ovšem bude se měnit alfa složka texelů tvořících bloky 8×8 texelů. U sousedních bloků se bude alfa složka měnit z hodnoty 0 na 255 a naopak:

function makeTexture(width, height) {
    const array = new Array(width*height*4);
    const divider = width / 8;
 
    let index = 0;
    for (j=0; j<height; j++) {
        for (i=0; i<width; i++) {
            const alpha = ((i&divider)==0^(j&divider)==0) * 255;
            array[index++] = 128;
            array[index++] = 256*i/width;
            array[index++] = 256*j/width;
            array[index++] = alpha;            // alfa slozka
        }
    }
    return array;
}

Textura se zkonstruuje následujícím způsobem:

gl.texImage2D(gl.TEXTURE_2D,      // typ textury: zde 2D textura
              0,                  // úroveň detailu
              gl.RGBA,            // počet barvových komponent (zde 4)
              textureWidth,       // horizontální rozlišení textury
              textureHeight,      // vertikální rozlišení textury
              0,                  // šířka okraje textury
              gl.RGBA,            // formát uložení texelů
              gl.UNSIGNED_BYTE,   // typ každé barvové složky texelu
              texels              // pole texelů
);
Poznámka: povšimněte si, že se skutečně používá formát RGBA.

Demonstrační příklad: vykreslení textury s texely ve formáty RGBA obsahující různé hodnoty alfa složky

V dalším demonstračním příkladu se pokusíme o vykreslení stěny, na kterou je nanesena textura s texely ve formátu RGBA. Tyto texely mají alfa složku nastavenou na hodnotu 0 či 255. Příklad je dostupný na adrese https://tisnik.github.io/tem­p/texturesA.html.

Povšimněte si, že průhlednost v tomto případě není vypočtena korektně, protože přes průhledné texely by měla „prosvítat“ barva pozadí. Důvodem je fakt, že jsme nepovolili takzvaný blending zmíněný v navazujících kapitolách.

Úplný zdrojový kód tohoto demonstračního příkladu vypadá následovně:

const vertexShaderSource = `
    attribute vec2 position;
    attribute vec2 texcoord;
    varying vec2 vTexcoord;
 
    void main() {
        gl_Position = vec4(position, 0, 1);
        vTexcoord = texcoord;
    }
`
 
const fragmentShaderSource = `
    precision mediump float;
    varying vec2 vTexcoord;
    uniform sampler2D texture;
 
    void main() {
        gl_FragColor = texture2D(texture, vTexcoord);
    }
`
 
function print(message) {
    console.log(message);
}
 
function makeTexture(width, height) {
    const array = new Array(width*height*4);
    const divider = width / 8;
 
    let index = 0;
    for (j=0; j<height; j++) {
        for (i=0; i<width; i++) {
            const alpha = ((i&divider)==0^(j&divider)==0) * 255;
            array[index++] = 128;
            array[index++] = 256*i/width;
            array[index++] = 256*j/width;
            array[index++] = alpha;            // alfa slozka
        }
    }
    return array;
}
 
// reference na objekt představující kreslicí plátno umístěné na webové stránce
const canvas = document.getElementById("web_gl_canvas");
if (!canvas) {
    throw new Error("Canvas with id 'web_gl_canvas' not found");
}
print("Canvas object retrieved");
 
// vytvoření a získání kontextu WebGL (3D grafika)
const gl = canvas.getContext("webgl");
if (!gl) {
    throw new Error("WebGL is not supported or context creation failed");
}
print("WebGL context created");
 
// vytvoření vertex shaderu
const vertexShader = gl.createShader(gl.VERTEX_SHADER);
if (!vertexShader) {
    throw new Error("Failed to create vertex shader.");
}
print("Vertex shader created");
 
// překlad vertex shaderu
gl.shaderSource(vertexShader, vertexShaderSource);
gl.compileShader(vertexShader);
if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
    const log = gl.getShaderInfoLog(vertexShader);
    gl.deleteShader(vertexShader);
    throw new Error(`Vertex shader compile failed: ${log}`);
}
print("Vertex shader compiled");
 
// vytvoření fragment shaderu
const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
if (!fragmentShader) {
    throw new Error("Failed to create fragment shader.");
}
print("Fragment shader created");
 
// překlad fragment shaderu
gl.shaderSource(fragmentShader, fragmentShaderSource);
gl.compileShader(fragmentShader);
if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
    const log = gl.getShaderInfoLog(fragmentShader);
    gl.deleteShader(fragmentShader);
    throw new Error(`fragment shader compile failed: ${log}`);
}
print("Fragment shader compiled");
 
// registrace obou shaderů
const program = gl.createProgram();
if (!program) {
    throw new Error("Failed to create program.");
}
print("Program created");
 
gl.attachShader(program, vertexShader);
gl.attachShader(program, fragmentShader);
print("Shaders attached to the program");
 
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
    const log = gl.getProgramInfoLog(program);
    gl.deleteProgram(program);
    throw new Error(`Program link failed: ${log}`);
}
print("Program linked");
 
const min_x = -0.9
const max_x = 0.9
const min_y = min_x
const max_y = max_x
 
// souřadnice vrcholů trojúhelníku + souřadnice v prostoru textury
const vertexes = [
  // x, y,   u, v
   min_x, min_y, 0.0, 0.0,
   min_x, max_y, 0.0, 1.0,
   max_x, max_y, 1.0, 1.0,
 
   min_x, min_y, 0.0, 0.0,
   max_x, max_y, 1.0, 1.0,
   max_x, min_y, 1.0, 0.0,
];
 
// buffer, do kterého se překopírují souřadnice bodu
const vertexBuffer = gl.createBuffer();
if (!vertexBuffer) {
    throw new Error("Failed to create buffer.");
}
print("Vertex buffer created");
gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
 
const data = new Float32Array(vertexes);
gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
print("Vertex buffer filled-in by vertexes");
 
// navázání na parametr předávaný do vertex shaderu
const p = gl.getAttribLocation(program, "position");
if (p === -1) {
    throw new Error("Attribute 'position' not found in shader program");
}
print("Attribute 'position' found in shader program")
 
// navázání na parametr předávaný do vertex shaderu
const texLoc = gl.getAttribLocation(program, "texcoord");
if (p === -1) {
    throw new Error("Attribute 'texcoord' not found in shader program");
}
print("Attribute 'texcoord' found in shader program")
 
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(p,
                       2,                                // počet prvků v každém atributu
                       gl.FLOAT,                         // typ prvků
                       gl.FALSE,                         // data nejsou normalizována
                       4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       0                                 // offset
);
gl.enableVertexAttribArray(p);
 
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(texLoc,
                       2,                                // počet prvků v každém atributu
                       gl.FLOAT,                         // typ prvků
                       gl.FALSE,                         // data nejsou normalizována
                       4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       2*Float32Array.BYTES_PER_ELEMENT  // offset
);
gl.enableVertexAttribArray(texLoc);
 
// textura (prozatím primitivní)
const texture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
 
const textureWidth = 16
const textureHeight = 16
 
// textura
textureArray = makeTexture(textureWidth, textureHeight);
const texels = new Uint8Array(textureArray);
 
gl.texImage2D(gl.TEXTURE_2D,      // typ textury: zde 2D textura
              0,                  // úroveň detailu
              gl.RGBA,            // počet barvových komponent (zde 4)
              textureWidth,       // horizontální rozlišení textury
              textureHeight,      // vertikální rozlišení textury
              0,                  // šířka okraje textury
              gl.RGBA,            // formát uložení texelů
              gl.UNSIGNED_BYTE,   // typ každé barvové složky texelu
              texels              // pole texelů
);
 
// způsob vykreslení textury
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
 
// navázání na atribut ve shaderech
const samplerLoc = gl.getUniformLocation(program, "texture");
gl.uniform1i(samplerLoc, 0);
 
// transformace souřadnic: z normalizovaných souřadnic na souřadnice na plátnu
gl.viewport(0, 0, canvas.width, canvas.height);
 
// nastavení barvy pro vymazání barvového bufferu
gl.clearColor(0, 0, 0, 1);
 
// vymazání barvového bufferu
gl.clear(gl.COLOR_BUFFER_BIT);
 
// spuštění programu
gl.useProgram(program);
 
// vykreslení dvojice trojúhelníků
gl.drawArrays(gl.TRIANGLES, 0, 6);

Povolení blendingu a určení způsobu výpočtu výsledné barvy fragmentů

Aby se korektně pracovalo s alfa složkami texelů, je nutné povolit a nakonfigurovat blending (tj. míchání barev). Především musíme nejdříve specifikovat, jakým způsobem se budou kombinovat právě vykreslované fragmenty s hodnotami uloženými ve framebufferu.

Poznámka: připomeňme, že fragment je datová struktura složená z barvy pixelu, jeho průhlednosti, vzdálenosti od pozorovatele a případných dalších informací. Framebuffer je v podstatě pravidelná matice fragmentů. Barvy fragmentů tvoří ve framebufferu samostatný color buffer, který se zobrazuje na obrazovce. Rasterizace je proces, kterým se matematický model plošky (polygonu) převádí na jednotlivé fragmenty

Způsob míchání barvy uložené ve framebufferu a barvy vykreslovaného fragmentu se řídí uživatelem definovanou míchací rovnicí (blending function). V této rovnici vystupují následující členy:

  • Zdroj (source) je fragment vzniklý rasterizací v právě běžícím rasterizačním procesu.
  • Cíl (destination) je hodnota zapsaná ve framebufferu, tj. barva fragmentu, který již byl vykreslen dříve. Tato hodnota bude v závislosti na nastavené blending funkci přepsána nebo jinak ovlivněna.

V knihovně OpenGL lze stanovit koeficienty míchání pro každou barevnou složku zvlášť. Tak lze jednoduše dosáhnout na první pohled složitých efektů, například maskování jedné barvy apod.

Míchací rovnice použitá při blendingu

Míchací rovnici (původně zapsanou ve vektorovém tvaru), která se při blendingu používá pro výpočet nové barvy fragmentu, lze rozepsat do čtyř rovnic odpovídajících barvovému modelu RGBA:

Rn=RsSr+RdDr
Gn=GsSg+GdDg
Bn=BsSb+BdDb
An=AsSa+AdDa

Význam jednotlivých členů v těchto čtyřech rovnicích je následující:

Člen Význam
Rn nově vypočtená červená barevná složka
Gn nově vypočtená zelená barevná složka
Bn nově vypočtená modrá barevná složka
An nová hodnota alfa složky
Rs červená barevná složka zdrojového fragmentu
Gs zelená barevná složka zdrojového fragmentu
Bs modrá barevná složka zdrojového fragmentu
As alfa složka zdrojového fragmentu
Rd červená barevná složka cílového fragmentu
Gd zelená barevná složka cílového fragmentu
Bd modrá barevná složka cílového fragmentu
Ad alfa složka cílového fragmentu
Sr míchací faktor pro červenou barvu zdrojového fragmentu
Sg míchací faktor pro zelenou barvu zdrojového fragmentu
Sb míchací faktor pro modrou barvu zdrojového fragmentu
Sa míchací faktor pro alfa složku zdrojového fragmentu
Dr míchací faktor pro červenou barvu cílového fragmentu
Dg míchací faktor pro zelenou barvu cílového fragmentu
Db míchací faktor pro modrou barvu cílového fragmentu
Da míchací faktor pro alfa složku cílového fragmentu

Stačí si však zapamatovat význam jednotlivých písmen: R-red, G-green, B-blue, A-alpha, n-new fragment, s-source fragment, d-destination fragment.

Ve výše uvedených rovnicích je nutné specifikovat míchací faktory (koeficienty) Sr, Sg, Sb, Sa, Dr, Dg, Db a Da, ostatní hodnoty odpovídají barvám a alfa-složkám zdrojových a cílových fragmentů. Koeficienty S a D se nezadávají přímo číselnou hodnotou, protože se mohou měnit v závislosti na barvách zdrojových a cílových fragmentů. Místo toho se používají symboly, jejichž konkrétní hodnota se vypočte automaticky při rasterizaci.

Funkce blendFunc

Pro zadání míchacích koeficientů se v OpenGL (ES) používá funkce:

void gl.blendFunc(GLenum sFactor, GLenum dFactor);

První parametr <tt>sFactor</tt> určuje způsob výpočtu míchacích faktorů Sr, Sg, Sb a Sa, druhý parametr <tt>dFactor</tt> způsob výpočtu faktorů Dr, Dg, Db a Da.

Pro hodnoty, které lze do těchto parametrů dosadit, platí základní pravidla:

  1. Za <tt>sFactor</tt> popř. <tt>dFactor</tt> lze dosadit některou z konstant, které jsou předdefinovány v hlavičkovém souboru gl.h (neplatí pro WebGL).
  2. Některé z těchto konstant lze zadat do obou parametrů. Jedná se například o konstanty GL_ZERO, GL_ONE apod. Význam těchto konstant se samozřejmě liší podle toho, do kterého parametru jsou dosazeny.
  3. Některé konstanty lze použít pouze pro parametr <tt>sFactor</tt>. Jedná se například o konstanty GL_DST_COLOR nebo GL_ONE_MINUS_DST_COLOR.
  4. Další konstanty lze naopak použít pouze pro parametr <tt>dFactor</tt>. Konkrétně se jedná o konstanty GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR apod.

Příklad volby míchací funkce v prostředí využívajícího WebGL:

// povolení blendingu
gl.enable(gl.BLEND);
gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
Poznámka: význam konkrétních konstant je popsán v navazující kapitole.

Význam předpřipravených míchacích faktorů

V následující tabulce je vypsán význam míchacích faktorů, které můžeme použít pro specifikaci koeficientů míchací rovnice. Ve sloupci Název je zapsáno jméno faktoru, tj. symbolická konstanta definovaná v souboru gl.h (opět: neplatí pro prostředí s WebGL). Ve sloupci Použití je označeno, zda se může symbolická konstanta použít pro dosazení do parametru sFactor (S), dFactor (D) nebo do obou parametrů. Ve sloupci Význam jsou ve vektorovém tvaru naznačeny hodnoty zdrojových či cílových koeficientů.

Název Použití Význam
GL_ZERO S nebo D (0, 0, 0, 0)
GL_ONE S nebo D (1, 1, 1, 1)
GL_DST_COLOR S (Rd, Gd, Bd, Ad)
GL_SRC_COLOR D (Rs, Gs, Bs, As)
GL_ONE_MINUS_DST_COLOR S (1, 1, 1, 1)-(Rd, Gd, Bd, Ad)
GL_ONE_MINUS_SRC_COLOR D (1, 1, 1, 1)-(Rs, Gs, Bs, As)
GL_SRC_ALPHA S nebo D (As, As, As, As)
GL_ONE_MINUS_SRC_ALPHA S nebo D (1, 1, 1, 1)-(As, As, As, As)
GL_DST_ALPHA S nebo D (Ad, Ad, Ad, Ad)
GL_ONE_MINUS_DST_ALPHA S nebo D (1, 1, 1, 1)-(Ad, Ad, Ad, Ad)
GL_SRC_ALPHA_SATURATE S (f, f, f, 1)   f=min(As, 1-Ad)
Poznámka: konstanta GL_ZERO se v prostředí WebGL bude zapisovat stylem gl.ZERO atd.

V praxi bude nejtypičtější nastavení s výpočtem průhlednosti realizováno následovně:

// povolení blendingu
gl.enable(gl.BLEND);
gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);

Demonstrační příklad: vykreslení textury s texely ve formátu RGBA společně s výpočtem blendingu

V dalším demonstračním příkladu je ukázána nejčastější konfigurace blendingu. Alfa složka textury je použita pro výpočet barvy fragmentu ze dvou složek: původní barvy fragmentu (což je v našem případě barva pozadí) a RGBA složky texelu přečteného z textury. Výsledek je uložen zpět do barvového bufferu.

Ukažme si, jak bude vypadat výsledek v případě, kdy je nastavena černá barva pozadí a některé texely v textuře jsou zcela průhledné. Program pro vykreslení scény je dostupný na adrese https://tisnik.github.io/tem­p/texturesB.html.

Výsledek je tedy korektní – přes průsvitné texely je vidět barva pozadí.

Zdrojový kód tohoto demonstračního příkladu vypadá následovně:

const vertexShaderSource = `
    attribute vec2 position;
    attribute vec2 texcoord;
    varying vec2 vTexcoord;
 
    void main() {
        gl_Position = vec4(position, 0, 1);
        vTexcoord = texcoord;
    }
`
 
const fragmentShaderSource = `
    precision mediump float;
    varying vec2 vTexcoord;
    uniform sampler2D texture;
 
    void main() {
        gl_FragColor = texture2D(texture, vTexcoord);
    }
`
 
function print(message) {
    console.log(message);
}
 
function makeTexture(width, height) {
    const array = new Array(width*height*4);
    const divider = width / 8;
 
    let index = 0;
    for (j=0; j<height; j++) {
        for (i=0; i<width; i++) {
            const alpha = ((i&divider)==0^(j&divider)==0) * 255;
            array[index++] = 128;
            array[index++] = 256*i/width;
            array[index++] = 256*j/width;
            array[index++] = alpha;            // alfa slozka
        }
    }
    return array;
}
 
// reference na objekt představující kreslicí plátno umístěné na webové stránce
const canvas = document.getElementById("web_gl_canvas");
if (!canvas) {
    throw new Error("Canvas with id 'web_gl_canvas' not found");
}
print("Canvas object retrieved");
 
// vytvoření a získání kontextu WebGL (3D grafika)
const gl = canvas.getContext("webgl");
if (!gl) {
    throw new Error("WebGL is not supported or context creation failed");
}
print("WebGL context created");
 
// vytvoření vertex shaderu
const vertexShader = gl.createShader(gl.VERTEX_SHADER);
if (!vertexShader) {
    throw new Error("Failed to create vertex shader.");
}
print("Vertex shader created");
 
// překlad vertex shaderu
gl.shaderSource(vertexShader, vertexShaderSource);
gl.compileShader(vertexShader);
if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
    const log = gl.getShaderInfoLog(vertexShader);
    gl.deleteShader(vertexShader);
    throw new Error(`Vertex shader compile failed: ${log}`);
}
print("Vertex shader compiled");
 
// vytvoření fragment shaderu
const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
if (!fragmentShader) {
    throw new Error("Failed to create fragment shader.");
}
print("Fragment shader created");
 
// překlad fragment shaderu
gl.shaderSource(fragmentShader, fragmentShaderSource);
gl.compileShader(fragmentShader);
if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
    const log = gl.getShaderInfoLog(fragmentShader);
    gl.deleteShader(fragmentShader);
    throw new Error(`fragment shader compile failed: ${log}`);
}
print("Fragment shader compiled");
 
// registrace obou shaderů
const program = gl.createProgram();
if (!program) {
    throw new Error("Failed to create program.");
}
print("Program created");
 
gl.attachShader(program, vertexShader);
gl.attachShader(program, fragmentShader);
print("Shaders attached to the program");
 
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
    const log = gl.getProgramInfoLog(program);
    gl.deleteProgram(program);
    throw new Error(`Program link failed: ${log}`);
}
print("Program linked");
 
const min_x = -0.9
const max_x = 0.9
const min_y = min_x
const max_y = max_x
 
// souřadnice vrcholů trojúhelníku + souřadnice v prostoru textury
const vertexes = [
  // x, y,   u, v
   min_x, min_y, 0.0, 0.0,
   min_x, max_y, 0.0, 1.0,
   max_x, max_y, 1.0, 1.0,
 
   min_x, min_y, 0.0, 0.0,
   max_x, max_y, 1.0, 1.0,
   max_x, min_y, 1.0, 0.0,
];
 
// buffer, do kterého se překopírují souřadnice bodu
const vertexBuffer = gl.createBuffer();
if (!vertexBuffer) {
    throw new Error("Failed to create buffer.");
}
print("Vertex buffer created");
gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
 
const data = new Float32Array(vertexes);
gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
print("Vertex buffer filled-in by vertexes");
 
// navázání na parametr předávaný do vertex shaderu
const p = gl.getAttribLocation(program, "position");
if (p === -1) {
    throw new Error("Attribute 'position' not found in shader program");
}
print("Attribute 'position' found in shader program")
 
// navázání na parametr předávaný do vertex shaderu
const texLoc = gl.getAttribLocation(program, "texcoord");
if (p === -1) {
    throw new Error("Attribute 'texcoord' not found in shader program");
}
print("Attribute 'texcoord' found in shader program")
 
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(p,
                       2,                                // počet prvků v každém atributu
                       gl.FLOAT,                         // typ prvků
                       gl.FALSE,                         // data nejsou normalizována
                       4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       0                                 // offset
);
gl.enableVertexAttribArray(p);
 
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(texLoc,
                       2,                                // počet prvků v každém atributu
                       gl.FLOAT,                         // typ prvků
                       gl.FALSE,                         // data nejsou normalizována
                       4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       2*Float32Array.BYTES_PER_ELEMENT  // offset
);
gl.enableVertexAttribArray(texLoc);
 
// textura (prozatím primitivní)
const texture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
 
const textureWidth = 16
const textureHeight = 16
 
// textura
textureArray = makeTexture(textureWidth, textureHeight);
const texels = new Uint8Array(textureArray);
 
gl.texImage2D(gl.TEXTURE_2D,      // typ textury: zde 2D textura
              0,                  // úroveň detailu
              gl.RGBA,            // počet barvových komponent (zde 4)
              textureWidth,       // horizontální rozlišení textury
              textureHeight,      // vertikální rozlišení textury
              0,                  // šířka okraje textury
              gl.RGBA,            // formát uložení texelů
              gl.UNSIGNED_BYTE,   // typ každé barvové složky texelu
              texels              // pole texelů
);
 
// způsob vykreslení textury
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
 
// povolení blendingu
gl.enable(gl.BLEND);
gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
 
// navázání na atribut ve shaderech
const samplerLoc = gl.getUniformLocation(program, "texture");
gl.uniform1i(samplerLoc, 0);
 
// transformace souřadnic: z normalizovaných souřadnic na souřadnice na plátnu
gl.viewport(0, 0, canvas.width, canvas.height);
 
// nastavení barvy pro vymazání barvového bufferu
gl.clearColor(0, 0, 0, 1);
 
// vymazání barvového bufferu
gl.clear(gl.COLOR_BUFFER_BIT);
 
// spuštění programu
gl.useProgram(program);
 
// vykreslení dvojice trojúhelníků
gl.drawArrays(gl.TRIANGLES, 0, 6);

Vizuální chyby, které při texturování vznikají

V další kapitole si popíšeme mipmapping. Ten představuje techniku, která je často používaná pro odstranění či alespoň zmenšení některých vizuálních chyb (resp. přesněji řečeno nežádoucích rozdílů mezi jednotlivými snímky) vzniklých při pohybu těles s nanesenou texturou v trojrozměrné scéně nebo při pohybu celé scény (tj. změně orientace nebo pozice pozorovatele). Obraz těles s nanesenou texturou se na obrazovce při pohybu zmenšuje, zvětšuje či jinak deformuje, čímž také dochází k nutnosti zvětšování a zmenšování textury při nanášení texelů (rastrových elementů textury) na zobrazované pixely.

Při zvětšování a zmenšování textury můžeme pro zamezení některých vizuálních chyb využít filtraci. Nejrychlejšího zobrazení scény však dosáhneme vypnutím filtrace a výběrem vždy pouze jednoho nejbližšího texelu z textury pro každý vykreslovaný pixel:

gl.texParameteri(TEXTURE_2D,
                 TEXTURE_MAG_FILTER,
                 NEAREST);
gl.texParameteri(TEXTURE_2D,
                 TEXTURE_MIN_FILTER,
                 NEAREST);

Předchozí způsob je sice nejrychlejší, současně však žádným způsobem neřeší vznik artefaktů, například moaré, způsobeného podvzorkováním obrazu. V OpenGL lze využít několika způsobů, které zamezují vznikům těchto artefaktů při zvětšování a zejména zmenšování textur. Pokud se vykresluje statická scéna, je možné použít pouze vhodné filtrace, pracující na principu výběru několika sousedních texelů a jejich bilineární interpolaci při výpočtu barvy vykreslovaného pixelu:

gl.texParameteri(TEXTURE_2D,
                 TEXTURE_MAG_FILTER,
                 LINEAR);
gl.texParameteri(TEXTURE_2D,
                 TEXTURE_MIN_FILTER,
                 LINEAR);

Nevýhodou předchozího způsobu je ovšem určité zpomalení vykreslování, zejména díky faktu, že se musí provádět více přístupů do texturovací paměti, která v dnešní době představuje úzké hrdlo grafických akcelerátorů (rychlost použitých pamětí na grafických akcelerátorech roste mnohem pomaleji než výpočetní výkon použitých grafických procesorů – GPU).

V některých případech, zejména při požadavku na vyšší kvalitu obrázků, je možné použít antialiasing, který se v OpenGL provádí tak, že se scéna vykreslí ve vyšším rozlišení než je rozlišení obrazovky a poté se provede snížení rozlišení pomocí filtrace s vhodným jádrem filtru (kernelem).

Při animacích však kromě moaré vznikají i další artefakty z nichž nejviditelnější je „problikávání“ pixelů na příliš zmenšených texturách, tj. například texturách nanesených na vzdálených objektech. V těchto případech už běžná filtrace (pracující pouze pro těsné okolí nanášených texelů) není příliš prospěšná, protože s každým pohybem otexturovaného tělesa se může v rovině textury provést posun až o několik desítek texelů, čímž dochází k prudké změně vykreslované barvy.

Textury s více úrovněmi detailu

Pro zamezení problikávání se používají textury uložené ve více rozlišeních (tj. úrovních detailu). Při vykreslování otexturovaného povrchu se nejdříve zjistí relativní velikost povrchu vůči celé textuře a poté se vybere vhodné rozlišení textury, která se posléze nanese. Tento postup má nevýhodu v tom, že při postupném zmenšování objektu by docházelo ke skokové změně textury (přešlo by se k menšímu rozlišení textury). Proto se zavádí další úroveň interpolace, kdy se vybere nejbližší větší a nejbližší menší textura a barva pixelů se vypočte interpolací mezi těmito dvěma texturami.

Nyní tedy zbývá pouze volba vhodného rozlišení textur. Z hlediska implementace interpolátoru na grafickém akcelerátoru je nejvýhodnější, aby se rozlišení textury v horizontálním i vertikálním směru snižovalo vždy na polovinu. Počet texelů je v každé následující textuře zmenšen na čtvrtinu až do dosažení textury o velikosti 1×1 texel. Výsledná struktura představující texturu s různými úrovněmi detailů se nazývá mipmapa.

Podpora mipmap v OpenGL

V grafické knihovně OpenGL jsou mipmapy samozřejmě také podporovány, protože se jedná o velmi často používanou vykreslovací pomůcku. Pro každé nastavované rozlišení textury je zapotřebí zavolat již dříve popsanou funkci:

gl.texImage2D(gl.TEXTURE_2D,      // typ textury: zde 2D textura
              level,              // úroveň detailu
              gl.RGBA,            // počet barvových komponent (zde 4)
              textureWidth,       // horizontální rozlišení textury
              textureHeight,      // vertikální rozlišení textury
              0,                  // šířka okraje textury
              gl.RGBA,            // formát uložení texelů
              gl.UNSIGNED_BYTE,   // typ každé barvové složky texelu
              texels              // pole texelů
);

kde se do parametru level zadává úroveň textury v hierarchii. Nulou specifikujeme texturu se základním (tj. nejvyšším) rozlišením, jedničkou texturu s rozlišením polovičním atd. V texturovací paměti grafického akcelerátoru se postupným voláním gl.texImage2D vytvoří takzvaná mipmapa, tj. textura, ve které jsou uloženy všechny velikosti textur rozdělených na jednotlivé barevné složky RGB.

Školení Hacking

Praktické použití mipmap bude ukázáno v navazujícím článku.

Repositář s demonstračními příklady

Všechny demonstrační příklady, které jsme si v předchozí šestici článků i v dnešním článku ukázali, je možné spustit přímo ve webovém prohlížeči přes odkazy uvedené v tabulce pod tímto odstavcem. Doplněny jsou i odkazy na zdrojové kódy psané v JavaScriptu (ty se automaticky načítají do HTML stránek):

# Příklad Stručný popis Adresa příkladu
1 step1.html webová stránka s kreslicím plátnem (canvasem) https://tisnik.github.io/tem­p/step1.html
2 step1.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/step1.js
     
3 step2.html využití kreslicího plátna s 2D kontextem https://tisnik.github.io/tem­p/step2.html
4 step2.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/step2.js
     
5 step3.html vymazání barvového bufferu pro kontext WebGL https://tisnik.github.io/tem­p/step3.html
6 step3.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/step3.js
     
7 step4.html transformace souřadnic: z normalizovaných souřadnic na souřadnice na plátnu https://tisnik.github.io/tem­p/step4.html
8 step4.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/step4.js
     
9 step5.html vykreslení jediného bodu na plátno v kontextu WebGL https://tisnik.github.io/tem­p/step5.html
10 step5.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/step5.js
     
11 step6.html vykreslení bodu s určením jeho souřadnic ve scéně https://tisnik.github.io/tem­p/step6.html
12 step6.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/step6.js
     
13 step7.html vykreslení většího množství bodů do scény https://tisnik.github.io/tem­p/step7.html
14 step7.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/step7.js
     
15 step8.html kontrola provedení jednotlivých operací https://tisnik.github.io/tem­p/step8.html
16 step8.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/step8.js
     
17 step9.html vykreslení trojice úseček na plochu kreslicího plátna https://tisnik.github.io/tem­p/step9.html
18 step9.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/step9.js
     
19 stepA.html nastavení konstantní barvy úseček https://tisnik.github.io/tem­p/stepA.html
20 stepA.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/stepA.js
     
21 stepB.html vykreslení na sebe navazujících úseček s předáním souřadnic https://tisnik.github.io/tem­p/stepB.html
22 stepB.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/stepB.js
     
23 stepC.html vykreslení uzavřené sekvence úseček s předáním souřadnic https://tisnik.github.io/tem­p/stepC.html
24 stepC.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/stepC.js
     
25 stepD.html vykreslení bodů, každý bod může mít libovolnou barvu https://tisnik.github.io/tem­p/stepD.html
26 stepD.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/stepD.js
     
27 stepE.html vykreslení úseček, barva je vypočtena interpolací barev https://tisnik.github.io/tem­p/stepE.html
28 stepE.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/stepE.js
     
29 triangle1.html vykreslení trojúhelníku konstantní barvou https://tisnik.github.io/tem­p/triangle1.html
30 triangle1.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/triangle1.js
     
31 triangle2.html interpolace barev při vyplňování trojúhelníku https://tisnik.github.io/tem­p/triangle2.html
32 triangle2.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/triangle2.js
     
33 triangle3.html vykreslení pásu trojúhelníků https://tisnik.github.io/tem­p/triangle3.html
34 triangle3.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/triangle3.js
     
35 triangle4.html vykreslení trsu trojúhelníků – neúplná varianta https://tisnik.github.io/tem­p/triangle4.html
36 triangle4.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/triangle4.js
     
37 triangle5.html vykreslení trsu trojúhelníků – úplná varianta https://tisnik.github.io/tem­p/triangle5.html
38 triangle5.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/triangle5.js
     
39 triangle6.html překrývající se trojúhelníky (Z-buffer není použit) https://tisnik.github.io/tem­p/triangle6.html
40 triangle6.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/triangle6.js
     
41 triangle7.html překrývající se trojúhelníky (Z-buffer je použit) https://tisnik.github.io/tem­p/triangle7.html
42 triangle7.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/triangle7.js
     
43 cube1.html 3D krychle vykreslená do 2D plochy bez aplikace transformací https://tisnik.github.io/tem­p/cube1.html
44 cube1.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/cube1.js
     
45 cube2.html transformace reprezentovaná jednotkovou maticí https://tisnik.github.io/tem­p/cube2.html
46 cube2.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/cube2.js
     
47 cube3.html zobrazení 3D kostky z různých úhlů pohledu https://tisnik.github.io/tem­p/cube3.html
48 cube3.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/cube3.js
     
49 cube4.html zobrazení 3D kostky s využitím základní perspektivní projekce https://tisnik.github.io/tem­p/cube4.html
50 cube4.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/cube4.js
     
51 cube5.html krychle v 3D prostoru https://tisnik.github.io/tem­p/cube5.html
52 cube5.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/cube5.js
     
53 cube6.html rotace krychle v 3D prostoru s perspektivní projekcí https://tisnik.github.io/tem­p/cube6.html
54 cube6.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/cube6.js
     
55 cube7.html animace rotace krychle složené z hran (úseček) v 3D prostoru s perspektivní projekcí https://tisnik.github.io/tem­p/cube7.html
56 cube7.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/cube7.js
     
57 cube8.html animace rotace krychle složené z trojúhelníků v 3D prostoru s perspektivní projekcí https://tisnik.github.io/tem­p/cube8.html
58 cube8.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/cube8.js
     
59 cube9.html animace rotace krychle složené z trojúhelníků v 3D prostoru s perspektivní projekcí a povolením paměti hloubky https://tisnik.github.io/tem­p/cube9.html
60 cube9.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/cube9.js
     
60 cubeA.html změna vzdálenosti bližší pohledové roviny https://tisnik.github.io/tem­p/cubeA.html
61 cubeA.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/cubeA.js
     
62 cubeB.html doplnění rotující krychle o obě chybějící stěny https://tisnik.github.io/tem­p/cubeB.html
63 cubeB.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/cubeB.js
     
64 texsize.html zjištění maximálního rozlišení textury https://tisnik.github.io/tem­p/texsize.html
65 texsize.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/texsize.js
     
66 texture1.html textura namapovaná na jediný trojúhelník https://tisnik.github.io/tem­p/texture1.html
67 texture1.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/texture1.js
     
68 texture2.html textura namapovaná na dvojici trojúhelníků tvořících čtvercovou stěnu https://tisnik.github.io/tem­p/texture2.html
69 texture2.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/texture2.js
     
70 texture3.html jednoduchá procedurální textura https://tisnik.github.io/tem­p/texture3.html
71 texture3.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/texture3.js
     
72 texture4.html modifikace UV souřadnic textury https://tisnik.github.io/tem­p/texture4.html
73 texture4.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/texture4.js
     
74 texture5.html textura načtená z rastrového obrázku https://tisnik.github.io/tem­p/texture5.html
75 texture5.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/texture5.js
     
76 texture6.html opakování textury na povrchu těles https://tisnik.github.io/tem­p/texture6.html
77 texture6.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/texture6.js
     
78 texture7.html kombinace opakování textury v jednom směru s prodloužením okraje ve směru jiném https://tisnik.github.io/tem­p/texture7.html
79 texture7.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/texture7.js
     
80 texture8.html textura s malým rozlišením vykreslená bez bilineární filtrace https://tisnik.github.io/tem­p/texture8.html
81 texture8.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/texture8.js
     
82 texture9.html textura s malým rozlišením vykreslená s bilineární filtrací https://tisnik.github.io/tem­p/texture9.html
83 texture9.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/texture9.js
     
84 textureA.html textura s průhlednými texely, ovšem vykreslená bez povolení blendingu https://tisnik.github.io/tem­p/textureA.html
85 textureA.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/textureA.js
     
86 textureB.html textura s průhlednými texely vykreslená s povolením blendingu https://tisnik.github.io/tem­p/textureB.html
87 textureB.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/textureB.js

Odkazy na Internetu

  1. WebGL: 3D Graphics for the Web
    https://www.khronos.org/webgl/
  2. OpenGL Shading Language
    https://en.wikipedia.org/wi­ki/OpenGL_Shading_Language
  3. WebGL (Wikipedia)
    https://en.wikipedia.org/wiki/WebGL
  4. WebGL
    https://wikis.khronos.org/web­gl/Main_Page
  5. OpenGL ES (Wikipedia)
    https://en.wikipedia.org/wi­ki/OpenGL_ES
  6. Float32Array
    https://developer.mozilla.org/en-US/docs/Web/JavaScript/Re­ference/Global_Objects/Flo­at32Array
  7. ECMAScript compatibility table
    https://compat-table.github.io/compat-table/es6/
  8. Learn-OpenGLES-Tutorials
    https://github.com/learnopengles/Learn-OpenGLES-Tutorials
  9. Implement OpenGL ES and EGL
    https://source.android.com/doc­s/core/graphics/implement-opengl-es
  10. Khronos Group
    https://www.khronos.org/
  11. Khronos Group (Wikipedia)
    https://en.wikipedia.org/wi­ki/Khronos_Group
  12. Raspberry Pi VideoCore APIs
    http://elinux.org/Raspberry_Pi_Vi­deoCore_APIs
  13. EGL quick reference card
    https://www.khronos.org/files/egl-1–4-quick-reference-card.pdf
  14. EGL Reference Pages Index
    https://www.khronos.org/re­gistry/egl/sdk/docs/man/html/in­dexflat.php
  15. GLSL
    https://glsl.app/
  16. Shader Tutorials by Ronja
    https://www.ronja-tutorials.com/
  17. CanvasRenderingContext2D
    https://developer.mozilla.org/en-US/docs/Web/API/CanvasRen­deringContext2D
  18. WebGL2RenderingContext
    https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext
  19. WebGLRenderingContext
    https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext
  20. Matrix Transformations
    https://vitaminac.github.io/Matrices-in-Computer-Graphics/
  21. Homogeneous coordinates
    https://en.wikipedia.org/wi­ki/Homogeneous_coordinates
  22. Transformation matrix
    https://en.wikipedia.org/wi­ki/Transformation_matrix
  23. Affine transformation
    https://en.wikipedia.org/wi­ki/Affine_transformation
  24. OpenGL Projection Matrix
    https://songho.ca/opengl/gl_pro­jectionmatrix.html
  25. Texture mapping
    https://en.wikipedia.org/wi­ki/Texture_mapping
  26. UV mapping
    https://en.wikipedia.org/wi­ki/UV_mapping
  27. UV Coordinates explained
    https://blog.nobel-joergensen.com/2011/04/05/procedural-generated-mesh-in-unity-part-2-with-uv-mapping/
  28. Introduction to texture mapping
    http://www.decew.net/OSS/Re­ferences/chapter_2_texture_map­ping.pdf
  29. Alfa kanál
    https://cs.wikipedia.org/wi­ki/Alfa_kan%C3%A1l
  30. Blending
    https://learnopengl.com/Advanced-OpenGL/Blending
  31. Blending (OpenGL wiki)
    https://wikis.khronos.org/o­pengl/Blending
Neutrální ikona do widgetu na odběr článků ze seriálů

Zajímá vás toto téma? Chcete se o něm dozvědět víc?

Objednejte si upozornění na nově vydané články do vašeho mailu. Žádný článek vám tak neuteče.


Autor článku

Vystudoval VUT FIT a v současné době pracuje na projektech vytvářených v jazycích Python a Go.