public bool IsEquivalentTo(HEU_AttributeData other)
{
bool bResult = true;
string header = "HEU_AttributeData";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return false;
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._attributeInfo.ToTestObject(), other._attributeInfo.ToTestObject(), ref bResult, header, "_attributeInfo");
HEU_TestHelpers.AssertTrueLogEquivalent(this._name, other._name, ref bResult, header, "_name");
HEU_TestHelpers.AssertTrueLogEquivalent(this._attributeType, other._attributeType, ref bResult, header, "_attributeType");
HEU_TestHelpers.AssertTrueLogEquivalent(this._intValues, other._intValues, ref bResult, header, "_intValues");
HEU_TestHelpers.AssertTrueLogEquivalent(this._floatValues, other._floatValues, ref bResult, header, "_floatValues");
HEU_TestHelpers.AssertTrueLogEquivalent(this._stringValues, other._stringValues, ref bResult, header, "_stringValues");
HEU_TestHelpers.AssertTrueLogEquivalent(this._attributeState, other._attributeState, ref bResult, header, "_attributeState");
return bResult;
}
public bool IsEquivalentTo(HEU_Handle other)
{
bool bResult = true;
string header = "HEU_Handle";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return false;
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._handleName, other._handleName, ref bResult, header, "_handleName");
HEU_TestHelpers.AssertTrueLogEquivalent(this._handleType,other._handleType, ref bResult, header, "_handleType");
HEU_TestHelpers.AssertTrueLogEquivalent(this._handleIndex, other._handleIndex, ref bResult, header, "_handleIndex");
HEU_TestHelpers.AssertTrueLogEquivalent(this._handleParamTranslateBinding, other._handleParamTranslateBinding, ref bResult, header, "_handleParamTranslateBinding");
HEU_TestHelpers.AssertTrueLogEquivalent(this._handleParamRotateBinding, other._handleParamRotateBinding, ref bResult, header, "_handleParamRotateBinding");
HEU_TestHelpers.AssertTrueLogEquivalent(this._handleParamScaleBinding, other._handleParamScaleBinding, ref bResult, header, "_handleParamScaleBinding");
HEU_TestHelpers.AssertTrueLogEquivalent(this._handlePosition, other._handlePosition, ref bResult, header, "_handlePosition");
HEU_TestHelpers.AssertTrueLogEquivalent(this._handleRotation, other._handleRotation, ref bResult, header, "_handleRotation");
HEU_TestHelpers.AssertTrueLogEquivalent(this._handleScale, other._handleScale, ref bResult, header, "_handleScale");
HEU_TestHelpers.AssertTrueLogEquivalent(this._rstOrder, other._rstOrder, ref bResult, header, "_rstOrder");
HEU_TestHelpers.AssertTrueLogEquivalent(this._xyzOrder, other._xyzOrder, ref bResult, header, "_xyzOrder");
HEU_TestHelpers.AssertTrueLogEquivalent(this._convertedTransformEuler.ToTestObject(), other._convertedTransformEuler.ToTestObject(), ref bResult, header, "_convertedTransformEuler");
// Skip _materialKey
return bResult;
}
public void OnGUI()
{
using (new GUILayout.VerticalScope())
{
_shelfName = EditorGUILayout.TextField("New Shelf Name", _shelfName);
using (new EditorGUI.DisabledScope(string.IsNullOrEmpty(_shelfName) || _shelfName.Trim().Length == 0))
{
if (GUILayout.Button("Create"))
{
//HEU_Logger.Log("Shelf name: " + _shelfName);
HEU_Shelf newShelf = HEU_ShelfTools.AddShelf(_shelfName, _shelfPath);
if (newShelf != null)
{
HEU_ShelfTools.SaveShelf();
HEU_ShelfTools.SetReloadShelves();
this.Close();
}
else
{
HEU_Logger.LogError("Invalid Shelf! Please check if the name or path is valid.");
}
}
}
if (GUILayout.Button("Cancel"))
{
this.Close();
}
}
}
public bool IsEquivalentTo(HEU_GeoNode other)
{
bool bResult = true;
string header = "HEU_GeoNode";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return(false);
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._geoInfo.ToTestObject(), other._geoInfo.ToTestObject(), ref bResult, header, "_geoInfo");
//HEU_TestHelpers.AssertTrueLogEquivalent(this._geoName, other._geoName, ref bResult, header, "_geoName");
HEU_TestHelpers.AssertTrueLogEquivalent(this._parts, other._parts, ref bResult, header, "_part");
// SKip _containerObjectNode/parentAsset stuff
HEU_TestHelpers.AssertTrueLogEquivalent(this._geoCurve, other._geoCurve, ref bResult, header, "_geoCurve");
// Skip volumCache
HEU_TestHelpers.AssertTrueLogEquivalent(this._volumeCaches, other._volumeCaches, ref bResult, header, "_volumeCaches");
return(bResult);
}
public bool IsEquivalentTo(HEU_AttributesStore other)
{
bool bResult = true;
string header = "HEU_AttributesStore";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return false;
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._geoName, other._geoName, ref bResult, header, "_geoName");
HEU_TestHelpers.AssertTrueLogEquivalent(this._attributeDatas, other._attributeDatas, ref bResult, header, "_attributeDatas");
HEU_TestHelpers.AssertTrueLogEquivalent(this._hasColorAttribute, other._hasColorAttribute, ref bResult, header, "_hasColorAttribute");
HEU_TestHelpers.AssertTrueLogEquivalent(this._localMaterial.ToTestObject(), other._localMaterial.ToTestObject(), ref bResult, header, "_localMaterial");
HEU_TestHelpers.AssertTrueLogEquivalent(this._outputTransform.ToTestObject(), other._outputTransform.ToTestObject(), ref bResult, header, "_outputTransform");
HEU_TestHelpers.AssertTrueLogEquivalent(this._positionAttributeValues, other._positionAttributeValues, ref bResult, header, "_positionAttributeValues");
HEU_TestHelpers.AssertTrueLogEquivalent(this._vertexIndices, other._vertexIndices, ref bResult, header, "_vertexIndices");
HEU_TestHelpers.AssertTrueLogEquivalent(this._outputGameObject, other._outputGameObject, ref bResult, header, "_outputGameObject");
HEU_TestHelpers.AssertTrueLogEquivalent(this._outputMesh.ToTestObject(), other._outputMesh.ToTestObject(), ref bResult, header, "_outputMesh");
HEU_TestHelpers.AssertTrueLogEquivalent(this._outputMaterials.ToTestObject(), other._outputMaterials.ToTestObject(), ref bResult, header, "_outputMaterials");
HEU_TestHelpers.AssertTrueLogEquivalent(this._outputCollider.ToTestObject(), other._outputCollider.ToTestObject(), ref bResult, header, "_outputColliders");
HEU_TestHelpers.AssertTrueLogEquivalent(this._outputColliderMesh.ToTestObject(), other._outputColliderMesh.ToTestObject(), ref bResult, header, "_outputColliderMesh");
return bResult;
}
public void SyncDirtyAttributesToHoudini(HEU_SessionBase session)
{
if (!UploadAttributeViaMeshInput(session, _geoID, _partID))
{
HEU_Logger.LogError("Unable to upload custom attribute edits!");
}
}
public static HEU_SessionBase CreateSessionFromType(System.Type type)
{
#if !UNITY_5_6_OR_NEWER
HEU_Logger.LogError("Houdini Engine for Unity only supports Unity version 5.6.0 and newer!");
#elif HOUDINIENGINEUNITY_ENABLED
if (type == null || type == typeof(HEU_SessionHAPI))
{
// By default, we use HAPI if Houdini Engine is enabled
return new HEU_SessionHAPI();
}
else if (_createSessionFromTypeDelegate != null)
{
// For custom HEU_SessionBase classes
System.Delegate[] delegates = _createSessionFromTypeDelegate.GetInvocationList();
foreach (System.Delegate del in delegates)
{
CreateSessionFromTypeDelegate createDelegate = del as CreateSessionFromTypeDelegate;
HEU_SessionBase newSession = createDelegate.Invoke(type);
if (newSession != null)
{
return newSession;
}
}
}
#endif
// Fallback to empty session
return new HEU_SessionBase();
}
/// <summary>
/// Writes out the TerrainLayer file path as a string attribute (primitive-owned) for the specified heightfield volume.
/// </summary>
/// <param name="session">Current Houdini session</param>
/// <param name="geoNodeID">Geometry object ID</param>
/// <param name="partID">Part ID (volume)</param>
/// <param name="terrainLayer">The TerrainLayer's file path is set as attribute</param>
/// <returns>True if successfully added the attribute.</returns>
public bool SetTerrainLayerAttributesToHeightField(HEU_SessionBase session, HAPI_NodeId geoNodeID, HAPI_PartId partID, TerrainLayer terrainLayer)
{
string assetPath = HEU_AssetDatabase.GetAssetPath(terrainLayer);
if (string.IsNullOrEmpty(assetPath))
{
return(false);
}
HAPI_AttributeInfo attrInfo = new HAPI_AttributeInfo();
attrInfo.exists = true;
attrInfo.owner = HAPI_AttributeOwner.HAPI_ATTROWNER_PRIM;
attrInfo.storage = HAPI_StorageType.HAPI_STORAGETYPE_STRING;
attrInfo.count = 1;
attrInfo.tupleSize = 1;
attrInfo.originalOwner = HAPI_AttributeOwner.HAPI_ATTROWNER_INVALID;
if (!session.AddAttribute(geoNodeID, partID, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TERRAINLAYER_FILE_ATTR, ref attrInfo))
{
HEU_Logger.LogError("Failed to add TerrainLayer file attribute to input heightfield.");
return(false);
}
string[] pathData = new string[] { assetPath };
if (!session.SetAttributeStringData(geoNodeID, partID, HEU_Defines.DEFAULT_UNITY_HEIGHTFIELD_TERRAINLAYER_FILE_ATTR, ref attrInfo, pathData, 0, 1))
{
HEU_Logger.LogError("Failed to set TerrainLayer file name to input heightfield");
return(false);
}
return(true);
}
public static void CreatePDGAssetLink()
{
GameObject selectedGO = Selection.activeGameObject;
if (selectedGO != null)
{
HEU_HoudiniAssetRoot assetRoot = selectedGO.GetComponent<HEU_HoudiniAssetRoot>();
if (assetRoot != null)
{
if (assetRoot._houdiniAsset != null)
{
string name = string.Format("{0}_PDGLink", assetRoot._houdiniAsset.AssetName);
GameObject go = HEU_GeneralUtility.CreateNewGameObject(name);
HEU_PDGAssetLink assetLink = go.AddComponent<HEU_PDGAssetLink>();
assetLink.Setup(assetRoot._houdiniAsset);
Selection.activeGameObject = go;
}
else
{
HEU_Logger.LogError("Selected gameobject is not an instantiated HDA. Failed to create PDG Asset Link.");
}
}
else
{
HEU_Logger.LogError("Selected gameobject is not an instantiated HDA. Failed to create PDG Asset Link.");
}
}
else
{
//HEU_Logger.LogError("Nothing selected. Select an instantiated HDA first.");
HEU_EditorUtility.DisplayErrorDialog("PDG Asset Link", "No HDA selected. You must select an instantiated HDA first.", "OK");
}
}
/// <summary>
/// Create the main heightfield network for input.
/// </summary>
/// <param name="session"></param>
/// <param name="idt"></param>
/// <returns>True if successfully created the network</returns>
public bool CreateHeightFieldInputNode(HEU_SessionBase session, HEU_InputDataTerrain idt)
{
idt._heightfieldNodeID = HEU_Defines.HEU_INVALID_NODE_ID;
idt._heightNodeID = HEU_Defines.HEU_INVALID_NODE_ID;
idt._maskNodeID = HEU_Defines.HEU_INVALID_NODE_ID;
idt._mergeNodeID = HEU_Defines.HEU_INVALID_NODE_ID;
idt._parentNodeID = HEU_Defines.HEU_INVALID_NODE_ID; // Heightfields should have its own objects.
// Create the HeightField node network
bool bResult = session.CreateHeightFieldInput(idt._parentNodeID, idt._heightFieldName, idt._numPointsX, idt._numPointsY, idt._voxelSize,
HAPI_HeightFieldSampling.HAPI_HEIGHTFIELD_SAMPLING_CORNER,
out idt._heightfieldNodeID, out idt._heightNodeID, out idt._maskNodeID, out idt._mergeNodeID);
if (!bResult ||
idt._heightfieldNodeID == HEU_Defines.HEU_INVALID_NODE_ID ||
idt._heightNodeID == HEU_Defines.HEU_INVALID_NODE_ID ||
idt._maskNodeID == HEU_Defines.HEU_INVALID_NODE_ID ||
idt._mergeNodeID == HEU_Defines.HEU_INVALID_NODE_ID)
{
HEU_Logger.LogError("Failed to create new heightfield node in Houdini session!");
return(false);
}
if (!session.CookNode(idt._heightNodeID, false))
{
HEU_Logger.LogError("New input node failed to cook!");
return(false);
}
return(true);
}
public static bool GetParameterColor3Value(HEU_SessionBase session, HAPI_NodeId nodeID, HAPI_ParmInfo[] parameters, string parameterName, Color defaultValue, out Color outputColor)
{
int parameterIndex = GetParameterIndexFromNameOrTag(session, nodeID, parameters, parameterName);
if (parameterIndex < 0 || parameterIndex >= parameters.Length)
{
outputColor = defaultValue;
return false;
}
if (parameters[parameterIndex].size < 3)
{
HEU_Logger.LogError("Parameter size not large enough to be a Color3");
outputColor = defaultValue;
return false;
}
int valueIndex = parameters[parameterIndex].floatValuesIndex;
float[] value = new float[3];
if (session.GetParamFloatValues(nodeID, value, valueIndex, 3))
{
outputColor = new Color(value[0], value[1], value[2], 1f);
return true;
}
outputColor = defaultValue;
return false;
}
private void SetErrorState(string msg, bool bLogIt)
{
// Log first error
if (!_errored && bLogIt)
{
HEU_Logger.LogError(msg);
}
_errored = true;
_errorMsg = msg;
}
/// <summary>
/// Set the given TerrainData's TreePrototyes as attributes on the given part.
/// The TreePrototypes as stored a string attributes where the name is HEU_Defines.HEIGHTFIELD_TREEPROTOTYPE + index.
/// The string value is the tree prefab's file path comme-separated with the bend factor:
/// e.g: Assets/Trees/redtree.prefab,0.9
/// This does nothing if the given TerrainData doesn't have TreePrototype.
/// </summary>
/// <param name="session">Houdini Engine session</param>
/// <param name="geoNodeID">Geometry object ID</param>
/// <param name="partID">Part ID</param>
/// <param name="terrainData">The TerrainData containing TreePrototypes.</param>
public void SetTreePrototypes(HEU_SessionBase session, HAPI_NodeId geoNodeID, HAPI_PartId partID, TerrainData terrainData)
{
TreePrototype[] treePrototypes = terrainData.treePrototypes;
if (treePrototypes == null || treePrototypes.Length == 0)
{
return;
}
// For each prototype, fill up a string attribute owned by primitive.
// The string format is: tree_prefab_path,bend_factor
string prefabPath;
float bendFactor;
for (int i = 0; i < treePrototypes.Length; ++i)
{
if (treePrototypes[i] == null)
{
continue;
}
prefabPath = HEU_AssetDatabase.GetAssetPath(treePrototypes[i].prefab);
if (prefabPath == null)
{
continue;
}
bendFactor = treePrototypes[i].bendFactor;
HAPI_AttributeInfo attrInfo = new HAPI_AttributeInfo();
attrInfo.exists = true;
attrInfo.owner = HAPI_AttributeOwner.HAPI_ATTROWNER_PRIM;
attrInfo.storage = HAPI_StorageType.HAPI_STORAGETYPE_STRING;
attrInfo.count = 1;
attrInfo.tupleSize = 1;
attrInfo.originalOwner = HAPI_AttributeOwner.HAPI_ATTROWNER_INVALID;
string attrName = HEU_Defines.HEIGHTFIELD_TREEPROTOTYPE + i.ToString();
if (!session.AddAttribute(geoNodeID, partID, attrName, ref attrInfo))
{
HEU_Logger.LogError("Failed to add TreePrototype string attribute to input heightfield.");
return;
}
string[] pathData = new string[] { string.Format("{0},{1}", prefabPath, bendFactor) };
if (!session.SetAttributeStringData(geoNodeID, partID, attrName, ref attrInfo, pathData, 0, 1))
{
HEU_Logger.LogError("Failed to set TreePrototype string value to input heightfield.");
return;
}
}
}
/// <summary>
/// Helper to set heightfield data for a specific volume node.
/// Used for a specific terrain layer.
/// </summary>
/// <param name="session">Session that the volume node resides in.</param>
/// <param name="volumeNodeID">ID of the target volume node</param>
/// <param name="partID">Part ID</param>
/// <param name="heightValues">Array of height or alpha values</param>
/// <param name="heightFieldName">Name of the layer</param>
/// <returns>True if successfully uploaded heightfield values</returns>
public bool SetHeightFieldData(HEU_SessionBase session, HAPI_NodeId volumeNodeID, HAPI_PartId partID, float[] heightValues, string heightFieldName, ref HAPI_VolumeInfo baseVolumeInfo)
{
// Cook the node to get infos below
if (!session.CookNode(volumeNodeID, false))
{
return(false);
}
// Get Geo, Part, and Volume infos
HAPI_GeoInfo geoInfo = new HAPI_GeoInfo();
if (!session.GetGeoInfo(volumeNodeID, ref geoInfo))
{
return(false);
}
HAPI_PartInfo partInfo = new HAPI_PartInfo();
if (!session.GetPartInfo(geoInfo.nodeId, partID, ref partInfo))
{
return(false);
}
HAPI_VolumeInfo volumeInfo = new HAPI_VolumeInfo();
if (!session.GetVolumeInfo(volumeNodeID, partInfo.id, ref volumeInfo))
{
return(false);
}
volumeInfo.tileSize = 1;
// Use same transform as base layer
volumeInfo.transform = baseVolumeInfo.transform;
if (!session.SetVolumeInfo(volumeNodeID, partInfo.id, ref volumeInfo))
{
HEU_Logger.LogError("Unable to set volume info on input heightfield node!");
return(false);
}
// Now set the height data
if (!session.SetHeightFieldData(geoInfo.nodeId, partInfo.id, heightFieldName, heightValues, 0, heightValues.Length))
{
HEU_Logger.LogErrorFormat("Unable to set `{0}` height values on input heightfield node!\n" +
"Check your terrain sizes including Control Texture Resolution is less than the Heightmap Resolution.",
heightFieldName);
return(false);
}
return(true);
}
public bool IsEquivalentTo(HEU_ParameterData other)
{
bool bResult = true;
string header = "HEU_ParameterData";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return false;
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._name, other._name, ref bResult, header, "_name");
HEU_TestHelpers.AssertTrueLogEquivalent(this._labelName, other._labelName, ref bResult, header, "_labelName");
HEU_TestHelpers.AssertTrueLogEquivalent(this._help, other._help, ref bResult, header, "_help");
// Skip child parameter Ids values, but not count
HEU_TestHelpers.AssertTrueLogEquivalent(this._childParameterIDs.Count, other._childParameterIDs.Count, ref bResult, header, "_childParameterIds");
HEU_TestHelpers.AssertTrueLogEquivalent(this._intValues, other._intValues, ref bResult, header, "_intValues");
HEU_TestHelpers.AssertTrueLogEquivalent(this._floatValues, other._floatValues, ref bResult, header, "_floatValues");
HEU_TestHelpers.AssertTrueLogEquivalent(this._stringValues, other._stringValues, ref bResult, header, "_stringValues");
HEU_TestHelpers.AssertTrueLogEquivalent(this._toggle, other._toggle, ref bResult, header, "_toggle");
HEU_TestHelpers.AssertTrueLogEquivalent(this._color, other._color, ref bResult, header, "_color");
HEU_TestHelpers.AssertTrueLogEquivalent(this._gradient.ToTestObject(), other._gradient.ToTestObject(), ref bResult, header, "_gradient");
HEU_TestHelpers.AssertTrueLogEquivalent(this._animCurve.ToTestObject(), other._animCurve.ToTestObject(), ref bResult, header, "_animCurve");
// Skip choiceLabels
HEU_TestHelpers.AssertTrueLogEquivalent(this._choiceStringValues, other._choiceStringValues, ref bResult, header, "_choiceStringValues");
HEU_TestHelpers.AssertTrueLogEquivalent(this._choiceIntValues, other._choiceIntValues, ref bResult, header, "_choiceIntValues");
HEU_TestHelpers.AssertTrueLogEquivalent(this._parmInfo.ToTestObject(), other._parmInfo.ToTestObject(), ref bResult, header, "_parmInfo");
HEU_TestHelpers.AssertTrueLogEquivalent(this._showChildren, other._showChildren, ref bResult, header, "_showChildren");
HEU_TestHelpers.AssertTrueLogEquivalent(this._fileTypeInfo, other._fileTypeInfo, ref bResult, header, "_fileTypeInfo");
HEU_TestHelpers.AssertTrueLogEquivalent(this._folderListChildrenProcessed, other._folderListChildrenProcessed, ref bResult, header, "_folderListChildrenProcessed");
HEU_TestHelpers.AssertTrueLogEquivalent(this._tabSelectedIndex, other._tabSelectedIndex, ref bResult, header, "_tabSelectedIndex");
HEU_TestHelpers.AssertTrueLogEquivalent(this._paramInputNode, other._paramInputNode, ref bResult, header, "_paramInputNode");
HEU_TestHelpers.AssertTrueLogEquivalent(this._hasAssetPathTag, other._hasAssetPathTag, ref bResult, header, "_hasAssetPathTag");
return bResult;
}
public bool IsEquivalentTo(HEU_ToolsInfo other)
{
bool bResult = true;
string header = "HEU_ToolsInfo";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return false;
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._paintBrushSize, other._paintBrushSize, ref bResult, header, "_paintBrushSize");
HEU_TestHelpers.AssertTrueLogEquivalent(this._paintBrushOpacity, other._paintBrushOpacity, ref bResult, header, "_paintBrushOpacity");
HEU_TestHelpers.AssertTrueLogEquivalent(this._paintIntValue, other._paintIntValue, ref bResult, header, "_paintIntValue");
HEU_TestHelpers.AssertTrueLogEquivalent(this._paintFloatValue, other._paintFloatValue, ref bResult, header, "_paintFloatValue");
HEU_TestHelpers.AssertTrueLogEquivalent(this._paintStringValue, other._paintStringValue, ref bResult, header, "_paintStringValue");
HEU_TestHelpers.AssertTrueLogEquivalent(this._lastAttributeNodeName, other._lastAttributeNodeName, ref bResult, header, "_lastAttributeNodeName");
HEU_TestHelpers.AssertTrueLogEquivalent(this._lastAttributeName, other._lastAttributeName, ref bResult, header, "_lastAttributeName");
HEU_TestHelpers.AssertTrueLogEquivalent(this._brushHandleColor, other._brushHandleColor, ref bResult, header, "_brushHandleColor");
HEU_TestHelpers.AssertTrueLogEquivalent(this._affectedAreaPaintColor, other._affectedAreaPaintColor, ref bResult, header, "_affectedAreaPaintColor");
HEU_TestHelpers.AssertTrueLogEquivalent(this._liveUpdate, other._liveUpdate, ref bResult, header, "_liveUpdate");
HEU_TestHelpers.AssertTrueLogEquivalent(this._isPainting, other._isPainting, ref bResult, header, "_isPainting");
HEU_TestHelpers.AssertTrueLogEquivalent(this._editPointBoxSize, other._editPointBoxSize, ref bResult, header, "_editPointBoxSize");
HEU_TestHelpers.AssertTrueLogEquivalent(this._editPointBoxUnselectedColor, other._editPointBoxUnselectedColor, ref bResult, header, "_editPointBoxUnselectedColor");
HEU_TestHelpers.AssertTrueLogEquivalent(this._editPointBoxSelectedColor, other._editPointBoxSelectedColor, ref bResult, header, "_editPointBoxSelectedColor");
// HEU_TestHelpers.AssertTrueLogEquivalent(this._recacheRequired, other._recacheRequired, ref bResult, header, "_recacheRequired");
HEU_TestHelpers.AssertTrueLogEquivalent(this._paintMergeMode, other._paintMergeMode, ref bResult, header, "_paintMergeMode");
HEU_TestHelpers.AssertTrueLogEquivalent(this._showOnlyEditGeometry, other._showOnlyEditGeometry, ref bResult, header, "_showOnlyEditGeometry");
HEU_TestHelpers.AssertTrueLogEquivalent(this._alwaysCookUpstream, other._alwaysCookUpstream, ref bResult, header, "_alwaysCookUpstream");
HEU_TestHelpers.AssertTrueLogEquivalent(this._paintMeshVisiblity, other._paintMeshVisiblity, ref bResult, header, "_paintMeshVisibility");
return bResult;
}
public bool IsEquivalentTo(HEU_ObjectInstanceInfo other)
{
bool bResult = true;
string header = "HEU_ObjectInstanceInfo";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return false;
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._instancedInputs, other._instancedInputs, ref bResult, header, "_instancedInputs");
return bResult;
}
public bool IsEquivalentTo(HEU_AssetSerializedMetaData other)
{
bool bResult = true;
string header = "HEU_AssetSerializedMetaData";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return(false);
}
// These things shouldn't be tested because they're specifically "hacky"
return(bResult);
}
public bool IsEquivalentTo(HEU_InstancedInput other)
{
bool bResult = true;
string header = "HEU_InstancedInput";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return false;
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._instancedGameObject, other._instancedGameObject, ref bResult, header, "_instancedGameObject");
HEU_TestHelpers.AssertTrueLogEquivalent(this._rotationOffset, other._rotationOffset, ref bResult, header, "_rotationOffset");
HEU_TestHelpers.AssertTrueLogEquivalent(this._scaleOffset, other._scaleOffset, ref bResult, header, "_scaleOffset");
return bResult;
}
public bool IsEquivalentTo(HEU_InstanceInputUIState other)
{
bool bResult = true;
string header = "HEU_InstanceInputUIState";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return false;
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._showInstanceInputs, other._showInstanceInputs, ref bResult, header, "_showInstanceInputs");
HEU_TestHelpers.AssertTrueLogEquivalent(this._numInputsToShowUI, other._numInputsToShowUI, ref bResult, header, "_numInputsToShowUI");
HEU_TestHelpers.AssertTrueLogEquivalent(this._inputsPageIndexUI , other._inputsPageIndexUI, ref bResult, header, "_inputPageIndexUI");
return bResult;
}
public bool IsEquivalentTo(HEU_ObjectNode other)
{
bool bResult = true;
string header = "HEU_ObjectNode";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return false;
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._objectInfo.ToTestObject(), other._objectInfo.ToTestObject(), ref bResult, header, "Object Info");
HEU_TestHelpers.AssertTrueLogEquivalent(this._geoNodes, other._geoNodes, ref bResult, header, "Geo Node");
HEU_TestHelpers.AssertTrueLogEquivalent(this._objectTransform.ToTestObject(), other._objectTransform.ToTestObject(), ref bResult, header, "Object transform");
return bResult;
}
public bool IsEquivalentTo(HEU_GeneratedOutput other)
{
bool bResult = true;
string header = "HEU_GeneratedOutput";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return false;
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._outputData, other._outputData, ref bResult, header, "_outputData");
HEU_TestHelpers.AssertTrueLogEquivalent(this._childOutputs, other._childOutputs, ref bResult, header, "_childOutputs");
HEU_TestHelpers.AssertTrueLogEquivalent(this.isInstancer, other.isInstancer, ref bResult, header, "_childOutputs");
return bResult;
}
private bool SetMaskLayer(HEU_SessionBase session, HEU_InputDataTerrain idt, ref HAPI_VolumeInfo baseVolumeInfo)
{
int sizeX = idt._terrainData.alphamapWidth;
int sizeY = idt._terrainData.alphamapHeight;
int totalSize = sizeX * sizeY;
float[] maskValues = new float[totalSize];
if (!SetHeightFieldData(session, idt._maskNodeID, 0, maskValues, HEU_Defines.HAPI_HEIGHTFIELD_LAYERNAME_MASK, ref baseVolumeInfo))
{
return(false);
}
if (!session.CommitGeo(idt._maskNodeID))
{
HEU_Logger.LogError("Failed to commit volume layer 'mask'");
return(false);
}
return(true);
}
public bool IsEquivalentTo(HEU_MaterialData other)
{
bool bResult = true;
string header = "HEU_MaterialData";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return false;
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._material.ToTestObject(), other._material.ToTestObject(), ref bResult, header, "_material");
HEU_TestHelpers.AssertTrueLogEquivalent(this._materialSource, other._materialSource, ref bResult, header, "_materialSource");
// Skip _materialKey
return bResult;
}
public bool IsEquivalentTo(HEU_GeneratedOutputData other)
{
bool bResult = true;
string header = "HEU_GeneratedOutputData";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return false;
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._gameObject, other._gameObject, ref bResult, header, "_gameObject");
HEU_TestHelpers.AssertTrueLogEquivalent(_renderMaterials.ToTestObject(), other._renderMaterials.ToTestObject(), ref bResult, header, "_renderMaterials");
HEU_TestHelpers.AssertTrueLogEquivalent(_colliders.ToTestObject(), other._colliders.ToTestObject(), ref bResult, header, "_colliders");
return bResult;
}
public bool IsEquivalentTo(HEU_ParameterModifier other)
{
bool bResult = true;
string header = "HEU_ParameterModifier";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return false;
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._parameterIndex, other._parameterIndex, ref bResult, header, "_parameterIndex");
HEU_TestHelpers.AssertTrueLogEquivalent(this._action, other._action, ref bResult, header, "_action");
HEU_TestHelpers.AssertTrueLogEquivalent(this._instanceIndex, other._instanceIndex, ref bResult, header, "_instanceIndex");
HEU_TestHelpers.AssertTrueLogEquivalent(this._modifierValue, other._modifierValue, ref bResult, header, "_modifierValue");
HEU_TestHelpers.AssertTrueLogEquivalent(this._floatValue, other._floatValue, ref bResult, header, "_floatValue");
HEU_TestHelpers.AssertTrueLogEquivalent(this._intValue, other._intValue, ref bResult, header, "_intValue");
return bResult;
}
/// <summary>
/// Start the work in a new thread, with priority and background set.
/// </summary>
public virtual void Start()
{
Debug.Assert(!StopRequested, "StopRequested is true. Task didn't get reset!");
Debug.Assert(!IsComplete, "IsComplete is true. Task didn't get reset!");
if (_thread == null)
{
// Activate the task first ensuring it won't be stopped until complete or stopped
IsActive = true;
IsComplete = false;
HEU_ThreadManager.Instance.AddTask(this);
_thread = new System.Threading.Thread(Run);
_thread.Priority = Priority;
_thread.IsBackground = IsBackground;
_thread.Start();
}
else
{
HEU_Logger.LogError("Thread already running!");
}
}
public bool IsEquivalentTo(HEU_HandleParamBinding other)
{
bool bResult = true;
string header = "HEU_HandleParamBinding";
if (other == null)
{
HEU_Logger.LogError(header + " Not equivalent");
return false;
}
HEU_TestHelpers.AssertTrueLogEquivalent(this._paramType, other._paramType, ref bResult, header, "_paramType");
// SKip parmID
HEU_TestHelpers.AssertTrueLogEquivalent(this._paramName, other._paramName, ref bResult, header, "_paramName");
HEU_TestHelpers.AssertTrueLogEquivalent(this._bDisabled, other._bDisabled, ref bResult, header, "_bDisabled");
HEU_TestHelpers.AssertTrueLogEquivalent(this._boundChannels, other._boundChannels, ref bResult, header, "_boundChannels");
return bResult;
}
/// <summary>
/// Create an input node network and upload the given set of input objects.
/// This creates a SOP/merge node, and input nodes for each object in inputObjects
/// which are then connected to the merge node.
/// It finds the input interface that supports each object in inputObjects for creating
/// the input node and uploading the data based on the type of data.
/// </summary>
/// <param name="session">Session to create the input node in</param>
/// <param name="assetID">Main asset ID</param>
/// <param name="connectMergeID">Created SOP/merge node ID</param>
/// <param name="inputObjects">List of input objects to upload</param>
/// <param name="inputObjectsConnectedAssetIDs">List of input node IDs for the input nodes created</param>
/// <param name="inputNode">The specified inputNode to create the node for (used for settings)</param>
/// <returns>True if successfully uploading input nodes</returns>
internal static bool CreateInputNodeWithMultiObjects(HEU_SessionBase session, HAPI_NodeId assetID,
ref HAPI_NodeId connectMergeID, ref List<HEU_InputObjectInfo> inputObjects, ref List<HAPI_NodeId> inputObjectsConnectedAssetIDs, HEU_InputNode inputNode)
{
bool bKeepWorldTransform = inputNode.KeepWorldTransform;
// Create the merge SOP node that the input nodes are going to connect to.
if (!session.CreateNode(-1, "SOP/merge", null, true, out connectMergeID))
{
HEU_Logger.LogErrorFormat("Unable to create merge SOP node for connecting input assets.");
return false;
}
int numObjects = inputObjects.Count;
for (int i = 0; i < numObjects; ++i)
{
HAPI_NodeId newConnectInputID = HEU_Defines.HEU_INVALID_NODE_ID;
inputObjectsConnectedAssetIDs.Add(newConnectInputID);
// Skipping null gameobjects. Though if this causes issues, can always let it continue
// to create input node, but not upload mesh data
if (inputObjects[i]._gameObject == null)
{
continue;
}
HEU_InputInterface inputInterface = GetInputInterface(inputObjects[i]);
if (inputInterface == null)
{
HEU_Logger.LogWarningFormat("No input interface found for gameobject: {0}. Skipping upload!", inputObjects[i]._gameObject.name);
continue;
}
// Apply settings based on the interface type.
System.Type inputInterfaceType = inputInterface.GetType();
if (inputInterfaceType == typeof(HEU_InputInterfaceMesh))
{
HEU_InputInterfaceMesh meshInterface = inputInterface as HEU_InputInterfaceMesh;
meshInterface.Initialize(inputNode.MeshSettings);
}
if (inputInterfaceType == typeof(HEU_InputInterfaceTilemap))
{
HEU_InputInterfaceTilemap tilemapInterface = inputInterface as HEU_InputInterfaceTilemap;
tilemapInterface.Initialize(inputNode.TilemapSettings);
}
bool bResult = inputInterface.CreateInputNodeWithDataUpload(session, connectMergeID, inputObjects[i]._gameObject, out newConnectInputID);
if (!bResult || newConnectInputID == HEU_Defines.HEU_INVALID_NODE_ID)
{
HEU_Logger.LogError("Failed to upload input.");
continue;
}
inputObjectsConnectedAssetIDs[i] = newConnectInputID;
if (!session.ConnectNodeInput(connectMergeID, i, newConnectInputID))
{
HEU_Logger.LogErrorFormat("Unable to connect input nodes!");
return false;
}
UploadInputObjectTransform(session, inputObjects[i], newConnectInputID, bKeepWorldTransform);
}
return true;
}
/// <summary>
/// Creates a mesh input node and uploads the mesh data from inputObject.
/// </summary>
/// <param name="session">Session that connectNodeID exists in</param>
/// <param name="connectNodeID">The node to connect the network to. Most likely a SOP/merge node</param>
/// <param name="inputObject">The gameobject containing the mesh components</param>
/// <param name="inputNodeID">The created input node ID</param>
/// <returns>True if created network and uploaded mesh data.</returns>
public override bool CreateInputNodeWithDataUpload(HEU_SessionBase session, HAPI_NodeId connectNodeID, GameObject inputObject, out HAPI_NodeId inputNodeID)
{
inputNodeID = HEU_Defines.HEU_INVALID_NODE_ID;
// Create input node, cook it, then upload the geometry data
if (!HEU_HAPIUtility.IsNodeValidInHoudini(session, connectNodeID))
{
HEU_Logger.LogError("Connection node is invalid.");
return false;
}
bool bExportColliders = settings != null && settings.ExportColliders == true;
// Get upload meshes from input object
HEU_InputDataMeshes inputMeshes = GenerateMeshDatasFromGameObject(inputObject, bExportColliders);
if (inputMeshes == null || inputMeshes._inputMeshes == null || inputMeshes._inputMeshes.Count == 0)
{
HEU_Logger.LogError("No valid meshes found on input objects.");
return false;
}
string inputName = null;
HAPI_NodeId newNodeID = HEU_Defines.HEU_INVALID_NODE_ID;
session.CreateInputNode(out newNodeID, inputName);
if (newNodeID == HEU_Defines.HEU_INVALID_NODE_ID || !HEU_HAPIUtility.IsNodeValidInHoudini(session, newNodeID))
{
HEU_Logger.LogError("Failed to create new input node in Houdini session!");
return false;
}
inputNodeID = newNodeID;
if (!UploadData(session, inputNodeID, inputMeshes))
{
if (!session.CookNode(inputNodeID, false))
{
HEU_Logger.LogError("New input node failed to cook!");
return false;
}
return false;
}
bool createMergeNode = false;
HAPI_NodeId mergeNodeId = HEU_Defines.HEU_INVALID_NODE_ID;
if (bExportColliders)
{
createMergeNode = true;
}
if (!createMergeNode)
{
return true;
}
HAPI_NodeId parentId = HEU_HAPIUtility.GetParentNodeID(session, newNodeID);
if (!session.CreateNode(parentId, "merge", null, false, out mergeNodeId))
{
HEU_Logger.LogErrorFormat("Unable to create merge SOP node for connecting input assets.");
return false;
}
if (!session.ConnectNodeInput(mergeNodeId, 0, newNodeID))
{
HEU_Logger.LogErrorFormat("Unable to connect to input node!");
return false;
}
if (!session.SetNodeDisplay(mergeNodeId, 1))
{
HEU_Logger.LogWarningFormat("Unable to set display flag!");
}
inputNodeID = mergeNodeId;
if (bExportColliders)
{
if (!UploadColliderData(session, mergeNodeId, inputMeshes, parentId))
{
return false;
}
}
if (!session.CookNode(inputNodeID, false))
{
HEU_Logger.LogError("New input node failed to cook!");
return false;
}
return true;
}
