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

shane007

以下是一个用来做参照的opengl显示字符串的代码，使用了freetype库。
6 G( V: j1 d/ N+ e. }本代码经过分析以及改写之后，将取代游戏原有的显示函数。

代码详细说明如下

' ^0 j5 `0 K8 w

1. 在上述 renderString 函数中，我们有以下关键部分的解释：
   
2. 
   
3. glBindTexture(GL_TEXTURE_2D, fontTexture);：将字体纹理绑定到当前的OpenGL上下文。这是因为我们要使用 fontTexture 中存储的字形位图数据进行渲染。
   
4. 
   # Z% L& j% H4 ]# n! t
5. glEnable(GL_BLEND); 和 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);：启用混合模式以处理字符的透明度。混合模式通过 glBlendFunc 设置，这里使用了常见的源和目标因子来实现源颜色与目标颜色的混合，从而实现透明效果。
   % R* }& _% W7 R' D2 L6 h
6. 
   - p* _' R$ f$ E8 [3 N/ q
7. glBegin(GL_QUADS); 和 glEnd();：在这两个函数之间的代码用于指定字符的四边形顶点，以便在OpenGL上下文中绘制字符。
   
8. 
   
9. for (const char* p = text; *p; p++) { ... }：这个循环遍历传递给函数的字符串 text 中的每个字符，然后为每个字符执行以下操作：
   : G. A  a8 l! @' G/ A( D! z
10. 
    ) V0 d4 E2 J" |( l- w4 ]8 D
11. FT_Load_Char(face, *p, FT_LOAD_RENDER);：使用FreeType加载字符的字形数据，包括轮廓和位图信息。加载后，可以从 face->glyph 中访问该字符的字形数据。
    
12. 
    * n  \* N. ~- B2 ^* `% P( {
13. 计算字符在屏幕上的位置和大小，包括 xpos（x坐标）、ypos（y坐标）、w（宽度）和 h（高度）。
    8 f/ F( R0 M+ M& Z5 V* z
14. 
    $ F8 U7 C6 U9 R3 X, J6 m
15. 使用 glTexCoord2f 和 glVertex2f 来指定字符的纹理坐标和顶点坐标，以创建一个四边形。这四边形将字形的位图数据绘制到屏幕上的指定位置。
    
16. 
    , C/ \$ p& z& g% D7 O5 b7 w7 \
17. x += (face->glyph->advance.x >> 6);：更新 x 坐标，以便将下一个字符紧密排列在当前字符的后面。face->glyph->advance.x 包含字符的横向位移信息，>> 6 是用来将其转换为像素单位的操作。
    & K0 Z/ w* ^* r2 Q
18. 
    . x3 u1 X& R2 H  o2 I
19. 最后，glDisable(GL_BLEND); 用于禁用混合模式，以免影响后续的绘制操作。
    * U7 ]/ z8 ?1 O7 x  A1 \' L
20. 
    
21. 总之，renderString 函数的作用是将传递给它的字符串中的字符一个接一个地绘制到OpenGL上下文中，使用FreeType加载的字形数据和字体纹理来实现文本渲染效果。渲染过程涉及到字符的位置计算、纹理坐标的设置以及混合模式的启用和禁用，以确保字符在屏幕上正确显示。
    

复制代码

1. 字形数据处理的关键函数之一。以下是 FT_Load_Char 函数的详细解释：
   
2. 
   ' i/ f; m" g) P& ]; y8 _
3. 参数：
   * d+ w8 \) W  p( T. U1 n+ ~
4. 
   - U- v5 ?! z+ z% s
5. face：一个指向已经打开的字体文件的 FT_Face 结构体的指针。FT_Face 包含了字体的各种信息，包括字形数据。
   + L7 p! v/ `  S- O2 B* |$ R  U6 L
6. char_code：要加载的字符的Unicode编码值。您需要传递字符的Unicode编码作为此参数，以指定要加载的字符。
   + N" y( ^* t% N3 ~  r' h: Z4 k
7. load_flags：一个用于控制字形加载选项的标志位。您可以使用这些标志位来控制加载的方式，例如是否要加载字形的轮廓数据、是否要加载字形的位图数据等。
   
8. 功能：
   
9. 
   
10. FT_Load_Char 函数的主要功能是加载指定字符的字形数据。
    7 D/ D8 w" R# r* d" v. M
11. 如果成功，它将在 FT_Face 结构体中的 glyph 字段中填充有关字符的字形信息。
    : d4 S5 D; P3 X" ~3 i4 [$ _
12. 这包括了字符的轮廓数据、位图数据、宽度、高度、位图偏移等等，具体取决于传递给 load_flags 参数的设置。
    
13. 使用示例：
    
14. 
    
