lolengine
/
lol
镜像自地址 https://github.com/lolengine/lol
1
0
派生 0
代码 工单 0 版本发布 0 百科 动态
2203 提交
5 分支
27 MiB
 
 
 
目录树: 5dc05d7f3e
lol/src/gpu/renderer.cpp

830 行
21 KiB
原始文件 Blame 文件历史 

  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 <lol/main.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.     BlendEquation m_blend_rgb, m_blend_alpha;

  65.     BlendFunc m_blend_src, m_blend_dst;

  66.     DepthFunc m_depth_func;

  67.     DepthMask m_depth_mask;

  68.     CullMode m_cull_mode;

  69.     PolygonMode m_polygon_mode;

  70. 

  71. private:

  72. #if defined USE_D3D9

  73.     IDirect3D9 *m_d3d_ctx;

  74.     IDirect3DDevice9 *m_d3d_dev;

  75. #elif defined _XBOX

  76.     Direct3D *m_d3d_ctx;

  77.     D3DDevice *m_d3d_dev;

  78. #endif

  79. };

  80. 

  81. /*

  82.  * Public Renderer class

  83.  */

  84. 

  85. Renderer::Renderer(ivec2 size)

  86.   : m_data(new RendererData())

  87. {

  88. #if defined USE_D3D9 || defined _XBOX

  89.     /* Create Direct3D context */

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

  91.     if (!m_data->m_d3d_ctx)

  92.     {

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

  94.         exit(EXIT_FAILURE);

  95.     }

  96. 

  97.     /* Create Direct3D device */

  98. #   if defined _XBOX

  99.     XVIDEO_MODE VideoMode;

  100.     XGetVideoMode(&VideoMode);

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

  102.                                 VideoMode.dwDisplayHeight));

  103. #   endif

  104.     D3DPRESENT_PARAMETERS d3dpp;

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

  106.     d3dpp.BackBufferWidth = size.x;

  107.     d3dpp.BackBufferHeight = size.y;

  108.     d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;

  109.     d3dpp.BackBufferCount = 1;

  110.     d3dpp.hDeviceWindow = g_hwnd;

  111. #   if defined USE_SDL

  112.     d3dpp.Windowed = TRUE;

  113. #   endif

  114.     d3dpp.EnableAutoDepthStencil = TRUE;

  115.     d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;

  116.     d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;

  117.     d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;

  118. 

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

  120.                                                  D3DCREATE_HARDWARE_VERTEXPROCESSING,

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

  122.     if (FAILED(hr))

  123.     {

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

  125.         exit(EXIT_FAILURE);

  126.     }

  127. 

  128. #else

  129. #   if defined USE_GLEW && !defined __APPLE__

  130.     /* Initialise GLEW if necessary */

  131.     GLenum glerr = glewInit();

  132.     if (glerr != GLEW_OK)

  133.     {

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

  135.         exit(EXIT_FAILURE);

  136.     }

  137. #   endif

  138. #endif

  139. 

  140.     /* Initialise rendering states */

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

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

  143. 

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

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

  146. 

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

  148.     SetClearDepth(1.f);

  149. 

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

  151.     m_data->m_alpha_value = -1.0f;

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

  153. 

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

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

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

  157. 

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

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

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

  161. 

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

  163.     SetDepthFunc(DepthFunc::LessOrEqual);

  164. 

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

  166.     SetDepthMask(DepthMask::Enabled);

  167. 

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

  169.     SetCullMode(CullMode::Clockwise);

  170. 

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

  172.     SetPolygonMode(PolygonMode::Fill);

  173. 

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

  175. #if defined USE_D3D9 || defined _XBOX

  176.     /* TODO */

  177. #else

  178. #   if defined HAVE_GL_2X && !defined __APPLE__

  179.     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

  180. #   endif

  181. #endif

  182. }

  183. 

  184. Renderer::~Renderer()

  185. {

  186.     delete m_data;

  187. }

  188. 

  189. void *Renderer::GetDevice()

  190. {

  191. #if defined USE_D3D9 || defined _XBOX

  192.     return m_data->m_d3d_dev;

  193. #else

  194.     return nullptr;

  195. #endif

  196. }

  197. 

  198. /*

  199.  * Buffer clearing

  200.  */

  201. 

  202. void Renderer::Clear(ClearMask mask)

  203. {

  204. #if defined USE_D3D9 || defined _XBOX

  205.     int m = 0;

  206.     if (mask & ClearMask::Color)

  207.         m |= D3DCLEAR_TARGET;

  208.     if (mask & ClearMask::Depth)

  209.         m |= D3DCLEAR_ZBUFFER;

  210.     if (mask & ClearMask::Stencil)

  211.         m |= D3DCLEAR_STENCIL;

  212. 

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

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

  215. 

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

  217.                                         GetClearDepth(), 0)))

  218.         Abort();

  219. #else

  220.     GLbitfield m = 0;

  221.     if (mask & ClearMask::Color)

  222.         m |= GL_COLOR_BUFFER_BIT;

  223.     if (mask & ClearMask::Depth)

  224.         m |= GL_DEPTH_BUFFER_BIT;

  225.     if (mask & ClearMask::Stencil)

  226.         m |= GL_STENCIL_BUFFER_BIT;

  227.     glClear(m);

  228. #endif

  229. }

  230. 

  231. /*

  232.  * Viewport dimensions

  233.  */

  234. 

  235. void Renderer::SetViewport(ibox2 viewport)

  236. {

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

  238.         return;

  239. 

  240. #if defined USE_D3D9 || defined _XBOX

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

  242.                         viewport.B.x, viewport.B.y,

  243.                         0.0f, 1.0f };

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

  245. #else

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

  247. #endif

  248. 

  249.     m_data->m_viewport = viewport;

  250. }

  251. 

  252. ibox2 Renderer::GetViewport() const

  253. {

  254.     return m_data->m_viewport;

  255. }

  256. 

  257. float Renderer::GetXYRatio() const

  258. {

  259.     ibox2 a = GetViewport();

  260.     ibox2 b(a.A, a.B);

  261.     ivec2 s = b.B - b.A;

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

  263. }

  264. 

  265. float Renderer::GetYXRatio() const

  266. {

  267.     ibox2 a = GetViewport();

  268.     ibox2 b(a.A, a.B);

  269.     ivec2 s = b.B - b.A;

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

  271. }

  272. 

  273. /*

  274.  * Clear color

  275.  */

  276. 

  277. void Renderer::SetClearColor(vec4 color)

  278. {

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

  280.         return;

  281. 

  282. #if defined USE_D3D9 || defined _XBOX

  283.     /* Nothing to do */

  284. #else

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

  286. #endif

  287. 

  288.     m_data->m_clear_color = color;

  289. }

  290. 

  291. vec4 Renderer::GetClearColor() const

  292. {

  293.     return m_data->m_clear_color;

  294. }

  295. 

  296. /*

  297.  * Clear depth

  298.  */

  299. 

  300. void Renderer::SetClearDepth(float depth)

  301. {

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

  303.         return;

  304. 

  305. #if defined USE_D3D9 || defined _XBOX

  306.     /* Nothing to do */

  307. #elif defined HAVE_GLES_2X

  308.     glClearDepthf(depth);

  309. #else

  310.     glClearDepth(depth);

  311. #endif

  312. 

  313.     m_data->m_clear_depth = depth;

  314. }

  315. 

  316. float Renderer::GetClearDepth() const

  317. {

  318.     return m_data->m_clear_depth;

  319. }

  320. 

  321. /*

  322.  * Alpha testing

  323.  */

  324. 

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

  326. {

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

  328.         return;

  329. 

  330. #if defined USE_D3D9 || defined _XBOX

  331.     switch (func)

  332.     {

  333.         case AlphaFunc::Disabled:

  334.             break; /* Nothing to do */

  335.         case AlphaFunc::Never:

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

  337.             break;

  338.         case AlphaFunc::Less:

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

  340.             break;

  341.         case AlphaFunc::Equal:

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

  343.             break;

  344.         case AlphaFunc::LessOrEqual:

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

  346.             break;

  347.         case AlphaFunc::Greater:

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

  349.             break;

  350.         case AlphaFunc::NotEqual:

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

  352.             break;

  353.         case AlphaFunc::GreaterOrEqual:

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

  355.             break;

  356.         case AlphaFunc::Always:

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

  358.             break;

  359.     }

  360. 

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

  362.     {

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

  364.     }

  365.     else

  366.     {

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

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

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

  370.     }

  371. #elif defined GL_VERSION_1_1

  372.     switch (func)

  373.     {

  374.         case AlphaFunc::Disabled:

  375.             break; /* Nothing to do */

  376.         case AlphaFunc::Never:

  377.             glAlphaFunc(GL_NEVER, alpha); break;

  378.         case AlphaFunc::Less:

  379.             glAlphaFunc(GL_LESS, alpha); break;

  380.         case AlphaFunc::Equal:

  381.             glAlphaFunc(GL_EQUAL, alpha); break;

  382.         case AlphaFunc::LessOrEqual:

  383.             glAlphaFunc(GL_LEQUAL, alpha); break;

  384.         case AlphaFunc::Greater:

  385.             glAlphaFunc(GL_GREATER, alpha); break;

  386.         case AlphaFunc::NotEqual:

  387.             glAlphaFunc(GL_NOTEQUAL, alpha); break;

  388.         case AlphaFunc::GreaterOrEqual:

  389.             glAlphaFunc(GL_GEQUAL, alpha); break;

  390.         case AlphaFunc::Always:

  391.             glAlphaFunc(GL_ALWAYS, alpha); break;

  392.     }

  393. 

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

  395.         glDisable(GL_ALPHA_TEST);

  396.     else

  397.         glEnable(GL_ALPHA_TEST);

  398. #else

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

  400. #endif

  401. 

  402.     m_data->m_alpha_func = func;

  403.     m_data->m_alpha_value = alpha;

  404. }

  405. 

  406. AlphaFunc Renderer::GetAlphaFunc() const

  407. {

  408.     return m_data->m_alpha_func;

  409. }

  410. 

  411. float Renderer::GetAlphaValue() const

  412. {

  413.     return m_data->m_alpha_value;

  414. }

  415. 

  416. /*

  417.  * Blend equation

  418.  */

  419. 

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

  421. {

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

  423.         return;

  424. 

  425. #if defined USE_D3D9 || defined _XBOX

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

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

  428. 

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

  430.     {

  431.         switch (s2[i])

  432.         {

  433.             case BlendEquation::Add:

  434.                 s1[i] = D3DBLENDOP_ADD; break;

  435.             case BlendEquation::Subtract:

  436.                 s1[i] = D3DBLENDOP_SUBTRACT; break;

  437.             case BlendEquation::ReverseSubtract:

  438.                 s1[i] = D3DBLENDOP_REVSUBTRACT; break;

  439.             case BlendEquation::Min:

  440.                 s1[i] = D3DBLENDOP_MIN; break;

  441.             case BlendEquation::Max:

  442.                 s1[i] = D3DBLENDOP_MAX; break;

  443.         }

  444.     }

  445. 

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

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

  448. #else

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

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

  451. 

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

  453.     {

  454.         switch (s2[i])

  455.         {

  456.             case BlendEquation::Add:

  457.                 s1[i] = GL_FUNC_ADD; break;

  458.             case BlendEquation::Subtract:

  459.                 s1[i] = GL_FUNC_SUBTRACT; break;

  460.             case BlendEquation::ReverseSubtract:

  461.                 s1[i] = GL_FUNC_REVERSE_SUBTRACT; break;

  462. #if defined GL_MIN && defined GL_MAX

  463.             case BlendEquation::Min:

  464.                 s1[i] = GL_MIN; break;

  465.             case BlendEquation::Max:

  466.                 s1[i] = GL_MAX; break;

  467. #else

  468.             case BlendEquation::Min:

  469.                 s1[i] = GL_MIN_EXT; break;

  470.             case BlendEquation::Max:

  471.                 s1[i] = GL_MAX_EXT; break;

  472. #endif

  473.         }

  474.     }

  475. 

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

  477. #endif

  478. 

  479.     m_data->m_blend_rgb = rgb;

  480.     m_data->m_blend_alpha = alpha;

  481. }

  482. 

  483. BlendEquation Renderer::GetBlendEquationRgb() const

  484. {

  485.     return m_data->m_blend_rgb;

  486. }

  487. 

  488. BlendEquation Renderer::GetBlendEquationAlpha() const

  489. {

  490.     return m_data->m_blend_alpha;

  491. }

  492. 

  493. /*

  494.  * Blend function

  495.  */

  496. 

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

  498. {

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

  500.         return;

  501. 

  502. #if defined USE_D3D9 || defined _XBOX

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

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

  505. 

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

  507.     {

  508.         switch (s2[i])

  509.         {

  510.             case BlendFunc::Disabled:

  511.                 break; /* Nothing to do */

  512.             case BlendFunc::Zero:

  513.                 s1[i] = D3DBLEND_ZERO; break;

  514.             case BlendFunc::One:

  515.                 s1[i] = D3DBLEND_ONE; break;

  516.             case BlendFunc::SrcColor:

  517.                 s1[i] = D3DBLEND_SRCCOLOR; break;

  518.             case BlendFunc::OneMinusSrcColor:

  519.                 s1[i] = D3DBLEND_INVSRCCOLOR; break;

  520.             case BlendFunc::DstColor:

  521.                 s1[i] = D3DBLEND_DESTCOLOR; break;

  522.             case BlendFunc::OneMinusDstColor:

  523.                 s1[i] = D3DBLEND_INVDESTCOLOR; break;

  524.             case BlendFunc::SrcAlpha:

  525.                 s1[i] = D3DBLEND_SRCALPHA; break;

  526.             case BlendFunc::OneMinusSrcAlpha:

  527.                 s1[i] = D3DBLEND_INVSRCALPHA; break;

  528.             case BlendFunc::DstAlpha:

  529.                 s1[i] = D3DBLEND_DESTALPHA; break;

  530.             case BlendFunc::OneMinusDstAlpha:

  531.                 s1[i] = D3DBLEND_INVDESTALPHA; break;

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

  533.             case BlendFunc::ConstantColor:

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

  535.                 break;

  536.             case BlendFunc::OneMinusConstantColor:

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

  538.                 break;

  539.             case BlendFunc::ConstantAlpha:

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

  541.                 break;

  542.             case BlendFunc::OneMinusConstantAlpha:

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

  544.                 break;

  545.         }

  546.     }

  547. 

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

  549.     {

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

  551.     }

  552.     else

  553.     {

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

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

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

  557.     }

  558. #else

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

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

  561. 

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

  563.     {

  564.         switch (s2[i])

  565.         {

  566.             case BlendFunc::Disabled:

  567.                 break; /* Nothing to do */

  568.             case BlendFunc::Zero:

  569.                 s1[i] = GL_ZERO; break;

  570.             case BlendFunc::One:

  571.                 s1[i] = GL_ONE; break;

  572.             case BlendFunc::SrcColor:

  573.                 s1[i] = GL_SRC_COLOR; break;

  574.             case BlendFunc::OneMinusSrcColor:

  575.                 s1[i] = GL_ONE_MINUS_SRC_COLOR; break;

  576.             case BlendFunc::DstColor:

  577.                 s1[i] = GL_DST_COLOR; break;

  578.             case BlendFunc::OneMinusDstColor:

  579.                 s1[i] = GL_ONE_MINUS_DST_COLOR; break;

  580.             case BlendFunc::SrcAlpha:

  581.                 s1[i] = GL_SRC_ALPHA; break;

  582.             case BlendFunc::OneMinusSrcAlpha:

  583.                 s1[i] = GL_ONE_MINUS_SRC_ALPHA; break;

  584.             case BlendFunc::DstAlpha:

  585.                 s1[i] = GL_DST_ALPHA; break;

  586.             case BlendFunc::OneMinusDstAlpha:

  587.                 s1[i] = GL_ONE_MINUS_DST_ALPHA; break;

  588.             case BlendFunc::ConstantColor:

  589.                 s1[i] = GL_CONSTANT_COLOR; break;

  590.             case BlendFunc::OneMinusConstantColor:

  591.                 s1[i] = GL_ONE_MINUS_CONSTANT_COLOR; break;

  592.             case BlendFunc::ConstantAlpha:

  593.                 s1[i] = GL_CONSTANT_ALPHA; break;

  594.             case BlendFunc::OneMinusConstantAlpha:

  595.                 s1[i] = GL_ONE_MINUS_CONSTANT_ALPHA; break;

  596.         }

  597.     }

  598. 

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

  600.     {

  601.         glDisable(GL_BLEND);

  602.     }

  603.     else

  604.     {

  605.         glEnable(GL_BLEND);

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

  607.     }

  608. #endif

  609. 

  610.     m_data->m_blend_src = src;

  611.     m_data->m_blend_dst = dst;

  612. }

  613. 

  614. BlendFunc Renderer::GetBlendFuncSrc() const

  615. {

  616.     return m_data->m_blend_src;

  617. }

  618. 

  619. BlendFunc Renderer::GetBlendFuncDst() const

  620. {

  621.     return m_data->m_blend_dst;

  622. }

  623. 

  624. /*

  625.  * Depth test

  626.  */

  627. 

  628. void Renderer::SetDepthFunc(DepthFunc func)

  629. {

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

  631.         return;

  632. 

  633. #if defined USE_D3D9 || defined _XBOX

  634.     switch (func)

  635.     {

  636.         case DepthFunc::Disabled:

  637.             break; /* Nothing to do */

  638.         case DepthFunc::Never:

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

  640.             break;

  641.         case DepthFunc::Less:

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

  643.             break;

  644.         case DepthFunc::Equal:

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

  646.             break;

  647.         case DepthFunc::LessOrEqual:

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

  649.             break;

  650.         case DepthFunc::Greater:

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

  652.             break;

  653.         case DepthFunc::NotEqual:

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

  655.             break;

  656.         case DepthFunc::GreaterOrEqual:

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

  658.             break;

  659.         case DepthFunc::Always:

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

  661.             break;

  662.     }

  663. 

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

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

  666.     else

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

  668. #else

  669.     switch (func)

  670.     {

  671.         case DepthFunc::Disabled:

  672.             break; /* Nothing to do */

  673.         case DepthFunc::Never:

  674.             glDepthFunc(GL_NEVER); break;

  675.         case DepthFunc::Less:

  676.             glDepthFunc(GL_LESS); break;

  677.         case DepthFunc::Equal:

  678.             glDepthFunc(GL_EQUAL); break;

  679.         case DepthFunc::LessOrEqual:

  680.             glDepthFunc(GL_LEQUAL); break;

  681.         case DepthFunc::Greater:

  682.             glDepthFunc(GL_GREATER); break;

  683.         case DepthFunc::NotEqual:

  684.             glDepthFunc(GL_NOTEQUAL); break;

  685.         case DepthFunc::GreaterOrEqual:

  686.             glDepthFunc(GL_GEQUAL); break;

  687.         case DepthFunc::Always:

  688.             glDepthFunc(GL_ALWAYS); break;

  689.     }

  690. 

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

  692.         glDisable(GL_DEPTH_TEST);

  693.     else

  694.         glEnable(GL_DEPTH_TEST);

  695. #endif

  696. 

  697.     m_data->m_depth_func = func;

  698. }

  699. 

  700. DepthFunc Renderer::GetDepthFunc() const

  701. {

  702.     return m_data->m_depth_func;

  703. }

  704. 

  705. /*

  706.  * Depth mask

  707.  */

  708. 

  709. void Renderer::SetDepthMask(DepthMask mask)

  710. {

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

  712.         return;

  713. 

  714. #if defined USE_D3D9 || defined _XBOX

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

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

  717.     else

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

  719. #else

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

  721.         glDepthMask(GL_FALSE);

  722.     else

  723.         glDepthMask(GL_TRUE);

  724. #endif

  725. 

  726.     m_data->m_depth_mask = mask;

  727. }

  728. 

  729. DepthMask Renderer::GetDepthMask() const

  730. {

  731.     return m_data->m_depth_mask;

  732. }

  733. 

  734. /*

  735.  * Face culling

  736.  */

  737. 

  738. void Renderer::SetCullMode(CullMode mode)

  739. {

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

  741.         return;

  742. 

  743. #if defined USE_D3D9 || defined _XBOX

  744.     switch (mode)

  745.     {

  746.     case CullMode::Disabled:

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

  748.         break;

  749.     case CullMode::Clockwise:

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

  751.         break;

  752.     case CullMode::CounterClockwise:

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

  754.         break;

  755.     }

  756. #else

  757.     switch (mode)

  758.     {

  759.     case CullMode::Disabled:

  760.         glDisable(GL_CULL_FACE);

  761.         break;

  762.     case CullMode::Clockwise:

  763.         glEnable(GL_CULL_FACE);

  764.         glCullFace(GL_FRONT);

  765.         glFrontFace(GL_CW);

  766.         break;

  767.     case CullMode::CounterClockwise:

  768.         glEnable(GL_CULL_FACE);

  769.         glCullFace(GL_FRONT);

  770.         glFrontFace(GL_CCW);

  771.         break;

  772.     }

  773. #endif

  774. 

  775.     m_data->m_cull_mode = mode;

  776. }

  777. 

  778. CullMode Renderer::GetCullMode() const

  779. {

  780.     return m_data->m_cull_mode;

  781. }

  782. 

  783. /*

  784.  * Polygon rendering mode

  785.  */

  786. 

  787. void Renderer::SetPolygonMode(PolygonMode mode)

  788. {

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

  790.         return;

  791. 

  792. #if defined USE_D3D9 || defined _XBOX

  793.     switch (mode)

  794.     {

  795.     case PolygonMode::Point:

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

  797.         break;

  798.     case PolygonMode::Line:

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

  800.         break;

  801.     case PolygonMode::Fill:

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

  803.         break;

  804.     }

  805. #elif defined __CELLOS_LV2__ || defined GL_VERSION_1_1

  806.     switch (mode)

  807.     {

  808.     case PolygonMode::Point:

  809.         glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);

  810.         break;

  811.     case PolygonMode::Line:

  812.         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

  813.         break;

  814.     case PolygonMode::Fill:

  815.         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

  816.         break;

  817.     }

  818. #endif

  819. 

  820.     m_data->m_polygon_mode = mode;

  821. }

  822. 

  823. PolygonMode Renderer::GetPolygonMode() const

  824. {

  825.     return m_data->m_polygon_mode;

  826. }

  827. 

  828. } /* namespace lol */