コード例 #1
0
        private static List <ResourcePak> BuildPaks(string root_path, ContentManifest manifest)
        {
            var paks = new List <ResourcePak>();

            foreach (var group in manifest.Content)
            {
                var pak = new ResourcePak(group.Key);

                foreach (var image in group.Value.Images)
                {
                    var path = new Uri(Path.Combine(root_path, group.Key, image.Value.Path)).LocalPath;

                    var pixmap_data = ContentLoader.LoadPixmapData(path);

                    pak.Resources.Add(image.Value.Id, pixmap_data);
                }
                foreach (var font in group.Value.Fonts)
                {
                    var descr_path = new Uri(Path.Combine(root_path, group.Key, font.Value.Path)).LocalPath;
                    var image_path = new Uri(Path.Combine(root_path, group.Key, font.Value.ImagePath)).LocalPath;

                    var font_data = ContentLoader.LoadFontData(descr_path, image_path);

                    pak.Resources.Add(font.Value.Id, font_data);
                }
                foreach (var shader in group.Value.Shaders)
                {
                    var vs_path = new Uri(Path.Combine(root_path, group.Key, shader.Value.VertexSrcPath)).LocalPath;
                    var fs_path = new Uri(Path.Combine(root_path, group.Key, shader.Value.FragmentSrcPath)).LocalPath;

                    var shader_data = ContentLoader.LoadShaderProgramData(vs_path, fs_path);

                    pak.Resources.Add(shader.Value.Id, shader_data);
                }
                foreach (var sfx in group.Value.Effects)
                {
                    //TODO:
                }
                foreach (var song in group.Value.Songs)
                {
                    //TODO:
                }
                foreach (var txt in group.Value.TextFiles)
                {
                    var txt_path = new Uri(Path.Combine(root_path, group.Key, txt.Value.Path)).LocalPath;

                    var txt_data = ContentLoader.LoadTextFileData(txt_path);

                    pak.Resources.Add(txt.Value.Id, txt_data);
                }

                paks.Add(pak);
            }

            return(paks);
        }
コード例 #2
0
        //private static void BuildAppConfigFile(string root_path, AppProject project)
        //{
        //    GameProperties props = new GameProperties()
        //    {
        //        Title = project.Title,
        //        FrameRate = project.FrameRate,
        //        CanvasWidth = project.CanvasWidth,
        //        CanvasHeight = project.CanvasHeight,
        //        Fullscreen = project.StartFullscreen,
        //        PreloadResourcePaks = project.PreloadPaks
        //    };

        //    File.WriteAllBytes(Path.Combine(root_path, "Config.json"),
        //        JsonSerializer.PrettyPrintByteArray(JsonSerializer.Serialize(props)));

        //}

        private static List <ResourcePak> BuildProjectResources(GameAssetsManifest manifest)
        {
            var resource_groups = manifest.Resources;

            var results = new List <ResourcePak>();

            foreach (var(groupKey, group) in resource_groups)
            {
                var pak = new ResourcePak(groupKey);

                Console.WriteLine($"Creating resource Pak: {pak.Name}");

                if (group.Images != null)
                {
                    foreach (var image_info in group.Images)
                    {
                        var pixmap_data = ImageBuilder.Build(image_info.Id, image_info.Path);

                        pak.Images.Add(image_info.Id, pixmap_data);

                        pak.TotalResourcesCount++;

                        Console.WriteLine($"Added Image: {pixmap_data.Id}");
                    }
                }

                if (group.Shaders != null)
                {
                    foreach (var shader_info in group.Shaders)
                    {
                        var shader_data = ShaderBuilder.Build(shader_info.Id, shader_info.VsPath, shader_info.FsPath);

                        pak.Shaders.Add(shader_info.Id, shader_data);

                        pak.TotalResourcesCount++;

                        Console.WriteLine($"Added Shader: {shader_data.Id}");
                    }
                }

                if (group.Fonts != null)
                {
                    foreach (var font_info in group.Fonts)
                    {
                        var build_params = new FontBuildParams()
                        {
                            Id          = font_info.Id,
                            LineSpacing = font_info.LineSpacing,
                            Spacing     = font_info.Spacing,
                            DefaultChar = font_info.DefaultChar,
                            Faces       = font_info.Faces.Select(f => new FontFace()
                            {
                                CharRanges = f.CharRanges.Select(CharRange.GetFromKey).ToList(),
                                Path       = f.Path,
                                Size       = f.Size,
                            }).ToList()
                        };

                        var font_data = FontBuilder.Build(build_params);

                        pak.Fonts.Add(font_info.Id, font_data);

                        pak.TotalResourcesCount++;

                        Console.WriteLine($"Added Font: {font_data.Id}");
                    }
                }

                if (group.Atlases != null)
                {
                    foreach (var atlas_info in group.Atlases)
                    {
                        var atlas_data = AtlasBuilder.Build(atlas_info.Id, atlas_info.Path, atlas_info.Regions);

                        pak.Atlases.Add(atlas_data.Id, atlas_data);

                        pak.TotalResourcesCount++;

                        Console.WriteLine($"Added Atlas: {atlas_data.Id}");
                    }
                }

                if (group.TextFiles != null)
                {
                    foreach (var text_file_info in group.TextFiles)
                    {
                        var text_file_data = TextBuilder.Build(text_file_info.Id, text_file_info.Path);
                        pak.TextFiles.Add(text_file_info.Id, text_file_data);

                        pak.TotalResourcesCount++;

                        Console.WriteLine($"Added TextFile: {text_file_data.Id}");
                    }
                }

                results.Add(pak);
                Console.WriteLine($"Built PAK with {pak.TotalResourcesCount} resources.");
            }

            return(results);
        }
