【Opengl游戏汉化 #5】 尼比鲁：秘密年代 （NiBiRu）字幕显示函数修改2

shane007

以下是一个用来做参照的opengl显示字符串的代码，使用了freetype库。
. H: N# s* c. _本代码经过分析以及改写之后，将取代游戏原有的显示函数。

代码详细说明如下

/ f' U0 v6 o4 d3 U# n8 e6 I

1. 在上述 renderString 函数中，我们有以下关键部分的解释：
   * \& J3 Z5 j2 `! k' z
2. 
   
3. glBindTexture(GL_TEXTURE_2D, fontTexture);：将字体纹理绑定到当前的OpenGL上下文。这是因为我们要使用 fontTexture 中存储的字形位图数据进行渲染。
   
4. 
   " }* G9 h( z( e$ r
5. glEnable(GL_BLEND); 和 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);：启用混合模式以处理字符的透明度。混合模式通过 glBlendFunc 设置，这里使用了常见的源和目标因子来实现源颜色与目标颜色的混合，从而实现透明效果。
   3 m  F- d( `, _7 G8 D; V- \
6. 
   
7. glBegin(GL_QUADS); 和 glEnd();：在这两个函数之间的代码用于指定字符的四边形顶点，以便在OpenGL上下文中绘制字符。
   
8. 
     G, D. `" \& `7 o- `
9. for (const char* p = text; *p; p++) { ... }：这个循环遍历传递给函数的字符串 text 中的每个字符，然后为每个字符执行以下操作：
   
10. 
    
11. FT_Load_Char(face, *p, FT_LOAD_RENDER);：使用FreeType加载字符的字形数据，包括轮廓和位图信息。加载后，可以从 face->glyph 中访问该字符的字形数据。
    0 y1 o: o1 W8 ?2 t$ J
12. 
    
13. 计算字符在屏幕上的位置和大小，包括 xpos（x坐标）、ypos（y坐标）、w（宽度）和 h（高度）。
    
14. 
    
15. 使用 glTexCoord2f 和 glVertex2f 来指定字符的纹理坐标和顶点坐标，以创建一个四边形。这四边形将字形的位图数据绘制到屏幕上的指定位置。
    
16. 
    * U3 N6 {6 N" @5 ?% s9 I# Y+ q  }. ^
17. x += (face->glyph->advance.x >> 6);：更新 x 坐标，以便将下一个字符紧密排列在当前字符的后面。face->glyph->advance.x 包含字符的横向位移信息，>> 6 是用来将其转换为像素单位的操作。
    2 O. T* U3 z( @' U& ^" Y/ r
18. 
    
19. 最后，glDisable(GL_BLEND); 用于禁用混合模式，以免影响后续的绘制操作。
    
20. 
    8 D/ c% B1 Q; [. V: T* Z6 F9 [0 A
21. 总之，renderString 函数的作用是将传递给它的字符串中的字符一个接一个地绘制到OpenGL上下文中，使用FreeType加载的字形数据和字体纹理来实现文本渲染效果。渲染过程涉及到字符的位置计算、纹理坐标的设置以及混合模式的启用和禁用，以确保字符在屏幕上正确显示。
    3 C$ G& V. t4 p

复制代码

1. 字形数据处理的关键函数之一。以下是 FT_Load_Char 函数的详细解释：
   
2. 
   / r5 q- p( n0 w6 a% l
3. 参数：
   , x* g8 j  K* }) Z" y
4. 
   ( A# T) d3 b/ Q2 g# e
5. face：一个指向已经打开的字体文件的 FT_Face 结构体的指针。FT_Face 包含了字体的各种信息，包括字形数据。
   / z$ G' |. ?# {
6. char_code：要加载的字符的Unicode编码值。您需要传递字符的Unicode编码作为此参数，以指定要加载的字符。
   
7. load_flags：一个用于控制字形加载选项的标志位。您可以使用这些标志位来控制加载的方式，例如是否要加载字形的轮廓数据、是否要加载字形的位图数据等。
     L  @! ]2 J5 l3 b
8. 功能：
   
9. 
   % u9 V4 e' h5 \2 t
10. FT_Load_Char 函数的主要功能是加载指定字符的字形数据。
    
11. 如果成功，它将在 FT_Face 结构体中的 glyph 字段中填充有关字符的字形信息。
    ) g( R' z, ~8 O( }
12. 这包括了字符的轮廓数据、位图数据、宽度、高度、位图偏移等等，具体取决于传递给 load_flags 参数的设置。
    
13. 使用示例：
    
14. 
    6 U0 r/ ^8 V7 d  m  X
15. c
    5 K( `4 I/ M. F; J' y
16. Copy code
    5 |& s! S* m- W1 f
