lolengine
/
lol
spegling av https://github.com/lolengine/lol
1
0
Förgrening 0
Kod Ärenden 0 Släpp 0 Wiki Aktiviteter
1738 Incheckningar
5 Grenar
18 MiB
 
 
 
Träd: 1b157def49
lol/src/gpu/renderer.cpp

732 rader
19 KiB
Rå Blame Historik 

  1. //

  2. // Lol Engine

  3. //

  4. // Copyright: (c) 2010-2013 Sam Hocevar <sam@hocevar.net>

  5. //   This program is free software; you can redistribute it and/or

  6. //   modify it under the terms of the Do What The Fuck You Want To

  7. //   Public License, Version 2, as published by Sam Hocevar. See

  8. //   http://www.wtfpl.net/ for more details.

  9. //

  10. 

  11. #if defined HAVE_CONFIG_H

  12. #   include "config.h"

  13. #endif

  14. 

  15. #include <cstdlib>

  16. 

  17. #if defined _XBOX

  18. #   include <xtl.h>

  19. #   undef near /* Fuck Microsoft */

  20. #   undef far /* Fuck Microsoft again */

  21. #elif defined _WIN32

  22. #   if defined USE_D3D9

  23. #      include <d3d9.h>

  24. #   endif

  25. #   define WIN32_LEAN_AND_MEAN

  26. #   include <windows.h>

  27. #   undef near /* Fuck Microsoft */

  28. #   undef far /* Fuck Microsoft again */

  29. #endif

  30. 

  31. #include "core.h"

  32. #include "lolgl.h"

  33. 

  34. /* FIXME: find a way to pass g_hwnd from the windowing system */

  35. #if defined USE_D3D9

  36. extern HWND g_hwnd;

  37. #elif defined _XBOX

  38. HWND g_hwnd = 0;

  39. #endif

  40. 

  41. namespace lol

  42. {

  43. 

  44. /*

  45.  * The global g_renderer object, initialised by Video::Init

  46.  */

  47. 

  48. Renderer *g_renderer = nullptr;

  49. 

  50. /*

  51.  * Private RendererData class

  52.  */

  53. 

  54. class RendererData

  55. {

  56.     friend class Renderer;

  57. 

  58. private:

  59.     ibox2 m_viewport;

  60.     vec4 m_clear_color;

  61.     float m_clear_depth;

  62.     AlphaFunc m_alpha_func;

  63.     float m_alpha_value;

  64.     BlendFunc m_blend_src, m_blend_dst;

  65.     DepthFunc m_depth_func;

  66.     DepthMask m_depth_mask;

  67.     CullMode m_cull_mode;

  68.     PolygonMode m_polygon_mode;

  69. 

  70. private:

  71. #if defined USE_D3D9

  72.     IDirect3D9 *m_d3d_ctx;

  73.     IDirect3DDevice9 *m_d3d_dev;

  74. #elif defined _XBOX

  75.     Direct3D *m_d3d_ctx;

  76.     D3DDevice *m_d3d_dev;

  77. #endif

  78. };

  79. 

  80. /*

  81.  * Public Renderer class

  82.  */

  83. 

  84. Renderer::Renderer(ivec2 size)

  85.   : m_data(new RendererData())

  86. {

  87. #if defined USE_D3D9 || defined _XBOX

  88.     /* Create Direct3D context */

  89.     m_data->m_d3d_ctx = Direct3DCreate9(D3D_SDK_VERSION);

  90.     if (!m_data->m_d3d_ctx)

  91.     {

  92.         Log::Error("cannot initialise D3D\n");

  93.         exit(EXIT_FAILURE);

  94.     }

  95. 

  96.     /* Create Direct3D device */

  97. #   if defined _XBOX

  98.     XVIDEO_MODE VideoMode;

  99.     XGetVideoMode(&VideoMode);

  100.     size = lol::min(size, ivec2(VideoMode.dwDisplayWidth,

  101.                                 VideoMode.dwDisplayHeight));

  102. #   endif

  103.     D3DPRESENT_PARAMETERS d3dpp;

  104.     memset(&d3dpp, 0, sizeof(d3dpp));

  105.     d3dpp.BackBufferWidth = size.x;

  106.     d3dpp.BackBufferHeight = size.y;

  107.     d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;

  108.     d3dpp.BackBufferCount = 1;

  109.     d3dpp.hDeviceWindow = g_hwnd;

  110. #   if defined USE_SDL

  111.     d3dpp.Windowed = TRUE;

  112. #   endif

  113.     d3dpp.EnableAutoDepthStencil = TRUE;

  114.     d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;

  115.     d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;

  116.     d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;

  117. 

  118.     HRESULT hr = m_data->m_d3d_ctx->CreateDevice(0, D3DDEVTYPE_HAL, g_hwnd,

  119.                                                  D3DCREATE_HARDWARE_VERTEXPROCESSING,

  120.                                                  &d3dpp, &m_data->m_d3d_dev);

  121.     if (FAILED(hr))

  122.     {

  123.         Log::Error("cannot create D3D device\n");

  124.         exit(EXIT_FAILURE);

  125.     }

  126. 

  127. #else

  128. #   if defined USE_GLEW && !defined __APPLE__

  129.     /* Initialise GLEW if necessary */

  130.     GLenum glerr = glewInit();

  131.     if (glerr != GLEW_OK)

  132.     {

  133.         Log::Error("cannot initialise GLEW: %s\n", glewGetErrorString(glerr));

  134.         exit(EXIT_FAILURE);

  135.     }

  136. #   endif

  137. #endif

  138. 

  139.     /* Initialise rendering states */

  140.     m_data->m_viewport = ibox2(0, 0, 0, 0);

  141.     SetViewport(ibox2(vec2(0), size));

  142. 

  143.     m_data->m_clear_color = vec4(-1.f);

  144.     SetClearColor(vec4(0.1f, 0.2f, 0.3f, 1.0f));

  145. 

  146.     m_data->m_clear_depth = -1.f;

  147.     SetClearDepth(1.f);

  148. 

  149.     m_data->m_alpha_func = AlphaFunc::Never;

  150.     m_data->m_alpha_value = -1.0f;

  151.     SetAlphaFunc(AlphaFunc::Disabled, 0.0f);

  152. 

  153.     m_data->m_blend_src = BlendFunc::Disabled;

  154.     m_data->m_blend_dst = BlendFunc::Disabled;

  155.     SetBlendFunc(BlendFunc::SrcAlpha, BlendFunc::OneMinusSrcAlpha);

  156. 

  157.     m_data->m_depth_func = DepthFunc::Disabled;

  158.     SetDepthFunc(DepthFunc::LessOrEqual);

  159. 

  160.     m_data->m_depth_mask = DepthMask::Disabled;

  161.     SetDepthMask(DepthMask::Enabled);

  162. 

  163.     m_data->m_cull_mode = CullMode::Disabled;

  164.     SetCullMode(CullMode::Clockwise);

  165. 

  166.     m_data->m_polygon_mode = PolygonMode::Point;

  167.     SetPolygonMode(PolygonMode::Fill);

  168. 

  169.     /* Add some rendering states that we don't export to the user */

  170. #if defined USE_D3D9 || defined _XBOX

  171.     /* TODO */

  172. #else

  173. #   if defined HAVE_GL_2X && !defined __APPLE__

  174.     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

  175. #   endif

  176. #endif

  177. }

  178. 

  179. Renderer::~Renderer()

  180. {

  181.     delete m_data;

  182. }

  183. 

  184. void *Renderer::GetDevice()

  185. {

  186. #if defined USE_D3D9 || defined _XBOX

  187.     return m_data->m_d3d_dev;

  188. #else

  189.     return nullptr;

  190. #endif

  191. }

  192. 

  193. /*

  194.  * Buffer clearing

  195.  */

  196. 

  197. void Renderer::Clear(ClearMask mask)

  198. {

  199. #if defined USE_D3D9 || defined _XBOX

  200.     int m = 0;

  201.     if (mask & ClearMask::Color)

  202.         m |= D3DCLEAR_TARGET;

  203.     if (mask & ClearMask::Depth)

  204.         m |= D3DCLEAR_ZBUFFER;

  205.     if (mask & ClearMask::Stencil)

  206.         m |= D3DCLEAR_STENCIL;

  207. 

  208.     vec3 tmp = 255.999f * GetClearColor().rgb;

  209.     D3DCOLOR clear_color = D3DCOLOR_XRGB((int)tmp.r, (int)tmp.g, (int)tmp.b);

  210. 

  211.     if (FAILED(m_data->m_d3d_dev->Clear(0, nullptr, m, clear_color,

  212.                                         GetClearDepth(), 0)))

  213.         Abort();

  214. #else

  215.     GLbitfield m = 0;

  216.     if (mask & ClearMask::Color)

  217.         m |= GL_COLOR_BUFFER_BIT;

  218.     if (mask & ClearMask::Depth)

  219.         m |= GL_DEPTH_BUFFER_BIT;

  220.     if (mask & ClearMask::Stencil)

  221.         m |= GL_STENCIL_BUFFER_BIT;

  222.     glClear(m);

  223. #endif

  224. }

  225. 

  226. /*

  227.  * Viewport dimensions

  228.  */

  229. 

  230. void Renderer::SetViewport(ibox2 viewport)

  231. {

  232.     if (m_data->m_viewport == viewport)

  233.         return;

  234. 

  235. #if defined USE_D3D9 || defined _XBOX

  236.     D3DVIEWPORT9 vp = { viewport.A.x, viewport.A.y,

  237.                         viewport.B.x, viewport.B.y,

  238.                         0.0f, 1.0f };

  239.     m_data->m_d3d_dev->SetViewport(&vp);

  240. #else

  241.     glViewport(viewport.A.x, viewport.A.y, viewport.B.x, viewport.B.y);

  242. #endif

  243. 

  244.     m_data->m_viewport = viewport;

  245. }

  246. 

  247. ibox2 Renderer::GetViewport() const

  248. {

  249.     return m_data->m_viewport;

  250. }

  251. 

  252. /*

  253.  * Clear color

  254.  */

  255. 

  256. void Renderer::SetClearColor(vec4 color)

  257. {

  258.     if (m_data->m_clear_color == color)

  259.         return;

  260. 

  261. #if defined USE_D3D9 || defined _XBOX

  262.     /* Nothing to do */

  263. #else

  264.     glClearColor(color.r, color.g, color.b, color.a);

  265. #endif

  266. 

  267.     m_data->m_clear_color = color;

  268. }

  269. 

  270. vec4 Renderer::GetClearColor() const

  271. {

  272.     return m_data->m_clear_color;

  273. }

  274. 

  275. /*

  276.  * Clear depth

  277.  */

  278. 

  279. void Renderer::SetClearDepth(float depth)

  280. {

  281.     if (m_data->m_clear_depth == depth)

  282.         return;

  283. 

  284. #if defined USE_D3D9 || defined _XBOX

  285.     /* Nothing to do */

  286. #elif defined HAVE_GLES_2X

  287.     glClearDepthf(depth);

  288. #else

  289.     glClearDepth(depth);

  290. #endif

  291. 

  292.     m_data->m_clear_depth = depth;

  293. }

  294. 

  295. float Renderer::GetClearDepth() const

  296. {

  297.     return m_data->m_clear_depth;

  298. }

  299. 

  300. /*

  301.  * Alpha testing

  302.  */

  303. 

  304. void Renderer::SetAlphaFunc(AlphaFunc func, float alpha)

  305. {

  306.     if (m_data->m_alpha_func == func && m_data->m_alpha_value == alpha)

  307.         return;

  308. 

  309. #if defined USE_D3D9 || defined _XBOX

  310.     switch (func)

  311.     {

  312.         case AlphaFunc::Disabled:

  313.             break; /* Nothing to do */

  314.         case AlphaFunc::Never:

  315.             m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_NEVER);

  316.             break;

  317.         case AlphaFunc::Less:

  318.             m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_LESS);

  319.             break;

  320.         case AlphaFunc::Equal:

  321.             m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_EQUAL);

  322.             break;

  323.         case AlphaFunc::LessOrEqual:

  324.             m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_LESSEQUAL);

  325.             break;

  326.         case AlphaFunc::Greater:

  327.             m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATER);

  328.             break;

  329.         case AlphaFunc::NotEqual:

  330.             m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_NOTEQUAL);

  331.             break;

  332.         case AlphaFunc::GreaterOrEqual:

  333.             m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL);

  334.             break;

  335.         case AlphaFunc::Always:

  336.             m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_ALWAYS);

  337.             break;

  338.     }

  339. 

  340.     if (func == AlphaFunc::Disabled)

  341.     {

  342.         m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);

  343.     }

  344.     else

  345.     {

  346.         m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);

  347.         m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAREF,

  348.                                           (DWORD)(alpha * 255.999f));

  349.     }

  350. #elif defined GL_VERSION_1_1

  351.     switch (func)

  352.     {

  353.         case AlphaFunc::Disabled:

  354.             break; /* Nothing to do */

  355.         case AlphaFunc::Never:

  356.             glAlphaFunc(GL_NEVER, alpha); break;

  357.         case AlphaFunc::Less:

  358.             glAlphaFunc(GL_LESS, alpha); break;

  359.         case AlphaFunc::Equal:

  360.             glAlphaFunc(GL_EQUAL, alpha); break;

  361.         case AlphaFunc::LessOrEqual:

  362.             glAlphaFunc(GL_LEQUAL, alpha); break;

  363.         case AlphaFunc::Greater:

  364.             glAlphaFunc(GL_GREATER, alpha); break;

  365.         case AlphaFunc::NotEqual:

  366.             glAlphaFunc(GL_NOTEQUAL, alpha); break;

  367.         case AlphaFunc::GreaterOrEqual:

  368.             glAlphaFunc(GL_GEQUAL, alpha); break;

  369.         case AlphaFunc::Always:

  370.             glAlphaFunc(GL_ALWAYS, alpha); break;

  371.     }

  372. 

  373.     if (func == AlphaFunc::Disabled)

  374.         glDisable(GL_ALPHA_TEST);

  375.     else

  376.         glEnable(GL_ALPHA_TEST);

  377. #else

  378.     /* XXX: alpha test not available in GL ES and deprecated anyway. */

  379. #endif

  380. 

  381.     m_data->m_alpha_func = func;

  382.     m_data->m_alpha_value = alpha;

  383. }

  384. 

  385. AlphaFunc Renderer::GetAlphaFunc() const

  386. {

  387.     return m_data->m_alpha_func;

  388. }

  389. 

  390. float Renderer::GetAlphaValue() const

  391. {

  392.     return m_data->m_alpha_value;

  393. }

  394. 

  395. /*

  396.  * Blend function

  397.  */

  398. 

  399. void Renderer::SetBlendFunc(BlendFunc src, BlendFunc dst)

  400. {

  401.     if (m_data->m_blend_src == src && m_data->m_blend_dst == dst)

  402.         return;

  403. 

  404. #if defined USE_D3D9 || defined _XBOX

  405.     D3DBLEND s1[2] = { D3DBLEND_ONE, D3DBLEND_ZERO };

  406.     BlendFunc s2[2] = { src, dst };

  407. 

  408.     for (int i = 0; i < 2; ++i)

  409.     {

  410.         switch (s2[i])

  411.         {

  412.             case BlendFunc::Disabled:

  413.                 break; /* Nothing to do */

  414.             case BlendFunc::Zero:

  415.                 s1[i] = D3DBLEND_ZERO; break;

  416.             case BlendFunc::One:

  417.                 s1[i] = D3DBLEND_ONE; break;

  418.             case BlendFunc::SrcColor:

  419.                 s1[i] = D3DBLEND_SRCCOLOR; break;

  420.             case BlendFunc::OneMinusSrcColor:

  421.                 s1[i] = D3DBLEND_INVSRCCOLOR; break;

  422.             case BlendFunc::DstColor:

  423.                 s1[i] = D3DBLEND_DESTCOLOR; break;

  424.             case BlendFunc::OneMinusDstColor:

  425.                 s1[i] = D3DBLEND_INVDESTCOLOR; break;

  426.             case BlendFunc::SrcAlpha:

  427.                 s1[i] = D3DBLEND_SRCALPHA; break;

  428.             case BlendFunc::OneMinusSrcAlpha:

  429.                 s1[i] = D3DBLEND_INVSRCALPHA; break;

  430.             case BlendFunc::DstAlpha:

  431.                 s1[i] = D3DBLEND_DESTALPHA; break;

  432.             case BlendFunc::OneMinusDstAlpha:

  433.                 s1[i] = D3DBLEND_INVDESTALPHA; break;

  434.             /* FiXME: these can be supported using D3DPBLENDCAPS_BLENDFACTOR */

  435.             case BlendFunc::ConstantColor:

  436.                 ASSERT(0, "BlendFunc::ConstantColor not supported");

  437.                 break;

  438.             case BlendFunc::OneMinusConstantColor:

  439.                 ASSERT(0, "BlendFunc::OneMinusConstantColor not supported");

  440.                 break;

  441.             case BlendFunc::ConstantAlpha:

  442.                 ASSERT(0, "BlendFunc::ConstantAlpha not supported");

  443.                 break;

  444.             case BlendFunc::OneMinusConstantAlpha:

  445.                 ASSERT(0, "BlendFunc::OneMinusConstantAlpha not supported");

  446.                 break;

  447.         }

  448.     }

  449. 

  450.     if (src == BlendFunc::Disabled)

  451.     {

  452.         m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHABLENDENABLE, 0);

  453.     }

  454.     else

  455.     {

  456.         m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHABLENDENABLE, 1);

  457.         m_data->m_d3d_dev->SetRenderState(D3DRS_SRCBLEND, s1[0]);

  458.         m_data->m_d3d_dev->SetRenderState(D3DRS_DESTBLEND, s1[1]);

  459.     }

  460. #else

  461.     GLenum s1[2] = { GL_ONE, GL_ZERO };

  462.     BlendFunc s2[2] = { src, dst };

  463. 

  464.     for (int i = 0; i < 2; ++i)

  465.     {

  466.         switch (s2[i])

  467.         {

  468.             case BlendFunc::Disabled:

  469.                 break; /* Nothing to do */

  470.             case BlendFunc::Zero:

  471.                 s1[i] = GL_ZERO; break;

  472.             case BlendFunc::One:

  473.                 s1[i] = GL_ONE; break;

  474.             case BlendFunc::SrcColor:

  475.                 s1[i] = GL_SRC_COLOR; break;

  476.             case BlendFunc::OneMinusSrcColor:

  477.                 s1[i] = GL_ONE_MINUS_SRC_COLOR; break;

  478.             case BlendFunc::DstColor:

  479.                 s1[i] = GL_DST_COLOR; break;

  480.             case BlendFunc::OneMinusDstColor:

  481.                 s1[i] = GL_ONE_MINUS_DST_COLOR; break;

  482.             case BlendFunc::SrcAlpha:

  483.                 s1[i] = GL_SRC_ALPHA; break;

  484.             case BlendFunc::OneMinusSrcAlpha:

  485.                 s1[i] = GL_ONE_MINUS_SRC_ALPHA; break;

  486.             case BlendFunc::DstAlpha:

  487.                 s1[i] = GL_DST_ALPHA; break;

  488.             case BlendFunc::OneMinusDstAlpha:

  489.                 s1[i] = GL_ONE_MINUS_DST_ALPHA; break;

  490.             case BlendFunc::ConstantColor:

  491.                 s1[i] = GL_CONSTANT_COLOR; break;

  492.             case BlendFunc::OneMinusConstantColor:

  493.                 s1[i] = GL_ONE_MINUS_CONSTANT_COLOR; break;

  494.             case BlendFunc::ConstantAlpha:

  495.                 s1[i] = GL_CONSTANT_ALPHA; break;

  496.             case BlendFunc::OneMinusConstantAlpha:

  497.                 s1[i] = GL_ONE_MINUS_CONSTANT_ALPHA; break;

  498.         }

  499.     }

  500. 

  501.     if (src == BlendFunc::Disabled)

  502.     {

  503.         glDisable(GL_BLEND);

  504.     }

  505.     else

  506.     {

  507.         glEnable(GL_BLEND);

  508.         glBlendFunc(s1[0], s1[1]);

  509.     }

  510. #endif

  511. 

  512.     m_data->m_blend_src = src;

  513.     m_data->m_blend_dst = dst;

  514. }

  515. 

  516. BlendFunc Renderer::GetBlendFuncSrc() const

  517. {

  518.     return m_data->m_blend_src;

  519. }

  520. 

  521. BlendFunc Renderer::GetBlendFuncDst() const

  522. {

  523.     return m_data->m_blend_dst;

  524. }

  525. 

  526. /*

  527.  * Depth test

  528.  */

  529. 

  530. void Renderer::SetDepthFunc(DepthFunc func)

  531. {

  532.     if (m_data->m_depth_func == func)

  533.         return;

  534. 

  535. #if defined USE_D3D9 || defined _XBOX

  536.     switch (func)

  537.     {

  538.         case DepthFunc::Disabled:

  539.             break; /* Nothing to do */

  540.         case DepthFunc::Never:

  541.             m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_NEVER);

  542.             break;

  543.         case DepthFunc::Less:

  544.             m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESS);

  545.             break;

  546.         case DepthFunc::Equal:

  547.             m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_EQUAL);

  548.             break;

  549.         case DepthFunc::LessOrEqual:

  550.             m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);

  551.             break;

  552.         case DepthFunc::Greater:

  553.             m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_GREATER);

  554.             break;

  555.         case DepthFunc::NotEqual:

  556.             m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_NOTEQUAL);

  557.             break;

  558.         case DepthFunc::GreaterOrEqual:

  559.             m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_GREATEREQUAL);

  560.             break;

  561.         case DepthFunc::Always:

  562.             m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);

  563.             break;

  564.     }

  565. 

  566.     if (func == DepthFunc::Disabled)

  567.         m_data->m_d3d_dev->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);

  568.     else

  569.         m_data->m_d3d_dev->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);

  570. #else

  571.     switch (func)

  572.     {

  573.         case DepthFunc::Disabled:

  574.             break; /* Nothing to do */

  575.         case DepthFunc::Never:

  576.             glDepthFunc(GL_NEVER); break;

  577.         case DepthFunc::Less:

  578.             glDepthFunc(GL_LESS); break;

  579.         case DepthFunc::Equal:

  580.             glDepthFunc(GL_EQUAL); break;

  581.         case DepthFunc::LessOrEqual:

  582.             glDepthFunc(GL_LEQUAL); break;

  583.         case DepthFunc::Greater:

  584.             glDepthFunc(GL_GREATER); break;

  585.         case DepthFunc::NotEqual:

  586.             glDepthFunc(GL_NOTEQUAL); break;

  587.         case DepthFunc::GreaterOrEqual:

  588.             glDepthFunc(GL_GEQUAL); break;

  589.         case DepthFunc::Always:

  590.             glDepthFunc(GL_ALWAYS); break;

  591.     }

  592. 

  593.     if (func == DepthFunc::Disabled)

  594.         glDisable(GL_DEPTH_TEST);

  595.     else

  596.         glEnable(GL_DEPTH_TEST);

  597. #endif

  598. 

  599.     m_data->m_depth_func = func;

  600. }

  601. 

  602. DepthFunc Renderer::GetDepthFunc() const

  603. {

  604.     return m_data->m_depth_func;

  605. }

  606. 

  607. /*

  608.  * Depth mask

  609.  */

  610. 

  611. void Renderer::SetDepthMask(DepthMask mask)

  612. {

  613.     if (m_data->m_depth_mask == mask)

  614.         return;

  615. 

  616. #if defined USE_D3D9 || defined _XBOX

  617.     if (mask == DepthMask::Disabled)

  618.         m_data->m_d3d_dev->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE);

  619.     else

  620.         m_data->m_d3d_dev->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE);

  621. #else

  622.     if (mask == DepthMask::Disabled)

  623.         glDepthMask(GL_FALSE);

  624.     else

  625.         glDepthMask(GL_TRUE);

  626. #endif

  627. 

  628.     m_data->m_depth_mask = mask;

  629. }

  630. 

  631. DepthMask Renderer::GetDepthMask() const

  632. {

  633.     return m_data->m_depth_mask;

  634. }

  635. 

  636. /*

  637.  * Face culling

  638.  */

  639. 

  640. void Renderer::SetCullMode(CullMode mode)

  641. {

  642.     if (m_data->m_cull_mode == mode)

  643.         return;

  644. 

  645. #if defined USE_D3D9 || defined _XBOX

  646.     switch (mode)

  647.     {

  648.     case CullMode::Disabled:

  649.         m_data->m_d3d_dev->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);

  650.         break;

  651.     case CullMode::Clockwise:

  652.         m_data->m_d3d_dev->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);

  653.         break;

  654.     case CullMode::CounterClockwise:

  655.         m_data->m_d3d_dev->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);

  656.         break;

  657.     }

  658. #else

  659.     switch (mode)

  660.     {

  661.     case CullMode::Disabled:

  662.         glDisable(GL_CULL_FACE);

  663.         break;

  664.     case CullMode::Clockwise:

  665.         glEnable(GL_CULL_FACE);

  666.         glCullFace(GL_FRONT);

  667.         glFrontFace(GL_CW);

  668.         break;

  669.     case CullMode::CounterClockwise:

  670.         glEnable(GL_CULL_FACE);

  671.         glCullFace(GL_FRONT);

  672.         glFrontFace(GL_CCW);

  673.         break;

  674.     }

  675. #endif

  676. 

  677.     m_data->m_cull_mode = mode;

  678. }

  679. 

  680. CullMode Renderer::GetCullMode() const

  681. {

  682.     return m_data->m_cull_mode;

  683. }

  684. 

  685. /*

  686.  * Polygon rendering mode

  687.  */

  688. 

  689. void Renderer::SetPolygonMode(PolygonMode mode)

  690. {

  691.     if (m_data->m_polygon_mode == mode)

  692.         return;

  693. 

  694. #if defined USE_D3D9 || defined _XBOX

  695.     switch (mode)

  696.     {

  697.     case PolygonMode::Point:

  698.         m_data->m_d3d_dev->SetRenderState(D3DRS_FILLMODE, D3DFILL_POINT);

  699.         break;

  700.     case PolygonMode::Line:

  701.         m_data->m_d3d_dev->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);

  702.         break;

  703.     case PolygonMode::Fill:

  704.         m_data->m_d3d_dev->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);

  705.         break;

  706.     }

  707. #elif defined __CELLOS_LV2__ || defined GL_VERSION_1_1

  708.     switch (mode)

  709.     {

  710.     case PolygonMode::Point:

  711.         glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);

  712.         break;

  713.     case PolygonMode::Line:

  714.         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

  715.         break;

  716.     case PolygonMode::Fill:

  717.         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

  718.         break;

  719.     }

  720. #endif

  721. 

  722.     m_data->m_polygon_mode = mode;

  723. }

  724. 

  725. PolygonMode Renderer::GetPolygonMode() const

  726. {

  727.     return m_data->m_polygon_mode;

  728. }

  729. 

  730. } /* namespace lol */