public static void Copy(ObjectOptions from, ObjectOptions to)
            {
                to.Parent = from.Parent;

                to.MinScale = from.MinScale;
                to.MaxScale = from.MaxScale;

                to.RotateX = from.RotateX;
                to.RotateY = from.RotateY;
                to.RotateZ = from.RotateZ;

                to.ScaleX = from.ScaleX;
                to.ScaleY = from.ScaleY;
                to.ScaleZ = from.ScaleZ;

                to.AlignToSurface    = from.AlignToSurface;
                to.UniformScaling    = from.UniformScaling;
                to.ScaleHeightOffset = from.ScaleHeightOffset;

                to.MinHeightOffset = from.MinHeightOffset;
                to.MaxHeightOffset = from.MaxHeightOffset;

                to.MinDot = from.MinDot;
                to.MaxDot = from.MaxDot;
            }
Esempio n. 2
0
 public void ObjectInstantiation ()
 {
     var options = new ObjectOptions ();
     SetObjectOptions (options);
     var @object = new Mono.Upnp.Dcp.MediaServer1.ContentDirectory1.Object ("-1", "-1", options);
     Assert.AreEqual ("-1", @object.Id);
     AssertObject (@object, options);
     AssertObject (@object, @object.GetOptions ());
 }
Esempio n. 3
0
        public void ObjectInstantiation()
        {
            var options = new ObjectOptions();

            SetObjectOptions(options);
            var @object = new Mono.Upnp.Dcp.MediaServer1.ContentDirectory1.Object("-1", "-1", options);

            Assert.AreEqual("-1", @object.Id);
            AssertObject(@object, options);
            AssertObject(@object, @object.GetOptions());
        }
Esempio n. 4
0
        static void SetObjectOptions(ObjectOptions options)
        {
            options.Title        = "1";
            options.Creator      = "2";
            options.WriteStatus  = WriteStatus.Protected;
            options.IsRestricted = true;
            var resource_options = new ResourceOptions();

            SetResourceOptions(resource_options);
            options.Resources = new[] { new Resource(new Uri("http://0"), resource_options) };
        }
Esempio n. 5
0
        protected void CopyToOptions (ObjectOptions options)
        {
            if (options == null) {
                throw new ArgumentNullException ("options");
            }

            options.Title = Title;
            options.Creator = Creator;
            options.WriteStatus = WriteStatus;
            options.IsRestricted = IsRestricted;
            options.Resources = new List<Resource> (Resources);
        }
Esempio n. 6
0
 private void tree_MouseUp(object sender, MouseEventArgs e)
 {
     if (e.Button == System.Windows.Forms.MouseButtons.Right)
     {
         TreeNode node = tree.GetNodeAt(e.X, e.Y);
         if (node != null && node.Tag != null)
         {
             tree.SelectedNode = node;
             ObjectOptions objectOptions = (ObjectOptions)node.Tag;
             if (objectOptions.Options != null)
             {
                 objectOptions.Options.DisplayOptions(this, contextMenu, e.Location);
             }
         }
     }
 }
Esempio n. 7
0
        public Object (string id, string parentId, ObjectOptions options)
        {
            if (id == null) {
                throw new ArgumentNullException ("id");
            } else if (parentId == null) {
                throw new ArgumentNullException ("parentId");
            } else if (options == null) {
                throw new ArgumentNullException ("options");
            }

            Id = id;
            ParentId = parentId;
            Title = options.Title;
            Creator = options.Creator;
            WriteStatus = options.WriteStatus;
            IsRestricted = options.IsRestricted;
            Resources = Helper.MakeReadOnlyCopy (options.Resources);
            Class = new Class (ClassManager.GetClassNameFromType (GetType ()));
        }
Esempio n. 8
0
        private IObjecOptions ProcessSingleFile(string fileName)
        {
            CheckFile(fileName);
            FileExtensions fileExtension = Containers.GetFileExtension(fileName);
            IObjecOptions  objectOptions = new ObjectOptions(fileName, containers.Find(fileExtension).ObjectType);

            foreach (var item in optionParams)
            {
                if (item.Value)
                {
                    try {
                        objectOptions.Options.SetProperty(item.Key);
                    } catch (ArgumentException ex) {
                        string message = String.Format(Properties.Resources.InvalidOption, item.Key);
                        throw new CommandLineException(String.Format("{0} {1}",
                                                                     message,
                                                                     Properties.Resources.ForThisObjectType),
                                                       ex);
                    }
                }
            }
            return(objectOptions);
        }
 /// <summary>
 /// Returns <c>true</c> if ObjectOptions.TupleFormat is not set.
 /// </summary>
 public static bool ShouldUseTupleFormat(this ObjectOptions options)
 {
     return((options & ObjectOptions.TupleFormat) == ObjectOptions.TupleFormat);
 }
