Example #1
0
        private static void RecordRenderPipelineAnalytics()
        {
            if (!GGriffinSettings.Instance.EnableEditorAnalytics)
            {
                return;
            }

            string renderPipeline = Shader.globalRenderPipeline;

            if (renderPipeline.Equals(string.Empty))
            {
                GAnalytics.Record(GAnalytics.RENDER_PIPELINE_BUILTIN, true);
            }
            else if (renderPipeline.Equals("LightweightPipeline"))
            {
                GAnalytics.Record(GAnalytics.RENDER_PIPELINE_LIGHTWEIGHT, true);
            }
            else if (renderPipeline.Equals("UniversalPipeline,LightweightPipeline"))
            {
                GAnalytics.Record(GAnalytics.RENDER_PIPELINE_UNIVERSAL, true);
            }
            else
            {
                GAnalytics.Record(GAnalytics.RENDER_PIPELINE_OTHER, true);
            }
        }
Example #2
0
        private void DrawRenderingGUI()
        {
            string label = "Rendering";
            string id    = "rendering" + data.Id;

            GenericMenu menu = new GenericMenu();

            menu.AddItem(
                new GUIContent("Reset"),
                false,
                () => { data.Rendering.ResetFull(); });
            GEditorCommon.Foldout(label, false, id, () =>
            {
                GRendering settings = data.Rendering;
                EditorGUI.BeginChangeCheck();
                settings.CastShadow       = EditorGUILayout.Toggle("Cast Shadow", settings.CastShadow);
                settings.ReceiveShadow    = EditorGUILayout.Toggle("Receive Shadow", settings.ReceiveShadow);
                settings.DrawFoliage      = EditorGUILayout.Toggle("Draw Foliage", settings.DrawFoliage);
                GUI.enabled               = SystemInfo.supportsInstancing;
                settings.EnableInstancing = EditorGUILayout.Toggle("Enable Instancing", settings.EnableInstancing);
                GUI.enabled               = true;
                settings.BillboardStart   = EditorGUILayout.Slider("Billboard Start", settings.BillboardStart, 0f, GCommon.MAX_TREE_DISTANCE);
                settings.TreeDistance     = EditorGUILayout.Slider("Tree Distance", settings.TreeDistance, 0f, GCommon.MAX_TREE_DISTANCE);
                settings.GrassDistance    = EditorGUILayout.Slider("Grass Distance", settings.GrassDistance, 0f, GCommon.MAX_GRASS_DISTANCE);
                if (EditorGUI.EndChangeCheck())
                {
                    data.SetDirty(GTerrainData.DirtyFlags.Rendering);
                    if (settings.EnableInstancing)
                    {
                        GAnalytics.Record(GAnalytics.ENABLE_INSTANCING, true);
                    }
                }
            }, menu);
        }
