Využití textur ve WebGL a OpenGL ES: vykreslení 3D objektu s texturou

3D konvička wireframe
Autor: Hay Kranen, Wikimedia, podle licence: CC-BY
Dnes si ukážeme způsob interaktivní změny zobrazení textur, včetně volby blendingu. Následně zkombinujeme dvě operace: vykreslení 3D tělesa z trojúhelníků a vykreslení otexturovaných trojúhelníků.

Na dvojici článků Využití textur ve WebGL a OpenGL ES a Využití textur ve WebGL a OpenGL ES: zvětšování, zmenšování a blending dnes navážeme, protože si ukážeme další možnosti nanášení 2D textur na plochy tvořící povrch těles.

Co se dozvíte v článku
  1. Interaktivní změna parametrů textury
  2. Reakce skriptu na změnu parametrů provedených na webové stránce
  3. Úplný zdrojový kód prvního demonstračního příkladu
  4. Vliv alfa složky texelů na způsob zobrazení textury
  5. Nový ovládací prvek na webové stránce ovlivňující maximální hodnotu alfa složky
  6. Úprava funkce pro výpočet texelů v textuře
  7. Úplný zdrojový kód druhého demonstračního příkladu
  8. Textury nanesené na plochy v 3D prostoru: pole obsahující světové souřadnice i souřadnice v prostoru textury
  9. Způsob předání světových 3D souřadnic a souřadnic v prostoru textury
  10. Úplný zdrojový kód třetího demonstračního příkladu
  11. Pole se souřadnicemi vrcholů krychle i s u-v souřadnicemi v prostoru textury
  12. Funkce pro vykreslení rotující krychle, jejíž stěny jsou pokryty texturou
  13. Úplný zdrojový kód čtvrtého demonstračního příkladu
  14. Interaktivní konfigurace blendingu s modifikací alfa složky textury
  15. Úplný zdrojový kód pátého demonstračního příkladu
  16. Z jakého důvodu dochází při vykreslování předchozího příkladu k viditelným chybám?
  17. Obsah navazujícího článku: plně programovatelný vykreslovací řetězec
  18. Repositář s demonstračními příklady
  19. Odkazy na Internetu

Nejdříve si ukážeme, jakým způsobem je možné interaktivně měnit způsob zobrazení textur (včetně volby blendingu, tj. míchací rovnice) a následně zkombinujeme dvě operace, které jsme prozatím realizovali každou zvlášť: vykreslení 3D tělesa složeného z trojúhelníků a vykreslení otexturovaných trojúhelníků.

Krychle s plochami vyplněnými konstantní barvou.

Obrázek 1: Krychle se stěnami vyplněnými konstantní barvou.

Autor: tisnik, podle licence: Rights Managed

Závěrečná část článku bude věnována problematice zobrazení plošek (trojúhelníků) pokrytých texturou s průhlednými nebo poloprůhlednými texely. V tomto případě je totiž nutné scénu zobrazovat ve dvou krocích: nejprve se zobrazí neprůhledné plošky se zapnutou pamětí hloubky a následně se zobrazí (polo)průhledné plošky, ovšem do paměti hloubky bude zakázán zápis. Navíc je nutné tyto plošky správně seřadit.

Dvojice trojúhelníků pokrytá texturou.

Obrázek 2: Dvojice trojúhelníků pokrytá texturou.

Autor: tisnik, podle licence: Rights Managed

Interaktivní změna parametrů textury

Změnu parametrů zobrazení textur lze v případě potřeby provádět interaktivně. Ostatně to je i jeden z důvodů, proč si možnosti knihovny OpenGL ES vysvětlujeme společně s technologií WebGL – tvorba (jednoduchého) grafického uživatelského rozhraní je v tomto případě snadná, a to bez nutnosti instalace dalších vývojářských verzí GTK či Qt. V dnešním prvním demonstračním příkladu budeme chtít interaktivně povolit či zakázat blending (míchání), vybrat vhodnou míchací rovnici a taktéž nastavit barvu pozadí (namísto černé libovolnou jinou barvu, včetně alfa složky). Samotný design stránky nás nebude trápit, takže se spokojíme s následujícími ovládacími prvky:

Interaktivní ovládací prvky ovlivňující způsob zobrazení textury v prvním demonstračním příkladu.

Obrázek 3: Interaktivní ovládací prvky ovlivňující způsob zobrazení textury v prvním demonstračním příkladu.

Autor: tisnik, podle licence: Rights Managed

Do webové stránky kromě kreslicího plátna vložíme i další ovládací prvky, konkrétně zatrhávací tlačítko pro povolení blendingu, dvojici výběrových boxů pro volbu míchací rovnice a čtveřici posuvníků pro změnu barvy pozadí (RGB, ovšem včetně průhlednosti). Povšimněte si, že všechny ovládací prvky reagují na operace provedené uživatelem – zavolají totiž JavaScriptovou funkci draw:

<!doctype html>
<html>
    <head>
        <title>WebGL: texturesC</title>
    </head>
    <body>
        <!-- kreslicí plátno -->
        <canvas id="web_gl_canvas" width="256" height="256"></canvas>
 
        <br />
 
        <label>
            <span>Blending enabled</span>
            <input type="checkbox" id="enable_blending" onchange="draw()">
        </label>
 
        <br />
 
        <label>
            <span>Blending function #1</span>
            <select id="blending_func_1" onchange="draw()">
                <option value="ZERO">ZERO</option>
                <option value="ONE">ONE</option>
                <option value="SRC_ALPHA" selected>SRC_ALPHA</option>
                <option value="SRC_ALPHA_SATURATE">SRC_ALPHA_SATURATE</option>
                <option value="ONE_MINUS_SRC_ALPHA">ONE_MINUS_SRC_ALPHA</option>
                <option value="DST_ALPHA">DST_ALPHA</option>
                <option value="ONE_MINUS_DST_ALPHA">ONE_MINUS_DST_ALPHA</option>
                <option value="DST_COLOR">DST_COLOR</option>
                <option value="ONE_MINUS_DST_COLOR">ONE_MINUS_DST_COLOR</option>
            </select>
        </label>
 
        <br />
 
        <label>
            <span>Blending function #2</span>
            <select id="blending_func_2" onchange="draw()">
                <option value="ZERO">ZERO</option>
                <option value="ONE">ONE</option>
                <option value="SRC_COLOR">SRC_COLOR</option>
                <option value="ONE_MINUS_SRC_COLOR">ONE_MINUS_SRC_COLOR</option>
                <option value="SRC_ALPHA">SRC_ALPHA</option>
                <option value="ONE_MINUS_SRC_ALPHA" selected>ONE_MINUS_SRC_ALPHA</option>
                <option value="DST_ALPHA">DST_ALPHA</option>
                <option value="ONE_MINUS_DST_ALPHA">ONE_MINUS_DST_ALPHA</option>
            </select>
        </label>
 
        <br />
 
        <label>
            <span>R</span>
            <input type="range" id="r" min="0" max="1" step="0.01" value="0" onchange="draw()">
        </label>
 
        <br />
 
        <label>
            <span>G</span>
            <input type="range" id="g" min="0" max="1" step="0.01" value="0" onchange="draw()">
        </label>
 
        <br />
 
        <label>
            <span>B</span>
            <input type="range" id="b" min="0" max="1" step="0.01" value="0" onchange="draw()">
        </label>
 
        <br />
 
        <label>
            <span>A</span>
            <input type="range" id="a" min="0" max="1" step="0.01" value="1" onchange="draw()">
        </label>
 
        <!-- skript, který kreslicí plátno využije -->
        <script type="application/javascript" src="texturesC.js"></script>
 
    </body>
