Add UrlReference attempt number 2

sources/assets/Xenko.Core.Assets/AssetRegistry.cs

@@ -11,6 +11,7 @@
 using Xenko.Core.Serialization.Contents;
 using Xenko.Core.VisualStudio;
 using Xenko.Core.Yaml.Serialization;
+using Xenko.Core.Serialization;
 
 namespace Xenko.Core.Assets
 {
@@ -289,6 +290,14 @@ public static IReadOnlyList<Type> GetAssetTypes(Type contentType)
             lock (RegistryLock)
             {
                 var currentType = contentType;
+                if (UrlReferenceHelper.IsGenericUrlReferenceType(currentType))
+                {
+                    currentType = UrlReferenceHelper.GetTargetContentType(currentType);
+                }
+                else if (UrlReferenceHelper.IsUrlReferenceType(contentType))
+                {
+                    return GetPublicTypes().Where(t => IsAssetType(t)).ToList();
+                }
                 List<Type> assetTypes;
                 return ContentToAssetTypes.TryGetValue(currentType, out assetTypes) ? new List<Type>(assetTypes) : new List<Type>();
             }

sources/assets/Xenko.Core.Assets/Serializers/UrlReferenceSerializer.cs

@@ -0,0 +1,53 @@
+using System;
+using Xenko.Core;
+using Xenko.Core.Annotations;
+using Xenko.Core.IO;
+using Xenko.Core.Reflection;
+using Xenko.Core.Serialization;
+using Xenko.Core.Yaml;
+using Xenko.Core.Yaml.Events;
+using Xenko.Core.Yaml.Serialization;
+
+namespace Xenko.Core.Assets.Serializers
+{
+    /// <summary>
+    /// A Yaml serializer for <see cref="UrlReference"/>
+    /// </summary>
+    [YamlSerializerFactory(YamlAssetProfile.Name)]
+    internal class UrlReferenceSerializer : AssetScalarSerializerBase
+    {
+        public override bool CanVisit(Type type)
+        {
+            return typeof(UrlReference).IsAssignableFrom(type);
+        }
+
+        public override object ConvertFrom(ref ObjectContext context, Scalar fromScalar)
+        {
+            if (!AssetReference.TryParse(fromScalar.Value, out var guid, out var location))
+            {
+                throw new YamlException(fromScalar.Start, fromScalar.End, "Unable to decode url reference [{0}]. Expecting format GUID:LOCATION".ToFormat(fromScalar.Value));
+            }
+
+            var urlReference = UrlReferenceHelper.CreateReference(context.Descriptor.Type, guid, location.FullPath);
+
+            return urlReference;
+        }
+
+        public override string ConvertTo(ref ObjectContext objectContext)
+        {
+            if (objectContext.Instance is UrlReference urlReference)
+            {
+                var attachedReference = AttachedReferenceManager.GetAttachedReference(urlReference);
+
+                if (attachedReference != null)
+                {
+                    return $"{attachedReference.Id}:{urlReference.Url}";
+                }
+            }
+
+            throw new YamlException($"Unable to extract url reference from object [{objectContext.Instance}]");
+        }
+
+
+    }
+}

sources/core/Xenko.Core.Design/Module.cs

@@ -2,9 +2,9 @@
 // Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
 
 using System.ComponentModel;
-
 using Xenko.Core.Mathematics;
 using Xenko.Core.Reflection;
+using Xenko.Core.Serialization;
 using Xenko.Core.TypeConverters;
 
 namespace Xenko.Core
@@ -16,6 +16,7 @@ public static void Initialize()
         {
             // Make sure that this assembly is registered
             AssemblyRegistry.Register(typeof(Module).Assembly, AssemblyCommonCategories.Assets);
+
             TypeDescriptor.AddAttributes(typeof(Color), new TypeConverterAttribute(typeof(ColorConverter)));
             TypeDescriptor.AddAttributes(typeof(Color3), new TypeConverterAttribute(typeof(Color3Converter)));
             TypeDescriptor.AddAttributes(typeof(Color4), new TypeConverterAttribute(typeof(Color4Converter)));
@@ -28,6 +29,7 @@ public static void Initialize()
             TypeDescriptor.AddAttributes(typeof(Vector2), new TypeConverterAttribute(typeof(Vector2Converter)));
             TypeDescriptor.AddAttributes(typeof(Vector3), new TypeConverterAttribute(typeof(Vector3Converter)));
             TypeDescriptor.AddAttributes(typeof(Vector4), new TypeConverterAttribute(typeof(Vector4Converter)));
+            TypeDescriptor.AddAttributes(typeof(UrlReference), new TypeConverterAttribute(typeof(UrlReferenceConverter)));
         }
     }
 }

sources/core/Xenko.Core.Design/TypeConverters/TypeConverterHelper.cs

