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

shane007

5 D' C, q( S' @" k( S2 b# R
以下是一个用来做参照的opengl显示字符串的代码，使用了freetype库。
本代码经过分析以及改写之后，将取代游戏原有的显示函数。
/ K9 d* Y: |6 l! }
代码详细说明如下

1 f! b* N8 {+ ~/ V

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

复制代码

0 }( I/ R! n5 A1 S( P+ Q

1. 字形数据处理的关键函数之一。以下是 FT_Load_Char 函数的详细解释：
     K+ ^; G+ L! t
2. 
   
3. 参数：
   ) A- u4 z$ ^4 Y  |3 j" A  v
4. 
   * r5 U% w! o8 C1 v7 k) F+ @
5. face：一个指向已经打开的字体文件的 FT_Face 结构体的指针。FT_Face 包含了字体的各种信息，包括字形数据。
   
6. char_code：要加载的字符的Unicode编码值。您需要传递字符的Unicode编码作为此参数，以指定要加载的字符。
   + _$ X% Q$ l- T- A/ T
7. load_flags：一个用于控制字形加载选项的标志位。您可以使用这些标志位来控制加载的方式，例如是否要加载字形的轮廓数据、是否要加载字形的位图数据等。
   
8. 功能：
   
9. 
   
10. FT_Load_Char 函数的主要功能是加载指定字符的字形数据。
    5 `- l9 ~' a7 g$ ~
11. 如果成功，它将在 FT_Face 结构体中的 glyph 字段中填充有关字符的字形信息。
    ; R% {& i6 ?/ E+ Z4 v
12. 这包括了字符的轮廓数据、位图数据、宽度、高度、位图偏移等等，具体取决于传递给 load_flags 参数的设置。
    5 q$ J- `9 P4 {/ t6 N
13. 使用示例：
    : Q% f9 b& \5 [2 s# \5 P, c
14. 
    
15. c
    
16. Copy code
    ) h" z+ |! L  ~
17. FT_Load_Char(face, 'A', FT_LOAD_RENDER);
    / A, I; l0 I' J
18. 这个示例会加载字体中字符 'A' 的字形数据，并将其渲染到位图中。FT_LOAD_RENDER 标志告诉FreeType要渲染字符的位图数据。加载后，您可以在 face->glyph 结构体中找到有关 'A' 字符的相关信息，包括位图数据、宽度、高度、位图偏移等等。
    , W2 j& ^4 p7 M( g6 O  S6 a
19. 
    
20. 错误处理：
    ) I* w; o5 l; ~) C, R0 U; N. X; V
21. 
    4 D8 F" ~+ u. \. b, e" C0 l
22. 如果加载失败，FT_Load_Char 函数可以返回错误代码。您应该检查返回值以进行错误处理，并根据需要采取适当的措施，例如跳过加载失败的字符或终止渲染过程。
    ! g5 T7 K0 L1 U' \
23. 总之，FT_Load_Char 函数是FreeType库中用于加载指定字符的字形数据的重要功能之一，它使您能够准备要渲染的字符数据，以便在文本渲染中使用。加载的数据可以包括字符的轮廓信息（矢量数据）和位图信息，具体取决于 load_flags 参数的设置。这个函数在字体渲染中起到关键作用，以便将字符正确呈现在屏幕上。

复制代码

# t& @7 \( f1 y% ?& K- J; d
" C; q- E- T0 @; D( r代码
8 }$ R5 E  D, j' v
  g/ V; |- `! [. C# w, v6 E, P+ u9 G

1. 
   
2. 
   
3. 
   : w: G! V- G3 Y- E: G! f+ j
4. #include <stdio.h>
   ! F1 b. b( h3 G3 O' X1 }6 g
5. #include <stdlib.h>
   " f& P5 _  |+ D; e
6. #include <GL/glew.h>
   
7. #include <GLFW/glfw3.h>
   
8. #include <ft2build.h>
   $ X9 W+ R9 i; L8 _
9. #include FT_FREETYPE_H
   
10. 
    
11. // 定义字形数据的字节数组
    - E; z0 x  d* E' e
12. unsigned char fontData[] = {
    8 i5 s" J, A/ r
13.     // 字形数据的字节表示
    , ]5 `4 y2 a1 T) ?
14.     // 例如，这里可以包含字母、数字和符号的字形数据
    ! r4 G4 V* L2 p" h9 {  N2 Z0 ^
15. };
    # ]" s# _$ q! s( I: L