Esempio n. 10
0
 /// <summary>
 /// Returns <c>true</c> if ObjectOptions.IgnoreUnknownKey is not set.
 /// </summary>
 public static bool ShouldThrowAtUnknownKey(this ObjectOptions options)
 {
     return((options & ObjectOptions.IgnoreUnknownKey) == 0);
 }
Esempio n. 11
0
 /// <summary>
 /// Returns <c>true</c> if ObjectOptions.IncludeStatic is not set.
 /// </summary>
 public static bool ShouldIgnoreStatic(this ObjectOptions options)
 {
     return((options & ObjectOptions.IncludeStatic) == 0);
 }
Esempio n. 12
0
 /// <summary>
 /// Returns <c>true</c> if ObjectOptions.IgnoreProperties is set.
 /// </summary>
 public static bool ShouldIgnoreProperties(this ObjectOptions options)
 {
     return((options & ObjectOptions.IgnoreProperties) == ObjectOptions.IgnoreProperties);
 }
 public JSONObjectAttribute() : base()
 {
     _options = ObjectOptions.Default;
 }
Esempio n. 14
0
        static void AssertObject(Mono.Upnp.Dcp.MediaServer1.ContentDirectory1.Object @object, ObjectOptions options)
        {
            Assert.AreEqual(@object.Title, options.Title);
            Assert.AreEqual(@object.Creator, options.Creator);
            Assert.AreEqual(@object.WriteStatus, options.WriteStatus);
            Assert.AreEqual(@object.IsRestricted, options.IsRestricted);
            Assert.IsTrue(@object.Resources.IsReadOnly);
            var object_enumerator  = @object.Resources.GetEnumerator();
            var options_enumerator = options.Resources.GetEnumerator();

            Assert.IsTrue(object_enumerator.MoveNext());
            Assert.IsTrue(options_enumerator.MoveNext());
            AssertResource(object_enumerator.Current, options_enumerator.Current.GetOptions());
        }
Esempio n. 15
0
 static void SetObjectOptions (ObjectOptions options)
 {
     options.Title = "1";
     options.Creator = "2";
     options.WriteStatus = WriteStatus.Protected;
     options.IsRestricted = true;
     var resource_options = new ResourceOptions ();
     SetResourceOptions (resource_options);
     options.Resources = new[] { new Resource (new Uri ("http://0"), resource_options) };
 }
