image.h

Go to the documentation of this file.

//            Copyright (C) 2004-2007 by The Allacrost Project
//                         All Rights Reserved
//
// This code is licensed under the GNU GPL version 2. It is free software 
// and you may modify it and/or redistribute it under the terms of this license.
// See http://www.gnu.org/copyleft/gpl.html for details.

#ifndef __IMAGE_HEADER__
#define __IMAGE_HEADER__

#include "defs.h"
#include "utils.h"
#include "color.h"
#include "tex_mgmt.h"

namespace hoa_video {

namespace private_video {

class ImageLoadInfo {
public:
  int32 width;

  int32 height;

  void* pixels;

  ImageLoadInfo () :
    width (0),
    height (0),
    pixels (NULL)
  {}

}; // class ImageLoadInfo


class Image {
public:
  TexSheet* texture_sheet;

  std::string filename;


  std::string tags;

  int32 x, y;

  float u1, v1, u2, v2;

  int32 width, height;

  bool grayscale;

  int32 ref_count;

  Image(const std::string &fname, const std::string &tags_, int32 width, int32 height, bool grayscale_);

  Image(TexSheet *sheet, const std::string &fname, const std::string &tags_, int32 x_, int32 y_, float u1_, float v1_,
    float u2_, float v2_, int32 wifth, int32 height, bool grayscale_);

  Image & operator=(Image &rhs)
    { return *this; }
}; // class Image


class ImageElement {
  friend class AnimatedImage;
public:
  Image* image;

  float x_offset;

  float y_offset;

  float u1, v1, u2, v2;

  float width;

  float height;

  Color color[4];

  bool blend;

  bool one_color;

  bool white;

  ImageElement(Image *image_, float x_offset_, float y_offset_, float u1_, float v1_,
    float u2_, float v2_, float width_, float height_, Color color_[4]);
  
  ImageElement(Image *image_, float x_offset_, float y_offset_, float u1_, float v1_,
    float u2_, float v2_, float width_, float height_);
}; // class ImageElement



struct MultiImageInfo {
  ImageLoadInfo multi_image;  
  ImageLoadInfo image;    
};


} // namespace private_video



class ImageDescriptor {
  friend class GameVideo;
public:
  ImageDescriptor();

  virtual ~ImageDescriptor()
  {}

  virtual void Clear() = 0;



  virtual void SetStatic(const bool is_static) = 0;

  virtual void SetWidth(const float width) = 0;

  virtual void SetHeight(const float height) = 0;

  virtual void SetDimensions(const float width, const float height) = 0;

  virtual void SetColor(const Color &color) = 0;

  virtual void SetVertexColors(const Color &tl, const Color &tr, const Color &bl, const Color &br) = 0;



  virtual float GetWidth() const = 0;

  virtual float GetHeight() const = 0;

  bool IsGrayScale() const
    { return _grayscale; }

  bool IsAnimated() const
    { return _animated; }

  bool Load();

  void Draw();


  bool Save(const std::string filename) const;

protected:
  float _width, _height;

  Color _color[4];

  bool  _is_static;

  bool _grayscale;

  bool _animated;

  bool _loaded;


  void _Clear ();
}; // class ImageDescriptor


class StillImage : public ImageDescriptor {
  friend class GameVideo;
  friend class AnimatedImage;
  friend class private_video::ParticleSystem;
public:
  StillImage(const bool grayscale = false);

  void Clear();

  void EnableGrayScale();

  void DisableGrayScale();

  bool AddImage(const StillImage &id, float x_offset, float y_offset, float u1 = 0.0f, float v1 = 0.0f,
    float u2 = 1.0f, float v2 = 1.0f);
  


  void SetFilename(const std::string &filename)
    { _filename = filename; }

  void SetWidth(const float width);

  void SetHeight(const float height);

  void SetDimensions(const float width, const float height);

  void SetStatic(const bool is_static)
    { _is_static = is_static; }

  void SetColor(const Color &color)
    { _color[0] = _color[1] = _color[2] = _color[3] = color; }

  void SetVertexColors(const Color &tl, const Color &tr, const Color &bl, const Color &br)
    { _color[0] = tl; _color[1] = tr; _color[2] = bl; _color[3] = br; }



  std::string GetFilename() const
    { return _filename; }

  float GetWidth() const
    { return _width; }

  float GetHeight() const
    { return _height; }

  void GetVertexColor(Color &c, uint8 index)
    { if (index > 3) return; else c = _color[index]; }

private:
  std::string _filename;

  std::vector <private_video::ImageElement> _elements;
}; // class StillImage : public ImageDescriptor



namespace private_video {

class AnimationFrame {
public:
  uint32 frame_time;

  StillImage image;
}; // class AnimationFrame

} // namespace private_video



class AnimatedImage : public ImageDescriptor {
  friend class GameVideo;
public:
  AnimatedImage(const bool grayscale = false);

  void Clear();

  void EnableGrayScale();

  void DisableGrayScale();

  void Update();

  void ResetAnimation()
    { _frame_index = 0; _frame_counter = 0; _loop_counter = 0; _loops_finished = false; }

  bool AddFrame(const StillImage &frame, uint32 frame_time);

  bool AddFrame(const std::string &frame, uint32 frame_time);



  void SetWidth(const float width);

  void SetHeight(const float height);

  void SetDimensions(const float width, const float height);

  void SetColor(const Color &color);

  void SetVertexColors(const Color &tl, const Color &tr, const Color &bl, const Color &br);

  void SetStatic(const bool is_static)
    { _is_static = is_static; }

  void SetFrameIndex(const uint32 index)
    { if (index > _frames.size()) return; _frame_index = index; _frame_counter = 0; }

  void SetTimeProgress(uint32 time)
    { _frame_counter = time; }

  void SetNumberLoops(int32 loops)
    { _number_loops = loops; }

  void SetLoopCounter(int32 loops)
    { _loop_counter = loops; }

  void SetLoopsFinished(bool loops)
    { _loops_finished = loops; }




  float GetWidth() const
    { if (_frames.size() == 0) return 0.0f; else return _frames[0].image.GetWidth(); }

  float GetHeight() const
    { if (_frames.size() == 0) return 0.0f; else return _frames[0].image.GetHeight(); }

  uint32 GetNumFrames() const
    { return _frames.size(); }

  uint32 GetCurrentFrameIndex() const
    { return _frame_index; }

  StillImage *GetFrame(uint32 index) const
    { if (index >= _frames.size()) return NULL; else return const_cast<StillImage*>(&(_frames[index].image)); }

  uint32 GetTimeProgress() const
    { return _frame_counter; }

  float GetPercentProgress() const
    { return static_cast<float>(_frame_counter) / _frames[_frame_index].frame_time; }

  bool IsLoopsFinished() const
    { return _loops_finished; }

private:
  uint32 _frame_index;

  uint32 _frame_counter;

  int32 _number_loops;

  int32 _loop_counter;

  bool _loops_finished;

  std::vector<private_video::AnimationFrame> _frames;
};

}  // namespace hoa_video

#endif  // __IMAGE_HEADER__

---