Stored rotation that adjusts to a new rotation accordingly.

Ugh, I hate rotation calculations. I need a quick snippet of code that adjusts my stored rotation with the current rotation, so that no matter what the new rotation is it still performs the rotation I have stored, but accordingly with the new rotation. I just need the line that calculates the rotation. Thanks.

I've tried multiplying but it just rotates it by one quarter turn one direction and another. Weird. I've tried all kinds of stuff and I've been referencing both wikis. You would think someone would've posted something like this on the wiki a long time ago. *sigh* I'll keep trying.

integer toggle; // toggles between open and close
integer touches; // counter for open/close storage

rotation closed_rot;
rotation open_rot;

default
{
state_entry()
{
toggle = FALSE;
touches = 0;
}

touch_start(integer total_number)
{
//Store closed position
if (touches == 0) // store closed position
{
closed_rot = llGetRot();

llOwnerSay("Closed set.";
touches = 1;
return;

} else if (touches == 1) // store open position
{
open_rot = llGetRot();

llOwnerSay("Open set.";
touches = 2; // disable storage

//Set closed postion
llSetRot(closed_rot);
return;
}

// Toggle back and forth between open and closed positions
if (toggle == FALSE)
{
// Here's where the script fails to rotate correctly
llSetRot(llGetRot()*open_rot);
toggle = TRUE;

} else
{
// Here's where the script fails to rotate correctly
llSetRot(llGetRot()*closed_rot);
toggle = FALSE;
}
}
}

Yes. I am using a single prim. I'm assuming with a single non-linked prim I use global rotation (i.e. not local), correct? Here's what I'm doing...

On start the script waits for you to position your prim in the closed position/rotation. You then touch the prim to set it. Next, move the prim to a new position/rotation and touch the prim to set the open position/rotation. The script then toggles between open/close positions and works fine if you use llSetRot(open_rot) and llSetRot(closed_rot) as long a you don't move your prim, but if you move the prim by rotating it elsewhere it doesn't adjust correctly to the new rotation using llGetRot() * open_rot (or closed_rot). What this does is seem to rotate the prim 1/4 turn in two directions.

I want to be able to move my prim any rotation and position and have it rotate as intended based on the new rotation and position.

*hands Hewee a beer* Thanks so much. Do I have your permission to add this one to the library?

integer toggle = FALSE;
integer touches = 0;

rotation closed_rot;
rotation open_rot;
vector open_pos;
vector closed_pos;
vector offset;

open()
{
llSetPos(llGetPos()+offset*llGetRot());
llSetRot(open_rot*llGetRot());
toggle = TRUE;
}

close()
{
llSetPos(llGetPos()-offset*llGetRot());
llSetRot((ZERO_ROTATION/open_rot)*llGetRot());
toggle = FALSE;
}

default
{
touch_start(integer nDetected)
{
if (touches == 0)
{
closed_pos = llGetPos();
closed_rot = llGetRot();
++touches;

llOwnerSay("Closed set.";
} else if (touches == 1)
{
open_pos = llGetPos();
offset = open_pos - closed_pos;
open_rot = llGetRot()/closed_rot;
llOwnerSay("c:"+(string)closed_pos+"o:"+(string)open_pos+"-/+"+(string)offset);
++touches;

llOwnerSay("Open set.";

close();
} else if (!toggle)
{
open();
} else
{
close();
}
}
}

integer toggle;
integer acquire=1;
rotation initial_rot;
vector initial_pos;
integer move_count=0;

vector pos1;
vector pos2;
vector pos3;
rotation rot1;
rotation rot2;
rotation rot3;
rotation rel1;
rotation rel2;
rotation rel3;
vector off1;
vector off2;
vector off3;


store()
{
move_count = move_count + 1;
if (move_count == 1)
{
pos1 = llGetPos();
rot1 = llGetRot();
rel1 = llGetRot()/initial_rot;
off1 = (llGetPos()-initial_pos)/initial_rot;

} else if (move_count == 2)
{
pos2 = llGetPos();
rot2 = llGetRot();
rel2 = llGetRot()/rot1;
off2 = (llGetPos()-pos1)/rot1;

} else if (move_count == 3)
{
pos3 = llGetPos();
rot3 = llGetRot();
rel3 = llGetRot()/rot2;
off3 = (llGetPos()-pos2)/rot2;

}

llOwnerSay("Stored "+(string)move_count+" of 3";
acquire++;
}

default
{
state_entry()
{
initial_rot = llGetRot();
initial_pos = llGetPos();
toggle = FALSE;
llOwnerSay("Initial position/rotation stored. Please move your object and touch to store each position/rotation. Three will be stored, then when touched the animation will move forward. When touched again it will move backward.";
}

touch_start(integer touches)
{
if (acquire == 1)
{
store();
return;
} else if (acquire == 2)
{
store();
return;
} else if (acquire == 3)
{
store();
acquire++;
}

if (acquire == 4)
{
llOwnerSay("Storage complete. Moved to original position. Touch prim to animate forward. Touch again to animate backward.";
llSetPos(initial_pos);
llSetRot(initial_rot);
acquire++;
return;

} else if (acquire == 5)
{
if (toggle == FALSE)
{
//Animate forward
rotation temp_rot = llGetRot();
llSetPrimitiveParams([ PRIM_POSITION, llGetPos()+off1*temp_rot,PRIM_ROTATION,rel1*temp_rot]);
llSleep(.2);

temp_rot = llGetRot();
llSetPrimitiveParams([ PRIM_POSITION, llGetPos()+off2*temp_rot ,PRIM_ROTATION,rel2*temp_rot]);
llSleep(.2);

temp_rot = llGetRot();
llSetPrimitiveParams([ PRIM_POSITION, llGetPos()+off3*temp_rot ,PRIM_ROTATION,rel3*temp_rot]);

toggle = TRUE;
return;
}
else if (toggle == TRUE)
{
// Reverse the animation
rotation temp_rot = (ZERO_ROTATION/rel3)*llGetRot();
llSetPrimitiveParams([ PRIM_POSITION, llGetPos()-off3*temp_rot,PRIM_ROTATION, temp_rot]);
llSleep(.2);

temp_rot = (ZERO_ROTATION/rel2)*llGetRot();
llSetPrimitiveParams([ PRIM_POSITION, llGetPos()-off2*temp_rot,PRIM_ROTATION, temp_rot]);
llSleep(.2);

temp_rot = (ZERO_ROTATION/rel1)*llGetRot();
llSetPrimitiveParams([ PRIM_POSITION, llGetPos()-off1*temp_rot ,PRIM_ROTATION,temp_rot]);

toggle = FALSE;
}
}
}
}