SDL2源代码分析3：渲染器（SDL_Renderer）

￡神魔★判官ぃ 2022-08-20 05:23 313阅读 0赞

=====================================================

SDL源代码分析系列文章列表：

[SDL2源代码分析1：初始化（SDL\_Init()）][SDL2_1_SDL_Init]

[SDL2源代码分析2：窗口（SDL\_Window）][SDL2_2_SDL_Window]

[SDL2源代码分析3：渲染器（SDL\_Renderer）][SDL2_3_SDL_Renderer]

[SDL2源代码分析4：纹理（SDL\_Texture）][SDL2_4_SDL_Texture]

[SDL2源代码分析5：更新纹理（SDL\_UpdateTexture()）][SDL2_5_SDL_UpdateTexture]

[SDL2源代码分析6：复制到渲染器（SDL\_RenderCopy()）][SDL2_6_SDL_RenderCopy]

[SDL2源代码分析7：显示（SDL\_RenderPresent()）][SDL2_7_SDL_RenderPresent]

[SDL2源代码分析8：视频显示总结][SDL2_8]

=====================================================

上一篇文章分析了SDL中创建窗口的函数SDL\_CreateWindow()。这篇文章继续分析SDL的源代码。本文分析SDL的渲染器（SDL\_Renderer）。

![20141103004453630][]

SDL播放视频的代码流程如下所示。

初始化:

> SDL\_Init(): 初始化SDL。  
> SDL\_CreateWindow(): 创建窗口（Window）。  
> SDL\_CreateRenderer(): 基于窗口创建渲染器（Render）。  
> SDL\_CreateTexture(): 创建纹理（Texture）。

循环渲染数据:

> SDL\_UpdateTexture(): 设置纹理的数据。  
> SDL\_RenderCopy(): 纹理复制给渲染器。
> 
> SDL\_RenderPresent(): 显示。

上篇文章分析了该流程中的第2个函数SDL\_CreateWindow()。本文继续分析该流程中的第3个函数SDL\_CreateRenderer()。

## SDL\_Renderer ##

SDL\_Renderer结构体定义了一个SDL2中的渲染器。如果直接使用SDL2编译好的SDK的话，是看不到它的内部结构的。有关它的定义在头文件中只有一行代码，如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\*\*
2.   \* \\brief A structure representing rendering state
3.   \*/
4.  **struct** SDL\_Renderer; 
5.  **typedef****struct** SDL\_Renderer SDL\_Renderer;

在源代码工程中可以看到SDL\_Renderer的定义，位于render\\SDL\_sysrender.h文件中。它的定义如下。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\* Define the SDL renderer structure \*/
2.  **struct** SDL\_Renderer 
3.  \{ 
4.  **const****void** \*magic; 
5.  
6.  
7.  **void** (\*WindowEvent) (SDL\_Renderer \* renderer, **const** SDL\_WindowEvent \*event); 
8.  **int** (\*GetOutputSize) (SDL\_Renderer \* renderer, **int** \*w, **int** \*h); 
9.  **int** (\*CreateTexture) (SDL\_Renderer \* renderer, SDL\_Texture \* texture); 
10. **int** (\*SetTextureColorMod) (SDL\_Renderer \* renderer, 
11.  SDL\_Texture \* texture); 
12. **int** (\*SetTextureAlphaMod) (SDL\_Renderer \* renderer, 
13.  SDL\_Texture \* texture); 
14. **int** (\*SetTextureBlendMode) (SDL\_Renderer \* renderer, 
15.  SDL\_Texture \* texture); 
16. **int** (\*UpdateTexture) (SDL\_Renderer \* renderer, SDL\_Texture \* texture, 
17. **const** SDL\_Rect \* rect, **const****void** \*pixels, 
18. **int** pitch); 
19. **int** (\*UpdateTextureYUV) (SDL\_Renderer \* renderer, SDL\_Texture \* texture, 
20. **const** SDL\_Rect \* rect, 
21. **const** Uint8 \*Yplane, **int** Ypitch, 
22. **const** Uint8 \*Uplane, **int** Upitch, 
23. **const** Uint8 \*Vplane, **int** Vpitch); 
24. **int** (\*LockTexture) (SDL\_Renderer \* renderer, SDL\_Texture \* texture, 
25. **const** SDL\_Rect \* rect, **void** \*\*pixels, **int** \*pitch); 
26. **void** (\*UnlockTexture) (SDL\_Renderer \* renderer, SDL\_Texture \* texture); 
27. **int** (\*SetRenderTarget) (SDL\_Renderer \* renderer, SDL\_Texture \* texture); 
28. **int** (\*UpdateViewport) (SDL\_Renderer \* renderer); 
29. **int** (\*UpdateClipRect) (SDL\_Renderer \* renderer); 
30. **int** (\*RenderClear) (SDL\_Renderer \* renderer); 
31. **int** (\*RenderDrawPoints) (SDL\_Renderer \* renderer, **const** SDL\_FPoint \* points, 
32. **int** count); 
33. **int** (\*RenderDrawLines) (SDL\_Renderer \* renderer, **const** SDL\_FPoint \* points, 
34. **int** count); 
35. **int** (\*RenderFillRects) (SDL\_Renderer \* renderer, **const** SDL\_FRect \* rects, 
36. **int** count); 
37. **int** (\*RenderCopy) (SDL\_Renderer \* renderer, SDL\_Texture \* texture, 
38. **const** SDL\_Rect \* srcrect, **const** SDL\_FRect \* dstrect); 
39. **int** (\*RenderCopyEx) (SDL\_Renderer \* renderer, SDL\_Texture \* texture, 
40. **const** SDL\_Rect \* srcquad, **const** SDL\_FRect \* dstrect, 
41. **const****double** angle, **const** SDL\_FPoint \*center, **const** SDL\_RendererFlip flip); 
42. **int** (\*RenderReadPixels) (SDL\_Renderer \* renderer, **const** SDL\_Rect \* rect, 
43.  Uint32 format, **void** \* pixels, **int** pitch); 
44. **void** (\*RenderPresent) (SDL\_Renderer \* renderer); 
45. **void** (\*DestroyTexture) (SDL\_Renderer \* renderer, SDL\_Texture \* texture); 
46. 
47. 
48. **void** (\*DestroyRenderer) (SDL\_Renderer \* renderer); 
49. 
50. 
51. **int** (\*GL\_BindTexture) (SDL\_Renderer \* renderer, SDL\_Texture \*texture, **float** \*texw, **float** \*texh); 
52. **int** (\*GL\_UnbindTexture) (SDL\_Renderer \* renderer, SDL\_Texture \*texture); 
53. 
54. 
55. /\* The current renderer info \*/
56.  SDL\_RendererInfo info; 
57. 
58. 
59. /\* The window associated with the renderer \*/
60.  SDL\_Window \*window; 
61.  SDL\_bool hidden; 
62. 
63. 
64. /\* The logical resolution for rendering \*/
65. **int** logical\_w; 
66. **int** logical\_h; 
67. **int** logical\_w\_backup; 
68. **int** logical\_h\_backup; 
69. 
70. 
71. /\* The drawable area within the window \*/
72.  SDL\_Rect viewport; 
73.  SDL\_Rect viewport\_backup; 
74. 
75. 
76. /\* The clip rectangle within the window \*/
77.  SDL\_Rect clip\_rect; 
78.  SDL\_Rect clip\_rect\_backup; 
79. 
80. 
81. /\* The render output coordinate scale \*/
82.  SDL\_FPoint scale; 
83.  SDL\_FPoint scale\_backup; 
84. 
85. 
86. /\* The list of textures \*/
87.  SDL\_Texture \*textures; 
88.  SDL\_Texture \*target; 
89. 
90. 
91.  Uint8 r, g, b, a; /\*\*< Color for drawing operations values \*/
92.  SDL\_BlendMode blendMode; /\*\*< The drawing blend mode \*/
93. 
94. 
95. **void** \*driverdata; 
96. \};

通过代码可以看出其中包含了一个“渲染器”应该包含的各种属性。这个结构体中的各个变量还没有深入研究，暂不详细分析。下面来看看如何创建这个SDL\_Renderer。

## SDL\_CreateRenderer() ##

**函数简介**

SDL中使用SDL\_CreateRenderer()基于窗口创建渲染器。SDL\_CreateRenderer()原型如下。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  SDL\_Renderer \* SDLCALL SDL\_CreateRenderer(SDL\_Window \* window, 
2.  **int** index, Uint32 flags);

参数含义如下。

window： 渲染的目标窗口。

index：打算初始化的渲染设备的索引。设置“-1”则初始化默认的渲染设备。

flags：支持以下值（位于SDL\_RendererFlags定义中）

SDL\_RENDERER\_SOFTWARE ：使用软件渲染

SDL\_RENDERER\_ACCELERATED ：使用硬件加速

SDL\_RENDERER\_PRESENTVSYNC：和显示器的刷新率同步

SDL\_RENDERER\_TARGETTEXTURE ：不太懂

返回创建完成的渲染器的ID。如果创建失败则返回NULL。

**函数调用关系图**

SDL\_CreateRenderer()关键函数的调用关系可以用下图表示。

[![SouthEast][]][SouthEast 1]

上述图片不太清晰，相册里面上传了一份原始的大图片：

