Repository: Unity-Technologies/UnityCsReference
Branch: master
Commit: 59b03b8a0f17
Files: 4921
Total size: 46.4 MB
Directory structure:
gitextract_76xfp494/
├── Editor/
│ ├── IncrementalBuildPipeline/
│ │ ├── BeeBuildProgramCommon.Data/
│ │ │ ├── BeeBuildProgramCommon.Data.gen.csproj
│ │ │ └── Data.cs
│ │ ├── PlayerBuildProgramLibrary.Data/
│ │ │ ├── Data.cs
│ │ │ └── PlayerBuildProgramLibrary.Data.gen.csproj
│ │ └── ScriptCompilationBuildProgram.Data/
│ │ ├── Data.cs
│ │ └── ScriptCompilationBuildProgram.Data.gen.csproj
│ └── Mono/
│ ├── 2D/
│ │ ├── Common/
│ │ │ ├── ScriptBindings/
│ │ │ │ └── SpriteEditorExtension.bindings.cs
│ │ │ ├── SpriteEditorUtility.cs
│ │ │ ├── TexturePlatformSettingsController.cs
│ │ │ ├── TexturePlatformSettingsFormatHelper.cs
│ │ │ └── TexturePlatformSettingsView.cs
│ │ ├── Interface/
│ │ │ ├── IEvent.cs
│ │ │ └── ITexturePlatformSetting.cs
│ │ └── SpriteAtlas/
│ │ ├── EditorSpriteAtlas.bindings.cs
│ │ ├── EditorSpritePacking.bindings.cs
│ │ ├── SpriteAtlasAsset.bindings.cs
│ │ ├── SpriteAtlasImporter.bindings.cs
│ │ ├── SpriteAtlasImporterInspector.cs
│ │ └── SpriteAtlasInspector.cs
│ ├── Accessibility/
│ │ └── UserAccessibilitySettings.cs
│ ├── Animation/
│ │ ├── AnimationClipSettings.bindings.cs
│ │ ├── AnimationClipStats.bindings.cs
│ │ ├── AnimationMode.bindings.cs
│ │ ├── AnimationUtility.bindings.cs
│ │ ├── AnimationWindow/
│ │ │ ├── AddCurvesPopup.cs
│ │ │ ├── AddCurvesPopupHierarchy.cs
│ │ │ ├── AddCurvesPopupHierarchyBuilder.cs
│ │ │ ├── AddCurvesPopupHierarchyDataSource.cs
│ │ │ ├── AddCurvesPopupHierarchyGUI.cs
│ │ │ ├── AnimEditor.cs
│ │ │ ├── AnimEditorOverlay.cs
│ │ │ ├── AnimationClipSelectionItem.cs
│ │ │ ├── AnimationContextualPropertyMenu.cs
│ │ │ ├── AnimationKeyTime.cs
│ │ │ ├── AnimationRecording.cs
│ │ │ ├── AnimationWindow.cs
│ │ │ ├── AnimationWindowClipPopup.cs
│ │ │ ├── AnimationWindowClipboard.cs
│ │ │ ├── AnimationWindowControl.cs
│ │ │ ├── AnimationWindowControllerAttribute.cs
│ │ │ ├── AnimationWindowCurve.cs
│ │ │ ├── AnimationWindowEvent.cs
│ │ │ ├── AnimationWindowEventInspector.cs
│ │ │ ├── AnimationWindowHierarchy.cs
│ │ │ ├── AnimationWindowHierarchyDataSource.cs
│ │ │ ├── AnimationWindowHierarchyGUI.cs
│ │ │ ├── AnimationWindowHierarchyNode.cs
│ │ │ ├── AnimationWindowKeySelection.cs
│ │ │ ├── AnimationWindowKeyframe.cs
│ │ │ ├── AnimationWindowManipulator.cs
│ │ │ ├── AnimationWindowOptions.cs
│ │ │ ├── AnimationWindowSelectionItem.cs
│ │ │ ├── AnimationWindowState.cs
│ │ │ ├── AnimationWindowStyles.cs
│ │ │ ├── AnimationWindowUtility.cs
│ │ │ ├── ControlPointRenderer.cs
│ │ │ ├── CurveBindingUtility.cs
│ │ │ ├── CurveEditor.cs
│ │ │ ├── CurveEditorRectangleTool.cs
│ │ │ ├── CurveEditorSelection.cs
│ │ │ ├── CurveEditorSettings.cs
│ │ │ ├── CurveEditorWindow.cs
│ │ │ ├── CurveMenuManager.cs
│ │ │ ├── CurveRenderer/
│ │ │ │ ├── BoolCurveRenderer.cs
│ │ │ │ ├── CurveRenderer.cs
│ │ │ │ ├── EulerCurveCombinedRenderer.cs
│ │ │ │ ├── EulerCurveRenderer.cs
│ │ │ │ ├── IntCurveRenderer.cs
│ │ │ │ └── NormalCurveRenderer.cs
│ │ │ ├── Deprecated/
│ │ │ │ ├── AnimationEventTimeline.cs
│ │ │ │ ├── EditorGUIExt.cs
│ │ │ │ └── UtilityClasses.cs
│ │ │ ├── DopeLine.cs
│ │ │ ├── DopeSheetEditor.cs
│ │ │ ├── DopeSheetEditorRectangleTool.cs
│ │ │ ├── GameObjectSelectionItem.cs
│ │ │ ├── IAnimationContextualResponder.cs
│ │ │ ├── IAnimationRecordingState.cs
│ │ │ ├── IAnimationWindowControl.cs
│ │ │ ├── IAnimationWindowController.cs
│ │ │ ├── MinMaxCurveEditorWindow.cs
│ │ │ ├── RectangleTool.cs
│ │ │ └── RotationCurveInterpolation.cs
│ │ ├── AnimatorController.cs
│ │ ├── BlendTree.cs
│ │ ├── EditorCurveBinding.bindings.cs
│ │ ├── GameObjectRecorder.bindings.cs
│ │ ├── MaterialAnimationUtility.cs
│ │ ├── MecanimUtilities.cs
│ │ ├── SerializedStringTable.cs
│ │ ├── StateMachine.cs
│ │ ├── TickHandler.cs
│ │ ├── TickStyle.cs
│ │ ├── TimeArea.cs
│ │ ├── TransitionPreview.cs
│ │ └── ZoomableArea.cs
│ ├── AnimationCurvePreviewCache.bindings.cs
│ ├── AnimatorController.bindings.cs
│ ├── AnimatorControllerLayer.bindings.cs
│ ├── Annotation/
│ │ ├── AnnotationUtility.bindings.cs
│ │ ├── AnnotationWindow.cs
│ │ ├── GizmoInfo.cs
│ │ ├── GizmoUtility.cs
│ │ ├── LayerVisibilityWindow.cs
│ │ ├── SceneFXWindow.cs
│ │ ├── SceneRenderModeWindow.cs
│ │ └── SceneViewCameraWindow.cs
│ ├── ArrayUtility.cs
│ ├── AssemblyHelper.cs
│ ├── AssemblyInfo/
│ │ └── AssemblyInfo.cs
│ ├── AssemblyReloadEvents.cs
│ ├── AssemblyValidation.cs
│ ├── AssetDatabase/
│ │ ├── AssetDatabase.cs
│ │ ├── AssetDatabase.deprecated.cs
│ │ ├── AssetDatabaseSearching.cs
│ │ ├── AssetImportInProgressProxy.bindings.cs
│ │ ├── AssetMoveInfo.cs
│ │ ├── AssetPreview.bindings.cs
│ │ └── AssetsModifiedProcessor.cs
│ ├── AssetDeleteResult.cs
│ ├── AssetModificationProcessor.cs
│ ├── AssetMoveResult.cs
│ ├── AssetPipeline/
│ │ ├── AssemblyDefinitionImporter.cs
│ │ ├── AssemblyDefinitionReferenceImporter.cs
│ │ ├── AssetImportContext.bindings.cs
│ │ ├── AssetImporter.bindings.cs
│ │ ├── BumpMapSettings.bindings.cs
│ │ ├── CameraDescription.bindings.cs
│ │ ├── ComputeShaderImporter.bindings.cs
│ │ ├── IHVImageFormatImporter.bindings.cs
│ │ ├── ImportLog.bindings.cs
│ │ ├── LightDescription.bindings.cs
│ │ ├── LocalCacheServer.cs
│ │ ├── MaterialDescription.bindings.cs
│ │ ├── ShaderImporter.bindings.cs
│ │ ├── ShaderIncludeImporter.bindings.cs
│ │ ├── SpeedTree/
│ │ │ ├── SpeedTree9Importer.cs
│ │ │ ├── SpeedTree9ImporterEditor.cs
│ │ │ ├── SpeedTree9ImporterMaterialEditor.cs
│ │ │ ├── SpeedTree9ImporterModelEditor.cs
│ │ │ ├── SpeedTree9ImporterWindEditor.cs
│ │ │ ├── SpeedTree9Reader.cs
│ │ │ ├── SpeedTreeImporterCommon.cs
│ │ │ ├── SpeedTreeImporterOutputData.cs
│ │ │ └── SpeedTreeImporterSettings.cs
│ │ ├── SpeedTreeImporter.bindings.cs
│ │ ├── TextureGenerator.bindings.cs
│ │ ├── TextureImporter.bindings.cs
│ │ ├── TextureImporterEnums.cs
│ │ ├── TextureImporterTypes.bindings.cs
│ │ └── TextureUtil.bindings.cs
│ ├── AssetPostprocessor.cs
│ ├── AssetPreviewUpdater.cs
│ ├── AssetStore/
│ │ ├── AssetStoreAsset.cs
│ │ ├── AssetStoreClient.cs
│ │ ├── AssetStoreContext.cs
│ │ ├── AssetStorePreviewManager.cs
│ │ ├── AssetStoreWindow.cs
│ │ └── Json.cs
│ ├── AssetStore.bindings.cs
│ ├── AssetStoreCachePathManager.bindings.cs
│ ├── AssetStoreCachePathManager.cs
│ ├── AssetStoreContext.bindings.cs
│ ├── AssetStoreToolUtils.bindings.cs
│ ├── AssetStoreUtils.bindings.cs
│ ├── AssetsMenuUtility.bindings.cs
│ ├── AsyncHTTPClient.bindings.cs
│ ├── AsyncHTTPClient.cs
│ ├── AttributeHelper.cs
│ ├── Audio/
│ │ ├── Analytics/
│ │ │ ├── AudioAnalytics.cs
│ │ │ ├── AudioRandomContainerBuildAnalyticsEvent.cs
│ │ │ └── AudioRandomContainerQuitAnalyticsEvent.cs
│ │ ├── AudioContainerListDragAndDropManipulator.cs
│ │ ├── AudioContainerWindow.cs
│ │ ├── AudioContainerWindowState.cs
│ │ ├── Bindings/
│ │ │ └── AudioUtil.bindings.cs
│ │ ├── Effects/
│ │ │ ├── AudioCurveRendering.cs
│ │ │ ├── AudioMixerEffectPlugin.cs
│ │ │ ├── Complex.cs
│ │ │ ├── DuckVolumeGUI.cs
│ │ │ ├── IAudioEffectPlugin.cs
│ │ │ ├── IAudioEffectPluginGUI.cs
│ │ │ └── ParamEQGUI.cs
│ │ ├── Mixer/
│ │ │ ├── AudioMixerDescription.cs
│ │ │ ├── Bindings/
│ │ │ │ ├── AudioMixerController.cs
│ │ │ │ └── AudioMixerGroup.cs
│ │ │ └── GUI/
│ │ │ ├── AudioMixerChannelStripView.cs
│ │ │ ├── AudioMixerColorCodes.cs
│ │ │ ├── AudioMixerDrawUtils.cs
│ │ │ ├── AudioMixerEffectGUI.cs
│ │ │ ├── AudioMixerEffectView.cs
│ │ │ ├── AudioMixerExposedParameterView.cs
│ │ │ ├── AudioMixerExposedParametersPopup.cs
│ │ │ ├── AudioMixerGroupTreeView.cs
│ │ │ ├── AudioMixerGroupViewList.cs
│ │ │ ├── AudioMixerSelection.cs
│ │ │ ├── AudioMixerSnapshotView.cs
│ │ │ ├── AudioMixerUtility.cs
│ │ │ ├── AudioMixerWindow.cs
│ │ │ ├── AudioMixersTreeView.cs
│ │ │ ├── ReorderableListWithRenameAndScrollView.cs
│ │ │ └── TreeViewForAudioMixerGroups.cs
│ │ ├── StreamedAudioClipPreview.cs
│ │ ├── UIElements/
│ │ │ ├── AudioContainerElementClipField.cs
│ │ │ ├── AudioLevelMeter.cs
│ │ │ ├── AudioRandomRangeSliderTracker.cs
│ │ │ ├── OnAudioFilterReadLevelMeter.cs
│ │ │ └── Tickmarks.cs
│ │ ├── UIToolkitUtilities.cs
│ │ ├── WaveformPreview.cs
│ │ ├── WaveformPreviewFactory.cs
│ │ └── WaveformStreamer.bindings.cs
│ ├── AvatarUtility.bindings.cs
│ ├── BaseBuildTarget.cs
│ ├── BlendTree.bindings.cs
│ ├── BlendTreePreviewUtility.bindings.cs
│ ├── BrokenPrefabAsset.bindings.cs
│ ├── BrokenPrefabAssetEditor.cs
│ ├── BugReportingTools.bindings.cs
│ ├── BuildPipeline/
│ │ ├── Android/
│ │ │ └── AndroidPostGenerateGradleProject.cs
│ │ ├── AssemblyStripper.cs
│ │ ├── AssemblyTypeInfoGenerator.cs
│ │ ├── BuildFailedException.cs
│ │ ├── BuildPipelineInterfaces.cs
│ │ ├── BuildPlatform.cs
│ │ ├── BuildPlayerContext.cs
│ │ ├── DataBuildDirtyTracker.cs
│ │ ├── DesktopStandaloneBuildWindowExtension.cs
│ │ ├── DesktopStandalonePostProcessor.cs
│ │ ├── DesktopStandaloneUserBuildSettings.cs
│ │ ├── IPostprocessLaunch.cs
│ │ ├── Il2Cpp/
│ │ │ └── IL2CPPUtils.cs
│ │ ├── NamedBuildTarget.cs
│ │ ├── OSArchitecture.cs
│ │ ├── PostprocessBuildPlayer.cs
│ │ ├── RenderPipeline/
│ │ │ ├── EnsureSinglePipelineOnBuild.cs
│ │ │ ├── RenderPipelineBuildProcessor.cs
│ │ │ └── RenderPipelineGlobalSettingsStripper.cs
│ │ ├── RuntimeClassMetadata.cs
│ │ ├── RuntimeClassMetadataUtils.bindings.cs
│ │ └── UnityLinker/
│ │ └── UnityLinkerBuildPipelineData.cs
│ ├── BuildPipeline.bindings.cs
│ ├── BuildPipelineExperimental.cs
│ ├── BuildPlayerDataExtractor.cs
│ ├── BuildPlayerSceneTreeView.cs
│ ├── BuildPlayerWindow.cs
│ ├── BuildPlayerWindowBuildMethods.cs
│ ├── BuildProfile/
│ │ ├── BuildProfile.cs
│ │ ├── BuildProfileAPI.cs
│ │ ├── BuildProfileCLI.cs
│ │ ├── BuildProfileContext.cs
│ │ ├── BuildProfileCreate.cs
│ │ ├── BuildProfileGraphicsSettings.cs
│ │ ├── BuildProfileGraphicsSettingsEditor.cs
│ │ ├── BuildProfileModuleUtil.cs
│ │ ├── BuildProfilePackageAddInfo.cs
│ │ ├── BuildProfilePlatformSettingsBase.cs
│ │ ├── BuildProfilePlayerSettings.cs
│ │ ├── BuildProfileQualitySettings.cs
│ │ ├── BuildProfileQualitySettingsEditor.cs
│ │ ├── BuildProfileRenameOverlay.cs
│ │ ├── BuildProfileSceneListTreeView.cs
│ │ ├── BuildProfileState.cs
│ │ ├── Events.cs
│ │ └── SharedPlatformSettings.cs
│ ├── BuildTarget.cs
│ ├── BuildTargetConverter.cs
│ ├── BuildTargetDiscovery.bindings.cs
│ ├── BuildTargetGroup.cs
│ ├── CSPreProcess.cs
│ ├── Callbacks.cs
│ ├── Camera/
│ │ ├── BuiltinBakedReflectionSystem.bindings.cs
│ │ ├── CameraProjectionCache.cs
│ │ ├── EditorCameraUtils.bindings.cs
│ │ ├── IScriptableBakedReflectionSystem.cs
│ │ ├── IScriptableBakedReflectionSystemStageNotifier.cs
│ │ ├── SceneStateHash.cs
│ │ ├── ScriptableBakedReflectionSystem.cs
│ │ ├── ScriptableBakedReflectionSystemSettings.cs
│ │ └── ScriptableBakedReflectionSystemWrapper.bindings.cs
│ ├── Categorize.cs
│ ├── ChangeTrackerHandle.bindings.cs
│ ├── Clipboard/
│ │ ├── Clipboard.cs
│ │ ├── ClipboardContextMenu.cs
│ │ ├── ClipboardParser.cs
│ │ └── ClipboardState.cs
│ ├── ClipboardUtility.cs
│ ├── CloudBuild/
│ │ └── CloudBuild.cs
│ ├── CodeEditor/
│ │ ├── CodeEditor.cs
│ │ ├── CodeEditorAnalytics.cs
│ │ ├── CodeEditorProjectSync.cs
│ │ ├── DefaultExternalCodeEditor.cs
│ │ ├── ExternalEditor.bindings.cs
│ │ ├── IExternalCodeEditor.cs
│ │ └── SyncVS.cs
│ ├── Collab/
│ │ ├── CollabToUVCSBridge.cs
│ │ └── IVersionControl.cs
│ ├── CollectImportedDependenciesAttribute.cs
│ ├── Commands/
│ │ ├── CommandService.cs
│ │ └── GOCreationCommands.cs
│ ├── CompilationPipeline.bindings.cs
│ ├── ComponentUtility.bindings.cs
│ ├── ComponentUtility.cs
│ ├── ConsoleWindow.cs
│ ├── ConsoleWindowUtility.cs
│ ├── ContainerWindow.bindings.cs
│ ├── ContainerWindow.cs
│ ├── ContextMenuUtility.cs
│ ├── CustomEditorAttributes.bindings.cs
│ ├── CustomEditorAttributes.cs
│ ├── CustomInspectorStubs.cs
│ ├── CutBoard.cs
│ ├── DataMode.cs
│ ├── DefaultAsset.bindings.cs
│ ├── Delayer.cs
│ ├── DeploymentTargets/
│ │ ├── DefaultDeploymentTargetsExtension.cs
│ │ ├── DeploymentTargetLogger.cs
│ │ ├── DeploymentTargetManager.cs
│ │ └── IDeploymentTargetsExtension.cs
│ ├── DisplayUtility.cs
│ ├── DragAndDrop.bindings.cs
│ ├── DrivenPropertyManagerInternal.bindings.cs
│ ├── DrivenRectTransformUndo.cs
│ ├── DropInfo.cs
│ ├── DynamicHints/
│ │ ├── DynamicHintContent.cs
│ │ └── DynamicHintUtility.cs
│ ├── EditorApplication.bindings.cs
│ ├── EditorApplication.cs
│ ├── EditorApplication.deprecated.cs
│ ├── EditorAssemblies.bindings.cs
│ ├── EditorAssemblies.cs
│ ├── EditorBuildSettings.bindings.cs
│ ├── EditorConnectionInternal.bindings.cs
│ ├── EditorGUI.EnumMaskField.deprecated.cs
│ ├── EditorGUI.RenderPipeline.cs
│ ├── EditorGUI.cs
│ ├── EditorGUILayout.RenderPipeline.cs
│ ├── EditorGUILayout.cs
│ ├── EditorGUIUtility.bindings.cs
│ ├── EditorGUIUtility.cs
│ ├── EditorGraphicsSettings.bindings.cs
│ ├── EditorGraphicsSettings.cs
│ ├── EditorHeaderItemAttribute.cs
│ ├── EditorMode/
│ │ ├── MenuService.cs
│ │ └── ModeService.cs
│ ├── EditorPrefs.bindings.cs
│ ├── EditorResources.bindings.cs
│ ├── EditorResources.cs
│ ├── EditorSceneManager.bindings.cs
│ ├── EditorSceneManager.bindings.deprecated.cs
│ ├── EditorSceneManager.cs
│ ├── EditorSerializationUtility.bindings.cs
│ ├── EditorSettings.bindings.cs
│ ├── EditorUserBuildSettings.bindings.cs
│ ├── EditorUserBuildSettings.deprecated.cs
│ ├── EditorUserBuildSettingsEmbeddedCommon.bindings.cs
│ ├── EditorUserBuildSettingsEmbeddedLinux.deprecated.cs
│ ├── EditorUserBuildSettingsQNX.bindings.cs
│ ├── EditorUserBuildSettingsQNX.deprecated.cs
│ ├── EditorUserBuildSettingsUtils.cs
│ ├── EditorUserSettings.bindings.cs
│ ├── EditorUtility.bindings.cs
│ ├── EditorUtility.cs
│ ├── EditorWindow.bindings.cs
│ ├── EditorWindow.cs
│ ├── EnumDataUtility.cs
│ ├── EventWithPerformanceTracker.cs
│ ├── ExportPackageOptions.cs
│ ├── ExternalPlayModeView/
│ │ ├── ExternalPlayModeView.bindings.cs
│ │ └── ExternalPlayModeView.cs
│ ├── FileUtil.bindings.cs
│ ├── FileUtil.cs
│ ├── FlagSet.cs
│ ├── GI/
│ │ ├── DeviceContext.bindings.cs
│ │ ├── InputExtraction.bindings.cs
│ │ ├── InputExtraction.cs
│ │ ├── IntegrationContext.bindings.cs
│ │ ├── InteractiveLightBaking.bindings.cs
│ │ ├── LightBaker.bindings.cs
│ │ ├── LightProbeVisualization.bindings.cs
│ │ ├── LightingDataAsset.bindings.cs
│ │ ├── LightmapEditorSettings.bindings.cs
│ │ ├── LightmapEditorSettingsDeprecated.cs
│ │ ├── LightmapParameters.bindings.cs
│ │ ├── LightmapSnapshot.deprecated.cs
│ │ ├── LightmapVisualization.bindings.cs
│ │ ├── Lightmapping.bindings.cs
│ │ ├── Lightmapping.deprecated.cs
│ │ ├── PostProcessing.bindings.cs
│ │ ├── ProbeIntegrator.bindings.cs
│ │ ├── ProgressState.bindings.cs
│ │ ├── RadeonRaysDeviceContext.bindings.cs
│ │ ├── RadeonRaysLightBaker.bindings.cs
│ │ ├── UnityComputeBake.cs
│ │ ├── WintermuteDeviceContext.bindings.cs
│ │ ├── WintermuteLightBaker.bindings.cs
│ │ └── World.bindings.cs
│ ├── GUI/
│ │ ├── AboutWindow.cs
│ │ ├── AngularDial.cs
│ │ ├── AnimatedValues.cs
│ │ ├── AppStatusBar.cs
│ │ ├── AssetPopupBackend.cs
│ │ ├── AssetSaveDialog.cs
│ │ ├── BumpMapSettingsFixingWindow.cs
│ │ ├── ButtonWithAnimatedIcon.cs
│ │ ├── CacheServerToggle.cs
│ │ ├── CacheServerWindow.cs
│ │ ├── CallbackController.cs
│ │ ├── ColorMutator.cs
│ │ ├── ColorPicker.cs
│ │ ├── ColorPicker.deprecated.cs
│ │ ├── ColumnView.cs
│ │ ├── CreateAssetUtility.cs
│ │ ├── DockArea.cs
│ │ ├── DragRect.cs
│ │ ├── EditorApplicationLayout.cs
│ │ ├── EditorCache.cs
│ │ ├── EditorGUIContents.cs
│ │ ├── EditorGUIInternal.cs
│ │ ├── EditorStyles.cs
│ │ ├── EditorUpdateWindow.cs
│ │ ├── ExposablePopupMenu.cs
│ │ ├── FallbackEditorWindow.cs
│ │ ├── FlexibleMenu/
│ │ │ ├── FlexibleMenu.cs
│ │ │ ├── FlexibleMenuModifyItemUI.cs
│ │ │ └── IFlexibleMenuItemProvider.cs
│ │ ├── FlowLayout.cs
│ │ ├── FoldoutHeader.cs
│ │ ├── GenericMenu.cs
│ │ ├── GradientEditor.cs
│ │ ├── GradientField.cs
│ │ ├── GradientPicker.cs
│ │ ├── HexColorTextField.cs
│ │ ├── IApplyRevertPropertyContextMenuItemProvider.cs
│ │ ├── InternalEditorGUI.cs
│ │ ├── InternalEditorGUILayout.cs
│ │ ├── Knob.cs
│ │ ├── LazyLoadReferenceField.cs
│ │ ├── ListViewElement.cs
│ │ ├── ListViewGUI.cs
│ │ ├── ListViewGUILayout.cs
│ │ ├── ListViewOptions.cs
│ │ ├── ListViewShared.cs
│ │ ├── ListViewState.cs
│ │ ├── MainView.cs
│ │ ├── ManagedDebuggerToggle.cs
│ │ ├── ManagedDebuggerWindow.cs
│ │ ├── MaskFieldGUI.cs
│ │ ├── ObjectField.cs
│ │ ├── PackageExport.cs
│ │ ├── PackageExportTreeView.cs
│ │ ├── PackageImport.cs
│ │ ├── PackageImportTreeView.cs
│ │ ├── PaneDragTab.cs
│ │ ├── PingData.cs
│ │ ├── PopupLocation.cs
│ │ ├── PopupLocationHelper.cs
│ │ ├── PopupWindow.cs
│ │ ├── PopupWindowWithoutFocus.cs
│ │ ├── PreviewResizer.cs
│ │ ├── RenameOverlay.cs
│ │ ├── ReorderableList.cs
│ │ ├── ScalableGUIContent.cs
│ │ ├── ScreenShotting.cs
│ │ ├── SearchField.cs
│ │ ├── SliderWithTexture.cs
│ │ ├── SplitView.cs
│ │ ├── Splitter.cs
│ │ ├── StructPropertyGUI.cs
│ │ ├── SubToolbar.cs
│ │ ├── TargetChoiceHandler.cs
│ │ ├── TextFieldDropDown.cs
│ │ ├── Toolbars/
│ │ │ ├── EditorToolbar.cs
│ │ │ ├── EditorToolbarElementAttribute.cs
│ │ │ ├── EditorToolbarManager.cs
│ │ │ ├── EditorToolbarUtility.cs
│ │ │ ├── MainToolbarImguiContainer.cs
│ │ │ └── Toolbar.cs
│ │ ├── TreeView/
│ │ │ ├── AssetOrGameObjectTreeViewDragging.cs
│ │ │ ├── AssetsTreeViewDataSource.cs
│ │ │ ├── AssetsTreeViewGUI.cs
│ │ │ ├── GameObjectTreeViewDataSource.cs
│ │ │ ├── GameObjectTreeViewGUI.cs
│ │ │ ├── GameObjectTreeViewItem.cs
│ │ │ ├── ITreeViewDataSource.cs
│ │ │ ├── ITreeViewDragging.cs
│ │ │ ├── ITreeViewGUI.cs
│ │ │ ├── LazyTreeViewDataSource.cs
│ │ │ ├── MultiColumnHeader.cs
│ │ │ ├── MultiColumnHeaderDefaults.cs
│ │ │ ├── MultiColumnHeaderState.cs
│ │ │ ├── SubSceneGUI.cs
│ │ │ ├── ToggleTreeView.cs
│ │ │ ├── TreeViewControl/
│ │ │ │ ├── TreeViewControl.cs
│ │ │ │ ├── TreeViewControlDataSource.cs
│ │ │ │ ├── TreeViewControlDefaults.cs
│ │ │ │ ├── TreeViewControlDragging.cs
│ │ │ │ ├── TreeViewControlGUI.cs
│ │ │ │ └── TreeViewOld.cs
│ │ │ ├── TreeViewController.cs
│ │ │ ├── TreeViewDataSource.cs
│ │ │ ├── TreeViewDragging.cs
│ │ │ ├── TreeViewExpandAnimator.cs
│ │ │ ├── TreeViewGUI.cs
│ │ │ ├── TreeViewGUIWithCustomItemHeights.cs
│ │ │ ├── TreeViewItem.cs
│ │ │ ├── TreeViewTests/
│ │ │ │ ├── TreeViewTest.cs
│ │ │ │ ├── TreeViewTestBackEnd.cs
│ │ │ │ ├── TreeViewTestDataSource.cs
│ │ │ │ ├── TreeViewTestDragging.cs
│ │ │ │ ├── TreeViewTestGUI.cs
│ │ │ │ ├── TreeViewTestGUICustom.cs
│ │ │ │ ├── TreeViewTestLazyDataSource.cs
│ │ │ │ ├── TreeViewTestWindow.cs
│ │ │ │ └── TreeViewTestWithCustomHeight.cs
│ │ │ └── TreeViewUtililty.cs
│ │ ├── VUMeter.cs
│ │ ├── VerticalGrid.cs
│ │ └── WindowLayout.cs
│ ├── GUID.bindings.cs
│ ├── GUIDebugger/
│ │ ├── BaseInspectView.cs
│ │ ├── ElementHighlighter.cs
│ │ ├── GUIClipInspectView.cs
│ │ ├── GUILayoutInspectView.cs
│ │ ├── GUINamedControlInspectView.cs
│ │ ├── GUIPropertyInspectView.cs
│ │ ├── GUIViewDebuggerHelper.bindings.cs
│ │ ├── GUIViewDebuggerWindow.cs
│ │ ├── StyleDrawInspectView.cs
│ │ ├── StylePicker.cs
│ │ └── UnifiedInspectView.cs
│ ├── GUIView.bindings.cs
│ ├── GUIView.cs
│ ├── GameObjectChangeTracker.bindings.cs
│ ├── GameObjectUtility.bindings.cs
│ ├── GameObjectUtility.deprecated.cs
│ ├── GameView/
│ │ ├── GameView.cs
│ │ ├── GameViewSize.cs
│ │ ├── GameViewSizeGroup.cs
│ │ ├── GameViewSizeMenu.cs
│ │ ├── GameViewSizes.cs
│ │ ├── GameViewSizesMenuItemProvider.cs
│ │ ├── GameViewSizesMenuModifyItemUI.cs
│ │ ├── GameviewGUI.cs
│ │ ├── IGameViewOnPlayMenuUser.cs
│ │ └── IGameViewSizeMenuUser.cs
│ ├── GenerateIconsWithMipLevels.cs
│ ├── Gizmos/
│ │ └── DrawGizmo.cs
│ ├── GlobalObjectId.bindings.cs
│ ├── GradientPreviewCache.bindings.cs
│ ├── Graphics/
│ │ ├── Analytics/
│ │ │ ├── GraphicsToolLifetimeAnalytic.cs
│ │ │ └── GraphicsToolUsageAnalytic.cs
│ │ ├── EditorMaterialUtility.bindings.cs
│ │ ├── GraphicsStateCollectionImporter.cs
│ │ ├── RenderPipelineGlobalSettingsPostprocessor.cs
│ │ ├── RenderPipelineGraphicsSettingsEditorUtility.cs
│ │ ├── RenderingLayersLimitSettings.cs
│ │ ├── ShaderCompilerData.cs
│ │ ├── StaticBatchingEditorHelper.cs
│ │ └── VulkanDeviceFilterListsEditor.cs
│ ├── Grids/
│ │ ├── EditorSnap.cs
│ │ ├── GridShortcuts.cs
│ │ ├── GridSnapping.cs
│ │ └── SnapSettings.cs
│ ├── Handles/
│ │ ├── ArcHandle.cs
│ │ ├── BoneHandle.cs
│ │ ├── BoundsHandle/
│ │ │ ├── BoxBoundsHandle.cs
│ │ │ ├── CapsuleBoundsHandle.cs
│ │ │ ├── PrimitiveBoundsHandle.cs
│ │ │ └── SphereBoundsHandle.cs
│ │ ├── Button.cs
│ │ ├── ConeFrustrumHandle.cs
│ │ ├── ConeHandle.cs
│ │ ├── Disc.cs
│ │ ├── FreeMove.cs
│ │ ├── FreeRotate.cs
│ │ ├── HandleUtility.bindings.cs
│ │ ├── HandleUtility.cs
│ │ ├── Handles.bindings.cs
│ │ ├── Handles.cs
│ │ ├── PositionHandle.cs
│ │ ├── RadiusHandle.cs
│ │ ├── RectHandle.cs
│ │ ├── RotationHandle.cs
│ │ ├── ScaleHandle.cs
│ │ ├── SimpleRadiusHandle.cs
│ │ ├── Slider1D.cs
│ │ ├── Slider2D.cs
│ │ ├── SliderScale.cs
│ │ ├── TransformHandle.cs
│ │ └── VertexSnapping.cs
│ ├── Hardware.bindings.cs
│ ├── Help.bindings.cs
│ ├── Help.cs
│ ├── HierarchyProperty.bindings.cs
│ ├── HomeWindow.bindings.cs
│ ├── HostView.cs
│ ├── HyperLinkClickedEventArgs.cs
│ ├── IAudioPlatformProperties.cs
│ ├── IBuildPlatformProperties.cs
│ ├── IBuildTarget.cs
│ ├── ICleanuppable.cs
│ ├── IDerivedBuildTarget.cs
│ ├── IDerivedBuildTargetProvider.cs
│ ├── IDropArea.cs
│ ├── IGraphicsPlatformProperties.cs
│ ├── IHasCustomMenu.cs
│ ├── IIconPlatformProperties.cs
│ ├── IInsightsPlatformProperties.cs
│ ├── IPlatformProperties.cs
│ ├── IPlayerConnectionPlatformProperties.cs
│ ├── ISubtargetPlatformProperties.cs
│ ├── IUIPlatformProperties.cs
│ ├── IVRPlatformProperties.cs
│ ├── IconSelector.cs
│ ├── ImportSettings/
│ │ ├── AnimationClipInfoProperties.cs
│ │ ├── BaseSpeedTreeImporterTabUI.cs
│ │ ├── DesktopPluginImporterExtension.cs
│ │ ├── EditorPluginImporterExtension.cs
│ │ ├── ExposeTransformEditor.cs
│ │ ├── IHVImageFormatImporterInspector.cs
│ │ ├── ImportSettingsInternalID.cs
│ │ ├── SpeedTreeImporterInspector.cs
│ │ ├── SpeedTreeImporterMaterialEditor.cs
│ │ ├── SpeedTreeImporterModelEditor.cs
│ │ ├── TextureImportPlatformSettings.cs
│ │ ├── TextureImportValidFormats.cs
│ │ └── TextureImporterInspector.cs
│ ├── InSceneAssetUtility.bindings.cs
│ ├── Inspector/
│ │ ├── AimConstraintEditor.cs
│ │ ├── AnimationClipEditor.cs
│ │ ├── AnimationEditor.cs
│ │ ├── AnimatorInspector.cs
│ │ ├── AnimatorOverrideControllerInspector.cs
│ │ ├── AssemblyDefinitionImporterInspector.cs
│ │ ├── AssemblyDefinitionReferenceImporterInspector.cs
│ │ ├── AssetBundleNameGUI.cs
│ │ ├── AudioChorusFilterEditor.cs
│ │ ├── AudioClipInspector.cs
│ │ ├── AudioDistortionFilterInspector.cs
│ │ ├── AudioEchoFilterInspector.cs
│ │ ├── AudioFilterGUI.cs
│ │ ├── AudioHighPassFilterInspector.cs
│ │ ├── AudioLowPassFilterInspector.cs
│ │ ├── AudioManagerInspector.cs
│ │ ├── AudioMixerControllerInspector.cs
│ │ ├── AudioMixerGroupEditor.cs
│ │ ├── AudioRandomContainerInspector.cs
│ │ ├── AudioReverbFilterEditor.cs
│ │ ├── AudioReverbZoneEditor.cs
│ │ ├── AudioSourceInspector.cs
│ │ ├── AutodeskInteractiveShaderGUI.cs
│ │ ├── Avatar/
│ │ │ ├── AvatarAutoMapper.cs
│ │ │ ├── AvatarBipedMapper.cs
│ │ │ ├── AvatarControl.cs
│ │ │ ├── AvatarEditor.cs
│ │ │ ├── AvatarMappingEditor.cs
│ │ │ ├── AvatarMuscleEditor.cs
│ │ │ ├── AvatarSetupTool.cs
│ │ │ └── AvatarSkeletonDrawer.cs
│ │ ├── AvatarMaskInspector.cs
│ │ ├── AvatarMaskUtility.cs
│ │ ├── AvatarPreview.cs
│ │ ├── AvatarPreviewSelection.cs
│ │ ├── BillboardAssetInspector.cs
│ │ ├── BillboardRendererInspector.cs
│ │ ├── BlendTreeInspector.cs
│ │ ├── CameraEditor.cs
│ │ ├── CameraEditorUtils.cs
│ │ ├── CameraOverlay.cs
│ │ ├── CanvasEditor.cs
│ │ ├── CanvasRendererEditor.cs
│ │ ├── ColliderEditorBase.cs
│ │ ├── ColorPresetLibraryInspector.cs
│ │ ├── ComputeShaderImporterInspector.cs
│ │ ├── ComputeShaderInspector.cs
│ │ ├── ConstrainProportionsTransformScale.cs
│ │ ├── ConstraintEditorBase.cs
│ │ ├── Core/
│ │ │ ├── AddComponent/
│ │ │ │ ├── AddComponentDataSource.cs
│ │ │ │ ├── AddComponentGUI.cs
│ │ │ │ ├── AddComponentWindow.cs
│ │ │ │ ├── ComponentDropdownItem.cs
│ │ │ │ └── NewScriptDropdownItem.cs
│ │ │ ├── AdvancedDropdown/
│ │ │ │ ├── AdvancedDropdownDataSource.cs
│ │ │ │ ├── AdvancedDropdownGUI.cs
│ │ │ │ ├── AdvancedDropdownItem.cs
│ │ │ │ ├── AdvancedDropdownState.cs
│ │ │ │ ├── AdvancedDropdownWindow.cs
│ │ │ │ ├── DataSources/
│ │ │ │ │ ├── CallbackDataSource.cs
│ │ │ │ │ ├── MultiLevelDataSource.cs
│ │ │ │ │ ├── MultiselectDataSource.cs
│ │ │ │ │ └── SimpleDataSource.cs
│ │ │ │ └── EditorGUI/
│ │ │ │ ├── AdvancedDropdown.cs
│ │ │ │ ├── EditorGUIAdvancedDropdown.cs
│ │ │ │ └── StatelessAdvancedDropdown.cs
│ │ │ ├── CustomEditor.cs
│ │ │ ├── GUI/
│ │ │ │ └── TypeSelectionList.cs
│ │ │ ├── GenericInspector.cs
│ │ │ ├── InspectorPreviewWindow.cs
│ │ │ ├── InspectorWindow.cs
│ │ │ ├── PreviewWindow.cs
│ │ │ ├── PropertyEditor.cs
│ │ │ ├── RootEditor.cs
│ │ │ ├── ScriptAttributeGUI/
│ │ │ │ ├── CustomPropertyDrawerAttribute.cs
│ │ │ │ ├── DecoratorDrawer.cs
│ │ │ │ ├── GUIDrawer.cs
│ │ │ │ ├── Implementations/
│ │ │ │ │ ├── DecoratorDrawers.cs
│ │ │ │ │ ├── ExposedReferenceDrawer.cs
│ │ │ │ │ ├── ExposedReferenceObject.cs
│ │ │ │ │ └── PropertyDrawers.cs
│ │ │ │ ├── PropertyDrawer.cs
│ │ │ │ ├── PropertyHandler.cs
│ │ │ │ ├── PropertyTrait.cs
│ │ │ │ └── ScriptAttributeUtility.cs
│ │ │ ├── ScriptBindings/
│ │ │ │ └── Editor.bindings.cs
│ │ │ └── Utils/
│ │ │ ├── InspectorWindowUtils.cs
│ │ │ └── PropertyDrawerCache.cs
│ │ ├── CubemapArrayInspector.cs
│ │ ├── CubemapInspector.cs
│ │ ├── CubemapPreview.cs
│ │ ├── CurvePresetLibraryInspector.cs
│ │ ├── CustomPreviewAttribute.cs
│ │ ├── CustomRenderTextureEditor.cs
│ │ ├── DirectorEditor.cs
│ │ ├── DoubleCurvePresetLibraryInspector.cs
│ │ ├── EditMode.cs
│ │ ├── Editor.cs
│ │ ├── EditorDragging.cs
│ │ ├── EditorElementUpdater.cs
│ │ ├── EditorSettingsInspector.cs
│ │ ├── Enlighten/
│ │ │ └── LightmapParameters.cs
│ │ ├── FontInspector.cs
│ │ ├── GameObjectInspector.cs
│ │ ├── GenericPresetLibraryInspector.cs
│ │ ├── GradientPresetLibraryInspector.cs
│ │ ├── GraphicsSettingsInspector.cs
│ │ ├── GraphicsSettingsInspectors/
│ │ │ ├── GraphicsSettingsElement.cs
│ │ │ ├── GraphicsSettingsInspectorTierSettings.cs
│ │ │ ├── GraphicsSettingsInspectorUtility.cs
│ │ │ ├── RenderPipelineGlobalSettingsAssetProcessor.cs
│ │ │ └── RenderPipelineGraphicsSettingsPropertyDrawer.cs
│ │ ├── IEditorElement.cs
│ │ ├── LODGroupEditor.cs
│ │ ├── LODGroupGUI.cs
│ │ ├── LabelGUI.cs
│ │ ├── LayoutDropdownWindow.cs
│ │ ├── LegacyIlluminShaderGUI.cs
│ │ ├── LightEditor.cs
│ │ ├── LightProbeGroupInspector.cs
│ │ ├── LightProbeProxyVolumeEditor.cs
│ │ ├── LightProbesInspector.cs
│ │ ├── LightingSettingsEditor.cs
│ │ ├── LineRendererCurveEditor.cs
│ │ ├── LineRendererEditor.cs
│ │ ├── LineRendererEditorSettings.cs
│ │ ├── LineRendererPositionsView.cs
│ │ ├── LineRendererToolModes.cs
│ │ ├── LookAtConstraintEditor.cs
│ │ ├── MaskFieldDropdown.cs
│ │ ├── MaterialEditor.cs
│ │ ├── MaterialEditorGUIHelpers.cs
│ │ ├── MaterialPropertyDrawer.cs
│ │ ├── MemorySettingsEditor.cs
│ │ ├── MeshPreview.cs
│ │ ├── MeshRendererEditor.cs
│ │ ├── MinMaxCurvePropertyDrawer.cs
│ │ ├── MinMaxGradientPropertyDrawer.cs
│ │ ├── ModelInspector.cs
│ │ ├── MonoScriptInspector.cs
│ │ ├── NavMeshAgentInspector.cs
│ │ ├── NavMeshObstacleInspector.cs
│ │ ├── NotSupportedOnRenderPipelineInspector.cs
│ │ ├── OcclusionAreaEditor.cs
│ │ ├── OcclusionPortalEditor.cs
│ │ ├── OffMeshLinkInspector.deprecated.cs
│ │ ├── ParentConstraintEditor.cs
│ │ ├── ParticleSystemForceFieldInspector.cs
│ │ ├── PlayerSettingsEditor/
│ │ │ ├── PlayerSettingsEditor.cs
│ │ │ ├── PlayerSettingsIconsEditor.cs
│ │ │ ├── PlayerSettingsSplashScreenEditor.bindings.cs
│ │ │ ├── PlayerSettingsSplashScreenEditor.cs
│ │ │ ├── WebTemplate.cs
│ │ │ └── WebTemplateManagerBase.cs
│ │ ├── PlayerSettingsSectionAttribute.cs
│ │ ├── PositionConstraintEditor.cs
│ │ ├── PreviewRenderUtility.cs
│ │ ├── ProjectSettingsBaseEditor.cs
│ │ ├── QualitySettingsEditor.cs
│ │ ├── RayTracingShaderInspector.cs
│ │ ├── RectHandles.cs
│ │ ├── RectTransformEditor.cs
│ │ ├── RectTransformSnapping.cs
│ │ ├── ReflectionProbeEditor.cs
│ │ ├── RenderPipelineAssetSelector.cs
│ │ ├── RenderPipelineEditorUtility.cs
│ │ ├── RenderSettingsInspector.cs
│ │ ├── RenderTextureEditor.cs
│ │ ├── RendererEditorBase.cs
│ │ ├── RendererLightingSettings.cs
│ │ ├── ReorderableListWrapper.cs
│ │ ├── RotationConstraintEditor.cs
│ │ ├── ScaleConstraintEditor.cs
│ │ ├── ScriptExecutionOrderInspector.cs
│ │ ├── ScriptableObjectAssetEditor.cs
│ │ ├── ScriptableRenderPipelineExtensionAttribute.deprecated.cs
│ │ ├── ShaderGUI.cs
│ │ ├── ShaderImporterInspector.cs
│ │ ├── ShaderIncludePathAttribute.cs
│ │ ├── ShaderInspector.cs
│ │ ├── ShaderVariantCollectionInspector.cs
│ │ ├── ShadowCascadeSplitGUI.cs
│ │ ├── SkinnedMeshRendererEditor.cs
│ │ ├── SkyboxPanoramicShaderGUI.cs
│ │ ├── SkyboxProceduralShaderGUI.cs
│ │ ├── SortingGroupEditor.cs
│ │ ├── SortingLayerEditorUtility.cs
│ │ ├── SpeedTree8ShaderGUI.cs
│ │ ├── SpeedTree9ShaderGUI.cs
│ │ ├── SpeedTreeMaterialInspector.cs
│ │ ├── SpriteFrameInspector.cs
│ │ ├── SpriteRendererEditor.cs
│ │ ├── StandardParticlesShaderGUI.cs
│ │ ├── StandardShaderGUI.cs
│ │ ├── StreamingControllerInspector.cs
│ │ ├── TabbedEditor.cs
│ │ ├── TagManagerInspector.cs
│ │ ├── TextMeshInspector.cs
│ │ ├── Texture2DArrayInspector.cs
│ │ ├── Texture2DArrayPreview.cs
│ │ ├── Texture3DInspector.cs
│ │ ├── Texture3DPreview.cs
│ │ ├── TextureInspector.cs
│ │ ├── TimeControl.cs
│ │ ├── TimeManagerInspector.cs
│ │ ├── TimelineControl.cs
│ │ ├── TrailRendererEditor.cs
│ │ ├── TransformInspector.cs
│ │ ├── TransformRotationGUI.cs
│ │ ├── TransformUtils.cs
│ │ ├── UNetBehaviourInspector.cs
│ │ ├── UnityEventDrawer.cs
│ │ ├── VersionControlSettingsInspector.cs
│ │ ├── VisualElements/
│ │ │ ├── ClippingPlanes.cs
│ │ │ ├── MinMaxGradientField.cs
│ │ │ ├── ObjectFieldWithPrompt.cs
│ │ │ ├── ProjectSettings/
│ │ │ │ ├── BuiltInShaderElement.cs
│ │ │ │ ├── ProjectSettingsElementWithSO.cs
│ │ │ │ ├── ProjectSettingsScopes.cs
│ │ │ │ ├── ProjectSettingsSection.cs
│ │ │ │ ├── ProjectSettingsTitleBar.cs
│ │ │ │ ├── TabButton.cs
│ │ │ │ └── TabbedView.cs
│ │ │ └── RenderingLayerMaskField.cs
│ │ ├── WebCamTextureInspector.cs
│ │ └── WindInspector.cs
│ ├── InspectorUtility.cs
│ ├── InteractionContext.bindings.cs
│ ├── Internal/
│ │ └── MonoScripts.cs
│ ├── InternalEditorUtility.bindings.cs
│ ├── InternalEditorUtility.cs
│ ├── InternalMeshUtil.bindings.cs
│ ├── LODUtility.bindings.cs
│ ├── LogEntries.bindings.cs
│ ├── Macros/
│ │ ├── MacroEvaluator.cs
│ │ └── MethodEvaluator.cs
│ ├── MaterialProperty.cs
│ ├── MaterialProperty.deprecated.cs
│ ├── Media/
│ │ └── Bindings/
│ │ ├── MediaDecoder.bindings.cs
│ │ └── MediaEncoder.bindings.cs
│ ├── MemorySettings.bindings.cs
│ ├── Menu.bindings.cs
│ ├── MenuCommand.cs
│ ├── MenuItem.cs
│ ├── MeshUtility.bindings.cs
│ ├── ModuleMetadata.bindings.cs
│ ├── Modules/
│ │ ├── BeeBuildPostprocessor.cs
│ │ ├── DefaultBuildProfileExtension.cs
│ │ ├── DefaultBuildWindowExtension.cs
│ │ ├── DefaultCompilationExtension.cs
│ │ ├── DefaultPlatformSupportModule.cs
│ │ ├── DefaultPlayerSettingsEditorExtension.cs
│ │ ├── DefaultPluginImporterExtension.cs
│ │ ├── DefaultTextureImportSettingsExtension.cs
│ │ ├── DerivedBuildTargetExtensionsProvider.cs
│ │ ├── IDerivedBuildTargetExtensions.cs
│ │ ├── IPostStrippingModuleAdder.cs
│ │ ├── IPreStrippingModuleAdder.cs
│ │ ├── ModuleManager.cs
│ │ ├── PlatformSupportModule.cs
│ │ └── PostStrippingModuleAdder.cs
│ ├── MonoCecil/
│ │ ├── FileOpenInfo.cs
│ │ ├── IFileOpenInfo.cs
│ │ ├── IMonoCecilHelper.cs
│ │ └── MonoCecilHelper.cs
│ ├── MonoScript.bindings.cs
│ ├── MuscleClipUtility.bindings.cs
│ ├── Networking/
│ │ └── PlayerConnection/
│ │ ├── AttachToPlayerGUI.cs
│ │ ├── ConnectionDropDown.cs
│ │ └── EditorConnection.cs
│ ├── OSUtil.bindings.cs
│ ├── ObjectFactory.bindings.cs
│ ├── ObjectListArea.cs
│ ├── ObjectListGroup.cs
│ ├── ObjectListLocalGroup.cs
│ ├── ObjectNames.bindings.cs
│ ├── ObjectNames.cs
│ ├── ObjectPool/
│ │ └── PoolManager.cs
│ ├── ObjectSelector.cs
│ ├── ObjectTreeForSelector.cs
│ ├── OrderedCallbackCollection.cs
│ ├── Overlays/
│ │ ├── ICreateToolbar.cs
│ │ ├── IMGUIOverlay.cs
│ │ ├── Overlay.cs
│ │ ├── OverlayAttribute.cs
│ │ ├── OverlayCanvas.cs
│ │ ├── OverlayCanvasesData.cs
│ │ ├── OverlayContainer.cs
│ │ ├── OverlayContainerDropZone.cs
│ │ ├── OverlayContainerInsertDropZone.cs
│ │ ├── OverlayDockArea.cs
│ │ ├── OverlayDragger.cs
│ │ ├── OverlayDropZone.cs
│ │ ├── OverlayDropZoneBase.cs
│ │ ├── OverlayGhostDropZone.cs
│ │ ├── OverlayInsertIndicator.cs
│ │ ├── OverlayMenuItem.cs
│ │ ├── OverlayPlacement.cs
│ │ ├── OverlayPopup.cs
│ │ ├── OverlayPopupWindow.cs
│ │ ├── OverlayPreset.cs
│ │ ├── OverlayPresetManager.cs
│ │ ├── OverlayResizer.cs
│ │ ├── OverlayToolbar.cs
│ │ ├── OverlayUtilities.cs
│ │ ├── SaveOverlayPreset.cs
│ │ ├── ToolbarDropZone.cs
│ │ └── ToolbarOverlay.cs
│ ├── PackageManagerUtilityInternal.cs
│ ├── PackageUtility.bindings.cs
│ ├── Performance.bindings.cs
│ ├── PerformanceTools/
│ │ ├── FrameDebugger.bindings.cs
│ │ ├── FrameDebugger.cs
│ │ ├── FrameDebuggerData.cs
│ │ ├── FrameDebuggerEventDetailsView.cs
│ │ ├── FrameDebuggerEventDisplayData.cs
│ │ ├── FrameDebuggerHelper.cs
│ │ ├── FrameDebuggerStyles.cs
│ │ ├── FrameDebuggerToolbarView.cs
│ │ └── FrameDebuggerTreeView.cs
│ ├── Picking/
│ │ ├── PickingIncludeExcludeList.cs
│ │ └── PickingObject.cs
│ ├── PlatformSupport/
│ │ ├── PlatformIconField.cs
│ │ ├── PlayerSettingsPlatformIcons.bindings.cs
│ │ ├── ProvisioningProfile.cs
│ │ ├── ProvisioningProfileGUI.cs
│ │ └── ReorderableTextureList.cs
│ ├── PlayModeView/
│ │ ├── PlayModeAnalytics.cs
│ │ ├── PlayModeView.cs
│ │ └── PlayModeWindow.cs
│ ├── Playables/
│ │ ├── PlayableOutputEditorExtensions.cs
│ │ └── Playables.bindings.cs
│ ├── PlayerConnectionLogReceiver.cs
│ ├── PlayerPrefsSettings.cs
│ ├── PlayerSettings.bindings.cs
│ ├── PlayerSettings.deprecated.cs
│ ├── PlayerSettingsAndroid.bindings.cs
│ ├── PlayerSettingsDefaultTextureCompressionHandler.cs
│ ├── PlayerSettingsEmbeddedLinux.bindings.cs
│ ├── PlayerSettingsFacebook.bindings.cs
│ ├── PlayerSettingsIOS.bindings.cs
│ ├── PlayerSettingsLumin.bindings.cs
│ ├── PlayerSettingsMacOS.bindings.cs
│ ├── PlayerSettingsPS4.bindings.cs
│ ├── PlayerSettingsQNX.bindings.cs
│ ├── PlayerSettingsSplashScreen.bindings.cs
│ ├── PlayerSettingsSplashScreen.cs
│ ├── PlayerSettingsSwitch.bindings.cs
│ ├── PlayerSettingsSwitch.deprecated.bindings.cs
│ ├── PlayerSettingsTVOS.bindings.cs
│ ├── PlayerSettingsVisionOS.bindings.cs
│ ├── PlayerSettingsVulkan.bindings.cs
│ ├── PlayerSettingsWSA.bindings.cs
│ ├── PlayerSettingsWSA.cs
│ ├── PlayerSettingsWebGL.bindings.cs
│ ├── PlayerSettingsXboxOne.bindings.cs
│ ├── PluginDesc.cs
│ ├── Plugins/
│ │ └── PluginsHelper.cs
│ ├── PointCreator.cs
│ ├── PointEditor.cs
│ ├── PolygonEditor.bindings.cs
│ ├── PostprocessScene.cs
│ ├── Prefabs/
│ │ ├── PrefabFamilyPopup.cs
│ │ ├── PrefabImporter.bindings.cs
│ │ ├── PrefabImporterEditor.cs
│ │ ├── PrefabInstanceChangedListener.cs
│ │ ├── PrefabOverrides/
│ │ │ ├── PrefabOverride.cs
│ │ │ ├── PrefabOverridesTreeView.cs
│ │ │ ├── PrefabOverridesUtility.cs
│ │ │ ├── PrefabOverridesWindow.cs
│ │ │ └── TransformVisitor.cs
│ │ ├── PrefabReplaceUtility.cs
│ │ ├── PrefabUtility.bindings.cs
│ │ ├── PrefabUtility.cs
│ │ └── PropertyModification.bindings.cs
│ ├── PreferencesWindow/
│ │ ├── AssetPipelinePreferences.cs
│ │ ├── CollectionsPreferences.cs
│ │ ├── PreferencesItem.cs
│ │ └── PreferencesSettingsProviders.cs
│ ├── PresetLibraries/
│ │ ├── ColorPresetLibrary.cs
│ │ ├── CurvePresetLibrary.cs
│ │ ├── CurvePresetsContentsForPopupWindow.cs
│ │ ├── DoubleCurvePresetLibrary.cs
│ │ ├── DoubleCurvePresetsContentsForPopupWindow.cs
│ │ ├── GradientPresetLibrary.cs
│ │ ├── PopupWindowContentForNewLibrary.cs
│ │ ├── PresetLibrary.cs
│ │ ├── PresetLibraryEditor.cs
│ │ ├── PresetLibraryEditorMenu.cs
│ │ ├── PresetLibraryManager.cs
│ │ └── ScriptableObjectSaveLoadHelper.cs
│ ├── Progress/
│ │ ├── AssemblyInfo.cs
│ │ ├── Progress.bindings.cs
│ │ ├── Progress.cs
│ │ └── ProgressOrderComparer.cs
│ ├── ProgressScope.bindings.cs
│ ├── ProgressScope.cs
│ ├── ProjectBrowser/
│ │ ├── AssetClipboardUtility.cs
│ │ ├── CachedFilteredHierachy.cs
│ │ ├── GlobSearchUtilities.cs
│ │ ├── ProjectBrowser.cs
│ │ ├── ProjectBrowserColumnOne.cs
│ │ ├── ProjectBrowserPopups.cs
│ │ ├── ProjectWindowUtil.cs
│ │ ├── SavedSearchFilter.cs
│ │ ├── SearchFilter.cs
│ │ └── SearchableEditorWindow.cs
│ ├── ProjectTemplateWindow.cs
│ ├── RegistryUtil.bindings.cs
│ ├── RemoteInput/
│ │ └── Remoting.bindings.cs
│ ├── RemoveLegacyMenuItems.cs
│ ├── RenderDoc/
│ │ ├── RenderDoc.bindings.cs
│ │ └── RenderDocUtil.cs
│ ├── RenderPipelineGlobalSettingsEditor.cs
│ ├── RenderPipelineGraphicsSettingsCollectionPropertyDrawer.cs
│ ├── RenderPipelineGraphicsSettingsContextMenu.cs
│ ├── RenderPipelineResourcesEditorUtils.cs
│ ├── RuntimeInitializeOnLoadManager.bindings.cs
│ ├── SJSON.bindings.cs
│ ├── SaveAssetsProcessor.cs
│ ├── SavedGUIState.bindings.cs
│ ├── SceneHierarchy.cs
│ ├── SceneHierarchyHooks.cs
│ ├── SceneHierarchySortingWindow.cs
│ ├── SceneHierarchyStageHandling.cs
│ ├── SceneHierarchyWindow.cs
│ ├── SceneManagement/
│ │ ├── EditorSceneManager.cs
│ │ ├── SceneSetup.cs
│ │ └── StageManager/
│ │ ├── AssetEvents.cs
│ │ ├── AvatarConfigurationStage.cs
│ │ ├── BreadcrumbBar.cs
│ │ ├── MainStage.cs
│ │ ├── MainStageHierarchyState.cs
│ │ ├── PrefabStage/
│ │ │ ├── PrefabStage.cs
│ │ │ ├── PrefabStage.deprecated.cs
│ │ │ └── PrefabStageUtility.cs
│ │ ├── PrefabStageHierarchyState.cs
│ │ ├── PreviewSceneStage.cs
│ │ ├── SceneViewCameraState.cs
│ │ ├── Stage.cs
│ │ ├── StageNavigationHistory.cs
│ │ ├── StageNavigationManager.cs
│ │ ├── StageUtility.bindings.cs
│ │ └── StageUtility.cs
│ ├── SceneModeWindows/
│ │ ├── DefaultLightingExplorerExtension.cs
│ │ ├── LightingExplorerExtensionAttribute.deprecated.cs
│ │ ├── LightingExplorerTab.cs
│ │ ├── LightingExplorerWindow.cs
│ │ ├── LightingWindow.cs
│ │ ├── LightingWindowBakeSettings.cs
│ │ ├── LightingWindowEnvironmentTab.cs
│ │ ├── LightingWindowLightingTab.cs
│ │ ├── LightingWindowLightmapPreviewTab.cs
│ │ ├── LightingWindowTab.cs
│ │ ├── LightmapPreviewWindow.cs
│ │ ├── OcclusionCullingWindow.cs
│ │ └── SceneModeUtility.cs
│ ├── SceneObjectIdentifier.bindings.cs
│ ├── SceneView/
│ │ ├── CameraFlyModeContext.cs
│ │ ├── PickingShortcutContext.cs
│ │ ├── RectSelection.cs
│ │ ├── SceneOrientationGizmo.cs
│ │ ├── SceneView.cs
│ │ ├── SceneViewGrid.cs
│ │ ├── SceneViewMotion.cs
│ │ ├── SceneViewOverlay.cs
│ │ ├── SceneViewOverlays.cs
│ │ ├── SceneViewPicking.cs
│ │ ├── SceneViewPiercingMenu.cs
│ │ ├── SceneViewStageHandling.cs
│ │ ├── SceneViewToolbarStyles.cs
│ │ ├── SceneViewToolbars.cs
│ │ ├── SceneViewViewpoint.cs
│ │ └── Viewpoint/
│ │ ├── CameraViewpoint.cs
│ │ ├── ViewpointAPI.cs
│ │ └── ViewpointProxyTypeCache.cs
│ ├── SceneVisibility/
│ │ ├── SceneVisibilityHierarchyGUI.cs
│ │ ├── SceneVisibilityManager.cs
│ │ └── SceneVisibilityState.bindings.cs
│ ├── ScriptEditorUtility.cs
│ ├── ScriptReloadProperties.cs
│ ├── ScriptableSingleton.cs
│ ├── ScriptableSingletonDictionary.cs
│ ├── ScriptableWizard.cs
│ ├── Scripting/
│ │ ├── APIUpdater/
│ │ │ ├── APIUpdaterAssemblyHelper.cs
│ │ │ ├── APIUpdaterHelper.cs
│ │ │ ├── APIUpdaterLogger.cs
│ │ │ ├── APIUpdaterManager.bindings.cs
│ │ │ └── AssemblyDependencyGraph.cs
│ │ ├── AsyncInstantiateManager.cs
│ │ ├── Compilers/
│ │ │ ├── CommandLineFormatter.cs
│ │ │ ├── CompilerBase.cs
│ │ │ ├── CompilerOutputParserBase.cs
│ │ │ ├── CompilerSpecificReponseFiles.cs
│ │ │ ├── Il2CppOutputParser.cs
│ │ │ ├── MicrosoftCSharpCompilerOutputParser.cs
│ │ │ ├── MicrosoftCSharpResponseFileProvider.cs
│ │ │ ├── MicrosoftResponseFileParser.cs
│ │ │ ├── ResponseFileProvider.cs
│ │ │ ├── ScriptCompilerBase.cs
│ │ │ └── UWPReferences.cs
│ │ ├── ManagedDebugger.bindings.cs
│ │ ├── NativeClassExtensionUtilities.cs
│ │ ├── ScriptCompilation/
│ │ │ ├── AssemblyBuilder.cs
│ │ │ ├── AssemblyDefinitionException.cs
│ │ │ ├── AssemblyFlags.cs
│ │ │ ├── AssemblyGraphBuilder.cs
│ │ │ ├── AssemblyGraphBuilderFactory.cs
│ │ │ ├── AssetPath.cs
│ │ │ ├── AssetPathMetaData.cs
│ │ │ ├── AssetPathVersionMetaData.cs
│ │ │ ├── AutoReferencedPackageAssemblies.cs
│ │ │ ├── BeeDriver/
│ │ │ │ ├── BeeScriptCompilation.cs
│ │ │ │ ├── PotentiallyUpdatableErrorMessages.cs
│ │ │ │ ├── UnityBeeDriver.cs
│ │ │ │ ├── UnityBeeDriverProfilerSession.cs
│ │ │ │ ├── UnityScriptUpdater.cs
│ │ │ │ ├── UnityScriptUpdaterConsentAPI.cs
│ │ │ │ └── UnitySourceFileUpdatersResultHandler.cs
│ │ │ ├── CompilationPipeline.cs
│ │ │ ├── CompilationPipelineCommonHelper.cs
│ │ │ ├── CompilationSetupErrorsTracker.cs
│ │ │ ├── CompilerMessage.cs
│ │ │ ├── CustomScriptAssembly.cs
│ │ │ ├── CustomScriptAssemblyReference.cs
│ │ │ ├── DefineConstraintsHelper.cs
│ │ │ ├── EditorBuildRules.cs
│ │ │ ├── EditorCompilation.cs
│ │ │ ├── EditorCompilationInterface.cs
│ │ │ ├── EditorScriptCompilationOptions.cs
│ │ │ ├── EnumerableExtensions.cs
│ │ │ ├── ExpressionNotValidException.cs
│ │ │ ├── ExpressionTypeFactory.cs
│ │ │ ├── ExpressionTypeKey.cs
│ │ │ ├── GUIDReference.cs
│ │ │ ├── ILPostProcessingProgram.cs
│ │ │ ├── IVersion.cs
│ │ │ ├── LoadingAssemblyDefinition.cs
│ │ │ ├── MonoLibraryHelpers.cs
│ │ │ ├── PathMultidimensionalDivisionTree.cs
│ │ │ ├── PlatformSupportModuleHelpers.cs
│ │ │ ├── PostProcessorOutputParser.cs
│ │ │ ├── PrecompiledAssembly.cs
│ │ │ ├── RoslynAnalyzers.cs
│ │ │ ├── SafeMode.cs
│ │ │ ├── ScriptAssembly.cs
│ │ │ ├── SemVersion.cs
│ │ │ ├── TargetAssembly.cs
│ │ │ ├── TestRunnerHelpers.cs
│ │ │ ├── UnityCodeGenHelpers.cs
│ │ │ ├── UnitySpecificCompilerMessageProcessor.cs
│ │ │ ├── UnityVersion.cs
│ │ │ ├── Utility.cs
│ │ │ ├── VersionDefineExpression.cs
│ │ │ ├── VersionDefinesConsoleLogs.bindings.cs
│ │ │ ├── VersionRanges.cs
│ │ │ ├── VersionRangesEvaluators.cs
│ │ │ └── VersionRangesFactory.cs
│ │ └── ScriptCompilers.cs
│ ├── ScriptingDefinesHelper.cs
│ ├── Search/
│ │ ├── AdvancedObjectSelectorAttribute.cs
│ │ ├── LegacyImplementations.cs
│ │ ├── ObjectSelector.Deprecated.cs
│ │ ├── ObjectSelectorSearch.cs
│ │ ├── OpenSearchHelper.cs
│ │ ├── Project.Deprecated.cs
│ │ ├── ProjectSearch.cs
│ │ ├── Scene.Deprecated.cs
│ │ ├── SceneSearch.cs
│ │ └── SearchService.cs
│ ├── SearchUtility.cs
│ ├── Selection/
│ │ ├── ActiveEditorTracker.bindings.cs
│ │ ├── Selection.bindings.cs
│ │ └── Selection.cs
│ ├── SelectionCommands/
│ │ └── SelectionCommands.cs
│ ├── SerializationDebug.bindings.cs
│ ├── SerializedObject.bindings.cs
│ ├── SerializedProperty/
│ │ ├── SerializedPropertyFilters.cs
│ │ ├── SerializedPropertyTable.cs
│ │ └── SerializedPropertyTreeView.cs
│ ├── SerializedProperty.bindings.cs
│ ├── SerializedPropertyExtensions.cs
│ ├── Settings/
│ │ ├── Providers/
│ │ │ └── AssetSettingsProvider.cs
│ │ ├── RenderPipelines/
│ │ │ └── RenderPipelineGraphicsSettingsManager.cs
│ │ ├── SettingsProvider.cs
│ │ ├── SettingsProviderAttribute.cs
│ │ ├── SettingsService.cs
│ │ ├── SettingsTreeView.cs
│ │ └── SettingsWindow.cs
│ ├── Settings.cs
│ ├── SettingsWindow/
│ │ ├── FogEditor.cs
│ │ ├── LightingEditor.cs
│ │ └── OtherRenderingEditor.cs
│ ├── ShaderUtil.bindings.cs
│ ├── ShaderUtil.bindings.deprecated.cs
│ ├── ShaderUtil.cs
│ ├── Shaders/
│ │ ├── MaterialHierarchyPopup.cs
│ │ ├── ShaderKeywordFilterAttributes.cs
│ │ ├── ShaderKeywordFilterConstraintAttributes.cs
│ │ ├── ShaderKeywordFilterData.cs
│ │ └── ShaderKeywordFilterUtil.cs
│ ├── SpeedTreeMaterialFixer.cs
│ ├── SplashScreenLogo.cs
│ ├── SpritePacker.bindings.cs
│ ├── Sprites/
│ │ ├── SpriteUtility.cs
│ │ └── SpriteUtilityWindow.cs
│ ├── SpritesEditor.bindings.cs
│ ├── StateMachine.bindings.cs
│ ├── StateMachineBehaviourContext.bindings.cs
│ ├── StaticEditorFlags.cs
│ ├── StaticOcclusionCulling.bindings.cs
│ ├── TagManager.bindings.cs
│ ├── TerrainEditor/
│ │ └── TerrainInspectorUtil.bindings.cs
│ ├── Text/
│ │ ├── BlurryTextMappingTable.cs
│ │ ├── EditorFontAssetFactory.cs
│ │ └── EditorTextSettings.cs
│ ├── Tools/
│ │ ├── BuiltinTools.cs
│ │ ├── EditorAction.cs
│ │ ├── EditorActionTool.cs
│ │ ├── EditorTool.cs
│ │ ├── EditorToolAttributes.cs
│ │ ├── EditorToolCache.cs
│ │ ├── EditorToolContext.cs
│ │ ├── EditorToolGUI.cs
│ │ ├── EditorToolManager.cs
│ │ ├── EditorToolSettingsOverlay.cs
│ │ ├── EditorToolUtility.cs
│ │ ├── EditorTools.deprecated.cs
│ │ ├── GameObjectToolContext.cs
│ │ ├── IEditor.cs
│ │ ├── PrimitiveColliderTool.cs
│ │ ├── ToolEntry.cs
│ │ ├── ToolManager.cs
│ │ ├── ToolShortcutContext.cs
│ │ ├── ToolVariantPrefs.cs
│ │ ├── Tools.cs
│ │ └── TransformManipulator.cs
│ ├── TooltipView/
│ │ └── TooltipView.cs
│ ├── Tuple.cs
│ ├── Tutorial/
│ │ ├── Highlighter.bindings.cs
│ │ └── Highlighter.cs
│ ├── TypeCache.bindings.cs
│ ├── TypeCache.cs
│ ├── TypeSystem/
│ │ ├── UnityType.bindings.cs
│ │ └── UnityType.cs
│ ├── UIElements/
│ │ ├── BaseLiveReloadAssetTracker.cs
│ │ ├── Bindings/
│ │ │ ├── BindingStyleHelpers.cs
│ │ │ ├── BindingsInterface.cs
│ │ │ └── SerializedPropertyBindingEvents.cs
│ │ ├── Controls/
│ │ │ ├── ColorField.cs
│ │ │ ├── CurveField.cs
│ │ │ ├── EnumFlagsField.cs
│ │ │ ├── GradientField.cs
│ │ │ ├── LayerField.cs
│ │ │ ├── LayerMaskField.cs
│ │ │ ├── Mask64Field.cs
│ │ │ ├── MaskField.cs
│ │ │ ├── ObjectField.cs
│ │ │ ├── PropertyField.cs
│ │ │ ├── TagField.cs
│ │ │ └── Toolbar/
│ │ │ ├── IToolbarMenuElement.cs
│ │ │ ├── SearchFieldBase.cs
│ │ │ ├── Toolbar.cs
│ │ │ ├── ToolbarBreadcrumbs.cs
│ │ │ ├── ToolbarButton.cs
│ │ │ ├── ToolbarMenu.cs
│ │ │ ├── ToolbarPopupSearchField.cs
│ │ │ ├── ToolbarSearchField.cs
│ │ │ ├── ToolbarSpacer.cs
│ │ │ └── ToolbarToggle.cs
│ │ ├── DefaultMainToolbar.cs
│ │ ├── Drawers/
│ │ │ └── Internal/
│ │ │ ├── DropdownOptionListItem.cs
│ │ │ └── UnityEventItem.cs
│ │ ├── EditorFocusMonitor.cs
│ │ ├── EditorMenuExtensions.cs
│ │ ├── EditorWindowPersistentViewData.cs
│ │ ├── GenericDropdownMenuWindowContent.cs
│ │ ├── Inspector/
│ │ │ ├── EditorElement.cs
│ │ │ ├── IEditorElementDecorator.cs
│ │ │ └── InspectorElement.cs
│ │ ├── SerializableJsonDictionary.cs
│ │ ├── StyleSheets/
│ │ │ ├── StyleSheetEditor.cs
│ │ │ ├── StyleSheetImportErrors.cs
│ │ │ ├── StyleSheetImportGlossary.cs
│ │ │ ├── StyleSheetImporter.cs
│ │ │ ├── StyleSheetImporterImpl.cs
│ │ │ ├── StyleSheetResourceUtil.cs
│ │ │ ├── ThemeAssetDefinitionState.cs
│ │ │ ├── ThemeRegistry.cs
│ │ │ ├── ThemeStyleSheetImporter.cs
│ │ │ ├── ThemeStyleSheetImporterEditor.cs
│ │ │ └── URIHelpers.cs
│ │ ├── UIBuildAnalyticsEvent.cs
│ │ └── UIElementsEditorUtility.cs
│ ├── Undo/
│ │ ├── EditorObjectChangeEvents.cs
│ │ ├── Undo.bindings.cs
│ │ ├── UndoHistoryWindow.cs
│ │ ├── UndoSerializationWindow.cs
│ │ └── UndoWindow.cs
│ ├── Undo.cs
│ ├── UnityConnect/
│ │ ├── CloudProjectSettings.cs
│ │ ├── CloudProjectSettingsEventManager.cs
│ │ ├── CoppaCompliance.cs
│ │ ├── Network/
│ │ │ ├── OrganizationRequestResponse.cs
│ │ │ ├── ProjectRequestResponse.cs
│ │ │ ├── UnityConnectRequests.cs
│ │ │ ├── UnityConnectWebRequestException.cs
│ │ │ ├── UnityConnectWebRequestUtils.cs
│ │ │ └── UserRequestResponse.cs
│ │ ├── ServiceToken/
│ │ │ ├── Caching/
│ │ │ │ ├── GenesisAndServiceTokenCaching.cs
│ │ │ │ ├── IGenesisAndServiceTokenCaching.cs
│ │ │ │ ├── JsonWebToken.cs
│ │ │ │ └── Tokens.cs
│ │ │ ├── ServiceToken.cs
│ │ │ └── TokenExchange/
│ │ │ ├── ITokenExchange.cs
│ │ │ ├── Model/
│ │ │ │ ├── TokenExchangeRequest.cs
│ │ │ │ └── TokenExchangeResponse.cs
│ │ │ └── TokenExchange.cs
│ │ ├── Services/
│ │ │ ├── EditorProjectAccess.bindings.cs
│ │ │ ├── ServicesConfiguration.cs
│ │ │ └── ServicesUtils.cs
│ │ ├── UnityConnect.bindings.cs
│ │ ├── Uri/
│ │ │ ├── IUnityConnectRequestUriProvider.cs
│ │ │ └── UnityConnectRequestUriProvider.cs
│ │ └── Utils/
│ │ └── AsyncUtils.cs
│ ├── UnityStats.bindings.cs
│ ├── Unsupported.bindings.cs
│ ├── Unwrapping.bindings.cs
│ ├── Utils/
│ │ ├── AssemblyReferenceChecker.cs
│ │ ├── DirectoryExtensions.cs
│ │ ├── EditorExtensionMethods.cs
│ │ ├── EnumUtility.cs
│ │ ├── IDeviceUtils.cs
│ │ ├── IconUtility.bindings.cs
│ │ ├── LightProbeGroupSelection.cs
│ │ ├── ManagedProgram.cs
│ │ ├── MathUtils.cs
│ │ ├── MenuUtils.cs
│ │ ├── MetroCertificatePasswordWindow.cs
│ │ ├── MetroCreateTestCertificateWindow.cs
│ │ ├── MonoInstallationFinder.cs
│ │ ├── NetCoreProgram.cs
│ │ ├── NetCoreRunProgram.cs
│ │ ├── NetStandardFinder.cs
│ │ ├── Paths.cs
│ │ ├── PerformanceChecks.cs
│ │ ├── Pram.cs
│ │ ├── ProcessOutputStreamReader.cs
│ │ ├── Program.cs
│ │ ├── ProgressBarUtils.cs
│ │ ├── SearchUtils.cs
│ │ ├── SimpleProfiler.cs
│ │ ├── StateCache.cs
│ │ ├── TickTimerHelper.cs
│ │ ├── TimeAgo.cs
│ │ ├── TimeHelper.cs
│ │ ├── UnityEventTools.cs
│ │ └── WebURLs.bindings.cs
│ ├── VersionControl/
│ │ ├── Common/
│ │ │ ├── IIconOverlayExtension.cs
│ │ │ ├── IInspectorWindowExtension.cs
│ │ │ ├── IPopupMenuExtension.cs
│ │ │ ├── ISettingsInspectorExtension.cs
│ │ │ ├── VCAsset.cs
│ │ │ ├── VCAssetList.cs
│ │ │ ├── VCAssetModificationHooks.cs
│ │ │ ├── VCChangeSet.cs
│ │ │ ├── VCChangeSets.cs
│ │ │ ├── VCMessage.cs
│ │ │ ├── VCProvider.cs
│ │ │ ├── VCTask.cs
│ │ │ ├── VCUtils.cs
│ │ │ ├── VersionControlAttribute.cs
│ │ │ ├── VersionControlDescriptor.cs
│ │ │ ├── VersionControlManager.cs
│ │ │ └── VersionControlObject.cs
│ │ ├── UI/
│ │ │ ├── VCListControl.cs
│ │ │ ├── VCListItem.cs
│ │ │ ├── VCMenuChange.cs
│ │ │ ├── VCMenuPending.cs
│ │ │ ├── VCMenuProject.cs
│ │ │ ├── VCOverlay.cs
│ │ │ ├── VCProjectHooks.cs
│ │ │ ├── VCWindowChange.cs
│ │ │ ├── VCWindowCheckoutFailure.cs
│ │ │ ├── VCWindowPending.cs
│ │ │ ├── VCWindowResolve.cs
│ │ │ └── VCWindowRevert.cs
│ │ ├── VCAsset.bindings.cs
│ │ ├── VCChangeSet.bindings.cs
│ │ ├── VCCustomCommand.bindings.cs
│ │ ├── VCMessage.bindings.cs
│ │ ├── VCPlugin.bindings.cs
│ │ ├── VCProvider.bindings.cs
│ │ ├── VCTask.bindings.cs
│ │ └── VersionControlManager.bindings.cs
│ ├── VersionControlSettings.bindings.cs
│ ├── VertexChannelCompressionFlags.cs
│ ├── View.cs
│ ├── VisualStudioIntegration/
│ │ └── FileIO.cs
│ ├── VisualStudioUtil.bindings.cs
│ ├── WindowAction.cs
│ └── WindowBackendManager.cs
├── External/
│ ├── JsonParsers/
│ │ └── MiniJson/
│ │ └── MiniJSON.cs
│ ├── NiceIO/
│ │ └── NiceIO.cs
│ ├── baselib/
│ │ └── baselib/
│ │ └── CSharp/
│ │ ├── BaselibNativeLibrary.cs
│ │ ├── BindingsUnity/
│ │ │ ├── Baselib_DynamicLibrary.gen.binding.cs
│ │ │ ├── Baselib_ErrorCode.gen.binding.cs
│ │ │ ├── Baselib_ErrorState.gen.binding.cs
│ │ │ ├── Baselib_FileIO.gen.binding.cs
│ │ │ ├── Baselib_HostnameLookup.gen.binding.cs
│ │ │ ├── Baselib_Memory.gen.binding.cs
│ │ │ ├── Baselib_NetworkAddress.gen.binding.cs
│ │ │ ├── Baselib_RegisteredNetwork.gen.binding.cs
│ │ │ ├── Baselib_Socket.gen.binding.cs
│ │ │ ├── Baselib_SourceLocation.gen.binding.cs
│ │ │ ├── Baselib_SystemFutex.gen.binding.cs
│ │ │ ├── Baselib_SystemSemaphore.gen.binding.cs
│ │ │ ├── Baselib_Thread.gen.binding.cs
│ │ │ ├── Baselib_ThreadLocalStorage.gen.binding.cs
│ │ │ ├── Baselib_Timer.gen.binding.cs
│ │ │ └── Baselib_WakeupFallbackStrategy.gen.binding.cs
│ │ ├── Error.cs
│ │ └── ManualBindings.cs
│ ├── il2cpp/
│ │ └── builds/
│ │ ├── Il2CppEditorIntegration/
│ │ │ └── SharedWithEditor.cs
│ │ └── LinkerEditorIntegration/
│ │ └── SharedWithEditor.cs
│ └── unitytls/
│ └── builds/
│ └── CSharp/
│ ├── BindingsUnity/
│ │ └── TLSAgent.gen.bindings.cs
│ └── UnityTLSNativeLibrary.cs
├── LICENSE.md
├── Modules/
│ ├── AI/
│ │ ├── AssemblyInfo.cs
│ │ ├── Builder/
│ │ │ └── NavMeshBuilder.bindings.cs
│ │ ├── Components/
│ │ │ ├── NavMeshAgent.bindings.cs
│ │ │ ├── NavMeshObstacle.bindings.cs
│ │ │ ├── OffMeshLink.bindings.cs
│ │ │ └── OffMeshLink.deprecated.cs
│ │ ├── NavMesh/
│ │ │ ├── NavMesh.bindings.cs
│ │ │ └── NavMesh.deprecated.cs
│ │ ├── NavMeshExperimental.bindings.cs
│ │ ├── NavMeshPath.bindings.cs
│ │ └── Public/
│ │ ├── NavMeshBindingTypes.bindings.cs
│ │ └── NavMeshBuildSettings.bindings.cs
│ ├── AIEditor/
│ │ ├── Builder/
│ │ │ └── NavMeshBuilderEditor.deprecated.cs
│ │ ├── Utilities/
│ │ │ ├── NavMeshEditorHelpers.bindings.cs
│ │ │ └── NavMeshEditorHelpers.cs
│ │ └── Visualization/
│ │ └── NavMeshVisualizationSettings.bindings.cs
│ ├── AR/
│ │ └── ARCore/
│ │ └── ScriptBindings/
│ │ └── ARCore.bindings.cs
│ ├── Accessibility/
│ │ ├── AssemblyInfo.cs
│ │ ├── Bindings/
│ │ │ ├── AccessibilityAction.bindings.cs
│ │ │ ├── AccessibilityManager.bindings.cs
│ │ │ ├── AccessibilityNodeData.bindings.cs
│ │ │ ├── AccessibilityNodeManager.bindings.cs
│ │ │ ├── AccessibilityNotificationContext.bindings.cs
│ │ │ └── AccessibilitySettings.bindings.cs
│ │ ├── Managed/
│ │ │ ├── AccessibilitySettings.cs
│ │ │ ├── AssistiveSupport.cs
│ │ │ ├── Hierarchy/
│ │ │ │ ├── AccessibilityHierarchy.cs
│ │ │ │ └── AccessibilityNode.cs
│ │ │ ├── IAccessibilityNotificationDispatcher.cs
│ │ │ └── Services/
│ │ │ ├── AccessibilityHierarchyService.cs
│ │ │ ├── IService.cs
│ │ │ └── ServiceManager.cs
│ │ └── VisionUtility.cs
│ ├── AccessibilityEditor/
│ │ └── Managed/
│ │ ├── AccessibilityEditor.cs
│ │ ├── AccessibilityHierarchyTreeView.cs
│ │ ├── AccessibilityHierarchyViewModel.cs
│ │ ├── AccessibilityHierarchyViewer.cs
│ │ ├── AccessibilityHierarchyViewerWindow.cs
│ │ ├── SearchableLabel.cs
│ │ └── TreeViewSearchBar.cs
│ ├── AdaptivePerformance/
│ │ └── Editor/
│ │ └── AdaptivePerformanceInstaller.cs
│ ├── AndroidJNI/
│ │ ├── AndroidApplication.bindings.cs
│ │ ├── AndroidApplicationExitInfo.cs
│ │ ├── AndroidAssetPacks.bindings.cs
│ │ ├── AndroidDevice.bindings.cs
│ │ ├── AndroidDiagnosticsReporting.cs
│ │ ├── AndroidGame.bindings.cs
│ │ ├── AndroidGame.cs
│ │ ├── AndroidInsets.bindings.cs
│ │ ├── AndroidJNI.bindings.cs
│ │ ├── AndroidJNISafe.cs
│ │ ├── AndroidJava.cs
│ │ ├── AndroidPermissions.cs
│ │ ├── AssemblyInfo.cs
│ │ └── Configuration/
│ │ ├── AndroidColorModeHdr.cs
│ │ ├── AndroidColorModeWideColorGamut.cs
│ │ ├── AndroidConfiguration.cs
│ │ ├── AndroidHardwareKeyboardHidden.cs
│ │ ├── AndroidKeyboard.cs
│ │ ├── AndroidKeyboardHidden.cs
│ │ ├── AndroidNavigation.cs
│ │ ├── AndroidNavigationHidden.cs
│ │ ├── AndroidOrientation.cs
│ │ ├── AndroidScreenLayoutDirection.cs
│ │ ├── AndroidScreenLayoutLong.cs
│ │ ├── AndroidScreenLayoutRound.cs
│ │ ├── AndroidScreenLayoutSize.cs
│ │ ├── AndroidTouchScreen.cs
│ │ ├── AndroidUiModeNight.cs
│ │ └── AndroidUiModeType.cs
│ ├── Animation/
│ │ ├── Managed/
│ │ │ ├── Animation.deprecated.cs
│ │ │ ├── AnimationPlayableBinding.cs
│ │ │ ├── AnimationPlayableUtilities.cs
│ │ │ ├── Animator.deprecated.cs
│ │ │ ├── DiscreteEvaluationAttribute.cs
│ │ │ ├── IAnimationClipSource.cs
│ │ │ ├── IAnimationJob.cs
│ │ │ ├── IAnimationJobPlayable.cs
│ │ │ ├── IAnimationPreviewable.cs
│ │ │ ├── IAnimationWindowPreview.cs
│ │ │ ├── NotKeyableAttribute.cs
│ │ │ ├── ProcessAnimationJobStruct.cs
│ │ │ └── StateMachineBehaviour.cs
│ │ └── ScriptBindings/
│ │ ├── AimConstraint.bindings.cs
│ │ ├── Animation.bindings.cs
│ │ ├── AnimationClip.bindings.cs
│ │ ├── AnimationClipPlayable.bindings.cs
│ │ ├── AnimationHumanStream.bindings.cs
│ │ ├── AnimationLayerMixerPlayable.bindings.cs
│ │ ├── AnimationMixerPlayable.bindings.cs
│ │ ├── AnimationMotionXToDeltaPlayable.bindings.cs
│ │ ├── AnimationOffsetPlayable.bindings.cs
│ │ ├── AnimationPlayableExtensions.bindings.cs
│ │ ├── AnimationPlayableGraphExtensions.bindings.cs
│ │ ├── AnimationPlayableOutput.bindings.cs
│ │ ├── AnimationPlayableOutputExtensions.bindings.cs
│ │ ├── AnimationPosePlayable.bindings.cs
│ │ ├── AnimationRemoveScalePlayable.bindings.cs
│ │ ├── AnimationScriptPlayable.bindings.cs
│ │ ├── AnimationStream.bindings.cs
│ │ ├── AnimationStreamHandles.bindings.cs
│ │ ├── Animator.bindings.cs
│ │ ├── AnimatorControllerParameter.bindings.cs
│ │ ├── AnimatorControllerPlayable.bindings.cs
│ │ ├── AnimatorJobExtensions.bindings.cs
│ │ ├── AnimatorOverrideController.bindings.cs
│ │ ├── AnimatorUtility.bindings.cs
│ │ ├── Avatar.bindings.cs
│ │ ├── AvatarBuilder.bindings.cs
│ │ ├── AvatarMask.bindings.cs
│ │ ├── BoundProperty.bindings.cs
│ │ ├── Constraint.bindings.cs
│ │ ├── GenericBinding.bindings.cs
│ │ ├── HumanPoseHandler.bindings.cs
│ │ ├── HumanTrait.bindings.cs
│ │ ├── LookAtConstraint.bindings.cs
│ │ ├── Motion.bindings.cs
│ │ ├── MuscleHandle.bindings.cs
│ │ ├── ParentConstraint.bindings.cs
│ │ └── RuntimeAnimatorController.bindings.cs
│ ├── AssetBundle/
│ │ └── Managed/
│ │ ├── AssemblyInfo.cs
│ │ ├── AssetBundle.bindings.cs
│ │ ├── AssetBundle.deprecated.cs
│ │ ├── AssetBundleCreateRequest.bindings.cs
│ │ ├── AssetBundleLoadingCache.bindings.cs
│ │ ├── AssetBundleManifest.bindings.cs
│ │ ├── AssetBundleRecompressOperation.bindings.cs
│ │ ├── AssetBundleRequest.bindings.cs
│ │ ├── AssetBundleUnloadOperation.bindings.cs
│ │ └── AssetBundleUtility.bindings.cs
│ ├── AssetDatabase/
│ │ └── Editor/
│ │ ├── Public/
│ │ │ └── PreviewImporter.bindings.cs
│ │ ├── ScriptBindings/
│ │ │ ├── ArtifactInfo.binding.cs
│ │ │ ├── AssetDatabase.bindings.cs
│ │ │ ├── AssetDatabaseExperimental.bindings.cs
│ │ │ ├── AssetOrigin.binding.cs
│ │ │ └── CacheServer.bindings.cs
│ │ └── V2/
│ │ ├── Managed/
│ │ │ ├── ArtifactDifferenceReporter.cs
│ │ │ ├── ArtifactDifferenceReporterTesting.cs
│ │ │ ├── AssetImportWorkerPostProcessorHelper.cs
│ │ │ ├── AssetPostprocessorStaticVariableIgnoreAttribute.cs
│ │ │ └── ImportActivityWindow.cs
│ │ └── MultiArtifactTestImporter.bindings.cs
│ ├── AssetPipelineEditor/
│ │ ├── AssetPostprocessors/
│ │ │ ├── FBXMaterialDescriptionPreprocessor.cs
│ │ │ ├── ModelImporterPostProcessor.cs
│ │ │ ├── SketchupMaterialDescriptionPreprocessor.cs
│ │ │ └── ThreeDSMaterialDescriptionPreprocessor.cs
│ │ ├── ImportSettings/
│ │ │ ├── AssetImporterEditor.bindings.cs
│ │ │ ├── AssetImporterEditor.cs
│ │ │ ├── AssetImporterTabbedEditor.cs
│ │ │ ├── AudioImporterInspector.cs
│ │ │ ├── BaseAssetImporterTabUI.cs
│ │ │ ├── ModelImporterClipEditor.cs
│ │ │ ├── ModelImporterEditor.cs
│ │ │ ├── ModelImporterMaterialEditor.cs
│ │ │ ├── ModelImporterModelEditor.cs
│ │ │ ├── ModelImporterRigEditor.cs
│ │ │ ├── PluginImporterInspector.cs
│ │ │ ├── ScriptedImporterEditor.cs
│ │ │ └── VideoClipImporterInspector.cs
│ │ └── Public/
│ │ ├── AndroidAssetPackImporter.bindings.cs
│ │ ├── AudioImporter.bindings.cs
│ │ ├── CompiledAssemblies.bindings.cs
│ │ ├── ModelImporting/
│ │ │ └── ModelImporter.bindings.cs
│ │ ├── MonoImporter.bindings.cs
│ │ ├── MovieImporter.deprecated.cs
│ │ ├── NativeFormatImporterUtility.bindings.cs
│ │ ├── PluginImporter.bindings.cs
│ │ ├── RoslynAdditionalFiles.binding.cs
│ │ ├── RoslynAnalyzerConfig.binding.cs
│ │ ├── RuleSetCache.bindings.cs
│ │ ├── ScriptedImporter.cs
│ │ ├── TextScriptImporter.bindings.cs
│ │ └── VideoImporter.bindings.cs
│ ├── Audio/
│ │ └── Public/
│ │ ├── Managed/
│ │ │ ├── Audio.deprecated.cs
│ │ │ ├── IHandle.cs
│ │ │ └── IValidatable.cs
│ │ └── ScriptBindings/
│ │ ├── Audio.bindings.cs
│ │ ├── AudioClipExtensions.bindings.cs
│ │ ├── AudioClipPlayable.bindings.cs
│ │ ├── AudioMixer.bindings.cs
│ │ ├── AudioMixerGroup.bindings.cs
│ │ ├── AudioMixerPlayable.bindings.cs
│ │ ├── AudioMixerSnapshot.bindings.cs
│ │ ├── AudioPlayableBinding.cs
│ │ ├── AudioPlayableGraphExtensions.bindings.cs
│ │ ├── AudioPlayableOutput.bindings.cs
│ │ ├── AudioRandomContainer.bindings.cs
│ │ ├── AudioRenderer.bindings.cs
│ │ ├── AudioSampleProvider.bindings.cs
│ │ ├── AudioSampleProviderExtensions.bindings.cs
│ │ ├── AudioSourceExtensions.bindings.cs
│ │ ├── ExposeDSPGraph.cs
│ │ ├── ExposeVivox.cs
│ │ ├── MovieTexture.deprecated.cs
│ │ └── UnityEngineWebCamTexture.bindings.cs
│ ├── AudioEditor/
│ │ └── ScriptBindings/
│ │ ├── AudioMixerController.bindings.cs
│ │ ├── AudioMixerDescription.bindings.cs
│ │ ├── AudioMixerEffectController.bindings.cs
│ │ ├── AudioMixerGroupController.bindings.cs
│ │ └── AudioMixerSnapshotController.bindings.cs
│ ├── BuildPipeline/
│ │ └── Editor/
│ │ ├── Managed/
│ │ │ ├── BuildArchiveImporter.cs
│ │ │ ├── BuildCompression.deprecated.cs
│ │ │ ├── BuildDefines.cs
│ │ │ ├── BuildInstructionImporter.cs
│ │ │ ├── BuildMetaDataImporter.cs
│ │ │ ├── BuildOutput.cs
│ │ │ ├── BuildPlayerDataGenerator.cs
│ │ │ ├── BuildReferenceMap.bindings.cs
│ │ │ ├── BuildSettings.cs
│ │ │ ├── BuildTargetSelection.cs
│ │ │ ├── BuildUsageCache.bindings.cs
│ │ │ ├── BuildUsageTagGlobal.cs
│ │ │ ├── BuildUsageTagSet.bindings.cs
│ │ │ ├── ContentBuildInterface.bindings.cs
│ │ │ ├── ContentBuildInterface.deprecated.cs
│ │ │ ├── ContentBuildInterfaceProfile.bindings.cs
│ │ │ ├── GameManagerDependencyInfo.cs
│ │ │ ├── ObjectIdentifier.bindings.cs
│ │ │ ├── PlayerBuildInterface.bindings.cs
│ │ │ ├── ResourceFile.cs
│ │ │ ├── SceneDependencyInfo.cs
│ │ │ ├── TypeDB.bindings.cs
│ │ │ ├── UnifiedBuildPipelineInternalApi.bindings.cs
│ │ │ └── WriteCommand.cs
│ │ ├── Shared/
│ │ │ └── ReferencesArtifactGenerator.bindings.cs
│ │ └── Ucbp/
│ │ └── BuildPipelineContext.bindings.cs
│ ├── BuildProfileEditor/
│ │ ├── ActiveBuildProfilerListener.cs
│ │ ├── AssemblyInfo.cs
│ │ ├── AssetImportOverridesWindow.cs
│ │ ├── BuildAutomation/
│ │ │ ├── BuildAutomation.cs
│ │ │ ├── BuildAutomationModalWindow.cs
│ │ │ ├── BuildAutomationSettings.cs
│ │ │ └── BuildAutomationSettingsEditor.cs
│ │ ├── BuildProfileEditor.cs
│ │ ├── BuildProfilePlayerSettingsEditor.cs
│ │ ├── BuildProfileWindow.cs
│ │ ├── Elements/
│ │ │ ├── BuildProfileBootstrapView.cs
│ │ │ ├── BuildProfileCard.cs
│ │ │ ├── BuildProfileGraphicsSettingsOverridesView.cs
│ │ │ ├── BuildProfileListEditableLabel.cs
│ │ │ ├── BuildProfileListLabel.cs
│ │ │ ├── BuildProfileQualitySettingsOverridesView.cs
│ │ │ ├── BuildProfileSceneList.cs
│ │ │ ├── DropdownButton.cs
│ │ │ ├── PlatformListView.cs
│ │ │ ├── PlatformPackageEntry.cs
│ │ │ ├── PlatformPackageItem.cs
│ │ │ └── PreconfiguredSettingsItem.cs
│ │ ├── Events.cs
│ │ ├── Handlers/
│ │ │ ├── BuildProfileContextMenu.cs
│ │ │ ├── BuildProfileDataSource.cs
│ │ │ └── BuildProfileWindowSelection.cs
│ │ ├── PlatformDiscoveryWindow.cs
│ │ ├── TrText.cs
│ │ └── Util.cs
│ ├── BuildReportingEditor/
│ │ ├── BuildReportRestService.bindings.cs
│ │ └── Managed/
│ │ ├── BuildFile.cs
│ │ ├── BuildReport.bindings.cs
│ │ ├── BuildReportRestService.cs
│ │ ├── BuildResult.cs
│ │ ├── BuildStep.cs
│ │ ├── BuildStepMessage.cs
│ │ ├── BuildSummary.cs
│ │ ├── BuildType.cs
│ │ ├── CommonRoles.bindings.cs
│ │ ├── PackedAssetInfo.cs
│ │ ├── PackedAssets.bindings.cs
│ │ ├── ScenesUsingAsset.cs
│ │ ├── ScenesUsingAssets.bindings.cs
│ │ ├── ScopedBuildStep.cs
│ │ ├── StrippingInfo.cs
│ │ └── StrippingInfoWithSizeAnalysis.cs
│ ├── Cloth/
│ │ └── Cloth.bindings.cs
│ ├── ClothEditor/
│ │ ├── ClothInspector.cs
│ │ └── ScriptBindings/
│ │ └── ClothUtilities.bindings.cs
│ ├── CloudServicesSettingsEditor/
│ │ ├── Ads/
│ │ │ └── ScriptBindings/
│ │ │ └── AdvertisementSettings.bindings.cs
│ │ ├── Analytics/
│ │ │ └── ScriptBindings/
│ │ │ └── AnalyticsSettings.bindings.cs
│ │ ├── CrashReporting/
│ │ │ ├── Managed/
│ │ │ │ └── CrashReporting.cs
│ │ │ └── ScriptBindings/
│ │ │ └── CrashReportingSettings.bindings.cs
│ │ ├── PerformanceReporting/
│ │ │ └── ScriptBindings/
│ │ │ └── PerformanceReportingSettings.bindings.cs
│ │ └── Purchasing/
│ │ └── ScriptBindings/
│ │ └── PurchasingSettings.bindings.cs
│ ├── ClusterInput/
│ │ └── ClusterInput.bindings.cs
│ ├── ClusterRenderer/
│ │ ├── ClusterRenderer.bindings.cs
│ │ └── ClusterSerialization.bindings.cs
│ ├── ContentLoad/
│ │ └── Public/
│ │ └── ContentLoad.bindings.cs
│ ├── CrashReporting/
│ │ └── CrashReporter.bindings.cs
│ ├── DSPGraph/
│ │ └── Public/
│ │ └── ScriptBindings/
│ │ ├── AudioHandle.bindings.cs
│ │ ├── AudioMemoryManager.bindings.cs
│ │ ├── AudioOutputHookManager.bindings.cs
│ │ ├── DSPCommandBlock.bindings.cs
│ │ ├── DSPGraph.bindings.cs
│ │ ├── DSPNodeUpdateRequest.bindings.cs
│ │ ├── DSPSampleProvider.bindings.cs
│ │ ├── ExecuteContext.bindings.cs
│ │ └── ExposeDSPGraph.cs
│ ├── DeviceSimulatorEditor/
│ │ ├── AssemblyInfo.cs
│ │ ├── DeviceInfo/
│ │ │ ├── DeviceInfo.cs
│ │ │ ├── DeviceInfoAsset.cs
│ │ │ ├── DeviceInfoImporter.cs
│ │ │ ├── DeviceInfoImporterEditor.cs
│ │ │ └── DeviceLoader.cs
│ │ ├── DeviceListPopup.cs
│ │ ├── DevicePackage.cs
│ │ ├── DeviceSimulatorMain.cs
│ │ ├── Input/
│ │ │ ├── InputManagerBackend.cs
│ │ │ └── TouchEventManipulator.cs
│ │ ├── Plugins/
│ │ │ ├── ApplicationPlugin.cs
│ │ │ ├── DeviceSimulator.cs
│ │ │ ├── DeviceSimulatorPlugin.cs
│ │ │ └── PluginController.cs
│ │ ├── Shims/
│ │ │ ├── ApplicationSimulation.cs
│ │ │ ├── ScreenSimulation.cs
│ │ │ └── SystemInfoSimulation.cs
│ │ ├── SimulatorPlayerSettings.cs
│ │ ├── SimulatorState.cs
│ │ ├── SimulatorUtilities.cs
│ │ ├── SimulatorWindow.cs
│ │ ├── UserInterfaceController.cs
│ │ └── VisualElements/
│ │ └── DeviceView.cs
│ ├── DiagnosticsEditor/
│ │ ├── DiagnosticsConsoleMessage.cs
│ │ └── DiagnosticsPreferences.cs
│ ├── Director/
│ │ ├── AssemblyInfo.cs
│ │ └── ScriptBindings/
│ │ ├── DataPlayable.bindings.cs
│ │ ├── DataPlayable.cs
│ │ ├── DataPlayableBinding.cs
│ │ ├── DataPlayableOutput.bindings.cs
│ │ ├── DataPlayableOutputExtensions.bindings.cs
│ │ ├── IDataPlayer.cs
│ │ ├── PlayableDirector.bindings.cs
│ │ └── PlayableSystems.bindings.cs
│ ├── EditorToolbar/
│ │ ├── Controls/
│ │ │ ├── AIDropdownContent.cs
│ │ │ ├── ComponentToolContextButton.cs
│ │ │ ├── EditorToolbarButton.cs
│ │ │ ├── EditorToolbarDropdown.cs
│ │ │ ├── EditorToolbarDropdownToggle.cs
│ │ │ ├── EditorToolbarFloatField.cs
│ │ │ ├── EditorToolbarIcon.cs
│ │ │ ├── EditorToolbarToggle.cs
│ │ │ ├── LastCustomToolButton.cs
│ │ │ ├── LoadingSpinner.cs
│ │ │ ├── ToolButton.cs
│ │ │ └── ToolContextButton.cs
│ │ └── ToolbarElements/
│ │ ├── AIDropdown.cs
│ │ ├── AIDropdownConfig.cs
│ │ ├── AccountDropdown.cs
│ │ ├── BuiltinToolSettings.cs
│ │ ├── CloudButton.cs
│ │ ├── EditorToolsToolbar.cs
│ │ ├── LayersDropdown.cs
│ │ ├── LayoutDropdown.cs
│ │ ├── ModesDropdown.cs
│ │ ├── OverlayMenu.cs
│ │ ├── PackageManagerButton.cs
│ │ ├── PlayModeButtons.cs
│ │ ├── SearchButton.cs
│ │ ├── SnapSettings.cs
│ │ ├── StoreButton.cs
│ │ └── UndoButton.cs
│ ├── EmbreeEditor/
│ │ └── Embree.bindings.cs
│ ├── GameCenter/
│ │ ├── Managed/
│ │ │ ├── LocalService.cs
│ │ │ └── NetworkServices.cs
│ │ └── Public/
│ │ └── GameCenterServices.bindings.cs
│ ├── GenericRemoteEditor/
│ │ └── Public/
│ │ └── GenericRemote.bindings.cs
│ ├── GraphViewEditor/
│ │ ├── AssemblyInfo.cs
│ │ ├── Capabilities.cs
│ │ ├── Decorators/
│ │ │ └── GridBackground.cs
│ │ ├── Direction.cs
│ │ ├── EdgeControl.cs
│ │ ├── Elements/
│ │ │ ├── Blackboard/
│ │ │ │ ├── Blackboard.cs
│ │ │ │ ├── BlackboardField.cs
│ │ │ │ ├── BlackboardRow.cs
│ │ │ │ └── BlackboardSection.cs
│ │ │ ├── Edge.cs
│ │ │ ├── ElementResizer.cs
│ │ │ ├── GraphElement.cs
│ │ │ ├── GraphElementScopeExtensions.cs
│ │ │ ├── Group.cs
│ │ │ ├── GroupDropArea.cs
│ │ │ ├── IResizable.cs
│ │ │ ├── Line2.cs
│ │ │ ├── MiniMap.cs
│ │ │ ├── Node.cs
│ │ │ ├── Pill.cs
│ │ │ ├── Placemat/
│ │ │ │ ├── Placemat.cs
│ │ │ │ └── PlacematContainer.cs
│ │ │ ├── Port.cs
│ │ │ ├── ResizableElement.cs
│ │ │ ├── Scope.cs
│ │ │ ├── ScopeContentContainer.cs
│ │ │ ├── StackNode.cs
│ │ │ ├── StackNodeDropTarget.cs
│ │ │ ├── StackNodeSeparator.cs
│ │ │ ├── StickyNote.cs
│ │ │ └── TokenNode.cs
│ │ ├── ExperimentalNamespaceRelic.cs
│ │ ├── ICollectibleElement.cs
│ │ ├── IDroppable.cs
│ │ ├── IInsertLocation.cs
│ │ ├── ISelectable.cs
│ │ ├── ISelection.cs
│ │ ├── IconBadge.cs
│ │ ├── LineView.cs
│ │ ├── Manipulators/
│ │ │ ├── ClickSelector.cs
│ │ │ ├── ContentDragger.cs
│ │ │ ├── Dragger.cs
│ │ │ ├── EdgeConnector.cs
│ │ │ ├── EdgeDragHelper.cs
│ │ │ ├── EdgeManipulator.cs
│ │ │ ├── FreehandSelector.cs
│ │ │ ├── Inserter.cs
│ │ │ ├── RectangleSelector.cs
│ │ │ ├── Resizer.cs
│ │ │ ├── SelectionDragger.cs
│ │ │ ├── SelectionDropper.cs
│ │ │ ├── ShortcutHandler.cs
│ │ │ ├── SnapService.cs
│ │ │ ├── Snapper.cs
│ │ │ └── Zoomer.cs
│ │ ├── NodeAdapter.cs
│ │ ├── NodeSearch/
│ │ │ ├── SearchTree.cs
│ │ │ └── SearchWindow.cs
│ │ ├── Orientation.cs
│ │ ├── Utils/
│ │ │ ├── GraphViewTemplateDescriptor.cs
│ │ │ ├── RectUtils.cs
│ │ │ └── VisualElementAttacher.cs
│ │ ├── Views/
│ │ │ └── GraphView.cs
│ │ └── Windows/
│ │ ├── GraphViewBlackboardWindow.cs
│ │ ├── GraphViewEditorWindow.cs
│ │ ├── GraphViewMinimapWindow.cs
│ │ ├── GraphViewTemplateWindow.cs
│ │ └── GraphViewToolWindow.cs
│ ├── Grid/
│ │ ├── Managed/
│ │ │ └── Grid.cs
│ │ └── ScriptBindings/
│ │ ├── Grid.bindings.cs
│ │ └── GridLayout.bindings.cs
│ ├── GridAndSnap/
│ │ ├── GridSettingsWindow.cs
│ │ ├── LinkedVector3Field.cs
│ │ └── SnapSettingsWindow.cs
│ ├── GridEditor/
│ │ └── Managed/
│ │ └── GridEditor.cs
│ ├── HierarchyCore/
│ │ ├── Managed/
│ │ │ ├── AssemblyInfo.cs
│ │ │ ├── HierarchyFlattenedNodeChildren.cs
│ │ │ ├── HierarchyNodeChildren.cs
│ │ │ ├── HierarchyNodeChildrenAlloc.cs
│ │ │ ├── HierarchyNodeChildrenFixed.cs
│ │ │ ├── HierarchyNodeMapUnmanaged.cs
│ │ │ ├── HierarchyNodeTypeHandlerBase.cs
│ │ │ ├── HierarchyNodeTypeHandlerBaseEnumerable.cs
│ │ │ ├── HierarchyPropertyString.cs
│ │ │ ├── HierarchyPropertyUnmanaged.cs
│ │ │ ├── HierarchySearch.cs
│ │ │ ├── HierarchyViewNodesEnumerable.cs
│ │ │ ├── IHierarchyProperty.cs
│ │ │ └── NativeSparseArray.cs
│ │ └── ScriptBindings/
│ │ ├── Hierarchy.bindings.cs
│ │ ├── HierarchyCommandList.bindings.cs
│ │ ├── HierarchyFlattened.bindings.cs
│ │ ├── HierarchyFlattenedNode.bindings.cs
│ │ ├── HierarchyNode.bindings.cs
│ │ ├── HierarchyNodeFlags.bindings.cs
│ │ ├── HierarchyNodeType.bindings.cs
│ │ ├── HierarchyPropertyDescriptor.bindings.cs
│ │ ├── HierarchyPropertyId.bindings.cs
│ │ ├── HierarchyPropertyStorageType.bindings.cs
│ │ ├── HierarchySearch.bindings.cs
│ │ ├── HierarchyTestsHelper.bindings.cs
│ │ └── HierarchyViewModel.bindings.cs
│ ├── IMGUI/
│ │ ├── AssemblyInfo.cs
│ │ ├── DrawStates.cs
│ │ ├── Event.bindings.cs
│ │ ├── Event.cs
│ │ ├── EventCommandNames.cs
│ │ ├── EventEnums.cs
│ │ ├── EventInterests.cs
│ │ ├── FriendAttributes.cs
│ │ ├── GUI.bindings.cs
│ │ ├── GUI.cs
│ │ ├── GUIClip.bindings.cs
│ │ ├── GUIContent.cs
│ │ ├── GUIDebugger.bindings.cs
│ │ ├── GUIElement.deprecated.cs
│ │ ├── GUIEnums.cs
│ │ ├── GUILayer.deprecated.cs
│ │ ├── GUILayout.cs
│ │ ├── GUILayoutOption.cs
│ │ ├── GUILayoutUtility.bindings.cs
│ │ ├── GUILayoutUtility.cs
│ │ ├── GUISkin.bindings.cs
│ │ ├── GUISkin.cs
│ │ ├── GUIStateObjects.cs
│ │ ├── GUIStyle.bindings.cs
│ │ ├── GUIStyle.cs
│ │ ├── GUITargetAttribute.cs
│ │ ├── GUITexture.deprecated.cs
│ │ ├── GUIUtility.bindings.cs
│ │ ├── GUIUtility.cs
│ │ ├── IMGUITextHandle.cs
│ │ ├── LayoutEntry.cs
│ │ ├── LayoutGroup.cs
│ │ ├── ObjectGUIState.bindings.cs
│ │ ├── RuntimeTextSettings.cs
│ │ ├── ScrollViewState.cs
│ │ ├── SliderHandler.cs
│ │ ├── TextEditingUtilities.cs
│ │ ├── TextEditor.cs
│ │ └── TextSelectingUtilities.cs
│ ├── Identifiers/
│ │ └── Identifiers.bindings.cs
│ ├── ImageConversion/
│ │ └── ScriptBindings/
│ │ ├── AssemblyInfo.cs
│ │ └── ImageConversion.bindings.cs
│ ├── Input/
│ │ └── Private/
│ │ ├── Input.cs
│ │ └── InputModule.bindings.cs
│ ├── InputForUI/
│ │ ├── AssemblyInfo.cs
│ │ ├── Events/
│ │ │ ├── CommandEvent.cs
│ │ │ ├── Event.cs
│ │ │ ├── EventModifiers.cs
│ │ │ ├── EventSource.cs
│ │ │ ├── IEventProperties.cs
│ │ │ ├── IMECompositionEvent.cs
│ │ │ ├── KeyEvent.cs
│ │ │ ├── NavigationEvent.cs
│ │ │ ├── PointerEvent.cs
│ │ │ └── TextInputEvent.cs
│ │ ├── Provider/
│ │ │ ├── EventProvider.cs
│ │ │ ├── IEventProviderImpl.cs
│ │ │ ├── InputEventPartialProvider.cs
│ │ │ ├── InputManagerProvider.cs
│ │ │ ├── NavigationEventRepeatHelper.cs
│ │ │ └── PointerState.cs
│ │ └── Sanitizer/
│ │ └── EventSanitizer.cs
│ ├── InputLegacy/
│ │ ├── AndroidInput.bindings.cs
│ │ ├── Input.bindings.cs
│ │ └── MouseEvents.cs
│ ├── JSONSerialize/
│ │ └── Public/
│ │ └── JsonUtility.bindings.cs
│ ├── JSONSerializeEditor/
│ │ └── EditorJsonUtility.bindings.cs
│ ├── Licensing/
│ │ ├── Public/
│ │ │ └── LicensingUtility.bindings.cs
│ │ └── UI/
│ │ ├── Data/
│ │ │ └── Events/
│ │ │ ├── Base/
│ │ │ │ ├── Notification.cs
│ │ │ │ ├── NotificationReasons.cs
│ │ │ │ ├── NotificationType.cs
│ │ │ │ └── NotificationWithDetails.cs
│ │ │ ├── BorrowFeatureStatusNotification.cs
│ │ │ ├── LicenseExpiredNotification.cs
│ │ │ ├── LicenseOfflineValidityEndingNotification.cs
│ │ │ └── LicenseUpdateNotification.cs
│ │ ├── Events/
│ │ │ ├── Buttons/
│ │ │ │ ├── CloseButton.cs
│ │ │ │ ├── CloseProjectButton.cs
│ │ │ │ ├── EventsButtonFactory.cs
│ │ │ │ ├── EventsButtonType.cs
│ │ │ │ ├── IEventsButtonFactory.cs
│ │ │ │ ├── ManageLicenseButton.cs
│ │ │ │ ├── OkButton.cs
│ │ │ │ ├── OpenUnityHubButton.cs
│ │ │ │ ├── SaveAndQuitButton.cs
│ │ │ │ ├── TemplateEventsButton.cs
│ │ │ │ └── UpdateLicenseButton.cs
│ │ │ ├── Handlers/
│ │ │ │ ├── INotificationHandler.cs
│ │ │ │ ├── LicenseExpiredHandler.cs
│ │ │ │ ├── LicenseOfflineValidityEndingHandler.cs
│ │ │ │ └── LicenseUpdateHandler.cs
│ │ │ ├── ILicenseNotificationHandlerFactory.cs
│ │ │ ├── IModalWrapper.cs
│ │ │ ├── INotificationDispatcher.cs
│ │ │ ├── LicenseNotificationDispatcher.cs
│ │ │ ├── LicenseNotificationHandlerFactory.cs
│ │ │ ├── ModalWrapper.cs
│ │ │ ├── Text/
│ │ │ │ └── LicenseTrStrings.cs
│ │ │ └── Windows/
│ │ │ ├── LicenseExpiredWindow.cs
│ │ │ ├── LicenseExpiredWindowContents.cs
│ │ │ ├── LicenseOfflineValidityEndedWindow.cs
│ │ │ ├── LicenseOfflineValidityEndedWindowContents.cs
│ │ │ ├── LicenseOfflineValidityEndingWindow.cs
│ │ │ ├── LicenseOfflineValidityEndingWindowContents.cs
│ │ │ ├── LicenseRemovedWindow.cs
│ │ │ ├── LicenseRemovedWindowContents.cs
│ │ │ ├── LicenseReturnedWindow.cs
│ │ │ ├── LicenseReturnedWindowContents.cs
│ │ │ ├── LicenseRevokedWindow.cs
│ │ │ ├── LicenseRevokedWindowContents.cs
│ │ │ ├── TemplateLicenseEventWindow.cs
│ │ │ └── TemplateLicenseEventWindowContents.cs
│ │ ├── Helper/
│ │ │ ├── Constants.cs
│ │ │ ├── ILicenseLogger.cs
│ │ │ ├── LicenseLogger.cs
│ │ │ └── Utils.cs
│ │ ├── INativeApiWrapper.cs
│ │ ├── LicenseManagedWrapper.cs
│ │ └── NativeApiWrapper.cs
│ ├── Localization/
│ │ └── Public/
│ │ └── LocalizationAsset.bindings.cs
│ ├── LocalizationEditor/
│ │ ├── LocalizationAttribute.cs
│ │ ├── LocalizationDatabase.bindings.cs
│ │ ├── LocalizationDatabase.cs
│ │ └── LocalizedEditorFontManager.cs
│ ├── Marshalling/
│ │ ├── MarshallingTests.bindings.cs
│ │ └── MarshallingTests2.bindings.cs
│ ├── MeshLODGenerator/
│ │ └── ScriptBindings/
│ │ └── MeshLODUtility.bindings.cs
│ ├── Multiplayer/
│ │ └── Managed/
│ │ ├── AssemblyInfo.cs
│ │ ├── MultiplayerManager.bindings.cs
│ │ ├── MultiplayerRole.cs
│ │ └── MultiplayerRolesData.bindings.cs
│ ├── MultiplayerEditor/
│ │ └── Managed/
│ │ ├── AssemblyInfo.cs
│ │ ├── EditorMultiplayerManager.bindings.cs
│ │ ├── MultiplayerRoleDropdown.cs
│ │ └── MultiplayerRolesDataEditor.cs
│ ├── PackageManager/
│ │ └── Editor/
│ │ └── Managed/
│ │ ├── AssetStoreInfo.cs
│ │ ├── AuthorInfo.cs
│ │ ├── BuildUtilities.cs
│ │ ├── CacheRootConfig.cs
│ │ ├── Client.cs
│ │ ├── ConfigSource.cs
│ │ ├── DependencyInfo.cs
│ │ ├── DownloadProgress.cs
│ │ ├── EditorCompatibilityInfo.cs
│ │ ├── EditorCompatibilityLevel.cs
│ │ ├── EntitlementLicensingModel.cs
│ │ ├── EntitlementsInfo.cs
│ │ ├── Error.cs
│ │ ├── ErrorCode.cs
│ │ ├── Events.cs
│ │ ├── GitInfo.cs
│ │ ├── IShouldIncludeInBuildCallback.cs
│ │ ├── LogLevel.cs
│ │ ├── NativeEnumExtensions.cs
│ │ ├── NativeErrorCode.cs
│ │ ├── NativeStatusCode.cs
│ │ ├── OperationStatus.cs
│ │ ├── PackOperationResult.cs
│ │ ├── PackageCollection.cs
│ │ ├── PackageCompliance.cs
│ │ ├── PackageComplianceStatus.cs
│ │ ├── PackageInfo.cs
│ │ ├── PackageManager.bindings.cs
│ │ ├── PackageProgress.cs
│ │ ├── PackageRegistrationDiffEventArgs.cs
│ │ ├── PackageSource.cs
│ │ ├── PackageValidation.cs
│ │ ├── ProgressState.cs
│ │ ├── ProgressUpdateEventArgs.cs
│ │ ├── RegistryCompliance.cs
│ │ ├── RegistryComplianceStatus.cs
│ │ ├── RegistryInfo.cs
│ │ ├── RepositoryInfo.cs
│ │ ├── RequestProgress.cs
│ │ ├── Requests/
│ │ │ ├── AddAndRemoveRequest.cs
│ │ │ ├── AddRequest.cs
│ │ │ ├── AddScopedRegistryRequest.cs
│ │ │ ├── ClearCacheRequest.cs
│ │ │ ├── ClearCacheRootRequest.cs
│ │ │ ├── EmbedRequest.cs
│ │ │ ├── GetCacheRootRequest.cs
│ │ │ ├── GetRegistriesRequest.cs
│ │ │ ├── ListBuiltInPackagesRequest.cs
│ │ │ ├── ListRequest.cs
│ │ │ ├── PackRequest.cs
│ │ │ ├── RemoveRequest.cs
│ │ │ ├── RemoveScopedRegistryRequest.cs
│ │ │ ├── Request.cs
│ │ │ ├── Requests.bindings.cs
│ │ │ ├── ResetToEditorDefaultsRequest.cs
│ │ │ ├── SearchRequest.cs
│ │ │ ├── SetCacheRootRequest.cs
│ │ │ └── UpdateScopedRegistryRequest.cs
│ │ ├── ResolutionStrategy.cs
│ │ ├── Search/
│ │ │ ├── SearchCapabilities.cs
│ │ │ └── SearchOrderBy.cs
│ │ ├── SemVersionHelper.cs
│ │ ├── SignatureInfo.cs
│ │ ├── SignatureStatus.cs
│ │ ├── StatusCode.cs
│ │ ├── UnityLifecycleInfo.cs
│ │ ├── UpdateScopedRegistryOptions.cs
│ │ ├── VersionsInfo.cs
│ │ └── Violation.cs
│ ├── PackageManagerUI/
│ │ └── Editor/
│ │ ├── Extensions/
│ │ │ ├── BaseDropdownItem.cs
│ │ │ ├── DetailsExtension.cs
│ │ │ ├── ExtendableToolbarMenu.cs
│ │ │ ├── ExtensionManager.cs
│ │ │ ├── InputDropdownArgs.cs
│ │ │ ├── Interfaces/
│ │ │ │ ├── IDetailsExtension.cs
│ │ │ │ ├── IExtension.cs
│ │ │ │ ├── IMenu.cs
│ │ │ │ ├── IMenuDropdownItem.cs
│ │ │ │ ├── IPackageActionButton.cs
│ │ │ │ ├── IPackageActionDropdownItem.cs
│ │ │ │ ├── IPackageActionMenu.cs
│ │ │ │ ├── IPackageSelectionChangedHandler.cs
│ │ │ │ ├── IWindow.cs
│ │ │ │ ├── IWindowCreatedHandler.cs
│ │ │ │ └── IWindowDestroyHandler.cs
│ │ │ ├── MenuDropdownItem.cs
│ │ │ ├── PackageActionDropdownItem.cs
│ │ │ ├── PackageExtensionAction.cs
│ │ │ └── PackageSelectionArgs.cs
│ │ ├── External/
│ │ │ ├── EditorGameServiceExtension.cs
│ │ │ ├── SemVersionExtension.cs
│ │ │ └── ServicesTab/
│ │ │ ├── ServiceGroupingsWrapper.cs
│ │ │ └── ServicesTabConfiguration.cs
│ │ ├── Services/
│ │ │ ├── Analytics/
│ │ │ │ ├── AssetSelectionWindowAnalytics.cs
│ │ │ │ ├── PackageCacheManagementAnalytics.cs
│ │ │ │ ├── PackageManagerDialogAnalytics.cs
│ │ │ │ ├── PackageManagerFiltersAnalytics.cs
│ │ │ │ ├── PackageManagerOperationErrorAnalytics.cs
│ │ │ │ └── PackageManagerWindowAnalytics.cs
│ │ │ ├── AssetStore/
│ │ │ │ ├── Asset.cs
│ │ │ │ ├── AssetSelectionHandler.cs
│ │ │ │ ├── AssetStoreCache.cs
│ │ │ │ ├── AssetStoreClientV2.cs
│ │ │ │ ├── AssetStoreDownloadInfo.cs
│ │ │ │ ├── AssetStoreDownloadManager.cs
│ │ │ │ ├── AssetStoreDownloadOperation.cs
│ │ │ │ ├── AssetStoreImportedPackage.cs
│ │ │ │ ├── AssetStoreListOperation.cs
│ │ │ │ ├── AssetStoreLocalInfo.cs
│ │ │ │ ├── AssetStoreOAuth.cs
│ │ │ │ ├── AssetStorePackageFactory.cs
│ │ │ │ ├── AssetStorePackageInstaller.cs
│ │ │ │ ├── AssetStorePackageVersion.cs
│ │ │ │ ├── AssetStoreProductInfo.cs
│ │ │ │ ├── AssetStorePurchaseInfo.cs
│ │ │ │ ├── AssetStorePurchases.cs
│ │ │ │ ├── AssetStoreRestAPI.cs
│ │ │ │ ├── AssetStoreUpdateInfo.cs
│ │ │ │ ├── AssetStoreUtils.cs
│ │ │ │ ├── AssetStoreVersionList.cs
│ │ │ │ ├── JsonParser.cs
│ │ │ │ └── LocalInfoHandler.cs
│ │ │ ├── Common/
│ │ │ │ ├── BackgroundFetchHandler.cs
│ │ │ │ ├── BasePackageVersion.cs
│ │ │ │ ├── BaseVersionList.cs
│ │ │ │ ├── DictionaryExtensions.cs
│ │ │ │ ├── DownloadState.cs
│ │ │ │ ├── FetchStatusTracker.cs
│ │ │ │ ├── Icon.cs
│ │ │ │ ├── OperationFactory.cs
│ │ │ │ ├── Package.cs
│ │ │ │ ├── PackageComplianceExtension.cs
│ │ │ │ ├── PackageInfoExtension.cs
│ │ │ │ ├── PackageManagerPrefs.cs
│ │ │ │ ├── PlaceholderPackageVersion.cs
│ │ │ │ ├── PlaceholderVersionList.cs
│ │ │ │ ├── PlayModeDownload.cs
│ │ │ │ ├── Product.cs
│ │ │ │ ├── RegistryComplianceExtension.cs
│ │ │ │ ├── RegistryInfoExtension.cs
│ │ │ │ ├── ResourceLoader.cs
│ │ │ │ ├── UIError.cs
│ │ │ │ ├── UIErrorCode.cs
│ │ │ │ ├── UniqueIdMapper.cs
│ │ │ │ └── ViolationExtension.cs
│ │ │ ├── EntitlementsErrorAndDeprecationChecker.cs
│ │ │ ├── Interfaces/
│ │ │ │ ├── IOperation.cs
│ │ │ │ ├── IPackage.cs
│ │ │ │ ├── IPackageVersion.cs
│ │ │ │ ├── IPage.cs
│ │ │ │ ├── IProduct.cs
│ │ │ │ ├── IVersionList.cs
│ │ │ │ └── IVisualStateList.cs
│ │ │ ├── Packages/
│ │ │ │ ├── Actions/
│ │ │ │ │ ├── AddAction.cs
│ │ │ │ │ ├── CancelDownloadAction.cs
│ │ │ │ │ ├── DeselectAction.cs
│ │ │ │ │ ├── DisableCondition.cs
│ │ │ │ │ ├── DownloadActionBase.cs
│ │ │ │ │ ├── DownloadNewAction.cs
│ │ │ │ │ ├── DownloadUpdateAction.cs
│ │ │ │ │ ├── GitUpdateAction.cs
│ │ │ │ │ ├── ImportActionBase.cs
│ │ │ │ │ ├── ImportNewAction.cs
│ │ │ │ │ ├── ImportUpdateAction.cs
│ │ │ │ │ ├── PackageAction.cs
│ │ │ │ │ ├── PauseDownloadAction.cs
│ │ │ │ │ ├── ReDownloadAction.cs
│ │ │ │ │ ├── ReImportAction.cs
│ │ │ │ │ ├── RemoveAction.cs
│ │ │ │ │ ├── RemoveCustomAction.cs
│ │ │ │ │ ├── RemoveImportedAction.cs
│ │ │ │ │ ├── ResetAction.cs
│ │ │ │ │ ├── ResumeDownloadAction.cs
│ │ │ │ │ ├── SignInAction.cs
│ │ │ │ │ ├── UnlockAction.cs
│ │ │ │ │ ├── UpdateAction.cs
│ │ │ │ │ ├── UpdateActionBase.cs
│ │ │ │ │ └── VersionHistoryUpdateAction.cs
│ │ │ │ ├── PackageDatabase.cs
│ │ │ │ ├── PackageImage.cs
│ │ │ │ ├── PackageLink/
│ │ │ │ │ ├── PackageLink.cs
│ │ │ │ │ ├── PackageLinkFactory.cs
│ │ │ │ │ ├── PackageUpmChangelogLink.cs
│ │ │ │ │ ├── PackageUpmDocumentationLink.cs
│ │ │ │ │ ├── PackageUpmLicenseLink.cs
│ │ │ │ │ └── PackageUpmVersionHistoryChangelogLink.cs
│ │ │ │ ├── PackageOperationDispatcher.cs
│ │ │ │ ├── PackageProgress.cs
│ │ │ │ ├── PackageSample.cs
│ │ │ │ ├── PackageSizeInfo.cs
│ │ │ │ ├── PackageState.cs
│ │ │ │ ├── PackageTag.cs
│ │ │ │ └── RegistryType.cs
│ │ │ ├── Pages/
│ │ │ │ ├── BasePage.cs
│ │ │ │ ├── PageCapability.cs
│ │ │ │ ├── PageFactory.cs
│ │ │ │ ├── PageFilters.cs
│ │ │ │ ├── PageManager.cs
│ │ │ │ ├── PageRefreshHandler.cs
│ │ │ │ ├── PageSelection.cs
│ │ │ │ ├── PageSortOption.cs
│ │ │ │ ├── PageTypes/
│ │ │ │ │ ├── BuiltInPage.cs
│ │ │ │ │ ├── ExtensionPage.cs
│ │ │ │ │ ├── InProjectNonCompliancePage.cs
│ │ │ │ │ ├── InProjectPage.cs
│ │ │ │ │ ├── InProjectUpdatesPage.cs
│ │ │ │ │ ├── MyAssetsPage.cs
│ │ │ │ │ ├── MyRegistriesPage.cs
│ │ │ │ │ ├── ScopedRegistryPage.cs
│ │ │ │ │ └── UnityRegistryPage.cs
│ │ │ │ ├── PaginatedVisualStateList.cs
│ │ │ │ ├── RefreshOptions.cs
│ │ │ │ ├── SimplePage.cs
│ │ │ │ ├── VisualState.cs
│ │ │ │ └── VisualStateList.cs
│ │ │ ├── ProjectSettings/
│ │ │ │ ├── PackageManagerProjectSettings.cs
│ │ │ │ ├── PackageManagerProjectSettingsProvider.cs
│ │ │ │ ├── RegistryInfoDraft.cs
│ │ │ │ ├── RegistryInfoDraftData.cs
│ │ │ │ └── RegistryInfoOriginalData.cs
│ │ │ ├── Proxies/
│ │ │ │ ├── ApplicationProxy.cs
│ │ │ │ ├── AssetDatabaseProxy.cs
│ │ │ │ ├── AssetStoreCachePathProxy.cs
│ │ │ │ ├── ClientProxy.cs
│ │ │ │ ├── DateTimeProxy.cs
│ │ │ │ ├── EditorAnalyticsProxy.cs
│ │ │ │ ├── HttpClientFactory.cs
│ │ │ │ ├── IOProxy.cs
│ │ │ │ ├── PackageManagerProjectSettingsProxy.cs
│ │ │ │ ├── SelectionProxy.cs
│ │ │ │ ├── UnityConnectProxy.cs
│ │ │ │ └── UnityOAuthProxy.cs
│ │ │ ├── ServicesContainer.cs
│ │ │ ├── Upm/
│ │ │ │ ├── UpmAddAndRemoveOperation.cs
│ │ │ │ ├── UpmAddOperation.cs
│ │ │ │ ├── UpmAddRegistryOperation.cs
│ │ │ │ ├── UpmBaseOperation.cs
│ │ │ │ ├── UpmCache.cs
│ │ │ │ ├── UpmCacheRootClient.cs
│ │ │ │ ├── UpmClearCacheRootOperation.cs
│ │ │ │ ├── UpmClient.cs
│ │ │ │ ├── UpmGetCacheRootOperation.cs
│ │ │ │ ├── UpmGetRegistriesOperation.cs
│ │ │ │ ├── UpmListOperation.cs
│ │ │ │ ├── UpmPackageData.cs
│ │ │ │ ├── UpmPackageFactory.cs
│ │ │ │ ├── UpmPackageVersion.cs
│ │ │ │ ├── UpmRegistryClient.cs
│ │ │ │ ├── UpmRemoveOperation.cs
│ │ │ │ ├── UpmRemoveRegistryOperation.cs
│ │ │ │ ├── UpmSearchOperation.cs
│ │ │ │ ├── UpmSetCacheRootOperation.cs
│ │ │ │ ├── UpmUpdateRegistryOperation.cs
│ │ │ │ └── UpmVersionList.cs
│ │ │ └── UserSettings/
│ │ │ └── PackageManagerUserSettingsProvider.cs
│ │ └── UI/
│ │ ├── AddPackageByNameDropdown.cs
│ │ ├── Common/
│ │ │ ├── Alert.cs
│ │ │ ├── BaseDropdownButton.cs
│ │ │ ├── DelayedSelectionHandler.cs
│ │ │ ├── DropdownButton.cs
│ │ │ ├── IOUtils.cs
│ │ │ ├── IncorrectFieldTypeException.cs
│ │ │ ├── InspectorSelectionHandler.cs
│ │ │ ├── LoadingSpinner.cs
│ │ │ ├── ProgressBar.cs
│ │ │ ├── SelectableLabel.cs
│ │ │ ├── Tabs/
│ │ │ │ ├── BaseTabElement.cs
│ │ │ │ ├── BaseTabView.cs
│ │ │ │ ├── ITabElement.cs
│ │ │ │ └── ITabView.cs
│ │ │ ├── TagLabelList.cs
│ │ │ ├── TextFieldPlaceholder.cs
│ │ │ ├── ToolbarWindowMenu.cs
│ │ │ ├── UIUtils.cs
│ │ │ ├── VisualElementCache.cs
│ │ │ └── VisualElementExtensions.cs
│ │ ├── DropdownContainer.cs
│ │ ├── DropdownContent.cs
│ │ ├── DropdownElement.cs
│ │ ├── Filters/
│ │ │ ├── AssetStoreFiltersWindow.cs
│ │ │ └── UpmFiltersWindow.cs
│ │ ├── Generic/
│ │ │ └── HelpBoxWithOptionalReadMore.cs
│ │ ├── GenericInputDropdown.cs
│ │ ├── InProgressDropdown.cs
│ │ ├── InProgressView.cs
│ │ ├── Interfaces/
│ │ │ ├── IPackageListView.cs
│ │ │ ├── IPackageManagerExtension.cs
│ │ │ └── ISelectableItem.cs
│ │ ├── MultiSelect/
│ │ │ ├── CheckUpdateFoldout.cs
│ │ │ ├── DownloadFoldoutGroup.cs
│ │ │ ├── DownloadUpdateFoldoutGroup.cs
│ │ │ ├── IMultiSelectFoldoutElement.cs
│ │ │ ├── InstallFoldoutGroup.cs
│ │ │ ├── MultiSelectDetails.cs
│ │ │ ├── MultiSelectFoldout.cs
│ │ │ ├── MultiSelectFoldoutGroup.cs
│ │ │ ├── MultiSelectItem.cs
│ │ │ ├── NoActionsFoldout.cs
│ │ │ ├── RemoveFoldoutGroup.cs
│ │ │ ├── RemoveImportedFoldoutGroup.cs
│ │ │ ├── UnlockFoldout.cs
│ │ │ ├── UpdateFoldout.cs
│ │ │ └── UpdateFoldoutGroup.cs
│ │ ├── PackageDetails.cs
│ │ ├── PackageDetailsBody.cs
│ │ ├── PackageDetailsHeader.cs
│ │ ├── PackageDetailsLinks.cs
│ │ ├── PackageDetailsTabs/
│ │ │ ├── PackageDetailsDependenciesTab.cs
│ │ │ ├── PackageDetailsDescriptionTab.cs
│ │ │ ├── PackageDetailsFeatureDependenciesTab.cs
│ │ │ ├── PackageDetailsImagesTab.cs
│ │ │ ├── PackageDetailsImportedAssetsTab.cs
│ │ │ ├── PackageDetailsOverviewTab.cs
│ │ │ ├── PackageDetailsOverviewTabContent.cs
│ │ │ ├── PackageDetailsReleasesTab.cs
│ │ │ ├── PackageDetailsSampleItem.cs
│ │ │ ├── PackageDetailsSamplesTab.cs
│ │ │ ├── PackageDetailsTabElement.cs
│ │ │ ├── PackageDetailsTabView.cs
│ │ │ ├── PackageDetailsVersionHistoryItem.cs
│ │ │ ├── PackageDetailsVersionsTab.cs
│ │ │ ├── SignInDetails.cs
│ │ │ └── SortedColumn.cs
│ │ ├── PackageGroup.cs
│ │ ├── PackageHelpBox/
│ │ │ ├── DeprecatedPackageHelpBox.cs
│ │ │ ├── DeprecatedVersionHelpBox.cs
│ │ │ ├── DisabledPackageHelpBox.cs
│ │ │ ├── HiddenProductHelpBox.cs
│ │ │ ├── NonCompliantPackageHelpBox.cs
│ │ │ ├── PackageBaseHelpBox.cs
│ │ │ ├── ScopedRegistryHelpBox.cs
│ │ │ └── VersionTagHelpBox.cs
│ │ ├── PackageItem.cs
│ │ ├── PackageLinks/
│ │ │ ├── PackageLinkButton.cs
│ │ │ └── PackageQuickStartButton.cs
│ │ ├── PackageList.cs
│ │ ├── PackageListScrollView.cs
│ │ ├── PackageListView.cs
│ │ ├── PackageLoadBar.cs
│ │ ├── PackageManagerExtensions.cs
│ │ ├── PackageManagerFiltersWindow.cs
│ │ ├── PackageManagerToolbar.cs
│ │ ├── PackageManagerWindow.cs
│ │ ├── PackageManagerWindowRoot.cs
│ │ ├── PackageManifest.cs
│ │ ├── PackageManifestImporterEditor.cs
│ │ ├── PackagePlatformList.cs
│ │ ├── PackageReleaseDetailsItem.cs
│ │ ├── PackageSampleItemLowWidth.cs
│ │ ├── PackageSearchBar.cs
│ │ ├── PackageSelectionEditor.cs
│ │ ├── PackageSelectionObject.cs
│ │ ├── PackageStatusBar.cs
│ │ ├── PackageTagLabel/
│ │ │ ├── PackageAssetStoreTagLabel.cs
│ │ │ ├── PackageBaseTagLabel.cs
│ │ │ ├── PackageDeprecatedTagLabel.cs
│ │ │ ├── PackageDynamicTagLabel.cs
│ │ │ └── PackageSimpleTagLabel.cs
│ │ ├── PartiallyNonCompliantRegistryMessage.cs
│ │ ├── RegistryItem.cs
│ │ ├── ScopedRegistriesSettings.cs
│ │ ├── ScopedRegistryAddedPopup.cs
│ │ ├── SelectionWindow/
│ │ │ ├── SelectionWindow.cs
│ │ │ ├── SelectionWindowData.cs
│ │ │ ├── SelectionWindowFooter.cs
│ │ │ ├── SelectionWindowHeader.cs
│ │ │ ├── SelectionWindowProxy.cs
│ │ │ ├── SelectionWindowRoot.cs
│ │ │ ├── SelectionWindowRow.cs
│ │ │ └── SelectionWindowTreeView.cs
│ │ ├── Sidebar/
│ │ │ ├── Sidebar.cs
│ │ │ └── SidebarRow.cs
│ │ ├── SignInBar.cs
│ │ ├── ToolBar/
│ │ │ ├── Interfaces/
│ │ │ │ └── IPackageToolBarButton.cs
│ │ │ ├── LegacyFormatDropdownButton.cs
│ │ │ ├── PackageToolBar.cs
│ │ │ ├── PackageToolBarButtonSingleAction.cs
│ │ │ └── PackageToolBarError.cs
│ │ └── VersionInfoIcon.cs
│ ├── ParticleSystem/
│ │ ├── Managed/
│ │ │ ├── IJobParticleSystem.cs
│ │ │ ├── ParticleSystem.deprecated.cs
│ │ │ ├── ParticleSystemEnums.cs
│ │ │ ├── ParticleSystemJobStructs.cs
│ │ │ ├── ParticleSystemRenderer.deprecated.cs
│ │ │ └── ParticleSystemStructs.cs
│ │ └── ScriptBindings/
│ │ ├── ParticleSystem.bindings.cs
│ │ ├── ParticleSystemForceField.bindings.cs
│ │ ├── ParticleSystemModules.bindings.cs
│ │ └── ParticleSystemRenderer.bindings.cs
│ ├── ParticleSystemEditor/
│ │ ├── ParticleEffectUI.cs
│ │ ├── ParticleSystemClipboard.cs
│ │ ├── ParticleSystemCurveEditor.cs
│ │ ├── ParticleSystemEditor.cs
│ │ ├── ParticleSystemModules/
│ │ │ ├── ClampVelocityModuleUI.cs
│ │ │ ├── CollisionModuleUI.cs
│ │ │ ├── ColorByVelocityModuleUI.cs
│ │ │ ├── ColorModuleUI.cs
│ │ │ ├── CustomDataModuleUI.cs
│ │ │ ├── EmissionModuleUI.cs
│ │ │ ├── ExternalForcesModuleUI.cs
│ │ │ ├── ForceModuleUI.cs
│ │ │ ├── InheritVelocityModuleUI.cs
│ │ │ ├── InitialModuleUI.cs
│ │ │ ├── LifetimeByEmitterSpeedModuleUI.cs
│ │ │ ├── LightsModuleUI.cs
│ │ │ ├── ModuleUI.cs
│ │ │ ├── ModuleUIHelpers.cs
│ │ │ ├── NoiseModuleUI.cs
│ │ │ ├── RendererModuleUI.cs
│ │ │ ├── RotationByVelocityModuleUI.cs
│ │ │ ├── RotationModuleUI.cs
│ │ │ ├── SerializedModuleUI.cs
│ │ │ ├── ShapeModuleUI.cs
│ │ │ ├── SizeByVelocityModuleUI.cs
│ │ │ ├── SizeModuleUI.cs
│ │ │ ├── SubModuleUI.cs
│ │ │ ├── TrailModuleUI.cs
│ │ │ ├── TriggerModuleUI.cs
│ │ │ ├── UVModuleUI.cs
│ │ │ └── VelocityModuleUI.cs
│ │ ├── ParticleSystemStyles.cs
│ │ ├── ParticleSystemUI.cs
│ │ ├── ParticleSystemWindow.cs
│ │ ├── ScriptBindings/
│ │ │ └── ParticleSystemEditor.bindings.cs
│ │ ├── SerializedMinMaxColor.cs
│ │ ├── SerializedMinMaxCurve.cs
│ │ └── SerializedMinMaxGradient.cs
│ ├── PerformanceReporting/
│ │ └── ScriptBindings/
│ │ └── PerformanceReporting.bindings.cs
│ ├── Physics/
│ │ ├── AssemblyInfo.cs
│ │ ├── Managed/
│ │ │ ├── Collision.cs
│ │ │ ├── CollisionDetectionMode.cs
│ │ │ ├── ForceMode.cs
│ │ │ ├── JointConstraints.cs
│ │ │ └── WheelFrictionCurve.cs
│ │ └── ScriptBindings/
│ │ ├── Articulations.bindings.cs
│ │ ├── Articulations.deprecated.cs
│ │ ├── BoxCollider.bindings.cs
│ │ ├── CapsuleCollider.bindings.cs
│ │ ├── CharacterController.bindings.cs
│ │ ├── CharacterJoint.bindings.cs
│ │ ├── Collider.bindings.cs
│ │ ├── ConfigurableJoint.bindings.cs
│ │ ├── ConstantForce.bindings.cs
│ │ ├── ContactModification.bindings.cs
│ │ ├── FixedJoint.bindings.cs
│ │ ├── HingeJoint.bindings.cs
│ │ ├── ImmediatePhysics.bindings.cs
│ │ ├── Joint.bindings.cs
│ │ ├── MeshCollider.bindings.cs
│ │ ├── Physics.bindings.cs
│ │ ├── Physics.deprecated.cs
│ │ ├── PhysicsContact.bindings.cs
│ │ ├── PhysicsContact.deprecated.cs
│ │ ├── PhysicsGeometry.bindings.cs
│ │ ├── PhysicsMaterial.bindings.cs
│ │ ├── PhysicsMaterial.deprecated.cs
│ │ ├── PhysicsScene.bindings.cs
│ │ ├── QueryCommand.bindings.cs
│ │ ├── QueryCommand.deprecated.cs
│ │ ├── RaycastHit.bindings.cs
│ │ ├── Rigidbody.bindings.cs
│ │ ├── Rigidbody.deprecated.cs
│ │ ├── SphereCollider.bindings.cs
│ │ └── SpringJoint.bindings.cs
│ ├── Physics2D/
│ │ └── ScriptBindings/
│ │ ├── Physics2D.bindings.cs
│ │ └── Physics2D.deprecated.cs
│ ├── Physics2DEditor/
│ │ └── Managed/
│ │ ├── Colliders/
│ │ │ ├── BoxCollider2DEditor.cs
│ │ │ ├── BoxCollider2DTool.cs
│ │ │ ├── CapsuleCollider2DEditor.cs
│ │ │ ├── CapsuleCollider2DTool.cs
│ │ │ ├── CircleCollider2DEditor.cs
│ │ │ ├── CircleCollider2DTool.cs
│ │ │ ├── Collider2DEditorBase.cs
│ │ │ ├── Collider2DToolBase.cs
│ │ │ ├── CompositeCollider2DEditor.cs
│ │ │ ├── CustomCollider2DEditor.cs
│ │ │ ├── EdgeCollider2DEditor.cs
│ │ │ ├── EdgeCollider2DTool.cs
│ │ │ ├── EditableLineHandle2D.cs
│ │ │ ├── EditablePath2D.cs
│ │ │ ├── EditablePath2DTool.cs
│ │ │ ├── PolygonCollider2DEditor.cs
│ │ │ ├── PolygonCollider2DTool.cs
│ │ │ └── PrimitiveCollider2DTool.cs
│ │ ├── Effectors/
│ │ │ ├── AreaEffector2DEditor.cs
│ │ │ ├── BuoyancyEffector2DEditor.cs
│ │ │ ├── Effector2DEditor.cs
│ │ │ ├── PlatformEffector2DEditor.cs
│ │ │ ├── PointEffector2DEditor.cs
│ │ │ └── SurfaceEffector2DEditor.cs
│ │ ├── Joints/
│ │ │ ├── AnchoredJoint2DEditor.cs
│ │ │ ├── DistanceJoint2DEditor.cs
│ │ │ ├── HingeJoint2DEditor.cs
│ │ │ ├── HingeJoint2DTool.cs
│ │ │ ├── Joint2DEditor.cs
│ │ │ ├── JointAngularLimitHandle2D.cs
│ │ │ ├── RelativeJoint2DEditor.cs
│ │ │ ├── SliderJoint2DEditor.cs
│ │ │ ├── SpringJoint2DEditor.cs
│ │ │ ├── TargetJoint2DEditor.cs
│ │ │ └── WheelJoint2DEditor.cs
│ │ ├── Menu/
│ │ │ └── Physics2DMenuItem.cs
│ │ ├── Rigidbody/
│ │ │ └── Rigidbody2DEditor.cs
│ │ └── Settings/
│ │ ├── LayerCollisionMatrix2D.cs
│ │ ├── Physics2DPreferences.cs
│ │ └── Physics2DSettingsEditor.cs
│ ├── PhysicsEditor/
│ │ ├── ArticulationBodyEditor.cs
│ │ ├── ArticulationBodyEditorCommon.cs
│ │ ├── ArticulationBodyJointLimitTool.cs
│ │ ├── ArticulatonBodyAnchorTransformTool.cs
│ │ ├── BoxColliderEditor.cs
│ │ ├── CapsuleColliderEditor.cs
│ │ ├── CharacterControllerEditor.cs
│ │ ├── CharacterJointEditor.cs
│ │ ├── Collider3DEditorBase.cs
│ │ ├── ColliderEditorUtility.cs
│ │ ├── ConfigurableJointEditor.cs
│ │ ├── HingeJointEditor.cs
│ │ ├── JointAngularLimitHandle.cs
│ │ ├── JointEditor.cs
│ │ ├── MeshColliderEditor.cs
│ │ ├── PhysicsDebugWindow.cs
│ │ ├── PhysicsDebugWindowContactsTab.cs
│ │ ├── PhysicsDebugWindowInfoTab.cs
│ │ ├── PhysicsDebugWindowInternal.cs
│ │ ├── PhysicsDebugWindowQueries.cs
│ │ ├── PhysicsManagerInspector.cs
│ │ ├── PhysicsManagerInspectorBridge.cs
│ │ ├── PhysicsMaterialEditor.cs
│ │ ├── RagdollBuilder.cs
│ │ ├── RagdollBuilderWindow.cs
│ │ ├── RigidbodyEditor.cs
│ │ ├── ScriptBindings/
│ │ │ ├── PhysicsDebug.bindings.cs
│ │ │ └── PhysicsDebug.deprecated.cs
│ │ ├── SphereColliderEditor.cs
│ │ ├── TerrainColliderEditor.cs
│ │ └── WheelColliderEditor.cs
│ ├── PresetsEditor/
│ │ ├── AddPresetTypeWindow/
│ │ │ ├── AddPresetTypeDataSource.cs
│ │ │ ├── AddPresetTypeGUI.cs
│ │ │ ├── AddPresetTypeWindow.cs
│ │ │ └── PresetTypeDropdownItem.cs
│ │ ├── PresetEditorHelper.cs
│ │ ├── PresetManagerPostProcessor.cs
│ │ └── Public/
│ │ ├── Preset.bindings.cs
│ │ ├── PresetManager.bindings.cs
│ │ └── PresetType.bindings.cs
│ ├── PresetsUIEditor/
│ │ ├── DefaultPresetReorderableList.cs
│ │ ├── PresetEditor.cs
│ │ ├── PresetManagerEditor.cs
│ │ ├── PresetSearchProvider.cs
│ │ └── PresetSelector.cs
│ ├── ProfilerEditor/
│ │ ├── MemoryProfiler/
│ │ │ ├── ArrayEntries.cs
│ │ │ ├── BlockSection.cs
│ │ │ ├── ChapterSection.cs
│ │ │ ├── MemoryProfilerCompilationGuard.cs
│ │ │ ├── MemorySnapshot.cs
│ │ │ ├── MemorySnapshotFileReader.cs
│ │ │ └── MemorySnapshotFileWriter.bindings.cs
│ │ ├── ProfilerOutOfProcess/
│ │ │ └── ProfilerRoleProvider.cs
│ │ ├── ProfilerWindow/
│ │ │ ├── Analytics/
│ │ │ │ ├── EditorAnalyticsService.cs
│ │ │ │ ├── IAnalyticsService.cs
│ │ │ │ └── ProfilerWindowAnalytics.cs
│ │ │ ├── Bottlenecks/
│ │ │ │ ├── Chart/
│ │ │ │ │ ├── BottlenecksChartViewController.cs
│ │ │ │ │ ├── Components/
│ │ │ │ │ │ ├── BlocksGraphView/
│ │ │ │ │ │ │ ├── BlocksGraphView.cs
│ │ │ │ │ │ │ └── BlocksGraphViewMeshBuilder.cs
│ │ │ │ │ │ └── GraphView.cs
│ │ │ │ │ ├── Data/
│ │ │ │ │ │ ├── BottlenecksChartViewModel.cs
│ │ │ │ │ │ └── BottlenecksChartViewModelBuilder.cs
│ │ │ │ │ └── Tooltip/
│ │ │ │ │ └── BottlenecksChartTooltipViewController.cs
│ │ │ │ ├── Data/
│ │ │ │ │ ├── IProfilerCaptureDataService.cs
│ │ │ │ │ ├── IProfilerPersistentSettingsService.cs
│ │ │ │ │ ├── LegacyGlobalProfilerPersistentSettingsService.cs
│ │ │ │ │ └── LegacySingletonProfilerCaptureDataService.cs
│ │ │ │ └── Details/
│ │ │ │ ├── BottlenecksDetailsViewController.cs
│ │ │ │ ├── Data/
│ │ │ │ │ ├── BottlenecksDetailsViewModel.cs
│ │ │ │ │ └── BottlenecksDetailsViewModelBuilder.cs
│ │ │ │ └── Shared/
│ │ │ │ └── TimeFormatterUtility.cs
│ │ │ ├── Chart.cs
│ │ │ ├── IProfilerWindowController.cs
│ │ │ ├── LegacyProfilerAreaUtility.cs
│ │ │ ├── ModuleEditor/
│ │ │ │ ├── Data/
│ │ │ │ │ ├── CounterCollector.cs
│ │ │ │ │ └── ModuleData.cs
│ │ │ │ ├── ModuleDetailsViewController.cs
│ │ │ │ ├── ModuleEditorWindow.cs
│ │ │ │ ├── ModuleListViewController.cs
│ │ │ │ ├── ViewController.cs
│ │ │ │ └── Views/
│ │ │ │ └── DragIndicator.cs
│ │ │ ├── ProfilerCategoryActivator.cs
│ │ │ ├── ProfilerChart.cs
│ │ │ ├── ProfilerColors.cs
│ │ │ ├── ProfilerCounterData.cs
│ │ │ ├── ProfilerCounterDescriptor.cs
│ │ │ ├── ProfilerDetailedCallsView.cs
│ │ │ ├── ProfilerDetailedObjectsView.cs
│ │ │ ├── ProfilerDetailedView.cs
│ │ │ ├── ProfilerEditorUtility.cs
│ │ │ ├── ProfilerFrameDataTreeView.cs
│ │ │ ├── ProfilerFrameHierarchyView.cs
│ │ │ ├── ProfilerFrameViewBase.cs
│ │ │ ├── ProfilerModuleTypeValidator.cs
│ │ │ ├── ProfilerModules/
│ │ │ │ ├── Audio/
│ │ │ │ │ ├── AudioProfilerModule.cs
│ │ │ │ │ └── AudioProfilerView.cs
│ │ │ │ ├── Box2D/
│ │ │ │ │ └── Physics2DProfilerModule.cs
│ │ │ │ ├── CPU/
│ │ │ │ │ ├── CPUProfilerModule.cs
│ │ │ │ │ ├── FlowIndicatorDrawer.cs
│ │ │ │ │ ├── FlowLinesDrawer.cs
│ │ │ │ │ ├── ProfilerFrameTimingUtility.cs
│ │ │ │ │ └── ProfilerTimelineGUI.cs
│ │ │ │ ├── CPUorGPUProfilerModule.cs
│ │ │ │ ├── DynamicProfilerModule.cs
│ │ │ │ ├── FileIO/
│ │ │ │ │ ├── AssetLoadingProfilerModule.cs
│ │ │ │ │ ├── AssetLoadingProfilerView.cs
│ │ │ │ │ ├── AssetMarkerTreeView.cs
│ │ │ │ │ ├── FileAccessTreeView.cs
│ │ │ │ │ ├── FileIOProfilerModule.cs
│ │ │ │ │ ├── FileIOProfilerView.cs
│ │ │ │ │ ├── FileSummaryTreeView.cs
│ │ │ │ │ └── LoadingProfilerViewBase.cs
│ │ │ │ ├── GPU/
│ │ │ │ │ └── GPUProfilerModule.cs
│ │ │ │ ├── GlobalIllumination/
│ │ │ │ │ └── GlobalIlluminationProfilerModule.cs
│ │ │ │ ├── LegacyDetailsViewController.cs
│ │ │ │ ├── Memory/
│ │ │ │ │ ├── MemoryElement.cs
│ │ │ │ │ ├── MemoryElementDataManager.cs
│ │ │ │ │ ├── MemoryProfilerModule.cs
│ │ │ │ │ ├── MemorySnapshot.cs
│ │ │ │ │ ├── MemoryTreeList.cs
│ │ │ │ │ ├── ObjectMemoryInfo.cs
│ │ │ │ │ └── ObjectMemoryStackInfo.cs
│ │ │ │ ├── PhysX/
│ │ │ │ │ └── PhysicsProfilerModule.cs
│ │ │ │ ├── ProfilerModule.cs
│ │ │ │ ├── ProfilerModuleBase.cs
│ │ │ │ ├── ProfilerModuleChartType.cs
│ │ │ │ ├── ProfilerModuleMetadataAttribute.cs
│ │ │ │ ├── ProfilerModuleViewController.cs
│ │ │ │ ├── Rendering/
│ │ │ │ │ └── RenderingProfilerModule.cs
│ │ │ │ ├── SampleSelection.cs
│ │ │ │ ├── StandardDetailsViewController.cs
│ │ │ │ ├── SwitchableLegacyDetailsViewController.cs
│ │ │ │ ├── Video/
│ │ │ │ │ └── VideoProfilerModule.cs
│ │ │ │ ├── VirtualTexturing/
│ │ │ │ │ ├── VirtualTexturingProfilerModule.cs
│ │ │ │ │ └── VirtualTexturingProfilerView.cs
│ │ │ │ └── uGui/
│ │ │ │ ├── UIDetailsProfilerModule.cs
│ │ │ │ ├── UIProfilerModule.cs
│ │ │ │ ├── UISystemProfiler.cs
│ │ │ │ ├── UISystemProfilerChart.cs
│ │ │ │ ├── UISystemProfilerThumbnailService.cs
│ │ │ │ └── UISystemProfilerTreeView.cs
│ │ │ ├── ProfilerModulesDropdownWindow.cs
│ │ │ ├── ProfilerWindow.cs
│ │ │ ├── UIElements/
│ │ │ │ ├── MemoryUsageBreakdown.cs
│ │ │ │ ├── MemoryUsageBreakdownElement.cs
│ │ │ │ └── SelectableLabel.cs
│ │ │ ├── Utilities/
│ │ │ │ └── UIUtility.cs
│ │ │ └── ViewControllerSystem/
│ │ │ ├── InvalidViewDefinedInUxmlException.cs
│ │ │ ├── ViewController.cs
│ │ │ └── ViewControllerUtility.cs
│ │ └── Public/
│ │ ├── FrameDataView.bindings.cs
│ │ ├── HierarchyFrameDataView.bindings.cs
│ │ ├── NativeProfilerTimeline.bindings.cs
│ │ ├── ProfilerAPI.bindings.cs
│ │ ├── ProfilerFrameDataIterator.bindings.cs
│ │ ├── ProfilerProperty.bindings.cs
│ │ ├── ProfilerSettings.cs
│ │ ├── ProfilerSettingsProvider.cs
│ │ ├── ProfilingSessionMetaData.bindings.cs
│ │ └── RawFrameDataView.bindings.cs
│ ├── Progress/
│ │ ├── ProgressWindow.cs
│ │ └── VisualProgressItem.cs
│ ├── Properties/
│ │ └── Runtime/
│ │ ├── Algorithms/
│ │ │ ├── PropertyContainer+Accept.cs
│ │ │ ├── PropertyContainer+GetProperty.cs
│ │ │ ├── PropertyContainer+GetValue.cs
│ │ │ ├── PropertyContainer+Path.cs
│ │ │ ├── PropertyContainer+SetValue.cs
│ │ │ ├── PropertyContainer.cs
│ │ │ └── VisitReturnCode.cs
│ │ ├── AssemblyInfo.cs
│ │ ├── Attributes.cs
│ │ ├── Exceptions.cs
│ │ ├── Properties/
│ │ │ ├── AttributesScope.cs
│ │ │ ├── DelegateProperty.cs
│ │ │ ├── ICollectionElementProperty.cs
│ │ │ ├── Internal/
│ │ │ │ └── IAttributes.cs
│ │ │ ├── Property.cs
│ │ │ ├── PropertyPath.cs
│ │ │ └── ReflectedMemberProperty.cs
│ │ ├── PropertyBags/
│ │ │ ├── ArrayPropertyBag.cs
│ │ │ ├── ContainerPropertyBag.cs
│ │ │ ├── DictionaryPropertyBag.cs
│ │ │ ├── HashSetPropertyBag.cs
│ │ │ ├── IPropertyBag.cs
│ │ │ ├── IndexedCollectionPropertyBag.cs
│ │ │ ├── Internal/
│ │ │ │ ├── PropertiesInitialization.cs
│ │ │ │ └── PropertyBagStore.cs
│ │ │ ├── KeyValueCollectionPropertyBag.cs
│ │ │ ├── KeyValuePairPropertyBag.cs
│ │ │ ├── ListPropertyBag.cs
│ │ │ ├── PropertyBag+Accept.cs
│ │ │ ├── PropertyBag+Registration.cs
│ │ │ ├── PropertyBag+TypeConstruction.cs
│ │ │ ├── PropertyBag.cs
│ │ │ ├── PropertyCollection.cs
│ │ │ └── SetPropertyBag.cs
│ │ ├── PropertyVisitors/
│ │ │ ├── Adapters/
│ │ │ │ ├── IExcludePropertyAdapter.cs
│ │ │ │ ├── IVisitPrimitivesPropertyAdapter.cs
│ │ │ │ └── IVisitPropertyAdapter.cs
│ │ │ ├── ConcreteTypeVisitor.cs
│ │ │ ├── ExcludeContext.cs
│ │ │ ├── IAccept.cs
│ │ │ ├── IVisitor.cs
│ │ │ ├── Internal/
│ │ │ │ └── ReadOnlyAdapterCollection.cs
│ │ │ ├── PathVisitor.cs
│ │ │ ├── PropertyVisitor.cs
│ │ │ └── VisitContext.cs
│ │ ├── Reflection/
│ │ │ └── Internal/
│ │ │ ├── ReflectedPropertyBag.cs
│ │ │ ├── ReflectedPropertyBagProvider.cs
│ │ │ └── ReflectionUtilities.cs
│ │ └── Utility/
│ │ ├── TypeConversion.cs
│ │ ├── TypeTraits.cs
│ │ └── TypeUtility.cs
│ ├── PropertiesEditor/
│ │ └── Module/
│ │ ├── AssemblyInfo.cs
│ │ └── PropertiesEditorInitialization.cs
│ ├── QuickSearch/
│ │ └── Editor/
│ │ ├── FuzzySearch.cs
│ │ ├── ISearchView.cs
│ │ ├── Indexing/
│ │ │ ├── AssetIndexer.cs
│ │ │ ├── CustomIndexers.cs
│ │ │ ├── IndexManager.cs
│ │ │ ├── IndexerExtensions.cs
│ │ │ ├── ObjectIndexer.cs
│ │ │ ├── SearchDatabase.cs
│ │ │ ├── SearchDatabaseException.cs
│ │ │ ├── SearchDatabaseImporter.cs
│ │ │ ├── SearchDocumentList.cs
│ │ │ ├── SearchDocumentListTable.cs
│ │ │ ├── SearchIndexComparer.cs
│ │ │ ├── SearchIndexEntryHeapEnumerator.cs
│ │ │ ├── SearchIndexEntryImporter.cs
│ │ │ ├── SearchIndexer.cs
│ │ │ ├── SearchIndexerQuery.cs
│ │ │ ├── SearchNativeList.cs
│ │ │ ├── SearchNativeReadOnlyArray.cs
│ │ │ ├── SearchResultCollection.cs
│ │ │ └── SearchTask.cs
│ │ ├── PropertyDatabase/
│ │ │ ├── DefaultPropertyDatabaseSerializers.cs
│ │ │ ├── PropertyDatabase.cs
│ │ │ ├── PropertyDatabaseRecord.cs
│ │ │ ├── PropertyDatabaseSerializer.cs
│ │ │ ├── PropertyDatabaseStore.cs
│ │ │ └── PropertyStringTable.cs
│ │ ├── Providers/
│ │ │ ├── AdbProvider.cs
│ │ │ ├── AssetProvider.cs
│ │ │ ├── AssetStoreProvider.cs
│ │ │ ├── BasePerformanceProvider.cs
│ │ │ ├── Calculator.cs
│ │ │ ├── FindProvider.cs
│ │ │ ├── LogProvider.cs
│ │ │ ├── MenuProvider.cs
│ │ │ ├── ObjectQueryEngine.cs
│ │ │ ├── PackageManagerProvider.cs
│ │ │ ├── PerformanceProvider.cs
│ │ │ ├── ProfilerMarkersProvider.cs
│ │ │ ├── SceneProvider.cs
│ │ │ ├── SceneQueryEngine.cs
│ │ │ ├── SearchServiceProvider.cs
│ │ │ ├── SettingsProvider.cs
│ │ │ └── StaticMethodProvider.cs
│ │ ├── QueryBuilder/
│ │ │ ├── Blocks/
│ │ │ │ ├── QueryAddNewBlock.cs
│ │ │ │ ├── QueryAreaBlock.cs
│ │ │ │ ├── QueryBlockEditor.cs
│ │ │ │ ├── QueryExpressionBlock.cs
│ │ │ │ ├── QueryFilterBlock.cs
│ │ │ │ ├── QueryListBlock.cs
│ │ │ │ ├── QueryListBlockAttribute.cs
│ │ │ │ ├── QueryTextFieldBlock.cs
│ │ │ │ └── QueryWordBlock.cs
│ │ │ ├── IBlockEditor.cs
│ │ │ ├── IQuerySource.cs
│ │ │ ├── QueryBlock.cs
│ │ │ ├── QueryBuilder.cs
│ │ │ ├── QueryBuilderHelpers.cs
│ │ │ ├── QueryEnginePropositionsExtensions.cs
│ │ │ ├── QueryMarker.cs
│ │ │ └── QuerySelector.cs
│ │ ├── QueryEngine/
│ │ │ ├── AggregateEnumerable.cs
│ │ │ ├── DefaultNestedQueryAggregators.cs
│ │ │ ├── DefaultQueryFilterHandlers.cs
│ │ │ ├── DefaultQueryHandler.cs
│ │ │ ├── EnumerableCreator.cs
│ │ │ ├── IInstruction.cs
│ │ │ ├── IntersectionEnumerable.cs
│ │ │ ├── NestedQueryEnumerable.cs
│ │ │ ├── NestedQueryHandler.cs
│ │ │ ├── ParsedQuery.cs
│ │ │ ├── Query.Deprecated.cs
│ │ │ ├── QueryEngine.Deprecated.cs
│ │ │ ├── QueryEngine.cs
│ │ │ ├── QueryEngineAttributes.cs
│ │ │ ├── QueryEngineUtils.cs
│ │ │ ├── QueryError.cs
│ │ │ ├── QueryFilterOperations.cs
│ │ │ ├── QueryFilterOperators.cs
│ │ │ ├── QueryFilters.cs
│ │ │ ├── QueryGraph.cs
│ │ │ ├── QueryNodes.cs
│ │ │ ├── QueryToggle.cs
│ │ │ ├── QueryToken.cs
│ │ │ ├── QueryTokenizer.cs
│ │ │ ├── UnionEnumerable.cs
│ │ │ └── WhereEnumerable.cs
│ │ ├── SearchAction.cs
│ │ ├── SearchAnalytics.cs
│ │ ├── SearchContext.cs
│ │ ├── SearchEngines/
│ │ │ ├── AdvancedObjectSelector.cs
│ │ │ ├── DefaultAdvancedObjectSelector.cs
│ │ │ └── SearchEngines.cs
│ │ ├── SearchEnumerator.cs
│ │ ├── SearchExpression/
│ │ │ ├── Evaluators/
│ │ │ │ ├── AggregateEvaluator.cs
│ │ │ │ ├── AliasEvaluators.cs
│ │ │ │ ├── CompareEvaluators.cs
│ │ │ │ ├── ContextEvaluators.cs
│ │ │ │ ├── ControlFlowEvaluators.cs
│ │ │ │ ├── ConverterEvaluators.cs
│ │ │ │ ├── EnvarEvaluators.cs
│ │ │ │ ├── ExceptEvaluator.cs
│ │ │ │ ├── GroupByEvaluator.cs
│ │ │ │ ├── IntersectEvaluator.cs
│ │ │ │ ├── MapEvaluator.cs
│ │ │ │ ├── MathEvaluators.cs
│ │ │ │ ├── PrimitiveEvaluators.cs
│ │ │ │ ├── PrintEvaluator.cs
│ │ │ │ ├── QueryEvaluator.cs
│ │ │ │ ├── RandomEvaluator.cs
│ │ │ │ ├── SelectEvaluator.cs
│ │ │ │ ├── SortEvaluator.cs
│ │ │ │ └── UnionEvaluator.cs
│ │ │ ├── Parsers/
│ │ │ │ ├── AliasExpressionParser.cs
│ │ │ │ ├── ConstantExpressionParser.cs
│ │ │ │ ├── ExpandExpressionParser.cs
│ │ │ │ ├── NamedExpressionParser.cs
│ │ │ │ ├── QueryExpressionParser.cs
│ │ │ │ ├── SelectorExpressionParser.cs
│ │ │ │ └── SetExpressionParser.cs
│ │ │ ├── ReflectionUtils.cs
│ │ │ ├── ResultIterators.cs
│ │ │ ├── SearchExpression.cs
│ │ │ ├── SearchExpressionContext.cs
│ │ │ ├── SearchExpressionEvaluator.cs
│ │ │ ├── SearchExpressionParser.cs
│ │ │ ├── SearchExpressionRuntime.cs
│ │ │ ├── SearchExpressionValidator.cs
│ │ │ ├── SearchItemQueryEngine.cs
│ │ │ └── TaskEvaluatorManager.cs
│ │ ├── SearchFilterEnumTypes.cs
│ │ ├── SearchFlags.cs
│ │ ├── SearchItem.cs
│ │ ├── SearchList.cs
│ │ ├── SearchMonitor.cs
│ │ ├── SearchPreviewManager.cs
│ │ ├── SearchProvider.cs
│ │ ├── SearchQuery/
│ │ │ ├── SearchQuery.cs
│ │ │ ├── SearchQueryAsset.cs
│ │ │ ├── SearchQueryEditor.cs
│ │ │ └── SearchTemplateAttribute.cs
│ │ ├── SearchQueryError.cs
│ │ ├── SearchSelection.cs
│ │ ├── SearchService.cs
│ │ ├── SearchSession.cs
│ │ ├── SearchSettings.cs
│ │ ├── SearchUtils.cs
│ │ ├── Selectors/
│ │ │ ├── AssetSelectors.cs
│ │ │ ├── ItemSelectors.cs
│ │ │ ├── MaterialSelectors.cs
│ │ │ ├── PropertySelectors.cs
│ │ │ ├── SceneSelectors.cs
│ │ │ ├── SearchColumn.cs
│ │ │ └── SearchSelector.cs
│ │ ├── Table/
│ │ │ ├── ColumnEditor.cs
│ │ │ ├── ColumnSelector.cs
│ │ │ ├── ITableView.cs
│ │ │ ├── SearchReport.cs
│ │ │ └── SearchTable.cs
│ │ ├── Transactions/
│ │ │ ├── TimeRange.cs
│ │ │ ├── Transaction.cs
│ │ │ ├── TransactionManager.cs
│ │ │ ├── TransactionUtils.cs
│ │ │ └── TransactionViewer.cs
│ │ ├── UI/
│ │ │ ├── Dispatcher.cs
│ │ │ ├── IResultView.cs
│ │ │ ├── Icons.cs
│ │ │ ├── ObjectField.cs
│ │ │ ├── SearchContextPropertyDrawer.cs
│ │ │ ├── SearchEventManager.cs
│ │ │ ├── SearchPickerWindow.cs
│ │ │ ├── SearchProposition.cs
│ │ │ ├── SearchViewState.cs
│ │ │ └── UndoManager.cs
│ │ ├── UITK/
│ │ │ ├── GridView.cs
│ │ │ ├── ISearchPanel.cs
│ │ │ ├── RenamableLabel.cs
│ │ │ ├── SearchAutoCompleteWindow.cs
│ │ │ ├── SearchBaseCollectionView.cs
│ │ │ ├── SearchDetailView.cs
│ │ │ ├── SearchElement.cs
│ │ │ ├── SearchEmptyView.cs
│ │ │ ├── SearchField.cs
│ │ │ ├── SearchGlobalEventHandlerManager.cs
│ │ │ ├── SearchGridView.cs
│ │ │ ├── SearchGroupBar.cs
│ │ │ ├── SearchItemEditorElement.cs
│ │ │ ├── SearchListView.cs
│ │ │ ├── SearchQueryBuilderView.cs
│ │ │ ├── SearchQueryListView.cs
│ │ │ ├── SearchQueryPanelView.cs
│ │ │ ├── SearchStatusBar.cs
│ │ │ ├── SearchTableView.cs
│ │ │ ├── SearchTableViewCell.cs
│ │ │ ├── SearchTableViewColumn.cs
│ │ │ ├── SearchTableViewColumnSorter.cs
│ │ │ ├── SearchToolbar.cs
│ │ │ ├── SearchView.cs
│ │ │ ├── SearchViewItem.cs
│ │ │ └── SearchWindow.cs
│ │ └── Utilities/
│ │ ├── BinarySearchFinder.cs
│ │ ├── DebugTimer.cs
│ │ ├── HashingUtils.cs
│ │ ├── IStringView.cs
│ │ ├── RaceConditionDetector.cs
│ │ ├── RetriableOperation.cs
│ │ ├── SearchDisposableTracker.cs
│ │ ├── StringView.cs
│ │ ├── SubsetStringView.cs
│ │ ├── TryConvert.cs
│ │ └── Utils.cs
│ ├── SafeMode/
│ │ └── SafeModeToolbarWindow.cs
│ ├── SceneTemplateEditor/
│ │ ├── DependencyListView.cs
│ │ ├── GridView.cs
│ │ ├── ListSelectionWindow.cs
│ │ ├── ReferenceUtils.cs
│ │ ├── ScenePicker.cs
│ │ ├── SceneTemplateAnalytics.cs
│ │ ├── SceneTemplateAsset.cs
│ │ ├── SceneTemplateAssetInspectorWindow.cs
│ │ ├── SceneTemplateDialog.cs
│ │ ├── SceneTemplatePipeline.cs
│ │ ├── SceneTemplatePreferences.cs
│ │ ├── SceneTemplatePreviewArea.cs
│ │ ├── SceneTemplateProjectSettings.cs
│ │ ├── SceneTemplateService.cs
│ │ ├── SceneTemplateUtils.cs
│ │ ├── SnapshotUtils.cs
│ │ ├── Styles.cs
│ │ └── VisualSplitter.cs
│ ├── SceneView/
│ │ ├── CameraOverlay.cs
│ │ ├── DropdownToggle.cs
│ │ ├── SceneViewLightingOverlays.cs
│ │ └── SceneViewToolbarElements.cs
│ ├── ScreenCapture/
│ │ └── ScriptBindings/
│ │ └── ScreenCapture.bindings.cs
│ ├── ShaderFoundry/
│ │ └── ScriptBindings/
│ │ ├── AssemblyInfo.cs
│ │ ├── Block.bindings.cs
│ │ ├── BlockConstructorGenerator.bindings.cs
│ │ ├── BlockLinkOverride.bindings.cs
│ │ ├── BlockLinker.bindings.cs
│ │ ├── BlockSequenceElement.bindings.cs
│ │ ├── BlockShader.bindings.cs
│ │ ├── BlockShaderInterface.bindings.cs
│ │ ├── BlockVariable.bindings.cs
│ │ ├── CopyRule.bindings.cs
│ │ ├── CustomizationPoint.bindings.cs
│ │ ├── CustomizationPointImplementation.bindings.cs
│ │ ├── DataType.bindings.cs
│ │ ├── DataTypeStatic.cs
│ │ ├── DefaultContainer.cs
│ │ ├── DefineDescriptor.bindings.cs
│ │ ├── EqualityChecks.cs
│ │ ├── FoundryAPIAttribute.cs
│ │ ├── FoundryHandle.bindings.cs
│ │ ├── FunctionParameter.bindings.cs
│ │ ├── HandleList.bindings.cs
│ │ ├── ITemplateGenerator.cs
│ │ ├── ITemplateLinker.cs
│ │ ├── IncludeDescriptor.bindings.cs
│ │ ├── InterfaceRegistrationStatement.bindings.cs
│ │ ├── InternalType.cs
│ │ ├── KeywordDescriptor.bindings.cs
│ │ ├── Namespace.bindings.cs
│ │ ├── PackageRequirement.bindings.cs
│ │ ├── PassStageType.bindings.cs
│ │ ├── PragmaDescriptor.bindings.cs
│ │ ├── PublicType.cs
│ │ ├── RegisterTemplatesWithInterface.bindings.cs
│ │ ├── RenderStateDescriptor.bindings.cs
│ │ ├── ShaderAttribute.bindings.cs
│ │ ├── ShaderAttributeParameter.bindings.cs
│ │ ├── ShaderBuilder.cs
│ │ ├── ShaderContainer.bindings.cs
│ │ ├── ShaderCustomEditor.bindings.cs
│ │ ├── ShaderDependency.bindings.cs
│ │ ├── ShaderFunction.bindings.cs
│ │ ├── ShaderType.bindings.cs
│ │ ├── StageDescription.bindings.cs
│ │ ├── StructField.bindings.cs
│ │ ├── TagDescriptor.bindings.cs
│ │ ├── Template.bindings.cs
│ │ ├── TemplateInstance.bindings.cs
│ │ ├── TemplatePass.bindings.cs
│ │ └── Utilities.cs
│ ├── SharedInternals/
│ │ ├── Attributes.cs
│ │ ├── BindingsAttributes.cs
│ │ └── UnityString.cs
│ ├── ShortcutManager/
│ │ └── ShortcutManagerWindowView.cs
│ ├── ShortcutManagerEditor/
│ │ ├── BindingValidator.cs
│ │ ├── ConflictResolver.cs
│ │ ├── ConflictResolverWindow.cs
│ │ ├── ContextManager.cs
│ │ ├── DeleteShortcutProfileWindow.cs
│ │ ├── Directory.cs
│ │ ├── Discovery.cs
│ │ ├── DiscoveryInvalidShortcutReporter.cs
│ │ ├── FormerlyPrefKeyAsAttribute.cs
│ │ ├── IConflictResolver.cs
│ │ ├── IDirectory.cs
│ │ ├── IDiscovery.cs
│ │ ├── IShortcutContext.cs
│ │ ├── KeyCombination.cs
│ │ ├── PriorityContextAttribute.cs
│ │ ├── PromptWindow.cs
│ │ ├── ReserveModifiersAttribute.cs
│ │ ├── ShortcutAttribute.cs
│ │ ├── ShortcutAttributeDiscoveryProvider.cs
│ │ ├── ShortcutBinding.cs
│ │ ├── ShortcutController.cs
│ │ ├── ShortcutEntry.cs
│ │ ├── ShortcutHelperBar.cs
│ │ ├── ShortcutHelperBarUtility.cs
│ │ ├── ShortcutManager.cs
│ │ ├── ShortcutManagerWindow.cs
│ │ ├── ShortcutManagerWindowViewController.cs
│ │ ├── ShortcutProfile.cs
│ │ ├── ShortcutProfileManager.cs
│ │ ├── ShortcutProfileStore.cs
│ │ └── Trigger.cs
│ ├── SketchUpEditor/
│ │ └── Mono/
│ │ ├── SketchUp.bindings.cs
│ │ ├── SketchUpImportDlg.cs
│ │ ├── SketchUpImporterEditor.cs
│ │ └── SketchUpImporterModelEditor.cs
│ ├── SpriteMask/
│ │ └── Public/
│ │ └── ScriptBindings/
│ │ └── SpriteMask.bindings.cs
│ ├── SpriteMaskEditor/
│ │ └── Editor/
│ │ └── Managed/
│ │ └── SpriteMaskEditor.cs
│ ├── SpriteShape/
│ │ └── Public/
│ │ └── ScriptBindings/
│ │ ├── SpriteShapeRenderer.bindings.cs
│ │ └── SpriteShapeUtility.bindings.cs
│ ├── SpriteShapeEditor/
│ │ └── Managed/
│ │ └── SpriteShapeRendererEditor.cs
│ ├── Streaming/
│ │ └── ScriptBindings/
│ │ └── StreamingController.bindings.cs
│ ├── StyleSheetsEditor/
│ │ ├── Converters/
│ │ │ ├── ConverterUtils.cs
│ │ │ ├── GUISkinCompare.cs
│ │ │ ├── GUISkinToStyleSheet.cs
│ │ │ ├── GUIStyleExtensions.cs
│ │ │ ├── Graph.cs
│ │ │ ├── StyleCatalogToSkin.cs
│ │ │ ├── StyleSheetBuilderHelper.cs
│ │ │ ├── StyleSheetCache.cs
│ │ │ ├── StyleSheetResolver.cs
│ │ │ ├── StyleSheetSplitter.cs
│ │ │ └── StyleSheetToUss.cs
│ │ ├── StyleCatalog.cs
│ │ └── StylePainter.cs
│ ├── Substance/
│ │ ├── SubstanceUtility.bindings.cs
│ │ └── SubstanceUtility.cs
│ ├── Subsystems/
│ │ ├── Example/
│ │ │ ├── ExampleSubsystem.bindings.cs
│ │ │ └── ExampleSubsystemDescriptor.bindings.cs
│ │ ├── ISubsystem.cs
│ │ ├── ISubsystemDescriptor.cs
│ │ ├── IntegratedSubsystem.bindings.cs
│ │ ├── IntegratedSubsystem.deprecated.cs
│ │ ├── IntegratedSubsystemDescriptor.bindings.cs
│ │ ├── Subsystem.deprecated.cs
│ │ ├── SubsystemDescriptor.deprecated.cs
│ │ ├── SubsystemDescriptorStore.bindings.cs
│ │ ├── SubsystemDescriptorStore.cs
│ │ ├── SubsystemDescriptorStore.deprecated.cs
│ │ ├── SubsystemDescriptorWithProvider.cs
│ │ ├── SubsystemManager.bindings.cs
│ │ ├── SubsystemManager.cs
│ │ ├── SubsystemManager.deprecated.cs
│ │ ├── SubsystemProvider.cs
│ │ ├── SubsystemProxy.cs
│ │ └── SubsystemWithProvider.cs
│ ├── Terrain/
│ │ └── Public/
│ │ ├── BrushTransform.cs
│ │ ├── PaintContext.cs
│ │ ├── SpeedTreeWind.bindings.cs
│ │ ├── Terrain.bindings.cs
│ │ ├── Terrain.deprecated.cs
│ │ ├── TerrainCallbacks.cs
│ │ ├── TerrainData.GPUCopy.cs
│ │ ├── TerrainData.bindings.cs
│ │ ├── TerrainLayer.bindings.cs
│ │ ├── TerrainPaintUtility.cs
│ │ └── TerrainUtility.cs
│ ├── TerrainEditor/
│ │ ├── AssemblyInfo.cs
│ │ ├── Brush/
│ │ │ ├── Brush.cs
│ │ │ ├── BrushEditor.cs
│ │ │ └── BrushList.cs
│ │ ├── HeightmapFilters.cs
│ │ ├── Overlays/
│ │ │ ├── BrushAttributes.cs
│ │ │ ├── BrushesOverlay.cs
│ │ │ ├── CondensedSlider.cs
│ │ │ ├── TerrainTransientToolbarOverlay.cs
│ │ │ └── ToolEditors.cs
│ │ ├── PaintTools/
│ │ │ ├── CreateTerrainTool.cs
│ │ │ ├── PaintDetailsTool.cs
│ │ │ ├── PaintDetailsToolUtility.cs
│ │ │ ├── PaintHeightTool.cs
│ │ │ ├── PaintHolesTool.cs
│ │ │ ├── PaintTextureTool.cs
│ │ │ ├── PaintTreesTool.cs
│ │ │ ├── SetHeightTool.cs
│ │ │ ├── SmoothHeightTool.cs
│ │ │ ├── StampTool.cs
│ │ │ ├── TerrainPaintTool.cs
│ │ │ └── TerrainPaintToolUtility.cs
│ │ ├── TerrainInspector.cs
│ │ ├── TerrainWizards.cs
│ │ ├── TreeAOImporter.cs
│ │ └── Utilities/
│ │ ├── TerrainEditorUtility.cs
│ │ ├── TerrainLayerInspector.cs
│ │ ├── TerrainLayerUtility.cs
│ │ ├── TerrainMenus.cs
│ │ └── TerrainPaintUtilityEditor.cs
│ ├── TerrainPhysics/
│ │ └── TerrainPhysics.bindings.cs
│ ├── TextCoreFontEngine/
│ │ └── Managed/
│ │ ├── AssemblyInfo.cs
│ │ ├── FaceInfo.cs
│ │ ├── FontEngine.bindings.cs
│ │ ├── FontEngineMarshallingCommon.cs
│ │ ├── FontFeatureCommon.cs
│ │ ├── FontFeatureCommonGPOS.cs
│ │ ├── FontFeatureCommonGSUB.cs
│ │ └── Glyph.cs
│ ├── TextCoreFontEngineEditor/
│ │ └── Managed/
│ │ ├── AssemblyInfo.cs
│ │ └── FontEngineEditor.bindings.cs
│ ├── TextCoreTextEngine/
│ │ └── Managed/
│ │ ├── ATGMeshInfo.cs
│ │ ├── AssemblyInfo.cs
│ │ ├── Character.cs
│ │ ├── ColorUtilities.cs
│ │ ├── FastAction.cs
│ │ ├── FontFeatureCommon.cs
│ │ ├── FontFeatureTable.cs
│ │ ├── LineInfo.cs
│ │ ├── LinkInfo.cs
│ │ ├── MaterialManager.cs
│ │ ├── MaterialReference.cs
│ │ ├── MaterialReferenceManager.cs
│ │ ├── MeshInfo.bindings.cs
│ │ ├── MeshInfo.cs
│ │ ├── NativeTextElementInfo.cs
│ │ ├── NativeTextInfo.cs
│ │ ├── TextAssets/
│ │ │ ├── FontAsset/
│ │ │ │ ├── FontAssetAtlasPopulation.cs
│ │ │ │ ├── FontAssetFactory.cs
│ │ │ │ ├── FontAssetFontFeatures.cs
│ │ │ │ └── NativeFontAsset.cs
│ │ │ ├── FontAsset.cs
│ │ │ ├── FontAssetUtilities.cs
│ │ │ ├── SpriteAsset.cs
│ │ │ ├── SpriteCharacter.cs
│ │ │ ├── SpriteGlyph.cs
│ │ │ ├── TextAsset.cs
│ │ │ ├── TextColorGradient.cs
│ │ │ ├── TextSettings.cs
│ │ │ ├── TextStyle.cs
│ │ │ └── TextStyleSheet.cs
│ │ ├── TextCoreVertex.bindings.cs
│ │ ├── TextElement.cs
│ │ ├── TextElementInfo.cs
│ │ ├── TextEventManager.cs
│ │ ├── TextGenerator/
│ │ │ ├── NativeTextGenerationSettings.bindings.cs
│ │ │ ├── RichTextTagParser.cs
│ │ │ ├── TextGenerationSettings.cs
│ │ │ ├── TextGeneratorCommon.cs
│ │ │ ├── TextGeneratorHtmlTagValidation.cs
│ │ │ ├── TextGeneratorInternal.cs
│ │ │ ├── TextGeneratorLayout.cs
│ │ │ ├── TextGeneratorParsing.cs
│ │ │ ├── TextGeneratorPreferredValues.cs
│ │ │ ├── TextGeneratorPrepare.cs
│ │ │ ├── TextGeneratorUtilities.cs
│ │ │ ├── TextLib.bindings.cs
│ │ │ └── TextSelectionService.bindings.cs
│ │ ├── TextGenerator.cs
│ │ ├── TextHandle.cs
│ │ ├── TextHandlePermanentCache.cs
│ │ ├── TextHandleTemporaryCache.cs
│ │ ├── TextInfo.cs
│ │ ├── TextMarkupTagsCommon.cs
│ │ ├── TextProcessingCommon.cs
│ │ ├── TextProcessingStacks.cs
│ │ ├── TextResourcesManager.cs
│ │ ├── TextShaderUtilities.cs
│ │ ├── TextUtilities.cs
│ │ └── UnicodeLineBreakingRules.cs
│ ├── TextCoreTextEngineEditor/
│ │ └── Managed/
│ │ ├── AssemblyInfo.cs
│ │ ├── EditorShaderUtilities.cs
│ │ ├── FontAssetCreationMenu.cs
│ │ ├── FontAssetCreatorWindow.cs
│ │ ├── FontAssetEditor.cs
│ │ ├── FontAssetEditorUtilities.cs
│ │ ├── ICUDataAssetUtilities.cs
│ │ ├── PropertyDrawers/
│ │ │ ├── CharacterPropertyDrawer.cs
│ │ │ ├── GlyphMetricsPropertyDrawer.cs
│ │ │ ├── GlyphPairAdjustmentRecordPropertyDrawer.cs
│ │ │ ├── GlyphPropertyDrawer.cs
│ │ │ ├── GlyphRectPropertyDrawer.cs
│ │ │ ├── LigatureSubstitutionRecordPropertyDrawer.cs
│ │ │ ├── MarkToBaseAdjustmentRecordPropertyDrawer.cs
│ │ │ ├── MarkToMarkAdjustmentRecordPropertyDrawer.cs
│ │ │ ├── SpriteCharacterPropertyDrawer.cs
│ │ │ ├── SpriteGlyphPropertyDrawer.cs
│ │ │ ├── TextCorePropertyDrawerUtilities.cs
│ │ │ └── UnicodeLineBreakingRulesPropertyDrawer.cs
│ │ ├── SerializedPropertyHolder.cs
│ │ ├── SpriteAssetCreationMenu.cs
│ │ ├── SpriteAssetImportFormats.cs
│ │ ├── SpriteAssetImporter.cs
│ │ ├── TextAssetPostProcessor.cs
│ │ ├── TextColorGradientAssetCreationMenu.cs
│ │ ├── TextColorGradientEditor.cs
│ │ ├── TextCoreContextMenuItems.cs
│ │ ├── TextCoreEditorUtilities.cs
│ │ ├── TextCorePreBuildProcessor.cs
│ │ ├── TextCoreShaderGUI.cs
│ │ ├── TextCoreShaderGUIBitmap.cs
│ │ ├── TextCoreShaderGUISDF.cs
│ │ ├── TextEditorResourceManager.cs
│ │ ├── TextSettingsCreationMenu.cs
│ │ ├── TextSettingsEditor.cs
│ │ ├── TextSpriteAssetEditor.cs
│ │ ├── TextStyleAssetCreationMenu.cs
│ │ └── TextStyleSheetEditor.cs
│ ├── TextRendering/
│ │ ├── FontStyle.cs
│ │ ├── GUIText.deprecated.cs
│ │ ├── TextGenerator.cs
│ │ └── TextRendering.bindings.cs
│ ├── TextRenderingEditor/
│ │ ├── TextRenderingCommands.cs
│ │ ├── TrueTypeFontImporter.bindings.cs
│ │ └── TrueTypeFontImporterInspector.cs
│ ├── Tilemap/
│ │ ├── Managed/
│ │ │ ├── CustomGridBrushAttribute.cs
│ │ │ ├── GridBrushBase.cs
│ │ │ ├── ITilemap.cs
│ │ │ ├── Tile.cs
│ │ │ ├── TileBase.cs
│ │ │ └── Tilemap.cs
│ │ └── ScriptBindings/
│ │ └── Tilemap.bindings.cs
│ ├── TilemapEditor/
│ │ └── Editor/
│ │ └── Managed/
│ │ ├── EditorPreviewTilemap.cs
│ │ ├── Grid/
│ │ │ └── GridPalette.cs
│ │ ├── TileBaseEditor.cs
│ │ ├── TileEditor.cs
│ │ ├── TilemapCollider2DEditor.cs
│ │ ├── TilemapEditor.cs
│ │ └── TilemapRendererEditor.cs
│ ├── TreeEditor/
│ │ ├── Includes/
│ │ │ ├── Perlin.cs
│ │ │ ├── RingLoop.cs
│ │ │ ├── SplineNode.cs
│ │ │ ├── TextureAtlas.cs
│ │ │ ├── TreeAOSphere.cs
│ │ │ ├── TreeAttribute.cs
│ │ │ ├── TreeGroup.cs
│ │ │ ├── TreeGroupBranch.cs
│ │ │ ├── TreeGroupLeaf.cs
│ │ │ ├── TreeGroupRoot.cs
│ │ │ ├── TreeMaterial.cs
│ │ │ ├── TreeNode.cs
│ │ │ ├── TreeSpline.cs
│ │ │ ├── TreeTriangle.cs
│ │ │ └── TreeVertex.cs
│ │ ├── TreeData.cs
│ │ ├── TreeEditor.cs
│ │ └── TreeEditorHelper.cs
│ ├── UI/
│ │ └── ScriptBindings/
│ │ ├── CanvasGroup.bindings.cs
│ │ ├── CanvasRenderer.bindings.cs
│ │ ├── RectTransformUtil.bindings.cs
│ │ ├── RectTransformUtility.cs
│ │ └── UICanvas.bindings.cs
│ ├── UIAutomationEditor/
│ │ ├── AutomatedWindow.cs
│ │ ├── ClickOverTime.cs
│ │ ├── DragOverTime.cs
│ │ ├── EventUtility.cs
│ │ ├── FakeCursor.cs
│ │ ├── KeyInputOverTime.cs
│ │ └── TestEditorWindow.cs
│ ├── UIBuilder/
│ │ └── Editor/
│ │ ├── Builder/
│ │ │ ├── Builder.cs
│ │ │ ├── BuilderBindingsCache.cs
│ │ │ ├── BuilderEditorInitialization.cs
│ │ │ ├── BuilderExternalPackages.cs
│ │ │ ├── BuilderPane.cs
│ │ │ ├── BuilderPaneContent.cs
│ │ │ ├── BuilderPaneWindow.cs
│ │ │ ├── BuilderSelection.cs
│ │ │ ├── Controllers/
│ │ │ │ └── UxmlBatchedChangesController.cs
│ │ │ ├── Document/
│ │ │ │ ├── BuilderDocument.cs
│ │ │ │ ├── BuilderDocumentOpenUSS.cs
│ │ │ │ ├── BuilderDocumentOpenUXML.cs
│ │ │ │ ├── BuilderDocumentSettings.cs
│ │ │ │ └── BuilderUXMLFileSettings.cs
│ │ │ ├── Draggers/
│ │ │ │ ├── BuilderClassDragger.cs
│ │ │ │ ├── BuilderDragger.cs
│ │ │ │ ├── BuilderExplorerDragger.cs
│ │ │ │ ├── BuilderHierarchyDragger.cs
│ │ │ │ ├── BuilderLibraryDragger.cs
│ │ │ │ ├── BuilderStyleSheetsDragger.cs
│ │ │ │ └── BuilderViewportDragger.cs
│ │ │ ├── Explorer/
│ │ │ │ ├── BuilderExplorer.cs
│ │ │ │ ├── BuilderExplorerItem.cs
│ │ │ │ ├── BuilderHierarchy.cs
│ │ │ │ ├── BuilderHierarchyUtilities.cs
│ │ │ │ ├── BuilderHierarchyWindow.cs
│ │ │ │ ├── BuilderNewSelectorField.cs
│ │ │ │ ├── BuilderStyleSheets.cs
│ │ │ │ ├── BuilderStyleSheetsContextMenu.cs
│ │ │ │ ├── BuilderStyleSheetsUtilities.cs
│ │ │ │ └── BuilderStyleSheetsWindow.cs
│ │ │ ├── Inspector/
│ │ │ │ ├── Binding/
│ │ │ │ │ ├── BindingCompatibilityStatus.cs
│ │ │ │ │ ├── BindingConverterGroupDetailsView.cs
│ │ │ │ │ ├── BindingConverterGroupViewItem.cs
│ │ │ │ │ ├── BindingConvertersField.cs
│ │ │ │ │ ├── BuilderBindingPropertyDrawers.cs
│ │ │ │ │ ├── BuilderBindingUtility.cs
│ │ │ │ │ ├── BuilderBindingUxmlAtttributesView.cs
│ │ │ │ │ ├── BuilderBindingView.cs
│ │ │ │ │ ├── BuilderBindingWindow.cs
│ │ │ │ │ ├── BuilderDataSourceAndPathView.cs
│ │ │ │ │ ├── BuilderDataSourcePathCompleter.cs
│ │ │ │ │ ├── BuilderPropertyPathInfoDetailsView.cs
│ │ │ │ │ ├── BuilderPropertyPathInfoViewItem.cs
│ │ │ │ │ └── ShowOnlyCompatibleResultsToggle.cs
│ │ │ │ ├── BuilderInspector.cs
│ │ │ │ ├── BuilderInspectorAttributes.cs
│ │ │ │ ├── BuilderInspectorCanvas.cs
│ │ │ │ ├── BuilderInspectorHeader.cs
│ │ │ │ ├── BuilderInspectorInheritedStyles.cs
│ │ │ │ ├── BuilderInspectorLocalStyles.cs
│ │ │ │ ├── BuilderInspectorMatchingSelectors.cs
│ │ │ │ ├── BuilderInspectorPreview.cs
│ │ │ │ ├── BuilderInspectorPreviewWindow.cs
│ │ │ │ ├── BuilderInspectorStyleFields+Transitions.cs
│ │ │ │ ├── BuilderInspectorStyleFields.cs
│ │ │ │ ├── BuilderInspectorStyleSheet.cs
│ │ │ │ ├── BuilderInspectorVariables.cs
│ │ │ │ ├── BuilderInspectorVariablesListItem.cs
│ │ │ │ ├── BuilderInspectorWindow.cs
│ │ │ │ ├── BuilderNewClassWindow.cs
│ │ │ │ ├── BuilderStyleRow.cs
│ │ │ │ ├── BuilderStyleSheetsNewSelectorHelpTips.cs
│ │ │ │ └── IBuilderInspectorSection.cs
│ │ │ ├── Library/
│ │ │ │ ├── BuilderLibrary.cs
│ │ │ │ ├── BuilderLibraryContent.cs
│ │ │ │ ├── BuilderLibraryPlainView.cs
│ │ │ │ ├── BuilderLibraryProjectScanner.cs
│ │ │ │ ├── BuilderLibraryTreeItem.cs
│ │ │ │ ├── BuilderLibraryTreeView.cs
│ │ │ │ ├── BuilderLibraryView.cs
│ │ │ │ └── BuilderLibraryWindow.cs
│ │ │ ├── Manipulators/
│ │ │ │ ├── BuilderAnchorer.cs
│ │ │ │ ├── BuilderManipulator.cs
│ │ │ │ ├── BuilderMover.cs
│ │ │ │ ├── BuilderParentTracker.cs
│ │ │ │ ├── BuilderPlacementIndicator.cs
│ │ │ │ ├── BuilderResizer.cs
│ │ │ │ ├── BuilderSelectionIndicator.cs
│ │ │ │ ├── BuilderTracker.cs
│ │ │ │ └── BuilderTransformer.cs
│ │ │ ├── Previews/
│ │ │ │ ├── BuilderCodePreview.cs
│ │ │ │ ├── BuilderPreviewWindow.cs
│ │ │ │ ├── BuilderTooltipPreview.cs
│ │ │ │ ├── BuilderUssPreview.cs
│ │ │ │ ├── BuilderUssPreviewWindow.cs
│ │ │ │ ├── BuilderUxmlPreview.cs
│ │ │ │ └── BuilderUxmlPreviewWindow.cs
│ │ │ ├── Toolbar/
│ │ │ │ └── BuilderToolbar.cs
│ │ │ ├── Utilities/
│ │ │ │ ├── BuilderAnalyticsUtility.cs
│ │ │ │ ├── BuilderAssetModificationProcessor.cs
│ │ │ │ ├── BuilderAssetPostprocessor.cs
│ │ │ │ ├── BuilderAssetUtilities.cs
│ │ │ │ ├── BuilderCommandHandler.cs
│ │ │ │ ├── BuilderConstants.cs
│ │ │ │ ├── BuilderDialogsUtility.cs
│ │ │ │ ├── BuilderEditorUtility.cs
│ │ │ │ ├── BuilderElementContextMenu.cs
│ │ │ │ ├── BuilderInspectorUtilities.cs
│ │ │ │ ├── BuilderNameUtilities.cs
│ │ │ │ ├── BuilderPackageUtilities.cs
│ │ │ │ ├── BuilderPlacementUtilities.cs
│ │ │ │ ├── BuilderProjectSettings.cs
│ │ │ │ ├── BuilderSharedStyles.cs
│ │ │ │ └── BuilderStyleUtilities.cs
│ │ │ ├── UxmlAttributesView/
│ │ │ │ ├── BuilderUxmlAttributesView.cs
│ │ │ │ ├── Fields/
│ │ │ │ │ ├── BuilderTypeField.cs
│ │ │ │ │ ├── BuilderUxmlAssetAttributeField.cs
│ │ │ │ │ ├── BuilderUxmlAttributeFieldFactory.cs
│ │ │ │ │ ├── BuilderUxmlAttributeFieldFactoryRegistry.cs
│ │ │ │ │ ├── BuilderUxmlEnumAttributeField.cs
│ │ │ │ │ ├── BuilderUxmlImageAttributeField.cs
│ │ │ │ │ ├── BuilderUxmlIntAttributeField.cs
│ │ │ │ │ ├── BuilderUxmlStringAttributeField.cs
│ │ │ │ │ ├── BuilderUxmlTypeAttributeField.cs
│ │ │ │ │ └── UxmlAttributeFieldPropertyDrawers.cs
│ │ │ │ └── IBatchedUxmlChangesListener.cs
│ │ │ └── Viewport/
│ │ │ ├── BuilderCanvas.cs
│ │ │ ├── BuilderCanvasStyleControls.cs
│ │ │ ├── BuilderInPlaceTextEditingUtilities.cs
│ │ │ ├── BuilderNotifications.cs
│ │ │ ├── BuilderPanner.cs
│ │ │ ├── BuilderViewport.cs
│ │ │ ├── BuilderViewportWindow.cs
│ │ │ ├── BuilderVisualTreeStyleUpdaterTraversal.cs
│ │ │ ├── BuilderZoomer.cs
│ │ │ └── IBuilderViewportWindow.cs
│ │ ├── UIElementsViewImporterEditor.cs
│ │ └── Utilities/
│ │ ├── Background/
│ │ │ └── CheckerboardBackground.cs
│ │ ├── CategoryDropdownField/
│ │ │ ├── CategoryDropdownContent.cs
│ │ │ ├── CategoryDropdownField+WindowContent.cs
│ │ │ └── CategoryDropdownField.cs
│ │ ├── ElementHierarchyView/
│ │ │ ├── BaseOverlayPainter.cs
│ │ │ ├── ElementHierarchyView.cs
│ │ │ ├── HighlightOverlayPainter.cs
│ │ │ ├── LayoutOverlayPainter.cs
│ │ │ ├── OverlayPainterHelperElement.cs
│ │ │ └── RepaintOverlayPainter.cs
│ │ ├── FoldoutField/
│ │ │ ├── FoldoutColorField.cs
│ │ │ ├── FoldoutField.cs
│ │ │ ├── FoldoutNumberField.cs
│ │ │ └── FoldoutTransitionField.cs
│ │ ├── FoldoutWithCheckbox/
│ │ │ └── FoldoutWithCheckbox.cs
│ │ ├── FontStyleStrip/
│ │ │ └── FontStyleStrip.cs
│ │ ├── HelpBox/
│ │ │ └── HelpBox.cs
│ │ ├── Importers/
│ │ │ ├── BuilderStyleSheetImporter.cs
│ │ │ └── BuilderVisualTreeAssetImporter.cs
│ │ ├── LibraryFoldout/
│ │ │ └── LibraryFoldout.cs
│ │ ├── ModalPopup/
│ │ │ └── ModalPopup.cs
│ │ ├── MultiTypeField/
│ │ │ └── MultiTypeField.cs
│ │ ├── PercentSlider/
│ │ │ └── PercentSlider.cs
│ │ ├── PersistedFoldout/
│ │ │ ├── BuilderCategoryPersistedFoldout.cs
│ │ │ └── PersistedFoldout.cs
│ │ ├── ReflectionExtensions/
│ │ │ └── ReflectionExtensions.cs
│ │ ├── Selector/
│ │ │ └── SelectorUtility.cs
│ │ ├── StringExtensions/
│ │ │ └── StringExtensions.cs
│ │ ├── StyleField/
│ │ │ ├── AngleStyleField.cs
│ │ │ ├── AssetReferenceStyleField.cs
│ │ │ ├── BackgroundPositionDimensionStyleField.cs
│ │ │ ├── BackgroundPositionStyleField.cs
│ │ │ ├── BackgroundRepeatStyleField.cs
│ │ │ ├── BackgroundSizeStyleField.cs
│ │ │ ├── BorderBoxModelView.cs
│ │ │ ├── BoxModelElement.cs
│ │ │ ├── BoxModelStyleField.cs
│ │ │ ├── BoxType.cs
│ │ │ ├── CursorStyleField.cs
│ │ │ ├── DimensionStyleField.cs
│ │ │ ├── FieldSearchCompleter.cs
│ │ │ ├── FieldStatusIndicator.cs
│ │ │ ├── FieldValueInfo.cs
│ │ │ ├── FontDefinitionStyleField.cs
│ │ │ ├── ImageStyleField.cs
│ │ │ ├── IntegerStyleField.cs
│ │ │ ├── NumericStyleField.cs
│ │ │ ├── PositionAnchorPoint.cs
│ │ │ ├── PositionAnchors.cs
│ │ │ ├── PositionSection.cs
│ │ │ ├── PositionStyleField.cs
│ │ │ ├── RotateStyleField.cs
│ │ │ ├── ScaleStyleField.cs
│ │ │ ├── SpacingBoxModelView.cs
│ │ │ ├── StyleField.cs
│ │ │ ├── StyleFieldConstants.cs
│ │ │ ├── StyleFieldPopup.cs
│ │ │ ├── StyleFieldPopupWindow.cs
│ │ │ ├── StyleVariableUtilities.cs
│ │ │ ├── TextAutoSizeStyleField.cs
│ │ │ ├── TextShadowStyleField.cs
│ │ │ ├── TransformOriginSelector.cs
│ │ │ ├── TransformOriginStyleField.cs
│ │ │ ├── TranslateStyleField.cs
│ │ │ ├── USSVariablesStyleField.cs
│ │ │ ├── VariableCompleter.cs
│ │ │ ├── VariableEditingHandler.cs
│ │ │ ├── VariableField.cs
│ │ │ ├── VariableInfo.cs
│ │ │ ├── VariableInfoTooltip.cs
│ │ │ └── VariableInfoView.cs
│ │ ├── StyleSheetExtensions/
│ │ │ ├── StyleComplexSelectorExtensions.cs
│ │ │ ├── StylePropertyExtensions.cs
│ │ │ ├── StylePropertyManipulator.cs
│ │ │ ├── StyleRuleExtensions.cs
│ │ │ ├── StyleSheetExtensions.cs
│ │ │ ├── StyleSheetToUss.cs
│ │ │ ├── StyleSheetUtilities.cs
│ │ │ └── StyleValueHandleExtensions.cs
│ │ ├── TextAlignStrip/
│ │ │ └── TextAlignStrip.cs
│ │ ├── Transitions/
│ │ │ ├── BuilderTransition.cs
│ │ │ ├── BuilderTransitionData.cs
│ │ │ ├── TransitionChangeType.cs
│ │ │ ├── TransitionEvents.cs
│ │ │ ├── TransitionListView.cs
│ │ │ ├── TransitionPropertyDropdownContent.cs
│ │ │ ├── TransitionsExtensions.cs
│ │ │ └── UIStyleValue.cs
│ │ ├── TypeExtensions/
│ │ │ └── TypeExtensions.cs
│ │ ├── TypeField/
│ │ │ └── BuilderAttributeTypeName.cs
│ │ ├── UnityUIBuilderSelectionMarker/
│ │ │ └── UnityUIBuilderSelectionMarker.cs
│ │ ├── VisualElementExtensions/
│ │ │ ├── VersionChangeTypeUtility.cs
│ │ │ └── VisualElementExtensions.cs
│ │ └── VisualTreeAssetExtensions/
│ │ ├── IUxmlFactoryExtensions.cs
│ │ ├── TemplateAssetExtensions.cs
│ │ ├── ValueToUXML.cs
│ │ ├── VisualElementAssetExtensions.cs
│ │ ├── VisualTreeAssetExtensions.cs
│ │ ├── VisualTreeAssetLinkedCloneTree.cs
│ │ ├── VisualTreeAssetToUXML.cs
│ │ └── VisualTreeAssetUtilities.cs
│ ├── UIElements/
│ │ ├── AssemblyInfo.cs
│ │ ├── Core/
│ │ │ ├── AlignmentUtils.cs
│ │ │ ├── Atlas.cs
│ │ │ ├── BackgroundPosition.PropertyBag.cs
│ │ │ ├── BackgroundPosition.cs
│ │ │ ├── BackgroundPropertyHelper.cs
│ │ │ ├── BackgroundRepeat.PropertyBag.cs
│ │ │ ├── BackgroundRepeat.cs
│ │ │ ├── BackgroundSize.PropertyBag.cs
│ │ │ ├── BackgroundSize.cs
│ │ │ ├── BindableElement.cs
│ │ │ ├── Bindings/
│ │ │ │ ├── Binding.Factory.cs
│ │ │ │ ├── Binding.cs
│ │ │ │ ├── BindingActivationContext.cs
│ │ │ │ ├── BindingContext.cs
│ │ │ │ ├── BindingResult.cs
│ │ │ │ ├── BindingTarget.cs
│ │ │ │ ├── BindingUpdater.cs
│ │ │ │ ├── ConverterGroup.cs
│ │ │ │ ├── ConverterGroups.cs
│ │ │ │ ├── CustomBinding.Factory.cs
│ │ │ │ ├── CustomBinding.cs
│ │ │ │ ├── DataBinding.Factory.cs
│ │ │ │ ├── DataBinding.cs
│ │ │ │ ├── DataBindingManager.cs
│ │ │ │ ├── DataBindingUtility.cs
│ │ │ │ ├── DataSourceContext.cs
│ │ │ │ ├── IDataSourceProvider.cs
│ │ │ │ ├── IDataSourceViewHashProvider.cs
│ │ │ │ ├── INotifyBindablePropertyChanged.cs
│ │ │ │ ├── Utils/
│ │ │ │ │ ├── AutoCompletePathVisitor.cs
│ │ │ │ │ └── TypePathVisitor.cs
│ │ │ │ ├── VisualTreeBindingsUpdater.cs
│ │ │ │ └── VisualTreeDataBindingUpdater.cs
│ │ │ ├── ClampedDragger.cs
│ │ │ ├── ClickDetector.cs
│ │ │ ├── Clickable.cs
│ │ │ ├── Collections/
│ │ │ │ ├── Controllers/
│ │ │ │ │ ├── BaseListViewController.cs
│ │ │ │ │ ├── BaseTreeViewController.cs
│ │ │ │ │ ├── CollectionViewController.cs
│ │ │ │ │ ├── DefaultMultiColumnTreeViewController.cs
│ │ │ │ │ ├── DefaultTreeViewController.cs
│ │ │ │ │ ├── IDefaultTreeViewController.cs
│ │ │ │ │ ├── ISerializedObjectList.cs
│ │ │ │ │ ├── ListViewController.cs
│ │ │ │ │ ├── MultiColumnListViewController.cs
│ │ │ │ │ ├── MultiColumnTreeViewController.cs
│ │ │ │ │ ├── TreeDataController.cs
│ │ │ │ │ └── TreeViewController.cs
│ │ │ │ ├── DictionaryExtensions.cs
│ │ │ │ └── Virtualization/
│ │ │ │ ├── CollectionVirtualizationController.cs
│ │ │ │ ├── DynamicHeightVirtualizationController.cs
│ │ │ │ ├── FixedHeightVirtualizationController.cs
│ │ │ │ ├── ReusableCollectionItem.cs
│ │ │ │ ├── ReusableListViewItem.cs
│ │ │ │ ├── ReusableMultiColumnListViewItem.cs
│ │ │ │ ├── ReusableMultiColumnTreeViewItem.cs
│ │ │ │ ├── ReusableTreeViewItem.cs
│ │ │ │ └── VerticalVirtualizationController.cs
│ │ │ ├── ContextualMenuManager.cs
│ │ │ ├── ContextualMenuManipulator.cs
│ │ │ ├── Controls/
│ │ │ │ ├── BaseBoolField.cs
│ │ │ │ ├── BaseCompositeField.cs
│ │ │ │ ├── BaseListView.cs
│ │ │ │ ├── BasePopupField.cs
│ │ │ │ ├── BaseSlider.cs
│ │ │ │ ├── BaseTreeView.cs
│ │ │ │ ├── BaseVerticalCollectionView.cs
│ │ │ │ ├── Binding.cs
│ │ │ │ ├── BoundsField.cs
│ │ │ │ ├── BoundsIntField.cs
│ │ │ │ ├── Box.cs
│ │ │ │ ├── Button.cs
│ │ │ │ ├── ButtonStripField.cs
│ │ │ │ ├── CompoundFields.cs
│ │ │ │ ├── DoubleField.cs
│ │ │ │ ├── DropdownField.cs
│ │ │ │ ├── EnumField.cs
│ │ │ │ ├── FloatField.cs
│ │ │ │ ├── Foldout.cs
│ │ │ │ ├── GenericDropdownMenu.cs
│ │ │ │ ├── GroupBox.cs
│ │ │ │ ├── Hash128Field.cs
│ │ │ │ ├── HelpBox.cs
│ │ │ │ ├── IMixedValueSupport.cs
│ │ │ │ ├── INotifyValueChanged.cs
│ │ │ │ ├── Image.cs
│ │ │ │ ├── InputField/
│ │ │ │ │ ├── BaseField.cs
│ │ │ │ │ ├── KeyboardTextEditor.cs
│ │ │ │ │ ├── TextEditor.cs
│ │ │ │ │ ├── TextField.cs
│ │ │ │ │ ├── TextInputFieldBase.cs
│ │ │ │ │ └── TouchScreenTextEditor.cs
│ │ │ │ ├── IntegerField.cs
│ │ │ │ ├── Label.cs
│ │ │ │ ├── ListView.cs
│ │ │ │ ├── LongField.cs
│ │ │ │ ├── MinMaxSlider.cs
│ │ │ │ ├── MultiColumn/
│ │ │ │ │ ├── Column.cs
│ │ │ │ │ ├── ColumnLayout.cs
│ │ │ │ │ ├── ColumnMover.cs
│ │ │ │ │ ├── ColumnResizer.cs
│ │ │ │ │ ├── Columns.cs
│ │ │ │ │ ├── MultiColumnCollectionHeader.cs
│ │ │ │ │ ├── MultiColumnController.cs
│ │ │ │ │ ├── MultiColumnHeaderColumn.cs
│ │ │ │ │ ├── MultiColumnHeaderColumnResizeHandle.cs
│ │ │ │ │ ├── MultiColumnListView.cs
│ │ │ │ │ ├── MultiColumnTreeView.cs
│ │ │ │ │ ├── SortColumnDescription.cs
│ │ │ │ │ └── SortColumnDescriptions.cs
│ │ │ │ ├── PopupField.cs
│ │ │ │ ├── PopupWindow.cs
│ │ │ │ ├── ProgressBar.cs
│ │ │ │ ├── RadioButton.cs
│ │ │ │ ├── RadioButtonGroup.cs
│ │ │ │ ├── RepeatButton.cs
│ │ │ │ ├── ScrollView.cs
│ │ │ │ ├── Scroller.cs
│ │ │ │ ├── Slider.cs
│ │ │ │ ├── SliderInt.cs
│ │ │ │ ├── Tab.cs
│ │ │ │ ├── TabDragger.cs
│ │ │ │ ├── TabView.cs
│ │ │ │ ├── TextValueField.cs
│ │ │ │ ├── Toggle.cs
│ │ │ │ ├── ToggleButtonGroup/
│ │ │ │ │ ├── ToggleButtonGroup.cs
│ │ │ │ │ ├── ToggleButtonGroupState.cs
│ │ │ │ │ └── ToggleButtonGroupStatePropertiesAttribute.cs
│ │ │ │ ├── TreeView.cs
│ │ │ │ ├── TreeViewHelpers.cs
│ │ │ │ ├── TreeViewItemData.cs
│ │ │ │ ├── TwoPaneSplitView.cs
│ │ │ │ ├── TwoPaneSplitViewResizer.cs
│ │ │ │ ├── UnsignedIntegerField.cs
│ │ │ │ └── UnsignedLongField.cs
│ │ │ ├── Conversions/
│ │ │ │ └── SetValueVisitor.cs
│ │ │ ├── CountingBloomFilter.cs
│ │ │ ├── Cursor.PropertyBag.cs
│ │ │ ├── Cursor.cs
│ │ │ ├── DisposeHelper.cs
│ │ │ ├── DragAndDrop/
│ │ │ │ ├── BaseReorderableDragAndDropController.cs
│ │ │ │ ├── DragAndDropUtility.cs
│ │ │ │ ├── DragEventsProcessor.cs
│ │ │ │ ├── ICollectionDragAndDropController.cs
│ │ │ │ ├── IDragAndDrop.cs
│ │ │ │ ├── IDragAndDropArgs.cs
│ │ │ │ ├── IDragAndDropController.cs
│ │ │ │ ├── IReorderable.cs
│ │ │ │ ├── ListViewDragger.cs
│ │ │ │ ├── ListViewDraggerAnimated.cs
│ │ │ │ ├── ListViewReorderableDragAndDropController.cs
│ │ │ │ └── TreeViewReorderableDragAndDropController.cs
│ │ │ ├── DropdownMenu.cs
│ │ │ ├── DropdownUtility.cs
│ │ │ ├── EasingCurves.cs
│ │ │ ├── EventDispatcher.cs
│ │ │ ├── Events/
│ │ │ │ ├── CaptureEvents.cs
│ │ │ │ ├── ChangeEvent.cs
│ │ │ │ ├── CommandEvents.cs
│ │ │ │ ├── DebuggerEventDispatchUtilities.cs
│ │ │ │ ├── DragAndDropEvents.cs
│ │ │ │ ├── ElementUnderPointer.cs
│ │ │ │ ├── EventBase.cs
│ │ │ │ ├── EventCallback.cs
│ │ │ │ ├── EventCallbackRegistry.cs
│ │ │ │ ├── EventDebugger/
│ │ │ │ │ ├── EventDebugger.cs
│ │ │ │ │ ├── EventDebuggerEventRecord.cs
│ │ │ │ │ ├── EventDebuggerTrace.cs
│ │ │ │ │ └── GlobalCallbackRegistry.cs
│ │ │ │ ├── EventDispatchUtilities.cs
│ │ │ │ ├── EventHandler.cs
│ │ │ │ ├── FocusEvents.cs
│ │ │ │ ├── IMEEvent.cs
│ │ │ │ ├── InputEvents.cs
│ │ │ │ ├── KeyboardEvents.cs
│ │ │ │ ├── LayoutEvents.cs
│ │ │ │ ├── LinkTagEvent.cs
│ │ │ │ ├── MouseEvents.cs
│ │ │ │ ├── MouseEventsHelper.cs
│ │ │ │ ├── NavigationEvents.cs
│ │ │ │ ├── PanelEvents.cs
│ │ │ │ ├── PointerDeviceState.cs
│ │ │ │ ├── PointerEvents.cs
│ │ │ │ ├── PropagationPaths.cs
│ │ │ │ ├── StyleEvents.cs
│ │ │ │ ├── TooltipEvent.cs
│ │ │ │ ├── TransitionEvents.cs
│ │ │ │ └── UIEvent.cs
│ │ │ ├── FieldMouseDragger.cs
│ │ │ ├── FilterFunctionDefinition.cs
│ │ │ ├── FilterFunctionDefinitionUtils.cs
│ │ │ ├── FocusController.cs
│ │ │ ├── GameObjects/
│ │ │ │ ├── DefaultEventSystem.InputForUIProcessor.cs
│ │ │ │ ├── DefaultEventSystem.LegacyInputProcessor.cs
│ │ │ │ ├── DefaultEventSystem.cs
│ │ │ │ ├── DocumentPicker.cs
│ │ │ │ ├── DynamicAtlasSettings.cs
│ │ │ │ ├── NavigateFocusRing.cs
│ │ │ │ ├── PanelInputConfiguration.cs
│ │ │ │ ├── PanelSettings.cs
│ │ │ │ ├── RuntimeEventDispatcher.cs
│ │ │ │ ├── RuntimePanel.cs
│ │ │ │ ├── RuntimePanelUtils.cs
│ │ │ │ ├── ScreenRaycaster.cs
│ │ │ │ ├── UIDocument.cs
│ │ │ │ ├── UIDocumentHierarchyUtil.cs
│ │ │ │ └── WorldSpaceInput.cs
│ │ │ ├── GroupBoxUtility.cs
│ │ │ ├── HierarchyTraversal.cs
│ │ │ ├── IEnumerableUtils.cs
│ │ │ ├── IGroupBox.cs
│ │ │ ├── IGroupManager.cs
│ │ │ ├── ILiveReloadAssetTracker.cs
│ │ │ ├── ILiveReloadSystem.cs
│ │ │ ├── IMGUIContainer.cs
│ │ │ ├── ISerializableJsonDictionary.cs
│ │ │ ├── ITransform.cs
│ │ │ ├── ImmediateModeElement.cs
│ │ │ ├── InteractionEnums.cs
│ │ │ ├── KeyboardNavigationManipulator.cs
│ │ │ ├── Layout/
│ │ │ │ ├── LayoutConfig.cs
│ │ │ │ ├── LayoutHandle.cs
│ │ │ │ ├── LayoutManager.cs
│ │ │ │ ├── LayoutNode+Computed.cs
│ │ │ │ ├── LayoutNode+Hierarchy.cs
│ │ │ │ ├── LayoutNode+Style.cs
│ │ │ │ ├── LayoutNode.cs
│ │ │ │ ├── LayoutProcessor.cs
│ │ │ │ ├── Model/
│ │ │ │ │ ├── Components/
│ │ │ │ │ │ ├── LayoutCacheData.cs
│ │ │ │ │ │ ├── LayoutComputedData.cs
│ │ │ │ │ │ ├── LayoutConfigData.cs
│ │ │ │ │ │ ├── LayoutDataAccess.cs
│ │ │ │ │ │ ├── LayoutDataStore.cs
│ │ │ │ │ │ └── LayoutNodeData.cs
│ │ │ │ │ ├── FixedBuffer.cs
│ │ │ │ │ ├── LayoutAlign.cs
│ │ │ │ │ ├── LayoutDefaults.cs
│ │ │ │ │ ├── LayoutDimension.cs
│ │ │ │ │ ├── LayoutDirection.cs
│ │ │ │ │ ├── LayoutDisplay.cs
│ │ │ │ │ ├── LayoutEdge.cs
│ │ │ │ │ ├── LayoutFlexDirection.cs
│ │ │ │ │ ├── LayoutJustify.cs
│ │ │ │ │ ├── LayoutList.cs
│ │ │ │ │ ├── LayoutLogLevel.cs
│ │ │ │ │ ├── LayoutMeasureMode.cs
│ │ │ │ │ ├── LayoutNodeType.cs
│ │ │ │ │ ├── LayoutOverflow.cs
│ │ │ │ │ ├── LayoutPositionType.cs
│ │ │ │ │ ├── LayoutPrintOptions.cs
│ │ │ │ │ ├── LayoutSize.cs
│ │ │ │ │ ├── LayoutUnit.cs
│ │ │ │ │ ├── LayoutValue.cs
│ │ │ │ │ └── LayoutWrap.cs
│ │ │ │ └── Native/
│ │ │ │ ├── LayoutNative.bindings.cs
│ │ │ │ └── LayoutProcessorNative.cs
│ │ │ ├── ManipulatorActivationFilter.cs
│ │ │ ├── Manipulators.cs
│ │ │ ├── MouseButton.cs
│ │ │ ├── MouseCaptureController.cs
│ │ │ ├── MouseManipulator.cs
│ │ │ ├── Native/
│ │ │ │ ├── Renderer/
│ │ │ │ │ ├── MeshWriteDataInterface.bindings.cs
│ │ │ │ │ ├── UIPainter2D.bindings.cs
│ │ │ │ │ ├── UIRMeshBuilder.bindings.cs
│ │ │ │ │ ├── UIRenderer.bindings.cs
│ │ │ │ │ └── UIRendererJobProcessor.bindings.cs
│ │ │ │ ├── TextNative.bindings.cs
│ │ │ │ └── UIElementsUtility.bindings.cs
│ │ │ ├── ObjectPool.cs
│ │ │ ├── Panel.cs
│ │ │ ├── PenButton.cs
│ │ │ ├── PointerCaptureController.cs
│ │ │ ├── PointerManipulator.cs
│ │ │ ├── ProjectionUtils.cs
│ │ │ ├── Renderer/
│ │ │ │ ├── GCHandlePool.cs
│ │ │ │ ├── LayoutDebuggerVisualElement.cs
│ │ │ │ ├── SafeHandleAccess.cs
│ │ │ │ ├── UIRAllocator2D.cs
│ │ │ │ ├── UIRAtlasAllocator.cs
│ │ │ │ ├── UIRAtlasManager.cs
│ │ │ │ ├── UIRCommandList.cs
│ │ │ │ ├── UIRCommandManipulator.cs
│ │ │ │ ├── UIRDetachedAllocator.cs
│ │ │ │ ├── UIRDynamicAtlasPage.cs
│ │ │ │ ├── UIRElementBuilder.cs
│ │ │ │ ├── UIREntryPool.cs
│ │ │ │ ├── UIREntryPreProcessor.cs
│ │ │ │ ├── UIREntryProcessor.cs
│ │ │ │ ├── UIREntryRecorder.cs
│ │ │ │ ├── UIRGradientSettingsAtlas.cs
│ │ │ │ ├── UIRImplicitPool.cs
│ │ │ │ ├── UIRJobManager.cs
│ │ │ │ ├── UIRJobMerger.cs
│ │ │ │ ├── UIRLayoutUpdater.cs
│ │ │ │ ├── UIRLinkedPool.cs
│ │ │ │ ├── UIRMeshGenerationContext.cs
│ │ │ │ ├── UIRMeshGenerationDeferrer.cs
│ │ │ │ ├── UIRMeshGenerationNode.cs
│ │ │ │ ├── UIRMeshGenerator.cs
│ │ │ │ ├── UIRNativeList.cs
│ │ │ │ ├── UIRNativePagedList.cs
│ │ │ │ ├── UIROpacityIdAccelerator.cs
│ │ │ │ ├── UIRPainter2D.cs
│ │ │ │ ├── UIRRenderData.cs
│ │ │ │ ├── UIRRenderEvents.cs
│ │ │ │ ├── UIRRenderTree.cs
│ │ │ │ ├── UIRRenderTreeCompositor.cs
│ │ │ │ ├── UIRRenderTreeManager.cs
│ │ │ │ ├── UIRRepaintUpdater.cs
│ │ │ │ ├── UIRShaderInfoStorage.cs
│ │ │ │ ├── UIRShaders.cs
│ │ │ │ ├── UIRTempAllocator.cs
│ │ │ │ ├── UIRTempMeshAllocator.cs
│ │ │ │ ├── UIRTextCoreSettings.cs
│ │ │ │ ├── UIRTextureBlitter.cs
│ │ │ │ ├── UIRTextureRegistry.cs
│ │ │ │ ├── UIRTextureSlotManager.cs
│ │ │ │ ├── UIRUtility.cs
│ │ │ │ ├── UIRVEShaderInfoAllocator.cs
│ │ │ │ ├── UIRVectorImageManager.cs
│ │ │ │ ├── UIRVisualChangesProcessor.cs
│ │ │ │ └── UIRenderer/
│ │ │ │ ├── UIRenderDevice.cs
│ │ │ │ ├── UIRenderDeviceAllocator.cs
│ │ │ │ └── UIRenderers.cs
│ │ │ ├── Scheduler.cs
│ │ │ ├── Spacing.cs
│ │ │ ├── StringUtils.cs
│ │ │ ├── Style/
│ │ │ │ ├── Angle.PropertyBag.cs
│ │ │ │ ├── Angle.cs
│ │ │ │ ├── Background.PropertyBag.cs
│ │ │ │ ├── Background.cs
│ │ │ │ ├── ComputedStyle.cs
│ │ │ │ ├── ComputedTransitions.cs
│ │ │ │ ├── CustomStyle.cs
│ │ │ │ ├── EasingFunction.PropertyBag.cs
│ │ │ │ ├── EasingFunction.cs
│ │ │ │ ├── FilterFunction.PropertyBag.cs
│ │ │ │ ├── FilterFunction.cs
│ │ │ │ ├── FontDefinition.PropertyBag.cs
│ │ │ │ ├── FontDefinition.cs
│ │ │ │ ├── Generated/
│ │ │ │ │ ├── ComputedStyle.cs
│ │ │ │ │ ├── IResolvedStyle.cs
│ │ │ │ │ ├── IStyle.cs
│ │ │ │ │ ├── InitialStyle.cs
│ │ │ │ │ ├── InlineStyleAccess.cs
│ │ │ │ │ ├── InlineStyleAccessPropertyBag.cs
│ │ │ │ │ ├── ResolvedStyleAccess.cs
│ │ │ │ │ ├── ResolvedStyleAccessPropertyBag.cs
│ │ │ │ │ ├── ResolvedStyleProperties.cs
│ │ │ │ │ ├── ShorthandApplicator.cs
│ │ │ │ │ ├── StyleDataStructs.cs
│ │ │ │ │ ├── StyleDebug.cs
│ │ │ │ │ ├── StyleDiff.cs
│ │ │ │ │ ├── StyleProperties.cs
│ │ │ │ │ ├── StylePropertyCache.cs
│ │ │ │ │ ├── StylePropertyEnums.cs
│ │ │ │ │ └── StylePropertyUtil.cs
│ │ │ │ ├── IResolvedStyle.cs
│ │ │ │ ├── IStyle.cs
│ │ │ │ ├── InlineStyleAccess.PropertyBag.cs
│ │ │ │ ├── InlineStyleAccess.cs
│ │ │ │ ├── Length.PropertyBag.cs
│ │ │ │ ├── Length.cs
│ │ │ │ ├── ResolvedStyleAccess.PropertyBag.cs
│ │ │ │ ├── ResolvedStyleAccess.cs
│ │ │ │ ├── Rotate.PropertyBag.cs
│ │ │ │ ├── Rotate.cs
│ │ │ │ ├── Scale.PropertyBag.cs
│ │ │ │ ├── Scale.cs
│ │ │ │ ├── StyleBackground.cs
│ │ │ │ ├── StyleBackgroundPosition.cs
│ │ │ │ ├── StyleBackgroundRepeat.cs
│ │ │ │ ├── StyleBackgroundSize.cs
│ │ │ │ ├── StyleColor.cs
│ │ │ │ ├── StyleCursor.cs
│ │ │ │ ├── StyleDataRef.cs
│ │ │ │ ├── StyleDebug.cs
│ │ │ │ ├── StyleDiff.cs
│ │ │ │ ├── StyleEnum.cs
│ │ │ │ ├── StyleFloat.cs
│ │ │ │ ├── StyleFont.cs
│ │ │ │ ├── StyleFontDefinition.cs
│ │ │ │ ├── StyleInt.cs
│ │ │ │ ├── StyleLength.cs
│ │ │ │ ├── StyleList.cs
│ │ │ │ ├── StyleMaterial.cs
│ │ │ │ ├── StylePropertyUtil.cs
│ │ │ │ ├── StyleRotate.cs
│ │ │ │ ├── StyleScale.cs
│ │ │ │ ├── StyleTextShadow.cs
│ │ │ │ ├── StyleTransformOrigin.cs
│ │ │ │ ├── StyleTranslate.cs
│ │ │ │ ├── StyleTypes.cs
│ │ │ │ ├── StyleValue.PropertyBag.cs
│ │ │ │ ├── TimeValue.PropertyBag.cs
│ │ │ │ ├── TimeValue.cs
│ │ │ │ ├── TransformOrigin.PropertyBag.cs
│ │ │ │ ├── TransformOrigin.cs
│ │ │ │ ├── Translate.PropertyBag.cs
│ │ │ │ └── Translate.cs
│ │ │ ├── StyleEnums.cs
│ │ │ ├── StylePropertyAnimation.cs
│ │ │ ├── StylePropertyAnimationSystem.cs
│ │ │ ├── StylePropertyName.PropertyBag.cs
│ │ │ ├── StylePropertyName.cs
│ │ │ ├── StyleSheets/
│ │ │ │ ├── CSSSpec.cs
│ │ │ │ ├── Dimension.cs
│ │ │ │ ├── MatchedRulesExtractor.cs
│ │ │ │ ├── ScalableImage.cs
│ │ │ │ ├── StyleComplexSelector.cs
│ │ │ │ ├── StyleProperty.cs
│ │ │ │ ├── StylePropertyReader.cs
│ │ │ │ ├── StylePropertyReaderHelper.cs
│ │ │ │ ├── StyleRule.cs
│ │ │ │ ├── StyleSelector.cs
│ │ │ │ ├── StyleSelectorHelper.cs
│ │ │ │ ├── StyleSelectorPart.cs
│ │ │ │ ├── StyleSelectorRelationship.cs
│ │ │ │ ├── StyleSelectorType.cs
│ │ │ │ ├── StyleSheet.cs
│ │ │ │ ├── StyleSheetApplicator.cs
│ │ │ │ ├── StyleSheetBuilder.cs
│ │ │ │ ├── StyleSheetCache.cs
│ │ │ │ ├── StyleSheetColor.cs
│ │ │ │ ├── StyleSheetExtensions.cs
│ │ │ │ ├── StyleSheetUtility.cs
│ │ │ │ ├── StyleValue.cs
│ │ │ │ ├── StyleValueFunction.cs
│ │ │ │ ├── StyleValueHandle.cs
│ │ │ │ ├── StyleValueKeyword.cs
│ │ │ │ ├── StyleValueType.cs
│ │ │ │ ├── StyleVariable.cs
│ │ │ │ ├── Syntax/
│ │ │ │ │ ├── StyleSyntaxExpression.cs
│ │ │ │ │ ├── StyleSyntaxParser.cs
│ │ │ │ │ └── StyleSyntaxToken.cs
│ │ │ │ ├── ThemeStyleSheet.cs
│ │ │ │ └── Validation/
│ │ │ │ ├── StyleMatcher.cs
│ │ │ │ ├── StylePropertyCache.cs
│ │ │ │ ├── StylePropertyValueParser.cs
│ │ │ │ └── StyleValidator.cs
│ │ │ ├── StyleTextAutoSize.cs
│ │ │ ├── TemplateContainer.cs
│ │ │ ├── Text/
│ │ │ │ ├── ATGTextEventHandler.cs
│ │ │ │ ├── ATGTextHandle.cs
│ │ │ │ ├── ATGTextJobSystem.cs
│ │ │ │ ├── PanelTextSettings.cs
│ │ │ │ ├── TextEditingManipulator.cs
│ │ │ │ ├── TextEventHandler.cs
│ │ │ │ ├── TextJobSystem.cs
│ │ │ │ ├── TextSelectingManipulator.cs
│ │ │ │ ├── TextUtilities.cs
│ │ │ │ ├── UITKTextHandle.cs
│ │ │ │ └── UITKTextJobSystem.cs
│ │ │ ├── TextAutoSize.PropertyBag.cs
│ │ │ ├── TextAutoSize.cs
│ │ │ ├── TextElement.cs
│ │ │ ├── TextElementEdition.cs
│ │ │ ├── TextElementExperimental.cs
│ │ │ ├── TextElementSelection.cs
│ │ │ ├── TextShadow.PropertyBag.cs
│ │ │ ├── TextShadow.cs
│ │ │ ├── Transitions.cs
│ │ │ ├── UIElementsBridge.cs
│ │ │ ├── UIElementsInitialization.cs
│ │ │ ├── UIElementsRuntimeUtility.cs
│ │ │ ├── UIElementsUtility.cs
│ │ │ ├── UIToolkitInputConfiguration.cs
│ │ │ ├── UQuery.cs
│ │ │ ├── UXML/
│ │ │ │ ├── FieldRenderingAttributes.cs
│ │ │ │ ├── IUxmlAttributes.cs
│ │ │ │ ├── OrphanFactories.cs
│ │ │ │ ├── TemplateAsset.cs
│ │ │ │ ├── UxmlAssetAttributeDescription.cs
│ │ │ │ ├── UxmlAttributeDescription.cs
│ │ │ │ ├── UxmlAttributes.cs
│ │ │ │ ├── UxmlChildElementDescription.cs
│ │ │ │ ├── UxmlDescriptionRegistry.cs
│ │ │ │ ├── UxmlFactory.cs
│ │ │ │ ├── UxmlImageAttributeDescription.cs
│ │ │ │ ├── UxmlObjectAsset.cs
│ │ │ │ ├── UxmlObjectFactoryRegistry.cs
│ │ │ │ ├── UxmlSerializedData.cs
│ │ │ │ ├── UxmlTypeRestriction.cs
│ │ │ │ ├── UxmlUtility.cs
│ │ │ │ ├── VisualElementAsset.cs
│ │ │ │ ├── VisualElementFactoryRegistry.cs
│ │ │ │ ├── VisualTreeAsset.cs
│ │ │ │ └── VisualTreeAssetUtilities.cs
│ │ │ ├── UpgradeConstants.cs
│ │ │ ├── ValueAnimation.cs
│ │ │ ├── VectorImage.cs
│ │ │ ├── VisualElement.cs
│ │ │ ├── VisualElementAnimation.cs
│ │ │ ├── VisualElementBindableProperties.cs
│ │ │ ├── VisualElementDataBinding.cs
│ │ │ ├── VisualElementEventInterests.cs
│ │ │ ├── VisualElementExperimentalFeatures.cs
│ │ │ ├── VisualElementFocusRing.cs
│ │ │ ├── VisualElementHierarchy.cs
│ │ │ ├── VisualElementMathUtils.cs
│ │ │ ├── VisualElementScheduler.cs
│ │ │ ├── VisualElementStyleAccess.cs
│ │ │ ├── VisualElementStyleSheetSet.cs
│ │ │ ├── VisualElementTooltip.cs
│ │ │ ├── VisualElementTypeData.cs
│ │ │ ├── VisualElementUtils.cs
│ │ │ ├── VisualTreeAnimationUpdater.cs
│ │ │ ├── VisualTreeHierarchyFlagsUpdater.cs
│ │ │ ├── VisualTreeHierarchyTracker.cs
│ │ │ ├── VisualTreeStyleUpdater.cs
│ │ │ ├── VisualTreeUpdater.cs
│ │ │ ├── VisualTreeViewDataUpdater.cs
│ │ │ └── WorldSpaceData.cs
│ │ ├── InputSystem/
│ │ │ ├── InputSystemEventSystem.cs
│ │ │ └── InputWrapper.cs
│ │ ├── Managed/
│ │ │ ├── Utility/
│ │ │ │ └── ChunkAllocatingArray.cs
│ │ │ ├── VisualNode.cs
│ │ │ ├── VisualNodeChildren.cs
│ │ │ ├── VisualNodeClassList.cs
│ │ │ └── VisualPanel.cs
│ │ └── ScriptBindings/
│ │ ├── VisualManager.bindings.cs
│ │ ├── VisualNodeChildrenData.bindings.cs
│ │ ├── VisualNodeClassData.bindings.cs
│ │ ├── VisualNodeClassNameStore.bindings.cs
│ │ ├── VisualNodeData.bindings.cs
│ │ ├── VisualNodeHandle.bindings.cs
│ │ ├── VisualNodeImguiData.bindings.cs
│ │ ├── VisualNodeProperty.bindings.cs
│ │ ├── VisualNodePropertyStore.bindings.cs
│ │ ├── VisualNodePseudoStateData.bindings.cs
│ │ ├── VisualNodeRenderData.bindings.cs
│ │ ├── VisualNodeTextData.bindings.cs
│ │ ├── VisualPanelData.bindings.cs
│ │ └── VisualPanelHandle.bindings.cs
│ ├── UIElementsEditor/
│ │ ├── ATGAnalytics.cs
│ │ ├── AssemblyInfo.cs
│ │ ├── Bindings/
│ │ │ ├── BaseListViewSerializedObjectBinding.cs
│ │ │ ├── DefaultSerializedObjectBindingImplementation.cs
│ │ │ ├── EditorListViewController.cs
│ │ │ ├── EditorMultiColumnListViewController.cs
│ │ │ ├── ListViewSerializedObjectBinding.cs
│ │ │ ├── MultiColumnListViewSerializedObjectBinding.cs
│ │ │ ├── SerializedDefaultEnumBinding.cs
│ │ │ ├── SerializedIsExpandedBinding.cs
│ │ │ ├── SerializedManagedEnumBinding.cs
│ │ │ ├── SerializedObjectBinding.cs
│ │ │ ├── SerializedObjectBindingBase.cs
│ │ │ ├── SerializedObjectBindingContext.cs
│ │ │ ├── SerializedObjectBindingContextUpdater.cs
│ │ │ ├── SerializedObjectBindingPropertyToBaseField.cs
│ │ │ ├── SerializedObjectBindingToBaseField.cs
│ │ │ ├── SerializedObjectReferenceBinding.cs
│ │ │ ├── SerializedObjectStringConversionBinding.cs
│ │ │ └── SerializedPropertyHelper.cs
│ │ ├── Debugger/
│ │ │ ├── BoxModelView.cs
│ │ │ ├── DebuggerSearchBar.cs
│ │ │ ├── DebuggerTreeView.cs
│ │ │ ├── EditorWindowExtension.cs
│ │ │ ├── Events/
│ │ │ │ ├── CodeLine.cs
│ │ │ │ ├── EventLog.cs
│ │ │ │ ├── EventLogLine.cs
│ │ │ │ ├── EventTypeSearchField.cs
│ │ │ │ ├── IRegisteredCallbackLine.cs
│ │ │ │ ├── RegisterCallbackLines/
│ │ │ │ │ ├── CallbackInfo.cs
│ │ │ │ │ ├── CodeLineInfo.cs
│ │ │ │ │ └── TitleInfo.cs
│ │ │ │ └── UIElementsEventDebugger.cs
│ │ │ ├── LayoutDebugger/
│ │ │ │ ├── LayoutPanelDebuggerImpl.cs
│ │ │ │ ├── UILayoutDebugger.cs
│ │ │ │ ├── UILayoutDebuggerHistogram.cs
│ │ │ │ └── UILayoutDebuggerWindow.cs
│ │ │ ├── OtherDebbugerField.cs
│ │ │ ├── OverlayPainter.cs
│ │ │ ├── PanelDebugger.cs
│ │ │ ├── StyleLengthField.cs
│ │ │ ├── StylePropertyDebugger.cs
│ │ │ ├── StylesDebugger.cs
│ │ │ ├── TextureAtlas/
│ │ │ │ ├── TextureAtlasViewer.cs
│ │ │ │ └── TextureAtlasViewerWindow.cs
│ │ │ ├── UIElementsDebugger.cs
│ │ │ ├── UIR/
│ │ │ │ ├── Debugger/
│ │ │ │ │ ├── AllocatorDebugger.cs
│ │ │ │ │ └── UIRDebugger.cs
│ │ │ │ └── UIRDebugUtility.cs
│ │ │ └── UxmlExporter.cs
│ │ ├── Delegates/
│ │ │ ├── EditorDelegateRegistration.cs
│ │ │ └── SerializedPropertyDelegates.cs
│ │ ├── EditorContextualMenuManager.cs
│ │ ├── EditorCursor.cs
│ │ ├── EditorDragAndDrop.cs
│ │ ├── EditorMonitor.cs
│ │ ├── EditorPanel.cs
│ │ ├── EditorUIElementsBridge.cs
│ │ ├── FilterDefinitionPropertyDrawer.cs
│ │ ├── GameObjects/
│ │ │ ├── Inspector/
│ │ │ │ ├── PanelInputConfigurationEditor.cs
│ │ │ │ ├── PanelSettingsInspector.cs
│ │ │ │ ├── UIDocumentInspector.cs
│ │ │ │ └── UIRendererEditor.cs
│ │ │ ├── LiveReloadTrackerCreator.cs
│ │ │ ├── PanelSettingsCreator/
│ │ │ │ └── PanelSettingsCreator.cs
│ │ │ ├── PlayModeMenuItems.cs
│ │ │ └── UIDocumentHierarchyWatcher.cs
│ │ ├── Legacy/
│ │ │ └── ProgressBar.cs
│ │ ├── PanelDebug.cs
│ │ ├── RetainedMode.cs
│ │ ├── StringBuilderPool.cs
│ │ ├── Text/
│ │ │ ├── PanelTextSettingsCreationMenu.cs
│ │ │ ├── PanelTextSettingsEditor.cs
│ │ │ ├── PanelTextSettingsImporter.cs
│ │ │ └── TextInfoOverlay.cs
│ │ ├── Tooltip.cs
│ │ ├── UIElementsEditorInitialization.cs
│ │ ├── UIElementsEditorRuntimeUtility.cs
│ │ ├── UIElementsEditorWindowCreator/
│ │ │ ├── CSharpTemplateCreator.cs
│ │ │ ├── UIElementsEditorWindowCreator.cs
│ │ │ ├── UssTemplateCreator.cs
│ │ │ └── UxmlTemplateCreator.cs
│ │ ├── UIElementsViewImporter.cs
│ │ ├── UIToolkitProjectSettings.cs
│ │ ├── UIToolkitSettingsProvider.cs
│ │ ├── UXML/
│ │ │ ├── UxmlAttributeComparison.cs
│ │ │ ├── UxmlAttributeConverter.cs
│ │ │ ├── UxmlSerializedDataCreator.cs
│ │ │ ├── UxmlSerializedDataDescription.cs
│ │ │ ├── UxmlSerializedDataRegistry.cs
│ │ │ └── UxmlSerializer.cs
│ │ ├── UXMLAssetAttributeCache.cs
│ │ ├── UXMLEditorFactories.cs
│ │ ├── UXMLFactoryPreserver.cs
│ │ ├── UXMLSchemaGenerator.cs
│ │ ├── UxmlCodeDependencies.cs
│ │ ├── VisualTreeAssetChangeTrackerUpdater.cs
│ │ ├── VisualTreeAssetEditor.cs
│ │ ├── VisualTreeEditorUpdater.cs
│ │ └── WindowBackends/
│ │ ├── DefaultEditorWindowBackend.cs
│ │ └── DefaultWindowBackend.cs
│ ├── UIElementsSamplesEditor/
│ │ ├── ElementSnippet.cs
│ │ ├── Snippets/
│ │ │ ├── BoundsFieldSnippet.cs
│ │ │ ├── BoundsIntFieldSnippet.cs
│ │ │ ├── ButtonSnippet.cs
│ │ │ ├── ColorFieldSnippet.cs
│ │ │ ├── CurveFieldSnippet.cs
│ │ │ ├── DropdownFieldSnippet.cs
│ │ │ ├── EnumFieldSnippet.cs
│ │ │ ├── EnumFlagsFieldSnippet.cs
│ │ │ ├── FloatFieldSnippet.cs
│ │ │ ├── GradientFieldSnippet.cs
│ │ │ ├── HelpBoxSnippet.cs
│ │ │ ├── IntegerFieldSnippet.cs
│ │ │ ├── LabelSnippet.cs
│ │ │ ├── LayerFieldSnippet.cs
│ │ │ ├── LayerMaskFieldSnippet.cs
│ │ │ ├── ListViewSnippet.cs
│ │ │ ├── LongFieldSnippet.cs
│ │ │ ├── Mask64FieldSnippet.cs
│ │ │ ├── MaskFieldSnippet.cs
│ │ │ ├── MinMaxSliderSnippet.cs
│ │ │ ├── MultiColumnListViewSnippet.cs
│ │ │ ├── MultiColumnTreeViewSnippet.cs
│ │ │ ├── ObjectFieldSnippet.cs
│ │ │ ├── PopupFieldSnippet.cs
│ │ │ ├── RadioButtonGroupSnippet.cs
│ │ │ ├── RadioButtonSnippet.cs
│ │ │ ├── RectFieldSnippet.cs
│ │ │ ├── RectIntFieldSnippet.cs
│ │ │ ├── ScrollerSnippet.cs
│ │ │ ├── SliderIntSnippet.cs
│ │ │ ├── SliderSnippet.cs
│ │ │ ├── TabViewSnippet.cs
│ │ │ ├── TagFieldSnippet.cs
│ │ │ ├── TextFieldSnippet.cs
│ │ │ ├── ToggleButtonGroupSnippet.cs
│ │ │ ├── ToggleSnippet.cs
│ │ │ ├── TreeViewSnippet.cs
│ │ │ ├── UnsignedIntegerFieldSnippet.cs
│ │ │ ├── UnsignedLongFieldSnippet.cs
│ │ │ ├── Vector2FieldSnippet.cs
│ │ │ ├── Vector2IntFieldSnippet.cs
│ │ │ ├── Vector3FieldSnippet.cs
│ │ │ ├── Vector3IntFieldSnippet.cs
│ │ │ └── Vector4FieldSnippet.cs
│ │ ├── StylesExplorer.cs
│ │ ├── UIElementsSamples.cs
│ │ └── UIElementsSnippetAsset.cs
│ ├── UMPE/
│ │ └── Editor/
│ │ ├── ChannelClient.cs
│ │ ├── ChannelService.cs
│ │ ├── DataService.cs
│ │ ├── EventService.cs
│ │ ├── RoleProviderAttribute.cs
│ │ └── UMPE.bindings.cs
│ ├── UnityAnalytics/
│ │ ├── ContinuousEvent/
│ │ │ └── ContinuousEvent.bindings.cs
│ │ ├── Public/
│ │ │ ├── AnalyticsSessionInfo.bindings.cs
│ │ │ ├── Events/
│ │ │ │ ├── CustomEventData.bindings.cs
│ │ │ │ └── CustomEventData.cs
│ │ │ ├── UnityAnalytics.bindings.cs
│ │ │ └── UnityAnalytics.cs
│ │ └── RemoteSettings/
│ │ └── RemoteSettings.bindings.cs
│ ├── UnityAnalyticsCommon/
│ │ └── Public/
│ │ ├── Events/
│ │ │ ├── AssetDatabaseAnalytics.cs
│ │ │ ├── BuildAssetBundleAnalytics.cs
│ │ │ ├── CollabOperationAnalytics.cs
│ │ │ ├── LicensingAnalytics.cs
│ │ │ ├── MetalUtilAnalytics.cs
│ │ │ ├── NavigationAnalytics.cs
│ │ │ ├── PackageManagerAnalytics.cs
│ │ │ ├── PackageUtilityAnalytics.cs
│ │ │ ├── StallAnalytics.cs
│ │ │ ├── SubsystemsAnalytics.cs
│ │ │ ├── TestAnalytics.cs
│ │ │ └── VRDeviceAnalytics.cs
│ │ ├── UnityAnalyticsCommon.bindings.cs
│ │ └── UnityAnalyticsCommon.cs
│ ├── UnityConnect/
│ │ ├── UnityAds/
│ │ │ └── UnityAdsSettings.bindings.cs
│ │ └── UnityConnectSettings.bindings.cs
│ ├── UnityConnectEditor/
│ │ ├── Analytics/
│ │ │ └── EditorGameServicesAnalytics.cs
│ │ ├── Common/
│ │ │ ├── CoppaDrawer.cs
│ │ │ ├── CoppaManager.cs
│ │ │ ├── INotificationSubscriber.cs
│ │ │ ├── IProjectEditorDrawer.cs
│ │ │ ├── Notification.cs
│ │ │ ├── NotificationManager.cs
│ │ │ ├── PackageHelper.cs
│ │ │ ├── ProjectBindDrawer.cs
│ │ │ ├── ProjectBindManager.cs
│ │ │ ├── ProjectNameSlashReplacer.cs
│ │ │ ├── ServicesConstants.cs
│ │ │ ├── SimpleStateMachine.cs
│ │ │ └── UIElementsNotificationSubscriber.cs
│ │ ├── ProjectSettings/
│ │ │ ├── AdsProjectSettings.cs
│ │ │ ├── AnalyticsProjectSettings.cs
│ │ │ ├── CloudBuildProjectSettings.cs
│ │ │ ├── CloudDiagProjectSettings.cs
│ │ │ ├── Fallback/
│ │ │ │ ├── InstallPackageSection.cs
│ │ │ │ ├── PackageInstallationHandler.cs
│ │ │ │ ├── VisualElementConstants.cs
│ │ │ │ └── VisualElementUtils.cs
│ │ │ ├── GeneralProjectSettings.cs
│ │ │ └── PurchasingProjectSettings.cs
│ │ ├── Services/
│ │ │ ├── AdsService.cs
│ │ │ ├── AnalyticsConfiguration.cs
│ │ │ ├── AnalyticsService.cs
│ │ │ ├── AnalyticsValidationPoller.cs
│ │ │ ├── BuildService.cs
│ │ │ ├── CloudBuildPoller.cs
│ │ │ ├── CrashService.cs
│ │ │ ├── PurchasingConfiguration.cs
│ │ │ ├── PurchasingService.cs
│ │ │ ├── SingleService.cs
│ │ │ └── UDPServices.cs
│ │ ├── ServicesExploreMenu.cs
│ │ ├── ServicesProjectSettings.cs
│ │ └── ServicesRepository.cs
│ ├── UnityCurl/
│ │ ├── FriendAttributes.cs
│ │ └── Public/
│ │ └── UnityCurl.bindings.cs
│ ├── UnityEditorAnalyticsEditor/
│ │ ├── BuildEventsHandler.cs
│ │ ├── DebuggerEventListHandler.cs
│ │ ├── EditorAnalytics.bindings.cs
│ │ ├── Events/
│ │ │ └── EditorAnalyticsEvent.bindings.cs
│ │ └── UsabilityAnalytics.bindings.cs
│ ├── UnityWebRequest/
│ │ ├── FriendAttributes.cs
│ │ └── Public/
│ │ ├── CertificateHandler/
│ │ │ └── CertificateHandler.bindings.cs
│ │ ├── DownloadHandler/
│ │ │ └── DownloadHandler.bindings.cs
│ │ ├── MultipartFormHelper.cs
│ │ ├── UnityWebRequest.bindings.cs
│ │ ├── UploadHandler/
│ │ │ └── UploadHandler.bindings.cs
│ │ ├── WebRequest.deprecated.cs
│ │ ├── WebRequestExtensions.cs
│ │ └── WebRequestUtils.cs
│ ├── UnityWebRequestAssetBundle/
│ │ ├── Public/
│ │ │ └── DownloadHandlerAssetBundle.bindings.cs
│ │ └── UnityWebRequestAssetBundle.cs
│ ├── UnityWebRequestAudio/
│ │ ├── Public/
│ │ │ └── DownloadHandlerAudio.bindings.cs
│ │ └── UnityWebRequestMultimedia.cs
│ ├── UnityWebRequestTexture/
│ │ ├── Public/
│ │ │ └── DownloadHandlerTexture.bindings.cs
│ │ └── UnityWebRequestTexture.cs
│ ├── UnityWebRequestWWW/
│ │ └── Public/
│ │ ├── WWW.bindings.cs
│ │ ├── WWW.cs
│ │ └── WWWAudio.deprecated.cs
│ ├── VFX/
│ │ ├── FriendAttributes.cs
│ │ └── Public/
│ │ └── ScriptBindings/
│ │ ├── VFXEnums.bindings.cs
│ │ ├── VFXEventAttribute.bindings.cs
│ │ ├── VFXExpressionValues.bindings.cs
│ │ ├── VFXManager.bindings.cs
│ │ ├── VFXSpawnerCallbacks.bindings.cs
│ │ ├── VFXSpawnerState.bindings.cs
│ │ └── VisualEffect.bindings.cs
│ ├── VFXEditor/
│ │ ├── FriendAttributes.cs
│ │ └── Public/
│ │ ├── ScriptBindings/
│ │ │ ├── VFXExpressionMesh.bindings.cs
│ │ │ ├── VFXExpressionNoise.bindings.cs
│ │ │ ├── VFXExpressionTexture.bindings.cs
│ │ │ ├── VFXMemorySerializer.bindings.cs
│ │ │ ├── VisualEffectImporter.bindings.cs
│ │ │ ├── VisualEffectResource.bindings.cs
│ │ │ ├── VisualEffectSubgraph.bindings.cs
│ │ │ ├── VisualEffectTest.bindings.cs
│ │ │ └── VisualEffectUtility.bindings.cs
│ │ └── VisualEffectEditorDefault.cs
│ ├── VR/
│ │ └── ScriptBindings/
│ │ └── XR.bindings.cs
│ ├── VREditor/
│ │ ├── Mono/
│ │ │ └── VREditor.cs
│ │ └── ScriptBindings/
│ │ └── VREditor.bindings.cs
│ ├── Vehicles/
│ │ └── Vehicles.bindings.cs
│ ├── Video/
│ │ └── Public/
│ │ └── ScriptBindings/
│ │ ├── MediaComponent.bindings.cs
│ │ ├── VideoClip.bindings.cs
│ │ ├── VideoClipPlayable.bindings.cs
│ │ ├── VideoMediaPlayback.bindings.cs
│ │ ├── VideoPlayer.bindings.cs
│ │ └── VideoPlayerExtensions.bindings.cs
│ ├── VideoEditor/
│ │ └── Editor/
│ │ ├── VideoClipInspector.cs
│ │ ├── VideoPlayerEditor.cs
│ │ └── VideoUtil.bindings.cs
│ ├── VirtualTexturing/
│ │ ├── Managed/
│ │ │ └── AssemblyInfo.cs
│ │ └── ScriptBindings/
│ │ └── VirtualTexturing.bindings.cs
│ ├── VirtualTexturingEditor/
│ │ └── ScriptBindings/
│ │ └── VirtualTexturingEditor.bindings.cs
│ ├── Wind/
│ │ └── Public/
│ │ └── WindZone.bindings.cs
│ ├── XR/
│ │ ├── ScriptBindings/
│ │ │ ├── InputTracking.cs
│ │ │ ├── VRNode.cs
│ │ │ ├── VRNodeState.cs
│ │ │ └── XRInput.bindings.cs
│ │ ├── Stats/
│ │ │ └── XRStats.bindings.cs
│ │ └── Subsystems/
│ │ ├── Display/
│ │ │ ├── XRDisplaySubsystem.bindings.cs
│ │ │ └── XRDisplaySubsystemDescriptor.bindings.cs
│ │ ├── Input/
│ │ │ ├── XRInputSubsystem.bindings.cs
│ │ │ └── XRInputSubsystemDescriptor.bindings.cs
│ │ └── Meshing/
│ │ ├── XRMeshSubsystem.bindings.cs
│ │ └── XRMeshSubsystemDescriptor.bindings.cs
│ └── XREditor/
│ ├── Boot/
│ │ └── XRBoot.bindings.cs
│ ├── Build/
│ │ └── XRBuildUtilities.bindings.cs
│ └── XRManagementInstaller.cs
├── Projects/
│ └── CSharp/
│ ├── UnityEditor.csproj
│ ├── UnityEngine.csproj
│ └── UnityReferenceSource.sln
├── README.md
├── Runtime/
│ ├── 2D/
│ │ ├── Common/
│ │ │ └── ScriptBindings/
│ │ │ ├── Clipper2D.bindings.cs
│ │ │ ├── ClipperOffset2D.bindings.cs
│ │ │ ├── Light2DBase.cs
│ │ │ ├── PixelSnapping.bindings.cs
│ │ │ ├── SpriteDataAccess.bindings.cs
│ │ │ ├── SpriteDataUtility.cs
│ │ │ ├── SpriteRenderer.bindings.cs
│ │ │ ├── SpriteRendererGroup.bindings.cs
│ │ │ └── Sprites.bindings.cs
│ │ ├── Sorting/
│ │ │ └── ScriptBindings/
│ │ │ └── SortingGroup.bindings.cs
│ │ └── SpriteAtlas/
│ │ └── ScriptBindings/
│ │ └── SpriteAtlas.bindings.cs
│ ├── Export/
│ │ ├── 2D/
│ │ │ └── SortingLayer.bindings.cs
│ │ ├── Analytics/
│ │ │ └── AnalyticsCommon.cs
│ │ ├── Animation/
│ │ │ └── AnimationCurve.bindings.cs
│ │ ├── Annotations/
│ │ │ └── JetBrains.Annotations.cs
│ │ ├── Apple/
│ │ │ └── FrameCaptureMetal.bindings.cs
│ │ ├── Application/
│ │ │ ├── Application.bindings.cs
│ │ │ └── Application.cs
│ │ ├── AssemblyInfo.cs
│ │ ├── Assertions/
│ │ │ ├── Assert/
│ │ │ │ ├── AssertBase.cs
│ │ │ │ ├── AssertBool.cs
│ │ │ │ ├── AssertFloat.cs
│ │ │ │ ├── AssertGeneric.cs
│ │ │ │ ├── AssertNull.cs
│ │ │ │ ├── AssertPrimitiveTypes.cs
│ │ │ │ ├── AssertionException.cs
│ │ │ │ ├── AssertionMessageUtil.cs
│ │ │ │ └── Comparers/
│ │ │ │ └── FloatComparer.cs
│ │ │ └── Must/
│ │ │ ├── MustBool.cs
│ │ │ ├── MustFloat.cs
│ │ │ ├── MustGeneric.cs
│ │ │ └── MustNull.cs
│ │ ├── Audio/
│ │ │ └── AudioType.cs
│ │ ├── BaseClass.cs
│ │ ├── Bootstrap/
│ │ │ └── BootConfig.bindings.cs
│ │ ├── Burst/
│ │ │ ├── BurstAuthorizedExternalMethodAttribute.cs
│ │ │ ├── BurstCompilerService.bindings.cs
│ │ │ ├── BurstCompilerService.cs
│ │ │ └── BurstDiscardAttribute.cs
│ │ ├── BurstLike/
│ │ │ └── BurstLike.bindings.cs
│ │ ├── Caching/
│ │ │ ├── Cache.bindings.cs
│ │ │ ├── Caching.bindings.cs
│ │ │ └── Caching.deprecated.cs
│ │ ├── Camera/
│ │ │ ├── BatchRenderGroupAnalytics.cs
│ │ │ ├── BuiltinRuntimeReflectionSystem.bindings.cs
│ │ │ ├── Camera.bindings.cs
│ │ │ ├── Camera.deprecated.cs
│ │ │ ├── CullingGroup.bindings.cs
│ │ │ ├── FlareLayer.bindings.cs
│ │ │ ├── IScriptableRuntimeReflectionSystem.cs
│ │ │ ├── ReflectionProbe.bindings.cs
│ │ │ ├── ScriptableRuntimeReflectionSystem.cs
│ │ │ ├── ScriptableRuntimeReflectionSystemSettings.bindings.cs
│ │ │ └── ScriptableRuntimeReflectionSystemWrapper.cs
│ │ ├── Collections/
│ │ │ ├── CollectionExtensions.cs
│ │ │ ├── NativeCollectionAccessPolicies.cs
│ │ │ └── NativeCollectionEnums.bindings.cs
│ │ ├── ContentNamespace/
│ │ │ └── ContentNamespace.bindings.cs
│ │ ├── Coverage.bindings.cs
│ │ ├── CrashReport/
│ │ │ └── CrashReport.bindings.cs
│ │ ├── Debug/
│ │ │ ├── Debug.bindings.cs
│ │ │ └── Debug.deprecated.cs
│ │ ├── DedicatedServer/
│ │ │ └── Arguments.bindings.cs
│ │ ├── Device/
│ │ │ ├── Application.cs
│ │ │ ├── Screen.cs
│ │ │ └── SystemInfo.cs
│ │ ├── DiagnosticSwitch/
│ │ │ └── DiagnosticSwitch.cs
│ │ ├── Diagnostics/
│ │ │ └── DiagnosticsUtils.bindings.cs
│ │ ├── Director/
│ │ │ ├── CameraPlayable.bindings.cs
│ │ │ ├── ExposedPropertyTable.bindings.cs
│ │ │ ├── ExposedReference.cs
│ │ │ ├── FrameData.cs
│ │ │ ├── FrameRate.bindings.cs
│ │ │ ├── IExposedPropertyTable.cs
│ │ │ ├── INotification.cs
│ │ │ ├── INotificationReceiver.cs
│ │ │ ├── IPlayable.cs
│ │ │ ├── IPlayableBehaviour.cs
│ │ │ ├── IPlayableOutput.cs
│ │ │ ├── MaterialEffectPlayable.bindings.cs
│ │ │ ├── Notification.cs
│ │ │ ├── Playable.cs
│ │ │ ├── PlayableAsset.cs
│ │ │ ├── PlayableBehaviour.cs
│ │ │ ├── PlayableBindings.cs
│ │ │ ├── PlayableExtensions.cs
│ │ │ ├── PlayableGraph.bindings.cs
│ │ │ ├── PlayableHandle.bindings.cs
│ │ │ ├── PlayableOutput.cs
│ │ │ ├── PlayableOutputExtensions.cs
│ │ │ ├── PlayableOutputExtensions.deprecated.cs
│ │ │ ├── PlayableOutputHandle.bindings.cs
│ │ │ ├── ScriptPlayable.cs
│ │ │ ├── ScriptPlayableBinding.cs
│ │ │ ├── ScriptPlayableOutput.cs
│ │ │ ├── TextureMixerPlayable.bindings.cs
│ │ │ ├── TexturePlayableBinding.cs
│ │ │ ├── TexturePlayableGraphExtensions.bindings.cs
│ │ │ └── TexturePlayableOutput.bindings.cs
│ │ ├── ETW/
│ │ │ └── EventProvider.bindings.cs
│ │ ├── ExpressionEvaluator.cs
│ │ ├── File/
│ │ │ ├── ArchiveFile.bindings.cs
│ │ │ ├── AsyncReadManager.bindings.cs
│ │ │ ├── BuildCompression.cs
│ │ │ ├── File.bindings.cs
│ │ │ └── VirtualFileSystem.bindings.cs
│ │ ├── FriendAttributes.cs
│ │ ├── GI/
│ │ │ ├── DynamicGI.bindings.cs
│ │ │ ├── GIDebugVisualisation.bindings.cs
│ │ │ ├── LightingSettings.bindings.cs
│ │ │ ├── LightingSettings.deprecated.cs
│ │ │ └── Lightmapping.cs
│ │ ├── Geometry/
│ │ │ ├── Bounds.cs
│ │ │ ├── BoundsInt.cs
│ │ │ ├── GeometryUtility.cs
│ │ │ ├── Plane.cs
│ │ │ ├── Ray.cs
│ │ │ ├── Ray2D.cs
│ │ │ ├── Rect.cs
│ │ │ ├── RectInt.cs
│ │ │ └── RectOffset.cs
│ │ ├── Gizmos/
│ │ │ ├── Gizmos.bindings.cs
│ │ │ └── Gizmos.cs
│ │ ├── Graphics/
│ │ │ ├── AsyncGPUReadback.bindings.cs
│ │ │ ├── BeforeRenderHelper.cs
│ │ │ ├── BillboardRenderer.bindings.cs
│ │ │ ├── CustomRenderTextureManager.cs
│ │ │ ├── Display.bindings.cs
│ │ │ ├── GPUFence.deprecated.cs
│ │ │ ├── Graphics.bindings.cs
│ │ │ ├── Graphics.cs
│ │ │ ├── Graphics.deprecated.cs
│ │ │ ├── GraphicsBuffer.bindings.cs
│ │ │ ├── GraphicsComponents.bindings.cs
│ │ │ ├── GraphicsDeviceDebug.bindings.cs
│ │ │ ├── GraphicsEnums.cs
│ │ │ ├── GraphicsFence.bindings.cs
│ │ │ ├── GraphicsFormatUtility.bindings.cs
│ │ │ ├── GraphicsJobsFilterModes.bindings.cs
│ │ │ ├── GraphicsManagers.bindings.cs
│ │ │ ├── GraphicsRenderers.bindings.cs
│ │ │ ├── GraphicsSettings.RenderPipelineGlobalSettings.bindings.cs
│ │ │ ├── GraphicsSettings.bindings.cs
│ │ │ ├── GraphicsStateCollection.bindings.cs
│ │ │ ├── GraphicsStateCollection.cs
│ │ │ ├── GraphicsTexture.bindings.cs
│ │ │ ├── Graphics_BindingsOverloads.cs
│ │ │ ├── HDROutputFaking.bindings.cs
│ │ │ ├── IRenderPipelineGraphicsSettings.cs
│ │ │ ├── IRenderPipelineResources.cs
│ │ │ ├── LOD.bindings.cs
│ │ │ ├── Light.bindings.cs
│ │ │ ├── Light.deprecated.cs
│ │ │ ├── LightProbeGroup.bindings.cs
│ │ │ ├── LightProbeProxyVolume.bindings.cs
│ │ │ ├── LineUtility.cs
│ │ │ ├── MachineLearningContext.bindings.cs
│ │ │ ├── MachineLearningContext.cs
│ │ │ ├── MachineLearningOperator.bindings.cs
│ │ │ ├── MachineLearningOperator.cs
│ │ │ ├── MachineLearningTensor.bindings.cs
│ │ │ ├── MachineLearningTensor.cs
│ │ │ ├── Mesh.bindings.cs
│ │ │ ├── Mesh.cs
│ │ │ ├── MeshData.bindings.cs
│ │ │ ├── MeshData.cs
│ │ │ ├── OnDemandRendering.bindings.cs
│ │ │ ├── RayTracingAccelerationStructure.bindings.cs
│ │ │ ├── RenderPipelineGraphicsSettingsCollection.cs
│ │ │ ├── RenderPipelineGraphicsSettingsExtensions.cs
│ │ │ ├── RenderingCommandBuffer.bindings.cs
│ │ │ ├── RenderingCommandBuffer.cs
│ │ │ ├── RenderingCommandBuffer.deprecated.cs
│ │ │ ├── RenderingCommandBufferExtensions.bindings.cs
│ │ │ ├── ShaderWarmup.bindings.cs
│ │ │ ├── ShadingRateImage.bindings.cs
│ │ │ ├── ShadingRateImage.cs
│ │ │ ├── ShadingRateInfo.binding.cs
│ │ │ ├── SplashScreen.bindings.cs
│ │ │ ├── SupportedOnRenderPipeline.cs
│ │ │ ├── Texture.bindings.cs
│ │ │ ├── Texture.cs
│ │ │ ├── Texture.deprecated.cs
│ │ │ ├── VulkanDeviceFilterLists.bindings.cs
│ │ │ └── Watermark.bindings.cs
│ │ ├── Handheld/
│ │ │ └── Handheld.bindings.cs
│ │ ├── Hashing/
│ │ │ ├── Hash128.bindings.cs
│ │ │ ├── HashUtilities.cs
│ │ │ └── SpookyHash.cs
│ │ ├── Hmi/
│ │ │ └── HmiPlatform.bindings.cs
│ │ ├── IMGUI/
│ │ │ ├── GUIElement.bindings.cs
│ │ │ └── ScrollWaitDefinitions.cs
│ │ ├── Input/
│ │ │ ├── Cursor.bindings.cs
│ │ │ └── KeyCode.cs
│ │ ├── Internal/
│ │ │ ├── DefaultValueAttribute.cs
│ │ │ ├── ExcludeFromDocs.cs
│ │ │ └── InternalInterfaces.cs
│ │ ├── Jobs/
│ │ │ └── AtomicSafetyHandle.bindings.cs
│ │ ├── Logging/
│ │ │ ├── DebugLogHandler.cs
│ │ │ ├── ILogHandler.cs
│ │ │ ├── ILogger.cs
│ │ │ ├── Logger.cs
│ │ │ └── UnityLogWriter.bindings.cs
│ │ ├── Lumin/
│ │ │ ├── UsesLuminPlatformLevel.cs
│ │ │ └── UsesLuminPrivilege.cs
│ │ ├── Math/
│ │ │ ├── Color.cs
│ │ │ ├── Color32.cs
│ │ │ ├── ColorUtility.bindings.cs
│ │ │ ├── ColorUtility.cs
│ │ │ ├── Gradient.bindings.cs
│ │ │ ├── Math.bindings.cs
│ │ │ ├── Mathf.cs
│ │ │ ├── Matrix4x4.cs
│ │ │ ├── Quaternion.cs
│ │ │ ├── SphericalHarmonicsL2.bindings.cs
│ │ │ ├── Vector2.cs
│ │ │ ├── Vector2Int.cs
│ │ │ ├── Vector3.cs
│ │ │ ├── Vector3Int.cs
│ │ │ └── Vector4.cs
│ │ ├── Misc/
│ │ │ └── ObjectDispatcher.bindings.cs
│ │ ├── NativeArray/
│ │ │ ├── DisposeSentinel.cs
│ │ │ ├── NativeArray.cs
│ │ │ └── NativeSlice.cs
│ │ ├── Networking/
│ │ │ ├── Ping.bindings.cs
│ │ │ └── PlayerConnection/
│ │ │ ├── ConnectionApi.cs
│ │ │ ├── PlayerConnection.cs
│ │ │ └── PlayerEditorConnectionEvents.cs
│ │ ├── NumericFieldDraggerUtility.cs
│ │ ├── ObjectPool/
│ │ │ ├── CollectionPool.cs
│ │ │ ├── GenericPool.cs
│ │ │ ├── IObjectPool.cs
│ │ │ ├── IPool.cs
│ │ │ ├── LinkedPool.cs
│ │ │ ├── ObjectPools.cs
│ │ │ ├── PoolManager.cs
│ │ │ ├── PooledObject.cs
│ │ │ └── UnsafeGenericPool.cs
│ │ ├── PlayerConnection/
│ │ │ ├── PlayerConnection.cs
│ │ │ └── PlayerConnectionInternal.bindings.cs
│ │ ├── PlayerLoop/
│ │ │ └── PlayerLoop.bindings.cs
│ │ ├── PlayerPrefs/
│ │ │ └── PlayerPrefs.bindings.cs
│ │ ├── Profiler/
│ │ │ └── IgnoredByDeepProfilerAttribute.cs
│ │ ├── Properties/
│ │ │ └── DrivenPropertyManager.bindings.cs
│ │ ├── PropertyDrawer/
│ │ │ └── PropertyAttribute.cs
│ │ ├── PropertyName/
│ │ │ ├── PropertyName.bindings.cs
│ │ │ └── PropertyName.cs
│ │ ├── Random/
│ │ │ ├── Random.bindings.cs
│ │ │ └── Random.cs
│ │ ├── RenderPipeline/
│ │ │ ├── AttachmentDescriptor.cs
│ │ │ ├── BitOperationUtils.cs
│ │ │ ├── BlendState.cs
│ │ │ ├── CullingParameters.cs
│ │ │ ├── CullingResults.bindings.cs
│ │ │ ├── CullingResults.cs
│ │ │ ├── DepthState.cs
│ │ │ ├── DrawRendererFlags.cs
│ │ │ ├── DrawingSettings.cs
│ │ │ ├── FilteringSettings.cs
│ │ │ ├── GizmoSubset.cs
│ │ │ ├── InvalidImportException.cs
│ │ │ ├── LODParameters.cs
│ │ │ ├── ObjectIdRequest.cs
│ │ │ ├── PerObjectData.cs
│ │ │ ├── RasterState.cs
│ │ │ ├── ReflectionProbeSortingCriteria.cs
│ │ │ ├── RenderPipeline.cs
│ │ │ ├── RenderPipelineAsset.cs
│ │ │ ├── RenderPipelineAsset.deprecated.cs
│ │ │ ├── RenderPipelineGlobalSettings.cs
│ │ │ ├── RenderPipelineManager.cs
│ │ │ ├── RenderPipelineManager.deprecated.cs
│ │ │ ├── RenderQueueRange.cs
│ │ │ ├── RenderStateBlock.cs
│ │ │ ├── RenderStateMask.cs
│ │ │ ├── RenderTargetBlendState.cs
│ │ │ ├── RendererList.bindings.cs
│ │ │ ├── RenderingLayerMask.bindings.cs
│ │ │ ├── ScopedRenderPass.cs
│ │ │ ├── ScriptableRenderContext.bindings.cs
│ │ │ ├── ScriptableRenderContext.cs
│ │ │ ├── ShaderTagId.cs
│ │ │ ├── ShadowDrawingSettings.cs
│ │ │ ├── ShadowSplitData.cs
│ │ │ ├── SortingCriteria.cs
│ │ │ ├── SortingLayerRange.cs
│ │ │ ├── SortingSettings.cs
│ │ │ ├── StencilState.cs
│ │ │ ├── SupportedRenderingFeatures.cs
│ │ │ ├── UISubset.cs
│ │ │ ├── VisibleLight.cs
│ │ │ ├── VisibleLightFlags.cs
│ │ │ └── VisibleReflectionProbe.cs
│ │ ├── Rendering/
│ │ │ ├── BatchRendererGroup.bindings.cs
│ │ │ └── GPUDrivenRendering.bindings.cs
│ │ ├── Resources/
│ │ │ ├── IconAttribute.cs
│ │ │ ├── Resources.bindings.cs
│ │ │ └── Resources.deprecated.cs
│ │ ├── SceneManager/
│ │ │ ├── LineUtility.bindings.cs
│ │ │ ├── Scene.bindings.cs
│ │ │ ├── Scene.cs
│ │ │ ├── SceneManager.bindings.cs
│ │ │ ├── SceneManager.cs
│ │ │ └── SceneUtility.bindings.cs
│ │ ├── Scripting/
│ │ │ ├── APIUpdating/
│ │ │ │ └── UpdatedFromAttribute.cs
│ │ │ ├── AlwaysLinkAssemblyAttribute.cs
│ │ │ ├── ApiRestrictions.bindings.cs
│ │ │ ├── AsyncInstantiateOperation.bindings.cs
│ │ │ ├── AsyncOperation.bindings.cs
│ │ │ ├── AsyncOperation.cs
│ │ │ ├── AttributeHelperEngine.cs
│ │ │ ├── Attributes.cs
│ │ │ ├── Awaitable.AsyncMethodBuilder.cs
│ │ │ ├── Awaitable.AsyncMethodBuilderT.cs
│ │ │ ├── Awaitable.AsyncOperation.cs
│ │ │ ├── Awaitable.Awaiter.cs
│ │ │ ├── Awaitable.Bindings.cs
│ │ │ ├── Awaitable.DelayedCall.cs
│ │ │ ├── Awaitable.Threading.cs
│ │ │ ├── Awaitable.UnityEvents.cs
│ │ │ ├── Awaitable.cs
│ │ │ ├── AwaitableCompletionSource.cs
│ │ │ ├── AwaitableT.cs
│ │ │ ├── Behaviour.bindings.cs
│ │ │ ├── BindingsHelpers.cs
│ │ │ ├── CastHelper.cs
│ │ │ ├── Categorize.cs
│ │ │ ├── ClassLibraryInitializer.cs
│ │ │ ├── Component.bindings.cs
│ │ │ ├── Component.deprecated.cs
│ │ │ ├── Coroutine.bindings.cs
│ │ │ ├── Coroutines.cs
│ │ │ ├── CustomYieldInstruction.cs
│ │ │ ├── EnumDataUtility.cs
│ │ │ ├── EnumInfo.cs
│ │ │ ├── ExcludeFromObjectFactoryAttribute.cs
│ │ │ ├── ExtensionOfNativeClassAttribute.cs
│ │ │ ├── FailedToLoadScriptObject.cs
│ │ │ ├── GameObject.bindings.cs
│ │ │ ├── GameObject.deprecated.cs
│ │ │ ├── GarbageCollector.bindings.cs
│ │ │ ├── Il2CppEagerStaticClassConstructionAttribute.cs
│ │ │ ├── InspectorOrderAttribute.cs
│ │ │ ├── LayerMask.bindings.cs
│ │ │ ├── LazyLoadReference.cs
│ │ │ ├── ManagedStreamHelpers.cs
│ │ │ ├── MonoBehaviour.bindings.cs
│ │ │ ├── NoAllocHelpers.bindings.cs
│ │ │ ├── PreserveAttribute.cs
│ │ │ ├── RangeInt.cs
│ │ │ ├── RequireAttributeUsagesAttribute.cs
│ │ │ ├── RequireDerivedAttribute.cs
│ │ │ ├── RequireImplementorsAttribute.cs
│ │ │ ├── RequiredInterfaceAttribute.cs
│ │ │ ├── RequiredMemberAttribute.cs
│ │ │ ├── RuntimeInitializeOnLoadAttribute.cs
│ │ │ ├── ScriptableObject.bindings.cs
│ │ │ ├── ScriptingRuntime.bindings.cs
│ │ │ ├── ScriptingUtility.cs
│ │ │ ├── SelectionBaseAttribute.cs
│ │ │ ├── StackTrace.cs
│ │ │ ├── TagHandle.cs
│ │ │ ├── TextAsset.bindings.cs
│ │ │ ├── TextAsset.cs
│ │ │ ├── TrackedReference.cs
│ │ │ ├── UnhandledExceptionHandler.bindings.cs
│ │ │ ├── UnityAPICompatibilityVersionAttribute.cs
│ │ │ ├── UnityEngineObject.bindings.cs
│ │ │ ├── UnitySynchronizationContext.cs
│ │ │ ├── WaitForEndOfFrame.cs
│ │ │ ├── WaitForFixedUpdate.cs
│ │ │ ├── WaitForSeconds.cs
│ │ │ ├── WaitForSecondsRealtime.cs
│ │ │ ├── WaitTimeoutMode.cs
│ │ │ ├── WaitUntil.cs
│ │ │ ├── WaitWhile.cs
│ │ │ └── YieldOperation.cs
│ │ ├── SearchService/
│ │ │ ├── ObjectSelectorHandlerAttribute.Deprecated.cs
│ │ │ └── SearchContextAttribute.cs
│ │ ├── Security/
│ │ │ ├── Security.cs
│ │ │ └── SecurityPublic.cs
│ │ ├── Serialization/
│ │ │ ├── FormerlySerializedAsAttribute.cs
│ │ │ ├── ManagedReferenceUtility.bindings.cs
│ │ │ ├── Serialization.cs
│ │ │ └── UnitySurrogateSelector.cs
│ │ ├── Shaders/
│ │ │ ├── ComputeBuffer.bindings.cs
│ │ │ ├── ComputeShader.bindings.cs
│ │ │ ├── ComputeShader.cs
│ │ │ ├── GlobalKeyword.bindings.cs
│ │ │ ├── LocalKeyword.bindings.cs
│ │ │ ├── LocalKeywordSpace.bindings.cs
│ │ │ ├── Material.bindings.cs
│ │ │ ├── Material.cs
│ │ │ ├── MaterialPropertyBlock.bindings.cs
│ │ │ ├── MaterialPropertyBlock.cs
│ │ │ ├── PassIdentifier.bindings.cs
│ │ │ ├── PlatformKeywordSet.cs
│ │ │ ├── RayTracingShader.bindings.cs
│ │ │ ├── RayTracingShader.cs
│ │ │ ├── Shader.bindings.cs
│ │ │ ├── Shader.cs
│ │ │ ├── ShaderKeyword.bindings.cs
│ │ │ ├── ShaderKeyword.deprecated.cs
│ │ │ ├── ShaderKeywordSet.bindings.cs
│ │ │ ├── ShaderProperties.cs
│ │ │ ├── ShaderVariantAnalytics/
│ │ │ │ └── ShaderRuntimeInfoAnalytics.cs
│ │ │ ├── ShaderVariantCollection.bindings.cs
│ │ │ └── ShaderVariantCollection.cs
│ │ ├── Snapping/
│ │ │ ├── SnapAxis.cs
│ │ │ └── Snapping.cs
│ │ ├── StaticBatching/
│ │ │ ├── CombineForStaticBatching.cs
│ │ │ └── MeshSubsetCombineUtility.cs
│ │ ├── StaticShim/
│ │ │ ├── ApplicationShimBase.cs
│ │ │ ├── ScreenShimBase.cs
│ │ │ ├── ShimManager.cs
│ │ │ └── SystemInfoShimBase.cs
│ │ ├── Stripping/
│ │ │ └── ClassStubsForStripping.cs
│ │ ├── SystemInfo/
│ │ │ ├── SystemInfo.bindings.cs
│ │ │ └── SystemInfo.deprecated.cs
│ │ ├── Time/
│ │ │ ├── DiscreteTime.cs
│ │ │ ├── RationalTime.bindings.cs
│ │ │ ├── SystemClock.cs
│ │ │ └── Time.bindings.cs
│ │ ├── TouchScreenKeyboard/
│ │ │ ├── TouchScreenKeyboard.bindings.cs
│ │ │ └── TouchScreenKeyboardType.cs
│ │ ├── UINumericFieldsUtils.cs
│ │ ├── Undo/
│ │ │ └── RuntimeUndo.bindings.cs
│ │ ├── UnityEngineInternal/
│ │ │ ├── APIUpdaterRuntimeServices.cs
│ │ │ ├── TypeInferenceRuleAttribute.cs
│ │ │ └── WrappedTypes.cs
│ │ ├── UnityEvent/
│ │ │ ├── PropertyChangedEvent.cs
│ │ │ ├── UnityEvent.cs
│ │ │ └── UnityEventQueueSystem.bindings.cs
│ │ ├── Unsafe/
│ │ │ ├── UTF8StringView.bindings.cs
│ │ │ ├── UnsafeUtility.bindings.cs
│ │ │ ├── UnsafeUtility.cs
│ │ │ └── UnsafeUtilityPatched.cs
│ │ ├── WSA/
│ │ │ ├── WSAApplication.bindings.cs
│ │ │ ├── WSACursor.bindings.cs
│ │ │ ├── WSALauncher.bindings.cs
│ │ │ └── WSATiles.bindings.cs
│ │ ├── Windows/
│ │ │ ├── AppTrial.bindings.cs
│ │ │ ├── PhotoCapture.bindings.cs
│ │ │ ├── Speech.bindings.cs
│ │ │ ├── Speech.cs
│ │ │ ├── VideoCapture.bindings.cs
│ │ │ ├── WebCam.bindings.cs
│ │ │ ├── WindowsCrashReporting.bindings.cs
│ │ │ ├── WindowsCrypto.bindings.cs
│ │ │ ├── WindowsDirectory.bindings.cs
│ │ │ ├── WindowsFile.bindings.cs
│ │ │ ├── WindowsInput.bindings.cs
│ │ │ └── WindowsInput.cs
│ │ ├── XR/
│ │ │ └── Pose.cs
│ │ └── iOS/
│ │ ├── AppleDevice.bindings.cs
│ │ ├── OnDemandResources.bindings.cs
│ │ ├── iOS.deprecated.cs
│ │ ├── iOSDevice.bindings.cs
│ │ ├── iOSDevice.cs
│ │ ├── iOSReplayKit.bindings.cs
│ │ ├── iOSSystemGestureDeferMode.cs
│ │ ├── tvOS.bindings.cs
│ │ ├── tvOS.bindings.deprecated.cs
│ │ └── tvOSDevice.cs
│ ├── Jobs/
│ │ ├── Managed/
│ │ │ ├── BatchQueries.cs
│ │ │ ├── IJob.cs
│ │ │ ├── IJobFor.cs
│ │ │ ├── IJobParallelFor.cs
│ │ │ └── IJobParallelForTransform.cs
│ │ └── ScriptBindings/
│ │ ├── JobHandle.bindings.cs
│ │ └── Jobs.bindings.cs
│ ├── NameFormatter/
│ │ └── NameFormatter.bindings.cs
│ ├── Profiler/
│ │ └── ScriptBindings/
│ │ ├── FrameDebugger.bindings.cs
│ │ ├── MemoryProfiling.bindings.cs
│ │ ├── MemoryProfiling.deprecated.cs
│ │ ├── Profiler.bindings.cs
│ │ ├── ProfilerCategory.cs
│ │ ├── ProfilerMarker.bindings.cs
│ │ ├── ProfilerMarker.cs
│ │ ├── ProfilerRecorder.bindings.cs
│ │ ├── ProfilerScreenCapture.cs
│ │ ├── ProfilerUnsafeUtility.bindings.cs
│ │ ├── ProfilerUtility.cs
│ │ ├── Recorder.bindings.cs
│ │ └── Sampler.bindings.cs
│ ├── Scripting/
│ │ ├── APIUpdating/
│ │ │ └── APIUpdaterRuntimeHelpers.cs
│ │ ├── Internal/
│ │ │ └── LifecycleManagement/
│ │ │ ├── AssemblyLoadedAttributes.cs
│ │ │ ├── CodeLoadedScope.cs
│ │ │ ├── LifecycleAttributeBase.cs
│ │ │ ├── RequiredMemberAttribute.cs
│ │ │ ├── ScopedLazy.cs
│ │ │ └── StaticsCleanupAttributes.cs
│ │ └── Marshalling/
│ │ ├── ArrayHandleOnStack.cs
│ │ ├── BindingsHelpers.bindings.cs
│ │ ├── BlittableArrayWrapper.cs
│ │ ├── BlittableListWrapper.cs
│ │ ├── ExceptionMarshaller.cs
│ │ ├── ManagedSpanWrapper.cs
│ │ ├── StringMarshalling.cs
│ │ └── UnmanagedCallersOnlyAttribute.cs
│ └── Transform/
│ └── ScriptBindings/
│ ├── RectTransform.bindings.cs
│ ├── Transform.bindings.cs
│ └── TransformAccessArray.bindings.cs
├── Tools/
│ ├── Unity.CecilTools/
│ │ ├── CecilUtils.cs
│ │ ├── ElementType.cs
│ │ ├── Extensions/
│ │ │ ├── MethodDefinitionExtensions.cs
│ │ │ ├── ResolutionExtensions.cs
│ │ │ ├── TypeDefinitionExtensions.cs
│ │ │ └── TypeReferenceExtensions.cs
│ │ ├── Properties/
│ │ │ └── AssemblyInfo.cs
│ │ └── Unity.CecilTools.gen.csproj
│ └── Unity.SerializationLogic/
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── Unity.SerializationLogic.gen.csproj
│ ├── UnityEngineTypePredicates.cs
│ └── UnitySerializationLogic.cs
├── artifacts/
│ └── generated/
│ └── UnityEvent/
│ ├── UnityEvent_0.cs
│ ├── UnityEvent_1.cs
│ ├── UnityEvent_2.cs
│ ├── UnityEvent_3.cs
│ └── UnityEvent_4.cs
└── third-party-notices.txt
================================================
FILE CONTENTS
================================================
================================================
FILE: Editor/IncrementalBuildPipeline/BeeBuildProgramCommon.Data/BeeBuildProgramCommon.Data.gen.csproj
================================================
BeeBuildProgramCommon.Data
netstandard2.1
false
false
false
latest
1701
================================================
FILE: Editor/IncrementalBuildPipeline/BeeBuildProgramCommon.Data/Data.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
namespace BeeBuildProgramCommon.Data
{
public class PackageInfo
{
public string Name;
public string ResolvedPath;
}
public struct Version
{
public int Release, Major, Minor;
public Version(int release, int major, int minor)
{
Release = release;
Major = major;
Minor = minor;
}
}
public class ConfigurationData
{
public string Il2CppDir;
public string UnityLinkerPath;
public string Il2CppPath;
public string NetCoreRunPath;
public string DotNetExe;
public string EditorContentsPath;
public PackageInfo[] Packages;
public string UnityVersion;
public Version UnityVersionNumeric;
public string UnitySourceCodePath;
public bool Batchmode;
public bool EmitDataForBeeWhy;
public string NamedPipeOrUnixSocket;
}
}
================================================
FILE: Editor/IncrementalBuildPipeline/PlayerBuildProgramLibrary.Data/Data.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
namespace PlayerBuildProgramLibrary.Data
{
public class Plugin
{
public string AssetPath;
public string DestinationPath;
public string Architecture;
public string CompileFlags;
public bool AddToEmbeddedBinaries;
public override string ToString()
{
return $"'{AssetPath} -> '{DestinationPath}' ({Architecture})";
}
}
public class PluginsData
{
public Plugin[] Plugins = new Plugin[0];
}
public class GenerateNativePluginsForAssembliesArgs
{
public string PluginOutputFolder;
public string SymbolOutputFolder;
public string[] Assemblies;
}
public class GenerateNativePluginsForAssembliesSettings
{
public bool HasCallback;
public string DisplayName;
public string[] AdditionalInputFiles = new string[0];
}
public class PlayerBuildConfig
{
public string DestinationPath;
public string StagingArea;
public string DataFolder;
public string CompanyName;
public string ProductName;
public string PlayerPackage;
public string ApplicationIdentifier;
public string Architecture;
public ScriptingBackend ScriptingBackend;
public bool NoGUID;
public bool InstallIntoBuildsFolder;
public bool GenerateIdeProject;
public bool Development;
public bool UseNewInputSystem;
public GenerateNativePluginsForAssembliesSettings GenerateNativePluginsForAssembliesSettings;
public Services Services;
public string[] ManagedAssemblies;
public StreamingAssetsFile[] StreamingAssetsFiles;
}
public class BuiltFilesOutput
{
public string[] Files = new string[0];
public string BootConfigArtifact;
}
public class LinkerConfig
{
public string[] LinkXmlFiles = new string[0];
public string[] AssembliesToProcess = new string[0];
public string EditorToLinkerData;
public string Runtime;
public string Profile;
public string Ruleset;
public string ModulesAssetPath;
public string[] AdditionalArgs = new string[0];
public bool AllowDebugging;
public bool PerformEngineStripping;
}
public class Il2CppConfig
{
public bool EnableDeepProfilingSupport;
public bool EnableFullGenericSharing;
public string Profile;
public string[] IDEProjectDefines;
public string ConfigurationName;
public bool GcWBarrierValidation;
public bool GcIncremental;
public string[] AdditionalCppFiles = new string[0];
public string[] AdditionalArgs = new string[0];
public string CompilerFlags;
public string[] AdditionalLibraries;
public string[] AdditionalDefines;
public string[] AdditionalIncludeDirectories;
public string[] AdditionalLinkDirectories;
public string LinkerFlags;
public string LinkerFlagsFile;
public string ExtraTypes;
public bool CreateSymbolFiles;
public bool AllowDebugging;
public string SysRootPath;
public string ToolChainPath;
public string RelativeDataPath;
public bool GenerateUsymFile;
public string UsymtoolPath;
}
public class Services
{
public bool EnableUnityConnect;
public bool EnablePerformanceReporting;
public bool EnableAnalytics;
public bool EnableCrashReporting;
public bool EnableInsights;
}
public class StreamingAssetsFile
{
public string File;
public string RelativePath;
}
public enum ScriptingBackend
{
Mono,
IL2CPP,
CoreCLR,
}
}
================================================
FILE: Editor/IncrementalBuildPipeline/PlayerBuildProgramLibrary.Data/PlayerBuildProgramLibrary.Data.gen.csproj
================================================
PlayerBuildProgramLibrary.Data
netstandard2.1
false
false
false
latest
1701
PlayerBuildProgramLibrary.Data
================================================
FILE: Editor/IncrementalBuildPipeline/ScriptCompilationBuildProgram.Data/Data.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
namespace ScriptCompilationBuildProgram.Data
{
public static class Constants
{
public const string ScriptAssembliesTarget = "ScriptAssemblies";
public const string ScriptAssembliesAndTypeDBTarget = "ScriptAssembliesAndTypeDB";
public const string MovedFromExtension = "mvfrm";
}
public class ScriptCompilationData
{
public AssemblyData[] Assemblies;
public AssemblyData[] CodegenAssemblies;
public string DotnetRuntimePath;
public string DotnetRoslynPath;
public string MovedFromExtractorPath;
public string OutputDirectory;
public bool Debug;
public string BuildTarget;
public string Localization;
public string BuildPlayerDataOutput;
public bool ExtractRuntimeInitializeOnLoads;
public bool EnableDiagnostics;
public bool EmitInfoForScriptUpdater;
public string[] AssembliesToScanForTypeDB;
public string[] SearchPaths;
}
public class AssemblyData
{
public string Name;
public string[] SourceFiles = new string[0];
public string[] Defines = new string[0];
public string[] PrebuiltReferences = new string[0];
public int[] References = new int[0];
public bool AllowUnsafeCode;
public string RuleSet;
public string AnalyzerConfigPath;
public string LanguageVersion;
public bool UseDeterministicCompilation;
public bool SuppressCompilerWarnings;
public string[] Analyzers = new string[0];
public string[] AdditionalFiles = new string[0];
public string Asmdef;
public string[] BclDirectories = new string[0];
public string[] CustomCompilerOptions = new string[0];
public int DebugIndex;
public bool SkipCodeGen;
public string Path;
}
public class ScriptCompilationData_Out
{
public AssemblyData_Out[] Assemblies;
public bool LocalizeCompilerMessages;
}
public class AssemblyData_Out
{
public string Path;
public string ScriptUpdaterRsp;
public string MovedFromExtractorFile;
}
}
================================================
FILE: Editor/IncrementalBuildPipeline/ScriptCompilationBuildProgram.Data/ScriptCompilationBuildProgram.Data.gen.csproj
================================================
ScriptCompilationBuildProgram.Data
netstandard2.1
false
false
false
latest
1701
================================================
FILE: Editor/Mono/2D/Common/ScriptBindings/SpriteEditorExtension.bindings.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using UnityEngine;
using UnityEngine.Bindings;
using UnityEngine.U2D;
namespace UnityEditor.U2D
{
[NativeHeader("Editor/Src/2D/SpriteEditorExtension.h")]
public static class SpriteEditorExtension
{
public static GUID GetSpriteID(this Sprite sprite)
{
return new GUID(GetSpriteIDScripting(sprite));
}
public static void SetSpriteID(this Sprite sprite, GUID guid)
{
SetSpriteIDScripting(sprite, guid.ToString());
}
private static extern string GetSpriteIDScripting([NotNull] Sprite sprite);
private static extern void SetSpriteIDScripting([NotNull] Sprite sprite, string spriteID);
internal static extern SpriteAtlas GetActiveAtlas([NotNull] this Sprite sprite);
internal static extern string GetActiveAtlasName([NotNull] this Sprite sprite);
internal static extern Texture2D GetActiveAtlasTexture([NotNull] this Sprite sprite);
internal static extern Rect GetActiveAtlasTextureRect([NotNull] this Sprite sprite);
internal static extern Vector2 GetActiveAtlasTextureRectOffset([NotNull] this Sprite sprite);
internal static extern Texture2D GetActiveAtlasAlphaTexture([NotNull] this Sprite sprite);
}
}
================================================
FILE: Editor/Mono/2D/Common/SpriteEditorUtility.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
using UnityEditor;
using UnityEngine;
using UnityEngine.Assertions;
using Object = UnityEngine.Object;
namespace UnityEditorInternal
{
static internal class SpriteEditorUtility
{
public static Vector2 GetPivotValue(SpriteAlignment alignment, Vector2 customOffset)
{
switch (alignment)
{
case SpriteAlignment.BottomLeft:
return new Vector2(0f, 0f);
case SpriteAlignment.BottomCenter:
return new Vector2(0.5f, 0f);
case SpriteAlignment.BottomRight:
return new Vector2(1f, 0f);
case SpriteAlignment.LeftCenter:
return new Vector2(0f, 0.5f);
case SpriteAlignment.Center:
return new Vector2(0.5f, 0.5f);
case SpriteAlignment.RightCenter:
return new Vector2(1f, 0.5f);
case SpriteAlignment.TopLeft:
return new Vector2(0f, 1f);
case SpriteAlignment.TopCenter:
return new Vector2(0.5f, 1f);
case SpriteAlignment.TopRight:
return new Vector2(1f, 1f);
case SpriteAlignment.Custom:
return customOffset;
}
return Vector2.zero;
}
public static Rect RoundedRect(Rect rect)
{
return new Rect(
Mathf.RoundToInt(rect.xMin),
Mathf.RoundToInt(rect.yMin),
Mathf.RoundToInt(rect.width),
Mathf.RoundToInt(rect.height)
);
}
public static Rect RoundToInt(Rect r)
{
r.xMin = Mathf.RoundToInt(r.xMin);
r.yMin = Mathf.RoundToInt(r.yMin);
r.xMax = Mathf.RoundToInt(r.xMax);
r.yMax = Mathf.RoundToInt(r.yMax);
return r;
}
public static Rect ClampedRect(Rect rect, Rect clamp, bool maintainSize)
{
Rect r = new Rect(rect);
if (maintainSize)
{
Vector2 center = rect.center;
if (center.x + Mathf.Abs(rect.width) * .5f > clamp.xMax)
center.x = clamp.xMax - rect.width * .5f;
if (center.x - Mathf.Abs(rect.width) * .5f < clamp.xMin)
center.x = clamp.xMin + rect.width * .5f;
if (center.y + Mathf.Abs(rect.height) * .5f > clamp.yMax)
center.y = clamp.yMax - rect.height * .5f;
if (center.y - Mathf.Abs(rect.height) * .5f < clamp.yMin)
center.y = clamp.yMin + rect.height * .5f;
r.center = center;
}
else
{
if (r.width > 0f)
{
r.xMin = Mathf.Max(rect.xMin, clamp.xMin);
r.xMax = Mathf.Min(rect.xMax, clamp.xMax);
}
else
{
r.xMin = Mathf.Min(rect.xMin, clamp.xMax);
r.xMax = Mathf.Max(rect.xMax, clamp.xMin);
}
if (r.height > 0f)
{
r.yMin = Mathf.Max(rect.yMin, clamp.yMin);
r.yMax = Mathf.Min(rect.yMax, clamp.yMax);
}
else
{
r.yMin = Mathf.Min(rect.yMin, clamp.yMax);
r.yMax = Mathf.Max(rect.yMax, clamp.yMin);
}
}
r.width = Mathf.Abs(r.width);
r.height = Mathf.Abs(r.height);
return r;
}
public static void DrawBox(Rect position)
{
Vector3[] points = new Vector3[5];
int i = 0;
points[i++] = new Vector3(position.xMin, position.yMin, 0f);
points[i++] = new Vector3(position.xMax, position.yMin, 0f);
points[i++] = new Vector3(position.xMax, position.yMax, 0f);
points[i++] = new Vector3(position.xMin, position.yMax, 0f);
DrawLine(points[0], points[1]);
DrawLine(points[1], points[2]);
DrawLine(points[2], points[3]);
DrawLine(points[3], points[0]);
}
public static void DrawLine(Vector3 p1, Vector3 p2)
{
Assert.IsTrue(Event.current.type == EventType.Repaint);
GL.Vertex(p1);
GL.Vertex(p2);
}
public static void BeginLines(Color color)
{
Assert.IsTrue(Event.current.type == EventType.Repaint);
HandleUtility.ApplyWireMaterial();
GL.PushMatrix();
GL.MultMatrix(Handles.matrix);
GL.Begin(GL.LINES);
GL.Color(color);
}
public static void EndLines()
{
Assert.IsTrue(Event.current.type == EventType.Repaint);
GL.End();
GL.PopMatrix();
}
public static void FourIntFields(Vector2 rectSize, GUIContent label, GUIContent labelX, GUIContent labelY, GUIContent labelZ, GUIContent labelW, ref int x, ref int y, ref int z, ref int w)
{
Rect rect = GUILayoutUtility.GetRect(rectSize.x, rectSize.y);
Rect labelRect = rect;
labelRect.width = EditorGUIUtility.labelWidth;
labelRect.height = EditorGUI.kSingleLineHeight;
GUI.Label(labelRect, label);
Rect fieldRect = rect;
fieldRect.width -= EditorGUIUtility.labelWidth;
fieldRect.height = EditorGUI.kSingleLineHeight;
fieldRect.x += EditorGUIUtility.labelWidth;
fieldRect.width /= 2;
fieldRect.width -= EditorGUI.kSpacingSubLabel;
float oldLabelWidth = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = EditorGUI.CalcPrefixLabelWidth(labelX);
GUI.SetNextControlName("FourIntFields_x");
x = EditorGUI.IntField(fieldRect, labelX, x);
fieldRect.x += fieldRect.width + EditorGUI.kSpacing;
GUI.SetNextControlName("FourIntFields_y");
y = EditorGUI.IntField(fieldRect, labelY, y);
fieldRect.y += EditorGUI.kSingleLineHeight + EditorGUI.kVerticalSpacingMultiField;
fieldRect.x -= fieldRect.width + EditorGUI.kSpacing;
GUI.SetNextControlName("FourIntFields_z");
z = EditorGUI.IntField(fieldRect, labelZ, z);
fieldRect.x += fieldRect.width + EditorGUI.kSpacing;
GUI.SetNextControlName("FourIntFields_w");
w = EditorGUI.IntField(fieldRect, labelW, w);
EditorGUIUtility.labelWidth = oldLabelWidth;
}
}
}
================================================
FILE: Editor/Mono/2D/Common/TexturePlatformSettingsController.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System.Collections.Generic;
using UnityEditor.U2D.Interface;
using UnityEngine;
using UnityEngine.Assertions;
using TargetAttributes = UnityEditor.BuildTargetDiscovery.TargetAttributes;
namespace UnityEditor.U2D.Common
{
internal class TexturePlatformSettingsViewController : ITexturePlatformSettingsController
{
public bool HandleDefaultSettings(List platformSettings, ITexturePlatformSettingsView view, ITexturePlatformSettingsFormatHelper formatHelper)
{
Assert.IsTrue(platformSettings.Count > 0, "At least 1 platform setting is needed to display the texture platform setting UI.");
var allSize = platformSettings[0].maxTextureSize;
var allFormat = platformSettings[0].format;
var allCompression = platformSettings[0].textureCompression;
var allUseCrunchedCompression = platformSettings[0].crunchedCompression;
var allCompressionQuality = platformSettings[0].compressionQuality;
var mixedSize = false;
var mixedFormat = false;
var mixedCompression = false;
var mixedUseCrunchedCompression = false;
var mixedCompressionQuality = false;
var sizeChanged = false;
var formatChanged = false;
var compressionChanged = false;
var useCrunchedCompressionChanged = false;
var compressionQualityChanged = false;
for (var i = 1; i < platformSettings.Count; ++i)
{
var settings = platformSettings[i];
if (settings.maxTextureSize != allSize)
mixedSize = true;
if (settings.format != allFormat)
mixedFormat = true;
if (settings.textureCompression != allCompression)
mixedCompression = true;
if (settings.crunchedCompression != allUseCrunchedCompression)
mixedUseCrunchedCompression = true;
if (settings.compressionQuality != allCompressionQuality)
mixedCompressionQuality = true;
}
allSize = view.DrawMaxSize(allSize, mixedSize, false, out sizeChanged);
int[] formatValues = null;
string[] formatStrings = null;
formatHelper.AcquireDefaultTextureFormatValuesAndStrings(out formatValues, out formatStrings);
allFormat = view.DrawFormat(allFormat, formatValues, formatStrings, mixedFormat, false, out formatChanged);
if (allFormat == TextureImporterFormat.Automatic && (!mixedFormat || formatChanged))
{
allCompression = view.DrawCompression(allCompression, mixedCompression, false, out compressionChanged);
if (allCompression != TextureImporterCompression.Uncompressed && (!mixedCompression || compressionChanged))
{
allUseCrunchedCompression = view.DrawUseCrunchedCompression(allUseCrunchedCompression,
mixedUseCrunchedCompression, false, out useCrunchedCompressionChanged);
if (allUseCrunchedCompression && (!mixedUseCrunchedCompression || useCrunchedCompressionChanged))
{
allCompressionQuality = view.DrawCompressionQualitySlider(allCompressionQuality,
mixedCompressionQuality, false, out compressionQualityChanged);
}
}
}
if (sizeChanged || compressionChanged || formatChanged || useCrunchedCompressionChanged || compressionQualityChanged)
{
for (var i = 0; i < platformSettings.Count; ++i)
{
if (sizeChanged)
platformSettings[i].maxTextureSize = allSize;
if (formatChanged)
platformSettings[i].format = allFormat;
if (compressionChanged)
platformSettings[i].textureCompression = allCompression;
if (useCrunchedCompressionChanged)
platformSettings[i].crunchedCompression = allUseCrunchedCompression;
if (compressionQualityChanged)
platformSettings[i].compressionQuality = allCompressionQuality;
}
return true;
}
else
return false;
}
public bool HandlePlatformSettings(BuildTarget buildTarget, List platformSettings, ITexturePlatformSettingsView view, ITexturePlatformSettingsFormatHelper formatHelper)
{
Assert.IsTrue(platformSettings.Count > 0, "At least 1 platform setting is needed to display the texture platform setting UI.");
var allOverride = platformSettings[0].overridden;
var allSize = platformSettings[0].maxTextureSize;
var allFormat = platformSettings[0].format;
var allCompressionQuality = platformSettings[0].compressionQuality;
var allAlphaSplit = platformSettings[0].allowsAlphaSplitting;
var mixedOverride = false;
var mixedSize = false;
var mixedFormat = false;
var mixedCompression = false;
var mixedAlphaSplit = false;
var overrideChanged = false;
var sizeChanged = false;
var formatChanged = false;
var compressionChanged = false;
var alphaSplitChanged = false;
for (var i = 1; i < platformSettings.Count; ++i)
{
var settings = platformSettings[i];
if (settings.overridden != allOverride)
mixedOverride = true;
if (settings.maxTextureSize != allSize)
mixedSize = true;
if (settings.format != allFormat)
mixedFormat = true;
if (settings.compressionQuality != allCompressionQuality)
mixedCompression = true;
if (settings.allowsAlphaSplitting != allAlphaSplit)
mixedAlphaSplit = true;
}
allOverride = view.DrawOverride(allOverride, mixedOverride, out overrideChanged);
allSize = view.DrawMaxSize(allSize, mixedSize, mixedOverride || !allOverride, out sizeChanged);
int[] formatValues = null;
string[] formatStrings = null;
formatHelper.AcquireTextureFormatValuesAndStrings(buildTarget, out formatValues, out formatStrings);
allFormat = view.DrawFormat(allFormat, formatValues, formatStrings, mixedFormat, mixedOverride || !allOverride, out formatChanged);
if (!mixedFormat && formatHelper.TextureFormatRequireCompressionQualityInput(allFormat))
{
bool showAsEnum = BuildTargetDiscovery.PlatformHasFlag(buildTarget, TargetAttributes.HasIntegratedGPU);
if (showAsEnum)
{
var compressionMode = 1;
if (allCompressionQuality == (int)TextureCompressionQuality.Fast)
compressionMode = 0;
else if (allCompressionQuality == (int)TextureCompressionQuality.Best)
compressionMode = 2;
compressionMode = view.DrawCompressionQualityPopup(compressionMode, mixedCompression, mixedOverride || !allOverride, out compressionChanged);
if (compressionChanged)
{
switch (compressionMode)
{
case 0: allCompressionQuality = (int)TextureCompressionQuality.Fast; break;
case 1: allCompressionQuality = (int)TextureCompressionQuality.Normal; break;
case 2: allCompressionQuality = (int)TextureCompressionQuality.Best; break;
default:
Assert.IsTrue(false, "ITexturePlatformSettingsView.DrawCompressionQualityPopup should never return compression option value that's not 0, 1 or 2.");
break;
}
}
}
else
{
allCompressionQuality = view.DrawCompressionQualitySlider(allCompressionQuality, mixedCompression, mixedOverride || !allOverride, out compressionChanged);
}
// show the ETC1 split option only for sprites on platforms supporting ETC.
bool isETCPlatform = TextureImporter.IsETC1SupportedByBuildTarget(buildTarget);
bool isETCFormatSelected = TextureImporter.IsTextureFormatETC1Compression((TextureFormat)allFormat);
if (isETCPlatform && isETCFormatSelected)
{
allAlphaSplit = view.DrawAlphaSplit(allAlphaSplit, mixedAlphaSplit, mixedOverride || !allOverride, out alphaSplitChanged);
}
}
if (overrideChanged || sizeChanged || formatChanged || compressionChanged || alphaSplitChanged)
{
for (var i = 0; i < platformSettings.Count; ++i)
{
if (overrideChanged)
platformSettings[i].overridden = allOverride;
if (sizeChanged)
platformSettings[i].maxTextureSize = allSize;
if (formatChanged)
platformSettings[i].format = allFormat;
if (compressionChanged)
platformSettings[i].compressionQuality = allCompressionQuality;
if (alphaSplitChanged)
platformSettings[i].allowsAlphaSplitting = allAlphaSplit;
}
return true;
}
else
return false;
}
}
}
================================================
FILE: Editor/Mono/2D/Common/TexturePlatformSettingsFormatHelper.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using UnityEditor.U2D.Interface;
namespace UnityEditor.U2D.Common
{
internal class TexturePlatformSettingsFormatHelper : ITexturePlatformSettingsFormatHelper
{
public void AcquireTextureFormatValuesAndStrings(BuildTarget buildTarget, out int[] formatValues, out string[] formatStrings)
{
TextureImportValidFormats.GetPlatformTextureFormatValuesAndStrings(TextureImporterType.Sprite, buildTarget,
out formatValues, out formatStrings);
}
public void AcquireDefaultTextureFormatValuesAndStrings(out int[] formatValues, out string[] formatStrings)
{
TextureImportValidFormats.GetDefaultTextureFormatValuesAndStrings(TextureImporterType.Sprite,
out formatValues, out formatStrings);
}
public bool TextureFormatRequireCompressionQualityInput(TextureImporterFormat format)
{
return TextureImporterInspector.IsFormatRequireCompressionSetting(format);
}
}
}
================================================
FILE: Editor/Mono/2D/Common/TexturePlatformSettingsView.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
using UnityEngine;
using UnityEditor.U2D.Interface;
namespace UnityEditor.U2D.Common
{
internal class TexturePlatformSettingsView : ITexturePlatformSettingsView
{
class Styles
{
public readonly GUIContent textureFormatLabel = EditorGUIUtility.TrTextContent("Format");
public readonly GUIContent maxTextureSizeLabel = EditorGUIUtility.TrTextContent("Max Texture Size", "Maximum size of the packed texture.");
public readonly GUIContent compressionLabel = EditorGUIUtility.TrTextContent("Compression", "How will this texture be compressed?");
public readonly GUIContent useCrunchedCompressionLabel = EditorGUIUtility.TrTextContent("Use Crunch Compression", "Texture is crunch-compressed to save space on disk when applicable.");
public readonly GUIContent useAlphaSplitLabel = EditorGUIUtility.TrTextContent("Split Alpha Channel", "Alpha for this texture will be preserved by splitting the alpha channel to another texture, and both resulting textures will be compressed using ETC1.");
public readonly GUIContent compressionQualityLabel = EditorGUIUtility.TrTextContent("Compressor Quality");
public readonly GUIContent compressionQualitySliderLabel = EditorGUIUtility.TrTextContent("Compressor Quality", "Use the slider to adjust compression quality from 0 (Fastest) to 100 (Best)");
public readonly int[] kMaxTextureSizeValues = { 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384 };
public readonly GUIContent[] kMaxTextureSizeStrings;
public readonly GUIContent[] kTextureCompressionOptions =
{
EditorGUIUtility.TrTextContent("None", "Texture is not compressed."),
EditorGUIUtility.TrTextContent("Low Quality", "Texture compressed with low quality but high performance, high compression format."),
EditorGUIUtility.TrTextContent("Normal Quality", "Texture is compressed with a standard format."),
EditorGUIUtility.TrTextContent("High Quality", "Texture compressed with a high quality format."),
};
public readonly int[] kTextureCompressionValues =
{
(int)TextureImporterCompression.Uncompressed,
(int)TextureImporterCompression.CompressedLQ,
(int)TextureImporterCompression.Compressed,
(int)TextureImporterCompression.CompressedHQ
};
public readonly GUIContent[] kMobileCompressionQualityOptions =
{
EditorGUIUtility.TrTextContent("Fast"),
EditorGUIUtility.TrTextContent("Normal"),
EditorGUIUtility.TrTextContent("Best")
};
public Styles()
{
kMaxTextureSizeStrings = new GUIContent[kMaxTextureSizeValues.Length];
for (var i = 0; i < kMaxTextureSizeValues.Length; ++i)
kMaxTextureSizeStrings[i] = EditorGUIUtility.TextContent(string.Format("{0}", kMaxTextureSizeValues[i]));
}
}
private static Styles s_Styles;
public string buildPlatformTitle { get; set; }
internal TexturePlatformSettingsView()
{
s_Styles = s_Styles ?? new Styles();
}
public virtual TextureImporterCompression DrawCompression(TextureImporterCompression defaultValue, bool isMixedValue, bool isDisabled, out bool changed)
{
using (new EditorGUI.DisabledScope(isDisabled))
{
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = isMixedValue;
defaultValue = (TextureImporterCompression)EditorGUILayout.IntPopup(s_Styles.compressionLabel,
(int)defaultValue, s_Styles.kTextureCompressionOptions, s_Styles.kTextureCompressionValues);
EditorGUI.showMixedValue = false;
changed = EditorGUI.EndChangeCheck();
return defaultValue;
}
}
public virtual bool DrawUseCrunchedCompression(bool defaultValue, bool isMixedValue, bool isDisabled, out bool changed)
{
using (new EditorGUI.DisabledScope(isDisabled))
{
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = isMixedValue;
defaultValue = EditorGUILayout.Toggle(s_Styles.useCrunchedCompressionLabel, defaultValue);
EditorGUI.showMixedValue = false;
changed = EditorGUI.EndChangeCheck();
return defaultValue;
}
}
public virtual bool DrawOverride(bool defaultValue, bool isMixedValue, out bool changed)
{
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = isMixedValue;
defaultValue = EditorGUILayout.ToggleLeft(EditorGUIUtility.TempContent("Override for " + buildPlatformTitle), defaultValue);
EditorGUI.showMixedValue = false;
changed = EditorGUI.EndChangeCheck();
return defaultValue;
}
public virtual int DrawMaxSize(int defaultValue, bool isMixedValue, bool isDisabled, out bool changed)
{
using (new EditorGUI.DisabledScope(isDisabled))
{
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = isMixedValue;
defaultValue = EditorGUILayout.IntPopup(s_Styles.maxTextureSizeLabel, defaultValue,
s_Styles.kMaxTextureSizeStrings, s_Styles.kMaxTextureSizeValues);
EditorGUI.showMixedValue = false;
changed = EditorGUI.EndChangeCheck();
return defaultValue;
}
}
public virtual TextureImporterFormat DrawFormat(TextureImporterFormat defaultValue, int[] displayValues, string[] displayStrings, bool isMixedValue, bool isDisabled, out bool changed)
{
using (new EditorGUI.DisabledScope(isDisabled))
{
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = isMixedValue;
defaultValue = (TextureImporterFormat)EditorGUILayout.IntPopup(s_Styles.textureFormatLabel, (int)defaultValue, EditorGUIUtility.TempContent(displayStrings), displayValues);
EditorGUI.showMixedValue = false;
changed = EditorGUI.EndChangeCheck();
return defaultValue;
}
}
public virtual int DrawCompressionQualityPopup(int defaultValue, bool isMixedValue, bool isDisabled, out bool changed)
{
using (new EditorGUI.DisabledScope(isDisabled))
{
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = isMixedValue;
defaultValue = EditorGUILayout.Popup(s_Styles.compressionQualityLabel, defaultValue,
s_Styles.kMobileCompressionQualityOptions);
EditorGUI.showMixedValue = false;
changed = EditorGUI.EndChangeCheck();
return defaultValue;
}
}
public virtual int DrawCompressionQualitySlider(int defaultValue, bool isMixedValue, bool isDisabled, out bool changed)
{
using (new EditorGUI.DisabledScope(isDisabled))
{
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = isMixedValue;
defaultValue = EditorGUILayout.IntSlider(s_Styles.compressionQualitySliderLabel, defaultValue, 0, 100);
EditorGUI.showMixedValue = false;
changed = EditorGUI.EndChangeCheck();
return defaultValue;
}
}
public virtual bool DrawAlphaSplit(bool defaultValue, bool isMixedValue, bool isDisabled, out bool changed)
{
using (new EditorGUI.DisabledScope(isDisabled))
{
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = isMixedValue;
defaultValue = EditorGUILayout.Toggle(s_Styles.useAlphaSplitLabel, defaultValue);
EditorGUI.showMixedValue = false;
changed = EditorGUI.EndChangeCheck();
return defaultValue;
}
}
}
}
================================================
FILE: Editor/Mono/2D/Interface/IEvent.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
using UnityEngine;
using UnityEvent = UnityEngine.Event;
// We are putting this in the Editor folder for now since on SpriteEditorWindow et al. are using it
namespace UnityEngine.U2D.Interface
{
internal interface IEvent
{
EventType type { get; }
string commandName { get; }
bool control { get; }
bool alt { get; }
bool shift { get; }
KeyCode keyCode { get; }
Vector2 mousePosition { get; }
int button { get; }
EventModifiers modifiers { get; }
EventType GetTypeForControl(int id);
void Use();
}
internal class Event : IEvent
{
UnityEvent m_Event;
public Event()
{
m_Event = UnityEvent.current;
}
public EventType type
{
get { return m_Event.type; }
}
public string commandName
{
get { return m_Event.commandName; }
}
public bool control
{
get { return m_Event.control; }
}
public bool alt
{
get { return m_Event.alt; }
}
public bool shift
{
get { return m_Event.shift; }
}
public KeyCode keyCode
{
get { return m_Event.keyCode; }
}
public Vector2 mousePosition
{
get { return m_Event.mousePosition; }
}
public int button
{
get { return m_Event.button; }
}
public void Use()
{
m_Event.Use();
}
public EventModifiers modifiers
{
get { return m_Event.modifiers; }
}
public EventType GetTypeForControl(int id)
{
return m_Event.GetTypeForControl(id);
}
}
internal interface IEventSystem
{
IEvent current { get; }
}
internal class EventSystem : IEventSystem
{
public IEvent current
{
get { return new Event(); }
}
}
}
================================================
FILE: Editor/Mono/2D/Interface/ITexturePlatformSetting.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System.Collections.Generic;
using UnityEngine;
namespace UnityEditor.U2D.Interface
{
internal interface ITexturePlatformSettingsView
{
string buildPlatformTitle { get; set; }
TextureImporterCompression DrawCompression(TextureImporterCompression defaultValue, bool isMixedValue, bool isDisabled, out bool changed);
bool DrawUseCrunchedCompression(bool defaultValue, bool isMixedValue, bool isDisabled, out bool changed);
bool DrawAlphaSplit(bool defaultValue, bool isMixedValue, bool isDisabled, out bool changed);
bool DrawOverride(bool defaultValue, bool isMixedValue, out bool changed);
int DrawMaxSize(int defaultValue, bool isMixedValue, bool isDisabled, out bool changed);
TextureImporterFormat DrawFormat(TextureImporterFormat defaultValue, int[] displayValues, string[] displayStrings, bool isMixedValue, bool isDisabled, out bool changed);
int DrawCompressionQualityPopup(int defaultValue, bool isMixedValue, bool isDisabled, out bool changed);
int DrawCompressionQualitySlider(int defaultValue, bool isMixedValue, bool isDisabled, out bool changed);
}
internal interface ITexturePlatformSettingsFormatHelper
{
void AcquireTextureFormatValuesAndStrings(BuildTarget buildTarget, out int[] displayValues, out string[] displayStrings);
void AcquireDefaultTextureFormatValuesAndStrings(out int[] formatValues, out string[] formatStrings);
bool TextureFormatRequireCompressionQualityInput(TextureImporterFormat format);
}
internal interface ITexturePlatformSettingsController
{
bool HandleDefaultSettings(List platformSettings, ITexturePlatformSettingsView view, ITexturePlatformSettingsFormatHelper formatHelper);
bool HandlePlatformSettings(BuildTarget buildTarget, List platformSettings, ITexturePlatformSettingsView view, ITexturePlatformSettingsFormatHelper formatHelper);
}
}
================================================
FILE: Editor/Mono/2D/SpriteAtlas/EditorSpriteAtlas.bindings.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System.Runtime.InteropServices;
using UnityEngine;
using UnityEngine.U2D;
using UnityEngine.Bindings;
using System;
using UnityEditor.AssetImporters;
namespace UnityEditor.U2D
{
[NativeHeader("Runtime/2D/SpriteAtlas/SpriteAtlas.h")]
[NativeHeader("Editor/Src/2D/SpriteAtlas/SpriteAtlasPackingUtilities.h")]
public class SpriteAtlasUtility
{
[FreeFunction("SpriteAtlasExtensions::EnableV2Import")]
extern internal static void EnableV2Import(bool onOff);
[FreeFunction("SpriteAtlasExtensions::CleanupAtlasPacking")]
extern public static void CleanupAtlasPacking();
[FreeFunction("CollectAllSpriteAtlasesAndPack")]
extern public static void PackAllAtlases(BuildTarget target, bool canCancel = true);
[FreeFunction("PackSpriteAtlases")]
extern internal static void PackAtlasesInternal(SpriteAtlas[] atlases, BuildTarget target, bool canCancel = true, bool invokedFromImporter = false, bool unloadSprites = false);
public static void PackAtlases(SpriteAtlas[] atlases, BuildTarget target, bool canCancel = true)
{
if (atlases == null)
throw new ArgumentNullException("atlases", "Value for parameter atlases is null");
foreach (var atlas in atlases)
if (atlas == null)
throw new ArgumentNullException("atlases", "One of the elements in atlases is null. Please check your Inputs.");
PackAtlasesInternal(atlases, target, canCancel, false, true);
}
}
[StructLayout(LayoutKind.Sequential)]
public struct SpriteAtlasTextureSettings
{
[NativeName("anisoLevel")]
private int m_AnisoLevel;
[NativeName("compressionQuality")]
private int m_CompressionQuality;
[NativeName("maxTextureSize")]
private int m_MaxTextureSize;
[NativeName("textureCompression")]
private int m_TextureCompression;
[NativeName("filterMode")]
private int m_FilterMode;
[NativeName("generateMipMaps")]
private bool m_GenerateMipMaps;
[NativeName("readable")]
private bool m_Readable;
[NativeName("crunchedCompression")]
private bool m_CrunchedCompression;
[NativeName("sRGB")]
private bool m_sRGB;
public int maxTextureSize { get { return m_MaxTextureSize; } }
public int anisoLevel { get { return m_AnisoLevel; } set { m_AnisoLevel = value; } }
public FilterMode filterMode { get { return (FilterMode)m_FilterMode; } set { m_FilterMode = (int)value; } }
public bool generateMipMaps { get { return m_GenerateMipMaps; } set { m_GenerateMipMaps = value; } }
public bool readable { get { return m_Readable; } set { m_Readable = value; } }
public bool sRGB { get { return m_sRGB; } set { m_sRGB = value; } }
}
[StructLayout(LayoutKind.Sequential)]
public struct SpriteAtlasPackingSettings
{
[NativeName("blockOffset")]
private int m_BlockOffset;
[NativeName("padding")]
private int m_Padding;
[NativeName("allowAlphaSplitting")]
private bool m_AllowAlphaSplitting;
[NativeName("enableRotation")]
private bool m_EnableRotation;
[NativeName("enableTightPacking")]
private bool m_EnableTightPacking;
[NativeName("enableAlphaDilation")]
private bool m_EnableAlphaDilation;
public int blockOffset { get { return m_BlockOffset; } set { m_BlockOffset = value; } }
public int padding { get { return m_Padding; } set { m_Padding = value; } }
public bool enableRotation { get { return m_EnableRotation; } set { m_EnableRotation = value; } }
public bool enableTightPacking { get { return m_EnableTightPacking; } set { m_EnableTightPacking = value; } }
public bool enableAlphaDilation { get { return m_EnableAlphaDilation; } set { m_EnableAlphaDilation = value; } }
}
[NativeHeader("Editor/Src/AssetPipeline/TextureImporting/TextureImporterTypes.h")]
[NativeHeader("Editor/Src/AssetPipeline/TextureImporting/TextureImporter.bindings.h")]
[NativeHeader("Editor/Src/2D/SpriteAtlas/SpriteAtlas_EditorTypes.h")]
[NativeHeader("Runtime/2D/SpriteAtlas/SpriteAtlas.h")]
public static class SpriteAtlasExtensions
{
extern public static void Add([NotNull] this SpriteAtlas spriteAtlas, UnityEngine.Object[] objects);
extern public static void Remove([NotNull] this SpriteAtlas spriteAtlas, UnityEngine.Object[] objects);
extern internal static void RemoveAt([NotNull] this SpriteAtlas spriteAtlas, int index);
extern public static UnityEngine.Object[] GetPackables([NotNull] this SpriteAtlas spriteAtlas);
extern internal static void SetV2([NotNull] this SpriteAtlas spriteAtlas);
internal static void RegisterAndPackAtlas(this SpriteAtlas spriteAtlas, AssetImportContext context, AssetImporter importer, U2D.ScriptablePacker scriptablePacker)
{
RegisterAndPackAtlasInternal(spriteAtlas, context, importer, scriptablePacker);
}
extern private static void RegisterAndPackAtlasInternal([NotNull] this SpriteAtlas spriteAtlas, [NotNull] AssetImportContext context, [NotNull] AssetImporter importer, UnityEngine.Object scriptablePacker);
extern public static SpriteAtlasTextureSettings GetTextureSettings([NotNull] this SpriteAtlas spriteAtlas);
extern public static void SetTextureSettings([NotNull] this SpriteAtlas spriteAtlas, SpriteAtlasTextureSettings src);
extern public static SpriteAtlasPackingSettings GetPackingSettings([NotNull] this SpriteAtlas spriteAtlas);
extern public static void SetPackingSettings([NotNull] this SpriteAtlas spriteAtlas, SpriteAtlasPackingSettings src);
[NativeName("GetPlatformSettings")]
extern private static TextureImporterPlatformSettings GetPlatformSettings_Internal([NotNull] this SpriteAtlas spriteAtlas, string buildTarget);
public static TextureImporterPlatformSettings GetPlatformSettings(this SpriteAtlas spriteAtlas, string buildTarget)
{
buildTarget = TextureImporter.GetTexturePlatformSerializationName(buildTarget); // String may refer to a platform group: if != "Standalone", ensure it refers to a platform instead. E.g.: "iOS", not "iPhone".
return GetPlatformSettings_Internal(spriteAtlas, buildTarget);
}
[NativeName("SetPlatformSettings")]
extern private static void SetPlatformSettings_Internal([NotNull] this SpriteAtlas spriteAtlas, TextureImporterPlatformSettings src);
public static void SetPlatformSettings(this SpriteAtlas spriteAtlas, TextureImporterPlatformSettings src)
{
src.name = TextureImporter.GetTexturePlatformSerializationName(src.name); // String may refer to a platform group: if != "Standalone", ensure it refers to a platform instead. E.g.: "iOS", not "iPhone".
SetPlatformSettings_Internal(spriteAtlas, src);
}
extern public static void SetIncludeInBuild([NotNull] this SpriteAtlas spriteAtlas, bool value);
extern public static void SetIsVariant([NotNull] this SpriteAtlas spriteAtlas, bool value);
extern public static void SetMasterAtlas([NotNull] this SpriteAtlas spriteAtlas, SpriteAtlas value);
extern public static void SetVariantScale([NotNull] this SpriteAtlas spriteAtlas, float value);
extern public static bool IsIncludeInBuild([NotNull] this SpriteAtlas spriteAtlas);
extern public static SpriteAtlas GetMasterAtlas([NotNull] this SpriteAtlas spriteAtlas);
extern internal static void CopyMasterAtlasSettings([NotNull] this SpriteAtlas spriteAtlas);
extern internal static string GetHash([NotNull] this SpriteAtlas spriteAtlas);
extern internal static Texture2D[] GetPreviewTextures([NotNull] this SpriteAtlas spriteAtlas);
extern internal static Texture2D[] GetPreviewAlphaTextures([NotNull] this SpriteAtlas spriteAtlas);
extern internal static TextureFormat GetTextureFormat([NotNull] this SpriteAtlas spriteAtlas, BuildTarget target);
extern internal static Sprite[] GetPackedSprites([NotNull] this SpriteAtlas spriteAtlas);
extern internal static Hash128 GetStoredHash([NotNull] this SpriteAtlas spriteAtlas);
[NativeName("GetSecondaryPlatformSettings")]
extern private static TextureImporterPlatformSettings GetSecondaryPlatformSettings_Internal([NotNull] this SpriteAtlas spriteAtlas, string buildTarget, string secondaryTextureName);
internal static TextureImporterPlatformSettings GetSecondaryPlatformSettings(this SpriteAtlas spriteAtlas, string buildTarget, string secondaryTextureName)
{
buildTarget = TextureImporter.GetTexturePlatformSerializationName(buildTarget); // String may refer to a platform group: if != "Standalone", ensure it refers to a platform instead. E.g.: "iOS", not "iPhone".
return GetSecondaryPlatformSettings_Internal(spriteAtlas, buildTarget, secondaryTextureName);
}
[NativeName("SetSecondaryPlatformSettings")]
extern private static void SetSecondaryPlatformSettings_Internal([NotNull] this SpriteAtlas spriteAtlas, TextureImporterPlatformSettings src, string secondaryTextureName);
internal static void SetSecondaryPlatformSettings(this SpriteAtlas spriteAtlas, TextureImporterPlatformSettings src, string secondaryTextureName)
{
src.name = TextureImporter.GetTexturePlatformSerializationName(src.name); // String may refer to a platform group: if != "Standalone", ensure it refers to a platform instead. E.g.: "iOS", not "iPhone".
SetSecondaryPlatformSettings_Internal(spriteAtlas, src, secondaryTextureName);
}
extern internal static bool GetSecondaryColorSpace([NotNull] this SpriteAtlas spriteAtlas, string secondaryTextureName);
extern internal static void SetSecondaryColorSpace([NotNull] this SpriteAtlas spriteAtlas, string secondaryTextureName, bool srGB);
extern internal static void DeleteSecondaryPlatformSettings([NotNull] this SpriteAtlas spriteAtlas, string secondaryTextureName);
extern internal static string GetSecondaryTextureNameInAtlas(string atlasTextureName);
extern internal static string GetPageNumberInAtlas(string atlasTextureName);
}
}
================================================
FILE: Editor/Mono/2D/SpriteAtlas/EditorSpritePacking.bindings.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using Unity.Collections;
using UnityEngine;
using UnityEngine.U2D;
using UnityEngine.Bindings;
using UnityEngine.Scripting;
using Unity.Collections.LowLevel.Unsafe;
namespace UnityEditor.U2D.SpritePacking
{
[RequiredByNativeCode]
[StructLayout(LayoutKind.Sequential)]
internal struct SpritePackInfoInternal
{
public int guid;
public int texIndex;
public int indexCount;
public int vertexCount;
public RectInt rect;
public IntPtr indices;
public IntPtr vertices;
};
[RequiredByNativeCode]
[StructLayout(LayoutKind.Sequential)]
internal struct SpritePackTextureInfoInternal
{
public int width;
public int height;
public IntPtr buffer;
};
[RequiredByNativeCode]
[StructLayout(LayoutKind.Sequential)]
internal struct SpritePackDatasetInternal
{
public SpritePackInfoInternal spriteData;
public SpritePackTextureInfoInternal textureData;
};
[StructLayout(LayoutKind.Sequential)]
internal struct SpritePackInfo
{
public int guid;
public int texIndex;
public int indexCount;
public int vertexCount;
public RectInt rect;
public NativeArray indices;
public NativeArray vertices;
};
[StructLayout(LayoutKind.Sequential)]
internal struct SpritePackTextureInfo
{
public int width;
public int height;
public NativeArray buffer;
};
internal struct SpritePackDataset
{
public List spriteData;
public List textureData;
};
internal struct SpritePackConfig
{
public int padding;
};
[NativeHeader("Runtime/2D/SpriteAtlas/SpriteAtlas.h")]
[NativeHeader("Editor/Src/2D/SpriteAtlas/SpriteAtlasPackingUtilities.h")]
internal class SpritePackUtility
{
internal unsafe static SpritePackDataset PackCustomSpritesWrapper(SpritePackDataset input, SpritePackConfig packConfig, Allocator alloc)
{
var output = new SpritePackDataset();
var spriteCount = input.spriteData.Count;
if (0 == spriteCount)
return output;
var data = new NativeArray(spriteCount, Allocator.Temp, NativeArrayOptions.ClearMemory);
for (int i = 0; i < spriteCount; ++i)
{
SpritePackDatasetInternal rawData = data[i];
rawData.spriteData.guid = input.spriteData[i].guid;
int texIndex = input.spriteData[i].texIndex;
if (texIndex >= input.textureData.Count)
{
data.Dispose();
throw new ArgumentOutOfRangeException("texIndex", "texIndex must point to a valid index in textureData list.");
}
rawData.spriteData.texIndex = texIndex;
rawData.spriteData.indexCount = input.spriteData[i].indexCount;
rawData.spriteData.vertexCount = input.spriteData[i].vertexCount;
rawData.spriteData.rect = input.spriteData[i].rect;
rawData.spriteData.indices = input.spriteData[i].indices.IsCreated ? (IntPtr)input.spriteData[i].indices.GetUnsafePtr() : (IntPtr)0;
rawData.spriteData.vertices = input.spriteData[i].vertices.IsCreated ? (IntPtr)input.spriteData[i].vertices.GetUnsafePtr() : (IntPtr)0;
rawData.textureData.width = input.textureData[texIndex].width;
rawData.textureData.height = input.textureData[texIndex].height;
rawData.textureData.buffer = input.textureData[texIndex].buffer.IsCreated ? (IntPtr)input.textureData[texIndex].buffer.GetUnsafePtr() : (IntPtr)0;
data[i] = rawData;
}
var spriteOutput = (SpritePackDatasetInternal*)PackCustomSpritesInternal(spriteCount, (SpritePackDatasetInternal*)data.GetUnsafePtr(), packConfig);
if (null != spriteOutput)
{
var colorBufferArray = new SpritePackTextureInfo[spriteCount];
for (int i = 0; i < spriteCount; ++i)
{
SpritePackTextureInfoInternal rawBuffer = spriteOutput[i].textureData;
int index = spriteOutput[i].spriteData.texIndex;
SpritePackTextureInfo outputBuffer = colorBufferArray[index];
// New Texture. Copy.
if (!outputBuffer.buffer.IsCreated)
{
outputBuffer.width = rawBuffer.width;
outputBuffer.height = rawBuffer.height;
Color32* rawColor = (Color32*)rawBuffer.buffer;
if (null != rawColor)
{
outputBuffer.buffer = new NativeArray(rawBuffer.width * rawBuffer.height, alloc);
UnsafeUtility.MemCpy(outputBuffer.buffer.GetUnsafePtr(), rawColor, rawBuffer.width * rawBuffer.height * sizeof(Color32));
}
UnsafeUtility.Free((void*)rawBuffer.buffer, Allocator.Persistent);
}
colorBufferArray[index] = outputBuffer;
}
output.textureData = new List(colorBufferArray);
var spriteDataArray = new SpritePackInfo[spriteCount];
for (int i = 0; i < spriteCount; ++i)
{
SpritePackInfo spriteData = spriteDataArray[i];
spriteData.guid = spriteOutput[i].spriteData.guid;
spriteData.indexCount = spriteOutput[i].spriteData.indexCount;
spriteData.vertexCount = spriteOutput[i].spriteData.vertexCount;
spriteData.rect = spriteOutput[i].spriteData.rect;
if (0 != spriteData.indexCount && 0 != spriteData.vertexCount)
{
int* rawIndices = (int*)spriteOutput[i].spriteData.indices;
if (null != rawIndices)
{
spriteData.indices = new NativeArray(spriteOutput[i].spriteData.indexCount, alloc);
UnsafeUtility.MemCpy(spriteData.indices.GetUnsafePtr(), rawIndices, spriteOutput[i].spriteData.indexCount * sizeof(int));
}
Vector3* rawVertices = (Vector3*)spriteOutput[i].spriteData.vertices;
if (null != rawVertices)
{
spriteData.vertices = new NativeArray(spriteOutput[i].spriteData.vertexCount, alloc);
UnsafeUtility.MemCpy(spriteData.vertices.GetUnsafePtr(), rawVertices, spriteOutput[i].spriteData.vertexCount * sizeof(Vector3));
}
UnsafeUtility.Free((void*)spriteOutput[i].spriteData.indices, Allocator.Persistent);
UnsafeUtility.Free((void*)spriteOutput[i].spriteData.vertices, Allocator.Persistent);
}
spriteData.texIndex = spriteOutput[i].spriteData.texIndex;
spriteDataArray[i] = spriteData;
}
output.spriteData = new List(spriteDataArray);
UnsafeUtility.Free((void*)spriteOutput, Allocator.Persistent);
}
data.Dispose();
return output;
}
internal static SpritePackDataset PackCustomSprites(SpritePackDataset spriteDataInput, SpritePackConfig packConfig, Allocator outputAlloc)
{
return PackCustomSpritesWrapper(spriteDataInput, packConfig, outputAlloc);
}
[NativeThrows]
[FreeFunction("PackCustomSprites")]
extern internal unsafe static IntPtr PackCustomSpritesInternal(int spriteCount, SpritePackDatasetInternal* data, SpritePackConfig packConfig);
}
}
================================================
FILE: Editor/Mono/2D/SpriteAtlas/SpriteAtlasAsset.bindings.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using UnityEngine;
using UnityEngine.Bindings;
using UnityEngine.Scripting;
using UnityEngine.U2D;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Collections;
namespace UnityEditor.U2D
{
[UsedByNativeCode]
public abstract class ScriptablePacker : ScriptableObject
{
public enum PackTransform
{
None = 0,
FlipHorizontal = 1,
FlipVertical = 2,
Rotate180 = 3,
}
[RequiredByNativeCode]
[StructLayout(LayoutKind.Sequential)]
public struct SpritePack
{
public int x;
public int y;
public int page;
public PackTransform rot;
};
[RequiredByNativeCode]
[StructLayout(LayoutKind.Sequential)]
public struct SpriteData
{
public int guid;
public int texIndex;
public int indexCount;
public int vertexCount;
public int indexOffset;
public int vertexOffset;
public RectInt rect;
public SpritePack output;
};
[RequiredByNativeCode]
[StructLayout(LayoutKind.Sequential)]
public struct TextureData
{
public int width;
public int height;
public int bufferOffset;
};
[RequiredByNativeCode]
[StructLayout(LayoutKind.Sequential)]
internal struct PackerDataInternal
{
public int colorCount;
public IntPtr colorData;
public int spriteCount;
public IntPtr spriteData;
public int textureCount;
public IntPtr textureData;
public int indexCount;
public IntPtr indexData;
public int vertexCount;
public IntPtr vertexData;
};
[StructLayout(LayoutKind.Sequential)]
public struct PackerData
{
public NativeArray colorData;
public NativeArray spriteData;
public NativeArray textureData;
public NativeArray indexData;
public NativeArray vertexData;
};
// Public function to pack.
public abstract bool Pack(SpriteAtlasPackingSettings config, SpriteAtlasTextureSettings setting, PackerData input);
// Internal Glue function.
[RequiredByNativeCode]
internal bool PackInternal(SpriteAtlasPackingSettings config, SpriteAtlasTextureSettings setting, PackerDataInternal packerData)
{
var input = new PackerData();
unsafe
{
input.colorData = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray((void*)packerData.colorData, packerData.colorCount, Allocator.None);
input.spriteData = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray((void*)packerData.spriteData, packerData.spriteCount, Allocator.None);
input.textureData = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray((void*)packerData.textureData, packerData.textureCount, Allocator.None);
input.indexData = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray((void*)packerData.indexData, packerData.indexCount, Allocator.None);
input.vertexData = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray((void*)packerData.vertexData, packerData.vertexCount, Allocator.None);
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref input.colorData, AtomicSafetyHandle.GetTempMemoryHandle());
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref input.spriteData, AtomicSafetyHandle.GetTempMemoryHandle());
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref input.textureData, AtomicSafetyHandle.GetTempMemoryHandle());
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref input.indexData, AtomicSafetyHandle.GetTempMemoryHandle());
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref input.vertexData, AtomicSafetyHandle.GetTempMemoryHandle());
}
return Pack(config, setting, input);
}
};
// SpriteAtlas Importer lets you modify [[SpriteAtlas]]
[NativeHeader("Editor/Src/2D/SpriteAtlas/SpriteAtlasAsset.h")]
[NativeType(Header = "Editor/Src/2D/SpriteAtlas/SpriteAtlasAsset.h")]
public class SpriteAtlasAsset : UnityEngine.Object
{
public SpriteAtlasAsset() { Internal_Create(this); }
extern private static void Internal_Create([Writable] SpriteAtlasAsset self);
extern public bool isVariant { [NativeMethod("GetIsVariant")] get; }
extern public void SetIsVariant(bool value);
extern public void SetMasterAtlas(SpriteAtlas atlas);
extern public SpriteAtlas GetMasterAtlas();
extern internal UnityEngine.Object GetPacker();
extern internal void SetPacker(UnityEngine.Object obj);
extern public void Add(UnityEngine.Object[] objects);
extern public void Remove(UnityEngine.Object[] objects);
public void SetScriptablePacker(ScriptablePacker obj)
{
SetPacker(obj);
}
extern internal void RemoveAt(int index);
[Obsolete("SetVariantScale is no longer supported and will be removed. Use SpriteAtlasImporter.SetVariantScale instead.")]
public void SetVariantScale(float value) { }
[Obsolete("SetIncludeInBuild is no longer supported and will be removed. Use SpriteAtlasImporter.SetIncludeInBuild instead.")]
public void SetIncludeInBuild(bool value) { }
[Obsolete("IsIncludeInBuild is no longer supported and will be removed. Use SpriteAtlasImporter.IsIncludeInBuild instead.")]
public bool IsIncludeInBuild() { return true; }
[Obsolete("SetPlatformSettings is no longer supported and will be removed. Use SpriteAtlasImporter.SetPlatformSettings instead.")]
public void SetPlatformSettings(TextureImporterPlatformSettings src) { }
[Obsolete("SetTextureSettings is no longer supported and will be removed. Use SpriteAtlasImporter.SetTextureSettings instead.")]
public void SetTextureSettings(SpriteAtlasTextureSettings src) { }
[Obsolete("SetPackingSettings is no longer supported and will be removed. Use SpriteAtlasImporter.SetPackingSettings instead.")]
public void SetPackingSettings(SpriteAtlasPackingSettings src) { }
[Obsolete("GetPackingSettings is no longer supported and will be removed. Use SpriteAtlasImporter.GetPackingSettings instead.")]
public SpriteAtlasPackingSettings GetPackingSettings() { return new SpriteAtlasPackingSettings(); }
[Obsolete("GetTextureSettings is no longer supported and will be removed. Use SpriteAtlasImporter.GetTextureSettings instead.")]
public SpriteAtlasTextureSettings GetTextureSettings() { return new SpriteAtlasTextureSettings(); }
[Obsolete("GetPlatformSettings is no longer supported and will be removed. Use SpriteAtlasImporter.GetPlatformSettingss instead.")]
public TextureImporterPlatformSettings GetPlatformSettings(string buildTarget) { return new TextureImporterPlatformSettings(); }
// Load SpriteAtlasAsset
public static SpriteAtlasAsset Load(string assetPath)
{
var objs = UnityEditorInternal.InternalEditorUtility.LoadSerializedFileAndForget(assetPath);
return (objs.Length > 0) ? objs[0] as SpriteAtlasAsset : null;
}
public static void Save(SpriteAtlasAsset asset, string assetPath)
{
if (asset == null)
throw new ArgumentNullException("Parameter asset is null");
var objs = new UnityEngine.Object[] { asset };
UnityEditorInternal.InternalEditorUtility.SaveToSerializedFileAndForget(objs, assetPath, UnityEditor.EditorSettings.serializationMode != UnityEditor.SerializationMode.ForceBinary);
}
}
};
================================================
FILE: Editor/Mono/2D/SpriteAtlas/SpriteAtlasImporter.bindings.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
using System.Collections.Generic;
using System.ComponentModel;
using UnityEditor.Build;
using UnityEditor.AssetImporters;
using UnityEngine;
using UnityEngine.Bindings;
using UnityEngine.Scripting;
using UnityEngine.U2D;
namespace UnityEditor.U2D
{
// SpriteAtlas Importer lets you modify [[SpriteAtlas]]
[HelpURL("https://docs.unity3d.com/6000.2/Documentation/Manual/sprite/atlas/v2/sprite-atlas-v2.html")]
[NativeHeader("Editor/Src/2D/SpriteAtlas/SpriteAtlasImporter.h")]
public sealed partial class SpriteAtlasImporter : AssetImporter
{
extern internal static void MigrateAllSpriteAtlases();
extern public float variantScale { get; set; }
extern public bool includeInBuild { get; set; }
extern public SpriteAtlasPackingSettings packingSettings { get; set; }
extern public SpriteAtlasTextureSettings textureSettings { get; set; }
[NativeName("SetPlatformSettings")]
extern private void SetPlatformSettings_Internal(TextureImporterPlatformSettings src);
public void SetPlatformSettings(TextureImporterPlatformSettings src)
{
src.name = TextureImporter.GetTexturePlatformSerializationName(src.name); // String may refer to a platform group: if != "Standalone", ensure it refers to a platform instead. E.g.: "iOS", not "iPhone".
SetPlatformSettings_Internal(src);
}
[NativeName("GetPlatformSettings")]
extern private TextureImporterPlatformSettings GetPlatformSettings_Internal(string buildTarget);
public TextureImporterPlatformSettings GetPlatformSettings(string buildTarget)
{
buildTarget = TextureImporter.GetTexturePlatformSerializationName(buildTarget); // String may refer to a platform group: if != "Standalone", ensure it refers to a platform instead. E.g.: "iOS", not "iPhone".
return GetPlatformSettings_Internal(buildTarget);
}
extern internal TextureFormat GetTextureFormat(BuildTarget target);
[NativeName("GetSecondaryPlatformSettings")]
extern private TextureImporterPlatformSettings GetSecondaryPlatformSettings_Internal(string buildTarget, string secondaryTextureName);
internal TextureImporterPlatformSettings GetSecondaryPlatformSettings(string buildTarget, string secondaryTextureName)
{
buildTarget = TextureImporter.GetTexturePlatformSerializationName(buildTarget); // String may refer to a platform group: if != "Standalone", ensure it refers to a platform instead. E.g.: "iOS", not "iPhone".
return GetSecondaryPlatformSettings_Internal(buildTarget, secondaryTextureName);
}
[NativeName("SetSecondaryPlatformSettings")]
extern private void SetSecondaryPlatformSettings_Internal(TextureImporterPlatformSettings src, string secondaryTextureName);
internal void SetSecondaryPlatformSettings(TextureImporterPlatformSettings src, string secondaryTextureName)
{
src.name = TextureImporter.GetTexturePlatformSerializationName(src.name); // String may refer to a platform group: if != "Standalone", ensure it refers to a platform instead. E.g.: "iOS", not "iPhone".
SetSecondaryPlatformSettings_Internal(src, secondaryTextureName);
}
extern internal bool GetSecondaryColorSpace(string secondaryTextureName);
extern internal void SetSecondaryColorSpace(string secondaryTextureName, bool srGB);
extern internal void DeleteSecondaryPlatformSettings(string secondaryTextureName);
}
};
================================================
FILE: Editor/Mono/2D/SpriteAtlas/SpriteAtlasImporterInspector.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System.IO;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
using UnityEngine.U2D;
using UnityEditor.Build;
using UnityEditor.U2D.Common;
using UnityEditor.U2D.Interface;
using UnityEditorInternal;
using UnityEditor.AssetImporters;
namespace UnityEditor.U2D
{
[CustomEditor(typeof(SpriteAtlasImporter))]
internal class SpriteAtlasImporterInspector : AssetImporterEditor
{
class SpriteAtlasInspectorPlatformSettingView : TexturePlatformSettingsView
{
private bool m_ShowMaxSizeOption;
public SpriteAtlasInspectorPlatformSettingView(bool showMaxSizeOption)
{
m_ShowMaxSizeOption = showMaxSizeOption;
}
public override int DrawMaxSize(int defaultValue, bool isMixedValue, bool isDisabled, out bool changed)
{
if (m_ShowMaxSizeOption)
return base.DrawMaxSize(defaultValue, isMixedValue, isDisabled, out changed);
else
changed = false;
return defaultValue;
}
}
class Styles
{
public readonly GUIStyle preDropDown = "preDropDown";
public readonly GUIStyle previewButton = "preButton";
public readonly GUIStyle previewSlider = "preSlider";
public readonly GUIStyle previewSliderThumb = "preSliderThumb";
public readonly GUIStyle previewLabel = "preLabel";
public readonly GUIContent textureSettingLabel = EditorGUIUtility.TrTextContent("Texture");
public readonly GUIContent variantSettingLabel = EditorGUIUtility.TrTextContent("Variant");
public readonly GUIContent packingParametersLabel = EditorGUIUtility.TrTextContent("Packing");
public readonly GUIContent atlasTypeLabel = EditorGUIUtility.TrTextContent("Type");
public readonly GUIContent defaultPlatformLabel = EditorGUIUtility.TrTextContent("Default");
public readonly GUIContent masterAtlasLabel = EditorGUIUtility.TrTextContent("Master Atlas", "Assigning another Sprite Atlas asset will make this atlas a variant of it.");
public readonly GUIContent packerLabel = EditorGUIUtility.TrTextContent("Scriptable Packer", "Scriptable Object that implements custom packing for Sprite-Atlas.");
public readonly GUIContent bindAsDefaultLabel = EditorGUIUtility.TrTextContent("Include in Build", "Packed textures will be included in the build by default.");
public readonly GUIContent enableRotationLabel = EditorGUIUtility.TrTextContent("Allow Rotation", "Try rotating the sprite to fit better during packing.");
public readonly GUIContent enableTightPackingLabel = EditorGUIUtility.TrTextContent("Tight Packing", "Use the mesh outline to fit instead of the whole texture rect during packing.");
public readonly GUIContent enableAlphaDilationLabel = EditorGUIUtility.TrTextContent("Alpha Dilation", "Enable Alpha Dilation for SpriteAtlas padding pixels.");
public readonly GUIContent paddingLabel = EditorGUIUtility.TrTextContent("Padding", "The amount of extra padding between packed sprites.");
public readonly GUIContent generateMipMapLabel = EditorGUIUtility.TrTextContent("Generate Mip Maps");
public readonly GUIContent packPreviewLabel = EditorGUIUtility.TrTextContent("Pack Preview", "Save and preview packed Sprite Atlas textures.");
public readonly GUIContent sRGBLabel = EditorGUIUtility.TrTextContent("sRGB", "Texture content is stored in gamma space.");
public readonly GUIContent readWrite = EditorGUIUtility.TrTextContent("Read/Write", "Enable to be able to access the raw pixel data from code.");
public readonly GUIContent variantMultiplierLabel = EditorGUIUtility.TrTextContent("Scale", "Down scale ratio.");
public readonly GUIContent copyMasterButton = EditorGUIUtility.TrTextContent("Copy Master's Settings", "Copy all master's settings into this variant.");
public readonly GUIContent disabledPackLabel = EditorGUIUtility.TrTextContent("Sprite Atlas packing is disabled. Enable it in Edit > Project Settings > Editor.", null, EditorGUIUtility.GetHelpIcon(MessageType.Info));
public readonly GUIContent packableListLabel = EditorGUIUtility.TrTextContent("Objects for Packing", "Only accepts Folders, Sprite Sheet (Texture) and Sprite.");
public readonly GUIContent notPowerOfTwoWarning = EditorGUIUtility.TrTextContent("This scale will produce a Variant Sprite Atlas with a packed Texture that is NPOT (non - power of two). This may cause visual artifacts in certain compression/Texture formats.");
public readonly GUIContent secondaryTextureNameLabel = EditorGUIUtility.TrTextContent("Secondary Texture Name", "The name of the Secondary Texture to apply the following settings to.");
public readonly GUIContent platformSettingsDropDownLabel = EditorGUIUtility.TrTextContent("Show Platform Settings For");
public readonly GUIContent smallZoom = EditorGUIUtility.IconContent("PreTextureMipMapLow");
public readonly GUIContent largeZoom = EditorGUIUtility.IconContent("PreTextureMipMapHigh");
public readonly GUIContent alphaIcon = EditorGUIUtility.IconContent("PreTextureAlpha");
public readonly GUIContent RGBIcon = EditorGUIUtility.IconContent("PreTextureRGB");
public readonly GUIContent trashIcon = EditorGUIUtility.TrIconContent("TreeEditor.Trash", "Delete currently selected settings.");
public readonly int packableElementHash = "PackableElement".GetHashCode();
public readonly int packableSelectorHash = "PackableSelector".GetHashCode();
public readonly string swapObjectRegisterUndo = L10n.Tr("Swap Packable");
public readonly string secondaryTextureNameTextControlName = "secondary_texture_name_text_field";
public readonly string defaultTextForSecondaryTextureName = L10n.Tr("(Matches the names of the Secondary Textures in your Sprites.)");
public readonly string nameUniquenessWarning = L10n.Tr("Secondary Texture names must be unique within a Sprite or Sprite Atlas.");
public readonly int[] atlasTypeValues = { 0, 1 };
public readonly GUIContent[] atlasTypeOptions =
{
EditorGUIUtility.TrTextContent("Master"),
EditorGUIUtility.TrTextContent("Variant"),
};
public readonly int[] paddingValues = { 2, 4, 8 };
public readonly GUIContent[] paddingOptions;
public Styles()
{
paddingOptions = new GUIContent[paddingValues.Length];
for (var i = 0; i < paddingValues.Length; ++i)
paddingOptions[i] = EditorGUIUtility.TextContent(paddingValues[i].ToString());
}
}
private static Styles s_Styles;
private static Styles styles
{
get
{
s_Styles = s_Styles ?? new Styles();
return s_Styles;
}
}
private SpriteAtlasAsset spriteAtlasAsset
{
get { return m_TargetAsset; }
}
private SpriteAtlasImporter spriteAtlasImporter
{
get { return target as SpriteAtlasImporter; }
}
private enum AtlasType { Undefined = -1, Master = 0, Variant = 1 }
private SerializedProperty m_FilterMode;
private SerializedProperty m_AnisoLevel;
private SerializedProperty m_GenerateMipMaps;
private SerializedProperty m_Readable;
private SerializedProperty m_UseSRGB;
private SerializedProperty m_EnableTightPacking;
private SerializedProperty m_EnableAlphaDilation;
private SerializedProperty m_EnableRotation;
private SerializedProperty m_Padding;
private SerializedProperty m_BindAsDefault;
private SerializedProperty m_Packables;
private SerializedProperty m_MasterAtlas;
private SerializedProperty m_VariantScale;
private SerializedProperty m_ScriptablePacker;
private string m_Hash;
private int m_PreviewPage = 0;
private int m_TotalPages = 0;
private int[] m_OptionValues = null;
private string[] m_OptionDisplays = null;
private Texture2D[] m_PreviewTextures = null;
private Texture2D[] m_PreviewAlphaTextures = null;
private bool m_PackableListExpanded = true;
private ReorderableList m_PackableList;
private SpriteAtlasAsset m_TargetAsset;
private string m_AssetPath;
private float m_MipLevel = 0;
private bool m_ShowAlpha;
private bool m_Discard = false;
private List m_PlatformSettingsOptions;
private int m_SelectedPlatformSettings = 0;
private int m_ContentHash = 0;
private List m_ValidPlatforms;
private Dictionary> m_TempPlatformSettings;
private ITexturePlatformSettingsView m_TexturePlatformSettingsView;
private ITexturePlatformSettingsView m_SecondaryTexturePlatformSettingsView;
private ITexturePlatformSettingsFormatHelper m_TexturePlatformSettingTextureHelper;
private ITexturePlatformSettingsController m_TexturePlatformSettingsController;
private SerializedObject m_SerializedAssetObject = null;
// The first two options are the main texture and a separator while the last two options are another separator and the new settings menu.
private bool secondaryTextureSelected { get { return m_SelectedPlatformSettings >= 2 && m_SelectedPlatformSettings <= m_PlatformSettingsOptions.Count - 3; } }
static bool IsPackable(Object o)
{
return o != null && (o.GetType() == typeof(Sprite) || o.GetType() == typeof(Texture2D) || (o.GetType() == typeof(DefaultAsset) && ProjectWindowUtil.IsFolder(o.GetInstanceID())));
}
static Object ValidateObjectForPackableFieldAssignment(Object[] references, System.Type objType, SerializedProperty property, EditorGUI.ObjectFieldValidatorOptions options)
{
// We only validate and care about the first one as this is a object field assignment.
if (references.Length > 0 && IsPackable(references[0]))
return references[0];
return null;
}
bool IsTargetVariant()
{
return spriteAtlasAsset ? spriteAtlasAsset.isVariant : false;
}
bool IsTargetMaster()
{
return spriteAtlasAsset ? !spriteAtlasAsset.isVariant : true;
}
protected override bool needsApplyRevert => false;
internal override string targetTitle
{
get
{
return spriteAtlasAsset ? ( Path.GetFileNameWithoutExtension(m_AssetPath) + " (Sprite Atlas)" ) : "SpriteAtlasImporter Settings";
}
}
private string LoadSourceAsset()
{
var assetPath = AssetDatabase.GetAssetPath(target);
var loadedObjects = InternalEditorUtility.LoadSerializedFileAndForget(assetPath);
if (loadedObjects.Length > 0)
m_TargetAsset = loadedObjects[0] as SpriteAtlasAsset;
return assetPath;
}
private SerializedObject serializedAssetObject
{
get
{
return GetSerializedAssetObject();
}
}
internal static int SpriteAtlasAssetHash(SerializedObject obj)
{
int hashCode = 0;
if (obj == null)
return 0;
unchecked
{
hashCode = (int)2166136261 ^ (int) obj.FindProperty("m_MasterAtlas").contentHash;
hashCode = hashCode * 16777619 ^ (int) obj.FindProperty("m_ImporterData").contentHash;
hashCode = hashCode * 16777619 ^ (int) obj.FindProperty("m_IsVariant").contentHash;
hashCode = hashCode * 16777619 ^ (int)obj.FindProperty("m_ScriptablePacker").contentHash;
}
return hashCode;
}
internal static int SpriteAtlasImporterHash(SerializedObject obj)
{
int hashCode = 0;
if (obj == null)
return 0;
unchecked
{
hashCode = (int)2166136261 ^ (int)obj.FindProperty("m_PackingSettings").contentHash;
hashCode = hashCode * 16777619 ^ (int)obj.FindProperty("m_TextureSettings").contentHash;
hashCode = hashCode * 16777619 ^ (int)obj.FindProperty("m_PlatformSettings").contentHash;
hashCode = hashCode * 16777619 ^ (int)obj.FindProperty("m_SecondaryTextureSettings").contentHash;
hashCode = hashCode * 16777619 ^ (int)obj.FindProperty("m_BindAsDefault").contentHash;
hashCode = hashCode * 16777619 ^ (int)obj.FindProperty("m_VariantMultiplier").contentHash;
}
return hashCode;
}
internal int GetInspectorHash()
{
return SpriteAtlasAssetHash(m_SerializedAssetObject) * 16777619 ^ SpriteAtlasImporterHash(m_SerializedObject);
}
private SerializedObject GetSerializedAssetObject()
{
if (m_SerializedAssetObject == null)
{
try
{
m_SerializedAssetObject = new SerializedObject(spriteAtlasAsset, m_Context);
m_SerializedAssetObject.inspectorMode = inspectorMode;
m_ContentHash = GetInspectorHash();
m_EnabledProperty = m_SerializedAssetObject.FindProperty("m_Enabled");
}
catch (System.ArgumentException e)
{
m_SerializedAssetObject = null;
m_EnabledProperty = null;
throw new SerializedObjectNotCreatableException(e.Message);
}
}
return m_SerializedAssetObject;
}
public override void OnEnable()
{
base.OnEnable();
m_FilterMode = serializedObject.FindProperty("m_TextureSettings.filterMode");
m_AnisoLevel = serializedObject.FindProperty("m_TextureSettings.anisoLevel");
m_GenerateMipMaps = serializedObject.FindProperty("m_TextureSettings.generateMipMaps");
m_Readable = serializedObject.FindProperty("m_TextureSettings.readable");
m_UseSRGB = serializedObject.FindProperty("m_TextureSettings.sRGB");
m_EnableTightPacking = serializedObject.FindProperty("m_PackingSettings.enableTightPacking");
m_EnableRotation = serializedObject.FindProperty("m_PackingSettings.enableRotation");
m_EnableAlphaDilation = serializedObject.FindProperty("m_PackingSettings.enableAlphaDilation");
m_Padding = serializedObject.FindProperty("m_PackingSettings.padding");
m_BindAsDefault = serializedObject.FindProperty("m_BindAsDefault");
m_VariantScale = serializedObject.FindProperty("m_VariantMultiplier");
PopulatePlatformSettingsOptions();
SyncPlatformSettings();
m_TexturePlatformSettingsView = new SpriteAtlasInspectorPlatformSettingView(IsTargetMaster());
m_TexturePlatformSettingTextureHelper = new TexturePlatformSettingsFormatHelper();
m_TexturePlatformSettingsController = new TexturePlatformSettingsViewController();
// Don't show max size option for secondary textures as they must have the same size as the main texture.
m_SecondaryTexturePlatformSettingsView = new SpriteAtlasInspectorPlatformSettingView(false);
m_AssetPath = LoadSourceAsset();
if (spriteAtlasAsset == null)
return;
m_MasterAtlas = serializedAssetObject.FindProperty("m_MasterAtlas");
m_ScriptablePacker = serializedAssetObject.FindProperty("m_ScriptablePacker");
m_Packables = serializedAssetObject.FindProperty("m_ImporterData.packables");
m_PackableList = new ReorderableList(serializedAssetObject, m_Packables, true, true, true, true);
m_PackableList.onAddCallback = AddPackable;
m_PackableList.drawElementCallback = DrawPackableElement;
m_PackableList.elementHeight = EditorGUIUtility.singleLineHeight;
m_PackableList.headerHeight = 0f;
}
// Populate the platform settings dropdown list with secondary texture names found through serialized properties of the Sprite Atlas assets.
private void PopulatePlatformSettingsOptions()
{
m_PlatformSettingsOptions = new List { L10n.Tr("Main Texture"), "", "", L10n.Tr("New Secondary Texture settings.") };
SerializedProperty secondaryPlatformSettings = serializedObject.FindProperty("m_SecondaryTextureSettings");
if (secondaryPlatformSettings != null && !secondaryPlatformSettings.hasMultipleDifferentValues)
{
int numSecondaryTextures = secondaryPlatformSettings.arraySize;
List secondaryTextureNames = new List(numSecondaryTextures);
for (int i = 0; i < numSecondaryTextures; ++i)
secondaryTextureNames.Add(secondaryPlatformSettings.GetArrayElementAtIndex(i).displayName);
// Insert after main texture and the separator.
m_PlatformSettingsOptions.InsertRange(2, secondaryTextureNames);
}
m_SelectedPlatformSettings = 0;
}
void SyncPlatformSettings()
{
m_TempPlatformSettings = new Dictionary>();
string secondaryTextureName = null;
if (secondaryTextureSelected)
secondaryTextureName = m_PlatformSettingsOptions[m_SelectedPlatformSettings];
// Default platform
var defaultSettings = new List();
m_TempPlatformSettings.Add(TextureImporterInspector.s_DefaultPlatformName, defaultSettings);
var settings = secondaryTextureSelected
? spriteAtlasImporter.GetSecondaryPlatformSettings(TextureImporterInspector.s_DefaultPlatformName, secondaryTextureName)
: spriteAtlasImporter.GetPlatformSettings(TextureImporterInspector.s_DefaultPlatformName);
defaultSettings.Add(settings);
m_ValidPlatforms = BuildPlatforms.instance.GetValidPlatforms();
foreach (var platform in m_ValidPlatforms)
{
var platformSettings = new List();
m_TempPlatformSettings.Add(platform.name, platformSettings);
var perPlatformSettings = secondaryTextureSelected ? spriteAtlasImporter.GetSecondaryPlatformSettings(platform.name, secondaryTextureName) : spriteAtlasImporter.GetPlatformSettings(platform.name);
// setting will be in default state if copy failed
platformSettings.Add(perPlatformSettings);
}
}
void RenameSecondaryPlatformSettings(string oldName, string newName)
{
spriteAtlasImporter.DeleteSecondaryPlatformSettings(oldName);
var defaultPlatformSettings = m_TempPlatformSettings[TextureImporterInspector.s_DefaultPlatformName];
spriteAtlasImporter.SetSecondaryPlatformSettings(defaultPlatformSettings[0], newName);
foreach (var buildPlatform in m_ValidPlatforms)
{
var platformSettings = m_TempPlatformSettings[buildPlatform.name];
spriteAtlasImporter.SetSecondaryPlatformSettings(platformSettings[0], newName);
}
}
void AddPackable(ReorderableList list)
{
ObjectSelector.get.Show(null, typeof(Object), null, false);
ObjectSelector.get.searchFilter = "t:sprite t:texture2d t:folder";
ObjectSelector.get.objectSelectorID = styles.packableSelectorHash;
}
void DrawPackableElement(Rect rect, int index, bool selected, bool focused)
{
var property = m_Packables.GetArrayElementAtIndex(index);
var controlID = EditorGUIUtility.GetControlID(styles.packableElementHash, FocusType.Passive);
var previousObject = property.objectReferenceValue;
var changedObject = EditorGUI.DoObjectField(rect, rect, controlID, previousObject, target, typeof(Object), ValidateObjectForPackableFieldAssignment, false);
if (changedObject != previousObject)
{
Undo.RegisterCompleteObjectUndo(spriteAtlasAsset, styles.swapObjectRegisterUndo);
property.objectReferenceValue = changedObject;
}
if (GUIUtility.keyboardControl == controlID && !selected)
m_PackableList.index = index;
}
protected override void Apply()
{
if (HasModified())
{
if (spriteAtlasAsset)
{
SpriteAtlasAsset.Save(spriteAtlasAsset, m_AssetPath);
AssetDatabase.ImportAsset(m_AssetPath);
}
m_ContentHash = GetInspectorHash();
}
base.Apply();
}
protected override bool useAssetDrawPreview { get { return false; } }
protected void PackPreviewGUI()
{
EditorGUILayout.Space();
using (new GUILayout.HorizontalScope())
{
using (new EditorGUI.DisabledScope(!HasModified() || !IsValidAtlas() || Application.isPlaying))
{
GUILayout.FlexibleSpace();
if (GUILayout.Button(styles.packPreviewLabel))
{
GUI.FocusControl(null);
SpriteAtlasUtility.EnableV2Import(true);
SaveChanges();
SpriteAtlasUtility.EnableV2Import(false);
}
}
}
}
private bool IsValidAtlas()
{
if (IsTargetVariant())
return m_MasterAtlas.objectReferenceValue != null;
else
return true;
}
public override bool HasModified()
{
return !m_Discard && (base.HasModified() || m_ContentHash != GetInspectorHash());
}
private void ValidateMasterAtlas()
{
if (m_MasterAtlas.objectReferenceValue != null)
{
var assetPath = AssetDatabase.GetAssetPath(m_MasterAtlas.objectReferenceValue);
if (assetPath == m_AssetPath)
{
UnityEngine.Debug.LogWarning("Cannot set itself as MasterAtlas. Please assign a valid MasterAtlas.");
m_MasterAtlas.objectReferenceValue = null;
}
}
if (m_MasterAtlas.objectReferenceValue != null)
{
SpriteAtlas masterAsset = m_MasterAtlas.objectReferenceValue as SpriteAtlas;
if (masterAsset != null && masterAsset.isVariant)
{
UnityEngine.Debug.LogWarning("Cannot set a VariantAtlas as MasterAtlas. Please assign a valid MasterAtlas.");
m_MasterAtlas.objectReferenceValue = null;
}
}
}
public override void OnInspectorGUI()
{
// Ensure changes done through script are reflected immediately in Inspector by Syncing m_TempPlatformSettings with Actual Settings.
SyncPlatformSettings();
serializedObject.Update();
if (spriteAtlasAsset)
{
serializedAssetObject.Update();
HandleCommonSettingUI();
}
EditorGUILayout.PropertyField(m_BindAsDefault, styles.bindAsDefaultLabel);
GUILayout.Space(EditorGUI.kSpacing);
bool isTargetMaster = true;
if (spriteAtlasAsset)
isTargetMaster = IsTargetMaster();
if (isTargetMaster)
HandleMasterSettingUI();
if (!spriteAtlasAsset || IsTargetVariant())
HandleVariantSettingUI();
GUILayout.Space(EditorGUI.kSpacing);
HandleTextureSettingUI();
GUILayout.Space(EditorGUI.kSpacing);
// Only show the packable object list when:
// - This is a master atlas.
if (targets.Length == 1 && IsTargetMaster() && spriteAtlasAsset)
HandlePackableListUI();
serializedObject.ApplyModifiedProperties();
if (spriteAtlasAsset)
{
serializedAssetObject.ApplyModifiedProperties();
PackPreviewGUI();
}
ApplyRevertGUI();
}
private void HandleCommonSettingUI()
{
var atlasType = AtlasType.Undefined;
if (IsTargetMaster())
atlasType = AtlasType.Master;
else if (IsTargetVariant())
atlasType = AtlasType.Variant;
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = atlasType == AtlasType.Undefined;
atlasType = (AtlasType)EditorGUILayout.IntPopup(styles.atlasTypeLabel, (int)atlasType, styles.atlasTypeOptions, styles.atlasTypeValues);
EditorGUI.showMixedValue = false;
if (EditorGUI.EndChangeCheck())
{
bool setToVariant = atlasType == AtlasType.Variant;
spriteAtlasAsset.SetIsVariant(setToVariant);
// Reinit the platform setting view
m_TexturePlatformSettingsView = new SpriteAtlasInspectorPlatformSettingView(IsTargetMaster());
}
m_ScriptablePacker.objectReferenceValue = EditorGUILayout.ObjectField(styles.packerLabel, m_ScriptablePacker.objectReferenceValue, typeof(UnityEditor.U2D.ScriptablePacker), false);
if (atlasType == AtlasType.Variant)
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(m_MasterAtlas, styles.masterAtlasLabel);
if (EditorGUI.EndChangeCheck())
{
ValidateMasterAtlas();
// Apply modified properties here to have latest master atlas reflected in native codes.
serializedAssetObject.ApplyModifiedPropertiesWithoutUndo();
PopulatePlatformSettingsOptions();
SyncPlatformSettings();
}
}
}
private void HandleVariantSettingUI()
{
EditorGUILayout.LabelField(styles.variantSettingLabel, EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_VariantScale, styles.variantMultiplierLabel);
// Test if the multiplier scale a power of two size (1024) into another power of 2 size.
if (!Mathf.IsPowerOfTwo((int)(m_VariantScale.floatValue * 1024)))
EditorGUILayout.HelpBox(styles.notPowerOfTwoWarning.text, MessageType.Warning, true);
}
private void HandleBoolToIntPropertyField(SerializedProperty prop, GUIContent content)
{
Rect rect = EditorGUILayout.GetControlRect();
EditorGUI.BeginProperty(rect, content, prop);
EditorGUI.BeginChangeCheck();
var boolValue = EditorGUI.Toggle(rect, content, prop.boolValue);
if (EditorGUI.EndChangeCheck())
prop.boolValue = boolValue;
EditorGUI.EndProperty();
}
private void HandleMasterSettingUI()
{
EditorGUILayout.LabelField(styles.packingParametersLabel, EditorStyles.boldLabel);
HandleBoolToIntPropertyField(m_EnableRotation, styles.enableRotationLabel);
HandleBoolToIntPropertyField(m_EnableTightPacking, styles.enableTightPackingLabel);
HandleBoolToIntPropertyField(m_EnableAlphaDilation, styles.enableAlphaDilationLabel);
EditorGUILayout.IntPopup(m_Padding, styles.paddingOptions, styles.paddingValues, styles.paddingLabel);
GUILayout.Space(EditorGUI.kSpacing);
}
private void HandleTextureSettingUI()
{
EditorGUILayout.LabelField(styles.textureSettingLabel, EditorStyles.boldLabel);
HandleBoolToIntPropertyField(m_Readable, styles.readWrite);
HandleBoolToIntPropertyField(m_GenerateMipMaps, styles.generateMipMapLabel);
HandleBoolToIntPropertyField(m_UseSRGB, styles.sRGBLabel);
EditorGUILayout.PropertyField(m_FilterMode);
var showAniso = !m_FilterMode.hasMultipleDifferentValues && !m_GenerateMipMaps.hasMultipleDifferentValues
&& (FilterMode)m_FilterMode.intValue != FilterMode.Point && m_GenerateMipMaps.boolValue;
if (showAniso)
EditorGUILayout.IntSlider(m_AnisoLevel, 0, 16);
GUILayout.Space(EditorGUI.kSpacing);
// "Show Platform Settings For" dropdown
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel(s_Styles.platformSettingsDropDownLabel);
EditorGUI.BeginChangeCheck();
m_SelectedPlatformSettings = EditorGUILayout.Popup(m_SelectedPlatformSettings, m_PlatformSettingsOptions.ToArray(), GUILayout.MaxWidth(150.0f));
if (EditorGUI.EndChangeCheck())
{
// New settings option is selected...
if (m_SelectedPlatformSettings == m_PlatformSettingsOptions.Count - 1)
{
m_PlatformSettingsOptions.Insert(m_SelectedPlatformSettings - 1, s_Styles.defaultTextForSecondaryTextureName);
m_SelectedPlatformSettings--;
EditorGUI.FocusTextInControl(s_Styles.secondaryTextureNameTextControlName);
}
SyncPlatformSettings();
}
if (secondaryTextureSelected)
{
// trash can button
if (GUILayout.Button(s_Styles.trashIcon, EditorStyles.iconButton, GUILayout.ExpandWidth(false)))
{
EditorGUI.EndEditingActiveTextField();
spriteAtlasImporter.DeleteSecondaryPlatformSettings(m_PlatformSettingsOptions[m_SelectedPlatformSettings]);
m_PlatformSettingsOptions.RemoveAt(m_SelectedPlatformSettings);
m_SelectedPlatformSettings--;
if (m_SelectedPlatformSettings == 1)
m_SelectedPlatformSettings = 0;
SyncPlatformSettings();
}
}
}
EditorGUILayout.EndHorizontal();
// Texture platform settings UI.
EditorGUILayout.BeginHorizontal();
{
EditorGUI.indentLevel++;
GUILayout.Space(EditorGUI.indent);
EditorGUI.indentLevel--;
if (m_SelectedPlatformSettings == 0)
{
GUILayout.Space(EditorGUI.kSpacing);
HandlePlatformSettingUI(null);
}
else
{
EditorGUILayout.BeginVertical();
{
GUILayout.Space(EditorGUI.kSpacing);
string oldSecondaryTextureName = m_PlatformSettingsOptions[m_SelectedPlatformSettings];
GUI.SetNextControlName(s_Styles.secondaryTextureNameTextControlName);
EditorGUI.BeginChangeCheck();
string textFieldText = EditorGUILayout.DelayedTextField(s_Styles.secondaryTextureNameLabel, oldSecondaryTextureName);
if (EditorGUI.EndChangeCheck() && oldSecondaryTextureName != textFieldText)
{
if (!m_PlatformSettingsOptions.Exists(x => x == textFieldText))
{
m_PlatformSettingsOptions[m_SelectedPlatformSettings] = textFieldText;
RenameSecondaryPlatformSettings(oldSecondaryTextureName, textFieldText);
}
else
{
Debug.LogWarning(s_Styles.nameUniquenessWarning);
EditorGUI.FocusTextInControl(s_Styles.secondaryTextureNameTextControlName);
}
}
string secondaryTextureName = m_PlatformSettingsOptions[m_SelectedPlatformSettings];
EditorGUI.BeginChangeCheck();
bool value = EditorGUILayout.Toggle(s_Styles.sRGBLabel, spriteAtlasImporter.GetSecondaryColorSpace(secondaryTextureName));
if (EditorGUI.EndChangeCheck())
spriteAtlasImporter.SetSecondaryColorSpace(secondaryTextureName, value);
HandlePlatformSettingUI(textFieldText);
}
EditorGUILayout.EndVertical();
}
}
EditorGUILayout.EndHorizontal();
}
private void HandlePlatformSettingUI(string secondaryTextureName)
{
int shownTextureFormatPage = EditorGUILayout.BeginPlatformGrouping(m_ValidPlatforms.ToArray(), styles.defaultPlatformLabel);
var defaultPlatformSettings = m_TempPlatformSettings[TextureImporterInspector.s_DefaultPlatformName];
bool isSecondary = secondaryTextureName != null;
ITexturePlatformSettingsView view = isSecondary ? m_SecondaryTexturePlatformSettingsView : m_TexturePlatformSettingsView;
if (shownTextureFormatPage == -1)
{
if (m_TexturePlatformSettingsController.HandleDefaultSettings(defaultPlatformSettings, view, m_TexturePlatformSettingTextureHelper))
{
for (var i = 0; i < defaultPlatformSettings.Count; ++i)
{
if (isSecondary)
spriteAtlasImporter.SetSecondaryPlatformSettings(defaultPlatformSettings[i], secondaryTextureName);
else
spriteAtlasImporter.SetPlatformSettings(defaultPlatformSettings[i]);
}
}
}
else
{
var buildPlatform = m_ValidPlatforms[shownTextureFormatPage];
var platformSettings = m_TempPlatformSettings[buildPlatform.name];
for (var i = 0; i < platformSettings.Count; ++i)
{
var settings = platformSettings[i];
if (!settings.overridden)
{
if (defaultPlatformSettings[0].format == TextureImporterFormat.Automatic)
{
settings.format = (TextureImporterFormat)spriteAtlasImporter.GetTextureFormat(buildPlatform.defaultTarget);
}
else
{
settings.format = defaultPlatformSettings[0].format;
}
settings.maxTextureSize = defaultPlatformSettings[0].maxTextureSize;
settings.crunchedCompression = defaultPlatformSettings[0].crunchedCompression;
settings.compressionQuality = defaultPlatformSettings[0].compressionQuality;
}
}
m_TexturePlatformSettingsView.buildPlatformTitle = buildPlatform.title.text;
if (m_TexturePlatformSettingsController.HandlePlatformSettings(buildPlatform.defaultTarget, platformSettings, view, m_TexturePlatformSettingTextureHelper))
{
for (var i = 0; i < platformSettings.Count; ++i)
{
if (isSecondary)
spriteAtlasImporter.SetSecondaryPlatformSettings(platformSettings[i], secondaryTextureName);
else
spriteAtlasImporter.SetPlatformSettings(platformSettings[i]);
}
}
}
EditorGUILayout.EndPlatformGrouping();
}
private void HandlePackableListUI()
{
var currentEvent = Event.current;
var usedEvent = false;
Rect rect = EditorGUILayout.GetControlRect();
var controlID = EditorGUIUtility.s_LastControlID;
switch (currentEvent.type)
{
case EventType.DragExited:
if (GUI.enabled)
HandleUtility.Repaint();
break;
case EventType.DragUpdated:
case EventType.DragPerform:
if (rect.Contains(currentEvent.mousePosition) && GUI.enabled)
{
// Check each single object, so we can add multiple objects in a single drag.
var didAcceptDrag = false;
var references = DragAndDrop.objectReferences;
foreach (var obj in references)
{
if (IsPackable(obj))
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
if (currentEvent.type == EventType.DragPerform)
{
m_Packables.AppendFoldoutPPtrValue(obj);
didAcceptDrag = true;
DragAndDrop.activeControlID = 0;
}
else
DragAndDrop.activeControlID = controlID;
}
}
if (didAcceptDrag)
{
GUI.changed = true;
DragAndDrop.AcceptDrag();
usedEvent = true;
}
}
break;
case EventType.ValidateCommand:
if (currentEvent.commandName == ObjectSelector.ObjectSelectorClosedCommand && ObjectSelector.get.objectSelectorID == styles.packableSelectorHash)
usedEvent = true;
break;
case EventType.ExecuteCommand:
if (currentEvent.commandName == ObjectSelector.ObjectSelectorClosedCommand && ObjectSelector.get.objectSelectorID == styles.packableSelectorHash)
{
var obj = ObjectSelector.GetCurrentObject();
if (IsPackable(obj))
{
m_Packables.AppendFoldoutPPtrValue(obj);
m_PackableList.index = m_Packables.arraySize - 1;
}
usedEvent = true;
}
break;
}
// Handle Foldout after we handle the current event because Foldout might process the drag and drop event and used it.
m_PackableListExpanded = EditorGUI.Foldout(rect, m_PackableListExpanded, styles.packableListLabel, true);
if (usedEvent)
currentEvent.Use();
if (m_PackableListExpanded)
{
EditorGUI.indentLevel++;
m_PackableList.DoLayoutList();
EditorGUI.indentLevel--;
}
}
public override void SaveChanges()
{
if (!m_Discard)
base.SaveChanges();
m_ContentHash = GetInspectorHash();
}
public override void DiscardChanges()
{
m_Discard = true;
base.DiscardChanges();
m_ContentHash = GetInspectorHash();
}
void CachePreviewTexture()
{
var spriteAtlas = AssetDatabase.LoadAssetAtPath(m_AssetPath);
if (spriteAtlas != null)
{
bool hasPreview = m_PreviewTextures != null && m_PreviewTextures.Length > 0;
if (hasPreview)
{
foreach (var previewTexture in m_PreviewTextures)
hasPreview = previewTexture != null;
}
if (!hasPreview || m_Hash != spriteAtlas.GetHash())
{
m_PreviewTextures = spriteAtlas.GetPreviewTextures();
m_PreviewAlphaTextures = spriteAtlas.GetPreviewAlphaTextures();
m_Hash = spriteAtlas.GetHash();
if (m_PreviewTextures != null
&& m_PreviewTextures.Length > 0
&& m_TotalPages != m_PreviewTextures.Length)
{
m_TotalPages = m_PreviewTextures.Length;
m_OptionDisplays = new string[m_TotalPages];
m_OptionValues = new int[m_TotalPages];
for (int i = 0; i < m_TotalPages; ++i)
{
string texName = m_PreviewTextures[i].name;
var pageNum = SpriteAtlasExtensions.GetPageNumberInAtlas(texName);
var secondaryName = SpriteAtlasExtensions.GetSecondaryTextureNameInAtlas(texName);
m_OptionDisplays[i] = secondaryName == "" ? string.Format("MainTex - Page ({0})", pageNum) : string.Format("{0} - Page ({1})", secondaryName, pageNum);
m_OptionValues[i] = i;
}
}
}
}
}
public override string GetInfoString()
{
if (m_PreviewTextures != null && m_PreviewPage < m_PreviewTextures.Length)
{
Texture2D t = m_PreviewTextures[m_PreviewPage];
GraphicsFormat format = GraphicsFormatUtility.GetFormat(t);
return string.Format("{0}x{1} {2}\n{3}", t.width, t.height, GraphicsFormatUtility.GetFormatString(format), EditorUtility.FormatBytes(TextureUtil.GetStorageMemorySizeLong(t)));
}
return "";
}
public override bool HasPreviewGUI()
{
CachePreviewTexture();
if (m_PreviewTextures != null && m_PreviewTextures.Length > 0)
{
Texture2D t = m_PreviewTextures[0];
return t != null;
}
return false;
}
public override void OnPreviewSettings()
{
// Do not allow changing of pages when multiple atlases is selected.
if (targets.Length == 1 && m_OptionDisplays != null && m_OptionValues != null && m_TotalPages > 1)
m_PreviewPage = EditorGUILayout.IntPopup(m_PreviewPage, m_OptionDisplays, m_OptionValues, styles.preDropDown, GUILayout.MaxWidth(50));
else
m_PreviewPage = 0;
if (m_PreviewTextures != null)
{
m_PreviewPage = Mathf.Min(m_PreviewPage, m_PreviewTextures.Length - 1);
Texture2D t = m_PreviewTextures[m_PreviewPage];
if (t == null)
return;
if (GraphicsFormatUtility.HasAlphaChannel(t.format) || (m_PreviewAlphaTextures != null && m_PreviewAlphaTextures.Length > 0))
m_ShowAlpha = GUILayout.Toggle(m_ShowAlpha, m_ShowAlpha ? styles.alphaIcon : styles.RGBIcon, styles.previewButton);
int mipCount = Mathf.Max(1, TextureUtil.GetMipmapCount(t));
if (mipCount > 1)
{
GUILayout.Box(styles.smallZoom, styles.previewLabel);
m_MipLevel = Mathf.Round(GUILayout.HorizontalSlider(m_MipLevel, mipCount - 1, 0, styles.previewSlider, styles.previewSliderThumb, GUILayout.MaxWidth(64)));
GUILayout.Box(styles.largeZoom, styles.previewLabel);
}
}
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
CachePreviewTexture();
if (m_ShowAlpha && m_PreviewAlphaTextures != null && m_PreviewPage < m_PreviewAlphaTextures.Length)
{
var at = m_PreviewAlphaTextures[m_PreviewPage];
var bias = m_MipLevel - (float)(System.Math.Log(at.width / r.width) / System.Math.Log(2));
EditorGUI.DrawTextureTransparent(r, at, ScaleMode.ScaleToFit, 0, bias);
}
else if (m_PreviewTextures != null && m_PreviewPage < m_PreviewTextures.Length)
{
Texture2D t = m_PreviewTextures[m_PreviewPage];
if (t == null)
return;
float bias = m_MipLevel - (float)(System.Math.Log(t.width / r.width) / System.Math.Log(2));
if (m_ShowAlpha)
EditorGUI.DrawTextureAlpha(r, t, ScaleMode.ScaleToFit, 0, bias);
else
EditorGUI.DrawTextureTransparent(r, t, ScaleMode.ScaleToFit, 0, bias);
}
}
}
}
================================================
FILE: Editor/Mono/2D/SpriteAtlas/SpriteAtlasInspector.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
using UnityEngine.U2D;
using UnityEditor.Build;
using UnityEditor.U2D.Common;
using UnityEditor.U2D.Interface;
using UnityEditorInternal;
namespace UnityEditor.U2D
{
[CustomEditor(typeof(SpriteAtlas))]
[CanEditMultipleObjects]
internal class SpriteAtlasInspector : Editor
{
class SpriteAtlasInspectorPlatformSettingView : TexturePlatformSettingsView
{
private bool m_ShowMaxSizeOption;
public SpriteAtlasInspectorPlatformSettingView(bool showMaxSizeOption)
{
m_ShowMaxSizeOption = showMaxSizeOption;
}
public override int DrawMaxSize(int defaultValue, bool isMixedValue, bool isDisabled, out bool changed)
{
if (m_ShowMaxSizeOption)
return base.DrawMaxSize(defaultValue, isMixedValue, isDisabled, out changed);
else
changed = false;
return defaultValue;
}
}
class Styles
{
public readonly GUIStyle preDropDown = "preDropDown";
public readonly GUIStyle previewButton = "preButton";
public readonly GUIStyle previewSlider = "preSlider";
public readonly GUIStyle previewSliderThumb = "preSliderThumb";
public readonly GUIStyle previewLabel = "preLabel";
public readonly GUIContent textureSettingLabel = EditorGUIUtility.TrTextContent("Texture");
public readonly GUIContent variantSettingLabel = EditorGUIUtility.TrTextContent("Variant");
public readonly GUIContent packingParametersLabel = EditorGUIUtility.TrTextContent("Packing");
public readonly GUIContent atlasTypeLabel = EditorGUIUtility.TrTextContent("Type");
public readonly GUIContent defaultPlatformLabel = EditorGUIUtility.TrTextContent("Default");
public readonly GUIContent masterAtlasLabel = EditorGUIUtility.TrTextContent("Master Atlas", "Assigning another Sprite Atlas asset will make this atlas a variant of it.");
public readonly GUIContent bindAsDefaultLabel = EditorGUIUtility.TrTextContent("Include in Build", "Packed textures will be included in the build by default.");
public readonly GUIContent enableRotationLabel = EditorGUIUtility.TrTextContent("Allow Rotation", "Try rotating the sprite to fit better during packing.");
public readonly GUIContent enableTightPackingLabel = EditorGUIUtility.TrTextContent("Tight Packing", "Use the mesh outline to fit instead of the whole texture rect during packing.");
public readonly GUIContent enableAlphaDilationLabel = EditorGUIUtility.TrTextContent("Alpha Dilation", "Enable Alpha Dilation for SpriteAtlas padding pixels.");
public readonly GUIContent paddingLabel = EditorGUIUtility.TrTextContent("Padding", "The amount of extra padding between packed sprites.");
public readonly GUIContent generateMipMapLabel = EditorGUIUtility.TrTextContent("Generate Mip Maps");
public readonly GUIContent sRGBLabel = EditorGUIUtility.TrTextContent("sRGB", "Texture content is stored in gamma space.");
public readonly GUIContent readWrite = EditorGUIUtility.TrTextContent("Read/Write", "Enable to be able to access the raw pixel data from code.");
public readonly GUIContent variantMultiplierLabel = EditorGUIUtility.TrTextContent("Scale", "Down scale ratio.");
public readonly GUIContent packButton = EditorGUIUtility.TrTextContent("Pack Preview", "Pack this atlas.");
public readonly GUIContent disabledPackLabel = EditorGUIUtility.TrTextContent("Sprite Atlas packing is disabled. Enable it in Edit > Project Settings > Editor.", null, EditorGUIUtility.GetHelpIcon(MessageType.Info));
public readonly GUIContent packableListLabel = EditorGUIUtility.TrTextContent("Objects for Packing", "Only accepts Folder, Sprite Sheet (Texture) and Sprite.");
public readonly GUIContent notPowerOfTwoWarning = EditorGUIUtility.TrTextContent("This scale will produce a Variant Sprite Atlas with a packed Texture that is NPOT (non - power of two). This may cause visual artifacts in certain compression/Texture formats.");
public readonly GUIContent secondaryTextureNameLabel = EditorGUIUtility.TrTextContent("Secondary Texture Name", "The name of the Secondary Texture to apply the following settings to.");
public readonly GUIContent platformSettingsDropDownLabel = EditorGUIUtility.TrTextContent("Show Platform Settings For");
public readonly GUIContent smallZoom = EditorGUIUtility.IconContent("PreTextureMipMapLow");
public readonly GUIContent largeZoom = EditorGUIUtility.IconContent("PreTextureMipMapHigh");
public readonly GUIContent alphaIcon = EditorGUIUtility.IconContent("PreTextureAlpha");
public readonly GUIContent RGBIcon = EditorGUIUtility.IconContent("PreTextureRGB");
public readonly GUIContent trashIcon = EditorGUIUtility.TrIconContent("TreeEditor.Trash", "Delete currently selected settings.");
public readonly int packableElementHash = "PackableElement".GetHashCode();
public readonly int packableSelectorHash = "PackableSelector".GetHashCode();
public readonly string swapObjectRegisterUndo = L10n.Tr("Swap Packable");
public readonly string secondaryTextureNameTextControlName = "secondary_texture_name_text_field";
public readonly string defaultTextForSecondaryTextureName = L10n.Tr("(Matches the names of the Secondary Textures in your Sprites.)");
public readonly string nameUniquenessWarning = L10n.Tr("Secondary Texture names must be unique within a Sprite or Sprite Atlas.");
public readonly int[] atlasTypeValues = { 0, 1 };
public readonly GUIContent[] atlasTypeOptions =
{
EditorGUIUtility.TrTextContent("Master"),
EditorGUIUtility.TrTextContent("Variant"),
};
public readonly int[] paddingValues = { 2, 4, 8 };
public readonly GUIContent[] paddingOptions;
public Styles()
{
paddingOptions = new GUIContent[paddingValues.Length];
for (var i = 0; i < paddingValues.Length; ++i)
paddingOptions[i] = EditorGUIUtility.TextContent(paddingValues[i].ToString());
}
}
private static Styles s_Styles;
private static Styles styles
{
get
{
s_Styles = s_Styles ?? new Styles();
return s_Styles;
}
}
private enum AtlasType { Undefined = -1, Master = 0, Variant = 1 }
private SerializedProperty m_FilterMode;
private SerializedProperty m_AnisoLevel;
private SerializedProperty m_GenerateMipMaps;
private SerializedProperty m_Readable;
private SerializedProperty m_UseSRGB;
private SerializedProperty m_EnableTightPacking;
private SerializedProperty m_EnableAlphaDilation;
private SerializedProperty m_EnableRotation;
private SerializedProperty m_Padding;
private SerializedProperty m_BindAsDefault;
private SerializedProperty m_Packables;
private SerializedProperty m_MasterAtlas;
private SerializedProperty m_VariantScale;
private string m_Hash;
private int m_PreviewPage = 0;
private int m_TotalPages = 0;
private int[] m_OptionValues = null;
private string[] m_OptionDisplays = null;
private Texture2D[] m_PreviewTextures = null;
private Texture2D[] m_PreviewAlphaTextures = null;
private bool m_PackableListExpanded = true;
private ReorderableList m_PackableList;
private float m_MipLevel = 0;
private bool m_ShowAlpha;
private List m_PlatformSettingsOptions;
private int m_SelectedPlatformSettings = 0;
private List m_ValidPlatforms;
private Dictionary> m_TempPlatformSettings;
private ITexturePlatformSettingsView m_TexturePlatformSettingsView;
private ITexturePlatformSettingsView m_SecondaryTexturePlatformSettingsView;
private ITexturePlatformSettingsFormatHelper m_TexturePlatformSettingTextureHelper;
private ITexturePlatformSettingsController m_TexturePlatformSettingsController;
private SpriteAtlas spriteAtlas { get { return target as SpriteAtlas; } }
// The first two options are the main texture and a separator while the last two options are another separator and the new settings menu.
private bool secondaryTextureSelected { get { return m_SelectedPlatformSettings >= 2 && m_SelectedPlatformSettings <= m_PlatformSettingsOptions.Count - 3; } }
static bool IsPackable(Object o)
{
return o != null && (o.GetType() == typeof(Sprite) || o.GetType() == typeof(Texture2D) || (o.GetType() == typeof(DefaultAsset) && ProjectWindowUtil.IsFolder(o.GetInstanceID())));
}
static Object ValidateObjectForPackableFieldAssignment(Object[] references, System.Type objType, SerializedProperty property, EditorGUI.ObjectFieldValidatorOptions options)
{
// We only validate and care about the first one as this is a object field assignment.
if (references.Length > 0 && IsPackable(references[0]))
return references[0];
return null;
}
bool AllTargetsAreVariant()
{
foreach (SpriteAtlas sa in targets)
{
if (!sa.isVariant)
return false;
}
return true;
}
bool AllTargetsAreMaster()
{
foreach (SpriteAtlas sa in targets)
{
if (sa.isVariant)
return false;
}
return true;
}
void OnEnable()
{
if (targets == null)
return;
var validCount = 0;
foreach (var so in targets)
{
if (so != null)
validCount++;
}
if (validCount == 0)
return;
m_FilterMode = serializedObject.FindProperty("m_EditorData.textureSettings.filterMode");
m_AnisoLevel = serializedObject.FindProperty("m_EditorData.textureSettings.anisoLevel");
m_GenerateMipMaps = serializedObject.FindProperty("m_EditorData.textureSettings.generateMipMaps");
m_Readable = serializedObject.FindProperty("m_EditorData.textureSettings.readable");
m_UseSRGB = serializedObject.FindProperty("m_EditorData.textureSettings.sRGB");
m_EnableTightPacking = serializedObject.FindProperty("m_EditorData.packingSettings.enableTightPacking");
m_EnableAlphaDilation = serializedObject.FindProperty("m_EditorData.packingSettings.enableAlphaDilation");
m_EnableRotation = serializedObject.FindProperty("m_EditorData.packingSettings.enableRotation");
m_Padding = serializedObject.FindProperty("m_EditorData.packingSettings.padding");
m_MasterAtlas = serializedObject.FindProperty("m_MasterAtlas");
m_BindAsDefault = serializedObject.FindProperty("m_EditorData.bindAsDefault");
m_VariantScale = serializedObject.FindProperty("m_EditorData.variantMultiplier");
PopulatePlatformSettingsOptions();
m_Packables = serializedObject.FindProperty("m_EditorData.packables");
m_PackableList = new ReorderableList(serializedObject, m_Packables, true, true, true, true);
m_PackableList.drawHeaderCallback = DrawPackablesHeader;
m_PackableList.onAddCallback = AddPackable;
m_PackableList.onRemoveCallback = RemovePackable;
m_PackableList.drawElementCallback = DrawPackableElement;
m_PackableList.elementHeight = EditorGUIUtility.singleLineHeight;
m_PackableList.headerHeight = 3f + EditorGUIUtility.singleLineHeight;
SyncPlatformSettings();
m_TexturePlatformSettingsView = new SpriteAtlasInspectorPlatformSettingView(AllTargetsAreMaster());
m_TexturePlatformSettingTextureHelper = new TexturePlatformSettingsFormatHelper();
m_TexturePlatformSettingsController = new TexturePlatformSettingsViewController();
// Don't show max size option for secondary textures as they must have the same size as the main texture.
m_SecondaryTexturePlatformSettingsView = new SpriteAtlasInspectorPlatformSettingView(false);
}
// Populate the platform settings dropdown list with secondary texture names found through serialized properties of the Sprite Atlas assets.
private void PopulatePlatformSettingsOptions()
{
m_PlatformSettingsOptions = new List { L10n.Tr("Main Texture"), "", "", L10n.Tr("New Secondary Texture settings.") };
SerializedProperty secondaryPlatformSettings = serializedObject.FindProperty("m_EditorData.secondaryTextureSettings");
if (secondaryPlatformSettings != null && !secondaryPlatformSettings.hasMultipleDifferentValues)
{
int numSecondaryTextures = secondaryPlatformSettings.arraySize;
List secondaryTextureNames = new List(numSecondaryTextures);
for (int i = 0; i < numSecondaryTextures; ++i)
secondaryTextureNames.Add(secondaryPlatformSettings.GetArrayElementAtIndex(i).displayName);
// Insert after main texture and the separator.
m_PlatformSettingsOptions.InsertRange(2, secondaryTextureNames);
}
m_SelectedPlatformSettings = 0;
}
void SyncPlatformSettings()
{
m_TempPlatformSettings = new Dictionary>();
string secondaryTextureName = null;
if (secondaryTextureSelected)
secondaryTextureName = m_PlatformSettingsOptions[m_SelectedPlatformSettings];
// Default platform
var defaultSettings = new List();
m_TempPlatformSettings.Add(TextureImporterInspector.s_DefaultPlatformName, defaultSettings);
foreach (SpriteAtlas sa in targets)
{
var settings = secondaryTextureSelected
? sa.GetSecondaryPlatformSettings(TextureImporterInspector.s_DefaultPlatformName, secondaryTextureName)
: sa.GetPlatformSettings(TextureImporterInspector.s_DefaultPlatformName);
defaultSettings.Add(settings);
}
m_ValidPlatforms = BuildPlatforms.instance.GetValidPlatforms();
foreach (var platform in m_ValidPlatforms)
{
var platformSettings = new List();
m_TempPlatformSettings.Add(platform.name, platformSettings);
foreach (SpriteAtlas sa in targets)
{
var settings = secondaryTextureSelected
? sa.GetSecondaryPlatformSettings(platform.name, secondaryTextureName)
: sa.GetPlatformSettings(platform.name);
// setting will be in default state if copy failed
platformSettings.Add(settings);
}
}
}
void RenameSecondaryPlatformSettings(string oldName, string newName)
{
for (var i = 0; i < targets.Length; ++i)
{
SpriteAtlas sa = (SpriteAtlas)targets[i];
sa.DeleteSecondaryPlatformSettings(oldName);
var defaultPlatformSettings = m_TempPlatformSettings[TextureImporterInspector.s_DefaultPlatformName];
sa.SetSecondaryPlatformSettings(defaultPlatformSettings[i], newName);
foreach (var buildPlatform in m_ValidPlatforms)
{
var platformSettings = m_TempPlatformSettings[buildPlatform.name];
sa.SetSecondaryPlatformSettings(platformSettings[i], newName);
}
}
}
void DrawPackablesHeader(Rect headerRect)
{
EditorGUI.LabelField(headerRect, EditorGUIUtility.TempContent("Packables"));
}
void AddPackable(ReorderableList list)
{
ObjectSelector.get.Show(null, typeof(Object), null, false);
ObjectSelector.get.searchFilter = "t:sprite t:texture2d t:folder";
ObjectSelector.get.objectSelectorID = styles.packableSelectorHash;
}
void RemovePackable(ReorderableList list)
{
var index = list.index;
if (index != -1)
spriteAtlas.RemoveAt(index);
}
void DrawPackableElement(Rect rect, int index, bool selected, bool focused)
{
var property = m_Packables.GetArrayElementAtIndex(index);
var controlID = EditorGUIUtility.GetControlID(styles.packableElementHash, FocusType.Passive);
var previousObject = property.objectReferenceValue;
var changedObject = EditorGUI.DoObjectField(rect, rect, controlID, previousObject, target, typeof(Object), ValidateObjectForPackableFieldAssignment, false);
if (changedObject != previousObject)
{
// Always call Remove() on the previous object if we swapping the object field item.
// This ensure the Sprites was pack in this atlas will be refreshed of it unbound.
Undo.RegisterCompleteObjectUndo(spriteAtlas, styles.swapObjectRegisterUndo);
if (previousObject != null)
spriteAtlas.Remove(new Object[] { previousObject });
property.objectReferenceValue = changedObject;
}
if (GUIUtility.keyboardControl == controlID && !selected)
m_PackableList.index = index;
}
public override void OnInspectorGUI()
{
// Ensure changes done through script are reflected immediately in Inspector by Syncing m_TempPlatformSettings with Actual Settings.
SyncPlatformSettings();
serializedObject.Update();
HandleCommonSettingUI();
GUILayout.Space(EditorGUI.kSpacing);
if (AllTargetsAreVariant())
HandleVariantSettingUI();
else if (AllTargetsAreMaster())
HandleMasterSettingUI();
GUILayout.Space(EditorGUI.kSpacing);
HandleTextureSettingUI();
GUILayout.Space(EditorGUI.kSpacing);
// Only show the packable object list when:
// - This is a master atlas.
// - It is not currently selecting multiple atlases.
if (targets.Length == 1 && AllTargetsAreMaster())
HandlePackableListUI();
bool spriteAtlasPackingEnabled = (EditorSettings.spritePackerMode == SpritePackerMode.BuildTimeOnlyAtlas
|| EditorSettings.spritePackerMode == SpritePackerMode.AlwaysOnAtlas || EditorSettings.spritePackerMode == SpritePackerMode.SpriteAtlasV2);
if (spriteAtlasPackingEnabled && !Application.isPlaying)
{
using (new EditorGUI.DisabledScope(!Editor.IsPersistent(spriteAtlas)))
{
if (GUILayout.Button(styles.packButton, GUILayout.ExpandWidth(false)))
{
SpriteAtlas[] spriteAtlases = new SpriteAtlas[targets.Length];
for (int i = 0; i < spriteAtlases.Length; ++i)
spriteAtlases[i] = (SpriteAtlas)targets[i];
SpriteAtlasUtility.PackAtlases(spriteAtlases, EditorUserBuildSettings.activeBuildTarget);
// Packing an atlas might change platform settings in the process, reinitialize
SyncPlatformSettings();
GUIUtility.ExitGUI();
}
}
}
else
{
if (GUILayout.Button(styles.disabledPackLabel, EditorStyles.helpBox))
{
SettingsService.OpenProjectSettings("Project/Editor");
}
}
serializedObject.ApplyModifiedProperties();
}
private void HandleCommonSettingUI()
{
var atlasType = AtlasType.Undefined;
if (AllTargetsAreMaster())
atlasType = AtlasType.Master;
else if (AllTargetsAreVariant())
atlasType = AtlasType.Variant;
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = atlasType == AtlasType.Undefined;
using (new EditorGUI.DisabledScope(!Editor.IsPersistent(spriteAtlas)))
{
atlasType = (AtlasType)EditorGUILayout.IntPopup(styles.atlasTypeLabel, (int)atlasType, styles.atlasTypeOptions, styles.atlasTypeValues);
}
EditorGUI.showMixedValue = false;
if (EditorGUI.EndChangeCheck())
{
bool setToVariant = atlasType == AtlasType.Variant;
foreach (SpriteAtlas sa in targets)
sa.SetIsVariant(setToVariant);
// Reinit the platform setting view
m_TexturePlatformSettingsView = new SpriteAtlasInspectorPlatformSettingView(AllTargetsAreMaster());
}
if (atlasType == AtlasType.Variant)
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(m_MasterAtlas, styles.masterAtlasLabel);
if (EditorGUI.EndChangeCheck())
{
// Apply modified properties here to have latest master atlas reflected in native codes.
serializedObject.ApplyModifiedProperties();
foreach (SpriteAtlas sa in targets)
sa.CopyMasterAtlasSettings();
PopulatePlatformSettingsOptions();
SyncPlatformSettings();
}
}
EditorGUILayout.PropertyField(m_BindAsDefault, styles.bindAsDefaultLabel);
}
private void HandleVariantSettingUI()
{
EditorGUILayout.LabelField(styles.variantSettingLabel, EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_VariantScale, styles.variantMultiplierLabel);
// Test if the multiplier scale a power of two size (1024) into another power of 2 size.
if (!Mathf.IsPowerOfTwo((int)(m_VariantScale.floatValue * 1024)))
EditorGUILayout.HelpBox(styles.notPowerOfTwoWarning.text, MessageType.Warning, true);
}
private void HandleBoolToIntPropertyField(SerializedProperty prop, GUIContent content)
{
Rect rect = EditorGUILayout.GetControlRect();
EditorGUI.BeginProperty(rect, content, prop);
EditorGUI.BeginChangeCheck();
var boolValue = EditorGUI.Toggle(rect, content, prop.boolValue);
if (EditorGUI.EndChangeCheck())
prop.boolValue = boolValue;
EditorGUI.EndProperty();
}
private void HandleMasterSettingUI()
{
EditorGUILayout.LabelField(styles.packingParametersLabel, EditorStyles.boldLabel);
HandleBoolToIntPropertyField(m_EnableRotation, styles.enableRotationLabel);
HandleBoolToIntPropertyField(m_EnableTightPacking, styles.enableTightPackingLabel);
HandleBoolToIntPropertyField(m_EnableAlphaDilation, styles.enableAlphaDilationLabel);
EditorGUILayout.IntPopup(m_Padding, styles.paddingOptions, styles.paddingValues, styles.paddingLabel);
GUILayout.Space(EditorGUI.kSpacing);
}
private void HandleTextureSettingUI()
{
EditorGUILayout.LabelField(styles.textureSettingLabel, EditorStyles.boldLabel);
HandleBoolToIntPropertyField(m_Readable, styles.readWrite);
HandleBoolToIntPropertyField(m_GenerateMipMaps, styles.generateMipMapLabel);
HandleBoolToIntPropertyField(m_UseSRGB, styles.sRGBLabel);
EditorGUILayout.PropertyField(m_FilterMode);
var showAniso = !m_FilterMode.hasMultipleDifferentValues && !m_GenerateMipMaps.hasMultipleDifferentValues
&& (FilterMode)m_FilterMode.intValue != FilterMode.Point && m_GenerateMipMaps.boolValue;
if (showAniso)
EditorGUILayout.IntSlider(m_AnisoLevel, 0, 16);
GUILayout.Space(EditorGUI.kSpacing);
// "Show Platform Settings For" dropdown
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel(s_Styles.platformSettingsDropDownLabel);
EditorGUI.BeginChangeCheck();
m_SelectedPlatformSettings = EditorGUILayout.Popup(m_SelectedPlatformSettings, m_PlatformSettingsOptions.ToArray(), GUILayout.MaxWidth(150.0f));
if (EditorGUI.EndChangeCheck())
{
// New settings option is selected...
if (m_SelectedPlatformSettings == m_PlatformSettingsOptions.Count - 1)
{
m_PlatformSettingsOptions.Insert(m_SelectedPlatformSettings - 1, s_Styles.defaultTextForSecondaryTextureName);
m_SelectedPlatformSettings--;
EditorGUI.FocusTextInControl(s_Styles.secondaryTextureNameTextControlName);
}
SyncPlatformSettings();
}
if (secondaryTextureSelected)
{
// trash can button
if (GUILayout.Button(s_Styles.trashIcon, EditorStyles.iconButton, GUILayout.ExpandWidth(false)))
{
EditorGUI.EndEditingActiveTextField();
foreach (SpriteAtlas sa in targets)
sa.DeleteSecondaryPlatformSettings(m_PlatformSettingsOptions[m_SelectedPlatformSettings]);
m_PlatformSettingsOptions.RemoveAt(m_SelectedPlatformSettings);
m_SelectedPlatformSettings--;
if (m_SelectedPlatformSettings == 1)
m_SelectedPlatformSettings = 0;
SyncPlatformSettings();
}
}
}
EditorGUILayout.EndHorizontal();
// Texture platform settings UI.
EditorGUILayout.BeginHorizontal();
{
EditorGUI.indentLevel++;
GUILayout.Space(EditorGUI.indent);
EditorGUI.indentLevel--;
if (m_SelectedPlatformSettings == 0)
{
GUILayout.Space(EditorGUI.kSpacing);
HandlePlatformSettingUI(null);
}
else
{
EditorGUILayout.BeginVertical();
{
GUILayout.Space(EditorGUI.kSpacing);
string oldSecondaryTextureName = m_PlatformSettingsOptions[m_SelectedPlatformSettings];
GUI.SetNextControlName(s_Styles.secondaryTextureNameTextControlName);
EditorGUI.BeginChangeCheck();
string textFieldText = EditorGUILayout.DelayedTextField(s_Styles.secondaryTextureNameLabel, oldSecondaryTextureName);
if (EditorGUI.EndChangeCheck() && oldSecondaryTextureName != textFieldText)
{
if (!m_PlatformSettingsOptions.Exists(x => x == textFieldText))
{
m_PlatformSettingsOptions[m_SelectedPlatformSettings] = textFieldText;
RenameSecondaryPlatformSettings(oldSecondaryTextureName, textFieldText);
}
else
{
Debug.LogWarning(s_Styles.nameUniquenessWarning);
EditorGUI.FocusTextInControl(s_Styles.secondaryTextureNameTextControlName);
}
}
string secondaryTextureName = m_PlatformSettingsOptions[m_SelectedPlatformSettings];
SpriteAtlas sa = (SpriteAtlas)target;
EditorGUI.BeginChangeCheck();
bool value = EditorGUILayout.Toggle(s_Styles.sRGBLabel, sa.GetSecondaryColorSpace(secondaryTextureName));
if (EditorGUI.EndChangeCheck())
sa.SetSecondaryColorSpace(secondaryTextureName, value);
HandlePlatformSettingUI(textFieldText);
}
EditorGUILayout.EndVertical();
}
}
EditorGUILayout.EndHorizontal();
}
private void HandlePlatformSettingUI(string secondaryTextureName)
{
bool isSecondary = secondaryTextureName != null;
ITexturePlatformSettingsView view = isSecondary ? m_SecondaryTexturePlatformSettingsView : m_TexturePlatformSettingsView;
int shownTextureFormatPage = EditorGUILayout.BeginPlatformGrouping(m_ValidPlatforms.ToArray(), s_Styles.defaultPlatformLabel);
var defaultPlatformSettings = m_TempPlatformSettings[TextureImporterInspector.s_DefaultPlatformName];
if (shownTextureFormatPage == -1)
{
if (m_TexturePlatformSettingsController.HandleDefaultSettings(defaultPlatformSettings, view, m_TexturePlatformSettingTextureHelper))
{
for (var i = 0; i < defaultPlatformSettings.Count; ++i)
{
SpriteAtlas sa = (SpriteAtlas)targets[i];
if (isSecondary)
sa.SetSecondaryPlatformSettings(defaultPlatformSettings[i], secondaryTextureName);
else
sa.SetPlatformSettings(defaultPlatformSettings[i]);
}
}
}
else
{
var buildPlatform = m_ValidPlatforms[shownTextureFormatPage];
var platformSettings = m_TempPlatformSettings[buildPlatform.name];
for (var i = 0; i < platformSettings.Count; ++i)
{
var settings = platformSettings[i];
if (!settings.overridden)
{
if (defaultPlatformSettings[0].format == TextureImporterFormat.Automatic)
{
SpriteAtlas sa = (SpriteAtlas)targets[i];
settings.format = (TextureImporterFormat)sa.GetTextureFormat(buildPlatform.defaultTarget);
}
else
{
settings.format = defaultPlatformSettings[0].format;
}
settings.maxTextureSize = defaultPlatformSettings[0].maxTextureSize;
settings.crunchedCompression = defaultPlatformSettings[0].crunchedCompression;
settings.compressionQuality = defaultPlatformSettings[0].compressionQuality;
}
}
view.buildPlatformTitle = buildPlatform.title.text;
if (m_TexturePlatformSettingsController.HandlePlatformSettings(buildPlatform.defaultTarget, platformSettings, view, m_TexturePlatformSettingTextureHelper))
{
for (var i = 0; i < platformSettings.Count; ++i)
{
SpriteAtlas sa = (SpriteAtlas)targets[i];
if (isSecondary)
sa.SetSecondaryPlatformSettings(platformSettings[i], secondaryTextureName);
else
sa.SetPlatformSettings(platformSettings[i]);
}
}
}
EditorGUILayout.EndPlatformGrouping();
}
private void HandlePackableListUI()
{
var currentEvent = Event.current;
var usedEvent = false;
Rect rect = EditorGUILayout.GetControlRect();
var controlID = EditorGUIUtility.s_LastControlID;
switch (currentEvent.type)
{
case EventType.DragExited:
if (GUI.enabled)
HandleUtility.Repaint();
break;
case EventType.DragUpdated:
case EventType.DragPerform:
if (rect.Contains(currentEvent.mousePosition) && GUI.enabled)
{
// Check each single object, so we can add multiple objects in a single drag.
var didAcceptDrag = false;
var references = DragAndDrop.objectReferences;
foreach (var obj in references)
{
if (IsPackable(obj))
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
if (currentEvent.type == EventType.DragPerform)
{
m_Packables.AppendFoldoutPPtrValue(obj);
didAcceptDrag = true;
DragAndDrop.activeControlID = 0;
}
else
DragAndDrop.activeControlID = controlID;
}
}
if (didAcceptDrag)
{
GUI.changed = true;
DragAndDrop.AcceptDrag();
usedEvent = true;
}
}
break;
case EventType.ValidateCommand:
if (currentEvent.commandName == ObjectSelector.ObjectSelectorClosedCommand && ObjectSelector.get.objectSelectorID == styles.packableSelectorHash)
usedEvent = true;
break;
case EventType.ExecuteCommand:
if (currentEvent.commandName == ObjectSelector.ObjectSelectorClosedCommand && ObjectSelector.get.objectSelectorID == styles.packableSelectorHash)
{
var obj = ObjectSelector.GetCurrentObject();
if (IsPackable(obj))
{
m_Packables.AppendFoldoutPPtrValue(obj);
m_PackableList.index = m_Packables.arraySize - 1;
}
usedEvent = true;
}
break;
}
// Handle Foldout after we handle the current event because Foldout might process the drag and drop event and used it.
m_PackableListExpanded = EditorGUI.Foldout(rect, m_PackableListExpanded, styles.packableListLabel, true);
if (usedEvent)
currentEvent.Use();
if (m_PackableListExpanded)
{
EditorGUI.indentLevel++;
m_PackableList.DoLayoutList();
EditorGUI.indentLevel--;
}
}
void CachePreviewTexture()
{
if (m_PreviewTextures == null || m_Hash != spriteAtlas.GetHash())
{
m_PreviewTextures = spriteAtlas.GetPreviewTextures();
m_PreviewAlphaTextures = spriteAtlas.GetPreviewAlphaTextures();
m_Hash = spriteAtlas.GetHash();
if (m_PreviewTextures != null
&& m_PreviewTextures.Length > 0
&& m_TotalPages != m_PreviewTextures.Length)
{
m_TotalPages = m_PreviewTextures.Length;
m_OptionDisplays = new string[m_TotalPages];
m_OptionValues = new int[m_TotalPages];
for (int i = 0; i < m_TotalPages; ++i)
{
string texName = m_PreviewTextures[i].name;
var pageNum = SpriteAtlasExtensions.GetPageNumberInAtlas(texName);
var secondaryName = SpriteAtlasExtensions.GetSecondaryTextureNameInAtlas(texName);
m_OptionDisplays[i] = secondaryName == "" ? string.Format("MainTex - Page ({0})", pageNum) : string.Format("{0} - Page ({1})", secondaryName, pageNum);
m_OptionValues[i] = i;
}
}
}
}
public override string GetInfoString()
{
if (m_PreviewTextures != null && m_PreviewPage < m_PreviewTextures.Length)
{
Texture2D t = m_PreviewTextures[m_PreviewPage];
GraphicsFormat format = GraphicsFormatUtility.GetFormat(t);
return string.Format("{0}x{1} {2}\n{3}", t.width, t.height, GraphicsFormatUtility.GetFormatString(format), EditorUtility.FormatBytes(TextureUtil.GetStorageMemorySizeLong(t)));
}
return "";
}
public override bool HasPreviewGUI()
{
CachePreviewTexture();
return (m_PreviewTextures != null && m_PreviewTextures.Length > 0);
}
public override void OnPreviewSettings()
{
// Do not allow changing of pages when multiple atlases is selected.
if (targets.Length == 1 && m_OptionDisplays != null && m_OptionValues != null && m_TotalPages > 1)
m_PreviewPage = EditorGUILayout.IntPopup(m_PreviewPage, m_OptionDisplays, m_OptionValues, styles.preDropDown, GUILayout.MaxWidth(50));
else
m_PreviewPage = 0;
if (m_PreviewTextures != null)
{
m_PreviewPage = Mathf.Min(m_PreviewPage, m_PreviewTextures.Length - 1);
Texture2D t = m_PreviewTextures[m_PreviewPage];
if (GraphicsFormatUtility.HasAlphaChannel(t.format) || (m_PreviewAlphaTextures != null && m_PreviewAlphaTextures.Length > 0))
m_ShowAlpha = GUILayout.Toggle(m_ShowAlpha, m_ShowAlpha ? styles.alphaIcon : styles.RGBIcon, styles.previewButton);
int mipCount = Mathf.Max(1, TextureUtil.GetMipmapCount(t));
if (mipCount > 1)
{
GUILayout.Box(styles.smallZoom, styles.previewLabel);
m_MipLevel = Mathf.Round(GUILayout.HorizontalSlider(m_MipLevel, mipCount - 1, 0, styles.previewSlider, styles.previewSliderThumb, GUILayout.MaxWidth(64)));
GUILayout.Box(styles.largeZoom, styles.previewLabel);
}
}
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
CachePreviewTexture();
if (m_ShowAlpha && m_PreviewAlphaTextures != null && m_PreviewPage < m_PreviewAlphaTextures.Length)
{
var at = m_PreviewAlphaTextures[m_PreviewPage];
var bias = m_MipLevel - (float)(System.Math.Log(at.width / r.width) / System.Math.Log(2));
EditorGUI.DrawTextureTransparent(r, at, ScaleMode.ScaleToFit, 0, bias);
}
else if (m_PreviewTextures != null && m_PreviewPage < m_PreviewTextures.Length)
{
Texture2D t = m_PreviewTextures[m_PreviewPage];
float bias = m_MipLevel - (float)(System.Math.Log(t.width / r.width) / System.Math.Log(2));
if (m_ShowAlpha)
EditorGUI.DrawTextureAlpha(r, t, ScaleMode.ScaleToFit, 0, bias);
else
EditorGUI.DrawTextureTransparent(r, t, ScaleMode.ScaleToFit, 0, bias);
}
}
}
}
================================================
FILE: Editor/Mono/Accessibility/UserAccessibilitySettings.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
namespace UnityEditor.Accessibility
{
internal enum ColorBlindCondition
{
Default,
Deuteranopia,
Protanopia,
Tritanopia,
}
// NOTE: The preferences in this class are currently only exposed via a context menu in the ProfilerWindow
// these toggles need to instead be moved to e.g., the Preferences menu before they are used elsewhere
internal static class UserAccessiblitySettings
{
static UserAccessiblitySettings()
{
s_ColorBlindCondition = (ColorBlindCondition)EditorPrefs.GetInt(k_ColorBlindConditionPrefKey, (int)ColorBlindCondition.Default);
}
private const string k_ColorBlindConditionPrefKey = "AccessibilityColorBlindCondition";
public static ColorBlindCondition colorBlindCondition
{
get { return s_ColorBlindCondition; }
set
{
if (s_ColorBlindCondition != value)
{
s_ColorBlindCondition = value;
EditorPrefs.SetInt(k_ColorBlindConditionPrefKey, (int)value);
if (colorBlindConditionChanged != null)
colorBlindConditionChanged();
}
}
}
private static ColorBlindCondition s_ColorBlindCondition;
public static Action colorBlindConditionChanged;
}
}
================================================
FILE: Editor/Mono/Animation/AnimationClipSettings.bindings.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
using System.Runtime.InteropServices;
using UnityEngine;
using UnityEngine.Bindings;
using UnityEngine.Scripting;
using UnityEngine.Playables;
using UnityEngine.Scripting.APIUpdating;
using UnityEngine.Internal;
namespace UnityEditor
{
[NativeType(CodegenOptions.Custom, "MonoAnimationClipSettings")]
[NativeAsStruct]
[StructLayout(LayoutKind.Sequential)]
[RequiredByNativeCode]
public class AnimationClipSettings
{
public AnimationClip additiveReferencePoseClip;
public float additiveReferencePoseTime;
public float startTime;
public float stopTime;
public float orientationOffsetY;
public float level;
public float cycleOffset;
public bool hasAdditiveReferencePose;
public bool loopTime;
public bool loopBlend;
public bool loopBlendOrientation;
public bool loopBlendPositionY;
public bool loopBlendPositionXZ;
public bool keepOriginalOrientation;
public bool keepOriginalPositionY;
public bool keepOriginalPositionXZ;
public bool heightFromFeet;
public bool mirror;
}
}
================================================
FILE: Editor/Mono/Animation/AnimationClipStats.bindings.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
using UnityEngine;
using UnityEngine.Bindings;
using UnityEngine.Scripting;
using UnityEngine.Playables;
using UnityEngine.Scripting.APIUpdating;
using UnityEngine.Internal;
namespace UnityEditor
{
// Must be kept in sync with AnimationClipStats in AnimationClipStats
internal struct AnimationClipStats
{
public int size;
public int clips;
public int positionCurves;
public int quaternionCurves;
public int eulerCurves;
public int scaleCurves;
public int muscleCurves;
public int genericCurves;
public int pptrCurves;
public int totalCurves;
public int constantCurves;
public int denseCurves;
public int streamCurves;
public void Reset()
{
size = 0;
clips = 0;
positionCurves = 0;
quaternionCurves = 0;
eulerCurves = 0;
scaleCurves = 0;
muscleCurves = 0;
genericCurves = 0;
pptrCurves = 0;
totalCurves = 0;
constantCurves = 0;
denseCurves = 0;
streamCurves = 0;
}
public void Combine(AnimationClipStats other)
{
size += other.size;
clips += other.clips;
positionCurves += other.positionCurves;
quaternionCurves += other.quaternionCurves;
eulerCurves += other.eulerCurves;
scaleCurves += other.scaleCurves;
muscleCurves += other.muscleCurves;
genericCurves += other.genericCurves;
pptrCurves += other.pptrCurves;
totalCurves += other.totalCurves;
constantCurves += other.constantCurves;
denseCurves += other.denseCurves;
streamCurves += other.streamCurves;
}
}
}
================================================
FILE: Editor/Mono/Animation/AnimationMode.bindings.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
using UnityEngine.Bindings;
using UnityEngine.Scripting;
using UnityEngine.Scripting.APIUpdating;
using UnityEngine.Playables;
using UnityEngine;
using Object = UnityEngine.Object;
namespace UnityEditor
{
public class AnimationModeDriver : ScriptableObject
{
internal delegate bool IsKeyCallback(Object target, string propertyPath);
internal IsKeyCallback isKeyCallback;
[UsedByNativeCode]
internal bool InvokeIsKeyCallback_Internal(Object target, string propertyPath)
{
if (isKeyCallback == null)
return false;
return isKeyCallback(target, propertyPath);
}
}
[NativeHeader("Editor/Src/Animation/AnimationMode.bindings.h")]
[NativeHeader("Editor/Src/Animation/EditorCurveBinding.bindings.h")]
[NativeHeader("Editor/Src/Prefabs/PropertyModification.h")]
public class AnimationMode
{
static private bool s_InAnimationPlaybackMode = false;
static private bool s_InAnimationRecordMode = false;
static internal event Action onAnimationRecordingStart;
static internal event Action onAnimationRecordingStop;
static private PrefColor s_AnimatedPropertyColor = new PrefColor("Animation/Property Animated", 0.82f, 0.97f, 1.00f, 1.00f, 0.54f, 0.85f, 1.00f, 1.00f);
static private PrefColor s_RecordedPropertyColor = new PrefColor("Animation/Property Recorded", 1.00f, 0.60f, 0.60f, 1.00f, 1.00f, 0.50f, 0.50f, 1.00f);
static private PrefColor s_CandidatePropertyColor = new PrefColor("Animation/Property Candidate", 1.00f, 0.70f, 0.60f, 1.00f, 1.00f, 0.67f, 0.43f, 1.00f);
static public Color animatedPropertyColor { get { return s_AnimatedPropertyColor; } }
static public Color recordedPropertyColor { get { return s_RecordedPropertyColor; } }
static public Color candidatePropertyColor { get { return s_CandidatePropertyColor; } }
static private AnimationModeDriver s_DummyDriver;
static private AnimationModeDriver DummyDriver()
{
if (s_DummyDriver == null)
{
s_DummyDriver = ScriptableObject.CreateInstance();
s_DummyDriver.name = "DummyDriver";
}
return s_DummyDriver;
}
extern public static bool IsPropertyAnimated(Object target, string propertyPath);
extern internal static bool IsPropertyCandidate(Object target, string propertyPath);
// Stops animation mode, as used by the animation editor.
public static void StopAnimationMode()
{
Internal_StopAnimationMode(DummyDriver());
}
// Stops animation mode, as used by the animation editor.
public static void StopAnimationMode(AnimationModeDriver driver)
{
Internal_StopAnimationMode(driver);
}
// Returns true if the editor is currently in animation mode.
public static bool InAnimationMode()
{
return Internal_InAnimationModeNoDriver();
}
// Returns true if the editor is currently in animation mode.
public static bool InAnimationMode(AnimationModeDriver driver)
{
return Internal_InAnimationMode(driver);
}
// Starts animation mode, as used by the animation editor.
public static void StartAnimationMode()
{
Internal_StartAnimationMode(DummyDriver());
}
// Starts animation mode, as used by the animation editor.
public static void StartAnimationMode(AnimationModeDriver driver)
{
Internal_StartAnimationMode(driver);
}
// Stops animation playback mode, as used by the animation editor.
internal static void StopAnimationPlaybackMode()
{
s_InAnimationPlaybackMode = false;
}
// Returns true if the editor is currently in animation playback mode.
internal static bool InAnimationPlaybackMode()
{
return s_InAnimationPlaybackMode;
}
// Starts animation mode, as used by the animation editor playback mode.
internal static void StartAnimationPlaybackMode()
{
s_InAnimationPlaybackMode = true;
}
internal static void StopAnimationRecording()
{
s_InAnimationRecordMode = false;
onAnimationRecordingStop?.Invoke();
}
internal static bool InAnimationRecording()
{
return s_InAnimationRecordMode;
}
internal static void StartAnimationRecording()
{
s_InAnimationRecordMode = true;
onAnimationRecordingStart?.Invoke();
}
internal static void StartCandidateRecording(AnimationModeDriver driver)
{
Internal_StartCandidateRecording(driver);
}
[NativeThrows]
extern internal static void AddCandidate(EditorCurveBinding binding, PropertyModification modification, bool keepPrefabOverride);
[NativeThrows]
extern internal static void AddCandidates([NotNull] GameObject gameObject, [NotNull] AnimationClip clip);
extern internal static void StopCandidateRecording();
extern internal static bool IsRecordingCandidates();
[NativeThrows]
extern public static void BeginSampling();
[NativeThrows]
extern public static void EndSampling();
[NativeThrows]
extern public static void SampleAnimationClip([NotNull] GameObject gameObject, [NotNull] AnimationClip clip, float time);
[NativeThrows]
extern internal static void SampleCandidateClip([NotNull] GameObject gameObject, [NotNull] AnimationClip clip, float time);
[NativeThrows]
extern public static void SamplePlayableGraph(PlayableGraph graph, int index, float time);
[NativeThrows]
extern public static void AddPropertyModification(EditorCurveBinding binding, PropertyModification modification, bool keepPrefabOverride);
[NativeThrows]
extern public static void AddEditorCurveBinding([NotNull] GameObject gameObject, EditorCurveBinding binding);
[NativeThrows]
extern internal static void AddTransformTR([NotNull] GameObject root, string path);
[NativeThrows]
extern internal static void AddTransformTRS([NotNull] GameObject root, string path);
[NativeThrows]
extern internal static void InitializePropertyModificationForGameObject([NotNull] GameObject gameObject, [NotNull] AnimationClip clip);
[NativeThrows]
extern internal static void InitializePropertyModificationForObject([NotNull] Object target, [NotNull] AnimationClip clip);
[NativeThrows]
extern internal static void RevertPropertyModificationsForGameObject([NotNull] GameObject gameObject);
[NativeThrows]
extern internal static void RevertPropertyModificationsForObject([NotNull] Object target);
// Returns editor curve bindings for animation clip and animator hierarchy that need to be snapshot for animation mode.
extern internal static EditorCurveBinding[] GetAllBindings([NotNull] GameObject root, [NotNull] AnimationClip clip);
// Returns editor curve bindings for animation clip that need to be snapshot for animation mode.
extern internal static EditorCurveBinding[] GetCurveBindings([NotNull] AnimationClip clip);
// Return editor curve bindings for animator hierarhcy that need to be snapshot for animation mode.
extern internal static EditorCurveBinding[] GetAnimatorBindings([NotNull] GameObject root);
extern private static void Internal_StartAnimationMode(Object driver);
extern private static void Internal_StopAnimationMode(Object driver);
extern private static bool Internal_InAnimationMode(Object driver);
extern private static bool Internal_InAnimationModeNoDriver();
[NativeThrows]
extern private static void Internal_StartCandidateRecording(Object driver);
}
}
================================================
FILE: Editor/Mono/Animation/AnimationUtility.bindings.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine.Bindings;
using UnityEngine.Scripting;
using UnityEngine.Scripting.APIUpdating;
using UnityEngine;
using UnityEngine.Internal;
using Object = UnityEngine.Object;
using UnityEngine.Animations;
namespace UnityEditor
{
public struct ObjectReferenceKeyframe
{
public float time;
public UnityEngine.Object value;
}
// An AnimationClipCurveData object contains all the information needed to identify a specific curve in an AnimationClip. The curve animates a specific property of a component / material attached to a game object / animated bone.
public class AnimationClipCurveData
{
// The path of the game object / bone being animated.
public string path;
// The type of the component / material being animated.
public Type type;
// The name of the property being animated.
public string propertyName;
// The actual animation curve.
public AnimationCurve curve;
// This is only used internally for deleting curves
internal int classID;
internal int scriptInstanceID;
public AnimationClipCurveData()
{
}
public AnimationClipCurveData(EditorCurveBinding binding)
{
path = binding.path;
type = binding.type;
propertyName = binding.propertyName;
curve = null;
classID = binding.m_ClassID;
scriptInstanceID = binding.m_ScriptInstanceID;
}
}
[NativeHeader("Editor/Src/Animation/AnimationUtility.bindings.h")]
[NativeHeader("Modules/Animation/ScriptBindings/GenericBinding.bindings.h")]
public partial class AnimationUtility
{
public enum CurveModifiedType
{
CurveDeleted = 0,
CurveModified = 1,
ClipModified = 2
}
public enum TangentMode
{
Free = 0,
Auto = 1,
Linear = 2,
Constant = 3,
ClampedAuto = 4
}
internal enum PolynomialValid
{
Valid = 0,
InvalidPreWrapMode = 1,
InvalidPostWrapMode = 2,
TooManySegments = 3
}
internal enum DiscreteBindingResult
{
Valid = 0,
InvalidScript = 1,
MissingField = 2,
IncompatibleFieldType = 3,
MissingDiscreteAttribute = 4
}
public delegate void OnCurveWasModified(AnimationClip clip, EditorCurveBinding binding, CurveModifiedType type);
public static OnCurveWasModified onCurveWasModified;
[RequiredByNativeCode]
private static void Internal_CallOnCurveWasModified(AnimationClip clip, EditorCurveBinding binding, CurveModifiedType type)
{
if (onCurveWasModified != null)
onCurveWasModified(clip, binding, type);
}
[RequiredByNativeCode]
private static void Internal_CallAnimationClipAwake(AnimationClip clip)
{
if (onCurveWasModified != null)
onCurveWasModified(clip, new EditorCurveBinding(), CurveModifiedType.ClipModified);
}
[Obsolete("GetAnimationClips(Animation) is deprecated. Use GetAnimationClips(GameObject) instead.")]
public static AnimationClip[] GetAnimationClips(Animation component)
{
return GetAnimationClipsInAnimationPlayer(component.gameObject);
}
// Returns the array of AnimationClips that are referenced in the Animation component
public static AnimationClip[] GetAnimationClips(GameObject gameObject)
{
if (gameObject == null)
throw new ArgumentNullException("gameObject");
AnimationClip[] clips = GetAnimationClipsInAnimationPlayer(gameObject);
IAnimationClipSource[] clipSources = gameObject.GetComponents();
if (clipSources.Length > 0)
{
var allClips = new List(clips);
for (int i = 0; i < clipSources.Length; ++i)
{
var extraClips = new List();
clipSources[i].GetAnimationClips(extraClips);
allClips.Capacity = allClips.Count + extraClips.Count;
foreach (var clip in extraClips)
{
if (clip != null)
allClips.Add(clip);
}
}
return allClips.ToArray();
}
return clips;
}
// Returns the array of AnimationClips that are referenced in the Animation component
extern internal static AnimationClip[] GetAnimationClipsInAnimationPlayer([NotNull] GameObject gameObject);
// Sets the array of AnimationClips to be referenced in the Animation component
extern public static void SetAnimationClips([NotNull] Animation animation, [Unmarshalled] AnimationClip[] clips);
public static EditorCurveBinding[] GetAnimatableBindings(GameObject targetObject, GameObject root)
{
return Internal_GetGameObjectAnimatableBindings(targetObject, root);
}
internal static EditorCurveBinding[] GetAnimatableBindings(ScriptableObject scriptableObject)
{
return Internal_GetScriptableObjectAnimatableBindings(scriptableObject);
}
internal static EditorCurveBinding[] GetAnimationStreamBindings(GameObject root)
{
return Internal_GetAnimationStreamBindings(root);
}
extern private static EditorCurveBinding[] Internal_GetGameObjectAnimatableBindings([NotNull] GameObject targetObject, [NotNull] GameObject root);
extern private static EditorCurveBinding[] Internal_GetScriptableObjectAnimatableBindings([NotNull] ScriptableObject scriptableObject);
extern private static EditorCurveBinding[] Internal_GetAnimationStreamBindings([NotNull] GameObject root);
// Binds the property and returns the type of the bound value (Can be used to display special UI for it and to enforce correct drag and drop)
// null if it can't be bound.
public static System.Type GetEditorCurveValueType(GameObject root, EditorCurveBinding binding)
{
return Internal_GetGameObjectEditorCurveValueType(root, binding);
}
internal static System.Type GetEditorCurveValueType(ScriptableObject scriptableObject, EditorCurveBinding binding)
{
return Internal_GetScriptableObjectEditorCurveValueType(scriptableObject, binding);
}
extern private static System.Type Internal_GetGameObjectEditorCurveValueType([NotNull] GameObject root, EditorCurveBinding binding);
extern private static System.Type Internal_GetScriptableObjectEditorCurveValueType([NotNull] ScriptableObject scriptableObject, EditorCurveBinding binding);
extern public static bool GetFloatValue([NotNull] GameObject root, EditorCurveBinding binding, out float data);
extern public static bool GetDiscreteIntValue([NotNull] GameObject root, EditorCurveBinding binding, out int data);
public static bool GetObjectReferenceValue(GameObject root, EditorCurveBinding binding, out Object data)
{
data = Internal_GetObjectReferenceValue(root, binding, out bool result);
return result;
}
extern private static Object Internal_GetObjectReferenceValue([NotNull] GameObject root, EditorCurveBinding binding, out bool result);
extern public static Object GetAnimatedObject([NotNull] GameObject root, EditorCurveBinding binding);
public static Type PropertyModificationToEditorCurveBinding(PropertyModification modification, GameObject gameObject, out EditorCurveBinding binding)
{
binding = new EditorCurveBinding();
binding.type = typeof(Object); // dummy type to avoid errors while marshalling.
if (modification == null)
return null;
return Internal_PropertyModificationToEditorCurveBinding(modification, gameObject, out binding);
}
extern private static Type Internal_PropertyModificationToEditorCurveBinding(PropertyModification modification, [NotNull] GameObject gameObject, out EditorCurveBinding binding);
extern internal static PropertyModification EditorCurveBindingToPropertyModification(EditorCurveBinding binding, [NotNull] GameObject gameObject);
extern public static EditorCurveBinding[] GetCurveBindings([NotNull] AnimationClip clip);
extern public static EditorCurveBinding[] GetObjectReferenceCurveBindings([NotNull] AnimationClip clip);
extern public static ObjectReferenceKeyframe[] GetObjectReferenceCurve([NotNull] AnimationClip clip, EditorCurveBinding binding);
public static void SetObjectReferenceCurve(AnimationClip clip, EditorCurveBinding binding, [Unmarshalled]ObjectReferenceKeyframe[] keyframes)
{
Internal_SetObjectReferenceCurve(clip, binding, keyframes, true);
Internal_InvokeOnCurveWasModified(clip, binding, keyframes != null ? CurveModifiedType.CurveModified : CurveModifiedType.CurveDeleted);
}
public static void SetObjectReferenceCurves(AnimationClip clip, EditorCurveBinding[] bindings, ObjectReferenceKeyframe[][] keyframes)
{
if (bindings == null)
throw new ArgumentNullException(nameof(bindings), $"{nameof(bindings)} must be non-null");
if (keyframes == null)
throw new ArgumentNullException(nameof(keyframes), $"{nameof(keyframes)} must be non-null");
if (bindings.Length != keyframes.Length)
throw new InvalidOperationException($"{nameof(bindings)} and {nameof(keyframes)} must be of equal length");
int length = bindings.Length;
for (int i = 0; i < length; i++)
{
SetObjectReferenceCurveNoSync(clip, bindings[i], keyframes[i]);
}
SyncEditorCurves(clip);
Internal_InvokeOnCurveWasModified(clip, new EditorCurveBinding(), CurveModifiedType.ClipModified);
}
internal static void SetObjectReferenceCurveNoSync(AnimationClip clip, EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes)
{
Internal_SetObjectReferenceCurve(clip, binding, keyframes, false);
Internal_InvokeOnCurveWasModified(clip, binding, keyframes != null ? CurveModifiedType.CurveModified : CurveModifiedType.CurveDeleted);
}
[NativeThrows]
extern private static void Internal_SetObjectReferenceCurve([NotNull] AnimationClip clip, EditorCurveBinding binding, [Unmarshalled] ObjectReferenceKeyframe[] keyframes, bool updateMuscleClip);
extern public static AnimationCurve GetEditorCurve([NotNull] AnimationClip clip, EditorCurveBinding binding);
public static void SetEditorCurve(AnimationClip clip, EditorCurveBinding binding, AnimationCurve curve)
{
Internal_SetEditorCurve(clip, binding, curve, true);
Internal_InvokeOnCurveWasModified(clip, binding, curve != null ? CurveModifiedType.CurveModified : CurveModifiedType.CurveDeleted);
}
public static void SetEditorCurves(AnimationClip clip, EditorCurveBinding[] bindings, AnimationCurve[] curves)
{
if (bindings == null)
throw new ArgumentNullException(nameof(bindings), $"{nameof(bindings)} must be non-null");
if (curves == null)
throw new ArgumentNullException(nameof(curves), $"{nameof(curves)} must be non-null");
if (bindings.Length != curves.Length)
throw new InvalidOperationException($"{nameof(bindings)} and {nameof(curves)} must be of equal length");
int length = bindings.Length;
for (int i = 0; i < length; i++)
{
SetEditorCurveNoSync(clip, bindings[i], curves[i]);
}
SyncEditorCurves(clip);
Internal_InvokeOnCurveWasModified(clip, new EditorCurveBinding(), AnimationUtility.CurveModifiedType.ClipModified);
}
internal static void SetEditorCurveNoSync(AnimationClip clip, EditorCurveBinding binding, AnimationCurve curve)
{
Internal_SetEditorCurve(clip, binding, curve, false);
Internal_InvokeOnCurveWasModified(clip, binding, curve != null ? CurveModifiedType.CurveModified : CurveModifiedType.CurveDeleted);
}
[NativeThrows]
extern private static void Internal_SetEditorCurve([NotNull] AnimationClip clip, EditorCurveBinding binding, AnimationCurve curve, bool syncEditorCurves);
extern internal static DiscreteBindingResult IsDiscreteIntBinding(EditorCurveBinding binding);
extern internal static void SyncEditorCurves([NotNull] AnimationClip clip);
private static void Internal_InvokeOnCurveWasModified(AnimationClip clip, EditorCurveBinding binding, CurveModifiedType type)
{
if (onCurveWasModified != null)
{
onCurveWasModified(clip, binding, type);
}
}
[NativeThrows]
extern internal static void UpdateTangentsFromModeSurrounding([NotNull] AnimationCurve curve, int index);
extern internal static void UpdateTangentsFromMode([NotNull] AnimationCurve curve);
[NativeThrows, ThreadSafe]
extern public static TangentMode GetKeyLeftTangentMode([NotNull] AnimationCurve curve, int index);
[NativeThrows, ThreadSafe]
extern public static TangentMode GetKeyRightTangentMode([NotNull] AnimationCurve curve, int index);
[NativeThrows]
extern public static bool GetKeyBroken([NotNull] AnimationCurve curve, int index);
[NativeThrows, ThreadSafe]
extern public static void SetKeyLeftTangentMode([NotNull] AnimationCurve curve, int index, TangentMode tangentMode);
[NativeThrows, ThreadSafe]
extern public static void SetKeyRightTangentMode([NotNull] AnimationCurve curve, int index, TangentMode tangentMode);
[NativeThrows]
extern public static void SetKeyBroken([NotNull] AnimationCurve curve, int index, bool broken);
internal static TangentMode GetKeyLeftTangentMode(Keyframe key)
{
return Internal_GetKeyLeftTangentMode(key);
}
internal static TangentMode GetKeyRightTangentMode(Keyframe key)
{
return Internal_GetKeyRightTangentMode(key);
}
internal static bool GetKeyBroken(Keyframe key)
{
return Internal_GetKeyBroken(key);
}
extern private static TangentMode Internal_GetKeyLeftTangentMode(Keyframe key);
extern private static TangentMode Internal_GetKeyRightTangentMode(Keyframe key);
extern private static bool Internal_GetKeyBroken(Keyframe key);
internal static void SetKeyLeftTangentMode(ref Keyframe key, TangentMode tangentMode)
{
Internal_SetKeyLeftTangentMode(ref key, tangentMode);
}
internal static void SetKeyRightTangentMode(ref Keyframe key, TangentMode tangentMode)
{
Internal_SetKeyRightTangentMode(ref key, tangentMode);
}
internal static void SetKeyBroken(ref Keyframe key, bool broken)
{
Internal_SetKeyBroken(ref key, broken);
}
extern private static void Internal_SetKeyLeftTangentMode(ref Keyframe key, TangentMode tangentMode);
extern private static void Internal_SetKeyRightTangentMode(ref Keyframe key, TangentMode tangentMode);
extern private static void Internal_SetKeyBroken(ref Keyframe key, bool broken);
[NativeThrows]
extern internal static int AddInbetweenKey(AnimationCurve curve, float time);
[Obsolete("GetAllCurves is deprecated. Use GetCurveBindings and GetObjectReferenceCurveBindings instead.")]
public static AnimationClipCurveData[] GetAllCurves(AnimationClip clip)
{
bool includeCurveData = true;
return GetAllCurves(clip, includeCurveData);
}
[Obsolete("GetAllCurves is deprecated. Use GetCurveBindings and GetObjectReferenceCurveBindings instead.")]
public static AnimationClipCurveData[] GetAllCurves(AnimationClip clip, [DefaultValue("true")] bool includeCurveData)
{
EditorCurveBinding[] bindings = GetCurveBindings(clip);
AnimationClipCurveData[] curves = new AnimationClipCurveData[bindings.Length];
for (int i = 0; i < curves.Length; i++)
{
curves[i] = new AnimationClipCurveData(bindings[i]);
if (includeCurveData)
curves[i].curve = GetEditorCurve(clip, bindings[i]);
}
return curves;
}
[Obsolete("This overload is deprecated. Use the one with EditorCurveBinding instead.")]
public static bool GetFloatValue(GameObject root, string relativePath, Type type, string propertyName, out float data)
{
return GetFloatValue(root, EditorCurveBinding.FloatCurve(relativePath, type, propertyName), out data);
}
[Obsolete("This overload is deprecated. Use the one with EditorCurveBinding instead.")]
public static void SetEditorCurve(AnimationClip clip, string relativePath, Type type, string propertyName, AnimationCurve curve)
{
SetEditorCurve(clip, EditorCurveBinding.FloatCurve(relativePath, type, propertyName), curve);
}
[Obsolete("This overload is deprecated. Use the one with EditorCurveBinding instead.")]
public static AnimationCurve GetEditorCurve(AnimationClip clip, string relativePath, Type type, string propertyName)
{
return GetEditorCurve(clip, EditorCurveBinding.FloatCurve(relativePath, type, propertyName));
}
public static AnimationEvent[] GetAnimationEvents(AnimationClip clip)
{
var blittableEvents = GetAnimationEventsInternal(clip);
var animationEvents = blittableEvents.Select(AnimationEventBlittable.ToAnimationEvent).ToArray();
foreach (var blittableEvent in blittableEvents)
blittableEvent.Dispose();
return animationEvents;
}
[return:Unmarshalled]
extern internal static AnimationEventBlittable[] GetAnimationEventsInternal([NotNull] AnimationClip clip);
public static void SetAnimationEvents(AnimationClip clip, AnimationEvent[] events)
{
var blittableEvents = events.Select(AnimationEventBlittable.FromAnimationEvent).ToArray();
SetAnimationEventsInternal(clip, blittableEvents);
foreach (var blittableEvent in blittableEvents)
blittableEvent.Dispose();
}
extern internal static void SetAnimationEventsInternal([NotNull] AnimationClip clip, [NotNull] AnimationEventBlittable[] events);
extern public static string CalculateTransformPath([NotNull] Transform targetTransform, Transform root);
extern public static AnimationClipSettings GetAnimationClipSettings([NotNull] AnimationClip clip);
extern internal static void RebuildMecanimData([NotNull] AnimationClip clip);
extern public static void SetAnimationClipSettings([NotNull] AnimationClip clip, AnimationClipSettings srcClipInfo);
extern internal static void SetAnimationClipSettingsNoDirty([NotNull] AnimationClip clip, AnimationClipSettings srcClipInfo);
extern public static void SetAdditiveReferencePose(AnimationClip clip, AnimationClip referenceClip, float time);
extern internal static bool IsValidOptimizedPolynomialCurve(AnimationCurve curve);
extern public static void ConstrainToPolynomialCurve(AnimationCurve curve);
extern internal static int GetMaxNumPolynomialSegmentsSupported();
extern internal static PolynomialValid IsValidPolynomialCurve(AnimationCurve curve);
extern internal static AnimationClipStats GetAnimationClipStats(AnimationClip clip);
[Obsolete("This is not used anymore. Root motion curves are automatically generated if applyRootMotion is enabled on Animator component.")]
public static bool GetGenerateMotionCurves(AnimationClip clip)
{
return true;
}
[Obsolete("This is not used anymore. Root motion curves are automatically generated if applyRootMotion is enabled on Animator component.")]
public static void SetGenerateMotionCurves(AnimationClip clip, bool value)
{
}
[Obsolete("Use AnimationClip.hasGenericRootTransform instead.")]
extern internal static bool HasGenericRootTransform(AnimationClip clip);
[Obsolete("Use AnimationClip.hasMotionFloatCurves instead.")]
extern internal static bool HasMotionFloatCurves(AnimationClip clip);
[Obsolete("Use AnimationClip.hasMotionCurves instead.")]
extern internal static bool HasMotionCurves(AnimationClip clip);
[Obsolete("Use AnimationClip.hasRootCurves instead.")]
extern internal static bool HasRootCurves(AnimationClip clip);
extern internal static bool AmbiguousBinding(string path, int classID, Transform root);
extern internal static Vector3 GetClosestEuler(Quaternion q, Vector3 eulerHint, RotationOrder rotationOrder);
[NativeHeader("Modules/Animation/AnimationUtility.h")]
[FreeFunction]
extern internal static void SampleEulerHint([NotNull] GameObject go, [NotNull] AnimationClip clip, float inTime, WrapMode wrapMode);
[Obsolete("Use AnimationMode.InAnimationMode instead.")]
static public bool InAnimationMode()
{
return AnimationMode.InAnimationMode();
}
[Obsolete("Use AnimationMode.StartAnimationmode instead.")]
public static void StartAnimationMode(Object[] objects)
{
Debug.LogWarning("AnimationUtility.StartAnimationMode is deprecated. Use AnimationMode.StartAnimationMode with the new APIs. The objects passed to this function will no longer be reverted automatically. See AnimationMode.AddPropertyModification");
AnimationMode.StartAnimationMode();
}
[Obsolete("Use AnimationMode.StopAnimationMode instead.")]
public static void StopAnimationMode()
{
AnimationMode.StopAnimationMode();
}
[Obsolete("SetAnimationType is no longer supported.")]
public static void SetAnimationType(AnimationClip clip, ModelImporterAnimationType type) {}
extern public static GenericBinding[] EditorCurveBindingsToGenericBindings(EditorCurveBinding[] editorCurveBindings);
}
}
================================================
FILE: Editor/Mono/Animation/AnimationWindow/AddCurvesPopup.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;
using System;
using Object = UnityEngine.Object;
namespace UnityEditorInternal
{
internal class AddCurvesPopup : EditorWindow
{
const float k_WindowPadding = 3;
const float k_SpaceForSlider = 16;
const float k_WindowMaxWidth = 450;
const float k_WindowMinWidth = 240;
const float k_WindowFixedHeight = 250;
internal static AnimationWindowState s_State;
private static AddCurvesPopup s_AddCurvesPopup;
private static long s_LastClosedTime;
private static AddCurvesPopupHierarchy s_Hierarchy;
public delegate void OnNewCurveAdded(AddCurvesPopupPropertyNode node);
private static OnNewCurveAdded NewCurveAddedCallback;
Vector2 GetWindowSize()
{
float contentWidth = s_Hierarchy.GetContentWidth();
float width = Mathf.Clamp(contentWidth + k_SpaceForSlider + k_WindowPadding, k_WindowMinWidth, k_WindowMaxWidth);
return new Vector2(width, k_WindowFixedHeight);
}
void Init(Rect buttonRect)
{
s_Hierarchy = new AddCurvesPopupHierarchy();
s_Hierarchy.InitIfNeeded(this, new Rect(0, 0, k_WindowMinWidth, k_WindowFixedHeight));
buttonRect = GUIUtility.GUIToScreenRect(buttonRect);
ShowAsDropDown(buttonRect, GetWindowSize(), new[] { PopupLocation.Right });
}
void OnEnable()
{
AssemblyReloadEvents.beforeAssemblyReload += Close;
}
void OnDisable()
{
AssemblyReloadEvents.beforeAssemblyReload -= Close;
s_LastClosedTime = System.DateTime.Now.Ticks / System.TimeSpan.TicksPerMillisecond;
s_AddCurvesPopup = null;
s_Hierarchy = null;
}
internal static void AddNewCurve(AddCurvesPopupPropertyNode node)
{
AnimationWindowUtility.CreateDefaultCurves(s_State, node.curveBindings);
if (NewCurveAddedCallback != null)
NewCurveAddedCallback(node);
}
internal static bool ShowAtPosition(Rect buttonRect, AnimationWindowState state, OnNewCurveAdded newCurveCallback)
{
// We could not use realtimeSinceStartUp since it is set to 0 when entering/exitting playmode, we assume an increasing time when comparing time.
long nowMilliSeconds = System.DateTime.Now.Ticks / System.TimeSpan.TicksPerMillisecond;
bool justClosed = nowMilliSeconds < s_LastClosedTime + 50;
if (!justClosed)
{
Event.current.Use();
if (s_AddCurvesPopup == null)
s_AddCurvesPopup = ScriptableObject.CreateInstance();
NewCurveAddedCallback = newCurveCallback;
s_State = state;
s_AddCurvesPopup.Init(buttonRect);
return true;
}
return false;
}
internal void OnGUI()
{
// We do not use the layout event
if (Event.current.type == EventType.Layout)
return;
Vector2 windowSize = GetWindowSize();
Rect rect = new Rect(1, 1, windowSize.x - k_WindowPadding, windowSize.y - k_WindowPadding);
GUI.Box(new Rect(0, 0, windowSize.x, windowSize.y), GUIContent.none, "grey_border");
s_Hierarchy.OnGUI(rect, this);
}
}
}
================================================
FILE: Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchy.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using UnityEditor;
using UnityEditor.IMGUI.Controls;
using UnityEngine;
using TreeViewController = UnityEditor.IMGUI.Controls.TreeViewController;
using TreeViewItem = UnityEditor.IMGUI.Controls.TreeViewItem;
using TreeViewState = UnityEditor.IMGUI.Controls.TreeViewState;
namespace UnityEditorInternal
{
internal class AddCurvesPopupHierarchy
{
private TreeViewController m_TreeView;
private TreeViewState m_TreeViewState;
private AddCurvesPopupHierarchyDataSource m_TreeViewDataSource;
private float m_ContentWidth = 0f;
public float GetContentWidth()
{
return m_ContentWidth;
}
public void OnGUI(Rect position, EditorWindow owner)
{
m_TreeView.SetTotalRect(position);
m_TreeView.OnEvent();
m_TreeView.OnGUI(position, GUIUtility.GetControlID(FocusType.Keyboard));
}
public void InitIfNeeded(EditorWindow owner, Rect rect)
{
if (m_TreeViewState == null)
m_TreeViewState = new TreeViewState();
else
return;
m_TreeView = new TreeViewController(owner, m_TreeViewState);
m_TreeView.deselectOnUnhandledMouseDown = true;
m_TreeViewDataSource = new AddCurvesPopupHierarchyDataSource(m_TreeView);
AddCurvesPopupHierarchyGUI gui = new AddCurvesPopupHierarchyGUI(m_TreeView, owner);
m_TreeView.Init(rect,
m_TreeViewDataSource,
gui,
null
);
m_TreeViewDataSource.UpdateData();
m_ContentWidth = gui.GetContentWidth();
}
internal virtual bool IsRenamingNodeAllowed(TreeViewItem node)
{
return false;
}
}
}
================================================
FILE: Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchyBuilder.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;
using System;
using System.Linq;
using UnityEditor.IMGUI.Controls;
using Object = UnityEngine.Object;
using TreeViewItem = UnityEditor.IMGUI.Controls.TreeViewItem;
using TreeViewUtility = UnityEditor.IMGUI.Controls.TreeViewUtility;
namespace UnityEditorInternal
{
struct AddCurvesPopupHierarchyBuilder
{
struct KeyComparer : IComparer
{
static readonly Type s_GameObjectType = typeof(GameObject);
static readonly Type s_TransformType = typeof(Transform);
public int Compare(Key x, Key y)
{
var result = String.Compare(x.path, y.path, StringComparison.Ordinal);
if (result == 0 && x.type != y.type)
{
// Make sure GameObject properties appear first, then Transform.
if (x.type == s_GameObjectType)
return -1;
if (y.type == s_GameObjectType)
return 1;
if (x.type == typeof(Transform))
return -1;
if (y.type == typeof(Transform))
return 1;
return String.Compare(x.type.Name, y.type.Name, StringComparison.Ordinal);
}
return result;
}
}
struct Key
{
public string path;
public Type type;
}
SortedDictionary> m_AccumulatedBindings;
AnimationWindowState m_State;
public AddCurvesPopupHierarchyBuilder(AnimationWindowState state)
{
m_AccumulatedBindings = new SortedDictionary>(new KeyComparer());
m_State = state;
}
public void Add(EditorCurveBinding binding)
{
var key = new Key { path = binding.path, type = binding.type };
if (m_AccumulatedBindings.TryGetValue(key, out var bindings))
bindings.Add(binding);
else
m_AccumulatedBindings[key] = new List(new [] {binding});
}
void RemoveUnnecessaryBindings(List bindings)
{
for (int i = bindings.Count - 1; i >= 0; --i)
{
// Let's not add those that already have a existing curve.
if (AnimationWindowUtility.IsCurveCreated(m_State.activeAnimationClip, bindings[i]))
bindings.RemoveAt(i);
// Remove animator enabled property which shouldn't be animated.
else if (bindings[i].type == typeof(Animator) && bindings[i].propertyName == "m_Enabled")
bindings.RemoveAt(i);
// For RectTransform.position we only want .z
else if (AnimationWindowUtility.IsRectTransformPosition(bindings[i]) && !bindings[i].propertyName.EndsWith(".z"))
bindings.RemoveAt(i);
// Don't show for the root go
else if (bindings[i].type == typeof(GameObject) && string.IsNullOrEmpty(bindings[i].path))
bindings.RemoveAt(i);
}
}
public TreeViewItem CreateTreeView()
{
TreeViewItem rootNode;
// Bindings of a single Component/ScriptableObject, skip the group node.
if (m_AccumulatedBindings.Count == 1)
{
var bindings = m_AccumulatedBindings.First().Value;
RemoveUnnecessaryBindings(bindings);
if (bindings.Count > 0)
{
rootNode = AddAnimatableObjectToHierarchy(bindings, null, "");
}
else
{
rootNode = new AddCurvesPopupObjectNode(null, string.Empty, string.Empty);
}
}
else
{
var groupNodes = new Dictionary();
var childNodes = new Dictionary>();
var inheritedNodeWeights = new Dictionary();
rootNode = new AddCurvesPopupObjectNode(null, string.Empty, string.Empty);
TreeViewItem groupNode = rootNode;
groupNodes.Add(string.Empty, (rootNode));
childNodes.Add(groupNode, new List());
inheritedNodeWeights.Add(groupNode, 0);
string currentPath = string.Empty;
foreach (var kvp in m_AccumulatedBindings)
{
if (!currentPath.Equals(kvp.Key.path))
{
TreeViewItem parentNode = rootNode;
var parentPath = GetParentPath(kvp.Key.path);
while (parentPath != null)
{
if (groupNodes.TryGetValue(parentPath, out var node))
{
parentNode = node;
break;
}
parentPath = GetParentPath(parentPath);
}
groupNode = new AddCurvesPopupObjectNode(parentNode, kvp.Key.path, "", GetObjectName(kvp.Key.path));
groupNodes.Add(kvp.Key.path, groupNode);
childNodes.Add(groupNode, new List());
inheritedNodeWeights.Add(groupNode, 0);
childNodes[parentNode].Add(groupNode);
currentPath = kvp.Key.path;
}
var bindings = kvp.Value;
RemoveUnnecessaryBindings(bindings);
if (bindings.Count > 0)
{
// Builtin GameObject attributes.
if (kvp.Key.type == typeof(GameObject))
{
TreeViewItem newNode = CreateNode(bindings.ToArray(), groupNode, null);
if (newNode != null)
childNodes[groupNode].Add(newNode);
}
else
{
childNodes[groupNode].Add(AddAnimatableObjectToHierarchy(bindings, groupNode, kvp.Key.path));
var parentGroupNode = groupNode;
while (parentGroupNode != null)
{
inheritedNodeWeights[parentGroupNode] += bindings.Count;
parentGroupNode = parentGroupNode.parent;
}
}
}
}
// Remove empty leaves from tree view.
foreach (var kvp in inheritedNodeWeights)
{
// Remove Leaves nodes without properties.
if (inheritedNodeWeights[kvp.Key] == 0 && kvp.Key.parent != null)
{
childNodes[kvp.Key.parent].Remove(kvp.Key);
kvp.Key.parent = null;
}
}
// Set child parent references.
foreach (var kvp in childNodes)
{
TreeViewUtility.SetChildParentReferences(kvp.Value, kvp.Key);
}
}
m_AccumulatedBindings.Clear();
return rootNode;
}
private string GetParentPath(string path)
{
if (String.IsNullOrEmpty(path))
return null;
int index = path.LastIndexOf('/');
if (index == -1)
return string.Empty;
return path.Substring(0, index);
}
private string GetObjectName(string path)
{
if (String.IsNullOrEmpty(path))
return null;
int index = path.LastIndexOf('/');
if (index == -1)
return path;
return path.Substring(index + 1);
}
private string GetClassName(EditorCurveBinding binding)
{
if (m_State.activeRootGameObject != null)
{
Object target = AnimationUtility.GetAnimatedObject(m_State.activeRootGameObject, binding);
if (target != null)
return ObjectNames.GetInspectorTitle(target);
}
return binding.type.Name;
}
private Texture2D GetIcon(EditorCurveBinding binding)
{
return AssetPreview.GetMiniTypeThumbnail(binding.type);
}
private TreeViewItem AddAnimatableObjectToHierarchy(List curveBindings, TreeViewItem parentNode, string path)
{
TreeViewItem node = new AddCurvesPopupObjectNode(parentNode, path, GetClassName(curveBindings[0]));
node.icon = GetIcon(curveBindings[0]);
List childNodes = new List();
List singlePropertyBindings = new List();
SerializedObject so = null;
for (int i = 0; i < curveBindings.Count; i++)
{
EditorCurveBinding curveBinding = curveBindings[i];
if (m_State.activeRootGameObject && curveBinding.isSerializeReferenceCurve)
{
var animatedObject = AnimationUtility.GetAnimatedObject(m_State.activeRootGameObject, curveBinding);
if (animatedObject != null && (so == null || so.targetObject != animatedObject))
so = new SerializedObject(animatedObject);
}
singlePropertyBindings.Add(curveBinding);
// We expect curveBindings to come sorted by propertyname
if (i == curveBindings.Count - 1 || AnimationWindowUtility.GetPropertyGroupName(curveBindings[i + 1].propertyName) != AnimationWindowUtility.GetPropertyGroupName(curveBinding.propertyName))
{
TreeViewItem newNode = CreateNode(singlePropertyBindings.ToArray(), node, so);
if (newNode != null)
childNodes.Add(newNode);
singlePropertyBindings.Clear();
}
}
childNodes.Sort();
TreeViewUtility.SetChildParentReferences(childNodes, node);
return node;
}
private TreeViewItem CreateNode(EditorCurveBinding[] curveBindings, TreeViewItem parentNode, SerializedObject so)
{
var node = new AddCurvesPopupPropertyNode(parentNode, curveBindings, AnimationWindowUtility.GetNicePropertyGroupDisplayName(curveBindings[0], so));
node.icon = parentNode.icon;
return node;
}
}
class AddCurvesPopupObjectNode : TreeViewItem
{
public AddCurvesPopupObjectNode(TreeViewItem parent, string path, string className, string displayName = null)
: base((path + className).GetHashCode(), parent != null ? parent.depth + 1 : -1, parent, displayName ?? className)
{
}
}
class AddCurvesPopupPropertyNode : TreeViewItem
{
public EditorCurveBinding[] curveBindings;
public AddCurvesPopupPropertyNode(TreeViewItem parent, EditorCurveBinding[] curveBindings, string displayName)
: base(curveBindings[0].GetHashCode(), parent.depth + 1, parent, displayName)
{
this.curveBindings = curveBindings;
}
public override int CompareTo(TreeViewItem other)
{
AddCurvesPopupPropertyNode otherNode = other as AddCurvesPopupPropertyNode;
if (otherNode != null)
{
if (displayName.Contains("Rotation") && otherNode.displayName.Contains("Position"))
return 1;
if (displayName.Contains("Position") && otherNode.displayName.Contains("Rotation"))
return -1;
}
return base.CompareTo(other);
}
}
}
================================================
FILE: Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchyDataSource.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using UnityEditor;
using UnityEditor.IMGUI.Controls;
using TreeViewController = UnityEditor.IMGUI.Controls.TreeViewController;
using TreeViewDataSource = UnityEditor.IMGUI.Controls.TreeViewDataSource;
namespace UnityEditorInternal
{
class AddCurvesPopupHierarchyDataSource : TreeViewDataSource
{
public AddCurvesPopupHierarchyDataSource(TreeViewController treeView)
: base(treeView)
{
showRootItem = false;
rootIsCollapsable = false;
}
private void SetupRootNodeSettings()
{
showRootItem = false;
SetExpanded(root, true);
}
public override void FetchData()
{
m_RootItem = null;
if (AddCurvesPopup.s_State.selection.canAddCurves)
{
var state = AddCurvesPopup.s_State;
AddBindingsToHierarchy(state.controlInterface.GetAnimatableBindings());
}
SetupRootNodeSettings();
m_NeedRefreshRows = true;
}
private void AddBindingsToHierarchy(EditorCurveBinding[] bindings)
{
if (bindings == null || bindings.Length == 0)
{
m_RootItem = new AddCurvesPopupObjectNode(null, "", "");
return;
}
var builder = new AddCurvesPopupHierarchyBuilder(AddCurvesPopup.s_State);
for (int i = 0; i < bindings.Length; i++)
{
builder.Add(bindings[i]);
}
m_RootItem = builder.CreateTreeView();
}
public void UpdateData()
{
m_TreeView.ReloadData();
}
}
}
================================================
FILE: Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchyGUI.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using UnityEditor;
using UnityEditor.IMGUI.Controls;
using UnityEngine;
using System.Collections.Generic;
using UnityEditor.ShortcutManagement;
using TreeViewController = UnityEditor.IMGUI.Controls.TreeViewController;
using TreeViewItem = UnityEditor.IMGUI.Controls.TreeViewItem;
using TreeViewGUI = UnityEditor.IMGUI.Controls.TreeViewGUI;
namespace UnityEditorInternal
{
internal class AddCurvesPopupHierarchyGUI : TreeViewGUI
{
public EditorWindow owner;
public bool showPlusButton { get; set; }
private GUIStyle buttonStyle = "IconButton";
private GUIContent plusIcon = EditorGUIUtility.TrIconContent("Toolbar Plus");
private GUIStyle plusButtonBackgroundStyle = "Tag MenuItem";
private GUIContent addPropertiesContent = EditorGUIUtility.TrTextContent("Add Properties");
private const float plusButtonWidth = 17;
public AddCurvesPopupHierarchyGUI(TreeViewController treeView, EditorWindow owner)
: base(treeView, true)
{
this.owner = owner;
}
public override void OnRowGUI(Rect rowRect, TreeViewItem node, int row, bool selected, bool focused)
{
base.OnRowGUI(rowRect, node, row, selected, focused);
DoAddCurveButton(rowRect, node);
HandleContextMenu(rowRect, node);
}
private void DoAddCurveButton(Rect rowRect, TreeViewItem node)
{
// Is it propertynode. If not, then we don't need plusButton so quit here
AddCurvesPopupPropertyNode hierarchyNode = node as AddCurvesPopupPropertyNode;
if (hierarchyNode == null || hierarchyNode.curveBindings == null || hierarchyNode.curveBindings.Length == 0)
return;
Rect buttonRect = new Rect(rowRect.width - plusButtonWidth, rowRect.yMin, plusButtonWidth, buttonStyle.fixedHeight);
// TODO Make a style for add curves popup
// Draw background behind plus button to prevent text overlapping
GUI.Box(buttonRect, GUIContent.none, plusButtonBackgroundStyle);
// Check if the curve already exists and remove plus button
if (GUI.Button(buttonRect, plusIcon, buttonStyle))
{
AddCurvesPopup.AddNewCurve(hierarchyNode);
// Hold shift key to add new curves and keep window opened.
if (Event.current.shift)
m_TreeView.ReloadData();
else
owner.Close();
}
}
private void HandleContextMenu(Rect rowRect, TreeViewItem node)
{
if (Event.current.type != EventType.ContextClick)
return;
if (rowRect.Contains(Event.current.mousePosition))
{
// Add current node to selection
var ids = new List(m_TreeView.GetSelection());
ids.Add(node.id);
m_TreeView.SetSelection(ids.ToArray(), false, false);
GenerateMenu().ShowAsContext();
Event.current.Use();
}
}
private GenericMenu GenerateMenu()
{
GenericMenu menu = new GenericMenu();
menu.AddItem(addPropertiesContent, false, AddPropertiesFromSelectedNodes);
return menu;
}
private void AddPropertiesFromSelectedNodes()
{
int[] ids = m_TreeView.GetSelection();
for (int i = 0; i < ids.Length; ++i)
{
var node = m_TreeView.FindItem(ids[i]);
var propertyNode = node as AddCurvesPopupPropertyNode;
if (propertyNode != null)
{
AddCurvesPopup.AddNewCurve(propertyNode);
}
else if (node.hasChildren)
{
foreach (var childNode in node.children)
{
var childPropertyNode = childNode as AddCurvesPopupPropertyNode;
if (childPropertyNode != null)
{
AddCurvesPopup.AddNewCurve(childPropertyNode);
}
}
}
}
m_TreeView.ReloadData();
}
public float GetContentWidth()
{
IList rows = m_TreeView.data.GetRows();
List allRows = new List();
allRows.AddRange(rows);
for (int i = 0; i < allRows.Count; ++i)
{
var row = allRows[i];
if (row.hasChildren)
allRows.AddRange(row.children);
}
float rowWidth = GetMaxWidth(allRows);
return rowWidth + plusButtonWidth;
}
override protected void SyncFakeItem()
{
//base.SyncFakeItem();
}
override protected void RenameEnded()
{
//base.RenameEnded();
}
override protected bool IsRenaming(int id)
{
return false;
}
public override bool BeginRename(TreeViewItem item, float delay)
{
return false;
}
override protected Texture GetIconForItem(TreeViewItem item)
{
if (item != null)
return item.icon;
return null;
}
}
}
================================================
FILE: Editor/Mono/Animation/AnimationWindow/AnimEditor.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
using UnityEngine;
using System.Collections.Generic;
using UnityEditor.ShortcutManagement;
using UnityEditorInternal;
namespace UnityEditor
{
internal enum WrapModeFixed
{
Default = (int)WrapMode.Default,
Once = (int)WrapMode.Once,
Loop = (int)WrapMode.Loop,
ClampForever = (int)WrapMode.ClampForever,
PingPong = (int)WrapMode.PingPong
}
[Serializable]
class AnimEditor : ScriptableObject
{
// Active Animation windows
private static List s_AnimationWindows = new List();
public static List GetAllAnimationWindows() { return s_AnimationWindows; }
public bool stateDisabled { get { return m_State.disabled; } }
[SerializeField] private SplitterState m_HorizontalSplitter;
[SerializeReference] private AnimationWindowState m_State;
[SerializeReference] private DopeSheetEditor m_DopeSheet;
[SerializeReference] private CurveEditor m_CurveEditor;
[SerializeField] private AnimationWindowHierarchy m_Hierarchy;
[SerializeField] private AnimationWindowClipPopup m_ClipPopup;
[SerializeField] private AnimationEventTimeLine m_Events;
[SerializeField] private AnimEditorOverlay m_Overlay;
[SerializeField] private EditorWindow m_OwnerWindow;
[System.NonSerialized] private Rect m_Position;
[System.NonSerialized] private bool m_TriggerFraming;
[System.NonSerialized] private bool m_Initialized;
private float hierarchyWidth { get { return m_HorizontalSplitter.realSizes[0]; } }
private float contentWidth { get { return m_HorizontalSplitter.realSizes[1]; } }
internal static PrefColor kEulerXColor = new PrefColor("Animation/EulerX", 1.0f, 0.0f, 1.0f, 1.0f);
internal static PrefColor kEulerYColor = new PrefColor("Animation/EulerY", 1.0f, 1.0f, 0.0f, 1.0f);
internal static PrefColor kEulerZColor = new PrefColor("Animation/EulerZ", 0.0f, 1.0f, 1.0f, 1.0f);
static private Color s_SelectionRangeColorLight = new Color32(255, 255, 255, 90);
static private Color s_SelectionRangeColorDark = new Color32(200, 200, 200, 40);
static private Color selectionRangeColor
{
get
{
return EditorGUIUtility.isProSkin ? s_SelectionRangeColorDark : s_SelectionRangeColorLight;
}
}
static private Color s_OutOfRangeColorLight = new Color32(160, 160, 160, 127);
static private Color s_OutOfRangeColorDark = new Color32(40, 40, 40, 127);
static private Color outOfRangeColor
{
get
{
return EditorGUIUtility.isProSkin ? s_OutOfRangeColorDark : s_OutOfRangeColorLight;
}
}
static private Color s_InRangeColorLight = new Color32(211, 211, 211, 255);
static private Color s_InRangeColorDark = new Color32(75, 75, 75, 255);
static private Color inRangeColor
{
get
{
return EditorGUIUtility.isProSkin ? s_InRangeColorDark : s_InRangeColorLight;
}
}
static private Color s_FilterBySelectionColorLight = new Color(0.82f, 0.97f, 1.00f, 1.00f);
static private Color s_FilterBySelectionColorDark = new Color(0.54f, 0.85f, 1.00f, 1.00f);
static private Color filterBySelectionColor
{
get
{
return EditorGUIUtility.isProSkin ? s_FilterBySelectionColorDark : s_FilterBySelectionColorLight;
}
}
internal const int kSliderThickness = 13;
internal const int kIntFieldWidth = 35;
internal const int kHierarchyMinWidth = 300;
internal const int kToggleButtonWidth = 80;
internal const float kDisabledRulerAlpha = 0.12f;
private int layoutRowHeight
{
get { return (int)EditorGUI.kWindowToolbarHeight; }
}
internal struct FrameRateMenuEntry
{
public FrameRateMenuEntry(GUIContent content, float value)
{
this.content = content;
this.value = value;
}
public GUIContent content;
public float value;
}
internal static FrameRateMenuEntry[] kAvailableFrameRates = new FrameRateMenuEntry[]
{
new FrameRateMenuEntry(EditorGUIUtility.TextContent("Set Sample Rate/24"), 24f),
new FrameRateMenuEntry(EditorGUIUtility.TextContent("Set Sample Rate/25"), 25f),
new FrameRateMenuEntry(EditorGUIUtility.TextContent("Set Sample Rate/30"), 30f),
new FrameRateMenuEntry(EditorGUIUtility.TextContent("Set Sample Rate/50"), 50f),
new FrameRateMenuEntry(EditorGUIUtility.TextContent("Set Sample Rate/60"), 60f)
};
public AnimationWindowState state { get { return m_State; } }
public AnimationWindowSelectionItem selection
{
get
{
return m_State.selection;
}
set
{
m_State.selection = value;
}
}
public IAnimationWindowController controlInterface
{
get
{
return state.controlInterface;
}
}
public IAnimationWindowController overrideControlInterface
{
get
{
return state.overrideControlInterface;
}
set
{
state.overrideControlInterface = value;
}
}
private bool triggerFraming
{
set
{
m_TriggerFraming = value;
}
get
{
return m_TriggerFraming;
}
}
internal CurveEditor curveEditor { get { return m_CurveEditor; } }
internal DopeSheetEditor dopeSheetEditor { get { return m_DopeSheet; } }
public void OnAnimEditorGUI(EditorWindow parent, Rect position)
{
m_DopeSheet.m_Owner = parent;
m_OwnerWindow = parent;
m_Position = position;
if (!m_Initialized)
Initialize();
m_State.OnGUI();
if (m_State.disabled && m_State.recording)
m_State.recording = false;
SynchronizeLayout();
using (new EditorGUI.DisabledScope(m_State.disabled || m_State.animatorIsOptimized))
{
int optionsID = GUIUtility.GetControlID(FocusType.Passive);
if (Event.current.type != EventType.Repaint)
OptionsOnGUI(optionsID);
OverlayEventOnGUI();
GUILayout.BeginHorizontal();
SplitterGUILayout.BeginHorizontalSplit(m_HorizontalSplitter);
// Left side
GUILayout.BeginVertical();
// First row of controls
GUILayout.BeginHorizontal(AnimationWindowStyles.animPlayToolBar);
PlayControlsOnGUI();
GUILayout.EndHorizontal();
// Second row of controls
GUILayout.BeginHorizontal(AnimationWindowStyles.animClipToolBar);
LinkOptionsOnGUI();
ClipSelectionDropDownOnGUI();
GUILayout.FlexibleSpace();
FrameRateInputFieldOnGUI();
FilterBySelectionButtonOnGUI();
AddKeyframeButtonOnGUI();
AddEventButtonOnGUI();
GUILayout.EndHorizontal();
HierarchyOnGUI();
// Bottom row of controls
using (new GUILayout.HorizontalScope(AnimationWindowStyles.toolbarBottom))
{
TabSelectionOnGUI();
}
GUILayout.EndVertical();
// Right side
GUILayout.BeginVertical();
// Acquire Rects
Rect timerulerRect = GUILayoutUtility.GetRect(contentWidth, layoutRowHeight);
Rect eventsRect = GUILayoutUtility.GetRect(contentWidth, layoutRowHeight - 1);
Rect contentLayoutRect = GUILayoutUtility.GetRect(contentWidth, contentWidth, 0f, float.MaxValue, GUILayout.ExpandHeight(true));
// MainContent must be done first since it resizes the Zoomable area.
MainContentOnGUI(contentLayoutRect);
TimeRulerOnGUI(timerulerRect);
EventLineOnGUI(eventsRect);
GUILayout.EndVertical();
SplitterGUILayout.EndHorizontalSplit();
GUILayout.EndHorizontal();
// Overlay
OverlayOnGUI(contentLayoutRect);
if (Event.current.type == EventType.Repaint)
{
OptionsOnGUI(optionsID);
AnimationWindowStyles.separator.Draw(new Rect(hierarchyWidth, 0, 1, position.height), false, false, false, false);
}
RenderEventTooltip();
}
}
void MainContentOnGUI(Rect contentLayoutRect)
{
// Bail out if the hierarchy in animator is optimized.
if (m_State.animatorIsOptimized)
{
GUI.Label(contentLayoutRect, GUIContent.none, AnimationWindowStyles.dopeSheetBackground);
Vector2 textSize = GUI.skin.label.CalcSize(AnimationWindowStyles.animatorOptimizedText);
Rect labelRect = new Rect(contentLayoutRect.x + contentLayoutRect.width * .5f - textSize.x * .5f, contentLayoutRect.y + contentLayoutRect.height * .5f - textSize.y * .5f, textSize.x, textSize.y);
GUI.Label(labelRect, AnimationWindowStyles.animatorOptimizedText);
return;
}
var mainAreaControlID = 0;
if (m_State.disabled)
{
SetupWizardOnGUI(contentLayoutRect);
}
else
{
Event evt = Event.current;
if (evt.type == EventType.MouseDown && contentLayoutRect.Contains(evt.mousePosition))
m_Events.ClearSelection();
if (triggerFraming && evt.type == EventType.Repaint)
{
m_DopeSheet.FrameClip();
m_CurveEditor.FrameClip(true, true);
triggerFraming = false;
}
if (m_State.showCurveEditor)
{
CurveEditorOnGUI(contentLayoutRect);
mainAreaControlID = m_CurveEditor.areaControlID;
}
else
{
DopeSheetOnGUI(contentLayoutRect);
mainAreaControlID = m_DopeSheet.areaControlID;
}
}
HandleMainAreaCopyPaste(mainAreaControlID);
}
private void OverlayEventOnGUI()
{
if (m_State.animatorIsOptimized)
return;
if (m_State.disabled)
return;
Rect overlayRect = new Rect(hierarchyWidth - 1, 0f, contentWidth - kSliderThickness, m_Position.height - kSliderThickness);
GUI.BeginGroup(overlayRect);
m_Overlay.HandleEvents();
GUI.EndGroup();
}
private void OverlayOnGUI(Rect contentRect)
{
if (m_State.animatorIsOptimized)
return;
if (m_State.disabled)
return;
if (Event.current.type != EventType.Repaint)
return;
Rect contentRectNoSliders = new Rect(contentRect.xMin, contentRect.yMin, contentRect.width - kSliderThickness, contentRect.height - kSliderThickness);
Rect overlayRectNoSliders = new Rect(hierarchyWidth - 1, 0f, contentWidth - kSliderThickness, m_Position.height - kSliderThickness);
GUI.BeginGroup(overlayRectNoSliders);
Rect localRect = new Rect(0, 0, overlayRectNoSliders.width, overlayRectNoSliders.height);
Rect localContentRect = contentRectNoSliders;
localContentRect.position -= overlayRectNoSliders.min;
m_Overlay.OnGUI(localRect, localContentRect);
GUI.EndGroup();
}
public void Update()
{
if (m_State == null)
return;
PlaybackUpdate();
}
public void OnEnable()
{
s_AnimationWindows.Add(this);
if (m_State == null)
{
m_State = new AnimationWindowState();
m_State.animEditor = this;
InitializeHorizontalSplitter();
InitializeClipSelection();
InitializeDopeSheet();
InitializeEvents();
InitializeCurveEditor();
InitializeOverlay();
}
InitializeNonserializedValues();
m_State.timeArea = m_State.showCurveEditor ? (TimeArea)m_CurveEditor : m_DopeSheet;
m_DopeSheet.state = m_State;
m_ClipPopup.state = m_State;
m_Overlay.state = m_State;
m_State.OnEnable();
m_CurveEditor.curvesUpdated += SaveChangedCurvesFromCurveEditor;
m_CurveEditor.OnEnable();
}
public void OnDisable()
{
s_AnimationWindows.Remove(this);
if (m_CurveEditor != null)
{
m_CurveEditor.curvesUpdated -= SaveChangedCurvesFromCurveEditor;
m_CurveEditor.OnDisable();
}
m_DopeSheet?.OnDisable();
m_State.OnDisable();
}
public void OnDestroy()
{
m_CurveEditor?.OnDestroy();
m_State?.OnDestroy();
}
public void OnSelectionChanged()
{
triggerFraming = true; // Framing of clip can only be done after Layout. Here we just order it to happen later on.
Repaint();
}
public void OnSelectionUpdated()
{
m_State.OnSelectionUpdated();
Repaint();
}
public void OnStartLiveEdit()
{
SaveCurveEditorKeySelection();
}
public void OnEndLiveEdit()
{
UpdateSelectedKeysToCurveEditor();
m_State.ResampleAnimation();
}
public void OnLostFocus()
{
// RenameOverlay might still be active, close before switching to another window.
if (m_Hierarchy != null)
m_Hierarchy.EndNameEditing(true);
// Stop text editing. FrameRate ui or Frame ui may still be in edition mode.
EditorGUI.EndEditingActiveTextField();
}
private void PlaybackUpdate()
{
if (m_State.disabled && m_State.playing)
m_State.playing = false;
if (m_State.PlaybackUpdate())
Repaint();
}
private void SetupWizardOnGUI(Rect position)
{
GUI.Label(position, GUIContent.none, AnimationWindowStyles.dopeSheetBackground);
Rect positionWithoutScrollBar = new Rect(position.x, position.y, position.width - kSliderThickness, position.height - kSliderThickness);
GUI.BeginClip(positionWithoutScrollBar);
GUI.enabled = true;
m_State.showCurveEditor = false;
m_State.timeArea = m_DopeSheet;
m_State.timeArea.SetShownHRangeInsideMargins(0f, 1f);
bool animatableObject = m_State.activeGameObject && !EditorUtility.IsPersistent(m_State.activeGameObject);
if (animatableObject)
{
var missingObjects = (!m_State.activeRootGameObject && !m_State.activeAnimationClip) ? AnimationWindowStyles.animatorAndAnimationClip.text : AnimationWindowStyles.animationClip.text;
string txt = String.Format(AnimationWindowStyles.formatIsMissing.text, m_State.activeGameObject.name, missingObjects);
const float buttonWidth = 70f;
const float buttonHeight = 20f;
const float buttonPadding = 3f;
GUIContent textContent = GUIContent.Temp(txt);
Vector2 textSize = GUI.skin.label.CalcSize(textContent);
Rect labelRect = new Rect(positionWithoutScrollBar.width * .5f - textSize.x * .5f, positionWithoutScrollBar.height * .5f - textSize.y * .5f, textSize.x, textSize.y);
GUI.Label(labelRect, textContent);
Rect buttonRect = new Rect(positionWithoutScrollBar.width * .5f - buttonWidth * .5f, labelRect.yMax + buttonPadding, buttonWidth, buttonHeight);
if (GUI.Button(buttonRect, AnimationWindowStyles.create))
{
if (AnimationWindowUtility.InitializeGameobjectForAnimation(m_State.activeGameObject))
{
Component animationPlayer = AnimationWindowUtility.GetClosestAnimationPlayerComponentInParents(m_State.activeGameObject.transform);
m_State.activeAnimationClip = AnimationUtility.GetAnimationClips(animationPlayer.gameObject)[0];
}
// Layout has changed, bail out now.
EditorGUIUtility.ExitGUI();
}
}
else
{
Color oldColor = GUI.color;
GUI.color = Color.gray;
Vector2 textSize = GUI.skin.label.CalcSize(AnimationWindowStyles.noAnimatableObjectSelectedText);
Rect labelRect = new Rect(positionWithoutScrollBar.width * .5f - textSize.x * .5f, positionWithoutScrollBar.height * .5f - textSize.y * .5f, textSize.x, textSize.y);
GUI.Label(labelRect, AnimationWindowStyles.noAnimatableObjectSelectedText);
GUI.color = oldColor;
}
GUI.EndClip();
GUI.enabled = false; // Reset state to false. It's always false originally for SetupWizardOnGUI.
}
private void EventLineOnGUI(Rect eventsRect)
{
eventsRect.width -= kSliderThickness;
GUI.Label(eventsRect, GUIContent.none, AnimationWindowStyles.eventBackground);
using (new EditorGUI.DisabledScope(!selection.animationIsEditable))
{
m_Events.EventLineGUI(eventsRect, m_State);
}
}
private void RenderEventTooltip()
{
m_Events.DrawInstantTooltip(m_Position);
}
private void TabSelectionOnGUI()
{
GUILayout.FlexibleSpace();
EditorGUI.BeginChangeCheck();
GUILayout.Toggle(!m_State.showCurveEditor, AnimationWindowStyles.dopesheet, AnimationWindowStyles.miniToolbarButton, GUILayout.Width(kToggleButtonWidth));
GUILayout.Toggle(m_State.showCurveEditor, AnimationWindowStyles.curves, EditorStyles.toolbarButtonRight, GUILayout.Width(kToggleButtonWidth));
if (EditorGUI.EndChangeCheck())
{
SwitchBetweenCurvesAndDopesheet();
}
}
private void HierarchyOnGUI()
{
Rect hierarchyLayoutRect = GUILayoutUtility.GetRect(hierarchyWidth, hierarchyWidth, 0f, float.MaxValue, GUILayout.ExpandHeight(true));
if (!m_State.showReadOnly && !m_State.selection.animationIsEditable)
{
Vector2 labelSize = GUI.skin.label.CalcSize(AnimationWindowStyles.readOnlyPropertiesLabel);
const float buttonWidth = 210f;
const float buttonHeight = 20f;
const float buttonPadding = 3f;
Rect labelRect = new Rect(hierarchyLayoutRect.x + hierarchyLayoutRect.width * .5f - labelSize.x * .5f, hierarchyLayoutRect.y + hierarchyLayoutRect.height * .5f - labelSize.y, labelSize.x, labelSize.y);
Rect buttonRect = new Rect(hierarchyLayoutRect.x + hierarchyLayoutRect.width * .5f - buttonWidth * .5f, labelRect.yMax + buttonPadding, buttonWidth, buttonHeight);
GUI.Label(labelRect, AnimationWindowStyles.readOnlyPropertiesLabel);
if (GUI.Button(buttonRect, AnimationWindowStyles.readOnlyPropertiesButton))
{
m_State.showReadOnly = true;
// Layout has changed, bail out now.
EditorGUIUtility.ExitGUI();
}
return;
}
if (!m_State.disabled)
m_Hierarchy.OnGUI(hierarchyLayoutRect);
}
private void FrameRateInputFieldOnGUI()
{
if (!m_State.showFrameRate)
return;
using (new EditorGUI.DisabledScope(!selection.animationIsEditable))
{
GUILayout.Label(AnimationWindowStyles.samples, EditorStyles.toolbarLabel);
EditorGUI.BeginChangeCheck();
int clipFrameRate = EditorGUILayout.DelayedIntField((int)m_State.clipFrameRate, EditorStyles.toolbarTextField, GUILayout.Width(kIntFieldWidth));
if (EditorGUI.EndChangeCheck())
{
m_State.clipFrameRate = clipFrameRate;
UpdateSelectedKeysToCurveEditor();
}
}
}
private void ClipSelectionDropDownOnGUI()
{
m_ClipPopup.OnGUI();
}
private void DopeSheetOnGUI(Rect position)
{
Rect noVerticalSliderRect = new Rect(position.xMin, position.yMin, position.width - kSliderThickness, position.height);
if (Event.current.type == EventType.Repaint)
{
m_DopeSheet.rect = noVerticalSliderRect;
m_DopeSheet.SetTickMarkerRanges();
m_DopeSheet.RecalculateBounds();
}
if (m_State.showCurveEditor)
return;
Rect noSlidersRect = new Rect(position.xMin, position.yMin, position.width - kSliderThickness, position.height - kSliderThickness);
m_DopeSheet.BeginViewGUI();
GUI.Label(position, GUIContent.none, AnimationWindowStyles.dopeSheetBackground);
if (!m_State.disabled)
{
m_DopeSheet.TimeRuler(noSlidersRect, m_State.frameRate, false, true, kDisabledRulerAlpha, m_State.timeFormat); // grid
}
m_DopeSheet.OnGUI(noSlidersRect, m_State.hierarchyState.scrollPos * -1);
m_DopeSheet.EndViewGUI();
Rect verticalScrollBarPosition = new Rect(noVerticalSliderRect.xMax, noVerticalSliderRect.yMin, kSliderThickness, noSlidersRect.height);
float visibleHeight = m_Hierarchy.GetTotalRect().height;
float contentHeight = Mathf.Max(visibleHeight, m_Hierarchy.GetContentSize().y);
m_State.hierarchyState.scrollPos.y = GUI.VerticalScrollbar(verticalScrollBarPosition, m_State.hierarchyState.scrollPos.y, visibleHeight, 0f, contentHeight);
if (m_DopeSheet.spritePreviewLoading == true)
Repaint();
}
private void CurveEditorOnGUI(Rect position)
{
if (Event.current.type == EventType.Repaint)
{
m_CurveEditor.rect = position;
m_CurveEditor.SetTickMarkerRanges();
}
Rect noSlidersRect = new Rect(position.xMin, position.yMin, position.width - kSliderThickness, position.height - kSliderThickness);
m_CurveEditor.vSlider = m_State.showCurveEditor;
m_CurveEditor.hSlider = m_State.showCurveEditor;
// Sync animation curves in curve editor. Do it only once per frame.
if (Event.current.type == EventType.Layout)
UpdateCurveEditorData();
m_CurveEditor.BeginViewGUI();
if (!m_State.disabled)
{
GUI.Box(noSlidersRect, GUIContent.none, AnimationWindowStyles.curveEditorBackground);
m_CurveEditor.GridGUI();
}
EditorGUI.BeginChangeCheck();
m_CurveEditor.CurveGUI();
if (EditorGUI.EndChangeCheck())
{
SaveChangedCurvesFromCurveEditor();
}
m_CurveEditor.EndViewGUI();
}
private void TimeRulerOnGUI(Rect timeRulerRect)
{
Rect timeRulerRectNoScrollbar = new Rect(timeRulerRect.xMin, timeRulerRect.yMin, timeRulerRect.width - kSliderThickness, timeRulerRect.height);
Rect timeRulerBackgroundRect = timeRulerRectNoScrollbar;
GUI.Box(timeRulerBackgroundRect, GUIContent.none, AnimationWindowStyles.timeRulerBackground);
if (!m_State.disabled)
{
RenderInRangeOverlay(timeRulerRectNoScrollbar);
RenderSelectionOverlay(timeRulerRectNoScrollbar);
}
m_State.timeArea.TimeRuler(timeRulerRectNoScrollbar, m_State.frameRate, true, false, 1f, m_State.timeFormat);
if (!m_State.disabled)
RenderOutOfRangeOverlay(timeRulerRectNoScrollbar);
}
private GenericMenu GenerateOptionsMenu()
{
GenericMenu menu = new GenericMenu();
menu.AddItem(EditorGUIUtility.TextContent("Seconds"), m_State.timeFormat == TimeArea.TimeFormat.TimeFrame, () => m_State.timeFormat = TimeArea.TimeFormat.TimeFrame);
menu.AddItem(EditorGUIUtility.TextContent("Frames"), m_State.timeFormat == TimeArea.TimeFormat.Frame, () => m_State.timeFormat = TimeArea.TimeFormat.Frame);
menu.AddSeparator("");
menu.AddItem(EditorGUIUtility.TextContent("Ripple"), m_State.rippleTime, () => m_State.rippleTime = !m_State.rippleTime);
menu.AddSeparator("");
menu.AddItem(EditorGUIUtility.TextContent("Show Sample Rate"), m_State.showFrameRate, () => m_State.showFrameRate = !m_State.showFrameRate);
bool isAnimatable = selection != null && selection.animationIsEditable;
GenericMenu.MenuFunction2 nullMenuFunction2 = null;
for (int i = 0; i < kAvailableFrameRates.Length; ++i)
{
FrameRateMenuEntry entry = kAvailableFrameRates[i];
bool isActive = m_State.clipFrameRate.Equals(entry.value);
menu.AddItem(entry.content, isActive, isAnimatable ? SetFrameRate : nullMenuFunction2, entry.value);
}
menu.AddSeparator("");
menu.AddItem(EditorGUIUtility.TextContent("Show Read-only Properties"), m_State.showReadOnly, () => m_State.showReadOnly = !m_State.showReadOnly);
return menu;
}
private void OptionsOnGUI(int controlID)
{
Rect layoutRect = new Rect(hierarchyWidth, 0f, contentWidth, layoutRowHeight);
GUI.BeginGroup(layoutRect);
Vector2 optionsSize = EditorStyles.toolbarButtonRight.CalcSize(AnimationWindowStyles.optionsContent);
Rect optionsRect = new Rect(layoutRect.width - kSliderThickness, 0f, optionsSize.x, optionsSize.y);
GUI.Box(optionsRect, GUIContent.none, AnimationWindowStyles.animPlayToolBar);
if (EditorGUI.DropdownButton(controlID, optionsRect, AnimationWindowStyles.optionsContent, AnimationWindowStyles.optionsButton))
{
var menu = GenerateOptionsMenu();
menu.ShowAsContext();
}
GUI.EndGroup();
}
internal void SetFrameRate(object frameRate)
{
m_State.clipFrameRate = (float)frameRate;
UpdateSelectedKeysToCurveEditor();
}
private void FilterBySelectionButtonOnGUI()
{
Color backupColor = GUI.color;
if (m_State.filterBySelection)
{
Color selectionColor = filterBySelectionColor;
selectionColor.a *= GUI.color.a;
GUI.color = selectionColor;
}
EditorGUI.BeginChangeCheck();
bool filterBySelection = GUILayout.Toggle(m_State.filterBySelection, AnimationWindowStyles.filterBySelectionContent, EditorStyles.toolbarButton);
if (EditorGUI.EndChangeCheck())
{
m_State.filterBySelection = filterBySelection;
}
GUI.color = backupColor;
}
private void AddEventButtonOnGUI()
{
using (new EditorGUI.DisabledScope(!selection.animationIsEditable))
{
if (GUILayout.Button(AnimationWindowStyles.addEventContent, AnimationWindowStyles.animClipToolbarButton))
m_Events.AddEvent(m_State.currentTime, selection.rootGameObject, selection.animationClip);
}
}
private void AddKeyframeButtonOnGUI()
{
bool canAddKey = selection.animationIsEditable && m_State.filteredCurves.Count != 0;
using (new EditorGUI.DisabledScope(!canAddKey))
{
if (GUILayout.Button(AnimationWindowStyles.addKeyframeContent, AnimationWindowStyles.animClipToolbarButton))
{
SaveCurveEditorKeySelection();
var keyTime = AnimationKeyTime.Time(m_State.currentTime, m_State.frameRate);
AnimationWindowUtility.AddSelectedKeyframes(m_State, keyTime);
UpdateSelectedKeysToCurveEditor();
// data is scheduled for an update, bail out now to avoid using out of date data.
EditorGUIUtility.ExitGUI();
}
}
}
private void PlayControlsOnGUI()
{
using (new EditorGUI.DisabledScope(!m_State.canPreview))
{
PreviewButtonOnGUI();
}
using (new EditorGUI.DisabledScope(!m_State.canRecord))
{
RecordButtonOnGUI();
}
if (GUILayout.Button(AnimationWindowStyles.firstKeyContent, EditorStyles.toolbarButton))
{
state.GoToFirstKeyframe();
// Stop text editing. User may be editing frame navigation ui which will not update until we exit text editing.
EditorGUI.EndEditingActiveTextField();
}
if (GUILayout.Button(AnimationWindowStyles.prevKeyContent, EditorStyles.toolbarButton))
{
state.GoToPreviousKeyframe();
// Stop text editing. User may be editing frame navigation ui which will not update until we exit text editing.
EditorGUI.EndEditingActiveTextField();
}
using (new EditorGUI.DisabledScope(!m_State.canPlay))
{
PlayButtonOnGUI();
}
if (GUILayout.Button(AnimationWindowStyles.nextKeyContent, EditorStyles.toolbarButton))
{
state.GoToNextKeyframe();
// Stop text editing. User may be editing frame navigation ui which will not update until we exit text editing.
EditorGUI.EndEditingActiveTextField();
}
if (GUILayout.Button(AnimationWindowStyles.lastKeyContent, EditorStyles.toolbarButton))
{
state.GoToLastKeyframe();
// Stop text editing. User may be editing frame navigation ui which will not update until we exit text editing.
EditorGUI.EndEditingActiveTextField();
}
GUILayout.FlexibleSpace();
EditorGUI.BeginChangeCheck();
int newFrame = EditorGUILayout.DelayedIntField(m_State.currentFrame, EditorStyles.toolbarTextField, GUILayout.Width(kIntFieldWidth));
if (EditorGUI.EndChangeCheck())
{
state.currentFrame = newFrame;
}
}
private void LinkOptionsOnGUI()
{
if (m_State.linkedWithSequencer)
{
if (GUILayout.Toggle(true, AnimationWindowStyles.sequencerLinkContent, EditorStyles.toolbarButton) == false)
{
m_State.linkedWithSequencer = false;
m_State.selection = null;
m_State.overrideControlInterface = null;
// Layout has changed, bail out now.
EditorGUIUtility.ExitGUI();
}
}
}
static void ExecuteShortcut(ShortcutArguments args, Action exp)
{
var animationWindow = (AnimationWindow)args.context;
var animEditor = animationWindow.animEditor;
if (EditorWindow.focusedWindow != animationWindow)
return;
if (animEditor.stateDisabled || animEditor.state.animatorIsOptimized)
return;
exp(animEditor);
animEditor.Repaint();
}
static void ExecuteShortcut(ShortcutArguments args, Action exp)
{
ExecuteShortcut(args, animEditor => exp(animEditor.state));
}
[FormerlyPrefKeyAs("Animation/Show Curves", "c")]
[Shortcut("Animation/Show Curves", typeof(AnimationWindow), KeyCode.C)]
static void ShowCurves(ShortcutArguments args)
{
ExecuteShortcut(args, animEditor => { animEditor.SwitchBetweenCurvesAndDopesheet(); });
}
[FormerlyPrefKeyAs("Animation/Play Animation", " ")]
[Shortcut("Animation/Play Animation", typeof(AnimationWindow), KeyCode.Space)]
static void TogglePlayAnimation(ShortcutArguments args)
{
ExecuteShortcut(args, state =>
{
state.playing = !state.playing;
});
}
[FormerlyPrefKeyAs("Animation/Next Frame", ".")]
[Shortcut("Animation/Next Frame", typeof(AnimationWindow), KeyCode.Period)]
static void NextFrame(ShortcutArguments args)
{
ExecuteShortcut(args, state => state.GoToNextFrame());
}
[FormerlyPrefKeyAs("Animation/Previous Frame", ",")]
[Shortcut("Animation/Previous Frame", typeof(AnimationWindow), KeyCode.Comma)]
static void PreviousFrame(ShortcutArguments args)
{
ExecuteShortcut(args, state => state.GoToPreviousFrame());
}
[FormerlyPrefKeyAs("Animation/Previous Keyframe", "&,")]
[Shortcut("Animation/Previous Keyframe", typeof(AnimationWindow), KeyCode.Comma, ShortcutModifiers.Alt)]
static void PreviousKeyFrame(ShortcutArguments args)
{
ExecuteShortcut(args, state => state.GoToPreviousKeyframe());
}
[FormerlyPrefKeyAs("Animation/Next Keyframe", "&.")]
[Shortcut("Animation/Next Keyframe", typeof(AnimationWindow), KeyCode.Period, ShortcutModifiers.Alt)]
static void NextKeyFrame(ShortcutArguments args)
{
ExecuteShortcut(args, state => state.GoToNextKeyframe());
}
[FormerlyPrefKeyAs("Animation/First Keyframe", "#,")]
[Shortcut("Animation/First Keyframe", typeof(AnimationWindow), KeyCode.Comma, ShortcutModifiers.Shift)]
static void FirstKeyFrame(ShortcutArguments args)
{
ExecuteShortcut(args, state => state.GoToFirstKeyframe());
}
[FormerlyPrefKeyAs("Animation/Last Keyframe", "#.")]
[Shortcut("Animation/Last Keyframe", typeof(AnimationWindow), KeyCode.Period, ShortcutModifiers.Shift)]
static void LastKeyFrame(ShortcutArguments args)
{
ExecuteShortcut(args, state => state.GoToLastKeyframe());
}
[FormerlyPrefKeyAs("Animation/Key Selected", "k")]
[Shortcut("Animation/Key Selected", null, KeyCode.K)]
static void KeySelected(ShortcutArguments args)
{
AnimationWindow animationWindow = AnimationWindow.GetAllAnimationWindows().Find(aw => (aw.state.previewing || aw == EditorWindow.focusedWindow));
if (animationWindow == null)
return;
var animEditor = animationWindow.animEditor;
animEditor.SaveCurveEditorKeySelection();
AnimationWindowUtility.AddSelectedKeyframes(animEditor.m_State, AnimationKeyTime.Frame(animEditor.state.currentFrame, animEditor.state.frameRate));
animEditor.state.ClearCandidates();
animEditor.UpdateSelectedKeysToCurveEditor();
animEditor.Repaint();
}
[FormerlyPrefKeyAs("Animation/Key Modified", "#k")]
[Shortcut("Animation/Key Modified", null, KeyCode.K, ShortcutModifiers.Shift)]
static void KeyModified(ShortcutArguments args)
{
AnimationWindow animationWindow = AnimationWindow.GetAllAnimationWindows().Find(aw => (aw.state.previewing || aw == EditorWindow.focusedWindow));
if (animationWindow == null)
return;
var animEditor = animationWindow.animEditor;
animEditor.SaveCurveEditorKeySelection();
animEditor.state.ProcessCandidates();
animEditor.UpdateSelectedKeysToCurveEditor();
animEditor.Repaint();
}
[Shortcut("Animation/Toggle Ripple", typeof(AnimationWindow), KeyCode.Alpha2, ShortcutModifiers.Shift)]
static void ToggleRipple(ShortcutArguments args)
{
ExecuteShortcut(args, animEditor => { animEditor.state.rippleTime = !animEditor.state.rippleTime; });
}
[ClutchShortcut("Animation/Ripple (Clutch)", typeof(AnimationWindow), KeyCode.Alpha2)]
static void ClutchRipple(ShortcutArguments args)
{
ExecuteShortcut(args, animEditor => { animEditor.state.rippleTimeClutch = args.stage == ShortcutStage.Begin; });
}
[Shortcut("Animation/Frame All", typeof(AnimationWindow), KeyCode.A)]
static void FrameAll(ShortcutArguments args)
{
ExecuteShortcut(args, animEditor => { animEditor.triggerFraming = true; });
}
private void PlayButtonOnGUI()
{
EditorGUI.BeginChangeCheck();
bool playbackEnabled = GUILayout.Toggle(m_State.playing, AnimationWindowStyles.playContent, EditorStyles.toolbarButton);
if (EditorGUI.EndChangeCheck())
{
m_State.playing = playbackEnabled;
// Stop text editing. User may be editing frame navigation ui which will not update until we exit text editing.
EditorGUI.EndEditingActiveTextField();
}
}
private void PreviewButtonOnGUI()
{
EditorGUI.BeginChangeCheck();
bool recordingEnabled = GUILayout.Toggle(m_State.previewing, AnimationWindowStyles.previewContent, EditorStyles.toolbarButton);
if (EditorGUI.EndChangeCheck())
{
m_State.previewing = recordingEnabled;
}
}
private void RecordButtonOnGUI()
{
EditorGUI.BeginChangeCheck();
Color backupColor = GUI.color;
if (m_State.recording)
{
Color recordedColor = AnimationMode.recordedPropertyColor;
recordedColor.a *= GUI.color.a;
GUI.color = recordedColor;
}
bool recordingEnabled = GUILayout.Toggle(m_State.recording, AnimationWindowStyles.recordContent, EditorStyles.toolbarButton);
if (EditorGUI.EndChangeCheck())
{
m_State.recording = recordingEnabled;
if (!recordingEnabled)
{
// Force refresh in inspector as stopping recording does not invalidate any data.
InspectorWindow.RepaintAllInspectors();
}
}
GUI.color = backupColor;
}
private void SwitchBetweenCurvesAndDopesheet()
{
if (!m_State.showCurveEditor)
{
SwitchToCurveEditor();
}
else
{
SwitchToDopeSheetEditor();
}
}
internal void SwitchToCurveEditor()
{
m_State.showCurveEditor = true;
UpdateSelectedKeysToCurveEditor();
AnimationWindowUtility.SyncTimeArea(m_DopeSheet, m_CurveEditor);
m_State.timeArea = m_CurveEditor;
}
internal void SwitchToDopeSheetEditor()
{
m_State.showCurveEditor = false;
UpdateSelectedKeysFromCurveEditor();
AnimationWindowUtility.SyncTimeArea(m_CurveEditor, m_DopeSheet);
m_State.timeArea = m_DopeSheet;
}
private void RenderSelectionOverlay(Rect rect)
{
if (m_State.showCurveEditor && !m_CurveEditor.hasSelection)
return;
if (!m_State.showCurveEditor && m_State.selectedKeys.Count == 0)
return;
const int kOverlayMinWidth = 14;
Bounds bounds = m_State.showCurveEditor ? m_CurveEditor.selectionBounds : m_State.selectionBounds;
float startPixel = m_State.TimeToPixel(bounds.min.x) + rect.xMin;
float endPixel = m_State.TimeToPixel(bounds.max.x) + rect.xMin;
if ((endPixel - startPixel) < kOverlayMinWidth)
{
float centerPixel = (startPixel + endPixel) * 0.5f;
startPixel = centerPixel - kOverlayMinWidth * 0.5f;
endPixel = centerPixel + kOverlayMinWidth * 0.5f;
}
AnimationWindowUtility.DrawSelectionOverlay(rect, selectionRangeColor, startPixel, endPixel);
}
private void RenderInRangeOverlay(Rect rect)
{
Color color = inRangeColor;
if (m_State.recording)
color *= AnimationMode.recordedPropertyColor;
else if (m_State.previewing)
color *= AnimationMode.animatedPropertyColor;
else
color = Color.clear;
Vector2 timeRange = m_State.timeRange;
AnimationWindowUtility.DrawInRangeOverlay(rect, color, m_State.TimeToPixel(timeRange.x) + rect.xMin, m_State.TimeToPixel(timeRange.y) + rect.xMin);
}
private void RenderOutOfRangeOverlay(Rect rect)
{
Color color = outOfRangeColor;
if (m_State.recording)
color *= AnimationMode.recordedPropertyColor;
else if (m_State.previewing)
color *= AnimationMode.animatedPropertyColor;
Vector2 timeRange = m_State.timeRange;
AnimationWindowUtility.DrawOutOfRangeOverlay(rect, color, m_State.TimeToPixel(timeRange.x) + rect.xMin, m_State.TimeToPixel(timeRange.y) + rect.xMin);
}
private void SynchronizeLayout()
{
m_HorizontalSplitter.realSizes[1] = (int)Mathf.Max(Mathf.Min(m_Position.width - m_HorizontalSplitter.realSizes[0], m_HorizontalSplitter.realSizes[1]), 0);
// Synchronize frame rate
if (selection.animationClip != null)
{
m_State.frameRate = selection.animationClip.frameRate;
}
else
{
m_State.frameRate = AnimationWindowState.kDefaultFrameRate;
}
}
struct ChangedCurvesPerClip
{
public List bindings;
public List curves;
}
// Curve editor changes curves, but we are in charge of saving them into the clip
private void SaveChangedCurvesFromCurveEditor()
{
m_State.SaveKeySelection(AnimationWindowState.kEditCurveUndoLabel);
var curvesToUpdate = new Dictionary();
var changedCurves = new ChangedCurvesPerClip();
for (int i = 0; i < m_CurveEditor.animationCurves.Length; ++i)
{
CurveWrapper curveWrapper = m_CurveEditor.animationCurves[i];
if (curveWrapper.changed)
{
if (!curveWrapper.animationIsEditable)
Debug.LogError("Curve is not editable and shouldn't be saved.");
if (curveWrapper.animationClip != null)
{
if (curvesToUpdate.TryGetValue(curveWrapper.animationClip, out changedCurves))
{
changedCurves.bindings.Add(curveWrapper.binding);
changedCurves.curves.Add(curveWrapper.curve.length > 0 ? curveWrapper.curve : null);
}
else
{
changedCurves.bindings = new List();
changedCurves.curves = new List();
changedCurves.bindings.Add(curveWrapper.binding);
changedCurves.curves.Add(curveWrapper.curve.length > 0 ? curveWrapper.curve : null);
curvesToUpdate.Add(curveWrapper.animationClip, changedCurves);
}
}
curveWrapper.changed = false;
}
}
if (curvesToUpdate.Count > 0)
{
foreach (var kvp in curvesToUpdate)
{
Undo.RegisterCompleteObjectUndo(kvp.Key, AnimationWindowState.kEditCurveUndoLabel);
AnimationWindowUtility.SaveCurves(kvp.Key, kvp.Value.bindings, kvp.Value.curves);
}
m_State.ResampleAnimation();
}
}
// We sync keyframe selection from curve editor to AnimationWindowState
private void UpdateSelectedKeysFromCurveEditor()
{
m_State.ClearKeySelections();
foreach (CurveSelection curveSelection in m_CurveEditor.selectedCurves)
{
AnimationWindowKeyframe keyFrame = AnimationWindowUtility.CurveSelectionToAnimationWindowKeyframe(curveSelection, m_State.filteredCurves);
if (keyFrame != null)
m_State.SelectKey(keyFrame);
}
}
// We sync keyframe selection from AnimationWindowState to curve editor
private void UpdateSelectedKeysToCurveEditor()
{
UpdateCurveEditorData();
m_CurveEditor.ClearSelection();
m_CurveEditor.BeginRangeSelection();
foreach (AnimationWindowKeyframe keyframe in m_State.selectedKeys)
{
CurveSelection curveSelection = AnimationWindowUtility.AnimationWindowKeyframeToCurveSelection(keyframe, m_CurveEditor);
if (curveSelection != null)
m_CurveEditor.AddSelection(curveSelection);
}
m_CurveEditor.EndRangeSelection();
}
private void SaveCurveEditorKeySelection()
{
// Synchronize current selection in curve editor and save selection snapshot in undo redo.
if (m_State.showCurveEditor)
UpdateSelectedKeysFromCurveEditor();
else
UpdateSelectedKeysToCurveEditor();
m_CurveEditor.SaveKeySelection(AnimationWindowState.kEditCurveUndoLabel);
}
public void BeginKeyModification()
{
SaveCurveEditorKeySelection();
m_State.SaveKeySelection(AnimationWindowState.kEditCurveUndoLabel);
m_State.ClearKeySelections();
}
public void EndKeyModification()
{
UpdateSelectedKeysToCurveEditor();
}
void HandleMainAreaCopyPaste(int controlID)
{
var evt = Event.current;
var type = evt.GetTypeForControl(controlID);
if (type != EventType.ValidateCommand && type != EventType.ExecuteCommand)
return;
if (evt.commandName == EventCommandNames.Copy)
{
// If events timeline has selected events right now then bail out; copying of
// these will get processed later by AnimationEventTimeLine.
if (m_Events.HasSelectedEvents)
return;
if (type == EventType.ExecuteCommand)
{
if (m_State.showCurveEditor)
UpdateSelectedKeysFromCurveEditor();
m_State.CopyKeys();
}
evt.Use();
}
else if (evt.commandName == EventCommandNames.Paste)
{
if (type == EventType.ExecuteCommand)
{
// If clipboard contains events right now then paste those.
if (AnimationWindowEventsClipboard.CanPaste())
{
m_Events.PasteEvents(m_State.activeRootGameObject, m_State.activeAnimationClip, m_State.currentTime);
}
else
{
SaveCurveEditorKeySelection();
m_State.PasteKeys();
UpdateSelectedKeysToCurveEditor();
}
// data is scheduled for an update, bail out now to avoid using out of date data.
EditorGUIUtility.ExitGUI();
}
evt.Use();
}
}
internal void UpdateCurveEditorData()
{
m_CurveEditor.animationCurves = m_State.activeCurveWrappers;
}
public void Repaint()
{
if (m_OwnerWindow != null)
m_OwnerWindow.Repaint();
}
// Called just-in-time by OnGUI
private void Initialize()
{
AnimationWindowStyles.Initialize();
InitializeHierarchy();
m_CurveEditor.state = m_State;
// The rect here is only for initialization and will be overriden at layout
m_HorizontalSplitter.realSizes[0] = kHierarchyMinWidth;
m_HorizontalSplitter.realSizes[1] = (int)Mathf.Max(m_Position.width - kHierarchyMinWidth, kHierarchyMinWidth);
m_DopeSheet.rect = new Rect(0, 0, contentWidth, 100);
m_Initialized = true;
}
// Called once during initialization of m_State
private void InitializeClipSelection()
{
m_ClipPopup = new AnimationWindowClipPopup();
}
// Called once during initialization of m_State
private void InitializeHierarchy()
{
// The rect here is only for initialization and will be overriden at layout
m_Hierarchy = new AnimationWindowHierarchy(m_State, m_OwnerWindow, new Rect(0, 0, hierarchyWidth, 100));
}
// Called once during initialization of m_State
private void InitializeDopeSheet()
{
m_DopeSheet = new DopeSheetEditor(m_OwnerWindow);
m_DopeSheet.SetTickMarkerRanges();
m_DopeSheet.hSlider = true;
m_DopeSheet.shownArea = new Rect(1, 1, 1, 1);
// The rect here is only for initialization and will be overriden at layout
m_DopeSheet.rect = new Rect(0, 0, contentWidth, 100);
m_DopeSheet.hTicks.SetTickModulosForFrameRate(m_State.frameRate);
}
// Called once during initialization of m_State
private void InitializeEvents()
{
m_Events = new AnimationEventTimeLine(m_OwnerWindow);
}
// Called once during initialization of m_State
private void InitializeCurveEditor()
{
// The rect here is only for initialization and will be overriden at layout
m_CurveEditor = new CurveEditor(new Rect(0, 0, contentWidth, 100), new CurveWrapper[0], false);
CurveEditorSettings settings = new CurveEditorSettings();
settings.hTickStyle.distMin = 30; // min distance between vertical lines before they disappear completely
settings.hTickStyle.distFull = 80; // distance between vertical lines where they gain full strength
settings.hTickStyle.distLabel = 0; // min distance between vertical lines labels
if (EditorGUIUtility.isProSkin)
{
settings.vTickStyle.tickColor.color = new Color(1, 1, 1, settings.vTickStyle.tickColor.color.a); // color and opacity of horizontal lines
settings.vTickStyle.labelColor.color = new Color(1, 1, 1, settings.vTickStyle.labelColor.color.a); // color and opacity of horizontal line labels
}
settings.vTickStyle.distMin = 15; // min distance between horizontal lines before they disappear completely
settings.vTickStyle.distFull = 40; // distance between horizontal lines where they gain full strength
settings.vTickStyle.distLabel = 30; // min distance between horizontal lines labels
settings.vTickStyle.stubs = true;
settings.hRangeMin = 0;
settings.hRangeLocked = false;
settings.vRangeLocked = false;
settings.hSlider = true;
settings.vSlider = true;
settings.allowDeleteLastKeyInCurve = true;
settings.rectangleToolFlags = CurveEditorSettings.RectangleToolFlags.FullRectangleTool;
settings.undoRedoSelection = true;
settings.flushCurveCache = false; // Curve Wrappers are cached in AnimationWindowState.
m_CurveEditor.shownArea = new Rect(1, 1, 1, 1);
m_CurveEditor.settings = settings;
m_CurveEditor.state = m_State;
}
// Called once during initialization of m_State
private void InitializeHorizontalSplitter()
{
m_HorizontalSplitter = SplitterState.FromRelative(new float[] { kHierarchyMinWidth, kHierarchyMinWidth * 3 }, new float[] { kHierarchyMinWidth, kHierarchyMinWidth }, null);
m_HorizontalSplitter.realSizes[0] = kHierarchyMinWidth;
m_HorizontalSplitter.realSizes[1] = kHierarchyMinWidth;
}
// Called once during initialization of m_State
private void InitializeOverlay()
{
m_Overlay = new AnimEditorOverlay();
}
// Called during initialization, even when m_State already exists
private void InitializeNonserializedValues()
{
// Since CurveEditor doesn't know about AnimationWindowState, a delegate allows it to reflect frame rate changes
m_State.onFrameRateChange += delegate(float newFrameRate)
{
m_CurveEditor.invSnap = newFrameRate;
m_CurveEditor.hTicks.SetTickModulosForFrameRate(newFrameRate);
};
m_State.onStartLiveEdit += OnStartLiveEdit;
m_State.onEndLiveEdit += OnEndLiveEdit;
}
}
}
================================================
FILE: Editor/Mono/Animation/AnimationWindow/AnimEditorOverlay.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
using UnityEngine;
using UnityEditor;
using System.Collections;
using System.Collections.Generic;
using UnityEditorInternal;
using Object = UnityEngine.Object;
namespace UnityEditorInternal
{
[System.Serializable]
internal class AnimEditorOverlay
{
[SerializeReference] public AnimationWindowState state;
private TimeCursorManipulator m_PlayHeadCursor;
private Rect m_Rect;
private Rect m_ContentRect;
public Rect rect { get { return m_Rect; } }
public Rect contentRect { get { return m_ContentRect; } }
public void Initialize()
{
if (m_PlayHeadCursor == null)
{
m_PlayHeadCursor = new TimeCursorManipulator(AnimationWindowStyles.playHead);
m_PlayHeadCursor.onStartDrag += (AnimationWindowManipulator manipulator, Event evt) =>
{
if (evt.mousePosition.y <= (m_Rect.yMin + 20))
return OnStartDragPlayHead(evt);
return false;
};
m_PlayHeadCursor.onDrag += (AnimationWindowManipulator manipulator, Event evt) =>
{
return OnDragPlayHead(evt);
};
m_PlayHeadCursor.onEndDrag += (AnimationWindowManipulator manipulator, Event evt) =>
{
return OnEndDragPlayHead(evt);
};
}
}
public void OnGUI(Rect rect, Rect contentRect)
{
if (Event.current.type != EventType.Repaint)
return;
m_Rect = rect;
m_ContentRect = contentRect;
Initialize();
m_PlayHeadCursor.OnGUI(m_Rect, m_Rect.xMin + TimeToPixel(state.currentTime));
}
public void HandleEvents()
{
Initialize();
m_PlayHeadCursor.HandleEvents();
}
private bool OnStartDragPlayHead(Event evt)
{
state.playing = false;
state.controlInterface.time = MousePositionToTime(evt);
return true;
}
private bool OnDragPlayHead(Event evt)
{
state.controlInterface.time = MousePositionToTime(evt);
return true;
}
private bool OnEndDragPlayHead(Event evt)
{
return true;
}
public float MousePositionToTime(Event evt)
{
float width = m_ContentRect.width;
float time = Mathf.Max(((evt.mousePosition.x / width) * state.visibleTimeSpan + state.minVisibleTime), 0);
time = state.SnapToFrame(time, AnimationWindowState.SnapMode.SnapToFrame);
return time;
}
public float MousePositionToValue(Event evt)
{
float height = m_ContentRect.height;
float valuePixel = height - evt.mousePosition.y;
TimeArea timeArea = state.timeArea;
float pixelPerValue = timeArea.m_Scale.y * -1f;
float zeroValuePixel = timeArea.shownArea.yMin * pixelPerValue * -1f;
float value = (valuePixel - zeroValuePixel) / pixelPerValue;
return value;
}
public float TimeToPixel(float time)
{
return state.TimeToPixel(time);
}
public float ValueToPixel(float value)
{
TimeArea timeArea = state.timeArea;
float pixelPerValue = timeArea.m_Scale.y * -1f;
float zeroValuePixel = timeArea.shownArea.yMin * pixelPerValue * -1f;
float pixelValue = value * pixelPerValue + zeroValuePixel;
return pixelValue;
}
}
}
================================================
FILE: Editor/Mono/Animation/AnimationWindow/AnimationClipSelectionItem.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
using UnityEngine;
using UnityEditor;
using Object = UnityEngine.Object;
namespace UnityEditorInternal
{
[Serializable]
internal class AnimationClipSelectionItem : AnimationWindowSelectionItem
{
public static AnimationClipSelectionItem Create(AnimationClip animationClip, Object sourceObject = null)
{
var selectionItem = new AnimationClipSelectionItem
{
gameObject = sourceObject as GameObject,
scriptableObject = sourceObject as ScriptableObject,
animationClip = animationClip,
id = 0
};
return selectionItem;
}
public override bool canPreview { get { return false; } }
public override bool canRecord { get { return false; } }
public override bool canChangeAnimationClip { get { return false; } }
public override bool canSyncSceneSelection { get { return false; } }
}
}
================================================
FILE: Editor/Mono/Animation/AnimationWindow/AnimationContextualPropertyMenu.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
namespace UnityEditorInternal
{
class AnimationPropertyContextualMenu
{
public static AnimationPropertyContextualMenu Instance = new AnimationPropertyContextualMenu();
IAnimationContextualResponder m_Responder;
private static GUIContent addKeyContent = EditorGUIUtility.TrTextContent("Add Key");
private static GUIContent updateKeyContent = EditorGUIUtility.TrTextContent("Update Key");
private static GUIContent removeKeyContent = EditorGUIUtility.TrTextContent("Remove Key");
private static GUIContent removeCurveContent = EditorGUIUtility.TrTextContent("Remove All Keys");
private static GUIContent goToPreviousKeyContent = EditorGUIUtility.TrTextContent("Go to Previous Key");
private static GUIContent goToNextKeyContent = EditorGUIUtility.TrTextContent("Go to Next Key");
private static GUIContent addCandidatesContent = EditorGUIUtility.TrTextContent("Key All Modified");
private static GUIContent addAnimatedContent = EditorGUIUtility.TrTextContent("Key All Animated");
public AnimationPropertyContextualMenu()
{
EditorApplication.contextualPropertyMenu += OnPropertyContextMenu;
MaterialEditor.contextualPropertyMenu += OnPropertyContextMenu;
}
public void SetResponder(IAnimationContextualResponder responder)
{
m_Responder = responder;
}
public bool IsResponder(IAnimationContextualResponder responder)
{
return responder == m_Responder;
}
void OnPropertyContextMenu(GenericMenu menu, SerializedProperty property)
{
if (m_Responder == null)
return;
PropertyModification[] modifications = AnimationWindowUtility.SerializedPropertyToPropertyModifications(property);
bool isPropertyAnimatable = m_Responder.IsAnimatable(modifications);
if (isPropertyAnimatable)
{
var targetObject = property.serializedObject.targetObject;
if (m_Responder.IsEditable(targetObject))
OnPropertyContextMenu(menu, modifications);
else
OnDisabledPropertyContextMenu(menu);
}
}
void OnPropertyContextMenu(GenericMenu menu, MaterialProperty property, Renderer[] renderers)
{
if (m_Responder == null)
return;
if (property.targets == null || property.targets.Length == 0)
return;
if (renderers == null || renderers.Length == 0)
return;
var modifications = new List();
foreach (Renderer renderer in renderers)
{
modifications.AddRange(MaterialAnimationUtility.MaterialPropertyToPropertyModifications(property, renderer));
}
if (m_Responder.IsEditable(renderers[0]))
OnPropertyContextMenu(menu, modifications.ToArray());
else
OnDisabledPropertyContextMenu(menu);
}
void OnPropertyContextMenu(GenericMenu menu, PropertyModification[] modifications)
{
bool hasKey = m_Responder.KeyExists(modifications);
bool hasCandidate = m_Responder.CandidateExists(modifications);
bool hasCurve = (hasKey || m_Responder.CurveExists(modifications));
bool hasAnyCandidate = m_Responder.HasAnyCandidates();
bool hasAnyCurve = m_Responder.HasAnyCurves();
menu.AddItem(((hasKey && hasCandidate) ? updateKeyContent : addKeyContent), false, () =>
{
m_Responder.AddKey(modifications);
});
if (hasKey)
{
menu.AddItem(removeKeyContent, false, () =>
{
m_Responder.RemoveKey(modifications);
});
}
else
{
menu.AddDisabledItem(removeKeyContent);
}
if (hasCurve)
{
menu.AddItem(removeCurveContent, false, () =>
{
m_Responder.RemoveCurve(modifications);
});
}
else
{
menu.AddDisabledItem(removeCurveContent);
}
menu.AddSeparator(string.Empty);
if (hasAnyCandidate)
{
menu.AddItem(addCandidatesContent, false, () =>
{
m_Responder.AddCandidateKeys();
});
}
else
{
menu.AddDisabledItem(addCandidatesContent);
}
if (hasAnyCurve)
{
menu.AddItem(addAnimatedContent, false, () =>
{
m_Responder.AddAnimatedKeys();
});
}
else
{
menu.AddDisabledItem(addAnimatedContent);
}
menu.AddSeparator(string.Empty);
if (hasCurve)
{
menu.AddItem(goToPreviousKeyContent, false, () =>
{
m_Responder.GoToPreviousKeyframe(modifications);
});
menu.AddItem(goToNextKeyContent, false, () =>
{
m_Responder.GoToNextKeyframe(modifications);
});
}
else
{
menu.AddDisabledItem(goToPreviousKeyContent);
menu.AddDisabledItem(goToNextKeyContent);
}
}
void OnDisabledPropertyContextMenu(GenericMenu menu)
{
menu.AddDisabledItem(addKeyContent);
menu.AddDisabledItem(removeKeyContent);
menu.AddDisabledItem(removeCurveContent);
menu.AddSeparator(string.Empty);
menu.AddDisabledItem(addCandidatesContent);
menu.AddDisabledItem(addAnimatedContent);
menu.AddSeparator(string.Empty);
menu.AddDisabledItem(goToPreviousKeyContent);
menu.AddDisabledItem(goToNextKeyContent);
}
}
}
================================================
FILE: Editor/Mono/Animation/AnimationWindow/AnimationKeyTime.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using UnityEngine;
namespace UnityEditorInternal
{
[System.Serializable]
struct AnimationKeyTime
{
[SerializeField] private float m_FrameRate;
[SerializeField] private int m_Frame;
[SerializeField] private float m_Time;
public float time { get { return m_Time; } }
public int frame { get { return m_Frame; } }
public float frameRate { get { return m_FrameRate; } }
///
/// A frame has a range of time. This is the beginning of the frame.
///
public float frameFloor
{
get
{
return ((float)frame - 0.5f) / frameRate;
}
}
///
/// A frame has a range of time. This is the end of the frame.
///
public float frameCeiling
{
get
{
return ((float)frame + 0.5f) / frameRate;
}
}
public float timeRound
{
get
{
return (float)frame / frameRate;
}
}
public static AnimationKeyTime Time(float time, float frameRate)
{
AnimationKeyTime key = new AnimationKeyTime();
key.m_Time = Mathf.Max(time, 0f);
key.m_FrameRate = frameRate;
key.m_Frame = UnityEngine.Mathf.RoundToInt(key.m_Time * frameRate);
return key;
}
public static AnimationKeyTime Frame(int frame, float frameRate)
{
AnimationKeyTime key = new AnimationKeyTime();
key.m_Frame = (frame < 0) ? 0 : frame;
key.m_Time = key.m_Frame / frameRate;
key.m_FrameRate = frameRate;
return key;
}
// Check if a time in seconds overlaps with the frame
public bool ContainsTime(float time)
{
return time >= frameFloor && time < frameCeiling;
}
public bool Equals(AnimationKeyTime key)
{
return m_Frame == key.m_Frame &&
m_FrameRate == key.m_FrameRate &&
Mathf.Approximately(m_Time, key.m_Time);
}
}
}
================================================
FILE: Editor/Mono/Animation/AnimationWindow/AnimationRecording.cs
================================================
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using UnityEngine;
using UnityEditor;
namespace UnityEditorInternal
{
internal class AnimationRecording
{
const string kLocalPosition = "m_LocalPosition";
const string kLocalRotation = "m_LocalRotation";
const string kLocalScale = "m_LocalScale";
const string kLocalEulerAnglesHint = "m_LocalEulerAnglesHint";
static bool HasAnyRecordableModifications(GameObject root, UndoPropertyModification[] modifications)
{
for (int i = 0; i < modifications.Length; i++)
{
EditorCurveBinding tempBinding;
if (AnimationUtility.PropertyModificationToEditorCurveBinding(modifications[i].previousValue, root, out tempBinding) != null)
return true;
}
return false;
}
static private UndoPropertyModification[] FilterModifications(IAnimationRecordingState state, ref UndoPropertyModification[] modifications)
{
GameObject rootGameObject = state.activeRootGameObject;
List discardedModifications = new List();
List outModifications = new List();
for (int i = 0; i < modifications.Length; ++i)
{
UndoPropertyModification modification = modifications[i];
PropertyModification prop = modification.previousValue;
if (state.DiscardModification(prop))
{
discardedModifications.Add(modification);
continue;
}
var binding = new EditorCurveBinding();
if (AnimationUtility.PropertyModificationToEditorCurveBinding(prop, rootGameObject, out binding) != null)
outModifications.Add(modification);
else
discardedModifications.Add(modification);
}
if (discardedModifications.Count > 0)
modifications = outModifications.ToArray();
return discardedModifications.ToArray();
}
internal class RotationModification
{
public UndoPropertyModification x;
public UndoPropertyModification y;
public UndoPropertyModification z;
public UndoPropertyModification w;
public UndoPropertyModification lastQuatModification;
public bool useEuler = false;
public UndoPropertyModification eulerX;
public UndoPropertyModification eulerY;
public UndoPropertyModification eulerZ;
}
static private void CollectRotationModifications(IAnimationRecordingState state, ref UndoPropertyModification[] modifications,
ref Dictionary rotationModifications)
{
List outModifs = new List();
foreach (var modification in modifications)
{
PropertyModification prop = modification.previousValue;
if (!(prop.target is Transform))
{
outModifs.Add(modification);
continue;
}
EditorCurveBinding binding = new EditorCurveBinding();
AnimationUtility.PropertyModificationToEditorCurveBinding(prop, state.activeRootGameObject, out binding);
if (binding.propertyName.StartsWith(kLocalRotation))
{
RotationModification rotationModification;
if (!rotationModifications.TryGetValue(prop.target, out rotationModification))
{
rotationModification = new RotationModification();
rotationModifications[prop.target] = rotationModification;
}
if (binding.propertyName.EndsWith("x"))
rotationModification.x = modification;
else if (binding.propertyName.EndsWith("y"))
rotationModification.y = modification;
else if (binding.propertyName.EndsWith("z"))
rotationModification.z = modification;
else if (binding.propertyName.EndsWith("w"))
rotationModification.w = modification;
rotationModification.lastQuatModification = modification;
}
else if (prop.propertyPath.StartsWith(kLocalEulerAnglesHint))
{
RotationModification rotationModification;
if (!rotationModifications.TryGetValue(prop.target, out rotationModification))
{
rotationModification = new RotationModification();
rotationModifications[prop.target] = rotationModification;
}
rotationModification.useEuler = true;
if (prop.propertyPath.EndsWith("x"))
rotationModification.eulerX = modification;
else if (prop.propertyPath.EndsWith("y"))
rotationModification.eulerY = modification;
else if (prop.propertyPath.EndsWith("z"))
rotationModification.eulerZ = modification;
}
else
{
outModifs.Add(modification);
}
}
if (rotationModifications.Count > 0)
{
modifications = outModifs.ToArray();
}
}
static private void DiscardRotationModification(RotationModification rotationModification, ref List discardedModifications)
{
if (rotationModification.x.currentValue != null)
discardedModifications.Add(rotationModification.x);
if (rotationModification.y.currentValue != null)
discardedModifications.Add(rotationModification.y);
if (rotationModification.z.currentValue != null)
discardedModifications.Add(rotationModification.z);
if (rotationModification.w.currentValue != null)
discardedModifications.Add(rotationModification.w);
if (rotationModification.eulerX.currentValue != null)
discardedModifications.Add(rotationModification.eulerX);
if (rotationModification.eulerY.currentValue != null)
discardedModifications.Add(rotationModification.eulerY);
if (rotationModification.eulerZ.currentValue != null)
discardedModifications.Add(rotationModification.eulerZ);
}
static private UndoPropertyModification[] FilterRotationModifications(IAnimationRecordingState state, ref Dictionary rotationModifications)
{
GameObject rootGameObject = state.activeRootGameObject;
List