GLSL dla praktyków: laboratorium shaderów, z którego naprawdę da się korzystać
Shadery GLSL stają się intuicyjne, gdy można zmienić jedną liczbę i zobaczyć wynik w 60 fps. To interaktywne laboratorium zawiera presety shaderów, które można modyfikować w czasie rzeczywistym: fale sinusoidalne modulujące pola kolorów, funkcje szumu generujące teren oraz ray marching budujący sceny 3D wyłącznie z matematyki.
Shaderów nauczyłem się, zmieniając jedną liczbę naraz i obserwując, co się stanie. Lektura matematyki mówiła mi, co robi fala sinusoidalna. Przesunięcie suwaka pokazywało, jak to wygląda, gdy fala sinusoidalna moduluje pole kolorów w 60 fps. To drugie rozumienie zostaje w pamięci. To laboratorium należy do serii Interactive Explorations i do szerszego obszaru inżynierii projektowej.
Poniższy artykuł zawiera interaktywne laboratorium GLSL z presetami shaderów, które można modyfikować w czasie rzeczywistym. Ma ono strukturę warsztatu, nie wykładu: szybka iteracja, wizualny feedback i tyle komentarza, ile trzeba, by zrozumieć, co robi każde pokrętło i dlaczego.
TL;DR
Aby naprawdę opanować GLSL, należy przestać biernie czytać teorię shaderów i zacząć śmiało manipulować uniformami. Warto zmieniać jeden parametr naraz, obserwować, jak deformują się pola przestrzenne i czasowe, a potem zapisać wnioski w postaci wzorców wielokrotnego użytku. Interaktywne laboratorium poniżej daje praktyczną pętlę: wybór presetu, regulacja parametrów Speed, Scale, Detail i Color Shift oraz budowanie intuicji dzięki natychmiastowemu feedbackowi wizualnemu.1
Dlaczego to ma znaczenie w pracy produktowej
Shadery rozwiązują realne problemy produktowe. Tekst o nauce o kolorze w interfejsach wyjaśnia, jak działa percepcja koloru na poziomie teorii; shadery to miejsce, w którym ta teoria staje się wizualnym wynikiem w czasie rzeczywistym. Przydają się przy:
- animowanych tłach budujących nastrój, które pozostają lekkie
- wizualnych sygnaturach marki bez dostarczania ciężkich zasobów wideo
- interaktywnych blokach narracyjnych wewnątrz treści redakcyjnych
- generatywnych systemach wizualnych, które można parametryzować dla każdej kampanii
Laboratorium na tej stronie samo jest przykładem produkcyjnym: komponentem WebGL bez żadnych zależności, osadzonym we wpisie renderowanym po stronie serwera, bez narzędzi do budowania, zgodnym z każdą opisaną niżej zasadą.
Konkretny przypadek: Sorting Visualizer na tej stronie wykorzystuje pełnoekranowy fragment shader jako nastrojowe tło za animacją sortowania. Shader renderuje powoli przesuwający się gradient, który reaguje na postęp algorytmu sortowania: faza koloru przesuwa się wraz z kolejnymi zamianami, tworząc wizualną „temperaturę”, która rośnie razem z pracą algorytmu. Implementacja liczy 48 linii GLSL (wariant plasmy sterowany pojedynczym uniformem u_progress od 0.0 do 1.0). Na MacBooku Air M1 autora shader dodaje 0,3 ms na klatkę do budżetu renderowania, co przy 60 fps (budżet 16,6 ms) jest pomijalne. Na iPhonie 12 Mini (A14, testowanym przez zdalne debugowanie w Safari) ten sam shader dodaje 0,8 ms na klatkę, nadal z dużym zapasem. Shader zastąpił animację gradientu w CSS, która wymagała 6 KB definicji keyframe’ów, nie potrafiła reagować na stan aplikacji i przy każdej zmianie koloru wywoływała ponowne przeliczenie układu. Wersja GLSL jest mniejsza (1,2 KB), komponowana przez GPU (zerowy koszt układu) i sparametryzowana (uniform postępu można podłączyć do dowolnego źródła danych).
Praktycznym ograniczeniem jest zawsze wydajność. Jeśli budżet klatki załamie się na urządzeniach mobilnych, pomysł wizualny jest martwy, bez względu na elegancję matematyki.
Model mentalny, który naprawdę się utrwala
Każdy fragment shader warto traktować jako trzy problemy rozwiązywane po kolei:2
- problem transformacji współrzędnych
- problem sygnału okresowego
- problem mapowania kolorów
W GLSL każdy krok sprowadza się do kilku linii. Typy vec2, vec3 i vec4 to wbudowane typy wektorowe GLSL złożone z 2, 3 i 4 składowych zmiennoprzecinkowych, używane odpowiednio do współrzędnych, kolorów i pikseli wyjściowych:
// Step 1: Coordinates, where am I in normalized space?
vec2 uv = gl_FragCoord.xy / u_resolution; // 0.0 to 1.0
vec2 p = uv * u_scale; // scale the coordinate space
// Step 2: Signal, what scalar field exists at this point and time?
float signal = sin(p.x * 6.28 + u_time); // periodic wave across x-axis
// Step 3: Color, how do I map that scalar to visible output?
vec3 color = vec3(signal * 0.5 + 0.5); // remap -1..1 to 0..1
gl_FragColor = vec4(color, 1.0); // WebGL 1.0 (GLSL ES 1.00) output
Wartości u_resolution, u_scale i u_time to uniformy: wartości, które CPU wysyła do GPU w każdej klatce. Uniformy są powierzchnią sterowania. Zmiana u_scale przybliża lub oddala przestrzeń współrzędnych. Zmiana u_time animuje sygnał. Kod shadera pozostaje ten sam; zachowanie się zmienia, bo zmieniają się dane wejściowe. Laboratorium poniżej udostępnia cztery uniformy (Speed, Scale, Detail, Color Shift), aby można było poczuć to bezpośrednio.
Z tej trzystopniowej pętli da się zbudować niemal wszystko.
Trzy presety, trzy zachowania
Laboratorium zawiera trzy zachowania shaderów, aby można było porównać wzorce:
-
Plasma: nałożone fale
sin()tworzą wzory interferencyjne. Trzy fale sinusoidalne o różnych częstotliwościach i fazach nakładają się na siebie, dając interferencję konstruktywną (jasne pasma tam, gdzie fale się pokrywają) i destruktywną (ciemne pasma tam, gdzie fale się znoszą). Uniform Scale określa, ile cykli fali mieści się w obszarze widoku. Po zwiększeniu wzór interferencyjny zagęszcza się w drobne ziarno. Po zmniejszeniu wyłaniają się szerokie, organiczne gradienty.3glsl float a = sin(p.x + t * 1.1); float b = sin((p.y + t * 0.9) * 1.3); float c = sin((p.x + p.y + t * 0.7) * 0.8); float signal = (a + b + c) / 3.0; -
Contour Rings:
length()oblicza odległość radialną od środka, tworząc płynny gradient, który rośnie od 0.0 w środku do większych wartości na krawędziach. Następniesin()zamienia tę stale rosnącą odległość w powtarzające się fale, z tego samego powodu, dla którego zmarszczki na stawie układają się w koncentryczne kręgi.abs()+smoothstep()wyostrzają te gładkie fale w wyraźne pasma, dając ten sam efekt wizualny co poziomice na mapie topograficznej. Uniform Detail steruje gęstością pasm, mnożąc odległość, zanimsin()ją zawinie: więcej szczegółów oznacza ciaśniejsze pierścienie. Efekt wizualny przypomina skan radaru albo odczyt topograficzny.glsl float d = length(p); float wave = sin((d * 18.0 * u_detail) - t * 2.0); float bands = smoothstep(0.1, 0.85, abs(wave)); -
Flow Warp: shader przekształca współrzędne kartezjańskie na biegunowe (
atandla kąta,lengthdla promienia). Współrzędne biegunowe są tu kluczem: kąt rośnie liniowo podczas obiegu wokół środka, więcsin(8.0 * angle)tworzy osiem promienistych szprych (osiem pełnych cykli sinusa na 360 stopni). Promień rośnie od środka na zewnątrz, więccos(12.0 * radius)tworzy dwanaście koncentrycznych zmarszczek. Ich suma daje wzór interferencyjny: szprychy przecinające pierścienie. Wykładniczy składnik poświaty (exp(-3.0 * radius)) dodaje spadek jasności od środka, ponieważexp(-x)szybko maleje wraz ze wzrostem x. Uniform Color Shift obraca mapowanie odcieni, pokazując, jak to samo pole zniekształceń daje różne palety kolorów.glsl float angle = atan(p.y, p.x); float radius = length(p); float field = sin(8.0 * angle + t * 2.2) + cos(12.0 * radius - t * 1.7); float glow = exp(-3.0 * radius) * (0.6 + 0.4 * sin(t + radius * 8.0));
Wszystkie współdzielą ten sam interfejs uniformów (Speed, Scale, Detail, Color Shift), dzięki czemu można poczuć, jak identyczne kontrolki dają różne rezultaty w zależności od projektu sygnału.
Zwycięska strategia szybkiej nauki
W laboratorium warto zastosować następującą sekwencję:
- Zacząć od Plasma, ustawić niską wartość Scale, a następnie zwiększyć Speed.
- Przełączyć na Contour Rings, zwiększyć szczegółowość, zmniejszyć prędkość.
- Przełączyć na Flow Warp, a następnie przeciągnąć suwak przesunięcia koloru, aby zobaczyć mapowanie fazy.
- Zatrzymać animację i porównać nieruchome klatki między presetami.
- Wrócić do ulubionego presetu i dostroić go pod określony, zawężony cel stylistyczny (spokojny, agresywny, techniczny, filmowy).
Ta pętla wymusza świadome decyzje estetyczne zamiast przypadkowego kręcenia parametrami. Ten sam rodzaj ustrukturyzowanej eksploracji estetycznej dotyczy napięcia między pięknem a brutalizmem w projektowaniu, gdzie ograniczenie odsłania charakter.
Ćwiczenie: po kroku 5 należy zapisać trzy słowa opisujące stworzony obraz. Potem przestawić jeden suwak na przeciwną skrajność i zapisać trzy nowe słowa. Porównać oba opisy. Różnica między nimi to własna powierzchnia gustu: zakres efektów wizualnych, które da się nazwać i do których można świadomie dojść. Warto powtórzyć ćwiczenie z innymi presetami, aby tę powierzchnię poszerzyć.
Typowe błędy na początku nauki GLSL
Trzy błędy pojawiają się niemal w każdym pierwszym shaderze:
Brak normalizacji współrzędnych. gl_FragCoord zwraca współrzędne w pikselach (od 0 do 1920 na ekranie 1080p). Bez dzielenia przez u_resolution każde sin() i cos() operuje na ogromnych wartościach, dając szum wizualny zamiast płynnych wzorów. Rozwiązaniem jest zawsze pierwsza linia: vec2 uv = gl_FragCoord.xy / u_resolution;
Traktowanie zakresu kolorów jako -1 do 1. sin() zwraca wartości od -1.0 do 1.0, ale kanały koloru oczekują wartości od 0.0 do 1.0. Ujemne wartości koloru są obcinane do czerni, co daje ostre pasma zamiast płynnych gradientów. Wzór przemapowania signal * 0.5 + 0.5 zamienia zakres -1..1 na 0..1. Każdy shader w powyższym laboratorium używa tego wzorca.
Animowanie bez u_time. Shader, który używa wyłącznie współrzędnych przestrzennych, daje statyczny obraz. Animacja wymaga uniformu czasu, który CPU zwiększa w każdej klatce i wysyła do GPU. Sam shader nigdy nie śledzi czasu: otrzymuje bieżący czas jako uniform i oblicza klatkę tak, jakby ta chwila była jedyną. Każda klatka jest czystą funkcją swoich danych wejściowych.
Debugowanie błędów shaderów
Błędy shaderów WebGL pojawiają się w konsoli przeglądarki. Na początku wyglądają zagadkowo, ale układają się w przewidywalne wzorce. Oto trzy błędy, które pojawiają się najczęściej, i ich znaczenie:
ERROR: 0:12: 'u_resolution' : undeclared identifier: shader odwołuje się do uniformu, który nigdy nie został zadeklarowany. Albo w źródle shadera brakuje deklaracji uniform, albo nazwa zawiera literówkę. Rozwiązanie: dodać uniform vec2 u_resolution; na początku fragment shadera, przed void main().
ERROR: 0:8: '' : compilation terminated: shader zawiera błąd składni przed linią 8. GLSL wymaga składni w stylu C: średnika na końcu każdej instrukcji, domkniętych nawiasów klamrowych i braku końcowych przecinków. Najczęstszą przyczyną jest brakujący średnik w poprzedniej linii. Rozwiązanie: sprawdzić linie 1-7 pod kątem brakujących średników, niedomkniętych nawiasów lub błędnych nazw typów.
Czarny lub biały canvas bez błędów w konsoli: shader skompilował się i zlinkował poprawnie, ale wartości wyjściowe wykraczają poza zakres 0.0-1.0. gl_FragColor oczekuje, że każdy kanał (R, G, B, A) mieści się między 0.0 a 1.0. Wartości powyżej 1.0 są obcinane do bieli. Wartości poniżej 0.0 są obcinane do czerni. Rozwiązanie: dodać wzór przemapowania (signal * 0.5 + 0.5), aby przesunąć sygnał z zakresu -1..1 do zakresu 0..1. Jeśli canvas jest całkowicie biały, wszystkie wartości przekraczają 1.0. Jeśli całkowicie czarny, wszystkie są poniżej 0.0.
Technika debugowania dla każdego shadera: ustawić gl_FragColor = vec4(uv, 0.0, 1.0); jako ostatnią linię. Ta linia maluje gradient od czerni (lewy dolny róg, gdzie uv = 0,0) do żółci (prawy górny róg, gdzie uv = 1,1), z czerwienią wzdłuż osi x i zielenią wzdłuż osi y. Jeśli gradient wygląda poprawnie, przestrzeń współrzędnych działa, a problem tkwi w sygnale lub mapowaniu kolorów. Jeśli gradient jest błędny (np. cały w jednym kolorze albo odwrócony), błąd zawiera transformacja współrzędnych. Ta technika pozwala ustalić, który z trzech problemów (współrzędne, sygnał, kolor) zawiera błąd.
Zabezpieczenia produkcyjne
Przy wdrażaniu shaderów na stronach z treścią należy przestrzegać następujących ograniczeń:
- ograniczyć rozdzielczość canvasu względem współczynnika pikseli urządzenia, aby uniknąć skoków overdraw
- udostępnić tylko niewielką, sensowną powierzchnię sterowania
- zapewnić statyczny fallback, gdy
WebGLjest niedostępny - wstrzymywać renderowanie, gdy karta jest ukryta
- unikać kosztownych rozgałęzień i zagnieżdżonych pętli w kodzie fragmentów
Laboratorium przestrzega tych zasad, więc można go użyć jako szablonu. Na sprzęcie testowym autora (MacBook Air M1, zintegrowane GPU) te shadery utrzymują 60 fps przy współczynniku pikseli urządzenia 1x; wyniki zależą od GPU, ale złożoność shaderów jest celowo na tyle niska, by poradziła sobie z nimi większość sprzętu. Przy 2x DPR na ekranie Retina liczba pikseli rośnie czterokrotnie; ograniczenie do Math.min(dpr, 2) chroni GPU przed czterokrotnie większą pracą dla różnicy wizualnej, której większość użytkowników nie dostrzega.8
Oto wzorzec wstrzymywania przy ukrytej karcie w JavaScripcie, dwie linie, które nie pozwalają shaderowi spalać cykli GPU na ukrytej karcie:
document.addEventListener('visibilitychange', () => {
if (document.hidden) cancelAnimationFrame(frameId);
else frameId = requestAnimationFrame(render);
});
Oraz limit DPR:
const dpr = Math.min(window.devicePixelRatio || 1, 2);
canvas.width = canvas.clientWidth * dpr;
canvas.height = canvas.clientHeight * dpr;
Oba wzorce są już zaimplementowane w powyższym laboratorium. Można je skopiować bezpośrednio do własnych projektów WebGL.
Co zbudować dalej
Dobre kolejne kroki:
-
Kopiowanie uniformów do schowka. Udostępnić bieżący stan
{ speed, scale, detail, colorShift }jako obiekt JSON. Przycisk „Copy Preset” zapisuje go do schowka. Przywrócenie presetu toObject.assign(state, JSON.parse(clipboard)). Serializacja presetów ma znaczenie, bo eksploracja estetyczna jest z natury ulotna: wystarczy przesunąć suwak, a poprzedni stan znika. Preset, który da się zserializować, zamienia przelotny efekt wizualny w artefakt, który można zapisać i udostępnić. -
Eksport migawek gradientów. Wywołać
canvas.toDataURL('image/png'), aby przechwycić bieżącą klatkę jako statyczny obraz. Rozmiar canvasu eksportu dopasować do wymiarów kart społecznościowych (1200x630 dla Open Graph, 1080x1080 dla Instagrama). Shader tworzy unikalne, bezpieczne dla marki gradienty bez zdjęć stockowych. -
Mapowanie pozycji przewijania na uniform. Użyć
IntersectionObserverlub nasłuchiwania przewijania, aby obliczyć wartość postępu 0.0-1.0 i przekazać ją jako uniform. Shader reaguje na pozycję czytelnika na stronie, bo GPU otrzymuje stale zmieniającą się wartość sterującą stanem wizualnym: ten sam mechanizm co suwak Speed, tylko sterowany przewijaniem zamiast kontrolką interfejsu. Efektem są narracyjne przejścia, w których obraz ewoluuje wraz z postępem treści.4 -
Powiązanie fazy koloru ze stanem zewnętrznym. Przekazywać jako uniformy porę dnia, parametry kampanii lub preferencje użytkownika. Shader, który przesuwa odcień zależnie od czasu lokalnego, tworzy subtelną personalizację bez serwowania różnych zasobów.
Kluczem jest przejście od „shadera jako zabawki” do „shadera jako prymitywu produktowego wielokrotnego użytku”. Interaktywny tekst o korekcji błędów Hamminga i wizualizator tokenizacji kierują się tą samą filozofią: czynią abstrakcyjne pojęcia namacalnymi dzięki bezpośredniej manipulacji. A myślenie przestrzenne, które sprawia, że shadery stają się intuicyjne, łączy się z tym samym myśleniem w tekście o topologii wiedzy w embeddingach, gdzie wielowymiarowe przestrzenie wektorowe kodują znaczenie semantyczne.
Kluczowe wnioski
Dla inżynierów uczących się GLSL:
-
Śmiało manipulować uniformami, teorię czytać biernie. Zmiana jednego parametru naraz i obserwacja efektu wizualnego buduje intuicję szybciej niż studiowanie matematyki w oderwaniu. Laboratorium powyżej istnieje po to, by ta pętla była szybka.
-
Każdy fragment shader rozwiązuje po kolei trzy problemy. Transformacja współrzędnych, sygnał okresowy, mapowanie kolorów. Gdy ten model mentalny zaskoczy, każdy napotkany shader da się rozłożyć na trzy warstwy i zrozumieć każdą z nich osobno.
Dla zespołów wdrażających shadery produkcyjnie:
-
Projektowanie ograniczeń znaczy więcej niż złożoność shadera. Limit DPR, wstrzymywanie przy ukrytej karcie, fallbacki i niewielka powierzchnia sterowania to decyzje produkcyjne, które przesądzają, czy shader przetrwa zderzenie z prawdziwymi użytkownikami na prawdziwym sprzęcie.
-
Shadery to prymitywy produktowe wielokrotnego użytku, nie zabawki. Tła w barwach marki, wizualizacje dedykowane kampaniom, przejścia sterowane przewijaniem i subtelna personalizacja to produkcyjne zastosowania, które shadery obsługują bez zasobów wideo, przepustowości CDN i zależności od frameworków.
Często zadawane pytania
Czym jest GLSL i jak działają fragment shadery w WebGL?
GLSL (OpenGL Shading Language) to język podobny do C, w którym pisze się programy shaderów działające na GPU. WebGL to API przeglądarki zapewniające dostęp do OpenGL ES, które wykonuje te shadery. Fragment shader napisany w GLSL uruchamia się raz na każdy fragment w każdej klatce; w prostym pełnoekranowym czworokącie, takim jak w laboratorium powyżej, każdy fragment odpowiada jednemu pikselowi, więc shader w praktyce oblicza kolor każdego piksela na podstawie jego współrzędnych, bieżącego czasu i wszelkich wartości uniformów dostarczonych przez CPU. Laboratorium powyżej używa WebGL, aby kompilować i wykonywać fragment shadery GLSL bezpośrednio w przeglądarce, bez wtyczek i rozszerzeń.5
Czym są uniformy w programowaniu shaderów?
Uniformy to wartości tylko do odczytu wysyłane w każdej klatce z CPU (JavaScript) do GPU (shader GLSL). W odróżnieniu od atrybutów wierzchołków (różnych dla każdego wierzchołka) czy zmiennych varying (interpolowanych w obrębie trójkąta) uniformy pozostają stałe dla każdego piksela w ramach jednego wywołania rysowania. Typowe uniformy to czas, rozdzielczość, pozycja myszy i własne wartości sterujące. Laboratorium udostępnia cztery uniformy (Speed, Scale, Detail, Color Shift), którymi można manipulować suwakami, aby w czasie rzeczywistym zobaczyć, jak zmiana wartości po stronie CPU zmienia obraz wyjściowy po stronie GPU.
Jak shadery osiągają wydajność w czasie rzeczywistym?
Fragment shadery działają równolegle na tysiącach rdzeni GPU. Obliczenia każdego piksela są niezależne od wszystkich pozostałych, więc GPU przetwarza je jednocześnie, a nie po kolei. Canvas 1920x1080 ma około 2 milionów fragmentów. CPU przetwarza je w dużej mierze sekwencyjnie (SIMD pomaga, ale przepustowość pozostaje o rzędy wielkości niższa). GPU rozdziela je na tysiące rdzeni i kończy w ciągu milisekund. Ograniczenie polega na tym, że żaden piksel nie może odczytać wyniku obliczeń innego piksela w tym samym przebiegu, i dlatego programowanie shaderów wymaga innego modelu mentalnego niż sekwencyjny kod CPU.6
Czy można bezpiecznie używać shaderów WebGL w produkcyjnych projektach webowych?
Tak, z ograniczeniami. Należy ograniczyć rozdzielczość canvasu względem współczynnika pikseli urządzenia, aby uniknąć overdraw na ekranach o wysokim DPI. Wstrzymywać pętlę animacji, gdy karta nie jest widoczna (nasłuchując zdarzenia visibilitychange na document). Zapewnić statyczny obraz zastępczy lub gradient CSS, gdy WebGL jest niedostępny. Unikać kosztownych operacji, takich jak zagnieżdżone pętle, odczyty tekstur w gałęziach warunkowych czy ogólnie nadmiar rozgałęzień. Laboratorium przestrzega wszystkich tych zabezpieczeń produkcyjnych.
Czego warto się uczyć po tym laboratorium?
Kolejnym krokiem jest The Book of Shaders Patricia Gonzaleza Vivo i Jen Lowe, uporządkowany kurs obejmujący funkcje szumu, pola odległości i bardziej zaawansowane techniki GLSL.1 W przypadku technik pól odległości kanonicznym źródłem są artykuły Inigo Quileza o funkcjach odległości ze znakiem.7 Po oswojeniu się z fragment shaderami warto poznać vertex shadery (manipulacja geometrią) i compute shadery (obliczenia ogólnego przeznaczenia na GPU).
-
Patricio Gonzalez Vivo i Jen Lowe, The Book of Shaders, thebookofshaders.com. Kanoniczne interaktywne źródło do nauki GLSL. Omawia fragment shadery od podstawowego wyjścia koloru przez szum i fraktale po przetwarzanie obrazu, z przykładami, które można edytować na żywo. ↩↩
-
Ten trzystopniowy podział (współrzędne, sygnał, kolor) upraszcza model przedstawiony w The Book of Shaders, w rozdziałach 5-7, które omawiają funkcje kształtujące, kolory i kształty jako kolejne warstwy budowy fragment shadera. ↩
-
Preset plasma ilustruje syntezę Fouriera: budowanie złożonego wzoru przez dodawanie fal sinusoidalnych o różnych częstotliwościach. Twierdzenie Fouriera mówi, że każdy złożony sygnał okresowy można zbudować z fal sinusoidalnych o różnych częstotliwościach i fazach (lub na nie rozłożyć). Dodawanie kolejnych składników sinusoidalnych daje coraz bardziej złożone wzory interferencyjne. Zob. też: Gonzalez Vivo, “Shaping Functions”, thebookofshaders.com/05/. ↩
-
Animacje shaderów sterowane przewijaniem działają na tej samej zasadzie co CSS
scroll-timeline, ale z dowolnymi efektami wizualnymi obliczanymi przez GPU. Uniform otrzymuje znormalizowaną pozycję przewijania (0.0 na górze, 1.0 na dole), a shader interpoluje między stanami wizualnymi. MDN dokumentuje bazowe API zdarzenia przewijania: developer.mozilla.org/en-US/docs/Web/API/Document/scroll_event. ↩ -
WebGL 1.0 (oparty na OpenGL ES 2.0) jest obsługiwany przez ponad 98% przeglądarek na świecie. Zob. caniuse.com/webgl. WebGL 2.0 (oparty na OpenGL ES 3.0) dodaje transform feedback, wiele celów renderowania i inne funkcje, ale nie jest potrzebny do pracy z fragment shaderami, takiej jak w laboratorium powyżej. Compute shadery są dostępne przez WebGPU, nie przez WebGL. ↩
-
Równoległy model wykonania GPU jest powodem, dla którego programowanie shaderów zabrania komunikacji między pikselami w ramach jednego wywołania rysowania. John Owens et al., “A Survey of General-Purpose Computation on Graphics Hardware”, Computer Graphics Forum, Vol. 26, No. 1, s. 80-113, 2007. To ograniczenie kształtuje cały model programowania GLSL. ↩
-
Inigo Quilez, “Distance Functions”, iquilezles.org/articles/distfunctions2d/. Katalog funkcji odległości ze znakiem 2D i 3D autorstwa Quileza to standardowe źródło wiedzy o proceduralnej geometrii w shaderach. ↩
-
Równoległy model wykonania GPU, który sprawia, że fragment shadery są szybkie, ogranicza też sposób ich działania. Akenine-Moller, T., Haines, E., i Hoffman, N., Real-Time Rendering, wyd. 4, A K Peters/CRC Press, 2018, rozdział 3 (The Graphics Processing Unit). Książka zawiera najpełniejsze omówienie architektury GPU dla programistów grafiki, w tym zależności między przepustowością fragmentów, fill rate i DPR. Khronos Group utrzymuje specyfikację GLSL ES, która definiuje język użyty w tym laboratorium: registry.khronos.org/OpenGL/specs/es/2.0/GLSL_ES_Specification_1.00.pdf. ↩