newgrf_spritegroup.h

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 NEWGRF_SPRITEGROUP_H
#define NEWGRF_SPRITEGROUP_H
 
#include "core/pool_type.hpp"
#include "town_type.h"
#include "engine_type.h"
#include "house_type.h"
#include "industry_type.h"
 
#include "newgrf_callbacks.h"
#include "newgrf_generic.h"
#include "newgrf_storage.h"
#include "newgrf_commons.h"
 
struct SpriteGroup;
struct ResultSpriteGroup;
struct TileLayoutSpriteGroup;
struct IndustryProductionSpriteGroup;
struct ResolverObject;
using CallbackResult = uint16_t;
 
using ResolverResult = std::variant<std::monostate, CallbackResult, const ResultSpriteGroup *, const TileLayoutSpriteGroup *, const IndustryProductionSpriteGroup *>;
 
/* SPRITE_WIDTH is 24. ECS has roughly 30 sprite groups per real sprite.
 * Adding an 'extra' margin would be assuming 64 sprite groups per real
 * sprite. 64 = 2^6, so 2^30 should be enough (for now) */
using SpriteGroupID = PoolID<uint32_t, struct SpriteGroupIDTag, 1U << 30, 0xFFFFFFFF>;
using SpriteGroupPool = Pool<SpriteGroup, SpriteGroupID, 1024, PoolType::Data>;
extern SpriteGroupPool _spritegroup_pool;
 
/* Common wrapper for all the different sprite group types */
struct SpriteGroup : SpriteGroupPool::PoolItem<&_spritegroup_pool> {
protected:
  SpriteGroup() {} // Not `= default` as that resets PoolItem->index.
  virtual ResolverResult Resolve(ResolverObject &object) const = 0;
 
public:
  virtual ~SpriteGroup() = default;
 
  uint32_t nfo_line = 0;
 
  static ResolverResult Resolve(const SpriteGroup *group, ResolverObject &object, bool top_level = true);
};
struct SpriteGroup : SpriteGroupPool::PoolItem<&_spritegroup_pool> {…};
 
 
/* 'Real' sprite groups contain a list of other result or callback sprite
 * groups. */
struct RealSpriteGroup : SpriteGroup {
  RealSpriteGroup() : SpriteGroup() {}
 
  /* Loaded = in motion, loading = not moving
   * Each group contains several spritesets, for various loading stages */
 
  /* XXX: For stations the meaning is different - loaded is for stations
   * with small amount of cargo whilst loading is for stations with a lot
   * of da stuff. */
 
  std::vector<const SpriteGroup *> loaded{};  
  std::vector<const SpriteGroup *> loading{}; 
 
protected:
  ResolverResult Resolve(ResolverObject &object) const override;
};
struct RealSpriteGroup : SpriteGroup {…};
 
/* Shared by deterministic and random groups. */
enum VarSpriteGroupScope : uint8_t {
  VSG_BEGIN,
 
  VSG_SCOPE_SELF = VSG_BEGIN, 
  VSG_SCOPE_PARENT,           
  VSG_SCOPE_RELATIVE,         
 
  VSG_END
};
enum VarSpriteGroupScope : uint8_t {…};
DECLARE_INCREMENT_DECREMENT_OPERATORS(VarSpriteGroupScope)
 
enum DeterministicSpriteGroupSize : uint8_t {
  DSG_SIZE_BYTE,
  DSG_SIZE_WORD,
  DSG_SIZE_DWORD,
};
 
enum DeterministicSpriteGroupAdjustType : uint8_t {
  DSGA_TYPE_NONE,
  DSGA_TYPE_DIV,
  DSGA_TYPE_MOD,
};
 
enum DeterministicSpriteGroupAdjustOperation : uint8_t {
  DSGA_OP_ADD,  
  DSGA_OP_SUB,  
  DSGA_OP_SMIN, 
  DSGA_OP_SMAX, 
  DSGA_OP_UMIN, 
  DSGA_OP_UMAX, 
  DSGA_OP_SDIV, 
  DSGA_OP_SMOD, 
  DSGA_OP_UDIV, 
  DSGA_OP_UMOD, 
  DSGA_OP_MUL,  
  DSGA_OP_AND,  
  DSGA_OP_OR,   
  DSGA_OP_XOR,  
  DSGA_OP_STO,  
  DSGA_OP_RST,  
  DSGA_OP_STOP, 
  DSGA_OP_ROR,  
  DSGA_OP_SCMP, 
  DSGA_OP_UCMP, 
  DSGA_OP_SHL,  
  DSGA_OP_SHR,  
  DSGA_OP_SAR,  
};
enum DeterministicSpriteGroupAdjustOperation : uint8_t {…};
 
 
struct DeterministicSpriteGroupAdjust {
  DeterministicSpriteGroupAdjustOperation operation{};
  DeterministicSpriteGroupAdjustType type{};
  uint8_t variable = 0;
  uint8_t parameter = 0; 
  uint8_t shift_num = 0;
  uint32_t and_mask = 0;
  uint32_t add_val = 0;
  uint32_t divmod_val = 0;
  const SpriteGroup *subroutine = nullptr;
};
struct DeterministicSpriteGroupAdjust {…};
 
 
struct DeterministicSpriteGroupResult {
  bool calculated_result = false;
  const SpriteGroup *group = nullptr;
 
