Exemple #1
0
 // Set into dictionary to later be set into the host
 public void setParmStrings(HAPI_ParmInfo parm, string[] strings)
 {
     for (int i = 0; i < parm.size; ++i)
     {
         myParmStringValues[parm.stringValuesIndex + i] = strings[i];
     }
 }
    public void initDefaultParameters()
    {
        // Set curve defaults.
        // TODO: Make the defaults editable.
        // TODO: Make generic update parm value functions.

        try
        {
            HAPI_ParmInfo primitive_type_parm            = prParms.findParm("type");
            HAPI_ParmInfo method_parm                    = prParms.findParm("method");
            int           primitive_type_parm_default    = HoudiniHost.prCurvePrimitiveTypeDefault;
            int           method_parm_default            = HoudiniHost.prCurveMethodDefault;
            int           primitive_type_parm_int_values = primitive_type_parm.intValuesIndex;
            int           method_parm_int_values         = method_parm.intValuesIndex;

            prParms.prParmIntValues[primitive_type_parm_int_values] = primitive_type_parm_default;
            prParms.prParmIntValues[method_parm_int_values]         = method_parm_default;

            int[] temp_int_values = new int[1];

            temp_int_values[0] = primitive_type_parm_default;
            HoudiniHost.setParmIntValues(prControl.prNodeId, temp_int_values, primitive_type_parm.intValuesIndex, 1);

            temp_int_values[0] = method_parm_default;
            HoudiniHost.setParmIntValues(prControl.prNodeId, temp_int_values, method_parm.intValuesIndex, 1);

            HoudiniHost.cookAsset(prControl.prAsset.prAssetId, prControl.prAsset.prSplitGeosByGroup);
        }
        catch {}
    }
Exemple #3
0
    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]);
        }
    }
Exemple #4
0
    public void setChangedParameterIntoHost(int id)
    {
        if (prControl == null)
        {
            return;
        }
        if (prControl.prAsset == null)
        {
            return;
        }

        if (id == -1)
        {
            return;
        }

        HAPI_ParmInfo parm = findParm(id);

        if ((HAPI_ParmType)parm.type == HAPI_ParmType.HAPI_PARMTYPE_MULTIPARMLIST)
        {
            int[] values = new int[1];
            HoudiniHost.getParmIntValues(prControl.prNodeId, values, parm.intValuesIndex, 1);

            int difference = prParmIntValues[parm.intValuesIndex] - values[0];
            if (difference > 0)
            {
                appendMultiparmInstances(parm, difference);
            }
            else if (difference < 0)
            {
                removeMultiparmInstances(parm, -difference);
            }

            getParameterValues();
        }
        else if (parm.isNode())
        {
            setChangedNodeParameterIntoHost(id);
        }
        else if (parm.isFloat())
        {
            float[] values = new float[parm.size];
            Array.Copy(prParmFloatValues, parm.floatValuesIndex, values, 0, parm.size);
            HoudiniHost.setParmFloatValues(prControl.prNodeId, values, parm.floatValuesIndex, parm.size);
        }
        else if (parm.isInt() && (HAPI_ParmType)parm.type != HAPI_ParmType.HAPI_PARMTYPE_MULTIPARMLIST)
        {
            int[] values = new int[parm.size];
            Array.Copy(prParmIntValues, parm.intValuesIndex, values, 0, parm.size);
            HoudiniHost.setParmIntValues(prControl.prNodeId, values, parm.intValuesIndex, parm.size);
        }
        else if (parm.isString())
        {
            string[] strings = getParmStrings(parm);
            for (int p = 0; p < parm.size; ++p)
            {
                HoudiniHost.setParmStringValue(prControl.prNodeId, strings[p], parm.id, p);
            }
        }
    }
Exemple #5
0
 public void cacheStrings(HAPI_ParmInfo parm_info)
 {
     typeInfo     = parm_info.typeInfo;
     name         = parm_info.name;
     label        = parm_info.label;
     templateName = parm_info.templateName;
     help         = parm_info.help;
 }
Exemple #6
0
 // This will retrieve the cached copy of the string
 public string[] getParmStrings(HAPI_ParmInfo parm)
 {
     string[] strings = new string[parm.size];
     for (int i = 0; i < parm.size; ++i)
     {
         strings[i] = myParmStringValues[parm.stringValuesIndex + i];
     }
     return(strings);
 }
    public float getParmFloatValue(string name, int index)
    {
        HAPI_ParmInfo parm_info = myAssetParms.findParm(name);

        if (parm_info.isFloat())
        {
            return(myAssetParms.prParmFloatValues[parm_info.floatValuesIndex + index]);
        }

        throw new HoudiniErrorInvalidArgument(name + " is not a float!");
    }
    public string getParmStringValue(string name, int index)
    {
        HAPI_ParmInfo parm_info = myAssetParms.findParm(name);

        if (parm_info.isString())
        {
            return(myAssetParms.getParmStrings(parm_info)[index]);
        }

        throw new HoudiniErrorInvalidArgument(name + " is not a string!");
    }
    public void setParmStringValue(string name, int index, string value)
    {
        HAPI_ParmInfo parm_info = myAssetParms.findParm(name);

        if (!parm_info.isString())
        {
            throw new HoudiniErrorInvalidArgument(name + " is not a string!");
        }

        HoudiniHost.setParmStringValue(myAsset.prNodeId, value, parm_info.id, index);

        myAsset.buildClientSide();
    }
    public void setParmFloatValue(string name, int index, float value)
    {
        HAPI_ParmInfo parm_info = myAssetParms.findParm(name);

        if (!parm_info.isFloat())
        {
            throw new HoudiniErrorInvalidArgument(name + " is not a float!");
        }

        int values_index = parm_info.floatValuesIndex + index;

        float[] float_value = { value };

        HoudiniHost.setParmFloatValues(myAsset.prNodeId, float_value, values_index, 1);

        myAsset.buildClientSide();
    }
