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

shane007

) t" X& o6 D' U9 [* j0 b. @* q
以下是一个用来做参照的opengl显示字符串的代码，使用了freetype库。
5 ?  h2 M3 z: U# M' T本代码经过分析以及改写之后，将取代游戏原有的显示函数。

' J( q/ k- I/ s" C8 ]0 m5 B代码详细说明如下

/ P1 \' M: ^7 U+ A( P

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

复制代码

1. 字形数据处理的关键函数之一。以下是 FT_Load_Char 函数的详细解释：
   
2. 
   4 E7 z4 a9 d) Q$ M/ O; `
3. 参数：
   & G' A* v% Y* R  ^  d' n0 A' }
4. 
   1 u; W: a! q% y8 d$ R6 P
5. face：一个指向已经打开的字体文件的 FT_Face 结构体的指针。FT_Face 包含了字体的各种信息，包括字形数据。
   % \0 s5 g9 c) N  d6 z
6. char_code：要加载的字符的Unicode编码值。您需要传递字符的Unicode编码作为此参数，以指定要加载的字符。
   . E6 I4 w, g  |5 {4 o1 C5 Z
7. load_flags：一个用于控制字形加载选项的标志位。您可以使用这些标志位来控制加载的方式，例如是否要加载字形的轮廓数据、是否要加载字形的位图数据等。
   
8. 功能：
   
9. 
   
10. FT_Load_Char 函数的主要功能是加载指定字符的字形数据。
    
11. 如果成功，它将在 FT_Face 结构体中的 glyph 字段中填充有关字符的字形信息。
    # Q3 W5 g: T- X$ ~% b
12. 这包括了字符的轮廓数据、位图数据、宽度、高度、位图偏移等等，具体取决于传递给 load_flags 参数的设置。
    
13. 使用示例：
    ! c  u1 N. b+ c& P$ M
14. 
    
15. c
    9 Y1 ]( Z$ m& l' i1 P
16. Copy code
    
17. FT_Load_Char(face, 'A', FT_LOAD_RENDER);
    " ]' ]- x' q: r! |
18. 这个示例会加载字体中字符 'A' 的字形数据，并将其渲染到位图中。FT_LOAD_RENDER 标志告诉FreeType要渲染字符的位图数据。加载后，您可以在 face->glyph 结构体中找到有关 'A' 字符的相关信息，包括位图数据、宽度、高度、位图偏移等等。
    
19. 
    9 S% L. V5 ^5 i& `
20. 错误处理：
    4 a5 C2 @+ q7 X
21. 
    " ^: T8 T# A& w) b! ]
22. 如果加载失败，FT_Load_Char 函数可以返回错误代码。您应该检查返回值以进行错误处理，并根据需要采取适当的措施，例如跳过加载失败的字符或终止渲染过程。
    7 }" v3 k$ h4 m4 _2 O& Z! W% W
23. 总之，FT_Load_Char 函数是FreeType库中用于加载指定字符的字形数据的重要功能之一，它使您能够准备要渲染的字符数据，以便在文本渲染中使用。加载的数据可以包括字符的轮廓信息（矢量数据）和位图信息，具体取决于 load_flags 参数的设置。这个函数在字体渲染中起到关键作用，以便将字符正确呈现在屏幕上。

复制代码

8 M5 R2 B7 j+ a& [5 q
2 h8 W2 @; ?% w6 S" W) W3 }代码
- ?; w, g$ a, U- O, X3 _# |
4 W) U1 [) u* E' r# r6 S- k) B

1. 
   
2. 
   
3. 
   
