View source for Rotation/pl

{{Multi-lang}}
{{LSL Header/pl}}{{RightToc}}
=Obroty=
LSL'owy typ '''rotation''' jest używany do przedstawienia trójwymiarowej orientacji.
Orientacja jest reprezentowana przez pojęcie matematyczne nazywane {{LSLG|quaternion|kwaternionem}}.  Można myśleć o kwaternionie jako o czterech liczbach, z których pierwsze trzy reprezentują kierunek w którym obiekt jest skierowany (rozumiany jako wektor 3D), a czwarta z nich to nachylenie (kąt obrotu) w lewo lub w prawo w płaszczyźnie normalnej (prostopadłej) do kierunku skierowania. 
Podstawową zaletą kwaternionów jest to, ze nie powodują one błędów typu [http://en.wikipedia.org/wiki/Gimbal_Lock gimbal lock] (związanych z równoległością prostych w przestrzeni trójwymiarowej). 
Jeżeli chcesz zapoznać się ze szczegółami matematycznymi, zobacz {{LSLG|quaternion|kwaternion}}.
{{LSLG|Rotation Synopsis}} to lista użytecznych funkcji i zdarzeń (events) odnoszących się do obrotów.
Jest też informacja o obracaniu tekstur, {{LSLG|texture|tutaj}}

==Inne reprezentacje==
Innym sposobem przedstawienia obrotów jest użycie trzech liczb, <X, Y, Z>, które reprezentują kąty (wyrażone w [[radians|radianach]]) o które obiekt jest obracany dookoła każdej z osi. Ten rodzaj przedstawienia używany jest w okienku Edycji, i jest generalnie łatwy w wizualizacji. Uwaga, te trzy liczby to typ '''vector''' a nie '''rotation''', choć reprezentują tę samą informację. Ten sposób przedstawienia rotacji nazywamy ''Eulerowskim''.
  
Trzecim rodzajem reprezentacji jest użycie trzech wektorów, wskazujących gdzie jest skierowany przód, góra i lewa strona obiektu. W rzeczywistości potrzebne są tylko dwa z trzech wektorów, ponieważ z dowolnych dwóch da się trzeci wyliczyć.

Z pewnych powodów, takich jak np. możliwość składania obrotów, cztero-liczbowa wersja, '''rotation''', jest lepsza, chociaż na początku może być trudniejsza to wyobrażenia sobie. Na szczęście bardzo rzadko występuje konieczność posługiwania się wewnętrzną reprezentacją ''obrotów'', ponieważ są funkcje konwertujące różne sposoby reprezentacji.

==Reguła prawej dłoni==
W LSL'u wszystkie obroty są wykonywane zgodnie z regułą '''prawej dłoni'''. Ustawiamy dłoń z palcami wyprostowanymi wzdłuż osi OX. Następnie zginamy palce, z wyjątkiem kciuka, wskazując zwrot osi OY. Odwiedziny kciuk wskazuje zwrot osi OZ w układzie prawoskrętnym. Podczas edycji obiektu trzy kolorowe strzałki wskazują dodatni kierunek każdej osi (X: czerwona, Y: zielona, Z: niebieska).

[http://pl.wikipedia.org/wiki/Regu%C5%82a_prawej_d%C5%82oni#Matematyka Reguła Prawej Dłoni] 

Prawa ręka jeszcze się przyda, do ustalenia kierunku dodatniego obrotu.  Palce pięści prawej dłoni, z kciukiem ustawionym w osi obrotu który nas interesuje, wskazują kierunek dodatnigo obrotu wokół tej osi. Obroty wzdłuż osi X, Y i Z są często określane jako "beczka", "nurkowanie" i "zboczenie" (Roll, Pitch, and Yaw), sczególnie dotyczy to pojazdów.

[http://pl.wikipedia.org/wiki/Regu%C5%82a_prawej_d%C5%82oni#Zwrot_zwi.C4.85zany_z_rotacj.C4.85 Kierunek obrotów wg Reguły Prawej Dłoni]

== Składanie obrotów ==

Do składania '''obrotów''' używa się operatorów '''mnożenia''' i '''dzielenia'''. Nie należy używać dodawania i odejmowania dla '''obrotów''', ponieważ nie dają one spodziewanych rezultatów. '''Mnożenie''' obraca w kierunku dodatnim, podczas gdy '''dzielenie''' w kierunku ujemnym. Można też odwrócić obrót bezpośrednio, poprzez pomnożenie składowej S przez -1. Np. X.s = -X.s.

W przeciwieństwie do innych typów, np. {{LSLG|float}}, kolejność wykonywania obrotów ma znaczenie.([http://en.wikipedia.org/wiki/Commutative non-commutative]). Spowodowane jest to prostym zjawiskiem - W RL'u kolejność w jakiej wykonuje się obroty również ma znaczenie. Jeżeli weźmiemy rzutkę (strzałkę) z czterema piórami, z początkowym obrotem <0, 0, 0>, której tylna część jest punktem zero, będzie ona leżała wzdłuż osi X, skierowana szpicem w kierunku dodatnim, z piórami wzdłuż osi Z i Y. Osie rzutki i osie świata są równoległe. Obrócimy teraz naszą rzutkę o 45 stopni dookoła osi X i 30 stopnia dookoła osi Y dwa razy, zmieniając kolejność.

Przypadek I:
Po obróceniu o 45 stopni dookoła osi X, rzutka dalej leży na tej osi, tylko z piórami pod kątem 45 stopni do osi Z i Y. Obrócenie rzutki o 30 stopni dookoła osi Y przesunie ją w płaszczyźnie XZ, tak by czubek był odchylony o 30 stopni od osi X w dół (wg reguły prawej dłoni, małe wartości obrotu wokół osi Y opuszczają czubek w dół). Rzutka jest teraz skierowana pod kątem 30 stopni w dół, w tej samej płaszczyźnie pionowej, obrócona wokół swojej długiej osi, tak że pióra nie są  już skierowane pionowo i poziomo. 

Przypadek II:

Jeżeli wykonamy te same obroty w odwrotnej kolejności, czyli najpierw o 30 stopni wokół Y, rzutka obróci się w dół w płaszczyźnie XZ i nie będzie już leżała na osi X. Układy współrzędnych rzutki i świata nie są już równoległe. Teraz obrót o 45 stopni dookoła osi X spowoduje że tył strzałki pozostanie w miejscu, a czubek będzie nachylony w górę i w prawo pod kątem 30 i 45 stopni względem odpowiednich osi. Pióra rzutki nie są obrócone względem osi długiej rzutki.

W oczywisty sposób efekty końcowe różnią się, chociaż jedyną różnicą jest kolejność przekształceń.

Stałą typu '''rotation''' można utworzyć przez stworzenie {{LSLG|vector|wektora}} z wartościami X, Y, Z składowych obrotu wyrażonych w radianach (tzw. kąt Euler'a) a następnie zmieniając go w typ '''rotation''' używając funkcji {{LSLG|llEuler2Rot}}. Można też stworzyć wartość typu '''rotation''' bezpośrednio: Część rzeczywista to cosinus połowy kąta obrotu, część wektorowa jest znormalizowaną osią obrotu pomnożoną przez sinus połowy kąta obrotu. Do przekształcenia typu '''rotation''' na kąt Eulera typu {{LSLG|vector}} służy funkcja {{LSLG|llRot2Euler}}.

'''UWAGA:''' Kąty w LSL'u są wyrażane w radianach a nie w stopniach, ale można użyć predefiniowanych stałych [[#RAD_TO_DEG|RAD_TO_DEG]] i [[#DEG_TO_RAD|DEG_TO_RAD]]. Żeby uzyskać trzydziestopniową wartość typu '''rotation''' dookoła osi X axis można użyć następującej konstrukcji:

<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
|-
|rotation rot30X ||= {{LSLG|llEuler2Rot}}(<30, 0, 0> * DEG_TO_RAD);||// zminia stopnie na radiany a potem {{LSLG|vector|wektor}} w obrót: rot30x
|-
|{{LSLG|vector}} vec30X ||= {{LSLG|llRot2Euler}}(rot30X );||// zmienia obrót z powrotem w {{LSLG|vector|wektor}} (wartości kątów będą w radianach)
|}
</div></div>

== Kolejność obrotów dla wektorów Eulera ==

Z powyższych rozważań wynika jasno, żę kiedy obracamy obiekty wokół więcej niż jednej osi, kolejność tych obrotów ma zasadnicze znaczenie. Ten temat został ominięty przy traktowaniu wektora Eulerowskiego jako ''całkowitego obrotu'', ale nasuwa się pytanie: W jakiej kolejności wykonywane są obroty wokół poszczególnych osi? Odpowiedzią jest: '''Z, Y, X''' wg współrzędnych świata. Jeżeli obracasz obiekt wokół więcej niż jednej osi na raz, używając reprezentacji ''Eulerowkiej'', musisz ustalić {{LSLG|vector|wektor}} ''Eulera'' używając porządku obrotów Z, Y, X, a następnie funkcji {{LSLG|llEuler2Rot}}, żeby uzyskać typ '''rotation''', niezbędny do składania obrotów, lub zastosowania obrotu na obiekcie.

== Obroty lokalne i globalne (wg współrzędnych świata) ==

Ważne jest, aby rozróżniać obroty w układzie współrzędnych świata (globalnych) od tych w układzie współrzędnych obiektu (lokalnych). W edytorze można przełączać z jednego ukłądu na drugi i odwrotnie. W skrypcie trzeba dokonywać przekształceń celem uzyskania pożądanych efektów. 

'''Lokalne''' obroty są dokonywane wokół osi przypisanych do obiektu: przód/tył, lewo/prawo i góra/dół, bez uwzględniania jak obiekt jest obrócony względem współrzędnych globalnych. '''Globalne''' obroty są dokonywane wokół osi świata: Północ/Południe, Wschód/Zachód, Wyżej/Niżej. Różnicę najłatwiej obserwować obracając prim'a, a następnie edytując go i zmieniając układ współrzędnych pomiędzy lokalnym i globalnym. Należy zwrócić uwagę jak zmieniają kolorowe strzałki wskaźnika.

W LSL'u rodzaj obrotu (lokalny czy globalny) jest określony przez kolejność w jakiej obroty są ustawione w wyrażeniu.

Przykład poniżej pokazuje '''lokalny''' obrót o 30 stopni. Jest to spowodowane kolejnością - stał '''obrót''' o 30 stopni jest po lewej stronie operatora a '''obrót''' startowy obiektu (myRot) po prawej. Ten przykład ilustruje pierwsze przekształcenie przypadku  I powyżej. 

<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
|-
|rotation localRot = ||rot30X * myRot;||// wykonuje lokalny obrót przemnażając stały obrót przez obrót we współrzędnych świata
|}
</div></div>

Żeby wykonać obrót '''globalny''' należy użyć tych samych wartości, ale w odwrotnej kolejności. Jest to ilustracja drugiego przekształcenia z przypadku II powyżej

<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
|-
|rotation globalRot || = myRot * rot30X;||// wykonuje globalny obrót przemnażając obrót we współrzędnych świata przez stały obrót
|}
</div></div>

== Inny sposób spojrzenia na obroty ==

Może być łatwiej zrozumieć obroty '''lokalne''' i '''globalne''' zauważając, że operacje obrotu są wykonywane w kolejności przetwarzania - od lewej do prawej, z wyjątkiem wyrażeń w nawiasach.

W powyższym skrypcie ustawiającym zmienną localRot, zaczynając od <0, 0, 0>, najpierw wykonany został obrót rot30X, co spowodowało obrót prim'a wokół osi X '''świata''', ale osie obiektu i świat pokrywały się, więc efekt jest identyczny z obrotem wokół osi obiektu. Nasepnie został wykonany '''obrót''' myRot, który przekształca obiekt do pozycji początkowej, ale z "wbudowanym" dodatkowym obrotem wokół osi X i niezmienionym położeniem osi Y i Z. W wyniku powstaje obrót '''lokalny'''  

W skrypcie z globalRot, znów zaczynamy od <0,0,0>, ale najpierw obiekt obracany jest o myRot, co powoduje, że osie świata i obiektu nie są już tożsame. Tak więc następny '''obrót''', rot30X (który wykonuje dokładnie to samo co poprzednio), działa na obiekt wokół osi X '''świata''', czego efektem jest poza obróceniem również przemieszczenie obiektu. Efektem końcowym jest obrót '''globalny'''

'''Dzielenie''' '''obrotów''' daje efekt wykonania obrotów w przeciwną stronę. Pomnożenie przez '''obrót''' o 330 stopni jest równoznaczne z podzielniem przez '''obrót''' o 30 stopni.

== Używanie obrotów ==

Można uzyskać dostęp do poszczególnych składowych '''obrotu''' '''R''' używając konstrukcji '''R.x, R.y, R.z, & R.s''' ('''nie'''R.w). Część skalarna R.s jest cosinusem połowy kąta obrotu. Część wektorowa (R.x,R.y,R.z) jest iloczynem znormalizowanego wektora osi obrotu i sinusa połowy kąta obrotu. Można stworzyć '''obrót''' przeciwny albo poprzez zanegownie wszystkich trzech składowych x,y i z, albo przez zanegowanie składowej s. Można też używać typu '''rotation''' do przechowywania po prostu czterech wartości typu {{LSLG|float/pl|float}}. Ma to znaczenie w przypadku korzystania z {{LSLG|list/pl|list}}list. Lista zmiennych typu '''rotation'''  jest bardziej wydajna pamięciowo niż lista złożona ze zmiennych typu {{LSLG|float/pl|float}}, ale oczywiście kosztuje więcej cykli procesora przy "rozpakowywaniu".

<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
|-
|rotation rot30X ||= {{LSLG|llEuler2Rot}}(<30, 0, 0> * [[#DEG_TO_RAD|DEG_TO_RAD]] );||// Tworzy stałą typu rotation
|-
|rotation rotCopy ||= rot30X;||// Kopiuje ją do zmiennej rotCopy, kopiując wszystkie cztery składowe. 
|-
|float X ||= rotCopy.x;||// Wyciąga poszczególne składowe obrotu
|-
|float Y ||= rotCopy.y;||
|-
|float Z ||= rotCopy.z;||
|-
|float S ||= rotCopy.s;||
|-
|rotation anotherCopy ||= <X, Y, Z, S>;||// tworzy inny obrót z tych składowych
|}
</div></div>


Istnieje wbudowana stała '''obrót''' zerowy [[#ZERO_ROTATION|ZERO_ROTATION]], której można użyć bezpośrednio, lub jeżeli potrzbujesz odwrócić '''obrót R''', podziel [[#ZERO_ROTATION|ZERO_ROTATION]] przez '''R'''. Przypominając rozważania z poprzednich akapitów, mechanizm jest tu następujący: Najpierw wykonywany jest obrót zerowy, potem dzielenie (które daje obrót przeciwny) przez obrót '''R'''
<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
|-
|rotation rot330X ||= <-rot30X.x, -rot30X.y, -rot30X.z, rot30X.s>;||// obrót przeciwny - UWAGA składowa s nie została zanegowana
|-
|rotation another330X ||= [[#ZERO_ROTATION|ZERO_ROTATION]] / rot30X;||// obrót przeciwny wykonany dzieleniem, taki sam rezultat jak wyżej
|-
|rotation yetanother330X ||= <rot30X.x, rot30X.y, rot30X.z, -rot30X.s>;||// Nie dokładnie to samo, ale taki sam efekt.
|}
</div></div>

== Pojedyncze lub główne primy a primy dołączone a dostawki (attachments) ==

Niektóre rzeczy, jak na przykład drzwi pojazdów, powinny obracać się względem pojazdu, niezależnie od tego, jak ustawiony jest sam pojazd. Można to zrobić obrotami globalnymi, ale jest to męczące i nudne.
Z tego powodu istnieją trzy układy współrzędnych w których prim może być obracany: pojedynczy prim, dołączony do {{LSLG|linkset|zestawu}}, lub będący {{LSLG|attachment|dostawką }}. Prim będący głównym w {{LSLG|linkset|zestawie}} zachowuje się jak pojedyńczy. Prim będący {{LSLG|linkset|dostawką}} zachowuje się inaczej niż pozostałe i nie zawsze działa poprawnie


{{LSLRotGetSet}}

==Obracanie wektorów ==

Obracanie wektorów może być potrzebne w przypadku poruszania obiektu (używając LSL'a) po okręgu lub łuku, jeżeli oś obrotu nie jest osią tego obiektu.

Może to brzmieć skomplikowanie, ale tylko pozornie. Wystarczy [[#Składanie obrotów|rzutkę]] z przykładów wyżej zamienić na {{LSLG|vector|wektor}}, którego początkiem są pióra rzutki a współrzędne X,Y i Z to położenie jej szpica. Obracanie rzutki wokół końca przesuwa szpic w stożku, którego wierzchołkiem są pióra rzutki. W dokładnie ten sam sposób obracanie {{LSLG|vector|wektor'a}}, który reprezentuje przesunięcie względem środka obiektu (prim'a), obraca prim w takim samym stożku. Daje to taki efekt, że środek prim'a przesunięty o {{LSLG|vector|wektor}} staje się przecięciem osi obrotów.
	
<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
|-
|rotation rot6X ||= {{LSLG|llEuler2Rot}}(<30, 0, 0> * [[#DEG_TO_RAD|DEG_TO_RAD]] );||// Tworzy stałą typu obrót o wartości 30 stopni dookoła lokalnej osi X
|-
|vector offset ||= <0, 1, 0>;||// Tworzy przesunięcie o jeden metr w kierunku dodatnim globalnej osi Y
|-
|vector rotatedOffset || = offset * rot6X;||// Obraca przesunięcie, żeby uzyskać ruch spowodowany przez obroty
|-
|vector newPos || = {{LSLG|llGetPos}}() + (offset - rotatedOffset) * {{LSLG|llGetRot}}();||// przesuwa obiekt w położenie odpowiadające obróconemu przesunięciu
|-
|rotation newRot|| = rot6X * {{LSLG|llGetRot}}();||// zmienia rot, tak żeby dalej był zwrócony w stronę punktu przesunięcia
|}
</div></div>
<lsl>
//-- Te same efekty daje:
llSetPrimitiveParams( [PRIM_POSITION, llGetPos() + (gPosOffset - gPosOffset * gRotArc) * llGetRot(),
                       PRIM_ROTATION, gRotArc * llGetRot() );
</lsl>
'''Nota Bene:''' Wykonanie takiego skryptu daje w efekcie ruch, więc należy rozważyć takie konsekwencje jak wyrzucenie obiektu poza świat, pod ziemię, lub dalej niż 10 metrów itd.

Żeby uzyskać przesunięcie względem aktualnego przodu obiektu (np. w rezzor'ach) można użyć następującej konstrukcji
<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
|-
|rotation rotFacing ||= {{LSLG|llGetRot}}();||// pobiera obecny obrót obiektu
|-
|vector offset ||= <0, 0, 1>;||// tworzy przesunięcie o 1m w dodatnim kierunku globalnej osi Z
|-
|vector rotatedOffset || = offset * rotFacing;||// obraca przesunięcie tak, by było względem rotacji obiektu
|-
|vector correctOffset || = {{LSLG|llGetPos}}() + rotatedOffset;||// odczytuje globalne położenie lokalnego przesunięcia
|}
</div></div>
<lsl>
//-- to samo co:
vector correctOffset = llGetPos() + offset * llGetRot();
</lsl>

== Stałe ==
=== [[ZERO_ROTATION]] ===
ZERO_ROTATION = <0.0, 0.0, 0.0, 1.0>;<br/>
Stała typu rotation reprezentująca kąt Euler'a <0.0, 0.0, 0.0>.

=== [[DEG_TO_RAD]] ===
DEG_TO_RAD = 0.01745329238f;<br/>
Stała typu float, która pomnożona przez kat w stopniach da kąt w radianach.

=== [[RAD_TO_DEG]] ===
RAD_TO_DEG = 57.29578f;<br/>
Stała typu float, która pomnożona przez kat w radianach da kąt w stopniach.

[[Category:LSL_Types/pl|Rotation]][[Category:LSL_Math/pl]][[Category:LSL_Math/3D/pl]][[Category:LSL_Constants/pl]]