Second Life Wiki - User contributions [en]

User:Dora Gustafson/wind motor core

2016-12-10T18:56:14Z

Dora Gustafson: /* A working LSL script based on this core */

== Wind motor core ==
==== For use in virtual sailboats in SL ====
This wind motor uses four '''vectors''' to calculate boat velocity:
# '''''v''''': boat velocity
# '''''wind''''': wind velocity, direction at wind's eye
# '''''head''''': boat heading, normalized vector
# '''''n''''': sail normal, normalized vector. It doesn't matter which one of two normals is used<br>
; '''''v = head∙(-n∙(v + wind)*n)*head'''''<hr>
The tricky thing in a wind motor is that '''''v''''' is a function of '''''v''''' and it can not be isolated<br>
Therefor '''''v''''' is calculated by iteration, i.e. repeated calculations using the previous result<br>
Notes
# '''''head''''' and '''''n''''' are normalized vectors
# It does not matter if the positive or negative sail normal '''''n''''' is used in the equation
# '''''wind''''' is pointing the wind's eye so the wind blows opposite. Thus the minus sign in the equation
# The magnitude of '''''wind''''' is the wind speed
# The magnitude of '''''v''''' is the boat speed
==== A working LSL script based on this core ====
<source lang="lsl2">
// wind motor core, minimal sailboat script by Dora Gustafson, Studio Dora 2016
// use a two prim object: root prim for hull and child prim for sail
// enter this script, rez on water, sit and sail
// up, down arrows for setting sail
// left, right arrows for steering

vector windVector = <.0, 9.0, .0>; // wind from north, 9 m/S
float WindFactor = 12.0; // m/S
float heelFactor = .3;
float threeDEG = 0.052360; // 3°
float MAXSAIL = 1.48353; // 85°
float MINSAIL = 0.174533; // 10°
float sailAngle;
vector linear_motor;
vector angular_motor;
integer sailPrim = 2;
integer hullPrim = 1;
float time = 4.0;
vector blue = <0.0, 0.455, 0.851>;
vector green = <0.18, 0.8, 0.251>;
vector yellow = <1.0, 0.863, 0.0>;
vector red = <1.0, 0.255, 0.212>;

default
{
state_entry()
{
llSetVehicleType(VEHICLE_TYPE_BOAT);
llSetVehicleFloatParam( VEHICLE_HOVER_HEIGHT, 0.001 );
llSetVehicleFloatParam( VEHICLE_BANKING_EFFICIENCY, 0.0 );
llSetVehicleFloatParam( VEHICLE_ANGULAR_MOTOR_TIMESCALE, .75); // default 4
llSetVehicleFloatParam( VEHICLE_LINEAR_DEFLECTION_EFFICIENCY, 1); // default 0.5
llSetVehicleFloatParam( VEHICLE_LINEAR_DEFLECTION_TIMESCALE, .5); // default 3
llSetVehicleFloatParam( VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY, 0); // default 0.5
llSetVehicleFloatParam( VEHICLE_ANGULAR_DEFLECTION_TIMESCALE, .5); // default 5
llSitTarget( <-1.5, .0, 1.25>, ZERO_ROTATION);
sailAngle = MAXSAIL;
}
changed(integer change)
{
if (change & CHANGED_LINK)
{
key sitter = llAvatarOnSitTarget() ;
if(sitter != NULL_KEY)
{
llSetStatus( STATUS_PHYSICS, TRUE);
llRequestPermissions( sitter, PERMISSION_TAKE_CONTROLS);
llSetTimerEvent( time);
}
else
{
llSetStatus( STATUS_PHYSICS, FALSE);
llReleaseControls();
llSetTimerEvent( .0);
}
}
}
run_time_permissions(integer perm)
{
if ( perm & PERMISSION_TAKE_CONTROLS ) llTakeControls(CONTROL_FWD | CONTROL_BACK | CONTROL_ROT_RIGHT | CONTROL_ROT_LEFT, TRUE, FALSE);
}
control(key id, integer level, integer edge)
{
if ( edge & level & ( CONTROL_FWD | CONTROL_BACK) )
{
if ( edge & level & CONTROL_FWD )
{
if ( sailAngle + threeDEG < MAXSAIL ) sailAngle += threeDEG;
}
else if ( edge & level & CONTROL_BACK)
{
if ( sailAngle - threeDEG > MINSAIL ) sailAngle -= threeDEG;
}
llSetTimerEvent( 0.05);
}
else
{
if ( level & (CONTROL_ROT_RIGHT)) angular_motor.z = 0.8;
else if ( level & (CONTROL_ROT_LEFT)) angular_motor.z = -0.8;
else angular_motor.z = 0.0;
llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION, angular_motor);
}
}
timer()
{
if ( llGetStatus( STATUS_PHYSICS) )
{
// vector capture
rotation sailRot = llGetRot();
vector heading = llRot2Fwd( sailRot);
vector left = llRot2Left( sailRot);
vector velocity = llGetVel();
float speed = llVecMag( velocity);
vector Aw = windVector + velocity;
Aw.z = 0.0;
vector nAw = llVecNorm( Aw);
vector axs = heading%nAw; // up or down axis to turn sail around
float AwAngle = llAcos( heading*nAw); // apparent wind, local angle [0;PI]
// setting sail
float setsail = AwAngle;
if ( setsail > sailAngle ) setsail = sailAngle;
sailRot = llAxisAngle2Rot( axs, setsail);
vector sailnormal = llRot2Left( sailRot)*llGetRot(); // Global
llSetLinkPrimitiveParamsFast( sailPrim, [PRIM_ROT_LOCAL, sailRot'er]);
// Linear and Angular Motors
vector action = ZERO_VECTOR;
if ( llFabs( sailnormal*nAw) > MINSAIL ) action = -(sailnormal*Aw)*sailnormal;
linear_motor.x = WindFactor*action*heading;
llSetVehicleVectorParam( VEHICLE_LINEAR_MOTOR_DIRECTION, linear_motor);
// heel by wind
angular_motor.x = -heelFactor*action*left;
llSetVehicleVectorParam( VEHICLE_ANGULAR_MOTOR_DIRECTION, angular_motor);
llSetTimerEvent( time);
// optional signal color
vector color = red;
if ( sailAngle < 0.435*AwAngle ) color = blue;
else if ( sailAngle < 0.565*AwAngle ) color = green;
else if ( sailAngle < 0.825*AwAngle ) color = yellow;
llSetLinkColor( sailPrim, color, ALL_SIDES);
}
else
{
llSetTimerEvent( 0.0);
}
}
on_rez( integer p) { llResetScript(); }
}</source>
A few boats in world use this core now. Two of mine are "Windy" and "Breezy 9'er"
{{LSLC|Library}}

User:Dora Gustafson

2016-12-10T18:46:38Z

Dora Gustafson: /* Highlighted scripts */

{{LSL Header}}
<div id="box">
== About ==
I have been a premium since spring 2007.<br>
Over the time I made quite a few scripts.<br>
The scripts are the basis for my business.<br>
Many are published in the SL forums and some are given away.<br>
Here are some working scripts that highlights LSL functions and SL characteristics
</div>
<div id="box">

== Highlighted scripts ==
#[[User:Dora_Gustafson/talking_die|Talking Die]]
#[[User:Dora_Gustafson/llAxes2Rot_right_and_wrong|llAxes2Rot]] Right and Wrong
#[[User:Dora_Gustafson/point_tracker|Key framed Motion forward on a closed track]]
#[[User:Dora_Gustafson/Basic_Resizer|Re-size or re-scale objects with a single small script]]
#[[User:Dora_Gustafson/sundirection_and_time_of_day|Show Sun Direction and compare to Time of Day]]
#[[User:Dora_Gustafson/universal_hinged_motion|Universal hinged motion]] in 8 Key Frames
#[[User:Dora_Gustafson/Pendulum_motion|Pendulum motion]] Simple Pendulum Motion in 24 Key Frames, a good swing motion
#[[User:Dora_Gustafson/Harmonic_Oscillator_motion|Harmonic Oscillator motion]] Motion in 12 Key Frames
#[[User:Dora_Gustafson/captureCameraView|Capture Camera View]] Using llSetLinkCamera()
#[[User:Dora_Gustafson/llRotBetween_alternatives#llRotBetween.2C_some_alternatives_and_considerations|llRotBetween]] alternatives and considerations
#[[User:Dora_Gustafson/fixed_3D_relation|Fixed 3D Relation]] Position and Rotation computations
#[[User:Dora_Gustafson/JSON_structure_facial_expression|JSON structured menu]] for all facial expressions
#[[User:Dora_Gustafson/insertion_sort|Straight insertion Sort script]]
#[[User:Dora_Gustafson/occurences|Count occurencces in a list]]
#[[User:Dora_Gustafson/bezier_toy|Bézier Toy]]
#[[LlTargetOmega_Replacement|Replacing llTargetOmega]] with a Key Framed Motion
#[[User:Dora_Gustafson/moderated_world_wind|Moderated in-world wind]]
#[[User:Dora_Gustafson/wind_motor_core|Wind motor Core]]

User:Dora Gustafson/wind motor core

2016-12-10T18:41:19Z

Dora Gustafson: /* Wind motor core */

== Wind motor core ==
==== For use in virtual sailboats in SL ====
This wind motor uses four '''vectors''' to calculate boat velocity:
# '''''v''''': boat velocity
# '''''wind''''': wind velocity, direction at wind's eye
# '''''head''''': boat heading, normalized vector
# '''''n''''': sail normal, normalized vector. It doesn't matter which one of two normals is used<br>
; '''''v = head∙(-n∙(v + wind)*n)*head'''''<hr>
The tricky thing in a wind motor is that '''''v''''' is a function of '''''v''''' and it can not be isolated<br>
Therefor '''''v''''' is calculated by iteration, i.e. repeated calculations using the previous result<br>
Notes
# '''''head''''' and '''''n''''' are normalized vectors
# It does not matter if the positive or negative sail normal '''''n''''' is used in the equation
# '''''wind''''' is pointing the wind's eye so the wind blows opposite. Thus the minus sign in the equation
# The magnitude of '''''wind''''' is the wind speed
# The magnitude of '''''v''''' is the boat speed
==== A working LSL script based on this core ====
<source lang="lsl2">
// wind motor core, minimal sailboat script by Dora Gustafson, Studio Dora 2016
// use a two prim object: root prim for hull and child prim for sail
// enter this script, rez on water, sit and sail
// up, down arrows for setting sail
// left, right arrows for steering

vector windVector = <.0, 9.0, .0>; // wind from north, 9 m/S
float WindFactor = 12.0; // m/S
float heelFactor = .3;
float threeDEG = 0.052360; // 3°
float MAXSAIL = 1.48353; // 85°
float MINSAIL = 0.174533; // 10°
float sailAngle;
vector linear_motor;
vector angular_motor;
integer sailPrim = 2;
integer hullPrim = 1;
float time = 4.0;
vector blue = <0.0, 0.455, 0.851>;
vector green = <0.18, 0.8, 0.251>;
vector yellow = <1.0, 0.863, 0.0>;
vector red = <1.0, 0.255, 0.212>;

default
{
state_entry()
{
llSetVehicleType(VEHICLE_TYPE_BOAT);
llSetVehicleFloatParam( VEHICLE_HOVER_HEIGHT, 0.001 );
llSetVehicleFloatParam( VEHICLE_BANKING_EFFICIENCY, 0.0 );
llSetVehicleFloatParam( VEHICLE_ANGULAR_MOTOR_TIMESCALE, .75); // default 4
llSetVehicleFloatParam( VEHICLE_LINEAR_DEFLECTION_EFFICIENCY, 1); // default 0.5
llSetVehicleFloatParam( VEHICLE_LINEAR_DEFLECTION_TIMESCALE, .5); // default 3
llSetVehicleFloatParam( VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY, 0); // default 0.5
llSetVehicleFloatParam( VEHICLE_ANGULAR_DEFLECTION_TIMESCALE, .5); // default 5
llSitTarget( <-1.5, .0, 1.25>, ZERO_ROTATION);
sailAngle = MAXSAIL;
}
changed(integer change)
{
if (change & CHANGED_LINK)
{
key sitter = llAvatarOnSitTarget() ;
if(sitter != NULL_KEY)
{
llSetStatus( STATUS_PHYSICS, TRUE);
llRequestPermissions( sitter, PERMISSION_TAKE_CONTROLS);
llSetTimerEvent( time);
}
else
{
llSetStatus( STATUS_PHYSICS, FALSE);
llReleaseControls();
llSetTimerEvent( .0);
}
}
}
run_time_permissions(integer perm)
{
if ( perm & PERMISSION_TAKE_CONTROLS ) llTakeControls(CONTROL_FWD | CONTROL_BACK | CONTROL_ROT_RIGHT | CONTROL_ROT_LEFT, TRUE, FALSE);
}
control(key id, integer level, integer edge)
{
if ( edge & level & ( CONTROL_FWD | CONTROL_BACK) )
{
if ( edge & level & CONTROL_FWD )
{
if ( sailAngle + threeDEG < MAXSAIL ) sailAngle += threeDEG;
}
else if ( edge & level & CONTROL_BACK)
{
if ( sailAngle - threeDEG > MINSAIL ) sailAngle -= threeDEG;
}
llSetTimerEvent( 0.05);
}
else
{
if ( level & (CONTROL_ROT_RIGHT)) angular_motor.z = 0.8;
else if ( level & (CONTROL_ROT_LEFT)) angular_motor.z = -0.8;
else angular_motor.z = 0.0;
llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION, angular_motor);
}
}
timer()
{
if ( llGetStatus( STATUS_PHYSICS) )
{
// vector capture
rotation sailRot = llGetRot();
vector heading = llRot2Fwd( sailRot);
vector left = llRot2Left( sailRot);
vector velocity = llGetVel();
float speed = llVecMag( velocity);
vector Aw = windVector + velocity;
Aw.z = 0.0;
vector nAw = llVecNorm( Aw);
vector axs = heading%nAw; // up or down axis to turn sail around
float AwAngle = llAcos( heading*nAw); // apparent wind, local angle [0;PI]
// setting sail
float setsail = AwAngle;
if ( setsail > sailAngle ) setsail = sailAngle;
sailRot = llAxisAngle2Rot( axs, setsail);
vector sailnormal = llRot2Left( sailRot)*llGetRot(); // Global
llSetLinkPrimitiveParamsFast( sailPrim, [PRIM_ROT_LOCAL, sailRot]);
// Linear and Angular Motors
vector action = ZERO_VECTOR;
if ( llFabs( sailnormal*nAw) > MINSAIL ) action = -(sailnormal*Aw)*sailnormal;
linear_motor.x = WindFactor*action*heading;
llSetVehicleVectorParam( VEHICLE_LINEAR_MOTOR_DIRECTION, linear_motor);
// heel by wind
angular_motor.x = -heelFactor*action*left;
llSetVehicleVectorParam( VEHICLE_ANGULAR_MOTOR_DIRECTION, angular_motor);
llSetTimerEvent( time);
// optional signal color
vector color = red;
if ( sailAngle < 0.435*AwAngle ) color = blue;
else if ( sailAngle < 0.565*AwAngle ) color = green;
else if ( sailAngle < 0.825*AwAngle ) color = yellow;
llSetLinkColor( sailPrim, color, ALL_SIDES);
}
else
{
llSetTimerEvent( 0.0);
}
}
on_rez( integer p) { llResetScript(); }
}</source>
{{LSLC|Library}}

User:Dora Gustafson/wind motor core

2016-12-10T18:20:09Z

Dora Gustafson: Created page with " == Wind motor core == ==== For use in virtual sailboats in SL ==== This wind motor uses four '''vectors''' to calculate boat velocity: # '''''v''''': boat velocity # '''''win..."

LlWind

2016-09-19T19:26:04Z

Dora Gustafson:

{{LSL_Function
|inject-2={{LSL Function/offset|offset|noZ=*|sim=*}}
|func=llWind
|sort=Wind
|func_id=44
|func_sleep=0.0
|func_energy=10.0
|return_type=vector
|p1_type=vector
|p1_name=offset
|func_footnote
|return_text=that is the wind velocity at the prim's [[llGetPos|position]] + {{LSLPT|offset}}
|spec
|caveats
|examples=
<source lang="lsl2">
default
{
touch_start(integer num)
{
llSay(0, "Wind velocity: " + (string)llWind(ZERO_VECTOR));
}
}
</source>
<source lang="lsl2">
// wind interpretation as angle and speed
default
{
state_entry()
{
vector windVector = llWind( ZERO_VECTOR);
float windSpeed = llVecMag( windVector);
float windDirection = llAtan2( windVector.y, windVector.x);
integer compassWind = ( 450 - (integer)( RAD_TO_DEG*windDirection))%360;
llOwnerSay( "\nWind direction: "+(string)compassWind+"°\nWind speed: "+(string)windSpeed+" m/S");
}
}
</source>
|helpers
|also_functions={{LSL DefineRow||[[llCloud]]}}
|also_articles={{LSL DefineRow||{{LSLGC|Weather}}|SL Weather information}}
{{LSL DefineRow||[[User:Dora_Gustafson/moderated_world_wind|Moderated in-world wind]]}}
|notes
|issues={{Issue/V1|SVC-3131|llWind() and viewer wind effects do not match}}
|cat1=Region
|cat2=Weather
|cat3
|cat4
}}

User:Dora Gustafson

2016-08-10T09:48:38Z

Dora Gustafson: /* Highlighted scripts */

User:Dora Gustafson/moderated world wind

2016-08-10T09:40:34Z

Dora Gustafson: Moderated in world wind for sailing in general and racing particularely

== Moderated in World Wind ==
The sailing community in Second Life do not use the world wind for sailing. The reasons are
# The wind is different in each position so that two sailors are guarantied to have different wind at any time
# Most of the time the wind is too light or too heavy for sailing
This moderated wind overcomes these objections<br>
Firstly: Everybody read the wind in sim position <0,0,0><br>
Secondly: The wind speed is moderated to 5 times the cubic root of the obtained wind speed
<source lang="lsl2">
vector windVector = llWind( -llGetPos()); // Wind velocity in region at <0,0,0>
float speed = 5.0*llPow( llVecMag( windVector), .333333); // moderated speed
windVector = speed*llVecNorm( windVector); // moderated wind velocity
</source>
With this moderated wind all sailors are guarantied the same unpredictable wind at any time<br>
Statistics for the moderated wind:
measured: 33000 times (twelwe hours)
Wind Mean: 15 kts
Standard deviation: 3 kts
Max: 24 kts
Min: 3 kts
Observations:<br>
# very suitable for sailing
# may stay almost the same over one, two or more sims
# may change slowly over time or direction may jump
# wind direction may 'jump' but only when the wind speed is low (very natural)
# all sailors have identical wind conditions and racing on equal terms is possible
{{LSLC|Library}}

LSL Operators

2015-10-09T08:26:48Z

Dora Gustafson: modulus runtime error

{{LSL Header|ml=*}}{{LSLC|FixMe}}
Operators are used to cause an operation (or mathematical action) to be performed on one (such as !) or two operands. The easy and common example is 1 + 2 where 1 and 2 are operands, and the '''+''' is the operator.

This concept can be extended much further with LSL since operands can be variables with the special case of the assignment operators requiring that the left hand side be a variable.

{| bgcolor="#FFFFFF" border="1" cellspacing="2" cellpadding="6"
|- bgColor="#A7C1F2"
! Operator
! Description
! Usage Example
|-
| () || Parentheses || a * (b + c)
|-
| [] || Brackets: list constructor || [a, 2, "this", 0.01]
|-
| (''type'') || Typecasting || message = "The result is:" + (string) result;
|-
| ! ~ ++ -- || Logical-NOT, Bitwise-NOT, Increment, Decrement || counter++;
|-
| * / % || Multiply/Dot-Product, Divide, Modulus/Cross-Product || rollover = (count + 1)%5;
|-
| - || Subtraction || one = 3 - 2;
|-
| + || Addition or joining Strings || two = 1+1;
text = "Hello" + "World";
|-
| + || Concatenation or joining Lists || myList = [1, 2, 3] + [4, 5];
newList = oldList + addList;
|-
| << >> || Left Shift, Right Shift || eight = 4 << 1;
|-
| < <= > >= || Less Than, Less Than Or Equal To,
Greater Than, Greater Than or Equal To
|| isFalse = (6 <= 4);
|-
| == != || Comparison Equal, Comparison Not Equal || isFalse = ("this" == "that");
|-
| & || Bitwise AND || zero = 4 & 2;
four = 4 & 4;
|-
| ^ || Bitwise XOR || zero = 4 ^ 4;
six = 4 ^ 2;
|-
| <nowiki>|</nowiki> || Bitwise OR || four = 4 <nowiki>|</nowiki> 4;
six = 4 <nowiki>|</nowiki> 2;
|-
| <nowiki>||</nowiki> || Logical OR || isTrue = (FALSE <nowiki>||</nowiki> TRUE);
|-
| && ||Logical AND || isFalse = (FALSE && TRUE);
|-
| = += -= *= /= %= || Assignment || four = 4;
|}

