ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/Deliantra-Client/Client.xs
(Generate patch)

Comparing deliantra/Deliantra-Client/Client.xs (file contents):
Revision 1.39 by root, Sat Apr 15 00:04:58 2006 UTC vs.
Revision 1.223 by root, Sat Aug 11 11:07:08 2007 UTC

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

Diff Legend

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