[http://my.csdn.net/leixiaohua1020/album/detail/1793385][SouthEast 1]

打开上述相册里面的图片，右键选择“另存为”即可保存原始图片。

**源码分析**

SDL\_CreateRenderer()的源代码位于render\\SDL\_render.c中，如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  SDL\_Renderer \* SDL\_CreateRenderer(SDL\_Window \* window, **int** index, Uint32 flags) 
2.  \{ 
3.  \#if !SDL\_RENDER\_DISABLED
4.   SDL\_Renderer \*renderer = NULL; 
5.  **int** n = SDL\_GetNumRenderDrivers(); 
6.  **const****char** \*hint; 
7.  
8.  
9.  **if** (!window) \{ 
10.  SDL\_SetError("Invalid window"); 
11. **return** NULL; 
12.  \} 
13. 
14. 
15. **if** (SDL\_GetRenderer(window)) \{ 
16.  SDL\_SetError("Renderer already associated with window"); 
17. **return** NULL; 
18.  \} 
19. 
20. 
21.  hint = SDL\_GetHint(SDL\_HINT\_RENDER\_VSYNC); 
22. **if** (hint) \{ 
23. **if** (\*hint == '0') \{ 
24.  flags &= ~SDL\_RENDERER\_PRESENTVSYNC; 
25.  \} **else** \{ 
26.  flags |= SDL\_RENDERER\_PRESENTVSYNC; 
27.  \} 
28.  \} 
29. 
30. 
31. **if** (index < 0) \{ 
32.  hint = SDL\_GetHint(SDL\_HINT\_RENDER\_DRIVER); 
33. **if** (hint) \{ 
34. **for** (index = 0; index < n; ++index) \{ 
35. **const** SDL\_RenderDriver \*driver = render\_drivers\[index\]; 
36. 
37. 
38. **if** (SDL\_strcasecmp(hint, driver->info.name) == 0) \{ 
39. /\* Create a new renderer instance \*/
40.  renderer = driver->CreateRenderer(window, flags); 
41. **break**; 
42.  \} 
43.  \} 
44.  \} 
45. 
46. 
47. **if** (!renderer) \{ 
48. **for** (index = 0; index < n; ++index) \{ 
49. **const** SDL\_RenderDriver \*driver = render\_drivers\[index\]; 
50. 
51. 
52. **if** ((driver->info.flags & flags) == flags) \{ 
53. /\* Create a new renderer instance \*/
54.  renderer = driver->CreateRenderer(window, flags); 
55. **if** (renderer) \{ 
56. /\* Yay, we got one! \*/
57. **break**; 
58.  \} 
59.  \} 
60.  \} 
61.  \} 
62. **if** (index == n) \{ 
63.  SDL\_SetError("Couldn't find matching render driver"); 
64. **return** NULL; 
65.  \} 
66.  \} **else** \{ 
67. **if** (index >= SDL\_GetNumRenderDrivers()) \{ 
68.  SDL\_SetError("index must be -1 or in the range of 0 - %d", 
69.  SDL\_GetNumRenderDrivers() - 1); 
70. **return** NULL; 
71.  \} 
72. /\* Create a new renderer instance \*/
73.  renderer = render\_drivers\[index\]->CreateRenderer(window, flags); 
74.  \} 
75. 
76. 
77. **if** (renderer) \{ 
78.  renderer->magic = &renderer\_magic; 
79.  renderer->window = window; 
80.  renderer->scale.x = 1.0f; 
81.  renderer->scale.y = 1.0f; 
82. 
83. 
84. **if** (SDL\_GetWindowFlags(window) & (SDL\_WINDOW\_HIDDEN|SDL\_WINDOW\_MINIMIZED)) \{ 
85.  renderer->hidden = SDL\_TRUE; 
86.  \} **else** \{ 
87.  renderer->hidden = SDL\_FALSE; 
88.  \} 
89. 
90. 
91.  SDL\_SetWindowData(window, SDL\_WINDOWRENDERDATA, renderer); 
92. 
93. 
94.  SDL\_RenderSetViewport(renderer, NULL); 
95. 
96. 
97.  SDL\_AddEventWatch(SDL\_RendererEventWatch, renderer); 
98. 
99. 
100.  SDL\_LogInfo(SDL\_LOG\_CATEGORY\_RENDER, 
101. "Created renderer: %s", renderer->info.name); 
102.  \} 
103. **return** renderer; 
104. \#else
105.  SDL\_SetError("SDL not built with rendering support"); 
106. **return** NULL; 
107. \#endif
108. \}

SDL\_CreateRenderer()中最重要的一个函数就是它调用了SDL\_RenderDriver的CreateRenderer()方法。通过该方法可以创建一个渲染器。围绕着这个方法，包含了一些初始化工作以及一些收尾工作。下面针对这个最核心的函数进行分析。  
我们首先来看一下SDL\_RenderDriver这个结构体。从字面的意思可以看出它代表了“渲染器的驱动程序”。这个结构体的定义如下。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\* Define the SDL render driver structure \*/
2.  **struct** SDL\_RenderDriver 
3.  \{ 
4.   SDL\_Renderer \*(\*CreateRenderer) (SDL\_Window \* window, Uint32 flags); 
5.  
6.  
7.  /\* Info about the renderer capabilities \*/
8.   SDL\_RendererInfo info; 
9.  \};

从代码中可以看出，这个结构体的成员比较简单，包含了一个函数指针CreateRenderer()和一个存储信息的SDL\_RendererInfo类型的结构体info。CreateRenderer()是用于创建渲染器的函数，而SDL\_RendererInfo则包含了该结构体的一些信息，可以看一下SDL\_RendererInfo的定义。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\*\*
2.   \* \\brief Information on the capabilities of a render driver or context.
3.   \*/
4.  **typedef****struct** SDL\_RendererInfo 
5.  \{ 
6.  **const****char** \*name; /\*\*< The name of the renderer \*/
7.   Uint32 flags; /\*\*< Supported ::SDL\_RendererFlags \*/
8.   Uint32 num\_texture\_formats; /\*\*< The number of available texture formats \*/
9.   Uint32 texture\_formats\[16\]; /\*\*< The available texture formats \*/
10. **int** max\_texture\_width; /\*\*< The maximimum texture width \*/
11. **int** max\_texture\_height; /\*\*< The maximimum texture height \*/
12. \} SDL\_RendererInfo;

在SDL中有一个全局的SDL\_RenderDriver类型的静态数组render\_drivers，其中存储了SDL支持的所有渲染器。该数组定义如下。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static****const** SDL\_RenderDriver \*render\_drivers\[\] = \{ 
2.  \#if SDL\_VIDEO\_RENDER\_D3D
3.   &D3D\_RenderDriver, 
4.  \#endif
5.  \#if SDL\_VIDEO\_RENDER\_D3D11
6.   &D3D11\_RenderDriver, 
7.  \#endif
8.  \#if SDL\_VIDEO\_RENDER\_OGL
9.   &GL\_RenderDriver, 
10. \#endif
11. \#if SDL\_VIDEO\_RENDER\_OGL\_ES2
12.  &GLES2\_RenderDriver, 
13. \#endif
14. \#if SDL\_VIDEO\_RENDER\_OGL\_ES
15.  &GLES\_RenderDriver, 
16. \#endif
17. \#if SDL\_VIDEO\_RENDER\_DIRECTFB
18.  &DirectFB\_RenderDriver, 
19. \#endif
20. \#if SDL\_VIDEO\_RENDER\_PSP
21.  &PSP\_RenderDriver, 
22. \#endif
23.  &SW\_RenderDriver 
24. \};

从render\_drivers数组的定义可以看出，其中包含了Direct3D，OpenGL，OpenGL ES等各种渲染器的驱动程序。我们可以选择几个看一下。  
例如Direct3D的渲染器驱动程序D3D\_RenderDriver的定义如下（位于render\\direct3d\\SDL\_render\_d3d.c）。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  SDL\_RenderDriver D3D\_RenderDriver = \{ 
2.   D3D\_CreateRenderer, 
3.   \{ 
4.  "direct3d", 
5.   (SDL\_RENDERER\_ACCELERATED | SDL\_RENDERER\_PRESENTVSYNC | SDL\_RENDERER\_TARGETTEXTURE), 
6.   1, 
7.   \{SDL\_PIXELFORMAT\_ARGB8888\}, 
8.   0, 
9.   0\} 
10. \};

可以看出创建Direct3D渲染器的函数是D3D\_CreateRenderer()。  
  
OpenGL的渲染器驱动程序GL\_RenderDriver的定义如下（位于render\\opengl\\SDL\_render\_gl.c）。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  SDL\_RenderDriver GL\_RenderDriver = \{ 
2.   GL\_CreateRenderer, 
3.   \{ 
4.  "opengl", 
5.   (SDL\_RENDERER\_ACCELERATED | SDL\_RENDERER\_PRESENTVSYNC | SDL\_RENDERER\_TARGETTEXTURE), 
6.   1, 
7.   \{SDL\_PIXELFORMAT\_ARGB8888\}, 
8.   0, 
9.   0\} 
10. \};

可以看出创建OpenGL渲染器的函数是GL\_CreateRenderer()。  
  
  
软件渲染器驱动程序SW\_RenderDriver的定义如下（位于render\\software\\SDL\_render\_sw.c）。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  SDL\_RenderDriver SW\_RenderDriver = \{ 
2.   SW\_CreateRenderer, 
3.   \{ 
4.  "software", 
5.   SDL\_RENDERER\_SOFTWARE | SDL\_RENDERER\_TARGETTEXTURE, 
6.   8, 
7.   \{ 
8.   SDL\_PIXELFORMAT\_RGB555, 
9.   SDL\_PIXELFORMAT\_RGB565, 
10.  SDL\_PIXELFORMAT\_RGB888, 
11.  SDL\_PIXELFORMAT\_BGR888, 
12.  SDL\_PIXELFORMAT\_ARGB8888, 
13.  SDL\_PIXELFORMAT\_RGBA8888, 
14.  SDL\_PIXELFORMAT\_ABGR8888, 
15.  SDL\_PIXELFORMAT\_BGRA8888 
16.  \}, 
17.  0, 
18.  0\} 
19. \};

可以看出创建软件渲染器的函数是SW\_CreateRenderer ()。  
  
  
有关SDL\_RenderDriver这个结构体就不再多说了。下面分别看一下Direct3D，OpenGL，Software这三种最常见的渲染器的创建方法。

### 1.Direct3D ###

Direct3D 的渲染器在创建函数是D3D\_CreateRenderer()。该函数位于render\\direct3d\\SDL\_render\_d3d.c文件中。首先看一下它的代码。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  SDL\_Renderer \* D3D\_CreateRenderer(SDL\_Window \* window, Uint32 flags) 
2.  \{ 
3.   SDL\_Renderer \*renderer; 
4.   D3D\_RenderData \*data; 
5.   SDL\_SysWMinfo windowinfo; 
6.  **HRESULT** result; 
7.  **const****char** \*hint; 
8.   D3DPRESENT\_PARAMETERS pparams; 
9.   IDirect3DSwapChain9 \*chain; 
10.  D3DCAPS9 caps; 
11. **DWORD** device\_flags; 
12.  Uint32 window\_flags; 
13. **int** w, h; 
14.  SDL\_DisplayMode fullscreen\_mode; 
15. **int** displayIndex; 
16. 
17. 
18.  renderer = (SDL\_Renderer \*) SDL\_calloc(1, **sizeof**(\*renderer)); 
19. **if** (!renderer) \{ 
20.  SDL\_OutOfMemory(); 
21. **return** NULL; 
22.  \} 
23. 
24. 
25.  data = (D3D\_RenderData \*) SDL\_calloc(1, **sizeof**(\*data)); 
26. **if** (!data) \{ 
27.  SDL\_free(renderer); 
28.  SDL\_OutOfMemory(); 
29. **return** NULL; 
30.  \} 
31. 
32. 
33. **if** (!D3D\_LoadDLL(&data->d3dDLL, &data->d3d)) \{ 
34.  SDL\_free(renderer); 
35.  SDL\_free(data); 
36.  SDL\_SetError("Unable to create Direct3D interface"); 
37. **return** NULL; 
38.  \} 
39. 
40. 
41.  renderer->WindowEvent = D3D\_WindowEvent; 
42.  renderer->CreateTexture = D3D\_CreateTexture; 
43.  renderer->UpdateTexture = D3D\_UpdateTexture; 
44.  renderer->UpdateTextureYUV = D3D\_UpdateTextureYUV; 
45.  renderer->LockTexture = D3D\_LockTexture; 
46.  renderer->UnlockTexture = D3D\_UnlockTexture; 
47.  renderer->SetRenderTarget = D3D\_SetRenderTarget; 
48.  renderer->UpdateViewport = D3D\_UpdateViewport; 
49.  renderer->UpdateClipRect = D3D\_UpdateClipRect; 
50.  renderer->RenderClear = D3D\_RenderClear; 
51.  renderer->RenderDrawPoints = D3D\_RenderDrawPoints; 
52.  renderer->RenderDrawLines = D3D\_RenderDrawLines; 
53.  renderer->RenderFillRects = D3D\_RenderFillRects; 
54.  renderer->RenderCopy = D3D\_RenderCopy; 
55.  renderer->RenderCopyEx = D3D\_RenderCopyEx; 
56.  renderer->RenderReadPixels = D3D\_RenderReadPixels; 
57.  renderer->RenderPresent = D3D\_RenderPresent; 
58.  renderer->DestroyTexture = D3D\_DestroyTexture; 
59.  renderer->DestroyRenderer = D3D\_DestroyRenderer; 
60.  renderer->info = D3D\_RenderDriver.info; 
61.  renderer->info.flags = (SDL\_RENDERER\_ACCELERATED | SDL\_RENDERER\_TARGETTEXTURE); 
62.  renderer->driverdata = data; 
63. 
64. 
65.  SDL\_VERSION(&windowinfo.version); 
66.  SDL\_GetWindowWMInfo(window, &windowinfo); 
67. 
68. 
69.  window\_flags = SDL\_GetWindowFlags(window); 
70.  SDL\_GetWindowSize(window, &w, &h); 
71.  SDL\_GetWindowDisplayMode(window, &fullscreen\_mode); 
72. 
73. 
74.  SDL\_zero(pparams); 
75.  pparams.hDeviceWindow = windowinfo.info.win.window; 
76.  pparams.BackBufferWidth = w; 
77.  pparams.BackBufferHeight = h; 
78. **if** (window\_flags & SDL\_WINDOW\_FULLSCREEN) \{ 
79.  pparams.BackBufferFormat = 
80.  PixelFormatToD3DFMT(fullscreen\_mode.format); 
81.  \} **else** \{ 
82.  pparams.BackBufferFormat = D3DFMT\_UNKNOWN; 
83.  \} 
84.  pparams.BackBufferCount = 1; 
85.  pparams.SwapEffect = D3DSWAPEFFECT\_DISCARD; 
86. 
87. 
88. **if** (window\_flags & SDL\_WINDOW\_FULLSCREEN) \{ 
89. **if** ((window\_flags & SDL\_WINDOW\_FULLSCREEN\_DESKTOP) == SDL\_WINDOW\_FULLSCREEN\_DESKTOP) \{ 
90.  pparams.Windowed = TRUE; 
91.  pparams.FullScreen\_RefreshRateInHz = 0; 
92.  \} **else** \{ 
93.  pparams.Windowed = FALSE; 
94.  pparams.FullScreen\_RefreshRateInHz = fullscreen\_mode.refresh\_rate; 
95.  \} 
96.  \} **else** \{ 
97.  pparams.Windowed = TRUE; 
98.  pparams.FullScreen\_RefreshRateInHz = 0; 
99.  \} 
100. **if** (flags & SDL\_RENDERER\_PRESENTVSYNC) \{ 
101.  pparams.PresentationInterval = D3DPRESENT\_INTERVAL\_ONE; 
102.  \} **else** \{ 
103.  pparams.PresentationInterval = D3DPRESENT\_INTERVAL\_IMMEDIATE; 
104.  \} 
105. 
106. 
107. /\* Get the adapter for the display that the window is on \*/
108.  displayIndex = SDL\_GetWindowDisplayIndex(window); 
109.  data->adapter = SDL\_Direct3D9GetAdapterIndex(displayIndex); 
110. 
111. 
112.  IDirect3D9\_GetDeviceCaps(data->d3d, data->adapter, D3DDEVTYPE\_HAL, &caps); 
113. 
114. 
115.  device\_flags = D3DCREATE\_FPU\_PRESERVE; 
116. **if** (caps.DevCaps & D3DDEVCAPS\_HWTRANSFORMANDLIGHT) \{ 
117.  device\_flags |= D3DCREATE\_HARDWARE\_VERTEXPROCESSING; 
118.  \} **else** \{ 
119.  device\_flags |= D3DCREATE\_SOFTWARE\_VERTEXPROCESSING; 
120.  \} 
121. 
122. 
123.  hint = SDL\_GetHint(SDL\_HINT\_RENDER\_DIRECT3D\_THREADSAFE); 
124. **if** (hint && SDL\_atoi(hint)) \{ 
125.  device\_flags |= D3DCREATE\_MULTITHREADED; 
126.  \} 
127. 
128. 
129.  result = IDirect3D9\_CreateDevice(data->d3d, data->adapter, 
130.  D3DDEVTYPE\_HAL, 
131.  pparams.hDeviceWindow, 
132.  device\_flags, 
133.  &pparams, &data->device); 
134. **if** (FAILED(result)) \{ 
135.  D3D\_DestroyRenderer(renderer); 
136.  D3D\_SetError("CreateDevice()", result); 
137. **return** NULL; 
138.  \} 
139. 
140. 
141. /\* Get presentation parameters to fill info \*/
142.  result = IDirect3DDevice9\_GetSwapChain(data->device, 0, &chain); 
143. **if** (FAILED(result)) \{ 
144.  D3D\_DestroyRenderer(renderer); 
145.  D3D\_SetError("GetSwapChain()", result); 
146. **return** NULL; 
147.  \} 
148.  result = IDirect3DSwapChain9\_GetPresentParameters(chain, &pparams); 
149. **if** (FAILED(result)) \{ 
150.  IDirect3DSwapChain9\_Release(chain); 
151.  D3D\_DestroyRenderer(renderer); 
152.  D3D\_SetError("GetPresentParameters()", result); 
153. **return** NULL; 
154.  \} 
155.  IDirect3DSwapChain9\_Release(chain); 
156. **if** (pparams.PresentationInterval == D3DPRESENT\_INTERVAL\_ONE) \{ 
157.  renderer->info.flags |= SDL\_RENDERER\_PRESENTVSYNC; 
158.  \} 
159.  data->pparams = pparams; 
160. 
161. 
162.  IDirect3DDevice9\_GetDeviceCaps(data->device, &caps); 
163.  renderer->info.max\_texture\_width = caps.MaxTextureWidth; 
164.  renderer->info.max\_texture\_height = caps.MaxTextureHeight; 
165. **if** (caps.NumSimultaneousRTs >= 2) \{ 
166.  renderer->info.flags |= SDL\_RENDERER\_TARGETTEXTURE; 
167.  \} 
168. 
169. 
170. **if** (caps.PrimitiveMiscCaps & D3DPMISCCAPS\_SEPARATEALPHABLEND) \{ 
171.  data->enableSeparateAlphaBlend = SDL\_TRUE; 
172.  \} 
173. 
174. 
175. /\* Store the default render target \*/
176.  IDirect3DDevice9\_GetRenderTarget(data->device, 0, &data->defaultRenderTarget ); 
177.  data->currentRenderTarget = NULL; 
178. 
179. 
180. /\* Set up parameters for rendering \*/
181.  D3D\_InitRenderState(data); 
182. 
183. 
184. **if** (caps.MaxSimultaneousTextures >= 3) 
185.  \{ 
186. \#ifdef ASSEMBLE\_SHADER
187. /\* This shader was created by running the following HLSL through the fxc compiler
188.  and then tuning the generated assembly.
189. 
190. 
191.  fxc /T fx\_4\_0 /O3 /Gfa /Fc yuv.fxc yuv.fx
192. 
193. 
194.  \--- yuv.fx ---
195.  Texture2D g\_txY;
196.  Texture2D g\_txU;
197.  Texture2D g\_txV;
198. 
199. 
200.  SamplerState samLinear
201.  \{ 
202.  Filter = ANISOTROPIC;
203.  AddressU = Clamp;
204.  AddressV = Clamp;
205.  MaxAnisotropy = 1;
206.  \};
207. 
208. 
209.  struct VS\_OUTPUT
210.  \{ 
211.  float2 TextureUV : TEXCOORD0;
212.  \};
213. 
214. 
215.  struct PS\_OUTPUT
216.  \{ 
217.  float4 RGBAColor : SV\_Target;
218.  \};
219. 
220. 
221.  PS\_OUTPUT YUV420( VS\_OUTPUT In ) 
222.  \{ 
223.  const float3 offset = \{-0.0625, -0.5, -0.5\};
224.  const float3 Rcoeff = \{1.164, 0.000, 1.596\};
225.  const float3 Gcoeff = \{1.164, -0.391, -0.813\};
226.  const float3 Bcoeff = \{1.164, 2.018, 0.000\};
227. 
228. 
229.  PS\_OUTPUT Output;
230.  float2 TextureUV = In.TextureUV;
231. 
232. 
233.  float3 yuv;
234.  yuv.x = g\_txY.Sample( samLinear, TextureUV ).r;
235.  yuv.y = g\_txU.Sample( samLinear, TextureUV ).r;
236.  yuv.z = g\_txV.Sample( samLinear, TextureUV ).r;
237. 
238. 
239.  yuv += offset;
240.  Output.RGBAColor.r = dot(yuv, Rcoeff);
241.  Output.RGBAColor.g = dot(yuv, Gcoeff);
242.  Output.RGBAColor.b = dot(yuv, Bcoeff);
243.  Output.RGBAColor.a = 1.0f;
244. 
245. 
246.  return Output;
247.  \}
248. 
249. 
250.  technique10 RenderYUV420
251.  \{ 
252.  pass P0
253.  \{ 
254.  SetPixelShader( CompileShader( ps\_4\_0\_level\_9\_0, YUV420() ) );
255.  \}
256.  \}
257.  \*/
258. **const****char** \*shader\_text = 
259. "ps\_2\_0\\n"
260. "def c0, -0.0625, -0.5, -0.5, 1\\n"
261. "def c1, 1.16400003, 0, 1.59599996, 0\\n"
262. "def c2, 1.16400003, -0.391000003, -0.813000023, 0\\n"
263. "def c3, 1.16400003, 2.01799989, 0, 0\\n"
264. "dcl t0.xy\\n"
265. "dcl v0.xyzw\\n"
266. "dcl\_2d s0\\n"
267. "dcl\_2d s1\\n"
268. "dcl\_2d s2\\n"
269. "texld r0, t0, s0\\n"
270. "texld r1, t0, s1\\n"
271. "texld r2, t0, s2\\n"
272. "mov r0.y, r1.x\\n"
273. "mov r0.z, r2.x\\n"
274. "add r0.xyz, r0, c0\\n"
275. "dp3 r1.x, r0, c1\\n"
276. "dp3 r1.y, r0, c2\\n"
277. "dp2add r1.z, r0, c3, c3.z\\n"/\* Logically this is "dp3 r1.z, r0, c3" but the optimizer did its magic \*/
278. "mov r1.w, c0.w\\n"
279. "mul r0, r1, v0\\n"/\* Not in the HLSL, multiply by vertex color \*/
280. "mov oC0, r0\\n"
281.  ; 
282.  LPD3DXBUFFER pCode; 
283.  LPD3DXBUFFER pErrorMsgs; 
284. **LPDWORD** shader\_data = NULL; 
285. **DWORD** shader\_size = 0; 
286.  result = D3DXAssembleShader(shader\_text, SDL\_strlen(shader\_text), NULL, NULL, 0, &pCode, &pErrorMsgs); 
287. **if** (!FAILED(result)) \{ 
288.  shader\_data = (**DWORD**\*)pCode->lpVtbl->GetBufferPointer(pCode); 
289.  shader\_size = pCode->lpVtbl->GetBufferSize(pCode); 
290.  PrintShaderData(shader\_data, shader\_size); 
291.  \} **else** \{ 
292. **const****char** \*error = (**const****char** \*)pErrorMsgs->lpVtbl->GetBufferPointer(pErrorMsgs); 
293.  SDL\_SetError("Couldn't assemble shader: %s", error); 
294.  \} 
295. \#else
296. **const****DWORD** shader\_data\[\] = \{ 
297.  0xffff0200, 0x05000051, 0xa00f0000, 0xbd800000, 0xbf000000, 0xbf000000, 
298.  0x3f800000, 0x05000051, 0xa00f0001, 0x3f94fdf4, 0x00000000, 0x3fcc49ba, 
299.  0x00000000, 0x05000051, 0xa00f0002, 0x3f94fdf4, 0xbec83127, 0xbf5020c5, 
300.  0x00000000, 0x05000051, 0xa00f0003, 0x3f94fdf4, 0x400126e9, 0x00000000, 
301.  0x00000000, 0x0200001f, 0x80000000, 0xb0030000, 0x0200001f, 0x80000000, 
302.  0x900f0000, 0x0200001f, 0x90000000, 0xa00f0800, 0x0200001f, 0x90000000, 
303.  0xa00f0801, 0x0200001f, 0x90000000, 0xa00f0802, 0x03000042, 0x800f0000, 
304.  0xb0e40000, 0xa0e40800, 0x03000042, 0x800f0001, 0xb0e40000, 0xa0e40801, 
305.  0x03000042, 0x800f0002, 0xb0e40000, 0xa0e40802, 0x02000001, 0x80020000, 
306.  0x80000001, 0x02000001, 0x80040000, 0x80000002, 0x03000002, 0x80070000, 
307.  0x80e40000, 0xa0e40000, 0x03000008, 0x80010001, 0x80e40000, 0xa0e40001, 
308.  0x03000008, 0x80020001, 0x80e40000, 0xa0e40002, 0x0400005a, 0x80040001, 
309.  0x80e40000, 0xa0e40003, 0xa0aa0003, 0x02000001, 0x80080001, 0xa0ff0000, 
310.  0x03000005, 0x800f0000, 0x80e40001, 0x90e40000, 0x02000001, 0x800f0800, 
311.  0x80e40000, 0x0000ffff 
312.  \}; 
313. \#endif
314. **if** (shader\_data != NULL) \{ 
315.  result = IDirect3DDevice9\_CreatePixelShader(data->device, shader\_data, &data->ps\_yuv); 
316. **if** (!FAILED(result)) \{ 
317.  renderer->info.texture\_formats\[renderer->info.num\_texture\_formats++\] = SDL\_PIXELFORMAT\_YV12; 
318.  renderer->info.texture\_formats\[renderer->info.num\_texture\_formats++\] = SDL\_PIXELFORMAT\_IYUV; 
319.  \} **else** \{ 
320.  D3D\_SetError("CreatePixelShader()", result); 
321.  \} 
322.  \} 
323.  \} 
324. 
325. 
326. **return** renderer; 
327. \}

D3D\_CreateRenderer()这个函数的代码很长。在这里提取它最重点的几个进行简单的分析。

PS：由于这个函数中包含了大量的Direct3D的API，这方面如果不熟悉的话，可以参考以下两篇文章：

《[最简单的视音频播放示例3：Direct3D播放YUV，RGB（通过Surface）][3_Direct3D_YUV_RGB_Surface]》

《[最简单的视音频播放示例4：Direct3D播放RGB（通过Texture）][4_Direct3D_RGB_Texture]》

（1）为SDL\_Renderer分配内存  
这一步比较简单。直接使用SDL\_calloc()分配内存就可以了。SDL\_calloc()实际上就是calloc()，这一点在前面的文章中已经叙述，在这里不再重复。  
（2）加载Direct3D  
加载Direct3D通过函数D3D\_LoadDLL()完成。调用该函数可以得到一个IDirect3D9类型的接口。IDirect3D9接口可以用于完成D3D后续的初始化工作。D3D\_LoadDLL()函数的代码如下。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  SDL\_bool D3D\_LoadDLL( **void** \*\*pD3DDLL, IDirect3D9 \*\*pDirect3D9Interface ) 
2.  \{ 
3.   \*pD3DDLL = SDL\_LoadObject("D3D9.DLL"); 
4.  **if** (\*pD3DDLL) \{ 
5.   IDirect3D9 \*(WINAPI \* D3DCreate) (**UINT** SDKVersion); 
6.  
7.  
8.   D3DCreate = 
9.   (IDirect3D9 \* (WINAPI \*) (**UINT**)) SDL\_LoadFunction(\*pD3DDLL, 
10. "Direct3DCreate9"); 
11. **if** (D3DCreate) \{ 
12.  \*pDirect3D9Interface = D3DCreate(D3D\_SDK\_VERSION); 
13.  \} 
14. **if** (!\*pDirect3D9Interface) \{ 
15.  SDL\_UnloadObject(\*pD3DDLL); 
16.  \*pD3DDLL = NULL; 
17. **return** SDL\_FALSE; 
18.  \} 
19. 
20. 
21. **return** SDL\_TRUE; 
22.  \} **else** \{ 
23.  \*pDirect3D9Interface = NULL; 
24. **return** SDL\_FALSE; 
25.  \} 
26. \}

从代码中可以看出，该函数加载了一个“D3D9.DLL”的Dll，并且调用了其中的Direct3DCreate9()方法。  
  
  
（3）渲染器接口函数赋值

SDL\_Render结构体中有一系列的函数指针，包含了有关渲染器的各种功能。SDL通过调用这些函数指针就可以调用渲染器相应的功能。这是SDL支持多种渲染器的一个重要特点。代码如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  renderer->WindowEvent = D3D\_WindowEvent; 
2.  renderer->CreateTexture = D3D\_CreateTexture; 
3.  renderer->UpdateTexture = D3D\_UpdateTexture; 
4.  renderer->UpdateTextureYUV = D3D\_UpdateTextureYUV; 
5.  renderer->LockTexture = D3D\_LockTexture; 
6.  renderer->UnlockTexture = D3D\_UnlockTexture; 
7.  renderer->SetRenderTarget = D3D\_SetRenderTarget; 
8.  renderer->UpdateViewport = D3D\_UpdateViewport; 
9.  renderer->UpdateClipRect = D3D\_UpdateClipRect; 
10. renderer->RenderClear = D3D\_RenderClear; 
11. renderer->RenderDrawPoints = D3D\_RenderDrawPoints; 
12. renderer->RenderDrawLines = D3D\_RenderDrawLines; 
13. renderer->RenderFillRects = D3D\_RenderFillRects; 
14. renderer->RenderCopy = D3D\_RenderCopy; 
15. renderer->RenderCopyEx = D3D\_RenderCopyEx; 
16. renderer->RenderReadPixels = D3D\_RenderReadPixels; 
17. renderer->RenderPresent = D3D\_RenderPresent; 
18. renderer->DestroyTexture = D3D\_DestroyTexture; 
19. renderer->DestroyRenderer = D3D\_DestroyRenderer;

（4）创建Device

创建Direct3D的Device通过IDirect3D9\_CreateDevice()函数来实现。这一方面的知识不再叙述，可以参考Direct3D创建Device的相关的文章。

**（5）设置渲染状态**

设置渲染状态在函数D3D\_InitRenderState()中完成。该部分的知识也不再详述，可以参考Direct3D相关的渲染教程。贴出D3D\_InitRenderState()的代码。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static****void** D3D\_InitRenderState(D3D\_RenderData \*data) 
2.  \{ 
3.   D3DMATRIX matrix; 
4.  
5.  
6.   IDirect3DDevice9 \*device = data->device; 
7.  
8.  
9.   IDirect3DDevice9\_SetVertexShader(device, NULL); 
10.  IDirect3DDevice9\_SetFVF(device, D3DFVF\_XYZ | D3DFVF\_DIFFUSE | D3DFVF\_TEX1); 
11.  IDirect3DDevice9\_SetRenderState(device, D3DRS\_ZENABLE, D3DZB\_FALSE); 
12.  IDirect3DDevice9\_SetRenderState(device, D3DRS\_CULLMODE, D3DCULL\_NONE); 
13.  IDirect3DDevice9\_SetRenderState(device, D3DRS\_LIGHTING, FALSE); 
14. 
15. 
16. /\* Enable color modulation by diffuse color \*/
17.  IDirect3DDevice9\_SetTextureStageState(device, 0, D3DTSS\_COLOROP, 
18.  D3DTOP\_MODULATE); 
19.  IDirect3DDevice9\_SetTextureStageState(device, 0, D3DTSS\_COLORARG1, 
20.  D3DTA\_TEXTURE); 
21.  IDirect3DDevice9\_SetTextureStageState(device, 0, D3DTSS\_COLORARG2, 
22.  D3DTA\_DIFFUSE); 
23. 
24. 
25. /\* Enable alpha modulation by diffuse alpha \*/
26.  IDirect3DDevice9\_SetTextureStageState(device, 0, D3DTSS\_ALPHAOP, 
27.  D3DTOP\_MODULATE); 
28.  IDirect3DDevice9\_SetTextureStageState(device, 0, D3DTSS\_ALPHAARG1, 
29.  D3DTA\_TEXTURE); 
30.  IDirect3DDevice9\_SetTextureStageState(device, 0, D3DTSS\_ALPHAARG2, 
31.  D3DTA\_DIFFUSE); 
32. 
33. 
34. /\* Enable separate alpha blend function, if possible \*/
35. **if** (data->enableSeparateAlphaBlend) \{ 
36.  IDirect3DDevice9\_SetRenderState(device, D3DRS\_SEPARATEALPHABLENDENABLE, TRUE); 
37.  \} 
38. 
39. 
40. /\* Disable second texture stage, since we're done \*/
41.  IDirect3DDevice9\_SetTextureStageState(device, 1, D3DTSS\_COLOROP, 
42.  D3DTOP\_DISABLE); 
43.  IDirect3DDevice9\_SetTextureStageState(device, 1, D3DTSS\_ALPHAOP, 
44.  D3DTOP\_DISABLE); 
45. 
46. 
47. /\* Set an identity world and view matrix \*/
48.  matrix.m\[0\]\[0\] = 1.0f; 
49.  matrix.m\[0\]\[1\] = 0.0f; 
50.  matrix.m\[0\]\[2\] = 0.0f; 
51.  matrix.m\[0\]\[3\] = 0.0f; 
52.  matrix.m\[1\]\[0\] = 0.0f; 
53.  matrix.m\[1\]\[1\] = 1.0f; 
54.  matrix.m\[1\]\[2\] = 0.0f; 
55.  matrix.m\[1\]\[3\] = 0.0f; 
56.  matrix.m\[2\]\[0\] = 0.0f; 
57.  matrix.m\[2\]\[1\] = 0.0f; 
58.  matrix.m\[2\]\[2\] = 1.0f; 
59.  matrix.m\[2\]\[3\] = 0.0f; 
60.  matrix.m\[3\]\[0\] = 0.0f; 
61.  matrix.m\[3\]\[1\] = 0.0f; 
62.  matrix.m\[3\]\[2\] = 0.0f; 
63.  matrix.m\[3\]\[3\] = 1.0f; 
64.  IDirect3DDevice9\_SetTransform(device, D3DTS\_WORLD, &matrix); 
65.  IDirect3DDevice9\_SetTransform(device, D3DTS\_VIEW, &matrix); 
66. 
67. 
68. /\* Reset our current scale mode \*/
69.  SDL\_memset(data->scaleMode, 0xFF, **sizeof**(data->scaleMode)); 
70. 
71. 
72. /\* Start the render with beginScene \*/
73.  data->beginScene = SDL\_TRUE; 
74. \}

（6）创建Shader

创建Shader通过函数IDirect3DDevice9\_CreatePixelShader()完成。

完成以上步骤之后，Direct3D的渲染器就创建完毕了。

### 2.OpenGL ###

OpenGL 的渲染器在创建函数是GL\_CreateRenderer()。该函数位于render\\opengl\\SDL\_render\_gl.c文件中。首先看一下它的代码。

PS：其中用到了OpenGL的很多API。如果对OpenGL的API还不熟悉的话，可以参考文章：

《[最简单的视音频播放示例6：OpenGL播放YUV420P（通过Texture，使用Shader）][6_OpenGL_YUV420P_Texture_Shader]》

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  SDL\_Renderer \* GL\_CreateRenderer(SDL\_Window \* window, Uint32 flags) 
2.  \{ 
3.   SDL\_Renderer \*renderer; 
4.   GL\_RenderData \*data; 
5.  **const****char** \*hint; 
6.   GLint value; 
7.   Uint32 window\_flags; 
8.  **int** profile\_mask, major, minor; 
9.  
10. 
11.  SDL\_GL\_GetAttribute(SDL\_GL\_CONTEXT\_PROFILE\_MASK, &profile\_mask); 
12.  SDL\_GL\_GetAttribute(SDL\_GL\_CONTEXT\_MAJOR\_VERSION, &major); 
13.  SDL\_GL\_GetAttribute(SDL\_GL\_CONTEXT\_MINOR\_VERSION, &minor); 
14. 
15.  window\_flags = SDL\_GetWindowFlags(window); 
16. **if** (!(window\_flags & SDL\_WINDOW\_OPENGL) || 
17.  profile\_mask == SDL\_GL\_CONTEXT\_PROFILE\_ES || major != RENDERER\_CONTEXT\_MAJOR || minor != RENDERER\_CONTEXT\_MINOR) \{ 
18. 
19.  SDL\_GL\_SetAttribute(SDL\_GL\_CONTEXT\_PROFILE\_MASK, 0); 
20.  SDL\_GL\_SetAttribute(SDL\_GL\_CONTEXT\_MAJOR\_VERSION, RENDERER\_CONTEXT\_MAJOR); 
21.  SDL\_GL\_SetAttribute(SDL\_GL\_CONTEXT\_MINOR\_VERSION, RENDERER\_CONTEXT\_MINOR); 
22. 
23. 
24. **if** (SDL\_RecreateWindow(window, window\_flags | SDL\_WINDOW\_OPENGL) < 0) \{ 
25. /\* Uh oh, better try to put it back... \*/
26.  SDL\_GL\_SetAttribute(SDL\_GL\_CONTEXT\_PROFILE\_MASK, profile\_mask); 
27.  SDL\_GL\_SetAttribute(SDL\_GL\_CONTEXT\_MAJOR\_VERSION, major); 
28.  SDL\_GL\_SetAttribute(SDL\_GL\_CONTEXT\_MINOR\_VERSION, minor); 
29.  SDL\_RecreateWindow(window, window\_flags); 
30. **return** NULL; 
31.  \} 
32.  \} 
33. 
34. 
35.  renderer = (SDL\_Renderer \*) SDL\_calloc(1, **sizeof**(\*renderer)); 
36. **if** (!renderer) \{ 
37.  SDL\_OutOfMemory(); 
38. **return** NULL; 
39.  \} 
40. 
41. 
42.  data = (GL\_RenderData \*) SDL\_calloc(1, **sizeof**(\*data)); 
43. **if** (!data) \{ 
44.  GL\_DestroyRenderer(renderer); 
45.  SDL\_OutOfMemory(); 
46. **return** NULL; 
47.  \} 
48. 
49. 
50.  renderer->WindowEvent = GL\_WindowEvent; 
51.  renderer->GetOutputSize = GL\_GetOutputSize; 
52.  renderer->CreateTexture = GL\_CreateTexture; 
53.  renderer->UpdateTexture = GL\_UpdateTexture; 
54.  renderer->UpdateTextureYUV = GL\_UpdateTextureYUV; 
55.  renderer->LockTexture = GL\_LockTexture; 
56.  renderer->UnlockTexture = GL\_UnlockTexture; 
57.  renderer->SetRenderTarget = GL\_SetRenderTarget; 
58.  renderer->UpdateViewport = GL\_UpdateViewport; 
59.  renderer->UpdateClipRect = GL\_UpdateClipRect; 
60.  renderer->RenderClear = GL\_RenderClear; 
61.  renderer->RenderDrawPoints = GL\_RenderDrawPoints; 
62.  renderer->RenderDrawLines = GL\_RenderDrawLines; 
63.  renderer->RenderFillRects = GL\_RenderFillRects; 
64.  renderer->RenderCopy = GL\_RenderCopy; 
65.  renderer->RenderCopyEx = GL\_RenderCopyEx; 
66.  renderer->RenderReadPixels = GL\_RenderReadPixels; 
67.  renderer->RenderPresent = GL\_RenderPresent; 
68.  renderer->DestroyTexture = GL\_DestroyTexture; 
69.  renderer->DestroyRenderer = GL\_DestroyRenderer; 
70.  renderer->GL\_BindTexture = GL\_BindTexture; 
71.  renderer->GL\_UnbindTexture = GL\_UnbindTexture; 
72.  renderer->info = GL\_RenderDriver.info; 
73.  renderer->info.flags = (SDL\_RENDERER\_ACCELERATED | SDL\_RENDERER\_TARGETTEXTURE); 
74.  renderer->driverdata = data; 
75.  renderer->window = window; 
76. 
77. 
78.  data->context = SDL\_GL\_CreateContext(window); 
79. **if** (!data->context) \{ 
80.  GL\_DestroyRenderer(renderer); 
81. **return** NULL; 
82.  \} 
83. **if** (SDL\_GL\_MakeCurrent(window, data->context) < 0) \{ 
84.  GL\_DestroyRenderer(renderer); 
85. **return** NULL; 
86.  \} 
87. 
88. 
89. **if** (GL\_LoadFunctions(data) < 0) \{ 
90.  GL\_DestroyRenderer(renderer); 
91. **return** NULL; 
92.  \} 
93. 
94. 
95. \#ifdef \_\_MACOSX\_\_
96. /\* Enable multi-threaded rendering \*/
97. /\* Disabled until Ryan finishes his VBO/PBO code...
98.  CGLEnable(CGLGetCurrentContext(), kCGLCEMPEngine);
99.  \*/
100. \#endif
101. 
102. 
103. **if** (flags & SDL\_RENDERER\_PRESENTVSYNC) \{ 
104.  SDL\_GL\_SetSwapInterval(1); 
105.  \} **else** \{ 
106.  SDL\_GL\_SetSwapInterval(0); 
107.  \} 
108. **if** (SDL\_GL\_GetSwapInterval() > 0) \{ 
109.  renderer->info.flags |= SDL\_RENDERER\_PRESENTVSYNC; 
110.  \} 
111. 
112. 
113. /\* Check for debug output support \*/
114. **if** (SDL\_GL\_GetAttribute(SDL\_GL\_CONTEXT\_FLAGS, &value) == 0 && 
115.  (value & SDL\_GL\_CONTEXT\_DEBUG\_FLAG)) \{ 
116.  data->debug\_enabled = SDL\_TRUE; 
117.  \} 
118. **if** (data->debug\_enabled && SDL\_GL\_ExtensionSupported("GL\_ARB\_debug\_output")) \{ 
119.  PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARBFunc = (PFNGLDEBUGMESSAGECALLBACKARBPROC) SDL\_GL\_GetProcAddress("glDebugMessageCallbackARB"); 
120. 
121. 
122.  data->GL\_ARB\_debug\_output\_supported = SDL\_TRUE; 
123.  data->glGetPointerv(GL\_DEBUG\_CALLBACK\_FUNCTION\_ARB, (GLvoid \*\*)&data->next\_error\_callback); 
124.  data->glGetPointerv(GL\_DEBUG\_CALLBACK\_USER\_PARAM\_ARB, &data->next\_error\_userparam); 
125.  glDebugMessageCallbackARBFunc(GL\_HandleDebugMessage, renderer); 
126. 
127. 
128. /\* Make sure our callback is called when errors actually happen \*/
129.  data->glEnable(GL\_DEBUG\_OUTPUT\_SYNCHRONOUS\_ARB); 
130.  \} 
131. 
132. 
133. **if** (SDL\_GL\_ExtensionSupported("GL\_ARB\_texture\_rectangle") 
134.  || SDL\_GL\_ExtensionSupported("GL\_EXT\_texture\_rectangle")) \{ 
135.  data->GL\_ARB\_texture\_rectangle\_supported = SDL\_TRUE; 
136.  data->glGetIntegerv(GL\_MAX\_RECTANGLE\_TEXTURE\_SIZE\_ARB, &value); 
137.  renderer->info.max\_texture\_width = value; 
138.  renderer->info.max\_texture\_height = value; 
139.  \} **else** \{ 
140.  data->glGetIntegerv(GL\_MAX\_TEXTURE\_SIZE, &value); 
141.  renderer->info.max\_texture\_width = value; 
142.  renderer->info.max\_texture\_height = value; 
143.  \} 
144. 
145. 
146. /\* Check for multitexture support \*/
147. **if** (SDL\_GL\_ExtensionSupported("GL\_ARB\_multitexture")) \{ 
148.  data->glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) SDL\_GL\_GetProcAddress("glActiveTextureARB"); 
149. **if** (data->glActiveTextureARB) \{ 
150.  data->GL\_ARB\_multitexture\_supported = SDL\_TRUE; 
151.  data->glGetIntegerv(GL\_MAX\_TEXTURE\_UNITS\_ARB, &data->num\_texture\_units); 
152.  \} 
153.  \} 
154. 
155. 
156. /\* Check for shader support \*/
157.  hint = SDL\_GetHint(SDL\_HINT\_RENDER\_OPENGL\_SHADERS); 
158. **if** (!hint || \*hint != '0') \{ 
159.  data->shaders = GL\_CreateShaderContext(); 
160.  \} 
161.  SDL\_LogInfo(SDL\_LOG\_CATEGORY\_RENDER, "OpenGL shaders: %s", 
162.  data->shaders ? "ENABLED" : "DISABLED"); 
163. 
164. 
165. /\* We support YV12 textures using 3 textures and a shader \*/
166. **if** (data->shaders && data->num\_texture\_units >= 3) \{ 
167.  renderer->info.texture\_formats\[renderer->info.num\_texture\_formats++\] = SDL\_PIXELFORMAT\_YV12; 
168.  renderer->info.texture\_formats\[renderer->info.num\_texture\_formats++\] = SDL\_PIXELFORMAT\_IYUV; 
169.  \} 
170. 
171. 
172. \#ifdef \_\_MACOSX\_\_
173.  renderer->info.texture\_formats\[renderer->info.num\_texture\_formats++\] = SDL\_PIXELFORMAT\_UYVY; 
174. \#endif
175. 
176. 
177. **if** (SDL\_GL\_ExtensionSupported("GL\_EXT\_framebuffer\_object")) \{ 
178.  data->GL\_EXT\_framebuffer\_object\_supported = SDL\_TRUE; 
179.  data->glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC) 
180.  SDL\_GL\_GetProcAddress("glGenFramebuffersEXT"); 
181.  data->glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC) 
182.  SDL\_GL\_GetProcAddress("glDeleteFramebuffersEXT"); 
183.  data->glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) 
184.  SDL\_GL\_GetProcAddress("glFramebufferTexture2DEXT"); 
185.  data->glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC) 
186.  SDL\_GL\_GetProcAddress("glBindFramebufferEXT"); 
187.  data->glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) 
188.  SDL\_GL\_GetProcAddress("glCheckFramebufferStatusEXT"); 
189.  renderer->info.flags |= SDL\_RENDERER\_TARGETTEXTURE; 
190.  \} 
191.  data->framebuffers = NULL; 
192. 
193. 
194. /\* Set up parameters for rendering \*/
195.  GL\_ResetState(renderer); 
196. 
197. 
198. **return** renderer; 
199. \}