</html>

Reakce skriptu na změnu parametrů provedených na webové stránce

Skript, který realizuje vykreslení dvou trojúhelníků pokrytých texturou, pochopitelně musí nějakým způsobem reagovat na změny nastavení provedené uživatelem na webové stránce. Příkladem je povolení blendingu:

Povoleni blendingu.

Obrázek 4: Povoleni blendingu.

Autor: tisnik, podle licence: Rights Managed

Modifikace míchací rovnice.

Obrázek 5: Modifikace míchací rovnice.

Autor: tisnik, podle licence: Rights Managed

Vzhledem k tomu, že v příkladech schválně nepoužívám žádné pomocné knihovny (jQuery) ani frameworky, musíme si vystačit se základním JavaScriptem doplněného o API poskytovaného webovým prohlížečem. Příkladem je přečtení stavu zatrhávacího tlačítka (boxu), které lze realizovat takto:

// přečíst parametry nastavené na formuláti
const enable_blending = document.getElementById("enable_blending").checked;
 
// povolení či zákaz blendingu
if (enable_blending) {
    gl.enable(gl.BLEND);
} else {
    gl.disable(gl.BLEND);
}

Zajímavější je nastavení míchací rovnice. Nejprve přečteme hodnoty vybrané uživatelem z obou výběrových seznamů. Získáme tak dvojici řetězců. Ovšem tyto řetězce jsou vhodně pojmenovány takovým způsobem, aby sloužily jako klíč do pseudoslovníku implementovaného objektem gl. Tento objekt totiž například umožňuje zápisem:

gl["ONE_MINUS_SRC_ALPHA"]

získat konstantu gl.ONE_MINUS_SRC_ALPHA.

Operace nastavení míchací rovnice je tedy ve skutečnosti velmi snadná:

// nastavení blending operace
const blending_func_1_value = document.getElementById("blending_func_1").value;
const blending_func_2_value = document.getElementById("blending_func_2").value;
 
const blending_func_1 = gl[blending_func_1_value];
const blending_func_2 = gl[blending_func_2_value];
 
// nastavení blendingu
gl.blendFunc(blending_func_1, blending_func_2);

Nastavení barvy, kterou se vymaže barvový buffer, je ještě snadnější, protože postačuje přečíst hodnoty všech čtyř posuvníků. Načtené hodnoty jsou v očekávaném rozsahu a mají i korektní typ, takže řešení je velmi jednoduché:

// barva na kterou se vymaže pozadí před vykreslením textury
const r = document.getElementById("r").value;
const g = document.getElementById("g").value;
const b = document.getElementById("b").value;
const a = document.getElementById("a").value;
 
    // nastavení barvy pro vymazání barvového bufferu
    gl.clearColor(r, g, b, a);

Úplný zdrojový kód prvního demonstračního příkladu

Dnešní první demonstrační příklad, jenž byl popsán v předchozích kapitolách, si můžete otestovat na adrese https://tisnik.github.io/tem­p/texturesC.html. Následuje výpis celého zdrojového kódu tohoto 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 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);
 
 
 
function draw() {
    // přečíst parametry nastavené na formuláti
    const enable_blending = document.getElementById("enable_blending").checked;
 
    // nastavení blending operace
    const blending_func_1_value = document.getElementById("blending_func_1").value;
    const blending_func_2_value = document.getElementById("blending_func_2").value;
 
    const blending_func_1 = gl[blending_func_1_value];
    const blending_func_2 = gl[blending_func_2_value];
 
    // barva na kterou se vymaže pozadí před vykreslením textury
    const r = document.getElementById("r").value;
    const g = document.getElementById("g").value;
    const b = document.getElementById("b").value;
    const a = document.getElementById("a").value;
 
    // povolení či zákaz blendingu
    if (enable_blending) {
        gl.enable(gl.BLEND);
    } else {
        gl.disable(gl.BLEND);
    }
    // nastavení blendingu
    gl.blendFunc(blending_func_1, blending_func_2);
 
    // 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(r, g, b, a);
 
    // 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);
}
 
draw(false);

Vliv alfa složky texelů na způsob zobrazení textury

Některé varianty míchací rovnice pracují s alfa složkami texelů textury popř. s alfa složkami fragmentů uložených v barvovém bufferu (color buffer):

Název Použití Význam
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)

Textura se šachovnicí prozatím obsahuje texely, které jsou buď zcela neprůhledné nebo naopak zcela průhledné. Bude tedy vhodné upravit demonstrační příklad takovým způsobem, aby bylo možné průhlednost, resp. přesněji řečeno maximální průhlednost, interaktivně modifikovat. Do webové stránky tedy přidáme další ovládací prvek (posuvník):

Interaktivní ovládací prvky ovlivňující způsob zobrazení textury ve druhém demonstračním příkladu.

Obrázek 6: Interaktivní ovládací prvky ovlivňující způsob zobrazení textury ve druhém demonstračním příkladu.

Autor: tisnik, podle licence: Rights Managed

Nový ovládací prvek na webové stránce ovlivňující maximální hodnotu alfa složky

Přidání dalšího ovládacího prvku na plochu webové stránky je ve skutečnosti triviální:

<label>
    <span>Checker max alpha</span>
    <input type="range" id="max_alpha" min="0" max="255" step="1" value="255" onchange="draw()">
</label>

Úplný zdrojový kód stránky se změní do následující podoby:

