diff --git a/Editor/IncrementalBuildPipeline/BeeBuildProgramCommon.Data/BeeBuildProgramCommon.Data.gen.csproj b/Editor/IncrementalBuildPipeline/BeeBuildProgramCommon.Data/BeeBuildProgramCommon.Data.gen.csproj new file mode 100644 index 0000000000..3672103003 --- /dev/null +++ b/Editor/IncrementalBuildPipeline/BeeBuildProgramCommon.Data/BeeBuildProgramCommon.Data.gen.csproj @@ -0,0 +1,17 @@ + + + + + BeeBuildProgramCommon.Data + netstandard2.1 + false + false + false + latest + 1701 + + + + + + diff --git a/Editor/IncrementalBuildPipeline/BeeBuildProgramCommon.Data/Data.cs b/Editor/IncrementalBuildPipeline/BeeBuildProgramCommon.Data/Data.cs new file mode 100644 index 0000000000..0a7938fabc --- /dev/null +++ b/Editor/IncrementalBuildPipeline/BeeBuildProgramCommon.Data/Data.cs @@ -0,0 +1,41 @@ +// 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; + } +} diff --git a/Editor/IncrementalBuildPipeline/PlayerBuildProgramLibrary.Data/Data.cs b/Editor/IncrementalBuildPipeline/PlayerBuildProgramLibrary.Data/Data.cs new file mode 100644 index 0000000000..48b52443eb --- /dev/null +++ b/Editor/IncrementalBuildPipeline/PlayerBuildProgramLibrary.Data/Data.cs @@ -0,0 +1,132 @@ +// 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, + } +} diff --git a/Editor/IncrementalBuildPipeline/PlayerBuildProgramLibrary.Data/PlayerBuildProgramLibrary.Data.gen.csproj b/Editor/IncrementalBuildPipeline/PlayerBuildProgramLibrary.Data/PlayerBuildProgramLibrary.Data.gen.csproj new file mode 100644 index 0000000000..3f29c8f429 --- /dev/null +++ b/Editor/IncrementalBuildPipeline/PlayerBuildProgramLibrary.Data/PlayerBuildProgramLibrary.Data.gen.csproj @@ -0,0 +1,19 @@ + + + + + PlayerBuildProgramLibrary.Data + netstandard2.1 + false + false + false + latest + 1701 + PlayerBuildProgramLibrary.Data + + + + + + + diff --git a/Editor/IncrementalBuildPipeline/ScriptCompilationBuildProgram.Data/Data.cs b/Editor/IncrementalBuildPipeline/ScriptCompilationBuildProgram.Data/Data.cs new file mode 100644 index 0000000000..fc674d689c --- /dev/null +++ b/Editor/IncrementalBuildPipeline/ScriptCompilationBuildProgram.Data/Data.cs @@ -0,0 +1,68 @@ +// 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; + } +} diff --git a/Editor/IncrementalBuildPipeline/ScriptCompilationBuildProgram.Data/ScriptCompilationBuildProgram.Data.gen.csproj b/Editor/IncrementalBuildPipeline/ScriptCompilationBuildProgram.Data/ScriptCompilationBuildProgram.Data.gen.csproj new file mode 100644 index 0000000000..d714f512c1 --- /dev/null +++ b/Editor/IncrementalBuildPipeline/ScriptCompilationBuildProgram.Data/ScriptCompilationBuildProgram.Data.gen.csproj @@ -0,0 +1,18 @@ + + + + + ScriptCompilationBuildProgram.Data + netstandard2.1 + false + false + false + latest + 1701 + + + + + + + diff --git a/Editor/Mono/2D/Common/TexturePlatformSettingsView.cs b/Editor/Mono/2D/Common/TexturePlatformSettingsView.cs index 9432ed2b11..e46d1314a0 100644 --- a/Editor/Mono/2D/Common/TexturePlatformSettingsView.cs +++ b/Editor/Mono/2D/Common/TexturePlatformSettingsView.cs @@ -20,7 +20,7 @@ class Styles 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 }; + public readonly int[] kMaxTextureSizeValues = { 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384 }; public readonly GUIContent[] kMaxTextureSizeStrings; public readonly GUIContent[] kTextureCompressionOptions = diff --git a/Editor/Mono/2D/SpriteAtlas/EditorSpriteAtlas.bindings.cs b/Editor/Mono/2D/SpriteAtlas/EditorSpriteAtlas.bindings.cs index 6c1eb58feb..bf615783af 100644 --- a/Editor/Mono/2D/SpriteAtlas/EditorSpriteAtlas.bindings.cs +++ b/Editor/Mono/2D/SpriteAtlas/EditorSpriteAtlas.bindings.cs @@ -6,6 +6,8 @@ using UnityEngine; using UnityEngine.U2D; using UnityEngine.Bindings; +using System; +using UnityEditor.AssetImporters; namespace UnityEditor.U2D { @@ -13,6 +15,12 @@ namespace UnityEditor.U2D [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); @@ -21,6 +29,11 @@ public class SpriteAtlasUtility 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); } } @@ -47,6 +60,7 @@ public struct SpriteAtlasTextureSettings [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; } } @@ -67,11 +81,14 @@ public struct SpriteAtlasPackingSettings 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")] @@ -80,31 +97,71 @@ public struct SpriteAtlasPackingSettings [NativeHeader("Runtime/2D/SpriteAtlas/SpriteAtlas.h")] public static class SpriteAtlasExtensions { - extern public static void Add(this SpriteAtlas spriteAtlas, UnityEngine.Object[] objects); - extern public static void Remove(this SpriteAtlas spriteAtlas, UnityEngine.Object[] objects); - extern internal static void RemoveAt(this SpriteAtlas spriteAtlas, int index); - extern public static UnityEngine.Object[] GetPackables(this SpriteAtlas spriteAtlas); - extern public static SpriteAtlasTextureSettings GetTextureSettings(this SpriteAtlas spriteAtlas); - extern public static void SetTextureSettings(this SpriteAtlas spriteAtlas, SpriteAtlasTextureSettings src); - extern public static SpriteAtlasPackingSettings GetPackingSettings(this SpriteAtlas spriteAtlas); - extern public static void SetPackingSettings(this SpriteAtlas spriteAtlas, SpriteAtlasPackingSettings src); - extern public static TextureImporterPlatformSettings GetPlatformSettings(this SpriteAtlas spriteAtlas, string buildTarget); - extern public static void SetPlatformSettings(this SpriteAtlas spriteAtlas, TextureImporterPlatformSettings src); - extern public static void SetIncludeInBuild(this SpriteAtlas spriteAtlas, bool value); - extern public static void SetIsVariant(this SpriteAtlas spriteAtlas, bool value); - extern public static void SetMasterAtlas(this SpriteAtlas spriteAtlas, SpriteAtlas value); - extern public static void SetVariantScale(this SpriteAtlas spriteAtlas, float value); - extern internal static void CopyMasterAtlasSettings(this SpriteAtlas spriteAtlas); - extern internal static string GetHash(this SpriteAtlas spriteAtlas); - extern internal static Texture2D[] GetPreviewTextures(this SpriteAtlas spriteAtlas); - extern internal static Texture2D[] GetPreviewAlphaTextures(this SpriteAtlas spriteAtlas); - extern internal static TextureFormat GetTextureFormat(this SpriteAtlas spriteAtlas, BuildTarget target); - extern internal static Sprite[] GetPackedSprites(this SpriteAtlas spriteAtlas); - extern internal static Hash128 GetStoredHash(this SpriteAtlas spriteAtlas); - extern internal static TextureImporterPlatformSettings GetSecondaryPlatformSettings(this SpriteAtlas spriteAtlas, string buildTarget, string secondaryTextureName); - extern internal static void SetSecondaryPlatformSettings(this SpriteAtlas spriteAtlas, TextureImporterPlatformSettings src, string secondaryTextureName); - extern internal static bool GetSecondaryColorSpace(this SpriteAtlas spriteAtlas, string secondaryTextureName); - extern internal static void SetSecondaryColorSpace(this SpriteAtlas spriteAtlas, string secondaryTextureName, bool srGB); - extern internal static void DeleteSecondaryPlatformSettings(this SpriteAtlas spriteAtlas, string secondaryTextureName); + 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); } } diff --git a/Editor/Mono/2D/SpriteAtlas/EditorSpritePacking.bindings.cs b/Editor/Mono/2D/SpriteAtlas/EditorSpritePacking.bindings.cs new file mode 100644 index 0000000000..145e7da29f --- /dev/null +++ b/Editor/Mono/2D/SpriteAtlas/EditorSpritePacking.bindings.cs @@ -0,0 +1,183 @@ +// 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); + } +} diff --git a/Editor/Mono/2D/SpriteAtlas/SpriteAtlasAsset.bindings.cs b/Editor/Mono/2D/SpriteAtlas/SpriteAtlasAsset.bindings.cs index 9ffbf04228..ee92ddf825 100644 --- a/Editor/Mono/2D/SpriteAtlas/SpriteAtlasAsset.bindings.cs +++ b/Editor/Mono/2D/SpriteAtlas/SpriteAtlasAsset.bindings.cs @@ -4,16 +4,115 @@ using System; using System.Collections.Generic; -using System.ComponentModel; -using UnityEditor.Build; -using UnityEditor.Experimental.AssetImporters; +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")] @@ -25,25 +124,50 @@ public class SpriteAtlasAsset : UnityEngine.Object extern public bool isVariant { [NativeMethod("GetIsVariant")] get; } extern public void SetIsVariant(bool value); extern public void SetMasterAtlas(SpriteAtlas atlas); - extern public void SetIncludeInBuild(bool value); - extern public void SetVariantScale(float value); - extern public void SetPlatformSettings(TextureImporterPlatformSettings src); - extern public TextureImporterPlatformSettings GetPlatformSettings(string buildTarget); - extern public SpriteAtlasTextureSettings GetTextureSettings(); - extern public void SetTextureSettings(SpriteAtlasTextureSettings src); - extern public SpriteAtlasPackingSettings GetPackingSettings(); - extern public void SetPackingSettings(SpriteAtlasPackingSettings src); - + 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); - extern internal TextureFormat GetTextureFormat(BuildTarget target); - extern internal void CopyMasterAtlasSettings(); - extern internal TextureImporterPlatformSettings GetSecondaryPlatformSettings(string buildTarget, string secondaryTextureName); - extern internal void SetSecondaryPlatformSettings(TextureImporterPlatformSettings src, string secondaryTextureName); - extern internal bool GetSecondaryColorSpace(string secondaryTextureName); - extern internal void SetSecondaryColorSpace(string secondaryTextureName, bool srGB); - extern internal void DeleteSecondaryPlatformSettings(string secondaryTextureName); + [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); + } } }; diff --git a/Editor/Mono/2D/SpriteAtlas/SpriteAtlasImporter.bindings.cs b/Editor/Mono/2D/SpriteAtlas/SpriteAtlasImporter.bindings.cs index 99058c98dc..12a8178c4f 100644 --- a/Editor/Mono/2D/SpriteAtlas/SpriteAtlasImporter.bindings.cs +++ b/Editor/Mono/2D/SpriteAtlas/SpriteAtlasImporter.bindings.cs @@ -6,7 +6,7 @@ using System.Collections.Generic; using System.ComponentModel; using UnityEditor.Build; -using UnityEditor.Experimental.AssetImporters; +using UnityEditor.AssetImporters; using UnityEngine; using UnityEngine.Bindings; using UnityEngine.Scripting; @@ -15,9 +15,52 @@ 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); } }; diff --git a/Editor/Mono/2D/SpriteAtlas/SpriteAtlasImporterInspector.cs b/Editor/Mono/2D/SpriteAtlas/SpriteAtlasImporterInspector.cs index 39f8b1992e..2251994103 100644 --- a/Editor/Mono/2D/SpriteAtlas/SpriteAtlasImporterInspector.cs +++ b/Editor/Mono/2D/SpriteAtlas/SpriteAtlasImporterInspector.cs @@ -2,6 +2,7 @@ // 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; @@ -10,11 +11,12 @@ using UnityEditor.U2D.Common; using UnityEditor.U2D.Interface; using UnityEditorInternal; +using UnityEditor.AssetImporters; namespace UnityEditor.U2D { [CustomEditor(typeof(SpriteAtlasImporter))] - internal class SpriteAtlasImporterInspector : Editor + internal class SpriteAtlasImporterInspector : AssetImporterEditor { class SpriteAtlasInspectorPlatformSettingView : TexturePlatformSettingsView { @@ -49,19 +51,22 @@ class Styles 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 Enabled", "Enable to be able to access the raw pixel data from code."); + 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 Sprite Sheet (Texture) and Sprite."); + 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."); @@ -76,6 +81,7 @@ class Styles 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."); @@ -108,8 +114,14 @@ private static Styles styles return s_Styles; } } - private SpriteAtlasAsset spriteAtlasAsset { get { return m_TargetAsset as SpriteAtlasAsset; } } - private SpriteAtlasImporter spriteAtlasImporter { get { return target as SpriteAtlasImporter; } } + 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; @@ -118,6 +130,7 @@ private enum AtlasType { Undefined = -1, Master = 0, Variant = 1 } 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; @@ -125,6 +138,7 @@ private enum AtlasType { Undefined = -1, Master = 0, Variant = 1 } private SerializedProperty m_MasterAtlas; private SerializedProperty m_VariantScale; + private SerializedProperty m_ScriptablePacker; private string m_Hash; private int m_PreviewPage = 0; @@ -141,11 +155,12 @@ private enum AtlasType { Undefined = -1, Master = 0, Variant = 1 } private float m_MipLevel = 0; private bool m_ShowAlpha; - private bool m_HasChanged = false; + 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; @@ -160,7 +175,7 @@ private enum AtlasType { Undefined = -1, Master = 0, Variant = 1 } static bool IsPackable(Object o) { - return o != null && (o.GetType() == typeof(Sprite) || o.GetType() == typeof(Texture2D)); + 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) @@ -173,12 +188,22 @@ static Object ValidateObjectForPackableFieldAssignment(Object[] references, Syst bool IsTargetVariant() { - return spriteAtlasAsset.isVariant; + return spriteAtlasAsset ? spriteAtlasAsset.isVariant : false; } bool IsTargetMaster() { - return !spriteAtlasAsset.isVariant; + 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() @@ -197,6 +222,44 @@ private SerializedObject serializedAssetObject 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) @@ -205,6 +268,7 @@ private SerializedObject GetSerializedAssetObject() { 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) @@ -217,36 +281,24 @@ private SerializedObject GetSerializedAssetObject() return m_SerializedAssetObject; } - void OnEnable() + public override void OnEnable() { - m_AssetPath = LoadSourceAsset(); - if (spriteAtlasAsset == null) - return; - - m_FilterMode = serializedAssetObject.FindProperty("m_ImporterData.textureSettings.filterMode"); - m_AnisoLevel = serializedAssetObject.FindProperty("m_ImporterData.textureSettings.anisoLevel"); - m_GenerateMipMaps = serializedAssetObject.FindProperty("m_ImporterData.textureSettings.generateMipMaps"); - m_Readable = serializedAssetObject.FindProperty("m_ImporterData.textureSettings.readable"); - m_UseSRGB = serializedAssetObject.FindProperty("m_ImporterData.textureSettings.sRGB"); + base.OnEnable(); - m_EnableTightPacking = serializedAssetObject.FindProperty("m_ImporterData.packingSettings.enableTightPacking"); - m_EnableRotation = serializedAssetObject.FindProperty("m_ImporterData.packingSettings.enableRotation"); - m_Padding = serializedAssetObject.FindProperty("m_ImporterData.packingSettings.padding"); - - m_MasterAtlas = serializedAssetObject.FindProperty("m_MasterAtlas"); - m_BindAsDefault = serializedAssetObject.FindProperty("m_ImporterData.bindAsDefault"); - m_VariantScale = serializedAssetObject.FindProperty("m_ImporterData.variantMultiplier"); + 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(); - m_Packables = serializedAssetObject.FindProperty("m_ImporterData.packables"); - m_PackableList = new ReorderableList(serializedAssetObject, m_Packables, true, true, true, true); - m_PackableList.onAddCallback = AddPackable; - m_PackableList.onRemoveCallback = RemovePackable; - m_PackableList.drawElementCallback = DrawPackableElement; - m_PackableList.elementHeight = EditorGUIUtility.singleLineHeight; - m_PackableList.headerHeight = 0f; - SyncPlatformSettings(); m_TexturePlatformSettingsView = new SpriteAtlasInspectorPlatformSettingView(IsTargetMaster()); @@ -255,13 +307,26 @@ void OnEnable() // 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 = serializedAssetObject.FindProperty("m_ImporterData.secondaryTextureSettings"); + SerializedProperty secondaryPlatformSettings = serializedObject.FindProperty("m_SecondaryTextureSettings"); if (secondaryPlatformSettings != null && !secondaryPlatformSettings.hasMultipleDifferentValues) { int numSecondaryTextures = secondaryPlatformSettings.arraySize; @@ -289,8 +354,8 @@ void SyncPlatformSettings() var defaultSettings = new List(); m_TempPlatformSettings.Add(TextureImporterInspector.s_DefaultPlatformName, defaultSettings); var settings = secondaryTextureSelected - ? spriteAtlasAsset.GetSecondaryPlatformSettings(TextureImporterInspector.s_DefaultPlatformName, secondaryTextureName) - : spriteAtlasAsset.GetPlatformSettings(TextureImporterInspector.s_DefaultPlatformName); + ? spriteAtlasImporter.GetSecondaryPlatformSettings(TextureImporterInspector.s_DefaultPlatformName, secondaryTextureName) + : spriteAtlasImporter.GetPlatformSettings(TextureImporterInspector.s_DefaultPlatformName); defaultSettings.Add(settings); m_ValidPlatforms = BuildPlatforms.instance.GetValidPlatforms(); @@ -298,7 +363,7 @@ void SyncPlatformSettings() { var platformSettings = new List(); m_TempPlatformSettings.Add(platform.name, platformSettings); - var perPlatformSettings = secondaryTextureSelected ? spriteAtlasAsset.GetSecondaryPlatformSettings(platform.name, secondaryTextureName) : spriteAtlasAsset.GetPlatformSettings(platform.name); + var perPlatformSettings = secondaryTextureSelected ? spriteAtlasImporter.GetSecondaryPlatformSettings(platform.name, secondaryTextureName) : spriteAtlasImporter.GetPlatformSettings(platform.name); // setting will be in default state if copy failed platformSettings.Add(perPlatformSettings); } @@ -306,32 +371,25 @@ void SyncPlatformSettings() void RenameSecondaryPlatformSettings(string oldName, string newName) { - spriteAtlasAsset.DeleteSecondaryPlatformSettings(oldName); + spriteAtlasImporter.DeleteSecondaryPlatformSettings(oldName); var defaultPlatformSettings = m_TempPlatformSettings[TextureImporterInspector.s_DefaultPlatformName]; - spriteAtlasAsset.SetSecondaryPlatformSettings(defaultPlatformSettings[0], newName); + spriteAtlasImporter.SetSecondaryPlatformSettings(defaultPlatformSettings[0], newName); foreach (var buildPlatform in m_ValidPlatforms) { var platformSettings = m_TempPlatformSettings[buildPlatform.name]; - spriteAtlasAsset.SetSecondaryPlatformSettings(platformSettings[0], newName); + spriteAtlasImporter.SetSecondaryPlatformSettings(platformSettings[0], newName); } } void AddPackable(ReorderableList list) { ObjectSelector.get.Show(null, typeof(Object), null, false); - ObjectSelector.get.searchFilter = "t:sprite t:texture2d"; + 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) - spriteAtlasAsset.RemoveAt(index); - } - void DrawPackableElement(Rect rect, int index, bool selected, bool focused) { var property = m_Packables.GetArrayElementAtIndex(index); @@ -341,10 +399,7 @@ void DrawPackableElement(Rect rect, int index, bool selected, bool focused) 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. - if (previousObject != null) - spriteAtlasAsset.Remove(new Object[] { previousObject }); + Undo.RegisterCompleteObjectUndo(spriteAtlasAsset, styles.swapObjectRegisterUndo); property.objectReferenceValue = changedObject; } @@ -352,44 +407,39 @@ void DrawPackableElement(Rect rect, int index, bool selected, bool focused) m_PackableList.index = index; } - public virtual void OnDestroy() + protected override void Apply() { if (HasModified()) { - ApplyAndImport(); - } - } + if (spriteAtlasAsset) + { + SpriteAtlasAsset.Save(spriteAtlasAsset, m_AssetPath); + AssetDatabase.ImportAsset(m_AssetPath); + } - protected void Apply() - { - if (HasModified()) - { - serializedAssetObject.ApplyModifiedPropertiesWithoutUndo(); - InternalEditorUtility.SaveToSerializedFileAndForget(new Object[] { spriteAtlasAsset }, m_AssetPath, true); + m_ContentHash = GetInspectorHash(); } + base.Apply(); } - public void ApplyAndImport() - { - Apply(); - AssetDatabase.ImportAsset(m_AssetPath); - } + protected override bool useAssetDrawPreview { get { return false; } } - protected void ApplyRevertGUI() + protected void PackPreviewGUI() { EditorGUILayout.Space(); using (new GUILayout.HorizontalScope()) { - using (new EditorGUI.DisabledScope(!HasModified() || !IsValidAtlas())) + using (new EditorGUI.DisabledScope(!HasModified() || !IsValidAtlas() || Application.isPlaying)) { GUILayout.FlexibleSpace(); - if (GUILayout.Button("Pack Preview")) + if (GUILayout.Button(styles.packPreviewLabel)) { GUI.FocusControl(null); - ApplyAndImport(); - m_HasChanged = false; + SpriteAtlasUtility.EnableV2Import(true); + SaveChanges(); + SpriteAtlasUtility.EnableV2Import(false); } } } @@ -403,9 +453,9 @@ private bool IsValidAtlas() return true; } - public bool HasModified() + public override bool HasModified() { - return m_HasChanged; + return !m_Discard && (base.HasModified() || m_ContentHash != GetInspectorHash()); } private void ValidateMasterAtlas() @@ -432,24 +482,27 @@ private void ValidateMasterAtlas() public override void OnInspectorGUI() { - if (spriteAtlasAsset == null) - return; - - EditorGUI.BeginChangeCheck(); - // Ensure changes done through script are reflected immediately in Inspector by Syncing m_TempPlatformSettings with Actual Settings. SyncPlatformSettings(); - serializedAssetObject.Update(); - - HandleCommonSettingUI(); + serializedObject.Update(); + if (spriteAtlasAsset) + { + serializedAssetObject.Update(); + HandleCommonSettingUI(); + } + EditorGUILayout.PropertyField(m_BindAsDefault, styles.bindAsDefaultLabel); GUILayout.Space(EditorGUI.kSpacing); - if (IsTargetVariant()) - HandleVariantSettingUI(); - else if (IsTargetMaster()) + bool isTargetMaster = true; + if (spriteAtlasAsset) + isTargetMaster = IsTargetMaster(); + + if (isTargetMaster) HandleMasterSettingUI(); + if (!spriteAtlasAsset || IsTargetVariant()) + HandleVariantSettingUI(); GUILayout.Space(EditorGUI.kSpacing); @@ -459,15 +512,16 @@ public override void OnInspectorGUI() // Only show the packable object list when: // - This is a master atlas. - if (targets.Length == 1 && IsTargetMaster()) + if (targets.Length == 1 && IsTargetMaster() && spriteAtlasAsset) HandlePackableListUI(); - serializedAssetObject.ApplyModifiedPropertiesWithoutUndo(); - - if (EditorGUI.EndChangeCheck()) + serializedObject.ApplyModifiedProperties(); + if (spriteAtlasAsset) { - m_HasChanged = true; + serializedAssetObject.ApplyModifiedProperties(); + PackPreviewGUI(); } + ApplyRevertGUI(); } @@ -491,7 +545,7 @@ private void HandleCommonSettingUI() // 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(); @@ -501,13 +555,10 @@ private void HandleCommonSettingUI() ValidateMasterAtlas(); // Apply modified properties here to have latest master atlas reflected in native codes. serializedAssetObject.ApplyModifiedPropertiesWithoutUndo(); - spriteAtlasAsset.CopyMasterAtlasSettings(); PopulatePlatformSettingsOptions(); SyncPlatformSettings(); } } - - EditorGUILayout.PropertyField(m_BindAsDefault, styles.bindAsDefaultLabel); } private void HandleVariantSettingUI() @@ -537,6 +588,7 @@ private void HandleMasterSettingUI() 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); @@ -574,7 +626,6 @@ private void HandleTextureSettingUI() m_SelectedPlatformSettings--; EditorGUI.FocusTextInControl(s_Styles.secondaryTextureNameTextControlName); } - m_HasChanged = true; SyncPlatformSettings(); } @@ -585,7 +636,7 @@ private void HandleTextureSettingUI() { EditorGUI.EndEditingActiveTextField(); - spriteAtlasAsset.DeleteSecondaryPlatformSettings(m_PlatformSettingsOptions[m_SelectedPlatformSettings]); + spriteAtlasImporter.DeleteSecondaryPlatformSettings(m_PlatformSettingsOptions[m_SelectedPlatformSettings]); m_PlatformSettingsOptions.RemoveAt(m_SelectedPlatformSettings); @@ -593,7 +644,6 @@ private void HandleTextureSettingUI() if (m_SelectedPlatformSettings == 1) m_SelectedPlatformSettings = 0; - m_HasChanged = true; SyncPlatformSettings(); } } @@ -608,11 +658,15 @@ private void HandleTextureSettingUI() 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); @@ -630,14 +684,13 @@ private void HandleTextureSettingUI() Debug.LogWarning(s_Styles.nameUniquenessWarning); EditorGUI.FocusTextInControl(s_Styles.secondaryTextureNameTextControlName); } - m_HasChanged = true; } string secondaryTextureName = m_PlatformSettingsOptions[m_SelectedPlatformSettings]; EditorGUI.BeginChangeCheck(); - bool value = EditorGUILayout.Toggle(s_Styles.sRGBLabel, spriteAtlasAsset.GetSecondaryColorSpace(secondaryTextureName)); + bool value = EditorGUILayout.Toggle(s_Styles.sRGBLabel, spriteAtlasImporter.GetSecondaryColorSpace(secondaryTextureName)); if (EditorGUI.EndChangeCheck()) - spriteAtlasAsset.SetSecondaryColorSpace(secondaryTextureName, value); + spriteAtlasImporter.SetSecondaryColorSpace(secondaryTextureName, value); HandlePlatformSettingUI(textFieldText); } @@ -655,16 +708,15 @@ private void HandlePlatformSettingUI(string secondaryTextureName) ITexturePlatformSettingsView view = isSecondary ? m_SecondaryTexturePlatformSettingsView : m_TexturePlatformSettingsView; if (shownTextureFormatPage == -1) { - if (m_TexturePlatformSettingsController.HandleDefaultSettings(defaultPlatformSettings, m_TexturePlatformSettingsView, m_TexturePlatformSettingTextureHelper)) + if (m_TexturePlatformSettingsController.HandleDefaultSettings(defaultPlatformSettings, view, m_TexturePlatformSettingTextureHelper)) { for (var i = 0; i < defaultPlatformSettings.Count; ++i) { if (isSecondary) - spriteAtlasAsset.SetSecondaryPlatformSettings(defaultPlatformSettings[i], secondaryTextureName); + spriteAtlasImporter.SetSecondaryPlatformSettings(defaultPlatformSettings[i], secondaryTextureName); else - spriteAtlasAsset.SetPlatformSettings(defaultPlatformSettings[i]); + spriteAtlasImporter.SetPlatformSettings(defaultPlatformSettings[i]); } - m_HasChanged = true; } } else @@ -680,7 +732,7 @@ private void HandlePlatformSettingUI(string secondaryTextureName) { if (defaultPlatformSettings[0].format == TextureImporterFormat.Automatic) { - settings.format = (TextureImporterFormat)spriteAtlasAsset.GetTextureFormat(buildPlatform.defaultTarget); + settings.format = (TextureImporterFormat)spriteAtlasImporter.GetTextureFormat(buildPlatform.defaultTarget); } else { @@ -694,16 +746,15 @@ private void HandlePlatformSettingUI(string secondaryTextureName) } m_TexturePlatformSettingsView.buildPlatformTitle = buildPlatform.title.text; - if (m_TexturePlatformSettingsController.HandlePlatformSettings(buildPlatform.defaultTarget, platformSettings, m_TexturePlatformSettingsView, m_TexturePlatformSettingTextureHelper)) + if (m_TexturePlatformSettingsController.HandlePlatformSettings(buildPlatform.defaultTarget, platformSettings, view, m_TexturePlatformSettingTextureHelper)) { for (var i = 0; i < platformSettings.Count; ++i) { if (isSecondary) - spriteAtlasAsset.SetSecondaryPlatformSettings(platformSettings[i], secondaryTextureName); + spriteAtlasImporter.SetSecondaryPlatformSettings(platformSettings[i], secondaryTextureName); else - spriteAtlasAsset.SetPlatformSettings(platformSettings[i]); + spriteAtlasImporter.SetPlatformSettings(platformSettings[i]); } - m_HasChanged = true; } } @@ -788,6 +839,20 @@ private void HandlePackableListUI() } } + 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); @@ -814,24 +879,10 @@ void CachePreviewTexture() m_OptionValues = new int[m_TotalPages]; for (int i = 0; i < m_TotalPages; ++i) { - // Example texName: - // pageNum secondaryName - // V | V | - // sactx-2-128x128-Uncompressed-My Sprite Atlas-0fe925a#_Glow-var-0.5... string texName = m_PreviewTextures[i].name; - string pageNum = texName.Split('-')[1]; - int hashTag = texName.IndexOf('#'); - int dashAfterHashTag = hashTag != -1 ? texName.IndexOf('-', hashTag) : -1; - - string secondaryName; - if (hashTag == -1) - secondaryName = ""; - else if (dashAfterHashTag == -1) - secondaryName = "-" + texName.Substring(hashTag + 1); - else - secondaryName = "-" + texName.Substring(hashTag + 1, dashAfterHashTag - hashTag - 1); - - m_OptionDisplays[i] = string.Format("#{0}{1}", pageNum, secondaryName); + 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; } } @@ -878,7 +929,7 @@ public override void OnPreviewSettings() if (t == null) return; - if (TextureUtil.HasAlphaTextureFormat(t.format) || (m_PreviewAlphaTextures != null && m_PreviewAlphaTextures.Length > 0)) + 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)); diff --git a/Editor/Mono/2D/SpriteAtlas/SpriteAtlasInspector.cs b/Editor/Mono/2D/SpriteAtlas/SpriteAtlasInspector.cs index 2d9dcf1e96..cebb1e79ff 100644 --- a/Editor/Mono/2D/SpriteAtlas/SpriteAtlasInspector.cs +++ b/Editor/Mono/2D/SpriteAtlas/SpriteAtlasInspector.cs @@ -53,11 +53,12 @@ class Styles 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 Enabled", "Enable to be able to access the raw pixel data from code."); + 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."); @@ -77,6 +78,7 @@ class Styles 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."); @@ -118,6 +120,7 @@ private enum AtlasType { Undefined = -1, Master = 0, Variant = 1 } 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; @@ -191,6 +194,17 @@ bool AllTargetsAreMaster() 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"); @@ -198,6 +212,7 @@ void OnEnable() 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"); @@ -208,12 +223,13 @@ void OnEnable() PopulatePlatformSettingsOptions(); m_Packables = serializedObject.FindProperty("m_EditorData.packables"); - m_PackableList = new ReorderableList(serializedObject, m_Packables, true, false, true, true); + 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; + m_PackableList.headerHeight = 3f + EditorGUIUtility.singleLineHeight; SyncPlatformSettings(); @@ -301,6 +317,11 @@ void RenameSecondaryPlatformSettings(string oldName, string newName) } } + void DrawPackablesHeader(Rect headerRect) + { + EditorGUI.LabelField(headerRect, EditorGUIUtility.TempContent("Packables")); + } + void AddPackable(ReorderableList list) { ObjectSelector.get.Show(null, typeof(Object), null, false); @@ -326,6 +347,7 @@ void DrawPackableElement(Rect rect, int index, bool selected, bool focused) { // 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; @@ -363,22 +385,25 @@ public override void OnInspectorGUI() if (targets.Length == 1 && AllTargetsAreMaster()) HandlePackableListUI(); - bool spriteAtlasPackignEnabled = (EditorSettings.spritePackerMode == SpritePackerMode.BuildTimeOnlyAtlas + bool spriteAtlasPackingEnabled = (EditorSettings.spritePackerMode == SpritePackerMode.BuildTimeOnlyAtlas || EditorSettings.spritePackerMode == SpritePackerMode.AlwaysOnAtlas || EditorSettings.spritePackerMode == SpritePackerMode.SpriteAtlasV2); - if (spriteAtlasPackignEnabled) + if (spriteAtlasPackingEnabled && !Application.isPlaying) { - if (GUILayout.Button(styles.packButton, GUILayout.ExpandWidth(false))) + using (new EditorGUI.DisabledScope(!Editor.IsPersistent(spriteAtlas))) { - SpriteAtlas[] spriteAtlases = new SpriteAtlas[targets.Length]; - for (int i = 0; i < spriteAtlases.Length; ++i) - spriteAtlases[i] = (SpriteAtlas)targets[i]; + 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); + SpriteAtlasUtility.PackAtlases(spriteAtlases, EditorUserBuildSettings.activeBuildTarget); - // Packing an atlas might change platform settings in the process, reinitialize - SyncPlatformSettings(); + // Packing an atlas might change platform settings in the process, reinitialize + SyncPlatformSettings(); - GUIUtility.ExitGUI(); + GUIUtility.ExitGUI(); + } } } else @@ -402,7 +427,10 @@ private void HandleCommonSettingUI() EditorGUI.BeginChangeCheck(); EditorGUI.showMixedValue = atlasType == AtlasType.Undefined; - atlasType = (AtlasType)EditorGUILayout.IntPopup(styles.atlasTypeLabel, (int)atlasType, styles.atlasTypeOptions, styles.atlasTypeValues); + 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()) { @@ -461,6 +489,7 @@ private void HandleMasterSettingUI() 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); @@ -532,11 +561,15 @@ private void HandleTextureSettingUI() 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); @@ -732,24 +765,10 @@ void CachePreviewTexture() m_OptionValues = new int[m_TotalPages]; for (int i = 0; i < m_TotalPages; ++i) { - // Example texName: - // pageNum secondaryName - // V | V | - // sactx-2-128x128-Uncompressed-My Sprite Atlas-0fe925a#_Glow-var-0.5... string texName = m_PreviewTextures[i].name; - string pageNum = texName.Split('-')[1]; - int hashTag = texName.IndexOf('#'); - int dashAfterHashTag = hashTag != -1 ? texName.IndexOf('-', hashTag) : -1; - - string secondaryName; - if (hashTag == -1) - secondaryName = ""; - else if (dashAfterHashTag == -1) - secondaryName = "-" + texName.Substring(hashTag + 1); - else - secondaryName = "-" + texName.Substring(hashTag + 1, dashAfterHashTag - hashTag - 1); - - m_OptionDisplays[i] = string.Format("#{0}{1}", pageNum, secondaryName); + 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; } } @@ -788,7 +807,7 @@ public override void OnPreviewSettings() Texture2D t = m_PreviewTextures[m_PreviewPage]; - if (TextureUtil.HasAlphaTextureFormat(t.format) || (m_PreviewAlphaTextures != null && m_PreviewAlphaTextures.Length > 0)) + 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)); diff --git a/Editor/Mono/Animation/AnimationUtility.bindings.cs b/Editor/Mono/Animation/AnimationUtility.bindings.cs index f3996af8d1..0b40f052e6 100644 --- a/Editor/Mono/Animation/AnimationUtility.bindings.cs +++ b/Editor/Mono/Animation/AnimationUtility.bindings.cs @@ -4,6 +4,7 @@ using System; using System.Collections.Generic; +using System.Linq; using UnityEngine.Bindings; using UnityEngine.Scripting; using UnityEngine.Scripting.APIUpdating; @@ -11,6 +12,7 @@ using UnityEngine.Internal; using Object = UnityEngine.Object; +using UnityEngine.Animations; namespace UnityEditor { @@ -52,6 +54,7 @@ public AnimationClipCurveData(EditorCurveBinding binding) } [NativeHeader("Editor/Src/Animation/AnimationUtility.bindings.h")] + [NativeHeader("Modules/Animation/ScriptBindings/GenericBinding.bindings.h")] public partial class AnimationUtility { public enum CurveModifiedType @@ -78,6 +81,15 @@ internal enum PolynomialValid 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; @@ -118,7 +130,12 @@ public static AnimationClip[] GetAnimationClips(GameObject gameObject) var extraClips = new List(); clipSources[i].GetAnimationClips(extraClips); - allClips.AddRange(extraClips); + allClips.Capacity = allClips.Count + extraClips.Count; + foreach (var clip in extraClips) + { + if (clip != null) + allClips.Add(clip); + } } return allClips.ToArray(); @@ -131,7 +148,7 @@ public static AnimationClip[] GetAnimationClips(GameObject gameObject) 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, AnimationClip[] clips); + extern public static void SetAnimationClips([NotNull] Animation animation, [Unmarshalled] AnimationClip[] clips); public static EditorCurveBinding[] GetAnimatableBindings(GameObject targetObject, GameObject root) { @@ -168,13 +185,14 @@ internal static System.Type GetEditorCurveValueType(ScriptableObject scriptableO 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); - return data != null; + data = Internal_GetObjectReferenceValue(root, binding, out bool result); + return result; } - extern private static Object Internal_GetObjectReferenceValue([NotNull] GameObject root, EditorCurveBinding binding); + extern private static Object Internal_GetObjectReferenceValue([NotNull] GameObject root, EditorCurveBinding binding, out bool result); extern public static Object GetAnimatedObject([NotNull] GameObject root, EditorCurveBinding binding); @@ -197,7 +215,7 @@ public static Type PropertyModificationToEditorCurveBinding(PropertyModification extern public static ObjectReferenceKeyframe[] GetObjectReferenceCurve([NotNull] AnimationClip clip, EditorCurveBinding binding); - public static void SetObjectReferenceCurve(AnimationClip clip, EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes) + 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); @@ -228,7 +246,7 @@ internal static void SetObjectReferenceCurveNoSync(AnimationClip clip, EditorCur } [NativeThrows] - extern private static void Internal_SetObjectReferenceCurve([NotNull] AnimationClip clip, EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes, bool updateMuscleClip); + 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); @@ -266,6 +284,8 @@ internal static void SetEditorCurveNoSync(AnimationClip clip, EditorCurveBinding [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) @@ -382,12 +402,29 @@ public static AnimationCurve GetEditorCurve(AnimationClip clip, string relativeP return GetEditorCurve(clip, EditorCurveBinding.FloatCurve(relativePath, type, propertyName)); } - extern public static AnimationEvent[] GetAnimationEvents([NotNull] AnimationClip clip); - [NativeThrows] extern public static void SetAnimationEvents([NotNull] AnimationClip clip, [NotNull] AnimationEvent[] events); + 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); @@ -452,5 +489,8 @@ public static void StopAnimationMode() [Obsolete("SetAnimationType is no longer supported.")] public static void SetAnimationType(AnimationClip clip, ModelImporterAnimationType type) {} + + + extern public static GenericBinding[] EditorCurveBindingsToGenericBindings(EditorCurveBinding[] editorCurveBindings); } } diff --git a/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchy.cs b/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchy.cs index 4adb9ff208..cd32c12f4d 100644 --- a/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchy.cs +++ b/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchy.cs @@ -5,6 +5,9 @@ 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 { diff --git a/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchyBuilder.cs b/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchyBuilder.cs new file mode 100644 index 0000000000..51618a0dbd --- /dev/null +++ b/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchyBuilder.cs @@ -0,0 +1,318 @@ +// 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); + } + } +} diff --git a/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchyDataSource.cs b/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchyDataSource.cs index 738cf9fe1f..cb9654a3ff 100644 --- a/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchyDataSource.cs +++ b/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchyDataSource.cs @@ -2,20 +2,15 @@ // 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 TreeViewController = UnityEditor.IMGUI.Controls.TreeViewController; +using TreeViewDataSource = UnityEditor.IMGUI.Controls.TreeViewDataSource; namespace UnityEditorInternal { - internal class AddCurvesPopupHierarchyDataSource : TreeViewDataSource + class AddCurvesPopupHierarchyDataSource : TreeViewDataSource { - public static bool showEntireHierarchy { get; set; } - public AddCurvesPopupHierarchyDataSource(TreeViewController treeView) : base(treeView) { @@ -34,196 +29,29 @@ public override void FetchData() m_RootItem = null; if (AddCurvesPopup.s_State.selection.canAddCurves) { - GameObject rootGameObject = AddCurvesPopup.s_State.activeRootGameObject; - ScriptableObject scriptableObject = AddCurvesPopup.s_State.activeScriptableObject; - - if (rootGameObject != null) - { - AddGameObjectToHierarchy(rootGameObject, rootGameObject, AddCurvesPopup.s_State.activeAnimationClip, m_RootItem); - } - else if (scriptableObject != null) - { - AddScriptableObjectToHierarchy(scriptableObject, AddCurvesPopup.s_State.activeAnimationClip, m_RootItem); - } + var state = AddCurvesPopup.s_State; + AddBindingsToHierarchy(state.controlInterface.GetAnimatableBindings()); } SetupRootNodeSettings(); m_NeedRefreshRows = true; } - private TreeViewItem AddGameObjectToHierarchy(GameObject gameObject, GameObject rootGameObject, AnimationClip animationClip, TreeViewItem parent) - { - string path = AnimationUtility.CalculateTransformPath(gameObject.transform, rootGameObject.transform); - AddCurvesPopupGameObjectNode node = new AddCurvesPopupGameObjectNode(gameObject, parent, gameObject.name); - List childNodes = new List(); - - if (m_RootItem == null) - m_RootItem = node; - - // Iterate over all animatable objects - EditorCurveBinding[] allCurveBindings = AnimationUtility.GetAnimatableBindings(gameObject, rootGameObject); - List singleObjectBindings = new List(); - for (int i = 0; i < allCurveBindings.Length; i++) - { - EditorCurveBinding curveBinding = allCurveBindings[i]; - - singleObjectBindings.Add(curveBinding); - - // Don't create group for GameObject.m_IsActive. It looks messy - if (curveBinding.propertyName == "m_IsActive") - { - // Don't show for the root go - if (curveBinding.path != "") - { - TreeViewItem newNode = CreateNode(singleObjectBindings.ToArray(), node); - if (newNode != null) - childNodes.Add(newNode); - singleObjectBindings.Clear(); - } - else - { - singleObjectBindings.Clear(); - } - } - else - { - // We expect allCurveBindings to come sorted by type - - bool isLastItemOverall = (i == allCurveBindings.Length - 1); - bool isLastItemOnThisGroup = false; - - if (!isLastItemOverall) - isLastItemOnThisGroup = (allCurveBindings[i + 1].type != curveBinding.type); - - // Let's not add those that already have a existing curve. - if (AnimationWindowUtility.IsCurveCreated(animationClip, curveBinding)) - singleObjectBindings.Remove(curveBinding); - - // Remove animator enabled property which shouldn't be animated. - if (curveBinding.type == typeof(Animator) && curveBinding.propertyName == "m_Enabled") - singleObjectBindings.Remove(curveBinding); - - if ((isLastItemOverall || isLastItemOnThisGroup) && singleObjectBindings.Count > 0) - { - childNodes.Add(AddAnimatableObjectToHierarchy(singleObjectBindings.ToArray(), node, path)); - singleObjectBindings.Clear(); - } - } - } - - var animator = rootGameObject.GetComponent(); - if (animator != null) - { - //If the Animator has a human avatar, we need to check if the avatar's hierarchy matches that of the current GameObject. If they do not match, disable the node. - if (animator.avatarRoot != null && animator.isHuman) - { - if (animator.avatarRoot.Find(path) == null) - { - node.propertyPathMismatchWithHumanAvatar = true; - } - } - } - - - if (showEntireHierarchy) - { - // Iterate over all child GOs - for (int i = 0; i < gameObject.transform.childCount; i++) - { - Transform childTransform = gameObject.transform.GetChild(i); - TreeViewItem childNode = AddGameObjectToHierarchy(childTransform.gameObject, rootGameObject, animationClip, node); - if (childNode != null) - childNodes.Add(childNode); - } - } - - TreeViewUtility.SetChildParentReferences(childNodes, node); - return node; - } - - private TreeViewItem AddScriptableObjectToHierarchy(ScriptableObject scriptableObject, AnimationClip clip, TreeViewItem parent) - { - EditorCurveBinding[] allCurveBindings = AnimationUtility.GetAnimatableBindings(scriptableObject); - EditorCurveBinding[] availableBindings = allCurveBindings.Where(c => !AnimationWindowUtility.IsCurveCreated(clip, c)).ToArray(); - - TreeViewItem node = null; - if (availableBindings.Length > 0) - node = AddAnimatableObjectToHierarchy(availableBindings, parent, ""); - else - node = new AddCurvesPopupObjectNode(parent, "", scriptableObject.name); - - if (m_RootItem == null) - m_RootItem = node; - - return node; - } - - static string GetClassName(EditorCurveBinding binding) - { - if (AddCurvesPopup.s_State.activeRootGameObject != null) - { - Object target = AnimationUtility.GetAnimatedObject(AddCurvesPopup.s_State.activeRootGameObject, binding); - if (target) - return ObjectNames.GetInspectorTitle(target); - } - - return binding.type.Name; - } - - static Texture2D GetIcon(EditorCurveBinding binding) + private void AddBindingsToHierarchy(EditorCurveBinding[] bindings) { - if (AddCurvesPopup.s_State.activeRootGameObject != null) + if (bindings == null || bindings.Length == 0) { - return AssetPreview.GetMiniThumbnail(AnimationUtility.GetAnimatedObject(AddCurvesPopup.s_State.activeRootGameObject, binding)); - } - else if (AddCurvesPopup.s_State.activeScriptableObject != null) - { - return AssetPreview.GetMiniThumbnail(AddCurvesPopup.s_State.activeScriptableObject); + m_RootItem = new AddCurvesPopupObjectNode(null, "", ""); + return; } - return null; - } - - private TreeViewItem AddAnimatableObjectToHierarchy(EditorCurveBinding[] 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(); - - for (int i = 0; i < curveBindings.Length; i++) + var builder = new AddCurvesPopupHierarchyBuilder(AddCurvesPopup.s_State); + for (int i = 0; i < bindings.Length; i++) { - EditorCurveBinding curveBinding = curveBindings[i]; - - singlePropertyBindings.Add(curveBinding); - - // We expect curveBindings to come sorted by propertyname - if (i == curveBindings.Length - 1 || AnimationWindowUtility.GetPropertyGroupName(curveBindings[i + 1].propertyName) != AnimationWindowUtility.GetPropertyGroupName(curveBinding.propertyName)) - { - TreeViewItem newNode = CreateNode(singlePropertyBindings.ToArray(), node); - if (newNode != null) - childNodes.Add(newNode); - singlePropertyBindings.Clear(); - } + builder.Add(bindings[i]); } - childNodes.Sort(); - - TreeViewUtility.SetChildParentReferences(childNodes, node); - return node; - } - - private TreeViewItem CreateNode(EditorCurveBinding[] curveBindings, TreeViewItem parentNode) - { - var node = new AddCurvesPopupPropertyNode(parentNode, curveBindings); - - // For RectTransform.position we only want .z - if (AnimationWindowUtility.IsRectTransformPosition(node.curveBindings[0])) - node.curveBindings = new EditorCurveBinding[] {node.curveBindings[2]}; - - node.icon = parentNode.icon; - return node; + m_RootItem = builder.CreateTreeView(); } public void UpdateData() @@ -231,45 +59,4 @@ public void UpdateData() m_TreeView.ReloadData(); } } - - internal class AddCurvesPopupGameObjectNode : TreeViewItem - { - internal bool propertyPathMismatchWithHumanAvatar = false; - public AddCurvesPopupGameObjectNode(GameObject gameObject, TreeViewItem parent, string displayName) - : base(gameObject.GetInstanceID(), parent != null ? parent.depth + 1 : -1, parent, displayName) - { - } - } - - internal class AddCurvesPopupObjectNode : TreeViewItem - { - public AddCurvesPopupObjectNode(TreeViewItem parent, string path, string className) - : base((path + className).GetHashCode(), parent != null ? parent.depth + 1 : -1, parent, className) - { - } - } - - internal class AddCurvesPopupPropertyNode : TreeViewItem - { - public EditorCurveBinding[] curveBindings; - - public AddCurvesPopupPropertyNode(TreeViewItem parent, EditorCurveBinding[] curveBindings) - : base(curveBindings[0].GetHashCode(), parent.depth + 1, parent, AnimationWindowUtility.NicifyPropertyGroupName(curveBindings[0].type, AnimationWindowUtility.GetPropertyGroupName(curveBindings[0].propertyName))) - { - 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); - } - } } diff --git a/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchyGUI.cs b/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchyGUI.cs index 33897a16b6..bd964f16b6 100644 --- a/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchyGUI.cs +++ b/Editor/Mono/Animation/AnimationWindow/AddCurvesPopupHierarchyGUI.cs @@ -7,6 +7,9 @@ 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 { @@ -20,38 +23,17 @@ internal class AddCurvesPopupHierarchyGUI : TreeViewGUI private GUIContent addPropertiesContent = EditorGUIUtility.TrTextContent("Add Properties"); private const float plusButtonWidth = 17; - static Texture2D warningIcon = (Texture2D)EditorGUIUtility.LoadRequired("Icons/ShortcutManager/alertDialog.png"); - public static GUIStyle warningIconStyle; - public AddCurvesPopupHierarchyGUI(TreeViewController treeView, EditorWindow owner) : base(treeView, true) { this.owner = owner; - warningIconStyle = new GUIStyle(); - warningIconStyle.margin = new RectOffset(15, 15, 15, 15); } public override void OnRowGUI(Rect rowRect, TreeViewItem node, int row, bool selected, bool focused) { - bool propertyPathMismatchWithHumanAvatar = false; - AddCurvesPopupGameObjectNode addCurvesPopupNode = node as AddCurvesPopupGameObjectNode; - if (addCurvesPopupNode != null) - { - propertyPathMismatchWithHumanAvatar = addCurvesPopupNode.propertyPathMismatchWithHumanAvatar; - } - - using (new EditorGUI.DisabledScope(propertyPathMismatchWithHumanAvatar)) - { - base.OnRowGUI(rowRect, node, row, selected, focused); - DoAddCurveButton(rowRect, node); - HandleContextMenu(rowRect, node); - } - - if (propertyPathMismatchWithHumanAvatar) - { - Rect iconRect = new Rect(rowRect.width - plusButtonWidth, rowRect.yMin, plusButtonWidth, buttonStyle.fixedHeight); - GUI.Label(iconRect, new GUIContent(warningIcon, "The Avatar definition does not match the property path. Please author using a hierarchy the Avatar was built with."), warningIconStyle); - } + base.OnRowGUI(rowRect, node, row, selected, focused); + DoAddCurveButton(rowRect, node); + HandleContextMenu(rowRect, node); } private void DoAddCurveButton(Rect rowRect, TreeViewItem node) diff --git a/Editor/Mono/Animation/AnimationWindow/AnimEditor.cs b/Editor/Mono/Animation/AnimationWindow/AnimEditor.cs index d716dabb7f..7aa757d3d1 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimEditor.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimEditor.cs @@ -4,12 +4,9 @@ using System; using UnityEngine; -using UnityEditor; -using System.Collections; using System.Collections.Generic; using UnityEditor.ShortcutManagement; using UnityEditorInternal; -using Object = UnityEngine.Object; namespace UnityEditor { @@ -22,7 +19,8 @@ internal enum WrapModeFixed PingPong = (int)WrapMode.PingPong } - internal class AnimEditor : ScriptableObject + [Serializable] + class AnimEditor : ScriptableObject { // Active Animation windows private static List s_AnimationWindows = new List(); @@ -30,12 +28,12 @@ internal class AnimEditor : ScriptableObject public bool stateDisabled { get { return m_State.disabled; } } [SerializeField] private SplitterState m_HorizontalSplitter; - [SerializeField] private AnimationWindowState m_State; - [SerializeField] private DopeSheetEditor m_DopeSheet; + [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 CurveEditor m_CurveEditor; [SerializeField] private AnimEditorOverlay m_Overlay; [SerializeField] private EditorWindow m_OwnerWindow; @@ -141,7 +139,7 @@ public AnimationWindowSelectionItem selection } } - public IAnimationWindowControl controlInterface + public IAnimationWindowController controlInterface { get { @@ -149,7 +147,7 @@ public IAnimationWindowControl controlInterface } } - public IAnimationWindowControl overrideControlInterface + public IAnimationWindowController overrideControlInterface { get { @@ -189,8 +187,8 @@ public void OnAnimEditorGUI(EditorWindow parent, Rect position) m_State.OnGUI(); - if (m_State.disabled && controlInterface.recording) - m_State.StopRecording(); + if (m_State.disabled && m_State.recording) + m_State.recording = false; SynchronizeLayout(); @@ -362,14 +360,13 @@ public void Update() public void OnEnable() { - hideFlags = HideFlags.HideAndDontSave; s_AnimationWindows.Add(this); if (m_State == null) { - m_State = CreateInstance(typeof(AnimationWindowState)) as AnimationWindowState; - m_State.hideFlags = HideFlags.HideAndDontSave; + m_State = new AnimationWindowState(); m_State.animEditor = this; + InitializeHorizontalSplitter(); InitializeClipSelection(); InitializeDopeSheet(); @@ -385,6 +382,8 @@ public void OnEnable() m_ClipPopup.state = m_State; m_Overlay.state = m_State; + m_State.OnEnable(); + m_CurveEditor.curvesUpdated += SaveChangedCurvesFromCurveEditor; m_CurveEditor.OnEnable(); } @@ -399,18 +398,14 @@ public void OnDisable() m_CurveEditor.OnDisable(); } - if (m_DopeSheet != null) - m_DopeSheet.OnDisable(); - + m_DopeSheet?.OnDisable(); m_State.OnDisable(); } public void OnDestroy() { - if (m_CurveEditor != null) - m_CurveEditor.OnDestroy(); - - DestroyImmediate(m_State); + m_CurveEditor?.OnDestroy(); + m_State?.OnDestroy(); } public void OnSelectionChanged() @@ -433,7 +428,7 @@ public void OnStartLiveEdit() public void OnEndLiveEdit() { UpdateSelectedKeysToCurveEditor(); - controlInterface.ResampleAnimation(); + m_State.ResampleAnimation(); } public void OnLostFocus() @@ -448,10 +443,10 @@ public void OnLostFocus() private void PlaybackUpdate() { - if (m_State.disabled && controlInterface.playing) - controlInterface.StopPlayback(); + if (m_State.disabled && m_State.playing) + m_State.playing = false; - if (controlInterface.PlaybackUpdate()) + if (m_State.PlaybackUpdate()) Repaint(); } @@ -777,7 +772,7 @@ private void AddEventButtonOnGUI() private void AddKeyframeButtonOnGUI() { - bool canAddKey = selection.animationIsEditable && m_State.allCurves.Count != 0; + bool canAddKey = selection.animationIsEditable && m_State.filteredCurves.Count != 0; using (new EditorGUI.DisabledScope(!canAddKey)) { if (GUILayout.Button(AnimationWindowStyles.addKeyframeContent, AnimationWindowStyles.animClipToolbarButton)) @@ -795,19 +790,19 @@ private void AddKeyframeButtonOnGUI() private void PlayControlsOnGUI() { - using (new EditorGUI.DisabledScope(!controlInterface.canPreview)) + using (new EditorGUI.DisabledScope(!m_State.canPreview)) { PreviewButtonOnGUI(); } - using (new EditorGUI.DisabledScope(!controlInterface.canRecord)) + using (new EditorGUI.DisabledScope(!m_State.canRecord)) { RecordButtonOnGUI(); } if (GUILayout.Button(AnimationWindowStyles.firstKeyContent, EditorStyles.toolbarButton)) { - controlInterface.GoToFirstKeyframe(); + state.GoToFirstKeyframe(); // Stop text editing. User may be editing frame navigation ui which will not update until we exit text editing. EditorGUI.EndEditingActiveTextField(); @@ -815,20 +810,20 @@ private void PlayControlsOnGUI() if (GUILayout.Button(AnimationWindowStyles.prevKeyContent, EditorStyles.toolbarButton)) { - controlInterface.GoToPreviousKeyframe(); + 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(!controlInterface.canPlay)) + using (new EditorGUI.DisabledScope(!m_State.canPlay)) { PlayButtonOnGUI(); } if (GUILayout.Button(AnimationWindowStyles.nextKeyContent, EditorStyles.toolbarButton)) { - controlInterface.GoToNextKeyframe(); + state.GoToNextKeyframe(); // Stop text editing. User may be editing frame navigation ui which will not update until we exit text editing. EditorGUI.EndEditingActiveTextField(); @@ -836,7 +831,7 @@ private void PlayControlsOnGUI() if (GUILayout.Button(AnimationWindowStyles.lastKeyContent, EditorStyles.toolbarButton)) { - controlInterface.GoToLastKeyframe(); + state.GoToLastKeyframe(); // Stop text editing. User may be editing frame navigation ui which will not update until we exit text editing. EditorGUI.EndEditingActiveTextField(); @@ -848,7 +843,7 @@ private void PlayControlsOnGUI() int newFrame = EditorGUILayout.DelayedIntField(m_State.currentFrame, EditorStyles.toolbarTextField, GUILayout.Width(kIntFieldWidth)); if (EditorGUI.EndChangeCheck()) { - controlInterface.GoToFrame(newFrame); + state.currentFrame = newFrame; } } @@ -860,6 +855,7 @@ private void LinkOptionsOnGUI() { m_State.linkedWithSequencer = false; m_State.selection = null; + m_State.overrideControlInterface = null; // Layout has changed, bail out now. EditorGUIUtility.ExitGUI(); @@ -883,9 +879,9 @@ static void ExecuteShortcut(ShortcutArguments args, Action exp) animEditor.Repaint(); } - static void ExecuteShortcut(ShortcutArguments args, Action exp) + static void ExecuteShortcut(ShortcutArguments args, Action exp) { - ExecuteShortcut(args, animEditor => exp(animEditor.controlInterface)); + ExecuteShortcut(args, animEditor => exp(animEditor.state)); } [FormerlyPrefKeyAs("Animation/Show Curves", "c")] @@ -899,12 +895,9 @@ static void ShowCurves(ShortcutArguments args) [Shortcut("Animation/Play Animation", typeof(AnimationWindow), KeyCode.Space)] static void TogglePlayAnimation(ShortcutArguments args) { - ExecuteShortcut(args, controlInterface => + ExecuteShortcut(args, state => { - if (controlInterface.playing) - controlInterface.StopPlayback(); - else - controlInterface.StartPlayback(); + state.playing = !state.playing; }); } @@ -912,42 +905,42 @@ static void TogglePlayAnimation(ShortcutArguments args) [Shortcut("Animation/Next Frame", typeof(AnimationWindow), KeyCode.Period)] static void NextFrame(ShortcutArguments args) { - ExecuteShortcut(args, controlInterface => controlInterface.GoToNextFrame()); + ExecuteShortcut(args, state => state.GoToNextFrame()); } [FormerlyPrefKeyAs("Animation/Previous Frame", ",")] [Shortcut("Animation/Previous Frame", typeof(AnimationWindow), KeyCode.Comma)] static void PreviousFrame(ShortcutArguments args) { - ExecuteShortcut(args, controlInterface => controlInterface.GoToPreviousFrame()); + 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, controlInterface => controlInterface.GoToPreviousKeyframe()); + 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, controlInterface => controlInterface.GoToNextKeyframe()); + 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, controlInterface => controlInterface.GoToFirstKeyframe()); + 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, controlInterface => controlInterface.GoToLastKeyframe()); + ExecuteShortcut(args, state => state.GoToLastKeyframe()); } [FormerlyPrefKeyAs("Animation/Key Selected", "k")] @@ -961,8 +954,8 @@ static void KeySelected(ShortcutArguments args) var animEditor = animationWindow.animEditor; animEditor.SaveCurveEditorKeySelection(); - AnimationWindowUtility.AddSelectedKeyframes(animEditor.m_State, animEditor.controlInterface.time); - animEditor.controlInterface.ClearCandidates(); + AnimationWindowUtility.AddSelectedKeyframes(animEditor.m_State, AnimationKeyTime.Frame(animEditor.state.currentFrame, animEditor.state.frameRate)); + animEditor.state.ClearCandidates(); animEditor.UpdateSelectedKeysToCurveEditor(); animEditor.Repaint(); @@ -979,7 +972,7 @@ static void KeyModified(ShortcutArguments args) var animEditor = animationWindow.animEditor; animEditor.SaveCurveEditorKeySelection(); - animEditor.controlInterface.ProcessCandidates(); + animEditor.state.ProcessCandidates(); animEditor.UpdateSelectedKeysToCurveEditor(); animEditor.Repaint(); @@ -1006,13 +999,10 @@ static void FrameAll(ShortcutArguments args) private void PlayButtonOnGUI() { EditorGUI.BeginChangeCheck(); - bool playbackEnabled = GUILayout.Toggle(controlInterface.playing, AnimationWindowStyles.playContent, EditorStyles.toolbarButton); + bool playbackEnabled = GUILayout.Toggle(m_State.playing, AnimationWindowStyles.playContent, EditorStyles.toolbarButton); if (EditorGUI.EndChangeCheck()) { - if (playbackEnabled) - controlInterface.StartPlayback(); - else - controlInterface.StopPlayback(); + 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(); @@ -1023,13 +1013,10 @@ private void PreviewButtonOnGUI() { EditorGUI.BeginChangeCheck(); - bool recordingEnabled = GUILayout.Toggle(controlInterface.previewing, AnimationWindowStyles.previewContent, EditorStyles.toolbarButton); + bool recordingEnabled = GUILayout.Toggle(m_State.previewing, AnimationWindowStyles.previewContent, EditorStyles.toolbarButton); if (EditorGUI.EndChangeCheck()) { - if (recordingEnabled) - m_State.StartPreview(); - else - m_State.StopPreview(); + m_State.previewing = recordingEnabled; } } @@ -1038,22 +1025,20 @@ private void RecordButtonOnGUI() EditorGUI.BeginChangeCheck(); Color backupColor = GUI.color; - if (controlInterface.recording) + if (m_State.recording) { Color recordedColor = AnimationMode.recordedPropertyColor; recordedColor.a *= GUI.color.a; GUI.color = recordedColor; } - bool recordingEnabled = GUILayout.Toggle(controlInterface.recording, AnimationWindowStyles.recordContent, EditorStyles.toolbarButton); + bool recordingEnabled = GUILayout.Toggle(m_State.recording, AnimationWindowStyles.recordContent, EditorStyles.toolbarButton); if (EditorGUI.EndChangeCheck()) { - if (recordingEnabled) - m_State.StartRecording(); - else - { - m_State.StopRecording(); + m_State.recording = recordingEnabled; + if (!recordingEnabled) + { // Force refresh in inspector as stopping recording does not invalidate any data. InspectorWindow.RepaintAllInspectors(); } @@ -1122,9 +1107,9 @@ private void RenderInRangeOverlay(Rect rect) { Color color = inRangeColor; - if (controlInterface.recording) + if (m_State.recording) color *= AnimationMode.recordedPropertyColor; - else if (controlInterface.previewing) + else if (m_State.previewing) color *= AnimationMode.animatedPropertyColor; else color = Color.clear; @@ -1137,9 +1122,9 @@ private void RenderOutOfRangeOverlay(Rect rect) { Color color = outOfRangeColor; - if (controlInterface.recording) + if (m_State.recording) color *= AnimationMode.recordedPropertyColor; - else if (controlInterface.previewing) + else if (m_State.previewing) color *= AnimationMode.animatedPropertyColor; Vector2 timeRange = m_State.timeRange; @@ -1148,7 +1133,7 @@ private void RenderOutOfRangeOverlay(Rect rect) private void SynchronizeLayout() { - m_HorizontalSplitter.realSizes[1] = (int)Mathf.Min(m_Position.width - m_HorizontalSplitter.realSizes[0], m_HorizontalSplitter.realSizes[1]); + 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) @@ -1224,7 +1209,7 @@ private void UpdateSelectedKeysFromCurveEditor() m_State.ClearKeySelections(); foreach (CurveSelection curveSelection in m_CurveEditor.selectedCurves) { - AnimationWindowKeyframe keyFrame = AnimationWindowUtility.CurveSelectionToAnimationWindowKeyframe(curveSelection, m_State.allCurves); + AnimationWindowKeyframe keyFrame = AnimationWindowUtility.CurveSelectionToAnimationWindowKeyframe(curveSelection, m_State.filteredCurves); if (keyFrame != null) m_State.SelectKey(keyFrame); } @@ -1272,9 +1257,6 @@ public void EndKeyModification() void HandleMainAreaCopyPaste(int controlID) { - if (GUIUtility.keyboardControl != controlID) - return; - var evt = Event.current; var type = evt.GetTypeForControl(controlID); if (type != EventType.ValidateCommand && type != EventType.ExecuteCommand) @@ -1282,6 +1264,11 @@ void HandleMainAreaCopyPaste(int controlID) 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) @@ -1294,9 +1281,17 @@ void HandleMainAreaCopyPaste(int controlID) { if (type == EventType.ExecuteCommand) { - SaveCurveEditorKeySelection(); - m_State.PasteKeys(); - UpdateSelectedKeysToCurveEditor(); + // 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(); diff --git a/Editor/Mono/Animation/AnimationWindow/AnimEditorOverlay.cs b/Editor/Mono/Animation/AnimationWindow/AnimEditorOverlay.cs index f72678148c..007da0703b 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimEditorOverlay.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimEditorOverlay.cs @@ -15,7 +15,7 @@ namespace UnityEditorInternal [System.Serializable] internal class AnimEditorOverlay { - public AnimationWindowState state; + [SerializeReference] public AnimationWindowState state; private TimeCursorManipulator m_PlayHeadCursor; @@ -71,21 +71,20 @@ public void HandleEvents() private bool OnStartDragPlayHead(Event evt) { - state.controlInterface.StopPlayback(); - state.controlInterface.StartScrubTime(); - state.controlInterface.ScrubTime(MousePositionToTime(evt)); + state.playing = false; + + state.controlInterface.time = MousePositionToTime(evt); return true; } private bool OnDragPlayHead(Event evt) { - state.controlInterface.ScrubTime(MousePositionToTime(evt)); + state.controlInterface.time = MousePositionToTime(evt); return true; } private bool OnEndDragPlayHead(Event evt) { - state.controlInterface.EndScrubTime(); return true; } diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationClipSelectionItem.cs b/Editor/Mono/Animation/AnimationWindow/AnimationClipSelectionItem.cs index c6942190d7..757cfbdd4a 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationClipSelectionItem.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationClipSelectionItem.cs @@ -10,16 +10,18 @@ namespace UnityEditorInternal { + [Serializable] internal class AnimationClipSelectionItem : AnimationWindowSelectionItem { - public static AnimationClipSelectionItem Create(AnimationClip animationClip, Object sourceObject) + public static AnimationClipSelectionItem Create(AnimationClip animationClip, Object sourceObject = null) { - AnimationClipSelectionItem selectionItem = CreateInstance(typeof(AnimationClipSelectionItem)) as AnimationClipSelectionItem; - - selectionItem.gameObject = sourceObject as GameObject; - selectionItem.scriptableObject = sourceObject as ScriptableObject; - selectionItem.animationClip = animationClip; - selectionItem.id = 0; // no need for id since there's only one item in selection. + var selectionItem = new AnimationClipSelectionItem + { + gameObject = sourceObject as GameObject, + scriptableObject = sourceObject as ScriptableObject, + animationClip = animationClip, + id = 0 + }; return selectionItem; } diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationContextualPropertyMenu.cs b/Editor/Mono/Animation/AnimationWindow/AnimationContextualPropertyMenu.cs index 91c81a171e..357e1113ce 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationContextualPropertyMenu.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationContextualPropertyMenu.cs @@ -2,16 +2,13 @@ // 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.Reflection; using UnityEngine; using UnityEditor; -using Object = UnityEngine.Object; namespace UnityEditorInternal { - internal class AnimationPropertyContextualMenu + class AnimationPropertyContextualMenu { public static AnimationPropertyContextualMenu Instance = new AnimationPropertyContextualMenu(); diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationKeyTime.cs b/Editor/Mono/Animation/AnimationWindow/AnimationKeyTime.cs index 35d04bed28..30a34ea21c 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationKeyTime.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationKeyTime.cs @@ -2,9 +2,7 @@ // Copyright (c) Unity Technologies. For terms of use, see // https://unity3d.com/legal/licenses/Unity_Reference_Only_License -using System; using UnityEngine; -using UnityEditor; namespace UnityEditorInternal { diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationRecording.cs b/Editor/Mono/Animation/AnimationWindow/AnimationRecording.cs index 697f03d428..eff217eca1 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationRecording.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationRecording.cs @@ -475,10 +475,14 @@ static bool ValueFromPropertyModification(PropertyModification modification, Edi } else { - float temp; - if (float.TryParse(modification.value, NumberStyles.Float, CultureInfo.InvariantCulture, out temp)) + if(binding.isDiscreteCurve && int.TryParse(modification.value, NumberStyles.Integer, CultureInfo.InvariantCulture, out int tempInt)) { - outObject = temp; + outObject = tempInt; + return true; + } + else if (float.TryParse(modification.value, NumberStyles.Float, CultureInfo.InvariantCulture, out float tempFloat)) + { + outObject = tempFloat; return true; } else @@ -505,7 +509,9 @@ static void AddKey(IAnimationRecordingState state, EditorCurveBinding binding, T if (curve.length == 0) { if (state.currentFrame != 0) + { AnimationWindowUtility.AddKeyframeToCurve(curve, previousValue, type, AnimationKeyTime.Frame(0, clip.frameRate)); + } } } @@ -632,7 +638,7 @@ static private void ProcessAnimatorModifications(IAnimationRecordingState state, if (isHumanBone) { - Debug.LogWarning("Keyframing translation on humanoid rig is not supported!", target as Transform); + Debug.LogWarning("Keyframing translation on humanoid rig is not supported!", target); discardListPos.Add(item.Key); } else if (isRootMotion) @@ -691,7 +697,7 @@ static private void ProcessAnimatorModifications(IAnimationRecordingState state, if (isHumanBone) { - Debug.LogWarning("Keyframing rotation on humanoid rig is not supported!", target as Transform); + Debug.LogWarning("Keyframing rotation on humanoid rig is not supported!", target); discardListRot.Add(item.Key); } else if (isRootMotion) @@ -739,7 +745,7 @@ static private void ProcessAnimatorModifications(IAnimationRecordingState state, bool isHumanBone = isHuman && !isRootTransform && animator.IsBoneTransform(target); if (isHumanBone) { - Debug.LogWarning("Keyframing scale on humanoid rig is not supported!", target as Transform); + Debug.LogWarning("Keyframing scale on humanoid rig is not supported!", target); discardListScale.Add(item.Key); } } diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindow.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindow.cs index fbddcca9f8..bd82bca45e 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindow.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindow.cs @@ -4,20 +4,22 @@ using System; using UnityEngine; -using UnityEditor; -using System.Collections; using System.Collections.Generic; +using System.Linq; +using System.Reflection; using UnityEditorInternal; using Object = UnityEngine.Object; namespace UnityEditor { [EditorWindowTitle(title = "Animation", useTypeNameAsIconName = true)] - internal class AnimationWindow : EditorWindow, IHasCustomMenu + public sealed class AnimationWindow : EditorWindow, IHasCustomMenu { // Active Animation windows private static List s_AnimationWindows = new List(); - public static List GetAllAnimationWindows() { return s_AnimationWindows; } + internal static List GetAllAnimationWindows() { return s_AnimationWindows; } + + private static Type[] s_CustomControllerTypes = null; private AnimEditor m_AnimEditor; @@ -30,27 +32,164 @@ internal class AnimationWindow : EditorWindow, IHasCustomMenu private GUIContent m_DefaultTitleContent; private GUIContent m_RecordTitleContent; - internal AnimEditor animEditor + internal AnimEditor animEditor => m_AnimEditor; + + internal AnimationWindowState state { get { - return m_AnimEditor; + if (m_AnimEditor != null) + { + return m_AnimEditor.state; + } + return null; } } - internal AnimationWindowState state + public AnimationClip animationClip { get { if (m_AnimEditor != null) { - return m_AnimEditor.state; + return m_AnimEditor.state.activeAnimationClip; } return null; } + set + { + if (m_AnimEditor != null) + { + m_AnimEditor.state.activeAnimationClip = value; + } + } + } + + public bool previewing + { + get + { + if (m_AnimEditor != null) + { + return m_AnimEditor.state.previewing; + } + return false; + } + set + { + if (m_AnimEditor != null) + { + m_AnimEditor.state.previewing = value; + } + } } - public void ForceRefresh() + public bool canPreview + { + get + { + if (m_AnimEditor != null) + { + return m_AnimEditor.state.canPreview; + } + + return false; + } + } + + public bool recording + { + get + { + if (m_AnimEditor != null) + { + return m_AnimEditor.state.recording; + } + return false; + } + set + { + if (m_AnimEditor != null) + { + m_AnimEditor.state.recording = value; + } + } + } + + public bool canRecord + { + get + { + if (m_AnimEditor != null) + { + return m_AnimEditor.state.canRecord; + } + + return false; + } + } + + public bool playing + { + get + { + if (m_AnimEditor != null) + { + return m_AnimEditor.state.playing; + } + return false; + } + set + { + if (m_AnimEditor != null) + { + m_AnimEditor.state.playing = value; + } + } + } + + public float time + { + get + { + if (m_AnimEditor != null) + { + return m_AnimEditor.state.currentTime; + } + return 0.0f; + } + set + { + if (m_AnimEditor != null) + { + m_AnimEditor.state.currentTime = value; + } + } + } + + public int frame + { + get + { + if (m_AnimEditor != null) + { + return m_AnimEditor.state.currentFrame; + } + return 0; + } + set + { + if (m_AnimEditor != null) + { + m_AnimEditor.state.currentFrame = value; + } + } + } + + private AnimationWindow() + {} + + internal void ForceRefresh() { if (m_AnimEditor != null) { @@ -58,11 +197,11 @@ public void ForceRefresh() } } - public void OnEnable() + void OnEnable() { if (m_AnimEditor == null) { - m_AnimEditor = CreateInstance(typeof(AnimEditor)) as AnimEditor; + m_AnimEditor = CreateInstance(); m_AnimEditor.hideFlags = HideFlags.HideAndDontSave; } @@ -74,23 +213,23 @@ public void OnEnable() OnSelectionChange(); - Undo.undoRedoPerformed += UndoRedoPerformed; + Undo.undoRedoEvent += UndoRedoPerformed; } - public void OnDisable() + void OnDisable() { s_AnimationWindows.Remove(this); m_AnimEditor.OnDisable(); - Undo.undoRedoPerformed -= UndoRedoPerformed; + Undo.undoRedoEvent -= UndoRedoPerformed; } - public void OnDestroy() + void OnDestroy() { DestroyImmediate(m_AnimEditor); } - public void Update() + void Update() { if (m_AnimEditor == null) return; @@ -98,7 +237,7 @@ public void Update() m_AnimEditor.Update(); } - public void OnGUI() + void OnGUI() { if (m_AnimEditor == null) return; @@ -107,7 +246,7 @@ public void OnGUI() m_AnimEditor.OnAnimEditorGUI(this, position); } - public void OnSelectionChange() + internal void OnSelectionChange() { if (m_AnimEditor == null) return; @@ -122,22 +261,19 @@ public void OnSelectionChange() m_LockTracker.isLocked = false; } - GameObject activeGameObject = activeObject as GameObject; - if (activeGameObject != null) + if (activeObject is GameObject activeGameObject) { EditGameObject(activeGameObject); } else { - Transform activeTransform = activeObject as Transform; - if (activeTransform != null) + if (activeObject is Transform activeTransform) { EditGameObject(activeTransform.gameObject); } else { - AnimationClip activeAnimationClip = activeObject as AnimationClip; - if (activeAnimationClip != null) + if (activeObject is AnimationClip activeAnimationClip) EditAnimationClip(activeAnimationClip); } } @@ -148,18 +284,18 @@ public void OnSelectionChange() } } - public void OnFocus() + void OnFocus() { OnSelectionChange(); } - public void OnControllerChange() + internal void OnControllerChange() { // Refresh selectedItem to update selected clips. OnSelectionChange(); } - public void OnLostFocus() + void OnLostFocus() { if (m_AnimEditor != null) m_AnimEditor.OnLostFocus(); @@ -177,28 +313,56 @@ static bool OnOpenAsset(int instanceID, int line) return false; } - public bool EditGameObject(GameObject gameObject) + internal bool EditGameObject(GameObject gameObject) { - return EditGameObjectInternal(gameObject, (IAnimationWindowControl)null); + if (EditorUtility.IsPersistent(gameObject)) + return false; + + if ((gameObject.hideFlags & HideFlags.NotEditable) != 0) + return false; + + var newSelection = GameObjectSelectionItem.Create(gameObject); + if (ShouldUpdateGameObjectSelection(newSelection)) + { + m_AnimEditor.selection = newSelection; + + IAnimationWindowController controller = null; + + var rootGameObject = newSelection.rootGameObject; + if (rootGameObject != null) + controller = FindCustomController(rootGameObject); + + m_AnimEditor.overrideControlInterface = controller; + + m_LastSelectedObjectID = gameObject != null ? gameObject.GetInstanceID() : 0; + } + else + m_AnimEditor.OnSelectionUpdated(); + + return true; } - public bool EditAnimationClip(AnimationClip animationClip) + internal bool EditAnimationClip(AnimationClip animationClip) { if (state.linkedWithSequencer == true) return false; - EditAnimationClipInternal(animationClip, (Object)null, (IAnimationWindowControl)null); + EditAnimationClipInternal(animationClip, (Object)null, (IAnimationWindowController)null); return true; } - public bool EditSequencerClip(AnimationClip animationClip, Object sourceObject, IAnimationWindowControl controlInterface) + internal bool EditSequencerClip(AnimationClip animationClip, Object sourceObject, IAnimationWindowControl controlInterface) { EditAnimationClipInternal(animationClip, sourceObject, controlInterface); state.linkedWithSequencer = true; + + if (controlInterface != null) + controlInterface.Init(state); + return true; } - public void UnlinkSequencer() + internal void UnlinkSequencer() { if (state.linkedWithSequencer) { @@ -210,29 +374,35 @@ public void UnlinkSequencer() } } - private bool EditGameObjectInternal(GameObject gameObject, IAnimationWindowControl controlInterface) + private IAnimationWindowController FindCustomController(GameObject gameObject) { - if (EditorUtility.IsPersistent(gameObject)) - return false; + IAnimationWindowController controller = null; - if ((gameObject.hideFlags & HideFlags.NotEditable) != 0) - return false; + if (s_CustomControllerTypes == null) + { + s_CustomControllerTypes = TypeCache + .GetTypesWithAttribute() + .Where(type => typeof(IAnimationWindowController).IsAssignableFrom(type)) + .ToArray(); + } - var newSelection = GameObjectSelectionItem.Create(gameObject); - if (ShouldUpdateGameObjectSelection(newSelection)) + foreach (var controllerType in s_CustomControllerTypes) { - m_AnimEditor.selection = newSelection; - m_AnimEditor.overrideControlInterface = controlInterface; + var attribute = controllerType.GetCustomAttribute(); + var component = gameObject.GetComponent(attribute.componentType); - m_LastSelectedObjectID = gameObject != null ? gameObject.GetInstanceID() : 0; + if (component != null) + { + controller = (IAnimationWindowController)Activator.CreateInstance(controllerType); + controller.OnCreate(this, component); + break; + } } - else - m_AnimEditor.OnSelectionUpdated(); - return true; + return controller; } - private void EditAnimationClipInternal(AnimationClip animationClip, Object sourceObject, IAnimationWindowControl controlInterface) + private void EditAnimationClipInternal(AnimationClip animationClip, Object sourceObject, IAnimationWindowController controlInterface) { var newSelection = AnimationClipSelectionItem.Create(animationClip, sourceObject); if (ShouldUpdateSelection(newSelection)) @@ -246,7 +416,7 @@ private void EditAnimationClipInternal(AnimationClip animationClip, Object sourc m_AnimEditor.OnSelectionUpdated(); } - protected virtual void ShowButton(Rect r) + void ShowButton(Rect r) { if (m_LockButtonStyle == null) m_LockButtonStyle = "IN LockButton"; @@ -302,12 +472,12 @@ private bool ShouldUpdateSelection(AnimationWindowSelectionItem selectedItem) return (selectedItem.GetRefreshHash() != currentSelection.GetRefreshHash()); } - private void UndoRedoPerformed() + private void UndoRedoPerformed(in UndoRedoInfo info) { Repaint(); } - public virtual void AddItemsToMenu(GenericMenu menu) + public void AddItemsToMenu(GenericMenu menu) { m_LockTracker.AddItemsToMenu(menu, m_AnimEditor.stateDisabled); } diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowClipPopup.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowClipPopup.cs index 9c9167b0c1..b0b6991af4 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindowClipPopup.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowClipPopup.cs @@ -12,7 +12,7 @@ namespace UnityEditor [System.Serializable] class AnimationWindowClipPopup { - [SerializeField] public AnimationWindowState state; + [SerializeReference] public AnimationWindowState state; static int s_ClipPopupHash = "s_ClipPopupHash".GetHashCode(); @@ -214,7 +214,8 @@ private AnimationClip[] GetOrderedClipList() if (state.activeRootGameObject != null) clips = AnimationUtility.GetAnimationClips(state.activeRootGameObject); - Array.Sort(clips, (AnimationClip clip1, AnimationClip clip2) => CurveUtility.GetClipName(clip1).CompareTo(CurveUtility.GetClipName(clip2))); + //Using AlphaNum/Natural Compare to sort clips + Array.Sort(clips, (AnimationClip clip1, AnimationClip clip2) => EditorUtility.NaturalCompareObjectNames(clip1, clip2)); return clips; } diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowClipboard.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowClipboard.cs index 471302ee0a..22939495c9 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindowClipboard.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowClipboard.cs @@ -77,6 +77,12 @@ internal static void CopyEvents(IList allEvents, bool[] selected copyEvents.Add(new AnimationWindowEventClipboard(allEvents[explicitIndex])); } var data = new AnimationWindowEventsClipboard {events = copyEvents.ToArray()}; + + // Animation keyframes right now do not go through regular clipboard machinery, + // so when copying Events, make sure Keyframes are cleared from the clipboard, or things + // get confusing. + AnimationWindowState.ClearKeyframeClipboard(); + Clipboard.SetCustomValue(data); } diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowControl.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowControl.cs index 49cf330b3f..4223a5ea38 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindowControl.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowControl.cs @@ -7,19 +7,17 @@ using UnityEngine; using UnityEditor; using System.Collections.Generic; -using System.Collections; using Object = UnityEngine.Object; using UnityEngine.Playables; using UnityEngine.Animations; -using UnityEngine.Experimental.Animations; - using Unity.Profiling; namespace UnityEditorInternal { - internal class AnimationWindowControl : IAnimationWindowControl, IAnimationContextualResponder + [Serializable] + class AnimationWindowControl : IAnimationWindowController, IAnimationContextualResponder { class CandidateRecordingState : IAnimationRecordingState { @@ -134,95 +132,65 @@ private static bool HasFlag(ResampleFlags flags, ResampleFlags flag) private static ProfilerMarker s_ResampleAnimationMarker = new ProfilerMarker("AnimationWindowControl.ResampleAnimation"); - public override void OnEnable() + public void OnEnable() { - base.OnEnable(); - EditorApplication.playModeStateChanged += OnPlayModeStateChanged; } public void OnDisable() { - StopPreview(); - StopPlayback(); - EditorApplication.playModeStateChanged -= OnPlayModeStateChanged; } + public void OnCreate(AnimationWindow animationWindow, Component component) + { + // nothing to do. + } + public void OnDestroy() { if (m_Driver != null) - DestroyImmediate(m_Driver); + ScriptableObject.DestroyImmediate(m_Driver); } - public override void OnSelectionChanged() + public void OnSelectionChanged() { // Set back time at beginning and stop recording. if (state != null) m_Time = AnimationKeyTime.Time(0f, state.frameRate); StopPreview(); - StopPlayback(); } void OnPlayModeStateChanged(PlayModeStateChange state) { - if (state == PlayModeStateChange.ExitingPlayMode) + if (state == PlayModeStateChange.ExitingPlayMode || + state == PlayModeStateChange.ExitingEditMode) { StopPreview(); - StopPlayback(); } } - public override AnimationKeyTime time + public float time { - get - { - return m_Time; - } + get => m_Time.time; + set => SetCurrentTime(value); } - public override void GoToTime(float time) + public int frame { - SetCurrentTime(time); + get => m_Time.frame; + set => SetCurrentFrame(value); } - public override void GoToFrame(int frame) - { - SetCurrentFrame(frame); - } - - public override void StartScrubTime() - { - // nothing to do... - } - - public override void ScrubTime(float time) + public void GoToTime(float time) { SetCurrentTime(time); } - public override void EndScrubTime() - { - // nothing to do... - } - - public override void GoToPreviousFrame() + public void GoToFrame(int frame) { - SetCurrentFrame(time.frame - 1); - } - - public override void GoToNextFrame() - { - SetCurrentFrame(time.frame + 1); - } - - public override void GoToPreviousKeyframe() - { - List curves = (state.showCurveEditor && state.activeCurves.Count > 0) ? state.activeCurves : state.allCurves; - - float newTime = AnimationWindowUtility.GetPreviousKeyframeTime(curves.ToArray(), time.time, state.clipFrameRate); - SetCurrentTime(state.SnapToFrame(newTime, AnimationWindowState.SnapMode.SnapToClipFrame)); + SetCurrentFrame(frame); } public void GoToPreviousKeyframe(PropertyModification[] modifications) @@ -232,27 +200,19 @@ public void GoToPreviousKeyframe(PropertyModification[] modifications) return; List curves = new List(); - for (int i = 0; i < state.allCurves.Count; ++i) + for (int i = 0; i < state.filteredCurves.Count; ++i) { - AnimationWindowCurve curve = state.allCurves[i]; + AnimationWindowCurve curve = state.filteredCurves[i]; if (Array.Exists(bindings, binding => curve.binding.Equals(binding))) curves.Add(curve); } - float newTime = AnimationWindowUtility.GetPreviousKeyframeTime(curves.ToArray(), time.time, state.clipFrameRate); - SetCurrentTime(state.SnapToFrame(newTime, AnimationWindowState.SnapMode.SnapToClipFrame)); + float newTime = AnimationWindowUtility.GetPreviousKeyframeTime(curves.ToArray(), time, state.clipFrameRate); + SetCurrentTime(state.SnapToFrame(newTime, AnimationWindowState.SnapMode.SnapToFrame)); state.Repaint(); } - public override void GoToNextKeyframe() - { - List curves = (state.showCurveEditor && state.activeCurves.Count > 0) ? state.activeCurves : state.allCurves; - - float newTime = AnimationWindowUtility.GetNextKeyframeTime(curves.ToArray(), time.time, state.clipFrameRate); - SetCurrentTime(state.SnapToFrame(newTime, AnimationWindowState.SnapMode.SnapToClipFrame)); - } - public void GoToNextKeyframe(PropertyModification[] modifications) { EditorCurveBinding[] bindings = AnimationWindowUtility.PropertyModificationsToEditorCurveBindings(modifications, state.activeRootGameObject, state.activeAnimationClip); @@ -260,40 +220,28 @@ public void GoToNextKeyframe(PropertyModification[] modifications) return; List curves = new List(); - for (int i = 0; i < state.allCurves.Count; ++i) + for (int i = 0; i < state.filteredCurves.Count; ++i) { - AnimationWindowCurve curve = state.allCurves[i]; + AnimationWindowCurve curve = state.filteredCurves[i]; if (Array.Exists(bindings, binding => curve.binding.Equals(binding))) curves.Add(curve); } - float newTime = AnimationWindowUtility.GetNextKeyframeTime(curves.ToArray(), time.time, state.clipFrameRate); - SetCurrentTime(state.SnapToFrame(newTime, AnimationWindowState.SnapMode.SnapToClipFrame)); + float newTime = AnimationWindowUtility.GetNextKeyframeTime(curves.ToArray(), time, state.clipFrameRate); + SetCurrentTime(state.SnapToFrame(newTime, AnimationWindowState.SnapMode.SnapToFrame)); state.Repaint(); } - public override void GoToFirstKeyframe() - { - if (state.activeAnimationClip) - SetCurrentTime(state.activeAnimationClip.startTime); - } - - public override void GoToLastKeyframe() - { - if (state.activeAnimationClip) - SetCurrentTime(state.activeAnimationClip.stopTime); - } - private void SnapTimeToFrame() { - float newTime = state.FrameToTime(time.frame); + float newTime = state.FrameToTime(frame); SetCurrentTime(newTime); } private void SetCurrentTime(float value) { - if (!Mathf.Approximately(value, time.time)) + if (!Mathf.Approximately(value, time)) { m_Time = AnimationKeyTime.Time(value, state.frameRate); StartPreview(); @@ -304,7 +252,7 @@ private void SetCurrentTime(float value) private void SetCurrentFrame(int value) { - if (value != time.frame) + if (value != frame) { m_Time = AnimationKeyTime.Frame(value, state.frameRate); StartPreview(); @@ -313,7 +261,7 @@ private void SetCurrentFrame(int value) } } - public override bool canPlay + public bool canPlay { get { @@ -321,34 +269,35 @@ public override bool canPlay } } - public override bool playing + public bool playing { get { return AnimationMode.InAnimationPlaybackMode() && previewing; } + set + { + if (value) + StartPlayback(); + else + StopPlayback(); + } } - public override bool StartPlayback() + private void StartPlayback() { - if (!canPlay) - return false; - - if (!playing) - { - AnimationMode.StartAnimationPlaybackMode(); + if (!canPlay || playing) + return; - m_PreviousUpdateTime = Time.realtimeSinceStartup; + AnimationMode.StartAnimationPlaybackMode(); - // Auto-Preview when start playing - StartPreview(); - ClearCandidates(); - } + m_PreviousUpdateTime = Time.realtimeSinceStartup; - return true; + // Auto-Preview when start playing + ClearCandidates(); } - public override void StopPlayback() + private void StopPlayback() { if (AnimationMode.InAnimationPlaybackMode()) { @@ -359,15 +308,12 @@ public override void StopPlayback() } } - public override bool PlaybackUpdate() + public bool PlaybackUpdate() { - if (!playing) - return false; - float deltaTime = Time.realtimeSinceStartup - m_PreviousUpdateTime; m_PreviousUpdateTime = Time.realtimeSinceStartup; - float newTime = time.time + deltaTime; + float newTime = time + deltaTime; // looping if (newTime > state.maxTime) @@ -380,7 +326,7 @@ public override bool PlaybackUpdate() return true; } - public override bool canPreview + public bool canPreview { get { @@ -393,7 +339,7 @@ public override bool canPreview } } - public override bool previewing + public bool previewing { get { @@ -403,39 +349,56 @@ public override bool previewing return AnimationMode.InAnimationMode(driver); } + set + { + if (value) + StartPreview(); + else + StopPreview(); + } } - public override bool StartPreview() + private void StartPreview() { - if (previewing) - return true; - - if (!canPreview) - return false; + if (previewing || !canPreview) + return; AnimationMode.StartAnimationMode(GetAnimationModeDriver()); AnimationPropertyContextualMenu.Instance.SetResponder(this); Undo.postprocessModifications += PostprocessAnimationRecordingModifications; + PrefabUtility.allowRecordingPrefabPropertyOverridesFor += AllowRecordingPrefabPropertyOverridesFor; DestroyGraph(); CreateCandidateClip(); + //If a hierarchy was created and array reorder happen in the inspector prior + //to the preview being started we will need to ensure that the display name + //reflects the binding path on an array element. + state.UpdateCurvesDisplayName(); + IAnimationWindowPreview[] previewComponents = FetchPostProcessComponents(); - m_UsesPostProcessComponents = previewComponents != null; + m_UsesPostProcessComponents = previewComponents != null && previewComponents.Length > 0; if (previewComponents != null) { + // Animation preview affects inspector values, so make sure we ignore constrain proportions + ConstrainProportionsTransformScale.m_IsAnimationPreview = true; foreach (var component in previewComponents) { component.StartPreview(); } } - return true; + ResampleAnimation(); } - public override void StopPreview() + private void StopPreview() { - StopPlayback(); - StopRecording(); + if (!previewing) + return; + + OnExitingAnimationMode(); + + ConstrainProportionsTransformScale.m_IsAnimationPreview = false; + ClearCandidates(); DestroyGraph(); DestroyCandidateClip(); @@ -470,11 +433,9 @@ public override void StopPreview() m_UsesPostProcessComponents = false; } - - Undo.postprocessModifications -= PostprocessAnimationRecordingModifications; } - public override bool canRecord + public bool canRecord { get { @@ -485,7 +446,7 @@ public override bool canRecord } } - public override bool recording + public bool recording { get { @@ -493,37 +454,30 @@ public override bool recording return AnimationMode.InAnimationRecording(); return false; } + set + { + if (value) + StartRecording(); + else + StopRecording(); + } } - public override bool StartRecording(Object targetObject) - { - return StartRecording(); - } - - private bool StartRecording() + private void StartRecording() { - if (recording) - return true; - - if (!canRecord) - return false; - - if (StartPreview()) - { - AnimationMode.StartAnimationRecording(); - ClearCandidates(); - return true; - } + if (!canRecord || recording) + return; - return false; + AnimationMode.StartAnimationRecording(); + ClearCandidates(); } - public override void StopRecording() + private void StopRecording() { - if (recording) - { - AnimationMode.StopAnimationRecording(); - } + if (!recording) + return; + + AnimationMode.StopAnimationRecording(); } private void StartCandidateRecording() @@ -610,7 +564,7 @@ private void RebuildGraph(Animator animator) m_GraphRoot = (Playable)motionX; } - var output = AnimationPlayableOutput.Create(m_Graph, "ouput", animator); + var output = AnimationPlayableOutput.Create(m_Graph, "output", animator); output.SetSourcePlayable(m_GraphRoot); output.SetWeight(0.0f); } @@ -625,7 +579,7 @@ private IAnimationWindowPreview[] FetchPostProcessComponents() return null; } - public override void ResampleAnimation() + public void ResampleAnimation() { ResampleAnimation(ResampleFlags.Default); } @@ -635,9 +589,7 @@ private void ResampleAnimation(ResampleFlags flags) if (state.disabled) return; - if (previewing == false) - return; - if (canPreview == false) + if (!canPreview || !previewing) return; s_ResampleAnimationMarker.Begin(); @@ -681,20 +633,23 @@ private void ResampleAnimation(ResampleFlags flags) } if (!m_CandidateClip.empty) + { + StartCandidateRecording(); AnimationMode.AddCandidates(state.activeRootGameObject, m_CandidateClip); + } m_ClipPlayable.SetSampleRate(playing ? -1 : state.activeAnimationClip.frameRate); - AnimationMode.SamplePlayableGraph(m_Graph, 0, time.time); + AnimationMode.SamplePlayableGraph(m_Graph, 0, time); // This will cover euler/quaternion matching in basic playable graphs only (animation clip + candidate clip). - AnimationUtility.SampleEulerHint(state.activeRootGameObject, state.activeAnimationClip, time.time, WrapMode.Clamp); + AnimationUtility.SampleEulerHint(state.activeRootGameObject, state.activeAnimationClip, time, WrapMode.Clamp); if (!m_CandidateClip.empty) - AnimationUtility.SampleEulerHint(state.activeRootGameObject, m_CandidateClip, time.time, WrapMode.Clamp); + AnimationUtility.SampleEulerHint(state.activeRootGameObject, m_CandidateClip, time, WrapMode.Clamp); } else { - AnimationMode.SampleAnimationClip(state.activeRootGameObject, state.activeAnimationClip, time.time); + AnimationMode.SampleAnimationClip(state.activeRootGameObject, state.activeAnimationClip, time); if (!m_CandidateClip.empty) AnimationMode.SampleCandidateClip(state.activeRootGameObject, m_CandidateClip, 0f); } @@ -719,7 +674,7 @@ private AnimationModeDriver GetAnimationModeDriver() { if (m_Driver == null) { - m_Driver = CreateInstance(); + m_Driver = ScriptableObject.CreateInstance(); m_Driver.hideFlags = HideFlags.HideAndDontSave; m_Driver.name = "AnimationWindowDriver"; m_Driver.isKeyCallback += (Object target, string propertyPath) => @@ -749,19 +704,50 @@ private AnimationModeDriver GetCandidateDriver() { if (m_CandidateDriver == null) { - m_CandidateDriver = CreateInstance(); + m_CandidateDriver = ScriptableObject.CreateInstance(); m_CandidateDriver.name = "AnimationWindowCandidateDriver"; } return m_CandidateDriver; } + private bool AllowRecordingPrefabPropertyOverridesFor(UnityEngine.Object componentOrGameObject) + { + if (componentOrGameObject == null) + throw new ArgumentNullException(nameof(componentOrGameObject)); + + if (componentOrGameObject is not Component && componentOrGameObject is not GameObject) + return true; + + var rootOfAnimation = state.activeRootGameObject; + if (rootOfAnimation == null) + return true; + + return false; + } + + void OnExitingAnimationMode() + { + Undo.postprocessModifications -= PostprocessAnimationRecordingModifications; + PrefabUtility.allowRecordingPrefabPropertyOverridesFor -= AllowRecordingPrefabPropertyOverridesFor; + } + + void RecordPropertyOverridesForNonAnimatedProperties(UndoPropertyModification[] modifications) + { + PrefabUtility.allowRecordingPrefabPropertyOverridesFor -= AllowRecordingPrefabPropertyOverridesFor; + foreach (var mod in modifications) + { + PrefabUtility.RecordPrefabInstancePropertyModifications(mod.currentValue.target); + } + PrefabUtility.allowRecordingPrefabPropertyOverridesFor += AllowRecordingPrefabPropertyOverridesFor; + } + private UndoPropertyModification[] PostprocessAnimationRecordingModifications(UndoPropertyModification[] modifications) { - //Fix for case 751009: The animationMode can be changed outside the AnimationWindow, and this callback needs to be unregistered. + //Fix for case 751009: The animationMode can be changed outside the AnimationWindow, and callbacks needs to be unregistered. if (!AnimationMode.InAnimationMode(GetAnimationModeDriver())) { - Undo.postprocessModifications -= PostprocessAnimationRecordingModifications; + OnExitingAnimationMode(); return modifications; } @@ -770,6 +756,11 @@ private UndoPropertyModification[] PostprocessAnimationRecordingModifications(Un else if (previewing) modifications = RegisterCandidates(modifications); + // Fix for UUM-61742: Unrecorded Prefab overloads should be recorded immediately + RecordPropertyOverridesForNonAnimatedProperties(modifications); + + RefreshDisplayNamesOnArrayTopologicalChange(modifications); + // Only resample when playable graph has been customized with post process nodes. if (m_UsesPostProcessComponents) ResampleAnimation(ResampleFlags.None); @@ -777,6 +768,28 @@ private UndoPropertyModification[] PostprocessAnimationRecordingModifications(Un return modifications; } + private void RefreshDisplayNamesOnArrayTopologicalChange(UndoPropertyModification[] modifications) + { + if (modifications.Length >= 2) + { + if (modifications[0].currentValue.propertyPath.EndsWith("]") && + modifications[0].currentValue.propertyPath.Contains(".Array.data[") && + modifications[1].currentValue.propertyPath.EndsWith("]") && + modifications[1].currentValue.propertyPath.Contains(".Array.data[")) + { + //Array reordering might affect curves display name + state.UpdateCurvesDisplayName(); + } + else if (modifications[0].currentValue.propertyPath.EndsWith(".Array.size") && + Convert.ToInt64(modifications[0].currentValue.value) < + Convert.ToInt64(modifications[0].previousValue.value)) + { + //Array shrinking might affect curves display name + state.UpdateCurvesDisplayName(); + } + } + } + private UndoPropertyModification[] ProcessAutoKey(UndoPropertyModification[] modifications) { BeginKeyModification(); @@ -844,7 +857,7 @@ private void DestroyCandidateClip() m_CandidateClip = null; } - public override void ClearCandidates() + public void ClearCandidates() { StopCandidateRecording(); @@ -852,7 +865,7 @@ public override void ClearCandidates() m_CandidateClip.ClearCurves(); } - public override void ProcessCandidates() + public void ProcessCandidates() { BeginKeyModification(); @@ -861,15 +874,15 @@ public override void ProcessCandidates() List curves = new List(); - for (int i = 0; i < state.allCurves.Count; ++i) + for (int i = 0; i < state.filteredCurves.Count; ++i) { - AnimationWindowCurve curve = state.allCurves[i]; + AnimationWindowCurve curve = state.filteredCurves[i]; EditorCurveBinding remappedBinding = RotationCurveInterpolation.RemapAnimationBindingForRotationCurves(curve.binding, m_CandidateClip); if (Array.Exists(bindings, binding => remappedBinding.Equals(binding)) || Array.Exists(objectCurveBindings, binding => remappedBinding.Equals(binding))) curves.Add(curve); } - AnimationWindowUtility.AddKeyframes(state, curves, time); + AnimationWindowUtility.AddKeyframes(state, curves, m_Time); EndKeyModification(); @@ -884,15 +897,15 @@ private List GetKeys(PropertyModification[] modificatio if (bindings.Length == 0) return keys; - for (int i = 0; i < state.allCurves.Count; ++i) + for (int i = 0; i < state.filteredCurves.Count; ++i) { - AnimationWindowCurve curve = state.allCurves[i]; + AnimationWindowCurve curve = state.filteredCurves[i]; if (Array.Exists(bindings, binding => curve.binding.Equals(binding))) { int keyIndex = curve.GetKeyframeIndex(state.time); if (keyIndex >= 0) { - keys.Add(curve.m_Keyframes[keyIndex]); + keys.Add(curve.keyframes[keyIndex]); } } } @@ -985,7 +998,7 @@ public bool HasAnyCandidates() public bool HasAnyCurves() { - return (state.allCurves.Count > 0); + return (state.filteredCurves.Count > 0); } public void AddKey(SerializedProperty property) @@ -1080,7 +1093,7 @@ public void AddAnimatedKeys() { BeginKeyModification(); - AnimationWindowUtility.AddKeyframes(state, state.allCurves, time); + AnimationWindowUtility.AddKeyframes(state, state.filteredCurves, m_Time); ClearCandidates(); EndKeyModification(); @@ -1100,5 +1113,74 @@ private void EndKeyModification() if (animEditor != null) animEditor.EndKeyModification(); } + + public EditorCurveBinding[] GetAnimatableBindings() + { + var rootGameObject = state.activeRootGameObject; + var scriptableObject = state.activeScriptableObject; + + if (rootGameObject != null) + { + return AnimationWindowUtility.GetAnimatableBindings(rootGameObject); + } + if (scriptableObject != null) + { + return AnimationUtility.GetAnimatableBindings(scriptableObject); + } + + return Array.Empty(); + } + + public EditorCurveBinding[] GetAnimatableBindings(GameObject gameObject) + { + var rootGameObject = state.activeRootGameObject; + return AnimationUtility.GetAnimatableBindings(gameObject, rootGameObject); + } + + public Type GetValueType(EditorCurveBinding binding) + { + var rootGameObject = state.activeRootGameObject; + var scriptableObject = state.activeScriptableObject; + + if (rootGameObject != null) + { + return AnimationUtility.GetEditorCurveValueType(rootGameObject, binding); + } + else if (scriptableObject != null) + { + return AnimationUtility.GetEditorCurveValueType(scriptableObject, binding); + } + else + { + if (binding.isPPtrCurve) + { + // Cannot extract type of PPtrCurve. + return null; + } + else + { + // Cannot extract type of AnimationCurve. Default to float. + return typeof(float); + } + } + } + + public float GetFloatValue(EditorCurveBinding binding) + { + AnimationUtility.GetFloatValue(state.activeRootGameObject, binding, out var value); + return value; + } + + public int GetIntValue(EditorCurveBinding binding) + { + AnimationUtility.GetDiscreteIntValue(state.activeRootGameObject, binding, out var value); + return value; + } + + public Object GetObjectReferenceValue(EditorCurveBinding binding) + { + AnimationUtility.GetObjectReferenceValue(state.activeRootGameObject, binding, out var value); + return value; + } } } diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowControllerAttribute.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowControllerAttribute.cs new file mode 100644 index 0000000000..06a91feb10 --- /dev/null +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowControllerAttribute.cs @@ -0,0 +1,24 @@ +// 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; + +namespace UnityEditor +{ + [AttributeUsage(AttributeTargets.Class)] + class AnimationWindowControllerAttribute : Attribute + { + public Type componentType { get; } + + public AnimationWindowControllerAttribute(System.Type type) + { + if (type == null) + Debug.LogError("Failed to load AnimationWindowControl component type"); + componentType = type; + } + } + +} diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowCurve.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowCurve.cs index 135dfd5cc2..c7d0cf939e 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindowCurve.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowCurve.cs @@ -15,7 +15,7 @@ internal class AnimationWindowCurve : IComparable, IEquata { public const float timeEpsilon = 0.00001f; - public List m_Keyframes; + private List m_Keyframes; private EditorCurveBinding m_Binding; private int m_BindingHashCode; @@ -28,6 +28,7 @@ internal class AnimationWindowCurve : IComparable, IEquata public EditorCurveBinding binding { get { return m_Binding; } } public bool isPPtrCurve { get { return m_Binding.isPPtrCurve; } } public bool isDiscreteCurve { get { return m_Binding.isDiscreteCurve; } } + public bool isSerializeReferenceCurve{ get {return m_Binding.isSerializeReferenceCurve;}} public bool isPhantom { get { return m_Binding.isPhantom; } } public string propertyName { get { return m_Binding.propertyName; } } public string path { get { return m_Binding.path; } } @@ -45,6 +46,20 @@ internal class AnimationWindowCurve : IComparable, IEquata public bool animationIsEditable { get { return m_SelectionBinding != null ? m_SelectionBinding.animationIsEditable : true; } } public int selectionID { get { return m_SelectionBinding != null ? m_SelectionBinding.id : 0; } } + public IReadOnlyList keyframes => m_Keyframes; + + private object defaultValue + { + get + { + if (isPPtrCurve) + return null; + if (isDiscreteCurve) + return 0; + return 0f; + } + } + public AnimationWindowSelectionItem selectionBinding { get { return m_SelectionBinding; } set { m_SelectionBinding = value; } } public AnimationWindowCurve(AnimationClip clip, EditorCurveBinding binding, System.Type valueType) @@ -112,12 +127,12 @@ public int CompareTo(AnimationWindowCurve obj) // We want to sort position before rotation if (sameTransformComponent) { - string propertyGroupA = AnimationWindowUtility.GetNicePropertyGroupDisplayName(typeof(Transform), AnimationWindowUtility.GetPropertyGroupName(propertyName)); - string propertyGroupB = AnimationWindowUtility.GetNicePropertyGroupDisplayName(typeof(Transform), AnimationWindowUtility.GetPropertyGroupName(obj.propertyName)); + string propertyGroupA = AnimationWindowUtility.GetPropertyGroupName(propertyName); + string propertyGroupB = AnimationWindowUtility.GetPropertyGroupName(obj.propertyName); - if (propertyGroupA.Contains("Position") && propertyGroupB.Contains("Rotation")) + if (propertyGroupA.Equals("m_LocalPosition") && (propertyGroupB.Equals("m_LocalRotation") || propertyGroupB.StartsWith("localEulerAngles"))) return -1; - if (propertyGroupA.Contains("Rotation") && propertyGroupB.Contains("Position")) + if ((propertyGroupA.Equals("m_LocalRotation") || propertyGroupA.StartsWith("localEulerAngles")) && propertyGroupB.Equals("m_LocalPosition")) return 1; } // Transform component should always come first. @@ -177,17 +192,10 @@ public AnimationCurve ToAnimationCurve() AnimationCurve animationCurve = new AnimationCurve(); List keys = new List(); - float lastFrameTime = float.MinValue; - for (int i = 0; i < length; i++) { - // Make sure we don't get two keyframes in an exactly the same time. We just ignore those. - if (Mathf.Abs(m_Keyframes[i].time - lastFrameTime) > AnimationWindowCurve.timeEpsilon) - { - Keyframe newKeyframe = m_Keyframes[i].ToKeyframe(); - keys.Add(newKeyframe); - lastFrameTime = m_Keyframes[i].time; - } + Keyframe newKeyframe = m_Keyframes[i].ToKeyframe(); + keys.Add(newKeyframe); } animationCurve.keys = keys.ToArray(); @@ -199,17 +207,10 @@ public ObjectReferenceKeyframe[] ToObjectCurve() int length = m_Keyframes.Count; List keys = new List(); - float lastFrameTime = float.MinValue; - for (int i = 0; i < length; i++) { - // Make sure we don't get two keyframes in an exactly the same time. We just ignore those. - if (Mathf.Abs(m_Keyframes[i].time - lastFrameTime) > AnimationWindowCurve.timeEpsilon) - { - ObjectReferenceKeyframe newKeyframe = m_Keyframes[i].ToObjectReferenceKeyframe(); - lastFrameTime = newKeyframe.time; - keys.Add(newKeyframe); - } + ObjectReferenceKeyframe newKeyframe = m_Keyframes[i].ToObjectReferenceKeyframe(); + keys.Add(newKeyframe); } keys.Sort((a, b) => a.time.CompareTo(b.time)); @@ -228,7 +229,7 @@ public AnimationWindowKeyframe FindKeyAtTime(AnimationKeyTime keyTime) public object Evaluate(float time) { if (m_Keyframes.Count == 0) - return isPPtrCurve ? null : (object)0f; + return defaultValue; AnimationWindowKeyframe firstKey = m_Keyframes[0]; if (time <= firstKey.time) @@ -243,9 +244,9 @@ public object Evaluate(float time) { AnimationWindowKeyframe nextKey = m_Keyframes[i]; - if (key.time < time && nextKey.time >= time) + if (key.time <= time && nextKey.time > time) { - if (isPPtrCurve) + if (isPPtrCurve || isDiscreteCurve) { return key.value; } @@ -266,7 +267,7 @@ public object Evaluate(float time) } // Shouldn't happen... - return isPPtrCurve ? null : (object)0f; + return defaultValue; } public void AddKeyframe(AnimationWindowKeyframe key, AnimationKeyTime keyTime) @@ -288,6 +289,11 @@ public void RemoveKeyframe(AnimationKeyTime time) } } + public void RemoveKeyframe(AnimationWindowKeyframe keyframe) + { + m_Keyframes.Remove(keyframe); + } + public bool HasKeyframe(AnimationKeyTime time) { return GetKeyframeIndex(time) != -1; diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowEvent.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowEvent.cs index 613cfa17ff..4b3cce3606 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindowEvent.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowEvent.cs @@ -13,10 +13,46 @@ namespace UnityEditor { - internal struct AnimationWindowEventMethod + /// + /// Holds the context for AnimationEvent editing. + /// + class AnimationEventEditorState { - public string name; - public Type parameterType; + static bool s_ShowOverloadedFunctionsDetails = true; + static bool s_ShowDuplicatedFunctionsDetails = true; + + bool m_ShowOverloadedFunctionsDetails = s_ShowOverloadedFunctionsDetails; + bool m_ShowDuplicatedFunctionsDetails = s_ShowDuplicatedFunctionsDetails; + + /// + /// Used to track whether or not to show extra details about duplicated function names found in among the potential supported functions + /// + public bool ShowOverloadedFunctionsDetails + { + get => m_ShowOverloadedFunctionsDetails; + set + { + m_ShowOverloadedFunctionsDetails = s_ShowOverloadedFunctionsDetails = value; + } + } + + /// + /// Used to track whether or not to show extra details about overloaded function names found in among the potential supported functions + /// + public bool ShowDuplicatedFunctionsDetails + { + get => m_ShowDuplicatedFunctionsDetails; + set + { + m_ShowDuplicatedFunctionsDetails = s_ShowDuplicatedFunctionsDetails = value; + } + } + + public AnimationEventEditorState() + { + m_ShowOverloadedFunctionsDetails = s_ShowOverloadedFunctionsDetails; + m_ShowDuplicatedFunctionsDetails = s_ShowDuplicatedFunctionsDetails; + } } internal class AnimationWindowEvent : ScriptableObject diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowEventInspector.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowEventInspector.cs index 0884c194bb..584f590753 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindowEventInspector.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowEventInspector.cs @@ -5,7 +5,6 @@ using System.Linq; using UnityEngine; using UnityEditor; -using System.Collections; using System.Collections.Generic; using System.Reflection; using System; @@ -17,15 +16,18 @@ namespace UnityEditor [CanEditMultipleObjects] internal class AnimationWindowEventInspector : Editor { + public static GUIContent s_OverloadWarning = EditorGUIUtility.TrTextContent("Some functions were overloaded in MonoBehaviour components and may not work as intended if used with Animation Events!"); + public static GUIContent s_DuplicatesWarning = EditorGUIUtility.TrTextContent("Some functions have the same name across several Monobehaviour components and may not work as intended if used with Animation Events!"); + const string kNotSupportedPostFix = " (Function Not Supported)"; const string kNoneSelected = "(No Function Selected)"; - public static GUIContent s_OverloadWarning = EditorGUIUtility.TrTextContent("Some functions were overloaded in MonoBehaviour components and may not work as intended if used with Animation Events!"); + AnimationEventEditorState m_State = new(); public override void OnInspectorGUI() { var awes = targets.Select(o => o as AnimationWindowEvent).ToArray(); - OnEditAnimationEvents(awes); + OnEditAnimationEvents(awes, m_State); } protected override void OnHeaderGUI() @@ -34,12 +36,17 @@ protected override void OnHeaderGUI() DrawHeaderGUI(this, targetTitle); } - public static void OnEditAnimationEvent(AnimationWindowEvent awe) + public static void OnEditAnimationEvent(AnimationWindowEvent awe, AnimationEventEditorState state) { - OnEditAnimationEvents(new AnimationWindowEvent[] {awe}); + OnEditAnimationEvents(new AnimationWindowEvent[] {awe}, state); } - public static void OnEditAnimationEvents(AnimationWindowEvent[] awEvents) + // These are used so we don't alloc new lists on every call + static List supportedMethods; + static List overloads; + static List duplicates; + + public static void OnEditAnimationEvents(AnimationWindowEvent[] awEvents, AnimationEventEditorState state) { AnimationWindowEventData data = GetData(awEvents); if (data.events == null || data.selectedEvents == null || data.selectedEvents.Length == 0) @@ -49,68 +56,64 @@ public static void OnEditAnimationEvents(AnimationWindowEvent[] awEvents) bool singleFunctionName = Array.TrueForAll(data.selectedEvents, evt => evt.functionName == firstEvent.functionName); - GUI.changed = false; + EditorGUI.BeginChangeCheck(); if (data.root != null) { - List methods = new List(); - HashSet overloads = new HashSet(); - CollectSupportedMethods(data.root, methods, overloads); + supportedMethods ??= new List(); + overloads ??= new List(); + duplicates ??= new List(); - var methodsFormatted = new List(methods.Count); + supportedMethods.Clear(); + overloads.Clear(); + duplicates.Clear(); + CollectSupportedMethods(data.root, supportedMethods, overloads, duplicates); - for (int i = 0; i < methods.Count; ++i) - { - AnimationWindowEventMethod method = methods[i]; + int selected = supportedMethods.FindIndex(method => method.Name == firstEvent.functionName); - string postFix = " ( )"; - if (method.parameterType != null) - { - if (method.parameterType == typeof(float)) - postFix = " ( float )"; - else if (method.parameterType == typeof(int)) - postFix = " ( int )"; - else - postFix = string.Format(" ( {0} )", method.parameterType.Name); - } + // A non-empty array used for rendering the contents of the popup + // It is of size 1 greater than the list of supported methods to account for the "None" option + string[] methodsFormatted = new string[supportedMethods.Count + 1]; - methodsFormatted.Add(method.name + postFix); + for (int i = 0; i < supportedMethods.Count; ++i) + { + AnimationMethodMap methodMap = supportedMethods[i]; + string menuPath = methodMap.methodMenuPath; + methodsFormatted[i] = menuPath; } - int notSupportedIndex = methods.Count; - int selected = methods.FindIndex(method => method.name == firstEvent.functionName); + // Add a final option to set the function to no selected function + int notSupportedIndex = supportedMethods.Count; if (selected == -1) { - selected = methods.Count; - - AnimationWindowEventMethod newMethod = new AnimationWindowEventMethod(); - newMethod.name = firstEvent.functionName; - newMethod.parameterType = null; - - methods.Add(newMethod); + selected = notSupportedIndex; + // Display that the current function is not supported if applicable if (string.IsNullOrEmpty(firstEvent.functionName)) - methodsFormatted.Add(kNoneSelected); + methodsFormatted[notSupportedIndex] = kNoneSelected; else - methodsFormatted.Add(firstEvent.functionName + kNotSupportedPostFix); + methodsFormatted[notSupportedIndex] = firstEvent.functionName + kNotSupportedPostFix; + + var emptyMethodMap = new AnimationMethodMap(); + supportedMethods.Add(emptyMethodMap); } EditorGUIUtility.labelWidth = 130; EditorGUI.showMixedValue = !singleFunctionName; int wasSelected = singleFunctionName ? selected : -1; - selected = EditorGUILayout.Popup("Function: ", selected, methodsFormatted.ToArray()); + selected = EditorGUILayout.Popup("Function: ", selected, methodsFormatted); if (wasSelected != selected && selected != -1 && selected != notSupportedIndex) { foreach (var evt in data.selectedEvents) { - evt.functionName = methods[selected].name; + evt.functionName = supportedMethods[selected].Name; evt.stringParameter = string.Empty; } } EditorGUI.showMixedValue = false; - var selectedParameter = methods[selected].parameterType; + var selectedParameter = supportedMethods[selected].parameterType; if (singleFunctionName && selectedParameter != null) { @@ -127,6 +130,24 @@ public static void OnEditAnimationEvents(AnimationWindowEvent[] awEvents) { EditorGUILayout.Space(); EditorGUILayout.HelpBox(s_OverloadWarning.text, MessageType.Warning, true); + state.ShowOverloadedFunctionsDetails = EditorGUILayout.Foldout(state.ShowOverloadedFunctionsDetails, "Show Details"); + if (state.ShowOverloadedFunctionsDetails) + { + string overloadedFunctionDetails = "Overloaded Functions: \n" + GetFormattedMethodsText(overloads); + GUILayout.Label(overloadedFunctionDetails, EditorStyles.helpBox); + } + } + + if (duplicates.Count > 0) + { + EditorGUILayout.Space(); + EditorGUILayout.HelpBox(s_DuplicatesWarning.text, MessageType.Warning, true); + state.ShowDuplicatedFunctionsDetails = EditorGUILayout.Foldout(state.ShowDuplicatedFunctionsDetails, "Show Details"); + if (state.ShowDuplicatedFunctionsDetails) + { + string duplicatedFunctionDetails = "Duplicated Functions: \n" + GetFormattedMethodsText(duplicates); + GUILayout.Label(duplicatedFunctionDetails, EditorStyles.helpBox); + } } } else @@ -139,7 +160,6 @@ public static void OnEditAnimationEvents(AnimationWindowEvent[] awEvents) foreach (var evt in data.selectedEvents) { evt.functionName = functionName; - evt.stringParameter = string.Empty; } } EditorGUI.showMixedValue = false; @@ -153,15 +173,53 @@ public static void OnEditAnimationEvents(AnimationWindowEvent[] awEvents) using (new EditorGUI.DisabledScope(true)) { AnimationEvent dummyEvent = new AnimationEvent(); - DoEditRegularParameters(new AnimationEvent[] {dummyEvent}, typeof(AnimationEvent)); + DoEditRegularParameters(new AnimationEvent[] { dummyEvent }, typeof(AnimationEvent)); } } } - if (GUI.changed) + if (EditorGUI.EndChangeCheck()) SetData(awEvents, data); } + static string GetFormattedMethodsText(List methods) + { + string text = ""; + foreach (AnimationMethodMap methodMap in methods) + { + text += string.Format("{0}.{1} ( {2} )\n", methodMap.sourceBehaviour.GetType().Name, methodMap.Name, GetTypeName(methodMap.parameterType)); + } + text = text.Trim(); + return text; + } + + static string GetTypeName(Type t) + { + if (t == null) + return ""; + if (t == typeof(int)) + return "int"; + if (t == typeof(float)) + return "float"; + if (t == typeof(string)) + return "string"; + if (t == typeof(bool)) + return "bool"; + return t.Name; + } + + static string GetFormattedMethodName(AnimationMethodMap methodMap) + { + string targetName = methodMap.sourceBehaviour.GetType().Name; + string methodName = methodMap.Name; + string args = GetTypeName(methodMap.parameterType); + + if (methodName.StartsWith("set_") || methodName.StartsWith("get_")) + return string.Format("{0}/Properties/{1} ( {2} )", targetName, methodName, args); + else + return string.Format("{0}/Methods/{1} ( {2} )", targetName, methodName, args); + } + public static void OnDisabledAnimationEvent() { AnimationEvent dummyEvent = new AnimationEvent(); @@ -169,11 +227,13 @@ public static void OnDisabledAnimationEvent() using (new EditorGUI.DisabledScope(true)) { dummyEvent.functionName = EditorGUILayout.TextField(EditorGUIUtility.TrTextContent("Function"), dummyEvent.functionName); - DoEditRegularParameters(new AnimationEvent[] {dummyEvent}, typeof(AnimationEvent)); + DoEditRegularParameters(new AnimationEvent[] { dummyEvent }, typeof(AnimationEvent)); } } - public static void CollectSupportedMethods(GameObject gameObject, List supportedMethods, HashSet overloadedMethods) + static Dictionary> s_TypeAnimationMethodMapCache = new Dictionary>(); + + static void CollectSupportedMethods(GameObject gameObject, List supportedMethods, List overloadedMethods, List duplicatedMethods) { if (gameObject == null) return; @@ -188,59 +248,99 @@ public static void CollectSupportedMethods(GameObject gameObject, List validMethods)) { - MethodInfo method = methods[i]; - string name = method.Name; + var pendingValidMethods = new List(); + MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly ); + for (int i = 0; i < methods.Length; i++) + { + MethodInfo method = methods[i]; + string name = method.Name; - if (!IsSupportedMethodName(name)) - continue; + if (!IsSupportedMethodName(name)) + continue; - ParameterInfo[] parameters = method.GetParameters(); - if (parameters.Length > 1) - continue; + ParameterInfo[] parameters = method.GetParameters(); + if (parameters.Length > 1) + continue; - Type parameterType = null; + Type parameterType = null; - if (parameters.Length == 1) - { - parameterType = parameters[0].ParameterType; - if (!(parameterType == typeof(string) || - parameterType == typeof(float) || - parameterType == typeof(int) || - parameterType == typeof(AnimationEvent) || - parameterType == typeof(UnityEngine.Object) || - parameterType.IsSubclassOf(typeof(UnityEngine.Object)) || - parameterType.IsEnum)) - continue; + if (parameters.Length == 1) + { + parameterType = parameters[0].ParameterType; + if (!(parameterType == typeof(string) || + parameterType == typeof(float) || + parameterType == typeof(int) || + parameterType == typeof(AnimationEvent) || + parameterType == typeof(UnityEngine.Object) || + parameterType.IsSubclassOf(typeof(UnityEngine.Object)) || + parameterType.IsEnum)) + continue; + } + + AnimationMethodMap newMethodMap = new AnimationMethodMap + { + sourceBehaviour = behaviour, + methodInfo = method, + parameterType = parameterType + }; + + newMethodMap.methodMenuPath = GetFormattedMethodName(newMethodMap); + + pendingValidMethods.Add(newMethodMap); } - AnimationWindowEventMethod newMethod = new AnimationWindowEventMethod(); - newMethod.name = method.Name; - newMethod.parameterType = parameterType; + validMethods = pendingValidMethods.AsReadOnly(); + s_TypeAnimationMethodMapCache.Add(type, validMethods); + } + foreach (var method in validMethods) + { // Since AnimationEvents only stores method name, it can't handle functions with multiple overloads. - // Only retrieve first found function, but discard overloads. - int existingMethodIndex = supportedMethods.FindIndex(m => m.name == name); + // or functions with the same name across multiple monobehaviours + // Only retrieve first found method, and discard overloads and duplicate names. + int existingMethodIndex = supportedMethods.FindIndex(m => m.Name == method.Name); if (existingMethodIndex != -1) { // The method is only ambiguous if it has a different signature to the one we saw before - if (supportedMethods[existingMethodIndex].parameterType != parameterType) + if (supportedMethods[existingMethodIndex].parameterType != method.parameterType) + { + overloadedMethods.Add(method); + } + // Otherwise, there is another monobehaviour with the same method name. + else { - overloadedMethods.Add(name); + duplicatedMethods.Add(method); } } else { - supportedMethods.Add(newMethod); + supportedMethods.Add(method); } } + type = type.BaseType; } } } + /// + /// Maps the methodInfo and paramter type of a considered animation method to a source monobeheaviour. + /// Mimics the structure of + /// + struct AnimationMethodMap + { + public Object sourceBehaviour; + public MethodInfo methodInfo; + public Type parameterType; + + // Used for caching + public string methodMenuPath; + + public string Name => methodInfo?.Name ?? ""; + } + public static string FormatEvent(GameObject root, AnimationEvent evt) { if (string.IsNullOrEmpty(evt.functionName)) @@ -273,7 +373,7 @@ public static string FormatEvent(GameObject root, AnimationEvent evt) if (method == null) continue; - var parameterTypes = method.GetParameters().Select(p => p.ParameterType); + var parameterTypes = method.GetParameters(); return evt.functionName + FormatEventArguments(parameterTypes, evt); } @@ -382,15 +482,15 @@ private static bool IsSupportedMethodName(string name) return name != "Main" && name != "Start" && name != "Awake" && name != "Update"; } - private static string FormatEventArguments(IEnumerable paramTypes, AnimationEvent evt) + private static string FormatEventArguments(ParameterInfo[] paramTypes, AnimationEvent evt) { - if (!paramTypes.Any()) + if (paramTypes.Length == 0) return " ( )"; - if (paramTypes.Count() > 1) + if (paramTypes.Length > 1) return kNotSupportedPostFix; - var paramType = paramTypes.First(); + var paramType = paramTypes[0].ParameterType; if (paramType == typeof(string)) return " ( \"" + evt.stringParameter + "\" )"; @@ -427,6 +527,9 @@ private struct AnimationWindowEventData public AnimationEvent[] selectedEvents; } + + // this are used so we don't alloc new lists on every call + static List getDataSelectedEvents; private static AnimationWindowEventData GetData(AnimationWindowEvent[] awEvents) { var data = new AnimationWindowEventData(); @@ -445,14 +548,15 @@ private static AnimationWindowEventData GetData(AnimationWindowEvent[] awEvents) if (data.events != null) { - List selectedEvents = new List(); + getDataSelectedEvents ??= new List(); + getDataSelectedEvents.Clear(); foreach (var awEvent in awEvents) { if (awEvent.eventIndex >= 0 && awEvent.eventIndex < data.events.Length) - selectedEvents.Add(data.events[awEvent.eventIndex]); + getDataSelectedEvents.Add(data.events[awEvent.eventIndex]); } - data.selectedEvents = selectedEvents.ToArray(); + data.selectedEvents = getDataSelectedEvents.ToArray(); } return data; @@ -478,11 +582,11 @@ private static void SetData(AnimationWindowEvent[] awEvents, AnimationWindowEven } } - [MenuItem("CONTEXT/AnimationWindowEvent/Reset")] + [MenuItem("CONTEXT/AnimationWindowEvent/Reset", secondaryPriority = 7)] static void ResetValues(MenuCommand command) { AnimationWindowEvent awEvent = command.context as AnimationWindowEvent; - AnimationWindowEvent[] awEvents = new AnimationWindowEvent[] {awEvent}; + AnimationWindowEvent[] awEvents = new AnimationWindowEvent[] { awEvent }; AnimationWindowEventData data = GetData(awEvents); if (data.events == null || data.selectedEvents == null || data.selectedEvents.Length == 0) diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchy.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchy.cs index 2147351f6a..a5e353264b 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchy.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchy.cs @@ -6,6 +6,9 @@ using UnityEditor; using System.Collections.Generic; using UnityEditor.IMGUI.Controls; +using TreeViewController = UnityEditor.IMGUI.Controls.TreeViewController; +using TreeViewItem = UnityEditor.IMGUI.Controls.TreeViewItem; +using TreeViewState = UnityEditor.IMGUI.Controls.TreeViewState; namespace UnityEditorInternal { @@ -44,6 +47,7 @@ internal class AnimationWindowHierarchy // Animation window shared state private AnimationWindowState m_State; private TreeViewController m_TreeView; + private AnimationWindowHierarchyGUI m_HierarchyGUI; public Vector2 GetContentSize() { @@ -65,6 +69,7 @@ public void OnGUI(Rect position) { m_TreeView.OnEvent(); m_TreeView.OnGUI(position, GUIUtility.GetControlID(FocusType.Keyboard)); + m_HierarchyGUI.ReclaimPendingFieldFocus(); } public void Init(EditorWindow owner, Rect rect) @@ -74,9 +79,10 @@ public void Init(EditorWindow owner, Rect rect) m_TreeView = new TreeViewController(owner, m_State.hierarchyState); m_State.hierarchyData = new AnimationWindowHierarchyDataSource(m_TreeView, m_State); + m_HierarchyGUI = new AnimationWindowHierarchyGUI(m_TreeView, m_State); m_TreeView.Init(rect, m_State.hierarchyData, - new AnimationWindowHierarchyGUI(m_TreeView, m_State), + m_HierarchyGUI, null ); diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchyDataSource.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchyDataSource.cs index 820a11e84c..00dbb47ccd 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchyDataSource.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchyDataSource.cs @@ -7,6 +7,11 @@ using UnityEditor.IMGUI.Controls; using UnityEngine; using Object = UnityEngine.Object; +using TreeViewController = UnityEditor.IMGUI.Controls.TreeViewController; +using TreeViewItem = UnityEditor.IMGUI.Controls.TreeViewItem; +using TreeViewUtility = UnityEditor.IMGUI.Controls.TreeViewUtility; +using TreeViewDataSource = UnityEditor.IMGUI.Controls.TreeViewDataSource; + namespace UnityEditorInternal { @@ -48,10 +53,10 @@ public override void FetchData() List childNodes = new List(); - if (state.allCurves.Count > 0) + if (state.filteredCurves.Count > 0) { AnimationWindowHierarchyMasterNode masterNode = new AnimationWindowHierarchyMasterNode(); - masterNode.curves = state.allCurves.ToArray(); + masterNode.curves = state.filteredCurves.ToArray(); childNodes.Add(masterNode); } @@ -75,17 +80,25 @@ public List CreateTreeFromCurves() List nodes = new List(); List singlePropertyCurves = new List(); - AnimationWindowCurve[] curves = state.allCurves.ToArray(); + List curves = state.filteredCurves; AnimationWindowHierarchyNode parentNode = (AnimationWindowHierarchyNode)m_RootItem; + SerializedObject so = null; - for (int i = 0; i < curves.Length; i++) + for (int i = 0; i < curves.Count; i++) { AnimationWindowCurve curve = curves[i]; if (!state.ShouldShowCurve(curve)) continue; - AnimationWindowCurve nextCurve = i < curves.Length - 1 ? curves[i + 1] : null; + AnimationWindowCurve nextCurve = i < curves.Count - 1 ? curves[i + 1] : null; + + if (curve.isSerializeReferenceCurve && state.activeRootGameObject != null) + { + var animatedObject = AnimationUtility.GetAnimatedObject(state.activeRootGameObject, curve.binding); + if (animatedObject != null && (so == null || so.targetObject != animatedObject)) + so = new SerializedObject(animatedObject); + } singlePropertyCurves.Add(curve); @@ -94,12 +107,12 @@ public List CreateTreeFromCurves() // We expect curveBindings to come sorted by propertyname // So we compare curve vs nextCurve. If its different path or different group (think "scale.xyz" as group), then we know this is the last element of such group. - if (i == curves.Length - 1 || !areSameGroup || !areSamePathAndType) + if (i == curves.Count - 1 || !areSameGroup || !areSamePathAndType) { if (singlePropertyCurves.Count > 1) - nodes.Add(AddPropertyGroupToHierarchy(singlePropertyCurves.ToArray(), parentNode)); + nodes.Add(AddPropertyGroupToHierarchy(singlePropertyCurves.ToArray(), parentNode, so)); else - nodes.Add(AddPropertyToHierarchy(singlePropertyCurves[0], parentNode)); + nodes.Add(AddPropertyToHierarchy(singlePropertyCurves[0], parentNode, so)); singlePropertyCurves.Clear(); } } @@ -107,12 +120,12 @@ public List CreateTreeFromCurves() return nodes; } - private AnimationWindowHierarchyPropertyGroupNode AddPropertyGroupToHierarchy(AnimationWindowCurve[] curves, AnimationWindowHierarchyNode parentNode) + private AnimationWindowHierarchyPropertyGroupNode AddPropertyGroupToHierarchy(AnimationWindowCurve[] curves, AnimationWindowHierarchyNode parentNode, SerializedObject so) { List childNodes = new List(); System.Type animatableObjectType = curves[0].type; - AnimationWindowHierarchyPropertyGroupNode node = new AnimationWindowHierarchyPropertyGroupNode(animatableObjectType, 0, AnimationWindowUtility.GetPropertyGroupName(curves[0].propertyName), curves[0].path, parentNode); + AnimationWindowHierarchyPropertyGroupNode node = new AnimationWindowHierarchyPropertyGroupNode(animatableObjectType, 0, AnimationWindowUtility.GetPropertyGroupName(curves[0].propertyName), curves[0].path, parentNode, AnimationWindowUtility.GetNicePropertyGroupDisplayName(curves[0].binding, so)); node.icon = GetIcon(curves[0].binding); @@ -121,7 +134,7 @@ private AnimationWindowHierarchyPropertyGroupNode AddPropertyGroupToHierarchy(An foreach (AnimationWindowCurve curve in curves) { - AnimationWindowHierarchyPropertyNode childNode = AddPropertyToHierarchy(curve, node); + AnimationWindowHierarchyPropertyNode childNode = AddPropertyToHierarchy(curve, node, so); // For child nodes we do not want to display the type in front (It is already shown by the group node) childNode.displayName = AnimationWindowUtility.GetPropertyDisplayName(childNode.propertyName); childNodes.Add(childNode); @@ -131,9 +144,9 @@ private AnimationWindowHierarchyPropertyGroupNode AddPropertyGroupToHierarchy(An return node; } - private AnimationWindowHierarchyPropertyNode AddPropertyToHierarchy(AnimationWindowCurve curve, AnimationWindowHierarchyNode parentNode) + private AnimationWindowHierarchyPropertyNode AddPropertyToHierarchy(AnimationWindowCurve curve, AnimationWindowHierarchyNode parentNode, SerializedObject so) { - AnimationWindowHierarchyPropertyNode node = new AnimationWindowHierarchyPropertyNode(curve.type, 0, curve.propertyName, curve.path, parentNode, curve.binding, curve.isPPtrCurve); + AnimationWindowHierarchyPropertyNode node = new AnimationWindowHierarchyPropertyNode(curve.type, 0, curve.propertyName, curve.path, parentNode, curve.binding, curve.isPPtrCurve, AnimationWindowUtility.GetNicePropertyDisplayName(curve.binding, so)); if (parentNode.icon != null) node.icon = parentNode.icon; @@ -147,13 +160,35 @@ private AnimationWindowHierarchyPropertyNode AddPropertyToHierarchy(AnimationWin public Texture2D GetIcon(EditorCurveBinding curveBinding) { - if (state.activeRootGameObject != null) + return AssetPreview.GetMiniTypeThumbnail(curveBinding.type); + } + + public void UpdateSerializeReferenceCurvesArrayNiceDisplayName() + { + if (state.activeRootGameObject == null) + return; + + //This is required in the case that there might have been a topological change + //leading to a different display name(topological path) + SerializedObject so = null; + foreach (AnimationWindowHierarchyNode hierarchyNode in GetRows()) { - Object animatedObject = AnimationUtility.GetAnimatedObject(state.activeRootGameObject, curveBinding); - if (animatedObject != null) - return AssetPreview.GetMiniThumbnail(animatedObject); + if (hierarchyNode.curves != null) + { + foreach (var curve in hierarchyNode.curves) + { + if (curve.isSerializeReferenceCurve && hierarchyNode.displayName.Contains(".Array.data[")) + { + var animatedObject = AnimationUtility.GetAnimatedObject(state.activeRootGameObject, curve.binding); + if (animatedObject != null && (so == null || so.targetObject != animatedObject)) + so = new SerializedObject(animatedObject); + + hierarchyNode.displayName = AnimationWindowUtility.GetNicePropertyDisplayName(curve.binding, so); + } + } + } } - return AssetPreview.GetMiniTypeThumbnail(curveBinding.type); + } public void UpdateData() diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchyGUI.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchyGUI.cs index 279995baab..af65ed17fd 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchyGUI.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchyGUI.cs @@ -9,6 +9,10 @@ using System.Linq; using UnityEditor.IMGUI.Controls; +using TreeViewItem = UnityEditor.IMGUI.Controls.TreeViewItem; +using TreeViewGUI = UnityEditor.IMGUI.Controls.TreeViewGUI; +using TreeViewController = UnityEditor.IMGUI.Controls.TreeViewController; + namespace UnityEditorInternal { internal class AnimationWindowHierarchyGUI : TreeViewGUI @@ -30,6 +34,9 @@ internal class AnimationWindowHierarchyGUI : TreeViewGUI private int[] m_HierarchyItemValueControlIDs; private int[] m_HierarchyItemButtonControlIDs; + private bool m_NeedsToReclaimFieldFocus; + private int m_FieldToReclaimFocus; + private const float k_RowRightOffset = 10; private const float k_ValueFieldDragWidth = 15; private const float k_ValueFieldWidth = 80; @@ -40,11 +47,24 @@ internal class AnimationWindowHierarchyGUI : TreeViewGUI public const float k_AddCurveButtonNodeHeight = 40f; public const float k_RowBackgroundColorBrightness = 0.28f; private const float k_SelectedPhantomCurveColorMultiplier = 1.4f; + private const float k_CurveColorIndicatorIconSize = 11; private readonly static Color k_KeyColorInDopesheetMode = new Color(0.7f, 0.7f, 0.7f, 1); private readonly static Color k_KeyColorForNonCurves = new Color(0.7f, 0.7f, 0.7f, 0.5f); private readonly static Color k_LeftoverCurveColor = Color.yellow; + private static readonly string k_DefaultValue = L10n.Tr(" (Default Value)"); + private static readonly string k_TransformPosition = L10n.Tr("Transform position, rotation and scale can't be partially animated. This value will be animated to the default value"); + private static readonly string k_Missing = L10n.Tr(" (Missing!)"); + private static readonly string k_GameObjectComponentMissing = L10n.Tr("The GameObject or Component is missing ({0})"); + private static readonly string k_DuplicateGameObjectName = L10n.Tr(" (Duplicate GameObject name!)"); + private static readonly string k_TargetForCurveIsAmbigous = L10n.Tr("Target for curve is ambiguous since there are multiple GameObjects with same name ({0})"); + private static readonly string k_RemoveProperties = L10n.Tr("Remove Properties"); + private static readonly string k_RemoveProperty = L10n.Tr("Remove Property"); + private static readonly string k_AddKey = L10n.Tr("Add Key"); + private static readonly string k_DeleteKey = L10n.Tr("Delete Key"); + private static readonly string k_RemoveCurve = L10n.Tr("Remove Curve"); + internal static int s_WasInsideValueRectFrame = -1; public AnimationWindowHierarchyGUI(TreeViewController treeView, AnimationWindowState state) @@ -158,8 +178,6 @@ private void DoAddCurveButton(Rect rect, AnimationWindowHierarchyNode node, int // the control id counter to shift when scrolling through the view. if (DoTreeViewButton(m_HierarchyItemButtonControlIDs[row], rectWithMargin, k_AnimatePropertyLabel, GUI.skin.button)) { - AddCurvesPopupHierarchyDataSource.showEntireHierarchy = true; - if (AddCurvesPopup.ShowAtPosition(rectWithMargin, state, OnNewCurveAdded)) { GUIUtility.ExitGUI(); @@ -235,7 +253,7 @@ private void DoIconAndName(Rect rect, AnimationWindowHierarchyNode node, bool se if (node is AnimationWindowHierarchyPropertyNode) rect.width -= k_ValueFieldOffsetFromRightSide + 2; - bool isLeftOverCurve = AnimationWindowUtility.IsNodeLeftOverCurve(node); + bool isLeftOverCurve = AnimationWindowUtility.IsNodeLeftOverCurve(state, node); bool isAmbiguous = AnimationWindowUtility.IsNodeAmbiguous(node); bool isPhantom = AnimationWindowUtility.IsNodePhantom(node); @@ -243,18 +261,18 @@ private void DoIconAndName(Rect rect, AnimationWindowHierarchyNode node, bool se string tooltipText = ""; if (isPhantom) { - warningText = " (Default Value)"; - tooltipText = "Transform position, rotation and scale can't be partially animated. This value will be animated to the default value"; + warningText = k_DefaultValue; + tooltipText = k_TransformPosition; } if (isLeftOverCurve) { - warningText = " (Missing!)"; - tooltipText = "The GameObject or Component is missing (" + node.path + ")"; + warningText = k_Missing; + tooltipText = string.Format(k_GameObjectComponentMissing, node.path); } if (isAmbiguous) { - warningText = " (Duplicate GameObject name!)"; - tooltipText = "Target for curve is ambiguous since there are multiple GameObjects with same name (" + node.path + ")"; + warningText = k_DuplicateGameObjectName; + tooltipText = string.Format(k_TargetForCurveIsAmbigous, node.path); } Color oldColor = lineStyle.normal.textColor; @@ -286,6 +304,7 @@ private void DoIconAndName(Rect rect, AnimationWindowHierarchyNode node, bool se SetStyleTextColor(lineStyle, textColor); rect.xMin += (int)(indent + foldoutStyleWidth + lineStyle.margin.left); + rect.yMin = rect.y + (rect.height - EditorGUIUtility.singleLineHeight) / 2; GUI.Label(rect, Styles.content, lineStyle); SetStyleTextColor(lineStyle, oldColor); @@ -316,12 +335,10 @@ private void DoValueField(Rect rect, AnimationWindowHierarchyNode node, int row) // We do valuefields for dopelines that only have single curve AnimationWindowCurve curve = curves[0]; - object objectValue = CurveBindingUtility.GetCurrentValue(state, curve); + object value = CurveBindingUtility.GetCurrentValue(state, curve); - if (objectValue is float) + if (!curve.isPPtrCurve) { - float value = (float)objectValue; - Rect valueFieldDragRect = new Rect(rect.xMax - k_ValueFieldOffsetFromRightSide - k_ValueFieldDragWidth, rect.y, k_ValueFieldDragWidth, rect.height); Rect valueFieldRect = new Rect(rect.xMax - k_ValueFieldOffsetFromRightSide, rect.y, k_ValueFieldWidth, rect.height); @@ -332,7 +349,7 @@ private void DoValueField(Rect rect, AnimationWindowHierarchyNode node, int row) if (curve.valueType == typeof(bool)) { - value = GUI.Toggle(valueFieldRect, m_HierarchyItemValueControlIDs[row], value != 0, GUIContent.none, EditorStyles.toggle) ? 1 : 0; + value = GUI.Toggle(valueFieldRect, m_HierarchyItemValueControlIDs[row], Convert.ToSingle(value) != 0f, GUIContent.none, EditorStyles.toggle) ? 1f : 0f; } else { @@ -342,48 +359,59 @@ private void DoValueField(Rect rect, AnimationWindowHierarchyNode node, int row) && Event.current.type == EventType.KeyDown && (Event.current.character == '\n' || (int)Event.current.character == 3)); - // Force back keyboard focus to float field editor when editing it. - // TreeView forces keyboard focus on itself at mouse down and we lose focus here. + // Force back keyboard focus to float field editor when editing it since the TreeView forces keyboard focus on itself at mouse down. + // The focus will be reclaimed after the TreeViewController.OnGUI call. if (EditorGUI.s_RecycledEditor.controlID == id && Event.current.type == EventType.MouseDown && valueFieldRect.Contains(Event.current.mousePosition)) { - GUIUtility.keyboardControl = id; + m_NeedsToReclaimFieldFocus = true; + m_FieldToReclaimFocus = id; } - value = EditorGUI.DoFloatField(EditorGUI.s_RecycledEditor, - valueFieldRect, - valueFieldDragRect, - id, - value, - "g5", - m_AnimationSelectionTextField, - true); - if (enterInTextField) + if (curve.isDiscreteCurve) { - GUI.changed = true; - Event.current.Use(); + value = EditorGUI.DoIntField(EditorGUI.s_RecycledEditor, + valueFieldRect, + valueFieldDragRect, + id, + Convert.ToInt32(value), + EditorGUI.kIntFieldFormatString, + m_AnimationSelectionTextField, + true, + 0); + if (enterInTextField) + { + GUI.changed = true; + Event.current.Use(); + } + } + else + { + value = EditorGUI.DoFloatField(EditorGUI.s_RecycledEditor, + valueFieldRect, + valueFieldDragRect, + id, + Convert.ToSingle(value), + "g5", + m_AnimationSelectionTextField, + true); + if (enterInTextField) + { + GUI.changed = true; + Event.current.Use(); + } + + var floatValue = Convert.ToSingle(value); + if (float.IsInfinity(floatValue) || float.IsNaN(floatValue)) + value = 0f; } } - if (float.IsInfinity(value) || float.IsNaN(value)) - value = 0; - if (EditorGUI.EndChangeCheck()) { string undoLabel = "Edit Key"; AnimationKeyTime newAnimationKeyTime = AnimationKeyTime.Time(state.currentTime, curve.clip.frameRate); - - AnimationWindowKeyframe existingKeyframe = null; - foreach (AnimationWindowKeyframe keyframe in curve.m_Keyframes) - { - if (Mathf.Approximately(keyframe.time, state.currentTime)) - existingKeyframe = keyframe; - } - - if (existingKeyframe == null) - AnimationWindowUtility.AddKeyframeToCurve(curve, value, curve.valueType, newAnimationKeyTime); - else - existingKeyframe.value = value; + AnimationWindowUtility.AddKeyframeToCurve(curve, value, curve.valueType, newAnimationKeyTime); state.SaveCurve(curve.clip, curve, undoLabel); curvesChanged = true; @@ -392,7 +420,22 @@ private void DoValueField(Rect rect, AnimationWindowHierarchyNode node, int row) } if (curvesChanged) + { + //Fix for case 1382193: Stop recording any candidates if a property value field is modified + if (AnimationMode.IsRecordingCandidates()) + state.ClearCandidates(); + state.ResampleAnimation(); + } + } + + internal void ReclaimPendingFieldFocus() + { + if (m_NeedsToReclaimFieldFocus) + { + GUIUtility.keyboardControl = m_FieldToReclaimFocus; + m_NeedsToReclaimFieldFocus = false; + } } private bool DoTreeViewButton(int id, Rect position, GUIContent content, GUIStyle style) @@ -431,7 +474,7 @@ private void DoCurveDropdown(Rect rect, AnimationWindowHierarchyNode node, int r { rect = new Rect( rect.xMax - k_RowRightOffset - 12, - rect.yMin + 2, + rect.yMin + 2 + (rect.height - EditorGUIUtility.singleLineHeight) / 2, 22, 12); // case 767863. @@ -466,15 +509,14 @@ private void DoCurveColorIndicator(Rect rect, AnimationWindowHierarchyNode node) { foreach (var curve in node.curves) { - if (curve.m_Keyframes.Any(key => state.time.ContainsTime(key.time))) + if (curve.keyframes.Any(key => state.time.ContainsTime(key.time))) { hasKey = true; } } } - Texture icon = hasKey ? CurveUtility.GetIconKey() : CurveUtility.GetIconCurve(); - rect = new Rect(rect.xMax - k_RowRightOffset - (icon.width / 2) - 5, rect.yMin + k_ColorIndicatorTopMargin, icon.width, icon.height); + rect = new Rect(rect.xMax - k_RowRightOffset - (k_CurveColorIndicatorIconSize / 2) - 5, rect.yMin + k_ColorIndicatorTopMargin + (rect.height - EditorGUIUtility.singleLineHeight) / 2, k_CurveColorIndicatorIconSize, k_CurveColorIndicatorIconSize); GUI.DrawTexture(rect, icon, ScaleMode.ScaleToFit, true, 1); GUI.color = originalColor; @@ -531,7 +573,7 @@ private GenericMenu GenerateMenu(List interactedNo GenericMenu menu = new GenericMenu(); // Remove curves - GUIContent removePropertyContent = new GUIContent(curves.Count > 1 || forceGroupRemove ? "Remove Properties" : "Remove Property"); + GUIContent removePropertyContent = new GUIContent(curves.Count > 1 || forceGroupRemove ? k_RemoveProperties : k_RemoveProperty); if (!enabled) menu.AddDisabledItem(removePropertyContent); else @@ -582,13 +624,13 @@ private GenericMenu GenerateMenu(List interactedNo string str; - str = "Add Key"; + str = k_AddKey; if (allHaveKeys || !enabled) menu.AddDisabledItem(new GUIContent(str)); else menu.AddItem(new GUIContent(str), false, AddKeysAtCurrentTime, curves); - str = "Delete Key"; + str = k_DeleteKey; if (noneHaveKeys || !enabled) menu.AddDisabledItem(new GUIContent(str)); else @@ -634,7 +676,7 @@ private void RemoveCurvesFromSelectedNodes() private void RemoveCurvesFromNodes(List nodes) { - string undoLabel = "Remove Curve"; + string undoLabel = k_RemoveCurve; state.SaveKeySelection(undoLabel); foreach (var node in nodes) @@ -846,7 +888,7 @@ override protected void RenameEnded() { EditorCurveBinding newBinding = AnimationWindowUtility.GetRenamedBinding(curve.binding, newName); - if (AnimationWindowUtility.CurveExists(newBinding, state.allCurves.ToArray())) + if (AnimationWindowUtility.CurveExists(newBinding, state.filteredCurves.ToArray())) { Debug.LogWarning("Curve already exists, renaming cancelled."); continue; diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchyNode.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchyNode.cs index 7ed4ca36a9..833ebd9bc4 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchyNode.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowHierarchyNode.cs @@ -6,6 +6,8 @@ using UnityEngine; using System.Collections.Generic; using UnityEditor.IMGUI.Controls; +using TreeViewItem = UnityEditor.IMGUI.Controls.TreeViewItem; + namespace UnityEditorInternal { @@ -33,8 +35,8 @@ public AnimationWindowHierarchyNode(int instanceID, int depth, TreeViewItem pare internal class AnimationWindowHierarchyPropertyGroupNode : AnimationWindowHierarchyNode { - public AnimationWindowHierarchyPropertyGroupNode(System.Type animatableObjectType, int setId, string propertyName, string path, TreeViewItem parent) - : base(AnimationWindowUtility.GetPropertyNodeID(setId, path, animatableObjectType, propertyName), parent != null ? parent.depth + 1 : -1, parent, animatableObjectType, AnimationWindowUtility.GetPropertyGroupName(propertyName), path, AnimationWindowUtility.GetNicePropertyGroupDisplayName(animatableObjectType, propertyName)) + public AnimationWindowHierarchyPropertyGroupNode(System.Type animatableObjectType, int setId, string propertyName, string path, TreeViewItem parent, string displayName) + : base(AnimationWindowUtility.GetPropertyNodeID(setId, path, animatableObjectType, propertyName), parent != null ? parent.depth + 1 : -1, parent, animatableObjectType, AnimationWindowUtility.GetPropertyGroupName(propertyName), path, displayName) {} } @@ -42,8 +44,8 @@ internal class AnimationWindowHierarchyPropertyNode : AnimationWindowHierarchyNo { public bool isPptrNode; - public AnimationWindowHierarchyPropertyNode(System.Type animatableObjectType, int setId, string propertyName, string path, TreeViewItem parent, EditorCurveBinding binding, bool isPptrNode) - : base(AnimationWindowUtility.GetPropertyNodeID(setId, path, animatableObjectType, propertyName), parent != null ? parent.depth + 1 : -1, parent, animatableObjectType, propertyName, path, AnimationWindowUtility.GetNicePropertyDisplayName(animatableObjectType, propertyName)) + public AnimationWindowHierarchyPropertyNode(System.Type animatableObjectType, int setId, string propertyName, string path, TreeViewItem parent, EditorCurveBinding binding, bool isPptrNode, string displayName) + : base(AnimationWindowUtility.GetPropertyNodeID(setId, path, animatableObjectType, propertyName), parent != null ? parent.depth + 1 : -1, parent, animatableObjectType, propertyName, path, displayName) { this.binding = binding; this.isPptrNode = isPptrNode; diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowKeyframe.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowKeyframe.cs index 2a310b8c35..e9fa64f7fa 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindowKeyframe.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowKeyframe.cs @@ -2,6 +2,7 @@ // Copyright (c) Unity Technologies. For terms of use, see // https://unity3d.com/legal/licenses/Unity_Reference_Only_License +using System; using UnityEngine; using UnityEditor; @@ -104,7 +105,16 @@ public AnimationWindowKeyframe(AnimationWindowKeyframe key) public AnimationWindowKeyframe(AnimationWindowCurve curve, Keyframe key) { this.time = key.time; - this.value = key.value; + + if (curve.isDiscreteCurve) + { + this.value = UnityEngine.Animations.DiscreteEvaluationAttributeUtilities.ConvertFloatToDiscreteInt(key.value); + } + else + { + this.value = key.value; + } + this.curve = curve; this.m_InTangent = key.inTangent; this.m_OutTangent = key.outTangent; @@ -139,9 +149,9 @@ public int GetHash() public int GetIndex() { - for (int i = 0; i < curve.m_Keyframes.Count; i++) + for (int i = 0; i < curve.keyframes.Count; i++) { - if (curve.m_Keyframes[i] == this) + if (curve.keyframes[i] == this) { return i; } @@ -151,7 +161,20 @@ public int GetIndex() public Keyframe ToKeyframe() { - var keyframe = new Keyframe(time, (float)value, inTangent, outTangent); + float floatValue; + if (curve.isDiscreteCurve) + { + // case 1395978 + // Negative int values converted to float create NaN values. Limiting discrete int values to only positive values + // until we rewrite the animation backend with dedicated int curves. + floatValue = UnityEngine.Animations.DiscreteEvaluationAttributeUtilities.ConvertDiscreteIntToFloat(Math.Max(Convert.ToInt32(value), 0)); + } + else + { + floatValue = Convert.ToSingle(value); + } + + var keyframe = new Keyframe(time, floatValue, inTangent, outTangent); keyframe.tangentModeInternal = m_TangentMode; keyframe.weightedMode = weightedMode; diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowSelectionItem.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowSelectionItem.cs index b857dccea1..98e48d56ef 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindowSelectionItem.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowSelectionItem.cs @@ -12,15 +12,14 @@ namespace UnityEditorInternal { - internal class AnimationWindowSelectionItem : ScriptableObject, System.IEquatable, ISelectionBinding + [Serializable] + abstract class AnimationWindowSelectionItem : System.IEquatable, ISelectionBinding { [SerializeField] private int m_Id; [SerializeField] private GameObject m_GameObject; [SerializeField] private ScriptableObject m_ScriptableObject; [SerializeField] private AnimationClip m_AnimationClip; - private List m_CurvesCache = null; - public virtual int id { get { return m_Id; } set { m_Id = value; } } public virtual GameObject gameObject { get { return m_GameObject; } set { m_GameObject = value; } } @@ -195,137 +194,6 @@ public virtual bool canCreateClips public virtual bool canSyncSceneSelection { get { return true; } } - public List curves - { - get - { - if (m_CurvesCache == null) - { - m_CurvesCache = new List(); - - if (animationClip != null) - { - EditorCurveBinding[] curveBindings = AnimationUtility.GetCurveBindings(animationClip); - EditorCurveBinding[] objectCurveBindings = AnimationUtility.GetObjectReferenceCurveBindings(animationClip); - - List transformCurves = new List(); - - foreach (EditorCurveBinding curveBinding in curveBindings) - { - if (AnimationWindowUtility.ShouldShowAnimationWindowCurve(curveBinding)) - { - AnimationWindowCurve curve = new AnimationWindowCurve(animationClip, curveBinding, GetEditorCurveValueType(curveBinding)); - curve.selectionBinding = this; - - m_CurvesCache.Add(curve); - - if (AnimationWindowUtility.IsActualTransformCurve(curveBinding)) - { - transformCurves.Add(curve); - } - } - } - - foreach (EditorCurveBinding curveBinding in objectCurveBindings) - { - AnimationWindowCurve curve = new AnimationWindowCurve(animationClip, curveBinding, GetEditorCurveValueType(curveBinding)); - curve.selectionBinding = this; - - m_CurvesCache.Add(curve); - } - - transformCurves.Sort(); - if (transformCurves.Count > 0) - { - FillInMissingTransformCurves(transformCurves, ref m_CurvesCache); - } - } - // Curves need to be sorted with path/type/property name so it's possible to construct hierarchy from them - // Sorting logic in AnimationWindowCurve.CompareTo() - m_CurvesCache.Sort(); - } - - return m_CurvesCache; - } - } - - private void FillInMissingTransformCurves(List transformCurves, ref List curvesCache) - { - EditorCurveBinding lastBinding = transformCurves[0].binding; - var propertyGroup = new EditorCurveBinding ? [3]; - string propertyGroupName; - foreach (var transformCurve in transformCurves) - { - var transformBinding = transformCurve.binding; - //if it's a new property group - if (transformBinding.path != lastBinding.path - || AnimationWindowUtility.GetPropertyGroupName(transformBinding.propertyName) != AnimationWindowUtility.GetPropertyGroupName(lastBinding.propertyName)) - { - propertyGroupName = AnimationWindowUtility.GetPropertyGroupName(lastBinding.propertyName); - - FillPropertyGroup(ref propertyGroup, lastBinding, propertyGroupName, ref curvesCache); - - lastBinding = transformBinding; - - propertyGroup = new EditorCurveBinding ? [3]; - } - - AssignBindingToRightSlot(transformBinding, ref propertyGroup); - } - FillPropertyGroup(ref propertyGroup, lastBinding, AnimationWindowUtility.GetPropertyGroupName(lastBinding.propertyName), ref curvesCache); - } - - private void FillPropertyGroup(ref EditorCurveBinding?[] propertyGroup, EditorCurveBinding lastBinding, string propertyGroupName, ref List curvesCache) - { - var newBinding = lastBinding; - newBinding.isPhantom = true; - if (!propertyGroup[0].HasValue) - { - newBinding.propertyName = propertyGroupName + ".x"; - AnimationWindowCurve curve = new AnimationWindowCurve(animationClip, newBinding, GetEditorCurveValueType(newBinding)); - curve.selectionBinding = this; - curvesCache.Add(curve); - } - - if (!propertyGroup[1].HasValue) - { - newBinding.propertyName = propertyGroupName + ".y"; - AnimationWindowCurve curve = new AnimationWindowCurve(animationClip, newBinding, GetEditorCurveValueType(newBinding)); - curve.selectionBinding = this; - curvesCache.Add(curve); - } - - if (!propertyGroup[2].HasValue) - { - newBinding.propertyName = propertyGroupName + ".z"; - AnimationWindowCurve curve = new AnimationWindowCurve(animationClip, newBinding, GetEditorCurveValueType(newBinding)); - curve.selectionBinding = this; - curvesCache.Add(curve); - } - } - - private void AssignBindingToRightSlot(EditorCurveBinding transformBinding, ref EditorCurveBinding?[] propertyGroup) - { - if (transformBinding.propertyName.EndsWith(".x")) - { - propertyGroup[0] = transformBinding; - } - else if (transformBinding.propertyName.EndsWith(".y")) - { - propertyGroup[1] = transformBinding; - } - else if (transformBinding.propertyName.EndsWith(".z")) - { - propertyGroup[2] = transformBinding; - } - } - - public static AnimationWindowSelectionItem Create() - { - AnimationWindowSelectionItem selectionItem = CreateInstance(typeof(AnimationWindowSelectionItem)) as AnimationWindowSelectionItem; - return selectionItem; - } - public int GetRefreshHash() { return unchecked (id * 19603 ^ @@ -334,11 +202,6 @@ public int GetRefreshHash() (scriptableObject != null ? scriptableObject.GetHashCode() : 0)); } - public void ClearCache() - { - m_CurvesCache = null; - } - virtual public void Synchronize() { // nothing to do. @@ -351,30 +214,5 @@ public bool Equals(AnimationWindowSelectionItem other) gameObject == other.gameObject && scriptableObject == other.scriptableObject; } - - public Type GetEditorCurveValueType(EditorCurveBinding curveBinding) - { - if (rootGameObject != null) - { - return AnimationUtility.GetEditorCurveValueType(rootGameObject, curveBinding); - } - else if (scriptableObject != null) - { - return AnimationUtility.GetEditorCurveValueType(scriptableObject, curveBinding); - } - else - { - if (curveBinding.isPPtrCurve) - { - // Cannot extract type of PPtrCurve. - return null; - } - else - { - // Cannot extract type of AnimationCurve. Default to float. - return typeof(float); - } - } - } } } diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowState.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowState.cs index 8b52dff073..6de5dd2e79 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindowState.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowState.cs @@ -3,20 +3,18 @@ // https://unity3d.com/legal/licenses/Unity_Reference_Only_License using System; -using System.Reflection; using System.Linq; using UnityEngine; using UnityEditor; using System.Collections.Generic; -using System.Collections; using UnityEditor.IMGUI.Controls; using Object = UnityEngine.Object; -using Random = UnityEngine.Random; +using TreeViewItem = UnityEditor.IMGUI.Controls.TreeViewItem; namespace UnityEditorInternal { [System.Serializable] - internal class AnimationWindowState : ScriptableObject, ICurveEditorState + class AnimationWindowState : ICurveEditorState { public enum RefreshType { @@ -29,23 +27,28 @@ public enum SnapMode { Disabled = 0, SnapToFrame = 1, + [Obsolete("SnapToClipFrame has been made redundant with SnapToFrame, SnapToFrame will behave the same.")] SnapToClipFrame = 2 } - [SerializeField] public AnimationWindowHierarchyState hierarchyState; // Persistent state of treeview on the left side of window [SerializeField] public AnimEditor animEditor; // Reference to owner of this state. Used to trigger repaints. + [SerializeField] public AnimationWindowHierarchyState hierarchyState = new(); // Persistent state of treeview on the left side of window + [NonSerialized] public AnimationWindowHierarchyDataSource hierarchyData; + + [SerializeReference] private TimeArea m_TimeArea; // Either curveeditor or dopesheet depending on which is selected + [SerializeReference] private AnimationWindowControl m_ControlInterface; + [SerializeReference] private IAnimationWindowController m_OverrideControlInterface; + + [SerializeReference] private AnimationWindowSelectionItem m_EmptySelection; + [SerializeReference] private AnimationWindowSelectionItem m_Selection; // Internal selection + [SerializeField] private AnimationWindowKeySelection m_KeySelection; // What is selected. Hashes persist cache reload, because they are from keyframe time+value + [SerializeField] public bool showCurveEditor; // Do we show dopesheet or curves [SerializeField] public bool linkedWithSequencer; // Toggle Sequencer selection mode. [SerializeField] private bool m_RippleTime; // Toggle ripple time option for curve editor and dopesheet. private bool m_RippleTimeClutch; // Toggle ripple time option for curve editor and dopesheet. - [SerializeField] private TimeArea m_TimeArea; // Either curveeditor or dopesheet depending on which is selected - [SerializeField] private AnimationWindowSelectionItem m_EmptySelection; - [SerializeField] private AnimationWindowSelectionItem m_Selection; // Internal selection - [SerializeField] private AnimationWindowKeySelection m_KeySelection; // What is selected. Hashes persist cache reload, because they are from keyframe time+value [SerializeField] private int m_ActiveKeyframeHash; // Which keyframe is active (selected key that user previously interacted with) [SerializeField] private float m_FrameRate = kDefaultFrameRate; - [SerializeField] private AnimationWindowControl m_ControlInterface; - [SerializeField] private IAnimationWindowControl m_OverrideControlInterface; [SerializeField] private int[] m_SelectionFilter; [NonSerialized] public Action onStartLiveEdit; @@ -54,10 +57,13 @@ public enum SnapMode private static List s_KeyframeClipboard; // For copy-pasting keyframes - [NonSerialized] public AnimationWindowHierarchyDataSource hierarchyData; + private bool m_AllCurvesCacheDirty = true; + private bool m_FilteredCurvesCacheDirty = true; + private bool m_ActiveCurvesCacheDirty = true; + private List m_AllCurvesCache = new (); + private List m_FilteredCurvesCache = new (); + private List m_ActiveCurvesCache = new (); - private List m_AllCurvesCache; - private List m_ActiveCurvesCache; private List m_dopelinesCache; private List m_SelectedKeysCache; private Bounds? m_SelectionBoundsCache; @@ -99,30 +105,14 @@ public AnimationWindowSelectionItem selection return m_Selection; if (m_EmptySelection == null) - { m_EmptySelection = AnimationClipSelectionItem.Create(null, null); - m_EmptySelection.hideFlags = HideFlags.HideAndDontSave; - } return m_EmptySelection; } set { - if (m_Selection != null) - Object.DestroyImmediate(m_Selection); - - // Make a copy and take ownership - if (value != null) - { - m_Selection = Object.Instantiate(value); - m_Selection.hideFlags = HideFlags.HideAndDontSave; - } - else - { - m_Selection = null; - } - + m_Selection = value; OnSelectionChanged(); } } @@ -196,34 +186,20 @@ public bool disabled } } - public IAnimationWindowControl controlInterface - { - get - { - if (m_OverrideControlInterface != null) - return m_OverrideControlInterface; - - return m_ControlInterface; - } - } + public IAnimationWindowController controlInterface => m_OverrideControlInterface ?? m_ControlInterface; - public IAnimationWindowControl overrideControlInterface + public IAnimationWindowController overrideControlInterface { - get - { - return m_OverrideControlInterface; - } - + get => m_OverrideControlInterface; set { if (m_OverrideControlInterface != null) - Object.DestroyImmediate(m_OverrideControlInterface); + m_OverrideControlInterface.OnDestroy(); m_OverrideControlInterface = value; } } - public bool filterBySelection { get @@ -293,11 +269,11 @@ private void Refresh() if (refresh == RefreshType.Everything) { - selection.ClearCache(); + m_AllCurvesCacheDirty = true; + m_FilteredCurvesCacheDirty = true; + m_ActiveCurvesCacheDirty = true; m_ActiveKeyframeCache = null; - m_AllCurvesCache = null; - m_ActiveCurvesCache = null; m_dopelinesCache = null; m_SelectedKeysCache = null; m_SelectionBoundsCache = null; @@ -355,45 +331,54 @@ public void ForceRefresh() private void PurgeSelection() { - Object.DestroyImmediate(m_Selection); + linkedWithSequencer = false; + m_OverrideControlInterface = null; m_Selection = null; } public void OnEnable() { - hideFlags = HideFlags.HideAndDontSave; AnimationUtility.onCurveWasModified += CurveWasModified; - Undo.undoRedoPerformed += UndoRedoPerformed; + Undo.undoRedoEvent += UndoRedoPerformed; AssemblyReloadEvents.beforeAssemblyReload += PurgeSelection; // NoOps... onStartLiveEdit += () => {}; onEndLiveEdit += () => {}; - if (m_ControlInterface == null) - m_ControlInterface = CreateInstance(typeof(AnimationWindowControl)) as AnimationWindowControl; - m_ControlInterface.state = this; + m_ControlInterface = new AnimationWindowControl + { + state = this + }; m_ControlInterface.OnEnable(); + + m_AllCurvesCacheDirty = true; + m_FilteredCurvesCacheDirty = true; + m_ActiveCurvesCacheDirty = true; } public void OnDisable() { AnimationUtility.onCurveWasModified -= CurveWasModified; - Undo.undoRedoPerformed -= UndoRedoPerformed; + Undo.undoRedoEvent -= UndoRedoPerformed; AssemblyReloadEvents.beforeAssemblyReload -= PurgeSelection; m_ControlInterface.OnDisable(); + previewing = false; } public void OnDestroy() { m_ControlInterface.OnDestroy(); + m_ControlInterface = null; + + if (m_OverrideControlInterface != null) + { + m_OverrideControlInterface.OnDestroy(); + m_OverrideControlInterface = null; + } - Object.DestroyImmediate(m_EmptySelection); - Object.DestroyImmediate(m_Selection); Object.DestroyImmediate(m_KeySelection); - Object.DestroyImmediate(m_ControlInterface); - Object.DestroyImmediate(m_OverrideControlInterface); } public void OnSelectionChanged() @@ -432,10 +417,10 @@ public RefreshType refresh } } - public void UndoRedoPerformed() + public void UndoRedoPerformed(in UndoRedoInfo info) { refresh = RefreshType.Everything; - controlInterface.ResampleAnimation(); + ResampleAnimation(); } // When curve is modified, we never trigger refresh right away. We order a refresh at later time by setting refresh to appropriate value. @@ -452,10 +437,10 @@ void CurveWasModified(AnimationClip clip, EditorCurveBinding binding, AnimationU bool hadPhantom = false; int hashCode = binding.GetHashCode(); - List curves = selection.curves; + var curves = filteredCurves; for (int j = 0; j < curves.Count; ++j) { - AnimationWindowCurve curve = curves[j]; + var curve = curves[j]; int curveHash = curve.GetBindingHashCode(); if (curveHash == hashCode) { @@ -530,7 +515,7 @@ private void SaveSelectedKeys(string undoLabel) List toBeDeleted = new List(); // If selected keys are dragged over non-selected keyframe at exact same time, then delete the unselected ones underneath - foreach (AnimationWindowKeyframe other in snapshot.curve.m_Keyframes) + foreach (AnimationWindowKeyframe other in snapshot.curve.keyframes) { // Keyframe is in selection, skip. if (snapshot.selectedKeys.Exists(liveEditKey => liveEditKey.key == other)) @@ -545,7 +530,7 @@ private void SaveSelectedKeys(string undoLabel) foreach (AnimationWindowKeyframe deletedKey in toBeDeleted) { - snapshot.curve.m_Keyframes.Remove(deletedKey); + snapshot.curve.RemoveKeyframe(deletedKey); } } @@ -565,53 +550,116 @@ public void RemoveCurve(AnimationWindowCurve curve, string undoLabel) AnimationUtility.SetEditorCurve(curve.clip, curve.binding, null); } - public bool previewing { get { return controlInterface.previewing; } } - - public bool canPreview { get { return controlInterface.canPreview; } } - - public void StartPreview() + public bool previewing { - controlInterface.StartPreview(); - controlInterface.ResampleAnimation(); - } + get => controlInterface.previewing; + set + { + if (controlInterface.previewing == value) + return; - public void StopPreview() - { - controlInterface.StopPreview(); + if (value) + { + if (canPreview) + controlInterface.previewing = true; + } + else + { + // Automatically stop recording and playback when stopping preview. + controlInterface.playing = false; + controlInterface.recording = false; + controlInterface.previewing = false; + } + } } - public bool recording { get { return controlInterface.recording; } } - - public bool canRecord { get { return controlInterface.canRecord; } } + public bool canPreview => controlInterface.canPreview; - public void StartRecording() + public void UpdateCurvesDisplayName() { - controlInterface.StartRecording(selection.sourceObject); - controlInterface.ResampleAnimation(); + if (hierarchyData != null) + hierarchyData.UpdateSerializeReferenceCurvesArrayNiceDisplayName(); } - public void StopRecording() + public bool recording { - controlInterface.StopRecording(); - } + get => controlInterface.recording; + set + { + if (controlInterface.recording == value) + return; - public bool playing { get { return controlInterface.playing; } } + if (value) + { + if (canRecord) + { + // Auto-Preview when starting recording + controlInterface.previewing = true; - public void StartPlayback() - { - controlInterface.StartPlayback(); + if (controlInterface.previewing) + controlInterface.recording = true; + } + } + else + controlInterface.recording = false; + } } - public void StopPlayback() + public bool canRecord => controlInterface.canRecord; + + public bool playing { - controlInterface.StopPlayback(); + get => controlInterface.playing; + set + { + if (controlInterface.playing == value) + return; + + if (value) + { + if (canPlay) + { + // Auto-Preview when starting playback. + controlInterface.previewing = true; + + if (controlInterface.previewing) + controlInterface.playing = true; + } + } + else + controlInterface.playing = false; + } } + public bool canPlay => controlInterface.canPlay; + public void ResampleAnimation() { + if (disabled) + return; + + if (controlInterface.previewing == false) + return; + if (controlInterface.canPreview == false) + return; + controlInterface.ResampleAnimation(); } + public bool PlaybackUpdate() + { + if (disabled) + return false; + + if (!controlInterface.playing) + return false; + + return controlInterface.PlaybackUpdate(); + } + + public void ClearCandidates() => controlInterface.ClearCandidates(); + public void ProcessCandidates() => controlInterface.ProcessCandidates(); + public bool ShouldShowCurve(AnimationWindowCurve curve) { if (filterBySelection && activeRootGameObject != null) @@ -639,67 +687,211 @@ private void UpdateSelectionFilter() m_SelectionFilter = (filterBySelection) ? (int[])Selection.instanceIDs.Clone() : null; } - public List allCurves + void RebuildAllCurvesCacheIfNecessary() { - get + if (m_AllCurvesCacheDirty == false && m_AllCurvesCache != null) + return; + + if (m_AllCurvesCache == null) + m_AllCurvesCache = new List(); + else + m_AllCurvesCache.Clear(); + + var animationClip = activeAnimationClip; + if (animationClip == null || (!selection.animationIsEditable && !showReadOnly)) + return; + + EditorCurveBinding[] curveBindings = AnimationUtility.GetCurveBindings(animationClip); + EditorCurveBinding[] objectCurveBindings = AnimationUtility.GetObjectReferenceCurveBindings(animationClip); + + List transformCurves = new List(); + + foreach (EditorCurveBinding curveBinding in curveBindings) { - if (m_AllCurvesCache == null) + if (AnimationWindowUtility.ShouldShowAnimationWindowCurve(curveBinding)) { - if (!selection.animationIsEditable && !showReadOnly) - { - // Empty list. - m_AllCurvesCache = new List(); - } - else if (!filterBySelection || activeRootGameObject == null) - { - m_AllCurvesCache = selection.curves; - } - else + AnimationWindowCurve curve = new AnimationWindowCurve(animationClip, curveBinding, controlInterface.GetValueType(curveBinding)); + curve.selectionBinding = selection; + + m_AllCurvesCache.Add(curve); + + if (AnimationWindowUtility.IsActualTransformCurve(curveBinding)) { - List allCurvesUnfiltered = selection.curves; - m_AllCurvesCache = new List(); - for (int i = 0; i < allCurvesUnfiltered.Count; ++i) - { - if (ShouldShowCurve(allCurvesUnfiltered[i])) - m_AllCurvesCache.Add(allCurvesUnfiltered[i]); - } + transformCurves.Add(curve); } } + } - return m_AllCurvesCache; + foreach (EditorCurveBinding curveBinding in objectCurveBindings) + { + AnimationWindowCurve curve = new AnimationWindowCurve(animationClip, curveBinding, controlInterface.GetValueType(curveBinding)); + curve.selectionBinding = selection; + + m_AllCurvesCache.Add(curve); + } + + transformCurves.Sort(); + if (transformCurves.Count > 0) + { + FillInMissingTransformCurves(animationClip, transformCurves, ref m_AllCurvesCache); } + + // Curves need to be sorted with path/type/property name so it's possible to construct hierarchy from them + // Sorting logic in AnimationWindowCurve.CompareTo() + m_AllCurvesCache.Sort(); + + m_AllCurvesCacheDirty = false; } - public List activeCurves + private void RebuildFilteredCurvesCacheIfNecessary() { - get + if (m_FilteredCurvesCacheDirty == false && m_FilteredCurvesCache != null) + return; + + if (m_FilteredCurvesCache == null) + m_FilteredCurvesCache = new List(); + else + m_FilteredCurvesCache.Clear(); + + for (int i = 0; i < m_AllCurvesCache.Count; ++i) + { + if (ShouldShowCurve(m_AllCurvesCache[i])) + m_FilteredCurvesCache.Add(m_AllCurvesCache[i]); + } + + m_FilteredCurvesCacheDirty = false; + } + + private void RebuildActiveCurvesCacheIfNecessary() + { + if (m_ActiveCurvesCacheDirty == false && m_ActiveCurvesCache != null) + return; + + if (m_ActiveCurvesCache == null) + m_ActiveCurvesCache = new List(); + else + m_ActiveCurvesCache.Clear(); + + if (hierarchyState != null && hierarchyData != null) { - if (m_ActiveCurvesCache == null) + foreach (int id in hierarchyState.selectedIDs) { - m_ActiveCurvesCache = new List(); - if (hierarchyState != null && hierarchyData != null) - { - foreach (int id in hierarchyState.selectedIDs) - { - TreeViewItem node = hierarchyData.FindItem(id); - AnimationWindowHierarchyNode hierarchyNode = node as AnimationWindowHierarchyNode; + TreeViewItem node = hierarchyData.FindItem(id); + AnimationWindowHierarchyNode hierarchyNode = node as AnimationWindowHierarchyNode; - if (hierarchyNode == null) - continue; + if (hierarchyNode == null) + continue; - AnimationWindowCurve[] curves = hierarchyNode.curves; - if (curves == null) - continue; + AnimationWindowCurve[] curves = hierarchyNode.curves; + if (curves == null) + continue; - foreach (AnimationWindowCurve curve in curves) - if (!m_ActiveCurvesCache.Contains(curve)) - m_ActiveCurvesCache.Add(curve); - } + foreach (AnimationWindowCurve curve in curves) + if (!m_ActiveCurvesCache.Contains(curve)) + m_ActiveCurvesCache.Add(curve); + } - m_ActiveCurvesCache.Sort(); - } + m_ActiveCurvesCache.Sort(); + } + + m_ActiveCurvesCacheDirty = false; + } + + private void FillInMissingTransformCurves(AnimationClip animationClip, List transformCurves, ref List curvesCache) + { + EditorCurveBinding lastBinding = transformCurves[0].binding; + var propertyGroup = new EditorCurveBinding ? [3]; + string propertyGroupName; + foreach (var transformCurve in transformCurves) + { + var transformBinding = transformCurve.binding; + //if it's a new property group + if (transformBinding.path != lastBinding.path + || AnimationWindowUtility.GetPropertyGroupName(transformBinding.propertyName) != AnimationWindowUtility.GetPropertyGroupName(lastBinding.propertyName)) + { + propertyGroupName = AnimationWindowUtility.GetPropertyGroupName(lastBinding.propertyName); + + FillPropertyGroup(animationClip, ref propertyGroup, lastBinding, propertyGroupName, ref curvesCache); + + lastBinding = transformBinding; + + propertyGroup = new EditorCurveBinding ? [3]; } + AssignBindingToRightSlot(transformBinding, ref propertyGroup); + } + FillPropertyGroup(animationClip, ref propertyGroup, lastBinding, AnimationWindowUtility.GetPropertyGroupName(lastBinding.propertyName), ref curvesCache); + } + + private void FillPropertyGroup(AnimationClip animationClip, ref EditorCurveBinding?[] propertyGroup, EditorCurveBinding lastBinding, string propertyGroupName, ref List curvesCache) + { + var newBinding = lastBinding; + newBinding.isPhantom = true; + if (!propertyGroup[0].HasValue) + { + newBinding.propertyName = propertyGroupName + ".x"; + AnimationWindowCurve curve = new AnimationWindowCurve(animationClip, newBinding, controlInterface.GetValueType(newBinding)); + curve.selectionBinding = selection; + curvesCache.Add(curve); + } + + if (!propertyGroup[1].HasValue) + { + newBinding.propertyName = propertyGroupName + ".y"; + AnimationWindowCurve curve = new AnimationWindowCurve(animationClip, newBinding, controlInterface.GetValueType(newBinding)); + curve.selectionBinding = selection; + curvesCache.Add(curve); + } + + if (!propertyGroup[2].HasValue) + { + newBinding.propertyName = propertyGroupName + ".z"; + AnimationWindowCurve curve = new AnimationWindowCurve(animationClip, newBinding, controlInterface.GetValueType(newBinding)); + curve.selectionBinding = selection; + curvesCache.Add(curve); + } + } + + private void AssignBindingToRightSlot(EditorCurveBinding transformBinding, ref EditorCurveBinding?[] propertyGroup) + { + if (transformBinding.propertyName.EndsWith(".x")) + { + propertyGroup[0] = transformBinding; + } + else if (transformBinding.propertyName.EndsWith(".y")) + { + propertyGroup[1] = transformBinding; + } + else if (transformBinding.propertyName.EndsWith(".z")) + { + propertyGroup[2] = transformBinding; + } + } + + public List allCurves + { + get + { + RebuildAllCurvesCacheIfNecessary(); + return m_AllCurvesCache; + } + } + + public List filteredCurves + { + get + { + RebuildAllCurvesCacheIfNecessary(); + RebuildFilteredCurvesCacheIfNecessary(); + return m_FilteredCurvesCache; + } + } + + public List activeCurves + { + get + { + RebuildActiveCurvesCacheIfNecessary(); return m_ActiveCurvesCache; } } @@ -712,14 +904,14 @@ public CurveWrapper[] activeCurveWrappers { List activeCurveWrappers = new List(); foreach (AnimationWindowCurve curve in activeCurves) - if (!curve.isDiscreteCurve) - activeCurveWrappers.Add(AnimationWindowUtility.GetCurveWrapper(curve, curve.clip)); + if (AnimationWindowUtility.GetCurveWrapper(curve, curve.clip) is CurveWrapper wrapper) + activeCurveWrappers.Add(wrapper); // If there are no active curves, we would end up with empty curve editor so we just give all curves insteads if (!activeCurveWrappers.Any()) - foreach (AnimationWindowCurve curve in allCurves) - if (!curve.isDiscreteCurve) - activeCurveWrappers.Add(AnimationWindowUtility.GetCurveWrapper(curve, curve.clip)); + foreach (AnimationWindowCurve curve in filteredCurves) + if (AnimationWindowUtility.GetCurveWrapper(curve, curve.clip) is CurveWrapper wrapper) + activeCurveWrappers.Add(wrapper); m_ActiveCurveWrappersCache = activeCurveWrappers.ToArray(); } @@ -791,9 +983,9 @@ public AnimationWindowKeyframe activeKeyframe { if (m_ActiveKeyframeCache == null) { - foreach (AnimationWindowCurve curve in allCurves) + foreach (AnimationWindowCurve curve in filteredCurves) { - foreach (AnimationWindowKeyframe keyframe in curve.m_Keyframes) + foreach (AnimationWindowKeyframe keyframe in curve.keyframes) { if (keyframe.GetHash() == m_ActiveKeyframeHash) m_ActiveKeyframeCache = keyframe; @@ -816,9 +1008,9 @@ public List selectedKeys if (m_SelectedKeysCache == null) { m_SelectedKeysCache = new List(); - foreach (AnimationWindowCurve curve in allCurves) + foreach (AnimationWindowCurve curve in filteredCurves) { - foreach (AnimationWindowKeyframe keyframe in curve.m_Keyframes) + foreach (AnimationWindowKeyframe keyframe in curve.keyframes) { if (KeyIsSelected(keyframe)) { @@ -842,7 +1034,7 @@ public Bounds selectionBounds { AnimationWindowKeyframe key = keys[0]; float time = key.time; - float val = key.isPPtrCurve ? 0.0f : (float)key.value; + float val = key.isPPtrCurve || key.isDiscreteCurve ? 0.0f : (float)key.value; Bounds bounds = new Bounds(new Vector2(time, val), Vector2.zero); @@ -851,7 +1043,7 @@ public Bounds selectionBounds key = keys[i]; time = key.time; - val = key.isPPtrCurve ? 0.0f : (float)key.value; + val = key.isPPtrCurve || key.isDiscreteCurve ? 0.0f : (float)key.value; bounds.Encapsulate(new Vector2(time, val)); } @@ -874,7 +1066,7 @@ private HashSet selectedKeyHashes { if (m_KeySelection == null) { - m_KeySelection = CreateInstance(); + m_KeySelection = ScriptableObject.CreateInstance(); m_KeySelection.hideFlags = HideFlags.HideAndDontSave; } @@ -884,7 +1076,7 @@ private HashSet selectedKeyHashes { if (m_KeySelection == null) { - m_KeySelection = CreateInstance(); + m_KeySelection = ScriptableObject.CreateInstance(); m_KeySelection.hideFlags = HideFlags.HideAndDontSave; } @@ -948,7 +1140,7 @@ public void DeleteKeys(List keys) curves.Add(keyframe.curve); UnselectKey(keyframe); - keyframe.curve.m_Keyframes.Remove(keyframe); + keyframe.curve.RemoveKeyframe(keyframe); } SaveCurves(activeAnimationClip, curves, kEditCurveUndoLabel); @@ -971,7 +1163,7 @@ public void StartLiveEdit() { LiveEditCurve snapshot = new LiveEditCurve(); snapshot.curve = selectedKey.curve; - foreach (AnimationWindowKeyframe key in selectedKey.curve.m_Keyframes) + foreach (AnimationWindowKeyframe key in selectedKey.curve.keyframes) { LiveEditKeyframe liveEditKey = new LiveEditKeyframe(); liveEditKey.keySnapshot = new AnimationWindowKeyframe(key); @@ -1048,7 +1240,7 @@ public void TransformSelectedKeys(Matrix4x4 matrix, bool flipX, bool flipY, bool if (snapshot.curve.animationIsEditable) { // Transform time value. - Vector3 v = new Vector3(liveEditKey.keySnapshot.time, liveEditKey.keySnapshot.isPPtrCurve ? 0f : (float)liveEditKey.keySnapshot.value, 0f); + Vector3 v = new Vector3(liveEditKey.keySnapshot.time, liveEditKey.keySnapshot.isPPtrCurve || liveEditKey.keySnapshot.isDiscreteCurve ? 0f : (float)liveEditKey.keySnapshot.value, 0f); v = matrix.MultiplyPoint3x4(v); liveEditKey.key.time = Mathf.Max((snapToFrame) ? SnapToFrame(v.x, snapshot.curve.clip.frameRate) : v.x, 0f); @@ -1069,7 +1261,7 @@ public void TransformSelectedKeys(Matrix4x4 matrix, bool flipX, bool flipY, bool liveEditKey.key.outWeight = liveEditKey.keySnapshot.inWeight; } - if (!liveEditKey.key.isPPtrCurve) + if (!liveEditKey.key.isPPtrCurve && !liveEditKey.key.isDiscreteCurve) { liveEditKey.key.value = v.y; @@ -1163,6 +1355,16 @@ public void TransformRippleKeys(Matrix4x4 matrix, float t1, float t2, bool flipX EndLiveEdit(); } + internal static bool CanPasteKeys() + { + return s_KeyframeClipboard != null && s_KeyframeClipboard.Count > 0; + } + + internal static void ClearKeyframeClipboard() + { + s_KeyframeClipboard?.Clear(); + } + public void CopyKeys() { if (s_KeyframeClipboard == null) @@ -1187,13 +1389,19 @@ public void CopyKeys() { CopyAllActiveCurves(); } + + // Animation keyframes right now do not go through regular clipboard machinery, + // so when copying keyframes, make sure regular clipboard is cleared, or things + // get confusing. + if (s_KeyframeClipboard.Count > 0) + Clipboard.stringValue = string.Empty; } public void CopyAllActiveCurves() { foreach (AnimationWindowCurve curve in activeCurves) { - foreach (AnimationWindowKeyframe keyframe in curve.m_Keyframes) + foreach (AnimationWindowKeyframe keyframe in curve.keyframes) { s_KeyframeClipboard.Add(new AnimationWindowKeyframe(keyframe)); } @@ -1269,14 +1477,16 @@ public void PasteKeys() // Only allow pasting of key frame from numerical curves to numerical curves or from pptr curves to pptr curves. if ((newKeyframe.time >= 0.0f) && (newKeyframe.curve != null) && (newKeyframe.curve.isPPtrCurve == keyframe.curve.isPPtrCurve)) { - if (newKeyframe.curve.HasKeyframe(AnimationKeyTime.Time(newKeyframe.time, newKeyframe.curve.clip.frameRate))) - newKeyframe.curve.RemoveKeyframe(AnimationKeyTime.Time(newKeyframe.time, newKeyframe.curve.clip.frameRate)); + var keyTime = AnimationKeyTime.Time(newKeyframe.time, newKeyframe.curve.clip.frameRate); + + if (newKeyframe.curve.HasKeyframe(keyTime)) + newKeyframe.curve.RemoveKeyframe(keyTime); // When copy-pasting multiple keyframes (curve), its a continous thing. This is why we delete the existing keyframes in the pasted range. if (lastTargetCurve == newKeyframe.curve) newKeyframe.curve.RemoveKeysAtRange(lastTime, newKeyframe.time); - newKeyframe.curve.m_Keyframes.Add(newKeyframe); + newKeyframe.curve.AddKeyframe(newKeyframe, keyTime); SelectKey(newKeyframe); // TODO: Optimize to only save curve once instead once per keyframe SaveCurve(newKeyframe.curve.clip, newKeyframe.curve, kEditCurveUndoLabel); @@ -1362,7 +1572,7 @@ private void ReloadModifiedCurveWrapperCache() if (m_ModifiedCurves.Contains(curveWrapper.id)) { - AnimationWindowCurve curve = allCurves.Find(c => c.GetHashCode() == curveWrapper.id); + AnimationWindowCurve curve = filteredCurves.Find(c => c.GetHashCode() == curveWrapper.id); if (curve != null) { // Boundaries have changed, invalidate all curves @@ -1396,9 +1606,9 @@ private void ReloadModifiedCurveWrapperCache() private void ReloadModifiedAnimationCurveCache() { - for (int i = 0; i < allCurves.Count; ++i) + for (int i = 0; i < filteredCurves.Count; ++i) { - AnimationWindowCurve curve = allCurves[i]; + AnimationWindowCurve curve = filteredCurves[i]; if (m_ModifiedCurves.Contains(curve.GetHashCode())) curve.LoadKeyframes(curve.clip); } @@ -1436,7 +1646,7 @@ private void OnNewCurveAdded(EditorCurveBinding newCurve) } // Values do not change whenever a new curve is added, so we force an inspector update here. - controlInterface.ResampleAnimation(); + ResampleAnimation(); m_lastAddedCurveBinding = null; } @@ -1629,16 +1839,16 @@ public float clipFrameRate SaveKeySelection(kEditCurveUndoLabel); // Reposition all keyframes to match the new sampling rate - foreach (var curve in selection.curves) + foreach (var curve in allCurves) { - foreach (var key in curve.m_Keyframes) + foreach (var key in curve.keyframes) { int frame = AnimationKeyTime.Time(key.time, clipFrameRate).frame; key.time = AnimationKeyTime.Frame(frame, value).time; } } - SaveCurves(activeAnimationClip, selection.curves, kEditCurveUndoLabel); + SaveCurves(activeAnimationClip, allCurves, kEditCurveUndoLabel); AnimationEvent[] events = AnimationUtility.GetAnimationEvents(activeAnimationClip); foreach (AnimationEvent ev in events) @@ -1670,9 +1880,19 @@ public float frameRate } } - public AnimationKeyTime time { get { return controlInterface.time; } } - public int currentFrame { get { return time.frame; } set { controlInterface.GoToFrame(value); } } - public float currentTime { get { return time.time; } set { controlInterface.GoToTime(value); } } + public AnimationKeyTime time => AnimationKeyTime.Time(controlInterface.time, frameRate); + + public int currentFrame + { + get => controlInterface.frame; + set => controlInterface.frame = value; + } + + public float currentTime + { + get => controlInterface.time; + set => controlInterface.time = value; + } public TimeArea.TimeFormat timeFormat { get { return AnimationWindowOptions.timeFormat; } set { AnimationWindowOptions.timeFormat = value; } } @@ -1802,5 +2022,44 @@ public float PixelDeltaToTime(Rect rect) { return visibleTimeSpan / rect.width; } + + public void GoToPreviousFrame() + { + controlInterface.frame -= 1; + } + + public void GoToNextFrame() + { + controlInterface.frame += 1; + } + + public void GoToPreviousKeyframe() + { + List curves = (showCurveEditor && activeCurves.Count > 0) ? activeCurves : filteredCurves; + + float newTime = AnimationWindowUtility.GetPreviousKeyframeTime(curves.ToArray(), controlInterface.time, clipFrameRate); + controlInterface.time = SnapToFrame(newTime, SnapMode.SnapToFrame); + } + + public void GoToNextKeyframe() + { + List curves = (showCurveEditor && activeCurves.Count > 0) ? activeCurves : filteredCurves; + + float newTime = AnimationWindowUtility.GetNextKeyframeTime(curves.ToArray(), controlInterface.time, clipFrameRate); + controlInterface.time = SnapToFrame(newTime, AnimationWindowState.SnapMode.SnapToFrame); + } + + public void GoToFirstKeyframe() + { + if (activeAnimationClip) + controlInterface.time = activeAnimationClip.startTime; + } + + public void GoToLastKeyframe() + { + if (activeAnimationClip) + controlInterface.time = activeAnimationClip.stopTime; + } + } } diff --git a/Editor/Mono/Animation/AnimationWindow/AnimationWindowUtility.cs b/Editor/Mono/Animation/AnimationWindow/AnimationWindowUtility.cs index 92d731e609..df9a25a1a8 100644 --- a/Editor/Mono/Animation/AnimationWindow/AnimationWindowUtility.cs +++ b/Editor/Mono/Animation/AnimationWindow/AnimationWindowUtility.cs @@ -16,7 +16,7 @@ namespace UnityEditorInternal { - static internal class AnimationWindowUtility + static class AnimationWindowUtility { public static void SaveCurve(AnimationClip clip, AnimationWindowCurve curve) { @@ -111,11 +111,11 @@ public static void CreateDefaultCurves(AnimationWindowState state, AnimationClip public static AnimationWindowCurve CreateDefaultCurve(AnimationWindowState state, AnimationClip animationClip, EditorCurveBinding binding) { - Type type = state.selection.GetEditorCurveValueType(binding); + Type type = state.controlInterface.GetValueType(binding); AnimationWindowCurve curve = new AnimationWindowCurve(animationClip, binding, type); - object currentValue = CurveBindingUtility.GetCurrentValue(state.activeRootGameObject, binding); + object currentValue = CurveBindingUtility.GetCurrentValue(state, binding); if (animationClip.length == 0.0F) { AddKeyframeToCurve(curve, currentValue, type, AnimationKeyTime.Time(0.0F, animationClip.frameRate)); @@ -138,7 +138,7 @@ public static bool ShouldShowAnimationWindowCurve(EditorCurveBinding curveBindin return true; } - public static bool IsNodeLeftOverCurve(AnimationWindowHierarchyNode node) + public static bool IsNodeLeftOverCurve(AnimationWindowState state, AnimationWindowHierarchyNode node) { if (node.binding != null) { @@ -150,7 +150,7 @@ public static bool IsNodeLeftOverCurve(AnimationWindowHierarchyNode node) if (selectionBinding.rootGameObject == null && selectionBinding.scriptableObject == null) return false; - return selectionBinding.GetEditorCurveValueType((EditorCurveBinding)node.binding) == null; + return state.controlInterface.GetValueType((EditorCurveBinding)node.binding) == null; } } } @@ -159,7 +159,7 @@ public static bool IsNodeLeftOverCurve(AnimationWindowHierarchyNode node) if (node.hasChildren) { foreach (var child in node.children) - return IsNodeLeftOverCurve(child as AnimationWindowHierarchyNode); + return IsNodeLeftOverCurve(state, child as AnimationWindowHierarchyNode); } return false; @@ -200,13 +200,13 @@ public static bool IsNodePhantom(AnimationWindowHierarchyNode node) public static void AddSelectedKeyframes(AnimationWindowState state, AnimationKeyTime time) { - List curves = state.activeCurves.Count > 0 ? state.activeCurves : state.allCurves; + List curves = state.activeCurves.Count > 0 ? state.activeCurves : state.filteredCurves; AddKeyframes(state, curves, time); } public static void AddKeyframes(AnimationWindowState state, IList curves, AnimationKeyTime time) { - string undoLabel = "Add Key"; + string undoLabel = L10n.Tr("Add Key"); state.SaveKeySelection(undoLabel); state.ClearKeySelections(); @@ -230,7 +230,7 @@ public static void AddKeyframes(AnimationWindowState state, IList curves, AnimationKeyTime time) { - string undoLabel = "Remove Key"; + string undoLabel = L10n.Tr("Remove Key"); state.SaveKeySelection(undoLabel); foreach (AnimationWindowCurve curve in curves) @@ -266,9 +266,21 @@ public static AnimationWindowKeyframe AddKeyframeToCurve(AnimationWindowCurve cu keyframe.curve = curve; curve.AddKeyframe(keyframe, time); } + else if (curve.isDiscreteCurve) + { + Keyframe tempKey = new Keyframe(time.time, 0f); + AnimationUtility.SetKeyLeftTangentMode(ref tempKey, TangentMode.Constant); + AnimationUtility.SetKeyRightTangentMode(ref tempKey, TangentMode.Constant); + AnimationUtility.SetKeyBroken(ref tempKey, true); + + keyframe = new AnimationWindowKeyframe(curve, tempKey); + keyframe.value = Convert.ToInt32(value); + + curve.AddKeyframe(keyframe, time); + } else if (type == typeof(bool) || type == typeof(float) || type == typeof(int)) { - Keyframe tempKey = new Keyframe(time.time, (float)value); + Keyframe tempKey = new Keyframe(time.time, Convert.ToSingle(value)); if (type == typeof(bool)) { AnimationUtility.SetKeyLeftTangentMode(ref tempKey, TangentMode.Constant); @@ -280,9 +292,10 @@ public static AnimationWindowKeyframe AddKeyframeToCurve(AnimationWindowCurve cu { // Create temporary curve to get proper tangents AnimationCurve animationCurve = curve.ToAnimationCurve(); + if (animationCurve.length <= 1) { - TangentMode tangentMode = curve.isDiscreteCurve ? TangentMode.Constant : TangentMode.Linear; + TangentMode tangentMode = TangentMode.Linear; AnimationUtility.SetKeyLeftTangentMode(ref tempKey, tangentMode); AnimationUtility.SetKeyRightTangentMode(ref tempKey, tangentMode); } @@ -457,52 +470,40 @@ public static object GetCurrentValue(GameObject rootGameObject, EditorCurveBindi { if (curveBinding.isPPtrCurve) { - Object value; - AnimationUtility.GetObjectReferenceValue(rootGameObject, curveBinding, out value); + AnimationUtility.GetObjectReferenceValue(rootGameObject, curveBinding, out var value); + return value; + } + else if (curveBinding.isDiscreteCurve) + { + AnimationUtility.GetDiscreteIntValue(rootGameObject, curveBinding, out var value); return value; } else { - float value; - AnimationUtility.GetFloatValue(rootGameObject, curveBinding, out value); + AnimationUtility.GetFloatValue(rootGameObject, curveBinding, out var value); return value; } } - public static List GetAnimatableProperties(GameObject gameObject, GameObject root, Type valueType) - { - EditorCurveBinding[] animatable = AnimationUtility.GetAnimatableBindings(gameObject, root); - - List result = new List(); - foreach (EditorCurveBinding binding in animatable) - if (AnimationUtility.GetEditorCurveValueType(root, binding) == valueType) - result.Add(binding); - - return result; - } - - public static List GetAnimatableProperties(GameObject gameObject, GameObject root, Type objectType, Type valueType) + public static EditorCurveBinding[] GetAnimatableBindings(GameObject rootGameObject) { - EditorCurveBinding[] animatable = AnimationUtility.GetAnimatableBindings(gameObject, root); - - List result = new List(); - foreach (EditorCurveBinding binding in animatable) - if (binding.type == objectType && AnimationUtility.GetEditorCurveValueType(root, binding) == valueType) - result.Add(binding); + if (rootGameObject != null) + { + var transforms = rootGameObject.GetComponentsInChildren(); - return result; - } + // At least 10 bindings for Transform (m_LocalPosition, m_LocalRotation, m_LocalScale) and 1 binding for GameObject (m_IsActive) + const int kMinNumberOfBindingsPerGameObject = 11; - public static List GetAnimatableProperties(ScriptableObject scriptableObject, Type valueType) - { - EditorCurveBinding[] animatable = AnimationUtility.GetAnimatableBindings(scriptableObject); + var bindings = new List(transforms.Length * kMinNumberOfBindingsPerGameObject); + for (int i = 0; i < transforms.Length; ++i) + { + bindings.AddRange(AnimationUtility.GetAnimatableBindings(transforms[i].gameObject, rootGameObject)); + } - List result = new List(); - foreach (EditorCurveBinding binding in animatable) - if (AnimationUtility.GetEditorCurveValueType(scriptableObject, binding) == valueType) - result.Add(binding); + return bindings.ToArray(); + } - return result; + return Array.Empty(); } public static bool PropertyIsAnimatable(Object targetObject, string propertyPath, Object rootObject) @@ -614,7 +615,7 @@ public static PropertyModification[] SerializedPropertyToPropertyModifications(S var modification = new PropertyModification(); modification.target = targetObjects[j]; - modification.propertyPath = singleProperty.propertyPath; + modification.propertyPath = (singleProperty.isReferencingAManagedReferenceField ? singleProperty.managedReferencePropertyPath : singleProperty.propertyPath); modification.value = value; modification.objectReference = objectReference; modifications.Add(modification); @@ -632,6 +633,8 @@ public static PropertyModification[] SerializedPropertyToPropertyModifications(S value = propertyIter.floatValue.ToString(CultureInfo.InvariantCulture); else if (isInt) value = propertyIter.intValue.ToString(); + else if (isEnum) + value = propertyIter.enumValueIndex.ToString(); else // if (isBool) value = propertyIter.boolValue ? "1" : "0"; @@ -640,7 +643,7 @@ public static PropertyModification[] SerializedPropertyToPropertyModifications(S var modification = new PropertyModification(); modification.target = targetObjects[j]; - modification.propertyPath = propertyIter.propertyPath; + modification.propertyPath = (propertyIter.isReferencingAManagedReferenceField ? propertyIter.managedReferencePropertyPath : propertyIter.propertyPath); modification.value = value; modification.objectReference = objectReference; modifications.Add(modification); @@ -729,16 +732,23 @@ public static void RenameCurvePath(AnimationWindowCurve curve, EditorCurveBindin } } + private static readonly string k_PositionDisplayName = L10n.Tr("Position"); + private static readonly string k_ScaleDisplayName = L10n.Tr("Scale"); + private static readonly string k_RotationDisplayName = L10n.Tr("Rotation"); + private static readonly string k_MaterialReferenceDisplayName = L10n.Tr("Material Reference"); + // Takes raw animation curve propertyname and makes it pretty public static string GetPropertyDisplayName(string propertyName) { - propertyName = propertyName.Replace("m_LocalPosition", "Position"); - propertyName = propertyName.Replace("m_LocalScale", "Scale"); - propertyName = propertyName.Replace("m_LocalRotation", "Rotation"); - propertyName = propertyName.Replace("localEulerAnglesBaked", "Rotation"); - propertyName = propertyName.Replace("localEulerAnglesRaw", "Rotation"); - propertyName = propertyName.Replace("localEulerAngles", "Rotation"); - propertyName = propertyName.Replace("m_Materials.Array.data", "Material Reference"); + propertyName = propertyName.Replace("m_LocalPosition", k_PositionDisplayName); + propertyName = propertyName.Replace("m_LocalScale", k_ScaleDisplayName); + propertyName = propertyName.Replace("m_LocalRotation", k_RotationDisplayName); + propertyName = propertyName.Replace("localEulerAnglesBaked", k_RotationDisplayName); + propertyName = propertyName.Replace("localEulerAnglesRaw", k_RotationDisplayName); + propertyName = propertyName.Replace("localEulerAngles", k_RotationDisplayName); + propertyName = propertyName.Replace("m_Materials.Array.data", k_MaterialReferenceDisplayName); + if (propertyName.StartsWith("managedReferences[")) + propertyName = propertyName.Remove(0, propertyName.IndexOf('.')+1); propertyName = ObjectNames.NicifyVariableName(propertyName); propertyName = propertyName.Replace("m_", ""); @@ -758,6 +768,29 @@ public static bool ShouldPrefixWithTypeName(Type animatableObjectType, string pr return true; } + public static string GetNicePropertyDisplayName(EditorCurveBinding curveBinding, SerializedObject so) + { + if (curveBinding.isSerializeReferenceCurve) + { + if (so != null) + { + var displayName = curveBinding.propertyName; + var sp = so.FindFirstPropertyFromManagedReferencePath(displayName); + if (sp != null) + displayName = AnimationWindowUtility.GetPropertyDisplayName(AnimationWindowUtility.GetPropertyGroupName(sp.propertyPath)); + if (displayName != "") + return displayName; + } + else + { + return ObjectNames.NicifyVariableName(curveBinding.type.Name) + "." + curveBinding.propertyName; + } + + } + + return AnimationWindowUtility.GetNicePropertyDisplayName(curveBinding.type, AnimationWindowUtility.GetPropertyGroupName(curveBinding.propertyName)); + } + public static string GetNicePropertyDisplayName(Type animatableObjectType, string propertyName) { if (ShouldPrefixWithTypeName(animatableObjectType, propertyName)) @@ -766,6 +799,28 @@ public static string GetNicePropertyDisplayName(Type animatableObjectType, strin return GetPropertyDisplayName(propertyName); } + public static string GetNicePropertyGroupDisplayName(EditorCurveBinding curveBinding, SerializedObject so) + { + if (curveBinding.isSerializeReferenceCurve ) + { + if (so != null) + { + var displayName = curveBinding.propertyName; + var sp = so.FindFirstPropertyFromManagedReferencePath(displayName); + if (sp != null) + displayName = AnimationWindowUtility.GetPropertyDisplayName(AnimationWindowUtility.GetPropertyGroupName(sp.propertyPath)); + if (displayName != "") + return displayName; + } + else + { + return ObjectNames.NicifyVariableName(curveBinding.type.Name) + "." + curveBinding.propertyName; + } + } + + return NicifyPropertyGroupName(curveBinding.type, AnimationWindowUtility.GetPropertyGroupName(curveBinding.propertyName)); + } + public static string GetNicePropertyGroupDisplayName(Type animatableObjectType, string propertyGroupName) { if (ShouldPrefixWithTypeName(animatableObjectType, propertyGroupName)) @@ -780,7 +835,7 @@ public static string NicifyPropertyGroupName(Type animatableObjectType, string p string result = GetPropertyGroupName(GetPropertyDisplayName(propertyGroupName)); // Workaround for uGUI RectTransform which only animates position.z - if (animatableObjectType == typeof(RectTransform) & result.Equals("Position")) + if (animatableObjectType == typeof(RectTransform) && result.Equals("Position")) result = "Position (Z)"; return result; @@ -833,7 +888,7 @@ public static float GetNextKeyframeTime(AnimationWindowCurve[] curves, float cur foreach (AnimationWindowCurve curve in curves) { - foreach (AnimationWindowKeyframe keyframe in curve.m_Keyframes) + foreach (AnimationWindowKeyframe keyframe in curve.keyframes) { AnimationKeyTime keyTime = AnimationKeyTime.Time(keyframe.time, frameRate); if (keyTime.frame <= candidateKeyTime.frame && keyTime.frame >= nextTime.frame) @@ -859,7 +914,7 @@ public static float GetPreviousKeyframeTime(AnimationWindowCurve[] curves, float foreach (AnimationWindowCurve curve in curves) { - foreach (AnimationWindowKeyframe keyframe in curve.m_Keyframes) + foreach (AnimationWindowKeyframe keyframe in curve.keyframes) { AnimationKeyTime keyTime = AnimationKeyTime.Time(keyframe.time, frameRate); if (keyTime.frame >= candidateKeyTime.frame && keyTime.frame <= previousTime.frame) @@ -888,6 +943,7 @@ public static bool InitializeGameobjectForAnimation(GameObject animatedObject) return false; animationPlayer = EnsureActiveAnimationPlayer(animatedObject); + Undo.RecordObject(animationPlayer, "Add animation clip"); bool success = AddClipToAnimationPlayerComponent(animationPlayer, newClip); if (!success) @@ -947,6 +1003,8 @@ public static bool AddClipToAnimatorComponent(Animator animator, AnimationClip n if (controller == null) { controller = UnityEditor.Animations.AnimatorController.CreateAnimatorControllerForClip(newClip, animator.gameObject); + + Undo.RecordObject(animator, "Set Controller"); UnityEditor.Animations.AnimatorController.SetAnimatorController(animator, controller); if (controller != null) @@ -984,7 +1042,7 @@ public static bool AddClipToAnimationComponent(Animation animation, AnimationCli internal static AnimationClip CreateNewClip(string gameObjectName) { // Go forward with presenting user a save clip dialog - string message = string.Format("Create a new animation for the game object '{0}':", gameObjectName); + string message = string.Format(L10n.Tr("Create a new animation for the game object '{0}':"), gameObjectName); string newClipDirectory = ProjectWindowUtil.GetActiveFolderPath(); if (s_LastPathUsedForNewClip != null) { @@ -994,7 +1052,7 @@ internal static AnimationClip CreateNewClip(string gameObjectName) newClipDirectory = directoryPath; } } - string newClipPath = EditorUtility.SaveFilePanelInProject("Create New Animation", "New Animation", "anim", message, newClipDirectory); + string newClipPath = EditorUtility.SaveFilePanelInProject(L10n.Tr("Create New Animation"), "New Animation", "anim", message, newClipDirectory); // If user canceled or save path is invalid, we can't create a clip if (newClipPath == "") @@ -1020,6 +1078,7 @@ internal static AnimationClip CreateNewClipAtPath(string clipPath) if (asset) { + newClip.name = asset.name; EditorUtility.CopySerialized(newClip, asset); AssetDatabase.SaveAssets(); Object.DestroyImmediate(newClip); @@ -1060,13 +1119,23 @@ public static Component GetClosestAnimationPlayerComponentInParents(Transform tr { while (true) { - var animator = tr.GetComponent(); - if (animator != null) + if (tr.TryGetComponent(out Animator animator)) + { return animator; + } - var animation = tr.GetComponent(); - if (animation != null) + if (tr.TryGetComponent(out Animation animation)) + { return animation; + } + + if (tr.TryGetComponent(out IAnimationClipSource clipPlayer)) + { + if (clipPlayer is Component clipPlayerComponent) + { + return clipPlayerComponent; + } + } if (tr == tr.root) break; @@ -1081,7 +1150,10 @@ public static Animator GetClosestAnimatorInParents(Transform tr) { while (true) { - if (tr.GetComponent() != null) return tr.GetComponent(); + if (tr.TryGetComponent(out Animator animator)) + { + return animator; + } if (tr == tr.root) break; tr = tr.parent; } @@ -1093,7 +1165,10 @@ public static Animation GetClosestAnimationInParents(Transform tr) { while (true) { - if (tr.GetComponent() != null) return tr.GetComponent(); + if (tr.TryGetComponent(out Animation animation)) + { + return animation; + } if (tr == tr.root) break; tr = tr.parent; } @@ -1204,6 +1279,10 @@ private static CurveWrapper.PreProcessKeyMovement CreateKeyPreprocessorForCurve( public static CurveWrapper GetCurveWrapper(AnimationWindowCurve curve, AnimationClip clip) { + //Discrete and PPtr curves are not allowed to create curve wrappers. + if (curve.isDiscreteCurve || curve.isPPtrCurve) + return null; + CurveWrapper curveWrapper = new CurveWrapper(); curveWrapper.renderer = CreateRendererForCurve(curve); curveWrapper.preProcessKeyMovementDelegate = CreateKeyPreprocessorForCurve(curve); @@ -1224,8 +1303,8 @@ public static AnimationWindowKeyframe CurveSelectionToAnimationWindowKeyframe(Cu { int curveID = curve.GetHashCode(); if (curveID == curveSelection.curveID) - if (curve.m_Keyframes.Count > curveSelection.key) - return curve.m_Keyframes[curveSelection.key]; + if (curve.keyframes.Count > curveSelection.key) + return curve.keyframes[curveSelection.key]; } return null; @@ -1309,7 +1388,7 @@ public static bool ForceGrouping(EditorCurveBinding binding) if (typeof(Renderer).IsAssignableFrom(binding.type)) { string group = GetPropertyGroupName(binding.propertyName); - return group == "material._Color"; + return group == "material._Color" || group == "material._BaseColor"; } return false; } diff --git a/Editor/Mono/Animation/AnimationWindow/ControlPointRenderer.cs b/Editor/Mono/Animation/AnimationWindow/ControlPointRenderer.cs index 8ea9b1fb61..63c6a6d689 100644 --- a/Editor/Mono/Animation/AnimationWindow/ControlPointRenderer.cs +++ b/Editor/Mono/Animation/AnimationWindow/ControlPointRenderer.cs @@ -97,11 +97,11 @@ public void Render() if (renderChunk.isDirty) { - renderChunk.mesh.vertices = renderChunk.vertices.ToArray(); - renderChunk.mesh.colors32 = renderChunk.colors.ToArray(); - renderChunk.mesh.uv = renderChunk.uvs.ToArray(); + renderChunk.mesh.SetVertices(renderChunk.vertices); + renderChunk.mesh.SetColors(renderChunk.colors); + renderChunk.mesh.SetUVs(0, renderChunk.uvs); - renderChunk.mesh.SetIndices(renderChunk.indices.ToArray(), MeshTopology.Triangles, 0); + renderChunk.mesh.SetIndices(renderChunk.indices, MeshTopology.Triangles, 0); renderChunk.isDirty = false; } diff --git a/Editor/Mono/Animation/AnimationWindow/CurveBindingUtility.cs b/Editor/Mono/Animation/AnimationWindow/CurveBindingUtility.cs index 21ee380a73..6678280c1d 100644 --- a/Editor/Mono/Animation/AnimationWindow/CurveBindingUtility.cs +++ b/Editor/Mono/Animation/AnimationWindow/CurveBindingUtility.cs @@ -9,13 +9,32 @@ namespace UnityEditorInternal { static internal class CurveBindingUtility { + // Current value of the property that rootGO + curveBinding is pointing to + public static object GetCurrentValue(AnimationWindowState state, EditorCurveBinding binding) + { + if (binding.isPPtrCurve) + { + return state.controlInterface.GetObjectReferenceValue(binding); + } + else if (binding.isDiscreteCurve) + { + return state.controlInterface.GetIntValue(binding); + } + + return state.controlInterface.GetFloatValue(binding); + } + + // Retrieve current value. If bindings are available and value is animated, use bindings to get value. // Otherwise, evaluate AnimationWindowCurve at current time. public static object GetCurrentValue(AnimationWindowState state, AnimationWindowCurve curve) { - if (state.previewing && curve.rootGameObject != null) + // UUM-66112 - state.linkedWithSequencer - Padding for issue in Timeline where muscle + // values are not updated in the editor when previewing in the Animation Window. + // Fallback to curve values. + if (state.previewing && curve.rootGameObject != null && !state.linkedWithSequencer) { - return AnimationWindowUtility.GetCurrentValue(curve.rootGameObject, curve.binding); + return GetCurrentValue(state, curve.binding); } else { @@ -37,6 +56,10 @@ public static object GetCurrentValue(GameObject rootGameObject, EditorCurveBindi // Cannot extract type of PPtrCurve. return null; } + else if (curveBinding.isDiscreteCurve) + { + return 0; + } else { // Cannot extract type of AnimationCurve. Default to float. diff --git a/Editor/Mono/Animation/AnimationWindow/CurveEditor.cs b/Editor/Mono/Animation/AnimationWindow/CurveEditor.cs index 7f082fe984..650bd7ee7e 100644 --- a/Editor/Mono/Animation/AnimationWindow/CurveEditor.cs +++ b/Editor/Mono/Animation/AnimationWindow/CurveEditor.cs @@ -217,6 +217,12 @@ internal class CurveEditor : TimeArea, CurveUpdater CurveWrapper[] m_AnimationCurves; static int s_SelectKeyHash = "SelectKeys".GetHashCode(); + private static readonly string k_DeleteKeys = L10n.Tr("Delete Keys"); + private static readonly string k_DeleteKey = L10n.Tr("Delete Key"); + private static readonly string k_EditKeys = L10n.Tr("Edit Keys..."); + private static readonly string k_EditKey = L10n.Tr("Edit Key..."); + private static readonly string k_EditCurve = L10n.Tr("Edit Curve"); + private static readonly string k_AddKey = L10n.Tr("Add Key"); public delegate void CallbackFunction(); @@ -646,13 +652,13 @@ public CurveEditor(Rect rect, CurveWrapper[] curves, bool minimalGUI) : base(min public void OnEnable() { // Only add callback once. - Undo.undoRedoPerformed -= UndoRedoPerformed; - Undo.undoRedoPerformed += UndoRedoPerformed; + Undo.undoRedoEvent -= UndoRedoPerformed; + Undo.undoRedoEvent += UndoRedoPerformed; } public void OnDisable() { - Undo.undoRedoPerformed -= UndoRedoPerformed; + Undo.undoRedoEvent -= UndoRedoPerformed; if (m_PointRenderer != null) m_PointRenderer.FlushCache(); @@ -666,7 +672,7 @@ public void OnDestroy() ScriptableObject.DestroyImmediate(m_Selection); } - void UndoRedoPerformed() + void UndoRedoPerformed(in UndoRedoInfo info) { if (settings.undoRedoSelection) InvalidateSelectionBounds(); @@ -1105,8 +1111,8 @@ public void CurveGUI() m_MenuManager = new CurveMenuManager(this); GenericMenu menu = new GenericMenu(); - string deleteKeyLabel = keyList.Count > 1 ? "Delete Keys" : "Delete Key"; - string editKeyLabel = keyList.Count > 1 ? "Edit Keys..." : "Edit Key..."; + string deleteKeyLabel = keyList.Count > 1 ? k_DeleteKeys : k_DeleteKey; + string editKeyLabel = keyList.Count > 1 ? k_EditKeys : k_EditKey; if (isEditable) { @@ -1158,7 +1164,7 @@ public void CurveGUI() DrawCurvesTangents(); DrawCurvesOverlay(); - m_RectangleTool.OverlayOnGUI(); + m_RectangleTool.OverlayOnGUI(rect); EditSelectedPoints(); } @@ -1290,7 +1296,7 @@ void DragTangents() if (m_SelectedTangentPoint != null) { - SaveKeySelection("Edit Curve"); + SaveKeySelection(k_EditCurve); GUIUtility.hotControl = tangentId; evt.Use(); @@ -1320,11 +1326,16 @@ void DragTangents() key.inTangent = tangentDirection.y / tangentDirection.x; key.inWeight = Mathf.Clamp(Mathf.Abs(tangentDirection.x / dx), 0f, 1f); } - else + else if (tangentDirection.y > 0) { key.inTangent = Mathf.Infinity; key.inWeight = 0f; } + else + { + key.inTangent = -Mathf.Infinity; + key.inWeight = 0f; + } AnimationUtility.SetKeyLeftTangentMode(ref key, TangentMode.Free); if (!AnimationUtility.GetKeyBroken(key)) @@ -1344,11 +1355,16 @@ void DragTangents() key.outTangent = tangentDirection.y / tangentDirection.x; key.outWeight = Mathf.Clamp(Mathf.Abs(tangentDirection.x / dx), 0f, 1f); } - else + else if (tangentDirection.y > 0) { key.outTangent = Mathf.Infinity; key.outWeight = 0f; } + else + { + key.outTangent = -Mathf.Infinity; + key.outWeight = 0f; + } AnimationUtility.SetKeyRightTangentMode(ref key, TangentMode.Free); if (!AnimationUtility.GetKeyBroken(key)) @@ -1390,9 +1406,9 @@ internal void DeleteSelectedKeys() { string undoLabel; if (selectedCurves.Count > 1) - undoLabel = "Delete Keys"; + undoLabel = k_DeleteKeys; else - undoLabel = "Delete Key"; + undoLabel = k_DeleteKey; SaveKeySelection(undoLabel); @@ -1408,7 +1424,7 @@ internal void DeleteSelectedKeys() continue; if (!settings.allowDeleteLastKeyInCurve) - if (cw.curve.keys.Length == 1) + if (cw.curve.length == 1) continue; cw.curve.RemoveKey(k.key); @@ -1427,9 +1443,9 @@ private void DeleteKeys(object obj) string undoLabel; if (keyList.Count > 1) - undoLabel = "Delete Keys"; + undoLabel = k_DeleteKeys; else - undoLabel = "Delete Key"; + undoLabel = k_DeleteKey; SaveKeySelection(undoLabel); @@ -1438,7 +1454,7 @@ private void DeleteKeys(object obj) for (int i = keyList.Count - 1; i >= 0; i--) { if (!settings.allowDeleteLastKeyInCurve) - if (keyList[i].curve.keys.Length == 1) + if (keyList[i].curve.length == 1) continue; if (!GetCurveWrapperFromID(keyList[i].curveId).animationIsEditable) @@ -1788,6 +1804,9 @@ float SnapValue(float v) new internal static class Styles { + public const float pointIconCenterOffsetX = 7; + public const float pointIconCenterOffsetY = 8; + public const float pointIconSize = 16; public static Texture2D pointIcon = EditorGUIUtility.LoadIcon("curvekeyframe"); public static Texture2D pointIconWeighted = EditorGUIUtility.LoadIcon("curvekeyframeweighted"); public static Texture2D pointIconSelected = EditorGUIUtility.LoadIcon("curvekeyframeselected"); @@ -1903,7 +1922,7 @@ int GetCurveAtPosition(Vector2 viewPos, out Vector2 closestPointOnCurve) void CreateKeyFromClick(object obj) { - string undoLabel = "Add Key"; + string undoLabel = k_AddKey; SaveKeySelection(undoLabel); List ids = CreateKeyFromClick((Vector2)obj); @@ -1924,7 +1943,7 @@ List CreateKeyFromClick(Vector2 viewPos) CurveWrapper cw = m_AnimationCurves[singleCurveIndex]; Vector2 localPos = ViewToDrawingTransformPoint(viewPos); float time = localPos.x; - if (cw.curve.keys.Length == 0 || time < cw.curve.keys[0].time || time > cw.curve.keys[cw.curve.keys.Length - 1].time) + if (cw.curve.length == 0 || time < cw.curve[0].time || time > cw.curve[cw.curve.length - 1].time) { if (CreateKeyFromClick(singleCurveIndex, localPos)) curveIds.Add(cw.id); @@ -2142,9 +2161,10 @@ CurveSelection FindNearest() if (cw.readOnly || cw.hidden) continue; - for (int i = 0; i < cw.curve.keys.Length; ++i) + Keyframe[] keys = cw.curve.keys; + for (int i = 0; i < cw.curve.length; ++i) { - Keyframe k = cw.curve.keys[i]; + Keyframe k = keys[i]; float d = (GetGUIPoint(cw, new Vector2(k.time, k.value)) - mousePos).sqrMagnitude; // If we have an exact hit we just return that key if (d <= kExactPickDistSqr) @@ -2260,7 +2280,7 @@ bool HandleCurveAndRegionMoveToFrontOnMouseDown(ref Vector2 timeValue, ref Curve if (mouseY >= v1 && mouseY <= v2) { timeValue = mousePositionInDrawing; - curves = new[] {cw, cw2}; + curves = new[] { cw, cw2 }; MoveCurveToFront(cw.id); return true; } @@ -2320,7 +2340,7 @@ void SelectPoints() if (curve != null) { BeginRangeSelection(); - for (int keyIndex = 0; keyIndex < curve.keys.Length; ++keyIndex) + for (int keyIndex = 0; keyIndex < curve.length; ++keyIndex) { if (!selectedCurves.Any(x => x.curveID == selectedPoint.curveID && x.key == keyIndex)) { @@ -2333,7 +2353,7 @@ void SelectPoints() } else { - SaveKeySelection("Add Key"); + SaveKeySelection(k_AddKey); List curveIds = CreateKeyFromClick(Event.current.mousePosition); if (curveIds.Count > 0) @@ -3052,7 +3072,7 @@ void ResetDragging() void MakeCurveBackups() { - SaveKeySelection("Edit Curve"); + SaveKeySelection(k_EditCurve); m_CurveBackups = new List(); int lastCurveID = -1; @@ -3102,6 +3122,7 @@ Vector2 GetPosition(CurveSelection selection) { Vector2 dir = new Vector2(1.0F, key.inTangent); if (key.inTangent == Mathf.Infinity) dir = new Vector2(0, -1); + else if (key.inTangent == -Mathf.Infinity) dir = new Vector2(0, 1); Vector2 viewDir = NormalizeInViewSpace(dir); @@ -3125,6 +3146,7 @@ Vector2 GetPosition(CurveSelection selection) { Vector2 dir = new Vector2(1.0F, key.outTangent); if (key.outTangent == Mathf.Infinity) dir = new Vector2(0, -1); + else if (key.outTangent == -Mathf.Infinity) dir = new Vector2(0, 1); Vector2 viewDir = NormalizeInViewSpace(dir); @@ -3681,7 +3703,7 @@ void DrawPoint(Vector2 viewPos, CurveWrapper.SelectionMode selected, MouseCursor { // Important to take floor of positions of GUI stuff to get pixel correct alignment of // stuff drawn with both GUI and Handles/GL. Otherwise things are off by one pixel half the time. - var rect = new Rect(Mathf.Floor(viewPos.x) - 4, Mathf.Floor(viewPos.y) - 4, Styles.pointIcon.width, Styles.pointIcon.height); + var rect = new Rect(Mathf.Floor(viewPos.x) - Styles.pointIconCenterOffsetX, Mathf.Floor(viewPos.y) - Styles.pointIconCenterOffsetY, Styles.pointIconSize, Styles.pointIconSize); if (selected == CurveWrapper.SelectionMode.None) { @@ -3707,7 +3729,7 @@ void DrawTangentPoint(Vector2 viewPos, bool weighted) { // Important to take floor of positions of GUI stuff to get pixel correct alignment of // stuff drawn with both GUI and Handles/GL. Otherwise things are off by one pixel half the time. - var rect = new Rect(Mathf.Floor(viewPos.x) - 4, Mathf.Floor(viewPos.y) - 4, Styles.pointIcon.width, Styles.pointIcon.height); + var rect = new Rect(Mathf.Floor(viewPos.x) - Styles.pointIconCenterOffsetX, Mathf.Floor(viewPos.y) - Styles.pointIconCenterOffsetY, Styles.pointIconSize, Styles.pointIconSize); if (weighted) { @@ -3815,7 +3837,6 @@ WrapMode WrapModeIconPopup(Keyframe key, WrapMode oldWrap, float hOffset) { r.y = r.y - selectedPopupIndex * 16 - 19; } - EditorGUI.PopupCallbackInfo.instance = new EditorGUI.PopupCallbackInfo(controlID); EditorUtility.DisplayCustomMenu(r, popupStrings, selectedPopupIndex, EditorGUI.PopupCallbackInfo.instance.SetEnumValueDelegate, null); GUIUtility.keyboardControl = controlID; @@ -3829,7 +3850,6 @@ WrapMode WrapModeIconPopup(Keyframe key, WrapMode oldWrap, float hOffset) { r.y = r.y - selectedPopupIndex * 16 - 19; } - EditorGUI.PopupCallbackInfo.instance = new EditorGUI.PopupCallbackInfo(controlID); EditorUtility.DisplayCustomMenu(r, popupStrings, selectedPopupIndex, EditorGUI.PopupCallbackInfo.instance.SetEnumValueDelegate, null); evt.Use(); @@ -4077,7 +4097,7 @@ public void GridGUI() float[] ticksPos = (float[])ticks.Clone(); // Calculate how many decimals are needed to show the differences between the labeled ticks - int decimals = MathUtils.GetNumberOfDecimalsForMinimumDifference(vTicks.GetPeriodOfLevel(labelLevel)); + int decimals = MathUtils.GetNumberOfDecimalsForMinimumDifference(vTicks.GetPeriodOfLevel(labelLevel)); string format = "n" + decimals; m_AxisLabelFormat = format; diff --git a/Editor/Mono/Animation/AnimationWindow/CurveEditorRectangleTool.cs b/Editor/Mono/Animation/AnimationWindow/CurveEditorRectangleTool.cs index a78a744486..267c9616ee 100644 --- a/Editor/Mono/Animation/AnimationWindow/CurveEditorRectangleTool.cs +++ b/Editor/Mono/Animation/AnimationWindow/CurveEditorRectangleTool.cs @@ -554,7 +554,7 @@ public void OnGUI() GUI.color = oldColor; } - public void OverlayOnGUI() + public void OverlayOnGUI(Rect bounds) { if (!hasSelection) return; @@ -578,7 +578,7 @@ public void OverlayOnGUI() m_VBarTop.OnGUI(m_Layout.vBarTopRect); } - DrawLabels(); + DrawLabels(bounds); GUI.color = oldColor; } @@ -763,7 +763,7 @@ private ToolLayout CalculateLayout() return layout; } - private void DrawLabels() + private void DrawLabels(Rect bounds) { if (dragMode == DragMode.None) return; @@ -793,7 +793,6 @@ private void DrawLabels() { GUIContent labelContent = new GUIContent(string.Format("{0}", m_CurveEditor.FormatTime(selectionBounds.center.x, m_CurveEditor.invSnap, m_CurveEditor.timeFormat))); Vector2 labelSize = styles.dragLabel.CalcSize(labelContent); - EditorGUI.DoDropShadowLabel(new Rect(m_Layout.leftLabelAnchor.x, m_Layout.leftLabelAnchor.y, labelSize.x, labelSize.y), labelContent, styles.dragLabel, 0.3f); } } @@ -831,7 +830,14 @@ private void DrawLabels() GUIContent labelContent = new GUIContent(string.Format("{0}, {1}", m_CurveEditor.FormatTime(localPosition.x, m_CurveEditor.invSnap, m_CurveEditor.timeFormat), m_CurveEditor.FormatValue(localPosition.y))); Vector2 labelSize = styles.dragLabel.CalcSize(labelContent); - EditorGUI.DoDropShadowLabel(new Rect(labelPosition.x, labelPosition.y - labelSize.y, labelSize.x, labelSize.y), labelContent, styles.dragLabel, 0.3f); + // Clamp popup to remain inside the curve editor window + var labelRect = new Rect(labelPosition.x, labelPosition.y - labelSize.y, labelSize.x, labelSize.y); + labelRect.x += Mathf.Max(0.0f, bounds.xMin - labelRect.xMin); + labelRect.x -= Mathf.Max(0.0f, labelRect.xMax - bounds.xMax); + labelRect.y += Mathf.Max(0.0f, bounds.yMin - labelRect.yMin); + labelRect.y -= Mathf.Max(0.0f, labelRect.yMax - bounds.yMax); + + EditorGUI.DoDropShadowLabel(labelRect, labelContent, styles.dragLabel, 0.3f); } } } diff --git a/Editor/Mono/Animation/AnimationWindow/CurveEditorWindow.cs b/Editor/Mono/Animation/AnimationWindow/CurveEditorWindow.cs index 00a8a9099d..0de9352fa1 100644 --- a/Editor/Mono/Animation/AnimationWindow/CurveEditorWindow.cs +++ b/Editor/Mono/Animation/AnimationWindow/CurveEditorWindow.cs @@ -30,12 +30,13 @@ public enum NormalizationMode } //const int kToolbarHeight = 17; - const int kPresetsHeight = 46; + const int kPresetsHeight = 50; static CurveEditorWindow s_SharedCurveEditor; - CurveEditor m_CurveEditor; + internal CurveEditor m_CurveEditor; + Vector2 m_PresetScrollPosition; AnimationCurve m_Curve; Color m_Color; @@ -43,11 +44,14 @@ public enum NormalizationMode GUIContent m_GUIContent = new GUIContent(); [SerializeField] - GUIView delegateView; + GUIView m_DelegateView; public const string CurveChangedCommand = "CurveChanged"; public const string CurveChangeCompletedCommand = "CurveChangeCompleted"; + // Watch out when accessing this, it will create a new curve editor window if none exists yet. + // If you don't display the window (call Show()), it will cause an error when validating the layout + // (e.g. when the user maximizes a window). public static CurveEditorWindow instance { get @@ -99,6 +103,11 @@ public static Color color } } + internal static GUIView delegateView + { + get { return visible ? CurveEditorWindow.instance.m_DelegateView : null; } + } + public static bool visible { get { return s_SharedCurveEditor != null; } @@ -269,7 +278,7 @@ private void RefreshShownCurves() public void Show(GUIView viewToUpdate, CurveEditorSettings settings) { - delegateView = viewToUpdate; + m_DelegateView = viewToUpdate; m_OnCurveChanged = null; Init(settings); @@ -281,7 +290,7 @@ public void Show(GUIView viewToUpdate, CurveEditorSettings settings) public void Show(Action onCurveChanged, CurveEditorSettings settings) { m_OnCurveChanged = onCurveChanged; - delegateView = null; + m_DelegateView = null; Init(settings); ShowAuxWindow(); @@ -451,7 +460,7 @@ void OnGUI() { bool gotMouseUp = (Event.current.type == EventType.MouseUp); - if (delegateView == null && m_OnCurveChanged == null) + if (m_DelegateView == null && m_OnCurveChanged == null) m_Curve = null; if (ms_Styles == null) @@ -468,20 +477,38 @@ void OnGUI() m_CurveEditor.OnGUI(); // Preset swatch area - GUI.Box(new Rect(0, position.height - kPresetsHeight, position.width, kPresetsHeight), "", ms_Styles.curveSwatchArea); + var presetRect = new Rect(0, position.height - kPresetsHeight, position.width, kPresetsHeight); + GUI.Box(presetRect, "", ms_Styles.curveSwatchArea); + Color curveColor = m_Color; curveColor.a *= 0.6f; - const float margin = 45f; const float width = 40f; const float height = 25f; - float yPos = position.height - kPresetsHeight + (kPresetsHeight - height) * 0.5f; + const float spaceBetweenSwatches = 5f; + const float presetDropdownSize = 16f; + const float horizontalScrollbarHeight = 15f; + const float presetDropdownCenteringOffset = 2f; + float yPos = (kPresetsHeight - height) * 0.5f; InitCurvePresets(); CurvePresetLibrary curveLibrary = m_CurvePresets.GetPresetLibraryEditor().GetCurrentLib(); if (curveLibrary != null) { - for (int i = 0; i < curveLibrary.Count(); i++) + var numPresets = curveLibrary.Count(); + var presetDropDownRect = new Rect(spaceBetweenSwatches, yPos + presetDropdownCenteringOffset, presetDropdownSize, presetDropdownSize); + Rect contentRect = new Rect(0, 0, numPresets * (width + spaceBetweenSwatches) + presetDropDownRect.xMax, presetRect.height - horizontalScrollbarHeight); + m_PresetScrollPosition = GUI.BeginScrollView( + presetRect, // Rectangle of the visible area + m_PresetScrollPosition, // Current scroll position + contentRect, // Rectangle containing all content + false, // Always show horizontal scrollbar + false // Always show vertical scrollbar + ); + + PresetDropDown(presetDropDownRect); + + Rect swatchRect = new Rect(presetDropDownRect.xMax + spaceBetweenSwatches, yPos, width, height); + for (int i = 0; i < numPresets; i++) { - Rect swatchRect = new Rect(margin + (width + 5f) * i, yPos, width, height); m_GUIContent.tooltip = curveLibrary.GetName(i); if (GUI.Button(swatchRect, m_GUIContent, ms_Styles.curveSwatch)) { @@ -495,14 +522,11 @@ void OnGUI() if (Event.current.type == EventType.Repaint) curveLibrary.Draw(swatchRect, i); - if (swatchRect.xMax > position.width - 2 * margin) - break; + swatchRect.x += width + spaceBetweenSwatches; } + GUI.EndScrollView(); } - Rect presetDropDownButtonRect = new Rect(margin - 20f, yPos + 5f, 20, 20); - PresetDropDown(presetDropDownButtonRect); - // For adding default preset curves //if (EditorGUI.DropdownButton(new Rect (position.width -26, yPos, 20, 20), GUIContent.none, FocusType.Passive, "OL Plus")) // AddDefaultPresetsToCurrentLib (); @@ -576,11 +600,11 @@ private void DoUpdateCurve(bool exitGUI) void SendEvent(string eventName, bool exitGUI) { - if (delegateView) + if (m_DelegateView) { Event e = EditorGUIUtility.CommandEvent(eventName); Repaint(); - delegateView.SendEvent(e); + m_DelegateView.SendEvent(e); if (exitGUI) GUIUtility.ExitGUI(); } diff --git a/Editor/Mono/Animation/AnimationWindow/CurveRenderer/NormalCurveRenderer.cs b/Editor/Mono/Animation/AnimationWindow/CurveRenderer/NormalCurveRenderer.cs index e18bb8552d..dde6db2ac8 100644 --- a/Editor/Mono/Animation/AnimationWindow/CurveRenderer/NormalCurveRenderer.cs +++ b/Editor/Mono/Animation/AnimationWindow/CurveRenderer/NormalCurveRenderer.cs @@ -20,8 +20,8 @@ internal class NormalCurveRenderer : CurveRenderer private AnimationCurve m_Curve; private float m_CustomRangeStart = 0; private float m_CustomRangeEnd = 0; - private float rangeStart { get { return (m_CustomRangeStart == 0 && m_CustomRangeEnd == 0 && m_Curve.length > 0 ? m_Curve.keys[0].time : m_CustomRangeStart); } } - private float rangeEnd { get { return (m_CustomRangeStart == 0 && m_CustomRangeEnd == 0 && m_Curve.length > 0 ? m_Curve.keys[m_Curve.length - 1].time : m_CustomRangeEnd); } } + private float rangeStart { get { return (m_CustomRangeStart == 0 && m_CustomRangeEnd == 0 && m_Curve.length > 0 ? m_Curve[0].time : m_CustomRangeStart); } } + private float rangeEnd { get { return (m_CustomRangeStart == 0 && m_CustomRangeEnd == 0 && m_Curve.length > 0 ? m_Curve[m_Curve.length - 1].time : m_CustomRangeEnd); } } private WrapMode preWrapMode = WrapMode.Once; private WrapMode postWrapMode = WrapMode.Once; @@ -262,11 +262,14 @@ public void DrawCurve(float minTime, float maxTime, Color color, Matrix4x4 trans { BuildCurveMesh(); - Keyframe[] keys = m_Curve.keys; - if (keys.Length > 0) + int numKeys = m_Curve.length; + int first = 0; + int last = Mathf.Max(first, numKeys - 1); + + if (numKeys > 0) { - Vector3 firstPoint = new Vector3(rangeStart, keys.First().value); - Vector3 lastPoint = new Vector3(rangeEnd, keys.Last().value); + Vector3 firstPoint = new Vector3(rangeStart, m_Curve[first].value); + Vector3 lastPoint = new Vector3(rangeEnd, m_Curve[last].value); DrawCurveWrapped(minTime, maxTime, rangeStart, rangeEnd, preWrapMode, postWrapMode, m_CurveMesh, firstPoint, lastPoint, transform, color, wrapColor); } } diff --git a/Editor/Mono/Animation/AnimationWindow/Deprecated/AnimationEventTimeline.cs b/Editor/Mono/Animation/AnimationWindow/Deprecated/AnimationEventTimeline.cs index 83ac70c0c1..48b2e83421 100644 --- a/Editor/Mono/Animation/AnimationWindow/Deprecated/AnimationEventTimeline.cs +++ b/Editor/Mono/Animation/AnimationWindow/Deprecated/AnimationEventTimeline.cs @@ -27,12 +27,13 @@ internal static class Styles private AnimationEvent[] m_EventsAtMouseDown; [System.NonSerialized] private float[] m_EventTimes; + private static readonly Vector2 k_EventMarkerSize = new Vector2(16, 16); private bool m_DirtyTooltip = false; private int m_HoverEvent = -1; - // Rects used for checking mouse-move state changes private string m_InstantTooltipText = null; private Vector2 m_InstantTooltipPoint = Vector2.zero; + private bool m_HasSelectedEvents; public AnimationEventTimeLine(EditorWindow owner) { @@ -53,7 +54,7 @@ public int Compare(AnimationEvent x, AnimationEvent y) } } - private class EventLineContextMenuObject + private struct EventLineContextMenuObject { public GameObject m_Animated; public AnimationClip m_Clip; @@ -71,6 +72,8 @@ public EventLineContextMenuObject(GameObject animated, AnimationClip clip, float } } + internal bool HasSelectedEvents => m_HasSelectedEvents; + public void AddEvent(float time, GameObject gameObject, AnimationClip animationClip) { AnimationWindowEvent awEvent = AnimationWindowEvent.CreateAndEdit(gameObject, animationClip, time); @@ -141,7 +144,7 @@ void CopyEvents(AnimationClip clip, bool[] selected, int explicitIndex = -1) AnimationWindowEventsClipboard.CopyEvents(allEvents, selected, explicitIndex); } - void PasteEvents(GameObject animated, AnimationClip clip, float time) + internal void PasteEvents(GameObject animated, AnimationClip clip, float time) { var oldEvents = AnimationUtility.GetAnimationEvents(clip); var newEvents = AnimationWindowEventsClipboard.AddPastedEvents(oldEvents, time, out var selected); @@ -199,15 +202,15 @@ public void EventLineGUI(Rect rect, AnimationWindowState state) int sharedOffset = 0; if (shared > 1) { - float spread = Mathf.Min((shared - 1) * (eventMarker.width - 1), (int)(state.FrameDeltaToPixel(rect) - eventMarker.width * 2)); - sharedOffset = Mathf.FloorToInt(Mathf.Max(0, spread - (eventMarker.width - 1) * (sharedLeft))); + float spread = Mathf.Min((shared - 1) * (k_EventMarkerSize.x - 1), (int)(state.FrameDeltaToPixel(rect) - k_EventMarkerSize.x * 2)); + sharedOffset = Mathf.FloorToInt(Mathf.Max(0, spread - (k_EventMarkerSize.x - 1) * (sharedLeft))); } Rect r = new Rect( - keypos + sharedOffset - eventMarker.width / 2, + keypos + sharedOffset - k_EventMarkerSize.x / 2, (rect.height - 10) * (float)(sharedLeft - shared + 1) / Mathf.Max(1, shared - 1), - eventMarker.width, - eventMarker.height); + k_EventMarkerSize.x, + k_EventMarkerSize.y); hitRects[i] = r; drawRects[i] = r; @@ -225,6 +228,7 @@ public void EventLineGUI(Rect rect, AnimationWindowState state) } bool[] selectedEvents = new bool[events.Length]; + m_HasSelectedEvents = false; Object[] selectedObjects = Selection.objects; foreach (Object selectedObject in selectedObjects) @@ -235,6 +239,7 @@ public void EventLineGUI(Rect rect, AnimationWindowState state) if (awe.eventIndex >= 0 && awe.eventIndex < selectedEvents.Length) { selectedEvents[awe.eventIndex] = true; + m_HasSelectedEvents = true; } } } diff --git a/Editor/Mono/Animation/AnimationWindow/DopeLine.cs b/Editor/Mono/Animation/AnimationWindow/DopeLine.cs index c576b1cf2c..da6b52f5f0 100644 --- a/Editor/Mono/Animation/AnimationWindow/DopeLine.cs +++ b/Editor/Mono/Animation/AnimationWindow/DopeLine.cs @@ -98,7 +98,7 @@ public List keys { m_Keys = new List(); foreach (AnimationWindowCurve curve in m_Curves) - foreach (AnimationWindowKeyframe key in curve.m_Keyframes) + foreach (AnimationWindowKeyframe key in curve.keyframes) m_Keys.Add(key); m_Keys.Sort((a, b) => a.time.CompareTo(b.time)); diff --git a/Editor/Mono/Animation/AnimationWindow/DopeSheetEditor.cs b/Editor/Mono/Animation/AnimationWindow/DopeSheetEditor.cs index 4ad6ddec5e..ae4b219977 100644 --- a/Editor/Mono/Animation/AnimationWindow/DopeSheetEditor.cs +++ b/Editor/Mono/Animation/AnimationWindow/DopeSheetEditor.cs @@ -9,13 +9,14 @@ using Event = UnityEngine.Event; using Object = UnityEngine.Object; using System.Collections; +using System.Linq; namespace UnityEditorInternal { [System.Serializable] - internal class DopeSheetEditor : TimeArea, CurveUpdater + class DopeSheetEditor : TimeArea, CurveUpdater { - public AnimationWindowState state; + [SerializeReference] public AnimationWindowState state; // How much rendered keyframe left edge is visually offset when compared to the time it represents. // A diamond shape left edge isn't representing the time, the middle part is. @@ -23,6 +24,8 @@ internal class DopeSheetEditor : TimeArea, CurveUpdater // Pptr keyframe preview also needs 1px offset so it sits more tightly in the grid private const float k_PptrKeyframeOffset = -1; + private static readonly Vector2 k_ControlPointSize = new Vector2(16, 16); + const int kLabelMarginHorizontal = 8; const int kLabelMarginVertical = 2; @@ -148,7 +151,7 @@ public void AddUnselectedKey(DrawElement element) else { Rect rect = element.position; - rect.size = new Vector2(m_DefaultDopeKeyIcon.width, m_DefaultDopeKeyIcon.height); + rect.size = k_ControlPointSize; m_UnselectedKeysRenderer.AddPoint(rect, element.color); } } @@ -164,7 +167,7 @@ public void AddSelectedKey(DrawElement element) else { Rect rect = element.position; - rect.size = new Vector2(m_DefaultDopeKeyIcon.width, m_DefaultDopeKeyIcon.height); + rect.size = k_ControlPointSize; m_SelectedKeysRenderer.AddPoint(rect, element.color); } } @@ -180,7 +183,7 @@ public void AddDragDropKey(DrawElement element) else { Rect rect = element.position; - rect.size = new Vector2(m_DefaultDopeKeyIcon.width, m_DefaultDopeKeyIcon.height); + rect.size = k_ControlPointSize; m_DragDropKeysRenderer.AddPoint(rect, element.color); } } @@ -493,7 +496,7 @@ private void DopeLineRepaint(DopeLine dopeline) if (DoDragAndDrop(dopeline, dopeline.position, false)) { - float time = Mathf.Max(state.PixelToTime(Event.current.mousePosition.x, AnimationWindowState.SnapMode.SnapToClipFrame), 0f); + float time = Mathf.Max(state.PixelToTime(Event.current.mousePosition.x, AnimationWindowState.SnapMode.SnapToFrame), 0f); Color keyColor = Color.gray.RGBMultiplied(1.2f); Texture2D texture = null; @@ -561,15 +564,15 @@ private GenericMenu GenerateMenu(DopeLine dopeline) hoveringKeys.Add(key); } - AnimationKeyTime mouseKeyTime = AnimationKeyTime.Time(state.PixelToTime(Event.current.mousePosition.x, AnimationWindowState.SnapMode.SnapToClipFrame), state.frameRate); + AnimationKeyTime mouseKeyTime = AnimationKeyTime.Time(state.PixelToTime(Event.current.mousePosition.x, AnimationWindowState.SnapMode.SnapToFrame), state.frameRate); - string str = "Add Key"; + string str = L10n.Tr("Add Key"); if (dopeline.isEditable && hoveringKeys.Count == 0) menu.AddItem(new GUIContent(str), false, AddKeyToDopeline, new AddKeyToDopelineContext {dopeline = dopeline, time = mouseKeyTime}); else menu.AddDisabledItem(new GUIContent(str)); - str = state.selectedKeys.Count > 1 ? "Delete Keys" : "Delete Key"; + str = state.selectedKeys.Count > 1 ? L10n.Tr("Delete Keys") : L10n.Tr("Delete Key"); if (dopeline.isEditable && (state.selectedKeys.Count > 0 || hoveringKeys.Count > 0)) menu.AddItem(new GUIContent(str), false, DeleteKeys, state.selectedKeys.Count > 0 ? state.selectedKeys : hoveringKeys); else @@ -638,7 +641,7 @@ private void HandleDragging() foreach (AnimationWindowKeyframe selectedKey in state.selectedKeys) firstSelectedKeyTime = Mathf.Min(selectedKey.time, firstSelectedKeyTime); - float currentTime = state.SnapToFrame(state.PixelToTime(Event.current.mousePosition.x), AnimationWindowState.SnapMode.SnapToClipFrame); + float currentTime = state.SnapToFrame(state.PixelToTime(Event.current.mousePosition.x), AnimationWindowState.SnapMode.SnapToFrame); if (m_IsDragging) { @@ -773,9 +776,7 @@ private void HandleDragAndDropToEmptyArea() { EditorCurveBinding? spriteBinding = CreateNewPptrDopeline(state.selection, typeof(Sprite)); if (spriteBinding != null) - { DoSpriteDropAfterGeneratingNewDopeline(state.activeAnimationClip, spriteBinding); - } } DragAndDrop.visualMode = DragAndDropVisualMode.Copy; @@ -792,8 +793,35 @@ private void DoSpriteDropAfterGeneratingNewDopeline(AnimationClip animationClip, // Create the new curve for our sprites AnimationWindowCurve newCurve = new AnimationWindowCurve(animationClip, (EditorCurveBinding)spriteBinding, typeof(Sprite)); - // And finally perform the drop onto the curve + // Perform the drop onto the curve PerformDragAndDrop(newCurve, 0f); + + // Assign the Sprite in the first keyframe to the SpriteRenderer's Sprite property + AssignSpriteToSpriteRenderer(newCurve); + } + + private void AssignSpriteToSpriteRenderer(AnimationWindowCurve curve) + { + var rootGameObject = state.selection.rootGameObject; + if (rootGameObject == null) + return; + + var hasValidCurve = curve.keyframes.Count > 0 && curve.binding.type == typeof(SpriteRenderer); + if (!hasValidCurve) + return; + + var spriteRenderer = AnimationUtility.GetAnimatedObject(rootGameObject, curve.binding) as SpriteRenderer; + var hasValidSpriteRenderer = spriteRenderer != null && spriteRenderer.sprite == null; + if (!hasValidSpriteRenderer) + return; + + var keyframe = curve.keyframes[0]; + var sprite = keyframe.value as Sprite; + if (sprite != null) + { + Undo.RecordObject(spriteRenderer, "Add Sprite"); + spriteRenderer.sprite = sprite; + } } private void HandleRectangleToolEvents() @@ -803,29 +831,46 @@ private void HandleRectangleToolEvents() private bool DopelineForValueTypeExists(Type valueType) { - return state.allCurves.Exists(curve => curve.valueType == valueType); + return state.filteredCurves.Exists(curve => curve.valueType == valueType); + } + + public EditorCurveBinding[] GetAnimatableProperties(AnimationWindowSelectionItem selection, Type valueType) + { + EditorCurveBinding[] allBindings = null; + if (selection.gameObject != null) + { + allBindings = state.controlInterface.GetAnimatableBindings(selection.gameObject); + } + else if (selection.scriptableObject != null) + { + allBindings = state.controlInterface.GetAnimatableBindings(); + } + + return allBindings + .Where(binding => state.controlInterface.GetValueType(binding) == valueType) + .ToArray(); } private EditorCurveBinding? CreateNewPptrDopeline(AnimationWindowSelectionItem selectedItem, Type valueType) { - List potentialBindings = null; + EditorCurveBinding[] potentialBindings = null; if (selectedItem.rootGameObject != null) { - potentialBindings = AnimationWindowUtility.GetAnimatableProperties(selectedItem.rootGameObject, selectedItem.rootGameObject, valueType); - if (potentialBindings.Count == 0 && valueType == typeof(Sprite)) // No animatable properties for Sprite available. Default as SpriteRenderer. + potentialBindings = GetAnimatableProperties(selectedItem, valueType); + if (potentialBindings.Length == 0 && valueType == typeof(Sprite)) // No animatable properties for Sprite available. Default as SpriteRenderer. { return CreateNewSpriteRendererDopeline(selectedItem.rootGameObject, selectedItem.rootGameObject); } } else if (selectedItem.scriptableObject != null) { - potentialBindings = AnimationWindowUtility.GetAnimatableProperties(selectedItem.scriptableObject, valueType); + potentialBindings = GetAnimatableProperties(selectedItem, valueType); } - if (potentialBindings == null || potentialBindings.Count == 0) + if (potentialBindings == null || potentialBindings.Length == 0) return null; - if (potentialBindings.Count == 1) // Single property for this valuetype, return it + if (potentialBindings.Length == 1) // Single property for this valuetype, return it { return potentialBindings[0]; } @@ -855,20 +900,16 @@ private void SelectTypeForCreatingNewPptrDopeline(object userData, string[] opti DoSpriteDropAfterGeneratingNewDopeline(animationClip, bindings[selected]); } - private EditorCurveBinding? CreateNewSpriteRendererDopeline(GameObject targetGameObject, GameObject rootGameObject) + private EditorCurveBinding CreateNewSpriteRendererDopeline(GameObject targetGameObject, GameObject rootGameObject) { // Let's make sure there is spriterenderer to animate if (!targetGameObject.GetComponent()) targetGameObject.AddComponent(); - // Now we should always find an animatable binding for it - List curveBindings = AnimationWindowUtility.GetAnimatableProperties(targetGameObject, rootGameObject, typeof(SpriteRenderer), typeof(Sprite)); - if (curveBindings.Count == 1) - return curveBindings[0]; - - // Something went wrong - Debug.LogError("Unable to create animatable SpriteRenderer component"); - return null; + return EditorCurveBinding.PPtrCurve( + AnimationUtility.CalculateTransformPath(targetGameObject.transform, rootGameObject.transform), + typeof(SpriteRenderer), + "m_Sprite"); } private void HandleDragAndDrop(DopeLine dopeline) @@ -1003,7 +1044,7 @@ private void HandleMouseDown(DopeLine dopeline) private void HandleDopelineDoubleclick(DopeLine dopeline) { - float timeAtMousePosition = state.PixelToTime(Event.current.mousePosition.x, AnimationWindowState.SnapMode.SnapToClipFrame); + float timeAtMousePosition = state.PixelToTime(Event.current.mousePosition.x, AnimationWindowState.SnapMode.SnapToFrame); AnimationKeyTime mouseKeyTime = AnimationKeyTime.Time(timeAtMousePosition, state.frameRate); AnimationWindowUtility.AddKeyframes(state, dopeline.curves, mouseKeyTime); @@ -1027,7 +1068,7 @@ private Rect GetKeyframeRect(DopeLine dopeline, AnimationWindowKeyframe keyframe if (dopeline.isPptrDopeline && dopeline.tallMode && (keyframe == null || keyframe.value != null)) width = dopeline.position.height; - return new Rect(state.TimeToPixel(state.SnapToFrame(time, AnimationWindowState.SnapMode.SnapToClipFrame)) + GetKeyframeOffset(dopeline, keyframe), dopeline.position.yMin, width, dopeline.position.height); + return new Rect(state.TimeToPixel(state.SnapToFrame(time, AnimationWindowState.SnapMode.SnapToFrame)) + GetKeyframeOffset(dopeline, keyframe), dopeline.position.yMin, width, dopeline.position.height); } // This means "how much is the rendered keyframe offset in pixels for x-axis". @@ -1085,12 +1126,12 @@ public void FrameSelected() { foreach (AnimationWindowCurve curve in state.activeCurves) { - int keyCount = curve.m_Keyframes.Count; + int keyCount = curve.keyframes.Count; if (keyCount > 1) { - Vector2 pt1 = new Vector2(curve.m_Keyframes[0].time, 0.0f); - Vector2 pt2 = new Vector2(curve.m_Keyframes[keyCount - 1].time, 0.0f); + Vector2 pt1 = new Vector2(curve.keyframes[0].time, 0.0f); + Vector2 pt2 = new Vector2(curve.keyframes[keyCount - 1].time, 0.0f); if (firstKey) { @@ -1162,7 +1203,7 @@ private bool DoDragAndDrop(DopeLine dopeLine, Rect position, bool perform) if (perform) { - float time = Mathf.Max(state.PixelToTime(Event.current.mousePosition.x, AnimationWindowState.SnapMode.SnapToClipFrame), 0f); + float time = Mathf.Max(state.PixelToTime(Event.current.mousePosition.x, AnimationWindowState.SnapMode.SnapToFrame), 0f); AnimationWindowCurve targetCurve = GetCurveOfType(dopeLine, targetType); PerformDragAndDrop(targetCurve, time); } @@ -1175,7 +1216,7 @@ private void PerformDragAndDrop(AnimationWindowCurve targetCurve, float time) if (DragAndDrop.objectReferences.Length == 0 || targetCurve == null) return; - string undoLabel = "Drop Key"; + string undoLabel = L10n.Tr("Drop Key"); state.SaveKeySelection(undoLabel); state.ClearSelections(); @@ -1421,8 +1462,8 @@ public Rect GetCurrentPixelRect() { float height = AnimationWindowHierarchyGUI.k_DopeSheetRowHeight; Rect r = AnimationWindowUtility.FromToRect(m_SelectStartPoint, m_SelectMousePoint); - r.xMin = owner.state.TimeToPixel(owner.state.PixelToTime(r.xMin, AnimationWindowState.SnapMode.SnapToClipFrame), AnimationWindowState.SnapMode.SnapToClipFrame); - r.xMax = owner.state.TimeToPixel(owner.state.PixelToTime(r.xMax, AnimationWindowState.SnapMode.SnapToClipFrame), AnimationWindowState.SnapMode.SnapToClipFrame); + r.xMin = owner.state.TimeToPixel(owner.state.PixelToTime(r.xMin, AnimationWindowState.SnapMode.SnapToFrame), AnimationWindowState.SnapMode.SnapToFrame); + r.xMax = owner.state.TimeToPixel(owner.state.PixelToTime(r.xMax, AnimationWindowState.SnapMode.SnapToFrame), AnimationWindowState.SnapMode.SnapToFrame); r.yMin = Mathf.Floor(r.yMin / height) * height; r.yMax = (Mathf.Floor(r.yMax / height) + 1) * height; return r; @@ -1432,8 +1473,8 @@ public Rect GetCurrentTimeRect() { float height = AnimationWindowHierarchyGUI.k_DopeSheetRowHeight; Rect r = AnimationWindowUtility.FromToRect(m_SelectStartPoint, m_SelectMousePoint); - r.xMin = owner.state.PixelToTime(r.xMin, AnimationWindowState.SnapMode.SnapToClipFrame); - r.xMax = owner.state.PixelToTime(r.xMax, AnimationWindowState.SnapMode.SnapToClipFrame); + r.xMin = owner.state.PixelToTime(r.xMin, AnimationWindowState.SnapMode.SnapToFrame); + r.xMax = owner.state.PixelToTime(r.xMax, AnimationWindowState.SnapMode.SnapToFrame); r.yMin = Mathf.Floor(r.yMin / height) * height; r.yMax = (Mathf.Floor(r.yMax / height) + 1) * height; return r; @@ -1446,7 +1487,7 @@ public void UpdateCurves(List changedCurves, string undoText) foreach (ChangedCurve changedCurve in changedCurves) { - AnimationWindowCurve curve = state.allCurves.Find(c => changedCurve.curveId == c.GetHashCode()); + AnimationWindowCurve curve = state.filteredCurves.Find(c => changedCurve.curveId == c.GetHashCode()); if (curve != null) { AnimationUtility.SetEditorCurve(curve.clip, changedCurve.binding, changedCurve.curve); diff --git a/Editor/Mono/Animation/AnimationWindow/GameObjectSelectionItem.cs b/Editor/Mono/Animation/AnimationWindow/GameObjectSelectionItem.cs index f1d1aa5e68..3c40b4b184 100644 --- a/Editor/Mono/Animation/AnimationWindow/GameObjectSelectionItem.cs +++ b/Editor/Mono/Animation/AnimationWindow/GameObjectSelectionItem.cs @@ -8,11 +8,12 @@ namespace UnityEditorInternal { + [Serializable] internal class GameObjectSelectionItem : AnimationWindowSelectionItem { public static GameObjectSelectionItem Create(GameObject gameObject) { - GameObjectSelectionItem selectionItem = CreateInstance(typeof(GameObjectSelectionItem)) as GameObjectSelectionItem; + var selectionItem = new GameObjectSelectionItem(); selectionItem.gameObject = gameObject; selectionItem.animationClip = null; diff --git a/Editor/Mono/Animation/AnimationWindow/IAnimationContextualResponder.cs b/Editor/Mono/Animation/AnimationWindow/IAnimationContextualResponder.cs index 9070b0ecf8..ce1a181faa 100644 --- a/Editor/Mono/Animation/AnimationWindow/IAnimationContextualResponder.cs +++ b/Editor/Mono/Animation/AnimationWindow/IAnimationContextualResponder.cs @@ -2,8 +2,6 @@ // 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; diff --git a/Editor/Mono/Animation/AnimationWindow/IAnimationWindowControl.cs b/Editor/Mono/Animation/AnimationWindow/IAnimationWindowControl.cs index 356bc4fb30..fb89e71fb3 100644 --- a/Editor/Mono/Animation/AnimationWindow/IAnimationWindowControl.cs +++ b/Editor/Mono/Animation/AnimationWindow/IAnimationWindowControl.cs @@ -3,26 +3,64 @@ // https://unity3d.com/legal/licenses/Unity_Reference_Only_License using System; -using UnityEngine; using UnityEditor; +using UnityEngine; using Object = UnityEngine.Object; namespace UnityEditorInternal { - internal abstract class IAnimationWindowControl : ScriptableObject + // Compatibility implementation of IAnimationWindowController. + abstract class IAnimationWindowControl : ScriptableObject, IAnimationWindowController { - public virtual void OnEnable() { hideFlags = HideFlags.HideAndDontSave; } + [SerializeReference] AnimationWindowState m_State; + + public virtual void OnEnable() + { + hideFlags = HideFlags.HideAndDontSave; + } + public abstract void OnSelectionChanged(); + public void Init(AnimationWindowState state) + { + m_State = state; + } + + void IAnimationWindowController.OnCreate(AnimationWindow animationWindow, UnityEngine.Component component) + { + } + + void IAnimationWindowController.OnDestroy() + { + // Animation Window has ownership of `IAnimationWindowControl` in legacy workflow. + Object.DestroyImmediate(this); + } + + float IAnimationWindowController.time + { + get => time.time; + set => GoToTime(value); + } + + int IAnimationWindowController.frame + { + get => time.frame; + set => GoToFrame(value); + } + public abstract AnimationKeyTime time { get; } public abstract void GoToTime(float time); public abstract void GoToFrame(int frame); + // Not used anymore. This was not used by either the AnimationWindow nor Timeline. + // Replaced by setting IAnimationWindowController.time. public abstract void StartScrubTime(); public abstract void ScrubTime(float time); public abstract void EndScrubTime(); + // Not used anymore. Required internal knowledge of the Animation Window and + // default implementation should suffice. public abstract void GoToPreviousFrame(); public abstract void GoToNextFrame(); public abstract void GoToPreviousKeyframe(); @@ -31,26 +69,152 @@ internal abstract class IAnimationWindowControl : ScriptableObject public abstract void GoToLastKeyframe(); public abstract bool canPlay { get; } - public abstract bool playing { get; } + bool IAnimationWindowController.playing + { + get => playing; + set + { + if (value) + StartPlayback(); + else + StopPlayback(); + } + } + + public abstract bool playing { get; } public abstract bool StartPlayback(); public abstract void StopPlayback(); public abstract bool PlaybackUpdate(); public abstract bool canPreview { get; } - public abstract bool previewing { get; } + bool IAnimationWindowController.previewing + { + get => previewing; + set + { + if (value) + StartPreview(); + else + StopPreview(); + } + } + + public abstract bool previewing { get; } public abstract bool StartPreview(); public abstract void StopPreview(); public abstract bool canRecord { get; } - public abstract bool recording { get; } + bool IAnimationWindowController.recording + { + get => recording; + set + { + if (value) + StartRecording(null); + else + StopRecording(); + } + } + + public abstract bool recording { get; } + // targetObject parameter is not used. public abstract bool StartRecording(Object targetObject); public abstract void StopRecording(); + public abstract void ResampleAnimation(); public abstract void ProcessCandidates(); public abstract void ClearCandidates(); + + EditorCurveBinding[] IAnimationWindowController.GetAnimatableBindings() + { + if (m_State == null) + return Array.Empty(); + + var rootGameObject = m_State.activeRootGameObject; + var scriptableObject = m_State.activeScriptableObject; + + if (rootGameObject != null) + { + return AnimationWindowUtility.GetAnimatableBindings(rootGameObject); + } + if (scriptableObject != null) + { + return AnimationUtility.GetAnimatableBindings(scriptableObject); + } + + return Array.Empty(); + } + + EditorCurveBinding[] IAnimationWindowController.GetAnimatableBindings(GameObject gameObject) + { + if (m_State == null) + return Array.Empty(); + + var rootGameObject = m_State.activeRootGameObject; + return AnimationUtility.GetAnimatableBindings(gameObject, rootGameObject); + } + + System.Type IAnimationWindowController.GetValueType(EditorCurveBinding binding) + { + if (m_State == null) + return default; + + var rootGameObject = m_State.activeRootGameObject; + var scriptableObject = m_State.activeScriptableObject; + + if (rootGameObject != null) + { + return AnimationUtility.GetEditorCurveValueType(rootGameObject, binding); + } + else if (scriptableObject != null) + { + return AnimationUtility.GetEditorCurveValueType(scriptableObject, binding); + } + else + { + if (binding.isPPtrCurve) + { + // Cannot extract type of PPtrCurve. + return null; + } + else + { + // Cannot extract type of AnimationCurve. Default to float. + return typeof(float); + } + } + } + + float IAnimationWindowController.GetFloatValue(EditorCurveBinding binding) + { + if (m_State == null) + return default; + + AnimationUtility.GetFloatValue(m_State.activeRootGameObject, binding, out var value); + return value; + } + + int IAnimationWindowController.GetIntValue(EditorCurveBinding binding) + { + if (m_State == null) + return default; + + AnimationUtility.GetDiscreteIntValue(m_State.activeRootGameObject, binding, out var value); + return value; + } + + UnityEngine.Object IAnimationWindowController.GetObjectReferenceValue(EditorCurveBinding binding) + { + if (m_State == null) + return default; + + AnimationUtility.GetObjectReferenceValue(m_State.activeRootGameObject, binding, out var value); + return value; + } + } } diff --git a/Editor/Mono/Animation/AnimationWindow/IAnimationWindowController.cs b/Editor/Mono/Animation/AnimationWindow/IAnimationWindowController.cs new file mode 100644 index 0000000000..ced9cb6703 --- /dev/null +++ b/Editor/Mono/Animation/AnimationWindow/IAnimationWindowController.cs @@ -0,0 +1,42 @@ +// 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 UnityEditor +{ + interface IAnimationWindowController + { + void OnCreate(AnimationWindow animationWindow, UnityEngine.Component component); + void OnDestroy(); + void OnSelectionChanged(); + + float time { get; set; } + int frame { get; set; } + + bool canPlay { get; } + bool playing { get; set; } + + bool PlaybackUpdate(); + + bool canPreview { get; } + bool previewing { get; set; } + + bool canRecord { get; } + bool recording { get; set; } + + void ResampleAnimation(); + + void ProcessCandidates(); + void ClearCandidates(); + + EditorCurveBinding[] GetAnimatableBindings(GameObject gameObject); + EditorCurveBinding[] GetAnimatableBindings(); + System.Type GetValueType(EditorCurveBinding binding); + float GetFloatValue(EditorCurveBinding binding); + int GetIntValue(EditorCurveBinding binding); + UnityEngine.Object GetObjectReferenceValue(EditorCurveBinding binding); + + } +} diff --git a/Editor/Mono/Animation/AnimationWindow/MinMaxCurveEditorWindow.cs b/Editor/Mono/Animation/AnimationWindow/MinMaxCurveEditorWindow.cs index 5b44306564..f1c1306127 100644 --- a/Editor/Mono/Animation/AnimationWindow/MinMaxCurveEditorWindow.cs +++ b/Editor/Mono/Animation/AnimationWindow/MinMaxCurveEditorWindow.cs @@ -3,7 +3,6 @@ // https://unity3d.com/legal/licenses/Unity_Reference_Only_License using System; -using System.Linq; using UnityEngine; namespace UnityEditor @@ -249,11 +248,12 @@ void UpdateRegionDomain() { foreach (var animationCurve in new[] { m_MaxCurve, m_MinCurve }) { - if (animationCurve.length > 0) + var keyCount = animationCurve.length; + if (keyCount > 0) { var keys = animationCurve.keys; - domain.x = Mathf.Min(domain.x, keys.First().time); - domain.y = Math.Max(domain.y, keys.Last().time); + domain.x = Mathf.Min(domain.x, animationCurve[0].time); + domain.y = Math.Max(domain.y, animationCurve[keyCount - 1].time); } } } diff --git a/Editor/Mono/Animation/AnimationWindow/RotationCurveInterpolation.cs b/Editor/Mono/Animation/AnimationWindow/RotationCurveInterpolation.cs index ede837fd2c..6c017c2958 100644 --- a/Editor/Mono/Animation/AnimationWindow/RotationCurveInterpolation.cs +++ b/Editor/Mono/Animation/AnimationWindow/RotationCurveInterpolation.cs @@ -225,7 +225,7 @@ static public EditorCurveBinding RemapAnimationBindingForRotationCurves(EditorCu internal static void SetInterpolation(AnimationClip clip, EditorCurveBinding[] curveBindings, Mode newInterpolationMode) { - Undo.RegisterCompleteObjectUndo(clip, "Rotation Interpolation"); + Undo.RegisterCompleteObjectUndo(clip, L10n.Tr("Rotation Interpolation")); if (clip.legacy && newInterpolationMode == Mode.RawEuler) { @@ -269,7 +269,7 @@ internal static void SetInterpolation(AnimationClip clip, EditorCurveBinding[] c oldCurvesBindings.Add(removeCurve); } - Undo.RegisterCompleteObjectUndo(clip, "Rotation Interpolation"); + Undo.RegisterCompleteObjectUndo(clip, L10n.Tr("Rotation Interpolation")); foreach (EditorCurveBinding binding in oldCurvesBindings) AnimationUtility.SetEditorCurve(clip, binding, null); diff --git a/Editor/Mono/Animation/AnimatorController.cs b/Editor/Mono/Animation/AnimatorController.cs index 3330ed6235..f5a2c0e500 100644 --- a/Editor/Mono/Animation/AnimatorController.cs +++ b/Editor/Mono/Animation/AnimatorController.cs @@ -2,6 +2,7 @@ // Copyright (c) Unity Technologies. For terms of use, see // https://unity3d.com/legal/licenses/Unity_Reference_Only_License +using System; using UnityEngine; using System.IO; using System.Collections.Generic; @@ -60,6 +61,8 @@ public void AddLayer(string name) if (AssetDatabase.GetAssetPath(this) != "") AssetDatabase.AddObjectToAsset(newLayer.stateMachine, AssetDatabase.GetAssetPath(this)); + undoHandler.DoUndoCreated(newLayer.stateMachine, "Layer added"); + AddLayer(newLayer); } @@ -79,6 +82,16 @@ internal void RemoveLayers(List layerIndexes) AnimatorControllerLayer[] layerVector = this.layers; foreach (var layerIndex in layerIndexes) { + for (var i = 0; i < layerVector.Length; ++i) + { + var syncedLayerIndex = layerVector[i].syncedLayerIndex; + if (syncedLayerIndex > layerIndex) + { + // synced layer is after the layer being removed, so it's going to be shifted upon removal + layerVector[i].syncedLayerIndex = syncedLayerIndex - 1; + } + } + RemoveLayerInternal(layerIndex, ref layerVector); } this.layers = layerVector; @@ -195,6 +208,8 @@ public AnimatorState CreateBlendTreeInController(string name, out BlendTree tree if (AssetDatabase.GetAssetPath(this) != "") AssetDatabase.AddObjectToAsset(tree, AssetDatabase.GetAssetPath(this)); + undoHandler.DoUndoCreated(tree, "Blend Tree Created"); + AnimatorState state = layers[layerIndex].stateMachine.AddState(tree.name); state.motion = tree; return state; @@ -244,7 +259,13 @@ internal static AnimatorController CreateAnimatorControllerForClip(AnimationClip public static AnimatorController CreateAnimatorControllerAtPathWithClip(string path, AnimationClip clip) { AnimatorController controller = CreateAnimatorControllerAtPath(path); - controller.AddMotion(clip); + + AnimatorStateMachine stateMachine = controller.layers[0].stateMachine; + stateMachine.pushUndo = false; + var state = stateMachine.AddState(clip.name); + state.motion = clip; + stateMachine.pushUndo = true; + return controller; } @@ -255,6 +276,15 @@ public void SetStateEffectiveMotion(AnimatorState state, Motion motion) public void SetStateEffectiveMotion(AnimatorState state, Motion motion, int layerIndex) { + //delete existing nested blend tree asset + Motion selectedMotion = GetStateEffectiveMotion(state, layerIndex); + BlendTree blendTree = selectedMotion as BlendTree; + + if (blendTree != null && !AssetDatabase.IsMainAsset(blendTree)) + { + MecanimUtilities.DestroyBlendTreeRecursive(blendTree); + } + if (layers[layerIndex].syncedLayerIndex == -1) { undoHandler.DoUndo(state, "Set Motion"); @@ -276,14 +306,10 @@ public Motion GetStateEffectiveMotion(AnimatorState state) public Motion GetStateEffectiveMotion(AnimatorState state, int layerIndex) { - if (layers[layerIndex].syncedLayerIndex == -1) - { - return state.motion; - } - else - { - return layers[layerIndex].GetOverrideMotion(state); - } + if (layerIndex < 0 || layerIndex > layers.Length) + return null; + + return layers[layerIndex].syncedLayerIndex == -1 ? state.motion : layers[layerIndex].GetOverrideMotion(state); } public void SetStateEffectiveBehaviours(AnimatorState state, int layerIndex, StateMachineBehaviour[] behaviours) @@ -302,6 +328,9 @@ public void SetStateEffectiveBehaviours(AnimatorState state, int layerIndex, Sta public StateMachineBehaviour[] GetStateEffectiveBehaviours(AnimatorState state, int layerIndex) { + if (layerIndex < 0 || layerIndex > layers.Length) + return Array.Empty(); + return Internal_GetEffectiveBehaviours(state, layerIndex) as StateMachineBehaviour[]; } diff --git a/Editor/Mono/Animation/BlendTree.cs b/Editor/Mono/Animation/BlendTree.cs index 70ba96bbf2..33619e8979 100644 --- a/Editor/Mono/Animation/BlendTree.cs +++ b/Editor/Mono/Animation/BlendTree.cs @@ -80,14 +80,16 @@ internal bool HasChild(BlendTree childTree, bool recursive) internal BlendTree CreateBlendTreeChild(Vector2 position, float threshold) { - Undo.RecordObject(this, "Created BlendTree Child"); - BlendTree tree = new BlendTree(); tree.name = "BlendTree"; tree.hideFlags = HideFlags.HideInHierarchy; if (AssetDatabase.GetAssetPath(this) != "") AssetDatabase.AddObjectToAsset(tree, AssetDatabase.GetAssetPath(this)); + Undo.RegisterCreatedObjectUndo(tree, "Blend Tree Created"); + + Undo.RecordObject(this, "Created BlendTree Child"); + AddChild(tree, position, threshold); return tree; } diff --git a/Editor/Mono/Animation/EditorCurveBinding.bindings.cs b/Editor/Mono/Animation/EditorCurveBinding.bindings.cs index d6ccd3d822..334acb0ff6 100644 --- a/Editor/Mono/Animation/EditorCurveBinding.bindings.cs +++ b/Editor/Mono/Animation/EditorCurveBinding.bindings.cs @@ -8,6 +8,8 @@ using UnityEngine.Playables; using UnityEngine.Scripting.APIUpdating; using UnityEngine.Internal; +using UnityEngine; +using static UnityEditor.AnimationUtility; namespace UnityEditor { @@ -29,15 +31,24 @@ public struct EditorCurveBinding : IEquatable //is it a discrete curve private int m_isDiscreteCurve; + //is it a serialize reference curve + private int m_isSerializeReferenceCurve; + //is it placeholder curve private int m_isPhantom; + //is it a unknown curve: mean it needs to be processed further more to find out what is this curve + // This is necessary to support old user code using FloatCurve for non float type + private int m_isUnknownCurve; + // This is only used internally for deleting curves internal int m_ClassID; internal int m_ScriptInstanceID; public bool isPPtrCurve { get { return m_isPPtrCurve != 0; } } public bool isDiscreteCurve { get { return m_isDiscreteCurve != 0; } } + + public bool isSerializeReferenceCurve { get { return m_isSerializeReferenceCurve != 0; } } internal bool isPhantom { get { return m_isPhantom != 0; } set { m_isPhantom = value == true ? 1 : 0; } } public static bool operator==(EditorCurveBinding lhs, EditorCurveBinding rhs) @@ -49,7 +60,7 @@ public struct EditorCurveBinding : IEquatable return false; } - return lhs.m_isPPtrCurve == rhs.m_isPPtrCurve && lhs.m_isDiscreteCurve == rhs.m_isDiscreteCurve && lhs.path == rhs.path && lhs.type == rhs.type && lhs.propertyName == rhs.propertyName; + return lhs.m_isPPtrCurve == rhs.m_isPPtrCurve && lhs.m_isDiscreteCurve == rhs.m_isDiscreteCurve && lhs.m_isSerializeReferenceCurve == rhs.m_isSerializeReferenceCurve && lhs.path == rhs.path && lhs.type == rhs.type && lhs.propertyName == rhs.propertyName; } public static bool operator!=(EditorCurveBinding lhs, EditorCurveBinding rhs) @@ -93,6 +104,8 @@ static public EditorCurveBinding FloatCurve(string inPath, System.Type inType, s BaseCurve(inPath, inType, inPropertyName, out binding); binding.m_isPPtrCurve = 0; binding.m_isDiscreteCurve = 0; + binding.m_isSerializeReferenceCurve = 0; + binding.m_isUnknownCurve = 1; return binding; } @@ -103,6 +116,8 @@ static public EditorCurveBinding PPtrCurve(string inPath, System.Type inType, st BaseCurve(inPath, inType, inPropertyName, out binding); binding.m_isPPtrCurve = 1; binding.m_isDiscreteCurve = 1; + binding.m_isSerializeReferenceCurve = 0; + binding.m_isUnknownCurve = 0; return binding; } @@ -112,6 +127,31 @@ static public EditorCurveBinding DiscreteCurve(string inPath, System.Type inType BaseCurve(inPath, inType, inPropertyName, out binding); binding.m_isPPtrCurve = 0; binding.m_isDiscreteCurve = 1; + binding.m_isSerializeReferenceCurve = 0; + binding.m_isUnknownCurve = 0; + + DiscreteBindingResult result = AnimationUtility.IsDiscreteIntBinding(binding); + if (result == DiscreteBindingResult.IncompatibleFieldType || result == DiscreteBindingResult.MissingDiscreteAttribute) + { + Debug.LogWarning( + $"Property [" + inPropertyName + "] is not a supported discrete curve binding. " + + "Discrete curves only support [" + typeof(Enum) + "] and [" + typeof(int) + " with the `DiscreteEvaluation` attribute]."); + + binding.m_isDiscreteCurve = 0; + binding.m_isUnknownCurve = 1; + } + + return binding; + } + + static public EditorCurveBinding SerializeReferenceCurve(string inPath, System.Type inType, long refID, string inPropertyName, bool isPPtr, bool isDiscrete) + { + EditorCurveBinding binding; + BaseCurve(inPath, inType, $"managedReferences[{refID}].{inPropertyName}", out binding); + binding.m_isPPtrCurve = isPPtr ? 1 : 0; + binding.m_isDiscreteCurve = isDiscrete || isPPtr ? 1 : 0; + binding.m_isSerializeReferenceCurve = 1; + binding.m_isUnknownCurve = 0; return binding; } diff --git a/Editor/Mono/Animation/MaterialAnimationUtility.cs b/Editor/Mono/Animation/MaterialAnimationUtility.cs index d31ce0aacc..27cfc5e01d 100644 --- a/Editor/Mono/Animation/MaterialAnimationUtility.cs +++ b/Editor/Mono/Animation/MaterialAnimationUtility.cs @@ -6,6 +6,7 @@ using System.Collections.Generic; using UnityEditor; using UnityEngine; +using ShaderPropertyType = UnityEngine.Rendering.ShaderPropertyType; using Object = UnityEngine.Object; namespace UnityEditorInternal @@ -63,16 +64,17 @@ static PropertyModification[] MaterialPropertyToPropertyModifications(string nam return modifications; } - static bool ApplyMaterialModificationToAnimationRecording(PropertyModification[] modifications) + static bool ApplyMaterialModificationToAnimationRecording(PropertyModification[] previousModifications, PropertyModification[] currentModifications) { - UndoPropertyModification[] undoModifications = new UndoPropertyModification[modifications.Length]; + UndoPropertyModification[] undoModifications = new UndoPropertyModification[previousModifications.Length]; for (int i = 0; i < undoModifications.Length; ++i) { - undoModifications[i].previousValue = modifications[i]; + undoModifications[i].previousValue = previousModifications[i]; + undoModifications[i].currentValue = currentModifications[i]; } UndoPropertyModification[] ret = Undo.InvokePostprocessModifications(undoModifications); - return ret.Length != modifications.Length; + return ret.Length != undoModifications.Length; } static public bool OverridePropertyColor(MaterialProperty materialProp, Renderer target, out Color color) @@ -80,20 +82,27 @@ static public bool OverridePropertyColor(MaterialProperty materialProp, Renderer var propertyPaths = new List(); string basePropertyPath = kMaterialPrefix + materialProp.name; - if (materialProp.type == MaterialProperty.PropType.Texture) + if (materialProp.propertyType == ShaderPropertyType.Texture) { propertyPaths.Add(basePropertyPath + "_ST.x"); propertyPaths.Add(basePropertyPath + "_ST.y"); propertyPaths.Add(basePropertyPath + "_ST.z"); propertyPaths.Add(basePropertyPath + "_ST.w"); } - else if (materialProp.type == MaterialProperty.PropType.Color) + else if (materialProp.propertyType == ShaderPropertyType.Color) { propertyPaths.Add(basePropertyPath + ".r"); propertyPaths.Add(basePropertyPath + ".g"); propertyPaths.Add(basePropertyPath + ".b"); propertyPaths.Add(basePropertyPath + ".a"); } + else if (materialProp.propertyType == ShaderPropertyType.Vector) + { + propertyPaths.Add(basePropertyPath + ".x"); + propertyPaths.Add(basePropertyPath + ".y"); + propertyPaths.Add(basePropertyPath + ".z"); + propertyPaths.Add(basePropertyPath + ".w"); + } else { propertyPaths.Add(basePropertyPath); @@ -130,37 +139,37 @@ static public void TearDownMaterialPropertyBlock(Renderer target) static public bool ApplyMaterialModificationToAnimationRecording(MaterialProperty materialProp, int changedMask, Renderer target, object oldValue) { bool applied = false; - switch (materialProp.type) + switch (materialProp.propertyType) { - case MaterialProperty.PropType.Color: + case ShaderPropertyType.Color: SetupMaterialPropertyBlock(materialProp, changedMask, target); - applied = ApplyMaterialModificationToAnimationRecording(MaterialPropertyToPropertyModifications(materialProp, target, (Color)oldValue)); + applied = ApplyMaterialModificationToAnimationRecording(MaterialPropertyToPropertyModifications(materialProp, target, (Color)oldValue), MaterialPropertyToPropertyModifications(materialProp, target, materialProp.colorValue)); if (!applied) TearDownMaterialPropertyBlock(target); return applied; - case MaterialProperty.PropType.Vector: + case ShaderPropertyType.Vector: SetupMaterialPropertyBlock(materialProp, changedMask, target); - applied = ApplyMaterialModificationToAnimationRecording(MaterialPropertyToPropertyModifications(materialProp, target, (Vector4)oldValue)); + applied = ApplyMaterialModificationToAnimationRecording(MaterialPropertyToPropertyModifications(materialProp, target, (Vector4)oldValue), MaterialPropertyToPropertyModifications(materialProp, target, materialProp.vectorValue)); if (!applied) TearDownMaterialPropertyBlock(target); return applied; - case MaterialProperty.PropType.Float: - case MaterialProperty.PropType.Range: + case ShaderPropertyType.Float: + case ShaderPropertyType.Range: SetupMaterialPropertyBlock(materialProp, changedMask, target); - applied = ApplyMaterialModificationToAnimationRecording(MaterialPropertyToPropertyModifications(materialProp, target, (float)oldValue)); + applied = ApplyMaterialModificationToAnimationRecording(MaterialPropertyToPropertyModifications(materialProp, target, (float)oldValue), MaterialPropertyToPropertyModifications(materialProp, target, materialProp.floatValue)); if (!applied) TearDownMaterialPropertyBlock(target); return applied; - case MaterialProperty.PropType.Texture: + case ShaderPropertyType.Texture: { if (MaterialProperty.IsTextureOffsetAndScaleChangedMask(changedMask)) { string name = materialProp.name + "_ST"; SetupMaterialPropertyBlock(materialProp, changedMask, target); - applied = ApplyMaterialModificationToAnimationRecording(MaterialPropertyToPropertyModifications(name, target, (Vector4)oldValue)); + applied = ApplyMaterialModificationToAnimationRecording(MaterialPropertyToPropertyModifications(name, target, (Vector4)oldValue), MaterialPropertyToPropertyModifications(name, target, materialProp.textureScaleAndOffset)); if (!applied) TearDownMaterialPropertyBlock(target); return applied; @@ -175,17 +184,17 @@ static public bool ApplyMaterialModificationToAnimationRecording(MaterialPropert static public PropertyModification[] MaterialPropertyToPropertyModifications(MaterialProperty materialProp, Renderer target) { - switch (materialProp.type) + switch (materialProp.propertyType) { - case MaterialProperty.PropType.Color: + case ShaderPropertyType.Color: return MaterialPropertyToPropertyModifications(materialProp, target, materialProp.colorValue); - case MaterialProperty.PropType.Vector: + case ShaderPropertyType.Vector: return MaterialPropertyToPropertyModifications(materialProp, target, materialProp.vectorValue); - case MaterialProperty.PropType.Float: - case MaterialProperty.PropType.Range: + case ShaderPropertyType.Float: + case ShaderPropertyType.Range: return MaterialPropertyToPropertyModifications(materialProp, target, materialProp.floatValue); - case MaterialProperty.PropType.Texture: + case ShaderPropertyType.Texture: { string name = materialProp.name + "_ST"; return MaterialPropertyToPropertyModifications(name, target, materialProp.vectorValue); diff --git a/Editor/Mono/Animation/StateMachine.cs b/Editor/Mono/Animation/StateMachine.cs index 6fbe2217fd..7a0a5c021d 100644 --- a/Editor/Mono/Animation/StateMachine.cs +++ b/Editor/Mono/Animation/StateMachine.cs @@ -27,6 +27,11 @@ public void DoUndo(Object target, string undoOperation) impl.DoUndo(target, undoOperation); } + public void DoUndoCreated(Object target, string undoOperation) + { + impl.DoUndoCreated(target, undoOperation); + } + PushUndoIfNeededImpl impl { get @@ -54,6 +59,14 @@ public void DoUndo(Object target, string undoOperation) } } + public void DoUndoCreated(Object target, string undoOperation) + { + if (m_PushUndo) + { + Undo.RegisterCreatedObjectUndo(target, undoOperation); + } + } + public bool m_PushUndo; } } @@ -87,11 +100,12 @@ public void RemoveCondition(AnimatorCondition condition) } } - + [HelpURL("StateMachineTransitions")] internal class AnimatorDefaultTransition : ScriptableObject { } + [HelpURL("class-State")] public partial class AnimatorState : Object { private PushUndoIfNeeded undoHandler = new PushUndoIfNeeded(true); @@ -128,6 +142,8 @@ private AnimatorStateTransition CreateTransition(bool setDefaultExitTime) AssetDatabase.AddObjectToAsset(newTransition, AssetDatabase.GetAssetPath(this)); newTransition.hideFlags = HideFlags.HideInHierarchy; + undoHandler.DoUndoCreated(newTransition, "Transition Created"); + if (setDefaultExitTime) SetDefaultTransitionExitTime(ref newTransition); @@ -227,6 +243,7 @@ public int uniqueNameHash } } + [HelpURL("NestedStateMachines")] public partial class AnimatorStateMachine : Object { private PushUndoIfNeeded undoHandler = new PushUndoIfNeeded(true); @@ -377,6 +394,8 @@ public AnimatorState AddState(string name, Vector3 position) if (AssetDatabase.GetAssetPath(this) != "") AssetDatabase.AddObjectToAsset(state, AssetDatabase.GetAssetPath(this)); + undoHandler.DoUndoCreated(state, "State Created"); + AddState(state, position); return state; @@ -392,6 +411,7 @@ public void AddState(AnimatorState state, Vector3 position) } undoHandler.DoUndo(this, "State added"); + ChildAnimatorState newState = new ChildAnimatorState(); newState.state = state; newState.position = position; @@ -423,6 +443,8 @@ public AnimatorStateMachine AddStateMachine(string name, Vector3 position) if (AssetDatabase.GetAssetPath(this) != "") AssetDatabase.AddObjectToAsset(stateMachine, AssetDatabase.GetAssetPath(this)); + undoHandler.DoUndoCreated(stateMachine, "StateMachine Created"); + return stateMachine; } @@ -453,23 +475,24 @@ public void RemoveStateMachine(AnimatorStateMachine stateMachine) private AnimatorStateTransition AddAnyStateTransition() { - undoHandler.DoUndo(this, "AnyState Transition Added"); - - AnimatorStateTransition[] transitionsVector = anyStateTransitions; AnimatorStateTransition newTransition = new AnimatorStateTransition(); newTransition.hasExitTime = false; newTransition.hasFixedDuration = true; newTransition.duration = 0.25f; newTransition.exitTime = 0.75f; + newTransition.hideFlags = HideFlags.HideInHierarchy; if (AssetDatabase.GetAssetPath(this) != "") AssetDatabase.AddObjectToAsset(newTransition, AssetDatabase.GetAssetPath(this)); - newTransition.hideFlags = HideFlags.HideInHierarchy; + undoHandler.DoUndoCreated(newTransition, "AnyState Transition Created"); + + undoHandler.DoUndo(this, "AnyState Transition Added"); + + AnimatorStateTransition[] transitionsVector = anyStateTransitions; ArrayUtility.Add(ref transitionsVector, newTransition); anyStateTransitions = transitionsVector; - return newTransition; } @@ -521,42 +544,48 @@ internal void RemoveAnyStateTransitionRecursive(AnimatorStateTransition transiti public AnimatorTransition AddStateMachineTransition(AnimatorStateMachine sourceStateMachine) { - AnimatorStateMachine sm = null; - return AddStateMachineTransition(sourceStateMachine, sm); + AnimatorTransition newTransition = new AnimatorTransition(); + AddStateMachineTransition(sourceStateMachine, newTransition); + return newTransition; } public AnimatorTransition AddStateMachineTransition(AnimatorStateMachine sourceStateMachine, AnimatorStateMachine destinationStateMachine) { - undoHandler.DoUndo(this, "StateMachine Transition Added"); - - AnimatorTransition[] transitionsVector = GetStateMachineTransitions(sourceStateMachine); - AnimatorTransition newTransition = new AnimatorTransition(); - if (destinationStateMachine) - { - newTransition.destinationStateMachine = destinationStateMachine; - } - - if (AssetDatabase.GetAssetPath(this) != "") - AssetDatabase.AddObjectToAsset(newTransition, AssetDatabase.GetAssetPath(this)); - - newTransition.hideFlags = HideFlags.HideInHierarchy; - ArrayUtility.Add(ref transitionsVector, newTransition); - SetStateMachineTransitions(sourceStateMachine, transitionsVector); - + var newTransition = new AnimatorTransition(); + newTransition.destinationStateMachine = destinationStateMachine; + AddStateMachineTransition(sourceStateMachine, newTransition); return newTransition; } public AnimatorTransition AddStateMachineTransition(AnimatorStateMachine sourceStateMachine, AnimatorState destinationState) { - AnimatorTransition newTransition = AddStateMachineTransition(sourceStateMachine); + var newTransition = new AnimatorTransition(); newTransition.destinationState = destinationState; + AddStateMachineTransition(sourceStateMachine, newTransition); return newTransition; } + internal void AddStateMachineTransition(AnimatorStateMachine sourceStateMachine, AnimatorTransition transition) + { + transition.hideFlags = HideFlags.HideInHierarchy; + + if (AssetDatabase.GetAssetPath(this) != "") + AssetDatabase.AddObjectToAsset(transition, AssetDatabase.GetAssetPath(this)); + + undoHandler.DoUndoCreated(transition, "StateMachine Transition Created"); + + undoHandler.DoUndo(this, "StateMachine Transition Added"); + + AnimatorTransition[] transitionsVector = GetStateMachineTransitions(sourceStateMachine); + ArrayUtility.Add(ref transitionsVector, transition); + SetStateMachineTransitions(sourceStateMachine, transitionsVector); + } + public AnimatorTransition AddStateMachineExitTransition(AnimatorStateMachine sourceStateMachine) { - AnimatorTransition newTransition = AddStateMachineTransition(sourceStateMachine); + var newTransition = new AnimatorTransition(); newTransition.isExit = true; + AddStateMachineTransition(sourceStateMachine, newTransition); return newTransition; } @@ -577,14 +606,16 @@ public bool RemoveStateMachineTransition(AnimatorStateMachine sourceStateMachine private AnimatorTransition AddEntryTransition() { - undoHandler.DoUndo(this, "Entry Transition Added"); - AnimatorTransition[] transitionsVector = entryTransitions; AnimatorTransition newTransition = new AnimatorTransition(); + newTransition.hideFlags = HideFlags.HideInHierarchy; if (AssetDatabase.GetAssetPath(this) != "") AssetDatabase.AddObjectToAsset(newTransition, AssetDatabase.GetAssetPath(this)); - newTransition.hideFlags = HideFlags.HideInHierarchy; + undoHandler.DoUndoCreated(newTransition, "Entry Transition Created"); + + undoHandler.DoUndo(this, "Entry Transition Added"); + AnimatorTransition[] transitionsVector = entryTransitions; ArrayUtility.Add(ref transitionsVector, newTransition); entryTransitions = transitionsVector; diff --git a/Editor/Mono/Animation/TickHandler.cs b/Editor/Mono/Animation/TickHandler.cs index 270854c65b..e5fa350ab7 100644 --- a/Editor/Mono/Animation/TickHandler.cs +++ b/Editor/Mono/Animation/TickHandler.cs @@ -190,7 +190,11 @@ public int GetLevelWithMinSeparation(float pixelSeparation) public void SetTickStrengths(float tickMinSpacing, float tickMaxSpacing, bool sqrt) { - m_TickStrengths = new float[m_TickModulos.Length]; + if (m_TickStrengths == null || m_TickStrengths.Length != m_TickModulos.Length) + { + m_TickStrengths = new float[m_TickModulos.Length]; + } + m_SmallestTick = 0; m_BiggestTick = m_TickModulos.Length - 1; diff --git a/Editor/Mono/Animation/TimeArea.cs b/Editor/Mono/Animation/TimeArea.cs index 829a93691c..d64fe78d23 100644 --- a/Editor/Mono/Animation/TimeArea.cs +++ b/Editor/Mono/Animation/TimeArea.cs @@ -21,7 +21,7 @@ public TickHandler hTicks [SerializeField] private TickHandler m_VTicks; - private List m_TickCache = new List(1000); + static readonly List s_TickCache = new List(1000); public TickHandler vTicks { @@ -114,12 +114,12 @@ public void DrawMajorTicks(Rect position, float frameRate) float strength = hTicks.GetStrengthOfLevel(l) * .9f; if (strength > kTickRulerFatThreshold) { - m_TickCache.Clear(); - hTicks.GetTicksAtLevel(l, true, m_TickCache); - for (int i = 0; i < m_TickCache.Count; i++) + s_TickCache.Clear(); + hTicks.GetTicksAtLevel(l, true, s_TickCache); + for (int i = 0; i < s_TickCache.Count; i++) { - if (m_TickCache[i] < 0) continue; - int frame = Mathf.RoundToInt(m_TickCache[i] * frameRate); + if (s_TickCache[i] < 0) continue; + int frame = Mathf.RoundToInt(s_TickCache[i] * frameRate); float x = FrameToPixel(frame, frameRate, position, theShowArea); // Draw line DrawVerticalLineFast(x, 0.0f, position.height, tickColor); @@ -166,13 +166,13 @@ public void TimeRuler(Rect position, float frameRate, bool labels, bool useEntir for (int l = 0; l < hTicks.tickLevels; l++) { float strength = hTicks.GetStrengthOfLevel(l) * .9f; - m_TickCache.Clear(); - hTicks.GetTicksAtLevel(l, true, m_TickCache); - for (int i = 0; i < m_TickCache.Count; i++) + s_TickCache.Clear(); + hTicks.GetTicksAtLevel(l, true, s_TickCache); + for (int i = 0; i < s_TickCache.Count; i++) { - if (m_TickCache[i] < hRangeMin || m_TickCache[i] > hRangeMax) + if (s_TickCache[i] < hRangeMin || s_TickCache[i] > hRangeMax) continue; - int frame = Mathf.RoundToInt(m_TickCache[i] * frameRate); + int frame = Mathf.RoundToInt(s_TickCache[i] * frameRate); float height = useEntireHeight ? position.height @@ -192,19 +192,19 @@ public void TimeRuler(Rect position, float frameRate, bool labels, bool useEntir { // Draw tick labels int labelLevel = hTicks.GetLevelWithMinSeparation(kTickRulerDistLabel); - m_TickCache.Clear(); - hTicks.GetTicksAtLevel(labelLevel, false, m_TickCache); - for (int i = 0; i < m_TickCache.Count; i++) + s_TickCache.Clear(); + hTicks.GetTicksAtLevel(labelLevel, false, s_TickCache); + for (int i = 0; i < s_TickCache.Count; i++) { - if (m_TickCache[i] < hRangeMin || m_TickCache[i] > hRangeMax) + if (s_TickCache[i] < hRangeMin || s_TickCache[i] > hRangeMax) continue; - int frame = Mathf.RoundToInt(m_TickCache[i] * frameRate); + int frame = Mathf.RoundToInt(s_TickCache[i] * frameRate); // Important to take floor of positions of GUI stuff to get pixel correct alignment of // stuff drawn with both GUI and Handles/GL. Otherwise things are off by one pixel half the time. float labelpos = Mathf.Floor(FrameToPixel(frame, frameRate, position)); - string label = FormatTickTime(m_TickCache[i], frameRate, timeFormat); + string label = FormatTickTime(s_TickCache[i], frameRate, timeFormat); GUI.Label(new Rect(labelpos + 3, -1, 40, 20), label, timeAreaStyles.timelineTick); } } diff --git a/Editor/Mono/Animation/TransitionPreview.cs b/Editor/Mono/Animation/TransitionPreview.cs index da4a2629d2..6b26f509e6 100644 --- a/Editor/Mono/Animation/TransitionPreview.cs +++ b/Editor/Mono/Animation/TransitionPreview.cs @@ -36,6 +36,7 @@ internal class TransitionPreview private bool m_MustResample = true; private bool m_MustSampleMotions = false; + private bool m_MustResetParameterInfoList = false; public bool mustResample { set { m_MustResample = value; } get { return m_MustResample; } } private float m_LastEvalTime = -1.0f; private bool m_IsResampling = false; @@ -268,7 +269,7 @@ private void ResampleTransition(AnimatorStateTransition transition, AvatarMask l AnimatorStateInfo currentState = m_AvatarPreview.Animator.GetCurrentAnimatorStateInfo(m_LayerIndex); m_LeftStateWeightA = currentState.normalizedTime; m_LeftStateTimeA = currentTime; - while (!hasFinished && currentTime < maxDuration) + while (!hasFinished) { m_AvatarPreview.Animator.Update(stepTime); @@ -302,7 +303,7 @@ private void ResampleTransition(AnimatorStateTransition transition, AvatarMask l m_LeftStateTimeB = currentTime; } - if (hasTransitioned) + if (hasTransitioned || hasFinished) { m_RightStateWeightB = currentState.normalizedTime; m_RightStateTimeB = currentTime; @@ -328,6 +329,11 @@ private void ResampleTransition(AnimatorStateTransition transition, AvatarMask l float leftDuration = (m_LeftStateTimeB - m_LeftStateTimeA) / (m_LeftStateWeightB - m_LeftStateWeightA); float rightDuration = (m_RightStateTimeB - m_RightStateTimeA) / (m_RightStateWeightB - m_RightStateWeightA); + // Ensure step times make sense based on these timings + // If step time is too small, the samping will take too long + currentStateStepTime = Mathf.Max(currentStateStepTime, leftDuration / 600.0f); + nextStateStepTime = Mathf.Max(nextStateStepTime, rightDuration / 600.0f); + if (m_MustSampleMotions) { // Do this as infrequently as possible @@ -398,6 +404,8 @@ private void ResampleTransition(AnimatorStateTransition transition, AvatarMask l public void SetTransition(AnimatorStateTransition transition, AnimatorState sourceState, AnimatorState destinationState, AnimatorControllerLayer srcLayer, Animator previewObject) { m_RefSrcState = sourceState; + m_MustResetParameterInfoList = m_RefDstState != destinationState; + m_RefDstState = destinationState; TransitionInfo info = new TransitionInfo(); info.Set(transition, sourceState, destinationState); @@ -589,10 +597,12 @@ private void Init(Animator scenePreviewObject, Motion motion) CreateController(); - if (m_ParameterInfoList == null) + if(m_ParameterInfoList == null || m_MustResetParameterInfoList) { + m_MustResetParameterInfoList = false; CreateParameterInfoList(); } + } public void DoTransitionPreview() @@ -600,9 +610,6 @@ public void DoTransitionPreview() if (m_Controller == null) return; - if (Event.current.type == EventType.Repaint) - m_AvatarPreview.timeControl.Update(); - DoTimeline(); // Draw the blend values @@ -721,7 +728,12 @@ public void OnInteractivePreviewGUI(Rect r, GUIStyle background) { if (m_AvatarPreview != null && m_Controller != null) { - if (m_LastEvalTime != m_AvatarPreview.timeControl.currentTime && Event.current.type == EventType.Repaint) + bool isRepaint = (Event.current.type == EventType.Repaint); + + if (isRepaint) + m_AvatarPreview.timeControl.Update(); + + if (m_LastEvalTime != m_AvatarPreview.timeControl.currentTime && isRepaint) { m_AvatarPreview.Animator.playbackTime = m_AvatarPreview.timeControl.currentTime; m_AvatarPreview.Animator.Update(0); diff --git a/Editor/Mono/Animation/ZoomableArea.cs b/Editor/Mono/Animation/ZoomableArea.cs index 4685bc4e13..b93187d184 100644 --- a/Editor/Mono/Animation/ZoomableArea.cs +++ b/Editor/Mono/Animation/ZoomableArea.cs @@ -85,9 +85,27 @@ private void SetAllowExceed(ref float rangeEnd, ref bool allowExceed, float valu private float m_VScaleMin = kMinScale; private float m_VScaleMax = kMaxScale; - private const float kMinWidth = 0.05f; + private float m_MinWidth = 0.05f; private const float kMinHeight = 0.05f; + private const float k_ScrollStepSize = 10f; // mirrors GUI scrollstepsize as there is no global const for this. + + public float minWidth + { + get { return m_MinWidth; } + set + { + if (value > 0) + m_MinWidth = value; + else + { + Debug.LogWarning("Zoomable area width cannot have a value of " + + "or below 0. Reverting back to a default value of 0.05f"); + m_MinWidth = 0.05f; + } + } + } + public float hScaleMin { get { return m_HScaleMin; } @@ -352,10 +370,10 @@ public Rect rect public void SetShownHRangeInsideMargins(float min, float max) { float widthInsideMargins = drawRect.width - leftmargin - rightmargin; - if (widthInsideMargins < kMinWidth) widthInsideMargins = kMinWidth; + if (widthInsideMargins < m_MinWidth) widthInsideMargins = m_MinWidth; float denum = max - min; - if (denum < kMinWidth) denum = kMinWidth; + if (denum < m_MinWidth) denum = m_MinWidth; m_Scale.x = widthInsideMargins / denum; @@ -366,7 +384,7 @@ public void SetShownHRangeInsideMargins(float min, float max) public void SetShownHRange(float min, float max) { float denum = max - min; - if (denum < kMinWidth) denum = kMinWidth; + if (denum < m_MinWidth) denum = m_MinWidth; m_Scale.x = drawRect.width / denum; @@ -418,7 +436,7 @@ public Rect shownArea { set { - float width = (value.width < kMinWidth) ? kMinWidth : value.width; + float width = (value.width < m_MinWidth) ? m_MinWidth : value.width; float height = (value.height < kMinHeight) ? kMinHeight : value.height; if (m_UpDirection == YDirection.Positive) @@ -477,11 +495,11 @@ private Rect shownAreaInsideMarginsInternal { set { - float width = (value.width < kMinWidth) ? kMinWidth : value.width; + float width = (value.width < m_MinWidth) ? m_MinWidth : value.width; float height = (value.height < kMinHeight) ? kMinHeight : value.height; float widthInsideMargins = drawRect.width - leftmargin - rightmargin; - if (widthInsideMargins < kMinWidth) widthInsideMargins = kMinWidth; + if (widthInsideMargins < m_MinWidth) widthInsideMargins = m_MinWidth; float heightInsideMargins = drawRect.height - topmargin - bottommargin; if (heightInsideMargins < kMinHeight) heightInsideMargins = kMinHeight; @@ -519,9 +537,9 @@ private Rect shownAreaInsideMarginsInternal float GetWidthInsideMargins(float widthWithMargins, bool substractSliderWidth = false) { - float width = (widthWithMargins < kMinWidth) ? kMinWidth : widthWithMargins; + float width = (widthWithMargins < m_MinWidth) ? m_MinWidth : widthWithMargins; float widthInsideMargins = width - leftmargin - rightmargin - (substractSliderWidth ? (m_VSlider ? styles.visualSliderWidth : 0) : 0); - return Mathf.Max(widthInsideMargins, kMinWidth); + return Mathf.Max(widthInsideMargins, m_MinWidth); } float GetHeightInsideMargins(float heightWithMargins, bool substractSliderHeight = false) @@ -696,7 +714,11 @@ public void HandleZoomAndPanEvents(Rect area) break; case EventType.ScrollWheel: if (!area.Contains(Event.current.mousePosition)) + { + HandleScrolling(area); break; + } + if (m_IgnoreScrollWheelUntilClicked && GUIUtility.keyboardControl != id) break; @@ -709,6 +731,24 @@ public void HandleZoomAndPanEvents(Rect area) GUILayout.EndArea(); } + void HandleScrolling(Rect area) + { + if (m_MinimalGUI) + return; + if (m_VSlider && new Rect(area.x + area.width, area.y + GUI.skin.verticalScrollbarUpButton.fixedHeight, vSliderWidth, area.height - (GUI.skin.verticalScrollbarDownButton.fixedHeight + hSliderHeight)).Contains(Event.current.mousePosition)) + { + SetTransform(new Vector2(m_Translation.x, m_Translation.y - (Event.current.delta.y * k_ScrollStepSize)), m_Scale); + Event.current.Use(); + return; + } + + if (m_HSlider && new Rect(area.x + GUI.skin.horizontalScrollbarLeftButton.fixedWidth, area.y + area.height, area.width - (GUI.skin.horizontalScrollbarRightButton.fixedWidth + vSliderWidth), hSliderHeight).Contains(Event.current.mousePosition)) + { + SetTransform(new Vector2(m_Translation.x + (Event.current.delta.y * k_ScrollStepSize), m_Translation.y), m_Scale); + Event.current.Use(); + } + } + public void EndViewGUI() { if (m_MinimalGUI && Event.current.type == EventType.Repaint) @@ -867,7 +907,7 @@ private void HandleZoomEvent(Vector2 zoomAround, bool scrollwhell) // Cap scale when at min width to not "glide" away when zooming closer float width = shownAreaInsideMargins.width; - if (width / scale <= kMinWidth) + if (width / scale <= m_MinWidth) return; SetScaleFocused(zoomAround, scale * m_Scale, Event.current.shift, EditorGUI.actionKey); @@ -947,7 +987,7 @@ public void EnforceScaleAndRange() { // range only has an influence if it is enforced, i.e. not infinity float denum = hRangeMax - hRangeMin; - if (denum < kMinWidth) denum = kMinWidth; + if (denum < m_MinWidth) denum = m_MinWidth; constrainedWidth = Mathf.Min(constrainedWidth, denum); } diff --git a/Editor/Mono/AnimatorController.bindings.cs b/Editor/Mono/AnimatorController.bindings.cs index 46d865b2ac..49b5dce79c 100644 --- a/Editor/Mono/AnimatorController.bindings.cs +++ b/Editor/Mono/AnimatorController.bindings.cs @@ -33,6 +33,7 @@ extern public AnimatorControllerLayer[] layers [FreeFunction(Name = "AnimatorControllerBindings::GetLayers", HasExplicitThis = true)] get; [FreeFunction(Name = "AnimatorControllerBindings::SetLayers", HasExplicitThis = true, ThrowsException = true)] + [param: Unmarshalled] set; } @@ -41,6 +42,7 @@ extern public AnimatorControllerParameter[] parameters [FreeFunction(Name = "AnimatorControllerBindings::GetParameters", HasExplicitThis = true)] get; [FreeFunction(Name = "AnimatorControllerBindings::SetParameters", HasExplicitThis = true, ThrowsException = true)] + [param: Unmarshalled] set; } @@ -87,7 +89,7 @@ static public StateMachineBehaviourContext[] FindStateMachineBehaviourContext(St extern internal MonoScript GetBehaviourMonoScript(AnimatorState state, int layerIndex, int behaviourIndex); [FreeFunction] - extern private static ScriptableObject ScriptingAddStateMachineBehaviourWithType(Type stateMachineBehaviourType, AnimatorController controller, AnimatorState state, int layerIndex); + extern private static ScriptableObject ScriptingAddStateMachineBehaviourWithType(Type stateMachineBehaviourType, [NotNull] AnimatorController controller, [NotNull] AnimatorState state, int layerIndex); [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)] @@ -133,6 +135,6 @@ internal extern bool isAssetBundled extern internal ScriptableObject[] Internal_GetEffectiveBehaviours([NotNull] AnimatorState state, int layerIndex); [FreeFunction(Name = "AnimatorControllerBindings::Internal_SetEffectiveBehaviours", HasExplicitThis = true)] - extern internal void Internal_SetEffectiveBehaviours([NotNull] AnimatorState state, int layerIndex, ScriptableObject[] behaviours); + extern internal void Internal_SetEffectiveBehaviours([NotNull] AnimatorState state, int layerIndex, [Unmarshalled] ScriptableObject[] behaviours); } } diff --git a/Editor/Mono/Annotation/AnnotationUtility.bindings.cs b/Editor/Mono/Annotation/AnnotationUtility.bindings.cs index adf769c77a..1efe191cbc 100644 --- a/Editor/Mono/Annotation/AnnotationUtility.bindings.cs +++ b/Editor/Mono/Annotation/AnnotationUtility.bindings.cs @@ -3,13 +3,12 @@ // https://unity3d.com/legal/licenses/Unity_Reference_Only_License using System; -using System.Runtime.InteropServices; using UnityEngine.Bindings; namespace UnityEditor { [NativeType(CodegenOptions.Custom, "AnnotationBindings")] - internal partial struct Annotation + struct Annotation { public int iconEnabled; public int gizmoEnabled; @@ -19,13 +18,23 @@ internal partial struct Annotation } [NativeHeader("Editor/Mono/Annotation/AnnotationUtility.bindings.h")] - [NativeHeader("Editor/Src/AnnotationManager.h")] - internal sealed partial class AnnotationUtility + [NativeHeader("Editor/Src/Gizmos/AnnotationManager.h")] + static class AnnotationUtility { + // Similar values as in Annotation (in AnnotationManager.h) + public enum Flags + { + kHasIcon = 1 << 0, + kHasGizmo = 1 << 1, + kIsDisabled = 1 << 2 + }; + extern internal static Annotation[] GetAnnotations(); extern internal static Annotation[] GetRecentlyChangedAnnotations(); + extern internal static Annotation GetAnnotation(int classID, string scriptClass); + [StaticAccessor("GetAnnotationManager()", StaticAccessorType.Dot)] extern internal static string GetNameOfCurrentSetup(); @@ -69,5 +78,14 @@ internal sealed partial class AnnotationUtility [StaticAccessor("GetAnnotationManager()", StaticAccessorType.Dot)] internal extern static float iconSize { get; set; } + + [StaticAccessor("GetAnnotationManager()", StaticAccessorType.Dot)] + internal extern static float fadeGizmoSize { get; set; } + + [StaticAccessor("GetAnnotationManager()", StaticAccessorType.Dot)] + internal extern static bool fadeGizmos { get; set; } + + [StaticAccessor("GetAnnotationManager()", StaticAccessorType.Dot)] + internal extern static bool useInspectorExpandedState { get; set; } } } diff --git a/Editor/Mono/Annotation/AnnotationWindow.cs b/Editor/Mono/Annotation/AnnotationWindow.cs index ed885a0b41..8442759474 100644 --- a/Editor/Mono/Annotation/AnnotationWindow.cs +++ b/Editor/Mono/Annotation/AnnotationWindow.cs @@ -4,16 +4,24 @@ using UnityEngine; using System.Collections.Generic; -using System.Globalization; +using UnityEditor.ShortcutManagement; namespace UnityEditor { internal class AnnotationWindow : EditorWindow { + private static SavedBool s_ShowTerrainDebugWarnings = new SavedBool("Terrain.ShowDebugWarnings", true); + + public static bool ShowTerrainDebugWarnings + { + get => s_ShowTerrainDebugWarnings.value; + set => s_ShowTerrainDebugWarnings.value = value; + } + class Styles { public GUIStyle toggle = "Toggle"; - public GUIStyle toggleMixed = "ToggleMixed"; + public GUIStyle toggleMixed = EditorStyles.toggleMixed; public GUIStyle listEvenBg = "ObjectPickerResultsOdd";//"ObjectPickerResultsEven";// public GUIStyle listOddBg = "ObjectPickerResultsEven";//"ObjectPickerResultsEven";// public GUIStyle background = "grey_border"; @@ -21,7 +29,6 @@ class Styles public GUIStyle iconDropDown = "IN dropdown"; public GUIStyle listTextStyle; public GUIStyle listHeaderStyle; - public GUIStyle texelWorldSizeStyle; public GUIStyle columnHeaderStyle; public const float k_ToggleSize = 17f; @@ -34,12 +41,6 @@ public Styles() listHeaderStyle = new GUIStyle(EditorStyles.boldLabel); listHeaderStyle.padding.left = 5; - texelWorldSizeStyle = new GUIStyle(EditorStyles.label); - texelWorldSizeStyle.alignment = TextAnchor.UpperRight; - texelWorldSizeStyle.font = EditorStyles.miniLabel.font; - texelWorldSizeStyle.fontSize = EditorStyles.miniLabel.fontSize; - texelWorldSizeStyle.padding.right = 0; - columnHeaderStyle = EditorStyles.miniLabel; } } @@ -52,41 +53,50 @@ private enum EnabledState Mixed = 2 } - const float kWindowWidth = 270; - const float scrollBarWidth = 14; - const float listElementHeight = 18; + const float k_WindowWidth = 270; + const float k_ScrollBarWidth = 14; + const float k_ListElementHeight = 18; + const float k_FrameWidth = 1f; float iconSize = 16; float gizmoRightAlign; float gizmoTextRightAlign; float iconRightAlign; float iconTextRightAlign; - const float frameWidth = 1f; - static bool s_Debug = false; static AnnotationWindow s_AnnotationWindow = null; static long s_LastClosedTime; + const long k_JustClosedPeriod = 400; + static Styles m_Styles; - List m_RecentAnnotations; - List m_BuiltinAnnotations; - List m_ScriptAnnotations; + List m_RecentAnnotations; + List m_BuiltinAnnotations; + List m_ScriptAnnotations; Vector2 m_ScrollPosition; bool m_SyncWithState; string m_LastScriptThatHasShownTheIconSelector; + List m_MonoScriptIconsChanged; const int maxShowRecent = 5; readonly string textGizmoVisible = L10n.Tr("Show/Hide Gizmo"); + GUIContent generalContent = EditorGUIUtility.TrTextContent("General"); GUIContent iconToggleContent = EditorGUIUtility.TrTextContent("", "Show/Hide Icon"); GUIContent iconSelectContent = EditorGUIUtility.TrTextContent("", "Select Icon"); GUIContent icon3dGizmoContent = EditorGUIUtility.TrTextContent("3D Icons"); + GUIContent terrainDebugWarnings = EditorGUIUtility.TrTextContent("Terrain Debug Warnings"); GUIContent showOutlineContent = EditorGUIUtility.TrTextContent("Selection Outline"); GUIContent showWireframeContent = EditorGUIUtility.TrTextContent("Selection Wire"); + GUIContent fadeGizmosContent = EditorGUIUtility.TrTextContent("Fade Gizmos", "Fade out and stop rendering gizmos that are small on screen"); + GUIContent lightProbeVisualizationContent = EditorGUIUtility.TrTextContent("Light Probe Visualization"); + GUIContent displayWeightsContent = EditorGUIUtility.TrTextContent("Display Weights"); + GUIContent displayOcclusionContent = EditorGUIUtility.TrTextContent("Display Occlusion"); + GUIContent highlightInvalidCellsContent = EditorGUIUtility.TrTextContent("Highlight Invalid Cells", "Highlight the invalid cells that cannot be used for probe interpolation."); private bool m_IsGameView; + string m_SearchFilter = string.Empty; + const float exponentStart = -3.0f; const float exponentRange = 3.0f; - const string kAlwaysFullSizeText = "Always Full Size"; - const string kHideAllIconsText = "Hide All Icons"; static float ConvertTexelWorldSizeTo01(float texelWorldSize) { @@ -104,22 +114,6 @@ static float Convert01ToTexelWorldSize(float value01) return Mathf.Pow(10.0f, exponentStart + exponentRange * value01); // texel size is between 10e-2 (0.01) and 10e2 (100) worldunits. (texel in the icon texture) } - static string ConvertTexelWorldSizeToString(float texelWorldSize) - { - if (texelWorldSize == -1.0f) - { - return kAlwaysFullSizeText; - } - if (texelWorldSize == 0.0f) - { - return kHideAllIconsText; - } - - float displaySize = texelWorldSize * 32.0f; // The 32 is default icon size, so we show worldsize for 32 pixel icons. - int numDecimals = MathUtils.GetNumberOfDecimalsForMinimumDifference(displaySize * 0.1f); - return displaySize.ToString("N" + numDecimals, CultureInfo.InvariantCulture.NumberFormat); - } - public void MonoScriptIconChanged(MonoScript monoScript) { if (monoScript == null) @@ -142,7 +136,18 @@ static public void IconChanged() float GetTopSectionHeight() { - const int numberOfControls = 3; + const int numberOfGeneralControls = 6; + + int numberOfLightProbeVisualizationControls = 0; + if (!UnityEngine.Rendering.SupportedRenderingFeatures.active.overridesLightProbeSystem) + { + if (LightProbeVisualization.lightProbeVisualizationMode == LightProbeVisualization.LightProbeVisualizationMode.None) + numberOfLightProbeVisualizationControls = 3; + else + numberOfLightProbeVisualizationControls = 5; + } + + int numberOfControls = numberOfGeneralControls + numberOfLightProbeVisualizationControls; return EditorGUI.kSingleLineHeight * numberOfControls + EditorGUI.kControlVerticalSpacing * (numberOfControls - 1) + EditorStyles.inspectorBig.padding.bottom; } @@ -157,7 +162,7 @@ void OnDisable() AssemblyReloadEvents.beforeAssemblyReload -= Close; // When window closes we copy all changes to monoimporters (reimport monoScripts) foreach (MonoScript monoScript in m_MonoScriptIconsChanged) - MonoImporter.CopyMonoScriptIconToImporters(monoScript); + IconSelector.CopyIconToImporter(monoScript); s_LastClosedTime = System.DateTime.Now.Ticks / System.TimeSpan.TicksPerMillisecond; s_AnnotationWindow = null; @@ -167,7 +172,7 @@ internal static bool ShowAtPosition(Rect buttonRect, bool isGameView) { // 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; + bool justClosed = nowMilliSeconds < s_LastClosedTime + k_JustClosedPeriod; if (!justClosed) { Event.current.Use(); @@ -201,9 +206,9 @@ void Init(Rect buttonRect, bool isGameView) SyncToState(); - float windowHeight = 2 * frameWidth + GetTopSectionHeight() + DrawNormalList(false, 100, 0, 10000); + float windowHeight = 2 * k_FrameWidth + GetTopSectionHeight() + DrawNormalList(false, 100, 0, 10000); windowHeight = Mathf.Min(windowHeight, 900); - Vector2 windowSize = new Vector2(kWindowWidth, windowHeight); + Vector2 windowSize = new Vector2(k_WindowWidth, windowHeight); ShowAsDropDown(buttonRect, windowSize); } @@ -213,18 +218,19 @@ private void IconHasChanged() if (string.IsNullOrEmpty(m_LastScriptThatHasShownTheIconSelector)) return; - foreach (AInfo t in m_ScriptAnnotations) + foreach (GizmoInfo t in m_ScriptAnnotations) { - if (t.m_ScriptClass == m_LastScriptThatHasShownTheIconSelector) + if (t.scriptClass == m_LastScriptThatHasShownTheIconSelector) { - if (t.m_IconEnabled == false) + if (t.iconEnabled == false) { - t.m_IconEnabled = true; + t.iconEnabled = true; SetIconState(t); break; } } } + SyncToState(); Repaint(); } @@ -241,12 +247,12 @@ void Cancel() GUIUtility.ExitGUI(); } - AInfo GetAInfo(int classID, string scriptClass) + GizmoInfo GetAInfo(int classID, string scriptClass) { if (scriptClass != "") - return m_ScriptAnnotations.Find(delegate(AInfo o) { return o.m_ScriptClass == scriptClass; }); + return m_ScriptAnnotations.Find(delegate(GizmoInfo o) { return o.scriptClass == scriptClass; }); - return m_BuiltinAnnotations.Find(delegate(AInfo o) { return o.m_ClassID == classID; }); + return m_BuiltinAnnotations.Find(delegate(GizmoInfo o) { return o.classID == classID; }); } private void SyncToState() @@ -254,53 +260,33 @@ private void SyncToState() // Sync annotations Annotation[] a = AnnotationUtility.GetAnnotations(); - string debuginfo = ""; - if (s_Debug) - debuginfo += "AnnotationWindow: SyncToState\n"; - - m_BuiltinAnnotations = new List(); - m_ScriptAnnotations = new List(); + m_BuiltinAnnotations = new List(); + m_ScriptAnnotations = new List(); for (int i = 0; i < a.Length; ++i) { - if (s_Debug) - debuginfo += " same as below: icon " + a[i].iconEnabled + " gizmo " + a[i].gizmoEnabled + "\n"; - - bool ge = (a[i].gizmoEnabled == 1); - bool ie = (a[i].iconEnabled == 1); - AInfo anno = new AInfo(ge, ie, a[i].flags, a[i].classID, a[i].scriptClass); + GizmoInfo anno = new GizmoInfo(a[i]); - if (anno.m_ScriptClass == "") - { + if(string.IsNullOrEmpty(anno.scriptClass)) m_BuiltinAnnotations.Add(anno); - if (s_Debug) - debuginfo += " " + UnityType.FindTypeByPersistentTypeID(anno.m_ClassID).name + ": icon " + anno.m_IconEnabled + " gizmo " + anno.m_GizmoEnabled + "\n"; - } else - { m_ScriptAnnotations.Add(anno); - if (s_Debug) - debuginfo += " " + a[i].scriptClass + ": icon " + anno.m_IconEnabled + " gizmo " + anno.m_GizmoEnabled + "\n"; - } } m_BuiltinAnnotations.Sort(); m_ScriptAnnotations.Sort(); // Sync recently changed annotations - m_RecentAnnotations = new List(); + m_RecentAnnotations = new List(); Annotation[] recent = AnnotationUtility.GetRecentlyChangedAnnotations(); for (int i = 0; i < recent.Length && i < maxShowRecent; ++i) { // Note: ainfo can be null if script has been renamed. - AInfo ainfo = GetAInfo(recent[i].classID, recent[i].scriptClass); + GizmoInfo ainfo = GetAInfo(recent[i].classID, recent[i].scriptClass); if (ainfo != null) m_RecentAnnotations.Add(ainfo); } m_SyncWithState = false; - - if (s_Debug) - Debug.Log(debuginfo); } internal void OnGUI() @@ -330,31 +316,26 @@ internal void OnGUI() void DrawTopSection(float topSectionHeight) { // Bg - GUI.Label(new Rect(frameWidth, 0, position.width - 2 * frameWidth, topSectionHeight), "", EditorStyles.inspectorBig); + GUI.Label(new Rect(k_FrameWidth, 0, position.width - 2 * k_FrameWidth, topSectionHeight), "", EditorStyles.inspectorBig); float topmargin = 7; float margin = 11; float curY = topmargin; - - float labelWidth = m_Styles.listHeaderStyle.CalcSize(showOutlineContent).x + GUI.skin.toggle.CalcSize(GUIContent.none).x + 1; + float labelWidth = m_Styles.listHeaderStyle.CalcSize(terrainDebugWarnings).x + GUI.skin.toggle.CalcSize(GUIContent.none).x + 1; float rowHeight = 18; - // Toggle 3D gizmos + // General section Rect toggleRect = new Rect(margin, curY, labelWidth, rowHeight); - AnnotationUtility.use3dGizmos = GUI.Toggle(toggleRect, AnnotationUtility.use3dGizmos, icon3dGizmoContent); - - // Texel world size - float texelWorldSize = AnnotationUtility.iconSize; - if (s_Debug) - { - Rect texelSizeRect = new Rect(0, curY + 10, position.width - margin, rowHeight); - GUI.Label(texelSizeRect, ConvertTexelWorldSizeToString(texelWorldSize), m_Styles.texelWorldSizeStyle); - } + GUI.Label(toggleRect, generalContent, EditorStyles.boldLabel); + curY += rowHeight; + // 3D icons toggle & slider + toggleRect = new Rect(margin, curY, labelWidth, rowHeight); + AnnotationUtility.use3dGizmos = GUI.Toggle(toggleRect, AnnotationUtility.use3dGizmos, icon3dGizmoContent); using (new EditorGUI.DisabledScope(!AnnotationUtility.use3dGizmos)) { - // Slider + float texelWorldSize = AnnotationUtility.iconSize; float sliderWidth = position.width - margin - labelWidth; float iconSize01 = ConvertTexelWorldSizeTo01(texelWorldSize); Rect sliderRect = new Rect(labelWidth + margin, curY, sliderWidth - margin, rowHeight); @@ -365,17 +346,70 @@ void DrawTopSection(float topSectionHeight) SceneView.RepaintAll(); } } + curY += rowHeight; + // Gizmo fadeout toggle & slider + toggleRect = new Rect(margin, curY, labelWidth, rowHeight); + AnnotationUtility.fadeGizmos = GUI.Toggle(toggleRect, AnnotationUtility.fadeGizmos, fadeGizmosContent); + using (new EditorGUI.DisabledScope(!AnnotationUtility.fadeGizmos)) + { + float fadeSize = AnnotationUtility.fadeGizmoSize; + float sliderWidth = position.width - margin - labelWidth; + Rect sliderRect = new Rect(labelWidth + margin, curY, sliderWidth - margin, rowHeight); + float newFadeSize = GUI.HorizontalSlider(sliderRect, fadeSize, 2.0f, 10.0f); + if (fadeSize != newFadeSize) + { + AnnotationUtility.fadeGizmoSize = newFadeSize; + SceneView.RepaintAll(); + } + } curY += rowHeight; - // Show Grid using (new EditorGUI.DisabledScope(m_IsGameView)) { + // Selection outline/wire toggleRect = new Rect(margin, curY, labelWidth, rowHeight); AnnotationUtility.showSelectionOutline = GUI.Toggle(toggleRect, AnnotationUtility.showSelectionOutline, showOutlineContent); + curY += rowHeight; - toggleRect.y += rowHeight; + toggleRect = new Rect(margin, curY, labelWidth, rowHeight); AnnotationUtility.showSelectionWire = GUI.Toggle(toggleRect, AnnotationUtility.showSelectionWire, showWireframeContent); + curY += rowHeight; + + // TODO: Change to Debug Errors & Debug Warnings + toggleRect = new Rect(margin, curY, labelWidth, rowHeight); + EditorGUI.BeginChangeCheck(); + s_ShowTerrainDebugWarnings.value = GUI.Toggle(toggleRect, s_ShowTerrainDebugWarnings.value, terrainDebugWarnings); + if (EditorGUI.EndChangeCheck()) + SceneView.RepaintAll(); + } + curY += rowHeight; + + // Light probe section + if (!UnityEngine.Rendering.SupportedRenderingFeatures.active.overridesLightProbeSystem) + { + curY += rowHeight; + toggleRect = new Rect(margin, curY, labelWidth, rowHeight); + GUI.Label(toggleRect, lightProbeVisualizationContent, EditorStyles.boldLabel); + curY += rowHeight; + + toggleRect = new Rect(margin, curY, position.width - margin * 2, rowHeight); + LightProbeVisualization.lightProbeVisualizationMode = (LightProbeVisualization.LightProbeVisualizationMode)EditorGUI.EnumPopup(toggleRect, LightProbeVisualization.lightProbeVisualizationMode); + curY += rowHeight; + + if (LightProbeVisualization.lightProbeVisualizationMode != LightProbeVisualization.LightProbeVisualizationMode.None) + { + toggleRect = new Rect(margin, curY, labelWidth, rowHeight); + LightProbeVisualization.showInterpolationWeights = GUI.Toggle(toggleRect, LightProbeVisualization.showInterpolationWeights, displayWeightsContent); + curY += rowHeight; + + toggleRect = new Rect(margin, curY, labelWidth, rowHeight); + LightProbeVisualization.showOcclusions = GUI.Toggle(toggleRect, LightProbeVisualization.showOcclusions, displayOcclusionContent); + curY += rowHeight; + + toggleRect = new Rect(margin, curY, labelWidth, rowHeight); + LightProbeVisualization.highlightInvalidCells = GUI.Toggle(toggleRect, LightProbeVisualization.highlightInvalidCells, highlightInvalidCellsContent); + } } } @@ -391,18 +425,18 @@ void DrawAnnotationList(float startY, float height) Rect scrollViewRect = new Rect(0, startY + barHeight, position.width - 4, - height - barHeight - frameWidth); + height - barHeight - k_FrameWidth); float totalContentHeight = DrawNormalList(false, 0, 0, 100000); Rect contentRect = new Rect(0, 0, 1, totalContentHeight); bool isScrollbarVisible = totalContentHeight > scrollViewRect.height; float listElementWidth = scrollViewRect.width; if (isScrollbarVisible) - listElementWidth -= scrollBarWidth; + listElementWidth -= k_ScrollBarWidth; // Scrollview m_ScrollPosition = GUI.BeginScrollView(scrollViewRect, m_ScrollPosition, contentRect, false, false, GUI.skin.horizontalScrollbar, GUI.skin.verticalScrollbar, EditorStyles.scrollViewAlt); { - DrawNormalList(true, listElementWidth, m_ScrollPosition.y - listElementHeight, m_ScrollPosition.y + totalContentHeight); + DrawNormalList(true, listElementWidth, m_ScrollPosition.y - k_ListElementHeight, m_ScrollPosition.y + totalContentHeight); } GUI.EndScrollView(); } @@ -417,17 +451,29 @@ float DrawNormalList(bool doDraw, float listElementWidth, float startY, float en bool even = true; float curY = 0; bool headerDrawn = false; + bool searchDrawn = false; - curY = DrawListSection(curY, L10n.Tr("Recently Changed"), m_RecentAnnotations, doDraw, listElementWidth, startY, endY, ref even, true, ref headerDrawn); - curY = DrawListSection(curY, L10n.Tr("Scripts"), m_ScriptAnnotations, doDraw, listElementWidth, startY, endY, ref even, false, ref headerDrawn); - curY = DrawListSection(curY, L10n.Tr("Built-in Components"), m_BuiltinAnnotations, doDraw, listElementWidth, startY, endY, ref even, false, ref headerDrawn); + curY = DrawListSection(curY, L10n.Tr("Recently Changed"), m_RecentAnnotations, doDraw, listElementWidth, startY, endY, ref even, true, ref headerDrawn, ref searchDrawn); + curY = DrawListSection(curY, L10n.Tr("Scripts"), m_ScriptAnnotations, doDraw, listElementWidth, startY, endY, ref even, false, ref headerDrawn, ref searchDrawn); + curY = DrawListSection(curY, L10n.Tr("Built-in Components"), m_BuiltinAnnotations, doDraw, listElementWidth, startY, endY, ref even, false, ref headerDrawn, ref searchDrawn); return curY; } - float DrawListSection(float y, string sectionHeader, List listElements, bool doDraw, float listElementWidth, float startY, float endY, ref bool even, bool useSeperator, ref bool headerDrawn) + bool DoesMatchFilter(GizmoInfo el) + { + if (string.IsNullOrEmpty(m_SearchFilter)) + return true; + if (el.name.IndexOf(m_SearchFilter, System.StringComparison.OrdinalIgnoreCase) < 0) + return false; + return true; + } + + float DrawListSection(float y, string sectionHeader, List listElements, bool doDraw, float listElementWidth, float startY, float endY, ref bool even, bool useSeperator, ref bool headerDrawn, ref bool searchDrawn) { float curY = y; + const float kSearchPaddingV = 3; + const float kSearchHeight = EditorGUI.kSingleSmallLineHeight + kSearchPaddingV; const float extraHeader = 15; const float headerHeight = 20; @@ -436,11 +482,24 @@ float DrawListSection(float y, string sectionHeader, List listElements, b if (doDraw) { // Header background - Rect rect = new Rect(1, curY, listElementWidth - 2, extraHeader + headerHeight); + Rect rect = new Rect(1, curY, listElementWidth - 2, extraHeader + (headerDrawn ? 0 : kSearchHeight) + headerHeight); Flip(ref even); GUIStyle backgroundStyle = even ? m_Styles.listEvenBg : m_Styles.listOddBg; // m_Styles.listSectionHeaderBg;// GUI.Label(rect, GUIContent.Temp(""), backgroundStyle); } + + // Search field + if (!searchDrawn) + { + searchDrawn = true; + if (doDraw) + { + Rect searchRect = new Rect(11, curY + kSearchPaddingV, listElementWidth - 16, EditorGUI.kSingleSmallLineHeight); + m_SearchFilter = EditorGUI.ToolbarSearchField(searchRect, m_SearchFilter, false); + } + curY += kSearchHeight; + } + curY += extraHeader; if (doDraw) { @@ -452,14 +511,16 @@ float DrawListSection(float y, string sectionHeader, List listElements, b // List elements for (int i = 0; i < listElements.Count; ++i) { + if (!DoesMatchFilter(listElements[i])) + continue; Flip(ref even); if (curY > startY && curY < endY) { - Rect rect = new Rect(1, curY, listElementWidth - 2, listElementHeight); + Rect rect = new Rect(1, curY, listElementWidth - 2, k_ListElementHeight); if (doDraw) DrawListElement(rect, even, listElements[i]); } - curY += listElementHeight; + curY += k_ListElementHeight; } if (useSeperator) @@ -478,7 +539,7 @@ float DrawListSection(float y, string sectionHeader, List listElements, b return curY; } - void DrawListHeader(string header, List elements, Rect rect, ref bool headerDrawn) + void DrawListHeader(string header, List elements, Rect rect, ref bool headerDrawn) { GUI.Label(rect, GUIContent.Temp(header), m_Styles.listHeaderStyle); @@ -488,14 +549,16 @@ void DrawListHeader(string header, List elements, Rect rect, ref bool hea for (int i = 0; i < elements.Count; i++) { var element = elements[i]; + if (!DoesMatchFilter(element)) + continue; - if (element.HasGizmo()) + if (element.hasGizmo) { if (enabledState == EnabledState.NotSet) { - enabledState = element.m_GizmoEnabled ? EnabledState.All : EnabledState.None; + enabledState = element.gizmoEnabled ? EnabledState.All : EnabledState.None; } - else if ((enabledState == EnabledState.All) != element.m_GizmoEnabled) + else if ((enabledState == EnabledState.All) != element.gizmoEnabled) { enabledState = EnabledState.Mixed; break; @@ -503,6 +566,9 @@ void DrawListHeader(string header, List elements, Rect rect, ref bool hea } } + if (enabledState == EnabledState.NotSet) + return; + var gizmoText = "gizmo"; var gizmoTextSize = m_Styles.columnHeaderStyle.CalcSize(new GUIContent(gizmoText)); gizmoTextRightAlign = gizmoTextSize.x; @@ -514,25 +580,26 @@ void DrawListHeader(string header, List elements, Rect rect, ref bool hea GUIStyle style = m_Styles.toggle; - bool enabled = enabledState > EnabledState.None; - + bool enabled = enabledState == EnabledState.All; bool setMixed = enabledState == EnabledState.Mixed; if (setMixed) style = m_Styles.toggleMixed; Rect toggleRect = new Rect(rect.width - gizmoRightAlign, rect.y + (rect.height - toggleSize) * 0.5f, toggleSize, toggleSize); + EditorGUI.BeginChangeCheck(); bool newEnabled = GUI.Toggle(toggleRect, enabled, GUIContent.none, style); - - if (newEnabled != enabled) + if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < elements.Count; i++) { var element = elements[i]; + if (!DoesMatchFilter(element)) + continue; - if (element.m_GizmoEnabled != newEnabled) + if (element.gizmoEnabled != newEnabled) { - element.m_GizmoEnabled = newEnabled; + element.gizmoEnabled = newEnabled; SetGizmoState(element, false); } } @@ -556,7 +623,7 @@ void DrawListHeader(string header, List elements, Rect rect, ref bool hea } } - void DrawListElement(Rect rect, bool even, AInfo ainfo) + void DrawListElement(Rect rect, bool even, GizmoInfo ainfo) { if (ainfo == null) { @@ -584,12 +651,12 @@ void DrawListElement(Rect rect, bool even, AInfo ainfo) Rect textRect = rect; //textRect.x += 22; textRect.width = rect.width - iconRightAlign - 22; // ensure text doesnt flow behind toggles - GUI.Label(textRect, ainfo.m_DisplayText, m_Styles.listTextStyle); + GUI.Label(textRect, ainfo.name, m_Styles.listTextStyle); // Icon toggle Rect iconRect = new Rect(rect.width - iconRightAlign + 2, rect.y + (rect.height - iconSize) * 0.5f, iconSize, iconSize); // +2 because the given rect is shortened by 2px before this method call - if (ainfo.m_ScriptClass != "") + if (ainfo.scriptClass != "") { Rect div = iconRect; div.x += 18; @@ -605,7 +672,7 @@ void DrawListElement(Rect rect, bool even, AInfo ainfo) GUI.DrawTexture(div, EditorGUIUtility.whiteTexture, ScaleMode.StretchToFill); GUI.color = Color.white; - if (!ainfo.IsDisabled()) + if (!ainfo.disabled) { Rect arrowRect = iconRect; arrowRect.x += 18; @@ -614,10 +681,10 @@ void DrawListElement(Rect rect, bool even, AInfo ainfo) if (GUI.Button(arrowRect, iconSelectContent, m_Styles.iconDropDown)) { - Object script = EditorGUIUtility.GetScript(ainfo.m_ScriptClass); + Object script = EditorGUIUtility.GetScript(ainfo.scriptClass); if (script != null) { - m_LastScriptThatHasShownTheIconSelector = ainfo.m_ScriptClass; + m_LastScriptThatHasShownTheIconSelector = ainfo.scriptClass; if (IconSelector.ShowAtPosition(script, arrowRect, true)) { IconSelector.SetMonoScriptIconChangedCallback(MonoScriptIconChanged); @@ -628,18 +695,18 @@ void DrawListElement(Rect rect, bool even, AInfo ainfo) } } - if (ainfo.Thumb != null) + if (ainfo.thumb != null) { - if (!ainfo.m_IconEnabled) + if (!ainfo.iconEnabled) { GUI.color = new Color(GUI.color.r, GUI.color.g, GUI.color.b, disabledAlpha); tooltip = ""; } - iconToggleContent.image = ainfo.Thumb; + iconToggleContent.image = ainfo.thumb; if (GUI.Button(iconRect, iconToggleContent, GUIStyle.none)) { - ainfo.m_IconEnabled = !ainfo.m_IconEnabled; + ainfo.iconEnabled = !ainfo.iconEnabled; SetIconState(ainfo); } @@ -656,12 +723,12 @@ void DrawListElement(Rect rect, bool even, AInfo ainfo) GUI.color = orgColor; // Gizmo toggle - if (ainfo.HasGizmo()) + if (ainfo.hasGizmo) { tooltip = textGizmoVisible; Rect togglerRect = new Rect(rect.width - gizmoRightAlign + 2, rect.y + (rect.height - togglerSize) * 0.5f, togglerSize, togglerSize); // +2 because the given rect is shortened by 2px before this method call - ainfo.m_GizmoEnabled = GUI.Toggle(togglerRect, ainfo.m_GizmoEnabled, new GUIContent("", tooltip), m_Styles.toggle); + ainfo.gizmoEnabled = GUI.Toggle(togglerRect, ainfo.gizmoEnabled, new GUIContent("", tooltip), m_Styles.toggle); if (GUI.changed) { SetGizmoState(ainfo); @@ -673,98 +740,28 @@ void DrawListElement(Rect rect, bool even, AInfo ainfo) GUI.color = orgColor; } - void SetIconState(AInfo ainfo) + void SetIconState(GizmoInfo ainfo) { - AnnotationUtility.SetIconEnabled(ainfo.m_ClassID, ainfo.m_ScriptClass, ainfo.m_IconEnabled ? 1 : 0); + AnnotationUtility.SetIconEnabled(ainfo.classID, ainfo.scriptClass, ainfo.iconEnabled ? 1 : 0); SceneView.RepaintAll(); } - void SetGizmoState(AInfo ainfo, bool addToMostRecentChanged = true) + void SetGizmoState(GizmoInfo ainfo, bool addToMostRecentChanged = true) { - AnnotationUtility.SetGizmoEnabled(ainfo.m_ClassID, ainfo.m_ScriptClass, ainfo.m_GizmoEnabled ? 1 : 0, addToMostRecentChanged); + AnnotationUtility.SetGizmoEnabled(ainfo.classID, ainfo.scriptClass, ainfo.gizmoEnabled ? 1 : 0, addToMostRecentChanged); SceneView.RepaintAll(); } - } - - internal class AInfo : System.IComparable, System.IEquatable - { - // Similar values as in Annotation (in AnnotationManager.h) - public enum Flags { kHasIcon = 1, kHasGizmo = 2, kIsDisabled = 4 } - - public AInfo(bool gizmoEnabled, bool iconEnabled, int flags, int classID, string scriptClass) - { - m_GizmoEnabled = gizmoEnabled; - m_IconEnabled = iconEnabled; - m_ClassID = classID; - m_ScriptClass = scriptClass; - m_Flags = flags; - if (m_ScriptClass == "") - m_DisplayText = UnityType.FindTypeByPersistentTypeID(m_ClassID).name; - else - m_DisplayText = m_ScriptClass; - } - - public bool m_IconEnabled; - public bool m_GizmoEnabled; - public int m_ClassID; - public string m_ScriptClass; - public string m_DisplayText; - public int m_Flags; - private Object m_Script; - public Object Script - { - get - { - if (m_Script == null && m_ScriptClass != "") - m_Script = EditorGUIUtility.GetScript(m_ScriptClass); - return m_Script; - } - } - private Texture2D m_Thumb; - public Texture2D Thumb - { - get - { - if (m_Thumb == null) - { - // Icon for scripts - if (Script != null) - m_Thumb = EditorGUIUtility.GetIconForObject(m_Script); - // Icon for builtin components - else if (HasIcon()) - m_Thumb = AssetPreview.GetMiniTypeThumbnailFromClassID(m_ClassID); - } - return m_Thumb; - } - } - - public bool HasGizmo() - { - return (m_Flags & (int)Flags.kHasGizmo) > 0; - } - - public bool HasIcon() - { - return (m_Flags & (int)Flags.kHasIcon) > 0; - } - - public bool IsDisabled() - { - return (m_Flags & (int)Flags.kIsDisabled) > 0; - } - public int CompareTo(object obj) + [Shortcut("Scene View/Toggle Selection Outline", typeof(SceneView))] + static void ToggleSelectionOutline() { - AInfo other = obj as AInfo; - if (other != null) - return this.m_DisplayText.CompareTo(other.m_DisplayText); - else - throw new System.ArgumentException("Object is not an AInfo"); + AnnotationUtility.showSelectionOutline = !AnnotationUtility.showSelectionOutline; } - public bool Equals(AInfo other) + [Shortcut("Scene View/Toggle Selection Wireframe", typeof(SceneView))] + static void ToggleSelectionWireframe() { - return (m_ClassID == other.m_ClassID && m_ScriptClass == other.m_ScriptClass); + AnnotationUtility.showSelectionWire = !AnnotationUtility.showSelectionWire; } } } diff --git a/Editor/Mono/Annotation/GizmoInfo.cs b/Editor/Mono/Annotation/GizmoInfo.cs new file mode 100644 index 0000000000..63c3abe3ef --- /dev/null +++ b/Editor/Mono/Annotation/GizmoInfo.cs @@ -0,0 +1,119 @@ +// 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 UnityObject = UnityEngine.Object; + +namespace UnityEditor +{ + [Serializable] + public class GizmoInfo : IComparable + { + [SerializeField] + bool m_IconEnabled; + + [SerializeField] + bool m_GizmoEnabled; + + [SerializeField] + int m_ClassID; + + [SerializeField] + string m_ScriptClass; + + [SerializeField] + string m_Name; + + [SerializeField] + int m_Flags; + + [NonSerialized] + UnityObject m_Script; + + [NonSerialized] + Texture2D m_Thumb; + + internal GizmoInfo() + { + m_IconEnabled = false; + m_GizmoEnabled = false; + m_ClassID = -1; + m_ScriptClass = null; + m_Name = ""; + m_Flags = 0; + } + + internal GizmoInfo(Annotation annotation) + { + m_GizmoEnabled = annotation.gizmoEnabled > 0; + m_IconEnabled = annotation.iconEnabled > 0; + m_ClassID = annotation.classID; + m_ScriptClass = annotation.scriptClass; + m_Flags = annotation.flags; + m_Name = string.IsNullOrEmpty(m_ScriptClass) + ? UnityType.FindTypeByPersistentTypeID(m_ClassID).name + : m_Name = m_ScriptClass; + } + + internal int classID => m_ClassID; + + internal string scriptClass => m_ScriptClass; + + public string name => m_Name; + + public bool hasGizmo => (m_Flags & (int)AnnotationUtility.Flags.kHasGizmo) > 0; + + public bool gizmoEnabled + { + get => m_GizmoEnabled; + set => m_GizmoEnabled = value; + } + + public bool hasIcon => (m_Flags & (int)AnnotationUtility.Flags.kHasIcon) > 0; + + public bool iconEnabled + { + get => m_IconEnabled; + set => m_IconEnabled = value; + } + + internal bool disabled => (m_Flags & (int)AnnotationUtility.Flags.kIsDisabled) > 0; + + public UnityObject script + { + get + { + if (m_Script == null && m_ScriptClass != "") + m_Script = EditorGUIUtility.GetScript(m_ScriptClass); + return m_Script; + } + } + + public Texture2D thumb + { + get + { + if (m_Thumb == null) + { + // Icon for scripts + if (script != null) + m_Thumb = EditorGUIUtility.GetIconForObject(m_Script); + // Icon for builtin components + else if (hasIcon) + m_Thumb = AssetPreview.GetMiniTypeThumbnailFromClassID(m_ClassID); + } + + return m_Thumb; + } + } + + public int CompareTo(object obj) + { + if(obj is GizmoInfo other) + return m_Name.CompareTo(other.m_Name); + return 1; + } + } +} diff --git a/Editor/Mono/Annotation/GizmoUtility.cs b/Editor/Mono/Annotation/GizmoUtility.cs new file mode 100644 index 0000000000..ea1c5b5b92 --- /dev/null +++ b/Editor/Mono/Annotation/GizmoUtility.cs @@ -0,0 +1,77 @@ +// 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.Linq; +using UnityEngine; + +namespace UnityEditor +{ + public static class GizmoUtility + { + const float k_MinFadeGizmoSize = 1f; + const float k_MaxFadeGizmoSize = 10f; + + static void GetAnnotationIdAndClass(Type type, out int id, out string klass) + { + var unityType = UnityType.FindTypeByName(type.Name); + id = unityType?.persistentTypeID ?? 0; + // In AnnotationManager, if script name is null or empty the persistent ID is used. If not, the type is + // assumed to be a built-in type. + klass = unityType == null ? type.Name : null; + } + + public static bool TryGetGizmoInfo(Type type, out GizmoInfo info) + { + GetAnnotationIdAndClass(type, out var id, out var name); + var annotation = AnnotationUtility.GetAnnotation(id, name); + + if (annotation.gizmoEnabled == -1 && annotation.iconEnabled == -1 && annotation.flags == -1) + { + info = new GizmoInfo(); + return false; + } + + info = new GizmoInfo(annotation); + return true; + } + + public static GizmoInfo[] GetGizmoInfo() + { + var annotations = AnnotationUtility.GetAnnotations(); + return annotations.Select(x => new GizmoInfo(x)).ToArray(); + } + + public static void ApplyGizmoInfo(GizmoInfo info, bool addToRecentlyChanged = true) + { + int gizmoEnabled = info.gizmoEnabled ? 1 : 0; + AnnotationUtility.SetGizmoEnabled(info.classID, info.scriptClass, gizmoEnabled, addToRecentlyChanged); + AnnotationUtility.SetIconEnabled(info.classID, info.scriptClass, info.iconEnabled ? 1 : 0); + } + + public static void SetGizmoEnabled(Type type, bool enabled, bool addToRecentlyChanged = true) + { + GetAnnotationIdAndClass(type, out var id, out var name); + AnnotationUtility.SetGizmoEnabled(id, name, enabled ? 1 : 0, addToRecentlyChanged); + } + + public static void SetIconEnabled(Type type, bool enabled) + { + GetAnnotationIdAndClass(type, out var id, out var name); + AnnotationUtility.SetIconEnabled(id, name, enabled ? 1 : 0); + } + + public static float iconSize + { + get => AnnotationUtility.iconSize; + set => AnnotationUtility.iconSize = Mathf.Clamp01(value); + } + + public static bool use3dIcons + { + get => AnnotationUtility.use3dGizmos; + set => AnnotationUtility.use3dGizmos = value; + } + } +} diff --git a/Editor/Mono/Annotation/LayerVisibilityWindow.cs b/Editor/Mono/Annotation/LayerVisibilityWindow.cs index 3147a32e4c..177ad6e7cd 100644 --- a/Editor/Mono/Annotation/LayerVisibilityWindow.cs +++ b/Editor/Mono/Annotation/LayerVisibilityWindow.cs @@ -17,11 +17,12 @@ private class Styles public readonly GUIStyle listEvenBg = "ObjectPickerResultsOdd"; public readonly GUIStyle listOddBg = "ObjectPickerResultsEven"; public readonly GUIStyle separator = "sv_iconselector_sep"; - public readonly GUIStyle lockButton = "IN LockButton"; public readonly GUIStyle listTextStyle; public readonly GUIStyle listHeaderStyle; - public readonly Texture2D visibleOn = EditorGUIUtility.LoadIcon("animationvisibilitytoggleon"); + public readonly Texture2D visibleOn = EditorGUIUtility.LoadIcon("animationvisibilitytoggleon"); public readonly Texture2D visibleOff = EditorGUIUtility.LoadIcon("animationvisibilitytoggleoff"); + public readonly Texture2D pickable = EditorGUIUtility.LoadIcon("scenepicking_pickable"); + public readonly Texture2D notpickable = EditorGUIUtility.LoadIcon("scenepicking_notpickable"); public readonly GUIContent editLayers = EditorGUIUtility.TrTextContent("Edit Layers..."); public Styles() { @@ -34,17 +35,18 @@ public Styles() } } - const float kScrollBarWidth = 14; - const float kFrameWidth = 1f; - const float kToggleSize = 17; - const float kSeparatorHeight = 6; - const string kLayerVisible = "Show/Hide Layer"; - const string kLayerLocked = "Lock Layer for Picking"; + const float k_ScrollBarWidth = 14; + const float k_FrameWidth = 1f; + const float k_ToggleSize = 17; + const float k_SeparatorHeight = 6; + const string k_LayerVisible = "Show/Hide Layer"; + const string k_LayerPickable = "Toggle Pickable status this Layer. Non-Pickable items cannot be selected in the Scene View."; private static LayerVisibilityWindow s_LayerVisibilityWindow; private static long s_LastClosedTime; - private static Styles s_Styles; + const long k_JustClosedPeriod = 400; + private static Styles s_Styles; private List s_LayerNames; private List s_LayerMasks; private int m_AllLayersMask; @@ -85,7 +87,7 @@ internal static bool ShowAtPosition(Rect buttonRect) { // 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; + bool justClosed = nowMilliSeconds < s_LastClosedTime + k_JustClosedPeriod; if (!justClosed) { Event.current.Use(); @@ -106,16 +108,16 @@ private void Init(Rect buttonRect) var rowCount = (s_LayerNames.Count + 2 + 1 + 1); - var windowHeight = rowCount * EditorGUI.kSingleLineHeight + kSeparatorHeight; + var windowHeight = rowCount * EditorGUI.kSingleLineHeight + k_SeparatorHeight; int sortingLayerCount = InternalEditorUtility.GetSortingLayerCount(); if (sortingLayerCount > 1) { - windowHeight += kSeparatorHeight + EditorGUI.kSingleLineHeight; + windowHeight += k_SeparatorHeight + EditorGUI.kSingleLineHeight; windowHeight += sortingLayerCount * EditorGUI.kSingleLineHeight; } m_ContentHeight = windowHeight; - windowHeight += 2 * kFrameWidth; + windowHeight += 2 * k_FrameWidth; windowHeight = Mathf.Min(windowHeight, 600); var windowSize = new Vector2(180, windowHeight); @@ -131,12 +133,12 @@ internal void OnGUI() if (s_Styles == null) s_Styles = new Styles(); - var scrollViewRect = new Rect(kFrameWidth, kFrameWidth, position.width - 2 * kFrameWidth, position.height - 2 * kFrameWidth); + var scrollViewRect = new Rect(k_FrameWidth, k_FrameWidth, position.width - 2 * k_FrameWidth, position.height - 2 * k_FrameWidth); var contentRect = new Rect(0, 0, 1, m_ContentHeight); bool isScrollbarVisible = m_ContentHeight > scrollViewRect.height; float listElementWidth = scrollViewRect.width; if (isScrollbarVisible) - listElementWidth -= kScrollBarWidth; + listElementWidth -= k_ScrollBarWidth; m_ScrollPosition = GUI.BeginScrollView(scrollViewRect, m_ScrollPosition, contentRect, false, false, GUI.skin.horizontalScrollbar, GUI.skin.verticalScrollbar, EditorStyles.scrollViewAlt); Draw(listElementWidth); @@ -173,9 +175,9 @@ private void DrawHeader(ref Rect rect, string text, ref bool even) private void DrawSeparator(ref Rect rect, bool even) { - DrawListBackground(new Rect(rect.x + 1, rect.y, rect.width - 2, kSeparatorHeight), even); + DrawListBackground(new Rect(rect.x + 1, rect.y, rect.width - 2, k_SeparatorHeight), even); GUI.Label(new Rect(rect.x + 5, rect.y + 3, rect.width - 10, 3), GUIContent.none, s_Styles.separator); - rect.y += kSeparatorHeight; + rect.y += k_SeparatorHeight; } private void Draw(float listElementWidth) @@ -271,24 +273,23 @@ void DoOneSortingLayer(Rect rect, int index, ref bool even) even = !even; } - private void DoLayerEntry(Rect rect, string layerName, bool even, bool showVisible, bool showLock, bool visible, bool locked, out bool visibleChanged, out bool lockedChanged) + private void DoLayerEntry(Rect rect, string layerName, bool even, bool showVisible, bool showLock, bool visible, bool picked, out bool visibleChanged, out bool lockedChanged) { DrawListBackground(rect, even); EditorGUI.BeginChangeCheck(); // text (works as visibility toggle as well) Rect textRect = rect; - textRect.width -= kToggleSize * 2; + textRect.width -= k_ToggleSize * 2; visible = GUI.Toggle(textRect, visible, EditorGUIUtility.TempContent(layerName), s_Styles.listTextStyle); // visible checkbox - var toggleRect = new Rect(rect.width - kToggleSize * 2, rect.y + (rect.height - kToggleSize) * 0.5f, kToggleSize, kToggleSize); + var toggleRect = new Rect(rect.width - k_ToggleSize * 2, rect.y + (rect.height - k_ToggleSize) * 0.5f, k_ToggleSize, k_ToggleSize); visibleChanged = false; if (showVisible) { var iconRect = toggleRect; - iconRect.y += 3; - var gc = new GUIContent(string.Empty, visible ? s_Styles.visibleOn : s_Styles.visibleOff, kLayerVisible); + var gc = new GUIContent(string.Empty, visible ? s_Styles.visibleOn : s_Styles.visibleOff, k_LayerVisible); GUI.Toggle(iconRect, visible, gc, GUIStyle.none); visibleChanged = EditorGUI.EndChangeCheck(); } @@ -297,9 +298,10 @@ private void DoLayerEntry(Rect rect, string layerName, bool even, bool showVisib lockedChanged = false; if (showLock) { - toggleRect.x += kToggleSize; + toggleRect.x += k_ToggleSize; EditorGUI.BeginChangeCheck(); - GUI.Toggle(toggleRect, locked, new GUIContent(string.Empty, kLayerLocked), s_Styles.lockButton); + var gc = new GUIContent(string.Empty, picked ? s_Styles.notpickable : s_Styles.pickable, k_LayerPickable); + GUI.Toggle(toggleRect, picked, gc, GUIStyle.none); lockedChanged = EditorGUI.EndChangeCheck(); } } diff --git a/Editor/Mono/Annotation/SceneFXWindow.cs b/Editor/Mono/Annotation/SceneFXWindow.cs index 4b7a97b2e6..2b2c8c2143 100644 --- a/Editor/Mono/Annotation/SceneFXWindow.cs +++ b/Editor/Mono/Annotation/SceneFXWindow.cs @@ -4,6 +4,7 @@ using System; using UnityEngine; +using UnityEngine.Rendering; namespace UnityEditor { @@ -21,7 +22,7 @@ private class Styles public override Vector2 GetWindowSize() { - var windowHeight = 2f * kFrameWidth + EditorGUI.kSingleLineHeight * 6; + var windowHeight = 2f * kFrameWidth + EditorGUI.kSingleLineHeight * 7; if (UnityEngine.VFX.VFXManager.activateVFX) { windowHeight += EditorGUI.kSingleLineHeight; @@ -74,6 +75,12 @@ private void Draw(Rect rect) DrawListElement(drawPos, "Skybox", state.showSkybox, value => state.showSkybox = value); drawPos.y += EditorGUI.kSingleLineHeight; + if(SupportedRenderingFeatures.active.supportsClouds) + { + DrawListElement(drawPos, "Clouds", state.showClouds, value => state.showClouds = value); + drawPos.y += EditorGUI.kSingleLineHeight; + } + DrawListElement(drawPos, "Fog", state.showFog, value => state.showFog = value); drawPos.y += EditorGUI.kSingleLineHeight; diff --git a/Editor/Mono/Annotation/SceneRenderModeWindow.cs b/Editor/Mono/Annotation/SceneRenderModeWindow.cs index eef98aa409..58674ab1c4 100644 --- a/Editor/Mono/Annotation/SceneRenderModeWindow.cs +++ b/Editor/Mono/Annotation/SceneRenderModeWindow.cs @@ -3,6 +3,7 @@ // https://unity3d.com/legal/licenses/Unity_Reference_Only_License using System; +using System.Collections.Generic; using System.Linq; using UnityEngine; using UnityEngine.Rendering; @@ -75,61 +76,47 @@ public enum DrawCameraMode BakedUVOverlap = 32, TextureStreaming = 33, BakedLightmapCulling = 34, - GIContributorsReceivers = 35 + GIContributorsReceivers = 35, } internal class SceneRenderModeWindow : PopupWindowContent { static class Styles { - private static GUIStyle s_MenuItem; - private static GUIStyle s_Separator; + private static GUIStyle menuItem; + private static GUIStyle separator; + private static GUIContent debuggerLabel; - public static GUIStyle sMenuItem => s_MenuItem ?? (s_MenuItem = "MenuItem"); - public static GUIStyle sSeparator => s_Separator ?? (s_Separator = "sv_iconselector_sep"); + public static GUIStyle s_MenuItem => menuItem ?? (menuItem = "MenuItem"); + public static GUIStyle s_Separator => separator ?? (separator = "sv_iconselector_sep"); + public static GUIContent s_DebuggerLabel => debuggerLabel ??= EditorGUIUtility.TrTextContent("Rendering Debugger..."); private static readonly string kShadingMode = "Shading Mode"; private static readonly string kMiscellaneous = "Miscellaneous"; private static readonly string kDeferred = "Deferred"; - private static readonly string kGlobalIllumination = "Global Illumination"; + private static readonly string kLighting = "Lighting"; private static readonly string kRealtimeGI = "Realtime Global Illumination"; private static readonly string kBakedGI = "Baked Global Illumination"; - private static readonly string kMaterialValidation = "Material Validation"; - - public static readonly GUIContent sResolutionToggle = - EditorGUIUtility.TrTextContent("Show Lightmap Resolution"); // Map all builtin DrawCameraMode entries // This defines the order in which the entries appear in the dropdown menu! public static readonly SceneView.CameraMode[] sBuiltinCameraModes = { - new SceneView.CameraMode(DrawCameraMode.Textured, "Shaded", kShadingMode), - new SceneView.CameraMode(DrawCameraMode.Wireframe, "Wireframe", kShadingMode), - new SceneView.CameraMode(DrawCameraMode.TexturedWire, "Shaded Wireframe", kShadingMode), - - new SceneView.CameraMode(DrawCameraMode.ShadowCascades, "Shadow Cascades", kMiscellaneous), - new SceneView.CameraMode(DrawCameraMode.RenderPaths, "Render Paths", kMiscellaneous), - new SceneView.CameraMode(DrawCameraMode.AlphaChannel, "Alpha Channel", kMiscellaneous), - new SceneView.CameraMode(DrawCameraMode.Overdraw, "Overdraw", kMiscellaneous), - new SceneView.CameraMode(DrawCameraMode.Mipmaps, "Mipmaps", kMiscellaneous), - new SceneView.CameraMode(DrawCameraMode.TextureStreaming, "Texture Streaming", kMiscellaneous), - new SceneView.CameraMode(DrawCameraMode.SpriteMask, "Sprite Mask", kMiscellaneous), - - new SceneView.CameraMode(DrawCameraMode.DeferredDiffuse, "Albedo", kDeferred), - new SceneView.CameraMode(DrawCameraMode.DeferredSpecular, "Specular", kDeferred), - new SceneView.CameraMode(DrawCameraMode.DeferredSmoothness, "Smoothness", kDeferred), - new SceneView.CameraMode(DrawCameraMode.DeferredNormal, "Normal", kDeferred), + new SceneView.CameraMode(DrawCameraMode.Textured, "Shaded", kShadingMode, false), + new SceneView.CameraMode(DrawCameraMode.Wireframe, "Wireframe", kShadingMode, false), + new SceneView.CameraMode(DrawCameraMode.TexturedWire, "Shaded Wireframe", kShadingMode, false), - new SceneView.CameraMode(DrawCameraMode.Systems, "Systems", kGlobalIllumination), - new SceneView.CameraMode(DrawCameraMode.Clustering, "Clustering", kGlobalIllumination), - new SceneView.CameraMode(DrawCameraMode.LitClustering, "Lit Clustering", kGlobalIllumination), - new SceneView.CameraMode(DrawCameraMode.RealtimeCharting, "UV Charts", kGlobalIllumination), - new SceneView.CameraMode(DrawCameraMode.GIContributorsReceivers, "Contributors / Receivers", kGlobalIllumination), + new SceneView.CameraMode(DrawCameraMode.GIContributorsReceivers, "Contributors / Receivers", kLighting), + new SceneView.CameraMode(DrawCameraMode.ShadowCascades, "Shadow Cascades", kLighting), - new SceneView.CameraMode(DrawCameraMode.RealtimeAlbedo, "Albedo", kRealtimeGI), - new SceneView.CameraMode(DrawCameraMode.RealtimeEmissive, "Emissive", kRealtimeGI), new SceneView.CameraMode(DrawCameraMode.RealtimeIndirect, "Indirect", kRealtimeGI), new SceneView.CameraMode(DrawCameraMode.RealtimeDirectionality, "Directionality", kRealtimeGI), + new SceneView.CameraMode(DrawCameraMode.RealtimeAlbedo, "Albedo", kRealtimeGI), + new SceneView.CameraMode(DrawCameraMode.RealtimeEmissive, "Emissive", kRealtimeGI), + new SceneView.CameraMode(DrawCameraMode.RealtimeCharting, "UV Charts", kRealtimeGI), + new SceneView.CameraMode(DrawCameraMode.Systems, "Systems", kRealtimeGI), + new SceneView.CameraMode(DrawCameraMode.Clustering, "Clustering", kRealtimeGI), + new SceneView.CameraMode(DrawCameraMode.LitClustering, "Lit Clustering", kRealtimeGI), new SceneView.CameraMode(DrawCameraMode.BakedLightmap, "Baked Lightmap", kBakedGI), new SceneView.CameraMode(DrawCameraMode.BakedDirectionality, "Directionality", kBakedGI), @@ -139,15 +126,40 @@ static class Styles new SceneView.CameraMode(DrawCameraMode.BakedCharting, "UV Charts", kBakedGI), new SceneView.CameraMode(DrawCameraMode.BakedTexelValidity, "Texel Validity", kBakedGI), new SceneView.CameraMode(DrawCameraMode.BakedUVOverlap, "UV Overlap", kBakedGI), - new SceneView.CameraMode(DrawCameraMode.BakedLightmapCulling, "Baked Lightmap Culling", kBakedGI), new SceneView.CameraMode(DrawCameraMode.BakedIndices, "Lightmap Indices", kBakedGI), new SceneView.CameraMode(DrawCameraMode.LightOverlap, "Light Overlap", kBakedGI), - new SceneView.CameraMode(DrawCameraMode.ValidateAlbedo, "Validate Albedo", kMaterialValidation), - new SceneView.CameraMode(DrawCameraMode.ValidateMetalSpecular, "Validate Metal Specular", kMaterialValidation), + new SceneView.CameraMode(DrawCameraMode.DeferredDiffuse, "Albedo", kDeferred), + new SceneView.CameraMode(DrawCameraMode.DeferredSpecular, "Specular", kDeferred), + new SceneView.CameraMode(DrawCameraMode.DeferredSmoothness, "Smoothness", kDeferred), + new SceneView.CameraMode(DrawCameraMode.DeferredNormal, "Normal", kDeferred), + + new SceneView.CameraMode(DrawCameraMode.RenderPaths, "Render Paths", kMiscellaneous), + new SceneView.CameraMode(DrawCameraMode.AlphaChannel, "Alpha Channel", kMiscellaneous), + new SceneView.CameraMode(DrawCameraMode.Overdraw, "Overdraw", kMiscellaneous), + new SceneView.CameraMode(DrawCameraMode.Mipmaps, "Mipmaps", kMiscellaneous), + new SceneView.CameraMode(DrawCameraMode.TextureStreaming, "Texture Mipmap Streaming", kMiscellaneous), + new SceneView.CameraMode(DrawCameraMode.SpriteMask, "Sprite Mask", kMiscellaneous), + new SceneView.CameraMode(DrawCameraMode.ValidateAlbedo, "Validate Albedo", kMiscellaneous), + new SceneView.CameraMode(DrawCameraMode.ValidateMetalSpecular, "Validate Metal Specular", kMiscellaneous), }; + + } + + // UUM-96180: Default CameraMode should be DrawCameraMode.GIContributorsReceivers + internal static SceneView.CameraMode defaultCameraMode + { + get + { + var mode = Styles.sBuiltinCameraModes [3]; + if(mode.drawMode != DrawCameraMode.GIContributorsReceivers) + Debug.LogError("Default Draw Camera mode should be set to DrawCameraMode.GIContributorsReceivers."); + return mode; + } } + private Dictionary foldoutStates = new Dictionary(); + private float windowHeight { get @@ -155,33 +167,22 @@ private float windowHeight int headers; int modes; - // TODO: This needs to be fixed and we need to find a way to dif. between disabled and unsupported - if (GraphicsSettings.currentRenderPipeline != null) - { - // When using SRP, we completely hide disabled builtin modes, including headers - headers = Styles.sBuiltinCameraModes.Where(mode => m_SceneView.IsCameraDrawModeEnabled(mode)).Select(mode => mode.section).Distinct().Count() + - SceneView.userDefinedModes.Where(mode => m_SceneView.IsCameraDrawModeEnabled(mode)).Select(mode => mode.section).Distinct().Count(); - modes = Styles.sBuiltinCameraModes.Count(mode => m_SceneView.IsCameraDrawModeEnabled(mode)) + SceneView.userDefinedModes.Count(mode => m_SceneView.IsCameraDrawModeEnabled(mode)); - } - else - { - headers = Styles.sBuiltinCameraModes.Select(mode => mode.section).Distinct().Count() + SceneView.userDefinedModes.Where(mode => m_SceneView.IsCameraDrawModeEnabled(mode)).Select(mode => mode.section).Distinct().Count(); - modes = Styles.sBuiltinCameraModes.Length + SceneView.userDefinedModes.Count(mode => m_SceneView.IsCameraDrawModeEnabled(mode)); - } + // Hide unsupported items and headers + headers = Styles.sBuiltinCameraModes.Where(mode => m_SceneView.IsCameraDrawModeSupported(mode) && mode.show) + .Select(mode => mode.section).Distinct().Count() + + SceneView.userDefinedModes.Where(mode => m_SceneView.IsCameraDrawModeSupported(mode) && mode.show) + .Select(mode => mode.section).Distinct().Count(); + modes = Styles.sBuiltinCameraModes.Count(mode => m_SceneView.IsCameraDrawModeSupported(mode) && mode.show) + + SceneView.userDefinedModes.Count(mode => m_SceneView.IsCameraDrawModeSupported(mode) && mode.show); - int separators = headers - 1; - return ((headers + modes) * EditorGUI.kSingleLineHeight) + (kSeparatorHeight * separators) + kShowLightmapResolutionHeight; + return UpdatedHeight(headers, modes, GraphicsSettings.isScriptableRenderPipelineEnabled); } } const float windowWidth = 205; const float kSeparatorHeight = 3; - const float kFrameWidth = 1f; const float kHeaderHorizontalPadding = 5f; const float kHeaderVerticalPadding = 3f; - const float kTogglePadding = 7f; - - static readonly float kShowLightmapResolutionHeight = EditorGUI.kSingleLineHeight + kSeparatorHeight * 2; readonly SceneView m_SceneView; @@ -206,6 +207,13 @@ public override void OnGUI(Rect rect) Draw(rect.width); + if (GUI.changed) + { + GUIUtility.ExitGUI(); + editorWindow.RepaintImmediately(); + GUI.changed = false; // Reset the changed flag + } + // Use mouse move so we get hover state correctly in the menu item rows if (Event.current.type == EventType.MouseMove) Event.current.Use(); @@ -226,78 +234,136 @@ private void DrawSeparator(ref Rect rect) labelRect.width -= kHeaderHorizontalPadding * 2; labelRect.height = kSeparatorHeight; - GUI.Label(labelRect, GUIContent.none, Styles.sSeparator); + GUI.Label(labelRect, GUIContent.none, Styles.s_Separator); rect.y += kSeparatorHeight; } - private void DrawHeader(ref Rect rect, GUIContent label) + //Opens render debugger window located at \newSRP\unity\Packages\com.unity.render-pipelines.core\Editor\Debugging\DebugWindow.cs + private void DrawRenderingDebuggerShortCut(Rect rect) { var labelRect = rect; labelRect.y += kHeaderVerticalPadding; - labelRect.x += kHeaderHorizontalPadding; - labelRect.width = EditorStyles.miniLabel.CalcSize(label).x; - labelRect.height = EditorStyles.miniLabel.CalcSize(label).y; - GUI.Label(labelRect, label, EditorStyles.miniLabel); - rect.y += EditorGUI.kSingleLineHeight; + EditorGUI.LabelField(labelRect,string.Empty, Styles.s_MenuItem); + labelRect.x -= kHeaderHorizontalPadding; + var debuggerLabelSize = EditorStyles.foldout.CalcSize(Styles.s_DebuggerLabel); + labelRect.height = debuggerLabelSize.y; + + if (GUI.Button(labelRect, Styles.s_DebuggerLabel, Styles.s_MenuItem)) + { + EditorApplication.ExecuteMenuItem("Window/Analysis/Rendering Debugger"); + editorWindow.Close(); + } + rect.y += labelRect.height; + } private void Draw(float listElementWidth) { var drawPos = new Rect(0, 0, listElementWidth, EditorGUI.kSingleLineHeight); - bool usingScriptableRenderPipeline = (GraphicsSettings.currentRenderPipeline != null); string lastSection = null; - foreach (SceneView.CameraMode mode in SceneView.userDefinedModes.OrderBy(mode => mode.section).Concat(Styles.sBuiltinCameraModes)) + foreach (SceneView.CameraMode mode in SceneView.userDefinedModes.OrderBy(mode => mode.section) + .Concat(Styles.sBuiltinCameraModes)) { + if (!mode.show) + continue; + // Draw separators and headers - if (usingScriptableRenderPipeline && mode.drawMode != DrawCameraMode.UserDefined && !m_SceneView.IsCameraDrawModeEnabled(mode)) - // When using SRP, we completely hide disabled builtin modes, including headers + if (mode.drawMode != DrawCameraMode.UserDefined && !m_SceneView.IsCameraDrawModeSupported(mode)) + // Hide unsupported items and headers continue; if (lastSection != mode.section) { - // Draw header for new section - if (lastSection != null) - // Don't draw separator before first section - DrawSeparator(ref drawPos); - DrawHeader(ref drawPos, EditorGUIUtility.TextContent(mode.section)); lastSection = mode.section; + if (!foldoutStates.ContainsKey(lastSection)) + { + foldoutStates.Add(lastSection, true); + } + + bool previousState = foldoutStates[lastSection]; + Rect foldoutRect = new Rect(drawPos.x, drawPos.y, drawPos.width, EditorGUI.kSingleLineHeight); + + EditorGUI.LabelField(foldoutRect,string.Empty, Styles.s_MenuItem); + foldoutStates[lastSection] = EditorGUI.Foldout(foldoutRect, foldoutStates[lastSection], EditorGUIUtility.TextContent(lastSection), true); + + drawPos.y += EditorGUI.kSingleLineHeight; + + if (previousState != foldoutStates[lastSection]) + { + UpdateWindowSize(); + } } - using (new EditorGUI.DisabledScope(!m_SceneView.IsCameraDrawModeEnabled(mode))) + if (foldoutStates[lastSection]) { - DoBuiltinMode(ref drawPos, mode); + using (new EditorGUI.DisabledScope(!m_SceneView.IsCameraDrawModeEnabled(mode))) + { + using (new EditorGUI.IndentLevelScope()) + { + DoBuiltinMode(ref drawPos, mode); + } + } } } - bool disabled = (m_SceneView.cameraMode.drawMode < DrawCameraMode.RealtimeCharting) || - !IsModeEnabled(m_SceneView.cameraMode.drawMode); - DoResolutionToggle(drawPos, disabled); + if (GraphicsSettings.isScriptableRenderPipelineEnabled) + { + DrawSeparator(ref drawPos); + DrawRenderingDebuggerShortCut(drawPos); + } } - bool IsModeEnabled(DrawCameraMode mode) + private void UpdateWindowSize() { - return m_SceneView.IsCameraDrawModeEnabled(GetBuiltinCameraMode(mode)); + if (editorWindow != null && Event.current.type != EventType.Layout) + { + float newWindowHeight = RecalculateWindowHeight(); + editorWindow.minSize = new Vector2(windowWidth, newWindowHeight); + editorWindow.maxSize = new Vector2(windowWidth, newWindowHeight); + } } - void DoResolutionToggle(Rect rect, bool disabled) + private float RecalculateWindowHeight() { - // Bg - GUI.Label(new Rect(kFrameWidth, rect.y, windowWidth - kFrameWidth * 2, kShowLightmapResolutionHeight), "", EditorStyles.inspectorBig); + int headers = 0; + int modes = 0; - rect.y += kSeparatorHeight; - rect.x += kTogglePadding; - - using (new EditorGUI.DisabledScope(disabled)) + string lastSection = null; + foreach (SceneView.CameraMode mode in SceneView.userDefinedModes.OrderBy(mode => mode.section) + .Concat(Styles.sBuiltinCameraModes)) { - EditorGUI.BeginChangeCheck(); - bool showResolution = GUI.Toggle(rect, LightmapVisualization.showResolution, Styles.sResolutionToggle); - if (EditorGUI.EndChangeCheck()) + if (!mode.show) + continue; + + if (mode.drawMode != DrawCameraMode.UserDefined && !m_SceneView.IsCameraDrawModeSupported(mode)) + continue; + + if (lastSection != mode.section) + { + headers++; + lastSection = mode.section; + } + + if (foldoutStates.ContainsKey(lastSection) && foldoutStates[lastSection]) { - LightmapVisualization.showResolution = showResolution; - SceneView.RepaintAll(); + modes++; } } + + return UpdatedHeight(headers, modes, GraphicsSettings.isScriptableRenderPipelineEnabled); + } + + private float UpdatedHeight(int headers, int modes, bool isSRP) + { + int separators = headers - 1; + return ((headers + modes + (isSRP ? 1 : 0)) * EditorGUI.kSingleLineHeight) + (kSeparatorHeight * separators); + } + + + bool IsModeEnabled(DrawCameraMode mode) + { + return m_SceneView.IsCameraDrawModeEnabled(GetBuiltinCameraMode(mode)); } void DoBuiltinMode(ref Rect rect, SceneView.CameraMode mode) @@ -306,7 +372,8 @@ void DoBuiltinMode(ref Rect rect, SceneView.CameraMode mode) { EditorGUI.BeginChangeCheck(); - GUI.Toggle(rect, m_SceneView.cameraMode == mode, EditorGUIUtility.TextContent(mode.name), Styles.sMenuItem); + GUI.Toggle(rect, m_SceneView.cameraMode == mode, EditorGUIUtility.TextContent(mode.name), + Styles.s_MenuItem); if (EditorGUI.EndChangeCheck()) { m_SceneView.cameraMode = mode; @@ -322,11 +389,14 @@ public static GUIContent GetGUIContent(DrawCameraMode drawCameraMode) { if (drawCameraMode == DrawCameraMode.UserDefined) return GUIContent.none; - return EditorGUIUtility.TextContent(Styles.sBuiltinCameraModes.Single(mode => mode.drawMode == drawCameraMode).name); + return EditorGUIUtility.TextContent(Styles.sBuiltinCameraModes + .Single(mode => mode.drawMode == drawCameraMode).name); } internal static SceneView.CameraMode GetBuiltinCameraMode(DrawCameraMode drawMode) { + if (drawMode == DrawCameraMode.Normal) + drawMode = DrawCameraMode.Textured; return Styles.sBuiltinCameraModes.Single(mode => mode.drawMode == drawMode); } diff --git a/Editor/Mono/Annotation/SceneViewCameraWindow.cs b/Editor/Mono/Annotation/SceneViewCameraWindow.cs index 14606fe187..9cdb8a8d16 100644 --- a/Editor/Mono/Annotation/SceneViewCameraWindow.cs +++ b/Editor/Mono/Annotation/SceneViewCameraWindow.cs @@ -17,6 +17,7 @@ static class Styles public static readonly GUIContent copySettingsLabel = EditorGUIUtility.TrTextContent("Copy Settings"); public static readonly GUIContent pasteSettingsLabel = EditorGUIUtility.TrTextContent("Paste Settings"); public static readonly GUIContent resetSettingsLabel = EditorGUIUtility.TrTextContent("Reset Settings"); + public static readonly GUIContent cameraSpeedRange = EditorGUIUtility.TrTextContent(" "); public static readonly GUIStyle settingsArea; @@ -41,20 +42,21 @@ static Styles() GUIContent m_SceneCameraLabel = EditorGUIUtility.TrTextContent("Scene Camera"); GUIContent m_NavigationLabel = EditorGUIUtility.TrTextContent("Navigation"); - const int kFieldCount = 12; + readonly string k_ClippingPlaneWarning = L10n.Tr("Using extreme values between the near and far planes may cause rendering issues. In general, to get better precision move the Near plane as far as possible."); + + const int kFieldCount = 13; const int kWindowWidth = 290; const int kContentPadding = 4; - const int kWindowHeight = ((int)EditorGUI.kSingleLineHeight) * kFieldCount + kContentPadding * 2; - const float kPrefixLabelWidth = 120f; - const float kNearClipMin = .01f; const int k_HeaderSpacing = 2; + const int kWindowHeight = ((int)EditorGUI.kSingleLineHeight) * kFieldCount + kContentPadding * 2 + k_HeaderSpacing * 2; + const float kPrefixLabelWidth = 120f; + // FOV values chosen to be the smallest and largest before extreme visual corruption const float k_MinFieldOfView = 4f; const float k_MaxFieldOfView = 120f; Vector2 m_WindowSize; Vector2 m_Scroll; - float[] m_Vector2Floats = { 0, 0 }; public static event Action additionalSettingsGui; @@ -76,8 +78,8 @@ public SceneViewCameraWindow(SceneView sceneView) m_WindowSize = new Vector2(kWindowWidth, kWindowHeight); m_MinMaxContent = new[] { - EditorGUIUtility.TrTextContent("Min", "The minimum speed of the camera in the Scene view. Valid values are between [0.001, 98]."), - EditorGUIUtility.TrTextContent("Max", "The maximum speed of the camera in the Scene view. Valid values are between [0.002, 99].") + EditorGUIUtility.TrTextContent("Min", $"The minimum speed of the camera in the Scene view. Valid values are between [{SceneView.CameraSettings.kAbsoluteSpeedMin}, {SceneView.CameraSettings.kAbsoluteSpeedMax - 1}]."), + EditorGUIUtility.TrTextContent("Max", $"The maximum speed of the camera in the Scene view. Valid values are between [{SceneView.CameraSettings.kAbsoluteSpeedMin + .0001f}, {SceneView.CameraSettings.kAbsoluteSpeedMax}].") }; } @@ -127,8 +129,13 @@ void Draw() using (new EditorGUI.DisabledScope(settings.dynamicClip)) { float near = settings.nearClip, far = settings.farClip; - DrawClipPlanesField(EditorGUI.s_ClipingPlanesLabel, ref near, ref far, EditorGUI.kNearFarLabelsWidth); + DrawStackedFloatField(EditorGUI.s_ClipingPlanesLabel, + EditorGUI.s_NearAndFarLabels[0], + EditorGUI.s_NearAndFarLabels[1], ref near, ref far, + EditorGUI.kNearFarLabelsWidth); settings.SetClipPlanes(near, far); + if(far/near > 10000000 || near < 0.0001f) + EditorGUILayout.HelpBox(k_ClippingPlaneWarning,MessageType.Warning); } settings.occlusionCulling = EditorGUILayout.Toggle(m_OcclusionCulling, settings.occlusionCulling); @@ -151,13 +158,15 @@ void Draw() EditorGUI.BeginChangeCheck(); - m_Vector2Floats[0] = settings.speedMin; - m_Vector2Floats[1] = settings.speedMax; + DrawStackedFloatField(Styles.cameraSpeedRange, + m_MinMaxContent[0], + m_MinMaxContent[1], + ref min, ref max, + EditorGUI.kNearFarLabelsWidth); - DrawSpeedMinMaxFields(); if (EditorGUI.EndChangeCheck()) - settings.SetSpeedMinMax(m_Vector2Floats); + settings.SetSpeedMinMax(min, max); EditorGUIUtility.labelWidth = 0f; @@ -165,25 +174,16 @@ void Draw() { EditorGUILayout.Space(k_HeaderSpacing); additionalSettingsGui(m_SceneView); - } - if (Event.current.type == EventType.Repaint) - m_WindowSize.y = Math.Min(GUILayoutUtility.GetLastRect().yMax + kContentPadding, kWindowHeight * 3); + if (Event.current.type == EventType.Repaint) + m_WindowSize.y = Math.Min(GUILayoutUtility.GetLastRect().yMax + kContentPadding * 2, kWindowHeight * 3); + } GUILayout.EndVertical(); GUILayout.EndScrollView(); } - void DrawSpeedMinMaxFields() - { - GUILayout.BeginHorizontal(); - GUILayout.Space(EditorGUIUtility.labelWidth); - Rect r = EditorGUILayout.GetControlRect(false, EditorGUI.kSingleLineHeight, EditorStyles.numberField); - EditorGUI.MultiFloatField(r, m_MinMaxContent, m_Vector2Floats); - GUILayout.EndHorizontal(); - } - - void DrawClipPlanesField(GUIContent label, ref float near, ref float far, float propertyLabelsWidth, params GUILayoutOption[] options) + static void DrawStackedFloatField(GUIContent label, GUIContent firstFieldLabel, GUIContent secondFieldLabel, ref float near, ref float far, float propertyLabelsWidth, params GUILayoutOption[] options) { bool hasLabel = EditorGUI.LabelHasContent(label); float height = EditorGUI.kSingleLineHeight * 2 + EditorGUI.kVerticalSpacingMultiField; @@ -198,9 +198,9 @@ void DrawClipPlanesField(GUIContent label, ref float near, ref float far, float EditorGUIUtility.labelWidth = propertyLabelsWidth; EditorGUI.indentLevel = 0; - near = EditorGUI.FloatField(fieldPosition, EditorGUI.s_NearAndFarLabels[0], near); + near = EditorGUI.FloatField(fieldPosition, firstFieldLabel, near); fieldPosition.y += EditorGUI.kSingleLineHeight + EditorGUI.kVerticalSpacingMultiField; - far = EditorGUI.FloatField(fieldPosition, EditorGUI.s_NearAndFarLabels[1], far); + far = EditorGUI.FloatField(fieldPosition, secondFieldLabel, far); EditorGUI.indentLevel = oldIndentLevel; EditorGUIUtility.labelWidth = oldLabelWidth; diff --git a/Editor/Mono/AssemblyHelper.cs b/Editor/Mono/AssemblyHelper.cs index ea64eff0fa..188e621637 100644 --- a/Editor/Mono/AssemblyHelper.cs +++ b/Editor/Mono/AssemblyHelper.cs @@ -13,202 +13,18 @@ using UnityEngine; using System.Runtime.InteropServices; using UnityEngine.Scripting; +using Debug = UnityEngine.Debug; +using Unity.Profiling; +using UnityEditor.AssetImporters; +using UnityEditor.Scripting.ScriptCompilation; +using UnityEngine.Scripting.APIUpdating; namespace UnityEditor { - internal partial class AssemblyHelper + internal class AssemblyHelper { static Dictionary managedToDllType = new Dictionary(); - - // Check if assmebly internal name doesn't match file name, and show the warning. - static public void CheckForAssemblyFileNameMismatch(string assemblyPath) - { - string fileName = Path.GetFileNameWithoutExtension(assemblyPath); - string assemblyName = ExtractInternalAssemblyName(assemblyPath); - - if (string.IsNullOrEmpty(assemblyName)) - return; - - if (fileName != assemblyName) - { - Debug.LogWarning("Assembly '" + assemblyName + "' has non matching file name: '" + Path.GetFileName(assemblyPath) + "'. This can cause build issues on some platforms."); - } - } - - static public string[] GetNamesOfAssembliesLoadedInCurrentDomain() - { - var assemblies = AppDomain.CurrentDomain.GetAssemblies(); - var locations = new List(); - foreach (var a in assemblies) - { - try - { - locations.Add(a.Location); - } - catch (NotSupportedException) - { - //we have some "dynamic" assmeblies that do not have a filename - } - } - return locations.ToArray(); - } - - static public string ExtractInternalAssemblyName(string path) - { - try - { - AssemblyDefinition definition = AssemblyDefinition.ReadAssembly(path); - return definition.Name.Name; - } - catch - { - return ""; - } - } - - static AssemblyDefinition GetAssemblyDefinitionCached(string path, Dictionary cache) - { - if (cache.ContainsKey(path)) - return cache[path]; - - AssemblyDefinition definition = AssemblyDefinition.ReadAssembly(path); - cache[path] = definition; - return definition; - } - - static private bool CouldBelongToDotNetOrWindowsRuntime(string assemblyPath) - { - return assemblyPath.IndexOf("mscorlib.dll") != -1 || - assemblyPath.IndexOf("System.") != -1 || - assemblyPath.IndexOf("Microsoft.") != -1 || - assemblyPath.IndexOf("Windows.") != -1 || - assemblyPath.IndexOf("WinRTLegacy.dll") != -1 || - assemblyPath.IndexOf("platform.dll") != -1; - } - - static private bool IgnoreAssembly(string assemblyPath, BuildTarget target) - { - if (target == BuildTarget.WSAPlayer) - { - if (CouldBelongToDotNetOrWindowsRuntime(assemblyPath)) - return true; - } - else if (target == BuildTarget.XboxOne) - { - var profile = PlayerSettings.GetApiCompatibilityLevel(BuildTargetGroup.XboxOne); - if (profile == ApiCompatibilityLevel.NET_4_6 || profile == ApiCompatibilityLevel.NET_Standard_2_0) - { - if (CouldBelongToDotNetOrWindowsRuntime(assemblyPath)) - return true; - } - } - - return IsInternalAssembly(assemblyPath); - } - - static private void AddReferencedAssembliesRecurse(string assemblyPath, List alreadyFoundAssemblies, string[] allAssemblyPaths, string[] foldersToSearch, Dictionary cache, BuildTarget target) - { - if (IgnoreAssembly(assemblyPath, target)) - return; - - if (!File.Exists(assemblyPath)) - return; - - AssemblyDefinition assembly = GetAssemblyDefinitionCached(assemblyPath, cache); - if (assembly == null) - throw new System.ArgumentException("Referenced Assembly " + Path.GetFileName(assemblyPath) + " could not be found!"); - - // Ignore it if we already added the assembly - if (alreadyFoundAssemblies.IndexOf(assemblyPath) != -1) - return; - - alreadyFoundAssemblies.Add(assemblyPath); - - var architectureSpecificPlugins = PluginImporter.GetImporters(target).Where(i => - { - var cpu = i.GetPlatformData(target, "CPU"); - return !string.IsNullOrEmpty(cpu) && !string.Equals(cpu, "AnyCPU", StringComparison.InvariantCultureIgnoreCase); - }).Select(i => Path.GetFileName(i.assetPath)).Distinct(); - - // Go through all referenced assemblies - foreach (AssemblyNameReference referencedAssembly in assembly.MainModule.AssemblyReferences) - { - // Special cases for Metro - if (referencedAssembly.Name == "BridgeInterface") continue; - if (referencedAssembly.Name == "WinRTBridge") continue; - if (referencedAssembly.Name == "UnityEngineProxy") continue; - if (IgnoreAssembly(referencedAssembly.Name + ".dll", target)) continue; - - string foundPath = FindAssemblyName(referencedAssembly.FullName, referencedAssembly.Name, allAssemblyPaths, foldersToSearch, cache); - - if (foundPath == "") - { - // Ignore architecture specific plugin references - var found = false; - foreach (var extension in new[] { ".dll", ".winmd" }) - { - if (architectureSpecificPlugins.Any(p => string.Equals(p, referencedAssembly.Name + extension, StringComparison.InvariantCultureIgnoreCase))) - { - found = true; - break; - } - } - if (found) - continue; - throw new System.ArgumentException(string.Format("The Assembly {0} is referenced by {1} ('{2}'). But the dll is not allowed to be included or could not be found.", - referencedAssembly.Name, - assembly.MainModule.Assembly.Name.Name, - assemblyPath)); - } - - AddReferencedAssembliesRecurse(foundPath, alreadyFoundAssemblies, allAssemblyPaths, foldersToSearch, cache, target); - } - } - - static string FindAssemblyName(string fullName, string name, string[] allAssemblyPaths, string[] foldersToSearch, Dictionary cache) - { - // Search in provided assemblies - for (int i = 0; i < allAssemblyPaths.Length; i++) - { - if (!File.Exists(allAssemblyPaths[i])) - continue; - - AssemblyDefinition definition = GetAssemblyDefinitionCached(allAssemblyPaths[i], cache); - if (definition.MainModule.Assembly.Name.Name == name) - return allAssemblyPaths[i]; - } - - // Search in GAC - foreach (string folder in foldersToSearch) - { - string pathInGacFolder = Path.Combine(folder, name + ".dll"); - if (File.Exists(pathInGacFolder)) - return pathInGacFolder; - } - return ""; - } - - static public string[] FindAssembliesReferencedBy(string[] paths, string[] foldersToSearch, BuildTarget target) - { - List unique = new List(); - string[] allAssemblyPaths = paths; - - var cache = new Dictionary(); - for (int i = 0; i < paths.Length; i++) - AddReferencedAssembliesRecurse(paths[i], unique, allAssemblyPaths, foldersToSearch, cache, target); - - for (int i = 0; i < paths.Length; i++) - unique.Remove(paths[i]); - - return unique.ToArray(); - } - - static public string[] FindAssembliesReferencedBy(string path, string[] foldersToSearch, BuildTarget target) - { - string[] tmp = new string[1]; - tmp[0] = path; - return FindAssembliesReferencedBy(tmp, foldersToSearch, target); - } + static BuildPlayerDataExtractor m_BuildPlayerDataExtractor = new BuildPlayerDataExtractor(); static public bool IsUnityEngineModule(AssemblyDefinition assembly) { @@ -220,46 +36,15 @@ static public bool IsUnityEngineModule(Assembly assembly) return assembly.GetCustomAttributes(typeof(UnityEngineModuleAssembly), false).Length > 0; } - private static bool IsTypeAUserExtendedScript(TypeReference type) - { - if (type == null || type.FullName == "System.Object") - return false; - - try - { - var typeDefinition = type.Resolve(); - var attributes = typeDefinition.CustomAttributes; - for (var i = 0; i < attributes.Count; i++) - { - if (attributes[i].Constructor.DeclaringType.FullName == "UnityEngine.ExtensionOfNativeClassAttribute") - return true; - } - - if (typeDefinition.BaseType != null) - return IsTypeAUserExtendedScript(typeDefinition.BaseType); - } - catch (AssemblyResolutionException) - { - // just eat exception if we fail to load assembly here. - // failure should be handled better in other places. - } - - return false; - } - public static string[] GetDefaultAssemblySearchPaths() { // Add the path to all available precompiled assemblies - var group = EditorUserBuildSettings.activeBuildTargetGroup; var target = EditorUserBuildSettings.activeBuildTarget; - var precompiledAssemblies = InternalEditorUtility.GetPrecompiledAssemblies(true, group, target); - - HashSet searchPaths = new HashSet(); + var precompiledAssemblyPaths = InternalEditorUtility.GetPrecompiledAssemblyPaths(); - foreach (var asm in precompiledAssemblies) - searchPaths.Add(Path.GetDirectoryName(asm.Path)); + HashSet searchPaths = new HashSet(precompiledAssemblyPaths); - precompiledAssemblies = InternalEditorUtility.GetUnityAssemblies(true, group, target); + var precompiledAssemblies = InternalEditorUtility.GetUnityAssemblies(true, target); foreach (var asm in precompiledAssemblies) searchPaths.Add(Path.GetDirectoryName(asm.Path)); @@ -267,84 +52,59 @@ public static string[] GetDefaultAssemblySearchPaths() // Required for MonoBehaviour derived types like UIBehaviour that // were previous in a precompiled UnityEngine.UI.dll, but are now // compiled in a package. - searchPaths.Add("Library/ScriptAssemblies"); + searchPaths.Add(InternalEditorUtility.GetEditorScriptAssembliesPath()); return searchPaths.ToArray(); } - public static void ExtractAllClassesThatAreUserExtendedScripts(string path, out string[] classNamesArray, out string[] classNameSpacesArray, out string[] originalClassNameSpacesArray) + [RequiredByNativeCode] + public static bool ExtractAllClassesThatAreUserExtendedScripts(string path, out string[] classNamesArray, out string[] classNameSpacesArray, out string[] movedFromNamespacesArray) { - List classNames = new List(); - List nameSpaces = new List(); - List originalNamespaces = new List(); - var readerParameters = new ReaderParameters(); + var typesDerivedFromMonoBehaviour = TypeCache.GetTypesDerivedFrom(); + var typesDerivedFromScriptableObject = TypeCache.GetTypesDerivedFrom(); + var typesDerivedFromScriptedImporter = TypeCache.GetTypesDerivedFrom(); - // this will resolve any types in assemblies within the same directory as the type's assembly - // or any folder which contains a currently available precompiled dll - var assemblyResolver = new DefaultAssemblyResolver(); - var searchPaths = GetDefaultAssemblySearchPaths(); + var fileName = Path.GetFileName(path); + IEnumerable userTypes = typesDerivedFromMonoBehaviour.Where(x => Path.GetFileName(x.Assembly.Location) == fileName); + userTypes = userTypes + .Concat(typesDerivedFromScriptableObject.Where(x => Path.GetFileName(x.Assembly.Location) == fileName)) + .Concat(typesDerivedFromScriptedImporter.Where(x => Path.GetFileName(x.Assembly.Location) == fileName)).ToList(); - foreach (var asmpath in searchPaths) - assemblyResolver.AddSearchDirectory(asmpath); + List classNames = new List(userTypes.Count()); + List nameSpaces = new List(userTypes.Count()); + List originalNamespaces = new List(userTypes.Count()); - assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(path)); - readerParameters.AssemblyResolver = assemblyResolver; - - AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly(path, readerParameters); - foreach (ModuleDefinition module in assembly.Modules) + string pathToAssembly = null; + foreach (var userType in userTypes) { - foreach (TypeDefinition type in module.Types) - { - TypeReference baseType = type.BaseType; + if (string.IsNullOrEmpty(pathToAssembly)) + pathToAssembly = Path.GetFullPath(userType.Assembly.Location); - try - { - if (IsTypeAUserExtendedScript(baseType)) - { - classNames.Add(type.Name); - nameSpaces.Add(type.Namespace); - - var originalNamespace = string.Empty; - var attribute = type.CustomAttributes.SingleOrDefault(a => a.AttributeType.FullName == typeof(UnityEngine.Scripting.APIUpdating.MovedFromAttribute).FullName); - - if (attribute != null) - { - originalNamespace = (string)attribute.ConstructorArguments[0].Value; - } + classNames.Add(userType.Name); + nameSpaces.Add(userType.Namespace); - originalNamespaces.Add(originalNamespace); - } - } - catch (Exception) - { - Debug.LogError("Failed to extract " + type.FullName + " class of base type " + baseType.FullName + " when inspecting " + path); - } - } + var movedFromAttribute = userType.GetCustomAttribute(); + originalNamespaces.Add(movedFromAttribute?.data.nameSpace); } classNamesArray = classNames.ToArray(); classNameSpacesArray = nameSpaces.ToArray(); - originalClassNameSpacesArray = originalNamespaces.ToArray(); + movedFromNamespacesArray = originalNamespaces.ToArray(); + + return !Utility.IsPathsEqual(pathToAssembly, path); } - struct GetAssemblyResolverData + /// Extract information about all types in the specified assembly, searchDirs might be used to resolve dependencies. + [RequiredByNativeCode] + static public AssemblyInfoManaged[] ExtractAssemblyTypeInfo(bool isEditor) { - public IAssemblyResolver Resolver; - public string[] SearchDirs; + var extractAssemblyTypeInfo = m_BuildPlayerDataExtractor.ExtractAssemblyTypeInfo(isEditor); + return extractAssemblyTypeInfo; } - /// Extract information about all types in the specified assembly, searchDirs might be used to resolve dependencies. - static public AssemblyTypeInfoGenerator.ClassInfo[] ExtractAssemblyTypeInfo(BuildTarget targetPlatform, bool isEditor, string assemblyPathName, string[] searchDirs) + static public AssemblyInfoManaged[] ExtractAssemblyTypeInfoFromFiles(string[] typeDbJsonPaths) { - try - { - AssemblyTypeInfoGenerator gen = new AssemblyTypeInfoGenerator(assemblyPathName, searchDirs); - return gen.GatherClassInfo(); - } - catch (System.Exception ex) - { - throw new Exception("ExtractAssemblyTypeInfo: Failed to process " + assemblyPathName + ", " + ex); - } + return m_BuildPlayerDataExtractor.ExtractAssemblyTypeInfoFromFiles(typeDbJsonPaths); } [StructLayout(LayoutKind.Sequential)] @@ -354,88 +114,17 @@ public struct RuntimeInitializeOnLoadMethodsData public int methodsCount; } - static void FindRuntimeInitializeOnLoadMethodAttributes(TypeDefinition type, - string assemblyName, - ref List classInfoList, - ref int methodCount) + [RequiredByNativeCode] + public static void ExtractPlayerRuntimeInitializeOnLoadMethods(string jsonPath) { - if (!type.HasMethods) - return; - - foreach (var method in type.Methods) + try { - // RuntimeInitializeOnLoadMethod only works on static methods. - if (!method.IsStatic) - continue; - - foreach (var attribute in method.CustomAttributes) - { - if (attribute.AttributeType.FullName == "UnityEngine.RuntimeInitializeOnLoadMethodAttribute") - { - RuntimeInitializeLoadType loadType = RuntimeInitializeLoadType.AfterSceneLoad; - - if (attribute.ConstructorArguments != null && attribute.ConstructorArguments.Count > 0) - loadType = (RuntimeInitializeLoadType)attribute.ConstructorArguments[0].Value; - - RuntimeInitializeClassInfo classInfo = new RuntimeInitializeClassInfo(); - - classInfo.assemblyName = assemblyName; - classInfo.className = type.FullName; - classInfo.methodNames = new[] { method.Name }; - classInfo.loadTypes = new[] { loadType }; - classInfoList.Add(classInfo); - methodCount++; - } - } + m_BuildPlayerDataExtractor.ExtractPlayerRuntimeInitializeOnLoadMethods(jsonPath); } - } - - [RequiredByNativeCode] - public static RuntimeInitializeOnLoadMethodsData ExtractPlayerRuntimeInitializeOnLoadMethods(BuildTarget targetPlatform, string[] assemblyPaths, string[] searchDirs) - { - var classInfoList = new List(); - int methodCount = 0; - - foreach (var assemblyPath in assemblyPaths) + catch (Exception exception) { - try - { - var assemblyResolverData = new GetAssemblyResolverData { SearchDirs = searchDirs, }; - var resolver = new DefaultAssemblyResolver(); - foreach (var searchDir in searchDirs) - resolver.AddSearchDirectory(searchDir); - - assemblyResolverData.Resolver = resolver; - - var assembly = AssemblyDefinition.ReadAssembly(assemblyPath, new ReaderParameters - { - AssemblyResolver = assemblyResolverData.Resolver - }); - - var assemblyName = assembly.Name.Name; - - foreach (var module in assembly.Modules) - { - foreach (var type in module.Types) - { - FindRuntimeInitializeOnLoadMethodAttributes(type, - assemblyName, - ref classInfoList, - ref methodCount); - } - } - } - catch (Exception ex) - { - throw new Exception("ExtractPlayerRuntimeInitializeOnLoadMethods: Failed to process " + assemblyPath + ", " + ex); - } + Debug.LogError($"Failed extracting RuntimeInitializeOnLoadMethods. Player will not be able to execute RuntimeInitializeOnLoadMethods: {exception.Message}{Environment.NewLine}{exception.StackTrace}"); } - - var data = new RuntimeInitializeOnLoadMethodsData(); - data.classInfos = classInfoList.ToArray(); - data.methodsCount = methodCount; - - return data; } internal static Type[] GetTypesFromAssembly(Assembly assembly) @@ -469,34 +158,78 @@ public static bool IsInternalAssembly(string file) return ModuleUtils.GetAdditionalReferencesForUserScripts().Any(p => p.Equals(file)); } - const int kDefaultDepth = 10; - internal static ICollection FindAssemblies(string basePath) + /// + /// Performs a depth-first-search topological sort on the input assemblies, + /// based on the outgoing assembly references from each assembly. The + /// returned list is sorted such that assembly A appears before any + /// assemblies that depend (directly or indirectly) on assembly A. + /// + internal static Assembly[] TopologicalSort(Assembly[] assemblies) { - return FindAssemblies(basePath, kDefaultDepth); - } + using var _ = new ProfilerMarker("SortAssembliesTopologically").Auto(); - internal static ICollection FindAssemblies(string basePath, int maxDepth) - { - var assemblies = new List(); + var assembliesByName = new Dictionary(assemblies.Length); + for (var i = 0; i < assemblies.Length; i++) + { + assembliesByName[assemblies[i].GetName().Name] = i; + } - if (0 == maxDepth) - return assemblies; + var result = new Assembly[assemblies.Length]; + var resultIndex = 0; - try + var visited = new TopologicalSortVisitStatus[assemblies.Length]; + + void VisitAssembly(int index) { - DirectoryInfo directory = new DirectoryInfo(basePath); - assemblies.AddRange(directory.GetFiles() - .Where(file => IsManagedAssembly(file.FullName)) - .Select(file => file.FullName)); - foreach (DirectoryInfo subdirectory in directory.GetDirectories()) - assemblies.AddRange(FindAssemblies(subdirectory.FullName, maxDepth - 1)); + var visitStatus = visited[index]; + + switch (visitStatus) + { + case TopologicalSortVisitStatus.Visiting: + // We have a cyclic dependency between assemblies. This should really be an error, but... + // We need to allow cyclic dependencies between assemblies, because the rest of Unity allows them. + // For example if you make an assembly override for UnityEngine.AccessibilityModule.dll, + // it will reference UnityEditor.CoreModule.dll, which in turn references + // UnityEngine.AccessibilityModule.dll... and that doesn't trigger an error. + // The topological sort won't be correct in this case, but it's better than erroring-out. + break; + + case TopologicalSortVisitStatus.NotVisited: + visited[index] = TopologicalSortVisitStatus.Visiting; + + var assembly = assemblies[index]; + + var assemblyReferences = assembly.GetReferencedAssemblies(); + foreach (var assemblyReference in assemblyReferences) + { + // It's okay if we can't resolve the assembly. It just means that the referenced assembly + // is not in the input set of assemblies, so we wouldn't be able to sort it anyway. + if (assembliesByName.TryGetValue(assemblyReference.Name, out var referencedAssembly)) + { + VisitAssembly(referencedAssembly); + } + } + + visited[index] = TopologicalSortVisitStatus.Visited; + + result[resultIndex++] = assembly; + break; + } } - catch (Exception) + + for (var i = 0; i < assemblies.Length; i++) { - // Return what we have now + VisitAssembly(i); } - return assemblies; + return result; + } + + private enum TopologicalSortVisitStatus : byte + { + NotVisited, + Visiting, + Visited } } } diff --git a/Editor/Mono/AssemblyInfo/AssemblyInfo.cs b/Editor/Mono/AssemblyInfo/AssemblyInfo.cs index c5cccb9ae8..5a99613788 100644 --- a/Editor/Mono/AssemblyInfo/AssemblyInfo.cs +++ b/Editor/Mono/AssemblyInfo/AssemblyInfo.cs @@ -2,11 +2,21 @@ // Copyright (c) Unity Technologies. For terms of use, see // https://unity3d.com/legal/licenses/Unity_Reference_Only_License +// NOTE: the build system includes this source file in ALL Editor modules + using System.Runtime.CompilerServices; using UnityEngine; +[assembly: AssemblyIsEditorAssembly] + +// TODO: over time, remove the InternalsVisibleTo attributes from this section +// You can start by moving them to EditorCoreModuleAssemblyInfo.cs to reduce internal visibility +// To remove a line in there, the target assembly must not depend on _any_ internal API from built-in Editor modules + + // ADD_NEW_PLATFORM_HERE [assembly: InternalsVisibleTo("Unity.LiveNotes")] +[assembly: InternalsVisibleTo("Unity.Audio.Tests")] [assembly: InternalsVisibleTo("Unity.Burst")] [assembly: InternalsVisibleTo("Unity.Burst.Editor")] [assembly: InternalsVisibleTo("Unity.Cloud.Collaborate.Editor")] @@ -24,28 +34,64 @@ [assembly: InternalsVisibleTo("UnityEngine.Common")] [assembly: InternalsVisibleTo("Unity.PureCSharpTests")] [assembly: InternalsVisibleTo("Unity.IntegrationTests")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.Android")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.Android.CommonUtils")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.Animation")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.AssetImporting")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.BuildPipeline")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.Builds")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.CrashReporting")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.DeploymentTargets")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.EditorApplication")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.EditorUI")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.GameCore")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.GameView")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.Lightmapping")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.Metro")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.Misc")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.PackageManager")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.Profiler")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.PS4")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.PS5")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.Switch")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.Rendering")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.SceneVisibility")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.ScriptCompilation")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.ShortcutManager")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.UIToolkit")] +[assembly: InternalsVisibleTo("Unity.IntegrationTests.Framework.PackageManager")] [assembly: InternalsVisibleTo("Unity.DeploymentTests.Services")] -[assembly: InternalsVisibleTo("Unity.IntegrationTests.UnityAnalytics")] +[assembly: InternalsVisibleTo("Unity.PerformanceIntegrationTests")] [assembly: InternalsVisibleTo("Unity.Timeline.Editor")] [assembly: InternalsVisibleTo("Unity.PackageManagerUI.Develop.Editor")] [assembly: InternalsVisibleTo("Unity.DeviceSimulator.Editor")] - [assembly: InternalsVisibleTo("Unity.Timeline.EditorTests")] [assembly: InternalsVisibleTo("UnityEditor.Graphs")] [assembly: InternalsVisibleTo("UnityEditor.UWP.Extensions")] [assembly: InternalsVisibleTo("UnityEditor.iOS.Extensions.Common")] +[assembly: InternalsVisibleTo("UnityEditor.Apple.Extensions.Common")] [assembly: InternalsVisibleTo("UnityEditor.iOS.Extensions")] +[assembly: InternalsVisibleTo("UnityEditor.VisionOS.Extensions")] [assembly: InternalsVisibleTo("UnityEditor.AppleTV.Extensions")] [assembly: InternalsVisibleTo("UnityEditor.Android.Extensions")] [assembly: InternalsVisibleTo("UnityEditor.XboxOne.Extensions")] [assembly: InternalsVisibleTo("UnityEditor.PS4.Extensions")] +[assembly: InternalsVisibleTo("UnityEditor.PS5.Extensions")] [assembly: InternalsVisibleTo("UnityEditor.Switch.Extensions")] [assembly: InternalsVisibleTo("UnityEditor.WebGL.Extensions")] +[assembly: InternalsVisibleTo("Unity.Automation.Players.WebGL")] +[assembly: InternalsVisibleTo("Unity.WebGL.Extensions")] [assembly: InternalsVisibleTo("UnityEditor.LinuxStandalone.Extensions")] +[assembly: InternalsVisibleTo("UnityEditor.CloudRendering.Extensions")] +[assembly: InternalsVisibleTo("UnityEditor.EmbeddedLinux.Extensions")] +[assembly: InternalsVisibleTo("UnityEditor.QNX.Extensions")] +[assembly: InternalsVisibleTo("UnityEditor.Kepler.Extensions")] [assembly: InternalsVisibleTo("UnityEditor.WindowsStandalone.Extensions")] [assembly: InternalsVisibleTo("UnityEditor.OSXStandalone.Extensions")] [assembly: InternalsVisibleTo("UnityEditor.Lumin.Extensions")] -[assembly: InternalsVisibleTo("UnityEditor.Stadia.Extensions")] +[assembly: InternalsVisibleTo("UnityEditor.GameCoreScarlett.Extensions")] +[assembly: InternalsVisibleTo("UnityEditor.GameCoreXboxOne.Extensions")] +[assembly: InternalsVisibleTo("UnityEditor.GameCoreCommon.Extensions")] [assembly: InternalsVisibleTo("UnityEditor.Networking")] [assembly: InternalsVisibleTo("UnityEngine.Networking")] [assembly: InternalsVisibleTo("Unity.Analytics.Editor")] @@ -103,6 +149,8 @@ [assembly: InternalsVisibleTo("Unity.XR.Remoting.Editor")] [assembly: InternalsVisibleTo("UnityEngine.Common")] [assembly: InternalsVisibleTo("Unity.UI.Builder.Editor")] +[assembly: InternalsVisibleTo("Unity.UI.TestFramework.Editor.Tests")] // for UI Test Framework +[assembly: InternalsVisibleTo("UnityEditor.UIBuilderModule")] [assembly: InternalsVisibleTo("Unity.UI.Builder.EditorTests")] [assembly: InternalsVisibleTo("Unity.GraphViewTestUtilities.Editor")] [assembly: InternalsVisibleTo("Unity.ProBuilder.Editor")] @@ -111,11 +159,56 @@ [assembly: InternalsVisibleTo("Unity.2D.Tilemap.Editor")] [assembly: InternalsVisibleTo("Unity.2D.Tilemap.EditorTests")] [assembly: InternalsVisibleTo("Unity.PackageCleanConsoleTest.Editor")] -[assembly: InternalsVisibleTo("Unity.UIElements")] -[assembly: InternalsVisibleTo("Unity.UIElements.Editor")] -[assembly: InternalsVisibleTo("Unity.UIElements.Tests")] -[assembly: InternalsVisibleTo("Unity.UIElements.EditorTests")] +[assembly: InternalsVisibleTo("Unity.TextCore.Editor.Tests")] +[assembly: InternalsVisibleTo("UnityEditor.TextCoreTextEngineModule")] +[assembly: InternalsVisibleTo("Unity.TextMeshPro.Editor")] +[assembly: InternalsVisibleTo("Unity.Animation.Editor.AnimationWindow")] +[assembly: InternalsVisibleTo("Unity.VisualEffectGraph.Editor")] +[assembly: InternalsVisibleTo("Unity.Testing.VisualEffectGraph.EditorTests")] +[assembly: InternalsVisibleTo("Unity.VisualEffectGraph.EditorTests")] +[assembly: InternalsVisibleTo("Unity.RenderPipelines.Multiple_SRP.EditorTests")] +[assembly: InternalsVisibleTo("Unity.ShaderGraph.Editor")] + [assembly: InternalsVisibleTo("Unity.SceneTemplate.Editor")] [assembly: InternalsVisibleTo("com.unity.purchasing.udp.Editor")] +[assembly: InternalsVisibleTo("com.unity.search.extensions.editor")] + +[assembly: InternalsVisibleTo("UnityEditor.Android.Extensions")] + +[assembly: InternalsVisibleTo("Unity.Entities.Build")] + +[assembly: InternalsVisibleTo("Unity.Muse.Chat.Bridge")] +[assembly: InternalsVisibleTo("Unity.AI.Assistant.Bridge.Editor")] + +[assembly: InternalsVisibleTo("Unity.Multiplayer.Playmode.Editor.Bridge")] +[assembly: InternalsVisibleTo("Unity.DedicatedServer.Editor.Bridge")] + +[assembly: InternalsVisibleTo("Unity.Scenes")] + + +[assembly: InternalsVisibleTo("UnityEditor.Switch.Tests")] + +[assembly: InternalsVisibleTo("UnityEditor.BuildProfileModule.Tests")] + +[assembly: InternalsVisibleTo("UnityEditor.PS4.Tests")] + +[assembly: InternalsVisibleTo("UnityEditor.PS5.Tests")] + +[assembly: InternalsVisibleTo("Unity.Automation.Players.EmbeddedLinux")] +[assembly: InternalsVisibleTo("Unity.Automation.Players.QNX")] + +[assembly: InternalsVisibleTo("Unity.GraphToolsAuthoringFramework.InternalEditorBridge")] + +// Module test assemblies +[assembly: InternalsVisibleTo("Unity.Modules.iOSExtensions.Tests.Editor")] +[assembly: InternalsVisibleTo("Unity.Modules.Licensing.Tests.Editor")] +[assembly: InternalsVisibleTo("Unity.Modules.PlatformIcons.Tests.Editor")] +// This should move with the AnimationWindow to a module at some point +[assembly: InternalsVisibleTo("Unity.Modules.Animation.AnimationWindow.Tests.Editor")] +[assembly: InternalsVisibleTo("Unity.Modules.Physics.Tests.Editor")] +[assembly: InternalsVisibleTo("Unity.Tests.Shared")] + +// Test Assemblies +[assembly: InternalsVisibleTo("Unity.Core.UnityEvent.Tests.Editor")] +[assembly: InternalsVisibleTo("Unity.Core.Scripting.AssemblyVersion.Tests.Editor")] -[assembly: AssemblyIsEditorAssembly] diff --git a/Editor/Mono/AssemblyReloadEvents.cs b/Editor/Mono/AssemblyReloadEvents.cs index 9a908f5235..b5eb6a24fb 100644 --- a/Editor/Mono/AssemblyReloadEvents.cs +++ b/Editor/Mono/AssemblyReloadEvents.cs @@ -9,21 +9,45 @@ namespace UnityEditor public static class AssemblyReloadEvents { public delegate void AssemblyReloadCallback(); - public static event AssemblyReloadCallback beforeAssemblyReload; - public static event AssemblyReloadCallback afterAssemblyReload; + public static event AssemblyReloadCallback beforeAssemblyReload + { + add => m_BeforeAssemblyReloadEvent.Add(value); + remove => m_BeforeAssemblyReloadEvent.Remove(value); + } + private static EventWithPerformanceTracker m_BeforeAssemblyReloadEvent = + new EventWithPerformanceTracker($"{nameof(AssemblyReloadEvents)}.{nameof(beforeAssemblyReload)}"); + public static event AssemblyReloadCallback afterAssemblyReload + { + add => m_AfterAssemblyReloadEvent.Add(value); + remove => m_AfterAssemblyReloadEvent.Remove(value); + } + private static EventWithPerformanceTracker m_AfterAssemblyReloadEvent = + new EventWithPerformanceTracker($"{nameof(AssemblyReloadEvents)}.{nameof(afterAssemblyReload)}"); [RequiredByNativeCode] static void OnBeforeAssemblyReload() { - if (beforeAssemblyReload != null) - beforeAssemblyReload(); + if (!m_BeforeAssemblyReloadEvent.hasSubscribers) + return; + using var scope = new ProgressScope("OnBeforeAssemblyReload Callback", "", forceUpdate: true); + foreach (var evt in m_BeforeAssemblyReloadEvent) + { + scope.SetText($"{evt.Method?.DeclaringType?.FullName}.{evt.Method?.Name}", true); + evt(); + } } [RequiredByNativeCode] static void OnAfterAssemblyReload() { - if (afterAssemblyReload != null) - afterAssemblyReload(); + if (!m_AfterAssemblyReloadEvent.hasSubscribers) + return; + using var scope = new ProgressScope("OnAfterAssemblyReload Callback", "", forceUpdate: true); + foreach (var evt in m_AfterAssemblyReloadEvent) + { + scope.SetText($"{evt.Method?.DeclaringType?.FullName}.{evt.Method?.Name}", true); + evt(); + } } } } diff --git a/Editor/Mono/AssemblyValidation.cs b/Editor/Mono/AssemblyValidation.cs index 8221509241..bc57ec7a62 100644 --- a/Editor/Mono/AssemblyValidation.cs +++ b/Editor/Mono/AssemblyValidation.cs @@ -6,8 +6,10 @@ using System.Collections.Generic; using System.Globalization; using System.IO; +using System.Linq; using System.Runtime.InteropServices; using Mono.Cecil; +using Unity.IO.LowLevel.Unsafe; using UnityEditor.Scripting.ScriptCompilation; using UnityEngine.Scripting; @@ -130,12 +132,39 @@ public static Error[] ValidateAssemblies(string[] assemblyPaths, bool enableLogg } var errors = ValidateAssemblyDefinitions(assemblyPaths, - assemblyDefinitions, - PluginCompatibleWithEditor); + assemblyDefinitions); return errors; } + [RequiredByNativeCode] + internal static Error[] ValidateRoslynAnalyzers(string[] analyzerPaths) + { + var readerParameters = new ReaderParameters + { + ReadingMode = ReadingMode.Deferred + }; + List errors = new List(); + foreach(var analyzer in analyzerPaths) + { + using (var analyzerDefinition = AssemblyDefinition.ReadAssembly(analyzer, readerParameters)) + { + var netstandardVersion = analyzerDefinition.MainModule.AssemblyReferences.Where(r => r.Name == "netstandard").FirstOrDefault(); + if (netstandardVersion != null && netstandardVersion.Version >= new Version(2, 1)) + { + errors.Add(new Error + { + assemblyPath = analyzer, + flags = ErrorFlags.ReferenceHasErrors, + message = $"{analyzerDefinition.Name.Name} references {netstandardVersion}. A roslyn analyzer should reference netstandard version 2.0" + }); + } + + } + } + return errors.ToArray(); + } + [RequiredByNativeCode] public static Error[] ValidateAssemblyDefinitionFiles() { @@ -182,27 +211,14 @@ public static Error[] ValidateAssemblyDefinitionFiles() return errors.ToArray(); } - public static bool PluginCompatibleWithEditor(string path) - { - var pluginImporter = AssetImporter.GetAtPath(path) as PluginImporter; - - if (pluginImporter == null) - return true; - - if (pluginImporter.GetCompatibleWithAnyPlatform()) - return true; - - return pluginImporter.GetCompatibleWithEditor(); - } - - public static bool ShouldValidateReferences(string path) + public static bool ShouldValidateReferences(string path, + Dictionary allPrecompiledAssemblies) { - var pluginImporter = AssetImporter.GetAtPath(path) as PluginImporter; - if (pluginImporter == null) + if (!allPrecompiledAssemblies.TryGetValue(path, out var precompiledAssembly)) return true; - return pluginImporter.ValidateReferences; + return precompiledAssembly.Flags.HasFlag(AssemblyFlags.ValidateAssembly); } public static void PrintAssemblyDefinitions(AssemblyDefinition[] assemblyDefinitions) @@ -221,23 +237,20 @@ public static void PrintAssemblyDefinitions(AssemblyDefinition[] assemblyDefinit } public static Error[] ValidateAssembliesInternal(string[] assemblyPaths, - string[] searchPaths, - Func compatibleWithEditor) + string[] searchPaths) { var assemblyDefinitions = LoadAssemblyDefinitions(assemblyPaths, searchPaths); - return ValidateAssemblyDefinitions(assemblyPaths, assemblyDefinitions, compatibleWithEditor); + return ValidateAssemblyDefinitions(assemblyPaths, assemblyDefinitions); } public static Error[] ValidateAssemblyDefinitions(string[] assemblyPaths, - AssemblyDefinition[] assemblyDefinitions, - Func compatibleWithEditor) + AssemblyDefinition[] assemblyDefinitions) { var errors = new Error[assemblyPaths.Length]; CheckAssemblyReferences(assemblyPaths, errors, - assemblyDefinitions, - compatibleWithEditor); + assemblyDefinitions); return errors; } @@ -271,11 +284,8 @@ public static AssemblyDefinition[] LoadAssemblyDefinitions(string[] assemblyPath public static void CheckAssemblyReferences(string[] assemblyPaths, Error[] errors, - AssemblyDefinition[] assemblyDefinitions, - Func compatibleWithEditor) + AssemblyDefinition[] assemblyDefinitions) { - SetupEditorCompatibility(assemblyPaths, errors, compatibleWithEditor); - var assemblyDefinitionNameToIndex = new Dictionary(); var assembliesAndReferencesArray = new AssemblyAndReferences[assemblyPaths.Length]; @@ -289,6 +299,11 @@ public static void CheckAssemblyReferences(string[] assemblyPaths, }; } + var precompiledAssemblies = EditorCompilationInterface.Instance + .PrecompiledAssemblyProvider.GetAllPrecompiledAssemblies() + .Where(x => x.Flags.HasFlag(AssemblyFlags.UserAssembly)); + var allPrecompiledAssemblies = precompiledAssemblies.ToDictionary(x => AssetPath.ReplaceSeparators(VirtualFileSystem.ToLogicalPath(x.Path))); + for (int i = 0; i < assemblyPaths.Length; ++i) { if (errors[i].HasFlag(ErrorFlags.IncompatibleWithEditor)) @@ -298,14 +313,15 @@ public static void CheckAssemblyReferences(string[] assemblyPaths, // Check if "Validate References" option is enabled // in the PluginImporter - if (!ShouldValidateReferences(assemblyPath)) + if (!ShouldValidateReferences(AssetPath.ReplaceSeparators(assemblyPath), allPrecompiledAssemblies)) continue; ResolveAndSetupReferences(i, errors, assemblyDefinitions, assemblyDefinitionNameToIndex, - assembliesAndReferencesArray); + assembliesAndReferencesArray, + assemblyPath); } // Check assemblies for references to assemblies with errors @@ -346,27 +362,12 @@ public static void CheckAssemblyReferences(string[] assemblyPaths, while (referenceErrorCount > 0); } - public static void SetupEditorCompatibility(string[] assemblyPaths, - Error[] errors, - Func compatibleWithEditor) - { - for (int i = 0; i < assemblyPaths.Length; ++i) - { - var assemblyPath = assemblyPaths[i]; - - if (!compatibleWithEditor(assemblyPath)) - { - errors[i].Add(ErrorFlags.IncompatibleWithEditor, - "Assembly is incompatible with the editor"); - } - } - } - public static void ResolveAndSetupReferences(int index, Error[] errors, AssemblyDefinition[] assemblyDefinitions, Dictionary assemblyDefinitionNameToIndex, - AssemblyAndReferences[] assemblyAndReferences) + AssemblyAndReferences[] assemblyAndReferences, + string assemblyPath) { var assemblyDefinition = assemblyDefinitions[index]; var assemblyResolver = assemblyDefinition.MainModule.AssemblyResolver; @@ -378,29 +379,25 @@ public static void ResolveAndSetupReferences(int index, Capacity = assemblyReferences.Length }; + bool isReferencingUnityAssemblies = false; foreach (var reference in assemblyReferences) { + if (!isReferencingUnityAssemblies && (Utility.FastStartsWith(reference.Name, "UnityEngine", "unityengine") || Utility.FastStartsWith(reference.Name, "UnityEditor", "unityeditor"))) + { + isReferencingUnityAssemblies = true; + } + try { var referenceAssemblyDefinition = assemblyResolver.Resolve(reference); - int referenceAssemblyDefinitionIndex; - - if (assemblyDefinitionNameToIndex.TryGetValue(referenceAssemblyDefinition.Name.Name, - out referenceAssemblyDefinitionIndex)) + if (reference.Name == assemblyDefinition.Name.Name) { - bool isSigned = IsSigned(reference); - if (isSigned) - { - var definition = assemblyDefinitions[referenceAssemblyDefinitionIndex]; - - if (definition.Name.Version.ToString() != reference.Version.ToString() && !IsInSameFolder(assemblyDefinition, referenceAssemblyDefinition)) - { - errors[index].Add(ErrorFlags.UnresolvableReference, - $"{assemblyDefinition.Name.Name} references strong named {reference.Name} in a different folder, versions has to match. Assembly references: {reference.Version} Found in project: {definition.Name.Version}."); - } - } + errors[index].Add(ErrorFlags.ReferenceHasErrors, $"{reference.Name} references itself."); + } + if (assemblyDefinitionNameToIndex.TryGetValue(referenceAssemblyDefinition.Name.Name, out int referenceAssemblyDefinitionIndex)) + { referenceIndieces.Add(referenceAssemblyDefinitionIndex); } } @@ -412,6 +409,15 @@ public static void ResolveAndSetupReferences(int index, } } + if (isReferencingUnityAssemblies) + { + var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(assemblyPath); + if (assemblyDefinitions[index].Name.Name != fileNameWithoutExtension) + { + errors[index].Add(ErrorFlags.ReferenceHasErrors, $"Assembly name '{assemblyDefinitions[index].Name.Name}' does not match file name '{fileNameWithoutExtension}'"); + } + } + assemblyAndReferences[index].referenceIndicies = referenceIndieces.ToArray(); } diff --git a/Editor/Mono/AssetDatabase/AssetDatabase.cs b/Editor/Mono/AssetDatabase/AssetDatabase.cs index 0e8519e5be..733c8e8f70 100644 --- a/Editor/Mono/AssetDatabase/AssetDatabase.cs +++ b/Editor/Mono/AssetDatabase/AssetDatabase.cs @@ -19,53 +19,74 @@ public sealed partial class AssetDatabase public delegate void ImportPackageFailedCallback(string packageName, string errorMessage); // Delegate to be called when package import begins - public static event ImportPackageCallback importPackageStarted; + public static event ImportPackageCallback importPackageStarted + { + add => m_importPackageStartedEvent.Add(value); + remove => m_importPackageStartedEvent.Remove(value); + } + private static EventWithPerformanceTracker m_importPackageStartedEvent = new EventWithPerformanceTracker($"{nameof(AssetDatabase)}.{nameof(importPackageStarted)}"); // Delegate to be called when package import completes - public static event ImportPackageCallback importPackageCompleted; + public static event ImportPackageCallback importPackageCompleted + { + add => m_importPackageCompletedEvent.Add(value); + remove => m_importPackageCompletedEvent.Remove(value); + } + private static EventWithPerformanceTracker m_importPackageCompletedEvent = new EventWithPerformanceTracker($"{nameof(AssetDatabase)}.{nameof(importPackageCompleted)}"); // Called when package import completes, listing the selected items public static Action onImportPackageItemsCompleted; + private static DelegateWithPerformanceTracker> m_onImportPackageItemsCompleted = new DelegateWithPerformanceTracker>($"{nameof(AssetDatabase)}.{nameof(onImportPackageItemsCompleted)}"); // Delegate to be called when package import is cancelled - public static event ImportPackageCallback importPackageCancelled; + public static event ImportPackageCallback importPackageCancelled + { + add => m_importPackageCancelledEvent.Add(value); + remove => m_importPackageCancelledEvent.Remove(value); + } + private static EventWithPerformanceTracker m_importPackageCancelledEvent = new EventWithPerformanceTracker($"{nameof(AssetDatabase)}.{nameof(importPackageCancelled)}"); // Delegate to be called when package import fails - public static event ImportPackageFailedCallback importPackageFailed; + public static event ImportPackageFailedCallback importPackageFailed + { + add => m_importPackageFailedEvent.Add(value); + remove => m_importPackageFailedEvent.Remove(value); + } + private static EventWithPerformanceTracker m_importPackageFailedEvent = new EventWithPerformanceTracker($"{nameof(AssetDatabase)}.{nameof(importPackageFailed)}"); [RequiredByNativeCode] private static void Internal_CallImportPackageStarted(string packageName) { - if (importPackageStarted != null) - importPackageStarted(packageName); + foreach (var evt in m_importPackageStartedEvent) + evt(packageName); } [RequiredByNativeCode] private static void Internal_CallImportPackageCompleted(string packageName) { - if (importPackageCompleted != null) - importPackageCompleted(packageName); + foreach (var evt in m_importPackageCompletedEvent) + evt(packageName); } [RequiredByNativeCode] private static void Internal_CallOnImportPackageItemsCompleted(string[] items) { - if (onImportPackageItemsCompleted != null) - onImportPackageItemsCompleted(items); + foreach (var evt in m_onImportPackageItemsCompleted.UpdateAndInvoke(onImportPackageItemsCompleted)) + evt(items); } [RequiredByNativeCode] private static void Internal_CallImportPackageCancelled(string packageName) { - if (importPackageCancelled != null) - importPackageCancelled(packageName); + foreach (var evt in m_importPackageCancelledEvent) + evt(packageName); } [RequiredByNativeCode] private static void Internal_CallImportPackageFailed(string packageName, string errorMessage) { - if (importPackageFailed != null) - importPackageFailed(packageName, errorMessage); + foreach (var evt in m_importPackageFailedEvent) + evt(packageName, errorMessage); } [RequiredByNativeCode] @@ -74,6 +95,17 @@ private static bool Internal_IsOpenForEdit(string assetOrMetaFilePath) return IsOpenForEdit(assetOrMetaFilePath); } + public static void CanOpenForEdit(string[] assetOrMetaFilePaths, List outNotEditablePaths, [uei.DefaultValue("StatusQueryOptions.UseCachedIfPossible")] StatusQueryOptions statusQueryOptions = StatusQueryOptions.UseCachedIfPossible) + { + if (assetOrMetaFilePaths == null) + throw new ArgumentNullException(nameof(assetOrMetaFilePaths)); + if (outNotEditablePaths == null) + throw new ArgumentNullException(nameof(outNotEditablePaths)); + UnityEngine.Profiling.Profiler.BeginSample("AssetDatabase.CanOpenForEdit"); + AssetModificationProcessorInternal.CanOpenForEdit(assetOrMetaFilePaths, outNotEditablePaths, statusQueryOptions); + UnityEngine.Profiling.Profiler.EndSample(); + } + public static void IsOpenForEdit(string[] assetOrMetaFilePaths, List outNotEditablePaths, [uei.DefaultValue("StatusQueryOptions.UseCachedIfPossible")] StatusQueryOptions statusQueryOptions = StatusQueryOptions.UseCachedIfPossible) { if (assetOrMetaFilePaths == null) @@ -108,12 +140,15 @@ public static bool MakeEditable(string[] paths, string prompt = null, List GetTextMetaFilePathFromAssetPath(*)")] + [Obsolete("GetTextMetaDataPathFromAssetPath has been renamed to GetTextMetaFilePathFromAssetPath (UnityUpgradable) -> GetTextMetaFilePathFromAssetPath(*)",true)] public static string GetTextMetaDataPathFromAssetPath(string path) { return null; } } // Used to be part of Asset Server, and public API for some reason. - [Obsolete("AssetStatus enum is not used anymore (Asset Server has been removed)")] + [Obsolete("AssetStatus enum is not used anymore (Asset Server has been removed)",true)] public enum AssetStatus { Calculating = -1, @@ -32,7 +35,7 @@ public enum AssetStatus } // Used to be part of Asset Server, and public API for some reason. - [Obsolete("AssetsItem class is not used anymore (Asset Server has been removed)")] + [Obsolete("AssetsItem class is not used anymore (Asset Server has been removed)",true)] [StructLayout(LayoutKind.Sequential)] [System.Serializable] public sealed class AssetsItem @@ -50,3 +53,92 @@ public sealed class AssetsItem } } +namespace UnityEditor.Experimental +{ + public partial class AssetDatabaseExperimental + { + [FreeFunction("AssetDatabase::ClearImporterOverride")] + [Obsolete("AssetDatabaseExperimental.ClearImporterOverride() has been deprecated. Use AssetDatabase.ClearImporterOverride() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.ClearImporterOverride(*)", true)] + extern public static void ClearImporterOverride(string path); + + [FreeFunction("AssetDatabase::IsCacheServerEnabled")] + [Obsolete("AssetDatabaseExperimental.IsCacheServerEnabled() has been deprecated. Use AssetDatabase.IsCacheServerEnabled() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.IsCacheServerEnabled(*)", true)] + public extern static bool IsCacheServerEnabled(); + + [Obsolete("AssetDatabaseExperimental.SetImporterOverride() has been deprecated. Use AssetDatabase.SetImporterOverride() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.SetImporterOverride(*)", true)] + public static void SetImporterOverride(string path) + where T : ScriptedImporter + { + AssetDatabase.SetImporterOverrideInternal(path, typeof(T)); + } + + [FreeFunction("AssetDatabase::GetImporterOverride")] + [Obsolete("AssetDatabaseExperimental.GetImporterOverride() has been deprecated. Use AssetDatabase.GetImporterOverride() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.GetImporterOverride(*)", true)] + extern public static System.Type GetImporterOverride(string path); + + [FreeFunction("AssetDatabase::GetAvailableImporters")] + [Obsolete("AssetDatabaseExperimental.GetAvailableImporterTypes() has been deprecated. Use AssetDatabase.GetAvailableImporters() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.GetAvailableImporters(*)", true)] + extern public static Type[] GetAvailableImporterTypes(string path); + + [FreeFunction("AcceleratorClientCanConnectTo")] + [Obsolete("AssetDatabaseExperimental.CanConnectToCacheServer() has been deprecated. Use AssetDatabase.CanConnectToCacheServer() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.CanConnectToCacheServer(*)", true)] + public extern static bool CanConnectToCacheServer(string ip, UInt16 port); + + [FreeFunction()] + [Obsolete("AssetDatabaseExperimental.RefreshSettings() has been deprecated. Use AssetDatabase.RefreshSettings() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.RefreshSettings(*)", true)] + public extern static void RefreshSettings(); + + [Obsolete("AssetDatabaseExperimental.CacheServerConnectionChangedParameters has been deprecated. Use UnityEditor.CacheServerConnectionChangedParameters instead (UnityUpgradable) -> UnityEditor.CacheServerConnectionChangedParameters", true)] + public struct CacheServerConnectionChangedParameters + { + } + +#pragma warning disable 67 + [Obsolete("AssetDatabaseExperimental.cacheServerConnectionChanged has been deprecated. Use AssetDatabase.cacheServerConnectionChanged instead (UnityUpgradable) -> UnityEditor.AssetDatabase.cacheServerConnectionChanged", true)] + public static event Action cacheServerConnectionChanged; +#pragma warning restore 67 + + [FreeFunction("AcceleratorClientIsConnected")] + [Obsolete("AssetDatabaseExperimental.IsConnectedToCacheServer() has been deprecated. Use AssetDatabase.IsConnectedToCacheServer() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.IsConnectedToCacheServer(*)", true)] + public extern static bool IsConnectedToCacheServer(); + + [FreeFunction()] + [Obsolete("AssetDatabaseExperimental.GetCacheServerAddress() has been deprecated. Use AssetDatabase.GetCacheServerAddress() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.GetCacheServerAddress(*)", true)] + public extern static string GetCacheServerAddress(); + + [FreeFunction()] + [Obsolete("AssetDatabaseExperimental.GetCacheServerPort() has been deprecated. Use AssetDatabase.GetCacheServerPort() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.GetCacheServerPort(*)", true)] + public extern static UInt16 GetCacheServerPort(); + + [FreeFunction("AssetDatabase::GetCacheServerNamespacePrefix")] + [Obsolete("AssetDatabaseExperimental.GetCacheServerNamespacePrefix() has been deprecated. Use AssetDatabase.GetCacheServerNamespacePrefix() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.GetCacheServerNamespacePrefix(*)", true)] + public extern static string GetCacheServerNamespacePrefix(); + + [FreeFunction("AssetDatabase::GetCacheServerEnableDownload")] + [Obsolete("AssetDatabaseExperimental.GetCacheServerEnableDownload() has been deprecated. Use AssetDatabase.GetCacheServerEnableDownload() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.GetCacheServerEnableDownload(*)", true)] + public extern static bool GetCacheServerEnableDownload(); + + [FreeFunction("AssetDatabase::GetCacheServerEnableUpload")] + [Obsolete("AssetDatabaseExperimental.GetCacheServerEnableUpload() has been deprecated. Use AssetDatabase.GetCacheServerEnableUpload() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.GetCacheServerEnableUpload(*)", true)] + public extern static bool GetCacheServerEnableUpload(); + + [FreeFunction("AssetDatabase::IsDirectoryMonitoringEnabled")] + [Obsolete("AssetDatabaseExperimental.IsDirectoryMonitoringEnabled() has been deprecated. Use AssetDatabase.IsDirectoryMonitoringEnabled() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.IsDirectoryMonitoringEnabled(*)", true)] + public extern static bool IsDirectoryMonitoringEnabled(); + + [FreeFunction("AssetDatabaseExperimental::RegisterCustomDependency")] + [PreventExecutionInState(AssetDatabasePreventExecution.kPreventCustomDependencyChanges, PreventExecutionSeverity.PreventExecution_ManagedException, "Custom dependencies can only be removed when the assetdatabase is not importing.")] + [Obsolete("AssetDatabaseExperimental.RegisterCustomDependency() has been deprecated. Use AssetDatabase.RegisterCustomDependency() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.RegisterCustomDependency(*)", true)] + public extern static void RegisterCustomDependency(string dependency, Hash128 hashOfValue); + + [FreeFunction("AssetDatabaseExperimental::UnregisterCustomDependencyPrefixFilter")] + [PreventExecutionInState(AssetDatabasePreventExecution.kPreventCustomDependencyChanges, PreventExecutionSeverity.PreventExecution_ManagedException, "Custom dependencies can only be removed when the assetdatabase is not importing.")] + [Obsolete("AssetDatabaseExperimental.UnregisterCustomDependencyPrefixFilter() has been deprecated. Use AssetDatabase.UnregisterCustomDependencyPrefixFilter() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.UnregisterCustomDependencyPrefixFilter(*)", true)] + public extern static UInt32 UnregisterCustomDependencyPrefixFilter(string prefixFilter); + + [FreeFunction("AssetDatabase::IsAssetImportProcess")] + [Obsolete("AssetDatabaseExperimental.IsAssetImportWorkerProcess() has been deprecated. Use AssetDatabase.IsAssetImportWorkerProcess() instead (UnityUpgradable) -> UnityEditor.AssetDatabase.IsAssetImportWorkerProcess(*)", true)] + public extern static bool IsAssetImportWorkerProcess(); + } +} + diff --git a/Editor/Mono/AssetDatabase/AssetDatabaseSearching.cs b/Editor/Mono/AssetDatabase/AssetDatabaseSearching.cs index 73a65b22ac..1597fff5e5 100644 --- a/Editor/Mono/AssetDatabase/AssetDatabaseSearching.cs +++ b/Editor/Mono/AssetDatabase/AssetDatabaseSearching.cs @@ -5,7 +5,9 @@ using System; using System.Linq; using System.Collections.Generic; +using UnityEditor.Utils; using UnityEngine; +using UnityEngine.Bindings; using Object = UnityEngine.Object; namespace UnityEditor @@ -32,9 +34,10 @@ public static string[] FindAssets(string filter, string[] searchInFolders) internal static string[] FindAssets(SearchFilter searchFilter) { - return FindAllAssets(searchFilter).Select(property => property.guid).ToArray(); + return FindAllAssets(searchFilter).Select(property => property.guid).Distinct().ToArray(); } + [VisibleToOtherModules("UnityEditor.UIBuilderModule")] internal static IEnumerable FindAllAssets(SearchFilter searchFilter) { var enumerator = EnumerateAllAssets(searchFilter); @@ -64,13 +67,15 @@ private static IEnumerator FindInFolders(SearchFilter searchFilter, Func FindInFolders(SearchFilter searchFilter, Func FindInFolders(SearchFilter searchFilter, Func FindEverywhere(SearchFilter searchFilter, Func< rootPaths.Add(package.assetPath); } } + + HierarchyProperty lastProperty = null; foreach (var rootPath in rootPaths) { var property = new HierarchyProperty(rootPath); - property.SetSearchFilter(searchFilter); + if (lastProperty != null) + property.CopySearchFilterFrom(lastProperty); + else + property.SetSearchFilter(searchFilter); + lastProperty = property; while (property.Next(null)) { yield return selector(property); diff --git a/Editor/Mono/AssetDatabase/AssetPreview.bindings.cs b/Editor/Mono/AssetDatabase/AssetPreview.bindings.cs index 4cca1c5fc8..752db88303 100644 --- a/Editor/Mono/AssetDatabase/AssetPreview.bindings.cs +++ b/Editor/Mono/AssetDatabase/AssetPreview.bindings.cs @@ -22,16 +22,16 @@ public static Texture2D GetAssetPreview(Object asset) return null; } - internal static Texture2D GetAssetPreview(int instanceID) + internal static Texture2D GetAssetPreview(EntityId entityId) { - return GetAssetPreview(instanceID, kSharedClientID); + return GetAssetPreview(entityId, kSharedClientID); } [FreeFunction("AssetPreviewBindings::GetAssetPreview")] - internal static extern Texture2D GetAssetPreview(int instanceID, int clientID); + internal static extern Texture2D GetAssetPreview(EntityId entityId, int clientID); [FreeFunction("AssetPreviewBindings::HasAssetPreview")] - internal static extern bool HasAssetPreview(int instanceID, int clientID); + internal static extern bool HasAssetPreview(EntityId entityId, int clientID); internal static Texture2D GetAssetPreviewFromGUID(string guid) { @@ -46,8 +46,13 @@ public static bool IsLoadingAssetPreview(int instanceID) return IsLoadingAssetPreview(instanceID, kSharedClientID); } + public static bool IsLoadingAssetPreview(EntityId entityId) + { + return IsLoadingAssetPreview(entityId, kSharedClientID); + } + [FreeFunction("AssetPreviewBindings::IsLoadingAssetPreview")] - internal static extern bool IsLoadingAssetPreview(int instanceID, int clientID); + internal static extern bool IsLoadingAssetPreview(EntityId entityId, int clientID); public static bool IsLoadingAssetPreviews() { @@ -89,12 +94,7 @@ public static Texture2D GetMiniThumbnail(Object obj) public static Texture2D GetMiniTypeThumbnail(Type type) { - Texture2D tex; - if (typeof(MonoBehaviour).IsAssignableFrom(type)) - tex = EditorGUIUtility.LoadIcon(type.FullName.Replace('.', '/') + " Icon"); - else - tex = GetMiniTypeThumbnailFromType(type); - return tex; + return GetMiniTypeThumbnailFromType(type); } [FreeFunction("AssetPreviewBindings::GetMiniTypeThumbnailFromObject")] diff --git a/Editor/Mono/AssetDatabase/AssetsModifiedProcessor.cs b/Editor/Mono/AssetDatabase/AssetsModifiedProcessor.cs index 84164ffc05..5566b7228e 100644 --- a/Editor/Mono/AssetDatabase/AssetsModifiedProcessor.cs +++ b/Editor/Mono/AssetDatabase/AssetsModifiedProcessor.cs @@ -4,6 +4,7 @@ using System; using System.Collections.Generic; +using UnityEditor.Profiling; namespace UnityEditor.Experimental { @@ -30,7 +31,11 @@ protected void ReportAssetChanged(string assetChanged) internal void Internal_OnAssetsModified(string[] changedAssets, string[] addedAssets, string[] deletedAssets, AssetMoveInfo[] movedAssets) { - OnAssetsModified(changedAssets, addedAssets, deletedAssets, movedAssets); + var type = GetType(); + using (new EditorPerformanceMarker($"{type.Name}.{nameof(OnAssetsModified)}", type).Auto()) + { + OnAssetsModified(changedAssets, addedAssets, deletedAssets, movedAssets); + } } } } diff --git a/Editor/Mono/AssetModificationProcessor.cs b/Editor/Mono/AssetModificationProcessor.cs index d542559bf9..3c49382af1 100644 --- a/Editor/Mono/AssetModificationProcessor.cs +++ b/Editor/Mono/AssetModificationProcessor.cs @@ -5,31 +5,24 @@ using System; using System.Collections.Generic; using UnityEngine; +using UnityEngine.Scripting; using UnityEditor.VersionControl; using UnityEditorInternal; using UnityEditorInternal.VersionControl; using System.Linq; using System.Reflection; - -[Obsolete("Use UnityEditor.AssetModificationProcessor")] -public class AssetModificationProcessor -{ -} +using UnityEditor.Profiling; +using UnityEngine.Scripting.APIUpdating; namespace UnityEditor { + [MovedFrom("")] public class AssetModificationProcessor { } internal class AssetModificationProcessorInternal { - enum FileMode - { - Binary, - Text - } - static bool CheckArgumentTypes(Type[] types, MethodInfo method) { ParameterInfo[] parameters = method.GetParameters(); @@ -96,7 +89,6 @@ static System.Collections.Generic.IEnumerable AssetModificationProc { List processors = new List(); processors.AddRange(TypeCache.GetTypesDerivedFrom()); - processors.AddRange(TypeCache.GetTypesDerivedFrom()); assetModificationProcessors = processors.ToArray(); } return assetModificationProcessors; @@ -104,42 +96,48 @@ static System.Collections.Generic.IEnumerable AssetModificationProc } #pragma warning restore 0618 - static void OnWillCreateAsset(string path) + [RequiredByNativeCode] + internal static void OnWillCreateAsset(string path) { foreach (var assetModificationProcessorClass in AssetModificationProcessors) { - MethodInfo method = assetModificationProcessorClass.GetMethod("OnWillCreateAsset", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); + const string methodName = "OnWillCreateAsset"; + MethodInfo method = assetModificationProcessorClass.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); if (method != null) { object[] args = { path }; if (!CheckArguments(args, method)) continue; - method.Invoke(null, args); + using (new EditorPerformanceMarker($"{assetModificationProcessorClass.Name}.{methodName}", assetModificationProcessorClass).Auto()) + method.Invoke(null, args); } } } // ReSharper disable once UnusedMember.Local - invoked from native code - static void FileModeChanged(string[] assets, UnityEditor.VersionControl.FileMode mode) + [RequiredByNativeCode] + static void FileModeChanged(string[] assets, FileMode mode) { - if (!Provider.enabled) - return; + AssetModificationHook.FileModeChanged(assets, mode); - // if we happen to be disconnected or work offline, there's not much we can do; - // just ignore the file mode and hope that VCS client/project is setup to handle - // appropriate file types correctly - if (!Provider.isActive) - return; - - // we'll want to re-serialize these assets in different (text vs binary) mode; - // make sure they are editable first - AssetDatabase.MakeEditable(assets); - Provider.SetFileMode(assets, mode); + object[] args = { assets, mode }; + foreach (var type in AssetModificationProcessors) + { + const string methodName = "FileModeChanged"; + var method = type.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); + if (method == null) + continue; + if (!CheckArgumentsAndReturnType(args, method, typeof(void))) + continue; + using (new EditorPerformanceMarker($"{type.Name}.{methodName}", type).Auto()) + method.Invoke(null, args); + } } // Postprocess on all assets once an automatic import has completed // ReSharper disable once UnusedMember.Local - invoked from native code + [RequiredByNativeCode] static void OnWillSaveAssets(string[] assets, out string[] assetsThatShouldBeSaved, out string[] assetsThatShouldBeReverted, bool explicitlySaveAsset) { assetsThatShouldBeReverted = new string[0]; @@ -159,14 +157,17 @@ static void OnWillSaveAssets(string[] assets, out string[] assetsThatShouldBeSav foreach (var assetModificationProcessorClass in AssetModificationProcessors) { - MethodInfo method = assetModificationProcessorClass.GetMethod("OnWillSaveAssets", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); + const string methodName = "OnWillSaveAssets"; + MethodInfo method = assetModificationProcessorClass.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); if (method != null) { object[] args = { assetsThatShouldBeSaved }; if (!CheckArguments(args, method)) continue; - string[] result = (string[])method.Invoke(null, args); + string[] result; + using (new EditorPerformanceMarker($"{assetModificationProcessorClass.Name}.{methodName}", assetModificationProcessorClass).Auto()) + result = (string[])method.Invoke(null, args); if (result != null) assetsThatShouldBeSaved = result; @@ -196,6 +197,7 @@ static void OnWillSaveAssets(string[] assets, out string[] assetsThatShouldBeSav } } + [RequiredByNativeCode] static AssetMoveResult OnWillMoveAsset(string fromPath, string toPath, string[] newPaths, string[] NewMetaPaths) { AssetMoveResult finalResult = AssetMoveResult.DidNotMove; @@ -203,34 +205,39 @@ static AssetMoveResult OnWillMoveAsset(string fromPath, string toPath, string[] foreach (var assetModificationProcessorClass in AssetModificationProcessors) { - MethodInfo method = assetModificationProcessorClass.GetMethod("OnWillMoveAsset", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); + const string methodName = "OnWillMoveAsset"; + MethodInfo method = assetModificationProcessorClass.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); if (method != null) { object[] args = { fromPath, toPath }; if (!CheckArgumentsAndReturnType(args, method, finalResult.GetType())) continue; - finalResult |= (AssetMoveResult)method.Invoke(null, args); + using (new EditorPerformanceMarker($"{assetModificationProcessorClass.Name}.{methodName}", assetModificationProcessorClass).Auto()) + finalResult |= (AssetMoveResult)method.Invoke(null, args); } } return finalResult; } + [RequiredByNativeCode] static AssetDeleteResult OnWillDeleteAsset(string assetPath, RemoveAssetOptions options) { AssetDeleteResult finalResult = AssetDeleteResult.DidNotDelete; foreach (var assetModificationProcessorClass in AssetModificationProcessors) { - MethodInfo method = assetModificationProcessorClass.GetMethod("OnWillDeleteAsset", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); + const string methodName = "OnWillDeleteAsset"; + MethodInfo method = assetModificationProcessorClass.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); if (method != null) { object[] args = { assetPath, options }; if (!CheckArgumentsAndReturnType(args, method, finalResult.GetType())) continue; - finalResult |= (AssetDeleteResult)method.Invoke(null, args); + using (new EditorPerformanceMarker($"{assetModificationProcessorClass.Name}.{methodName}", assetModificationProcessorClass).Auto()) + finalResult |= (AssetDeleteResult)method.Invoke(null, args); } } @@ -242,6 +249,7 @@ static AssetDeleteResult OnWillDeleteAsset(string assetPath, RemoveAssetOptions return finalResult; } + [RequiredByNativeCode] static void OnWillDeleteAssets(string[] assetPaths, AssetDeleteResult[] outPathDeletionResults, RemoveAssetOptions options) { for (int i = 0; i < outPathDeletionResults.Length; i++) @@ -251,7 +259,8 @@ static void OnWillDeleteAssets(string[] assetPaths, AssetDeleteResult[] outPathD List nonDeletedPathIndices = new List(); foreach (var assetModificationProcessorClass in AssetModificationProcessors) { - MethodInfo method = assetModificationProcessorClass.GetMethod("OnWillDeleteAsset", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); + const string methodName = "OnWillDeleteAsset"; + MethodInfo method = assetModificationProcessorClass.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); if (method == null) continue; @@ -261,8 +270,12 @@ static void OnWillDeleteAssets(string[] assetPaths, AssetDeleteResult[] outPathD if (!CheckArgumentsAndReturnType(args, method, typeof(AssetDeleteResult))) continue; - AssetDeleteResult callbackResult = (AssetDeleteResult)method.Invoke(null, args); - outPathDeletionResults[i] |= callbackResult; + + using (new EditorPerformanceMarker($"{assetModificationProcessorClass.Name}.{methodName}", assetModificationProcessorClass).Auto()) + { + AssetDeleteResult callbackResult = (AssetDeleteResult)method.Invoke(null, args); + outPathDeletionResults[i] |= callbackResult; + } } } @@ -301,31 +314,73 @@ static void OnWillDeleteAssets(string[] assetPaths, AssetDeleteResult[] outPathD } } - static MethodInfo[] isOpenForEditMethods = null; - static MethodInfo[] GetIsOpenForEditMethods() + static MethodInfo[] s_CanOpenForEditMethods; + static MethodInfo[] s_LegacyCanOpenForEditMethods; + static MethodInfo[] s_IsOpenForEditMethods; + static MethodInfo[] s_LegacyIsOpenForEditMethods; + + static void GetOpenForEditMethods(bool canOpenForEditVariant, out MethodInfo[] methods, out MethodInfo[] legacyMethods) { - if (isOpenForEditMethods == null) + if (canOpenForEditVariant) { - List mArray = new List(); - foreach (var assetModificationProcessorClass in AssetModificationProcessors) - { - MethodInfo method = assetModificationProcessorClass.GetMethod("IsOpenForEdit", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); - if (method != null) - { - string dummy = ""; - bool bool_dummy = false; - Type[] types = { dummy.GetType(), dummy.GetType().MakeByRefType() }; - if (!CheckArgumentTypesAndReturnType(types, method, bool_dummy.GetType())) - continue; + if (s_CanOpenForEditMethods == null) + GetOpenForEditMethods("CanOpenForEdit", out s_CanOpenForEditMethods, out s_LegacyCanOpenForEditMethods); + methods = s_CanOpenForEditMethods; + legacyMethods = s_LegacyCanOpenForEditMethods; + } + else + { + if (s_IsOpenForEditMethods == null) + GetOpenForEditMethods("IsOpenForEdit", out s_IsOpenForEditMethods, out s_LegacyIsOpenForEditMethods); + methods = s_IsOpenForEditMethods; + legacyMethods = s_LegacyIsOpenForEditMethods; + } + } - mArray.Add(method); - } + static void GetOpenForEditMethods(string name, out MethodInfo[] methods, out MethodInfo[] legacyMethods) + { + var methodList = new List(); + var legacyMethodList = new List(); + + Type[] types = { typeof(string[]), typeof(List), typeof(StatusQueryOptions) }; + Type[] legacyTypes = { typeof(string), typeof(string).MakeByRefType() }; + + foreach (var type in AssetModificationProcessors) + { + // First look for a method with a signature that accepts multiple paths "bool (string[] assetOrMetaFilePaths, List outNotEditablePaths, StatusQueryOptions statusQueryOptions)". + MethodInfo method; + try + { + method = type.GetMethod(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, types, null); + } + catch (AmbiguousMatchException) + { + Debug.LogWarning($"Ambiguous {name} methods in {type.Name}."); + continue; + } + if (method?.ReturnType == typeof(bool)) + { + methodList.Add(method); + continue; } - isOpenForEditMethods = mArray.ToArray(); + // Then look for a legacy method that accepts single path only "bool (string assetOrMetaFilePath, out string message)". + MethodInfo legacyMethod; + try + { + legacyMethod = type.GetMethod(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); + } + catch (AmbiguousMatchException) + { + Debug.LogWarning($"Ambiguous {name} methods in {type.Name}."); + continue; + } + if (legacyMethod != null && CheckArgumentTypesAndReturnType(legacyTypes, legacyMethod, typeof(bool))) + legacyMethodList.Add(legacyMethod); } - return isOpenForEditMethods; + methods = methodList.ToArray(); + legacyMethods = legacyMethodList.ToArray(); } enum Editability @@ -339,32 +394,74 @@ static Editability GetPathEditability(string assetPath) { // read-only asset locations (e.g. shared packages) are considered not editable bool rootFolder, readOnly; - bool validPath = AssetDatabase.GetAssetFolderInfo(assetPath, out rootFolder, out readOnly); + bool validPath = AssetDatabase.TryGetAssetFolderInfo(assetPath, out rootFolder, out readOnly); if (validPath && readOnly) return Editability.Never; // other paths that are not know to asset database, and not versioned, are considered always editable - if (!Provider.PathIsVersioned(assetPath)) + if (!VersionControlUtils.IsPathVersioned(assetPath)) return Editability.Always; return Editability.Maybe; } - static bool IsOpenForEditViaScriptCallbacks(string assetPath, ref string message) + static bool GetOpenForEditViaScriptCallbacks(bool canOpenForEditVariant, string[] paths, List notEditablePaths, out string message, StatusQueryOptions options) { - foreach (var method in GetIsOpenForEditMethods()) + message = string.Empty; + GetOpenForEditMethods(canOpenForEditVariant, out var methods, out var legacyMethods); + + if (methods.Length != 0) { - object[] args = {assetPath, message}; - if (!(bool)method.Invoke(null, args)) + object[] args = { paths, notEditablePaths, options }; + foreach (var method in methods) { - message = args[1] as string; - return false; + if (!(bool)method.Invoke(null, args)) + return false; } } + + if (legacyMethods.Length != 0) + { + foreach (var legacyMethod in legacyMethods) + { + var result = true; + foreach (var path in paths) + { + object[] legacyArgs = { path, null }; + if (!(bool)legacyMethod.Invoke(null, legacyArgs)) + { + result = false; + notEditablePaths.Add(path); + message = legacyArgs[1] as string; + } + } + + if (!result) + return false; + } + } + return true; } + internal static bool CanOpenForEdit(string assetPath, out string message, StatusQueryOptions statusOptions) + { + if (IsOpenForEdit(assetPath, out message, statusOptions)) + return true; + + // Status has just been updated so there's no need to force update again. + if (statusOptions == StatusQueryOptions.ForceUpdate) + statusOptions = StatusQueryOptions.UseCachedIfPossible; + + return GetOpenForEdit(true, assetPath, out message, statusOptions); + } + internal static bool IsOpenForEdit(string assetPath, out string message, StatusQueryOptions statusOptions) + { + return GetOpenForEdit(false, assetPath, out message, statusOptions); + } + + static bool GetOpenForEdit(bool canOpenForEditVariant, string assetPath, out string message, StatusQueryOptions statusOptions) { message = string.Empty; if (string.IsNullOrEmpty(assetPath)) @@ -375,22 +472,64 @@ internal static bool IsOpenForEdit(string assetPath, out string message, StatusQ return true; if (editability == Editability.Never) return false; - if (!AssetModificationHook.IsOpenForEdit(assetPath, out message, statusOptions)) + + if (!AssetModificationHook.GetOpenForEdit(canOpenForEditVariant, assetPath, out message, statusOptions)) return false; - if (!IsOpenForEditViaScriptCallbacks(assetPath, ref message)) + + return GetOpenForEditViaScriptCallbacks(canOpenForEditVariant, new[] { assetPath }, new List(), out message, statusOptions); + } + + internal static bool CanOpenForEdit(string[] assetOrMetaFilePaths, List outNotEditablePaths, StatusQueryOptions statusQueryOptions) + { + outNotEditablePaths.Clear(); + if (assetOrMetaFilePaths == null || assetOrMetaFilePaths.Length == 0) + return true; + + var queryList = GetQueryList(assetOrMetaFilePaths, outNotEditablePaths); + if (queryList.Count == 0) + return outNotEditablePaths.Count == 0; + + // Get a list of paths that are not open for edit. + var notOpenForEditPaths = new List(); + AssetModificationHook.GetOpenForEdit(false, queryList, notOpenForEditPaths, statusQueryOptions); + GetOpenForEditViaScriptCallbacks(false, queryList.ToArray(), notOpenForEditPaths, out var message, statusQueryOptions); + + if (notOpenForEditPaths.Count == 0) + return outNotEditablePaths.Count == 0; + + // Status has just been updated so there's no need to force update again. + if (statusQueryOptions == StatusQueryOptions.ForceUpdate) + statusQueryOptions = StatusQueryOptions.UseCachedIfPossible; + + // Check paths that are not open for edit. + if (!AssetModificationHook.GetOpenForEdit(true, notOpenForEditPaths, outNotEditablePaths, statusQueryOptions)) return false; - return true; + return GetOpenForEditViaScriptCallbacks(true, notOpenForEditPaths.ToArray(), outNotEditablePaths, out message, statusQueryOptions); } - internal static void IsOpenForEdit(string[] assetOrMetaFilePaths, List outNotEditablePaths, StatusQueryOptions statusQueryOptions = StatusQueryOptions.UseCachedIfPossible) + internal static bool IsOpenForEdit(string[] assetOrMetaFilePaths, List outNotEditablePaths, StatusQueryOptions statusQueryOptions) { outNotEditablePaths.Clear(); if (assetOrMetaFilePaths == null || assetOrMetaFilePaths.Length == 0) - return; + return true; + + var queryList = GetQueryList(assetOrMetaFilePaths, outNotEditablePaths); + if (queryList.Count == 0) + return outNotEditablePaths.Count == 0; + + // check with VCS + if (!AssetModificationHook.GetOpenForEdit(false, queryList, outNotEditablePaths, statusQueryOptions)) + return false; - var queryList = new List(); - foreach (var path in assetOrMetaFilePaths) + // check with possible script callbacks + return GetOpenForEditViaScriptCallbacks(false, queryList.ToArray(), outNotEditablePaths, out var message, statusQueryOptions); + } + + static List GetQueryList(string[] paths, List outNotEditablePaths) + { + var result = new List(paths.Length); + foreach (var path in paths) { if (string.IsNullOrEmpty(path)) continue; // treat empty/null paths as editable (might be under Library folders etc.) @@ -402,42 +541,74 @@ internal static void IsOpenForEdit(string[] assetOrMetaFilePaths, List o outNotEditablePaths.Add(path); continue; } - queryList.Add(path); - } - - // check with VCS - AssetModificationHook.IsOpenForEdit(queryList, outNotEditablePaths, statusQueryOptions); - - // check with possible script callbacks - var scriptCallbacks = GetIsOpenForEditMethods(); - if (scriptCallbacks != null && scriptCallbacks.Length > 0) - { - var stillEditable = assetOrMetaFilePaths.Except(outNotEditablePaths).Where(f => !string.IsNullOrEmpty(f)); - var message = string.Empty; - foreach (var path in stillEditable) - { - if (!IsOpenForEditViaScriptCallbacks(path, ref message)) - outNotEditablePaths.Add(path); - } + result.Add(path); } + return result; } + [RequiredByNativeCode] internal static void OnStatusUpdated() { WindowPending.OnStatusUpdated(); foreach (var assetModificationProcessorClass in AssetModificationProcessors) { - MethodInfo method = assetModificationProcessorClass.GetMethod("OnStatusUpdated", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); + const string methodName = "OnStatusUpdated"; + MethodInfo method = assetModificationProcessorClass.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); if (method != null) { object[] args = {}; if (!CheckArgumentsAndReturnType(args, method, typeof(void))) continue; - method.Invoke(null, args); + using (new EditorPerformanceMarker($"{assetModificationProcessorClass.Name}.{methodName}", assetModificationProcessorClass).Auto()) + method.Invoke(null, args); + } + } + } + + static MethodInfo[] s_MakeEditableMethods; + + static MethodInfo[] GetMakeEditableMethods() + { + if (s_MakeEditableMethods == null) + { + var methods = new List(); + Type[] types = { typeof(string[]), typeof(string), typeof(List) }; + foreach (var type in AssetModificationProcessors) + { + MethodInfo method; + try + { + method = type.GetMethod("MakeEditable", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); + } + catch (AmbiguousMatchException) + { + Debug.LogWarning($"Ambiguous MakeEditable methods in {type.Name}."); + continue; + } + if (method != null && CheckArgumentTypesAndReturnType(types, method, typeof(bool))) + methods.Add(method); } + s_MakeEditableMethods = methods.ToArray(); } + return s_MakeEditableMethods; + } + + internal static bool MakeEditable(string[] paths, string prompt, List outNotEditablePaths) + { + var methods = GetMakeEditableMethods(); + if (methods == null || methods.Length == 0) + return true; + + object[] args = { paths, prompt ?? string.Empty, outNotEditablePaths ?? new List() }; + foreach (var method in methods) + { + if (!(bool)method.Invoke(null, args)) + return false; + } + + return true; } } } diff --git a/Editor/Mono/AssetPipeline/AssetImportContext.bindings.cs b/Editor/Mono/AssetPipeline/AssetImportContext.bindings.cs index b9af2bcd7e..ba0ca9ed58 100644 --- a/Editor/Mono/AssetPipeline/AssetImportContext.bindings.cs +++ b/Editor/Mono/AssetPipeline/AssetImportContext.bindings.cs @@ -8,11 +8,12 @@ using UnityEngine; using UnityEngine.Bindings; using UnityEngine.Scripting; +using UnityEngine.Scripting.APIUpdating; using Debug = UnityEngine.Debug; using Object = UnityEngine.Object; +using UnityEditor.Experimental; - -namespace UnityEditor.Experimental.AssetImporters +namespace UnityEditor.AssetImporters { /// Universal structure that holds all the data relevant to importing an asset, including temporary data that needs to be shared across stages that make on any given importer's pipeline. /// @@ -21,6 +22,7 @@ namespace UnityEditor.Experimental.AssetImporters /// various parts that make up an importers pipeline. This container simply transports information from one "stage" to the other. Each stage is free to add/delete/alter the content of the container [RequiredByNativeCode] [NativeHeader("Editor/Src/AssetPipeline/AssetImportContext.h")] + [MovedFrom("UnityEditor.Experimental.AssetImporters")] public class AssetImportContext { // The bindings generator is setting the instance pointer in this field @@ -30,12 +32,13 @@ public class AssetImportContext AssetImportContext() {} public extern string assetPath { get; internal set; } + + [Obsolete("GetResultPath has been deprecated. Use GetOutputArtifactFilePath(string) instead (UnityUpgradable) -> GetOutputArtifactFilePath(*)")] + [NativeName("GetOutputArtifactFilePath")] public extern string GetResultPath(string extension); public extern BuildTarget selectedBuildTarget { get; } - extern void LogMessage(string msg, string file, int line, UnityEngine.Object obj, bool isAnError); - [NativeThrows] public extern void SetMainObject(Object obj); public extern Object mainObject { get; } @@ -67,6 +70,22 @@ public void DependsOnSourceAsset(string path) [NativeName("DependsOnSourceAsset")] private extern void DependsOnSourceAssetInternal(string path); + public void DependsOnSourceAsset(GUID guid) + { + if (guid.Empty()) + { + throw new ArgumentNullException("guid", "Cannot add dependency on empty GUID."); + } + + DependsOnSourceAssetInternalGUID(guid); + } + + [NativeName("DependsOnSourceAsset")] + private extern void DependsOnSourceAssetInternalGUID(GUID guid); + + [NativeName("GetFolderEntries")] + internal extern GUID[] GetFolderEntries(GUID folder); + internal void DependsOnImportedAsset(string path) { if (string.IsNullOrEmpty(path)) @@ -77,9 +96,67 @@ internal void DependsOnImportedAsset(string path) DependsOnImportedAssetInternal(path); } + [NativeName("GetArtifactFilePath")] + private extern string GetArtifactFilePath_Internal(string path, string fileName); + + public string GetArtifactFilePath(string path, string fileName) + { + return GetArtifactFilePath_Internal(path, fileName); + } + + public string GetArtifactFilePath(GUID guid, string fileName) + { + return GetArtifactFilePath(new ArtifactKey(guid), fileName); + } + + public extern string GetArtifactFilePath(ArtifactKey key, string fileName); + + public extern string GetOutputArtifactFilePath(string fileName); + [NativeName("DependsOnImportedAsset")] private extern void DependsOnImportedAssetInternal(string path); + public extern Object GetReferenceToAssetMainObject(string path); + + public void DependsOnArtifact(ArtifactKey key) + { + if (!key.isValid) + { + throw new ArgumentNullException("key", "Cannot add dependency on invalid ArtifactKey."); + } + + DependsOnArtifactInternal(key); + } + + [NativeName("DependsOnArtifact")] + private extern void DependsOnArtifactInternal(ArtifactKey key); + + public void DependsOnArtifact(GUID guid) + { + if (guid.Empty()) + { + throw new ArgumentNullException("guid", "Cannot add dependency on empty GUID."); + } + + DependsOnArtifactInternalGUID(guid); + } + + [NativeName("DependsOnArtifact")] + private extern void DependsOnArtifactInternalGUID(GUID guid); + + public void DependsOnArtifact(string path) + { + if (string.IsNullOrEmpty(path)) + { + throw new ArgumentNullException("path", "Cannot add dependency on invalid path."); + } + + DependsOnArtifactInternalPath(path); + } + + [NativeName("DependsOnArtifact")] + private extern void DependsOnArtifactInternalPath(string path); + public void DependsOnCustomDependency(string dependency) { if (string.IsNullOrEmpty(dependency)) @@ -87,42 +164,49 @@ public void DependsOnCustomDependency(string dependency) throw new ArgumentNullException("dependency", "Cannot add custom dependency on an empty custom dependency."); } + if (string.CompareOrdinal(dependency,"srp/default-shader") == 0 && assetPath.EndsWith(".shader", StringComparison.OrdinalIgnoreCase)) + { + throw new Exception($"A shader '{assetPath}' cannot depend on the 'srp/default-shader' custom dependency because this operation is unsupported."); + } + DependsOnCustomDependencyInternal(dependency); } [NativeName("DependsOnCustomDependency")] private extern void DependsOnCustomDependencyInternal(string path); + extern void AddImportLog(string msg, string file, int line, ImportLogFlags flags, UnityEngine.Object obj); + + void AddImportLog(string msg, ImportLogFlags flags, UnityEngine.Object obj) + { + var st = new StackTrace(2, true); + var sf = st.GetFrame(0); + AddImportLog(msg, sf.GetFileName(), sf.GetFileLineNumber(), flags, obj); + } + public void LogImportError(string msg, UnityEngine.Object obj = null) { - AddToLog(msg, true, obj); + AddImportLog(msg, ImportLogFlags.Error, obj); } internal void LogImportError(string msg, string file, int line, UnityEngine.Object obj = null) { - AddToLog(msg, file, line, true, obj); + AddImportLog(msg, file, line, ImportLogFlags.Error, obj); } public void LogImportWarning(string msg, UnityEngine.Object obj = null) { - AddToLog(msg, false, obj); + AddImportLog(msg, ImportLogFlags.Warning, obj); } internal void LogImportWarning(string msg, string file, int line, UnityEngine.Object obj = null) { - AddToLog(msg, file, line, false, obj); - } - - void AddToLog(string msg, bool isAnError, UnityEngine.Object obj) - { - var st = new StackTrace(2, true); - var sf = st.GetFrame(0); - AddToLog(msg, sf.GetFileName(), sf.GetFileLineNumber(), isAnError, obj); + AddImportLog(msg, file, line, ImportLogFlags.Warning, obj); } - void AddToLog(string msg, string file, int line, bool isAnError, UnityEngine.Object obj) + internal static class BindingsMarshaller { - LogMessage(msg, file, line, obj, isAnError); + public static IntPtr ConvertToNative(AssetImportContext ctx) => ctx.m_Self; } } } diff --git a/Editor/Mono/AssetPipeline/AssetImporter.bindings.cs b/Editor/Mono/AssetPipeline/AssetImporter.bindings.cs index c53e7cd3d1..f2846c569b 100644 --- a/Editor/Mono/AssetPipeline/AssetImporter.bindings.cs +++ b/Editor/Mono/AssetPipeline/AssetImporter.bindings.cs @@ -3,11 +3,13 @@ // https://unity3d.com/legal/licenses/Unity_Reference_Only_License using System; +using System.Linq; using System.Collections.Generic; using UnityEngine; using Object = UnityEngine.Object; using UnityEngine.Bindings; using UnityEngine.Scripting; +using UnityEditor.AssetImporters; namespace UnityEditor { @@ -91,9 +93,23 @@ public extern string assetBundleVariant set; } + public static ImportLog GetImportLog(string path) + { + return GetImportLog(AssetDatabase.GUIDFromAssetPath(path)); + } + + [FreeFunction("AssetImporter::GetImportLog")] + internal static extern ImportLog GetImportLog(GUID guid); + + [FreeFunction("AssetImporter::GetImportLogEntriesCount")] + internal static extern bool GetImportLogEntriesCount(GUID guid, out int nbErrors, out int nbWarnings); + [NativeName("SetAssetBundleName")] extern public void SetAssetBundleNameAndVariant(string assetBundleName, string assetBundleVariant); + [NativeMethod("SetThumbnailFromTexture2D")] + extern internal void SetThumbnailFromTexture2D(Texture2D image, int instanceID); + [FreeFunction("FindAssetImporterAtAssetPath")] extern public static AssetImporter GetAtPath(string path); @@ -145,5 +161,15 @@ public Dictionary GetExternalObjectMap() public extern bool SupportsRemappedAssetType(Type type); internal extern double GetImportStartTime(); + + internal AssetPostprocessor.PostprocessorInfo[] GetDynamicPostprocessors() + { + return AssetPostprocessingInternal.GetSortedDynamicPostprocessorsForAsset(assetPath).ToArray(); + } + + internal static AssetPostprocessor.PostprocessorInfo[] GetStaticPostprocessors(Type importerType) + { + return AssetPostprocessingInternal.GetSortedStaticPostprocessorTypes(importerType).ToArray(); + } } } diff --git a/Editor/Mono/AssetPipeline/BumpMapSettings.bindings.cs b/Editor/Mono/AssetPipeline/BumpMapSettings.bindings.cs index ac5f9229f1..dd9c4c80b7 100644 --- a/Editor/Mono/AssetPipeline/BumpMapSettings.bindings.cs +++ b/Editor/Mono/AssetPipeline/BumpMapSettings.bindings.cs @@ -13,7 +13,7 @@ internal class BumpMapSettings { public static extern bool silentMode { get; set; } - public static extern void PerformBumpMapCheck(Material material); + public static extern void PerformBumpMapCheck([NotNull] Material material); } public static class MaterialEditorExtensions diff --git a/Editor/Mono/AssetPipeline/CameraDescription.bindings.cs b/Editor/Mono/AssetPipeline/CameraDescription.bindings.cs new file mode 100644 index 0000000000..d4deb91590 --- /dev/null +++ b/Editor/Mono/AssetPipeline/CameraDescription.bindings.cs @@ -0,0 +1,78 @@ +// 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; + +namespace UnityEditor.AssetImporters +{ + [RequiredByNativeCode] + [NativeHeader("Editor/Src/AssetPipeline/ModelImporting/CameraDescription.h")] + public class CameraDescription : IDisposable + { + internal IntPtr m_Ptr; + + public CameraDescription() + { + m_Ptr = Internal_Create(); + } + + ~CameraDescription() + { + Destroy(); + } + + public void Dispose() + { + Destroy(); + GC.SuppressFinalize(this); + } + + void Destroy() + { + if (m_Ptr != IntPtr.Zero) + { + Internal_Destroy(m_Ptr); + m_Ptr = IntPtr.Zero; + } + } + + public bool TryGetProperty(string propertyName, out float value) => TryGetFloatProperty(propertyName, out value); + public bool TryGetProperty(string propertyName, out Vector4 value) => TryGetVector4Property(propertyName, out value); + public bool TryGetProperty(string propertyName, out string value) => TryGetStringProperty(propertyName, out value); + public bool TryGetProperty(string propertyName, out int value) => TryGetIntProperty(propertyName, out value); + + public extern void GetVector4PropertyNames(List names); + public extern void GetFloatPropertyNames(List names); + public extern void GetStringPropertyNames(List names); + public extern void GetIntPropertyNames(List names); + + extern bool TryGetVector4Property(string propertyName, out Vector4 value); + extern bool TryGetFloatProperty(string propertyName, out float value); + extern bool TryGetStringProperty(string propertyName, out string value); + extern bool TryGetIntProperty(string propertyName, out int value); + + public bool TryGetAnimationCurve(string clipName, string propertyName, out AnimationCurve value) + { + value = TryGetAnimationCurve(clipName, propertyName); + return value != null; + } + + public extern bool HasAnimationCurveInClip(string clipName, string propertyName); + public extern bool HasAnimationCurve(string propertyName); + extern AnimationCurve TryGetAnimationCurve(string clipName, string propertyName); + + static extern IntPtr Internal_Create(); + static extern void Internal_Destroy(IntPtr ptr); + + internal static class BindingsMarshaller + { + public static IntPtr ConvertToNative(CameraDescription desc) => desc.m_Ptr; + } + } +} diff --git a/Editor/Mono/AssetPipeline/ComputeShaderImporter.bindings.cs b/Editor/Mono/AssetPipeline/ComputeShaderImporter.bindings.cs index 80f55ba0be..649360a5a0 100644 --- a/Editor/Mono/AssetPipeline/ComputeShaderImporter.bindings.cs +++ b/Editor/Mono/AssetPipeline/ComputeShaderImporter.bindings.cs @@ -10,6 +10,6 @@ namespace UnityEditor [NativeHeader("Editor/Src/AssetPipeline/ComputeShaderImporter.h")] public sealed partial class ComputeShaderImporter : AssetImporter { - [NativeProperty("PreprocessorOverride")] extern public PreprocessorOverride preprocessorOverride { get; set; } + public PreprocessorOverride preprocessorOverride { get { return PreprocessorOverride.UseProjectSettings; } set {} } } } diff --git a/Editor/Mono/AssetPipeline/IHVImageFormatImporter.bindings.cs b/Editor/Mono/AssetPipeline/IHVImageFormatImporter.bindings.cs index 76a0e47420..7b2efea6b6 100644 --- a/Editor/Mono/AssetPipeline/IHVImageFormatImporter.bindings.cs +++ b/Editor/Mono/AssetPipeline/IHVImageFormatImporter.bindings.cs @@ -74,5 +74,17 @@ public extern int streamingMipmapsPriority get; set; } + + public extern bool ignoreMipmapLimit + { + get; + set; + } + + public extern string mipmapLimitGroupName + { + get; + set; + } } } diff --git a/Editor/Mono/AssetPipeline/ImportLog.bindings.cs b/Editor/Mono/AssetPipeline/ImportLog.bindings.cs new file mode 100644 index 0000000000..f717d18a24 --- /dev/null +++ b/Editor/Mono/AssetPipeline/ImportLog.bindings.cs @@ -0,0 +1,60 @@ +// 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 Object = UnityEngine.Object; + +namespace UnityEditor.AssetImporters +{ + // Subset of C++ LogMessageFlags in LogAssert.h + [Flags] + public enum ImportLogFlags + { + None = 0, // kNoLogMessageFlags + Error = 1 << 6, // kAssetImportError + Warning = 1 << 7 // kAssetImportWarning + }; + + [NativeHeader("Editor/Src/AssetPipeline/ImportLog.h")] + [NativeHeader("Editor/Src/AssetPipeline/ImportLog.bindings.h")] + [ExcludeFromObjectFactory] + public sealed class ImportLog : Object + { + internal struct Filters + { + public const string SearchToken = "i"; + public const string AllIssuesStr = "all"; + public const string ErrorsStr = "errors"; + public const string WarningsStr = "warnings"; + } + + [NativeType(CodegenOptions.Custom, "MonoImportLogEntry")] + public struct ImportLogEntry + { + public string message; + public ImportLogFlags flags; + public int line; + public string file; + + public UnityEngine.Object context + { + get => Object.FindObjectFromInstanceID(instanceID); + set => instanceID = value.GetInstanceID(); + } + + internal int instanceID; + }; + + public extern ImportLogEntry[] logEntries + { + [NativeMethod("GetLogEntries")] + get; + } + + [NativeMethod("PrintToConsole")] + internal extern void PrintToConsole(); + } +} diff --git a/Editor/Mono/AssetPipeline/LightDescription.bindings.cs b/Editor/Mono/AssetPipeline/LightDescription.bindings.cs new file mode 100644 index 0000000000..837f137eae --- /dev/null +++ b/Editor/Mono/AssetPipeline/LightDescription.bindings.cs @@ -0,0 +1,78 @@ +// 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; + +namespace UnityEditor.AssetImporters +{ + [RequiredByNativeCode] + [NativeHeader("Editor/Src/AssetPipeline/ModelImporting/LightDescription.h")] + public class LightDescription : IDisposable + { + internal IntPtr m_Ptr; + + public LightDescription() + { + m_Ptr = Internal_Create(); + } + + ~LightDescription() + { + Destroy(); + } + + public void Dispose() + { + Destroy(); + GC.SuppressFinalize(this); + } + + void Destroy() + { + if (m_Ptr != IntPtr.Zero) + { + Internal_Destroy(m_Ptr); + m_Ptr = IntPtr.Zero; + } + } + + public bool TryGetProperty(string propertyName, out float value) => TryGetFloatProperty(propertyName, out value); + public bool TryGetProperty(string propertyName, out Vector4 value) => TryGetVector4Property(propertyName, out value); + public bool TryGetProperty(string propertyName, out string value) => TryGetStringProperty(propertyName, out value); + public bool TryGetProperty(string propertyName, out int value) => TryGetIntProperty(propertyName, out value); + + public extern void GetVector4PropertyNames(List names); + public extern void GetFloatPropertyNames(List names); + public extern void GetStringPropertyNames(List names); + public extern void GetIntPropertyNames(List names); + + extern bool TryGetVector4Property(string propertyName, out Vector4 value); + extern bool TryGetFloatProperty(string propertyName, out float value); + extern bool TryGetStringProperty(string propertyName, out string value); + extern bool TryGetIntProperty(string propertyName, out int value); + + public bool TryGetAnimationCurve(string clipName, string propertyName, out AnimationCurve value) + { + value = TryGetAnimationCurve(clipName, propertyName); + return value != null; + } + + public extern bool HasAnimationCurveInClip(string clipName, string propertyName); + public extern bool HasAnimationCurve(string propertyName); + extern AnimationCurve TryGetAnimationCurve(string clipName, string propertyName); + + static extern IntPtr Internal_Create(); + static extern void Internal_Destroy(IntPtr ptr); + + internal static class BindingsMarshaller + { + public static IntPtr ConvertToNative(LightDescription desc) => desc.m_Ptr; + } + } +} diff --git a/Editor/Mono/AssetPipeline/LocalCacheServer.cs b/Editor/Mono/AssetPipeline/LocalCacheServer.cs index 8dababbb4d..e4a6ea2d66 100644 --- a/Editor/Mono/AssetPipeline/LocalCacheServer.cs +++ b/Editor/Mono/AssetPipeline/LocalCacheServer.cs @@ -2,27 +2,13 @@ // Copyright (c) Unity Technologies. For terms of use, see // https://unity3d.com/legal/licenses/Unity_Reference_Only_License -using System.Diagnostics; using System.IO; -using System; -using System.Net; -using System.Net.Sockets; -using UnityEditor.Scripting; using UnityEditor.Utils; -using UnityEngine; -using UnityEngine.Scripting; namespace UnityEditor { - internal class LocalCacheServer : ScriptableSingleton + internal class LocalCacheServer { - [SerializeField] public string path; - [SerializeField] public int port; - [SerializeField] public ulong size; - [SerializeField] public int pid = -1; - [SerializeField] public string time; - - public const string SizeKey = "LocalCacheServerSize"; public const string PathKey = "LocalCacheServerPath"; public const string CustomPathKey = "LocalCacheServerCustomPath"; @@ -36,195 +22,21 @@ public static string GetCacheLocation() return result; } - public static void CreateCacheDirectory() - { - string cacheDirectoryPath = GetCacheLocation(); - if (Directory.Exists(cacheDirectoryPath) == false) - Directory.CreateDirectory(cacheDirectoryPath); - } - - void Create(int _port, ulong _size) - { - var nodeExecutable = Paths.Combine(EditorApplication.applicationContentsPath, "Tools", "nodejs"); - if (Application.platform == RuntimePlatform.WindowsEditor) - nodeExecutable = Paths.Combine(nodeExecutable, "node.exe"); - else - nodeExecutable = Paths.Combine(nodeExecutable, "bin", "node"); - - CreateCacheDirectory(); - path = GetCacheLocation(); - var cacheServerJs = Paths.Combine(EditorApplication.applicationContentsPath, "Tools", "CacheServer", "main.js"); - var processStartInfo = new ProcessStartInfo(nodeExecutable) - { - Arguments = "\"" + cacheServerJs + "\"" - + " --port " + _port - + " --path \"" + path - + "\" --nolegacy" - + " --monitor-parent-process " + Process.GetCurrentProcess().Id - // node.js has issues running on windows with stdout not redirected. - // so we silence logging to avoid that. And also to avoid CacheServer - // spamming the editor logs on OS X. - + " --silent" - + " --size " + _size, - UseShellExecute = false, - CreateNoWindow = true - }; - - var p = new Process(); - p.StartInfo = processStartInfo; - p.Start(); - - port = _port; - pid = p.Id; - size = _size; - time = p.StartTime.ToString(); - Save(true); - } - - public static int GetRandomUnusedPort() - { - var listener = new TcpListener(IPAddress.Any, 0); - listener.Start(); - var port = ((IPEndPoint)listener.LocalEndpoint).Port; - listener.Stop(); - return port; - } - - public static bool PingHost(string host, int port, int timeout) - { - try - { - using (var client = new TcpClient()) - { - var result = client.BeginConnect(host, port, null, null); - result.AsyncWaitHandle.WaitOne(TimeSpan.FromMilliseconds(timeout)); - return client.Connected; - } - } - catch - { - return false; - } - } - - public static bool WaitForServerToComeAlive(int port) - { - DateTime start = DateTime.Now; - DateTime maximum = start.AddSeconds(5); - while (DateTime.Now < maximum) - { - if (PingHost("localhost", port, 10)) - { - System.Console.WriteLine("Server Came alive after {0} ms", (DateTime.Now - start).TotalMilliseconds); - return true; - } - } - return false; - } - - public static void Kill() - { - if (instance.pid == -1) - return; - - Process p = null; - try - { - p = Process.GetProcessById(instance.pid); - p.Kill(); - instance.pid = -1; - } - catch - { - // if we could not get a process, there is non alive. continue. - } - } - - public static void CreateIfNeeded() + public static void Setup() { - // See if we can get an existing process with the PID we remembered. - Process p = null; - try - { - p = Process.GetProcessById(instance.pid); - } - catch - { - // if we could not get a process, there is non alive. continue. - } + var mode = (AssetPipelinePreferences.CacheServerMode)EditorPrefs.GetInt("CacheServerMode"); - ulong size = (ulong)EditorPrefs.GetInt(SizeKey, 10) * 1024 * 1024 * 1024; - // Check if this process is really the one we used (and not another one reusing the PID). - if (p != null && p.StartTime.ToString() == instance.time) + if (mode == AssetPipelinePreferences.CacheServerMode.Local) { - if (instance.size == size && instance.path == GetCacheLocation()) - { - // We have a server running for this setup, which we can reuse, but make sure that the cache server directory exists in case it was cleaned earlier - CreateCacheDirectory(); - return; - } - else - { - // This server does not match our setup. Kill it, so we can start a new one. - Kill(); - } + EditorGUILayout.HelpBox("Local CacheServer is no longer supported", MessageType.Info, true); } - - // No existing server we can use. Start a new one. - instance.Create(GetRandomUnusedPort(), size); - WaitForServerToComeAlive(instance.port); - } - - public static void Setup() - { - var mode = (CacheServerPreferences.CacheServerMode)EditorPrefs.GetInt("CacheServerMode"); - - if (mode == CacheServerPreferences.CacheServerMode.Local) - CreateIfNeeded(); - else - Kill(); - } - - [UsedByNativeCode] - public static int GetLocalCacheServerPort() - { - Setup(); - return instance.port; } public static void Clear() { - Kill(); string cacheDirectoryPath = GetCacheLocation(); if (Directory.Exists(cacheDirectoryPath)) Directory.Delete(cacheDirectoryPath, true); } - - public static bool CheckCacheLocationExists() - { - return Directory.Exists(GetCacheLocation()); - } - - public static bool CheckValidCacheLocation(string path) - { - if (Directory.Exists(path)) - { - var contents = Directory.GetFileSystemEntries(path); - foreach (var dir in contents) - { - var name = Path.GetFileName(dir).ToLower(); - if (name.Length == 2) - continue; - if (name == "temp") - continue; - if (name == ".ds_store") - continue; - if (name == "desktop.ini") - continue; - return false; - } - } - return true; - } } } diff --git a/Editor/Mono/AssetPipeline/MaterialDescription.bindings.cs b/Editor/Mono/AssetPipeline/MaterialDescription.bindings.cs index d069614cb1..6a6c519ccb 100644 --- a/Editor/Mono/AssetPipeline/MaterialDescription.bindings.cs +++ b/Editor/Mono/AssetPipeline/MaterialDescription.bindings.cs @@ -4,7 +4,6 @@ using System; using System.Collections.Generic; -using System.Runtime.InteropServices; using UnityEngine; using UnityEngine.Bindings; using UnityEngine.Scripting; @@ -82,5 +81,10 @@ public bool TryGetAnimationCurve(string clipName, string propertyName, out Anima static extern IntPtr Internal_Create(); static extern void Internal_Destroy(IntPtr ptr); + + internal static class BindingsMarshaller + { + public static IntPtr ConvertToNative(MaterialDescription desc) => desc.m_Ptr; + } } } diff --git a/Editor/Mono/AssetPipeline/ShaderImporter.bindings.cs b/Editor/Mono/AssetPipeline/ShaderImporter.bindings.cs index 48452edb4a..6f93f51e47 100644 --- a/Editor/Mono/AssetPipeline/ShaderImporter.bindings.cs +++ b/Editor/Mono/AssetPipeline/ShaderImporter.bindings.cs @@ -20,6 +20,6 @@ public sealed partial class ShaderImporter : AssetImporter public extern Texture GetNonModifiableTexture(string name); - [NativeProperty("PreprocessorOverride")] extern public PreprocessorOverride preprocessorOverride { get; set; } + public PreprocessorOverride preprocessorOverride { get { return PreprocessorOverride.UseProjectSettings; } set {} } } } diff --git a/Editor/Mono/AssetPipeline/ShaderIncludeImporter.bindings.cs b/Editor/Mono/AssetPipeline/ShaderIncludeImporter.bindings.cs new file mode 100644 index 0000000000..28eedf6a2c --- /dev/null +++ b/Editor/Mono/AssetPipeline/ShaderIncludeImporter.bindings.cs @@ -0,0 +1,19 @@ +// 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; + +namespace UnityEditor +{ + [NativeHeader("Editor/Src/AssetPipeline/ShaderIncludeImporter.h")] + internal sealed partial class ShaderIncludeImporter : AssetImporter + { + } + + [NativeHeader("Editor/Src/Shaders/ShaderInclude.h")] + public sealed partial class ShaderInclude : TextAsset + { + } +} diff --git a/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9Importer.cs b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9Importer.cs new file mode 100644 index 0000000000..eec1335d57 --- /dev/null +++ b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9Importer.cs @@ -0,0 +1,1607 @@ +// 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.IO; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Rendering; + +using UnityEditor.AssetImporters; + +using STVertex = UnityEditor.SpeedTree.Importer.Vertex; +using Material = UnityEngine.Material; +using Color = UnityEngine.Color; + +using static UnityEditor.SpeedTree.Importer.SpeedTreeImporterCommon; +using static UnityEditor.SpeedTree.Importer.WindConfigSDK; +using static UnityEditor.SpeedTree.Importer.SpeedTree9Importer; +using static UnityEditor.SpeedTree.Importer.SpeedTree9Reader; + +namespace UnityEditor.SpeedTree.Importer +{ + // [2024-09-27] version: 3 + // Fixed code that would lead to m_LODCount vs m_PerLODSettings.arraySize mismatching in GUI + [ScriptedImporter(version: 3, ext: "st9", AllowCaching = true)] + public class SpeedTree9Importer : ScriptedImporter + { + const int SPEEDTREE_9_WIND_VERSION = 1; + const int SPEEDTREE_9_MATERIAL_VERSION = 1; + + internal static class ImporterSettings + { + internal const string kGameObjectName = "SpeedTree"; + internal const string kLegacyShaderName = "Nature/SpeedTree9"; + internal const string kWindAssetName = "SpeedTreeWind"; + internal const string kSRPDependencyName = "SpeedTree9Importer_DefaultShader"; + internal const string kMaterialSettingsDependencyname = "SpeedTree9Importer_MaterialSettings"; + internal const string kIconName = "UnityEditor/SpeedTree9Importer Icon"; + } + + private static class Styles + { + internal static readonly Texture2D kIcon = EditorGUIUtility.FindTexture(ImporterSettings.kIconName); + } + + private struct STMeshGeometry + { + public Vector3[] vertices; + public Vector3[] normals; + public Vector4[] tangents; + public Color32[] colors32; + public Vector4[][] uvs; + public int lodIndex; + + public STMeshGeometry(int vertexCount, int UVCount, int indexLod) + { + vertices = new Vector3[vertexCount]; + normals = new Vector3[vertexCount]; + tangents = new Vector4[vertexCount]; + colors32 = new Color32[vertexCount]; + uvs = new Vector4[UVCount][]; + lodIndex = indexLod; + + for (int i = 0; i < UVCount; ++i) + { + uvs[i] = new Vector4[vertexCount]; + } + } + } + + [SerializeField] + internal MeshSettings m_MeshSettings = new MeshSettings(); + + [SerializeField] + internal MaterialSettings m_MaterialSettings = new MaterialSettings(); + + [SerializeField] + internal LightingSettings m_LightingSettings = new LightingSettings(); + + [SerializeField] + internal AdditionalSettings m_AdditionalSettings = new AdditionalSettings(); + + [SerializeField] + internal LODSettings m_LODSettings = new LODSettings(); + + [SerializeField] + internal List m_PerLODSettings = new List(); + + [SerializeField] + internal WindSettings m_WindSettings = new WindSettings(); + + [SerializeField] + internal int m_MaterialVersion = SPEEDTREE_9_MATERIAL_VERSION; + + /// + /// Necessary to set default HDRP properties and materials upgrade. + /// + /// The main object used by the importer, containing the data. + public delegate void OnAssetPostProcess(GameObject mainObject); + + /// + /// Exposes the Diffuse Profile property in the importer inspector with compatible render pipelines. + /// + /// The serialized property of the diffusion profile asset. + /// The serialized property of the diffusion profile hash. + /// + /// Necessary to expose the Diffuse Profile property in the inspector, since the importer is not + /// aware of HDRP as it's a package. This property is highly used by artists, so exposing it is a big win. + /// + public delegate void OnCustomEditorSettings(ref SerializedProperty diffusionProfileAsset, ref SerializedProperty diffusionProfileHash); + + [SerializeField] + internal SpeedTreeImporterOutputData m_OutputImporterData; + + private static ulong s_DefaultShaderHash; + private static readonly TimeSpan k_CheckDependencyFrequency = TimeSpan.FromSeconds(5); + private static DateTime s_LastCheck; + + // Cache main objects, created during import process. + private AssetImportContext m_Context; + private SpeedTree9Reader m_Tree; + private Shader m_Shader; + private SpeedTreeWindAsset m_WindAsset; + + // Values cached at the begining of the import process. + private bool m_HasFacingData; + private bool m_HasBranch2Data; + private bool m_LastLodIsBillboard; + private bool m_WindEnabled; + private uint m_LODCount; + private uint m_CollisionObjectsCount; + private string m_PathFromDirectory; + + internal bool MaterialsShouldBeRegenerated => m_MaterialVersion != SPEEDTREE_9_MATERIAL_VERSION; + + public override bool SupportsRemappedAssetType(Type type) + { + return true; + } + + public override void OnImportAsset(AssetImportContext ctx) + { + m_Context = ctx; + m_Tree = new SpeedTree9Reader(); + + FileStatus status = m_Tree.Initialize(ctx.assetPath); + if (status != FileStatus.Valid) + { + ctx.LogImportError($"Error while initializing the SpeedTree9 reader: {status}."); + return; + } + + m_Tree.ReadContent(); + + CacheTreeImporterValues(ctx.assetPath); + + ctx.DependsOnCustomDependency(ImporterSettings.kSRPDependencyName); + + if (!TryGetShaderForCurrentRenderPipeline(out m_Shader)) + { + ctx.LogImportError("SpeedTree9 shader is invalid, cannot create Materials for this SpeedTree asset."); + return; + } + + m_OutputImporterData = SpeedTreeImporterOutputData.Create(); + m_OutputImporterData.hasBillboard = m_LastLodIsBillboard; + + CalculateScaleFactorFromUnit(); + + if (m_WindEnabled) + { + m_OutputImporterData.m_WindConfig = CopySpeedTree9WindConfig(m_Tree.Wind, m_MeshSettings.scaleFactor, m_Tree.Bounds); + SetWindParameters(ref m_OutputImporterData.m_WindConfig); + + m_WindAsset = new SpeedTreeWindAsset(SPEEDTREE_9_WIND_VERSION, m_OutputImporterData.m_WindConfig) + { + name = ImporterSettings.kWindAssetName, + }; + } + + GameObject mainObject = new GameObject(ImporterSettings.kGameObjectName); + + if (m_AdditionalSettings.generateRigidbody) + { + CreateAndAddRigidBodyToAsset(mainObject); + } + + ctx.AddObjectToAsset(ImporterSettings.kGameObjectName, mainObject); + ctx.SetMainObject(mainObject); + + SetThumbnailFromTexture2D(Styles.kIcon, mainObject.GetInstanceID()); + + m_OutputImporterData.mainObject = mainObject; + + CalculateBillboardAndPerLODSettings(); + + CreateMeshAndMaterials(); + + CreateAssetIdentifiersAndAddMaterialsToContext(); + + if (m_AdditionalSettings.generateColliders && m_CollisionObjectsCount > 0) + { + CreateAndAddCollidersToAsset(); + } + + if (m_WindEnabled) + { + ctx.AddObjectToAsset(ImporterSettings.kWindAssetName, m_WindAsset); + } + + ctx.AddObjectToAsset(m_OutputImporterData.name, m_OutputImporterData); + ctx.DependsOnCustomDependency(ImporterSettings.kMaterialSettingsDependencyname); + + AddDependencyOnExtractedMaterials(); + + TriggerAllCallbacks(); + } + + private void TriggerAllCallbacks() + { + var allMethods = AttributeHelper.GetMethodsWithAttribute().methodsWithAttributes; + foreach (var method in allMethods) + { + var callback = Delegate.CreateDelegate(typeof(OnAssetPostProcess), method.info) as OnAssetPostProcess; + callback?.Invoke(m_OutputImporterData.mainObject); + } + } + + private void CacheTreeImporterValues(string assetPath) + { + // Variables used a lot are cached, since accessing any Reader array has a non-negligeable cost. + m_LODCount = (uint)m_Tree.Lod.Length; + if(m_LODCount > LODGroupGUI.kLODColors.Length) + { + Debug.LogWarningFormat("Number of LOD meshes in asset ({0}) is larger than the maximum number supported by Unity GUI ({1})." + + "\nImporting only the first {1} LOD meshes." + , m_LODCount, LODGroupGUI.kLODColors.Length); + + // LODGroup GUI won't draw if we're above this limit, so we prevent future assertions here. + m_LODCount = (uint)LODGroupGUI.kLODColors.Length; + } + + m_HasFacingData = TreeHasFacingData(); + m_HasBranch2Data = m_Tree.Wind.DoBranch2; + m_LastLodIsBillboard = m_Tree.BillboardInfo.LastLodIsBillboard; + m_CollisionObjectsCount = (uint)m_Tree.CollisionObjects.Length; + + WindConfigSDK windCfg = m_Tree.Wind; + m_WindEnabled = (windCfg.DoShared || windCfg.DoBranch1 || windCfg.DoBranch2 || windCfg.DoRipple) + && m_WindSettings.enableWind; + + m_PathFromDirectory = Path.GetDirectoryName(assetPath) + "/"; + } + + internal void RegenerateMaterials() + { + m_OutputImporterData = AssetDatabase.LoadAssetAtPath(assetPath); + + if (m_OutputImporterData.hasEmbeddedMaterials) + { + // TODO: Verify if we could only generate the embedded materials + // instead of reimporting entirely the asset. + SaveAndReimport(); + return; + } + + try + { + AssetDatabase.StartAssetEditing(); + + RegenerateAndPopulateExternalMaterials(this.assetPath); + + TriggerAllCallbacks(); + } + finally + { + AssetDatabase.StopAssetEditing(); + } + } + + [InitializeOnLoadMethod] + static void InitializeEditorCallback() + { + EditorApplication.update += DirtyCustomDependencies; + s_DefaultShaderHash = ComputeDefaultShaderHash(); + AssetDatabase.RegisterCustomDependency(ImporterSettings.kSRPDependencyName, new Hash128(s_DefaultShaderHash, 0)); + } + + + static ulong CombineHash(ulong h1, ulong h2) + { + unchecked + { + return h1 ^ h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2); // Similar to c++ boost::hash_combine + } + } + + static ulong ComputeDefaultShaderHash() + { + ulong newDefaultShaderHash = 0UL; + if (GraphicsSettings.GetDefaultShader(DefaultShaderType.SpeedTree9) == null) + { + newDefaultShaderHash = 0; + } + else + { + if (AssetDatabase.TryGetGUIDAndLocalFileIdentifier(GraphicsSettings.GetDefaultShader(DefaultShaderType.SpeedTree9), out var guid, + out long fileId)) + { + newDefaultShaderHash = CombineHash((ulong)guid.GetHashCode(), (ulong)fileId); + } + } + + return newDefaultShaderHash; + } + + static void DirtyCustomDependencies() + { + DateTime now = DateTime.UtcNow; + if (Application.isPlaying || ((now - s_LastCheck) < k_CheckDependencyFrequency)) + { + return; + } + + s_LastCheck = now; + + ulong newDefaultShaderHash = ComputeDefaultShaderHash(); + if (s_DefaultShaderHash != newDefaultShaderHash) + { + s_DefaultShaderHash = newDefaultShaderHash; + AssetDatabase.RegisterCustomDependency(ImporterSettings.kSRPDependencyName, new Hash128(s_DefaultShaderHash, 0)); + AssetDatabase.Refresh(); + } + } + + #region Mesh Geometry & Renderers + private Mesh CreateMeshAndGeometry(Lod lod, int lodIndex) + { + bool isBillboard = m_LastLodIsBillboard && (lodIndex == (m_LODCount - 1)); + int vertexCount = (int)lod.Vertices.Length; + int numUVs = CalculateNumUVs(isBillboard); + + STMeshGeometry sTMeshGeometry = new STMeshGeometry(vertexCount, numUVs, lodIndex); + + CalculateMeshGeometry(sTMeshGeometry, lod, isBillboard); + + Mesh mesh = new Mesh() + { + name = "LOD" + sTMeshGeometry.lodIndex + "_Mesh", + indexFormat = (sTMeshGeometry.vertices.Length > 65535) ? IndexFormat.UInt32 : IndexFormat.UInt16, + subMeshCount = (int)lod.DrawCalls.Length, + vertices = sTMeshGeometry.vertices, + normals = sTMeshGeometry.normals, + tangents = sTMeshGeometry.tangents, + colors32 = sTMeshGeometry.colors32 + }; + + mesh.SetUVs(0, sTMeshGeometry.uvs[0]); + mesh.SetUVs(1, sTMeshGeometry.uvs[1]); + if (!isBillboard) + { + // SpeedTree shader expects certain UV2 & UV3 values for leaf facing & wind. + // if we don't claim them here now, tree rendering may break when Unity + // uses UV2 & UV3 and the shader finds unexpected values. + mesh.SetUVs(2, sTMeshGeometry.uvs[2]); // Branch2Pos, Branch2Dir, Branch2Weight, + mesh.SetUVs(3, sTMeshGeometry.uvs[3]); // 2/3 Anchor XYZ, FacingFlag + } + + return mesh; + } + + private void SetMeshIndices(Mesh mesh, Lod lod, DrawCall draw, int drawIndex) + { + int[] indices = new int[draw.IndexCount]; + + uint[] lodIndices = lod.Indices; + + for (int index = 0; index < draw.IndexCount; ++index) + { + indices[index] = unchecked((int)lodIndices[unchecked((int)(draw.IndexStart + index))]); + } + mesh.SetIndices(indices, MeshTopology.Triangles, drawIndex, true); + } + + private void CreateMeshAndLODObjects(Mesh mesh, int lodIndex, ref LOD[] lods) + { + mesh.RecalculateUVDistributionMetrics(); + GameObject lodObject = new GameObject("LOD" + lodIndex); + lodObject.transform.parent = m_OutputImporterData.mainObject.transform; + + MeshFilter meshFilter = lodObject.AddComponent(); + meshFilter.mesh = mesh; + + MeshRenderer renderer = lodObject.AddComponent(); + { + lods[lodIndex] = new LOD(m_PerLODSettings[lodIndex].height, new Renderer[] { renderer }); + + SetMeshRendererSettings(renderer, lodIndex); + } + + AddTreeComponentToLODObject(lodObject); + + m_Context.AddObjectToAsset(mesh.name, mesh); + } + + private void CalculateMeshGeometry(STMeshGeometry sTMeshGeometry, Lod lod, bool isBillboard) + { + STVertex[] vertices = lod.Vertices; + + for (int i = 0; i < sTMeshGeometry.vertices.Length; ++i) + { + STVertex vertex = vertices[i]; + + sTMeshGeometry.vertices[i].Set( + vertex.Anchor.X + (vertex.CameraFacing ? -vertex.Offset.X : vertex.Offset.X), + vertex.Anchor.Y + vertex.Offset.Y, + vertex.Anchor.Z + vertex.Offset.Z); + + sTMeshGeometry.vertices[i] *= m_MeshSettings.scaleFactor; + + sTMeshGeometry.normals[i].Set(vertex.Normal.X, vertex.Normal.Y, vertex.Normal.Z); + + Vector3 vertexTangent = new Vector3(vertex.Tangent.X, vertex.Tangent.Y, vertex.Tangent.Z); + Vector3 binormal = Vector3.Cross(sTMeshGeometry.normals[i], vertexTangent); + Vector2 vertexBinormal = new Vector3(vertex.Binormal.X, vertex.Binormal.Y, vertex.Binormal.Z); + + float dot = Vector3.Dot(binormal, vertexBinormal); + float flip = (dot < 0.0f) ? -1.0f : 1.0f; + + sTMeshGeometry.tangents[i].Set(vertex.Tangent.X, vertex.Tangent.Y, vertex.Tangent.Z, flip); + + sTMeshGeometry.colors32[i] = new Color( + vertex.Color.X * vertex.AmbientOcclusion, + vertex.Color.Y * vertex.AmbientOcclusion, + vertex.Color.Z * vertex.AmbientOcclusion, + vertex.BlendWeight); + + // Texcoord setup: + // 0 Diffuse UV, Branch1Pos, Branch1Dir + // 1 Lightmap UV, Branch1Weight, RippleWeight + + // If Branch2 is available: + // 2 Branch2Pos, Branch2Dir, Branch2Weight, + + // If camera-facing geom is available: + // 2/3 Anchor XYZ, FacingFlag + + int currentUV = 0; + sTMeshGeometry.uvs[currentUV++][i].Set( + vertex.TexCoord.X, + vertex.TexCoord.Y, + vertex.BranchWind1.X, + vertex.BranchWind1.Y); + + sTMeshGeometry.uvs[currentUV++][i].Set( + vertex.LightmapTexCoord.X, + vertex.LightmapTexCoord.Y, + vertex.BranchWind1.Z, + vertex.RippleWeight); + + if (!isBillboard) + { + float anchorX = m_HasFacingData ? vertex.Anchor.X * m_MeshSettings.scaleFactor : 0.0f; + float anchorY = m_HasFacingData ? vertex.Anchor.Y * m_MeshSettings.scaleFactor : 0.0f; + float anchorZ = m_HasFacingData ? vertex.Anchor.Z * m_MeshSettings.scaleFactor : 0.0f; + float leafFacingFlag = vertex.CameraFacing ? 1.0f : 0.0f; + + sTMeshGeometry.uvs[currentUV++][i].Set( + m_HasBranch2Data ? vertex.BranchWind2.X : anchorX, + m_HasBranch2Data ? vertex.BranchWind2.Y : anchorY, + m_HasBranch2Data ? vertex.BranchWind2.Z : anchorZ, + m_HasBranch2Data ? 0.0f /*UNUSED*/ : leafFacingFlag); + + bool useUV3 = m_HasBranch2Data && m_HasFacingData; + sTMeshGeometry.uvs[currentUV++][i].Set( + useUV3 ? anchorX : 0.0f, + useUV3 ? anchorY : 0.0f, + useUV3 ? anchorZ : 0.0f, + useUV3 ? leafFacingFlag : 0.0f); + } + } + } + + private void SetMeshRendererSettings(MeshRenderer renderer, int lodIndex) + { + ShadowCastingMode castMode = (m_LightingSettings.enableShadowCasting) ? ShadowCastingMode.On : ShadowCastingMode.Off; + LightProbeUsage probeUsage = (m_LightingSettings.enableLightProbes) ? LightProbeUsage.BlendProbes : LightProbeUsage.Off; + ReflectionProbeUsage reflectionProbe = m_LightingSettings.reflectionProbeEnumValue; + bool receiveShadows = m_LightingSettings.enableShadowReceiving; + + if (m_PerLODSettings[lodIndex].enableSettingOverride) + { + castMode = m_PerLODSettings[lodIndex].castShadows ? ShadowCastingMode.On : ShadowCastingMode.Off; + probeUsage = m_PerLODSettings[lodIndex].useLightProbes ? LightProbeUsage.BlendProbes : LightProbeUsage.Off; + receiveShadows = m_PerLODSettings[lodIndex].receiveShadows; + reflectionProbe = m_PerLODSettings[lodIndex].reflectionProbeUsage; + } + + renderer.sharedMaterials = RetrieveMaterialsForCurrentLod(lodIndex); + renderer.motionVectorGenerationMode = m_AdditionalSettings.motionVectorModeEnumValue; + renderer.receiveShadows = receiveShadows; + renderer.shadowCastingMode = castMode; + renderer.lightProbeUsage = probeUsage; + renderer.reflectionProbeUsage = reflectionProbe; + } + + private int CalculateNumUVs(bool isBillboard) + { + int numUVs = 2; + if (!isBillboard) + { + numUVs += 2; // reserve UV2 & UV3 for 3D-geometry to detect leaf facing (VS effect) correctly + } + return numUVs; + } + #endregion + + #region LODs + private PerLODSettings InstantiateAndInitializeLODSettingsObject(bool isBillboardLOD) + { + return new PerLODSettings() + { + enableSettingOverride = isBillboardLOD, + enableBump = m_MaterialSettings.enableBumpMapping, + enableHue = m_MaterialSettings.enableHueVariation, + enableSubsurface = m_MaterialSettings.enableSubsurfaceScattering, + castShadows = true, + receiveShadows = true, + useLightProbes = !isBillboardLOD, + reflectionProbeUsage = isBillboardLOD ? ReflectionProbeUsage.Off : ReflectionProbeUsage.BlendProbes, + }; + } + + private void CalculateBillboardAndPerLODSettings() + { + if (m_PerLODSettings.Count > m_LODCount) + { + m_PerLODSettings.RemoveRange((int)m_LODCount, m_PerLODSettings.Count); + } + else if (m_PerLODSettings.Count < m_LODCount) + { + m_PerLODSettings.Clear(); + for (int i = 0; i < m_LODCount; ++i) + { + bool isBillboardLOD = m_LastLodIsBillboard && i == m_LODCount - 1; + + PerLODSettings lodSettings = InstantiateAndInitializeLODSettingsObject(isBillboardLOD); + + m_PerLODSettings.Add(lodSettings); + } + + // Always reset LOD heights if size doesn't match. + for (int i = 0; i < m_LODCount; ++i) + { + m_PerLODSettings[i].height = (i == 0) ? 0.5f : m_PerLODSettings[i - 1].height * 0.5f; + } + + if (m_LODCount > 0) + { + // Using this pattern to avoid using 'Last' from Linq. + m_PerLODSettings[^1].height = 0.01f; + } + } + + Debug.Assert(m_PerLODSettings.Count == m_LODCount); + } + + private Material[] RetrieveMaterialsForCurrentLod(int lodIndex) + { + List materials = m_OutputImporterData.lodMaterials.materials; + + if (materials == null || materials.Count == 0) + return null; + + List matIDs = m_OutputImporterData.lodMaterials.lodToMaterials[lodIndex]; + + // Using this pattern to avoid using 'Select' from Linq. + Material[] lodMaterials = new Material[matIDs.Count]; + for (int i = 0; i < matIDs.Count; ++i) + { + lodMaterials[i] = materials[matIDs[i]].material; + } + + return lodMaterials; + } + + private void AddLODGroupToMainObjectAndSetTransition(LOD[] lods) + { + LODGroup lodGroup = m_OutputImporterData.mainObject.AddComponent(); + lodGroup.SetLODs(lods); + + int numLODs = lods.Length; + + if (m_LODSettings.enableSmoothLODTransition && numLODs > 0) + { + lodGroup.fadeMode = LODFadeMode.CrossFade; + lodGroup.animateCrossFading = m_LODSettings.animateCrossFading; + lodGroup.lastLODBillboard = m_LastLodIsBillboard; + + if (!m_LODSettings.animateCrossFading) + { + int lastLod = numLODs - 1; + lods[lastLod].fadeTransitionWidth = m_LODSettings.fadeOutWidth; + + if (m_LastLodIsBillboard && numLODs > 2) + { + int lastMeshLOD = numLODs - 2; + lods[lastMeshLOD].fadeTransitionWidth = m_LODSettings.billboardTransitionCrossFadeWidth; + } + } + } + + lodGroup.RecalculateBounds(); + } + + private void AddTreeComponentToLODObject(GameObject mainObject) + { + // Register the wind asset ptr through Tree component. + Tree treeComponent = mainObject.AddComponent(); + if (m_WindEnabled) + { + treeComponent.windAsset = m_WindAsset; + } + } + #endregion + + #region Materials + private void CreateMeshAndMaterials(bool regenerateMaterials = false) + { + LOD[] lods = new LOD[m_LODCount]; + + // Loop each LOD (mesh) of the asset. + for (int lodIndex = 0; lodIndex < m_LODCount; ++lodIndex) + { + Lod lod = m_Tree.Lod[lodIndex]; + Mesh mesh = CreateMeshAndGeometry(lod, lodIndex); + + // Loop each DrawCall (material) of the current mesh LOD. + for (int drawIndex = 0; drawIndex < lod.DrawCalls.Length; ++drawIndex) + { + DrawCall draw = lod.DrawCalls[drawIndex]; + + STMaterial stMaterial = m_Tree.Materials[(int)draw.MaterialIndex]; + + CreateMaterialsForCurrentLOD(stMaterial, lodIndex, regenerateMaterials); + + SetMeshIndices(mesh, lod, draw, drawIndex); + } + + CreateMeshAndLODObjects(mesh, lodIndex, ref lods); + } + + AddLODGroupToMainObjectAndSetTransition(lods); + } + + private void CreateMaterialsForCurrentLOD(STMaterial stMaterial, int lodIndex, bool regenerateMaterials) + { + bool matOverrided = m_PerLODSettings[lodIndex].enableSettingOverride; + bool isBillboard = m_LastLodIsBillboard && (lodIndex == (m_LODCount - 1)); + + // Overrided LODs have they own unique material. + string stMatName = stMaterial.Name; + if (matOverrided && !isBillboard) + stMatName += String.Format("LOD{0}", lodIndex); + + // Retrieve previously extracted material and update serialized index. + if (TryGetExternalMaterial(stMatName, out var extractedMat)) + { + // Explicity regenerate materials, should happen when bumping the material version for example. + if (regenerateMaterials) + { + extractedMat = CreateMaterial(stMaterial, lodIndex, extractedMat.name, m_PathFromDirectory); + + SetMaterialTextureAndColorProperties(stMaterial, extractedMat, lodIndex, m_PathFromDirectory); + } + else + { + RetrieveMaterialSpecialProperties(extractedMat); + } + + var existedMatIndex = m_OutputImporterData.lodMaterials.materials.FindIndex(m => m.defaultName == stMatName); + if (existedMatIndex == -1) + { + m_OutputImporterData.lodMaterials.materials.Add(new MaterialInfo { material = extractedMat, defaultName = stMatName, exported = true }); + m_OutputImporterData.lodMaterials.matNameToIndex[stMatName] = m_OutputImporterData.lodMaterials.materials.Count - 1; + } + else + { + m_OutputImporterData.lodMaterials.matNameToIndex[stMatName] = existedMatIndex; + } + } + // Create material if it doesn't exist yet. + else if (!m_OutputImporterData.lodMaterials.matNameToIndex.ContainsKey(stMatName)) + { + Material newMat = CreateMaterial(stMaterial, lodIndex, stMatName, m_PathFromDirectory); + + m_OutputImporterData.lodMaterials.materials.Add(new MaterialInfo { material = newMat, defaultName = stMatName, exported = false }); + m_OutputImporterData.lodMaterials.matNameToIndex.Add(stMatName, m_OutputImporterData.lodMaterials.materials.Count - 1); + } + + // Map the material id to the current LOD. + int indexMat = m_OutputImporterData.lodMaterials.matNameToIndex[stMatName]; + m_OutputImporterData.lodMaterials.AddLodMaterialIndex(lodIndex, indexMat); + } + + private void CreateAssetIdentifiersAndAddMaterialsToContext() + { + m_OutputImporterData.materialsIdentifiers.Clear(); + + foreach (MaterialInfo matInfo in m_OutputImporterData.lodMaterials.materials) + { + m_OutputImporterData.hasEmbeddedMaterials |= !matInfo.exported; + + if (!matInfo.exported) + { + m_Context.AddObjectToAsset(matInfo.material.name, matInfo.material); + + // It looks like a limitation from the default AssetImporter system. When deleting extracted materials manually, + // the external object map still contains a null reference, even after a reimport of the asset. + if (TryGetSourceAssetIdentifierFromName(matInfo.material.name, out var assetIdentifier)) + { + RemoveRemap(assetIdentifier); + } + } + + m_OutputImporterData.materialsIdentifiers.Add(new AssetIdentifier(matInfo.material.GetType(), matInfo.defaultName)); + } + } + + private void RegenerateMaterialsFromTree() + { + for (int lodIndex = 0; lodIndex < m_LODCount; lodIndex++) + { + Lod stLOD = m_Tree.Lod[lodIndex]; + + // Loop necessary materials for current LOD. + for (int drawIndex = 0; drawIndex < stLOD.DrawCalls.Length; ++drawIndex) + { + int matIndex = (int)stLOD.DrawCalls[drawIndex].MaterialIndex; + STMaterial stMaterial = m_Tree.Materials[matIndex]; + + CreateMaterialsForCurrentLOD(stMaterial, lodIndex, regenerateMaterials: true); + } + } + } + + private void RegenerateAndPopulateExternalMaterials(string assetPath) + { + // This object could potentially be cached, but this function is rarely triggered (only when bumping the material version) + // so the cost of caching it is not really interesting. + m_Tree = new SpeedTree9Reader(); + + FileStatus status = m_Tree.Initialize(assetPath); + if (status != FileStatus.Valid) + { + Debug.LogError($"Error while initializing the SpeedTree9 reader: {status}."); + return; + } + + m_Tree.ReadContent(); + + CacheTreeImporterValues(assetPath); + + if (!TryGetShaderForCurrentRenderPipeline(out m_Shader)) + { + Debug.LogError("SpeedTree9 shader is invalid, cannot create Materials for this SpeedTree asset."); + return; + } + + m_OutputImporterData = AssetDatabase.LoadAssetAtPath(assetPath); + m_OutputImporterData.lodMaterials.materials.Clear(); + + if (m_WindEnabled) + { + m_OutputImporterData.m_WindConfig = CopySpeedTree9WindConfig(m_Tree.Wind, m_MeshSettings.scaleFactor, m_Tree.Bounds); + } + + RegenerateMaterialsFromTree(); + + foreach (MaterialInfo matInfo in m_OutputImporterData.lodMaterials.materials) + { + m_OutputImporterData.hasEmbeddedMaterials |= !matInfo.exported; + + m_OutputImporterData.materialsIdentifiers.Add(new AssetIdentifier(matInfo.material.GetType(), matInfo.material.name)); + + // Remap the new material to the importer 'ExternalObjectMap'. + if (TryGetExternalMaterial(matInfo.defaultName, out var extractedMat)) + { + string newMatPath = AssetDatabase.GetAssetPath(extractedMat); + + // Not ideal, but it's safer to regenerate entirely the material (in case the pipeline has changed) + // and to avoid any potential issue with the 'ExternalObject' system (material null during next import) + if (File.Exists(newMatPath)) + { + File.Delete(newMatPath); + AssetDatabase.CreateAsset(matInfo.material, newMatPath); + } + + if (TryGetSourceAssetIdentifierFromName(matInfo.defaultName, out var assetIdentifier)) + { + AddRemap(assetIdentifier, matInfo.material); + } + } + } + } + + private bool TryGetExternalMaterial(string name, out Material material) + { + var externalObjMap = GetExternalObjectMap(); + + foreach (var obj in externalObjMap) + { + if (obj.Key.name == name) + { + material = obj.Value as Material; + return material != null; + } + } + + material = null; + return false; + } + + private bool TryGetSourceAssetIdentifierFromName(string name, out SourceAssetIdentifier assetIdentifier) + { + var externalObjMap = GetExternalObjectMap(); + + foreach (var obj in externalObjMap) + { + if (obj.Key.name == name) + { + assetIdentifier = obj.Key; + return true; + } + } + + assetIdentifier = new SourceAssetIdentifier(); + return false; + } + + private Material CreateMaterial(STMaterial stMaterial, int lod, string matName, string path) + { + Material mat = new Material(m_Shader) + { + name = matName + }; + + RetrieveMaterialSpecialProperties(mat); + + SetMaterialTextureAndColorProperties(stMaterial, mat, lod, path); + + SetMaterialOtherProperties(stMaterial, mat); + + SetWindKeywords(mat, stMaterial.Billboard); + + return mat; + } + + private bool SetMaterialTexture(Material mat, STMaterial stMaterial, int indexMap, string path, int property) + { + if (stMaterial.Maps.Length > indexMap) + { + MaterialMap stMatMap = stMaterial.Maps[indexMap]; + string mapPath = stMatMap.Path; + + if (!stMatMap.Used) + return false; + + if (!string.IsNullOrEmpty(mapPath)) + { + Texture2D texture = LoadTexture(mapPath, path); + + if (texture != null) + { + mat.SetTexture(property, texture); + return true; + } + } + } + + return false; + } + + private Texture2D LoadTexture(string mapPath, string path) + { + string texturePath = path + mapPath; + + Texture2D texture = (m_Context != null) + ? m_Context.GetReferenceToAssetMainObject(texturePath) as Texture2D + : AssetDatabase.LoadAssetAtPath(texturePath, typeof(Texture2D)) as Texture2D; + + if (texture != null) + return texture; + + // Textures are not located near the asset, let's check if they were moved somewhere else. + string mapPathWithoutExtension = Path.GetFileNameWithoutExtension(mapPath); + string[] textureAssets = AssetDatabase.FindAssets(mapPathWithoutExtension); + + if (textureAssets != null && textureAssets.Length > 0) + { + string assetPathFromGUID = AssetDatabase.GUIDToAssetPath(textureAssets[0]); + + texture = (m_Context != null) + ? m_Context.GetReferenceToAssetMainObject(assetPathFromGUID) as Texture2D + : AssetDatabase.LoadAssetAtPath(assetPathFromGUID, typeof(Texture2D)) as Texture2D; + + return texture; + } + + return null; + } + + private bool TryGetInstanceIDFromMaterialProperty(Material material, int propertyName, out int id) + { + if (!material.HasProperty(propertyName)) + { + id = 0; + return false; + } + + var property = material.GetTexture(propertyName); + id = property.GetInstanceID(); + + return true; + } + + // Not all pipelines support the following properties, so we don't draw them in the inspector if that's the case. + private void RetrieveMaterialSpecialProperties(Material mat) + { + m_OutputImporterData.hasAlphaClipThreshold |= mat.HasProperty(MaterialProperties.AlphaClipThresholdID); + m_OutputImporterData.hasTransmissionScale |= mat.HasProperty(MaterialProperties.TransmissionScaleID); + } + + private void SetMaterialTextureAndColorProperties(STMaterial stMaterial, Material mat, int lodIndex, string path) + { + bool enableHueVariation = m_MaterialSettings.enableHueVariation; + bool enableBumpMapping = m_MaterialSettings.enableBumpMapping; + bool enableSubsurfaceScattering = m_MaterialSettings.enableSubsurfaceScattering; + + if (m_PerLODSettings[lodIndex].enableSettingOverride) + { + enableHueVariation = m_PerLODSettings[lodIndex].enableHue; + enableBumpMapping = m_PerLODSettings[lodIndex].enableBump; + enableSubsurfaceScattering = m_PerLODSettings[lodIndex].enableSubsurface; + } + + // MainTex and Color + { + bool colorTex = SetMaterialTexture(mat, stMaterial, 0, path, MaterialProperties.MainTexID); + + if (colorTex && TryGetInstanceIDFromMaterialProperty(mat, MaterialProperties.MainTexID, out int id) && id != 0) + { + mat.SetColor(MaterialProperties.ColorTintID, m_MaterialSettings.mainColor); + } + else if (colorTex) + { + Vec4 stColorVec = stMaterial.Maps[3].Color; + Color rpColor = new Color(stColorVec.X, stColorVec.Y, stColorVec.Z, stColorVec.W); + + mat.SetColor(MaterialProperties.ColorTintID, m_MaterialSettings.mainColor * rpColor); + } + } + + // Bump map + { + bool hasNormalMap = SetMaterialTexture(mat, stMaterial, 1, path, MaterialProperties.NormalMapID); + bool enableFeature = hasNormalMap && enableBumpMapping; + + mat.SetFloat(MaterialProperties.NormalMapKwToggleID, (enableFeature) ? 1.0f : 0.0f); + } + + // Glossiness, metallic, AO + { + bool foundExtra = SetMaterialTexture(mat, stMaterial, 2, path, MaterialProperties.ExtraTexID); + + int id = 0; + if (foundExtra && TryGetInstanceIDFromMaterialProperty(mat, MaterialProperties.ExtraTexID, out id) && id != 0) + { + // _Glossiness (== _Smoothness) is multipled in the shader with the texture values if ExtraTex is present. + // Set default value 1.0f to override the default value 0.5, otherwise, the original texture values will + // be scaled down to half as much. Same goes for _Metallic + mat.SetFloat(MaterialProperties.GlossinessID, 1.0f); + mat.SetFloat(MaterialProperties.MetallicID, 1.0f); + } + else if (foundExtra) + { + Vec4 stColor = stMaterial.Maps[2].Color; + mat.SetFloat(MaterialProperties.GlossinessID, stColor.X); + mat.SetFloat(MaterialProperties.MetallicID, stColor.Y); + } + + mat.SetFloat(MaterialProperties.ExtraMapKwToggleID, (foundExtra && id != 0) ? 1.0f : 0.0f); + } + + // Extra and SSS + if (stMaterial.TwoSided || stMaterial.Billboard) + { + bool hasSSSTex = SetMaterialTexture(mat, stMaterial, 3, path, MaterialProperties.SubsurfaceTexID); + bool setToggle = hasSSSTex && enableSubsurfaceScattering; + + // TODO: To implement in ST9 Shader. + mat.SetFloat(MaterialProperties.SubsurfaceKwToggleID, (setToggle) ? 1.0f : 0.0f); + + if (hasSSSTex && TryGetInstanceIDFromMaterialProperty(mat, MaterialProperties.SubsurfaceTexID, out int id) && id != 0) + { + mat.SetColor(MaterialProperties.SubsurfaceColorID, new Color(1.0f, 1.0f, 1.0f, 1.0f)); + } + else if (hasSSSTex) + { + Vec4 stColor = stMaterial.Maps[3].Color; + mat.SetColor(MaterialProperties.SubsurfaceColorID, new Color(stColor.X, stColor.Y, stColor.Z, stColor.W)); + } + + if (m_OutputImporterData.hasAlphaClipThreshold && mat.HasFloat(MaterialProperties.AlphaClipThresholdID)) + { + mat.SetFloat(MaterialProperties.AlphaClipThresholdID, m_MaterialSettings.alphaClipThreshold); + } + + if (m_OutputImporterData.hasTransmissionScale && mat.HasFloat(MaterialProperties.TransmissionScaleID)) + { + mat.SetFloat(MaterialProperties.TransmissionScaleID, m_MaterialSettings.transmissionScale); + } + } + + // Hue effect + { + mat.SetFloat(MaterialProperties.HueVariationKwToggleID, enableHueVariation ? 1.0f : 0.0f); + mat.SetColor(MaterialProperties.HueVariationColorID, m_MaterialSettings.hueVariation); + } + } + + private void SetMaterialOtherProperties(STMaterial stMaterial, Material mat) + { + bool isBillboard = stMaterial.Billboard; + + // Other properties + mat.SetFloat(MaterialProperties.BillboardKwToggleID, isBillboard ? 1.0f : 0.0f); + if (isBillboard) + { + mat.EnableKeyword(MaterialKeywords.BillboardID); + } + mat.SetFloat(MaterialProperties.LeafFacingKwToggleID, m_HasFacingData ? 1.0f : 0.0f); + + if (mat.HasFloat(MaterialProperties.DoubleSidedToggleID)) + mat.SetFloat(MaterialProperties.DoubleSidedToggleID, stMaterial.TwoSided ? 1.0f : 0.0f); + + if (mat.HasFloat(MaterialProperties.DoubleSidedNormalModeID)) + mat.SetFloat(MaterialProperties.DoubleSidedNormalModeID, stMaterial.FlipNormalsOnBackside ? 0.0f : 2.0f); + + if (mat.HasVector(MaterialProperties.DiffusionProfileAssetID)) + mat.SetVector(MaterialProperties.DiffusionProfileAssetID, m_MaterialSettings.diffusionProfileAssetID); + + if (mat.HasFloat(MaterialProperties.DiffusionProfileID)) + mat.SetFloat(MaterialProperties.DiffusionProfileID, m_MaterialSettings.diffusionProfileID); + + if (mat.HasFloat(MaterialProperties.BackfaceNormalModeID)) + mat.SetFloat(MaterialProperties.BackfaceNormalModeID, stMaterial.FlipNormalsOnBackside ? 0.0f : 2.0f); + + if (mat.HasFloat(MaterialProperties.TwoSidedID)) + mat.SetFloat(MaterialProperties.TwoSidedID, stMaterial.TwoSided ? 0.0f : 2.0f); // matches cull mode. 0: no cull + + mat.enableInstancing = true; + mat.doubleSidedGI = stMaterial.TwoSided; + } + + private void SetWindKeywords(Material material, bool isBillboardMat) + { + if (material == null) + return; + + //------------------------------------------------------------------------ + // Note: + // mat.SetFloat(...) : Legacy rendering pipeline keyword toggle + // mat.EnableKeyword(...) : SRP keyword toggle + //------------------------------------------------------------------------ + SpeedTreeWindConfig9 windCfg = m_OutputImporterData.m_WindConfig; + + if (windCfg.doShared != 0) + { + material.SetFloat(MaterialProperties.WindSharedKwToggle, 1.0f); + } + if (!isBillboardMat) + { + if (windCfg.doBranch2 != 0) + { + material.SetFloat(MaterialProperties.WindBranch2KwToggle, 1.0f); + } + if (windCfg.doBranch1 != 0) + { + material.SetFloat(MaterialProperties.WindBranch1KwToggle, 1.0f); + } + if (windCfg.doRipple != 0) + { + material.SetFloat(MaterialProperties.WindRippleKwToggle, 1.0f); + if (windCfg.doShimmer != 0) + { + material.SetFloat(MaterialProperties.WindShimmerKwToggle, 1.0f); + } + } + } + } + + internal bool SearchAndRemapMaterials(string materialFolderPath) + { + bool changedMappings = false; + + if (materialFolderPath == null) + throw new ArgumentNullException("materialFolderPath"); + + if (string.IsNullOrEmpty(materialFolderPath)) + throw new ArgumentException(string.Format("Invalid material folder path: {0}.", materialFolderPath), "materialFolderPath"); + + string[] guids = AssetDatabase.FindAssets("t:Material", new string[] { materialFolderPath }); + List> materials = new List>(); + foreach (string guid in guids) + { + string path = AssetDatabase.GUIDToAssetPath(guid); + // ensure that we only load material assets, not embedded materials + Material material = AssetDatabase.LoadMainAssetAtPath(path) as Material; + if (material) + materials.Add(new Tuple(path, material)); + } + + m_OutputImporterData = AssetDatabase.LoadAssetAtPath(assetPath); + AssetIdentifier[] importedMaterials = m_OutputImporterData.materialsIdentifiers.ToArray(); + + foreach (Tuple material in materials) + { + string materialName = material.Item2.name; + string materialFile = material.Item1; + + // the legacy materials have the LOD in the path, while the new materials have the LOD as part of the name + bool isLegacyMaterial = !materialName.Contains("LOD") && !materialName.Contains("Billboard"); + bool hasLOD = isLegacyMaterial && materialFile.Contains("LOD"); + string lod = Path.GetFileNameWithoutExtension(Path.GetDirectoryName(materialFile)); + AssetIdentifier importedMaterial = Array.Find(importedMaterials, x => x.name.Contains(materialName) && (!hasLOD || x.name.Contains(lod))); + + if (!string.IsNullOrEmpty(importedMaterial.name)) + { + SourceAssetIdentifier importedIdentifier = new SourceAssetIdentifier(material.Item2); + + AddRemap(importedIdentifier, material.Item2); + changedMappings = true; + } + } + + return changedMappings; + } + + internal string GetMaterialFolderPath() + { + return FileUtil.DeleteLastPathNameComponent(assetPath) + "/"; + } + + internal void SetMaterialsVersionToCurrent() + { + m_MaterialVersion = SPEEDTREE_9_MATERIAL_VERSION; + MarkDirty(); + } + + private void AddDependencyOnExtractedMaterials() + { + Dictionary extMap = GetExternalObjectMap(); + + foreach (var entry in extMap) + { + if (entry.Value != null) + { + string matPath = AssetDatabase.GetAssetPath(entry.Value); + + m_Context.DependsOnImportedAsset(matPath); + + // Necessary to avoid the warning "Import of asset setup artifact dependency to but dependency isn't used + // and therefore not registered in the asset database". + AssetDatabase.LoadAssetAtPath(matPath, typeof(Material)); + } + } + } + #endregion + + #region Wind + private unsafe SpeedTreeWindConfig9 CopySpeedTree9WindConfig(WindConfigSDK wind, float scaleFactor, in Bounds3 treeBounds) + { + const bool CHECK_ZERO = true; + const bool DONT_CHECK_ZERO = false; + + void CopyCurve(in float[] src, float* dst) + { + const int NUM_CURVE_ELEMENTS = 20; + Debug.Assert(src.Length == NUM_CURVE_ELEMENTS); + for (global::System.Int32 i = 0; i < NUM_CURVE_ELEMENTS; i++) + { + dst[i] = src[i]; + } + } + + void CopyCurveScale(in float[] src, float* dst, float scaleFactor) + { + const int NUM_CURVE_ELEMENTS = 20; + Debug.Assert(src.Length == NUM_CURVE_ELEMENTS); + for (global::System.Int32 i = 0; i < NUM_CURVE_ELEMENTS; i++) + { + dst[i] = src[i] * scaleFactor; + } + } + + bool ValidCurve(float[] curve, bool bCheckZero = CHECK_ZERO) + { + bool bNonZero = false; + for (int i = 0; i < curve.Length; ++i) + { + bNonZero |= curve[i] != 0.0f; + if (float.IsNaN(curve[i])) + { + return false; + } + } + + if (bCheckZero) + { + return bNonZero; + } + return true; + } + + bool BranchHasAllCurvesValid(in WindBranch b) + { + return ValidCurve(b.Bend) + && ValidCurve(b.Oscillation) + && ValidCurve(b.Speed, CHECK_ZERO) + && ValidCurve(b.Turbulence) + && ValidCurve(b.Flexibility, DONT_CHECK_ZERO + ); + } + + bool RippleHasAllCurvesValid(in WindRipple r) + { + return ValidCurve(r.Planar) + && ValidCurve(r.Directional) + && ValidCurve(r.Speed) + && ValidCurve(r.Flexibility, DONT_CHECK_ZERO + ); + } + + SpeedTreeWindConfig9 cfg = new SpeedTreeWindConfig9(); + + // common + WindConfigCommon common = wind.Common; + cfg.strengthResponse = common.StrengthResponse; + cfg.directionResponse = common.DirectionResponse; + cfg.gustFrequency = common.GustFrequency; + cfg.gustStrengthMin = common.GustStrengthMin; + cfg.gustStrengthMax = common.GustStrengthMax; + cfg.gustDurationMin = common.GustDurationMin; + cfg.gustDurationMax = common.GustDurationMax; + cfg.gustRiseScalar = common.GustRiseScalar; + cfg.gustFallScalar = common.GustFallScalar; + + // st9 + cfg.branch1StretchLimit = wind.Branch1StretchLimit * scaleFactor; + cfg.branch2StretchLimit = wind.Branch2StretchLimit * scaleFactor; + cfg.importScale = scaleFactor; + cfg.treeExtentX = (treeBounds.Max.X - treeBounds.Min.X) * scaleFactor; + cfg.treeExtentY = (treeBounds.Max.Y - treeBounds.Min.Y) * scaleFactor; + cfg.treeExtentZ = (treeBounds.Max.Z - treeBounds.Min.Z) * scaleFactor; + + if (wind.DoShared) + { + WindConfigSDK.WindBranch shared = wind.Shared; + CopyCurveScale(shared.Bend, cfg.bendShared, scaleFactor); + CopyCurveScale(shared.Oscillation, cfg.oscillationShared, scaleFactor); + CopyCurve(shared.Speed, cfg.speedShared); + CopyCurve(shared.Turbulence, cfg.turbulenceShared); + CopyCurve(shared.Flexibility, cfg.flexibilityShared); + cfg.independenceShared = shared.Independence; + cfg.sharedHeightStart = wind.SharedStartHeight; // this is a % value + if (BranchHasAllCurvesValid(in shared)) + { + cfg.doShared = 1; + } + } + + if (wind.DoBranch1) + { + WindConfigSDK.WindBranch branch1 = wind.Branch1; + CopyCurveScale(branch1.Bend, cfg.bendBranch1, scaleFactor); + CopyCurveScale(branch1.Oscillation, cfg.oscillationBranch1, scaleFactor); + CopyCurve(branch1.Speed, cfg.speedBranch1); + CopyCurve(branch1.Turbulence, cfg.turbulenceBranch1); + CopyCurve(branch1.Flexibility, cfg.flexibilityBranch1); + cfg.independenceBranch1 = branch1.Independence; + if (BranchHasAllCurvesValid(in branch1)) + { + cfg.doBranch1 = 1; + } + } + + if (wind.DoBranch2) + { + WindConfigSDK.WindBranch branch2 = wind.Branch2; + CopyCurveScale(branch2.Bend, cfg.bendBranch2, scaleFactor); + CopyCurveScale(branch2.Oscillation, cfg.oscillationBranch2, scaleFactor); + CopyCurve(branch2.Speed, cfg.speedBranch2); + CopyCurve(branch2.Turbulence, cfg.turbulenceBranch2); + CopyCurve(branch2.Flexibility, cfg.flexibilityBranch2); + cfg.independenceBranch2 = branch2.Independence; + if (BranchHasAllCurvesValid(in branch2)) + { + cfg.doBranch2 = 1; + } + } + + if (wind.DoRipple) + { + WindConfigSDK.WindRipple ripple = wind.Ripple; + CopyCurveScale(ripple.Planar, cfg.planarRipple, scaleFactor); + CopyCurveScale(ripple.Directional, cfg.directionalRipple, scaleFactor); + CopyCurve(ripple.Speed, cfg.speedRipple); + CopyCurve(ripple.Flexibility, cfg.flexibilityRipple); + cfg.independenceRipple = ripple.Independence; + if (RippleHasAllCurvesValid(in ripple)) + { + cfg.doRipple = 1; + if (wind.DoShimmer) + { + cfg.doShimmer = 1; + cfg.shimmerRipple = ripple.Shimmer; + } + } + } + return cfg; + } + + private void SetWindParameters(ref SpeedTreeWindConfig9 cfg) + { + cfg.strengthResponse = m_WindSettings.strenghResponse; + cfg.directionResponse = m_WindSettings.directionResponse; + cfg.windIndependence = m_WindSettings.randomness; + } + + #endregion + + #region Others + private void CalculateScaleFactorFromUnit() + { + switch (m_MeshSettings.unitConversion) + { + // Use units in the imported file without any conversion. + case STUnitConversion.kLeaveAsIs: + m_MeshSettings.scaleFactor = 1.0f; + break; + case STUnitConversion.kFeetToMeters: + m_MeshSettings.scaleFactor = SpeedTreeConstants.kFeetToMetersRatio; + break; + case STUnitConversion.kCentimetersToMeters: + m_MeshSettings.scaleFactor = SpeedTreeConstants.kCentimetersToMetersRatio; + break; + case STUnitConversion.kInchesToMeters: + m_MeshSettings.scaleFactor = SpeedTreeConstants.kInchesToMetersRatio; + break; + case STUnitConversion.kCustomConversion: + /* no-op */ + break; + } + } + + private bool TreeHasFacingData() + { + for (int lodIndex = 0; lodIndex < m_LODCount; ++lodIndex) + { + Lod lod = m_Tree.Lod[lodIndex]; + + for (int drawIndex = 0; drawIndex < lod.DrawCalls.Length; ++drawIndex) + { + DrawCall draw = lod.DrawCalls[drawIndex]; + if(draw.ContainsFacingGeometry) + return true; + } + } + return false; + } + + internal static bool TryGetShaderForCurrentRenderPipeline(out Shader shader) + { + shader = GraphicsSettings.GetDefaultShader(DefaultShaderType.SpeedTree9); + if (shader == null) + { + shader = Shader.Find(ImporterSettings.kLegacyShaderName); + } + + return shader != null; + } + + private void CreateAndAddRigidBodyToAsset(GameObject mainObject) + { + Rigidbody rb = mainObject.AddComponent(); + if (rb != null) + { + rb.useGravity = false; + rb.isKinematic = true; + } + } + + private void CreateAndAddCollidersToAsset() + { + for (int iCollider = 0; iCollider < m_CollisionObjectsCount; ++iCollider) + { + CollisionObject stCollider = m_Tree.CollisionObjects[iCollider]; + + GameObject collisionObject = new GameObject("Collider" + (iCollider + 1)); + collisionObject.transform.parent = m_OutputImporterData.mainObject.transform; + + Vector3 vOne = new Vector3(stCollider.Position.X, stCollider.Position.Y, stCollider.Position.Z); + Vector3 vTwo = new Vector3(stCollider.Position2.X, stCollider.Position2.Y, stCollider.Position2.Z); + + vOne *= m_MeshSettings.scaleFactor; + vTwo *= m_MeshSettings.scaleFactor; + + collisionObject.transform.position = (vOne + vTwo) * 0.5f; + + if ((vOne - vTwo).sqrMagnitude < 0.001f) + { + SphereCollider collider = collisionObject.AddComponent(); + collider.radius = stCollider.Radius * m_MeshSettings.scaleFactor; + } + else + { + CapsuleCollider collider = collisionObject.AddComponent(); + collider.direction = 2; + collider.radius = stCollider.Radius * m_MeshSettings.scaleFactor; + collider.height = (vOne - vTwo).magnitude; + collisionObject.transform.LookAt(vTwo); + } + + m_Context.AddObjectToAsset(collisionObject.name, collisionObject); + } + } + + internal float[] GetPerLODSettingsHeights() + { + float[] heightsArray = new float[m_PerLODSettings.Count]; + + for (int i = 0; i < m_PerLODSettings.Count; ++i) + { + heightsArray[i] = m_PerLODSettings[i].height; + } + + return heightsArray; + } + #endregion + } + + // Use a postprocessor to set various settings on the textures since these dont stick during first import. + class SpeedTree9Postprocessor : AssetPostprocessor + { + private static void OnPostprocessAllAssets( + string[] importedAssets, + string[] deletedAssets, + string[] movedAssets, + string[] movedFromAssetPaths, + bool didDomainReload) + { + foreach (string assetFilename in importedAssets) + { + if (Path.GetExtension(assetFilename) == ".st9") + { + try + { + AssetDatabase.StartAssetEditing(); + + ChangeTextureImporterSettingsForSt9Files(assetFilename); + } + finally + { + AssetDatabase.StopAssetEditing(); + } + } + } + + if (didDomainReload) + { + if (TryGetHashSpeedTreeAttributeMaterialSettings(out List strToHash)) + { + Hash128 hash = new Hash128(); + + foreach (string str in strToHash) + { + hash.Append(str); + } + + AssetDatabase.RegisterCustomDependency(ImporterSettings.kMaterialSettingsDependencyname, hash); + } + else + { + AssetDatabase.UnregisterCustomDependencyPrefixFilter(ImporterSettings.kMaterialSettingsDependencyname); + } + } + } + + private static bool TryGetHashSpeedTreeAttributeMaterialSettings(out List strToHash) + { + var allMethods = AttributeHelper.GetMethodsWithAttribute().methodsWithAttributes; + + strToHash = new List(); + + foreach (var method in allMethods) + { + MaterialSettingsCallbackAttribute attribute = method.attribute as MaterialSettingsCallbackAttribute; + + strToHash.Add($"{method.info.Name}-{method.info.DeclaringType.AssemblyQualifiedName}-{attribute.MethodVersion.ToString()}"); + } + + strToHash.Sort(); + return strToHash.Count > 0; + } + + private static void ChangeTextureImporterSettingsForSt9Files(string assetPath) + { + SpeedTree9Reader tree = new SpeedTree9Reader(); + + FileStatus status = tree.Initialize(assetPath); + if (status != FileStatus.Valid) + { + Debug.LogError($"Error while initializing the SpeedTree9 reader: {status}."); + return; + } + + tree.ReadContent(); + + string path = Path.GetDirectoryName(assetPath) + "/"; + for (int matIndex = 0; matIndex < tree.Materials.Length; ++matIndex) + { + STMaterial stMaterial = tree.Materials[matIndex]; + + if (TryGetTextureImporterFromIndex(stMaterial, 0, path, out TextureImporter texImporterColor)) + ApplyColorTextureSettings(texImporterColor); + + if (TryGetTextureImporterFromIndex(stMaterial, 1, path, out TextureImporter texImporterNormal)) + ApplyNormalTextureSettings(texImporterNormal); + + if (TryGetTextureImporterFromIndex(stMaterial, 2, path, out TextureImporter texImporterExtra)) + ApplyExtraTextureSettings(texImporterExtra); + } + } + + private static bool TryGetTextureImporterFromIndex( + STMaterial stMaterial, + int index, + string directoryPath, + out TextureImporter textureImporter) + { + textureImporter = null; + + if (stMaterial.Maps.Length <= index) + return false; + + MaterialMap mat = stMaterial.Maps[index]; + if (!mat.Used || string.IsNullOrEmpty(mat.Path)) + return false; + + TextureImporter texImporter = TextureImporter.GetAtPath(directoryPath + mat.Path) as TextureImporter; + if (texImporter == null) + return false; + + textureImporter = texImporter; + return true; + } + + private static void ApplyColorTextureSettings(TextureImporter texImporter) + { + if (texImporter.alphaIsTransparency && + texImporter.mipMapsPreserveCoverage && + texImporter.alphaTestReferenceValue == 0.1f) + return; + + texImporter.alphaIsTransparency = true; + texImporter.mipMapsPreserveCoverage = true; + texImporter.alphaTestReferenceValue = 0.1f; + + EditorUtility.SetDirty(texImporter); + texImporter.SaveAndReimport(); + } + + private static void ApplyNormalTextureSettings(TextureImporter texImporter) + { + if (texImporter.textureType == TextureImporterType.NormalMap) + return; + + texImporter.textureType = TextureImporterType.NormalMap; + + EditorUtility.SetDirty(texImporter); + texImporter.SaveAndReimport(); + } + + private static void ApplyExtraTextureSettings(TextureImporter texImporter) + { + if (texImporter.sRGBTexture == false) + return; + + texImporter.sRGBTexture = false; + + EditorUtility.SetDirty(texImporter); + texImporter.SaveAndReimport(); + } + } +} diff --git a/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9ImporterEditor.cs b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9ImporterEditor.cs new file mode 100644 index 0000000000..081cd3b494 --- /dev/null +++ b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9ImporterEditor.cs @@ -0,0 +1,309 @@ +// Unity C# reference source +// Copyright (c) Unity Technologies. For terms of use, see +// https://unity3d.com/legal/licenses/Unity_Reference_Only_License + +using UnityEditor.AssetImporters; +using System.Collections.Generic; +using UnityEngine; +using System; + +namespace UnityEditor.SpeedTree.Importer +{ + [CustomEditor(typeof(SpeedTree9Importer))] + [CanEditMultipleObjects] + internal class SpeedTree9ImporterEditor : AssetImporterTabbedEditor + { + private static class Styles + { + public static GUIContent ApplyAndGenerate = EditorGUIUtility.TrTextContent("Apply & Generate Materials", "Apply current importer settings and generate materials with new settings."); + public static GUIContent Regenerate = EditorGUIUtility.TrTextContent("Regenerate Materials", "Regenerate materials from the current importer settings."); + public static GUIContent RegenerateRemapped = EditorGUIUtility.TrTextContent("Regenerate Materials", "Regenerate the remapped materials from the current import settings."); + public static GUIContent ApplyAndGenerateRemapped = EditorGUIUtility.TrTextContent("Apply & Generate Materials", "Apply current importer settings and regenerate the remapped materials with new settings."); + + public static readonly string ModelTabName = "Model"; + public static readonly string MaterialsTabName = "Materials"; + public static readonly string WindTabName = "Wind"; + } + + private bool m_HasRemappedMaterials = false; + private SpeedTreeImporterOutputData m_OutputImporterData = null; + private SpeedTree9Importer m_STImporter = null; + + internal IEnumerable importers + { + get + { + SpeedTree9Importer[] st9Importers = new SpeedTree9Importer[targets.Length]; + + for (int i = 0; i < targets.Length; ++i) + { + st9Importers[i] = targets[i] as SpeedTree9Importer; + } + + return st9Importers; + } + } + + public override void OnEnable() + { + m_STImporter = target as SpeedTree9Importer; + + if (tabs == null) + { + tabs = new BaseAssetImporterTabUI[] + { + new SpeedTree9ImporterModelEditor(this), + new SpeedTree9ImporterMaterialEditor(this), + new SpeedTree9ImporterWindEditor(this) + }; + m_TabNames = new string[] { Styles.ModelTabName, Styles.MaterialsTabName, Styles.WindTabName }; + } + + m_OutputImporterData = AssetDatabase.LoadAssetAtPath(m_STImporter.assetPath); + Debug.Assert(m_OutputImporterData != null); + + base.OnEnable(); + } + + public override void OnDisable() + { + foreach (var tab in tabs) + { + tab.OnDisable(); + } + base.OnDisable(); + } + + // None of the ModelImporter sub editors support multi preview. + public override bool HasPreviewGUI() + { + return base.HasPreviewGUI() && targets.Length < 2; + } + + // Only show the imported GameObject when the Model tab is active. + public override bool showImportedObject { get { return activeTab is SpeedTree9ImporterModelEditor; } } + + public override GUIContent GetPreviewTitle() + { + var tab = activeTab as ModelImporterClipEditor; + if (tab != null) + return new GUIContent(tab.selectedClipName); + + return base.GetPreviewTitle(); + } + + internal bool upgradeMaterials + { + get + { + foreach (var importer in importers) + { + if (importer != null && importer.MaterialsShouldBeRegenerated) + return true; + } + return false; + } + } + + protected override bool OnApplyRevertGUI() + { + bool applied = base.OnApplyRevertGUI(); + + bool hasModified = HasModified(); + if (tabs == null) // Hitting apply, we lose the tabs object within base.OnApplyRevertGUI() + { + if (hasModified) + Apply(); + return applied; + } + + bool doMatsHaveDifferentShaders = (tabs[0] as SpeedTree9ImporterModelEditor).DoMaterialsHaveDifferentShader(); + + // We show the "Generate" button when we have extracted materials since the user should have 2 choices: + // - Apply the importer settings changes on top of the extracted materials (by regenerating them) + // - Only apply the importer settings changes to the embedded materials and not the extracted ones, + // since the users might want to be able to keep their own changes without the importer to erase them. + m_HasRemappedMaterials = HasRemappedMaterials(); + + if (upgradeMaterials || doMatsHaveDifferentShaders || m_HasRemappedMaterials) + { + // Force material upgrade when a custom render pipeline is active so that render pipeline-specific material + // modifications may be applied. + bool upgrade = upgradeMaterials || (UnityEngine.Rendering.GraphicsSettings.currentRenderPipeline != null); + + if (GUILayout.Button(GetGenerateButtonText(hasModified, upgrade))) + { + // Apply the changes and generate the materials before importing so that asset previews are up-to-date. + if (hasModified) + Apply(); + + if (upgrade) + { + foreach (var importer in importers) + { + importer.SetMaterialsVersionToCurrent(); + } + } + + GenerateMaterials(); + + if (hasModified || upgrade) + { + // Necessary since we remap the newly generated materials to the mesh LOD(s). + SaveChanges(); + applied = true; + } + } + } + + return applied; + } + + internal GUIContent GetGenerateButtonText(bool modified, bool upgrade) + { + if (modified || upgrade) + { + if (m_HasRemappedMaterials) + return Styles.ApplyAndGenerate; + else + return Styles.ApplyAndGenerateRemapped; + } + else + { + if (m_HasRemappedMaterials) + return Styles.Regenerate; + else + return Styles.RegenerateRemapped; + } + } + + private bool HasEmbeddedMaterials + { + get + { + bool materialsValid = m_OutputImporterData.lodMaterials.materials.Count > 0 + && m_OutputImporterData.lodMaterials.materials.TrueForAll(p => p.material != null); + + return m_OutputImporterData.hasEmbeddedMaterials && materialsValid; + } + } + + private void GenerateMaterials() + { + List paths = new List(); + List matFolders = new List(); + List importersWithEmbeddedMaterials = new List(); + + // TODO: Add support for multi-edit. + if (HasEmbeddedMaterials) + { + importersWithEmbeddedMaterials.Add(m_STImporter); + } + + foreach (var importer in importersWithEmbeddedMaterials) + { + var remappedAssets = importer.GetExternalObjectMap(); + + List materials = new List(); + + foreach (var asset in remappedAssets) + { + if (asset.Value is Material && asset.Value != null) + { + materials.Add(asset.Value); + } + } + + foreach (var material in materials) + { + string path = AssetDatabase.GetAssetPath(material); + paths.Add(path); + matFolders.Add(FileUtil.DeleteLastPathNameComponent(path)); + } + } + + bool doGenerate = true; + if (paths.Count > 0) + { + doGenerate = AssetDatabase.MakeEditable(paths.ToArray(), $"Materials will be checked out in:\n{string.Join("\n", matFolders.ToArray())}"); + } + + if (doGenerate) + { + foreach (var importer in importers) + { + importer.RegenerateMaterials(); + } + } + } + + private bool HasRemappedMaterials() + { + m_HasRemappedMaterials = true; + + if (m_OutputImporterData.materialsIdentifiers.Count == 0) + return true; + + // if the m_ExternalObjecs map has any unapplied changes, keep the state of the button as is + if (serializedObject.hasModifiedProperties) + return m_HasRemappedMaterials; + + m_HasRemappedMaterials = true; + foreach (var importer in importers) + { + var externalObjectMap = importer.GetExternalObjectMap(); + var materialArray = m_OutputImporterData.materialsIdentifiers.ToArray();// importer.SourceMaterials.ToArray(); + + int remappedMaterialCount = 0; + foreach (var entry in externalObjectMap) + { + if (entry.Key.type == typeof(Material) && Array.Exists(materialArray, x => x.name == entry.Key.name && entry.Value != null)) + ++remappedMaterialCount; + } + + m_HasRemappedMaterials = m_HasRemappedMaterials && remappedMaterialCount != 0; + if (!m_HasRemappedMaterials) + break; + } + return m_HasRemappedMaterials; + } + } + + internal abstract class BaseSpeedTree9ImporterTabUI : BaseAssetImporterTabUI + { + protected SpeedTreeImporterOutputData m_OutputImporterData; + + internal BaseSpeedTree9ImporterTabUI(AssetImporterEditor panelContainer) + : base(panelContainer) + { + } + internal override void OnEnable() + { + TryLoadOutputImporterData(); + } + + protected IEnumerable importers + { + get { return (panelContainer as SpeedTree9ImporterEditor).importers; } + } + + protected bool upgradeMaterials + { + get { return (panelContainer as SpeedTree9ImporterEditor).upgradeMaterials; } + } + + protected bool TryLoadOutputImporterData() + { + m_OutputImporterData = null; + + // Doesn't support multi-edit for now. + foreach (SpeedTree9Importer importer in importers) + { + m_OutputImporterData = AssetDatabase.LoadAssetAtPath(importer.assetPath); + break; + } + + return m_OutputImporterData != null; + } + } +} diff --git a/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9ImporterMaterialEditor.cs b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9ImporterMaterialEditor.cs new file mode 100644 index 0000000000..2bda72c40a --- /dev/null +++ b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9ImporterMaterialEditor.cs @@ -0,0 +1,314 @@ +// 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.AssetImporters; +using UnityEngine; + +namespace UnityEditor.SpeedTree.Importer +{ + class SpeedTree9ImporterMaterialEditor : BaseSpeedTree9ImporterTabUI + { + private static class Styles + { + public static GUIContent RemapOptions = EditorGUIUtility.TrTextContent("On Demand Remap"); + public static GUIContent RemapMaterialsInProject = EditorGUIUtility.TrTextContent("Search and Remap...", "Click on this button to search and remap the materials from the project."); + public static GUIContent ExternalMaterialMappings = EditorGUIUtility.TrTextContent("Remapped Materials", "External materials to use for each embedded material."); + + public static GUIContent Materials = EditorGUIUtility.TrTextContent("Materials"); + public static GUIContent ExtractEmbeddedMaterials = EditorGUIUtility.TrTextContent("Extract Materials...", "Click on this button to extract the embedded materials."); + + public static GUIContent InternalMaterialHelp = EditorGUIUtility.TrTextContent("Materials are embedded inside the imported asset."); + public static GUIContent MaterialAssignmentsHelp = EditorGUIUtility.TrTextContent("Material assignments can be remapped below."); + + public static GUIContent ExternalMaterialSearchHelp = EditorGUIUtility.TrTextContent("Searches the user provided directory and matches the materials that share the same name and LOD with the originally imported material."); + public static GUIContent SelectMaterialFolder = EditorGUIUtility.TrTextContent("Select Materials Folder"); + } + + private SpeedTree9Importer m_STImporter; + private SerializedProperty m_ExternalObjects; + + private bool m_ShowMaterialRemapOptions; + private bool m_HasEmbeddedMaterials; + + private bool ImporterHasEmbeddedMaterials + { + get + { + bool materialsValid = m_OutputImporterData.lodMaterials.materials.Count > 0 + && m_OutputImporterData.lodMaterials.materials.TrueForAll(p => p.material != null); + + return m_OutputImporterData.hasEmbeddedMaterials && materialsValid; + } + } + + public SpeedTree9ImporterMaterialEditor(AssetImporterEditor panelContainer) + : base(panelContainer) + { } + + internal override void OnEnable() + { + base.OnEnable(); + + m_STImporter = target as SpeedTree9Importer; + + m_ExternalObjects = serializedObject.FindProperty("m_ExternalObjects"); + } + + public override void OnInspectorGUI() + { + serializedObject.Update(); + + ShowMaterialGUI(); + + serializedObject.ApplyModifiedProperties(); + } + + private bool HasEmbeddedMaterials() + { + if (m_OutputImporterData.materialsIdentifiers.Count == 0 || !ImporterHasEmbeddedMaterials) + return false; + + // if the m_ExternalObjecs map has any unapplied changes, keep the state of the button as is + if (m_ExternalObjects.serializedObject.hasModifiedProperties) + return m_HasEmbeddedMaterials; + + m_HasEmbeddedMaterials = true; + foreach (var t in m_ExternalObjects.serializedObject.targetObjects) + { + var externalObjectMap = m_STImporter.GetExternalObjectMap(); + var materialsList = m_OutputImporterData.materialsIdentifiers.ToArray();// m_STImporter.m_Materials.ToArray(); + + int remappedMaterialCount = 0; + foreach (var entry in externalObjectMap) + { + bool isMatValid = Array.Exists(materialsList, x => x.name == entry.Key.name && entry.Value != null); + if (entry.Key.type == typeof(Material) && isMatValid) + ++remappedMaterialCount; + } + + m_HasEmbeddedMaterials = m_HasEmbeddedMaterials && remappedMaterialCount != materialsList.Length; + } + return m_HasEmbeddedMaterials; + } + + private void ShowMaterialGUI() + { + serializedObject.UpdateIfRequiredOrScript(); + + string materialHelp = string.Empty; + int arraySize = m_OutputImporterData.materialsIdentifiers.Count; + + if (arraySize > 0 && HasEmbeddedMaterials()) + { + // we're generating materials inside the prefab + materialHelp = Styles.InternalMaterialHelp.text; + } + + if (targets.Length == 1 && arraySize > 0) + { + materialHelp += " " + Styles.MaterialAssignmentsHelp.text; + } + + if (ExtractMaterialsGUI()) + { + // Necessary to avoid the error "BeginLayoutGroup must be called first". + GUIUtility.ExitGUI(); + return; + } + + if (!string.IsNullOrEmpty(materialHelp)) + { + EditorGUILayout.HelpBox(materialHelp, MessageType.Info); + } + + // The material remap list + if (targets.Length == 1 && arraySize > 0) + { + GUILayout.Label(Styles.ExternalMaterialMappings, EditorStyles.boldLabel); + + if (MaterialRemapOptions()) + return; + + // The list of material names is immutable, whereas the map of external objects can change based on user actions. + // For each material name, map the external object associated with it. + // The complexity comes from the fact that we may not have an external object in the map, so we can't make a property out of it + for (int materialIdx = 0; materialIdx < arraySize; ++materialIdx) + { + string name = m_OutputImporterData.materialsIdentifiers[materialIdx].name; + string type = m_OutputImporterData.materialsIdentifiers[materialIdx].type; + + SerializedProperty materialProp = null; + Material material = null; + int propertyIdx = 0; + + for (int externalObjectIdx = 0, count = m_ExternalObjects.arraySize; externalObjectIdx < count; ++externalObjectIdx) + { + SerializedProperty pair = m_ExternalObjects.GetArrayElementAtIndex(externalObjectIdx); + string externalName = pair.FindPropertyRelative("first.name").stringValue; + string externalType = pair.FindPropertyRelative("first.type").stringValue; + + // Cannot do a strict comparison, since externalType is set to "UnityEngine:Material" (C++) + // and type "UnityEngine.Material" (C#). + bool typeMatching = externalType.Contains("Material") && type.Contains("Material"); + + if (externalName == name && typeMatching) + { + materialProp = pair.FindPropertyRelative("second"); + material = materialProp != null ? materialProp.objectReferenceValue as Material : null; + + // If 'material' is null, it's likely because it was deleted. So we assign null to 'materialProp' + // to avoid the 'missing material' reference error in the UI. + materialProp = (material != null) ? pair.FindPropertyRelative("second") : null; + propertyIdx = externalObjectIdx; + break; + } + } + + GUIContent nameLabel = EditorGUIUtility.TextContent(name); + nameLabel.tooltip = name; + if (materialProp != null) + { + EditorGUI.BeginChangeCheck(); + EditorGUILayout.ObjectField(materialProp, typeof(Material), nameLabel); + if (EditorGUI.EndChangeCheck()) + { + if (materialProp.objectReferenceValue == null) + { + m_ExternalObjects.DeleteArrayElementAtIndex(propertyIdx); + } + } + } + else + { + EditorGUI.BeginChangeCheck(); + material = EditorGUILayout.ObjectField(nameLabel, material, typeof(Material), false) as Material; + if (EditorGUI.EndChangeCheck()) + { + if (material != null) + { + int newIndex = m_ExternalObjects.arraySize++; + SerializedProperty pair = m_ExternalObjects.GetArrayElementAtIndex(newIndex); + pair.FindPropertyRelative("first.name").stringValue = name; + pair.FindPropertyRelative("first.type").stringValue = type; + pair.FindPropertyRelative("second").objectReferenceValue = material; + } + } + } + } + } + } + + private bool ExtractMaterialsGUI() + { + bool buttonPressed = false; + + EditorGUILayout.BeginHorizontal(); + { + EditorGUILayout.PrefixLabel(Styles.Materials); + using (new EditorGUI.DisabledScope(!HasEmbeddedMaterials())) + { + buttonPressed = GUILayout.Button(Styles.ExtractEmbeddedMaterials); + + if (buttonPressed) + { + // use the first target for selecting the destination folder, but apply that path for all targets + string destinationPath = m_STImporter.assetPath; + destinationPath = EditorUtility.SaveFolderPanel(Styles.SelectMaterialFolder.text, + FileUtil.DeleteLastPathNameComponent(destinationPath), ""); + if (string.IsNullOrEmpty(destinationPath)) + { + // Cancel the extraction if the user did not select a folder. + EditorGUILayout.EndHorizontal(); + return buttonPressed; + } + destinationPath = FileUtil.GetProjectRelativePath(destinationPath); + + try + { + // batch the extraction of the materials + AssetDatabase.StartAssetEditing(); + + PrefabUtility.ExtractMaterialsFromAsset(targets, destinationPath); + } + finally + { + AssetDatabase.StopAssetEditing(); + } + } + } + } + EditorGUILayout.EndHorizontal(); + + // AssetDatabase.StopAssetEditing() invokes OnEnable(), which invalidates all the serialized properties, so we must return. + return buttonPressed; + } + + private bool MaterialRemapOptions() + { + bool buttonPressed = false; + + m_ShowMaterialRemapOptions = EditorGUILayout.Foldout(m_ShowMaterialRemapOptions, Styles.RemapOptions); + if (m_ShowMaterialRemapOptions) + { + EditorGUI.indentLevel++; + + EditorGUILayout.HelpBox(Styles.ExternalMaterialSearchHelp.text, MessageType.Info); + + EditorGUI.indentLevel--; + + using (new EditorGUILayout.HorizontalScope()) + { + GUILayout.FlexibleSpace(); + using (new EditorGUI.DisabledScope(assetTarget == null)) + { + buttonPressed = GUILayout.Button(Styles.RemapMaterialsInProject); + if (buttonPressed) + { + bool bStartedAssetEditing = false; + try + { + foreach (var t in targets) + { + string folderToSearch = m_STImporter.GetMaterialFolderPath(); + folderToSearch = EditorUtility.OpenFolderPanel(Styles.SelectMaterialFolder.text, folderToSearch, ""); + + bool bUserSelectedAFolder = folderToSearch != ""; // folderToSearch is empty if the user cancels the window + if (bUserSelectedAFolder) + { + string projectRelativePath = FileUtil.GetProjectRelativePath(folderToSearch); + bool bRelativePathIsNotEmpty = projectRelativePath != ""; + if (bRelativePathIsNotEmpty) + { + AssetDatabase.StartAssetEditing(); + bStartedAssetEditing = true; + m_STImporter.SearchAndRemapMaterials(projectRelativePath); + + AssetDatabase.WriteImportSettingsIfDirty(m_STImporter.assetPath); + AssetDatabase.ImportAsset(m_STImporter.assetPath, ImportAssetOptions.ForceUpdate); + } + else + { + Debug.LogWarning("Selected folder is outside of the project's folder hierarchy, please provide a folder from the project.\n"); + } + } + } + } + finally + { + if (bStartedAssetEditing) + { + AssetDatabase.StopAssetEditing(); + } + } + } + } + } + EditorGUILayout.Space(); + } + + return buttonPressed; + } + } +} diff --git a/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9ImporterModelEditor.cs b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9ImporterModelEditor.cs new file mode 100644 index 0000000000..549b0b0313 --- /dev/null +++ b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9ImporterModelEditor.cs @@ -0,0 +1,755 @@ +// Unity C# reference source +// Copyright (c) Unity Technologies. For terms of use, see +// https://unity3d.com/legal/licenses/Unity_Reference_Only_License + +using UnityEditor.AssetImporters; +using System; +using UnityEditor.AnimatedValues; +using UnityEngine; +using System.IO; +using System.Collections.Generic; +using static UnityEditor.SpeedTree.Importer.SpeedTree9Importer; + +using Styles = UnityEditor.SpeedTree.Importer.SpeedTreeImporterCommonEditor.Styles; + +namespace UnityEditor.SpeedTree.Importer +{ + class SpeedTree9ImporterModelEditor : BaseSpeedTree9ImporterTabUI + { + // Mesh properties + private SerializedProperty m_UnitConversion; + private SerializedProperty m_ScaleFactor; + + // Material properties + private SerializedProperty m_MainColor; + private SerializedProperty m_EnableHueVariation; + private SerializedProperty m_HueVariation; + private SerializedProperty m_AlphaClipThreshold; + private SerializedProperty m_TransmissionScale; + private SerializedProperty m_EnableBumpMapping; + private SerializedProperty m_EnableSubsurfaceScattering; + private SerializedProperty m_DiffusionProfileAssetID; + private SerializedProperty m_DiffusionProfileID; + + // Lighting properties + private SerializedProperty m_EnableShadowCasting; + private SerializedProperty m_EnableShadowReceiving; + private SerializedProperty m_EnableLightProbes; + private SerializedProperty m_ReflectionProbeEnumValue; + + // Additional Settings properties + private SerializedProperty m_MotionVectorModeEnumValue; + private SerializedProperty m_GenerateColliders; + private SerializedProperty m_GenerateRigidbody; + + // LOD properties + private SerializedProperty m_EnableSmoothLOD; + private SerializedProperty m_AnimateCrossFading; + private SerializedProperty m_BillboardTransitionCrossFadeWidth; + private SerializedProperty m_FadeOutWidth; + private SerializedProperty m_PerLODSettings; + + // LODGroup GUI + private int m_SelectedLODSlider = -1; + private int m_SelectedLODRange = 0; + private SavedBool[] m_LODGroupFoldoutHeaderValues = null; + private Texture2D[] m_LODColorTextures; + + private AnimBool m_ShowSmoothLODOptions = new AnimBool(); + private AnimBool m_ShowCrossFadeWidthOptions = new AnimBool(); + + private SpeedTree9Importer m_StEditor; + + public SpeedTree9ImporterModelEditor(AssetImporterEditor panelContainer) + : base(panelContainer) + { } + + internal override void OnEnable() + { + base.OnEnable(); + + m_StEditor = target as SpeedTree9Importer; + + // Mesh properties + { + MeshSettings meshSettings = m_StEditor.m_MeshSettings; + string meshSettingsStr = nameof(m_StEditor.m_MeshSettings); + + m_UnitConversion = FindPropertyFromName(meshSettingsStr, nameof(meshSettings.unitConversion)); + m_ScaleFactor = FindPropertyFromName(meshSettingsStr, nameof(meshSettings.scaleFactor)); + } + + // Material properties + { + MaterialSettings matSettings = m_StEditor.m_MaterialSettings; + string matSettingsStr = nameof(m_StEditor.m_MaterialSettings); + + m_MainColor = FindPropertyFromName(matSettingsStr, nameof(matSettings.mainColor)); + m_EnableHueVariation = FindPropertyFromName(matSettingsStr, nameof(matSettings.enableHueVariation)); + m_HueVariation = FindPropertyFromName(matSettingsStr, nameof(matSettings.hueVariation)); + m_AlphaClipThreshold = FindPropertyFromName(matSettingsStr, nameof(matSettings.alphaClipThreshold)); + m_TransmissionScale = FindPropertyFromName(matSettingsStr, nameof(matSettings.transmissionScale)); + m_EnableBumpMapping = FindPropertyFromName(matSettingsStr, nameof(matSettings.enableBumpMapping)); + m_EnableSubsurfaceScattering = FindPropertyFromName(matSettingsStr, nameof(matSettings.enableSubsurfaceScattering)); + + m_DiffusionProfileAssetID = FindPropertyFromName(matSettingsStr, nameof(matSettings.diffusionProfileAssetID)); + m_DiffusionProfileID = FindPropertyFromName(matSettingsStr, nameof(matSettings.diffusionProfileID)); + } + + // Lighting properties + { + LightingSettings lightSettings = m_StEditor.m_LightingSettings; + string lightSettingsStr = nameof(m_StEditor.m_LightingSettings); + + m_EnableShadowCasting = FindPropertyFromName(lightSettingsStr, nameof(lightSettings.enableShadowCasting)); + m_EnableShadowReceiving = FindPropertyFromName(lightSettingsStr, nameof(lightSettings.enableShadowReceiving)); + m_EnableLightProbes = FindPropertyFromName(lightSettingsStr, nameof(lightSettings.enableLightProbes)); + m_ReflectionProbeEnumValue = FindPropertyFromName(lightSettingsStr, nameof(lightSettings.reflectionProbeEnumValue)); + } + + // Additional Settings properties + { + AdditionalSettings addSettings = m_StEditor.m_AdditionalSettings; + string addSettingsStr = nameof(m_StEditor.m_AdditionalSettings); + + m_MotionVectorModeEnumValue = FindPropertyFromName(addSettingsStr, nameof(addSettings.motionVectorModeEnumValue)); + m_GenerateColliders = FindPropertyFromName(addSettingsStr, nameof(addSettings.generateColliders)); + m_GenerateRigidbody = FindPropertyFromName(addSettingsStr, nameof(addSettings.generateRigidbody)); + } + + // LOD properties + { + LODSettings lodSettings = m_StEditor.m_LODSettings; + string lodSettingsStr = nameof(m_StEditor.m_LODSettings); + + m_EnableSmoothLOD = FindPropertyFromName(lodSettingsStr, nameof(lodSettings.enableSmoothLODTransition)); + m_AnimateCrossFading = FindPropertyFromName(lodSettingsStr, nameof(lodSettings.animateCrossFading)); + m_BillboardTransitionCrossFadeWidth = FindPropertyFromName(lodSettingsStr, nameof(lodSettings.billboardTransitionCrossFadeWidth)); + m_FadeOutWidth = FindPropertyFromName(lodSettingsStr, nameof(lodSettings.fadeOutWidth)); + m_PerLODSettings = serializedObject.FindProperty(nameof(m_StEditor.m_PerLODSettings)); + } + + // Other + { + m_ShowSmoothLODOptions.value = m_EnableSmoothLOD.hasMultipleDifferentValues || m_EnableSmoothLOD.boolValue; + m_ShowSmoothLODOptions.valueChanged.AddListener(Repaint); + + m_ShowCrossFadeWidthOptions.value = m_AnimateCrossFading.hasMultipleDifferentValues || !m_AnimateCrossFading.boolValue; + m_ShowCrossFadeWidthOptions.valueChanged.AddListener(Repaint); + } + + ResetFoldoutLists(); + } + + internal override void OnDisable() + { + base.OnDisable(); + + m_ShowSmoothLODOptions.valueChanged.RemoveListener(Repaint); + m_ShowCrossFadeWidthOptions.valueChanged.RemoveListener(Repaint); + } + + void TriggerCallbacks() + { + var allMethods = AttributeHelper.GetMethodsWithAttribute().methodsWithAttributes; + foreach (var method in allMethods) + { + var callback = Delegate.CreateDelegate(typeof(OnCustomEditorSettings), method.info) as OnCustomEditorSettings; + callback?.Invoke(ref m_DiffusionProfileAssetID, ref m_DiffusionProfileID); + } + } + + public override void OnInspectorGUI() + { + serializedObject.Update(); + + // Mesh properties + SpeedTreeImporterCommonEditor.ShowMeshGUI(ref m_UnitConversion, ref m_ScaleFactor); + + EditorGUILayout.Space(); + + // Material Properties + SpeedTreeImporterCommonEditor.ShowMaterialGUI( + ref m_MainColor, + ref m_EnableHueVariation, + ref m_HueVariation, + ref m_AlphaClipThreshold, + ref m_EnableBumpMapping, + ref m_EnableSubsurfaceScattering, + renderHueVariationDropdown: m_EnableHueVariation.boolValue, + renderAlphaTestRef: m_OutputImporterData.hasAlphaClipThreshold + ); + + if (m_OutputImporterData.hasTransmissionScale) + { + EditorGUILayout.PropertyField(m_TransmissionScale, Styles.TransmissionScale); + } + + // Update the Diffuse Profile is necessary + TriggerCallbacks(); + + EditorGUILayout.Space(); + + // Lighting Properties + SpeedTreeImporterCommonEditor.ShowLightingGUI( + ref m_EnableShadowCasting, + ref m_EnableShadowReceiving, + ref m_EnableLightProbes, + ref m_ReflectionProbeEnumValue); + + EditorGUILayout.Space(); + + // Additional Settings + SpeedTreeImporterCommonEditor.ShowAdditionalSettingsGUI( + ref m_MotionVectorModeEnumValue, + ref m_GenerateColliders, + ref m_GenerateRigidbody); + + EditorGUILayout.Space(); + + // LOD properties + SpeedTreeImporterCommonEditor.ShowLODGUI( + ref m_EnableSmoothLOD, + ref m_AnimateCrossFading, + ref m_BillboardTransitionCrossFadeWidth, + ref m_FadeOutWidth, + ref m_ShowSmoothLODOptions, + ref m_ShowCrossFadeWidthOptions); + + EditorGUILayout.Space(); + + ShowLODGUI(); + + ShowMaterialWarnings(); + + serializedObject.ApplyModifiedProperties(); + } + + private void ShowMaterialWarnings() + { + EditorGUILayout.Space(); + + bool materialsNeedToBeUpgraded = upgradeMaterials; + + if (materialsNeedToBeUpgraded) + { + EditorGUILayout.HelpBox( + String.Format("SpeedTree materials need to be upgraded. " + + "Please back them up (if modified manually) then hit the \"{0}\" button below.", Styles.ApplyAndGenerate.text) + , MessageType.Warning + ); + } + else if (!materialsNeedToBeUpgraded && DoMaterialsHaveDifferentShader()) + { + EditorGUILayout.HelpBox( + String.Format("There is a different SpeedTree shader provided by the current render pipeline " + + "which probably is more suitable for rendering. Hit the \"{0}\" button to regenerate the materials." + , (panelContainer as SpeedTree9ImporterEditor).GetGenerateButtonText(HasModified() + , materialsNeedToBeUpgraded).text + ) + , MessageType.Warning + ); + } + } + + private SerializedProperty FindPropertyFromName(string parentProperty, string childProperty) + { + const string dotStr = "."; + + string finalName = String.Concat(parentProperty, dotStr, childProperty); + + return serializedObject.FindProperty(finalName); + } + + internal bool DoMaterialsHaveDifferentShader() + { + if (assetTargets is null || assetTargets.Length == 0) + { + return false; + } + + GameObject[] prefabs = new GameObject[assetTargets.Length]; + for (int i = 0; i < assetTargets.Length; ++i) + { + prefabs[i] = assetTargets[i] as GameObject; + } + + List importerArray = new List(); + foreach (SpeedTree9Importer importer in importers) + { + importerArray.Add(importer); + } + + string defaultShaderName = String.Empty; + if (TryGetShaderForCurrentRenderPipeline(out var shader)) + { + defaultShaderName = shader.name; + } + else + { + Debug.LogWarning("SpeedTree9 shader is invalid, cannot create Materials for this SpeedTree asset."); + } + + // In tests assetTargets can become null + for (int i = 0; i < Math.Min(importerArray.Count, prefabs?.Length ?? 0); ++i) + { + foreach (var mr in prefabs[i].transform.GetComponentsInChildren()) + { + foreach (var mat in mr.sharedMaterials) + { + if (mat?.shader.name != defaultShaderName) + return true; + } + } + } + + return false; + } + + // TODO: Abstract the following code, so it can be shared between ST8 and ST9. + + private void ShowLODGUI() + { + // LOD slider + Customizations + if (HasSameLODConfig()) + { + var area = GUILayoutUtility.GetRect(0, LODGroupGUI.kSliderBarHeight, GUILayout.ExpandWidth(true)); + var lods = GetLODInfoArray(area); + bool bDrawLODCustomizationGUI = m_SelectedLODRange != -1 && lods.Count > 0; + + EditorGUILayout.Space(); + + DrawLODLevelSlider(area, lods); + + if (bDrawLODCustomizationGUI) + { + GUILayout.Space(5); + DrawLODGroupFoldouts(lods); + } + } + + // Mixed Value LOD Slider + else + { + if (CanUnifyLODConfig()) + { + EditorGUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + Rect buttonRect = GUILayoutUtility.GetRect(Styles.ResetLOD, EditorStyles.miniButton); + if (GUI.Button(buttonRect, Styles.ResetLOD, EditorStyles.miniButton)) + { + var dropDownMenu = new GenericMenu(); + foreach (SpeedTree9Importer importer in importers) + { + float[] heights = importer.GetPerLODSettingsHeights(); + string[] heightsFormated = new string[heights.Length]; + for (int i = 0; i < heights.Length; ++i) + { + heightsFormated[i] = string.Format("{0:0}%", heights[i] * 100); + } + + var menuText = String.Format("{0}: {1}", + Path.GetFileNameWithoutExtension(importer.assetPath), + String.Join(" | ", heightsFormated)); + dropDownMenu.AddItem(new GUIContent(menuText), false, OnResetLODMenuClick, importer); + } + dropDownMenu.DropDown(buttonRect); + } + EditorGUILayout.EndHorizontal(); + } + else + { + EditorGUILayout.HelpBox(Styles.MultiSelectionLODNotSupported.text, MessageType.Info); + } + } + + EditorGUILayout.Space(); + } + + private readonly int m_LODSliderId = "LODSliderIDHash".GetHashCode(); + + private void DrawLODLevelSlider(Rect sliderPosition, List lods) + { + int sliderId = GUIUtility.GetControlID(m_LODSliderId, FocusType.Passive); + Event evt = Event.current; + + switch (evt.GetTypeForControl(sliderId)) + { + case EventType.Repaint: + { + LODGroupGUI.DrawLODSlider(sliderPosition, lods, m_SelectedLODRange); + break; + } + case EventType.MouseDown: + { + // Slightly grow position on the x because edge buttons overflow by 5 pixels + var barPosition = sliderPosition; + barPosition.x -= 5; + barPosition.width += 10; + + if (barPosition.Contains(evt.mousePosition)) + { + evt.Use(); + GUIUtility.hotControl = sliderId; + + // Check for button click + var clickedButton = false; + + // case:464019 have to re-sort the LOD array for these buttons to get the overlaps in the right order... + List lodsLeft = new List(); + List lodsRight = new List(); + + foreach (LODGroupGUI.LODInfo lodInfo in lods) + { + if (lodInfo.ScreenPercent > 0.5f) + { + lodsLeft.Add(lodInfo); + } + else + { + lodsRight.Add(lodInfo); + } + } + + // Descending order. + lodsLeft.Sort(new Comparison((i1, i2) => i2.LODLevel.CompareTo(i1.LODLevel))); + + // Ascending order. + lodsRight.Sort(new Comparison((i1, i2) => i1.LODLevel.CompareTo(i2.LODLevel))); + + var lodButtonOrder = new List(); + lodButtonOrder.AddRange(lodsLeft); + lodButtonOrder.AddRange(lodsRight); + + foreach (var lod in lodButtonOrder) + { + if (lod.m_ButtonPosition.Contains(evt.mousePosition)) + { + m_SelectedLODSlider = lod.LODLevel; + m_SelectedLODRange = lod.LODLevel; + clickedButton = true; + break; + } + } + + if (!clickedButton) + { + // Check for range click + foreach (var lod in lodButtonOrder) + { + if (lod.m_RangePosition.Contains(evt.mousePosition)) + { + m_SelectedLODSlider = -1; + m_SelectedLODRange = lod.LODLevel; + ExpandSelectedHeaderAndCloseRemaining(m_SelectedLODRange); + break; + } + } + } + } + break; + } + case EventType.MouseUp: + { + if (GUIUtility.hotControl == sliderId) + { + GUIUtility.hotControl = 0; + evt.Use(); + } + break; + } + case EventType.MouseDrag: + { + if (GUIUtility.hotControl == sliderId && m_SelectedLODSlider >= 0 && lods[m_SelectedLODSlider] != null) + { + evt.Use(); + + var cameraPercent = LODGroupGUI.GetCameraPercent(evt.mousePosition, sliderPosition); + // Bias by 0.1% so that there is no skipping when sliding + LODGroupGUI.SetSelectedLODLevelPercentage(cameraPercent - 0.001f, m_SelectedLODSlider, lods); + m_PerLODSettings.GetArrayElementAtIndex(m_SelectedLODSlider).FindPropertyRelative("height").floatValue = lods[m_SelectedLODSlider].RawScreenPercent; + } + break; + } + } + } + + private void DrawLODGroupFoldouts(List lods) + { + // check camera and bail if null + Camera camera = null; + if (SceneView.lastActiveSceneView && SceneView.lastActiveSceneView.camera) + camera = SceneView.lastActiveSceneView.camera; + if (camera == null) + return; + + // draw lod foldouts + for (int i = 0; i < m_PerLODSettings.arraySize; i++) + { + DrawLODGroupFoldout(camera, i, ref m_LODGroupFoldoutHeaderValues[i], lods); + } + } + + private string GetLODSubmeshAndTriCountLabel(int numLODs, int lodGroupIndex, SpeedTree9Importer im, LODGroup lodGroup) + { + LOD[] lods = lodGroup.GetLODs(); + + if(lods.Length != numLODs) + { + Debug.LogWarningFormat("Number of LODs mismatch between serialized object & LODGroup: {0}\nPlease re-import the asset and kindly report a bug if this warning keeps coming back.", im.assetPath); + numLODs = lods.Length; + } + + int[][] primitiveCounts = new int[numLODs][]; + int[] submeshCounts = new int[numLODs]; + for (int i = 0; i < lods.Length; i++) + { + Renderer[] renderers = lods[i].renderers; + primitiveCounts[i] = new int[renderers.Length]; + + for (int j = 0; j < renderers.Length; j++) + { + bool hasMismatchingSubMeshTopologyTypes = LODGroupEditor.CheckIfMeshesHaveMatchingTopologyTypes(renderers); + + Mesh rendererMesh = LODGroupEditor.GetMeshFromRendererIfAvailable(renderers[j]); + if (rendererMesh == null) + continue; + + submeshCounts[i] += rendererMesh.subMeshCount; + + if (hasMismatchingSubMeshTopologyTypes) + { + primitiveCounts[i][j] = rendererMesh.vertexCount; + } + else + { + for (int subMeshIndex = 0; subMeshIndex < rendererMesh.subMeshCount; subMeshIndex++) + { + primitiveCounts[i][j] += (int)rendererMesh.GetIndexCount(subMeshIndex) / 3; + } + } + } + } + + int totalTriCount = 0; + if (primitiveCounts.Length > 0 && primitiveCounts[lodGroupIndex] != null) + { + Array.ForEach(primitiveCounts[lodGroupIndex], delegate (int i) { totalTriCount += i; }); + } + + int sumPrimitiveCounts = 0; + Array.ForEach(primitiveCounts[0], delegate (int i) { sumPrimitiveCounts += i; }); + + int lod0TriCount = sumPrimitiveCounts; + + var triCountChange = lod0TriCount != 0 ? (float)totalTriCount / lod0TriCount * 100 : 0; + string triangleChangeLabel = lodGroupIndex > 0 && lod0TriCount != 0 ? $"({triCountChange.ToString("f2")}% LOD0)" : ""; + + bool wideInspector = Screen.width >= 480; + triangleChangeLabel = wideInspector ? triangleChangeLabel : ""; + string submeshCountLabel = wideInspector ? $"- {submeshCounts[lodGroupIndex]} Sub Mesh(es)" : ""; + + return $"{totalTriCount} {LODGroupGUI.GUIStyles.m_TriangleCountLabel.text} {triangleChangeLabel} {submeshCountLabel}"; + } + + private Color GetLODGroupColor(int lodIndex) + { + return LODGroupGUI.kLODColors[lodIndex % LODGroupGUI.kLODColors.Length]; + } + + private void DrawLODGroupFoldout(Camera camera, int lodGroupIndex, ref SavedBool foldoutState, List lodInfoList) + { + GameObject[] ObjectArrayToGameObjectArray(UnityEngine.Object[] objects) + { + if (objects == null) + return null; + + GameObject[] gameObjects = new GameObject[objects.Length]; + + for (int i = 0; i < objects.Length; ++i) + { + gameObjects[i] = objects[i] as GameObject; + } + + return gameObjects; + } + + List importersList = new List(importers); + + GameObject[] prefabs = ObjectArrayToGameObjectArray(assetTargets); // In tests assetTargets can become null + SpeedTree9Importer[] importerArray = importersList.ToArray(); + + int numSelectedAssets = Math.Min(importerArray.Length, prefabs?.Length ?? 0); + bool isDrawingSelectedLODGroup = m_SelectedLODRange == lodGroupIndex; + + // even though multiple assets may be selected, this code path + // ensures the numLODs match for all the selected assets (see HasSameLODConfig() calls) + int numLODs = m_PerLODSettings.arraySize; + bool hasBillboard = m_OutputImporterData.hasBillboard; + + string LODFoldoutHeaderLabel = (hasBillboard && lodGroupIndex == m_PerLODSettings.arraySize - 1) + ? "Billboard" + : $"LOD {lodGroupIndex}"; + + // primitive and submesh counts are displayed only when a single asset is selected + string LODFoldoutHeaderGroupAdditionalText = numSelectedAssets == 1 + ? GetLODSubmeshAndTriCountLabel(numLODs, lodGroupIndex, importerArray[0], prefabs[0].GetComponentInChildren()) + : ""; + + // ------------------------------------------------------------------------------------------------------------------------------ + + if (isDrawingSelectedLODGroup) + LODGroupGUI.DrawRoundedBoxAroundLODDFoldout(lodGroupIndex, m_SelectedLODRange); + else + EditorGUILayout.BeginVertical(EditorStyles.helpBox); + + foldoutState.value = LODGroupGUI.FoldoutHeaderGroupInternal( + GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.inspectorTitlebarFlat) + , foldoutState.value + , LODFoldoutHeaderLabel + , m_LODColorTextures[lodGroupIndex] + , GetLODGroupColor(lodGroupIndex) * 0.6f // 0.5f magic number is copied from LODGroupsGUI.cs + , LODFoldoutHeaderGroupAdditionalText + ); + + if (foldoutState.value) // expanded LOD-specific options panel + { + DrawLODSettingCustomizationGUI(lodInfoList, lodGroupIndex); + } + + if (isDrawingSelectedLODGroup) + GUILayoutUtility.EndLayoutGroup(); + else + EditorGUILayout.EndVertical(); + } + + private void DrawLODSettingCustomizationGUI(List lods, int lodIndex) + { + bool isBillboard = (lodIndex == lods.Count - 1) && m_OutputImporterData.hasBillboard; + + SerializedProperty selectedLODProp = m_PerLODSettings.GetArrayElementAtIndex(lodIndex); + SerializedProperty lodSettingOverride = selectedLODProp.FindPropertyRelative("enableSettingOverride"); + + // We don't want to clutter the GUI with same options but for billboards, instead + // we treat the Billboard LOD level as always 'overrideSettings' and display the + // billboard options below without the 'enableSettingOverride' warning text. + if (isBillboard) + { + EditorGUILayout.LabelField("Billboard Options", EditorStyles.boldLabel); + EditorGUILayout.HelpBox(Styles.BillboardSettingsHelp.text, MessageType.Info); + } + else + { + // Toggle + GUIContent customizationLabel = EditorGUIUtility.TrTextContent(String.Format("Customize {0} options", lods[lodIndex].LODName), "To override options for a certain LOD, check this box and select the LOD from the LOD slider above"); + EditorGUILayout.PropertyField(lodSettingOverride, customizationLabel); + + // Warning + if (lodSettingOverride.boolValue) + { + EditorGUILayout.HelpBox(Styles.EnableLodCustomizationsWarn.text, MessageType.Warning); + } + } + EditorGUILayout.Space(); + + // settings + using (new EditorGUI.DisabledScope(!lodSettingOverride.boolValue)) + { + EditorGUILayout.Space(); + EditorGUILayout.LabelField("Lighting", EditorStyles.boldLabel); + EditorGUILayout.PropertyField(selectedLODProp.FindPropertyRelative("castShadows"), Styles.CastShadows); + + using (new EditorGUI.DisabledScope(!UnityEngine.Rendering.SupportedRenderingFeatures.active.receiveShadows)) + { + EditorGUILayout.PropertyField(selectedLODProp.FindPropertyRelative("receiveShadows"), Styles.ReceiveShadows); + } + + var useLightProbes = selectedLODProp.FindPropertyRelative("useLightProbes"); + EditorGUILayout.PropertyField(useLightProbes, Styles.UseLightProbes); + if (!useLightProbes.hasMultipleDifferentValues && useLightProbes.boolValue && isBillboard) + EditorGUILayout.HelpBox("Enabling Light Probe for billboards breaks batched rendering and may cause performance problem.", MessageType.Warning); + + // TODO: reflection probe support when PBS is implemented + //EditorGUILayout.PropertyField(SelectedLODProp.FindPropertyRelative("useReflectionProbes"), Styles.UseReflectionProbes); + + EditorGUILayout.Space(); + EditorGUILayout.LabelField("Material", EditorStyles.boldLabel); + EditorGUILayout.PropertyField(selectedLODProp.FindPropertyRelative("enableHue"), Styles.EnableColorVariation); + EditorGUILayout.PropertyField(selectedLODProp.FindPropertyRelative("enableBump"), Styles.EnableBump); + + EditorGUILayout.PropertyField(selectedLODProp.FindPropertyRelative("enableSubsurface"), Styles.EnableSubsurface); + } + } + + private void OnResetLODMenuClick(object userData) + { + //var toHeights = (userData as SpeedTreeImporter).LODHeights; + for (int i = 0; i < m_StEditor.m_PerLODSettings.Count; ++i) + { + var toHeight = m_StEditor.m_PerLODSettings[i].height; + m_PerLODSettings.GetArrayElementAtIndex(i).FindPropertyRelative("height").floatValue = toHeight; + } + } + + private bool HasSameLODConfig() + { + if (m_PerLODSettings.FindPropertyRelative("Array.size").hasMultipleDifferentValues) + return false; + + for (int i = 0; i < m_PerLODSettings.arraySize; ++i) + { + if (m_PerLODSettings.GetArrayElementAtIndex(i).FindPropertyRelative("height").hasMultipleDifferentValues) + return false; + } + return true; + } + + private void ExpandSelectedHeaderAndCloseRemaining(int index) + { + // need this to safeguard against drag & drop on Culled section + // as that sets the LOD index to 8 which is outside of the total + // allowed LOD range + if (index >= m_PerLODSettings.arraySize) + return; + + Array.ForEach(m_LODGroupFoldoutHeaderValues, el => el.value = false); + m_LODGroupFoldoutHeaderValues[index].value = true; + } + + private List GetLODInfoArray(Rect area) + { + int lodCount = m_PerLODSettings.arraySize; + return LODGroupGUI.CreateLODInfos( + lodCount, area, + i => i == lodCount - 1 && m_OutputImporterData.hasBillboard ? "Billboard" : String.Format("LOD {0}", i), + i => m_PerLODSettings.GetArrayElementAtIndex(i).FindPropertyRelative("height").floatValue); + } + + private bool CanUnifyLODConfig() + { + // TODO: Add multi-selection support for LOD UI. + return false; + } + + void InitAndSetFoldoutLabelTextures() + { + m_LODColorTextures = new Texture2D[m_PerLODSettings.arraySize]; + for (int i = 0; i < m_LODColorTextures.Length; i++) + { + m_LODColorTextures[i] = new Texture2D(1, 1); + m_LODColorTextures[i].SetPixel(0, 0, GetLODGroupColor(i)); + } + } + + void ResetFoldoutLists() + { + int lodArraySize = Mathf.Min(m_PerLODSettings.arraySize, LODGroupGUI.kLODColors.Length); + m_LODGroupFoldoutHeaderValues = new SavedBool[lodArraySize]; + for (int i = 0; i < lodArraySize; i++) + { + m_LODGroupFoldoutHeaderValues[i] = new SavedBool($"{target.GetType()}.lodFoldout{i}", false); + } + InitAndSetFoldoutLabelTextures(); + } + } +} diff --git a/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9ImporterWindEditor.cs b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9ImporterWindEditor.cs new file mode 100644 index 0000000000..8f6e6fd9ab --- /dev/null +++ b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9ImporterWindEditor.cs @@ -0,0 +1,70 @@ +// Unity C# reference source +// Copyright (c) Unity Technologies. For terms of use, see +// https://unity3d.com/legal/licenses/Unity_Reference_Only_License + +using UnityEditor.AssetImporters; +using System; +using UnityEngine; + +namespace UnityEditor.SpeedTree.Importer +{ + class SpeedTree9ImporterWindEditor : BaseSpeedTree9ImporterTabUI + { + private class Styles + { + public static GUIContent EnableWind = EditorGUIUtility.TrTextContent("Enable Wind"); + public static GUIContent StrengthResponse = EditorGUIUtility.TrTextContent("Strength Response", "The strength response of the wind."); + public static GUIContent DirectionResponse = EditorGUIUtility.TrTextContent("Direction Response", "The direction response of the wind."); + public static GUIContent WindRandomness = EditorGUIUtility.TrTextContent("Randomness", "Amount of world position based noise applied to each tree."); + } + + private SerializedProperty m_EnableWind; + private SerializedProperty m_StrengthResponse; + private SerializedProperty m_DirectionResponse; + private SerializedProperty m_WindRandomness; + + private SpeedTree9Importer m_StEditor; + + public SpeedTree9ImporterWindEditor(AssetImporterEditor panelContainer) + : base(panelContainer) + { } + + internal override void OnEnable() + { + m_StEditor = target as SpeedTree9Importer; + + WindSettings windSettings = m_StEditor.m_WindSettings; + string windSettingsStr = nameof(m_StEditor.m_WindSettings); + + m_EnableWind = FindPropertyFromName(windSettingsStr, nameof(windSettings.enableWind)); + m_StrengthResponse = FindPropertyFromName(windSettingsStr, nameof(windSettings.strenghResponse)); + m_DirectionResponse = FindPropertyFromName(windSettingsStr, nameof(windSettings.directionResponse)); + m_WindRandomness = FindPropertyFromName(windSettingsStr, nameof(windSettings.randomness)); + } + + public override void OnInspectorGUI() + { + serializedObject.Update(); + + EditorGUILayout.PropertyField(m_EnableWind, Styles.EnableWind); + + using (new EditorGUI.DisabledScope(!m_EnableWind.boolValue)) + { + EditorGUILayout.PropertyField(m_StrengthResponse, Styles.StrengthResponse); + EditorGUILayout.PropertyField(m_DirectionResponse, Styles.DirectionResponse); + EditorGUILayout.PropertyField(m_WindRandomness, Styles.WindRandomness); + } + + serializedObject.ApplyModifiedProperties(); + } + + private SerializedProperty FindPropertyFromName(string parentProperty, string childProperty) + { + const string dotStr = "."; + + string finalName = String.Concat(parentProperty, dotStr, childProperty); + + return serializedObject.FindProperty(finalName); + } + } +} diff --git a/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9Reader.cs b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9Reader.cs new file mode 100644 index 0000000000..99e3a64086 --- /dev/null +++ b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9Reader.cs @@ -0,0 +1,634 @@ +// 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.IO; +using System.Runtime.InteropServices; +using UnityEngine; + +namespace UnityEditor.SpeedTree.Importer +{ + #region Data Classes + + [StructLayout(LayoutKind.Sequential, Pack = 4)] + struct Vec2 + { + private float x, y; + + public float X + { + get { return x; } + set { x = value; } + } + + public float Y + { + get { return y; } + set { y = value; } + } + } + + [StructLayout(LayoutKind.Sequential, Pack = 4)] + struct Vec3 + { + private float x, y, z; + + public float X + { + get { return x; } + set { x = value; } + } + + public float Y + { + get { return y; } + set { y = value; } + } + + public float Z + { + get { return z; } + set { z = value; } + } + } + + [StructLayout(LayoutKind.Sequential, Pack = 4)] + struct Vec4 + { + private float x, y, z, w; + + public float X + { + get { return x; } + set { x = value; } + } + + public float Y + { + get { return y; } + set { y = value; } + } + + public float Z + { + get { return z; } + set { z = value; } + } + + public float W + { + get { return w; } + set { w = value; } + } + } + + [StructLayout(LayoutKind.Sequential, Pack = 4)] + struct Bounds3 + { + public Vec3 Min { get; private set; } + public Vec3 Max { get; private set; } + } + + [StructLayout(LayoutKind.Sequential, Pack = 4)] + struct Vertex + { + public Vec3 Anchor { get; private set; } + public Vec3 Offset { get; private set; } + public Vec3 LodOffset { get; private set; } + public Vec3 Normal { get; private set; } + public Vec3 Tangent { get; private set; } + public Vec3 Binormal { get; private set; } + public Vec2 TexCoord { get; private set; } + public Vec2 LightmapTexCoord { get; private set; } + public Vec3 Color { get; private set; } + public float AmbientOcclusion { get; private set; } + public float BlendWeight { get; private set; } + public Vec3 BranchWind1 { get; private set; } // pos, dir, weight + public Vec3 BranchWind2 { get; private set; } + public float RippleWeight { get; private set; } + public bool CameraFacing { get; private set; } + public uint BoneID { get; private set; } + } + + [StructLayout(LayoutKind.Sequential, Pack = 4)] + struct DrawCall + { + public uint MaterialIndex { get; private set; } + public bool ContainsFacingGeometry { get; private set; } + public uint IndexStart { get; private set; } + public uint IndexCount { get; private set; } + } + + [StructLayout(LayoutKind.Sequential, Pack = 4)] + struct Bone + { + public uint ID { get; private set; } + public bool ParentID { get; private set; } + public Vec3 Start { get; private set; } + public Vec3 End { get; private set; } + public float Radius { get; private set; } + } + + #endregion + + #region Data Tables + interface ReaderData + { + public void Initialize(Byte[] data, int offset); + } + + class Lod : ReaderData + { + private enum OffsetData + { + Vertices = 0, + Indices = 1, + DrawCalls = 2 + } + + public Vertex[] Vertices { get; private set; } + public uint[] Indices { get; private set; } + public DrawCall[] DrawCalls { get; private set; } + + public void Initialize(Byte[] data, int offset) + { + Vertices = SpeedTree9ReaderUtility.GetArray(data, offset, (int)OffsetData.Vertices); + Indices = SpeedTree9ReaderUtility.GetArray(data, offset, (int)OffsetData.Indices); + DrawCalls = SpeedTree9ReaderUtility.GetArray(data, offset, (int)OffsetData.DrawCalls); + } + } + + class BillboardInfo : ReaderData + { + private enum OffsetData + { + LastLodIsBillboard = 0, + IncludesTopDown = 1, + SideViewCount = 2 + } + + public bool LastLodIsBillboard { get; private set; } + public bool IncludesTopDown { get; private set; } + public uint SideViewCount { get; private set; } + + public void Initialize(Byte[] data, int offset) + { + LastLodIsBillboard = SpeedTree9ReaderUtility.GetBool(data, offset, (int)OffsetData.LastLodIsBillboard); + IncludesTopDown = SpeedTree9ReaderUtility.GetBool(data, offset, (int)OffsetData.IncludesTopDown); + SideViewCount = SpeedTree9ReaderUtility.GetUInt(data, offset, (int)OffsetData.SideViewCount); + } + } + + class CollisionObject : ReaderData + { + private enum OffsetData + { + Position = 0, + Position2 = 1, + Radius = 2, + UserData = 3 + } + + public Vec3 Position { get; private set; } + public Vec3 Position2 { get; private set; } + public float Radius { get; private set; } + public string UserData { get; private set; } + + public void Initialize(Byte[] data, int offset) + { + Position = SpeedTree9ReaderUtility.GetStruct(data, offset, (int)OffsetData.Position); + Position2 = SpeedTree9ReaderUtility.GetStruct(data, offset, (int)OffsetData.Position2); + Radius = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.Radius); + UserData = SpeedTree9ReaderUtility.GetString(data, offset, (int)OffsetData.UserData); + } + } + + class MaterialMap : ReaderData + { + private enum OffsetData + { + Used = 0, + Path = 1, + Color = 2 + } + + public bool Used { get; private set; } + public string Path { get; private set; } + public Vec4 Color { get; private set; } + + public void Initialize(Byte[] data, int offset) + { + Used = SpeedTree9ReaderUtility.GetBool(data, offset, (int)OffsetData.Used); + Path = SpeedTree9ReaderUtility.GetString(data, offset, (int)OffsetData.Path); + Color = SpeedTree9ReaderUtility.GetStruct(data, offset, (int)OffsetData.Color); + } + } + + class STMaterial : ReaderData + { + private enum OffsetData + { + Name = 0, + TwoSided = 1, + FlipNormalsOnBackside = 2, + Billboard = 3, + Maps = 4 + } + + public string Name { get; private set; } + public bool TwoSided { get; private set; } + public bool FlipNormalsOnBackside { get; private set; } + public bool Billboard { get; private set; } + public MaterialMap[] Maps { get; private set; } + + public void Initialize(Byte[] data, int offset) + { + Name = SpeedTree9ReaderUtility.GetString(data, offset, (int)OffsetData.Name); + TwoSided = SpeedTree9ReaderUtility.GetBool(data, offset, (int)OffsetData.TwoSided); + FlipNormalsOnBackside = SpeedTree9ReaderUtility.GetBool(data, offset, (int)OffsetData.FlipNormalsOnBackside); + Billboard = SpeedTree9ReaderUtility.GetBool(data, offset, (int)OffsetData.Billboard); + Maps = SpeedTree9ReaderUtility.GetDataObjectArray(data, offset, (int)OffsetData.Maps); + } + } + #endregion + + #region Wind Data Tables + class WindConfigCommon : ReaderData + { + private enum OffsetData + { + StrengthResponse = 0, + DirectionResponse = 1, + GustFrequency = 5, + GustStrengthMin = 6, + GustStrengthMax = 7, + GustDurationMin = 8, + GustDurationMax = 9, + GustRiseScalar = 10, + GustFallScalar = 11, + CurrentStrength = 15 + } + + public float StrengthResponse { get; private set; } + public float DirectionResponse { get; private set; } + public float GustFrequency { get; private set; } + public float GustStrengthMin { get; private set; } + public float GustStrengthMax { get; private set; } + public float GustDurationMin { get; private set; } + public float GustDurationMax { get; private set; } + public float GustRiseScalar { get; private set; } + public float GustFallScalar { get; private set; } + public float CurrentStrength { get; private set; } + + public void Initialize(Byte[] data, int offset) + { + StrengthResponse = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.StrengthResponse); + DirectionResponse = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.DirectionResponse); + GustFrequency = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.GustFrequency); + GustStrengthMin = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.GustStrengthMin); + GustStrengthMax = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.GustStrengthMax); + GustDurationMin = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.GustDurationMin); + GustDurationMax = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.GustDurationMax); + GustRiseScalar = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.GustRiseScalar); + GustFallScalar = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.GustFallScalar); + CurrentStrength = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.CurrentStrength); + } + }; + + class WindConfigSDK : ReaderData + { + internal class WindBranch : ReaderData + { + private enum OffsetData + { + Bend = 0, + Oscillation = 1, + Speed = 2, + Turbulence = 3, + Flexibility = 4, + Independence = 5 + } + + public float[] Bend { get; private set; } + public float[] Oscillation { get; private set; } + public float[] Speed { get; private set; } + public float[] Turbulence { get; private set; } + public float[] Flexibility { get; private set; } + public float Independence { get; private set; } + + public void Initialize(Byte[] data, int offset) + { + Bend = SpeedTree9ReaderUtility.GetArray(data, offset, (int)OffsetData.Bend); + Oscillation = SpeedTree9ReaderUtility.GetArray(data, offset, (int)OffsetData.Oscillation); + Speed = SpeedTree9ReaderUtility.GetArray(data, offset, (int)OffsetData.Speed); + Turbulence = SpeedTree9ReaderUtility.GetArray(data, offset, (int)OffsetData.Turbulence); + Flexibility = SpeedTree9ReaderUtility.GetArray(data, offset, (int)OffsetData.Flexibility); + Independence = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.Independence); + } + }; + + internal class WindRipple : ReaderData + { + private enum OffsetData + { + Planar = 0, + Directional = 1, + Speed = 2, + Flexibility = 3, + Shimmer = 4, + Independence = 5 + } + + public float[] Planar { get; private set; } + public float[] Directional { get; private set; } + public float[] Speed { get; private set; } + public float[] Flexibility { get; private set; } + public float Shimmer { get; private set; } + public float Independence { get; private set; } + + public void Initialize(Byte[] data, int offset) + { + Planar = SpeedTree9ReaderUtility.GetArray(data, offset, (int)OffsetData.Planar); + Directional = SpeedTree9ReaderUtility.GetArray(data, offset, (int)OffsetData.Directional); + Speed = SpeedTree9ReaderUtility.GetArray(data, offset, (int)OffsetData.Speed); + Flexibility = SpeedTree9ReaderUtility.GetArray(data, offset, (int)OffsetData.Flexibility); + Shimmer = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.Shimmer); + Independence = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.Independence); + } + }; + + private enum OffsetData + { + Common = 0, + Shared = 1, + Branch1 = 2, + Branch2 = 3, + Ripple = 4, + SharedStartHeight = 10, + Branch1StretchLimit = 11, + Branch2StretchLimit = 12, + DoShared = 15, + DoBranch1 = 16, + DoBranch2 = 17, + DoRipple = 18, + DoShimmer = 19 + } + + public WindConfigCommon Common { get; private set; } + public WindBranch Shared { get; private set; } + public WindBranch Branch1 { get; private set; } + public WindBranch Branch2 { get; private set; } + public WindRipple Ripple { get; private set; } + + public float SharedStartHeight { get; private set; } + public float Branch1StretchLimit { get; private set; } + public float Branch2StretchLimit { get; private set; } + + public bool DoShared { get; private set; } + public bool DoBranch1 { get; private set; } + public bool DoBranch2 { get; private set; } + public bool DoRipple { get; private set; } + public bool DoShimmer { get; private set; } + + public void Initialize(Byte[] data, int offset) + { + Common = SpeedTree9ReaderUtility.GetDataObject(data, offset, (int)OffsetData.Common); + Shared = SpeedTree9ReaderUtility.GetDataObject(data, offset, (int)OffsetData.Shared); + Branch1 = SpeedTree9ReaderUtility.GetDataObject(data, offset, (int)OffsetData.Branch1); + Branch2 = SpeedTree9ReaderUtility.GetDataObject(data, offset, (int)OffsetData.Branch2); + Ripple = SpeedTree9ReaderUtility.GetDataObject(data, offset, (int)OffsetData.Ripple); + + SharedStartHeight = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.SharedStartHeight); + Branch1StretchLimit = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.Branch1StretchLimit); + Branch2StretchLimit = SpeedTree9ReaderUtility.GetFloat(data, offset, (int)OffsetData.Branch2StretchLimit); + + DoShared = SpeedTree9ReaderUtility.GetBool(data, offset, (int)OffsetData.DoShared); + DoBranch1 = SpeedTree9ReaderUtility.GetBool(data, offset, (int)OffsetData.DoBranch1); + DoBranch2 = SpeedTree9ReaderUtility.GetBool(data, offset, (int)OffsetData.DoBranch2); + DoRipple = SpeedTree9ReaderUtility.GetBool(data, offset, (int)OffsetData.DoRipple); + DoShimmer = SpeedTree9ReaderUtility.GetBool(data, offset, (int)OffsetData.DoShimmer); + } + }; + #endregion + + #region Reader Utilities + static class SpeedTree9ReaderUtility + { + public static int GetOffset(in Byte[] data, int offsetIn, int index) + { + int offset = offsetIn + (index + 1) * 4; + return offsetIn + (int)BitConverter.ToUInt32(data, offset); + } + + public static float GetFloat(in Byte[] data, int offsetIn, int index) + { + return BitConverter.ToSingle(data, GetOffset(data, offsetIn, index)); + } + + public static string GetString(in Byte[] data, int offsetIn, int index) + { + int offset = GetOffset(data, offsetIn, index); + int length = (int)BitConverter.ToUInt32(data, offset); + return System.Text.Encoding.UTF8.GetString(data, offset + 4, length - 1); + } + + public static T GetStruct(in Byte[] data, int offsetIn, int index) where T : struct + { + int offset = GetOffset(data, offsetIn, index); + return MemoryMarshal.Cast(data.AsSpan().Slice(offset))[0]; + } + + public static bool GetBool(in Byte[] data, int offsetIn, int index) + { + return GetInt(data, offsetIn, index) != 0; + } + + public static int GetInt(in Byte[] data, int offsetIn, int index) + { + return BitConverter.ToInt32(data, GetOffset(data, offsetIn, index)); + } + + public static uint GetUInt(in Byte[] data, int offsetIn, int index) + { + return BitConverter.ToUInt32(data, GetOffset(data, offsetIn, index)); + } + + public static T[] GetArray(Byte[] data, int offset, int type) where T : struct + { + int offsetData = SpeedTree9ReaderUtility.GetOffset(data, offset, (int)type); + uint countData = BitConverter.ToUInt32(data, offsetData); + + T[] array = new T[countData]; + + for (int i = 0; i < countData; i++) + { + array[i] = MemoryMarshal.Cast(data.AsSpan().Slice(offsetData + 4))[i]; + } + + return array; + } + + public static T GetDataObject(in Byte[] data, int offset, int index) where T : ReaderData, new() + { + int dataOffset = SpeedTree9ReaderUtility.GetOffset(data, offset, index); + + T readData = new T(); + readData.Initialize(data, dataOffset); + + return readData; + } + + public static T[] GetDataObjectArray(in Byte[] data, int offset, int index) where T : ReaderData, new() + { + int dataOffset = SpeedTree9ReaderUtility.GetOffset(data, offset, index); + uint dataCount = BitConverter.ToUInt32(data, dataOffset); + + T[] readData = new T[dataCount]; + + for (int i = 0; i < dataCount; i++) + { + int offsetNew = SpeedTree9ReaderUtility.GetOffset(data, dataOffset, i); + + T newData = new T(); + newData.Initialize(data, offsetNew); + + readData[i] = newData; + } + + return readData; + } + } + #endregion + + internal class SpeedTree9Reader : IDisposable + { + internal enum FileStatus + { + Valid = 0, + InvalidPath = 1, + InvalidSignature = 2 + } + + enum OffsetData + { + VersionMajor = 0, + VersionMinor = 1, + Bounds = 2, + Lod = 5, + BillboardInfo = 6, + CollisionObjects = 7, + Materials = 10, + Wind = 15 + } + + const string k_TokenKey = "SpeedTree9______"; + + public uint VersionMajor { get; private set; } + public uint VersionMinor { get; private set; } + public Bounds3 Bounds { get; private set; } + public Lod[] Lod { get; private set; } + public BillboardInfo BillboardInfo { get; private set; } + public CollisionObject[] CollisionObjects { get; private set; } + public STMaterial[] Materials { get; private set; } + public WindConfigSDK Wind { get; private set; } + + private string m_AssetPath; + private FileStream m_FileStream; + private int m_Offset; + private bool m_Disposed; + + public FileStatus Initialize(string assetPath) + { + m_AssetPath = assetPath; + m_FileStream = new FileStream(m_AssetPath, FileMode.Open, FileAccess.Read); + + if (!File.Exists(assetPath)) + { + return FileStatus.InvalidPath; + } + + if (!ValidateFileSignature()) + { + return FileStatus.InvalidSignature; + } + + return FileStatus.Valid; + } + + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + protected void Dispose(bool disposing) + { + if (!m_Disposed) + { + // Manual release of managed resources. + if (disposing) + { + if (m_FileStream != null) + { + m_FileStream.Close(); + } + } + + // Release unmanaged resources. + m_Disposed = true; + } + } + + public void ReadContent() + { + byte[] data = File.ReadAllBytes(m_AssetPath); + + VersionMajor = SpeedTree9ReaderUtility.GetUInt(data, m_Offset, (int)OffsetData.VersionMajor); + VersionMinor = SpeedTree9ReaderUtility.GetUInt(data, m_Offset, (int)OffsetData.VersionMinor); + Bounds = SpeedTree9ReaderUtility.GetStruct(data, m_Offset, (int)OffsetData.Bounds); + Lod = SpeedTree9ReaderUtility.GetDataObjectArray(data, m_Offset, (int)OffsetData.Lod); + BillboardInfo = SpeedTree9ReaderUtility.GetDataObject(data, m_Offset, (int)OffsetData.BillboardInfo); + CollisionObjects = SpeedTree9ReaderUtility.GetDataObjectArray(data, m_Offset, (int)OffsetData.CollisionObjects); + Materials = SpeedTree9ReaderUtility.GetDataObjectArray(data, m_Offset, (int)OffsetData.Materials); + Wind = SpeedTree9ReaderUtility.GetDataObject(data, m_Offset, (int)OffsetData.Wind); + + if (m_FileStream != null) + { + m_FileStream.Close(); + } + } + + private unsafe bool ValidateFileSignature() + { + byte[] buffer = new byte[k_TokenKey.Length]; + + try + { + int bytesRead = m_FileStream.Read(buffer, m_Offset, k_TokenKey.Length); + + if (bytesRead != buffer.Length) + { + return false; + } + } + catch (UnauthorizedAccessException ex) + { + Debug.LogError(ex.Message); + } + + bool valid = true; + for (int i = 0; i < k_TokenKey.Length && valid; ++i) + { + valid &= (k_TokenKey[i] == buffer[i]); + } + + if (valid) + { + m_Offset = k_TokenKey.Length; + } + + return valid; + } + } +} diff --git a/Editor/Mono/AssetPipeline/SpeedTree/SpeedTreeImporterCommon.cs b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTreeImporterCommon.cs new file mode 100644 index 0000000000..eaee480758 --- /dev/null +++ b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTreeImporterCommon.cs @@ -0,0 +1,300 @@ +// 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 System; +using UnityEngine.Rendering; +using UnityEditor.AnimatedValues; + +namespace UnityEditor.SpeedTree.Importer +{ + class SpeedTreeConstants + { + internal static readonly float kFeetToMetersRatio = 0.3048f; + internal static readonly float kCentimetersToMetersRatio = 0.01f; + internal static readonly float kInchesToMetersRatio = 0.0254f; + internal static readonly float kAlphaTestRef = 0.33f; + internal static readonly string kBillboardMaterialName = "Billboard"; + } + + static class SpeedTreeImporterCommon + { + internal enum STUnitConversion + { + kLeaveAsIs = 0, + kFeetToMeters, + kCentimetersToMeters, + kInchesToMeters, + kCustomConversion + }; + + internal static class MaterialProperties + { + internal static readonly int MainTexID = Shader.PropertyToID("_MainTex"); + internal static readonly int ColorTintID = Shader.PropertyToID("_ColorTint"); + + internal static readonly int NormalMapKwToggleID = Shader.PropertyToID("_NormalMapKwToggle"); + internal static readonly int NormalMapID = Shader.PropertyToID("_NormalMap"); + + internal static readonly int ExtraMapKwToggleID = Shader.PropertyToID("_ExtraMapKwToggle"); + internal static readonly int ExtraTexID = Shader.PropertyToID("_ExtraTex"); + internal static readonly int GlossinessID = Shader.PropertyToID("_Glossiness"); + internal static readonly int MetallicID = Shader.PropertyToID("_Metallic"); + + internal static readonly int SubsurfaceKwToggleID = Shader.PropertyToID("_SubsurfaceKwToggle"); + internal static readonly int SubsurfaceTexID = Shader.PropertyToID("_SubsurfaceTex"); + internal static readonly int SubsurfaceColorID = Shader.PropertyToID("_SubsurfaceColor"); + internal static readonly int AlphaClipThresholdID = Shader.PropertyToID("_AlphaClipThreshold"); + internal static readonly int TransmissionScaleID = Shader.PropertyToID("_TransmissionScale"); + internal static readonly int DiffusionProfileAssetID = Shader.PropertyToID("_Diffusion_Profile_Asset"); + internal static readonly int DiffusionProfileID = Shader.PropertyToID("_DiffusionProfile"); + + internal static readonly int HueVariationKwToggleID = Shader.PropertyToID("_HueVariationKwToggle"); + internal static readonly int HueVariationColorID = Shader.PropertyToID("_HueVariationColor"); + + internal static readonly int LeafFacingKwToggleID = Shader.PropertyToID("_LeafFacingKwToggle"); + internal static readonly int BillboardKwToggleID = Shader.PropertyToID("_BillboardKwToggle"); + internal static readonly int DoubleSidedToggleID = Shader.PropertyToID("_DoubleSidedKwToggle"); + internal static readonly int DoubleSidedNormalModeID = Shader.PropertyToID("_DoubleSidedNormalMode"); + internal static readonly int BackfaceNormalModeID = Shader.PropertyToID("_BackfaceNormalMode"); + internal static readonly int TwoSidedID = Shader.PropertyToID("_TwoSided"); + + internal static readonly int WindSharedKwToggle = Shader.PropertyToID("_WIND_SHARED"); + internal static readonly int WindBranch2KwToggle = Shader.PropertyToID("_WIND_BRANCH2"); + internal static readonly int WindBranch1KwToggle = Shader.PropertyToID("_WIND_BRANCH1"); + internal static readonly int WindRippleKwToggle = Shader.PropertyToID("_WIND_RIPPLE"); + internal static readonly int WindShimmerKwToggle = Shader.PropertyToID("_WIND_SHIMMER"); + } + + internal static class MaterialKeywords + { + internal static readonly string VBSetupStandardID = "VB_SETUP_STANDARD"; + internal static readonly string VBSetupBranch2ID = "VB_SETUP_BRANCH2"; + internal static readonly string VBSetupCameraFacingID = "VB_SETUP_CAMERA_FACING"; + internal static readonly string VBSetupBranch2AndCameraFacingID = "VB_SETUP_BRANCH2_AND_CAMERA_FACING"; + internal static readonly string VBSetupBillboardID = "VB_SETUP_BILLBOARD"; + internal static readonly string VBSetupID = "VB_SETUP"; + internal static readonly string BillboardID = "_BILLBOARD"; + } + } + + static class SpeedTreeImporterCommonEditor + { + internal class Styles + { + // Meshes labels + public static GUIContent MeshesHeader = EditorGUIUtility.TrTextContent("Meshes"); + public static GUIContent UnitConversion = EditorGUIUtility.TrTextContent("Unit Conversion", "Select the unit conversion to apply to the imported SpeedTree asset."); + public static GUIContent ScaleFactor = EditorGUIUtility.TrTextContent("Scale Factor", "How much to scale the tree model, interpreting the exported units as meters. Must be positive."); + public static GUIContent[] UnitConversionNames = + { + new GUIContent("Leave As Is") + , new GUIContent("ft to m") + , new GUIContent("cm to m") + , new GUIContent("inch to m") + , new GUIContent("Custom") + }; + + // Materials labels + public static GUIContent MaterialHeader = EditorGUIUtility.TrTextContent("Material"); + public static GUIContent MainColor = EditorGUIUtility.TrTextContent("Main Color", "The color modulating the diffuse lighting component."); + public static GUIContent EnableColorVariation = EditorGUIUtility.TrTextContent("Color Variation", "Color is determined by linearly interpolating between the Main Color & Color Variation values based on the world position X, Y and Z values"); + public static GUIContent EnableBump = EditorGUIUtility.TrTextContent("Normal Map", "Enable normal (Bump) mapping."); + public static GUIContent EnableSubsurface = EditorGUIUtility.TrTextContent("Subsurface Scattering", "Enable subsurface scattering effects."); + public static GUIContent HueVariation = EditorGUIUtility.TrTextContent("Variation Color (RGB), Intensity (A)", "Tint the tree with the Variation Color"); + public static GUIContent AlphaTestRef = EditorGUIUtility.TrTextContent("Alpha Cutoff", "The alpha-test reference value."); + public static GUIContent TransmissionScale = EditorGUIUtility.TrTextContent("Transmission Scale", "The transmission scale value."); + + // Lighting labels + public static GUIContent LightingHeader = EditorGUIUtility.TrTextContent("Lighting"); + public static GUIContent CastShadows = EditorGUIUtility.TrTextContent("Cast Shadows", "The tree casts shadow"); + public static GUIContent ReceiveShadows = EditorGUIUtility.TrTextContent("Receive Shadows", "The tree receives shadow"); + public static GUIContent UseLightProbes = EditorGUIUtility.TrTextContent("Light Probes", "The tree uses light probe for lighting"); // TODO: update help text + public static GUIContent UseReflectionProbes = EditorGUIUtility.TrTextContent("Reflection Probes", "The tree uses reflection probe for rendering"); // TODO: update help text + public static GUIContent[] ReflectionProbeUsageNames = GetReflectionProbeUsageNames(); + + public static GUIContent[] GetReflectionProbeUsageNames() + { + string[] names = Enum.GetNames(typeof(ReflectionProbeUsage)); + GUIContent[] probUsageNames = new GUIContent[names.Length]; + + for (int i = 0; i < names.Length; ++i) + { + string varName = ObjectNames.NicifyVariableName(names[i]); + probUsageNames[i] = (new GUIContent(varName)); + } + + return probUsageNames; + } + + // Additional Settings labels + public static GUIContent AdditionalSettingsHeader = EditorGUIUtility.TrTextContent("Additional Settings"); + public static GUIContent MotionVectorMode = EditorGUIUtility.TrTextContent("Motion Vectors", "Motion vector mode to set for the mesh renderer of each LOD object"); + + // Wind labels + public static GUIContent WindHeader = EditorGUIUtility.TrTextContent("Wind"); + public static GUIContent WindQuality = EditorGUIUtility.TrTextContent("Wind Quality", "Controls the wind effect's quality."); + public static GUIContent[] MotionVectorModeNames = // Match SharedRendererDataTypes.h / enum MotionVectorGenerationMode +{ + new GUIContent("Camera Motion Only") // kMotionVectorCamera = 0, // Use camera motion for motion vectors + , new GUIContent("Per Object Motion") // kMotionVectorObject, // Use a per object motion vector pass for this object + , new GUIContent("Force No Motion") // kMotionVectorForceNoMotion, // Force no motion for this object (0 into motion buffer) + }; + + public static GUIContent[] GetWindQualityNames() + { + GUIContent[] windQualityNames = new GUIContent[SpeedTreeImporter.windQualityNames.Length]; + + for (int i = 0; i < SpeedTreeImporter.windQualityNames.Length; ++i) + { + windQualityNames[i] = new GUIContent(SpeedTreeImporter.windQualityNames[i]); + } + + return windQualityNames; + } + + // LOD labels + public static GUIContent LODHeader = EditorGUIUtility.TrTextContent("LOD"); + public static GUIContent ResetLOD = EditorGUIUtility.TrTextContent("Reset LOD to...", "Unify the LOD settings for all selected assets"); + public static GUIContent SmoothLOD = EditorGUIUtility.TrTextContent("Smooth Transitions", "Toggles smooth LOD transitions"); + public static GUIContent AnimateCrossFading = EditorGUIUtility.TrTextContent("Animate Cross-fading", "Cross-fading is animated instead of being calculated by distance"); + public static GUIContent CrossFadeWidth = EditorGUIUtility.TrTextContent("Crossfade Width", "Proportion of the last 3D mesh LOD region width which is used for cross-fading to billboard tree"); + public static GUIContent FadeOutWidth = EditorGUIUtility.TrTextContent("Fade Out Width", "The proportion of the billboard LOD region width that is used to fade out the billboard."); + + public static GUIContent EnableLodCustomizationsWarn = EditorGUIUtility.TrTextContent("Customizing LOD options may help with tuning the GPU performance but will likely negatively impact the instanced draw batching, i.e. CPU performance.\nPlease use the per-LOD customizations with careful memory and performance profiling for both CPU and GPU and remember that these options are a trade-off rather than a free win."); + public static GUIContent BillboardSettingsHelp = EditorGUIUtility.TrTextContent("Billboard options are separate from the 3D model options shown above.\nChange the options below for influencing billboard rendering."); + public static GUIContent MultiSelectionLODNotSupported = EditorGUIUtility.TrTextContent("Multi-selection is not supported for LOD settings."); + + public static GUIContent ApplyAndGenerate = EditorGUIUtility.TrTextContent("Apply & Generate Materials", "Apply current importer settings and generate asset materials with the new settings."); + } + + static internal void ShowMeshGUI( + ref SerializedProperty unitConversionEnumValue, + ref SerializedProperty scaleFactor) + { + GUILayout.Label(Styles.MeshesHeader, EditorStyles.boldLabel); + + EditorGUILayout.Popup(unitConversionEnumValue, Styles.UnitConversionNames, Styles.UnitConversion); + + bool bShowCustomScaleFactor = unitConversionEnumValue.intValue == Styles.UnitConversionNames.Length - 1; + if (bShowCustomScaleFactor) + { + EditorGUILayout.PropertyField(scaleFactor, Styles.ScaleFactor); + if (scaleFactor.floatValue < 0f) + { + scaleFactor.floatValue = 0f; + } + if (scaleFactor.floatValue == 0f) + { + EditorGUILayout.HelpBox("Scale factor must be positive.", MessageType.Warning); + } + } + } + + static internal void ShowMaterialGUI( + ref SerializedProperty mainColor, + ref SerializedProperty enableHueVariation, + ref SerializedProperty hueVariation, + ref SerializedProperty alphaTestRef, + ref SerializedProperty enableBumpMapping, + ref SerializedProperty enableSubsurfaceScattering, + bool renderHueVariationDropdown = false, + bool renderAlphaTestRef = false) + { + EditorGUILayout.LabelField(Styles.MaterialHeader, EditorStyles.boldLabel); + + EditorGUILayout.PropertyField(mainColor, Styles.MainColor); + EditorGUILayout.PropertyField(enableHueVariation, Styles.EnableColorVariation); + + if (renderHueVariationDropdown) + { + EditorGUILayout.PropertyField(hueVariation, Styles.HueVariation); + } + + if (renderAlphaTestRef) + EditorGUILayout.Slider(alphaTestRef, 0f, 1f, Styles.AlphaTestRef); + + EditorGUILayout.PropertyField(enableBumpMapping, Styles.EnableBump); + EditorGUILayout.PropertyField(enableSubsurfaceScattering, Styles.EnableSubsurface); + } + + static internal void ShowLightingGUI( + ref SerializedProperty enableShadowCasting, + ref SerializedProperty enableShadowReceiving, + ref SerializedProperty enableLightProbeUsage, + ref SerializedProperty reflectionProbeUsage) + { + GUILayout.Label(Styles.LightingHeader, EditorStyles.boldLabel); + + EditorGUILayout.PropertyField(enableShadowCasting, Styles.CastShadows); + + // from the docs page: https://docs.unity3d.com/Manual/SpeedTree.html + // Known issues: As with any other renderer, the Receive Shadows option has no effect while using deferred rendering. + // TODO: test and conditionally expose this field + using (new EditorGUI.DisabledScope(!UnityEngine.Rendering.SupportedRenderingFeatures.active.receiveShadows)) + { + EditorGUILayout.PropertyField(enableShadowReceiving, Styles.ReceiveShadows); + } + + EditorGUILayout.PropertyField(enableLightProbeUsage, Styles.UseLightProbes); + } + + static internal void ShowAdditionalSettingsGUI( + ref SerializedProperty motionVectorModeEnumValue, + ref SerializedProperty generateColliders, + ref SerializedProperty generateRigidbody) + { + GUILayout.Label(Styles.AdditionalSettingsHeader, EditorStyles.boldLabel); + EditorGUILayout.Popup(motionVectorModeEnumValue, Styles.MotionVectorModeNames, Styles.MotionVectorMode); + + EditorGUILayout.PropertyField(generateColliders); + EditorGUILayout.PropertyField(generateRigidbody); + } + + static internal void ShowWindGUI( + ref SerializedProperty bestWindQuality, + ref SerializedProperty selectedWindQuality) + { + GUILayout.Label(Styles.WindHeader, EditorStyles.boldLabel); + + int NumAvailableWindQualityOptions = 1 + bestWindQuality.intValue; // 0 is None, we want at least 1 value + ArraySegment availableWindQualityOptions = new ArraySegment(Styles.GetWindQualityNames(), 0, NumAvailableWindQualityOptions); + EditorGUILayout.Popup(selectedWindQuality, availableWindQualityOptions.ToArray(), Styles.WindQuality); + } + + static internal void ShowLODGUI( + ref SerializedProperty enableSmoothLOD, + ref SerializedProperty animateCrossFading, + ref SerializedProperty billboardTransitionCrossFadeWidth, + ref SerializedProperty fadeOutWidth, + ref AnimBool showSmoothLODOptions, + ref AnimBool showCrossFadeWidthOptions) + { + showSmoothLODOptions.target = enableSmoothLOD.hasMultipleDifferentValues || enableSmoothLOD.boolValue; + showCrossFadeWidthOptions.target = animateCrossFading.hasMultipleDifferentValues || !animateCrossFading.boolValue; + + GUILayout.Label(Styles.LODHeader, EditorStyles.boldLabel); + + EditorGUILayout.PropertyField(enableSmoothLOD, Styles.SmoothLOD); + + using (new EditorGUI.IndentLevelScope()) + { + // Note: FadeGroupScope doesn't work here, as if the 'faded' is not updated correctly. + + if (EditorGUILayout.BeginFadeGroup(showSmoothLODOptions.faded)) + { + EditorGUILayout.PropertyField(animateCrossFading, Styles.AnimateCrossFading); + + if (EditorGUILayout.BeginFadeGroup(showCrossFadeWidthOptions.faded)) + { + EditorGUILayout.Slider(billboardTransitionCrossFadeWidth, 0.0f, 1.0f, Styles.CrossFadeWidth); + EditorGUILayout.Slider(fadeOutWidth, 0.0f, 1.0f, Styles.FadeOutWidth); + } + EditorGUILayout.EndFadeGroup(); + } + EditorGUILayout.EndFadeGroup(); + } + } + } +} diff --git a/Editor/Mono/AssetPipeline/SpeedTree/SpeedTreeImporterOutputData.cs b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTreeImporterOutputData.cs new file mode 100644 index 0000000000..bc11ceb74d --- /dev/null +++ b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTreeImporterOutputData.cs @@ -0,0 +1,68 @@ +// 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 System.Collections.Generic; + +namespace UnityEditor.SpeedTree.Importer +{ + internal class SpeedTreeImporterOutputData : ScriptableObject + { + /// + /// The main object of the asset. + /// + public GameObject mainObject; + + /// + /// Contains the materials data and materials are assigned per LOD with an index. + /// + public LODMaterials lodMaterials = new LODMaterials(); + + /// + /// The materials metadata used for the materials extraction code. + /// + public List materialsIdentifiers = new List(); + + /// + /// Represents the wind configuration parameters. + /// + public SpeedTreeWindConfig9 m_WindConfig = new SpeedTreeWindConfig9(); + + /// + /// Determines if the current asset has embedded materials or not. + /// + public bool hasEmbeddedMaterials = false; + + /// + /// Determines if the current Shader supports alpha clip threshold. + /// + public bool hasAlphaClipThreshold = false; + + /// + /// Determines if the current Shader supports transmision scale. + /// + public bool hasTransmissionScale = false; + + /// + /// Determines if the current asset has a biilboard or not. + /// + public bool hasBillboard = false; + + /// + /// Create an instance of SpeedTreeImporterOutputData with default settings. + /// + /// The newly created SpeedTreeImporterOutputData instance. + static public SpeedTreeImporterOutputData Create() + { + SpeedTreeImporterOutputData outputImporterData = CreateInstance(); + outputImporterData.name = "ImporterOutputData"; + + // Ideally, we should use this flag so the file is not visible in the asset prefab. + // Though, it breaks the 'AssetDatabase.LoadAssetAtPath' function (the file is not loaded anymore). + // outputImporterData.hideFlags = HideFlags.HideInHierarchy; + + return outputImporterData; + } + } +} diff --git a/Editor/Mono/AssetPipeline/SpeedTree/SpeedTreeImporterSettings.cs b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTreeImporterSettings.cs new file mode 100644 index 0000000000..a6a84b45ee --- /dev/null +++ b/Editor/Mono/AssetPipeline/SpeedTree/SpeedTreeImporterSettings.cs @@ -0,0 +1,224 @@ +// 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 System; +using UnityEngine.Rendering; + +using System.Collections.Generic; +using static UnityEditor.SpeedTree.Importer.SpeedTreeImporterCommon; + +namespace UnityEditor.SpeedTree.Importer +{ + [Serializable] + internal class MeshSettings + { + public STUnitConversion unitConversion = STUnitConversion.kFeetToMeters; + public float scaleFactor = SpeedTreeConstants.kFeetToMetersRatio; + } + + [Serializable] + internal class MaterialSettings + { + public Color mainColor = Color.white; + public Color hueVariation = new Color(1.0f, 0.5f, 0.0f, 0.1f); + public float alphaClipThreshold = 0.10f; + public float transmissionScale = 0.0f; + + public bool enableHueVariation = false; + public bool enableBumpMapping = true; + public bool enableSubsurfaceScattering = true; + + public Vector4 diffusionProfileAssetID = Vector4.zero; + public uint diffusionProfileID = 0; + } + + [Serializable] + internal class LightingSettings + { + public bool enableShadowCasting = true; + public bool enableShadowReceiving = true; + public bool enableLightProbes = true; + public ReflectionProbeUsage reflectionProbeEnumValue = ReflectionProbeUsage.BlendProbes; + } + + [Serializable] + internal class AdditionalSettings + { + public MotionVectorGenerationMode motionVectorModeEnumValue = MotionVectorGenerationMode.Object; + public bool generateColliders = true; + public bool generateRigidbody = true; + } + + [Serializable] + internal class LODSettings + { + public bool enableSmoothLODTransition = true; + public bool animateCrossFading = true; + public float billboardTransitionCrossFadeWidth = 0.25f; + public float fadeOutWidth = 0.25f; + public bool hasBillboard = false; + } + + [Serializable] + internal class PerLODSettings + { + public bool enableSettingOverride = false; + + // LOD + public float height = 0.5f; + + // Lighting + public bool castShadows = false; + public bool receiveShadows = false; + public bool useLightProbes = false; + public ReflectionProbeUsage reflectionProbeUsage = ReflectionProbeUsage.Off; + + // Material + public bool enableBump = false; + public bool enableHue = false; + public bool enableSubsurface = false; + }; + + [Serializable] + internal class MaterialInfo + { + public Material material = null; + public string defaultName = null; + public bool exported = false; + } + + [Serializable] + internal class LODMaterials + { + public List materials = new List(); + public Dictionary> lodToMaterials = new Dictionary>(); + public Dictionary matNameToIndex = new Dictionary(); + + public void AddLodMaterialIndex(int lod, int matIndex) + { + if (lodToMaterials.ContainsKey(lod)) + { + lodToMaterials[lod].Add(matIndex); + } + else + { + lodToMaterials.Add(lod, new List() { matIndex}); + } + } + } + + [Serializable] + internal class WindSettings + { + public bool enableWind = true; + + [Range(1.0f, 20.0f)] + public float strenghResponse = 5.0f; + + [Range(1.0f, 20.0f)] + public float directionResponse = 2.5f; + + [Range(0.0f, 1.0f)] + public float randomness = 0.5f; + } + + // Ideally, we should use 'AssetImporter.SourceAssetIdentifier', but this struct has many problems: + // 1 - 'Type' is not a serializable type, so it's always equal to null in our context. + // 2 - The C# struct is not matching the C++ class. + // 3 - Missing the 'Serializable' attribute on top of the struct. + [Serializable] + internal class AssetIdentifier + { + public string type; + public string name; + + public AssetIdentifier(UnityEngine.Object asset) + { + if (asset == null) + { + throw new ArgumentNullException("asset"); + } + + this.type = asset.GetType().ToString(); + this.name = asset.name; + } + + public AssetIdentifier(Type type, string name) + { + if (type == null) + { + throw new ArgumentNullException("type"); + } + + if (name == null) + { + throw new ArgumentNullException("name"); + } + + if (string.IsNullOrEmpty(name)) + { + throw new ArgumentException("The name is empty", "name"); + } + + this.type = type.ToString(); + this.name = name; + } + } + + /// + /// This attribute is used as a callback to set SRP specific properties from the importer. + /// + [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)] + public class MaterialSettingsCallbackAttribute : Attribute + { + /// + /// The version of the method. + /// + public int MethodVersion; + + /// + /// Initializes a new instance of the MaterialSettingsCallbackAttribute with the given method version. + /// + /// The given method version. + public MaterialSettingsCallbackAttribute(int methodVersion) + { + MethodVersion = methodVersion; + } + + [RequiredSignature] + static void SignatureExample(GameObject mainObject) + { + throw new InvalidOperationException(); + } + } + + /// + /// This attribute is used as a callback to extend the inspector by adding + /// the Diffuse Profile property when the HDRP package is in use. + /// + [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)] + public class DiffuseProfileCallbackAttribute : Attribute + { + /// + /// The version of the method. + /// + public int MethodVersion; + + /// + /// Initializes a new instance of the DiffuseProfileCallbackAttribute with the given method version. + /// + /// The given method version. + public DiffuseProfileCallbackAttribute(int methodVersion) + { + MethodVersion = methodVersion; + } + + [RequiredSignature] + static void SignatureExample(ref SerializedProperty diffusionProfileAsset, ref SerializedProperty diffusionProfileHash) + { + throw new InvalidOperationException(); + } + } +} diff --git a/Editor/Mono/AssetPipeline/SpeedTreeImporter.bindings.cs b/Editor/Mono/AssetPipeline/SpeedTreeImporter.bindings.cs index 7c05bf4d56..dd19442061 100644 --- a/Editor/Mono/AssetPipeline/SpeedTreeImporter.bindings.cs +++ b/Editor/Mono/AssetPipeline/SpeedTreeImporter.bindings.cs @@ -55,7 +55,7 @@ public extern bool isV8 ///////////////////////////////////////////////////////////////////////////// - // Common material properties + // Material properties public extern Color mainColor { get; set; } @@ -71,7 +71,30 @@ public extern bool isV8 public extern Color hueVariation { get; set; } public extern float alphaTestRef { get; set; } + public extern bool enableBumpByDefault { get; set; } + public extern bool enableHueByDefault { get; set; } + public extern bool enableSubsurfaceByDefault { get; set; } + ///////////////////////////////////////////////////////////////////////////// + // Lighting properties + + public extern bool castShadowsByDefault { get; set; } + public extern bool receiveShadowsByDefault { get; set; } + public extern bool useLightProbesByDefault { get; set; } + public extern int reflectionProbeUsagesByDefault { get; set; } + + ///////////////////////////////////////////////////////////////////////////// + // Wind properties + + public static readonly string[] windQualityNames = new[] { "None", "Fastest", "Fast", "Better", "Best", "Palm" }; + public extern int bestWindQuality { get; } + public extern int selectedWindQuality { get; set; } + + ///////////////////////////////////////////////////////////////////////////// + // Physics settings + + public extern bool generateRigidbody { get; set; } + public extern bool generateColliders { get; set; } ///////////////////////////////////////////////////////////////////////////// // LOD settings @@ -82,11 +105,21 @@ public extern bool hasBillboard get; } + public extern bool enableSmoothLODTransition { get; set; } public extern bool animateCrossFading { get; set; } public extern float billboardTransitionCrossFadeWidth { get; set; } public extern float fadeOutWidth { get; set; } + public extern bool[] enableSettingOverride + { + [FreeFunction(Name = "SpeedTreeImporterBindings::GetEnableSettingOverride", HasExplicitThis = true)] + get; + [NativeThrows] + [FreeFunction(Name = "SpeedTreeImporterBindings::SetEnableSettingOverride", HasExplicitThis = true)] + set; + } + public extern float[] LODHeights { [FreeFunction(Name = "SpeedTreeImporterBindings::GetLODHeights", HasExplicitThis = true)] @@ -159,10 +192,6 @@ public extern bool[] enableSubsurface set; } - public static readonly string[] windQualityNames = new[] { "None", "Fastest", "Fast", "Better", "Best", "Palm" }; - - public extern int bestWindQuality { get; } - public extern int[] windQualities { [FreeFunction(Name = "SpeedTreeImporterBindings::GetWindQuality", HasExplicitThis = true)] @@ -233,4 +262,63 @@ public bool SearchAndRemapMaterials(string materialFolderPath) return changedMappings; } } + + class SpeedTreePostProcessor : AssetPostprocessor + { + private static void FixExtraTexture_sRGB(IEnumerable subAssets) + { + AssetDatabase.StartAssetEditing(); + + foreach (var subAsset in subAssets) + { + if (subAsset is Material) + { + Material m = subAsset as Material; + Texture tex = m.GetTexture("_ExtraTex"); + if (tex) + { + string texturePath = AssetDatabase.GetAssetOrScenePath(tex); + TextureImporter texImporter = AssetImporter.GetAtPath(texturePath) as TextureImporter; + if(texImporter) + { + // Multiple materials may be referencing the same ExtraTexture, therefore + // we'll need to check the importer's setting and only queue a single reimport + // for a given texture. + if (texImporter.sRGBTexture) + { + texImporter.sRGBTexture = false; // extra texture does not contain color data, hence shouldn't be sRGB. + texImporter.SaveAndReimport(); + } + + + } + } + } + } + AssetDatabase.StopAssetEditing(); + } + + static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths) + { + foreach (var asset in importedAssets) + { + bool st8 = asset.EndsWith(".st", StringComparison.OrdinalIgnoreCase); + if(st8) + { + SpeedTreeImporter importer = AssetImporter.GetAtPath(asset) as SpeedTreeImporter; + if (importer == null) + continue; + + // Check the external materials in case the user has extracted + Dictionary externalAssets = importer.GetExternalObjectMap(); + if(externalAssets != null) + FixExtraTexture_sRGB(externalAssets.Values); + + // Check the object subassets -- updates the materials if they're embedded in the SpeedTree asset + UnityEngine.Object[] subAssets = AssetDatabase.LoadAllAssetsAtPath(asset); + FixExtraTexture_sRGB(subAssets); + } + } + } + } } diff --git a/Editor/Mono/AssetPipeline/TextureGenerator.bindings.cs b/Editor/Mono/AssetPipeline/TextureGenerator.bindings.cs index e368f12d59..7c1eb764c4 100644 --- a/Editor/Mono/AssetPipeline/TextureGenerator.bindings.cs +++ b/Editor/Mono/AssetPipeline/TextureGenerator.bindings.cs @@ -9,10 +9,12 @@ using System.Collections.Generic; using Unity.Collections; using Unity.Collections.LowLevel.Unsafe; +using UnityEngine.Scripting.APIUpdating; -namespace UnityEditor.Experimental.AssetImporters +namespace UnityEditor.AssetImporters { [StructLayout(LayoutKind.Sequential)] + [MovedFrom("UnityEditor.Experimental.AssetImporters")] public struct SpriteImportData { private string m_Name; @@ -20,6 +22,7 @@ public struct SpriteImportData private SpriteAlignment m_Alignment; private Vector2 m_Pivot; private Vector4 m_Border; + private string m_CustomData; private float m_TessellationDetail; private string m_SpriteID; private List m_Outline; @@ -29,16 +32,18 @@ public struct SpriteImportData public SpriteAlignment alignment { get { return m_Alignment; } set { m_Alignment = value; } } public Vector2 pivot { get { return m_Pivot; } set { m_Pivot = value; } } public Vector4 border { get { return m_Border; } set { m_Border = value; } } + internal string customData { get { return m_CustomData; } set { m_CustomData = value; } } public List outline { get { return m_Outline; } set { m_Outline = value; } } public float tessellationDetail {get { return m_TessellationDetail; } set { m_TessellationDetail = value; } } public string spriteID {get { return m_SpriteID; } set { m_SpriteID = value; } } } [StructLayout(LayoutKind.Sequential)] + [MovedFrom("UnityEditor.Experimental.AssetImporters")] public struct TextureGenerationOutput { [NativeName("texture")] - private Texture2D m_Texture; + private Texture m_Texture; [NativeName("importInspectorWarnings")] private string m_ImportInspectorWarnings; [NativeName("importWarnings")] @@ -48,7 +53,8 @@ public struct TextureGenerationOutput [NativeName("sprites")] private Sprite[] m_Sprites; - public Texture2D texture { get { return m_Texture; } } + public Texture2D texture { get { return m_Texture as Texture2D; } } + public Texture output { get { return m_Texture; } } public string importInspectorWarnings { get { return m_ImportInspectorWarnings; } } public string[] importWarnings { get { return m_ImportWarnings; } } public Texture2D thumbNail { get { return m_ThumbNail; } } @@ -58,6 +64,7 @@ public struct TextureGenerationOutput [StructLayout(LayoutKind.Sequential)] [NativeAsStruct] + [MovedFrom("UnityEditor.Experimental.AssetImporters")] public class SourceTextureInformation { [NativeName("width")] @@ -76,6 +83,7 @@ public class SourceTextureInformation } [StructLayout(LayoutKind.Sequential)] + [MovedFrom("UnityEditor.Experimental.AssetImporters")] public struct TextureGenerationSettings { [NativeName("assetPath")] @@ -138,6 +146,8 @@ public TextureGenerationSettings(TextureImporterType type) m_Settings.mipmapFadeDistanceEnd = 3; m_Settings.heightmapScale = 0.25f; m_Settings.normalMapFilter = TextureImporterNormalFilter.Standard; + m_Settings.flipGreenChannel = false; + m_Settings.swizzleRaw = 0x03020100; // R,G,B,A m_Settings.cubemapConvolution = 0; m_Settings.generateCubemap = TextureImporterGenerateCubemap.AutoCubemap; m_Settings.seamlessCubemap = false; @@ -199,6 +209,18 @@ public TextureGenerationSettings(TextureImporterType type) m_Settings.alphaIsTransparency = false; m_Settings.alphaSource = TextureImporterAlphaSource.None; break; + case TextureImporterType.DirectionalLightmap: + m_Settings.sRGBTexture = false; + m_Settings.npotScale = TextureImporterNPOTScale.ToNearest; + m_Settings.alphaIsTransparency = false; + m_Settings.alphaSource = TextureImporterAlphaSource.None; + break; + case TextureImporterType.Shadowmask: + m_Settings.sRGBTexture = false; + m_Settings.npotScale = TextureImporterNPOTScale.ToNearest; + m_Settings.alphaIsTransparency = false; + m_Settings.alphaSource = TextureImporterAlphaSource.None; + break; case TextureImporterType.SingleChannel: m_Settings.sRGBTexture = false; break; @@ -221,15 +243,21 @@ public TextureGenerationSettings(TextureImporterType type) [NativeHeader("Editor/Src/AssetPipeline/TextureImporting/TextureImporterTypes.h")] [NativeHeader("Editor/Src/AssetPipeline/TextureImporting/TextureImporter.bindings.h")] [NativeHeader("Runtime/Serialize/BuildTarget.h")] + [MovedFrom("UnityEditor.Experimental.AssetImporters")] public static unsafe class TextureGenerator { public static TextureGenerationOutput GenerateTexture(TextureGenerationSettings settings, NativeArray colorBuffer) { - return GenerateTextureImpl(settings, colorBuffer.GetUnsafeReadOnlyPtr(), colorBuffer.Length * UnsafeUtility.SizeOf()); + return GenerateTextureImpl(settings, colorBuffer.GetUnsafeReadOnlyPtr(), colorBuffer.Length * UnsafeUtility.SizeOf(), 4); + } + + public static TextureGenerationOutput GenerateTexture(TextureGenerationSettings settings, NativeArray colorBuffer) + { + return GenerateTextureImpl(settings, colorBuffer.GetUnsafeReadOnlyPtr(), colorBuffer.Length * UnsafeUtility.SizeOf(), 16); } [NativeThrows] [NativeMethod("GenerateTextureScripting")] - extern static unsafe TextureGenerationOutput GenerateTextureImpl(TextureGenerationSettings settings, void* colorBuffer, int colorBufferLength); + extern static unsafe TextureGenerationOutput GenerateTextureImpl(TextureGenerationSettings settings, void* colorBuffer, int colorBufferLength, int bytesPerPixel); } } diff --git a/Editor/Mono/AssetPipeline/TextureImporter.bindings.cs b/Editor/Mono/AssetPipeline/TextureImporter.bindings.cs index 09ec8bebdf..e304c3437b 100644 --- a/Editor/Mono/AssetPipeline/TextureImporter.bindings.cs +++ b/Editor/Mono/AssetPipeline/TextureImporter.bindings.cs @@ -6,7 +6,7 @@ using System.Collections.Generic; using System.ComponentModel; using UnityEditor.Build; -using UnityEditor.Experimental.AssetImporters; +using UnityEditor.AssetImporters; using UnityEngine; using UnityEngine.Bindings; using UnityEngine.Scripting; @@ -17,16 +17,12 @@ namespace UnityEditor [NativeHeader("Editor/Src/AssetPipeline/TextureImporting/TextureImporter.h")] [NativeHeader("Editor/Src/AssetPipeline/TextureImporting/TextureImporter.deprecated.h")] [NativeHeader("Editor/Src/AssetPipeline/TextureImporting/TextureImporterUtils.h")] + [NativeHeader("Editor/Src/AssetPipeline/TextureImporting/TextureImporterPlatformSettingsUtils.h")] [NativeHeader("Editor/Src/EditorUserBuildSettings.h")] public sealed partial class TextureImporter : AssetImporter { - private string GetFixedPlatformName(string platform) - { - var targetGroup = BuildPipeline.GetBuildTargetGroupByName(platform); - if (targetGroup != BuildTargetGroup.Unknown) - return BuildPipeline.GetBuildTargetGroupName(targetGroup); - return platform; - } + [FreeFunction] + internal static extern string GetTexturePlatformSerializationName(string platformName); [Obsolete("textureFormat is no longer accessible at the TextureImporter level. For old 'simple' formats use the textureCompression property for the equivalent automatic choice (Uncompressed for TrueColor, Compressed and HQCommpressed for 16 bits). For platform specific formats use the [[PlatformTextureSettings]] API. Using this setter will setup various parameters to match the new automatic system as well as possible. Getter will return the last value set.")] public extern TextureImporterFormat textureFormat @@ -98,7 +94,9 @@ public bool GetPlatformTextureSettings(string platform, out int maxTextureSize, return GetPlatformTextureSettings(platform, out maxTextureSize, out textureFormat, out compressionQuality, out etc1AlphaSplitEnabled); } - // C++ implementation will return default platform if the requested platform does not have any settings yet. + // C++ implementation will return default platform if the requested platform is not valid. + // See "Editor/Mono/BuildPipeline/BuildPlatform.cs" -> "GetValidPlatformNames" for more + // information regarding what is considered to be a valid platform. [NativeName("GetPlatformTextureSettings")] private extern TextureImporterPlatformSettings GetPlatformTextureSetting_Internal(string platform); @@ -106,8 +104,7 @@ public bool GetPlatformTextureSettings(string platform, out int maxTextureSize, // public API will always return a valid TextureImporterPlatformSettings, creating it based on the default one if it did not exist. public TextureImporterPlatformSettings GetPlatformTextureSettings(string platform) { - // make sure we are converting the settings to use the proper BuildTargetGroupName to get them (the way it works on other importers) - platform = GetFixedPlatformName(platform); + platform = GetTexturePlatformSerializationName(platform); // String may refer to a platform group: if != "Standalone", ensure it refers to a platform instead. E.g.: "iOS", not "iPhone". TextureImporterPlatformSettings dest = GetPlatformTextureSetting_Internal(platform); if (platform != dest.name) @@ -125,22 +122,24 @@ public TextureImporterPlatformSettings GetDefaultPlatformTextureSettings() public TextureImporterFormat GetAutomaticFormat(string platform) { - platform = GetFixedPlatformName(platform); + platform = GetTexturePlatformSerializationName(platform); // String may refer to a platform group: if != "Standalone", ensure it refers to a platform instead. E.g.: "iOS", not "iPhone". TextureImporterSettings settings = new TextureImporterSettings(); ReadTextureSettings(settings); TextureImporterPlatformSettings platformSettings = GetPlatformTextureSettings(platform); - List validPlatforms = BuildPlatforms.instance.GetValidPlatforms(); - foreach (BuildPlatform bp in validPlatforms) + BuildTarget buildTarget = BuildPipeline.GetBuildTargetByName(platform); + if (buildTarget != BuildTarget.NoTarget) { - if (bp.name == platform) - { - return DefaultFormatFromTextureParameters(settings, - platformSettings, - DoesSourceTextureHaveAlpha(), - IsSourceTextureHDR(), - bp.defaultTarget); - } + return DefaultFormatFromTextureParameters(settings, + !platformSettings.overridden ? GetDefaultPlatformTextureSettings() : platformSettings, + DoesSourceTextureHaveAlpha(), + IsSourceTextureHDR(), + buildTarget); + + // Regarding the "GetDefaultPlatformTextureSettings" call: in case 1281084, we made it so that platform settings stop automatically + // resetting to the default platform's settings when the platform override is disabled. This introduced a regression where + // "GetAutomaticFormat" would not return the actual format used by platforms with a disabled override, (as in, the one indicated in + // the default platform's settings) which is why we pass in the default platform's settings instead. } return TextureImporterFormat.Automatic; @@ -181,8 +180,7 @@ public void SetPlatformTextureSettings(string platform, int maxTextureSize, Text // Set specific target platform settings public void SetPlatformTextureSettings(TextureImporterPlatformSettings platformSettings) { - // we need to fix the name in case the user changed it to some mismatching value - platformSettings.name = GetFixedPlatformName(platformSettings.name); + platformSettings.name = GetTexturePlatformSerializationName(platformSettings.name); // String may refer to a platform group: if != "Standalone", ensure it refers to a platform instead. E.g.: "iOS", not "iPhone". SetPlatformTextureSettings_Internal(platformSettings); } @@ -192,7 +190,8 @@ public void SetPlatformTextureSettings(TextureImporterPlatformSettings platformS public void ClearPlatformTextureSettings(string platform) { - ClearPlatformTextureSettings_Internal(GetFixedPlatformName(platform)); + platform = GetTexturePlatformSerializationName(platform); // String may refer to a platform group: if != "Standalone", ensure it refers to a platform instead. E.g.: "iOS", not "iPhone". + ClearPlatformTextureSettings_Internal(platform); } [FreeFunction] @@ -251,6 +250,9 @@ public static bool IsDefaultPlatformTextureFormatValid(TextureImporterType textu [NativeProperty("VTOnly")] public extern bool vtOnly { get; set; } + public extern bool ignoreMipmapLimit { get; set; } + public extern string mipmapLimitGroupName { get; set; } + // Generate mip maps for the texture? public extern bool mipmapEnabled { get; set; } // Keep texture borders the same when generating mipmaps? @@ -306,11 +308,32 @@ public bool lightmap set { if (value) textureType = TextureImporterType.Lightmap; else textureType = TextureImporterType.Default; } } - // Convert heightmap to normal map? public extern bool convertToNormalmap { get; set; } - // Is this texture a normal map? public extern TextureImporterNormalFilter normalmapFilter { get; set; } - // Amount of bumpyness in the heightmap. + public extern bool flipGreenChannel { get; set; } + + extern uint swizzle { get; set; } + public TextureImporterSwizzle swizzleR + { + get => (TextureImporterSwizzle)(swizzle & 0xFF); + set => swizzle = (swizzle & 0xFFFFFF00) | (uint)value; + } + public TextureImporterSwizzle swizzleG + { + get => (TextureImporterSwizzle)((swizzle >> 8) & 0xFF); + set => swizzle = (swizzle & 0xFFFF00FF) | ((uint)value<<8); + } + public TextureImporterSwizzle swizzleB + { + get => (TextureImporterSwizzle)((swizzle >> 16) & 0xFF); + set => swizzle = (swizzle & 0xFF00FFFF) | ((uint)value<<16); + } + public TextureImporterSwizzle swizzleA + { + get => (TextureImporterSwizzle)((swizzle >> 24) & 0xFF); + set => swizzle = (swizzle & 0x00FFFFFF) | ((uint)value<<24); + } + [NativeProperty("NormalmapHeightScale")] public extern float heightmapScale { get; set; } @@ -347,11 +370,13 @@ public extern TextureWrapMode wrapMode public extern SpriteImportMode spriteImportMode { get; set; } [NativeProperty("SpriteMetaDatas")] + [Obsolete("Support for accessing sprite meta data through spritesheet has been removed. Please use the UnityEditor.U2D.Sprites.ISpriteEditorDataProvider interface instead.")] public extern SpriteMetaData[] spritesheet { get; set; } public extern SecondarySpriteTexture[] secondarySpriteTextures { get; set; } - public extern string spritePackingTag { get; set; } + [Obsolete("Support for packing sprites through spritePackingTag has been removed. Please use SpriteAtlas instead.")] + public string spritePackingTag { get { return ""; } set { } } // The number of pixels in one unit. Note: The C++ side still uses the name pixelsToUnits which is misleading, // but has not been changed yet to minimize merge conflicts. @@ -371,6 +396,16 @@ internal void GetWidthAndHeight(ref int width, ref int height) height = info.height; } + public void GetSourceTextureWidthAndHeight(out int width, out int height) + { + var info = GetSourceTextureInformation(); + if (info.width == -1) + throw new InvalidOperationException("The texture has not yet finished importing. This most likely means this method was called in an AssetPostprocessor.OnPreprocessAsset callback."); + + width = info.width; + height = info.height; + } + internal bool IsSourceTextureHDR() { return GetSourceTextureInformation().hdr; @@ -414,9 +449,30 @@ public void ReadTextureSettings(TextureImporterSettings dest) // Set texture importers settings from [[TextureImporterSettings]] class. public void SetTextureSettings(TextureImporterSettings src) { + ValidateAndCorrectTextureImporterSettings(src); settings = src; } + private void ValidateAndCorrectTextureImporterSettings(TextureImporterSettings m_Settings) + { + switch (m_Settings.textureType) + { + case TextureImporterType.Sprite: + m_Settings.npotScale = ValidateAndCorrectSetting(m_Settings.npotScale, TextureImporterNPOTScale.None, nameof(m_Settings.npotScale)); + break; + } + } + + private T ValidateAndCorrectSetting(T actual, T expected, string settingName) + { + if (!actual.Equals(expected)) + { + Debug.LogWarning($"You cannot set {settingName} to {actual} for this texture type. It has been reset to {expected}."); + return expected; + } + return actual; + } + private extern TextureImporterSettings settings { get; set; } [NativeName("GetImportInspectorWarning")] @@ -424,11 +480,17 @@ public void SetTextureSettings(TextureImporterSettings src) public extern void ReadTextureImportInstructions(BuildTarget target, out TextureFormat desiredFormat, out ColorSpace colorSpace, out int compressionQuality); + internal extern bool textureStillNeedsToBeCompressed { [NativeName("DoesTextureStillNeedToBeCompressed")] get; } + // This is pure backward compatibility codepath. It can be removed when we decide that the time has come - internal extern bool ShouldShowRemoveMatteOption(); internal extern bool removeMatte { get; set; } public extern bool ignorePngGamma { get; set; } - internal static readonly int MaxTextureSizeAllowedForReadable = 8192; //keep in sync with TextureImporter.h + + // This is for remapping Sprite that are renamed. + extern internal bool GetNameFromInternalIDMap(long id, ref string name); + + [NativeName("GetSpriteMetaDatas")] + internal extern SpriteMetaData[] GetSpriteMetaDatas(); } } diff --git a/Editor/Mono/AssetPipeline/TextureImporterEnums.cs b/Editor/Mono/AssetPipeline/TextureImporterEnums.cs index c4f1eef85a..67aab13541 100644 --- a/Editor/Mono/AssetPipeline/TextureImporterEnums.cs +++ b/Editor/Mono/AssetPipeline/TextureImporterEnums.cs @@ -3,6 +3,7 @@ // https://unity3d.com/legal/licenses/Unity_Reference_Only_License using System; +using System.ComponentModel; using UnityEngine.Scripting; namespace UnityEditor @@ -27,6 +28,9 @@ internal enum TextureUsageMode // Baked lightmap without any encoding BakedLightmapFullHDR = 8, RealtimeLightmapRGBM = 9, + NormalmapASTCnm = 10, + SingleChannelRed = 11, + SingleChannelAlpha = 12, } // Imported texture format for [[TextureImporter]]. @@ -34,22 +38,28 @@ public enum TextureImporterFormat { Automatic = -1, // Choose a compressed format automatically. - [System.Obsolete("Use textureCompression property instead")] + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + [System.Obsolete("Enum member TextureImporterFormat.AutomaticCompressed is obsolete. Use the TextureImporter.textureCompression property instead.", true)] AutomaticCompressed = -1, // Choose a 16 bit format automatically. - [System.Obsolete("Use textureCompression property instead")] + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + [System.Obsolete("Enum member TextureImporterFormat.Automatic16bit is obsolete. Use TextureImporter.textureCompression property instead.", true)] Automatic16bit = -2, // Choose a Truecolor format automatically. - [System.Obsolete("Use textureCompression property instead")] + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + [System.Obsolete("Enum member TextureImporterFormat.AutomaticTruecolor is obsolete. Use the TextureImporter.textureCompression property instead.", true)] AutomaticTruecolor = -3, // Choose a Crunched format automatically. - [System.Obsolete("Use crunchedCompression property instead")] + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + [System.Obsolete("Enum member TextureImporterFormat.AutomaticCrunched is obsolete. Use the TextureImporter.crunchedCompression property instead.", true)] AutomaticCrunched = -5, // Choose an HDR format automatically. - [System.Obsolete("HDR is handled automatically now")] + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + [System.Obsolete("Enum member TextureImporterFormat.AutomaticHDR is obsolete. HDR is handled automatically now.", true)] AutomaticHDR = -6, // Choose a compresssed HDR format automatically. - [System.Obsolete("HDR is handled automatically now")] + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + [System.Obsolete("Enum member TextureImporterFormat.AutomaticCompressedHDR is obsolete. HDR is handled automatically now.", true)] AutomaticCompressedHDR = -7, // DXT1 compressed texture format. @@ -110,20 +120,31 @@ public enum TextureImporterFormat DXT5Crunched = 29, // PowerVR (iPhone) 2 bits/pixel compressed color texture format. + [System.Obsolete("Texture compression format PVRTC has been deprecated and will be removed in a future release")] + [EditorBrowsable(EditorBrowsableState.Never)] PVRTC_RGB2 = 30, // PowerVR (iPhone) 2 bits/pixel compressed with alpha channel texture format. + [System.Obsolete("Texture compression format PVRTC has been deprecated and will be removed in a future release")] + [EditorBrowsable(EditorBrowsableState.Never)] PVRTC_RGBA2 = 31, // PowerVR (iPhone) 4 bits/pixel compressed color texture format. + [System.Obsolete("Texture compression format PVRTC has been deprecated and will be removed in a future release")] + [EditorBrowsable(EditorBrowsableState.Never)] PVRTC_RGB4 = 32, // PowerVR (iPhone) 4 bits/pixel compressed with alpha channel texture format. + [System.Obsolete("Texture compression format PVRTC has been deprecated and will be removed in a future release")] + [EditorBrowsable(EditorBrowsableState.Never)] PVRTC_RGBA4 = 33, + // ETC (GLES2.0) 4 bits/pixel compressed RGB texture format. ETC_RGB4 = 34, // ATC (Android) 4 bits/pixel compressed RGB texture format. - [System.Obsolete("Use ETC_RGB4 (UnityUpgradable) -> ETC_RGB4")] + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + [System.Obsolete("Enum member ATC_RGB4 is obsolete. Use ETC_RGB4 (UnityUpgradable) -> ETC_RGB4", true)] ATC_RGB4 = 35, - [System.Obsolete("Use ETC2_RGBA8 (UnityUpgradable) -> ETC2_RGBA8")] + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + [System.Obsolete("Enum member ATC_RGBA8 is obsolete. Use ETC2_RGBA8 (UnityUpgradable) -> ETC2_RGBA8", true)] ATC_RGBA8 = 36, // EAC 4 bits/pixel compressed 16-bit R texture format @@ -151,47 +172,49 @@ public enum TextureImporterFormat ASTC_12x12 = 53, [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] - [System.Obsolete("Use ASTC_4x4 (UnityUpgradable) -> ASTC_4x4")] - ASTC_RGB_4x4 = 48, + [System.Obsolete("Enum member ASTC_RGB_4x4 is obsolete. Use ASTC_4x4 (UnityUpgradable) -> ASTC_4x4", true)] + ASTC_RGB_4x4 = -48, [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] - [System.Obsolete("Use ASTC_5x5 (UnityUpgradable) -> ASTC_5x5")] - ASTC_RGB_5x5 = 49, + [System.Obsolete("Enum member ASTC_RGB_5x5 is obsolete. Use ASTC_5x5 (UnityUpgradable) -> ASTC_5x5", true)] + ASTC_RGB_5x5 = -49, [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] - [System.Obsolete("Use ASTC_6x6 (UnityUpgradable) -> ASTC_6x6")] - ASTC_RGB_6x6 = 50, + [System.Obsolete("Enum member ASTC_RGB_6x6 is obsolete. Use ASTC_6x6 (UnityUpgradable) -> ASTC_6x6", true)] + ASTC_RGB_6x6 = -50, [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] - [System.Obsolete("Use ASTC_8x8 (UnityUpgradable) -> ASTC_8x8")] - ASTC_RGB_8x8 = 51, + [System.Obsolete("Enum member ASTC_RGB_8x8 is obsolete. Use ASTC_8x8 (UnityUpgradable) -> ASTC_8x8", true)] + ASTC_RGB_8x8 = -51, [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] - [System.Obsolete("Use ASTC_10x10 (UnityUpgradable) -> ASTC_10x10")] - ASTC_RGB_10x10 = 52, + [System.Obsolete("Enum member ASTC_RGB_10x10 is obsolete. Use ASTC_10x10 (UnityUpgradable) -> ASTC_10x10", true)] + ASTC_RGB_10x10 = -52, [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] - [System.Obsolete("Use ASTC_12x12 (UnityUpgradable) -> ASTC_12x12")] - ASTC_RGB_12x12 = 53, + [System.Obsolete("Enum member ASTC_RGB_12x12 is obsolete. Use ASTC_12x12 (UnityUpgradable) -> ASTC_12x12", true)] + ASTC_RGB_12x12 = -53, [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] - [System.Obsolete("Use ASTC_4x4 (UnityUpgradable) -> ASTC_4x4")] - ASTC_RGBA_4x4 = 54, + [System.Obsolete("Enum member ASTC_RGBA_4x4 is obsolete. Use ASTC_4x4 (UnityUpgradable) -> ASTC_4x4", true)] + ASTC_RGBA_4x4 = -54, [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] - [System.Obsolete("Use ASTC_5x5 (UnityUpgradable) -> ASTC_5x5")] - ASTC_RGBA_5x5 = 55, + [System.Obsolete("Enum member ASTC_RGBA_5x5 is obsolete. Use ASTC_5x5 (UnityUpgradable) -> ASTC_5x5", true)] + ASTC_RGBA_5x5 = -55, [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] - [System.Obsolete("Use ASTC_6x6 (UnityUpgradable) -> ASTC_6x6")] - ASTC_RGBA_6x6 = 56, + [System.Obsolete("Enum member ASTC_RGBA_6x6 is obsolete. Use ASTC_6x6 (UnityUpgradable) -> ASTC_6x6", true)] + ASTC_RGBA_6x6 = -56, [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] - [System.Obsolete("Use ASTC_8x8 (UnityUpgradable) -> ASTC_8x8")] - ASTC_RGBA_8x8 = 57, + [System.Obsolete("Enum member ASTC_RGBA_8x8 is obsolete. Use ASTC_8x8 (UnityUpgradable) -> ASTC_8x8", true)] + ASTC_RGBA_8x8 = -57, [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] - [System.Obsolete("Use ASTC_10x10 (UnityUpgradable) -> ASTC_10x10")] - ASTC_RGBA_10x10 = 58, + [System.Obsolete("Enum member ASTC_RGBA_10x10 is obsolete. Use ASTC_10x10 (UnityUpgradable) -> ASTC_10x10", true)] + ASTC_RGBA_10x10 = -58, [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] - [System.Obsolete("Use ASTC_12x12 (UnityUpgradable) -> ASTC_12x12")] - ASTC_RGBA_12x12 = 59, + [System.Obsolete("Enum member ASTC_RGBA_12x12 is obsolete. Use ASTC_12x12 (UnityUpgradable) -> ASTC_12x12", true)] + ASTC_RGBA_12x12 = -59, // Nintendo 3DS-flavoured ETC - [System.Obsolete("Nintendo 3DS is no longer supported.")] - ETC_RGB4_3DS = 60, - [System.Obsolete("Nintendo 3DS is no longer supported.")] - ETC_RGBA8_3DS = 61, + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + [System.Obsolete("Enum member ETC_RGB4_3DS is obsolete. Nintendo 3DS is no longer supported.", true)] + ETC_RGB4_3DS = -60, + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + [System.Obsolete("Enum member ETC_RGBA8_3DS is obsolete. Nintendo 3DS is no longer supported.", true)] + ETC_RGBA8_3DS = -61, // ETC1 crunched texture format. ETC_RGB4Crunched = 64, @@ -214,6 +237,14 @@ public enum TextureImporterFormat RG32 = 72, RGB48 = 73, RGBA64 = 74, + R8_SIGNED = 75, + RG16_SIGNED = 76, + RGB24_SIGNED = 77, + RGBA32_SIGNED = 78, + R16_SIGNED = 79, + RG32_SIGNED = 80, + RGB48_SIGNED = 81, + RGBA64_SIGNED = 82, } // Mip map filter for [[TextureImporter]]. @@ -295,25 +326,28 @@ public enum TextureImporterSingleChannelComponent public enum TextureImporterType { Default = 0, - [System.Obsolete("Use Default (UnityUpgradable) -> Default")] - Image = 0, NormalMap = 1, - [System.Obsolete("Use NormalMap (UnityUpgradable) -> NormalMap")] - Bump = 1, GUI = 2, Sprite = 8, Cursor = 7, - [System.Obsolete("Use importer.textureShape = TextureImporterShape.TextureCube")] - Cubemap = 3, - [System.Obsolete("Use a texture setup as a cubemap with glossy reflection instead")] - Reflection = 3, Cookie = 4, Lightmap = 6, - [System.Obsolete("HDRI is not supported anymore")] - HDRI = 9, - [System.Obsolete("Use Default instead. All texture types now have an Advanced foldout (UnityUpgradable) -> Default")] - Advanced = 5, - SingleChannel = 10 + SingleChannel = 10, + Shadowmask = 11, + DirectionalLightmap = 12, + + [System.Obsolete("Use Default (UnityUpgradable) -> Default", true)] + Image = Int32.MinValue, + [System.Obsolete("Use NormalMap (UnityUpgradable) -> NormalMap", true)] + Bump = -1, + [System.Obsolete("Use importer.textureShape = TextureImporterShape.TextureCube", true)] + Cubemap = -3, + [System.Obsolete("Use a texture setup as a cubemap with glossy reflection instead", true)] + Reflection = -3, + [System.Obsolete("Use Default instead. All texture types now have an Advanced foldout (UnityUpgradable) -> Default", true)] + Advanced = -5, + [System.Obsolete("HDRI is not supported anymore", true)] + HDRI = -9, } public enum TextureImporterCompression @@ -362,4 +396,26 @@ public enum AndroidETC2FallbackOverride // 32-bit uncompressed, downscaled 2x Quality32BitDownscaled = 3 } + + public enum TextureImporterSwizzle + { + R = 0, + G = 1, + B = 2, + A = 3, + OneMinusR = 4, + OneMinusG = 5, + OneMinusB = 6, + OneMinusA = 7, + Zero = 8, + One = 9 + } + + // Cookie light type mode for [[TextureImporter]]. + internal enum TextureImporterCookieLightType + { + Spot = 0, + Directional = 1, + Point = 2 + } } diff --git a/Editor/Mono/AssetPipeline/TextureImporterTypes.bindings.cs b/Editor/Mono/AssetPipeline/TextureImporterTypes.bindings.cs index 93f3aae558..a282894dd5 100644 --- a/Editor/Mono/AssetPipeline/TextureImporterTypes.bindings.cs +++ b/Editor/Mono/AssetPipeline/TextureImporterTypes.bindings.cs @@ -6,6 +6,7 @@ using System.Runtime.InteropServices; using UnityEngine; using UnityEngine.Bindings; +using UnityEngine.Serialization; namespace UnityEditor { @@ -17,6 +18,7 @@ public struct SpriteMetaData public int alignment; public Vector2 pivot; public Vector4 border; + internal string customData; } // Note: MUST match memory layout of TextureImporterSettings in TextureImporter.h! @@ -27,14 +29,14 @@ public struct SpriteMetaData [NativeType(CodegenOptions.Custom, "TextureImporterSettings")] [NativeHeader("Editor/Src/AssetPipeline/TextureImporting/TextureImporter.bindings.h")] [NativeHeader("Editor/Src/AssetPipeline/TextureImporting/TextureImporterTypes.h")] - public sealed partial class TextureImporterSettings + public sealed class TextureImporterSettings { [SerializeField] - int m_AlphaSource; + int m_AlphaSource = (int)TextureImporterAlphaSource.FromInput; [SerializeField] int m_MipMapMode; [SerializeField] - int m_EnableMipMap; + int m_EnableMipMap = 1; [SerializeField] int m_FadeOut; [SerializeField] @@ -57,6 +59,10 @@ public sealed partial class TextureImporterSettings [SerializeField] int m_NormalMapFilter; [SerializeField] + int m_FlipGreenChannel; + [SerializeField] + uint m_Swizzle = 0x03020100; + [SerializeField] int m_IsReadable; [SerializeField] @@ -64,11 +70,15 @@ public sealed partial class TextureImporterSettings [SerializeField] int m_StreamingMipmapsPriority; + [SerializeField] + int m_VTOnly; + [SerializeField, FormerlySerializedAs("m_IgnoreMasterTextureLimit")] + int m_IgnoreMipmapLimit; [SerializeField] int m_NPOTScale; [SerializeField] - int m_sRGBTexture; + int m_sRGBTexture = 1; [SerializeField] int m_SpriteMode; @@ -117,6 +127,9 @@ public sealed partial class TextureImporterSettings [SerializeField] int m_IgnorePngGamma; + [SerializeField] + int m_CookieMode; + // memory layout of these is in TextureSettings.h [SerializeField] [NativeName("m_TextureSettings.m_FilterMode")] @@ -260,6 +273,37 @@ public TextureImporterNormalFilter normalMapFilter get {return (TextureImporterNormalFilter)m_NormalMapFilter; } set { m_NormalMapFilter = (int)value; } } + public bool flipGreenChannel + { + get => m_FlipGreenChannel != 0; + set => m_FlipGreenChannel = value ? 1 : 0; + } + + public TextureImporterSwizzle swizzleR + { + get => (TextureImporterSwizzle)(m_Swizzle & 0xFF); + set => m_Swizzle = (m_Swizzle & 0xFFFFFF00) | (uint)value; + } + public TextureImporterSwizzle swizzleG + { + get => (TextureImporterSwizzle)((m_Swizzle >> 8) & 0xFF); + set => m_Swizzle = (m_Swizzle & 0xFFFF00FF) | ((uint)value<<8); + } + public TextureImporterSwizzle swizzleB + { + get => (TextureImporterSwizzle)((m_Swizzle >> 16) & 0xFF); + set => m_Swizzle = (m_Swizzle & 0xFF00FFFF) | ((uint)value<<16); + } + public TextureImporterSwizzle swizzleA + { + get => (TextureImporterSwizzle)((m_Swizzle >> 24) & 0xFF); + set => m_Swizzle = (m_Swizzle & 0x00FFFFFF) | ((uint)value<<24); + } + internal uint swizzleRaw + { + get => m_Swizzle; + set => m_Swizzle = value; + } public TextureImporterAlphaSource alphaSource { get {return (TextureImporterAlphaSource)m_AlphaSource; } @@ -300,6 +344,16 @@ public int streamingMipmapsPriority set { m_StreamingMipmapsPriority = value; } } + public bool vtOnly + { + get { return m_VTOnly != 0; } + set { m_VTOnly = value ? 1 : 0; } + } + public bool ignoreMipmapLimit + { + get { return m_IgnoreMipmapLimit != 0; } + set { m_IgnoreMipmapLimit = value ? 1 : 0; } + } public TextureImporterNPOTScale npotScale { @@ -551,6 +605,8 @@ public sealed partial class TextureImporterPlatformSettings [SerializeField] int m_Overridden = 0; [SerializeField] + int m_IgnorePlatformSupport = 0; + [SerializeField] int m_MaxTextureSize = 2048; [SerializeField] int m_ResizeAlgorithm = (int)TextureResizeAlgorithm.Mitchell; @@ -583,6 +639,12 @@ public bool overridden set { m_Overridden = value ? 1 : 0; } } + public bool ignorePlatformSupport + { + get { return m_IgnorePlatformSupport != 0; } + set { m_IgnorePlatformSupport = value ? 1 : 0; } + } + public int maxTextureSize { get { return m_MaxTextureSize; } diff --git a/Editor/Mono/AssetPipeline/TextureUtil.bindings.cs b/Editor/Mono/AssetPipeline/TextureUtil.bindings.cs index c5f2d5f3df..b8e5a75f56 100644 --- a/Editor/Mono/AssetPipeline/TextureUtil.bindings.cs +++ b/Editor/Mono/AssetPipeline/TextureUtil.bindings.cs @@ -5,36 +5,25 @@ using System; using UnityEngine; using UnityEngine.Bindings; - +using UnityEngine.Experimental.Rendering; //for GraphicsFormat namespace UnityEditor { [NativeHeader("Editor/Src/AssetPipeline/TextureImporting/TextureImporterUtils.h")] [NativeHeader("Runtime/Graphics/TextureFormat.h")] + [NativeHeader("Runtime/Graphics/Format.h")] internal static class TextureUtil { - [Obsolete("GetStorageMemorySize has been deprecated since it is limited to 2GB. Please use GetStorageMemorySizeLong() instead.")] - public static int GetStorageMemorySize(Texture t) - { - return (int)GetStorageMemorySizeLong(t); - } - [FreeFunction] - public static extern long GetStorageMemorySizeLong(Texture t); - - [Obsolete("GetRuntimeMemorySize has been deprecated since it is limited to 2GB. Please use GetRuntimeMemorySizeLong() instead.")] - public static int GetRuntimeMemorySize(Texture t) - { - return (int)GetRuntimeMemorySizeLong(t); - } + public static extern long GetStorageMemorySizeLong([NotNull] Texture t); [FreeFunction] - public static extern long GetRuntimeMemorySizeLong(Texture t); + public static extern long GetRuntimeMemorySizeLong([NotNull] Texture t); [FreeFunction] - public static extern bool IsNonPowerOfTwo(Texture2D t); + public static extern bool IsNonPowerOfTwo([NotNull] Texture2D t); [FreeFunction] - public static extern TextureUsageMode GetUsageMode(Texture t); + public static extern TextureUsageMode GetUsageMode([NotNull] Texture t); [FreeFunction] public static extern bool IsNormalMapUsageMode(TextureUsageMode usageMode); @@ -54,30 +43,41 @@ public static int GetRuntimeMemorySize(Texture t) [FreeFunction] public static extern bool IsValidTextureFormat(TextureFormat format); + [Obsolete("IsCompressedTextureFormat has been moved to GraphicsFormatUtility.IsCompressedFormat(TextureFormat)")] [FreeFunction("IsAnyCompressedTextureFormat")] public static extern bool IsCompressedTextureFormat(TextureFormat format); + [Obsolete("IsCompressedCrunchTextureFormat has been moved to GraphicsFormatUtility.IsCrunchFormat(TextureFormat)")] [FreeFunction("IsCompressedCrunchTextureFormat")] public static extern bool IsCompressedCrunchTextureFormat(TextureFormat format); [FreeFunction] - public static extern TextureFormat GetTextureFormat(Texture texture); + public static extern TextureFormat GetTextureFormat([NotNull] Texture texture); + [Obsolete("IsAlphaOnlyTextureFormat has been moved to GraphicsFormatUtility.IsAlphaOnlyFormat(TextureFormat)")] [FreeFunction] public static extern bool IsAlphaOnlyTextureFormat(TextureFormat format); + [Obsolete("IsHDRFormat has been moved to GraphicsFormatUtility.IsHDRFormat(TextureFormat)")] [FreeFunction] public static extern bool IsHDRFormat(TextureFormat format); + [Obsolete("IsHDRGraphicsFormat has been moved to GraphicsFormatUtility.IsHDRFormat(GraphicsFormat)")] + [FreeFunction("IsHDRFormat")] + public static extern bool IsHDRGraphicsFormat(GraphicsFormat format); + + [Obsolete("HasAlphaTextureFormat has been moved to GraphicsFormatUtility.HasAlphaChannel(TextureFormat)")] [FreeFunction] public static extern bool HasAlphaTextureFormat(TextureFormat format); + [Obsolete("GetTextureFormatString has been moved to GraphicsFormatUtility.GetFormatString(TextureFormat)")] [FreeFunction] public static extern string GetTextureFormatString(TextureFormat format); [FreeFunction] - public static extern string GetTextureColorSpaceString(Texture texture); + public static extern string GetTextureColorSpaceString([NotNull] Texture texture); + [Obsolete("ConvertToAlphaTextureFormat has been moved to GraphicsFormatUtility.ConvertToAlphaFormat(TextureFormat)")] [FreeFunction] public static extern TextureFormat ConvertToAlphaTextureFormat(TextureFormat format); @@ -87,22 +87,22 @@ public static bool IsDepthRTFormat(RenderTextureFormat format) } [FreeFunction] - public static extern bool HasMipMap(Texture t); + public static extern bool HasMipMap([NotNull] Texture t); [FreeFunction] - public static extern bool NeedsExposureControl(Texture t); + public static extern bool NeedsExposureControl([NotNull] Texture t); [FreeFunction] - public static extern int GetGPUWidth(Texture t); + public static extern int GetGPUWidth([NotNull] Texture t); [FreeFunction] - public static extern int GetGPUHeight(Texture t); + public static extern int GetGPUHeight([NotNull] Texture t); [FreeFunction] - public static extern int GetMipmapCount(Texture t); + public static extern int GetMipmapCount([NotNull] Texture t); [FreeFunction] - public static extern bool GetLinearSampled(Texture t); + public static extern bool GetLinearSampled([NotNull] Texture t); public static int GetDefaultCompressionQuality() { @@ -110,25 +110,25 @@ public static int GetDefaultCompressionQuality() } [FreeFunction] - public static extern Vector4 GetTexelSizeVector(Texture t); + public static extern Vector4 GetTexelSizeVector([NotNull] Texture t); [FreeFunction] - public static extern Texture2D GetSourceTexture(Cubemap cubemapRef, CubemapFace face); + public static extern Texture2D GetSourceTexture([NotNull] Cubemap cubemapRef, CubemapFace face); [FreeFunction] - public static extern void SetSourceTexture(Cubemap cubemapRef, CubemapFace face, Texture2D tex); + public static extern void SetSourceTexture([NotNull] Cubemap cubemapRef, CubemapFace face, Texture2D tex); [FreeFunction] - public static extern void CopyTextureIntoCubemapFace(Texture2D textureRef, Cubemap cubemapRef, CubemapFace face); + public static extern void CopyTextureIntoCubemapFace([NotNull] Texture2D textureRef, [NotNull] Cubemap cubemapRef, CubemapFace face); [FreeFunction] - public static extern void CopyCubemapFaceIntoTexture(Cubemap cubemapRef, CubemapFace face, Texture2D textureRef); + public static extern void CopyCubemapFaceIntoTexture([NotNull] Cubemap cubemapRef, CubemapFace face, [NotNull] Texture2D textureRef); [FreeFunction] - public static extern bool ReformatCubemap(Cubemap cubemap, int width, int height, TextureFormat textureFormat, bool useMipmap, bool linear); + public static extern bool ReformatCubemap([NotNull] Cubemap cubemap, int width, int height, TextureFormat textureFormat, bool useMipmap, bool linear); [FreeFunction] - public static extern bool ReformatTexture(ref Texture2D texture, int width, int height, TextureFormat textureFormat, bool useMipmap, bool linear); + public static extern bool ReformatTexture([NotNull] ref Texture2D texture, int width, int height, TextureFormat textureFormat, bool useMipmap, bool linear); [FreeFunction] public static extern void SetAnisoLevelNoDirty(Texture tex, int level); @@ -143,10 +143,7 @@ public static int GetDefaultCompressionQuality() public static extern void SetFilterModeNoDirty(Texture tex, FilterMode mode); [FreeFunction] - public static extern bool DoesTextureStillNeedToBeCompressed(string assetPath); - - [FreeFunction] - public static extern bool IsCubemapReadable(Cubemap cubemapRef); + public static extern bool IsCubemapReadable([NotNull] Cubemap cubemapRef); [FreeFunction] public static extern void MarkCubemapReadable(Cubemap cubemapRef, bool readable); diff --git a/Editor/Mono/AssetPostprocessor.cs b/Editor/Mono/AssetPostprocessor.cs index 99617add6b..cd90784455 100644 --- a/Editor/Mono/AssetPostprocessor.cs +++ b/Editor/Mono/AssetPostprocessor.cs @@ -5,24 +5,53 @@ using UnityEngine; using UnityEngine.Internal; using UnityEngine.Scripting; -using UnityEngine.Profiling; using System; -using System.Collections; using System.Collections.Generic; using System.Linq; using System.Reflection; using UnityEditor.AssetImporters; using Object = UnityEngine.Object; -using UnityEditor.Experimental.AssetImporters; -using UnityEditorInternal; -using Unity.CodeEditor; using UnityEditor.Profiling; +using UnityEditor.Callbacks; namespace UnityEditor { // AssetPostprocessor lets you hook into the import pipeline and run scripts prior or after importing assets. public partial class AssetPostprocessor { + internal struct PostprocessorInfo + { + public Type Type { get; } + public string[] Methods { get; } + public uint Version { get; } + public int Priority { get; } + /// + /// StaticDependency is true if any method in the postprocessor is not part of the NonAutomaticDependencyMethods list. + /// This is used to know which PostprocessorInfo should be used for the static importer dependency hash. + /// + public bool StaticDependency { get; } + + public PostprocessorInfo(Type assetPostprocessorType, int importerPriority) + { + Type = assetPostprocessorType; + Methods = null; + Version = 0; + StaticDependency = false; + Priority = importerPriority; + } + + public PostprocessorInfo(Type assetPostprocessorType, string[] implementedMethods) + { + Type = assetPostprocessorType; + Methods = implementedMethods; + StaticDependency = Methods.Intersect(AssetPostprocessingInternal.k_NonAutomaticDependencyMethods).Count() != Methods.Length; + + var inst = (AssetPostprocessor)Activator.CreateInstance(assetPostprocessorType); + Version = inst.GetVersion(); + Priority = inst.GetPostprocessOrder(); + } + } + private string m_PathName; private AssetImportContext m_Context; @@ -34,23 +63,39 @@ public partial class AssetPostprocessor // Logs an import warning to the console. [ExcludeFromDocs] + [Obsolete("Use context.LogImportWarning(string) instead.")] public void LogWarning(string warning) { Object context = null; LogWarning(warning, context); } - public void LogWarning(string warning, [DefaultValue("null")] Object context) { Debug.LogWarning(warning, context); } + [Obsolete("Use context.LogImportWarning(string, Object) instead.")] + public void LogWarning(string warning, [DefaultValue("null")] Object context) + { + if (m_Context != null) + m_Context.LogImportWarning(warning, context); + else + Debug.LogWarning(warning, context); + } // Logs an import error message to the console. [ExcludeFromDocs] + [Obsolete("Use context.LogImportError(string) instead.")] public void LogError(string warning) { Object context = null; LogError(warning, context); } - public void LogError(string warning, [DefaultValue("null")] Object context) { Debug.LogError(warning, context); } + [Obsolete("Use context.LogImportError(string, Object) instead.")] + public void LogError(string warning, [DefaultValue("null")] Object context) + { + if (m_Context != null) + m_Context.LogImportError(warning, context); + else + Debug.LogError(warning, context); + } // Returns the version of the asset postprocessor. public virtual uint GetVersion() { return 0; } @@ -67,8 +112,179 @@ public void LogError(string warning) } + class OnPostprocessAllAssetsCallbackCollection : OrderedCallbackCollection + { + public class MethodInfoCallback : Callback + { + public MethodInfo Method { get; } + + public override Type classType => Method.DeclaringType; + + public bool MethodDomainReload { get; } + + public override string name => classType.FullName; + + public MethodInfoCallback(MethodInfo method, bool methodDomainReload) + { + Method = method; + MethodDomainReload = methodDomainReload; + } + + public override IEnumerable GetCustomAttributes() => Method.GetCustomAttributes(); + } + + public override string name => "OnPostprocessAllAssets"; + + public override List GetCallbacks() + { + var methodArgTypes = new Type[] { typeof(string).MakeArrayType(), typeof(string).MakeArrayType(), typeof(string).MakeArrayType(), typeof(string).MakeArrayType() }; + var methodDomainReloadParamArgTypes = new Type[] { methodArgTypes[0], methodArgTypes[1], methodArgTypes[2], methodArgTypes[3], typeof(bool) }; + const BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static; + + var callbacks = new List(); + foreach (var assetPostprocessorClass in TypeCache.GetTypesDerivedFrom()) + { + var method = assetPostprocessorClass.GetMethod("OnPostprocessAllAssets", flags, null, methodArgTypes, null); + if (method != null) + { + callbacks.Add(new MethodInfoCallback(method, false)); + } + else + { + // OnPostprocessAllAssets with didDomainReload parameter + method = assetPostprocessorClass.GetMethod("OnPostprocessAllAssets", flags, null, methodDomainReloadParamArgTypes, null); + if (method != null) + { + callbacks.Add(new MethodInfoCallback(method, true)); + } + } + } + + return callbacks; + } + } + internal class AssetPostprocessingInternal { + // What is it: + // Static postprocessor methods always called for each importer that are part of importer static dependency. + // No new postprocessors should be added to these lists. Please reach out to #devs-import-workflow to talk about new additions. + internal static readonly string[] k_NonAutomaticDependencyMethods = + { + "OnPreprocessAsset", + }; + static readonly string[] k_ModelImporterPostprocessors = + { + "OnPreprocessModel", + "OnPostprocessMeshHierarchy", + "OnPostprocessModel", + "OnPreprocessAnimation", + "OnPostprocessAnimation", + "OnPostprocessGameObjectWithAnimatedUserProperties", + "OnPostprocessGameObjectWithUserProperties", + "OnPostprocessMaterial", + "OnAssignMaterialModel", + "OnPreprocessMaterialDescription", + }; + + static readonly string[] k_DynamicModelImporterPostprocessors = + { + "OnPreprocessCameraDescription", + "OnPreprocessLightDescription" + }; + + static readonly string[] k_TextureImporterPostprocessors = + { + "OnPreprocessTexture", + "OnPostprocessTexture", + "OnPostprocessCubemap", + "OnPostprocessSprites", + "OnPostprocessTexture3D", + "OnPostprocessTexture2DArray" + }; + + static readonly string[] k_IHVImporterPostprocessors = + { + "OnPostprocessTexture", + }; + static readonly string[] k_AudioImporterPostprocessors = + { + "OnPreprocessAudio", + "OnPostprocessAudio", + }; + static readonly string[] k_SpeedTreeImporterPostprocessors = + { + "OnPreprocessSpeedTree", + "OnPostprocessSpeedTree", + }; + static readonly string[] k_PrefabImporterPostprocessors = + { + "OnPostprocessPrefab", + }; + static readonly string[] k_CameraPostprocessors = + { + "OnPreprocessCameraDescription", + }; + static readonly string[] k_LightPostprocessors = + { + "OnPreprocessLightDescription", + }; + static readonly string[] k_TexturePreprocessors = + { + "OnPreprocessTexture", + }; + static readonly string[] k_Texture2DPostprocessors = + { + "OnPostprocessTexture", + }; + static readonly string[] k_Texture2DArrayPostprocessors = + { + "OnPostprocessTexture2DArray" + }; + static readonly string[] k_Texture3DPostprocessors = + { + "OnPostprocessTexture3D" + }; + static readonly string[] k_TextureCubePostprocessors = + { + "OnPostprocessCubemap" + }; + static readonly string[] k_SpritePostprocessors = + { + "OnPostprocessSprites", + }; + + static Dictionary s_PostprocessorMethodsByDependencyKey; + static Dictionary s_StaticPostprocessorMethodsByImporterType; + static Dictionary s_DynamicPostprocessorMethodsByImporterType; + + // Internal for debugging purposes. We can generate dependency graphs to help understand issues. + internal static OnPostprocessAllAssetsCallbackCollection s_OnPostprocessAllAssetsCallbacks = new OnPostprocessAllAssetsCallbackCollection(); + + static AssetPostprocessingInternal() + { + s_StaticPostprocessorMethodsByImporterType = new Dictionary(); + s_StaticPostprocessorMethodsByImporterType.Add(typeof(ModelImporter), k_ModelImporterPostprocessors); + s_StaticPostprocessorMethodsByImporterType.Add(typeof(IHVImageFormatImporter), k_IHVImporterPostprocessors); + s_StaticPostprocessorMethodsByImporterType.Add(typeof(SpeedTreeImporter), k_SpeedTreeImporterPostprocessors); + s_StaticPostprocessorMethodsByImporterType.Add(typeof(AudioImporter), k_AudioImporterPostprocessors); + s_StaticPostprocessorMethodsByImporterType.Add(typeof(PrefabImporter), k_PrefabImporterPostprocessors); + + s_DynamicPostprocessorMethodsByImporterType = new Dictionary(); + s_DynamicPostprocessorMethodsByImporterType.Add(typeof(ModelImporter), k_DynamicModelImporterPostprocessors); + s_DynamicPostprocessorMethodsByImporterType.Add(typeof(TextureImporter), k_TextureImporterPostprocessors); + + s_PostprocessorMethodsByDependencyKey = new Dictionary(); + s_PostprocessorMethodsByDependencyKey.Add(kCameraPostprocessorDependencyName, k_CameraPostprocessors); + s_PostprocessorMethodsByDependencyKey.Add(kLightPostprocessorDependencyName, k_LightPostprocessors); + s_PostprocessorMethodsByDependencyKey.Add(kTexturePreprocessorDependencyName, k_TexturePreprocessors); + s_PostprocessorMethodsByDependencyKey.Add(kTexture2DPostprocessorDependencyName, k_Texture2DPostprocessors); + s_PostprocessorMethodsByDependencyKey.Add(kTexture2DArrayPostprocessorDependencyName, k_Texture2DArrayPostprocessors); + s_PostprocessorMethodsByDependencyKey.Add(kTexture3DPostprocessorDependencyName, k_Texture3DPostprocessors); + s_PostprocessorMethodsByDependencyKey.Add(kTextureCubePostprocessorDependencyName, k_TextureCubePostprocessors); + s_PostprocessorMethodsByDependencyKey.Add(kTextureSpritePostprocessorDependencyName, k_SpritePostprocessors); + } + [Serializable] class AssetPostProcessorAnalyticsData { @@ -91,111 +307,80 @@ static void LogPostProcessorMissingDefaultConstructor(Type type) [RequiredByNativeCode] // Postprocess on all assets once an automatic import has completed - static void PostprocessAllAssets(string[] importedAssets, string[] addedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromPathAssets) + static void PostprocessAllAssets(string[] importedAssets, string[] addedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromPathAssets, bool didDomainReload) { object[] args = { importedAssets, deletedAssets, movedAssets, movedFromPathAssets }; - foreach (var assetPostprocessorClass in GetCachedAssetPostprocessorClasses()) + object[] argsWithDidDomainReload = { importedAssets, deletedAssets, movedAssets, movedFromPathAssets, didDomainReload}; + var containsNoAssets = importedAssets.Length == 0 && addedAssets.Length == 0 && deletedAssets.Length == 0 && movedAssets.Length == 0 && movedFromPathAssets.Length == 0; + + foreach (OnPostprocessAllAssetsCallbackCollection.MethodInfoCallback assetPostProcessor in s_OnPostprocessAllAssetsCallbacks.sortedCallbacks) { - MethodInfo method = assetPostprocessorClass.GetMethod("OnPostprocessAllAssets", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); - if (method != null) + try { - InvokeMethod(method, args); + if (assetPostProcessor.MethodDomainReload) + { + using (new EditorPerformanceMarker($"{assetPostProcessor.classType.Name}.OnPostprocessAllAssets", assetPostProcessor.classType).Auto()) + InvokeMethod(assetPostProcessor.Method, argsWithDidDomainReload); + } + else + { + if (containsNoAssets) + continue; + + using (new EditorPerformanceMarker($"{assetPostProcessor.classType.Name}.OnPostprocessAllAssets", assetPostProcessor.classType).Auto()) + InvokeMethod(assetPostProcessor.Method, args); + } + } + catch (Exception e) + { + Debug.LogException(e); } } - Profiler.BeginSample("SyncVS.PostprocessSyncProject"); - #pragma warning disable 618 - if (ScriptEditorUtility.GetScriptEditorFromPath(CodeEditor.CurrentEditorInstallation) == ScriptEditorUtility.ScriptEditor.Other - || ScriptEditorUtility.GetScriptEditorFromPath(CodeEditor.CurrentEditorInstallation) == ScriptEditorUtility.ScriptEditor.SystemDefault) - { + using (new EditorPerformanceMarker("SyncVS.PostprocessSyncProject").Auto()) CodeEditorProjectSync.PostprocessSyncProject(importedAssets, addedAssets, deletedAssets, movedAssets, movedFromPathAssets); - } - else - { - ///@TODO: we need addedAssets for SyncVS. Make this into a proper API and write tests - SyncVS.PostprocessSyncProject(importedAssets, addedAssets, deletedAssets, movedAssets, movedFromPathAssets); - } - Profiler.EndSample(); } - [RequiredByNativeCode] - static void PreprocessAssembly(string pathName) + internal class CompareAssetImportPriority : IComparer, IComparer { - foreach (AssetPostprocessor inst in m_ImportProcessors) + public int Compare(AssetPostprocessor.PostprocessorInfo x, AssetPostprocessor.PostprocessorInfo y) { - InvokeMethodIfAvailable(inst, "OnPreprocessAssembly", new[] { pathName }); - } - } + int xo = x.Priority; + int yo = y.Priority; - //This is undocumented, and a "safeguard" for when visualstudio gets a new release that is incompatible with ours, so that users can postprocess our csproj to fix it. - //(or just completely replace them). Hopefully we'll never need this. - static internal void CallOnGeneratedCSProjectFiles() - { - object[] args = {}; - foreach (var method in AllPostProcessorMethodsNamed("OnGeneratedCSProjectFiles")) - { - InvokeMethod(method, args); - } - } - - //This callback is used by C# code editors to modify the .sln file. - static internal string CallOnGeneratedSlnSolution(string path, string content) - { - foreach (var method in AllPostProcessorMethodsNamed("OnGeneratedSlnSolution")) - { - object[] args = { path, content }; - object returnValue = InvokeMethod(method, args); - - if (method.ReturnType == typeof(string)) - content = (string)returnValue; + var compare = xo.CompareTo(yo); + if (compare == 0) + { + compare = x.Type.FullName.CompareTo(y.Type.FullName); + if (compare == 0) + compare = x.Type.AssemblyQualifiedName.CompareTo(y.Type.AssemblyQualifiedName); + } + return compare; } - return content; - } - - // This callback is used by C# code editors to modify the .csproj files. - static internal string CallOnGeneratedCSProject(string path, string content) - { - foreach (var method in AllPostProcessorMethodsNamed("OnGeneratedCSProject")) + public int Compare(AssetPostprocessor x, AssetPostprocessor y) { - object[] args = { path, content }; - object returnValue = InvokeMethod(method, args); - - if (method.ReturnType == typeof(string)) - content = (string)returnValue; + var xi = new AssetPostprocessor.PostprocessorInfo(x.GetType(), x.GetPostprocessOrder()); + var yi = new AssetPostprocessor.PostprocessorInfo(y.GetType(), y.GetPostprocessOrder()); + return Compare(xi, yi); } - - return content; } - //This callback is used by UnityVS to take over project generation from unity - static internal bool OnPreGeneratingCSProjectFiles() + private static string BuildStaticDependencyHashString(SortedSet list) { - object[] args = {}; - bool result = false; - foreach (var method in AllPostProcessorMethodsNamed("OnPreGeneratingCSProjectFiles")) + var hashStr = ""; + foreach (var info in list) { - object returnValue = InvokeMethod(method, args); - - if (method.ReturnType == typeof(bool)) - result = result | (bool)returnValue; + if (info.StaticDependency) + { + hashStr += info.Type.AssemblyQualifiedName; + hashStr += '.'; + hashStr += info.Version; + hashStr += '|'; + } } - return result; - } - private static IEnumerable AllPostProcessorMethodsNamed(string callbackName) - { - return GetCachedAssetPostprocessorClasses().Select(assetPostprocessorClass => assetPostprocessorClass.GetMethod(callbackName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static)).Where(method => method != null); - } - - internal class CompareAssetImportPriority : IComparer - { - int IComparer.Compare(System.Object xo, System.Object yo) - { - int x = ((AssetPostprocessor)xo).GetPostprocessOrder(); - int y = ((AssetPostprocessor)yo).GetPostprocessOrder(); - return x.CompareTo(y); - } + return hashStr; } private static string BuildHashString(SortedList list) @@ -212,19 +397,36 @@ private static string BuildHashString(SortedList list) return hashStr; } - internal class PostprocessStack - { - internal ArrayList m_ImportProcessors = null; - } + internal const string kCameraPostprocessorDependencyName = "postprocessor/camera"; + internal const string kLightPostprocessorDependencyName = "postprocessor/light"; + internal const string kTexture2DPostprocessorDependencyName = "postprocessor/texture2D"; + internal const string kTextureCubePostprocessorDependencyName = "postprocessor/textureCube"; + internal const string kTexture3DPostprocessorDependencyName = "postprocessor/texture3D"; + internal const string kTexture2DArrayPostprocessorDependencyName = "postprocessor/texture2DArray"; + internal const string kTextureSpritePostprocessorDependencyName = "postprocessor/textureSprite"; + internal const string kTexturePreprocessorDependencyName = "postprocessor/texturePreprocessor"; + + static Stack> m_PostprocessStack = null; + static SortedSet m_ImportProcessors = null; - static ArrayList m_PostprocessStack = null; - static ArrayList m_ImportProcessors = null; static Type[] m_PostprocessorClasses = null; static string m_MeshProcessorsHashString = null; - static string m_TextureProcessorsHashString = null; static string m_AudioProcessorsHashString = null; static string m_SpeedTreeProcessorsHashString = null; static string m_PrefabProcessorsHashString = null; + static string m_CameraProcessorsHashString = null; + static string m_LightProcessorsHashString = null; + static string m_Texture2DProcessorsHashString = null; + static string m_TextureCubeProcessorsHashString = null; + static string m_Texture3DPostprocessorDependencyName = null; + static string m_Texture2DArrayDependencyName = null; + static string m_TextureSpriteDependencyName = null; + static string m_TexturePreprocessorDependencyName = null; + + static Dictionary> s_StaticPostprocessorsPerImporterType = new Dictionary>(); + static Dictionary> s_DynamicPostprocessorsPerImporterType = new Dictionary>(); + + static Stack s_AnalyticsEventsStack = new Stack(); static Type[] GetCachedAssetPostprocessorClasses() { @@ -234,116 +436,201 @@ static Type[] GetCachedAssetPostprocessorClasses() } [RequiredByNativeCode] - static void InitPostprocessors(AssetImportContext context, string pathName) + static void InitPostprocessorsForTextureGenerator(string pathName) { - m_ImportProcessors = new ArrayList(); var analyticsEvent = new AssetPostProcessorAnalyticsData(); - analyticsEvent.importActionId = ((int)Math.Floor(AssetImporter.GetAtPath(pathName).GetImportStartTime() * 1000)).ToString(); + analyticsEvent.importActionId = "None"; s_AnalyticsEventsStack.Push(analyticsEvent); - // @TODO: This is just a temporary workaround for the import settings. - // We should add importers to the asset, persist them and show an inspector for them. - foreach (Type assetPostprocessorClass in GetCachedAssetPostprocessorClasses()) + m_ImportProcessors = new SortedSet(new CompareAssetImportPriority()); + foreach (var postprocessorInfo in GetSortedStaticPostprocessorTypes(typeof(TextureImporter))) { - try - { - var assetPostprocessor = Activator.CreateInstance(assetPostprocessorClass) as AssetPostprocessor; - assetPostprocessor.assetPath = pathName; - assetPostprocessor.context = context; - m_ImportProcessors.Add(assetPostprocessor); - } - catch (MissingMethodException) - { - LogPostProcessorMissingDefaultConstructor(assetPostprocessorClass); - } - catch (Exception e) - { - Debug.LogException(e); - } + var assetPostprocessor = (AssetPostprocessor)Activator.CreateInstance(postprocessorInfo.Type); + assetPostprocessor.assetPath = pathName; + assetPostprocessor.context = null; + m_ImportProcessors.Add(assetPostprocessor); } - m_ImportProcessors.Sort(new CompareAssetImportPriority()); + foreach (var postprocessorInfo in GetSortedDynamicPostprocessorTypes(typeof(TextureImporter))) + { + var assetPostprocessor = (AssetPostprocessor)Activator.CreateInstance(postprocessorInfo.Type); + assetPostprocessor.assetPath = pathName; + assetPostprocessor.context = null; + m_ImportProcessors.Add(assetPostprocessor); + } - // Setup postprocessing stack to support rentrancy (Import asset immediate) - PostprocessStack postStack = new PostprocessStack(); - postStack.m_ImportProcessors = m_ImportProcessors; + // Setup postprocessing stack to support reentrancy (Import asset immediate) if (m_PostprocessStack == null) - m_PostprocessStack = new ArrayList(); - m_PostprocessStack.Add(postStack); + m_PostprocessStack = new Stack>(); + m_PostprocessStack.Push(m_ImportProcessors); } [RequiredByNativeCode] - static void CleanupPostprocessors() + static void InitPostprocessors(AssetImportContext context, string pathName, Type importerType, double importStartTime) { - if (m_PostprocessStack != null) + var analyticsEvent = new AssetPostProcessorAnalyticsData(); + analyticsEvent.importActionId = ((int)Math.Floor(importStartTime * 1000)).ToString(); + s_AnalyticsEventsStack.Push(analyticsEvent); + + m_ImportProcessors = new SortedSet(new CompareAssetImportPriority()); + foreach (var postprocessorInfo in GetSortedStaticPostprocessorTypes(importerType)) { - m_PostprocessStack.RemoveAt(m_PostprocessStack.Count - 1); - if (m_PostprocessStack.Count != 0) - { - PostprocessStack postStack = (PostprocessStack)m_PostprocessStack[m_PostprocessStack.Count - 1]; - m_ImportProcessors = postStack.m_ImportProcessors; - } + var assetPostprocessor = (AssetPostprocessor)Activator.CreateInstance(postprocessorInfo.Type); + assetPostprocessor.assetPath = pathName; + assetPostprocessor.context = context; + m_ImportProcessors.Add(assetPostprocessor); } - if (s_AnalyticsEventsStack.Peek().postProcessorCalls.Count != 0) - EditorAnalytics.SendAssetPostprocessorsUsage(s_AnalyticsEventsStack.Peek()); + foreach (var postprocessorInfo in GetSortedDynamicPostprocessorTypes(importerType)) + { + var assetPostprocessor = (AssetPostprocessor)Activator.CreateInstance(postprocessorInfo.Type); + assetPostprocessor.assetPath = pathName; + assetPostprocessor.context = context; + m_ImportProcessors.Add(assetPostprocessor); + } - s_AnalyticsEventsStack.Pop(); + // Setup postprocessing stack to support reentrancy (Import asset immediate) + if (m_PostprocessStack == null) + m_PostprocessStack = new Stack>(); + m_PostprocessStack.Push(m_ImportProcessors); } - static bool ImplementsAnyOfTheses(Type type, string[] methods) + [RequiredByNativeCode] + static void CleanupPostprocessors() { - foreach (var method in methods) + if (m_PostprocessStack != null) { - if (type.GetMethod(method, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) != null) - return true; + m_PostprocessStack.Pop(); + m_ImportProcessors = m_PostprocessStack.Count > 0 ? m_PostprocessStack.Peek() : null; + } + + if (s_AnalyticsEventsStack.Count > 0) + { + var lastEvent = s_AnalyticsEventsStack.Pop(); + if (lastEvent.postProcessorCalls.Count > 0) + EditorAnalytics.SendAssetPostprocessorsUsage(lastEvent); } - return false; } - [RequiredByNativeCode] - static string GetMeshProcessorsHashString() + static bool ImplementsAnyOfTheses(Type type, IEnumerable methods, out List usedMethods) { - if (m_MeshProcessorsHashString != null) - return m_MeshProcessorsHashString; + usedMethods = new List(methods.Where(method => type.GetMethod(method, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) != null)); + return usedMethods.Count > 0; + } - var versionsByType = new SortedList(); + /* + * Returns the list of actual dynamic postprocessor methods for a particular asset. + * Note: That where the asset is not yet imported, this list will be empty. + */ + internal static SortedSet GetSortedDynamicPostprocessorsForAsset(string path) + { + var list = new SortedSet(new CompareAssetImportPriority()); - foreach (var assetPostprocessorClass in GetCachedAssetPostprocessorClasses()) + var guid = AssetDatabase.GUIDFromAssetPath(path); + if (guid.Empty()) + return list; + + //Artifact Infos may contains multiple artifacts, associated with different version of the object (E.g. Main, Preview etc.) + var artifactInfos = AssetDatabase.GetArtifactInfos(guid); + + var allMethodsNames = new List(); + foreach (var info in artifactInfos) { - try + if (!info.isCurrentArtifact) + continue; + + foreach (var kvp in info.dependencies) { - var inst = Activator.CreateInstance(assetPostprocessorClass) as AssetPostprocessor; - var type = inst.GetType(); - bool hasAnyPostprocessMethod = ImplementsAnyOfTheses(type, new[] - { - "OnPreprocessModel", - "OnPostprocessMeshHierarchy", - "OnPostprocessModel", - "OnPreprocessAnimation", - "OnPostprocessAnimation", - "OnPostprocessGameObjectWithAnimatedUserProperties", - "OnPostprocessGameObjectWithUserProperties", - "OnPostprocessMaterial", - "OnAssignMaterialModel", - "OnPreprocessMaterialDescription" - }); - uint version = inst.GetVersion(); - if (hasAnyPostprocessMethod) + if (kvp.Value.type == ArtifactInfoDependencyType.Dynamic) { - versionsByType.Add(type.FullName, version); + //Try to retrieve Postprocessor Methods associated with the supplied Dependency keys + string dependencyName = kvp.Key.Replace(ArtifactDifferenceReporter.kEnvironment_CustomDependency + "/", ""); + if (s_PostprocessorMethodsByDependencyKey.TryGetValue(dependencyName, out var methodNames)) + allMethodsNames.AddRange(methodNames); } } - catch (MissingMethodException) + } + + if (allMethodsNames.Count == 0) + return list; + + /* + * The asset has dynamic dependencies to an Asset Postprocessor, so let's find any Postprocessors which + * implements those methods. + */ + var distinctMethodNames = allMethodsNames.Distinct(); + foreach (Type assetPostprocessorClass in GetCachedAssetPostprocessorClasses()) + { + if (ImplementsAnyOfTheses(assetPostprocessorClass, distinctMethodNames, out var methods)) { - LogPostProcessorMissingDefaultConstructor(assetPostprocessorClass); + if (assetPostprocessorClass.GetConstructors().Any(t => t.GetParameters().Count() == 0)) + list.Add(new AssetPostprocessor.PostprocessorInfo(assetPostprocessorClass, methods.ToArray())); + else + LogPostProcessorMissingDefaultConstructor(assetPostprocessorClass); } - catch (Exception e) + } + + return list; + } + + internal static SortedSet GetSortedStaticPostprocessorTypes(Type importer) + { + var defaultMethods = new string[] + { + "OnPreprocessAsset" + }; + return GetSortedPostprocessorTypes(importer, s_StaticPostprocessorMethodsByImporterType, defaultMethods, + s_StaticPostprocessorsPerImporterType); + } + + /* + * Returns the list of *possible* dynamic postprocessor methods associated with a particular importer type. + * See also: GetSortedDynamicPostprocessorsForAsset, to get the actual postprocessor methods for a given asset. + */ + internal static SortedSet GetSortedDynamicPostprocessorTypes(Type importer) + { + return GetSortedPostprocessorTypes(importer, s_DynamicPostprocessorMethodsByImporterType, new string[0], + s_DynamicPostprocessorsPerImporterType); + } + + static SortedSet GetSortedPostprocessorTypes(Type importer, Dictionary postprocessorMethodsByImporterType, string[] defaultMethods, Dictionary> cache) + { + if (cache.TryGetValue(importer, out var cachedPostprocessors)) + return cachedPostprocessors; + + var list = new SortedSet(new CompareAssetImportPriority()); + var allMethodsNames = defaultMethods.ToList(); + var methodsType = importer; + while (methodsType != null && methodsType != typeof(AssetImporter)) + { + if (postprocessorMethodsByImporterType.TryGetValue(methodsType, out var methodNames)) + allMethodsNames.AddRange(methodNames); + methodsType = methodsType.BaseType; + } + + foreach (Type assetPostprocessorClass in GetCachedAssetPostprocessorClasses()) + { + if (ImplementsAnyOfTheses(assetPostprocessorClass, allMethodsNames, out var methods)) { - Debug.LogException(e); + if (assetPostprocessorClass.GetConstructors().Any(t => t.GetParameters().Count() == 0)) + list.Add(new AssetPostprocessor.PostprocessorInfo(assetPostprocessorClass, methods.ToArray())); + else + LogPostProcessorMissingDefaultConstructor(assetPostprocessorClass); } } - m_MeshProcessorsHashString = BuildHashString(versionsByType); + + cache.Add(importer, list); + + return list; + } + + [RequiredByNativeCode] + static string GetMeshProcessorsHashString() + { + if (m_MeshProcessorsHashString != null) + return m_MeshProcessorsHashString; + + m_MeshProcessorsHashString = BuildStaticDependencyHashString(GetSortedStaticPostprocessorTypes(typeof(ModelImporter))); return m_MeshProcessorsHashString; } @@ -357,7 +644,7 @@ static void PreprocessAsset() } [RequiredByNativeCode] - static void PreprocessMesh(string pathName) + static void PreprocessModel(string pathName) { CallPostProcessMethods("OnPreprocessModel", null); } @@ -410,12 +697,14 @@ static void PostprocessMeshHierarchy(GameObject root) CallPostProcessMethods("OnPostprocessMeshHierarchy", args); } + [RequiredByNativeCode] static void PostprocessMesh(GameObject gameObject) { object[] args = { gameObject }; CallPostProcessMethods("OnPostprocessModel", args); } + [RequiredByNativeCode] static void PostprocessSpeedTree(GameObject gameObject) { object[] args = { gameObject }; @@ -429,6 +718,22 @@ static void PostprocessMaterial(Material material) CallPostProcessMethods("OnPostprocessMaterial", args); } + [RequiredByNativeCode] + static void PreprocessCameraDescription(AssetImportContext assetImportContext, CameraDescription description, Camera camera, AnimationClip[] animations) + { + assetImportContext.DependsOnCustomDependency(kCameraPostprocessorDependencyName); + object[] args = { description, camera, animations }; + CallPostProcessMethods("OnPreprocessCameraDescription", args); + } + + [RequiredByNativeCode] + static void PreprocessLightDescription(AssetImportContext assetImportContext, LightDescription description, Light light, AnimationClip[] animations) + { + assetImportContext.DependsOnCustomDependency(kLightPostprocessorDependencyName); + object[] args = { description, light, animations }; + CallPostProcessMethods("OnPreprocessLightDescription", args); + } + [RequiredByNativeCode] static void PreprocessMaterialDescription(MaterialDescription description, Material material, AnimationClip[] animations) { @@ -452,64 +757,107 @@ static EditorCurveBinding[] PostprocessGameObjectWithAnimatedUserProperties(Game } [RequiredByNativeCode] - static string GetTextureProcessorsHashString() + static void PreprocessTexture(string pathName, AssetImportContext context) { - if (m_TextureProcessorsHashString != null) - return m_TextureProcessorsHashString; - - var versionsByType = new SortedList(); - - foreach (var assetPostprocessorClass in GetCachedAssetPostprocessorClasses()) + if (context != null) { - try - { - var inst = Activator.CreateInstance(assetPostprocessorClass) as AssetPostprocessor; - var type = inst.GetType(); - bool hasPreProcessMethod = type.GetMethod("OnPreprocessTexture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) != null; - bool hasPostProcessMethod = (type.GetMethod("OnPostprocessTexture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) != null) || - (type.GetMethod("OnPostprocessCubemap", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) != null); - uint version = inst.GetVersion(); - if (hasPreProcessMethod || hasPostProcessMethod) - { - versionsByType.Add(type.FullName, version); - } - } - catch (MissingMethodException) - { - LogPostProcessorMissingDefaultConstructor(assetPostprocessorClass); - } - catch (Exception e) - { - Debug.LogException(e); - } + context.DependsOnCustomDependency(kTexturePreprocessorDependencyName); } - m_TextureProcessorsHashString = BuildHashString(versionsByType); - return m_TextureProcessorsHashString; + CallPostProcessMethods("OnPreprocessTexture", null); } [RequiredByNativeCode] - static void PreprocessTexture(string pathName) + static void PreprocessTextureFromScript(string pathName) { CallPostProcessMethods("OnPreprocessTexture", null); } [RequiredByNativeCode] - static void PostprocessTexture(Texture2D tex, string pathName) + static void PostprocessTexture(Texture2D tex, string pathName, AssetImportContext context) + { + if (context != null) + { + context.DependsOnCustomDependency(kTexture2DPostprocessorDependencyName); + } + object[] args = { tex }; + CallPostProcessMethods("OnPostprocessTexture", args); + } + + [RequiredByNativeCode] + static void PostprocessTextureFromScript(Texture2D tex, string pathName) { object[] args = { tex }; CallPostProcessMethods("OnPostprocessTexture", args); } [RequiredByNativeCode] - static void PostprocessCubemap(Cubemap tex, string pathName) + static void PostprocessCubemap(Cubemap tex, string pathName, AssetImportContext context) { + if (context != null) + { + context.DependsOnCustomDependency(kTextureCubePostprocessorDependencyName); + } object[] args = { tex }; CallPostProcessMethods("OnPostprocessCubemap", args); } [RequiredByNativeCode] - static void PostprocessSprites(Texture2D tex, string pathName, Sprite[] sprites) + static void PostprocessCubemapFromScript(Cubemap tex, string pathName) + { + object[] args = { tex }; + CallPostProcessMethods("OnPostprocessCubemap", args); + } + + [RequiredByNativeCode] + static void PostprocessTexture3D(Texture3D tex, string pathName, AssetImportContext context) + { + if (context != null) + { + context.DependsOnCustomDependency(kTexture3DPostprocessorDependencyName); + } + object[] args = { tex }; + CallPostProcessMethods("OnPostprocessTexture3D", args); + } + + [RequiredByNativeCode] + static void PostprocessTexture3DFromScript(Texture3D tex, string pathName) + { + object[] args = { tex }; + CallPostProcessMethods("OnPostprocessTexture3D", args); + } + + [RequiredByNativeCode] + static void PostprocessTexture2DArray(Texture2DArray tex, string pathName, AssetImportContext context) + { + if (context != null) + { + context.DependsOnCustomDependency(kTexture2DArrayPostprocessorDependencyName); + } + object[] args = { tex }; + CallPostProcessMethods("OnPostprocessTexture2DArray", args); + } + + [RequiredByNativeCode] + static void PostprocessTexture2DArrayFromScript(Texture2DArray tex, string pathName) + { + object[] args = { tex }; + CallPostProcessMethods("OnPostprocessTexture2DArray", args); + } + + [RequiredByNativeCode] + static void PostprocessSprites(Texture2D tex, string pathName, Sprite[] sprites, AssetImportContext context) + { + if (context != null) + { + context.DependsOnCustomDependency(kTextureSpritePostprocessorDependencyName); + } + object[] args = { tex, sprites }; + CallPostProcessMethods("OnPostprocessSprites", args); + } + + [RequiredByNativeCode] + static void PostprocessSpritesFromScript(Texture2D tex, string pathName, Sprite[] sprites) { object[] args = { tex, sprites }; CallPostProcessMethods("OnPostprocessSprites", args); @@ -521,33 +869,7 @@ static string GetAudioProcessorsHashString() if (m_AudioProcessorsHashString != null) return m_AudioProcessorsHashString; - var versionsByType = new SortedList(); - - foreach (var assetPostprocessorClass in GetCachedAssetPostprocessorClasses()) - { - try - { - var inst = Activator.CreateInstance(assetPostprocessorClass) as AssetPostprocessor; - var type = inst.GetType(); - bool hasPreProcessMethod = type.GetMethod("OnPreprocessAudio", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) != null; - bool hasPostProcessMethod = type.GetMethod("OnPostprocessAudio", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) != null; - uint version = inst.GetVersion(); - if (hasPreProcessMethod || hasPostProcessMethod) - { - versionsByType.Add(type.FullName, version); - } - } - catch (MissingMethodException) - { - LogPostProcessorMissingDefaultConstructor(assetPostprocessorClass); - } - catch (Exception e) - { - Debug.LogException(e); - } - } - - m_AudioProcessorsHashString = BuildHashString(versionsByType); + m_AudioProcessorsHashString = BuildStaticDependencyHashString(GetSortedStaticPostprocessorTypes(typeof(AudioImporter))); return m_AudioProcessorsHashString; } @@ -557,8 +879,6 @@ static void PreprocessAudio(string pathName) CallPostProcessMethods("OnPreprocessAudio", null); } - static Stack s_AnalyticsEventsStack = new Stack(); - [RequiredByNativeCode] static void PostprocessAudio(AudioClip clip, string pathName) { @@ -571,33 +891,7 @@ static string GetPrefabProcessorsHashString() { if (m_PrefabProcessorsHashString != null) return m_PrefabProcessorsHashString; - - var versionsByType = new SortedList(); - - foreach (var assetPostprocessorClass in GetCachedAssetPostprocessorClasses()) - { - try - { - var inst = Activator.CreateInstance(assetPostprocessorClass) as AssetPostprocessor; - var type = inst.GetType(); - bool hasPostProcessMethod = type.GetMethod("OnPostprocessPrefab", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) != null; - uint version = inst.GetVersion(); - if (version != 0 && hasPostProcessMethod) - { - versionsByType.Add(type.FullName, version); - } - } - catch (MissingMethodException) - { - LogPostProcessorMissingDefaultConstructor(assetPostprocessorClass); - } - catch (Exception e) - { - Debug.LogException(e); - } - } - - m_PrefabProcessorsHashString = BuildHashString(versionsByType); + m_PrefabProcessorsHashString = BuildStaticDependencyHashString(GetSortedStaticPostprocessorTypes(typeof(PrefabImporter))); return m_PrefabProcessorsHashString; } @@ -609,9 +903,9 @@ static void PostprocessPrefab(GameObject prefabAssetRoot) } [RequiredByNativeCode] - static void PostprocessAssetbundleNameChanged(string assetPath, string prevoiusAssetBundleName, string newAssetBundleName) + static void PostprocessAssetbundleNameChanged(string assetPath, string previousAssetBundleName, string newAssetBundleName) { - object[] args = { assetPath, prevoiusAssetBundleName, newAssetBundleName }; + object[] args = { assetPath, previousAssetBundleName, newAssetBundleName }; foreach (var assetPostprocessorClass in GetCachedAssetPostprocessorClasses()) { @@ -625,6 +919,27 @@ static string GetSpeedTreeProcessorsHashString() { if (m_SpeedTreeProcessorsHashString != null) return m_SpeedTreeProcessorsHashString; + m_SpeedTreeProcessorsHashString = BuildStaticDependencyHashString(GetSortedStaticPostprocessorTypes(typeof(SpeedTreeImporter))); + return m_SpeedTreeProcessorsHashString; + } + + [InitializeOnLoadMethod] + static void RefreshCustomDependencies() + { + AssetDatabase.RegisterCustomDependency(kCameraPostprocessorDependencyName, Hash128.Compute(GetCameraProcessorsHashString())); + AssetDatabase.RegisterCustomDependency(kLightPostprocessorDependencyName, Hash128.Compute(GetLightProcessorsHashString())); + AssetDatabase.RegisterCustomDependency(kTexture2DPostprocessorDependencyName, Hash128.Compute(GetTexture2DProcessorsHashString())); + AssetDatabase.RegisterCustomDependency(kTextureCubePostprocessorDependencyName, Hash128.Compute(GetTextureCubeProcessorsHashString())); + AssetDatabase.RegisterCustomDependency(kTexture3DPostprocessorDependencyName, Hash128.Compute(GetTexture3DProcessorsHashString())); + AssetDatabase.RegisterCustomDependency(kTexture2DArrayPostprocessorDependencyName, Hash128.Compute(GetTexture2DArrayProcessorsHashString())); + AssetDatabase.RegisterCustomDependency(kTextureSpritePostprocessorDependencyName, Hash128.Compute(GetTextureSpriteProcessorsHashString())); + AssetDatabase.RegisterCustomDependency(kTexturePreprocessorDependencyName, Hash128.Compute(GetTexturePreProcessorsHashString())); + } + + static void GetProcessorHashString(string methodName, ref string hashString) + { + if (hashString != null) + return; var versionsByType = new SortedList(); @@ -632,14 +947,11 @@ static string GetSpeedTreeProcessorsHashString() { try { - var inst = Activator.CreateInstance(assetPostprocessorClass) as AssetPostprocessor; - var type = inst.GetType(); - bool hasPreProcessMethod = type.GetMethod("OnPreprocessSpeedTree", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) != null; - bool hasPostProcessMethod = type.GetMethod("OnPostprocessSpeedTree", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) != null; - uint version = inst.GetVersion(); - if (hasPreProcessMethod || hasPostProcessMethod) + if (assetPostprocessorClass.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) != null) { - versionsByType.Add(type.FullName, version); + var inst = Activator.CreateInstance(assetPostprocessorClass) as AssetPostprocessor; + uint version = inst.GetVersion(); + versionsByType.Add(assetPostprocessorClass.FullName, version); } } catch (MissingMethodException) @@ -652,8 +964,63 @@ static string GetSpeedTreeProcessorsHashString() } } - m_SpeedTreeProcessorsHashString = BuildHashString(versionsByType); - return m_SpeedTreeProcessorsHashString; + hashString = BuildHashString(versionsByType); + } + + [RequiredByNativeCode] + static string GetCameraProcessorsHashString() + { + GetProcessorHashString("OnPreprocessCameraDescription", ref m_CameraProcessorsHashString); + return m_CameraProcessorsHashString; + } + + [RequiredByNativeCode] + static string GetLightProcessorsHashString() + { + GetProcessorHashString("OnPreprocessLightDescription", ref m_LightProcessorsHashString); + return m_LightProcessorsHashString; + } + + [RequiredByNativeCode] + static string GetTexturePreProcessorsHashString() + { + GetProcessorHashString("OnPreprocessTexture", ref m_TexturePreprocessorDependencyName); + return m_TexturePreprocessorDependencyName; + } + + [RequiredByNativeCode] + static string GetTexture2DProcessorsHashString() + { + GetProcessorHashString("OnPostprocessTexture", ref m_Texture2DProcessorsHashString); + return m_Texture2DProcessorsHashString; + } + + [RequiredByNativeCode] + static string GetTextureCubeProcessorsHashString() + { + GetProcessorHashString("OnPostprocessCubemap", ref m_TextureCubeProcessorsHashString); + return m_TextureCubeProcessorsHashString; + } + + [RequiredByNativeCode] + static string GetTexture3DProcessorsHashString() + { + GetProcessorHashString("OnPostprocessTexture3D", ref m_Texture3DPostprocessorDependencyName); + return m_Texture3DPostprocessorDependencyName; + } + + [RequiredByNativeCode] + static string GetTexture2DArrayProcessorsHashString() + { + GetProcessorHashString("OnPostprocessTexture2DArray", ref m_Texture2DArrayDependencyName); + return m_Texture2DArrayDependencyName; + } + + [RequiredByNativeCode] + static string GetTextureSpriteProcessorsHashString() + { + GetProcessorHashString("OnPostprocessSprites", ref m_TextureSpriteDependencyName); + return m_TextureSpriteDependencyName; } static bool IsAssetPostprocessorAnalyticsEnabled() @@ -688,6 +1055,11 @@ static void CallPostProcessMethodsUntilReturnedObjectIsValid(string methodNam static void CallPostProcessMethods(string methodName, object[] args) { + if (m_ImportProcessors == null) + { + throw new Exception("m_ImportProcessors is null, InitPostProcessors should be called before any of the post process methods are called."); + } + if (IsAssetPostprocessorAnalyticsEnabled()) { int invocationCount = 0; @@ -719,7 +1091,7 @@ static void CallPostProcessMethods(string methodName, object[] args) static object InvokeMethod(MethodInfo method, object[] args) { object res = null; - using (new EditorPerformanceTracker(method.DeclaringType.Name + "." + method.Name)) + using (new EditorPerformanceMarker(method.DeclaringType.Name + "." + method.Name, method.DeclaringType).Auto()) { res = method.Invoke(null, args); } @@ -729,10 +1101,11 @@ static object InvokeMethod(MethodInfo method, object[] args) static bool InvokeMethodIfAvailable(object target, string methodName, object[] args) { - MethodInfo method = target.GetType().GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); + var type = target.GetType(); + MethodInfo method = type.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); if (method != null) { - using (new EditorPerformanceTracker(target.GetType().Name + "." + methodName)) + using (new EditorPerformanceMarker(type.Name + "." + methodName, type).Auto()) { method.Invoke(target, args); } @@ -744,15 +1117,16 @@ static bool InvokeMethodIfAvailable(object target, string methodName, object[] a static bool InvokeMethodIfAvailable(object target, string methodName, object[] args, ref T returnedObject) where T : class { - MethodInfo method = target.GetType().GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); + var type = target.GetType(); + MethodInfo method = type.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); if (method != null) { - using (new EditorPerformanceTracker(target.GetType().Name + "." + methodName)) + using (new EditorPerformanceMarker(type.Name + "." + methodName, type).Auto()) { returnedObject = method.Invoke(target, args) as T; } - return true; + return returnedObject != null; } return false; } diff --git a/Editor/Mono/AssetPreviewUpdater.cs b/Editor/Mono/AssetPreviewUpdater.cs index 3d310838d5..c58d13d430 100644 --- a/Editor/Mono/AssetPreviewUpdater.cs +++ b/Editor/Mono/AssetPreviewUpdater.cs @@ -3,22 +3,27 @@ // https://unity3d.com/legal/licenses/Unity_Reference_Only_License using UnityEngine; +using UnityEngine.Rendering; +using UnityEngine.Scripting; namespace UnityEditor { internal static class AssetPreviewUpdater { - // Generate a preview texture for an asset + [RequiredByNativeCode] public static Texture2D CreatePreviewForAsset(Object obj, Object[] subAssets, string assetPath) { - if (obj == null) - return null; + return CreatePreview(obj, subAssets, assetPath, 128, 128); + } - System.Type type = CustomEditorAttributes.FindCustomEditorType(obj, false); + // Generate a preview texture for an asset + public static Texture2D CreatePreview(Object obj, Object[] subAssets, string assetPath, int width, int height) + { + var type = CustomEditorAttributes.FindCustomEditorType(obj, false); if (type == null) return null; - System.Reflection.MethodInfo info = type.GetMethod("RenderStaticPreview"); + var info = type.GetMethod("RenderStaticPreview"); if (info == null) { Debug.LogError("Fail to find RenderStaticPreview base method"); @@ -28,13 +33,11 @@ public static Texture2D CreatePreviewForAsset(Object obj, Object[] subAssets, st if (info.DeclaringType == typeof(Editor)) return null; - - Editor editor = Editor.CreateEditor(obj); - + var editor = Editor.CreateEditor(obj); if (editor == null) return null; - - Texture2D tex = editor.RenderStaticPreview(assetPath, subAssets, 128, 128); + + var previewTexture = editor.RenderStaticPreview(assetPath, subAssets, width, height); // For debugging we write the preview to a file (keep) //{ @@ -45,8 +48,7 @@ public static Texture2D CreatePreviewForAsset(Object obj, Object[] subAssets, st //} Object.DestroyImmediate(editor); - - return tex; + return previewTexture; } } } diff --git a/Editor/Mono/AssetStore/AssetStoreAsset.cs b/Editor/Mono/AssetStore/AssetStoreAsset.cs index 137b5b3546..3b893e6003 100644 --- a/Editor/Mono/AssetStore/AssetStoreAsset.cs +++ b/Editor/Mono/AssetStore/AssetStoreAsset.cs @@ -681,7 +681,7 @@ private static string intToSizeString(int inValue) if (idx < 0) return ""; - return UnityString.Format("{0:#.##} {1}", val, scale[idx]); + return string.Format("{0:#.##} {1}", val, scale[idx]); } public override bool HasPreviewGUI() diff --git a/Editor/Mono/AssetStore/AssetStoreContext.cs b/Editor/Mono/AssetStore/AssetStoreContext.cs index 0909c63e8b..806a9fd664 100644 --- a/Editor/Mono/AssetStore/AssetStoreContext.cs +++ b/Editor/Mono/AssetStore/AssetStoreContext.cs @@ -12,7 +12,6 @@ using System.Linq; using System.IO; using UnityEditor.Web; -using UnityEditor.Analytics; namespace UnityEditor { @@ -53,9 +52,10 @@ public string GetAuthToken() return UnityEditorInternal.InternalEditorUtility.GetAuthToken(); } + [Obsolete("GetLicenseFlags is no longer supported", error: true)] public int[] GetLicenseFlags() { - return UnityEditorInternal.InternalEditorUtility.GetLicenseFlags(); + return new int[] {}; } public string GetString(string key) diff --git a/Editor/Mono/AssetStore/AssetStorePreviewManager.cs b/Editor/Mono/AssetStore/AssetStorePreviewManager.cs index f7579935f2..30fa6b3c6d 100644 --- a/Editor/Mono/AssetStore/AssetStorePreviewManager.cs +++ b/Editor/Mono/AssetStore/AssetStorePreviewManager.cs @@ -107,7 +107,7 @@ public static int Downloading public static string StatsString() { - return string.Format("Reqs: {0}, Ok: {1}, Abort: {2}, CacheDel: {3}, Cache: {4}/{5}, CacheHit: {6}", + return string.Format("Reqs: {0}, OK: {1}, Abort: {2}, CacheDel: {3}, Cache: {4}/{5}, CacheHit: {6}", Instance.Requested, Instance.m_Success, Instance.m_Aborted, Instance.m_CacheRemove, AssetStorePreviewManager.CachedAssetStoreImages.Count, Instance.m_MaxCachedAssetStoreImages, diff --git a/Editor/Mono/AssetStore/AssetStoreWindow.cs b/Editor/Mono/AssetStore/AssetStoreWindow.cs index 8426927fa4..94f781af9e 100644 --- a/Editor/Mono/AssetStore/AssetStoreWindow.cs +++ b/Editor/Mono/AssetStore/AssetStoreWindow.cs @@ -5,15 +5,14 @@ using UnityEngine; using UnityEngine.UIElements; using UnityEditor.Connect; +using UnityEditor.PackageManager.UI; +using UnityEditor.UIElements; namespace UnityEditor { [EditorWindowTitle(title = "Asset Store", icon = "Asset Store")] internal class AssetStoreWindow : EditorWindow { - // Use this for initialization - // Index at 1499 because "Package Manager" is 1500, pairing tools for user to get external content - [MenuItem("Window/Asset Store", false, 1499)] public static AssetStoreWindow Init() { if (EditorPrefs.GetBool("AlwaysOpenAssetStoreInBrowser", false)) @@ -30,14 +29,22 @@ public static AssetStoreWindow Init() } } - private static void OpenAssetStoreInBrowser() + [MenuItem("Window/Package Management/Asset Store", false, 2000)] + public static void OpenAssetStoreInBrowser() { string assetStoreUrl = UnityConnect.instance.GetConfigurationURL(CloudConfigUrl.CloudAssetStoreUrl); - if (UnityEditor.Connect.UnityConnect.instance.loggedIn) - UnityEditor.Connect.UnityConnect.instance.OpenAuthorizedURLInWebBrowser(assetStoreUrl); + assetStoreUrl += "?utm_source=unity-editor-window-menu&utm_medium=desktop-app"; + if (UnityConnect.instance.loggedIn) + UnityConnect.instance.OpenAuthorizedURLInWebBrowser(assetStoreUrl); else Application.OpenURL(assetStoreUrl); } + [MenuItem("Window/Package Management/My Assets", false, 1501)] + public static void OpenMyAssetsInPackageManager() + { + PackageManagerWindow.OpenAndSelectPage(PackageManager.UI.Internal.MyAssetsPage.k_Id); + } + public void OnEnable() { this.antiAliasing = 4; @@ -47,10 +54,10 @@ public void OnEnable() { var root = windowResource.CloneTree(); - var lightStyleSheet = EditorGUIUtility.Load(EditorUIService.instance.GetUIToolkitDefaultCommonLightStyleSheetPath()) as StyleSheet; + var lightStyleSheet = EditorGUIUtility.Load(UIElementsEditorUtility.s_DefaultCommonLightStyleSheetPath) as StyleSheet; var assetStoreStyleSheet = EditorGUIUtility.Load("StyleSheets/AssetStore/AssetStoreWindow.uss") as StyleSheet; var styleSheet = CreateInstance(); - styleSheet.isUnityStyleSheet = true; + styleSheet.isDefaultStyleSheet = true; var resolver = new StyleSheets.StyleSheetResolver(); resolver.AddStyleSheets(lightStyleSheet, assetStoreStyleSheet); @@ -93,7 +100,7 @@ private void OnVisitWebsiteButtonClicked() private void OnLaunchPackageManagerButtonClicked() { - EditorUIService.instance.PackageManagerOpen(); + PackageManagerWindow.OpenAndSelectPackage(null); } private void SetMinMaxSizes() diff --git a/Editor/Mono/AssetStoreCachePathManager.bindings.cs b/Editor/Mono/AssetStoreCachePathManager.bindings.cs new file mode 100644 index 0000000000..5af3259549 --- /dev/null +++ b/Editor/Mono/AssetStoreCachePathManager.bindings.cs @@ -0,0 +1,24 @@ +// Unity C# reference source +// Copyright (c) Unity Technologies. For terms of use, see +// https://unity3d.com/legal/licenses/Unity_Reference_Only_License + +using UnityEngine.Bindings; + +namespace UnityEditorInternal +{ + [NativeHeader("Editor/Src/AssetStore/AssetStoreCachePathManager.h")] + internal partial class AssetStoreCachePathManager + { + [FreeFunction("AssetStoreCachePathManager::GetDefaultConfig")] + public static extern CachePathConfig GetDefaultConfig(); + + [FreeFunction("AssetStoreCachePathManager::GetConfig")] + public static extern CachePathConfig GetConfig(); + + [FreeFunction("AssetStoreCachePathManager::SetConfig")] + public static extern ConfigStatus SetConfig(string newPath); + + [FreeFunction("AssetStoreCachePathManager::ResetConfig")] + public static extern ConfigStatus ResetConfig(); + } +} diff --git a/Editor/Mono/AssetStoreCachePathManager.cs b/Editor/Mono/AssetStoreCachePathManager.cs new file mode 100644 index 0000000000..31fba1756c --- /dev/null +++ b/Editor/Mono/AssetStoreCachePathManager.cs @@ -0,0 +1,51 @@ +// 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 UnityEditor.PackageManager; +using System.Runtime.InteropServices; +using RequiredByNativeCodeAttribute = UnityEngine.Scripting.RequiredByNativeCodeAttribute; + +namespace UnityEditorInternal +{ + internal partial class AssetStoreCachePathManager + { + public enum ConfigStatus + { + Success = 0, + InvalidPath, + ReadOnly, + EnvironmentOverride, + Default, + Failed + }; + + [Serializable] + [StructLayout(LayoutKind.Sequential)] + [RequiredByNativeCode] + [NativeAsStruct] + internal class CachePathConfig + { + [SerializeField] + [NativeName("path")] + private string m_Path = ""; + + [SerializeField] + [NativeName("source")] + private ConfigSource m_Source = ConfigSource.Unknown; + + [SerializeField] + [NativeName("status")] + private ConfigStatus m_Status = ConfigStatus.Success; + + public string path => m_Path; + + public ConfigSource source => m_Source; + + public ConfigStatus status => m_Status; + } + } +} diff --git a/Editor/Mono/AssetStoreToolUtils.bindings.cs b/Editor/Mono/AssetStoreToolUtils.bindings.cs index c0f8571cb6..4617548b93 100644 --- a/Editor/Mono/AssetStoreToolUtils.bindings.cs +++ b/Editor/Mono/AssetStoreToolUtils.bindings.cs @@ -11,6 +11,7 @@ namespace UnityEditorInternal [StaticAccessor("AssetStoreScriptBindings", StaticAccessorType.DoubleColon)] public sealed partial class AssetStoreToolUtils { + [System.Obsolete("BuildAssetStoreAssetBundle has been made obsolete. Please use BuildPipeline.BuildAssetBundles() or Addressables.", true)] extern public static bool BuildAssetStoreAssetBundle(Object targetObject, string targetPath); } } diff --git a/Editor/Mono/AssetStoreUtils.bindings.cs b/Editor/Mono/AssetStoreUtils.bindings.cs index 6f783d1aa5..9a48f1fb6f 100644 --- a/Editor/Mono/AssetStoreUtils.bindings.cs +++ b/Editor/Mono/AssetStoreUtils.bindings.cs @@ -15,12 +15,15 @@ internal class AssetStoreUtils private const string kAssetStoreUrl = "https://shawarma.unity3d.com"; public delegate void DownloadDoneCallback(string package_id, string message, int bytes, int total); + extern public static string BuildBaseDownloadPath(string publisher, string category); + extern public static string BuildFinalDownloadPath(string baseDir, string packageName); + [NativeThrows] extern public static void Download(string id, string url, string[] destination, string key, string jsonData, bool resumeOK, DownloadDoneCallback doneCallback = null); [NativeThrows] extern public static string CheckDownload(string id, string url, string[] destination, string key); [NativeThrows] - extern public static bool AbortDownload(string id, string[] destination); + extern public static bool AbortDownload(string[] destination); extern public static void RegisterDownloadDelegate([NotNull] ScriptableObject d); extern public static void UnRegisterDownloadDelegate([NotNull] ScriptableObject d); extern public static string GetLoaderPath(); diff --git a/Editor/Mono/AssetsMenuUtility.bindings.cs b/Editor/Mono/AssetsMenuUtility.bindings.cs index 9e03f90b4c..b7c1f404ed 100644 --- a/Editor/Mono/AssetsMenuUtility.bindings.cs +++ b/Editor/Mono/AssetsMenuUtility.bindings.cs @@ -6,9 +6,38 @@ namespace UnityEditor { + internal enum ScriptTemplate + { + CSharp_NewBehaviourScript = 0, + CSharp_NewPlayableBehaviour, + Shader_NewSurfaceShader, + CSharp_NewSceneTemplatePipelineScript, + CSharp_NewPlayableAsset, + CSharp_NewScriptableObjectScript, + Shader_NewUnlitShader, + AsmDef_NewEditModeTestAssembly, + AsmDef_NewTestAssembly, + AsmDef_NewAssembly, + AsmRef_NewAssemblyReference, + CSharp_NewEmptyScript, + CSharp_NewTestScript, + Shader_NewImageEffectShader, + Shader_NewComputeShader, + Shader_NewRayTracingShader, + CSharp_NewStateMachineBehaviourScript, + CSharp_NewSubStateMachineBehaviourScript, + Count + } + [NativeHeader("Editor/Src/Commands/AssetsMenuUtility.h")] internal static class AssetsMenuUtility { public static extern bool SelectionHasImmutable(); + public static string GetScriptTemplatePath(ScriptTemplate template) + { + return GetScriptTemplatePath((int)template); + } + + private static extern string GetScriptTemplatePath(int index); } } diff --git a/Editor/Mono/AttributeHelper.cs b/Editor/Mono/AttributeHelper.cs index b3e89eb401..2719d77a50 100644 --- a/Editor/Mono/AttributeHelper.cs +++ b/Editor/Mono/AttributeHelper.cs @@ -56,12 +56,11 @@ static MonoGizmoMethod[] ExtractGizmos(Assembly assembly) continue; } - var item = new MonoGizmoMethod(); - + Type targetType; if (gizmoAttr.drawnType == null) - item.drawnType = parameters[0].ParameterType; + targetType = parameters[0].ParameterType; else if (parameters[0].ParameterType.IsAssignableFrom(gizmoAttr.drawnType)) - item.drawnType = gizmoAttr.drawnType; + targetType = gizmoAttr.drawnType; else { Debug.LogWarningFormat( @@ -81,17 +80,39 @@ static MonoGizmoMethod[] ExtractGizmos(Assembly assembly) continue; } - item.drawGizmo = mi; - item.options = (int)gizmoAttr.drawOptions; + if (targetType.IsInterface) + { + var types = TypeCache.GetTypesDerivedFrom(targetType); + foreach (var type in types) + { + //Limit the types to the classes that have the interface and not it's children + if (type.BaseType != null && type.BaseType.IsAssignableFrom(targetType)) + continue; - commands.Add(item); + commands.Add(new MonoGizmoMethod + { + drawnType = type, + drawGizmo = mi, + options = (int)gizmoAttr.drawOptions, + }); + } + } + else + { + commands.Add(new MonoGizmoMethod + { + drawnType = targetType, + drawGizmo = mi, + options = (int)gizmoAttr.drawOptions, + }); + } } } return commands.ToArray(); } [RequiredByNativeCode] - static string GetComponentMenuName(Type type) + static object GetComponentMenuName(Type type) { var attrs = type.GetCustomAttributes(typeof(AddComponentMenu), false); if (attrs.Length > 0) @@ -124,7 +145,7 @@ struct MonoCreateAssetItem } [RequiredByNativeCode] - static MonoCreateAssetItem[] ExtractCreateAssetMenuItems(Assembly assembly) + static MonoCreateAssetItem[] ExtractCreateAssetMenuItems() { var result = new List(); @@ -145,6 +166,11 @@ static MonoCreateAssetItem[] ExtractCreateAssetMenuItems(Assembly assembly) if (!System.IO.Path.HasExtension(fileName)) fileName = fileName + ".asset"; + // trim the trailing space from the menu name: + // 1. visually it is hard to differentialte menu names with or without spaces. + // 2. when asset menu is searched, it will search the trimmed menu name, so it will create a edge case where a menu name with space could not be found after creation. + menuItemName = menuItemName.TrimEnd(); + var item = new MonoCreateAssetItem { menuItem = menuItemName, diff --git a/Editor/Mono/Audio/Analytics/AudioAnalytics.cs b/Editor/Mono/Audio/Analytics/AudioAnalytics.cs new file mode 100644 index 0000000000..95269ef37f --- /dev/null +++ b/Editor/Mono/Audio/Analytics/AudioAnalytics.cs @@ -0,0 +1,13 @@ +// 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.Analytics; + +namespace UnityEditor.Audio.Analytics; + +static class AudioAnalytics +{ +} diff --git a/Editor/Mono/Audio/Analytics/AudioRandomContainerBuildAnalyticsEvent.cs b/Editor/Mono/Audio/Analytics/AudioRandomContainerBuildAnalyticsEvent.cs new file mode 100644 index 0000000000..e23b9f372a --- /dev/null +++ b/Editor/Mono/Audio/Analytics/AudioRandomContainerBuildAnalyticsEvent.cs @@ -0,0 +1,85 @@ +// 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.Build; +using UnityEditor.Build.Reporting; +using UnityEngine; +using UnityEngine.Audio; +using UnityEngine.Analytics; + +namespace UnityEditor.Audio.Analytics; + +class AudioRandomContainerBuildAnalyticsEvent : IPostprocessBuildWithReport +{ + [AnalyticInfo(eventName: "audioRandomContainerBuild", vendorKey: "unity.audio", maxEventsPerHour: 60, maxNumberOfElements: 2)] + internal class AudioRandomAnalytic : IAnalytic + { + public AudioRandomAnalytic(string build_guid, int count) + { + this.build_guid = build_guid; + this.count = count; + } + + [Serializable] + struct Payload : IAnalytic.IData + { + public string build_guid; + public int count; + } + + + public bool TryGatherData(out IAnalytic.IData data, out Exception error) + { + error = null; + data = new Payload + { + build_guid = build_guid, + count = count + }; + + return data != null; + } + + private string build_guid; + private int count; + } + + + public int callbackOrder { get; } + + public void OnPostprocessBuild(BuildReport report) + { + SendEvent(report); + } + + static void SendEvent(BuildReport report) + { + if (!EditorAnalytics.enabled + || AudioSettings.unityAudioDisabled + || report == null + || report.packedAssets.Length == 0) + { + return; + } + + var count = 0; + + for (var i = 0; i < report.packedAssets.Length; ++i) + { + var infos = report.packedAssets[i].GetContents(); + + for (var j = 0; j < infos.Length; ++j) + { + if (infos[j].type == typeof(AudioRandomContainer)) + { + ++count; + } + } + } + + EditorAnalytics.SendAnalytic(new AudioRandomAnalytic(report.summary.guid.ToString(), count)); + } + + } diff --git a/Editor/Mono/Audio/Analytics/AudioRandomContainerQuitAnalyticsEvent.cs b/Editor/Mono/Audio/Analytics/AudioRandomContainerQuitAnalyticsEvent.cs new file mode 100644 index 0000000000..27a8a63948 --- /dev/null +++ b/Editor/Mono/Audio/Analytics/AudioRandomContainerQuitAnalyticsEvent.cs @@ -0,0 +1,64 @@ +// 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.Analytics; + +namespace UnityEditor.Audio.Analytics; + +[InitializeOnLoad] +class AudioRandomContainerQuitAnalyticsEvent +{ + [AnalyticInfo(eventName: "audioRandomContainerQuit", vendorKey: "unity.audio", maxEventsPerHour: 60, maxNumberOfElements: 1)] + internal class AudioRandomAnalytic : IAnalytic + { + public AudioRandomAnalytic(int count) + { + this.count = count; + } + + [Serializable] + struct Payload : IAnalytic.IData + { + public int count; + } + + + public bool TryGatherData(out IAnalytic.IData data, out Exception error) + { + error = null; + data = new Payload + { + count = count + }; + + return data != null; + } + + private int count; + } + + static AudioRandomContainerQuitAnalyticsEvent() + { + EditorApplication.wantsToQuit += OnEditorApplicationWantsToQuit; + } + + static bool OnEditorApplicationWantsToQuit() + { + SendEvent(); + return true; + } + + static void SendEvent() + { + if (!EditorAnalytics.enabled || AudioSettings.unityAudioDisabled) + { + return; + } + + var assetPaths = AssetDatabase.FindAssets("t:AudioRandomContainer"); + EditorAnalytics.SendAnalytic(new AudioRandomAnalytic(assetPaths.Length)); + } +} diff --git a/Editor/Mono/Audio/AudioContainerListDragAndDropManipulator.cs b/Editor/Mono/Audio/AudioContainerListDragAndDropManipulator.cs new file mode 100644 index 0000000000..67f85fa2b5 --- /dev/null +++ b/Editor/Mono/Audio/AudioContainerListDragAndDropManipulator.cs @@ -0,0 +1,58 @@ +// 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 UnityEngine; +using UnityEngine.UIElements; + +namespace UnityEditor; + +class AudioContainerListDragAndDropManipulator : PointerManipulator +{ + internal delegate void AddAudioClipsDelegate(List audioClips); + + internal AddAudioClipsDelegate addAudioClipsDelegate; + + public AudioContainerListDragAndDropManipulator(VisualElement root) + { + target = root.Q("audio-clips-list-view"); + } + + protected override void RegisterCallbacksOnTarget() + { + target.RegisterCallback(OnDragUpdate); + target.RegisterCallback(OnDragPerform); + } + + protected override void UnregisterCallbacksFromTarget() + { + target?.UnregisterCallback(OnDragUpdate); + target?.UnregisterCallback(OnDragPerform); + } + + static void OnDragUpdate(DragUpdatedEvent _) + { + DragAndDrop.visualMode = DragAndDropVisualMode.Generic; + } + + void OnDragPerform(DragPerformEvent evt) + { + var audioClips = new List(); + + foreach (var path in DragAndDrop.paths) + { + var audioClip = AssetDatabase.LoadAssetAtPath(path); + + if (audioClip != null) + audioClips.Add(audioClip); + } + + if (audioClips.Count > 0) + { + DragAndDrop.AcceptDrag(); + addAudioClipsDelegate?.Invoke(audioClips); + } + } +} diff --git a/Editor/Mono/Audio/AudioContainerWindow.cs b/Editor/Mono/Audio/AudioContainerWindow.cs new file mode 100644 index 0000000000..03355b2a14 --- /dev/null +++ b/Editor/Mono/Audio/AudioContainerWindow.cs @@ -0,0 +1,1522 @@ +// 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 UnityEditor.Audio; +using UnityEditor.Audio.UIElements; +using UnityEditor.ShortcutManagement; +using UnityEditor.UIElements; +using UnityEngine; +using UnityEngine.Assertions; +using UnityEngine.Audio; +using UnityEngine.Scripting; +using UnityEngine.UIElements; +using Object = UnityEngine.Object; + +namespace UnityEditor; + +sealed class AudioContainerWindow : EditorWindow +{ + enum Icons + { + Play = 0, + Stop = 1, + Skip = 2, + DiceOff = 3, + DiceOn = 4 + } + + /// + /// The cached instance of the window, if it is open. + /// + internal static AudioContainerWindow Instance { get; private set; } + + internal readonly AudioContainerWindowState State = new(); + + /// + /// Holds the added list elements in the list interaction callbacks. + /// Only used locally in these methods, but it's a global member to avoid GC. + /// + readonly List m_AddedElements = new(); + readonly string k_EmptyGuidString = Guid.Empty.ToString("N"); + readonly Texture2D[] k_IconTextureCache = new Texture2D[Enum.GetNames(typeof(Icons)).Length]; + + VisualElement m_ContainerRootVisualElement; + VisualElement m_Day0RootVisualElement; + + // Preview section + Label m_AssetNameLabel; + Button m_PlayStopButton; + VisualElement m_PlayStopButtonImage; + Button m_SkipButton; + VisualElement m_SkipButtonImage; + + // Volume section + Slider m_VolumeSlider; + AudioRandomRangeSliderTracker m_VolumeRandomRangeTracker; + FloatField m_VolumeField; + Button m_VolumeRandomizationButton; + VisualElement m_VolumeRandomizationButtonImage; + MinMaxSlider m_VolumeRandomizationRangeSlider; + Vector2Field m_VolumeRandomizationRangeField; + AudioLevelMeter m_Meter; + + // Pitch section + Slider m_PitchSlider; + AudioRandomRangeSliderTracker m_PitchRandomRangeTracker; + FloatField m_PitchField; + Button m_PitchRandomizationButton; + VisualElement m_PitchRandomizationButtonImage; + MinMaxSlider m_PitchRandomizationRangeSlider; + Vector2Field m_PitchRandomizationRangeField; + + // Clip list section + ListView m_ClipsListView; + AudioContainerListDragAndDropManipulator m_DragManipulator; + + // Trigger and playback mode section + RadioButtonGroup m_TriggerRadioButtonGroup; + RadioButtonGroup m_PlaybackModeRadioButtonGroup; + IntegerField m_AvoidRepeatingLastField; + + // Automatic trigger section + RadioButtonGroup m_AutomaticTriggerModeRadioButtonGroup; + Slider m_TimeSlider; + AudioRandomRangeSliderTracker m_TimeRandomRangeTracker; + FloatField m_TimeField; + Button m_TimeRandomizationButton; + VisualElement m_TimeRandomizationButtonImage; + MinMaxSlider m_TimeRandomizationRangeSlider; + Vector2Field m_TimeRandomizationRangeField; + RadioButtonGroup m_LoopRadioButtonGroup; + IntegerField m_CountField; + Button m_CountRandomizationButton; + VisualElement m_CountRandomizationButtonImage; + MinMaxSlider m_CountRandomizationRangeSlider; + Vector2Field m_CountRandomizationRangeField; + Label m_AutomaticTriggerModeLabel; + Label m_LoopLabel; + + bool m_IsVisible; + bool m_IsInitializing; + bool m_Day0ElementsInitialized; + bool m_ContainerElementsInitialized; + bool m_IsSubscribedToGUICallbacksAndEvents; + bool m_ClipFieldProgressBarsAreCleared = true; + + /// + /// Holds the previous state of the list elements for undo/delete housekeeping + /// + List m_CachedElements = new(); + + [RequiredByNativeCode] + internal static void CreateAudioRandomContainerWindow() + { + var window = GetWindow(); + window.Show(); + } + + // Used by tests. + internal bool IsInitializedForTargetDisplay() + { + return m_ContainerElementsInitialized && m_IsSubscribedToGUICallbacksAndEvents; + } + + static void OnCreateButtonClicked() + { + ProjectWindowUtil.CreateAudioRandomContainer(); + } + + void OnEnable() + { + if (Instance == null) + { + Instance = this; + } + + SetTitle(); + } + + void OnDisable() + { + State.OnDestroy(); + UnsubscribeFromGUICallbacksAndEvents(); + m_IsInitializing = false; + m_Day0ElementsInitialized = false; + m_ContainerElementsInitialized = false; + m_CachedElements.Clear(); + m_AddedElements.Clear(); + + if (Instance == this) + { + Instance = null; + } + } + + void OnFocus() + { + if (State.AudioContainer != null) + { + UpdateTransportButtonStates(); + } + } + + void Update() + { + if (!m_IsVisible) + return; + + if (State.IsPreviewPlayingOrPaused()) { UpdateClipFieldProgressBars(); } + else if (!m_ClipFieldProgressBarsAreCleared) { ClearClipFieldProgressBars(); } + + if (m_Meter != null) + { + if (State.IsPreviewPlayingOrPaused()) + { + if (State != null) { m_Meter.Value = State.GetMeterValue(); } + else { m_Meter.Value = -80.0f; } + } + else + { + if (m_Meter.Value != -80.0f) { m_Meter.Value = -80.0f; } + } + } + } + + void SetTitle() + { + var titleString = "Audio Random Container"; + + if (State.IsDirty()) + titleString += "*"; + + titleContent = new GUIContent(titleString) + { + image = GetIconTexture(Icons.DiceOff) + }; + } + + void CreateGUI() + { + try + { + if (m_IsInitializing) + return; + + m_IsInitializing = true; + + var root = rootVisualElement; + + if (root.childCount == 0) + { + var rootAsset = UIToolkitUtilities.LoadUxml("UXML/Audio/AudioRandomContainer.uxml"); + Assert.IsNotNull(rootAsset); + rootAsset.CloneTree(root); + + var styleSheet = UIToolkitUtilities.LoadStyleSheet("StyleSheets/Audio/AudioRandomContainer.uss"); + Assert.IsNotNull(styleSheet); + root.styleSheets.Add(styleSheet); + root.Add(State.GetResourceTrackerElement()); + + m_ContainerRootVisualElement = UIToolkitUtilities.GetChildByName(root, "ARC_ScrollView"); + Assert.IsNotNull(m_ContainerRootVisualElement); + m_Day0RootVisualElement = UIToolkitUtilities.GetChildByName(root, "Day0"); + Assert.IsNotNull(m_Day0RootVisualElement); + } + + if (m_ContainerElementsInitialized) + root.Unbind(); + + if (State.AudioContainer == null) + { + if (!m_Day0ElementsInitialized) + { + InitializeDay0Elements(); + m_Day0ElementsInitialized = true; + } + + m_Day0RootVisualElement.style.display = DisplayStyle.Flex; + m_ContainerRootVisualElement.style.display = DisplayStyle.None; + } + else + { + if (!m_ContainerElementsInitialized) + { + InitializeContainerElements(); + m_ContainerElementsInitialized = true; + EditorApplication.update += OneTimeEditorApplicationUpdate; + } + + if (!m_IsSubscribedToGUICallbacksAndEvents) + SubscribeToGUICallbacksAndEvents(); + + BindAndTrackObjectAndProperties(); + + m_Day0RootVisualElement.style.display = DisplayStyle.None; + m_ContainerRootVisualElement.style.display = DisplayStyle.Flex; + m_CachedElements = State.AudioContainer.elements.ToList(); + m_ClipsListView.Rebuild(); // Force a list rebuild when the list has changed or it will not always render correctly due to a UI toolkit bug. + } + } + finally + { + m_IsInitializing = false; + } + } + + bool IsDisplayingTarget() + { + return + m_Day0RootVisualElement != null + && m_Day0RootVisualElement.style.display == DisplayStyle.None + && m_ContainerRootVisualElement != null + && m_ContainerRootVisualElement.style.display == DisplayStyle.Flex; + } + + void InitializeDay0Elements() + { + var createButtonLabel = UIToolkitUtilities.GetChildByName