Added Polish translation for manuals regarding GUI and components. Updated sprite and importing-models manuals. (#362)

docs/pl/manuals/camera.md

@@ -0,0 +1,166 @@
+---
+title: Kamera
+brief: Ta instrukcja opisuje komponent Kamery w Defoldzie.
+---
+
+# Kamera
+
+Kamera (ang. camera) w Defoldzie jest komponentem, który zmienia widok i projekcję świata gry. Komponent kamery definiuje podstawową kamerę perspektywiczną lub ortograficzną, która dostarcza macierz widoku i projekcji do skryptu renderującego (ang. render script).
+
+Kamera perspektywiczna jest zazwyczaj używana w grach 3D, gdzie widok kamery oraz wielkość i perspektywa obiektów oparte są na tzw. bryle widokowej (ang. view frustum) oraz odległości i kącie widzenia od kamery do obiektów w grze.
+
+W grach 2D często pożądane jest renderowanie sceny za pomocą rzutu ortograficznego. Oznacza to, że widok kamery jest określany przez specjalną bryłę widokową - prostopadłościan. Rzut ortograficzny jest nierealistyczny, ponieważ nie zmienia rozmiaru obiektów na podstawie ich odległości. Obiekt oddalony o 1000 jednostek zostanie narysowany w takim samym rozmiarze jak obiekt tuż przed kamerą.
+
+![projekcje](images/camera/projections.png)
+
+
+## Tworzenie kamery
+
+Aby utworzyć kamerę, <kbd>kliknij prawym przyciskiem myszy</kbd> na obiekcie gry i wybierz <kbd>Add Component ▸ Camera</kbd>. Możesz także utworzyć plik komponentu w hierarchii projektu (*Outline*) i dodać go do obiektu gry.
+
+![tworzenie kamery](images/camera/create.png)
+
+Komponent kamery ma następujące właściwości, które definiują bryłę kamery (*frustum*):
+
+![ustawienia kamery](images/camera/settings.png)
+
+Id
+: Identyfikator komponentu
+
+Aspect Ratio
+: (**Tylko dla kamery perspektywicznej**) Współczynnik proporcji - stosunek szerokości bryły widokowej do jej wysokości. Wartość 1.0 oznacza założenie kwadratowego widoku. 1.33 jest odpowiednie dla widoku 4:3, takiego jak 1024x768. 1.78 jest odpowiednie dla widoku 16:9. To ustawienie jest ignorowane, jeśli jest ustawiony *Auto Aspect Ratio*.
+
+Fov
+: (**Tylko dla kamery perspektywicznej**) Pionowe pole widzenia kamery wyrażone w radianach. Im szersze pole widzenia, tym więcej zobaczy kamera.
+
+Near Z
+: wartość Z bliskiej płaszczyzny odcięcia (ang. clipping plane).
+
+Far Z
+: Wartość Z dalekiej płaszczyzny odcięcia.
+
+Auto Aspect Ratio
+: (**Tylko dla kamery perspektywicznej**) - Automatyczny współczynnik proporcji - ustaw tę opcję, aby kamera automatycznie obliczała współczynnik proporcji.
+
+Orthographic Projection
+: Projekcja ortograficzna - ustaw tę opcję, aby przełączyć kamerę na projekcję ortograficzną (patrz niżej).
+
+Orthographic Zoom
+: (**Tylko dla kamery ortograficznej**) - Powiększenie używane dla rzutu ortograficznego (> 1 = przybliż, < 1 = oddal).
+
+
+## Używanie kamery
+
+Aby aktywować kamerę i przekazać jej macierze widoku i projekcji do skryptu renderującego, wyślij komponentowi wiadomość `acquire_camera_focus`:
+
+```lua
+msg.post("#camera", "acquire_camera_focus")
+```
+
+Co klatkę, komponent kamery, który obecnie ma fokus kamery, wyśle wiadomość `set_view_projection` do gniazda `"@render"`, czyli dotrze to do twojego skryptu renderującego:
+
+```lua
+-- builtins/render/default.render_script
+--
+function on_message(self, message_id, message)
+    if message_id == hash("set_view_projection") then
+        self.view = message.view                    -- [1]
+        self.projection = message.projection
+    end
+end
+```
+
+1. Wiadomość wysłana z komponentu kamery zawiera macierz widoku (view matrix) i macierz projekcji (projection matrix).
+
+Komponent kamery dostarcza skryptowi renderującemu macierz projekcji albo perspektywiczną, albo ortograficzną, w zależności od właściwości *Orthographic Projection* kamery. Macierz projekcji uwzględnia również określone płaszczyzny odcięcia bliskie i dalekie (near Z, far Z), pole widzenia (FOV) oraz ustawienia współczynnika proporcji kamery.
+
+Macierz widoku dostarczana przez kamerę określa położenie i orientację kamery. Kamera z Projekcją Ortograficzną (*Orthographic Projection*) będzie miała widok wycentrowany na pozycji obiektu gry, do którego jest podłączona, podczas gdy kamera z Projekcją Perspektywiczną (*Perspective Projection*) będzie miała lewy dolny róg widoku na obiekcie gry, do którego jest podłączona.
+
+::: important
+Dla zachowania kompatybilności wstecznej domyślny skrypt renderujący ignoruje projekcję dostarczoną przez kamerę i zawsze używa rzutu ortograficznego. Dowiedz się więcej o skrypcie renderującym oraz macierzach widoku i projekcji w [instrukcji do renderowania](/manuals/render/#default-view-projection).
+:::
+
+Możesz powiedzieć skryptowi renderującemu, aby używał projekcji dostarczonej przez kamerę, wysyłając wiadomość do skryptu renderującego.
+
+```lua
+msg.post("@render:", "use_camera_projection")
+```
+
+### Poruszanie kamerą
+
+Aby przesuwać kamerę po obszarze gry, należy przesuwać obiekt gry, do którego jest przypisany komponent kamery. Komponent kamery automatycznie będzie wysyłał zaktualizowaną macierz widoku na podstawie bieżącej pozycji kamery wzdłuż osi X i Y.
+
+### Zoomowanie kamery
+
+Możesz przybliżać i oddalać, używając kamery perspektywicznej, przesuwając obiekt gry, do którego jest przypisana kamera, wzdłuż osi Z. Komponent kamery automatycznie będzie wysyłał zaktualizowaną macierz widoku na podstawie bieżącej pozycji kamery wzdłuż osi Z.
+
+Możesz również przybliżać i oddalać, używając kamery ortograficznej, poprzez zmianę właściwości *Orthographic Zoom* kamery:
+
+```lua
+go.set("#camera", "orthographic_zoom", 2)
+```
+
+### Śledzenie obiektu gry
+
+Kamerę można ustawić tak, aby śledziła obiekt gry, ustawiając obiekt gry, do którego przypisany jest komponent kamery, jako potomka obiektu gry, który ma być śledzony:
+
+![Śledzenie obiektu gry](images/camera/follow.png)
+
+Alternatywnym sposobem jest aktualizacja pozycji obiektu gry, do którego przypisany jest komponent kamery, co klatkę, w miarę jak obiekt gry do śledzenia się przemieszcza.
+
+### Konwersja współrzędnych ekranu na współrzędne świata
+
+Gdy kamera jest przesunięta, przybliżona lub zmieniła projekcję względem domyślnego rozciągniętego rzutu ortograficznego, współrzędne myszy na ekranie dostarczone w funkcji cyklu życia `on_input()` nie będą już odpowiadać współrzędnym świata twoich obiektów gry. Musisz ręcznie uwzględnić zmianę widoku lub projekcji. Konwersja z współrzędnych myszy/ekranu na współrzędne świata z domyślnego skryptu renderującego wygląda tak:
+
+::: sidenote
+[Rozwiązania dla kamer od społeczności](/manuals/camera/#rozwiązania-dla-kamer-od-społeczności) wymienione w tym podręczniku oferują funkcje do konwersji między współrzędnymi ekranu a świata.
+:::
+
+```Lua
+-- builtins/render/default.render_script
+--
+local function screen_to_world(x, y, z)
+	local inv = vmath.inv(self.projection * self.view)
+	x = (2 * x / render.get_width()) - 1
+	y = (2 * y / render.get_height()) - 1
+	z = (2 * z) - 1
+	local x1 = x * inv.m00 + y * inv.m01 + z * inv.m02 + inv.m03
+	local y1 = x * inv.m10 + y * inv.m11 + z * inv.m12 + inv.m13
+	local z1 = x * inv.m20 + y * inv.m21 + z * inv.m22 + inv.m23
+	return x1, y1, z1
+end
+```
+
+## Manipulacja w czasie rzeczywistym
+
+Kamery można manipulować w czasie rzeczywistym za pomocą różnych wiadomości i właściwości ([patrz w dokumentacji API](/ref/camera/)).).
+
+Kamera ma wiele różnych właściwości (properties), które można manipulować za pomocą `go.get()` i `go.set()`:
+
+`fov`
+: Pole widzenia kamery (typ `number`).
+
+`near_z`
+: Bliska wartość Z kamery (typ `number`).
+
+`far_z`
+: Daleka wartość Z kamery (typ `number`).
+
+`orthographic_zoom`
+: Zoom kamery ortograficznej (typ `number`).
+
+`aspect_ratio`
+: Dodane w Defold 1.4.8. Stosunek szerokości bryły widokowej do jej wysokości. Używane do obliczania projekcji kamery perspektywicznej (typ `number`).
+
+`view`
+: Dodane w Defold 1.4.8. Obliczona macierz widoku kamery. TYLKO DO ODCZYTU. (typ `matrix4`).
+
+`projection`
+: Dodane w Defold 1.4.8. Obliczona macierz projekcji kamery.  TYLKO DO ODCZYTU. (typ `matrix4`).
+
+
+## Rozwiązania dla kamer od społeczności
+
+Istnieje biblioteka wspomagająca kamery, która implementuje wspólne funkcje, takie jak śledzenie obiektu gry, trzęsienie ekranu, konwersja współrzędnych ekranu na współrzędne świata i inne. Jest dostępna na portalu zasobów społeczności Defold (Assets portal):
+
+- [Orthographic Camera](https://defold.com/assets/orthographic/) - tylko 2D, autor: Björn Ritzl.

docs/pl/manuals/factory.md

@@ -0,0 +1,268 @@
+---
+title: Fabryka
+brief: Ta instrukcja opisuje komponent fabryki służący do tworzenia obiektów gry z komponentami w czasie działania programu.
+---
+
+# Fabryka
+
+Komponenty fabryki w Defoldzie służą do dynamicznego generowania obiektów gry z puli obiektów podczas działania gry.
+
+Gdy dodajesz komponent fabryki do obiektu gry, w właściwości *Prototype* określasz, jaki plik obiektu gry fabryka powinna używać jako prototyp (nazywany również "prefabem", "szablonem" czy "blueprintem" w innych silnikach) dla wszystkich nowych obiektów gry, które tworzy.
+
+![Fabryka](images/factory/factory_collection.png)
+
+![Fabryka](images/factory/factory_component.png)
+
+Aby wywołać utworzenie obiektu gry, należy wywołać funkcję `factory.create()`:
+
+```lua
+-- factory.script
+local p = go.get_position()
+p.y = vmath.lerp(math.random(), min_y, max_y)
+local component = "#star_factory"
+factory.create(component, p)
+```
+
+![Spawned game object](images/factory/factory_spawned.png)
+
+`factory.create()` przyjmuje 5 parameterów:
+
+`url`
+: Identyfikator komponentu fabryki, który ma utworzyć nowy obiekt gry.
+
+`[position]`
+: (opcjonalne) pozycja w przestrzeni świata (world position) nowego obiektu gry. Powinien to być `vector3`. Jeśli nie określisz pozycji, obiekt gry zostanie utworzony w pozycji komponentu fabryki.
+
+`[rotation]`
+: (opcjonalne) obrót w przestrzeni świata (world rotation) nowego obiektu gry. Powinien to być kwaternion - `quat`.
+
+`[properties]`
+: (opcjonalne) tabela Lua z wartościami właściwości skryptu do zainicjowania obiektu gry. Zobacz szczegóły w [instrukcji o właściwościach skryptu](/manuals/script-properties).
+
+`[scale]`
+: (opcjonalne) skala utworzonego obiektu gry. Skalę można wyrazić jako liczbę - `number` (większą niż 0), która określa jednolitą skalę we wszystkich osiach. Możesz też podać `vector3`, gdzie każdy komponent określa skalę w odpowiedniej osi.
+
+Na przykład:
+
+```lua
+-- factory.script
+local p = go.get_position()
+p.y = vmath.lerp(math.random(), min_y, max_y)
+local component = "#star_factory"
+-- Utwórz obiekt z obrotem 0, ale podwójną skalą.
+-- Ustaw wartość punktową "score" na 10.
+factory.create(component, p, nil, { score = 10 }, 2.0) -- <1>
+```
+
+1. Ustala wartość punktową obiektu gry gwiazdy.
+
+```lua
+-- star.script
+go.property("score", 1) -- <1>
+
+local speed = -240
+
+function update(self, dt)
+    local p = go.get_position()
+    p.x = p.x + speed * dt
+    if p.x < -32 then
+        go.delete()
+    end
+    go.set_position(p)
+end
+
+function on_message(self, message_id, message, sender)
+    if message_id == hash("collision_response") then
+        msg.post("main#gui", "add_score", {amount = self.score}) -- <2>
+        go.delete()
+    end
+end
+```
+
+1. Właściwość skryptu "score" jest zdefiniowana z wartością domyślną.
+2. Odwołuje się do właściwości skryptu "score" jako przechowywanej wartości w "self".
+
+![utworzone obiekty](images/factory/factory_spawned2.png)
+
+::: sidenote
+Defold obecnie nie obsługuje nieliniowego skalowania kształtów kolizji. Jeśli podasz wartość nieliniowego skalowania, na przykład `vmath.vector3(1.0, 2.0, 1.0)` to sprite zostanie odpowiednio przeskalowany, ale kształty kolizji nie.
+:::
+
+
+## Adresowanie obiektów utworzonych z fabryki
+
+Mechanizm adresowania Defolda umożliwia dostęp do każdego obiektu i komponentu w trakcie działania gry. [Instrukcja adresowania](/manuals/addressing/) zawiera szczegółowe informacje na temat działania tego systemu. Ten mechanizm można również wykorzystać do dostępu do utworzonych obiektów gry i ich komponentów. Najczęściej wystarcza użycie identyfikatora utworzonego obiektu, na przykład w celu wysłania wiadomości:
+
+```lua
+local function create_hunter(target_id)
+    local id = factory.create("#hunterfactory")
+    msg.post(id, "hunt", { target = target_id })
+    return id
+end
+```
+
+::: sidenote
+Przesłanie wiadomości bezpośrednio do obiektu gry, a nie do określonego komponentu, w rzeczywistości wysyła wiadomość do wszystkich komponentów tego obiektu. Zazwyczaj nie stanowi to problemu, ale warto pamiętać, jeśli obiekt ma wiele komponentów.
+:::
+
+Ale co, jeśli musisz uzyskać dostęp do konkretnego komponentu na utworzonym obiekcie gry, na przykład, aby wyłączyć obiekt kolizji lub zmienić obraz sprite'a? Rozwiązaniem jest skonstruowanie adresu URL na podstawie identyfikatora obiektu gry i identyfikatora komponentu:
+
+```lua
+local function create_guard(unarmed)
+    local id = factory.create("#guardfactory")
+    if unarmed then
+        local weapon_sprite_url = msg.url(nil, id, "weapon")
+        msg.post(weapon_sprite_url, "disable")
+
+        local body_sprite_url = msg.url(nil, id, "body")
+        sprite.play_flipbook(body_sprite_url, hash("red_guard"))
+    end
+end
+```
+
+## Śledzenie utworzonych obiektów i rodziców
+
+Wywołując `factory.create()` otrzymujesz identyfikator nowego obiektu gry, co pozwala na przechowywanie go do użycia później. Jednym z powszechnych zastosowań jest generowanie obiektów i dodawanie ich identyfikatorów do tabeli, dzięki czemu można je usunąć w późniejszym momencie, na przykład podczas resetowania układu poziomu:
+
+```lua
+-- spawner.script
+self.spawned_coins = {}
+
+...
+
+-- Spawn a coin and store it in the "coins" table.
+local id = factory.create("#coinfactory", coin_position)
+table.insert(self.spawned_coins, id)
+```
+
+I później:
+
+```lua
+-- spawner.script
+-- Usuń utworzone monety
+for _, coin_id in ipairs(self.spawned_coins) do
+    go.delete(coin_id)
+end
+
+-- lub alternatywnie:
+go.delete(self.spawned_coins)
+```
+
+Warto też wiedzieć jakie obiekty się utworzyło w świecie gry. Przykładem może być obiekt, którego instancję chcemy mieć tylko jedną w jednym czasie. Utworzony obiekt musi wtedy poinformować swojego twórcę (spawner) kiedy jest usunięty lub nieaktywny, dzięki czemu spawner będzie mógł utworzyć następną instancję:
+
+```lua
+-- spawner.script
+-- Utwórz drona i ustaw jego rodzica na url tego skryptu
+self.spawned_drone = factory.create("#dronefactory", drone_position, nil, { parent = msg.url() })
+
+...
+
+function on_message(self, message_id, message, sender)
+    if message_id == hash("drone_dead") then
+        self.spawed_drone = nil
+    end
+end
+```
+
+A to logika utworzonego obiektu:
+```lua
+-- drone.script
+go.property("parent", msg.url())
+
+...
+
+function final(self)
+    -- I'm dead.
+    msg.post(self.parent, "drone_dead")
+end
+```
+
+## Dynamiczne ładowanie zasobów fabryki
+
+Zaznaczając opcję *Load Dynamically* (Ładuj dynamicznie) we właściwościach fabryki, silnik Defold odkłada w czasie ładowanie zasobów związanych z fabryką.
+
+![Load dynamically](images/factory/load_dynamically.png)
+
+Gdy opcja jest niezaznaczona, silnik ładuje zasoby prototypu, gdy komponent fabryki jest ładowany, więc są one od razu gotowe do generowania.
+
+Z opcją zaznaczoną, masz dwie możliwości użycia fabryki:
+
+Synchroniczne wczytywanie
+: Wywołaj [`factory.create()`](/ref/factory/#factory.create), gdy chcesz generować obiekty. Spowoduje to synchroniczne ładowanie zasobów, co może powodować przycięcia w zależności od wielkości zasobu, a następnie tworzenie nowych instancji.
+
+  ```lua
+  function init(self)
+      -- Gdy komponent fabryki jest ładowany, nie są jeszcze dostępne zasoby fabryki.
+      -- Wywołanie create bez wcześniejszego wywołania load spowoduje synchroniczne
+      -- ładowanie zasobów.
+      self.go_id = factory.create("#factory")
+  end
+
+  function final(self)
+      -- Usuwa obiekty gry. Zasoby zostaną zwolnione.
+      -- W tym przypadku zasoby zostaną usunięte, ponieważ komponent fabryki
+      -- nie trzyma referencji.
+      go.delete(self.go_id)
+
+      -- Wywołanie unload nie spowoduje żadnych działań,
+      -- ponieważ komponent fabryki nie trzyma referencji.
+      factory.unload("#factory")
+  end
+  ```
+
+Asynchroniczne wczytywanie
+: Wywołaj [`factory.load()`](/ref/factory/#factory.load), aby jawnie załadować zasoby asynchronicznie. Po zakończeniu ładowania zasobów, są one gotowe do generowania - wywołane wtedy zostanie wywołanie zwrotne (callback).
+
+  ```lua
+  function load_complete(self, url, result)
+      -- Ładowanie jest zakończone, zasoby są gotowe do generowania.
+      self.go_id = factory.create(url)
+  end
+
+  function init(self)
+      -- Gdy komponent fabryki jest ładowany, nie są jeszcze dostępne zasoby fabryki.
+      -- Wywołanie load spowoduje ładowanie zasobów.
+      factory.load("#factory", load_complete)
+  end
+
+  function final(self)
+      -- Usuwa obiekt gry. Zasoby nie zostaną zwolnione,
+      -- ponieważ komponent fabryki nadal trzyma referencję.
+      go.delete(self.go_id)
+
+      -- Wywołanie unload spowoduje zwolnienie zasobów trzymanych przez komponent fabryki,
+      -- co spowoduje zniszczenie zasobów.
+      factory.unload("#factory")
+  end
+  ```
+
+## Dynamiczny prototyp
+
+Możliwa jest zmiana prototypu *Prototype*, który ma utworzyć fabryka, zaznaczając opcję *Dynamic Prototype* we właściwościach fabryki.
+
+![Dynamic prototype](images/factory/dynamic_prototype.png)
+
+Gdy opcja *Dynamic Prototype* jest zaznaczona, komponent fabryki może zmieniać prototyp, używając funkcji `factory.set_prototype()`. Przykład:
+
+```lua
+factory.unload("#factory") -- zwolnij poprzednie zasoby
+factory.set_prototype("#factory", "/main/levels/enemyA.goc")
+local enemy_id = factory.create("#factory")
+```
+
+::: important
+Gdy opcja *Dynamic Prototype* jest ustawiona, ilość komponentów w kolekcji nie może być optymalizowana, a zawierająca kolekcja będzie korzystać z domyślnych liczby komponentów z pliku *game.project*.
+:::
+
+
+## Limit instancji
+
+Ustawienie *max_instances* w ustawieniach związanych z kolekcją (*Collection related settings*) ogranicza łączną liczbę instancji obiektów gry, które mogą istnieć w świecie (główna kolekcja "main.collection" wczytana podczas uruchamiania lub dowolny świat wczytany za pośrednictwem pełnomocnika kolekcji). Wszystkie obiekty gry, które istnieją w świecie, są wliczane do tego limitu, niezależnie od tego, czy są umieszczone ręcznie w edytorze, czy generowane dynamicznie za pomocą skryptu.
+
+![Limit instancji](images/factory/factory_max_instances.png)
+
+Jeśli ustawisz *max_instances* na 1024 i masz 24 ręcznie umieszczone obiekty gry w swojej głównej kolekcji, możesz utworzyć dodatkowe 1000 obiektów gry. Gdy tylko usuniesz obiekt gry, będziesz mógł utworzyć nową instancję.
+
+## Pula obiektów gry
+
+Może się wydawać, że dobrym pomysłem jest zapisywanie utworzonych obiektów gry w puli i ponowne ich użycie. Jednak silnik Defold wykonuje już pulowanie obiektów pod spodem, więc dodatkowe obciążenie spowolni działanie. Szybsze i bardziej przejrzyste jest usuwanie obiektów gry i tworzenie nowych.

docs/pl/manuals/gui-box.md

@@ -0,0 +1,28 @@
+---
+title: Węzły prostokątne - box w Defoldzie
+brief: Ta instrukcja wyjaśnia jak używać węzłów typu box.
+---
+
+# Węzeł GUI typu box
+
+Węzeł prostokątny box to prostokąt wypełniony kolorem, teksturą lub animacją.
+
+## Dodawanie węzłów box
+
+Dodaj nowe węzły box, <kbd>klikając prawym przyciskiem myszy</kbd> w widoku "Outline" i wybierając <kbd>Add ▸ Box</kbd>, lub naciśnij klawisz <kbd>A</kbd> i wybierz <kbd>Box</kbd>.
+
+Możesz używać obrazów i animacji z atlasów lub źródeł kafelków, które zostały dodane do GUI. Dodaj tekstury, klikając prawym przyciskiem myszy na ikonę folderu "Textures" w widoku "Outline" i wybierając <kbd>Add ▸ Textures...</kbd>. Następnie ustaw właściwość *Texture* węzłu box na daną teksturę:
+
+![Textures](images/gui-box/create.png){srcset="images/gui-box/[email protected] 2x"}
+
+Należy zauważyć, że kolor węzła box będzie barwił (ang. tint) grafikę. Kolor barwienia jest mnożony przez dane obrazu, co oznacza, że jeśli ustawisz kolor na biały (domyślny), w praktyce nie zostanie zastosowane barwienie.
+
+![Tinted texture](images/gui-box/tinted.png){srcset="images/gui-box/[email protected] 2x"}
+
+Węzły box są zawsze renderowane, nawet jeśli nie mają przypisanej tekstury, mają ustawioną wartość alfa na `0` lub mają rozmiar `0, 0, 0`. Węzły box powinny zawsze mieć przypisaną do nich teksturę, aby renderer mógł je właściwie grupować i zmniejszać liczbę wywołań rysowania (ang. draw calls).
+
+## Odtwarzanie animacji
+
+Węzły pudełkowe mogą odtwarzać animacje z atlasów lub źródeł kafelków. Aby dowiedzieć się więcej, zajrzyj do [instrukcji do animacji flipbook](/manuals/flipbook-animation).
+
+:[Slice-9](../shared/slice-9-texturing.md)

docs/pl/manuals/gui-clipping.md

@@ -0,0 +1,75 @@
+---
+title: Wycinanie GUI w Defoldzie
+brief: Ta instrukcja wyjaśnia jak działa przycinanie i maskowanie GUI w Defoldzie
+---
+
+# Wycinanie GUI
+
+Węzły GUI można wykorzystać jako węzły wycinające (*clipping* nodes) - maski kontrolujące, jak renderowane są inne węzły. Ta instrukcja wyjaśnia, jak działa ta funkcjonalność.
+
+## Tworzenie węzła wycinającego
+
+Węzły typu Box, Text i Pie można wykorzystać jako węzły wycinające. Aby utworzyć węzeł wycinający, dodaj węzeł do swojego GUI, a następnie ustaw jego właściwości odpowiednio:
+
+Clipping Mode
+: Tryb używany do wycinania.
+
+  - `None` renderuje węzeł bez jakiegokolwiek wycinania.
+  - `Stencil` - maska - sprawia, że węzeł zapisuje bieżącą maskę wycięcia.
+
+Clipping Visible
+: Zaznacz, aby renderować zawartość węzła.
+
+Clipping Inverted
+: Zaznacz, aby zapisać odwrócenie kształtu węzła w masce.
+
+Następnie dodaj węzeł lub węzły, które chcesz wyciąć jako dzieci węzła wycinającego.
+
+![Create clipping](images/gui-clipping/create.png){srcset="images/gui-clipping/[email protected] 2x"}
+
+## Maska wycinająca
+
+Wycinanie działa poprzez zapisywanie węzłów do bufora wycinania (*stencil buffer*). Ten bufor zawiera maski wycinania: informacje, które mówią karcie graficznej, czy dany piksel powinien być renderowany, czy nie.
+
+- Węzeł bez rodzica wycinającego, ale z ustawionym trybem wycinania `Stencil`, zapisuje swój kształt (lub odwrotny kształt) do nowej maski wycinania przechowywanej w buforze wycinania.
+- Jeśli węzeł wycinający ma rodzica wycinającego, zamiast tego przycinany jest kształt maski wycinania rodzica. Węzeł dziecka wycinającego nie może _rozszerzać_ bieżącej maski wycinania, tylko ją dalej przycina.
+- Węzły, które nie są węzłami wycinającymi i są dziećmi węzłów wycinających, zostaną wyrenderowane z maską wycinania stworzoną przez hierarchię rodzica.
+
+![Clipping hierarchy](images/gui-clipping/setup.png){srcset="images/gui-clipping/[email protected] 2x"}
+
+W tym przykładzie utworzono trzy węzły w hierarchii:
+
+- Kształty szesciokąta i kwadratu to węzły przycinające stencil.
+- Sześciokąt tworzy nową maskę wycinania, a kwadrat ją dodatkowo przycina.
+- Węzeł koła to zwykły węzeł typu pie, więc zostanie wyrenderowany z maską wycinania utworzoną przez węzły nadrzędne.
+
+Dla tej hierarchii możliwe są cztery kombinacje normalnych i odwróconych wycinaczy. Obszar zielony oznacza część koła, która jest renderowana. Reszta jest przycinana:
+
+![Stencil masks](images/gui-clipping/modes.png){srcset="images/gui-clipping/[email protected] 2x"}
+
+## Ograniczenia maski wycinania
+
+- Całkowita liczba wycinaczy maski nie może przekroczyć 256.
+- Maksymalna głębokość zagnieżdżenia węzłów dzieci o typie _stencil_ wynosi 8 poziomów (tylko węzły z wycinaniem typu stencil się w to wliczają).
+- Maksymalna liczba rodzeństwa węzłów maski wynosi 127. Dla każdego poziomu w dół hierarchii maski wycinania maksymalne ograniczenie jest dzielone na pół.
+- Węzły odwrócone są droższe. Istnieje limit 8 węzłów wycinania z odwróceniem, a każdy z nich zmniejszy maksymalną liczbę węzłów wycinania bez odwracania na pół.
+- Wycinacze renderują maskę wycinania z _geometrii_ węzła (nie tekstury). Możliwe jest odwrócenie maski, ustawiając właściwość *Inverted clipper*.
+
+## Warstwy
+
+Warstwy można wykorzystać do kontrolowania kolejności renderowania (i grupowania) węzłów. Podczas korzystania z warstw i węzłów wycinających standardowa kolejność warstw jest nadpisywana. Kolejność warstw zawsze ma pierwszeństwo przed kolejnością wycinania - jeśli przypisanie warstw jest łączone z węzłami wycinającymi, wycinanie może odbywać się poza kolejnością, jeśli węzeł nadrzędny z wycinaniem jest przypisany do wyższej warstwy niż jego dzieci. Dzieci bez przypisanej warstwy nadal będą przestrzegać hierarchii i zostaną narysowane i przycięte po rodzicu.
+
+::: sidenote
+Węzeł wycinania i jego hierarchia zostaną narysowane jako pierwsze, jeśli mają przypisaną warstwę, a w zwykłej kolejności, jeśli nie mają przypisanej warstwy.
+:::
+
+![Layers and clipping](images/gui-clipping/layers.png){srcset="images/gui-clipping/[email protected] 2x"}
+
+W tym przykładzie zarówno węzły wycinające "Donut BG" i "BG" korzystają z tej samej warstwy 1. Kolejność renderowania między nimi będzie zgodna z kolejnością w hierarchii, gdzie "Donut BG" zostanie narysowane przed "BG". Jednak węzeł dziecka "Donut Shadow" jest przypisany do warstwy 2, która ma wyższy porządek warstw i zostanie narysowany po obu węzłach wycinających. W tym przypadku kolejność renderowania będzie następująca:
+
+- Donut BG
+- BG
+- BG Frame
+- Donut Shadow
+
+Widzisz, że obiekt "Donut Shadow" zostanie przycięty przez oba węzły wycinające ze względu na warstwę, chociaż jest tylko dzieckiem jednego z nich.

docs/pl/manuals/gui-layouts.md

@@ -0,0 +1,100 @@
+---
+title: Układy interfejsu w Defoldzie
+brief: Defold supports GUIs that automatically adapt to screen orientation changes on mobile devices. This document explains how the feature works.
+---
+
+# Układy interfejsu
+
+Układy interfejsu (ang. layouts) to wspierana przez Defold opcja automatycznego dostosowywania się do zmian orientacji ekranu na urządzeniach mobilnych. W tym dokumencie wyjaśniono, jak działa ta funkcjonalność.
+
+Defold supports GUIs that automatically adapt to screen orientation changes on mobile devices. By using this feature you can design GUIs that adapt to the orientation and aspect ratio of a range of screen sizes. It is also possible to create layouts that match particular device models.
+
+## Tworzenie profili wyświetlania
+
+Domyślnie, w ustawieniach *game.project*, używa się wbudowanego pliku z ustawieniami profili wyświetlania (ang. display profiles) ("builtins/render/default.display_profiles"). Domyślne profile to `"Landscape"` (1280 pikseli szerokości i 720 pikseli wysokości) i `"Portrait"` (720 pikseli szerokości i 1280 pikseli wysokości). W profilach tych nie ustawiono modeli urządzeń, dlatego pasują one do dowolnego urządzenia.
+
+Aby utworzyć nowy plik z ustawieniami profili, skopiuj istniejący z folderu "builtins" lub <kbd>kliknij prawym przyciskiem myszy</kbd> w odpowiednim miejscu w widoku *Assets* i wybierz <kbd>New... -> Display Profiles"</kbd>. Nadaj nowemu plikowi odpowiednią nazwę i kliknij <kbd>OK</kbd>.
+
+Edytor otworzy teraz nowy plik do edycji. Dodaj nowe profile, klikając <kbd>+<kbd> na liście *Profiles*. Dla każdego profilu dodaj zestaw "kwalifikatorów" (*qualifiers*) dla profilu:
+
+Width
+: Szerokość kwalifikatora w pikselach.
+
+Height
+: Wysokość kwalifikatora w pikselach.
+
+Device Models
+: Lista modeli urządzeń oddzielonych przecinkami. Nazwa modelu urządzenia pasuje do początku nazwy modelu urządzenia. Przykład: `iPhone10` pasuje do modeli "iPhone10,\*". Nazwy modeli z przecinkami powinny być umieszczone w cudzysłowie, np. `"iPhone10,3", "iPhone10,6"` pasuje do modeli iPhone X (https://www.theiphonewiki.com/wiki/Models). Należy zauważyć, że tylko platformy Android i iOS raportują nazwę modelu urządzenia podczas wywoływania funkcji `sys.get_sys_info`. Inne platformy zwracają pusty ciąg znaków i dlatego nigdy nie wybiorą profilu wyświetlania z kwalifikatorem modelu urządzenia.
+
+![New display profiles](images/gui-layouts/new_profiles.png){srcset="images/gui-layouts/[email protected] 2x"}
+
+Należy również określić, że silnik powinien używać nowych profili. Otwórz *game.project* i wybierz plik z profilami wyświetlania w ustawieniach *Display Profiles* w sekcji *display*.
+
+
+![Settings](images/gui-layouts/settings.png){srcset="images/gui-layouts/[email protected] 2x"}
+
+Jeśli chcesz, aby silnik automatycznie przełączał się między układami w orientacji pionowej i poziomej po obróceniu urządzenia, zaznacz opcję *Dynamic Orientation*. Silnik będzie dynamicznie wybierać pasujący układ i zmieniać wybór w razie zmiany orientacji urządzenia.
+
+## Układy interfejsu
+
+Obecny zestaw profili wyświetlania można wykorzystać do tworzenia wariantów układów (layouts) węzłów interfejsu. Aby dodać nowy układ do sceny interfejsu, kliknij prawym przyciskiem myszy na ikonie *Layouts* w widoku *Outline* i wybierz <kbd>Add ▸ Layout ▸ ...</kbd>.
+
+![Add layout to scene](images/gui-layouts/add_layout.png){srcset="images/gui-layouts/[email protected] 2x"}
+
+Podczas edycji sceny interfejsu wszystkie węzły są edytowane w określonym układzie. Obecnie wybrany układ jest widoczny w rozwijanym menu układu sceny interfejsu w pasku narzędziowym. Jeśli nie wybrano żadnego układu, węzły są edytowane w układzie *Default*.
+
+![Layouts toolbar](images/gui-layouts/toolbar.png){srcset="images/gui-layouts/[email protected] 2x"}
+
+![portrait edit](images/gui-layouts/portrait.png){srcset="images/gui-layouts/[email protected] 2x"}
+
+Każda zmiana właściwości węzła dokonana z wybranym układem, nadpisuje właściwość w odniesieniu do układu *Default*. Właściwości, które zostały nadpisane, są oznaczone kolorem niebieskim. Węzły z nadpisanymi właściwościami również są oznaczone kolorem niebieskim. Możesz kliknąć przycisk resetowania obok dowolnej nadpisanej właściwości, aby przywrócić ją do pierwotnej wartości.
+
+![landscape edit](images/gui-layouts/landscape.png){srcset="images/gui-layouts/[email protected] 2x"}
+
+Układ nie może usuwać ani tworzyć nowych węzłów, może jedynie nadpisywać właściwości. Jeśli chcesz usunąć węzeł z układu, możesz albo przenieść węzeł poza obszar ekranu, albo usunąć go za pomocą logiki skryptu. Należy także zwrócić uwagę na obecnie wybrany układ. Jeśli dodasz układ do projektu, nowy układ będzie konfigurowany zgodnie z aktualnie wybranym układem. Kopiowanie i wklejanie węzłów uwzględnia obecnie wybrany układ zarówno podczas kopiowania, jak i podczas wklejania.
+
+## Dynamiczny wybór profilu
+
+Dynamiczny dopasowywacz układu ocenia każdy kwalifikator profilu wyświetlania według następujących reguł:
+
+1. Jeśli nie jest ustawiony model urządzenia albo model urządzenia jest i pasuje do profilu, obliczana jest ocena (S) dla kwalifikatora.
+
+2. Ocena (S) jest obliczana na podstawie powierzchni ekranu (`A`), powierzchni z kwalifikatora (`A_Q`), proporcji obrazu ekranu (`R`) i proporcji obrazu z kwalifikatora (`R_Q`).
+
+<img src="https://latex.codecogs.com/svg.latex?\inline&space;S=\left|1&space;-&space;\frac{A}{A_Q}\right|&space;&plus;&space;\left|1&space;-&space;\frac{R}{R_Q}\right|" title="S=\left|1 - \frac{A}{A_Q}\right| + \left|1 - \frac{R}{R_Q}\right|" />
+
+3. Profil z najniższą oceną jest wybierany, jeśli orientacja (landscape lub portrait) kwalifikatora pasuje do orientacji ekranu.
+
+4. Jeśli nie znaleziono profilu z kwalifikatorem o tej samej orientacji, wybierany jest profil z najlepszą oceną kwalifikatora o innej orientacji.
+
+5. Jeśli nie można wybrać żadnego profilu, stosowany jest profil awaryjny *Default*.
+
+Ponieważ układ *Default* jest stosowany jako profil awaryjny w czasie rzeczywistym, jeśli nie ma lepszego pasującego układu, oznacza to, że jeśli dodasz układ *Landscape*, będzie to najlepsze dopasowanie dla wszystkich orientacji, dopóki nie dodasz także układu *Portrait*.
+
+## Komunikaty o zmianie układu
+
+Kiedy silnik zmienia układ w wyniku obracania urządzenia, wysyłana jest wiadomość `layout_changed` do skryptów komponentów GUI, które są dotknięte zmianą. Komunikat zawiera zahaszowany identyfikator (hashed id) układu, dzięki czemu skrypt może wykonywać logikę zależnie od wybranego układu.
+
+When the engine switches layout as a result of device rotation, a `layout_changed` message is posted to the GUI components' scripts that are affected by the change. The message contains the hashed id of the layout so the script can perform logic depending on which layout is selected:
+
+```lua
+function on_message(self, message_id, message, sender)
+  if message_id == hash("layout_changed") and message.id == hash("My Landscape") then
+    --- zmieniono układ na landscape
+  elseif message_id == hash("layout_changed") and message.id == hash("My Portrait") then
+    -- zmieniono układ na portrait
+  end
+end
+```
+
+Ponadto, bieżący skrypt renderowania otrzymuje komunikat za każdym razem, gdy zmienia się okno (widok gry), a to obejmuje zmiany orientacji.
+
+```lua
+function on_message(self, message_id, message)
+  if message_id == hash("window_resized") then
+    -- Okno zostało zmienione. message.width i message.height zawierają nowe wymiary okna.
+  end
+end
+```
+
+Przy zmianie orientacji menedżer układu interfejsu automatycznie przeskalowuje i przemieszcza węzły GUI zgodnie z układem i właściwościami węzłów. Jednak treść gry jest renderowana w osobnym przebiegu (domyślnie) z projekcją rozciągania do bieżącego okna. Aby zmienić to zachowanie, należy dostarczyć własny zmodyfikowany skrypt renderowania lub skorzystać z [biblioteki kamer](/assets/).

docs/pl/manuals/gui-particlefx.md

@@ -0,0 +1,35 @@
+---
+title: Węzły efektów cząsteczkowych - particle FX w Defoldzie.
+brief: Ta instrukcja wyjaśnia jak używać węzłów typu particleFX.
+---
+
+# Węzeł GUI typu text ParticleFX
+
+Węzeł efektu cząsteczkowego (ang. particle effect node) służy do odtwarzania systemów efektów cząsteczkowych na ekranie GUI.
+
+## Dodawanie węzłów ParticleFX
+
+Dodaj nowe węzły cząsteczkowe, <kbd>klikając prawym przyciskiem myszy</kbd> w widoku *Outline* i wybierając kbd>Add ▸ ParticleFX</kbd> lub naciśnij <kbd>A</kbd> i wybierz <kbd>ParticleFX</kbd>.
+
+Możesz użyć efektów cząsteczkowych, które dodałeś do GUI jako źródła efektu. Dodaj efekty cząsteczkowe, <kbd>klikając prawym przyciskiem myszy</kbd> na ikonie folderu *Particle FX* w widoku *Outline* i wybierając <kbd>Add ▸ Particle FX...</kbd>. Następnie ustaw właściwość *Particlefx* na węźle:
+
+![Particle fx](images/gui-particlefx/create.png){srcset="images/gui-particlefx/[email protected] 2x"}
+
+## Kontrolowanie efektu
+
+Możesz uruchamiać i zatrzymywać efekt, kontrolując węzeł za pomocą skryptu:
+You can start and stop the effect by controlling the node from a script:
+
+```lua
+-- uruchomienie efektu cząsteczkowego
+local particles_node = gui.get_node("particlefx")
+gui.play_particlefx(particles_node)
+```
+
+```lua
+-- zatrzymanie efektu cząsteczkowego
+local particles_node = gui.get_node("particlefx")
+gui.stop_particlefx(particles_node)
+```
+
+Aby uzyskać szczegółowe informacje na temat działania efektów cząsteczkowych, sprawdź [instrukcję do efektów cząsteczkowych](/manuals/particlefx).

docs/pl/manuals/gui-pie.md

@@ -0,0 +1,56 @@
+---
+title: Węzły pierścieniowe - pie w Defoldzie.
+brief: Ta instrukcja wyjaśnia jak używać węzłów typu pie.
+---
+
+# Węzeł GUI typu pie
+
+Węzły pierścieniowe - "pie" są używane do tworzenia obiektów okrągłych lub elipsoidalnych, począwszy od zwykłych okręgów po kształty przypominające placki lub kwadratowe pączki.
+
+## Tworzenie węzła pie
+
+Kliknij <kbd>prawym przyciskiem myszy</kbd> w sekcji *Nodes* w panelu *Outline* i wybierz <kbd>Add ▸ Pie</kbd>. Nowy węzeł pie zostaje zaznaczony, i możesz modyfikować jego właściwości.
+
+![Create pie node](images/gui-pie/create.png){srcset="images/gui-pie/[email protected] 2x"}
+
+Następujące właściwości są unikalne dla węzłów pie:
+
+Inner Radius
+: Wewnętrzny promień węzła, wyrażony wzdłuż osi X.
+
+Outer Bounds
+: Kształt zewnętrznych granic węzła.
+
+  - `Ellipse`  rozszerzy węzeł do zewnętrznego promienia.
+  - `Rectangle`  rozszerzy węzeł do obwiedni węzła.
+
+Perimeter Vertices
+: Wierzchołki obwiedni - liczba segmentów, które zostaną użyte do zbudowania kształtu, wyrażona jako liczba wierzchołków wymaganych do pełnego obwiedni 360 stopni węzła.
+
+Pie Fill Angle
+: Kąt wypełnienia - określa, ile z placka ma zostać wypełnione. Wyrażane jako kąt przeciwny do ruchu wskazówek zegara, zaczynając od prawej strony.
+
+![Properties](images/gui-pie/properties.png){srcset="images/gui-pie/[email protected] 2x"}
+
+Jeśli ustawisz teksturę na węźle, obraz tekstury jest używany "płasko", tak aby rogi tekstury korelowały z rogami obwiedni węzła.
+
+## Modyfikacja węzłów pie w czasie działania programu
+
+Węzły pie reagują na ogólne funkcje manipulacji węzłami do ustawiania rozmiaru, punktu obrotu, koloru i innych. Istnieje kilka funkcji i właściwości dostępnych tylko dla węzłów pie:
+
+```lua
+local pienode = gui.get_node("my_pie_node")
+
+-- pobierz zewnętrzne granice
+local fill_angle = gui.get_fill_angle(pienode)
+
+-- zwiększ liczbę wierzchołków obwiedni
+local vertices = gui.get_perimeter_vertices(pienode)
+gui.set_perimeter_vertices(pienode, vertices + 1)
+
+-- zmień zewnętrzne granice
+gui.set_outer_bounds(pienode, gui.PIEBOUNDS_RECTANGLE)
+
+-- animuj wewnętrzny promień
+gui.animate(pienode, "inner_radius", 100, gui.EASING_INOUTSINE, 2, 0, nil, gui.PLAYBACK_LOOP_PINGPONG)
+```

docs/pl/manuals/gui-script.md

@@ -0,0 +1,151 @@
+---
+title: Skrypty GUI w Defoldzie
+brief: Ta instrukcja wyjaśnia jak działają skrypty GUI w Defoldzie
+---
+
+# Skrypty GUI
+
+Aby kontrolować logikę swojego interfejsu GUI i animować węzły, używa się skryptów Lua. Skrypty GUI działają tak samo jak zwykłe skrypty obiektów gry, ale są zapisywane jako inny rodzaj pliku i mają dostęp do innej grupy funkcji: funkcji modułu `gui`.
+
+## Dodawanie skryptu do GUI
+
+Aby dodać skrypt do GUI, najpierw stwórz plik skryptu GUI, klikając <kbd>prawym przyciskiem myszy</kbd> w odpowiednie miejsce w przeglądarce Zasobów i wybierając <kbd>New ▸ Gui Script</kbd> z menu kontekstowego.
+
+Edytor automatycznie otwiera nowy plik skryptu. Bazuje on na szablonie i jest wyposażony w puste funkcje cyklu życia, takie same jak skrypty obiektów gry:
+
+```lua
+function init(self)
+   -- Add initialization code here
+   -- Remove this function if not needed
+end
+
+function final(self)
+   -- Add finalization code here
+   -- Remove this function if not needed
+end
+
+function update(self, dt)
+   -- Add update code here
+   -- Remove this function if not needed
+end
+
+function on_message(self, message_id, message, sender)
+   -- Add message-handling code here
+   -- Remove this function if not needed
+end
+
+function on_input(self, action_id, action)
+   -- Add input-handling code here
+   -- Remove this function if not needed
+end
+
+function on_reload(self)
+   -- Add input-handling code here
+   -- Remove this function if not needed
+end
+```
+
+Aby przypiąć skrypt do komponentu GUI, otwórz prototyp komponentu GUI (inaczej nazywane "prefabami" lub "szablonami" w innych silnikach) i wybierz korzeń (root) w *Outline*, aby wywołać Właściwości (*Properties*) GUI. Ustaw właściwość *Script* na plik skryptu.
+
+![Script](images/gui-script/set_script.png){srcset="images/gui-script/[email protected] 2x"}
+
+Jeśli komponent GUI został dodany do obiektu gry w dowolnym miejscu gry, skrypt zostanie teraz uruchomiony.
+
+## Przestrzeń nazw "gui"
+
+Skrypty GUI mają dostęp do przestrzeni nazw (ang. namespace) `gui` i [wszystkich funkcji gui](/ref/gui). Przestrzeń nazw `go` dla obiektów gry nie jest dostępna dla GUI, dlatego konieczne jest oddzielenie logiki obiektów gry poprzez skrypty komponentów i komunikację między skryptami GUI a skryptami komponentów obiektów gry. Próby użycia funkcji `go` w skrypcie GUI spowodują błąd:
+
+```lua
+function init(self)
+   local id = go.get_id()
+end
+```
+
+```txt
+ERROR:SCRIPT: /main/my_gui.gui_script:2: You can only access go.* functions and values from a script instance (.script file)
+stack traceback:
+   [C]: in function 'get_id'
+   /main/my_gui.gui_script:2: in function </main/my_gui.gui_script:1>
+```
+
+## Przesyłanie wiadomości
+
+Dowolny komponent GUI z przypisanym skryptem ma zdolność do komunikacji z innymi obiektami w środowisku uruchomieniowym gry poprzez przesyłanie wiadomości, zachowuje się tak samo jak dowolny inny komponent skryptu.
+
+Możesz adresować komponent GUI tak samo, jak dowolny inny komponent skryptu:
+
+```lua
+local stats = { score = 4711, stars = 3, health = 6 }
+msg.post("hud#gui", "set_stats", stats)
+```
+
+![message passing](images/gui-script/message_passing.png){srcset="images/gui-script/[email protected] 2x"}
+
+## Adresowanie węzłów
+
+Węzły GUI mogą być manipulowane przez skrypt GUI przypisany do komponentu. Każdy węzeł musi mieć unikalne *Id*, które jest ustawiane w edytorze:
+
+![message passing](images/gui-script/node_id.png){srcset="images/gui-script/[email protected] 2x"}
+
+*Id* pozwala skryptowi uzyskać dostęp do węzła i manipulować nim za pomocą [funkcji przestrzeni nazw gui](/ref/gui):
+
+```lua
+-- rozszerz pasek zdrowia o 10 jednostek
+local healthbar_node = gui.get_node("healthbar")
+local size = gui.get_size(healthbar_node)
+size.x = size.x + 10
+gui.set_size(healthbar_node, size)
+```
+
+## Dynamicznie tworzone węzły
+
+Aby utworzyć nowy węzeł w czasie rzeczywistym, masz dwie opcje. Pierwsza opcja polega na tworzeniu węzłów od podstaw, wywołując funkcje `gui.new_[type]_node()`. Funkcje te zwracają referencję do nowego węzła, którą można używać do manipulowania węzłem:
+
+```lua
+-- Utwórz nowy węzeł typu "box"
+local new_position = vmath.vector3(400, 300, 0)
+local new_size = vmath.vector3(450, 400, 0)
+local new_boxnode = gui.new_box_node(new_position, new_size)
+gui.set_color(new_boxnode, vmath.vector4(0.2, 0.26, 0.32, 1))
+
+-- Utwórz nowy węzeł typu "text"
+local new_textnode = gui.new_text_node(new_position, "Hello!")
+gui.set_font(new_textnode, "sourcesans")
+gui.set_color(new_textnode, vmath.vector4(0.69, 0.6, 0.8, 1.0))
+```
+
+![dynamic node](images/gui-script/dynamic_nodes.png){srcset="images/gui-script/[email protected] 2x"}
+
+Alternatywnym sposobem na tworzenie nowych węzłów jest klonowanie istniejącego węzła za pomocą funkcji `gui.clone()` lub drzewa węzłów za pomocą funkcji `gui.clone_tree()`:
+
+```lua
+-- sklonuj pasek zdrowia
+local healthbar_node = gui.get_node("healthbar")
+local healthbar_node_2 = gui.clone(healthbar_node)
+
+-- sklonuj drzewo węzłów przycisku
+local button = gui.get_node("my_button")
+local new_button_nodes = gui.clone_tree(button)
+
+-- pobierz nowy korzeń drzewa
+local new_root = new_button_nodes["my_button"]
+
+-- przesuń korzeń (i dzieci) o 300 w prawo
+local root_position = gui.get_position(new_root)
+root_position.x = root_position.x + 300
+gui.set_position(new_root, root_position)
+```
+
+## Dynamiczne identyfikatory węzłów
+
+Dynamicznie tworzone węzły nie posiadają przypisanego identyfikatora. Jest to celowe. Referencje zwracane przez funkcje `gui.new_[type]_node()`, `gui.clone()` i `gui.clone_tree()` są jedyną rzeczą, która jest potrzebna do dostępu do węzłów, i powinieneś śledzić tę referencję.
+
+Dynamically created nodes do not have an id assigned to them. This is by design. The references that are returned from `gui.new_[type]_node()`, `gui.clone()` and `gui.clone_tree()` are the only thing necessary to be able to access the nodes and you should keep track of that reference.
+
+```lua
+-- Dodaj węzeł tekstowy
+local new_textnode = gui.new_text_node(vmath.vector3(100, 100, 0), "Hello!")
+-- "new_textnode" zawiera referencję do węzła.
+-- Węzeł nie ma identyfikatora, i to jest w porządku. Nie ma powodu, by używać
+-- funkcji `gui.get_node()`, gdy mamy już referencję.
+```

docs/pl/manuals/gui-spine.md

@@ -0,0 +1,6 @@
+---
+title: Defold GUI Spine nodes
+brief: This manual explains how to use bone animated Spine nodes in Defold GUI scenes.
+---
+
+[Ta instrukcja została przeniesiona tutaj](/extension-spine).

docs/pl/manuals/gui-template.md

@@ -0,0 +1,62 @@
+---
+title: Szablony GUI w Defoldzie
+brief: Ta instrukcja wyjaśnia, jak działają szablony GUI.
+---
+
+# Węzły szablonów GUI
+
+Węzły szablonów (ang. template nodes) GUI zapewniają potężny mechanizm tworzenia wielokrotnego użytku komponentów GUI na podstawie wspólnych "szablonów" lub "prefabrykatów". Ten podręcznik wyjaśnia tę funkcję i jej użycie.
+
+Szablon GUI to scena GUI, która jest tworzona, węzeł po węźle, w innej scenie GUI. Wartości właściwości węzłów oryginalnych szablonów można wówczas zastępować.
+
+## Tworzenie szablonu
+
+Szablon GUI to zwykła scena GUI, więc tworzy się go tak samo jak każdą inną scenę GUI. <kbd>Kliknij prawym przyciskiem myszy</kbd> w odpowiednim miejscu w panelu Assets i wybierz <kbd>New... ▸ Gui</kbd>.
+
+![Create template](images/gui-templates/create.png){srcset="images/gui-templates/[email protected] 2x"}
+
+Utwórz szablon i zapisz go. Należy zauważyć, że węzły instancji tego szablonu zostaną umieszczone względem położenia początkowego, dlatego dobrym pomysłem jest utworzenie szablonu w pozycji 0, 0, 0.
+
+## Tworzenie instancji na podstawie szablonu
+
+Możesz tworzyć dowolną liczbę instancji opartych na jednej instancji. Utwórz lub otwórz scenę GUI, w której chcesz umieścić szablon, a następnie <kbd>kliknij prawym przyciskiem myszy</kbd> sekcję *Nodes* w widoku *Outline* i wybierz <kbd>Add ▸ Template</kbd>.
+
+![Create instance](images/gui-templates/create_instance.png){srcset="images/gui-templates/[email protected] 2x"}
+
+Ustaw właściwość *Template* na plik sceny GUI szablonu.
+
+Możesz dodać dowolną liczbę instancji szablonów, a dla każdej instancji można zastępować właściwości każdego węzła i zmieniać pozycję węzła instancji, kolorowanie, rozmiar, teksturę itp.
+
+![Instances](images/gui-templates/instances.png){srcset="images/gui-templates/[email protected] 2x"}
+
+Każda zmieniona właściwość jest oznaczona kolorem niebieskim w edytorze. Naciśnij przycisk resetowania przy właściwości, aby ustawić jej wartość na wartość z szablonu:
+
+![Properties](images/gui-templates/properties.png){srcset="images/gui-templates/[email protected] 2x"}
+
+Każdy węzeł, który ma zmienione właściwości, jest również kolorowany na niebiesko w widoku *Outline*:
+
+![Outline](images/gui-templates/outline.png){srcset="images/gui-templates/[email protected] 2x"}
+
+Instancja szablonu jest wylistowana jako składana pozycja w widoku *Outline*. Jednak należy zauważyć, że ten element w widoku *nie jest węzłem*. Instancja szablonu nie istnieje także w czasie wykonywania, ale wszystkie węzły, które są częścią instancji, istnieją.
+
+Węzły, które są częścią instancji szablonu, są automatycznie nazwane przyrostkiem i ukośnikiem (`"/"`) do ich *Id*. Przyrostek ten to *Id* ustawione w instancji szablonu.
+
+::: important
+Zastępowanie właściwości węzłów instancji szablonu w *Layouts* nie działa obecnie w Edytorze.
+
+Zobacz https://github.com/defold/editor2-issues/issues/1124
+:::
+
+## Modyfikowanie szablonów w czasie działania programu
+
+Skrypty, które manipulują lub sprawdzają węzły dodane za pomocą szablonów, muszą uwzględniać tylko nazwy węzłów instancji i uwzględniać *Id* instancji szablonu jako prefiks nazwy węzła:
+
+```lua
+if gui.pick_node(gui.get_node("button_1/button"), x, y) then
+    -- Do something...
+end
+```
+
+Nie ma węzła odpowiadającego samej instancji szablonu. Jeśli potrzebujesz węzła głównego dla instancji, dodaj go do szablonu.
+
+Jeśli skrypt jest powiązany ze sceną GUI szablonu, skrypt ten nie jest częścią drzewa węzłów instancji. Możesz dołączyć jeden pojedynczy skrypt do każdej sceny GUI, więc twoja logika skryptu musi znajdować się na scenie GUI, na której instancjonujesz swoje szablony.

docs/pl/manuals/gui-text.md

@@ -0,0 +1,58 @@
+---
+title: Węzły tekstowe - text w Defoldzie.
+brief: Ta instrukcja wyjaśnia jak używać węzłów typu text.
+---
+
+# Węzeł GUI typu text
+
+Defold obsługuje konkretny rodzaj węzła GUI, który umożliwia renderowanie tekstu w scenach GUI. Każdy zasób fontu dodany do projektu może być używany do renderowania węzłów tekstu.
+
+## Dodawanie węzłów tekstowych
+
+Fonty, które chcesz używać w węzłach tekstowych GUI, muszą zostać dodane do komponentu GUI. <kbd>Kliknij prawym przyciskiem myszy</kbd> na folder *Fonts*, użyj górnego menu <kbd>GUI</kbd> lub naciśnij odpowiedni skrót klawiaturowy.
+
+![Fonts](images/gui-text/fonts.png){srcset="images/gui-text/[email protected] 2x"}
+
+Węzły tekstowe posiadają zestaw specjalnych właściwości:
+
+*Font*
+: Każdy węzeł tekstowy, który tworzysz, musi mieć ustawioną właściwość Font.
+
+*Text*
+: Ta właściwość zawiera wyświetlany tekst.
+
+*Line Break*
+: Wyrównanie tekstu odpowiada ustawieniom punktu obrotu (ang. pivot setting), a ustawienie tej właściwości pozwala na przepływ tekstu na kilku liniach. Szerokość węzła określa, jak tekst się zawija.
+
+## Wyrównanie
+
+Ustawiając punkt obrotu węzła, możesz zmienić tryb wyrównywania tekstu (ang. alignment mode).
+
+*Center*
+: Jeśli punkt obrotu jest ustawiony na `Center`, `North` lub `South`, tekst jest wyrównywany do środka.
+
+*Left*
+: Jeśli punkt obrotu jest ustawiony na dowolny z trybów `West`, tekst jest wyrównywany do lewej.
+
+*Right*
+: Jeśli punkt obrotu jest ustawiony na dowolny z trybów `East`, tekst jest wyrównywany do prawej.
+
+![Text alignment](images/gui-text/align.png){srcset="images/gui-text/[email protected] 2x"}
+
+## Modyfikowanie węzłów tekstowych w czasie działania programu
+
+Węzły tekstowe reagują na ogólne funkcje manipulacji węzłami do ustawiania rozmiaru, punktu obrotu, koloru i innych. Istnieje kilka funkcji tylko dla węzłów tekstowych:
+
+* Aby zmienić czcionkę węzła tekstowego, użyj funkcji [`gui.set_font()`](/ref/gui/#gui.set_font).
+* Aby zmienić zachowanie podziału linii węzła tekstowego, użyj funkcji [`gui.set_line_break()`](/ref/gui/#gui.set_line_break).
+* Aby zmienić zawartość węzła tekstowego, użyj funkcji [`gui.set_text()`](/ref/gui/#gui.set_text).
+
+```lua
+function on_message(self, message_id, message, sender)
+    if message_id == hash("set_score") then
+        local s = gui.get_node("score")
+        gui.set_text(s, message.score)
+    end
+end
+```
+

docs/pl/manuals/gui.md

@@ -0,0 +1,339 @@
+---
+title: Sceny GUI w Defoldzie
+brief: Ta instrukcja omawia edytor GUI w Defold, różne typy węzłów GUI oraz skrypty GUI.
+---
+
+# GUI
+
+GUI - Graphical User Interface, czyli graficzny interfejs użytkownika dostarcza elementów, które są w grze wyświetlana zazwyczaj nad światem gry. Defold dostarcza niestandardowy edytor GUI i potężne możliwości skryptowe, które są specjalnie dostosowane do budowy i implementacji interfejsów użytkownika.
+
+Graficzny interfejs użytkownika w Defoldzie to komponent, który tworzysz i przypisujesz do obiektu gry, umieszczając go w kolekcji. Ten komponent ma następujące właściwości:
+
+* Posiada proste, ale potężne funkcje układu (layout), które pozwalają na renderowanie interfejsu użytkownika niezależnie od rozdzielczości i proporcji obrazu.
+* Może mieć dołączoną logikę za pomocą skryptu GUI.
+* Jest (domyślnie) renderowany na wierzchu innych treści, niezależnie od widoku kamery, więc nawet jeśli masz ruchomą kamerę, twoje elementy interfejsu GUI pozostaną na ekranie. Zachowanie renderowania można zmienić.
+* Komponenty GUI są renderowane niezależnie od widoku gry. Dlatego nie są umieszczane w określonym miejscu w edytorze kolekcji, ani nie mają reprezentacji wizualnej w edytorze kolekcji. Komponenty GUI muszą znajdować się w obiekcie gry, który ma swoje miejsce w kolekcji. Zmiana tego miejsca nie ma wpływu na GUI.
+
+## Tworzenie komponentu GUI
+
+Komponenty GUI są tworzone na podstawie pliku prototypu sceny GUI (nazywanego również "prefabem", "szablonem" lub "blueprintem" w innych silnikach). Aby utworzyć nowy komponent GUI, <kbd>kliknij prawym przyciskiem myszy</kbd> w panelu *Assets* i wybierz <kbd>New ▸ Gui</kbd>. Wprowadź nazwę nowego pliku GUI i naciśnij <kbd>OK</kbd>.
+
+![New gui file](images/gui/new_gui_file.png){srcset="images/gui/[email protected] 2x"}
+
+Teraz Defold automatycznie otwiera plik w edytorze sceny GUI.
+
+![New gui](images/gui/new_gui.png){srcset="images/gui/[email protected] 2x"}
+
+W panelu *Outline* znajdziesz wszystkie elementy GUI: listę węzłów (nodes) i wszelkie zależności (patrz niżej).
+
+Centralny obszar edycji pokazuje GUI. W pasku narzędziowym w prawym górnym rogu obszaru edycji znajdują się narzędzia *Move*, *Rotate* i *Scale* (odpowiednio Przesuń, Obróć i Skaluj), a także selektor układu [layout](/manuals/gui-layouts).
+
+![toolbar](images/gui/toolbar.png){srcset="images/gui/[email protected] 2x"}
+
+Biały prostokąt pokazuje obszar wybranego layoutu, o domyślnej szerokości i wysokości ekranu ustawionej w ustawieniach projektu.
+
+Wybierając węzeł "Gui" w panelu *Outline*, zostaną wyświetlone *Properties* komponentu GUI:
+
+Script
+: Skrypt GUI przypisany do tego komponentu GUI.
+
+Material
+: Materiał używany podczas renderowania tego GUI.
+
+Adjust Reference
+: Dostosowanie odniesienia - kontroluje, jak powinien być obliczany Tryb dostosowania (*Adjust Mode*) każdego węzła:
+
+  - `Per Node` - dostosowuje każdy węzeł do dostosowanego rozmiaru węzła nadrzędnego lub zmienionego rozmiaru ekranu.
+  - `Disable` - wyłącza tryb dostosowywania węzła. To wymusza, aby wszystkie węzły zachowały swój ustawiony rozmiar.
+
+Max Nodes
+: Maksymalna liczba węzłów dla tego GUI.
+
+## Zależności
+
+Drzewo zasobów w grze Defold jest statyczne, więc wszelkie zależności, które potrzebujesz dla swoich węzłów GUI, muszą być dodane do komponentu. W panelu *Outline* grupuje się wszystkie zależności według typu w "folderach":
+
+![dependencies](images/gui/dependencies.png){srcset="images/gui/[email protected] 2x"}
+
+Aby dodać nową zależność, <kbd>kliknij prawym przyciskiem myszy</kbd> root "Gui" w panelu *Outline*, a następnie wybierz <kbd>Add ▸ [typ]</kbd> z kontekstowego menu.
+
+Możesz także <kbd>kliknąć prawym przyciskiem myszy</kbd> na ikonie folderu dla typu, który chcesz dodać, i wybrać <kbd>Add ▸ [typ]</kbd>.
+
+## Typy węzłów
+
+Komponent GUI jest tworzony z zestawu węzłów (nodes). Węzły to proste elementy. Mogą być przesuwane (przesuwane, skalowane i obracane) oraz uporządkowane w hierarchi rodzic-dziecko zarówno w edytorze, jak i w trakcie działania skryptu. Istnieją następujące typy węzłów:
+
+Box node
+: ![box node](images/icons/gui-box-node.png){.left}
+  Węzeł prostokątny z jednym kolorem, teksturą lub animacją typu flip-book. Zobacz [dokumentację węzła prostokątnego](/manuals/gui-box).
+
+<div style="clear: both;"></div>
+
+Text node
+: ![text node](images/icons/gui-text-node.png){.left}
+  Wyświetla tekst. Zobacz [dokumentację węzła tekstowego](/manuals/gui-text) for details.
+
+<div style="clear: both;"></div>
+
+Pie node
+: ![pie node](images/icons/gui-pie-node.png){.left}
+  Węzeł okrągły lub eliptyczny, który może być częściowo wypełniony (jak pierścień) lub odwrócony. Zobacz [dokumentację węzła pierścienia](/manuals/gui-pie).
+
+<div style="clear: both;"></div>
+
+Template node
+: ![template node](images/icons/gui.png){.left}
+  Szablony służą do tworzenia instancji na podstawie innych plików sceny GUI. Zobacz [dokumentację węzła szablonu](/manuals/gui-template).
+
+<div style="clear: both;"></div>
+
+ParticleFX node
+: ![particlefx node](images/icons/particlefx.png){.left}
+  Odtwarza efekt cząsteczkowy. Zobacz [dokumentację węzła ParticleFX](/manuals/gui-particlefx).
+
+<div style="clear: both;"></div>
+
+Aby dodać węzły, kliknij prawym przyciskiem myszy na folderze *Nodes* i wybierz <kbd>Add ▸</kbd>, a następnie <kbd>Box</kbd>, <kbd>Text</kbd>, <kbd>Pie</kbd>, <kbd>Template</kbd> lub <kbd>ParticleFx</kbd>.
+
+![Add nodes](images/gui/add_node.png){srcset="images/gui/[email protected] 2x"}
+
+Możesz także nacisnąć <kbd>A</kbd> i wybrać typ, który chcesz dodać do GUI.
+
+## Właściwości węzłów
+
+Każdy węzeł ma szeroki zestaw właściwości (properties), które kontrolują jego wygląd:
+
+Id
+: Identyfikator węzła. Ta nazwa musi być unikalna w ramach sceny GUI.
+
+Position, Rotation and Scale
+: Kontrolują położenie, orientację i skalę węzła. Możesz użyć narzędzi *Move*, *Rotate* i *Scale*  (odpowiednio Przesuń, Obróć i Skaluj), aby zmienić te wartości. Wartości można animować za pomocą skryptu ([dowiedz się więcej](/manuals/property-animation)).
+
+Rozmiar (węzły box, text i pie)
+: Rozmiar węzła jest domyślnie automatyczny, ale ustawiając *Size Mode* na `Manual`, możesz zmienić wartość. Rozmiar określa granice węzła i jest używany do wykrywania interakcji z myszą. Tę wartość można animować za pomocą skryptu ([dowiedz się więcej](/manuals/property-animation)).
+
+Size Mode (węzły box i pie)
+: Jeśli jest ustawiony na `Automatic`, edytor ustawia rozmiar węzła. Jeśli jest ustawiony na `Manual`, możesz samodzielnie ustawić rozmiar.
+
+Enabled
+: Jeśli nie jest zaznaczone, węzeł nie jest renderowany, nie jest animowany i nie można go zaznaczyć za pomocą `gui.pick_node()`. Użyj `gui.set_enabled()` i `gui.is_enabled()` do zmiany w kodzie i sprawdzenia tej właściwości.
+
+Visible
+: Jeśli nie jest zaznaczone, węzeł nie jest renderowany, ale wciąż może być animowany i można go zaznaczyć za pomocą `gui.pick_node()`. Użyj `gui.set_visible()` i `gui.get_visible()` do zmiany w kodzie i sprawdzenia tej właściwości.
+
+Text (węzły text)
+: Tekst do wyświetlenia na węźle.
+
+Line Break (węzły text)
+: Ustaw do zawijania tekstu zgodnie z szerokością węzła.
+
+Font (węzły text)
+: Font do użycia podczas renderowania tekstu.
+
+Texture (węzły box i pie)
+: Tekstura do narysowania na węźle. Jest to odniesienie do obrazu lub animacji w atlasie lub źródle kafelków.
+
+Slice 9 (węzły box)
+: Ustaw, aby zachować rozmiar pikseli tekstury węzła wokół krawędzi i na rogach, gdy węzeł ma zmieniany rozmiar. Zobacz szczegóły w [dokumentacji węzła prostokątnego](/manuals/gui-box).
+
+Inner Radius (węzły pie)
+: Wewnętrzny promień węzła, wyrażony wzdłuż osi X. Zobacz [dokumentację węzła pierścienia](/manuals/gui-pie).
+
+Outer Bounds(węzły pie)
+: Kontroluje zachowanie zewnętrznych granic. Zobacz [dokumentację węzła pierścienia](/manuals/gui-pie).
+
+Perimeter Vertices  (węzły pie)
+: Liczba segmentów, które zostaną użyte do zbudowania kształtu. Zobacz [dokumentację węzła pierścienia](/manuals/gui-pie).
+
+Pie Fill Angle (węzły pie)
+: Kąt wypełnienia - ile z pierścienia powinno być wypełnione. Zobacz[dokumentację węzła pierścienia](/manuals/gui-pie).
+
+Template (węzły template)
+: Plik sceny GUI do użycia jako szablon na węźle. Zobacz [dokumentację węzła szablonu](/manuals/gui-template).
+
+ParticleFX (węzły ParticleFX)
+: Efekt cząsteczkowy do użycia na węźle. Zobacz [dokumentację węzła ParticleFX](/manuals/gui-particlefx).
+
+Color
+: Kolor węzła. Jeśli węzeł jest tekstury, kolor zmienia odcień tekstury. Kolor można animować za pomocą skryptu (dowiedz się więcej).
+
+Alpha
+: Przejrzystość węzła. Wartość alfa może być animowana za pomocą skryptu ([dowiedz się więcej](/manuals/property-animation)).
+
+Inherit Alpha
+: Zaznaczenie tego pola sprawia, że węzeł dziedziczy wartość alfy węzła nadrzędnego. Wartość alfy węzła jest następnie mnożona przez wartość alfy nadrzędnego węzła.
+
+Leading (węzły text)
+: Skalująca liczba dla rozstawu międzywierszowego. Wartość `0` oznacza brak rozstawu międzywierszowego. `1` (domyślnie) to normalny rozstaw międzywierszowy.
+
+Tracking (węzły text)
+: Skalująca liczba dla odstępu między literami. Domyślnie wynosi `0`.
+
+Layer
+: Przypisanie warstwy węzłowi zastępuje normalny porządek rysowania i zamiast tego renderowanie podąża za porządkiem warstwy. Poniżej znajdziesz szczegóły.
+
+Blend mode
+: Tryb mieszania kontroluje sposób mieszania się grafiki węzła z grafiką tła:
+
+  - `Alpha` - mieszają się wartości pikseli węzła z tłem. Odpowiada to trybowi "Normal" w oprogramowaniu graficznym.
+  - `Add` - dodaje wartości pikseli węzła do tła. Odpowiada to trybowi "Linear Dodge" w niektórym oprogramowaniu graficznym.
+  - `Multiply` - mnoży wartości pikseli węzła przez tło.
+
+Pivot
+: Oś obrotu - ustawia punkt obrotu węzła. Można to postrzegać jako "punkt centralny" węzła. Każda rotacja, skalowanie lub zmiana rozmiaru będzie zachodzić wokół tego punktu.
+
+Możliwe wartości to `Center`, `North`, `South`, `East`, `West`, `North West`, `North East`, `South West` lub `South East`.
+
+  ![pivot point](images/gui/pivot.png){srcset="images/gui/[email protected] 2x"}
+
+Jeśli zmienisz punkt obrotu węzła, węzeł zostanie przesunięty tak, że nowy punkt obrotu będzie znajdować się w pozycji węzła. Węzły tekstowe są ustawiane tak, że `Center` ustawia środek tekstu, `West` ustawia tekst wyrównany do lewej, a `East` ustawia tekst wyrównany do prawej.
+
+X Anchor, Y Anchor
+: Kotwiczenie kontroluje, w jaki sposób wertykalna i pozioma pozycja węzła jest zmieniana, gdy granice sceny lub granice węzła nadrzędnego są rozciągane, aby pasować do rzeczywistego rozmiaru ekranu.
+
+  ![Anchor unadjusted](images/gui/anchoring_unadjusted.png){srcset="images/gui/[email protected] 2x"}
+
+  Dostępne są następujące tryby kotwiczenia:
+
+  - `None` (zarówno *X Anchor*, jak i *Y Anchor*) zachowuje pozycję węzła od centrum węzła nadrzędnego lub sceny, w odniesieniu do jego zmienionego rozmiaru.
+  - `Left` lub `Right` (*X Anchor*) skaluje poziomą pozycję węzła, aby zachować pozycję z lewego i prawego brzegu węzła nadrzędnego lub sceny w tej samej proporcji.
+  - `Top` lub `Bottom` skaluje pionową pozycję węzła, aby zachować pozycję z górnego i dolnego brzegu węzła nadrzędnego lub sceny w tej samej proporcji.
+
+  ![Anchoring](images/gui/anchoring.png){srcset="images/gui/[email protected] 2x"}
+
+Adjust Mode
+: Ustala tryb dostosowania węzła. Ustawienie trybu dostosowania kontroluje, co się dzieje z węzłem, gdy granice sceny lub granice węzła nadrzędnego są dostosowywane, aby pasować do rzeczywistego rozmiaru ekranu.
+
+  Węzeł utworzony w scenie, w której rozdzielczość logiczna jest typową rozdzielczością krajobrazu:
+
+  ![Unadjusted](images/gui/unadjusted.png){srcset="images/gui/[email protected] 2x"}
+
+  Dostępne są następujące tryby dostosowania:
+
+  - `Fit` Dopasowanie sceny do ekranu pionowego powoduje rozciągnięcie sceny. Każdy obszar ograniczający węzła jest podobnie rozciągany. Jednak ustawiając tryb dostosowania, można zachować niezmieniony stosunek szerokości węzła. 
+  - `Zoom` skaluje zawartość węzła tak, aby była równa rozciągniętej szerokości lub wysokości prostokątnego obszaru ograniczającego, w zależności od tego, która jest większa. Innymi słowy, zawartość w pełni pokryje rozciągnięty obszar ograniczający węzła.
+  - `Stretch` rozciąga zawartość węzła, tak aby wypełniła rozciągnięty obszar ograniczający węzła.
+
+  ![Adjust modes](images/gui/adjusted.png){srcset="images/gui/[email protected] 2x"}
+
+  Jeśli właściwość sceny GUI *Adjust Reference* jest ustawiona na `Disabled`, czyli wyłaczona, to ustawienie to będzie ignorowane.
+
+Clipping Mode (węzły box i pie)
+: Ustawia tryb przycinania na węźle:
+
+  - `None` renderuje węzeł jak zwykle.
+  - `Stencil` powoduje, że obrzeża węzła definiują maskę szablonu, która jest używana do przycinania węzłów podrzędnych węzła.
+
+  Zobacz [instrukcję przycinania GUI](/manuals/gui-clipping).
+
+Clipping Visible (węzły box i pie)
+: Ustaw, aby renderować zawartość węzła na obszarze maski szablonu. Zobacz [instrukcję przycinania GUI](/manuals/gui-clipping).
+
+Clipping Inverted (węzły box i pie)
+: Odwróć maskę szablonu. Zobacz [instrukcję przycinania GUI](/manuals/gui-clipping).
+
+## Punkt obrotu, Kotwice i Tryb Dostosowywania
+
+Kombinacja właściwości Pivot, Anchors i Adjust Mode umożliwia bardzo elastyczne projektowanie interfejsów GUI, ale może być to dość trudne do zrozumienia bez konkretnego przykładu. Przyjrzyjmy się temu projektowi interfejsu GUI utworzonemu dla ekranu o rozdzielczości 640x1136 pikseli:
+
+![](images/gui/adjustmode_example_original.png)
+
+Interfejs użytkownika jest utworzony z kotwicami X i Y ustawionymi na None, a Tryb Dostosowywania Adjust Mode dla każdego węzła pozostawiony na domyślnym ustawieniu Fit. Pivot dla panelu górnego to North, pivot dla panelu dolnego to South, a pivot dla pasków w panelu górnym to West. Reszta węzłów ma punkty obrotu ustawione na Center. Jeśli zmienimy rozmiar okna, aby było szersze, to oto co się stanie:
+
+![](images/gui/adjustmode_example_resized.png)
+
+Teraz, co zrobić, jeśli chcemy, aby górne i dolne paski zawsze miały taką samą szerokość jak ekran? Możemy zmienić Adjust Mode dla paneli tła na kolor szary na Stretch:
+
+![](images/gui/adjustmode_example_resized_stretch.png)
+
+To jest lepsze. Panele tła w kolorze szarym będą teraz zawsze rozciągnięte do szerokości okna, ale paski w panelu górnym oraz dwie skrzynki na dole nie są właściwie umieszczone. Jeśli chcemy, aby paski na górze pozostały po lewej stronie, musimy zmienić X Anchor z None na Left:
+
+![](images/gui/adjustmode_example_top_anchor_left.png)
+
+To jest dokładnie tak, jak chcemy, żeby było w przypadku panelu górnego. Paski w panelu górnym miały już punkty obrotu ustawione na West, co oznacza, że będą się ładnie pozycjonować z lewym/zachodnim brzegiem pasków (Pivot) przywiązanych do lewego brzegu panelu nadrzędnego (X Anchor).
+
+Teraz, jeśli ustawimy X Anchor na Left dla lewej skrzynki i na Right dla prawej skrzynki, otrzymamy następujący wynik:
+
+![](images/gui/adjustmode_example_bottom_anchor_left_right.png)
+
+To nie jest dokładnie oczekiwany wynik. Obie skrzynki powinny być tak blisko lewego i prawego brzegu, jak paski w panelu górnym. Powodem tego jest błędne ustawienie punktu obrotu:
+
+![](images/gui/adjustmode_example_bottom_pivot_center.png)
+
+Obie skrzynki mają ustawiony punkt obrotu - Pivot na Center. Oznacza to, że gdy ekran staje się szerszy, środek skrzynki (punkt obrotu) pozostaje na tej samej względnej odległości od brzegów. W przypadku lewej skrzynki było to 17% od lewego brzegu w oryginalnym oknie o rozdzielczości 640x1136 pikseli:
+
+![](images/gui/adjustmode_example_original_ratio.png)
+
+Gdy rozmiar ekranu jest inny, środek lewej skrzynki pozostaje na tej samej odległości 17% od lewego brzegu:
+
+![](images/gui/adjustmode_example_resized_stretch_ratio.png)
+
+Jeśli zmienimy Pivot z Center na West dla lewej skrzynki i na East dla prawej skrzynki i przesuniemy skrzynki, otrzymamy oczekiwany wynik, nawet gdy ekran zostanie zmieniony w rozmiarze:
+
+![](images/gui/adjustmode_example_bottom_pivot_west_east.png)
+
+## Kolejność rysowania
+
+Wszystkie węzły są renderowane w kolejności, w jakiej są wymienione w folderze "Nodes". Węzeł na górze listy jest rysowany jako pierwszy i będzie więc wyglądać tak, jakby był za innymi węzłami. Ostatni węzeł na liście jest rysowany jako ostatni, co oznacza, że będzie wyglądać tak, jakby był z przodu względem wszystkich innych węzłów. Zmiana wartości Z na węźle nie kontroluje kolejności rysowania; jednakże, jeśli ustawisz wartość Z poza zakresem renderowania swojego skryptu renderującego, węzeł nie będzie już renderowany na ekranie. Możesz również nadpisać kolejność indeksów węzłów warstwami (patrz poniżej).
+
+![Draw order](images/gui/draw_order.png){srcset="images/gui/[email protected] 2x"}
+
+Wybierz węzeł i naciśnij <kbd>Alt + W górę/W dół</kbd>, aby przesunąć węzeł w górę lub w dół i zmienić kolejność indeksu.
+
+Kolejność rysowania można zmieniać w skrypcie:
+
+```lua
+local bean_node = gui.get_node("bean")
+local shield_node = gui.get_node("shield")
+
+if gui.get_index(shield_node) < gui.get_index(bean_node) then
+  gui.move_above(shield_node, bean_node)
+end
+```
+
+## Hierarchie rodzic-dziecko
+
+Węzeł staje się dzieckiem (ang. child) innego węzła, przeciągając go na węzeł, który chcesz, aby był rodzicem (ang. parent) dziecka. Węzeł z rodzicem dziedziczy transformację (pozycję, obrót i skalę) stosowaną do rodzica i względem punktu obrotu rodzica.
+
+![Parent child](images/gui/parent_child.png){srcset="images/gui/[email protected] 2x"}
+
+Rodzice są rysowani przed swoimi dziećmi. Wykorzystaj warstwy, aby zmienić kolejność rysowania węzłów rodzica i dziecka oraz zoptymalizować renderowanie węzłów (patrz poniżej).
+
+## Warstwy i wywołania rysowania
+
+Warstwy (ang. layers) pozwalają na dokładną kontrolę nad tym, w jaki sposób węzły są rysowane i mogą być używane do zmniejszenia liczby wywołań rysowania (ang. draw calls), jakie silnik musi tworzyć, aby narysować scenę GUI. Gdy silnik ma rysować węzły sceny GUI, grupuje je we wskaźniki wywołań rysowania na podstawie następujących warunków:
+
+- Węzły muszą używać tego samego typu.
+- Węzły muszą używać tego samego atlasu lub źródła kafelków.
+- Węzły muszą być renderowane tym samym trybem mieszania (blend mode).
+- Muszą używać tego samego fontu.
+
+Jeśli węzeł różni się od poprzedniego pod względem któregoś z tych punktów, nastąpi przerwanie wskaźnika i zostanie utworzone inne wywołanie rysowania. Przycinanie węzłów (clipping nodes) zawsze przerywa wskaźnik, tak jak i każdy zakres szablonu (stencil scope).
+
+Możliwość organizowania węzłów w hierarchie ułatwia grupowanie węzłów w jednostki łatwo zarządzalne. Jednak hierarchie mogą skutecznie przerywać renderowanie wskaźników, jeśli miesza się różne typy węzłów:
+
+![Breaking batch hierarchy](images/gui/break_batch.png){srcset="images/gui/[email protected] 2x"}
+
+Kiedy potok renderowania (ang. rendering pipeline) przechodzi przez listę węzłów, zmuszony jest utworzyć oddzielny wskaźnik dla każdego oddzielnego węzła, ponieważ typy są różne. Ogólnie rzecz biorąc, te trzy przyciski będą wymagały sześciu wywołań rysowania.
+
+Przypisując węzłom warstwy, można je uporządkować w inny sposób, co pozwala potokowi renderowania grupować węzły w mniej wywołań rysowania. Zacznij od dodania potrzebnych warstw do sceny. Kliknij prawym przyciskiem na ikonę folderu "Layers" w widoku "Outline" i wybierz "Add ▸ Layer". Zaznacz nową warstwę i przypisz jej właściwość "Name" w widoku "Properties".
+
+![Layers](images/gui/layers.png){srcset="images/gui/[email protected] 2x"}
+
+Następnie ustaw właściwość "Layer" dla każdego węzła na odpowiadającą mu warstwę. Kolejność rysowania warstw ma pierwszeństwo nad zwykłym porządkiem indeksów węzłów, więc ustawienie węzłów graficznych przycisku na warstwę "graphics" i węzłów tekstowych przycisku na warstwę "text" spowoduje następującą kolejność rysowania:
+
+Najpierw wszystkie węzły w warstwie "text", od góry:
+
+  1. "button-1"
+  2. "button-2"
+  3. "button-3"
+
+Następnie wszystkie węzły w warstwie "tekst", od góry:
+
+  4. "button-text-1"
+  5. "button-text-2"
+  6. "button-text-3"
+
+Węzły mogą teraz być grupowane w dwóch wywołaniach rysowania, zamiast sześciu. To znaczna wydajnościowa korzyść!
+
+Należy zauważyć, że węzeł potomny (child node) bez ustawionej warstwy dziedziczy domyślne ustawienia warstwy od węzła rodzica. Nieustawienie warstwy na węźle domyślnie dodaje go do warstwy "null", która jest rysowana przed innymi warstwami.

docs/pl/manuals/importing-models.md

@@ -4,16 +4,24 @@ brief: Ta instrukcja opisuje ze szczegółami jak importować i edytować modele
 ---
 
 # Importowanie modeli 3D
-Defold obecnie wspiera modele, szkielety i animacje tylko w formacie Collada *.dae*. Możesz używać narzędzi takich jak Maya, 3D Max, Sketchup czy Blender do tworzenia i/lub konwertowania modeli trójwymiarowych do formatu Collada. Blender jest jednym z popularniejszych i potężnych narzędzi do modelowania 3D, animacji, a nawet renderowania. Działa na systemach operacyjnych Windows, macOS i Linux i jest dostępny za darmo do pobrania ze strony http://www.blender.org
+Defold obecnie wspiera modele, szkielety i animacje w formacie GL Transmission Format *.glTF* oraz *Collada *.dae*. Możesz używać narzędzi takich jak Maya, 3D Max, Sketchup czy Blender do tworzenia i/lub konwertowania modeli trójwymiarowych do formatu glTF i Collada. Blender jest jednym z popularniejszych i potężnych narzędzi do modelowania 3D, animacji, a nawet renderowania. Działa na systemach operacyjnych Windows, macOS i Linux i jest dostępny za darmo do pobrania ze strony http://www.blender.org
 
 ![Model w Blenderze](images/model/blender.png){srcset="images/model/[email protected] 2x"}
 
-## Exportowanie do formatu Collada
-Kiedy eksportujesz model 3D do formatu Collada, otrzymujesz plik z rozszerzeniem *.dae*. Plik ten zawiera wszystkie informacje o wierzchołkach (ang. vertices), krawędziach i teksturach (ang. faces), które składają się na model trójwymiarowy, a także współrzędne UV (ang. _UV coordinates_) (które, w skrócie, przypisują daną część tekstury do siatki modelu) jeśli zostały zdefiniowane, kości szkieletu i dane o animacji.
+## Importowanie do Defolda
+Aby zaimportować model 3D do Defold, przeciągnij i upuść plik *.gltf* lub *.dae* oraz odpowiednie obrazy tekstur w dowolnej lokalizacji w panelu *Assets*.
+
+![Importowanie](images/model/assets.png){srcset="images/model/[email protected] 2x"}
+
+## Używanie Modeli
+Kiedy model został zaimportowany do Defolda możesz go użyć jako [komponent typu Model](/manuals/model).
+
+## Exportowanie do formatu glTF i Collada
+Kiedy eksportujesz model 3D do formatu glTF lub Collada, otrzymujesz plik z rozszerzeniem *.gltf* lub *.dae*. Plik ten zawiera wszystkie informacje o wierzchołkach (ang. vertices), krawędziach i teksturach (ang. faces), które składają się na model trójwymiarowy, a także współrzędne UV (ang. _UV coordinates_) (które, w skrócie, przypisują daną część tekstury do siatki modelu) jeśli zostały zdefiniowane, kości szkieletu i dane o animacji.
 
-* Szczegółowy opisy wielokątów (ang. polygons) siatki możesz znaleźć na stronie http://en.wikipedia.org/wiki/Polygon_mesh.
+* Szczegółowy opisy wielokątów (ang. polygons) siatki możesz znaleźć na stronie (https://pl.wikipedia.org/wiki/Siatka_(grafika_3D))[https://pl.wikipedia.org/wiki/Siatka_(grafika_3D)].
 
-* Współrzędne UV i mapowanie UV opisane jest na stronie http://en.wikipedia.org/wiki/UV_mapping.
+* Współrzędne UV i mapowanie UV opisane jest na stronie (http://en.wikipedia.org/wiki/UV_mapping)[http://en.wikipedia.org/wiki/UV_mapping].
 
 Defold nakłada pewne ograniczenia na eksportowane dane o animacji:
 
@@ -23,20 +31,18 @@ Defold nakłada pewne ograniczenia na eksportowane dane o animacji:
 
 * Klipy animacji (ang. animation clips) w formacie Collada nie są wspierane. W celu używania wielu animacji dla modelu wyeksportuj je do osobnych plików *.dae* i zbierz je w zasób *.animationset* w edytorze Defold.
 
-
 ### Wymagania
 Kiedy eksportujesz model do formatu Collada musisz zapewnić spełnienie poniższych wymagań:
 
 * Model musi zawierać pojedynczą siatkę (ang. mesh)
 * Model musi używać jednego materiału
-
+* Wyeksportowany plik *.gltf* musi używać wbudowanych danych o siatce trójwymiarowej (embedded mesh data). Dane w osobnych plikach binarnych nie są wspierane.
 
 #### Łączenie wielu siatek
 Możesz użyć np. Blendera do połączenia wielu siatek. Wybierz wszystkie siatki i naciśnij `CTRL`/`CMD` + `J`.
 
 ![Łączenie siatek](images/model/blender_join_meshes.png)
 
-
 #### Usuwanie materiałów
 Możesz użyć np. Blendera do usunięcia dodatkowych materiałó z modeli. Wybierz dany materiał i naciśnij `-`.
 
@@ -56,22 +62,12 @@ Następnie możesz wyeksportować rozkład UV do pliku graficznego, który póź
 
 ![Eksportuj rozkład UV](images/model/blender_export_uv_layout.png)
 
-![Eksportuj ustawienia rozkładu UV layout settings](images/model/blender_export_uv_layout_settings.png)
+![Eksportuj ustawienia rozkładu - UV layout settings](images/model/blender_export_uv_layout_settings.png)
 
-![Eksportuj rozkład UV layout result](images/model/blender_export_uv_layout_result.png)
+![Eksportuj rozkład - UV layout result](images/model/blender_export_uv_layout_result.png)
 
 
 ## Exportowanie używając Blendera
 Możesz eksportować modele do formatu Collada używając opcji Export z menu w Blenderze. Wybierz dany model, wybierz opcję Export i zaznacz opcję "Selection Only".
 
 ![Exportowanie używając Blendera](images/model/blender_export.png)
-
-
-## Importowanie do Defolda
-Żeby zaimportować model, przenieś go do katalogu projektu lub przeciągnij plik *.dae* nad wybrany obraz tekstury w panelu *Assets Pane*.
-
-![Importowane zasoby modelu](images/model/assets.png){srcset="images/model/[email protected] 2x"}
-
-
-## Używanie modeli
-Kiedy model 3D jest zaimportowany do Defolda możesz go użyć w [komponencie Model](/manuals/model).

docs/pl/manuals/label.md

@@ -0,0 +1,131 @@
+---
+title: Etykieta w Defoldzie
+brief: Ta instrukcja wyjaśnia jak korzystać z etykiety w celu wyświetlania tekstu w grach.
+---
+
+# Etykieta (Label)
+
+Komponent Etykieta (ang. Label) renderuje fragment tekstu na ekranie w przestrzeni gry. Domyślnie jest sortowany i rysowany razem z wszystkimi grafikami sprite i kafelkami. Komponent ten ma zestaw właściwości, które regulują sposób renderowania tekstu. GUI w Defoldzie obsługuje tekst, ale może być trudno umieścić elementy GUI w przestrzeni świata gry, razem z obiektami gry. Etykiety ułatwiają to.
+
+## Tworzenie etykiety
+
+Aby utworzyć komponent etykiety - label, <kbd>kliknij prawym przyciskiem myszy</kbd> na obiekcie gry i wybierz <kbd>Add Component ▸ Label</kbd>.
+
+![Dodaj etykietę](images/label/add_label.png){srcset="images/label/[email protected] 2x"}
+
+(Jeśli chcesz utworzyć kilka etykiet na podstawie tego samego szablonu, możesz także utworzyć nowy plik komponentu etykiety: <kbd>kliknij prawym przyciskiem myszy</kbd> na folder w panelu *Assets* i wybierz <kbd>New... ▸ Label</kbd>, a następnie dodaj plik jako komponent do dowolnych obiektów gry).
+
+![Nowa etykieta](images/label/label.png){srcset="images/label/[email protected] 2x"}
+
+Ustaw właściwość *Font* na font, który chcesz użyć, i upewnij się, że właściwość *Material* ma materiał, który pasuje do rodzaju fontu:
+
+![Font i materiał](images/label/font_material.png){srcset="images/label/[email protected] 2x"}
+
+## Właściwości etykiety
+
+Oprócz właściwości *Id*, *Position*, *Rotation* i *Scale*, istnieje kilka specyficznych dla komponentu właściwości (properties):
+
+*Text*
+: Zawartość tekstu etykiety.
+
+*Size*
+: Rozmiar obwiedni tekstu. Jeśli ustawiona jest *Line Break* (Łamanie linii), szerokość określa punkt, w którym tekst ma być złamany.
+
+*Color*
+: Kolor tekstu.
+
+*Outline*
+: Kolor obramowania tekstu.
+
+*Shadow*
+: Kolor cienia tekstu.
+
+::: sidenote
+Należy zauważyć, że domyślny materiał wyłącza renderowanie cieni ze względów wydajnościowych.
+:::
+
+*Leading*
+: Interlinia - skalowalna liczba dla odstępu między liniami. Wartość 0 oznacza brak odstępu między liniami. Domyślnie wynosi 1.
+
+*Tracking*
+: Śledzenie - skalowalna liczba dla odstępu między literami. Domyślnie wynosi 0.
+
+*Pivot*
+: Punkt obrotu tekstu. Używaj go, aby zmieniać wyrównanie tekstu (patrz poniżej).
+
+*Blend Mode*
+: Tryb mieszania do użycia podczas renderowania etykiety.
+
+*Line Break*
+: Łamanie linii - wyrównanie tekstu podąża za ustawieniem *pivot* i ustawienie tej właściwości pozwala na przepływ tekstu na kilka linii. Szerokość komponentu określa, gdzie tekst ma się zawijać. Należy zauważyć, że tekst musi zawierać spacje, aby mógł się złamać.
+
+*Font*
+: Zasób fontu do użycia w tej etykiecie.
+
+*Material*
+: Materiał do użycia podczas renderowania tej etykiety. Upewnij się, że wybierasz materiał stworzony dla rodzaju czcionki, którą używasz (mapa bitowa (bitmap), pole odległości (distance field) lub BMFont).
+
+### Tryby mieszania
+: [Tryby mieszania - blend-modes opisane są tutaj](../shared/blend-modes.md)
+
+### Pivot i wyrównanie
+
+Ustawiając właściwość *Pivot*, możesz zmienić tryb wyrównania tekstu.
+
+*Center*
+: Środek - jeśli pivot jest ustawiony na `Center`, `North` lub `South`, tekst jest wyrównywany do środka.
+
+*Left*
+: Do lewej - jeśli pivot jest ustawiony na którykolwiek z trybów `West`, tekst jest wyrównywany do lewej.
+
+*Right*
+: Do prawej - jeśli pivot jest ustawiony na którykolwiek z trybów `East`, tekst jest wyrównywany do prawej.
+
+![Wyrównanie tekstu](images/label/align.png){srcset="images/label/[email protected] 2x"}
+
+## Manipulacja etykietą w czasie rzeczywistym
+
+Możesz manipulować etykietami w czasie działania programu, uzyskując i ustawiając tekst etykiety oraz różne inne właściwości.
+
+`color`
+: Kolor etykiety (typ `vector4`)
+
+`outline`
+: Kolor obrysu etykiety (typ `vector4`)
+
+`shadow`
+: Kolor cienia etykiety (typ `vector4`)
+
+`scale`
+: Skala etykiety, albo typu `number` dla jednolitej skali, albo `vector3` dla indywidualnej skali wzdłuż każdej osi.
+
+`size`
+: Rozmiar etykiety (typ `vector3`)
+
+```lua
+function init(self)
+    -- Ustaw tekst komponentu "my_label" w tym samym obiekcie gry
+    -- co ten skrypt.
+    label.set_text("#my_label", "New text")
+end
+```
+
+```lua
+function init(self)
+    -- Ustaw kolor komponentu "my_label" w tym samym obiekcie gry.
+    -- Kolor jest wartością RGBA przechowywaną w wektorze 4-składnikowym.
+    local grey = vmath.vector4(0.5, 0.5, 0.5, 1.0)
+    go.set("#my_label", "color", grey)
+
+    -- ... i usuń obrys, ustawiając jego alfa na 0 ...
+    go.set("#my_label", "outline.w", 0)
+
+    -- ... i powiększ go dwukrotnie wzdłuż osi x
+    local scale_x = go.get("#my_label", "scale.x")
+    go.set("#my_label", "scale.x", scale_x * 2)
+end
+```
+
+## Konfiguracja projektu
+
+Plik *game.project* ma kilka [ustawień projektu związanych z etykietami](/manuals/project-settings#label.

docs/pl/manuals/mesh.md

@@ -0,0 +1,107 @@
+---
+title: Komponent Mesh w Defoldzie
+brief: Ta instrukcja opisuje jak działają komponenty typu Mesh służące do wyśweitlania obiektów 3D.
+---
+
+# Komponent Mesh (Siatka)
+
+Defold to od podstaw silnik 3D. Nawet w przypadku pracy tylko z materiałem 2D, całe renderowanie jest wykonywane w 3D, ale rzutowane ortograficznie na ekran. Defold pozwala na korzystanie z pełnej zawartości 3D poprzez dodawanie i tworzenie komponentów 3D w czasie wykonywania w kolekcjach. Możesz tworzyć gry w czystym 3D, korzystając tylko z aktywów 3D, lub mieszać zawartość 3D i 2D według własnych preferencji. Komponent typu Mesh - Siatka jest jednym z komponentów do obsługi elementów trójwymiarowych.
+
+## Tworzenie komponentu Siatki
+
+Komponenty Siatki - mesh są tworzone tak samo jak każdy inny komponent obiektu gry. Możesz to zrobić na dwa sposoby:
+
+- Utwórz plik Mesh <kbd>klikając prawym przyciskiem myszy</kbd> w lokalizacji w panelu *Assets* i wybierając <kbd>New... ▸ Mesh</kbd>.
+- Utwórz komponent osadzony bezpośrednio w obiekcie gry <kbd>klikając prawym przyciskiem myszy</kbd> na obiekcie gry w panelu *Outline* i wybierając <kbd>Add Component ▸ Mesh</kbd>.
+
+![Mesh w obiekcie gry](images/mesh/mesh.png)
+
+Po utworzeniu Siatki musisz określić szereg właściwości (properties):
+
+### Właściwości Siatki
+
+Oprócz właściwości *Id*, *Position* i *Rotation* istnieją następujące właściwości specyficzne dla komponentu typu Mesh:
+
+*Material*
+: Materiał do użycia podczas renderowania Siatki trójwymiarowej.
+
+*Vertices*
+: Plik bufora opisujący dane Siatki dla strumienia.
+
+*Primitive Type*
+: Typ prymitywu: Linie, Trójkąty lub Trójkąty Strip (Lines, Triangles or Triangle Strip).
+
+*Position Stream*
+: Strumień pozycji - ta właściwość powinna zawierać nazwę strumienia *position*. Strumień jest automatycznie dostarczany jako wejście do vertex shadera (shadera wierzchołków).
+
+*Normal Stream*
+: Strumień normalnych - ta właściwość powinna zawierać nazwę strumienia *normal*. Strumień jest automatycznie dostarczany jako wejście do vertex shadera.
+
+*tex0*
+: Ustaw to na teksturę do użycia na siatce.
+
+## Manipulacja w Edytorze
+
+Dzięki komponentowi typu Mesh możesz swobodnie edytować i manipulować komponentem i/lub otaczającym obiektem gry za pomocą standardowych narzędzi Edytora sceny (*Scene Editor*), aby dostosować pozycję, obrót i skalowanie Siatki według swojego uznania.
+
+## Manipulacja w czasie rzeczywistym
+
+Możesz manipulować meshami w czasie wykonania programu, korzystając z buforów Defolda. Oto przykład tworzenia sześcianu z pasów trójkątów:
+
+```Lua
+
+-- definicja wierzchołków sześcianu
+local vertices = {
+	0, 0, 0,
+	0, 1, 0,
+	1, 0, 0,
+	1, 1, 0,
+	1, 1, 1,
+	0, 1, 0,
+	0, 1, 1,
+	0, 0, 1,
+	1, 1, 1,
+	1, 0, 1,
+	1, 0, 0,
+	0, 0, 1,
+	0, 0, 0,
+	0, 1, 0
+}
+
+-- utwórz bufor z danymi pozycji
+local buf = buffer.create(#vertices / 3, {
+	{ name = hash("position"), type=buffer.VALUE_TYPE_FLOAT32, count = 3 }
+})
+
+-- pobierz strumień pozycji i zapisz wierzchołki
+local positions = buffer.get_stream(buf, "position")
+for i, value in ipairs(vertices) do
+	positions[i] = vertices[i]
+end
+
+-- ustaw bufor z wierzchołkami w siatce
+local res = go.get("#mesh", "vertices")
+resource.set_buffer(res, buf)
+```
+
+Aby uzyskać więcej informacji na temat korzystania z komponentu Mesh, w tym projektów przykładowych i fragmentów kodu, zapoznaj się z [postem ogłoszeniowym na forum](https://forum.defold.com/t/mesh-component-in-defold-1-2-169-beta/65137.
+
+## Frustum culling
+
+Frustum culling, czyli odrzucanie widoku spoza bryły widoku to funkcjonalność pozwalająca usuwać powierzchnie spoza widoku określonego przez specjalną bryłę (frustum) w celu zyskiwaniu na szybkości renderowania. Komponenty typu Mesh nie są automatycznie odrzucane ze względu na ich dynamiczną naturę i fakt, że niemożliwe jest dokładne ustalenie, w jaki sposób dane pozycyjne są kodowane. Aby odrzucić mesh, należy ustawić prostopadłościenne obramowanie otaczające mesh jako metadane w buforze za pomocą 6 liczb zmiennoprzecinkowych (AABB min/max):
+
+```lua
+buffer.set_metadata(buf, hash("AABB"), { 0, 0, 0, 1, 1, 1 }, buffer.VALUE_TYPE_FLOAT32)
+```
+
+## Stałe materiałowe
+
+{% include shared/material-constants.md component='mesh' variable='tint' %}
+
+`tint`
+: odcień/barwa Siatki (typu `vector4`). Wektor 4-składnikowy jest używany do reprezentowania odcienia z X, Y, Z i W odpowiadającymi kolorami czerwonym, zielonym, niebieskim i alfa (przezroczystości).
+
+## Przestrzeń wierzchołkowa lokalna a przestrzeń świata
+Jeśli ustawienia Przestrzeni wierzchołka (Vertex Space setting) materiału Siatki są ustawione na Przestrzeń lokalną (vertex local space), dane zostaną dostarczone do shadera w postaci, w jakiej są, i będziesz musiał przekształcać wierzchołki/normalne na GPU, tak jak zwykle.
+
+Jeśli ustawienia Przestrzeni wierzchołka materiału meshu są ustawione na Przestrzeń świata (world space), musisz albo dostarczyć domyślny strumień "position" i "normal", albo wybrać go z listy rozwijanej podczas edycji Siatki. Ma to na celu przekształcenie danych do przestrzeni świata w celu ich grupowania z innymi obiektami.

docs/pl/manuals/model.md

@@ -0,0 +1,125 @@
+---
+title: Modele 3D w Defoldzie
+brief: Ta instrukcja opisuje, jak wprowadzać modele 3D, szkielety i animacje do gry.
+---
+
+# Modele 3D
+
+Defold to od podstaw silnik 3D. Nawet gdy pracujesz tylko z materiałami 2D, całe renderowanie odbywa się w 3D, ale jest rzutowane ortograficznie na ekran. Defold pozwala na wykorzystywanie pełnej zawartości 3D poprzez dodawanie aktywów 3D lub Modeli do swoich kolekcji. Możesz budować gry wyłącznie w 3D, korzystając tylko z aktywów 3D, lub łączyć zawartość 3D i 2D, jak sobie życzysz. Komponent typu Model jest jednym z komponentów do obsługi elementów trójwymiarowych.
+
+## Tworzenie komponentu Modelu
+
+Komponenty Modelu tworzy się tak samo jak każdy inny komponent obiektu gry. Możesz to zrobić na dwa sposoby:
+
+- Utwórz plik Modelu, klikając prawym przyciskiem myszy w przeglądarki Aktywów i wybierając opcję <kbd>New... ▸ Model</kbd>.
+- Utwórz komponent osadzony bezpośrednio w obiekcie gry, klikając prawym przyciskiem myszy w obiekcie gry w widoku Konspekt i wybierając <kbd>Add Component ▸ Model</kbd>.
+
+![Model w obiekcie gry](images/model/model.png)
+
+Po utworzeniu siatki musisz określić szereg właściwości (properties):
+
+### Właściwości Modeli
+
+Oprócz właściwości *Id*, *Position* i *Rotation* istnieją następujące właściwości specyficzne dla komponentu typu Mesh:
+
+*Mesh*
+: Siatka - ta właściwość powinna odnosić się do pliku glTF *.gltf* lub Collada *.dae*, który zawiera siatkę trójwymiarową, którą chcesz użyć. Jeśli plik zawiera wiele siatek, zostanie odczytana tylko pierwsza.
+
+*Material*
+: Materiał - ustaw tę właściwość na materiał, który utworzyłeś i nadaje się do tekstur obiektu 3D. Dostępny jest wbudowany plik *model.material*, który można użyć jako punkt wyjścia.
+
+*Texture*
+: Tekstura - ta właściwość powinna wskazywać na plik obrazu tekstury, który chcesz zastosować do obiektu.
+
+*Skeleton*
+: Szkielet - ta właściwość powinna odnosić się do pliku glTF *.gltf* lub Collada *.dae*, który zawiera szkielet do użycia w animacji. Należy zauważyć, że Defold wymaga jednego korzenia hierarchii kostnej (root bone).
+
+*Animations*
+: Animacje - ustaw to na Plik zestawu animacji (*Animation Set*), który zawiera animacje, które chcesz użyć na modelu.
+
+*Default Animation*
+: Domyślna Animacja - to animacja (z zestawu animacji), która będzie najpierw automatycznie odtwarzana na modelu.
+
+## Manipulacja w Edytorze
+
+Mając komponent Modelu, możesz swobodnie edytować i manipulować komponentem lub otaczającym obiektem gry za pomocą zwykłych narzędzi Edytora Sceny (*Scene Editor*), aby dostosować model do swoich potrzeb.
+
+![Wiggler w grze](images/model/ingame.png){srcset="images/model/[email protected] 2x"}
+
+## Manipulacja w czasie rzeczywistym
+
+Możesz manipulować modelami w czasie działania programu za pomocą różnych funkcji i właściwości (zobacz [dokumentację API](/ref/model/)) w celu uzyskania informacji na temat użycia).
+
+### Animacja w czasie rzeczywistym
+
+Defold oferuje wsparcie dla kontroli animacji w czasie działania programu. Więcej informacji można znaleźć w [instrukcji dotyczącej animacji modelu](/manuals/model-animation):
+
+```lua
+local play_properties = { blend_duration = 0.1 }
+model.play_anim("#model", "jump", go.PLAYBACK_ONCE_FORWARD, play_properties)
+```
+
+Kursor odtwarzania animacji można animować ręcznie lub za pomocą systemu animacji właściwości:
+
+```lua
+-- ustaw animację biegu
+model.play_anim("#model", "run", go.PLAYBACK_NONE)
+-- animuj kursor animacji
+go.animate("#model", "cursor", go.PLAYBACK_LOOP_PINGPONG, 1, go.EASING_LINEAR, 10)
+```
+
+### Modyfikacja właściwości Modelu
+
+Model ma również wiele różnych właściwości, które można manipulować za pomocą funkcji `go.get()` i `go.set()`:
+
+`animation`
+: aktualna animacja modelu (typ `hash`) (TYLKO DO ODCZYTU). Zmieniasz animację, używając `model.play_anim()` (patrz wyżej).
+
+`cursor`
+: znormalizowany kursor animacji (typ `number`).
+
+`material`
+: materiał modelu (typ `hash`). Możesz to zmieniać za pomocą właściwości zasobów materiału i `go.set()`. Obejrzyj [dokumentację API](/ref/model/#material) w celu uzyskania przykładu.
+
+`playback_rate`
+: prędkość odtwarzania animacji (typ `number`).
+
+`textureN`
+: tekstury modelu, gdzie N to 0-7 (typ `hash`). Możesz to zmieniać za pomocą właściwości zasobów tekstury i `go.set()`. Obejrzyj [dokumentację API](/ref/model/#textureN) w celu uzyskania przykładu.
+
+## Materiały
+
+Oprogramowanie 3D zwykle pozwala na ustawienie właściwości wierzchołków obiektu, takie jak kolor i nakładanie tekstur. Te informacje trafiają do pliku glTF *.gltf* lub Collada *.dae*, który eksportujesz z oprogramowania 3D. W zależności od wymagań gry będziesz musiał wybrać lub utworzyć odpowiednie i _wydajne_ materiały dla swoich obiektów. Materiał łączy w sobie programy cieniowania (shadery) z zestawem parametrów do renderowania obiektu.
+
+Dostępny jest prosty materiał modelu 3D w wbudowanym folderze materiałów. Jeśli potrzebujesz tworzyć niestandardowe materiały dla swoich modeli, zobacz [dokumentację materiałów](/manuals/material) w celu uzyskania dalszych informacji. W [dokumentacji shaderów](/manuals/shader) znajdziesz informacje na temat działania takich programów cieniowania.
+
+### Stałe materiału
+
+{% include shared/material-constants.md component='model' variable='tint' %}
+
+`tint`
+: Kolor modelu (type `vector4`). Wektor 4-składnikowy jest używany do reprezentacji odcienia z wartościami X, Y, Z i W odpowiadającymi za czerwień, zielony, niebieski i kolor alfa (przezroczystości).
+
+## Renderowanie
+
+Domyślny skryp renderowanie (render script) jest napisany pod gry 2D i nie działa dobrze z modelami 3D. Kopiując domyślny skrypt i dodając kilka lini kodu możesz szybko włączyć renderowanie obiektów trójwymiarowych dla Twoich Modeli. Na przykład:
+
+  ```lua
+
+  function init(self)
+    self.model_pred = render.predicate({"model"})
+    ...
+  end
+
+  function update()
+    ...
+    render.set_depth_mask(true)
+    render.enable_state(render.STATE_DEPTH_TEST)
+    render.set_projection(stretch_projection(-1000, 1000))  -- orthographic
+    render.draw(self.model_pred)
+    render.set_depth_mask(false)
+    ...
+  end
+  ```
+
+Zobacz [dokumnetację renderowania](/manuals/render) w celu uzyskania dalszych informacji o skryptach renderowania.

docs/pl/manuals/particlefx.md

@@ -0,0 +1,244 @@
+---
+title: Efekty cząsteczkowe w Defoldzie
+brief: Ta instrukcja wyjaśnia, jak działa komponent efektów cząsteczkowych i jak go edytować, aby tworzyć efekty wizualne z użyciem cząsteczek.
+---
+
+# Efekty cząsteczkowe (Particle FX)
+
+Efekty cząsteczkowe (ang. particle effects) to wydajne elementy wizualne złożone z wielu powtarzalnych lub nie elementów (cząsteczek) i służą do wizualnego wzbogacania gier. Możesz ich używać do tworzenia eksplozji, rozprysku krwi, śladów, efektów pogodowych i wielu innych.
+
+![Edytor ParticleFX](images/particlefx/editor.png){srcset="images/particlefx/[email protected] 2x"}
+
+Efekty cząsteczkowe składają się z wielu emiterów (emitters) i opcjonalnych modyfikatorów (modifiers):
+
+Emitter
+: Emiter to umieszczony w przestrzeni kształt, który emituje cząsteczki równomiernie rozłożone na powierzchni tego kształtu. Emiter zawiera właściwości, które kontrolują generowanie cząsteczek oraz obraz lub animację, czas życia, kolor, kształt i prędkość poszczególnych cząstek.
+
+Modifier
+: Modyfikator wpływa na prędkość generowanych cząsteczek, sprawiając, że przyspieszają lub zwalniają w określonym kierunku, poruszają się promieniowo lub krążą wokół punktu. Modyfikatory mogą wpływać na pojedyncze cząsteczki jednego lub każdego emitera.
+
+## Tworzenie efektu cząsteczkowego
+
+Wybierz opcję <kbd>New... ▸ Particle FX</kbd> z menu kontekstowego w panelu *Assets*. Nadaj nowemu plikowi efektu cząsteczkowego nazwę. Edytor zostanie teraz otwarty w pliku z użyciem [Edytora Sceny](/manuals/editor/#the-scene-editor).
+
+W panelu *Outline* wyświetlany jest domyślny emiter. Wybierz emiter, aby wyświetlić jego właściwości w dolnym panelu *Properties* (Właściwości).
+
+![Domyślne cząsteczki](images/particlefx/default.png){srcset="images/particlefx/[email protected] 2x"}
+
+Aby dodać nowy emiter do efektu, <kbd>kliknij prawym przyciskiem myszy</kbd> na korzeniu (root) w panelu *Outline* i wybierz <kbd>Add Emitter ▸ [type]</kbd> z menu kontekstowego. Zauważ, że można nawet później zmienić typ emitera w jego właściwościach.
+
+Aby dodać nowy modyfikator, <kbd>kliknij prawym przyciskiem myszy</kbd> w miejscu modyfikatora w panelu *Outline* (korzeń efektu lub konkretny emiter) i wybierz <kbd>Add Modifier</kbd>, a następnie wybierz typ modyfikatora.
+
+![Dodaj modyfikator](images/particlefx/add_modifier.png){srcset="images/particlefx/[email protected] 2x"}
+
+![Wybór modyfikatora](images/particlefx/add_modifier_select.png){srcset="images/particlefx/[email protected] 2x"}
+
+Modyfikator osadzony na korzeniu efektu (nie jest dzieckiem emitera) wpływa na wszystkie cząsteczki w efekcie.
+
+Modyfikator, który jest dodany jako dziecko emitera, wpływa tylko na cząsteczki tego emitera.
+
+## Podgląd efektu
+
+* Wybierz opcję <kbd>View ▸ Play</kbd> z menu, aby zobaczyć podgląd efektu. Być może będziesz musiał oddalić kamerę, aby właściwie zobaczyć efekt.
+* Wybierz ponownie <kbd>View ▸ Play</kbd>, aby zapauzować efekt.
+* Wybierz <kbd>View ▸ Stop</kbd> aby zatrzymać efekt. Ponowne uruchomienie go rozpoczyna od jego stanu początkowego.
+
+Podczas edytowania emitera lub modyfikatora, wynik jest natychmiast widoczny w edytorze, nawet gdy efekt jest zatrzymany:
+
+![Edytowanie efektów](images/particlefx/rotate.gif)
+
+## Właściwości emitera
+
+Id
+: Identyfikator emitera (używany przy ustawianiu stałych renderowania dla określonych emiterów).
+
+Position/Rotation
+: Transformacja emitera względem komponentu ParticleFX.
+
+Play Mode
+: Tryb Odtwarzania - kontroluje sposób odtwarzania emitera:
+  - `Once` zatrzymuje emitera po osiągnięciu swojego czasu trwania.
+  - `Loop` ponownie uruchamia emitera po osiągnięciu czasu trwania.
+
+Size Mode
+: Tryb Rozmiaru - kontroluje, jak będą skalowane animacje poklatkowe atlasu:
+  - `Auto` - Automatyczny - zachowuje rozmiar każdej klatki animacji atlasu zgodnie z obrazem źródłowym.
+  - `Manual` - Manualny - ustawia rozmiar cząsteczki zgodnie z właściwością rozmiaru.
+
+Emission Space
+: Przestrzeń Emisji - w jakiej przestrzeni będą istniały generowane cząsteczki:
+  - `World` - Przestrzeń Świata - przemieszcza cząsteczki niezależnie od emitera.
+  - `Emitter` - Przestrzeń Emitera przemieszcza cząsteczki względem emitera.
+
+Duration
+: Czas Trwania - liczba sekund, przez które emiter powinien emitować cząsteczki.
+
+Start Delay
+: Opóźnienie Początku Emitowania - liczba sekund, na którą emiter powinien poczekać przed emisją cząsteczek.
+
+Start Offset
+: Odsunięcie Początku Emitowania - liczba sekund, po której symulacji cząsteczki emiter powinien rozpocząć, innymi słowy, jak długo emiter powinien "rozgrzewać" efekt.
+
+Image
+: Plik obrazu (Źródło Kafelków lub Atlas), który ma służyć do teksturyzacji i animacji cząsteczek.
+
+Animation
+: Animacja z pliku *Image*, która ma być używana na cząsteczkach.
+
+Material
+: Materiał do użycia do cieniowania (shading) cząsteczek.
+
+Blend Mode
+: Dostępne tryby mieszania to `Alpha`, `Add` i `Multiply`.
+
+Max Particle Count
+Maksymalna Liczba Cząsteczek - liczba cząstek pochodzących z tego emitera, która może istnieć jednocześnie.
+
+Emitter Type
+: Typ kształtu emitera
+  - `Circle` - Koło - emituje cząsteczki z losowej lokalizacji wewnątrz koła. Cząsteczki są skierowane na zewnątrz od centrum. Średnicę koła definiuje *Emitter Size X*.
+
+  - `2D Cone` - Stożek 2D - emituje cząsteczki z losowej lokalizacji wewnątrz płaskiego stożka (trójkąta). Cząsteczki są skierowane do góry stożka. *Emitter Size X* definiuje szerokość góry, a *Emitter Size Y* definiuje wysokość.
+
+  - `Box` - Sześcian - emituje cząsteczki z losowej lokalizacji wewnątrz sześcianu. Cząsteczki są skierowane w górę wzdłuż osi Y sześcianu. *Emitter Size X*, *Y* i *Z* definiują odpowiednio szerokość, wysokość i głębokość. Dla prostokąta 2D zachowaj rozmiar Z na zero.
+
+  - `Sphere` - Sfera - emituje cząsteczki z losowej lokalizacji wewnątrz kuli. Cząsteczki są skierowane na zewnątrz od centrum. Średnicę kuli definiuje *Emitter Size X*.
+
+  - `Cone` - Stożek - emituje cząsteczki z losowej lokalizacji wewnątrz stożka 3D. Cząsteczki kierują się na zewnątrz przez szeroki dysk stożka. *Emitter Size X* definiuje średnicę szerokiego dysku, a *Emitter Size Y* definiuje wysokość stożka.
+
+  ![Typy kształtów emiterów](images/particlefx/emitter_types.png){srcset="images/particlefx/[email protected] 2x"}
+
+Particle Orientation
+: Orientacja Cząsteczek - jak są ustawione cząsteczki emitowane:
+  - `Default` - Domyślna - ustawia orientację na orientację jednostkową.
+  - `Initial Direction` - Początkowy Kierunek - zachowuje początkową orientację emitowanych cząsteczk.
+  - `Movement Direction` - Kierunek Ruchu - dostosowuje orientację cząsteczek zgodnie z ich prędkością.
+
+Inherit Velocity
+: Dziedziczenie Prędkości - skalowany współczynnik, który określa, ile cząsteczki powinny dziedziczyć z prędkości emitera. Ta wartość jest dostępna tylko wtedy, gdy *Emission Space* jest ustawiona na `World`. Prędkość emitera jest obliczana co klatkę.
+
+Stretch With Velocity
+Rozciągnięcie z Prędkością - zaznacz, aby skalować rozciągnięcie cząsteczek w kierunku ruchu.
+
+### Tryby Mieszania
+:[Tryby Mieszania - blend-modes](../shared/blend-modes.md)
+
+## Kluczowe właściwości emitera
+
+Te właściwości mają dwa pola: wartość (value) i rozprzestrzenienie (spread). Rozprzestrzenienie to zmienna losowa, która jest stosowana losowo dla każdej wygenerowanej cząsteczki. Na przykład, jeśli wartość wynosi 50, a rozprzestrzenienie wynosi 3, każda wygenerowana cząsteczka otrzyma wartość między 47 a 53 (50 +/- 3).
+
+![właściwości](images/particlefx/property.png){srcset="images/particlefx/[email protected] 2x"}
+
+Zaznaczając przycisk klucza (key button), wartość właściwości jest kontrolowana za pomocą krzywej w trakcie trwania emitera. Aby zresetować właściwość z klucza, odznacz przycisk klucza.
+
+![właściwości z kluczem](images/particlefx/key.png){srcset="images/particlefx/[email protected] 2x"}
+
+Edytor Krzywej *Curve Editor* (dostępny w zakładkach w dolnym widoku) służy do modyfikacji krzywej. Właściwości z kluczem nie mogą być edytowane w widoku *Properties* , tylko w Edytorze Krzywej właśnie. <kbd>Kliknij i przeciągnij</kbd> punkty i styczne, aby zmodyfikować kształt krzywej. <kbd>Podwójne kliknięcie</kbd> na krzywej dodaje punkty kontrolne. Aby usunąć punkt kontrolny, podwójnie kliknij na niego.
+
+![Edytor Krzywej](images/particlefx/curve_editor.png){srcset="images/particlefx/[email protected] 2x"}
+
+Aby automatycznie przybliżyć Edytor Krzywej w celu wyświetlenia wszystkich krzywych, naciśnij <kbd>F</kbd>.
+
+Następujące właściwości można regulować w czasie trwania emitera:
+
+Spawn Rate
+: Częstotliwość Emisji - liczba cząsteczek do wyemitowania na sekundę.
+
+Emitter Size X/Y/Z
+: Rozmiar Emitera X/Y/Z - wymiary kształtu emitera, zobacz szczegóły prz opisie *Emitter Type* powyżej.
+
+Particle Life Time
+: Czas Życia Cząsteczki - długość życia każdej wyemitowanej cząsteczki, w sekundach.
+
+Initial Speed
+: Początkowa Prędkość każdej wyemitowanej cząsteczki.
+
+Initial Size
+: Początkowy Rozmiar każdej wyemitowanej cząsteczki. Jeśli ustawisz Tryb Rozmiaru *Size Mode* na `Automatic` i użyjesz animacji atlasu jako źródła obrazu, to właściwość ta jest ignorowana.
+
+Initial Red/Green/Blue/Alpha
+: Początkowe wartości składowych koloru dla cząsteczek, odpowiednio: Czerwony, Zielony, Niebieski, Alfa.
+
+Initial Rotation
+: Początkowe wartości obrotu (w stopniach) dla cząsteczek.
+
+Initial Stretch X/Y
+: Początkowe wartości rozciągnięcia (w jednostkach) dla cząsteczek.
+
+Initial Angular Velocity
+: Początkowa prędkość kątowa (w stopniach/sekundę) każdej wyemitowanej cząsteczki.
+
+Następujące właściwości można regulować w trakcie życia cząsteczek:
+
+Life Scale
+: Skala - wartość skali w trakcie życia każdej cząsteczki.
+
+Life Red/Green/Blue/Alpha
+: Wartość odcienia koloru w trakcie życia każdej cząsteczki, odpowiednio: Czerwony, Zielony, Niebieski, Alfa.
+
+Life Rotation
+: Wartość obrotu (w stopniach) w trakcie życia każdej cząsteczki.
+
+Life Stretch X/Y
+: Wartość rozciągnięcia (w jednostkach) w trakcie życia każdej cząsteczki.
+
+Life Angular Velocity
+: Prędkość kątowa (w stopniach/sekundę) w trakcie życia każdej cząsteczki.
+
+## Modyfikatory
+
+Dostępne są cztery rodzaje modyfikatorów, które wpływają na prędkość cząsteczek:
+
+`Acceleration`
+: Przyspieszenie w ogólnym kierunku.
+
+`Drag`
+: Opór - zmniejsza przyspieszenie cząsteczek proporcjonalnie do prędkości cząsteczki.
+
+`Radial`
+: Przyciąga lub odpycha cząsteczki w kierunku lub z dala od określonej pozycji dookoła.
+
+`Vortex`
+: Wir - wpływa na cząsteczki w kierunku okręgu lub spiralnie wokół swojej pozycji.
+
+  ![modyfikatory](images/particlefx/modifiers.png){srcset="images/particlefx/[email protected] 2x"}
+
+## Właściwości Modyfikatora
+
+Position/Rotation
+: Pozycja/Obrót - transformacja modyfikatora względem swojego rodzica.
+
+Magnitude
+: Wielkość wpływy modyfikatora na cząsteczki.
+
+Max Distance
+: Maksymalna odległość, w jakiej cząsteczki są w ogóle brane pod uwagę przez ten modyfikator. Dotyczy tylko modyfikatorów Radial i Vortex.
+
+## Kontrola efektu cząsteczkowego
+
+Aby uruchomić i zatrzymać efekt cząsteczkowy z poziomu skryptu:
+
+```lua
+-- uruchom komponent efektu "cząsteczki" w bieżącym obiekcie gry
+particlefx.play("#particles")
+
+-- zatrzymaj komponent efektu "cząsteczki" w bieżącym obiekcie gry
+particlefx.stop("#particles")
+```
+
+::: sidenote
+Efekt cząsteczkowy będzie nadal emitować cząsteczki nawet wtedy, gdy obiekt gry, do którego należy komponent efektu cząsteczkowego, zostanie usunięty.
+:::
+
+Zobacz szczegóły w [dokumentacji Efektów Cząsteczkowych]](/ref/particlefx).
+
+## Stałe materiału
+
+Domyślny materiał Efektu cząsteczkowego posiada następujące stałe, które można zmieniać za pomocą `particlefx.set_constant()` i resetować za pomocą `particlefx.reset_constant()` (zobacz szczegóły w [instrukcji do Materiałów](/manuals/material/#vertex-and-fragment-constants)):
+
+`tint`
+: Kolor odcienia efektu cząsteczkowego (`vector4`). Wektor 4-składnikowy jest używany do reprezentowania odcienia koloru, gdzie X, Y, Z i W odpowiadają czerwieni, zieleni, niebieskiemu i odcieniowi alfa. Więcej szczegółów w [dokumentacji API](/ref/particlefx/#particlefx.set_constant:url-constant-value).
+
+## Konfiguracja projektu
+
+Plik *game.project* zawiera kilka [ustawień projektu związanych z cząsteczkami](/manuals/project-settings#particle-fx).

docs/pl/manuals/sound.md

@@ -0,0 +1,225 @@
+---
+title: Dźwięk w Defoldzie
+brief: Ta instrukcja wyjaśnia jak można importować i obsługiwać dźwięki w Defoldzie.
+---
+
+# Dźwięk
+
+Komponent Dźwięku (Sound) w Defoldzie jest prosty, ale potężny. Istnieją tylko dwie koncepcje, o których musisz wiedzieć:
+
+Komponenty dźwięku
+: Te komponenty zawierają rzeczywisty dźwięk, który ma być odtwarzany i potrafią go odtwarzać.
+
+Grupy dźwięku
+: Każdy komponent dźwięku może być przypisany do grupy (Sound group). Grupy ułatwiają zarządzanie dźwiękami, które powinny być ze sobą powiązane w intuicyjny sposób. Na przykład grupa "sound_fx" może być utworzona, a każdy dźwięk należący do tej grupy może być wyciszany za pomocą jednego prostego wywołania funkcji.
+
+## Tworzenie komponentu dźwięku
+
+Komponenty dźwięku można tworzyć tylko w miejscu w obiekcie gry. Aby utworzyć nowy obiekt gry, kliknij go prawym przyciskiem myszy i wybierz <kbd>Add Component ▸ Sound</kbd> oraz kliknij "OK".
+
+![Wybierz komponent](images/sound/sound_add_component.jpg)
+
+Utworzony komponent ma zestaw właściwości (properties), które powinny zostać ustawione:
+
+![Wybierz komponent](images/sound/sound_properties.png)
+
+*Sound*
+: dźwięk - powinien być ustawiony na plik dźwiękowy w twoim projekcie. Plik powinien być w formacie _Wave_ lub _Ogg Vorbis_. Defold obsługuje pliki dźwiękowe zapisane z głębią bitową 16 bitów i częstotliwością próbkowania 44100.
+
+*Looping*
+: Jeśli jest zaznaczone, dźwięk będzie odtwarzany _Loopcount_ razy lub do momentu ręcznego zatrzymania.
+
+*Loopcount*
+: Liczba razy, jakie dźwięk odtworzy w przypadku pętli (0 oznacza, że dźwięk będzie odtwarzany w pętli, aż zostanie ręcznie zatrzymany).
+
+*Group*
+: nazwa grupy dźwięku, do której dźwięk powinien należeć. Jeśli to pole pozostanie puste, dźwięk zostanie przypisany do wbudowanej grupy "master".
+
+*Gain*
+: Wzmocnienie - możesz ustawić wzmocnienie dźwięku bezpośrednio na komponencie. Pozwala to na łatwe dostosowanie wzmocnienia dźwięku bez konieczności powrotu do programu dźwiękowego i ponownego eksportu. Zobacz poniżej, aby dowiedzieć się, jak jest obliczane wzmocnienie.
+
+*Pan*
+: Panorama - możesz ustawić wartość tzw. panoramy dźwięku bezpośrednio na komponencie. Panorama musi mieć wartość między -1 (lewo - 45 stopni) a 1 (prawo - 45 stopni). Dzięki panoramie mamy kontrolę nad tym, z której strony (lub też – z którego głośnika) dźwięk odtwarzany jest z większa głośnością.
+
+*Speed*
+: Prędkość - możesz ustawić wartość prędkości dźwięku bezpośrednio na komponencie. Wartość 1.0 to normalna prędkość, 0.5 to prędkość o połowę mniejsza, a 2.0 to prędkość podwójna.
+
+## Odtwarzanie dźwięku
+
+Gdy masz komponent dźwięku właściwie skonfigurowany, możesz spowodować odtworzenie dźwięku, wywołując [`sound.play()`](/ref/sound/#sound.play:url-[play_properties]-[complete_function]):
+
+```lua
+sound.play("go#sound", {delay = 1, gain = 0.5, pan = -1.0, speed = 1.25})
+```
+
+Można też wysłać wiadomość `"play_sound"` do komponentu dźwięku ([szczegóły w dokumentacji](https://defold.com/ref/sound/#play_sound)):
+
+```lua
+msg.post("#sound", "play_sound", {delay = 1, gain = 0.5})
+```
+
+::: sidenote
+Dźwięk będzie nadal odtwarzany nawet wtedy, gdy obiekt gry, do którego należy komponent dźwięku, zostanie usunięty. Możesz wywołać [`sound.stop()`](/ref/sound/#sound.stop:url), aby zatrzymać dźwięk (patrz poniżej).
+:::
+
+Każda wywołanie tej funkcji lub wiadomość wysłana do komponentu spowoduje odtworzenie kolejnego wystąpienia dźwięku, aż dostępny bufor dźwięku zostanie wypełniony, a silnik wyświetli błędy w konsoli. Zaleca się zaimplementowanie mechanizmu filtrowania i grupowania dźwięków.
+
+## Zatrzymywanie dźwięku
+
+If you wish to stop playing a sound you can call [`sound.stop()`](/ref/sound/#sound.stop:url):
+
+```lua
+sound.stop("go#sound")
+```
+
+Można też wysłać wiadomość "stop_sound":
+
+```lua
+msg.post("#sound", "stop_sound")
+```
+
+## Wzmocnienie
+
+![Wzmocnienie](images/sound/sound_gain.png)
+
+System dźwięku ma 4 poziomy wzmocnienia (gain):
+
+- Wzmocnienie ustawione na komponencie dźwięku.
+- Wzmocnienie ustawione podczas rozpoczęcia odtwarzania dźwięku poprzez wywołanie `sound.play()` lub zmianę wzmocnienia na głosie poprzez wywołanie `sound.set_gain()`.
+- Wzmocnienie ustawione w grupie za pomocą funkcji [`sound.set_group_gain()`](/ref/sound#sound.set_group_gain).
+- Wzmocnienie ustawione w grupie "master". Można je zmieniać za pomocą `sound.set_group_gain(hash("master"))`.
+
+Wzmocnienie wyjściowe jest wynikiem przemnóżenia tych 4 wzmocnień. Domyślne wzmocnienie wynosi wszędzie 1.0 (0 dB).
+
+## Grupy dźwiękowe
+
+Dowolny komponent dźwięku z określoną nazwą grupy dźwiękowej zostanie umieszczony w grupie dźwiękowej o tej nazwie. Jeśli nie określisz grupy, dźwięk zostanie przypisany do grupy wbudowanej "master". Możesz także jawnie ustawić grupę na komponencie dźwięku na "master", co ma ten sam efekt.
+
+Dostępne są pewne funkcje, które pozwalają na pobranie wszystkich dostępnych grup, pobranie nazwy (stringa), ustawienie i pobranie wzmocnienia, średnią kwadratową RMS (patrz [http://pl.wikipedia.org/wiki/Root_mean_square](http://pl.wikipedia.org/wiki/Root_mean_square)) i wzmocnienie szczytowe (ang. peak gain). Istnieje również funkcja, która pozwala sprawdzić, czy czasem aktualnie nie działa odtwarzacz muzyki na urządzeniu docelowym:
+
+```lua
+-- Jeśli dźwięk jest odtwarzany na tym urządzeniu iPhone/Android, wycisz wszystko
+if sound.is_music_playing() then
+    for i, group_hash in ipairs(sound.get_groups()) do
+        sound.set_group_gain(group_hash, 0)
+    end
+end
+```
+
+Grupy są identyfikowane za pomocą wartości hash. Nazwę (stringa) można pobrać za pomocą [`sound.get_group_name()`](/ref/sound#sound.get_group_name), co można wykorzystać do wyświetlania nazw grup w narzędziach deweloperskich, na przykład w mikserze do testowania poziomów grup.
+
+![Mikser grup](images/sound/sound_mixer.png)
+
+::: important
+Nie należy pisać kodu, który polega na wartości typu string grupy dźwiękowej, ponieważ nie są one dostępne w wersji końcowej, w release.
+:::
+
+Wszystkie wartości są liniowe w zakresie od 0 do 1.0 (0 dB). Aby przeliczyć na decybele, wystarczy użyć standardowej formuły:
+
+$$
+db = 20 \times \log \left( gain \right)
+$$
+
+```lua
+for i, group_hash in ipairs(sound.get_groups()) do
+    -- Nazwa w typie string jest dostępna tylko w trybie debug. Zwraca "unknown_*" w wersji końcowej.
+    local name = sound.get_group_name(group_hash)
+    local gain = sound.get_group_gain(group_hash)
+
+    -- Przelicz na decybele.
+    local db = 20 * math.log10(gain)
+
+    -- Pobierz średnią kwadratową RMS (Root Mean Square). Lewy i prawy kanał oddzielnie.
+    local left_rms, right_rms = sound.get_rms(group_hash, 2048 / 65536.0)
+    left_rmsdb = 20 * math.log10(left_rms)
+    right_rmsdb = 20 * math.log10(right_rms)
+
+    -- Pobierz wzmocnienie szczytowe. Lewy i prawy kanał oddzielnie.
+    left_peak, right_peak = sound.get_peak(group_hash, 2048 * 10 / 65536.0)
+    left_peakdb = 20 * math.log10(left_peak)
+    right_peakdb = 20 * math.log10(right_peak)
+end
+
+-- Ustaw wzmocnienie grupy "master" na +6 dB (math.pow(10, 6/20)).
+sound.set_group_gain("master", 1.995)
+```
+
+## Filtrowanie dźwięków
+
+Jeśli Twoja gra odtwarza ten sam dźwięk w przypadku zdarzenia, a to zdarzenie jest często wyzwalane, istnieje ryzyko odtwarzania tego samego dźwięku dwa lub więcej razy niemal jednocześnie. W takim przypadku dźwięki zostaną przesunięte fazowo, co może prowadzić do wyraźnych artefaktów.
+
+![Phase shift](images/sound/sound_phase_shift.png)
+
+Najprostszym sposobem radzenia sobie z tym problemem jest stworzenie bramy (gate), która filtrowałaby wiadomości dźwiękowe i nie pozwalałaby na odtworzenie tego samego dźwięku więcej niż raz w określonym odstępie czasu:
+
+```lua
+-- Nie pozwól na odtworzenie tego samego dźwięku w określonym odstępie czasu "gate_time".
+local gate_time = 0.3
+
+function init(self)
+    -- Przechowuj timery odtwarzanych dźwięków w tabeli i odliczaj każdy klatkowy,
+    -- aż będą w tabeli przez "gate_time" sekundy. Następnie usuń je.
+    self.sounds = {}
+end
+
+function update(self, dt)
+    -- Odliczaj zapisane timery
+    for k,_ in pairs(self.sounds) do
+        self.sounds[k] = self.sounds[k] - dt
+        if self.sounds[k] < 0 then
+            self.sounds[k] = nil
+        end
+    end
+end
+
+function on_message(self, message_id, message, sender)
+    if message_id == hash("play_gated_sound") then
+        -- Odtwarzaj tylko dźwięki, które nie znajdują się obecnie w tabeli filtrującej.
+        if self.sounds[message.soundcomponent] == nil then
+            -- Zapisz timer dźwięku w tabeli
+            self.sounds[message.soundcomponent] = gate_time
+            -- Odtwórz dźwięk
+            sound.play(message.soundcomponent, { gain = message.gain })
+        else
+            -- Próba odtworzenia dźwięku była filtrowana
+            print("gated " .. message.soundcomponent)
+        end
+    end
+end
+```
+
+Aby skorzystać teraz z takiej bramy, po prostu wyślij jej wiadomość `play_gated_sound` i określ docelowy komponent dźwięku oraz wzmocnienie dźwięku. Brama wywoła `sound.play()` z docelowym komponentem dźwięku, jeśli jest otwarta:
+
+```lua
+msg.post("/sound_gate#script", "play_gated_sound", { soundcomponent = "/sounds#explosion1", gain = 1.0 })
+```
+
+::: important
+Nie zadziała to, gdy brama nasłuchiwać będzie wiadomości `play_sound`, ponieważ ta nazwa jest zarezerwowana przez silnik Defold. Mamy do czynienia z nieoczekiwanym zachowaniem, jeśli użyjesz zarezerwowanych nazw wiadomości.
+:::
+
+## Manipulacja w czasie rzeczywistym
+
+Możesz manipulować dźwiękami w czasie rzeczywistym za pomocą różnych właściwości (szczegóły w [dokumentacji API](/ref/sound/)). Następujące właściwości można manipulować przy użyciu `go.get()` i `go.set()`:
+
+`gain`
+: Wzmocnienie (głośność) komponentu dźwięku (`number`).
+
+`pan`
+: Panorama komponentu dźwięku (`number`). Panorama musi mieć wartość między -1 (lewo - 45 stopni) a 1 (prawo - 45 stopni). Dzięki panoramie mamy kontrolę nad tym, z której strony (lub też – z którego głośnika) dźwięk odtwarzany jest z większa głośnością.
+
+`speed`
+: Prędkość komponentu dźwięku (`number`). Wartość 1.0 to normalna prędkość, 0.5 to prędkość o połowę mniejsza, a 2.0 to prędkość podwójna.
+
+`sound`
+: Ścieżka do zasobu dźwięku (`hash)`. Możesz użyć ścieżki zasobu do zmiany dźwięku za pomocą `resource.set_sound(path, buffer)`. Przykład:
+
+```lua
+local boom = sys.load_resource("/sounds/boom.wav")
+local path = go.get("#sound", "sound")
+resource.set_sound(path, boom)
+```
+
+## Konfiguracja projektu
+
+Plik *game.project* zawiera kilka [ustawień projektu związanych z komponentami dźwięku](/manuals/project-settings#sound).

docs/pl/manuals/spine.md

@@ -0,0 +1,6 @@
+---
+title: Animacje szkieletowe Spine
+brief: This manual explains how to bring Spine animations from _Spine_ into Defold.
+---
+
+[Ta instrukcja została przeniesiona tutaj.](/extension-spine)

docs/pl/manuals/sprite.md

@@ -9,16 +9,16 @@ Komponent typu Sprite (z ang. dosłownie: chochlik/duszek/krasnoludek - popularn
 
 ![sprite](images/graphics/sprite.png){srcset="images/graphics/[email protected] 2x"}
 
-Komponent typu Sprite może wykorzystywać jako teksturę [Galerię - Atlas](/manuals/atlas) lub [Źródło kafelków - Tile Source](/manuals/tilesource).
+Komponent typu Sprite może wykorzystywać jako teksturę galerię obrazów, tzw. [Atlas](/manuals/atlas) lub [Źródło kafelków - Tile Source](/manuals/tilesource).
 
 ## Właściwości Sprite'ów
 
-Poza właściwościami takimi jak *Id*, *Position* i *Rotation* komponenty te posiadają swoje specyficzne właściwości:
+Poza właściwościami takimi jak *Id*, *Position* i *Rotation* komponenty te posiadają swoje specyficzne właściwości (properties):
 
 *Image*
 : Obraz/tekstura dwuwymiarowa - może nią być Galeria - `Atlas` lub Źródło kafelków - `Tile Source`.
 
-*DefaultAnimation*
+*Default Animation*
 : Domyślna animacja używana przy wyświetlaniu obrazu.
 
 *Material*
@@ -27,6 +27,14 @@ Poza właściwościami takimi jak *Id*, *Position* i *Rotation* komponenty te po
 *Blend Mode*
 : Tryb "mieszania"/blendowania używany również przy renderowaniu. Więcej szczegółów poniżej.
 
+*Size Mode*
+: Tryb rozmiaru - jeśli ustawiony na `Automatic`, to Edytor będzie ustawiał rozmiar sprite'a. Jeśli ustawiony na `Manual`, to możesz dopasować rozmiar sprite'a.
+
+*Slice 9*
+: Przekrój na 9 części - ustaw tę właściwość aby zachować prawidłowość pikseli na rogach sprite'a, kiedy jego rozmiar jest zmieniany.
+
+:[Więcej o funkcjonalności Slice-9 tutaj.](../shared/slice-9-texturing.md)
+
 ### Blend modes - tryby blendowania
 :[blend-modes](../shared/blend-modes.md)
 
@@ -64,6 +72,18 @@ Sprite posiada również różne właściwości, którymi można manipulować pr
 `tint`
 : Kolor zabarwienia/odcienia obrazka (`vector4`). Wektor czterech komponentów reprezentuje zabarwienie, gdzie komponenty x, y, z, w odpowiadają składowym: czerwony, zielony, niebieski i przezroczystość (red, green, blue, alpha).
 
+## Atrybuty materiału
+
+Sprite może nadpisywać atrybuty wierzchołków (vertex attributes) aktualnie przypisanego materiały i przekazywać je do shadera wierzchołków (vertex shader) z komponentu (szczegóły znajdziesz w [instrukcji do materiałów](/manuals/material/#attributes)).
+
+Atrybuty określone w materiale pokażą się jako zwykłe właściwości w widoku inspekcyjnym i mogą być ustawione na indywidualne komponenty sprite. Jeśli jakikolwiek atrybut jest nadpisany, zostanie on zaznaczony jako nadpisana właściwość i przechowana w pliku komponenty sprite na dysku.
+
+![sprite-attributes](../images/graphics/sprite-attributes.png)
+
+::: sidenote
+Niestandardowe atrybuty są dostępne od wersji Defold 1.4.8!
+:::
+
 ## Konfiguracja projektu
 
 Plik *game.project* zawiera [te ustawienia](/manuals/project-settings#sprite) dotyczące sprite'ów.