protected override bool buildCreateObjects(bool reload_asset, ref HoudiniProgressBar progress_bar)
{
try
{
const int object_id = 0;
const int geo_id = 0;
// Write marshalled geo to Input Asset.
HoudiniAssetUtility.setMesh(
prAssetId, object_id, geo_id, ref myEditableMesh, null, myGeoAttributeManager);
// Apply the input asset transform to the marshaled object in the Houdini scene.
HAPI_TransformEuler trans = HoudiniAssetUtility.getHapiTransform(transform.localToWorldMatrix);
HoudiniHost.setObjectTransform(prAssetId, object_id, ref trans);
// Marshall in the animation.
Animation anim_component = GetComponent <Animation>();
if (anim_component)
{
if (anim_component.clip != null)
{
marshalCurvesFromClip(prObjectNodeId, anim_component.clip);
}
else
{
foreach (AnimationState anim_state in anim_component)
{
AnimationClip clip = anim_component.GetClip(anim_state.name);
if (clip != null)
{
marshalCurvesFromClip(prObjectNodeId, clip);
break;
}
}
}
}
HoudiniHost.repaint();
}
catch (HoudiniError)
{
// Per-object errors are not re-thrown so that the rest of the asset has a chance to load.
//Debug.LogWarning( error.ToString() );
}
return(false);
}
private static extern HAPI_Result HAPI_ConvertTransform( ref HAPI_Session session, ref HAPI_TransformEuler transform_in, HAPI_RSTOrder rst_order, HAPI_XYZOrder rot_order, out HAPI_TransformEuler transform_out );
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Public
public void handlesOnSceneGUI()
{
if ( myAssetOTL.prShowPinnedInstances )
drawPinnedInstances();
// On mouse up the drag operation is completed.
if ( Event.current.type == EventType.MouseUp )
myOpInProgress = false;
string currentGlobalManipTool = Tools.current.ToString();
if ( currentGlobalManipTool == "Rotate" )
myManipMode = XformManipMode.Rotate;
else if ( currentGlobalManipTool == "Move" )
myManipMode = XformManipMode.Translate;
else if ( currentGlobalManipTool == "Scale" )
myManipMode = XformManipMode.Scale;
if ( myAssetOTL == null )
return;
int node_id = myAssetOTL.prNodeId;
HAPI_HandleInfo[] handleInfos = myAssetOTL.prHandleInfos;
if ( handleInfos == null )
return;
// Detect changes and build asset only when changed.
bool changed = false;
for ( int ii = 0; ii < handleInfos.Length; ++ii )
{
HAPI_HandleInfo handleInfo = handleInfos[ ii ];
if ( handleInfo.typeName == "xform" )
{
float tx = 0, ty = 0, tz = 0;
float rx = 0, ry = 0, rz = 0;
float sx = 1, sy = 1, sz = 1;
HAPI_RSTOrder rstOrder = HAPI_RSTOrder.HAPI_SRT;
HAPI_XYZOrder xyzOrder = HAPI_XYZOrder.HAPI_XYZ;
HAPI_HandleBindingInfo[] bindingInfos = myAssetOTL.prHandleBindingInfos[ ii ];
int[] parm_int_values = myAssetOTL.prParms.prParmIntValues;
float[] parm_float_values = myAssetOTL.prParms.prParmFloatValues;
if ( parm_int_values == null || parm_float_values == null )
{
Debug.LogError( "No parm int/float values yet handles exist?" );
continue;
}
int translate_parm_id = -1;
int rotate_parm_id = -1;
int scale_parm_id = -1;
int rst_order_parm_id = -1;
int xyz_order_parm_id = -1;
foreach ( HAPI_HandleBindingInfo bindingInfo in bindingInfos )
{
string parm_name = bindingInfo.handleParmName;
if ( parm_name == "tx" )
translate_parm_id = bindingInfo.assetParmId;
else if ( parm_name == "rx" )
rotate_parm_id = bindingInfo.assetParmId;
else if ( parm_name == "sx" )
scale_parm_id = bindingInfo.assetParmId;
else if ( parm_name == "trs_order" )
rst_order_parm_id = bindingInfo.assetParmId;
else if ( parm_name == "xyz_order" )
xyz_order_parm_id = bindingInfo.assetParmId;
}
if ( translate_parm_id >= 0 )
{
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm( translate_parm_id );
tx = parm_float_values[ parm_info.floatValuesIndex + 0 ];
ty = parm_float_values[ parm_info.floatValuesIndex + 1 ];
tz = parm_float_values[ parm_info.floatValuesIndex + 2 ];
}
if ( rotate_parm_id >= 0 )
{
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm( rotate_parm_id );
rx = parm_float_values[ parm_info.floatValuesIndex + 0 ];
ry = parm_float_values[ parm_info.floatValuesIndex + 1 ];
rz = parm_float_values[ parm_info.floatValuesIndex + 2 ];
}
if ( scale_parm_id >= 0 )
{
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm( scale_parm_id );
sx = parm_float_values[ parm_info.floatValuesIndex + 0 ];
sy = parm_float_values[ parm_info.floatValuesIndex + 1 ];
sz = parm_float_values[ parm_info.floatValuesIndex + 2 ];
}
if ( rst_order_parm_id >= 0 )
{
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm( rst_order_parm_id );
rstOrder = (HAPI_RSTOrder) parm_int_values[ parm_info.intValuesIndex ];
}
if ( xyz_order_parm_id >= 0 )
{
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm( xyz_order_parm_id );
xyzOrder = (HAPI_XYZOrder) parm_int_values[ parm_info.intValuesIndex ];
}
HAPI_TransformEuler xform = new HAPI_TransformEuler( true );
// This bit is a little tricky. We will eventually call Handle.PositionHandle
// or Handle.RotationHandle to display the translation and rotation handles.
// These function take a translation parameter and a rotation parameter in
// order to display the handle in its proper location and orientation.
// These functions have an assumed order that it will put the rotation
// and translation back together. Depending whether the order of translation
// and roation matches that of the rstOrder setting, we may, or may not
// need to convert the translation parameter for use with the handle.
if ( rstOrder == HAPI_RSTOrder.HAPI_TSR || rstOrder == HAPI_RSTOrder.HAPI_STR || rstOrder == HAPI_RSTOrder.HAPI_SRT )
{
xform.position[0] = tx;
xform.position[1] = ty;
xform.position[2] = tz;
xform.rotationEuler[0] = rx;
xform.rotationEuler[1] = ry;
xform.rotationEuler[2] = rz;
xform.scale[0] = 1;
xform.scale[1] = 1;
xform.scale[2] = 1;
xform.rotationOrder = xyzOrder;
xform.rstOrder = rstOrder;
}
else
{
xform.position[0] = 0;
xform.position[1] = 0;
xform.position[2] = 0;
xform.rotationEuler[0] = rx;
xform.rotationEuler[1] = ry;
xform.rotationEuler[2] = rz;
xform.scale[0] = 1;
xform.scale[1] = 1;
xform.scale[2] = 1;
xform.rotationOrder = xyzOrder;
xform.rstOrder = rstOrder;
}
xform = HoudiniHost.convertTransform( xform, HAPI_RSTOrder.HAPI_SRT, HAPI_XYZOrder.HAPI_ZXY );
// 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).
xform.position[ 0 ] = -xform.position[ 0 ];
xform.rotationEuler[ 1 ] = -xform.rotationEuler[ 1 ];
xform.rotationEuler[ 2 ] = -xform.rotationEuler[ 2 ];
tx = -tx;
Handles.matrix = myAssetOTL.transform.localToWorldMatrix;
Vector3 position;
if( rstOrder == HAPI_RSTOrder.HAPI_TSR || rstOrder == HAPI_RSTOrder.HAPI_STR || rstOrder == HAPI_RSTOrder.HAPI_SRT )
position = new Vector3( xform.position[ 0 ], xform.position[ 1 ], xform.position[ 2 ] );
else
position = new Vector3( tx, ty, tz );
Quaternion rotation = Quaternion.Euler(
xform.rotationEuler[ 0 ], xform.rotationEuler[ 1 ], xform.rotationEuler[ 2 ] );
Vector3 scale = new Vector3( sx, sy, sz );
if ( myManipMode == XformManipMode.Translate )
{
if ( translate_parm_id < 0 )
continue;
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm( translate_parm_id );
if ( parm_info.invisible )
continue;
GUIStyle style = new GUIStyle( EditorStyles.textField );
style.contentOffset = new Vector2( 1.4f, 1.4f );
string handle_name = handleInfo.name;
if ( parm_info.disabled )
handle_name = handle_name + " (disabled)";
GUIContent content = new GUIContent( handle_name );
content.tooltip = handle_name;
Handles.Label( position, content, style );
if ( parm_info.disabled )
{
Handles.lighting = false;
Handles.PositionHandle( position, rotation );
Handles.lighting = true;
continue;
}
Vector3 new_position = Handles.PositionHandle( position, rotation );
if ( new_position != position )
{
changed = true;
if ( !myOpInProgress )
{
Undo.RecordObject( myAssetOTL.prParms.prParmsUndoInfo, handleInfo.name );
myOpInProgress = true;
}
if ( rstOrder == HAPI_RSTOrder.HAPI_TSR
|| rstOrder == HAPI_RSTOrder.HAPI_STR
|| rstOrder == HAPI_RSTOrder.HAPI_SRT )
{
xform.position[ 0 ] = new_position[ 0 ];
xform.position[ 1 ] = new_position[ 1 ];
xform.position[ 2 ] = new_position[ 2 ];
xform = HoudiniHost.convertTransform( xform, rstOrder, xyzOrder );
new_position.x = xform.position[ 0 ];
new_position.y = xform.position[ 1 ];
new_position.z = xform.position[ 2 ];
}
// the - in the x coordinate is to convert back to "Houdini" coordinates
parm_float_values[ parm_info.floatValuesIndex + 0 ] = -new_position.x;
parm_float_values[ parm_info.floatValuesIndex + 1 ] = new_position.y;
parm_float_values[ parm_info.floatValuesIndex + 2 ] = new_position.z;
float[] temp_float_values = new float[ HoudiniConstants.HAPI_POSITION_VECTOR_SIZE ];
for ( int pp = 0; pp < HoudiniConstants.HAPI_POSITION_VECTOR_SIZE; ++pp )
temp_float_values[ pp ] = parm_float_values[ parm_info.floatValuesIndex + pp ];
HoudiniHost.setParmFloatValues( node_id, temp_float_values, parm_info.floatValuesIndex,
parm_info.size );
myAsset.savePreset();
} // if changed
}
else if ( myManipMode == XformManipMode.Rotate )
{
if ( rotate_parm_id < 0 )
continue;
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm( rotate_parm_id );
if ( parm_info.invisible )
continue;
GUIStyle style = new GUIStyle( EditorStyles.textField );
style.contentOffset = new Vector2( 1.4f, 1.4f );
string handle_name = handleInfo.name;
if ( parm_info.disabled )
handle_name = handle_name + " (disabled)";
GUIContent content = new GUIContent( handle_name );
content.tooltip = handle_name;
Handles.Label( position, content, style );
if ( parm_info.disabled )
{
Handles.lighting = false;
Handles.RotationHandle( rotation, position );
Handles.lighting = true;
continue;
}
Quaternion new_rotation = Handles.RotationHandle( rotation, position );
if ( new_rotation != rotation )
{
changed = true;
if ( !myOpInProgress )
{
Undo.RecordObject( myAssetOTL.prParms.prParmsUndoInfo, handleInfo.name );
myOpInProgress = true;
}
Vector3 newRot = new_rotation.eulerAngles;
xform.position[0] = 0;
xform.position[1] = 0;
xform.position[2] = 0;
xform.rotationEuler[0] = newRot.x;
xform.rotationEuler[1] = newRot.y;
xform.rotationEuler[2] = newRot.z;
xform.scale[0] = 1;
xform.scale[1] = 1;
xform.scale[2] = 1;
xform.rotationOrder = HAPI_XYZOrder.HAPI_ZXY;
xform.rstOrder = HAPI_RSTOrder.HAPI_SRT;
xform = HoudiniHost.convertTransform( xform, rstOrder, xyzOrder );
parm_float_values[ parm_info.floatValuesIndex + 0 ] = xform.rotationEuler[ 0 ];
// the - in the y & z coordinate is to convert back to "Houdini" coordinates
parm_float_values[ parm_info.floatValuesIndex + 1 ] = -xform.rotationEuler[ 1 ];
parm_float_values[ parm_info.floatValuesIndex + 2 ] = -xform.rotationEuler[ 2 ];
float[] temp_float_values = new float[ HoudiniConstants.HAPI_POSITION_VECTOR_SIZE ];
for ( int pp = 0; pp < HoudiniConstants.HAPI_POSITION_VECTOR_SIZE; ++pp )
temp_float_values[ pp ] = parm_float_values[ parm_info.floatValuesIndex + pp ];
HoudiniHost.setParmFloatValues(
node_id, temp_float_values, parm_info.floatValuesIndex, parm_info.size );
myAsset.savePreset();
} // if changed
}
else if ( myManipMode == XformManipMode.Scale )
{
if ( scale_parm_id < 0 )
continue;
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm( scale_parm_id );
if ( parm_info.invisible )
continue;
GUIStyle style = new GUIStyle( EditorStyles.textField );
style.contentOffset = new Vector2( 1.4f, 1.4f );
string handle_name = handleInfo.name;
if ( parm_info.disabled )
handle_name = handle_name + " (disabled)";
GUIContent content = new GUIContent( handle_name );
content.tooltip = handle_name;
Handles.Label( position, content, style );
if ( parm_info.disabled )
{
Handles.lighting = false;
Handles.ScaleHandle( scale, position, rotation, 1.0f );
Handles.lighting = true;
continue;
}
Vector3 new_scale = Handles.ScaleHandle( scale, position, rotation, 1.0f );
if ( new_scale != scale )
{
changed = true;
if ( !myOpInProgress )
{
Undo.RecordObject( myAssetOTL.prParms.prParmsUndoInfo, handleInfo.name );
myOpInProgress = true;
}
parm_float_values[ parm_info.floatValuesIndex + 0 ] = new_scale.x;
parm_float_values[ parm_info.floatValuesIndex + 1 ] = new_scale.y;
parm_float_values[ parm_info.floatValuesIndex + 2 ] = new_scale.z;
float[] temp_float_values = new float[ HoudiniConstants.HAPI_POSITION_VECTOR_SIZE ];
for ( int pp = 0; pp < HoudiniConstants.HAPI_POSITION_VECTOR_SIZE; ++pp )
temp_float_values[ pp ] = parm_float_values[ parm_info.floatValuesIndex + pp ];
HoudiniHost.setParmFloatValues(
node_id, temp_float_values, parm_info.floatValuesIndex,
parm_info.size );
myAsset.savePreset();
} // if changed
} // if myManipMode
} // if typeName
} // for each handle
if ( changed )
myAssetOTL.buildClientSide();
}
public static void getAssetTransform(
HAPI_AssetId asset_id, HAPI_RSTOrder rst_order, HAPI_XYZOrder rot_order,
out HAPI_TransformEuler transform )
{
#if ( UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || ( UNITY_METRO && UNITY_EDITOR ) )
HAPI_Result status_code = HAPI_GetAssetTransform( ref mySession, asset_id, rst_order, rot_order, out transform );
processStatusCode( status_code );
#else
throw new HoudiniErrorUnsupportedPlatform();
#endif
}
HAPI_SetObjectTransform( ref HAPI_Session session, HAPI_AssetId asset_id, HAPI_ObjectId object_id, ref HAPI_TransformEuler transform );
public static HAPI_TransformEuler convertMatrixToEuler(
Matrix4x4 matrix, HAPI_RSTOrder rst_order, HAPI_XYZOrder rot_order )
{
#if ( UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || ( UNITY_METRO && UNITY_EDITOR ) )
HAPI_TransformEuler transform = new HAPI_TransformEuler();
float[] raw_matrix = new float[ 16 ];
for ( int i = 0; i < 16; ++i )
raw_matrix[ i ] = matrix[ i ];
HAPI_Result status_code = HAPI_ConvertMatrixToEuler(
ref mySession, raw_matrix, rst_order, rot_order, ref transform );
processStatusCode( status_code );
return transform;
#else
throw new HoudiniErrorUnsupportedPlatform();
#endif
}
HAPI_SetAssetTransform(
ref HAPI_Session session,
HAPI_AssetId asset_id,
ref HAPI_TransformEuler transform);
HAPI_GetAssetTransform( ref HAPI_Session session, HAPI_AssetId asset_id, HAPI_RSTOrder rst_order, HAPI_XYZOrder rot_order, out HAPI_TransformEuler transform );
HAPI_ConvertTransform(
ref HAPI_Session session,
ref HAPI_TransformEuler transform_in,
HAPI_RSTOrder rst_order,
HAPI_XYZOrder rot_order,
out HAPI_TransformEuler transform_out);
HAPI_ConvertMatrixToEuler(
ref HAPI_Session session,
float[] matrix,
HAPI_RSTOrder rst_order,
HAPI_XYZOrder rot_order,
ref HAPI_TransformEuler transform_out);
private static extern HAPI_Result HAPI_SetObjectTransform( ref HAPI_Session session, HAPI_AssetId asset_id, HAPI_ObjectId object_id, ref HAPI_TransformEuler transform );
private static extern HAPI_Result HAPI_GetAssetTransform( ref HAPI_Session session, HAPI_AssetId asset_id, HAPI_RSTOrder rst_order, HAPI_XYZOrder rot_order, out HAPI_TransformEuler transform );
private static extern HAPI_Result HAPI_ConvertTransformEulerToMatrix( ref HAPI_Session session, ref HAPI_TransformEuler transform, [Out] float[] matrix );
HAPI_ConvertMatrixToEuler( ref HAPI_Session session, float[] matrix, HAPI_RSTOrder rst_order, HAPI_XYZOrder rot_order, ref HAPI_TransformEuler transform_out );
HAPI_ConvertMatrixToEuler(
float[] mat,
HAPI_RSTOrder rst_order, HAPI_XYZOrder rot_order,
ref HAPI_TransformEuler transform_out);
HAPI_ConvertTransformEulerToMatrix( ref HAPI_Session session, ref HAPI_TransformEuler transform, [Out] float[] matrix );
HAPI_ConvertTransformEulerToMatrix(
ref HAPI_TransformEuler transform,
[Out] float[] matrix);
HAPI_SetAssetTransform( ref HAPI_Session session, HAPI_AssetId asset_id, ref HAPI_TransformEuler transform );
HAPI_GetAssetTransform(
HAPI_AssetId asset_id,
HAPI_RSTOrder rst_order, HAPI_XYZOrder rot_order,
out HAPI_TransformEuler transform);
// UTILITY --------------------------------------------------------------------------------------------------
public static HAPI_TransformEuler convertTransform(
HAPI_TransformEuler transform,
HAPI_RSTOrder rst_order, HAPI_XYZOrder rot_order )
{
#if ( UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || ( UNITY_METRO && UNITY_EDITOR ) )
HAPI_TransformEuler transform_out = new HAPI_TransformEuler();
HAPI_Result status_code = HAPI_ConvertTransform(
ref mySession, ref transform, rst_order, rot_order, out transform_out );
processStatusCode( status_code );
return transform_out;
#else
throw new HoudiniErrorUnsupportedPlatform();
#endif
}
HAPI_SetAssetTransform(
HAPI_AssetId asset_id,
ref HAPI_TransformEuler transform);
public static Matrix4x4 convertTransformEulerToMatrix( HAPI_TransformEuler transform )
{
#if ( UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || ( UNITY_METRO && UNITY_EDITOR ) )
float[] raw_matrix = new float[ 16 ];
HAPI_Result status_code = HAPI_ConvertTransformEulerToMatrix( ref mySession, ref transform, raw_matrix );
processStatusCode( status_code );
Matrix4x4 output = new Matrix4x4();
for ( int i = 0; i < 16; ++i )
output[ i ] = raw_matrix[ i ];
return output;
#else
throw new HoudiniErrorUnsupportedPlatform();
#endif
}
HAPI_SetObjectTransform(
HAPI_AssetId asset_id, HAPI_ObjectId object_id,
ref HAPI_TransformEuler transform);
public static void setObjectTransform(
HAPI_AssetId asset_id, HAPI_ObjectId object_id,
ref HAPI_TransformEuler transform )
{
#if ( UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || ( UNITY_METRO && UNITY_EDITOR ) )
HAPI_Result status_code = HAPI_SetObjectTransform( ref mySession, asset_id, object_id, ref transform );
processStatusCode( status_code );
#else
throw new HoudiniErrorUnsupportedPlatform();
#endif
}
HAPI_ConvertTransform(
ref HAPI_TransformEuler transform_in_out,
HAPI_RSTOrder rst_order, HAPI_XYZOrder rot_order);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Public
public void handlesOnSceneGUI()
{
if (myAssetOTL.prShowPinnedInstances)
{
drawPinnedInstances();
}
// On mouse up the drag operation is completed.
if (Event.current.type == EventType.MouseUp)
{
myOpInProgress = false;
}
string currentGlobalManipTool = Tools.current.ToString();
if (currentGlobalManipTool == "Rotate")
{
myManipMode = XformManipMode.Rotate;
}
else if (currentGlobalManipTool == "Move")
{
myManipMode = XformManipMode.Translate;
}
else if (currentGlobalManipTool == "Scale")
{
myManipMode = XformManipMode.Scale;
}
if (myAssetOTL == null)
{
return;
}
int node_id = myAssetOTL.prNodeId;
HAPI_HandleInfo[] handleInfos = myAssetOTL.prHandleInfos;
if (handleInfos == null)
{
return;
}
// Detect changes and build asset only when changed.
bool changed = false;
for (int ii = 0; ii < handleInfos.Length; ++ii)
{
HAPI_HandleInfo handleInfo = handleInfos[ii];
if (handleInfo.typeName == "xform")
{
float tx = 0, ty = 0, tz = 0;
float rx = 0, ry = 0, rz = 0;
float sx = 1, sy = 1, sz = 1;
HAPI_RSTOrder rstOrder = HAPI_RSTOrder.HAPI_SRT;
HAPI_XYZOrder xyzOrder = HAPI_XYZOrder.HAPI_XYZ;
HAPI_HandleBindingInfo[] bindingInfos = myAssetOTL.prHandleBindingInfos[ii];
int[] parm_int_values = myAssetOTL.prParms.prParmIntValues;
float[] parm_float_values = myAssetOTL.prParms.prParmFloatValues;
if (parm_int_values == null || parm_float_values == null)
{
Debug.LogError("No parm int/float values yet handles exist?");
continue;
}
int translate_parm_id = -1;
int rotate_parm_id = -1;
int scale_parm_id = -1;
int rst_order_parm_id = -1;
int xyz_order_parm_id = -1;
foreach (HAPI_HandleBindingInfo bindingInfo in bindingInfos)
{
string parm_name = bindingInfo.handleParmName;
if (parm_name == "tx")
{
translate_parm_id = bindingInfo.assetParmId;
}
else if (parm_name == "rx")
{
rotate_parm_id = bindingInfo.assetParmId;
}
else if (parm_name == "sx")
{
scale_parm_id = bindingInfo.assetParmId;
}
else if (parm_name == "trs_order")
{
rst_order_parm_id = bindingInfo.assetParmId;
}
else if (parm_name == "xyz_order")
{
xyz_order_parm_id = bindingInfo.assetParmId;
}
}
if (translate_parm_id >= 0)
{
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(translate_parm_id);
tx = parm_float_values[parm_info.floatValuesIndex + 0];
ty = parm_float_values[parm_info.floatValuesIndex + 1];
tz = parm_float_values[parm_info.floatValuesIndex + 2];
}
if (rotate_parm_id >= 0)
{
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(rotate_parm_id);
rx = parm_float_values[parm_info.floatValuesIndex + 0];
ry = parm_float_values[parm_info.floatValuesIndex + 1];
rz = parm_float_values[parm_info.floatValuesIndex + 2];
}
if (scale_parm_id >= 0)
{
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(scale_parm_id);
sx = parm_float_values[parm_info.floatValuesIndex + 0];
sy = parm_float_values[parm_info.floatValuesIndex + 1];
sz = parm_float_values[parm_info.floatValuesIndex + 2];
}
if (rst_order_parm_id >= 0)
{
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(rst_order_parm_id);
rstOrder = (HAPI_RSTOrder)parm_int_values[parm_info.intValuesIndex];
}
if (xyz_order_parm_id >= 0)
{
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(xyz_order_parm_id);
xyzOrder = (HAPI_XYZOrder)parm_int_values[parm_info.intValuesIndex];
}
HAPI_TransformEuler xform = new HAPI_TransformEuler(true);
// This bit is a little tricky. We will eventually call Handle.PositionHandle
// or Handle.RotationHandle to display the translation and rotation handles.
// These function take a translation parameter and a rotation parameter in
// order to display the handle in its proper location and orientation.
// These functions have an assumed order that it will put the rotation
// and translation back together. Depending whether the order of translation
// and roation matches that of the rstOrder setting, we may, or may not
// need to convert the translation parameter for use with the handle.
if (rstOrder == HAPI_RSTOrder.HAPI_TSR || rstOrder == HAPI_RSTOrder.HAPI_STR || rstOrder == HAPI_RSTOrder.HAPI_SRT)
{
xform.position[0] = tx;
xform.position[1] = ty;
xform.position[2] = tz;
xform.rotationEuler[0] = rx;
xform.rotationEuler[1] = ry;
xform.rotationEuler[2] = rz;
xform.scale[0] = 1;
xform.scale[1] = 1;
xform.scale[2] = 1;
xform.rotationOrder = xyzOrder;
xform.rstOrder = rstOrder;
}
else
{
xform.position[0] = 0;
xform.position[1] = 0;
xform.position[2] = 0;
xform.rotationEuler[0] = rx;
xform.rotationEuler[1] = ry;
xform.rotationEuler[2] = rz;
xform.scale[0] = 1;
xform.scale[1] = 1;
xform.scale[2] = 1;
xform.rotationOrder = xyzOrder;
xform.rstOrder = rstOrder;
}
xform = HoudiniHost.convertTransform(xform, HAPI_RSTOrder.HAPI_SRT, HAPI_XYZOrder.HAPI_ZXY);
// 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).
xform.position[0] = -xform.position[0];
xform.rotationEuler[1] = -xform.rotationEuler[1];
xform.rotationEuler[2] = -xform.rotationEuler[2];
tx = -tx;
Handles.matrix = myAssetOTL.transform.localToWorldMatrix;
Vector3 position;
if (rstOrder == HAPI_RSTOrder.HAPI_TSR || rstOrder == HAPI_RSTOrder.HAPI_STR || rstOrder == HAPI_RSTOrder.HAPI_SRT)
{
position = new Vector3(xform.position[0], xform.position[1], xform.position[2]);
}
else
{
position = new Vector3(tx, ty, tz);
}
Quaternion rotation = Quaternion.Euler(
xform.rotationEuler[0], xform.rotationEuler[1], xform.rotationEuler[2]);
Vector3 scale = new Vector3(sx, sy, sz);
if (myManipMode == XformManipMode.Translate)
{
if (translate_parm_id < 0)
{
continue;
}
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(translate_parm_id);
if (parm_info.invisible)
{
continue;
}
GUIStyle style = new GUIStyle(EditorStyles.textField);
style.contentOffset = new Vector2(1.4f, 1.4f);
string handle_name = handleInfo.name;
if (parm_info.disabled)
{
handle_name = handle_name + " (disabled)";
}
GUIContent content = new GUIContent(handle_name);
content.tooltip = handle_name;
Handles.Label(position, content, style);
if (parm_info.disabled)
{
Handles.lighting = false;
Handles.PositionHandle(position, rotation);
Handles.lighting = true;
continue;
}
Vector3 new_position = Handles.PositionHandle(position, rotation);
if (new_position != position)
{
changed = true;
if (!myOpInProgress)
{
Undo.RecordObject(myAssetOTL.prParms.prParmsUndoInfo, handleInfo.name);
myOpInProgress = true;
}
if (rstOrder == HAPI_RSTOrder.HAPI_TSR ||
rstOrder == HAPI_RSTOrder.HAPI_STR ||
rstOrder == HAPI_RSTOrder.HAPI_SRT)
{
xform.position[0] = new_position[0];
xform.position[1] = new_position[1];
xform.position[2] = new_position[2];
xform = HoudiniHost.convertTransform(xform, rstOrder, xyzOrder);
new_position.x = xform.position[0];
new_position.y = xform.position[1];
new_position.z = xform.position[2];
}
// the - in the x coordinate is to convert back to "Houdini" coordinates
parm_float_values[parm_info.floatValuesIndex + 0] = -new_position.x;
parm_float_values[parm_info.floatValuesIndex + 1] = new_position.y;
parm_float_values[parm_info.floatValuesIndex + 2] = new_position.z;
float[] temp_float_values = new float[HoudiniConstants.HAPI_POSITION_VECTOR_SIZE];
for (int pp = 0; pp < HoudiniConstants.HAPI_POSITION_VECTOR_SIZE; ++pp)
{
temp_float_values[pp] = parm_float_values[parm_info.floatValuesIndex + pp];
}
HoudiniHost.setParmFloatValues(node_id, temp_float_values, parm_info.floatValuesIndex,
parm_info.size);
myAsset.savePreset();
} // if changed
}
else if (myManipMode == XformManipMode.Rotate)
{
if (rotate_parm_id < 0)
{
continue;
}
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(rotate_parm_id);
if (parm_info.invisible)
{
continue;
}
GUIStyle style = new GUIStyle(EditorStyles.textField);
style.contentOffset = new Vector2(1.4f, 1.4f);
string handle_name = handleInfo.name;
if (parm_info.disabled)
{
handle_name = handle_name + " (disabled)";
}
GUIContent content = new GUIContent(handle_name);
content.tooltip = handle_name;
Handles.Label(position, content, style);
if (parm_info.disabled)
{
Handles.lighting = false;
Handles.RotationHandle(rotation, position);
Handles.lighting = true;
continue;
}
Quaternion new_rotation = Handles.RotationHandle(rotation, position);
if (new_rotation != rotation)
{
changed = true;
if (!myOpInProgress)
{
Undo.RecordObject(myAssetOTL.prParms.prParmsUndoInfo, handleInfo.name);
myOpInProgress = true;
}
Vector3 newRot = new_rotation.eulerAngles;
xform.position[0] = 0;
xform.position[1] = 0;
xform.position[2] = 0;
xform.rotationEuler[0] = newRot.x;
xform.rotationEuler[1] = newRot.y;
xform.rotationEuler[2] = newRot.z;
xform.scale[0] = 1;
xform.scale[1] = 1;
xform.scale[2] = 1;
xform.rotationOrder = HAPI_XYZOrder.HAPI_ZXY;
xform.rstOrder = HAPI_RSTOrder.HAPI_SRT;
xform = HoudiniHost.convertTransform(xform, rstOrder, xyzOrder);
parm_float_values[parm_info.floatValuesIndex + 0] = xform.rotationEuler[0];
// the - in the y & z coordinate is to convert back to "Houdini" coordinates
parm_float_values[parm_info.floatValuesIndex + 1] = -xform.rotationEuler[1];
parm_float_values[parm_info.floatValuesIndex + 2] = -xform.rotationEuler[2];
float[] temp_float_values = new float[HoudiniConstants.HAPI_POSITION_VECTOR_SIZE];
for (int pp = 0; pp < HoudiniConstants.HAPI_POSITION_VECTOR_SIZE; ++pp)
{
temp_float_values[pp] = parm_float_values[parm_info.floatValuesIndex + pp];
}
HoudiniHost.setParmFloatValues(
node_id, temp_float_values, parm_info.floatValuesIndex, parm_info.size);
myAsset.savePreset();
} // if changed
}
else if (myManipMode == XformManipMode.Scale)
{
if (scale_parm_id < 0)
{
continue;
}
HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(scale_parm_id);
if (parm_info.invisible)
{
continue;
}
GUIStyle style = new GUIStyle(EditorStyles.textField);
style.contentOffset = new Vector2(1.4f, 1.4f);
string handle_name = handleInfo.name;
if (parm_info.disabled)
{
handle_name = handle_name + " (disabled)";
}
GUIContent content = new GUIContent(handle_name);
content.tooltip = handle_name;
Handles.Label(position, content, style);
if (parm_info.disabled)
{
Handles.lighting = false;
Handles.ScaleHandle(scale, position, rotation, 1.0f);
Handles.lighting = true;
continue;
}
Vector3 new_scale = Handles.ScaleHandle(scale, position, rotation, 1.0f);
if (new_scale != scale)
{
changed = true;
if (!myOpInProgress)
{
Undo.RecordObject(myAssetOTL.prParms.prParmsUndoInfo, handleInfo.name);
myOpInProgress = true;
}
parm_float_values[parm_info.floatValuesIndex + 0] = new_scale.x;
parm_float_values[parm_info.floatValuesIndex + 1] = new_scale.y;
parm_float_values[parm_info.floatValuesIndex + 2] = new_scale.z;
float[] temp_float_values = new float[HoudiniConstants.HAPI_POSITION_VECTOR_SIZE];
for (int pp = 0; pp < HoudiniConstants.HAPI_POSITION_VECTOR_SIZE; ++pp)
{
temp_float_values[pp] = parm_float_values[parm_info.floatValuesIndex + pp];
}
HoudiniHost.setParmFloatValues(
node_id, temp_float_values, parm_info.floatValuesIndex,
parm_info.size);
myAsset.savePreset();
} // if changed
} // if myManipMode
} // if typeName
} // for each handle
if (changed)
{
myAssetOTL.buildClientSide();
}
}
HAPI_ConvertTransform( ref HAPI_Session session, ref HAPI_TransformEuler transform_in, HAPI_RSTOrder rst_order, HAPI_XYZOrder rot_order, out HAPI_TransformEuler transform_out );
public bool setNodeParameterIntoHost(int id)
{
HAPI_ParmInfo parm = findParm(id);
var parm_input = myParmInputs[id];
if (!parm_input.inputObject)
{
return(false);
}
// Create new input node.
GameObject input_object = parm_input.inputObject;
HoudiniControl houdini_control = input_object.GetComponent <HoudiniControl>();
MeshFilter mesh_filter = input_object.GetComponent <MeshFilter>();
if (houdini_control &&
houdini_control.prAsset.gameObject.GetComponentInChildren <HoudiniGeoControl>())
{
if (!houdini_control.prAsset.isAssetValid())
{
houdini_control.prAsset.buildAll();
}
HoudiniGeoControl geo_control =
houdini_control.prAsset.gameObject.GetComponentInChildren <HoudiniGeoControl>();
parm_input.inputNodeId = geo_control.prNodeId;
// Add ourselves to our input asset's downstream nodes so when it cooks we cook.
houdini_control.prAsset.addDownstreamAsset(myControl.prAsset);
}
else if (houdini_control &&
input_object.GetComponent <HoudiniAssetCurve>())
{
if (!houdini_control.prAsset.isAssetValid())
{
houdini_control.prAsset.buildAll();
}
parm_input.inputNodeId = houdini_control.prNodeId;
// Add ourselves to our input asset's downstream nodes so when it cooks we cook.
houdini_control.prAsset.addDownstreamAsset(myControl.prAsset);
}
else if (mesh_filter && mesh_filter.sharedMesh)
{
// We need to remove spaces in the input name
string inputName = input_object.name.Replace(' ', '_');
parm_input.inputNodeId = HoudiniHost.createInputNode(inputName);
Mesh mesh = mesh_filter.sharedMesh;
HoudiniAssetUtility.setMesh(
parm_input.inputNodeId, 0, parm_input.inputNodeId, ref mesh, null, null);
// Set the asset transform from the source GameObject transform.
HAPI_TransformEuler trans =
HoudiniAssetUtility.getHapiTransform(input_object.transform.localToWorldMatrix);
HAPI_NodeInfo input_node_info = HoudiniHost.getNodeInfo(parm_input.inputNodeId);
HoudiniHost.setObjectTransform(input_node_info.parentId, ref trans);
}
else
{
return(false);
}
HAPI_NodeInfo node_info = HoudiniHost.getNodeInfo(parm_input.inputNodeId);
parm_input.inputNodeUniqueId = node_info.uniqueHoudiniNodeId;
// Assign node parm input.
HoudiniHost.setParmNodeValue(prControl.prNodeId, parm.name, parm_input.inputNodeId);
myParmInputs[id] = parm_input;
return(true);
}
private static extern HAPI_Result HAPI_ConvertMatrixToEuler( ref HAPI_Session session, float[] matrix, HAPI_RSTOrder rst_order, HAPI_XYZOrder rot_order, ref HAPI_TransformEuler transform_out );
