View source for Rotation/ru

{{Multi-lang}}
{{LSL Header/ru}}{{LSLC|||{{#var:lang}}}}{{LSLC|Types||{{#var:lang}}}}

См. также [[:Category:LSL_Text|Text]].
== Вращение(Rotation). ==

{{{!}} style="font-size:110%;padding:0;
Тип '''вращение''' (
{{!}} style="font-size:120%; background: #ffffff; color: green; vertical-align: top; text-align: center; "{{!}}'''rotation'''|{{!}} ) в LSL является одним из нескольких способов представления ориентации в 3D-проостранстве - трехмерном пространстве. (Обратите внимание, что мы пытаемся написать имя типа в '''жирном'''.)
{{!}}}

'''Вращение''' (<code> rotation</code>)  можно рассматривать как дискретный поворот в трехмерном пространстве, и как ориентацию объекта так, насколько много он обернулся вокруг любых осей, которые мы используем - обычно осей региона.

Математический объект вызывает {{LSLG|quaternion}} ({{LSLG|кватернион}}). Вы можете представлять кватернион в виде четырех чисел, три из которых представляют направление объекта, а четвертое - крен объекта влево или вправо вокруг этого направления.Основным преимуществом использования кватернионов является то, что они не восприимчивы к [http://en.wikipedia.org/wiki/Gimbal_Lock блокировке вращения].
Для комплексной внутренней работы с кватернионной математикой - см. {{LSLG|quaternion|кватернион}}.
Список функций и событий, связанных с вращениями, см. {{LSLG|LSL Rotation Synopsis|краткий обзор LSL-вращения (rotation)}}.
Существует также информация о вызывании текстурных вращений в {{LSLG|texture|текстуры}}.



{|
|
Пример:
<lsl>rotation R = <1.23, 0.0, 4.56, 1.0>
</lsl>
|}

{{#vardefine:p_name_desc|variable name
}}{{#vardefine:p_value_desc|string expression or constant
}}{{#vardefine:p_value_t_desc|expression or constant
}}
<div id="box">

== Другие представления ==
=== Эйлера вектор ===
Другой способ представления Угол 3D использует три номера, <X, y, Z>, которые представляют собой сумму, объект поворачивается вокруг каждой оси. Это используется в окне редактирования, например, и, как правило, легко для людей, для визуализации. Легко регулировки вращения <x, y, z> номера в окне редактирования и посмотреть, как ведет себя объект. Обратите внимание, что в окне редактирования, цифры даны в градусах, то есть под прямым углом 90.

В LSL, эти три угла выражены в [[радиан]] вместо градусов, то есть под прямым углом является PI / 2. (Радиан является своего рода очень толстый степени.)
Заметим, что эти три числа типа "вектор'' ''', а не типа" вращение''''', хотя это может представлять ту же информацию. Это называется'''' Эйлера представление 3D углом. '' 'В LSL вращение вокруг Z делается, а затем вокруг у, и, наконец, вокруг X'''.

=== Оси плюс угол ===
При этом способе можно определить оси вращения, как определяющий ось, вокруг которой землей спины, и использовать его вместе с углом поворота вокруг оси, которая определяет величину поворота, чтобы дать'' 'вращение''' .

Так что если вы хотите, чтобы определить "вращение'' ''' вокруг оси на 45 градусов в плоскости XY (North East в регионе координаты), вам нужно указать оси с тем же количеством х и у, но без каких-либо Z. Ось может быть <1.0, 1.0, 0.0>. Абсолютная величина числа, определяющие оси не имеют значения в этом представлении; <2.0, 2.0, 0.0> будет работать так же хорошо. Угол поворота отдельный номер задается в радианах, например. PI / 3 = 60 градусов. Вместе они определяют "вращение'' ''' глобальном 60 градусов по оси северо-востоке.

Как Ось кватернионная плюс угол использует четыре цифры, но она не должна быть "нормальный".

=== FWD, влево, вверх ===
Еще один способ для представления тех же 3D угол использовать три вектора, показывая, что фронт указывая на FWD (передний), что топ указывает на (вверх), и то, что с левой стороны указывает на (слева). На самом деле, только два из трех необходимы, потому что любые две определяет третий.

По понятным причинам, такие как возможность легко комбинировать вращения, четыре версии, "вращение'' ''' кватернионов, лучше, хотя, возможно, сложнее для новичка, чтобы схватить. К счастью, это очень редко нужно делать ничего с фактическим внутренним представлением'''' повороты и есть функции для преобразования легко переключаться между тремя типами LSL, а также между градусами и радианах.

== Правилу правой руки ==
В LSL все вращения выполняется в соответствии с'' 'правилу правой руки'''. С правой стороны, расширить первого пальца в направлении положительного направления оси х. Расширение второй палец под прямым углом к вашим первым пальцем, он будет указывать вдоль положительной оси, а большой палец, продлен по прямым углом как укажет вдоль положительной оси. При редактировании объекта, три цветных оси стрелки направлены в положительном направлении для каждой оси (X: красный, Y: зеленый, Z: синий).

http://en.wikipedia.org/wiki/Right_hand_rule

Теперь, не снимают правой рукой только все же, есть еще одно применение для него, определяющий направление положительного вращения. Сделать кулак правой рукой, большой палец простирался и указывая в положительном направлении оси вы заинтересованы Ваши пальцы локон вокруг в направлении положительного вращения. Вращений вокруг X, Y, Z и оси часто называют крен, тангаж, рыскание и, в частности, для транспортных средств.

[Http://en.wikipedia.org/wiki/Tait-Bryan_angles ролл Шаг рыскания]

== Объединение поворотов== 
'
Предположим, у вас есть два оборота. ''r1'' является поворот на 90 градусов влево, и ''r2'' Как вращаться на 30 градусов вправо. (Любые повороты будет работать, это всего лишь пример.)
Вы можете комбинировать ''r1'' и ''r2'', чтобы сделать использование ''r3'' '''*''' оператора. Это действительно не умножать их, он ''сочиняет'' им.

<lsl>
rotation R3 = R1 * R2;
</lsl>

Результат в этом случае является то, что'''' R3 средства вращаются на 60 градусов влево.

Другими словами, совместить'' 'вращения''', можно использовать "многократно'' 'и''''' разрыва'' 'операторов. Не пытайтесь использовать сложение или вычитание операторов на'' 'повороты''', поскольку они не будут делать то, что вы ожидаете. Операция "умножения'' ''' применяет вращение в положительном направлении, эксплуатация« разделяй''''' означает отрицательный вращения. Вы также можете отрицать вращение непосредственно, просто свести на нет с компонентом, например, X.s = -X.s.

В отличие от других типов, таких как {{LSLG | поплавок}}, порядок, в котором операции выполняются,
[Http://en.wikipedia.org/wiki/Commutative некоммутативную], имеет важное значение.
Причина этого проста: вы делаете заказ вращений в важно в RL. Например, если у Вас был дротик с четырьмя перьями, начал с вращением <0, 0, 0> с его хвостом о происхождении, он будет лежать на оси X с его точки направленные в положительном направлении X, его перья вдоль Z и Y оси и оси дротик и осей мир будет приведен в соответствие. Мы собираемся, чтобы повернуть его на 45 градусов вокруг X и 30 градусов вокруг Y, но в разной последовательности.

Во-первых, после поворота 45 ° вокруг X дротик все равно будет по оси Х, неподвижная, просто повернулся вдоль его продольной оси, так что перьев будет на 45 градусов к оси. Тогда вращающийся 30 ° вокруг Y бы переместить его в плоскости XZ, чтобы указать на 30 градусов от оси X (вспомним правила правой руки для вращения означает небольшое положительное вращение вокруг Y перемещает точку вниз). Дарт ветров, направленная вверх 30 ° вниз, в одной вертикальной плоскости, это уже второй, но повернулся вокруг своей длинной оси так перья уже не вверх и вниз.

Если вы сделали это в другую сторону, первая поворотная 30 град в Y, дротик будет вращаться вниз в плоскости XZ, но заметил, что она больше не находится на оси X, оси X и в мире не выровнены больше. Сейчас 45 градусов вращение вокруг оси X будет поворачивать вокруг своей дротик хвост, момент после 30 град конуса, ось которого вдоль положительной оси X мира, на 45 градусов вверх и вправо. Если вы искали вниз по оси X, было бы указывая поворота от 30 градусов ниже оси X, вверх и вправо, из плоскости XZ, до точки ниже первого квадранта в плоскости XY, перья, как это вращающийся пошли.

Ясно, что это другой результат с первого вращения, но порядок ротации это единственное, что изменилось.

Чтобы сделать постоянной ротации необходимо определить'' 'вращения''' значение, которое может быть сделано путем создания LSLG {{|}} вектор с X, Y, Z углов в радианах в качестве компонентов (так называемый угол Эйлера) , то, что для преобразования'' 'вращения''' с помощью {{LSLG | llEuler2Rot}} функции. Чтобы перейти от вращения угол Эйлера {{LSLG | вектора}} {{использование LSLG | llRot2Euler}}.

Если вы хотите осевого вращения вставке оси вращения и угол поворота в {{LSLG | llAxisAngle2Rot}} функция, и это вернется "вращение'' '''. Чтобы перейти от вращения Вернуться к оси и угла, используйте {{LSLG | llRot2Axis}} и {{LSLG | llRot2Angle}} соответственно.

Можно попеременно создавать родной вращение непосредственно: реальная часть косинус половины угла поворота, а вектор часть нормированной оси вращения, умноженного на синус половины угла вращения.

'Примечание:''''' углов в LSL даны в радианах, а не в градусах, но вы можете легко конвертировать с помощью встроенных констант [[# RAD_TO_DEG | RAD_TO_DEG]] и [[# DEG_TO_RAD | DEG_TO_RAD]]. Для "вращение'' '30'' градусов вокруг оси X можно использовать:

<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
|- valign="top"
| style="white-space: nowrap" |rotation rot30X
| style="white-space: nowrap" |= [[llEuler2Rot]](<30, 0, 0> * [[DEG_TO_RAD]]);
||// convert the degrees to radians, then convert that [[vector]] into a rotation, rot30x
|- valign="top"
| style="white-space: nowrap" |[[vector]] vec30X 
| style="white-space: nowrap" |= [[llRot2Euler]](rot30X );
||// convert the rotation back to a [[vector]] (the values will be in radians)
|- valign="top"
| style="white-space: nowrap" |rotation rot30X
| style="white-space: nowrap" |= [[llAxisAngle2Rot]](<1, 0, 0>, 30 * [[DEG_TO_RAD]]);
||// convert the degrees to radians, then convert into a rotation, rot30x
|}
</div></div>









== Различия между кватернионам математики и LSL вращений ==

Существуют некоторые различия между LSL и математике, которые имеют мало в то время как последствия сценария, но это может озадачить людей с предварительного математического знания. Поэтому мы подумали, что было бы хорошо, чтобы перечислить их здесь:

* В LSL, все кватернионов нормированы (скалярное произведение'' 'R''' на'' 'R''' всегда'' '1'' '), и, следовательно, представляют собой способы для вращения объектов без изменения их размеров . В математике, общий кватернионов может быть не нормируется, и они представляют'''' сродства, то есть способ, чтобы повернуть'' 'и''' изменения размера объектов.
* В LSL, термин'' 'с''' является четвертым членом вращения:'' '<x, y, z, s>'''. В математике, термин'' 'с''', которая также называется "реальная часть", написана в качестве первой координаты кватернионов:'' '(с, х, у, г)'''.
* Умножение написано в обратном порядке LSL и в математике. В LSL, вы должны написать'' 'R * S''', где в математике можно было бы написать'' 'S. R'' '.

== Порядке ротации для векторов Эйлера ==

Исходя из вышеизложенного, становится ясно, что при работе с вращений вокруг более одной оси, тем, как они сделали в критическое. В'''' Эйлера обсуждения выше этого был отчасти умалчивается немного, отдельные повороты вокруг трех осей Определение общего вращения'''', но напрашивается вопрос: Что оси порядка вращениями сделано? Ответ'' 'Z, Y, X''' в глобальных координатах. Если вы пытаетесь, чтобы повернуть объект вокруг более одной оси одновременно использованием'''' Эйлера представительства, определить правильный'''' Эйлера {{LSLG | вектора}}, используя Z, Y, X порядке ротации, затем с помощью {{LSLG | llEuler2Rot}} функцию, чтобы получить'' 'вращение''' для использования в сочетании вращения или применение вращения к объекту.

Местное == против глобального (Мир) вращений ==

Важно провести различие между относительной "вращение'' ''' к миру, и относительная" вращение''''' в местный самого объекта. В редакторе, вы можете переключаться с одного на другой. В скрипте, необходимо преобразовать из одного в другой, чтобы получить желаемое поведение.

Вращений «Местные'' ''' являются те сделали вокруг осей встроенный в сам объект вперед / назад, влево / вправо, вверх / вниз, независимо от того, вращается объект в мире. Вращений «Глобальный'' ''' являются те, сделано во всем мире топоры, Север / Юг, Восток / Запад, Выше / Ниже. Вы можете увидеть разницу, вращая Prim, затем отредактировать его и изменить параметры осей между локальными и глобальными, обратите внимание, как цветные стрелки осей изменения.

В LSL, разница между делают «местное'' ''' или вращение" глобального''''' порядок'' 'повороты''' оцениваются в заявлении.

Это делает 30 градусов «местного'' ''' вращения, поместив постоянной 30 градусов''' вращение'' 'слева от начала'' объекта" вращение''' (myRot). Это как первая операция в первом примере выше, просто скручивания дротик 30 градусов вокруг своей длинной оси.

<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
|- valign="top"
| style="white-space: nowrap" |rotation localRot = 
| style="white-space: nowrap" |rot30X * myRot;
||// do a local rotation by multiplying a constant rotation by a world rotation
|}
</div></div>

Для вращения «глобальный'' ''', используйте" вращение''''' же значения, но в обратном порядке. Это похоже на вторую операцию во втором примере, дротик вращающихся и вправо вокруг оси X мире. В этом случае существующий вращения (myRot) поворачивается на 30 градусов вокруг глобальной оси X.

<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
|- valign="top"
| style="white-space: nowrap" |rotation globalRot 
| style="white-space: nowrap" | = myRot * rot30X;
||// do a global rotation by multiplying a world rotation by a constant rotation
|}
</div></div>

== Еще один способ думать об объединении вращений ==

Вы можете думать о «местных'' ''' против этой разницы''' глобальной'' ', считая, что''' повороты'' 'делается в оценке порядке, то есть слева направо, за исключением выражения в скобках.

В localRot случае то, что произошло то, что, начиная с <0, 0, 0>, rot30X было сделано в первую очередь, вращающиеся Prim вокруг оси мира X, но, поскольку, когда он до вращения, локальных и глобальных осей одинаковы, то есть эффект делает вращение вокруг локальной оси X объекта. Тогда второй'' 'вращения''' myRot было сделано которая вращалась Prim в исходное вращение, но теперь с дополнительными оси вращения X запеченные дюйма, как это выглядит в том, что чопорная поворачиваться на месте, вокруг собственной оси X , с Y и Z вращения вращения неизменным,'' 'местные'''.

В globalRot случае, опять начиная с <0, 0, 0>, первый объект вращается в исходное вращения (myRot), но теперь оси объекта и осей в мире больше не выровнены! Итак, "вращение'' ''' rot30x второй делает то, что сделал в локальном случае, вращается объект 30 градусов вокруг оси X мире, но эффект, чтобы повернуть объект через конус вокруг оси X, так как мир X объекта оси и оси Х в мире не то же самое это время. То, что это выглядит как то, что чопорные поворачивается на 30 градусов вокруг оси X мире, следовательно, вращение «глобальный'' '''.

'' 'Отдел''' из'' 'вращения''' имеет эффект делает вращение в противоположном направлении, умножением на 330 градусов'' 'вращение''' такой же, как деление на 30 градусов'' "вращение'' '.

== Использование == Повороты

Вы можете получить доступ к отдельным компонентам'' 'вращения''''' 'R''' на'' 'Rx, Ry, Rz, R, S &''' ('' 'не''' Rw). Скалярная часть РС косинус половины угла поворота. Векторной части (Rx, Ry, Rz) есть произведение нормированных оси вращения, и на синус половины угла поворота. Вы можете создавать "вращение'' ''' обратной путем отрицания X, Y, Z членов (или, сделав значение с отрицательным). Как в стороне, вы можете также использовать "вращение'' ''' просто как хранилище [[поплавок]] значения," вращение''''' каждый магазинах четыре из них и [[Список]], состоящий из ' вращение'''' 'является более эффективным, чем [[Список]], состоящий из [[поплавок]] ы, но есть накладные расходы в распаковывая их.


<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
|- valign="top"
| style="white-space: nowrap" |rotation rot30X 
| style="white-space: nowrap" |= [[llEuler2Rot]](<30, 0, 0> * [[#DEG_TO_RAD|DEG_TO_RAD]] );
||// Create a rotation constant
|- valign="top"
| style="white-space: nowrap" |rotation rotCopy 
| style="white-space: nowrap" |= rot30X;
||// Just copy it into rotCopy, it copies all 4 float components
|- valign="top"
| style="white-space: nowrap" |float X 
| style="white-space: nowrap" |= rotCopy.x;
||// Get out the individual components of the rotation
|- valign="top"
| style="white-space: nowrap" |float Y 
| style="white-space: nowrap" |= rotCopy.y;
||
|- valign="top"
| style="white-space: nowrap" |float Z 
| style="white-space: nowrap" |= rotCopy.z;
||
|- valign="top"
| style="white-space: nowrap" |float S 
| style="white-space: nowrap" |= rotCopy.s;
||
|- valign="top"
| style="white-space: nowrap" |rotation anotherCopy 
| style="white-space: nowrap" |= <X, Y, Z, S>;
||// Make another rotation out of the components
|}
</div></div>


Существует встроенный в постоянном для нулевого'' 'вращения''' [[# ZERO_ROTATION | ZERO_ROTATION]], которые вы можете использовать прямо или, если вам нужно, чтобы инвертировать'' 'вращения R''', разделите [[# ZERO_ROTATION | ZERO_ROTATION]] на'' 'R'''. В качестве напоминания сверху, это работает, первую вращающуюся в нулевое положение, то потому, что это пропасть, вращающихся в противоположном направлении к первоначальному'' 'вращения''', тем самым делает обратное вращение.

<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
|- valign="top"
| style="white-space: nowrap" |rotation rot330X 
| style="white-space: nowrap" |= <-rot30X.x, -rot30X.y, -rot30X.z, rot30X.s>;
||// invert a rotation - NOTE the s component isn't negated
|- valign="top"
| style="white-space: nowrap" |rotation another330X 
| style="white-space: nowrap" |= [[#ZERO_ROTATION|ZERO_ROTATION]] / rot30X;
||// invert a rotation by  division, same result as rot330X
|- valign="top"
| style="white-space: nowrap" |rotation yetanother330X 
| style="white-space: nowrap" |= <rot30X.x, rot30X.y, rot30X.z, -rot30X.s>;
||// not literally the same but works the same.
|}
</div></div>

== Одноместный или корневой Prims VS Связанные Prims против Вложения ==

Причиной говорить о едином или связанных Prim вращений в том, что такие вещи, как двери на транспортные средства, желаемого движения является перемещение дверей относительно транспортного средства, независимо от того, что вращение общее транспортное средство. В то время как можно сделать это с глобальным вращений, было бы быстро расти утомительно.
Есть вообще три системы координат Prim может быть в: в полном одиночестве, часть {{LSLG |}} группы каналов или части LSLG {{|}} привязанности. Когда чопорная один, т.е. не является частью {{LSLG | группы каналов}}, он действует как росток чопорные, а когда она является частью {{LSLG | привязанности}}, он действует по-разному и немного нарушена.

{{LSLRotGetSet}}

== Вращающиеся векторы ==

В LSL, вращая [[вектор]] очень полезно, если вы хотите переместить объект в дугу или окружность, когда центр вращения не центр объекта.

Это звучит очень сложным, но гораздо меньше, чем кажется на первый взгляд. Помните, из вышеизложенного вращающихся [[# Объединение Повороты | дротик]], и заменить физические дротик с [[вектор]], происхождение которых хвост дротика и компоненты которого в X, Y, Z и описатьположение кончика дротик. Вращение вокруг своей дротик хвост движется кончик дротика и через дугу, центр вращения хвоста дротики. Точно таким же способом, вращая [[Vector]], который представляет смещение от центра вращается Prim Prim через ту же дугу. То, что это выглядит как это объект вращается вокруг позиции компенсируется [[вектор]] от центра Prim.
=== Положение Объект вращается вокруг относительной точки ===
<lsl>rotation vRotArc       = llEuler2Rot( <30.0, 0.0, 0.0> * DEG_TO_RAD );
 //-- creates a rotation constant, 30 degrees around the X axis

vector   vPosOffset     = <0.0, 1.0, 0.0>;
 //-- creates an offset one meter in the positive Y direction

vector   vPosRotOffset  = vPosOffset * vRotArc;
 //-- rotates the offset to get the motion caused by the rotation

vector   vPosOffsetDiff = vPosOffset - vPosRotOffset;
 //-- gets the local difference between the current offset and the rotated one

vector   vPosRotDiff    = vPosOffsetDiff * llGetRot();
 //-- rotates the difference in the offsets to be relative to the global rotation.

vector   vPosNew        = llGetPos() + vPosRotDiff;
 //-- finds the prims new position by adding the rotated offset difference

rotation vRotNew        = vRotArc * llGetRot();
 //-- finds rot to continue facing offset point</lsl>
: в применении, и то же действие, как:
<lsl>llSetPrimitiveParams( [PRIM_POSITION, llGetPos() + (vPosOffset - vPosOffset * vRotArc) * llGetRot(),
                       PRIM_ROTATION, vRotArc * llGetRot()] );</lsl>
* Приведенные выше результаты метода в орбите объект всегда с той же стороны, обращенной к центру. Альтернатива, которая сохраняет орбитальных вращений выглядит следующим образом

<lsl>llSetPrimitiveParams( [PRIM_POSITION, llGetPos() + (vPosOffset - vPosOffset * vRotArc) * llGetRot()];
vPosOffset = vPosOffset * vRotArc;</lsl>

'''На заметку:''' Делать это движение, так что не забывайте о проблемах перемещения Prim от мира, под землей, более чем на 10 метров и т.д. Кроме того, чтобы получить полную орбиту, вам нужно повторите перечисленные стадии (в [[Таймер]] может быть).

'''Внимание:''' Эти условия распространяются на объекты (или корень примы если вы предпочитаете), детский примы должны использовать [[PRIM_POS_LOCAL]] за позицию, и [[PRIM_ROT_LOCAL]] или [[llGetlocalRot]] для вращения, а Суть в том, вращается вокруг должно быть относительно корня.

=== Позиции относительной точкой, вокруг повернутого объекта ===
Чтобы получить точку относительно объектов текущего облицовка (например, используется в rezzors)

<lsl>vector   vPosOffset     = <0.0, 0.0, 1.0>;
 //-- создает смещение на один метр в положительном направлении Z.

vector   vPosRotOffset  = vPosOffset * llGetRot();
 //-- вращать смещение, которое по отношению к вращению объектов

vector   vPosOffsetIsAt = llGetPos() + vPosRotOffset;
 //-- получить область положение поворачивается смещение</lsl>
:в применении, те же действия,:
<lsl>llRezAtRoot( "Object", llGetPos() + vPosOffset * llGetRot(), ZERO_VECTOR, ZERO_ROTATION, 0 );</lsl>

== Нормализация вращения == 
При необходимости точности, часто важно - даже необходимым - работать с нормированными вращения, что означает масштабирования каждого кватернион, так что его'' х, у, и'''''' г значения равны 1. Некоторые операции в LSL будет фактически генерировать ошибку времени выполнения, если вы не делаете этого. Глядя на это с другой стороны, необходимо, чтобы выразить вращения таким образом, что касается угла поворота вектора <1.0,1.0,1.0>. Математически нормализации вращения'' 'Q''' означает расчета

'''Нормализация Q = Q / Sqrt( Q.x^2 + Q.y^2 + Q.z^2 + Q.s^2)'''

Полагая, что с точки LSL:
<lsl>rotation NormRot(rotation Q)
{
    float MagQ = llSqrt(Q.x*Q.x + Q.y*Q.y +Q.z*Q.z + Q.s*Q.s);
    return <Q.x/MagQ, Q.y/MagQ, Q.z/MagQ, Q.s/MagQ>;
}</lsl>

:'''Примечание''': только методы в LSL для получения де-нормированной вращений [[llAxes2Rot]] ('' через входы, которые не являются взаимно ортогональных или через входы различной величины''), или прямой манипулирование элементами ротации. Все остальные функции * LL вернуться нормированного вращений. Использование предыдущего примера может ввести небольшой плавающей точкой ошибки в нормированный вращения из-за ограниченной точностью.

== Полезные фрагменты ==
<lsl>integer IsRotation(string s)
{
    list split = llParseString2List(s, [" "], ["<", ">", ","]);
    if(llGetListLength(split) != 9)//we must check the list length, or the next test won't work properly.
        return 0;
    return !((string)((rotation)s) == (string)((rotation)((string)llListInsertList(split, ["-"], 7))));
    //it works by trying to flip the sign on the S element of the rotation,
    //if it works or breaks the rotation then the values won't match.
    //if the rotation was already broken then the sign flip will have no affect and the values will match
    //we cast back to string so we can catch negative zero which allows for support of <0,0,0,0>
}//Strife Onizuka</lsl>


{{CopyAsComment|Рассчитайте точку D на расстоянии в направлении аватара ID сталкивается}}

<lsl>vector point_in_front_of( key id, float d )
{
    list pose = llGetObjectDetails( id, [ OBJECT_POS, OBJECT_ROT ] );
    return ( llList2Vector( pose, 0 ) + < d, 0.0, 0.0 > * llList2Rot( pose, 1 ) );
}// Mephistopheles Thalheimer</lsl>


{{CopyAsComment|Rez объект о на расстоянии г от конца оси z.<br>
Объект rezzed ориентирована на rezzer}}

<lsl>rez_object_at_end( string o, float d )
{
    vector s = llGetScale();
    
    if( llGetInventoryType( o ) == INVENTORY_OBJECT )
    {
        llRezObject( o, llGetPos() + llRot2Up( llGetRot() ) * ( s.z / 2.0 + d ) , ZERO_VECTOR, llGetRot(), 0 );
    }
}// Mephistopheles Thalheimer(Мефистофель Тальгеймер)</lsl>

{{CopyAsComment|Полезные функции преобразуются в LSL от [http://www.isner.com/tutorials/quatSpells/quaternion_spells_12.htm this page]: {{HiddenButCopy|http://www.isner.com/tutorials/quatSpells/quaternion_spells_12.htm}}}}

{{CopyAsComment|Масштабирование вращения:}}
<lsl>rotation ScaleQuat(rotation source, float ratio)
{
	return llAxisAngle2Rot(llRot2Axis(source), ratio * llRot2Angle(source));
}</lsl>

{{CopyAsComment|Ограничение вращения в данной плоскости, определяется его нормальным, очень полезно для транспортных средств, которые остаются в горизонтальном получается: <br/>
Отметим, что существует недостаток где-то в этой функции, это дает неправильные результаты в некоторых обстоятельствах.}}

<lsl>rotation ConstrainQuat2Plane(rotation source, vector normal)
{
	return llAxisAngle2Rot(normal, <source.x, source.y, source.z> * normal * llRot2Angle(source));
} // Jesrad Seraph</lsl>

{{CopyAsComment|Slerp (rotation combination) function from [[Slerp]]:}}
<lsl>rotation BlendQuats(rotation a, rotation b, float ratio)
{
	return llAxisAngle2Rot(llRot2Axis(b /= a), ratio * llRot2Angle(b)) * a;
}</lsl>


== Константы ==
=== [[ZERO_ROTATION]] ===
ZERO_ROTATION = <0.0, 0.0, 0.0, 1.0>;<br/>
Вращения константа, представляющая угла Эйлера <0.0, 0.0, 0.0>.

=== [[DEG_TO_RAD]] ===
DEG_TO_RAD = 0.01745329238f;<br/>
float-константа, которая при умножении на угол в градусах дает угол в радианах.

=== [[RAD_TO_DEG]] ===
RAD_TO_DEG = 57.29578f;<br/>
float-константа при умножении на угол в радианах дает угол в градусах.


[[Category:LSL_Types|Rotation]][[Category:LSL_Math]][[Category:LSL_Math/3D]][[Category:LSL Rotation]]









== Полезные функции ==
<div style="padding: 0.5em;">
=== Созданные пользоваетем полезные функции ===
Эти функции были созданы и предоставлены пользователям LSL для выполнения операций не распространяется встроенный LSL функций.


{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[Chr]] || Возвращает Unicode символ с данным кодом. См. также [[Ord]].
|-
|| [[Float2String]] || Позволяет Выходная строка из поплавка в аккуратные текстовый формат, с возможностью округления.
|-
|| [[Left]] || Возврат текста осталось от указанного сепаратора.
|-
|| [[Like]] || Смотрите, если одно слово соответствует части другого.
|-
|| [[Ord]] || Возвращает порядковое (Unicode код) характер. См. также [[Chr]].
|-
|| [[RandomString]] || Создает случайной строки.
|-
|| [[RemoveHTMLTags]] || Удаляет HTML-теги из строки (и символы новой строки)
|-
|| [[Right]] || возвращает текст праве указанный разделитель.
|-
|| [[Library_Combined_Library#str_replace|str_replace]] || заменить все вхождения строки другой строки в строку.
|-
|| [[Stristr]] || Возвращает строку из первого вхождения иглы до конца стогу.
|-
|| [[SplitLine]] || вставка escape 'new line' кодов в определенных позициях строки.
|-
|| [[WrapText]] || Прерывает текст в соответствие длины вашей спецификации.
|}

=== Текст-документы из библиотеки скриптов ===
{| {{Prettytable}}
|-
|{{Hl2}}| '''Name'''
|{{Hl2}}| '''Creator'''
|{{Hl2}}| '''Description'''
|-
||[[ParseString2List]]
||[[User:Strife Onizuka|Strife Onizuka]]
||То же, что [[llParseString2List]] и [[llParseStringKeepNulls]], но не ограничены 8 прокладками или сепараторов. Таким образом заменить вызов [[llParseString2List]] и [[llParseStringKeepNulls]] функций с помощью вызова [[Parse_String_To_List|ParseString2List]] всякий раз, когда у вас есть более чем на 8 сепараторов или более 8 распорки.
|-
||[[String Compare]]
||[[User:Xaviar Czervik|Xaviar Czervik]]
||Сравнивает две строки и надежно возвращает либо 1, -1 или 0, если они такие же.
|-
||[[XyText 1.5|XyText]]
||[[User:Xylor Baysklef|Xylor Baysklef]]
|| Текстовый дисплей (до 10 символов) на прим. Используйте столько примы как хотелось бы.
|-
||[[XyyyyzText|XyyyyzText]]
||[[User:Criz Collins|Criz Collins]]
|| Текстовый дисплей (до 10 символов) на прим. Отображает различные текст для каждой строки, а не единый текст, который будет разбит на следующие строки. Смотреть здесь, что это значит: http://screencast.com/t/1wMLujLcEO
|-
||[[XyzzyText|XyzzyText]]
||[[User:Thraxis Epsilon|Thraxis Epsilon]] and [[User:Gigs Taggart|Gigs Taggart]]
|| Текстовый дисплей (до 10 символов) на примы. Путь, более эффективны, чем XyText.
|}
</div>