Video.h

Go to the documentation of this file.

/* This file is part of the Zenipex Library (zenilib).
 * Copyright (C) 2011 Mitchell Keith Bloch (bazald).
 *
 * zenilib is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * zenilib 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with zenilib.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef ZENI_VIDEO_H
#define ZENI_VIDEO_H

#include <Zeni/Core.h>
#include <Zeni/Color.h>
#include <Zeni/Coordinate.h>
#include <Zeni/Matrix4f.h>
#include <Zeni/Singleton.h>
#include <Zeni/String.h>

#include <SDL/SDL.h>
#include <cmath>
#include <vector>

typedef void* ShHandle;

namespace Zeni {

  class Camera;
  struct Fog;
  class Font;
  struct Light;
  class Material;
  class Program;
  class Renderable;
  class Shader;
  class Texture;
  class Vertex_Buffer;
  class Vertex_Buffer_Renderer;
  class Video;
  class XML_Document;

#ifdef _WINDOWS
  ZENI_GRAPHICS_EXT template class ZENI_GRAPHICS_DLL Singleton<Video>;
#endif

  class ZENI_GRAPHICS_DLL Video : public Singleton<Video> {
    friend class Singleton<Video>;

    static Video * create();

#ifdef _WINDOWS
#pragma warning( push )
#pragma warning( disable : 4251 )
#endif
    static Uninit g_uninit;
    static Reinit g_reinit;
#ifdef _WINDOWS
#pragma warning( pop )
#endif

  protected:
    Video();
    virtual ~Video() = 0;

  private:
    // Undefined
    Video(const Video &);
    Video & operator=(const Video &);

  public:
    enum VIDEO_MODE {ZENI_VIDEO_ANY, ZENI_VIDEO_GL_FIXED, ZENI_VIDEO_DX9, ZENI_VIDEO_GL_SHADER};

    enum TEST {ZENI_NEVER = 0,
               ZENI_LESS = 1,
               ZENI_EQUAL = 2,
               ZENI_GREATER = 4,
               ZENI_NOT_EQUAL = 8,
               ZENI_LESS_OR_EQUAL = 3,
               ZENI_GREATER_OR_EQUAL = 6,
               ZENI_ALWAYS = 15};

    // Rendering functions
    virtual bool begin_prerender() = 0; 
    virtual bool begin_render() = 0; 
    virtual void end_render() = 0; 
    virtual void render(const Renderable &renderable) = 0; 
    virtual void clear_depth_buffer() = 0; 

    // Accessors
    inline static VIDEO_MODE get_video_mode(); 
    inline static bool get_backface_culling(); 
    inline static bool get_lighting(); 
    inline static const Color & get_ambient_lighting(); 
    inline static bool get_normal_interpolation(); 
    inline static bool get_vertical_sync(); 
    inline static int get_multisampling(); 
    virtual int get_maximum_anisotropy() const = 0; 
    virtual bool has_vertex_buffers() const = 0; 
    inline bool is_zwrite_enabled() const; 
    inline bool is_ztest_enabled() const; 
    inline bool is_alpha_test_enabled() const; 
    inline TEST get_alpha_test_function() const; 
    inline float get_alpha_test_value() const; 
    inline bool is_3d() const; 
    inline ShHandle get_vertex_shader_compiler() const; 
    inline ShHandle get_fragment_shader_compiler() const; 

    // Modifiers
    inline void set_2d(); 
    inline void set_2d(const std::pair<Point2f, Point2f> &camera2d,
                       const bool &fix_aspect_ratio = false); 
    inline void set_3d(const Camera &camera); 
    virtual void set_2d_view(const std::pair<Point2f, Point2f> &camera2d,
      const std::pair<Point2i, Point2i> &viewport = std::make_pair(Point2i(), get().get_render_target_size()),
      const bool &fix_aspect_ratio = false) = 0; 
    virtual void set_3d_view(const Camera &camera, const std::pair<Point2i, Point2i> &viewport =
      std::make_pair(Point2i(), get().get_render_target_size())) = 0; 
    virtual void set_backface_culling(const bool &on) = 0; 
    virtual void set_vertical_sync(const bool &on) = 0; 
    virtual void set_zwrite(const bool &enabled) = 0; 
    virtual void set_ztest(const bool &enabled) = 0; 
    virtual void set_alpha_test(const bool &enabled, const TEST &test = ZENI_ALWAYS, const float &value = 0.0f) = 0; 

    // Color and Texturing
    inline const Color & get_Color() const; 
    inline const Color & get_clear_Color() const; 
    virtual void set_Color(const Color &color) = 0; 
    virtual void set_clear_Color(const Color &color) = 0; 
    inline void apply_Texture(const String &name); 
    virtual void apply_Texture(const unsigned long &id) = 0; 
    virtual void apply_Texture(const Texture &texture) = 0; 
    virtual void unapply_Texture() = 0; 

    // Lighting and Materials
    virtual void set_lighting(const bool &on = true) = 0; 
    virtual void set_ambient_lighting(const Color &color) = 0; 
    const Light * get_Light(const int &number) const; 
    virtual void set_Light(const int &number, const Light &light) = 0; 
    virtual void unset_Light(const int &number) = 0; 
    virtual void set_Material(const Material &material) = 0; 
    virtual void unset_Material(const Material &material) = 0; 

    // Fog
    const Fog * get_Fog() const; 
    virtual void set_Fog(const Fog &fog) = 0; 
    virtual void unset_Fog() = 0; 

    // Shaders
    virtual void set_program(Program &program) = 0; 
    virtual void unset_program() = 0; 

    // Render-to-texture
    virtual void set_render_target(Texture &texture) = 0; 
    virtual void unset_render_target() = 0; 
    virtual void clear_render_target(const Color &color = Color(0.0f, 0.0f, 0.0f, 0.0f)) = 0; 
    virtual const Point2i & get_render_target_size() const = 0; 

    // Model/World Transformation Stack Functions
    virtual void select_world_matrix() = 0; 
    virtual void push_world_stack() = 0; 
    virtual void pop_world_stack() = 0; 
    virtual void translate_scene(const Vector3f &direction) = 0; 
    virtual void rotate_scene(const Vector3f &about, const float &radians) = 0; 
    inline void rotate_scene(const Quaternion &rotation); 
    virtual void scale_scene(const Vector3f &factor) = 0; 
    virtual void transform_scene(const Matrix4f &transformation) = 0; 

    // View+Projection Matrix Functions
    virtual Point2f get_pixel_offset() const = 0; 
    inline const Matrix4f & get_view_matrix() const; 
    inline const Matrix4f & get_projection_matrix() const; 
    inline const std::pair<Point2i, Point2i> & get_viewport() const; 
    virtual void set_view_matrix(const Matrix4f &view) = 0; 
    virtual void set_projection_matrix(const Matrix4f &projection) = 0; 
    virtual void set_viewport(const std::pair<Point2i, Point2i> &viewport =
      std::make_pair(Point2i(), get().get_render_target_size())) = 0; 
    void set_viewport(const float &aspect_ratio,
      const std::pair<Point2i, Point2i> &viewport =
      std::make_pair(Point2i(), get().get_render_target_size())); 
    std::pair<Point2i, Point2i> calculate_viewport(const std::pair<Point2f, Point2f> &camera2d,
      const std::pair<Point2i, Point2i> &viewport,
      const bool &fix_aspect_ratio); 
    std::pair<Point2i, Point2i> calculate_viewport(const float &aspect_ratio,
      const std::pair<Point2i, Point2i> &viewport =
      std::make_pair(Point2i(), get().get_render_target_size())) const; 

    // Creation Functions
    virtual Texture * load_Texture(const String &filename, const bool &repeat, const bool &lazy_loading = false) = 0; 
    virtual Texture * create_Texture(const Image &image) = 0; 
    virtual Texture * create_Texture(const Point2i &size, const bool &repeat) = 0; 
    virtual Font * create_Font(const String &filename, 
      const float &glyph_height, const float &virtual_screen_height) = 0; 
    virtual Vertex_Buffer_Renderer * create_Vertex_Buffer_Renderer(Vertex_Buffer &vertex_buffer) = 0; 
    virtual Shader * create_Vertex_Shader(const String &filename) = 0; 
    virtual Shader * create_Fragment_Shader(const String &filename) = 0; 
    virtual Program * create_Program() = 0; 

    // Call before any other Video functions; May throw Video_Initialized
    static void preinit_video_mode(const VIDEO_MODE &vm = ZENI_VIDEO_ANY); 
    static void preinit_multisampling(const int &multisampling = 0); 
    static void preinit_vertical_sync(const bool &vertical_sync = false); 
    static void preinit_from_file(const String &filename); 
    static void preinit_from_file(const XML_Document &file); 

    // Re/uninitialize the Rendering Device
    static void change_resolution(const Point2i &resolution);
#ifndef ANDROID
    static void save(const bool &backup = true); 
    static bool revert(); 
    static void set_failsafe_defaults(); 

    static void print_errors(); 
#endif
    
  protected:
    String compile_glsles_shader(const String &filename, const ShHandle &compiler); 

    ShHandle m_vertex_compiler;
    ShHandle m_fragment_compiler;

  private:
    static VIDEO_MODE g_video_mode;

    static bool g_backface_culling;
    static bool g_lighting;
    static Color g_ambient_lighting;
#ifdef _WINDOWS
#pragma warning( push )
#pragma warning( disable : 4251 )
#endif
    static Unordered_Map<int, Light> g_lights;
    static Fog g_fog;
#ifdef _WINDOWS
#pragma warning( pop )
#endif
    static bool g_fog_enabled;
    static Color g_clear_color;
    static bool g_normal_interp;
    static bool g_vertical_sync;
    static int g_multisampling;

    Color m_color;

    const Matrix4f m_preview;
    Matrix4f m_view;
    Matrix4f m_projection;
#ifdef _WINDOWS
#pragma warning( push )
#pragma warning( disable : 4251 )
#endif
    std::pair<Point2i, Point2i> m_viewport;
#ifdef _WINDOWS
#pragma warning( pop )
#endif

    static bool g_zwrite;
    static bool g_ztest;

    bool m_alpha_test;
    TEST m_alpha_function;
    float m_alpha_value;

    bool m_3d;
  };

  ZENI_GRAPHICS_DLL Video & get_Video(); 

  struct ZENI_GRAPHICS_DLL Video_Init_Failure : public Error {
    Video_Init_Failure() : Error("Zeni Video Failed to Initialize Correctly") {}
  };

  struct ZENI_GRAPHICS_DLL Light_Out_of_Range : public Error {
    Light_Out_of_Range() : Error("Light Set Out of Range [0,7]") {}
  };

  struct ZENI_GRAPHICS_DLL Video_Render_To_Texture_Error : public Error {
    Video_Render_To_Texture_Error() : Error("Zeni Video Render To Texture Encountered An Error") {}
  };

  struct ZENI_GRAPHICS_DLL GLSL_ES_Shader_Compilation_Failure : public Error {
    GLSL_ES_Shader_Compilation_Failure() : Error("GLSL ES Shader failed to compile") {}
  };

}

#endif