<!doctype html>
<html>
    <head>
        <title>WebGL: texturesD</title>
    </head>
    <body>
        <!-- kreslicí plátno -->
        <canvas id="web_gl_canvas" width="256" height="256"></canvas>
 
        <br />
 
        <label>
            <span>Blending enabled</span>
            <input type="checkbox" id="enable_blending" onchange="draw()">
        </label>
 
        <br />
 
        <label>
            <span>Blending function #1</span>
            <select id="blending_func_1" onchange="draw()">
                <option value="ZERO">ZERO</option>
                <option value="ONE">ONE</option>
                <option value="SRC_ALPHA" selected>SRC_ALPHA</option>
                <option value="SRC_ALPHA_SATURATE">SRC_ALPHA_SATURATE</option>
                <option value="ONE_MINUS_SRC_ALPHA">ONE_MINUS_SRC_ALPHA</option>
                <option value="DST_ALPHA">DST_ALPHA</option>
                <option value="ONE_MINUS_DST_ALPHA">ONE_MINUS_DST_ALPHA</option>
                <option value="DST_COLOR">DST_COLOR</option>
                <option value="ONE_MINUS_DST_COLOR">ONE_MINUS_DST_COLOR</option>
            </select>
        </label>
 
        <br />
 
        <label>
            <span>Blending function #2</span>
            <select id="blending_func_2" onchange="draw()">
                <option value="ZERO">ZERO</option>
                <option value="ONE">ONE</option>
                <option value="SRC_COLOR">SRC_COLOR</option>
                <option value="ONE_MINUS_SRC_COLOR">ONE_MINUS_SRC_COLOR</option>
                <option value="SRC_ALPHA">SRC_ALPHA</option>
                <option value="ONE_MINUS_SRC_ALPHA" selected>ONE_MINUS_SRC_ALPHA</option>
                <option value="DST_ALPHA">DST_ALPHA</option>
                <option value="ONE_MINUS_DST_ALPHA">ONE_MINUS_DST_ALPHA</option>
            </select>
        </label>
 
        <br />
 
        <label>
            <span>Checker max alpha</span>
            <input type="range" id="max_alpha" min="0" max="255" step="1" value="255" onchange="draw()">
        </label>
 
        <br />
 
        <label>
            <span>R</span>
            <input type="range" id="r" min="0" max="1" step="0.01" value="0" onchange="draw()">
        </label>
 
        <br />
 
        <label>
            <span>G</span>
            <input type="range" id="g" min="0" max="1" step="0.01" value="0" onchange="draw()">
        </label>
 
        <br />
 
        <label>
            <span>B</span>
            <input type="range" id="b" min="0" max="1" step="0.01" value="0" onchange="draw()">
        </label>
 
        <br />
 
        <label>
            <span>A</span>
            <input type="range" id="a" min="0" max="1" step="0.01" value="1" onchange="draw()">
        </label>
 
        <!-- skript, který kreslicí plátno využije -->
        <script type="application/javascript" src="texturesD.js"></script>
 
    </body>
</html>

Úprava funkce pro výpočet texelů v textuře

Připomeňme si, že jsme až doposud počítali barvy texelů v textuře v následující funkci:

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;
}

Této funkci se předává pouze požadované rozlišení textury a výsledkem bude pole obsahující šířka×výška×4 hodnot, protože každý texel je reprezentován čtyřmi prvky (RGBA):

Nově ovšem budeme do funkce předávat ještě hodnotu alfa složky, resp. přesněji řečeno maximální hodnotu – některé texely budou mít alfa složku nulovou a jiné ji budou mít nastavenou právě na hodnotu max_alpha. Zdrojový kód funkce makeTexture se z tohoto důvodu nepatrně změní:

function makeTexture(width, height, max_alpha) {
    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) * max_alpha;
            array[index++] = 128;
            array[index++] = 256*i/width;
            array[index++] = 256*j/width;
            array[index++] = alpha;            // alfa slozka
        }
    }
    return array;
}

Vytvoření textury, předání textury do vykreslovacího řetězce a nastavení parametrů textury (tedy toho, jak se bude textura vykreslovat a jak se budou počítat souřadnice v prostoru textury) zajišťuje funkce nazvaná createTexture:

function createTexture(alpha) {
    // 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, alpha);
    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);
}

Úplný zdrojový kód druhého demonstračního příkladu

Dnešní druhý demonstrační příklad je možné otestovat na adrese https://tisnik.github.io/tem­p/texturesD.html. Jak je v tomto seriálu zvykem, následuje výpis celého zdrojového kódu tohoto 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, max_alpha) {
    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) * max_alpha;
            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);
 
function createTexture(alpha) {
    // 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, alpha);
    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);
}
 
 
old_alpha = -1.0;
 
function draw() {
    // přečíst parametry nastavené na formuláti
    const enable_blending = document.getElementById("enable_blending").checked;
 
    // nastavení blending operace
    const blending_func_1_value = document.getElementById("blending_func_1").value;
    const blending_func_2_value = document.getElementById("blending_func_2").value;
 
    const blending_func_1 = gl[blending_func_1_value];
    const blending_func_2 = gl[blending_func_2_value];
 
    // průhlednost v textuře
    const max_alpha = document.getElementById("max_alpha").value;
 
    // barva na kterou se vymaže pozadí před vykreslením textury
    const r = document.getElementById("r").value;
    const g = document.getElementById("g").value;
    const b = document.getElementById("b").value;
    const a = document.getElementById("a").value;
 
    if (max_alpha != old_alpha) {
        createTexture(max_alpha);
        old_alpha = max_alpha;
    }
 
    // povolení či zákaz blendingu
    if (enable_blending) {
        gl.enable(gl.BLEND);
    } else {
        gl.disable(gl.BLEND);
    }
    // nastavení blendingu
    gl.blendFunc(blending_func_1, blending_func_2);
 
    // 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(r, g, b, a);
 
    // 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);
}
 
draw(false);

Textury nanesené na plochy v 3D prostoru: pole obsahující světové souřadnice i souřadnice v prostoru textury

Shrňme si ve stručnosti, jaké možnosti vykreslovací pipeline jsme si až doposud popsali. Víme již, jak se vykreslují 3D tělesa, jejichž povrch je reprezentován sítí trojúhelníků. A taktéž umíme vykreslit 2D plochu složenou z trojúhelníků, na kterou je nanesena (taktéž plošná) textura. Připomeňme si, že v případě popisu povrchu 3D tělesa bylo použito pole obsahující pouze souřadnice vrcholů trojúhelníků. Jednalo se o pole s následující strukturou:

// souřadnice trojúhelníků
const vertexes = [
    // přední stěna (2 trojúhelníky)
    min_x, min_y, max_z,
    max_x, min_y, max_z,
    max_x, max_y, max_z,
 
    min_x, min_y, max_z,
    max_x, max_y, max_z,
    min_x, max_y, max_z,
 
    // pravá stěna (2 trojúhelníky)
    max_x, min_y, max_z,
    max_x, min_y, min_z,
    max_x, max_y, min_z,
 
    max_x, min_y, max_z,
    max_x, max_y, min_z,
    max_x, max_y, max_z,
 
    // zadní stěna (2 trojúhelníky)
    max_x, min_y, min_z,
    min_x, min_y, min_z,
    min_x, max_y, min_z,
 
    max_x, min_y, min_z,
    min_x, max_y, min_z,
    max_x, max_y, min_z,
 
    // levá stěna (2 trojúhelníky)
    min_x, min_y, min_z,
    min_x, min_y, max_z,
    min_x, max_y, max_z,
 
    min_x, min_y, min_z,
    min_x, max_y, max_z,
    min_x, max_y, min_z,
];