16. 
    
17. FT_Library library;
    ( Y; g( v2 W% n3 a
18. FT_Face face;
    
19. GLuint fontTexture;
    
20. 
    , h, R. i4 ?7 \
21. // 初始化FreeType库和OpenGL
    
22. void initialize() {
    
23.     if (FT_Init_FreeType(&library)) {
    / X& A& L1 Z, A" l
24.         fprintf(stderr, "Failed to initialize FreeType\n");
    / B" ]  u$ N8 S. J. z) L
25.         exit(EXIT_FAILURE);
    
26.     }
    $ i( X( E9 ^9 S: v
27. 
    ) j- z4 }8 @" |# w9 }0 B. r# T
28.     if (FT_New_Memory_Face(library, fontData, sizeof(fontData), 0, &face)) {
    . e' {. b$ b, C1 c0 h
29.         fprintf(stderr, "Failed to create a FreeType font face\n");
    
30.         exit(EXIT_FAILURE);
    / C0 n. v# s( C- k- N# u9 J
31.     }
    # r3 @7 z6 Z/ T! h. V
32. 
    
33.     if (FT_Set_Pixel_Sizes(face, 0, 48)) { // 设置字体大小
    + A; g5 z/ ~  N9 [+ B
34.         fprintf(stderr, "Failed to set font size\n");
    
35.         exit(EXIT_FAILURE);
    , _4 c* Q% u0 u+ t* O& @4 d' H+ F
36.     }
    
37. 
    
38.     glGenTextures(1, &fontTexture);
    % L" b, c4 f7 V4 t& \
39.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    ' L) p/ N3 A# L' t# h2 [' v" C
40.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    3 `5 b7 R$ `+ s
41. 
    " {+ Y) c, `& ]! l
42.     // 将字形数据传递给OpenGL纹理
    ) x+ b4 R) m+ S! |
43.     for (int i = 0; i < 128; i++) {
    
44.         if (FT_Load_Char(face, i, FT_LOAD_RENDER)) {
    # H, |& D+ A' z8 _' z5 Q* r
45.             fprintf(stderr, "Failed to load glyph for character '%c'\n", i);
    6 ]. q* f% s. e1 T: j
46.             continue;
    
47.         }
    ( ^* a& R( K# n( t5 `2 v
48. 
    
49.         glTexImage2D(
    7 i$ ]. t) o7 @. |! X6 Z& J
50.             GL_TEXTURE_2D,
    
51.             0,
    : u& r+ _" I! ^; F8 ~
52.             GL_RED,
    - `  ]* o1 z1 `. d
53.             face->glyph->bitmap.width,
    8 P; P* d1 U" e& E/ L
54.             face->glyph->bitmap.rows,
    " {9 l7 H* M* n$ X
55.             0,
    6 ?- n; _2 a' b( {9 ]" d; t
56.             GL_RED,
    
57.             GL_UNSIGNED_BYTE,
    
58.             face->glyph->bitmap.buffer
    
59.         );
    % @, p6 Z# `; R5 J2 J* E1 `# L
60. 
    ' i0 m/ n! t" n% A- l2 S
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);
    7 J( x0 r  [5 A, X# }4 [
63.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    7 e4 A+ T+ S/ m" X
64.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    
65.     }
    
66. }
    
67. 
    / O+ N+ ]$ \3 g/ h7 t" [# e
68. // 渲染字符串
    # H- }. O: R; W+ ^9 {
69. void renderString(const char* text, float x, float y) {
    3 Z$ P% r4 V5 _; y8 }7 f/ d$ }
70.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    * f, U5 k  n- v3 X6 e" r
71. 
    
72.     glEnable(GL_BLEND);
    ( f+ s* ~, t- }9 {, E9 k
73.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    6 V' Y- T* L* {' g) P5 X7 u
74. 
    0 i, d  Y4 U; {( z2 Z/ \% u: ^# q
75.     glBegin(GL_QUADS);
    0 G8 u. `, t% d  S
76.     for (const char* p = text; *p; p++) {
    ' o: m+ a# D* T# }( q4 |
77.         FT_Load_Char(face, *p, FT_LOAD_RENDER);
    * q3 I1 S; |0 d: V. M
78. 
    
79.         glTexImage2D(
    
80.             GL_TEXTURE_2D,
    
81.             0,
    
82.             GL_RED,
    
83.             face->glyph->bitmap.width,
    
84.             face->glyph->bitmap.rows,
    1 ~& e3 |+ D, z& z" N& b. G8 r
85.             0,
    ) t& X) s/ C$ Y( ~4 |8 k
86.             GL_RED,
    
87.             GL_UNSIGNED_BYTE,
    7 i0 s) L, q  h- ~/ C1 L5 B6 G9 q  `) Z0 q
88.             face->glyph->bitmap.buffer
    
89.         );
    
