video.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 __VIDEO_HEADER__
#define __VIDEO_HEADER__

#include "defs.h"
#include "utils.h"

// OpenGL includes
#ifdef __APPLE__
  #include <OpenGL/gl.h>
  #include <OpenGL/glu.h>
#else
  #include <GL/gl.h>
  #include <GL/glu.h>
#endif

// libpng and libjpeg image loader includes
#include <png.h>
extern "C" {
  #include <jpeglib.h>
}

// SDL_ttf includes
#ifdef __APPLE__
  #include <SDL_ttf/SDL_ttf.h>
#else
  #include <SDL/SDL_ttf.h>
#endif

// Various other headers of the video engine
#include "context.h"
#include "color.h"
#include "coord_sys.h"
#include "fade.h"
#include "image.h"
#include "interpolator.h"
#include "shake.h"
#include "screen_rect.h"
#include "tex_mgmt.h"
#include "text.h"
#include "particle_manager.h"
#include "particle_effect.h"
#include "gui.h"
#include "menu_window.h"
#include "option.h"
#include "textbox.h"

namespace hoa_video {

extern GameVideo* VideoManager;

extern bool VIDEO_DEBUG;

float RandomFloat(float a, float b);


void RotatePoint(float &x, float &y, float angle);


float Lerp(float alpha, float initial, float final);





const int32 VIDEO_ANIMATION_FRAME_PERIOD = 10;

enum VIDEO_DRAW_FLAGS {
  VIDEO_DRAW_FLAGS_INVALID = -1,


  VIDEO_X_LEFT = 1, VIDEO_X_CENTER = 2, VIDEO_X_RIGHT = 3,


  VIDEO_Y_TOP = 4, VIDEO_Y_CENTER = 5, VIDEO_Y_BOTTOM = 6,


  VIDEO_X_FLIP = 7, VIDEO_X_NOFLIP = 8,


  VIDEO_Y_FLIP = 9, VIDEO_Y_NOFLIP = 10,


  VIDEO_NO_BLEND = 11, VIDEO_BLEND = 12, VIDEO_BLEND_ADD = 13,

  VIDEO_DRAW_FLAGS_TOTAL = 14
};


enum VIDEO_TARGET {
  VIDEO_TARGET_INVALID = -1,

  VIDEO_TARGET_SDL_WINDOW = 0,

  VIDEO_TARGET_QT_WIDGET  = 1,

  VIDEO_TARGET_TOTAL = 2
};


enum VIDEO_STENCIL_OP {
  VIDEO_STENCIL_OP_INVALID = -1,

  VIDEO_STENCIL_OP_ONE      = 0,

  VIDEO_STENCIL_OP_ZERO     = 1,

  VIDEO_STENCIL_OP_INCREASE = 2,

  VIDEO_STENCIL_OP_DECREASE = 3,

  VIDEO_STENCIL_OP_TOTAL = 4
};

enum {
  VIDEO_STANDARD_RES_WIDTH  = 1024,
  VIDEO_STANDARD_RES_HEIGHT = 768
};

class GameVideo : public hoa_utils::Singleton<GameVideo> {
  friend class hoa_utils::Singleton<GameVideo>;
  friend class TextBox;
  friend class OptionBox;
  friend class MenuWindow;
  friend class private_video::GUIElement;
  friend class private_video::GUISupervisor;
  friend class private_video::FixedTexMemMgr;
  friend class private_video::VariableTexMemMgr;
  friend class private_video::TexSheet;
  friend class private_video::ParticleSystem;
  friend class StillImage;
  friend class RenderedString;

public:
  ~GameVideo();

  bool SingletonInitialize();


  //-- General --------------------------------------------------------------

  bool Clear();

  bool Clear(const Color &c);

  bool Display(int32 frame_time);


  bool SetTarget(VIDEO_TARGET target);

  //-- Video settings -------------------------------------------------------


  bool SetResolution(int32 width, int32 height);

  int32 GetWidth() const { return _width; }

  int32 GetHeight() const { return _height; }

  const CoordSys& GetCoordSys() const { return _coord_sys; }

  bool IsFullscreen();

  void GetPixelSize(double &x, double &y)
  {
    x = (_coord_sys.GetRight() - _coord_sys.GetLeft()) / _width;
    y = (_coord_sys.GetTop() - _coord_sys.GetBottom()) / _height;
  }

  bool SetFullscreen(bool fullscreen);

  bool ToggleFullscreen();

  bool ApplySettings();

  //-- Coordinate system / viewport  ------------------------------------------

  void SetViewport(float left, float right, float bottom, float top);

