Primjer 5 - zrcalno osvjetljavanje i učitavanje vanjskog modela

Rezultat

Opis korištenja osvjetljenja

Uz osvjetljenje prostora je u ovom primjeru dodano zrcalno osvjetljenje, kao i izvor svjetlosti u točki koji emitira svjetlost na sve strane.

Najprije će biti prikazan fragment shader za osvjetljavanje po fragmentu.

              <script id="per-fragment-lighting-fs" type="x-shader/x-fragment">
                precision mediump float;

                varying vec2 vTextureCoord;
                varying vec3 vTransformedNormal;
                varying vec4 vPosition;

                uniform float uMaterialShininess;     // svojstvo odsjaja materijala

                uniform bool uShowSpecularHighlights; // uključivanje/isključivanje osdjaja
                uniform bool uUseLighting;

                uniform vec3 uAmbientColor;

                uniform vec3 uPointLightingLocation;      // "točkasti izvor svjetlosti"
                uniform vec3 uPointLightingSpecularColor;
                uniform vec3 uPointLightingDiffuseColor;

                uniform sampler2D uSampler;

                void main(void) {
                  vec3 lightWeighting;
                  if (!uUseLighting) {
                      lightWeighting = vec3(1.0, 1.0, 1.0);
                  } 
                  else {
                    // računanje smjera osvjetljenja
                    vec3 lightDirection = normalize(uPointLightingLocation - vPosition.xyz);
                    // normiranje
                    vec3 normal = normalize(vTransformedNormal);

                    float specularLightWeighting = 0.0;
                    if (uShowSpecularHighlights) {
                      // smjer promatračevog oka
                      vec3 eyeDirection = normalize(-vPosition.xyz);
                      // GLSL reflect() vraća smjer odbijanja svjetlosti
                      vec3 reflectionDirection = reflect(-lightDirection, normal);
                      // dobivanje "težine" zcralnog osvjetljenja
                      specularLightWeighting = pow(max(dot(reflectionDirection, eyeDirection), 0.0), uMaterialShininess);
                    }

                    // dobivanje "težine" difuznog osvjetljenja
                    float diffuseLightWeighting = max(dot(normal, lightDirection), 0.0);

                    // dobivanje krajnje "težine" osvjetljenja
                    lightWeighting = uAmbientColor
                      + uPointLightingSpecularColor * specularLightWeighting
                      + uPointLightingDiffuseColor * diffuseLightWeighting;
                  }

                  vec4 fragmentColor;
                  fragmentColor = texture2D(uSampler, vec2(vTextureCoord.s, vTextureCoord.t));
                  gl_FragColor = vec4(fragmentColor.rgb * lightWeighting, fragmentColor.a);
                }
              </script>

              <script id="per-fragment-lighting-vs" type="x-shader/x-vertex">
                attribute vec3 aVertexPosition;
                attribute vec3 aVertexNormal;
                attribute vec2 aTextureCoord;

                uniform mat4 uMVMatrix;
                uniform mat4 uPMatrix;
                uniform mat3 uNMatrix;

                varying vec2 vTextureCoord;
                varying vec3 vTransformedNormal;
                varying vec4 vPosition;

                void main(void) {
                  vPosition = uMVMatrix * vec4(aVertexPosition, 1.0);
                  gl_Position = uPMatrix * vPosition;
                  vTextureCoord = aTextureCoord;
                  vTransformedNormal = uNMatrix * aVertexNormal;
                }
              </script>
            

Za vertex shader nije potrebno puno objašnjenja, bitno je spomenuti da je i dalje potrebno računanje lokacije vertexa nakon primjene matrice transformacije i normalu množimo sa matricom normala, a to spremamo u varijable da se mogu koristiti u fragment shaderu.

Učitavanje vanjskog modela

Učitavanje vanjskog modela nije komplicirano. Umjesto metode initBuffers() su korištene dvije metode, loadTeacup() za samo učitavanje datoteke, i handleLoadedTeacup() koja prima objekt s podacima i kreira potrebne buffere.

