Repulsion between physical and other objects

For a swing, the trick for natural motion is to use llSin() to calculate
angles for llSetRot().  This gives you the deceleration at the top of the
swing so you don't have a jerky direction reversal.

AnnMarie Otoole

----- Original Message -----
From: "Barrington John" <sl.barrington.john@...>
To: <secondlifescripters@...>
Sent: Thursday, September 04, 2008 6:17 AM
Subject: Re: Repulsion between physical and other objects

> Something to bear in mind here is that smoothness
> of movement is surprisingly subjective.
>
> Recently, I made a swing for my partner  and
> started off using llSetRot() to make it happen,
> but couldn't get it smooth enough for my own
> tastes - using it was actually nauseating for
> me.  My partner, however, was perfectly happy
> with the movement.  I was not.  Since this was a
> labour of love rather than Lindens, I kept
> investigating - people I spoke to who'd made
> swings (all using the same method with varying
> parameters) were adamant that their swings were
> "smooth" - I, on the other hand, found every one
> of these swings to be very unpleasant to use,
> rather to their builders' bafflement. Impasse.
>
> In the end, I changed the movement in my own
> swing to use llTargetOmega() and was delighted to
> find it completely free from any jerkiness.  My
> partner kind of agreed that it was a better
> experience and we started to use the swing a lot
> more.
>
> Now, whenever we come across a swing or a hammock
> in our SL travels, it is she as much as me who
> remarks that the swing at home is far more
> pleasant to use.  Meanwhile, the builders of
> llSetRot() systems continue to be perfectly happy
> with their own creations.  It's incredible how
> subjective it is, and what is fine to one person
> can actually be genuinely unpleasant,
> even nauseating, to another.
>
> I'd be very interested to visit your llSetRot()
> Ferris wheel in-world, to see if I could ride it
> without feeling ill, and to compare notes with
> someone who found the movement fine to use; I
> find it hard to believe that the difference is
> purely psychological, and wonder if it's to do
> with different hardware.
>
> On Wed, 3 Sep 2008 07:09:38 -0700
> Jippen <cheetahmorph@...> wrote:
>

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

[Glen Canaday]

Ann,

oo? How does that work? /me looks for example...

G

AnnMarie@... wrote:

> For a swing, the trick for natural motion is to use llSin() to
> calculate angles for llSetRot().  This gives you the deceleration at
> the top of the swing so you don't have a jerky direction reversal.
>
> AnnMarie Otoole
>
> ----- Original Message ----- From: "Barrington John"
> <sl.barrington.john@...>
> To: <secondlifescripters@...>
> Sent: Thursday, September 04, 2008 6:17 AM
> Subject: Re: Repulsion between physical and other objects
>
>
>> Something to bear in mind here is that smoothness
>> of movement is surprisingly subjective.
>>
>> Recently, I made a swing for my partner  and
>> started off using llSetRot() to make it happen,
>> but couldn't get it smooth enough for my own
>> tastes - using it was actually nauseating for
>> me.  My partner, however, was perfectly happy
>> with the movement.  I was not.  Since this was a
>> labour of love rather than Lindens, I kept
>> investigating - people I spoke to who'd made
>> swings (all using the same method with varying
>> parameters) were adamant that their swings were
>> "smooth" - I, on the other hand, found every one
>> of these swings to be very unpleasant to use,
>> rather to their builders' bafflement. Impasse.
>>
>> In the end, I changed the movement in my own
>> swing to use llTargetOmega() and was delighted to
>> find it completely free from any jerkiness.  My
>> partner kind of agreed that it was a better
>> experience and we started to use the swing a lot
>> more.
>>
>> Now, whenever we come across a swing or a hammock
>> in our SL travels, it is she as much as me who
>> remarks that the swing at home is far more
>> pleasant to use.  Meanwhile, the builders of
>> llSetRot() systems continue to be perfectly happy
>> with their own creations.  It's incredible how
>> subjective it is, and what is fine to one person
>> can actually be genuinely unpleasant,
>> even nauseating, to another.
>>
>> I'd be very interested to visit your llSetRot()
>> Ferris wheel in-world, to see if I could ride it
>> without feeling ill, and to compare notes with
>> someone who found the movement fine to use; I
>> find it hard to believe that the difference is
>> purely psychological, and wonder if it's to do
>> with different hardware.
>>
>> On Wed, 3 Sep 2008 07:09:38 -0700
>> Jippen <cheetahmorph@...> wrote:
>>
>
> _______________________________________________
> Click here to unsubscribe or manage your list subscription:
> https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters
>

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

