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.51 by root, Wed Apr 19 20:46:44 2006 UTC vs.
Revision 1.233 by root, Tue Aug 21 02:39:17 2007 UTC

1#ifdef _WIN32 1#ifdef _WIN32
2# define WIN32_LEAN_AND_MEAN
3# define NTDDI_VERSION NTDDI_WIN2K // needed to get win2000 api calls
2# include <malloc.h> 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>
3#endif 14#endif
4 15
5#include "EXTERN.h" 16#include "EXTERN.h"
6#include "perl.h" 17#include "perl.h"
7#include "XSUB.h" 18#include "XSUB.h"
8 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>
9#include <string.h> 31#include <string.h>
10#include <stdio.h> 32#include <stdio.h>
33#include <stdlib.h>
34
35#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
11 36
12#include <SDL.h> 37#include <SDL.h>
38#include <SDL_thread.h>
39#include <SDL_endian.h>
13#include <SDL_image.h> 40#include <SDL_image.h>
41#include <SDL_mixer.h>
14#include <SDL_opengl.h> 42#include <SDL_opengl.h>
15 43
44#define PANGO_ENABLE_BACKEND
45#define G_DISABLE_CAST_CHECKS
46
16#include <glib/gmacros.h> 47#include <glib/gmacros.h>
17 48
18#include <pango/pango.h> 49#include <pango/pango.h>
19#include <pango/pangofc-fontmap.h>
20#include <pango/pangoft2.h>
21 50
22#ifndef _WIN32 51#ifndef _WIN32
23# include <sys/types.h> 52# include <sys/types.h>
24# include <sys/socket.h> 53# include <sys/socket.h>
25# include <netinet/in.h> 54# include <netinet/in.h>
26# include <netinet/tcp.h> 55# include <netinet/tcp.h>
27# include <inttypes.h> 56# include <inttypes.h>
28#else
29 typedef unsigned char uint8_t;
30 typedef unsigned short uint16_t;
31 typedef unsigned int uint32_t;
32 typedef signed char int8_t;
33 typedef signed short int16_t;
34 typedef signed int int32_t;
35#endif 57#endif
58
59#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
36 60
37#define FOW_DARKNESS 32 61#define FOW_DARKNESS 32
38 62
39#define MAP_EXTEND_X 32 63#define MAP_EXTEND_X 32
40#define MAP_EXTEND_Y 512 64#define MAP_EXTEND_Y 512
41 65
42static PangoContext *context; 66#define MIN_FONT_HEIGHT 10
43static 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}
44 149
45typedef struct cf_layout { 150typedef struct cf_layout {
46 PangoLayout *pl; 151 PangoLayout *pl;
152 float r, g, b, a; // default color for rgba mode
47 int base_height; 153 int base_height;
154 CFPlus__Font font;
155 rc_t *rc;
48} *CFClient__Layout; 156} *CFPlus__Layout;
157
158static CFPlus__Font default_font;
159static PangoContext *opengl_context;
160static PangoFontMap *opengl_fontmap;
49 161
50static void 162static void
51substitute_func (FcPattern *pattern, gpointer data) 163substitute_func (FcPattern *pattern, gpointer data)
52{ 164{
53 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
54 FcPatternAddBool (pattern, FC_AUTOHINT, 0); 169 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
55} 170}
56 171
57static void 172static void
58layout_update (CFClient__Layout self) 173layout_update_font (CFPlus__Layout self)
59{ 174{
60 /* 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
61 * reasonably well with bitstream vera 176 * reasonably well with bitstream vera
62 */ 177 */
63 PangoFontDescription *font = pango_context_get_font_description (context); 178 PangoFontDescription *font = self->font ? self->font : default_font;
64 179
65 int height = self->base_height * (PANGO_SCALE * 8 / 10);
66
67 if (pango_font_description_get_size (font) != height)
68 {
69 pango_font_description_set_absolute_size (font, height); 180 pango_font_description_set_absolute_size (font,
70 pango_layout_context_changed (self->pl); 181 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
71 } 182
183 pango_layout_set_font_description (self->pl, font);
72} 184}
73 185
74static void 186static void
75layout_get_pixel_size (CFClient__Layout self, int *w, int *h) 187layout_get_pixel_size (CFPlus__Layout self, int *w, int *h)
76{ 188{
77 layout_update (self); 189 PangoRectangle rect;
78 190
191 // get_pixel_* wrongly rounds down
79 pango_layout_get_pixel_size (self->pl, w, h); 192 pango_layout_get_extents (self->pl, 0, &rect);
80 193
81 *w = (*w + 3) & ~3; 194 rect.width = (rect.width + PANGO_SCALE - 1) / PANGO_SCALE;
82 if (!*w) *w = 1; 195 rect.height = (rect.height + PANGO_SCALE - 1) / PANGO_SCALE;
83 if (!*h) *h = 1;
84}
85 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;
86typedef uint16_t mapface; 205typedef uint16_t faceid;
87 206
88typedef struct { 207typedef struct {
89 GLint name; 208 GLuint name;
90 int w, h; 209 int w, h;
91 float s, t; 210 float s, t;
92 uint8_t r, g, b, a; 211 uint8_t r, g, b, a;
212 tileid smoothtile;
213 uint8_t smoothlevel;
93} maptex; 214} maptex;
94 215
95typedef struct { 216typedef struct {
217 uint32_t player;
218 tileid tile[3];
96 int16_t darkness; 219 uint16_t darkness;
97 mapface face[3]; 220 uint8_t stat_width, stat_hp, flags, smoothmax;
98} mapcell; 221} mapcell;
99 222
100typedef struct { 223typedef struct {
101 int32_t c0, c1; 224 int32_t c0, c1;
102 mapcell *col; 225 mapcell *col;
103} maprow; 226} maprow;
104 227
105typedef struct map { 228typedef struct map {
106 int x, y, w, h; 229 int x, y, w, h;
107 int ox, oy; /* offset to virtual global coordinate system */ 230 int ox, oy; /* offset to virtual global coordinate system */
108 int faces; 231 int faces; tileid *face2tile; // [faceid]
109 mapface *face; 232 int texs; maptex *tex; // [tileid]
110
111 int texs;
112 maptex *tex;
113 233
114 int32_t rows; 234 int32_t rows;
115 maprow *row; 235 maprow *row;
116} *CFClient__Map; 236} *CFPlus__Map;
117 237
118static char * 238static char *
119prepend (char *ptr, int sze, int inc) 239prepend (char *ptr, int sze, int inc)
120{ 240{
121 char *p; 241 char *p;
… …
138} 258}
139 259
140#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))
141#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))
142 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
143static maprow * 283static maprow *
144map_get_row (CFClient__Map self, int y) 284map_get_row (CFPlus__Map self, int y)
145{ 285{
146 if (0 > y) 286 if (0 > y)
147 { 287 {
148 int extend = - y + MAP_EXTEND_Y; 288 int extend = - y + MAP_EXTEND_Y;
149 Prepend (maprow, self->row, self->rows, extend); 289 Prepend (maprow, self->row, self->rows, extend);
… …
187 327
188 return row->col + (x - row->c0); 328 return row->col + (x - row->c0);
189} 329}
190 330
191static mapcell * 331static mapcell *
192map_get_cell (CFClient__Map self, int x, int y) 332map_get_cell (CFPlus__Map self, int x, int y)
193{ 333{
194 return row_get_cell (map_get_row (self, y), x); 334 return row_get_cell (map_get_row (self, y), x);
195} 335}
196 336
197static void 337static void
198map_clear (CFClient__Map self) 338map_clear (CFPlus__Map self)
199{ 339{
200 int r; 340 int r;
201 341
202 for (r = 0; r < self->rows; r++) 342 for (r = 0; r < self->rows; r++)
203 Safefree (self->row[r].col); 343 Safefree (self->row[r].col);
… …
211 self->row = 0; 351 self->row = 0;
212 self->rows = 0; 352 self->rows = 0;
213} 353}
214 354
215static void 355static void
216map_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)
217{ 357{
218 int x, y; 358 int x, y;
219 maprow *row; 359 maprow *row;
360 mapcell *cell;
220 361
221 for (y = y0; y < y0 + h; y++) 362 for (y = y0; y < y0 + h; y++)
222 if (y >= 0) 363 if (y >= 0)
223 { 364 {
224 if (y >= self->rows) 365 if (y >= self->rows)
… …
230 if (x >= row->c0) 371 if (x >= row->c0)
231 { 372 {
232 if (x >= row->c1) 373 if (x >= row->c1)
233 break; 374 break;
234 375
235 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;
236 } 382 }
237 } 383 }
238} 384}
239 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
240MODULE = CFClient PACKAGE = CFClient 492MODULE = CFPlus PACKAGE = CFPlus
241 493
242PROTOTYPES: ENABLE 494PROTOTYPES: ENABLE
243 495
244BOOT: 496BOOT:
245{ 497{
246 HV *stash = gv_stashpv ("CFClient", 1); 498 HV *stash = gv_stashpv ("CFPlus", 1);
247 static const struct { 499 static const struct {
248 const char *name; 500 const char *name;
249 IV iv; 501 IV iv;
250 } *civ, const_iv[] = { 502 } *civ, const_iv[] = {
251# define const_iv(name) { # name, (IV)name } 503# define const_iv(name) { # name, (IV)name }
504 const_iv (SDLK_MODIFIER_MIN),
505 const_iv (SDLK_MODIFIER_MAX),
506
252 const_iv (SDL_ACTIVEEVENT), 507 const_iv (SDL_ACTIVEEVENT),
253 const_iv (SDL_KEYDOWN), 508 const_iv (SDL_KEYDOWN),
254 const_iv (SDL_KEYUP), 509 const_iv (SDL_KEYUP),
255 const_iv (SDL_MOUSEMOTION), 510 const_iv (SDL_MOUSEMOTION),
256 const_iv (SDL_MOUSEBUTTONDOWN), 511 const_iv (SDL_MOUSEBUTTONDOWN),
… …
265 const_iv (SDL_EVENT_RESERVEDA), 520 const_iv (SDL_EVENT_RESERVEDA),
266 const_iv (SDL_EVENT_RESERVEDB), 521 const_iv (SDL_EVENT_RESERVEDB),
267 const_iv (SDL_VIDEORESIZE), 522 const_iv (SDL_VIDEORESIZE),
268 const_iv (SDL_VIDEOEXPOSE), 523 const_iv (SDL_VIDEOEXPOSE),
269 const_iv (SDL_USEREVENT), 524 const_iv (SDL_USEREVENT),
525
526 const_iv (SDL_APPINPUTFOCUS),
527 const_iv (SDL_APPMOUSEFOCUS),
528 const_iv (SDL_APPACTIVE),
529
270 const_iv (SDLK_KP0), 530 const_iv (SDLK_KP0),
271 const_iv (SDLK_KP1), 531 const_iv (SDLK_KP1),
272 const_iv (SDLK_KP2), 532 const_iv (SDLK_KP2),
273 const_iv (SDLK_KP3), 533 const_iv (SDLK_KP3),
274 const_iv (SDLK_KP4), 534 const_iv (SDLK_KP4),
… …
329 const_iv (SDLK_BREAK), 589 const_iv (SDLK_BREAK),
330 const_iv (SDLK_MENU), 590 const_iv (SDLK_MENU),
331 const_iv (SDLK_POWER), 591 const_iv (SDLK_POWER),
332 const_iv (SDLK_EURO), 592 const_iv (SDLK_EURO),
333 const_iv (SDLK_UNDO), 593 const_iv (SDLK_UNDO),
594
334 const_iv (KMOD_NONE), 595 const_iv (KMOD_NONE),
596 const_iv (KMOD_SHIFT),
335 const_iv (KMOD_LSHIFT), 597 const_iv (KMOD_LSHIFT),
336 const_iv (KMOD_RSHIFT), 598 const_iv (KMOD_RSHIFT),
599 const_iv (KMOD_CTRL),
337 const_iv (KMOD_LCTRL), 600 const_iv (KMOD_LCTRL),
338 const_iv (KMOD_RCTRL), 601 const_iv (KMOD_RCTRL),
602 const_iv (KMOD_ALT),
339 const_iv (KMOD_LALT), 603 const_iv (KMOD_LALT),
340 const_iv (KMOD_RALT), 604 const_iv (KMOD_RALT),
605 const_iv (KMOD_META),
341 const_iv (KMOD_LMETA), 606 const_iv (KMOD_LMETA),
342 const_iv (KMOD_RMETA), 607 const_iv (KMOD_RMETA),
343 const_iv (KMOD_NUM), 608 const_iv (KMOD_NUM),
344 const_iv (KMOD_CAPS), 609 const_iv (KMOD_CAPS),
345 const_iv (KMOD_MODE), 610 const_iv (KMOD_MODE),
346 const_iv (KMOD_CTRL),
347 const_iv (KMOD_SHIFT),
348 const_iv (KMOD_ALT),
349 const_iv (KMOD_META)
350# undef const_iv 611# undef const_iv
351 }; 612 };
352 613
353 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 614 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
354 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 615 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
355 616
356 fontmap = pango_ft2_font_map_new (); 617 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
357 pango_ft2_font_map_set_default_substitute ((PangoFT2FontMap *)fontmap, substitute_func, 0, 0); 618 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
358 context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)fontmap);
359} 619}
620
621void
622weaken (SV *rv)
623 PROTOTYPE: $
624 CODE:
625 sv_rvweaken (rv);
360 626
361int 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 ();
643 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
644 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
645}
646
647char *
648SDL_GetError ()
649
650int
362SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO) 651SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)
363 652
364void 653void
365SDL_Quit () 654SDL_Quit ()
366 655
367void 656void
368SDL_ListModes () 657SDL_ListModes (int rgb, int alpha)
369 PPCODE: 658 PPCODE:
370{ 659{
371 SDL_Rect **m; 660 SDL_Rect **m;
372 661
373 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5); 662 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
374 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5); 663 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
375 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5); 664 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
376 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 1); 665 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
377 666
667 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15);
668 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE , 0);
669
378 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE, 0); 670 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE , 0);
379 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0); 671 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
380 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE, 0); 672 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
381 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0); 673 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
382 674
383 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); 675 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
676#if SDL_VERSION_ATLEAST(1,2,10)
384 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15); 677 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
385 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 0); 678 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
679#endif
386 680
387 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 681 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
388 682
389 if (m && m != (SDL_Rect **)-1) 683 if (m && m != (SDL_Rect **)-1)
390 while (*m) 684 while (*m)
391 { 685 {
686 if ((*m)->w >= 640 && (*m)->h >= 480)
687 {
392 AV *av = newAV (); 688 AV *av = newAV ();
393 av_push (av, newSViv ((*m)->w)); 689 av_push (av, newSViv ((*m)->w));
394 av_push (av, newSViv ((*m)->h)); 690 av_push (av, newSViv ((*m)->h));
691 av_push (av, newSViv (rgb));
692 av_push (av, newSViv (alpha));
395 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av))); 693 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
694 }
396 695
397 ++m; 696 ++m;
398 } 697 }
399} 698}
400 699
401int 700int
402SDL_SetVideoMode (int w, int h, int fullscreen) 701SDL_SetVideoMode (int w, int h, int rgb, int alpha, int fullscreen)
403 CODE: 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
404 RETVAL = !!SDL_SetVideoMode ( 712 RETVAL = !!SDL_SetVideoMode (
405 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0) 713 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0)
406 ); 714 );
715
716 if (RETVAL)
717 {
718 av_clear (texture_av);
719
407 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+"); 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}
408 OUTPUT: 726 OUTPUT:
409 RETVAL 727 RETVAL
410 728
411void 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 ()
829
830void
412lowdelay (int fd, int val = 1) 831lowdelay (int fd, int val = 1)
413 CODE: 832 CODE:
833 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val));
834
835void
836win32_proxy_info ()
837 PPCODE:
838{
414#ifndef _WIN32 839#ifdef _WIN32
415 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val)); 840 char buffer[2048];
841 DWORD buflen;
842
843 EXTEND (SP, 3);
844
845 buflen = sizeof (buffer);
846 if (InternetQueryOption (0, INTERNET_OPTION_PROXY, (void *)buffer, &buflen))
847 if (((INTERNET_PROXY_INFO *)buffer)->dwAccessType == INTERNET_OPEN_TYPE_PROXY)
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 }
416#endif 861#endif
417 862}
418char *
419gl_version ()
420 CODE:
421 RETVAL = (char *)glGetString (GL_VERSION);
422 OUTPUT:
423 RETVAL
424
425char *
426gl_extensions ()
427 CODE:
428 RETVAL = (char *)glGetString (GL_EXTENSIONS);
429 OUTPUT:
430 RETVAL
431 863
432void 864void
433add_font (char *file) 865add_font (char *file)
434 CODE: 866 CODE:
435 FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */ 867 FcConfigAppFontAddFile (0, (const FcChar8 *)file);
436
437void
438set_font (char *file)
439 CODE:
440{
441 int count;
442 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)file, 0, 0, &count);
443 PangoFontDescription *font = pango_fc_font_description_from_pattern (pattern, 0);
444 FcPatternDestroy (pattern);
445 pango_context_set_font_description (context, font);
446}
447 868
448void 869void
449load_image_inline (SV *image_) 870load_image_inline (SV *image_)
450 ALIAS: 871 ALIAS:
451 load_image_file = 1 872 load_image_file = 1
… …
454 STRLEN image_len; 875 STRLEN image_len;
455 char *image = (char *)SvPVbyte (image_, image_len); 876 char *image = (char *)SvPVbyte (image_, image_len);
456 SDL_Surface *surface, *surface2; 877 SDL_Surface *surface, *surface2;
457 SDL_PixelFormat fmt; 878 SDL_PixelFormat fmt;
458 SDL_RWops *rw = ix 879 SDL_RWops *rw = ix
459 ? SDL_RWFromFile (image, "r") 880 ? SDL_RWFromFile (image, "rb")
460 : SDL_RWFromConstMem (image, image_len); 881 : SDL_RWFromConstMem (image, image_len);
461 882
462 if (!rw) 883 if (!rw)
463 croak ("load_image: %s", SDL_GetError ()); 884 croak ("load_image: %s", SDL_GetError ());
464 885
… …
493 914
494 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE); 915 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE);
495 916
496 assert (surface2->pitch == surface2->w * 4); 917 assert (surface2->pitch == surface2->w * 4);
497 918
919 SDL_LockSurface (surface2);
498 EXTEND (SP, 5); 920 EXTEND (SP, 6);
499 PUSHs (sv_2mortal (newSViv (surface2->w))); 921 PUSHs (sv_2mortal (newSViv (surface2->w)));
500 PUSHs (sv_2mortal (newSViv (surface2->h))); 922 PUSHs (sv_2mortal (newSViv (surface2->h)));
501 SDL_LockSurface (surface2);
502 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 923 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));
503 SDL_UnlockSurface (surface2);
504 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)));
505 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 925 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
506 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE))); 926 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
927 SDL_UnlockSurface (surface2);
507 928
508 SDL_FreeSurface (surface); 929 SDL_FreeSurface (surface);
509 SDL_FreeSurface (surface2); 930 SDL_FreeSurface (surface2);
510} 931}
511 932
… …
533 PUSHs (sv_2mortal (newSViv (b / y))); 954 PUSHs (sv_2mortal (newSViv (b / y)));
534 PUSHs (sv_2mortal (newSViv (a / y))); 955 PUSHs (sv_2mortal (newSViv (a / y)));
535} 956}
536 957
537void 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
538fatal (char *message) 967fatal (char *message)
539 CODE: 968 CODE:
969 fprintf (stderr, "FATAL: %s\n", message);
540#ifdef _WIN32 970#ifdef _WIN32
541 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND); 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:
978#ifdef WIN32
979 ExitThread (retval); // unclean, please beam me up
542#else 980#else
543 fprintf (stderr, "FATAL: %s\n", message); 981 _exit (retval);
544#endif 982#endif
545 exit (1);
546 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
547MODULE = CFClient PACKAGE = CFClient::Layout 1020MODULE = CFPlus PACKAGE = CFPlus::Layout
548 1021
549CFClient::Layout 1022PROTOTYPES: DISABLE
550new (SV *class, int base_height = 10) 1023
1024void
1025reset_glyph_cache ()
1026 PROTOTYPE:
1027 CODE:
1028 tc_clear ();
1029
1030CFPlus::Layout
1031new (SV *class)
551 CODE: 1032 CODE:
552 New (0, RETVAL, 1, struct cf_layout); 1033 New (0, RETVAL, 1, struct cf_layout);
553 RETVAL->base_height = base_height; 1034
554 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
555 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);
556 OUTPUT: 1046 OUTPUT:
557 RETVAL 1047 RETVAL
558 1048
559void 1049void
560DESTROY (CFClient::Layout self) 1050DESTROY (CFPlus::Layout self)
561 CODE: 1051 CODE:
562 g_object_unref (self->pl); 1052 g_object_unref (self->pl);
1053 rc_free (self->rc);
563 Safefree (self); 1054 Safefree (self);
564 1055
565void 1056void
566set_text (CFClient::Layout self, SV *text_) 1057set_text (CFPlus::Layout self, SV *text_)
567 CODE: 1058 CODE:
568{ 1059{
569 STRLEN textlen; 1060 STRLEN textlen;
570 char *text = SvPVutf8 (text_, textlen); 1061 char *text = SvPVutf8 (text_, textlen);
571 1062
572 pango_layout_set_text (self->pl, text, textlen); 1063 pango_layout_set_text (self->pl, text, textlen);
573} 1064}
574 1065
575void 1066void
576set_markup (CFClient::Layout self, SV *text_) 1067set_markup (CFPlus::Layout self, SV *text_)
577 CODE: 1068 CODE:
578{ 1069{
579 STRLEN textlen; 1070 STRLEN textlen;
580 char *text = SvPVutf8 (text_, textlen); 1071 char *text = SvPVutf8 (text_, textlen);
581 1072
582 pango_layout_set_markup (self->pl, text, textlen); 1073 pango_layout_set_markup (self->pl, text, textlen);
583} 1074}
584 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
585SV * 1161SV *
586get_text (CFClient::Layout self) 1162get_text (CFPlus::Layout self)
587 CODE: 1163 CODE:
588 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0); 1164 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
589 SvUTF8_on (RETVAL); 1165 sv_utf8_decode (RETVAL);
590 OUTPUT: 1166 OUTPUT:
591 RETVAL 1167 RETVAL
592 1168
593void 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
594set_height (CFClient::Layout self, int base_height) 1187set_height (CFPlus::Layout self, int base_height)
595 CODE: 1188 CODE:
1189 if (self->base_height != base_height)
1190 {
596 self->base_height = base_height; 1191 self->base_height = base_height;
1192 layout_update_font (self);
1193 }
597 1194
598void 1195void
599set_width (CFClient::Layout self, int max_width = -1) 1196set_width (CFPlus::Layout self, int max_width = -1)
600 CODE: 1197 CODE:
601 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);
602 1199
603void 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
604size (CFClient::Layout self) 1226size (CFPlus::Layout self)
605 PPCODE: 1227 PPCODE:
606{ 1228{
607 int w, h; 1229 int w, h;
608 1230
609 layout_update (self);
610 layout_get_pixel_size (self, &w, &h); 1231 layout_get_pixel_size (self, &w, &h);
611 1232
612 EXTEND (SP, 2); 1233 EXTEND (SP, 2);
613 PUSHs (sv_2mortal (newSViv (w))); 1234 PUSHs (sv_2mortal (newSViv (w)));
614 PUSHs (sv_2mortal (newSViv (h))); 1235 PUSHs (sv_2mortal (newSViv (h)));
615} 1236}
616 1237
617int 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
618xy_to_index (CFClient::Layout self, int x, int y) 1251xy_to_index (CFPlus::Layout self, int x, int y)
619 CODE: 1252 CODE:
620{ 1253{
621 int index, trailing; 1254 int index, trailing;
622
623 layout_update (self);
624 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);
625
626 RETVAL = index; 1256 RETVAL = index + trailing;
627} 1257}
628 OUTPUT: 1258 OUTPUT:
629 RETVAL 1259 RETVAL
630 1260
631void 1261void
632cursor_pos (CFClient::Layout self, int index) 1262cursor_pos (CFPlus::Layout self, int index)
633 PPCODE: 1263 PPCODE:
634{ 1264{
635 PangoRectangle strong_pos; 1265 PangoRectangle strong_pos;
636 layout_update (self);
637 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1266 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);
638 1267
639 EXTEND (SP, 3); 1268 EXTEND (SP, 3);
640 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1269 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));
641 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1270 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
642 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1271 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));
643} 1272}
644 1273
645void 1274void
646render (CFClient::Layout self) 1275index_to_line_x (CFPlus::Layout self, int index, int trailing = 0)
647 PPCODE: 1276 PPCODE:
648{ 1277{
649 SV *retval; 1278 int line, x;
650 int w, h;
651 FT_Bitmap bitmap;
652 1279
653 layout_update (self); 1280 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
654 layout_get_pixel_size (self, &w, &h); 1281 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
655 1282
656 retval = newSV (w * h);
657 SvPOK_only (retval);
658 SvCUR_set (retval, w * h);
659
660 bitmap.rows = h;
661 bitmap.width = w;
662 bitmap.pitch = w;
663 bitmap.buffer = (unsigned char*)SvPVX (retval);
664 bitmap.num_grays = 256;
665 bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
666
667 memset (bitmap.buffer, 0, w * h);
668
669 pango_ft2_render_layout (&bitmap, self->pl, 0 * PANGO_SCALE, 0 * PANGO_SCALE);
670
671 EXTEND (SP, 3); 1283 EXTEND (SP, 2);
672 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 {
673 PUSHs (sv_2mortal (newSViv (h))); 1308 PUSHs (sv_2mortal (newSViv (index)));
674 PUSHs (sv_2mortal (retval)); 1309 PUSHs (sv_2mortal (newSViv (trailing)));
1310 }
675} 1311}
676 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
677MODULE = CFClient PACKAGE = CFClient::Texture 1347MODULE = CFPlus PACKAGE = CFPlus::Texture
678 1348
1349PROTOTYPES: ENABLE
1350
1351int minpot (int n)
1352
679void 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
680draw_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.)
681 PROTOTYPE: $$$;$$ 1377 PROTOTYPE: $$$;$$
1378 ALIAS:
1379 draw_quad_alpha = 1
1380 draw_quad_alpha_premultiplied = 2
682 CODE: 1381 CODE:
683{ 1382{
684 HV *hv = (HV *)SvRV (self); 1383 HV *hv = (HV *)SvRV (self);
685 float s = SvNV (*hv_fetch (hv, "s", 1, 1)); 1384 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
686 float t = SvNV (*hv_fetch (hv, "t", 1, 1)); 1385 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
687 int name = SvIV (*hv_fetch (hv, "name", 4, 1)); 1386 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
688 int wrap_mode = SvIV (*hv_fetch (hv, "wrap_mode", 9, 1)); 1387
1388 if (name <= 0)
1389 XSRETURN_EMPTY;
689 1390
690 if (items < 5) 1391 if (items < 5)
691 { 1392 {
692 w = SvNV (*hv_fetch (hv, "w", 1, 1)); 1393 w = SvNV (*hv_fetch (hv, "w", 1, 1));
693 h = SvNV (*hv_fetch (hv, "h", 1, 1)); 1394 h = SvNV (*hv_fetch (hv, "h", 1, 1));
694 } 1395 }
695 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
696 glBindTexture (GL_TEXTURE_2D, name); 1411 glBindTexture (GL_TEXTURE_2D, name);
697 if (wrap_mode) { 1412
698 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
699 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
700 }
701 glBegin (GL_QUADS); 1413 glBegin (GL_QUADS);
702 glTexCoord2f (0, 0); glVertex2f (x , y ); 1414 glTexCoord2f (0, 0); glVertex2f (x , y );
703 glTexCoord2f (0, t); glVertex2f (x , y + h); 1415 glTexCoord2f (0, t); glVertex2f (x , y + h);
704 glTexCoord2f (s, t); glVertex2f (x + w, y + h); 1416 glTexCoord2f (s, t); glVertex2f (x + w, y + h);
705 glTexCoord2f (s, 0); glVertex2f (x + w, y ); 1417 glTexCoord2f (s, 0); glVertex2f (x + w, y );
706 glEnd (); 1418 glEnd ();
707}
708 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
709MODULE = CFClient PACKAGE = CFClient::Map 1438MODULE = CFPlus PACKAGE = CFPlus::Map
710 1439
711CFClient::Map 1440PROTOTYPES: DISABLE
712new (SV *class, int map_width, int map_height) 1441
1442CFPlus::Map
1443new (SV *class)
713 CODE: 1444 CODE:
714 New (0, RETVAL, 1, struct map); 1445 New (0, RETVAL, 1, struct map);
715 RETVAL->x = 0; 1446 RETVAL->x = 0;
716 RETVAL->y = 0; 1447 RETVAL->y = 0;
717 RETVAL->w = map_width; 1448 RETVAL->w = 0;
718 RETVAL->h = map_height; 1449 RETVAL->h = 0;
719 RETVAL->ox = 0; 1450 RETVAL->ox = 0;
720 RETVAL->oy = 0; 1451 RETVAL->oy = 0;
721 RETVAL->faces = 8192; 1452 RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
722 Newz (0, RETVAL->face, RETVAL->faces, mapface); 1453 RETVAL->texs = 8192; Newz (0, RETVAL->tex , RETVAL->texs , maptex);
723 RETVAL->texs = 8192;
724 Newz (0, RETVAL->tex, RETVAL->texs, maptex);
725 RETVAL->rows = 0; 1454 RETVAL->rows = 0;
726 RETVAL->row = 0; 1455 RETVAL->row = 0;
727 OUTPUT: 1456 OUTPUT:
728 RETVAL 1457 RETVAL
729 1458
730void 1459void
731DESTROY (CFClient::Map self) 1460DESTROY (CFPlus::Map self)
732 CODE: 1461 CODE:
733{ 1462{
734 map_clear (self); 1463 map_clear (self);
735 Safefree (self->face); 1464 Safefree (self->face2tile);
1465 Safefree (self->tex);
736 Safefree (self); 1466 Safefree (self);
737} 1467}
738 1468
739void 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
740clear (CFClient::Map self) 1476clear (CFPlus::Map self)
741 CODE: 1477 CODE:
742 map_clear (self); 1478 map_clear (self);
743 1479
744void 1480void
745set_face (CFClient::Map self, int face, int texid) 1481set_tileid (CFPlus::Map self, int face, int tile)
746 CODE: 1482 CODE:
747{ 1483{
748 while (self->faces <= face) 1484 need_facenum (self, face); self->face2tile [face] = tile;
749 { 1485 need_texid (self, tile);
750 Append (mapface, self->face, self->faces, self->faces);
751 self->faces *= 2;
752 }
753
754 self->face [face] = texid;
755} 1486}
756 1487
757void 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
758set_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)
759 CODE: 1513 CODE:
760{ 1514{
761 while (self->texs <= texid) 1515 need_texid (self, texid);
762 {
763 Append (maptex, self->tex, self->texs, self->texs);
764 self->texs *= 2;
765 }
766 1516
767 { 1517 {
768 maptex *tex = self->tex + texid; 1518 maptex *tex = self->tex + texid;
769 1519
770 tex->name = name; 1520 tex->name = name;
… …
775 tex->r = r; 1525 tex->r = r;
776 tex->g = g; 1526 tex->g = g;
777 tex->b = b; 1527 tex->b = b;
778 tex->a = a; 1528 tex->a = a;
779 } 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);
780} 1539}
781 1540
782int 1541int
783ox (CFClient::Map self) 1542ox (CFPlus::Map self)
784 ALIAS: 1543 ALIAS:
785 oy = 1 1544 oy = 1
1545 x = 2
1546 y = 3
1547 w = 4
1548 h = 5
786 CODE: 1549 CODE:
787 switch (ix) 1550 switch (ix)
788 { 1551 {
789 case 0: RETVAL = self->ox; break; 1552 case 0: RETVAL = self->ox; break;
790 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;
791 } 1558 }
792 OUTPUT: 1559 OUTPUT:
793 RETVAL 1560 RETVAL
794 1561
795void 1562void
796scroll (CFClient::Map self, int dx, int dy) 1563scroll (CFPlus::Map self, int dx, int dy)
797 CODE: 1564 CODE:
798{ 1565{
799 if (dx > 0) 1566 if (dx > 0)
800 map_blank (self, self->x, self->y, dx - 1, self->h); 1567 map_blank (self, self->x, self->y, dx, self->h);
801 else if (dx < 0) 1568 else if (dx < 0)
802 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);
803 1570
804 if (dy > 0) 1571 if (dy > 0)
805 map_blank (self, self->x, self->y, self->w, dy - 1); 1572 map_blank (self, self->x, self->y, self->w, dy);
806 else if (dy < 0) 1573 else if (dy < 0)
807 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);
808 1575
809 self->ox += dx; self->x += dx; 1576 self->ox += dx; self->x += dx;
810 self->oy += dy; self->y += dy; 1577 self->oy += dy; self->y += dy;
811 1578
812 while (self->y < 0) 1579 while (self->y < 0)
… …
816 self->rows += MAP_EXTEND_Y; 1583 self->rows += MAP_EXTEND_Y;
817 self->y += MAP_EXTEND_Y; 1584 self->y += MAP_EXTEND_Y;
818 } 1585 }
819} 1586}
820 1587
821void 1588SV *
822map1a_update (CFClient::Map self, SV *data_) 1589map1a_update (CFPlus::Map self, SV *data_, int extmap)
823 CODE: 1590 CODE:
824{ 1591{
825 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 1592 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
826 uint8_t *data_end = (uint8_t *)SvEND (data_); 1593 uint8_t *data_end = (uint8_t *)SvEND (data_);
827 mapcell *cell; 1594 mapcell *cell;
828 int x, y, flags; 1595 int x, y, z, flags;
1596 AV *missing = newAV ();
1597 RETVAL = newRV_noinc ((SV *)missing);
829 1598
830 while (data < data_end) 1599 while (data < data_end - 1)
831 { 1600 {
832 flags = (data [0] << 8) + data [1]; data += 2; 1601 flags = (data [0] << 8) + data [1]; data += 2;
833 1602
834 x = ((flags >> 10) & 63) + self->x; 1603 x = self->x + ((flags >> 10) & 63);
835 y = ((flags >> 4) & 63) + self->y; 1604 y = self->y + ((flags >> 4) & 63);
836 1605
837 cell = map_get_cell (self, x, y); 1606 cell = map_get_cell (self, x, y);
838 1607
839 if (flags & 15) 1608 if (flags & 15)
840 { 1609 {
841 if (cell->darkness < 0) 1610 if (!cell->darkness)
842 { 1611 {
1612 memset (cell, 0, sizeof (*cell));
843 cell->darkness = 0; 1613 cell->darkness = 256;
844 cell->face [0] = 0;
845 cell->face [1] = 0;
846 cell->face [2] = 0;
847 } 1614 }
848 1615
849 cell->darkness = flags & 8 ? *data++ : 255;
850
851 //TODO: don't trust server data to be in-range(!) 1616 //TODO: don't trust server data to be in-range(!)
852 1617
853 if (flags & 4) 1618 if (flags & 8)
854 { 1619 {
855 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;
856 } 1656 }
857 1657
1658 for (z = 0; z <= 2; ++z)
858 if (flags & 2) 1659 if (flags & (4 >> z))
859 { 1660 {
860 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 }
861 } 1678 }
862
863 if (flags & 1)
864 {
865 cell->face [2] = self->face [(data [0] << 8) + data [1]]; data += 2;
866 }
867 } 1679 }
868 else 1680 else
869 cell->darkness = -1; 1681 cell->darkness = 0;
870 } 1682 }
871} 1683}
1684 OUTPUT:
1685 RETVAL
872 1686
873SV * 1687SV *
874mapmap (CFClient::Map self, int w, int h) 1688mapmap (CFPlus::Map self, int x0, int y0, int w, int h)
875 CODE: 1689 CODE:
876{ 1690{
877 int x0, x1, x; 1691 int x1, x;
878 int y0, y1, y; 1692 int y1, y;
879 int z; 1693 int z;
880 SV *map_sv = newSV (w * h * sizeof (uint32_t)); 1694 SV *map_sv = newSV (w * h * sizeof (uint32_t));
881 uint32_t *map = (uint32_t *)SvPVX (map_sv); 1695 uint32_t *map = (uint32_t *)SvPVX (map_sv);
882 1696
883 SvPOK_only (map_sv); 1697 SvPOK_only (map_sv);
884 SvCUR_set (map_sv, w * h * sizeof (uint32_t)); 1698 SvCUR_set (map_sv, w * h * sizeof (uint32_t));
885 1699
886 x0 = self->x - w / 2; x1 = x0 + w; 1700 x0 += self->x; x1 = x0 + w;
887 y0 = self->y - h / 2; y1 = y0 + h; 1701 y0 += self->y; y1 = y0 + h;
888 1702
889 for (y = y0; y < y1; y++) 1703 for (y = y0; y < y1; y++)
890 { 1704 {
891 maprow *row = 0 <= y && y < self->rows 1705 maprow *row = 0 <= y && y < self->rows
892 ? self->row + y 1706 ? self->row + y
… …
900 { 1714 {
901 mapcell *cell = row->col + (x - row->c0); 1715 mapcell *cell = row->col + (x - row->c0);
902 1716
903 for (z = 0; z <= 0; z++) 1717 for (z = 0; z <= 0; z++)
904 { 1718 {
905 mapface face = cell->face [z];
906
907 if (face)
908 {
909 maptex tex = self->tex [face]; 1719 maptex tex = self->tex [cell->tile [z]];
910 int a0 = 255 - tex.a; 1720 int a0 = 255 - tex.a;
911 int a1 = tex.a; 1721 int a1 = tex.a;
912 1722
913 r = (r * a0 + tex.r * a1) / 255; 1723 r = (r * a0 + tex.r * a1) / 255;
914 g = (g * a0 + tex.g * a1) / 255; 1724 g = (g * a0 + tex.g * a1) / 255;
915 b = (b * a0 + tex.b * a1) / 255; 1725 b = (b * a0 + tex.b * a1) / 255;
916 a = (a * a0 + tex.a * a1) / 255; 1726 a = (a * a0 + tex.a * a1) / 255;
917 }
918 } 1727 }
919 } 1728 }
920 1729
921 *map++ = (r ) 1730 *map++ = (r )
922 | (g << 8) 1731 | (g << 8)
… …
929} 1738}
930 OUTPUT: 1739 OUTPUT:
931 RETVAL 1740 RETVAL
932 1741
933void 1742void
934draw (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)
935 PPCODE: 2085 PPCODE:
936{ 2086{
937 int vx, vy;
938 int x, y, z; 2087 int x, y;
939 int last_name; 2088 int sw1 = sw + 2;
940 mapface face; 2089 int sh1 = sh + 2;
2090 int sh3 = sh * 3;
941 int sw4 = (sw + 3) & ~3; 2091 int sw34 = (sw * 3 + 3) & ~3;
2092 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
942 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh)); 2093 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));
943 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv); 2094 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
944 2095
945 memset (darkness, 255, sw4 * sh);
946 SvPOK_only (darkness_sv); 2096 SvPOK_only (darkness3_sv);
947 SvCUR_set (darkness_sv, sw4 * sh); 2097 SvCUR_set (darkness3_sv, sw34 * sh3);
948 2098
949 vx = self->x + (self->w - sw) / 2 - shift_x; 2099 mx += self->x - 1;
950 vy = self->y + (self->h - sh) / 2 - shift_y; 2100 my += self->y - 1;
951 2101
952 /* 2102 memset (darkness1, 255, sw1 * sh1);
953 int vx = self->vx = self->w >= sw
954 ? self->x + (self->w - sw) / 2
955 : MIN (self->x, MAX (self->x + self->w - sw + 1, self->vx));
956 2103
957 int vy = self->vy = self->h >= sh
958 ? self->y + (self->h - sh) / 2
959 : MIN (self->y, MAX (self->y + self->h - sh + 1, self->vy));
960 */
961
962 glColor4ub (255, 255, 255, 255);
963
964 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
965 glEnable (GL_BLEND);
966 glEnable (GL_TEXTURE_2D);
967 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
968
969 glBegin (GL_QUADS);
970
971 last_name = 0;
972
973 for (z = 0; z < 3; z++)
974 for (y = 0; y < sh; y++) 2104 for (y = 0; y < sh1; y++)
975 if (0 <= y + vy && y + vy < self->rows) 2105 if (0 <= y + my && y + my < self->rows)
976 { 2106 {
977 maprow *row = self->row + (y + vy); 2107 maprow *row = self->row + (y + my);
978 2108
979 for (x = 0; x < sw; x++) 2109 for (x = 0; x < sw1; x++)
980 if (row->c0 <= x + vx && x + vx < row->c1) 2110 if (row->c0 <= x + mx && x + mx < row->c1)
981 { 2111 {
982 mapcell *cell = row->col + (x + vx - row->c0); 2112 mapcell *cell = row->col + (x + mx - row->c0);
983 2113
984 darkness[y * sw4 + x] = cell->darkness < 0 2114 darkness1 [y * sw1 + x] = cell->darkness
2115 ? 255 - (cell->darkness - 1)
985 ? 255 - FOW_DARKNESS 2116 : 255 - FOW_DARKNESS;
986 : 255 - cell->darkness;
987
988 face = cell->face [z];
989
990 if (face)
991 {
992 maptex tex = self->tex [face];
993
994 int px = (x + 1) * 32 - tex.w;
995 int py = (y + 1) * 32 - tex.h;
996
997 if (last_name != tex.name)
998 {
999 glEnd ();
1000 last_name = tex.name;
1001 glBindTexture (GL_TEXTURE_2D, last_name);
1002 glBegin (GL_QUADS);
1003 }
1004
1005 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1006 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1007 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1008 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1009 }
1010 } 2117 }
1011 } 2118 }
1012 2119
1013 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];
1014 2132
1015 glDisable (GL_TEXTURE_2D); 2133 uint8_t r11 = (d11 + d21 + d12) / 3;
1016 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);
1017 2157
1018 EXTEND (SP, 3); 2158 EXTEND (SP, 3);
1019 PUSHs (sv_2mortal (newSViv (sw4))); 2159 PUSHs (sv_2mortal (newSViv (sw34)));
1020 PUSHs (sv_2mortal (newSViv (sh))); 2160 PUSHs (sv_2mortal (newSViv (sh3)));
1021 PUSHs (darkness_sv); 2161 PUSHs (darkness3_sv);
1022} 2162}
1023 2163
1024SV * 2164SV *
1025get_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)
1026 CODE: 2166 CODE:
1027{ 2167{
1028 int x, y, x1, y1; 2168 int x, y, x1, y1;
1029 SV *data_sv = newSV (w * h * 7 + 5); 2169 SV *data_sv = newSV (w * h * 7 + 5);
1030 uint8_t *data = (uint8_t *)SvPVX (data_sv); 2170 uint8_t *data = (uint8_t *)SvPVX (data_sv);
… …
1032 *data++ = 0; /* version 0 format */ 2172 *data++ = 0; /* version 0 format */
1033 *data++ = w >> 8; *data++ = w; 2173 *data++ = w >> 8; *data++ = w;
1034 *data++ = h >> 8; *data++ = h; 2174 *data++ = h >> 8; *data++ = h;
1035 2175
1036 // 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
1037 // TODO: treat rows as we treat 2177 // TODO: treat rows as we treat columns
1038 map_get_row (self, y0 + self->y - self->oy);//D 2178 map_get_row (self, y0 + self->y - self->oy);//D
1039 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
1040 2180
1041 x0 += self->x - self->ox; 2181 x0 += self->x - self->ox;
1042 y0 += self->y - self->oy; 2182 y0 += self->y - self->oy;
… …
1055 if (row && row->c0 <= x && x < row->c1) 2195 if (row && row->c0 <= x && x < row->c1)
1056 { 2196 {
1057 mapcell *cell = row->col + (x - row->c0); 2197 mapcell *cell = row->col + (x - row->c0);
1058 uint8_t flags = 0; 2198 uint8_t flags = 0;
1059 2199
1060 if (cell->face [0]) flags |= 1; 2200 if (cell->tile [0]) flags |= 1;
1061 if (cell->face [1]) flags |= 2; 2201 if (cell->tile [1]) flags |= 2;
1062 if (cell->face [2]) flags |= 4; 2202 if (cell->tile [2]) flags |= 4;
1063 2203
1064 *data++ = flags; 2204 *data++ = flags;
1065 2205
1066 if (flags & 1) 2206 if (flags & 1)
1067 { 2207 {
2208 tileid tile = cell->tile [0];
1068 *data++ = cell->face [0] >> 8; 2209 *data++ = tile >> 8;
1069 *data++ = cell->face [0]; 2210 *data++ = tile;
1070 } 2211 }
1071 2212
1072 if (flags & 2) 2213 if (flags & 2)
1073 { 2214 {
2215 tileid tile = cell->tile [1];
1074 *data++ = cell->face [1] >> 8; 2216 *data++ = tile >> 8;
1075 *data++ = cell->face [1]; 2217 *data++ = tile;
1076 } 2218 }
1077 2219
1078 if (flags & 4) 2220 if (flags & 4)
1079 { 2221 {
2222 tileid tile = cell->tile [2];
1080 *data++ = cell->face [2] >> 8; 2223 *data++ = tile >> 8;
1081 *data++ = cell->face [2]; 2224 *data++ = tile;
1082 } 2225 }
1083 } 2226 }
1084 else 2227 else
1085 *data++ = 0; 2228 *data++ = 0;
1086 } 2229 }
… …
1092} 2235}
1093 OUTPUT: 2236 OUTPUT:
1094 RETVAL 2237 RETVAL
1095 2238
1096void 2239void
1097set_rect (CFClient::Map self, int x0, int y0, uint8_t *data) 2240set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data)
1098 PPCODE: 2241 PPCODE:
1099{ 2242{
1100 int x, y, z; 2243 int x, y, z;
1101 int w, h; 2244 int w, h;
1102 int x1, y1; 2245 int x1, y1;
1103 2246
1104 if (*data++ != 0) 2247 if (*data++ != 0)
1105 return; /* version mismatch */ 2248 XSRETURN_EMPTY; /* version mismatch */
1106 2249
1107 w = *data++ << 8; w |= *data++; 2250 w = *data++ << 8; w |= *data++;
1108 h = *data++ << 8; h |= *data++; 2251 h = *data++ << 8; h |= *data++;
1109 2252
1110 // 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
1111 // TODO: treat rows as we treat 2254 // TODO: treat rows as we treat columns
1112 map_get_row (self, y0 + self->y - self->oy);//D 2255 map_get_row (self, y0 + self->y - self->oy);//D
1113 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
1114 2257
1115 x0 += self->x - self->ox; 2258 x0 += self->x - self->ox;
1116 y0 += self->y - self->oy; 2259 y0 += self->y - self->oy;
… …
1126 { 2269 {
1127 uint8_t flags = *data++; 2270 uint8_t flags = *data++;
1128 2271
1129 if (flags) 2272 if (flags)
1130 { 2273 {
1131 mapface face[3] = { 0, 0, 0 };
1132
1133 mapcell *cell = row_get_cell (row, x); 2274 mapcell *cell = row_get_cell (row, x);
2275 tileid tile[3] = { 0, 0, 0 };
1134 2276
1135 if (flags & 1) { face[0] = *data++ << 8; face[0] |= *data++; } 2277 if (flags & 1) { tile[0] = *data++ << 8; tile[0] |= *data++; }
1136 if (flags & 2) { face[1] = *data++ << 8; face[1] |= *data++; } 2278 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
1137 if (flags & 4) { face[2] = *data++ << 8; face[2] |= *data++; } 2279 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
1138 2280
1139 if (cell->darkness <= 0) 2281 if (cell->darkness == 0)
1140 { 2282 {
1141 cell->darkness = -1; 2283 cell->darkness = 0;
1142 2284
1143 for (z = 0; z <= 2; z++) 2285 for (z = 0; z <= 2; z++)
1144 { 2286 {
1145 cell->face[z] = face[z]; 2287 tileid t = tile [z];
1146 2288
1147 if (face[z] && (face[z] >= self->texs || !self->tex[face [z]].name)) 2289 if (t >= self->texs || (t && !self->tex [t].name))
2290 {
1148 XPUSHs (sv_2mortal (newSViv (face[z]))); 2291 XPUSHs (sv_2mortal (newSViv (t)));
2292 need_texid (self, t);
2293 }
2294
2295 cell->tile [z] = t;
1149 } 2296 }
1150 } 2297 }
1151 } 2298 }
1152 } 2299 }
1153 } 2300 }
1154} 2301}
1155 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
2762void glRect_lineloop (float x1, float y1, float x2, float y2)
2763 CODE:
2764 glBegin (GL_LINE_LOOP);
2765 glVertex2f (x1, y1);
2766 glVertex2f (x2, y1);
2767 glVertex2f (x2, y2);
2768 glVertex2f (x1, y2);
2769 glEnd ();
2770
2771PROTOTYPES: ENABLE
2772
2773void glBegin (int mode)
2774
2775void glEnd ()
2776
2777void glPointSize (GLfloat size)
2778
2779void glLineWidth (GLfloat width)
2780
2781void glInterleavedArrays (int format, int stride, char *data)
2782
2783void glDrawElements (int mode, int count, int type, char *indices)
2784
2785# 1.2 void glDrawRangeElements (int mode, int start, int end
2786
2787void glTexEnv (int target, int pname, float param)
2788 CODE:
2789 glTexEnvf (target, pname, param);
2790
2791void glTexParameter (int target, int pname, float param)
2792 CODE:
2793 glTexParameterf (target, pname, param);
2794
2795void glBindTexture (int target, int name)
2796
2797void glConvolutionParameter (int target, int pname, float params)
2798 CODE:
2799 if (gl.ConvolutionParameterf)
2800 gl.ConvolutionParameterf (target, pname, params);
2801
2802void glConvolutionFilter2D (int target, int internalformat, int width, int height, int format, int type, char *data)
2803 CODE:
2804 if (gl.ConvolutionFilter2D)
2805 gl.ConvolutionFilter2D (target, internalformat, width, height, format, type, data);
2806
2807void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column)
2808 CODE:
2809 if (gl.SeparableFilter2D)
2810 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);
2811
2812void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data)
2813
2814void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
2815
2816void glDrawPixels (int width, int height, int format, int type, char *pixels)
2817
2818void glPixelZoom (float x, float y)
2819
2820void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
2821
2822int glGenTexture ()
2823 CODE:
2824 RETVAL = gen_texture ();
2825 OUTPUT:
2826 RETVAL
2827
2828void glDeleteTexture (int name)
2829 CODE:
2830 del_texture (name);
2831
2832int glGenList ()
2833 CODE:
2834 RETVAL = glGenLists (1);
2835 OUTPUT:
2836 RETVAL
2837
2838void glDeleteList (int list)
2839 CODE:
2840 glDeleteLists (list, 1);
2841
2842void glNewList (int list, int mode = GL_COMPILE)
2843
2844void glEndList ()
2845
2846void glCallList (int list)
2847
2848MODULE = CFPlus PACKAGE = CFPlus::UI::Base
2849
2850PROTOTYPES: DISABLE
2851
2852void
2853find_widget (SV *self, NV x, NV y)
2854 PPCODE:
2855{
2856 if (within_widget (self, x, y))
2857 XPUSHs (self);
2858}
2859
2860BOOT:
2861{
2862 hover_gv = gv_fetchpv ("CFPlus::UI::HOVER", 1, SVt_NV);
2863
2864 draw_x_gv = gv_fetchpv ("CFPlus::UI::Base::draw_x", 1, SVt_NV);
2865 draw_y_gv = gv_fetchpv ("CFPlus::UI::Base::draw_y", 1, SVt_NV);
2866 draw_w_gv = gv_fetchpv ("CFPlus::UI::Base::draw_w", 1, SVt_NV);
2867 draw_h_gv = gv_fetchpv ("CFPlus::UI::Base::draw_h", 1, SVt_NV);
2868}
2869
2870void
2871draw (SV *self)
2872 CODE:
2873{
2874 HV *hv;
2875 SV **svp;
2876 NV x, y, w, h;
2877 SV *draw_x_sv = GvSV (draw_x_gv);
2878 SV *draw_y_sv = GvSV (draw_y_gv);
2879 SV *draw_w_sv = GvSV (draw_w_gv);
2880 SV *draw_h_sv = GvSV (draw_h_gv);
2881 double draw_x, draw_y;
2882
2883 if (!SvROK (self))
2884 croak ("CFPlus::Base::draw: %s not a reference", SvPV_nolen (self));
2885
2886 hv = (HV *)SvRV (self);
2887
2888 if (SvTYPE (hv) != SVt_PVHV)
2889 croak ("CFPlus::Base::draw: %s not a hashref", SvPV_nolen (self));
2890
2891 svp = hv_fetch (hv, "w", 1, 0); w = svp ? SvNV (*svp) : 0.;
2892 svp = hv_fetch (hv, "h", 1, 0); h = svp ? SvNV (*svp) : 0.;
2893
2894 if (!h || !w)
2895 XSRETURN_EMPTY;
2896
2897 svp = hv_fetch (hv, "x", 1, 0); x = svp ? SvNV (*svp) : 0.;
2898 svp = hv_fetch (hv, "y", 1, 0); y = svp ? SvNV (*svp) : 0.;
2899
2900 draw_x = SvNV (draw_x_sv) + x;
2901 draw_y = SvNV (draw_y_sv) + y;
2902
2903 if (draw_x + w < 0 || draw_x >= SvNV (draw_w_sv)
2904 || draw_y + h < 0 || draw_y >= SvNV (draw_h_sv))
2905 XSRETURN_EMPTY;
2906
2907 sv_setnv (draw_x_sv, draw_x);
2908 sv_setnv (draw_y_sv, draw_y);
2909
2910 glPushMatrix ();
2911 glTranslated (x, y, 0);
2912
2913 if (SvROK (GvSV (hover_gv)) && SvRV (GvSV (hover_gv)) == (SV *)hv)
2914 {
2915 svp = hv_fetch (hv, "can_hover", sizeof ("can_hover") - 1, 0);
2916
2917 if (svp && SvTRUE (*svp))
2918 {
2919 glColor4f (1.0f * 0.2f, 0.8f * 0.2f, 0.5f * 0.2f, 0.2f);
2920 glEnable (GL_BLEND);
2921 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2922 glBegin (GL_QUADS);
2923 glVertex2f (0, 0);
2924 glVertex2f (w, 0);
2925 glVertex2f (w, h);
2926 glVertex2f (0, h);
2927 glEnd ();
2928 glDisable (GL_BLEND);
2929 }
2930 }
2931#if 0
2932 if ($ENV{CFPLUS_DEBUG} & 1) {
2933 glPushMatrix;
2934 glColor 1, 1, 0, 1;
2935 glTranslate 0.375, 0.375;
2936 glBegin GL_LINE_LOOP;
2937 glVertex 0 , 0;
2938 glVertex $self->{w} - 1, 0;
2939 glVertex $self->{w} - 1, $self->{h} - 1;
2940 glVertex 0 , $self->{h} - 1;
2941 glEnd;
2942 glPopMatrix;
2943 #CFPlus::UI::Label->new (w => $self->{w}, h => $self->{h}, text => $self, fontsize => 0)->_draw;
2944 }
2945#endif
2946 PUSHMARK (SP);
2947 XPUSHs (self);
2948 PUTBACK;
2949 call_method ("_draw", G_VOID | G_DISCARD);
2950 SPAGAIN;
2951
2952 glPopMatrix ();
2953
2954 draw_x = draw_x - x; sv_setnv (draw_x_sv, draw_x);
2955 draw_y = draw_y - y; sv_setnv (draw_y_sv, draw_y);
2956}
2957

Diff Legend

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