'''Note:''' modulus, like integer division cause a ''Script run-time error. Math Error'' when second operand equals 0

'''Note:''' Unlike all other binary operators, the % operator only allows integer or vector operands.

'''Note:''' Unlike most, if not all, other languages that use the C style '''&&''' and '''||''' operators, '''both''' operands are '''always''' evaluated. For example,

<source lang="lsl2">if (TRUE || 1/0) llSay(PUBLIC_CHANNEL, "Aha!");</source>

will cause a Math Error rather than say "Aha".

'''Note:''' The ++ (increment) and -- (decrement) have their effect on their number either before or after the number is evaluated when used in conditions dependent on whether they are before or after the number.

<source lang="lsl2">integer count;
if(!(++count)) // Is incremented then evaluated.
llSay(PUBLIC_CHANNEL, "Aha"); // Will not be said.</source>

<source lang="lsl2">integer count;
if(!(count++)) // Is evaluated then incremented.
llSay(PUBLIC_CHANNEL, "Aha"); // Will be said.</source>

'''Note:''' The order of precedence of boolean operators is unclear. It is possible that there is a [http://jira.secondlife.com/browse/SVC-779 bug] in the expression parser, making precedence inconsistent, or it may simply be that '''||''' and '''&&''' have equal precedence; testing is inconclusive. Thus, when in doubt, parenthesize.
'''SubNote:''' As the above bug has been closed as expected behavior, one can only assume the boolean operators have equal precedence.

'''Note:''' The order of evaluation appears to be backwards from most languages. If the value of x starts as 1 then the first two conditions below evaluate false and the second two evaluate true:

<source lang="lsl2">(x && (x = 0) == 0 && x)</source>
<source lang="lsl2">(x && (x = 0) == 0 && x == 0)</source>
<source lang="lsl2">(x == 0 && (x = 0) == 0)</source>
<source lang="lsl2">(x == 0 && (x = 0) == 0 && x)</source>

Both sides are evaluated regardless of the the truth of either side.

'''Note:''' Equality test on lists does not compare contents, only the length.
{| {{Prettytable}}
|+
==+ Operator==
<code>result = left + right</code>
|-{{Hl2}}
!Left Type
!Right Type
!Result Type
!Description
|-
|integer
|integer
|integer
|Adds '''left''' and '''right'''
|-
|integer
|float
|float
|Adds '''left''' and '''right'''
|-
|float
|integer
|float
|Adds '''left''' and '''right'''
|-
|string
|string
|string
|Concatenates '''right''' onto the end of '''left'''.
|-
|list
|*
|list
|Concatenates '''right''' onto the end of '''left'''.
|-
|*
|list
|list
|Affixes '''left''' onto the start of '''right'''.
|-
|vector
|vector
|vector
|Adds '''left''' and '''right'''
|-
|rotation
|rotation
|rotation
|Adds '''left''' and '''right'''<br/>Not useful for combining rotations, use [[#* Operator|*]] or [[#/ Operator|/]] instead.
|}

{| {{Prettytable}}
|+
==Shorthand Operators==
Alternatives to the simple '=' operator...
|-{{Hl2}}
!Simple assignment operator
!Shorthand operator
|-
|a = a + 1
|a += 1
|-
|a = a – 1
|a -= 1
|-
|a = a * (n+1)
|a *= (n+1)
|-
|a = a / (n+1)
|a /= (n+1)
|-
|a = a % b
|a %= b
|}

=={{Wikipedia|De Morgan's laws|w=n}}==
{| {{Prettytable|style=margin-top:0; float:left;}}
|+ Bitwise Equivalencies
!AND
!OR
|-
|| <code>~(a & b)</code> || <code>~a | ~b</code>
|-
|| <code>~a & ~b</code> || <code>~(a | b)</code>
|-
| colspan="2" |
|-
|| <code>a & ~b</code> || <code>~(~a | b)</code>
|-
|| <code>~(a & ~b)</code> || <code>~a | b</code>
|-
|}
{| {{Prettytable|style=margin-top:0; float:left;}}
|+ Boolean Equivalencies
!AND
!OR
|-
|| <code>!(a && b)</code> || <code>!a || !b</code>
|-
|| <code>!a && !b</code> || <code>!(a || b)</code>
|-
| colspan="2" |
|-
|| <code>a && !b</code> || <code>!(!a || b)</code>
|-
|| <code>!(a && !b)</code> || <code>!a || b</code>
|-
|}
Due to {{Wikipedia|De Morgan's laws|w=n}}, by row, code in the '''AND''' column is logically equivalent to code in the '''OR'''. '''a''' and '''b''' need not be variables, they can be expressions. In certain circumstances these equivalencies can be used to simplify complex code. It is important not to confuse the two sets when using them. The first two rows depict De Morgan's laws as it is formulated, the second two build upon it.

{{LSLC|}}{{LSLC|Syntax}}{{LSLC|Keywords}}

LlRequestSimulatorData

2015-08-22T15:27:37Z

Dora Gustafson: Unit for length

{{LSL_Function
|inject-2={{Issues/SVC-2596}}{{Issues/SVC-4921}}{{Issues/BUG-5031}}
|func_id=293|func_sleep=1.0|func_energy=10.0
|func=llRequestSimulatorData
|return_type=key
|return_subtype=handle
|p1_type=string|p1_name=region|p1_desc=Case sensitive region name.
|p2_type=integer|p2_name=data|p2_desc=DATA_* flag
|func_footnote
|func_desc=Requests {{LSLP|data}} about {{LSLP|region}}. When {{LSLP|data}} is available the {{LSLG|dataserver}} event will be raised.
|return_text=for a {{LSLG|dataserver}} event response.
|spec
|caveats=
*There is no DATA_SIM_TYPE or DATA_SIM_MAXPRIMS flags. [[#SVC-4921|SVC-4921]]
|constants={{{!}} {{Prettytable|style=margin-top:0;}}
{{!}}- {{Hl2}}
! colspan="2" {{!}} {{LSL Param|data}} Constant
! Type
! colspan="4" {{!}} Description
{{!}}-
{{LSL_Constants/llRequestedSimulatorData}}
{{!}}}
|examples=Hide objects in PG or unknown regions
<source lang="lsl2">
key gRateingQuery = NULL_KEY ;

show()
{
llSetLinkAlpha( LINK_SET, 1.0, ALL_SIDES );
}//show

hide()
{
llSetLinkAlpha( LINK_SET, 0.0, ALL_SIDES );
}//hide

default
{
on_rez(integer Setting)
{
llResetScript();
}//on_rez

state_entry()
{
gRateingQuery = llRequestSimulatorData( llGetRegionName(), DATA_SIM_RATING );
}//state_entry

changed(integer ItChanged)
{
if (ItChanged & CHANGED_OWNER) llResetScript();
if (ItChanged & CHANGED_REGION) llResetScript();
}//changed

dataserver(key query_id, string data)
{
if (query_id == gRateingQuery)
{
if (data == "MATURE" || data == "ADULT") show();
else if (data == "UNKNOWN" || data == "PG") hide();
}//gRateingQuery
}//dataserver

}//default
</source>
|helpers
|also_functions=
{{LSL DefineRow||[[llGetParcelDetails]]|}}
{{LSL DefineRow||[[llGetParcelFlags]]|}}
{{LSL DefineRow||[[llGetParcelMaxPrims]]|}}
{{LSL DefineRow||[[llGetParcelPrimCount]]|}}
|also_tests=
{{LSL DefineRow||[[llRequestSimulatorData Test]]}}
|also_events
|also_articles
|notes=Global Position in meters
|issues
|cat1=Dataserver
|cat2=Region
|cat3
|cat4
}}

LlInstantMessage

2015-02-18T18:07:52Z

Dora Gustafson:

{{LSL_Function
|inject-2={{Issues/SVC-92}}{{LSL_Function/avatar|user}}{{LSL_Function/chat||message}}
|func_id=118|func_sleep=2.0|func_energy=10.0
|func=llInstantMessage
|p1_type=key|p1_name=user|p1_desc
|p2_type=string|p2_name=message|p2_desc
|func_desc=Sends an Instant Message specified in the string {{LSLP|message}} to the user specified by {{LSLP|user}}.
|func_footer=To send a message directly to an object, use [[llRegionSayTo]].
|return_text
|spec
|caveats=
* All object IM's are throttled at a maximum of 2500 per 30mins, per owner, per region in a rolling window. this includes IM's sent after the throttle is in place
** Throttled IM's are dropped. for implementation see [[llInstantMessage#notes|notes]] below
* Messages longer than 1175 bytes will be truncated to 1175 bytes. This can convey 1175 ASCII characters, or fewer if non-ASCII characters are present.
{{KBcaution|width=100%|The 1175 byte limit is changing. As of Feb 26th, 2013 in all sims, Instant messages are now truncated to 1023 bytes to prevent certain types of delivery failure. (see https://wiki.secondlife.com/wiki/Release_Notes/Second_Life_Server/13#13.02.15.270481 ).}}
*{{LSLP|message}} will appear in the chat window and will not logged by the InstantMessage logging facility. (If a the specified user is not signed in, the messages will be delivered to their email just like a regular instant message, if the user has enabled email for their account.)

|examples=Tell the owner somebody touched the object:
<source lang="lsl2">
default
{
touch_start( integer total_num )
{
llInstantMessage( llGetOwner(), "Someone touched me" );
}
}</source>
Send an IM to a detected avatar only
<source lang="lsl2">
default
{
touch_start( integer total_num )
{
llInstantMessage( llDetectedKey(0), "Hands Off!");
}
}
</source>
|helpers
|also_functions=
{{LSL DefineRow||[[llOwnerSay]]|Sends chat region wide to owner}}
{{LSL DefineRow||[[llRegionSay]]|Sends chat region wide}}
{{LSL DefineRow||[[llRegionSayTo]]|Sends chat region wide to a specific prim/avatar}}
{{LSL DefineRow||[[llWhisper]]|Sends chat limited to 10 meters}}
{{LSL DefineRow||[[llSay]]|Sends chat limited to 20 meters}}
{{LSL DefineRow||[[llShout]]|Sends chat limited to 100 meters}}
|also_tests
|also_articles
|also_events
|notes=
* [[llRegionSayTo]] may be a better choice if the target is in the same region as the object sending the message, as it has no built-in delay and can communicate directly with objects, as well as with avatars and their attachments.
* Instant Messaging allows communication from an object to an avatar anywhere on the Grid. However, an object cannot receive an Instant Message.
* Using [[llInstantMessage]] from one or more child scripts will avoid delays in the main script. Child scripts will still be subject to delays, [[LSL Event Queue|message queue]] limits, and region throttles.
* Throttling Implementation (Kelly Linden):
** The throttle is on all IMs from the object owner. It does not disable all IMs in the region, but does disable all IMs from the owner of the object.
** The throttle is not per object, but per owner. Splitting the spamming object into multiple objects will not help unless owned by different people. This also means that owning multiple almost too spammy objects will cause you to hit the limit.
** 2500 IMs in 30 minutes will trigger the block.
** IMs that are blocked continue to count against the throttle. The IM count must drop below 2500 before any IMs will be delivered.
** The IM count of the previous window is used to approximate the rolling window. If it is 20% into the current window the IM count will be the current count + 80% of the previous count. This allows us to approximate a rolling average, however it has the behavior that a flood of IMs can have an effect on the throttle for double the window length. This is why in practice the throttle behaves more like 5k in 1hr than 2.5k in 30min.

|cat1=Communications
|cat2=Instant Message
|cat3
|cat4
}}

User:Dora Gustafson/talking die

2015-01-22T20:57:37Z

Dora Gustafson: /* The Talking Die script */

{{LSL Header}}
==The Talking Die script==
Place this script in a cube and you have a Die.<br>
The Die will say how many pips are on the upward face, after the Die is tossed.
<source lang="lsl2">
/////
// The talking Die script, studio Dora, Dora Gustafson 2008
// v1.20 Basics
/////
// Place this script in a cube and you have a Die.
// The Die will say how many pips are up after it is tossed.
// Free ware! feel free to utilize this script
// and texture, partially or as a whole
// Please give credit to the creator: Dora Gustafson
// You can do that by keeping this header unchanged
/////

list pr;
string dieTexture = "b88d3ced-e298-83d7-7da6-e130a337b6ac"; // terning 2x6 SD.png

string pips_up()
{
vector u = llRot2Fwd( llGetRot() );
vector v = llRot2Left( llGetRot() );
vector w = llRot2Up( llGetRot() );

// Vectors associated with die pip numbers
list pips_list = [ u.z, 1, -u.z, 6, v.z, 2, -v.z, 5, w.z, 3, -w.z, 4 ];
// sort for the one with the biggest Z (vertical up) component,
// the associated pip number is upward
return llList2String( llListSort( pips_list, 2, FALSE ), 1 );
}

default
{
state_entry()
{
llSetPrimitiveParams([
PRIM_TEXTURE, 0, dieTexture, < 0.5, 0.333, 0.0>, < 0.75, -0.333, 0.0>, 0.0,
PRIM_TEXTURE, 1, dieTexture, < 0.5, 0.333, 0.0>, < -0.75, 0.0, 0.0>, 0.0,
PRIM_TEXTURE, 2, dieTexture, < 0.5, 0.333, 0.0>, < 0.75, 0.333, 0.0>, 0.0,
PRIM_TEXTURE, 3, dieTexture, < 0.5, 0.333, 0.0>, < 0.75, 0.0, 0.0>, 0.0,
PRIM_TEXTURE, 4, dieTexture, < 0.5, 0.333, 0.0>, < -0.75, 0.333, 0.0>, 0.0,
PRIM_TEXTURE, 5, dieTexture, < 0.5, 0.333, 0.0>, < -0.75, -0.333, 0.0>, 0.0 ]);
llSetStatus( STATUS_PHYSICS, TRUE );
llSetBuoyancy( 0.5 );
}

collision_start(integer n)
{
llSetTimerEvent( 2.0 );
pr = llGetPrimitiveParams([PRIM_POSITION, PRIM_ROTATION ]);
}

land_collision_start(vector v)
{
llSetTimerEvent( 2.0 );
pr = llGetPrimitiveParams([PRIM_POSITION, PRIM_ROTATION ]);
}

timer()
{
list prnu = llGetPrimitiveParams([PRIM_POSITION, PRIM_ROTATION ]);
if ( pr == prnu )
{
llSetTimerEvent( 0.0 );
llWhisper( PUBLIC_CHANNEL, pips_up() + " pips" );
}
else pr = prnu;
}
}</source>
{{LSLC|Library}}

User:Dora Gustafson/llAxes2Rot right and wrong

2015-01-22T20:56:34Z

Dora Gustafson: /* llAxes2Rot right and wrong */

{{LSL Header}}
==llAxes2Rot right and wrong==
Does it matter if all three vectors are mutually orthogonal unit vectors?<br>
I made a test script to satisfy my own curiosity:
<source lang="lsl2">
key model;
integer tog=0;
vector lookat;

rotation Vec2RotBastard( vector V )
{
vector UP = < 0.0, 0.0, 1.0 >;
vector LEFT = llVecNorm(UP%V);
return llAxes2Rot(V, LEFT, UP);
// demand for orthogonal, unit vectors is not fulfilled in general:
// V is a unit vector in special cases only
// UP and V are orthogonal in special cases only
}

rotation Vec2RotNorm( vector V )
{
V = llVecNorm( V );
vector UP = < 0.0, 0.0, 1.0 >;
vector LEFT = llVecNorm(UP%V);
return llAxes2Rot(V, LEFT, UP);
// demand for orthogonal vectors is not fulfilled in general:
// UP and V are orthogonal in special cases only
}

rotation Vec2RotTrue( vector V )
{
V = llVecNorm( V );
vector UP = < 0.0, 0.0, 1.0 >;
vector LEFT = llVecNorm(UP%V);
UP = llVecNorm(V%LEFT); // you want to keep the direction of V
return llAxes2Rot(V, LEFT, UP);
}

rotation Vec2RotHor( vector V )
{
V = llVecNorm( V );
vector UP = < 0.0, 0.0, 1.0 >;
vector LEFT = llVecNorm(UP%V);
V = llVecNorm(LEFT%UP); // you want V confined to the horizontal plane
return llAxes2Rot(V, LEFT, UP);
}

default
{
touch_end(integer n)
{
llSetTimerEvent( 4.0 );
model = llDetectedKey(0);
}

timer()
{
lookat = llList2Vector( llGetObjectDetails( model, [OBJECT_POS]), 0 );
if ( lookat != ZERO_VECTOR )
{
if ( !tog )
{
llSetColor ( <1.0, 0.2, 0.0>, ALL_SIDES );
llSetRot( Vec2RotBastard( lookat - llGetPos()));
}
else if ( tog == 1 )
{
llSetColor ( <1.0, 1.0, 0.0>, ALL_SIDES );
llSetRot( Vec2RotNorm( lookat - llGetPos()));
}
else if ( tog == 2 )
{
llSetColor ( <0.4, 1.0, 0.0>, ALL_SIDES );
llSetRot( Vec2RotTrue( lookat - llGetPos()));
}
else if ( tog == 3 )
{
llSetColor ( <0.0, 0.6, 1.0>, ALL_SIDES );
llSetRot( Vec2RotHor( lookat - llGetPos()));
}
tog = ++tog % 4;
}
else
{
llSetColor ( <0.0, 0.0, 0.0>, ALL_SIDES );
llSetTimerEvent( 0.0 );
}
}
}
</source>
How to use:
rezz a prim say x,y,z = 5.0, 0.2, 0.2 meters, put he script in and touch the prim.
It will point you for 4 sec with each routine in turn.
Move around and fly up to see where the prim will point.<br>
Each routine will color the prim its own color:
* Red: "Bastard" routine, Not unit and not orthogonal.
* Yellow: "Norm" routine, unit vectors but not orthogonal.
* Green: "True" routine, true direction, the demands are met.
* Blue: "Hor" routine, direction in the horizontal plane only, the demands are met.

User:Dora Gustafson/point tracker

2015-01-22T20:55:10Z

Dora Gustafson:

<div id="box">
== KFM Key framed Motion forward on a closed track ==
<source lang="lsl2">
// point tracker script by Dora Gustafson, Studio Dora 2011
// The objct follows a path given by a number of points beginning with the object's position == <0,0,0>
// The path is closed so it ends where it begins
// Points prim's X-axis forward along the path and it's Y-axis is always horizontal
// v1.01 simplified for focus
// v1.02 with 'refFrame' like in vehicles, to change what is forward
// Translation divided in a straight one and one including a rotation
// Object forward can either be horizontal or follow path forward up and down
// v1.02.1 For WIKI. RefFrame inverted. Track is relative to where script is reset

float speed=2.0; // m/S
float straight=0.75; // part to travel without turning. 0.0 <= straight < 1.0
integer horz=FALSE; // TRUE object forward horizontal no matter if the track goes up or down
list track=[<0,0,0>,<4,0,0>,<4,5,2>,<0,5,2>]; // list of points to track; must have at least 2 elements
rotation refFrame=<0.0, 0.0, 0.0, 1.0>;
list KFMlist;
vector basePos;
integer i;
integer j;
integer k;
integer L;
vector U;
vector V;
vector W;
vector LEFT=< 0.0, 1.0, 0.0 >;

rotation Vec2Rot( vector FWD )
{
FWD = llVecNorm( FWD );
vector UP = < 0.0, 0.0, 1.0 >;
if ( llFabs(FWD.z) < 1.0 ) LEFT = llVecNorm(UP%FWD);
if (horz) FWD = llVecNorm(LEFT%UP);
else UP = llVecNorm(FWD%LEFT);
return llAxes2Rot(FWD, LEFT, UP);
}

default
{
state_entry()
{
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]); // make client mesh-aware
refFrame.s = -refFrame.s;
basePos = llGetPos();
L = llGetListLength(track);
KFMlist = [];
for ( i=0; i<L; i++)
{
j = (i+1) % L;
V = llList2Vector( track, j)-llList2Vector( track, i);
U = straight*V;
KFMlist += [U, ZERO_ROTATION, 0.1+llVecMag(U)/speed];
k = (j+1) % L;
W = llList2Vector( track, k)-llList2Vector( track, j);
KFMlist += [V-U, refFrame*Vec2Rot(W)/(refFrame*Vec2Rot(V)), 0.1+llVecMag(V-U)/speed];
}
}
touch_end(integer n)
{
llSetPrimitiveParams([PRIM_POSITION, basePos, PRIM_ROTATION, refFrame*Vec2Rot(llList2Vector( track, 1)-llList2Vector( track, 0))]);
llSetKeyframedMotion( KFMlist, []);
}
}
</source>
</div>
{{LSLC|Library}}

User:Dora Gustafson/Basic Resizer

2015-01-22T20:54:01Z

Dora Gustafson:

===The purpose is to resize a linkset/object using a single script===
The script is simple and does not meet special requests, but it can be used and it will work in big attached objects, like flexi skirts and prim hair as well as in non attached builds.<br>
The script can resize large link sets. It is small and doesn't keep long lists.<br>
It will take up 14000 bytes when compiled for MONO and 16 Kbytes when compiled for LSO
<source lang="lsl2">// resize script by Dora Gustafson, Studio Dora 2010
// Free for anybody to read, copy, modify, compile, use, rip apart, trample on and flush
// The script is open source and free. As so it is not supported in any way
// NOTE: only for SL server v1.38 and later
// Place in prim or linkset in order to resize
// Must run in root prim
// resizer v1.0 No check or precautions against dimensions out of limits
// resizer v1.1 Test if new dimensions are within limts [0.01;10.0]m If not, resize is cancelled
// resizer v1.2 Added kill script button
// resizer v1.3 Added llListenRemove() for low lag
// resizer v1.4 Added Current relative size display
// resizer v1.5 Added rounding for size display
// resizer v1.6 Reversible resize increments
// resizer v1.7 changed to accept 64m max prim size, limits [0.01;64.0]m
// resizer v1.8 minimized memory impact when compiled for mono

integer dialogChanal;
list USER_MENU = [ "Size@Rez", "Size@Buy", "Kill Script", "-1.96..%", "-4.76..%", "-9.09..%", "+2%", "+5%", "+10%" ];
string uDialogP = "•Resize\n•Set to Size at Rez\n•Set to Size at Buy";

float fabsizeX;
float rezsizeX;
vector rs;
float listenTimeout=1800.0; // seconds
integer listenHandle;

open_dialog( vector vr )
{
string s="Size is "+(string)(llRound(100.0*vr.x/fabsizeX))+" %\n";
llDialog( llGetOwner(), s+uDialogP, USER_MENU, dialogChanal);
llSetTimerEvent(listenTimeout);
}

integer dimTest( vector vr )
{
return !( vr.x<0.01 || vr.y<0.01 || vr.z<0.01 || vr.x>64.0 || vr.y>64.0 || vr.z>64.0 );
}

primloop( float scal )
{
integer primindx;
integer validDim=TRUE;
list primP;

if (llGetNumberOfPrims()<2) validDim = validDim && dimTest( scal*llGetScale());
else
for ( primindx = 1; primindx <= llGetNumberOfPrims(); primindx++ )
{
primP = llGetLinkPrimitiveParams( primindx, [PRIM_SIZE]);
validDim = validDim && dimTest( scal*llList2Vector( primP, 0 ));
}

if ( validDim )
{
if (llGetNumberOfPrims()<2) llSetScale( scal*llGetScale()); // not linked prim
else
for ( primindx = 1; primindx <= llGetNumberOfPrims(); primindx++ )
{
primP = llGetLinkPrimitiveParams( primindx, [PRIM_SIZE, PRIM_POSITION]);
vector primScale = scal*llList2Vector( primP, 0 );
vector primPos = scal*(llList2Vector( primP, 1 )-llGetPos());
if ( primindx == 1 ) llSetLinkPrimitiveParamsFast( primindx, [PRIM_SIZE, primScale]);
else llSetLinkPrimitiveParamsFast( primindx, [PRIM_SIZE, primScale, PRIM_POSITION, primPos/llGetRootRotation()]);
}
}
else llOwnerSay("No resize! Out of limit sizes are not accepted");
}

default
{
state_entry()
{
llSetMemoryLimit(14000); // memory required
rs = llGetScale();
fabsizeX = rs.x;
rezsizeX = fabsizeX;
llOwnerSay("Size at buy is set to Current size");
}
on_rez( integer p)
{
rs = llGetScale();
rezsizeX = rs.x;
}
touch_end(integer n)
{
if (llDetectedKey(0) == llGetOwner())
{
dialogChanal = (integer)llFrand( 8388608.0 ) + 0x80000000;
llListenRemove(listenHandle);
listenHandle = llListen( dialogChanal, "", llGetOwner(), "");
open_dialog(llGetScale());
}
}
listen(integer cannel, string name, key id, string message)
{
if ( message == "Kill Script" ) llRemoveInventory( llGetScriptName());
else
{
rs = llGetScale();
if ( message == "+2%" ) primloop( 1.02);
else if ( message == "+5%" ) primloop( 1.05);
else if ( message == "+10%" ) primloop( 1.1);
else if ( message == "-1.96..%" ) primloop( 1.0/1.02);
else if ( message == "-4.76..%" ) primloop( 1.0/1.05);
else if ( message == "-9.09..%" ) primloop( 1.0/1.1);
else if ( message == "Size@Rez" ) primloop( rezsizeX/rs.x);
else if ( message == "Size@Buy" ) primloop( fabsizeX/rs.x);
open_dialog(llGetScale());
}
}
timer()
{
llListenRemove(listenHandle);
llSetTimerEvent(0.0);
}
}</source>
{{LSLC|Library}}

User:Dora Gustafson/sundirection and time of day

2015-01-22T20:52:42Z

Dora Gustafson:

{{LSL Header}}{{LSLC|Library}}
<div id="box">
== Show Sun Direction and compare to Time of Day ==
<div style="padding: 0.5em;">
Conclusion when compared to the ''Windlight default day cycle'':
* When the SunDirection vector is confined to the X-Z plane(Ecliptic) the result matches fairly well what is seen.
* The moon direction is not always opposite the sun direction.
* When the east point in Windlight is moved the SunDirection vector doesn't move with it.
* The often used method of using the Z component to separate day from night is very rough. Sunset and sunrise are both (equivalent)hours from where the sign of Z changes.
<source lang="lsl2">
// sun pointer script by Dora Gustafson, Studio Dora 2012
// Will point the prim's FWD in the SunDirection
// Will show the SunDirection vector and the equivalent real day hour
// vertical ecliptic matches the default day cycle sun in windlight

float sd_Rate=10.0;
integer vertical=TRUE; // vertical ecliptic

rotation Vec2Rot( vector FWD )
{
FWD = llVecNorm( FWD );
vector UP = < 0.0, 1.0, 0.0 >;
vector LEFT = llVecNorm(UP%FWD);
if (vertical) FWD = llVecNorm(LEFT%UP);
else UP = llVecNorm(FWD%LEFT);
return llAxes2Rot(FWD, LEFT, UP);
}

default
{
state_entry()
{
llSetTimerEvent(sd_Rate);
}
timer()
{
llSetRot( Vec2Rot( llGetSunDirection()));
float secs = 6.0*llGetTimeOfDay(); // multiply by 6 to show the equivalent real day hour
integer minutes = ((integer)secs/60)%60;
integer hours = (integer)secs/3600;
llSetText("Sundirection: "+(string)llGetSunDirection()+"\nSim Time: "+(string)hours+"H "+(string)minutes+"M", <1.0,1.0,1.0>, 1.0);
}
}
</source>
</div>
</div>

User:Dora Gustafson/universal hinged motion

2015-01-22T20:51:27Z

Dora Gustafson:

== Universal hinged motion in 8 key frames ==
Using [[LlSetKeyframedMotion|llSetKeyFramedMotion()]]
<source lang="lsl2">
// Universal hinged motion by Dora Gustafson, Studio Dora 2012
// will turn a box prim around one edge parallel to the prim's Y-axis
// for any prim orientation
// note that the smallest accepted time per frame is 1/9=0.11111111 and NOT 0.1
// v1.03 tuned for wiki
// v1.04 time tuning

float angleEnd=PI_BY_TWO;
float speed=0.2; // m/S
float steps=8.0; // number of Key Frames
float step=0.0;
list KFMlist=[];
vector V;
integer open=TRUE;
vector basePos;
rotation baseRot;

float motion_time( float mt)
{
mt = llRound(45.0*mt)/45.0;
if ( mt > 0.11111111 ) return mt;
else return 0.11111111;
}

default
{
state_entry()
{
llSetMemoryLimit(0x2000);
llOwnerSay((string)llGetFreeMemory());
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]);
basePos = llGetPos();
baseRot = llGetRot();
vector v1 = 0.5*llGetScale()*llGetRot();
rotation deltaRot = llEuler2Rot(< 0.0, angleEnd/steps, 0.0>);
while ( step < steps )
{
V = v1*llAxisAngle2Rot(llRot2Left(llGetRot()), angleEnd*step/steps);
V = v1*llAxisAngle2Rot(llRot2Left(llGetRot()), angleEnd*(step+1.0)/steps) - V;
KFMlist += [V, deltaRot, motion_time(llVecMag(V)/speed)];
step += 1.0;
}
}
touch_end( integer n)
{
llSetKeyframedMotion( [], []);
if ( open )
{
llSetPrimitiveParams([PRIM_POSITION, basePos, PRIM_ROTATION, baseRot]);
llSetKeyframedMotion( KFMlist, []);
}
else
{
llSetKeyframedMotion( KFMlist, [KFM_MODE, KFM_REVERSE]);
}
open = !open;
}
on_rez( integer n) { llResetScript(); }
}
</source>
After editing prim position, rotation and/or size the script should be reset in order to update the motion
{{LSLC|Library}}

User:Dora Gustafson/Pendulum motion

2015-01-22T20:50:23Z

Dora Gustafson:

<div id="box">
==Simple Pendulum Motion in 24 Key Frames==
=====Swing script=====
Will swing a prim like a simple pendulum pivoting at an axis parallel to the prim's Y-axis<br>
The pivot axis will be at the top of a prim with the Z-axis pointing up<br>
Quote from [http://en.wikipedia.org/wiki/Pendulum_(mathematics) Wikipedia]
A simple pendulum is an idealization of a real pendulum using the following assumptions:
The rod or cord on which the bob swings is massless, inextensible and always remains taut;
Motion occurs only in two dimensions, i.e. the bob does not trace an ellipse but an arc.
The motion does not lose energy to friction or air resistance.
The periode time increase with the Z dimension (the pendulum length)...<br>
If it is too small the motion will not be well because of the time limitation with Key Framed Motions<br>
The parameters set in the script works nice with a 3m long pendulum<br>
If the pendulum is moved, rotated or resized the script must be reset to update the motion<br>
<source lang="lsl2">
// Pendulum motion by Dora Gustafson, Studio Dora 2012
// Will swing a prim like a simple pendulum pivoting at an axis parallel to the prim's Y-axis
// The pivot axis will be at the top of a prim with the Z-axis pointing up
// Quote from http://en.wikipedia.org/wiki/Pendulum_(mathematics)
// • A simple pendulum is an idealization of a real pendulum using the following assumptions:
// • The rod or cord on which the bob swings is massless, inextensible and always remains taut;
// • Motion occurs only in two dimensions, i.e. the bob does not trace an ellipse but an arc.
// • The motion does not lose energy to friction or air resistance.
// The periode time increase with the Z dimension (the pendulum length)...
// If it is too small the motion will not be well because of the time limitation with Key Framed Motions
// The parameters set in the script works nice with a 3m long pendulum
// If the pendulum is moved, rotated or resized the script must be reset to update the motion

float angle=0.2; // max swing from resting (radians)
float steps=24.0; // number of Key Frames
float step=0.0;
list KFMlist=[];
vector U;
vector V;
float angleU=0.0;
float angleV;
integer swing=TRUE;
vector basePos;
rotation baseRot;

default
{
state_entry()
{
llSetMemoryLimit( llGetUsedMemory()+0x1000);
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]);
basePos = llGetPos();
baseRot = llGetRot();
vector v1 = llGetScale();
float periode = TWO_PI*llSqrt( v1.z/9.81);
float dT = periode/steps;
dT = llRound(45.0*dT)/45.0;
if ( dT < 0.11111111 ) dT = 0.11111111;
v1.x = 0.0;
v1.y = 0.0;
v1 = -0.5*v1*llGetRot();
U = v1;
while ( step < steps )
{
step += 1.0;
angleV = angle*llCos( TWO_PI*step/steps + PI_BY_TWO);
V = v1*llAxisAngle2Rot(llRot2Left(llGetRot()), angleV);
KFMlist += [V-U, llEuler2Rot(< 0.0, angleV-angleU, 0.0>), dT];
angleU = angleV;
U = V;
}
}
touch_start( integer n)
{
llSetKeyframedMotion( [], []);
llSleep(0.2);
llSetPrimitiveParams([PRIM_POSITION, basePos, PRIM_ROTATION, baseRot]);
if ( swing ) llSetKeyframedMotion( KFMlist, [ KFM_MODE, KFM_LOOP]);
swing = !swing;
}
on_rez( integer n) { llResetScript(); }
}</source>
</div>
{{LSLC|Library}}

User:Dora Gustafson/Harmonic Oscillator motion

2015-01-22T20:49:13Z

Dora Gustafson:

<div id="box">
==Harmonic oscillator motion in 12 Key Frames==
Will oscillate a prim along a straight line in space<br>
Only the first half period is computed, the second is the first in reverse<br>
If the prim is moved or scaled the script must be reset to update the motion<br>
<source lang="lsl2">
// Harmonic oscillator motion by Dora Gustafson, Studio Dora 2012
// will oscillate a prim along a straight line in space
// only the first half period is computed, the second is the first in reverse

float phase=PI;
vector amplitude=< 0.0, 0.0, 2.0>; // amplitude and direction for oscillation
float Hperiode=2.0; // half periode time S
float steps=12; // number of Key Frames for a half periode
float step=0.0;
list KFMlist=[];
vector U;
vector V;
integer osc=TRUE;
vector basePos;

default
{
state_entry()
{
llSetMemoryLimit( llGetUsedMemory()+0x1000);
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]);
basePos = llGetPos();
float dT = Hperiode/steps;
dT = llRound(45.0*dT)/45.0;
if ( dT < 0.11111111 ) dT = 0.11111111;
U = amplitude*llCos( phase);
while ( step < steps )
{
step += 1.0;
V = amplitude*llCos( PI*step/steps + phase);
KFMlist += [V-U, dT];
U = V;
}
}
touch_start( integer n)
{
llSetKeyframedMotion( [], []);
llSleep(0.2);
llSetRegionPos( basePos);
llSetPos( basePos);
if ( osc ) llSetKeyframedMotion( KFMlist, [KFM_DATA, KFM_TRANSLATION, KFM_MODE, KFM_PING_PONG]);
osc = !osc;
}
on_rez( integer n) { llResetScript(); }
}
</source>
</div>
{{LSLC|Library}}

User:Dora Gustafson/captureCameraView

2015-01-22T20:48:03Z

Dora Gustafson: /* Capture Camera View */

<div id="box">
==llSetLinkCamera() Example==
=====Capture Camera View=====
<source lang="lsl2">
// camera capture/release test, script by Dora Gustafson, Studio Dora 2012
// v1.1
// save script in prim
// sit on the prim
// move camera
// touch the prim to capture camera view or release capture

integer gag = FALSE;

default
{
state_entry()
{
llSitTarget( < 0.25, 0.0, 0.6 >, ZERO_ROTATION);
llSetClickAction(CLICK_ACTION_SIT);
llOwnerSay("To verify: stand up, press Esc, sit down and try to move the camera by the arrow keys");
}
touch_end(integer num)
{
gag = !gag;
if (gag) llRequestPermissions( llGetOwner(), PERMISSION_TRACK_CAMERA);
else
{
llSetLinkCamera( LINK_THIS, ZERO_VECTOR, ZERO_VECTOR);
llOwnerSay("Capture released");
}
}
run_time_permissions(integer perm)
{
if( perm & PERMISSION_TRACK_CAMERA)
{
rotation cam_rot=llGetCameraRot()/llGetRot(); // relative camera rotation
vector cam_pos=(llGetCameraPos()-llGetPos())/llGetRot(); // relative camera position
llSetLinkCamera( LINK_THIS, cam_pos, cam_pos + llRot2Fwd(cam_rot));
llOwnerSay("Camera view captured");
}
}
}
</source>
{{LSLC|Library}}

User:Dora Gustafson/llRotBetween alternatives

2015-01-22T20:46:07Z

Dora Gustafson: /* Scripts and functions */

<div id="box">
==llRotBetween, some alternatives and considerations==
=====Scope=====
Four functions are covered, They are
# llRotBetween( vector a, vector b); // The built in function
# RotBetween( vector a, vector b); // The replacement outlined in the wiki
# rotV2V( vector a, vector b); // The shortest replacement
# rotbetween( vector a, vector b); // Using a ''Vector to rotation'' function

=====Tests=====
First the rotations provided by functions were compared and they didn't compare at all.
: Testing rotations is a bad idea since there is no single solution to the question, but an infinite number of solutions.
: All 4 functions provide valid, but different rotations.
So the sensible thing to do is to test how the solution rotates a vector:

== Test with random, normalized vectors ==

<source lang="lsl2">
cycles = 0;
record = [];
while ( cycles++ < nLimit && llGetListLength( record) < 30)
{
u = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, llFrand( 2.0)-1.0 >);
v = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, llFrand( 2.0)-1.0 >);
solution = rotbetween( u, v);
if ( llVecDist( u*solution, v) > epsilon ) record += [cycles, u, v];
}</source>
<table style="width: 800px;" border="1" cellpadding="2"
cellspacing="2">
<tr>
<th style="text-align: center;" colspan="1"
rowspan="2">Errors / test cycles</th>
<th style="text-align: center;">Function 1</th>
<th style="text-align: center;">Function 2</th>
<th style="text-align: center;">Function 3</th>
<th style="text-align: center;">Function 4</th>
</tr>
<tr>
<th style="text-align: center;">llRotBetween</th>
<th style="text-align: center;">RotBetween</th>
<th style="text-align: center;">rotV2V</th>
<th style="text-align: center;">rotbetween</th>
</tr>
<tr>
<th style="text-align: center;" colspan="1"
rowspan="3">abs error > 1e-7</th>
<td style="text-align: right;"> 10 / 13</td>
<td style="text-align: right;"> 10 / 18</td>
<td style="text-align: right;"> 10 / 15</td>
<td style="text-align: right;"> 10 / 16</td>
</tr>
<tr>
<td style="text-align: right;"> 10 / 14</td>
<td style="text-align: right;"> 10 / 21</td>
<td style="text-align: right;"> 10 / 22</td>
<td style="text-align: right;"> 10 / 23</td>
</tr>
<tr>
<td style="text-align: right;"></td>
<td style="text-align: right;"> 10 / 27</td>
<td style="text-align: right;">10 / 14</td>
<td style="text-align: right;"> 10 / 13</td>
</tr>
<tr>
<th style="text-align: center;" colspan="1"
rowspan="3">abs error > 1e-6</th>
<td style="text-align: right;"> 7 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
</tr>
<tr>
<td style="text-align: right;"> 3 / 1000</td>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"> 1 / 10000</td>
<td style="text-align: right;"> 0 / 10000</td>
</tr>
<tr>
<td style="text-align: right;"> 8 / 1000</td>
<td style="text-align: right;"></td>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"></td>
</tr>
</table>

== Test with close to parallel and anti parallel vectors ==
<source lang="lsl2">
cycles = 0;
record = [];
while ( cycles++ < nLimit && llGetListLength( record) < 30)
{
u = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, llFrand( 2.0)-1.0 >);
v = < llFrand( 2E-3)-1E-3, llFrand( 2E-3)-1E-3, llFrand( 2E-3)-1E-3 >;
if ( llFrand(1.0) < 0.5 ) v -= u;
else v += u;
solution = rotbetween( u, v);
if ( llVecDist( u*solution, v) > epsilon ) record += [cycles, u, v];
}</source>
<table style="width: 800px;" border="1" cellpadding="2"
cellspacing="2">
<tr>
<th style="text-align: center;" colspan="1"
rowspan="2">Errors / test cycles</th>
<th style="text-align: center;">Function 1</th>
<th style="text-align: center;">Function 2</th>
<th style="text-align: center;">Function 3</th>
<th style="text-align: center;">Function 4</th>
</tr>
<tr>
<th style="text-align: center;">llRotBetween</th>
<th style="text-align: center;">RotBetween</th>
<th style="text-align: center;">rotV2V</th>
<th style="text-align: center;">rotbetween</th>
</tr>
<tr>
<th style="text-align: center;" colspan="1"
rowspan="3">abs error > 1e-3</th>
<td style="text-align: right;"> 10 / 16</td>
<td style="text-align: right;"> 10 / 98</td>
<td style="text-align: right;"> 10 / 222</td>
<td style="text-align: right;"> 10 / 192</td>
</tr>
<tr>
<td style="text-align: right;"> 10 / 15</td>
<td style="text-align: right;"> 10 / 96</td>
<td style="text-align: right;"> 10 / 89</td>
<td style="text-align: right;"> 10 / 164</td>
</tr>
<tr>
<td style="text-align: right;"> 10 / 27</td>
<td style="text-align: right;"> 10 / 109</td>
<td style="text-align: right;">10 / 99</td>
<td style="text-align: right;"> 10 / 75</td>
</tr>
<tr>
<th style="text-align: center;" colspan="1"
rowspan="2">abs error > 1e-2</th>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
</tr>
<tr>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"> 0 / 10000</td>
</tr>
</table>

== Conclusion ==
Functions 2, 3 and 4 have similar performances.
Function 1, the built-in, has a lower performance.<br>
All four functions are very good except with parallel and anti parallel vectors.<br>
The rotation found is not always what you expect.<br>
: The rotation will point a vector in the right direction, i.e. the rotation's ''forward'' is the vector direction.
: See [[User:Dora_Gustafson/llRotBetween_alternatives#About_the_function.27s_nature|note]] about the functions nature
: Function 4 is different, the solution will map a rotation with ''left'' in the horizontal plane

== Scripts and functions ==
;Function 1, llRotBetween( vector a, vector b)
: This is the built in function, see [[LlRotBetween|llRotBetween]]
: See [[User:Dora_Gustafson/llRotBetween_alternatives#About_the_function.27s_nature|note]] about the functions nature
;Function 2, RotBetween( vector a, vector b)
: This is the suggested [[LlRotBetween#Replacement|Replacement]] for llRotBetween
: See [[User:Dora_Gustafson/llRotBetween_alternatives#About_the_function.27s_nature|note]] about the functions nature
;Function 3, rotV2V( vector a, vector b)
<source lang="lsl2">rotation rotV2V( vector a, vector b)
{
a = llVecNorm(a);
b = llVecNorm(b);
vector c = b;
while ( llFabs(a*c) > 0.999999 ) c = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, llFrand( 2.0)-1.0 >);
c = llVecNorm(a%c);
return ZERO_ROTATION/llAxes2Rot( a, c, a%c)*llAxes2Rot( b, c, b%c);
}
</source>
: See [[User:Dora_Gustafson/llRotBetween_alternatives#About_the_function.27s_nature|note]] about the functions nature

;Function 4, rotbetween( vector a, vector b)
<source lang="lsl2">rotation Vec2Rot( vector a)
{
a = llVecNorm(a);
vector c = < 0.0, 0.0, 1.0 >;
if ( llFabs(a*c) > 0.999999 ) c = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, 0.0 >);
vector b = llVecNorm(c%a);
return llAxes2Rot( a, b, a%b);
}

rotation rotbetween( vector a, vector b)
{
return ZERO_ROTATION/Vec2Rot(a)*Vec2Rot(b);
}
</source>
: Returns a solution that will map a rotation with ''left'' in the horizontal plane. This is convenient for cameras and prims you don't want tilted
----

==About the function's nature==
The function determines a rotation (quaternion) which can map a vector onto another.
: It does nothing else, which means that there are no conditions on the other vectors associated with a rotation in space.
When the solution is used to rotate a body in space one should be aware of it’s nature.
: For a prim whose rotation is defined by three orthogonal vectors the forward vector mapping will be correct while the other vector mappings are unpredictable.
: A prim mapping will normally be rotated about the prim’s forward axis in an unpredictable way.
: The prim will be tilted to one side or the other side with respect to the vertical.
There are numerous solutions to the task of finding the rotation between two vectors and all are correct in the sense that they can correctly map one vector onto another.
{{LSLC|Library}}

User:Dora Gustafson/llRotBetween alternatives

2015-01-22T20:44:09Z

Dora Gustafson: /* Test with close to parallel and anti parallel vectors */

<div id="box">
==llRotBetween, some alternatives and considerations==
=====Scope=====
Four functions are covered, They are
# llRotBetween( vector a, vector b); // The built in function
# RotBetween( vector a, vector b); // The replacement outlined in the wiki
# rotV2V( vector a, vector b); // The shortest replacement
# rotbetween( vector a, vector b); // Using a ''Vector to rotation'' function

=====Tests=====
First the rotations provided by functions were compared and they didn't compare at all.
: Testing rotations is a bad idea since there is no single solution to the question, but an infinite number of solutions.
: All 4 functions provide valid, but different rotations.
So the sensible thing to do is to test how the solution rotates a vector:

== Test with random, normalized vectors ==

<source lang="lsl2">
cycles = 0;
record = [];
while ( cycles++ < nLimit && llGetListLength( record) < 30)
{
u = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, llFrand( 2.0)-1.0 >);
v = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, llFrand( 2.0)-1.0 >);
solution = rotbetween( u, v);
if ( llVecDist( u*solution, v) > epsilon ) record += [cycles, u, v];
}</source>
<table style="width: 800px;" border="1" cellpadding="2"
cellspacing="2">
<tr>
<th style="text-align: center;" colspan="1"
rowspan="2">Errors / test cycles</th>
<th style="text-align: center;">Function 1</th>
<th style="text-align: center;">Function 2</th>
<th style="text-align: center;">Function 3</th>
<th style="text-align: center;">Function 4</th>
</tr>
<tr>
<th style="text-align: center;">llRotBetween</th>
<th style="text-align: center;">RotBetween</th>
<th style="text-align: center;">rotV2V</th>
<th style="text-align: center;">rotbetween</th>
</tr>
<tr>
<th style="text-align: center;" colspan="1"
rowspan="3">abs error > 1e-7</th>
<td style="text-align: right;"> 10 / 13</td>
<td style="text-align: right;"> 10 / 18</td>
<td style="text-align: right;"> 10 / 15</td>
<td style="text-align: right;"> 10 / 16</td>
</tr>
<tr>
<td style="text-align: right;"> 10 / 14</td>
<td style="text-align: right;"> 10 / 21</td>
<td style="text-align: right;"> 10 / 22</td>
<td style="text-align: right;"> 10 / 23</td>
</tr>
<tr>
<td style="text-align: right;"></td>
<td style="text-align: right;"> 10 / 27</td>
<td style="text-align: right;">10 / 14</td>
<td style="text-align: right;"> 10 / 13</td>
</tr>
<tr>
<th style="text-align: center;" colspan="1"
rowspan="3">abs error > 1e-6</th>
<td style="text-align: right;"> 7 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
</tr>
<tr>
<td style="text-align: right;"> 3 / 1000</td>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"> 1 / 10000</td>
<td style="text-align: right;"> 0 / 10000</td>
</tr>
<tr>
<td style="text-align: right;"> 8 / 1000</td>
<td style="text-align: right;"></td>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"></td>
</tr>
</table>

== Test with close to parallel and anti parallel vectors ==
<source lang="lsl2">
cycles = 0;
record = [];
while ( cycles++ < nLimit && llGetListLength( record) < 30)
{
u = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, llFrand( 2.0)-1.0 >);
v = < llFrand( 2E-3)-1E-3, llFrand( 2E-3)-1E-3, llFrand( 2E-3)-1E-3 >;
if ( llFrand(1.0) < 0.5 ) v -= u;
else v += u;
solution = rotbetween( u, v);
if ( llVecDist( u*solution, v) > epsilon ) record += [cycles, u, v];
}</source>
<table style="width: 800px;" border="1" cellpadding="2"
cellspacing="2">
<tr>
<th style="text-align: center;" colspan="1"
rowspan="2">Errors / test cycles</th>
<th style="text-align: center;">Function 1</th>
<th style="text-align: center;">Function 2</th>
<th style="text-align: center;">Function 3</th>
<th style="text-align: center;">Function 4</th>
</tr>
<tr>
<th style="text-align: center;">llRotBetween</th>
<th style="text-align: center;">RotBetween</th>
<th style="text-align: center;">rotV2V</th>
<th style="text-align: center;">rotbetween</th>
</tr>
<tr>
<th style="text-align: center;" colspan="1"
rowspan="3">abs error > 1e-3</th>
<td style="text-align: right;"> 10 / 16</td>
<td style="text-align: right;"> 10 / 98</td>
<td style="text-align: right;"> 10 / 222</td>
<td style="text-align: right;"> 10 / 192</td>
</tr>
<tr>
<td style="text-align: right;"> 10 / 15</td>
<td style="text-align: right;"> 10 / 96</td>
<td style="text-align: right;"> 10 / 89</td>
<td style="text-align: right;"> 10 / 164</td>
</tr>
<tr>
<td style="text-align: right;"> 10 / 27</td>
<td style="text-align: right;"> 10 / 109</td>
<td style="text-align: right;">10 / 99</td>
<td style="text-align: right;"> 10 / 75</td>
</tr>
<tr>
<th style="text-align: center;" colspan="1"
rowspan="2">abs error > 1e-2</th>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
</tr>
<tr>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"> 0 / 10000</td>
</tr>
</table>

== Conclusion ==
Functions 2, 3 and 4 have similar performances.
Function 1, the built-in, has a lower performance.<br>
All four functions are very good except with parallel and anti parallel vectors.<br>
The rotation found is not always what you expect.<br>
: The rotation will point a vector in the right direction, i.e. the rotation's ''forward'' is the vector direction.
: See [[User:Dora_Gustafson/llRotBetween_alternatives#About_the_function.27s_nature|note]] about the functions nature
: Function 4 is different, the solution will map a rotation with ''left'' in the horizontal plane

== Scripts and functions ==
;Function 1, llRotBetween( vector a, vector b)
: This is the built in function, see [[LlRotBetween|llRotBetween]]
: See [[User:Dora_Gustafson/llRotBetween_alternatives#About_the_function.27s_nature|note]] about the functions nature
;Function 2, RotBetween( vector a, vector b)
: This is the suggested [[LlRotBetween#Replacement|Replacement]] for llRotBetween
: See [[User:Dora_Gustafson/llRotBetween_alternatives#About_the_function.27s_nature|note]] about the functions nature
;Function 3, rotV2V( vector a, vector b)
<lsl>rotation rotV2V( vector a, vector b)
{
a = llVecNorm(a);
b = llVecNorm(b);
vector c = b;
while ( llFabs(a*c) > 0.999999 ) c = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, llFrand( 2.0)-1.0 >);
c = llVecNorm(a%c);
return ZERO_ROTATION/llAxes2Rot( a, c, a%c)*llAxes2Rot( b, c, b%c);
}
</lsl>
: See [[User:Dora_Gustafson/llRotBetween_alternatives#About_the_function.27s_nature|note]] about the functions nature

;Function 4, rotbetween( vector a, vector b)
<lsl>rotation Vec2Rot( vector a)
{
a = llVecNorm(a);
vector c = < 0.0, 0.0, 1.0 >;
if ( llFabs(a*c) > 0.999999 ) c = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, 0.0 >);
vector b = llVecNorm(c%a);
return llAxes2Rot( a, b, a%b);
}

rotation rotbetween( vector a, vector b)
{
return ZERO_ROTATION/Vec2Rot(a)*Vec2Rot(b);
}
</lsl>
: Returns a solution that will map a rotation with ''left'' in the horizontal plane. This is convenient for cameras and prims you don't want tilted
----

==About the function's nature==
The function determines a rotation (quaternion) which can map a vector onto another.
: It does nothing else, which means that there are no conditions on the other vectors associated with a rotation in space.
When the solution is used to rotate a body in space one should be aware of it’s nature.
: For a prim whose rotation is defined by three orthogonal vectors the forward vector mapping will be correct while the other vector mappings are unpredictable.
: A prim mapping will normally be rotated about the prim’s forward axis in an unpredictable way.
: The prim will be tilted to one side or the other side with respect to the vertical.
There are numerous solutions to the task of finding the rotation between two vectors and all are correct in the sense that they can correctly map one vector onto another.
{{LSLC|Library}}

User:Dora Gustafson/llRotBetween alternatives

2015-01-22T20:43:30Z

Dora Gustafson: /* Test with random, normalized vectors */

<div id="box">
==llRotBetween, some alternatives and considerations==
=====Scope=====
Four functions are covered, They are
# llRotBetween( vector a, vector b); // The built in function
# RotBetween( vector a, vector b); // The replacement outlined in the wiki
# rotV2V( vector a, vector b); // The shortest replacement
# rotbetween( vector a, vector b); // Using a ''Vector to rotation'' function

=====Tests=====
First the rotations provided by functions were compared and they didn't compare at all.
: Testing rotations is a bad idea since there is no single solution to the question, but an infinite number of solutions.
: All 4 functions provide valid, but different rotations.
So the sensible thing to do is to test how the solution rotates a vector:

== Test with random, normalized vectors ==

<source lang="lsl2">
cycles = 0;
record = [];
while ( cycles++ < nLimit && llGetListLength( record) < 30)
{
u = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, llFrand( 2.0)-1.0 >);
v = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, llFrand( 2.0)-1.0 >);
solution = rotbetween( u, v);
if ( llVecDist( u*solution, v) > epsilon ) record += [cycles, u, v];
}</source>
<table style="width: 800px;" border="1" cellpadding="2"
cellspacing="2">
<tr>
<th style="text-align: center;" colspan="1"
rowspan="2">Errors / test cycles</th>
<th style="text-align: center;">Function 1</th>
<th style="text-align: center;">Function 2</th>
<th style="text-align: center;">Function 3</th>
<th style="text-align: center;">Function 4</th>
</tr>
<tr>
<th style="text-align: center;">llRotBetween</th>
<th style="text-align: center;">RotBetween</th>
<th style="text-align: center;">rotV2V</th>
<th style="text-align: center;">rotbetween</th>
</tr>
<tr>
<th style="text-align: center;" colspan="1"
rowspan="3">abs error > 1e-7</th>
<td style="text-align: right;"> 10 / 13</td>
<td style="text-align: right;"> 10 / 18</td>
<td style="text-align: right;"> 10 / 15</td>
<td style="text-align: right;"> 10 / 16</td>
</tr>
<tr>
<td style="text-align: right;"> 10 / 14</td>
<td style="text-align: right;"> 10 / 21</td>
<td style="text-align: right;"> 10 / 22</td>
<td style="text-align: right;"> 10 / 23</td>
</tr>
<tr>
<td style="text-align: right;"></td>
<td style="text-align: right;"> 10 / 27</td>
<td style="text-align: right;">10 / 14</td>
<td style="text-align: right;"> 10 / 13</td>
</tr>
<tr>
<th style="text-align: center;" colspan="1"
rowspan="3">abs error > 1e-6</th>
<td style="text-align: right;"> 7 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
</tr>
<tr>
<td style="text-align: right;"> 3 / 1000</td>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"> 1 / 10000</td>
<td style="text-align: right;"> 0 / 10000</td>
</tr>
<tr>
<td style="text-align: right;"> 8 / 1000</td>
<td style="text-align: right;"></td>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"></td>
</tr>
</table>

== Test with close to parallel and anti parallel vectors ==
<lsl>
cycles = 0;
record = [];
while ( cycles++ < nLimit && llGetListLength( record) < 30)
{
u = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, llFrand( 2.0)-1.0 >);
v = < llFrand( 2E-3)-1E-3, llFrand( 2E-3)-1E-3, llFrand( 2E-3)-1E-3 >;
if ( llFrand(1.0) < 0.5 ) v -= u;
else v += u;
solution = rotbetween( u, v);
if ( llVecDist( u*solution, v) > epsilon ) record += [cycles, u, v];
}</lsl>
<table style="width: 800px;" border="1" cellpadding="2"
cellspacing="2">
<tr>
<th style="text-align: center;" colspan="1"
rowspan="2">Errors / test cycles</th>
<th style="text-align: center;">Function 1</th>
<th style="text-align: center;">Function 2</th>
<th style="text-align: center;">Function 3</th>
<th style="text-align: center;">Function 4</th>
</tr>
<tr>
<th style="text-align: center;">llRotBetween</th>
<th style="text-align: center;">RotBetween</th>
<th style="text-align: center;">rotV2V</th>
<th style="text-align: center;">rotbetween</th>
</tr>
<tr>
<th style="text-align: center;" colspan="1"
rowspan="3">abs error > 1e-3</th>
<td style="text-align: right;"> 10 / 16</td>
<td style="text-align: right;"> 10 / 98</td>
<td style="text-align: right;"> 10 / 222</td>
<td style="text-align: right;"> 10 / 192</td>
</tr>
<tr>
<td style="text-align: right;"> 10 / 15</td>
<td style="text-align: right;"> 10 / 96</td>
<td style="text-align: right;"> 10 / 89</td>
<td style="text-align: right;"> 10 / 164</td>
</tr>
<tr>
<td style="text-align: right;"> 10 / 27</td>
<td style="text-align: right;"> 10 / 109</td>
<td style="text-align: right;">10 / 99</td>
<td style="text-align: right;"> 10 / 75</td>
</tr>
<tr>
<th style="text-align: center;" colspan="1"
rowspan="2">abs error > 1e-2</th>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
<td style="text-align: right;"> 0 / 1000</td>
</tr>
<tr>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"> 0 / 10000</td>
<td style="text-align: right;"> 0 / 10000</td>
</tr>
</table>

== Conclusion ==
Functions 2, 3 and 4 have similar performances.
Function 1, the built-in, has a lower performance.<br>
All four functions are very good except with parallel and anti parallel vectors.<br>
The rotation found is not always what you expect.<br>
: The rotation will point a vector in the right direction, i.e. the rotation's ''forward'' is the vector direction.
: See [[User:Dora_Gustafson/llRotBetween_alternatives#About_the_function.27s_nature|note]] about the functions nature
: Function 4 is different, the solution will map a rotation with ''left'' in the horizontal plane

== Scripts and functions ==
;Function 1, llRotBetween( vector a, vector b)
: This is the built in function, see [[LlRotBetween|llRotBetween]]
: See [[User:Dora_Gustafson/llRotBetween_alternatives#About_the_function.27s_nature|note]] about the functions nature
;Function 2, RotBetween( vector a, vector b)
: This is the suggested [[LlRotBetween#Replacement|Replacement]] for llRotBetween
: See [[User:Dora_Gustafson/llRotBetween_alternatives#About_the_function.27s_nature|note]] about the functions nature
;Function 3, rotV2V( vector a, vector b)
<lsl>rotation rotV2V( vector a, vector b)
{
a = llVecNorm(a);
b = llVecNorm(b);
vector c = b;
while ( llFabs(a*c) > 0.999999 ) c = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, llFrand( 2.0)-1.0 >);
c = llVecNorm(a%c);
return ZERO_ROTATION/llAxes2Rot( a, c, a%c)*llAxes2Rot( b, c, b%c);
}
</lsl>
: See [[User:Dora_Gustafson/llRotBetween_alternatives#About_the_function.27s_nature|note]] about the functions nature

;Function 4, rotbetween( vector a, vector b)
<lsl>rotation Vec2Rot( vector a)
{
a = llVecNorm(a);
vector c = < 0.0, 0.0, 1.0 >;
if ( llFabs(a*c) > 0.999999 ) c = llVecNorm(< llFrand( 2.0)-1.0, llFrand( 2.0)-1.0, 0.0 >);
vector b = llVecNorm(c%a);
return llAxes2Rot( a, b, a%b);
}

rotation rotbetween( vector a, vector b)
{
return ZERO_ROTATION/Vec2Rot(a)*Vec2Rot(b);
}
</lsl>
: Returns a solution that will map a rotation with ''left'' in the horizontal plane. This is convenient for cameras and prims you don't want tilted
----

==About the function's nature==
The function determines a rotation (quaternion) which can map a vector onto another.
: It does nothing else, which means that there are no conditions on the other vectors associated with a rotation in space.
When the solution is used to rotate a body in space one should be aware of it’s nature.
: For a prim whose rotation is defined by three orthogonal vectors the forward vector mapping will be correct while the other vector mappings are unpredictable.
: A prim mapping will normally be rotated about the prim’s forward axis in an unpredictable way.
: The prim will be tilted to one side or the other side with respect to the vertical.
There are numerous solutions to the task of finding the rotation between two vectors and all are correct in the sense that they can correctly map one vector onto another.
{{LSLC|Library}}

User:Dora Gustafson/fixed 3D relation

2015-01-22T20:42:20Z

Dora Gustafson:

== Fixed 3D relation ==
Any prim in SL has a position and a rotation in space<br>
Two prims have a relative position and rotation between them<br>
The relative position and rotation is what I call the relation between the prims<br>
In scripting you often want to keep the relation after one or both prims have moved<br>
A typical example is to rez a prim with a fixed relation to the rezzing prim<br>

When you know position and rotation for two prims the relation can be computed like this:
<source lang="lsl2">
relativeRot = P2Rot / P1Rot;
relativePos = (P2Pos - P1Pos) / P1Rot;
</source>
When you know the relation and position and rotation for prim 1 you can compute position and rotation for prim 2 like this
<source lang="lsl2">
P2Rot = relativeRot * P1Rot;
P2Pos = P1Pos + relativePos * P1Rot;
</source>
Likewise you can compute position and rotation for prim 1 when they are known for prim 2
<source lang="lsl2">
P1Rot = ZERO_ROTATION/relativeRot * P2Rot;
P1Pos = P2Pos - relativePos/relativeRot * P2Rot;
</source>
{{LSLC|Library}}

User:Dora Gustafson/JSON structure facial expression

2015-01-22T20:39:24Z

Dora Gustafson:

== JSON structured menu for all facial expressions ==
The script has 19 facial expressions that can be chosen from a menu
:The expressions can also be chosen by random and they can be played in a loop
:The script can be used in a pose ball or in an attached (HUD)prim
:When used for a pose ball the camera position is saved for next session
The script features a [[Json_usage_in_LSL|JSON structured]] dialog-menu
:In this case the menu has one main page and three child pages
:The power of JSON shows where the menu is decoded and in the navigation between menus. See the first lines in the listen event handler
<source lang="lsl2">
// Pose ball and facial expressions, script by Dora Gustafson, Studio Dora 2012
// build on Basic pose ball script. by Dora Gustafson, Studio Dora 2010
// v1.00 Has 10 facial expressions that can be chosen from a menu, chosen by random,
// ... looped, has menu reopen and saves camera position
// v1.01 wearable. Sit on or attach
// v1.02 JSON structured dialog-menu with all 19 facial expressions

// Define all menu names and menu button lay-outs
string mDisa = "Disapproval";
list LDisa = ["Home","Open mouth","Disdain","Frown","Tongue out","Anger","Bored"];
string mChee = "Cheerful";
list LChee = ["Home","Kiss","Smile","Toothsmile","Laugh","Surprise","Wink"];
string mMis = "Miserable";
list LMis = ["Home","Worry","Afraid","Sad","Cry","Embarrassed","Repulsed","Shrug"];
string mHom = "Home";
list LHom = ["Cheerful","Miserable","Disapproval","Loop","Random"];

// strided list coupler button name and animation name. The order of strides doesn't matter
list coupling = [ "Afraid", "express_afraid_emote",
"Anger", "express_anger_emote",
"Bored", "express_bored_emote",
"Cry", "express_cry_emote",
"Disdain", "express_disdain",
"Embarrassed", "express_embarrassed_emote",
"Frown", "express_frown",
"Kiss", "express_kiss",
"Laugh", "express_laugh_emote",
"Open mouth", "express_open_mouth",
"Repulsed", "express_repulsed_emote",
"Sad", "express_sad_emote",
"Shrug", "express_shrug_emote",
"Smile", "express_smile",
"Surprise", "express_surprise_emote",
"Tongue out", "express_tongue_out",
"Toothsmile", "express_toothsmile",
"Wink", "express_wink_emote",
"Worry", "express_worry_emote" ];

string JSONMenu;
list BUTTONS;
key sitter;
integer dialogChanal=-532247677;
integer haandtag;
string menuHead;
integer act=0;
string Fanim = "stand";

default
{
state_entry()
{
string s1 = llList2Json( JSON_ARRAY, LDisa);
string s2 = llList2Json( JSON_ARRAY, LChee);
string s3 = llList2Json( JSON_ARRAY, LMis);
string s4 = llList2Json( JSON_ARRAY, LHom);
JSONMenu = llList2Json( JSON_OBJECT, [mDisa, s1, mChee, s2, mMis, s3, mHom, s4]+coupling);
BUTTONS = LHom ;
llSitTarget( <0.0, 0.0, 1.0>, ZERO_ROTATION );
llSetSitText("Animate");
llSetClickAction(CLICK_ACTION_SIT);
}
attach(key id)
{
menuHead = llGetScriptName( )+"\nMemory in use: "+(string)llGetUsedMemory()+"\n\nChoose any of 19 facial expressions";
llSetClickAction(CLICK_ACTION_TOUCH);
llSetTimerEvent( 0.0 );
act = 0;
if (id)
{
sitter = id;
llRequestPermissions( sitter , PERMISSION_TRIGGER_ANIMATION);
}
else llListenRemove( haandtag);
}
changed(integer change)
{
menuHead = llGetScriptName( )+"\nMemory in use: "+(string)llGetUsedMemory()+"\n\n[Page Down] reopens this Dialog Menu\n\nChoose any of 19 facial expressions";
llSetTimerEvent( 0.0 );
act = 0;
if (change & CHANGED_LINK)
{
sitter = llAvatarOnSitTarget() ;
if(sitter != NULL_KEY) llRequestPermissions( sitter , PERMISSION_TRIGGER_ANIMATION | PERMISSION_TAKE_CONTROLS | PERMISSION_TRACK_CAMERA);
else
{
if (llGetPermissions() & PERMISSION_TRIGGER_ANIMATION) llStopAnimation(Fanim);
llSetAlpha(1.0, ALL_SIDES); // show prim
llListenRemove( haandtag);
}
}
}
run_time_permissions(integer perm)
{
if ( (perm & PERMISSION_TRIGGER_ANIMATION) && (llAvatarOnSitTarget() != NULL_KEY) )
{
llSetAlpha(0.0, ALL_SIDES); // hide prim
llStartAnimation(Fanim);
llStopAnimation("sit");
}
if ( perm & PERMISSION_TAKE_CONTROLS )
{
llTakeControls( CONTROL_DOWN , TRUE, TRUE);
llListenRemove( haandtag);
haandtag = llListen( dialogChanal, "", sitter, "");
llDialog( sitter, menuHead, BUTTONS, dialogChanal);
}
}
touch_end( integer num )
{
if ( llDetectedKey(0) == sitter )
{
llListenRemove( haandtag);
haandtag = llListen( dialogChanal, "", sitter, "");
llDialog( sitter, menuHead, BUTTONS, dialogChanal);
}
}
control(key id, integer down, integer new)
{
if ( down & new & CONTROL_DOWN ) llDialog( sitter, menuHead, BUTTONS, dialogChanal);
}
listen( integer channel, string name, key id, string message)
{
if ( JSON_ARRAY == llJsonValueType( JSONMenu, [message])) BUTTONS = llParseString2List( llJsonGetValue( JSONMenu, [message]),[",","[","]","\""],[]);
else
{
if ( JSON_STRING == llJsonValueType( JSONMenu, [message])) Fanim = llJsonGetValue( JSONMenu, [message]);
else if ( "Loop" == message )
{
act = act ^ 1;
if ( act & 1 ) llSetTimerEvent( 3.0 );
else llSetTimerEvent( 0.0 );
}
else if ( "Random" == message )
{
Fanim = llList2String( llListRandomize( coupling, 2), 1);
act = act ^ 2;
}
if ( llGetPermissions() & PERMISSION_TRIGGER_ANIMATION) llStartAnimation( Fanim);
}
llDialog( sitter, menuHead, BUTTONS, dialogChanal);
if( llGetPermissions() & PERMISSION_TRACK_CAMERA)
{
rotation cam_rot=llGetCameraRot()/llGetRot(); // relative camera rotation
vector cam_pos=(llGetCameraPos()-llGetPos())/llGetRot(); // relative camera position
llSetLinkCamera( LINK_THIS, cam_pos, cam_pos + llRot2Fwd(cam_rot));
}
}
timer()
{
if ( act & 2 ) Fanim = llList2String( llListRandomize( coupling, 2), 1);
if ( llGetPermissions() & PERMISSION_TRIGGER_ANIMATION) llStartAnimation( Fanim);
}
}
</source>
{{LSLC|Library}}

User:Dora Gustafson/insertion sort

2015-01-22T20:37:04Z

Dora Gustafson:

== Straight insertion Sort ==
The effective straight insertion sort routine for LSL is included
: First is the most simplified edition
<source lang="lsl2">
insertionSort()
{
integer i;
integer j;
for ( i=1; i<llGetListLength(Lcrit); i++)
{
j=i;
while ( llList2Integer( Lcrit, j-1)>llList2Integer( Lcrit, i) && j>0) --j;
if (j<i) Lcrit=llListReplaceList( Lcrit, llList2List( Lcrit, i, i)+llList2List( Lcrit, j, i-1), j, i);
}
}</source>
It will sort a list: Lcrit, of numbers in ascending order<br>
This simple edition can easily be expanded to sort parallel lists something that can't be done with the built in [[LlListSort|llListSort()]]
: Then a full version that can sort a strided list and take the same parameters as the built in [[LlListSort|llListSort()]] does
<source lang="lsl2">
list insertionSort( list src, integer stride, integer ascending)
{
integer i;
integer j;
integer k = llGetListLength(src);
if (ascending) for ( i=stride; i<k; i+=stride)
{
j=i;
while ( llList2Float( src, j-stride)>llList2Float( src, i) && j>0) j -= stride;
if (j<i) src=llListReplaceList( src, llList2List( src, i, i+stride-1)+llList2List( src, j, i-1), j, i+stride-1);
}
else for ( i=stride; i<k; i+=stride)
{
j=i;
while ( llList2Float( src, j-stride)<llList2Float( src, i) && j>0) j -= stride;
if (j<i) src=llListReplaceList( src, llList2List( src, i, i+stride-1)+llList2List( src, j, i-1), j, i+stride-1);
}
return src;
}</source>
The straight insertion sort method has great advantages over the bubble sort method, but in lsl the competition isn't even.
: The [[LlListSort|llListSort()]] is normally a factor 10 to 100 times faster.
: When sorting lists that are in order or almost in order, this sort and the built in are almost doing the job at the same speed.
: Lists used for testing had 100 strides with three elements in each<br>
This routine can sort on numbers only! A>B and A<B are only defined in LSL for numbers
{{LSLC|Library}}

User:Dora Gustafson/occurences

2015-01-22T20:32:41Z

Dora Gustafson:

== Count Occurrences in a list ==
Look for and count anything, that can be an element, in a list
: This script is an example which include a list: "haystack" and an element: "needle"
: Here "haystack" and "needle" are constants and only meant to make up a working script
<source lang="lsl2">
// count occurrences in list; by Dora Gustafson, Studio Dora 2014
// v1.1 inline code

default
{
state_entry()
{
list haystack = [1,2,1,2,1,2,3,2,4,5,2,6,4,2,3,2,1,8];
list needle = [2];
integer i = 0;
integer j = 0;
integer k = llListFindList( haystack, needle);
integer m = llGetListLength( haystack );
while ( k >= 0 && i < m )
{
i += k+1;
k = llListFindList( llList2List( haystack, i, -1), needle);
++j;
}
llOwnerSay((string)needle+" occurs "+(string)j+" times in "+llDumpList2String( haystack, ", "));
}
}
</source>
This program is straight, a recursive approach follows
<source lang="lsl2">
// count occurrences in list; by Dora Gustafson, Studio Dora 2014
// v1.1 inline code
// v1.2 recursive approach

list haystack = [1,2,1,2,1,2,3,2,4,5,2,6,4,2,3,2,1,8];
list needle = [2];
integer j = 0;

tin( list L )
{
integer k = llListFindList( L, needle);
if ( k >= 0 )
{
++j;
if ( k+1 < llGetListLength(L) ) tin( llList2List( L, k+1, -1));
}
}

default
{
state_entry()
{
tin( haystack);
llOwnerSay((string)needle+" occurs "+(string)j+" times in "+llDumpList2String( haystack, ", "));
}
}</source>
The advantage of recursion over straight code is a shorter code(the code is reused)<br>
The disadvantages are longer execution time and more overhead generated at runtime
: For these reasons the recursion approach is a bad choice to search a long list in LSL
{{LSLC|Library}}

User:Dora Gustafson/Replacing llTargetOmega/function

2015-01-22T20:29:28Z

Dora Gustafson:

== Replacing llTargetOmega, the function ==
<source lang="lsl2">
KeyFramedOmega( vector axis, float spinrate)
{
llSetKeyframedMotion( [], []);
if ( spinrate )
{
float v = TWO_PI/3.0;
if ( spinrate < 0 ) v = -v;
list L = [llAxisAngle2Rot( axis/llGetRot(), v), v/spinrate];
llSetKeyframedMotion( L+L+L, [KFM_DATA, KFM_ROTATION, KFM_MODE, KFM_LOOP]);
}
}
</source>

LlTargetOmega Replacement

2015-01-22T20:28:13Z

Dora Gustafson:

{{LSL_Function
|func=KeyFramedOmega
|func_id
|func_sleep
|func_energy
|func_desc=Rotates the object/prim around axis at a rate of spinrate in radians per second
|func_footnote
|return_type
|return_text
|p1_type=vector
|p1_name=axis
|p1_desc=arbitrary axis to rotate the object around
|p1_hover
|p2_type=float
|p2_name=spinrate
|p2_desc=rate of rotation in radians per second
|p2_hover
|constants
|spec=
* This doesn't make [[llTargetOmega]] redundant but in some cases a Key Framed motion may be preferred
* The routine: "KeyFramedOmega" is easy to use for [[llTargetOmega]]: It takes the first two parameters in [[llTargetOmega]]: axis and spinrate
* All viewers will see the same spin and rotation
* The object will keep the rotation it has when spin is stopped
* A spin will continue even when the script is deleted
|caveats=
* The script must be in the root prim
* It can not spin child prims
* The object must be convex hull physics type
* Can not spin physical objects
* If the center of mass is not at the center of the root, the object will shake and jerk and drift erratically ([https://jira.secondlife.com/browse/BUG-7266 BUG-7266])
|examples=
This script shows how to use the routine to start, stop and reverse a spin on repeated touches
<source lang="lsl2">
// llTargetOmega substitution by Dora Gustafson, Studio Dora 2014

integer P;

KeyFramedOmega( vector axis, float spinrate)
{
llSetKeyframedMotion( [], []);
if ( spinrate )
{
float v = TWO_PI/3.0;
if ( spinrate < 0 ) v = -v;
list L = [llAxisAngle2Rot( axis/llGetRot(), v), v/spinrate];
llSetKeyframedMotion( L+L+L, [KFM_DATA, KFM_ROTATION, KFM_MODE, KFM_LOOP]);
}
}

default
{
state_entry()
{
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]);
}
touch_end( integer n)
{
P = ++P%4;
if ( P == 1 ) KeyFramedOmega( <0,0,1>, 2.0); // Positive spin
else if ( P == 3 ) KeyFramedOmega( <0,0,1>, -2.0); // Negative spin
else KeyFramedOmega( <0,0,1>, 0.0); // Stop spin
}
}
</source>
|helpers
|also_header
|also_functions=: [[llTargetOmega]]
: [[llSetKeyframedMotion]]
|also_tests
|also_events
|also_articles
|also_footer
|notes=The magnitude of ''axis'' do '''not''' influence the ''spinrate''
|mode=user
|deprecated
|location=[[User:Dora_Gustafson/Replacing_llTargetOmega/function|The Function]]
|cat1=Rotation
|cat2=Examples
|signature=[[User:Dora Gustafson|Dora Gustafson]] 04:36, 12 August 2014 (PDT)
}}

User:Dora Gustafson/bezier toy

2015-01-22T20:25:17Z

Dora Gustafson:

{{LSL Header}}
== Bézier Toy ==
:Strictly for fun!
::The toy is made of one prim and a script.
::The prim will move along a smooth closed curve in space until it is stopped.
::The prim can be sat on and will then move you as a rollercoaster.
::Experimenting with the: camera distance, camera angle and camera in mouselook is great fun.
::Making a smoke tail is optional.
:The curve travelled
::The curve is made from a number of Bézier curves computed in the script.
::The curves are put together seamlessly.
::The points used for the curves are picked at random inside a box with editable size.
::New curves are computed each time The button New in the dialog menu is pressed.
:KeyFramed Motion
::The Second Life technique used is called: [[LlSetKeyframedMotion|KeyFramed Motion]]
::This makes it possible to let the toy run forever without a script.
::Just start the toy and remove the script with the Kill Script button in the dialog menu
<source lang="lsl2">
// Bezier Key Framed Motion script by Dora Gustafson, Studio Dora 2012
// Build on Cubic(3.order) Bezier chain by Dora Gustafson, Studio Dora 2008
// v1.01 Key Framed Motion 2012
// v1.02 introducing KFM
// v1.03 KFM alone
// v1.04 Appending more seamless bezier curves
// v1.05 Box limited randomP
// v1.06 Smoke on/off and script erase
// v1.07 Parameter menu
// v1.08 Particle size = f(prim scale). Range separate for X, Y and Z
// v1.09 Same randomP as in: "Bezier Spot Light Key Framed Motion". No more rangeOffset
// ... randomP box limits rotated as prim

float Tmotion = 8.0; // seconds
vector range = < 5.0, 5.0, 5.0 >; // ± half range for each coordinate in meters
rotation refFrame=<-0.5, -0.5, -0.5, 0.5>; // points Z forward
string toolDialog = "\nNew, Compute new points\nBegin Key Framed Motion\nEnd Key Framed Motion\nSmoke on or off\nKill Script to remove script from object\n...a Studio Dora product";
list TOOL_MENU = [ "CurveNumb", "Kill Script", "Range", "Cycle Time", "Frames/Curve", "New", "Begin", "End" ];
integer dialogChannel;
integer paramChannel;
integer paramHandl;
integer frames=16;
vector Po0;
vector Po1;
vector P0;
vector P1;
vector P2;
vector P3;
vector Q1;
vector Q2;
vector Q3;
vector LEFT=< 0.0, 1.0, 0.0 >;
list KFMlist=[];
vector b1;
vector b2;
rotation r1;
rotation r2;
integer curvNumb=3;
integer smoke=FALSE;
string partTextur;
rotation homeRot;

MakeParticles()
{
vector vsz = llGetScale();
float sc = 0.5*(vsz.x+vsz.y);
vsz = < sc, sc, 0.0 >;
llParticleSystem([
PSYS_PART_FLAGS,
PSYS_PART_INTERP_COLOR_MASK //Colors fade from start to end
| PSYS_PART_INTERP_SCALE_MASK //Scale fades from beginning to end
,PSYS_SRC_PATTERN, PSYS_SRC_PATTERN_ANGLE_CONE
,PSYS_SRC_TEXTURE, partTextur //UUID of the desired particle texture, or inventory name
,PSYS_SRC_MAX_AGE, 0.0 //Time, in seconds, for particles to be emitted. 0 = forever
,PSYS_PART_MAX_AGE, 60.0 //Lifetime, in seconds, that a particle lasts
,PSYS_SRC_BURST_RATE, 0.02 //How long, in seconds, between each emission
,PSYS_SRC_BURST_PART_COUNT, 1 //Number of particles per emission
,PSYS_SRC_BURST_RADIUS, 0.0 //Radius of emission
,PSYS_SRC_BURST_SPEED_MIN, 0.0 //Minimum speed of an emitted particle
,PSYS_SRC_BURST_SPEED_MAX, 0.0 //Maximum speed of an emitted particle
,PSYS_SRC_ACCEL, <0.0,0.0,0.0> //Acceleration of particles each second
,PSYS_PART_START_COLOR, <1.0,1.0,1.0> //Starting RGB color
,PSYS_PART_END_COLOR, <1.0,1.0,1.0> //Ending RGB color, if INTERP_COLOR_MASK is on
,PSYS_PART_START_ALPHA, 1.0 //Starting transparency, 1 is opaque, 0 is transparent.
,PSYS_PART_END_ALPHA, 0.0 //Ending transparency
,PSYS_PART_START_SCALE, vsz //Starting particle size
,PSYS_PART_END_SCALE, 1.5*vsz //Ending particle size, if INTERP_SCALE_MASK is on
,PSYS_SRC_ANGLE_BEGIN, 3.1415 //Inner angle for ANGLE patterns
,PSYS_SRC_ANGLE_END, 3.1415 //Outer angle for ANGLE patterns
,PSYS_SRC_OMEGA, <0.0,0.0,0.0> //Rotation of ANGLE patterns, similar to llTargetOmega()
]);
}

openBox( integer n, string menuText)
{
paramChannel = dialogChannel + n;
llListenRemove( paramHandl);
paramHandl = llListen( paramChannel, "", llGetOwner(), "");
llTextBox( llGetOwner(), menuText, paramChannel);
}

vector randomP()
{
return llGetPos() + < range.x*(llFrand( 2.0)-1.0), range.y*(llFrand( 2.0)-1.0), range.z*(llFrand( 2.0)-1.0) > * homeRot;
}

rotation Vec2Rot( vector FWD )
{
FWD = llVecNorm( FWD );
vector UP = < 0.0, 0.0, 1.0 >;
if ( llFabs(FWD.z) < 1.0 ) LEFT = llVecNorm(UP%FWD);
UP = llVecNorm(FWD%LEFT);
return refFrame*llAxes2Rot(FWD, LEFT, UP);
}

tDialog()
{
string menuD = llGetScriptName( )+"\nMemory in use: "+(string)llGetUsedMemory();
menuD += "\n\nRange = ±"+(string)range+" meters";
menuD += "\nCycle time = "+(string)Tmotion+" Seconds";
menuD += "\nFrames per curve = "+(string)frames;
menuD += "\nNumber of curves = "+(string)curvNumb;
list T_MENU = ["Smoke ON"];
if (smoke) T_MENU = ["Smoke OFF"];
llDialog( llGetOwner(), menuD + toolDialog, T_MENU + TOOL_MENU, dialogChannel);
}

integer random_channel()
{// mask out 4 LSBits for other uses
return ((128 * (integer)llFrand( 8388608.0 )) + (integer)llFrand( 8388608.0 ) + 0x80000000) & 0xFFFFFFF0;
}

coefisFirst()
{
P0 = llGetPos();
Po0 = P0;
P3 = randomP();
P2 = randomP();
P1 = randomP();
Po1 = P1;
Q1 = 3.0*P1-3.0*P0;
Q2 = 3.0*P0-6.0*P1+3.0*P2;
Q3 = 3.0*P1-P0+P3-3.0*P2;
}

coefisNext()
{
P0 = P3;
P1 = 2.0*P3-P2;
P3 = randomP();
P2 = randomP();
Q1 = 3.0*P1-3.0*P0;
Q2 = 3.0*P0-6.0*P1+3.0*P2;
Q3 = 3.0*P1-P0+P3-3.0*P2;
}

coefisLast()
{
P0 = P3;
P1 = 2.0*P3-P2;
P2 = 2.0*Po0-Po1;
P3 = Po0;
Q1 = 3.0*P1-3.0*P0;
Q2 = 3.0*P0-6.0*P1+3.0*P2;
Q3 = 3.0*P1-P0+P3-3.0*P2;
}

vector Bez( float x ) { return P0 + (Q1 + (Q2 + Q3*x)*x)*x; }

vector dBez( float x ) { return Q1 + (2.0*Q2 + 3.0*Q3*x)*x; }

vector sBez( float x ) { return 2.0*Q2 + 6.0*Q3*x; }

default
{
state_entry()
{
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]);
dialogChannel = random_channel();
llListen( dialogChannel, "", llGetOwner(), "");
refFrame.s = -refFrame.s;
string textureName = llGetInventoryName(INVENTORY_TEXTURE, 0 );
if ( llGetInventoryType( textureName ) == INVENTORY_TEXTURE ) partTextur = textureName; // use extern, inventory texture
else partTextur = "";
}
touch_end(integer n)
{
if ( llDetectedKey(0) == llGetOwner() )
{
if ( llGetListLength( KFMlist) > 5 ) tDialog();
else llDialog( llGetOwner(), llGetScriptName( )+"\n\nMust make a new", ["New"], dialogChannel);
}
}
listen(integer channel, string name, key id, string message)
{
if ( message == "CurveNumb" ) openBox( 1, "Enter number of appended Bezier curves= 2,3,4,...,18");
else if ( message == "Range" ) openBox( 2, "Specify ±range relative to curent position\nCube: [X range, Y range, Z range]");
else if ( message == "Cycle Time" ) openBox( 3, "Time in seconds for one cycle");
else if ( message == "Frames/Curve" ) openBox( 4, "Number of key frames per Bezier curve [2;100]");
else if ( message == "Kill Script" ) llRemoveInventory( llGetScriptName());
else
{
if ( message == "New" )
{
homeRot = llGetRot();
float liN = (float)frames;
float dT = Tmotion/liN/(float)curvNumb;
dT = llRound(45.0*dT)/45.0;
if ( dT < 0.11111111 ) dT = 0.11111111;
KFMlist=[];
coefisFirst();
b1 = Bez(0);
r1 = Vec2Rot( dBez(0));
integer i;
for ( i=1; i<=frames; i++ )
{
b2 = Bez( i/liN); r2 = Vec2Rot(dBez( i/liN));
KFMlist += [ b2-b1, r2/r1, dT];
b1 = b2; r1 = r2;
}
integer j = curvNumb;
while ( j-- > 2 )
{
coefisNext();
for ( i=1; i<=frames; i++ )
{
b2 = Bez( i/liN); r2 = Vec2Rot(dBez( i/liN));
KFMlist += [ b2-b1, r2/r1, dT];
b1 = b2; r1 = r2;
}
}
coefisLast();
for ( i=1; i<=frames; i++ )
{
b2 = Bez( i/liN); r2 = Vec2Rot(dBez( i/liN));
KFMlist += [ b2-b1, r2/r1, dT];
b1 = b2; r1 = r2;
}
}
else if ( message == "End" )
{
llSetKeyframedMotion( [], []);
llSleep(0.2);
llSetRegionPos( Po0);
llSetPrimitiveParams([PRIM_POSITION, Po0, PRIM_ROTATION, homeRot]);
}
else if ( message == "Begin" && llGetListLength( KFMlist))
{
llSetKeyframedMotion( [], []);
llSleep(0.2);
llSetRegionPos( Po0);
llSetPrimitiveParams([PRIM_POSITION, Po0, PRIM_ROTATION, Vec2Rot( Po1-Po0)]);
llSetKeyframedMotion( KFMlist, [KFM_MODE, KFM_LOOP]);
}
else if ( message == "Smoke ON" ) { MakeParticles(); smoke = TRUE; }
else if ( message == "Smoke OFF" ) { llParticleSystem([]); smoke = FALSE; }
else if ( channel == dialogChannel + 1 )
{
curvNumb = (integer)message;
if ( curvNumb < 2 || curvNumb > 18 ) curvNumb = 2;
}
else if ( channel == dialogChannel + 2 )
{
list L = llCSV2List( message);
if ( llGetListLength(L) == 3 )
{
range.x = llList2Float( L, 0);
range.y = llList2Float( L, 1);
range.z = llList2Float( L, 2);
}
else if ( llGetListLength(L) == 1 ) range = (vector)llList2String( L, 0);
else if ( range.x<=0.0 || range.y<=0.0 || range.z<=0.0 ) llOwnerSay("Range must be entered as a vector with positive elements\nor as three comma separated positive numbers");
}
else if ( channel == dialogChannel + 3 )
{
Tmotion = (float)message;
if ( Tmotion < 1.0 ) Tmotion = 1.0;
}
else if ( channel == dialogChannel + 4 )
{
frames = (integer)message;
if ( frames < 2 || frames > 100 ) frames = 16;
}
llListenRemove( paramHandl );
tDialog();
}
}
on_rez(integer param) { llResetScript(); }
}
</source>
=== The menu ===
:New
::Will compute new curves from new randomly picked points in space
::The points will be picked inside a box with the prim in the center and rotated just like the prim
::Do not press New when the prim is moving, if you want any control of the curve
:Begin
::Begin the prim travel
:End
::End the travel and reset prim to start position and start rotation
:Range
::The range in which random points will be picked for the Bézier curves
::It is given by 3 coordinates X, Y and Z
::The coordinates form a box with the prim in the middle: prim position ±X, ±Y and ±Z
::This imaginary box is rotated just like the prim!
::In edit mode you can see the prim’s axes when you choose local coordinates (as opposed to world coordinates)
::Note that the prim will not stay inside the box on its journey, only the points used to compute the journey are guarantied to be inside
:Cycle Time
::The time it takes to complete one cycle from start to start
:Frames/Curve
::The number of keyframes for each Bézier curve
:Smoke ON/OFF
::Toggles the particle emitter ON/OFF
:CurveNumb
::The number of Bézier curves from start to start
:Kill Script
::Will remove the script and the toy can’t be controlled anymore
::The toy will continue doing what it did when the script was removed
{{LSLC|Library}}

LlRotBetween

2014-10-03T12:52:43Z

Dora Gustafson:

{{LSL_Function
|inject-2={{Issues/SVC-4415}}{{Issues/SCR-309}}
|func_id=21|func_sleep=0.0|func_energy=10.0
|func=llRotBetween
|return_type=rotation|p1_type=vector|p1_name=start|p2_type=vector|p2_name=end
|func_footnote
|func_desc
|return_text=that is the shortest rotation between the direction {{LSLP|start}} and the direction {{LSLP|end}}
|spec={{LSLP|start}} and {{LSLP|end}} are directions and are relative to the origin <0.0, 0.0, 0.0>. If you have coordinates relative to a different origin, subtract that origin from the input vectors.
|caveats=
*<code>start * llRotBetween(start, end) == end</code> is only true if {{LSLP|start}} and {{LSLP|end}} have the same magnitude and neither have a magnitude of zero (see [[#Useful Snippets]] for a workaround).
**This of course is ignoring floating point precision errors.
* The above is true because of vector magnitudes and not a shortcoming of this function. The '''rotation''' returned is '''correct''' regardless of magnitudes
* Rotations are from -PI to +PI around each axis.
|constants
|examples=
<lsl>llRotBetween(<1.0, 0.0, 0.0>, <0.0, -1.0, 0.0>)
// will return <0.00000, 0.00000, -0.70711, 0.70711> (which represents -90 degrees on the z axis)

llRotBetween(<0.0, 0.0, 0.0>, <0.0, -1.0, 0.0>)
// will return <0.00000, 0.00000, 0.00000, 1.00000> (which represents a zero angle on all axis)
// because <0.0, 0.0, 0.0> does not convey a direction.</lsl>
|helpers
|also_functions={{LSL DefineRow||[[llAngleBetween]]}}
|also_tests
|also_events
|also_articles
|helpers=This function adjusts the magnitude of the quaternion so <code>start * llRotBetween(start, end) == end</code> is true as long as neither have a magnitude really close to zero. They do not have to have the same magnitude. (If either is too close to zero than this will return an unadjusted quaternion). While this is mathematically correct, it won't help with floating point rounding errors, so it's more accurate to say <code>start * return ≈ end</code>.
<lsl>rotation RotBetween(vector start, vector end) //adjusts quaternion magnitude so (start * return == end)
{//Authors note: I have never had a use for this but it's good to know how to do it if I did.
rotation rot = llRotBetween(start, end);
float d = start * start;
if(d)//is 'start' zero?
if((d = llPow(end * end / d, 0.25)))//is 'end' zero?
return <rot.x * d, rot.y * d, rot.z * d, rot.s * d>;
return rot;
}//Strife Onizuka</lsl>
|notes=
Vectors that are near opposite each other in direction may lead to erroneous results.
<lsl>
// First Vector is due north second vector is ALMOST due south.
rotation lRotation = llRotBetween( <0., 1., 0.>, <-0.001, -.1, 0.> );
llSay(0, lRotation );
// Provides a result of <1.00000, 0.00000, 0.00000, 0.00000>.
</lsl>
|location={{SourceLink/bitbucket|viewer-release|indra/llmath/llquaternion.cpp|line=425}}
|deepnotes= === Replacement ===
Due to the annoying quirks of this function {{User|Moon Metty}} wrote a drop in replacement. - {{Jira|SCR-309}}.
The maximum error is reported to be 2.7e-7 @ 2.2 radians.
<lsl>rotation RotBetween(vector a, vector b)
{
float aabb = llSqrt((a * a) * (b * b)); // product of the lengths of the arguments
if (aabb)
{
float ab = (a * b) / aabb; // normalized dotproduct of the arguments (cosine)
vector c = <(a.y * b.z - a.z * b.y) / aabb,
(a.z * b.x - a.x * b.z) / aabb,
(a.x * b.y - a.y * b.x) / aabb >; // normalized crossproduct of the arguments
float cc = c * c; // squared length of the normalized crossproduct (sine)
if (cc) // test if the arguments are not (anti)parallel
{
float s;
if (ab > -0.707107)
s = 1 + ab; // use the cosine to adjust the s-element
else
s = cc / (1 + llSqrt(1 - cc)); // use the sine to adjust the s-element
float m = llSqrt(cc + s * s); // the magnitude of the quaternion
return <c.x / m, c.y / m, c.z / m, s / m>; // return the normalized quaternion
}
if (ab > 0)
return ZERO_ROTATION; // the arguments are parallel, or anti-parallel if not true:
float m = llSqrt(a.x * a.x + a.y * a.y); // the length of one argument projected on the XY-plane
if (m)
return <a.y / m, -a.x / m, 0, 0>; // return a rotation with the axis in the XY-plane
return <1, 0, 0, 0>; // the arguments are parallel to the Z-axis, rotate around the X-axis
}
return ZERO_ROTATION; // the arguments are too small, return zero rotation
}//Written by Moon Metty, optimized by Strife Onizuka

// This version keeps the axis in the XY-plane, in case of anti-parallel vectors (unlike the current LL implementation). -- Moon Metty</lsl>

===Bad Reference Implementation===
<lsl>//Loosely based on SL source code, like SL's version, it's not very accurate. You want to use the above version.
rotation llRotBetween(vector start, vector end) {
vector v1 = llVecNorm(start);
vector v2 = llVecNorm(end);
float dot = v1 * v2;
vector axis = v1 % v2;
if (dot < -0.9999999) {
// 180 degrees or there abouts
vector ortho_axis = llVecNorm(<1.f, 0.f, 0.f> - (sn * (sn.x / (sn * sn))));
if (ortho_axis)
return < ortho_axis.x, ortho_axis.y, ortho_axis.z, 0.f>;
return <0.0, 0.0, 1.0, 0.0>;
}
else if(dot > 0.9999999) {
//parallel
return ZERO_ROTATION;
}
dot = dot + 1.0;
float m = llPow((axis * axis) + (dot * dot), -0.5);
return <axis.x * m, axis.y * m, axis.z * m, dot * m>;
}</lsl>
===llRotBetween alternatives===
[[User:Dora_Gustafson/llRotBetween_alternatives#llRotBetween.2C_some_alternatives_and_considerations|Alternatives and considerations]]
|cat1=Math/3D
|cat2=Rotation
|cat3
|cat4
}}

LlRotBetween

2014-10-03T12:45:45Z

Dora Gustafson:

{{LSL_Function
|inject-2={{Issues/SVC-4415}}{{Issues/SCR-309}}
|func_id=21|func_sleep=0.0|func_energy=10.0
|func=llRotBetween
|return_type=rotation|p1_type=vector|p1_name=start|p2_type=vector|p2_name=end
|func_footnote
|func_desc
|return_text=that is the shortest rotation between the direction {{LSLP|start}} and the direction {{LSLP|end}}
|spec={{LSLP|start}} and {{LSLP|end}} are directions and are relative to the origin <0.0, 0.0, 0.0>. If you have coordinates relative to a different origin, subtract that origin from the input vectors.
|caveats=
*<code>start * llRotBetween(start, end) == end</code> is only true if {{LSLP|start}} and {{LSLP|end}} have the same magnitude and neither have a magnitude of zero (see [[#Useful Snippets]] for a workaround).
**This of course is ignoring floating point precision errors.
* The above is true because of vector magnitudes. The '''rotation''' returned is '''correct''' regardless of that (reserved rounding errors)
* Rotations are from -PI to +PI around each axis.
|constants
|examples=
<lsl>llRotBetween(<1.0, 0.0, 0.0>, <0.0, -1.0, 0.0>)
// will return <0.00000, 0.00000, -0.70711, 0.70711> (which represents -90 degrees on the z axis)

llRotBetween(<0.0, 0.0, 0.0>, <0.0, -1.0, 0.0>)
// will return <0.00000, 0.00000, 0.00000, 1.00000> (which represents a zero angle on all axis)
// because <0.0, 0.0, 0.0> does not convey a direction.</lsl>
|helpers
|also_functions={{LSL DefineRow||[[llAngleBetween]]}}
|also_tests
|also_events
|also_articles
|helpers=This function adjusts the magnitude of the quaternion so <code>start * llRotBetween(start, end) == end</code> is true as long as neither have a magnitude really close to zero. They do not have to have the same magnitude. (If either is too close to zero than this will return an unadjusted quaternion). While this is mathematically correct, it won't help with floating point rounding errors, so it's more accurate to say <code>start * return ≈ end</code>.
<lsl>rotation RotBetween(vector start, vector end) //adjusts quaternion magnitude so (start * return == end)
{//Authors note: I have never had a use for this but it's good to know how to do it if I did.
rotation rot = llRotBetween(start, end);
float d = start * start;
if(d)//is 'start' zero?
if((d = llPow(end * end / d, 0.25)))//is 'end' zero?
return <rot.x * d, rot.y * d, rot.z * d, rot.s * d>;
return rot;
}//Strife Onizuka</lsl>
|notes=
Vectors that are near opposite each other in direction may lead to erroneous results.
<lsl>
// First Vector is due north second vector is ALMOST due south.
rotation lRotation = llRotBetween( <0., 1., 0.>, <-0.001, -.1, 0.> );
llSay(0, lRotation );
// Provides a result of <1.00000, 0.00000, 0.00000, 0.00000>.
</lsl>
|location={{SourceLink/bitbucket|viewer-release|indra/llmath/llquaternion.cpp|line=425}}
|deepnotes= === Replacement ===
Due to the annoying quirks of this function {{User|Moon Metty}} wrote a drop in replacement. - {{Jira|SCR-309}}.
The maximum error is reported to be 2.7e-7 @ 2.2 radians.
<lsl>rotation RotBetween(vector a, vector b)
{
float aabb = llSqrt((a * a) * (b * b)); // product of the lengths of the arguments
if (aabb)
{
float ab = (a * b) / aabb; // normalized dotproduct of the arguments (cosine)
vector c = <(a.y * b.z - a.z * b.y) / aabb,
(a.z * b.x - a.x * b.z) / aabb,
(a.x * b.y - a.y * b.x) / aabb >; // normalized crossproduct of the arguments
float cc = c * c; // squared length of the normalized crossproduct (sine)
if (cc) // test if the arguments are not (anti)parallel
{
float s;
if (ab > -0.707107)
s = 1 + ab; // use the cosine to adjust the s-element
else
s = cc / (1 + llSqrt(1 - cc)); // use the sine to adjust the s-element
float m = llSqrt(cc + s * s); // the magnitude of the quaternion
return <c.x / m, c.y / m, c.z / m, s / m>; // return the normalized quaternion
}
if (ab > 0)
return ZERO_ROTATION; // the arguments are parallel, or anti-parallel if not true:
float m = llSqrt(a.x * a.x + a.y * a.y); // the length of one argument projected on the XY-plane
if (m)
return <a.y / m, -a.x / m, 0, 0>; // return a rotation with the axis in the XY-plane
return <1, 0, 0, 0>; // the arguments are parallel to the Z-axis, rotate around the X-axis
}
return ZERO_ROTATION; // the arguments are too small, return zero rotation
}//Written by Moon Metty, optimized by Strife Onizuka

// This version keeps the axis in the XY-plane, in case of anti-parallel vectors (unlike the current LL implementation). -- Moon Metty</lsl>

===Bad Reference Implementation===
<lsl>//Loosely based on SL source code, like SL's version, it's not very accurate. You want to use the above version.
rotation llRotBetween(vector start, vector end) {
vector v1 = llVecNorm(start);
vector v2 = llVecNorm(end);
float dot = v1 * v2;
vector axis = v1 % v2;
if (dot < -0.9999999) {
// 180 degrees or there abouts
vector ortho_axis = llVecNorm(<1.f, 0.f, 0.f> - (sn * (sn.x / (sn * sn))));
if (ortho_axis)
return < ortho_axis.x, ortho_axis.y, ortho_axis.z, 0.f>;
return <0.0, 0.0, 1.0, 0.0>;
}
else if(dot > 0.9999999) {
//parallel
return ZERO_ROTATION;
}
dot = dot + 1.0;
float m = llPow((axis * axis) + (dot * dot), -0.5);
return <axis.x * m, axis.y * m, axis.z * m, dot * m>;
}</lsl>
===llRotBetween alternatives===
[[User:Dora_Gustafson/llRotBetween_alternatives#llRotBetween.2C_some_alternatives_and_considerations|Alternatives and considerations]]
|cat1=Math/3D
|cat2=Rotation
|cat3
|cat4
}}

LlRotBetween

2014-10-03T12:41:32Z

Dora Gustafson:

{{LSL_Function
|inject-2={{Issues/SVC-4415}}{{Issues/SCR-309}}
|func_id=21|func_sleep=0.0|func_energy=10.0
|func=llRotBetween
|return_type=rotation|p1_type=vector|p1_name=start|p2_type=vector|p2_name=end
|func_footnote
|func_desc
|return_text=that is the shortest rotation between the direction {{LSLP|start}} and the direction {{LSLP|end}}
|spec={{LSLP|start}} and {{LSLP|end}} are directions and are relative to the origin <0.0, 0.0, 0.0>. If you have coordinates relative to a different origin, subtract that origin from the input vectors.
|caveats=
*<code>start * llRotBetween(start, end) == end</code> is only true if {{LSLP|start}} and {{LSLP|end}} have the same magnitude and neither have a magnitude of zero (see [[#Useful Snippets]] for a workaround).
**This of course is ignoring floating point precision errors.
* The above is true because of vector magnitudes. The rotation returned is correct regardless of that (reserved rounding errors)
* Rotations are from -PI to +PI around each axis.
|constants
|examples=
<lsl>llRotBetween(<1.0, 0.0, 0.0>, <0.0, -1.0, 0.0>)
// will return <0.00000, 0.00000, -0.70711, 0.70711> (which represents -90 degrees on the z axis)

llRotBetween(<0.0, 0.0, 0.0>, <0.0, -1.0, 0.0>)
// will return <0.00000, 0.00000, 0.00000, 1.00000> (which represents a zero angle on all axis)
// because <0.0, 0.0, 0.0> does not convey a direction.</lsl>
|helpers
|also_functions={{LSL DefineRow||[[llAngleBetween]]}}
|also_tests
|also_events
|also_articles
|helpers=This function adjusts the magnitude of the quaternion so <code>start * llRotBetween(start, end) == end</code> is true as long as neither have a magnitude really close to zero. They do not have to have the same magnitude. (If either is too close to zero than this will return an unadjusted quaternion). While this is mathematically correct, it won't help with floating point rounding errors, so it's more accurate to say <code>start * return ≈ end</code>.
<lsl>rotation RotBetween(vector start, vector end) //adjusts quaternion magnitude so (start * return == end)
{//Authors note: I have never had a use for this but it's good to know how to do it if I did.
rotation rot = llRotBetween(start, end);
float d = start * start;
if(d)//is 'start' zero?
if((d = llPow(end * end / d, 0.25)))//is 'end' zero?
return <rot.x * d, rot.y * d, rot.z * d, rot.s * d>;
return rot;
}//Strife Onizuka</lsl>
|notes=
Vectors that are near opposite each other in direction may lead to erroneous results.
<lsl>
// First Vector is due north second vector is ALMOST due south.
rotation lRotation = llRotBetween( <0., 1., 0.>, <-0.001, -.1, 0.> );
llSay(0, lRotation );
// Provides a result of <1.00000, 0.00000, 0.00000, 0.00000>.
</lsl>
|location={{SourceLink/bitbucket|viewer-release|indra/llmath/llquaternion.cpp|line=425}}
|deepnotes= === Replacement ===
Due to the annoying quirks of this function {{User|Moon Metty}} wrote a drop in replacement. - {{Jira|SCR-309}}.
The maximum error is reported to be 2.7e-7 @ 2.2 radians.
<lsl>rotation RotBetween(vector a, vector b)
{
float aabb = llSqrt((a * a) * (b * b)); // product of the lengths of the arguments
if (aabb)
{
float ab = (a * b) / aabb; // normalized dotproduct of the arguments (cosine)
vector c = <(a.y * b.z - a.z * b.y) / aabb,
(a.z * b.x - a.x * b.z) / aabb,
(a.x * b.y - a.y * b.x) / aabb >; // normalized crossproduct of the arguments
float cc = c * c; // squared length of the normalized crossproduct (sine)
if (cc) // test if the arguments are not (anti)parallel
{
float s;
if (ab > -0.707107)
s = 1 + ab; // use the cosine to adjust the s-element
else
s = cc / (1 + llSqrt(1 - cc)); // use the sine to adjust the s-element
float m = llSqrt(cc + s * s); // the magnitude of the quaternion
return <c.x / m, c.y / m, c.z / m, s / m>; // return the normalized quaternion
}
if (ab > 0)
return ZERO_ROTATION; // the arguments are parallel, or anti-parallel if not true:
float m = llSqrt(a.x * a.x + a.y * a.y); // the length of one argument projected on the XY-plane
if (m)
return <a.y / m, -a.x / m, 0, 0>; // return a rotation with the axis in the XY-plane
return <1, 0, 0, 0>; // the arguments are parallel to the Z-axis, rotate around the X-axis
}
return ZERO_ROTATION; // the arguments are too small, return zero rotation
}//Written by Moon Metty, optimized by Strife Onizuka

// This version keeps the axis in the XY-plane, in case of anti-parallel vectors (unlike the current LL implementation). -- Moon Metty</lsl>

===Bad Reference Implementation===
<lsl>//Loosely based on SL source code, like SL's version, it's not very accurate. You want to use the above version.
rotation llRotBetween(vector start, vector end) {
vector v1 = llVecNorm(start);
vector v2 = llVecNorm(end);
float dot = v1 * v2;
vector axis = v1 % v2;
if (dot < -0.9999999) {
// 180 degrees or there abouts
vector ortho_axis = llVecNorm(<1.f, 0.f, 0.f> - (sn * (sn.x / (sn * sn))));
if (ortho_axis)
return < ortho_axis.x, ortho_axis.y, ortho_axis.z, 0.f>;
return <0.0, 0.0, 1.0, 0.0>;
}
else if(dot > 0.9999999) {
//parallel
return ZERO_ROTATION;
}
dot = dot + 1.0;
float m = llPow((axis * axis) + (dot * dot), -0.5);
return <axis.x * m, axis.y * m, axis.z * m, dot * m>;
}</lsl>
===llRotBetween alternatives===
[[User:Dora_Gustafson/llRotBetween_alternatives#llRotBetween.2C_some_alternatives_and_considerations|Alternatives and considerations]]
|cat1=Math/3D
|cat2=Rotation
|cat3
|cat4
}}

LlRotBetween

2014-10-03T12:39:32Z

Dora Gustafson:

{{LSL_Function
|inject-2={{Issues/SVC-4415}}{{Issues/SCR-309}}
|func_id=21|func_sleep=0.0|func_energy=10.0
|func=llRotBetween
|return_type=rotation|p1_type=vector|p1_name=start|p2_type=vector|p2_name=end
|func_footnote
|func_desc
|return_text=that is the shortest rotation between the direction {{LSLP|start}} and the direction {{LSLP|end}}
|spec={{LSLP|start}} and {{LSLP|end}} are directions and are relative to the origin <0.0, 0.0, 0.0>. If you have coordinates relative to a different origin, subtract that origin from the input vectors.
|caveats=
*<code>start * llRotBetween(start, end) == end</code> is only true if {{LSLP|start}} and {{LSLP|end}} have the same magnitude and neither have a magnitude of zero (see [[#Useful Snippets]] for a workaround).
**This of course is ignoring floating point precision errors.
* The above is true because of different vector magnitudes. The rotation returned is correct regardless of vector sizes (reserved rounding errors)
* Rotations are from -PI to +PI around each axis.
|constants
|examples=
<lsl>llRotBetween(<1.0, 0.0, 0.0>, <0.0, -1.0, 0.0>)
// will return <0.00000, 0.00000, -0.70711, 0.70711> (which represents -90 degrees on the z axis)

llRotBetween(<0.0, 0.0, 0.0>, <0.0, -1.0, 0.0>)
// will return <0.00000, 0.00000, 0.00000, 1.00000> (which represents a zero angle on all axis)
// because <0.0, 0.0, 0.0> does not convey a direction.</lsl>
|helpers
|also_functions={{LSL DefineRow||[[llAngleBetween]]}}
|also_tests
|also_events
|also_articles
|helpers=This function adjusts the magnitude of the quaternion so <code>start * llRotBetween(start, end) == end</code> is true as long as neither have a magnitude really close to zero. They do not have to have the same magnitude. (If either is too close to zero than this will return an unadjusted quaternion). While this is mathematically correct, it won't help with floating point rounding errors, so it's more accurate to say <code>start * return ≈ end</code>.
<lsl>rotation RotBetween(vector start, vector end) //adjusts quaternion magnitude so (start * return == end)
{//Authors note: I have never had a use for this but it's good to know how to do it if I did.
rotation rot = llRotBetween(start, end);
float d = start * start;
if(d)//is 'start' zero?
if((d = llPow(end * end / d, 0.25)))//is 'end' zero?
return <rot.x * d, rot.y * d, rot.z * d, rot.s * d>;
return rot;
}//Strife Onizuka</lsl>
|notes=
Vectors that are near opposite each other in direction may lead to erroneous results.
<lsl>
// First Vector is due north second vector is ALMOST due south.
rotation lRotation = llRotBetween( <0., 1., 0.>, <-0.001, -.1, 0.> );
llSay(0, lRotation );
// Provides a result of <1.00000, 0.00000, 0.00000, 0.00000>.
</lsl>
|location={{SourceLink/bitbucket|viewer-release|indra/llmath/llquaternion.cpp|line=425}}
|deepnotes= === Replacement ===
Due to the annoying quirks of this function {{User|Moon Metty}} wrote a drop in replacement. - {{Jira|SCR-309}}.
The maximum error is reported to be 2.7e-7 @ 2.2 radians.
<lsl>rotation RotBetween(vector a, vector b)
{
float aabb = llSqrt((a * a) * (b * b)); // product of the lengths of the arguments
if (aabb)
{
float ab = (a * b) / aabb; // normalized dotproduct of the arguments (cosine)
vector c = <(a.y * b.z - a.z * b.y) / aabb,
(a.z * b.x - a.x * b.z) / aabb,
(a.x * b.y - a.y * b.x) / aabb >; // normalized crossproduct of the arguments
float cc = c * c; // squared length of the normalized crossproduct (sine)
if (cc) // test if the arguments are not (anti)parallel
{
float s;
if (ab > -0.707107)
s = 1 + ab; // use the cosine to adjust the s-element
else
s = cc / (1 + llSqrt(1 - cc)); // use the sine to adjust the s-element
float m = llSqrt(cc + s * s); // the magnitude of the quaternion
return <c.x / m, c.y / m, c.z / m, s / m>; // return the normalized quaternion
}
if (ab > 0)
return ZERO_ROTATION; // the arguments are parallel, or anti-parallel if not true:
float m = llSqrt(a.x * a.x + a.y * a.y); // the length of one argument projected on the XY-plane
if (m)
return <a.y / m, -a.x / m, 0, 0>; // return a rotation with the axis in the XY-plane
return <1, 0, 0, 0>; // the arguments are parallel to the Z-axis, rotate around the X-axis
}
return ZERO_ROTATION; // the arguments are too small, return zero rotation
}//Written by Moon Metty, optimized by Strife Onizuka

// This version keeps the axis in the XY-plane, in case of anti-parallel vectors (unlike the current LL implementation). -- Moon Metty</lsl>

===Bad Reference Implementation===
<lsl>//Loosely based on SL source code, like SL's version, it's not very accurate. You want to use the above version.
rotation llRotBetween(vector start, vector end) {
vector v1 = llVecNorm(start);
vector v2 = llVecNorm(end);
float dot = v1 * v2;
vector axis = v1 % v2;
if (dot < -0.9999999) {
// 180 degrees or there abouts
vector ortho_axis = llVecNorm(<1.f, 0.f, 0.f> - (sn * (sn.x / (sn * sn))));
if (ortho_axis)
return < ortho_axis.x, ortho_axis.y, ortho_axis.z, 0.f>;
return <0.0, 0.0, 1.0, 0.0>;
}
else if(dot > 0.9999999) {
//parallel
return ZERO_ROTATION;
}
dot = dot + 1.0;
float m = llPow((axis * axis) + (dot * dot), -0.5);
return <axis.x * m, axis.y * m, axis.z * m, dot * m>;
}</lsl>
===llRotBetween alternatives===
[[User:Dora_Gustafson/llRotBetween_alternatives#llRotBetween.2C_some_alternatives_and_considerations|Alternatives and considerations]]
|cat1=Math/3D
|cat2=Rotation
|cat3
|cat4
}}

LlTargetOmega Replacement

2014-10-01T12:35:09Z

Dora Gustafson: Undo revision 1193685 by Dora Gustafson (Talk)

{{LSL_Function
|func=KeyFramedOmega
|func_id
|func_sleep
|func_energy
|func_desc=Rotates the object/prim around axis at a rate of spinrate in radians per second
|func_footnote
|return_type
|return_text
|p1_type=vector
|p1_name=axis
|p1_desc=arbitrary axis to rotate the object around
|p1_hover
|p2_type=float
|p2_name=spinrate
|p2_desc=rate of rotation in radians per second
|p2_hover
|constants
|spec=
: This doesn't make [[llTargetOmega]] redundant but in some cases a Key Framed motion may be preferred
: The routine: "KeyFramedOmega" is easy to use for [[llTargetOmega]]: It takes the first two parameters in [[llTargetOmega]]: axis and spinrate
: All viewers will see the same spin and rotation
: The object will keep the rotation it has when spin is stopped
: A spin will continue even when the script is deleted
|caveats=
: The script must be in the root prim
: It can not spin child prims
: The object must be convex hull physics type
: Can not spin physical objects
|examples=
This script shows how to use the routine to start, stop and reverse a spin on repeated touches
<lsl>
// llTargetOmega substitution by Dora Gustafson, Studio Dora 2014

integer P;

KeyFramedOmega( vector axis, float spinrate)
{
llSetKeyframedMotion( [], []);
if ( spinrate )
{
float v = TWO_PI/3.0;
if ( spinrate < 0 ) v = -v;
list L = [llAxisAngle2Rot( axis/llGetRot(), v), v/spinrate];
llSetKeyframedMotion( L+L+L, [KFM_DATA, KFM_ROTATION, KFM_MODE, KFM_LOOP]);
}
}

default
{
state_entry()
{
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]);
}
touch_end( integer n)
{
P = ++P%4;
if ( P == 1 ) KeyFramedOmega( <0,0,1>, 2.0); // Positive spin
else if ( P == 3 ) KeyFramedOmega( <0,0,1>, -2.0); // Negative spin
else KeyFramedOmega( <0,0,1>, 0.0); // Stop spin
}
}
</lsl>
|helpers
|also_header
|also_functions=: [[llTargetOmega]]
: [[llSetKeyframedMotion]]
|also_tests
|also_events
|also_articles
|also_footer
|notes=The magnitude of ''axis'' do '''not''' influence the ''spinrate''
|mode=user
|deprecated
|location=[[User:Dora_Gustafson/Replacing_llTargetOmega/function|The Function]]
|cat1=Rotation
|cat2=Examples
|signature=[[User:Dora Gustafson|Dora Gustafson]] 04:36, 12 August 2014 (PDT)
}}

LlTargetOmega Replacement

2014-10-01T12:31:57Z

Dora Gustafson:

{{LSL_Function
|func=KeyFramedOmega
|func_id
|func_sleep
|func_energy
|func_desc=Rotates the object/prim around axis at a rate of spinrate in radians per second
|func_footnote
|return_type
|return_text
|p1_type=vector
|p1_name=axis
|p1_desc=arbitrary axis to rotate the object around
|p1_hover
|p2_type=float
|p2_name=spinrate
|p2_desc=rate of rotation in radians per second
|p2_hover
|constants
|spec=
: This doesn't make [[llTargetOmega]] redundant but in some cases a Key Framed motion may be preferred
: The routine: [[KeyFramedOmega]] is easy to use for [[llTargetOmega]]: It takes the first two parameters in [[llTargetOmega]]: axis and spinrate
: All viewers will see the same spin and rotation
: The object will keep the rotation it has when spin is stopped
: A spin will continue even when the script is deleted
|caveats=
: The script must be in the root prim
: It can not spin child prims
: The object must be convex hull physics type
: Can not spin physical objects
|examples=
This script shows how to use the routine to start, stop and reverse a spin on repeated touches
<lsl>
// llTargetOmega substitution by Dora Gustafson, Studio Dora 2014

integer P;

KeyFramedOmega( vector axis, float spinrate)
{
llSetKeyframedMotion( [], []);
if ( spinrate )
{
float v = TWO_PI/3.0;
if ( spinrate < 0 ) v = -v;
list L = [llAxisAngle2Rot( axis/llGetRot(), v), v/spinrate];
llSetKeyframedMotion( L+L+L, [KFM_DATA, KFM_ROTATION, KFM_MODE, KFM_LOOP]);
}
}

default
{
state_entry()
{
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]);
}
touch_end( integer n)
{
P = ++P%4;
if ( P == 1 ) KeyFramedOmega( <0,0,1>, 2.0); // Positive spin
else if ( P == 3 ) KeyFramedOmega( <0,0,1>, -2.0); // Negative spin
else KeyFramedOmega( <0,0,1>, 0.0); // Stop spin
}
}
</lsl>
|helpers
|also_header
|also_functions=: [[llTargetOmega]]
: [[llSetKeyframedMotion]]
|also_tests
|also_events
|also_articles
|also_footer
|notes=The magnitude of ''axis'' do '''not''' influence the ''spinrate''
|mode=user
|deprecated
|location=[[User:Dora_Gustafson/Replacing_llTargetOmega/function|The Function]]
|cat1=Rotation
|cat2=Examples
|signature=[[User:Dora Gustafson|Dora Gustafson]] 04:36, 12 August 2014 (PDT)
}}

User:Dora Gustafson

2014-10-01T12:17:35Z

Dora Gustafson: /* Highlighted scripts */

User:Dora Gustafson/Replacing llTargetOmega

2014-10-01T12:15:56Z

Dora Gustafson: Replaced content with "== Content moved == Moved to LlTargetOmega_Replacement : ~~~~"

== Content moved ==
Moved to [[LlTargetOmega_Replacement]]
: [[User:Dora Gustafson|Dora Gustafson]] 05:15, 1 October 2014 (PDT)

LlTargetOmega Replacement

2014-10-01T11:59:09Z

Dora Gustafson: Created page with "{{LSL_Function |func=KeyFramedOmega |func_id |func_sleep |func_energy |func_desc=Rotates the object/prim around axis at a rate of spinrate in radians per second |func_footnote |r…"

{{LSL_Function
|func=KeyFramedOmega
|func_id
|func_sleep
|func_energy
|func_desc=Rotates the object/prim around axis at a rate of spinrate in radians per second
|func_footnote
|return_type
|return_text
|p1_type=vector
|p1_name=axis
|p1_desc=arbitrary axis to rotate the object around
|p1_hover
|p2_type=float
|p2_name=spinrate
|p2_desc=rate of rotation in radians per second
|p2_hover
|constants
|spec=
: This doesn't make [[llTargetOmega]] redundant but in some cases a Key Framed motion may be preferred
: The routine: "KeyFramedOmega" is easy to use for [[llTargetOmega]]: It takes the first two parameters in [[llTargetOmega]]: axis and spinrate
: All viewers will see the same spin and rotation
: The object will keep the rotation it has when spin is stopped
: A spin will continue even when the script is deleted
|caveats=
: The script must be in the root prim
: It can not spin child prims
: The object must be convex hull physics type
: Can not spin physical objects
|examples=
This script shows how to use the routine to start, stop and reverse a spin on repeated touches
<lsl>
// llTargetOmega substitution by Dora Gustafson, Studio Dora 2014

integer P;

KeyFramedOmega( vector axis, float spinrate)
{
llSetKeyframedMotion( [], []);
if ( spinrate )
{
float v = TWO_PI/3.0;
if ( spinrate < 0 ) v = -v;
list L = [llAxisAngle2Rot( axis/llGetRot(), v), v/spinrate];
llSetKeyframedMotion( L+L+L, [KFM_DATA, KFM_ROTATION, KFM_MODE, KFM_LOOP]);
}
}

default
{
state_entry()
{
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]);
}
touch_end( integer n)
{
P = ++P%4;
if ( P == 1 ) KeyFramedOmega( <0,0,1>, 2.0); // Positive spin
else if ( P == 3 ) KeyFramedOmega( <0,0,1>, -2.0); // Negative spin
else KeyFramedOmega( <0,0,1>, 0.0); // Stop spin
}
}
</lsl>
|helpers
|also_header
|also_functions=: [[llTargetOmega]]
: [[llSetKeyframedMotion]]
|also_tests
|also_events
|also_articles
|also_footer
|notes=The magnitude of ''axis'' do '''not''' influence the ''spinrate''
|mode=user
|deprecated
|location=[[User:Dora_Gustafson/Replacing_llTargetOmega/function|The Function]]
|cat1=Rotation
|cat2=Examples
|signature=[[User:Dora Gustafson|Dora Gustafson]] 04:36, 12 August 2014 (PDT)
}}

VEHICLE REFERENCE FRAME

2014-09-17T18:16:28Z

Dora Gustafson: Undo revision 1193477 by Dora Gustafson (Talk)

{{LSL Constant
|name=VEHICLE_REFERENCE_FRAME
|type=integer
|value=44
|desc=Used to set the rotation of vehicle axes relative to local frame.
|examples=The rotation for the reference frame can be found in two steps:
# Place the vehicle with front facing east(red arrow) and with left side facing north(green arrow)
# now: [[rotation]] refFrame = [[ZERO_ROTATION]] / [[llGetRootRotation]]();
|events
|functions={{LSL DefineRow||[[llSetVehicleRotationParam]]}}
|location
|history
|comment
|articles={{LSL DefineRow||[[Linden Vehicle Tutorial]]}}
|cat1=Vehicle/Parameters
|cat2
|cat3
|cat4
|cat5
|cat6
}}

LlSetVehicleRotationParam

2014-09-17T18:13:24Z

Dora Gustafson:

{{LSL_Function
|func_id=235|func_sleep=0.0|func_energy=10.0
|func=llSetVehicleRotationParam
|p1_type=integer|p1_name=param|p1_desc=VEHICLE_* flag
|p2_type=rotation|p2_name=rot
|func_footnote
|func_desc=Sets the vehicle rotation parameter {{LSLP|param}} to {{LSLP|rot}}.
|return_text
|spec
|caveats
|constants={{LSL Constants/Vehicle|type=rotation}}
|examples=The reference frame can be computed and set in two steps:
# Place the vehicle with front facing east(red arrow) and with left side facing north(green arrow)
# [[llSetVehicleRotationParam]]( [[VEHICLE_REFERENCE_FRAME]], [[ZERO_ROTATION]] / [[llGetRootRotation]]());
|helpers
|also_functions={{LSL DefineRow||{{LSLG|llSetVehicleFloatParam}}|Sets a vehicle float parameter}}
{{LSL DefineRow||{{LSLG|llSetVehicleVectorParam}}|Sets a vehicle vector parmeter}}
|also_events
|also_tests
|also_articles={{LSL DefineRow||[[Linden Vehicle Tutorial]]}}
|notes
|permission
|cat1=Vehicle
|cat2
|cat3
|cat4
}}

VEHICLE REFERENCE FRAME

2014-09-17T18:04:34Z

Dora Gustafson:

{{LSL Constant
|name=VEHICLE_REFERENCE_FRAME
|type=integer
|value=44
|desc=Used to set the rotation of vehicle axes relative to local frame.
|examples
|events
|functions={{LSL DefineRow||[[llSetVehicleRotationParam]]}}
|location
|history
|comment
|articles={{LSL DefineRow||[[Linden Vehicle Tutorial]]}}
|cat1=Vehicle/Parameters
|cat2
|cat3
|cat4
|cat5
|cat6
}}

VEHICLE REFERENCE FRAME

2014-09-17T17:31:00Z

Dora Gustafson:

{{LSL Constant
|name=VEHICLE_REFERENCE_FRAME
|type=integer
|value=44
|desc=Used to set the rotation of vehicle axes relative to local frame.
|examples=The reference frame can be found in two steps:
# Place the vehicle with front facing east(red arrow) and with left side facing north(green arrow)
# now: [[rotation]] refFrame = [[ZERO_ROTATION]] / [[llGetRootRotation]]();
|events
|functions={{LSL DefineRow||[[llSetVehicleRotationParam]]}}
|location
|history
|comment
|articles={{LSL DefineRow||[[Linden Vehicle Tutorial]]}}
|cat1=Vehicle/Parameters
|cat2
|cat3
|cat4
|cat5
|cat6
}}

VEHICLE REFERENCE FRAME

2014-09-17T17:23:30Z

Dora Gustafson: get reference frame

{{LSL Constant
|name=VEHICLE_REFERENCE_FRAME
|type=integer
|value=44
|desc=Used to set the rotation of vehicle axes relative to local frame.
|examples=The reference frame can be found in two steps:
# Place the vehicle with front facing east(red arrow) and with left side facing north(green arrow)
# now: rotation refFrame = ZERO_ROTATION / llGetRootRotation();
|events
|functions={{LSL DefineRow||[[llSetVehicleRotationParam]]}}
|location
|history
|comment
|articles={{LSL DefineRow||[[Linden Vehicle Tutorial]]}}
|cat1=Vehicle/Parameters
|cat2
|cat3
|cat4
|cat5
|cat6
}}

User:Dora Gustafson/Replacing llTargetOmega

2014-08-12T14:38:06Z

Dora Gustafson:

{{LSL_Function
|func=KeyFramedOmega
|func_id
|func_sleep
|func_energy
|func_desc=Rotates the object/prim around axis at a rate of spinrate in radians per second
|func_footnote
|return_type
|return_text
|p1_type=vector
|p1_name=axis
|p1_desc=arbitrary axis to rotate the object around
|p1_hover
|p2_type=float
|p2_name=spinrate
|p2_desc=rate of rotation in radians per second
|p2_hover
|constants
|spec=
: This doesn't make [[llTargetOmega]] redundant but in some cases a Key Framed motion may be preferred
: The routine: "KeyFramedOmega" is easy to use for [[llTargetOmega]]: It takes the first two parameters in [[llTargetOmega]]: axis and spinrate
: All viewers will see the same spin and rotation
: The object will keep the rotation it has when spin is stopped
: A spin will continue even when the script is deleted
|caveats=
: The script must be in the root prim
: It can not spin child prims
: The object must be convex hull physics type
: Can not spin physical objects
|examples=
This script shows how to use the routine to start, stop and reverse a spin on repeated touches
<lsl>
// llTargetOmega substitution by Dora Gustafson, Studio Dora 2014

integer P;

KeyFramedOmega( vector axis, float spinrate)
{
llSetKeyframedMotion( [], []);
if ( spinrate )
{
float v = TWO_PI/3.0;
if ( spinrate < 0 ) v = -v;
list L = [llAxisAngle2Rot( axis/llGetRot(), v), v/spinrate];
llSetKeyframedMotion( L+L+L, [KFM_DATA, KFM_ROTATION, KFM_MODE, KFM_LOOP]);
}
}

default
{
state_entry()
{
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]);
}
touch_end( integer n)
{
P = ++P%4;
if ( P == 1 ) KeyFramedOmega( <0,0,1>, 2.0); // Positive spin
else if ( P == 3 ) KeyFramedOmega( <0,0,1>, -2.0); // Negative spin
else KeyFramedOmega( <0,0,1>, 0.0); // Stop spin
}
}
</lsl>
|helpers
|also_header
|also_functions=: [[llTargetOmega]]
: [[llSetKeyframedMotion]]
|also_tests
|also_events
|also_articles
|also_footer
|notes=The magnitude of ''axis'' do '''not''' influence the ''spinrate''
|mode=user
|deprecated
|location=[[User:Dora_Gustafson/Replacing_llTargetOmega/function|The Function]]
|cat1=Rotation
|cat2=Examples
|signature=[[User:Dora Gustafson|Dora Gustafson]] 04:36, 12 August 2014 (PDT)
}}

User:Dora Gustafson/Replacing llTargetOmega

2014-08-12T11:52:28Z

Dora Gustafson:

{{LSL_Function
|func=KeyFramedOmega
|func_id
|func_sleep
|func_energy
|func_desc=Rotates the object/prim around axis at a rate of spinrate in radians per second
|func_footnote
|return_type
|return_text
|p1_type=vector
|p1_name=axis
|p1_desc=arbitrary axis to rotate the object around
|p1_hover
|p2_type=float
|p2_name=spinrate
|p2_desc=rate of rotation in radians per second
|p2_hover
|constants
|spec=
: This doesn't make [[llTargetOmega]] redundant but in some cases a Key Framed motion may be preferred
: The routine: "KeyFramedOmega" is easy to use for [[llTargetOmega]]: It takes the first two parameters in [[llTargetOmega]]: axis and spinrate
: All viewers will see the same spin and rotation
: The object will keep the rotation it has when spin is stopped
: A spin will continue even when the script is deleted
|caveats=
: The script must be in the root prim
: It can not spin child prims
: The object must be convex hull physics type
: Can not spin physical objects
|examples=
This script shows how to use the routine to start, stop and reverse a spin on repeated touches
<lsl>
// llTargetOmega substitution by Dora Gustafson, Studio Dora 2014

integer P;

KeyFramedOmega( vector axis, float spinrate)
{
llSetKeyframedMotion( [], []);
if ( spinrate )
{
float v = TWO_PI/3.0;
if ( spinrate < 0 ) v = -v;
list L = [llAxisAngle2Rot( axis/llGetRot(), v), v/spinrate];
llSetKeyframedMotion( L+L+L, [KFM_DATA, KFM_ROTATION, KFM_MODE, KFM_LOOP]);
}
}

default
{
state_entry()
{
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]);
}
touch_end( integer n)
{
P = ++P%4;
if ( P == 1 ) KeyFramedOmega( <0,0,1>, 2.0); // Positive spin
else if ( P == 3 ) KeyFramedOmega( <0,0,1>, -2.0); // Negative spin
else KeyFramedOmega( <0,0,1>, 0.0); // Stop spin
}
}
</lsl>
|helpers
|also_header
|also_functions=: [[llTargetOmega]]
: [[llSetKeyframedMotion]]
|also_tests
|also_events
|also_articles
|also_footer
|notes
|mode=user
|deprecated
|location=[[User:Dora_Gustafson/Replacing_llTargetOmega/function|The Function]]
|cat1=Rotation
|cat2=Examples
|signature=[[User:Dora Gustafson|Dora Gustafson]] 04:36, 12 August 2014 (PDT)
}}

User:Dora Gustafson/Replacing llTargetOmega

2014-08-12T11:45:22Z

Dora Gustafson:

{{LSL_Function
|func=KeyFramedOmega
|func_id
|func_sleep
|func_energy
|func_desc=Rotates the object/prim around axis at a rate of spinrate in radians per second
|func_footnote
|return_type
|return_text
|p1_type=vector
|p1_name=axis
|p1_desc=arbitrary axis to rotate the object around
|p1_hover
|p2_type=float
|p2_name=spinrate
|p2_desc=rate of rotation in radians per second
|p2_hover
|constants
|spec=
: This doesn't make [[llTargetOmega]] redundant but in some cases a Key Framed motion may be preferred
: The routine: "KeyFramedOmega" is easy to use for [[llTargetOmega]]: It takes the first two parameters in [[llTargetOmega]]: axis and spinrate
: All viewers will see the same spin and rotation
: The object will keep the rotation it has when spin is stopped
: A spin will continue even when the script is deleted
|caveats=
: The script must be in the root prim
: It can not spin child prims
: The object must be convex hull physics type
: Can not spin physical objects
|examples=
This script shows how to use the routine to start, stop and reverse a spin on repeated touches
<lsl>
// llTargetOmega substitution by Dora Gustafson, Studio Dora 2014

integer P;

KeyFramedOmega( vector axis, float spinrate)
{
llSetKeyframedMotion( [], []);
if ( spinrate )
{
float v = TWO_PI/3.0;
if ( spinrate < 0 ) v = -v;
list L = [llAxisAngle2Rot( axis/llGetRot(), v), v/spinrate];
llSetKeyframedMotion( L+L+L, [KFM_DATA, KFM_ROTATION, KFM_MODE, KFM_LOOP]);
}
}

default
{
state_entry()
{
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]);
}
touch_end( integer n)
{
P = ++P%4;
if ( P == 1 ) KeyFramedOmega( <0,0,1>, 2.0); // Positive spin
else if ( P == 3 ) KeyFramedOmega( <0,0,1>, -2.0); // Negative spin
else KeyFramedOmega( <0,0,1>, 0.0); // Stop spin
}
}
</lsl>
|helpers
|also_header
|also_functions=: [[llTargetOmega]]
: [[llSetKeyframedMotion]]
|also_tests
|also_events
|also_articles
|also_footer
|notes
|mode=user
|deprecated
|location=[[User:Dora_Gustafson/Replacing_llTargetOmega/function|The Function]]
|cat1=Rotation
|cat2=LSL Examples
|signature=[[User:Dora Gustafson|Dora Gustafson]] 04:36, 12 August 2014 (PDT)
}}

User:Dora Gustafson/Replacing llTargetOmega

2014-08-12T11:36:38Z

Dora Gustafson:

{{LSL_Function
|func=KeyFramedOmega
|func_id
|func_sleep
|func_energy
|func_desc=Rotates the object/prim around axis at a rate of spinrate in radians per second
|func_footnote
|return_type
|return_text
|p1_type=vector
|p1_name=axis
|p1_desc=arbitrary axis to rotate the object around
|p1_hover
|p2_type=float
|p2_name=spinrate
|p2_desc=rate of rotation in radians per second
|p2_hover
|constants
|spec=
: This doesn't make [[llTargetOmega]] redundant but in some cases a Key Framed motion may be preferred
: The routine: "KeyFramedOmega" is easy to use for [[llTargetOmega]]: It takes the first two parameters in [[llTargetOmega]]: axis and spinrate
: All viewers will see the same spin and rotation
: The object will keep the rotation it has when spin is stopped
: A spin will continue even when the script is deleted
|caveats=
: The script must be in the root prim
: It can not spin child prims
: The object must be convex hull physics type
: Can not spin physical objects
|examples=
This script shows how to use the routine to start, stop and reverse a spin on repeated touches
<lsl>
// llTargetOmega substitution by Dora Gustafson, Studio Dora 2014

integer P;

KeyFramedOmega( vector axis, float spinrate)
{
llSetKeyframedMotion( [], []);
if ( spinrate )
{
float v = TWO_PI/3.0;
if ( spinrate < 0 ) v = -v;
list L = [llAxisAngle2Rot( axis/llGetRot(), v), v/spinrate];
llSetKeyframedMotion( L+L+L, [KFM_DATA, KFM_ROTATION, KFM_MODE, KFM_LOOP]);
}
}

default
{
state_entry()
{
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]);
}
touch_end( integer n)
{
P = ++P%4;
if ( P == 1 ) KeyFramedOmega( <0,0,1>, 2.0); // Positive spin
else if ( P == 3 ) KeyFramedOmega( <0,0,1>, -2.0); // Negative spin
else KeyFramedOmega( <0,0,1>, 0.0); // Stop spin
}
}
</lsl>
|helpers
|also_header
|also_functions=[[llTargetOmega]]
|also_tests
|also_events
|also_articles=[[llSetKeyframedMotion]]
|also_footer
|notes
|mode=user
|deprecated
|location=[[User:Dora_Gustafson/Replacing_llTargetOmega/function|The Function]]
|cat1=Rotation
|cat2
|signature=[[User:Dora Gustafson|Dora Gustafson]] 04:36, 12 August 2014 (PDT)
}}

User:Dora Gustafson/Replacing llTargetOmega

2014-08-12T11:32:10Z

Dora Gustafson:

{{LSL_Function
|func=KeyFramedOmega
|func_id
|func_sleep
|func_energy
|func_desc=Rotates the object/prim around axis at a rate of spinrate in radians per second
|func_footnote
|return_type
|return_text
|p1_type=vector
|p1_name=axis
|p1_desc=arbitrary axis to rotate the object around
|p1_hover
|p2_type=float
|p2_name=spinrate
|p2_desc=rate of rotation in radians per second
|p2_hover
|constants
|spec=
: This doesn't make [[llTargetOmega]] redundant but in some cases a Key Framed motion may be preferred
: The routine: "KeyFramedOmega" is easy to use for [[llTargetOmega]]: It takes the first two parameters in [[llTargetOmega]]: axis and spinrate
: All viewers will see the same spin and rotation
: The object will keep the rotation it has when spin is stopped
: A spin will continue even when the script is deleted
|caveats=
: The script must be in the root prim
: It can not spin child prims
: The object must be convex hull physics type
: Can not spin physical objects
|examples=
This script shows how to use the routine to start, stop and reverse a spin on repeated touches
<lsl>
// llTargetOmega substitution by Dora Gustafson, Studio Dora 2014

integer P;

KeyFramedOmega( vector axis, float spinrate)
{
llSetKeyframedMotion( [], []);
if ( spinrate )
{
float v = TWO_PI/3.0;
if ( spinrate < 0 ) v = -v;
list L = [llAxisAngle2Rot( axis/llGetRot(), v), v/spinrate];
llSetKeyframedMotion( L+L+L, [KFM_DATA, KFM_ROTATION, KFM_MODE, KFM_LOOP]);
}
}

default
{
state_entry()
{
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]);
}
touch_end( integer n)
{
P = ++P%4;
if ( P == 1 ) KeyFramedOmega( <0,0,1>, 2.0); // Positive spin
else if ( P == 3 ) KeyFramedOmega( <0,0,1>, -2.0); // Negative spin
else KeyFramedOmega( <0,0,1>, 0.0); // Stop spin
}
}
</lsl>
|helpers
|also_header
|also_functions=[[llTargetOmega]]
|also_tests
|also_events
|also_articles=[[llSetKeyframedMotion]]
|also_footer
|notes
|mode=user
|deprecated
|location=[[User:Dora_Gustafson/Replacing_llTargetOmega/function|The Function]]
|cat1=Rotation
|cat2
}}

User:Dora Gustafson/Replacing llTargetOmega/function

2014-08-12T11:05:50Z

Dora Gustafson: KeyFramedOmega function

== Replacing llTargetOmega, the function ==
<lsl>
KeyFramedOmega( vector axis, float spinrate)
{
llSetKeyframedMotion( [], []);
if ( spinrate )
{
float v = TWO_PI/3.0;
if ( spinrate < 0 ) v = -v;
list L = [llAxisAngle2Rot( axis/llGetRot(), v), v/spinrate];
llSetKeyframedMotion( L+L+L, [KFM_DATA, KFM_ROTATION, KFM_MODE, KFM_LOOP]);
}
}
</lsl>

User:Dora Gustafson/Replacing llTargetOmega

2014-08-12T10:47:27Z

Dora Gustafson:

== Replacing llTargetOmega with a Key Framed Motion ==
<lsl>
KeyFramedOmega( vector axis, float spinrate)
{
llSetKeyframedMotion( [], []);
if ( spinrate )
{
float v = TWO_PI/3.0;
if ( spinrate < 0 ) v = -v;
list L = [llAxisAngle2Rot( axis/llGetRot(), v), v/spinrate];
llSetKeyframedMotion( L+L+L, [KFM_DATA, KFM_ROTATION, KFM_MODE, KFM_LOOP]);
}
}
</lsl>
{{LSL_Function
|func=KeyFramedOmega
|func_id
|func_sleep
|func_energy
|func_desc=Rotates the object/prim around axis at a rate of spinrate in radians per second
|func_footnote
|return_type
|return_text
|p1_type=vector
|p1_name=axis
|p1_desc=arbitrary axis to rotate the object around
|p1_hover
|p2_type=float
|p2_name=spinrate
|p2_desc=rate of rotation in radians per second
|p2_hover
|constants
|spec=
: This doesn't make [[llTargetOmega]] redundant but in some cases a Key Framed motion may be preferred
: The routine: "KeyFramedOmega" is easy to use for [[llTargetOmega]]: It takes the first two parameters in [[llTargetOmega]]: axis and spinrate
: All viewers will see the same spin and rotation
: The object will keep the rotation it has when spin is stopped
: A spin will continue even when the script is deleted
|caveats=
: The script must be in the root prim
: It can not spin child prims
: The object must be convex hull physics type
: Can not spin physical objects
|examples=
This script shows how to use the routine to start, stop and reverse a spin on repeated touches
<lsl>
// llTargetOmega substitution by Dora Gustafson, Studio Dora 2014

integer P;

KeyFramedOmega( vector axis, float spinrate)
{
llSetKeyframedMotion( [], []);
if ( spinrate )
{
float v = TWO_PI/3.0;
if ( spinrate < 0 ) v = -v;
list L = [llAxisAngle2Rot( axis/llGetRot(), v), v/spinrate];
llSetKeyframedMotion( L+L+L, [KFM_DATA, KFM_ROTATION, KFM_MODE, KFM_LOOP]);
}
}

default
{
state_entry()
{
llSetPrimitiveParams([PRIM_PHYSICS_SHAPE_TYPE, PRIM_PHYSICS_SHAPE_CONVEX]);
}
touch_end( integer n)
{
P = ++P%4;
if ( P == 1 ) KeyFramedOmega( <0,0,1>, 2.0); // Positive spin
else if ( P == 3 ) KeyFramedOmega( <0,0,1>, -2.0); // Negative spin
else KeyFramedOmega( <0,0,1>, 0.0); // Stop spin
}
}
</lsl>
|helpers
|also_header
|also_functions=[[llTargetOmega]]
|also_tests
|also_events
|also_articles=[[llSetKeyframedMotion]]
|also_footer
|notes
|mode=user
|deprecated
|location
|cat1=LSL Rotation
}}