Rotation/ru

From Second Life Wiki
Jump to: navigation, search

См. также Text.

Вращение (rotation).

Тип вращение ( rotation ) в LSL является одним из нескольких способов представления ориентации в 3D-проостранстве - трехмерном пространстве. (Обратите внимание, что мы пытаемся написать имя типа в жирном.)


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


Математический объект вызывает quaternion (кватернион). Вы можете представлять кватернион в виде четырех чисел, три из которых представляют направление объекта, а четвертое - крен объекта влево или вправо вокруг этого направления.Основным преимуществом использования кватернионов является то, что они не восприимчивы к блокировке вращения. Для комплексной внутренней работы с кватернионной математикой - см. кватернион. Список функций и событий, связанных с вращениями, см. краткий обзор LSL-вращения (rotation). Существует также информация о вызывании текстурных вращений в текстуры.


Пример:

rotation R = <1.23, 0.0, 4.56, 1.0>;


Другие представления

Эйлера вектор

Другой способ представления Угол 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 и оси часто называют крен, тангаж, рыскание и, в частности, для транспортных средств.

ролл Шаг рыскания

Объединение поворотов

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

rotation R3 = R1 * R2;

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

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

В отличие от других типов, таких как поплавок, порядок, в котором операции выполняются, некоммутативную, имеет важное значение. Причина этого проста: вы делаете заказ вращений в важно в 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 углов в радианах в качестве компонентов (так называемый угол Эйлера) , то, что для преобразования 'вращения с помощью llEuler2Rot функции. Чтобы перейти от вращения угол Эйлера вектора

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 the attach point rotation of prim relative to attachment 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 attachment location 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.
.

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

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

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

rotation rot30X = llEuler2Rot(<30, 0, 0> * DEG_TO_RAD); // convert the degrees to radians, then convert that vector into a rotation, rot30x
vector vec30X = llRot2Euler(rot30X ); // convert the rotation back to a vector (the values will be in radians)
rotation rot30X = llAxisAngle2Rot(<1, 0, 0>, 30 * DEG_TO_RAD); // convert the degrees to radians, then convert into a rotation, rot30x





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

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

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

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

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

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

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

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

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

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

rotation localRot = rot30X * myRot; // do a local rotation by multiplying a constant rotation by a world rotation

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

rotation globalRot = myRot * rot30X; // do a global rotation by multiplying a world rotation by a constant rotation

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

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

В 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 членов (или, сделав значение с отрицательным). Как в стороне, вы можете также использовать "вращение просто как хранилище поплавок значения," вращение каждый магазинах четыре из них и Список, состоящий из ' вращение' 'является более эффективным, чем Список, состоящий из поплавок ы, но есть накладные расходы в распаковывая их.


rotation rot30X = llEuler2Rot(<30, 0, 0> * DEG_TO_RAD ); // Create a rotation constant
rotation rotCopy = rot30X; // Just copy it into rotCopy, it copies all 4 float components
float X = rotCopy.x; // Get out the individual components of the rotation
float Y = rotCopy.y;
float Z = rotCopy.z;
float S = rotCopy.s;
rotation anotherCopy = <X, Y, Z, S>; // Make another rotation out of the components


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

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.

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

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

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.

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

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

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

Положение Объект вращается вокруг относительной точки

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
в применении, и то же действие, как:
llSetPrimitiveParams( [PRIM_POSITION, llGetPos() + (vPosOffset - vPosOffset * vRotArc) * llGetRot(),
                       PRIM_ROTATION, vRotArc * llGetRot()] );
  • Приведенные выше результаты метода в орбите объект всегда с той же стороны, обращенной к центру. Альтернатива, которая сохраняет орбитальных вращений выглядит следующим образом
llSetPrimitiveParams( [PRIM_POSITION, llGetPos() + (vPosOffset - vPosOffset * vRotArc) * llGetRot()];
vPosOffset = vPosOffset * vRotArc;

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

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

Позиции относительной точкой, вокруг повернутого объекта

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

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

Нормализация вращения

При необходимости точности, часто важно - даже необходимым - работать с нормированными вращения, что означает масштабирования каждого кватернион, так что его х, у, и' г значения равны 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:

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 для получения де-нормированной вращений llAxes2Rot ( через входы, которые не являются взаимно ортогональных или через входы различной величины), или прямой манипулирование элементами ротации. Все остальные функции * LL вернуться нормированного вращений. Использование предыдущего примера может ввести небольшой плавающей точкой ошибки в нормированный вращения из-за ограниченной точностью.

Полезные фрагменты

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


/* Рассчитайте точку D на расстоянии в направлении аватара ID сталкивается */

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


/* Rez объект о на расстоянии г от конца оси z.
Объект rezzed ориентирована на rezzer */

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 от this page: http://www.isner.com/tutorials/quatSpells/quaternion_spells_12.htm */

/* Масштабирование вращения: */

rotation ScaleQuat(rotation source, float ratio)
{
	return llAxisAngle2Rot(llRot2Axis(source), ratio * llRot2Angle(source));
}

/* Ограничение вращения в данной плоскости, определяется его нормальным, очень полезно для транспортных средств, которые остаются в горизонтальном получается: ​​
Отметим, что существует недостаток где-то в этой функции, это дает неправильные результаты в некоторых обстоятельствах. */

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

/* Slerp (rotation combination) function from Slerp: */

rotation BlendQuats(rotation a, rotation b, float ratio)
{
	return llAxisAngle2Rot(llRot2Axis(b /= a), ratio * llRot2Angle(b)) * a;
}


Константы

ZERO_ROTATION

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

DEG_TO_RAD

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

RAD_TO_DEG

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





Полезные функции

Созданные пользоваетем полезные функции

Эти функции были созданы и предоставлены пользователям LSL для выполнения операций не распространяется встроенный LSL функций.


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

Текст-документы из библиотеки скриптов

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