GL\_CreateRenderer()这个函数的代码很长。在这里提取它最重点的几个进行简单的分析。  
  
（1）为SDL\_Renderer分配内存

这一步比较简单。直接使用SDL\_calloc()分配内存就可以了。

**（2）渲染器接口函数赋值**

SDL\_Render结构体中有一系列的函数指针，包含了有关渲染器的各种功能。这一点在Direct3D的时候已经提过，不再重复。代码如下。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  renderer->WindowEvent = GL\_WindowEvent; 
2.  renderer->GetOutputSize = GL\_GetOutputSize; 
3.  renderer->CreateTexture = GL\_CreateTexture; 
4.  renderer->UpdateTexture = GL\_UpdateTexture; 
5.  renderer->UpdateTextureYUV = GL\_UpdateTextureYUV; 
6.  renderer->LockTexture = GL\_LockTexture; 
7.  renderer->UnlockTexture = GL\_UnlockTexture; 
8.  renderer->SetRenderTarget = GL\_SetRenderTarget; 
9.  renderer->UpdateViewport = GL\_UpdateViewport; 
10. renderer->UpdateClipRect = GL\_UpdateClipRect; 
11. renderer->RenderClear = GL\_RenderClear; 
12. renderer->RenderDrawPoints = GL\_RenderDrawPoints; 
13. renderer->RenderDrawLines = GL\_RenderDrawLines; 
14. renderer->RenderFillRects = GL\_RenderFillRects; 
15. renderer->RenderCopy = GL\_RenderCopy; 
16. renderer->RenderCopyEx = GL\_RenderCopyEx; 
17. renderer->RenderReadPixels = GL\_RenderReadPixels; 
18. renderer->RenderPresent = GL\_RenderPresent; 
19. renderer->DestroyTexture = GL\_DestroyTexture; 
20. renderer->DestroyRenderer = GL\_DestroyRenderer; 
21. renderer->GL\_BindTexture = GL\_BindTexture; 
22. renderer->GL\_UnbindTexture = GL\_UnbindTexture;