Example #3
0
        private void DrawNeighboringGUI()
        {
            string label = "Neighboring";
            string id    = "polaris-v2-neighboring";

            GenericMenu menu = new GenericMenu();

            menu.AddItem(
                new GUIContent("Reset"),
                false,
                () => { ResetNeighboring(); });
            menu.AddItem(
                new GUIContent("Connect"),
                false,
                () => { GStylizedTerrain.ConnectAdjacentTiles(); });

            isNeighboringFoldoutExpanded = GEditorCommon.Foldout(label, false, id, () =>
            {
                EditorGUI.BeginChangeCheck();
                terrain.AutoConnect    = EditorGUILayout.Toggle("Auto Connect", terrain.AutoConnect);
                terrain.GroupId        = EditorGUILayout.DelayedIntField("Group Id", terrain.GroupId);
                terrain.TopNeighbor    = EditorGUILayout.ObjectField("Top Neighbor", terrain.TopNeighbor, typeof(GStylizedTerrain), true) as GStylizedTerrain;
                terrain.BottomNeighbor = EditorGUILayout.ObjectField("Bottom Neighbor", terrain.BottomNeighbor, typeof(GStylizedTerrain), true) as GStylizedTerrain;
                terrain.LeftNeighbor   = EditorGUILayout.ObjectField("Left Neighbor", terrain.LeftNeighbor, typeof(GStylizedTerrain), true) as GStylizedTerrain;
                terrain.RightNeighbor  = EditorGUILayout.ObjectField("Right Neighbor", terrain.RightNeighbor, typeof(GStylizedTerrain), true) as GStylizedTerrain;

                if (EditorGUI.EndChangeCheck())
                {
                    if (terrain.TopNeighbor != null || terrain.BottomNeighbor != null || terrain.LeftNeighbor != null || terrain.RightNeighbor != null)
                    {
                        GAnalytics.Record(GAnalytics.MULTI_TERRAIN, true);
                    }
                }
            }, menu);
        }
 private void OnEnable()
 {
     instance = target as GWindZone;
     if (instance.enabled)
     {
         GAnalytics.Record(GAnalytics.WIND_ZONE, true);
     }
 }
 private void OnEnable()
 {
     instance = target as GWindZone;
     if (instance.enabled)
     {
         GAnalytics.Record(GAnalytics.WIND_ZONE, true);
     }
     SceneView.duringSceneGui += DuringSceneGUI;
 }
        private void RecordShadingAnalytics()
        {
            GTexturingModel texturing = GGriffinSettings.Instance.WizardSettings.TexturingModel;
            string          url       =
                texturing == GTexturingModel.ColorMap ? GAnalytics.SHADING_COLOR_MAP :
                texturing == GTexturingModel.GradientLookup ? GAnalytics.SHADING_GRADIENT_LOOKUP :
                texturing == GTexturingModel.Splat ? GAnalytics.SHADING_SPLAT :
                texturing == GTexturingModel.VertexColor ? GAnalytics.SHADING_VERTEX_COLOR : string.Empty;

            GAnalytics.Record(url);
        }
        private void DrawCollectionsGUI()
        {
            string label = "Collections";
            string id    = "collections" + instance.GetInstanceID().ToString();

            GEditorCommon.Foldout(label, true, id, () =>
            {
                Rect r;
                r = EditorGUILayout.GetControlRect();
                if (GUI.Button(r, "Other Assets From Pinwheel"))
                {
                    GAnalytics.Record(GAnalytics.ASSET_EXPLORER_LINK_CLICK);
                    GAssetExplorer.ShowPinwheelAssets();
                }

                r = EditorGUILayout.GetControlRect();
                if (GUI.Button(r, "Vegetation"))
                {
                    GAnalytics.Record(GAnalytics.ASSET_EXPLORER_LINK_CLICK);
                    GAssetExplorer.ShowVegetationLink();
                }

                r = EditorGUILayout.GetControlRect();
                if (GUI.Button(r, "Rock & Props"))
                {
                    GAnalytics.Record(GAnalytics.ASSET_EXPLORER_LINK_CLICK);
                    GAssetExplorer.ShowRockPropsLink();
                }

                r = EditorGUILayout.GetControlRect();
                if (GUI.Button(r, "Water"))
                {
                    GAnalytics.Record(GAnalytics.ASSET_EXPLORER_LINK_CLICK);
                    GAssetExplorer.ShowWaterLink();
                }

                r = EditorGUILayout.GetControlRect();
                if (GUI.Button(r, "Sky & Ambient"))
                {
                    GAnalytics.Record(GAnalytics.ASSET_EXPLORER_LINK_CLICK);
                    GAssetExplorer.ShowSkyAmbientLink();
                }

                r = EditorGUILayout.GetControlRect();
                if (GUI.Button(r, "Character"))
                {
                    GAnalytics.Record(GAnalytics.ASSET_EXPLORER_LINK_CLICK);
                    GAssetExplorer.ShowCharacterLink();
                }
            });
        }