4. #include <stdio.h>
   - {: H& m/ A" l# J: R) ?& }
5. #include <stdlib.h>
   
6. #include <GL/glew.h>
   8 T' _" K/ \4 y1 s
7. #include <GLFW/glfw3.h>
   - R0 R1 _( S* U4 P% s
8. #include <ft2build.h>
   
9. #include FT_FREETYPE_H
   
10. 
    
11. // 定义字形数据的字节数组
    + v! _1 u3 D* N8 l: K
12. unsigned char fontData[] = {
    ! ]4 }* E+ I( q
13.     // 字形数据的字节表示
    
14.     // 例如，这里可以包含字母、数字和符号的字形数据
    
15. };
    
16. 
    9 I& ^! c2 K2 X+ s1 e5 m' r* D
17. FT_Library library;
    
18. FT_Face face;
    
19. GLuint fontTexture;
    5 F& K2 d+ p- U' n) S* e% j+ B/ L
20. 
    : \' b. O* }+ E$ \
21. // 初始化FreeType库和OpenGL
    
22. void initialize() {
    
23.     if (FT_Init_FreeType(&library)) {
    4 ~1 B" y' e: Z2 a3 x' T
24.         fprintf(stderr, "Failed to initialize FreeType\n");
    " G3 S0 w" p3 z6 Q- t+ b- p8 o$ m
25.         exit(EXIT_FAILURE);
    ' x3 j4 _9 y& E1 i
26.     }
    
27. 
    
28.     if (FT_New_Memory_Face(library, fontData, sizeof(fontData), 0, &face)) {
    
29.         fprintf(stderr, "Failed to create a FreeType font face\n");
    : C' H: P. B+ H
30.         exit(EXIT_FAILURE);
    3 S# m* {: d' O( k
31.     }
      i+ h6 i2 I' |/ k0 b. p" i! `
32. 
    
33.     if (FT_Set_Pixel_Sizes(face, 0, 48)) { // 设置字体大小
    $ C1 a# x7 W3 J8 @/ P' s3 P
34.         fprintf(stderr, "Failed to set font size\n");
    
35.         exit(EXIT_FAILURE);
    & }* [* }! ~9 M
36.     }
    
37. 
    
38.     glGenTextures(1, &fontTexture);
    
39.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    
40.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    
41. 
    # A& [7 q: T9 }$ S& n  h
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);
    
46.             continue;
    ( ?' s+ x% T. o7 S1 l
47.         }
    3 c% w( t4 P8 [& D
48. 
    7 T; ~- W2 a( \3 z% M; o! X0 K$ B6 u
49.         glTexImage2D(
    
50.             GL_TEXTURE_2D,
    
51.             0,
    7 Y7 j0 T# |8 t) A; H
52.             GL_RED,
    # ]8 |( D" m  e3 r, U
53.             face->glyph->bitmap.width,
    
54.             face->glyph->bitmap.rows,
    1 j+ |7 _+ {( Y4 V$ j7 E8 d
55.             0,
    * ~. u4 b6 c( P/ |+ C
56.             GL_RED,
    " Z. d: Q; h: L4 D8 v. v6 o
57.             GL_UNSIGNED_BYTE,
    ! }& d6 e/ q: ~( A# ?9 B- _' l
58.             face->glyph->bitmap.buffer
    % i8 T4 i  w/ J" A9 b
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);
    ) y4 j; o3 q$ ^8 e  z
63.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    
64.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    
65.     }
    
66. }
    / Q# A& `. y& ?3 n3 c7 f7 K( A% b
67. 
    
68. // 渲染字符串
    
69. void renderString(const char* text, float x, float y) {
    6 R* h* F; E( B% J3 O# f; ~1 g
70.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    , v% ]' Y" y" z/ X* {" Y$ c1 V6 x
71. 
    & x, k: ]4 l5 d' h! N7 Q
72.     glEnable(GL_BLEND);
    5 I" P4 T5 `0 y7 l7 A3 n# L& n( M
73.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
74. 
    
75.     glBegin(GL_QUADS);
    
76.     for (const char* p = text; *p; p++) {
    
77.         FT_Load_Char(face, *p, FT_LOAD_RENDER);
    5 L# K$ P: D5 U6 {  \( f$ I
78. 
    
79.         glTexImage2D(
    . |& G* r/ j/ s" O: j
80.             GL_TEXTURE_2D,
      f9 @  P: [! U' G% m, K
81.             0,
    
82.             GL_RED,
    & F4 p: v: p  |' ^+ ?- W! E
83.             face->glyph->bitmap.width,
    7 x  f$ n& V  C9 G( I6 E
84.             face->glyph->bitmap.rows,
    9 \4 g6 }- T! h& f$ ~
85.             0,
    0 N: M  F' E( a# _
86.             GL_RED,
    # H7 A1 L* w9 o) A
87.             GL_UNSIGNED_BYTE,
    
88.             face->glyph->bitmap.buffer
    
89.         );
    ' ]# ]3 @. e1 x. a$ l: r! a2 k
90. 
    
91.         float xpos = x + face->glyph->bitmap_left;
    
92.         float ypos = y - (face->glyph->bitmap.rows - face->glyph->bitmap_top);
    - ], x5 |- d9 N) Z& H4 ]  i
93. 
    
94.         float w = face->glyph->bitmap.width;
    / s/ h5 v: b2 j* @' h! [
95.         float h = face->glyph->bitmap.rows;
    
96. 
    $ U2 A4 k$ y% H5 f
97.         glTexCoord2f(0, 0);
    7 i3 s3 |& x# A" X0 S( X
98.         glVertex2f(xpos, ypos);
    3 ^- @# c3 O$ H+ }; e: l  }
99. 
    
100.         glTexCoord2f(0, 1);
     
101.         glVertex2f(xpos, ypos + h);
     
102. 
     
103.         glTexCoord2f(1, 1);
     - m- c0 p9 @. f9 O+ C
104.         glVertex2f(xpos + w, ypos + h);
     ! u' H: O5 C, I7 Y  s2 E
105. 
     
106.         glTexCoord2f(1, 0);
     
107.         glVertex2f(xpos + w, ypos);
     
108. 
     + s( U9 ?9 Q& b. Q3 ]! q
109.         x += (face->glyph->advance.x >> 6); // 字符之间的间距
     
110.     }
     , [1 I& T6 A) o1 i, {7 U0 W
111.     glEnd();
     
112. 
     
113.     glDisable(GL_BLEND);
     & g) x) @) E, @; F