Vanjska biblioteka je preuzeta s ovog linka, a radi se o datoteci u JSON formatu i opisuje pozicije vertexa, normale i teksture. Za teksturu je korištena ova slika.

              // asinkroni zahtjev za datotekom "teacup.json"
              function loadTeacup() {
                var request = new XMLHttpRequest();
                request.open("GET", "teacup.json");
                request.onreadystatechange = function () {
                  if (request.readyState == 4) {
                    handleLoadedTeacup(JSON.parse(request.responseText));
                  }
                }
                request.send();
              }

              var teacupVertexPositionBuffer;
              var teacupVertexNormalBuffer;
              var teacupVertexTextureCoordBuffer;
              var teacupVertexIndexBuffer;
              // standardna procedura koja bi se inače obavljala u initBuffers() metodi
              function handleLoadedTeacup(teacupData) {
                teacupVertexNormalBuffer = gl.createBuffer();
                gl.bindBuffer(gl.ARRAY_BUFFER, teacupVertexNormalBuffer);
                gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(teacupData.vertexNormals), gl.STATIC_DRAW);
                teacupVertexNormalBuffer.itemSize = 3;
                teacupVertexNormalBuffer.numItems = teacupData.vertexNormals.length / 3;

                teacupVertexTextureCoordBuffer = gl.createBuffer();
                gl.bindBuffer(gl.ARRAY_BUFFER, teacupVertexTextureCoordBuffer);
                gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(teacupData.vertexTextureCoords), gl.STATIC_DRAW);
                teacupVertexTextureCoordBuffer.itemSize = 2;
                teacupVertexTextureCoordBuffer.numItems = teacupData.vertexTextureCoords.length / 2;

                teacupVertexPositionBuffer = gl.createBuffer();
                gl.bindBuffer(gl.ARRAY_BUFFER, teacupVertexPositionBuffer);
                gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(teacupData.vertexPositions), gl.STATIC_DRAW);
                teacupVertexPositionBuffer.itemSize = 3;
                teacupVertexPositionBuffer.numItems = teacupData.vertexPositions.length / 3;

                teacupVertexIndexBuffer = gl.createBuffer();
                gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, teacupVertexIndexBuffer);
                gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(teacupData.indices), gl.STATIC_DRAW);
                teacupVertexIndexBuffer.itemSize = 1;
                teacupVertexIndexBuffer.numItems = teacupData.indices.length;
              }
            

Još je potrebno prikazati drawScene metodu koja iscrtava potrebnu sliku.

              function drawScene() {
                gl.viewport(0, 0, gl.viewportWidth, gl.viewportHeight);
                gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);

                mat4.perspective(45, gl.viewportWidth / gl.viewportHeight, 0.1, 300.0, pMatrix);

                // je li uključeno zrcalno osvjetljenje
                var specularHighlights = document.getElementById("specular").checked;
                gl.uniform1i(shaderProgram.showSpecularHighlightsUniform, specularHighlights);

                // je li uključeno svjetlo
                var svjetlo = document.getElementById("svjetlo").checked;
                gl.uniform1i(shaderProgram.useLightingUniform, svjetlo);
                if (svjetlo) {
                  // osvjetljenje prostora postavljeno na "nisku" razinu
                  gl.uniform3f(shaderProgram.ambientColorUniform, 0.2, 0.2, 0.2);

                  // pozicija "točkastog" osvjetljenja
                  gl.uniform3f(shaderProgram.pointLightingLocationUniform,
                    parseFloat(document.getElementById("pozicijaX").value),
                    parseFloat(document.getElementById("pozicijaY").value),
                    parseFloat(document.getElementById("pozicijaZ").value)
                  );

                  // "točkasto" svjetlo je bijele boje
                  gl.uniform3f(shaderProgram.pointLightingSpecularColorUniform, 1.0, 1.0, 1.0); // bijelo

                  // boja difuznog svjetla
                  gl.uniform3f(shaderProgram.pointLightingDiffuseColorUniform, 0.8, 0.8, 0.8);
                }

                mat4.identity(mvMatrix);
                mat4.translate(mvMatrix, [0, 0, udaljenost]);
                mat4.rotate(mvMatrix, degToRad(xKut), [1, 0, 0]);
                mat4.rotate(mvMatrix, degToRad(yKut), [0, 1, 0]);
                mat4.rotate(mvMatrix, degToRad(zKut), [0, 0, 1]);
                gl.bindTexture(gl.TEXTURE_2D, teacupTextura);
                gl.uniform1i(shaderProgram.samplerUniform, 0);

                // vrijednost odsjaja od materijala
                // veći broj -> manji i oštriji odsjaj
                gl.uniform1f(shaderProgram.materialShininessUniform, parseFloat(document.getElementById("shininess").value));

                gl.bindBuffer(gl.ARRAY_BUFFER, teacupVertexPositionBuffer);
                gl.vertexAttribPointer(shaderProgram.vertexPositionAttribute, teacupVertexPositionBuffer.itemSize, gl.FLOAT, false, 0, 0);

                gl.bindBuffer(gl.ARRAY_BUFFER, teacupVertexTextureCoordBuffer);
                gl.vertexAttribPointer(shaderProgram.textureCoordAttribute, teacupVertexTextureCoordBuffer.itemSize, gl.FLOAT, false, 0, 0);

                gl.bindBuffer(gl.ARRAY_BUFFER, teacupVertexNormalBuffer);
                gl.vertexAttribPointer(shaderProgram.vertexNormalAttribute, teacupVertexNormalBuffer.itemSize, gl.FLOAT, false, 0, 0);

                gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, teacupVertexIndexBuffer);
                setMatrixUniforms();
                gl.drawElements(gl.TRIANGLES, teacupVertexIndexBuffer.numItems, gl.UNSIGNED_SHORT, 0);
              }
            

Funkcionalnost korisničke interakcije nije potrebno pojašnjavati s obzirom na to da je gotovo ista kao i u prethodnom primjeru.