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.36 by elmex, Fri Apr 14 11:32:21 2006 UTC vs.
Revision 1.209 by root, Sat Jul 21 22:54:52 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, 0); 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 row->col[x - row->c0].darkness = -1; 365 cell = row->col + x - row->c0;
366
367 cell->darkness = 0;
368 cell->stat_hp = 0;
369 cell->flags = 0;
370 cell->player = 0;
156 } 371 }
157 } 372 }
158} 373}
159 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
160MODULE = CFClient PACKAGE = CFClient 481MODULE = CFPlus PACKAGE = CFPlus
161 482
162PROTOTYPES: ENABLE 483PROTOTYPES: ENABLE
163 484
164BOOT: 485BOOT:
165{ 486{
166 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 ();
167 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);
168 context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)fontmap); 633 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
169} 634}
170
171void
172lowdelay (int fd, int val = 1)
173 CODE:
174 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val));
175 635
176char * 636char *
177gl_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)
178 CODE: 647 PPCODE:
179 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}
180 OUTPUT: 715 OUTPUT:
181 RETVAL 716 RETVAL
182 717
718void
719SDL_GL_SwapBuffers ()
720
183char * 721char *
184gl_extensions () 722SDL_GetKeyName (int sym)
723
724int
725SDL_GetAppState ()
726
727void
728poll_events ()
185 CODE: 729 PPCODE:
186 RETVAL = (char *)glGetString (GL_EXTENSIONS); 730{
187 OUTPUT: 731 SDL_Event ev;
188 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}
189 849
190void 850void
191add_font (char *file) 851add_font (char *file)
192 CODE: 852 CODE:
193 FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */ 853 FcConfigAppFontAddFile (0, (const FcChar8 *)file);
194
195void
196set_font (char *file)
197 CODE:
198{
199 int count;
200 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)file, 0, 0, &count);
201 PangoFontDescription *font = pango_fc_font_description_from_pattern (pattern, 0);
202 FcPatternDestroy (pattern);
203 pango_context_set_font_description (context, font);
204}
205 854
206void 855void
207load_image_inline (SV *image_) 856load_image_inline (SV *image_)
208 ALIAS: 857 ALIAS:
209 load_image_file = 1 858 load_image_file = 1
… …
216 SDL_RWops *rw = ix 865 SDL_RWops *rw = ix
217 ? SDL_RWFromFile (image, "r") 866 ? SDL_RWFromFile (image, "r")
218 : SDL_RWFromConstMem (image, image_len); 867 : SDL_RWFromConstMem (image, image_len);
219 868
220 if (!rw) 869 if (!rw)
221 croak ("load_image: unable to open file"); 870 croak ("load_image: %s", SDL_GetError ());
222 871
223 surface = IMG_Load_RW (rw, 1); 872 surface = IMG_Load_RW (rw, 1);
224 if (!surface) 873 if (!surface)
225 croak ("load_image: unable to read file"); 874 croak ("load_image: %s", SDL_GetError ());
226 875
227 fmt.palette = NULL; 876 fmt.palette = NULL;
228 fmt.BitsPerPixel = 32; 877 fmt.BitsPerPixel = 32;
229 fmt.BytesPerPixel = 4; 878 fmt.BytesPerPixel = 4;
879#if SDL_BYTEORDER == SDL_LIL_ENDIAN
230 fmt.Rmask = 0x000000ff; 880 fmt.Rmask = 0x000000ff;
231 fmt.Gmask = 0x0000ff00; 881 fmt.Gmask = 0x0000ff00;
232 fmt.Bmask = 0x00ff0000; 882 fmt.Bmask = 0x00ff0000;
233 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
234 fmt.Rloss = 0; 890 fmt.Rloss = 0;
235 fmt.Gloss = 0; 891 fmt.Gloss = 0;
236 fmt.Bloss = 0; 892 fmt.Bloss = 0;
237 fmt.Aloss = 0; 893 fmt.Aloss = 0;
238 fmt.Rshift = 0; 894 fmt.Rshift = 0;
… …
242 fmt.colorkey = 0; 898 fmt.colorkey = 0;
243 fmt.alpha = 0; 899 fmt.alpha = 0;
244 900
245 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE); 901 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE);
246 902
903 assert (surface2->pitch == surface2->w * 4);
904
905 SDL_LockSurface (surface2);
247 EXTEND (SP, 5); 906 EXTEND (SP, 6);
248 PUSHs (sv_2mortal (newSViv (surface2->w))); 907 PUSHs (sv_2mortal (newSViv (surface2->w)));
249 PUSHs (sv_2mortal (newSViv (surface2->h))); 908 PUSHs (sv_2mortal (newSViv (surface2->h)));
250 SDL_LockSurface (surface2);
251 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 909 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));
252 SDL_UnlockSurface (surface2);
253 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)));
254 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 911 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
255 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_INT_8_8_8_8_REV))); 912 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
913 SDL_UnlockSurface (surface2);
256 914
257 SDL_FreeSurface (surface); 915 SDL_FreeSurface (surface);
258 SDL_FreeSurface (surface2); 916 SDL_FreeSurface (surface2);
259} 917}
260 918
261void 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
262fatal (char *message) 953fatal (char *message)
263 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:
264#ifdef WIN32 964#ifdef WIN32
265 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND); 965 ExitThread (retval); // unclean, please beam me up
266#else 966#else
267 fprintf (stderr, "%s\n", message); 967 _exit (retval);
268#endif 968#endif
269 exit (1);
270 969
271MODULE = CFClient PACKAGE = CFClient::Layout 970void
272 971debug ()
273CFClient::Layout
274new (SV *class, int base_height = 10)
275 CODE: 972 CODE:
276 New (0, RETVAL, 1, struct cf_layout); 973{
277 RETVAL->base_height = base_height; 974#if DEBUG
278 RETVAL->pl = pango_layout_new (context); 975 VALGRIND_DO_LEAK_CHECK;
279 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}
280 OUTPUT: 992 OUTPUT:
281 RETVAL 993 RETVAL
282 994
283void 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
284DESTROY (CFClient::Layout self) 1035DESTROY (CFPlus::Layout self)
285 CODE: 1036 CODE:
286 g_object_unref (self->pl); 1037 g_object_unref (self->pl);
287 Safefree (self); 1038 Safefree (self);
288 1039
289void 1040void
290set_text (CFClient::Layout self, SV *text_) 1041set_text (CFPlus::Layout self, SV *text_)
291 CODE: 1042 CODE:
292{ 1043{
293 STRLEN textlen; 1044 STRLEN textlen;
294 char *text = SvPVutf8 (text_, textlen); 1045 char *text = SvPVutf8 (text_, textlen);
295 1046
296 pango_layout_set_text (self->pl, text, textlen); 1047 pango_layout_set_text (self->pl, text, textlen);
297} 1048}
298 1049
299void 1050void
300set_markup (CFClient::Layout self, SV *text_) 1051set_markup (CFPlus::Layout self, SV *text_)
301 CODE: 1052 CODE:
302{ 1053{
303 STRLEN textlen; 1054 STRLEN textlen;
304 char *text = SvPVutf8 (text_, textlen); 1055 char *text = SvPVutf8 (text_, textlen);
305 1056
306 pango_layout_set_markup (self->pl, text, textlen); 1057 pango_layout_set_markup (self->pl, text, textlen);
307} 1058}
308 1059
309void 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
310set_height (CFClient::Layout self, int base_height) 1171set_height (CFPlus::Layout self, int base_height)
311 CODE: 1172 CODE:
1173 if (self->base_height != base_height)
1174 {
312 self->base_height = base_height; 1175 self->base_height = base_height;
1176 layout_update_font (self);
1177 }
313 1178
314void 1179void
315set_width (CFClient::Layout self, int max_width = -1) 1180set_width (CFPlus::Layout self, int max_width = -1)
316 CODE: 1181 CODE:
317 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);
318 1183
319void 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
320size (CFClient::Layout self) 1210size (CFPlus::Layout self)
321 PPCODE: 1211 PPCODE:
322{ 1212{
323 int w, h; 1213 int w, h;
324 1214
325 layout_update (self);
326 layout_get_pixel_size (self, &w, &h); 1215 layout_get_pixel_size (self, &w, &h);
327 1216
328 EXTEND (SP, 2); 1217 EXTEND (SP, 2);
329 PUSHs (sv_2mortal (newSViv (w))); 1218 PUSHs (sv_2mortal (newSViv (w)));
330 PUSHs (sv_2mortal (newSViv (h))); 1219 PUSHs (sv_2mortal (newSViv (h)));
331} 1220}
332 1221
333int 1222int
334xy_to_index (CFClient::Layout self, int x, int y) 1223descent (CFPlus::Layout self)
335 CODE: 1224 CODE:
336{ 1225{
337 int index, trailing; 1226 PangoRectangle rect;
338 1227 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0);
339 layout_update (self); 1228 pango_layout_line_get_pixel_extents (line, 0, &rect);
340 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing); 1229 RETVAL = PANGO_DESCENT (rect);
341
342 RETVAL = index;
343} 1230}
344 OUTPUT: 1231 OUTPUT:
345 RETVAL 1232 RETVAL
346 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
347void 1245void
348cursor_pos (CFClient::Layout self, int index) 1246cursor_pos (CFPlus::Layout self, int index)
349 PPCODE: 1247 PPCODE:
350{ 1248{
351 PangoRectangle strong_pos; 1249 PangoRectangle strong_pos;
352 layout_update (self);
353 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1250 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);
354 1251
355 EXTEND (SP, 3); 1252 EXTEND (SP, 3);
356 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1253 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));
357 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1254 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
358 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1255 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));
359} 1256}
360 1257
361void 1258void
362render (CFClient::Layout self) 1259index_to_line_x (CFPlus::Layout self, int index, int trailing = 0)
363 PPCODE: 1260 PPCODE:
364{ 1261{
365 SV *retval; 1262 int line, x;
366 int w, h;
367 FT_Bitmap bitmap;
368 1263
369 layout_update (self); 1264 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
370 layout_get_pixel_size (self, &w, &h); 1265 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
371 1266
372 retval = newSV (w * h);
373 SvPOK_only (retval);
374 SvCUR_set (retval, w * h);
375
376 bitmap.rows = h;
377 bitmap.width = w;
378 bitmap.pitch = w;
379 bitmap.buffer = (unsigned char*)SvPVX (retval);
380 bitmap.num_grays = 256;
381 bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
382
383 memset (bitmap.buffer, 0, w * h);
384
385 pango_ft2_render_layout (&bitmap, self->pl, 0 * PANGO_SCALE, 0 * PANGO_SCALE);
386
387 EXTEND (SP, 3); 1267 EXTEND (SP, 2);
388 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 {
389 PUSHs (sv_2mortal (newSViv (h))); 1292 PUSHs (sv_2mortal (newSViv (index)));
390 PUSHs (sv_2mortal (retval)); 1293 PUSHs (sv_2mortal (newSViv (trailing)));
1294 }
391} 1295}
392 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
393MODULE = CFClient PACKAGE = CFClient::Texture 1307MODULE = CFPlus PACKAGE = CFPlus::Texture
394 1308
1309PROTOTYPES: ENABLE
1310
1311int minpot (int n)
1312
395void 1313void
396draw_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.)
397 PROTOTYPE: $$$;$$ 1337 PROTOTYPE: $$$;$$
1338 ALIAS:
1339 draw_quad_alpha = 1
1340 draw_quad_alpha_premultiplied = 2
398 CODE: 1341 CODE:
399{ 1342{
400 HV *hv = (HV *)SvRV (self); 1343 HV *hv = (HV *)SvRV (self);
401 double s = SvNV (*hv_fetch (hv, "s", 1, 1)); 1344 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
402 double t = SvNV (*hv_fetch (hv, "t", 1, 1)); 1345 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
403 int name = SvIV (*hv_fetch (hv, "name", 4, 1)); 1346 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
404 int wrap_mode = SvIV (*hv_fetch (hv, "wrap_mode", 9, 1));
405 1347
406 if (items < 5) 1348 if (items < 5)
407 { 1349 {
408 w = SvNV (*hv_fetch (hv, "w", 1, 1)); 1350 w = SvNV (*hv_fetch (hv, "w", 1, 1));
409 h = SvNV (*hv_fetch (hv, "h", 1, 1)); 1351 h = SvNV (*hv_fetch (hv, "h", 1, 1));
410 } 1352 }
411 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
412 glBindTexture (GL_TEXTURE_2D, name); 1368 glBindTexture (GL_TEXTURE_2D, name);
413 if (wrap_mode) { 1369
414 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
415 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
416 }
417 glBegin (GL_QUADS); 1370 glBegin (GL_QUADS);
418 glTexCoord2d (0, 0); glVertex2d (x , y ); 1371 glTexCoord2f (0, 0); glVertex2f (x , y );
419 glTexCoord2d (0, t); glVertex2d (x , y + h); 1372 glTexCoord2f (0, t); glVertex2f (x , y + h);
420 glTexCoord2d (s, t); glVertex2d (x + w, y + h); 1373 glTexCoord2f (s, t); glVertex2f (x + w, y + h);
421 glTexCoord2d (s, 0); glVertex2d (x + w, y ); 1374 glTexCoord2f (s, 0); glVertex2f (x + w, y );
422 glEnd (); 1375 glEnd ();
423}
424 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
425MODULE = CFClient PACKAGE = CFClient::Map 1395MODULE = CFPlus PACKAGE = CFPlus::Map
426 1396
427CFClient::Map 1397PROTOTYPES: DISABLE
428new (SV *class, int map_width, int map_height) 1398
1399CFPlus::Map
1400new (SV *class)
429 CODE: 1401 CODE:
430 New (0, RETVAL, 1, struct map); 1402 New (0, RETVAL, 1, struct map);
431 RETVAL->x = 0; 1403 RETVAL->x = 0;
432 RETVAL->y = 0; 1404 RETVAL->y = 0;
433 RETVAL->w = map_width; 1405 RETVAL->w = 0;
434 RETVAL->h = map_height; 1406 RETVAL->h = 0;
435 RETVAL->vx = 0; 1407 RETVAL->ox = 0;
436 RETVAL->vy = 0; 1408 RETVAL->oy = 0;
437 RETVAL->faces = 8192; 1409 RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
438 Newz (0, RETVAL->face, RETVAL->faces, mapface); 1410 RETVAL->texs = 8192; Newz (0, RETVAL->tex , RETVAL->texs , maptex);
439 RETVAL->rows = 0; 1411 RETVAL->rows = 0;
440 RETVAL->row = 0; 1412 RETVAL->row = 0;
441 OUTPUT: 1413 OUTPUT:
442 RETVAL 1414 RETVAL
443 1415
444void 1416void
445DESTROY (CFClient::Map self) 1417DESTROY (CFPlus::Map self)
446 CODE: 1418 CODE:
447{ 1419{
448 map_clear (self); 1420 map_clear (self);
449 Safefree (self->face); 1421 Safefree (self->face2tile);
1422 Safefree (self->tex);
450 Safefree (self); 1423 Safefree (self);
451} 1424}
452 1425
453void 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
454clear (CFClient::Map self) 1433clear (CFPlus::Map self)
455 CODE: 1434 CODE:
456 map_clear (self); 1435 map_clear (self);
457 1436
458void 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
459set_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)
460 CODE: 1470 CODE:
461{ 1471{
462 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)
463 { 1508 {
464 Append (mapface, self->face, self->faces, self->faces); 1509 case 0: RETVAL = self->ox; break;
465 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;
466 } 1515 }
1516 OUTPUT:
1517 RETVAL
467 1518
468 self->face [face].name = name;
469 self->face [face].w = w;
470 self->face [face].h = h;
471 self->face [face].s = s;
472 self->face [face].t = t;
473}
474
475void 1519void
476scroll (CFClient::Map self, int dx, int dy) 1520scroll (CFPlus::Map self, int dx, int dy)
477 CODE: 1521 CODE:
478{ 1522{
479 if (dx > 0) 1523 if (dx > 0)
480 map_blank (self, self->x, self->y, dx - 1, self->h); 1524 map_blank (self, self->x, self->y, dx, self->h);
481 else if (dx < 0) 1525 else if (dx < 0)
482 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);
483 1527
484 if (dy > 0) 1528 if (dy > 0)
485 map_blank (self, self->x, self->y, self->w, dy - 1); 1529 map_blank (self, self->x, self->y, self->w, dy);
486 else if (dy < 0) 1530 else if (dy < 0)
487 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);
488 1532
489 self->x += dx; 1533 self->ox += dx; self->x += dx;
490 self->y += dy; 1534 self->oy += dy; self->y += dy;
491 1535
492 while (self->y < 0) 1536 while (self->y < 0)
493 { 1537 {
494 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y); 1538 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
495 1539
… …
497 self->y += MAP_EXTEND_Y; 1541 self->y += MAP_EXTEND_Y;
498 } 1542 }
499} 1543}
500 1544
501void 1545void
502map1a_update (CFClient::Map self, SV *data_) 1546map1a_update (CFPlus::Map self, SV *data_, int extmap)
503 CODE: 1547 CODE:
504{ 1548{
505 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 1549 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
506 uint8_t *data_end = (uint8_t *)SvEND (data_); 1550 uint8_t *data_end = (uint8_t *)SvEND (data_);
507 1551 mapcell *cell;
1552 int x, y, flags;
1553
508 while (data < data_end) 1554 while (data < data_end - 1)
509 { 1555 {
510 int flags = (data [0] << 8) + data [1]; data += 2; 1556 flags = (data [0] << 8) + data [1]; data += 2;
511 1557
512 int x = ((flags >> 10) & 63) + self->x; 1558 x = self->x + ((flags >> 10) & 63);
513 int y = ((flags >> 4) & 63) + self->y; 1559 y = self->y + ((flags >> 4) & 63);
514 1560
515 while (y >= self->rows) 1561 cell = map_get_cell (self, x, y);
516 {
517 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
518
519 self->rows += MAP_EXTEND_Y;
520 }
521
522 maprow *row = self->row + y;
523
524 if (!row->col)
525 {
526 Newz (0, row->col, MAP_EXTEND_X, mapcell);
527 row->c0 = self->x - MAP_EXTEND_X / 4;
528 row->c1 = row->c0 + MAP_EXTEND_X;
529 }
530
531 if (row->c0 > x)
532 {
533 int extend = row->c0 - x + MAP_EXTEND_X;
534 Prepend (mapcell, row->col, row->c1 - row->c0, extend);
535 row->c0 -= extend;
536 }
537 else if (x >= row->c1)
538 {
539 int extend = x - row->c1 + MAP_EXTEND_X;
540 Append (mapcell, row->col, row->c1 - row->c0, extend);
541 row->c1 += extend;
542 }
543
544 assert (y >= 0);
545 assert (y < self->rows);
546 assert (x >= row->c0);
547 assert (x < row->c1);
548 mapcell *cell = row->col + (x - row->c0);
549 1562
550 if (flags & 15) 1563 if (flags & 15)
551 { 1564 {
552 if (cell->darkness < 0 && x < self->w && y < self->h) 1565 if (!cell->darkness)
553 { 1566 {
1567 memset (cell, 0, sizeof (*cell));
554 cell->darkness = 0; 1568 cell->darkness = 256;
555 cell->face [0] = 0;
556 cell->face [1] = 0;
557 cell->face [2] = 0;
558 } 1569 }
1570
1571 //TODO: don't trust server data to be in-range(!)
1572
1573 if (flags & 8)
559 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
560 cell->darkness = flags & 8 ? *data++ : 255; 1610 cell->darkness = *data++ + 1;
1611 }
561 1612
562 if (flags & 4) 1613 if (flags & 4)
563 { 1614 {
564 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];
565 } 1618 }
566 1619
567 if (flags & 2) 1620 if (flags & 2)
568 { 1621 {
569 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];
570 } 1625 }
571 1626
572 if (flags & 1) 1627 if (flags & 1)
573 { 1628 {
574 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];
575 } 1632 }
576 } 1633 }
577 else 1634 else
578 cell->darkness = -1; 1635 cell->darkness = 0;
579 } 1636 }
580} 1637}
581 1638
582void 1639SV *
583draw (CFClient::Map self, int x0, int y0, int sw, int sh) 1640mapmap (CFPlus::Map self, int x0, int y0, int w, int h)
584 PPCODE: 1641 CODE:
585{ 1642{
586 int sw4 = (sw + 3) & ~3; 1643 int x1, x;
587 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh)); 1644 int y1, y;
1645 int z;
1646 SV *map_sv = newSV (w * h * sizeof (uint32_t));
588 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv); 1647 uint32_t *map = (uint32_t *)SvPVX (map_sv);
589 1648
590 SvPOK_only (darkness_sv); 1649 SvPOK_only (map_sv);
591 SvCUR_set (darkness_sv, sw4 * sh); 1650 SvCUR_set (map_sv, w * h * sizeof (uint32_t));
592 1651
593 int vx = self->vx = self->w >= sw 1652 x0 += self->x; x1 = x0 + w;
594 ? self->x + (self->w - sw) / 2 1653 y0 += self->y; y1 = y0 + h;
595 : MIN (self->x, MAX (self->x + self->w - sw + 1, self->vx));
596 1654
597 int vy = self->vy = self->h >= sh 1655 for (y = y0; y < y1; y++)
598 ? self->y + (self->h - sh) / 2 1656 {
599 : MIN (self->y, MAX (self->y + self->h - sh + 1, self->vy)); 1657 maprow *row = 0 <= y && y < self->rows
1658 ? self->row + y
1659 : 0;
1660
1661 for (x = x0; x < x1; x++)
1662 {
1663 int r = 32, g = 32, b = 32, a = 192;
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);
1686 }
1687 }
1688
1689 RETVAL = map_sv;
1690}
1691 OUTPUT:
1692 RETVAL
1693
1694void
1695draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T)
1696 CODE:
1697{
1698 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1699 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
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;
1704
1705 // thats current max. sorry.
1706 if (sw > 255) sw = 255;
1707 if (sh > 255) sh = 255;
1708
1709 // clear key, in case of extra padding
1710 memset (&skey, 0, sizeof (skey));
600 1711
601 glColor4ub (255, 255, 255, 255); 1712 glColor4ub (255, 255, 255, 255);
602 1713
1714 glEnable (GL_BLEND);
603 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 1715 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
604 glEnable (GL_BLEND);
605 glEnable (GL_TEXTURE_2D); 1716 glEnable (GL_TEXTURE_2D);
606 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 1717 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
607 1718
608 int x, y, z;
609
610 int last_name = 0;
611
612 glBegin (GL_QUADS); 1719 glBegin (GL_QUADS);
613 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
614 for (z = 0; z < 3; z++) 1748 for (z = 0; z <= 2; z++)
1749 {
1750 memset (smooth_level, 0, sizeof (smooth_level));
1751
615 for (y = 0; y < sh; y++) 1752 for (y = 0; y < sh; y++)
616 if (0 <= y + vy && y + vy < self->rows) 1753 if (0 <= y + my && y + my < self->rows)
617 { 1754 {
618 maprow *row = self->row + (y + vy); 1755 maprow *row = self->row + (y + my);
619 1756
620 for (x = 0; x < sw; x++) 1757 for (x = 0; x < sw; x++)
621 if (row->c0 <= x + vx && x + vx < row->c1) 1758 if (row->c0 <= x + mx && x + mx < row->c1)
622 { 1759 {
623 mapcell *cell = row->col + (x + vx - row->c0); 1760 mapcell *cell = row->col + (x + mx - row->c0);
624
625 darkness[y * sw4 + x] = cell->darkness < 0
626 ? 255 - FOW_DARKNESS
627 : 255 - cell->darkness;
628
629 uint16_t face = cell->face [z]; 1761 tileid tile = cell->tile [z];
630 1762
631 if (face) 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))
632 { 1858 {
633 mapface tex = self->face [face]; 1859 int level = (w << 5) | b;
1860 HE *he;
634 1861
635 int px = (x + 1) * 32 - tex.w; 1862 hv_iterinit (smooth);
636 int py = (y + 1) * 32 - tex.h; 1863 while ((he = hv_iternext (smooth)))
637
638 if (last_name != tex.name)
639 { 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
640 glEnd (); 1887 glEnd ();
641 last_name = tex.name;
642 glBindTexture (GL_TEXTURE_2D, last_name); 1888 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
643 glBegin (GL_QUADS); 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 }
644 } 1912 }
645
646 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
647 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
648 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
649 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
650 } 1913 }
651 }
652 } 1914 }
1915 }
1916
1917 hv_clear (smooth);
1918 }
653 1919
654 glEnd (); 1920 glEnd ();
655 1921
656 glDisable (GL_TEXTURE_2D); 1922 glDisable (GL_TEXTURE_2D);
657 glDisable (GL_BLEND); 1923 glDisable (GL_BLEND);
658 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
659 EXTEND (SP, 3); 2092 EXTEND (SP, 3);
660 PUSHs (sv_2mortal (newSViv (sw4))); 2093 PUSHs (sv_2mortal (newSViv (sw34)));
661 PUSHs (sv_2mortal (newSViv (sh))); 2094 PUSHs (sv_2mortal (newSViv (sh3)));
662 PUSHs (darkness_sv); 2095 PUSHs (darkness3_sv);
663} 2096}
664 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++)
2128 {
2129 if (row && row->c0 <= x && x < row->c1)
2130 {
2131 mapcell *cell = row->col + (x - row->c0);
2132 uint8_t flags = 0;
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
2140 if (flags & 1)
2141 {
2142 tileid tile = cell->tile [0];
2143 *data++ = tile >> 8;
2144 *data++ = tile;
2145 }
2146
2147 if (flags & 2)
2148 {
2149 tileid tile = cell->tile [1];
2150 *data++ = tile >> 8;
2151 *data++ = tile;
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;
2163 }
2164 }
2165
2166 SvPOK_only (data_sv);
2167 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2168 RETVAL = data_sv;
2169}
2170 OUTPUT:
2171 RETVAL
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
2552PROTOTYPES: ENABLE
2553
2554void glBegin (int mode)
2555
2556void glEnd ()
2557
2558void glPointSize (GLfloat size)
2559
2560void glLineWidth (GLfloat width)
2561
2562void glInterleavedArrays (int format, int stride, char *data)
2563
2564void glDrawElements (int mode, int count, int type, char *indices)
2565
2566# 1.2 void glDrawRangeElements (int mode, int start, int end
2567
2568void glTexEnv (int target, int pname, float param)
2569 CODE:
2570 glTexEnvf (target, pname, param);
2571
2572void glTexParameter (int target, int pname, float param)
2573 CODE:
2574 glTexParameterf (target, pname, param);
2575
2576void glBindTexture (int target, int name)
2577
2578void glConvolutionParameter (int target, int pname, float params)
2579 CODE:
2580 if (gl.ConvolutionParameterf)
2581 gl.ConvolutionParameterf (target, pname, params);
2582
2583void glConvolutionFilter2D (int target, int internalformat, int width, int height, int format, int type, char *data)
2584 CODE:
2585 if (gl.ConvolutionFilter2D)
2586 gl.ConvolutionFilter2D (target, internalformat, width, height, format, type, data);
2587
2588void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column)
2589 CODE:
2590 if (gl.SeparableFilter2D)
2591 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);
2592
2593void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data)
2594
2595void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
2596
2597void glDrawPixels (int width, int height, int format, int type, char *pixels)
2598
2599void glPixelZoom (float x, float y)
2600
2601void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
2602
2603int glGenTexture ()
2604 CODE:
2605 RETVAL = gen_texture ();
2606 OUTPUT:
2607 RETVAL
2608
2609void glDeleteTexture (int name)
2610 CODE:
2611 del_texture (name);
2612
2613int glGenList ()
2614 CODE:
2615 RETVAL = glGenLists (1);
2616 OUTPUT:
2617 RETVAL
2618
2619void glDeleteList (int list)
2620 CODE:
2621 glDeleteLists (list, 1);
2622
2623void glNewList (int list, int mode = GL_COMPILE)
2624
2625void glEndList ()
2626
2627void glCallList (int list)
2628
2629MODULE = CFPlus PACKAGE = CFPlus::UI::Base
2630
2631PROTOTYPES: DISABLE
2632
2633void
2634find_widget (SV *self, NV x, NV y)
2635 PPCODE:
2636{
2637 if (within_widget (self, x, y))
2638 XPUSHs (self);
2639}
2640
2641BOOT:
2642{
2643 hover_gv = gv_fetchpv ("CFPlus::UI::HOVER", 1, SVt_NV);
2644
2645 draw_x_gv = gv_fetchpv ("CFPlus::UI::Base::draw_x", 1, SVt_NV);
2646 draw_y_gv = gv_fetchpv ("CFPlus::UI::Base::draw_y", 1, SVt_NV);
2647 draw_w_gv = gv_fetchpv ("CFPlus::UI::Base::draw_w", 1, SVt_NV);
2648 draw_h_gv = gv_fetchpv ("CFPlus::UI::Base::draw_h", 1, SVt_NV);
2649}
2650
2651void
2652draw (SV *self)
2653 CODE:
2654{
2655 HV *hv;
2656 SV **svp;
2657 NV x, y, w, h;
2658 SV *draw_x_sv = GvSV (draw_x_gv);
2659 SV *draw_y_sv = GvSV (draw_y_gv);
2660 SV *draw_w_sv = GvSV (draw_w_gv);
2661 SV *draw_h_sv = GvSV (draw_h_gv);
2662 SV *hover;
2663 double draw_x, draw_y, draw_w, draw_h;
2664
2665 if (!SvROK (self))
2666 croak ("CFPlus::Base::draw: %s not a reference", SvPV_nolen (self));
2667
2668 hv = (HV *)SvRV (self);
2669
2670 if (SvTYPE (hv) != SVt_PVHV)
2671 croak ("CFPlus::Base::draw: %s not a hashref", SvPV_nolen (self));
2672
2673 svp = hv_fetch (hv, "w", 1, 0); w = svp ? SvNV (*svp) : 0.;
2674 svp = hv_fetch (hv, "h", 1, 0); h = svp ? SvNV (*svp) : 0.;
2675
2676 if (!h || !w)
2677 XSRETURN_EMPTY;
2678
2679 svp = hv_fetch (hv, "x", 1, 0); x = svp ? SvNV (*svp) : 0.;
2680 svp = hv_fetch (hv, "y", 1, 0); y = svp ? SvNV (*svp) : 0.;
2681
2682 draw_x = SvNV (draw_x_sv) + x;
2683 draw_y = SvNV (draw_y_sv) + y;
2684
2685 if (draw_x + w < 0 || draw_x >= SvNV (draw_w_sv)
2686 || draw_y + h < 0 || draw_y >= SvNV (draw_h_sv))
2687 XSRETURN_EMPTY;
2688
2689 sv_setnv (draw_x_sv, draw_x);
2690 sv_setnv (draw_y_sv, draw_y);
2691
2692 glPushMatrix ();
2693 glTranslated (x, y, 0);
2694
2695 if (SvROK (GvSV (hover_gv)) && SvRV (GvSV (hover_gv)) == (SV *)hv)
2696 {
2697 svp = hv_fetch (hv, "can_hover", sizeof ("can_hover") - 1, 0);
2698
2699 if (svp && SvTRUE (*svp))
2700 {
2701 glColor4f (1*0.2f, 0.8*0.2f, 0.5*0.2f, 0.2f);
2702 glEnable (GL_BLEND);
2703 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2704 glBegin (GL_QUADS);
2705 glVertex2f (0, 0);
2706 glVertex2f (w, 0);
2707 glVertex2f (w, h);
2708 glVertex2f (0, h);
2709 glEnd ();
2710 glDisable (GL_BLEND);
2711 }
2712 }
2713#if 0
2714 if ($ENV{CFPLUS_DEBUG} & 1) {
2715 glPushMatrix;
2716 glColor 1, 1, 0, 1;
2717 glTranslate 0.375, 0.375;
2718 glBegin GL_LINE_LOOP;
2719 glVertex 0 , 0;
2720 glVertex $self->{w} - 1, 0;
2721 glVertex $self->{w} - 1, $self->{h} - 1;
2722 glVertex 0 , $self->{h} - 1;
2723 glEnd;
2724 glPopMatrix;
2725 #CFPlus::UI::Label->new (w => $self->{w}, h => $self->{h}, text => $self, fontsize => 0)->_draw;
2726 }
2727#endif
2728 PUSHMARK (SP);
2729 XPUSHs (self);
2730 PUTBACK;
2731 call_method ("_draw", G_VOID | G_DISCARD);
2732 SPAGAIN;
2733
2734 glPopMatrix ();
2735
2736 draw_x = draw_x - x; sv_setnv (draw_x_sv, draw_x);
2737 draw_y = draw_y - y; sv_setnv (draw_y_sv, draw_y);
2738}
2739

Diff Legend

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