Exemple #11
0
    public void reset()
    {
        // Please keep these in the same order and grouping as their declarations at the top.

        // Assets -------------------------------------------------------------------------------------------------------

        prControl = null;

        // Parameters -----------------------------------------------------------------------------------------------

        prEditable = true;

        prParmCount            = 0;
        prParmIntValueCount    = 0;
        prParmFloatValueCount  = 0;
        prParmStringValueCount = 0;
        prParmChoiceCount      = 0;

        prParms             = new HAPI_ParmInfo[0];
        prParmIntValues     = new int[0];
        prParmFloatValues   = new float[0];
        prParmStringHandles = new HAPI_StringHandle[0];
        prParmChoiceLists   = new HAPI_ParmChoiceInfo[0];

        myParmInfoStrings       = new HAPI_ParmInfoStrings[0];
        myParmChoiceInfoStrings = new HAPI_ParmChoiceInfoStrings[0];

        myParmStringValues = new string[0];

        prLastChangedParmId = -1;

        myParmsUndoInfo = null;

        prFolderListSelections   = new List <int>();
        prFolderListSelectionIds = new List <int>();
        prFolderListSelections.Add(0);
        prFolderListSelectionIds.Add(-1);

        // Control -------------------------------------------------------------------------------------------------

        myPostSerialization    = true;
        myValuesEqualToHoudini = false;
    }
    public void appendMultiparmInstances(HAPI_ParmInfo multiparm, int num_instances)
    {
        if (prControl == null)
        {
            return;
        }
        if (prControl.prAsset == null)
        {
            return;
        }

        int insert_position = multiparm.instanceCount + multiparm.instanceStartOffset;

        for (int i = 0; i < num_instances; ++i)
        {
            HoudiniHost.insertMultiparmInstance(
                prControl.prNodeId,
                multiparm.id,                 // The multiparm list
                insert_position + i);
        }
    }
    public void removeMultiparmInstances(HAPI_ParmInfo multiparm, int num_instances)
    {
        if (prControl == null)
        {
            return;
        }
        if (prControl.prAsset == null)
        {
            return;
        }

        int first_removed_instance = multiparm.instanceCount - num_instances + multiparm.instanceStartOffset;

        for (int i = 0; i < num_instances; ++i)
        {
            HoudiniHost.removeMultiparmInstance(
                prControl.prNodeId,
                multiparm.id,                 // The multiparm list
                first_removed_instance);
        }
    }
    public void setParmIntValue(string name, int index, int value)
    {
        HAPI_ParmInfo parm_info = myAssetParms.findParm(name);

        if (!parm_info.isInt())
        {
            throw new HoudiniErrorInvalidArgument(name + " is not an int!");
        }

        int values_index = parm_info.intValuesIndex + index;

        int[] int_value = { value };

        if (myAsset.prAssetId < 0)
        {
            myAsset.buildClientSide();
        }

        HoudiniHost.setParmIntValues(myAsset.prNodeId, int_value, values_index, 1);

        myAsset.buildClientSide();
    }
Exemple #15
0
    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 ParmType getParmType(string name)
    {
        HAPI_ParmInfo parm_info = myAssetParms.findParm(name);

        if (parm_info.isInt())
        {
            return(ParmType.INT);
        }
        if (parm_info.isFloat())
        {
            return(ParmType.FLOAT);
        }
        if (parm_info.isString())
        {
            return(ParmType.STRING);
        }
        if (parm_info.isNonValue())
        {
            return(ParmType.IMMUTABLE);
        }

        return(ParmType.INVALID);
    }
Exemple #17
0
    public void setChangedNodeParameterIntoHost(int id)
    {
        HAPI_ParmInfo parm = findParm(id);

        if (id >= myParmInputs.Length)
        {
            Array.Resize(ref myParmInputs, id + 1);
        }

        // Take care of old input node.
        if (myParmInputs[id].inputObject)
        {
            HoudiniHost.setParmNodeValue(prControl.prNodeId, parm.name, -1);
            if (myParmInputs[id].inputObject.GetComponent <HoudiniControl>())
            {
                var houdini_control = myParmInputs[id].inputObject.GetComponent <HoudiniControl>();
                houdini_control.prAsset.removeDownstreamAsset(myControl.prAsset);
            }
            else if (HoudiniHost.isNodeValid(
                         myParmInputs[id].inputNodeId,
                         myParmInputs[id].inputNodeUniqueId))
            {
                HoudiniHost.deleteNode(myParmInputs[id].inputNodeId);
            }

            myParmInputs[id].inputObject = null;
        }

        if (!myParmInputs[id].newInputObject)
        {
            return;
        }

        myParmInputs[id].inputObject = myParmInputs[id].newInputObject;
        setNodeParameterIntoHost(id);
    }
Exemple #18
0
    public bool setNodeParameterIntoHost(int id)
    {
        HAPI_ParmInfo parm = findParm(id);

        var parm_input = myParmInputs[id];

        if (!parm_input.inputObject)
        {
            return(false);
        }

        // Create new input node.
        GameObject     input_object    = parm_input.inputObject;
        HoudiniControl houdini_control = input_object.GetComponent <HoudiniControl>();
        MeshFilter     mesh_filter     = input_object.GetComponent <MeshFilter>();

        if (houdini_control &&
            houdini_control.prAsset.gameObject.GetComponentInChildren <HoudiniGeoControl>())
        {
            if (!houdini_control.prAsset.isAssetValid())
            {
                houdini_control.prAsset.buildAll();
            }

            HoudiniGeoControl geo_control =
                houdini_control.prAsset.gameObject.GetComponentInChildren <HoudiniGeoControl>();
            parm_input.inputNodeId = geo_control.prNodeId;

            // Add ourselves to our input asset's downstream nodes so when it cooks we cook.
            houdini_control.prAsset.addDownstreamAsset(myControl.prAsset);
        }
        else if (houdini_control &&
                 input_object.GetComponent <HoudiniAssetCurve>())
        {
            if (!houdini_control.prAsset.isAssetValid())
            {
                houdini_control.prAsset.buildAll();
            }

            parm_input.inputNodeId = houdini_control.prNodeId;

            // Add ourselves to our input asset's downstream nodes so when it cooks we cook.
            houdini_control.prAsset.addDownstreamAsset(myControl.prAsset);
        }
        else if (mesh_filter && mesh_filter.sharedMesh)
        {
            // We need to remove spaces in the input name
            string inputName = input_object.name.Replace(' ', '_');

            parm_input.inputNodeId = HoudiniHost.createInputNode(inputName);
            Mesh mesh = mesh_filter.sharedMesh;
            HoudiniAssetUtility.setMesh(
                parm_input.inputNodeId, 0, parm_input.inputNodeId, ref mesh, null, null);

            // Set the asset transform from the source GameObject transform.
            HAPI_TransformEuler trans =
                HoudiniAssetUtility.getHapiTransform(input_object.transform.localToWorldMatrix);
            HAPI_NodeInfo input_node_info = HoudiniHost.getNodeInfo(parm_input.inputNodeId);
            HoudiniHost.setObjectTransform(input_node_info.parentId, ref trans);
        }
        else
        {
            return(false);
        }

        HAPI_NodeInfo node_info = HoudiniHost.getNodeInfo(parm_input.inputNodeId);

        parm_input.inputNodeUniqueId = node_info.uniqueHoudiniNodeId;

        // Assign node parm input.
        HoudiniHost.setParmNodeValue(prControl.prNodeId, parm.name, parm_input.inputNodeId);

        myParmInputs[id] = parm_input;

        return(true);
    }
