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

shane007

1 [) Y) o3 z5 z# j  j
8 Q9 u! r7 e2 G# l3 m2 q0 M& e以下是一个用来做参照的opengl显示字符串的代码，使用了freetype库。
本代码经过分析以及改写之后，将取代游戏原有的显示函数。
: N; @/ |$ @- S9 t: z3 j
- ], s: z  ~$ A2 u7 V, a5 C/ V代码详细说明如下
  G. K7 b% g5 j/ `  w+ i! E
$ k; M8 B# H  R. |0 g

1. 在上述 renderString 函数中，我们有以下关键部分的解释：
   , F* Y* T. \  |& D5 Q1 Q/ k$ E. \
2. 
   
3. glBindTexture(GL_TEXTURE_2D, fontTexture);：将字体纹理绑定到当前的OpenGL上下文。这是因为我们要使用 fontTexture 中存储的字形位图数据进行渲染。
   2 v" L: g5 z% _) d: |
4. 
   
5. glEnable(GL_BLEND); 和 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);：启用混合模式以处理字符的透明度。混合模式通过 glBlendFunc 设置，这里使用了常见的源和目标因子来实现源颜色与目标颜色的混合，从而实现透明效果。
   
6. 
   
7. glBegin(GL_QUADS); 和 glEnd();：在这两个函数之间的代码用于指定字符的四边形顶点，以便在OpenGL上下文中绘制字符。
   
8. 
     M9 h% N9 c3 S' _2 g4 |5 B
9. for (const char* p = text; *p; p++) { ... }：这个循环遍历传递给函数的字符串 text 中的每个字符，然后为每个字符执行以下操作：
   . J) H7 E: B9 v( V% {
10. 
    
11. FT_Load_Char(face, *p, FT_LOAD_RENDER);：使用FreeType加载字符的字形数据，包括轮廓和位图信息。加载后，可以从 face->glyph 中访问该字符的字形数据。
    3 V2 _1 H8 B4 z  F
12. 
    
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 是用来将其转换为像素单位的操作。
    
18. 
    
19. 最后，glDisable(GL_BLEND); 用于禁用混合模式，以免影响后续的绘制操作。
    
20. 
    & s) X2 L* C* \: L% G+ r
21. 总之，renderString 函数的作用是将传递给它的字符串中的字符一个接一个地绘制到OpenGL上下文中，使用FreeType加载的字形数据和字体纹理来实现文本渲染效果。渲染过程涉及到字符的位置计算、纹理坐标的设置以及混合模式的启用和禁用，以确保字符在屏幕上正确显示。
    ( G3 B' |. D2 o3 q, T

复制代码

3 @& W8 f( ^  W! H: O5 }

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

复制代码

7 m+ M& L5 N$ M/ S( E
代码
" Z1 _- q& T0 y) S# D

1. 
   
2. 
   ' i( F* K3 ^4 h
3. 
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   7 O3 l" v. Z3 d/ K4 R, A9 X
6. #include <GL/glew.h>
   
7. #include <GLFW/glfw3.h>
   8 A+ l9 X6 N$ u  c" s
8. #include <ft2build.h>
   * E- H7 j* I. |, ?
9. #include FT_FREETYPE_H
   3 \$ X, F+ k# V; y3 m
10. 
    
11. // 定义字形数据的字节数组
    . ?8 e9 S6 F: |; Z' E$ @
12. unsigned char fontData[] = {
    1 R: {0 P1 e0 Q( s* F3 y  T: a
13.     // 字形数据的字节表示
    % B4 a( N2 C: j! _
14.     // 例如，这里可以包含字母、数字和符号的字形数据
      X' c- ~( C/ T8 a4 L- D
15. };
    ( h" I9 |/ @! R; U3 s) f4 Q& {
16. 
    
17. FT_Library library;
    
18. FT_Face face;
    : Q" o$ `$ K9 a& _% D+ v
19. GLuint fontTexture;
      n/ j% {: C; Z/ |0 b
20. 
    & f0 Y: E; K$ V6 R9 P4 N3 @6 R  P3 r
21. // 初始化FreeType库和OpenGL
    ) N3 U3 N' k; G) [+ B+ R
