Need algorithm to make prim point x axis at velocity.

Anyone know the math to do this? I'd greatly appreciate it and i cant seem to find anyone that know.

probably because they can't make sense of the question?

velocity is a measure of RATE of movement, whereas X axis pointing would be rotation around a point.

llLookAt will point your prim towards a point regardless of position
llRotLookAt will point you prim in a direction regardless of position

I think velocity is a vector that includes both the rate of motion - which is speed - and the direction of the motion.

I read the question as meaning how to make the object's X axis point in the direction of motion.

Right. So something to the effect of:

rotation rot = llGetRot();
vector fwd = llRot2Fwd(rot);
vector vel = llGetVel();
rotation newRot = rot*llRotBetween(fwd, llVecNorm(vel));
llRotLookAt(newRot, STRENTH, DAMPING);

Right, or something like:

llSetRot( llRotBetween( < 1.0, 0.0, 0.0 >, llVecNorm(llGetVel())));

this worked pretty well for me..

    timer()
    {
        llLookAt(llGetPos() + llGetVel(), 1, 0.25);
    }

It does wobble a bit, and you have to do a little magic at rez time to get said object pointing in the right direction from the word go.. but it does seem to work.

OP asks for the X-axis to point ahead.
Seems to me llLookAt will point the Z-axis

Hewee's will be the most stable, especially across sim bounds, although it doesn't need the current rotation of the object since velocity is in global frame of reference, not local... so this should work fine...

Hewee's rotation variation (tweaked)
rotation Velocity2Rotation = llRotBetween( <1.0, 0.0, 0.0>, llGetVel() );

Winter's position variation
vector Velocity2Target = llGetPos() + llGetVel();

the second will misbehave when it passes it's mark or if changing sims at anything other than parallel to region axis'. multiplying it by 256 will remove most misbehavior within the same sim.

(yes I was having a brain fart earlier... velocity is a measure of rate of movement in a direction, speed is an undirected measure of rate of movement, I'm so used to people saying one to mean the other that I automatically translated it... mistake)

are you thinking of particles? look at assume the forward axis to be +x

Please take a close look at: http://wiki.secondlife.com/wiki/LlLookAt

Yeah. The reason I included the current rotation was to keep whatever part of the current rotation didn't depend on the direction of velocity. Basically constraining one component of the rotation instead of both (as much as possible).

O.o

damn, I was on the page for llRotLookAt when I was working, and assumed they both worked the same... guess not... I don't know the axis swapping formula offhand.

change the orientation of the base prim so that Z is pointing in the right direction?

Add another prim, or select one that faces correctly. That's what I'd do. Life's too short for complicated geometry.

there some odd axis flips in there, that may affect certain builds, but for the most part it treats -x as +z...

but getting a rotation that works for it is... mind numbing.

just use RotLookAt

Thanks everyone i figured it out thanks to your help. I will post the solution as soon as sl stops having login issues AGAIN.

rotation VectorToRotation ( vector V )
{
V = llVecNorm( V );
vector UP = < 0.0, 0.0, 1.0 >;
return llAxes2Rot(V, UP % V, UP);
}

Iz v.nize! you should add that to the portal (or I can)....

but why a function to flatten rotation to the z plane? (although I'm definitely pimping this next time someone asks about keeping their vehicle right side up just feed it <1,0,0>*llGetRot() and toss the normalization line) (rotation flattens inversely to UP's magnitude)

PS I knew there was a function I wasn't finding... I need to crosslink Axes2Rot to the others in the Portal

EDIT:
works for UP = ZERO_VECTOR, but rot between should be more effective (less instructions)

Ah, yes. I often use logic that looks quite similar:

vector fwd = ...;
vector left = llVecNorm(<-fwd.y, fwd.x, 0.0>); // Same as llVecNorm(<0,0,1>%fwd)
vector up = fwd%left;
rotation rot = llAxes2Rot(fwd, left, up);

(You may also want to check for the corner case where 'fwd' points straight up or down.)

The funny thing is, often people on these boards don't like to think in terms of coordinate basis vectors, so I tend to shy away from that kind of thing when answering questions now. It's thus very surprising to see that this is the solution you came too. Awesome job!

Let me also congratulate Moira with the simple solution she found
I have one complaint though: The 3 vectors in llAxis2Rot are not mutually orthogonal except in the special case where V is horizontal.
(V and UP are not orthogonal if V is pointing up or down)
In this case all three vectors are not unit vectors unless fwd is.
I don't know how much this means in your special case but I have experienced cases where it was crucial!
"All three vectors must be mutually orthogonal unit vectors"
Reference: http://wiki.secondlife.com/wiki/LlAxes2Rot

Edit: attempted solution to Moira's script:

rotation VectorToRotation ( 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
    // UP = llVecNorm(V%LEFT); // you want to keep the direction of V
    return llAxes2Rot(V, LEFT, UP);
}

There are two solutions, uncomment the one wanted
Happy scripting