It is a long time since I did one and mine was a vertical motion but from
memory, here is an outline on how to go about it.

The program has two segments.  The first to generate a list of numbers that
runs only if you change swing parameters.
This list of numbers is used by the second program segment that moves the
swing.
For the first part that generates the data list:-
You decide how many steps you want to do from peak to peak on the swing.
This can be user-setable if you want to adjust smoothness.
Divide 180 degrees by this number to get the step angle for looking up.
Start at 90 degrees and step to -90 degrees (converted to radians) and look
up the llSin() of these angles and put them in a list.
This will give you a list of numbers starting at +1 and ending at -1.
You now step through this list to create a second list.
You need to scale and convert the numbers from +1 through -1 to an angle for
llSetRot().
So +1 will correspond to the highest point on the swing, say 35 degrees
(which can be user adjustable too).
zero will correspond to swing vertical
-1 corresponds to swing back 35 degrees, all converted to radians.

You run this segment as needed to create the working list that contains the
angles that are plugged into llSetRot() only on rez, or when user wants to
change one of the parameters.

To run the swing have it sit at half way through the list (vertical) if you
want it to be able to stop.
When it starts, step through the list using a timer set to total swing time
divided by the number of steps (can be user adjustable).
You will be stepping from mid point on the list to the bottom, then reverse
and step through to the top, then reverse again.
On each step put the list angle value into llSetRot().

Although it is not physical, there is some smoothing built into llSetRot()
changes, they don't move instantaneoulsy so experiment to find the minimum
number of steps that looks smooth and reduces computing overhead.

If you want to get REALLY fancy, you can let the swing accelerate/decelerate
on start/stop by changing the 35 degree angle in increasing/decreasing steps
from/to zero, recalculating the angle list each time.

I'm sure the above could be written to calculate the angles on the fly
instead of using the list look-up but I did it this way.  It is easier to
understand and is probably less processing load on the sim computer.

AnnMarie Otoole.


----- Original Message -----
From: "G" <gcanaday@...>
To: <secondlifescripters@...>
Sent: Thursday, September 04, 2008 11:22 AM
Subject: Re: Repulsion between physical and other objects


>
> Ann,
>
> oo? How does that work? /me looks for example...
>
> G
>

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

[logan.park]

what about multithreading the setRots for smoother movement.  As in Jesrad Seraph's nonphys vehicle?  Possibly overkill for a swing application. :)
Kage

On Thu, Sep 4, 2008 at 12:34 PM, <AnnMarie@...> wrote:

It is a long time since I did one and mine was a vertical motion but from memory, here is an outline on how to go about it.

The program has two segments.  The first to generate a list of numbers that runs only if you change swing parameters.
This list of numbers is used by the second program segment that moves the swing.
For the first part that generates the data list:-
You decide how many steps you want to do from peak to peak on the swing.
This can be user-setable if you want to adjust smoothness.
Divide 180 degrees by this number to get the step angle for looking up.
Start at 90 degrees and step to -90 degrees (converted to radians) and look up the llSin() of these angles and put them in a list.
This will give you a list of numbers starting at +1 and ending at -1.
You now step through this list to create a second list.
You need to scale and convert the numbers from +1 through -1 to an angle for llSetRot().
So +1 will correspond to the highest point on the swing, say 35 degrees (which can be user adjustable too).
zero will correspond to swing vertical
-1 corresponds to swing back 35 degrees, all converted to radians.

You run this segment as needed to create the working list that contains the angles that are plugged into llSetRot() only on rez, or when user wants to change one of the parameters.

To run the swing have it sit at half way through the list (vertical) if you want it to be able to stop.
When it starts, step through the list using a timer set to total swing time divided by the number of steps (can be user adjustable).
You will be stepping from mid point on the list to the bottom, then reverse and step through to the top, then reverse again.
On each step put the list angle value into llSetRot().

Although it is not physical, there is some smoothing built into llSetRot() changes, they don't move instantaneoulsy so experiment to find the minimum number of steps that looks smooth and reduces computing overhead.