コード例 #3
0
        //private static void BuildAppConfigFile(string root_path, AppProject project)
        //{
        //    GameProperties props = new GameProperties()
        //    {
        //        Title = project.Title,
        //        FrameRate = project.FrameRate,
        //        CanvasWidth = project.CanvasWidth,
        //        CanvasHeight = project.CanvasHeight,
        //        Fullscreen = project.StartFullscreen,
        //        PreloadResourcePaks = project.PreloadPaks
        //    };

        //    File.WriteAllBytes(Path.Combine(root_path, "Config.json"),
        //        JsonSerializer.PrettyPrintByteArray(JsonSerializer.Serialize(props)));

        //}

        private static List <ResourcePak> BuildProjectResources(GameAssetsManifest manifest)
        {
            var resource_groups = manifest.Resources;

            var results = new List <ResourcePak>();

            foreach (var resource_group in resource_groups)
            {
                var pak = new ResourcePak(resource_group.Key);

                Console.WriteLine($"Creating resource Pak: {pak.Name}");

                if (resource_group.Value.Images != null)
                {
                    foreach (var image_info in resource_group.Value.Images)
                    {
                        var pixmap_data = ImageBuilder.Build(image_info.Id, image_info.Path);

                        pak.Images.Add(image_info.Id, pixmap_data);

                        pak.TotalResourcesCount++;

                        Console.WriteLine($"Added Image: {pixmap_data.Id}");
                    }
                }

                if (resource_group.Value.Shaders != null)
                {
                    foreach (var shader_info in resource_group.Value.Shaders)
                    {
                        var shader_data = ShaderBuilder.Build(shader_info.Id, shader_info.VsPath, shader_info.FsPath);

                        pak.Shaders.Add(shader_info.Id, shader_data);

                        pak.TotalResourcesCount++;

                        Console.WriteLine($"Added Shader: {shader_data.Id}");
                    }
                }

                if (resource_group.Value.Fonts != null)
                {
                    foreach (var font_info in resource_group.Value.Fonts)
                    {
                        var build_params = new FontBuildParams()
                        {
                            Id             = font_info.Id,
                            Path           = font_info.Path,
                            Size           = font_info.Size,
                            CharRangeLevel = font_info.CharRangeLevel,
                            PaddingLeft    = font_info.Padding != null ? font_info.Padding[0] : 0,
                            PaddingRight   = font_info.Padding != null ? font_info.Padding[1] : 0,
                            PaddingUp      = font_info.Padding != null ? font_info.Padding[2] : 0,
                            PaddingDown    = font_info.Padding != null ? font_info.Padding[3] : 0,
                            DropShadow     = font_info.DropShadow,
                            ShadowOffsetX  = font_info.ShadowOffsetX,
                            ShadowOffsetY  = font_info.ShadowOffsetY,
                            ShadowColor    = font_info.ShadowColor != null?Color.FromHex(font_info.ShadowColor) : Color.Black
                        };

                        var font_data = FontBuilder.Build(build_params);

                        pak.Fonts.Add(font_info.Id, font_data);

                        pak.TotalResourcesCount++;

                        Console.WriteLine($"Added Font: {font_data.Id}");
                    }
                }

                if (resource_group.Value.Atlases != null)
                {
                    foreach (var atlas_info in resource_group.Value.Atlases)
                    {
                        var atlas_data = AtlasBuilder.Build(atlas_info.Id, atlas_info.Path, atlas_info.Regions);

                        pak.Atlases.Add(atlas_data.Id, atlas_data);

                        pak.TotalResourcesCount++;

                        Console.WriteLine($"Added Atlas: {atlas_data.Id}");
                    }
                }

                if (resource_group.Value.TextFiles != null)
                {
                    foreach (var text_file_info in resource_group.Value.TextFiles)
                    {
                        var text_file_data = TextBuilder.Build(text_file_info.Id, text_file_info.Path);
                        pak.TextFiles.Add(text_file_info.Id, text_file_data);

                        pak.TotalResourcesCount++;

                        Console.WriteLine($"Added TextFile: {text_file_data.Id}");
                    }
                }

                results.Add(pak);
                Console.WriteLine($"Built PAK with {pak.TotalResourcesCount} resources.");
            }

            return(results);
        }
