655 lines
30 KiB
C#
655 lines
30 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Reflection;
|
|
using Newtonsoft.Json.Linq;
|
|
using Unity.Pipeline.Commands;
|
|
using Unity.Pipeline.Editor.Authoring;
|
|
using Unity.Pipeline.Models;
|
|
using UnityEditor;
|
|
|
|
namespace Unity.Pipeline.Editor.Commands.Assets
|
|
{
|
|
/// <summary>
|
|
/// <para>
|
|
/// Import-settings authoring commands (CLI-191 + CLI-212). Reads and edits the
|
|
/// <see cref="AssetImporter"/> for an asset.
|
|
/// </para>
|
|
///
|
|
/// <para>
|
|
/// <c>set_import_settings</c> sets named members on the importer from a JSON object and re-imports.
|
|
/// For the <c>Default</c> platform it sets top-level public properties/fields via reflection (works
|
|
/// across every importer kind). For a real platform on a <see cref="TextureImporter"/> /
|
|
/// <see cref="AudioImporter"/>, keys are applied onto the platform-override struct
|
|
/// (<see cref="TextureImporterPlatformSettings"/> / <see cref="AudioImporterSampleSettings"/>) which
|
|
/// is unreachable by top-level reflection. <see cref="ModelImporter"/> has no per-platform overrides.
|
|
/// </para>
|
|
///
|
|
/// <para>
|
|
/// <c>get_import_settings</c> reads the importer state structured by importer type (texture / model /
|
|
/// audio), including the default-platform fields and, for textures/audio, one platform override block.
|
|
/// </para>
|
|
///
|
|
/// <para>
|
|
/// Unknown keys are reported back rather than silently ignored, so an agent gets actionable feedback.
|
|
/// </para>
|
|
///
|
|
/// <para>
|
|
/// NOTE: import settings live in the asset's .meta file via the importer; this is an AssetDatabase
|
|
/// operation and is not part of Unity's Undo system. SaveAndReimport is not destructive to the
|
|
/// source file, so no <c>confirm</c> is required.
|
|
/// </para>
|
|
/// </summary>
|
|
public static class AssetImportCommands
|
|
{
|
|
// Caller-facing platform names accepted by both commands. "Default" means the default platform
|
|
// (top-level importer properties / default sample settings); the rest are real build platforms.
|
|
private static readonly HashSet<string> s_SupportedPlatforms = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
"Default", "Standalone", "iOS", "Android", "WebGL", "tvOS"
|
|
};
|
|
|
|
[CliCommand("set_import_settings", "Set import settings on an asset's AssetImporter (default platform top-level properties, or a texture/audio per-platform override) and re-import it.")]
|
|
public static SetImportSettingsResult SetImportSettings(
|
|
[CliArg("asset", "Reference to the asset whose importer to edit (path / guid / globalId).", Required = true)] ObjectRef asset,
|
|
[CliArg("settings", "JSON object of importer property/field names to values, e.g. {\"isReadable\": true, \"textureType\": \"NormalMap\"}. For platform != Default on a texture/audio importer, keys map onto the platform-settings struct (e.g. maxTextureSize, format, compressionFormat, quality, and overridden).", Required = true)] JObject settings,
|
|
[CliArg("platform", "Target platform: Default | Standalone | iOS | Android | WebGL | tvOS. Defaults to Default (top-level importer properties). A real platform writes a per-platform override (textures/audio only).")] string platform = "Default",
|
|
[CliArg("dry_run", "If true, validate which settings would apply (and which are unknown) without writing or re-importing.")] bool dryRun = false)
|
|
{
|
|
var importer = ResolveImporter(asset, out var assetPath);
|
|
|
|
if (settings == null || settings.Count == 0)
|
|
throw new ArgumentException("settings must be a non-empty JSON object.");
|
|
|
|
if (!s_SupportedPlatforms.Contains(platform))
|
|
throw new ArgumentException(
|
|
Serialize(new ErrorResult { Code = "unknown_platform", Message = $"Unknown platform '{platform}'. Supported: {string.Join(", ", s_SupportedPlatforms)}." }));
|
|
|
|
var canonicalPlatform = Canonical(platform);
|
|
var isDefault = string.Equals(canonicalPlatform, "Default", StringComparison.OrdinalIgnoreCase);
|
|
|
|
var result = new SetImportSettingsResult
|
|
{
|
|
AssetPath = assetPath,
|
|
ImporterType = importer.GetType().Name,
|
|
Platform = canonicalPlatform
|
|
};
|
|
|
|
// Strip the server-injected token before iterating: it is never an importer setting.
|
|
var keys = new List<string>();
|
|
foreach (var pair in settings)
|
|
{
|
|
if (pair.Key == "token")
|
|
continue;
|
|
keys.Add(pair.Key);
|
|
}
|
|
if (keys.Count == 0)
|
|
throw new ArgumentException("settings must be a non-empty JSON object.");
|
|
|
|
if (isDefault)
|
|
{
|
|
ApplyDefaultPlatform(importer, settings, keys, result, write: !dryRun);
|
|
}
|
|
else
|
|
{
|
|
switch (importer)
|
|
{
|
|
case TextureImporter texture:
|
|
ApplyTexturePlatform(texture, settings, keys, canonicalPlatform, result, write: !dryRun);
|
|
break;
|
|
case AudioImporter audio:
|
|
ApplyAudioPlatform(audio, settings, keys, canonicalPlatform, result, write: !dryRun);
|
|
break;
|
|
case ModelImporter _:
|
|
throw new ArgumentException(
|
|
Serialize(new ErrorResult { Code = "no_platform_overrides", Message = "ModelImporter has no per-platform overrides; use platform=Default." }));
|
|
default:
|
|
throw new ArgumentException(
|
|
Serialize(new ErrorResult { Code = "no_platform_overrides", Message = $"Importer '{result.ImporterType}' has no per-platform overrides; use platform=Default." }));
|
|
}
|
|
}
|
|
|
|
if (result.Unknown.Count > 0 && result.Applied.Count == 0)
|
|
throw new ArgumentException($"None of the supplied settings could be applied to '{result.ImporterType}' (unknown key or invalid value): {string.Join(", ", result.Unknown)}.");
|
|
|
|
if (dryRun)
|
|
return result;
|
|
|
|
importer.SaveAndReimport();
|
|
return result;
|
|
}
|
|
|
|
[CliCommand("get_import_settings", "Read an asset's import settings, structured by importer type (texture/model/audio), including the default-platform fields and (for textures/audio) one platform override block.")]
|
|
public static GetImportSettingsResult GetImportSettings(
|
|
[CliArg("asset", "Reference to the asset whose importer to read (path / guid / globalId).", Required = true)] ObjectRef asset,
|
|
[CliArg("platform", "Platform whose override to read: Default | Standalone | iOS | Android | WebGL | tvOS. Defaults to Default.")] string platform = "Default")
|
|
{
|
|
var importer = ResolveImporter(asset, out var assetPath);
|
|
|
|
if (!s_SupportedPlatforms.Contains(platform))
|
|
throw new ArgumentException(
|
|
Serialize(new ErrorResult { Code = "unknown_platform", Message = $"Unknown platform '{platform}'. Supported: {string.Join(", ", s_SupportedPlatforms)}." }));
|
|
|
|
var canonicalPlatform = Canonical(platform);
|
|
var isDefault = string.Equals(canonicalPlatform, "Default", StringComparison.OrdinalIgnoreCase);
|
|
|
|
var result = new GetImportSettingsResult
|
|
{
|
|
AssetPath = assetPath,
|
|
ImporterType = importer.GetType().Name,
|
|
Platform = canonicalPlatform
|
|
};
|
|
|
|
switch (importer)
|
|
{
|
|
case TextureImporter texture:
|
|
result.Settings = ReadTextureDefaults(texture);
|
|
result.PlatformOverride = ReadTexturePlatformOverride(texture, canonicalPlatform, isDefault);
|
|
break;
|
|
case ModelImporter model:
|
|
result.Settings = ReadModelDefaults(model);
|
|
result.PlatformOverride = null; // ModelImporter has no per-platform overrides.
|
|
break;
|
|
case AudioImporter audio:
|
|
result.Settings = ReadAudioDefaults(audio);
|
|
result.PlatformOverride = ReadAudioPlatformOverride(audio, canonicalPlatform, isDefault);
|
|
break;
|
|
default:
|
|
// Non-import asset (e.g. a ScriptableObject via NativeFormatImporter): return a
|
|
// minimal settings block rather than throwing.
|
|
result.Settings = new Dictionary<string, object>
|
|
{
|
|
["userData"] = importer.userData,
|
|
["assetBundleName"] = importer.assetBundleName
|
|
};
|
|
result.PlatformOverride = null;
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// ------------------------------------------------------------------ resolution / helpers
|
|
|
|
/// <summary>
|
|
/// Resolve an <see cref="ObjectRef"/> to its <see cref="AssetImporter"/>, confined to the
|
|
/// authoring root. Throws an actionable <see cref="ArgumentException"/> on any failure.
|
|
/// </summary>
|
|
private static AssetImporter ResolveImporter(ObjectRef asset, out string assetPath)
|
|
{
|
|
if (!ObjectResolver.TryResolve(asset, out var obj, out var error))
|
|
throw new ArgumentException(error);
|
|
|
|
assetPath = AssetDatabase.GetAssetPath(obj);
|
|
if (string.IsNullOrEmpty(assetPath))
|
|
throw new ArgumentException($"Reference '{asset}' does not point at an on-disk asset.");
|
|
|
|
// Confine to the authoring root so a GUID/globalId handle cannot reach an asset outside the
|
|
// sandbox.
|
|
assetPath = ProjectPaths.Resolve(assetPath, out var confineError);
|
|
if (assetPath == null)
|
|
throw new ArgumentException(
|
|
$"Asset '{asset}' is outside the authoring root '{ProjectPaths.AuthoringRoot}': {confineError}");
|
|
|
|
var importer = AssetImporter.GetAtPath(assetPath);
|
|
if (importer == null)
|
|
throw new ArgumentException($"No AssetImporter found for '{assetPath}'.");
|
|
|
|
return importer;
|
|
}
|
|
|
|
/// <summary>Normalize a caller platform name to its canonical capitalization (e.g. "ios" -> "iOS").</summary>
|
|
private static string Canonical(string platform)
|
|
{
|
|
foreach (var supported in s_SupportedPlatforms)
|
|
{
|
|
if (string.Equals(supported, platform, StringComparison.OrdinalIgnoreCase))
|
|
return supported;
|
|
}
|
|
return platform;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Map a caller-facing platform name to the build-platform string Unity's importer APIs expect.
|
|
/// Most match 1:1; iOS is "iPhone" to those APIs.
|
|
/// </summary>
|
|
private static string UnityPlatformName(string canonicalPlatform)
|
|
{
|
|
return string.Equals(canonicalPlatform, "iOS", StringComparison.OrdinalIgnoreCase) ? "iPhone" : canonicalPlatform;
|
|
}
|
|
|
|
// ------------------------------------------------------------------ default-platform reflection
|
|
|
|
private static void ApplyDefaultPlatform(AssetImporter importer, JObject settings, List<string> keys, SetImportSettingsResult result, bool write)
|
|
{
|
|
var importerType = importer.GetType();
|
|
const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase;
|
|
|
|
foreach (var key in keys)
|
|
{
|
|
// In dry_run we only validate the member exists and the value converts — never mutate the
|
|
// (possibly cached) importer instance, so a dry run leaves no trace.
|
|
var applied = TryApplyMember(importer, importerType, flags, key, settings[key], write);
|
|
if (applied)
|
|
result.Applied.Add(key);
|
|
else
|
|
result.Unknown.Add(key);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set a single named property or field on the target from a JSON token. Returns false when no
|
|
/// writable member with that name exists or the value cannot be converted to the member type.
|
|
/// Enum members accept the value name (case-insensitive) as well as numeric values.
|
|
/// </summary>
|
|
private static bool TryApplyMember(object target, Type type, BindingFlags flags, string memberName, JToken value, bool write)
|
|
{
|
|
var property = type.GetProperty(memberName, flags);
|
|
if (property != null && property.CanWrite && property.GetIndexParameters().Length == 0)
|
|
{
|
|
return TryConvertAndSet(property.PropertyType, value,
|
|
converted => { if (write) property.SetValue(target, converted); });
|
|
}
|
|
|
|
var field = type.GetField(memberName, flags);
|
|
if (field != null)
|
|
{
|
|
return TryConvertAndSet(field.FieldType, value,
|
|
converted => { if (write) field.SetValue(target, converted); });
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert a JSON token to <paramref name="targetType"/> (with case-insensitive enum-name support)
|
|
/// and, on success, invoke <paramref name="set"/>. Returns false when the value cannot convert.
|
|
/// </summary>
|
|
private static bool TryConvertAndSet(Type targetType, JToken value, Action<object> set)
|
|
{
|
|
try
|
|
{
|
|
if (!TryConvert(targetType, value, out var converted))
|
|
return false;
|
|
set(converted);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert a JSON token to a CLR value. Enums accept their value name (case-insensitive) or an
|
|
/// integral value; everything else defers to Newtonsoft's <see cref="JToken.ToObject(Type)"/>.
|
|
/// </summary>
|
|
private static bool TryConvert(Type targetType, JToken value, out object converted)
|
|
{
|
|
converted = null;
|
|
var underlying = Nullable.GetUnderlyingType(targetType) ?? targetType;
|
|
|
|
if (underlying.IsEnum)
|
|
{
|
|
if (value.Type == JTokenType.String)
|
|
{
|
|
var name = value.Value<string>();
|
|
if (string.IsNullOrEmpty(name))
|
|
return false;
|
|
try
|
|
{
|
|
converted = Enum.Parse(underlying, name, ignoreCase: true);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (value.Type == JTokenType.Integer)
|
|
{
|
|
converted = Enum.ToObject(underlying, value.Value<long>());
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
converted = value.ToObject(targetType);
|
|
return true;
|
|
}
|
|
|
|
// ------------------------------------------------------------------ texture platform overrides
|
|
|
|
private static void ApplyTexturePlatform(TextureImporter texture, JObject settings, List<string> keys, string canonicalPlatform, SetImportSettingsResult result, bool write)
|
|
{
|
|
var unityPlatform = UnityPlatformName(canonicalPlatform);
|
|
// Boxed struct so reflection SetValue mutates the local copy; written back via SetPlatformTextureSettings.
|
|
object boxed = texture.GetPlatformTextureSettings(unityPlatform);
|
|
var type = typeof(TextureImporterPlatformSettings);
|
|
const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase;
|
|
|
|
// Only treat "overridden" as explicitly provided when the caller passes a valid boolean.
|
|
// A non-boolean value is caught by TrySetBoolMember (reported to unknown[]), so we must
|
|
// not suppress the default overridden=true in that case or the override is silently skipped.
|
|
var explicitOverridden = settings.TryGetValue("overridden", StringComparison.OrdinalIgnoreCase, out var overriddenTok)
|
|
&& overriddenTok.Type == JTokenType.Boolean;
|
|
|
|
foreach (var key in keys)
|
|
{
|
|
if (string.Equals(key, "overridden", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
// Handled explicitly below; still report it as applied.
|
|
if (TrySetBoolMember(type, flags, boxed, "overridden", settings[key], write))
|
|
result.Applied.Add(key);
|
|
else
|
|
result.Unknown.Add(key);
|
|
continue;
|
|
}
|
|
|
|
if (TryApplyMember(boxed, type, flags, key, settings[key], write))
|
|
result.Applied.Add(key);
|
|
else
|
|
result.Unknown.Add(key);
|
|
}
|
|
|
|
// Default the override on (the caller intends to set platform-specific values) unless they
|
|
// explicitly passed overridden:false (in which case the value they passed is already in the
|
|
// boxed copy from the loop above).
|
|
if (!explicitOverridden)
|
|
SetBool(type, flags, boxed, "overridden", true);
|
|
|
|
if (write && result.Applied.Count > 0)
|
|
{
|
|
var settingsStruct = (TextureImporterPlatformSettings)boxed;
|
|
settingsStruct.name = unityPlatform;
|
|
texture.SetPlatformTextureSettings(settingsStruct);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set a named boolean member from a JSON token. Returns false when the token is not a boolean or
|
|
/// no settable bool member with that name exists, so a non-existent member is reported as unknown
|
|
/// rather than falsely applied. In <paramref name="write"/>=false (dry-run) mode the member is only
|
|
/// probed for existence, never mutated.
|
|
/// </summary>
|
|
private static bool TrySetBoolMember(Type type, BindingFlags flags, object boxed, string member, JToken token, bool write)
|
|
{
|
|
if (token.Type != JTokenType.Boolean)
|
|
return false;
|
|
if (!write)
|
|
return BoolMemberExists(type, flags, member);
|
|
return SetBool(type, flags, boxed, member, token.Value<bool>());
|
|
}
|
|
|
|
/// <summary>True when a settable boolean property or field with that name exists on the type.</summary>
|
|
private static bool BoolMemberExists(Type type, BindingFlags flags, string member)
|
|
{
|
|
var property = type.GetProperty(member, flags);
|
|
if (property != null && property.CanWrite && property.PropertyType == typeof(bool)
|
|
&& property.GetIndexParameters().Length == 0)
|
|
return true;
|
|
|
|
var field = type.GetField(member, flags);
|
|
return field != null && field.FieldType == typeof(bool);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write a boolean property or field (matching <see cref="TryApplyMember"/>'s property-then-field
|
|
/// resolution so a bool implemented as a property is also honored). Returns false — without
|
|
/// mutating anything — when no settable bool member with that name exists.
|
|
/// </summary>
|
|
private static bool SetBool(Type type, BindingFlags flags, object boxed, string member, bool value)
|
|
{
|
|
var property = type.GetProperty(member, flags);
|
|
if (property != null && property.CanWrite && property.PropertyType == typeof(bool)
|
|
&& property.GetIndexParameters().Length == 0)
|
|
{
|
|
property.SetValue(boxed, value);
|
|
return true;
|
|
}
|
|
|
|
var field = type.GetField(member, flags);
|
|
if (field != null && field.FieldType == typeof(bool))
|
|
{
|
|
field.SetValue(boxed, value);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static Dictionary<string, object> ReadTextureDefaults(TextureImporter texture)
|
|
{
|
|
return new Dictionary<string, object>
|
|
{
|
|
["textureType"] = texture.textureType.ToString(),
|
|
["textureShape"] = texture.textureShape.ToString(),
|
|
["sRGBTexture"] = texture.sRGBTexture,
|
|
["alphaSource"] = texture.alphaSource.ToString(),
|
|
["alphaIsTransparency"] = texture.alphaIsTransparency,
|
|
["isReadable"] = texture.isReadable,
|
|
["streamingMipmaps"] = texture.streamingMipmaps,
|
|
["mipmapEnabled"] = texture.mipmapEnabled,
|
|
["wrapMode"] = texture.wrapMode.ToString(),
|
|
["filterMode"] = texture.filterMode.ToString(),
|
|
["anisoLevel"] = texture.anisoLevel,
|
|
["spriteImportMode"] = texture.spriteImportMode.ToString(),
|
|
["spritePixelsPerUnit"] = texture.spritePixelsPerUnit,
|
|
["npotScale"] = texture.npotScale.ToString(),
|
|
["maxTextureSize"] = texture.maxTextureSize
|
|
};
|
|
}
|
|
|
|
private static Dictionary<string, object> ReadTexturePlatformOverride(TextureImporter texture, string canonicalPlatform, bool isDefault)
|
|
{
|
|
var settings = isDefault
|
|
? texture.GetDefaultPlatformTextureSettings()
|
|
: texture.GetPlatformTextureSettings(UnityPlatformName(canonicalPlatform));
|
|
|
|
return new Dictionary<string, object>
|
|
{
|
|
["overridden"] = !isDefault && settings.overridden,
|
|
["maxTextureSize"] = settings.maxTextureSize,
|
|
["resizeAlgorithm"] = settings.resizeAlgorithm.ToString(),
|
|
["format"] = settings.format.ToString(),
|
|
["textureCompression"] = settings.textureCompression.ToString(),
|
|
["compressionQuality"] = settings.compressionQuality,
|
|
["crunchedCompression"] = settings.crunchedCompression,
|
|
["androidETC2FallbackOverride"] = settings.androidETC2FallbackOverride.ToString()
|
|
};
|
|
}
|
|
|
|
// ------------------------------------------------------------------ audio platform overrides
|
|
|
|
private static void ApplyAudioPlatform(AudioImporter audio, JObject settings, List<string> keys, string canonicalPlatform, SetImportSettingsResult result, bool write)
|
|
{
|
|
var unityPlatform = UnityPlatformName(canonicalPlatform);
|
|
|
|
// overridden:false clears the override entirely (and ignores any other keys).
|
|
if (settings.TryGetValue("overridden", StringComparison.OrdinalIgnoreCase, out var overriddenToken)
|
|
&& overriddenToken.Type == JTokenType.Boolean
|
|
&& !overriddenToken.Value<bool>())
|
|
{
|
|
result.Applied.Add("overridden");
|
|
if (write)
|
|
audio.ClearSampleSettingOverride(unityPlatform);
|
|
return;
|
|
}
|
|
|
|
object boxed = audio.GetOverrideSampleSettings(unityPlatform);
|
|
var type = typeof(AudioImporterSampleSettings);
|
|
const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase;
|
|
|
|
foreach (var key in keys)
|
|
{
|
|
if (string.Equals(key, "overridden", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
// Only accept a boolean; anything else is a misuse and goes to unknown[].
|
|
if (settings[key].Type == JTokenType.Boolean)
|
|
result.Applied.Add(key);
|
|
else
|
|
result.Unknown.Add(key);
|
|
continue;
|
|
}
|
|
|
|
if (TryApplyMember(boxed, type, flags, key, settings[key], write))
|
|
result.Applied.Add(key);
|
|
else
|
|
result.Unknown.Add(key);
|
|
}
|
|
|
|
if (write && result.Applied.Count > 0)
|
|
{
|
|
var settingsStruct = (AudioImporterSampleSettings)boxed;
|
|
audio.SetOverrideSampleSettings(unityPlatform, settingsStruct);
|
|
}
|
|
}
|
|
|
|
private static Dictionary<string, object> ReadAudioDefaults(AudioImporter audio)
|
|
{
|
|
var sample = audio.defaultSampleSettings;
|
|
return new Dictionary<string, object>
|
|
{
|
|
["forceToMono"] = audio.forceToMono,
|
|
["loadInBackground"] = audio.loadInBackground,
|
|
["ambisonic"] = audio.ambisonic,
|
|
["loadType"] = sample.loadType.ToString(),
|
|
["compressionFormat"] = sample.compressionFormat.ToString(),
|
|
["quality"] = sample.quality,
|
|
["sampleRateSetting"] = sample.sampleRateSetting.ToString(),
|
|
["sampleRateOverride"] = sample.sampleRateOverride
|
|
};
|
|
}
|
|
|
|
private static Dictionary<string, object> ReadAudioPlatformOverride(AudioImporter audio, string canonicalPlatform, bool isDefault)
|
|
{
|
|
if (isDefault)
|
|
{
|
|
var sample = audio.defaultSampleSettings;
|
|
return new Dictionary<string, object>
|
|
{
|
|
["overridden"] = false,
|
|
["loadType"] = sample.loadType.ToString(),
|
|
["compressionFormat"] = sample.compressionFormat.ToString(),
|
|
["quality"] = sample.quality,
|
|
["sampleRateSetting"] = sample.sampleRateSetting.ToString(),
|
|
["sampleRateOverride"] = sample.sampleRateOverride
|
|
};
|
|
}
|
|
|
|
var unityPlatform = UnityPlatformName(canonicalPlatform);
|
|
var overridden = audio.ContainsSampleSettingsOverride(unityPlatform);
|
|
var settings = audio.GetOverrideSampleSettings(unityPlatform);
|
|
return new Dictionary<string, object>
|
|
{
|
|
["overridden"] = overridden,
|
|
["loadType"] = settings.loadType.ToString(),
|
|
["compressionFormat"] = settings.compressionFormat.ToString(),
|
|
["quality"] = settings.quality,
|
|
["sampleRateSetting"] = settings.sampleRateSetting.ToString(),
|
|
["sampleRateOverride"] = settings.sampleRateOverride
|
|
};
|
|
}
|
|
|
|
// ------------------------------------------------------------------ model defaults (no overrides)
|
|
|
|
private static Dictionary<string, object> ReadModelDefaults(ModelImporter model)
|
|
{
|
|
return new Dictionary<string, object>
|
|
{
|
|
// Meshes
|
|
["globalScale"] = model.globalScale,
|
|
["useFileScale"] = model.useFileScale,
|
|
["meshCompression"] = model.meshCompression.ToString(),
|
|
["isReadable"] = model.isReadable,
|
|
["meshOptimizationFlags"] = model.meshOptimizationFlags.ToString(),
|
|
["weldVertices"] = model.weldVertices,
|
|
["indexFormat"] = model.indexFormat.ToString(),
|
|
["keepQuads"] = model.keepQuads,
|
|
// Normals / Tangents
|
|
["importNormals"] = model.importNormals.ToString(),
|
|
["normalCalculationMode"] = model.normalCalculationMode.ToString(),
|
|
["normalSmoothingAngle"] = model.normalSmoothingAngle,
|
|
["importTangents"] = model.importTangents.ToString(),
|
|
["importBlendShapes"] = model.importBlendShapes,
|
|
// Geometry
|
|
["importCameras"] = model.importCameras,
|
|
["importLights"] = model.importLights,
|
|
["swapUVChannels"] = model.swapUVChannels,
|
|
["generateSecondaryUV"] = model.generateSecondaryUV,
|
|
// Materials
|
|
["materialImportMode"] = model.materialImportMode.ToString(),
|
|
["materialLocation"] = model.materialLocation.ToString(),
|
|
// Animation
|
|
["importAnimation"] = model.importAnimation,
|
|
["animationType"] = model.animationType.ToString(),
|
|
["importConstraints"] = model.importConstraints,
|
|
["importVisibility"] = model.importVisibility
|
|
};
|
|
}
|
|
|
|
private static string Serialize(object value)
|
|
{
|
|
return Newtonsoft.Json.JsonConvert.SerializeObject(value);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Result of <c>set_import_settings</c>: target platform plus which keys were applied vs. unknown.
|
|
/// </summary>
|
|
[Serializable]
|
|
public class SetImportSettingsResult
|
|
{
|
|
[Newtonsoft.Json.JsonProperty("assetPath")]
|
|
public string AssetPath { get; set; }
|
|
|
|
[Newtonsoft.Json.JsonProperty("importerType")]
|
|
public string ImporterType { get; set; }
|
|
|
|
[Newtonsoft.Json.JsonProperty("platform")]
|
|
public string Platform { get; set; }
|
|
|
|
[Newtonsoft.Json.JsonProperty("applied")]
|
|
public List<string> Applied { get; set; } = new List<string>();
|
|
|
|
[Newtonsoft.Json.JsonProperty("unknown")]
|
|
public List<string> Unknown { get; set; } = new List<string>();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Result of <c>get_import_settings</c>: the importer type, default-platform settings, and (for
|
|
/// textures/audio) one platform-override block. <c>platformOverride</c> is null for ModelImporter and
|
|
/// non-import assets.
|
|
/// </summary>
|
|
[Serializable]
|
|
public class GetImportSettingsResult
|
|
{
|
|
[Newtonsoft.Json.JsonProperty("assetPath")]
|
|
public string AssetPath { get; set; }
|
|
|
|
[Newtonsoft.Json.JsonProperty("importerType")]
|
|
public string ImporterType { get; set; }
|
|
|
|
[Newtonsoft.Json.JsonProperty("settings")]
|
|
public Dictionary<string, object> Settings { get; set; }
|
|
|
|
[Newtonsoft.Json.JsonProperty("platform")]
|
|
public string Platform { get; set; }
|
|
|
|
[Newtonsoft.Json.JsonProperty("platformOverride")]
|
|
public Dictionary<string, object> PlatformOverride { get; set; }
|
|
}
|
|
|
|
/// <summary>Structured error payload serialized into the thrown ArgumentException message.</summary>
|
|
[Serializable]
|
|
public class ErrorResult
|
|
{
|
|
[Newtonsoft.Json.JsonProperty("code")]
|
|
public string Code { get; set; }
|
|
|
|
[Newtonsoft.Json.JsonProperty("message")]
|
|
public string Message { get; set; }
|
|
}
|
|
}
|