Debian Codegraph @

gl_draw.c

raw ◀ ▶
Source reconstructed at patch state 0 of 1 — not the installed (fully patched) source.
1 Debian patch touch this file
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18
19 */
20
21 #include "quakedef.h"
22 #include "image.h"
23 #include "wad.h"
24
25 #include "cl_video.h"
26
27 #include "ft2.h"
28 #include "ft2_fontdefs.h"
29
30 struct cachepic_s
31 {
32 // size of pic
33 int width, height;
34 // this flag indicates that it should be loaded and unloaded on demand
35 int autoload;
36 // texture flags to upload with
37 int texflags;
38 // texture may be freed after a while
39 int lastusedframe;
40 // renderable texture
41 skinframe_t *skinframe;
42 // used for hash lookups
43 struct cachepic_s *chain;
44 // flags - CACHEPICFLAG_NEWPIC for example
45 unsigned int flags;
46 // name of pic
47 char name[MAX_QPATH];
48 };
49
50 dp_fonts_t dp_fonts;
51 static mempool_t *fonts_mempool = NULL;
52
53 cvar_t r_textshadow = {CVAR_SAVE, "r_textshadow", "0", "draws a shadow on all text to improve readability (note: value controls offset, 1 = 1 pixel, 1.5 = 1.5 pixels, etc)"};
54 cvar_t r_textbrightness = {CVAR_SAVE, "r_textbrightness", "0", "additional brightness for text color codes (0 keeps colors as is, 1 makes them all white)"};
55 cvar_t r_textcontrast = {CVAR_SAVE, "r_textcontrast", "1", "additional contrast for text color codes (1 keeps colors as is, 0 makes them all black)"};
56
57 cvar_t r_font_postprocess_blur = {CVAR_SAVE, "r_font_postprocess_blur", "0", "font blur amount"};
58 cvar_t r_font_postprocess_outline = {CVAR_SAVE, "r_font_postprocess_outline", "0", "font outline amount"};
59 cvar_t r_font_postprocess_shadow_x = {CVAR_SAVE, "r_font_postprocess_shadow_x", "0", "font shadow X shift amount, applied during outlining"};
60 cvar_t r_font_postprocess_shadow_y = {CVAR_SAVE, "r_font_postprocess_shadow_y", "0", "font shadow Y shift amount, applied during outlining"};
61 cvar_t r_font_postprocess_shadow_z = {CVAR_SAVE, "r_font_postprocess_shadow_z", "0", "font shadow Z shift amount, applied during blurring"};
62 cvar_t r_font_hinting = {CVAR_SAVE, "r_font_hinting", "3", "0 = no hinting, 1 = light autohinting, 2 = full autohinting, 3 = full hinting"};
63 cvar_t r_font_antialias = {CVAR_SAVE, "r_font_antialias", "1", "0 = monochrome, 1 = grey" /* , 2 = rgb, 3 = bgr" */};
64 cvar_t r_nearest_2d = {CVAR_SAVE, "r_nearest_2d", "0", "use nearest filtering on all 2d textures (including conchars)"};
65 cvar_t r_nearest_conchars = {CVAR_SAVE, "r_nearest_conchars", "0", "use nearest filtering on conchars texture"};
66
67 //=============================================================================
68 /* Support Routines */
69
70 static cachepic_t *cachepichash[CACHEPICHASHSIZE];
71 static cachepic_t cachepics[MAX_CACHED_PICS];
72 static int numcachepics;
73
74 rtexturepool_t *drawtexturepool;
75
76 int draw_frame = 1;
77
78 /*
79 ================
80 Draw_CachePic
81 ================
82 */
83 // FIXME: move this to client somehow
84 cachepic_t *Draw_CachePic_Flags(const char *path, unsigned int cachepicflags)
85 {
86 int crc, hashkey;
87 cachepic_t *pic;
88 int texflags;
89
90 texflags = TEXF_ALPHA;
91 if (!(cachepicflags & CACHEPICFLAG_NOCLAMP))
92 texflags |= TEXF_CLAMP;
93 if (cachepicflags & CACHEPICFLAG_MIPMAP)
94 texflags |= TEXF_MIPMAP;
95 if (!(cachepicflags & CACHEPICFLAG_NOCOMPRESSION) && gl_texturecompression_2d.integer && gl_texturecompression.integer)
96 texflags |= TEXF_COMPRESS;
97 if ((cachepicflags & CACHEPICFLAG_NEAREST) || r_nearest_2d.integer)
98 texflags |= TEXF_FORCENEAREST;
99
100 // check whether the picture has already been cached
101 crc = CRC_Block((unsigned char *)path, strlen(path));
102 hashkey = ((crc >> 8) ^ crc) % CACHEPICHASHSIZE;
103 for (pic = cachepichash[hashkey];pic;pic = pic->chain)
104 {
105 if (!strcmp(path, pic->name))
106 {
107 // if it was created (or replaced) by Draw_NewPic, just return it
108 if (!(pic->flags & CACHEPICFLAG_NEWPIC))
109 {
110 // reload the pic if texflags changed in important ways
111 // ignore TEXF_COMPRESS when comparing, because fallback pics remove the flag, and ignore TEXF_MIPMAP because QC specifies that
112 if ((pic->texflags ^ texflags) & ~(TEXF_COMPRESS | TEXF_MIPMAP))
113 {
114 Con_DPrintf("Draw_CachePic(\"%s\"): frame %i: reloading pic due to mismatch on flags\n", path, draw_frame);
115 goto reload;
116 }
117 if (!pic->skinframe || !pic->skinframe->base)
118 {
119 if (pic->flags & CACHEPICFLAG_FAILONMISSING)
120 return NULL;
121 Con_DPrintf("Draw_CachePic(\"%s\"): frame %i: reloading pic\n", path, draw_frame);
122 goto reload;
123 }
124 if (!(cachepicflags & CACHEPICFLAG_NOTPERSISTENT))
125 pic->autoload = false; // caller is making this pic persistent
126 }
127 if (pic->skinframe)
128 R_SkinFrame_MarkUsed(pic->skinframe);
129 pic->lastusedframe = draw_frame;
130 return pic;
131 }
132 }
133
134 if (numcachepics == MAX_CACHED_PICS)
135 {
136 Con_Printf ("Draw_CachePic(\"%s\"): frame %i: numcachepics == MAX_CACHED_PICS\n", path, draw_frame);
137 // FIXME: support NULL in callers?
138 return cachepics; // return the first one
139 }
140 Con_DPrintf("Draw_CachePic(\"%s\"): frame %i: loading pic%s\n", path, draw_frame, (cachepicflags & CACHEPICFLAG_NOTPERSISTENT) ? " notpersist" : "");
141 pic = cachepics + (numcachepics++);
142 memset(pic, 0, sizeof(*pic));
143 strlcpy (pic->name, path, sizeof(pic->name));
144 // link into list
145 pic->chain = cachepichash[hashkey];
146 cachepichash[hashkey] = pic;
147
148 reload:
149 if (pic->skinframe)
150 R_SkinFrame_PurgeSkinFrame(pic->skinframe);
151
152 pic->flags = cachepicflags;
153 pic->texflags = texflags;
154 pic->autoload = (cachepicflags & CACHEPICFLAG_NOTPERSISTENT) != 0;
155 pic->lastusedframe = draw_frame;
156
157 if (pic->skinframe)
158 {
159 // reload image after it was unloaded or texflags changed significantly
160 R_SkinFrame_LoadExternal_SkinFrame(pic->skinframe, pic->name, texflags | TEXF_FORCE_RELOAD, (cachepicflags & CACHEPICFLAG_QUIET) == 0, (cachepicflags & CACHEPICFLAG_FAILONMISSING) == 0);
161 }
162 else
163 {
164 // load high quality image (this falls back to low quality too)
165 pic->skinframe = R_SkinFrame_LoadExternal(pic->name, texflags | TEXF_FORCE_RELOAD, (cachepicflags & CACHEPICFLAG_QUIET) == 0, (cachepicflags & CACHEPICFLAG_FAILONMISSING) == 0);
166 }
167
168 // get the dimensions of the image we loaded (if it was successful)
169 if (pic->skinframe && pic->skinframe->base)
170 {
171 pic->width = R_TextureWidth(pic->skinframe->base);
172 pic->height = R_TextureHeight(pic->skinframe->base);
173 }
174
175 // check for a low quality version of the pic and use its size if possible, to match the stock hud
176 Image_GetStockPicSize(pic->name, &pic->width, &pic->height);
177
178 return pic;
179 }
180
181 cachepic_t *Draw_CachePic (const char *path)
182 {
183 return Draw_CachePic_Flags (path, 0); // default to persistent!
184 }
185
186 const char *Draw_GetPicName(cachepic_t *pic)
187 {
188 if (pic == NULL)
189 return "";
190 return pic->name;
191 }
192
193 int Draw_GetPicWidth(cachepic_t *pic)
194 {
195 if (pic == NULL)
196 return 0;
197 return pic->width;
198 }
199
200 int Draw_GetPicHeight(cachepic_t *pic)
201 {
202 if (pic == NULL)
203 return 0;
204 return pic->height;
205 }
206
207 qboolean Draw_IsPicLoaded(cachepic_t *pic)
208 {
209 if (pic == NULL)
210 return false;
211 if (pic->autoload && (!pic->skinframe || !pic->skinframe->base))
212 {
213 Con_DPrintf("Draw_IsPicLoaded(\"%s\"): Loading external skin\n", pic->name);
214 pic->skinframe = R_SkinFrame_LoadExternal(pic->name, pic->texflags | TEXF_FORCE_RELOAD, false, true);
215 }
216 // skinframe will only be NULL if the pic was created with CACHEPICFLAG_FAILONMISSING and not found
217 return pic->skinframe != NULL && pic->skinframe->base != NULL;
218 }
219
220 rtexture_t *Draw_GetPicTexture(cachepic_t *pic)
221 {
222 if (pic == NULL)
223 return NULL;
224 if (pic->autoload && (!pic->skinframe || !pic->skinframe->base))
225 {
226 Con_DPrintf("Draw_GetPicTexture(\"%s\"): Loading external skin\n", pic->name);
227 pic->skinframe = R_SkinFrame_LoadExternal(pic->name, pic->texflags | TEXF_FORCE_RELOAD, false, true);
228 }
229 pic->lastusedframe = draw_frame;
230 return pic->skinframe ? pic->skinframe->base : NULL;
231 }
232
233 void Draw_Frame(void)
234 {
235 int i;
236 cachepic_t *pic;
237 static double nextpurgetime;
238 if (nextpurgetime > realtime)
239 return;
240 nextpurgetime = realtime + 0.05;
241 for (i = 0, pic = cachepics;i < numcachepics;i++, pic++)
242 {
243 if (pic->autoload && pic->skinframe && pic->skinframe->base && pic->lastusedframe < draw_frame - 3)
244 {
245 Con_DPrintf("Draw_Frame(%i): Unloading \"%s\"\n", draw_frame, pic->name);
246 R_SkinFrame_PurgeSkinFrame(pic->skinframe);
247 }
248 }
249 draw_frame++;
250 }
251
252 cachepic_t *Draw_NewPic(const char *picname, int width, int height, unsigned char *pixels_bgra, textype_t textype, int texflags)
253 {
254 int crc, hashkey;
255 cachepic_t *pic;
256
257 crc = CRC_Block((unsigned char *)picname, strlen(picname));
258 hashkey = ((crc >> 8) ^ crc) % CACHEPICHASHSIZE;
259 for (pic = cachepichash[hashkey];pic;pic = pic->chain)
260 if (!strcmp (picname, pic->name))
261 break;
262
263 if (pic)
264 {
265 if (pic->flags & CACHEPICFLAG_NEWPIC && pic->skinframe && pic->skinframe->base && pic->width == width && pic->height == height)
266 {
267 Con_DPrintf("Draw_NewPic(\"%s\"): frame %i: updating texture\n", picname, draw_frame);
268 R_UpdateTexture(pic->skinframe->base, pixels_bgra, 0, 0, 0, width, height, 1);
269 R_SkinFrame_MarkUsed(pic->skinframe);
270 pic->lastusedframe = draw_frame;
271 return pic;
272 }
273 Con_Printf("Draw_NewPic(\"%s\"): frame %i: reloading pic because flags/size changed\n", picname, draw_frame);
274 }
275 else
276 {
277 if (numcachepics == MAX_CACHED_PICS)
278 {
279 Con_Printf ("Draw_NewPic(\"%s\"): frame %i: numcachepics == MAX_CACHED_PICS\n", picname, draw_frame);
280 // FIXME: support NULL in callers?
281 return cachepics; // return the first one
282 }
283 Con_Printf("Draw_NewPic(\"%s\"): frame %i: creating new cachepic\n", picname, draw_frame);
284 pic = cachepics + (numcachepics++);
285 memset(pic, 0, sizeof(*pic));
286 strlcpy (pic->name, picname, sizeof(pic->name));
287 // link into list
288 pic->chain = cachepichash[hashkey];
289 cachepichash[hashkey] = pic;
290 }
291
292 R_SkinFrame_PurgeSkinFrame(pic->skinframe);
293
294 pic->autoload = false;
295 pic->flags = CACHEPICFLAG_NEWPIC; // disable texflags checks in Draw_CachePic
296 pic->flags |= (texflags & TEXF_CLAMP) ? 0 : CACHEPICFLAG_NOCLAMP;
297 pic->flags |= (texflags & TEXF_FORCENEAREST) ? CACHEPICFLAG_NEAREST : 0;
298 pic->width = width;
299 pic->height = height;
300 pic->skinframe = R_SkinFrame_LoadInternalBGRA(picname, texflags | TEXF_FORCE_RELOAD, pixels_bgra, width, height, 0, 0, 0, vid.sRGB2D);
301 pic->lastusedframe = draw_frame;
302 return pic;
303 }
304
305 void Draw_FreePic(const char *picname)
306 {
307 int crc;
308 int hashkey;
309 cachepic_t *pic;
310 // this doesn't really free the pic, but does free its texture
311 crc = CRC_Block((unsigned char *)picname, strlen(picname));
312 hashkey = ((crc >> 8) ^ crc) % CACHEPICHASHSIZE;
313 for (pic = cachepichash[hashkey];pic;pic = pic->chain)
314 {
315 if (!strcmp (picname, pic->name) && pic->skinframe)
316 {
317 Con_DPrintf("Draw_FreePic(\"%s\"): frame %i: freeing pic\n", picname, draw_frame);
318 R_SkinFrame_PurgeSkinFrame(pic->skinframe);
319 return;
320 }
321 }
322 }
323
324 static float snap_to_pixel_x(float x, float roundUpAt);
325 extern int con_linewidth; // to force rewrapping
326 void LoadFont(qboolean override, const char *name, dp_font_t *fnt, float scale, float voffset)
327 {
328 int i, ch;
329 float maxwidth;
330 char widthfile[MAX_QPATH];
331 char *widthbuf;
332 fs_offset_t widthbufsize;
333
334 if(override || !fnt->texpath[0])
335 {
336 strlcpy(fnt->texpath, name, sizeof(fnt->texpath));
337 // load the cvars when the font is FIRST loader
338 fnt->settings.scale = scale;
339 fnt->settings.voffset = voffset;
340 fnt->settings.antialias = r_font_antialias.integer;
341 fnt->settings.hinting = r_font_hinting.integer;
342 fnt->settings.outline = r_font_postprocess_outline.value;
343 fnt->settings.blur = r_font_postprocess_blur.value;
344 fnt->settings.shadowx = r_font_postprocess_shadow_x.value;
345 fnt->settings.shadowy = r_font_postprocess_shadow_y.value;
346 fnt->settings.shadowz = r_font_postprocess_shadow_z.value;
347 }
348 // fix bad scale
349 if (fnt->settings.scale <= 0)
350 fnt->settings.scale = 1;
351
352 if(drawtexturepool == NULL)
353 return; // before gl_draw_start, so will be loaded later
354
355 if(fnt->ft2)
356 {
357 // clear freetype font
358 Font_UnloadFont(fnt->ft2);
359 Mem_Free(fnt->ft2);
360 fnt->ft2 = NULL;
361 }
362
363 if(fnt->req_face != -1)
364 {
365 if(!Font_LoadFont(fnt->texpath, fnt))
366 Con_DPrintf("Failed to load font-file for '%s', it will not support as many characters.\n", fnt->texpath);
367 }
368
369 fnt->pic = Draw_CachePic_Flags(fnt->texpath, CACHEPICFLAG_QUIET | CACHEPICFLAG_NOCOMPRESSION | (r_nearest_conchars.integer ? CACHEPICFLAG_NEAREST : 0) | CACHEPICFLAG_FAILONMISSING);
370 if(!Draw_IsPicLoaded(fnt->pic))
371 {
372 for (i = 0; i < MAX_FONT_FALLBACKS; ++i)
373 {
374 if (!fnt->fallbacks[i][0])
375 break;
376 fnt->pic = Draw_CachePic_Flags(fnt->fallbacks[i], CACHEPICFLAG_QUIET | CACHEPICFLAG_NOCOMPRESSION | (r_nearest_conchars.integer ? CACHEPICFLAG_NEAREST : 0) | CACHEPICFLAG_FAILONMISSING);
377 if(Draw_IsPicLoaded(fnt->pic))
378 break;
379 }
380 if(!Draw_IsPicLoaded(fnt->pic))
381 {
382 fnt->pic = Draw_CachePic_Flags("gfx/conchars", CACHEPICFLAG_NOCOMPRESSION | (r_nearest_conchars.integer ? CACHEPICFLAG_NEAREST : 0));
383 strlcpy(widthfile, "gfx/conchars.width", sizeof(widthfile));
384 }
385 else
386 dpsnprintf(widthfile, sizeof(widthfile), "%s.width", fnt->fallbacks[i]);
387 }
388 else
389 dpsnprintf(widthfile, sizeof(widthfile), "%s.width", fnt->texpath);
390
391 // unspecified width == 1 (base width)
392 for(ch = 0; ch < 256; ++ch)
393 fnt->width_of[ch] = 1;
394
395 // FIXME load "name.width", if it fails, fill all with 1
396 if((widthbuf = (char *) FS_LoadFile(widthfile, tempmempool, true, &widthbufsize)))
397 {
398 float extraspacing = 0;
399 const char *p = widthbuf;
400
401 ch = 0;
402 while(ch < 256)
403 {
404 if(!COM_ParseToken_Simple(&p, false, false, true))
405 return;
406
407 switch(*com_token)
408 {
409 case '0':
410 case '1':
411 case '2':
412 case '3':
413 case '4':
414 case '5':
415 case '6':
416 case '7':
417 case '8':
418 case '9':
419 case '+':
420 case '-':
421 case '.':
422 fnt->width_of[ch] = atof(com_token) + extraspacing;
423 ch++;
424 break;
425 default:
426 if(!strcmp(com_token, "extraspacing"))
427 {
428 if(!COM_ParseToken_Simple(&p, false, false, true))
429 return;
430 extraspacing = atof(com_token);
431 }
432 else if(!strcmp(com_token, "scale"))
433 {
434 if(!COM_ParseToken_Simple(&p, false, false, true))
435 return;
436 fnt->settings.scale = atof(com_token);
437 }
438 else
439 {
440 Con_Printf("Warning: skipped unknown font property %s\n", com_token);
441 if(!COM_ParseToken_Simple(&p, false, false, true))
442 return;
443 }
444 break;
445 }
446 }
447
448 Mem_Free(widthbuf);
449 }
450
451 if(fnt->ft2)
452 {
453 for (i = 0; i < MAX_FONT_SIZES; ++i)
454 {
455 ft2_font_map_t *map = Font_MapForIndex(fnt->ft2, i);
456 if (!map)
457 break;
458 for(ch = 0; ch < 256; ++ch)
459 map->width_of[ch] = Font_SnapTo(fnt->width_of[ch], 1/map->size);
460 }
461 }
462
463 maxwidth = fnt->width_of[0];
464 for(i = 1; i < 256; ++i)
465 maxwidth = max(maxwidth, fnt->width_of[i]);
466 fnt->maxwidth = maxwidth;
467
468 // fix up maxwidth for overlap
469 fnt->maxwidth *= fnt->settings.scale;
470
471 if(fnt == FONT_CONSOLE)
472 con_linewidth = -1; // rewrap console in next frame
473 }
474
475 extern cvar_t developer_font;
476 dp_font_t *FindFont(const char *title, qboolean allocate_new)
477 {
478 int i, oldsize;
479
480 // find font
481 for(i = 0; i < dp_fonts.maxsize; ++i)
482 if(!strcmp(dp_fonts.f[i].title, title))
483 return &dp_fonts.f[i];
484 // if not found - try allocate
485 if (allocate_new)
486 {
487 // find any font with empty title
488 for(i = 0; i < dp_fonts.maxsize; ++i)
489 {
490 if(!strcmp(dp_fonts.f[i].title, ""))
491 {
492 strlcpy(dp_fonts.f[i].title, title, sizeof(dp_fonts.f[i].title));
493 return &dp_fonts.f[i];
494 }
495 }
496 // if no any 'free' fonts - expand buffer
497 oldsize = dp_fonts.maxsize;
498 dp_fonts.maxsize = dp_fonts.maxsize + FONTS_EXPAND;
499 if (developer_font.integer)
500 Con_Printf("FindFont: enlarging fonts buffer (%i -> %i)\n", oldsize, dp_fonts.maxsize);
501 dp_fonts.f = (dp_font_t *)Mem_Realloc(fonts_mempool, dp_fonts.f, sizeof(dp_font_t) * dp_fonts.maxsize);
502 // relink ft2 structures
503 for(i = 0; i < oldsize; ++i)
504 if (dp_fonts.f[i].ft2)
505 dp_fonts.f[i].ft2->settings = &dp_fonts.f[i].settings;
506 // register a font in first expanded slot
507 strlcpy(dp_fonts.f[oldsize].title, title, sizeof(dp_fonts.f[oldsize].title));
508 return &dp_fonts.f[oldsize];
509 }
510 return NULL;
511 }
512
513 static float snap_to_pixel_x(float x, float roundUpAt)
514 {
515 float pixelpos = x * vid.width / vid_conwidth.value;
516 int snap = (int) pixelpos;
517 if (pixelpos - snap >= roundUpAt) ++snap;
518 return ((float)snap * vid_conwidth.value / vid.width);
519 /*
520 x = (int)(x * vid.width / vid_conwidth.value);
521 x = (x * vid_conwidth.value / vid.width);
522 return x;
523 */
524 }
525
526 static float snap_to_pixel_y(float y, float roundUpAt)
527 {
528 float pixelpos = y * vid.height / vid_conheight.value;
529 int snap = (int) pixelpos;
530 if (pixelpos - snap > roundUpAt) ++snap;
531 return ((float)snap * vid_conheight.value / vid.height);
532 /*
533 y = (int)(y * vid.height / vid_conheight.value);
534 y = (y * vid_conheight.value / vid.height);
535 return y;
536 */
537 }
538
539 static void LoadFont_f(void)
540 {
541 dp_font_t *f;
542 int i, sizes;
543 const char *filelist, *c, *cm;
544 float sz, scale, voffset;
545 char mainfont[MAX_QPATH];
546
547 if(Cmd_Argc() < 2)
548 {
549 Con_Printf("Available font commands:\n");
550 for(i = 0; i < dp_fonts.maxsize; ++i)
551 if (dp_fonts.f[i].title[0])
552 Con_Printf(" loadfont %s gfx/tgafile[...] [custom switches] [sizes...]\n", dp_fonts.f[i].title);
553 Con_Printf("A font can simply be gfx/tgafile, or alternatively you\n"
554 "can specify multiple fonts and faces\n"
555 "Like this: gfx/vera-sans:2,gfx/fallback:1\n"
556 "to load face 2 of the font gfx/vera-sans and use face 1\n"
557 "of gfx/fallback as fallback font.\n"
558 "You can also specify a list of font sizes to load, like this:\n"
559 "loadfont console gfx/conchars,gfx/fallback 8 12 16 24 32\n"
560 "In many cases, 8 12 16 24 32 should be a good choice.\n"
561 "custom switches:\n"
562 " scale x : scale all characters by this amount when rendering (doesnt change line height)\n"
563 " voffset x : offset all chars vertical when rendering, this is multiplied to character height\n"
564 );
565 return;
566 }
567 f = FindFont(Cmd_Argv(1), true);
568 if(f == NULL)
569 {
570 Con_Printf("font function not found\n");
571 return;
572 }
573
574 if(Cmd_Argc() < 3)
575 filelist = "gfx/conchars";
576 else
577 filelist = Cmd_Argv(2);
578
579 memset(f->fallbacks, 0, sizeof(f->fallbacks));
580 memset(f->fallback_faces, 0, sizeof(f->fallback_faces));
581
582 // first font is handled "normally"
583 c = strchr(filelist, ':');
584 cm = strchr(filelist, ',');
585 if(c && (!cm || c < cm))
586 f->req_face = atoi(c+1);
587 else
588 {
589 f->req_face = 0;
590 c = cm;
591 }
592
593 if(!c || (c - filelist) > MAX_QPATH)
594 strlcpy(mainfont, filelist, sizeof(mainfont));
595 else
596 {
597 memcpy(mainfont, filelist, c - filelist);
598 mainfont[c - filelist] = 0;
599 }
600
601 for(i = 0; i < MAX_FONT_FALLBACKS; ++i)
602 {
603 c = strchr(filelist, ',');
604 if(!c)
605 break;
606 filelist = c + 1;
607 if(!*filelist)
608 break;
609 c = strchr(filelist, ':');
610 cm = strchr(filelist, ',');
611 if(c && (!cm || c < cm))
612 f->fallback_faces[i] = atoi(c+1);
613 else
614 {
615 f->fallback_faces[i] = 0; // f->req_face; could make it stick to the default-font's face index
616 c = cm;
617 }
618 if(!c || (c-filelist) > MAX_QPATH)
619 {
620 strlcpy(f->fallbacks[i], filelist, sizeof(mainfont));
621 }
622 else
623 {
624 memcpy(f->fallbacks[i], filelist, c - filelist);
625 f->fallbacks[i][c - filelist] = 0;
626 }
627 }
628
629 // for now: by default load only one size: the default size
630 f->req_sizes[0] = 0;
631 for(i = 1; i < MAX_FONT_SIZES; ++i)
632 f->req_sizes[i] = -1;
633
634 scale = 1;
635 voffset = 0;
636 if(Cmd_Argc() >= 4)
637 {
638 for(sizes = 0, i = 3; i < Cmd_Argc(); ++i)
639 {
640 // special switches
641 if (!strcmp(Cmd_Argv(i), "scale"))
642 {
643 i++;
644 if (i < Cmd_Argc())
645 scale = atof(Cmd_Argv(i));
646 continue;
647 }
648 if (!strcmp(Cmd_Argv(i), "voffset"))
649 {
650 i++;
651 if (i < Cmd_Argc())
652 voffset = atof(Cmd_Argv(i));
653 continue;
654 }
655
656 if (sizes == -1)
657 continue; // no slot for other sizes
658
659 // parse one of sizes
660 sz = atof(Cmd_Argv(i));
661 if (sz > 0.001f && sz < 1000.0f) // do not use crap sizes
662 {
663 // search for duplicated sizes
664 int j;
665 for (j=0; j<sizes; j++)
666 if (f->req_sizes[j] == sz)
667 break;
668 if (j != sizes)
669 continue; // sz already in req_sizes, don't add it again
670
671 if (sizes == MAX_FONT_SIZES)
672 {
673 Con_Printf("Warning: specified more than %i different font sizes, exceding ones are ignored\n", MAX_FONT_SIZES);
674 sizes = -1;
675 continue;
676 }
677 f->req_sizes[sizes] = sz;
678 sizes++;
679 }
680 }
681 }
682
683 LoadFont(true, mainfont, f, scale, voffset);
684 }
685
686 /*
687 ===============
688 Draw_Init
689 ===============
690 */
691 static void gl_draw_start(void)
692 {
693 int i;
694 char vabuf[1024];
695 drawtexturepool = R_AllocTexturePool();
696
697 numcachepics = 0;
698 memset(cachepichash, 0, sizeof(cachepichash));
699
700 font_start();
701
702 // load default font textures
703 for(i = 0; i < dp_fonts.maxsize; ++i)
704 if (dp_fonts.f[i].title[0])
705 LoadFont(false, va(vabuf, sizeof(vabuf), "gfx/font_%s", dp_fonts.f[i].title), &dp_fonts.f[i], 1, 0);
706
707 // draw the loading screen so people have something to see in the newly opened window
708 SCR_UpdateLoadingScreen(true, true);
709 }
710
711 static void gl_draw_shutdown(void)
712 {
713 font_shutdown();
714
715 R_FreeTexturePool(&drawtexturepool);
716
717 numcachepics = 0;
718 memset(cachepichash, 0, sizeof(cachepichash));
719 }
720
721 static void gl_draw_newmap(void)
722 {
723 int i;
724 font_newmap();
725
726 // mark all of the persistent pics so they are not purged...
727 for (i = 0; i < numcachepics; i++)
728 {
729 cachepic_t *pic = cachepics + i;
730 if (!pic->autoload && pic->skinframe)
731 R_SkinFrame_MarkUsed(pic->skinframe);
732 }
733 }
734
735 void GL_Draw_Init (void)
736 {
737 int i, j;
738
739 Cvar_RegisterVariable(&r_font_postprocess_blur);
740 Cvar_RegisterVariable(&r_font_postprocess_outline);
741 Cvar_RegisterVariable(&r_font_postprocess_shadow_x);
742 Cvar_RegisterVariable(&r_font_postprocess_shadow_y);
743 Cvar_RegisterVariable(&r_font_postprocess_shadow_z);
744 Cvar_RegisterVariable(&r_font_hinting);
745 Cvar_RegisterVariable(&r_font_antialias);
746 Cvar_RegisterVariable(&r_textshadow);
747 Cvar_RegisterVariable(&r_textbrightness);
748 Cvar_RegisterVariable(&r_textcontrast);
749 Cvar_RegisterVariable(&r_nearest_2d);
750 Cvar_RegisterVariable(&r_nearest_conchars);
751
752 // allocate fonts storage
753 fonts_mempool = Mem_AllocPool("FONTS", 0, NULL);
754 dp_fonts.maxsize = MAX_FONTS;
755 dp_fonts.f = (dp_font_t *)Mem_Alloc(fonts_mempool, sizeof(dp_font_t) * dp_fonts.maxsize);
756 memset(dp_fonts.f, 0, sizeof(dp_font_t) * dp_fonts.maxsize);
757
758 // assign starting font names
759 strlcpy(FONT_DEFAULT->title, "default", sizeof(FONT_DEFAULT->title));
760 strlcpy(FONT_DEFAULT->texpath, "gfx/conchars", sizeof(FONT_DEFAULT->texpath));
761 strlcpy(FONT_CONSOLE->title, "console", sizeof(FONT_CONSOLE->title));
762 strlcpy(FONT_SBAR->title, "sbar", sizeof(FONT_SBAR->title));
763 strlcpy(FONT_NOTIFY->title, "notify", sizeof(FONT_NOTIFY->title));
764 strlcpy(FONT_CHAT->title, "chat", sizeof(FONT_CHAT->title));
765 strlcpy(FONT_CENTERPRINT->title, "centerprint", sizeof(FONT_CENTERPRINT->title));
766 strlcpy(FONT_INFOBAR->title, "infobar", sizeof(FONT_INFOBAR->title));
767 strlcpy(FONT_MENU->title, "menu", sizeof(FONT_MENU->title));
768 for(i = 0, j = 0; i < MAX_USERFONTS; ++i)
769 if(!FONT_USER(i)->title[0])
770 dpsnprintf(FONT_USER(i)->title, sizeof(FONT_USER(i)->title), "user%d", j++);
771
772 Cmd_AddCommand ("loadfont",LoadFont_f, "loadfont function tganame loads a font; example: loadfont console gfx/veramono; loadfont without arguments lists the available functions");
773 R_RegisterModule("GL_Draw", gl_draw_start, gl_draw_shutdown, gl_draw_newmap, NULL, NULL);
774 }
775
776 void DrawQ_Start(void)
777 {
778 r_refdef.draw2dstage = 1;
779 R_ResetViewRendering2D_Common(0, NULL, NULL, 0, 0, vid.width, vid.height, vid_conwidth.integer, vid_conheight.integer);
780 }
781
782 qboolean r_draw2d_force = false;
783
784 void DrawQ_Pic(float x, float y, cachepic_t *pic, float width, float height, float red, float green, float blue, float alpha, int flags)
785 {
786 dp_model_t *mod = CL_Mesh_UI();
787 msurface_t *surf;
788 int e0, e1, e2, e3;
789 if (!pic)
790 pic = Draw_CachePic("white");
791 // make sure pic is loaded - we don't use the texture here, Mod_Mesh_GetTexture looks up the skinframe by name
792 Draw_GetPicTexture(pic);
793 if (width == 0)
794 width = pic->width;
795 if (height == 0)
796 height = pic->height;
797 surf = Mod_Mesh_AddSurface(mod, Mod_Mesh_GetTexture(mod, pic->name, flags, pic->texflags, MATERIALFLAG_WALL | MATERIALFLAG_VERTEXCOLOR | MATERIALFLAG_ALPHAGEN_VERTEX), true);
798 e0 = Mod_Mesh_IndexForVertex(mod, surf, x , y , 0, 0, 0, -1, 0, 0, 0, 0, red, green, blue, alpha);
799 e1 = Mod_Mesh_IndexForVertex(mod, surf, x + width, y , 0, 0, 0, -1, 1, 0, 0, 0, red, green, blue, alpha);
800 e2 = Mod_Mesh_IndexForVertex(mod, surf, x + width, y + height, 0, 0, 0, -1, 1, 1, 0, 0, red, green, blue, alpha);
801 e3 = Mod_Mesh_IndexForVertex(mod, surf, x , y + height, 0, 0, 0, -1, 0, 1, 0, 0, red, green, blue, alpha);
802 Mod_Mesh_AddTriangle(mod, surf, e0, e1, e2);
803 Mod_Mesh_AddTriangle(mod, surf, e0, e2, e3);
804 }
805
806 void DrawQ_RotPic(float x, float y, cachepic_t *pic, float width, float height, float org_x, float org_y, float angle, float red, float green, float blue, float alpha, int flags)
807 {
808 float af = DEG2RAD(-angle); // forward
809 float ar = DEG2RAD(-angle + 90); // right
810 float sinaf = sin(af);
811 float cosaf = cos(af);
812 float sinar = sin(ar);
813 float cosar = cos(ar);
814 dp_model_t *mod = CL_Mesh_UI();
815 msurface_t *surf;
816 int e0, e1, e2, e3;
817 if (!pic)
818 pic = Draw_CachePic("white");
819 // make sure pic is loaded - we don't use the texture here, Mod_Mesh_GetTexture looks up the skinframe by name
820 Draw_GetPicTexture(pic);
821 if (width == 0)
822 width = pic->width;
823 if (height == 0)
824 height = pic->height;
825 surf = Mod_Mesh_AddSurface(mod, Mod_Mesh_GetTexture(mod, pic->name, flags, pic->texflags, MATERIALFLAG_WALL | MATERIALFLAG_VERTEXCOLOR | MATERIALFLAG_ALPHAGEN_VERTEX), true);
826 e0 = Mod_Mesh_IndexForVertex(mod, surf, x - cosaf * org_x - cosar * org_y , y - sinaf * org_x - sinar * org_y , 0, 0, 0, -1, 0, 0, 0, 0, red, green, blue, alpha);
827 e1 = Mod_Mesh_IndexForVertex(mod, surf, x + cosaf * (width - org_x) - cosar * org_y , y + sinaf * (width - org_x) - sinar * org_y , 0, 0, 0, -1, 1, 0, 0, 0, red, green, blue, alpha);
828 e2 = Mod_Mesh_IndexForVertex(mod, surf, x + cosaf * (width - org_x) + cosar * (height - org_y), y + sinaf * (width - org_x) + sinar * (height - org_y), 0, 0, 0, -1, 1, 1, 0, 0, red, green, blue, alpha);
829 e3 = Mod_Mesh_IndexForVertex(mod, surf, x - cosaf * org_x + cosar * (height - org_y), y - sinaf * org_x + sinar * (height - org_y), 0, 0, 0, -1, 0, 1, 0, 0, red, green, blue, alpha);
830 Mod_Mesh_AddTriangle(mod, surf, e0, e1, e2);
831 Mod_Mesh_AddTriangle(mod, surf, e0, e2, e3);
832 }
833
834 void DrawQ_Fill(float x, float y, float width, float height, float red, float green, float blue, float alpha, int flags)
835 {
836 DrawQ_Pic(x, y, Draw_CachePic("white"), width, height, red, green, blue, alpha, flags);
837 }
838
839 /// color tag printing
840 static const vec4_t string_colors[] =
841 {
842 // Quake3 colors
843 // LordHavoc: why on earth is cyan before magenta in Quake3?
844 // LordHavoc: note: Doom3 uses white for [0] and [7]
845 {0.0, 0.0, 0.0, 1.0}, // black
846 {1.0, 0.0, 0.0, 1.0}, // red
847 {0.0, 1.0, 0.0, 1.0}, // green
848 {1.0, 1.0, 0.0, 1.0}, // yellow
849 {0.0, 0.0, 1.0, 1.0}, // blue
850 {0.0, 1.0, 1.0, 1.0}, // cyan
851 {1.0, 0.0, 1.0, 1.0}, // magenta
852 {1.0, 1.0, 1.0, 1.0}, // white
853 // [515]'s BX_COLOREDTEXT extension
854 {1.0, 1.0, 1.0, 0.5}, // half transparent
855 {0.5, 0.5, 0.5, 1.0} // half brightness
856 // Black's color table
857 //{1.0, 1.0, 1.0, 1.0},
858 //{1.0, 0.0, 0.0, 1.0},
859 //{0.0, 1.0, 0.0, 1.0},
860 //{0.0, 0.0, 1.0, 1.0},
861 //{1.0, 1.0, 0.0, 1.0},
862 //{0.0, 1.0, 1.0, 1.0},
863 //{1.0, 0.0, 1.0, 1.0},
864 //{0.1, 0.1, 0.1, 1.0}
865 };
866
867 #define STRING_COLORS_COUNT (sizeof(string_colors) / sizeof(vec4_t))
868
869 static void DrawQ_GetTextColor(float color[4], int colorindex, float r, float g, float b, float a, qboolean shadow)
870 {
871 float C = r_textcontrast.value;
872 float B = r_textbrightness.value;
873 if (colorindex & 0x10000) // that bit means RGB color
874 {
875 color[0] = ((colorindex >> 12) & 0xf) / 15.0;
876 color[1] = ((colorindex >> 8) & 0xf) / 15.0;
877 color[2] = ((colorindex >> 4) & 0xf) / 15.0;
878 color[3] = (colorindex & 0xf) / 15.0;
879 }
880 else
881 Vector4Copy(string_colors[colorindex], color);
882 Vector4Set(color, color[0] * r * C + B, color[1] * g * C + B, color[2] * b * C + B, color[3] * a);
883 if (shadow)
884 {
885 float shadowalpha = (color[0]+color[1]+color[2]) * 0.8;
886 Vector4Set(color, 0, 0, 0, color[3] * bound(0, shadowalpha, 1));
887 }
888 }
889
890 // NOTE: this function always draws exactly one character if maxwidth <= 0
891 float DrawQ_TextWidth_UntilWidth_TrackColors_Scale(const char *text, size_t *maxlen, float w, float h, float sw, float sh, int *outcolor, qboolean ignorecolorcodes, const dp_font_t *fnt, float maxwidth)
892 {
893 const char *text_start = text;
894 int colorindex = STRING_COLOR_DEFAULT;
895 size_t i;
896 float x = 0;
897 Uchar ch, mapch, nextch;
898 Uchar prevch = 0; // used for kerning
899 int tempcolorindex;
900 float kx;
901 int map_index = 0;
902 size_t bytes_left;
903 ft2_font_map_t *fontmap = NULL;
904 ft2_font_map_t *map = NULL;
905 //ft2_font_map_t *prevmap = NULL;
906 ft2_font_t *ft2 = fnt->ft2;
907 // float ftbase_x;
908 qboolean snap = true;
909 qboolean least_one = false;
910 float dw; // display w
911 //float dh; // display h
912 const float *width_of;
913
914 if (!h) h = w;
915 if (!h) {
916 w = h = 1;
917 snap = false;
918 }
919 // do this in the end
920 w *= fnt->settings.scale;
921 h *= fnt->settings.scale;
922
923 // find the most fitting size:
924 if (ft2 != NULL)
925 {
926 if (snap)
927 map_index = Font_IndexForSize(ft2, h, &w, &h);
928 else
929 map_index = Font_IndexForSize(ft2, h, NULL, NULL);
930 fontmap = Font_MapForIndex(ft2, map_index);
931 }
932
933 dw = w * sw;
934 //dh = h * sh;
935
936 if (*maxlen < 1)
937 *maxlen = 1<<30;
938
939 if (!outcolor || *outcolor == -1)
940 colorindex = STRING_COLOR_DEFAULT;
941 else
942 colorindex = *outcolor;
943
944 // maxwidth /= fnt->scale; // w and h are multiplied by it already
945 // ftbase_x = snap_to_pixel_x(0);
946
947 if(maxwidth <= 0)
948 {
949 least_one = true;
950 maxwidth = -maxwidth;
951 }
952
953 //if (snap)
954 // x = snap_to_pixel_x(x, 0.4); // haha, it's 0 anyway
955
956 if (fontmap)
957 width_of = fontmap->width_of;
958 else
959 width_of = fnt->width_of;
960
961 i = 0;
962 while (((bytes_left = *maxlen - (text - text_start)) > 0) && *text)
963 {
964 size_t i0 = i;
965 nextch = ch = u8_getnchar(text, &text, bytes_left);
966 i = text - text_start;
967 if (!ch)
968 break;
969 if (ch == ' ' && !fontmap)
970 {
971 if(!least_one || i0) // never skip the first character
972 if(x + width_of[(int) ' '] * dw > maxwidth)
973 {
974 i = i0;
975 break; // oops, can't draw this
976 }
977 x += width_of[(int) ' '] * dw;
978 continue;
979 }
980 // i points to the char after ^
981 if (ch == STRING_COLOR_TAG && !ignorecolorcodes && i < *maxlen)
982 {
983 ch = *text; // colors are ascii, so no u8_ needed
984 if (ch <= '9' && ch >= '0') // ^[0-9] found
985 {
986 colorindex = ch - '0';
987 ++text;
988 ++i;
989 continue;
990 }
991 // i points to the char after ^...
992 // i+3 points to 3 in ^x123
993 // i+3 == *maxlen would mean that char is missing
994 else if (ch == STRING_COLOR_RGB_TAG_CHAR && i + 3 < *maxlen ) // ^x found
995 {
996 // building colorindex...
997 ch = tolower(text[1]);
998 tempcolorindex = 0x10000; // binary: 1,0000,0000,0000,0000
999 if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 12;
1000 else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 12;
1001 else tempcolorindex = 0;
1002 if (tempcolorindex)
1003 {
1004 ch = tolower(text[2]);
1005 if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 8;
1006 else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 8;
1007 else tempcolorindex = 0;
1008 if (tempcolorindex)
1009 {
1010 ch = tolower(text[3]);
1011 if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 4;
1012 else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 4;
1013 else tempcolorindex = 0;
1014 if (tempcolorindex)
1015 {
1016 colorindex = tempcolorindex | 0xf;
1017 // ...done! now colorindex has rgba codes (1,rrrr,gggg,bbbb,aaaa)
1018 i+=4;
1019 text += 4;
1020 continue;
1021 }
1022 }
1023 }
1024 }
1025 else if (ch == STRING_COLOR_TAG) // ^^ found, ignore the first ^ and go to print the second
1026 {
1027 i++;
1028 text++;
1029 }
1030 i--;
1031 }
1032 ch = nextch;
1033
1034 if (!fontmap || (ch <= 0xFF && fontmap->glyphs[ch].image) || (ch >= 0xE000 && ch <= 0xE0FF))
1035 {
1036 if (ch > 0xE000)
1037 ch -= 0xE000;
1038 if (ch > 0xFF)
1039 continue;
1040 if (fontmap)
1041 map = ft2_oldstyle_map;
1042 prevch = 0;
1043 if(!least_one || i0) // never skip the first character
1044 if(x + width_of[ch] * dw > maxwidth)
1045 {
1046 i = i0;
1047 break; // oops, can't draw this
1048 }
1049 x += width_of[ch] * dw;
1050 } else {
1051 if (!map || map == ft2_oldstyle_map || ch < map->start || ch >= map->start + FONT_CHARS_PER_MAP)
1052 {
1053 map = FontMap_FindForChar(fontmap, ch);
1054 if (!map)
1055 {
1056 if (!Font_LoadMapForIndex(ft2, map_index, ch, &map))
1057 break;
1058 if (!map)
1059 break;
1060 }
1061 }
1062 mapch = ch - map->start;
1063 if (prevch && Font_GetKerningForMap(ft2, map_index, w, h, prevch, ch, &kx, NULL))
1064 x += kx * dw;
1065 x += map->glyphs[mapch].advance_x * dw;
1066 //prevmap = map;
1067 prevch = ch;
1068 }
1069 }
1070
1071 *maxlen = i;
1072
1073 if (outcolor)
1074 *outcolor = colorindex;
1075
1076 return x;
1077 }
1078
1079 float DrawQ_Color[4];
1080 float DrawQ_String_Scale(float startx, float starty, const char *text, size_t maxlen, float w, float h, float sw, float sh, float basered, float basegreen, float baseblue, float basealpha, int flags, int *outcolor, qboolean ignorecolorcodes, const dp_font_t *fnt)
1081 {
1082 int shadow, colorindex = STRING_COLOR_DEFAULT;
1083 size_t i;
1084 float x = startx, y, s, t, u, v, thisw;
1085 Uchar ch, mapch, nextch;
1086 Uchar prevch = 0; // used for kerning
1087 int tempcolorindex;
1088 int map_index = 0;
1089 //ft2_font_map_t *prevmap = NULL; // the previous map
1090 ft2_font_map_t *map = NULL; // the currently used map
1091 ft2_font_map_t *fontmap = NULL; // the font map for the size
1092 float ftbase_y;
1093 const char *text_start = text;
1094 float kx, ky;
1095 ft2_font_t *ft2 = fnt->ft2;
1096 qboolean snap = true;
1097 float pix_x, pix_y;
1098 size_t bytes_left;
1099 float dw, dh;
1100 const float *width_of;
1101 dp_model_t *mod = CL_Mesh_UI();
1102 msurface_t *surf = NULL;
1103 int e0, e1, e2, e3;
1104 int tw, th;
1105 tw = Draw_GetPicWidth(fnt->pic);
1106 th = Draw_GetPicHeight(fnt->pic);
1107
1108 if (!h) h = w;
1109 if (!h) {
1110 h = w = 1;
1111 snap = false;
1112 }
1113
1114 starty -= (fnt->settings.scale - 1) * h * 0.5 - fnt->settings.voffset*h; // center & offset
1115 w *= fnt->settings.scale;
1116 h *= fnt->settings.scale;
1117
1118 if (ft2 != NULL)
1119 {
1120 if (snap)
1121 map_index = Font_IndexForSize(ft2, h, &w, &h);
1122 else
1123 map_index = Font_IndexForSize(ft2, h, NULL, NULL);
1124 fontmap = Font_MapForIndex(ft2, map_index);
1125 }
1126
1127 dw = w * sw;
1128 dh = h * sh;
1129
1130 // draw the font at its baseline when using freetype
1131 //ftbase_x = 0;
1132 ftbase_y = dh * (4.5/6.0);
1133
1134 if (maxlen < 1)
1135 maxlen = 1<<30;
1136
1137 if(!r_draw2d.integer && !r_draw2d_force)
1138 return startx + DrawQ_TextWidth_UntilWidth_TrackColors_Scale(text, &maxlen, w, h, sw, sh, NULL, ignorecolorcodes, fnt, 1000000000);
1139
1140 //ftbase_x = snap_to_pixel_x(ftbase_x);
1141 if(snap)
1142 {
1143 startx = snap_to_pixel_x(startx, 0.4);
1144 starty = snap_to_pixel_y(starty, 0.4);
1145 ftbase_y = snap_to_pixel_y(ftbase_y, 0.3);
1146 }
1147
1148 pix_x = vid.width / vid_conwidth.value;
1149 pix_y = vid.height / vid_conheight.value;
1150
1151 if (fontmap)
1152 width_of = fontmap->width_of;
1153 else
1154 width_of = fnt->width_of;
1155
1156 for (shadow = r_textshadow.value != 0 && basealpha > 0;shadow >= 0;shadow--)
1157 {
1158 prevch = 0;
1159 text = text_start;
1160
1161 if (!outcolor || *outcolor == -1)
1162 colorindex = STRING_COLOR_DEFAULT;
1163 else
1164 colorindex = *outcolor;
1165
1166 DrawQ_GetTextColor(DrawQ_Color, colorindex, basered, basegreen, baseblue, basealpha, shadow != 0);
1167
1168 x = startx;
1169 y = starty;
1170 /*
1171 if (shadow)
1172 {
1173 x += r_textshadow.value * vid.width / vid_conwidth.value;
1174 y += r_textshadow.value * vid.height / vid_conheight.value;
1175 }
1176 */
1177 while (((bytes_left = maxlen - (text - text_start)) > 0) && *text)
1178 {
1179 nextch = ch = u8_getnchar(text, &text, bytes_left);
1180 i = text - text_start;
1181 if (!ch)
1182 break;
1183 if (ch == ' ' && !fontmap)
1184 {
1185 x += width_of[(int) ' '] * dw;
1186 continue;
1187 }
1188 if (ch == STRING_COLOR_TAG && !ignorecolorcodes && i < maxlen)
1189 {
1190 ch = *text; // colors are ascii, so no u8_ needed
1191 if (ch <= '9' && ch >= '0') // ^[0-9] found
1192 {
1193 colorindex = ch - '0';
1194 DrawQ_GetTextColor(DrawQ_Color, colorindex, basered, basegreen, baseblue, basealpha, shadow != 0);
1195 ++text;
1196 ++i;
1197 continue;
1198 }
1199 else if (ch == STRING_COLOR_RGB_TAG_CHAR && i+3 < maxlen ) // ^x found
1200 {
1201 // building colorindex...
1202 ch = tolower(text[1]);
1203 tempcolorindex = 0x10000; // binary: 1,0000,0000,0000,0000
1204 if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 12;
1205 else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 12;
1206 else tempcolorindex = 0;
1207 if (tempcolorindex)
1208 {
1209 ch = tolower(text[2]);
1210 if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 8;
1211 else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 8;
1212 else tempcolorindex = 0;
1213 if (tempcolorindex)
1214 {
1215 ch = tolower(text[3]);
1216 if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 4;
1217 else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 4;
1218 else tempcolorindex = 0;
1219 if (tempcolorindex)
1220 {
1221 colorindex = tempcolorindex | 0xf;
1222 // ...done! now colorindex has rgba codes (1,rrrr,gggg,bbbb,aaaa)
1223 //Con_Printf("^1colorindex:^7 %x\n", colorindex);
1224 DrawQ_GetTextColor(DrawQ_Color, colorindex, basered, basegreen, baseblue, basealpha, shadow != 0);
1225 i+=4;
1226 text+=4;
1227 continue;
1228 }
1229 }
1230 }
1231 }
1232 else if (ch == STRING_COLOR_TAG)
1233 {
1234 i++;
1235 text++;
1236 }
1237 i--;
1238 }
1239 // get the backup
1240 ch = nextch;
1241 // using a value of -1 for the oldstyle map because NULL means uninitialized...
1242 // this way we don't need to rebind fnt->tex for every old-style character
1243 // E000..E0FF: emulate old-font characters (to still have smileys and such available)
1244 if (shadow)
1245 {
1246 x += 1.0/pix_x * r_textshadow.value;
1247 y += 1.0/pix_y * r_textshadow.value;
1248 }
1249 if (!fontmap || (ch <= 0xFF && fontmap->glyphs[ch].image) || (ch >= 0xE000 && ch <= 0xE0FF))
1250 {
1251 if (ch >= 0xE000)
1252 ch -= 0xE000;
1253 if (ch > 0xFF)
1254 goto out;
1255 if (fontmap)
1256 map = ft2_oldstyle_map;
1257 prevch = 0;
1258 //num = (unsigned char) text[i];
1259 //thisw = fnt->width_of[num];
1260 thisw = fnt->width_of[ch];
1261 // FIXME make these smaller to just include the occupied part of the character for slightly faster rendering
1262 if (r_nearest_conchars.integer)
1263 {
1264 s = (ch & 15)*0.0625f;
1265 t = (ch >> 4)*0.0625f;
1266 u = 0.0625f * thisw;
1267 v = 0.0625f;
1268 }
1269 else
1270 {
1271 s = (ch & 15)*0.0625f + (0.5f / tw);
1272 t = (ch >> 4)*0.0625f + (0.5f / th);
1273 u = 0.0625f * thisw - (1.0f / tw);
1274 v = 0.0625f - (1.0f / th);
1275 }
1276 surf = Mod_Mesh_AddSurface(mod, Mod_Mesh_GetTexture(mod, fnt->pic->name, flags, TEXF_ALPHA | TEXF_CLAMP, MATERIALFLAG_WALL | MATERIALFLAG_VERTEXCOLOR | MATERIALFLAG_ALPHAGEN_VERTEX), true);
1277 e0 = Mod_Mesh_IndexForVertex(mod, surf, x , y , 10, 0, 0, -1, s , t , 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1278 e1 = Mod_Mesh_IndexForVertex(mod, surf, x+dw*thisw, y , 10, 0, 0, -1, s+u, t , 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1279 e2 = Mod_Mesh_IndexForVertex(mod, surf, x+dw*thisw, y+dh, 10, 0, 0, -1, s+u, t+v, 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1280 e3 = Mod_Mesh_IndexForVertex(mod, surf, x , y+dh, 10, 0, 0, -1, s , t+v, 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1281 Mod_Mesh_AddTriangle(mod, surf, e0, e1, e2);
1282 Mod_Mesh_AddTriangle(mod, surf, e0, e2, e3);
1283 x += width_of[ch] * dw;
1284 } else {
1285 if (!map || map == ft2_oldstyle_map || ch < map->start || ch >= map->start + FONT_CHARS_PER_MAP)
1286 {
1287 // find the new map
1288 map = FontMap_FindForChar(fontmap, ch);
1289 if (!map)
1290 {
1291 if (!Font_LoadMapForIndex(ft2, map_index, ch, &map))
1292 {
1293 shadow = -1;
1294 break;
1295 }
1296 if (!map)
1297 {
1298 // this shouldn't happen
1299 shadow = -1;
1300 break;
1301 }
1302 }
1303 }
1304
1305 mapch = ch - map->start;
1306 thisw = map->glyphs[mapch].advance_x;
1307
1308 //x += ftbase_x;
1309 y += ftbase_y;
1310 if (prevch && Font_GetKerningForMap(ft2, map_index, w, h, prevch, ch, &kx, &ky))
1311 {
1312 x += kx * dw;
1313 y += ky * dh;
1314 }
1315 else
1316 kx = ky = 0;
1317 surf = Mod_Mesh_AddSurface(mod, Mod_Mesh_GetTexture(mod, map->pic->name, flags, TEXF_ALPHA | TEXF_CLAMP, MATERIALFLAG_WALL | MATERIALFLAG_VERTEXCOLOR | MATERIALFLAG_ALPHAGEN_VERTEX), true);
1318 e0 = Mod_Mesh_IndexForVertex(mod, surf, x + dw * map->glyphs[mapch].vxmin, y + dh * map->glyphs[mapch].vymin, 10, 0, 0, -1, map->glyphs[mapch].txmin, map->glyphs[mapch].tymin, 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1319 e1 = Mod_Mesh_IndexForVertex(mod, surf, x + dw * map->glyphs[mapch].vxmax, y + dh * map->glyphs[mapch].vymin, 10, 0, 0, -1, map->glyphs[mapch].txmax, map->glyphs[mapch].tymin, 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1320 e2 = Mod_Mesh_IndexForVertex(mod, surf, x + dw * map->glyphs[mapch].vxmax, y + dh * map->glyphs[mapch].vymax, 10, 0, 0, -1, map->glyphs[mapch].txmax, map->glyphs[mapch].tymax, 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1321 e3 = Mod_Mesh_IndexForVertex(mod, surf, x + dw * map->glyphs[mapch].vxmin, y + dh * map->glyphs[mapch].vymax, 10, 0, 0, -1, map->glyphs[mapch].txmin, map->glyphs[mapch].tymax, 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1322 Mod_Mesh_AddTriangle(mod, surf, e0, e1, e2);
1323 Mod_Mesh_AddTriangle(mod, surf, e0, e2, e3);
1324 //x -= ftbase_x;
1325 y -= ftbase_y;
1326
1327 x += thisw * dw;
1328
1329 //prevmap = map;
1330 prevch = ch;
1331 }
1332 out:
1333 if (shadow)
1334 {
1335 x -= 1.0/pix_x * r_textshadow.value;
1336 y -= 1.0/pix_y * r_textshadow.value;
1337 }
1338 }
1339 }
1340
1341 if (outcolor)
1342 *outcolor = colorindex;
1343
1344 // note: this relies on the proper text (not shadow) being drawn last
1345 return x;
1346 }
1347
1348 float DrawQ_String(float startx, float starty, const char *text, size_t maxlen, float w, float h, float basered, float basegreen, float baseblue, float basealpha, int flags, int *outcolor, qboolean ignorecolorcodes, const dp_font_t *fnt)
1349 {
1350 return DrawQ_String_Scale(startx, starty, text, maxlen, w, h, 1, 1, basered, basegreen, baseblue, basealpha, flags, outcolor, ignorecolorcodes, fnt);
1351 }
1352
1353 float DrawQ_TextWidth_UntilWidth_TrackColors(const char *text, size_t *maxlen, float w, float h, int *outcolor, qboolean ignorecolorcodes, const dp_font_t *fnt, float maxwidth)
1354 {
1355 return DrawQ_TextWidth_UntilWidth_TrackColors_Scale(text, maxlen, w, h, 1, 1, outcolor, ignorecolorcodes, fnt, maxwidth);
1356 }
1357
1358 float DrawQ_TextWidth(const char *text, size_t maxlen, float w, float h, qboolean ignorecolorcodes, const dp_font_t *fnt)
1359 {
1360 return DrawQ_TextWidth_UntilWidth(text, &maxlen, w, h, ignorecolorcodes, fnt, 1000000000);
1361 }
1362
1363 float DrawQ_TextWidth_UntilWidth(const char *text, size_t *maxlen, float w, float h, qboolean ignorecolorcodes, const dp_font_t *fnt, float maxWidth)
1364 {
1365 return DrawQ_TextWidth_UntilWidth_TrackColors(text, maxlen, w, h, NULL, ignorecolorcodes, fnt, maxWidth);
1366 }
1367
1368 #if 0
1369 // not used
1370 // no ^xrgb management
1371 static int DrawQ_BuildColoredText(char *output2c, size_t maxoutchars, const char *text, int maxreadchars, qboolean ignorecolorcodes, int *outcolor)
1372 {
1373 int color, numchars = 0;
1374 char *outputend2c = output2c + maxoutchars - 2;
1375 if (!outcolor || *outcolor == -1)
1376 color = STRING_COLOR_DEFAULT;
1377 else
1378 color = *outcolor;
1379 if (!maxreadchars)
1380 maxreadchars = 1<<30;
1381 textend = text + maxreadchars;
1382 while (text != textend && *text)
1383 {
1384 if (*text == STRING_COLOR_TAG && !ignorecolorcodes && text + 1 != textend)
1385 {
1386 if (text[1] == STRING_COLOR_TAG)
1387 text++;
1388 else if (text[1] >= '0' && text[1] <= '9')
1389 {
1390 color = text[1] - '0';
1391 text += 2;
1392 continue;
1393 }
1394 }
1395 if (output2c >= outputend2c)
1396 break;
1397 *output2c++ = *text++;
1398 *output2c++ = color;
1399 numchars++;
1400 }
1401 output2c[0] = output2c[1] = 0;
1402 if (outcolor)
1403 *outcolor = color;
1404 return numchars;
1405 }
1406 #endif
1407
1408 void DrawQ_SuperPic(float x, float y, cachepic_t *pic, float width, float height, float s1, float t1, float r1, float g1, float b1, float a1, float s2, float t2, float r2, float g2, float b2, float a2, float s3, float t3, float r3, float g3, float b3, float a3, float s4, float t4, float r4, float g4, float b4, float a4, int flags)
1409 {
1410 dp_model_t *mod = CL_Mesh_UI();
1411 msurface_t *surf;
1412 int e0, e1, e2, e3;
1413 if (!pic)
1414 pic = Draw_CachePic("white");
1415 // make sure pic is loaded - we don't use the texture here, Mod_Mesh_GetTexture looks up the skinframe by name
1416 Draw_GetPicTexture(pic);
1417 if (width == 0)
1418 width = pic->width;
1419 if (height == 0)
1420 height = pic->height;
1421 surf = Mod_Mesh_AddSurface(mod, Mod_Mesh_GetTexture(mod, pic->name, flags, pic->texflags, MATERIALFLAG_WALL | MATERIALFLAG_VERTEXCOLOR | MATERIALFLAG_ALPHAGEN_VERTEX), true);
1422 e0 = Mod_Mesh_IndexForVertex(mod, surf, x , y , 0, 0, 0, -1, s1, t1, 0, 0, r1, g1, b1, a1);
1423 e1 = Mod_Mesh_IndexForVertex(mod, surf, x + width, y , 0, 0, 0, -1, s2, t2, 0, 0, r2, g2, b2, a2);
1424 e2 = Mod_Mesh_IndexForVertex(mod, surf, x + width, y + height, 0, 0, 0, -1, s4, t4, 0, 0, r4, g4, b4, a4);
1425 e3 = Mod_Mesh_IndexForVertex(mod, surf, x , y + height, 0, 0, 0, -1, s3, t3, 0, 0, r3, g3, b3, a3);
1426 Mod_Mesh_AddTriangle(mod, surf, e0, e1, e2);
1427 Mod_Mesh_AddTriangle(mod, surf, e0, e2, e3);
1428 }
1429
1430 void DrawQ_Line (float width, float x1, float y1, float x2, float y2, float r, float g, float b, float alpha, int flags)
1431 {
1432 dp_model_t *mod = CL_Mesh_UI();
1433 msurface_t *surf;
1434 int e0, e1, e2, e3;
1435 float offsetx, offsety;
1436 // width is measured in real pixels
1437 if (fabs(x2 - x1) > fabs(y2 - y1))
1438 {
1439 offsetx = 0;
1440 offsety = 0.5f * width * vid_conheight.value / vid.height;
1441 }
1442 else
1443 {
1444 offsetx = 0.5f * width * vid_conwidth.value / vid.width;
1445 offsety = 0;
1446 }
1447 surf = Mod_Mesh_AddSurface(mod, Mod_Mesh_GetTexture(mod, "white", 0, 0, MATERIALFLAG_WALL | MATERIALFLAG_VERTEXCOLOR | MATERIALFLAG_ALPHAGEN_VERTEX), true);
1448 e0 = Mod_Mesh_IndexForVertex(mod, surf, x1 - offsetx, y1 - offsety, 10, 0, 0, -1, 0, 0, 0, 0, r, g, b, alpha);
1449 e1 = Mod_Mesh_IndexForVertex(mod, surf, x2 - offsetx, y2 - offsety, 10, 0, 0, -1, 0, 0, 0, 0, r, g, b, alpha);
1450 e2 = Mod_Mesh_IndexForVertex(mod, surf, x2 + offsetx, y2 + offsety, 10, 0, 0, -1, 0, 0, 0, 0, r, g, b, alpha);
1451 e3 = Mod_Mesh_IndexForVertex(mod, surf, x1 + offsetx, y1 + offsety, 10, 0, 0, -1, 0, 0, 0, 0, r, g, b, alpha);
1452 Mod_Mesh_AddTriangle(mod, surf, e0, e1, e2);
1453 Mod_Mesh_AddTriangle(mod, surf, e0, e2, e3);
1454 }
1455
1456 void DrawQ_SetClipArea(float x, float y, float width, float height)
1457 {
1458 int ix, iy, iw, ih;
1459 DrawQ_FlushUI();
1460
1461 // We have to convert the con coords into real coords
1462 // OGL uses bottom to top (origin is in bottom left)
1463 ix = (int)(0.5 + x * ((float)r_refdef.view.width / vid_conwidth.integer)) + r_refdef.view.x;
1464 iy = (int)(0.5 + y * ((float)r_refdef.view.height / vid_conheight.integer)) + r_refdef.view.y;
1465 iw = (int)(0.5 + width * ((float)r_refdef.view.width / vid_conwidth.integer));
1466 ih = (int)(0.5 + height * ((float)r_refdef.view.height / vid_conheight.integer));
1467 switch(vid.renderpath)
1468 {
1469 case RENDERPATH_GL32:
1470 case RENDERPATH_GLES2:
1471 GL_Scissor(ix, vid.height - iy - ih, iw, ih);
1472 break;
1473 }
1474
1475 GL_ScissorTest(true);
1476 }
1477
1478 void DrawQ_ResetClipArea(void)
1479 {
1480 DrawQ_FlushUI();
1481 GL_ScissorTest(false);
1482 }
1483
1484 void DrawQ_Finish(void)
1485 {
1486 DrawQ_FlushUI();
1487 r_refdef.draw2dstage = 0;
1488 }
1489
1490 void DrawQ_RecalcView(void)
1491 {
1492 DrawQ_FlushUI();
1493 if(r_refdef.draw2dstage)
1494 r_refdef.draw2dstage = -1; // next draw call will set viewport etc. again
1495 }
1496
1497 void DrawQ_FlushUI(void)
1498 {
1499 dp_model_t *mod = CL_Mesh_UI();
1500 if (mod->num_surfaces == 0)
1501 return;
1502
1503 if (!r_draw2d.integer && !r_draw2d_force)
1504 {
1505 Mod_Mesh_Reset(mod);
1506 return;
1507 }
1508
1509 // TODO: render the mesh using R_Q1BSP_Draw or similar, for full material support.
1510 r_refdef.view.colorscale = 1;
1511 r_textureframe++; // used only by R_GetCurrentTexture
1512 GL_DepthMask(false);
1513
1514 Mod_Mesh_Finalize(mod);
1515 R_DrawModelSurfaces(&cl_meshentities[MESH_UI].render, false, false, false, false, false, true);
1516
1517 Mod_Mesh_Reset(mod);
1518 }