（3）初始化OpenGL  
初始化OpenGL各种变量，包括SDL\_GL\_CreateContext()，SDL\_GL\_MakeCurrent()，GL\_LoadFunctions()等函数。这一部分还没有详细分析。

**（4）初始化Shader**

对Shader的初始化在函数GL\_CreateShaderContext()中完成。GL\_CreateShaderContext()的代码如下（位于render\\opengl\\SDL\_shaders\_gl.c）。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  GL\_ShaderContext \* GL\_CreateShaderContext() 
2.  \{ 
3.   GL\_ShaderContext \*ctx; 
4.   SDL\_bool shaders\_supported; 
5.  **int** i; 
6.  
7.  
8.   ctx = (GL\_ShaderContext \*)SDL\_calloc(1, **sizeof**(\*ctx)); 
9.  **if** (!ctx) \{ 
10. **return** NULL; 
11.  \} 
12. 
13. 
14. **if** (SDL\_GL\_ExtensionSupported("GL\_ARB\_texture\_rectangle") 
15.  || SDL\_GL\_ExtensionSupported("GL\_EXT\_texture\_rectangle")) \{ 
16.  ctx->GL\_ARB\_texture\_rectangle\_supported = SDL\_TRUE; 
17.  \} 
18. 
19. 
20. /\* Check for shader support \*/
21.  shaders\_supported = SDL\_FALSE; 
22. **if** (SDL\_GL\_ExtensionSupported("GL\_ARB\_shader\_objects") && 
23.  SDL\_GL\_ExtensionSupported("GL\_ARB\_shading\_language\_100") && 
24.  SDL\_GL\_ExtensionSupported("GL\_ARB\_vertex\_shader") && 
25.  SDL\_GL\_ExtensionSupported("GL\_ARB\_fragment\_shader")) \{ 
26.  ctx->glGetError = (GLenum (\*)(**void**)) SDL\_GL\_GetProcAddress("glGetError"); 
27.  ctx->glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC) SDL\_GL\_GetProcAddress("glAttachObjectARB"); 
28.  ctx->glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC) SDL\_GL\_GetProcAddress("glCompileShaderARB"); 
29.  ctx->glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC) SDL\_GL\_GetProcAddress("glCreateProgramObjectARB"); 
30.  ctx->glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC) SDL\_GL\_GetProcAddress("glCreateShaderObjectARB"); 
31.  ctx->glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC) SDL\_GL\_GetProcAddress("glDeleteObjectARB"); 
32.  ctx->glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC) SDL\_GL\_GetProcAddress("glGetInfoLogARB"); 
33.  ctx->glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC) SDL\_GL\_GetProcAddress("glGetObjectParameterivARB"); 
34.  ctx->glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC) SDL\_GL\_GetProcAddress("glGetUniformLocationARB"); 
35.  ctx->glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC) SDL\_GL\_GetProcAddress("glLinkProgramARB"); 
36.  ctx->glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC) SDL\_GL\_GetProcAddress("glShaderSourceARB"); 
37.  ctx->glUniform1iARB = (PFNGLUNIFORM1IARBPROC) SDL\_GL\_GetProcAddress("glUniform1iARB"); 
38.  ctx->glUniform1fARB = (PFNGLUNIFORM1FARBPROC) SDL\_GL\_GetProcAddress("glUniform1fARB"); 
39.  ctx->glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC) SDL\_GL\_GetProcAddress("glUseProgramObjectARB"); 
40. **if** (ctx->glGetError && 
41.  ctx->glAttachObjectARB && 
42.  ctx->glCompileShaderARB && 
43.  ctx->glCreateProgramObjectARB && 
44.  ctx->glCreateShaderObjectARB && 
45.  ctx->glDeleteObjectARB && 
46.  ctx->glGetInfoLogARB && 
47.  ctx->glGetObjectParameterivARB && 
48.  ctx->glGetUniformLocationARB && 
49.  ctx->glLinkProgramARB && 
50.  ctx->glShaderSourceARB && 
51.  ctx->glUniform1iARB && 
52.  ctx->glUniform1fARB && 
53.  ctx->glUseProgramObjectARB) \{ 
54.  shaders\_supported = SDL\_TRUE; 
55.  \} 
56.  \} 
57. 
58. 
59. **if** (!shaders\_supported) \{ 
60.  SDL\_free(ctx); 
61. **return** NULL; 
62.  \} 
63. 
64. 
65. /\* Compile all the shaders \*/
66. **for** (i = 0; i < NUM\_SHADERS; ++i) \{ 
67. **if** (!CompileShaderProgram(ctx, i, &ctx->shaders\[i\])) \{ 
68.  GL\_DestroyShaderContext(ctx); 
69. **return** NULL; 
70.  \} 
71.  \} 
72. 
73. 
74. /\* We're done! \*/
75. **return** ctx; 
76. \}

上述代码主要完成了以下两步：  
第一步，初始化GL\_ShaderContext。 GL\_ShaderContext中包含了OpenGL的Shader方面用到的各种接口函数。GL\_ShaderContext定义如下。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **struct** GL\_ShaderContext 
2.  \{ 
3.   GLenum (\*glGetError)(**void**); 
4.  
5.  
6.   PFNGLATTACHOBJECTARBPROC glAttachObjectARB; 
7.   PFNGLCOMPILESHADERARBPROC glCompileShaderARB; 
8.   PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB; 
9.   PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB; 
10.  PFNGLDELETEOBJECTARBPROC glDeleteObjectARB; 
11.  PFNGLGETINFOLOGARBPROC glGetInfoLogARB; 
12.  PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB; 
13.  PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB; 
14.  PFNGLLINKPROGRAMARBPROC glLinkProgramARB; 
15.  PFNGLSHADERSOURCEARBPROC glShaderSourceARB; 
16.  PFNGLUNIFORM1IARBPROC glUniform1iARB; 
17.  PFNGLUNIFORM1FARBPROC glUniform1fARB; 
18.  PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB; 
19. 
20. 
21.  SDL\_bool GL\_ARB\_texture\_rectangle\_supported; 
22. 
23. 
24.  GL\_ShaderData shaders\[NUM\_SHADERS\]; 
25. \};