  void SetCoordSys(float left, float right, float bottom, float top);

  void SetCoordSys(const CoordSys &coordinate_system);

  void EnableScissoring(bool enable);

  bool IsScissoringEnabled()
    { return _scissor_enabled; }

  void SetScissorRect(float left, float right, float bottom, float top);

  void SetScissorRect(const ScreenRect &rect);

  ScreenRect GetScissorRect()
    { return _scissor_rect; }

  ScreenRect CalculateScreenRect(float left, float right, float bottom, float top);

  //-- Transformations ------------------------------------------------------

  void PushState();

  void PopState ();


  void PushMatrix();

  void PopMatrix();

  void Move(float x, float y);

  void MoveRelative(float dx, float dy);

  void GetDrawPosition(float &x, float &y);

  void Rotate (float angle);

  void Scale(float x, float y);

  void SetTransform(float m[16]);

  //-- Text -----------------------------------------------------------------

  bool LoadFont(const std::string &TTF_filename, const std::string &name, uint32 size);

  bool IsValidFont(const std::string &name)
    { return (_font_map.find(name) != _font_map.end()); }

  FontProperties* GetFontProperties(const std::string &font_name);

  int32 CalculateTextWidth(const std::string &font_name, const hoa_utils::ustring &text);


  int32 CalculateTextWidth(const std::string &font_name, const std::string  &text);

  bool SetFont(const std::string &name);

  void EnableTextShadow(bool enable);

  void SetTextColor(const Color &color)
    { _current_text_color = color; }

  bool SetFontShadowXOffset(const std::string &font_name, int32 x);

  bool SetFontShadowYOffset(const std::string &font_name, int32 y);

  bool SetFontShadowStyle(const std::string &font_name, TEXT_SHADOW_STYLE style);

  std::string GetFont      () const;

  Color       GetTextColor () const;

  bool DrawText(const std::string &text);

  bool DrawText(const hoa_utils::ustring &uText);

  //-- Particle effects -----------------------------------------------------------

  ParticleEffectID AddParticleEffect(const std::string &particle_effect_filename, float x, float y, bool reload=false);

  bool DrawParticleEffects();

  void StopAllParticleEffects(bool kill_immediate = false);

  ParticleEffect *GetParticleEffect(ParticleEffectID id);

  int32 GetNumParticles();

  //-- Images / Animation ---------------------------------------------------------

  bool GetImageInfo (const std::string& file_name, uint32 &rows, uint32& cols, uint32& bpp);

  bool LoadImage(ImageDescriptor &id);

  bool LoadImageGrayScale(ImageDescriptor &id);

  bool LoadMultiImageFromNumberElements(std::vector<StillImage> &images, const std::string &filename, const uint32 rows, const uint32 cols);

  bool LoadMultiImageFromElementsSize(std::vector<StillImage> &images, const std::string &filename, const uint32 width, const uint32 height);

  bool LoadAnimatedImageFromNumberElements(AnimatedImage &image, const std::string &file_name, const uint32 rows, const uint32 cols);

  bool LoadAnimatedImageFromElementsSize(AnimatedImage &image, const std::string &file_name, const uint32 rows, const uint32 cols);

  /*  This function stores a vector of images as a single image. This is useful for creating multiimage 
   *  images. The image can be stored in JPEG or PNG, which is decided by the filename.
   *  \param image Vector of images to save
   *  \param file_name Name of the file.
   *  \param rows Number of rows of sub-images in the MultiImage.
   *  \param cols Number of columns of sub-images in the MultiImage.
   *  \return success/failure
   */
  bool SaveImage (const std::string &file_name, const std::vector<StillImage*> &image, const uint32 rows, const uint32 columns) const;

  /*  The image can be stored in JPEG or PNG, which is decided by the filename.
   *  \param image StillImage to store.
   *  \param file_name Name of the file.
   *  \return success/failure
   */
  bool SaveImage (const std::string &file_name, const StillImage &image) const;

  /*  The image can be stored in JPEG or PNG, which is decided by the filename.
   *  It will be stored as a multiimage, with each frame aligned in one row and as many columns as frames.
   *  \param image AnimatedImage to store.
   *  \param file_name Name of the file.
   *  \return success/failure
   */
  bool SaveImage (const std::string &file_name, const AnimatedImage &image) const;

  bool CaptureScreen(StillImage &id);

  bool DeleteImage(ImageDescriptor &id);

  bool UnloadTextures();

  bool ReloadTextures();

  void SetDrawFlags(int32 first_flag, ...);

  bool DrawImage(const ImageDescriptor &id);

