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 "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"
 
inline uint32_t GetRegister(uint i)
{
  extern TemporaryStorageArray<int32_t, 0x110> _temp_store;
  return _temp_store.GetValue(i);
}
 
/* List of different sprite group types */
enum SpriteGroupType : uint8_t {
  SGT_REAL,
  SGT_DETERMINISTIC,
  SGT_RANDOMIZED,
  SGT_CALLBACK,
  SGT_RESULT,
  SGT_TILELAYOUT,
  SGT_INDUSTRY_PRODUCTION,
};
 
struct SpriteGroup;
typedef uint32_t SpriteGroupID;
struct ResolverObject;
 
/* 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) */
typedef Pool<SpriteGroup, SpriteGroupID, 1024, 1U << 30, PT_DATA> SpriteGroupPool;
extern SpriteGroupPool _spritegroup_pool;
 
/* Common wrapper for all the different sprite group types */
struct SpriteGroup : SpriteGroupPool::PoolItem<&_spritegroup_pool> {
protected:
  SpriteGroup(SpriteGroupType type) : nfo_line(0), type(type) {}
  virtual const SpriteGroup *Resolve([[maybe_unused]] ResolverObject &object) const { return this; };
 
public:
  virtual ~SpriteGroup() = default;
 
  uint32_t nfo_line;
  SpriteGroupType type;
 
  virtual SpriteID GetResult() const { return 0; }
  virtual uint8_t GetNumResults() const { return 0; }
  virtual uint16_t GetCallbackResult() const { return CALLBACK_FAILED; }
 
  static const SpriteGroup *Resolve(const SpriteGroup *group, ResolverObject &object, bool top_level = true);
};
 
 
/* 'Real' sprite groups contain a list of other result or callback sprite
 * groups. */
struct RealSpriteGroup : SpriteGroup {
  RealSpriteGroup() : SpriteGroup(SGT_REAL) {}
 
  /* 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:
  const SpriteGroup *Resolve(ResolverObject &object) const override;
};
 
/* 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
};
DECLARE_POSTFIX_INCREMENT(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,  
};
 
 
struct DeterministicSpriteGroupAdjust {
  DeterministicSpriteGroupAdjustOperation operation;
  DeterministicSpriteGroupAdjustType type;
  uint8_t variable;
  uint8_t parameter; 
  uint8_t shift_num;
  uint32_t and_mask;
  uint32_t add_val;
  uint32_t divmod_val;
  const SpriteGroup *subroutine;
};
 
 
struct DeterministicSpriteGroupRange {
  const SpriteGroup *group;
  uint32_t low;
  uint32_t high;
};
 
 
struct DeterministicSpriteGroup : SpriteGroup {
  DeterministicSpriteGroup() : SpriteGroup(SGT_DETERMINISTIC) {}
 
  VarSpriteGroupScope var_scope;
  DeterministicSpriteGroupSize size;
  bool calculated_result;
  std::vector<DeterministicSpriteGroupAdjust> adjusts;
  std::vector<DeterministicSpriteGroupRange> ranges; // Dynamically allocated
 
  /* Dynamically allocated, this is the sole owner */
  const SpriteGroup *default_group;
 
  const SpriteGroup *error_group; // was first range, before sorting ranges
 
protected:
  const SpriteGroup *Resolve(ResolverObject &object) const override;
};
 
enum RandomizedSpriteGroupCompareMode : uint8_t {
  RSG_CMP_ANY,
  RSG_CMP_ALL,
};
 
struct RandomizedSpriteGroup : SpriteGroup {
  RandomizedSpriteGroup() : SpriteGroup(SGT_RANDOMIZED) {}
 
  VarSpriteGroupScope var_scope;  
 
  RandomizedSpriteGroupCompareMode cmp_mode; 
  uint8_t triggers;
  uint8_t count;
 
  uint8_t lowest_randbit; 
 
  std::vector<const SpriteGroup *> groups; 
 
protected:
  const SpriteGroup *Resolve(ResolverObject &object) const override;
};
 
 
/* This contains a callback result. A failed callback has a value of
 * CALLBACK_FAILED */