  bool operator==(const DeterministicSpriteGroupResult &) const = default;
};
struct DeterministicSpriteGroupResult {…};
 
struct DeterministicSpriteGroupRange {
  DeterministicSpriteGroupResult result;
  uint32_t low = 0;
  uint32_t high = 0;
};
struct DeterministicSpriteGroupRange {…};
 
 
struct DeterministicSpriteGroup : SpriteGroup {
  DeterministicSpriteGroup() : SpriteGroup() {}
 
  VarSpriteGroupScope var_scope{};
  DeterministicSpriteGroupSize size{};
  std::vector<DeterministicSpriteGroupAdjust> adjusts{};
  std::vector<DeterministicSpriteGroupRange> ranges{}; // Dynamically allocated
 
  /* Dynamically allocated, this is the sole owner */
  DeterministicSpriteGroupResult default_result;
 
  const SpriteGroup *error_group = nullptr; // was first range, before sorting ranges
 
protected:
  ResolverResult Resolve(ResolverObject &object) const override;
};
struct DeterministicSpriteGroup : SpriteGroup {…};
 
enum RandomizedSpriteGroupCompareMode : uint8_t {
  RSG_CMP_ANY,
  RSG_CMP_ALL,
};
 
struct RandomizedSpriteGroup : SpriteGroup {
  RandomizedSpriteGroup() : SpriteGroup() {}
 
  VarSpriteGroupScope var_scope{};  
 
  RandomizedSpriteGroupCompareMode cmp_mode{}; 
  uint8_t triggers = 0;
  uint8_t count = 0;
 
  uint8_t lowest_randbit = 0; 
 
  std::vector<const SpriteGroup *> groups{}; 
 
protected:
  ResolverResult Resolve(ResolverObject &object) const override;
};
struct RandomizedSpriteGroup : SpriteGroup {…};
 
 
/* This contains a callback result. A failed callback has a value of
 * CALLBACK_FAILED */
struct CallbackResultSpriteGroup : SpriteGroup {
  explicit CallbackResultSpriteGroup(CallbackResult value) : SpriteGroup(), result(value) {}
 
  CallbackResult result = 0;
 
protected:
  ResolverResult Resolve(ResolverObject &object) const override;
};
struct CallbackResultSpriteGroup : SpriteGroup {…};
 
 
/* A result sprite group returns the first SpriteID and the number of
 * sprites in the set */
struct ResultSpriteGroup : SpriteGroup {
  ResultSpriteGroup(SpriteID sprite, uint8_t num_sprites) : SpriteGroup(), num_sprites(num_sprites), sprite(sprite) {}
 
  uint8_t num_sprites = 0;
  SpriteID sprite = 0;
 
protected:
  ResolverResult Resolve(ResolverObject &) const override { return this; }
};
struct ResultSpriteGroup : SpriteGroup {…};
 
struct TileLayoutSpriteGroup : SpriteGroup {
  TileLayoutSpriteGroup() : SpriteGroup() {}
 
  NewGRFSpriteLayout dts{};
 
  SpriteLayoutProcessor ProcessRegisters(const ResolverObject &object, uint8_t *stage) const;
 
protected:
  ResolverResult Resolve(ResolverObject &) const override { return this; }
};
struct TileLayoutSpriteGroup : SpriteGroup {…};
 
struct IndustryProductionSpriteGroup : SpriteGroup {
  IndustryProductionSpriteGroup() : SpriteGroup() {}
 
  uint8_t version = 0; 
  uint8_t num_input = 0; 
  std::array<int16_t, INDUSTRY_NUM_INPUTS> subtract_input{}; 
  std::array<CargoType, INDUSTRY_NUM_INPUTS> cargo_input{}; 
  uint8_t num_output = 0; 
  std::array<uint16_t, INDUSTRY_NUM_OUTPUTS> add_output{}; 
  std::array<CargoType, INDUSTRY_NUM_OUTPUTS> cargo_output{}; 
  uint8_t again = 0;
 
protected:
  ResolverResult Resolve(ResolverObject &) const override { return this; }
};
struct IndustryProductionSpriteGroup : SpriteGroup {…};
 
struct ScopeResolver {
  ResolverObject &ro; 
 
  ScopeResolver(ResolverObject &ro) : ro(ro) {}
  virtual ~ScopeResolver() = default;
 
  virtual uint32_t GetRandomBits() const;
  virtual uint32_t GetRandomTriggers() const;
 
