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

shane007

& ]2 d6 _) U9 @$ S: D以下是一个用来做参照的opengl显示字符串的代码，使用了freetype库。
本代码经过分析以及改写之后，将取代游戏原有的显示函数。
1 N& n- f6 Z+ N
) s" i! @% _* u: B8 p: i代码详细说明如下
- b; p8 B. i9 h8 ^0 M/ J
$ D, ?/ P2 H; u2 a6 p( |. ]

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

复制代码

7 ?4 x6 b# O8 Z

1. 字形数据处理的关键函数之一。以下是 FT_Load_Char 函数的详细解释：
   
2. 
   
3. 参数：
   
4. 
   
5. face：一个指向已经打开的字体文件的 FT_Face 结构体的指针。FT_Face 包含了字体的各种信息，包括字形数据。
   
6. char_code：要加载的字符的Unicode编码值。您需要传递字符的Unicode编码作为此参数，以指定要加载的字符。
   . G" U, _- J" Z( y" ]: ?0 d
7. load_flags：一个用于控制字形加载选项的标志位。您可以使用这些标志位来控制加载的方式，例如是否要加载字形的轮廓数据、是否要加载字形的位图数据等。
   : d3 o2 x5 Q4 i8 _! t2 l- W6 r. ^
8. 功能：
   
9. 
   % U# Z, X) R$ l3 W* G4 Z
10. FT_Load_Char 函数的主要功能是加载指定字符的字形数据。
    
11. 如果成功，它将在 FT_Face 结构体中的 glyph 字段中填充有关字符的字形信息。
    
12. 这包括了字符的轮廓数据、位图数据、宽度、高度、位图偏移等等，具体取决于传递给 load_flags 参数的设置。
    % y0 J2 I/ i$ r! u5 D
13. 使用示例：
    
14. 
    ; a7 V6 H. {$ G4 h) q2 q! [% _. m
15. c
    
16. Copy code
    9 \" x) w" B, y1 Q  X$ ^: x/ x* [/ R
17. FT_Load_Char(face, 'A', FT_LOAD_RENDER);
    + X& \* o/ s. N
18. 这个示例会加载字体中字符 'A' 的字形数据，并将其渲染到位图中。FT_LOAD_RENDER 标志告诉FreeType要渲染字符的位图数据。加载后，您可以在 face->glyph 结构体中找到有关 'A' 字符的相关信息，包括位图数据、宽度、高度、位图偏移等等。
    
19. 
    % a0 `4 J4 v- S5 L( ?; ^5 r
20. 错误处理：
    
21. 
    
22. 如果加载失败，FT_Load_Char 函数可以返回错误代码。您应该检查返回值以进行错误处理，并根据需要采取适当的措施，例如跳过加载失败的字符或终止渲染过程。
    
23. 总之，FT_Load_Char 函数是FreeType库中用于加载指定字符的字形数据的重要功能之一，它使您能够准备要渲染的字符数据，以便在文本渲染中使用。加载的数据可以包括字符的轮廓信息（矢量数据）和位图信息，具体取决于 load_flags 参数的设置。这个函数在字体渲染中起到关键作用，以便将字符正确呈现在屏幕上。

复制代码

代码
" s- j0 I0 h. N  B6 {
5 o  b2 u9 K3 }* z# R

1. 
   9 V( Q$ e2 H& Z: T9 z2 z
2. 
   ) M% u* ?3 R" ^/ h
3. 
   + m' G: M1 Z% P& f1 y
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <GL/glew.h>
   * Q! q% `' z6 C, V% l) \- Y
7. #include <GLFW/glfw3.h>
   
8. #include <ft2build.h>
   ) M8 ]3 o% I5 z5 k' W2 l+ l
9. #include FT_FREETYPE_H
   
10. 
    
11. // 定义字形数据的字节数组
    % V9 i+ N, S+ d( [
12. unsigned char fontData[] = {
    + ^& y1 Q! z* K7 \) y
13.     // 字形数据的字节表示
    2 x6 A) R( R- u$ ]3 r# `5 [
14.     // 例如，这里可以包含字母、数字和符号的字形数据
    ' Y0 A7 N: r. T) |( B
15. };
    
16. 
    9 _7 s2 P; `! V8 I) [& j
17. FT_Library library;
    & ~2 y6 C, p0 z9 G  S( z) ^+ o' b
18. FT_Face face;
    
19. GLuint fontTexture;
    7 y% y6 `# T% `- w; \7 Q
20. 
    
21. // 初始化FreeType库和OpenGL
    
22. void initialize() {
    
23.     if (FT_Init_FreeType(&library)) {
    
24.         fprintf(stderr, "Failed to initialize FreeType\n");
    
25.         exit(EXIT_FAILURE);
    
26.     }
    6 v5 Y# q9 ~* v2 b- l
27. 
    
28.     if (FT_New_Memory_Face(library, fontData, sizeof(fontData), 0, &face)) {
    ; V9 k0 ?( U4 s, c$ p% d
29.         fprintf(stderr, "Failed to create a FreeType font face\n");
      {+ Z" B5 T$ D
30.         exit(EXIT_FAILURE);
    - W$ B' [8 _+ Q- {! V5 }  {( q
31.     }
    
32. 
    9 n2 ]# R* t: p% E8 N/ w
33.     if (FT_Set_Pixel_Sizes(face, 0, 48)) { // 设置字体大小
    
34.         fprintf(stderr, "Failed to set font size\n");
    
35.         exit(EXIT_FAILURE);
    0 D; [9 P6 g& ~" y: U6 O7 U+ s
36.     }
    
37. 
    
38.     glGenTextures(1, &fontTexture);
    
39.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    + q. F- j& X! u- M) y' W
40.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    / H, n; J: ]  s/ c; X' b# ~# A
41. 
    
42.     // 将字形数据传递给OpenGL纹理
    
43.     for (int i = 0; i < 128; i++) {
    
44.         if (FT_Load_Char(face, i, FT_LOAD_RENDER)) {
    : _% |7 r$ H/ `6 G
45.             fprintf(stderr, "Failed to load glyph for character '%c'\n", i);
    
46.             continue;
    
47.         }
    / u7 S& A$ d8 }( ~* I  o9 \
48. 
    
49.         glTexImage2D(
    ( M7 x2 l1 d- p1 b4 S
50.             GL_TEXTURE_2D,
    0 H7 v2 r7 d6 s
51.             0,
    
52.             GL_RED,
    " `  ]# ]2 i( Q5 ^: a
53.             face->glyph->bitmap.width,
    
54.             face->glyph->bitmap.rows,
    8 ^- [) N, l* h* J* n" z
55.             0,
    4 u7 ^, {( E8 b0 T
56.             GL_RED,
    ; D3 B: ?5 N% G0 O+ `$ u
57.             GL_UNSIGNED_BYTE,
    - d* L& l! _! V, Z. n
58.             face->glyph->bitmap.buffer
    
59.         );
    : F$ [( d: j$ X* W  [1 w" W
60. 
    
61.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
      j, j# E8 e6 X" b+ w: d3 O
62.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    3 r$ {& R0 C. {4 I8 E% M
63.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    
64.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    
65.     }
    # N: Q0 b0 H. S, f
66. }
    
67. 
    4 r/ U  Y2 T) i. u, T9 W
68. // 渲染字符串
    + H9 N9 c' y7 L% I. z
69. void renderString(const char* text, float x, float y) {
    
70.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    
71. 
    
72.     glEnable(GL_BLEND);
    # ?! f$ X9 N- y) R/ a0 b: L! K
73.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
74. 
    ' R  P2 q; }, f  B3 r1 x$ H
75.     glBegin(GL_QUADS);
    
76.     for (const char* p = text; *p; p++) {
    
77.         FT_Load_Char(face, *p, FT_LOAD_RENDER);
    
78. 
    
79.         glTexImage2D(
    2 I& V1 r/ F- a& p( N
80.             GL_TEXTURE_2D,
    
81.             0,
    9 a4 g: N- O1 b$ R  y$ q
82.             GL_RED,
    ' {- E4 v/ R. ?8 r! D4 {5 \9 E8 L
83.             face->glyph->bitmap.width,
    
84.             face->glyph->bitmap.rows,
    
85.             0,
    
86.             GL_RED,
    ; _) T; u/ m' s: i* v
87.             GL_UNSIGNED_BYTE,
    0 v* p. ~1 o$ y" g$ f5 n0 u* k
88.             face->glyph->bitmap.buffer
    + M( n( a& X# m0 l
89.         );
    5 m2 I2 u$ x' Q7 G, J
90. 
    
91.         float xpos = x + face->glyph->bitmap_left;
    & J* ?9 V. n0 v* z8 o. L
92.         float ypos = y - (face->glyph->bitmap.rows - face->glyph->bitmap_top);
    
93. 
    + h8 y0 b- D4 D7 I7 K
94.         float w = face->glyph->bitmap.width;
    
95.         float h = face->glyph->bitmap.rows;
    
96. 
    $ R: W5 S  T7 V% v- B" y
97.         glTexCoord2f(0, 0);
    # j2 M5 B7 t2 z) i
98.         glVertex2f(xpos, ypos);
    
99. 
    
100.         glTexCoord2f(0, 1);
     " Q3 m( P& F9 ^- w: M6 `1 f' K" V+ e; [
101.         glVertex2f(xpos, ypos + h);
     9 V" u4 I' w% p; N) ]
102. 
     ; ?% \; J9 d  q, }6 S
103.         glTexCoord2f(1, 1);
     
104.         glVertex2f(xpos + w, ypos + h);
     
105. 
     
106.         glTexCoord2f(1, 0);
     
107.         glVertex2f(xpos + w, ypos);
     0 I4 A+ E' D$ M
108. 
     " j$ K" F9 Q5 D3 e& L8 }
109.         x += (face->glyph->advance.x >> 6); // 字符之间的间距
     
110.     }
     0 L4 d0 {% n  }& p0 E1 }( L  i2 O
111.     glEnd();
     3 V  e3 I( z* R* }- a5 H. C
112. 
     
113.     glDisable(GL_BLEND);
     7 g( b/ N8 P! U( ^+ y* L: j4 \
114. }
     
115. 
     
116. int main() {
     
117.     if (!glfwInit()) {
     & o6 l( v/ Q+ \) W/ t
118.         fprintf(stderr, "Failed to initialize GLFW\n");
     
119.         return -1;
     
120.     }
     8 s" B  t3 A( A' [6 g
121. 
     9 S7 A2 f3 g% j. f) {. o# N% U
122.     GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL Text Rendering", NULL, NULL);
     
123.     if (!window) {
     0 y" \+ d# @; b+ p9 F, h6 ^
124.         fprintf(stderr, "Failed to create GLFW window\n");
       a5 _) J0 u7 H
125.         glfwTerminate();
     0 @% L" l* z* N" [
126.         return -1;
     
127.     }
     # @+ H+ K" p2 y
128. 
     0 z7 u0 n: }- n3 {$ n9 K3 c
129.     glfwMakeContextCurrent(window);
     
130.     glewInit();
     
131. 
     
132.     initialize();
     
133. 
     0 B) ]* E7 c" F/ \" E0 h1 M, o' K
134.     while (!glfwWindowShouldClose(window)) {
     
135.         glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     ' a+ M( e/ R  I7 Y$ `9 J
136.         glClear(GL_COLOR_BUFFER_BIT);
     
137. 
     
138.         glColor3f(1.0f, 1.0f, 1.0f);
     / G( `* I/ ~$ R6 d% t6 O  y
139.         renderString("Hello, OpenGL!", 100.0f, 100.0f);
     
140. 
     ; P8 W1 E3 w& f% I+ T
141.         glfwSwapBuffers(window);
     
142.         glfwPollEvents();
     
143.     }
     
144. 
     
145.     FT_Done_Face(face);
     $ s# v7 j9 E4 N
146.     FT_Done_FreeType(library);
     5 }) H; @* x  f1 q: [5 Q/ F
147. 
     
148.     glfwTerminate();
     1 f& f( w2 D0 X3 v
149. 
     
150.     return 0;
     2 b+ C& ^1 |& ?: T9 H! a8 }
151. }
     + U% w) _: x( c" g

复制代码

+ E! t2 Q1 X2 \! N% c' J

星之韶华

学习学习一下