114. }
     $ x9 v6 C+ A- S) B+ d1 \2 W5 J
115. 
     
116. int main() {
     5 |8 e8 F" r$ {
117.     if (!glfwInit()) {
     
118.         fprintf(stderr, "Failed to initialize GLFW\n");
     . X  V0 M4 w  |8 p$ |" b2 ~
119.         return -1;
     ) k) K3 X7 F7 h
120.     }
     % `3 q( u) Z& k. p
121. 
     ; N+ @) n# G- c! n7 G
122.     GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL Text Rendering", NULL, NULL);
     1 k* ^' ^8 y4 a6 Z" I
123.     if (!window) {
     # G" W% ^4 M9 o1 ]# c/ x9 e3 K' p
124.         fprintf(stderr, "Failed to create GLFW window\n");
     
125.         glfwTerminate();
     
126.         return -1;
     7 g" [8 o2 P5 B% T4 l! M$ Y+ j8 f
127.     }
     6 v9 ]9 O, }8 J7 r/ n& I9 m
128. 
     + ^" x" b$ G( h! V2 ^
129.     glfwMakeContextCurrent(window);
     8 T" @1 r1 _( L3 l+ z; P- g
130.     glewInit();
     . U8 L8 }+ U$ G, q
131. 
     8 V1 W9 e* {; ]6 b
132.     initialize();
     
133. 
     + t+ h- T( b3 ]" ?) U
134.     while (!glfwWindowShouldClose(window)) {
     5 e& N9 D2 u6 ~2 S3 C% |* ]
135.         glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     4 q& N, r: Q' J: [  D/ C
136.         glClear(GL_COLOR_BUFFER_BIT);
     9 Z7 M% s8 j/ {- a3 j2 x0 J
137. 
     * d9 I5 J6 s8 E0 J: }7 E; l
138.         glColor3f(1.0f, 1.0f, 1.0f);
     
139.         renderString("Hello, OpenGL!", 100.0f, 100.0f);
     
140. 
     8 n2 o% f8 ~& ^
141.         glfwSwapBuffers(window);
     ( V  ~4 |, C2 e! n' P; ]# U( D
142.         glfwPollEvents();
     6 z, M. d& J: [0 g. ~  @
143.     }
     0 f$ H& z$ c0 f  w$ O6 q" `8 J
144. 
     ( r6 i/ ?- E+ c3 L3 t) {3 s
145.     FT_Done_Face(face);
     . X1 D3 _: V& K/ K7 [3 L
146.     FT_Done_FreeType(library);
     
147. 
     
148.     glfwTerminate();
     ; k' U1 c( w1 I3 {6 W+ c; \
149. 
     
150.     return 0;
     ! \5 D7 R8 H- F
151. }
     7 }9 S  ?+ y. {) h6 v. R6 G

复制代码

4 T6 P% o- O! r$ S& M8 w