Exemple #19
0
    public void getParameterValues()
    {
        if (prControl == null)
        {
            return;
        }
        if (prControl.prAsset == null)
        {
            return;
        }
        if (prControl.prAssetId < 0)
        {
            return;
        }

        if (myPostSerialization)
        {
            myValuesEqualToHoudini = areValuesEqualToHoudini();
        }
        else
        {
            myValuesEqualToHoudini = true;
        }

        // Create undo info if it hasn't been created already
        if (myParmsUndoInfo == null)
        {
            myParmsUndoInfo = ScriptableObject.CreateInstance <HoudiniParmsUndoInfo>();
        }

        // Get the node info again
        HAPI_NodeInfo node_info = HoudiniHost.getNodeInfo(prControl.prNodeId);

        prParmCount            = node_info.parmCount;
        prParmIntValueCount    = node_info.parmIntValueCount;
        prParmFloatValueCount  = node_info.parmFloatValueCount;
        prParmStringValueCount = node_info.parmStringValueCount;
        prParmChoiceCount      = node_info.parmChoiceCount;

        // Get all parameters.
        prParms           = new HAPI_ParmInfo[prParmCount];
        myParmInfoStrings = new HAPI_ParmInfoStrings[prParmCount];
        if (myParmInputs == null)
        {
            myParmInputs = new HAPI_ParmInput[prParmCount];
        }
        HoudiniAssetUtility.getArray1Id(prControl.prNodeId, HoudiniHost.getParameters, prParms, prParmCount);

        // Get parameter int values.
        prParmIntValues = new int[prParmIntValueCount];
        HoudiniAssetUtility.getArray1Id(
            prControl.prNodeId, HoudiniHost.getParmIntValues, prParmIntValues, prParmIntValueCount);

        myParmsUndoInfo.parmIntValues = new int[prParmIntValueCount];
        Array.Copy(prParmIntValues, myParmsUndoInfo.parmIntValues, prParmIntValueCount);

        // Get parameter float values.
        prParmFloatValues = new float[prParmFloatValueCount];
        HoudiniAssetUtility.getArray1Id(
            prControl.prNodeId, HoudiniHost.getParmFloatValues, prParmFloatValues, prParmFloatValueCount);

        myParmsUndoInfo.parmFloatValues = new float[prParmFloatValueCount];
        Array.Copy(prParmFloatValues, myParmsUndoInfo.parmFloatValues, prParmFloatValueCount);

        // Get parameter string (handle) values.
        prParmStringHandles = new int[prParmStringValueCount];
        myParmStringValues  = new string[prParmStringValueCount];
        HoudiniAssetUtility.getArray1Id(
            prControl.prNodeId, HoudiniHost.getParmStringValues, prParmStringHandles, prParmStringValueCount);

        // Get parameter choice lists.
        prParmChoiceLists       = new HAPI_ParmChoiceInfo[prParmChoiceCount];
        myParmChoiceInfoStrings = new HAPI_ParmChoiceInfoStrings[prParmChoiceCount];
        HoudiniAssetUtility.getArray1Id(
            prControl.prNodeId, HoudiniHost.getParmChoiceLists, prParmChoiceLists, prParmChoiceCount);

        cacheStringsFromHost();

        // Go through parameters and set index map and multiparm map for undo info
        myParmsUndoInfo.parmNames.Clear();
        myParmsUndoInfo.parmIndices.Clear();

        foreach (HAPI_ParmInfo parm in prParms)
        {
            if (parm.isNode() && parm.id >= myParmInputs.Length)
            {
                // For input node params, make sure they have an entry
                // in myParmInputs for their data. Fixes bug 85804
                setChangedNodeParameterIntoHost(parm.id);
            }

            // Need to check the index values are greater or equal to 0
            // for now because there is a bug where some parameters are
            // being set to have an integer parameter type, a size of
            // zero, and an index value of -1
            if (parm.isInt() && parm.intValuesIndex >= 0)
            {
                myParmsUndoInfo.parmIndices.Add(parm.intValuesIndex);
            }
            else if (parm.isFloat() && parm.floatValuesIndex >= 0)
            {
                myParmsUndoInfo.parmIndices.Add(parm.floatValuesIndex);
            }
            else if (parm.isString() && parm.stringValuesIndex >= 0)
            {
                myParmsUndoInfo.parmIndices.Add(parm.stringValuesIndex);
            }
            else
            {
                continue;
            }

            myParmsUndoInfo.parmNames.Add(parm.name);
        }
    }
 HAPI_GetParmInfoFromName(
     ref HAPI_Session session,
     HAPI_NodeId node_id,
     string parm_name,
     out HAPI_ParmInfo parm_info);
Exemple #21
0
	public void appendMultiparmInstances( HAPI_ParmInfo multiparm, int num_instances )
	{
		if ( prControl == null )
			return;
		if ( prControl.prAsset == null )
			return;

		int insert_position = multiparm.instanceCount + multiparm.instanceStartOffset;

		for ( int i = 0; i < num_instances; ++i )
			HoudiniHost.insertMultiparmInstance(
				prControl.prNodeId,
				multiparm.id, // The multiparm list
				insert_position + i );
	}
Exemple #22
0
	public void removeMultiparmInstances( HAPI_ParmInfo multiparm, int num_instances )
	{
		if ( prControl == null )
			return;
		if ( prControl.prAsset == null )
			return;

		int first_removed_instance = multiparm.instanceCount - num_instances + multiparm.instanceStartOffset;

		for ( int i = 0; i < num_instances; ++i )
			HoudiniHost.removeMultiparmInstance(
				prControl.prNodeId,
				multiparm.id, // The multiparm list
				first_removed_instance );
	}
	public static HAPI_ParmInfo getParmInfo( HAPI_NodeId node_id, HAPI_ParmId parm_id )
	{
#if ( UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || ( UNITY_METRO && UNITY_EDITOR ) )
		HAPI_ParmInfo parm_info = new HAPI_ParmInfo();
		HAPI_Result status_code = HAPI_GetParmInfo( ref mySession, node_id, parm_id, out parm_info );
		processStatusCode( status_code );
		return parm_info;
#else
		throw new HoudiniErrorUnsupportedPlatform();
#endif
	}
 public void removeMultiparmInstance(HAPI_ParmInfo parm)
 {
     myMultiparmInstancePos = parm;
     myToRemoveInstance     = true;
 }
 // This will retrieve the cached copy of the string
 public string[] getParmStrings(HAPI_ParmInfo parm)
 {
     return(myParmStrings[parm.id]);
 }
Exemple #26
0
	public void insertMultiparmInstance( HAPI_ParmInfo parm )
	{
		myMultiparmInstancePos = parm;
		myToInsertInstance = true;
	}
Exemple #27
0
	// This will retrieve the cached copy of the string
	public string[] getParmStrings( HAPI_ParmInfo parm )
	{
		return myParmStrings[ parm.id ];
	}
    private static extern HAPI_Result HAPI_GetParmInfoFromName(
		ref HAPI_Session session,
		HAPI_NodeId node_id,
		string parm_name,
		out HAPI_ParmInfo parm_info );