Example #8
0
        private void DrawRenderingGUI()
        {
            string label = "Rendering";
            string id    = "rendering" + data.Id;

            GenericMenu menu = new GenericMenu();

            menu.AddItem(
                new GUIContent("Reset"),
                false,
                () => { data.Rendering.ResetFull(); });
            GEditorCommon.Foldout(label, false, id, () =>
            {
                GRendering settings = data.Rendering;
                EditorGUI.BeginChangeCheck();
                GEditorCommon.Header("Terrain Shadow");
                settings.CastShadow    = EditorGUILayout.Toggle("Cast Shadow", settings.CastShadow);
                settings.ReceiveShadow = EditorGUILayout.Toggle("Receive Shadow", settings.ReceiveShadow);

                GEditorCommon.Header("Tree Rendering");
                settings.DrawTrees        = EditorGUILayout.Toggle("Draw", settings.DrawTrees);
                GUI.enabled               = SystemInfo.supportsInstancing;
                settings.EnableInstancing = EditorGUILayout.Toggle("Enable Instancing", settings.EnableInstancing);
                GUI.enabled               = true;
                settings.BillboardStart   = EditorGUILayout.Slider("Billboard Start", settings.BillboardStart, 0f, GCommon.MAX_TREE_DISTANCE);
                settings.TreeDistance     = EditorGUILayout.Slider("Tree Distance", settings.TreeDistance, 0f, GCommon.MAX_TREE_DISTANCE);
                GRuntimeSettings.Instance.renderingDefault.cullVolumeBias = EditorGUILayout.Slider("Cull Volume Bias", GRuntimeSettings.Instance.renderingDefault.cullVolumeBias, 0f, 100f);

                GEditorCommon.Header("Grass & Detail Rendering");
                settings.DrawGrasses    = EditorGUILayout.Toggle("Draw", settings.DrawGrasses);
                settings.GrassDistance  = EditorGUILayout.Slider("Grass Distance", settings.GrassDistance, 0f, GCommon.MAX_GRASS_DISTANCE);
                settings.GrassFadeStart = EditorGUILayout.Slider("Fade Start", settings.GrassFadeStart, 0f, 1f);

                if (EditorGUI.EndChangeCheck())
                {
                    data.SetDirty(GTerrainData.DirtyFlags.Rendering);
                    if (settings.EnableInstancing)
                    {
                        GAnalytics.Record(GAnalytics.ENABLE_INSTANCING, true);
                    }
                }

                GEditorCommon.Header("Topographic");
                GEditorSettings.Instance.topographic.enable = EditorGUILayout.Toggle("Enable", GEditorSettings.Instance.topographic.enable);
            }, menu);
        }
Example #9
0
        private static void RecordRenderPipelineAnalytics()
        {
            string renderPipeline = Shader.globalRenderPipeline;

            if (renderPipeline.Equals(string.Empty))
            {
                GAnalytics.Record(GAnalytics.RENDER_PIPELINE_BUILTIN, true);
            }
            else if (renderPipeline.Equals("LightweightPipeline"))
            {
                GAnalytics.Record(GAnalytics.RENDER_PIPELINE_LIGHTWEIGHT, true);
            }
            else if (renderPipeline.Equals("UniversalPipeline,LightweightPipeline"))
            {
                GAnalytics.Record(GAnalytics.RENDER_PIPELINE_UNIVERSAL, true);
            }
            else
            {
                GAnalytics.Record(GAnalytics.RENDER_PIPELINE_OTHER, true);
            }
        }