If you want to get REALLY fancy, you can let the swing accelerate/decelerate on start/stop by changing the 35 degree angle in increasing/decreasing steps from/to zero, recalculating the angle list each time.

I'm sure the above could be written to calculate the angles on the fly instead of using the list look-up but I did it this way.  It is easier to understand and is probably less processing load on the sim computer.

AnnMarie Otoole.


----- Original Message ----- From: "G" <gcanaday@...>
To: <secondlifescripters@...>
Sent: Thursday, September 04, 2008 11:22 AM
Subject: Re: Repulsion between physical and other objects

Ann,

oo? How does that work? /me looks for example...

G

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

[Glen Canaday]

Ouch, that's a lot of work. It might be easier to simply use two
llSetRots on a timer that's a little too short to actually complete the
rotation, thus relying on the built-in smoothing for the direction
change rather than having the abrupt stop when rotation completes, since
it never completes... haven't tried it that way though, and there's no
way to change the rotation speed since the llSetRot() calls are pretty
static in how long they take to complete.

omg that was a long sentence.

G

AnnMarie@... wrote:

> It is a long time since I did one and mine was a vertical motion but
> from memory, here is an outline on how to go about it.
>
> The program has two segments.  The first to generate a list of numbers
> that runs only if you change swing parameters.
> This list of numbers is used by the second program segment that moves
> the swing.
> For the first part that generates the data list:-
> You decide how many steps you want to do from peak to peak on the swing.
> This can be user-setable if you want to adjust smoothness.
> Divide 180 degrees by this number to get the step angle for looking up.
> Start at 90 degrees and step to -90 degrees (converted to radians) and
> look up the llSin() of these angles and put them in a list.
> This will give you a list of numbers starting at +1 and ending at -1.
> You now step through this list to create a second list.
> You need to scale and convert the numbers from +1 through -1 to an
> angle for llSetRot().
> So +1 will correspond to the highest point on the swing, say 35
> degrees (which can be user adjustable too).
> zero will correspond to swing vertical
> -1 corresponds to swing back 35 degrees, all converted to radians.
>
> You run this segment as needed to create the working list that
> contains the angles that are plugged into llSetRot() only on rez, or
> when user wants to change one of the parameters.
>
> To run the swing have it sit at half way through the list (vertical)
> if you want it to be able to stop.
> When it starts, step through the list using a timer set to total swing
> time divided by the number of steps (can be user adjustable).
> You will be stepping from mid point on the list to the bottom, then
> reverse and step through to the top, then reverse again.
> On each step put the list angle value into llSetRot().
>
> Although it is not physical, there is some smoothing built into
> llSetRot() changes, they don't move instantaneoulsy so experiment to
> find the minimum number of steps that looks smooth and reduces
> computing overhead.
>
> If you want to get REALLY fancy, you can let the swing
> accelerate/decelerate on start/stop by changing the 35 degree angle in
> increasing/decreasing steps from/to zero, recalculating the angle list
> each time.
>
> I'm sure the above could be written to calculate the angles on the fly
> instead of using the list look-up but I did it this way.  It is easier
> to understand and is probably less processing load on the sim computer.
>
> AnnMarie Otoole.
>
>
> ----- Original Message ----- From: "G" <gcanaday@...>
> To: <secondlifescripters@...>
> Sent: Thursday, September 04, 2008 11:22 AM
> Subject: Re: Repulsion between physical and other objects
>
>
>>
>> Ann,
>>
>> oo? How does that work? /me looks for example...
>>
>> G
>>
>
>

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

[logan.park]

I think the issue of timered setRot leads to jerkiness-- there's a 0.2 second builtin script delay after you call that function, according to http://lslwiki.net/lslwiki/wakka.php?wakka=llSetRot

So at very best you'd get five updates per second.  Not sure how good that would look with any degree of damping clientside.
K

On Thu, Sep 4, 2008 at 1:12 PM, G <gcanaday@...> wrote:

Ouch, that's a lot of work. It might be easier to simply use two llSetRots on a timer that's a little too short to actually complete the rotation, thus relying on the built-in smoothing for the direction change rather than having the abrupt stop when rotation completes, since it never completes... haven't tried it that way though, and there's no way to change the rotation speed since the llSetRot() calls are pretty static in how long they take to complete.

omg that was a long sentence.

G

AnnMarie@... wrote:

It is a long time since I did one and mine was a vertical motion but from memory, here is an outline on how to go about it.