看这个结构体的定义会给人一种很混乱的感觉。不用去理会那些大串的大写字母，只要知道这个结构体是函数的接口的“合集”就可以了。从函数的名称中我们可以看出有编译Shader的glCreateShaderObject()，glShaderSource()，glCompileShader()等；以及编译Program的glCreateProgramObject()，glAttachObject ()，glLinkProgram()，glUseProgramObject ()等等。  
GL\_CreateShaderContext()函数中创建了一个GL\_ShaderContext并对其中的接口函数进行了赋值。  
  
第二步，编译Shader程序。 该功能在CompileShaderProgram()函数中完成。CompileShaderProgram()的函数代码如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static** SDL\_bool CompileShaderProgram(GL\_ShaderContext \*ctx, **int** index, GL\_ShaderData \*data) 
2.  \{ 
3.  **const****int** num\_tmus\_bound = 4; 
4.  **const****char** \*vert\_defines = ""; 
5.  **const****char** \*frag\_defines = ""; 
6.  **int** i; 
7.   GLint location; 
8.  
9.  
10. **if** (index == SHADER\_NONE) \{ 
11. **return** SDL\_TRUE; 
12.  \} 
13. 
14. 
15.  ctx->glGetError(); 
16. 
17. 
18. /\* Make sure we use the correct sampler type for our texture type \*/
19. **if** (ctx->GL\_ARB\_texture\_rectangle\_supported) \{ 
20.  frag\_defines = 
21. "\#define sampler2D sampler2DRect\\n"
22. "\#define texture2D texture2DRect\\n"; 
23.  \} 
24. 
25. 
26. /\* Create one program object to rule them all \*/
27.  data->program = ctx->glCreateProgramObjectARB(); 
28. 
29. 
30. /\* Create the vertex shader \*/
31.  data->vert\_shader = ctx->glCreateShaderObjectARB(GL\_VERTEX\_SHADER\_ARB); 
32. **if** (!CompileShader(ctx, data->vert\_shader, vert\_defines, shader\_source\[index\]\[0\])) \{ 
33. **return** SDL\_FALSE; 
34.  \} 
35. 
36. 
37. /\* Create the fragment shader \*/
38.  data->frag\_shader = ctx->glCreateShaderObjectARB(GL\_FRAGMENT\_SHADER\_ARB); 
39. **if** (!CompileShader(ctx, data->frag\_shader, frag\_defines, shader\_source\[index\]\[1\])) \{ 
40. **return** SDL\_FALSE; 
41.  \} 
42. 
43. 
44. /\* ... and in the darkness bind them \*/
45.  ctx->glAttachObjectARB(data->program, data->vert\_shader); 
46.  ctx->glAttachObjectARB(data->program, data->frag\_shader); 
47.  ctx->glLinkProgramARB(data->program); 
48. 
49. 
50. /\* Set up some uniform variables \*/
51.  ctx->glUseProgramObjectARB(data->program); 
52. **for** (i = 0; i < num\_tmus\_bound; ++i) \{ 
53. **char** tex\_name\[10\]; 
54.  SDL\_snprintf(tex\_name, SDL\_arraysize(tex\_name), "tex%d", i); 
55.  location = ctx->glGetUniformLocationARB(data->program, tex\_name); 
56. **if** (location >= 0) \{ 
57.  ctx->glUniform1iARB(location, i); 
58.  \} 
59.  \} 
60.  ctx->glUseProgramObjectARB(0); 
61. 
62. 
63. **return** (ctx->glGetError() == GL\_NO\_ERROR); 
64. \}