15. c
    + `' l2 c+ J8 i8 ^# q4 I7 K
16. Copy code
    
17. FT_Load_Char(face, 'A', FT_LOAD_RENDER);
    
18. 这个示例会加载字体中字符 'A' 的字形数据，并将其渲染到位图中。FT_LOAD_RENDER 标志告诉FreeType要渲染字符的位图数据。加载后，您可以在 face->glyph 结构体中找到有关 'A' 字符的相关信息，包括位图数据、宽度、高度、位图偏移等等。
    / M5 \) e  d4 l
19. 
    
20. 错误处理：
    ) x2 P1 ?' {- _4 d5 @3 b/ j  n& u
21. 
    1 A- Z  b6 q3 J
22. 如果加载失败，FT_Load_Char 函数可以返回错误代码。您应该检查返回值以进行错误处理，并根据需要采取适当的措施，例如跳过加载失败的字符或终止渲染过程。
    
23. 总之，FT_Load_Char 函数是FreeType库中用于加载指定字符的字形数据的重要功能之一，它使您能够准备要渲染的字符数据，以便在文本渲染中使用。加载的数据可以包括字符的轮廓信息（矢量数据）和位图信息，具体取决于 load_flags 参数的设置。这个函数在字体渲染中起到关键作用，以便将字符正确呈现在屏幕上。

复制代码

. h& L" P& D) ]8 i/ N& _& Q) F( r- Y$ _代码
6 c( ?4 q. [0 [$ _/ Q( J

1. 
   0 ~8 i4 H5 m% H" }; t% _/ J$ ?
2. 
   
3. 
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <GL/glew.h>
   
7. #include <GLFW/glfw3.h>
   ) o) ^, b$ H+ W3 _
8. #include <ft2build.h>
   
9. #include FT_FREETYPE_H
   & A2 X9 h3 h0 H, m: j- C- C
10. 
    - @# h* y; q' P4 A
11. // 定义字形数据的字节数组
    & \$ w$ `3 ~: x- h2 r! H
12. unsigned char fontData[] = {
    ) |! W2 S5 ~& f9 L. J
13.     // 字形数据的字节表示
    
14.     // 例如，这里可以包含字母、数字和符号的字形数据
    * {. j/ C6 G6 E2 m8 v6 ^
15. };
    - n! F/ j; S2 ?1 F+ e& E% i
16. 
    
17. FT_Library library;
    : ]( R, |+ N: q$ a) ^
18. FT_Face face;
    ' n. [$ u5 c9 P( O; J- q+ W
19. GLuint fontTexture;
    
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);
    ( l: E5 o# _  S9 n# B! y" M1 N
26.     }
    + i& c7 ]" y7 h/ J& H! U- _/ a% |
27. 
    
28.     if (FT_New_Memory_Face(library, fontData, sizeof(fontData), 0, &face)) {
    
29.         fprintf(stderr, "Failed to create a FreeType font face\n");
    9 O1 O9 u4 g3 {. w/ d/ o9 F
30.         exit(EXIT_FAILURE);
    ' w/ U% i) D+ v$ I
31.     }
    
32. 
    
33.     if (FT_Set_Pixel_Sizes(face, 0, 48)) { // 设置字体大小
    
34.         fprintf(stderr, "Failed to set font size\n");
    
35.         exit(EXIT_FAILURE);
    ' @/ z8 {# m9 n# ~8 ^7 Q4 R
36.     }
    
37. 
    $ R- r# j9 Y$ F) D
38.     glGenTextures(1, &fontTexture);
    
39.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    
40.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    4 H1 h# ?6 F# I- \- H
41. 
    ) A8 h2 K  |0 c
42.     // 将字形数据传递给OpenGL纹理
    # d5 |/ P6 o, O
43.     for (int i = 0; i < 128; i++) {
      S8 t$ |+ Y+ ^- R
44.         if (FT_Load_Char(face, i, FT_LOAD_RENDER)) {
    
45.             fprintf(stderr, "Failed to load glyph for character '%c'\n", i);
    
46.             continue;
    # l( E5 f) e1 U( Y7 s
47.         }
    
48. 
    
49.         glTexImage2D(
    
50.             GL_TEXTURE_2D,
    
51.             0,
    1 i* u/ l! k; A! w0 w: X5 M, B
52.             GL_RED,
    & a" m4 s8 O! X5 p
53.             face->glyph->bitmap.width,
    + H/ R0 |  L: @/ B* E' g0 d  H* ~
54.             face->glyph->bitmap.rows,
    * m/ f. o1 m/ @# Y8 e
55.             0,
    
56.             GL_RED,
    * g( n" U3 ]; `% e. Q
57.             GL_UNSIGNED_BYTE,
    
58.             face->glyph->bitmap.buffer
    
59.         );
    
60. 
    $ F$ c/ G, o8 f, X! j
61.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    % q! ^6 n4 M) A( n* Q4 C
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);
    
65.     }
    
66. }
    
