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

shane007

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

; t7 D- M0 x- V, Q3 }代码详细说明如下

5 G$ J& |0 w9 @3 \) i! Z' |: j% w

1. 在上述 renderString 函数中，我们有以下关键部分的解释：
   1 x/ N; R0 l% x& V1 P
2. 
   
3. glBindTexture(GL_TEXTURE_2D, fontTexture);：将字体纹理绑定到当前的OpenGL上下文。这是因为我们要使用 fontTexture 中存储的字形位图数据进行渲染。
   
4. 
   + v( j- X2 ]) ]* U
5. glEnable(GL_BLEND); 和 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);：启用混合模式以处理字符的透明度。混合模式通过 glBlendFunc 设置，这里使用了常见的源和目标因子来实现源颜色与目标颜色的混合，从而实现透明效果。
   
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 中访问该字符的字形数据。
    + L6 ^! h0 t% b5 V
12. 
    
13. 计算字符在屏幕上的位置和大小，包括 xpos（x坐标）、ypos（y坐标）、w（宽度）和 h（高度）。
    6 z" o) G: h; S1 P. {+ Y) j# r6 ]. ~
14. 
    
15. 使用 glTexCoord2f 和 glVertex2f 来指定字符的纹理坐标和顶点坐标，以创建一个四边形。这四边形将字形的位图数据绘制到屏幕上的指定位置。
    ; p7 C1 d  G( |2 E4 \1 ~% K
16. 
    
17. x += (face->glyph->advance.x >> 6);：更新 x 坐标，以便将下一个字符紧密排列在当前字符的后面。face->glyph->advance.x 包含字符的横向位移信息，>> 6 是用来将其转换为像素单位的操作。
    
18. 
    1 `! o) i6 @' V8 ~
19. 最后，glDisable(GL_BLEND); 用于禁用混合模式，以免影响后续的绘制操作。
    
20. 
    
21. 总之，renderString 函数的作用是将传递给它的字符串中的字符一个接一个地绘制到OpenGL上下文中，使用FreeType加载的字形数据和字体纹理来实现文本渲染效果。渲染过程涉及到字符的位置计算、纹理坐标的设置以及混合模式的启用和禁用，以确保字符在屏幕上正确显示。
    ' _3 I* l! q2 H9 D  X; O7 E- r

复制代码

6 o. H1 ~. ]5 F/ L! d3 x! m
2 o7 G- {% ?$ J0 v2 X* t1 Y5 A; o

1. 字形数据处理的关键函数之一。以下是 FT_Load_Char 函数的详细解释：
   
2. 
   
3. 参数：
   , A# V% s4 l  W' U3 P+ N/ w
4. 
   
5. face：一个指向已经打开的字体文件的 FT_Face 结构体的指针。FT_Face 包含了字体的各种信息，包括字形数据。
   / v& \6 G. q  x8 `2 i. f0 W
6. char_code：要加载的字符的Unicode编码值。您需要传递字符的Unicode编码作为此参数，以指定要加载的字符。
   
7. load_flags：一个用于控制字形加载选项的标志位。您可以使用这些标志位来控制加载的方式，例如是否要加载字形的轮廓数据、是否要加载字形的位图数据等。
   6 o3 f% h, b. b
8. 功能：
   ( f& h( F2 s" S
9. 
   3 D& U8 c. o* ]7 ?1 @9 I1 l
10. FT_Load_Char 函数的主要功能是加载指定字符的字形数据。
    - x7 X  H& w1 R1 `* P7 ?
11. 如果成功，它将在 FT_Face 结构体中的 glyph 字段中填充有关字符的字形信息。
    9 O' |& H) O+ {  b/ t
12. 这包括了字符的轮廓数据、位图数据、宽度、高度、位图偏移等等，具体取决于传递给 load_flags 参数的设置。
    8 Y  d# L  c7 h! P, `* r- P0 D1 N- y* z
13. 使用示例：
    
14. 
    
15. c
    1 `6 |- T. B+ j  K1 T7 v8 A$ T' ?
16. Copy code
    
17. FT_Load_Char(face, 'A', FT_LOAD_RENDER);
    ' j+ s( W8 }# ~
18. 这个示例会加载字体中字符 'A' 的字形数据，并将其渲染到位图中。FT_LOAD_RENDER 标志告诉FreeType要渲染字符的位图数据。加载后，您可以在 face->glyph 结构体中找到有关 'A' 字符的相关信息，包括位图数据、宽度、高度、位图偏移等等。
    
19. 
    5 I$ O+ n1 l. q$ R- s. P
20. 错误处理：
    
21. 
    
22. 如果加载失败，FT_Load_Char 函数可以返回错误代码。您应该检查返回值以进行错误处理，并根据需要采取适当的措施，例如跳过加载失败的字符或终止渲染过程。
    + B9 R/ D% d6 w, M/ I
23. 总之，FT_Load_Char 函数是FreeType库中用于加载指定字符的字形数据的重要功能之一，它使您能够准备要渲染的字符数据，以便在文本渲染中使用。加载的数据可以包括字符的轮廓信息（矢量数据）和位图信息，具体取决于 load_flags 参数的设置。这个函数在字体渲染中起到关键作用，以便将字符正确呈现在屏幕上。

复制代码

1 ^) G% @. O; a2 n  e4 r( h6 P
代码

1. 
   ; o# `5 }0 q6 W8 {7 G+ W
2. 
   
3. 
   % E( v, g! L9 @( @% l
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <GL/glew.h>
   3 z2 L; x! E- H# y4 a8 D
7. #include <GLFW/glfw3.h>
   : |4 z6 P) _# w3 N3 U" k/ I
8. #include <ft2build.h>
   8 A& ~. s. n9 y3 \$ d
9. #include FT_FREETYPE_H
   
10. 
    , B4 {! d5 k8 b; E* g& r
11. // 定义字形数据的字节数组
    ) O7 m7 \* ?2 U! e$ I3 \
12. unsigned char fontData[] = {
    3 |. w% g' |% d' q
13.     // 字形数据的字节表示
    
14.     // 例如，这里可以包含字母、数字和符号的字形数据
    
15. };
    / l$ J2 v" B) w+ z8 D9 g7 O
16. 
    4 z6 M$ o! ^7 g6 w7 m9 F
17. FT_Library library;
    
18. FT_Face face;
    
19. GLuint fontTexture;
    : v1 \$ c8 F: q8 ]6 L- `
20. 
      T6 v5 k) |# B3 N; x( R
21. // 初始化FreeType库和OpenGL
    
22. void initialize() {
    5 G# b- E% {5 ]: q+ M/ X, \
23.     if (FT_Init_FreeType(&library)) {
    0 J( d7 t+ W: @7 G- G$ j
24.         fprintf(stderr, "Failed to initialize FreeType\n");
    2 a1 _. q4 I3 u% Q
25.         exit(EXIT_FAILURE);
    
26.     }
    6 y) S6 |( C, o
27. 
    $ O0 K' F- Z2 }% }6 e* C4 V3 y
28.     if (FT_New_Memory_Face(library, fontData, sizeof(fontData), 0, &face)) {
    $ \7 \; i* n* m6 b! U& s! W; o
29.         fprintf(stderr, "Failed to create a FreeType font face\n");
    ! o" {5 }+ Z8 h$ U! u2 |
30.         exit(EXIT_FAILURE);
    
31.     }
    . j4 i! G, _. n& z- C. O( b4 L: u# o
32. 
    ; W" e& v9 A  I8 ]4 C) d
33.     if (FT_Set_Pixel_Sizes(face, 0, 48)) { // 设置字体大小
    : p& \, F* J! R# t- t% E2 C! X
34.         fprintf(stderr, "Failed to set font size\n");
    
35.         exit(EXIT_FAILURE);
    ! o. Y' |/ u0 l6 s* }3 i- N3 S
36.     }
    
37. 
    8 X( f* H( Z2 I2 n& V6 ^, g
38.     glGenTextures(1, &fontTexture);
    " {$ r7 L5 i. {( _- O4 _1 N+ f5 X
39.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    . Y+ L4 `1 `/ Q0 w: C
40.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    9 a; M6 ~; f2 U/ b2 ?
41. 
    
42.     // 将字形数据传递给OpenGL纹理
    
43.     for (int i = 0; i < 128; i++) {
    * J% [& n$ K* E* p' @- `" j( B
44.         if (FT_Load_Char(face, i, FT_LOAD_RENDER)) {
    
45.             fprintf(stderr, "Failed to load glyph for character '%c'\n", i);
    
46.             continue;
    3 \$ q8 H- a  Z7 {- w. n
47.         }
    
48. 
    4 ]% {8 |. j- c; i: D5 _) b
49.         glTexImage2D(
    0 M- ~( L* `, Z' j" |3 j! z
50.             GL_TEXTURE_2D,
    
51.             0,
    & b( E5 K% T. G! m' b/ s. F
52.             GL_RED,
    9 C0 K, n$ w- x) y0 Q4 i5 r1 @
53.             face->glyph->bitmap.width,
    / D2 a5 U: h% j$ Z
54.             face->glyph->bitmap.rows,
    ; _( R5 A2 q9 }% V2 l8 i
55.             0,
    , K8 f& l# d8 D, F  \4 u
56.             GL_RED,
    
57.             GL_UNSIGNED_BYTE,
    
58.             face->glyph->bitmap.buffer
    
59.         );
    
60. 
    1 l- f5 w# z; U$ N, E) y
61.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    ) A8 u' n) B$ E; ~) ?1 w" T
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);
    9 N  E* o7 X6 B' X  v" `9 Z' k
65.     }
    
66. }
    
67. 
    1 s0 a4 z2 [( s( f* |
68. // 渲染字符串
    
69. void renderString(const char* text, float x, float y) {
    
70.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    / g7 ]4 W; A- T- I4 u; t1 g% U
71. 
    ) B0 D4 a& N& h$ I
72.     glEnable(GL_BLEND);
    
73.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
74. 
    # }$ q7 {7 Y5 Q( H% I8 U
75.     glBegin(GL_QUADS);
    
76.     for (const char* p = text; *p; p++) {
    / m" O5 f  M; m, B6 I8 u3 s: b# P' {
77.         FT_Load_Char(face, *p, FT_LOAD_RENDER);
    
78. 
    0 p' @4 W4 ?7 c9 M9 ^: F; N
79.         glTexImage2D(
    
80.             GL_TEXTURE_2D,
      [8 h& d5 \: F3 t$ @* F: R
81.             0,
    
82.             GL_RED,
    
83.             face->glyph->bitmap.width,
    ) e; n: _4 Q: ~- Y2 y
84.             face->glyph->bitmap.rows,
    
85.             0,
    5 Y7 J7 D8 Y* P3 O9 m. Q
86.             GL_RED,
    
87.             GL_UNSIGNED_BYTE,
    
88.             face->glyph->bitmap.buffer
    - w! r! b1 r4 o4 V/ p3 a5 @
89.         );
    9 J: z0 E. V7 |
90. 
      Z: T. U" F) \. I- k9 h
91.         float xpos = x + face->glyph->bitmap_left;
    
92.         float ypos = y - (face->glyph->bitmap.rows - face->glyph->bitmap_top);
    $ }1 [. w$ ~" u3 b2 Z8 C9 I$ a, f7 \1 {
93. 
    " m# _$ b" o% R- ~# z3 G
94.         float w = face->glyph->bitmap.width;
    
95.         float h = face->glyph->bitmap.rows;
    
96. 
    7 `$ E  v5 r5 m1 Z9 R
97.         glTexCoord2f(0, 0);
    
98.         glVertex2f(xpos, ypos);
    
99. 
    
100.         glTexCoord2f(0, 1);
     - m$ z3 {0 S: W1 x
101.         glVertex2f(xpos, ypos + h);
     
102. 
     
103.         glTexCoord2f(1, 1);
     & V* k; y$ w. h2 [7 h6 Z
104.         glVertex2f(xpos + w, ypos + h);
     
105. 
     5 }( R5 y4 T$ A2 ?( z& `
106.         glTexCoord2f(1, 0);
     
107.         glVertex2f(xpos + w, ypos);
     
108. 
     
109.         x += (face->glyph->advance.x >> 6); // 字符之间的间距
     + e  s4 l4 i7 o+ A: ]* U
110.     }
     4 T1 ^: h; |  ?% C+ {
111.     glEnd();
     
112. 
     7 ^, s0 N* ~$ t) O; ]
113.     glDisable(GL_BLEND);
     0 T3 i& p$ {$ n( w: \
114. }
     
115. 
     * {) l6 j& ~' P6 X; U
116. int main() {
     
117.     if (!glfwInit()) {
     , F" K2 D0 {' d9 G# Z" A" B0 C+ N. Z
118.         fprintf(stderr, "Failed to initialize GLFW\n");
     3 ^# Q! r# ]# o2 c# q6 Q8 `
119.         return -1;
     
120.     }
     
121. 
     & H/ U; d6 J; P  w( H5 P+ w
122.     GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL Text Rendering", NULL, NULL);
     
123.     if (!window) {
     6 Y& q3 {) }' i% U) e/ p6 r# `1 _
124.         fprintf(stderr, "Failed to create GLFW window\n");
     : Z9 U! h+ T, O( h5 v
125.         glfwTerminate();
     ' J% T1 w. \7 c0 Z3 u/ `" [$ B/ z" V; z
126.         return -1;
     
127.     }
     
128. 
     ; N  W8 B! W- j9 ^  i9 D4 a2 t2 j
129.     glfwMakeContextCurrent(window);
     
130.     glewInit();
     
131. 
     
132.     initialize();
     % l9 l( G6 {% ]7 N9 ^# f( g" V; C
133. 
     ' e. {. W4 U8 Q* |
134.     while (!glfwWindowShouldClose(window)) {
     : ^0 Z) ]! u$ G) {- X+ H7 D
135.         glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     
136.         glClear(GL_COLOR_BUFFER_BIT);
     & x  B& o( u, N
137. 
     
138.         glColor3f(1.0f, 1.0f, 1.0f);
     
139.         renderString("Hello, OpenGL!", 100.0f, 100.0f);
     
140. 
     5 U: F& W  X, h
141.         glfwSwapBuffers(window);
     
142.         glfwPollEvents();
     
143.     }
     
144. 
     & h1 u( X9 \: e& f& w4 }! e
145.     FT_Done_Face(face);
     : Y9 t% B% C5 ^% P# u- w1 ^2 m, Y
146.     FT_Done_FreeType(library);
     
147. 
     1 S5 _9 U& M0 m
148.     glfwTerminate();
     
149. 
     * ^% E4 k+ q+ [
150.     return 0;
     
151. }
     / P. D+ I' X, N! w

复制代码

0 c6 x% d2 f* d& X; q1 T

星之韶华

学习学习一下