Video_GL_Shader.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_GL_SHADER_H
#define ZENI_VIDEO_GL_SHADER_H

#include <Zeni/Timer.h>
#include <Zeni/Video.h>

#ifndef DISABLE_GL

#if defined(REQUIRE_GL_ES)
#include <GLES/gl.h>
#define GL_ARRAY_BUFFER_ARB GL_ARRAY_BUFFER
#define GL_STATIC_DRAW_ARB GL_STATIC_DRAW
#define glBindFramebufferEXT glBindFramebuffer
#define glBindRenderbufferEXT glBindRenderbuffer
#define glFogi glFogx
#define glFramebufferRenderbufferEXT glFramebufferRenderbuffer
#define glFramebufferTexture2DEXT glFramebufferTexture2D
#define glGenFramebuffersEXT glGenFramebuffers
#define glGenRenderbuffersEXT glGenRenderbuffers
#define glRenderbufferStorageEXT glRenderbufferStorage
#else
#include <GL/glew.h>
#ifdef _LINUX
namespace GLXEW {
struct _XDisplay;
typedef _XDisplay Display;
typedef long unsigned int XID;
typedef XID GLXDrawable;
typedef void ( * PFNGLXSWAPINTERVALEXTPROC) (Display* dpy, GLXDrawable drawable, int interval);
typedef int ( * PFNGLXSWAPINTERVALSGIPROC) (int interval);
}
#endif
#endif

namespace Zeni {

  class Texture_GL;

  class ZENI_GRAPHICS_DLL Video_GL_Shader : public Video {
    friend class Video;
    friend ZENI_GRAPHICS_DLL Video & get_Video();

    Video_GL_Shader();
    ~Video_GL_Shader();

    // Undefined
    Video_GL_Shader(const Video_GL_Shader &);
    Video_GL_Shader & operator=(const Video_GL_Shader &);

  public:
    // Rendering functions
    bool begin_prerender(); 
    bool begin_render(); 
    void end_render(); 
    void render(const Renderable &renderable); 
    void clear_depth_buffer(); 

    // Accessors
    int get_maximum_anisotropy() const; 
    bool has_vertex_buffers() const; 

    // Modifiers
    void set_2d_view(const std::pair<Point2f, Point2f> & /*camera2d*/,
      const std::pair<Point2i, Point2i> & /*viewport*/ = std::make_pair(Point2i(), get_Video().get_render_target_size()),
      const bool &fix_aspect_ratio = false); 
    void set_3d_view(const Camera & /*camera*/,
      const std::pair<Point2i, Point2i> & /*viewport*/ = std::make_pair(Point2i(), get_Video().get_render_target_size())); 
    void set_backface_culling(const bool &on); 
    void set_vertical_sync(const bool &on); 
    void set_zwrite(const bool &enabled); 
    void set_ztest(const bool &enabled); 
    void set_alpha_test(const bool &enabled, const TEST &test, const float &value); 

    // Color and Texturing
    void set_Color(const Color &color); 
    void set_clear_Color(const Color &color); 
    inline void apply_Texture(const String &name) {return Video::apply_Texture(name);} 
    void apply_Texture(const unsigned long &id); 
    void apply_Texture(const Texture &texture); 
    void unapply_Texture(); 

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

    // Fog
    void set_Fog(const Fog &fog); 
    void unset_Fog(); 

    // Shaders
    void set_program(Program &program); 
    void unset_program(); 

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

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

    // View+Projection Matrix Functions
    Point2f get_pixel_offset() const; 
    void set_view_matrix(const Matrix4f &view); 
    void set_projection_matrix(const Matrix4f &projection); 
    void set_viewport(const std::pair<Point2i, Point2i> &viewport =
      std::make_pair(Point2i(), get_Video().get_render_target_size())); 

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

#if SDL_VERSION_ATLEAST(1,3,0)
    virtual void alert_window_destroyed(); 
#endif

  protected:
    void init();
    void uninit();

  private:
#if SDL_VERSION_ATLEAST(1,3,0)
    SDL_GLContext m_context;
#endif

#if !defined(REQUIRE_GL_ES) && defined(_LINUX)
    GLXEW::PFNGLXSWAPINTERVALEXTPROC m_pglSwapIntervalEXT;
    GLXEW::PFNGLXSWAPINTERVALSGIPROC m_pglSwapIntervalSGI;
#endif

    int m_maximum_anisotropy;
    bool m_zwrite;

    Texture_GL * m_render_target;

#ifdef MANUAL_GL_VSYNC_DELAY
    Zeni::Time m_buffer_swap_end_time;
    float m_time_taken;
    float m_weight_new;
#endif
  };

}

#endif

#endif