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
- Interaktivní změna parametrů textury
- Reakce skriptu na změnu parametrů provedených na webové stránce
- Úplný zdrojový kód prvního demonstračního příkladu
- Vliv alfa složky texelů na způsob zobrazení textury
- Nový ovládací prvek na webové stránce ovlivňující maximální hodnotu alfa složky
- Úprava funkce pro výpočet texelů v textuře
- Úplný zdrojový kód druhého demonstračního příkladu
- Textury nanesené na plochy v 3D prostoru: pole obsahující světové souřadnice i souřadnice v prostoru textury
- Způsob předání světových 3D souřadnic a souřadnic v prostoru textury
- Úplný zdrojový kód třetího demonstračního příkladu
- Pole se souřadnicemi vrcholů krychle i s u-v souřadnicemi v prostoru textury
- Funkce pro vykreslení rotující krychle, jejíž stěny jsou pokryty texturou
- Úplný zdrojový kód čtvrtého demonstračního příkladu
- Interaktivní konfigurace blendingu s modifikací alfa složky textury
- Úplný zdrojový kód pátého demonstračního příkladu
- Z jakého důvodu dochází při vykreslování předchozího příkladu k viditelným chybám?
- Obsah navazujícího článku: plně programovatelný vykreslovací řetězec
- Repositář s demonstračními příklady
- 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ů.
Obrázek 1: Krychle se stěnami vyplněnými konstantní barvou.
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.
Obrázek 2: Dvojice trojúhelníků pokrytá texturou.
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:
Obrázek 3: Interaktivní ovládací prvky ovlivňující způsob zobrazení textury v prvním demonstračním příkladu.
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:
Obrázek 4: Povoleni blendingu.
Obrázek 5: Modifikace míchací rovnice.
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/temp/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÷r)==0^(j÷r)==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):
Obrázek 6: Interaktivní ovládací prvky ovlivňující způsob zobrazení textury ve druhém demonstračním příkladu.
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÷r)==0^(j÷r)==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÷r)==0^(j÷r)==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/temp/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÷r)==0^(j÷r)==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/temp/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/temp/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÷r)==0^(j÷r)==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/temp/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÷r)==0^(j÷r)==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/temp/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÷r)==0^(j÷r)==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í:
- 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ě.
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/temp/step1.html |
| 2 | step1.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/step1.js |
| 3 | step2.html | využití kreslicího plátna s 2D kontextem | https://tisnik.github.io/temp/step2.html |
| 4 | step2.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/step2.js |
| 5 | step3.html | vymazání barvového bufferu pro kontext WebGL | https://tisnik.github.io/temp/step3.html |
| 6 | step3.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/step3.js |
| 7 | step4.html | transformace souřadnic: z normalizovaných souřadnic na souřadnice na plátnu | https://tisnik.github.io/temp/step4.html |
| 8 | step4.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/step4.js |
| 9 | step5.html | vykreslení jediného bodu na plátno v kontextu WebGL | https://tisnik.github.io/temp/step5.html |
| 10 | step5.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/step5.js |
| 11 | step6.html | vykreslení bodu s určením jeho souřadnic ve scéně | https://tisnik.github.io/temp/step6.html |
| 12 | step6.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/step6.js |
| 13 | step7.html | vykreslení většího množství bodů do scény | https://tisnik.github.io/temp/step7.html |
| 14 | step7.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/step7.js |
| 15 | step8.html | kontrola provedení jednotlivých operací | https://tisnik.github.io/temp/step8.html |
| 16 | step8.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/step8.js |
| 17 | step9.html | vykreslení trojice úseček na plochu kreslicího plátna | https://tisnik.github.io/temp/step9.html |
| 18 | step9.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/step9.js |
| 19 | stepA.html | nastavení konstantní barvy úseček | https://tisnik.github.io/temp/stepA.html |
| 20 | stepA.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/stepA.js |
| 21 | stepB.html | vykreslení na sebe navazujících úseček s předáním souřadnic | https://tisnik.github.io/temp/stepB.html |
| 22 | stepB.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/stepB.js |
| 23 | stepC.html | vykreslení uzavřené sekvence úseček s předáním souřadnic | https://tisnik.github.io/temp/stepC.html |
| 24 | stepC.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/stepC.js |
| 25 | stepD.html | vykreslení bodů, každý bod může mít libovolnou barvu | https://tisnik.github.io/temp/stepD.html |
| 26 | stepD.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/stepD.js |
| 27 | stepE.html | vykreslení úseček, barva je vypočtena interpolací barev | https://tisnik.github.io/temp/stepE.html |
| 28 | stepE.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/stepE.js |
| 29 | triangle1.html | vykreslení trojúhelníku konstantní barvou | https://tisnik.github.io/temp/triangle1.html |
| 30 | triangle1.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/triangle1.js |
| 31 | triangle2.html | interpolace barev při vyplňování trojúhelníku | https://tisnik.github.io/temp/triangle2.html |
| 32 | triangle2.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/triangle2.js |
| 33 | triangle3.html | vykreslení pásu trojúhelníků | https://tisnik.github.io/temp/triangle3.html |
| 34 | triangle3.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/triangle3.js |
| 35 | triangle4.html | vykreslení trsu trojúhelníků – neúplná varianta | https://tisnik.github.io/temp/triangle4.html |
| 36 | triangle4.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/triangle4.js |
| 37 | triangle5.html | vykreslení trsu trojúhelníků – úplná varianta | https://tisnik.github.io/temp/triangle5.html |
| 38 | triangle5.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/triangle5.js |
| 39 | triangle6.html | překrývající se trojúhelníky (Z-buffer není použit) | https://tisnik.github.io/temp/triangle6.html |
| 40 | triangle6.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/triangle6.js |
| 41 | triangle7.html | překrývající se trojúhelníky (Z-buffer je použit) | https://tisnik.github.io/temp/triangle7.html |
| 42 | triangle7.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/triangle7.js |
| 43 | cube1.html | 3D krychle vykreslená do 2D plochy bez aplikace transformací | https://tisnik.github.io/temp/cube1.html |
| 44 | cube1.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/cube1.js |
| 45 | cube2.html | transformace reprezentovaná jednotkovou maticí | https://tisnik.github.io/temp/cube2.html |
| 46 | cube2.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/cube2.js |
| 47 | cube3.html | zobrazení 3D kostky z různých úhlů pohledu | https://tisnik.github.io/temp/cube3.html |
| 48 | cube3.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/cube3.js |
| 49 | cube4.html | zobrazení 3D kostky s využitím základní perspektivní projekce | https://tisnik.github.io/temp/cube4.html |
| 50 | cube4.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/cube4.js |
| 51 | cube5.html | krychle v 3D prostoru | https://tisnik.github.io/temp/cube5.html |
| 52 | cube5.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/cube5.js |
| 53 | cube6.html | rotace krychle v 3D prostoru s perspektivní projekcí | https://tisnik.github.io/temp/cube6.html |
| 54 | cube6.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/cube6.js |
| 55 | cube7.html | animace rotace krychle složené z hran (úseček) v 3D prostoru s perspektivní projekcí | https://tisnik.github.io/temp/cube7.html |
| 56 | cube7.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/cube7.js |
| 57 | cube8.html | animace rotace krychle složené z trojúhelníků v 3D prostoru s perspektivní projekcí | https://tisnik.github.io/temp/cube8.html |
| 58 | cube8.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/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/temp/cube9.html |
| 60 | cube9.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/cube9.js |
| 60 | cubeA.html | změna vzdálenosti bližší pohledové roviny | https://tisnik.github.io/temp/cubeA.html |
| 61 | cubeA.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/cubeA.js |
| 62 | cubeB.html | doplnění rotující krychle o obě chybějící stěny | https://tisnik.github.io/temp/cubeB.html |
| 63 | cubeB.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/cubeB.js |
| 64 | texsize.html | zjištění maximálního rozlišení textury | https://tisnik.github.io/temp/texsize.html |
| 65 | texsize.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/texsize.js |
| 66 | texture1.html | textura namapovaná na jediný trojúhelník | https://tisnik.github.io/temp/texture1.html |
| 67 | texture1.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/texture1.js |
| 68 | texture2.html | textura namapovaná na dvojici trojúhelníků tvořících čtvercovou stěnu | https://tisnik.github.io/temp/texture2.html |
| 69 | texture2.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/texture2.js |
| 70 | texture3.html | jednoduchá procedurální textura | https://tisnik.github.io/temp/texture3.html |
| 71 | texture3.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/texture3.js |
| 72 | texture4.html | modifikace UV souřadnic textury | https://tisnik.github.io/temp/texture4.html |
| 73 | texture4.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/texture4.js |
| 74 | texture5.html | textura načtená z rastrového obrázku | https://tisnik.github.io/temp/texture5.html |
| 75 | texture5.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/texture5.js |
| 76 | texture6.html | opakování textury na povrchu těles | https://tisnik.github.io/temp/texture6.html |
| 77 | texture6.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/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/temp/texture7.html |
| 79 | texture7.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/texture7.js |
| 80 | texture8.html | textura s malým rozlišením vykreslená bez bilineární filtrace | https://tisnik.github.io/temp/texture8.html |
| 81 | texture8.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/texture8.js |
| 82 | texture9.html | textura s malým rozlišením vykreslená s bilineární filtrací | https://tisnik.github.io/temp/texture9.html |
| 83 | texture9.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/texture9.js |
| 84 | textureA.html | textura s průhlednými texely, ovšem vykreslená bez povolení blendingu | https://tisnik.github.io/temp/textureA.html |
| 85 | textureA.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/textureA.js |
| 86 | textureB.html | textura s průhlednými texely vykreslená s povolením blendingu | https://tisnik.github.io/temp/textureB.html |
| 87 | textureB.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/textureB.js |
| 88 | textureC.html | interaktivní nastavení parametrů textury | https://tisnik.github.io/temp/textureC.html |
| 89 | textureC.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/textureC.js |
| 90 | textureD.html | interaktivní nastavení parametrů textury, včetně alfa složky | https://tisnik.github.io/temp/textureD.html |
| 91 | textureD.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/textureD.js |
| 92 | textureE.html | 3D souřadnice + uv souřadnice textury v jediném poli (nekorektní řešení) | https://tisnik.github.io/temp/textureE.html |
| 93 | textureE.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/textureE.js |
| 94 | textureF.html | 3D souřadnice + uv souřadnice textury v jediném poli (korektní řešení) | https://tisnik.github.io/temp/textureF.html |
| 95 | textureF.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/textureF.js |
| 96 | cubeC.html | rotace krychle pokryté texturou | https://tisnik.github.io/temp/cubeC.html |
| 97 | cubeC.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/cubeC.js |
| 98 | cubeD.html | rotace krychle pokryté texturou + interaktivní nastavení parametrů textury | https://tisnik.github.io/temp/cubeD.html |
| 99 | cubeD.js | skript s implementací tohoto příkladu | https://tisnik.github.io/temp/cubeD.js |
Odkazy na Internetu
- WebGL: 3D Graphics for the Web
https://www.khronos.org/webgl/ - OpenGL Shading Language
https://en.wikipedia.org/wiki/OpenGL_Shading_Language - WebGL (Wikipedia)
https://en.wikipedia.org/wiki/WebGL - WebGL
https://wikis.khronos.org/webgl/Main_Page - OpenGL ES (Wikipedia)
https://en.wikipedia.org/wiki/OpenGL_ES - Float32Array
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float32Array - ECMAScript compatibility table
https://compat-table.github.io/compat-table/es6/ - Learn-OpenGLES-Tutorials
https://github.com/learnopengles/Learn-OpenGLES-Tutorials - Implement OpenGL ES and EGL
https://source.android.com/docs/core/graphics/implement-opengl-es - Khronos Group
https://www.khronos.org/ - Khronos Group (Wikipedia)
https://en.wikipedia.org/wiki/Khronos_Group - Raspberry Pi VideoCore APIs
http://elinux.org/Raspberry_Pi_VideoCore_APIs - EGL quick reference card
https://www.khronos.org/files/egl-1–4-quick-reference-card.pdf - EGL Reference Pages Index
https://www.khronos.org/registry/egl/sdk/docs/man/html/indexflat.php - GLSL
https://glsl.app/ - Shader Tutorials by Ronja
https://www.ronja-tutorials.com/ - CanvasRenderingContext2D
https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D - WebGL2RenderingContext
https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext - WebGLRenderingContext
https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext - Matrix Transformations
https://vitaminac.github.io/Matrices-in-Computer-Graphics/ - Homogeneous coordinates
https://en.wikipedia.org/wiki/Homogeneous_coordinates - Transformation matrix
https://en.wikipedia.org/wiki/Transformation_matrix - Affine transformation
https://en.wikipedia.org/wiki/Affine_transformation - OpenGL Projection Matrix
https://songho.ca/opengl/gl_projectionmatrix.html - Texture mapping
https://en.wikipedia.org/wiki/Texture_mapping - UV mapping
https://en.wikipedia.org/wiki/UV_mapping - UV Coordinates explained
https://blog.nobel-joergensen.com/2011/04/05/procedural-generated-mesh-in-unity-part-2-with-uv-mapping/ - Introduction to texture mapping
http://www.decew.net/OSS/References/chapter_2_texture_mapping.pdf - Alfa kanál
https://cs.wikipedia.org/wiki/Alfa_kan%C3%A1l - Blending
https://learnopengl.com/Advanced-OpenGL/Blending - Blending (OpenGL wiki)
https://wikis.khronos.org/opengl/Blending - glFog
https://docs.gl/gl3/glFog - OpenGL Fog (Version 2.0)
https://www.swiftless.com/tutorials/opengl/fog.html - OpenGL Fog
https://www.opengl.org/archives/resources/code/samples/sig99/shading99/course_slides/ShadowsTransparencyFog/tsld055.htm - <input> HTML input element
https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input - <input type=„checkbox“> HTML attribute value
https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input/checkbox - <input type=„range“> HTML attribute value
https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input/range - jQuery
https://github.com/jquery/jquery - GL constants translator
https://javagl.github.io/GLConstantsTranslator/GLConstantsTranslator.html - Chapter 4. Defined Constants and Associated Commands
https://www.the.discspace.org/tech/opengl/OpenGL%20Reference%20Manual/ch04.html - An Introduction to WebGL
https://graphics.cg.uni-saarland.de/courses/cg1-2019/slides/webgl.pdf