67. 
    ( b, ~3 x5 O: |5 X* q! X* S# m0 ?
68. // 渲染字符串
    ( b( B; R7 U' k- L+ X- i
69. void renderString(const char* text, float x, float y) {
    3 c7 Q6 l7 r* O% v8 O
70.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    ' K; e8 I& ^4 A! C9 `( t
71. 
    # P: _+ E$ U3 i" R* X0 s
72.     glEnable(GL_BLEND);
    , C  b6 t4 i8 x; W" i) o
73.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    ! n) a( o% _6 ]/ y9 E
74. 
    
75.     glBegin(GL_QUADS);
    
76.     for (const char* p = text; *p; p++) {
    
77.         FT_Load_Char(face, *p, FT_LOAD_RENDER);
    4 n# Q2 C; x0 L; H1 |2 D$ R$ n
78. 
    & U) r+ c/ P  n+ x# K" i; r
79.         glTexImage2D(
    * _, k$ W& v9 R& l6 g) b; `! W
80.             GL_TEXTURE_2D,
    
81.             0,
    : J& v8 [$ c, c& ^. y  m3 `$ X
82.             GL_RED,
    
83.             face->glyph->bitmap.width,
    
84.             face->glyph->bitmap.rows,
    
85.             0,
    , \% [0 d: z3 ~4 s) n
86.             GL_RED,
    & |" X, |- m8 t. W+ d; ]( e3 n
87.             GL_UNSIGNED_BYTE,
    
88.             face->glyph->bitmap.buffer
    ; U/ `9 f  T6 j" o2 o
89.         );
    
90. 
    ( Q2 V3 S& {* h% h' g
91.         float xpos = x + face->glyph->bitmap_left;
    ! ^. e' q0 W; K9 d4 {! y9 D
92.         float ypos = y - (face->glyph->bitmap.rows - face->glyph->bitmap_top);
    & W7 r1 u! K" ]8 s
93. 
    
94.         float w = face->glyph->bitmap.width;
    
95.         float h = face->glyph->bitmap.rows;
    
96. 
    6 b+ K; O4 q, H6 R9 l  S
97.         glTexCoord2f(0, 0);
    9 Y3 `1 k5 U! {
98.         glVertex2f(xpos, ypos);
    
99. 
    
100.         glTexCoord2f(0, 1);
     
101.         glVertex2f(xpos, ypos + h);
     
102. 
     
103.         glTexCoord2f(1, 1);
     " y5 L. x' g5 J5 z( T& n+ T+ \: x
104.         glVertex2f(xpos + w, ypos + h);
     " X2 ~* m  G& S
105. 
     
106.         glTexCoord2f(1, 0);
     ; L1 Z  Y' O7 ]+ K6 C  o
107.         glVertex2f(xpos + w, ypos);
     
108. 
     ' R9 I. d2 I1 s, v$ v
109.         x += (face->glyph->advance.x >> 6); // 字符之间的间距
     - L  S$ e* E* a, L% s! w" y
110.     }
     ' M8 C  q+ |: Z4 ?. l5 u( I
111.     glEnd();
     ' O6 p) w- x) o9 s2 R
112. 
     7 F: l3 F( ^: \  y- A
113.     glDisable(GL_BLEND);
     ; x. t: q; p! i1 V1 @
114. }
     
115. 
     
116. int main() {
     * w* E7 C$ L- x. Z
117.     if (!glfwInit()) {
     ! g3 E9 t; C" P
118.         fprintf(stderr, "Failed to initialize GLFW\n");
     7 v  t- k- g8 H3 K0 }& x
119.         return -1;
     - C- T- A; _9 W$ O& g8 f/ r# w& K
120.     }
     $ f. \! [( ^5 N! a
121. 
     
122.     GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL Text Rendering", NULL, NULL);
     4 r. K2 p" A7 t
123.     if (!window) {
     
124.         fprintf(stderr, "Failed to create GLFW window\n");
     
125.         glfwTerminate();
     
126.         return -1;
     
127.     }
     . @% x* |6 B0 E' U; s: m! [
128. 
     
129.     glfwMakeContextCurrent(window);
     
130.     glewInit();
     . T% d& p! y' `! l
131. 
     ' e9 m7 n9 a2 }: q0 x
132.     initialize();
     
133. 
     / x! h7 x/ |% @: c+ j: l# `
134.     while (!glfwWindowShouldClose(window)) {
     / ^) ~  B) \' k8 d. e: h; V1 G* S1 }
135.         glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     , W/ W. Q3 i: D8 {( w
136.         glClear(GL_COLOR_BUFFER_BIT);
     
137. 
     , G& g  l$ A$ |6 |, m
138.         glColor3f(1.0f, 1.0f, 1.0f);
     
139.         renderString("Hello, OpenGL!", 100.0f, 100.0f);
     : U! i! M& H7 k
140. 
     
141.         glfwSwapBuffers(window);
     
142.         glfwPollEvents();
     7 `0 d" G% M5 s: w! l: c" L& r
143.     }
     
144. 
     5 i# y' ]5 E7 o. D/ M$ y0 W+ ]7 P
145.     FT_Done_Face(face);
     
146.     FT_Done_FreeType(library);
     
147. 
     
148.     glfwTerminate();
     7 [0 e; K+ X5 k% y6 |2 C/ }' b; _/ c
149. 
     
150.     return 0;
     
151. }
     

复制代码

/ T) p9 w! b6 k8 |* a