コード例 #4
0
        private static List <ResourcePak> BuildProjectResources(string root_path, GameProject project)
        {
            var resource_groups = project.Resources;

            string shader_vs_aux = null;
            string shader_fs_aux = null;

            var results = new List <ResourcePak>();

            foreach (var resource_group in resource_groups)
            {
                var pak = new ResourcePak(resource_group.Key);

                var files = resource_group
                            .Value
                            .Select(p => new ResourceFileInfo(
                                        file_name: Path.GetFileNameWithoutExtension(p),
                                        full_path: Path.Combine(root_path, "Content", p),
                                        extension: Path.GetExtension(p),
                                        type: GetResourceTypeByExt(Path.GetExtension(p))))
                            .OrderBy(f => f.FileName)
                            .GroupBy(f => f.FileName);


                foreach (var file_group in files)
                {
                    foreach (var res_file_info in file_group)
                    {
                        switch (res_file_info.Type)
                        {
                        case ResourceType.Image:

                            var pixmap_data = Loader.LoadPixmapData(res_file_info.FullPath);

                            pak.Images.Add(res_file_info.FileName, pixmap_data);

                            break;

                        case ResourceType.Font:

                            var font_descr_path = res_file_info.FullPath;
                            var font_image_path = Path.Combine(
                                Path.GetDirectoryName(res_file_info.FullPath),
                                res_file_info.FileName + ".png"
                                );

                            var font_data = Loader.LoadFontData(font_descr_path, font_image_path);

                            pak.Fonts.Add(res_file_info.FileName, font_data);

                            break;

                        case ResourceType.Shader:

                            switch (res_file_info.Extension)
                            {
                            case ".vs":
                                shader_vs_aux = res_file_info.FullPath;
                                break;

                            case ".fs":
                                shader_fs_aux = res_file_info.FullPath;
                                break;
                            }

                            if (shader_vs_aux != null && shader_fs_aux != null)
                            {
                                var shader_data = Loader.LoadShaderProgramData(shader_vs_aux, shader_fs_aux);

                                pak.Shaders.Add(res_file_info.FileName, shader_data);

                                shader_vs_aux = null;
                                shader_fs_aux = null;
                            }

                            break;

                        case ResourceType.Sfx:

                            var sfx_data = Loader.LoadSfxData(res_file_info.FullPath);

                            pak.Sfx.Add(res_file_info.FileName, sfx_data);

                            break;

                        case ResourceType.Song:

                            var song_data = Loader.LoadSongData(res_file_info.FullPath);

                            pak.Songs.Add(res_file_info.FileName, song_data);

                            break;

                        case ResourceType.TextFile:

                            var text_file_data = Loader.LoadTextFileData(res_file_info.FullPath);

                            pak.TextFiles.Add(res_file_info.FileName, text_file_data);

                            break;
                        }
                    }
                }

                results.Add(pak);
            }

            return(results);
        }