@@ -20,12 +20,13 @@ public static bool CanConvert([NotNull] Type sourceType, [NotNull] Type destinat
             if (sourceType == null) throw new ArgumentNullException(nameof(sourceType));
             if (destinationType == null) throw new ArgumentNullException(nameof(destinationType));
 
+            var context = new DestinationTypeDescriptorContext(destinationType);
             // already same type or inherited (also works with interface), or
             // implements IConvertible, or
             // can convert from source type to target type
             return destinationType.IsAssignableFrom(sourceType) ||
                    (typeof(IConvertible).IsAssignableFrom(sourceType) && Type.GetTypeCode(destinationType) != TypeCode.Object) ||
-                   TypeDescriptor.GetConverter(sourceType).CanConvertTo(destinationType) || TypeDescriptor.GetConverter(destinationType).CanConvertFrom(sourceType);
+                   TypeDescriptor.GetConverter(sourceType).CanConvertTo(destinationType) || TypeDescriptor.GetConverter(destinationType).CanConvertFrom(context, sourceType);
         }
 
         /// <summary>
@@ -69,10 +70,11 @@ public static bool TryConvert(object source, [NotNull] Type destinationType, out
                         return true;
                     }
                     // Try to convert using the target type converter
+                    var context = new DestinationTypeDescriptorContext(destinationType);
                     converter = TypeDescriptor.GetConverter(destinationType);
-                    if (converter.CanConvertFrom(sourceType))
+                    if (converter.CanConvertFrom(context, sourceType))
                     {
-                        target = converter.ConvertFrom(source);
+                        target = converter.ConvertFrom(context, System.Globalization.CultureInfo.CurrentCulture, source);
                         return true;
                     }
                 }
@@ -92,5 +94,43 @@ public static bool TryConvert(object source, [NotNull] Type destinationType, out
             target = null;
             return false;
         }
+
+        public static Type GetDestinationType(ITypeDescriptorContext context)
+        {
+            if (context is DestinationTypeDescriptorContext c) return c.DestinationType;
+
+            return null;
+        }
+
+        private class DestinationTypeDescriptorContext : ITypeDescriptorContext
+        {
+            public DestinationTypeDescriptorContext(Type destinationType)
+            {
+                DestinationType = destinationType;
+            }
+
+            public Type DestinationType { get; }
+
+            public IContainer Container => null;
+
+            public object Instance => null;
+
+            public PropertyDescriptor PropertyDescriptor => null;
+
+            public object GetService(Type serviceType)
+            {
+                return null;
+            }
+
+            public void OnComponentChanged()
+            {
+
+            }
+
+            public bool OnComponentChanging()
+            {
+                return true;
+            }
+        }
     }
 }

sources/core/Xenko.Core.Design/TypeConverters/UrlReferenceConverter.cs

@@ -0,0 +1,39 @@
+// Copyright (c) Xenko contributors (https://xenko.com) and Silicon Studio Corp. (https://www.siliconstudio.co.jp)
+// Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
+
+using System;
+using System.ComponentModel;
+using System.Globalization;
+using Xenko.Core.Serialization;
+
+namespace Xenko.Core.TypeConverters
+{
+    /// <summary>
+    /// Defines a type converter for <see cref="UrlReference"/>.
+    /// </summary>
+    public class UrlReferenceConverter : BaseConverter
+    {
+
+        public UrlReferenceConverter()
+        {
+
+            //var type = typeof(Xenko.Core.Serialization.UrlReference);
+            //Properties = new PropertyDescriptorCollection(new System.ComponentModel.PropertyDescriptor[]
+            //{
+            //    new Reflection.PropertyDescriptor(type.GetProperty(nameof(Xenko.Core.Serialization.UrlReference.Url))),
+            //});
+        }
+
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+        {
+            return UrlReferenceHelper.IsUrlReferenceType(TypeConverterHelper.GetDestinationType(context));
+        }
+
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        {
+            var attachedReference = AttachedReferenceManager.GetAttachedReference(value);
+            var destinationType = TypeConverterHelper.GetDestinationType(context);
+            return UrlReferenceHelper.CreateReference(destinationType, attachedReference.Id, attachedReference.Url);
+        }
+    }
+}

sources/core/Xenko.Core.Serialization/Serialization/AttachedReferenceManager.cs

@@ -85,10 +85,8 @@ public static T CreateProxyObject<T>(IReference reference) where T : class, new(
         public static T CreateProxyObject<T>(AssetId id, string location) where T : class, new()
         {
             var result = new T();
-            var attachedReference = GetOrCreateAttachedReference(result);
-            attachedReference.Id = id;
-            attachedReference.Url = location;
-            attachedReference.IsProxy = true;
+            InitializeProxyObject(result, id, location);
+
             return result;
         }
 
@@ -121,11 +119,15 @@ public static object CreateProxyObject(Type type, AssetId id, string location)
                 }
             }
             var result = emptyCtor.Invoke(EmptyObjectArray);
-            var attachedReference = GetOrCreateAttachedReference(result);
+            InitializeProxyObject(result, id, location);
+            return result;
+        }
+        private static void InitializeProxyObject(object proxyObject, AssetId id, string location)
+        {
+            var attachedReference = GetOrCreateAttachedReference(proxyObject);
             attachedReference.Id = id;
             attachedReference.Url = location;
             attachedReference.IsProxy = true;
-            return result;
         }
     }
 }

sources/core/Xenko.Core.Serialization/Serialization/Serializers/UrlReferenceDataSerializer.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xenko.Core.Annotations;
+using Xenko.Core.Assets;
+
+namespace Xenko.Core.Serialization.Serializers
+{
+    /// <summary>
+    /// Serializer base class for for <see cref="UrlReference"/>.
+    /// </summary>
+    public abstract class UrlReferenceDataSerializerBase<T> : DataSerializer<T>
+        where T: UrlReference
+    {
+        /// <inheritdoc/>
+        public override void Serialize(ref T urlReference, ArchiveMode mode, [NotNull] SerializationStream stream)
+        {
+            if (mode == ArchiveMode.Serialize)
+            {
+                var attachedReference = AttachedReferenceManager.GetAttachedReference(urlReference);
+                if(attachedReference == null)
+                {
+                    throw new InvalidOperationException("UrlReference does not have an AttachedReference.");
+                }
+
+                stream.Write(attachedReference.Id);
+                stream.Write(attachedReference.Url);
+            }
+            else
+            {
+                var id = stream.Read<AssetId>();
+                var url = stream.ReadString();
+
+                urlReference = (T)UrlReferenceHelper.CreateReference(typeof(T), id, url);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Serializer for <see cref="UrlReference"/>.
+    /// </summary>
+    public sealed class UrlReferenceDataSerializer : UrlReferenceDataSerializerBase<UrlReference>
+    {
+
+    }
+
+    /// <summary>
+    /// Serializer for <see cref="UrlReference{T}"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of asset.</typeparam>
+    public sealed class UrlReferenceDataSerializer<T> : UrlReferenceDataSerializerBase<UrlReference<T>>
+        where T : class
+    {
+
+    }
+}

sources/core/Xenko.Core.Serialization/Serialization/UrlReference.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+using System.Text;
+using Xenko.Core.Annotations;
+using Xenko.Core.Assets;
+using Xenko.Core.Serialization.Contents;
+using Xenko.Core.Serialization.Serializers;
+
+namespace Xenko.Core.Serialization
+{
+    /// <summary>
+    /// Represents a Url to an asset.
+    /// </summary>
+    [DataContract("urlref", Inherited = true)]
+    [DataStyle(DataStyle.Compact)]
+    [ReferenceSerializer]
+    [DataSerializer(typeof(UrlReferenceDataSerializer))]
+    public class UrlReference
+    {
+        private string url;
+
+        public UrlReference()
+        {
+
+        }
+
+        /// <summary>
+        /// Create a new <see cref="UrlReference"/> instance.
+        /// </summary>
+        /// <param name="url"></param>
+        public UrlReference(string url)
+        {
+            if (string.IsNullOrWhiteSpace(url))
+            {
+                throw new ArgumentException($"{nameof(url)} cannot be null or empty.", nameof(url));
+            }
+
+            Url = url;
+        }
+
+        [DataMember(10)]
+        public string Url
+        {
+            get => url; 
+            internal set
+            {
+                if (string.IsNullOrEmpty(value))
+                {
+                    throw new ArgumentNullException(nameof(value));
+                }
+                url = value;
+            }
+        }
+
+        [DataMemberIgnore]
+        public bool IsEmpty => string.IsNullOrEmpty(url);
+
+        /// <inheritdoc/>
+        public override string ToString()
+        {
+            return $"{Url}";
+        }
+
+
+    }
+
+    /// <summary>
+    /// Represents a Url to an asset of type <see cref="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The type off asset.</typeparam>
+    [DataStyle(DataStyle.Compact)]
+    [DataSerializer(typeof(UrlReferenceDataSerializer<>), Mode = DataSerializerGenericMode.GenericArguments)]
+    public sealed class UrlReference<T> : UrlReference
+        where T : class
+    {
+        public UrlReference() : base()
+        {
+
+        }
+
+        /// <summary>
+        /// Create a new <see cref="UrlReference{T}"/> instance.
+        /// </summary>
+        /// <param name="url"></param>
+        public UrlReference(string url) : base(url)
+        {
+        }
+
+    }
+
+
+}