public StaticSpriteFont Load(AssetLoaderContext context, string assetName)
        {
            var fontData = context.Load <string>(assetName);

            return(StaticSpriteFont.FromBMFont(fontData,
                                               name => TextureGetter(context, name)));
        }
Example #2
0
 public SoundEffect Load(AssetLoaderContext context, string assetName)
 {
     using (var stream = context.Open(assetName))
     {
         return(SoundEffect.FromStream(stream));
     }
 }
Example #3
0
 public Texture2D Load(AssetLoaderContext context, string assetName)
 {
     using (var stream = context.Open(assetName))
     {
         return(Texture2DExtensions.FromStream(stream, true));
     }
 }
        public TextureRegionAtlas Load(AssetLoaderContext context, string assetName)
        {
            var data = context.Load <string>(assetName);

#if MONOGAME || FNA || STRIDE
            return(TextureRegionAtlas.Load(data, name => context.Load <Texture2D>(name)));
#else
            return(TextureRegionAtlas.Load(data, name => context.Load <Texture2DWrapper>(name).Texture));
#endif
        }
Example #5
0
        public SpriteFontBase Load(AssetLoaderContext context, string assetName)
        {
            if (assetName.Contains(".fnt"))
            {
                return(context.Load <StaticSpriteFont>(assetName));
            }
            else if (assetName.Contains(".ttf"))
            {
                return(context.Load <DynamicSpriteFont>(assetName));
            }

            throw new Exception(string.Format("Can't load font '{0}'", assetName));
        }
Example #6
0
        public FontSystem Load(AssetLoaderContext context, string assetName)
        {
            var parts = assetName.Split(':');

            var fontType = FontType.Regular;
            var amount   = 1;

            if (parts.Length > 1)
            {
                fontType = (FontType)Enum.Parse(typeof(FontType), parts[1]);

                if (fontType != FontType.Regular)
                {
                    if (parts.Length < 3)
                    {
                        throw new Exception("Missing amount");
                    }

                    amount = int.Parse(parts[2]);
                }
            }

            FontSystem fontSystem = null;

            switch (fontType)
            {
            case FontType.Regular:
                fontSystem = FontSystemFactory.Create(context.GraphicsDevice, 1024, 1024);
                break;

            case FontType.Blurry:
                fontSystem = FontSystemFactory.CreateBlurry(context.GraphicsDevice, 1024, 1024, amount);
                break;

            case FontType.Stroked:
                fontSystem = FontSystemFactory.CreateStroked(context.GraphicsDevice, 1024, 1024, amount);
                break;
            }

            var data = context.Load <byte[]>(parts[0]);

            fontSystem.AddFont(data);

            return(fontSystem);
        }
Example #7
0
        public Texture2DWrapper Load(AssetLoaderContext context, string assetName)
#endif
        {
            ImageResult result = null;

            using (var stream = context.Open(assetName))
            {
                if (stream.CanSeek)
                {
                    result = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
                }
                else
                {
                    // If stream doesnt provide seek functionaly, use MemoryStream instead
                    using (var ms = new MemoryStream())
                    {
                        stream.CopyTo(ms);
                        ms.Seek(0, SeekOrigin.Begin);
                        result = ImageResult.FromStream(ms, ColorComponents.RedGreenBlueAlpha);
                    }
                }
            }

            // Premultiply Alpha
            var b = result.Data;

            for (var i = 0; i < result.Data.Length; i += 4)
            {
                var a = b[i + 3];
                b[i]     = ApplyAlpha(b[i], a);
                b[i + 1] = ApplyAlpha(b[i + 1], a);
                b[i + 2] = ApplyAlpha(b[i + 2], a);
            }

#if MONOGAME || FNA || STRIDE
            var texture = CrossEngineStuff.CreateTexture(MyraEnvironment.GraphicsDevice, result.Width, result.Height);
            CrossEngineStuff.SetTextureData(texture, new Rectangle(0, 0, result.Width, result.Height), result.Data);
            return(texture);
#else
            var texture = MyraEnvironment.Platform.CreateTexture(result.Width, result.Height);
            MyraEnvironment.Platform.SetTextureData(texture, new Rectangle(0, 0, result.Width, result.Height), result.Data);
            return(new Texture2DWrapper(result.Width, result.Height, texture));
#endif
        }
Example #8
0
        public TextureRegion Load(AssetLoaderContext context, string assetName)
        {
            if (assetName.Contains(":"))
            {
                // First part is texture region atlas name
                // Second part is texture region name
                var parts = assetName.Split(':');
                var textureRegionAtlas = context.Load <TextureRegionAtlas>(parts[0]);
                return(textureRegionAtlas[parts[1]]);
            }

            // Ordinary texture
#if MONOGAME || FNA || STRIDE
            var texture = context.Load <Texture2D>(assetName);
            return(new TextureRegion(texture, new Rectangle(0, 0, texture.Width, texture.Height)));
#else
            var texture = context.Load <Texture2DWrapper>(assetName);
            return(new TextureRegion(texture.Texture, new Rectangle(0, 0, texture.Width, texture.Height)));
#endif
        }
