Content Manager

[blau]

Buenas, estoy haciendo un content manager para un editor que me abstraiga de la gestion del contenido:

Esta ha sido mi primera aproximacion:

public static class CustomContentManager
    {
        static ContentManager _content;
        static GraphicsDevice _device;

        public static void Initialize( ContentManager Content )
        {
            _content = Content;
        }

        public static void Initialize( GraphicsDevice Device )
        {
            _device = Device;
        }
     
        public static T Load<T>( string assetname )
        {
            if ( _content != null )
            {
                return _content.Load<T>( assetname );
            }

            using ( Stream stream = File.OpenRead( assetname ) )
            {
                if ( typeof( T ) == typeof(Texture2D) )
                {
                    return Texture2D.FromStream( _device, stream );
                }

                if ( typeof( T ) == typeof( SoundEffect ) )
                {
                    return SoundEffect.FromStream( stream );
                }
            }
            return default(T);
        }
    }

El problema es que al usar genericos da error al convertir. Ahora mismo ando algo espeso y no caigo en como hacerlo de forma decente.

El tema es que no quiero llamar a los importers ni processors dinamicamente porque la idea es que no se necesite tener visual studio con el framework completo para editar las texturas, niveles,.. etc...  pero quiero que se pueda probar todo ingame...

Voy a echarle un ratillo a san google, pero si alguien tiene una solucion o una vision alternativa me vendria bien...

[[EX3]]

Ostras, este tema me interesa (ando liado con algo "similar" en mi motor). Si avanzas ve mostrando progresos :)

Salu2...

[Vicente]

Se trata de enganar al compilador para que te deje hacer un casting a T de tus objetos (que es lo que hace el ContentManager por debajo).

Este es el codigo del ContentMananger.Load de XNA:

Código [Seleccionar] Expand


public virtual T Load<T>(string assetName)
{
    object obj2;
    Logger.BeginLogEvent(LoggingEvent.LoadContent, "XNA: Begin Loading Content: " + assetName);
    if (this.loadedAssets == null)
    {
        throw new ObjectDisposedException(this.ToString());
    }
    if (string.IsNullOrEmpty(assetName))
    {
        throw new ArgumentNullException("assetName");
    }
    assetName = TitleContainer.GetCleanPath(assetName);
    if (this.loadedAssets.TryGetValue(assetName, out obj2))
    {
        if (!(obj2 is T))
        {
            throw new ContentLoadException(string.Format(CultureInfo.CurrentCulture, FrameworkResources.BadXnbWrongType, new object[] { assetName, obj2.GetType(), typeof(T) }));
        }
        return (T) obj2;
    }
    T local = this.ReadAsset<T>(assetName, null);
    this.loadedAssets.Add(assetName, local);
    Logger.EndLogEvent(LoggingEvent.LoadContent, "XNA: Done Loading Content: " + assetName);
    return local;
}


Asi que simplemente eso, asignas tus objetos a un object y luego ese object lo casteas a T :) Ademas el Content tiene una cache para evitar cargar la misma cosa dos veces.

[blau]

Gracias... ahora me viene a la cabeza que ya lo había hecho así antes otras veces...