public bool GetUpdatedPosition(HEU_HoudiniAsset asset, ref Vector3 inPosition)
{
if (_handleParamTranslateBinding == null || _handleParamTranslateBinding._bDisabled)
{
return false;
}
HEU_SessionBase session = asset.GetAssetSession(true);
if(session == null)
{
return false;
}
if (IsSpecialRSTOrder(_rstOrder))
{
HAPI_TransformEuler transformEuler = _convertedTransformEuler;
transformEuler.position[0] = inPosition[0];
transformEuler.position[1] = inPosition[1];
transformEuler.position[2] = inPosition[2];
HAPI_TransformEuler newTransformEuler;
if (!session.ConvertTransform(ref transformEuler, _rstOrder, _xyzOrder, out newTransformEuler))
{
return false;
}
inPosition[0] = newTransformEuler.position[0];
inPosition[1] = newTransformEuler.position[1];
inPosition[2] = newTransformEuler.position[2];
}
inPosition[0] = -inPosition[0];
return true;
}
public static HAPI_TransformEuler GetHAPITransformFromMatrix(ref Matrix4x4 mat)
{
Quaternion q = GetQuaternion(ref mat);
Vector3 r = q.eulerAngles;
Vector3 p = GetPosition(ref mat);
Vector3 s = GetScale(ref mat);
HAPI_TransformEuler transform = new HAPI_TransformEuler(true);
transform.position[0] = -p[0];
transform.position[1] = p[1];
transform.position[2] = p[2];
transform.rotationEuler[0] = r[0];
transform.rotationEuler[1] = -r[1];
transform.rotationEuler[2] = -r[2];
transform.scale[0] = s[0];
transform.scale[1] = s[1];
transform.scale[2] = s[2];
transform.rotationOrder = HAPI_XYZOrder.HAPI_ZXY;
transform.rstOrder = HAPI_RSTOrder.HAPI_SRT;
return(transform);
}
/// <summary>
/// Generates heightfield/terrain data from the given object relevant for uploading to Houdini.
/// </summary>
/// <param name="inputObject"></param>
/// <returns>Valid input object or null if given object is not supported</returns>
public HEU_InputDataTerrain GenerateTerrainDataFromGameObject(GameObject inputObject)
{
HEU_InputDataTerrain inputData = null;
Terrain terrain = inputObject.GetComponent<Terrain>();
if (terrain != null)
{
TerrainData terrainData = terrain.terrainData;
Vector3 terrainSize = terrainData.size;
if (terrainSize.x != terrainSize.z)
{
Debug.LogError("Only square sized terrains are supported for input! Change to square size and try again.");
return null;
}
inputData = new HEU_InputDataTerrain();
inputData._inputObject = inputObject;
inputData._terrain = terrain;
inputData._terrainData = terrainData;
// Height values in Unity are normalized between 0 and 1, so this height scale
// will multiply them before uploading to Houdini.
inputData._heightScale = terrainSize.y;
// Terrain heightMapResolution is the pixel resolution, which we set to the number of voxels
// by dividing the terrain size with it. In Houdini, this is the Grid Spacing.
inputData._voxelSize = terrainSize.x / inputData._terrainData.heightmapResolution;
// This is the number of heightfield voxels on each dimension.
inputData._numPointsX = Mathf.RoundToInt(inputData._terrainData.heightmapResolution * inputData._voxelSize);
inputData._numPointsY = Mathf.RoundToInt(inputData._terrainData.heightmapResolution * inputData._voxelSize);
Matrix4x4 transformMatrix = inputObject.transform.localToWorldMatrix;
HAPI_TransformEuler transformEuler = HEU_HAPIUtility.GetHAPITransformFromMatrix(ref transformMatrix);
// Volume transform used for all heightfield layers
inputData._transform = new HAPI_Transform(false);
// Unity terrain pivots are at bottom left, but Houdini uses centered heightfields so
// apply local position offset by half sizes and account for coordinate change
inputData._transform.position[0] = terrainSize.z * 0.5f;
inputData._transform.position[1] = -terrainSize.x * 0.5f;
inputData._transform.position[2] = 0;
// Volume scale controls final size, but requires to be divided by 2
inputData._transform.scale[0] = terrainSize.x * 0.5f;
inputData._transform.scale[1] = terrainSize.z * 0.5f;
inputData._transform.scale[2] = 0.5f;
inputData._transform.rotationQuaternion[0] = 0f;
inputData._transform.rotationQuaternion[1] = 0f;
inputData._transform.rotationQuaternion[2] = 0f;
inputData._transform.rotationQuaternion[3] = 1f;
}
return inputData;
}
/// <summary>
/// Set the input node's transform.
/// </summary>
/// <param name="session">Session that the input node exists in</param>
/// <param name="inputObject">The input object info containing data about the input</param>
/// <param name="inputNodeID">The input node ID</param>
/// <param name="bKeepWorldTransform">Whether to use world transform or not</param>
/// <returns></returns>
internal static bool UploadInputObjectTransform(HEU_SessionBase session, HEU_InputObjectInfo inputObject, HAPI_NodeId inputNodeID, bool bKeepWorldTransform)
{
Matrix4x4 inputTransform = Matrix4x4.identity;
if (inputObject._useTransformOffset)
{
if (bKeepWorldTransform)
{
// Add offset tranform to world transform
Transform inputObjTransform = inputObject._gameObject.transform;
Vector3 position = inputObjTransform.position + inputObject._translateOffset;
Quaternion rotation = inputObjTransform.rotation * Quaternion.Euler(inputObject._rotateOffset);
Vector3 scale = Vector3.Scale(inputObjTransform.localScale, inputObject._scaleOffset);
Vector3 rotVector = rotation.eulerAngles;
inputTransform = HEU_HAPIUtility.GetMatrix4x4(ref position, ref rotVector, ref scale);
}
else
{
// Offset from origin.
inputTransform = HEU_HAPIUtility.GetMatrix4x4(ref inputObject._translateOffset, ref inputObject._rotateOffset, ref inputObject._scaleOffset);
}
}
else
{
inputTransform = inputObject._gameObject.transform.localToWorldMatrix;
}
HAPI_TransformEuler transformEuler = HEU_HAPIUtility.GetHAPITransformFromMatrix(ref inputTransform);
HAPI_NodeInfo inputNodeInfo = new HAPI_NodeInfo();
if (!session.GetNodeInfo(inputNodeID, ref inputNodeInfo))
{
return false;
}
if (session.SetObjectTransform(inputNodeInfo.parentId, ref transformEuler))
{
inputObject._syncdTransform = inputTransform;
inputObject._syncdChildTransforms.Clear();
GetChildrenTransforms(inputObject._gameObject.transform, ref inputObject._syncdChildTransforms);
}
return true;
}
public bool GetUpdatedRotation(HEU_HoudiniAsset asset, ref Quaternion inRotation)
{
if (_handleParamTranslateBinding == null || _handleParamTranslateBinding._bDisabled)
{
return false;
}
HEU_SessionBase session = asset.GetAssetSession(true);
if (session == null)
{
return false;
}
Vector3 newRotation = inRotation.eulerAngles;
HAPI_TransformEuler transformEuler = _convertedTransformEuler;
transformEuler.position[0] = 0;
transformEuler.position[1] = 0;
transformEuler.position[2] = 0;
transformEuler.rotationEuler[0] = newRotation[0];
transformEuler.rotationEuler[1] = newRotation[1];
transformEuler.rotationEuler[2] = newRotation[2];
transformEuler.scale[0] = 1;
transformEuler.scale[1] = 1;
transformEuler.scale[2] = 1;
transformEuler.rotationOrder = HAPI_XYZOrder.HAPI_ZXY;
transformEuler.rstOrder = HAPI_RSTOrder.HAPI_SRT;
HAPI_TransformEuler newTransformEuler;
if (!session.ConvertTransform(ref transformEuler, _rstOrder, _xyzOrder, out newTransformEuler))
{
return false;
}
inRotation[0] = newTransformEuler.rotationEuler[0];
inRotation[1] = -newTransformEuler.rotationEuler[1];
inRotation[2] = -newTransformEuler.rotationEuler[2];
return true;
}
public static HAPI_TransformEuler GetHAPITransform(ref Vector3 p, ref Vector3 r, ref Vector3 s)
{
HAPI_TransformEuler transform = new HAPI_TransformEuler(true);
transform.position[0] = -p[0];
transform.position[1] = p[1];
transform.position[2] = p[2];
transform.rotationEuler[0] = r[0];
transform.rotationEuler[1] = -r[1];
transform.rotationEuler[2] = -r[2];
transform.scale[0] = s[0];
transform.scale[1] = s[1];
transform.scale[2] = s[2];
transform.rotationOrder = HAPI_XYZOrder.HAPI_ZXY;
transform.rstOrder = HAPI_RSTOrder.HAPI_SRT;
return(transform);
}
public void GenerateTransform(HEU_SessionBase session, HEU_Parameters parameters)
{
HAPI_TransformEuler transformEuler = new HAPI_TransformEuler(true);
transformEuler.rstOrder = _rstOrder;
transformEuler.rotationOrder = _xyzOrder;
transformEuler.position[0] = 0;
transformEuler.position[1] = 0;
transformEuler.position[2] = 0;
transformEuler.rotationEuler[0] = 0;
transformEuler.rotationEuler[1] = 0;
transformEuler.rotationEuler[2] = 0;
transformEuler.scale[0] = 1;
transformEuler.scale[1] = 1;
transformEuler.scale[2] = 1;
if (_handleParamTranslateBinding != null)
{
HEU_ParameterData parmData = parameters.GetParameterWithParmID(_handleParamTranslateBinding._parmID);
if (parmData != null && !parmData._parmInfo.invisible)
{
transformEuler.position[0] = parmData._floatValues[0];
transformEuler.position[1] = parmData._floatValues[1];
transformEuler.position[2] = parmData._floatValues[2];
}
}
if(_handleParamRotateBinding != null)
{
HEU_ParameterData parmData = parameters.GetParameterWithParmID(_handleParamRotateBinding._parmID);
if (parmData != null && !parmData._parmInfo.invisible)
{
transformEuler.rotationEuler[0] = parmData._floatValues[0];
transformEuler.rotationEuler[1] = parmData._floatValues[1];
transformEuler.rotationEuler[2] = parmData._floatValues[2];
}
}
if(_handleParamScaleBinding != null)
{
HEU_ParameterData parmData = parameters.GetParameterWithParmID(_handleParamScaleBinding._parmID);
if (parmData != null && !parmData._parmInfo.invisible)
{
transformEuler.scale[0] = parmData._floatValues[0];
transformEuler.scale[1] = parmData._floatValues[1];
transformEuler.scale[2] = parmData._floatValues[2];
}
}
if (!session.ConvertTransform(ref transformEuler, HAPI_RSTOrder.HAPI_SRT, HAPI_XYZOrder.HAPI_ZXY, out _convertedTransformEuler))
{
return;
}
// Convert to left-handed Unity
_convertedTransformEuler.position[0] = -_convertedTransformEuler.position[0];
_convertedTransformEuler.rotationEuler[1] = -_convertedTransformEuler.rotationEuler[1];
_convertedTransformEuler.rotationEuler[2] = -_convertedTransformEuler.rotationEuler[2];
if (IsSpecialRSTOrder(transformEuler.rstOrder))
{
_handlePosition = new Vector3(_convertedTransformEuler.position[0], _convertedTransformEuler.position[1], _convertedTransformEuler.position[2]);
}
else if (_handleParamTranslateBinding != null)
{
_handlePosition = new Vector3(-transformEuler.position[0], transformEuler.position[1], transformEuler.position[2]);
}
else
{
_handlePosition = Vector3.zero;
}
_handleRotation = Quaternion.Euler(_convertedTransformEuler.rotationEuler[0], _convertedTransformEuler.rotationEuler[1], _convertedTransformEuler.rotationEuler[2]);
if (_handleParamScaleBinding != null)
{
_handleScale = new Vector3(transformEuler.scale[0], transformEuler.scale[1], transformEuler.scale[2]);
}
else
{
_handleScale = Vector3.one;
}
}
/// <summary>
/// Set the transform of an OBJ node.
/// </summary>
/// <param name="nodeID">The object node ID</param>
/// <param name="hapiTransform">The transform to set</param>
/// <returns>True if successfully set the transform</returns>
public virtual bool SetObjectTransform(HAPI_NodeId nodeID, ref HAPI_TransformEuler hapiTransform)
{
return false;
}
public virtual bool ConvertTransform(ref HAPI_TransformEuler inTransform, HAPI_RSTOrder RSTOrder, HAPI_XYZOrder ROTOrder, out HAPI_TransformEuler outTransform)
{
outTransform = new HAPI_TransformEuler();
return false;
}
