ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/Deliantra-Client/Client.xs
(Generate patch)

Comparing deliantra/Deliantra-Client/Client.xs (file contents):
Revision 1.30 by root, Thu Apr 13 23:07:56 2006 UTC vs.
Revision 1.210 by root, Tue Jul 24 18:24:03 2007 UTC

1#ifdef _WIN32
2# define WIN32_LEAN_AND_MEAN
3# define NTDDI_VERSION NTDDI_WIN2K // needed to get win2000 api calls
4# include <malloc.h>
5# include <windows.h>
6# include <wininet.h>
7# pragma warning(disable:4244)
8# pragma warning(disable:4761)
9#endif
10
11//#define DEBUG 1
12#if DEBUG
13# include <valgrind/memcheck.h>
14#endif
15
1#include "EXTERN.h" 16#include "EXTERN.h"
2#include "perl.h" 17#include "perl.h"
3#include "XSUB.h" 18#include "XSUB.h"
4 19
20#ifdef _WIN32
21# undef pipe
22#endif
23
24#include <assert.h>
25#include <math.h>
5#include <string.h> 26#include <string.h>
6#include <stdio.h> 27#include <stdio.h>
28#include <stdlib.h>
7 29
8#include <SDL.h> 30#include <SDL.h>
31#include <SDL_thread.h>
32#include <SDL_endian.h>
9#include <SDL_image.h> 33#include <SDL_image.h>
34#include <SDL_mixer.h>
10#include <SDL_opengl.h> 35#include <SDL_opengl.h>
11 36
37#define PANGO_ENABLE_BACKEND
38#define G_DISABLE_CAST_CHECKS
39
12#include <glib/gmacros.h> 40#include <glib/gmacros.h>
13 41
14#include <pango/pango.h> 42#include <pango/pango.h>
15#include <pango/pangofc-fontmap.h>
16#include <pango/pangoft2.h>
17 43
44#ifndef _WIN32
18#include <sys/types.h> 45# include <sys/types.h>
19#include <sys/socket.h> 46# include <sys/socket.h>
20#include <netinet/in.h> 47# include <netinet/in.h>
21#include <netinet/tcp.h> 48# include <netinet/tcp.h>
22
23#include <inttypes.h> 49# include <inttypes.h>
50#endif
51
52#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
24 53
25#define FOW_DARKNESS 32 54#define FOW_DARKNESS 32
26 55
27#define MAP_EXTEND_X 32 56#define MAP_EXTEND_X 32
28#define MAP_EXTEND_Y 512 57#define MAP_EXTEND_Y 512
29 58
30static PangoContext *context; 59#define MIN_FONT_HEIGHT 10
31static PangoFontMap *fontmap; 60
61#if 0
62# define PARACHUTE SDL_INIT_NOPARACHUTE
63#else
64# define PARACHUTE 0
65#endif
66
67static AV *texture_av;
68
69static struct
70{
71#define GL_FUNC(ptr,name) ptr name;
72#include "glfunc.h"
73#undef GL_FUNC
74} gl;
75
76static void
77gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa)
78{
79 if (gl.BlendFuncSeparate)
80 gl.BlendFuncSeparate (sa, da, saa, daa);
81 else if (gl.BlendFuncSeparateEXT)
82 gl.BlendFuncSeparateEXT (sa, da, saa, daa);
83 else
84 glBlendFunc (sa, da);
85}
86
87static GLuint
88gen_texture ()
89{
90 GLuint name;
91
92 if (AvFILL (texture_av) >= 0)
93 name = (GLuint)(size_t)av_pop (texture_av);
94 else
95 glGenTextures (1, &name);
96
97 return name;
98}
99
100static void
101del_texture (GLuint name)
102{
103 /* make a half-assed attempt at returning the memory used by the texture */
104 /* textures are frequently being reused by cfplus anyway */
105 /*glBindTexture (GL_TEXTURE_2D, name);*/
106 /*glTexImage2D (GL_TEXTURE_2D, 0, GL_ALPHA, 0, 0, 0, GL_ALPHA, GL_UNSIGNED_BYTE, 0);*/
107 av_push (texture_av, (SV *)(size_t)name);
108 glDeleteTextures (1, &name);
109}
110
111#include "texcache.c"
112
113#include "pango-font.c"
114#include "pango-fontmap.c"
115#include "pango-render.c"
116
117typedef Mix_Chunk *CFPlus__MixChunk;
118typedef Mix_Music *CFPlus__MixMusic;
119
120typedef PangoFontDescription *CFPlus__Font;
121
122static int
123shape_attr_p (PangoLayoutRun *run)
124{
125 GSList *attrs = run->item->analysis.extra_attrs;
126
127 while (attrs)
128 {
129 PangoAttribute *attr = attrs->data;
130
131 if (attr->klass->type == PANGO_ATTR_SHAPE)
132 return 1;
133
134 attrs = attrs->next;
135 }
136
137 return 0;
138}
32 139
33typedef struct cf_layout { 140typedef struct cf_layout {
34 PangoLayout *pl; 141 PangoLayout *pl;
142 float r, g, b, a; // default color for rgba mode
35 int base_height; 143 int base_height;
144 CFPlus__Font font;
36} *CFClient__Layout; 145} *CFPlus__Layout;
146
147static CFPlus__Font default_font;
148static PangoContext *opengl_context;
149static PangoFontMap *opengl_fontmap;
37 150
38static void 151static void
39substitute_func (FcPattern *pattern, gpointer data) 152substitute_func (FcPattern *pattern, gpointer data)
40{ 153{
41 FcPatternAddBool (pattern, FC_HINTING , 1); 154 FcPatternAddBool (pattern, FC_HINTING, 1);
155#ifdef FC_HINT_STYLE
156 FcPatternAddBool (pattern, FC_HINT_STYLE, FC_HINT_FULL);
157#endif
42 FcPatternAddBool (pattern, FC_AUTOHINT, 1); 158 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
43} 159}
44 160
45static void 161static void
46layout_update (CFClient__Layout self) 162layout_update_font (CFPlus__Layout self)
47{ 163{
48 /* use a random scale factor to account for unknown descenders, 0.8 works 164 /* use a random scale factor to account for unknown descenders, 0.8 works
49 * reasonably well with bitstream vera 165 * reasonably well with bitstream vera
50 */ 166 */
51 PangoFontDescription *font = pango_context_get_font_description (context); 167 PangoFontDescription *font = self->font ? self->font : default_font;
52 pango_font_description_set_absolute_size (font, self->base_height * (PANGO_SCALE * 8 / 10)); 168
169 pango_font_description_set_absolute_size (font,
170 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
171
172 pango_layout_set_font_description (self->pl, font);
53} 173}
54 174
55static void 175static void
56layout_get_pixel_size (CFClient__Layout self, int *w, int *h) 176layout_get_pixel_size (CFPlus__Layout self, int *w, int *h)
57{ 177{
58 layout_update (self); 178 PangoRectangle rect;
59 179
180 // get_pixel_* wrongly rounds down
60 pango_layout_get_pixel_size (self->pl, w, h); 181 pango_layout_get_extents (self->pl, 0, &rect);
61 182
62 *w = (*w + 3) & ~3; 183 rect.width = (rect.width + PANGO_SCALE - 1) / PANGO_SCALE;
63 if (!*w) *w = 1; 184 rect.height = (rect.height + PANGO_SCALE - 1) / PANGO_SCALE;
64 if (!*h) *h = 1; 185
186 if (!rect.width) rect.width = 1;
187 if (!rect.height) rect.height = 1;
188
189 *w = rect.width;
190 *h = rect.height;
65} 191}
192
193typedef uint16_t tileid;
194typedef uint16_t faceid;
66 195
67typedef struct { 196typedef struct {
68 GLint name; 197 int name;
69 int w, h; 198 int w, h;
70 float s, t; 199 float s, t;
71} mapface; 200 uint8_t r, g, b, a;
201 tileid smoothtile;
202 uint8_t smoothlevel;
203} maptex;
72 204
73typedef struct { 205typedef struct {
206 uint32_t player;
207 tileid tile[3];
74 int16_t darkness; 208 uint16_t darkness;
75 uint16_t face[3]; 209 uint8_t stat_width, stat_hp, flags, smoothmax;
76} mapcell; 210} mapcell;
77 211
78typedef struct { 212typedef struct {
79 int32_t c0, c1; 213 int32_t c0, c1;
80 mapcell *col; 214 mapcell *col;
81} maprow; 215} maprow;
82 216
83typedef struct map { 217typedef struct map {
84 int x, y, w, h; 218 int x, y, w, h;
85 int vx, vy; 219 int ox, oy; /* offset to virtual global coordinate system */
86 int faces; 220 int faces; tileid *face2tile; // [faceid]
87 mapface *face; 221 int texs; maptex *tex; // [tileid]
88 222
89 uint32_t rows; 223 int32_t rows;
90 maprow *row; 224 maprow *row;
91} *CFClient__Map; 225} *CFPlus__Map;
92 226
93static char * 227static char *
94prepend (char *ptr, int sze, int inc) 228prepend (char *ptr, int sze, int inc)
95{ 229{
96 char *p; 230 char *p;
… …
114 248
115#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type)) 249#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
116#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type)) 250#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
117 251
118static void 252static void
253need_facenum (struct map *self, faceid face)
254{
255 while (self->faces <= face)
256 {
257 Append (tileid, self->face2tile, self->faces, self->faces);
258 self->faces *= 2;
259 }
260}
261
262static void
263need_texid (struct map *self, int texid)
264{
265 while (self->texs <= texid)
266 {
267 Append (maptex, self->tex, self->texs, self->texs);
268 self->texs *= 2;
269 }
270}
271
272static maprow *
273map_get_row (CFPlus__Map self, int y)
274{
275 if (0 > y)
276 {
277 int extend = - y + MAP_EXTEND_Y;
278 Prepend (maprow, self->row, self->rows, extend);
279
280 self->rows += extend;
281 self->y += extend;
282 y += extend;
283 }
284 else if (y >= self->rows)
285 {
286 int extend = y - self->rows + MAP_EXTEND_Y;
287 Append (maprow, self->row, self->rows, extend);
288 self->rows += extend;
289 }
290
291 return self->row + y;
292}
293
294static mapcell *
295row_get_cell (maprow *row, int x)
296{
297 if (!row->col)
298 {
299 Newz (0, row->col, MAP_EXTEND_X, mapcell);
300 row->c0 = x - MAP_EXTEND_X / 4;
301 row->c1 = row->c0 + MAP_EXTEND_X;
302 }
303
304 if (row->c0 > x)
305 {
306 int extend = row->c0 - x + MAP_EXTEND_X;
307 Prepend (mapcell, row->col, row->c1 - row->c0, extend);
308 row->c0 -= extend;
309 }
310 else if (x >= row->c1)
311 {
312 int extend = x - row->c1 + MAP_EXTEND_X;
313 Append (mapcell, row->col, row->c1 - row->c0, extend);
314 row->c1 += extend;
315 }
316
317 return row->col + (x - row->c0);
318}
319
320static mapcell *
321map_get_cell (CFPlus__Map self, int x, int y)
322{
323 return row_get_cell (map_get_row (self, y), x);
324}
325
326static void
119map_clear (CFClient__Map self) 327map_clear (CFPlus__Map self)
120{ 328{
121 int r; 329 int r;
122 330
123 for (r = 0; r < self->rows; r++) 331 for (r = 0; r < self->rows; r++)
124 Safefree (self->row[r].col); 332 Safefree (self->row[r].col);
125 333
126 Safefree (self->row); 334 Safefree (self->row);
127 335
128 self->x = 0; 336 self->x = 0;
129 self->y = 0; 337 self->y = 0;
130 self->vx = 0; 338 self->ox = 0;
131 self->vy = 0; 339 self->oy = 0;
132 self->row = 0; 340 self->row = 0;
133 self->rows = 0; 341 self->rows = 0;
134} 342}
135 343
136static void 344static void
137map_blank (CFClient__Map self, int x0, int y0, int w, int h) 345map_blank (CFPlus__Map self, int x0, int y0, int w, int h)
138{ 346{
139 int x, y; 347 int x, y;
348 maprow *row;
349 mapcell *cell;
140 350
141 for (y = y0; y < y0 + h; y++) 351 for (y = y0; y < y0 + h; y++)
142 if (y >= 0) 352 if (y >= 0)
143 { 353 {
144 if (y >= self->rows) 354 if (y >= self->rows)
145 break; 355 break;
146 356
147 maprow *row = self->row + y; 357 row = self->row + y;
148 358
149 for (x = x0; x < x0 + w; x++) 359 for (x = x0; x < x0 + w; x++)
150 if (x >= row->c0) 360 if (x >= row->c0)
151 { 361 {
152 if (x >= row->c1) 362 if (x >= row->c1)
153 break; 363 break;
154 364
155 mapcell *cell = row->col + (x - row->c0); 365 cell = row->col + x - row->c0;
366
156 cell->darkness = -1; 367 cell->darkness = 0;
368 cell->stat_hp = 0;
157 cell->face [2] = 0; 369 cell->flags = 0;
370 cell->player = 0;
158 } 371 }
159 } 372 }
160} 373}
161 374
375typedef struct {
376 tileid tile;
377 uint8_t x, y, level;
378} smooth_key;
379
380static void
381smooth_or_bits (HV *hv, smooth_key *key, IV bits)
382{
383 SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1);
384
385 if (SvIOK (*sv))
386 SvIV_set (*sv, SvIVX (*sv) | bits);
387 else
388 sv_setiv (*sv, bits);
389}
390
391static void
392music_finished (void)
393{
394 SDL_UserEvent ev;
395
396 ev.type = SDL_USEREVENT;
397 ev.code = 0;
398 ev.data1 = 0;
399 ev.data2 = 0;
400
401 SDL_PushEvent ((SDL_Event *)&ev);
402}
403
404static void
405channel_finished (int channel)
406{
407 SDL_UserEvent ev;
408
409 ev.type = SDL_USEREVENT;
410 ev.code = 1;
411 ev.data1 = (void *)(long)channel;
412 ev.data2 = 0;
413
414 SDL_PushEvent ((SDL_Event *)&ev);
415}
416
417static unsigned int
418minpot (unsigned int n)
419{
420 if (!n)
421 return 0;
422
423 --n;
424
425 n |= n >> 1;
426 n |= n >> 2;
427 n |= n >> 4;
428 n |= n >> 8;
429 n |= n >> 16;
430
431 return n + 1;
432}
433
434/* SDL should provide this, really. */
435#define SDLK_MODIFIER_MIN 300
436#define SDLK_MODIFIER_MAX 314
437
438/******************************************************************************/
439
440static GV *draw_x_gv, *draw_y_gv, *draw_w_gv, *draw_h_gv;
441static GV *hover_gv;
442
443static int
444within_widget (SV *widget, NV x, NV y)
445{
446 HV *self;
447 SV **svp;
448 NV wx, ww, wy, wh;
449
450 if (!SvROK (widget))
451 return 0;
452
453 self = (HV *)SvRV (widget);
454
455 if (SvTYPE (self) != SVt_PVHV)
456 return 0;
457
458 svp = hv_fetch (self, "y", 1, 0); wy = svp ? SvNV (*svp) : 0.;
459 if (y < wy)
460 return 0;
461
462 svp = hv_fetch (self, "h", 1, 0); wh = svp ? SvNV (*svp) : 0.;
463 if (y >= wy + wh)
464 return 0;
465
466 svp = hv_fetch (self, "x", 1, 0); wx = svp ? SvNV (*svp) : 0.;
467 if (x < wx)
468 return 0;
469
470 svp = hv_fetch (self, "w", 1, 0); ww = svp ? SvNV (*svp) : 0.;
471 if (x >= wx + ww)
472 return 0;
473
474 svp = hv_fetch (self, "can_events", sizeof ("can_events") - 1, 0);
475 if (!svp || !SvTRUE (*svp))
476 return 0;
477
478 return 1;
479}
480
162MODULE = CFClient PACKAGE = CFClient 481MODULE = CFPlus PACKAGE = CFPlus
163 482
164PROTOTYPES: ENABLE 483PROTOTYPES: ENABLE
165 484
166BOOT: 485BOOT:
167{ 486{
168 fontmap = pango_ft2_font_map_new (); 487 HV *stash = gv_stashpv ("CFPlus", 1);
488 static const struct {
489 const char *name;
490 IV iv;
491 } *civ, const_iv[] = {
492# define const_iv(name) { # name, (IV)name }
493 const_iv (SDLK_MODIFIER_MIN),
494 const_iv (SDLK_MODIFIER_MAX),
495
496 const_iv (SDL_ACTIVEEVENT),
497 const_iv (SDL_KEYDOWN),
498 const_iv (SDL_KEYUP),
499 const_iv (SDL_MOUSEMOTION),
500 const_iv (SDL_MOUSEBUTTONDOWN),
501 const_iv (SDL_MOUSEBUTTONUP),
502 const_iv (SDL_JOYAXISMOTION),
503 const_iv (SDL_JOYBALLMOTION),
504 const_iv (SDL_JOYHATMOTION),
505 const_iv (SDL_JOYBUTTONDOWN),
506 const_iv (SDL_JOYBUTTONUP),
507 const_iv (SDL_QUIT),
508 const_iv (SDL_SYSWMEVENT),
509 const_iv (SDL_EVENT_RESERVEDA),
510 const_iv (SDL_EVENT_RESERVEDB),
511 const_iv (SDL_VIDEORESIZE),
512 const_iv (SDL_VIDEOEXPOSE),
513 const_iv (SDL_USEREVENT),
514
515 const_iv (SDL_APPINPUTFOCUS),
516 const_iv (SDL_APPMOUSEFOCUS),
517 const_iv (SDL_APPACTIVE),
518
519 const_iv (SDLK_KP0),
520 const_iv (SDLK_KP1),
521 const_iv (SDLK_KP2),
522 const_iv (SDLK_KP3),
523 const_iv (SDLK_KP4),
524 const_iv (SDLK_KP5),
525 const_iv (SDLK_KP6),
526 const_iv (SDLK_KP7),
527 const_iv (SDLK_KP8),
528 const_iv (SDLK_KP9),
529 const_iv (SDLK_KP_PERIOD),
530 const_iv (SDLK_KP_DIVIDE),
531 const_iv (SDLK_KP_MULTIPLY),
532 const_iv (SDLK_KP_MINUS),
533 const_iv (SDLK_KP_PLUS),
534 const_iv (SDLK_KP_ENTER),
535 const_iv (SDLK_KP_EQUALS),
536 const_iv (SDLK_UP),
537 const_iv (SDLK_DOWN),
538 const_iv (SDLK_RIGHT),
539 const_iv (SDLK_LEFT),
540 const_iv (SDLK_INSERT),
541 const_iv (SDLK_HOME),
542 const_iv (SDLK_END),
543 const_iv (SDLK_PAGEUP),
544 const_iv (SDLK_PAGEDOWN),
545 const_iv (SDLK_F1),
546 const_iv (SDLK_F2),
547 const_iv (SDLK_F3),
548 const_iv (SDLK_F4),
549 const_iv (SDLK_F5),
550 const_iv (SDLK_F6),
551 const_iv (SDLK_F7),
552 const_iv (SDLK_F8),
553 const_iv (SDLK_F9),
554 const_iv (SDLK_F10),
555 const_iv (SDLK_F11),
556 const_iv (SDLK_F12),
557 const_iv (SDLK_F13),
558 const_iv (SDLK_F14),
559 const_iv (SDLK_F15),
560 const_iv (SDLK_NUMLOCK),
561 const_iv (SDLK_CAPSLOCK),
562 const_iv (SDLK_SCROLLOCK),
563 const_iv (SDLK_RSHIFT),
564 const_iv (SDLK_LSHIFT),
565 const_iv (SDLK_RCTRL),
566 const_iv (SDLK_LCTRL),
567 const_iv (SDLK_RALT),
568 const_iv (SDLK_LALT),
569 const_iv (SDLK_RMETA),
570 const_iv (SDLK_LMETA),
571 const_iv (SDLK_LSUPER),
572 const_iv (SDLK_RSUPER),
573 const_iv (SDLK_MODE),
574 const_iv (SDLK_COMPOSE),
575 const_iv (SDLK_HELP),
576 const_iv (SDLK_PRINT),
577 const_iv (SDLK_SYSREQ),
578 const_iv (SDLK_BREAK),
579 const_iv (SDLK_MENU),
580 const_iv (SDLK_POWER),
581 const_iv (SDLK_EURO),
582 const_iv (SDLK_UNDO),
583
584 const_iv (KMOD_NONE),
585 const_iv (KMOD_SHIFT),
586 const_iv (KMOD_LSHIFT),
587 const_iv (KMOD_RSHIFT),
588 const_iv (KMOD_CTRL),
589 const_iv (KMOD_LCTRL),
590 const_iv (KMOD_RCTRL),
591 const_iv (KMOD_ALT),
592 const_iv (KMOD_LALT),
593 const_iv (KMOD_RALT),
594 const_iv (KMOD_META),
595 const_iv (KMOD_LMETA),
596 const_iv (KMOD_RMETA),
597 const_iv (KMOD_NUM),
598 const_iv (KMOD_CAPS),
599 const_iv (KMOD_MODE),
600# undef const_iv
601 };
602
603 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
604 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
605
606 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
607 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
608}
609
610void
611weaken (SV *rv)
612 PROTOTYPE: $
613 CODE:
614 sv_rvweaken (rv);
615
616int
617in_destruct ()
618 CODE:
619 RETVAL = PL_main_cv == Nullcv;
620 OUTPUT:
621 RETVAL
622
623NV floor (NV x)
624
625NV ceil (NV x)
626
627void
628pango_init ()
629 CODE:
630{
631 opengl_fontmap = pango_opengl_font_map_new ();
169 pango_ft2_font_map_set_default_substitute ((PangoFT2FontMap *)fontmap, substitute_func, 0, 0); 632 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
170 context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)fontmap); 633 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
171} 634}
172
173void
174lowdelay (int fd, int val = 1)
175 CODE:
176 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val));
177 635
178char * 636char *
179gl_version () 637SDL_GetError ()
638
639int
640SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)
641
642void
643SDL_Quit ()
644
645void
646SDL_ListModes (int rgb, int alpha)
180 CODE: 647 PPCODE:
181 RETVAL = (char *)glGetString (GL_VERSION); 648{
649 SDL_Rect **m;
650
651 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
652 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
653 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
654 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
655
656 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15);
657 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE , 0);
658
659 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE , 0);
660 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
661 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
662 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
663
664 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
665#if SDL_VERSION_ATLEAST(1,2,10)
666 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
667 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
668#endif
669
670 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
671
672 if (m && m != (SDL_Rect **)-1)
673 while (*m)
674 {
675 if ((*m)->w >= 640 && (*m)->h >= 480)
676 {
677 AV *av = newAV ();
678 av_push (av, newSViv ((*m)->w));
679 av_push (av, newSViv ((*m)->h));
680 av_push (av, newSViv (rgb));
681 av_push (av, newSViv (alpha));
682 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
683 }
684
685 ++m;
686 }
687}
688
689int
690SDL_SetVideoMode (int w, int h, int rgb, int alpha, int fullscreen)
691 CODE:
692{
693 SDL_EnableUNICODE (1);
694 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
695
696 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
697 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
698 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
699 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
700
701 RETVAL = !!SDL_SetVideoMode (
702 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0)
703 );
704
705 if (RETVAL)
706 {
707 av_clear (texture_av);
708
709 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+");
710#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
711#include "glfunc.h"
712#undef GL_FUNC
713 }
714}
182 OUTPUT: 715 OUTPUT:
183 RETVAL 716 RETVAL
184 717
718void
719SDL_GL_SwapBuffers ()
720
185char * 721char *
186gl_extensions () 722SDL_GetKeyName (int sym)
723
724int
725SDL_GetAppState ()
726
727void
728poll_events ()
187 CODE: 729 PPCODE:
188 RETVAL = (char *)glGetString (GL_EXTENSIONS); 730{
189 OUTPUT: 731 SDL_Event ev;
190 RETVAL 732
733 SDL_PumpEvents ();
734 while (SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_ALLEVENTS) > 0)
735 {
736 HV *hv = newHV ();
737 hv_store (hv, "type", 4, newSViv (ev.type), 0);
738
739 switch (ev.type)
740 {
741 case SDL_KEYDOWN:
742 case SDL_KEYUP:
743 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
744 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
745 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0);
746 hv_store (hv, "cmod", 4, newSViv (SDL_GetModState ()), 0); /* current mode */
747 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
748 break;
749
750 case SDL_ACTIVEEVENT:
751 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
752 hv_store (hv, "state", 5, newSViv (ev.active.state), 0);
753 break;
754
755 case SDL_MOUSEMOTION:
756 {
757 int state = ev.motion.state;
758 int x = ev.motion.x;
759 int y = ev.motion.y;
760 int xrel = ev.motion.xrel;
761 int yrel = ev.motion.yrel;
762
763 /* do simplistic event compression */
764 while (SDL_PeepEvents (&ev, 1, SDL_PEEKEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)) > 0
765 && state == ev.motion.state)
766 {
767 xrel += ev.motion.xrel;
768 yrel += ev.motion.yrel;
769 x = ev.motion.x;
770 y = ev.motion.y;
771 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
772 }
773
774 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);
775 hv_store (hv, "state", 5, newSViv (state), 0);
776 hv_store (hv, "x", 1, newSViv (x), 0);
777 hv_store (hv, "y", 1, newSViv (y), 0);
778 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
779 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
780 }
781 break;
782
783 case SDL_MOUSEBUTTONDOWN:
784 case SDL_MOUSEBUTTONUP:
785 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);
786
787 hv_store (hv, "button", 6, newSViv (ev.button.button), 0);
788 hv_store (hv, "state", 5, newSViv (ev.button.state), 0);
789 hv_store (hv, "x", 1, newSViv (ev.button.x), 0);
790 hv_store (hv, "y", 1, newSViv (ev.button.y), 0);
791 break;
792
793 case SDL_USEREVENT:
794 hv_store (hv, "code", 4, newSViv (ev.user.code), 0);
795 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0);
796 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0);
797 break;
798 }
799
800 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("CFPlus::UI::Event", 1))));
801 }
802}
803
804int
805Mix_OpenAudio (int frequency = 48000, int format = MIX_DEFAULT_FORMAT, int channels = 1, int chunksize = 2048)
806 POSTCALL:
807 Mix_HookMusicFinished (music_finished);
808 Mix_ChannelFinished (channel_finished);
809
810void
811Mix_CloseAudio ()
812
813int
814Mix_AllocateChannels (int numchans = -1)
815
816void
817lowdelay (int fd, int val = 1)
818 CODE:
819 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val));
820
821void
822win32_proxy_info ()
823 PPCODE:
824{
825#ifdef _WIN32
826 char buffer[2048];
827 DWORD buflen;
828
829 EXTEND (SP, 3);
830
831 buflen = sizeof (buffer);
832 if (InternetQueryOption (0, INTERNET_OPTION_PROXY, (void *)buffer, &buflen))
833 if (((INTERNET_PROXY_INFO *)buffer)->dwAccessType == INTERNET_OPEN_TYPE_PROXY)
834 {
835 PUSHs (newSVpv (((INTERNET_PROXY_INFO *)buffer)->lpszProxy, 0));
836
837 buflen = sizeof (buffer);
838 if (InternetQueryOption (0, INTERNET_OPTION_PROXY_USERNAME, (void *)buffer, &buflen))
839 {
840 PUSHs (newSVpv (buffer, 0));
841
842 buflen = sizeof (buffer);
843 if (InternetQueryOption (0, INTERNET_OPTION_PROXY_PASSWORD, (void *)buffer, &buflen))
844 PUSHs (newSVpv (buffer, 0));
845 }
846 }
847#endif
848}
191 849
192void 850void
193add_font (char *file) 851add_font (char *file)
194 CODE: 852 CODE:
195 FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */ 853 FcConfigAppFontAddFile (0, (const FcChar8 *)file);
196
197void
198set_font (char *file)
199 CODE:
200{
201 int count;
202 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)file, 0, 0, &count);
203 PangoFontDescription *font = pango_fc_font_description_from_pattern (pattern, 0);
204 FcPatternDestroy (pattern);
205 pango_context_set_font_description (context, font);
206}
207 854
208void 855void
209load_image_inline (SV *image_) 856load_image_inline (SV *image_)
210 ALIAS: 857 ALIAS:
211 load_image_file = 1 858 load_image_file = 1
… …
218 SDL_RWops *rw = ix 865 SDL_RWops *rw = ix
219 ? SDL_RWFromFile (image, "r") 866 ? SDL_RWFromFile (image, "r")
220 : SDL_RWFromConstMem (image, image_len); 867 : SDL_RWFromConstMem (image, image_len);
221 868
222 if (!rw) 869 if (!rw)
223 croak ("load_image: unable to open file"); 870 croak ("load_image: %s", SDL_GetError ());
224 871
225 surface = IMG_Load_RW (rw, 1); 872 surface = IMG_Load_RW (rw, 1);
226 if (!surface) 873 if (!surface)
227 croak ("load_image: unable to read file"); 874 croak ("load_image: %s", SDL_GetError ());
228 875
229 fmt.palette = NULL; 876 fmt.palette = NULL;
230 fmt.BitsPerPixel = 32; 877 fmt.BitsPerPixel = 32;
231 fmt.BytesPerPixel = 4; 878 fmt.BytesPerPixel = 4;
879#if SDL_BYTEORDER == SDL_LIL_ENDIAN
232 fmt.Rmask = 0x000000ff; 880 fmt.Rmask = 0x000000ff;
233 fmt.Gmask = 0x0000ff00; 881 fmt.Gmask = 0x0000ff00;
234 fmt.Bmask = 0x00ff0000; 882 fmt.Bmask = 0x00ff0000;
235 fmt.Amask = 0xff000000; 883 fmt.Amask = 0xff000000;
884#else
885 fmt.Rmask = 0xff000000;
886 fmt.Gmask = 0x00ff0000;
887 fmt.Bmask = 0x0000ff00;
888 fmt.Amask = 0x000000ff;
889#endif
236 fmt.Rloss = 0; 890 fmt.Rloss = 0;
237 fmt.Gloss = 0; 891 fmt.Gloss = 0;
238 fmt.Bloss = 0; 892 fmt.Bloss = 0;
239 fmt.Aloss = 0; 893 fmt.Aloss = 0;
240 fmt.Rshift = 0; 894 fmt.Rshift = 0;
… …
244 fmt.colorkey = 0; 898 fmt.colorkey = 0;
245 fmt.alpha = 0; 899 fmt.alpha = 0;
246 900
247 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE); 901 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE);
248 902
903 assert (surface2->pitch == surface2->w * 4);
904
905 SDL_LockSurface (surface2);
249 EXTEND (SP, 5); 906 EXTEND (SP, 6);
250 PUSHs (sv_2mortal (newSViv (surface2->w))); 907 PUSHs (sv_2mortal (newSViv (surface2->w)));
251 PUSHs (sv_2mortal (newSViv (surface2->h))); 908 PUSHs (sv_2mortal (newSViv (surface2->h)));
252 SDL_LockSurface (surface2);
253 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 909 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));
254 SDL_UnlockSurface (surface2);
255 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB))); 910 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));
256 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 911 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
257 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_INT_8_8_8_8_REV))); 912 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
913 SDL_UnlockSurface (surface2);
258 914
259 SDL_FreeSurface (surface); 915 SDL_FreeSurface (surface);
260 SDL_FreeSurface (surface2); 916 SDL_FreeSurface (surface2);
261} 917}
262 918
263void 919void
920average (int x, int y, uint32_t *data)
921 PPCODE:
922{
923 uint32_t r = 0, g = 0, b = 0, a = 0;
924
925 x = y = x * y;
926
927 while (x--)
928 {
929 uint32_t p = *data++;
930
931 r += (p ) & 255;
932 g += (p >> 8) & 255;
933 b += (p >> 16) & 255;
934 a += (p >> 24) & 255;
935 }
936
937 EXTEND (SP, 4);
938 PUSHs (sv_2mortal (newSViv (r / y)));
939 PUSHs (sv_2mortal (newSViv (g / y)));
940 PUSHs (sv_2mortal (newSViv (b / y)));
941 PUSHs (sv_2mortal (newSViv (a / y)));
942}
943
944void
945error (char *message)
946 CODE:
947 fprintf (stderr, "ERROR: %s\n", message);
948#ifdef _WIN32
949 MessageBox (0, message, "Crossfire+ Error", MB_OK | MB_ICONERROR);
950#endif
951
952void
264fatal (char *message) 953fatal (char *message)
265 CODE: 954 CODE:
955 fprintf (stderr, "FATAL: %s\n", message);
956#ifdef _WIN32
957 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR);
958#endif
959 _exit (1);
960
961void
962_exit (int retval = 0)
963 CODE:
266#ifdef WIN32 964#ifdef WIN32
267 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND); 965 ExitThread (retval); // unclean, please beam me up
268#else 966#else
269 fprintf (stderr, "%s\n", message); 967 _exit (retval);
270#endif 968#endif
271 exit (1);
272 969
273MODULE = CFClient PACKAGE = CFClient::Layout 970void
274 971debug ()
275CFClient::Layout
276new (SV *class, int base_height = 10)
277 CODE: 972 CODE:
278 New (0, RETVAL, 1, struct cf_layout); 973{
279 RETVAL->base_height = base_height; 974#if DEBUG
280 RETVAL->pl = pango_layout_new (context); 975 VALGRIND_DO_LEAK_CHECK;
281 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR); 976#endif
977}
978
979MODULE = CFPlus PACKAGE = CFPlus::Font
980
981PROTOTYPES: DISABLE
982
983CFPlus::Font
984new_from_file (SV *class, char *path, int id = 0)
985 CODE:
986{
987 int count;
988 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
989 RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
990 FcPatternDestroy (pattern);
991}
282 OUTPUT: 992 OUTPUT:
283 RETVAL 993 RETVAL
284 994
285void 995void
996DESTROY (CFPlus::Font self)
997 CODE:
998 pango_font_description_free (self);
999
1000void
1001make_default (CFPlus::Font self)
1002 PROTOTYPE: $
1003 CODE:
1004 default_font = self;
1005
1006MODULE = CFPlus PACKAGE = CFPlus::Layout
1007
1008PROTOTYPES: DISABLE
1009
1010void
1011reset_glyph_cache ()
1012 PROTOTYPE:
1013 CODE:
1014 tc_clear ();
1015
1016CFPlus::Layout
1017new (SV *class)
1018 CODE:
1019 New (0, RETVAL, 1, struct cf_layout);
1020
1021 RETVAL->pl = pango_layout_new (opengl_context);
1022 RETVAL->r = 1.;
1023 RETVAL->g = 1.;
1024 RETVAL->b = 1.;
1025 RETVAL->a = 1.;
1026 RETVAL->base_height = MIN_FONT_HEIGHT;
1027 RETVAL->font = 0;
1028
1029 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
1030 layout_update_font (RETVAL);
1031 OUTPUT:
1032 RETVAL
1033
1034void
286DESTROY (CFClient::Layout self) 1035DESTROY (CFPlus::Layout self)
287 CODE: 1036 CODE:
288 g_object_unref (self->pl); 1037 g_object_unref (self->pl);
289 Safefree (self); 1038 Safefree (self);
290 1039
291void 1040void
292set_markup (CFClient::Layout self, SV *text_) 1041set_text (CFPlus::Layout self, SV *text_)
293 CODE: 1042 CODE:
294{ 1043{
295 STRLEN textlen; 1044 STRLEN textlen;
296 char *text = SvPVutf8 (text_, textlen); 1045 char *text = SvPVutf8 (text_, textlen);
297 1046
1047 pango_layout_set_text (self->pl, text, textlen);
1048}
1049
1050void
1051set_markup (CFPlus::Layout self, SV *text_)
1052 CODE:
1053{
1054 STRLEN textlen;
1055 char *text = SvPVutf8 (text_, textlen);
1056
298 pango_layout_set_markup (self->pl, text, textlen); 1057 pango_layout_set_markup (self->pl, text, textlen);
299} 1058}
300 1059
301void 1060void
1061set_shapes (CFPlus::Layout self, ...)
1062 CODE:
1063{
1064 PangoAttrList *attrs = 0;
1065 const char *text = pango_layout_get_text (self->pl);
1066 const char *pos = text;
1067 int arg = 4;
1068
1069 while (arg < items && (pos = strstr (pos, OBJ_STR)))
1070 {
1071 PangoRectangle inkrect, rect;
1072 PangoAttribute *attr;
1073
1074 int x = SvIV (ST (arg - 3));
1075 int y = SvIV (ST (arg - 2));
1076 int w = SvIV (ST (arg - 1));
1077 int h = SvIV (ST (arg ));
1078
1079 inkrect.x = 0;
1080 inkrect.y = 0;
1081 inkrect.width = 0;
1082 inkrect.height = 0;
1083
1084 rect.x = x * PANGO_SCALE;
1085 rect.y = y * PANGO_SCALE;
1086 rect.width = w * PANGO_SCALE;
1087 rect.height = h * PANGO_SCALE;
1088
1089 if (!attrs)
1090 attrs = pango_layout_get_attributes (self->pl);
1091
1092 attr = pango_attr_shape_new (&inkrect, &rect);
1093 attr->start_index = pos - text;
1094 attr->end_index = attr->start_index + sizeof (OBJ_STR) - 1;
1095 pango_attr_list_insert (attrs, attr);
1096
1097 arg += 4;
1098 pos += sizeof (OBJ_STR) - 1;
1099 }
1100
1101 if (attrs)
1102 pango_layout_set_attributes (self->pl, attrs);
1103}
1104
1105void
1106get_shapes (CFPlus::Layout self)
1107 PPCODE:
1108{
1109 PangoLayoutIter *iter = pango_layout_get_iter (self->pl);
1110
1111 do
1112 {
1113 PangoLayoutRun *run = pango_layout_iter_get_run (iter);
1114
1115 if (run && shape_attr_p (run))
1116 {
1117 PangoRectangle extents;
1118 pango_layout_iter_get_run_extents (iter, 0, &extents);
1119
1120 EXTEND (SP, 2);
1121 PUSHs (sv_2mortal (newSViv (PANGO_PIXELS (extents.x))));
1122 PUSHs (sv_2mortal (newSViv (PANGO_PIXELS (extents.y))));
1123 }
1124 }
1125 while (pango_layout_iter_next_run (iter));
1126
1127 pango_layout_iter_free (iter);
1128}
1129
1130int
1131has_wrapped (CFPlus::Layout self)
1132 CODE:
1133{
1134 int lines = 1;
1135 const char *text = pango_layout_get_text (self->pl);
1136
1137 while (*text)
1138 lines += *text++ == '\n';
1139
1140 RETVAL = lines < pango_layout_get_line_count (self->pl);
1141}
1142 OUTPUT:
1143 RETVAL
1144
1145SV *
1146get_text (CFPlus::Layout self)
1147 CODE:
1148 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
1149 sv_utf8_decode (RETVAL);
1150 OUTPUT:
1151 RETVAL
1152
1153void
1154set_foreground (CFPlus::Layout self, float r, float g, float b, float a = 1.)
1155 CODE:
1156 self->r = r;
1157 self->g = g;
1158 self->b = b;
1159 self->a = a;
1160
1161void
1162set_font (CFPlus::Layout self, CFPlus::Font font = 0)
1163 CODE:
1164 if (self->font != font)
1165 {
1166 self->font = font;
1167 layout_update_font (self);
1168 }
1169
1170void
302set_height (CFClient::Layout self, int base_height) 1171set_height (CFPlus::Layout self, int base_height)
303 CODE: 1172 CODE:
1173 if (self->base_height != base_height)
1174 {
304 self->base_height = base_height; 1175 self->base_height = base_height;
1176 layout_update_font (self);
1177 }
305 1178
306void 1179void
307set_width (CFClient::Layout self, int max_width = -1) 1180set_width (CFPlus::Layout self, int max_width = -1)
308 CODE: 1181 CODE:
309 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE); 1182 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE);
310 1183
311void 1184void
1185set_indent (CFPlus::Layout self, int indent)
1186 CODE:
1187 pango_layout_set_indent (self->pl, indent * PANGO_SCALE);
1188
1189void
1190set_spacing (CFPlus::Layout self, int spacing)
1191 CODE:
1192 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE);
1193
1194void
1195set_ellipsise (CFPlus::Layout self, int ellipsise)
1196 CODE:
1197 pango_layout_set_ellipsize (self->pl,
1198 ellipsise == 1 ? PANGO_ELLIPSIZE_START
1199 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE
1200 : ellipsise == 3 ? PANGO_ELLIPSIZE_END
1201 : PANGO_ELLIPSIZE_NONE
1202 );
1203
1204void
1205set_single_paragraph_mode (CFPlus::Layout self, int spm)
1206 CODE:
1207 pango_layout_set_single_paragraph_mode (self->pl, !!spm);
1208
1209void
312size (CFClient::Layout self) 1210size (CFPlus::Layout self)
313 PPCODE: 1211 PPCODE:
314{ 1212{
315 int w, h; 1213 int w, h;
316 1214
317 layout_update (self);
318 layout_get_pixel_size (self, &w, &h); 1215 layout_get_pixel_size (self, &w, &h);
319 1216
320 EXTEND (SP, 2); 1217 EXTEND (SP, 2);
321 PUSHs (sv_2mortal (newSViv (w))); 1218 PUSHs (sv_2mortal (newSViv (w)));
322 PUSHs (sv_2mortal (newSViv (h))); 1219 PUSHs (sv_2mortal (newSViv (h)));
323} 1220}
324 1221
325int 1222int
326xy_to_index (CFClient::Layout self, int x, int y) 1223descent (CFPlus::Layout self)
327 CODE: 1224 CODE:
328{ 1225{
329 int index, trailing; 1226 PangoRectangle rect;
330 1227 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0);
331 layout_update (self); 1228 pango_layout_line_get_pixel_extents (line, 0, &rect);
332 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing); 1229 RETVAL = PANGO_DESCENT (rect);
333
334 RETVAL = index;
335} 1230}
336 OUTPUT: 1231 OUTPUT:
337 RETVAL 1232 RETVAL
338 1233
1234int
1235xy_to_index (CFPlus::Layout self, int x, int y)
1236 CODE:
1237{
1238 int index, trailing;
1239 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);
1240 RETVAL = index + trailing;
1241}
1242 OUTPUT:
1243 RETVAL
1244
339void 1245void
340cursor_pos (CFClient::Layout self, int index) 1246cursor_pos (CFPlus::Layout self, int index)
341 PPCODE: 1247 PPCODE:
342{ 1248{
343 PangoRectangle strong_pos; 1249 PangoRectangle strong_pos;
344 layout_update (self);
345 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1250 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);
346 1251
347 EXTEND (SP, 3); 1252 EXTEND (SP, 3);
348 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1253 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));
349 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1254 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
350 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1255 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));
351} 1256}
352 1257
353void 1258void
354render (CFClient::Layout self) 1259index_to_line_x (CFPlus::Layout self, int index, int trailing = 0)
355 PPCODE: 1260 PPCODE:
356{ 1261{
357 SV *retval; 1262 int line, x;
358 int w, h;
359 FT_Bitmap bitmap;
360 1263
361 layout_update (self); 1264 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
362 layout_get_pixel_size (self, &w, &h); 1265 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
363 1266
364 retval = newSV (w * h);
365 SvPOK_only (retval);
366 SvCUR_set (retval, w * h);
367
368 bitmap.rows = h;
369 bitmap.width = w;
370 bitmap.pitch = w;
371 bitmap.buffer = (unsigned char*)SvPVX (retval);
372 bitmap.num_grays = 256;
373 bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
374
375 memset (bitmap.buffer, 0, w * h);
376
377 pango_ft2_render_layout (&bitmap, self->pl, 0 * PANGO_SCALE, 0 * PANGO_SCALE);
378
379 EXTEND (SP, 3); 1267 EXTEND (SP, 2);
380 PUSHs (sv_2mortal (newSViv (w))); 1268 PUSHs (sv_2mortal (newSViv (line - 1)));
1269 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE)));
1270}
1271
1272void
1273line_x_to_index (CFPlus::Layout self, int line, int x)
1274 PPCODE:
1275{
1276 PangoLayoutLine *lp;
1277 int index, trailing;
1278
1279 if (line < 0)
1280 XSRETURN_EMPTY;
1281
1282 if (!(lp = pango_layout_get_line (self->pl, line)))
1283 XSRETURN_EMPTY; /* do better */
1284
1285 pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing);
1286
1287 EXTEND (SP, 2);
1288 if (GIMME_V == G_SCALAR)
1289 PUSHs (sv_2mortal (newSViv (index + trailing)));
1290 else
1291 {
381 PUSHs (sv_2mortal (newSViv (h))); 1292 PUSHs (sv_2mortal (newSViv (index)));
382 PUSHs (sv_2mortal (retval)); 1293 PUSHs (sv_2mortal (newSViv (trailing)));
1294 }
383} 1295}
384 1296
1297void
1298render (CFPlus::Layout self, float x, float y, int flags = 0)
1299 PPCODE:
1300 pango_opengl_render_layout_subpixel (
1301 self->pl,
1302 x * PANGO_SCALE, y * PANGO_SCALE,
1303 self->r, self->g, self->b, self->a,
1304 flags
1305 );
1306
385MODULE = CFClient PACKAGE = CFClient::Texture 1307MODULE = CFPlus PACKAGE = CFPlus::Texture
386 1308
1309PROTOTYPES: ENABLE
1310
1311int minpot (int n)
1312
387void 1313void
388draw_quad (SV *self, double x, double y, double w = 0, double h = 0) 1314pad (SV *data_, int ow, int oh, int nw, int nh)
1315 CODE:
1316{
1317 if ((nw != ow || nh != oh) && SvOK (data_))
1318 {
1319 STRLEN datalen;
1320 char *data = SvPVbyte (data_, datalen);
1321 int bpp = datalen / (ow * oh);
1322 SV *result_ = sv_2mortal (newSV (nw * nh * bpp));
1323
1324 SvPOK_only (result_);
1325 SvCUR_set (result_, nw * nh * bpp);
1326
1327 memset (SvPVX (result_), 0, nw * nh * bpp);
1328 while (oh--)
1329 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp);
1330
1331 sv_setsv (data_, result_);
1332 }
1333}
1334
1335void
1336draw_quad (SV *self, float x, float y, float w = 0., float h = 0.)
389 PROTOTYPE: $$$;$$ 1337 PROTOTYPE: $$$;$$
1338 ALIAS:
1339 draw_quad_alpha = 1
1340 draw_quad_alpha_premultiplied = 2
390 CODE: 1341 CODE:
391{ 1342{
392 HV *hv = (HV *)SvRV (self); 1343 HV *hv = (HV *)SvRV (self);
393 double s = SvNV (*hv_fetch (hv, "s", 1, 1)); 1344 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
394 double t = SvNV (*hv_fetch (hv, "t", 1, 1)); 1345 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
395 int name = SvIV (*hv_fetch (hv, "name", 4, 1)); 1346 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
396 1347
397 if (items < 5) 1348 if (items < 5)
398 { 1349 {
399 w = SvNV (*hv_fetch (hv, "w", 1, 1)); 1350 w = SvNV (*hv_fetch (hv, "w", 1, 1));
400 h = SvNV (*hv_fetch (hv, "h", 1, 1)); 1351 h = SvNV (*hv_fetch (hv, "h", 1, 1));
401 } 1352 }
402 1353
1354 if (ix)
1355 {
1356 glEnable (GL_BLEND);
1357
1358 if (ix == 2)
1359 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1360 else
1361 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1362 GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1363
1364 glEnable (GL_ALPHA_TEST);
1365 glAlphaFunc (GL_GREATER, 0.01f);
1366 }
1367
403 glBindTexture (GL_TEXTURE_2D, name); 1368 glBindTexture (GL_TEXTURE_2D, name);
1369
404 glBegin (GL_QUADS); 1370 glBegin (GL_QUADS);
405 glTexCoord2d (0, 0); glVertex2d (x , y ); 1371 glTexCoord2f (0, 0); glVertex2f (x , y );
406 glTexCoord2d (0, t); glVertex2d (x , y + h); 1372 glTexCoord2f (0, t); glVertex2f (x , y + h);
407 glTexCoord2d (s, t); glVertex2d (x + w, y + h); 1373 glTexCoord2f (s, t); glVertex2f (x + w, y + h);
408 glTexCoord2d (s, 0); glVertex2d (x + w, y ); 1374 glTexCoord2f (s, 0); glVertex2f (x + w, y );
409 glEnd (); 1375 glEnd ();
410}
411 1376
1377 if (ix)
1378 {
1379 glDisable (GL_ALPHA_TEST);
1380 glDisable (GL_BLEND);
1381 }
1382}
1383
1384IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1385 CODE:
1386{
1387 GLint width;
1388 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
1389 glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
1390 RETVAL = width > 0;
1391}
1392 OUTPUT:
1393 RETVAL
1394
412MODULE = CFClient PACKAGE = CFClient::Map 1395MODULE = CFPlus PACKAGE = CFPlus::Map
413 1396
414CFClient::Map 1397PROTOTYPES: DISABLE
415new (SV *class, int map_width, int map_height) 1398
1399CFPlus::Map
1400new (SV *class)
416 CODE: 1401 CODE:
417 New (0, RETVAL, 1, struct map); 1402 New (0, RETVAL, 1, struct map);
418 RETVAL->x = 0; 1403 RETVAL->x = 0;
419 RETVAL->y = 0; 1404 RETVAL->y = 0;
420 RETVAL->w = map_width; 1405 RETVAL->w = 0;
421 RETVAL->h = map_height; 1406 RETVAL->h = 0;
422 RETVAL->vx = 0; 1407 RETVAL->ox = 0;
423 RETVAL->vy = 0; 1408 RETVAL->oy = 0;
424 RETVAL->faces = 8192; 1409 RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
425 Newz (0, RETVAL->face, RETVAL->faces, mapface); 1410 RETVAL->texs = 8192; Newz (0, RETVAL->tex , RETVAL->texs , maptex);
426 RETVAL->rows = 0; 1411 RETVAL->rows = 0;
427 RETVAL->row = 0; 1412 RETVAL->row = 0;
428 OUTPUT: 1413 OUTPUT:
429 RETVAL 1414 RETVAL
430 1415
431void 1416void
432DESTROY (CFClient::Map self) 1417DESTROY (CFPlus::Map self)
433 CODE: 1418 CODE:
434{ 1419{
435 map_clear (self); 1420 map_clear (self);
436 Safefree (self->face); 1421 Safefree (self->face2tile);
1422 Safefree (self->tex);
437 Safefree (self); 1423 Safefree (self);
438} 1424}
439 1425
440void 1426void
1427resize (CFPlus::Map self, int map_width, int map_height)
1428 CODE:
1429 self->w = map_width;
1430 self->h = map_height;
1431
1432void
441clear (CFClient::Map self) 1433clear (CFPlus::Map self)
442 CODE: 1434 CODE:
443 map_clear (self); 1435 map_clear (self);
444 1436
445void 1437void
1438set_tileid (CFPlus::Map self, int face, int tile)
1439 CODE:
1440{
1441 need_facenum (self, face); self->face2tile [face] = tile;
1442 need_texid (self, tile);
1443}
1444
1445void
1446set_smooth (CFPlus::Map self, int face, int smooth, int level)
1447 CODE:
1448{
1449 tileid texid;
1450 maptex *tex;
1451
1452 if (face < 0 || face >= self->faces)
1453 return;
1454
1455 if (smooth < 0 || smooth >= self->faces)
1456 return;
1457
1458 texid = self->face2tile [face];
1459
1460 if (!texid)
1461 return;
1462
1463 tex = self->tex + texid;
1464 tex->smoothtile = self->face2tile [smooth];
1465 tex->smoothlevel = level;
1466}
1467
1468void
446set_texture (CFClient::Map self, int face, int name, int w, int h, float s, float t) 1469set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
447 CODE: 1470 CODE:
448{ 1471{
449 while (self->faces < face) 1472 need_texid (self, texid);
1473
1474 {
1475 maptex *tex = self->tex + texid;
1476
1477 tex->name = name;
1478 tex->w = w;
1479 tex->h = h;
1480 tex->s = s;
1481 tex->t = t;
1482 tex->r = r;
1483 tex->g = g;
1484 tex->b = b;
1485 tex->a = a;
1486 }
1487
1488 // somewhat hackish, but for textures that require it, it really
1489 // improves the look, and most others don't suffer.
1490 glBindTexture (GL_TEXTURE_2D, name);
1491 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1492 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1493 // use uglier nearest interpolation because linear suffers
1494 // from transparent color bleeding and ugly wrapping effects.
1495 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1496}
1497
1498int
1499ox (CFPlus::Map self)
1500 ALIAS:
1501 oy = 1
1502 x = 2
1503 y = 3
1504 w = 4
1505 h = 5
1506 CODE:
1507 switch (ix)
450 { 1508 {
451 Append (mapface, self->face, self->faces, self->faces); 1509 case 0: RETVAL = self->ox; break;
452 self->faces *= 2; 1510 case 1: RETVAL = self->oy; break;
1511 case 2: RETVAL = self->x; break;
1512 case 3: RETVAL = self->y; break;
1513 case 4: RETVAL = self->w; break;
1514 case 5: RETVAL = self->h; break;
453 } 1515 }
1516 OUTPUT:
1517 RETVAL
454 1518
455 self->face [face].name = name;
456 self->face [face].w = w;
457 self->face [face].h = h;
458 self->face [face].s = s;
459 self->face [face].t = t;
460}
461
462void 1519void
463scroll (CFClient::Map self, int dx, int dy) 1520scroll (CFPlus::Map self, int dx, int dy)
464 CODE: 1521 CODE:
465{ 1522{
466 if (dx > 0) 1523 if (dx > 0)
467 map_blank (self, self->x, self->y, dx - 1, self->h); 1524 map_blank (self, self->x, self->y, dx, self->h);
468 else if (dx < 0) 1525 else if (dx < 0)
469 map_blank (self, self->x + self->w + dx + 1, self->y, 1 - dx, self->h); 1526 map_blank (self, self->x + self->w + dx, self->y, -dx, self->h);
470 1527
471 if (dy > 0) 1528 if (dy > 0)
472 map_blank (self, self->x, self->y, self->w, dy - 1); 1529 map_blank (self, self->x, self->y, self->w, dy);
473 else if (dy < 0) 1530 else if (dy < 0)
474 map_blank (self, self->x, self->y + self->h + dy + 1, self->w, 1 - dy); 1531 map_blank (self, self->x, self->y + self->h + dy, self->w, -dy);
475 1532
476 self->x += dx; 1533 self->ox += dx; self->x += dx;
477 self->y += dy; 1534 self->oy += dy; self->y += dy;
478 1535
479 while (self->y < 0) 1536 while (self->y < 0)
480 { 1537 {
481 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y); 1538 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
482 1539
… …
484 self->y += MAP_EXTEND_Y; 1541 self->y += MAP_EXTEND_Y;
485 } 1542 }
486} 1543}
487 1544
488void 1545void
489map1a_update (CFClient::Map self, SV *data_) 1546map1a_update (CFPlus::Map self, SV *data_, int extmap)
490 CODE: 1547 CODE:
491{ 1548{
492 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 1549 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
493 uint8_t *data_end = (uint8_t *)SvEND (data_); 1550 uint8_t *data_end = (uint8_t *)SvEND (data_);
494 1551 mapcell *cell;
1552 int x, y, flags;
1553
495 while (data < data_end) 1554 while (data < data_end - 1)
496 { 1555 {
497 int flags = (data [0] << 8) + data [1]; data += 2; 1556 flags = (data [0] << 8) + data [1]; data += 2;
498 1557
499 int x = ((flags >> 10) & 63) + self->x; 1558 x = self->x + ((flags >> 10) & 63);
500 int y = ((flags >> 4) & 63) + self->y; 1559 y = self->y + ((flags >> 4) & 63);
501 1560
502 while (y >= self->rows) 1561 cell = map_get_cell (self, x, y);
503 {
504 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
505
506 self->rows += MAP_EXTEND_Y;
507 }
508
509 maprow *row = self->row + y;
510
511 if (!row->col)
512 {
513 Newz (0, row->col, MAP_EXTEND_X, mapcell);
514 row->c0 = self->x - MAP_EXTEND_X / 4;
515 row->c1 = row->c0 + MAP_EXTEND_X;
516 }
517
518 if (row->c0 > x)
519 {
520 int extend = row->c0 - x + MAP_EXTEND_X;
521 Prepend (mapcell, row->col, row->c1 - row->c0, extend);
522 row->c0 -= extend;
523 }
524 else if (x >= row->c1)
525 {
526 int extend = x - row->c1 + MAP_EXTEND_X;
527 Append (mapcell, row->col, row->c1 - row->c0, extend);
528 row->c1 += extend;
529 }
530
531 assert (y >= 0);
532 assert (y < self->rows);
533 assert (x >= row->c0);
534 assert (x < row->c1);
535 mapcell *cell = row->col + (x - row->c0);
536 1562
537 if (flags & 15) 1563 if (flags & 15)
538 { 1564 {
539 if (cell->darkness < 0 && x < self->w && y < self->h) 1565 if (!cell->darkness)
540 { 1566 {
1567 memset (cell, 0, sizeof (*cell));
541 cell->darkness = 0; 1568 cell->darkness = 256;
542 cell->face [0] = 0;
543 cell->face [1] = 0;
544 cell->face [2] = 0;
545 } 1569 }
1570
1571 //TODO: don't trust server data to be in-range(!)
1572
1573 if (flags & 8)
546 1574 {
1575 if (extmap)
1576 {
1577 uint8_t ext, cmd;
1578
1579 do
1580 {
1581 ext = *data++;
1582 cmd = ext & 0x3f;
1583
1584 if (cmd < 4)
1585 cell->darkness = 255 - ext * 64 + 1;
1586 else if (cmd == 5) // health
1587 {
1588 cell->stat_width = 1;
1589 cell->stat_hp = *data++;
1590 }
1591 else if (cmd == 6) // monster width
1592 cell->stat_width = *data++ + 1;
1593 else if (cmd == 0x47)
1594 {
1595 if (*data == 4)
1596 ; // decode player count
1597
1598 data += *data + 1;
1599 }
1600 else if (cmd == 8) // cell flags
1601 cell->flags = *data++;
1602 else if (ext & 0x40) // unknown, multibyte => skip
1603 data += *data + 1;
1604 else
1605 data++;
1606 }
1607 while (ext & 0x80);
1608 }
1609 else
547 cell->darkness = flags & 8 ? *data++ : 255; 1610 cell->darkness = *data++ + 1;
1611 }
548 1612
549 if (flags & 4) 1613 if (flags & 4)
550 { 1614 {
551 cell->face [0] = (data [0] << 8) + data [1]; data += 2; 1615 faceid face = (data [0] << 8) + data [1]; data += 2;
1616 need_facenum (self, face);
1617 cell->tile [0] = self->face2tile [face];
552 } 1618 }
553 1619
554 if (flags & 2) 1620 if (flags & 2)
555 { 1621 {
556 cell->face [1] = (data [0] << 8) + data [1]; data += 2; 1622 faceid face = (data [0] << 8) + data [1]; data += 2;
1623 need_facenum (self, face);
1624 cell->tile [1] = self->face2tile [face];
557 } 1625 }
558 1626
559 if (flags & 1) 1627 if (flags & 1)
560 { 1628 {
561 cell->face [2] = (data [0] << 8) + data [1]; data += 2; 1629 faceid face = (data [0] << 8) + data [1]; data += 2;
1630 need_facenum (self, face);
1631 cell->tile [2] = self->face2tile [face];
562 } 1632 }
563 } 1633 }
564 else 1634 else
1635 cell->darkness = 0;
1636 }
1637}
1638
1639SV *
1640mapmap (CFPlus::Map self, int x0, int y0, int w, int h)
1641 CODE:
1642{
1643 int x1, x;
1644 int y1, y;
1645 int z;
1646 SV *map_sv = newSV (w * h * sizeof (uint32_t));
1647 uint32_t *map = (uint32_t *)SvPVX (map_sv);
1648
1649 SvPOK_only (map_sv);
1650 SvCUR_set (map_sv, w * h * sizeof (uint32_t));
1651
1652 x0 += self->x; x1 = x0 + w;
1653 y0 += self->y; y1 = y0 + h;
1654
1655 for (y = y0; y < y1; y++)
1656 {
1657 maprow *row = 0 <= y && y < self->rows
1658 ? self->row + y
1659 : 0;
1660
1661 for (x = x0; x < x1; x++)
565 { 1662 {
566 cell->darkness = -1; 1663 int r = 32, g = 32, b = 32, a = 192;
567 cell->face [2] = 0; 1664
1665 if (row && row->c0 <= x && x < row->c1)
1666 {
1667 mapcell *cell = row->col + (x - row->c0);
1668
1669 for (z = 0; z <= 0; z++)
1670 {
1671 maptex tex = self->tex [cell->tile [z]];
1672 int a0 = 255 - tex.a;
1673 int a1 = tex.a;
1674
1675 r = (r * a0 + tex.r * a1) / 255;
1676 g = (g * a0 + tex.g * a1) / 255;
1677 b = (b * a0 + tex.b * a1) / 255;
1678 a = (a * a0 + tex.a * a1) / 255;
1679 }
1680 }
1681
1682 *map++ = (r )
1683 | (g << 8)
1684 | (b << 16)
1685 | (a << 24);
568 } 1686 }
569 } 1687 }
570}
571 1688
1689 RETVAL = map_sv;
1690}
1691 OUTPUT:
1692 RETVAL
1693
572void 1694void
573draw (CFClient::Map self, int x0, int y0, int sw, int sh) 1695draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T)
574 CODE: 1696 CODE:
575{ 1697{
576 int vx = self->vx = self->w >= sw 1698 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
577 ? self->x + (self->w - sw) / 2 1699 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
578 : MIN (self->x, MAX (self->x + self->w - sw + 1, self->vx)); 1700 static uint8_t smooth_max[256][256]; // egad, fats and wasteful on memory (64k)
1701 smooth_key skey;
1702 int x, y, z;
1703 int last_name;
579 1704
580 int vy = self->vy = self->h >= sh 1705 // thats current max. sorry.
581 ? self->y + (self->h - sh) / 2 1706 if (sw > 255) sw = 255;
582 : MIN (self->y, MAX (self->y + self->h - sh + 1, self->vy)); 1707 if (sh > 255) sh = 255;
1708
1709 // clear key, in case of extra padding
1710 memset (&skey, 0, sizeof (skey));
583 1711
584 glColor4ub (255, 255, 255, 255); 1712 glColor4ub (255, 255, 255, 255);
585 1713
1714 glEnable (GL_BLEND);
586 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 1715 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
587 glEnable (GL_BLEND);
588 glEnable (GL_TEXTURE_2D); 1716 glEnable (GL_TEXTURE_2D);
589 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 1717 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
590 1718
591 int x, y, z;
592
593 int last_name = 0;
594
595 glBegin (GL_QUADS); 1719 glBegin (GL_QUADS);
596 1720
1721 last_name = 0;
1722
1723 mx += self->x;
1724 my += self->y;
1725
1726 // first pass: determine smooth_max
1727 // rather ugly, if you ask me
1728 // could also be stored inside mapcell and updated on change
1729 memset (smooth_max, 0, sizeof (smooth_max));
1730
1731 for (y = 0; y < sh; y++)
1732 if (0 <= y + my && y + my < self->rows)
1733 {
1734 maprow *row = self->row + (y + my);
1735
1736 for (x = 0; x < sw; x++)
1737 if (row->c0 <= x + mx && x + mx < row->c1)
1738 {
1739 mapcell *cell = row->col + (x + mx - row->c0);
1740
1741 smooth_max[x + 1][y + 1] =
1742 MAX (self->tex [cell->tile [0]].smoothlevel,
1743 MAX (self->tex [cell->tile [1]].smoothlevel,
1744 self->tex [cell->tile [2]].smoothlevel));
1745 }
1746 }
1747
597 for (z = 0; z < 3; z++) 1748 for (z = 0; z <= 2; z++)
1749 {
1750 memset (smooth_level, 0, sizeof (smooth_level));
1751
598 for (y = 0; y < sh; y++) 1752 for (y = 0; y < sh; y++)
599 if (0 <= y + vy && y + vy < self->rows) 1753 if (0 <= y + my && y + my < self->rows)
1754 {
1755 maprow *row = self->row + (y + my);
1756
1757 for (x = 0; x < sw; x++)
1758 if (row->c0 <= x + mx && x + mx < row->c1)
1759 {
1760 mapcell *cell = row->col + (x + mx - row->c0);
1761 tileid tile = cell->tile [z];
1762
1763 if (tile)
1764 {
1765 maptex tex = self->tex [tile];
1766 int px = (x + 1) * T - tex.w;
1767 int py = (y + 1) * T - tex.h;
1768
1769 // suppressing texture state switches here
1770 // is only moderately effective, but worth the extra effort
1771 if (last_name != tex.name)
1772 {
1773 if (!tex.name)
1774 tex = self->tex [2]; /* missing, replace by noface */
1775
1776 glEnd ();
1777 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1778 glBegin (GL_QUADS);
1779 }
1780
1781 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1782 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1783 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1784 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1785
1786 if (cell->flags && z == 2)
1787 {
1788 if (cell->flags & 1)
1789 {
1790 maptex tex = self->tex [1];
1791 int px = x * T + T * 2 / 32;
1792 int py = y * T - T * 6 / 32;
1793
1794 glEnd ();
1795 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1796 glBegin (GL_QUADS);
1797
1798 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1799 glTexCoord2f (0 , tex.t); glVertex2f (px , py + T);
1800 glTexCoord2f (tex.s, tex.t); glVertex2f (px + T, py + T);
1801 glTexCoord2f (tex.s, 0 ); glVertex2f (px + T, py );
1802 }
1803 }
1804
1805 // update smooth hash
1806 if (tex.smoothtile)
1807 {
1808 skey.tile = tex.smoothtile;
1809 skey.level = tex.smoothlevel;
1810
1811 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31);
1812
1813 // add bits to current tile and all neighbours. skey.x|y is
1814 // shifted +1|+1 so we always stay positive.
1815
1816 // bits is ___n cccc CCCC bbbb
1817 // n do not draw borders&corners
1818 // c draw these corners, but...
1819 // C ... not these
1820 // b draw these borders
1821
1822 // borders: 1 ┃· 2 ━━ 4 ·┃ 8 ··
1823 // ┃· ·· ·┃ ━━
1824
1825 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1826 // ·· ·· ·┏ ┓·
1827
1828 // full tile
1829 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000);
1830
1831 // borders
1832 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091);
1833 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032);
1834 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064);
1835 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8);
1836
1837 // corners
1838 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);
1839 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);
1840 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);
1841 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);
1842 }
1843 }
1844 }
1845 }
1846
1847 // go through all smoothlevels, lowest to highest, then draw.
1848 // this is basically counting sort
1849 {
1850 int w, b;
1851
1852 for (w = 0; w < 256 / 32; ++w)
1853 {
1854 uint32_t smask = smooth_level [w];
1855 if (smask)
1856 for (b = 0; b < 32; ++b)
1857 if (smask & (((uint32_t)1) << b))
1858 {
1859 int level = (w << 5) | b;
1860 HE *he;
1861
1862 hv_iterinit (smooth);
1863 while ((he = hv_iternext (smooth)))
1864 {
1865 smooth_key *skey = (smooth_key *)HeKEY (he);
1866 IV bits = SvIVX (HeVAL (he));
1867
1868 if (!(bits & 0x1000)
1869 && skey->level == level
1870 && level > smooth_max [skey->x][skey->y])
1871 {
1872 maptex tex = self->tex [skey->tile];
1873 int px = (((int)skey->x) - 1) * T;
1874 int py = (((int)skey->y) - 1) * T;
1875 int border = bits & 15;
1876 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1877 float dx = tex.s * .0625f; // 16 images/row
1878 float dy = tex.t * .5f ; // 2 images/column
1879
1880 // this time naively avoiding texture state changes
1881 // save gobs of state changes.
1882 if (last_name != tex.name)
1883 {
1884 if (!tex.name)
1885 continue; // smoothing not yet available
1886
1887 glEnd ();
1888 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1889 glBegin (GL_QUADS);
1890 }
1891
1892 if (border)
1893 {
1894 float ox = border * dx;
1895
1896 glTexCoord2f (ox , 0.f ); glVertex2f (px , py );
1897 glTexCoord2f (ox , dy ); glVertex2f (px , py + T);
1898 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py + T);
1899 glTexCoord2f (ox + dx, 0.f ); glVertex2f (px + T, py );
1900 }
1901
1902 if (corner)
1903 {
1904 float ox = corner * dx;
1905
1906 glTexCoord2f (ox , dy ); glVertex2f (px , py );
1907 glTexCoord2f (ox , dy * 2.f); glVertex2f (px , py + T);
1908 glTexCoord2f (ox + dx, dy * 2.f); glVertex2f (px + T, py + T);
1909 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py );
1910 }
1911 }
1912 }
1913 }
1914 }
1915 }
1916
1917 hv_clear (smooth);
1918 }
1919
1920 glEnd ();
1921
1922 glDisable (GL_TEXTURE_2D);
1923 glDisable (GL_BLEND);
1924
1925 // top layer: overlays such as the health bar
1926 for (y = 0; y < sh; y++)
1927 if (0 <= y + my && y + my < self->rows)
1928 {
1929 maprow *row = self->row + (y + my);
1930
1931 for (x = 0; x < sw; x++)
1932 if (row->c0 <= x + mx && x + mx < row->c1)
1933 {
1934 mapcell *cell = row->col + (x + mx - row->c0);
1935
1936 int px = x * T;
1937 int py = y * T;
1938
1939 if (cell->stat_hp)
1940 {
1941 int width = cell->stat_width * T;
1942 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
1943
1944 glColor3ub (0, 0, 0);
1945 glRectf (px + 1, py - thick - 2,
1946 px + width - 1, py);
1947
1948 glColor3ub (cell->stat_hp, 255 - cell->stat_hp, 0);
1949 glRectf (px + 2,
1950 py - thick - 1,
1951 px + width - 2 - cell->stat_hp * (width - 4) / 255, py - 1);
1952 }
1953 }
1954 }
1955}
1956
1957void
1958draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data)
1959 CODE:
1960{
1961 static float color[16][3] = {
1962 { 0.00F, 0.00F, 0.00F },
1963 { 1.00F, 1.00F, 1.00F },
1964 { 0.00F, 0.00F, 0.55F },
1965 { 1.00F, 0.00F, 0.00F },
1966
1967 { 1.00F, 0.54F, 0.00F },
1968 { 0.11F, 0.56F, 1.00F },
1969 { 0.93F, 0.46F, 0.00F },
1970 { 0.18F, 0.54F, 0.34F },
1971
1972 { 0.56F, 0.73F, 0.56F },
1973 { 0.80F, 0.80F, 0.80F },
1974 { 0.55F, 0.41F, 0.13F },
1975 { 0.99F, 0.77F, 0.26F },
1976
1977 { 0.74F, 0.65F, 0.41F },
1978
1979 { 0.00F, 1.00F, 1.00F },
1980 { 1.00F, 0.00F, 1.00F },
1981 { 1.00F, 1.00F, 0.00F },
1982 };
1983
1984 int x, y;
1985
1986 glEnable (GL_TEXTURE_2D);
1987 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1988 glEnable (GL_BLEND);
1989 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1990 glBegin (GL_QUADS);
1991
1992 for (y = 0; y < h; y++)
1993 for (x = 0; x < w; x++)
1994 {
1995 unsigned char m = data [x + y * w];
1996
1997 if (m)
1998 {
1999 float *c = color [m & 15];
2000
2001 float tx1 = m & 0x40 ? 0.5 : 0.;
2002 float tx2 = tx1 + 0.5;
2003
2004 glColor4f (c[0], c[1], c[2], 0.75);
2005 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2006 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2007 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2008 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2009 }
2010 }
2011
2012 glEnd ();
2013 glDisable (GL_BLEND);
2014 glDisable (GL_TEXTURE_2D);
2015}
2016
2017void
2018fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh)
2019 PPCODE:
2020{
2021 int x, y;
2022 int sw1 = sw + 2;
2023 int sh1 = sh + 2;
2024 int sh3 = sh * 3;
2025 int sw34 = (sw * 3 + 3) & ~3;
2026 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2027 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));
2028 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2029
2030 SvPOK_only (darkness3_sv);
2031 SvCUR_set (darkness3_sv, sw34 * sh3);
2032
2033 mx += self->x - 1;
2034 my += self->y - 1;
2035
2036 memset (darkness1, 255, sw1 * sh1);
2037
2038 for (y = 0; y < sh1; y++)
2039 if (0 <= y + my && y + my < self->rows)
2040 {
2041 maprow *row = self->row + (y + my);
2042
2043 for (x = 0; x < sw1; x++)
2044 if (row->c0 <= x + mx && x + mx < row->c1)
2045 {
2046 mapcell *cell = row->col + (x + mx - row->c0);
2047
2048 darkness1 [y * sw1 + x] = cell->darkness
2049 ? 255 - (cell->darkness - 1)
2050 : 255 - FOW_DARKNESS;
2051 }
2052 }
2053
2054 for (y = 0; y < sh; ++y)
2055 for (x = 0; x < sw; ++x)
2056 {
2057 uint8_t d11 = darkness1 [(y ) * sw1 + x ];
2058 uint8_t d21 = darkness1 [(y ) * sw1 + x + 1];
2059 uint8_t d31 = darkness1 [(y ) * sw1 + x + 2];
2060 uint8_t d12 = darkness1 [(y + 1) * sw1 + x ];
2061 uint8_t d22 = darkness1 [(y + 1) * sw1 + x + 1];
2062 uint8_t d32 = darkness1 [(y + 1) * sw1 + x + 2];
2063 uint8_t d13 = darkness1 [(y + 2) * sw1 + x ];
2064 uint8_t d23 = darkness1 [(y + 2) * sw1 + x + 1];
2065 uint8_t d33 = darkness1 [(y + 2) * sw1 + x + 2];
2066
2067 uint8_t r11 = (d11 + d21 + d12) / 3;
2068 uint8_t r21 = d21;
2069 uint8_t r31 = (d21 + d31 + d32) / 3;
2070
2071 uint8_t r12 = d12;
2072 uint8_t r22 = d22;
2073 uint8_t r32 = d32;
2074
2075 uint8_t r13 = (d13 + d23 + d12) / 3;
2076 uint8_t r23 = d23;
2077 uint8_t r33 = (d23 + d33 + d32) / 3;
2078
2079 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11);
2080 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21);
2081 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31);
2082 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12);
2083 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22);
2084 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32);
2085 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13);
2086 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23);
2087 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33);
2088 }
2089
2090 free (darkness1);
2091
2092 EXTEND (SP, 3);
2093 PUSHs (sv_2mortal (newSViv (sw34)));
2094 PUSHs (sv_2mortal (newSViv (sh3)));
2095 PUSHs (darkness3_sv);
2096}
2097
2098SV *
2099get_rect (CFPlus::Map self, int x0, int y0, int w, int h)
2100 CODE:
2101{
2102 int x, y, x1, y1;
2103 SV *data_sv = newSV (w * h * 7 + 5);
2104 uint8_t *data = (uint8_t *)SvPVX (data_sv);
2105
2106 *data++ = 0; /* version 0 format */
2107 *data++ = w >> 8; *data++ = w;
2108 *data++ = h >> 8; *data++ = h;
2109
2110 // we need to do this 'cause we don't keep an absolute coord system for rows
2111 // TODO: treat rows as we treat columns
2112 map_get_row (self, y0 + self->y - self->oy);//D
2113 map_get_row (self, y0 + self->y - self->oy + h - 1);//D
2114
2115 x0 += self->x - self->ox;
2116 y0 += self->y - self->oy;
2117
2118 x1 = x0 + w;
2119 y1 = y0 + h;
2120
2121 for (y = y0; y < y1; y++)
2122 {
2123 maprow *row = 0 <= y && y < self->rows
2124 ? self->row + y
2125 : 0;
2126
2127 for (x = x0; x < x1; x++)
600 { 2128 {
601 maprow *row = self->row + (y + vy);
602
603 for (x = 0; x < sw; x++)
604 if (row->c0 <= x + vx && x + vx < row->c1) 2129 if (row && row->c0 <= x && x < row->c1)
605 { 2130 {
606 mapcell *cell = row->col + (x + vx - row->c0); 2131 mapcell *cell = row->col + (x - row->c0);
607 uint16_t face = cell->face [z]; 2132 uint8_t flags = 0;
608 2133
2134 if (cell->tile [0]) flags |= 1;
2135 if (cell->tile [1]) flags |= 2;
2136 if (cell->tile [2]) flags |= 4;
2137
2138 *data++ = flags;
2139
609 if (face) 2140 if (flags & 1)
610 { 2141 {
611 mapface tex = self->face [face]; 2142 tileid tile = cell->tile [0];
612 2143 *data++ = tile >> 8;
613 int px = (x + 1) * 32 - tex.w; 2144 *data++ = tile;
614 int py = (y + 1) * 32 - tex.h;
615
616 if (last_name != tex.name)
617 {
618 glEnd ();
619 last_name = tex.name;
620 glBindTexture (GL_TEXTURE_2D, last_name);
621 glBegin (GL_QUADS);
622 }
623
624 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
625 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
626 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
627 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
628 } 2145 }
2146
2147 if (flags & 2)
2148 {
2149 tileid tile = cell->tile [1];
2150 *data++ = tile >> 8;
2151 *data++ = tile;
629 } 2152 }
2153
2154 if (flags & 4)
2155 {
2156 tileid tile = cell->tile [2];
2157 *data++ = tile >> 8;
2158 *data++ = tile;
2159 }
2160 }
2161 else
2162 *data++ = 0;
630 } 2163 }
2164 }
631 2165
632 glEnd (); 2166 SvPOK_only (data_sv);
2167 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2168 RETVAL = data_sv;
633} 2169}
2170 OUTPUT:
2171 RETVAL
634 2172
2173void
2174set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data)
2175 PPCODE:
2176{
2177 int x, y, z;
2178 int w, h;
2179 int x1, y1;
2180
2181 if (*data++ != 0)
2182 return; /* version mismatch */
2183
2184 w = *data++ << 8; w |= *data++;
2185 h = *data++ << 8; h |= *data++;
2186
2187 // we need to do this 'cause we don't keep an absolute coord system for rows
2188 // TODO: treat rows as we treat columns
2189 map_get_row (self, y0 + self->y - self->oy);//D
2190 map_get_row (self, y0 + self->y - self->oy + h - 1);//D
2191
2192 x0 += self->x - self->ox;
2193 y0 += self->y - self->oy;
2194
2195 x1 = x0 + w;
2196 y1 = y0 + h;
2197
2198 for (y = y0; y < y1; y++)
2199 {
2200 maprow *row = map_get_row (self, y);
2201
2202 for (x = x0; x < x1; x++)
2203 {
2204 uint8_t flags = *data++;
2205
2206 if (flags)
2207 {
2208 mapcell *cell = row_get_cell (row, x);
2209 tileid tile[3] = { 0, 0, 0 };
2210
2211 if (flags & 1) { tile[0] = *data++ << 8; tile[0] |= *data++; }
2212 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
2213 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
2214
2215 if (cell->darkness == 0)
2216 {
2217 cell->darkness = 0;
2218
2219 for (z = 0; z <= 2; z++)
2220 {
2221 tileid t = tile [z];
2222
2223 if (t >= self->texs || (t && !self->tex [t].name))
2224 {
2225 XPUSHs (sv_2mortal (newSViv (t)));
2226 need_texid (self, t);
2227 }
2228
2229 cell->tile [z] = t;
2230 }
2231 }
2232 }
2233 }
2234 }
2235}
2236
2237MODULE = CFPlus PACKAGE = CFPlus::MixChunk
2238
2239PROTOTYPES: DISABLE
2240
2241CFPlus::MixChunk
2242new_from_file (SV *class, char *path)
2243 CODE:
2244 RETVAL = Mix_LoadWAV (path);
2245 OUTPUT:
2246 RETVAL
2247
2248void
2249DESTROY (CFPlus::MixChunk self)
2250 CODE:
2251 Mix_FreeChunk (self);
2252
2253int
2254volume (CFPlus::MixChunk self, int volume = -1)
2255 CODE:
2256 RETVAL = Mix_VolumeChunk (self, volume);
2257 OUTPUT:
2258 RETVAL
2259
2260int
2261play (CFPlus::MixChunk self, int channel = -1, int loops = 0, int ticks = -1)
2262 CODE:
2263 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
2264 OUTPUT:
2265 RETVAL
2266
2267MODULE = CFPlus PACKAGE = CFPlus::MixMusic
2268
2269int
2270volume (int volume = -1)
2271 PROTOTYPE: ;$
2272 CODE:
2273 RETVAL = Mix_VolumeMusic (volume);
2274 OUTPUT:
2275 RETVAL
2276
2277int
2278fade_out (int ms)
2279 CODE:
2280 RETVAL = Mix_FadeOutMusic (ms);
2281 OUTPUT:
2282 RETVAL
2283
2284CFPlus::MixMusic
2285new_from_file (SV *class, char *path)
2286 CODE:
2287 RETVAL = Mix_LoadMUS (path);
2288 OUTPUT:
2289 RETVAL
2290
2291void
2292DESTROY (CFPlus::MixMusic self)
2293 CODE:
2294 Mix_FreeMusic (self);
2295
2296int
2297play (CFPlus::MixMusic self, int loops = -1)
2298 CODE:
2299 RETVAL = Mix_PlayMusic (self, loops);
2300 OUTPUT:
2301 RETVAL
2302
2303int
2304fade_in_pos (CFPlus::MixMusic self, int loops, int ms, double position)
2305 CODE:
2306 RETVAL = Mix_FadeInMusicPos (self, loops, ms, position);
2307 OUTPUT:
2308 RETVAL
2309
2310MODULE = CFPlus PACKAGE = CFPlus::OpenGL
2311
2312PROTOTYPES: ENABLE
2313
2314BOOT:
2315{
2316 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1);
2317 static const struct {
2318 const char *name;
2319 IV iv;
2320 } *civ, const_iv[] = {
2321# define const_iv(name) { # name, (IV)name }
2322 const_iv (GL_VENDOR),
2323 const_iv (GL_VERSION),
2324 const_iv (GL_EXTENSIONS),
2325 const_iv (GL_COLOR_MATERIAL),
2326 const_iv (GL_SMOOTH),
2327 const_iv (GL_FLAT),
2328 const_iv (GL_DITHER),
2329 const_iv (GL_BLEND),
2330 const_iv (GL_CULL_FACE),
2331 const_iv (GL_SCISSOR_TEST),
2332 const_iv (GL_DEPTH_TEST),
2333 const_iv (GL_ALPHA_TEST),
2334 const_iv (GL_NORMALIZE),
2335 const_iv (GL_RESCALE_NORMAL),
2336 const_iv (GL_FRONT),
2337 const_iv (GL_BACK),
2338 const_iv (GL_AUX0),
2339 const_iv (GL_AND),
2340 const_iv (GL_ONE),
2341 const_iv (GL_ZERO),
2342 const_iv (GL_SRC_ALPHA),
2343 const_iv (GL_DST_ALPHA),
2344 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2345 const_iv (GL_ONE_MINUS_DST_ALPHA),
2346 const_iv (GL_SRC_ALPHA_SATURATE),
2347 const_iv (GL_RGB),
2348 const_iv (GL_RGBA),
2349 const_iv (GL_RGBA4),
2350 const_iv (GL_RGBA8),
2351 const_iv (GL_RGB5_A1),
2352 const_iv (GL_UNSIGNED_BYTE),
2353 const_iv (GL_UNSIGNED_SHORT),
2354 const_iv (GL_UNSIGNED_INT),
2355 const_iv (GL_ALPHA),
2356 const_iv (GL_INTENSITY),
2357 const_iv (GL_LUMINANCE),
2358 const_iv (GL_LUMINANCE_ALPHA),
2359 const_iv (GL_FLOAT),
2360 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),
2361 const_iv (GL_COMPILE),
2362 const_iv (GL_PROXY_TEXTURE_1D),
2363 const_iv (GL_PROXY_TEXTURE_2D),
2364 const_iv (GL_TEXTURE_1D),
2365 const_iv (GL_TEXTURE_2D),
2366 const_iv (GL_TEXTURE_ENV),
2367 const_iv (GL_TEXTURE_MAG_FILTER),
2368 const_iv (GL_TEXTURE_MIN_FILTER),
2369 const_iv (GL_TEXTURE_ENV_MODE),
2370 const_iv (GL_TEXTURE_WRAP_S),
2371 const_iv (GL_TEXTURE_WRAP_T),
2372 const_iv (GL_REPEAT),
2373 const_iv (GL_CLAMP),
2374 const_iv (GL_CLAMP_TO_EDGE),
2375 const_iv (GL_NEAREST),
2376 const_iv (GL_LINEAR),
2377 const_iv (GL_NEAREST_MIPMAP_NEAREST),
2378 const_iv (GL_LINEAR_MIPMAP_NEAREST),
2379 const_iv (GL_NEAREST_MIPMAP_LINEAR),
2380 const_iv (GL_LINEAR_MIPMAP_LINEAR),
2381 const_iv (GL_GENERATE_MIPMAP),
2382 const_iv (GL_MODULATE),
2383 const_iv (GL_DECAL),
2384 const_iv (GL_REPLACE),
2385 const_iv (GL_DEPTH_BUFFER_BIT),
2386 const_iv (GL_COLOR_BUFFER_BIT),
2387 const_iv (GL_PROJECTION),
2388 const_iv (GL_MODELVIEW),
2389 const_iv (GL_COLOR_LOGIC_OP),
2390 const_iv (GL_SEPARABLE_2D),
2391 const_iv (GL_CONVOLUTION_2D),
2392 const_iv (GL_CONVOLUTION_BORDER_MODE),
2393 const_iv (GL_CONSTANT_BORDER),
2394 const_iv (GL_POINTS),
2395 const_iv (GL_LINES),
2396 const_iv (GL_LINE_STRIP),
2397 const_iv (GL_LINE_LOOP),
2398 const_iv (GL_QUADS),
2399 const_iv (GL_QUAD_STRIP),
2400 const_iv (GL_TRIANGLES),
2401 const_iv (GL_TRIANGLE_STRIP),
2402 const_iv (GL_TRIANGLE_FAN),
2403 const_iv (GL_POLYGON),
2404 const_iv (GL_PERSPECTIVE_CORRECTION_HINT),
2405 const_iv (GL_POINT_SMOOTH_HINT),
2406 const_iv (GL_LINE_SMOOTH_HINT),
2407 const_iv (GL_POLYGON_SMOOTH_HINT),
2408 const_iv (GL_GENERATE_MIPMAP_HINT),
2409 const_iv (GL_FASTEST),
2410 const_iv (GL_DONT_CARE),
2411 const_iv (GL_NICEST),
2412 const_iv (GL_V2F),
2413 const_iv (GL_V3F),
2414 const_iv (GL_T2F_V3F),
2415 const_iv (GL_T2F_N3F_V3F),
2416# undef const_iv
2417 };
2418
2419 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
2420 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
2421
2422 texture_av = newAV ();
2423 AvREAL_off (texture_av);
2424}
2425
2426char *
2427gl_vendor ()
2428 CODE:
2429 RETVAL = (char *)glGetString (GL_VENDOR);
2430 OUTPUT:
2431 RETVAL
2432
2433char *
2434gl_version ()
2435 CODE:
2436 RETVAL = (char *)glGetString (GL_VERSION);
2437 OUTPUT:
2438 RETVAL
2439
2440char *
2441gl_extensions ()
2442 CODE:
2443 RETVAL = (char *)glGetString (GL_EXTENSIONS);
2444 OUTPUT:
2445 RETVAL
2446
2447const char *glGetString (GLenum pname)
2448
2449GLint glGetInteger (GLenum pname)
2450 CODE:
2451 glGetIntegerv (pname, &RETVAL);
2452 OUTPUT:
2453 RETVAL
2454
2455GLdouble glGetDouble (GLenum pname)
2456 CODE:
2457 glGetDoublev (pname, &RETVAL);
2458 OUTPUT:
2459 RETVAL
2460
2461int glGetError ()
2462
2463void glFinish ()
2464
2465void glClear (int mask)
2466
2467void glClearColor (float r, float g, float b, float a = 1.0)
2468 PROTOTYPE: @
2469
2470void glEnable (int cap)
2471
2472void glDisable (int cap)
2473
2474void glShadeModel (int mode)
2475
2476void glHint (int target, int mode)
2477
2478void glBlendFunc (int sfactor, int dfactor)
2479
2480void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2481 CODE:
2482 gl_BlendFuncSeparate (sa, da, saa, daa);
2483
2484void glDepthMask (int flag)
2485
2486void glLogicOp (int opcode)
2487
2488void glColorMask (int red, int green, int blue, int alpha)
2489
2490void glMatrixMode (int mode)
2491
2492void glPushMatrix ()
2493
2494void glPopMatrix ()
2495
2496void glLoadIdentity ()
2497
2498void glDrawBuffer (int buffer)
2499
2500void glReadBuffer (int buffer)
2501
2502# near_ and far_ are due to microsofts buggy "c" compiler
2503void glFrustum (double left, double right, double bottom, double top, double near_, double far_)
2504
2505# near_ and far_ are due to microsofts buggy "c" compiler
2506void glOrtho (double left, double right, double bottom, double top, double near_, double far_)
2507
2508PROTOTYPES: DISABLE
2509
2510void glViewport (int x, int y, int width, int height)
2511
2512void glScissor (int x, int y, int width, int height)
2513
2514void glTranslate (float x, float y, float z = 0.)
2515 CODE:
2516 glTranslatef (x, y, z);
2517
2518void glScale (float x, float y, float z = 1.)
2519 CODE:
2520 glScalef (x, y, z);
2521
2522void glRotate (float angle, float x, float y, float z)
2523 CODE:
2524 glRotatef (angle, x, y, z);
2525
2526void glColor (float r, float g, float b, float a = 1.0)
2527 ALIAS:
2528 glColor_premultiply = 1
2529 CODE:
2530 if (ix)
2531 {
2532 r *= a;
2533 g *= a;
2534 b *= a;
2535 }
2536 // microsoft visual "c" rounds instead of truncating...
2537 glColor4f (r, g, b, a);
2538
2539void glRasterPos (float x, float y, float z = 0.)
2540 CODE:
2541 glRasterPos3f (0, 0, z);
2542 glBitmap (0, 0, 0, 0, x, y, 0);
2543
2544void glVertex (float x, float y, float z = 0.)
2545 CODE:
2546 glVertex3f (x, y, z);
2547
2548void glTexCoord (float s, float t)
2549 CODE:
2550 glTexCoord2f (s, t);
2551
2552void glRect (float x1, float y1, float x2, float y2)
2553 CODE:
2554 glRectf (x1, y1, x2, y2);
2555
2556PROTOTYPES: ENABLE
2557
2558void glBegin (int mode)
2559
2560void glEnd ()
2561
2562void glPointSize (GLfloat size)
2563
2564void glLineWidth (GLfloat width)
2565
2566void glInterleavedArrays (int format, int stride, char *data)
2567
2568void glDrawElements (int mode, int count, int type, char *indices)
2569
2570# 1.2 void glDrawRangeElements (int mode, int start, int end
2571
2572void glTexEnv (int target, int pname, float param)
2573 CODE:
2574 glTexEnvf (target, pname, param);
2575
2576void glTexParameter (int target, int pname, float param)
2577 CODE:
2578 glTexParameterf (target, pname, param);
2579
2580void glBindTexture (int target, int name)
2581
2582void glConvolutionParameter (int target, int pname, float params)
2583 CODE:
2584 if (gl.ConvolutionParameterf)
2585 gl.ConvolutionParameterf (target, pname, params);
2586
2587void glConvolutionFilter2D (int target, int internalformat, int width, int height, int format, int type, char *data)
2588 CODE:
2589 if (gl.ConvolutionFilter2D)
2590 gl.ConvolutionFilter2D (target, internalformat, width, height, format, type, data);
2591
2592void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column)
2593 CODE:
2594 if (gl.SeparableFilter2D)
2595 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);
2596
2597void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data)
2598
2599void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
2600
2601void glDrawPixels (int width, int height, int format, int type, char *pixels)
2602
2603void glPixelZoom (float x, float y)
2604
2605void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
2606
2607int glGenTexture ()
2608 CODE:
2609 RETVAL = gen_texture ();
2610 OUTPUT:
2611 RETVAL
2612
2613void glDeleteTexture (int name)
2614 CODE:
2615 del_texture (name);
2616
2617int glGenList ()
2618 CODE:
2619 RETVAL = glGenLists (1);
2620 OUTPUT:
2621 RETVAL
2622
2623void glDeleteList (int list)
2624 CODE:
2625 glDeleteLists (list, 1);
2626
2627void glNewList (int list, int mode = GL_COMPILE)
2628
2629void glEndList ()
2630
2631void glCallList (int list)
2632
2633MODULE = CFPlus PACKAGE = CFPlus::UI::Base
2634
2635PROTOTYPES: DISABLE
2636
2637void
2638find_widget (SV *self, NV x, NV y)
2639 PPCODE:
2640{
2641 if (within_widget (self, x, y))
2642 XPUSHs (self);
2643}
2644
2645BOOT:
2646{
2647 hover_gv = gv_fetchpv ("CFPlus::UI::HOVER", 1, SVt_NV);
2648
2649 draw_x_gv = gv_fetchpv ("CFPlus::UI::Base::draw_x", 1, SVt_NV);
2650 draw_y_gv = gv_fetchpv ("CFPlus::UI::Base::draw_y", 1, SVt_NV);
2651 draw_w_gv = gv_fetchpv ("CFPlus::UI::Base::draw_w", 1, SVt_NV);
2652 draw_h_gv = gv_fetchpv ("CFPlus::UI::Base::draw_h", 1, SVt_NV);
2653}
2654
2655void
2656draw (SV *self)
2657 CODE:
2658{
2659 HV *hv;
2660 SV **svp;
2661 NV x, y, w, h;
2662 SV *draw_x_sv = GvSV (draw_x_gv);
2663 SV *draw_y_sv = GvSV (draw_y_gv);
2664 SV *draw_w_sv = GvSV (draw_w_gv);
2665 SV *draw_h_sv = GvSV (draw_h_gv);
2666 SV *hover;
2667 double draw_x, draw_y, draw_w, draw_h;
2668
2669 if (!SvROK (self))
2670 croak ("CFPlus::Base::draw: %s not a reference", SvPV_nolen (self));
2671
2672 hv = (HV *)SvRV (self);
2673
2674 if (SvTYPE (hv) != SVt_PVHV)
2675 croak ("CFPlus::Base::draw: %s not a hashref", SvPV_nolen (self));
2676
2677 svp = hv_fetch (hv, "w", 1, 0); w = svp ? SvNV (*svp) : 0.;
2678 svp = hv_fetch (hv, "h", 1, 0); h = svp ? SvNV (*svp) : 0.;
2679
2680 if (!h || !w)
2681 XSRETURN_EMPTY;
2682
2683 svp = hv_fetch (hv, "x", 1, 0); x = svp ? SvNV (*svp) : 0.;
2684 svp = hv_fetch (hv, "y", 1, 0); y = svp ? SvNV (*svp) : 0.;
2685
2686 draw_x = SvNV (draw_x_sv) + x;
2687 draw_y = SvNV (draw_y_sv) + y;
2688
2689 if (draw_x + w < 0 || draw_x >= SvNV (draw_w_sv)
2690 || draw_y + h < 0 || draw_y >= SvNV (draw_h_sv))
2691 XSRETURN_EMPTY;
2692
2693 sv_setnv (draw_x_sv, draw_x);
2694 sv_setnv (draw_y_sv, draw_y);
2695
2696 glPushMatrix ();
2697 glTranslated (x, y, 0);
2698
2699 if (SvROK (GvSV (hover_gv)) && SvRV (GvSV (hover_gv)) == (SV *)hv)
2700 {
2701 svp = hv_fetch (hv, "can_hover", sizeof ("can_hover") - 1, 0);
2702
2703 if (svp && SvTRUE (*svp))
2704 {
2705 glColor4f (1*0.2f, 0.8*0.2f, 0.5*0.2f, 0.2f);
2706 glEnable (GL_BLEND);
2707 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2708 glBegin (GL_QUADS);
2709 glVertex2f (0, 0);
2710 glVertex2f (w, 0);
2711 glVertex2f (w, h);
2712 glVertex2f (0, h);
2713 glEnd ();
2714 glDisable (GL_BLEND);
2715 }
2716 }
2717#if 0
2718 if ($ENV{CFPLUS_DEBUG} & 1) {
2719 glPushMatrix;
2720 glColor 1, 1, 0, 1;
2721 glTranslate 0.375, 0.375;
2722 glBegin GL_LINE_LOOP;
2723 glVertex 0 , 0;
2724 glVertex $self->{w} - 1, 0;
2725 glVertex $self->{w} - 1, $self->{h} - 1;
2726 glVertex 0 , $self->{h} - 1;
2727 glEnd;
2728 glPopMatrix;
2729 #CFPlus::UI::Label->new (w => $self->{w}, h => $self->{h}, text => $self, fontsize => 0)->_draw;
2730 }
2731#endif
2732 PUSHMARK (SP);
2733 XPUSHs (self);
2734 PUTBACK;
2735 call_method ("_draw", G_VOID | G_DISCARD);
2736 SPAGAIN;
2737
2738 glPopMatrix ();
2739
2740 draw_x = draw_x - x; sv_setnv (draw_x_sv, draw_x);
2741 draw_y = draw_y - y; sv_setnv (draw_y_sv, draw_y);
2742}
2743

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines