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.40 by root, Sat Apr 15 01:13:46 2006 UTC vs.
Revision 1.221 by root, Fri Aug 10 04:02:13 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, 0); 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 uint8_t r, g, b, a; 204 uint8_t r, g, b, a;
72} mapface; 205 tileid smoothtile;
206 uint8_t smoothlevel;
207} maptex;
73 208
74typedef struct { 209typedef struct {
210 uint32_t player;
211 tileid tile[3];
75 int16_t darkness; 212 uint16_t darkness;
76 uint16_t face[3]; 213 uint8_t stat_width, stat_hp, flags, smoothmax;
77} mapcell; 214} mapcell;
78 215
79typedef struct { 216typedef struct {
80 int32_t c0, c1; 217 int32_t c0, c1;
81 mapcell *col; 218 mapcell *col;
82} maprow; 219} maprow;
83 220
84typedef struct map { 221typedef struct map {
85 int x, y, w, h; 222 int x, y, w, h;
86 int vx, vy; 223 int ox, oy; /* offset to virtual global coordinate system */
87 int faces; 224 int faces; tileid *face2tile; // [faceid]
88 mapface *face; 225 int texs; maptex *tex; // [tileid]
89 226
90 uint32_t rows; 227 int32_t rows;
91 maprow *row; 228 maprow *row;
92} *CFClient__Map; 229} *CFPlus__Map;
93 230
94static char * 231static char *
95prepend (char *ptr, int sze, int inc) 232prepend (char *ptr, int sze, int inc)
96{ 233{
97 char *p; 234 char *p;
… …
115 252
116#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))
117#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))
118 255
119static 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
120map_clear (CFClient__Map self) 331map_clear (CFPlus__Map self)
121{ 332{
122 int r; 333 int r;
123 334
124 for (r = 0; r < self->rows; r++) 335 for (r = 0; r < self->rows; r++)
125 Safefree (self->row[r].col); 336 Safefree (self->row[r].col);
126 337
127 Safefree (self->row); 338 Safefree (self->row);
128 339
129 self->x = 0; 340 self->x = 0;
130 self->y = 0; 341 self->y = 0;
131 self->vx = 0; 342 self->ox = 0;
132 self->vy = 0; 343 self->oy = 0;
133 self->row = 0; 344 self->row = 0;
134 self->rows = 0; 345 self->rows = 0;
135} 346}
136 347
137static void 348static void
138map_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)
139{ 350{
140 int x, y; 351 int x, y;
352 maprow *row;
353 mapcell *cell;
141 354
142 for (y = y0; y < y0 + h; y++) 355 for (y = y0; y < y0 + h; y++)
143 if (y >= 0) 356 if (y >= 0)
144 { 357 {
145 if (y >= self->rows) 358 if (y >= self->rows)
146 break; 359 break;
147 360
148 maprow *row = self->row + y; 361 row = self->row + y;
149 362
150 for (x = x0; x < x0 + w; x++) 363 for (x = x0; x < x0 + w; x++)
151 if (x >= row->c0) 364 if (x >= row->c0)
152 { 365 {
153 if (x >= row->c1) 366 if (x >= row->c1)
154 break; 367 break;
155 368
156 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;
157 } 375 }
158 } 376 }
159} 377}
160 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
161MODULE = CFClient PACKAGE = CFClient 485MODULE = CFPlus PACKAGE = CFPlus
162 486
163PROTOTYPES: ENABLE 487PROTOTYPES: ENABLE
164 488
165BOOT: 489BOOT:
166{ 490{
167 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 ();
168 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);
169 context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)fontmap); 637 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
170} 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 ()
171 822
172void 823void
173lowdelay (int fd, int val = 1) 824lowdelay (int fd, int val = 1)
174 CODE: 825 CODE:
175 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val)); 826 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val));
176 827
177char * 828void
178gl_version () 829win32_proxy_info ()
179 CODE: 830 PPCODE:
180 RETVAL = (char *)glGetString (GL_VERSION); 831{
181 OUTPUT: 832#ifdef _WIN32
182 RETVAL 833 char buffer[2048];
834 DWORD buflen;
183 835
184char * 836 EXTEND (SP, 3);
185gl_extensions () 837
186 CODE: 838 buflen = sizeof (buffer);
187 RETVAL = (char *)glGetString (GL_EXTENSIONS); 839 if (InternetQueryOption (0, INTERNET_OPTION_PROXY, (void *)buffer, &buflen))
188 OUTPUT: 840 if (((INTERNET_PROXY_INFO *)buffer)->dwAccessType == INTERNET_OPEN_TYPE_PROXY)
189 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}
190 856
191void 857void
192add_font (char *file) 858add_font (char *file)
193 CODE: 859 CODE:
194 FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */ 860 FcConfigAppFontAddFile (0, (const FcChar8 *)file);
195
196void
197set_font (char *file)
198 CODE:
199{
200 int count;
201 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)file, 0, 0, &count);
202 PangoFontDescription *font = pango_fc_font_description_from_pattern (pattern, 0);
203 FcPatternDestroy (pattern);
204 pango_context_set_font_description (context, font);
205}
206 861
207void 862void
208load_image_inline (SV *image_) 863load_image_inline (SV *image_)
209 ALIAS: 864 ALIAS:
210 load_image_file = 1 865 load_image_file = 1
… …
213 STRLEN image_len; 868 STRLEN image_len;
214 char *image = (char *)SvPVbyte (image_, image_len); 869 char *image = (char *)SvPVbyte (image_, image_len);
215 SDL_Surface *surface, *surface2; 870 SDL_Surface *surface, *surface2;
216 SDL_PixelFormat fmt; 871 SDL_PixelFormat fmt;
217 SDL_RWops *rw = ix 872 SDL_RWops *rw = ix
218 ? SDL_RWFromFile (image, "r") 873 ? SDL_RWFromFile (image, "rb")
219 : SDL_RWFromConstMem (image, image_len); 874 : SDL_RWFromConstMem (image, image_len);
220 875
221 if (!rw) 876 if (!rw)
222 croak ("load_image: unable to open file"); 877 croak ("load_image: %s", SDL_GetError ());
223 878
224 surface = IMG_Load_RW (rw, 1); 879 surface = IMG_Load_RW (rw, 1);
225 if (!surface) 880 if (!surface)
226 croak ("load_image: unable to read file"); 881 croak ("load_image: %s", SDL_GetError ());
227 882
228 fmt.palette = NULL; 883 fmt.palette = NULL;
229 fmt.BitsPerPixel = 32; 884 fmt.BitsPerPixel = 32;
230 fmt.BytesPerPixel = 4; 885 fmt.BytesPerPixel = 4;
886#if SDL_BYTEORDER == SDL_LIL_ENDIAN
231 fmt.Rmask = 0x000000ff; 887 fmt.Rmask = 0x000000ff;
232 fmt.Gmask = 0x0000ff00; 888 fmt.Gmask = 0x0000ff00;
233 fmt.Bmask = 0x00ff0000; 889 fmt.Bmask = 0x00ff0000;
234 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
235 fmt.Rloss = 0; 897 fmt.Rloss = 0;
236 fmt.Gloss = 0; 898 fmt.Gloss = 0;
237 fmt.Bloss = 0; 899 fmt.Bloss = 0;
238 fmt.Aloss = 0; 900 fmt.Aloss = 0;
239 fmt.Rshift = 0; 901 fmt.Rshift = 0;
… …
245 907
246 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE); 908 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE);
247 909
248 assert (surface2->pitch == surface2->w * 4); 910 assert (surface2->pitch == surface2->w * 4);
249 911
912 SDL_LockSurface (surface2);
250 EXTEND (SP, 5); 913 EXTEND (SP, 6);
251 PUSHs (sv_2mortal (newSViv (surface2->w))); 914 PUSHs (sv_2mortal (newSViv (surface2->w)));
252 PUSHs (sv_2mortal (newSViv (surface2->h))); 915 PUSHs (sv_2mortal (newSViv (surface2->h)));
253 SDL_LockSurface (surface2);
254 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 916 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));
255 SDL_UnlockSurface (surface2);
256 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB))); 917 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));
257 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 918 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
258 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_INT_8_8_8_8_REV))); 919 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
920 SDL_UnlockSurface (surface2);
259 921
260 SDL_FreeSurface (surface); 922 SDL_FreeSurface (surface);
261 SDL_FreeSurface (surface2); 923 SDL_FreeSurface (surface2);
262} 924}
263 925
… …
285 PUSHs (sv_2mortal (newSViv (b / y))); 947 PUSHs (sv_2mortal (newSViv (b / y)));
286 PUSHs (sv_2mortal (newSViv (a / y))); 948 PUSHs (sv_2mortal (newSViv (a / y)));
287} 949}
288 950
289void 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
290fatal (char *message) 960fatal (char *message)
291 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:
292#ifdef WIN32 971#ifdef WIN32
293 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND); 972 ExitThread (retval); // unclean, please beam me up
294#else 973#else
295 fprintf (stderr, "FATAL: %s\n", message); 974 _exit (retval);
296#endif 975#endif
297 exit (1);
298 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
299MODULE = CFClient PACKAGE = CFClient::Layout 1013MODULE = CFPlus PACKAGE = CFPlus::Layout
300 1014
301CFClient::Layout 1015PROTOTYPES: DISABLE
302new (SV *class, int base_height = 10) 1016
1017void
1018reset_glyph_cache ()
1019 PROTOTYPE:
1020 CODE:
1021 tc_clear ();
1022
1023CFPlus::Layout
1024new (SV *class)
303 CODE: 1025 CODE:
304 New (0, RETVAL, 1, struct cf_layout); 1026 New (0, RETVAL, 1, struct cf_layout);
305 RETVAL->base_height = base_height; 1027
306 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
307 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);
308 OUTPUT: 1038 OUTPUT:
309 RETVAL 1039 RETVAL
310 1040
311void 1041void
312DESTROY (CFClient::Layout self) 1042DESTROY (CFPlus::Layout self)
313 CODE: 1043 CODE:
314 g_object_unref (self->pl); 1044 g_object_unref (self->pl);
315 Safefree (self); 1045 Safefree (self);
316 1046
317void 1047void
318set_text (CFClient::Layout self, SV *text_) 1048set_text (CFPlus::Layout self, SV *text_)
319 CODE: 1049 CODE:
320{ 1050{
321 STRLEN textlen; 1051 STRLEN textlen;
322 char *text = SvPVutf8 (text_, textlen); 1052 char *text = SvPVutf8 (text_, textlen);
323 1053
324 pango_layout_set_text (self->pl, text, textlen); 1054 pango_layout_set_text (self->pl, text, textlen);
325} 1055}
326 1056
327void 1057void
328set_markup (CFClient::Layout self, SV *text_) 1058set_markup (CFPlus::Layout self, SV *text_)
329 CODE: 1059 CODE:
330{ 1060{
331 STRLEN textlen; 1061 STRLEN textlen;
332 char *text = SvPVutf8 (text_, textlen); 1062 char *text = SvPVutf8 (text_, textlen);
333 1063
334 pango_layout_set_markup (self->pl, text, textlen); 1064 pango_layout_set_markup (self->pl, text, textlen);
335} 1065}
336 1066
337void 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
338set_height (CFClient::Layout self, int base_height) 1178set_height (CFPlus::Layout self, int base_height)
339 CODE: 1179 CODE:
1180 if (self->base_height != base_height)
1181 {
340 self->base_height = base_height; 1182 self->base_height = base_height;
1183 layout_update_font (self);
1184 }
341 1185
342void 1186void
343set_width (CFClient::Layout self, int max_width = -1) 1187set_width (CFPlus::Layout self, int max_width = -1)
344 CODE: 1188 CODE:
345 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);
346 1190
347void 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
348size (CFClient::Layout self) 1217size (CFPlus::Layout self)
349 PPCODE: 1218 PPCODE:
350{ 1219{
351 int w, h; 1220 int w, h;
352 1221
353 layout_update (self);
354 layout_get_pixel_size (self, &w, &h); 1222 layout_get_pixel_size (self, &w, &h);
355 1223
356 EXTEND (SP, 2); 1224 EXTEND (SP, 2);
357 PUSHs (sv_2mortal (newSViv (w))); 1225 PUSHs (sv_2mortal (newSViv (w)));
358 PUSHs (sv_2mortal (newSViv (h))); 1226 PUSHs (sv_2mortal (newSViv (h)));
359} 1227}
360 1228
361int 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
362xy_to_index (CFClient::Layout self, int x, int y) 1242xy_to_index (CFPlus::Layout self, int x, int y)
363 CODE: 1243 CODE:
364{ 1244{
365 int index, trailing; 1245 int index, trailing;
366
367 layout_update (self);
368 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);
369
370 RETVAL = index; 1247 RETVAL = index + trailing;
371} 1248}
372 OUTPUT: 1249 OUTPUT:
373 RETVAL 1250 RETVAL
374 1251
375void 1252void
376cursor_pos (CFClient::Layout self, int index) 1253cursor_pos (CFPlus::Layout self, int index)
377 PPCODE: 1254 PPCODE:
378{ 1255{
379 PangoRectangle strong_pos; 1256 PangoRectangle strong_pos;
380 layout_update (self);
381 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1257 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);
382 1258
383 EXTEND (SP, 3); 1259 EXTEND (SP, 3);
384 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1260 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));
385 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1261 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
386 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1262 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));
387} 1263}
388 1264
389void 1265void
390render (CFClient::Layout self) 1266index_to_line_x (CFPlus::Layout self, int index, int trailing = 0)
391 PPCODE: 1267 PPCODE:
392{ 1268{
393 SV *retval; 1269 int line, x;
394 int w, h;
395 FT_Bitmap bitmap;
396 1270
397 layout_update (self); 1271 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
398 layout_get_pixel_size (self, &w, &h); 1272 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
399 1273
400 retval = newSV (w * h);
401 SvPOK_only (retval);
402 SvCUR_set (retval, w * h);
403
404 bitmap.rows = h;
405 bitmap.width = w;
406 bitmap.pitch = w;
407 bitmap.buffer = (unsigned char*)SvPVX (retval);
408 bitmap.num_grays = 256;
409 bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
410
411 memset (bitmap.buffer, 0, w * h);
412
413 pango_ft2_render_layout (&bitmap, self->pl, 0 * PANGO_SCALE, 0 * PANGO_SCALE);
414
415 EXTEND (SP, 3); 1274 EXTEND (SP, 2);
416 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 {
417 PUSHs (sv_2mortal (newSViv (h))); 1299 PUSHs (sv_2mortal (newSViv (index)));
418 PUSHs (sv_2mortal (retval)); 1300 PUSHs (sv_2mortal (newSViv (trailing)));
1301 }
419} 1302}
420 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
421MODULE = CFClient PACKAGE = CFClient::Texture 1314MODULE = CFPlus PACKAGE = CFPlus::Texture
422 1315
1316PROTOTYPES: ENABLE
1317
1318int minpot (int n)
1319
423void 1320void
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
424draw_quad (SV *self, float x, float y, float w = 0, float h = 0) 1343draw_quad (SV *self, float x, float y, float w = 0., float h = 0.)
425 PROTOTYPE: $$$;$$ 1344 PROTOTYPE: $$$;$$
1345 ALIAS:
1346 draw_quad_alpha = 1
1347 draw_quad_alpha_premultiplied = 2
426 CODE: 1348 CODE:
427{ 1349{
428 HV *hv = (HV *)SvRV (self); 1350 HV *hv = (HV *)SvRV (self);
429 float s = SvNV (*hv_fetch (hv, "s", 1, 1)); 1351 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
430 float t = SvNV (*hv_fetch (hv, "t", 1, 1)); 1352 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
431 int name = SvIV (*hv_fetch (hv, "name", 4, 1)); 1353 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
432 int wrap_mode = SvIV (*hv_fetch (hv, "wrap_mode", 9, 1)); 1354
1355 if (name <= 0)
1356 XSRETURN_EMPTY;
433 1357
434 if (items < 5) 1358 if (items < 5)
435 { 1359 {
436 w = SvNV (*hv_fetch (hv, "w", 1, 1)); 1360 w = SvNV (*hv_fetch (hv, "w", 1, 1));
437 h = SvNV (*hv_fetch (hv, "h", 1, 1)); 1361 h = SvNV (*hv_fetch (hv, "h", 1, 1));
438 } 1362 }
439 1363
1364 if (ix)
1365 {
1366 glEnable (GL_BLEND);
1367
1368 if (ix == 2)
1369 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1370 else
1371 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1372 GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1373
1374 glEnable (GL_ALPHA_TEST);
1375 glAlphaFunc (GL_GREATER, 0.01f);
1376 }
1377
440 glBindTexture (GL_TEXTURE_2D, name); 1378 glBindTexture (GL_TEXTURE_2D, name);
441 if (wrap_mode) { 1379
442 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
443 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
444 }
445 glBegin (GL_QUADS); 1380 glBegin (GL_QUADS);
446 glTexCoord2f (0, 0); glVertex2f (x , y ); 1381 glTexCoord2f (0, 0); glVertex2f (x , y );
447 glTexCoord2f (0, t); glVertex2f (x , y + h); 1382 glTexCoord2f (0, t); glVertex2f (x , y + h);
448 glTexCoord2f (s, t); glVertex2f (x + w, y + h); 1383 glTexCoord2f (s, t); glVertex2f (x + w, y + h);
449 glTexCoord2f (s, 0); glVertex2f (x + w, y ); 1384 glTexCoord2f (s, 0); glVertex2f (x + w, y );
450 glEnd (); 1385 glEnd ();
451}
452 1386
1387 if (ix)
1388 {
1389 glDisable (GL_ALPHA_TEST);
1390 glDisable (GL_BLEND);
1391 }
1392}
1393
1394IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1395 CODE:
1396{
1397 GLint width;
1398 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
1399 glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
1400 RETVAL = width > 0;
1401}
1402 OUTPUT:
1403 RETVAL
1404
453MODULE = CFClient PACKAGE = CFClient::Map 1405MODULE = CFPlus PACKAGE = CFPlus::Map
454 1406
455CFClient::Map 1407PROTOTYPES: DISABLE
456new (SV *class, int map_width, int map_height) 1408
1409CFPlus::Map
1410new (SV *class)
457 CODE: 1411 CODE:
458 New (0, RETVAL, 1, struct map); 1412 New (0, RETVAL, 1, struct map);
459 RETVAL->x = 0; 1413 RETVAL->x = 0;
460 RETVAL->y = 0; 1414 RETVAL->y = 0;
461 RETVAL->w = map_width; 1415 RETVAL->w = 0;
462 RETVAL->h = map_height; 1416 RETVAL->h = 0;
463 RETVAL->vx = 0; 1417 RETVAL->ox = 0;
464 RETVAL->vy = 0; 1418 RETVAL->oy = 0;
465 RETVAL->faces = 8192; 1419 RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
466 Newz (0, RETVAL->face, RETVAL->faces, mapface); 1420 RETVAL->texs = 8192; Newz (0, RETVAL->tex , RETVAL->texs , maptex);
467 RETVAL->rows = 0; 1421 RETVAL->rows = 0;
468 RETVAL->row = 0; 1422 RETVAL->row = 0;
469 OUTPUT: 1423 OUTPUT:
470 RETVAL 1424 RETVAL
471 1425
472void 1426void
473DESTROY (CFClient::Map self) 1427DESTROY (CFPlus::Map self)
474 CODE: 1428 CODE:
475{ 1429{
476 map_clear (self); 1430 map_clear (self);
477 Safefree (self->face); 1431 Safefree (self->face2tile);
1432 Safefree (self->tex);
478 Safefree (self); 1433 Safefree (self);
479} 1434}
480 1435
481void 1436void
1437resize (CFPlus::Map self, int map_width, int map_height)
1438 CODE:
1439 self->w = map_width;
1440 self->h = map_height;
1441
1442void
482clear (CFClient::Map self) 1443clear (CFPlus::Map self)
483 CODE: 1444 CODE:
484 map_clear (self); 1445 map_clear (self);
485 1446
486void 1447void
1448set_tileid (CFPlus::Map self, int face, int tile)
1449 CODE:
1450{
1451 need_facenum (self, face); self->face2tile [face] = tile;
1452 need_texid (self, tile);
1453}
1454
1455void
1456set_smooth (CFPlus::Map self, int face, int smooth, int level)
1457 CODE:
1458{
1459 tileid texid;
1460 maptex *tex;
1461
1462 if (face < 0 || face >= self->faces)
1463 return;
1464
1465 if (smooth < 0 || smooth >= self->faces)
1466 return;
1467
1468 texid = self->face2tile [face];
1469
1470 if (!texid)
1471 return;
1472
1473 tex = self->tex + texid;
1474 tex->smoothtile = self->face2tile [smooth];
1475 tex->smoothlevel = level;
1476}
1477
1478void
487set_texture (CFClient::Map self, int face, int name, int w, int h, float s, float t, int r, int g, int b, int a) 1479set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
488 CODE: 1480 CODE:
489{ 1481{
490 while (self->faces < face) 1482 need_texid (self, texid);
1483
1484 {
1485 maptex *tex = self->tex + texid;
1486
1487 tex->name = name;
1488 tex->w = w;
1489 tex->h = h;
1490 tex->s = s;
1491 tex->t = t;
1492 tex->r = r;
1493 tex->g = g;
1494 tex->b = b;
1495 tex->a = a;
1496 }
1497
1498 // somewhat hackish, but for textures that require it, it really
1499 // improves the look, and most others don't suffer.
1500 glBindTexture (GL_TEXTURE_2D, name);
1501 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1502 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1503 // use uglier nearest interpolation because linear suffers
1504 // from transparent color bleeding and ugly wrapping effects.
1505 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1506}
1507
1508int
1509ox (CFPlus::Map self)
1510 ALIAS:
1511 oy = 1
1512 x = 2
1513 y = 3
1514 w = 4
1515 h = 5
1516 CODE:
1517 switch (ix)
491 { 1518 {
492 Append (mapface, self->face, self->faces, self->faces); 1519 case 0: RETVAL = self->ox; break;
493 self->faces *= 2; 1520 case 1: RETVAL = self->oy; break;
1521 case 2: RETVAL = self->x; break;
1522 case 3: RETVAL = self->y; break;
1523 case 4: RETVAL = self->w; break;
1524 case 5: RETVAL = self->h; break;
494 } 1525 }
1526 OUTPUT:
1527 RETVAL
495 1528
496 mapface *f = self->face + face;
497
498 f->name = name;
499 f->w = w;
500 f->h = h;
501 f->s = s;
502 f->t = t;
503 f->r = r;
504 f->g = g;
505 f->b = b;
506 f->a = a;
507}
508
509void 1529void
510scroll (CFClient::Map self, int dx, int dy) 1530scroll (CFPlus::Map self, int dx, int dy)
511 CODE: 1531 CODE:
512{ 1532{
513 if (dx > 0) 1533 if (dx > 0)
514 map_blank (self, self->x, self->y, dx - 1, self->h); 1534 map_blank (self, self->x, self->y, dx, self->h);
515 else if (dx < 0) 1535 else if (dx < 0)
516 map_blank (self, self->x + self->w + dx + 1, self->y, 1 - dx, self->h); 1536 map_blank (self, self->x + self->w + dx, self->y, -dx, self->h);
517 1537
518 if (dy > 0) 1538 if (dy > 0)
519 map_blank (self, self->x, self->y, self->w, dy - 1); 1539 map_blank (self, self->x, self->y, self->w, dy);
520 else if (dy < 0) 1540 else if (dy < 0)
521 map_blank (self, self->x, self->y + self->h + dy + 1, self->w, 1 - dy); 1541 map_blank (self, self->x, self->y + self->h + dy, self->w, -dy);
522 1542
523 self->x += dx; 1543 self->ox += dx; self->x += dx;
524 self->y += dy; 1544 self->oy += dy; self->y += dy;
525 1545
526 while (self->y < 0) 1546 while (self->y < 0)
527 { 1547 {
528 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y); 1548 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
529 1549
530 self->rows += MAP_EXTEND_Y; 1550 self->rows += MAP_EXTEND_Y;
531 self->y += MAP_EXTEND_Y; 1551 self->y += MAP_EXTEND_Y;
532 } 1552 }
533} 1553}
534 1554
535void 1555SV *
536map1a_update (CFClient::Map self, SV *data_) 1556map1a_update (CFPlus::Map self, SV *data_, int extmap)
537 CODE: 1557 CODE:
538{ 1558{
539 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 1559 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
540 uint8_t *data_end = (uint8_t *)SvEND (data_); 1560 uint8_t *data_end = (uint8_t *)SvEND (data_);
541 1561 mapcell *cell;
1562 int x, y, z, flags;
1563 AV *missing = newAV ();
1564 RETVAL = newRV_noinc ((SV *)missing);
1565
542 while (data < data_end) 1566 while (data < data_end - 1)
543 { 1567 {
544 int flags = (data [0] << 8) + data [1]; data += 2; 1568 flags = (data [0] << 8) + data [1]; data += 2;
545 1569
546 int x = ((flags >> 10) & 63) + self->x; 1570 x = self->x + ((flags >> 10) & 63);
547 int y = ((flags >> 4) & 63) + self->y; 1571 y = self->y + ((flags >> 4) & 63);
548 1572
549 while (y >= self->rows) 1573 cell = map_get_cell (self, x, y);
550 {
551 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
552
553 self->rows += MAP_EXTEND_Y;
554 }
555
556 maprow *row = self->row + y;
557
558 if (!row->col)
559 {
560 Newz (0, row->col, MAP_EXTEND_X, mapcell);
561 row->c0 = self->x - MAP_EXTEND_X / 4;
562 row->c1 = row->c0 + MAP_EXTEND_X;
563 }
564
565 if (row->c0 > x)
566 {
567 int extend = row->c0 - x + MAP_EXTEND_X;
568 Prepend (mapcell, row->col, row->c1 - row->c0, extend);
569 row->c0 -= extend;
570 }
571 else if (x >= row->c1)
572 {
573 int extend = x - row->c1 + MAP_EXTEND_X;
574 Append (mapcell, row->col, row->c1 - row->c0, extend);
575 row->c1 += extend;
576 }
577
578 assert (y >= 0);
579 assert (y < self->rows);
580 assert (x >= row->c0);
581 assert (x < row->c1);
582 mapcell *cell = row->col + (x - row->c0);
583 1574
584 if (flags & 15) 1575 if (flags & 15)
585 { 1576 {
586 if (cell->darkness < 0 && x < self->w && y < self->h) 1577 if (!cell->darkness)
587 { 1578 {
1579 memset (cell, 0, sizeof (*cell));
588 cell->darkness = 0; 1580 cell->darkness = 256;
589 cell->face [0] = 0;
590 cell->face [1] = 0;
591 cell->face [2] = 0;
592 } 1581 }
593
594 cell->darkness = flags & 8 ? *data++ : 255;
595 1582
1583 //TODO: don't trust server data to be in-range(!)
1584
596 if (flags & 4) 1585 if (flags & 8)
597 { 1586 {
598 cell->face [0] = (data [0] << 8) + data [1]; data += 2; 1587 if (extmap)
1588 {
1589 uint8_t ext, cmd;
1590
1591 do
1592 {
1593 ext = *data++;
1594 cmd = ext & 0x3f;
1595
1596 if (cmd < 4)
1597 cell->darkness = 255 - ext * 64 + 1;
1598 else if (cmd == 5) // health
1599 {
1600 cell->stat_width = 1;
1601 cell->stat_hp = *data++;
1602 }
1603 else if (cmd == 6) // monster width
1604 cell->stat_width = *data++ + 1;
1605 else if (cmd == 0x47)
1606 {
1607 if (*data == 4)
1608 ; // decode player count
1609
1610 data += *data + 1;
1611 }
1612 else if (cmd == 8) // cell flags
1613 cell->flags = *data++;
1614 else if (ext & 0x40) // unknown, multibyte => skip
1615 data += *data + 1;
1616 else
1617 data++;
1618 }
1619 while (ext & 0x80);
1620 }
1621 else
1622 cell->darkness = *data++ + 1;
599 } 1623 }
600 1624
1625 for (z = 0; z <= 2; ++z)
601 if (flags & 2) 1626 if (flags & (4 >> z))
602 { 1627 {
603 cell->face [1] = (data [0] << 8) + data [1]; data += 2; 1628 faceid face = (data [0] << 8) + data [1]; data += 2;
1629 need_facenum (self, face);
1630 cell->tile [z] = self->face2tile [face];
1631
1632 if (cell->tile [z])
1633 {
1634 maptex *tex = self->tex + cell->tile [z];
1635 if (!tex->name)
1636 av_push (missing, newSViv (cell->tile [z]));
1637
1638 if (tex->smoothtile)
1639 {
1640 maptex *smooth = self->tex + tex->smoothtile;
1641 if (!smooth->name)
1642 av_push (missing, newSViv (tex->smoothtile));
1643 }
1644 }
604 } 1645 }
605
606 if (flags & 1)
607 {
608 cell->face [2] = (data [0] << 8) + data [1]; data += 2;
609 }
610 } 1646 }
611 else 1647 else
612 cell->darkness = -1; 1648 cell->darkness = 0;
613 } 1649 }
614} 1650}
1651 OUTPUT:
1652 RETVAL
615 1653
616SV * 1654SV *
617mapmap (CFClient::Map self, int w, int h) 1655mapmap (CFPlus::Map self, int x0, int y0, int w, int h)
618 CODE: 1656 CODE:
619{ 1657{
620 int x0, x1, x; 1658 int x1, x;
621 int y0, y1, y; 1659 int y1, y;
622 int z; 1660 int z;
623 SV *map_sv = newSV (w * h * sizeof (uint32_t)); 1661 SV *map_sv = newSV (w * h * sizeof (uint32_t));
624 uint32_t *map = (uint32_t *)SvPVX (map_sv); 1662 uint32_t *map = (uint32_t *)SvPVX (map_sv);
625 1663
626 SvPOK_only (map_sv); 1664 SvPOK_only (map_sv);
627 SvCUR_set (map_sv, w * h * sizeof (uint32_t)); 1665 SvCUR_set (map_sv, w * h * sizeof (uint32_t));
628 1666
629 x0 = self->x - w / 2; x1 = x0 + w; 1667 x0 += self->x; x1 = x0 + w;
630 y0 = self->y - h / 2; y1 = y0 + h; 1668 y0 += self->y; y1 = y0 + h;
631 1669
632 for (y = y0; y < y1; y++) 1670 for (y = y0; y < y1; y++)
633 { 1671 {
634 maprow *row = 0 <= y && y < self->rows 1672 maprow *row = 0 <= y && y < self->rows
635 ? self->row + y 1673 ? self->row + y
… …
643 { 1681 {
644 mapcell *cell = row->col + (x - row->c0); 1682 mapcell *cell = row->col + (x - row->c0);
645 1683
646 for (z = 0; z <= 0; z++) 1684 for (z = 0; z <= 0; z++)
647 { 1685 {
648 uint16_t face = cell->face [z]; 1686 maptex tex = self->tex [cell->tile [z]];
649
650 if (face)
651 {
652 mapface tex = self->face [face];
653 int a0 = 255 - tex.a; 1687 int a0 = 255 - tex.a;
654 int a1 = tex.a; 1688 int a1 = tex.a;
655 1689
656 r = (r * a0 + tex.r * a1) / 255; 1690 r = (r * a0 + tex.r * a1) / 255;
657 g = (g * a0 + tex.g * a1) / 255; 1691 g = (g * a0 + tex.g * a1) / 255;
658 b = (b * a0 + tex.b * a1) / 255; 1692 b = (b * a0 + tex.b * a1) / 255;
659 a = (a * a0 + tex.a * a1) / 255; 1693 a = (a * a0 + tex.a * a1) / 255;
660 }
661 } 1694 }
662 } 1695 }
663 1696
664 *map++ = (r ) 1697 *map++ = (r )
665 | (g << 8) 1698 | (g << 8)
… …
672} 1705}
673 OUTPUT: 1706 OUTPUT:
674 RETVAL 1707 RETVAL
675 1708
676void 1709void
677draw (CFClient::Map self, int shift_x, int shift_y, int x0, int y0, int sw, int sh) 1710draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T)
678 PPCODE: 1711 CODE:
679{ 1712{
680 int sw4 = (sw + 3) & ~3; 1713 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
681 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh)); 1714 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
682 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv); 1715 static uint8_t smooth_max[256][256]; // egad, fats and wasteful on memory (64k)
1716 smooth_key skey;
1717 int x, y, z;
1718 int last_name;
683 1719
684 SvPOK_only (darkness_sv); 1720 // thats current max. sorry.
685 SvCUR_set (darkness_sv, sw4 * sh); 1721 if (sw > 255) sw = 255;
1722 if (sh > 255) sh = 255;
686 1723
687 int vx = self->x + (self->w - sw) / 2 - shift_x; 1724 // clear key, in case of extra padding
688 int vy = self->y + (self->h - sh) / 2 - shift_y; 1725 memset (&skey, 0, sizeof (skey));
689
690 if (0)
691 {
692 int vx = self->vx = self->w >= sw
693 ? self->x + (self->w - sw) / 2
694 : MIN (self->x, MAX (self->x + self->w - sw + 1, self->vx));
695
696 int vy = self->vy = self->h >= sh
697 ? self->y + (self->h - sh) / 2
698 : MIN (self->y, MAX (self->y + self->h - sh + 1, self->vy));
699 }
700 1726
701 glColor4ub (255, 255, 255, 255); 1727 glColor4ub (255, 255, 255, 255);
702 1728
1729 glEnable (GL_BLEND);
703 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 1730 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
704 glEnable (GL_BLEND);
705 glEnable (GL_TEXTURE_2D); 1731 glEnable (GL_TEXTURE_2D);
706 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 1732 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
707 1733
708 int x, y, z;
709
710 int last_name = 0;
711
712 glBegin (GL_QUADS); 1734 glBegin (GL_QUADS);
713 1735
1736 last_name = -1;
1737
1738 mx += self->x;
1739 my += self->y;
1740
1741 // first pass: determine smooth_max
1742 // rather ugly, if you ask me
1743 // could also be stored inside mapcell and updated on change
1744 memset (smooth_max, 0, sizeof (smooth_max));
1745
1746 for (y = 0; y < sh; y++)
1747 if (0 <= y + my && y + my < self->rows)
1748 {
1749 maprow *row = self->row + (y + my);
1750
1751 for (x = 0; x < sw; x++)
1752 if (row->c0 <= x + mx && x + mx < row->c1)
1753 {
1754 mapcell *cell = row->col + (x + mx - row->c0);
1755
1756 smooth_max[x + 1][y + 1] =
1757 MAX (self->tex [cell->tile [0]].smoothlevel,
1758 MAX (self->tex [cell->tile [1]].smoothlevel,
1759 self->tex [cell->tile [2]].smoothlevel));
1760 }
1761 }
1762
714 for (z = 0; z < 3; z++) 1763 for (z = 0; z <= 2; z++)
1764 {
1765 memset (smooth_level, 0, sizeof (smooth_level));
1766
715 for (y = 0; y < sh; y++) 1767 for (y = 0; y < sh; y++)
716 if (0 <= y + vy && y + vy < self->rows) 1768 if (0 <= y + my && y + my < self->rows)
717 { 1769 {
718 maprow *row = self->row + (y + vy); 1770 maprow *row = self->row + (y + my);
719 1771
720 for (x = 0; x < sw; x++) 1772 for (x = 0; x < sw; x++)
721 if (row->c0 <= x + vx && x + vx < row->c1) 1773 if (row->c0 <= x + mx && x + mx < row->c1)
722 { 1774 {
723 mapcell *cell = row->col + (x + vx - row->c0); 1775 mapcell *cell = row->col + (x + mx - row->c0);
724
725 darkness[y * sw4 + x] = cell->darkness < 0
726 ? 255 - FOW_DARKNESS
727 : 255 - cell->darkness;
728
729 uint16_t face = cell->face [z]; 1776 tileid tile = cell->tile [z];
730 1777
731 if (face) 1778 if (tile)
1779 {
1780 maptex tex = self->tex [tile];
1781 int px, py;
1782
1783 // suppressing texture state switches here
1784 // is only moderately effective, but worth the extra effort
1785 if (last_name != tex.name)
1786 {
1787 if (!tex.name)
1788 tex = self->tex [2]; /* missing, replace by noface */
1789
1790 glEnd ();
1791 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1792 glBegin (GL_QUADS);
1793 }
1794
1795 px = (x + 1) * T - tex.w;
1796 py = (y + 1) * T - tex.h;
1797
1798 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1799 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1800 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1801 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1802
1803 if (cell->flags && z == 2)
1804 {
1805 if (cell->flags & 1)
1806 {
1807 maptex tex = self->tex [1];
1808 int px = x * T + T * 2 / 32;
1809 int py = y * T - T * 6 / 32;
1810
1811 glEnd ();
1812 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1813 glBegin (GL_QUADS);
1814
1815 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1816 glTexCoord2f (0 , tex.t); glVertex2f (px , py + T);
1817 glTexCoord2f (tex.s, tex.t); glVertex2f (px + T, py + T);
1818 glTexCoord2f (tex.s, 0 ); glVertex2f (px + T, py );
1819 }
1820 }
1821
1822 // update smooth hash
1823 if (tex.smoothtile)
1824 {
1825 skey.tile = tex.smoothtile;
1826 skey.level = tex.smoothlevel;
1827
1828 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31);
1829
1830 // add bits to current tile and all neighbours. skey.x|y is
1831 // shifted +1|+1 so we always stay positive.
1832
1833 // bits is ___n cccc CCCC bbbb
1834 // n do not draw borders&corners
1835 // c draw these corners, but...
1836 // C ... not these
1837 // b draw these borders
1838
1839 // borders: 1 ┃· 2 ━━ 4 ·┃ 8 ··
1840 // ┃· ·· ·┃ ━━
1841
1842 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1843 // ·· ·· ·┏ ┓·
1844
1845 // full tile
1846 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000);
1847
1848 // borders
1849 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091);
1850 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032);
1851 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064);
1852 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8);
1853
1854 // corners
1855 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);
1856 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);
1857 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);
1858 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);
1859 }
1860 }
1861 }
1862 }
1863
1864 // go through all smoothlevels, lowest to highest, then draw.
1865 // this is basically counting sort
1866 {
1867 int w, b;
1868
1869 for (w = 0; w < 256 / 32; ++w)
1870 {
1871 uint32_t smask = smooth_level [w];
1872 if (smask)
1873 for (b = 0; b < 32; ++b)
1874 if (smask & (((uint32_t)1) << b))
732 { 1875 {
733 mapface tex = self->face [face]; 1876 int level = (w << 5) | b;
1877 HE *he;
734 1878
735 int px = (x + 1) * 32 - tex.w; 1879 hv_iterinit (smooth);
736 int py = (y + 1) * 32 - tex.h; 1880 while ((he = hv_iternext (smooth)))
737
738 if (last_name != tex.name)
739 { 1881 {
1882 smooth_key *skey = (smooth_key *)HeKEY (he);
1883 IV bits = SvIVX (HeVAL (he));
1884
1885 if (!(bits & 0x1000)
1886 && skey->level == level
1887 && level > smooth_max [skey->x][skey->y])
1888 {
1889 maptex tex = self->tex [skey->tile];
1890 int px = (((int)skey->x) - 1) * T;
1891 int py = (((int)skey->y) - 1) * T;
1892 int border = bits & 15;
1893 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1894 float dx = tex.s * .0625f; // 16 images/row
1895 float dy = tex.t * .5f ; // 2 images/column
1896
1897 // this time naively avoiding texture state changes
1898 // save gobs of state changes.
1899 if (last_name != tex.name)
1900 {
1901 if (!tex.name)
1902 continue; // smoothing not yet available
1903
740 glEnd (); 1904 glEnd ();
741 last_name = tex.name;
742 glBindTexture (GL_TEXTURE_2D, last_name); 1905 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
743 glBegin (GL_QUADS); 1906 glBegin (GL_QUADS);
1907 }
1908
1909 if (border)
1910 {
1911 float ox = border * dx;
1912
1913 glTexCoord2f (ox , 0.f ); glVertex2f (px , py );
1914 glTexCoord2f (ox , dy ); glVertex2f (px , py + T);
1915 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py + T);
1916 glTexCoord2f (ox + dx, 0.f ); glVertex2f (px + T, py );
1917 }
1918
1919 if (corner)
1920 {
1921 float ox = corner * dx;
1922
1923 glTexCoord2f (ox , dy ); glVertex2f (px , py );
1924 glTexCoord2f (ox , dy * 2.f); glVertex2f (px , py + T);
1925 glTexCoord2f (ox + dx, dy * 2.f); glVertex2f (px + T, py + T);
1926 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py );
1927 }
1928 }
744 } 1929 }
745
746 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
747 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
748 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
749 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
750 } 1930 }
751 }
752 } 1931 }
1932 }
1933
1934 hv_clear (smooth);
1935 }
753 1936
754 glEnd (); 1937 glEnd ();
755 1938
756 glDisable (GL_TEXTURE_2D); 1939 glDisable (GL_TEXTURE_2D);
757 glDisable (GL_BLEND); 1940 glDisable (GL_BLEND);
758 1941
1942 // top layer: overlays such as the health bar
1943 for (y = 0; y < sh; y++)
1944 if (0 <= y + my && y + my < self->rows)
1945 {
1946 maprow *row = self->row + (y + my);
1947
1948 for (x = 0; x < sw; x++)
1949 if (row->c0 <= x + mx && x + mx < row->c1)
1950 {
1951 mapcell *cell = row->col + (x + mx - row->c0);
1952
1953 int px = x * T;
1954 int py = y * T;
1955
1956 if (cell->stat_hp)
1957 {
1958 int width = cell->stat_width * T;
1959 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
1960
1961 glColor3ub (0, 0, 0);
1962 glRectf (px + 1, py - thick - 2,
1963 px + width - 1, py);
1964
1965 glColor3ub (cell->stat_hp, 255 - cell->stat_hp, 0);
1966 glRectf (px + 2,
1967 py - thick - 1,
1968 px + width - 2 - cell->stat_hp * (width - 4) / 255, py - 1);
1969 }
1970 }
1971 }
1972}
1973
1974void
1975draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data)
1976 CODE:
1977{
1978 static float color[16][3] = {
1979 { 0.00F, 0.00F, 0.00F },
1980 { 1.00F, 1.00F, 1.00F },
1981 { 0.00F, 0.00F, 0.55F },
1982 { 1.00F, 0.00F, 0.00F },
1983
1984 { 1.00F, 0.54F, 0.00F },
1985 { 0.11F, 0.56F, 1.00F },
1986 { 0.93F, 0.46F, 0.00F },
1987 { 0.18F, 0.54F, 0.34F },
1988
1989 { 0.56F, 0.73F, 0.56F },
1990 { 0.80F, 0.80F, 0.80F },
1991 { 0.55F, 0.41F, 0.13F },
1992 { 0.99F, 0.77F, 0.26F },
1993
1994 { 0.74F, 0.65F, 0.41F },
1995
1996 { 0.00F, 1.00F, 1.00F },
1997 { 1.00F, 0.00F, 1.00F },
1998 { 1.00F, 1.00F, 0.00F },
1999 };
2000
2001 int x, y;
2002
2003 glEnable (GL_TEXTURE_2D);
2004 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
2005 glEnable (GL_BLEND);
2006 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2007 glBegin (GL_QUADS);
2008
2009 for (y = 0; y < h; y++)
2010 for (x = 0; x < w; x++)
2011 {
2012 unsigned char m = data [x + y * w];
2013
2014 if (m)
2015 {
2016 float *c = color [m & 15];
2017
2018 float tx1 = m & 0x40 ? 0.5 : 0.;
2019 float tx2 = tx1 + 0.5;
2020
2021 glColor4f (c[0], c[1], c[2], 0.75);
2022 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2023 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2024 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2025 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2026 }
2027 }
2028
2029 glEnd ();
2030 glDisable (GL_BLEND);
2031 glDisable (GL_TEXTURE_2D);
2032}
2033
2034void
2035fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh)
2036 PPCODE:
2037{
2038 int x, y;
2039 int sw1 = sw + 2;
2040 int sh1 = sh + 2;
2041 int sh3 = sh * 3;
2042 int sw34 = (sw * 3 + 3) & ~3;
2043 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2044 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));
2045 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2046
2047 SvPOK_only (darkness3_sv);
2048 SvCUR_set (darkness3_sv, sw34 * sh3);
2049
2050 mx += self->x - 1;
2051 my += self->y - 1;
2052
2053 memset (darkness1, 255, sw1 * sh1);
2054
2055 for (y = 0; y < sh1; y++)
2056 if (0 <= y + my && y + my < self->rows)
2057 {
2058 maprow *row = self->row + (y + my);
2059
2060 for (x = 0; x < sw1; x++)
2061 if (row->c0 <= x + mx && x + mx < row->c1)
2062 {
2063 mapcell *cell = row->col + (x + mx - row->c0);
2064
2065 darkness1 [y * sw1 + x] = cell->darkness
2066 ? 255 - (cell->darkness - 1)
2067 : 255 - FOW_DARKNESS;
2068 }
2069 }
2070
2071 for (y = 0; y < sh; ++y)
2072 for (x = 0; x < sw; ++x)
2073 {
2074 uint8_t d11 = darkness1 [(y ) * sw1 + x ];
2075 uint8_t d21 = darkness1 [(y ) * sw1 + x + 1];
2076 uint8_t d31 = darkness1 [(y ) * sw1 + x + 2];
2077 uint8_t d12 = darkness1 [(y + 1) * sw1 + x ];
2078 uint8_t d22 = darkness1 [(y + 1) * sw1 + x + 1];
2079 uint8_t d32 = darkness1 [(y + 1) * sw1 + x + 2];
2080 uint8_t d13 = darkness1 [(y + 2) * sw1 + x ];
2081 uint8_t d23 = darkness1 [(y + 2) * sw1 + x + 1];
2082 uint8_t d33 = darkness1 [(y + 2) * sw1 + x + 2];
2083
2084 uint8_t r11 = (d11 + d21 + d12) / 3;
2085 uint8_t r21 = d21;
2086 uint8_t r31 = (d21 + d31 + d32) / 3;
2087
2088 uint8_t r12 = d12;
2089 uint8_t r22 = d22;
2090 uint8_t r32 = d32;
2091
2092 uint8_t r13 = (d13 + d23 + d12) / 3;
2093 uint8_t r23 = d23;
2094 uint8_t r33 = (d23 + d33 + d32) / 3;
2095
2096 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11);
2097 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21);
2098 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31);
2099 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12);
2100 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22);
2101 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32);
2102 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13);
2103 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23);
2104 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33);
2105 }
2106
2107 free (darkness1);
2108
759 EXTEND (SP, 3); 2109 EXTEND (SP, 3);
760 PUSHs (sv_2mortal (newSViv (sw4))); 2110 PUSHs (sv_2mortal (newSViv (sw34)));
761 PUSHs (sv_2mortal (newSViv (sh))); 2111 PUSHs (sv_2mortal (newSViv (sh3)));
762 PUSHs (darkness_sv); 2112 PUSHs (darkness3_sv);
763} 2113}
764 2114
2115SV *
2116get_rect (CFPlus::Map self, int x0, int y0, int w, int h)
2117 CODE:
2118{
2119 int x, y, x1, y1;
2120 SV *data_sv = newSV (w * h * 7 + 5);
2121 uint8_t *data = (uint8_t *)SvPVX (data_sv);
2122
2123 *data++ = 0; /* version 0 format */
2124 *data++ = w >> 8; *data++ = w;
2125 *data++ = h >> 8; *data++ = h;
2126
2127 // we need to do this 'cause we don't keep an absolute coord system for rows
2128 // TODO: treat rows as we treat columns
2129 map_get_row (self, y0 + self->y - self->oy);//D
2130 map_get_row (self, y0 + self->y - self->oy + h - 1);//D
2131
2132 x0 += self->x - self->ox;
2133 y0 += self->y - self->oy;
2134
2135 x1 = x0 + w;
2136 y1 = y0 + h;
2137
2138 for (y = y0; y < y1; y++)
2139 {
2140 maprow *row = 0 <= y && y < self->rows
2141 ? self->row + y
2142 : 0;
2143
2144 for (x = x0; x < x1; x++)
2145 {
2146 if (row && row->c0 <= x && x < row->c1)
2147 {
2148 mapcell *cell = row->col + (x - row->c0);
2149 uint8_t flags = 0;
2150
2151 if (cell->tile [0]) flags |= 1;
2152 if (cell->tile [1]) flags |= 2;
2153 if (cell->tile [2]) flags |= 4;
2154
2155 *data++ = flags;
2156
2157 if (flags & 1)
2158 {
2159 tileid tile = cell->tile [0];
2160 *data++ = tile >> 8;
2161 *data++ = tile;
2162 }
2163
2164 if (flags & 2)
2165 {
2166 tileid tile = cell->tile [1];
2167 *data++ = tile >> 8;
2168 *data++ = tile;
2169 }
2170
2171 if (flags & 4)
2172 {
2173 tileid tile = cell->tile [2];
2174 *data++ = tile >> 8;
2175 *data++ = tile;
2176 }
2177 }
2178 else
2179 *data++ = 0;
2180 }
2181 }
2182
2183 SvPOK_only (data_sv);
2184 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2185 RETVAL = data_sv;
2186}
2187 OUTPUT:
2188 RETVAL
2189
2190void
2191set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data)
2192 PPCODE:
2193{
2194 int x, y, z;
2195 int w, h;
2196 int x1, y1;
2197
2198 if (*data++ != 0)
2199 return; /* version mismatch */
2200
2201 w = *data++ << 8; w |= *data++;
2202 h = *data++ << 8; h |= *data++;
2203
2204 // we need to do this 'cause we don't keep an absolute coord system for rows
2205 // TODO: treat rows as we treat columns
2206 map_get_row (self, y0 + self->y - self->oy);//D
2207 map_get_row (self, y0 + self->y - self->oy + h - 1);//D
2208
2209 x0 += self->x - self->ox;
2210 y0 += self->y - self->oy;
2211
2212 x1 = x0 + w;
2213 y1 = y0 + h;
2214
2215 for (y = y0; y < y1; y++)
2216 {
2217 maprow *row = map_get_row (self, y);
2218
2219 for (x = x0; x < x1; x++)
2220 {
2221 uint8_t flags = *data++;
2222
2223 if (flags)
2224 {
2225 mapcell *cell = row_get_cell (row, x);
2226 tileid tile[3] = { 0, 0, 0 };
2227
2228 if (flags & 1) { tile[0] = *data++ << 8; tile[0] |= *data++; }
2229 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
2230 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
2231
2232 if (cell->darkness == 0)
2233 {
2234 cell->darkness = 0;
2235
2236 for (z = 0; z <= 2; z++)
2237 {
2238 tileid t = tile [z];
2239
2240 if (t >= self->texs || (t && !self->tex [t].name))
2241 {
2242 XPUSHs (sv_2mortal (newSViv (t)));
2243 need_texid (self, t);
2244 }
2245
2246 cell->tile [z] = t;
2247 }
2248 }
2249 }
2250 }
2251 }
2252}
2253
2254MODULE = CFPlus PACKAGE = CFPlus::RW
2255
2256CFPlus::RW
2257new (SV *class, SV *data_sv)
2258 CODE:
2259{
2260 STRLEN datalen;
2261 char *data = SvPVbyte (data_sv, datalen);
2262
2263 RETVAL = SDL_RWFromConstMem (data, datalen);
2264}
2265 OUTPUT:
2266 RETVAL
2267
2268CFPlus::RW
2269new_from_file (SV *class, const char *path, const char *mode = "rb")
2270 CODE:
2271 RETVAL = SDL_RWFromFile (path, mode);
2272 OUTPUT:
2273 RETVAL
2274
2275# fails on win32:
2276# CFPlus.xs(2268) : error C2059: syntax error : '('
2277#void
2278#close (CFPlus::RW self)
2279# CODE:
2280# (self->(close)) (self);
2281
2282MODULE = CFPlus PACKAGE = CFPlus::Channel
2283
2284PROTOTYPES: DISABLE
2285
2286CFPlus::Channel
2287find ()
2288 CODE:
2289{
2290 RETVAL = Mix_GroupAvailable (-1);
2291
2292 if (RETVAL < 0)
2293 {
2294 RETVAL = Mix_GroupOldest (-1);
2295
2296 if (RETVAL < 0)
2297 XSRETURN_UNDEF;
2298
2299 Mix_HaltChannel (RETVAL);
2300 }
2301
2302 Mix_UnregisterAllEffects (RETVAL);
2303 Mix_Volume (RETVAL, 128);
2304}
2305 OUTPUT:
2306 RETVAL
2307
2308void
2309halt (CFPlus::Channel self)
2310 CODE:
2311 Mix_HaltChannel (self);
2312
2313void
2314expire (CFPlus::Channel self, int ticks = -1)
2315 CODE:
2316 Mix_ExpireChannel (self, ticks);
2317
2318void
2319fade_out (CFPlus::Channel self, int ticks = -1)
2320 CODE:
2321 Mix_FadeOutChannel (self, ticks);
2322
2323int
2324volume (CFPlus::Channel self, int volume)
2325 CODE:
2326 RETVAL = Mix_Volume (self, CLAMP (volume, 0, 128));
2327 OUTPUT:
2328 RETVAL
2329
2330void
2331unregister_all_effects (CFPlus::Channel self)
2332 CODE:
2333 Mix_UnregisterAllEffects (self);
2334
2335void
2336set_panning (CFPlus::Channel self, int left, int right)
2337 CODE:
2338 left = CLAMP (left , 0, 255);
2339 right = CLAMP (right, 0, 255);
2340 Mix_SetPanning (self, left, right);
2341
2342void
2343set_distance (CFPlus::Channel self, int distance)
2344 CODE:
2345 Mix_SetDistance (self, CLAMP (distance, 0, 255));
2346
2347void
2348set_position (CFPlus::Channel self, int angle, int distance)
2349 CODE:
2350
2351void
2352set_position_r (CFPlus::Channel self, int dx, int dy, int maxdistance)
2353 CODE:
2354{
2355 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2356 int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI);
2357 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2358}
2359
2360void
2361set_reverse_stereo (CFPlus::Channel self, int flip)
2362 CODE:
2363 Mix_SetReverseStereo (self, flip);
2364
2365MODULE = CFPlus PACKAGE = CFPlus::MixChunk
2366
2367PROTOTYPES: DISABLE
2368
2369CFPlus::MixChunk
2370new (SV *class, CFPlus::RW rwops)
2371 CODE:
2372 RETVAL = Mix_LoadWAV_RW (rwops, 1);
2373 OUTPUT:
2374 RETVAL
2375
2376void
2377DESTROY (CFPlus::MixChunk self)
2378 CODE:
2379 Mix_FreeChunk (self);
2380
2381int
2382volume (CFPlus::MixChunk self, int volume = -1)
2383 CODE:
2384 if (items > 1)
2385 volume = CLAMP (volume, 0, 128);
2386 RETVAL = Mix_VolumeChunk (self, volume);
2387 OUTPUT:
2388 RETVAL
2389
2390CFPlus::Channel
2391play (CFPlus::MixChunk self, CFPlus::Channel channel = -1, int loops = 0, int ticks = -1)
2392 CODE:
2393{
2394 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
2395
2396 if (RETVAL < 0)
2397 XSRETURN_UNDEF;
2398
2399 if (channel < 0)
2400 {
2401 Mix_UnregisterAllEffects (RETVAL);
2402 Mix_Volume (RETVAL, 128);
2403 }
2404}
2405 OUTPUT:
2406 RETVAL
2407
2408MODULE = CFPlus PACKAGE = CFPlus::MixMusic
2409
2410int
2411volume (int volume = -1)
2412 PROTOTYPE: ;$
2413 CODE:
2414 if (items > 0)
2415 volume = CLAMP (volume, 0, 128);
2416 RETVAL = Mix_VolumeMusic (volume);
2417 OUTPUT:
2418 RETVAL
2419
2420void
2421fade_out (int ms)
2422 CODE:
2423 Mix_FadeOutMusic (ms);
2424
2425void
2426halt ()
2427 CODE:
2428 Mix_HaltMusic ();
2429
2430CFPlus::MixMusic
2431new (SV *class, CFPlus::RW rwops)
2432 CODE:
2433 RETVAL = Mix_LoadMUS_RW (rwops);
2434 OUTPUT:
2435 RETVAL
2436
2437void
2438DESTROY (CFPlus::MixMusic self)
2439 CODE:
2440 Mix_FreeMusic (self);
2441
2442int
2443play (CFPlus::MixMusic self, int loops = -1)
2444 CODE:
2445 RETVAL = Mix_PlayMusic (self, loops);
2446 OUTPUT:
2447 RETVAL
2448
2449void
2450fade_in_pos (CFPlus::MixMusic self, int loops, int ms, double position)
2451 CODE:
2452 Mix_FadeInMusicPos (self, loops, ms, position);
2453
2454MODULE = CFPlus PACKAGE = CFPlus::OpenGL
2455
2456PROTOTYPES: ENABLE
2457
2458BOOT:
2459{
2460 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1);
2461 static const struct {
2462 const char *name;
2463 IV iv;
2464 } *civ, const_iv[] = {
2465# define const_iv(name) { # name, (IV)name }
2466 const_iv (GL_VENDOR),
2467 const_iv (GL_VERSION),
2468 const_iv (GL_EXTENSIONS),
2469 const_iv (GL_COLOR_MATERIAL),
2470 const_iv (GL_SMOOTH),
2471 const_iv (GL_FLAT),
2472 const_iv (GL_DITHER),
2473 const_iv (GL_BLEND),
2474 const_iv (GL_CULL_FACE),
2475 const_iv (GL_SCISSOR_TEST),
2476 const_iv (GL_DEPTH_TEST),
2477 const_iv (GL_ALPHA_TEST),
2478 const_iv (GL_NORMALIZE),
2479 const_iv (GL_RESCALE_NORMAL),
2480 const_iv (GL_FRONT),
2481 const_iv (GL_BACK),
2482 const_iv (GL_AUX0),
2483 const_iv (GL_AND),
2484 const_iv (GL_ONE),
2485 const_iv (GL_ZERO),
2486 const_iv (GL_SRC_ALPHA),
2487 const_iv (GL_DST_ALPHA),
2488 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2489 const_iv (GL_ONE_MINUS_DST_ALPHA),
2490 const_iv (GL_SRC_ALPHA_SATURATE),
2491 const_iv (GL_RGB),
2492 const_iv (GL_RGBA),
2493 const_iv (GL_RGBA4),
2494 const_iv (GL_RGBA8),
2495 const_iv (GL_RGB5_A1),
2496 const_iv (GL_UNSIGNED_BYTE),
2497 const_iv (GL_UNSIGNED_SHORT),
2498 const_iv (GL_UNSIGNED_INT),
2499 const_iv (GL_ALPHA),
2500 const_iv (GL_INTENSITY),
2501 const_iv (GL_LUMINANCE),
2502 const_iv (GL_LUMINANCE_ALPHA),
2503 const_iv (GL_FLOAT),
2504 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),
2505 const_iv (GL_COMPILE),
2506 const_iv (GL_PROXY_TEXTURE_1D),
2507 const_iv (GL_PROXY_TEXTURE_2D),
2508 const_iv (GL_TEXTURE_1D),
2509 const_iv (GL_TEXTURE_2D),
2510 const_iv (GL_TEXTURE_ENV),
2511 const_iv (GL_TEXTURE_MAG_FILTER),
2512 const_iv (GL_TEXTURE_MIN_FILTER),
2513 const_iv (GL_TEXTURE_ENV_MODE),
2514 const_iv (GL_TEXTURE_WRAP_S),
2515 const_iv (GL_TEXTURE_WRAP_T),
2516 const_iv (GL_REPEAT),
2517 const_iv (GL_CLAMP),
2518 const_iv (GL_CLAMP_TO_EDGE),
2519 const_iv (GL_NEAREST),
2520 const_iv (GL_LINEAR),
2521 const_iv (GL_NEAREST_MIPMAP_NEAREST),
2522 const_iv (GL_LINEAR_MIPMAP_NEAREST),
2523 const_iv (GL_NEAREST_MIPMAP_LINEAR),
2524 const_iv (GL_LINEAR_MIPMAP_LINEAR),
2525 const_iv (GL_GENERATE_MIPMAP),
2526 const_iv (GL_MODULATE),
2527 const_iv (GL_DECAL),
2528 const_iv (GL_REPLACE),
2529 const_iv (GL_DEPTH_BUFFER_BIT),
2530 const_iv (GL_COLOR_BUFFER_BIT),
2531 const_iv (GL_PROJECTION),
2532 const_iv (GL_MODELVIEW),
2533 const_iv (GL_COLOR_LOGIC_OP),
2534 const_iv (GL_SEPARABLE_2D),
2535 const_iv (GL_CONVOLUTION_2D),
2536 const_iv (GL_CONVOLUTION_BORDER_MODE),
2537 const_iv (GL_CONSTANT_BORDER),
2538 const_iv (GL_POINTS),
2539 const_iv (GL_LINES),
2540 const_iv (GL_LINE_STRIP),
2541 const_iv (GL_LINE_LOOP),
2542 const_iv (GL_QUADS),
2543 const_iv (GL_QUAD_STRIP),
2544 const_iv (GL_TRIANGLES),
2545 const_iv (GL_TRIANGLE_STRIP),
2546 const_iv (GL_TRIANGLE_FAN),
2547 const_iv (GL_POLYGON),
2548 const_iv (GL_PERSPECTIVE_CORRECTION_HINT),
2549 const_iv (GL_POINT_SMOOTH_HINT),
2550 const_iv (GL_LINE_SMOOTH_HINT),
2551 const_iv (GL_POLYGON_SMOOTH_HINT),
2552 const_iv (GL_GENERATE_MIPMAP_HINT),
2553 const_iv (GL_FASTEST),
2554 const_iv (GL_DONT_CARE),
2555 const_iv (GL_NICEST),
2556 const_iv (GL_V2F),
2557 const_iv (GL_V3F),
2558 const_iv (GL_T2F_V3F),
2559 const_iv (GL_T2F_N3F_V3F),
2560# undef const_iv
2561 };
2562
2563 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
2564 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
2565
2566 texture_av = newAV ();
2567 AvREAL_off (texture_av);
2568}
2569
2570char *
2571gl_vendor ()
2572 CODE:
2573 RETVAL = (char *)glGetString (GL_VENDOR);
2574 OUTPUT:
2575 RETVAL
2576
2577char *
2578gl_version ()
2579 CODE:
2580 RETVAL = (char *)glGetString (GL_VERSION);
2581 OUTPUT:
2582 RETVAL
2583
2584char *
2585gl_extensions ()
2586 CODE:
2587 RETVAL = (char *)glGetString (GL_EXTENSIONS);
2588 OUTPUT:
2589 RETVAL
2590
2591const char *glGetString (GLenum pname)
2592
2593GLint glGetInteger (GLenum pname)
2594 CODE:
2595 glGetIntegerv (pname, &RETVAL);
2596 OUTPUT:
2597 RETVAL
2598
2599GLdouble glGetDouble (GLenum pname)
2600 CODE:
2601 glGetDoublev (pname, &RETVAL);
2602 OUTPUT:
2603 RETVAL
2604
2605int glGetError ()
2606
2607void glFinish ()
2608
2609void glClear (int mask)
2610
2611void glClearColor (float r, float g, float b, float a = 1.0)
2612 PROTOTYPE: @
2613
2614void glEnable (int cap)
2615
2616void glDisable (int cap)
2617
2618void glShadeModel (int mode)
2619
2620void glHint (int target, int mode)
2621
2622void glBlendFunc (int sfactor, int dfactor)
2623
2624void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2625 CODE:
2626 gl_BlendFuncSeparate (sa, da, saa, daa);
2627
2628void glDepthMask (int flag)
2629
2630void glLogicOp (int opcode)
2631
2632void glColorMask (int red, int green, int blue, int alpha)
2633
2634void glMatrixMode (int mode)
2635
2636void glPushMatrix ()
2637
2638void glPopMatrix ()
2639
2640void glLoadIdentity ()
2641
2642void glDrawBuffer (int buffer)
2643
2644void glReadBuffer (int buffer)
2645
2646# near_ and far_ are due to microsofts buggy "c" compiler
2647void glFrustum (double left, double right, double bottom, double top, double near_, double far_)
2648
2649# near_ and far_ are due to microsofts buggy "c" compiler
2650void glOrtho (double left, double right, double bottom, double top, double near_, double far_)
2651
2652PROTOTYPES: DISABLE
2653
2654void glViewport (int x, int y, int width, int height)
2655
2656void glScissor (int x, int y, int width, int height)
2657
2658void glTranslate (float x, float y, float z = 0.)
2659 CODE:
2660 glTranslatef (x, y, z);
2661
2662void glScale (float x, float y, float z = 1.)
2663 CODE:
2664 glScalef (x, y, z);
2665
2666void glRotate (float angle, float x, float y, float z)
2667 CODE:
2668 glRotatef (angle, x, y, z);
2669
2670void glColor (float r, float g, float b, float a = 1.0)
2671 ALIAS:
2672 glColor_premultiply = 1
2673 CODE:
2674 if (ix)
2675 {
2676 r *= a;
2677 g *= a;
2678 b *= a;
2679 }
2680 // microsoft visual "c" rounds instead of truncating...
2681 glColor4f (r, g, b, a);
2682
2683void glRasterPos (float x, float y, float z = 0.)
2684 CODE:
2685 glRasterPos3f (0, 0, z);
2686 glBitmap (0, 0, 0, 0, x, y, 0);
2687
2688void glVertex (float x, float y, float z = 0.)
2689 CODE:
2690 glVertex3f (x, y, z);
2691
2692void glTexCoord (float s, float t)
2693 CODE:
2694 glTexCoord2f (s, t);
2695
2696void glRect (float x1, float y1, float x2, float y2)
2697 CODE:
2698 glRectf (x1, y1, x2, y2);
2699
2700PROTOTYPES: ENABLE
2701
2702void glBegin (int mode)
2703
2704void glEnd ()
2705
2706void glPointSize (GLfloat size)
2707
2708void glLineWidth (GLfloat width)
2709
2710void glInterleavedArrays (int format, int stride, char *data)
2711
2712void glDrawElements (int mode, int count, int type, char *indices)
2713
2714# 1.2 void glDrawRangeElements (int mode, int start, int end
2715
2716void glTexEnv (int target, int pname, float param)
2717 CODE:
2718 glTexEnvf (target, pname, param);
2719
2720void glTexParameter (int target, int pname, float param)
2721 CODE:
2722 glTexParameterf (target, pname, param);
2723
2724void glBindTexture (int target, int name)
2725
2726void glConvolutionParameter (int target, int pname, float params)
2727 CODE:
2728 if (gl.ConvolutionParameterf)
2729 gl.ConvolutionParameterf (target, pname, params);
2730
2731void glConvolutionFilter2D (int target, int internalformat, int width, int height, int format, int type, char *data)
2732 CODE:
2733 if (gl.ConvolutionFilter2D)
2734 gl.ConvolutionFilter2D (target, internalformat, width, height, format, type, data);
2735
2736void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column)
2737 CODE:
2738 if (gl.SeparableFilter2D)
2739 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);
2740
2741void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data)
2742
2743void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
2744
2745void glDrawPixels (int width, int height, int format, int type, char *pixels)
2746
2747void glPixelZoom (float x, float y)
2748
2749void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
2750
2751int glGenTexture ()
2752 CODE:
2753 RETVAL = gen_texture ();
2754 OUTPUT:
2755 RETVAL
2756
2757void glDeleteTexture (int name)
2758 CODE:
2759 del_texture (name);
2760
2761int glGenList ()
2762 CODE:
2763 RETVAL = glGenLists (1);
2764 OUTPUT:
2765 RETVAL
2766
2767void glDeleteList (int list)
2768 CODE:
2769 glDeleteLists (list, 1);
2770
2771void glNewList (int list, int mode = GL_COMPILE)
2772
2773void glEndList ()
2774
2775void glCallList (int list)
2776
2777MODULE = CFPlus PACKAGE = CFPlus::UI::Base
2778
2779PROTOTYPES: DISABLE
2780
2781void
2782find_widget (SV *self, NV x, NV y)
2783 PPCODE:
2784{
2785 if (within_widget (self, x, y))
2786 XPUSHs (self);
2787}
2788
2789BOOT:
2790{
2791 hover_gv = gv_fetchpv ("CFPlus::UI::HOVER", 1, SVt_NV);
2792
2793 draw_x_gv = gv_fetchpv ("CFPlus::UI::Base::draw_x", 1, SVt_NV);
2794 draw_y_gv = gv_fetchpv ("CFPlus::UI::Base::draw_y", 1, SVt_NV);
2795 draw_w_gv = gv_fetchpv ("CFPlus::UI::Base::draw_w", 1, SVt_NV);
2796 draw_h_gv = gv_fetchpv ("CFPlus::UI::Base::draw_h", 1, SVt_NV);
2797}
2798
2799void
2800draw (SV *self)
2801 CODE:
2802{
2803 HV *hv;
2804 SV **svp;
2805 NV x, y, w, h;
2806 SV *draw_x_sv = GvSV (draw_x_gv);
2807 SV *draw_y_sv = GvSV (draw_y_gv);
2808 SV *draw_w_sv = GvSV (draw_w_gv);
2809 SV *draw_h_sv = GvSV (draw_h_gv);
2810 SV *hover;
2811 double draw_x, draw_y, draw_w, draw_h;
2812
2813 if (!SvROK (self))
2814 croak ("CFPlus::Base::draw: %s not a reference", SvPV_nolen (self));
2815
2816 hv = (HV *)SvRV (self);
2817
2818 if (SvTYPE (hv) != SVt_PVHV)
2819 croak ("CFPlus::Base::draw: %s not a hashref", SvPV_nolen (self));
2820
2821 svp = hv_fetch (hv, "w", 1, 0); w = svp ? SvNV (*svp) : 0.;
2822 svp = hv_fetch (hv, "h", 1, 0); h = svp ? SvNV (*svp) : 0.;
2823
2824 if (!h || !w)
2825 XSRETURN_EMPTY;
2826
2827 svp = hv_fetch (hv, "x", 1, 0); x = svp ? SvNV (*svp) : 0.;
2828 svp = hv_fetch (hv, "y", 1, 0); y = svp ? SvNV (*svp) : 0.;
2829
2830 draw_x = SvNV (draw_x_sv) + x;
2831 draw_y = SvNV (draw_y_sv) + y;
2832
2833 if (draw_x + w < 0 || draw_x >= SvNV (draw_w_sv)
2834 || draw_y + h < 0 || draw_y >= SvNV (draw_h_sv))
2835 XSRETURN_EMPTY;
2836
2837 sv_setnv (draw_x_sv, draw_x);
2838 sv_setnv (draw_y_sv, draw_y);
2839
2840 glPushMatrix ();
2841 glTranslated (x, y, 0);
2842
2843 if (SvROK (GvSV (hover_gv)) && SvRV (GvSV (hover_gv)) == (SV *)hv)
2844 {
2845 svp = hv_fetch (hv, "can_hover", sizeof ("can_hover") - 1, 0);
2846
2847 if (svp && SvTRUE (*svp))
2848 {
2849 glColor4f (1*0.2f, 0.8*0.2f, 0.5*0.2f, 0.2f);
2850 glEnable (GL_BLEND);
2851 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2852 glBegin (GL_QUADS);
2853 glVertex2f (0, 0);
2854 glVertex2f (w, 0);
2855 glVertex2f (w, h);
2856 glVertex2f (0, h);
2857 glEnd ();
2858 glDisable (GL_BLEND);
2859 }
2860 }
2861#if 0
2862 if ($ENV{CFPLUS_DEBUG} & 1) {
2863 glPushMatrix;
2864 glColor 1, 1, 0, 1;
2865 glTranslate 0.375, 0.375;
2866 glBegin GL_LINE_LOOP;
2867 glVertex 0 , 0;
2868 glVertex $self->{w} - 1, 0;
2869 glVertex $self->{w} - 1, $self->{h} - 1;
2870 glVertex 0 , $self->{h} - 1;
2871 glEnd;
2872 glPopMatrix;
2873 #CFPlus::UI::Label->new (w => $self->{w}, h => $self->{h}, text => $self, fontsize => 0)->_draw;
2874 }
2875#endif
2876 PUSHMARK (SP);
2877 XPUSHs (self);
2878 PUTBACK;
2879 call_method ("_draw", G_VOID | G_DISCARD);
2880 SPAGAIN;
2881
2882 glPopMatrix ();
2883
2884 draw_x = draw_x - x; sv_setnv (draw_x_sv, draw_x);
2885 draw_y = draw_y - y; sv_setnv (draw_y_sv, draw_y);
2886}
2887

Diff Legend

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