The program has two segments.  The first to generate a list of numbers that runs only if you change swing parameters.
This list of numbers is used by the second program segment that moves the swing.
For the first part that generates the data list:-
You decide how many steps you want to do from peak to peak on the swing.
This can be user-setable if you want to adjust smoothness.
Divide 180 degrees by this number to get the step angle for looking up.
Start at 90 degrees and step to -90 degrees (converted to radians) and look up the llSin() of these angles and put them in a list.
This will give you a list of numbers starting at +1 and ending at -1.
You now step through this list to create a second list.
You need to scale and convert the numbers from +1 through -1 to an angle for llSetRot().
So +1 will correspond to the highest point on the swing, say 35 degrees (which can be user adjustable too).
zero will correspond to swing vertical
-1 corresponds to swing back 35 degrees, all converted to radians.

You run this segment as needed to create the working list that contains the angles that are plugged into llSetRot() only on rez, or when user wants to change one of the parameters.

To run the swing have it sit at half way through the list (vertical) if you want it to be able to stop.
When it starts, step through the list using a timer set to total swing time divided by the number of steps (can be user adjustable).
You will be stepping from mid point on the list to the bottom, then reverse and step through to the top, then reverse again.
On each step put the list angle value into llSetRot().

Although it is not physical, there is some smoothing built into llSetRot() changes, they don't move instantaneoulsy so experiment to find the minimum number of steps that looks smooth and reduces computing overhead.

If you want to get REALLY fancy, you can let the swing accelerate/decelerate on start/stop by changing the 35 degree angle in increasing/decreasing steps from/to zero, recalculating the angle list each time.

I'm sure the above could be written to calculate the angles on the fly instead of using the list look-up but I did it this way.  It is easier to understand and is probably less processing load on the sim computer.

AnnMarie Otoole.


----- Original Message ----- From: "G" <gcanaday@...>
To: <secondlifescripters@...>
Sent: Thursday, September 04, 2008 11:22 AM
Subject: Re: Repulsion between physical and other objects

Ann,

oo? How does that work? /me looks for example...

G

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

This approach DOES change the speed of llSetRot() by making smaller and
smaller rotations as the swing approaches the direction reversal point so it
is actually stationary at the peak of the swing.  It RELIES on the fact that
the llSetRot() calls are in fact static for completion time.

Logan is correct, you are limited to about 5 steps per second, I had
forgotten that.  The application I did was sinusoidal linear motion where
the 0.2 built in sleep in llSetPos() was not a problem.

AnnMarie Otoole

----- Original Message -----
From: "G" <gcanaday@...>
To: <secondlifescripters@...>
Sent: Thursday, September 04, 2008 1:12 PM
Subject: Re: Programming a natural looking swing (was Repulsion between
physical and other objects)

>
> Ouch, that's a lot of work. It might be easier to simply use two llSetRots
> on a timer that's a little too short to actually complete the rotation,
> thus relying on the built-in smoothing for the direction change rather
> than having the abrupt stop when rotation completes, since it never
> completes... haven't tried it that way though, and there's no way to
> change the rotation speed since the llSetRot() calls are pretty static in
> how long they take to complete.
>
> omg that was a long sentence.
>

-bin/mailman/listinfo/secondlifescripters

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

[Glen Canaday]

I forgot about the delay in it. I don't generally use it repeatedly. I
should have remembered that, my bad!

G

Logan Park wrote:

> I think the issue of timered setRot leads to jerkiness-- there's a 0.2
> second builtin script delay after you call that function, according to
> http://lslwiki.net/lslwiki/wakka.php?wakka=llSetRot
>
> So at very best you'd get five updates per second.  Not sure how good
> that would look with any degree of damping clientside.
> K
>
> On Thu, Sep 4, 2008 at 1:12 PM, G <gcanaday@...
> <mailto:gcanaday@...>> wrote:
>
>
>     Ouch, that's a lot of work. It might be easier to simply use two
>     llSetRots on a timer that's a little too short to actually
>     complete the rotation, thus relying on the built-in smoothing for
>     the direction change rather than having the abrupt stop when
>     rotation completes, since it never completes... haven't tried it
>     that way though, and there's no way to change the rotation speed
>     since the llSetRot() calls are pretty static in how long they take
>     to complete.
>
>     omg that was a long sentence.
>
>     G
>
>
>     AnnMarie@... wrote:
>
>         It is a long time since I did one and mine was a vertical
>         motion but from memory, here is an outline on how to go about it.
>
>         The program has two segments.  The first to generate a list of
>         numbers that runs only if you change swing parameters.
>         This list of numbers is used by the second program segment
>         that moves the swing.
>         For the first part that generates the data list:-
>         You decide how many steps you want to do from peak to peak on
>         the swing.
>         This can be user-setable if you want to adjust smoothness.
>         Divide 180 degrees by this number to get the step angle for
>         looking up.
>         Start at 90 degrees and step to -90 degrees (converted to
>         radians) and look up the llSin() of these angles and put them
>         in a list.
>         This will give you a list of numbers starting at +1 and ending
>         at -1.
>         You now step through this list to create a second list.
>         You need to scale and convert the numbers from +1 through -1
>         to an angle for llSetRot().
>         So +1 will correspond to the highest point on the swing, say
>         35 degrees (which can be user adjustable too).
>         zero will correspond to swing vertical
>         -1 corresponds to swing back 35 degrees, all converted to radians.
>
>         You run this segment as needed to create the working list that
>         contains the angles that are plugged into llSetRot() only on
>         rez, or when user wants to change one of the parameters.
>
>         To run the swing have it sit at half way through the list
>         (vertical) if you want it to be able to stop.
>         When it starts, step through the list using a timer set to
>         total swing time divided by the number of steps (can be user
>         adjustable).
>         You will be stepping from mid point on the list to the bottom,
>         then reverse and step through to the top, then reverse again.
>         On each step put the list angle value into llSetRot().
>
>         Although it is not physical, there is some smoothing built
>         into llSetRot() changes, they don't move instantaneoulsy so
>         experiment to find the minimum number of steps that looks
>         smooth and reduces computing overhead.
>
>         If you want to get REALLY fancy, you can let the swing
>         accelerate/decelerate on start/stop by changing the 35 degree
>         angle in increasing/decreasing steps from/to zero,
>         recalculating the angle list each time.
>
>         I'm sure the above could be written to calculate the angles on
>         the fly instead of using the list look-up but I did it this
>         way.  It is easier to understand and is probably less
>         processing load on the sim computer.
>
>         AnnMarie Otoole.
>
>
>         ----- Original Message ----- From: "G" <gcanaday@...
>         <mailto:gcanaday@...>>
>         To: <secondlifescripters@...
>         <mailto:secondlifescripters@...>>
>         Sent: Thursday, September 04, 2008 11:22 AM
>         Subject: Re: Repulsion between physical and other objects
>
>
>
>             Ann,
>
>             oo? How does that work? /me looks for example...
>
>             G
>
>
>
>
>     _______________________________________________
>     Click here to unsubscribe or manage your list subscription:
>     https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters
>
>
> ------------------------------------------------------------------------
>
> _______________________________________________
> Click here to unsubscribe or manage your list subscription:
> https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters
>  

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

[Tigro Spottystripes]

wow! looking values up on a list is faster and easier on the sim than
doing math?! 0.0

some other time I'm gonna try to make a non-phys swing that will take
controls to let the "rider" swing back and forth, calculating in
realtime the new speeds, and I'll probably  use that arbitrary pivot
trick with llSetPrimitiveParams instead of offseting the actual center
of rotation of the linkset just for kicks Xp