  bool DrawImage(const ImageDescriptor &id, const Color &color);

  StillImage TilesToObject(std::vector<StillImage> &tiles, std::vector< std::vector<uint32> > indices);

  int32 GetFrameChange() { return _current_frame_diff; }

  void DEBUG_NextTexSheet();
  void DEBUG_PrevTexSheet();

  //-- Menus -----------------------------------------------------------------


  bool LoadMenuSkin(std::string skin_name, std::string border_image, std::string background_image, bool make_default = false);

  bool LoadMenuSkin(std::string skin_name, std::string border_image, Color background_color, bool make_default = false);

  bool LoadMenuSkin(std::string skin_name, std::string border_image, Color top_left, Color top_right,
    Color bottom_left, Color bottom_right, bool make_default = false);

  bool LoadMenuSkin(std::string skin_name, std::string border_image, std::string background_image,
    Color background_color, bool make_default = false);

  bool LoadMenuSkin(std::string skin_name, std::string border_image, std::string background_image,
    Color top_left, Color top_right, Color bottom_left, Color bottom_right, bool make_default = false);

  bool IsMenuSkinAvailable(std::string& skin_name) const
    { if (private_video::GUIManager->GetMenuSkin(skin_name) == NULL) return false; else return true; }

  void SetDefaultMenuSkin(std::string& skin_name)
    { private_video::GUIManager->SetDefaultMenuSkin(skin_name); }

  void DeleteMenuSkin(std::string& skin_name)
    { private_video::GUIManager->DeleteMenuSkin(skin_name); }

  //-- Lighting and fog -----------------------------------------------------

  bool EnableSceneLighting(const Color &color);

  void DisableSceneLighting();

  Color &GetSceneLightingColor();

  bool EnableFog(const Color &color, float intensity);

  void DisableFog();

  bool DrawHalo(const StillImage &id, float x, float y, const Color &color = Color(1.0f, 1.0f, 1.0f, 1.0f));

  bool DrawLight(const StillImage &id, float x, float y, const Color &color = Color(1.0f, 1.0f, 1.0f, 1.0f));

  bool EnablePointLights();

  void DisablePointLights();

  //bool AccumulateLights();

  bool ApplyLightingOverlay();

  //-- Overlays / lightning -------------------------------------------------------

  bool DrawFullscreenOverlay(const Color &color);

  bool MakeLightning(const std::string &lit_file);

  bool DrawLightning();

  //-- Fading ---------------------------------------------------------------

  void FadeScreen(const Color &color, float fade_time);

  bool IsFading();

  //-- Screen shaking -------------------------------------------------------

  bool ShakeScreen(float force, float falloff_time, ShakeFalloff falloff = VIDEO_FALLOFF_NONE);

  bool StopShaking();

  bool IsShaking();

  //-- Miscellaneous --------------------------------------------------------

  void SetGamma(float value);

  float GetGamma();

  void DrawFPS(uint32 frame_time);

  void ToggleFPS();

  void DrawGrid(float x, float y, float x_step, float y_step, const Color &c);

  void DrawRectangle(const float width, const float height, const Color &color);

  bool MakeScreenshot();

  bool ToggleAdvancedDisplay();

  bool SetDefaultCursor(const std::string &cursor_image_filename);

  StillImage *GetDefaultCursor();

  bool Draw(const RenderedString &string);

  bool Draw(const RenderedLine &line, int32 tex_index);

  RenderedString *RenderText(const hoa_utils::ustring &txt);

private:
  GameVideo();

  //-- Private variables ----------------------------------------------------

  private_video::ParticleManager _particle_manager;

  VIDEO_TARGET _target;

  // draw flags

  int8 _blend;

  int8 _x_align;

  int8 _y_align;

  int8 _x_flip;

  int8 _y_flip;

  char _next_temp_file[9];

  CoordSys    _coord_sys;

  ScreenRect _viewport;

  ScreenRect _scissor_rect;

  bool _scissor_enabled;

  private_video::ScreenFader _fader;

  bool   _advanced_display;

  bool   _fps_display;

  int32  _current_debug_TexSheet;

  int32  _num_tex_switches;

  int32  _num_draw_calls;

  bool   _uses_lights;

  GLuint _light_overlay;

  float  _x_shake;
  
  float _y_shake;

  float _gamma_value;

  std::list<private_video::ShakeForce> _shake_forces;

  bool _fullscreen;

  int32  _width;

  int32  _height;

  // changing the video settings does not actually do anything until
  // you call ApplySettings(). Up til that point, store them in temp
  // variables so if the new settings are invalid, we can roll back.

  bool   _temp_fullscreen;