struct CallbackResultSpriteGroup : SpriteGroup {
  CallbackResultSpriteGroup(uint16_t value, bool grf_version8) :
    SpriteGroup(SGT_CALLBACK),
    result(value)
  {
    /* Old style callback results (only valid for version < 8) have the highest byte 0xFF so signify it is a callback result.
     * New style ones only have the highest bit set (allows 15-bit results, instead of just 8) */
    if (!grf_version8 && (this->result >> 8) == 0xFF) {
      this->result &= ~0xFF00;
    } else {
      this->result &= ~0x8000;
    }
  }
 
  uint16_t result;
  uint16_t GetCallbackResult() const override { return this->result; }
};
 
 
/* 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(SGT_RESULT),
    num_sprites(num_sprites),
    sprite(sprite)
  {
  }
 
  uint8_t num_sprites;
  SpriteID sprite;
 
  SpriteID GetResult() const override { return this->sprite; }
  uint8_t GetNumResults() const override { return this->num_sprites; }
};
 
struct TileLayoutSpriteGroup : SpriteGroup {
  TileLayoutSpriteGroup() : SpriteGroup(SGT_TILELAYOUT) {}
  ~TileLayoutSpriteGroup() {}
 
  NewGRFSpriteLayout dts;
 
  const DrawTileSprites *ProcessRegisters(uint8_t *stage) const;
};
 
struct IndustryProductionSpriteGroup : SpriteGroup {
  IndustryProductionSpriteGroup() : SpriteGroup(SGT_INDUSTRY_PRODUCTION) {}
 
  uint8_t version;                              
  uint8_t num_input;                            
  int16_t subtract_input[INDUSTRY_NUM_INPUTS];  
  CargoID cargo_input[INDUSTRY_NUM_INPUTS];   
  uint8_t num_output;                           
  uint16_t add_output[INDUSTRY_NUM_OUTPUTS];    
  CargoID cargo_output[INDUSTRY_NUM_OUTPUTS]; 
  uint8_t again;
 
};
 
struct ScopeResolver {
  ResolverObject &ro; 
 
  ScopeResolver(ResolverObject &ro) : ro(ro) {}
  virtual ~ScopeResolver() = default;
 
  virtual uint32_t GetRandomBits() const;
  virtual uint32_t GetTriggers() 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 ResolverObject {
  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)
  {
    this->ResetState();
  }
 
  virtual ~ResolverObject() = default;
 
  ScopeResolver default_scope; 
 
  CallbackID callback;        
  uint32_t callback_param1;     
  uint32_t callback_param2;     
 
  uint32_t last_value;          
 
  uint32_t waiting_triggers;    
  uint32_t used_triggers;       
  uint32_t reseed[VSG_END];     
 
  const GRFFile *grffile;     
  const SpriteGroup *root_spritegroup; 
 
  const SpriteGroup *Resolve()
  {
    return SpriteGroup::Resolve(this->root_spritegroup, *this);
  }
 
  uint16_t ResolveCallback()
  {
    const SpriteGroup *result = Resolve();
    return result != nullptr ? result->GetCallbackResult() : CALLBACK_FAILED;
  }
 
  virtual const SpriteGroup *ResolveReal(const RealSpriteGroup *group) const;
 
  virtual ScopeResolver *GetScope(VarSpriteGroupScope scope = VSG_SCOPE_SELF, uint8_t relative = 0);
 
  uint32_t GetRemainingTriggers() const
  {
    return this->waiting_triggers & ~this->used_triggers;
  }
 
  uint32_t GetReseedSum() const
  {
    uint32_t sum = 0;
    for (VarSpriteGroupScope vsg = VSG_BEGIN; vsg < VSG_END; vsg++) {
      sum |= this->reseed[vsg];
    }
    return sum;
  }
 
  void ResetState()
  {
    this->last_value = 0;
    this->waiting_triggers = 0;
    this->used_triggers = 0;
    memset(this->reseed, 0, sizeof(this->reseed));
  }
 
  virtual GrfSpecFeature GetFeature() const { return GSF_INVALID; }
  virtual uint32_t GetDebugID() const { return 0; }
};
 
#endif /* NEWGRF_SPRITEGROUP_H */