private void cacheNumInstances()
{
HAPI_ObjectInfo object_info = prAsset.prObjects[prObjectId];
// Get Detail info.
HAPI_GeoInfo geo_info = new HAPI_GeoInfo();
HoudiniHost.getGeoInfo(prAsset.prAssetId, prObjectId, 0, out geo_info);
if (geo_info.partCount == 0)
{
return;
}
HAPI_PartInfo part_info = new HAPI_PartInfo();
HoudiniHost.getPartInfo(prAsset.prAssetId, prObjectId, 0, 0, out part_info);
if (prAsset.prEnableLogging)
{
Debug.Log("Instancer #" + prObjectId + " (" + object_info.name + "): "
+ "points: " + part_info.pointCount);
}
if (part_info.pointCount > 65000)
{
throw new HoudiniError("Point count (" + part_info.pointCount + ") above limit (" + 65000 + ")!");
}
myNumInstances = part_info.pointCount;
}
public void refresh(bool reload_asset)
{
if (prObjectControl == null)
{
Debug.LogError("Why is my object control null on a refresh?");
return;
}
GameObject geo_node = gameObject;
// Get Geo info.
HAPI_GeoInfo geo_info = new HAPI_GeoInfo();
HoudiniHost.getGeoInfo(prAssetId, prObjectId, prGeoId, out geo_info);
if (geo_info.type == HAPI_GeoType.HAPI_GEOTYPE_INPUT)
{
return;
}
if (!reload_asset && !geo_info.hasGeoChanged && !geo_info.hasMaterialChanged)
{
return;
}
if (reload_asset || geo_info.type == HAPI_GeoType.HAPI_GEOTYPE_CURVE)
{
for (int i = 0; i < myParts.Count; ++i)
{
HoudiniAssetUtility.destroyGameObject(myParts[i]);
}
myParts.Clear();
}
if (reload_asset || geo_info.hasGeoChanged)
{
// Initialize our geo control.
init(
geo_info.nodeId, prGeoId, geo_info.name, (HAPI_GeoType)geo_info.type,
geo_info.isEditable, geo_info.isDisplayGeo);
// Set node name.
geo_node.name = prGeoName;
}
if (!geo_info.isDisplayGeo &&
(geo_info.type != HAPI_GeoType.HAPI_GEOTYPE_CURVE &&
!myObjectControl.prAsset.prImportTemplatedGeos &&
geo_info.isTemplated))
{
return;
}
if (geo_info.type == HAPI_GeoType.HAPI_GEOTYPE_CURVE)
{
createAndInitCurve(prNodeId, prObjectId, prGeoId, prIsEditable);
}
else
{
if (reload_asset || geo_info.hasGeoChanged)
{
// Add new geos as needed.
while (myParts.Count < geo_info.partCount)
{
myParts.Add(createPart(myParts.Count));
}
// Remove stale geos.
while (myParts.Count > geo_info.partCount)
{
HoudiniAssetUtility.destroyGameObject(myParts[geo_info.partCount]);
myParts.RemoveAt(geo_info.partCount);
}
}
// Refresh all geos.
for (int i = 0; i < myParts.Count; ++i)
{
myParts[i].GetComponent <HoudiniPartControl>().refresh(
reload_asset, geo_info.hasGeoChanged, geo_info.hasMaterialChanged);
}
// Handle Edit/Paint Nodes
#if !HAPI_PAINT_SUPPORT
if (geo_info.type == HAPI_GeoType.HAPI_GEOTYPE_INTERMEDIATE)
{
// We are limited to using the first part, always.
if (myGeoAttributeManager == null && myParts.Count > 0)
{
const int part_id = 0;
GameObject part_gameobject = myParts[part_id];
HoudiniPartControl part_control = part_gameobject.GetComponent <HoudiniPartControl>();
MeshFilter mesh_filter = part_control.getOrCreateComponent <MeshFilter>();
MeshRenderer mesh_renderer = part_control.getOrCreateComponent <MeshRenderer>();
MeshCollider mesh_collider = part_control.getOrCreateComponent <MeshCollider>();
Mesh mesh = mesh_filter.sharedMesh;
myGeoAttributeManager = ScriptableObject.CreateInstance <HoudiniGeoAttributeManager>();
myGeoAttributeManager.init(mesh, mesh_renderer, mesh_collider, part_gameobject.transform);
// Fetch all point attributes.
string[] point_attribute_names = HoudiniHost.getAttributeNames(
prAssetId, prObjectId, prGeoId, part_id, HAPI_AttributeOwner.HAPI_ATTROWNER_POINT);
foreach (string point_attribute_name in point_attribute_names)
{
if (point_attribute_name == "P")
{
continue;
}
HAPI_AttributeInfo point_attribute_info = HoudiniHost.getAttributeInfo(
prAssetId, prObjectId, prGeoId, part_id, point_attribute_name,
HAPI_AttributeOwner.HAPI_ATTROWNER_POINT);
if (point_attribute_info.storage == HAPI_StorageType.HAPI_STORAGETYPE_INT)
{
int[] data = new int[0];
HoudiniAssetUtility.getAttribute(
prAssetId, prObjectId, prGeoId, part_id,
point_attribute_name,
ref point_attribute_info,
ref data,
HoudiniHost.getAttributeIntData);
HoudiniGeoAttribute attribute =
myGeoAttributeManager.createAttribute(point_attribute_name);
attribute.init(
mesh, point_attribute_name, HoudiniGeoAttribute.Type.INT,
point_attribute_info.tupleSize);
attribute.prOriginalAttributeOwner = HAPI_AttributeOwner.HAPI_ATTROWNER_POINT;
if (data.Length != attribute.prIntData.Length)
{
Debug.LogError("Size mis-match in paint tools.");
}
else
{
for (int i = 0; i < data.Length; ++i)
{
attribute.prIntData[i] = data[i];
}
}
}
else if (point_attribute_info.storage == HAPI_StorageType.HAPI_STORAGETYPE_FLOAT)
{
int tuple_size = point_attribute_info.tupleSize;
float[] data = new float[0];
HoudiniAssetUtility.getAttribute(
prAssetId, prObjectId, prGeoId, part_id,
point_attribute_name,
ref point_attribute_info,
ref data,
HoudiniHost.getAttributeFloatData);
HoudiniGeoAttribute attribute =
myGeoAttributeManager.createAttribute(point_attribute_name);
attribute.init(
mesh, point_attribute_name, HoudiniGeoAttribute.Type.FLOAT,
tuple_size);
attribute.prOriginalAttributeOwner = HAPI_AttributeOwner.HAPI_ATTROWNER_POINT;
// Get Vertex list.
HAPI_PartInfo part_info = new HAPI_PartInfo();
HoudiniHost.getPartInfo(
prAssetId, prObjectId, prGeoId, part_id, out part_info);
int[] vertex_list = new int[part_info.vertexCount];
HoudiniAssetUtility.getArray4Id(
prAssetId, prObjectId, prGeoId, part_id, HoudiniHost.getVertexList,
vertex_list, part_info.vertexCount);
if (part_info.vertexCount * tuple_size != attribute.prFloatData.Length)
{
Debug.LogError("Size mis-match in paint tools.");
}
else
{
for (int i = 0; i < part_info.vertexCount; ++i)
{
for (int tuple = 0; tuple < tuple_size; ++tuple)
{
attribute.prFloatData[i * tuple_size + tuple] =
data[vertex_list[i] * tuple_size + tuple];
}
}
}
}
else if (point_attribute_info.storage == HAPI_StorageType.HAPI_STORAGETYPE_STRING)
{
}
}
}
}
#endif // !HAPI_PAINT_SUPPORT
// Handle script attaching.
if (reload_asset && geo_info.partCount > 0)
{
HAPI_AttributeInfo script_attr_info = new HAPI_AttributeInfo("Unity_Script");
int[] script_attr = new int[0];
HoudiniAssetUtility.getAttribute(
prAssetId, prObjectId, prGeoId, 0, "Unity_Script",
ref script_attr_info, ref script_attr, HoudiniHost.getAttributeStringData);
if (script_attr_info.exists && script_attr_info.owner != HAPI_AttributeOwner.HAPI_ATTROWNER_DETAIL)
{
throw new HoudiniErrorIgnorable("I only understand Unity_Script as detail attributes!");
}
if (script_attr_info.exists && script_attr.Length > 0)
{
string script_to_attach = HoudiniHost.getString(script_attr[0]);
HoudiniAssetUtility.attachScript(geo_node, script_to_attach);
}
}
}
}
public bool refresh( bool reload_asset )
{
bool needs_recook = false;
if ( prObjectControl == null )
{
Debug.LogError( "Why is my object control null on a refresh?" );
return needs_recook;
}
GameObject geo_node = gameObject;
// Get Geo info.
HAPI_GeoInfo geo_info = new HAPI_GeoInfo();
try
{
// If templated geos are off this will error out for templated
// geos because they woudn't have cooked. But we still need to
// get the geo info to see that this is a templated geo and skip it.
HoudiniHost.getGeoInfo( prAssetId, prObjectId, prGeoId, out geo_info );
}
catch ( HoudiniErrorInvalidArgument ) {}
if ( geo_info.type == HAPI_GeoType.HAPI_GEOTYPE_INPUT )
return needs_recook;
if ( geo_info.isTemplated && !prAsset.prImportTemplatedGeos && !geo_info.isEditable )
return needs_recook;
if ( !reload_asset && !geo_info.hasGeoChanged && !geo_info.hasMaterialChanged )
return needs_recook;
if ( reload_asset || geo_info.type == HAPI_GeoType.HAPI_GEOTYPE_CURVE )
{
for ( int i = 0; i < myParts.Count; ++i )
HoudiniAssetUtility.destroyGameObject( myParts[ i ] );
myParts.Clear();
}
if ( reload_asset || geo_info.hasGeoChanged )
{
// Initialize our geo control.
init(
geo_info.nodeId, prGeoId, geo_info.name, (HAPI_GeoType) geo_info.type,
geo_info.isEditable, geo_info.isDisplayGeo );
// Set node name.
geo_node.name = prGeoName;
}
if ( !geo_info.isDisplayGeo &&
( geo_info.type != HAPI_GeoType.HAPI_GEOTYPE_CURVE &&
!myObjectControl.prAsset.prImportTemplatedGeos &&
geo_info.isTemplated ) )
{
return needs_recook;
}
if ( geo_info.type == HAPI_GeoType.HAPI_GEOTYPE_CURVE )
{
createAndInitCurve( prNodeId, prObjectId, prGeoId, prIsEditable );
needs_recook = true;
}
else
{
if ( reload_asset || geo_info.hasGeoChanged )
{
// Add new geos as needed.
while ( myParts.Count < geo_info.partCount )
myParts.Add( createPart( myParts.Count ) );
// Remove stale geos.
while ( myParts.Count > geo_info.partCount )
{
HoudiniAssetUtility.destroyGameObject( myParts[ geo_info.partCount ] );
myParts.RemoveAt( geo_info.partCount );
}
}
// Refresh all geos.
for ( int i = 0; i < myParts.Count; ++i )
myParts[ i ].GetComponent< HoudiniPartControl >().refresh(
reload_asset, geo_info.hasGeoChanged, geo_info.hasMaterialChanged );
// Handle Edit/Paint Nodes
if ( geo_info.type == HAPI_GeoType.HAPI_GEOTYPE_INTERMEDIATE )
{
// Currently, we only support painting on the first part.
const int part_id = 0;
GameObject part_gameobject = myParts[ part_id ];
HoudiniPartControl part_control = part_gameobject.GetComponent< HoudiniPartControl >();
MeshFilter mesh_filter = part_control.getOrCreateComponent< MeshFilter >();
MeshRenderer mesh_renderer = part_control.getOrCreateComponent< MeshRenderer >();
MeshCollider mesh_collider = part_control.getOrCreateComponent< MeshCollider >();
Mesh mesh = mesh_filter.sharedMesh;
// We are limited to using the first part, always.
if ( myGeoAttributeManager == null && myParts.Count > 0 )
{
if ( prAsset.prGeoAttributeManagerMap.contains( getRelativePath() ) )
{
myGeoAttributeManager = prAsset.prGeoAttributeManagerMap.get( getRelativePath() );
myGeoAttributeManager.name = getAbsolutePath() + "/GeoAttributeManager";
myGeoAttributeManager.reInit( mesh, mesh_renderer, mesh_collider, part_gameobject.transform );
}
else
{
myGeoAttributeManager = ScriptableObject.CreateInstance< HoudiniGeoAttributeManager >();
myGeoAttributeManager.name = getAbsolutePath() + "/GeoAttributeManager";
myGeoAttributeManager.init( mesh, mesh_renderer, mesh_collider, part_gameobject.transform );
prAsset.prGeoAttributeManagerMap.add( getRelativePath(), myGeoAttributeManager );
}
// Sync the attributes and see if we need a recook.
if ( myGeoAttributeManager.syncAttributes( prAssetId, prObjectId, prGeoId, part_id, mesh ) )
{
HoudiniAssetUtility.setMesh(
prAssetId, prObjectId, prGeoId,
ref mesh, part_control, myGeoAttributeManager );
needs_recook = true;
}
}
else
{
// Just sync the attributes but don't recook. Setting needs_recook to true here would
// cause infinite cooking.
myGeoAttributeManager.syncAttributes( prAssetId, prObjectId, prGeoId, part_id, mesh );
}
}
// Handle script attaching.
if ( reload_asset && geo_info.partCount > 0 )
{
HAPI_AttributeInfo script_attr_info = new HAPI_AttributeInfo( "Unity_Script" );
int[] script_attr = new int[ 0 ];
HoudiniAssetUtility.getAttribute(
prAssetId, prObjectId, prGeoId, 0, "Unity_Script",
ref script_attr_info, ref script_attr, HoudiniHost.getAttributeStringData );
if ( script_attr_info.exists && script_attr_info.owner != HAPI_AttributeOwner.HAPI_ATTROWNER_DETAIL )
throw new HoudiniErrorIgnorable( "I only understand Unity_Script as detail attributes!" );
if ( script_attr_info.exists && script_attr.Length > 0 )
{
string script_to_attach = HoudiniHost.getString( script_attr[ 0 ] );
HoudiniAssetUtility.attachScript( geo_node, script_to_attach );
}
}
}
return needs_recook;
}
public void instanceObjects(HoudiniProgressBar progress_bar)
{
try
{
destroyChildren();
HAPI_ObjectInfo object_info = prAsset.prObjects[prObjectId];
// Get Detail info.
HAPI_GeoInfo geo_info = new HAPI_GeoInfo();
HoudiniHost.getGeoInfo(prAsset.prAssetId, prObjectId, 0, out geo_info);
if (geo_info.partCount == 0)
{
return;
}
cacheNumInstances();
HAPI_Transform[] instance_transforms = new HAPI_Transform[myNumInstances];
Utility.getArray4Id(prAsset.prAssetId, prObjectId, 0, HAPI_RSTOrder.HAPI_SRT,
HoudiniHost.getInstanceTransforms, instance_transforms, myNumInstances);
// Get scale point attributes.
HAPI_AttributeInfo scale_attr_info = new HAPI_AttributeInfo("scale");
float[] scale_attr = new float[0];
Utility.getAttribute(prAsset.prAssetId, prObjectId, 0, 0, "scale",
ref scale_attr_info, ref scale_attr, HoudiniHost.getAttributeFloatData);
if (scale_attr_info.exists && scale_attr_info.owner != HAPI_AttributeOwner.HAPI_ATTROWNER_POINT)
{
throw new HoudiniErrorIgnorable("I only understand scale as point attributes!");
}
if (scale_attr_info.exists && scale_attr.Length != myNumInstances * 3)
{
throw new HoudiniError(
"Unexpected scale array length found for asset: " + prAsset.prAssetId + "!\n" +
"Expected length of: " + myNumInstances * 3 + " but given: " + scale_attr.Length);
}
HAPI_AttributeInfo script_attr_info = new HAPI_AttributeInfo("Unity_Script");
int[] script_attr = new int[0];
Utility.getAttribute(prAsset.prAssetId, prObjectId, 0, 0, "Unity_Script",
ref script_attr_info, ref script_attr, HoudiniHost.getAttributeStringData);
if (script_attr_info.exists && script_attr_info.owner != HAPI_AttributeOwner.HAPI_ATTROWNER_POINT)
{
throw new HoudiniErrorIgnorable("I only understand Unity_Script as point attributes!");
}
if (script_attr_info.exists && script_attr.Length != myNumInstances)
{
throw new HoudiniError("Unexpected Unity_Script array length found for asset: " + prAsset.prAssetId + "!");
}
int[] instance_attr = null;
int[] name_attr = null;
getInstanceAndNameAttrs(out instance_attr, out name_attr);
progress_bar.prTotal = myNumInstances;
List <int> exclusion_list = new List <int>();
instanceOverriddenObjects(myNumInstances, exclusion_list);
List <string> unique_instantiated_names = new List <string>();
HoudiniInstancerPersistentData persistent_data = prPersistentData;
if (persistent_data.variationChoice.Count != myNumInstances)
{
if (myNumInstances > persistent_data.variationChoice.Count)
{
int difference = myNumInstances - persistent_data.variationChoice.Count;
for (int ii = 0; ii < difference; ii++)
{
persistent_data.variationChoice.Add(-1);
}
}
else
{
int difference = persistent_data.variationChoice.Count - myNumInstances;
persistent_data.variationChoice.RemoveRange(
persistent_data.variationChoice.Count - difference, difference);
}
}
bool liveTransformPropagationSetting = false;
bool syncAssetTransformSetting = false;
bool enableCooking = true;
for (int ii = 0; ii < myNumInstances; ++ii)
{
if (exclusion_list.Contains(ii))
{
continue;
}
GameObject objToInstantiate = null;
if (instance_attr.Length > 0 || name_attr.Length > 0)
{
if (name_attr.Length > 0)
{
string obj_name = HoudiniHost.getString(name_attr[ii]);
int object_index = prAsset.findObjectByName(obj_name);
if (object_index >= 0)
{
objToInstantiate = prAsset.prGameObjects[object_index];
}
else
{
objToInstantiate = prAsset.findPartByName(obj_name, true);
}
if (objToInstantiate == null)
{
objToInstantiate = GameObject.Find(obj_name);
}
}
else
{
string instanceObjectPath = HoudiniHost.getString(instance_attr[ii]);
string[] pathItems = instanceObjectPath.Split('/');
string instanceObjectName = pathItems[pathItems.Length - 1];
int objectIndex = prAsset.findObjectByName(instanceObjectName);
if (objectIndex >= 0)
{
objToInstantiate = prAsset.prGameObjects[objectIndex];
}
else
{
objToInstantiate = GameObject.Find(instanceObjectName);
}
}
if (objToInstantiate != null)
{
HoudiniAsset hapi_asset = objToInstantiate.GetComponent <HoudiniAsset>();
if (hapi_asset != null)
{
liveTransformPropagationSetting = hapi_asset.prTransformChangeTriggersCooks;
syncAssetTransformSetting = hapi_asset.prPushUnityTransformToHoudini;
enableCooking = hapi_asset.prEnableCooking;
hapi_asset.prTransformChangeTriggersCooks = false;
hapi_asset.prPushUnityTransformToHoudini = false;
hapi_asset.prEnableCooking = false;
}
}
}
else if (object_info.objectToInstanceId >= 0)
{
objToInstantiate = prAsset.prGameObjects[object_info.objectToInstanceId];
}
if (objToInstantiate != null)
{
// Set progress bar information.
progress_bar.prCurrentValue = ii;
progress_bar.prMessage = "Instancing: " + objToInstantiate.name + " (" + ii + " of " + myNumInstances + ")";
progress_bar.displayProgressBar();
if (!unique_instantiated_names.Contains(objToInstantiate.name))
{
unique_instantiated_names.Add(objToInstantiate.name);
}
Vector3 pos = new Vector3();
// Apply object transforms.
//
// Axis and Rotation conversions:
// Note that Houdini's X axis points in the opposite direction that Unity's does. Also, Houdini's
// rotation is right handed, whereas Unity is left handed. To account for this, we need to invert
// the x coordinate of the translation, and do the same for the rotations (except for the x rotation,
// which doesn't need to be flipped because the change in handedness AND direction of the left x axis
// causes a double negative - yeah, I know).
pos[0] = -instance_transforms[ii].position[0];
pos[1] = instance_transforms[ii].position[1];
pos[2] = instance_transforms[ii].position[2];
Quaternion quat = new Quaternion(instance_transforms[ii].rotationQuaternion[0],
instance_transforms[ii].rotationQuaternion[1],
instance_transforms[ii].rotationQuaternion[2],
instance_transforms[ii].rotationQuaternion[3]);
Vector3 euler = quat.eulerAngles;
euler.y = -euler.y;
euler.z = -euler.z;
Vector3 scale = new Vector3(instance_transforms[ii].scale[0],
instance_transforms[ii].scale[1],
instance_transforms[ii].scale[2]);
Matrix4x4 local_mat = new Matrix4x4();
local_mat.SetTRS(pos, Quaternion.Euler(euler), scale);
// TODO: Now this *should* be the transform.localToWorldMatrix
// but for some reason, after a scene load, we pick up compensating
// factors in the local transform that cancel out the transform on the
// asset. For now just use the asset's transform as the parent matrix.
Matrix4x4 parent_mat = prAsset.transform.localToWorldMatrix;
Matrix4x4 global_mat = parent_mat * local_mat;
euler = HoudiniAssetUtility.getQuaternion(global_mat).eulerAngles;
pos = HoudiniAssetUtility.getPosition(global_mat);
scale = HoudiniAssetUtility.getScale(global_mat);
//mat.SetTRS( pos,
string script_to_attach = "";
if (script_attr_info.exists)
{
script_to_attach = HoudiniHost.getString(script_attr[ii]);
}
instanceObject(objToInstantiate,
pos,
euler,
ii,
scale_attr_info.exists,
scale,
script_attr_info.exists,
script_to_attach);
HoudiniAsset hapi_asset = objToInstantiate.GetComponent <HoudiniAsset>();
if (hapi_asset != null)
{
hapi_asset.prTransformChangeTriggersCooks = liveTransformPropagationSetting;
hapi_asset.prPushUnityTransformToHoudini = syncAssetTransformSetting;
hapi_asset.prEnableCooking = enableCooking;
}
}
}
updateUniqueInstantiatedNames(unique_instantiated_names);
}
catch (HoudiniError error)
{
Debug.LogWarning(error.ToString());
return;
}
}
public bool refresh(bool reload_asset, HAPI_ObjectInfo object_info)
{
bool needs_recook = false;
if (reload_asset)
{
for (int i = 0; i < myGeos.Count; ++i)
{
if (myGeos[i])
{
HoudiniAssetUtility.destroyGameObject(myGeos[i]);
}
}
myGeos.Clear();
}
if (reload_asset || object_info.haveGeosChanged)
{
// Get the GeoInfos of the display geo node
HAPI_GeoInfo display_geo_info = HoudiniHost.getDisplayGeoInfo(prObjectId);
int GeoCount = object_info.geoCount = 1;
// Add new geos as needed.
while (myGeos.Count < GeoCount)
{
myGeos.Add(createGeo(display_geo_info.nodeId));
}
int node_id = object_info.nodeId;
if (prAsset.prNodeInfo.type == HAPI_NodeType.HAPI_NODETYPE_SOP)
{
node_id = display_geo_info.nodeId;
}
// Look for editable nodes inside the network/the object
const bool recursive = true;
int[] editable_networks = HoudiniHost.getChildNodeList(
node_id,
(int)HAPI_NodeType.HAPI_NODETYPE_SOP,
(int)HAPI_NodeFlags.HAPI_NODEFLAGS_EDITABLE,
recursive);
// Add the editable nodes to it
for (int n = 0; n < editable_networks.Length; n++)
{
// The editable node has to be cooked first
HoudiniHost.cookNode(editable_networks[n]);
HAPI_GeoInfo editGeoInfo = HoudiniHost.getGeoInfo(editable_networks[n]);
myGeos.Add(createGeo(editGeoInfo.nodeId));
GeoCount++;
}
// Remove stale geos.
while (myGeos.Count > GeoCount)
{
HoudiniAssetUtility.destroyGameObject(myGeos[GeoCount]);
myGeos.RemoveAt(GeoCount);
}
// Refresh all geos.
for (int i = 0; i < myGeos.Count; ++i)
{
needs_recook |= myGeos[i].GetComponent <HoudiniGeoControl>().refresh(reload_asset);
}
}
return(needs_recook);
}
