Rotation/pl

/pl

LSL Portal

|

Funkcje

|

Zdarzenia

|

Typy

|

Stałe

|

Potoki

|

Biblioteka Skryptów

|

Tutoriale

Obroty

LSL'owy typ rotation jest używany do przedstawienia trójwymiarowej orientacji. Orientacja jest reprezentowana przez pojęcie matematyczne nazywane 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 gimbal lock (związanych z równoległością prostych w przestrzeni trójwymiarowej). Jeżeli chcesz zapoznać się ze szczegółami matematycznymi, zobacz kawternion. Rotation Synopsis to lista użytecznych funkcji i zdarzeń (events) odnoszących się do obrotów. Jest też informacja o obracaniu tekstur, tutaj

Inne reprezentacje

Innym sposobem przedstawienia obrotów jest użycie trzech liczb, <X, Y, Z>, które reprezentują kąty (wyrażone w 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: czerwona).

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.

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. float, kolejność wykonywania obrotów ma znaczenie.(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 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 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 vector służy funkcja 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 i DEG_TO_RAD. Żeby uzyskać trzydziestopniową wartość typu rotation dookoła osi X axis można użyć następującej konstrukcji:

rotation rot30X	= llEuler2Rot(<30, 0, 0> * DEG_TO_RAD);	// zminia stopnie na radiany a potem wektor w obrót: rot30x
vector vec30X	= llRot2Euler(rot30X );	// zmienia obrót z powrotem w wektor (wartości kątów będą w radianach)

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ć wektor Eulera używając porządku obrotów Z, Y, X, a następnie funkcji 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.

rotation localRot =

rot30X * myRot;

// wykonuje lokalny obrót przemnażając stały obrót przez obrót we współrzędnych świata

Ż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

rotation globalRot

= myRot * rot30X;

// wykonuje globalny obrót przemnażając obrót we współrzędnych świata przez stały obrót

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 (nieR.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 float. Ma to znaczenie w przypadku korzystania z listlist. Lista zmiennych typu rotation jest bardziej wydajna pamięciowo niż lista złożona ze zmiennych typu float, ale oczywiście kosztuje więcej cykli procesora przy "rozpakowywaniu".

rotation rot30X	= llEuler2Rot(<30, 0, 0> * 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

There is a built in constant for a zero rotation ZERO_ROTATION which you can use directly or, if you need to invert a rotation R, divide ZERO_ROTATION by R. As a reminder from above, this works by first rotating to the zero position, then because it is a divide, rotating in the opposite sense to the original rotation, thereby doing the inverse rotation.

rotation rot330X	= <-rot30X.x, -rot30X.y, -rot30X.z, rot30X.s>;	// invert a rotation - NOTE the s component isn't negated
rotation another330X	= ZERO_ROTATION / rot30X;	// invert a rotation by division, same result as rot330X
rotation yetanother330X	= <rot30X.x, rot30X.y, rot30X.z, -rot30X.s>;	// not literally the same but works the same.

Single or Root Prims vs Linked Prims vs Attachments

The reason for talking about single or linked prim rotations is that for things like doors on vehicles, the desired motion is to move the door relative to the vehicle, no matter what the rotation of the overall vehicle is. While possible to do this with global rotations, it would quickly grow tedious. There are generally three coordinate systems a prim can be in: all alone, part of a linkset, or part of an attachment. When a prim is alone, i.e., not part of a linkset, it acts like a root prim; when it is part of an attachment, it acts differently and is a bit broken.

Getting and setting rotations of prims

Function	Ground (rez'ed) Prims		Attached Prims
	Root	Children	Root	Children
llGetRot llGPP:PRIM_ROTATION llGetObjectDetails	global rotation of prim	global rotation of prim	global rotation of avatar	global rotation of avatar * global rotation of prim (Not Useful)
llGetLocalRot llGPP:PRIM_ROT_LOCAL	global rotation of prim	rotation of prim relative to root prim	rotation of attachment relative to attach point	rotation of prim relative to root prim
llGetRootRotation	global rotation of prim	global rotation of root prim	global rotation of avatar	global rotation of avatar
llSetRot* llSPP:PRIM_ROTATION*	set global rotation	complicated, see llSetRot	set rotation relative to attach point	set rotation to root attachment rotation * new_rot.
llSetLocalRot* llSPP:PRIM_ROT_LOCAL*	set global rotation	set rotation of prim relative to root prim	set rotation relative to attach point	set rotation of prim relative to root prim
llTargetOmega† ll[GS]PP:PRIM_OMEGA	spin linkset around prim's location	spin prim around its location	spin linkset around attach point	spin prim around its location

*	Physical objects which are not children in a linkset will not respond to setting rotations.
†	For non-Physical objects llTargetOmega is executed on the client side, providing a simple low lag method to do smooth continuous rotation.

Rotating Vectors

In LSL, rotating a vector is very useful if you want to move an object in an arc or circle when the center of rotation isn't the center of the object.

This sounds very complex, but there is much less here than meets the eye. Remember from the above discussion of rotating the dart, and replace the physical dart with a vector whose origin is the tail of the dart, and whose components in X, Y, and Z describe the position of the tip of the dart. Rotating the dart around its tail moves the tip of the dart through and arc whose center of rotation is the tail of the dart. In exactly the same way, rotating a vector which represents an offset from the center of a prim rotates the prim through the same arc. What this looks like is the object rotates around a position offset by the vector from the center of the prim.

rotation rot6X	= llEuler2Rot(<30, 0, 0> * DEG_TO_RAD );	// create a rotation constant, 30 degrees around the local X axis
vector offset	= <0, 1, 0>;	// create an offset one meter in the global positive Y direction
vector rotatedOffset	= offset * rot6X;	// rotate the offset to get the motion caused by the rotations
vector newPos	= llGetPos() + (offset - rotatedOffset) * llGetRot();	// move the prim position by the rotated offset amount
rotation newRot	= rot6X * llGetRot();	// change rot to continue facing offset point

<lsl> //-- same as: llSetPrimitiveParams( [PRIM_POSITION, llGetPos() + (gPosOffset - gPosOffset * gRotArc) * llGetRot(),

                      PRIM_ROTATION, gRotArc * llGetRot() );

</lsl> Nota Bene: Doing this is a move, so don't forget about issues of moving a prim off world, below ground, more than 10 meters etc.

To get a point relative to the objects current facing (such as used in rezzors)

rotation rotFacing	= llGetRot();	// get the objects current rotation
vector offset	= <0, 0, 1>;	// create an offset one meter in the global positive Z direction
vector rotatedOffset	= offset * rotFacing;	// rotate the offset to be relative to object rotation
vector correctOffset	= llGetPos() + rotatedOffset;	// get the global position of the local offset

<lsl> //-- same as: vector correctOffset = llGetPos() + offset * llGetRot(); </lsl>

Constants

ZERO_ROTATION

ZERO_ROTATION = <0.0, 0.0, 0.0, 1.0>;
A rotation constant representing a Euler angle of <0.0, 0.0, 0.0>.

DEG_TO_RAD

DEG_TO_RAD = 0.01745329238f;
A float constant that when multiplied by an angle in degrees gives the angle in radians.

RAD_TO_DEG

RAD_TO_DEG = 57.29578f;
A float constant when multiplied by an angle in radians gives the angle in degrees.