VGearsBackgroundFile.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 The V-Gears Team
 *
 * This file is part of V-Gears
 *
 * V-Gears is free software: you can redistribute it and/or modify it under
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, version 3.0 (GPLv3) of the License.
 *
 * V-Gears is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
 
#pragma once
 
#include <array>
#include <OgreResource.h>
#include <OgreImage.h>
#include <Ogre.h>
#include "common/TypeDefine.h"
#include "data/VGearsPaletteFile.h"
 
namespace VGears{
 
    // TODO inherit from VGears Resource.
 
    class BackgroundFile : public Ogre::Resource{
 
        public:
 
            BackgroundFile(
              Ogre::ResourceManager *creator, const String &name,
              Ogre::ResourceHandle handle, const String &group,
              bool is_manual = false, Ogre::ManualResourceLoader *loader = NULL
            );
 
            virtual ~BackgroundFile();
 
            static const String RESOURCE_TYPE;
 
            enum {
 
                PAGE_DATA_WIDTH = 256,
 
                PAGE_DATA_HEIGHT = PAGE_DATA_WIDTH,
 
                PAGE_DATA_SIZE = PAGE_DATA_WIDTH * PAGE_DATA_HEIGHT,
 
                SPRITE_WIDTH = 16,
 
                SPRITE_HEIGHT = SPRITE_WIDTH,
 
                SPRITE_PIXEL_COUNT = SPRITE_WIDTH * SPRITE_HEIGHT,
 
                LAYER_COUNT = 4,
 
                PALETTE_ENTRY_COUNT = 20,
 
                PAGE_COUNT = 42
            };
 
            struct SpriteData{
 
                Pixel dst;
 
                uint16 unknown_04[2];
 
                Pixel src;
 
                Pixel src2;
 
                uint16 width;
 
                uint16 height;
 
                uint16 palette_page;
 
                uint16 depth;
 
                uint8 animation_id;
 
                uint8 animation_frame;
 
                bool has_blending[2];
 
                uint16 blending;
 
                uint16 data_page;
 
                uint16 data_page2;
 
                uint16 colour_depth;
 
                Ogre::Vector3 src_big;
            };
 
            typedef std::vector<SpriteData> SpriteList;
 
            typedef std::vector<SpriteData*> SpritePtrList;
 
            void SortSprites();
 
            struct Layer{
 
                bool enabled;
 
                uint16 width;
 
                uint16 height;
                uint16 unknown_06;
 
                uint16 unknown_08[3];
 
                uint16 unknown_0E[4];
 
                SpriteList sprites;
            };
 
            typedef PaletteFile::Color Color;
 
            typedef std::vector<uint8> Buffer;
 
            typedef std::vector<Color> Colors;
 
            struct Page{
 
                bool enabled;
 
                uint16 unknown_02;
 
                uint16 value_size;
 
                // //uint8 if value_size == 1, uint16 if value_size == 2
                // uint8 data[PAGE_DATA_WIDTH][PAGE_DATA_HEIGHT];
 
                Buffer data;
 
                Colors colors;
            };
 
            std::array<Layer, LAYER_COUNT>& GetLayers(void) {return layers_;}
 
            std::array<uint8, PALETTE_ENTRY_COUNT>& GetPalette(void) {
                return palette_;
            }
 
            std::array<Page, PAGE_COUNT>& GetPages(void){return pages_;}
 
            Ogre::Image* CreateImage(const PaletteFilePtr &palette);
 
            void AddAllSprites(SpritePtrList& sprites) ;
 
        protected:
 
            virtual void loadImpl() override final;
 
            virtual void unloadImpl() override final;
 
            virtual size_t CalculateSize() const;
 
            virtual size_t CalculateSize(const Layer &layer) const;
 
            virtual size_t CalculateSize(const Page &page) const;
 
        private:
 
            std::array<Layer, LAYER_COUNT> layers_;
 
            std::array<uint8, PALETTE_ENTRY_COUNT> palette_;
 
            std::array<Page, PAGE_COUNT> pages_;
 
            static bool SpriteSorter(SpriteData sprite1, SpriteData sprite2);
    };
 
    typedef Ogre::SharedPtr<BackgroundFile> BackgroundFilePtr;
}