17. FT_Load_Char(face, 'A', FT_LOAD_RENDER);
    2 Y1 I( l0 f7 V  G" e, `2 e
18. 这个示例会加载字体中字符 'A' 的字形数据，并将其渲染到位图中。FT_LOAD_RENDER 标志告诉FreeType要渲染字符的位图数据。加载后，您可以在 face->glyph 结构体中找到有关 'A' 字符的相关信息，包括位图数据、宽度、高度、位图偏移等等。
    # c' v  Q% O& b2 G- V$ A
19. 
    
20. 错误处理：
    
21. 
    9 o' v* e7 s. N4 t
22. 如果加载失败，FT_Load_Char 函数可以返回错误代码。您应该检查返回值以进行错误处理，并根据需要采取适当的措施，例如跳过加载失败的字符或终止渲染过程。
    
23. 总之，FT_Load_Char 函数是FreeType库中用于加载指定字符的字形数据的重要功能之一，它使您能够准备要渲染的字符数据，以便在文本渲染中使用。加载的数据可以包括字符的轮廓信息（矢量数据）和位图信息，具体取决于 load_flags 参数的设置。这个函数在字体渲染中起到关键作用，以便将字符正确呈现在屏幕上。

复制代码

8 _5 h2 ?6 s, h! ?" F代码
- B" n% \9 Z6 J" l' Z1 j6 L
7 N" j- d# o- J  M6 V2 C! w+ [

1. 
   
2. 
   
3. 
   + Y; q/ V1 \) B+ ~% ^
4. #include <stdio.h>
   , U, X# \8 P& d
5. #include <stdlib.h>
   7 f7 ^& s" v+ `: G  @" J
6. #include <GL/glew.h>
   ' N; A* l1 q$ Y8 B* Q
7. #include <GLFW/glfw3.h>
   : r  ~3 ~; _% i6 R) [
8. #include <ft2build.h>
   
9. #include FT_FREETYPE_H
   
10. 
    " t4 w+ r, @  ~  v. |: @1 O. [& L
11. // 定义字形数据的字节数组
    
12. unsigned char fontData[] = {
    
13.     // 字形数据的字节表示
    
14.     // 例如，这里可以包含字母、数字和符号的字形数据
    5 ^# Z. {% z0 F
15. };
    : m: n4 }) @& r2 @7 ^
16. 
    
17. FT_Library library;
    
18. FT_Face face;
    
19. GLuint fontTexture;
    6 u$ k$ M  k0 ~0 ?& [3 {
20. 
    & Z2 a9 p0 H' q* S* l
21. // 初始化FreeType库和OpenGL
    
22. void initialize() {
    9 K4 q+ D2 V# y$ z( k  B
23.     if (FT_Init_FreeType(&library)) {
    
24.         fprintf(stderr, "Failed to initialize FreeType\n");
    9 v4 I- c' n9 A( z6 [( ^" }
25.         exit(EXIT_FAILURE);
    
26.     }
    0 B0 d, i" r, F$ h+ ?: L% ^
27. 
    8 }+ W- b3 O4 P2 H
28.     if (FT_New_Memory_Face(library, fontData, sizeof(fontData), 0, &face)) {
    5 z  l0 ]0 c( J: P; b5 L4 K: {
29.         fprintf(stderr, "Failed to create a FreeType font face\n");
    & ]) ]( T8 E" o* V4 A
30.         exit(EXIT_FAILURE);
    ; V0 Y) I7 P0 I" H
31.     }
    
32. 
    
33.     if (FT_Set_Pixel_Sizes(face, 0, 48)) { // 设置字体大小
    
34.         fprintf(stderr, "Failed to set font size\n");
    
35.         exit(EXIT_FAILURE);
    
36.     }
    , b; P7 i2 m1 f* ?7 z
37. 
    
38.     glGenTextures(1, &fontTexture);
    # ]; E8 p# m/ T
39.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    
40.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    
41. 
    
42.     // 将字形数据传递给OpenGL纹理
    
43.     for (int i = 0; i < 128; i++) {
    
44.         if (FT_Load_Char(face, i, FT_LOAD_RENDER)) {
    
45.             fprintf(stderr, "Failed to load glyph for character '%c'\n", i);
    3 S* P3 t! v% m' u* i
46.             continue;
    
47.         }
    8 G9 `. H% z/ J. y0 j8 }
48. 
    $ x+ C0 L! J& Q2 C* p+ ~" W
49.         glTexImage2D(
    
50.             GL_TEXTURE_2D,
    1 `1 k# J! N, E% ^! j: a7 E2 F+ ^
51.             0,
    
52.             GL_RED,
    
53.             face->glyph->bitmap.width,
    ) t) e* v. n! a, h. M3 P
54.             face->glyph->bitmap.rows,
    , H# U% }* G  a9 B. z+ a. l4 Z
55.             0,
    & {, i" {0 |. Y: R2 t# f5 K- E
56.             GL_RED,
    6 \+ s  W7 m: h+ i
57.             GL_UNSIGNED_BYTE,
    
58.             face->glyph->bitmap.buffer
    " K7 ~) h8 Z( n. j; k
59.         );
    
60. 
    
61.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    
62.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    
63.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    
64.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    
65.     }
    
66. }
    
67. 
    % k3 w/ h0 ]  q# G$ `
68. // 渲染字符串
    
