Example #1
0
        private void OnGUI()
        {
            GUILayout.BeginVertical();

            GUILayout.BeginHorizontal();
            GUILayout.Label("Primitive");
            var index = Mathf.Max(EditorGUILayout.Popup(_selectedBuilderIndex, _builderNames.ToArray()), 0);

            GUILayout.EndHorizontal();

            if (index >= 0 && _renderers.Count > index)
            {
                if (index != _selectedBuilderIndex || null == _renderer)
                {
                    _settings = (GeometryBuilderSettings)GeometryProvider.Factories[index].Invoke(null, null);

                    _renderer = _renderers[index];
                    _builder  = GeometryProvider.Builders[index];

                    _settings.Name        = Name(_builder);
                    _settings.Description = Description(_builder);
                }

                _renderer.Draw(_settings);

                _selectedBuilderIndex = index;
            }

            GUILayout.EndVertical();
        }
        /// <summary>
        /// Draws custom controls for Circle.
        /// </summary>
        /// <param name="settings"></param>
        protected override void DrawCustomControls(GeometryBuilderSettings settings)
        {
            base.DrawCustomControls(settings);

            var polygonSettings = (CircleGeometryBuilderSettings)settings;

            polygonSettings.NumSides = Mathf.Max(3, EditorGUILayout.IntField("Number of Sides", polygonSettings.NumSides));
        }
Example #3
0
        /// <summary>
        /// Draws pyramid specific controls.
        /// </summary>
        protected override void DrawCustomControls(GeometryBuilderSettings settings)
        {
            base.DrawCustomControls(settings);

            var pyramid = (PyramidGeometryBuilderSettings)settings;

            pyramid.NumSides = Mathf.Max(3, EditorGUILayout.IntField("Number of Sides", pyramid.NumSides));
            pyramid.Height   = EditorGUILayout.FloatField("Height", pyramid.Height);
        }
        /// <summary>
        /// Draws custom controls for a Plane.
        /// </summary>
        /// <param name="settings"></param>
        protected override void DrawCustomControls(GeometryBuilderSettings settings)
        {
            base.DrawCustomControls(settings);

            PlaneGeometryBuilderSettings planeSettings = (PlaneGeometryBuilderSettings)settings;

            planeSettings.NumXVerts = Mathf.Max(EditorGUILayout.IntField("Num X Vertices", planeSettings.NumXVerts), 2);
            planeSettings.NumZVerts = Mathf.Max(EditorGUILayout.IntField("Num Z Vertices", planeSettings.NumZVerts), 2);
        }
Example #5
0
        /// <summary>
        /// Draws cylinder specific controls.
        /// </summary>
        /// <param name="settings"></param>
        protected override void DrawCustomControls(GeometryBuilderSettings settings)
        {
            var cylinderSettings = (CylinderGeometryBuilderSettings)settings;

            base.DrawCustomControls(settings);

            cylinderSettings.NumSides = Mathf.Max(3, EditorGUILayout.IntField("Number of Sides", cylinderSettings.NumSides));
            cylinderSettings.Height   = EditorGUILayout.FloatField("Height", cylinderSettings.Height);
            cylinderSettings.Endcaps  = EditorGUILayout.Toggle("Cap Ends", cylinderSettings.Endcaps);
        }
Example #6
0
 /// <summary>
 /// Draws build controls.
 /// </summary>
 /// <param name="settings"></param>
 protected virtual void DrawBuildControls(GeometryBuilderSettings settings)
 {
     if (ToggleFoldout("Build", true))
     {
         _buildTabState = EditorUtility.DrawTabs(
             _buildTabState,
             new Tab("Create", DrawBuildCreate),
             new Tab("Update", DrawBuildUpdate),
             new Tab("Save", DrawBuildSave));
     }
 }
Example #7
0
 /// <summary>
 /// Draws controls for vertex transformations.
 /// </summary>
 /// <param name="settings"></param>
 protected virtual void DrawVertexControls(GeometryBuilderSettings settings)
 {
     if (Foldout("Vertices"))
     {
         EditorGUI.indentLevel++;
         settings.Vertex.Translation          = EditorGUILayout.Vector3Field("Translation", settings.Vertex.Translation);
         settings.Vertex.Rotation.eulerAngles = EditorGUILayout.Vector3Field("Rotation", settings.Vertex.Rotation.eulerAngles);
         settings.Vertex.Scale = EditorGUILayout.Vector3Field("Scale", settings.Vertex.Scale);
         EditorGUI.indentLevel--;
     }
 }
Example #8
0
        /// <summary>
        /// Draws Geosphere settings.
        /// </summary>
        /// <param name="settings"></param>
        protected override void DrawCustomControls(GeometryBuilderSettings settings)
        {
            base.DrawCustomControls(settings);

            var geosphereSettings = (GeosphereGeometryBuilderSettings)settings;

            geosphereSettings.Subdivisions = Mathf.Max(
                1,
                EditorGUILayout.IntSlider(
                    "Subdivisions",
                    geosphereSettings.Subdivisions,
                    0, 4));
        }
