SPRITE_SIZE_16x16,

// SPRITE_SIZE_24x24,

SPRITE_SIZE_32x32,

SPRITE_SIZE_COUNT

Sprite() { }

virtual ~Sprite() { }

virtual void DrawTo(wxDC* dc, SpriteSize sz, int start_x, int start_y, int width = -1, int height = -1) = 0;

virtual void unloadDC() = 0;

Sprite(const Sprite&);

Sprite& operator=(const Sprite&);

EditorSprite(wxBitmap* b16x16, wxBitmap* b32x32);

virtual ~EditorSprite();

virtual void DrawTo(wxDC* dc, SpriteSize sz, int start_x, int start_y, int width = -1, int height = -1);

virtual void unloadDC();

wxBitmap* bm[SPRITE_SIZE_COUNT];

GameSprite();

~GameSprite();

int getIndex(int width, int height, int layer, int pattern_x, int pattern_y, int pattern_z, int frame) const;

GLuint getHardwareID(int _x, int _y, int _layer, int _subtype, int _pattern_x, int _pattern_y, int _pattern_z, int _frame);

GLuint getHardwareID(int _x, int _y, int _dir, int _addon, int _pattern_z, const Outfit& _outfit, int _frame); // CreatureDatabase

virtual void DrawTo(wxDC* dc, SpriteSize sz, int start_x, int start_y, int width = -1, int height = -1);

virtual void unloadDC();

void clean(int time);

int getDrawHeight() const;

std::pair<int, int> getDrawOffset() const;

uint8_t getMiniMapColor() const;

bool hasLight() const noexcept {

return has_light;

}

const SpriteLight& getLight() const noexcept {

return light;

}

class Image;

class NormalImage;

class TemplateImage;

wxMemoryDC* getDC(SpriteSize size);

TemplateImage* getTemplateImage(int sprite_index, const Outfit& outfit);

class Image {

public:

Image();

virtual ~Image();

bool isGLLoaded;

int lastaccess;

void visit();

virtual void clean(int time);

virtual GLuint getHardwareID() = 0;

virtual uint8_t* getRGBData() = 0;

virtual uint8_t* getRGBAData() = 0;

protected:

virtual void createGLTexture(GLuint whatid);

virtual void unloadGLTexture(GLuint whatid);

};

class NormalImage : public Image {

public:

NormalImage();

virtual ~NormalImage();

// We use the sprite id as GL texture id

uint32_t id;

// This contains the pixel data

uint16_t size;

uint8_t* dump;

virtual void clean(int time);

virtual GLuint getHardwareID();

virtual uint8_t* getRGBData();

virtual uint8_t* getRGBAData();

protected:

virtual void createGLTexture(GLuint ignored = 0);

virtual void unloadGLTexture(GLuint ignored = 0);

};

class TemplateImage : public Image {

public:

TemplateImage(GameSprite* parent, int v, const Outfit& outfit);

virtual ~TemplateImage();

virtual GLuint getHardwareID();

virtual uint8_t* getRGBData();

virtual uint8_t* getRGBAData();

GLuint gl_tid;

GameSprite* parent;

int sprite_index;

uint8_t lookHead;

uint8_t lookBody;

uint8_t lookLegs;

uint8_t lookFeet;

protected:

void colorizePixel(uint8_t color, uint8_t& r, uint8_t& b, uint8_t& g);

virtual void createGLTexture(GLuint ignored = 0);

virtual void unloadGLTexture(GLuint ignored = 0);

};

uint32_t id;

wxMemoryDC* dc[SPRITE_SIZE_COUNT];

// GameSprite info

uint8_t height;

uint8_t width;

uint8_t layers;

uint8_t pattern_x;

uint8_t pattern_y;

uint8_t pattern_z;

uint8_t frames;

uint32_t numsprites;

Animator* animator;

uint16_t draw_height;

uint16_t drawoffset_x;

