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.39 by root, Sat Apr 15 00:04:58 2006 UTC vs.
Revision 1.211 by root, Sat Jul 28 00:45:28 2007 UTC

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

Diff Legend

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