22. void initialize() {
    
23.     if (FT_Init_FreeType(&library)) {
    
24.         fprintf(stderr, "Failed to initialize FreeType\n");
    
25.         exit(EXIT_FAILURE);
    & T4 C5 [8 u, n5 Z" s; @
26.     }
      O8 k& C- J" I+ p+ u, a0 k; r! u' y
27. 
    
28.     if (FT_New_Memory_Face(library, fontData, sizeof(fontData), 0, &face)) {
    
29.         fprintf(stderr, "Failed to create a FreeType font face\n");
    
30.         exit(EXIT_FAILURE);
    
31.     }
    7 {1 E8 ~9 `: ]8 L* q
32. 
    ( U$ S; A( Q6 r) k) M
33.     if (FT_Set_Pixel_Sizes(face, 0, 48)) { // 设置字体大小
    ( j& ]. }0 ~- Y, Z/ {
34.         fprintf(stderr, "Failed to set font size\n");
    
35.         exit(EXIT_FAILURE);
    
36.     }
    / n# M0 o' x8 U3 x
37. 
    
38.     glGenTextures(1, &fontTexture);
    # H3 [; I& E& n7 p5 J! l1 w* Q6 i% s
39.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    % a" Z! q( h# B3 L
40.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    , U$ d" [6 C% O9 E) E
41. 
    6 ^* W( Z/ [0 F) B; T
42.     // 将字形数据传递给OpenGL纹理
    9 n4 T# t2 o& L- M2 L  Z7 @. X* ?
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);
    1 e3 T7 w% W" M; r6 L
46.             continue;
    7 K* ~  a# d- b/ X
47.         }
    : h3 p5 @, t$ p
48. 
    
49.         glTexImage2D(
    
50.             GL_TEXTURE_2D,
    
51.             0,
    
52.             GL_RED,
    ' S" u. u% [; v5 |
53.             face->glyph->bitmap.width,
    
54.             face->glyph->bitmap.rows,
    
55.             0,
    9 w$ t! C+ J; z7 p4 f, @
56.             GL_RED,
    ; U* j$ x0 ~, {5 |$ ], I4 z. e
57.             GL_UNSIGNED_BYTE,
    % R! e7 P/ M' M0 f7 o3 ?
58.             face->glyph->bitmap.buffer
    + A+ [9 L+ q/ d
59.         );
    9 X/ E. h/ l7 p8 q( ]2 ?
60. 
    
61.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    ! k! m" l) e9 C* n1 R7 c- m
62.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    . M+ [/ B- b+ `. x
63.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    
64.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    - z/ C* w5 ?+ f  S1 d6 O* m
65.     }
    6 X9 W1 x0 N# q  \- V5 S$ c! q
66. }
    8 S- K# N* v6 u) Q" Q8 q
67. 
    + P3 L8 e( [0 k
68. // 渲染字符串
    3 U- \5 W- z2 f0 K9 c/ T; o- \- b
69. void renderString(const char* text, float x, float y) {
    % V' h6 n$ ~7 Y* ~1 C, b) D: O
70.     glBindTexture(GL_TEXTURE_2D, fontTexture);
    
71. 
    
72.     glEnable(GL_BLEND);
    ( m/ I6 M4 P% I/ ~' `1 Z* S
73.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
74. 
    
75.     glBegin(GL_QUADS);
    
76.     for (const char* p = text; *p; p++) {
    5 `1 [- {6 ]2 D
77.         FT_Load_Char(face, *p, FT_LOAD_RENDER);
    
78. 
    
79.         glTexImage2D(
    # ]: B+ ^: V& h( i& [) H) _! U
80.             GL_TEXTURE_2D,
    
81.             0,
    6 x" |+ }# O, A9 R# f8 F
82.             GL_RED,
    / @- J: H5 b( d) K# y- |
83.             face->glyph->bitmap.width,
    ( M; b2 y9 L! s1 T
84.             face->glyph->bitmap.rows,
    , A: D& l4 q9 K2 r2 ~6 `
85.             0,
    8 D3 g  G$ s) M, _$ ~7 c
86.             GL_RED,
    $ C; d; z& ~5 z
87.             GL_UNSIGNED_BYTE,
    : d0 D; o0 |: R( X# p4 M
88.             face->glyph->bitmap.buffer
    $ O" Q3 E4 w, M
89.         );
    
90. 
    1 c7 Z: p2 p2 l! G
91.         float xpos = x + face->glyph->bitmap_left;
    / q; @3 `  w; K/ G- m; M0 Y+ y2 p
92.         float ypos = y - (face->glyph->bitmap.rows - face->glyph->bitmap_top);
    ) B9 U4 N7 D7 Y5 l
93. 
    
94.         float w = face->glyph->bitmap.width;
    
95.         float h = face->glyph->bitmap.rows;
    . C+ S6 K4 G" |& O( I' Q4 r' e
96. 
    
97.         glTexCoord2f(0, 0);
    
98.         glVertex2f(xpos, ypos);
    % u4 F5 e* T2 m) ~5 V
99. 
    
100.         glTexCoord2f(0, 1);
     
101.         glVertex2f(xpos, ypos + h);
     
102. 
     
103.         glTexCoord2f(1, 1);
     
104.         glVertex2f(xpos + w, ypos + h);
     
105. 
     + S+ k( X5 _6 M+ H% d' P- v
106.         glTexCoord2f(1, 0);
     1 Q& E  c3 r# a! @2 A! d
107.         glVertex2f(xpos + w, ypos);
     
108. 
     4 o2 X5 T  i5 g/ j* \
109.         x += (face->glyph->advance.x >> 6); // 字符之间的间距
     * P+ r, j  {! T8 k
110.     }
     / {7 i" Q+ i: c4 t
111.     glEnd();
     
112. 
     3 U( W9 X2 l7 Z  \2 H
113.     glDisable(GL_BLEND);
     : |  l+ M7 n) q" U
114. }
       r. R6 e7 z. s% O8 A* K4 ]
115. 
     
116. int main() {
     * d0 w  ?: K$ z9 e" D. M
117.     if (!glfwInit()) {
     
118.         fprintf(stderr, "Failed to initialize GLFW\n");
     . b4 |# x' k4 a$ k$ `+ E+ x
119.         return -1;
     1 J/ t" b/ R/ t- a9 l
120.     }
     
121. 
     / b; \) G% S7 p0 n# }
122.     GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL Text Rendering", NULL, NULL);
     
123.     if (!window) {
     
124.         fprintf(stderr, "Failed to create GLFW window\n");
     ( L+ M$ k- N, E6 Z# {, x
125.         glfwTerminate();
     ) A2 z# h6 y% p2 n
126.         return -1;
     5 B# _" Y5 l# K" v, ~
127.     }
     
128. 
     
129.     glfwMakeContextCurrent(window);
     / E/ B/ {4 }! a* F
130.     glewInit();
     
131. 
     * ]0 M( k% N' A, G
132.     initialize();
     1 s1 _( }( g0 T  v7 I
133. 
     : h/ f2 Z& ~8 n/ M/ |
134.     while (!glfwWindowShouldClose(window)) {
     . U" h. F3 u2 k4 y& s$ m
135.         glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     
136.         glClear(GL_COLOR_BUFFER_BIT);
     
137. 
     % a. N# ]7 N* T( O" E& x
138.         glColor3f(1.0f, 1.0f, 1.0f);
     + D# Z" }0 |9 w; o" P6 w$ D
139.         renderString("Hello, OpenGL!", 100.0f, 100.0f);
       N9 g9 n! O# r; L0 F8 f+ \
140. 
     4 L; W0 l1 U* u+ U# b0 L! h
141.         glfwSwapBuffers(window);
     
142.         glfwPollEvents();
     6 O/ d; X, p1 n& i; A5 E; D
143.     }
     
144. 
     
145.     FT_Done_Face(face);
     
146.     FT_Done_FreeType(library);
       U/ M: @  i" w  a9 R" _% L
147. 
     
148.     glfwTerminate();
     $ m1 F5 V" F2 I$ N! J* j6 y9 l
149. 
       W& i; v/ ^" M& E+ h9 K
150.     return 0;
     
151. }
     

复制代码

& u) H6 k0 N; x& D# J