  virtual uint32_t GetVariable(uint8_t variable, [[maybe_unused]] uint32_t parameter, bool &available) const;
  virtual void StorePSA(uint reg, int32_t value);
};
struct ScopeResolver {…};
 
struct ResolverObject {
private:
  static TemporaryStorageArray<int32_t, 0x110> temp_store;
 
public:
  ResolverObject(const GRFFile *grffile, CallbackID callback = CBID_NO_CALLBACK, uint32_t callback_param1 = 0, uint32_t callback_param2 = 0)
    : default_scope(*this), callback(callback), callback_param1(callback_param1), callback_param2(callback_param2), grffile(grffile), root_spritegroup(nullptr)
  {
  }
  ResolverObject(const GRFFile *grffile, CallbackID callback = CBID_NO_CALLBACK, uint32_t callback_param1 = 0, uint32_t callback_param2 = 0) {…}
 
  virtual ~ResolverObject() = default;
 
  ResolverResult DoResolve()
  {
    temp_store.ClearChanges();
    this->last_value = 0;
    this->used_random_triggers = 0;
    this->reseed.fill(0);
    return SpriteGroup::Resolve(this->root_spritegroup, *this);
  }
 
  ScopeResolver default_scope; 
 
  inline int32_t GetRegister(uint i) const
  {
    return temp_store.GetValue(i);
  }
  inline int32_t GetRegister(uint i) const {…}
 
  inline void SetRegister(uint i, int32_t value)
  {
    temp_store.StoreValue(i, value);
  }
  inline void SetRegister(uint i, int32_t value) {…}
 
  CallbackID callback{}; 
  uint32_t callback_param1 = 0; 
  uint32_t callback_param2 = 0; 
 
  uint32_t last_value = 0; 
 
protected:
  uint32_t waiting_random_triggers = 0; 
  uint32_t used_random_triggers = 0; 
public:
  std::array<uint32_t, VSG_END> reseed; 
 
  const GRFFile *grffile = nullptr; 
  const SpriteGroup *root_spritegroup = nullptr; 
 
  template <class TSpriteGroup>
  inline const TSpriteGroup *Resolve()
  {
    auto result = this->DoResolve();
    const auto *group = std::get_if<const TSpriteGroup *>(&result);
    if (group == nullptr) return nullptr;
    return *group;
  }
  inline const TSpriteGroup *Resolve() {…}
 
  inline void ResolveRerandomisation()
  {
    /* The Resolve result has no meaning.
     * It can be a SpriteSet, a callback result, or even an invalid SpriteGroup reference (nullptr). */
    this->DoResolve();
  }
  inline void ResolveRerandomisation() {…}
 
  inline CallbackResult ResolveCallback(std::span<int32_t> regs100)
  {
    auto result = this->DoResolve();
    const auto *value = std::get_if<CallbackResult>(&result);
    if (value == nullptr) return CALLBACK_FAILED;
    for (uint i = 0; i < regs100.size(); ++i) {
      regs100[i] = this->GetRegister(0x100 + i);
    }
    return *value;
  }
  inline CallbackResult ResolveCallback(std::span<int32_t> regs100) {…}
 
  virtual const SpriteGroup *ResolveReal(const RealSpriteGroup &group) const;
 
  virtual ScopeResolver *GetScope(VarSpriteGroupScope scope = VSG_SCOPE_SELF, uint8_t relative = 0);
 
  uint32_t GetWaitingRandomTriggers() const
  {
    return this->waiting_random_triggers;
  }
  uint32_t GetWaitingRandomTriggers() const {…}
 
  void AddUsedRandomTriggers(uint32_t triggers)
  {
    this->used_random_triggers |= triggers;
  }
  void AddUsedRandomTriggers(uint32_t triggers) {…}
 
  uint32_t GetReseedSum() const
  {
    uint32_t sum = 0;
    for (VarSpriteGroupScope vsg = VSG_BEGIN; vsg < VSG_END; vsg++) {
      sum |= this->reseed[vsg];
    }
    return sum;
  }
  uint32_t GetReseedSum() const {…}
 
  virtual GrfSpecFeature GetFeature() const { return GSF_INVALID; }
  virtual uint32_t GetDebugID() const { return 0; }
};
struct ResolverObject {…};
 
template <class RandomTriggers>
struct SpecializedResolverObject : public ResolverObject {
  using ResolverObject::ResolverObject;
 
  void SetWaitingRandomTriggers(RandomTriggers triggers)
  {
    this->waiting_random_triggers = triggers.base();
  }
  void SetWaitingRandomTriggers(RandomTriggers triggers) {…}
 
  RandomTriggers GetUsedRandomTriggers() const
  {
    return static_cast<RandomTriggers>(this->used_random_triggers);
  }
  RandomTriggers GetUsedRandomTriggers() const {…}
};
 
#endif /* NEWGRF_SPRITEGROUP_H */
  using ResolverObject::ResolverObject; {…}
struct SpecializedResolverObject : public ResolverObject {…};