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.32 by root, Thu Apr 13 23:31:42 2006 UTC vs.
Revision 1.223 by root, Sat Aug 11 11:07:08 2007 UTC

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

Diff Legend

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