Example #9
0
        /// <summary>
        /// Draws controls for tangents.
        /// </summary>
        /// <param name="settings"></param>
        protected virtual void DrawTangentControls(GeometryBuilderSettings settings)
        {
            bool enabled = settings.Tangents.Enabled = ToggleFoldout("Tangents");

            if (enabled)
            {
                EditorGUI.indentLevel++;

                settings.Tangents.Invert = EditorGUILayout.Toggle("Generate", settings.Tangents.Invert);

                EditorGUI.indentLevel--;
            }
        }
Example #10
0
        /// <summary>
        /// Draws controls for normals.
        /// </summary>
        /// <param name="settings"></param>
        protected virtual void DrawNormalControls(GeometryBuilderSettings settings)
        {
            bool enabled = settings.Normals.Enabled = ToggleFoldout("Normals");

            if (enabled)
            {
                EditorGUI.indentLevel++;

                settings.Normals.Invert = EditorGUILayout.Toggle("Invert", settings.Normals.Invert);

                EditorGUI.indentLevel--;
            }
        }
Example #11
0
        /// <summary>
        /// Draws controls for triangle transformations.
        /// </summary>
        /// <param name="settings"></param>
        protected virtual void DrawTriangleControls(GeometryBuilderSettings settings)
        {
            if (Foldout("Triangles"))
            {
                EditorGUI.indentLevel++;

                settings.Vertex.DoubleSided = EditorGUILayout.Toggle("Double Sided", settings.Vertex.DoubleSided);

                GUI.enabled = !settings.Vertex.DoubleSided;
                settings.Vertex.ReverseWinding = EditorGUILayout.Toggle("Reverse Winding", settings.Vertex.ReverseWinding);
                GUI.enabled = true;

                EditorGUI.indentLevel--;
            }
        }
Example #12
0
        /// <summary>
        /// Draws all controls.
        /// </summary>
        /// <param name="settings"></param>
        public virtual void Draw(GeometryBuilderSettings settings)
        {
            GUILayout.BeginVertical();

            _scrollPosition = GUILayout.BeginScrollView(_scrollPosition);

            DrawIntro(settings);
            EditorGUILayout.Separator();

            if (Foldout("Primitive", true))
            {
                EditorGUI.indentLevel++;

                DrawCustomControls(settings);
                EditorGUILayout.Separator();

                EditorGUI.indentLevel--;
            }

            DrawVertexControls(settings);
            EditorGUILayout.Separator();

            DrawTriangleControls(settings);
            EditorGUILayout.Separator();

            DrawUVControls(settings, settings.UV, "UV");
            EditorGUILayout.Separator();

            DrawUVControls(settings, settings.UV1, "UV1");
            EditorGUILayout.Separator();

            DrawUVControls(settings, settings.UV2, "UV2");
            EditorGUILayout.Separator();

            DrawColorControls(settings);
            EditorGUILayout.Separator();

            DrawNormalControls(settings);
            EditorGUILayout.Separator();

            DrawBuildControls(settings);

            GUILayout.EndScrollView();

            GUILayout.EndVertical();
        }
Example #13
0
        /// <summary>
        /// Draws controls for Colors.
        /// </summary>
        /// <param name="settings"></param>
        protected virtual void DrawColorControls(GeometryBuilderSettings settings)
        {
            bool enabled = settings.Color.Enabled = ToggleFoldout("Color");

            if (enabled)
            {
                EditorGUI.indentLevel++;

                settings.Color.Tint = EditorGUILayout.ColorField(
                    "Color",
                    settings.Color.Tint);
                settings.Color.BlendMode = (BlendMode)EditorGUILayout.EnumPopup(
                    "Blend Mode",
                    settings.Color.BlendMode);

                EditorGUI.indentLevel--;
            }
        }
Example #14
0
        /// <summary>
        /// Draws controls for UVs.
        /// </summary>
        /// <param name="settings"></param>
        /// <param name="uv"></param>
        /// <param name="label"></param>
        protected virtual void DrawUVControls(
            GeometryBuilderSettings settings,
            GeometryBuilderUVSettings uv,
            string label)
        {
            bool enabled = uv.Enabled = ToggleFoldout(label);

            if (enabled)
            {
                EditorGUI.indentLevel++;

                uv.Rect = EditorGUILayout.RectField("Rect", uv.Rect);

                EditorGUILayout.LabelField("Rotation");
                EditorGUI.indentLevel++;
                uv.Rotation.Origin = EditorGUILayout.Vector2Field("Origin", uv.Rotation.Origin);
                uv.Rotation.Theta  = EditorGUILayout.FloatField("Theta", uv.Rotation.Theta);
                EditorGUI.indentLevel--;

                EditorGUI.indentLevel--;
            }
        }
Example #15
0
 /// <summary>
 /// Draws the heading.
 /// </summary>
 /// <param name="settings"></param>
 protected virtual void DrawIntro(GeometryBuilderSettings settings)
 {
     EditorGUI.indentLevel++;
     GUILayout.TextArea(settings.Description ?? "");
     EditorGUI.indentLevel--;
 }
Example #16
0
 /// <summary>
 /// Draws custom controls for a subclass of this renderer.
 /// </summary>
 /// <param name="settings"></param>
 protected virtual void DrawCustomControls(GeometryBuilderSettings settings)
 {
 }