Exemple #29
0
	// Set into dictionary to later be set into the host
	public void setParmStrings( HAPI_ParmInfo parm, string[] strings )
	{
		myParmStrings[ parm.id ] = strings;
	}
    public int getParmSize(string name)
    {
        HAPI_ParmInfo parm_info = myAssetParms.findParm(name);

        return(parm_info.size);
    }
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Public
    public void handlesOnSceneGUI()
    {
        if (myAssetOTL.prShowPinnedInstances)
        {
            drawPinnedInstances();
        }

        // On mouse up the drag operation is completed.
        if (Event.current.type == EventType.MouseUp)
        {
            myOpInProgress = false;
        }

        string currentGlobalManipTool = Tools.current.ToString();

        if (currentGlobalManipTool == "Rotate")
        {
            myManipMode = XformManipMode.Rotate;
        }

        else if (currentGlobalManipTool == "Move")
        {
            myManipMode = XformManipMode.Translate;
        }

        else if (currentGlobalManipTool == "Scale")
        {
            myManipMode = XformManipMode.Scale;
        }

        if (myAssetOTL == null)
        {
            return;
        }

        int node_id = myAssetOTL.prNodeId;

        HAPI_HandleInfo[] handleInfos = myAssetOTL.prHandleInfos;

        if (handleInfos == null)
        {
            return;
        }

        // Detect changes and build asset only when changed.
        bool changed = false;

        for (int ii = 0; ii < handleInfos.Length; ++ii)
        {
            HAPI_HandleInfo handleInfo = handleInfos[ii];
            if (handleInfo.typeName == "xform")
            {
                float         tx = 0, ty = 0, tz = 0;
                float         rx = 0, ry = 0, rz = 0;
                float         sx = 1, sy = 1, sz = 1;
                HAPI_RSTOrder rstOrder = HAPI_RSTOrder.HAPI_SRT;
                HAPI_XYZOrder xyzOrder = HAPI_XYZOrder.HAPI_XYZ;

                HAPI_HandleBindingInfo[] bindingInfos = myAssetOTL.prHandleBindingInfos[ii];

                int[]   parm_int_values   = myAssetOTL.prParms.prParmIntValues;
                float[] parm_float_values = myAssetOTL.prParms.prParmFloatValues;

                if (parm_int_values == null || parm_float_values == null)
                {
                    Debug.LogError("No parm int/float values yet handles exist?");
                    continue;
                }

                int translate_parm_id = -1;
                int rotate_parm_id    = -1;
                int scale_parm_id     = -1;
                int rst_order_parm_id = -1;
                int xyz_order_parm_id = -1;

                foreach (HAPI_HandleBindingInfo bindingInfo in bindingInfos)
                {
                    string parm_name = bindingInfo.handleParmName;
                    if (parm_name == "tx")
                    {
                        translate_parm_id = bindingInfo.assetParmId;
                    }

                    else if (parm_name == "rx")
                    {
                        rotate_parm_id = bindingInfo.assetParmId;
                    }

                    else if (parm_name == "sx")
                    {
                        scale_parm_id = bindingInfo.assetParmId;
                    }

                    else if (parm_name == "trs_order")
                    {
                        rst_order_parm_id = bindingInfo.assetParmId;
                    }

                    else if (parm_name == "xyz_order")
                    {
                        xyz_order_parm_id = bindingInfo.assetParmId;
                    }
                }

                if (translate_parm_id >= 0)
                {
                    HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(translate_parm_id);

                    tx = parm_float_values[parm_info.floatValuesIndex + 0];
                    ty = parm_float_values[parm_info.floatValuesIndex + 1];
                    tz = parm_float_values[parm_info.floatValuesIndex + 2];
                }

                if (rotate_parm_id >= 0)
                {
                    HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(rotate_parm_id);

                    rx = parm_float_values[parm_info.floatValuesIndex + 0];
                    ry = parm_float_values[parm_info.floatValuesIndex + 1];
                    rz = parm_float_values[parm_info.floatValuesIndex + 2];
                }

                if (scale_parm_id >= 0)
                {
                    HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(scale_parm_id);

                    sx = parm_float_values[parm_info.floatValuesIndex + 0];
                    sy = parm_float_values[parm_info.floatValuesIndex + 1];
                    sz = parm_float_values[parm_info.floatValuesIndex + 2];
                }

                if (rst_order_parm_id >= 0)
                {
                    HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(rst_order_parm_id);
                    rstOrder = (HAPI_RSTOrder)parm_int_values[parm_info.intValuesIndex];
                }

                if (xyz_order_parm_id >= 0)
                {
                    HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(xyz_order_parm_id);
                    xyzOrder = (HAPI_XYZOrder)parm_int_values[parm_info.intValuesIndex];
                }

                HAPI_TransformEuler xform = new HAPI_TransformEuler(true);

                // This bit is a little tricky.  We will eventually call Handle.PositionHandle
                // or Handle.RotationHandle to display the translation and rotation handles.
                // These function take a translation parameter and a rotation parameter in
                // order to display the handle in its proper location and orientation.
                // These functions have an assumed order that it will put the rotation
                // and translation back together.  Depending whether the order of translation
                // and roation matches that of the rstOrder setting, we may, or may not
                // need to convert the translation parameter for use with the handle.
                if (rstOrder == HAPI_RSTOrder.HAPI_TSR || rstOrder == HAPI_RSTOrder.HAPI_STR || rstOrder == HAPI_RSTOrder.HAPI_SRT)
                {
                    xform.position[0]      = tx;
                    xform.position[1]      = ty;
                    xform.position[2]      = tz;
                    xform.rotationEuler[0] = rx;
                    xform.rotationEuler[1] = ry;
                    xform.rotationEuler[2] = rz;
                    xform.scale[0]         = 1;
                    xform.scale[1]         = 1;
                    xform.scale[2]         = 1;
                    xform.rotationOrder    = xyzOrder;
                    xform.rstOrder         = rstOrder;
                }
                else
                {
                    xform.position[0]      = 0;
                    xform.position[1]      = 0;
                    xform.position[2]      = 0;
                    xform.rotationEuler[0] = rx;
                    xform.rotationEuler[1] = ry;
                    xform.rotationEuler[2] = rz;
                    xform.scale[0]         = 1;
                    xform.scale[1]         = 1;
                    xform.scale[2]         = 1;
                    xform.rotationOrder    = xyzOrder;
                    xform.rstOrder         = rstOrder;
                }

                xform = HoudiniHost.convertTransform(xform, HAPI_RSTOrder.HAPI_SRT, HAPI_XYZOrder.HAPI_ZXY);

                // 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).

                xform.position[0]      = -xform.position[0];
                xform.rotationEuler[1] = -xform.rotationEuler[1];
                xform.rotationEuler[2] = -xform.rotationEuler[2];
                tx = -tx;

                Handles.matrix = myAssetOTL.transform.localToWorldMatrix;

                Vector3 position;

                if (rstOrder == HAPI_RSTOrder.HAPI_TSR || rstOrder == HAPI_RSTOrder.HAPI_STR || rstOrder == HAPI_RSTOrder.HAPI_SRT)
                {
                    position = new Vector3(xform.position[0], xform.position[1], xform.position[2]);
                }
                else
                {
                    position = new Vector3(tx, ty, tz);
                }

                Quaternion rotation = Quaternion.Euler(
                    xform.rotationEuler[0], xform.rotationEuler[1], xform.rotationEuler[2]);
                Vector3 scale = new Vector3(sx, sy, sz);

                if (myManipMode == XformManipMode.Translate)
                {
                    if (translate_parm_id < 0)
                    {
                        continue;
                    }

                    HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(translate_parm_id);

                    if (parm_info.invisible)
                    {
                        continue;
                    }

                    GUIStyle style = new GUIStyle(EditorStyles.textField);
                    style.contentOffset = new Vector2(1.4f, 1.4f);
                    string handle_name = handleInfo.name;
                    if (parm_info.disabled)
                    {
                        handle_name = handle_name + " (disabled)";
                    }
                    GUIContent content = new GUIContent(handle_name);
                    content.tooltip = handle_name;
                    Handles.Label(position, content, style);

                    if (parm_info.disabled)
                    {
                        Handles.lighting = false;
                        Handles.PositionHandle(position, rotation);
                        Handles.lighting = true;
                        continue;
                    }

                    Vector3 new_position = Handles.PositionHandle(position, rotation);

                    if (new_position != position)
                    {
                        changed = true;

                        if (!myOpInProgress)
                        {
                            Undo.RecordObject(myAssetOTL.prParms.prParmsUndoInfo, handleInfo.name);
                            myOpInProgress = true;
                        }

                        if (rstOrder == HAPI_RSTOrder.HAPI_TSR ||
                            rstOrder == HAPI_RSTOrder.HAPI_STR ||
                            rstOrder == HAPI_RSTOrder.HAPI_SRT)
                        {
                            xform.position[0] = new_position[0];
                            xform.position[1] = new_position[1];
                            xform.position[2] = new_position[2];

                            xform          = HoudiniHost.convertTransform(xform, rstOrder, xyzOrder);
                            new_position.x = xform.position[0];
                            new_position.y = xform.position[1];
                            new_position.z = xform.position[2];
                        }

                        // the - in the x coordinate is to convert back to "Houdini" coordinates
                        parm_float_values[parm_info.floatValuesIndex + 0] = -new_position.x;
                        parm_float_values[parm_info.floatValuesIndex + 1] = new_position.y;
                        parm_float_values[parm_info.floatValuesIndex + 2] = new_position.z;

                        float[] temp_float_values = new float[HoudiniConstants.HAPI_POSITION_VECTOR_SIZE];
                        for (int pp = 0; pp < HoudiniConstants.HAPI_POSITION_VECTOR_SIZE; ++pp)
                        {
                            temp_float_values[pp] = parm_float_values[parm_info.floatValuesIndex + pp];
                        }
                        HoudiniHost.setParmFloatValues(node_id, temp_float_values, parm_info.floatValuesIndex,
                                                       parm_info.size);

                        myAsset.savePreset();
                    }                     // if changed
                }
                else if (myManipMode == XformManipMode.Rotate)
                {
                    if (rotate_parm_id < 0)
                    {
                        continue;
                    }

                    HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(rotate_parm_id);

                    if (parm_info.invisible)
                    {
                        continue;
                    }

                    GUIStyle style = new GUIStyle(EditorStyles.textField);
                    style.contentOffset = new Vector2(1.4f, 1.4f);
                    string handle_name = handleInfo.name;
                    if (parm_info.disabled)
                    {
                        handle_name = handle_name + " (disabled)";
                    }
                    GUIContent content = new GUIContent(handle_name);
                    content.tooltip = handle_name;
                    Handles.Label(position, content, style);

                    if (parm_info.disabled)
                    {
                        Handles.lighting = false;
                        Handles.RotationHandle(rotation, position);
                        Handles.lighting = true;
                        continue;
                    }

                    Quaternion new_rotation = Handles.RotationHandle(rotation, position);

                    if (new_rotation != rotation)
                    {
                        changed = true;

                        if (!myOpInProgress)
                        {
                            Undo.RecordObject(myAssetOTL.prParms.prParmsUndoInfo, handleInfo.name);
                            myOpInProgress = true;
                        }

                        Vector3 newRot = new_rotation.eulerAngles;

                        xform.position[0]      = 0;
                        xform.position[1]      = 0;
                        xform.position[2]      = 0;
                        xform.rotationEuler[0] = newRot.x;
                        xform.rotationEuler[1] = newRot.y;
                        xform.rotationEuler[2] = newRot.z;
                        xform.scale[0]         = 1;
                        xform.scale[1]         = 1;
                        xform.scale[2]         = 1;
                        xform.rotationOrder    = HAPI_XYZOrder.HAPI_ZXY;
                        xform.rstOrder         = HAPI_RSTOrder.HAPI_SRT;

                        xform = HoudiniHost.convertTransform(xform, rstOrder, xyzOrder);

                        parm_float_values[parm_info.floatValuesIndex + 0] = xform.rotationEuler[0];
                        // the - in the y & z coordinate is to convert back to "Houdini" coordinates
                        parm_float_values[parm_info.floatValuesIndex + 1] = -xform.rotationEuler[1];
                        parm_float_values[parm_info.floatValuesIndex + 2] = -xform.rotationEuler[2];

                        float[] temp_float_values = new float[HoudiniConstants.HAPI_POSITION_VECTOR_SIZE];
                        for (int pp = 0; pp < HoudiniConstants.HAPI_POSITION_VECTOR_SIZE; ++pp)
                        {
                            temp_float_values[pp] = parm_float_values[parm_info.floatValuesIndex + pp];
                        }
                        HoudiniHost.setParmFloatValues(
                            node_id, temp_float_values, parm_info.floatValuesIndex, parm_info.size);

                        myAsset.savePreset();
                    }                     // if changed
                }
                else if (myManipMode == XformManipMode.Scale)
                {
                    if (scale_parm_id < 0)
                    {
                        continue;
                    }

                    HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(scale_parm_id);

                    if (parm_info.invisible)
                    {
                        continue;
                    }

                    GUIStyle style = new GUIStyle(EditorStyles.textField);
                    style.contentOffset = new Vector2(1.4f, 1.4f);
                    string handle_name = handleInfo.name;
                    if (parm_info.disabled)
                    {
                        handle_name = handle_name + " (disabled)";
                    }
                    GUIContent content = new GUIContent(handle_name);
                    content.tooltip = handle_name;
                    Handles.Label(position, content, style);

                    if (parm_info.disabled)
                    {
                        Handles.lighting = false;
                        Handles.ScaleHandle(scale, position, rotation, 1.0f);
                        Handles.lighting = true;
                        continue;
                    }

                    Vector3 new_scale = Handles.ScaleHandle(scale, position, rotation, 1.0f);

                    if (new_scale != scale)
                    {
                        changed = true;

                        if (!myOpInProgress)
                        {
                            Undo.RecordObject(myAssetOTL.prParms.prParmsUndoInfo, handleInfo.name);
                            myOpInProgress = true;
                        }

                        parm_float_values[parm_info.floatValuesIndex + 0] = new_scale.x;
                        parm_float_values[parm_info.floatValuesIndex + 1] = new_scale.y;
                        parm_float_values[parm_info.floatValuesIndex + 2] = new_scale.z;

                        float[] temp_float_values = new float[HoudiniConstants.HAPI_POSITION_VECTOR_SIZE];
                        for (int pp = 0; pp < HoudiniConstants.HAPI_POSITION_VECTOR_SIZE; ++pp)
                        {
                            temp_float_values[pp] = parm_float_values[parm_info.floatValuesIndex + pp];
                        }
                        HoudiniHost.setParmFloatValues(
                            node_id, temp_float_values, parm_info.floatValuesIndex,
                            parm_info.size);

                        myAsset.savePreset();
                    } // if changed
                }     // if myManipMode
            }         // if typeName
        }             // for each handle

        if (changed)
        {
            myAssetOTL.buildClientSide();
        }
    }
    public void getParameterValues()
    {
        if (prControl == null)
        {
            return;
        }
        if (prControl.prAsset == null)
        {
            return;
        }
        if (prControl.prAssetId < 0)
        {
            return;
        }

        if (myPostSerialization)
        {
            myValuesEqualToHoudini = areValuesEqualToHoudini();
        }
        else
        {
            myValuesEqualToHoudini = true;
        }

        // Create undo info if it hasn't been created already
        if (myParmsUndoInfo == null)
        {
            myParmsUndoInfo = ScriptableObject.CreateInstance <HoudiniParmsUndoInfo>();
        }

        // Get the node info again
        HAPI_NodeInfo node_info = HoudiniHost.getNodeInfo(prControl.prNodeId);

        prParmCount            = node_info.parmCount;
        prParmIntValueCount    = node_info.parmIntValueCount;
        prParmFloatValueCount  = node_info.parmFloatValueCount;
        prParmStringValueCount = node_info.parmStringValueCount;
        prParmChoiceCount      = node_info.parmChoiceCount;

        // Get all parameters.
        prParms = new HAPI_ParmInfo[prParmCount];
        HoudiniAssetUtility.getArray1Id(prControl.prNodeId, HoudiniHost.getParameters, prParms, prParmCount);

        // Get parameter int values.
        prParmIntValues = new int[prParmIntValueCount];
        HoudiniAssetUtility.getArray1Id(
            prControl.prNodeId, HoudiniHost.getParmIntValues, prParmIntValues, prParmIntValueCount);

        myParmsUndoInfo.parmIntValues = new int[prParmIntValueCount];
        Array.Copy(prParmIntValues, myParmsUndoInfo.parmIntValues, prParmIntValueCount);

        // Get parameter float values.
        prParmFloatValues = new float[prParmFloatValueCount];
        HoudiniAssetUtility.getArray1Id(
            prControl.prNodeId, HoudiniHost.getParmFloatValues, prParmFloatValues, prParmFloatValueCount);

        myParmsUndoInfo.parmFloatValues = new float[prParmFloatValueCount];
        Array.Copy(prParmFloatValues, myParmsUndoInfo.parmFloatValues, prParmFloatValueCount);

        // Get parameter string (handle) values.
        prParmStringValues = new int[prParmStringValueCount];
        HoudiniAssetUtility.getArray1Id(
            prControl.prNodeId, HoudiniHost.getParmStringValues, prParmStringValues, prParmStringValueCount);

        // Get parameter choice lists.
        prParmChoiceLists = new HAPI_ParmChoiceInfo[prParmChoiceCount];
        HoudiniAssetUtility.getArray1Id(
            prControl.prNodeId, HoudiniHost.getParmChoiceLists, prParmChoiceLists, prParmChoiceCount);

        // Build the map of parm id -> parm
        for (int i = 0; i < prParms.Length; ++i)
        {
            myParmMap[prParms[i].id] = prParms[i];
        }

        cacheStringsFromHost();

        // Go through parameters and set index map and multiparm map for undo info
        myParmsUndoInfo.parmNames.Clear();
        myParmsUndoInfo.parmIndices.Clear();

        foreach (HAPI_ParmInfo parm in prParms)
        {
            // Need to check the index values are greater or equal to 0
            // for now because there is a bug where some parameters are
            // being set to have an integer parameter type, a size of
            // zero, and an index value of -1
            if (parm.isInt() && parm.intValuesIndex >= 0)
            {
                myParmsUndoInfo.parmIndices.Add(parm.intValuesIndex);
            }
            else if (parm.isFloat() && parm.floatValuesIndex >= 0)
            {
                myParmsUndoInfo.parmIndices.Add(parm.floatValuesIndex);
            }
            else if (parm.isString() && parm.stringValuesIndex >= 0)
            {
                myParmsUndoInfo.parmIndices.Add(parm.stringValuesIndex);
            }
            else
            {
                continue;
            }

            myParmsUndoInfo.parmNames.Add(parm.name);
        }

#if UNITY_EDITOR
        // Set which parameter values have been overridden (only needed for a prefab instance)
        if (prControl && prControl.isPrefabInstance() && gameObject.GetComponent <HoudiniAsset>() != null)
        {
            HoudiniAsset prefab_asset = prControl.prAsset.getParentPrefabAsset();
            if (prefab_asset && prefab_asset.prParms != null &&
                prefab_asset.prParms.prParms != null &&
                !prefab_asset.isApplyingChangesToPrefab())
            {
                // loop through parameter values and determine which ones have been
                // overridden (ie. changed from corresponding parameter value on prefab)
                for (int i = 0; i < prParms.Length; ++i)
                {
                    myOverriddenParmsMap[prParms[i].id] = !isParmSameInPrefab(prParms[i].id, prefab_asset.prParms);
                }
            }

            // This tells Unity that parameter values have been overridden for this prefab instance
            PrefabUtility.RecordPrefabInstancePropertyModifications(this);
        }
#endif // UNITY_EDITOR
    }
 HAPI_GetParmInfo(
     ref HAPI_Session session,
     HAPI_NodeId node_id,
     HAPI_ParmId parm_id,
     out HAPI_ParmInfo parm_info);
	HAPI_GetParmInfo(
		ref HAPI_Session session,
		HAPI_NodeId node_id,
		HAPI_ParmId parm_id,
		out HAPI_ParmInfo parm_info );
 public void insertMultiparmInstance(HAPI_ParmInfo parm)
 {
     myMultiparmInstancePos = parm;
     myToInsertInstance     = true;
 }
	HAPI_GetParmInfoFromName(
		ref HAPI_Session session,
		HAPI_NodeId node_id,
		string parm_name,
		out HAPI_ParmInfo parm_info );
 // Set into dictionary to later be set into the host
 public void setParmStrings(HAPI_ParmInfo parm, string[] strings)
 {
     myParmStrings[parm.id] = strings;
 }
    protected bool generateAssetControl(int index, ref bool join_last, ref bool no_label_toggle_last)
    {
        if (myParms.prParms == null)
        {
            return(false);
        }

        if (myParms.prParms[index].invisible)
        {
            return(false);
        }

        bool changed = false;

        HAPI_ParmInfo[]      parms        = myParms.prParms;
        HAPI_ParmInfo        parm         = parms[index];
        HAPI_ParmInfoStrings parm_strings = myParms.prParmInfoStrings[index];

        int[]   parm_int_values   = myParms.prParmIntValues;
        float[] parm_float_values = myParms.prParmFloatValues;

        HoudiniGUIParm gui_parm = new HoudiniGUIParm(parm, parm_strings);

        ///////////////////////////////////////////////////////////////////////
        // Integer Parameter
        if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_MULTIPARMLIST)
        {
            changed = HoudiniGUI.multiparmField(
                ref gui_parm, ref myDelayBuild, ref parm_int_values,
                ref join_last, ref no_label_toggle_last);
        }
        else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_INT)
        {
            if (parm.choiceCount > 0 && parm.choiceIndex >= 0)
            {
                // Draw popup (menu) field.
                List <string> labels = new List <string>();
                List <int>    values = new List <int>();

                // Go through our choices.
                for (int i = 0; i < parm.choiceCount; ++i)
                {
                    if (myParms.prParmChoiceLists[parm.choiceIndex + i].parentParmId != parm.id)
                    {
                        Debug.LogError("Parm choice parent parm id ("
                                       + myParms.prParmChoiceLists[parm.choiceIndex + i].parentParmId
                                       + ") not matching current parm id (" + parm.id + ")!\n"
                                       + "Choice index: " + (parm.choiceIndex + i) + ", "
                                       + "Choice count: " + parm.choiceCount);
                    }

                    labels.Add(myParms.prParmChoiceInfoStrings[parm.choiceIndex + i].label);
                    values.Add(i);
                }

                changed = HoudiniGUI.dropdown(
                    ref gui_parm, ref parm_int_values,
                    labels.ToArray(), values.ToArray(),
                    ref join_last, ref no_label_toggle_last,
                    null, ref parm_int_values);
            }
            else
            {
                changed = HoudiniGUI.intField(
                    ref gui_parm, ref myDelayBuild, ref parm_int_values,
                    ref join_last, ref no_label_toggle_last, null,
                    ref parm_int_values);
            }     // if parm.choiceCount
        }         // if parm.type is INT
        ///////////////////////////////////////////////////////////////////////
        // Float Parameter
        else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_FLOAT)
        {
            changed = HoudiniGUI.floatField(
                ref gui_parm, ref myDelayBuild, ref parm_float_values,
                ref join_last, ref no_label_toggle_last, null,
                ref parm_float_values);
        }         // if parm.type is FLOAT
        ///////////////////////////////////////////////////////////////////////
        // String Parameter
        else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_STRING)
        {
            if (parm.choiceCount > 0 && parm.choiceIndex >= 0)
            {
                // Draw popup (menu) field.
                List <string> labels = new List <string>();
                List <string> values = new List <string>();

                // Go through our choices.
                for (int i = 0; i < parm.choiceCount; ++i)
                {
                    if (myParms.prParmChoiceLists[parm.choiceIndex + i].parentParmId != parm.id)
                    {
                        Debug.LogError(
                            "Parm choice parent parm id ("
                            + myParms.prParmChoiceLists[parm.choiceIndex + i].parentParmId
                            + ") not matching current parm id (" + parm.id + ")!\n"
                            + "Choice index: " + (parm.choiceIndex + i) + ", "
                            + "Choice count: " + parm.choiceCount);
                    }

                    labels.Add(myParms.prParmChoiceInfoStrings[parm.choiceIndex + i].label);
                    values.Add(myParms.prParmChoiceInfoStrings[parm.choiceIndex + i].value);
                }

                string[] values_temp = myParms.getParmStrings(parm);
                gui_parm.valuesIndex = 0;                 // Since we're piping a de-handled temp array.

                changed = HoudiniGUI.dropdown(
                    ref gui_parm, ref values_temp,
                    labels.ToArray(), values.ToArray(),
                    ref join_last, ref no_label_toggle_last,
                    null, ref values_temp);

                if (changed)
                {
                    myParms.setParmStrings(parm, values_temp);
                }
            }
            else
            {
                string[] values = myParms.getParmStrings(parm);

                // The given string array is only for this parm so we need to set the values index to 0.
                gui_parm.valuesIndex = 0;

                changed = HoudiniGUI.stringField(
                    ref gui_parm, ref myDelayBuild, ref values,
                    ref join_last, ref no_label_toggle_last, null,
                    ref values);

                // Set the to be changed strings into the cache
                if (changed)
                {
                    myParms.setParmStrings(parm, values);
                }
            }
        }
        ///////////////////////////////////////////////////////////////////////
        // File Path Field
        else if (parm.isPath())
        {
            string[] path = myParms.getParmStrings(parm);

            if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_PATH_FILE_GEO)
            {
                gui_parm.label += " (geo)";
            }
            else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_PATH_FILE_IMAGE)
            {
                gui_parm.label += " (image)";
            }

            // Asset ID might still be invalid here so don't fail if it is.
            // It is invalid if the asset didn't cook yet after a scene load.
            try
            {
                string file_pattern = parm.typeInfo;
                if (file_pattern != "")
                {
                    gui_parm.label += " (" + file_pattern + ")";
                }
            }
            catch {}

            HAPI_Permissions permissions = parm.permissions;
            if (permissions == HAPI_Permissions.HAPI_PERMISSIONS_READ_ONLY)
            {
                gui_parm.label += " (read-only)";
                changed         = HoudiniGUI.fileOpenField(
                    ref gui_parm, ref myDelayBuild, ref path[0],
                    ref join_last, ref no_label_toggle_last);
            }
            else
            {
                if (permissions == HAPI_Permissions.HAPI_PERMISSIONS_WRITE_ONLY)
                {
                    gui_parm.label += " (write-only)";
                }

                changed = HoudiniGUI.fileSaveField(
                    ref gui_parm, ref myDelayBuild, ref path[0],
                    ref join_last, ref no_label_toggle_last);
            }

            if (changed)
            {
                myParms.setParmStrings(parm, path);
            }
        }
        ///////////////////////////////////////////////////////////////////////
        // Node Path Field
        else if (parm.isNode())
        {
            // Asset ID might still be invalid here so don't fail if it is.
            // It is invalid if the asset didn't cook yet after a scene load.
            try
            {
                string op_filter = parm.typeInfo;
                if (op_filter != "")
                {
                    gui_parm.label += " (" + op_filter + ")";
                }
            }
            catch {}

            HAPI_ParmInput     parm_input  = myParms.prParmInputs[parm.id];
            UnityEngine.Object temp_object = parm_input.inputObject;
            GameObject         undo_object = null;
            changed = HoudiniGUI.objectField(
                ref gui_parm, ref temp_object, typeof(GameObject),
                ref join_last, ref no_label_toggle_last, null, ref undo_object);

            if (changed)
            {
                parm_input.newInputObject   = (GameObject)temp_object;
                myParms.prParmInputs[index] = parm_input;
            }
        }
        ///////////////////////////////////////////////////////////////////////
        // Toggle Parameter
        else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_TOGGLE)
        {
            changed = HoudiniGUI.toggle(
                ref gui_parm, ref parm_int_values,
                ref join_last, ref no_label_toggle_last,
                null, ref parm_int_values);
        }
        ///////////////////////////////////////////////////////////////////////
        // Color Parameter
        else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_COLOR)
        {
            changed = HoudiniGUI.colourField(
                ref gui_parm, ref myDelayBuild, ref parm_float_values,
                ref join_last, ref no_label_toggle_last, null,
                ref parm_float_values);
        }
        ///////////////////////////////////////////////////////////////////////
        // Button Parameter
        else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_BUTTON)
        {
            if (parm.choiceCount > 0 && parm.choiceIndex >= 0)
            {
                // Draw popup (menu) field.
                List <string> labels = new List <string>();
                List <int>    values = new List <int>();

                // Go through our choices.
                for (int i = 0; i < parm.choiceCount; ++i)
                {
                    if (myParms.prParmChoiceLists[parm.choiceIndex + i].parentParmId != parm.id)
                    {
                        Debug.LogError(
                            "Parm choice parent parm id ("
                            + myParms.prParmChoiceLists[parm.choiceIndex + i].parentParmId
                            + ") not matching current parm id (" + parm.id + ")!\n"
                            + "Choice index: " + (parm.choiceIndex + i) + ", "
                            + "Choice count: " + parm.choiceCount);
                    }

                    labels.Add(myParms.prParmChoiceInfoStrings[parm.choiceIndex + i].label);
                    values.Add(i);
                }

                changed = HoudiniGUI.dropdown(
                    ref gui_parm, ref parm_int_values,
                    labels.ToArray(), values.ToArray(),
                    ref join_last, ref no_label_toggle_last,
                    null, ref parm_int_values);
            }
            else
            {
                changed = HoudiniGUI.button(ref gui_parm, ref join_last, ref no_label_toggle_last);
            }
        }
        ///////////////////////////////////////////////////////////////////////
        // Label
        else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_LABEL)
        {
            HoudiniGUI.label(ref gui_parm, ref join_last, ref no_label_toggle_last);
        }
        ///////////////////////////////////////////////////////////////////////
        // Separator
        else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_SEPARATOR)
        {
            HoudiniGUI.separator();
        }

        if (myAsset.hasProgressBarBeenUsed() && parm.id == myParms.prLastChangedParmId)
        {
            // TODO: Set the focus back to this control since the progress bar would have stolen it.
        }


        if (changed)
        {
            myParms.prLastChangedParmId = parm.id;
        }

        return(changed);
    }
    // Checks if the parameter with the given id parm_id represents the same parameter
    // with the same value in this set of parameters and another set of parameters parmsB.
    public bool isParmSameInPrefab(int parm_id, HoudiniParms parmsB)
    {
        HAPI_ParmInfo parm_infoA = findParm(parm_id);
        HAPI_ParmInfo parm_infoB = parmsB.findParm(parm_id);

        if (parm_infoA.GetType() != parm_infoB.GetType() ||
            parm_infoA.size != parm_infoB.size ||
            parm_infoA.name != parm_infoB.name ||
            parm_infoA.label != parm_infoB.label)
        {
            Debug.LogError("Parameter structure is different from prefab");
            return(false);
        }

        // only need to check type and size of one because already checked that
        // parameter infos have  type and size
        if (parm_infoA.isFloat())
        {
            for (int ii = 0; ii < parm_infoA.size; ii++)
            {
                float valueA = prParmFloatValues[parm_infoA.floatValuesIndex + ii];
                float valueB = parmsB.prParmFloatValues[parm_infoB.floatValuesIndex + ii];
                if (valueA != valueB)
                {
                    return(false);
                }
            }
        }
        else if (parm_infoB.isInt())
        {
            for (int ii = 0; ii < parm_infoA.size; ii++)
            {
                int valueA = prParmIntValues[parm_infoA.intValuesIndex + ii];
                int valueB = parmsB.prParmIntValues[parm_infoB.intValuesIndex + ii];
                if (valueA != valueB)
                {
                    return(false);
                }
            }
        }
        else if (parm_infoB.isString())
        {
            string[] valuesA = getParmStrings(parm_infoA);
            string[] valuesB = parmsB.getParmStrings(parm_infoB);

            if (valuesA.Length != valuesB.Length)
            {
                return(false);
            }

            for (int ii = 0; ii < valuesA.Length; ii++)
            {
                if (valuesA[ii] != valuesB[ii])
                {
                    return(false);
                }
            }
        }

        return(true);
    }