Example #9
0
        public DynamicSpriteFont Load(AssetLoaderContext context, string assetName)
        {
            var parts = assetName.Split(':');

            if (parts.Length < 2)
            {
                throw new Exception("Missing font size");
            }

            var fontSize = int.Parse(parts[parts.Length - 1]);

            var partsWithoutSize = new List <string>();

            for (var i = 0; i < parts.Length - 1; ++i)
            {
                partsWithoutSize.Add(parts[i]);
            }

            var fontSystem = context.Load <FontSystem>(string.Join(":", partsWithoutSize));

            return(fontSystem.GetFont(fontSize));
        }
Example #10
0
        public FontSystem Load(AssetLoaderContext context, string assetName)
        {
            var parts = assetName.Split(':');

            var fontType = FontType.Regular;
            var amount   = 1;

            if (parts.Length > 1)
            {
                fontType = (FontType)Enum.Parse(typeof(FontType), parts[1]);

                if (fontType != FontType.Regular)
                {
                    if (parts.Length < 3)
                    {
                        throw new Exception("Missing amount");
                    }

                    amount = int.Parse(parts[2]);
                }
            }

            FontSystem fontSystem = null;

#if MONOGAME || FNA || STRIDE
            switch (fontType)
            {
            case FontType.Regular:
                fontSystem = FontSystemFactory.Create(MyraEnvironment.GraphicsDevice, MyraEnvironment.FontAtlasSize, MyraEnvironment.FontAtlasSize);
                break;

            case FontType.Blurry:
                fontSystem = FontSystemFactory.CreateBlurry(MyraEnvironment.GraphicsDevice, amount, MyraEnvironment.FontAtlasSize, MyraEnvironment.FontAtlasSize);
                break;

            case FontType.Stroked:
                fontSystem = FontSystemFactory.CreateStroked(MyraEnvironment.GraphicsDevice, amount, MyraEnvironment.FontAtlasSize, MyraEnvironment.FontAtlasSize);
                break;
            }
#else
            switch (fontType)
            {
            case FontType.Regular:
                fontSystem = FontSystemFactory.Create(MyraEnvironment.FontAtlasSize, MyraEnvironment.FontAtlasSize);
                break;

            case FontType.Blurry:
                fontSystem = FontSystemFactory.CreateBlurry(amount, MyraEnvironment.FontAtlasSize, MyraEnvironment.FontAtlasSize);
                break;

            case FontType.Stroked:
                fontSystem = FontSystemFactory.CreateStroked(amount, MyraEnvironment.FontAtlasSize, MyraEnvironment.FontAtlasSize);
                break;
            }
#endif

            var data = context.Load <byte[]>(parts[0]);
            fontSystem.AddFont(data);

            return(fontSystem);
        }
Example #11
0
        public T Load <T>(string assetName)
        {
            var type = typeof(T);

            assetName = assetName.Replace('\\', SeparatorSymbol);

            Dictionary <string, object> cache;

            if (_cache.TryGetValue(type, out cache))
            {
                object cached;
                if (cache.TryGetValue(assetName, out cached))
                {
                    // Found in cache
                    return((T)cached);
                }
            }

            LoaderInfo loaderBase;

            if (!_loaders.TryGetValue(type, out loaderBase))
            {
                // Try determine it using AssetLoader attribute
                var attr = type.FindAttribute <AssetLoaderAttribute>();
                if (attr == null)
                {
                    throw new Exception(string.Format("Unable to resolve AssetLoader for type {0}", type.Name));
                }

                // Create loader
                loaderBase = new LoaderInfo(Activator.CreateInstance(attr.AssetLoaderType),
                                            attr.StoreInCache);

                // Save in the _loaders
                _loaders[type] = loaderBase;
            }

            var loader = (IAssetLoader <T>)loaderBase.Loader;

            var baseFolder    = string.Empty;
            var assetFileName = assetName;

            var separatorIndex = assetName.LastIndexOf(SeparatorSymbol);

            if (separatorIndex != -1)
            {
                baseFolder    = assetName.Substring(0, separatorIndex);
                assetFileName = assetName.Substring(separatorIndex + 1);
            }

            var context = new AssetLoaderContext(this, baseFolder);
            var result  = loader.Load(context, assetFileName);

            if (loaderBase.StoreInCache)
            {
                // Store in cache
                if (cache == null)
                {
                    cache        = new Dictionary <string, object>();
                    _cache[type] = cache;
                }

                cache[assetName] = result;
            }

            return(result);
        }
Example #12
0
        private TextureWithOffset TextureGetter(AssetLoaderContext context, string name)
        {
            var textureRegion = context.Load <TextureRegion>(name);

            return(new TextureWithOffset(textureRegion.Texture, textureRegion.Bounds.Location));
        }
Example #13
0
 public Texture2D Load(AssetLoaderContext context, string assetName)