public void CopyInputValuesTo(HEU_SessionBase session, HEU_InputNode destInputNode)
{
destInputNode._pendingInputObjectType = _inputObjectType;
if (destInputNode._inputObjectType == InputObjectType.HDA)
{
destInputNode.ResetConnectionForForceUpdate(session);
}
destInputNode.RemoveAllInputEntries();
foreach (HEU_InputObjectInfo srcInputObject in _inputObjects)
{
HEU_InputObjectInfo newInputObject = new HEU_InputObjectInfo();
srcInputObject.CopyTo(newInputObject);
destInputNode._inputObjects.Add(newInputObject);
}
foreach (HEU_InputHDAInfo srcInputInfo in _inputAssetInfos)
{
HEU_InputHDAInfo newInputInfo = new HEU_InputHDAInfo();
srcInputInfo.CopyTo(newInputInfo);
destInputNode._inputAssetInfos.Add(newInputInfo);
}
destInputNode._keepWorldTransform = _keepWorldTransform;
destInputNode._packGeometryBeforeMerging = _packGeometryBeforeMerging;
}
private HEU_InputObjectInfo CreateInputObjectInfo(GameObject inputGameObject)
{
HEU_InputObjectInfo newObjectInfo = new HEU_InputObjectInfo();
newObjectInfo._gameObject = inputGameObject;
return newObjectInfo;
}
public void CopyInputValuesTo(HEU_SessionBase session, HEU_InputNode destInputNode)
{
destInputNode._pendingInputObjectType = _inputObjectType;
if(destInputNode._inputObjectType == InputObjectType.HDA)
{
destInputNode.ResetConnectionForForceUpdate(session);
}
destInputNode._inputObjects.Clear();
foreach(HEU_InputObjectInfo inputObj in _inputObjects)
{
HEU_InputObjectInfo newInputObject = new HEU_InputObjectInfo();
inputObj.CopyTo(newInputObject);
//newInputObject._syncdTransform = Matrix4x4.identity;
destInputNode._inputObjects.Add(newInputObject);
}
destInputNode._inputAsset = _inputAsset;
destInputNode._connectedInputAsset = _connectedInputAsset;
destInputNode._keepWorldTransform = _keepWorldTransform;
destInputNode._packGeometryBeforeMerging = _packGeometryBeforeMerging;
}
public void CopyTo(HEU_InputObjectInfo destObject)
{
destObject._gameObject = _gameObject;
destObject._syncdTransform = _syncdTransform;
destObject._useTransformOffset = _useTransformOffset;
destObject._translateOffset = _translateOffset;
destObject._rotateOffset = _rotateOffset;
destObject._scaleOffset = _scaleOffset;
}
/// <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;
}
/// <summary>
/// Return the input interface that can upload the given inputObjectInfo's data.
/// It checks the inputObjectInfo._inputInterfaceType to see if it was previously
/// uploaded, and if so, uses the same interface.
/// </summary>
/// <param name="inputObjectInfo">Input object info used to find the interface</param>
/// <returns>Compatible input interface or null</returns>
internal static HEU_InputInterface GetInputInterface(HEU_InputObjectInfo inputObjectInfo)
{
HEU_InputInterface inputInterface = null;
if (inputObjectInfo._inputInterfaceType == null)
{
inputInterface = GetInputInterfaceByType(inputObjectInfo._inputInterfaceType);
}
if (inputInterface == null)
{
inputInterface = GetInputInterface(inputObjectInfo._gameObject);
if (inputInterface != null)
{
inputObjectInfo._inputInterfaceType = inputInterface.GetType();
}
}
return inputInterface;
}
public void LoadPreset(HEU_SessionBase session, HEU_InputPreset inputPreset)
{
ResetInputNode(session);
ChangeInputType(session, inputPreset._inputObjectType);
if (inputPreset._inputObjectType == InputObjectType.UNITY_MESH)
{
bool bSet = false;
int numObjects = inputPreset._inputObjectPresets.Count;
for (int i = 0; i < numObjects; ++i)
{
bSet = false;
if (!string.IsNullOrEmpty(inputPreset._inputObjectPresets[i]._gameObjectName))
{
GameObject inputGO = null;
if (inputPreset._inputObjectPresets[i]._isSceneObject)
{
inputGO = HEU_GeneralUtility.GetGameObjectByNameInScene(inputPreset._inputObjectPresets[i]._gameObjectName);
}
else
{
// Use the _gameObjectName as path to find in scene
inputGO = HEU_AssetDatabase.LoadAssetAtPath(inputPreset._inputObjectPresets[i]._gameObjectName, typeof(GameObject)) as GameObject;
if (inputGO == null)
{
Debug.LogErrorFormat("Unable to find input at {0}", inputPreset._inputObjectPresets[i]._gameObjectName);
}
}
if (inputGO != null)
{
HEU_InputObjectInfo inputObject = InternalAddInputObjectAtEnd(inputGO);
bSet = true;
inputObject._useTransformOffset = inputPreset._inputObjectPresets[i]._useTransformOffset;
inputObject._translateOffset = inputPreset._inputObjectPresets[i]._translateOffset;
inputObject._rotateOffset = inputPreset._inputObjectPresets[i]._rotateOffset;
inputObject._scaleOffset = inputPreset._inputObjectPresets[i]._scaleOffset;
}
else
{
Debug.LogWarningFormat("Gameobject with name {0} not found. Unable to set input object.", inputPreset._inputAssetName);
}
}
if (!bSet)
{
// Add dummy spot (user can replace it manually)
InternalAddInputObjectAtEnd(null);
}
}
}
else if (inputPreset._inputObjectType == HEU_InputNode.InputObjectType.HDA)
{
bool bSet = false;
int numInptus = inputPreset._inputAssetPresets.Count;
for (int i = 0; i < numInptus; ++i)
{
bSet = false;
if (!string.IsNullOrEmpty(inputPreset._inputAssetPresets[i]._gameObjectName))
{
bSet = FindAddToInputHDA(inputPreset._inputAssetPresets[i]._gameObjectName);
}
if (!bSet)
{
// Couldn't add for some reason, so just add dummy spot (user can replace it manually)
InternalAddInputHDAAtEnd(null);
}
}
if (numInptus == 0 && !string.IsNullOrEmpty(inputPreset._inputAssetName))
{
// Old preset. Add it to input
FindAddToInputHDA(inputPreset._inputAssetName);
}
}
KeepWorldTransform = inputPreset._keepWorldTransform;
PackGeometryBeforeMerging = inputPreset._packGeometryBeforeMerging;
RequiresUpload = true;
ClearUICache();
}
private HEU_InputObjectInfo InternalAddInputObjectAtEnd(GameObject newInputGameObject)
{
HEU_InputObjectInfo inputObject = CreateInputObjectInfo(newInputGameObject);
_inputObjects.Add(inputObject);
return inputObject;
}
public void UploadInput(HEU_SessionBase session)
{
if (_nodeID == HEU_Defines.HEU_INVALID_NODE_ID)
{
Debug.LogErrorFormat("Input Node ID is invalid. Unable to upload input. Try recooking.");
return;
}
if (_pendingInputObjectType != _inputObjectType)
{
ChangeInputType(session, _pendingInputObjectType);
}
if (_inputObjectType == InputObjectType.UNITY_MESH)
{
// Connect regular gameobjects
if (_inputObjects == null || _inputObjects.Count == 0)
{
DisconnectAndDestroyInputs(session);
}
else
{
DisconnectAndDestroyInputs(session);
List<HEU_InputObjectInfo> inputObjectClone = new List<HEU_InputObjectInfo>(_inputObjects);
// Special input interface preprocessing
for (int i = inputObjectClone.Count - 1; i >= 0; i--)
{
if (inputObjectClone[i] == null || inputObjectClone[i]._gameObject == null)
{
continue;
}
HEU_BoundingVolume boundingVolume = inputObjectClone[i]._gameObject.GetComponent<HEU_BoundingVolume>();
if (boundingVolume == null)
{
continue;
}
List<GameObject> boundingBoxObjects = boundingVolume.GetAllIntersectingObjects();
if (boundingBoxObjects == null)
{
continue;
}
foreach (GameObject obj in boundingBoxObjects)
{
if (obj == null)
{
continue;
}
HEU_InputObjectInfo newObjInfo = new HEU_InputObjectInfo();
inputObjectClone[i].CopyTo(newObjInfo);
newObjInfo._gameObject = obj;
inputObjectClone.Add(newObjInfo);
}
// Remove this because it's not a real interface
inputObjectClone.RemoveAt(i);
}
// Create merge object, and input nodes with data, then connect them to the merge object
bool bResult = HEU_InputUtility.CreateInputNodeWithMultiObjects(session, _nodeID, ref _connectedNodeID, ref inputObjectClone, ref _inputObjectsConnectedAssetIDs, _keepWorldTransform);
if (!bResult)
{
DisconnectAndDestroyInputs(session);
return;
}
// Now connect from this asset to the merge object
ConnectToMergeObject(session);
if (!UploadObjectMergeTransformType(session))
{
Debug.LogErrorFormat("Failed to upload object merge transform type!");
return;
}
if (!UploadObjectMergePackGeometry(session))
{
Debug.LogErrorFormat("Failed to upload object merge pack geometry value!");
return;
}
}
}
else if (_inputObjectType == InputObjectType.HDA)
{
// Connect HDAs
// First clear all previous input connections
DisconnectAndDestroyInputs(session);
// Create merge object, and connect all input HDAs
bool bResult = HEU_InputUtility.CreateInputNodeWithMultiAssets(session, _parentAsset, ref _connectedNodeID, ref _inputAssetInfos, _keepWorldTransform, -1);
if (!bResult)
{
DisconnectAndDestroyInputs(session);
return;
}
// Now connect from this asset to the merge object
ConnectToMergeObject(session);
if (!UploadObjectMergeTransformType(session))
{
Debug.LogErrorFormat("Failed to upload object merge transform type!");
return;
}
if (!UploadObjectMergePackGeometry(session))
{
Debug.LogErrorFormat("Failed to upload object merge pack geometry value!");
return;
}
}
//else if (_inputObjectType == InputObjectType.CURVE)
//{
// TODO INPUT NODE - create new Curve SOP (add HEU_Curve here?)
//}
else
{
Debug.LogErrorFormat("Unsupported input type {0}. Unable to upload input.", _inputObjectType);
}
RequiresUpload = false;
RequiresCook = true;
ClearUICache();
}
public static void ExecuteToolOperatorMultiple(string toolName, string toolPath, GameObject[] inputObjects)
{
GameObject outputObjectToSelect = null;
GameObject go = HEU_HAPIUtility.InstantiateHDA(toolPath, Vector3.zero, HEU_SessionManager.GetOrCreateDefaultSession(), false);
if(go == null)
{
Debug.LogWarningFormat("Failed to instantiate tool: {0}", toolName);
return;
}
HEU_HoudiniAssetRoot assetRoot = go.GetComponent<HEU_HoudiniAssetRoot>();
if (assetRoot != null)
{
HEU_HoudiniAsset asset = assetRoot._houdiniAsset;
HEU_SessionBase session = asset.GetAssetSession(true);
int numInputs = inputObjects.Length;
List<HEU_InputNode> inputNodes = asset.GetInputNodes();
if (inputNodes == null || inputNodes.Count == 0)
{
Debug.LogErrorFormat("Unable to assign input geometry due to no asset inputs on selected tool.");
}
else
{
// User could have selected any number of inputs objects, and asset could have any number of inputs.
// So use minimum of either to set input object into asset input.
int minInputCount = Mathf.Min(inputNodes.Count, numInputs);
for (int i = 0; i < minInputCount; ++i)
{
if (!IsValidInput(inputObjects[i]))
{
continue;
}
GameObject inputObject = inputObjects[i];
HEU_InputNode inputNode = inputNodes[i];
inputNode.ResetInputNode(session);
inputNode.ChangeInputType(session, HEU_InputNode.InputObjectType.UNITY_MESH);
HEU_InputObjectInfo inputInfo = inputNode.AddInputEntryAtEnd(inputObject);
inputInfo._useTransformOffset = false;
inputNode.KeepWorldTransform = true;
inputNode.PackGeometryBeforeMerging = false;
inputNode.RequiresUpload = true;
}
asset.RequestCook(true, true, true, true);
outputObjectToSelect = assetRoot.gameObject;
}
}
if (outputObjectToSelect != null)
{
HEU_EditorUtility.SelectObject(outputObjectToSelect);
}
}
public static void ExecuteToolOperatorSingle(string toolName, string toolPath, GameObject[] inputObjects)
{
// Single operator means single asset input. If multiple inputs are provided, create tool for each input.
List<GameObject> outputObjectsToSelect = new List<GameObject>();
int numInputs = inputObjects.Length;
for (int i = 0; i < numInputs; ++i)
{
if(!IsValidInput(inputObjects[i]))
{
continue;
}
GameObject inputObject = inputObjects[i];
GameObject go = HEU_HAPIUtility.InstantiateHDA(toolPath, Vector3.zero, HEU_SessionManager.GetOrCreateDefaultSession(), false);
if (go != null)
{
HEU_HoudiniAssetRoot assetRoot = go.GetComponent<HEU_HoudiniAssetRoot>();
if (assetRoot != null)
{
HEU_HoudiniAsset asset = assetRoot._houdiniAsset;
HEU_SessionBase session = asset.GetAssetSession(true);
List<HEU_InputNode> inputNodes = asset.GetInputNodes();
if (inputNodes == null || inputNodes.Count == 0)
{
Debug.LogErrorFormat("Unable to assign input geometry due to no asset inputs on selected tool.");
}
else
{
HEU_InputNode inputNode = inputNodes[0];
inputNode.ResetInputNode(session);
inputNode.ChangeInputType(session, HEU_InputNode.InputObjectType.UNITY_MESH);
HEU_InputObjectInfo inputInfo = inputNode.AddInputEntryAtEnd(inputObject);
inputInfo._useTransformOffset = false;
inputNode.KeepWorldTransform = true;
inputNode.PackGeometryBeforeMerging = false;
inputNode.RequiresUpload = true;
asset.RequestCook(true, true, true, true);
outputObjectsToSelect.Add(assetRoot.gameObject);
}
}
}
else
{
Debug.LogWarningFormat("Failed to instantiate tool: {0}", toolName);
}
}
if (outputObjectsToSelect.Count > 0)
{
HEU_EditorUtility.SelectObjects(outputObjectsToSelect.ToArray());
}
}
public void LoadPreset(HEU_SessionBase session, HEU_InputPreset inputPreset)
{
ResetInputNode(session);
ChangeInputType(session, inputPreset._inputObjectType);
if (inputPreset._inputObjectType == HEU_InputNode.InputObjectType.UNITY_MESH)
{
int numObjects = inputPreset._inputObjectPresets.Count;
for (int i = 0; i < numObjects; ++i)
{
if (!string.IsNullOrEmpty(inputPreset._inputObjectPresets[i]._gameObjectName))
{
GameObject inputGO = null;
if (inputPreset._inputObjectPresets[i]._isSceneObject)
{
inputGO = HEU_GeneralUtility.GetGameObjectByNameInScene(inputPreset._inputObjectPresets[i]._gameObjectName);
}
else
{
// Use the _gameObjectName as path to find in scene
inputGO = HEU_AssetDatabase.LoadAssetAtPath(inputPreset._inputObjectPresets[i]._gameObjectName, typeof(GameObject)) as GameObject;
if(inputGO == null)
{
Debug.LogErrorFormat("Unable to find input at {0}", inputPreset._inputObjectPresets[i]._gameObjectName);
}
}
if (inputGO != null)
{
HEU_InputObjectInfo inputObject = AddInputObjectAtEnd(inputGO);
inputObject._useTransformOffset = inputPreset._inputObjectPresets[i]._useTransformOffset;
inputObject._translateOffset = inputPreset._inputObjectPresets[i]._translateOffset;
inputObject._rotateOffset = inputPreset._inputObjectPresets[i]._rotateOffset;
inputObject._scaleOffset = inputPreset._inputObjectPresets[i]._scaleOffset;
}
else
{
Debug.LogWarningFormat("Gameobject with name {0} not found. Unable to set input object.", inputPreset._inputAssetName);
}
}
}
}
else if (inputPreset._inputObjectType == HEU_InputNode.InputObjectType.HDA)
{
if (!string.IsNullOrEmpty(inputPreset._inputAssetName))
{
GameObject inputAsset = GameObject.Find(inputPreset._inputAssetName);
if (inputAsset != null)
{
HEU_HoudiniAssetRoot inputAssetRoot = inputAsset != null ? inputAsset.GetComponent<HEU_HoudiniAssetRoot>() : null;
if (inputAssetRoot != null && inputAssetRoot._houdiniAsset != null)
{
// Need to reconnect and make sure connected asset is in this session
_inputAsset = inputAsset;
if (!inputAssetRoot._houdiniAsset.IsAssetValidInHoudini(session))
{
inputAssetRoot._houdiniAsset.RequestCook(true, false, true, true);
}
_connectedNodeID = inputAssetRoot._houdiniAsset.AssetID;
_parentAsset.ConnectToUpstream(inputAssetRoot._houdiniAsset);
_connectedInputAsset = _inputAsset;
}
else
{
Debug.LogErrorFormat("Input HDA with name {0} is not a valid asset (missing components). Unable to set input asset.", inputPreset._inputAssetName);
}
}
else
{
Debug.LogWarningFormat("Game with name {0} not found. Unable to set input asset.", inputPreset._inputAssetName);
}
}
}
KeepWorldTransform = inputPreset._keepWorldTransform;
PackGeometryBeforeMerging = inputPreset._packGeometryBeforeMerging;
RequiresUpload = true;
ClearUICache();
}
public HEU_InputObjectInfo AddInputObjectAtEnd(GameObject newInputGameObject)
{
HEU_InputObjectInfo inputObject = CreateInputObjectInfo(newInputGameObject);
_inputObjects.Add(inputObject);
return inputObject;
}