从代码中可以看出，这个函数调用了GL\_ShaderContext中用于初始化Shader以及Program的各个函数。有关初始化的流程不再细说，可以参考相关的文章。

在该函数中，调用了CompileShader()专门用于初始化Shader。该函数被调用了两次，分别用于初始化vertex shader和fragment shader。

CompileShader()的代码如下。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static** SDL\_bool CompileShader(GL\_ShaderContext \*ctx, GLhandleARB shader, **const****char** \*defines, **const****char** \*source) 
2.  \{ 
3.   GLint status; 
4.  **const****char** \*sources\[2\]; 
5.  
6.  
7.   sources\[0\] = defines; 
8.   sources\[1\] = source; 
9.  
10. 
11.  ctx->glShaderSourceARB(shader, SDL\_arraysize(sources), sources, NULL); 
12.  ctx->glCompileShaderARB(shader); 
13.  ctx->glGetObjectParameterivARB(shader, GL\_OBJECT\_COMPILE\_STATUS\_ARB, &status); 
14. **if** (status == 0) \{ 
15.  GLint length; 
16. **char** \*info; 
17. 
18. 
19.  ctx->glGetObjectParameterivARB(shader, GL\_OBJECT\_INFO\_LOG\_LENGTH\_ARB, &length); 
20.  info = SDL\_stack\_alloc(**char**, length+1); 
21.  ctx->glGetInfoLogARB(shader, length, NULL, info); 
22.  SDL\_LogError(SDL\_LOG\_CATEGORY\_RENDER, 
23. "Failed to compile shader:\\n%s%s\\n%s", defines, source, info); 
24. \#ifdef DEBUG\_SHADERS
25.  fprintf(stderr, 
26. "Failed to compile shader:\\n%s%s\\n%s", defines, source, info); 
27. \#endif
28.  SDL\_stack\_free(info); 
29. 
30. 
31. **return** SDL\_FALSE; 
32.  \} **else** \{ 
33. **return** SDL\_TRUE; 
34.  \} 
35. \}

从代码中可以看出，该函数调用glShaderSource()，glCompileShader()，glGetObjectParameteriv()这几个函数初始化一个Shader。  
Shader的代码位于一个名称为shader\_source的char型二维数组里，源代码如下所示。数组中每个元素代表一个Shader的代码，每个Shader的代码包含两个部分：vertex shader代码（对应元素\[0\]）以及fragment shader代码（对应元素\[1\]）。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\*
2.   \* NOTE: Always use sampler2D, etc here. We'll \#define them to the
3.   \* texture\_rectangle versions if we choose to use that extension.
4.   \*/
5.  **static****const****char** \*shader\_source\[NUM\_SHADERS\]\[2\] = 
6.  \{ 
7.  /\* SHADER\_NONE \*/
8.   \{ NULL, NULL \}, 
9.  
10. 
11. /\* SHADER\_SOLID \*/
12.  \{ 
13. /\* vertex shader \*/
14. "varying vec4 v\_color;\\n"
15. "\\n"
16. "void main()\\n"
17. "\{\\n"
18. " gl\_Position = gl\_ModelViewProjectionMatrix \* gl\_Vertex;\\n"
19. " v\_color = gl\_Color;\\n"
20. "\}", 
21. /\* fragment shader \*/
22. "varying vec4 v\_color;\\n"
23. "\\n"
24. "void main()\\n"
25. "\{\\n"
26. " gl\_FragColor = v\_color;\\n"
27. "\}"
28.  \}, 
29. 
30. 
31. /\* SHADER\_RGB \*/
32.  \{ 
33. /\* vertex shader \*/
34. "varying vec4 v\_color;\\n"
35. "varying vec2 v\_texCoord;\\n"
36. "\\n"
37. "void main()\\n"
38. "\{\\n"
39. " gl\_Position = gl\_ModelViewProjectionMatrix \* gl\_Vertex;\\n"
40. " v\_color = gl\_Color;\\n"
41. " v\_texCoord = vec2(gl\_MultiTexCoord0);\\n"
42. "\}", 
43. /\* fragment shader \*/
44. "varying vec4 v\_color;\\n"
45. "varying vec2 v\_texCoord;\\n"
46. "uniform sampler2D tex0;\\n"
47. "\\n"
48. "void main()\\n"
49. "\{\\n"
50. " gl\_FragColor = texture2D(tex0, v\_texCoord) \* v\_color;\\n"
51. "\}"
52.  \}, 
53. 
54. 
55. /\* SHADER\_YV12 \*/
56.  \{ 
57. /\* vertex shader \*/
58. "varying vec4 v\_color;\\n"
59. "varying vec2 v\_texCoord;\\n"
60. "\\n"
61. "void main()\\n"
62. "\{\\n"
63. " gl\_Position = gl\_ModelViewProjectionMatrix \* gl\_Vertex;\\n"
64. " v\_color = gl\_Color;\\n"
65. " v\_texCoord = vec2(gl\_MultiTexCoord0);\\n"
66. "\}", 
67. /\* fragment shader \*/
68. "varying vec4 v\_color;\\n"
69. "varying vec2 v\_texCoord;\\n"
70. "uniform sampler2D tex0; // Y \\n"
71. "uniform sampler2D tex1; // U \\n"
72. "uniform sampler2D tex2; // V \\n"
73. "\\n"
74. "// YUV offset \\n"
75. "const vec3 offset = vec3(-0.0625, -0.5, -0.5);\\n"
76. "\\n"
77. "// RGB coefficients \\n"
78. "const vec3 Rcoeff = vec3(1.164, 0.000, 1.596);\\n"
79. "const vec3 Gcoeff = vec3(1.164, -0.391, -0.813);\\n"
80. "const vec3 Bcoeff = vec3(1.164, 2.018, 0.000);\\n"
81. "\\n"
82. "void main()\\n"
83. "\{\\n"
84. " vec2 tcoord;\\n"
85. " vec3 yuv, rgb;\\n"
86. "\\n"
87. " // Get the Y value \\n"
88. " tcoord = v\_texCoord;\\n"
89. " yuv.x = texture2D(tex0, tcoord).r;\\n"
90. "\\n"
91. " // Get the U and V values \\n"
92. " tcoord \*= 0.5;\\n"
93. " yuv.y = texture2D(tex1, tcoord).r;\\n"
94. " yuv.z = texture2D(tex2, tcoord).r;\\n"
95. "\\n"
96. " // Do the color transform \\n"
97. " yuv += offset;\\n"
98. " rgb.r = dot(yuv, Rcoeff);\\n"
99. " rgb.g = dot(yuv, Gcoeff);\\n"
100. " rgb.b = dot(yuv, Bcoeff);\\n"
101. "\\n"
102. " // That was easy. :) \\n"
103. " gl\_FragColor = vec4(rgb, 1.0) \* v\_color;\\n"
104. "\}"
105.  \}, 
106. \};

有关OpenGL的渲染器的初始化代码暂时分析到这里。

### 3.Software ###

Software的渲染器在创建函数是SW\_CreateRenderer()。该函数位于render\\software\\SDL\_render\_sw.c文件中。首先看一下它的代码。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  SDL\_Renderer \* SW\_CreateRenderer(SDL\_Window \* window, Uint32 flags) 
2.  \{ 
3.   SDL\_Surface \*surface; 
4.  
5.  
6.   surface = SDL\_GetWindowSurface(window); 
7.  **if** (!surface) \{ 
8.  **return** NULL; 
9.   \} 
10. **return** SW\_CreateRendererForSurface(surface); 
11. \}

