Files
UmaViewer/Assets/Plugins/UnityGLTF/Runtime/Scripts/GLTFSettings.cs
T
左右看 0d848e4d07 bug fix
2023-06-28 00:35:46 +08:00

228 lines
9.0 KiB
C#

#if UNITY_EDITOR && UNITY_IMGUI
#define SHOW_SETTINGS_EDITOR
#endif
using System.Collections.Generic;
using UnityEngine;
using System.IO;
using UnityEngine.UIElements;
using UnityGLTF.Cache;
#if UNITY_EDITOR
using UnityEditor;
#endif
namespace UnityGLTF
{
#if SHOW_SETTINGS_EDITOR
internal class GltfSettingsProvider : SettingsProvider
{
private GLTFSettings settings;
private SerializedObject m_SerializedObject;
private SerializedProperty showDefaultReferenceNameWarning, showNamingRecommendationHint;
public override void OnGUI(string searchContext)
{
EditorGUIUtility.labelWidth = 200;
if (m_SerializedObject == null)
{
if (!settings) settings = GLTFSettings.GetOrCreateSettings();
m_SerializedObject = new SerializedObject(settings);
}
SerializedProperty prop = m_SerializedObject.GetIterator();
prop.NextVisible(true);
if (prop.NextVisible(true))
{
do
{
EditorGUILayout.PropertyField(prop, true);
switch (prop.name)
{
case nameof(GLTFSettings.UseCaching):
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button($"Clear Cache ({(exportCacheByteLength / (1024f * 1024f)):F2} MB)")) {
ExportCache.Clear();
CalculateCacheStats();
}
if (GUILayout.Button("Open Cache Directory ↗"))
ExportCache.OpenCacheDirectory();
EditorGUILayout.EndHorizontal();
break;
}
}
while (prop.NextVisible(false));
}
if(m_SerializedObject.hasModifiedProperties) {
m_SerializedObject.ApplyModifiedProperties();
}
}
public override void OnActivate(string searchContext, VisualElement rootElement)
{
base.OnActivate(searchContext, rootElement);
CalculateCacheStats();
}
private long exportCacheByteLength = 0;
private void CalculateCacheStats()
{
var files = new List<FileInfo>();
exportCacheByteLength = ExportCache.CalculateCacheSize(files);
}
[SettingsProvider]
public static SettingsProvider CreateGltfSettingsProvider()
{
GLTFSettings.GetOrCreateSettings();
return new GltfSettingsProvider("Project/UnityGLTF", SettingsScope.Project);
}
public GltfSettingsProvider(string path, SettingsScope scopes, IEnumerable<string> keywords = null) : base(path, scopes, keywords) { }
}
#endif
public class GLTFSettings : ScriptableObject
{
private const string k_PreferencesPrefix = "UnityGLTF_Preferences_";
private const string k_SettingsFileName = "UnityGLTFSettings.asset";
public const string k_RuntimeAndEditorSettingsPath = "Assets/Resources/" + k_SettingsFileName;
[System.Flags]
public enum BlendShapeExportPropertyFlags
{
None = 0,
PositionOnly = 1,
Normal = 2,
Tangent = 4,
All = ~0
}
[Header("Export Settings")]
[SerializeField]
private bool exportNames = true;
[SerializeField]
[Tooltip("If on, the entire texture path will be preserved. If off (default), textures are exported at root level.")]
private bool exportFullPath = false;
[SerializeField]
private bool requireExtensions = false;
[Header("Export Visibility")]
[SerializeField]
[Tooltip("Uses Camera.main layer settings to filter which objects are exported")]
private bool useMainCameraVisibility = true;
[SerializeField]
[Tooltip("glTF does not support visibility state. If this setting is true, disabled GameObjects will still be exported and be visible in the glTF file.")]
private bool exportDisabledGameObjects = false;
[Header("Export Textures")]
[SerializeField]
[Tooltip("(Experimental) Exports PNG/JPEG directly from disk instead of re-encoding from Unity's import result. No channel repacking will happen for these textures. Textures in other formats (PSD, TGA etc) not supported by glTF and in-memory textures (e.g. RenderTextures) are always re-encoded.")]
private bool tryExportTexturesFromDisk = false;
[SerializeField] [Tooltip("Determines texture export type (PNG or JPEG) based on alpha channel. When false, always exports lossless PNG files.")]
private bool useTextureFileTypeHeuristic = true;
[SerializeField] [Tooltip("Quality setting for exported JPEG files.")]
private int defaultJpegQuality = 90;
[Header("Export Animation")]
[SerializeField]
private bool exportAnimations = true;
[Tooltip("(Experimental) Export animations using KHR_animation_pointer. Requires the viewer to also support this extension.")]
[SerializeField]
private bool useAnimationPointer = false;
[SerializeField]
[Tooltip("Some viewers can't distinguish between animation clips that have the same name. This option ensures all exported animation names are unique.")]
private bool uniqueAnimationNames = false;
[SerializeField]
private bool bakeSkinnedMeshes = false;
[Header("Export Mesh Data")]
[SerializeField]
private BlendShapeExportPropertyFlags blendShapeExportProperties = BlendShapeExportPropertyFlags.All;
[SerializeField]
[Tooltip("(Experimental) Use Sparse Accessors for blend shape export. Not supported on some viewers.")]
private bool blendShapeExportSparseAccessors = true;
[SerializeField]
[Tooltip("If off, vertex colors are not exported. Vertex Colors aren't supported in some viewers (e.g. Google's SceneViewer).")]
private bool exportVertexColors = true;
[Header("Export Cache")]
[Tooltip("When enabled textures will be cached to disc for faster export times.\n(The cache size is reduced to stay below 1024 MB when the Editor quits)")]
public bool UseCaching = true;
public bool ExportNames { get => exportNames; set => exportNames = value; }
public bool ExportFullPath { get => exportFullPath; set => exportFullPath = value; }
public bool UseMainCameraVisibility { get => useMainCameraVisibility; set => useMainCameraVisibility = value; }
public bool RequireExtensions { get => requireExtensions; set => requireExtensions = value; }
public bool TryExportTexturesFromDisk { get => tryExportTexturesFromDisk; set => tryExportTexturesFromDisk = value; }
public bool UseTextureFileTypeHeuristic { get => useTextureFileTypeHeuristic; set => useTextureFileTypeHeuristic = value; }
public bool ExportVertexColors { get => exportVertexColors; set => exportVertexColors = value; }
public int DefaultJpegQuality { get => defaultJpegQuality; set => defaultJpegQuality = value; }
public bool ExportDisabledGameObjects { get => exportDisabledGameObjects; set => exportDisabledGameObjects = value; }
public bool ExportAnimations { get => exportAnimations; set => exportAnimations = value; }
public bool UseAnimationPointer { get => useAnimationPointer; set => useAnimationPointer = value; }
public bool UniqueAnimationNames { get => uniqueAnimationNames; set => uniqueAnimationNames = value; }
public bool BlendShapeExportSparseAccessors { get => blendShapeExportSparseAccessors; set => blendShapeExportSparseAccessors = value; }
public BlendShapeExportPropertyFlags BlendShapeExportProperties { get => blendShapeExportProperties; set => blendShapeExportProperties = value; }
public bool BakeSkinnedMeshes { get => bakeSkinnedMeshes; set => bakeSkinnedMeshes = value; }
#if UNITY_EDITOR
private const string SaveFolderPathPref = k_PreferencesPrefix + "SaveFolderPath";
public string SaveFolderPath
{
get => EditorPrefs.GetString(SaveFolderPathPref, null);
set => EditorPrefs.SetString(SaveFolderPathPref, value);
}
#endif
internal static GLTFSettings cachedSettings;
public static GLTFSettings GetOrCreateSettings()
{
if (!TryGetSettings(out var settings))
{
#if UNITY_EDITOR
settings = ScriptableObject.CreateInstance<GLTFSettings>();
var dir = Path.GetDirectoryName(k_RuntimeAndEditorSettingsPath);
if (!Directory.Exists(dir)) Directory.CreateDirectory(dir);
AssetDatabase.CreateAsset(settings, k_RuntimeAndEditorSettingsPath);
AssetDatabase.SaveAssets();
#else
settings = ScriptableObject.CreateInstance<GLTFSettings>();
#endif
}
cachedSettings = settings;
return settings;
}
public static bool TryGetSettings(out GLTFSettings settings)
{
settings = cachedSettings;
if (settings)
return true;
settings = Resources.Load<GLTFSettings>(Path.GetFileNameWithoutExtension(k_SettingsFileName));
#if UNITY_EDITOR
if (!settings)
{
settings = AssetDatabase.LoadAssetAtPath<GLTFSettings>(k_RuntimeAndEditorSettingsPath);
}
if (!settings)
{
var allSettings = AssetDatabase.FindAssets("t:GLTFSettings");
if (allSettings.Length > 0)
{
settings = AssetDatabase.LoadAssetAtPath<GLTFSettings>(AssetDatabase.GUIDToAssetPath(allSettings[0]));
}
}
cachedSettings = settings;
return settings;
#else
return settings;
#endif
}
}
}