Rezultat
Kontrole
- Strelica gore/dolje: rotacija oko x osi
- Strelica lijevo/desno: rotacija oko y osi
- 3/4: rotacija oko z osi
- PageUp/PageDown: približavanje/udaljavanje kocke
Smjer usmjerenog osvjetljenja
X: Y: Z:
Uključi osvjetljenje
Opis korištenja osvjetljenja
U primjer je uz usmjereno osvjetljenje dodano i osvjetljenje prostora.
Kao što je dosad naučeno na ovom kolegiju, da bi objekti pravilno "odbijali" svjetlost moramo definirati normale. Tako je za ovu kocku unutar initBuffers() metode nakon dijela koji kreira buffer s pozicijama vrhova, a prije dijela koji radi isto za teksture, dodano sljedeće.
...
kockaVertexNormalBuffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, kockaVertexNormalBuffer);
var vertexNormals = [
// prednja strana
0.0, 0.0, 1.0,
0.0, 0.0, 1.0,
0.0, 0.0, 1.0,
0.0, 0.0, 1.0,
// straznja strana
0.0, 0.0, -1.0,
0.0, 0.0, -1.0,
0.0, 0.0, -1.0,
0.0, 0.0, -1.0,
// gornja strana
0.0, 1.0, 0.0,
0.0, 1.0, 0.0,
0.0, 1.0, 0.0,
0.0, 1.0, 0.0,
// donja strana
0.0, -1.0, 0.0,
0.0, -1.0, 0.0,
0.0, -1.0, 0.0,
0.0, -1.0, 0.0,
// desna strana
1.0, 0.0, 0.0,
1.0, 0.0, 0.0,
1.0, 0.0, 0.0,
1.0, 0.0, 0.0,
// lijeva strana
-1.0, 0.0, 0.0,
-1.0, 0.0, 0.0,
-1.0, 0.0, 0.0,
-1.0, 0.0, 0.0,
];
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertexNormals), gl.STATIC_DRAW);
kockaVertexNormalBuffer.itemSize = 3;
kockaVertexNormalBuffer.numItems = 24;
...
Za svaku "stranicu" kocke je potrebno definirati vektore normale, što zapravo i nije problem, i za kocku je trivijalno. Nakon toga je potrebno unutar drawScene() metode dodati dio koda koji će prepoznati definirane normale.
gl.bindBuffer(gl.ARRAY_BUFFER, kockaVertexNormalBuffer);
gl.vertexAttribPointer(shaderProgram.vertexNormalAttribute, kockaVertexNormalBuffer.itemSize, gl.FLOAT, false, 0, 0);
Također, nakon dijela za korištenje teksture potrebno je definirati opcije za osvjetljenje. Prikaz toga je u nastavku.
// ukoliko je "uključeno" svjetlo
var svjetlo = document.getElementById("svjetlo").checked;
// postavljamo varijablu u shaderu koja će mu govoriti treba li ili ne uključiti svjetlo
gl.uniform1i(shaderProgram.useLightingUniform, svjetlo);
if (svjetlo) {
// osvjetljenje prostora postavljamo na bijelu boju
gl.uniform3f(shaderProgram.ambientColorUniform, 1.0, 1.0, 1.0);
// dohvaćanje smjera u kojem mora svijetliti usmjereno svjetlo
var lightingDirection = [
parseFloat(document.getElementById("smjerX").value),
parseFloat(document.getElementById("smjerY").value),
parseFloat(document.getElementById("smjerZ").value)
];
var adjustedLD = vec3.create();
// normaliziranje "lightingDirection" vektora
vec3.normalize(lightingDirection, adjustedLD);
// promjena smjera vektoru iz razloga što je za računanje potreban vektor koji govori odakle svjetlo ide
vec3.scale(adjustedLD, -1);
// prosljeđujemo svjetlo shaderu
gl.uniform3fv(shaderProgram.lightingDirectionUniform, adjustedLD);
// svjetlo će biti crvene boje
gl.uniform3f(shaderProgram.directionalColorUniform, 1.0, 0.0, 0.0);
}
Dodatne promjene su potrebne i kod setMatrixUniforms() metode. Potrebno je korištenje nove matrice transformacija koja će služiti upravo za transformaciju normala. Nije moguće korištenje već kreirane matrice transformacija jer bi, primjerice, nakon translacije od (0, 0, -5) normala (0, 0, 1) postala (0, 0, -4) što je pogrešno. U metodu je dodano sljedeće:
// pravi način za postizanje da normale pokazuju u pravom smjeru je korištenje transponirane inverzne matrice transformacija.
var normalMatrix = mat3.create();
mat4.toInverseMat3(mvMatrix, normalMatrix);
mat3.transpose(normalMatrix);
gl.uniformMatrix3fv(shaderProgram.nMatrixUniform, false, normalMatrix);
Uz to, potrebno je u metodu initShaders() dodati kod koji će inicijalizirati "vertexNormalAttribute" tako da program iz metode drawScene() može shaderu proslijediti normale.
shaderProgram.vertexNormalAttribute = gl.getAttribLocation(shaderProgram, "aVertexNormal");
gl.enableVertexAttribArray(shaderProgram.vertexNormalAttribute);
shaderProgram.useLightingUniform = gl.getUniformLocation(shaderProgram, "uUseLighting");
shaderProgram.ambientColorUniform = gl.getUniformLocation(shaderProgram, "uAmbientColor");
shaderProgram.lightingDirectionUniform = gl.getUniformLocation(shaderProgram, "uLightingDirection");
shaderProgram.directionalColorUniform = gl.getUniformLocation(shaderProgram, "uDirectionalColor");
Vrlo bitno, potrebno je promijeniti i programski kod shadera. Prvi na redu je fragment shader koji nema puno promjena. Boju piksela iz teksture dobivamo na isti način, no prije bojanja tu boju se uskladi s vektorom jačine osvjetljenja. To znači da ukoliko svjetlost na piksel pada okomito, on će imati 100% jačinu, a za ostale će to biti manje.
<script id="shader-fs" type="x-shader/x-fragment">
precision mediump float;
varying vec2 vTextureCoord;
varying vec3 vLightWeighting;
uniform sampler2D uSampler;
void main(void) {
vec4 textureColor = texture2D(uSampler, vec2(vTextureCoord.s, vTextureCoord.t));
gl_FragColor = vec4(textureColor.rgb * vLightWeighting, textureColor.a);
}
</script>
Sada na red dolazi vertex shader u kojem se računa jačina osvjetljavanja.
<script id="shader-vs" type="x-shader/x-vertex">
attribute vec3 aVertexPosition;
attribute vec3 aVertexNormal; // normale verteksa
attribute vec2 aTextureCoord;
uniform mat4 uMVMatrix;
uniform mat4 uPMatrix;
uniform mat3 uNMatrix; // matrica normala
uniform vec3 uAmbientColor; // boja osvjetljenja prostora
uniform vec3 uLightingDirection;// smjer usmjerenog svjetla
uniform vec3 uDirectionalColor; // boja usmjerenog svjetla
uniform bool uUseLighting; // svjetlo uključeno/isključeno
varying vec2 vTextureCoord;
varying vec3 vLightWeighting; // jačina osvjetljenja
void main(void) {
gl_Position = uPMatrix * uMVMatrix * vec4(aVertexPosition, 1.0);
vTextureCoord = aTextureCoord;
if (!uUseLighting) { // ako svjetlo nije uključeno, osvjetljenje prostora će biti RGB(0.5, 0.5, 0.5);
vLightWeighting = vec3(0.5, 0.5, 0.5);
} else {
// računamo orijentaciju normale
vec3 transformedNormal = uNMatrix * aVertexNormal;
// skalarni produkt normale i smjera usmjerenog svjetla za dobivanje intenziteta, minimum je 0
float directionalLightWeighting = max(dot(transformedNormal, uLightingDirection), 0.0);
// izračunavanje jačine osvjetljavanja
vLightWeighting = uAmbientColor + uDirectionalColor * directionalLightWeighting;
}
}
</script>