uint16_t drawoffset_y;

uint16_t minimap_color;

bool has_light = false;

SpriteLight light;

std::vector<NormalImage*> spriteList;

std::list<TemplateImage*> instanced_templates; // Templates that use this sprite

friend class GraphicManager;

int min;

int max;

FrameDuration(int min, int max) :

min(min), max(max) {

ASSERT(min <= max);

}

int getDuration() const {

if (min == max) {

return min;

}

return uniform_random(min, max);

};

void setValues(int min, int max) {

ASSERT(min <= max);

this->min = min;

this->max = max;

}

Animator(int frames, int start_frame, int loop_count, bool async);

~Animator();

int getStartFrame() const;

FrameDuration* getFrameDuration(int frame);

int getFrame();

void setFrame(int frame);

void reset();

int getDuration(int frame) const;

int getPingPongFrame();

int getLoopFrame();

void calculateSynchronous();

int frame_count;

int start_frame;

int loop_count;

bool async;

std::vector<FrameDuration*> durations;

int current_frame;

int current_loop;

int current_duration;

int total_duration;

AnimationDirection direction;

long last_time;

bool is_complete;

GraphicManager();

~GraphicManager();

void clear();

void cleanSoftwareSprites();

Sprite* getSprite(int id);

GameSprite* getCreatureSprite(int id);

long getElapsedTime() const {

return (animation_timer->TimeInMicro() / 1000).ToLong();

}

uint16_t getItemSpriteMaxID() const;

uint16_t getCreatureSpriteMaxID() const;

// Get an unused texture id (this is acquired by simply increasing a value starting from 0x10000000)

GLuint getFreeTextureID();

// This is part of the binary

bool loadEditorSprites();

// Metadata should be loaded first

// This fills the item / creature adress space

bool loadOTFI(const FileName& filename, wxString& error, wxArrayString& warnings);

bool loadSpriteMetadata(const FileName& datafile, wxString& error, wxArrayString& warnings);

bool loadSpriteMetadataFlags(FileReadHandle& file, GameSprite* sType, wxString& error, wxArrayString& warnings);

bool loadSpriteData(const FileName& datafile, wxString& error, wxArrayString& warnings);

// Cleans old & unused textures according to config settings

void garbageCollection();

void addSpriteToCleanup(GameSprite* spr);

wxFileName getMetadataFileName() const {

return metadata_file;

}

wxFileName getSpritesFileName() const {

return sprites_file;

}

bool hasTransparency() const;

bool isUnloaded() const;

ClientVersion* client_version;

bool unloaded;

// This is used if memcaching is NOT on

std::string spritefile;

bool loadSpriteDump(uint8_t*& target, uint16_t& size, int sprite_id);

typedef std::map<int, Sprite*> SpriteMap;

SpriteMap sprite_space;

typedef std::map<int, GameSprite::Image*> ImageMap;

ImageMap image_space;

std::deque<GameSprite*> cleanup_list;

DatFormat dat_format;

uint16_t item_count;

uint16_t creature_count;

bool otfi_found;

bool is_extended;

bool has_transparency;

bool has_frame_durations;

bool has_frame_groups;

wxFileName metadata_file;

wxFileName sprites_file;

int loaded_textures;

int lastclean;

wxStopWatch* animation_timer;

friend class GameSprite::Image;

friend class GameSprite::NormalImage;

friend class GameSprite::TemplateImage;

uint8_t red;

uint8_t green;

uint8_t blue;

uint8_t reserved;

RGBQuad(uint8_t r, uint8_t g, uint8_t b) :

red(r), green(g), blue(b), reserved(0) { }

operator uint32_t() {

return (blue << 0) | (green << 8) | (red << 16);

}

operator bool() {

// std::cout << "RGBQuad operator bool " << int(red) << " || " << int(blue) << " || " << int(green) << std::endl;

return blue != 0 || red != 0 || green != 0;

}