Nastavování parametrů textur
Co se dozvíte v článku
- Nastavování parametrů textur
- Rozšířená podpora formátů textur
- Opakování textury na zobrazovaných stěnách těles
- Demonstrační příklad: vykreslení textury, která se opakuje
- Textury s malým rozlišením
- Bilineární interpolace
- Demonstrační příklad: vykreslení textury s využitím bilineární interpolace
- Role alfa složky, kterou obsahují texely
- Vygenerování textury s nastavenými alfa složkami texelů
- Demonstrační příklad: vykreslení textury s texely ve formáty RGBA obsahující různé hodnoty alfa složky
- Povolení blendingu a určení způsobu výpočtu výsledné barvy fragmentů
- Míchací rovnice použitá při blendingu
- Funkce blendFunc
- Význam předpřipravených míchacích faktorů
- Demonstrační příklad: vykreslení textury s texely ve formátu RGBA společně s výpočtem blendingu
- Vizuální chyby, které při texturování vznikají
- Textury s více úrovněmi detailu
- Podpora mipmap v OpenGL
- Repositář s demonstračními příklady
- Odkazy na Internetu
V předchozím článku jsme v demonstračních příkladech používali funkce určené pro nastavení parametrů textury. Tyto funkce však nebyly podrobněji popsány, což se dnes budeme snažit napravit.
Parametry textury (tj. například způsob, jakým je textura mapována na povrch vykreslovaného tělesa) lze nastavit voláním metody:
texParameterf(
target,
pname,
value
);
nebo metody:
texParameteri(
target,
pname,
value
);
Alternativně lze také zavolat metody, které jako svůj poslední parametr akceptují místo skalární hodnoty pole hodnot:
texParameterfv(
target,
pname,
values
);
texParameteriv(
target,
pname,
values
);
První parametr (target) může podle zvolené dimenze textury nabývat hodnot TEXTURE_1D (jednodimenzionální textura, tj. barevný přechod), TEXTURE_2D (nejběžnější, rastrová textura) nebo TEXTURE_3D (objemová textura). Hodnoty parametrů dalších dvou parametrů pname a value jsou uvedeny v následujícím seznamu:
- Parametr TEXTURE_WRAP_S:
tímto parametrem specifikujeme, zda se má při překročení rozsahu texturovací souřadnice ve směru osy s (tento rozsah je, jak víme z minulého dílu od 0 do 1) provést opakování motivu na textuře (value=REPEAT) nebo „protažení“ první či poslední hodnoty (value=CLAMP). Opakování motivu na textuře je vhodné použít v případech, že zobrazujeme různé na sebe navazující motivy, například cihlové zdi, podlahy apod. Protažením textury lze v některých případech zamezit vizuálním artefaktům, které by se mohly objevit při napojování textur. Překročení rozsahu uv-souřadnic není tedy v žádném případě chybou. - Parametr TEXTURE_WRAP_T:
tento parametr má podobný význam jako parametr předchozí, ale s tím rozdílem, že se místo na souřadnici ve směru osy s vztahuje na souřadnici ve směru osy t. U 1D textur nemá hodnota tohoto parametru vliv na zobrazení textury, použitelný je pouze u 2D a 3D textur. Opakování resp. protažení textury lze pro souřadnice ve směrech s, t a r nastavovat nezávisle, což je patrné z demonstračních příkladů. - Parametr TEXTURE_WRAP_R:
tento parametr má opět podobný význam jako předchozí dva parametry, ale vztahuje se na třetí souřadnici r, která je použita například u objemových textur. - Parametr TEXTURE_MIN_FILTER:
tímto parametrem je možné zvolit filtr použitý při zmenšování textury, tj. tehdy, jestliže na plochu jednoho vykreslovaného pixelu musíme použít barvy několika sousedních texelů. Nejjednodušší a nejrychlejší filtr se volí hodnotou NEAREST. U tohoto filtru se barva vykreslovaného pixelu vypočte z barvy texelu, jehož souřadnice nejpřesněji odpovídají zadaným souřadnicím do textury. Poněkud sofistikovanější filtr se zadává hodnotou LINEAR, kdy se barva vykreslovaného pixelu spočítá pomocí bilineární interpolace z barev sousedních texelů. Další čtyři filtry (NEAREST_MIPMAP_NEAREST, NEAREST_MIPMAP_LINEAR, LINEAR_MIPMAP_NEAREST a LINEAR_MIPMAP_LINEAR) využívají takzvané mipmapy, tj. texturu uloženou ve formátu jakési pyramidy, kde jsou kromě základního rozlišení textury obsaženy i rozlišení nižší (vždy s polovičním počtem pixelů v horizontální i vertikální ose) až do nejmenší velikosti 1×1 pixel. - Parametr TEXTURE_MAX_FILTER:
tímto parametrem se volí filtr použitý při zvětšování textury, tj. v případě, že vykreslovaný pixel obsahuje pouze malou plochu texelu. Možné hodnoty jsou NEAREST (použije se nejbližší texel) nebo LINEAR (použije se lineární interpolace mezi barvami sousedních texelů). - Parametr TEXTURE_BORDER_COLOR:
tímto parametrem lze zvolit barvu rámečku okolo textury (pokud je rámeček použit, tj. má nenulovou šířku). V případě zadávání barvy je nutné použít příkazy texParameteriv() resp. texParameterfv(), protože barva se zadává jako vektor (pole) čtyř složek R, G, B a A. Implicitní barva rámečku je (0, 0, 0, 0), tedy černá.
Rozšířená podpora formátů textur
Kromě základních formátů textur, které jsme si popsali v minulém článku, je možné používat v OpenGL verze 1.2 a vyšších (i další rozšířené formáty. Jaká výhoda plyne z použití takových formátů? Především se jedná o to, že použitím některých formátů s malou nebo dostatečnou bitovou hloubkou můžeme ušetřit paměť alokovanou pro textury. Druhou výhodou je možnost použít textury načtené z různých externích souborů, které mají mnohdy exotický formát. V následující tabulce budou ukázány rozšířené formáty textur spolu se základním formátem a typem dat pro každou barevnou složku:
| Rozšířený formát | Základní formát | R (bitů) | G (bitů) | B (bitů) | A (bitů) | L (bitů) | I (bitů) |
| ALPHA4 | ALPHA | 4 | |||||
| ALPHA8 | ALPHA | 8 | |||||
| ALPHA12 | ALPHA | 12 | |||||
| ALPHA16 | ALPHA | 16 | |||||
| LUMINANCE4 | LUMINANCE | 4 | |||||
| LUMINANCE8 | LUMINANCE | 8 | |||||
| LUMINANCE12 | LUMINANCE | 12 | |||||
| LUMINANCE16 | LUMINANCE | 16 | |||||
| LUMINANCE4_ALPHA4 | LUMINANCE_ALPHA | 4 | 4 | ||||
| LUMINANCE6_ALPHA2 | LUMINANCE_ALPHA | 2 | 6 | ||||
| LUMINANCE8_ALPHA8 | LUMINANCE_ALPHA | 8 | 8 | ||||
| LUMINANCE12_ALPHA4 | LUMINANCE_ALPHA | 4 | 12 | ||||
| LUMINANCE12_ALPHA12 | LUMINANCE_ALPHA | 12 | 12 | ||||
| LUMINANCE16_ALPHA16 | LUMINANCE_ALPHA | 16 | 16 | ||||
| INTENSITY4 | INTENSITY | 4 | |||||
| INTENSITY8 | INTENSITY | 8 | |||||
| INTENSITY12 | INTENSITY | 12 | |||||
| INTENSITY16 | INTENSITY | 16 | |||||
| R3_G3_B2 | RGB | 3 | 3 | 2 | |||
| RGB4 | RGB | 4 | 4 | 4 | |||
| RGB5 | RGB | 5 | 5 | 5 | |||
| RGB8 | RGB | 8 | 8 | 8 | |||
| RGB10 | RGB | 10 | 10 | 10 | |||
| RGB12 | RGB | 12 | 12 | 12 | |||
| RGB16 | RGB | 16 | 16 | 16 | |||
| RGBA2 | RGBA | 2 | 2 | 2 | 2 | ||
| RGBA4 | RGBA | 4 | 4 | 4 | 4 | ||
| RGB5_A1 | RGBA | 5 | 5 | 5 | 1 | ||
| RGBA8 | RGBA | 8 | 8 | 8 | 8 | ||
| RGB10_A2 | RGBA | 10 | 10 | 10 | 2 | ||
| RGBA12 | RGBA | 12 | 12 | 12 | 12 | ||
| RGBA16 | RGBA | 16 | 16 | 16 | 16 |
Opakování textury na zobrazovaných stěnách těles
Připomeňme si, že v předchozím článku jsme parametry použité při nanášení textur nastavovali následujícím způsobem:
// způsob vykreslení textury gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
Poslední dva parametry určovaly, že pokud uv-souřadnice (v prostoru textury) leží mimo čtverec omezený vrcholy [0, 0] a [1, 1], budou texely ležící mimo tyto meze obsahovat barvy získané z texelů umístěných na hranách textury. To například znamená, že barva texelu na souřadnicích [100, 0.5] bude získána z texelu na souřadnicích [1, 0.5] atd. Výsledek již známe: https://tisnik.github.io/temp/textures4.html.
Ovšem mnohdy se, například při opakování motivu (kameny, cihly atd.) vyplatí texturu zopakovat a vytvořit tak mozaiku. V OpenGL ES je možné toto opakování povolit pro směr souřadnice u nezávisle na souřadnici v, takže se vždy musí nastavit oba parametry:
// způsob vykreslení textury gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
Demonstrační příklad: vykreslení textury, která se opakuje
V dnešním prvním demonstračním příkladu, který si můžete spustit z adresy https://tisnik.github.io/temp/textures6.html, je ukázáno, jakým způsobem je realizováno namapování textury s jejím opakováním:
const vertexShaderSource = `
attribute vec2 position;
attribute vec2 texcoord;
varying vec2 vTexcoord;
void main() {
gl_Position = vec4(position, 0, 1);
vTexcoord = texcoord;
}
`
const fragmentShaderSource = `
precision mediump float;
varying vec2 vTexcoord;
uniform sampler2D texture;
void main() {
gl_FragColor = texture2D(texture, vTexcoord);
}
`
function print(message) {
console.log(message);
}
function makeTexture(width, height) {
const array = new Array(width*height*4);
let index = 0;
for (j=0; j<height; j++) {
for (i=0; i<width; i++) {
const c = ((i&0x20)==0^(j&0x20)==0) * 255;
array[index++] = c;
array[index++] = i;
array[index++] = j;
array[index++] = 255; // alfa slozka
}
}
return array;
}
// reference na objekt představující kreslicí plátno umístěné na webové stránce
const canvas = document.getElementById("web_gl_canvas");
if (!canvas) {
throw new Error("Canvas with id 'web_gl_canvas' not found");
}
print("Canvas object retrieved");
// vytvoření a získání kontextu WebGL (3D grafika)
const gl = canvas.getContext("webgl");
if (!gl) {
throw new Error("WebGL is not supported or context creation failed");
}
print("WebGL context created");
// vytvoření vertex shaderu
const vertexShader = gl.createShader(gl.VERTEX_SHADER);
if (!vertexShader) {
throw new Error("Failed to create vertex shader.");
}
print("Vertex shader created");
// překlad vertex shaderu
gl.shaderSource(vertexShader, vertexShaderSource);
gl.compileShader(vertexShader);
if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
const log = gl.getShaderInfoLog(vertexShader);
gl.deleteShader(vertexShader);
throw new Error(`Vertex shader compile failed: ${log}`);
}
print("Vertex shader compiled");
// vytvoření fragment shaderu
const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
if (!fragmentShader) {
throw new Error("Failed to create fragment shader.");
}
print("Fragment shader created");
// překlad fragment shaderu
gl.shaderSource(fragmentShader, fragmentShaderSource);
gl.compileShader(fragmentShader);
if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
const log = gl.getShaderInfoLog(fragmentShader);
gl.deleteShader(fragmentShader);
throw new Error(`fragment shader compile failed: ${log}`);
}
print("Fragment shader compiled");
// registrace obou shaderů
const program = gl.createProgram();
if (!program) {
throw new Error("Failed to create program.");
}
print("Program created");
gl.attachShader(program, vertexShader);
gl.attachShader(program, fragmentShader);
print("Shaders attached to the program");
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
const log = gl.getProgramInfoLog(program);
gl.deleteProgram(program);
throw new Error(`Program link failed: ${log}`);
}
print("Program linked");
const min_x = -0.9
const max_x = 0.9
const min_y = min_x
const max_y = max_x
// souřadnice vrcholů trojúhelníku + souřadnice v prostoru textury
const vertexes = [
// x, y, u, v
min_x, min_y, 0.0, 0.0,
min_x, max_y, 0.0, 1.0,
max_x, max_y, 1.0, 1.0,
min_x, min_y, 0.0, 0.0,
max_x, max_y, 2.0, 2.0,
max_x, min_y, 2.0, 0.0,
];
// buffer, do kterého se překopírují souřadnice bodu
const vertexBuffer = gl.createBuffer();
if (!vertexBuffer) {
throw new Error("Failed to create buffer.");
}
print("Vertex buffer created");
gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
const data = new Float32Array(vertexes);
gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
print("Vertex buffer filled-in by vertexes");
// navázání na parametr předávaný do vertex shaderu
const p = gl.getAttribLocation(program, "position");
if (p === -1) {
throw new Error("Attribute 'position' not found in shader program");
}
print("Attribute 'position' found in shader program")
// navázání na parametr předávaný do vertex shaderu
const texLoc = gl.getAttribLocation(program, "texcoord");
if (p === -1) {
throw new Error("Attribute 'texcoord' not found in shader program");
}
print("Attribute 'texcoord' found in shader program")
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(p,
2, // počet prvků v každém atributu
gl.FLOAT, // typ prvků
gl.FALSE, // data nejsou normalizována
4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
0 // offset
);
gl.enableVertexAttribArray(p);
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(texLoc,
2, // počet prvků v každém atributu
gl.FLOAT, // typ prvků
gl.FALSE, // data nejsou normalizována
4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
2*Float32Array.BYTES_PER_ELEMENT // offset
);
gl.enableVertexAttribArray(texLoc);
// textura (prozatím primitivní)
const texture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
const textureWidth = 256
const textureHeight = 256
// textura
textureArray = makeTexture(textureWidth, textureHeight);
const texels = new Uint8Array(textureArray);
gl.texImage2D(gl.TEXTURE_2D, // typ textury: zde 2D textura
0, // úroveň detailu
gl.RGBA, // počet barvových komponent (zde 4)
textureWidth, // horizontální rozlišení textury
textureHeight, // vertikální rozlišení textury
0, // šířka okraje textury
gl.RGBA, // formát uložení texelů
gl.UNSIGNED_BYTE, // typ každé barvové složky texelu
texels // pole texelů
);
// způsob vykreslení textury
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
// navázání na atribut ve shaderech
const samplerLoc = gl.getUniformLocation(program, "texture");
gl.uniform1i(samplerLoc, 0);
// transformace souřadnic: z normalizovaných souřadnic na souřadnice na plátnu
gl.viewport(0, 0, canvas.width, canvas.height);
// nastavení barvy pro vymazání barvového bufferu
gl.clearColor(0, 0, 0, 1);
// vymazání barvového bufferu
gl.clear(gl.COLOR_BUFFER_BIT);
// spuštění programu
gl.useProgram(program);
// vykreslení dvojice trojúhelníků
gl.drawArrays(gl.TRIANGLES, 0, 6);
Pro úplnost ještě doplňuji mírně upravený příklad na adrese https://tisnik.github.io/temp/textures7.html, který v jednom směru texturu opakuje a ve směru druhém jen „prodlužuje“ její okraje.
const vertexShaderSource = `
attribute vec2 position;
attribute vec2 texcoord;
varying vec2 vTexcoord;
void main() {
gl_Position = vec4(position, 0, 1);
vTexcoord = texcoord;
}
`
const fragmentShaderSource = `
precision mediump float;
varying vec2 vTexcoord;
uniform sampler2D texture;
void main() {
gl_FragColor = texture2D(texture, vTexcoord);
}
`
function print(message) {
console.log(message);
}
function makeTexture(width, height) {
const array = new Array(width*height*4);
let index = 0;
for (j=0; j<height; j++) {
for (i=0; i<width; i++) {
const c = ((i&0x20)==0^(j&0x20)==0) * 255;
array[index++] = c;
array[index++] = i;
array[index++] = j;
array[index++] = 255; // alfa slozka
}
}
return array;
}
// reference na objekt představující kreslicí plátno umístěné na webové stránce
const canvas = document.getElementById("web_gl_canvas");
if (!canvas) {
throw new Error("Canvas with id 'web_gl_canvas' not found");
}
print("Canvas object retrieved");
// vytvoření a získání kontextu WebGL (3D grafika)
const gl = canvas.getContext("webgl");
if (!gl) {
throw new Error("WebGL is not supported or context creation failed");
}
print("WebGL context created");
// vytvoření vertex shaderu
const vertexShader = gl.createShader(gl.VERTEX_SHADER);
if (!vertexShader) {
throw new Error("Failed to create vertex shader.");
}
print("Vertex shader created");
// překlad vertex shaderu
gl.shaderSource(vertexShader, vertexShaderSource);
gl.compileShader(vertexShader);
if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
const log = gl.getShaderInfoLog(vertexShader);
gl.deleteShader(vertexShader);
throw new Error(`Vertex shader compile failed: ${log}`);
}
print("Vertex shader compiled");
// vytvoření fragment shaderu
const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
if (!fragmentShader) {
throw new Error("Failed to create fragment shader.");
}
print("Fragment shader created");
// překlad fragment shaderu
gl.shaderSource(fragmentShader, fragmentShaderSource);
gl.compileShader(fragmentShader);
if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
const log = gl.getShaderInfoLog(fragmentShader);
gl.deleteShader(fragmentShader);
throw new Error(`fragment shader compile failed: ${log}`);
}
print("Fragment shader compiled");
// registrace obou shaderů
const program = gl.createProgram();
if (!program) {
throw new Error("Failed to create program.");
}
print("Program created");
gl.attachShader(program, vertexShader);
gl.attachShader(program, fragmentShader);
print("Shaders attached to the program");
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
const log = gl.getProgramInfoLog(program);
gl.deleteProgram(program);
throw new Error(`Program link failed: ${log}`);
}
print("Program linked");
const min_x = -0.9
const max_x = 0.9
const min_y = min_x
const max_y = max_x
// souřadnice vrcholů trojúhelníku + souřadnice v prostoru textury
const vertexes = [
// x, y, u, v
min_x, min_y, 0.0, 0.0,
min_x, max_y, 0.0, 1.0,
max_x, max_y, 1.0, 1.0,
min_x, min_y, 0.0, 0.0,
max_x, max_y, 2.0, 2.0,
max_x, min_y, 2.0, 0.0,
];
// buffer, do kterého se překopírují souřadnice bodu
const vertexBuffer = gl.createBuffer();
if (!vertexBuffer) {
throw new Error("Failed to create buffer.");
}
print("Vertex buffer created");
gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
const data = new Float32Array(vertexes);
gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
print("Vertex buffer filled-in by vertexes");
// navázání na parametr předávaný do vertex shaderu
const p = gl.getAttribLocation(program, "position");
if (p === -1) {
throw new Error("Attribute 'position' not found in shader program");
}
print("Attribute 'position' found in shader program")
// navázání na parametr předávaný do vertex shaderu
const texLoc = gl.getAttribLocation(program, "texcoord");
if (p === -1) {
throw new Error("Attribute 'texcoord' not found in shader program");
}
print("Attribute 'texcoord' found in shader program")
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(p,
2, // počet prvků v každém atributu
gl.FLOAT, // typ prvků
gl.FALSE, // data nejsou normalizována
4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
0 // offset
);
gl.enableVertexAttribArray(p);
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(texLoc,
2, // počet prvků v každém atributu
gl.FLOAT, // typ prvků
gl.FALSE, // data nejsou normalizována
4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
2*Float32Array.BYTES_PER_ELEMENT // offset
);
gl.enableVertexAttribArray(texLoc);
// textura (prozatím primitivní)
const texture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
const textureWidth = 256
const textureHeight = 256
// textura
textureArray = makeTexture(textureWidth, textureHeight);
const texels = new Uint8Array(textureArray);
gl.texImage2D(gl.TEXTURE_2D, // typ textury: zde 2D textura
0, // úroveň detailu
gl.RGBA, // počet barvových komponent (zde 4)
textureWidth, // horizontální rozlišení textury
textureHeight, // vertikální rozlišení textury
0, // šířka okraje textury
gl.RGBA, // formát uložení texelů
gl.UNSIGNED_BYTE, // typ každé barvové složky texelu
texels // pole texelů
);
// způsob vykreslení textury
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
// navázání na atribut ve shaderech
const samplerLoc = gl.getUniformLocation(program, "texture");
gl.uniform1i(samplerLoc, 0);
// transformace souřadnic: z normalizovaných souřadnic na souřadnice na plátnu
gl.viewport(0, 0, canvas.width, canvas.height);
// nastavení barvy pro vymazání barvového bufferu
gl.clearColor(0, 0, 0, 1);
// vymazání barvového bufferu
gl.clear(gl.COLOR_BUFFER_BIT);
// spuštění programu
gl.useProgram(program);
// vykreslení dvojice trojúhelníků
gl.drawArrays(gl.TRIANGLES, 0, 6);
Textury s malým rozlišením
Rozlišení 2D textury je obecně odlišné od rozlišení stěny, která je vykreslena do výsledné scény. Mnohdy je rozlišení textury mnohem menší, což si ostatně můžeme poměrně snadno nasimulovat. Nejprve nepatrně pozměníme funkci makeTexture tak, aby se pro libovolnou požadovanou velikost textury vždy vygenerovala šachovnice 8×8 políček (výpočet nebude plně funkční pro textury menší než 8×8 texelů, to je však již extrém):
function makeTexture(width, height) {
const array = new Array(width*height*4);
const divider = width / 8;
let index = 0;
for (j=0; j<height; j++) {
for (i=0; i<width; i++) {
const c = ((i÷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;
}
Následně si necháme vygenerovat texturu s rozlišením pouhých 16×16 texelů:
const textureWidth = 16 const textureHeight = 16 // textura textureArray = makeTexture(textureWidth, textureHeight);
Výsledek pokrytí stěny (dvou trojúhelníků) takovou texturou je dostupný na stránce https://tisnik.github.io/temp/textures8.html.
Bilineární interpolace
Zvětšování rastrových obrázků tak, aby lidský zrak zaznamenal co nejmenší vizuální chyby, je poměrně rozsáhlá problematika. Vlastně se v ní snažíme do obrázku přidat další detaily, ke kterým ovšem nemáme příslušné informace. Většina triků, která se používá, spočívá v odstranění hran, které vznikají při naivním zvětšování jednotlivých pixelů (původní ploška s konstantní barvou se tedy zvětšuje). Tyto hrany jsou pro lidský zrak rušivé. Nejrychlejší je lineární interpolace mezi dvěma sousedními pixely. Ovšem vzhledem k tomu, že provádíme zobrazení 2D mřížky, musí se provádět interpolace jak ve směru osy x, tak i ve směru osy y. Z tohoto důvodu se používá termín bilineární interpolace. A ta je podporována i v Open GL (ES) při nanášení textur. Povoluje se ovšem v prostoru textury, tedy pro souřadnice u a v. V dalším výpisu se konkrétně jedná o druhý řádek:
// způsob vykreslení textury gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
Demonstrační příklad: vykreslení textury s využitím bilineární interpolace
Po zapnutí bilineární interpolace při zvětšování texelů (nikoli při jejich zmenšování) se na základě barev čtyř sousedních texelů a uv-souřadnic v texturovacím prostoru vypočte nová barva. U malých textur, které se hodně zvětšují, je výsledek kvůli provedené interpolaci značně rozmazaný, což je ostatně dobře viditelné, pokud si příklad spustíte z adresy
https://tisnik.github.io/temp/textures9.html.
Následuje výpis úplného zdrojového kódu tohoto demonstračního příkladu:
const vertexShaderSource = `
attribute vec2 position;
attribute vec2 texcoord;
varying vec2 vTexcoord;
void main() {
gl_Position = vec4(position, 0, 1);
vTexcoord = texcoord;
}
`
const fragmentShaderSource = `
precision mediump float;
varying vec2 vTexcoord;
uniform sampler2D texture;
void main() {
gl_FragColor = texture2D(texture, vTexcoord);
}
`
function print(message) {
console.log(message);
}
function makeTexture(width, height) {
const array = new Array(width*height*4);
const divider = width / 8;
let index = 0;
for (j=0; j<height; j++) {
for (i=0; i<width; i++) {
const c = ((i÷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
// souřadnice vrcholů trojúhelníku + souřadnice v prostoru textury
const vertexes = [
// x, y, u, v
min_x, min_y, 0.0, 0.0,
min_x, max_y, 0.0, 1.0,
max_x, max_y, 1.0, 1.0,
min_x, min_y, 0.0, 0.0,
max_x, max_y, 1.0, 1.0,
max_x, min_y, 1.0, 0.0,
];
// buffer, do kterého se překopírují souřadnice bodu
const vertexBuffer = gl.createBuffer();
if (!vertexBuffer) {
throw new Error("Failed to create buffer.");
}
print("Vertex buffer created");
gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
const data = new Float32Array(vertexes);
gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
print("Vertex buffer filled-in by vertexes");
// navázání na parametr předávaný do vertex shaderu
const p = gl.getAttribLocation(program, "position");
if (p === -1) {
throw new Error("Attribute 'position' not found in shader program");
}
print("Attribute 'position' found in shader program")
// navázání na parametr předávaný do vertex shaderu
const texLoc = gl.getAttribLocation(program, "texcoord");
if (p === -1) {
throw new Error("Attribute 'texcoord' not found in shader program");
}
print("Attribute 'texcoord' found in shader program")
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(p,
2, // počet prvků v každém atributu
gl.FLOAT, // typ prvků
gl.FALSE, // data nejsou normalizována
4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
0 // offset
);
gl.enableVertexAttribArray(p);
// seznam předávaný do vertex shaderu
gl.vertexAttribPointer(texLoc,
2, // počet prvků v každém atributu
gl.FLOAT, // typ prvků
gl.FALSE, // data nejsou normalizována
4*Float32Array.BYTES_PER_ELEMENT, // velikost vertexu+texturovacích souřadnic v bajtech
2*Float32Array.BYTES_PER_ELEMENT // offset
);
gl.enableVertexAttribArray(texLoc);
// textura (prozatím primitivní)
const texture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
const textureWidth = 16
const textureHeight = 16
// textura
textureArray = makeTexture(textureWidth, textureHeight);
const texels = new Uint8Array(textureArray);
gl.texImage2D(gl.TEXTURE_2D, // typ textury: zde 2D textura
0, // úroveň detailu
gl.RGBA, // počet barvových komponent (zde 4)
textureWidth, // horizontální rozlišení textury
textureHeight, // vertikální rozlišení textury
0, // šířka okraje textury
gl.RGBA, // formát uložení texelů
gl.UNSIGNED_BYTE, // typ každé barvové složky texelu
texels // pole texelů
);
// způsob vykreslení textury
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
// navázání na atribut ve shaderech
const samplerLoc = gl.getUniformLocation(program, "texture");
gl.uniform1i(samplerLoc, 0);
// transformace souřadnic: z normalizovaných souřadnic na souřadnice na plátnu
gl.viewport(0, 0, canvas.width, canvas.height);
// nastavení barvy pro vymazání barvového bufferu
gl.clearColor(0, 0, 0, 1);
// vymazání barvového bufferu
gl.clear(gl.COLOR_BUFFER_BIT);
// spuštění programu
gl.useProgram(program);
// vykreslení dvojice trojúhelníků
gl.drawArrays(gl.TRIANGLES, 0, 6);
Role alfa složky, kterou obsahují texely
V předchozích článcích o OpenGL ES jsme se již několikrát setkali s formátem používaným při práci s barvami. Barvy jsou v tomto barvovém formátu (resp. přesněji řečeno v barvovém prostoru) popsány s využitím tří barvových složek R (red), G (green) a B (blue). K těmto složkám se často přidává ještě složka čtvrtá, nazývaná A (Alfa). Výsledný barevný model se z tohoto důvodu označuje zkratkou RGBA. Pomocí alfa složky (někdy také nazývané alfa-kanál) lze specifikovat míru průhlednosti resp. neprůhlednosti vybraných objektů nebo jejich plošek. Alfa složku lze také nastavit samostatně pro každý texel ve vykreslované textuře, čehož se využívá při programování mnoha grafických efektů, například výbuchů či „magických jevů“ (a možná je až nadužíván).
Při spuštění programu, který používá pro vykreslování grafickou knihovnu OpenGL, je vliv alfa složky na vykreslovanou plošku ve výchozím nastavení zakázán. Proto, pokud chceme programovat některé grafické efekty, musíme před vykreslením vhodně nastavit režim míchání již nakreslené části scény s nově vykreslovanými tělesy.
Vygenerování textury s nastavenými alfa složkami texelů
Pro ukázku vlivu hodnoty alfa složky jednotlivých texelů na způsob vykreslení textury upravíme funkci pro vyplnění texelů hodnotami RGBA. Namísto šachovnicového vzorku se vypočítá gradientní barvový přechod, ovšem bude se měnit alfa složka texelů tvořících bloky 8×8 texelů. U sousedních bloků se bude alfa složka měnit z hodnoty 0 na 255 a naopak:
function makeTexture(width, height) {
const array = new Array(width*height*4);
const divider = width / 8;
let index = 0;
for (j=0; j<height; j++) {
for (i=0; i<width; i++) {
const alpha = ((i÷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;
}
Textura se zkonstruuje následujícím způsobem:
gl.texImage2D(gl.TEXTURE_2D, // typ textury: zde 2D textura
0, // úroveň detailu
gl.RGBA, // počet barvových komponent (zde 4)
textureWidth, // horizontální rozlišení textury
textureHeight, // vertikální rozlišení textury
0, // šířka okraje textury
gl.RGBA, // formát uložení texelů
gl.UNSIGNED_BYTE, // typ každé barvové složky texelu
texels // pole texelů
);
Demonstrační příklad: vykreslení textury s texely ve formáty RGBA obsahující různé hodnoty alfa složky
V dalším demonstračním příkladu se pokusíme o vykreslení stěny, na kterou je nanesena textura s texely ve formátu RGBA. Tyto texely mají alfa složku nastavenou na hodnotu 0 či 255. Příklad je dostupný na adrese https://tisnik.github.io/temp/texturesA.html.
Povšimněte si, že průhlednost v tomto případě není vypočtena korektně, protože přes průhledné texely by měla „prosvítat“ barva pozadí. Důvodem je fakt, že jsme nepovolili takzvaný blending zmíněný v navazujících kapitolách.
Úplný zdrojový kód tohoto demonstračního příkladu vypadá následovně:
const vertexShaderSource = `
attribute vec2 position;
attribute vec2 texcoord;
varying vec2 vTexcoord;
void main() {
gl_Position = vec4(position, 0, 1);
vTexcoord = texcoord;
}
`
const fragmentShaderSource = `
precision mediump float;
varying vec2 vTexcoord;
uniform sampler2D texture;
void main() {
gl_FragColor = texture2D(texture, vTexcoord);
}
`
function print(message) {
console.log(message);
}
function makeTexture(width, height) {
const array = new Array(width*height*4);
const divider = width / 8;
let index = 0;
for (j=0; j<height; j++) {
for (i=0; i<width; i++) {
const alpha = ((i÷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);
// navázání na atribut ve shaderech
const samplerLoc = gl.getUniformLocation(program, "texture");
gl.uniform1i(samplerLoc, 0);
// transformace souřadnic: z normalizovaných souřadnic na souřadnice na plátnu
gl.viewport(0, 0, canvas.width, canvas.height);
// nastavení barvy pro vymazání barvového bufferu
gl.clearColor(0, 0, 0, 1);
// vymazání barvového bufferu
gl.clear(gl.COLOR_BUFFER_BIT);
// spuštění programu
gl.useProgram(program);
// vykreslení dvojice trojúhelníků
gl.drawArrays(gl.TRIANGLES, 0, 6);
Povolení blendingu a určení způsobu výpočtu výsledné barvy fragmentů
Aby se korektně pracovalo s alfa složkami texelů, je nutné povolit a nakonfigurovat blending (tj. míchání barev). Především musíme nejdříve specifikovat, jakým způsobem se budou kombinovat právě vykreslované fragmenty s hodnotami uloženými ve framebufferu.
Způsob míchání barvy uložené ve framebufferu a barvy vykreslovaného fragmentu se řídí uživatelem definovanou míchací rovnicí (blending function). V této rovnici vystupují následující členy:
- Zdroj (source) je fragment vzniklý rasterizací v právě běžícím rasterizačním procesu.
- Cíl (destination) je hodnota zapsaná ve framebufferu, tj. barva fragmentu, který již byl vykreslen dříve. Tato hodnota bude v závislosti na nastavené blending funkci přepsána nebo jinak ovlivněna.
V knihovně OpenGL lze stanovit koeficienty míchání pro každou barevnou složku zvlášť. Tak lze jednoduše dosáhnout na první pohled složitých efektů, například maskování jedné barvy apod.
Míchací rovnice použitá při blendingu
Míchací rovnici (původně zapsanou ve vektorovém tvaru), která se při blendingu používá pro výpočet nové barvy fragmentu, lze rozepsat do čtyř rovnic odpovídajících barvovému modelu RGBA:
Rn=RsSr+RdDr
Gn=GsSg+GdDg
Bn=BsSb+BdDb
An=AsSa+AdDa
Význam jednotlivých členů v těchto čtyřech rovnicích je následující:
| Člen | Význam |
|---|---|
| Rn | nově vypočtená červená barevná složka |
| Gn | nově vypočtená zelená barevná složka |
| Bn | nově vypočtená modrá barevná složka |
| An | nová hodnota alfa složky |
| Rs | červená barevná složka zdrojového fragmentu |
| Gs | zelená barevná složka zdrojového fragmentu |
| Bs | modrá barevná složka zdrojového fragmentu |
| As | alfa složka zdrojového fragmentu |
| Rd | červená barevná složka cílového fragmentu |
| Gd | zelená barevná složka cílového fragmentu |
| Bd | modrá barevná složka cílového fragmentu |
| Ad | alfa složka cílového fragmentu |
| Sr | míchací faktor pro červenou barvu zdrojového fragmentu |
| Sg | míchací faktor pro zelenou barvu zdrojového fragmentu |
| Sb | míchací faktor pro modrou barvu zdrojového fragmentu |
| Sa | míchací faktor pro alfa složku zdrojového fragmentu |
| Dr | míchací faktor pro červenou barvu cílového fragmentu |
| Dg | míchací faktor pro zelenou barvu cílového fragmentu |
| Db | míchací faktor pro modrou barvu cílového fragmentu |
| Da | míchací faktor pro alfa složku cílového fragmentu |
Stačí si však zapamatovat význam jednotlivých písmen: R-red, G-green, B-blue, A-alpha, n-new fragment, s-source fragment, d-destination fragment.
Ve výše uvedených rovnicích je nutné specifikovat míchací faktory (koeficienty) Sr, Sg, Sb, Sa, Dr, Dg, Db a Da, ostatní hodnoty odpovídají barvám a alfa-složkám zdrojových a cílových fragmentů. Koeficienty S a D se nezadávají přímo číselnou hodnotou, protože se mohou měnit v závislosti na barvách zdrojových a cílových fragmentů. Místo toho se používají symboly, jejichž konkrétní hodnota se vypočte automaticky při rasterizaci.
Funkce blendFunc
Pro zadání míchacích koeficientů se v OpenGL (ES) používá funkce:
void gl.blendFunc(GLenum sFactor, GLenum dFactor);
První parametr <tt>sFactor</tt> určuje způsob výpočtu míchacích faktorů Sr, Sg, Sb a Sa, druhý parametr <tt>dFactor</tt> způsob výpočtu faktorů Dr, Dg, Db a Da.
Pro hodnoty, které lze do těchto parametrů dosadit, platí základní pravidla:
- Za <tt>sFactor</tt> popř. <tt>dFactor</tt> lze dosadit některou z konstant, které jsou předdefinovány v hlavičkovém souboru gl.h (neplatí pro WebGL).
- Některé z těchto konstant lze zadat do obou parametrů. Jedná se například o konstanty GL_ZERO, GL_ONE apod. Význam těchto konstant se samozřejmě liší podle toho, do kterého parametru jsou dosazeny.
- Některé konstanty lze použít pouze pro parametr <tt>sFactor</tt>. Jedná se například o konstanty GL_DST_COLOR nebo GL_ONE_MINUS_DST_COLOR.
- Další konstanty lze naopak použít pouze pro parametr <tt>dFactor</tt>. Konkrétně se jedná o konstanty GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR apod.
Příklad volby míchací funkce v prostředí využívajícího WebGL:
// povolení blendingu gl.enable(gl.BLEND); gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
Význam předpřipravených míchacích faktorů
V následující tabulce je vypsán význam míchacích faktorů, které můžeme použít pro specifikaci koeficientů míchací rovnice. Ve sloupci Název je zapsáno jméno faktoru, tj. symbolická konstanta definovaná v souboru gl.h (opět: neplatí pro prostředí s WebGL). Ve sloupci Použití je označeno, zda se může symbolická konstanta použít pro dosazení do parametru sFactor (S), dFactor (D) nebo do obou parametrů. Ve sloupci Význam jsou ve vektorovém tvaru naznačeny hodnoty zdrojových či cílových koeficientů.
| Název | Použití | Význam |
|---|---|---|
| GL_ZERO | S nebo D | (0, 0, 0, 0) |
| GL_ONE | S nebo D | (1, 1, 1, 1) |
| GL_DST_COLOR | S | (Rd, Gd, Bd, Ad) |
| GL_SRC_COLOR | D | (Rs, Gs, Bs, As) |
| GL_ONE_MINUS_DST_COLOR | S | (1, 1, 1, 1)-(Rd, Gd, Bd, Ad) |
| GL_ONE_MINUS_SRC_COLOR | D | (1, 1, 1, 1)-(Rs, Gs, Bs, As) |
| GL_SRC_ALPHA | S nebo D | (As, As, As, As) |
| GL_ONE_MINUS_SRC_ALPHA | S nebo D | (1, 1, 1, 1)-(As, As, As, As) |
| GL_DST_ALPHA | S nebo D | (Ad, Ad, Ad, Ad) |
| GL_ONE_MINUS_DST_ALPHA | S nebo D | (1, 1, 1, 1)-(Ad, Ad, Ad, Ad) |
| GL_SRC_ALPHA_SATURATE | S | (f, f, f, 1) f=min(As, 1-Ad) |
V praxi bude nejtypičtější nastavení s výpočtem průhlednosti realizováno následovně:
// povolení blendingu gl.enable(gl.BLEND); gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
Demonstrační příklad: vykreslení textury s texely ve formátu RGBA společně s výpočtem blendingu
V dalším demonstračním příkladu je ukázána nejčastější konfigurace blendingu. Alfa složka textury je použita pro výpočet barvy fragmentu ze dvou složek: původní barvy fragmentu (což je v našem případě barva pozadí) a RGBA složky texelu přečteného z textury. Výsledek je uložen zpět do barvového bufferu.
Ukažme si, jak bude vypadat výsledek v případě, kdy je nastavena černá barva pozadí a některé texely v textuře jsou zcela průhledné. Program pro vykreslení scény je dostupný na adrese https://tisnik.github.io/temp/texturesB.html.
Výsledek je tedy korektní – přes průsvitné texely je vidět barva pozadí.
Zdrojový kód tohoto demonstračního příkladu vypadá následovně:
const vertexShaderSource = `
attribute vec2 position;
attribute vec2 texcoord;
varying vec2 vTexcoord;
void main() {
gl_Position = vec4(position, 0, 1);
vTexcoord = texcoord;
}
`
const fragmentShaderSource = `
precision mediump float;
varying vec2 vTexcoord;
uniform sampler2D texture;
void main() {
gl_FragColor = texture2D(texture, vTexcoord);
}
`
function print(message) {
console.log(message);
}
function makeTexture(width, height) {
const array = new Array(width*height*4);
const divider = width / 8;
let index = 0;
for (j=0; j<height; j++) {
for (i=0; i<width; i++) {
const alpha = ((i÷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);
// povolení blendingu
gl.enable(gl.BLEND);
gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
// navázání na atribut ve shaderech
const samplerLoc = gl.getUniformLocation(program, "texture");
gl.uniform1i(samplerLoc, 0);
// transformace souřadnic: z normalizovaných souřadnic na souřadnice na plátnu
gl.viewport(0, 0, canvas.width, canvas.height);
// nastavení barvy pro vymazání barvového bufferu
gl.clearColor(0, 0, 0, 1);
// vymazání barvového bufferu
gl.clear(gl.COLOR_BUFFER_BIT);
// spuštění programu
gl.useProgram(program);
// vykreslení dvojice trojúhelníků
gl.drawArrays(gl.TRIANGLES, 0, 6);
Vizuální chyby, které při texturování vznikají
V další kapitole si popíšeme mipmapping. Ten představuje techniku, která je často používaná pro odstranění či alespoň zmenšení některých vizuálních chyb (resp. přesněji řečeno nežádoucích rozdílů mezi jednotlivými snímky) vzniklých při pohybu těles s nanesenou texturou v trojrozměrné scéně nebo při pohybu celé scény (tj. změně orientace nebo pozice pozorovatele). Obraz těles s nanesenou texturou se na obrazovce při pohybu zmenšuje, zvětšuje či jinak deformuje, čímž také dochází k nutnosti zvětšování a zmenšování textury při nanášení texelů (rastrových elementů textury) na zobrazované pixely.
Při zvětšování a zmenšování textury můžeme pro zamezení některých vizuálních chyb využít filtraci. Nejrychlejšího zobrazení scény však dosáhneme vypnutím filtrace a výběrem vždy pouze jednoho nejbližšího texelu z textury pro každý vykreslovaný pixel:
gl.texParameteri(TEXTURE_2D,
TEXTURE_MAG_FILTER,
NEAREST);
gl.texParameteri(TEXTURE_2D,
TEXTURE_MIN_FILTER,
NEAREST);
Předchozí způsob je sice nejrychlejší, současně však žádným způsobem neřeší vznik artefaktů, například moaré, způsobeného podvzorkováním obrazu. V OpenGL lze využít několika způsobů, které zamezují vznikům těchto artefaktů při zvětšování a zejména zmenšování textur. Pokud se vykresluje statická scéna, je možné použít pouze vhodné filtrace, pracující na principu výběru několika sousedních texelů a jejich bilineární interpolaci při výpočtu barvy vykreslovaného pixelu:
gl.texParameteri(TEXTURE_2D,
TEXTURE_MAG_FILTER,
LINEAR);
gl.texParameteri(TEXTURE_2D,
TEXTURE_MIN_FILTER,
LINEAR);
Nevýhodou předchozího způsobu je ovšem určité zpomalení vykreslování, zejména díky faktu, že se musí provádět více přístupů do texturovací paměti, která v dnešní době představuje úzké hrdlo grafických akcelerátorů (rychlost použitých pamětí na grafických akcelerátorech roste mnohem pomaleji než výpočetní výkon použitých grafických procesorů – GPU).
V některých případech, zejména při požadavku na vyšší kvalitu obrázků, je možné použít antialiasing, který se v OpenGL provádí tak, že se scéna vykreslí ve vyšším rozlišení než je rozlišení obrazovky a poté se provede snížení rozlišení pomocí filtrace s vhodným jádrem filtru (kernelem).
Při animacích však kromě moaré vznikají i další artefakty z nichž nejviditelnější je „problikávání“ pixelů na příliš zmenšených texturách, tj. například texturách nanesených na vzdálených objektech. V těchto případech už běžná filtrace (pracující pouze pro těsné okolí nanášených texelů) není příliš prospěšná, protože s každým pohybem otexturovaného tělesa se může v rovině textury provést posun až o několik desítek texelů, čímž dochází k prudké změně vykreslované barvy.
Textury s více úrovněmi detailu
Pro zamezení problikávání se používají textury uložené ve více rozlišeních (tj. úrovních detailu). Při vykreslování otexturovaného povrchu se nejdříve zjistí relativní velikost povrchu vůči celé textuře a poté se vybere vhodné rozlišení textury, která se posléze nanese. Tento postup má nevýhodu v tom, že při postupném zmenšování objektu by docházelo ke skokové změně textury (přešlo by se k menšímu rozlišení textury). Proto se zavádí další úroveň interpolace, kdy se vybere nejbližší větší a nejbližší menší textura a barva pixelů se vypočte interpolací mezi těmito dvěma texturami.
Nyní tedy zbývá pouze volba vhodného rozlišení textur. Z hlediska implementace interpolátoru na grafickém akcelerátoru je nejvýhodnější, aby se rozlišení textury v horizontálním i vertikálním směru snižovalo vždy na polovinu. Počet texelů je v každé následující textuře zmenšen na čtvrtinu až do dosažení textury o velikosti 1×1 texel. Výsledná struktura představující texturu s různými úrovněmi detailů se nazývá mipmapa.
Podpora mipmap v OpenGL
V grafické knihovně OpenGL jsou mipmapy samozřejmě také podporovány, protože se jedná o velmi často používanou vykreslovací pomůcku. Pro každé nastavované rozlišení textury je zapotřebí zavolat již dříve popsanou funkci:
gl.texImage2D(gl.TEXTURE_2D, // typ textury: zde 2D textura
level, // úroveň detailu
gl.RGBA, // počet barvových komponent (zde 4)
textureWidth, // horizontální rozlišení textury
textureHeight, // vertikální rozlišení textury
0, // šířka okraje textury
gl.RGBA, // formát uložení texelů
gl.UNSIGNED_BYTE, // typ každé barvové složky texelu
texels // pole texelů
);
kde se do parametru level zadává úroveň textury v hierarchii. Nulou specifikujeme texturu se základním (tj. nejvyšším) rozlišením, jedničkou texturu s rozlišením polovičním atd. V texturovací paměti grafického akcelerátoru se postupným voláním gl.texImage2D vytvoří takzvaná mipmapa, tj. textura, ve které jsou uloženy všechny velikosti textur rozdělených na jednotlivé barevné složky RGB.
Praktické použití mipmap bude ukázáno v navazujícím článku.
Repositář s demonstračními příklady
Všechny demonstrační příklady, které jsme si v předchozí šestici článků i v dnešním článku ukázali, je možné spustit přímo ve webovém prohlížeči přes odkazy uvedené v tabulce pod tímto odstavcem. Doplněny jsou i odkazy na zdrojové kódy psané v JavaScriptu (ty se automaticky načítají do HTML stránek):
| # | Příklad | Stručný popis | Adresa příkladu |
|---|---|---|---|
| 1 | step1.html | webová stránka s kreslicím plátnem (canvasem) | https://tisnik.github.io/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 |
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