Example #10
0
        private void DrawActionGUI()
        {
            string label = "Actions";
            string id    = "actions" + instance.GetInstanceID().ToString();

            GEditorCommon.Foldout(label, true, id, () =>
            {
                Rect createButtonRect = EditorGUILayout.GetControlRect();
                if (GUI.Button(createButtonRect, "Create static obstacles"))
                {
                    GAnalytics.Record(GAnalytics.NAVIGATION_HELPER);
                    instance.CreateStaticObstacles();
                }

                Rect deleteButtonRect = EditorGUILayout.GetControlRect();
                if (GUI.Button(deleteButtonRect, "Delete static obstacles"))
                {
                    instance.DeleteStaticObstacles();
                }
            });
        }
 public static void ShowStylizedVegetationLink()
 {
     GAnalytics.Record(GAnalytics.LINK_EXPLORE_ASSET);
     GAssetExplorer.ShowVegetationLink();
 }
 public static void ShowOnlineUserGuide()
 {
     GAnalytics.Record(GAnalytics.LINK_ONLINE_MANUAL);
     Application.OpenURL(GCommon.ONLINE_MANUAL);
 }
        public static void RecordAnalytics()
        {
#if UNITY_EDITOR_WIN
            GAnalytics.Record(GAnalytics.OS_WINDOWS, true);
#elif UNITY_EDITOR_OSX
            GAnalytics.Record(GAnalytics.OS_MAC, true);
#elif UNITY_EDITOR_LINUX
            GAnalytics.Record(GAnalytics.OS_LINUX, true);
#endif

            BuildTarget      buildTarget = EditorUserBuildSettings.activeBuildTarget;
            BuildTargetGroup buildGroup  = BuildPipeline.GetBuildTargetGroup(buildTarget);
            if (buildGroup == BuildTargetGroup.Standalone)
            {
                GAnalytics.Record(GAnalytics.PLATFORM_PC, true);
            }
            else if (buildGroup == BuildTargetGroup.iOS || buildGroup == BuildTargetGroup.Android)
            {
                GAnalytics.Record(GAnalytics.PLATFORM_MOBILE, true);
            }
            else if (buildGroup == BuildTargetGroup.WebGL)
            {
                GAnalytics.Record(GAnalytics.PLATFORM_WEB, true);
            }
            else if (buildGroup == BuildTargetGroup.PS4 || buildGroup == BuildTargetGroup.XboxOne || buildGroup == BuildTargetGroup.Switch)
            {
                GAnalytics.Record(GAnalytics.PLATFORM_CONSOLE, true);
            }
            else
            {
                GAnalytics.Record(GAnalytics.PLATFORM_OTHER, true);
            }

#if UNITY_2019_1 || UNITY_2019_2
            if (PlayerSettings.virtualRealitySupported)
            {
                GAnalytics.Record(GAnalytics.XR_PROJECT, true);
            }
#elif UNITY_2019_3_OR_NEWER
            if (isXrManagementInstalled)
            {
                GAnalytics.Record(GAnalytics.XR_PROJECT, true);
            }
#endif

            if (PlayerSettings.colorSpace == ColorSpace.Gamma)
            {
                GAnalytics.Record(GAnalytics.COLOR_SPACE_GAMMA, true);
            }
            else if (PlayerSettings.colorSpace == ColorSpace.Linear)
            {
                GAnalytics.Record(GAnalytics.COLOR_SPACE_LINEAR, true);
            }

            if (isASEInstalled)
            {
                GAnalytics.Record(GAnalytics.INTEGRATION_AMPLIFY_SHADER_EDITOR, true);
            }
            if (isPoseidonInstalled)
            {
                GAnalytics.Record(GAnalytics.INTEGRATION_POSEIDON, true);
            }
            if (isCSharpWizardInstalled)
            {
                GAnalytics.Record(GAnalytics.INTEGRATION_CSHARP_WIZARD, true);
            }
            if (isMeshToFileInstalled)
            {
                GAnalytics.Record(GAnalytics.INTEGRATION_MESH_TO_FILE, true);
            }
            if (isVegetationStudioProExtensionInstalled)
            {
                GAnalytics.Record(GAnalytics.INTEGRATION_VEGETATION_STUDIO, true);
            }
            if (isMicroSplatIntegrationInstalled)
            {
                GAnalytics.Record(GAnalytics.INTEGRATION_MICRO_SPLAT, true);
            }
        }
 public static void ShowYoutubeChannel()
 {
     GAnalytics.Record(GAnalytics.LINK_YOUTUBE);
     Application.OpenURL(GCommon.YOUTUBE_CHANNEL);
 }
