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.41 by root, Sat Apr 15 01:52:53 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: %s", SDL_GetError ()); 883 croak ("load_image: %s", SDL_GetError ());
223 884
… …
226 croak ("load_image: %s", SDL_GetError ()); 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
… …
285 PUSHs (sv_2mortal (newSViv (b / y))); 953 PUSHs (sv_2mortal (newSViv (b / y)));
286 PUSHs (sv_2mortal (newSViv (a / y))); 954 PUSHs (sv_2mortal (newSViv (a / y)));
287} 955}
288 956
289void 957void
958error (char *message)
959 CODE:
960 fprintf (stderr, "ERROR: %s\n", message);
961#ifdef _WIN32
962 MessageBox (0, message, "Crossfire+ Error", MB_OK | MB_ICONERROR);
963#endif
964
965void
290fatal (char *message) 966fatal (char *message)
291 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:
292#ifdef WIN32 977#ifdef WIN32
293 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND); 978 ExitThread (retval); // unclean, please beam me up
294#else 979#else
295 fprintf (stderr, "FATAL: %s\n", message); 980 _exit (retval);
296#endif 981#endif
297 exit (1);
298 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
299MODULE = CFClient PACKAGE = CFClient::Layout 1019MODULE = CFPlus PACKAGE = CFPlus::Layout
300 1020
301CFClient::Layout 1021PROTOTYPES: DISABLE
302new (SV *class, int base_height = 10) 1022
1023void
1024reset_glyph_cache ()
1025 PROTOTYPE:
1026 CODE:
1027 tc_clear ();
1028
1029CFPlus::Layout
1030new (SV *class)
303 CODE: 1031 CODE:
304 New (0, RETVAL, 1, struct cf_layout); 1032 New (0, RETVAL, 1, struct cf_layout);
305 RETVAL->base_height = base_height; 1033
306 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
307 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);
308 OUTPUT: 1044 OUTPUT:
309 RETVAL 1045 RETVAL
310 1046
311void 1047void
312DESTROY (CFClient::Layout self) 1048DESTROY (CFPlus::Layout self)
313 CODE: 1049 CODE:
314 g_object_unref (self->pl); 1050 g_object_unref (self->pl);
315 Safefree (self); 1051 Safefree (self);
316 1052
317void 1053void
318set_text (CFClient::Layout self, SV *text_) 1054set_text (CFPlus::Layout self, SV *text_)
319 CODE: 1055 CODE:
320{ 1056{
321 STRLEN textlen; 1057 STRLEN textlen;
322 char *text = SvPVutf8 (text_, textlen); 1058 char *text = SvPVutf8 (text_, textlen);
323 1059
324 pango_layout_set_text (self->pl, text, textlen); 1060 pango_layout_set_text (self->pl, text, textlen);
325} 1061}
326 1062
327void 1063void
328set_markup (CFClient::Layout self, SV *text_) 1064set_markup (CFPlus::Layout self, SV *text_)
329 CODE: 1065 CODE:
330{ 1066{
331 STRLEN textlen; 1067 STRLEN textlen;
332 char *text = SvPVutf8 (text_, textlen); 1068 char *text = SvPVutf8 (text_, textlen);
333 1069
334 pango_layout_set_markup (self->pl, text, textlen); 1070 pango_layout_set_markup (self->pl, text, textlen);
335} 1071}
336 1072
337void 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
338set_height (CFClient::Layout self, int base_height) 1184set_height (CFPlus::Layout self, int base_height)
339 CODE: 1185 CODE:
1186 if (self->base_height != base_height)
1187 {
340 self->base_height = base_height; 1188 self->base_height = base_height;
1189 layout_update_font (self);
1190 }
341 1191
342void 1192void
343set_width (CFClient::Layout self, int max_width = -1) 1193set_width (CFPlus::Layout self, int max_width = -1)
344 CODE: 1194 CODE:
345 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);
346 1196
347void 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
348size (CFClient::Layout self) 1223size (CFPlus::Layout self)
349 PPCODE: 1224 PPCODE:
350{ 1225{
351 int w, h; 1226 int w, h;
352 1227
353 layout_update (self);
354 layout_get_pixel_size (self, &w, &h); 1228 layout_get_pixel_size (self, &w, &h);
355 1229
356 EXTEND (SP, 2); 1230 EXTEND (SP, 2);
357 PUSHs (sv_2mortal (newSViv (w))); 1231 PUSHs (sv_2mortal (newSViv (w)));
358 PUSHs (sv_2mortal (newSViv (h))); 1232 PUSHs (sv_2mortal (newSViv (h)));
359} 1233}
360 1234
361int 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
362xy_to_index (CFClient::Layout self, int x, int y) 1248xy_to_index (CFPlus::Layout self, int x, int y)
363 CODE: 1249 CODE:
364{ 1250{
365 int index, trailing; 1251 int index, trailing;
366
367 layout_update (self);
368 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);
369
370 RETVAL = index; 1253 RETVAL = index + trailing;
371} 1254}
372 OUTPUT: 1255 OUTPUT:
373 RETVAL 1256 RETVAL
374 1257
375void 1258void
376cursor_pos (CFClient::Layout self, int index) 1259cursor_pos (CFPlus::Layout self, int index)
377 PPCODE: 1260 PPCODE:
378{ 1261{
379 PangoRectangle strong_pos; 1262 PangoRectangle strong_pos;
380 layout_update (self);
381 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1263 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);
382 1264
383 EXTEND (SP, 3); 1265 EXTEND (SP, 3);
384 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1266 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));
385 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1267 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
386 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1268 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));
387} 1269}
388 1270
389void 1271void
390render (CFClient::Layout self) 1272index_to_line_x (CFPlus::Layout self, int index, int trailing = 0)
391 PPCODE: 1273 PPCODE:
392{ 1274{
393 SV *retval; 1275 int line, x;
394 int w, h;
395 FT_Bitmap bitmap;
396 1276
397 layout_update (self); 1277 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
398 layout_get_pixel_size (self, &w, &h); 1278 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
399 1279
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); 1280 EXTEND (SP, 2);
416 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 {
417 PUSHs (sv_2mortal (newSViv (h))); 1305 PUSHs (sv_2mortal (newSViv (index)));
418 PUSHs (sv_2mortal (retval)); 1306 PUSHs (sv_2mortal (newSViv (trailing)));
1307 }
419} 1308}
420 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
421MODULE = CFClient PACKAGE = CFClient::Texture 1320MODULE = CFPlus PACKAGE = CFPlus::Texture
422 1321
1322PROTOTYPES: ENABLE
1323
1324int minpot (int n)
1325
423void 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
424draw_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.)
425 PROTOTYPE: $$$;$$ 1350 PROTOTYPE: $$$;$$
1351 ALIAS:
1352 draw_quad_alpha = 1
1353 draw_quad_alpha_premultiplied = 2
426 CODE: 1354 CODE:
427{ 1355{
428 HV *hv = (HV *)SvRV (self); 1356 HV *hv = (HV *)SvRV (self);
429 float s = SvNV (*hv_fetch (hv, "s", 1, 1)); 1357 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
430 float t = SvNV (*hv_fetch (hv, "t", 1, 1)); 1358 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
431 int name = SvIV (*hv_fetch (hv, "name", 4, 1)); 1359 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
432 int wrap_mode = SvIV (*hv_fetch (hv, "wrap_mode", 9, 1)); 1360
1361 if (name <= 0)
1362 XSRETURN_EMPTY;
433 1363
434 if (items < 5) 1364 if (items < 5)
435 { 1365 {
436 w = SvNV (*hv_fetch (hv, "w", 1, 1)); 1366 w = SvNV (*hv_fetch (hv, "w", 1, 1));
437 h = SvNV (*hv_fetch (hv, "h", 1, 1)); 1367 h = SvNV (*hv_fetch (hv, "h", 1, 1));
438 } 1368 }
439 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
440 glBindTexture (GL_TEXTURE_2D, name); 1384 glBindTexture (GL_TEXTURE_2D, name);
441 if (wrap_mode) { 1385
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); 1386 glBegin (GL_QUADS);
446 glTexCoord2f (0, 0); glVertex2f (x , y ); 1387 glTexCoord2f (0, 0); glVertex2f (x , y );
447 glTexCoord2f (0, t); glVertex2f (x , y + h); 1388 glTexCoord2f (0, t); glVertex2f (x , y + h);
448 glTexCoord2f (s, t); glVertex2f (x + w, y + h); 1389 glTexCoord2f (s, t); glVertex2f (x + w, y + h);
449 glTexCoord2f (s, 0); glVertex2f (x + w, y ); 1390 glTexCoord2f (s, 0); glVertex2f (x + w, y );
450 glEnd (); 1391 glEnd ();
451}
452 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
453MODULE = CFClient PACKAGE = CFClient::Map 1411MODULE = CFPlus PACKAGE = CFPlus::Map
454 1412
455CFClient::Map 1413PROTOTYPES: DISABLE
456new (SV *class, int map_width, int map_height) 1414
1415CFPlus::Map
1416new (SV *class)
457 CODE: 1417 CODE:
458 New (0, RETVAL, 1, struct map); 1418 New (0, RETVAL, 1, struct map);
459 RETVAL->x = 0; 1419 RETVAL->x = 0;
460 RETVAL->y = 0; 1420 RETVAL->y = 0;
461 RETVAL->w = map_width; 1421 RETVAL->w = 0;
462 RETVAL->h = map_height; 1422 RETVAL->h = 0;
463 RETVAL->vx = 0; 1423 RETVAL->ox = 0;
464 RETVAL->vy = 0; 1424 RETVAL->oy = 0;
465 RETVAL->faces = 8192; 1425 RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
466 Newz (0, RETVAL->face, RETVAL->faces, mapface); 1426 RETVAL->texs = 8192; Newz (0, RETVAL->tex , RETVAL->texs , maptex);
467 RETVAL->rows = 0; 1427 RETVAL->rows = 0;
468 RETVAL->row = 0; 1428 RETVAL->row = 0;
469 OUTPUT: 1429 OUTPUT:
470 RETVAL 1430 RETVAL
471 1431
472void 1432void
473DESTROY (CFClient::Map self) 1433DESTROY (CFPlus::Map self)
474 CODE: 1434 CODE:
475{ 1435{
476 map_clear (self); 1436 map_clear (self);
477 Safefree (self->face); 1437 Safefree (self->face2tile);
1438 Safefree (self->tex);
478 Safefree (self); 1439 Safefree (self);
479} 1440}
480 1441
481void 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
482clear (CFClient::Map self) 1449clear (CFPlus::Map self)
483 CODE: 1450 CODE:
484 map_clear (self); 1451 map_clear (self);
485 1452
486void 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
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) 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)
488 CODE: 1486 CODE:
489{ 1487{
490 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)
491 { 1524 {
492 Append (mapface, self->face, self->faces, self->faces); 1525 case 0: RETVAL = self->ox; break;
493 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;
494 } 1531 }
1532 OUTPUT:
1533 RETVAL
495 1534
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 1535void
510scroll (CFClient::Map self, int dx, int dy) 1536scroll (CFPlus::Map self, int dx, int dy)
511 CODE: 1537 CODE:
512{ 1538{
513 if (dx > 0) 1539 if (dx > 0)
514 map_blank (self, self->x, self->y, dx - 1, self->h); 1540 map_blank (self, self->x, self->y, dx, self->h);
515 else if (dx < 0) 1541 else if (dx < 0)
516 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);
517 1543
518 if (dy > 0) 1544 if (dy > 0)
519 map_blank (self, self->x, self->y, self->w, dy - 1); 1545 map_blank (self, self->x, self->y, self->w, dy);
520 else if (dy < 0) 1546 else if (dy < 0)
521 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);
522 1548
523 self->x += dx; 1549 self->ox += dx; self->x += dx;
524 self->y += dy; 1550 self->oy += dy; self->y += dy;
525 1551
526 while (self->y < 0) 1552 while (self->y < 0)
527 { 1553 {
528 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y); 1554 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
529 1555
530 self->rows += MAP_EXTEND_Y; 1556 self->rows += MAP_EXTEND_Y;
531 self->y += MAP_EXTEND_Y; 1557 self->y += MAP_EXTEND_Y;
532 } 1558 }
533} 1559}
534 1560
535void 1561SV *
536map1a_update (CFClient::Map self, SV *data_) 1562map1a_update (CFPlus::Map self, SV *data_, int extmap)
537 CODE: 1563 CODE:
538{ 1564{
539 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 1565 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
540 uint8_t *data_end = (uint8_t *)SvEND (data_); 1566 uint8_t *data_end = (uint8_t *)SvEND (data_);
541 1567 mapcell *cell;
1568 int x, y, z, flags;
1569 AV *missing = newAV ();
1570 RETVAL = newRV_noinc ((SV *)missing);
1571
542 while (data < data_end) 1572 while (data < data_end - 1)
543 { 1573 {
544 int flags = (data [0] << 8) + data [1]; data += 2; 1574 flags = (data [0] << 8) + data [1]; data += 2;
545 1575
546 int x = ((flags >> 10) & 63) + self->x; 1576 x = self->x + ((flags >> 10) & 63);
547 int y = ((flags >> 4) & 63) + self->y; 1577 y = self->y + ((flags >> 4) & 63);
548 1578
549 while (y >= self->rows) 1579 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 1580
584 if (flags & 15) 1581 if (flags & 15)
585 { 1582 {
586 if (cell->darkness < 0 && x < self->w && y < self->h) 1583 if (!cell->darkness)
587 { 1584 {
1585 memset (cell, 0, sizeof (*cell));
588 cell->darkness = 0; 1586 cell->darkness = 256;
589 cell->face [0] = 0;
590 cell->face [1] = 0;
591 cell->face [2] = 0;
592 } 1587 }
593
594 cell->darkness = flags & 8 ? *data++ : 255;
595 1588
1589 //TODO: don't trust server data to be in-range(!)
1590
596 if (flags & 4) 1591 if (flags & 8)
597 { 1592 {
598 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;
599 } 1629 }
600 1630
1631 for (z = 0; z <= 2; ++z)
601 if (flags & 2) 1632 if (flags & (4 >> z))
602 { 1633 {
603 cell->face [1] = (data [0] << 8) + data [1]; data += 2; 1634 faceid face = (data [0] << 8) + data [1]; data += 2;
1635 need_facenum (self, face);
1636 cell->tile [z] = self->face2tile [face];
1637
1638 if (cell->tile [z])
1639 {
1640 maptex *tex = self->tex + cell->tile [z];
1641 if (!tex->name)
1642 av_push (missing, newSViv (cell->tile [z]));
1643
1644 if (tex->smoothtile)
1645 {
1646 maptex *smooth = self->tex + tex->smoothtile;
1647 if (!smooth->name)
1648 av_push (missing, newSViv (tex->smoothtile));
1649 }
1650 }
604 } 1651 }
605
606 if (flags & 1)
607 {
608 cell->face [2] = (data [0] << 8) + data [1]; data += 2;
609 }
610 } 1652 }
611 else 1653 else
612 cell->darkness = -1; 1654 cell->darkness = 0;
613 } 1655 }
614} 1656}
1657 OUTPUT:
1658 RETVAL
615 1659
616SV * 1660SV *
617mapmap (CFClient::Map self, int w, int h) 1661mapmap (CFPlus::Map self, int x0, int y0, int w, int h)
618 CODE: 1662 CODE:
619{ 1663{
620 int x0, x1, x; 1664 int x1, x;
621 int y0, y1, y; 1665 int y1, y;
622 int z; 1666 int z;
623 SV *map_sv = newSV (w * h * sizeof (uint32_t)); 1667 SV *map_sv = newSV (w * h * sizeof (uint32_t));
624 uint32_t *map = (uint32_t *)SvPVX (map_sv); 1668 uint32_t *map = (uint32_t *)SvPVX (map_sv);
625 1669
626 SvPOK_only (map_sv); 1670 SvPOK_only (map_sv);
627 SvCUR_set (map_sv, w * h * sizeof (uint32_t)); 1671 SvCUR_set (map_sv, w * h * sizeof (uint32_t));
628 1672
629 x0 = self->x - w / 2; x1 = x0 + w; 1673 x0 += self->x; x1 = x0 + w;
630 y0 = self->y - h / 2; y1 = y0 + h; 1674 y0 += self->y; y1 = y0 + h;
631 1675
632 for (y = y0; y < y1; y++) 1676 for (y = y0; y < y1; y++)
633 { 1677 {
634 maprow *row = 0 <= y && y < self->rows 1678 maprow *row = 0 <= y && y < self->rows
635 ? self->row + y 1679 ? self->row + y
… …
643 { 1687 {
644 mapcell *cell = row->col + (x - row->c0); 1688 mapcell *cell = row->col + (x - row->c0);
645 1689
646 for (z = 0; z <= 0; z++) 1690 for (z = 0; z <= 0; z++)
647 { 1691 {
648 uint16_t face = cell->face [z]; 1692 maptex tex = self->tex [cell->tile [z]];
649
650 if (face)
651 {
652 mapface tex = self->face [face];
653 int a0 = 255 - tex.a; 1693 int a0 = 255 - tex.a;
654 int a1 = tex.a; 1694 int a1 = tex.a;
655 1695
656 r = (r * a0 + tex.r * a1) / 255; 1696 r = (r * a0 + tex.r * a1) / 255;
657 g = (g * a0 + tex.g * a1) / 255; 1697 g = (g * a0 + tex.g * a1) / 255;
658 b = (b * a0 + tex.b * a1) / 255; 1698 b = (b * a0 + tex.b * a1) / 255;
659 a = (a * a0 + tex.a * a1) / 255; 1699 a = (a * a0 + tex.a * a1) / 255;
660 }
661 } 1700 }
662 } 1701 }
663 1702
664 *map++ = (r ) 1703 *map++ = (r )
665 | (g << 8) 1704 | (g << 8)
… …
672} 1711}
673 OUTPUT: 1712 OUTPUT:
674 RETVAL 1713 RETVAL
675 1714
676void 1715void
677draw (CFClient::Map self, int shift_x, int shift_y, int x0, int y0, int sw, int sh) 1716draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T)
1717 CODE:
1718{
1719 int x, y, z;
1720
1721 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1722 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1723 static uint8_t smooth_max[256][256]; // egad, fats and wasteful on memory (64k)
1724 smooth_key skey;
1725
1726 rc_t *rc = rc_alloc ();
1727 rc_key_t key;
1728 rc_array_t *arr;
1729
1730 // thats current max. sorry.
1731 if (sw > 255) sw = 255;
1732 if (sh > 255) sh = 255;
1733
1734 // clear key, in case of extra padding
1735 memset (&skey, 0, sizeof (skey));
1736
1737 memset (&key, 0, sizeof (key));
1738 key.r = 255;
1739 key.g = 255;
1740 key.b = 255;
1741 key.a = 255;
1742 key.mode = GL_QUADS;
1743 key.format = GL_T2F_V3F;
1744 key.texname = -1;
1745
1746 mx += self->x;
1747 my += self->y;
1748
1749 // first pass: determine smooth_max
1750 // rather ugly, if you ask me
1751 // could also be stored inside mapcell and updated on change
1752 memset (smooth_max, 0, sizeof (smooth_max));
1753
1754 for (y = 0; y < sh; y++)
1755 if (0 <= y + my && y + my < self->rows)
1756 {
1757 maprow *row = self->row + (y + my);
1758
1759 for (x = 0; x < sw; x++)
1760 if (row->c0 <= x + mx && x + mx < row->c1)
1761 {
1762 mapcell *cell = row->col + (x + mx - row->c0);
1763
1764 smooth_max[x + 1][y + 1] =
1765 MAX (self->tex [cell->tile [0]].smoothlevel,
1766 MAX (self->tex [cell->tile [1]].smoothlevel,
1767 self->tex [cell->tile [2]].smoothlevel));
1768 }
1769 }
1770
1771 glEnable (GL_BLEND);
1772 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1773 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1774
1775 for (z = 0; z <= 2; z++)
1776 {
1777 memset (smooth_level, 0, sizeof (smooth_level));
1778
1779 for (y = 0; y < sh; y++)
1780 if (0 <= y + my && y + my < self->rows)
1781 {
1782 maprow *row = self->row + (y + my);
1783
1784 for (x = 0; x < sw; x++)
1785 if (row->c0 <= x + mx && x + mx < row->c1)
1786 {
1787 mapcell *cell = row->col + (x + mx - row->c0);
1788 tileid tile = cell->tile [z];
1789
1790 if (tile)
1791 {
1792 maptex tex = self->tex [tile];
1793 int px, py;
1794
1795 // suppressing texture state switches here
1796 // is only moderately effective, but worth the extra effort
1797 if (key.texname != tex.name)
1798 {
1799 if (!tex.name)
1800 tex = self->tex [2]; /* missing, replace by noface */
1801
1802 key.texname = tex.name;
1803 arr = rc_array (rc, &key);
1804 }
1805
1806 px = (x + 1) * T - tex.w;
1807 py = (y + 1) * T - tex.h;
1808
1809 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
1810 rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
1811 rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
1812 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
1813
1814 if (cell->flags && z == 2)
1815 {
1816 // overlays such as the speech bubble, probably more to come
1817 if (cell->flags & 1)
1818 {
1819 maptex tex = self->tex [1];
1820 int px = x * T + T * 2 / 32;
1821 int py = y * T - T * 6 / 32;
1822
1823 if (tex.name)
1824 {
1825 if (key.texname != tex.name)
1826 {
1827 key.texname = tex.name;
1828 arr = rc_array (rc, &key);
1829 }
1830
1831 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
1832 rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
1833 rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
1834 rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
1835 }
1836 }
1837 }
1838
1839 // update smooth hash
1840 if (tex.smoothtile)
1841 {
1842 skey.tile = tex.smoothtile;
1843 skey.level = tex.smoothlevel;
1844
1845 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31);
1846
1847 // add bits to current tile and all neighbours. skey.x|y is
1848 // shifted +1|+1 so we always stay positive.
1849
1850 // bits is ___n cccc CCCC bbbb
1851 // n do not draw borders&corners
1852 // c draw these corners, but...
1853 // C ... not these
1854 // b draw these borders
1855
1856 // borders: 1 ┃· 2 ━━ 4 ·┃ 8 ··
1857 // ┃· ·· ·┃ ━━
1858
1859 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1860 // ·· ·· ·┏ ┓·
1861
1862 // full tile
1863 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000);
1864
1865 // borders
1866 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091);
1867 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032);
1868 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064);
1869 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8);
1870
1871 // corners
1872 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);
1873 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);
1874 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);
1875 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);
1876 }
1877 }
1878 }
1879 }
1880
1881 // go through all smoothlevels, lowest to highest, then draw.
1882 // this is basically counting sort
1883 {
1884 int w, b;
1885
1886 for (w = 0; w < 256 / 32; ++w)
1887 {
1888 uint32_t smask = smooth_level [w];
1889 if (smask)
1890 for (b = 0; b < 32; ++b)
1891 if (smask & (((uint32_t)1) << b))
1892 {
1893 int level = (w << 5) | b;
1894 HE *he;
1895
1896 hv_iterinit (smooth);
1897 while ((he = hv_iternext (smooth)))
1898 {
1899 smooth_key *skey = (smooth_key *)HeKEY (he);
1900 IV bits = SvIVX (HeVAL (he));
1901
1902 if (!(bits & 0x1000)
1903 && skey->level == level
1904 && level > smooth_max [skey->x][skey->y])
1905 {
1906 maptex tex = self->tex [skey->tile];
1907 int px = (((int)skey->x) - 1) * T;
1908 int py = (((int)skey->y) - 1) * T;
1909 int border = bits & 15;
1910 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1911 float dx = tex.s * .0625f; // 16 images/row
1912 float dy = tex.t * .5f ; // 2 images/column
1913
1914 if (tex.name)
1915 {
1916 // this time avoiding texture state changes
1917 // save gobs of state changes.
1918 if (key.texname != tex.name)
1919 {
1920 key.texname = tex.name;
1921 arr = rc_array (rc, &key);
1922 }
1923
1924 if (border)
1925 {
1926 float ox = border * dx;
1927
1928 rc_t2f_v3f (arr, ox , 0.f , px , py , 0);
1929 rc_t2f_v3f (arr, ox , dy , px , py + T, 0);
1930 rc_t2f_v3f (arr, ox + dx, dy , px + T, py + T, 0);
1931 rc_t2f_v3f (arr, ox + dx, 0.f , px + T, py , 0);
1932 }
1933
1934 if (corner)
1935 {
1936 float ox = corner * dx;
1937
1938 rc_t2f_v3f (arr, ox , dy , px , py , 0);
1939 rc_t2f_v3f (arr, ox , dy * 2.f, px , py + T, 0);
1940 rc_t2f_v3f (arr, ox + dx, dy * 2.f, px + T, py + T, 0);
1941 rc_t2f_v3f (arr, ox + dx, dy , px + T, py , 0);
1942 }
1943 }
1944 }
1945 }
1946 }
1947 }
1948 }
1949
1950 hv_clear (smooth);
1951 rc_draw (rc);
1952 rc_clear (rc);
1953 }
1954
1955 glDisable (GL_BLEND);
1956 rc_free (rc);
1957
1958 // top layer: overlays such as the health bar
1959 for (y = 0; y < sh; y++)
1960 if (0 <= y + my && y + my < self->rows)
1961 {
1962 maprow *row = self->row + (y + my);
1963
1964 for (x = 0; x < sw; x++)
1965 if (row->c0 <= x + mx && x + mx < row->c1)
1966 {
1967 mapcell *cell = row->col + (x + mx - row->c0);
1968
1969 int px = x * T;
1970 int py = y * T;
1971
1972 if (cell->stat_hp)
1973 {
1974 int width = cell->stat_width * T;
1975 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
1976
1977 glColor3ub (0, 0, 0);
1978 glRectf (px + 1, py - thick - 2,
1979 px + width - 1, py);
1980
1981 glColor3ub (cell->stat_hp, 255 - cell->stat_hp, 0);
1982 glRectf (px + 2,
1983 py - thick - 1,
1984 px + width - 2 - cell->stat_hp * (width - 4) / 255, py - 1);
1985 }
1986 }
1987 }
1988}
1989
1990void
1991draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data)
1992 CODE:
1993{
1994 static float color[16][3] = {
1995 { 0.00F, 0.00F, 0.00F },
1996 { 1.00F, 1.00F, 1.00F },
1997 { 0.00F, 0.00F, 0.55F },
1998 { 1.00F, 0.00F, 0.00F },
1999
2000 { 1.00F, 0.54F, 0.00F },
2001 { 0.11F, 0.56F, 1.00F },
2002 { 0.93F, 0.46F, 0.00F },
2003 { 0.18F, 0.54F, 0.34F },
2004
2005 { 0.56F, 0.73F, 0.56F },
2006 { 0.80F, 0.80F, 0.80F },
2007 { 0.55F, 0.41F, 0.13F },
2008 { 0.99F, 0.77F, 0.26F },
2009
2010 { 0.74F, 0.65F, 0.41F },
2011
2012 { 0.00F, 1.00F, 1.00F },
2013 { 1.00F, 0.00F, 1.00F },
2014 { 1.00F, 1.00F, 0.00F },
2015 };
2016
2017 int x, y;
2018
2019 glEnable (GL_TEXTURE_2D);
2020 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
2021 glEnable (GL_BLEND);
2022 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2023 glBegin (GL_QUADS);
2024
2025 for (y = 0; y < h; y++)
2026 for (x = 0; x < w; x++)
2027 {
2028 unsigned char m = data [x + y * w];
2029
2030 if (m)
2031 {
2032 float *c = color [m & 15];
2033
2034 float tx1 = m & 0x40 ? 0.5 : 0.;
2035 float tx2 = tx1 + 0.5;
2036
2037 glColor4f (c[0], c[1], c[2], 0.75);
2038 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2039 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2040 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2041 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2042 }
2043 }
2044
2045 glEnd ();
2046 glDisable (GL_BLEND);
2047 glDisable (GL_TEXTURE_2D);
2048}
2049
2050void
2051fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh)
678 PPCODE: 2052 PPCODE:
679{ 2053{
2054 int x, y;
2055 int sw1 = sw + 2;
2056 int sh1 = sh + 2;
2057 int sh3 = sh * 3;
680 int sw4 = (sw + 3) & ~3; 2058 int sw34 = (sw * 3 + 3) & ~3;
2059 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
681 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh)); 2060 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));
682 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv); 2061 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
683 2062
684 SvPOK_only (darkness_sv); 2063 SvPOK_only (darkness3_sv);
685 SvCUR_set (darkness_sv, sw4 * sh); 2064 SvCUR_set (darkness3_sv, sw34 * sh3);
686 2065
687 int vx = self->x + (self->w - sw) / 2 - shift_x; 2066 mx += self->x - 1;
688 int vy = self->y + (self->h - sh) / 2 - shift_y; 2067 my += self->y - 1;
689 2068
690 if (0) 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);
2124
2125 EXTEND (SP, 3);
2126 PUSHs (sv_2mortal (newSViv (sw34)));
2127 PUSHs (sv_2mortal (newSViv (sh3)));
2128 PUSHs (darkness3_sv);
2129}
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++)
691 { 2155 {
692 int vx = self->vx = self->w >= sw 2156 maprow *row = 0 <= y && y < self->rows
693 ? self->x + (self->w - sw) / 2 2157 ? self->row + y
694 : MIN (self->x, MAX (self->x + self->w - sw + 1, self->vx)); 2158 : 0;
695 2159
696 int vy = self->vy = self->h >= sh 2160 for (x = x0; x < x1; x++)
697 ? self->y + (self->h - sh) / 2 2161 {
698 : MIN (self->y, MAX (self->y + self->h - sh + 1, self->vy)); 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 }
699 } 2197 }
700 2198
701 glColor4ub (255, 255, 255, 255); 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
702 2205
703 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2206void
704 glEnable (GL_BLEND); 2207set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data)
705 glEnable (GL_TEXTURE_2D); 2208 PPCODE:
706 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2209{
707 2210 int x, y, z;
2211 int w, h;
708 int x, y, z; 2212 int x1, y1;
709 2213
710 int last_name = 0; 2214 if (*data++ != 0)
2215 return; /* version mismatch */
711 2216
712 glBegin (GL_QUADS); 2217 w = *data++ << 8; w |= *data++;
2218 h = *data++ << 8; h |= *data++;
713 2219
714 for (z = 0; z < 3; z++) 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
715 for (y = 0; y < sh; y++) 2231 for (y = y0; y < y1; y++)
716 if (0 <= y + vy && y + vy < self->rows) 2232 {
2233 maprow *row = map_get_row (self, y);
2234
2235 for (x = x0; x < x1; x++)
717 { 2236 {
718 maprow *row = self->row + (y + vy); 2237 uint8_t flags = *data++;
719 2238
720 for (x = 0; x < sw; x++) 2239 if (flags)
721 if (row->c0 <= x + vx && x + vx < row->c1) 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)
722 { 2249 {
723 mapcell *cell = row->col + (x + vx - row->c0);
724
725 darkness[y * sw4 + x] = cell->darkness < 0
726 ? 255 - FOW_DARKNESS
727 : 255 - cell->darkness; 2250 cell->darkness = 0;
728 2251
729 uint16_t face = cell->face [z]; 2252 for (z = 0; z <= 2; z++)
730
731 if (face)
732 { 2253 {
733 mapface tex = self->face [face]; 2254 tileid t = tile [z];
734 2255
735 int px = (x + 1) * 32 - tex.w; 2256 if (t >= self->texs || (t && !self->tex [t].name))
736 int py = (y + 1) * 32 - tex.h;
737
738 if (last_name != tex.name)
739 { 2257 {
740 glEnd (); 2258 XPUSHs (sv_2mortal (newSViv (t)));
741 last_name = tex.name; 2259 need_texid (self, t);
742 glBindTexture (GL_TEXTURE_2D, last_name);
743 glBegin (GL_QUADS);
744 } 2260 }
745 2261
746 glTexCoord2f (0 , 0 ); glVertex2f (px , py ); 2262 cell->tile [z] = t;
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 } 2263 }
751 } 2264 }
2265 }
752 } 2266 }
2267 }
2268}
753 2269
754 glEnd (); 2270MODULE = CFPlus PACKAGE = CFPlus::RW
755 2271
756 glDisable (GL_TEXTURE_2D); 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 ();
757 glDisable (GL_BLEND); 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;
758 2897
759 EXTEND (SP, 3); 2898 glPopMatrix ();
760 PUSHs (sv_2mortal (newSViv (sw4)));
761 PUSHs (sv_2mortal (newSViv (sh)));
762 PUSHs (darkness_sv);
763}
764 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