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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef SPRITELOADER_HPP
#define SPRITELOADER_HPP
 
#include "../core/alloc_type.hpp"
#include "../core/enum_type.hpp"
#include "../gfx_type.h"
#include "../spritecache_type.h"
#include "sprite_file_type.hpp"
 
struct Sprite;

enum class SpriteComponent : uint8_t {
  RGB     = 0, 
  Alpha   = 1, 
  Palette = 2, 
  End, 
};

using SpriteComponents = EnumBitSet<SpriteComponent, uint8_t, SpriteComponent::End>;

template <class T>
class SpriteCollMap {
  EnumIndexArray<T, ZoomLevel, ZoomLevel::End> data{};
public:
  inline constexpr T &operator[](const ZoomLevel &zoom) { return this->data[zoom]; }
  inline constexpr const T &operator[](const ZoomLevel &zoom) const { return this->data[zoom]; }
 
  T &Root() { return this->data[ZoomLevel::Min]; }
  const T &Root() const { return this->data[ZoomLevel::Min]; }
};

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 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;
  };

  using SpriteCollection = SpriteCollMap<Sprite>;

  virtual ZoomLevels LoadSprite(SpriteLoader::SpriteCollection &sprite, SpriteFile &file, size_t file_pos, SpriteType sprite_type, bool load_32bpp, SpriteCacheCtrlFlags control_flags, ZoomLevels &avail_8bpp, ZoomLevels &avail_32bpp) = 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(SpriteType sprite_type, const SpriteLoader::SpriteCollection &sprite, SpriteAllocator &allocator) = 0;

  virtual uint GetSpriteAlignment()
  {
    return 0;
  }
};
#endif /* SPRITELOADER_HPP */