>>
>>     AnnMarie@... wrote:
>>
>>         It is a long time since I did one and mine was a vertical
>>         motion but from memory, here is an outline on how to go about
>> it.
>>
>>         The program has two segments.  The first to generate a list of
>>         numbers that runs only if you change swing parameters.
>>         This list of numbers is used by the second program segment
>>         that moves the swing.
>>         For the first part that generates the data list:-
>>         You decide how many steps you want to do from peak to peak on
>>         the swing.
>>         This can be user-setable if you want to adjust smoothness.
>>         Divide 180 degrees by this number to get the step angle for
>>         looking up.
>>         Start at 90 degrees and step to -90 degrees (converted to
>>         radians) and look up the llSin() of these angles and put them
>>         in a list.
>>         This will give you a list of numbers starting at +1 and ending
>>         at -1.
>>         You now step through this list to create a second list.
>>         You need to scale and convert the numbers from +1 through -1
>>         to an angle for llSetRot().
>>         So +1 will correspond to the highest point on the swing, say
>>         35 degrees (which can be user adjustable too).
>>         zero will correspond to swing vertical
>>         -1 corresponds to swing back 35 degrees, all converted to
>> radians.
>>
>>         You run this segment as needed to create the working list that
>>         contains the angles that are plugged into llSetRot() only on
>>         rez, or when user wants to change one of the parameters.
>>
>>         To run the swing have it sit at half way through the list
>>         (vertical) if you want it to be able to stop.
>>         When it starts, step through the list using a timer set to
>>         total swing time divided by the number of steps (can be user
>>         adjustable).
>>         You will be stepping from mid point on the list to the bottom,
>>         then reverse and step through to the top, then reverse again.
>>         On each step put the list angle value into llSetRot().
>>
>>         Although it is not physical, there is some smoothing built
>>         into llSetRot() changes, they don't move instantaneoulsy so
>>         experiment to find the minimum number of steps that looks
>>         smooth and reduces computing overhead.
>>
>>         If you want to get REALLY fancy, you can let the swing
>>         accelerate/decelerate on start/stop by changing the 35 degree
>>         angle in increasing/decreasing steps from/to zero,
>>         recalculating the angle list each time.
>>
>>         I'm sure the above could be written to calculate the angles on
>>         the fly instead of using the list look-up but I did it this
>>         way.  It is easier to understand and is probably less
>>         processing load on the sim computer.
>>
>>         AnnMarie Otoole.
>>
>>
>>         ----- Original Message ----- From: "G" <gcanaday@...
>>         <mailto:gcanaday@...>>
>>         To: <secondlifescripters@...
>>         <mailto:secondlifescripters@...>>
>>         Sent: Thursday, September 04, 2008 11:22 AM
>>         Subject: Re: Repulsion between physical and other objects
>>
>>
>>
>>             Ann,
>>
>>             oo? How does that work? /me looks for example...
>>
>>             G
>>
>>
>>
>>
>>     _______________________________________________
>>     Click here to unsubscribe or manage your list subscription:
>>    
>> https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters 
>>

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

[Hidenori GOTO]

Hi, this is a swing I built using llRotLookAt. (non-physical)

http://youtube.com/watch?v=CO2z4meDKCw

secondlife://galonge/51/44/26/



Hidenori Glushenko
http://blog.innx.co.jp/


2008/9/5 Tigro Spottystripes <tigrospottystripes@...>:

> wow! looking values up on a list is faster and easier on the sim than doing
> math?! 0.0
>
> some other time I'm gonna try to make a non-phys swing that will take
> controls to let the "rider" swing back and forth, calculating in realtime
> the new speeds, and I'll probably  use that arbitrary pivot trick with
> llSetPrimitiveParams instead of offseting the actual center of rotation of
> the linkset just for kicks Xp
>>>
>>>    AnnMarie@... wrote:
>>>
>>>        It is a long time since I did one and mine was a vertical
>>>        motion but from memory, here is an outline on how to go about it.
>>>
>>>        The program has two segments.  The first to generate a list of
>>>        numbers that runs only if you change swing parameters.
>>>        This list of numbers is used by the second program segment
>>>        that moves the swing.
>>>        For the first part that generates the data list:-
>>>        You decide how many steps you want to do from peak to peak on
>>>        the swing.
>>>        This can be user-setable if you want to adjust smoothness.
>>>        Divide 180 degrees by this number to get the step angle for
>>>        looking up.
>>>        Start at 90 degrees and step to -90 degrees (converted to
>>>        radians) and look up the llSin() of these angles and put them
>>>        in a list.
>>>        This will give you a list of numbers starting at +1 and ending
>>>        at -1.
>>>        You now step through this list to create a second list.
>>>        You need to scale and convert the numbers from +1 through -1
>>>        to an angle for llSetRot().
>>>        So +1 will correspond to the highest point on the swing, say
>>>        35 degrees (which can be user adjustable too).
>>>        zero will correspond to swing vertical
>>>        -1 corresponds to swing back 35 degrees, all converted to radians.
>>>
>>>        You run this segment as needed to create the working list that
>>>        contains the angles that are plugged into llSetRot() only on
>>>        rez, or when user wants to change one of the parameters.
>>>
>>>        To run the swing have it sit at half way through the list
>>>        (vertical) if you want it to be able to stop.
>>>        When it starts, step through the list using a timer set to
>>>        total swing time divided by the number of steps (can be user
>>>        adjustable).
>>>        You will be stepping from mid point on the list to the bottom,
>>>        then reverse and step through to the top, then reverse again.
>>>        On each step put the list angle value into llSetRot().
>>>
>>>        Although it is not physical, there is some smoothing built
>>>        into llSetRot() changes, they don't move instantaneoulsy so
>>>        experiment to find the minimum number of steps that looks
>>>        smooth and reduces computing overhead.
>>>
>>>        If you want to get REALLY fancy, you can let the swing
>>>        accelerate/decelerate on start/stop by changing the 35 degree
>>>        angle in increasing/decreasing steps from/to zero,
>>>        recalculating the angle list each time.
>>>
>>>        I'm sure the above could be written to calculate the angles on
>>>        the fly instead of using the list look-up but I did it this
>>>        way.  It is easier to understand and is probably less
>>>        processing load on the sim computer.
>>>
>>>        AnnMarie Otoole.
>>>
>>>
>>>        ----- Original Message ----- From: "G" <gcanaday@...
>>>        <mailto:gcanaday@...>>
>>>        To: <secondlifescripters@...
>>>        <mailto:secondlifescripters@...>>
>>>        Sent: Thursday, September 04, 2008 11:22 AM
>>>        Subject: Re: Repulsion between physical and other objects
>>>
>>>
>>>
>>>            Ann,
>>>
>>>            oo? How does that work? /me looks for example...
>>>
>>>            G
>>>
>>>
>>>
>>>
>>>    _______________________________________________
>>>    Click here to unsubscribe or manage your list subscription:
>>>
>>>  https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters
>
> _______________________________________________
> Click here to unsubscribe or manage your list subscription:
> https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters
>

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

[Tigro Spottystripes]

llRoLookAt? brilliant! :D

Hidenori GOTO escreveu:

Hi, this is a swing I built using llRotLookAt. (non-physical)

http://youtube.com/watch?v=CO2z4meDKCw

secondlife://galonge/51/44/26/



Hidenori Glushenko
http://blog.innx.co.jp/


2008/9/5 Tigro Spottystripes tigrospottystripes@...:
  

wow! looking values up on a list is faster and easier on the sim than doing
math?! 0.0

some other time I'm gonna try to make a non-phys swing that will take
controls to let the "rider" swing back and forth, calculating in realtime
the new speeds, and I'll probably  use that arbitrary pivot trick with
llSetPrimitiveParams instead of offseting the actual center of rotation of
the linkset just for kicks Xp
    

   AnnMarie@... wrote:

       It is a long time since I did one and mine was a vertical
       motion but from memory, here is an outline on how to go about it.

       The program has two segments.  The first to generate a list of
       numbers that runs only if you change swing parameters.
       This list of numbers is used by the second program segment
       that moves the swing.
       For the first part that generates the data list:-
       You decide how many steps you want to do from peak to peak on
       the swing.
       This can be user-setable if you want to adjust smoothness.
       Divide 180 degrees by this number to get the step angle for
       looking up.
       Start at 90 degrees and step to -90 degrees (converted to
       radians) and look up the llSin() of these angles and put them
       in a list.
       This will give you a list of numbers starting at +1 and ending
       at -1.
       You now step through this list to create a second list.
       You need to scale and convert the numbers from +1 through -1
       to an angle for llSetRot().
       So +1 will correspond to the highest point on the swing, say
       35 degrees (which can be user adjustable too).
       zero will correspond to swing vertical
       -1 corresponds to swing back 35 degrees, all converted to radians.

       You run this segment as needed to create the working list that
       contains the angles that are plugged into llSetRot() only on
       rez, or when user wants to change one of the parameters.

       To run the swing have it sit at half way through the list
       (vertical) if you want it to be able to stop.
       When it starts, step through the list using a timer set to
       total swing time divided by the number of steps (can be user
       adjustable).
       You will be stepping from mid point on the list to the bottom,
       then reverse and step through to the top, then reverse again.
       On each step put the list angle value into llSetRot().

       Although it is not physical, there is some smoothing built
       into llSetRot() changes, they don't move instantaneoulsy so
       experiment to find the minimum number of steps that looks
       smooth and reduces computing overhead.

       If you want to get REALLY fancy, you can let the swing
       accelerate/decelerate on start/stop by changing the 35 degree
       angle in increasing/decreasing steps from/to zero,
       recalculating the angle list each time.

       I'm sure the above could be written to calculate the angles on
       the fly instead of using the list look-up but I did it this
       way.  It is easier to understand and is probably less
       processing load on the sim computer.

       AnnMarie Otoole.


       ----- Original Message ----- From: "G" <gcanaday@...
       gcanaday@...>
       To: <secondlifescripters@...
       secondlifescripters@...>
       Sent: Thursday, September 04, 2008 11:22 AM
       Subject: Re: Repulsion between physical and other objects



           Ann,

           oo? How does that work? /me looks for example...

           G




   _______________________________________________
   Click here to unsubscribe or manage your list subscription:

 https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters
        

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

    

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

  

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

