cvideo.h

Go to the documentation of this file.

#ifndef CVIDEO_H
#define CVIDEO_H

#include "globals.h"

#include "csingletonmanager.h"

#include <list>
#include <assert.h>
#include <stdio.h>

typedef unsigned char uint8;

typedef unsigned long uint32;

class CPoint {
public:
  int x, y;

  /* Constructors... */
  CPoint() : x(0), y(0) { }
  CPoint(int x, int y) : x(x), y(y) { }

  void set(int x, int y) { this->x = x; this->y = y; }

  CPoint &operator+=(CPoint &point) {
    x += point.x;
    y += point.y;
    return *this;
  }

  friend const CPoint operator+(const CPoint &left, const CPoint &right);

  int operator==(const CPoint &right) const {
    return (x == right.x && y == right.y);
  }

  int operator!=(const CPoint &right) const {
    return !(x == right.x && y == right.y);
  }
};

class CRect {
public:
  CPoint pos;

  CPoint size;

  CRect() { }

  CRect(int x, int y, int w, int h) { set(x, y, w, h); }

  void set(int x, int y, int w, int h) {
    pos.x = x;
    pos.y = y;
    size.x = w;
    size.y = h;
  }

  void set(CPoint &pos, CPoint &size) { this->pos = pos; this->size = size; }

  int x1() const { return this->pos.x; }

  int y1() const { return this->pos.y; }

  int x2() const { return this->pos.x + this->size.x; }

  int y2() const { return this->pos.y + this->size.y; }

  int intersects_with(const CRect &r) const {
    return ( (this->x2() >= r.x1()) &&
              (r.x2() >= this->x1()) &&
              (this->y2() >= r.y1()) &&
              (r.y2() >= this->y1()) );
  }

  int operator==(const CRect &right) const {
    return (pos == right.pos && size == right.size);
  }

  int operator!=(const CRect &right) const {
    return (pos != right.pos || size != right.size);
  }
};

typedef std::list<CRect> CRectList;

class CColor;
class CSurfaceImpl;
class CScreen;

class CVideoSystem {
private:
  /* Outlaw copy constructor and '=' operator. */
  CVideoSystem(CVideoSystem &);
  CVideoSystem &operator=(CVideoSystem &);

protected:
  friend class CColor;
  friend class CSurface;
  friend class CSurfaceImpl;

  virtual CSurfaceImpl *make_csurface_impl(int w, int h) = 0;
  
  virtual CSurfaceImpl *make_csurface_impl(const char *filename) = 0;

  virtual uint32 make_color(uint8 r, uint8 g, uint8 b) = 0;

 public:
  CVideoSystem() { }
  virtual ~CVideoSystem() { }

  virtual CScreen &get_screen() = 0;
};

class CVideoSystemManager : public CSingletonManager<CVideoSystem> { };

typedef CSingletonFactory<CVideoSystem> CVideoSystemFactory;

class CColor {
private:
  /* The surface-specific color value. */
  uint32 color;
public:
  CColor(uint32 n_color = 0) : color(n_color) { }

  CColor(uint8 r, uint8 g, uint8 b) { color = CVideoSystemManager::get_instance().make_color(r,g,b); }

  operator uint32 () const { return color; }
};

class CSurfaceImpl {
public:
  virtual ~CSurfaceImpl() { }

  virtual void inc_ref_count() = 0;

  virtual void dec_ref_count() = 0;

  virtual int is_empty() = 0;

  virtual void set_transparent_color(CColor color) = 0;

  virtual void blit(CSurfaceImpl &source) = 0;

  virtual void blit(CSurfaceImpl &source, CPoint &dest_pos) = 0;

  virtual void blit(CSurfaceImpl &source, CPoint &dest_pos, CRect &src_rect) = 0;
  
  virtual void fill_rect(const CRect &rect, CColor color) = 0;

  virtual void set_clipping_rect(CRect &rect) = 0;

  virtual void clear_clipping_rect() = 0;

  virtual int get_depth() = 0;

  virtual int get_width() = 0;

  virtual int get_height() = 0;

  virtual void set_video_mode(int width, int height, int depth, int fullscreen) = 0;

  virtual void flip() = 0;

  virtual void update_rects(CRectList &rects) = 0;
};

class CSurface {
protected:
  CSurfaceImpl *impl;

  void attach(CSurface &cs) {
    impl = cs.impl;
    impl->inc_ref_count();
  }

  void detach() {
    if (impl) {
      impl->dec_ref_count();
      if (impl->is_empty()) delete impl;
      impl = 0;
    }
  }

public:
  CSurface() : impl(0) { }

  CSurface(int w, int h) { impl = CVideoSystemManager::get_instance().make_csurface_impl(w, h); }

  CSurface(const char *filename) { impl = CVideoSystemManager::get_instance().make_csurface_impl(filename); }

  CSurface(CSurface &copy) { attach(copy); }

  ~CSurface() { detach(); }

  CSurface &operator=(CSurface &cs) {
    if (this != &cs) {
      detach();
      attach(cs);
    }
    return *this;
  }

  void set_transparent_color(CColor color) { impl->set_transparent_color(color); }

  void blit(CSurface &source) { impl->blit( *source.impl ); }

  void blit(CSurface &source, CPoint &dest_pos) { impl->blit( *source.impl, dest_pos); }

  void blit(CSurface &source, CPoint &dest_pos, CRect &src_rect) { impl->blit( *source.impl, dest_pos, src_rect); }
  
  void fill_rect(const CRect &rect, CColor color) { impl->fill_rect(rect, color); }

  void set_clipping_rect(CRect &rect) { impl->set_clipping_rect(rect); }

  void clear_clipping_rect() { impl->clear_clipping_rect(); }

  int get_depth() { return impl->get_depth(); }

  int get_width() { return impl->get_width(); }

  int get_height() { return impl->get_height(); }

  CPoint get_size() { return CPoint(get_width(), get_height()); }
};

class CScreen : public CSurface {
private:
  /* Whether the screen is currently fullscreen or windowed. */
  int is_fullscreen;

  /* Outlaw copy and '=' operators. */
  CScreen(CScreen &copy);
  CScreen &operator=(CScreen &);

public:
  CScreen(CSurfaceImpl *n_impl) : is_fullscreen(0) { impl = n_impl; }

  void set_video_mode(int width, int height, int depth) {
    impl->set_video_mode(width, height, depth, is_fullscreen);
  }

  void flip() { impl->flip(); }

  void update_rects(CRectList &rects) { impl->update_rects(rects); }

  void set_fullscreen_mode(int mode) {
    is_fullscreen = mode;
    set_video_mode(get_width(), get_height(), get_depth());
  }

  int get_fullscreen_mode() {
    return is_fullscreen;
  }
};

#endif

---