Naopak pro uložení souřadnic 2D plochy současně se souřadnicemi v prostoru textury vypadalo příslušné pole značně odlišně, protože jsme museli pro každý vrchol uložit souřadnice vrcholu ve světovém prostoru a současně i uv souřadnice v prostoru textury:

// 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,
];

Nyní oba způsoby zkombinujeme. Každý vrchol trojúhelníku bude uložen jako pětice souřadnic: x, y, z, u a v. Prozatím pro jednoduchost bude každá z-ová souřadnice nulová:

const min_x = -0.9
const max_x = 0.9
const min_y = min_x
const max_y = max_x
const z = 0
 
// souřadnice vrcholů trojúhelníku + souřadnice v prostoru textury
const vertexes = [
  // x, y, z  u, v
   min_x, min_y, z, 0.0, 0.0,
   min_x, max_y, z, 0.0, 1.0,
   max_x, max_y, z, 1.0, 1.0,
 
   min_x, min_y, z, 0.0, 0.0,
   max_x, max_y, z, 1.0, 1.0,
   max_x, min_y, z, 1.0, 0.0,
];

Pochopitelně budeme muset nepatrně upravit i vertex shader. Ten bude akceptovat atribut pojmenovaný position, jenž bude typu vec3, a taktéž atribut pojmenovaný texcoord typu vec2. Je to logické, protože souřadnice vrcholu jsou skutečně reprezentovány trojicí [x, y, z], zatímco souřadnice v textuře dvojicí [u, v]. Vertex shader pouze rozšíří souřadnice vrcholu do 4D vektoru (přidá váhu) a zapamatuje si souřadnice v prostoru textury. Tyto údaje se po zpracování (znovu)použijí ve fragment shaderu:

const vertexShaderSource = `
    attribute vec3 position;
    attribute vec2 texcoord;
    varying vec2 vTexcoord;
 
    void main() {
        gl_Position = vec4(position, 1);
        vTexcoord = texcoord;
    }
`

Způsob předání světových 3D souřadnic a souřadnic v prostoru textury

Připomeňme si, jak se definuje takzvaný vertex buffer, přes který se budou souřadnice předávat do vykreslovací pipeline:

// buffer, do kterého se překopírují souřadnice vrcholů
const vertexBuffer = gl.createBuffer();
if (!vertexBuffer) {
    throw new Error("Failed to create buffer.");
}
print("Vertex buffer created");
gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);

Dále zkonvertujeme JavaScriptové pole se souřadnicemi [x, y, z, u, v] do pole typu Float32Array a pošleme výsledek do vykreslovací pipeline:

const data = new Float32Array(vertexes);
gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
print("Vertex buffer filled-in by vertexes");

Výsledek, který si můžete ověřit na adrese https://tisnik.github.io/tem­p/texturesE.html, ovšem už na první pohled není korektní. Je tomu tak z toho důvodu, že jsme nezměnili popis struktury předávaného pole. Stále totiž vykreslovacímu řetězci tvrdíme, že záznamy v poli mají čtyři souřadnice:

// 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);

a:

// 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);

Ve skutečnosti je úprava triviální. Pouze musíme modifikovat pátý parametr předávaný do metody vertexAttribPointer, protože každý záznam (o vrcholu) má pět složek. Samotné souřadnice vrcholu mají tři složky:

// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(p,
                       3,                                // počet prvků v každém atributu
                       gl.FLOAT,                         // typ prvků
                       gl.FALSE,                         // data nejsou normalizována
                       5*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       0                                 // offset
);
gl.enableVertexAttribArray(p);

Zatímco souřadnice v textuře obsahuje dvě složky, které jsou uloženy od offsetu 3:

// 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
                       5*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       3*Float32Array.BYTES_PER_ELEMENT  // offset
);
gl.enableVertexAttribArray(texLoc);

Úplný zdrojový kód třetího demonstračního příkladu

Dnešní třetí demonstrační příklad je možné otestovat na adrese https://tisnik.github.io/tem­p/texturesF.html. Následuje výpis úplného zdrojového kódu tohoto příkladu:

const vertexShaderSource = `
    attribute vec3 position;
    attribute vec2 texcoord;
    varying vec2 vTexcoord;
 
    void main() {
        gl_Position = vec4(position, 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
const z = 0
 
// souřadnice vrcholů trojúhelníku + souřadnice v prostoru textury
const vertexes = [
  // x, y, z  u, v
   min_x, min_y, z, 0.0, 0.0,
   min_x, max_y, z, 0.0, 1.0,
   max_x, max_y, z, 1.0, 1.0,
 
   min_x, min_y, z, 0.0, 0.0,
   max_x, max_y, z, 1.0, 1.0,
   max_x, min_y, z, 1.0, 0.0,
];
 
// buffer, do kterého se překopírují souřadnice vrcholů
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
                       5*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
                       5*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       3*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);

Pole se souřadnicemi vrcholů krychle i s u-v souřadnicemi v prostoru textury

V této chvíli již máme k dispozici všechny informace potřebné pro zobrazení krychle, na jejíž stěny je nanesena textura. Pro jednoduchost (alespoň prozatím) použijeme pro všechny stěny pouze jedinou texturu. Nejprve jsou nadefinovány mezní souřadnice vrcholů krychle a taktéž mezní souřadnice v prostoru textury (u-v):

// omezeno tak, aby bylo možné později rotovat
const min_x = -0.5
const max_x = 0.5
const min_y = min_x
const max_y = max_x
const min_z = min_x
const max_z = max_x
 
const min_u = 0.0
const min_v = 0.0
const max_u = 1.0
const max_v = 1.0

Dále máme ve skriptu definováno pole, které obsahuje pětici hodnot pro všechny vrcholy krychle (většina z nich se opakuje, protože vždy tři stěny se střetnou v jednom vrcholu) – tři souřadnice ve světovém prostoru a dvě souřadnice v prostoru textury: [x, y, z, u, v]. V tomto konkrétním poli jsou definovány informace pro osm trojúhelníků, které tvoří čtyři stěny krychle. V případě potřeby je pochopitelně možné dodefinovat obě zbývající stěny (tedy další čtyři trojúhelníky):

// souřadnice vrcholů trojúhelníků + souřadnice v prostoru textury
const vertexes = [
    // přední stěna (2 trojúhelníky)
    min_x, min_y, max_z, min_u, min_v,
    max_x, min_y, max_z, max_u, min_v,
    max_x, max_y, max_z, max_u, max_v,
 
    min_x, min_y, max_z, min_u, min_v,
    max_x, max_y, max_z, max_u, max_v,
    min_x, max_y, max_z, min_u, max_v,
 
    // pravá stěna (2 trojúhelníky)
    max_x, min_y, max_z, min_u, min_v,
    max_x, min_y, min_z, max_u, min_v,
    max_x, max_y, min_z, max_u, max_v,
 
    max_x, min_y, max_z, min_u, min_v,
    max_x, max_y, min_z, max_u, max_v,
    max_x, max_y, max_z, min_u, max_v,
 
    // zadní stěna (2 trojúhelníky)
    max_x, min_y, min_z, min_u, min_v,
    min_x, min_y, min_z, max_u, min_v,
    min_x, max_y, min_z, max_u, max_v,
 
    max_x, min_y, min_z, min_u, min_v,
    min_x, max_y, min_z, max_u, max_v,
    max_x, max_y, min_z, min_u, max_v,
 
    // levá stěna (2 trojúhelníky)
    min_x, min_y, min_z, min_u, min_v,
    min_x, min_y, max_z, max_u, min_v,
    min_x, max_y, max_z, max_u, max_v,
 
    min_x, min_y, min_z, min_u, min_v,
    min_x, max_y, max_z, max_u, max_v,
    min_x, max_y, min_z, min_u, max_v,
];

Následuje předání sekvence prvních tří souřadnic [x, y, z] do vykreslovací pipeline. Povšimněte si, že druhý parametr je nastaven na 3 a předposlední parametr na 5× velikost hodnot typu float:

// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(p,
                       3,                                // počet prvků v každém atributu
                       gl.FLOAT,                         // typ prvků
                       gl.FALSE,                         // data nejsou normalizována
                       5*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       0                                 // offset
);
gl.enableVertexAttribArray(p);

Předání dvojice souřadnic [u, v] do vykreslovací pipeline je realizováno následovně. Zde již musíme počítat s offsetem hodnot (3× velikost hodnot typu float):

// 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
                       5*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       3*Float32Array.BYTES_PER_ELEMENT  // offset
);
gl.enableVertexAttribArray(texLoc);

Funkce pro vykreslení rotující krychle, jejíž stěny jsou pokryty texturou

Zbývá nám ukázat funkci, která vykreslí rotující krychli pokrytou texturou. V této funkci se vlastně nemusely provést žádné změny, protože z pohledu vykreslovací pipeline není rozdíl mezi vykreslením stěn pokrytých konstantní barvou od stěn pokrytých texturou:

function draw(time) {
    // vykreslení jednoho snímku
 
    // přizpůsobíme se rychlosti vykreslování snímků
    const dt = (time - lastTime) * 0.001;
    lastTime = time;
 
    // výpočet 
    rotX += dt * 0.8;
    rotY += dt * 1.0;
 
    // transformace souřadnic: z normalizovaných souřadnic na souřadnice na plátnu
    gl.viewport(0, 0, canvas.width, canvas.height);
 
    // vymazání barvového bufferu i paměti hloubky
    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
 
    // transformační matice
    const aspect = canvas.width / canvas.height;
    const perspective_fov = matrix_perspective_fov(Math.PI / 3, aspect, 0.5, 100);
    const translate = matrix_translate(-2.0);
    const rx = matrix_rotate_around_x(rotX);
    const ry = matrix_rotate_around_y(rotY);
    const matrix = matrix_multiply(perspective_fov, matrix_multiply(translate, matrix_multiply(rx, ry)));
 
    // předat matici do vykreslovací pipeline
    gl.uniformMatrix4fv(umatrix, false, new Float32Array(matrix));
 
    // vykreslení trojúhelníků s předáním souřadnic vertexů a texturovacích souřadnic
    gl.drawArrays(gl.TRIANGLES, 0, 36-12);
 
    // vyžádání vykreslení dalšího snímku
    requestAnimationFrame(draw);
}
 
// vyžádání vykreslení dalšího snímku
requestAnimationFrame(draw);

Úplný zdrojový kód čtvrtého demonstračního příkladu

Dnešní čtvrtý demonstrační příklad by se měl po spuštění ve webovém prohlížeči chovat následovně: https://tisnik.github.io/tem­p/cubeC.html. Následuje, jak je již zvykem, výpis jeho úplného zdrojového kódu:

const vertexShaderSource = `
    attribute vec3 position;
    attribute vec2 texcoord;
    varying vec2 vTexcoord;
    uniform mat4 umatrix;
 
    void main() {
        gl_Position = umatrix * vec4(position, 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;
}
 
function matrix_identity() {
    return new Float32Array([
        1, 0, 0, 0,
        0, 1, 0, 0,
        0, 0, 1, 0,
        0, 0, 0, 1
    ]);
}
 
function matrix_translate(z) {
    return new Float32Array([
        1, 0, 0, 0,
        0, 1, 0, 0,
        0, 0, 1, 0,
        0, 0, z, 1
    ]);
}
 
function matrix_rotate_around_x(a) {
    const c = Math.cos(a);
    const s = Math.sin(a);
    return new Float32Array([
        1, 0, 0, 0,
        0, c, s, 0,
        0, -s, c, 0,
        0, 0, 0, 1
    ]);
}
 
function matrix_rotate_around_y(a) {
    const c = Math.cos(a);
    const s = Math.sin(a);
    return new Float32Array([
        c, 0, -s, 0,
        0, 1, 0, 0,
        s, 0, c, 0,
        0, 0, 0, 1
    ]);
}
 
function matrix_perspective_fov(fovy, aspect, near, far) {
    const f = 1.0 / Math.tan(fovy / 2);
    const nf = 1 / (near - far);
    return new Float32Array([
        f / aspect, 0, 0, 0,
        0, f, 0, 0,
        0, 0, (far + near) * nf, -1,
        0, 0, (2 * far * near) * nf, 0
    ]);
}
 
function matrix_multiply(a, b) {
    const out = new Float32Array(16);
    for (let col = 0; col < 4; col++) {
        for (let row = 0; row < 4; row++) {
            out[col * 4 + row] =
              a[0 * 4 + row] * b[col * 4 + 0] +
              a[1 * 4 + row] * b[col * 4 + 1] +
              a[2 * 4 + row] * b[col * 4 + 2] +
              a[3 * 4 + row] * b[col * 4 + 3];
        }
    }
    return out;
}
 
// 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", {
  depth: true
});
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");
 
// omezeno tak, aby bylo možné později rotovat
const min_x = -0.5
const max_x = 0.5
const min_y = min_x
const max_y = max_x
const min_z = min_x
const max_z = max_x
 
const min_u = 0.0
const min_v = 0.0
const max_u = 1.0
const max_v = 1.0
 
