lolengine
/
lol
mirror of https://github.com/lolengine/lol
1
0
Fork 0
Code Issues 0 Releases 0 Wiki Activity
2651 Commits
5 Branches
18 MiB
 
 
 
Tree: 7939719ce1
lol/src/gpu/renderer.cpp

842 lines
21 KiB
Raw Blame History 

  1. //

  2. //  Lol Engine

  3. //

  4. //  Copyright © 2010—2015 Sam Hocevar <sam@hocevar.net>

  5. //

  6. //  Lol Engine is free software. It comes without any warranty, to

  7. //  the extent permitted by applicable law. You can redistribute it

  8. //  and/or modify it under the terms of the Do What the Fuck You Want

  9. //  to Public License, Version 2, as published by the WTFPL Task Force.

  10. //  See http://www.wtfpl.net/ for more details.

  11. //

  12. 

  13. #include <lol/engine-internal.h>

  14. 

  15. #include <cstdlib>

  16. 

  17. #if defined _WIN32

  18. #   if defined USE_D3D9

  19. #      include <d3d9.h>

  20. #   endif

  21. #   define WIN32_LEAN_AND_MEAN 1

  22. #   include <windows.h>

  23. #   undef WIN32_LEAN_AND_MEAN

  24. #   undef near /* Fuck Microsoft */

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

  26. #endif

  27. 

  28. #include "lolgl.h"

  29. 

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

  31. #if defined USE_D3D9

  32. extern HWND g_hwnd;

  33. #endif

  34. 

  35. namespace lol

  36. {

  37. 

  38. /*

  39.  * The global g_renderers object, initialised by Video::Setup

  40.  */

  41. 

  42. //Renderer *g_renderer = nullptr;

  43. array<Renderer*> g_renderers;

  44. 

  45. /*

  46.  * Private RendererData class

  47.  */

  48. 

  49. class RendererData

  50. {

  51.     friend class Renderer;

  52. 

  53. private:

  54.     ibox2 m_viewport;

  55.     vec4 m_clear_color;

  56.     float m_clear_depth;

  57.     AlphaFunc m_alpha_func;

  58.     float m_alpha_value;

  59.     BlendEquation m_blend_rgb, m_blend_alpha;

  60.     BlendFunc m_blend_src, m_blend_dst;

  61.     DepthFunc m_depth_func;

  62.     DepthMask m_depth_mask;

  63.     CullMode m_cull_mode;

  64.     PolygonMode m_polygon_mode;

  65. 

  66. private:

  67. #if defined USE_D3D9

  68.     IDirect3D9 *m_d3d_ctx;

  69.     IDirect3DDevice9 *m_d3d_dev;

  70. #endif

  71. };

  72. 

  73. /*

  74.  * Public Renderer class

  75.  */

  76. 

  77. Renderer::Renderer(ivec2 size)

  78.   : m_data(new RendererData())

  79. {

  80. #if defined USE_D3D9

  81.     /* Create Direct3D context */

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

  83.     if (!m_data->m_d3d_ctx)

  84.     {

  85.         msg::error("cannot initialise D3D\n");

  86.         exit(EXIT_FAILURE);

  87.     }

  88. 

  89.     /* Create Direct3D device */

  90.     D3DPRESENT_PARAMETERS d3dpp;

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

  92.     d3dpp.BackBufferWidth = size.x;

  93.     d3dpp.BackBufferHeight = size.y;

  94.     d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;

  95.     d3dpp.BackBufferCount = 1;

  96.     d3dpp.hDeviceWindow = g_hwnd;

  97. #   if USE_SDL || USE_OLD_SDL

  98.     d3dpp.Windowed = TRUE;

  99. #   endif

  100.     d3dpp.EnableAutoDepthStencil = TRUE;

  101.     d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;

  102.     d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;

  103.     d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;

  104. 

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

  106.                                                  D3DCREATE_HARDWARE_VERTEXPROCESSING,

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

  108.     if (FAILED(hr))

  109.     {

  110.         msg::error("cannot create D3D device\n");

  111.         exit(EXIT_FAILURE);

  112.     }

  113. 

  114. #else

  115. #   if defined USE_GLEW && !defined __APPLE__

  116.     /* Initialise GLEW if necessary */

  117.     GLenum glerr = glewInit();

  118.     if (glerr != GLEW_OK)

  119.     {

  120.         msg::error("cannot initialise GLEW: %s\n", glewGetErrorString(glerr));

  121.         exit(EXIT_FAILURE);

  122.     }

  123. #   endif

  124. #endif

  125. 

  126.     /* Initialise rendering states */

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

  128.     SetViewport(ibox2(ivec2::zero, size));

  129. 

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

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

  132. 

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

  134.     SetClearDepth(1.f);

  135. 

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

  137.     m_data->m_alpha_value = -1.0f;

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

  139. 

  140.     m_data->m_blend_rgb = BlendEquation::Subtract;

  141.     m_data->m_blend_alpha = BlendEquation::Subtract;

  142.     SetBlendEquation(BlendEquation::Add, BlendEquation::Add);

  143. 

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

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

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

  147. 

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

  149.     SetDepthFunc(DepthFunc::LessOrEqual);

  150. 

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

  152.     SetDepthMask(DepthMask::Enabled);

  153. 

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

  155.     SetCullMode(CullMode::Clockwise);

  156. 

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

  158.     SetPolygonMode(PolygonMode::Fill);

  159. 

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

  161. #if defined USE_D3D9

  162.     /* TODO */

  163. #else

  164. #   if defined HAVE_GL_2X && !defined __APPLE__

  165.     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

  166. #   endif

  167. #endif

  168. }

  169. 

  170. Renderer::~Renderer()

  171. {

  172.     delete m_data;

  173. }

  174. 

  175. void *Renderer::GetDevice()

  176. {

  177. #if defined USE_D3D9

  178.     return m_data->m_d3d_dev;

  179. #else

  180.     return nullptr;

  181. #endif

  182. }

  183. 

  184. /*

  185.  * Buffer clearing

  186.  */

  187. 

  188. void Renderer::Clear(ClearMask mask)

  189. {

  190. #if defined USE_D3D9

  191.     int m = 0;

  192.     if (mask & ClearMask::Color)

  193.         m |= D3DCLEAR_TARGET;

  194.     if (mask & ClearMask::Depth)

  195.         m |= D3DCLEAR_ZBUFFER;

  196.     if (mask & ClearMask::Stencil)

  197.         m |= D3DCLEAR_STENCIL;

  198. 

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

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

  201. 

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

  203.                                         GetClearDepth(), 0)))

  204.         Abort();

  205. #else

  206.     GLbitfield m = 0;

  207.     if (mask & ClearMask::Color)

  208.         m |= GL_COLOR_BUFFER_BIT;

  209.     if (mask & ClearMask::Depth)

  210.         m |= GL_DEPTH_BUFFER_BIT;

  211.     if (mask & ClearMask::Stencil)

  212.         m |= GL_STENCIL_BUFFER_BIT;

  213.     glClear(m);

  214. #endif

  215. }

  216. 

  217. /*

  218. * Renderer static

  219. */

  220. 

  221. void Renderer::AddNew(ivec2 size)

  222. {

  223.     g_renderers << new Renderer(size);

  224. }

  225. 

  226. int Renderer::GetCount()

  227. {

  228.     return g_renderers.count();

  229. }

  230. 

  231. Renderer* Renderer::Get(int index)

  232. {

  233.     return g_renderers[index];

  234. }

  235. 

  236. void Renderer::DestroyAll()

  237. {

  238.     for (Renderer* renderer : g_renderers)

  239.         delete renderer;

  240.     g_renderers.empty();

  241. }

  242. 

  243. /*

  244.  * Viewport dimensions

  245.  */

  246. 

  247. void Renderer::SetViewport(ibox2 viewport)

  248. {

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

  250.         return;

  251. 

  252. #if defined USE_D3D9

  253.     D3DVIEWPORT9 vp = { viewport.aa.x, viewport.aa.y,

  254.                         viewport.bb.x, viewport.bb.y,

  255.                         0.0f, 1.0f };

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

  257. #else

  258.     glViewport(viewport.aa.x, viewport.aa.y, viewport.bb.x, viewport.bb.y);

  259. #endif

  260. 

  261.     m_data->m_viewport = viewport;

  262. }

  263. 

  264. ibox2 Renderer::GetViewport() const

  265. {

  266.     return m_data->m_viewport;

  267. }

  268. 

  269. float Renderer::GetXYRatio() const

  270. {

  271.     ivec2 s = GetViewport().extent();

  272.     return (float)s.x / s.y;

  273. }

  274. 

  275. float Renderer::GetYXRatio() const

  276. {

  277.     ivec2 s = GetViewport().extent();

  278.     return (float)s.y / s.x;

  279. }

  280. 

  281. /*

  282.  * Clear color

  283.  */

  284. 

  285. void Renderer::SetClearColor(vec4 color)

  286. {

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

  288.         return;

  289. 

  290. #if defined USE_D3D9

  291.     /* Nothing to do */

  292. #else

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

  294. #endif

  295. 

  296.     m_data->m_clear_color = color;

  297. }

  298. 

  299. vec4 Renderer::GetClearColor() const

  300. {

  301.     return m_data->m_clear_color;

  302. }

  303. 

  304. /*

  305.  * Clear depth

  306.  */

  307. 

  308. void Renderer::SetClearDepth(float depth)

  309. {

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

  311.         return;

  312. 

  313. #if defined USE_D3D9

  314.     /* Nothing to do */

  315. #elif defined HAVE_GLES_2X

  316.     glClearDepthf(depth);

  317. #else

  318.     glClearDepth(depth);

  319. #endif

  320. 

  321.     m_data->m_clear_depth = depth;

  322. }

  323. 

  324. float Renderer::GetClearDepth() const

  325. {

  326.     return m_data->m_clear_depth;

  327. }

  328. 

  329. /*

  330.  * Alpha testing

  331.  */

  332. 

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

  334. {

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

  336.         return;

  337. 

  338. #if defined USE_D3D9

  339.     switch (func)

  340.     {

  341.         case AlphaFunc::Disabled:

  342.             break; /* Nothing to do */

  343.         case AlphaFunc::Never:

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

  345.             break;

  346.         case AlphaFunc::Less:

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

  348.             break;

  349.         case AlphaFunc::Equal:

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

  351.             break;

  352.         case AlphaFunc::LessOrEqual:

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

  354.             break;

  355.         case AlphaFunc::Greater:

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

  357.             break;

  358.         case AlphaFunc::NotEqual:

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

  360.             break;

  361.         case AlphaFunc::GreaterOrEqual:

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

  363.             break;

  364.         case AlphaFunc::Always:

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

  366.             break;

  367.     }

  368. 

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

  370.     {

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

  372.     }

  373.     else

  374.     {

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

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

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

  378.     }

  379. #elif defined HAVE_GLES_2X

  380.     /* not supported */

  381. #elif defined GL_VERSION_1_1

  382.     switch (func)

  383.     {

  384.         case AlphaFunc::Disabled:

  385.             break; /* Nothing to do */

  386.         case AlphaFunc::Never:

  387.             glAlphaFunc(GL_NEVER, alpha); break;

  388.         case AlphaFunc::Less:

  389.             glAlphaFunc(GL_LESS, alpha); break;

  390.         case AlphaFunc::Equal:

  391.             glAlphaFunc(GL_EQUAL, alpha); break;

  392.         case AlphaFunc::LessOrEqual:

  393.             glAlphaFunc(GL_LEQUAL, alpha); break;

  394.         case AlphaFunc::Greater:

  395.             glAlphaFunc(GL_GREATER, alpha); break;

  396.         case AlphaFunc::NotEqual:

  397.             glAlphaFunc(GL_NOTEQUAL, alpha); break;

  398.         case AlphaFunc::GreaterOrEqual:

  399.             glAlphaFunc(GL_GEQUAL, alpha); break;

  400.         case AlphaFunc::Always:

  401.             glAlphaFunc(GL_ALWAYS, alpha); break;

  402.     }

  403. 

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

  405.         glDisable(GL_ALPHA_TEST);

  406.     else

  407.         glEnable(GL_ALPHA_TEST);

  408. #else

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

  410. #endif

  411. 

  412.     m_data->m_alpha_func = func;

  413.     m_data->m_alpha_value = alpha;

  414. }

  415. 

  416. AlphaFunc Renderer::GetAlphaFunc() const

  417. {

  418.     return m_data->m_alpha_func;

  419. }

  420. 

  421. float Renderer::GetAlphaValue() const

  422. {

  423.     return m_data->m_alpha_value;

  424. }

  425. 

  426. /*

  427.  * Blend equation

  428.  */

  429. 

  430. void Renderer::SetBlendEquation(BlendEquation rgb, BlendEquation alpha)

  431. {

  432.     if (m_data->m_blend_rgb == rgb && m_data->m_blend_alpha == alpha)

  433.         return;

  434. 

  435. #if defined USE_D3D9

  436.     D3DBLEND s1[2] = { D3DBLENDOP_ADD, D3DBLENDOP_ADD };

  437.     BlendEquation s2[2] = { rgb, alpha };

  438. 

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

  440.     {

  441.         switch (s2[i])

  442.         {

  443.             case BlendEquation::Add:

  444.                 s1[i] = D3DBLENDOP_ADD; break;

  445.             case BlendEquation::Subtract:

  446.                 s1[i] = D3DBLENDOP_SUBTRACT; break;

  447.             case BlendEquation::ReverseSubtract:

  448.                 s1[i] = D3DBLENDOP_REVSUBTRACT; break;

  449.             case BlendEquation::Min:

  450.                 s1[i] = D3DBLENDOP_MIN; break;

  451.             case BlendEquation::Max:

  452.                 s1[i] = D3DBLENDOP_MAX; break;

  453.         }

  454.     }

  455. 

  456.     m_data->m_d3d_dev->SetRenderState(D3DRS_BLENDOP, s1[0]);

  457.     m_data->m_d3d_dev->SetRenderState(D3DRS_BLENDOPALPHA, s1[1]);

  458. #else

  459.     GLenum s1[2] = { GL_FUNC_ADD, GL_FUNC_ADD };

  460.     BlendEquation s2[2] = { rgb, alpha };

  461. 

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

  463.     {

  464.         switch (s2[i])

  465.         {

  466.             case BlendEquation::Add:

  467.                 s1[i] = GL_FUNC_ADD; break;

  468.             case BlendEquation::Subtract:

  469.                 s1[i] = GL_FUNC_SUBTRACT; break;

  470.             case BlendEquation::ReverseSubtract:

  471.                 s1[i] = GL_FUNC_REVERSE_SUBTRACT; break;

  472. #if defined GL_MIN && defined GL_MAX

  473.             case BlendEquation::Min:

  474.                 s1[i] = GL_MIN; break;

  475.             case BlendEquation::Max:

  476.                 s1[i] = GL_MAX; break;

  477. #else

  478.             case BlendEquation::Min:

  479.                 s1[i] = GL_MIN_EXT; break;

  480.             case BlendEquation::Max:

  481.                 s1[i] = GL_MAX_EXT; break;

  482. #endif

  483.         }

  484.     }

  485. 

  486.     glBlendEquationSeparate(s1[0], s1[1]);

  487. #endif

  488. 

  489.     m_data->m_blend_rgb = rgb;

  490.     m_data->m_blend_alpha = alpha;

  491. }

  492. 

  493. BlendEquation Renderer::GetBlendEquationRgb() const

  494. {

  495.     return m_data->m_blend_rgb;

  496. }

  497. 

  498. BlendEquation Renderer::GetBlendEquationAlpha() const

  499. {

  500.     return m_data->m_blend_alpha;

  501. }

  502. 

  503. /*

  504.  * Blend function

  505.  */

  506. 

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

  508. {

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

  510.         return;

  511. 

  512. #if defined USE_D3D9

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

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

  515. 

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

  517.     {

  518.         switch (s2[i])

  519.         {

  520.             case BlendFunc::Disabled:

  521.                 break; /* Nothing to do */

  522.             case BlendFunc::Zero:

  523.                 s1[i] = D3DBLEND_ZERO; break;

  524.             case BlendFunc::One:

  525.                 s1[i] = D3DBLEND_ONE; break;

  526.             case BlendFunc::SrcColor:

  527.                 s1[i] = D3DBLEND_SRCCOLOR; break;

  528.             case BlendFunc::OneMinusSrcColor:

  529.                 s1[i] = D3DBLEND_INVSRCCOLOR; break;

  530.             case BlendFunc::DstColor:

  531.                 s1[i] = D3DBLEND_DESTCOLOR; break;

  532.             case BlendFunc::OneMinusDstColor:

  533.                 s1[i] = D3DBLEND_INVDESTCOLOR; break;

  534.             case BlendFunc::SrcAlpha:

  535.                 s1[i] = D3DBLEND_SRCALPHA; break;

  536.             case BlendFunc::OneMinusSrcAlpha:

  537.                 s1[i] = D3DBLEND_INVSRCALPHA; break;

  538.             case BlendFunc::DstAlpha:

  539.                 s1[i] = D3DBLEND_DESTALPHA; break;

  540.             case BlendFunc::OneMinusDstAlpha:

  541.                 s1[i] = D3DBLEND_INVDESTALPHA; break;

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

  543.             case BlendFunc::ConstantColor:

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

  545.                 break;

  546.             case BlendFunc::OneMinusConstantColor:

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

  548.                 break;

  549.             case BlendFunc::ConstantAlpha:

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

  551.                 break;

  552.             case BlendFunc::OneMinusConstantAlpha:

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

  554.                 break;

  555.         }

  556.     }

  557. 

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

  559.     {

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

  561.     }

  562.     else

  563.     {

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

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

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

  567.     }

  568. #else

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

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

  571. 

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

  573.     {

  574.         switch (s2[i])

  575.         {

  576.             case BlendFunc::Disabled:

  577.                 break; /* Nothing to do */

  578.             case BlendFunc::Zero:

  579.                 s1[i] = GL_ZERO; break;

  580.             case BlendFunc::One:

  581.                 s1[i] = GL_ONE; break;

  582.             case BlendFunc::SrcColor:

  583.                 s1[i] = GL_SRC_COLOR; break;

  584.             case BlendFunc::OneMinusSrcColor:

  585.                 s1[i] = GL_ONE_MINUS_SRC_COLOR; break;

  586.             case BlendFunc::DstColor:

  587.                 s1[i] = GL_DST_COLOR; break;

  588.             case BlendFunc::OneMinusDstColor:

  589.                 s1[i] = GL_ONE_MINUS_DST_COLOR; break;

  590.             case BlendFunc::SrcAlpha:

  591.                 s1[i] = GL_SRC_ALPHA; break;

  592.             case BlendFunc::OneMinusSrcAlpha:

  593.                 s1[i] = GL_ONE_MINUS_SRC_ALPHA; break;

  594.             case BlendFunc::DstAlpha:

  595.                 s1[i] = GL_DST_ALPHA; break;

  596.             case BlendFunc::OneMinusDstAlpha:

  597.                 s1[i] = GL_ONE_MINUS_DST_ALPHA; break;

  598.             case BlendFunc::ConstantColor:

  599.                 s1[i] = GL_CONSTANT_COLOR; break;

  600.             case BlendFunc::OneMinusConstantColor:

  601.                 s1[i] = GL_ONE_MINUS_CONSTANT_COLOR; break;

  602.             case BlendFunc::ConstantAlpha:

  603.                 s1[i] = GL_CONSTANT_ALPHA; break;

  604.             case BlendFunc::OneMinusConstantAlpha:

  605.                 s1[i] = GL_ONE_MINUS_CONSTANT_ALPHA; break;

  606.         }

  607.     }

  608. 

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

  610.     {

  611.         glDisable(GL_BLEND);

  612.     }

  613.     else

  614.     {

  615.         glEnable(GL_BLEND);

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

  617.     }

  618. #endif

  619. 

  620.     m_data->m_blend_src = src;

  621.     m_data->m_blend_dst = dst;

  622. }

  623. 

  624. BlendFunc Renderer::GetBlendFuncSrc() const

  625. {

  626.     return m_data->m_blend_src;

  627. }

  628. 

  629. BlendFunc Renderer::GetBlendFuncDst() const

  630. {

  631.     return m_data->m_blend_dst;

  632. }

  633. 

  634. /*

  635.  * Depth test

  636.  */

  637. 

  638. void Renderer::SetDepthFunc(DepthFunc func)

  639. {

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

  641.         return;

  642. 

  643. #if defined USE_D3D9

  644.     switch (func)

  645.     {

  646.         case DepthFunc::Disabled:

  647.             break; /* Nothing to do */

  648.         case DepthFunc::Never:

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

  650.             break;

  651.         case DepthFunc::Less:

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

  653.             break;

  654.         case DepthFunc::Equal:

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

  656.             break;

  657.         case DepthFunc::LessOrEqual:

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

  659.             break;

  660.         case DepthFunc::Greater:

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

  662.             break;

  663.         case DepthFunc::NotEqual:

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

  665.             break;

  666.         case DepthFunc::GreaterOrEqual:

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

  668.             break;

  669.         case DepthFunc::Always:

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

  671.             break;

  672.     }

  673. 

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

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

  676.     else

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

  678. #else

  679.     switch (func)

  680.     {

  681.         case DepthFunc::Disabled:

  682.             break; /* Nothing to do */

  683.         case DepthFunc::Never:

  684.             glDepthFunc(GL_NEVER); break;

  685.         case DepthFunc::Less:

  686.             glDepthFunc(GL_LESS); break;

  687.         case DepthFunc::Equal:

  688.             glDepthFunc(GL_EQUAL); break;

  689.         case DepthFunc::LessOrEqual:

  690.             glDepthFunc(GL_LEQUAL); break;

  691.         case DepthFunc::Greater:

  692.             glDepthFunc(GL_GREATER); break;

  693.         case DepthFunc::NotEqual:

  694.             glDepthFunc(GL_NOTEQUAL); break;

  695.         case DepthFunc::GreaterOrEqual:

  696.             glDepthFunc(GL_GEQUAL); break;

  697.         case DepthFunc::Always:

  698.             glDepthFunc(GL_ALWAYS); break;

  699.     }

  700. 

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

  702.         glDisable(GL_DEPTH_TEST);

  703.     else

  704.         glEnable(GL_DEPTH_TEST);

  705. #endif

  706. 

  707.     m_data->m_depth_func = func;

  708. }

  709. 

  710. DepthFunc Renderer::GetDepthFunc() const

  711. {

  712.     return m_data->m_depth_func;

  713. }

  714. 

  715. /*

  716.  * Depth mask

  717.  */

  718. 

  719. void Renderer::SetDepthMask(DepthMask mask)

  720. {

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

  722.         return;

  723. 

  724. #if defined USE_D3D9

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

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

  727.     else

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

  729. #else

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

  731.         glDepthMask(GL_FALSE);

  732.     else

  733.         glDepthMask(GL_TRUE);

  734. #endif

  735. 

  736.     m_data->m_depth_mask = mask;

  737. }

  738. 

  739. DepthMask Renderer::GetDepthMask() const

  740. {

  741.     return m_data->m_depth_mask;

  742. }

  743. 

  744. /*

  745.  * Face culling

  746.  */

  747. 

  748. void Renderer::SetCullMode(CullMode mode)

  749. {

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

  751.         return;

  752. 

  753. #if defined USE_D3D9

  754.     switch (mode)

  755.     {

  756.     case CullMode::Disabled:

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

  758.         break;

  759.     case CullMode::Clockwise:

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

  761.         break;

  762.     case CullMode::CounterClockwise:

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

  764.         break;

  765.     }

  766. #else

  767.     switch (mode)

  768.     {

  769.     case CullMode::Disabled:

  770.         glDisable(GL_CULL_FACE);

  771.         break;

  772.     case CullMode::Clockwise:

  773.         glEnable(GL_CULL_FACE);

  774.         glCullFace(GL_FRONT);

  775.         glFrontFace(GL_CW);

  776.         break;

  777.     case CullMode::CounterClockwise:

  778.         glEnable(GL_CULL_FACE);

  779.         glCullFace(GL_FRONT);

  780.         glFrontFace(GL_CCW);

  781.         break;

  782.     }

  783. #endif

  784. 

  785.     m_data->m_cull_mode = mode;

  786. }

  787. 

  788. CullMode Renderer::GetCullMode() const

  789. {

  790.     return m_data->m_cull_mode;

  791. }

  792. 

  793. /*

  794.  * Polygon rendering mode

  795.  */

  796. 

  797. void Renderer::SetPolygonMode(PolygonMode mode)

  798. {

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

  800.         return;

  801. 

  802. #if defined USE_D3D9

  803.     switch (mode)

  804.     {

  805.     case PolygonMode::Point:

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

  807.         break;

  808.     case PolygonMode::Line:

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

  810.         break;

  811.     case PolygonMode::Fill:

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

  813.         break;

  814.     }

  815. #elif defined HAVE_GLES_2X

  816.     /* not supported */

  817. #elif defined GL_VERSION_1_1

  818.     switch (mode)

  819.     {

  820.     case PolygonMode::Point:

  821.         glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);

  822.         break;

  823.     case PolygonMode::Line:

  824.         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

  825.         break;

  826.     case PolygonMode::Fill:

  827.         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

  828.         break;

  829.     }

  830. #endif

  831. 

  832.     m_data->m_polygon_mode = mode;

  833. }

  834. 

  835. PolygonMode Renderer::GetPolygonMode() const

  836. {

  837.     return m_data->m_polygon_mode;

  838. }

  839. 

  840. } /* namespace lol */