  int32  _temp_width;

  int32  _temp_height;

  GLuint _last_tex_ID;

  std::string _current_font;

  Color       _current_text_color;

  StillImage _default_menu_cursor;

  StillImage _rectangle_image;

  bool _text_shadow;

  Color _fog_color;

  float _fog_intensity;

  Color _light_color;

  bool  _lightning_active;

  int32 _lightning_current_time;

  int32 _lightning_end_time;

  std::vector <float> _lightning_data;

  int32 _animation_counter;

  int32 _current_frame_diff;

  std::map    <std::string, private_video::Image*>   _images;

  std::vector <private_video::TexSheet *>     _tex_sheets;

  std::map    <std::string, FontProperties *> _font_map;

  std::map <std::string, ParticleEffectDef *> _particle_effect_defs;

  std::stack  <private_video::Context>      _context_stack;

  //-- Private methods ------------------------------------------------------

  bool _BindTexture(GLuint tex_ID);

  int32 _ConvertXAlign(int32 xalign);

  int32 _ConvertYAlign(int32 yalign);

  GLuint _CreateBlankGLTexture(int32 width, int32 height);

  std::string _CreateTempFilename(const std::string &extension);

  private_video::TexSheet *_CreateTexSheet(int32 width, int32 height, private_video::TexSheetType type, bool is_static);

  bool _DeleteTexture(GLuint tex_ID);

  bool _DeleteImage(private_video::Image *const image);

  bool _DeleteImage(StillImage &id);

  bool _DeleteImage(AnimatedImage &id);

  bool _DeleteTempTextures();

  bool _DrawElement(const private_video::ImageElement &element, const Color *color_array);

  bool _DrawStillImage(const StillImage &img);

  bool _DrawStillImage(const StillImage &img, const Color &color);

  bool _DrawTextHelper(const uint16 *const uText);

  bool _CacheGlyphs(const uint16 *uText, FontProperties *fp);

  RenderedLine *_GenTexLine(uint16 *line, FontProperties *fp);

  Color _GetTextShadowColor(FontProperties *fp);

  private_video::TexSheet *_InsertImageInTexSheet(private_video::Image *image, private_video::ImageLoadInfo & load_info, bool is_static);

  bool _LoadImage(StillImage &id);

  bool _LoadImage(AnimatedImage &id);

  bool _LoadImageHelper(StillImage &id);


  bool _LoadMultiImage (std::vector <StillImage>& images, const std::string &file_name, const uint32& rows, const uint32& cols);

  bool _LoadRawImage(const std::string & file_name, private_video::ImageLoadInfo & load_info);

  bool _LoadRawImageJpeg(const std::string & file_name, private_video::ImageLoadInfo & load_info);

  bool _LoadRawImagePng(const std::string & file_name, private_video::ImageLoadInfo & load_info);

  bool _SavePng (const std::string& file_name, hoa_video::private_video::ImageLoadInfo &info) const;

  bool _SaveJpeg (const std::string& file_name, hoa_video::private_video::ImageLoadInfo &info) const;

  bool _GetImageInfoPng (const std::string& file_name, uint32 &rows, uint32& cols, uint32& bpp);

  bool _GetImageInfoJpeg (const std::string& file_name, uint32 &rows, uint32& cols, uint32& bpp);

  bool _ReloadImagesToSheet(private_video::TexSheet *tex_sheet);

  bool _RemoveImage(private_video::Image *image_to_remove);

  void _ConvertImageToGrayscale(const private_video::ImageLoadInfo& src, private_video::ImageLoadInfo &dst) const;


  void _RGBAToRGB (const private_video::ImageLoadInfo& src, private_video::ImageLoadInfo &dst) const;



  void _GetBufferFromTexture (hoa_video::private_video::ImageLoadInfo& buffer, hoa_video::private_video::TexSheet* texture) const;


  void _GetBufferFromImage (hoa_video::private_video::ImageLoadInfo& buffer, hoa_video::private_video::Image* img) const;

  bool _RemoveSheet(private_video::TexSheet *sheet_to_remove);

  float _RoundForce(float force);   // rounds a force value

  void _PopContext();

  void _PushContext();

  bool _SaveTempTextures();

  int32 _ScreenCoordX(float x);

  int32 _ScreenCoordY(float y);

  void  _UpdateShake(int32 frame_time);

  bool _ShouldSmooth();

  bool _DEBUG_ShowAdvancedStats();

  bool _DEBUG_ShowTexSheet();

  float _x;
  float _y;
}; // class GameVideo

}  // namespace hoa_video

#endif // __VIDEO_HEADER__

---