Exemplo n.º 1
0
        private void DrawReplaceSection()
        {
            using (new VerticalScope())
            {
                PropertyField(posMod);
                PropertyField(rotMod);
                PropertyField(scaleMod);

                using (new HorizontalScope())
                {
                    PropertyField(sample);

                    using (new EditorGUI.DisabledScope(sample.objectReferenceValue == null))
                    {
                        if (Button("Replace Selected With sample"))
                        {
                            tool.Replace();
                        }
                    }
                }
                PropertyField(showPreview);

                PropertyField(useOffset);
                if (useOffset.boolValue)
                {
                    PropertyField(offset);

                    using (new EditorGUI.DisabledScope(Selection.transforms.Length != 2))
                        using (new HorizontalScope())
                        {
                            if (Button("Set Offset To Selection Difference"))
                            {
                                //offset.managedReferenceValue = TransformValues.GetDifference(Selection.transforms[0], Selection.transforms[1]);
                                tool.offset = TransformValues.GetDifference(Selection.transforms[0], Selection.transforms[1]);
                                EditorUtility.SetDirty(target);
                                serializedObject.Update();
                            }
                        }
                }
            }
        }
Exemplo n.º 2
0
        private void DrawOffsetSection()
        {
            using (new VerticalScope("box"))
            {
                Label("Offset");
                _offset.position = Vector3Field("position", _offset.position);
                _offset.rotation = Vector3Field("rotation", _offset.rotation);
                _offset.scale    = Vector3Field("scale", _offset.scale);

                using (new HorizontalScope())
                {
                    if (Button("Set Offset To Selection Difference") && Selection.transforms.Length == 2)
                    {
                        _offset = TransformValues.GetDifference(Selection.transforms[0], Selection.transforms[1]);
                    }

                    if (Button("Add Offset To Selection"))
                    {
                        TransformObjectsBy(Selection.transforms);
                    }
                }
            }
        }
Exemplo n.º 3
0
        public void ReplaceObjectsWithPrefab(GameObject[] objects, GameObject sample, TransformValues offset)
        {
            Selection.objects = objects.Select(ReplaceWithPrefab).ToArray();

            GameObject ReplaceWithPrefab(GameObject obj)
            {
                var hierarchyIndex = obj.transform.GetSiblingIndex();

                GameObject newObj = InstantiateSample(obj.transform.parent);

                Undo.RegisterCreatedObjectUndo(newObj, "Instantiated Prefab");

                SetupTransformValues();

                Undo.DestroyObjectImmediate(obj);
                newObj.transform.SetSiblingIndex(hierarchyIndex);
                return(newObj);

                void SetupTransformValues()
                {
                    newObj.transform.localPosition    = GetNewTransformationValue(_positionMod, obj.transform.localPosition, newObj.transform.localPosition);
                    newObj.transform.localEulerAngles = GetNewTransformationValue(_rotationMod, obj.transform.localEulerAngles, newObj.transform.localEulerAngles);
                    newObj.transform.localScale       = GetNewTransformationValue(_scaleMod, obj.transform.localScale, newObj.transform.localScale);

                    offset.AddTo(newObj.transform);
                }

                Vector3 GetNewTransformationValue(TransformOperation transformation, Vector3 oldValue, Vector3 newValue)
                {
                    switch (transformation)
                    {
                    default:
                    case TransformOperation.UseOldValue:
                    {
                        return(oldValue);
                    }

                    case TransformOperation.UseNewValue:
                    {
                        return(newValue);
                    }

                    case TransformOperation.AddNewValue:
                    {
                        return(oldValue + newValue);
                    }
                    }
                }
            }
        }