private void assignUnityTag() { HAPI_AttributeInfo tag_attr_info = new HAPI_AttributeInfo(HoudiniHost.prUnityTagAttribName); int[] tag_attr = new int[0]; HoudiniAssetUtility.getAttribute( prAssetId, prObjectId, prGeoId, prPartId, HoudiniHost.prUnityTagAttribName, ref tag_attr_info, ref tag_attr, HoudiniHost.getAttributeStringData); if (tag_attr_info.exists) { string tag = HoudiniHost.getString(tag_attr[0]); if (tag != string.Empty) { try { gameObject.tag = tag; } catch { Debug.LogWarning("Unity Tag " + tag + " is not defined!"); } } } }
public void cacheStringsFromHost() { myParmsUndoInfo.parmStringValues = new string[prParmStringValueCount]; // For each string parameter, cache the string from the host for (int i = 0; i < prParms.Length; ++i) { HAPI_ParmInfo parm = prParms[i]; // Cache the strings in the parm info struct. myParmInfoStrings[i].cacheStrings(parm); if (parm.isString()) { string[] strings = new string[parm.size]; for (int p = 0; p < parm.size; ++p) { int values_index = parm.stringValuesIndex + p; string string_value = HoudiniHost.getString(prParmStringHandles[values_index]); strings[p] = string_value; myParmsUndoInfo.parmStringValues[values_index] = string_value; } setParmStrings(parm, strings); } } // Cache the choice list strings. for (int i = 0; i < myParmChoiceLists.Length; ++i) { myParmChoiceInfoStrings[i].cacheStrings(myParmChoiceLists[i]); } }
public void cacheStringsFromHost() { myParmsUndoInfo.parmStringValues = new string[prParmStringValueCount]; // For each string parameter, cache the string from the host foreach (HAPI_ParmInfo parm in prParms) { if (parm.isString()) { myParmStrings[parm.id] = new string[parm.size]; for (int p = 0; p < parm.size; ++p) { int values_index = parm.stringValuesIndex + p; string string_value = HoudiniHost.getString(prParmStringValues[values_index]); myParmStrings[parm.id][p] = string_value; myParmsUndoInfo.parmStringValues[values_index] = string_value; } } } }
public void syncPointsWithParm() { try { // Find the parm. HAPI_ParmInfo coords_parm_info = prParms.findParm("coords"); string point_list = HoudiniHost.getString(prParms.prParmStringHandles[coords_parm_info.stringValuesIndex]); if (point_list == null) { return; } // Clear all existing points. prPoints.Clear(); // Parse parm value for the points. string [] point_split = point_list.Split(new char [] { ' ' }); for (int i = 0; i < point_split.Length; ++i) { string vec_str = point_split[i]; string [] vec_split = vec_str.Split(new char [] { ',' }); if (vec_split.Length == 3) { Vector3 vec = new Vector3(); vec.x = (float)-System.Convert.ToDouble(vec_split[0]); vec.y = (float)System.Convert.ToDouble(vec_split[1]); vec.z = (float)System.Convert.ToDouble(vec_split[2]); prPoints.Add(vec); } } } catch {} }
public bool areValuesEqualToHoudini() { if (prControl == null) { return(false); } if (prControl.prAsset == null) { return(false); } if (prControl.prAssetId < 0) { return(false); } // Get the node info again HAPI_NodeInfo node_info = HoudiniHost.getNodeInfo(prControl.prNodeId); if (prParmCount != node_info.parmCount) { return(false); } if (prParmIntValueCount != node_info.parmIntValueCount) { return(false); } if (prParmFloatValueCount != node_info.parmFloatValueCount) { return(false); } if (prParmStringValueCount != node_info.parmStringValueCount) { return(false); } if (prParmChoiceCount != node_info.parmChoiceCount) { return(false); } // Get parameter int values. int[] houdini_int_values = new int[prParmIntValueCount]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmIntValues, houdini_int_values, prParmIntValueCount); if (prParmIntValues.Length != houdini_int_values.Length) { return(false); } for (int i = 0; i < prParmIntValueCount; ++i) { if (!prParmIntValues[i].Equals(houdini_int_values[i])) { return(false); } } // Get parameter float values. float[] houdini_float_values = new float[prParmFloatValueCount]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmFloatValues, houdini_float_values, prParmFloatValueCount); if (prParmFloatValues.Length != houdini_float_values.Length) { return(false); } for (int i = 0; i < prParmFloatValueCount; ++i) { if (!prParmFloatValues[i].Equals(houdini_float_values[i])) { return(false); } } // Get parameter string (handle) values. int[] houdini_string_values = new int[prParmStringValueCount]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmStringValues, houdini_string_values, prParmStringValueCount); if (prParmStringValues.Length != houdini_string_values.Length) { return(false); } for (int i = 0; i < prParmStringValueCount; ++i) { if (!HoudiniHost.getString(prParmStringValues[i]).Equals( HoudiniHost.getString(houdini_string_values[i]))) { return(false); } } return(true); }
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 void instanceObjects(HoudiniProgressBar progress_bar) { try { destroyChildren(); HAPI_ObjectInfo object_info = HoudiniHost.getObjectInfo(prObjectId); // Get Detail info. HAPI_GeoInfo geo_info = HoudiniHost.getDisplayGeoInfo(prObjectId); if (geo_info.partCount == 0) { return; } cacheNumInstances(); HAPI_Transform[] instance_transforms = new HAPI_Transform[myNumInstances]; Utility.getArray2Id( geo_info.nodeId, 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( geo_info.nodeId, 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( geo_info.nodeId, 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 i = 0; i < myNumInstances; ++i) { if (exclusion_list.Contains(i)) { continue; } GameObject obj_to_instance = null; if (instance_attr.Length > 0 || name_attr.Length > 0) { if (name_attr.Length > 0) { string obj_name = HoudiniHost.getString(name_attr[i]); int object_index = prAsset.findObjectByName(obj_name); if (object_index >= 0) { obj_to_instance = prAsset.prGameObjects[object_index]; } else { obj_to_instance = prAsset.findPartByName(obj_name, true); } if (obj_to_instance == null) { obj_to_instance = GameObject.Find(obj_name); } } else { string instanceObjectPath = HoudiniHost.getString(instance_attr[i]); string [] pathItems = instanceObjectPath.Split('/'); string instanceObjectName = pathItems[pathItems.Length - 1]; int objectIndex = prAsset.findObjectByName(instanceObjectName); if (objectIndex >= 0) { obj_to_instance = prAsset.prGameObjects[objectIndex]; } else { obj_to_instance = GameObject.Find(instanceObjectName); } } if (obj_to_instance != null) { HoudiniAsset hapi_asset = obj_to_instance.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) { int object_to_instance_idx = prAsset.findObjectByNodeId(object_info.objectToInstanceId); if (object_to_instance_idx >= 0) { obj_to_instance = prAsset.prGameObjects[object_to_instance_idx]; } } if (obj_to_instance != null) { // Set progress bar information. progress_bar.prCurrentValue = i; progress_bar.prMessage = "Instancing: " + obj_to_instance.name + " (" + i + " of " + myNumInstances + ")"; progress_bar.displayProgressBar(); if (!unique_instantiated_names.Contains(obj_to_instance.name)) { unique_instantiated_names.Add(obj_to_instance.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[i].position[0]; pos[1] = instance_transforms[i].position[1]; pos[2] = instance_transforms[i].position[2]; Quaternion quat = new Quaternion(instance_transforms[i].rotationQuaternion[0], instance_transforms[i].rotationQuaternion[1], instance_transforms[i].rotationQuaternion[2], instance_transforms[i].rotationQuaternion[3]); Vector3 euler = quat.eulerAngles; euler.y = -euler.y; euler.z = -euler.z; Vector3 scale = new Vector3(instance_transforms[i].scale[0], instance_transforms[i].scale[1], instance_transforms[i].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[i]); } instanceObject(obj_to_instance, pos, euler, i, scale_attr_info.exists, scale, script_attr_info.exists, script_to_attach); HoudiniAsset hapi_asset = obj_to_instance.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 ) { 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 bool sync( int asset_id, int object_id, int geo_id, int part_id, Mesh mesh, HAPI_AttributeInfo attribute_info) { int tuple_size = attribute_info.tupleSize; prStorageType = attribute_info.storage; prTupleSize = tuple_size; myVertexCount = mesh.vertexCount; Type type = prType; if (myInitializedVertexCount != mesh.vertexCount) { int new_size = mesh.vertexCount * tuple_size; if (type == Type.BOOL || type == Type.INT) { System.Array.Resize <int>(ref myIntData, new_size); } else if (type == Type.FLOAT) { System.Array.Resize <float>(ref myFloatData, new_size); } else if (type == Type.STRING) { System.Array.Resize <string>(ref myStringData, new_size); } } if (myInitializedVertexCount < mesh.vertexCount) { // Get Vertex list. HAPI_PartInfo part_info = new HAPI_PartInfo(); HoudiniHost.getPartInfo( asset_id, object_id, geo_id, part_id, out part_info); int[] vertex_list = new int[part_info.vertexCount]; HoudiniAssetUtility.getArray4Id( asset_id, object_id, geo_id, part_id, HoudiniHost.getVertexList, vertex_list, part_info.vertexCount); if (type == Type.BOOL || type == Type.INT) { int[] data = new int[0]; HoudiniAssetUtility.getAttribute( asset_id, object_id, geo_id, part_id, myName, ref attribute_info, ref data, HoudiniHost.getAttributeIntData); for (int i = myInitializedVertexCount; i < part_info.vertexCount; ++i) { for (int tuple = 0; tuple < tuple_size; ++tuple) { prIntData[i * tuple_size + tuple] = data[vertex_list[i] * tuple_size + tuple]; } } } else if (type == Type.FLOAT) { float[] data = new float[0]; HoudiniAssetUtility.getAttribute( asset_id, object_id, geo_id, part_id, myName, ref attribute_info, ref data, HoudiniHost.getAttributeFloatData); for (int i = myInitializedVertexCount; i < part_info.vertexCount; ++i) { for (int tuple = 0; tuple < tuple_size; ++tuple) { prFloatData[i * tuple_size + tuple] = data[vertex_list[i] * tuple_size + tuple]; } } } else if (type == Type.STRING) { int[] data = new int[0]; HoudiniAssetUtility.getAttribute( asset_id, object_id, geo_id, part_id, myName, ref attribute_info, ref data, HoudiniHost.getAttributeStringData); for (int i = myInitializedVertexCount; i < part_info.vertexCount; ++i) { for (int tuple = 0; tuple < tuple_size; ++tuple) { prStringData[i * tuple_size + tuple] = HoudiniHost.getString(data[vertex_list[i] * tuple_size + tuple]); } } } } // If some of the data was already bool needs_recook = myInitializedVertexCount > 0; myInitializedVertexCount = mesh.vertexCount; return(needs_recook); }