从代码中可以看出，SW\_CreateRenderer()调用了2个函数：SDL\_GetWindowSurface()和SW\_CreateRendererForSurface()。SDL\_GetWindowSurface()用于创建一个Surface；SW\_CreateRendererForSurface()基于Surface创建一个Renderer。  
下面分别看一下这2个函数的代码。  
SDL\_GetWindowSurface()的代码如下所示（位于video\\SDL\_video.c）。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  SDL\_Surface \* SDL\_GetWindowSurface(SDL\_Window \* window) 
2.  \{ 
3.   CHECK\_WINDOW\_MAGIC(window, NULL); 
4.  
5.  
6.  **if** (!window->surface\_valid) \{ 
7.  **if** (window->surface) \{ 
8.   window->surface->flags &= ~SDL\_DONTFREE; 
9.   SDL\_FreeSurface(window->surface); 
10.  \} 
11.  window->surface = SDL\_CreateWindowFramebuffer(window); 
12. **if** (window->surface) \{ 
13.  window->surface\_valid = SDL\_TRUE; 
14.  window->surface->flags |= SDL\_DONTFREE; 
15.  \} 
16.  \} 
17. **return** window->surface; 
18. \}

其中调用了一个函数SDL\_CreateWindowFramebuffer()，看一下该函数的代码。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static** SDL\_Surface \* SDL\_CreateWindowFramebuffer(SDL\_Window \* window) 
2.  \{ 
3.   Uint32 format; 
4.  **void** \*pixels; 
5.  **int** pitch; 
6.  **int** bpp; 
7.   Uint32 Rmask, Gmask, Bmask, Amask; 
8.  
9.  
10. **if** (!\_this->CreateWindowFramebuffer || !\_this->UpdateWindowFramebuffer) \{ 
11. **return** NULL; 
12.  \} 
13. 
14. 
15. **if** (\_this->CreateWindowFramebuffer(\_this, window, &format, &pixels, &pitch) < 0) \{ 
16. **return** NULL; 
17.  \} 
18. 
19. 
20. **if** (!SDL\_PixelFormatEnumToMasks(format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) \{ 
21. **return** NULL; 
22.  \} 
23. 
24. 
25. **return** SDL\_CreateRGBSurfaceFrom(pixels, window->w, window->h, bpp, pitch, Rmask, Gmask, Bmask, Amask); 
26. \}

该函数中调用了SDL\_VideoDevice中的一个函数CreateWindowFramebuffer()。我们以“Windows视频驱动”为例，看看CreateWindowFramebuffer()中的代码。在“Windows视频驱动”下，CreateWindowFramebuffer()对应的函数是WIN\_CreateWindowFramebuffer()。下面看一下该函数的代码。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **int** WIN\_CreateWindowFramebuffer(\_THIS, SDL\_Window \* window, Uint32 \* format, **void** \*\* pixels, **int** \*pitch) 
2.  \{ 
3.   SDL\_WindowData \*data = (SDL\_WindowData \*) window->driverdata; 
4.  **size\_t** size; 
5.   LPBITMAPINFO info; 
6.  **HBITMAP** hbm; 
7.  
8.  
9.  /\* Free the old framebuffer surface \*/
10. **if** (data->mdc) \{ 
11.  DeleteDC(data->mdc); 
12.  \} 
13. **if** (data->hbm) \{ 
14.  DeleteObject(data->hbm); 
15.  \} 
16. 
17. 
18. /\* Find out the format of the screen \*/
19.  size = **sizeof**(BITMAPINFOHEADER) + 256 \* **sizeof** (RGBQUAD); 
20.  info = (LPBITMAPINFO)SDL\_stack\_alloc(Uint8, size); 
21. 
22. 
23.  SDL\_memset(info, 0, size); 
24.  info->bmiHeader.biSize = **sizeof**(BITMAPINFOHEADER); 
25. 
26. 
27. /\* The second call to GetDIBits() fills in the bitfields \*/
28.  hbm = CreateCompatibleBitmap(data->hdc, 1, 1); 
29.  GetDIBits(data->hdc, hbm, 0, 0, NULL, info, DIB\_RGB\_COLORS); 
30.  GetDIBits(data->hdc, hbm, 0, 0, NULL, info, DIB\_RGB\_COLORS); 
31.  DeleteObject(hbm); 
32. 
33. 
34.  \*format = SDL\_PIXELFORMAT\_UNKNOWN; 
35. **if** (info->bmiHeader.biCompression == BI\_BITFIELDS) \{ 
36. **int** bpp; 
37.  Uint32 \*masks; 
38. 
39. 
40.  bpp = info->bmiHeader.biPlanes \* info->bmiHeader.biBitCount; 
41.  masks = (Uint32\*)((Uint8\*)info + info->bmiHeader.biSize); 
42.  \*format = SDL\_MasksToPixelFormatEnum(bpp, masks\[0\], masks\[1\], masks\[2\], 0); 
43.  \} 
44. **if** (\*format == SDL\_PIXELFORMAT\_UNKNOWN) 
45.  \{ 
46. /\* We'll use RGB format for now \*/
47.  \*format = SDL\_PIXELFORMAT\_RGB888; 
48. 
49. 
50. /\* Create a new one \*/
51.  SDL\_memset(info, 0, size); 
52.  info->bmiHeader.biSize = **sizeof**(BITMAPINFOHEADER); 
53.  info->bmiHeader.biPlanes = 1; 
54.  info->bmiHeader.biBitCount = 32; 
55.  info->bmiHeader.biCompression = BI\_RGB; 
56.  \} 
57. 
58. 
59. /\* Fill in the size information \*/
60.  \*pitch = (((window->w \* SDL\_BYTESPERPIXEL(\*format)) + 3) & ~3); 
61.  info->bmiHeader.biWidth = window->w; 
62.  info->bmiHeader.biHeight = -window->h; /\* negative for topdown bitmap \*/
63.  info->bmiHeader.biSizeImage = window->h \* (\*pitch); 
64. 
65. 
66.  data->mdc = CreateCompatibleDC(data->hdc); 
67.  data->hbm = CreateDIBSection(data->hdc, info, DIB\_RGB\_COLORS, pixels, NULL, 0); 
68.  SDL\_stack\_free(info); 
69. 
70. 
71. **if** (!data->hbm) \{ 
72. **return** WIN\_SetError("Unable to create DIB"); 
73.  \} 
74.  SelectObject(data->mdc, data->hbm); 
75. 
76. 
77. **return** 0; 
78. \}

从代码中可以看出，该函数调用了Win32的API函数CreateCompatibleBitmap()，CreateCompatibleDC()等一系列方法创建了“Surface”。  
  
SDL\_GetWindowSurface()函数到此分析完毕，现在回过头来再看SW\_CreateRenderer ()的另一个函数SW\_CreateRendererForSurface()。该函数的代码如下。

**\[cpp\]** [view plain][] [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  SDL\_Renderer \* SW\_CreateRendererForSurface(SDL\_Surface \* surface) 
2.  \{ 
3.   SDL\_Renderer \*renderer; 
4.   SW\_RenderData \*data; 
5.  
6.  
7.  **if** (!surface) \{ 
8.   SDL\_SetError("Can't create renderer for NULL surface"); 
9.  **return** NULL; 
10.  \} 
11. 
12. 
13.  renderer = (SDL\_Renderer \*) SDL\_calloc(1, **sizeof**(\*renderer)); 
14. **if** (!renderer) \{ 
15.  SDL\_OutOfMemory(); 
16. **return** NULL; 
17.  \} 
18. 
19. 
20.  data = (SW\_RenderData \*) SDL\_calloc(1, **sizeof**(\*data)); 
21. **if** (!data) \{ 
22.  SW\_DestroyRenderer(renderer); 
23.  SDL\_OutOfMemory(); 
24. **return** NULL; 
25.  \} 
26.  data->surface = surface; 
27. 
28. 
29.  renderer->WindowEvent = SW\_WindowEvent; 
30.  renderer->GetOutputSize = SW\_GetOutputSize; 
31.  renderer->CreateTexture = SW\_CreateTexture; 
32.  renderer->SetTextureColorMod = SW\_SetTextureColorMod; 
33.  renderer->SetTextureAlphaMod = SW\_SetTextureAlphaMod; 
34.  renderer->SetTextureBlendMode = SW\_SetTextureBlendMode; 
35.  renderer->UpdateTexture = SW\_UpdateTexture; 
36.  renderer->LockTexture = SW\_LockTexture; 
37.  renderer->UnlockTexture = SW\_UnlockTexture; 
38.  renderer->SetRenderTarget = SW\_SetRenderTarget; 
39.  renderer->UpdateViewport = SW\_UpdateViewport; 
40.  renderer->UpdateClipRect = SW\_UpdateClipRect; 
41.  renderer->RenderClear = SW\_RenderClear; 
42.  renderer->RenderDrawPoints = SW\_RenderDrawPoints; 
43.  renderer->RenderDrawLines = SW\_RenderDrawLines; 
44.  renderer->RenderFillRects = SW\_RenderFillRects; 
45.  renderer->RenderCopy = SW\_RenderCopy; 
46.  renderer->RenderCopyEx = SW\_RenderCopyEx; 
47.  renderer->RenderReadPixels = SW\_RenderReadPixels; 
48.  renderer->RenderPresent = SW\_RenderPresent; 
49.  renderer->DestroyTexture = SW\_DestroyTexture; 
50.  renderer->DestroyRenderer = SW\_DestroyRenderer; 
51.  renderer->info = SW\_RenderDriver.info; 
52.  renderer->driverdata = data; 
53. 
54. 
55.  SW\_ActivateRenderer(renderer); 
56. 
57. 
58. **return** renderer; 
59. \}

与前面的函数一样，该函数完成了SDL\_Renderer结构体中函数指针的赋值。

[SDL2_1_SDL_Init]: http://blog.csdn.net/leixiaohua1020/article/details/40680907
[SDL2_2_SDL_Window]: http://blog.csdn.net/leixiaohua1020/article/details/40701203
[SDL2_3_SDL_Renderer]: http://blog.csdn.net/leixiaohua1020/article/details/40723085
[SDL2_4_SDL_Texture]: http://blog.csdn.net/leixiaohua1020/article/details/40743061
[SDL2_5_SDL_UpdateTexture]: http://blog.csdn.net/leixiaohua1020/article/details/40876089
[SDL2_6_SDL_RenderCopy]: http://blog.csdn.net/leixiaohua1020/article/details/40895593
[SDL2_7_SDL_RenderPresent]: http://blog.csdn.net/leixiaohua1020/article/details/40895797
[SDL2_8]: http://blog.csdn.net/leixiaohua1020/article/details/41207787
[20141103004453630]: /images/20220731/dfda46787f0a4e6a81310e10baaf604f.png
[view plain]: http://blog.csdn.net/leixiaohua1020/article/details/40723085#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/506937
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/506937/fork
[SouthEast]: /images/20220731/c967b17afe7c4176a4369019e57bd90d.png
[SouthEast 1]: http://my.csdn.net/leixiaohua1020/album/detail/1793385
[3_Direct3D_YUV_RGB_Surface]: http://blog.csdn.net/leixiaohua1020/article/details/40279297
[4_Direct3D_RGB_Texture]: http://blog.csdn.net/leixiaohua1020/article/details/40301179
[6_OpenGL_YUV420P_Texture_Shader]: http://blog.csdn.net/leixiaohua1020/article/details/40379845