Video_DX9.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_DX9_H
#define ZENI_VIDEO_DX9_H

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

#ifndef DISABLE_DX9

typedef enum _D3DFORMAT D3DFORMAT;
typedef enum _D3DPOOL D3DPOOL;
typedef struct _D3DCAPS9 D3DCAPS9, *LPD3DCAPS9;
typedef struct _D3DPRESENT_PARAMETERS_ D3DPRESENT_PARAMETERS, *LPD3DPRESENT_PARAMETERS;
typedef struct ID3DXMatrixStack *LPD3DXMATRIXSTACK;
typedef struct ID3DXRenderToSurface *LPD3DXRENDERTOSURFACE;
typedef struct IDirect3D9 *LPDIRECT3D9;
typedef struct IDirect3DBaseTexture9 *LPDIRECT3DBASETEXTURE9;
typedef struct IDirect3DDevice9 *LPDIRECT3DDEVICE9;
typedef struct IDirect3DSurface9 *LPDIRECT3DSURFACE9;
typedef struct IDirect3DTexture9 *LPDIRECT3DTEXTURE9;
typedef struct tagPALETTEENTRY PALETTEENTRY;
typedef struct _D3DXMACRO D3DXMACRO, *LPD3DXMACRO;
typedef struct ID3DXInclude *LPD3DXINCLUDE;
typedef struct ID3DXBuffer *LPD3DXBUFFER;
typedef struct ID3DXConstantTable *LPD3DXCONSTANTTABLE;

namespace Zeni {

  struct Color;
  class Texture_DX9;

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

    Video_DX9();
    ~Video_DX9();

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

  public:
    typedef LPDIRECT3D9 (WINAPI *Direct3DCreate9_fcn)(UINT SDKVersion);
    typedef HRESULT (WINAPI *D3DXCreateRenderToSurface_fcn)(
      LPDIRECT3DDEVICE9       pDevice,
      UINT                    Width,
      UINT                    Height,
      D3DFORMAT               Format,
      BOOL                    DepthStencil,
      D3DFORMAT               DepthStencilFormat,
      LPD3DXRENDERTOSURFACE*  ppRenderToSurface);
    typedef HRESULT (WINAPI *D3DXCreateTexture_fcn)(
      LPDIRECT3DDEVICE9         pDevice,
      UINT                      Width,
      UINT                      Height,
      UINT                      MipLevels,
      DWORD                     Usage,
      D3DFORMAT                 Format,
      D3DPOOL                   Pool,
      LPDIRECT3DTEXTURE9*       ppTexture);
    typedef HRESULT (WINAPI *D3DXFilterTexture_fcn)(
      LPDIRECT3DBASETEXTURE9    pBaseTexture,
      CONST PALETTEENTRY*       pPalette,
      UINT                      SrcLevel,
      DWORD                     Filter);
    typedef HRESULT (WINAPI *D3DXCreateMatrixStack_fcn)(
      DWORD               Flags, 
      LPD3DXMATRIXSTACK*  ppStack);
    typedef HRESULT (WINAPI *D3DXCompileShader_fcn)(
      LPCSTR               pSrcData,
      UINT                 srcDataLen,
      const D3DXMACRO      *pDefines,
      LPD3DXINCLUDE        pInclude,
      LPCSTR               pFunctionName,
      LPCSTR               pProfile,
      DWORD                Flags,
      LPD3DXBUFFER        *ppShader,
      LPD3DXBUFFER        *ppErrorMsgs,
      LPD3DXCONSTANTTABLE *ppConstantTable);

    // DLL Functions
    static Direct3DCreate9_fcn Direct3DCreate9() {return g_Direct3DCreate9;}
    static D3DXCreateRenderToSurface_fcn D3DXCreateRenderToSurface() {return g_D3DXCreateRenderToSurface;}
    static D3DXCreateTexture_fcn D3DXCreateTexture() {return g_D3DXCreateTexture;}
    static D3DXFilterTexture_fcn D3DXFilterTexture() {return g_D3DXFilterTexture;}
    static D3DXCreateMatrixStack_fcn D3DXCreateMatrixStack() {return g_D3DXCreateMatrixStack;}
    static D3DXCompileShader_fcn D3DXCompileShader() {return g_D3DXCompileShader;}

    // 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) {Video::set_clear_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(); 

    // D3D-Related Functions
    const D3DCAPS9 & get_d3d_capabilities(); 
    const D3DPRESENT_PARAMETERS & get_d3d_parameters(); 
    inline LPDIRECT3D9 & get_d3d(); 
    inline LPDIRECT3DDEVICE9 & get_d3d_device(); 
    inline LPD3DXMATRIXSTACK & get_matrix_stack(); 
    inline const int & get_dpi(); 
    inline float get_dpi_ratio(); 

    // Custom D3D-Related Functions
    bool is_fvf_3d() const;
    void set_fvf_3d(const bool &on);
    void set_fvf(const bool &is_3d);

  protected:
    void init();
    bool init_device();
    void init_context();
    void destroy_device();

  private:
    void zero_handles();

    HMODULE m_d3d9;
    static Direct3DCreate9_fcn g_Direct3DCreate9;

    HMODULE m_d3dx9;
    static D3DXCreateRenderToSurface_fcn g_D3DXCreateRenderToSurface;
    static D3DXCreateTexture_fcn g_D3DXCreateTexture;
    static D3DXFilterTexture_fcn g_D3DXFilterTexture;
    static D3DXCreateMatrixStack_fcn g_D3DXCreateMatrixStack;
    static D3DXCompileShader_fcn g_D3DXCompileShader;

    void set_fvf();

    LPD3DCAPS9 m_d3d_capabilities;
    LPD3DPRESENT_PARAMETERS m_d3d_parameters;

    LPDIRECT3D9 m_d3d;
    LPDIRECT3DDEVICE9 m_d3d_device;
    LPD3DXMATRIXSTACK m_matrix_stack;
    int m_dpi;
    bool m_begun_render;

    bool m_textured, m_fvf_3d;

    Texture_DX9 * m_render_target;
    ID3DXRenderToSurface * m_render_to_surface;
    LPDIRECT3DSURFACE9 m_back_buffer;
  };

  struct ZENI_GRAPHICS_DLL Video_Device_Failure : public std::exception {
    Video_Device_Failure() : std::exception("Zeni Video Device Failed") {}
  };

}

#endif

#endif