private void DisconnectInputAssetActor(HEU_SessionBase session)
{
if (!_inputAssetConnected)
{
return;
}
if (_inputNodeType == InputNodeType.PARAMETER)
{
HEU_ParameterData paramData = _parentAsset.Parameters.GetParameter(_paramName);
if(paramData == null)
{
Debug.LogErrorFormat("Unable to find parameter with name {0}!", _paramName);
}
else if (!session.SetParamStringValue(_nodeID, "", paramData.ParmID, 0))
{
Debug.LogErrorFormat("Unable to clear object path parameter for input node!");
}
}
else if(session != null && _nodeID != HEU_Defines.HEU_INVALID_NODE_ID)
{
session.DisconnectNodeInput(_nodeID, _inputIndex, false);
}
HEU_HoudiniAssetRoot inputAssetRoot = _inputAsset != null ? _inputAsset.GetComponent<HEU_HoudiniAssetRoot>() : null;
if (inputAssetRoot != null)
{
_parentAsset.DisconnectFromUpstream(inputAssetRoot._houdiniAsset);
}
// Must clear this and not delete as this points to existing asset node.
// If _inputObjectType changes to MESH, node with this ID will get deleted.
_connectedNodeID = HEU_Defines.HEU_INVALID_NODE_ID;
_inputAssetConnected = false;
}
private void DisconnectInputAssetActor(HEU_SessionBase session)
{
if (!IsInputAssetConnected())
{
return;
}
if (session != null)
{
//Debug.LogWarningFormat("Disconnecting Node Input for _nodeID={0} with type={1}", _nodeID, _inputNodeType);
if (_inputNodeType == InputNodeType.PARAMETER)
{
HEU_ParameterData paramData = _parentAsset.Parameters.GetParameter(_paramName);
if (paramData == null)
{
Debug.LogErrorFormat("Unable to find parameter with name {0}!", _paramName);
}
else if (!session.SetParamStringValue(_nodeID, "", paramData.ParmID, 0))
{
Debug.LogErrorFormat("Unable to clear object path parameter for input node!");
}
}
else if (_nodeID != HEU_Defines.HEU_INVALID_NODE_ID)
{
session.DisconnectNodeInput(_nodeID, _inputIndex, false);
}
}
ClearConnectedInputAsset();
// Must clear this and not delete as this points to existing asset node.
// If _inputObjectType changes to MESH, node with this ID will get deleted.
_connectedNodeID = HEU_Defines.HEU_INVALID_NODE_ID;
}
public static bool SetChoice(HEU_HoudiniAsset asset, string paramName, int setValue)
{
HEU_ParameterData paramData = asset.Parameters.GetParameter(paramName);
if (paramData != null && paramData._parmInfo.choiceCount > 0 && setValue >= 0 && setValue < paramData._choiceIntValues.Length)
{
paramData._intValues[0] = paramData._choiceIntValues[setValue];
return true;
}
else
{
Debug.LogWarningFormat("{0}: Set failed. Asset [{0}]'s Parameter [{1}] is not a valid choice!", asset.AssetName, paramName);
return false;
}
}
public static bool SetString(HEU_HoudiniAsset asset, string paramName, string setValue)
{
HEU_ParameterData paramData = asset.Parameters.GetParameter(paramName);
if (paramData != null && (paramData.IsString() || paramData.IsPathFile()))
{
paramData._stringValues[0] = setValue;
return true;
}
else
{
Debug.LogWarningFormat("{0}: Set failed. Asset [{0}]'s Parameter [{1}] is not a valid string!", asset.AssetName, paramName);
return false;
}
}
public static bool SetFloats(HEU_HoudiniAsset asset, string paramName, float[] setValues)
{
HEU_ParameterData paramData = asset.Parameters.GetParameter(paramName);
if (paramData != null && paramData.IsFloat())
{
paramData._floatValues = setValues;
return true;
}
else
{
Debug.LogWarningFormat("{0}: Set failed. Asset [{0}]'s Parameter [{1}] is not a valid float!", asset.AssetName, paramName);
return false;
}
}
public static bool SetInt(HEU_HoudiniAsset asset, string paramName, int setValue)
{
HEU_ParameterData paramData = asset.Parameters.GetParameter(paramName);
if (paramData != null && paramData.IsInt())
{
paramData._intValues[0] = setValue;
return true;
}
else
{
Debug.LogWarningFormat("{0}: Set failed. Asset [{0}]'s Parameter [{1}] is not a valid int!", asset.AssetName, paramName);
return false;
}
}
public static bool GetToggle(HEU_HoudiniAsset asset, string paramName, out bool outValue)
{
outValue = false;
HEU_ParameterData paramData = asset.Parameters.GetParameter(paramName);
if (paramData != null && paramData.IsToggle())
{
outValue = paramData._toggle;
return true;
}
else
{
Debug.LogWarningFormat("{0}: Query failed. Asset [{0}]'s Parameter [{1}] is not a valid toggle!", asset.AssetName, paramName);
return false;
}
}
public static bool GetInputNode(HEU_HoudiniAsset asset, string paramName, int index, out GameObject obj)
{
obj = null;
HEU_ParameterData paramData = asset.Parameters.GetParameter(paramName);
if (paramData != null && paramData._paramInputNode != null)
{
obj = paramData._paramInputNode.GetInputEntryGameObject(index);
return obj != null;
}
else
{
Debug.LogWarningFormat("{0}: Set failed. Asset [{0}]'s Parameter [{1}] is not a valid input parameter!", asset.AssetName, paramName);
return false;
}
}
public static bool GetChoice(HEU_HoudiniAsset asset, string paramName, out int outValue)
{
outValue = 0;
HEU_ParameterData paramData = asset.Parameters.GetParameter(paramName);
if (paramData != null && paramData._parmInfo.choiceCount > 0)
{
outValue = paramData._intValues[0];
return true;
}
else
{
Debug.LogWarningFormat("{0}: Query failed. Asset [{0}]'s Parameter [{1}] is not a valid choice!", asset.AssetName, paramName);
return false;
}
}
public static bool GetFloat(HEU_HoudiniAsset asset, string paramName, out float outValue)
{
outValue = 0;
HEU_ParameterData paramData = asset.Parameters.GetParameter(paramName);
if (paramData != null && paramData.IsFloat())
{
outValue = paramData._floatValues[0];
return true;
}
else
{
Debug.LogWarningFormat("{0}: Query failed. Asset [{0}]'s Parameter [{1}] is not a valid float!", asset.AssetName, paramName);
return false;
}
}
public static bool GetColor(HEU_HoudiniAsset asset, string paramName, out Color getValue)
{
HEU_ParameterData paramData = asset.Parameters.GetParameter(paramName);
if (paramData != null && paramData.IsColor())
{
getValue = paramData._color;
return true;
}
else
{
getValue = Color.white;
Debug.LogWarningFormat("{0}: Query failed. Asset [{0}]'s Parameter [{1}] is not a valid color!", asset.AssetName, paramName);
return false;
}
}
public static bool SetInputNode(HEU_HoudiniAsset asset, string paramName, GameObject obj, int index)
{
HEU_ParameterData paramData = asset.Parameters.GetParameter(paramName);
if (paramData != null && paramData._paramInputNode != null)
{
if(index < paramData._paramInputNode.NumInputObjects())
{
paramData._paramInputNode.InsertInputObject(index, obj);
}
else
{
paramData._paramInputNode.AddInputObjectAtEnd(obj);
}
return true;
}
else
{
Debug.LogWarningFormat("{0}: Set failed. Asset [{0}]'s Parameter [{1}] is not a valid input parameter!", asset.AssetName, paramName);
return false;
}
}
private void DisconnectConnectedMergeNode(HEU_SessionBase session)
{
if (session != null)
{
//Debug.LogWarningFormat("Disconnecting Node Input for _nodeID={0} with type={1}", _nodeID, _inputNodeType);
if (_inputNodeType == InputNodeType.PARAMETER)
{
HEU_ParameterData paramData = _parentAsset.Parameters.GetParameter(_paramName);
if (paramData == null)
{
Debug.LogErrorFormat("Unable to find parameter with name {0}!", _paramName);
}
else if (!session.SetParamStringValue(_nodeID, "", paramData.ParmID, 0))
{
Debug.LogErrorFormat("Unable to clear object path parameter for input node!");
}
}
else if (_nodeID != HEU_Defines.HEU_INVALID_NODE_ID)
{
session.DisconnectNodeInput(_nodeID, _inputIndex, false);
}
}
}
/// <summary>
/// Project curve points onto collider or layer.
/// </summary>
/// <param name="parentAsset">Parent asset of the curve</param>
/// <param name="rayDirection">Direction to cast ray</param>
/// <param name="rayDistance">Maximum ray cast distance</param>
public void ProjectToColliders(HEU_HoudiniAsset parentAsset, Vector3 rayDirection, float rayDistance)
{
bool bRequiresUpload = false;
LayerMask layerMask = Physics.DefaultRaycastLayers;
HEU_Curve.CurveDrawCollision collisionType = parentAsset.CurveDrawCollision;
if (collisionType == CurveDrawCollision.COLLIDERS)
{
List<Collider> colliders = parentAsset.GetCurveDrawColliders();
bool bFoundHit = false;
int numPoints = _points.Count;
for (int i = 0; i < numPoints; ++i)
{
bFoundHit = false;
RaycastHit[] rayHits = Physics.RaycastAll(_points[i], rayDirection, rayDistance, layerMask, QueryTriggerInteraction.Ignore);
foreach (RaycastHit hit in rayHits)
{
foreach (Collider collider in colliders)
{
if (hit.collider == collider)
{
_points[i] = hit.point;
bFoundHit = true;
bRequiresUpload = true;
break;
}
}
if (bFoundHit)
{
break;
}
}
}
}
else if (collisionType == CurveDrawCollision.LAYERMASK)
{
layerMask = parentAsset.GetCurveDrawLayerMask();
int numPoints = _points.Count;
for (int i = 0; i < numPoints; ++i)
{
RaycastHit hitInfo;
if (Physics.Raycast(_points[i], rayDirection, out hitInfo, rayDistance, layerMask, QueryTriggerInteraction.Ignore))
{
_points[i] = hitInfo.point;
bRequiresUpload = true;
}
}
}
if (bRequiresUpload)
{
HEU_ParameterData paramData = _parameters.GetParameter(HEU_Defines.CURVE_COORDS_PARAM);
if (paramData != null)
{
paramData._stringValues[0] = GetPointsString(_points);
}
SetEditState(CurveEditState.REQUIRES_GENERATION);
}
}
public void GenerateTransform(HEU_SessionBase session, HEU_Parameters parameters)
{
HAPI_TransformEuler transformEuler = new HAPI_TransformEuler(true);
transformEuler.rstOrder = _rstOrder;
transformEuler.rotationOrder = _xyzOrder;
transformEuler.position[0] = 0;
transformEuler.position[1] = 0;
transformEuler.position[2] = 0;
transformEuler.rotationEuler[0] = 0;
transformEuler.rotationEuler[1] = 0;
transformEuler.rotationEuler[2] = 0;
transformEuler.scale[0] = 1;
transformEuler.scale[1] = 1;
transformEuler.scale[2] = 1;
if (_handleParamTranslateBinding != null)
{
HEU_ParameterData parmData = parameters.GetParameterWithParmID(_handleParamTranslateBinding._parmID);
if (parmData != null && !parmData._parmInfo.invisible)
{
transformEuler.position[0] = parmData._floatValues[0];
transformEuler.position[1] = parmData._floatValues[1];
transformEuler.position[2] = parmData._floatValues[2];
}
}
if(_handleParamRotateBinding != null)
{
HEU_ParameterData parmData = parameters.GetParameterWithParmID(_handleParamRotateBinding._parmID);
if (parmData != null && !parmData._parmInfo.invisible)
{
transformEuler.rotationEuler[0] = parmData._floatValues[0];
transformEuler.rotationEuler[1] = parmData._floatValues[1];
transformEuler.rotationEuler[2] = parmData._floatValues[2];
}
}
if(_handleParamScaleBinding != null)
{
HEU_ParameterData parmData = parameters.GetParameterWithParmID(_handleParamScaleBinding._parmID);
if (parmData != null && !parmData._parmInfo.invisible)
{
transformEuler.scale[0] = parmData._floatValues[0];
transformEuler.scale[1] = parmData._floatValues[1];
transformEuler.scale[2] = parmData._floatValues[2];
}
}
if (!session.ConvertTransform(ref transformEuler, HAPI_RSTOrder.HAPI_SRT, HAPI_XYZOrder.HAPI_ZXY, out _convertedTransformEuler))
{
return;
}
// Convert to left-handed Unity
_convertedTransformEuler.position[0] = -_convertedTransformEuler.position[0];
_convertedTransformEuler.rotationEuler[1] = -_convertedTransformEuler.rotationEuler[1];
_convertedTransformEuler.rotationEuler[2] = -_convertedTransformEuler.rotationEuler[2];
if (IsSpecialRSTOrder(transformEuler.rstOrder))
{
_handlePosition = new Vector3(_convertedTransformEuler.position[0], _convertedTransformEuler.position[1], _convertedTransformEuler.position[2]);
}
else if (_handleParamTranslateBinding != null)
{
_handlePosition = new Vector3(-transformEuler.position[0], transformEuler.position[1], transformEuler.position[2]);
}
else
{
_handlePosition = Vector3.zero;
}
_handleRotation = Quaternion.Euler(_convertedTransformEuler.rotationEuler[0], _convertedTransformEuler.rotationEuler[1], _convertedTransformEuler.rotationEuler[2]);
if (_handleParamScaleBinding != null)
{
_handleScale = new Vector3(transformEuler.scale[0], transformEuler.scale[1], transformEuler.scale[2]);
}
else
{
_handleScale = Vector3.one;
}
}
// LOGIC -----------------------------------------------------------------------------------------------------
public bool SetupHandle(HEU_SessionBase session, HAPI_NodeId assetID, int handleIndex, string handleName,
HEU_HandleType handleType, ref HAPI_HandleInfo handleInfo, HEU_Parameters parameters)
{
_handleIndex = handleIndex;
_handleName = handleName;
_handleType = handleType;
HAPI_HandleBindingInfo[] handleBindingInfos = new HAPI_HandleBindingInfo[handleInfo.bindingsCount];
if (!session.GetHandleBindingInfo(assetID, _handleIndex, handleBindingInfos, 0, handleInfo.bindingsCount))
{
return false;
}
HAPI_ParmId translateParmID = -1;
HAPI_ParmId rotateParmID = -1;
HAPI_ParmId scaleParmID = -1;
HAPI_ParmId rstOrderParmID = -1;
HAPI_ParmId xyzOrderParmID = -1;
_rstOrder = HAPI_RSTOrder.HAPI_SRT;
_xyzOrder = HAPI_XYZOrder.HAPI_XYZ;
_handleParamTranslateBinding = null;
_handleParamRotateBinding = null;
_handleParamScaleBinding = null;
for (int i = 0; i < handleBindingInfos.Length; ++i)
{
string parmName = HEU_SessionManager.GetString(handleBindingInfos[i].handleParmNameSH, session);
//string assetParmName = HEU_SessionManager.GetString(handleBindingInfos[i].assetParmNameSH, session);
//Debug.LogFormat("Handle {0} has parm {1} with asset parm {2} with asset parm id {3}", handleName, parmName, assetParmName, handleBindingInfos[i].assetParmId);
if (parmName.Equals("tx") || parmName.Equals("ty") || parmName.Equals("tz"))
{
translateParmID = handleBindingInfos[i].assetParmId;
if(_handleParamTranslateBinding == null)
{
HEU_ParameterData parmData = parameters.GetParameterWithParmID(translateParmID);
if (parmData != null && !parmData._parmInfo.invisible)
{
_handleParamTranslateBinding = new HEU_HandleParamBinding();
_handleParamTranslateBinding._paramType = HEU_HandleParamBinding.HEU_HandleParamType.TRANSLATE;
_handleParamTranslateBinding._parmID = parmData.ParmID;
_handleParamTranslateBinding._paramName = parmData._name;
_handleParamTranslateBinding._bDisabled = parmData._parmInfo.disabled;
}
}
if(_handleParamTranslateBinding != null)
{
if(parmName.Equals("tx"))
{
_handleParamTranslateBinding._boundChannels[0] = true;
}
else if (parmName.Equals("ty"))
{
_handleParamTranslateBinding._boundChannels[1] = true;
}
else if (parmName.Equals("tz"))
{
_handleParamTranslateBinding._boundChannels[2] = true;
}
}
}
if (parmName.Equals("rx") || parmName.Equals("ry") || parmName.Equals("rz"))
{
rotateParmID = handleBindingInfos[i].assetParmId;
if(_handleParamRotateBinding == null)
{
HEU_ParameterData parmData = parameters.GetParameterWithParmID(rotateParmID);
if (parmData != null && !parmData._parmInfo.invisible)
{
_handleParamRotateBinding = new HEU_HandleParamBinding();
_handleParamRotateBinding._paramType = HEU_HandleParamBinding.HEU_HandleParamType.ROTATE;
_handleParamRotateBinding._parmID = parmData.ParmID;
_handleParamRotateBinding._paramName = parmData._name;
_handleParamRotateBinding._bDisabled = parmData._parmInfo.disabled;
}
}
if (_handleParamRotateBinding != null)
{
if (parmName.Equals("rx"))
{
_handleParamRotateBinding._boundChannels[0] = true;
}
else if (parmName.Equals("ry"))
{
_handleParamRotateBinding._boundChannels[1] = true;
}
else if (parmName.Equals("rz"))
{
_handleParamRotateBinding._boundChannels[2] = true;
}
}
}
if (parmName.Equals("sx") || parmName.Equals("sy") || parmName.Equals("sz"))
{
scaleParmID = handleBindingInfos[i].assetParmId;
if (_handleParamScaleBinding == null)
{
HEU_ParameterData parmData = parameters.GetParameterWithParmID(scaleParmID);
if (parmData != null && !parmData._parmInfo.invisible)
{
_handleParamScaleBinding = new HEU_HandleParamBinding();
_handleParamScaleBinding._paramType = HEU_HandleParamBinding.HEU_HandleParamType.SCALE;
_handleParamScaleBinding._parmID = parmData.ParmID;
_handleParamScaleBinding._paramName = parmData._name;
_handleParamScaleBinding._bDisabled = parmData._parmInfo.disabled;
}
}
if (_handleParamScaleBinding != null)
{
if (parmName.Equals("sx"))
{
_handleParamScaleBinding._boundChannels[0] = true;
}
else if (parmName.Equals("sy"))
{
_handleParamScaleBinding._boundChannels[1] = true;
}
else if (parmName.Equals("sz"))
{
_handleParamScaleBinding._boundChannels[2] = true;
}
}
}
if(parmName.Equals("trs_order"))
{
rstOrderParmID = handleBindingInfos[i].assetParmId;
}
if (parmName.Equals("xyz_order"))
{
xyzOrderParmID = handleBindingInfos[i].assetParmId;
}
}
if (rstOrderParmID >= 0)
{
HEU_ParameterData parmData = parameters.GetParameter(rstOrderParmID);
if (parmData != null)
{
_rstOrder = (HAPI_RSTOrder)parmData._intValues[0];
}
}
if (xyzOrderParmID >= 0)
{
HEU_ParameterData parmData = parameters.GetParameter(xyzOrderParmID);
if (parmData != null)
{
_xyzOrder = (HAPI_XYZOrder)parmData._intValues[0];
}
}
GenerateTransform(session, parameters);
return true;
}
public bool DrawHandles(HEU_HoudiniAsset asset)
{
List<HEU_Handle> handles = CacheHandles();
HEU_HandleManipMode manipMode = GetCurrentGlobalManipMode();
GUIStyle textStyle = new GUIStyle(EditorStyles.textField);
textStyle.contentOffset = new Vector2(1.4f, 1.4f);
HEU_Parameters assetParameters = asset.Parameters;
SerializedObject serializedParametersObject = new SerializedObject(assetParameters);
SerializedProperty parameterListProperty = HEU_EditorUtility.GetSerializedProperty(serializedParametersObject, "_parameterList");
bool bChanged = false;
Matrix4x4 defaultMatrix = Handles.matrix;
foreach (HEU_Handle handle in handles)
{
if (handle.HandleType == HEU_Handle.HEU_HandleType.XFORM)
{
Handles.matrix = asset.transform.localToWorldMatrix;
Vector3 handlePosition = handle.HandlePosition;
Quaternion handleRotation = handle.HandleRotation;
Vector3 handleScale = handle.HandleScale;
string handleName = handle.HandleName;
if (manipMode == HEU_HandleManipMode.MOVE)
{
if (!handle.HasTranslateHandle())
{
continue;
}
bool bDisabled = handle.IsTranslateHandleDisabled();
if (bDisabled)
{
handleName += " (disabled)";
}
GUIContent labelContent = new GUIContent(handleName);
labelContent.tooltip = handleName;
Handles.Label(handlePosition, labelContent, textStyle);
if (bDisabled)
{
bool bLighting = Handles.lighting;
Handles.lighting = false;
Handles.PositionHandle(handlePosition, handleRotation);
Handles.lighting = bLighting;
continue;
}
Vector3 updatedPosition = Handles.PositionHandle(handlePosition, handleRotation);
if (updatedPosition != handlePosition)
{
if (!handle.GetUpdatedPosition(asset, ref updatedPosition))
{
continue;
}
HEU_HandleParamBinding translateBinding = handle.GetTranslateBinding();
if (translateBinding != null)
{
HEU_ParameterData paramData = assetParameters.GetParameterWithParmID(translateBinding._parmID);
if (paramData != null && paramData._unityIndex < parameterListProperty.arraySize)
{
SerializedProperty paramDataProperty = parameterListProperty.GetArrayElementAtIndex(paramData._unityIndex);
float[] posFloats = new float[3];
posFloats[0] = updatedPosition[0];
posFloats[1] = updatedPosition[1];
posFloats[2] = updatedPosition[2];
bChanged |= UpdateFloatArrayProperty(paramDataProperty, posFloats, translateBinding);
}
}
}
}
else if (manipMode == HEU_HandleManipMode.ROTATE)
{
if (!handle.HasRotateHandle())
{
continue;
}
bool bDisabled = handle.IsRotateHandleDisabled();
if (bDisabled)
{
handleName += " (disabled)";
}
GUIContent labelContent = new GUIContent(handleName);
labelContent.tooltip = handleName;
Handles.Label(handlePosition, labelContent, textStyle);
if (bDisabled)
{
bool bLighting = Handles.lighting;
Handles.lighting = false;
Handles.RotationHandle(handleRotation, handlePosition);
Handles.lighting = bLighting;
continue;
}
Quaternion updatedRotation = Handles.RotationHandle(handleRotation, handlePosition);
if (updatedRotation != handleRotation)
{
if (!handle.GetUpdatedRotation(asset, ref updatedRotation))
{
continue;
}
HEU_HandleParamBinding rotateBinding = handle.GetRotateBinding();
if (rotateBinding != null)
{
HEU_ParameterData paramData = assetParameters.GetParameterWithParmID(rotateBinding._parmID);
if (paramData != null && paramData._unityIndex < parameterListProperty.arraySize)
{
SerializedProperty paramDataProperty = parameterListProperty.GetArrayElementAtIndex(paramData._unityIndex);
float[] rotFloats = new float[3];
rotFloats[0] = updatedRotation[0];
rotFloats[1] = updatedRotation[1];
rotFloats[2] = updatedRotation[2];
bChanged |= UpdateFloatArrayProperty(paramDataProperty, rotFloats, rotateBinding);
}
}
}
}
else if (manipMode == HEU_HandleManipMode.SCALE)
{
if (!handle.HasScaleHandle())
{
continue;
}
bool bDisabled = handle.IsScaleHandleDisabled();
if (bDisabled)
{
handleName += " (disabled)";
}
GUIContent labelContent = new GUIContent(handleName);
labelContent.tooltip = handleName;
Handles.Label(handlePosition, labelContent, textStyle);
if (bDisabled)
{
bool bLighting = Handles.lighting;
Handles.lighting = false;
Handles.ScaleHandle(handleScale, handlePosition, handleRotation, 1f);
Handles.lighting = bLighting;
continue;
}
Vector3 updatedScale = Handles.ScaleHandle(handleScale, handlePosition, handleRotation, 1f);
if (updatedScale != handleScale)
{
HEU_HandleParamBinding scaleBinding = handle.GetScaleBinding();
if (scaleBinding != null)
{
HEU_ParameterData paramData = assetParameters.GetParameterWithParmID(scaleBinding._parmID);
if (paramData != null && paramData._unityIndex < parameterListProperty.arraySize)
{
SerializedProperty paramDataProperty = parameterListProperty.GetArrayElementAtIndex(paramData._unityIndex);
float[] scaleFloats = new float[3];
scaleFloats[0] = updatedScale[0];
scaleFloats[1] = updatedScale[1];
scaleFloats[2] = updatedScale[2];
bChanged |= UpdateFloatArrayProperty(paramDataProperty, scaleFloats, scaleBinding);
}
}
}
}
}
}
if (bChanged)
{
serializedParametersObject.ApplyModifiedProperties();
}
Handles.matrix = defaultMatrix;
return bChanged;
}
