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

Diff Legend

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