Ortograficzny widok 3D WebGL
Ten post jest kontynuacją serii postów o WebGL. W pierwszym omówiliśmy podstawy, a w poprzednim – macierze 2D. Jeśli jeszcze nie znasz tych artykułów, najpierw się z nimi zapoznaj. W ostatnim poście omówiliśmy, jak działają macierze 2D. Mówiliśmy o tym, że translację, obrót, skalowanie, a nawet rzutowanie z pikseli na przestrzeń przycinania można wykonać za pomocą 1 macierzy i magicznych działań matematycznych na macierzach. Od tego do 3D jest już tylko mały krok. W poprzednich przykładach 2D mieliśmy punkty 2D (x, y), które mnożyliśmy przez macierz 3x3. Aby uzyskać efekt 3D, potrzebujemy punktów 3D (x, y, z) i macierzy 4 x 4. Weźmy nasz ostatni przykład i zmieńmy go na 3D. Ponownie użyjemy litery F, ale tym razem w 3D. Pierwszą rzeczą, którą musimy zrobić, jest zmiana vertex shadera, aby obsługiwał 3D. Oto stary cieniujący.
<script id="2d-vertex-shader" type="x-shader/x-vertex">
attribute vec2 a_position;
uniform mat3 u_matrix;
void main() {
// Multiply the position by the matrix.
gl_Position = vec4((u_matrix * vec3(a_position, 1)).xy, 0, 1);
}
</script>
A oto nowy:
<script id="3d-vertex-shader" type="x-shader/x-vertex">
attribute vec4 a_position;
uniform mat4 u_matrix;
void main() {
// Multiply the position by the matrix.
gl_Position = u_matrix * a_position;
}
</script>
Teraz jest to jeszcze prostsze. Następnie musimy podać dane 3D.
...
gl.vertexAttribPointer(positionLocation, 3, gl.FLOAT, false, 0, 0);
...
// Fill the buffer with the values that define a letter 'F'.
function setGeometry(gl) {
gl.bufferData(
gl.ARRAY_BUFFER,
new Float32Array([
// left column
0, 0, 0,
30, 0, 0,
0, 150, 0,
0, 150, 0,
30, 0, 0,
30, 150, 0,
// top rung
30, 0, 0,
100, 0, 0,
30, 30, 0,
30, 30, 0,
100, 0, 0,
100, 30, 0,
// middle rung
30, 60, 0,
67, 60, 0,
30, 90, 0,
30, 90, 0,
67, 60, 0,
67, 90, 0]),
gl.STATIC_DRAW);
}
Następnie musimy zmienić wszystkie funkcje macierzy z 2D na 3D. Oto wersje 2D (przed) funkcji makeTranslation, makeRotation i makeScale.
function makeTranslation(tx, ty) {
return [
1, 0, 0,
0, 1, 0,
tx, ty, 1
];
}
function makeRotation(angleInRadians) {
var c = Math.cos(angleInRadians);
var s = Math.sin(angleInRadians);
return [
c,-s, 0,
s, c, 0,
0, 0, 1
];
}
function makeScale(sx, sy) {
return [
sx, 0, 0,
0, sy, 0,
0, 0, 1
];
}
A oto zaktualizowane wersje 3D.
function makeTranslation(tx, ty, tz) {
return [
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
tx, ty, tz, 1
];
}
function makeXRotation(angleInRadians) {
var c = Math.cos(angleInRadians);
var s = Math.sin(angleInRadians);
return [
1, 0, 0, 0,
0, c, s, 0,
0, -s, c, 0,
0, 0, 0, 1
];
};
function makeYRotation(angleInRadians) {
var c = Math.cos(angleInRadians);
var s = Math.sin(angleInRadians);
return [
c, 0, -s, 0,
0, 1, 0, 0,
s, 0, c, 0,
0, 0, 0, 1
];
};
function makeZRotation(angleInRadians) {
var c = Math.cos(angleInRadians);
var s = Math.sin(angleInRadians);
return [
c, s, 0, 0,
-s, c, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1,
];
}
function makeScale(sx, sy, sz) {
return [
sx, 0, 0, 0,
0, sy, 0, 0,
0, 0, sz, 0,
0, 0, 0, 1,
];
}
Zauważ, że mamy teraz 3 funkcje obrotu. W przypadku 2D potrzebowaliśmy tylko jednej, ponieważ obracaliśmy się tylko wokół osi Z. Aby jednak uzyskać efekt 3D, chcemy też mieć możliwość obracania wokół osi X i Y. Jak widać, wszystkie są bardzo podobne. Jeśli je rozwiążemy, zobaczysz, że upraszczają się tak jak wcześniej.
Obrót w osi Z
newX = x * c + y * s;
newY = x * -s + y * c;
Obrót w osi Y
newX = x * c + z * s;
newZ = x * -s + z * c;
Obrót w osi X
newY = y * c + z * s;
newZ = y * -s + z * c;
Musimy też zaktualizować funkcję projekcji. Oto stary
function make2DProjection(width, height) {
// Note: This matrix flips the Y axis so 0 is at the top.
return [
2 / width, 0, 0,
0, -2 / height, 0,
-1, 1, 1
];
}
który przekonwertował piksele na przestrzeń klipu. W naszej pierwszej próbie rozszerzenia go do 3D
function make2DProjection(width, height, depth) {
// Note: This matrix flips the Y axis so 0 is at the top.
return [
2 / width, 0, 0, 0,
0, -2 / height, 0, 0,
0, 0, 2 / depth, 0,
-1, 1, 0, 1,
];
}
Podobnie jak w przypadku x i y, musimy przekonwertować z z pikseli na przestrzeń przycinania. W tym przypadku jednostkami przestrzeni Z również są piksele. Przekażę wartość podobną do width dla głębokości,
więc nasza przestrzeń będzie miała szerokość od 0 do szerokości w pikselach, wysokość od 0 do wysokości w pikselach, ale
głębokość będzie wynosić od -głębokość / 2 do +głębokość / 2.
Na koniec musimy zaktualizować kod, który oblicza macierz.
// Compute the matrices
var projectionMatrix =
make2DProjection(canvas.width, canvas.height, canvas.width);
var translationMatrix =
makeTranslation(translation[0], translation[1], translation[2]);
var rotationXMatrix = makeXRotation(rotation[0]);
var rotationYMatrix = makeYRotation(rotation[1]);
var rotationZMatrix = makeZRotation(rotation[2]);
var scaleMatrix = makeScale(scale[0], scale[1], scale[2]);
// Multiply the matrices.
var matrix = matrixMultiply(scaleMatrix, rotationZMatrix);
matrix = matrixMultiply(matrix, rotationYMatrix);
matrix = matrixMultiply(matrix, rotationXMatrix);
matrix = matrixMultiply(matrix, translationMatrix);
matrix = matrixMultiply(matrix, projectionMatrix);
// Set the matrix.
gl.uniformMatrix4fv(matrixLocation, false, matrix);
Pierwszy problem polega na tym, że nasza geometria to płaska litera F, co utrudnia zobaczenie efektu 3D. Aby to naprawić, rozszerzmy geometrię do 3D. Nasza obecna litera F składa się z 3 prostokątów, z których każdy zawiera 2 trójkąty. Aby uzyskać efekt 3D, potrzebujemy łącznie 16 prostokątów. Jest ich zbyt wiele, aby je tu wymienić. 16 prostokątów x 2 trójkąty na prostokąt x 3 wierzchołki na trójkąt daje 96 wierzchołków. Jeśli chcesz zobaczyć je wszystkie, wyświetl źródło próbki. Musimy narysować więcej wierzchołków,
// Draw the geometry.
gl.drawArrays(gl.TRIANGLES, 0, 16 * 6);
Przesuwając suwaki, trudno stwierdzić, że to 3D. Spróbujmy pokolorować każdy prostokąt na inny kolor. Aby to zrobić, dodamy kolejny atrybut do naszego vertex shadera i zmienną, aby przekazać go z vertex shadera do fragment shadera. Oto nowy program do cieniowania wierzchołków
<script id="3d-vertex-shader" type="x-shader/x-vertex">
attribute vec4 a_position;
attribute vec4 a_color;
uniform mat4 u_matrix;
varying vec4 v_color;
void main() {
// Multiply the position by the matrix.
gl_Position = u_matrix * a_position;
// Pass the color to the fragment shader.
v_color = a_color;
}
</script>
Musimy użyć tego koloru w programie do cieniowania fragmentów,
<script id="3d-vertex-shader" type="x-shader/x-fragment">
precision mediump float;
// Passed in from the vertex shader.
varying vec4 v_color;
void main() {
gl_FragColor = v_color;
}
</script>
Musimy wyszukać lokalizację, aby dostarczyć kolory, a następnie skonfigurować kolejny bufor i atrybut, aby nadać mu kolory.
...
var colorLocation = gl.getAttribLocation(program, "a_color");
...
// Create a buffer for colors.
var buffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
gl.enableVertexAttribArray(colorLocation);
// We'll supply RGB as bytes.
gl.vertexAttribPointer(colorLocation, 3, gl.UNSIGNED_BYTE, true, 0, 0);
// Set Colors.
setColors(gl);
...
// Fill the buffer with colors for the 'F'.
function setColors(gl) {
gl.bufferData(
gl.ARRAY_BUFFER,
new Uint8Array([
// left column front
200, 70, 120,
200, 70, 120,
200, 70, 120,
200, 70, 120,
200, 70, 120,
200, 70, 120,
// top rung front
200, 70, 120,
200, 70, 120,
...
...
gl.STATIC_DRAW);
}
Ojej, co to za bałagan? Okazuje się, że wszystkie części trójwymiarowej litery F, czyli przód, tył, boki itd., są rysowane w kolejności, w jakiej występują w geometrii. Nie daje to jednak pożądanych rezultatów, ponieważ czasami elementy z tyłu są rysowane po elementach z przodu. Trójkąty w WebGL mają koncepcję przedniej i tylnej strony. Wierzchołki trójkąta skierowanego do przodu są ułożone zgodnie z ruchem wskazówek zegara. Wierzchołki trójkąta skierowanego do tyłu są ułożone w kierunku przeciwnym do ruchu wskazówek zegara.
WebGL może rysować tylko trójkąty skierowane do przodu lub do tyłu. Możemy włączyć tę funkcję za pomocą
gl.enable(gl.CULL_FACE);
co robimy tylko raz, na samym początku programu. Gdy ta funkcja jest włączona, WebGL domyślnie „odrzuca” trójkąty skierowane do tyłu. „Odrzucanie” w tym przypadku oznacza „nie rysowanie”. Zwróć uwagę, że w przypadku WebGL to, czy trójkąt jest uważany za obracający się zgodnie z ruchem wskazówek zegara czy w lewo, zależy od wierzchołków tego trójkąta w przestrzeni przycinania. Innymi słowy, WebGL określa, czy trójkąt jest z przodu czy z tyłu, PO zastosowaniu obliczeń do wierzchołków w module cieniowania wierzchołków. Oznacza to na przykład, że trójkąt zorientowany zgodnie z ruchem wskazówek zegara, który jest skalowany w osi X o -1, staje się trójkątem zorientowanym w lewo, a trójkąt zorientowany zgodnie z ruchem wskazówek zegara obrócony o 180 stopni wokół osi X lub Y staje się trójkątem zorientowanym w lewo. Ponieważ wyłączyliśmy CULL_FACE, widzimy zarówno trójkąty zgodne z ruchem wskazówek zegara(przód), jak i w lewo(tył). Teraz, gdy włączyliśmy tę funkcję, za każdym razem, gdy trójkąt skierowany do przodu odwróci się z powodu skalowania, obrotu lub z jakiegokolwiek innego powodu, WebGL go nie narysuje. To dobrze, ponieważ gdy obracasz coś w 3D, zazwyczaj chcesz, aby trójkąty, które są skierowane w Twoją stronę, były uważane za skierowane do przodu.
Hej! Gdzie się podziały wszystkie trójkąty? Okazuje się, że wiele z nich jest skierowanych w niewłaściwą stronę. Obróć go, a zobaczysz je, gdy spojrzysz na drugą stronę. Na szczęście można to łatwo naprawić. Wystarczy, że sprawdzimy, które są odwrócone, i zamienimy 2 ich wierzchołki. Jeśli na przykład jeden trójkąt skierowany do tyłu
1, 2, 3,
40, 50, 60,
700, 800, 900,
wystarczy odwrócić 2 ostatnie wierzchołki, aby skierować go do przodu.
1, 2, 3,
700, 800, 900,
40, 50, 60,
To już bliżej, ale jest jeszcze jeden problem. Nawet jeśli wszystkie trójkąty są skierowane we właściwym kierunku, a te skierowane do tyłu są odrzucane, nadal mamy miejsca, w których trójkąty, które powinny być z tyłu, są rysowane nad trójkątami, które powinny być z przodu.
Wejdź do BUFORA GŁĘBOKOŚCI.
Bufor głębokości, czasami nazywany buforem Z, to prostokąt o wymiarach depth pikseli, w którym każdemu pikselowi koloru użytemu do utworzenia obrazu odpowiada 1 piksel głębokości. Gdy WebGL rysuje każdy piksel koloru, może też narysować piksel głębi. Robi to na podstawie wartości, które zwracamy z modułu cieniującego wierzchołki dla Z. Podobnie jak w przypadku osi X i Y, oś Z również jest w przestrzeni wycinka (od -1 do +1). Ta wartość jest następnie konwertowana na wartość przestrzeni głębi (od 0 do +1).
Zanim WebGL narysuje piksel koloru, sprawdzi odpowiadający mu piksel głębi. Jeśli wartość głębi piksela, który ma zostać narysowany, jest większa niż wartość odpowiadającego mu piksela głębi, WebGL nie rysuje nowego piksela koloru. W przeciwnym razie rysuje zarówno nowy piksel koloru z kolorem z programu do cieniowania fragmentów, jak i piksel głębi z nową wartością głębi. Oznacza to, że piksele, które znajdują się za innymi pikselami, nie zostaną narysowane.
Możemy włączyć tę funkcję prawie tak samo łatwo, jak włączyliśmy odrzucanie za pomocą
gl.enable(gl.DEPTH_TEST);
Przed rozpoczęciem rysowania musimy też wyczyścić bufor głębokości do wartości 1.0.
// Draw the scene.
function drawScene() {
// Clear the canvas AND the depth buffer.
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
...
W następnym poście omówię, jak nadać mu perspektywę.
Dlaczego atrybut to vec4, ale rozmiar gl.vertexAttribPointer to 3?
Jeśli zwracasz uwagę na szczegóły, być może zauważyłeś, że zdefiniowaliśmy nasze 2 atrybuty jako
attribute vec4 a_position;
attribute vec4 a_color;
Oba są typu „vec4”, ale gdy mówimy WebGL, jak pobierać dane z buforów, używamy
gl.vertexAttribPointer(positionLocation, 3, gl.FLOAT, false, 0, 0);
gl.vertexAttribPointer(colorLocation, 3, gl.UNSIGNED_BYTE, true, 0, 0);
Wartość „3” w każdym z tych przypadków oznacza, że należy pobrać tylko 3 wartości na atrybut. Działa to, ponieważ w programie do cieniowania wierzchołków WebGL udostępnia wartości domyślne dla tych, których nie podasz. Wartości domyślne to 0, 0, 0, 1, gdzie x = 0, y = 0, z = 0 i w = 1. Dlatego w naszym starym programie do cieniowania wierzchołków 2D musieliśmy wyraźnie podać wartość 1. Przekazywaliśmy x i y, a dla z potrzebowaliśmy wartości 1, ale ponieważ domyślna wartość z to 0, musieliśmy wyraźnie podać 1. W przypadku 3D, mimo że nie podajemy wartości „w”, domyślnie jest ona ustawiona na 1, co jest potrzebne do działania matematyki macierzy.