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

shane007

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

代码详细说明如下

3 g; e+ Q: }* L. k

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

复制代码

& j) |: d' s8 H9 ~. A$ j5 `  M9 A# }

1. 字形数据处理的关键函数之一。以下是 FT_Load_Char 函数的详细解释：
   
2. 
   
3. 参数：
   
4. 
   
5. face：一个指向已经打开的字体文件的 FT_Face 结构体的指针。FT_Face 包含了字体的各种信息，包括字形数据。
   
6. char_code：要加载的字符的Unicode编码值。您需要传递字符的Unicode编码作为此参数，以指定要加载的字符。
   
7. load_flags：一个用于控制字形加载选项的标志位。您可以使用这些标志位来控制加载的方式，例如是否要加载字形的轮廓数据、是否要加载字形的位图数据等。
   
8. 功能：
   
9. 
   7 }% Y, w) e* I
10. FT_Load_Char 函数的主要功能是加载指定字符的字形数据。
    ( J+ I$ C2 @% W8 ~5 c
11. 如果成功，它将在 FT_Face 结构体中的 glyph 字段中填充有关字符的字形信息。
    2 @+ x* w1 i: l
12. 这包括了字符的轮廓数据、位图数据、宽度、高度、位图偏移等等，具体取决于传递给 load_flags 参数的设置。
    
13. 使用示例：
    6 Y6 E0 \$ X/ @5 y" n/ u
14. 
    
15. c
    
16. Copy code
    5 I' B6 s- e+ r/ }# N' I
17. FT_Load_Char(face, 'A', FT_LOAD_RENDER);
    
18. 这个示例会加载字体中字符 'A' 的字形数据，并将其渲染到位图中。FT_LOAD_RENDER 标志告诉FreeType要渲染字符的位图数据。加载后，您可以在 face->glyph 结构体中找到有关 'A' 字符的相关信息，包括位图数据、宽度、高度、位图偏移等等。
    ( I* f) O# L4 l6 S* z# p. Z/ f; X
19. 
    
20. 错误处理：
      _4 x2 Y7 C( u# e/ {$ F2 y
21. 
    ( u3 W& R0 Q4 L0 A
22. 如果加载失败，FT_Load_Char 函数可以返回错误代码。您应该检查返回值以进行错误处理，并根据需要采取适当的措施，例如跳过加载失败的字符或终止渲染过程。
    
23. 总之，FT_Load_Char 函数是FreeType库中用于加载指定字符的字形数据的重要功能之一，它使您能够准备要渲染的字符数据，以便在文本渲染中使用。加载的数据可以包括字符的轮廓信息（矢量数据）和位图信息，具体取决于 load_flags 参数的设置。这个函数在字体渲染中起到关键作用，以便将字符正确呈现在屏幕上。

复制代码

代码
. O7 E1 j# `) f

1. 
   * q" O& \8 e# w7 g0 p. i6 L, I
2. 
   
3. 
   1 u4 L) Y- Z5 D. |6 w6 k
4. #include <stdio.h>
   " a" i6 Z" ?. Q! x5 x# S( A
5. #include <stdlib.h>
   7 u: j9 P1 W$ d1 U* Q  K) X
6. #include <GL/glew.h>
   
7. #include <GLFW/glfw3.h>
   ( d$ w- T$ N1 T* Z- ^5 `$ K5 {0 e
8. #include <ft2build.h>
   
9. #include FT_FREETYPE_H
   8 m4 @. l# l8 {. W' m% s# k9 Z
10. 
    * Y+ p) K% v  T& d, R
11. // 定义字形数据的字节数组
    " J+ D+ e3 l. t0 o& M' g7 f# e
12. unsigned char fontData[] = {
    1 g* I) u6 M; u+ ?. D5 e0 U! o4 U
13.     // 字形数据的字节表示
    ) S' W+ E0 ?" `/ C# F
14.     // 例如，这里可以包含字母、数字和符号的字形数据
    ( ^/ Y- b2 J( Y3 V: b, u+ Q
15. };
    
16. 
    $ C$ S) i, ~. K5 `2 \
17. FT_Library library;
    
18. FT_Face face;
    , C" m# B0 [6 D* w6 w6 D& `
19. GLuint fontTexture;
    % o4 g. v: N4 O0 }
20. 
    
21. // 初始化FreeType库和OpenGL
    5 ^8 b0 z3 _! m* S+ Z
22. void initialize() {
    , R! d$ g; n' n$ G. ~
23.     if (FT_Init_FreeType(&library)) {
    ( Q8 e; W9 l6 \2 W3 a5 U0 s. G
24.         fprintf(stderr, "Failed to initialize FreeType\n");
    
25.         exit(EXIT_FAILURE);
    $ y' H5 {5 u( |% ?' I. {
26.     }
    
27. 
    8 E! O8 f# n" R9 t/ C
28.     if (FT_New_Memory_Face(library, fontData, sizeof(fontData), 0, &face)) {
    $ c7 H! |0 V& s$ P( |
29.         fprintf(stderr, "Failed to create a FreeType font face\n");
    " M( b$ E2 b9 |8 [  {0 X
30.         exit(EXIT_FAILURE);
    6 z3 R$ [9 S: n# i6 i
31.     }
    
32. 
    : F4 Q$ h1 v% L0 S6 z( u
33.     if (FT_Set_Pixel_Sizes(face, 0, 48)) { // 设置字体大小
    
34.         fprintf(stderr, "Failed to set font size\n");
    
35.         exit(EXIT_FAILURE);
    
36.     }
    
37. 
    
38.     glGenTextures(1, &fontTexture);
    
39.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    
40.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    
41. 
    
42.     // 将字形数据传递给OpenGL纹理
    
43.     for (int i = 0; i < 128; i++) {
    % V1 k% N5 V& l, n
44.         if (FT_Load_Char(face, i, FT_LOAD_RENDER)) {
    
45.             fprintf(stderr, "Failed to load glyph for character '%c'\n", i);
    
46.             continue;
    / m! |2 c- k$ I' r- m
47.         }
    + d# Y/ S+ W3 t: }" T# ]+ o, k
48. 
    
49.         glTexImage2D(
    
50.             GL_TEXTURE_2D,
    
51.             0,
    
52.             GL_RED,
    
53.             face->glyph->bitmap.width,
    
54.             face->glyph->bitmap.rows,
    3 r* N' F. d" X; r: n
55.             0,
    
56.             GL_RED,
      d8 K" v) A$ X  k' J: X
57.             GL_UNSIGNED_BYTE,
    
58.             face->glyph->bitmap.buffer
    
59.         );
    / R9 f" V' V* t6 Y  Q3 B$ K$ T* t
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);
    ! }+ w) l0 H  S8 O: p9 B
63.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    
64.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    
65.     }
    
66. }
    * S; l! Y( O& [( [( J; {
67. 
    ! z$ n2 J( k4 ]
68. // 渲染字符串
    
69. void renderString(const char* text, float x, float y) {
    - }0 S# |, P9 I' [! `0 H( q: R2 K
70.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    
71. 
    
72.     glEnable(GL_BLEND);
    5 K+ e, I' k5 q( }, J
73.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
74. 
    
75.     glBegin(GL_QUADS);
    : J  V) O& b6 R# F3 r. a0 p! N
76.     for (const char* p = text; *p; p++) {
    
77.         FT_Load_Char(face, *p, FT_LOAD_RENDER);
    4 T: y& w: a! S4 ~* q8 c. q
78. 
    " a/ D& w* ^8 Z" \, i: I
79.         glTexImage2D(
    
80.             GL_TEXTURE_2D,
    + V: T7 p1 t: c: G/ X- \
81.             0,
    6 Y( W1 X0 x2 s
82.             GL_RED,
    ! D& ~  p+ f2 h1 c. g$ H
83.             face->glyph->bitmap.width,
    ) U0 }7 G) k5 d8 I3 w( w
84.             face->glyph->bitmap.rows,
    
85.             0,
    
86.             GL_RED,
    
87.             GL_UNSIGNED_BYTE,
    
88.             face->glyph->bitmap.buffer
    ) ^9 q0 o2 [8 X; y
89.         );
    
90. 
    ) c; p! e9 `3 r3 k3 v5 M
91.         float xpos = x + face->glyph->bitmap_left;
    0 N: U! L1 M# I/ f
92.         float ypos = y - (face->glyph->bitmap.rows - face->glyph->bitmap_top);
    & ?7 \* ?' P) v1 ~* u. q+ S
93. 
    / l! y+ v' w" J% L
94.         float w = face->glyph->bitmap.width;
    
95.         float h = face->glyph->bitmap.rows;
    4 f" F3 N5 L# ?- W; v1 F& T
96. 
    - d2 `/ W/ d" `: ^
97.         glTexCoord2f(0, 0);
    3 P* ]& k8 J4 T7 ?
98.         glVertex2f(xpos, ypos);
    % g- z$ P3 ^3 l% }7 j; M' D/ E
99. 
    
100.         glTexCoord2f(0, 1);
       l2 G, ]" A9 j
101.         glVertex2f(xpos, ypos + h);
     * Z. j, H; B6 v7 p
102. 
     / f" N4 o* ~6 q* P2 E! E* g
103.         glTexCoord2f(1, 1);
     
104.         glVertex2f(xpos + w, ypos + h);
     ; |9 u, y0 H' ~6 c
105. 
     
106.         glTexCoord2f(1, 0);
     
107.         glVertex2f(xpos + w, ypos);
     
108. 
     $ c' N! m7 [, {. R- D  x
109.         x += (face->glyph->advance.x >> 6); // 字符之间的间距
     
110.     }
     
111.     glEnd();
     # W4 c) M1 |( }4 E) d$ r! M
112. 
     3 u5 c" T8 H" A' H6 `3 d4 S
113.     glDisable(GL_BLEND);
     
114. }
     " Y7 e4 [4 E) M7 R$ F& w: ?" s
115. 
     
116. int main() {
     & x9 [! @8 C4 q9 |' E
117.     if (!glfwInit()) {
     
118.         fprintf(stderr, "Failed to initialize GLFW\n");
     $ P6 n, O- ~$ d! y
119.         return -1;
     
120.     }
     - B- C& A4 S' k$ h5 _4 Y
121. 
     3 E5 D- _7 s6 w
122.     GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL Text Rendering", NULL, NULL);
     
123.     if (!window) {
     
124.         fprintf(stderr, "Failed to create GLFW window\n");
     0 n7 v1 ?; q, I8 Q" M# n
125.         glfwTerminate();
     " x( W. d0 t( G
126.         return -1;
     
127.     }
     3 f- f8 k/ g. ?2 {7 m
128. 
     
129.     glfwMakeContextCurrent(window);
     7 |, r1 L4 N. \2 K5 V
130.     glewInit();
     # N" t6 S4 O" [
131. 
     8 y' x1 c. j5 v
132.     initialize();
     2 h- D8 T( a- y9 |5 Q
133. 
     ( P: L! p* I3 `  j7 F' H- R
134.     while (!glfwWindowShouldClose(window)) {
     # T. }$ [2 e4 X/ S2 Q
135.         glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     ' _: I2 B0 I/ F) X4 U5 j* A
136.         glClear(GL_COLOR_BUFFER_BIT);
     6 e4 I+ H8 F; Q& R9 q; W8 z
137. 
     
138.         glColor3f(1.0f, 1.0f, 1.0f);
     
139.         renderString("Hello, OpenGL!", 100.0f, 100.0f);
     
140. 
     . B. m$ m5 P4 B4 K
141.         glfwSwapBuffers(window);
     $ e$ d1 F( G! {9 U0 M
142.         glfwPollEvents();
     / S4 G0 x, j  B0 z
143.     }
     + ]* v3 [0 C; n: m9 x7 g
144. 
     8 N8 ~" T, B9 G
145.     FT_Done_Face(face);
     
146.     FT_Done_FreeType(library);
     . R3 ?0 T& M# i/ u) ~5 j  q
147. 
     
148.     glfwTerminate();
     
149. 
     ' l# g+ l( k1 y* F4 S
150.     return 0;
     
151. }
     ; }* K; X  J7 x6 ]! N

复制代码

7 J! a' w6 W/ v7 L. H