public AnimationClip assignCurvesToClip()
{
HoudiniCurvesCollection curves = this;
AnimationClip clip = new AnimationClip();
clip.legacy = true;
bool found_nonconst_curve = false;
if (!curves.isConstantAnimCurve(curves.tx))
{
clip.SetCurve("", typeof(Transform), "localPosition.x", curves.tx);
found_nonconst_curve = true;
}
if (!curves.isConstantAnimCurve(curves.ty))
{
clip.SetCurve("", typeof(Transform), "localPosition.y", curves.ty);
found_nonconst_curve = true;
}
if (!curves.isConstantAnimCurve(curves.tz))
{
clip.SetCurve("", typeof(Transform), "localPosition.z", curves.tz);
found_nonconst_curve = true;
}
if (!curves.isConstantAnimCurve(curves.qx) ||
!curves.isConstantAnimCurve(curves.qy) ||
!curves.isConstantAnimCurve(curves.qz) ||
!curves.isConstantAnimCurve(curves.qw))
{
clip.SetCurve("", typeof(Transform), "localRotation.x", curves.qx);
clip.SetCurve("", typeof(Transform), "localRotation.y", curves.qy);
clip.SetCurve("", typeof(Transform), "localRotation.z", curves.qz);
clip.SetCurve("", typeof(Transform), "localRotation.w", curves.qw);
found_nonconst_curve = true;
}
if (!curves.isConstantAnimCurve(curves.sx))
{
clip.SetCurve("", typeof(Transform), "localScale.x", curves.sx);
found_nonconst_curve = true;
}
if (!curves.isConstantAnimCurve(curves.sy))
{
clip.SetCurve("", typeof(Transform), "localScale.y", curves.sy);
found_nonconst_curve = true;
}
if (!curves.isConstantAnimCurve(curves.sz))
{
clip.SetCurve("", typeof(Transform), "localScale.z", curves.sz);
found_nonconst_curve = true;
}
if (found_nonconst_curve)
{
clip.EnsureQuaternionContinuity();
return(clip);
}
return(null);
}
public void bakeAnimation(float curr_time, GameObject parent_object, HAPI_Transform hapi_transform)
{
try
{
Matrix4x4 parent_xform_inverse = Matrix4x4.identity;
if (parent_object != null)
{
parent_xform_inverse = parent_object.transform.localToWorldMatrix.inverse;
}
Vector3 pos = new Vector3();
// Apply object transforms.
//
// Axis and Rotation conversions:
// Note that Houdini's X axis points in the opposite direction that Unity's does. Also, Houdini's
// rotation is right handed, whereas Unity is left handed. To account for this, we need to invert
// the x coordinate of the translation, and do the same for the rotations (except for the x rotation,
// which doesn't need to be flipped because the change in handedness AND direction of the left x axis
// causes a double negative - yeah, I know).
pos[0] = -hapi_transform.position[0];
pos[1] = hapi_transform.position[1];
pos[2] = hapi_transform.position[2];
Quaternion quat = new Quaternion(hapi_transform.rotationQuaternion[0],
hapi_transform.rotationQuaternion[1],
hapi_transform.rotationQuaternion[2],
hapi_transform.rotationQuaternion[3]);
Vector3 euler = quat.eulerAngles;
euler.y = -euler.y;
euler.z = -euler.z;
quat = Quaternion.Euler(euler);
Vector3 scale = new Vector3(hapi_transform.scale[0],
hapi_transform.scale[1],
hapi_transform.scale[2]);
if (parent_object != null)
{
Matrix4x4 world_mat = Matrix4x4.identity;
world_mat.SetTRS(pos, quat, scale);
Matrix4x4 local_mat = parent_xform_inverse * world_mat;
quat = HoudiniAssetUtility.getQuaternion(local_mat);
scale = HoudiniAssetUtility.getScale(local_mat);
pos = HoudiniAssetUtility.getPosition(local_mat);
}
HoudiniCurvesCollection curves = myCurveCollection;
addKeyToCurve(curr_time, pos[0], curves.tx);
addKeyToCurve(curr_time, pos[1], curves.ty);
addKeyToCurve(curr_time, pos[2], curves.tz);
addKeyToCurve(curr_time, quat.x, curves.qx);
addKeyToCurve(curr_time, quat.y, curves.qy);
addKeyToCurve(curr_time, quat.z, curves.qz);
addKeyToCurve(curr_time, quat.w, curves.qw);
addKeyToCurve(curr_time, scale.x, curves.sx);
addKeyToCurve(curr_time, scale.y, curves.sy);
addKeyToCurve(curr_time, scale.z, curves.sz);
}
catch (HoudiniError error)
{
Debug.LogWarning(error.ToString());
return;
}
}
public void beginBakeAnimation()
{
myCurveCollection = new HoudiniCurvesCollection();
}
public void beginBakeAnimation()
{
try
{
cacheNumInstances();
myCurvesCollection = new HoudiniCurvesCollection[ myNumInstances ];
for ( int ii = 0; ii < myNumInstances; ++ii )
{
myCurvesCollection[ ii ] = new HoudiniCurvesCollection();
}
}
catch ( HoudiniError error )
{
Debug.LogWarning( error.ToString() );
return;
}
}
public void beginBakeAnimation()
{
myCurveCollection = new HoudiniCurvesCollection();
}
public void bakeAnimation(float curr_time, GameObject parent_object)
{
try
{
HAPI_GeoInfo geo_info = HoudiniHost.getDisplayGeoInfo(prObjectId);
HAPI_Transform[] instance_transforms = new HAPI_Transform[myNumInstances];
Utility.getArray2Id(
geo_info.nodeId, HAPI_RSTOrder.HAPI_SRT,
HoudiniHost.getInstanceTransforms, instance_transforms, myNumInstances);
Matrix4x4 parent_xform_inverse = Matrix4x4.identity;
if (parent_object != null)
{
parent_xform_inverse = parent_object.transform.localToWorldMatrix.inverse;
}
for (int ii = 0; ii < myNumInstances; ++ii)
{
Vector3 pos = new Vector3();
// Apply object transforms.
//
// Axis and Rotation conversions:
// Note that Houdini's X axis points in the opposite direction that Unity's does. Also, Houdini's
// rotation is right handed, whereas Unity is left handed. To account for this, we need to invert
// the x coordinate of the translation, and do the same for the rotations (except for the x rotation,
// which doesn't need to be flipped because the change in handedness AND direction of the left x axis
// causes a double negative - yeah, I know).
pos[0] = -instance_transforms[ii].position[0];
pos[1] = instance_transforms[ii].position[1];
pos[2] = instance_transforms[ii].position[2];
Quaternion quat = new Quaternion(instance_transforms[ii].rotationQuaternion[0],
instance_transforms[ii].rotationQuaternion[1],
instance_transforms[ii].rotationQuaternion[2],
instance_transforms[ii].rotationQuaternion[3]);
Vector3 euler = quat.eulerAngles;
euler.y = -euler.y;
euler.z = -euler.z;
quat = Quaternion.Euler(euler);
Vector3 scale = new Vector3(instance_transforms[ii].scale[0],
instance_transforms[ii].scale[1],
instance_transforms[ii].scale[2]);
if (parent_object != null)
{
Matrix4x4 world_mat = Matrix4x4.identity;
world_mat.SetTRS(pos, quat, scale);
Matrix4x4 local_mat = parent_xform_inverse * world_mat;
quat = HoudiniAssetUtility.getQuaternion(local_mat);
scale = HoudiniAssetUtility.getScale(local_mat);
pos = HoudiniAssetUtility.getPosition(local_mat);
}
HoudiniCurvesCollection curves = myCurvesCollection[ii];
HoudiniAssetUtility.addKeyToCurve(curr_time, pos[0], curves.tx);
HoudiniAssetUtility.addKeyToCurve(curr_time, pos[1], curves.ty);
HoudiniAssetUtility.addKeyToCurve(curr_time, pos[2], curves.tz);
HoudiniAssetUtility.addKeyToCurve(curr_time, quat.x, curves.qx);
HoudiniAssetUtility.addKeyToCurve(curr_time, quat.y, curves.qy);
HoudiniAssetUtility.addKeyToCurve(curr_time, quat.z, curves.qz);
HoudiniAssetUtility.addKeyToCurve(curr_time, quat.w, curves.qw);
HoudiniAssetUtility.addKeyToCurve(curr_time, scale.x, curves.sx);
HoudiniAssetUtility.addKeyToCurve(curr_time, scale.y, curves.sy);
HoudiniAssetUtility.addKeyToCurve(curr_time, scale.z, curves.sz);
}
}
catch (HoudiniError error)
{
Debug.LogWarning(error.ToString());
return;
}
}
