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

Diff Legend

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