private void AlignmentInspector()
    {
        EditorGUILayout.LabelField("Alignment", EditorStyles.boldLabel);
        alignTo = (AlignToType)EditorGUILayout.EnumPopup("Align to", alignTo);
        alignmentAxis = (AxisFlag)EditorGUILayout.EnumMaskField("Axis", alignmentAxis);

        string buttonLabel = "Select another object to align to";
        bool enableButton = false;
        Transform[] selectedTransforms = Selection.transforms;
        if (selectedTransforms.Length > 1)
        {
            if (alignTo == AlignToType.lastSelected)
            {
                buttonLabel = "Align to " + selectedTransforms[selectedTransforms.Length - 1].name;
            }
            else
            {
                buttonLabel = "Align to " + selectedTransforms[0].name;
            }
            enableButton = true;
        }

        GUI.enabled = enableButton;
        if (GUILayout.Button(buttonLabel))
        {
            AlignTo(alignTo, alignmentAxis);
        }
        GUI.enabled = true;
    }
    private void RandomScaleButton()
    {
        EditorGUILayout.LabelField("Random Scale (local)", EditorStyles.boldLabel);
        scaleAxisFlag = (AxisFlag)EditorGUILayout.EnumMaskField("Scale Axis", scaleAxisFlag);
        scaleSame = EditorGUILayout.ToggleLeft("Scale same", scaleSame);

        EditorGUILayout.BeginHorizontal();
        minScale = EditorGUILayout.FloatField("Min:", minScale);
        maxScale = EditorGUILayout.FloatField("Max", maxScale);
        EditorGUILayout.EndHorizontal();

        Transform[] selectedTransforms = Selection.transforms;
        string btnLabel = "Scale " + _transform.name;
        if (selectedTransforms.Length > 1)
            btnLabel = "Scale selection";

        if (GUILayout.Button(btnLabel))
        {
            RandomScale(scaleAxisFlag, selectedTransforms, scaleSame);
        }
    }
    private void RandomScale(AxisFlag axis, Transform[] selected , bool scaleSame)
    {
        for (int i = 0; i < selected.Length; i++)
        {
            Vector3 temp = selected[i].localScale;
            Vector3 random = Vector3.zero;
            if (scaleSame)
            {
                float rdm = Random.Range(minScale, maxScale);
                random.x = rdm;
                random.y = rdm;
                random.z = rdm;
            }
            else
            {
                random.x = Random.Range(minScale, maxScale);
                random.y = Random.Range(minScale, maxScale);
                random.z = Random.Range(minScale, maxScale);
            }

            if ((axis & AxisFlag.X) == AxisFlag.X)
                temp.x = random.x;

            if ((axis & AxisFlag.Y) == AxisFlag.Y)
                temp.y = random.y;

            if ((axis & AxisFlag.Z) == AxisFlag.Z)
                temp.z = random.z;

            Undo.RecordObject(_transform, "random scale " + selected[i].name);
            selected[i].localScale = temp;
        }
    }
    private void RandomRotateButton()
    {
        EditorGUILayout.LabelField("Random Rotation", EditorStyles.boldLabel);
        rotationAxisFlag = (AxisFlag)EditorGUILayout.EnumMaskField("Rotation Axis", rotationAxisFlag);

        Transform[] selectedTransforms = Selection.transforms;

        string label = "Rotate " + _transform.name;
        if (selectedTransforms.Length > 1)
            label = "Rotate selected";

        if (GUILayout.Button(label))
        {
            RandomRotate(rotationAxisFlag , selectedTransforms);
        }
    }
    private void RandomRotate(AxisFlag axis , Transform[] selected)
    {
        for (int i = 0; i < selected.Length; i++)
        {
            Vector3 temp = selected[i].localEulerAngles;

            if ((axis & AxisFlag.X) == AxisFlag.X)
                temp.x = RdmDeg();

            if ((axis & AxisFlag.Y) == AxisFlag.Y)
                temp.y = RdmDeg();

            if ((axis & AxisFlag.Z) == AxisFlag.Z)
                temp.z = RdmDeg();

            Undo.RecordObject(_transform, "random rotate " + selected[i].name);
            selected[i].localEulerAngles = temp;
        }
    }
    private void AlignTo(AlignToType to , AxisFlag axis)
    {
        Transform[] selectedTransforms = Selection.transforms;

        int targetIndex = 0;
        if (to == AlignToType.lastSelected)
            targetIndex = selectedTransforms.Length - 1;

        for (int i = 0; i < selectedTransforms.Length; i++)
        {
            if (i == targetIndex)
                continue;

            Vector3 temp = selectedTransforms[i].position;

            if ((axis & AxisFlag.X) == AxisFlag.X)
                temp.x = selectedTransforms[targetIndex].position.x;

            if ((axis & AxisFlag.Y) == AxisFlag.Y)
                temp.y = selectedTransforms[targetIndex].position.y;

            if ((axis & AxisFlag.Z) == AxisFlag.Z)
                temp.z = selectedTransforms[targetIndex].position.z;

            Undo.RecordObject(selectedTransforms[i], selectedTransforms[i].name +  " aligned to " + selectedTransforms[targetIndex].name);
            selectedTransforms[i].position = temp;
        }
    }