Example #15
0
        private void DrawFoliageGUI()
        {
            string label = "Foliage";
            string id    = "foliage" + data.Id;

            GenericMenu menu = new GenericMenu();

            menu.AddItem(
                new GUIContent("Reset"),
                false,
                () => { ConfirmAndResetFoliage(); });
            menu.AddItem(
                new GUIContent("Refresh"),
                false,
                () => { data.Foliage.Refresh(); });
            menu.AddItem(
                new GUIContent("Clean Up"),
                false,
                () => { data.Foliage.CleanUp(); });
            menu.AddItem(
                new GUIContent("Clear All Trees"),
                false,
                () => { ConfirmAndClearAllTrees(); });
            menu.AddItem(
                new GUIContent("Clear All Grasses"),
                false,
                () => { ConfirmAndClearAllGrasses(); });

            if (foliageAdditionalContextAction != null && foliageAdditionalContextAction.Count > 0)
            {
                menu.AddSeparator(null);
                for (int i = 0; i < foliageAdditionalContextAction.Count; ++i)
                {
                    menu.AddItem(
                        new GUIContent(foliageAdditionalContextAction[i].Name),
                        foliageAdditionalContextAction[i].IsOn,
                        foliageAdditionalContextAction[i].Action);
                }
            }

            GEditorCommon.Foldout(label, false, id, () =>
            {
                GFoliage settings = data.Foliage;
                EditorGUI.BeginChangeCheck();
                settings.Trees         = EditorGUILayout.ObjectField("Trees", settings.Trees, typeof(GTreePrototypeGroup), false) as GTreePrototypeGroup;
                settings.TreeSnapMode  = (GSnapMode)EditorGUILayout.EnumPopup("Snap Mode", settings.TreeSnapMode);
                SerializedObject so    = new SerializedObject(settings);
                SerializedProperty sp0 = so.FindProperty("treeSnapLayerMask");
                if (settings.TreeSnapMode == GSnapMode.World && sp0 != null)
                {
                    EditorGUILayout.PropertyField(sp0, new GUIContent("Snap Layers"));
                }

                GUI.enabled = false;
                EditorGUILayout.LabelField("Tree Instance Count", settings.TreeInstances.Count.ToString());
                GUI.enabled = true;
                if (EditorGUI.EndChangeCheck())
                {
                    so.ApplyModifiedProperties();
                    data.SetDirty(GTerrainData.DirtyFlags.Foliage);
                }

                sp0.Dispose();

                EditorGUI.BeginChangeCheck();
                settings.Grasses       = EditorGUILayout.ObjectField("Grasses", settings.Grasses, typeof(GGrassPrototypeGroup), false) as GGrassPrototypeGroup;
                settings.PatchGridSize = EditorGUILayout.IntField("Patch Grid Size", settings.PatchGridSize);
                settings.GrassSnapMode = (GSnapMode)EditorGUILayout.EnumPopup("Snap Mode", settings.GrassSnapMode);
                SerializedProperty sp1 = so.FindProperty("grassSnapLayerMask");
                if (settings.GrassSnapMode == GSnapMode.World && sp1 != null)
                {
                    EditorGUILayout.PropertyField(sp1, new GUIContent("Snap Layers"));
                }
                settings.EnableInteractiveGrass = EditorGUILayout.Toggle("Interactive Grass", settings.EnableInteractiveGrass);
                if (settings.EnableInteractiveGrass)
                {
                    settings.VectorFieldMapResolution = EditorGUILayout.DelayedIntField("Vector Field Map Resolution", settings.VectorFieldMapResolution);
                    settings.BendSensitive            = EditorGUILayout.Slider("Bend Sensitive", settings.BendSensitive, 0f, 1f);
                    settings.RestoreSensitive         = EditorGUILayout.Slider("Restore Sensitive", settings.RestoreSensitive, 0f, 1f);
                }

                GUI.enabled = false;
                EditorGUILayout.LabelField("Grass Instance Count", settings.GrassInstanceCount.ToString());

                string storageLabel =
                    settings.EstimatedGrassStorageMB < 1000 ? string.Format("{0} MB", settings.EstimatedGrassStorageMB.ToString("0.00")) :
                    string.Format("{0} GB", (settings.EstimatedGrassStorageMB / 1000f).ToString("0.00"));
                if (settings.EstimatedGrassStorageMB >= 100)
                {
                    storageLabel = string.Format("<color=red>{0}</color>", storageLabel);
                }

                string storageWarning = null;
                if (settings.EstimatedGrassStorageMB >= 100)
                {
                    storageWarning = "Grass storage is quite high, try reduce some instances for better save/load and serialization!";
                }

                EditorGUILayout.LabelField(new GUIContent("Estimated Storage"), new GUIContent(storageLabel, storageWarning), GEditorCommon.RichTextLabel);

                GUI.enabled = true;
                if (EditorGUI.EndChangeCheck())
                {
                    so.ApplyModifiedProperties();
                    data.SetDirty(GTerrainData.DirtyFlags.Foliage);
                    if (settings.EnableInteractiveGrass)
                    {
                        GAnalytics.Record(GAnalytics.ENABLE_INTERACTIVE_GRASS, true);
                    }
                }

                sp1.Dispose();
                so.Dispose();
            }, menu);
        }
 public static void ShowStylizedCharacterLink()
 {
     GAnalytics.Record(GAnalytics.LINK_EXPLORE_ASSET);
     GAssetExplorer.ShowCharacterLink();
 }
 public static void ShowFacebookPage()
 {
     GAnalytics.Record(GAnalytics.LINK_FACEBOOK);
     Application.OpenURL(GCommon.FACEBOOK_PAGE);
 }
 private void RecordSetShaderAnalytics()
 {
     GAnalytics.Record(GAnalytics.WIZARD_SET_SHADER);
 }
 public static void ShowStylizedSkyAmbientLink()
 {
     GAnalytics.Record(GAnalytics.LINK_EXPLORE_ASSET);
     GAssetExplorer.ShowSkyAmbientLink();
 }