// souřadnice vrcholů trojúhelníků + souřadnice v prostoru textury
const vertexes = [
    // přední stěna (2 trojúhelníky)
    min_x, min_y, max_z, min_u, min_v,
    max_x, min_y, max_z, max_u, min_v,
    max_x, max_y, max_z, max_u, max_v,
 
    min_x, min_y, max_z, min_u, min_v,
    max_x, max_y, max_z, max_u, max_v,
    min_x, max_y, max_z, min_u, max_v,
 
    // pravá stěna (2 trojúhelníky)
    max_x, min_y, max_z, min_u, min_v,
    max_x, min_y, min_z, max_u, min_v,
    max_x, max_y, min_z, max_u, max_v,
 
    max_x, min_y, max_z, min_u, min_v,
    max_x, max_y, min_z, max_u, max_v,
    max_x, max_y, max_z, min_u, max_v,
 
    // zadní stěna (2 trojúhelníky)
    max_x, min_y, min_z, min_u, min_v,
    min_x, min_y, min_z, max_u, min_v,
    min_x, max_y, min_z, max_u, max_v,
 
    max_x, min_y, min_z, min_u, min_v,
    min_x, max_y, min_z, max_u, max_v,
    max_x, max_y, min_z, min_u, max_v,
 
    // levá stěna (2 trojúhelníky)
    min_x, min_y, min_z, min_u, min_v,
    min_x, min_y, max_z, max_u, min_v,
    min_x, max_y, max_z, max_u, max_v,
 
    min_x, min_y, min_z, min_u, min_v,
    min_x, max_y, max_z, max_u, max_v,
    min_x, max_y, min_z, min_u, max_v,
];
 
// 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,
                       3,                                // počet prvků v každém atributu
                       gl.FLOAT,                         // typ prvků
                       gl.FALSE,                         // data nejsou normalizována
                       5*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
                       5*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       3*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);
 
// spuštění programu
gl.useProgram(program);
 
// úhly pro rotaci krychle
let rotX = 0, rotY = 0;
 
// čas vykreslení posledního snímku
let lastTime = 0;
 
// navázání na proměnnou dostupnou ve vertex shaderu
const umatrix = gl.getUniformLocation(program, "umatrix");
 
// povolení Z-bufferu
gl.enable(gl.DEPTH_TEST);
gl.depthFunc(gl.LESS);
 
gl.clearDepth(1.0);
 
// nastavení barvy pro vymazání barvového bufferu
gl.clearColor(0, 0, 0, 1);
 
 
 
function draw(time) {
    // vykreslení jednoho snímku
 
    // přizpůsobíme se rychlosti vykreslování snímků
    const dt = (time - lastTime) * 0.001;
    lastTime = time;
 
    // výpočet 
    rotX += dt * 0.8;
    rotY += dt * 1.0;
 
    // transformace souřadnic: z normalizovaných souřadnic na souřadnice na plátnu
    gl.viewport(0, 0, canvas.width, canvas.height);
 
    // vymazání barvového bufferu i paměti hloubky
    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
 
    // transformační matice
    const aspect = canvas.width / canvas.height;
    const perspective_fov = matrix_perspective_fov(Math.PI / 3, aspect, 0.5, 100);
    const translate = matrix_translate(-2.0);
    const rx = matrix_rotate_around_x(rotX);
    const ry = matrix_rotate_around_y(rotY);
    const matrix = matrix_multiply(perspective_fov, matrix_multiply(translate, matrix_multiply(rx, ry)));
 
    // předat matici do vykreslovací pipeline
    gl.uniformMatrix4fv(umatrix, false, new Float32Array(matrix));
 
    // vykreslení trojúhelníků s předáním souřadnic vertexů a texturovacích souřadnic
    gl.drawArrays(gl.TRIANGLES, 0, 36-12);
 
    // vyžádání vykreslení dalšího snímku
    requestAnimationFrame(draw);
}
 
// vyžádání vykreslení dalšího snímku
requestAnimationFrame(draw);

Interaktivní konfigurace blendingu s modifikací alfa složky textury

Nejzajímavější situace nastane ve chvíli, kdy povolíme blending při vykreslování textury, jejíž texely mohou být poloprůhledné nebo zcela průhledné. V tomto případě je nutné si uvědomit, že i průhledné texely jsou z pohledu vykreslovací pipeline „reálnými“ prvky scény, což může způsobit (resp. způsobí), že průhledný texel zakryje část scény vzdálenější od kamery, která by ovšem měla být viditelná. K této problematice se ještě vrátíme, nyní si však ukážeme webovou stránku umožňující interaktivní nastavení parametrů textury (včetně povolení či zákazu blendingu). Povšimněte si, že již při každé změně nějakého ovládacího prvku nemusíme explicitně volat funkci draw – ta se zavolá (i když po určité době) automaticky díky volání requestAnimationFrame(draw), které je ve skriptu realizováno:

<!doctype html>
<html>
    <head>
        <title>WebGL: cubeD</title>
    </head>
    <body>
        <!-- kreslicí plátno -->
        <canvas id="web_gl_canvas" width="256" height="256"></canvas>
 
        <br />
 
        <label>
            <span>Blending enabled</span>
            <input type="checkbox" id="enable_blending">
        </label>
 
        <br />
 
        <label>
            <span>Blending function #1</span>
            <select id="blending_func_1">
                <option value="ZERO">ZERO</option>
                <option value="ONE">ONE</option>
                <option value="SRC_ALPHA" selected>SRC_ALPHA</option>
                <option value="SRC_ALPHA_SATURATE">SRC_ALPHA_SATURATE</option>
                <option value="ONE_MINUS_SRC_ALPHA">ONE_MINUS_SRC_ALPHA</option>
                <option value="DST_ALPHA">DST_ALPHA</option>
                <option value="ONE_MINUS_DST_ALPHA">ONE_MINUS_DST_ALPHA</option>
                <option value="DST_COLOR">DST_COLOR</option>
                <option value="ONE_MINUS_DST_COLOR">ONE_MINUS_DST_COLOR</option>
            </select>
        </label>
 
        <br />
 
        <label>
            <span>Blending function #2</span>
            <select id="blending_func_2">
                <option value="ZERO">ZERO</option>
                <option value="ONE">ONE</option>
                <option value="SRC_COLOR">SRC_COLOR</option>
                <option value="ONE_MINUS_SRC_COLOR">ONE_MINUS_SRC_COLOR</option>
                <option value="SRC_ALPHA">SRC_ALPHA</option>
                <option value="ONE_MINUS_SRC_ALPHA" selected>ONE_MINUS_SRC_ALPHA</option>
                <option value="DST_ALPHA">DST_ALPHA</option>
                <option value="ONE_MINUS_DST_ALPHA">ONE_MINUS_DST_ALPHA</option>
            </select>
        </label>
 
        <br />
 
        <label>
            <span>R</span>
            <input type="range" id="r" min="0" max="1" step="0.01" value="0" onchange="draw()">
        </label>
 
        <br />
 
        <label>
            <span>G</span>
            <input type="range" id="g" min="0" max="1" step="0.01" value="0" onchange="draw()">
        </label>
 
        <br />
 
        <label>
            <span>B</span>
            <input type="range" id="b" min="0" max="1" step="0.01" value="0" onchange="draw()">
        </label>
 
        <br />
 
        <label>
            <span>A</span>
            <input type="range" id="a" min="0" max="1" step="0.01" value="1" onchange="draw()">
        </label>
 
        <br />
        <!-- skript, který kreslicí plátno využije -->
        <script type="application/javascript" src="cubeD.js"></script>
    </body>
