/// <summary>
/// Destroy all data.
/// </summary>
public void DestroyAllData()
{
if(_geoNodes != null)
{
for(int i = 0; i < _geoNodes.Count; ++i)
{
_geoNodes[i].DestroyAllData();
HEU_GeneralUtility.DestroyImmediate(_geoNodes[i]);
}
_geoNodes.Clear();
}
}
private bool LoadLayerFloatFromAttribute(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_NodeId partID, string attrName, ref float floatValue)
{
HAPI_AttributeInfo attrInfo = new HAPI_AttributeInfo();
float[] attrValues = new float[0];
HEU_GeneralUtility.GetAttribute(session, geoID, partID, attrName, ref attrInfo, ref attrValues, session.GetAttributeFloatData);
if (attrValues != null && attrValues.Length > 0)
{
floatValue = attrValues[0];
return true;
}
return false;
}
private bool LoadLayerTextureFromAttribute(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_NodeId partID, string attrName, out Texture2D outTexture)
{
outTexture = null;
// The texture path is stored as string primitive attribute. Only 1 string path per layer.
HAPI_AttributeInfo attrInfo = new HAPI_AttributeInfo();
string[] texturePath = HEU_GeneralUtility.GetAttributeStringData(session, geoID, partID, attrName, ref attrInfo);
if (texturePath != null && texturePath.Length > 0 && !string.IsNullOrEmpty(texturePath[0]))
{
outTexture = LoadAssetTexture(texturePath[0]);
}
return outTexture != null;
}
public static void DestroyGeneratedOutputData(HEU_GeneratedOutputData generatedOutputData, bool bDontDeletePersistantResources)
{
ClearGeneratedMaterialReferences(generatedOutputData);
// Colliders
HEU_GeneratedOutput.DestroyAllGeneratedColliders(generatedOutputData);
// Components
HEU_GeneralUtility.DestroyGeneratedMeshMaterialsLODGroups(generatedOutputData._gameObject, bDontDeletePersistantResources);
// Gameobject
HEU_GeneralUtility.DestroyImmediate(generatedOutputData._gameObject);
}
private void SetupUIElements()
{
if (_helpGridBoxStyle == null)
{
_helpGridBoxStyle = new GUIStyle(GUI.skin.box);
Color bgColor = HEU_EditorUI.IsEditorDarkSkin() ? new Color(0.8f, 0.8f, 0.8f, 0.2f) : new Color(0.6f, 0.6f, 0.6f, 0.6f);
_helpGridBoxStyle.normal.background = HEU_GeneralUtility.MakeTexture(1, 1, bgColor);
_helpGridBoxStyle.normal.textColor = HEU_EditorUI.IsEditorDarkSkin() ? Color.white : Color.black;
_helpGridBoxStyle.fontStyle = FontStyle.Normal;
_helpGridBoxStyle.fontSize = 11;
_helpGridBoxStyle.alignment = TextAnchor.MiddleLeft;
}
}
public static string GetTerrainDataExportPathFromHeightfieldAttribute(HEU_SessionBase session, HAPI_NodeId geoID,
HAPI_PartId partID)
{
HAPI_AttributeInfo attrInfo = new HAPI_AttributeInfo();
string[] attrValue = HEU_GeneralUtility.GetAttributeStringData(session, geoID, partID,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TERRAINDATA_EXPORT_PATH,
ref attrInfo);
if (attrInfo.exists && attrValue.Length > 0 && string.IsNullOrEmpty(attrValue[0]))
{
return attrValue[0];
}
return "";
}
/// <summary>
/// Set attribute-based modifiers such as tag, layer, and scripts on
/// the part outputs.
/// </summary>
/// <param name="session"></param>
internal void SetAttributeModifiersOnPartOutputs(HEU_SessionBase session)
{
int numParts = _parts.Count;
for (int i = 0; i < numParts; ++i)
{
if (_parts[i].OutputGameObject != null)
{
HEU_GeneralUtility.AssignUnityTag(session, GeoID, _parts[i].PartID, _parts[i].OutputGameObject);
HEU_GeneralUtility.AssignUnityLayer(session, GeoID, _parts[i].PartID, _parts[i].OutputGameObject);
HEU_GeneralUtility.MakeStaticIfHasAttribute(session, GeoID, _parts[i].PartID, _parts[i].OutputGameObject);
}
}
}
public static void DestroyBakedGameObjectsWithEndName(List<GameObject> gameObjectsToDestroy, string endName)
{
int numLeft = gameObjectsToDestroy.Count;
for (int i = 0; i < numLeft; ++i)
{
GameObject deleteGO = gameObjectsToDestroy[i];
if (string.IsNullOrEmpty(endName) || deleteGO.name.EndsWith(endName))
{
gameObjectsToDestroy[i] = null;
HEU_PartData.DestroyExistingGeneratedComponentsMeshData(deleteGO, true);
HEU_GeneralUtility.DestroyImmediate(deleteGO);
}
}
}
public static void ClearTOPNodeWorkItemResults(HEU_TOPNodeData topNode)
{
int numResults = topNode._workResults.Count;
for (int i = 0; i < numResults; ++i)
{
DestroyWorkItemResultData(topNode, topNode._workResults[i]);
}
topNode._workResults.Clear();
if (topNode._workResultParentGO != null)
{
HEU_GeneralUtility.DestroyImmediate(topNode._workResultParentGO);
}
}
private void LoadLayerVector2FromAttribute(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_NodeId partID, string attrName, ref Vector2 vectorValue)
{
HAPI_AttributeInfo attrInfo = new HAPI_AttributeInfo();
float[] attrValues = new float[0];
HEU_GeneralUtility.GetAttribute(session, geoID, partID, attrName, ref attrInfo, ref attrValues, session.GetAttributeFloatData);
if (attrValues != null && attrValues.Length == 2)
{
if (attrInfo.tupleSize == 2)
{
vectorValue[0] = attrValues[0];
vectorValue[1] = attrValues[1];
}
}
}
public static void DestroyGeneratedOutputChildren(HEU_GeneratedOutput generatedOutput)
{
// LOD Group component
HEU_GeneralUtility.DestroyComponent<LODGroup>(generatedOutput._outputData._gameObject);
int numChildren = generatedOutput._childOutputs != null ? generatedOutput._childOutputs.Count : 0;
for (int i = 0; i < numChildren; ++i)
{
if (generatedOutput._childOutputs[i] != null && generatedOutput._childOutputs[i]._gameObject != null)
{
DestroyGeneratedOutputData(generatedOutput._childOutputs[i], true);
}
}
generatedOutput._childOutputs.Clear();
}
/// <summary>
/// Given relative path to an asset (with Assets/ in the path), this returns the full path to it.
/// </summary>
/// <param name="inAssetRelativePath">Relative path to parse</param>
/// <returns>Returns full path to asset, or null if invalid input path</returns>
public static string GetAssetFullPath(string inAssetRelativePath)
{
string replaceOld = GetAssetRelativePathStart();
string replaceNew = Application.dataPath + HEU_Platform.DirectorySeparatorStr;
//Debug.LogFormat("Replacing relative {0} with full {1}", inAssetRelativePath, inAssetRelativePath.Replace(replaceOld, replaceNew));
if (IsPathRelativeToAssets(inAssetRelativePath))
{
return HEU_GeneralUtility.ReplaceFirstOccurrence(inAssetRelativePath, replaceOld, replaceNew);
}
else
{
Debug.LogWarningFormat("Given relative path {0} does not start with {1}. Unable to create full path!", inAssetRelativePath, replaceOld);
return null;
}
}
private bool FindAddToInputHDA(string gameObjectName)
{
HEU_HoudiniAssetRoot inputAssetRoot = HEU_GeneralUtility.GetHDAByGameObjectNameInScene(gameObjectName);
if (inputAssetRoot != null && inputAssetRoot._houdiniAsset != null)
{
// Adding to list will take care of reconnecting
InternalAddInputHDAAtEnd(inputAssetRoot.gameObject);
return true;
}
else
{
Debug.LogWarningFormat("HDA with gameobject name {0} not found. Unable to set input asset.", gameObjectName);
}
return false;
}
public static void DestroyGeneratedOutput(HEU_GeneratedOutput generatedOutput)
{
int numChildren = generatedOutput._childOutputs != null ? generatedOutput._childOutputs.Count : 0;
for (int i = 0; i < numChildren; ++i)
{
if (generatedOutput._childOutputs[i] != null && generatedOutput._childOutputs[i]._gameObject != null)
{
HEU_GeneralUtility.DestroyImmediate(generatedOutput._childOutputs[i]._gameObject);
}
}
generatedOutput._childOutputs.Clear();
HEU_GeneralUtility.DestroyImmediate(generatedOutput._outputData._gameObject);
generatedOutput._outputData._gameObject = null;
generatedOutput._outputData._renderMaterials = null;
}
/// <summary>
/// Retrieve and set the detail properties from the specified heightfield.
/// This includes detail distance, density, and resolution per patch.
/// </summary>
/// <param name="session">Current Houdini Engine session</param>
/// <param name="geoID">Heightfield object</param>
/// <param name="partID">Heightfield layer</param>
/// <param name="detailProperties">Reference to a HEU_DetailProperties which will
/// be populated.</param>
public static void PopulateDetailProperties(HEU_SessionBase session, HAPI_NodeId geoID,
HAPI_PartId partID, ref HEU_DetailProperties detailProperties)
{
// Detail distance
HAPI_AttributeInfo detailDistanceAttrInfo = new HAPI_AttributeInfo();
int[] detailDistances = new int[0];
HEU_GeneralUtility.GetAttribute(session, geoID, partID,
HEU_Defines.HEIGHTFIELD_DETAIL_DISTANCE, ref detailDistanceAttrInfo, ref detailDistances,
session.GetAttributeIntData);
// Detail density
HAPI_AttributeInfo detailDensityAttrInfo = new HAPI_AttributeInfo();
float[] detailDensity = new float[0];
HEU_GeneralUtility.GetAttribute(session, geoID, partID,
HEU_Defines.HEIGHTFIELD_DETAIL_DENSITY, ref detailDensityAttrInfo, ref detailDensity,
session.GetAttributeFloatData);
// Scatter Detail Resolution Per Patch (note that Detail Resolution comes from HF layer size)
HAPI_AttributeInfo resolutionPatchAttrInfo = new HAPI_AttributeInfo();
int[] resolutionPatches = new int[0];
HEU_GeneralUtility.GetAttribute(session, geoID, partID,
HEU_Defines.HEIGHTFIELD_DETAIL_RESOLUTION_PER_PATCH, ref resolutionPatchAttrInfo,
ref resolutionPatches, session.GetAttributeIntData);
if (detailProperties == null)
{
detailProperties = new HEU_DetailProperties();
}
// Unity only supports 1 set of detail resolution properties per terrain
int arraySize = 1;
if (detailDistanceAttrInfo.exists && detailDistances.Length >= arraySize)
{
detailProperties._detailDistance = detailDistances[0];
}
if (detailDensityAttrInfo.exists && detailDensity.Length >= arraySize)
{
detailProperties._detailDensity = detailDensity[0];
}
if (resolutionPatchAttrInfo.exists && resolutionPatches.Length >= arraySize)
{
detailProperties._detailResolutionPerPatch = resolutionPatches[0];
}
}
/// <summary>
/// Returns HEU_UploadMeshData with mesh data found on meshGameObject.
/// </summary>
/// <param name="meshGameObject">The GameObject to query mesh data from</param>
/// <returns>A valid HEU_UploadMeshData if mesh data found or null</returns>
public static HEU_InputDataMesh CreateSingleMeshData(GameObject meshGameObject)
{
HEU_InputDataMesh meshData = new HEU_InputDataMesh();
if (meshGameObject == null)
{
return null;
}
Mesh sharedMesh = GetMeshFromObject(meshGameObject);
if (sharedMesh == null)
{
return null;
}
meshData._mesh = sharedMesh;
meshData._numVertices = meshData._mesh.vertexCount;
meshData._numSubMeshes = meshData._mesh.subMeshCount;
meshData._meshName = meshGameObject.name;
// Use project path is not saved in scene, otherwise just use name
if (HEU_GeneralUtility.IsGameObjectInProject(meshGameObject))
{
meshData._meshPath = HEU_AssetDatabase.GetAssetOrScenePath(meshGameObject);
if (string.IsNullOrEmpty(meshData._meshPath))
{
meshData._meshPath = meshGameObject.name;
}
}
else
{
meshData._meshPath = meshGameObject.name;
}
//Debug.Log("Mesh Path: " + meshData._meshPath);
MeshRenderer meshRenderer = meshGameObject.GetComponent<MeshRenderer>();
if (meshRenderer != null)
{
meshData._materials = meshRenderer.sharedMaterials;
}
meshData._transform = meshGameObject.transform;
return meshData;
}
/// <summary>
/// Returns list of HEU_TreePrototypeInfo formed by querying data from given part.
/// </summary>
/// <param name="session">Houdini Engine session</param>
/// <param name="geoID">Geometry object</param>
/// <param name="partID">Part ID</param>
/// <returns>Returns list of HEU_TreePrototypeInfo or null if none found.</returns>
public static List<HEU_TreePrototypeInfo> GetTreePrototypeInfosFromPart(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_PartId partID)
{
List<HEU_TreePrototypeInfo> treePrototypes = new List<HEU_TreePrototypeInfo>();
// Each TreePrototype data is stored as a string attribute, under the 'HEU_Defines.HEIGHTFIELD_TREEPROTOTYPE + index'
// name. So check and parse until no more valid attributes found.
int index = 0;
while (true)
{
// Does this attribute exist?
string attrName = HEU_Defines.HEIGHTFIELD_TREEPROTOTYPE + index.ToString();
if (!HEU_GeneralUtility.HasAttribute(session, geoID, partID, attrName, HAPI_AttributeOwner.HAPI_ATTROWNER_PRIM))
{
break;
}
index++;
// Get the string value
HAPI_AttributeInfo treeAttrInfo = new HAPI_AttributeInfo();
string[] protoAttrString = HEU_GeneralUtility.GetAttributeStringData(session, geoID, partID,
attrName, ref treeAttrInfo);
if (protoAttrString == null || protoAttrString.Length == 0 || string.IsNullOrEmpty(protoAttrString[0]))
{
break;
}
// Parse the attribute string value:
// Only expecting a single element here, comma-separated for the asset path and bend factor:
// => asset_path,bend_factor
string[] properties = protoAttrString[0].Split(',');
if (properties.Length > 0 && !string.IsNullOrEmpty(properties[0]))
{
HEU_TreePrototypeInfo prototype = new HEU_TreePrototypeInfo();
prototype._prefabPath = properties[0];
if (properties.Length >= 2)
{
float.TryParse(properties[1], out prototype._bendfactor);
}
treePrototypes.Add(prototype);
}
}
return treePrototypes.Count > 0 ? treePrototypes : null;
}
public void SetupUI()
{
_backgroundStyle = new GUIStyle(GUI.skin.box);
RectOffset br = _backgroundStyle.margin;
br.top = 10;
br.bottom = 6;
br.left = 4;
br.right = 4;
_backgroundStyle.margin = br;
_eventMessageStyle = new GUIStyle(EditorStyles.textArea);
_eventMessageStyle.richText = true;
_eventMessageStyle.normal.textColor = new Color(1f, 1f, 1f, 1f);
_eventMessageStyle.normal.background = HEU_GeneralUtility.MakeTexture(1, 1, new Color(0, 0, 0, 1f));
}
/// <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;
}
//Set string detail attribute
public static bool SetMeshDetailAttribute(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_PartId partID, string attrName,
string data, ref HAPI_PartInfo partInfo)
{
HAPI_AttributeInfo attrInfo = new HAPI_AttributeInfo();
attrInfo.exists = true;
attrInfo.owner = HAPI_AttributeOwner.HAPI_ATTROWNER_DETAIL;
attrInfo.storage = HAPI_StorageType.HAPI_STORAGETYPE_STRING;
attrInfo.count = 1;
attrInfo.tupleSize = 1;
attrInfo.originalOwner = HAPI_AttributeOwner.HAPI_ATTROWNER_INVALID;
string[] values = new string[1];
values[0] = data;
return(HEU_GeneralUtility.SetAttributeArray(geoID, partID, attrName, ref attrInfo, values, session.SetAttributeStringData, 1));
}
//Set string point attributes
public static bool SetMeshPointAttribute(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_PartId partID, string attrName, string[] data, ref HAPI_PartInfo partInfo)
{
HAPI_AttributeInfo attrInfo = new HAPI_AttributeInfo();
attrInfo.exists = true;
attrInfo.owner = HAPI_AttributeOwner.HAPI_ATTROWNER_POINT;
attrInfo.storage = HAPI_StorageType.HAPI_STORAGETYPE_STRING;
attrInfo.count = partInfo.pointCount;
attrInfo.tupleSize = 1;
attrInfo.originalOwner = HAPI_AttributeOwner.HAPI_ATTROWNER_INVALID;
if (!session.AddAttribute(geoID, 0, attrName, ref attrInfo))
{
Debug.Log("Could not create attribute named: " + attrName);
return false;
}
return HEU_GeneralUtility.SetAttributeArray(geoID, partID, attrName, ref attrInfo, data, session.SetAttributeStringData, partInfo.pointCount);
}
public void DisablePaintCollider()
{
if (_localMeshCollider != null && _outputGameObject != null)
{
HEU_GeneralUtility.DestroyComponent<MeshCollider>(_outputGameObject);
_localMeshCollider = null;
}
if (_outputCollider != null)
{
_outputCollider.sharedMesh = _outputColliderMesh;
_outputCollider.enabled = _outputMeshColliderInitiallyEnabled;
_outputCollider = null;
_outputColliderMesh = null;
}
}
public void DestroyVolumeCache()
{
if (_volumeCaches != null)
{
int numCaches = _volumeCaches.Count;
for (int i = 0; i < numCaches; ++i)
{
if (_volumeCaches[i] != null)
{
ParentAsset.RemoveVolumeCache(_volumeCaches[i]);
HEU_GeneralUtility.DestroyImmediate(_volumeCaches[i]);
_volumeCaches[i] = null;
}
}
_volumeCaches = null;
}
}
private void SetOutputVisiblity(HEU_LoadBufferBase buffer)
{
bool bVisibility = !buffer._bInstanced;
if (HEU_GeneratedOutput.HasLODGroup(buffer._generatedOutput))
{
foreach (HEU_GeneratedOutputData childOutput in buffer._generatedOutput._childOutputs)
{
HEU_GeneralUtility.SetGameObjectRenderVisiblity(childOutput._gameObject, bVisibility);
HEU_GeneralUtility.SetGameObjectColliderState(childOutput._gameObject, bVisibility);
}
}
else
{
HEU_GeneralUtility.SetGameObjectRenderVisiblity(buffer._generatedOutput._outputData._gameObject, bVisibility);
HEU_GeneralUtility.SetGameObjectColliderState(buffer._generatedOutput._outputData._gameObject, bVisibility);
}
}
private void GetPartLayerAttributes(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_NodeId partID, HEU_VolumeLayer layer)
{
// Get the tile index, if it exists, for this part
HAPI_AttributeInfo tileAttrInfo = new HAPI_AttributeInfo();
int[] tileAttrData = new int[0];
HEU_GeneralUtility.GetAttribute(session, geoID, partID, HEU_Defines.HAPI_HEIGHTFIELD_TILE_ATTR, ref tileAttrInfo, ref tileAttrData, session.GetAttributeIntData);
if (tileAttrData != null && tileAttrData.Length > 0)
{
layer._tile = tileAttrData[0];
//Debug.LogFormat("Tile: {0}", tileAttrData[0]);
}
else
{
layer._tile = 0;
}
layer._hasLayerAttributes = HEU_TerrainUtility.VolumeLayerHasAttributes(session, geoID, partID);
}
private void GetPartLayerAttributes(HEU_SessionBase session, HAPI_NodeId geoID, HAPI_NodeId partID, HEU_VolumeLayer layer)
{
// Get the tile index, if it exists, for this part
HAPI_AttributeInfo tileAttrInfo = new HAPI_AttributeInfo();
int[] tileAttrData = new int[0];
HEU_GeneralUtility.GetAttribute(session, geoID, partID, HEU_Defines.HAPI_HEIGHTFIELD_TILE_ATTR, ref tileAttrInfo, ref tileAttrData, session.GetAttributeIntData);
if (tileAttrData != null && tileAttrData.Length > 0)
{
layer._tile = tileAttrData[0];
//Debug.LogFormat("Tile: {0}", tileAttrData[0]);
}
else
{
layer._tile = 0;
}
string[] layerAttrNames =
{
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TEXTURE_DIFFUSE_ATTR,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TEXTURE_MASK_ATTR,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TEXTURE_NORMAL_ATTR,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_NORMAL_SCALE_ATTR,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_METALLIC_ATTR,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_SMOOTHNESS_ATTR,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_SPECULAR_ATTR,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TILE_OFFSET_ATTR,
HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TILE_SIZE_ATTR
};
// Check if any of the layer attribute names show up in the existing primitive attributes
layer._hasLayerAttributes = false;
HAPI_AttributeInfo attrInfo = new HAPI_AttributeInfo();
bool bResult = false;
foreach (string layerAttr in layerAttrNames)
{
bResult = session.GetAttributeInfo(geoID, partID, layerAttr, HAPI_AttributeOwner.HAPI_ATTROWNER_PRIM, ref attrInfo);
if (bResult && attrInfo.exists)
{
layer._hasLayerAttributes = true;
break;
}
}
}
/// <summary>
/// Load and instantiate an HDA asset in Unity and Houdini, for the asset located at given path.
/// </summary>
/// <param name="filePath">Full path to the HDA in Unity project</param>
/// <param name="initialPosition">Initial location to create the instance in Unity.</param>
/// <returns>Returns the newly created gameobject for the asset in the scene, or null if creation failed.</returns>
public static GameObject InstantiateHDA(string filePath, Vector3 initialPosition, HEU_SessionBase session, bool bBuildAsync)
{
if (filePath == null || !HEU_Platform.DoesFileExist(filePath))
{
return(null);
}
// This will be the root GameObject for the HDA. Adding HEU_HoudiniAssetRoot
// allows to use a custom Inspector.
GameObject rootGO = new GameObject(HEU_Defines.HEU_DEFAULT_ASSET_NAME);
HEU_HoudiniAssetRoot assetRoot = rootGO.AddComponent <HEU_HoudiniAssetRoot>();
// Under the root, we'll add the HEU_HoudiniAsset onto another GameObject
// This will be marked as EditorOnly to strip out for builds
GameObject hdaGEO = new GameObject(HEU_PluginSettings.HDAData_Name);
hdaGEO.transform.parent = rootGO.transform;
// This holds all Houdini Engine data
HEU_HoudiniAsset asset = hdaGEO.AddComponent <HEU_HoudiniAsset>();
// Marking as EditorOnly to be excluded from builds
if (HEU_GeneralUtility.DoesUnityTagExist(HEU_PluginSettings.EditorOnly_Tag))
{
hdaGEO.tag = HEU_PluginSettings.EditorOnly_Tag;
}
// Bind the root to the asset
assetRoot._houdiniAsset = asset;
// Populate asset with what we know
asset.SetupAsset(HEU_HoudiniAsset.HEU_AssetType.TYPE_HDA, filePath, rootGO, session);
// Build it in Houdini Engine
asset.RequestReload(bBuildAsync);
// Apply Unity transform and possibly upload to Houdini Engine
rootGO.transform.position = initialPosition;
Debug.LogFormat("{0}: Created new HDA asset from {1} of type {2}.", HEU_Defines.HEU_NAME, filePath, asset.AssetType);
return(rootGO);
}
private void SetupGeoCurveGameObjectAndTransform(HEU_Curve curve)
{
if (curve._targetGameObject == null)
{
curve._targetGameObject = new GameObject();
}
// For geo curve, the parent is the HDA_Data
Transform curveTransform = curve._targetGameObject.transform;
curveTransform.parent = ParentAsset.OwnerGameObject.transform;
HEU_GeneralUtility.CopyFlags(curveTransform.parent.gameObject, curve._targetGameObject, true);
// Reset to origin
curveTransform.localPosition = Vector3.zero;
curveTransform.localRotation = Quaternion.identity;
curveTransform.localScale = Vector3.one;
}
public void PopulateInputPreset(HEU_InputPreset inputPreset)
{
inputPreset._inputObjectType = _inputObjectType;
inputPreset._inputAssetName = _inputAsset != null ? _inputAsset.name : "";
inputPreset._inputIndex = _inputIndex;
inputPreset._inputName = _inputName;
inputPreset._keepWorldTransform = _keepWorldTransform;
inputPreset._packGeometryBeforeMerging = _packGeometryBeforeMerging;
foreach (HEU_InputObjectInfo inputObject in _inputObjects)
{
HEU_InputObjectPreset inputObjectPreset = new HEU_InputObjectPreset();
if (inputObject._gameObject != null)
{
inputObjectPreset._gameObjectName = inputObject._gameObject.name;
// Tag whether scene or project input object
inputObjectPreset._isSceneObject = !HEU_GeneralUtility.IsGameObjectInProject(inputObject._gameObject);
if (!inputObjectPreset._isSceneObject)
{
// For inputs in project, use the project path as name
inputObjectPreset._gameObjectName = HEU_AssetDatabase.GetAssetOrScenePath(inputObject._gameObject);
}
}
else
{
inputObjectPreset._gameObjectName = "";
}
inputObjectPreset._useTransformOffset = inputObject._useTransformOffset;
inputObjectPreset._translateOffset = inputObject._translateOffset;
inputObjectPreset._rotateOffset = inputObject._rotateOffset;
inputObjectPreset._scaleOffset = inputObject._scaleOffset;
inputPreset._inputObjectPresets.Add(inputObjectPreset);
}
}
/// <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;
}
foreach (HEU_PartData part in _parts)
{
GameObject outputGO = part.OutputGameObject;
if (outputGO != null)
{
string scriptValue = HEU_GeneralUtility.GetUnityScriptAttributeValue(session, GeoID, part.PartID);
if (!string.IsNullOrEmpty(scriptValue))
{
HEU_GeneralUtility.AttachScriptWithInvokeFunction(scriptValue, outputGO);
}
}
}
}