69. void renderString(const char* text, float x, float y) {
    
70.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    
71. 
    
72.     glEnable(GL_BLEND);
    4 o$ }) M4 u7 T
73.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
74. 
    ) j! [. w- m- R* c' N$ x8 K
75.     glBegin(GL_QUADS);
    
76.     for (const char* p = text; *p; p++) {
    + S' |- P9 T8 D* y
77.         FT_Load_Char(face, *p, FT_LOAD_RENDER);
    
78. 
    & t% `" x7 T! z: Z% x
79.         glTexImage2D(
    ( c: o/ @' n! l
80.             GL_TEXTURE_2D,
    
81.             0,
    
82.             GL_RED,
    
83.             face->glyph->bitmap.width,
    ) w! F) d+ r4 w0 M3 Z: w
84.             face->glyph->bitmap.rows,
    
85.             0,
    6 u# H0 T, d) v; ^& S
86.             GL_RED,
    
87.             GL_UNSIGNED_BYTE,
    
88.             face->glyph->bitmap.buffer
    - g2 a, o4 g! `9 H1 Z9 H
89.         );
    
90. 
    
91.         float xpos = x + face->glyph->bitmap_left;
    
92.         float ypos = y - (face->glyph->bitmap.rows - face->glyph->bitmap_top);
    
93. 
    ) @4 O$ Q# I5 |3 r8 m5 R5 V8 `8 H
94.         float w = face->glyph->bitmap.width;
    
95.         float h = face->glyph->bitmap.rows;
    
96. 
    # o6 t5 _$ Z5 F$ i8 s
97.         glTexCoord2f(0, 0);
    ) ?8 d/ d8 T% \/ P2 `) u* m
98.         glVertex2f(xpos, ypos);
    
99. 
    3 T$ s8 p: {/ ^% e) R1 E
100.         glTexCoord2f(0, 1);
     ! C# z5 M6 @) `$ S
101.         glVertex2f(xpos, ypos + h);
     
102. 
     
103.         glTexCoord2f(1, 1);
     8 A9 R( Q% e1 E# O" [# o' ]4 i+ F
104.         glVertex2f(xpos + w, ypos + h);
     
105. 
     : v  C& m% b) B1 s  }
106.         glTexCoord2f(1, 0);
     : v8 r% b) `% s: y8 o
107.         glVertex2f(xpos + w, ypos);
     
108. 
     
109.         x += (face->glyph->advance.x >> 6); // 字符之间的间距
     
110.     }
     
111.     glEnd();
     
112. 
     $ O5 C! n+ ~" `9 d# I. r2 ~
113.     glDisable(GL_BLEND);
     6 q6 G, Q8 E' @! L, n; r! w" J$ F
114. }
     
115. 
     
116. int main() {
     / r2 _' B5 ~; [8 _) V# E" t
117.     if (!glfwInit()) {
     / i0 d. O1 z; p: [! ^' r
118.         fprintf(stderr, "Failed to initialize GLFW\n");
     ! q% l' ~- {$ A! C  X
119.         return -1;
     , `" n& S1 D/ f7 n" ~. {
120.     }
     " I' O1 w/ k- S, Y/ Q
121. 
     
122.     GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL Text Rendering", NULL, NULL);
     4 ]& C0 f: m) D% U
123.     if (!window) {
     
124.         fprintf(stderr, "Failed to create GLFW window\n");
     " z/ }% }  |) [4 _* y
125.         glfwTerminate();
     
126.         return -1;
     
127.     }
     
128. 
     4 O0 a2 E( n; f
129.     glfwMakeContextCurrent(window);
     + d) V5 ^* I9 w" |! E" o. T
130.     glewInit();
     . `8 I! d- i) r5 g
131. 
     
132.     initialize();
     ( Q3 c, {0 H/ J1 `8 ]! E
133. 
     
134.     while (!glfwWindowShouldClose(window)) {
     
135.         glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     ' t7 {# [7 {: a9 t2 l% ?; C
136.         glClear(GL_COLOR_BUFFER_BIT);
     " E  k& H8 t, I8 G
137. 
     0 r* J5 r) Z& i
138.         glColor3f(1.0f, 1.0f, 1.0f);
     - ]. d1 v1 T. i; C
139.         renderString("Hello, OpenGL!", 100.0f, 100.0f);
     ( g5 [' z6 L4 v1 l. p) v$ O
140. 
     
141.         glfwSwapBuffers(window);
     
142.         glfwPollEvents();
     
143.     }
     - s4 V9 [. }! R# [  [/ S. S: V
144. 
     
145.     FT_Done_Face(face);
     
146.     FT_Done_FreeType(library);
     , r+ O/ D+ N4 L) p# j, B6 F
147. 
     6 V8 I  @: Y- F% T( J0 B
148.     glfwTerminate();
     9 w! h2 x+ H& U3 G7 S
149. 
     2 l" z- Y( g- \; I) y
150.     return 0;
     
151. }
     

复制代码

7 l# {: ]6 y4 O1 a