Converting Aimdirection To Rotation

[ljilekor]

Hello

I'm looking for a way to convert the AimDirection to Rotation.
I have a particle system set up and it works fine. The rotations of the instanced geometry are set by the AimDirection.

The thing is that I have to export each instance (per particle) to fbx.
Therefore I have to deinstance my particle system. No problem on this side.
(another application would be that you need to control rotation after the aiming)
I duplicate my base object (used in the instancer) and fill in the transformation attributes per frame.

No problem for the position. I just use the worldPosition in my deinstance routine.
float $posPP[] = getParticleAttr -at worldPosition $myParticleShape;

My particles rotation is set with the AimDirection. By default, there is no rotationPP nor worldRotationPP from which i could get the actual rotations of the instance. I need to create a custom vector per particle (let's say worldRotationPP)

How can I convert the AimDirection vector to my worldRotationPP vector that I can use in my deinstance routine to set actual rotations?
I guess some vector math may be involved or is there a simpler way to do this?

Thanks in advance.

[ljilekor]

Well, I found a sollution though I do not really like it.

You can apply this solution for deinstancing but not if you wish to continue to control the rotation after aiming...

So, to deinstance an instancer that uses the AimDirection to control rotations,
write a script that:
- duplicates the base object (the one instanced) for each particle.

• get / set the worldposition
  float $worldPosPP[] = getParticleAttr -at worldPosition $myParticleShape;

• The aimDirection vector inside the instancer is in fact an offset (vector) to which the instance should aim.
  So get the AimDirection (Anything connected to the instancers AimDirection. Here I called it aimDirectionPP)
  float $aimOffsetPosPP[] = getParticleAttr -at aimDirectionPP $myParticleShape;
  And add this to the worldposition you queried earlier $worldPosPP.
  float $aimWorldPosPP[];
  $aimWorldPosPP[0]=$worldPosPP[0] + $aimOffsetPosPP[0] ;
  $aimWorldPosPP[1]=$worldPosPP[1] + $aimOffsetPosPP[1] ;
  $aimWorldPosPP[2]=$worldPosPP[2] + $aimOffsetPosPP[2] ;

• create an AimPosition object (locator or empty group) for each particle and set it's position to $aimWorldPosPP.

• Aimconstraint the duplicated baseobject to its corresponding AimPosition object.

You successfully deinstanced the particles instance.
Yeu can now read the world euler rotations rx,ry,rz in the channelbox of the duplicated object (in blue because of the aimconstraint)

Anyway, it works but it sucks.
It would be nice if maya would return something like rotationPP and/or worldRotationPP just like it does for positions.
We wouldn't need explanations that noone understands.

You could also get there by using vector maths. But in my specific case I lacked info (like an instances upvector) to calculate the rotationPP.

With Thinking Particles and ICE in mind, its really time that Autodesk reviews maya's powerfull but oldschool particle system / instancer in order to stay competitive.

[ljilekor]

I still think that this thread is worth looking at.

Not being able to switch (calculate/convert) between aimdirection and actual rotationXYZ (eg rotPP) soon becomes a real pain when you are doing a little more than simple behaviours with particles and where rotation plays an important role (instancing).

Let's say we have to make butterflies fly around (to make it simple with aimdirection=velocity) and on a given moment, they have to land with a given rotationXYZ on flower petals.

So the most versatile way would be use the actual rotation to control the instances real rotations (eg. set Rotation to rotPP).
During the flight, the aimdirection needs to be converted in rotationXYZ. (rotPP ?=? converted velocity)
On a given distance, the rotationsXYZ (converted from aimdirection(velocity)) interpolate towards a given rotationXYZ.

As a result we have the butterflies flying around folowing aiming towards their velocity. When triggered (time / distance) they would nicely interpole and land with the right orientation. Excellent!

Theoreticaly, you could do the same by interpolating aimDirections. But when working with aimdirections, the interpolation s#*K% and posing the landed butterflies is a pain... So this is why I prefer to control rotations directly wit rotationXYZ.

Does anybody knows how to do the vector math to convert aimdirection in real rotationsXYZ?

Thx again