Esempio n. 16
0
 static void AssertObject (Mono.Upnp.Dcp.MediaServer1.ContentDirectory1.Object @object, ObjectOptions options)
 {
     Assert.AreEqual (@object.Title, options.Title);
     Assert.AreEqual (@object.Creator, options.Creator);
     Assert.AreEqual (@object.WriteStatus, options.WriteStatus);
     Assert.AreEqual (@object.IsRestricted, options.IsRestricted);
     Assert.IsTrue (@object.Resources.IsReadOnly);
     var object_enumerator = @object.Resources.GetEnumerator ();
     var options_enumerator = options.Resources.GetEnumerator ();
     Assert.IsTrue (object_enumerator.MoveNext ());
     Assert.IsTrue (options_enumerator.MoveNext ());
     AssertResource (object_enumerator.Current, options_enumerator.Current.GetOptions ());
 }
        private bool CreateRandomObjectAtLoc(Vector2 loc, float finalMinDistSqrd, out bool objectPlaced, WeightedArray weightedObjects, ObjectOptions[] objectOptions, bool preview)
        {
            objectPlaced = false;

            if (InBounds(loc))
            {
                bool toCloseToProcess = true;
                // Don't do InNeighbourhood for clumping algorithm
                if (finalMinDistSqrd <= 0 || (!InNeighbourhood(loc, finalMinDistSqrd, out toCloseToProcess) && !InInnerBounds(loc)))
                {
                    RaycastHit hit;
                    if (CastRay(loc, out hit))
                    {
                        int           index   = weightedObjects.GetRandomObjectIndex();
                        ObjectOptions options = objectOptions[index];

                        float dotResult = Vector3.Dot(hit.normal, Vector3.up);
                        if (dotResult >= options.MinDot && dotResult <= options.MaxDot)
                        {
                            Vector3    pos = hit.point;
                            Quaternion rot;
                            Vector3    scale;
                            ApplySettingsToObject(options, hit.normal, ref pos, out rot, out scale);

                            GameObject newObject = weightedObjects.GetGameObject(index);
                            if (newObject != null)
                            {
                                if (_activeData.SphereCollisionCheck || _activeData.BoxCollisionCheck)
                                {
                                    Bounds bounds;
                                    if (GetBounds(newObject, _activeData.BoundsMode, pos, rot, scale, out bounds))
                                    {
                                        if (ModeData.Mode == DistributionMode.Surface)
                                        {
                                            ModeData.Surface.gameObject.SetActive(false);
                                        }

                                        bool      hasOverlap    = true;
                                        LayerMask correctedMask = InternalEditorUtility.ConcatenatedLayersMaskToLayerMask(_activeData.OverlapLayerMask);
                                        if (_activeData.SphereCollisionCheck)
                                        {
                                            hasOverlap = CheckSphereOverlap(bounds, correctedMask);
                                        }
                                        if (_activeData.BoxCollisionCheck && hasOverlap)
                                        {
                                            hasOverlap = CheckBoxOverlap(bounds, rot, correctedMask);
                                        }
                                        if (ModeData.Mode == DistributionMode.Surface)
                                        {
                                            ModeData.Surface.gameObject.SetActive(true);
                                        }
                                        if (hasOverlap)
                                        {
                                            return(!toCloseToProcess);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                return(!toCloseToProcess);
                            }
                            objectPlaced = true;
                            GameObject obj = (GameObject)PrefabUtility.InstantiatePrefab(newObject);
                            obj.transform.position   = pos;
                            obj.transform.rotation   = rot;
                            obj.transform.localScale = scale;

                            // When not doing this the colliders aren't properly initialized and OverlapXXX won't work
                            obj.SetActive(false);
                            obj.SetActive(true);

                            obj.transform.parent = options.Parent;

                            EditorData.PlacedObjects[_activeLevel].Add(obj);

                            if (_currNestingLevel < _maxNestingLevel)
                            {
                                PoissonPlacer placer = obj.GetComponent <PoissonPlacer>();
                                if (placer != null && placer.enabled)
                                {
                                    PoissonHelper helper = new PoissonHelper(placer);
                                    helper.Init();
                                    bool isValidSurface, preValid, currValid, postValid;
                                    int  highestValid;
                                    helper.LoadDataHolder();
                                    helper.ValidateSettings(false, out isValidSurface, out preValid, out currValid, out postValid, out highestValid);

                                    placer.EditorData.LastFrameValid = isValidSurface && preValid && currValid && postValid;
                                    if (highestValid >= 0)
                                    {
                                        Random.State randState = Random.state;
                                        helper.DistributePoisson(0, highestValid, preview, _currNestingLevel + 1, _maxNestingLevel);
                                        Random.state = randState;
                                    }
                                    helper.StoreDataHolder();
                                }
                            }
                        }
                    }
                }
                return(!toCloseToProcess || objectPlaced);
            }
            return(false);
        }
        private void ApplySettingsToObject(ObjectOptions options, Vector3 normalDir, ref Vector3 newPosition, out Quaternion newRotation, out Vector3 newScale)
        {
            newScale = new Vector3(1, 1, 1);
            if (options.UniformScaling == true)
            {
                float rand = Random.Range(options.MinScale, options.MaxScale);

                if (options.ScaleX == true)
                {
                    newScale.x = rand;
                }
                if (options.ScaleY == true)
                {
                    newScale.y = rand;
                }
                if (options.ScaleZ == true)
                {
                    newScale.z = rand;
                }
            }
            else
            {
                if (options.ScaleX == true)
                {
                    newScale.x = Random.Range(options.MinScale, options.MaxScale);
                }
                if (options.ScaleY == true)
                {
                    newScale.y = Random.Range(options.MinScale, options.MaxScale);
                }
                if (options.ScaleZ == true)
                {
                    newScale.z = Random.Range(options.MinScale, options.MaxScale);
                }
            }

            newRotation = new Quaternion();

            if (options.AlignToSurface == true)
            {
                Quaternion q1 = (options.RotateY == true) ? Quaternion.AngleAxis(Random.Range(0, 360), normalDir) : Quaternion.identity;
                Quaternion q2 = Quaternion.FromToRotation(Vector3.up, normalDir);
                newRotation = q1 * q2;
            }
            else
            {
                Vector3 eulerAngles = new Vector3();

                if (options.RotateX == true)
                {
                    eulerAngles.x = Random.Range(0.0f, 360.0f);
                }
                if (options.RotateY == true)
                {
                    eulerAngles.y = Random.Range(0.0f, 360.0f);
                }
                if (options.RotateZ == true)
                {
                    eulerAngles.z = Random.Range(0.0f, 360.0f);
                }

                newRotation = Quaternion.Euler(eulerAngles);
            }

            float heightOffset = Random.Range(options.MinHeightOffset, options.MaxHeightOffset);

            if (options.ScaleY && options.ScaleHeightOffset)
            {
                heightOffset *= newScale.y;
            }
            newPosition += normalDir * heightOffset;
        }
Esempio n. 19
0
 public ObjectOptions GetOptions ()
 {
     var options = new ObjectOptions ();
     CopyToOptions (options);
     return options;
 }
 public JSONObjectAttribute(ObjectOptions options) : base()
 {
     _options = options;
 }
        private void CreateOptions(WeightedArray objects, ObjectOptions[] options, ref int selectedIndex, float halfWidth)
        {
            bool disabled = (!objects?.HasWeightedElementsNonNull()) ?? true;

            Color oldColor = GUI.backgroundColor;

            GUI.backgroundColor = BACKGROUND_COLOR_SUB_MENU;
            EditorGUILayout.BeginVertical(SubBoxStyle);
            halfWidth          -= (DataHolder.IsWindow) ? BoxMargin : BoxMargin * 0.5f;
            GUI.backgroundColor = oldColor;

            using (new EditorGUI.DisabledScope(disabled))
            {
                GUIStyle centerStyle = new GUIStyle();
                centerStyle.alignment = TextAnchor.MiddleCenter;

                string[] objectStrings = null;
                IEnumerable <Tuple <WeightedObject, int> > objectsNonNull = null;

                if (!disabled)
                {
                    objectsNonNull = objects.Objects
                                     .Select((o, i) => new Tuple <WeightedObject, int>(o, i))
                                     .Where((o) => o.Item1.Object != null && o.Item1.Weight > 0);

                    objectStrings = objectsNonNull
                                    .Select((a, i) => i + ": " + objects.GetChance(a.Item1).ToString("F2") + "%) " + a.Item1.Object.name)
                                    .ToArray();

                    if (selectedIndex >= objectStrings.Count())
                    {
                        selectedIndex = Mathf.Max(objectStrings.Count() - 1, 0);
                    }
                }
                else
                {
                    objectStrings = new string[] { "" };
                    selectedIndex = 0;
                }

                ObjectOptions selectedOptions;
                EditorGUILayout.BeginHorizontal(RowStyle);
                EditorGUILayout.BeginVertical(SubLeftColumnStyle, GUILayout.MaxWidth(halfWidth));

                // Pass in an empty label or set EditorGUIUtility.fieldWidth to the EditorGUIUtility.labelWidth (== LABEL_WIDTH)
                // otherwise the width will be incorrect when the vertical scrollbar is visible
                selectedIndex = EditorGUILayout.Popup("", selectedIndex, objectStrings, PopupStyle);
                if (disabled)
                {
                    selectedOptions = new ObjectOptions();
                }
                else
                {
                    selectedOptions = options[objectsNonNull.ElementAt(selectedIndex).Item2];
                }
                EditorGUIUtility.fieldWidth = 0;
                EditorGUILayout.EndVertical();
                EditorGUILayout.BeginVertical(RightColumnStyle, GUILayout.MaxWidth(halfWidth));
                EditorGUILayout.LabelField("");
                EditorGUILayout.EndVertical();
                EditorGUILayout.EndHorizontal();

                EditorGUILayout.BeginHorizontal(RowStyle);
                using (new EditorGUILayout.VerticalScope(SubLeftColumnStyle, GUILayout.MaxWidth(halfWidth)))
                {
                    selectedOptions.Parent = (Transform)EditorGUILayout.ObjectField("Parent:", selectedOptions.Parent, typeof(Transform), true);

                    if (selectedOptions.Parent != null)
                    {
                        PrefabType prefabType = PrefabUtility.GetPrefabType(selectedOptions.Parent);
                        if (prefabType == PrefabType.Prefab || prefabType == PrefabType.ModelPrefab)
                        {
                            selectedOptions.Parent = null;
                        }
                    }

                    EditorGUILayout.BeginHorizontal(RowStyle);
                    EditorGUIUtility.labelWidth = LABEL_WIDTH;
                    EditorGUILayout.PrefixLabel("Rotate:", RowStyle);
                    EditorGUIUtility.labelWidth = 12.0f;
                    using (new EditorGUI.DisabledScope(selectedOptions.AlignToSurface == true))
                    {
                        selectedOptions.RotateX = EditorGUILayout.Toggle("X", selectedOptions.RotateX, ToggleStyle, GUILayout.ExpandWidth(false));
                    }
                    selectedOptions.RotateY = EditorGUILayout.Toggle("Y", selectedOptions.RotateY, ToggleStyle, GUILayout.ExpandWidth(false));
                    using (new EditorGUI.DisabledScope(selectedOptions.AlignToSurface == true))
                    {
                        selectedOptions.RotateZ = EditorGUILayout.Toggle("Z", selectedOptions.RotateZ, ToggleStyle, GUILayout.ExpandWidth(false));
                    }
                    EditorGUILayout.EndHorizontal();

                    EditorGUILayout.BeginHorizontal(RowStyle);
                    EditorGUIUtility.labelWidth = LABEL_WIDTH;
                    EditorGUILayout.PrefixLabel("Scale:", RowStyle);
                    EditorGUIUtility.labelWidth = 12.0f;
                    selectedOptions.ScaleX      = EditorGUILayout.Toggle("X", selectedOptions.ScaleX, ToggleStyle, GUILayout.ExpandWidth(false));
                    selectedOptions.ScaleY      = EditorGUILayout.Toggle("Y", selectedOptions.ScaleY, ToggleStyle, GUILayout.ExpandWidth(false));
                    selectedOptions.ScaleZ      = EditorGUILayout.Toggle("Z", selectedOptions.ScaleZ, ToggleStyle, GUILayout.ExpandWidth(false));
                    EditorGUILayout.EndHorizontal();

                    EditorGUIUtility.labelWidth    = LABEL_WIDTH;
                    selectedOptions.AlignToSurface = EditorGUILayout.Toggle("Align Z to surface:", selectedOptions.AlignToSurface, ToggleStyle);
                    selectedOptions.UniformScaling = EditorGUILayout.Toggle("Uniform scaling:", selectedOptions.UniformScaling, ToggleStyle);
                }
                using (new EditorGUILayout.VerticalScope(RightColumnStyle, GUILayout.MaxWidth(halfWidth)))
                {
                    // Magic number 9
                    EditorGUIUtility.fieldWidth = (halfWidth - LABEL_WIDTH) * 0.5f - 9.0f;

                    EditorGUILayout.BeginHorizontal(RowStyle);
                    // Add non-empty label to skip the first column
                    EditorGUILayout.PrefixLabel(" ", EditorStyles.objectField, RowStyle);
                    // Because unity layouting is pain
                    EditorGUIUtility.labelWidth = 0.0000001f;
                    EditorGUILayout.LabelField("Min", centerStyle, GUILayout.ExpandWidth(true));
                    EditorGUILayout.LabelField("Max", centerStyle, GUILayout.ExpandWidth(true));
                    EditorGUILayout.EndHorizontal();

                    EditorGUIUtility.labelWidth = LABEL_WIDTH;

                    EditorGUILayout.BeginHorizontal(RowStyle);
                    EditorGUILayout.PrefixLabel("Scale:", RowStyle);
                    selectedOptions.MinScale = EditorGUILayout.FloatField(selectedOptions.MinScale, NumberFieldStyle);
                    selectedOptions.MaxScale = EditorGUILayout.FloatField(selectedOptions.MaxScale, NumberFieldStyle);
                    EditorGUILayout.EndHorizontal();

                    EditorGUILayout.BeginHorizontal(RowStyle);
                    EditorGUILayout.PrefixLabel("Height offset:", RowStyle);
                    selectedOptions.MinHeightOffset = EditorGUILayout.FloatField(selectedOptions.MinHeightOffset, NumberFieldStyle);
                    selectedOptions.MaxHeightOffset = EditorGUILayout.FloatField(selectedOptions.MaxHeightOffset, NumberFieldStyle);
                    EditorGUILayout.EndHorizontal();

                    EditorGUILayout.BeginHorizontal(RowStyle);
                    EditorGUILayout.PrefixLabel("Face . Up:", RowStyle);
                    selectedOptions.MinDot = EditorGUILayout.FloatField(selectedOptions.MinDot, NumberFieldStyle);
                    selectedOptions.MaxDot = EditorGUILayout.FloatField(selectedOptions.MaxDot, NumberFieldStyle);
                    EditorGUILayout.EndHorizontal();

                    EditorGUIUtility.fieldWidth = 0;
                    using (new EditorGUI.DisabledScope(selectedOptions.ScaleY == false))
                    {
                        selectedOptions.ScaleHeightOffset = EditorGUILayout.Toggle(new GUIContent("Scale height offset:", "If enabled the height offset is scaled by the calculated Y scale"), selectedOptions.ScaleHeightOffset, ToggleStyle);
                    }
                }
                EditorGUILayout.EndHorizontal();
            }
            EditorGUILayout.EndVertical();
        }
Esempio n. 22
0
        public static void Copy(PoissonData from, PoissonData to)
        {
            to.Map = from.Map;

            to.ProjectionLayerMask = from.ProjectionLayerMask;
            to.ProjectionRaycastTriggerInteraction = from.ProjectionRaycastTriggerInteraction;

            to.MinDist             = from.MinDist;
            to.MaxDist             = from.MaxDist;
            to.DistToKeepNextLevel = from.DistToKeepNextLevel;

            to.MinClump = from.MinClump;
            to.MaxClump = from.MaxClump;

            to.MinClumpRange = from.MinClumpRange;
            to.MaxClumpRange = from.MaxClumpRange;

            to.UseSeed = from.UseSeed;
            to.Seed    = from.Seed;
            to.Samples = from.Samples;

            to.SphereCollisionCheck = from.SphereCollisionCheck;
            to.BoxCollisionCheck    = from.BoxCollisionCheck;

            to.PoissonObjects = from.PoissonObjects;
            to.ClumpObjects   = from.ClumpObjects;

            int fromLength = (from.PoissonObjectOptions == null) ? -1 : from.PoissonObjectOptions.Length;
            int toLength   = (to.PoissonObjectOptions == null) ? -1 : to.PoissonObjectOptions.Length;

            if (fromLength != toLength)
            {
                if (fromLength == -1)
                {
                    to.PoissonObjectOptions = null;
                }
                else
                {
                    to.PoissonObjectOptions = new ObjectOptions[fromLength];
                    to.PoissonObjectOptions.InitNew();
                }
            }
            for (int i = 0; i < fromLength; ++i)
            {
                ObjectOptions.Copy(from.PoissonObjectOptions[i], to.PoissonObjectOptions[i]);
            }

            fromLength = (from.ClumpObjectOptions == null) ? -1 : from.ClumpObjectOptions.Length;
            toLength   = (to.ClumpObjectOptions == null) ? -1 : to.ClumpObjectOptions.Length;
            if (fromLength != toLength)
            {
                if (fromLength == -1)
                {
                    to.ClumpObjectOptions = null;
                }
                else
                {
                    to.ClumpObjectOptions = new ObjectOptions[fromLength];
                    to.ClumpObjectOptions.InitNew();
                }
            }
            for (int i = 0; i < fromLength; ++i)
            {
                ObjectOptions.Copy(from.ClumpObjectOptions[i], to.ClumpObjectOptions[i]);
            }

            to.OverlapLayerMask = from.OverlapLayerMask;
            to.OverlapRaycastTriggerInteraction = from.OverlapRaycastTriggerInteraction;
            to.BoundsMode = from.BoundsMode;

            to.MaxSamples           = from.MaxSamples;
            to.MaxSamplesPreview    = from.MaxSamplesPreview;
            to.MaxSubPlacersNesting = from.MaxSubPlacersNesting;
        }