</html>

Úplný zdrojový kód pátého demonstračního příkladu

Dnešní pátý a současně i poslední demonstrační příklad si můžete spustit z adresy https://tisnik.github.io/tem­p/cubeD.html. Podobně, jako tomu bylo u všech předchozích příkladů, si i nyní uvedeme jeho úplný zdrojový kód:

const vertexShaderSource = `
    attribute vec3 position;
    attribute vec2 texcoord;
    varying vec2 vTexcoord;
    uniform mat4 umatrix;
 
    void main() {
        gl_Position = umatrix * vec4(position, 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;
}
 
function matrix_identity() {
    return new Float32Array([
        1, 0, 0, 0,
        0, 1, 0, 0,
        0, 0, 1, 0,
        0, 0, 0, 1
    ]);
}
 
function matrix_translate(z) {
    return new Float32Array([
        1, 0, 0, 0,
        0, 1, 0, 0,
        0, 0, 1, 0,
        0, 0, z, 1
    ]);
}
 
function matrix_rotate_around_x(a) {
    const c = Math.cos(a);
    const s = Math.sin(a);
    return new Float32Array([
        1, 0, 0, 0,
        0, c, s, 0,
        0, -s, c, 0,
        0, 0, 0, 1
    ]);
}
 
function matrix_rotate_around_y(a) {
    const c = Math.cos(a);
    const s = Math.sin(a);
    return new Float32Array([
        c, 0, -s, 0,
        0, 1, 0, 0,
        s, 0, c, 0,
        0, 0, 0, 1
    ]);
}
 
function matrix_perspective_fov(fovy, aspect, near, far) {
    const f = 1.0 / Math.tan(fovy / 2);
    const nf = 1 / (near - far);
    return new Float32Array([
        f / aspect, 0, 0, 0,
        0, f, 0, 0,
        0, 0, (far + near) * nf, -1,
        0, 0, (2 * far * near) * nf, 0
    ]);
}
 
function matrix_multiply(a, b) {
    const out = new Float32Array(16);
    for (let col = 0; col < 4; col++) {
        for (let row = 0; row < 4; row++) {
            out[col * 4 + row] =
              a[0 * 4 + row] * b[col * 4 + 0] +
              a[1 * 4 + row] * b[col * 4 + 1] +
              a[2 * 4 + row] * b[col * 4 + 2] +
              a[3 * 4 + row] * b[col * 4 + 3];
        }
    }
    return out;
}
 
// 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", {
  depth: true
});
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");
 
// omezeno tak, aby bylo možné později rotovat
const min_x = -0.5
const max_x = 0.5
const min_y = min_x
const max_y = max_x
const min_z = min_x
const max_z = max_x
 
const min_u = 0.0
const min_v = 0.0
const max_u = 1.0
const max_v = 1.0
 
// souřadnice vrcholů trojúhelníků + souřadnice v prostoru textury
const vertexes = [
    // přední stěna (2 trojúhelníky)
    min_x, min_y, max_z, min_u, min_v,
    max_x, min_y, max_z, max_u, min_v,
    max_x, max_y, max_z, max_u, max_v,
 
    min_x, min_y, max_z, min_u, min_v,
    max_x, max_y, max_z, max_u, max_v,
    min_x, max_y, max_z, min_u, max_v,
 
    // pravá stěna (2 trojúhelníky)
    max_x, min_y, max_z, min_u, min_v,
    max_x, min_y, min_z, max_u, min_v,
    max_x, max_y, min_z, max_u, max_v,
 
    max_x, min_y, max_z, min_u, min_v,
    max_x, max_y, min_z, max_u, max_v,
    max_x, max_y, max_z, min_u, max_v,
 
    // zadní stěna (2 trojúhelníky)
    max_x, min_y, min_z, min_u, min_v,
    min_x, min_y, min_z, max_u, min_v,
    min_x, max_y, min_z, max_u, max_v,
 
    max_x, min_y, min_z, min_u, min_v,
    min_x, max_y, min_z, max_u, max_v,
    max_x, max_y, min_z, min_u, max_v,
 
    // levá stěna (2 trojúhelníky)
    min_x, min_y, min_z, min_u, min_v,
    min_x, min_y, max_z, max_u, min_v,
    min_x, max_y, max_z, max_u, max_v,
 
    min_x, min_y, min_z, min_u, min_v,
    min_x, max_y, max_z, max_u, max_v,
    min_x, max_y, min_z, min_u, max_v,
];
 
// 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,
                       3,                                // počet prvků v každém atributu
                       gl.FLOAT,                         // typ prvků
                       gl.FALSE,                         // data nejsou normalizována
                       5*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
                       5*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
                       3*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);
 
// spuštění programu
gl.useProgram(program);
 
// úhly pro rotaci krychle
let rotX = 0, rotY = 0;
 
// čas vykreslení posledního snímku
let lastTime = 0;
 
// navázání na proměnnou dostupnou ve vertex shaderu
const umatrix = gl.getUniformLocation(program, "umatrix");
 
// povolení Z-bufferu
gl.enable(gl.DEPTH_TEST);
gl.depthFunc(gl.LESS);
 
gl.clearDepth(1.0);
 
// nastavení barvy pro vymazání barvového bufferu
gl.clearColor(0, 0, 0, 1);
 
 
 
// vykreslení jednoho snímku
function draw(time) {
    // přečíst parametry nastavené na formuláti
    const enable_blending = document.getElementById("enable_blending").checked;
 
    // nastavení blending operace
    const blending_func_1_value = document.getElementById("blending_func_1").value;
    const blending_func_2_value = document.getElementById("blending_func_2").value;
 
    const blending_func_1 = gl[blending_func_1_value];
    const blending_func_2 = gl[blending_func_2_value];
 
    // barva na kterou se vymaže pozadí před vykreslením textury
    const r = document.getElementById("r").value;
    const g = document.getElementById("g").value;
    const b = document.getElementById("b").value;
    const a = document.getElementById("a").value;
 
    // přizpůsobíme se rychlosti vykreslování snímků
    const dt = (time - lastTime) * 0.001;
    lastTime = time;
 
    // výpočet 
    rotX += dt * 0.8;
    rotY += dt * 1.0;
 
    // povolení či zákaz blendingu
    if (enable_blending) {
        gl.enable(gl.BLEND);
    } else {
        gl.disable(gl.BLEND);
    }
    // nastavení blendingu
    gl.blendFunc(blending_func_1, blending_func_2);
 
    // 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(r, g, b, a);
 
    // vymazání barvového bufferu i paměti hloubky
    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
 
    // transformační matice
    const aspect = canvas.width / canvas.height;
    const perspective_fov = matrix_perspective_fov(Math.PI / 3, aspect, 0.5, 100);
    const translate = matrix_translate(-2.0);
    const rx = matrix_rotate_around_x(rotX);
    const ry = matrix_rotate_around_y(rotY);
    const matrix = matrix_multiply(perspective_fov, matrix_multiply(translate, matrix_multiply(rx, ry)));
 
    // předat matici do vykreslovací pipeline
    gl.uniformMatrix4fv(umatrix, false, new Float32Array(matrix));
 
    // vykreslení trojúhelníků s předáním souřadnic vertexů a texturovacích souřadnic
    gl.drawArrays(gl.TRIANGLES, 0, 36-12);
 
    // vyžádání vykreslení dalšího snímku
    requestAnimationFrame(draw);
}
 
// vyžádání vykreslení dalšího snímku
requestAnimationFrame(draw);

Z jakého důvodu dochází při vykreslování předchozího příkladu k viditelným chybám?

Při vykreslování těles s průhlednými nebo poloprůhlednými stěnami záleží na pořadí vykreslování jednotlivých plošek (trojúhelníků). Jako první by se proto měly vykreslit nejvzdálenější objekty (resp. plošky). Zejména proto, že řazení plošek podle vzdálenosti od pozorovatele je časově náročné a nejednoznačné, je nutno metodu trošku vylepšit. Jeden z možných postupů je následující:

TOP100 prodej

  • Nejprve je zapotřebí při inicializaci aplikace (na webové stránkce) alokovat společně s barvovými buffery i paměť hloubky (Z-buffer)..
  • Paměť hloubky se musí nastavit do režimu čtení i zápisu (read-write) hloubek fragmentů. Toho dosáhneme zavoláním příkazu gl.depthMask(true).
  • Po nastavení hloubkového bufferu se vykreslí všechny neprůhledné objekty. Tyto objekty se vzhledem k testu hloubky každého vykreslovaného fragmentu vykreslí korektně. To je zapříčiněno funkcí hloubkového bufferu, který pro každý vykreslovaný fragment testuje, zda je umístěn před nebo za již vykresleným fragmentem, jehož hloubka je v hloubkovém bufferu uložena. Po vykreslení všech neprůhledných objektů je tedy v hloubkovém bufferu zapsána „výšková mapa“ nejbližších vykreslených fragmentů v každé buňce framebufferu.
  • Před vykreslením průhledných objektů se musí hloubkový režim nastavit do režimu read-only, tj. hloubky fragmentů jsou z hloubkového bufferu pouze čteny (a popř. odstraněny z dalšího vykreslování). Zápis hodnot do hloubkového bufferu je zakázán, protože průhledné objekty se musí vykreslit i tehdy, pokud jsou schovány za dalším průhledným objektem a neprůhledné objekty se za objekty průhlednými nesmí vymazat. Nastavení hloubkového bufferu do režimu read-only provedeme příkazem gl.depthMask(false).
  • Dalším krokem je seřazení průhledných objektů podle jejich hloubky (vzdálenosti) od pozorovatele. Objekty se poté vykreslí v tomto pořadí, nejdříve samozřejmě objekt nejvzdálenější.
  • Po vykreslení všech průhledných objektů se hloubkový buffer nastaví opět do režimu read-write (gl.depthMask(true)), aby se v příštím průchodu neprůhledné objekty vykreslily korektně.
Poznámka: praktickou ukázku si uvedeme příště.

Obsah navazujícího článku: plně programovatelný vykreslovací řetězec

Prozatím jsme se v tomto seriálu zabývali především popisem standardizovaného aplikačního rozhraní (API) nabízeného Open GL ES. Víme již, jakým postupem se provádí konfigurace vykreslovacího řetězce (vymazání bufferů, povolení blendingu atd.) a ukázali jsme si i způsoby předávání dat do vykreslovacího řetězce (to se provádí přes buffery, do nichž se posílají obsahy polí). Ovšem OpenGL ES nabízí v porovnání s původním „klasickým“ Open GL ještě jednu důležitou vlastnost: celý vykreslovací řetězec (rendering pipeline) není pouze konfigurovatelný, ale je i programovatelný. V této oblasti se využívají takzvané shadery, které jsme sice ve všech demonstračních příkladech používali (resp. jsme je dokonce byli nuceni používat), ovšem prozatím jsme se nezabývali tím, jak lze shadery využít pro realizaci různých grafických efektů. Ty se navíc spouští na GPU a jsou do značné míry nezávislé na výkonu hlavního mikroprocesoru. A právě tímto velmi důležitým tématem se budeme zabývat v navazující části tohoto seriálu.

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

Všechny demonstrační příklady, které jsme si v předchozích sedmi článcích 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
     
88 textureC.html interaktivní nastavení parametrů textury https://tisnik.github.io/tem­p/textureC.html
89 textureC.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/textureC.js
     
90 textureD.html interaktivní nastavení parametrů textury, včetně alfa složky https://tisnik.github.io/tem­p/textureD.html
91 textureD.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/textureD.js
     
92 textureE.html 3D souřadnice + uv souřadnice textury v jediném poli (nekorektní řešení) https://tisnik.github.io/tem­p/textureE.html
93 textureE.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/textureE.js
     
94 textureF.html 3D souřadnice + uv souřadnice textury v jediném poli (korektní řešení) https://tisnik.github.io/tem­p/textureF.html
95 textureF.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/textureF.js
     
96 cubeC.html rotace krychle pokryté texturou https://tisnik.github.io/tem­p/cubeC.html
97 cubeC.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/cubeC.js
     
98 cubeD.html rotace krychle pokryté texturou + interaktivní nastavení parametrů textury https://tisnik.github.io/tem­p/cubeD.html
99 cubeD.js skript s implementací tohoto příkladu https://tisnik.github.io/tem­p/cubeD.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
  32. glFog
    https://docs.gl/gl3/glFog
  33. OpenGL Fog (Version 2.0)
    https://www.swiftless.com/tu­torials/opengl/fog.html
  34. OpenGL Fog
    https://www.opengl.org/ar­chives/resources/code/sam­ples/sig99/shading99/course_sli­des/ShadowsTransparencyFog/tsld055­.htm
  35. <input> HTML input element
    https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/E­lements/input
  36. <input type=„checkbox“> HTML attribute value
    https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/E­lements/input/checkbox
  37. <input type=„range“> HTML attribute value
    https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/E­lements/input/range
  38. jQuery
    https://github.com/jquery/jquery
  39. GL constants translator
    https://javagl.github.io/GLCon­stantsTranslator/GLConstan­tsTranslator.html
  40. Chapter 4. Defined Constants and Associated Commands
    https://www.the.discspace­.org/tech/opengl/OpenGL%20Re­ference%20Manual/ch04.html
  41. An Introduction to WebGL
    https://graphics.cg.uni-saarland.de/courses/cg1-2019/slides/webgl.pdf
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.