90. 
    ( u  e' T. D5 Y3 p" X6 q
91.         float xpos = x + face->glyph->bitmap_left;
    + W6 H+ T* d0 c  ^6 S! d. k$ b7 Z
92.         float ypos = y - (face->glyph->bitmap.rows - face->glyph->bitmap_top);
    & p. D) r* Z1 J; W* D3 N7 j& G, s
93. 
    $ @+ b6 W" c! S8 r: j2 H$ |2 K
94.         float w = face->glyph->bitmap.width;
    ) v% G+ b; n& L3 y, J& e
95.         float h = face->glyph->bitmap.rows;
    
96. 
    
97.         glTexCoord2f(0, 0);
    
98.         glVertex2f(xpos, ypos);
    
99. 
    1 w; M( L+ E( u4 s
100.         glTexCoord2f(0, 1);
     0 Z8 e' L! |! Z* h0 j( F. O+ b
101.         glVertex2f(xpos, ypos + h);
     
102. 
     5 j' z- M% F7 t6 m% T
103.         glTexCoord2f(1, 1);
       V+ h" E2 G1 W$ n  t. v2 p
104.         glVertex2f(xpos + w, ypos + h);
     & E' T# j" y* q6 {4 s
105. 
     
106.         glTexCoord2f(1, 0);
       x4 @) |) }2 y) I8 W6 i
107.         glVertex2f(xpos + w, ypos);
     
108. 
     
109.         x += (face->glyph->advance.x >> 6); // 字符之间的间距
     
110.     }
     
111.     glEnd();
     
112. 
     9 w! T" d% E+ \4 y* S. z  Y8 J
113.     glDisable(GL_BLEND);
     % W# H! }( _: d7 T$ P: p% @
114. }
     ( _! d1 m& d( `. h$ B4 }
115. 
     
116. int main() {
     4 \4 E6 ~' ?) U' y8 k4 T
117.     if (!glfwInit()) {
     
118.         fprintf(stderr, "Failed to initialize GLFW\n");
     
119.         return -1;
     5 u; R0 [  `* ^/ Z" C
120.     }
     
121. 
     : q0 w, S8 j* o! n
122.     GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL Text Rendering", NULL, NULL);
     - L& s) {% D- [, ]; N* s. j
123.     if (!window) {
     
124.         fprintf(stderr, "Failed to create GLFW window\n");
     
125.         glfwTerminate();
     ( H! A6 v; F0 Z- v
126.         return -1;
     
127.     }
     : o6 H! b' O* y4 W' g/ N
128. 
     
129.     glfwMakeContextCurrent(window);
     
130.     glewInit();
     $ S8 [1 Y7 W2 n) W9 b5 b
131. 
     
132.     initialize();
     $ K, ^+ \. t1 H9 n2 w
133. 
     & E& W+ y3 W1 Y
134.     while (!glfwWindowShouldClose(window)) {
     
135.         glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     
136.         glClear(GL_COLOR_BUFFER_BIT);
     
137. 
     ' k" [5 T: m8 l* x  d
138.         glColor3f(1.0f, 1.0f, 1.0f);
     ) j, h0 L- E+ p, R7 k
139.         renderString("Hello, OpenGL!", 100.0f, 100.0f);
     
140. 
     
141.         glfwSwapBuffers(window);
     " i& r. I! e( C
142.         glfwPollEvents();
     
143.     }
     4 J8 w9 F) f7 p% ^, M8 F
144. 
     , `# _! L' h$ a. P1 ^# k4 t4 D3 O
145.     FT_Done_Face(face);
     
146.     FT_Done_FreeType(library);
     9 I$ ~2 ]: O& C5 }, W& y7 z6 [
147. 
     ) b: }! r4 K' y
148.     glfwTerminate();
     6 ?3 [* C' E8 X3 Z2 ]* `" G
149. 
     + C. v  H( p; T0 c$ C% ^
150.     return 0;
     
151. }
     

复制代码

# ]: N$ n! b& n/ f
) u/ B- T1 r3 z5 Y9 g

星之韶华

学习学习一下