Example #20
0
        private void DrawFoliageGUI()
        {
            string label = "Foliage";
            string id    = "foliage" + data.Id;

            GenericMenu menu = new GenericMenu();

            menu.AddItem(
                new GUIContent("Reset"),
                false,
                () => { ConfirmAndResetFoliage(); });
            menu.AddItem(
                new GUIContent("Refresh"),
                false,
                () => { data.Foliage.Refresh(); });
            menu.AddItem(
                new GUIContent("Clear All Trees"),
                false,
                () => { ConfirmAndClearAllTrees(); });
            menu.AddItem(
                new GUIContent("Clear All Grasses"),
                false,
                () => { ConfirmAndClearAllGrasses(); });

            if (foliageAdditionalContextAction != null && foliageAdditionalContextAction.Count > 0)
            {
                menu.AddSeparator(null);
                for (int i = 0; i < foliageAdditionalContextAction.Count; ++i)
                {
                    menu.AddItem(
                        new GUIContent(foliageAdditionalContextAction[i].Name),
                        foliageAdditionalContextAction[i].IsOn,
                        foliageAdditionalContextAction[i].Action);
                }
            }

            GFoliage settings           = data.Foliage;
            bool     showUpgradeMessage = settings.grassVersion < GFoliage.GRASS_VERSION_COMPRESSED;

            if (showUpgradeMessage)
            {
                menu.AddSeparator(null);
                menu.AddItem(
                    new GUIContent("Upgrade Grass Serialize Version"),
                    false,
                    () =>
                {
                    settings.Internal_UpgradeGrassSerializeVersion();
                });
            }

            string headerWarning = null;

            if (showUpgradeMessage)
            {
                headerWarning = "New grass serialize version is available, use context menu to upgrade (Recommended).";
            }

            GEditorCommon.Foldout(label, false, id, () =>
            {
                EditorGUI.BeginChangeCheck();
                GEditorCommon.Header("Trees");
                settings.Trees        = EditorGUILayout.ObjectField("Prototypes", settings.Trees, typeof(GTreePrototypeGroup), false) as GTreePrototypeGroup;
                settings.TreeSnapMode = (GSnapMode)EditorGUILayout.EnumPopup("Snap Mode", settings.TreeSnapMode);
                if (settings.TreeSnapMode == GSnapMode.World)
                {
                    settings.TreeSnapLayerMask = EditorGUILayout.LayerField("Snap Layer", settings.TreeSnapLayerMask);
                }

                GUI.enabled = false;
                EditorGUILayout.LabelField("Tree Instance Count", settings.TreeInstances.Count.ToString());
                GUI.enabled = true;
                if (EditorGUI.EndChangeCheck())
                {
                    data.SetDirty(GTerrainData.DirtyFlags.Foliage);
                }

                EditorGUI.BeginChangeCheck();
                GEditorCommon.Header("Grasses & Details");
                settings.Grasses       = EditorGUILayout.ObjectField("Prototypes", settings.Grasses, typeof(GGrassPrototypeGroup), false) as GGrassPrototypeGroup;
                settings.PatchGridSize = EditorGUILayout.DelayedIntField("Patch Grid Size", settings.PatchGridSize);

                settings.GrassSnapMode = (GSnapMode)EditorGUILayout.EnumPopup("Snap Mode", settings.GrassSnapMode);
                if (settings.GrassSnapMode == GSnapMode.World)
                {
                    settings.GrassSnapLayerMask = EditorGUILayout.LayerField("Snap Layer", settings.GrassSnapLayerMask);
                }
                settings.EnableInteractiveGrass = EditorGUILayout.Toggle("Interactive Grass", settings.EnableInteractiveGrass);
                if (settings.EnableInteractiveGrass)
                {
                    settings.VectorFieldMapResolution = EditorGUILayout.DelayedIntField("Vector Field Map Resolution", settings.VectorFieldMapResolution);
                    settings.BendSensitive            = EditorGUILayout.Slider("Bend Sensitive", settings.BendSensitive, 0f, 1f);
                    settings.RestoreSensitive         = EditorGUILayout.Slider("Restore Sensitive", settings.RestoreSensitive, 0f, 1f);
                }

                GUI.enabled = false;
                EditorGUILayout.LabelField("Grass Instance Count", settings.GrassInstanceCount.ToString());

                GUI.enabled = true;
                if (EditorGUI.EndChangeCheck())
                {
                    data.SetDirty(GTerrainData.DirtyFlags.Foliage);
                    if (settings.EnableInteractiveGrass)
                    {
                        GAnalytics.Record(GAnalytics.ENABLE_INTERACTIVE_GRASS, true);
                    }
                }
            },
                                  menu,
                                  headerWarning);
        }
 public static void ShowAssetsFromPinwheel()
 {
     GAnalytics.Record(GAnalytics.LINK_EXPLORE_ASSET);
     GAssetExplorer.ShowPinwheelAssets();
 }
 public static void ShowMeshToFileLink()
 {
     GAnalytics.Record(GAnalytics.LINK_EXPLORE_ASSET);
     GAssetExplorer.ShowMeshToFileLink();
 }
 public static void ShowCSharpWizardLink()
 {
     GAnalytics.Record(GAnalytics.LINK_EXPLORE_ASSET);
     GAssetExplorer.ShowCSharpWizardLink();
 }
 public static void ShowJupiterLink()
 {
     GAnalytics.Record(GAnalytics.LINK_EXPLORE_ASSET);
     GAssetExplorer.ShowJupiterLink();
 }
 public static void ShowStylizedWaterLink()
 {
     GAnalytics.Record(GAnalytics.LINK_EXPLORE_ASSET);
     GAssetExplorer.ShowRockPropsLink();
 }
 private void RecordCreateTerrainAnalytics()
 {
     GAnalytics.Record(GAnalytics.WIZARD_CREATE_TERRAIN);
 }