spriteloader.hpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD 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. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef SPRITELOADER_HPP
#define SPRITELOADER_HPP
 
#include "../core/alloc_type.hpp"
#include "../core/enum_type.hpp"
#include "../gfx_type.h"
#include "sprite_file_type.hpp"
 
struct Sprite;
 
enum SpriteColourComponent {
  SCC_RGB   = 1 << 0, 
  SCC_ALPHA = 1 << 1, 
  SCC_PAL   = 1 << 2, 
  SCC_MASK  = SCC_RGB | SCC_ALPHA | SCC_PAL, 
};
DECLARE_ENUM_AS_BIT_SET(SpriteColourComponent)
 
 
class SpriteLoader {
public:
  struct CommonPixel {
    uint8_t r;  
    uint8_t g;  
    uint8_t b;  
    uint8_t a;  
    uint8_t m;  
  };
 
  struct Sprite {
    uint16_t height;                   
    uint16_t width;                    
    int16_t x_offs;                    
    int16_t y_offs;                    
    SpriteType type;                 
    SpriteColourComponent colours;   
    SpriteLoader::CommonPixel *data; 
 
    void AllocateData(ZoomLevel zoom, size_t size) { this->data = Sprite::buffer[zoom].ZeroAllocate(size); }
  private:
    static ReusableBuffer<SpriteLoader::CommonPixel> buffer[ZOOM_LVL_END];
  };
 
  using SpriteCollection = std::array<Sprite, ZOOM_LVL_END>;
 
  virtual uint8_t LoadSprite(SpriteLoader::SpriteCollection &sprite, SpriteFile &file, size_t file_pos, SpriteType sprite_type, bool load_32bpp, uint8_t control_flags) = 0;
 
  virtual ~SpriteLoader() = default;
};
 
class SpriteAllocator {
public:
  virtual ~SpriteAllocator() = default;
 
  template <typename T>
  T *Allocate(size_t size)
  {
    return static_cast<T *>(this->AllocatePtr(size));
  }
 
protected:
  virtual void *AllocatePtr(size_t size) = 0;
};
 
class SpriteEncoder {
public:
 
  virtual ~SpriteEncoder() = default;
 
  virtual bool Is32BppSupported() = 0;
 
  virtual Sprite *Encode(const SpriteLoader::SpriteCollection &sprite, SpriteAllocator &allocator) = 0;
 
  virtual uint GetSpriteAlignment()
  {
    return 0;
  }
};
#endif /* SPRITELOADER_HPP */