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

610 lines
24 KiB
C#

using System;
using System.Collections.Generic;
using GLTF.Schema;
using GLTF.Schema.KHR_lights_punctual;
using UnityEngine;
using UnityGLTF.Extensions;
using UnityGLTF.JsonPointer;
using Object = UnityEngine.Object;
namespace UnityGLTF
{
public partial class GLTFSceneExporter
{
internal readonly List<IJsonPointerResolver> pointerResolvers = new List<IJsonPointerResolver>();
private readonly KHR_animation_pointer_Resolver animationPointerResolver = new KHR_animation_pointer_Resolver();
#region Shader Property Names
// ReSharper disable InconsistentNaming
private static readonly int _MainTex = Shader.PropertyToID("_MainTex");
private static readonly int _BaseMap = Shader.PropertyToID("_BaseMap");
private static readonly int _BaseColorTexture = Shader.PropertyToID("_BaseColorTexture");
private static readonly int baseColorTexture = Shader.PropertyToID("baseColorTexture");
private static readonly int _EmissionMap = Shader.PropertyToID("_EmissionMap");
private static readonly int _EmissiveTexture = Shader.PropertyToID("_EmissiveTexture");
private static readonly int emissiveTexture = Shader.PropertyToID("emissiveTexture");
private static readonly int _BumpMap = Shader.PropertyToID("_BumpMap");
private static readonly int _NormalTexture = Shader.PropertyToID("_NormalTexture");
private static readonly int normalTexture = Shader.PropertyToID("normalTexture");
private static readonly int _OcclusionMap = Shader.PropertyToID("_OcclusionMap");
private static readonly int _OcclusionTexture = Shader.PropertyToID("_OcclusionTexture");
private static readonly int occlusionTexture = Shader.PropertyToID("occlusionTexture");
// ReSharper restore InconsistentNaming
#endregion
public void RegisterResolver(IJsonPointerResolver resolver)
{
if (!pointerResolvers.Contains(resolver))
pointerResolvers.Add(resolver);
}
public void AddAnimationData(Object animatedObject, string propertyName, GLTFAnimation animation, float[] times, object[] values)
{
if (!animatedObject) return;
// TODO should skip property switches that are not supported without KHR_animation_pointer
// TODO should probably start with the transform check below and stop afterwards if KHR_animation_pointer is off
if (values.Length <= 0) return;
for (var i = 0; i < values.Length; i++)
{
if (values[i] != null) continue;
Debug.LogError($"GLTFExporter error: value {i} in animated property \"{propertyName}\" is null. Skipping", animatedObject);
return;
}
var channelTargetId = GetIndex(animatedObject);
if (channelTargetId < 0)
{
Debug.LogWarning($"An animated {animatedObject.GetType()} has not been exported, is the object disabled? {animatedObject.name} (InstanceID: {animatedObject.GetInstanceID()})", animatedObject);
return;
}
bool flipValueRange = false;
float? valueMultiplier = null;
bool isTextureTransform = false;
bool keepColorAlpha = true;
string secondPropertyName = null;
string extensionName = null;
switch (animatedObject)
{
case Material material:
// Debug.Log("material: " + material + ", propertyName: " + propertyName);
// mapping from known Unity property names to glTF property names
switch (propertyName)
{
case "_Color":
case "_BaseColor":
case "_BaseColorFactor":
case "baseColorFactor":
propertyName = "pbrMetallicRoughness/baseColorFactor";
break;
case "_Smoothness":
case "_Glossiness":
propertyName = "pbrMetallicRoughness/roughnessFactor";
flipValueRange = true;
break;
case "_Roughness":
case "_RoughnessFactor":
case "roughnessFactor":
propertyName = "pbrMetallicRoughness/roughnessFactor";
break;
case "_Metallic":
case "_MetallicFactor":
case "metallicFactor":
propertyName = "pbrMetallicRoughness/metallicFactor";
break;
case "_MainTex_ST":
case "_BaseMap_ST":
case "_BaseColorTexture_ST":
case "baseColorTexture_ST":
if (!(material.HasProperty(_MainTex) && material.GetTexture(_MainTex)) &&
!(material.HasProperty(_BaseMap) && material.GetTexture(_BaseMap)) &&
!(material.HasProperty(_BaseColorTexture) && material.GetTexture(_BaseColorTexture)) &&
!(material.HasProperty(baseColorTexture) && material.GetTexture(baseColorTexture))) return;
propertyName = $"pbrMetallicRoughness/baseColorTexture/extensions/{ExtTextureTransformExtensionFactory.EXTENSION_NAME}/{ExtTextureTransformExtensionFactory.SCALE}";
secondPropertyName = $"pbrMetallicRoughness/baseColorTexture/extensions/{ExtTextureTransformExtensionFactory.EXTENSION_NAME}/{ExtTextureTransformExtensionFactory.OFFSET}";
isTextureTransform = true;
extensionName = ExtTextureTransformExtensionFactory.EXTENSION_NAME;
break;
case "_EmissionColor":
case "_EmissiveFactor":
case "emissiveFactor":
propertyName = "emissiveFactor";
secondPropertyName = $"extensions/{KHR_materials_emissive_strength_Factory.EXTENSION_NAME}/{nameof(KHR_materials_emissive_strength.emissiveStrength)}";
extensionName = KHR_materials_emissive_strength_Factory.EXTENSION_NAME;
keepColorAlpha = false;
break;
case "_EmissionMap_ST":
case "_EmissiveTexture_ST":
case "emissiveTexture_ST":
if (!(material.HasProperty(_EmissionMap) && material.GetTexture(_EmissionMap)) &&
!(material.HasProperty(_EmissiveTexture) && material.GetTexture(_EmissiveTexture)) &&
!(material.HasProperty(emissiveTexture) && material.GetTexture(emissiveTexture))) return;
propertyName = $"emissiveTexture/extensions/{ExtTextureTransformExtensionFactory.EXTENSION_NAME}/{ExtTextureTransformExtensionFactory.SCALE}";
secondPropertyName = $"emissiveTexture/extensions/{ExtTextureTransformExtensionFactory.EXTENSION_NAME}/{ExtTextureTransformExtensionFactory.OFFSET}";
isTextureTransform = true;
extensionName = ExtTextureTransformExtensionFactory.EXTENSION_NAME;
break;
case "_Cutoff":
case "_AlphaCutoff":
case "alphaCutoff":
propertyName = "alphaCutoff";
break;
case "_BumpScale":
case "_NormalScale":
case "normalScale":
case "normalTextureScale":
propertyName = "normalTexture/scale";
break;
case "_BumpMap_ST":
case "_NormalTexture_ST":
case "normalTexture_ST":
if (!(material.HasProperty(_BumpMap) && material.GetTexture(_BumpMap)) &&
!(material.HasProperty(_NormalTexture) && material.GetTexture(_NormalTexture)) &&
!(material.HasProperty(normalTexture) && material.GetTexture(normalTexture))) return;
propertyName = $"normalTexture/extensions/{ExtTextureTransformExtensionFactory.EXTENSION_NAME}/{ExtTextureTransformExtensionFactory.SCALE}";
secondPropertyName = $"normalTexture/extensions/{ExtTextureTransformExtensionFactory.EXTENSION_NAME}/{ExtTextureTransformExtensionFactory.OFFSET}";
isTextureTransform = true;
extensionName = ExtTextureTransformExtensionFactory.EXTENSION_NAME;
break;
case "_OcclusionStrength":
case "occlusionStrength":
case "occlusionTextureStrength":
propertyName = "occlusionTexture/strength";
break;
case "_OcclusionMap_ST":
case "_OcclusionTexture_ST":
case "occlusionTexture_ST":
if (!(material.HasProperty(_OcclusionMap) && material.GetTexture(_OcclusionMap)) &&
!(material.HasProperty(_OcclusionTexture) && material.GetTexture(_OcclusionTexture)) &&
!(material.HasProperty(occlusionTexture) && material.GetTexture(occlusionTexture))) return;
propertyName = $"occlusionTexture/extensions/{ExtTextureTransformExtensionFactory.EXTENSION_NAME}/{ExtTextureTransformExtensionFactory.SCALE}";
secondPropertyName = $"occlusionTexture/extensions/{ExtTextureTransformExtensionFactory.EXTENSION_NAME}/{ExtTextureTransformExtensionFactory.OFFSET}";
isTextureTransform = true;
extensionName = ExtTextureTransformExtensionFactory.EXTENSION_NAME;
break;
// TODO metallic/roughness _ST
// KHR_materials_transmission
case "_TransmissionFactor":
case "transmissionFactor":
propertyName = $"extensions/{KHR_materials_transmission_Factory.EXTENSION_NAME}/{nameof(KHR_materials_transmission.transmissionFactor)}";
extensionName = KHR_materials_transmission_Factory.EXTENSION_NAME;
break;
// KHR_materials_volume
case "_ThicknessFactor":
case "thicknessFactor":
propertyName = $"extensions/{KHR_materials_volume_Factory.EXTENSION_NAME}/{nameof(KHR_materials_volume.thicknessFactor)}";
extensionName = KHR_materials_volume_Factory.EXTENSION_NAME;
break;
case "_AttenuationDistance":
case "attenuationDistance":
propertyName = $"extensions/{KHR_materials_volume_Factory.EXTENSION_NAME}/{nameof(KHR_materials_volume.attenuationDistance)}";
extensionName = KHR_materials_volume_Factory.EXTENSION_NAME;
break;
case "_AttenuationColor":
case "attenuationColor":
propertyName = $"extensions/{KHR_materials_volume_Factory.EXTENSION_NAME}/{nameof(KHR_materials_volume.attenuationColor)}";
extensionName = KHR_materials_volume_Factory.EXTENSION_NAME;
keepColorAlpha = false;
break;
// KHR_materials_ior
case "_IOR":
case "ior":
propertyName = $"extensions/{KHR_materials_ior_Factory.EXTENSION_NAME}/{nameof(KHR_materials_ior.ior)}";
extensionName = KHR_materials_ior_Factory.EXTENSION_NAME;
break;
// KHR_materials_iridescence
case "_IridescenceFactor":
case "iridescenceFactor":
propertyName = $"extensions/{KHR_materials_iridescence_Factory.EXTENSION_NAME}/{nameof(KHR_materials_iridescence.iridescenceFactor)}";
extensionName = KHR_materials_iridescence_Factory.EXTENSION_NAME;
break;
case "_IridescenceIor":
case "iridescenceIor":
propertyName = $"extensions/{KHR_materials_iridescence_Factory.EXTENSION_NAME}/{nameof(KHR_materials_iridescence.iridescenceIor)}";
extensionName = KHR_materials_iridescence_Factory.EXTENSION_NAME;
break;
case "_IridescenceThicknessMinimum":
case "iridescenceThicknessMinimum":
propertyName = $"extensions/{KHR_materials_iridescence_Factory.EXTENSION_NAME}/{nameof(KHR_materials_iridescence.iridescenceThicknessMinimum)}";
extensionName = KHR_materials_iridescence_Factory.EXTENSION_NAME;
break;
case "_IridescenceThicknessMaximum":
case "iridescenceThicknessMaximum":
propertyName = $"extensions/{KHR_materials_iridescence_Factory.EXTENSION_NAME}/{nameof(KHR_materials_iridescence.iridescenceThicknessMaximum)}";
extensionName = KHR_materials_iridescence_Factory.EXTENSION_NAME;
break;
// KHR_materials_specular
case "_SpecularFactor":
case "specularFactor":
propertyName = $"extensions/{KHR_materials_specular_Factory.EXTENSION_NAME}/{nameof(KHR_materials_specular.specularFactor)}";
extensionName = KHR_materials_specular_Factory.EXTENSION_NAME;
break;
case "_SpecularColorFactor":
case "specularColorFactor":
propertyName = $"extensions/{KHR_materials_specular_Factory.EXTENSION_NAME}/{nameof(KHR_materials_specular.specularColorFactor)}";
extensionName = KHR_materials_specular_Factory.EXTENSION_NAME;
keepColorAlpha = false;
break;
// TODO KHR_materials_clearcoat
// case "_ClearcoatFactor":
// case "clearcoatFactor":
// propertyName = $"extensions/{KHR_materials_clearcoat_Factory.EXTENSION_NAME}/{nameof(KHR_materials_clearcoat.clearcoatFactor)}";
// extensionName = KHR_materials_clearcoat_Factory.EXTENSION_NAME;
// break;
// case "_ClearcoatRoughnessFactor":
// case "clearcoatRoughnessFactor":
// propertyName = $"extensions/{KHR_materials_clearcoat_Factory.EXTENSION_NAME}/{nameof(KHR_materials_clearcoat.clearcoatRoughnessFactor)}";
// extensionName = KHR_materials_clearcoat_Factory.EXTENSION_NAME;
// break;
// TODO KHR_materials_sheen
// case "_SheenColorFactor":
// case "sheenColorFactor":
// propertyName = $"extensions/{KHR_materials_sheen_Factory.EXTENSION_NAME}/{nameof(KHR_materials_sheen.sheenColorFactor)}";
// extensionName = KHR_materials_sheen_Factory.EXTENSION_NAME;
// keepColorAlpha = false;
// break;
// case "_SheenRoughnessFactor":
// case "sheenRoughnessFactor":
// propertyName = $"extensions/{KHR_materials_sheen_Factory.EXTENSION_NAME}/{nameof(KHR_materials_sheen.sheenRoughnessFactor)}";
// extensionName = KHR_materials_sheen_Factory.EXTENSION_NAME;
// break;
default:
Debug.Log(LogType.Warning, "Unknown property name on Material " + material + ": " + propertyName);
break;
}
break;
case Light light:
extensionName = KHR_lights_punctualExtensionFactory.EXTENSION_NAME;
switch (propertyName)
{
case "m_Color":
propertyName = $"color";
keepColorAlpha = false;
break;
case "m_Intensity":
valueMultiplier = Mathf.PI; // matches ExportLight
propertyName = $"intensity";
break;
case "m_SpotAngle":
valueMultiplier = Mathf.Deg2Rad / 2;
propertyName = $"spot/outerConeAngle";
break;
case "m_InnerSpotAngle":
valueMultiplier = Mathf.Deg2Rad / 2;
propertyName = $"spot/innerConeAngle";
break;
case "m_Range":
propertyName = "range";
break;
default:
extensionName = null;
Debug.Log(LogType.Warning, "Unknown property name on Light " + light + ": " + propertyName);
break;
}
break;
case Camera camera:
if(camera.orthographic)
{
switch (propertyName)
{
case "orthographic size":
// TODO conversion factor
propertyName = "orthographic/ymag";
secondPropertyName = "orthographic/xmag";
break;
case "near clip plane":
propertyName = "orthographic/znear";
break;
case "far clip plane":
propertyName = "orthographic/zfar";
break;
default:
Debug.Log(LogType.Warning, "Unknown property name on Camera " + camera + ": " + propertyName);
break;
}
}
else
{
switch (propertyName)
{
case "field of view":
// TODO conversion factor
propertyName = "perspective/yfov";
valueMultiplier = Mathf.Deg2Rad;
break;
case "near clip plane":
propertyName = "perspective/znear";
break;
case "far clip plane":
propertyName = "perspective/zfar";
break;
default:
Debug.Log(LogType.Warning, "Unknown property name on Camera " + camera + ": " + propertyName);
break;
}
}
break;
case SkinnedMeshRenderer skinnedMesh:
// this code is adapted from SkinnedMeshRendererEditor (which calculates the right range for sliders to show)
// instead of calculating per blend shape, we're assuming all blendshapes have the same min/max here though.
var minBlendShapeFrameWeight = 0.0f;
var maxBlendShapeFrameWeight = 0.0f;
var sharedMesh = skinnedMesh.sharedMesh;
if (!sharedMesh)
{
Debug.Log(LogType.Error, "No mesh on SkinnedMeshRenderer " + skinnedMesh + ", skipping animation");
return;
}
var shapeCount = sharedMesh.blendShapeCount;
for (int index = 0; index < shapeCount; ++index)
{
var blendShapeFrameCount = sharedMesh.GetBlendShapeFrameCount(index);
for (var frameIndex = 0; frameIndex < blendShapeFrameCount; ++frameIndex)
{
var shapeFrameWeight = sharedMesh.GetBlendShapeFrameWeight(index, frameIndex);
minBlendShapeFrameWeight = Mathf.Min(shapeFrameWeight, minBlendShapeFrameWeight);
maxBlendShapeFrameWeight = Mathf.Max(shapeFrameWeight, maxBlendShapeFrameWeight);
}
}
if (maxBlendShapeFrameWeight != 0)
valueMultiplier = 1.0f / maxBlendShapeFrameWeight;
break;
case Transform _:
// generally allowed and already in the right format
break;
default:
// propertyName is exported as-is
// Debug.LogWarning($"Implicitly handling animated property \"{propertyName}\" for target {animatedObject}", animatedObject);
// filtering for what to include / what not to include based on whether its target can be resolved
if (settings.UseAnimationPointer && animatedObject is Component _)
{
var couldResolve = false;
var prop = $"/nodes/{channelTargetId}/{propertyName}";
foreach (var res in pointerResolvers)
{
// TODO: ideally we have a new method here to just ask the resolver if it supports that type
if (res.TryResolve(animatedObject, ref prop))
{
couldResolve = true;
}
}
if (!couldResolve)
{
return;
}
}
break;
}
var Node = new NodeId
{
Id = channelTargetId,
Root = _root
};
AccessorId timeAccessor = ExportAccessor(times);
AnimationChannel Tchannel = new AnimationChannel();
AnimationChannelTarget TchannelTarget = new AnimationChannelTarget() { Path = propertyName, Node = Node };
Tchannel.Target = TchannelTarget;
AnimationSampler Tsampler = new AnimationSampler();
Tsampler.Input = timeAccessor;
// for cases where one property needs to be split up into multiple tracks
// example: emissiveFactor * emissiveStrength
// TODO not needed when secondPropertyName==null
AnimationChannel Tchannel2 = new AnimationChannel();
AnimationChannelTarget TchannelTarget2 = new AnimationChannelTarget() { Path = secondPropertyName, Node = Node };
Tchannel2.Target = TchannelTarget2;
AnimationSampler Tsampler2 = new AnimationSampler();
Tsampler2.Input = timeAccessor;
bool actuallyNeedSecondSampler = true;
var val = values[0];
switch (val)
{
case float _:
if (flipValueRange)
{
Tsampler.Output = ExportAccessor(Array.ConvertAll(values, e => 1.0f - (float)e));
}
else if (valueMultiplier.HasValue)
{
var multiplier = valueMultiplier.Value;
Tsampler.Output = ExportAccessor(Array.ConvertAll(values, e => ((float)e) * multiplier));
}
else
{
Tsampler.Output = ExportAccessor(Array.ConvertAll(values, e => (float)e));
if (propertyName == "orthographic/ymag")
{
Tsampler2.Output = Tsampler.Output;
}
}
break;
case float[] _:
// check that all entries have the same length using a for loop
var firstLength = ((float[])values[0]).Length;
for (var i = 1; i < values.Length; i++)
{
if (((float[])values[i]).Length == firstLength) continue;
Debug.Log(LogType.Error, "When animating float arrays, all array entries must have the same length. Skipping");
return;
}
// construct a float array of all the float arrays together
var floatArray = new float[values.Length * firstLength];
// copy the individual arrays into the float array using Array.Copy
for (int i = 0; i < values.Length; i++)
Array.Copy((float[])values[i], 0, floatArray, i * firstLength, firstLength);
// glTF weights 0..1 match to Unity weights 0..100, but Unity weights can be in arbitrary ranges
if (valueMultiplier.HasValue)
{
for (var i = 0; i < floatArray.Length; i++)
floatArray[i] *= valueMultiplier.Value;
}
Tsampler.Output = ExportAccessor(floatArray);
break;
case Vector2 _:
Tsampler.Output = ExportAccessor(Array.ConvertAll(values, e => (Vector2)e));
break;
case Vector3 _:
if (propertyName == "translation")
Tsampler.Output = ExportAccessor(Array.ConvertAll(values, e =>
{
var v = (Vector3)e;
v.Scale(new Vector3(-1, 1, 1));
return v;
}));
else
Tsampler.Output = ExportAccessor(Array.ConvertAll(values, e => (Vector3)e));
break;
case Vector4 _:
if (!isTextureTransform)
{
Tsampler.Output = ExportAccessor(Array.ConvertAll(values, e => (Vector4)e));
}
else
{
var scales = new Vector2[values.Length];
var offsets = new Vector2[values.Length];
for (int i = 0; i < values.Length; i++)
{
DecomposeScaleOffset((Vector4) values[i], out var scale, out var offset);
scales[i] = scale;
offsets[i] = offset;
}
Tsampler.Output = ExportAccessor(scales);
Tsampler2.Output = ExportAccessor(offsets);
}
break;
case Quaternion _:
var animatedNode = _root.Nodes[channelTargetId];
var needsFlippedLookDirection = animatedNode.Light != null || animatedNode.Camera != null;
Tsampler.Output = ExportAccessorSwitchHandedness(Array.ConvertAll(values, e => (Quaternion)e), needsFlippedLookDirection); // Vec4 for rotations
break;
case Color _:
if (propertyName == "emissiveFactor" && secondPropertyName != null)
{
var colors = new Color[values.Length];
var strengths = new float[values.Length];
actuallyNeedSecondSampler = false;
for (int i = 0; i < values.Length; i++)
{
DecomposeEmissionColor((Color) values[i], out var color, out var intensity);
colors[i] = color;
strengths[i] = intensity;
if (intensity > 1)
actuallyNeedSecondSampler = true;
}
Tsampler.Output = ExportAccessor(colors, false);
Tsampler2.Output = ExportAccessor(strengths);
}
else
{
Tsampler.Output = ExportAccessor(Array.ConvertAll(values, e => (Color)e), keepColorAlpha);
}
break;
}
if (Tsampler.Output != null) Tsampler.Output.Value.BufferView.Value.ByteStride = 0;
if (Tsampler2.Output != null) Tsampler2.Output.Value.BufferView.Value.ByteStride = 0;
if (Tsampler.Output == null)
{
Debug.LogError($"GLTFExporter: Something went wrong, empty sampler output for \"{propertyName}\" in {animatedObject}", animatedObject);
return;
}
Tchannel.Sampler = new AnimationSamplerId
{
Id = animation.Samplers.Count,
GLTFAnimation = animation,
Root = _root
};
animation.Samplers.Add(Tsampler);
animation.Channels.Add(Tchannel);
if (settings.UseAnimationPointer)
ConvertToAnimationPointer(animatedObject, propertyName, TchannelTarget);
// in some cases, extensions aren't required even when we think they might, e.g. for emission color animation.
// if all animated values are below 1, we don't need a separate channel for emissive_intensity.
if (!actuallyNeedSecondSampler)
{
extensionName = null;
secondPropertyName = null;
}
if (extensionName != null)
{
DeclareExtensionUsage(extensionName, false);
// add extension to material if needed
if(animatedObject is Material material)
{
var mat = GetMaterialId(_root, material);
if (mat.Value.Extensions == null || !mat.Value.Extensions.ContainsKey(extensionName))
{
mat.Value.AddExtension(extensionName, GLTFProperty.CreateEmptyExtension(extensionName));
}
}
}
if (secondPropertyName != null)
{
Tchannel2.Sampler = new AnimationSamplerId
{
Id = animation.Samplers.Count,
GLTFAnimation = animation,
Root = _root
};
animation.Samplers.Add(Tsampler2);
animation.Channels.Add(Tchannel2);
if (settings.UseAnimationPointer)
ConvertToAnimationPointer(animatedObject, secondPropertyName, TchannelTarget2);
}
}
void ConvertToAnimationPointer(object animatedObject, string propertyName, AnimationChannelTarget target)
{
var ext = new KHR_animation_pointer();
ext.propertyBinding = propertyName;
ext.animatedObject = animatedObject;
ext.channel = target;
animationPointerResolver.Add(ext);
target.Node = null;
target.Path = "pointer";
target.AddExtension(KHR_animation_pointer.EXTENSION_NAME, ext);
DeclareExtensionUsage(KHR_animation_pointer.EXTENSION_NAME, false);
}
}
}