[Barrington John]

No, it uses llSleep() in-between each section of
the swinging motion.  If you'd like to see the
code, IM me (Barrington John) in-world; I'm
usually online during the SL day.  Same
offer applies to anyone here on any issue I
ramble about on this list.

On Thu, 04 Sep 2008 08:26:13 -0400
G <gcanaday@...> wrote:

>
> llTargetOmega for a swing? Did you use a timer
> to reverse the axes used in the rotation at the
> end of a swing?
>
> The reason I chose llSetRot for the one I made
> for my partner is because I needed it to follow
> the swing frame when I moved it, and it's far
> easier to do the math to make the swing agree
> with the frame using rotations than it is to
> determine which axis has to move how far in an
> automated rot, imo. llTargetOmega is smoother,
> yes... but I've only used it for continually
> rotating objects, myself.
>
> G
>
> Barrington John wrote:
> > Something to bear in mind here is that
> > smoothness of movement is surprisingly
> > subjective.
> >
> > Recently, I made a swing for my partner  and
> > started off using llSetRot() to make it
> > happen, but couldn't get it smooth enough for
> > my own tastes - using it was actually
> > nauseating for me.  My partner, however, was
> > perfectly happy with the movement.  I was
> > not.  Since this was a labour of love rather
> > than Lindens, I kept investigating - people I
> > spoke to who'd made swings (all using the
> > same method with varying parameters) were
> > adamant that their swings were "smooth" - I,
> > on the other hand, found every one of these
> > swings to be very unpleasant to use, rather
> > to their builders' bafflement. Impasse.
> >
> > In the end, I changed the movement in my own
> > swing to use llTargetOmega() and was
> > delighted to find it completely free from any
> > jerkiness.  My partner kind of agreed that it
> > was a better experience and we started to use
> > the swing a lot more.
> >
> > Now, whenever we come across a swing or a
> > hammock in our SL travels, it is she as much
> > as me who remarks that the swing at home is
> > far more pleasant to use.  Meanwhile, the
> > builders of llSetRot() systems continue to be
> > perfectly happy with their own creations.
> > It's incredible how subjective it is, and
> > what is fine to one person can actually be
> > genuinely unpleasant, even nauseating, to
> > another.
> >
> > I'd be very interested to visit your
> > llSetRot() Ferris wheel in-world, to see if I
> > could ride it without feeling ill, and to
> > compare notes with someone who found the
> > movement fine to use; I find it hard to
> > believe that the difference is purely
> > psychological, and wonder if it's to do with
> > different hardware.
> >
> > On Wed, 3 Sep 2008 07:09:38 -0700
> > Jippen <cheetahmorph@...> wrote:
> >
> >  
> >> I've had to deal with making a ferris wheel
> >> in SL. Since they move quite slowly, I just
> >> use llSetRot and llSetPos to make it rotate
> >> one degree a second. Swiped most of the code
> >> for it from a circle building tool. You can
> >> prolly find it at Yadni's. Gave me a 6 minute
> >> revolution time, which is pretty nice for a
> >> ferris wheel, and was smooth enough. Making
> >> the carriages swing would add some
> >> additional math to it, but shouldn't be too
> >> complicated.
> > _______________________________________________
> > Click here to unsubscribe or manage your list
> > subscription:
> > https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters
> >
> >  
>
> _______________________________________________
> Click here to unsubscribe or manage your list
> subscription:
> https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters

_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/secondlifescripters