Exemple #40
0
	public void removeMultiparmInstance( HAPI_ParmInfo parm )
	{
		myMultiparmInstancePos = parm;
		myToRemoveInstance = true;
	}
    private static extern HAPI_Result HAPI_GetParmInfo(
		ref HAPI_Session session,
		HAPI_NodeId node_id,
		HAPI_ParmId parm_id,
		out HAPI_ParmInfo parm_info );
Exemple #42
0
	public void getParameterValues()
	{
		if ( prControl == null )
			return;
		if ( prControl.prAsset == null )
			return;
		if ( prControl.prAssetId < 0 )
			return;

		if ( myPostSerialization )
			myValuesEqualToHoudini = areValuesEqualToHoudini();
		else
			myValuesEqualToHoudini = true;

		// Create undo info if it hasn't been created already
		if ( myParmsUndoInfo == null )
			myParmsUndoInfo = ScriptableObject.CreateInstance< HoudiniParmsUndoInfo >();

		// Get the node info again
		HAPI_NodeInfo node_info	= HoudiniHost.getNodeInfo( prControl.prNodeId );

		prParmCount 			= node_info.parmCount;
		prParmIntValueCount		= node_info.parmIntValueCount;
		prParmFloatValueCount	= node_info.parmFloatValueCount;
		prParmStringValueCount	= node_info.parmStringValueCount;
		prParmChoiceCount		= node_info.parmChoiceCount;

		// Get all parameters.
		prParms = new HAPI_ParmInfo[ prParmCount ];
		HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParameters, prParms, prParmCount );

		// Get parameter int values.
		prParmIntValues = new int[ prParmIntValueCount ];
		HoudiniAssetUtility.getArray1Id( 
			prControl.prNodeId, HoudiniHost.getParmIntValues, prParmIntValues, prParmIntValueCount );

		myParmsUndoInfo.parmIntValues = new int[ prParmIntValueCount ];
		Array.Copy( prParmIntValues, myParmsUndoInfo.parmIntValues, prParmIntValueCount );

		// Get parameter float values.
		prParmFloatValues = new float[ prParmFloatValueCount ];
		HoudiniAssetUtility.getArray1Id( 
			prControl.prNodeId, HoudiniHost.getParmFloatValues, prParmFloatValues, prParmFloatValueCount );

		myParmsUndoInfo.parmFloatValues = new float[ prParmFloatValueCount ];
		Array.Copy( prParmFloatValues, myParmsUndoInfo.parmFloatValues, prParmFloatValueCount );

		// Get parameter string (handle) values.
		prParmStringValues = new int[ prParmStringValueCount ];
		HoudiniAssetUtility.getArray1Id( 
			prControl.prNodeId, HoudiniHost.getParmStringValues, prParmStringValues, prParmStringValueCount );

		// Get parameter choice lists.
		prParmChoiceLists = new HAPI_ParmChoiceInfo[ prParmChoiceCount ];
		HoudiniAssetUtility.getArray1Id( 
			prControl.prNodeId, HoudiniHost.getParmChoiceLists, prParmChoiceLists, prParmChoiceCount );

		// Build the map of parm id -> parm
		for ( int i = 0; i < prParms.Length; ++i )
			myParmMap[ prParms[ i ].id ] = prParms[ i ];

		cacheStringsFromHost();

		// Go through parameters and set index map and multiparm map for undo info
		myParmsUndoInfo.parmNames.Clear();
		myParmsUndoInfo.parmIndices.Clear();

		foreach ( HAPI_ParmInfo parm in prParms )
		{
			// Need to check the index values are greater or equal to 0
			// for now because there is a bug where some parameters are
			// being set to have an integer parameter type, a size of 
			// zero, and an index value of -1
			if ( parm.isInt() && parm.intValuesIndex >= 0 )
				myParmsUndoInfo.parmIndices.Add( parm.intValuesIndex );
			else if ( parm.isFloat() && parm.floatValuesIndex >= 0 )
				myParmsUndoInfo.parmIndices.Add( parm.floatValuesIndex );
			else if ( parm.isString() && parm.stringValuesIndex >= 0 )
				myParmsUndoInfo.parmIndices.Add( parm.stringValuesIndex );
			else
				continue;

			myParmsUndoInfo.parmNames.Add( parm.name );
		}

#if UNITY_EDITOR
		// Set which parameter values have been overridden (only needed for a prefab instance)
		if ( prControl && prControl.isPrefabInstance() && gameObject.GetComponent< HoudiniAsset >() != null )
		{
			HoudiniAsset prefab_asset = prControl.prAsset.getParentPrefabAsset();
			if ( prefab_asset && prefab_asset.prParms != null && 
				prefab_asset.prParms.prParms != null && 
				!prefab_asset.isApplyingChangesToPrefab() )
			{
				// loop through parameter values and determine which ones have been
				// overridden (ie. changed from corresponding parameter value on prefab)
				for ( int i = 0; i < prParms.Length; ++i )
				{
					myOverriddenParmsMap[ prParms[ i ].id ] = !isParmSameInPrefab( prParms[ i ].id, prefab_asset.prParms );
				}
			}

			// This tells Unity that parameter values have been overridden for this prefab instance
			PrefabUtility.RecordPrefabInstancePropertyModifications( this );
		}
#endif // UNITY_EDITOR
	}