| public static GetOrCreateDefaultSession ( bool bNotifyUserError = true ) : HEU_SessionBase | ||
| bNotifyUserError | bool | |
| return | HEU_SessionBase | |
public static GameObject CreateNewAsset(HEU_HoudiniAsset.HEU_AssetType assetType, string rootName = "HoudiniAsset", Transform parentTransform = null, HEU_SessionBase session = null, bool bBuildAsync = true)
{
if (session == null)
{
session = HEU_SessionManager.GetOrCreateDefaultSession();
}
if (!session.IsSessionValid())
{
Debug.LogWarning("Invalid Houdini Engine session!");
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_HoudiniAssetRoot assetRoot = rootGO.AddComponent <HEU_HoudiniAssetRoot>();
// Set the game object's name to the asset's name
rootGO.name = string.Format("{0}{1}", rootName, rootGO.GetInstanceID());
// 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(assetType, null, rootGO, session);
// Build it in Houdini Engine
asset.RequestReload(bBuildAsync);
if (parentTransform != null)
{
rootGO.transform.parent = parentTransform;
rootGO.transform.localPosition = Vector3.zero;
}
else
{
rootGO.transform.position = Vector3.zero;
}
return(rootGO);
}
public HEU_SessionBase GetTaskSession()
{
if(_forceSessionID == HEU_SessionData.INVALID_SESSION_ID)
{
return HEU_SessionManager.GetOrCreateDefaultSession();
}
else
{
return HEU_SessionManager.GetSessionWithID(_forceSessionID);
}
}
/// <summary>
/// Return the current Houdini Engine session
/// </summary>
/// <returns></returns>
public HEU_SessionBase GetHAPIPDGSession(bool bCreate = true)
{
if (bCreate)
{
return(HEU_SessionManager.GetOrCreateDefaultSession());
}
else
{
return(HEU_SessionManager.GetDefaultSession());
}
}
// PUBLIC FUNCTIONS ===========================================================================
/// <inheritdoc />
public HEU_SessionBase GetSession()
{
if (_parentAsset != null)
{
return _parentAsset.GetAssetSession(true);
}
else
{
return HEU_SessionManager.GetOrCreateDefaultSession();
}
}
public static void ExecuteToolNoInput(string toolName, string toolPath)
{
GameObject go = HEU_HAPIUtility.InstantiateHDA(toolPath, Vector3.zero, HEU_SessionManager.GetOrCreateDefaultSession(), false);
if (go == null)
{
Debug.LogWarningFormat("Failed to instantiate tool: {0}", toolName);
}
else
{
HEU_EditorUtility.SelectObject(go);
}
}
private static void LoadHoudiniAssetFromPath(string hdaPath)
{
if (!string.IsNullOrEmpty(hdaPath))
{
// Store HDA path for next time
HEU_PluginSettings.LastLoadHDAPath = Path.GetDirectoryName(hdaPath);
GameObject go = HEU_HAPIUtility.InstantiateHDA(hdaPath, Vector3.zero, HEU_SessionManager.GetOrCreateDefaultSession(), true);
if (go != null)
{
HEU_EditorUtility.SelectObject(go);
}
}
}
public static void ExecuteToolGenerator(string toolName, string toolPath, Vector3 targetPosition, Quaternion targetRotation, Vector3 targetScale)
{
GameObject go = HEU_HAPIUtility.InstantiateHDA(toolPath, targetPosition, HEU_SessionManager.GetOrCreateDefaultSession(), true);
if (go != null)
{
go.transform.rotation = targetRotation;
go.transform.localScale = targetScale;
HEU_EditorUtility.SelectObject(go);
}
else
{
Debug.LogWarningFormat("Failed to instantiate tool: {0}", toolName);
}
}
public HEU_SessionBase GetHoudiniSession(bool bCreateIfNotFound)
{
HEU_SessionBase session = (_sessionID != HEU_SessionData.INVALID_SESSION_ID) ? HEU_SessionManager.GetSessionWithID(_sessionID) : null;
if (session == null || !session.IsSessionValid())
{
if (bCreateIfNotFound)
{
session = HEU_SessionManager.GetOrCreateDefaultSession();
if (session != null && session.IsSessionValid())
{
_sessionID = session.GetSessionData().SessionID;
}
}
}
return session;
}
public static void LoadHoudiniAssetWindow()
{
if (HEU_SessionManager.ValidatePluginSession())
{
string[] extensions = { "HDAs", "otl,hda,otllc,hdalc,otlnc,hdanc" };
string hdaPath = EditorUtility.OpenFilePanelWithFilters("Load Houdini Digital Asset", HEU_PluginSettings.LastLoadHDAPath, extensions);
if (!string.IsNullOrEmpty(hdaPath))
{
// Store HDA path for next time
HEU_PluginSettings.LastLoadHDAPath = Path.GetDirectoryName(hdaPath);
GameObject go = HEU_HAPIUtility.InstantiateHDA(hdaPath, Vector3.zero, HEU_SessionManager.GetOrCreateDefaultSession(), true);
if (go != null)
{
HEU_EditorUtility.SelectObject(go);
}
}
}
}
public static void ExecuteToolOperatorSingle(string toolName, string toolPath, GameObject[] inputObjects)
{
GameObject go = HEU_HAPIUtility.InstantiateHDA(toolPath, Vector3.zero, HEU_SessionManager.GetOrCreateDefaultSession(), true);
if (go != null)
{
HEU_HoudiniAssetRoot assetRoot = go.GetComponent<HEU_HoudiniAssetRoot>();
if (assetRoot != null)
{
//assetRoot._houdiniAsset
// TODO
}
HEU_EditorUtility.SelectObject(go);
}
else
{
Debug.LogWarningFormat("Failed to instantiate tool: {0}", toolName);
}
}
/// <summary>
/// For this object's _material, we update the shader attributes and
/// fetch the textures from Houdini.
/// </summary>
/// <param name="materialInfo">This material's info from Houdini</param>
/// <param name="assetCacheFolderPath">Path to asset's cache folder</param>
public bool UpdateMaterialFromHoudini(HAPI_MaterialInfo materialInfo, string assetCacheFolderPath)
{
if (_material == null)
{
return false;
}
HEU_SessionBase session = HEU_SessionManager.GetOrCreateDefaultSession();
HAPI_NodeInfo nodeInfo = new HAPI_NodeInfo();
if (!session.GetNodeInfo(materialInfo.nodeId, ref nodeInfo))
{
return false;
}
// Get all parameters of this material
HAPI_ParmInfo[] parmInfos = new HAPI_ParmInfo[nodeInfo.parmCount];
if (!HEU_GeneralUtility.GetArray1Arg(materialInfo.nodeId, session.GetParams, parmInfos, 0, nodeInfo.parmCount))
{
return false;
}
// Assign transparency shader or non-transparent.
bool isTransparent = IsTransparentMaterial(session, materialInfo.nodeId, parmInfos);
if (isTransparent)
{
_material.shader = HEU_MaterialFactory.FindPluginShader(HEU_PluginSettings.DefaultTransparentShader);
}
else
{
_material.shader = HEU_MaterialFactory.FindPluginShader(HEU_PluginSettings.DefaultStandardShader);
}
if (HEU_PluginSettings.UseLegacyShaders)
{
return UseLegacyShaders(materialInfo, assetCacheFolderPath, session, nodeInfo, parmInfos);
}
// Diffuse texture - render & extract
int diffuseMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_OGL_TEX1_ATTR, HEU_Defines.MAT_OGL_TEX1_ATTR_ENABLED);
if (diffuseMapParmIndex < 0)
{
diffuseMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_BASECOLOR_ATTR, HEU_Defines.MAT_BASECOLOR_ATTR_ENABLED);
}
if (diffuseMapParmIndex >= 0 && diffuseMapParmIndex < parmInfos.Length)
{
string diffuseTextureFileName = GetTextureFileNameFromMaterialParam(session, materialInfo.nodeId, parmInfos[diffuseMapParmIndex]);
_material.mainTexture = HEU_MaterialFactory.RenderAndExtractImageToTexture(session, materialInfo, parmInfos[diffuseMapParmIndex].id, diffuseTextureFileName, assetCacheFolderPath, false);
}
Color diffuseColor;
if (!HEU_ParameterUtility.GetParameterColor3Value(session, materialInfo.nodeId, parmInfos, HEU_Defines.MAT_OGL_DIFF_ATTR, Color.white, out diffuseColor))
{
HEU_ParameterUtility.GetParameterColor3Value(session, materialInfo.nodeId, parmInfos, HEU_Defines.MAT_DIFF_ATTR, Color.white, out diffuseColor);
}
float alpha;
GetMaterialAlpha(session, materialInfo.nodeId, parmInfos, 1f, out alpha);
if (isTransparent)
{
int opacityMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_OGL_OPACITY_MAP_ATTR, HEU_Defines.MAT_OGL_OPACITY_MAP_ATTR_ENABLED);
if (opacityMapParmIndex < 0)
{
opacityMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_OPACITY_MAP_ATTR, HEU_Defines.MAT_OPACITY_MAP_ATTR_ENABLED);
}
if (opacityMapParmIndex >= 0 && opacityMapParmIndex < parmInfos.Length)
{
string opacityTextureFileName = GetTextureFileNameFromMaterialParam(session, materialInfo.nodeId, parmInfos[opacityMapParmIndex]);
_material.SetTexture(HEU_Defines.UNITY_SHADER_OPACITY_MAP, HEU_MaterialFactory.RenderAndExtractImageToTexture(session, materialInfo, parmInfos[opacityMapParmIndex].id, opacityTextureFileName, assetCacheFolderPath, false));
}
}
diffuseColor.a = alpha;
_material.SetColor(HEU_Defines.UNITY_SHADER_COLOR, diffuseColor);
if (HEU_PluginSettings.UseSpecularShader)
{
Color specular;
Color defaultSpecular = new Color(0.2f, 0.2f, 0.2f, 1);
if (!HEU_ParameterUtility.GetParameterColor3Value(session, materialInfo.nodeId, parmInfos, HEU_Defines.MAT_OGL_SPEC_ATTR, defaultSpecular, out specular))
{
HEU_ParameterUtility.GetParameterColor3Value(session, materialInfo.nodeId, parmInfos, HEU_Defines.MAT_SPEC_ATTR, defaultSpecular, out specular);
}
_material.SetColor(HEU_Defines.UNITY_SHADER_SPEC_COLOR, specular);
int specMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_OGL_SPEC_MAP_ATTR, HEU_Defines.MAT_OGL_SPEC_MAP_ATTR_ENABLED);
if (specMapParmIndex < 0)
{
specMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_SPEC_MAP_ATTR, HEU_Defines.MAT_SPEC_MAP_ATTR_ENABLED);
}
if (specMapParmIndex >= 0 && specMapParmIndex < parmInfos.Length)
{
string specTextureFileName = GetTextureFileNameFromMaterialParam(session, materialInfo.nodeId, parmInfos[specMapParmIndex]);
_material.SetTexture(HEU_Defines.UNITY_SHADER_SPEC_MAP, HEU_MaterialFactory.RenderAndExtractImageToTexture(session, materialInfo, parmInfos[specMapParmIndex].id, specTextureFileName, assetCacheFolderPath, false));
}
}
else
{
float metallic = 0;
if (!HEU_ParameterUtility.GetParameterFloatValue(session, materialInfo.nodeId, parmInfos, HEU_Defines.MAT_OGL_METALLIC_ATTR, 0f, out metallic))
{
HEU_ParameterUtility.GetParameterFloatValue(session, materialInfo.nodeId, parmInfos, HEU_Defines.MAT_METALLIC_ATTR, 0f, out metallic);
}
_material.SetFloat(HEU_Defines.UNITY_SHADER_METALLIC, metallic);
int metallicMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_OGL_METALLIC_MAP_ATTR, HEU_Defines.MAT_OGL_METALLIC_MAP_ATTR_ENABLED);
if (metallicMapParmIndex < 0)
{
metallicMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_METALLIC_MAP_ATTR, HEU_Defines.MAT_METALLIC_MAP_ATTR_ENABLED);
}
if (metallicMapParmIndex >= 0 && metallicMapParmIndex < parmInfos.Length)
{
string metallicTextureFileName = GetTextureFileNameFromMaterialParam(session, materialInfo.nodeId, parmInfos[metallicMapParmIndex]);
_material.SetTexture(HEU_Defines.UNITY_SHADER_METALLIC_MAP, HEU_MaterialFactory.RenderAndExtractImageToTexture(session, materialInfo, parmInfos[metallicMapParmIndex].id, metallicTextureFileName, assetCacheFolderPath, false));
}
}
// Normal map - render & extract texture
int normalMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_NORMAL_ATTR, HEU_Defines.MAT_NORMAL_ATTR_ENABLED);
if (normalMapParmIndex < 0)
{
normalMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_OGL_NORMAL_ATTR, "");
}
if (normalMapParmIndex >= 0 && normalMapParmIndex < parmInfos.Length)
{
string normalTextureFileName = GetTextureFileNameFromMaterialParam(session, materialInfo.nodeId, parmInfos[normalMapParmIndex]);
Texture2D normalMap = HEU_MaterialFactory.RenderAndExtractImageToTexture(session, materialInfo, parmInfos[normalMapParmIndex].id, normalTextureFileName, assetCacheFolderPath, true);
if (normalMap != null)
{
_material.SetTexture(HEU_Defines.UNITY_SHADER_BUMP_MAP, normalMap);
}
}
// Emission
Color emission;
Color defaultEmission = new Color(0, 0, 0, 0);
if (!HEU_ParameterUtility.GetParameterColor3Value(session, materialInfo.nodeId, parmInfos, HEU_Defines.MAT_OGL_EMISSIVE_ATTR, defaultEmission, out emission))
{
HEU_ParameterUtility.GetParameterColor3Value(session, materialInfo.nodeId, parmInfos, HEU_Defines.MAT_EMISSIVE_ATTR, defaultEmission, out emission);
}
_material.SetColor(HEU_Defines.UNITY_SHADER_EMISSION_COLOR, emission);
int emissionMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_OGL_EMISSIVE_MAP_ATTR, HEU_Defines.MAT_OGL_EMISSIVE_MAP_ATTR_ENABLED);
if (emissionMapParmIndex < 0)
{
emissionMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_EMISSIVE_MAP_ATTR, HEU_Defines.MAT_EMISSIVE_MAP_ATTR_ENABLED);
}
if (emissionMapParmIndex >= 0 && emissionMapParmIndex < parmInfos.Length)
{
string emissionTextureFileName = GetTextureFileNameFromMaterialParam(session, materialInfo.nodeId, parmInfos[emissionMapParmIndex]);
_material.SetTexture(HEU_Defines.UNITY_SHADER_EMISSION_MAP, HEU_MaterialFactory.RenderAndExtractImageToTexture(session, materialInfo, parmInfos[emissionMapParmIndex].id, emissionTextureFileName, assetCacheFolderPath, false));
}
// Smoothness (need to invert roughness!)
float roughness;
float defaultRoughness = 0.5f;
if (!HEU_ParameterUtility.GetParameterFloatValue(session, materialInfo.nodeId, parmInfos, HEU_Defines.MAT_OGL_ROUGH_ATTR, defaultRoughness, out roughness))
{
HEU_ParameterUtility.GetParameterFloatValue(session, materialInfo.nodeId, parmInfos, HEU_Defines.MAT_ROUGH_ATTR, defaultRoughness, out roughness);
}
// Clamp shininess to non-zero as results in very hard shadows. Unity's UI does not allow zero either.
_material.SetFloat(HEU_Defines.UNITY_SHADER_SMOOTHNESS, Mathf.Max(0.03f, 1.0f - roughness));
int roughMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_OGL_ROUGH_MAP_ATTR, HEU_Defines.MAT_OGL_ROUGH_MAP_ATTR_ENABLED);
if (roughMapParmIndex < 0)
{
roughMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_ROUGH_MAP_ATTR, HEU_Defines.MAT_ROUGH_MAP_ATTR_ENABLED);
}
if (roughMapParmIndex >= 0 && roughMapParmIndex < parmInfos.Length)
{
string roughTextureFileName = GetTextureFileNameFromMaterialParam(session, materialInfo.nodeId, parmInfos[roughMapParmIndex]);
_material.SetTexture(HEU_Defines.UNITY_SHADER_SMOOTHNESS_MAP, HEU_MaterialFactory.RenderAndExtractImageToTexture(session, materialInfo, parmInfos[roughMapParmIndex].id, roughTextureFileName, assetCacheFolderPath, false, invertTexture: true));
}
// Occlusion (only has ogl map)
int occlusionMapParmIndex = HEU_ParameterUtility.FindTextureParamByNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_OGL_OCCLUSION_MAP_ATTR, HEU_Defines.MAT_OGL_ROUGH_MAP_ATTR_ENABLED);
if (occlusionMapParmIndex >= 0 && occlusionMapParmIndex < parmInfos.Length)
{
string occlusionTextureFileName = GetTextureFileNameFromMaterialParam(session, materialInfo.nodeId, parmInfos[occlusionMapParmIndex]);
_material.SetTexture(HEU_Defines.UNITY_SHADER_OCCLUSION_MAP, HEU_MaterialFactory.RenderAndExtractImageToTexture(session, materialInfo, parmInfos[occlusionMapParmIndex].id, occlusionTextureFileName, assetCacheFolderPath, false));
}
return true;
}
private static void ProcessDragEvent(Event dragEvent, SceneView sceneView)
{
if (dragEvent != null && (dragEvent.type == EventType.DragUpdated || dragEvent.type == EventType.DragPerform))
{
bool dragHDAs = false;
List <string> hdaList = new List <string>();
foreach (string file in DragAndDrop.paths)
{
if (HEU_HAPIUtility.IsHoudiniAssetFile(file))
{
dragHDAs = true;
DragAndDrop.visualMode = DragAndDropVisualMode.Move;
hdaList.Add(file);
break;
}
}
if (dragHDAs)
{
if (dragEvent.type == EventType.DragPerform)
{
if (HEU_SessionManager.ValidatePluginSession())
{
Vector3 dropPos = Vector3.zero;
if (sceneView != null)
{
Camera camera = sceneView.camera;
Vector3 mousePos = HEU_EditorUI.GetMousePosition(ref dragEvent, camera);
Ray ray = camera.ScreenPointToRay(mousePos);
ray.origin = camera.transform.position;
Plane plane = new Plane();
plane.SetNormalAndPosition(Vector3.up, Vector3.zero);
float enter = 0f;
plane.Raycast(ray, out enter);
enter = Mathf.Clamp(enter, camera.nearClipPlane, camera.farClipPlane);
dropPos = ray.origin + ray.direction * enter;
}
List <GameObject> createdGOs = new List <GameObject>();
foreach (string file in hdaList)
{
GameObject go = HEU_HAPIUtility.InstantiateHDA(file, dropPos, HEU_SessionManager.GetOrCreateDefaultSession(), true);
if (go != null)
{
createdGOs.Add(go);
}
}
// Select the created assets
HEU_EditorUtility.SelectObjects(createdGOs.ToArray());
}
}
dragEvent.Use();
}
}
}
/// <summary>
/// For this object's _material, we update the shader attributes and
/// fetch the textures from Houdini.
/// </summary>
/// <param name="materialInfo">This material's info from Houdini</param>
/// <param name="assetCacheFolderPath">Path to asset's cache folder</param>
public void UpdateMaterialFromHoudini(HAPI_MaterialInfo materialInfo, string assetCacheFolderPath)
{
HEU_SessionBase session = HEU_SessionManager.GetOrCreateDefaultSession();
HAPI_NodeInfo nodeInfo = new HAPI_NodeInfo();
if (!session.GetNodeInfo(materialInfo.nodeId, ref nodeInfo))
{
return;
}
// Get all parameters of this material
HAPI_ParmInfo[] parmInfos = new HAPI_ParmInfo[nodeInfo.parmCount];
if (!HEU_GeneralUtility.GetArray1Arg(materialInfo.nodeId, session.GetParams, parmInfos, 0, nodeInfo.parmCount))
{
return;
}
// Assign transparency shader or non-transparent.
if (IsTransparentMaterial(session, materialInfo.nodeId, parmInfos))
{
_material.shader = HEU_MaterialFactory.FindPluginShader(HEU_PluginSettings.DefaultTransparentShader);
}
else
{
_material.shader = HEU_MaterialFactory.FindPluginShader(HEU_PluginSettings.DefaultStandardShader);
}
// Diffuse texture - render & extract
int diffuseMapParmIndex = HEU_ParameterUtility.GetParameterIndexFromNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_OGL_TEX1_ATTR);
if (diffuseMapParmIndex < 0)
{
diffuseMapParmIndex = HEU_ParameterUtility.GetParameterIndexFromNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_BASECOLOR_ATTR);
if (diffuseMapParmIndex < 0)
{
diffuseMapParmIndex = HEU_ParameterUtility.GetParameterIndexFromNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_MAP_ATTR);
}
}
if (diffuseMapParmIndex >= 0 && diffuseMapParmIndex < parmInfos.Length)
{
string diffuseTextureFileName = GetTextureFileNameFromMaterialParam(session, materialInfo.nodeId, parmInfos[diffuseMapParmIndex]);
_material.mainTexture = HEU_MaterialFactory.RenderAndExtractImageToTexture(session, materialInfo, parmInfos[diffuseMapParmIndex].id, diffuseTextureFileName, assetCacheFolderPath);
}
// Normal map - render & extract texture
int normalMapParmIndex = HEU_ParameterUtility.GetParameterIndexFromNameOrTag(session, nodeInfo.id, parmInfos, HEU_Defines.MAT_OGL_NORMAL_ATTR);
if (normalMapParmIndex >= 0 && normalMapParmIndex < parmInfos.Length)
{
string normalTextureFileName = GetTextureFileNameFromMaterialParam(session, materialInfo.nodeId, parmInfos[normalMapParmIndex]);
Texture2D normalMap = HEU_MaterialFactory.RenderAndExtractImageToTexture(session, materialInfo, parmInfos[normalMapParmIndex].id, normalTextureFileName, assetCacheFolderPath);
if (normalMap != null)
{
_material.SetTexture(HEU_Defines.UNITY_SHADER_BUMP_MAP, normalMap);
}
}
// Assign shader properties
// Clamp shininess to non-zero as results in very hard shadows. Unity's UI does not allow zero either.
float shininess = HEU_ParameterUtility.GetParameterFloatValue(session, materialInfo.nodeId, parmInfos, HEU_Defines.MAT_OGL_ROUGH_ATTR, 0f);
_material.SetFloat(HEU_Defines.UNITY_SHADER_SHININESS, Mathf.Max(0.03f, 1.0f - shininess));
Color diffuseColor = HEU_ParameterUtility.GetParameterColor3Value(session, materialInfo.nodeId, parmInfos, HEU_Defines.MAT_OGL_DIFF_ATTR, Color.white);
diffuseColor.a = HEU_ParameterUtility.GetParameterFloatValue(session, materialInfo.nodeId, parmInfos, HEU_Defines.MAT_OGL_ALPHA_ATTR, 1f);
_material.SetColor(HEU_Defines.UNITY_SHADER_COLOR, diffuseColor);
Color specular = HEU_ParameterUtility.GetParameterColor3Value(session, materialInfo.nodeId, parmInfos, HEU_Defines.MAT_OGL_SPEC_ATTR, Color.black);
_material.SetColor(HEU_Defines.UNITY_SHADER_SPECCOLOR, specular);
}
public HEU_SessionBase GetHAPIPDGSession()
{
return(HEU_SessionManager.GetOrCreateDefaultSession());
}
public void TriggerButton(GraphReference reference)
{
Flow flow = Flow.New(reference);
string hdaPath = flow.GetValue <string>(inputPath);
bool hdaAsync = flow.GetValue <bool>(inputAsync);
Vector3 hdaPosition = flow.GetValue <Vector3>(inputPosition);
System.Action ContinueFlow = () =>
{
flow.Invoke(trigger);
};
bool hasErrored = false;
try
{
HEU_SessionBase session = HEU_SessionManager.GetOrCreateDefaultSession(true);
if (session != null)
{
GameObject go = HEU_HAPIUtility.InstantiateHDA(hdaPath, hdaPosition, session, bBuildAsync: hdaAsync);
hdaRoot = go.GetComponent <HEU_HoudiniAssetRoot>();
if (hdaRoot != null)
{
hdaAsset = hdaRoot.HoudiniAsset;
if (hdaAsync)
{
hdaAsset.ReloadDataEvent.AddListener((HEU_ReloadEventData data) =>
{
bSuccess = data.CookSuccess;
ContinueFlow();
});
}
else
{
bSuccess = hdaAsset.LastCookResult != HEU_AssetCookResultWrapper.ERRORED;
}
}
else
{
hasErrored = true;
}
}
else
{
hasErrored = true;
}
}
catch (System.Exception e)
{
Debug.LogError(e);
hasErrored = true;
}
if (hasErrored)
{
bSuccess = false;
ContinueFlow();
}
else if (!hdaAsync)
{
ContinueFlow();
}
}
public static void ExecuteToolOperatorMultiple(string toolName, string toolPath, GameObject[] inputObjects)
{
GameObject outputObjectToSelect = null;
GameObject go = HEU_HAPIUtility.InstantiateHDA(toolPath, Vector3.zero, HEU_SessionManager.GetOrCreateDefaultSession(), false);
if(go == null)
{
Debug.LogWarningFormat("Failed to instantiate tool: {0}", toolName);
return;
}
HEU_HoudiniAssetRoot assetRoot = go.GetComponent<HEU_HoudiniAssetRoot>();
if (assetRoot != null)
{
HEU_HoudiniAsset asset = assetRoot._houdiniAsset;
HEU_SessionBase session = asset.GetAssetSession(true);
int numInputs = inputObjects.Length;
List<HEU_InputNode> inputNodes = asset.GetInputNodes();
if (inputNodes == null || inputNodes.Count == 0)
{
Debug.LogErrorFormat("Unable to assign input geometry due to no asset inputs on selected tool.");
}
else
{
// User could have selected any number of inputs objects, and asset could have any number of inputs.
// So use minimum of either to set input object into asset input.
int minInputCount = Mathf.Min(inputNodes.Count, numInputs);
for (int i = 0; i < minInputCount; ++i)
{
if (!IsValidInput(inputObjects[i]))
{
continue;
}
GameObject inputObject = inputObjects[i];
HEU_InputNode inputNode = inputNodes[i];
inputNode.ResetInputNode(session);
inputNode.ChangeInputType(session, HEU_InputNode.InputObjectType.UNITY_MESH);
HEU_InputObjectInfo inputInfo = inputNode.AddInputEntryAtEnd(inputObject);
inputInfo._useTransformOffset = false;
inputNode.KeepWorldTransform = true;
inputNode.PackGeometryBeforeMerging = false;
inputNode.RequiresUpload = true;
}
asset.RequestCook(true, true, true, true);
outputObjectToSelect = assetRoot.gameObject;
}
}
if (outputObjectToSelect != null)
{
HEU_EditorUtility.SelectObject(outputObjectToSelect);
}
}
public static void ExecuteToolOperatorSingle(string toolName, string toolPath, GameObject[] inputObjects)
{
// Single operator means single asset input. If multiple inputs are provided, create tool for each input.
List<GameObject> outputObjectsToSelect = new List<GameObject>();
int numInputs = inputObjects.Length;
for (int i = 0; i < numInputs; ++i)
{
if(!IsValidInput(inputObjects[i]))
{
continue;
}
GameObject inputObject = inputObjects[i];
GameObject go = HEU_HAPIUtility.InstantiateHDA(toolPath, Vector3.zero, HEU_SessionManager.GetOrCreateDefaultSession(), false);
if (go != null)
{
HEU_HoudiniAssetRoot assetRoot = go.GetComponent<HEU_HoudiniAssetRoot>();
if (assetRoot != null)
{
HEU_HoudiniAsset asset = assetRoot._houdiniAsset;
HEU_SessionBase session = asset.GetAssetSession(true);
List<HEU_InputNode> inputNodes = asset.GetInputNodes();
if (inputNodes == null || inputNodes.Count == 0)
{
Debug.LogErrorFormat("Unable to assign input geometry due to no asset inputs on selected tool.");
}
else
{
HEU_InputNode inputNode = inputNodes[0];
inputNode.ResetInputNode(session);
inputNode.ChangeInputType(session, HEU_InputNode.InputObjectType.UNITY_MESH);
HEU_InputObjectInfo inputInfo = inputNode.AddInputEntryAtEnd(inputObject);
inputInfo._useTransformOffset = false;
inputNode.KeepWorldTransform = true;
inputNode.PackGeometryBeforeMerging = false;
inputNode.RequiresUpload = true;
asset.RequestCook(true, true, true, true);
outputObjectsToSelect.Add(assetRoot.gameObject);
}
}
}
else
{
Debug.LogWarningFormat("Failed to instantiate tool: {0}", toolName);
}
}
if (outputObjectsToSelect.Count > 0)
{
HEU_EditorUtility.SelectObjects(outputObjectsToSelect.ToArray());
}
}