| public static GetString ( int stringHandle, HEU_SessionBase session = null ) : string | ||
| stringHandle | int | String handle to query. |
| session | HEU_SessionBase | |
| Résultat | string | |
/// <summary>
/// Return the file name for the given material node's parameter.
/// </summary>
/// <param name="session">Current session</param>
/// <param name="nodeID">Material node ID</param>
/// <param name="parmInfo">Parameter on material to query</param>
/// <returns>Given parameter's string value</returns>
public static string GetTextureFileNameFromMaterialParam(HEU_SessionBase session, HAPI_NodeId nodeID, HAPI_ParmInfo parmInfo)
{
string textureFileName = "default_texture.png";
HAPI_StringHandle stringValue;
string paramName = HEU_SessionManager.GetString(parmInfo.nameSH, session);
if (session.GetParmStringValue(nodeID, paramName, 0, true, out stringValue))
{
string paramStrValue = HEU_SessionManager.GetString(stringValue, session);
// The returned string needs to be cleaned up:
// eg. opdef:/Sop/testgeometry_pighead?lowres.jpg -> Sop_testgeometry_pighead_lowres.jpg
textureFileName = paramStrValue;
int lastColon = textureFileName.LastIndexOf(':');
if (lastColon > 0 && (lastColon + 1) < textureFileName.Length)
{
textureFileName = textureFileName.Substring(lastColon + 1);
}
// Remove starting / after removing :: above
textureFileName = textureFileName.TrimStart('/');
textureFileName = textureFileName.Replace("?", "_");
textureFileName = textureFileName.Replace("/", "_");
//Debug.LogFormat("Texture File Name: {0}, {1}", paramStrValue, textureFileName);
}
return textureFileName;
}
/// <summary>
/// Process custom attribute with Unity script name, and attach any scripts found.
/// </summary>
/// <param name="session">Session to use</param>
public void ProcessUnityScriptAttribute(HEU_SessionBase session)
{
if (_parts == null || _parts.Count == 0)
{
return;
}
HAPI_AttributeInfo scriptAttributeInfo = new HAPI_AttributeInfo();
int[] scriptAttr = new int[0];
HEU_GeneralUtility.GetAttribute(session, GeoID, 0, HEU_PluginSettings.UnityScriptAttributeName, ref scriptAttributeInfo, ref scriptAttr, session.GetAttributeStringData);
if (scriptAttributeInfo.exists)
{
if (scriptAttributeInfo.owner != HAPI_AttributeOwner.HAPI_ATTROWNER_DETAIL)
{
Debug.LogWarningFormat("Houdini Engine for Unity only supports {0} as detail attributes!", HEU_PluginSettings.UnityScriptAttributeName);
}
else if (scriptAttr.Length > 0)
{
string scriptToAttach = HEU_SessionManager.GetString(scriptAttr[0]);
AttachScriptWithInvokeFunction(scriptToAttach);
}
}
}
public static List<HEU_Handle> FindOrGenerateHandles(HEU_SessionBase session, ref HAPI_AssetInfo assetInfo, HAPI_NodeId assetID, string assetName, HEU_Parameters parameters, List<HEU_Handle> currentHandles)
{
List<HEU_Handle> newHandles = new List<HEU_Handle>();
if (assetInfo.handleCount == 0)
{
return newHandles;
}
HAPI_HandleInfo[] handleInfos = new HAPI_HandleInfo[assetInfo.handleCount];
HEU_GeneralUtility.GetArray1Arg(assetID, session.GetHandleInfo, handleInfos, 0, assetInfo.handleCount);
for (int i = 0; i < handleInfos.Length; ++i)
{
if (handleInfos[i].bindingsCount <= 0)
{
continue;
}
string handleName = HEU_SessionManager.GetString(handleInfos[i].nameSH, session);
HEU_Handle.HEU_HandleType handleType = HEU_Handle.HEU_HandleType.UNSUPPORTED;
string handleTypeString = HEU_SessionManager.GetString(handleInfos[i].typeNameSH, session);
if (handleTypeString.Equals(HEU_Defines.HAPI_HANDLE_TRANSFORM))
{
handleType = HEU_Handle.HEU_HandleType.XFORM;
}
else
{
// Commented out warning as it gets annoying, especially with "Curve" handles
//Debug.LogWarningFormat("Asset {0} has unsupported Handle type {0} for handle {1}", assetName, handleName, handleTypeString);
continue;
}
HEU_Handle newHandle = null;
foreach (HEU_Handle curHandle in currentHandles)
{
if (curHandle.HandleName.Equals(handleName))
{
newHandle = curHandle;
break;
}
}
if (newHandle == null)
{
newHandle = ScriptableObject.CreateInstance<HEU_Handle>();
}
bool bSuccess = newHandle.SetupHandle(session, assetID, i, handleName, handleType, ref handleInfos[i], parameters);
if (bSuccess)
{
newHandles.Add(newHandle);
//Debug.LogFormat("Found handle {0} of type {1}", handleName, handleTypeString);
}
}
return newHandles;
}
public void Initialize(HEU_SessionBase session, HAPI_GeoInfo geoInfo, HEU_ObjectNode containerObjectNode)
{
_containerObjectNode = containerObjectNode;
_geoInfo = geoInfo;
_geoName = HEU_SessionManager.GetString(_geoInfo.nameSH, session);
//Debug.Log(string.Format("GeoNode initialized with ID={0}, name={1}, type={2}", GeoID, GeoName, geoInfo.type));
}
public virtual bool DoAssetLoad()
{
string assetPath = _filePath;
if (!HEU_Platform.DoesFileExist(assetPath))
{
assetPath = HEU_AssetDatabase.GetValidAssetPath(assetPath);
}
HAPI_NodeId libraryID = -1;
HAPI_NodeId newNodeID = -1;
byte[] buffer = null;
bool bResult = HEU_Platform.LoadFileIntoMemory(assetPath, out buffer);
if (bResult)
{
if (!_session.LoadAssetLibraryFromMemory(buffer, true, out libraryID))
{
HEU_Logger.LogErrorFormat("Unable to load asset library.");
return false;
}
//HEU_Logger.Log("Loaded asset");
int assetCount = 0;
bResult = _session.GetAvailableAssetCount(libraryID, out assetCount);
if (!bResult)
{
return false;
}
int[] assetNameLengths = new int[assetCount];
bResult = _session.GetAvailableAssets(libraryID, ref assetNameLengths, assetCount);
if (!bResult)
{
return false;
}
string[] assetNames = new string[assetCount];
for (int i = 0; i < assetCount; ++i)
{
assetNames[i] = HEU_SessionManager.GetString(assetNameLengths[i], _session);
}
// Create top level node. Note that CreateNode will cook the node if HAPI was initialized with threaded cook setting on.
string topNodeName = assetNames[0];
bResult = _session.CreateNode(-1, topNodeName, "", false, out newNodeID);
if (!bResult)
{
return false;
}
//HEU_Logger.Log("Created asset node");
_loadData._cookNodeID = newNodeID;
}
return true;
}
public void UpdateLayerFromPart(HEU_SessionBase session, HEU_PartData part)
{
HEU_GeoNode geoNode = part.ParentGeoNode;
HAPI_VolumeInfo volumeInfo = new HAPI_VolumeInfo();
bool bResult = session.GetVolumeInfo(geoNode.GeoID, part.PartID, ref volumeInfo);
if (!bResult || volumeInfo.tupleSize != 1 || volumeInfo.zLength != 1 || volumeInfo.storage != HAPI_StorageType.HAPI_STORAGETYPE_FLOAT)
{
return;
}
string volumeName = HEU_SessionManager.GetString(volumeInfo.nameSH, session);
part.SetVolumeLayerName(volumeName);
//Debug.LogFormat("Part name: {0}, GeoName: {1}, Volume Name: {2}, Display: {3}", part.PartName, geoNode.GeoName, volumeName, geoNode.Displayable);
bool bHeightPart = volumeName.Equals("height");
HEU_VolumeLayer layer = GetLayer(volumeName);
if (layer == null)
{
layer = new HEU_VolumeLayer();
layer._layerName = volumeName;
if (bHeightPart)
{
_layers.Insert(0, layer);
}
else
{
_layers.Add(layer);
}
}
layer._part = part;
GetPartLayerAttributes(session, geoNode.GeoID, part.PartID, layer);
if (!bHeightPart)
{
part.DestroyAllData();
}
if (!_updatedLayers.Contains(layer))
{
if (bHeightPart)
{
_updatedLayers.Insert(0, layer);
}
else
{
_updatedLayers.Add(layer);
}
}
}
public void SyncFromParameters(HEU_SessionBase session, HEU_HoudiniAsset parentAsset)
{
HAPI_NodeInfo geoNodeInfo = new HAPI_NodeInfo();
if (!session.GetNodeInfo(_geoID, ref geoNodeInfo))
{
return;
}
if (_parameters != null)
{
_parameters.CleanUp();
}
else
{
_parameters = ScriptableObject.CreateInstance<HEU_Parameters>();
}
string geoNodeName = HEU_SessionManager.GetString(geoNodeInfo.nameSH, session);
_parameters._uiLabel = geoNodeName.ToUpper() + " PARAMETERS";
bool bResult = _parameters.Initialize(session, _geoID, ref geoNodeInfo, null, null, parentAsset);
if (!bResult)
{
Debug.LogWarningFormat("Parameter generate failed for geo node {0}.", geoNodeInfo.id);
_parameters.CleanUp();
return;
}
_points.Clear();
string pointList = _parameters.GetStringFromParameter(HEU_Defines.CURVE_COORDS_PARAM);
if (!string.IsNullOrEmpty(pointList))
{
string[] pointSplit = pointList.Split(' ');
foreach (string str in pointSplit)
{
string[] vecSplit = str.Split(',');
if (vecSplit.Length == 3)
{
_points.Add(new Vector3(-System.Convert.ToSingle(vecSplit[0], System.Globalization.CultureInfo.InvariantCulture),
System.Convert.ToSingle(vecSplit[1], System.Globalization.CultureInfo.InvariantCulture),
System.Convert.ToSingle(vecSplit[2], System.Globalization.CultureInfo.InvariantCulture)));
}
}
}
// Since we just reset / created new our parameters and sync'd, we also need to
// get the preset from Houdini session
if (!HEU_EditorUtility.IsEditorPlaying() && IsEditable())
{
DownloadPresetData(session);
}
}
private void SyncWithObjectInfo(HEU_SessionBase session)
{
string realName = HEU_SessionManager.GetString(_objectInfo.nameSH, session);
if (!HEU_PluginSettings.ShortenFolderPaths || realName.Length < 3)
{
_objName = realName;
}
else
{
_objName = realName.Substring(0, 3) + this.GetHashCode();
}
}
public static int GetParameterIndexFromName(HEU_SessionBase session, HAPI_ParmInfo[] parameters, string parameterName)
{
if (parameters != null && parameters.Length > 0)
{
int numParameters = parameters.Length;
for (int i = 0; i < numParameters; ++i)
{
if (HEU_SessionManager.GetString(parameters[i].nameSH, session).Equals(parameterName))
{
return i;
}
}
}
return -1;
}
/// <summary>
/// Returns null if the given image info supports a Unity friendly image format.
/// Otherwise returns a file format that we know Unity supports.
/// </summary>
/// <param name="imageInfo">Image info containing the current image file format</param>
/// <returns></returns>
internal static string GetSupportedFileFormat(HEU_SessionBase session, ref HAPI_ImageInfo imageInfo)
{
string desiredFileFormatName = null;
string imageInfoFileFormat = HEU_SessionManager.GetString(imageInfo.imageFileFormatNameSH, session);
if (!imageInfoFileFormat.Equals(HEU_HAPIConstants.HAPI_PNG_FORMAT_NAME)
&& !imageInfoFileFormat.Equals(HEU_HAPIConstants.HAPI_JPEG_FORMAT_NAME)
&& !imageInfoFileFormat.Equals(HEU_HAPIConstants.HAPI_BMP_FORMAT_NAME)
&& !imageInfoFileFormat.Equals(HEU_HAPIConstants.HAPI_TGA_FORMAT_NAME))
{
desiredFileFormatName = HEU_HAPIConstants.HAPI_PNG_FORMAT_NAME;
}
return desiredFileFormatName;
}
public static bool LoadHDAFile(HEU_SessionBase session, string assetPath, out HAPI_NodeId assetLibraryID, out string[] assetNames)
{
assetLibraryID = HEU_Defines.HEU_INVALID_NODE_ID;
assetNames = new string[0];
// Load the file
string validAssetPath = HEU_PluginStorage.Instance.ConvertEnvKeyedPathToReal(assetPath);
if (validAssetPath != null)
{
assetPath = validAssetPath;
HAPI_AssetLibraryId libraryID = 0;
bool bResult = session.LoadAssetLibraryFromFile(assetPath, false, out libraryID);
if (!bResult)
{
return(false);
}
int assetCount = 0;
bResult = session.GetAvailableAssetCount(libraryID, out assetCount);
if (!bResult)
{
return(false);
}
Debug.AssertFormat(assetCount > 0, "Houdini Engine: Invalid Asset Count of {0}", assetCount);
HAPI_StringHandle[] assetNameLengths = new HAPI_StringHandle[assetCount];
bResult = session.GetAvailableAssets(libraryID, ref assetNameLengths, assetCount);
if (!bResult)
{
return(false);
}
// Sanity check that our array hasn't changed size
Debug.Assert(assetNameLengths.Length == assetCount, "Houdini Engine: Invalid Asset Names");
assetNames = new string[assetCount];
for (int i = 0; i < assetCount; ++i)
{
assetNames[i] = HEU_SessionManager.GetString(assetNameLengths[i]);
}
return(true);
}
return(false);
}
private void UpdateVolumeLayers(HEU_SessionBase session, HEU_HoudiniAsset houdiniAsset, List<HEU_PartData> volumeParts)
{
bool bResult;
foreach (HEU_PartData part in volumeParts)
{
HEU_GeoNode geoNode = part.ParentGeoNode;
HAPI_VolumeInfo volumeInfo = new HAPI_VolumeInfo();
bResult = session.GetVolumeInfo(geoNode.GeoID, part.PartID, ref volumeInfo);
if (!bResult || volumeInfo.tupleSize != 1 || volumeInfo.zLength != 1 || volumeInfo.storage != HAPI_StorageType.HAPI_STORAGETYPE_FLOAT)
{
continue;
}
string volumeName = HEU_SessionManager.GetString(volumeInfo.nameSH, session);
part.SetVolumeLayerName(volumeName);
//Debug.LogFormat("Part name: {0}, GeoName: {1}, Volume Name: {2}, Display: {3}", part.PartName, geoNode.GeoName, volumeName, geoNode.Displayable);
bool bHeightPart = volumeName.Equals("height");
HEU_VolumeLayer layer = GetLayer(volumeName);
if (layer == null)
{
layer = new HEU_VolumeLayer();
layer._layerName = volumeName;
layer._splatTexture = LoadDefaultSplatTexture();
if (bHeightPart)
{
_layers.Insert(0, layer);
}
else
{
_layers.Add(layer);
}
}
layer._part = part;
if (!bHeightPart)
{
part.DestroyAllData();
}
}
}
/// <summary>
/// Returns the Unity script attribute value, if found, on the specified geo's part.
/// The attribute must be of string type, and owned by detail.
/// </summary>
/// <param name="session">Session that the asset resides in</param>
/// <param name="geoID">The geo node's ID</param>
/// <param name="partID">The part's ID</param>
/// <returns>The name of the Unity script, or null if not found</returns>
public static string GetUnityScriptAttributeValue(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_PartId partID)
{
HAPI_AttributeInfo scriptAttributeInfo = new HAPI_AttributeInfo();
int[] scriptAttr = new int[0];
string scriptString = null;
HEU_GeneralUtility.GetAttribute(session, geoID, partID, HEU_PluginSettings.UnityScriptAttributeName, ref scriptAttributeInfo, ref scriptAttr, session.GetAttributeStringData);
if (scriptAttributeInfo.exists)
{
if (scriptAttr.Length > 0)
{
scriptString = HEU_SessionManager.GetString(scriptAttr[0]);
}
}
return scriptString;
}
internal void Initialize(HEU_SessionBase session, HAPI_GeoInfo geoInfo, HEU_ObjectNode containerObjectNode)
{
_containerObjectNode = containerObjectNode;
_geoInfo = geoInfo;
string realName = HEU_SessionManager.GetString(_geoInfo.nameSH, session);
if (!HEU_PluginSettings.ShortenFolderPaths || realName.Length < 3)
{
_geoName = HEU_SessionManager.GetString(_geoInfo.nameSH, session);
}
else
{
_geoName = realName.Substring(0, 3) + this.GetHashCode();
}
//HEU_Logger.Log(string.Format("GeoNode initialized with ID={0}, name={1}, type={2}", GeoID, GeoName, geoInfo.type));
}
public bool GenerateInstancerBuffers(HEU_SessionBase session, HAPI_NodeId nodeID, List<HAPI_PartInfo> instancerParts,
out List<HEU_LoadBufferInstancer> instancerBuffers)
{
instancerBuffers = null;
if (instancerParts.Count == 0)
{
return true;
}
instancerBuffers = new List<HEU_LoadBufferInstancer>();
foreach (HAPI_PartInfo partInfo in instancerParts)
{
HAPI_NodeId geoID = nodeID;
HAPI_PartId partID = partInfo.id;
string partName = HEU_SessionManager.GetString(partInfo.nameSH, session);
HEU_LoadBufferInstancer newBuffer = null;
if (partInfo.instancedPartCount > 0)
{
// Part instancer
newBuffer = GeneratePartsInstancerBuffer(session, geoID, partID, partName, partInfo);
}
else if (partInfo.vertexCount == 0 && partInfo.pointCount > 0)
{
// Point attribute instancer
newBuffer = GeneratePointAttributeInstancerBuffer(session, geoID, partID, partName, partInfo);
}
else
{
SetLog(HEU_LoadData.LoadStatus.ERROR, string.Format("Invalid instanced part count: {0} for part {1}", partInfo.instancedPartCount, partName));
continue;
}
if (newBuffer != null)
{
instancerBuffers.Add(newBuffer);
}
}
return true;
}
/// <summary>
/// Returns the Unity script attribute value, if found, on the specified geo's part.
/// The attribute must be of string type, and owned by detail.
/// </summary>
/// <param name="session">Session that the asset resides in</param>
/// <param name="geoID">The geo node's ID</param>
/// <param name="partID">The part's ID</param>
/// <returns>The name of the Unity script, or null if not found</returns>
public static string GetUnityScriptAttributeValue(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_PartId partID)
{
HAPI_AttributeInfo scriptAttributeInfo = new HAPI_AttributeInfo();
int[] scriptAttr = new int[0];
string scriptString = null;
HEU_GeneralUtility.GetAttribute(session, geoID, partID, HEU_PluginSettings.UnityScriptAttributeName, ref scriptAttributeInfo, ref scriptAttr, session.GetAttributeStringData);
if (scriptAttributeInfo.exists)
{
if (scriptAttributeInfo.owner != HAPI_AttributeOwner.HAPI_ATTROWNER_DETAIL)
{
Debug.LogWarningFormat("Houdini Engine for Unity only supports {0} as detail attributes!", HEU_PluginSettings.UnityScriptAttributeName);
}
else if (scriptAttr.Length > 0)
{
scriptString = HEU_SessionManager.GetString(scriptAttr[0]);
}
}
return scriptString;
}
// GEOMETRY GETTERS -------------------------------------------------------------------------------------------
public static string GetUniqueMaterialShopName(HAPI_NodeId assetID, HAPI_NodeId materialID)
{
HEU_SessionBase sessionBase = GetOrCreateDefaultSession();
if (sessionBase != null)
{
HAPI_AssetInfo assetInfo = new HAPI_AssetInfo();
if (!sessionBase.GetAssetInfo(assetID, ref assetInfo))
{
return "";
}
HAPI_MaterialInfo materialInfo = new HAPI_MaterialInfo();
if (!sessionBase.GetMaterialInfo(materialID, ref materialInfo))
{
return "";
}
HAPI_NodeInfo assetNodeInfo = new HAPI_NodeInfo();
if (!sessionBase.GetNodeInfo(assetID, ref assetNodeInfo))
{
return "";
}
HAPI_NodeInfo materialNodeInfo = new HAPI_NodeInfo();
if (!sessionBase.GetNodeInfo(materialInfo.nodeId, ref materialNodeInfo))
{
return "";
}
string assetNodeName = HEU_SessionManager.GetString(assetNodeInfo.internalNodePathSH, sessionBase);
string materialNodeName = HEU_SessionManager.GetString(materialNodeInfo.internalNodePathSH, sessionBase);
if (assetNodeName.Length > 0 && materialNodeName.Length > 0)
{
// Remove assetNodeName from materialNodeName. Extra position is for separator.
string materialName = materialNodeName.Substring(assetNodeName.Length + 1);
return materialName.Replace("/", "_");
}
}
return "";
}
/// <summary>
/// Assign the Unity tag to the GameObject if found on the part as attribute.
/// </summary>
public static void AssignUnityTag(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_PartId partID, GameObject gameObject)
{
HAPI_AttributeInfo tagAttrInfo = new HAPI_AttributeInfo();
int[] tagAttr = new int[0];
HEU_GeneralUtility.GetAttribute(session, geoID, partID, HEU_PluginSettings.UnityTagAttributeName, ref tagAttrInfo, ref tagAttr, session.GetAttributeStringData);
if (tagAttrInfo.exists)
{
string tag = HEU_SessionManager.GetString(tagAttr[0]);
if (tag.Length > 0)
{
try
{
SetTag(gameObject, tag, true);
}
catch (Exception ex)
{
Debug.LogWarning("Tag exception: " + ex.ToString());
Debug.LogWarningFormat("Unity tag '{0}' does not exist for current project. Add the tag in order to use it!", tag);
}
}
}
}
public static int FindTextureParamByNameOrTag(HEU_SessionBase session, HAPI_NodeId nodeID, HAPI_ParmInfo[] parameters, string parameterName, string useTextureParmName)
{
int outParmId = GetParameterIndexFromNameOrTag(session, nodeID, parameters, parameterName);
if (outParmId < 0)
{
return outParmId;
}
// Check if the matching "use" parameter exists.
int foundUseParmId = GetParameterIndexFromNameOrTag(session, nodeID, parameters, useTextureParmName);
if (foundUseParmId >= 0)
{
// Found a valid "use" parameter. Check if it is disabled.
int[] useValue = new int[1];
int intValuesIndex = parameters[foundUseParmId].intValuesIndex;
if (session.GetParamIntValues(nodeID, useValue, parameters[foundUseParmId].intValuesIndex, 1))
{
if (useValue.Length > 0 && useValue[0] == 0)
{
// We found the texture, but the use tag is disabled, so don't use it!
return -1;
}
}
}
// Finally, make sure that the found texture parm is not empty!
int[] parmValueHandle = new int[1];
if (session.GetParamStringValues(nodeID, parmValueHandle, parameters[outParmId].stringValuesIndex, 1))
{
string parmValue = HEU_SessionManager.GetString(parmValueHandle[0], session);
if (string.IsNullOrEmpty(parmValue))
{
return -1;
}
}
return outParmId;
}
/// <summary>
/// Assign Unity layer to the GameObject if found on the part as attribute.
/// </summary>
/// <param name="session"></param>
/// <param name="geoID"></param>
/// <param name="partID"></param>
/// <param name="gameObject"></param>
public static void AssignUnityLayer(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_PartId partID, GameObject gameObject)
{
HAPI_AttributeInfo layerAttrInfo = new HAPI_AttributeInfo();
int[] layerAttr = new int[0];
HEU_GeneralUtility.GetAttribute(session, geoID, partID, HEU_PluginSettings.UnityLayerAttributeName, ref layerAttrInfo, ref layerAttr, session.GetAttributeStringData);
if (layerAttrInfo.exists)
{
string layerStr = HEU_SessionManager.GetString(layerAttr[0]);
if (layerStr.Length > 0)
{
int layer = LayerMask.NameToLayer(layerStr);
if (layer < 0)
{
Debug.LogWarningFormat("Unity layer '{0}' does not exist for current project. Add the layer in order to use it!", layerStr);
}
else
{
HEU_GeneralUtility.SetLayer(gameObject, layer, true);
}
}
}
}
/// <summary>
/// Helper to parse spare parm containing the filter key words.
/// </summary>
/// <param name="session">Houdini Engine session that the TOP node is in</param>
/// <param name="topNodeID">TOP node to get spare parm from</param>
/// <param name="nodeInfo">Previously queried TOP node info</param>
/// <param name="nodeTags">Tag data to populate</param>
private static void ParseHEngineData(HEU_SessionBase session, HAPI_NodeId topNodeID, ref HAPI_NodeInfo nodeInfo, ref TOPNodeTags nodeTags)
{
// Turn off session logging error when querying string parm that might not be there
bool bLogError = session.LogErrorOverride;
session.LogErrorOverride = false;
int numStrings = nodeInfo.parmStringValueCount;
HAPI_StringHandle henginedatash = 0;
if (numStrings > 0 && session.GetParamStringValue(topNodeID, "henginedata", 0, out henginedatash))
{
string henginedatastr = HEU_SessionManager.GetString(henginedatash, session);
//HEU_Logger.Log("HEngine data: " + henginedatastr);
if (!string.IsNullOrEmpty(henginedatastr))
{
string[] tags = henginedatastr.Split(',');
if (tags != null && tags.Length > 0)
{
foreach (string t in tags)
{
if (t.Equals("show"))
{
nodeTags._showHEngineData = true;
nodeTags._show = true;
}
else if (t.Equals("autoload"))
{
nodeTags._autoloadHEngineData = true;
nodeTags._autoload = true;
}
}
}
}
}
// Logging error back on
session.LogErrorOverride = bLogError;
}
/// <summary>
/// Returns the single string value from Attribute with given name and owner type, or null if failed.
/// </summary>
/// <param name="session">Houdini Engine session to query</param>
/// <param name="geoID">The geometry ID in Houdini</param>
/// <param name="partID">The part ID in Houdini</param>
/// <param name="attrName">Name of the attribute to query</param>
/// <param name="attrOwner">Owner type of the attribute</param>
/// <returns>Valid string if successful, otherwise returns null</returns>
public static string GetAttributeStringValueSingle(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_PartId partID, string attrName, HAPI_AttributeOwner attrOwner)
{
if (string.IsNullOrEmpty(attrName))
{
return null;
}
HAPI_AttributeInfo attrInfo = new HAPI_AttributeInfo();
int[] stringHandle = new int[0];
HEU_GeneralUtility.GetAttribute(session, geoID, partID, attrName, ref attrInfo, ref stringHandle, session.GetAttributeStringData);
if (attrInfo.exists)
{
if (attrInfo.owner != attrOwner)
{
Debug.LogWarningFormat("Expected {0} attribute owner for attribute {1} but got {2}!", attrOwner, attrName, attrInfo.owner);
}
else if (stringHandle.Length > 0)
{
return HEU_SessionManager.GetString(stringHandle[0]);
}
}
return null;
}
private void ParseVolumeDatas(HEU_SessionBase session, List<HEU_PartData> volumeParts)
{
bool bResult;
foreach (HEU_PartData part in volumeParts)
{
HEU_GeoNode geoNode = part.ParentGeoNode;
HAPI_VolumeInfo volumeInfo = new HAPI_VolumeInfo();
bResult = session.GetVolumeInfo(geoNode.GeoID, part.PartID, ref volumeInfo);
if(!bResult || volumeInfo.tupleSize != 1 || volumeInfo.zLength != 1 || volumeInfo.storage != HAPI_StorageType.HAPI_STORAGETYPE_FLOAT)
{
continue;
}
string volumeName = HEU_SessionManager.GetString(volumeInfo.nameSH, session);
//Debug.LogFormat("Part name: {0}, GeoName: {1}, Volume Name: {2}, Display: {3}", part.PartName, geoNode.GeoName, volumeName, geoNode.Displayable);
if(volumeName.Equals("height"))
{
if (_heightMapVolumeData == null)
{
_heightMapVolumeData = new HEU_VolumeData();
_heightMapVolumeData._partData = part;
_heightMapVolumeData._volumeInfo = volumeInfo;
}
}
else
{
HEU_VolumeData volumeData = new HEU_VolumeData();
volumeData._partData = part;
volumeData._volumeInfo = volumeInfo;
_textureVolumeDatas.Add(volumeData);
}
}
}
/// <summary>
/// Process the part at the given index, creating its data (geometry),
/// and adding it to the list of parts.
/// </summary>
/// <param name="session"></param>
/// <param name="partID"></param>
/// <returns>A valid HEU_PartData if it has been successfully processed.</returns>
private void ProcessPart(HEU_SessionBase session, int partID, ref HAPI_PartInfo partInfo, ref HEU_PartData partData)
{
HEU_HoudiniAsset parentAsset = ParentAsset;
bool bResult = true;
//Debug.LogFormat("Part: name={0}, id={1}, type={2}, instanced={3}, instance count={4}, instance part count={5}", HEU_SessionManager.GetString(partInfo.nameSH, session), partID, partInfo.type, partInfo.isInstanced, partInfo.instanceCount, partInfo.instancedPartCount);
#if HEU_PROFILER_ON
float processPartStartTime = Time.realtimeSinceStartup;
#endif
bool isPartEditable = IsIntermediateOrEditable();
bool isAttribInstancer = false;
if (IsGeoInputType())
{
// Setup for input node to accept inputs
if (_inputNode == null)
{
string partName = HEU_SessionManager.GetString(partInfo.nameSH, session);
_inputNode = HEU_InputNode.CreateSetupInput(GeoID, 0, partName, HEU_InputNode.InputNodeType.NODE, ParentAsset);
if (_inputNode != null)
{
ParentAsset.AddInputNode(_inputNode);
}
}
if (HEU_HAPIUtility.IsSupportedPolygonType(partInfo.type) && partInfo.vertexCount == 0)
{
// No geometry for input asset
if (partData != null)
{
// Clean up existing part
HEU_PartData.DestroyPart(partData);
partData = null;
}
// No need to process further since we don't have geometry
return;
}
}
else
{
// Preliminary check for attribute instancing (mesh type with no verts but has points with instances)
if (HEU_HAPIUtility.IsSupportedPolygonType(partInfo.type) && partInfo.vertexCount == 0 && partInfo.pointCount > 0)
{
HAPI_AttributeInfo instanceAttrInfo = new HAPI_AttributeInfo();
HEU_GeneralUtility.GetAttributeInfo(session, GeoID, partID, HEU_PluginSettings.UnityInstanceAttr, ref instanceAttrInfo);
if (instanceAttrInfo.exists && instanceAttrInfo.count > 0)
{
isAttribInstancer = true;
}
}
}
if (partInfo.type == HAPI_PartType.HAPI_PARTTYPE_INVALID)
{
// Clean up invalid parts
if (partData != null)
{
HEU_PartData.DestroyPart(partData);
partData = null;
}
}
else if (partInfo.type < HAPI_PartType.HAPI_PARTTYPE_MAX)
{
// Process the part based on type. Keep or ignore.
// We treat parts of type curve as curves, along with geo nodes that are editable and type curves
if (partInfo.type == HAPI_PartType.HAPI_PARTTYPE_CURVE)
{
if (partData == null)
{
partData = ScriptableObject.CreateInstance <HEU_PartData>();
}
partData.Initialize(session, partID, GeoID, _containerObjectNode.ObjectID, this, ref partInfo,
HEU_PartData.PartOutputType.CURVE, isPartEditable, _containerObjectNode.IsInstancer(), false);
SetupGameObjectAndTransform(partData, parentAsset);
partData.ProcessCurvePart(session);
}
else if (partInfo.type == HAPI_PartType.HAPI_PARTTYPE_VOLUME)
{
// We only process "height" volume parts. Other volume parts are ignored for now.
#if TERRAIN_SUPPORTED
HAPI_VolumeInfo volumeInfo = new HAPI_VolumeInfo();
bResult = session.GetVolumeInfo(GeoID, partID, ref volumeInfo);
if (!bResult)
{
Debug.LogErrorFormat("Unable to get volume info for geo node {0} and part {1} ", GeoID, partID);
}
else
{
if (Displayable && !IsIntermediateOrEditable())
{
if (partData == null)
{
partData = ScriptableObject.CreateInstance <HEU_PartData>();
}
else
{
// Clear volume data (case where switching from polygonal mesh to volume output)
partData.ClearGeneratedMeshOutput();
}
partData.Initialize(session, partID, GeoID, _containerObjectNode.ObjectID, this, ref partInfo,
HEU_PartData.PartOutputType.VOLUME, isPartEditable, _containerObjectNode.IsInstancer(), false);
SetupGameObjectAndTransform(partData, ParentAsset);
}
}
#else
Debug.LogWarningFormat("Terrain (heightfield volume) is not yet supported.");
#endif
}
else if (partInfo.type == HAPI_PartType.HAPI_PARTTYPE_INSTANCER || isAttribInstancer)
{
if (partData == null)
{
partData = ScriptableObject.CreateInstance <HEU_PartData>();
}
else
{
partData.ClearGeneratedMeshOutput();
partData.ClearGeneratedVolumeOutput();
}
partData.Initialize(session, partID, GeoID, _containerObjectNode.ObjectID, this, ref partInfo,
HEU_PartData.PartOutputType.INSTANCER, isPartEditable, _containerObjectNode.IsInstancer(), isAttribInstancer);
SetupGameObjectAndTransform(partData, parentAsset);
}
else if (HEU_HAPIUtility.IsSupportedPolygonType(partInfo.type))
{
if (partData == null)
{
partData = ScriptableObject.CreateInstance <HEU_PartData>();
}
else
{
// Clear volume data (case where switching from something other output to mesh)
partData.ClearGeneratedVolumeOutput();
}
partData.Initialize(session, partID, GeoID, _containerObjectNode.ObjectID, this, ref partInfo,
HEU_PartData.PartOutputType.MESH, isPartEditable, _containerObjectNode.IsInstancer(), false);
// This check allows to ignore editable non-display nodes by default, but commented out to allow
// them for now. Users can also ignore them by turning on IgnoreNonDisplayNodes
//if (Displayable || (Editable && ParentAsset.EditableNodesToolsEnabled))
{
SetupGameObjectAndTransform(partData, parentAsset);
}
}
else
{
Debug.LogWarningFormat("Unsupported part type {0}", partInfo.type);
}
if (partData != null)
{
// Success!
_parts.Add(partData);
// Set unique name for the part
string partName = HEU_PluginSettings.UseFullPathNamesForOutput ? GeneratePartFullName(partData.PartName) : partData.PartName;
partData.SetGameObjectName(partName);
// For intermediate or default-type editable nodes, setup the HEU_AttributeStore
if (isPartEditable)
{
partData.SyncAttributesStore(session, _geoInfo.nodeId, ref partInfo);
}
else
{
// Remove attributes store if it has it
partData.DestroyAttributesStore();
}
}
}
#if HEU_PROFILER_ON
Debug.LogFormat("PART PROCESS TIME:: NAME={0}, TIME={1}", HEU_SessionManager.GetString(partInfo.nameSH, session), (Time.realtimeSinceStartup - processPartStartTime));
#endif
}
public void UpdateGeo(HEU_SessionBase session)
{
// Create or recreate parts.
bool bObjectInstancer = _containerObjectNode.IsInstancer();
// Save list of old parts. We'll destroy these after creating new parts.
// The reason for temporarily keeping these is to transfer data (eg. instance overrides, attribute data)
List <HEU_PartData> oldParts = new List <HEU_PartData>(_parts);
_parts.Clear();
try
{
if (!_geoInfo.isDisplayGeo)
{
if (ParentAsset.IgnoreNonDisplayNodes)
{
return;
}
else if (!_geoInfo.isEditable ||
(_geoInfo.type != HAPI_GeoType.HAPI_GEOTYPE_DEFAULT &&
_geoInfo.type != HAPI_GeoType.HAPI_GEOTYPE_INTERMEDIATE &&
_geoInfo.type != HAPI_GeoType.HAPI_GEOTYPE_CURVE))
{
return;
}
}
if (IsGeoCurveType())
{
ProcessGeoCurve(session);
}
else
{
int numParts = _geoInfo.partCount;
//Debug.Log("Number of parts: " + numParts);
//Debug.LogFormat("GeoNode type {0}, isTemplated: {1}, isDisplayGeo: {2}, isEditable: {3}", _geoInfo.type, _geoInfo.isTemplated, _geoInfo.isDisplayGeo, _geoInfo.isEditable);
for (int i = 0; i < numParts; ++i)
{
HAPI_PartInfo partInfo = new HAPI_PartInfo();
if (!session.GetPartInfo(GeoID, i, ref partInfo))
{
Debug.LogErrorFormat("Unable to get PartInfo for geo node {0} and part {1}.", GeoID, i);
continue;
}
// Find the old part for this new part.
HEU_PartData part = null;
HEU_PartData oldMatchedPart = null;
foreach (HEU_PartData oldPart in oldParts)
{
string partName = HEU_SessionManager.GetString(partInfo.nameSH, session);
if (oldPart.PartName.Equals(partName))
{
oldMatchedPart = oldPart;
}
}
if (oldMatchedPart != null)
{
//Debug.Log("Found matched part: " + oldMatchedPart.name);
List <HEU_ObjectInstanceInfo> sourceObjectInstanceInfos = null;
if (bObjectInstancer)
{
// ProcessPart will clear out the object instances, so hence why
// we keep a copy here, then restore after processing the parts.
sourceObjectInstanceInfos = oldMatchedPart.GetObjectInstanceInfos();
}
// Clear out old generated data
oldMatchedPart.ClearGeneratedData();
part = oldMatchedPart;
oldParts.Remove(oldMatchedPart);
ProcessPart(session, i, ref partInfo, ref part);
if (part != null && bObjectInstancer && sourceObjectInstanceInfos != null)
{
// Set object instances from old part into new. This keeps the user set object inputs around.
part.SetObjectInstanceInfos(sourceObjectInstanceInfos);
}
}
else
{
ProcessPart(session, i, ref partInfo, ref part);
}
}
}
}
finally
{
HEU_PartData.DestroyParts(oldParts);
}
}
private void PopulateAttributeData(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_PartId partID, HEU_AttributeData attributeData, ref HAPI_AttributeInfo attributeInfo)
{
attributeData._attributeInfo = attributeInfo;
int tupleSize = attributeInfo.tupleSize;
int attributeCount = attributeInfo.count;
int arraySize = attributeCount * tupleSize;
// First reset arrays if the type had changed since last sync
if ((attributeInfo.storage == HAPI_StorageType.HAPI_STORAGETYPE_INT && attributeData._attributeType != HEU_AttributeData.AttributeType.INT) ||
(attributeInfo.storage == HAPI_StorageType.HAPI_STORAGETYPE_FLOAT && attributeData._attributeType != HEU_AttributeData.AttributeType.FLOAT) ||
(attributeInfo.storage == HAPI_StorageType.HAPI_STORAGETYPE_STRING && attributeData._attributeType != HEU_AttributeData.AttributeType.STRING))
{
// Reset arrays if type is different
attributeData._floatValues = null;
attributeData._stringValues = null;
attributeData._intValues = null;
attributeData._attributeState = HEU_AttributeData.AttributeState.INVALID;
if(attributeInfo.storage == HAPI_StorageType.HAPI_STORAGETYPE_INT)
{
attributeData._attributeType = HEU_AttributeData.AttributeType.INT;
}
else if (attributeInfo.storage == HAPI_StorageType.HAPI_STORAGETYPE_FLOAT)
{
attributeData._attributeType = HEU_AttributeData.AttributeType.FLOAT;
}
else if (attributeInfo.storage == HAPI_StorageType.HAPI_STORAGETYPE_STRING)
{
attributeData._attributeType = HEU_AttributeData.AttributeType.STRING;
}
}
// Make sure the internal array is correctly sized for syncing.
if (attributeData._attributeType == HEU_AttributeData.AttributeType.INT)
{
if (attributeData._intValues == null)
{
attributeData._intValues = new int[arraySize];
attributeData._attributeState = HEU_AttributeData.AttributeState.INVALID;
}
else if (attributeData._intValues.Length != arraySize)
{
System.Array.Resize<int>(ref attributeData._intValues, arraySize);
attributeData._attributeState = HEU_AttributeData.AttributeState.INVALID;
}
attributeData._floatValues = null;
attributeData._stringValues = null;
if (attributeData._attributeState == HEU_AttributeData.AttributeState.INVALID)
{
int[] data = new int[0];
HEU_GeneralUtility.GetAttribute(session, geoID, partID, attributeData._name, ref attributeInfo, ref data, session.GetAttributeIntData);
for (int i = 0; i < attributeCount; ++i)
{
for (int tuple = 0; tuple < tupleSize; ++tuple)
{
attributeData._intValues[i * tupleSize + tuple] = data[i * tupleSize + tuple];
}
}
}
}
else if (attributeData._attributeType == HEU_AttributeData.AttributeType.FLOAT)
{
if (attributeData._floatValues == null)
{
attributeData._floatValues = new float[arraySize];
attributeData._attributeState = HEU_AttributeData.AttributeState.INVALID;
}
else if (attributeData._floatValues.Length != arraySize)
{
System.Array.Resize<float>(ref attributeData._floatValues, arraySize);
attributeData._attributeState = HEU_AttributeData.AttributeState.INVALID;
}
attributeData._intValues = null;
attributeData._stringValues = null;
if (attributeData._attributeState == HEU_AttributeData.AttributeState.INVALID)
{
float[] data = new float[0];
HEU_GeneralUtility.GetAttribute(session, geoID, partID, attributeData._name, ref attributeInfo, ref data, session.GetAttributeFloatData);
for (int i = 0; i < attributeCount; ++i)
{
for (int tuple = 0; tuple < tupleSize; ++tuple)
{
attributeData._floatValues[i * tupleSize + tuple] = data[i * tupleSize + tuple];
}
}
}
}
else if (attributeData._attributeType == HEU_AttributeData.AttributeType.STRING)
{
if (attributeData._stringValues == null)
{
attributeData._stringValues = new string[arraySize];
attributeData._attributeState = HEU_AttributeData.AttributeState.INVALID;
}
else if (attributeData._stringValues.Length != arraySize)
{
System.Array.Resize<string>(ref attributeData._stringValues, arraySize);
attributeData._attributeState = HEU_AttributeData.AttributeState.INVALID;
}
attributeData._intValues = null;
attributeData._floatValues = null;
if (attributeData._attributeState == HEU_AttributeData.AttributeState.INVALID)
{
HAPI_StringHandle[] data = new HAPI_StringHandle[0];
HEU_GeneralUtility.GetAttribute(session, geoID, partID, attributeData._name, ref attributeInfo, ref data, session.GetAttributeStringData);
for (int i = 0; i < attributeCount; ++i)
{
for (int tuple = 0; tuple < tupleSize; ++tuple)
{
HAPI_StringHandle stringHandle = data[i * tupleSize + tuple];
attributeData._stringValues[i * tupleSize + tuple] = HEU_SessionManager.GetString(stringHandle, session);
}
}
}
}
SetAttributeDataSyncd(attributeData);
}
public void SyncAllAttributesFrom(HEU_SessionBase session, HEU_HoudiniAsset asset, HAPI_NodeId geoID, ref HAPI_PartInfo partInfo, GameObject outputGameObject)
{
_geoID = geoID;
_partID = partInfo.id;
HAPI_GeoInfo geoInfo = new HAPI_GeoInfo();
if(session.GetGeoInfo(_geoID, ref geoInfo))
{
_geoName = HEU_SessionManager.GetString(geoInfo.nameSH, session);
}
if (outputGameObject != null)
{
_outputTransform = outputGameObject.transform;
}
// Need the vertex list of indices to map the positions to vertex colors
_vertexIndices = new int[partInfo.vertexCount];
if (!HEU_GeneralUtility.GetArray2Arg(geoID, partInfo.id, session.GetVertexList, _vertexIndices, 0, partInfo.vertexCount))
{
return;
}
// Note that this currently only supports point attributes
int attributePointCount = partInfo.attributeCounts[(int)HAPI_AttributeOwner.HAPI_ATTROWNER_POINT];
string[] pointAttributeNames = new string[attributePointCount];
if(!session.GetAttributeNames(geoID, partInfo.id, HAPI_AttributeOwner.HAPI_ATTROWNER_POINT, ref pointAttributeNames, attributePointCount))
{
Debug.LogErrorFormat("Failed to sync attributes. Unable to retrieve attribute names.");
return;
}
// Create new list of attributes. We'll move existing attributes that are still in use as we find them.
List<HEU_AttributeData> newAttributeDatas = new List<HEU_AttributeData>();
foreach (string pointAttributeName in pointAttributeNames)
{
if(string.IsNullOrEmpty(pointAttributeName))
{
continue;
}
// Get position attribute values separately. Used for painting and editing points in 3D scene.
HAPI_AttributeInfo pointAttributeInfo = new HAPI_AttributeInfo();
if(session.GetAttributeInfo(geoID, partInfo.id, pointAttributeName, HAPI_AttributeOwner.HAPI_ATTROWNER_POINT, ref pointAttributeInfo))
{
if (pointAttributeName.Equals(HEU_Defines.HAPI_ATTRIB_POSITION))
{
if (pointAttributeInfo.storage != HAPI_StorageType.HAPI_STORAGETYPE_FLOAT)
{
Debug.LogErrorFormat("Expected float type for position attribute, but got {0}", pointAttributeInfo.storage);
return;
}
_positionAttributeValues = new Vector3[pointAttributeInfo.count];
float[] data = new float[0];
HEU_GeneralUtility.GetAttribute(session, geoID, partInfo.id, pointAttributeName, ref pointAttributeInfo, ref data, session.GetAttributeFloatData);
for (int i = 0; i < pointAttributeInfo.count; ++i)
{
_positionAttributeValues[i] = new Vector3(-data[i * pointAttributeInfo.tupleSize + 0], data[i * pointAttributeInfo.tupleSize + 1], data[i * pointAttributeInfo.tupleSize + 2]);
}
// We don't let position attributes be editted (for now anyway)
continue;
}
HEU_AttributeData attrData = GetAttributeData(pointAttributeName);
if (attrData == null)
{
// Attribute data not found. Create it.
attrData = CreateAttribute(pointAttributeName, ref pointAttributeInfo);
//Debug.LogFormat("Created attribute data: {0}", pointAttributeName);
}
// Add to new list.
newAttributeDatas.Add(attrData);
// Sync the attribute info to data.
PopulateAttributeData(session, geoID, partInfo.id, attrData, ref pointAttributeInfo);
if(pointAttributeName.Equals(HEU_Defines.HAPI_ATTRIB_COLOR) || pointAttributeInfo.typeInfo == HAPI_AttributeTypeInfo.HAPI_ATTRIBUTE_TYPE_COLOR)
{
_hasColorAttribute = true;
}
}
else
{
// Failed to get point attribute info!
}
}
// Overwriting the old list with the new should automatically remove unused attribute datas.
_attributeDatas = newAttributeDatas;
}
// LOGIC -----------------------------------------------------------------------------------------------------
public bool SetupHandle(HEU_SessionBase session, HAPI_NodeId assetID, int handleIndex, string handleName,
HEU_HandleType handleType, ref HAPI_HandleInfo handleInfo, HEU_Parameters parameters)
{
_handleIndex = handleIndex;
_handleName = handleName;
_handleType = handleType;
HAPI_HandleBindingInfo[] handleBindingInfos = new HAPI_HandleBindingInfo[handleInfo.bindingsCount];
if (!session.GetHandleBindingInfo(assetID, _handleIndex, handleBindingInfos, 0, handleInfo.bindingsCount))
{
return false;
}
HAPI_ParmId translateParmID = -1;
HAPI_ParmId rotateParmID = -1;
HAPI_ParmId scaleParmID = -1;
HAPI_ParmId rstOrderParmID = -1;
HAPI_ParmId xyzOrderParmID = -1;
_rstOrder = HAPI_RSTOrder.HAPI_SRT;
_xyzOrder = HAPI_XYZOrder.HAPI_XYZ;
_handleParamTranslateBinding = null;
_handleParamRotateBinding = null;
_handleParamScaleBinding = null;
for (int i = 0; i < handleBindingInfos.Length; ++i)
{
string parmName = HEU_SessionManager.GetString(handleBindingInfos[i].handleParmNameSH, session);
//string assetParmName = HEU_SessionManager.GetString(handleBindingInfos[i].assetParmNameSH, session);
//Debug.LogFormat("Handle {0} has parm {1} with asset parm {2} with asset parm id {3}", handleName, parmName, assetParmName, handleBindingInfos[i].assetParmId);
if (parmName.Equals("tx") || parmName.Equals("ty") || parmName.Equals("tz"))
{
translateParmID = handleBindingInfos[i].assetParmId;
if(_handleParamTranslateBinding == null)
{
HEU_ParameterData parmData = parameters.GetParameterWithParmID(translateParmID);
if (parmData != null && !parmData._parmInfo.invisible)
{
_handleParamTranslateBinding = new HEU_HandleParamBinding();
_handleParamTranslateBinding._paramType = HEU_HandleParamBinding.HEU_HandleParamType.TRANSLATE;
_handleParamTranslateBinding._parmID = parmData.ParmID;
_handleParamTranslateBinding._paramName = parmData._name;
_handleParamTranslateBinding._bDisabled = parmData._parmInfo.disabled;
}
}
if(_handleParamTranslateBinding != null)
{
if(parmName.Equals("tx"))
{
_handleParamTranslateBinding._boundChannels[0] = true;
}
else if (parmName.Equals("ty"))
{
_handleParamTranslateBinding._boundChannels[1] = true;
}
else if (parmName.Equals("tz"))
{
_handleParamTranslateBinding._boundChannels[2] = true;
}
}
}
if (parmName.Equals("rx") || parmName.Equals("ry") || parmName.Equals("rz"))
{
rotateParmID = handleBindingInfos[i].assetParmId;
if(_handleParamRotateBinding == null)
{
HEU_ParameterData parmData = parameters.GetParameterWithParmID(rotateParmID);
if (parmData != null && !parmData._parmInfo.invisible)
{
_handleParamRotateBinding = new HEU_HandleParamBinding();
_handleParamRotateBinding._paramType = HEU_HandleParamBinding.HEU_HandleParamType.ROTATE;
_handleParamRotateBinding._parmID = parmData.ParmID;
_handleParamRotateBinding._paramName = parmData._name;
_handleParamRotateBinding._bDisabled = parmData._parmInfo.disabled;
}
}
if (_handleParamRotateBinding != null)
{
if (parmName.Equals("rx"))
{
_handleParamRotateBinding._boundChannels[0] = true;
}
else if (parmName.Equals("ry"))
{
_handleParamRotateBinding._boundChannels[1] = true;
}
else if (parmName.Equals("rz"))
{
_handleParamRotateBinding._boundChannels[2] = true;
}
}
}
if (parmName.Equals("sx") || parmName.Equals("sy") || parmName.Equals("sz"))
{
scaleParmID = handleBindingInfos[i].assetParmId;
if (_handleParamScaleBinding == null)
{
HEU_ParameterData parmData = parameters.GetParameterWithParmID(scaleParmID);
if (parmData != null && !parmData._parmInfo.invisible)
{
_handleParamScaleBinding = new HEU_HandleParamBinding();
_handleParamScaleBinding._paramType = HEU_HandleParamBinding.HEU_HandleParamType.SCALE;
_handleParamScaleBinding._parmID = parmData.ParmID;
_handleParamScaleBinding._paramName = parmData._name;
_handleParamScaleBinding._bDisabled = parmData._parmInfo.disabled;
}
}
if (_handleParamScaleBinding != null)
{
if (parmName.Equals("sx"))
{
_handleParamScaleBinding._boundChannels[0] = true;
}
else if (parmName.Equals("sy"))
{
_handleParamScaleBinding._boundChannels[1] = true;
}
else if (parmName.Equals("sz"))
{
_handleParamScaleBinding._boundChannels[2] = true;
}
}
}
if(parmName.Equals("trs_order"))
{
rstOrderParmID = handleBindingInfos[i].assetParmId;
}
if (parmName.Equals("xyz_order"))
{
xyzOrderParmID = handleBindingInfos[i].assetParmId;
}
}
if (rstOrderParmID >= 0)
{
HEU_ParameterData parmData = parameters.GetParameter(rstOrderParmID);
if (parmData != null)
{
_rstOrder = (HAPI_RSTOrder)parmData._intValues[0];
}
}
if (xyzOrderParmID >= 0)
{
HEU_ParameterData parmData = parameters.GetParameter(xyzOrderParmID);
if (parmData != null)
{
_xyzOrder = (HAPI_XYZOrder)parmData._intValues[0];
}
}
GenerateTransform(session, parameters);
return true;
}
/// <summary>
/// Load the geometry generated as results of the given work item, of the given TOP node.
/// The load will be done asynchronously.
/// Results must be tagged with 'file', and must have a file path, otherwise will not be loaded.
/// </summary>
/// <param name="session">Houdini Engine session that the TOP node is in</param>
/// <param name="topNode">TOP node that the work item belongs to</param>
/// <param name="workItemInfo">Work item whose results to load</param>
/// <param name="resultInfos">Results data</param>
/// <param name="workItemID">The work item's ID. Required for clearning its results.</param>
public void LoadResults(HEU_SessionBase session, HEU_TOPNodeData topNode, HAPI_PDG_WorkitemInfo workItemInfo, HAPI_PDG_WorkitemResultInfo[] resultInfos, HAPI_PDG_WorkitemId workItemID)
{
// Create HEU_GeoSync objects, set results, and sync it
string workItemName = HEU_SessionManager.GetString(workItemInfo.nameSH, session);
//Debug.LogFormat("Work item: {0}:: name={1}, results={2}", workItemInfo.index, workItemName, workItemInfo.numResults);
// Clear previously generated result
ClearWorkItemResultByID(topNode, workItemID);
if (resultInfos == null || resultInfos.Length == 0)
{
return;
}
HEU_TOPWorkResult result = GetWorkResultByID(topNode, workItemID);
if (result == null)
{
result = new HEU_TOPWorkResult();
result._workItemIndex = workItemInfo.index;
result._workItemID = workItemID;
topNode._workResults.Add(result);
}
// Load each result geometry
int numResults = resultInfos.Length;
for (int i = 0; i < numResults; ++i)
{
if (resultInfos[i].resultTagSH <= 0 || resultInfos[i].resultSH <= 0)
{
continue;
}
string tag = HEU_SessionManager.GetString(resultInfos[i].resultTagSH, session);
string path = HEU_SessionManager.GetString(resultInfos[i].resultSH, session);
//Debug.LogFormat("Result for work item {0}: result={1}, tag={2}, path={3}", result._workItemIndex, i, tag, path);
if (string.IsNullOrEmpty(tag) || !tag.StartsWith("file"))
{
continue;
}
string name = string.Format("{0}_{1}_{2}",
topNode._parentName,
workItemName,
workItemInfo.index);
// Get or create parent GO
if (topNode._workResultParentGO == null)
{
topNode._workResultParentGO = new GameObject(topNode._nodeName);
HEU_GeneralUtility.SetParentWithCleanTransform(GetLoadRootTransform(), topNode._workResultParentGO.transform);
topNode._workResultParentGO.SetActive(topNode._showResults);
}
GameObject newOrExistingGO = null;
int existingObjectIndex = -1;
for (int j = 0; j < result._generatedGOs.Count; j++)
{
if (result._generatedGOs[j] != null)
{
HEU_GeoSync oldGeoSync = result._generatedGOs[j].GetComponent<HEU_GeoSync>();
if (oldGeoSync != null && oldGeoSync._filePath == path)
{
oldGeoSync.Reset();
existingObjectIndex = j;
newOrExistingGO = result._generatedGOs[j];
break;
}
}
}
if (existingObjectIndex < 0)
{
newOrExistingGO = new GameObject(name);
result._generatedGOs.Add(newOrExistingGO);
}
HEU_GeneralUtility.SetParentWithCleanTransform(topNode._workResultParentGO.transform, newOrExistingGO.transform);
// HEU_GeoSync does the loading
HEU_GeoSync geoSync = newOrExistingGO.GetComponent<HEU_GeoSync>();
if (geoSync == null)
{
geoSync = newOrExistingGO.AddComponent<HEU_GeoSync>();
}
geoSync._filePath = path;
geoSync.SetOutputCacheDirectory(_outputCachePathRoot);
geoSync.StartSync();
}
}
/// <summary>
/// Given TOP nodes from a TOP network, populate internal state from each TOP node.
/// </summary>
/// <param name="session">Houdini Engine session</param>
/// <param name="topNetwork">TOP network to query TOP nodes from</param>
/// <param name="topNodeIDs">List of TOP nodes in the TOP network</param>
/// <param name="useHEngineData">Whether or not to use HEngine data for filtering</param>
/// <returns>True if successfully populated data</returns>
public static bool PopulateTOPNodes(HEU_SessionBase session, HEU_TOPNetworkData topNetwork, HAPI_NodeId[] topNodeIDs, bool useHEngineData)
{
// Holds list of found TOP nodes
List<HEU_TOPNodeData> newNodes = new List<HEU_TOPNodeData>();
foreach (HAPI_NodeId topNodeID in topNodeIDs)
{
// Not necessary. Blocks main thread.
//session.CookNode(childNodeID, HEU_PluginSettings.CookTemplatedGeos);
HAPI_NodeInfo childNodeInfo = new HAPI_NodeInfo();
if (!session.GetNodeInfo(topNodeID, ref childNodeInfo))
{
return false;
}
string nodeName = HEU_SessionManager.GetString(childNodeInfo.nameSH, session);
//Debug.LogFormat("TOP Node: name={0}, type={1}", nodeName, childNodeInfo.type);
TOPNodeTags tags = new TOPNodeTags();
if (useHEngineData)
{
ParseHEngineData(session, topNodeID, ref childNodeInfo, ref tags);
if (!tags._show)
{
continue;
}
}
else
{
tags._show = true;
}
HEU_TOPNodeData topNodeData = GetTOPNodeByName(nodeName, topNetwork._topNodes);
if (topNodeData == null)
{
topNodeData = new HEU_TOPNodeData();
}
else
{
topNetwork._topNodes.Remove(topNodeData);
}
newNodes.Add(topNodeData);
//topNodeData.Reset();
topNodeData._nodeID = topNodeID;
topNodeData._nodeName = nodeName;
topNodeData._parentName = topNetwork._parentName + "_" + topNetwork._nodeName;
topNodeData._tags = tags;
}
// Clear old unused TOP nodes
for (int i = 0; i < topNetwork._topNodes.Count; ++i)
{
ClearTOPNodeWorkItemResults(topNetwork._topNodes[i]);
}
topNetwork._topNodes = newNodes;
// Get list of updated TOP node names
topNetwork._topNodeNames = new string[topNetwork._topNodes.Count];
for (int i = 0; i < topNetwork._topNodes.Count; ++i)
{
topNetwork._topNodeNames[i] = topNetwork._topNodes[i]._nodeName;
}
return true;
}