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 class SpriteComponent : uint8_t {
  RGB     = 0, 
  Alpha   = 1, 
  Palette = 2, 
  End,
};
enum class SpriteComponent : uint8_t {…};
using SpriteComponents = EnumBitSet<SpriteComponent, uint8_t, SpriteComponent::End>;
 
template <class T>
class SpriteCollMap {
  std::array<T, to_underlying(ZoomLevel::End)> data{};
public:
  inline constexpr T &operator[](const ZoomLevel &zoom) { return this->data[to_underlying(zoom)]; }
  inline constexpr const T &operator[](const ZoomLevel &zoom) const { return this->data[to_underlying(zoom)]; }
 
  T &Root() { return this->data[to_underlying(ZoomLevel::Min)]; }
  const T &Root() const { return this->data[to_underlying(ZoomLevel::Min)]; }
};
class SpriteCollMap {…};
 
class SpriteLoader {
public:
  struct CommonPixel {
    uint8_t r = 0;  
    uint8_t g = 0;  
    uint8_t b = 0;  
    uint8_t a = 0;  
    uint8_t m = 0;  
  };
  struct CommonPixel {…};
 
  struct Sprite {
    uint16_t height;                   
    uint16_t width;                    
    int16_t x_offs;                    
    int16_t y_offs;                    
    SpriteComponents colours;   
    SpriteLoader::CommonPixel *data; 
 
    void AllocateData(ZoomLevel zoom, size_t size) { this->data = Sprite::buffer[zoom].ZeroAllocate(size); }
  private:
    static SpriteCollMap<ReusableBuffer<SpriteLoader::CommonPixel>> buffer;
  };
  struct Sprite {…};
 
  using SpriteCollection = SpriteCollMap<Sprite>;
 
  virtual ZoomLevels LoadSprite(SpriteLoader::SpriteCollection &sprite, SpriteFile &file, size_t file_pos, SpriteType sprite_type, bool load_32bpp, uint8_t control_flags, ZoomLevels &avail_8bpp, ZoomLevels &avail_32bpp) = 0;
 
  virtual ~SpriteLoader() = default;
};
class SpriteLoader {…};
 
class SpriteAllocator {
public:
  virtual ~SpriteAllocator() = default;
 
  template <typename T>
  T *Allocate(size_t size)
  {
    return static_cast<T *>(this->AllocatePtr(size));
  }
  T *Allocate(size_t size) {…}
 
protected:
  virtual void *AllocatePtr(size_t size) = 0;
};
class SpriteAllocator {…};
 
class SpriteEncoder {
public:
 
  virtual ~SpriteEncoder() = default;
 
  virtual bool Is32BppSupported() = 0;
 
  virtual Sprite *Encode(SpriteType sprite_type, const SpriteLoader::SpriteCollection &sprite, SpriteAllocator &allocator) = 0;
 
  virtual uint GetSpriteAlignment()
  {
    return 0;
  }
  virtual uint GetSpriteAlignment() {…}
};
class SpriteEncoder {…};
#endif /* SPRITELOADER_HPP */