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.130 by root, Wed Jul 12 17:21:01 2006 UTC vs.
Revision 1.224 by root, Sat Aug 11 11:21:46 2007 UTC

1#ifdef _WIN32 1#ifdef _WIN32
2# define _WIN32_WINNT 0x0500 // needed to get win2000 api calls 2# define WIN32_LEAN_AND_MEAN
3# define NTDDI_VERSION NTDDI_WIN2K // needed to get win2000 api calls
3# include <malloc.h> 4# include <malloc.h>
4# include <windows.h> 5# include <windows.h>
6# include <wininet.h>
5# pragma warning(disable:4244) 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>
6#endif 14#endif
7 15
8#include "EXTERN.h" 16#include "EXTERN.h"
9#include "perl.h" 17#include "perl.h"
10#include "XSUB.h" 18#include "XSUB.h"
11 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>
12#include <math.h> 30#include <math.h>
13#include <string.h> 31#include <string.h>
14#include <stdio.h> 32#include <stdio.h>
15#include <stdlib.h> 33#include <stdlib.h>
16 34
35#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
36
17#include <SDL.h> 37#include <SDL.h>
38#include <SDL_thread.h>
18#include <SDL_endian.h> 39#include <SDL_endian.h>
19#include <SDL_image.h> 40#include <SDL_image.h>
20#include <SDL_mixer.h> 41#include <SDL_mixer.h>
21#include <SDL_opengl.h> 42#include <SDL_opengl.h>
22 43
31# include <sys/types.h> 52# include <sys/types.h>
32# include <sys/socket.h> 53# include <sys/socket.h>
33# include <netinet/in.h> 54# include <netinet/in.h>
34# include <netinet/tcp.h> 55# include <netinet/tcp.h>
35# include <inttypes.h> 56# include <inttypes.h>
36#else
37 typedef unsigned char uint8_t;
38 typedef unsigned short uint16_t;
39 typedef unsigned int uint32_t;
40 typedef signed char int8_t;
41 typedef signed short int16_t;
42 typedef signed int int32_t;
43#endif 57#endif
44 58
45#include "glext.h"
46
47#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, objetc replacement character */ 59#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
48 60
49#define FOW_DARKNESS 32 61#define FOW_DARKNESS 32
50 62
51#define MAP_EXTEND_X 32 63#define MAP_EXTEND_X 32
52#define MAP_EXTEND_Y 512 64#define MAP_EXTEND_Y 512
57# define PARACHUTE SDL_INIT_NOPARACHUTE 69# define PARACHUTE SDL_INIT_NOPARACHUTE
58#else 70#else
59# define PARACHUTE 0 71# define PARACHUTE 0
60#endif 72#endif
61 73
74static AV *texture_av;
75
62static struct 76static struct
63{ 77{
64#define GL_FUNC(ptr,name) ptr name; 78#define GL_FUNC(ptr,name) ptr name;
65#include "glfunc.h" 79#include "glfunc.h"
66#undef GL_FUNC 80#undef GL_FUNC
67} gl; 81} gl;
68 82
83static void
69static void gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa) 84gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa)
70{ 85{
71 if (gl.BlendFuncSeparate) 86 if (gl.BlendFuncSeparate)
72 gl.BlendFuncSeparate (sa, da, saa, daa); 87 gl.BlendFuncSeparate (sa, da, saa, daa);
73 else if (gl.BlendFuncSeparateEXT) 88 else if (gl.BlendFuncSeparateEXT)
74 gl.BlendFuncSeparateEXT (sa, da, saa, daa); 89 gl.BlendFuncSeparateEXT (sa, da, saa, daa);
75 else 90 else
76 glBlendFunc (sa, da); 91 glBlendFunc (sa, da);
77} 92}
78 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
79#include "texcache.c" 118#include "texcache.c"
119#include "rendercache.c"
80 120
81#include "pango-font.c" 121#include "pango-font.c"
82#include "pango-fontmap.c" 122#include "pango-fontmap.c"
83#include "pango-render.c" 123#include "pango-render.c"
84 124
125typedef IV CFPlus__Channel;
126typedef SDL_RWops *CFPlus__RW;
85typedef Mix_Chunk *CFClient__MixChunk; 127typedef Mix_Chunk *CFPlus__MixChunk;
86typedef Mix_Music *CFClient__MixMusic; 128typedef Mix_Music *CFPlus__MixMusic;
87 129
88typedef PangoFontDescription *CFClient__Font; 130typedef PangoFontDescription *CFPlus__Font;
89 131
90static int 132static int
91shape_attr_p (PangoLayoutRun *run) 133shape_attr_p (PangoLayoutRun *run)
92{ 134{
93 GSList *attrs = run->item->analysis.extra_attrs; 135 GSList *attrs = run->item->analysis.extra_attrs;
107 149
108typedef struct cf_layout { 150typedef struct cf_layout {
109 PangoLayout *pl; 151 PangoLayout *pl;
110 float r, g, b, a; // default color for rgba mode 152 float r, g, b, a; // default color for rgba mode
111 int base_height; 153 int base_height;
112 CFClient__Font font; 154 CFPlus__Font font;
113} *CFClient__Layout; 155} *CFPlus__Layout;
114 156
115static CFClient__Font default_font; 157static CFPlus__Font default_font;
116static PangoContext *opengl_context; 158static PangoContext *opengl_context;
117static PangoFontMap *opengl_fontmap; 159static PangoFontMap *opengl_fontmap;
118 160
119static void 161static void
120substitute_func (FcPattern *pattern, gpointer data) 162substitute_func (FcPattern *pattern, gpointer data)
125#endif 167#endif
126 FcPatternAddBool (pattern, FC_AUTOHINT, 0); 168 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
127} 169}
128 170
129static void 171static void
130layout_update_font (CFClient__Layout self) 172layout_update_font (CFPlus__Layout self)
131{ 173{
132 /* 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
133 * reasonably well with bitstream vera 175 * reasonably well with bitstream vera
134 */ 176 */
135 PangoFontDescription *font = self->font ? self->font : default_font; 177 PangoFontDescription *font = self->font ? self->font : default_font;
139 181
140 pango_layout_set_font_description (self->pl, font); 182 pango_layout_set_font_description (self->pl, font);
141} 183}
142 184
143static void 185static void
144layout_get_pixel_size (CFClient__Layout self, int *w, int *h) 186layout_get_pixel_size (CFPlus__Layout self, int *w, int *h)
145{ 187{
188 PangoRectangle rect;
189
190 // get_pixel_* wrongly rounds down
146 pango_layout_get_pixel_size (self->pl, w, h); 191 pango_layout_get_extents (self->pl, 0, &rect);
147 192
148 if (!*w) *w = 1; 193 rect.width = (rect.width + PANGO_SCALE - 1) / PANGO_SCALE;
149 if (!*h) *h = 1; 194 rect.height = (rect.height + PANGO_SCALE - 1) / PANGO_SCALE;
150 195
151 *w = (*w + 3) & ~3; 196 if (!rect.width) rect.width = 1;
152} 197 if (!rect.height) rect.height = 1;
153 198
199 *w = rect.width;
200 *h = rect.height;
201}
202
203typedef uint16_t tileid;
154typedef uint16_t mapface; 204typedef uint16_t faceid;
155 205
156typedef struct { 206typedef struct {
157 GLint name; 207 int name;
158 int w, h; 208 int w, h;
159 float s, t; 209 float s, t;
160 uint8_t r, g, b, a; 210 uint8_t r, g, b, a;
211 tileid smoothtile;
212 uint8_t smoothlevel;
161} maptex; 213} maptex;
162 214
163typedef struct { 215typedef struct {
216 uint32_t player;
217 tileid tile[3];
164 int16_t darkness; 218 uint16_t darkness;
165 mapface face[3]; 219 uint8_t stat_width, stat_hp, flags, smoothmax;
166} mapcell; 220} mapcell;
167 221
168typedef struct { 222typedef struct {
169 int32_t c0, c1; 223 int32_t c0, c1;
170 mapcell *col; 224 mapcell *col;
171} maprow; 225} maprow;
172 226
173typedef struct map { 227typedef struct map {
174 int x, y, w, h; 228 int x, y, w, h;
175 int ox, oy; /* offset to virtual global coordinate system */ 229 int ox, oy; /* offset to virtual global coordinate system */
176 int faces; 230 int faces; tileid *face2tile; // [faceid]
177 mapface *face; 231 int texs; maptex *tex; // [tileid]
178
179 int texs;
180 maptex *tex;
181 232
182 int32_t rows; 233 int32_t rows;
183 maprow *row; 234 maprow *row;
184} *CFClient__Map; 235} *CFPlus__Map;
185 236
186static char * 237static char *
187prepend (char *ptr, int sze, int inc) 238prepend (char *ptr, int sze, int inc)
188{ 239{
189 char *p; 240 char *p;
206} 257}
207 258
208#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))
209#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))
210 261
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
211static maprow * 282static maprow *
212map_get_row (CFClient__Map self, int y) 283map_get_row (CFPlus__Map self, int y)
213{ 284{
214 if (0 > y) 285 if (0 > y)
215 { 286 {
216 int extend = - y + MAP_EXTEND_Y; 287 int extend = - y + MAP_EXTEND_Y;
217 Prepend (maprow, self->row, self->rows, extend); 288 Prepend (maprow, self->row, self->rows, extend);
255 326
256 return row->col + (x - row->c0); 327 return row->col + (x - row->c0);
257} 328}
258 329
259static mapcell * 330static mapcell *
260map_get_cell (CFClient__Map self, int x, int y) 331map_get_cell (CFPlus__Map self, int x, int y)
261{ 332{
262 return row_get_cell (map_get_row (self, y), x); 333 return row_get_cell (map_get_row (self, y), x);
263} 334}
264 335
265static void 336static void
266map_clear (CFClient__Map self) 337map_clear (CFPlus__Map self)
267{ 338{
268 int r; 339 int r;
269 340
270 for (r = 0; r < self->rows; r++) 341 for (r = 0; r < self->rows; r++)
271 Safefree (self->row[r].col); 342 Safefree (self->row[r].col);
279 self->row = 0; 350 self->row = 0;
280 self->rows = 0; 351 self->rows = 0;
281} 352}
282 353
283static void 354static void
284map_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)
285{ 356{
286 int x, y; 357 int x, y;
287 maprow *row; 358 maprow *row;
359 mapcell *cell;
288 360
289 for (y = y0; y < y0 + h; y++) 361 for (y = y0; y < y0 + h; y++)
290 if (y >= 0) 362 if (y >= 0)
291 { 363 {
292 if (y >= self->rows) 364 if (y >= self->rows)
298 if (x >= row->c0) 370 if (x >= row->c0)
299 { 371 {
300 if (x >= row->c1) 372 if (x >= row->c1)
301 break; 373 break;
302 374
303 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;
304 } 381 }
305 } 382 }
383}
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);
306} 399}
307 400
308static void 401static void
309music_finished (void) 402music_finished (void)
310{ 403{
346 n |= n >> 16; 439 n |= n >> 16;
347 440
348 return n + 1; 441 return n + 1;
349} 442}
350 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
351MODULE = CFClient PACKAGE = CFClient 491MODULE = CFPlus PACKAGE = CFPlus
352 492
353PROTOTYPES: ENABLE 493PROTOTYPES: ENABLE
354 494
355BOOT: 495BOOT:
356{ 496{
357 HV *stash = gv_stashpv ("CFClient", 1); 497 HV *stash = gv_stashpv ("CFPlus", 1);
358 static const struct { 498 static const struct {
359 const char *name; 499 const char *name;
360 IV iv; 500 IV iv;
361 } *civ, const_iv[] = { 501 } *civ, const_iv[] = {
362# define const_iv(name) { # name, (IV)name } 502# define const_iv(name) { # name, (IV)name }
503 const_iv (SDLK_MODIFIER_MIN),
504 const_iv (SDLK_MODIFIER_MAX),
505
363 const_iv (SDL_ACTIVEEVENT), 506 const_iv (SDL_ACTIVEEVENT),
364 const_iv (SDL_KEYDOWN), 507 const_iv (SDL_KEYDOWN),
365 const_iv (SDL_KEYUP), 508 const_iv (SDL_KEYUP),
366 const_iv (SDL_MOUSEMOTION), 509 const_iv (SDL_MOUSEMOTION),
367 const_iv (SDL_MOUSEBUTTONDOWN), 510 const_iv (SDL_MOUSEBUTTONDOWN),
376 const_iv (SDL_EVENT_RESERVEDA), 519 const_iv (SDL_EVENT_RESERVEDA),
377 const_iv (SDL_EVENT_RESERVEDB), 520 const_iv (SDL_EVENT_RESERVEDB),
378 const_iv (SDL_VIDEORESIZE), 521 const_iv (SDL_VIDEORESIZE),
379 const_iv (SDL_VIDEOEXPOSE), 522 const_iv (SDL_VIDEOEXPOSE),
380 const_iv (SDL_USEREVENT), 523 const_iv (SDL_USEREVENT),
524
525 const_iv (SDL_APPINPUTFOCUS),
526 const_iv (SDL_APPMOUSEFOCUS),
527 const_iv (SDL_APPACTIVE),
528
381 const_iv (SDLK_KP0), 529 const_iv (SDLK_KP0),
382 const_iv (SDLK_KP1), 530 const_iv (SDLK_KP1),
383 const_iv (SDLK_KP2), 531 const_iv (SDLK_KP2),
384 const_iv (SDLK_KP3), 532 const_iv (SDLK_KP3),
385 const_iv (SDLK_KP4), 533 const_iv (SDLK_KP4),
440 const_iv (SDLK_BREAK), 588 const_iv (SDLK_BREAK),
441 const_iv (SDLK_MENU), 589 const_iv (SDLK_MENU),
442 const_iv (SDLK_POWER), 590 const_iv (SDLK_POWER),
443 const_iv (SDLK_EURO), 591 const_iv (SDLK_EURO),
444 const_iv (SDLK_UNDO), 592 const_iv (SDLK_UNDO),
593
445 const_iv (KMOD_NONE), 594 const_iv (KMOD_NONE),
595 const_iv (KMOD_SHIFT),
446 const_iv (KMOD_LSHIFT), 596 const_iv (KMOD_LSHIFT),
447 const_iv (KMOD_RSHIFT), 597 const_iv (KMOD_RSHIFT),
598 const_iv (KMOD_CTRL),
448 const_iv (KMOD_LCTRL), 599 const_iv (KMOD_LCTRL),
449 const_iv (KMOD_RCTRL), 600 const_iv (KMOD_RCTRL),
601 const_iv (KMOD_ALT),
450 const_iv (KMOD_LALT), 602 const_iv (KMOD_LALT),
451 const_iv (KMOD_RALT), 603 const_iv (KMOD_RALT),
604 const_iv (KMOD_META),
452 const_iv (KMOD_LMETA), 605 const_iv (KMOD_LMETA),
453 const_iv (KMOD_RMETA), 606 const_iv (KMOD_RMETA),
454 const_iv (KMOD_NUM), 607 const_iv (KMOD_NUM),
455 const_iv (KMOD_CAPS), 608 const_iv (KMOD_CAPS),
456 const_iv (KMOD_MODE), 609 const_iv (KMOD_MODE),
457 const_iv (KMOD_CTRL),
458 const_iv (KMOD_SHIFT),
459 const_iv (KMOD_ALT),
460 const_iv (KMOD_META)
461# undef const_iv 610# undef const_iv
462 }; 611 };
463 612
464 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 613 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
465 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->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);
466} 618}
619
620void
621weaken (SV *rv)
622 PROTOTYPE: $
623 CODE:
624 sv_rvweaken (rv);
467 625
468int 626int
469in_destruct () 627in_destruct ()
470 CODE: 628 CODE:
471 RETVAL = PL_main_cv == Nullcv; 629 RETVAL = PL_main_cv == Nullcv;
483 opengl_fontmap = pango_opengl_font_map_new (); 641 opengl_fontmap = pango_opengl_font_map_new ();
484 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0); 642 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
485 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap); 643 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
486} 644}
487 645
646char *
647SDL_GetError ()
648
488int 649int
489SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE) 650SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)
490 651
491void 652void
492SDL_Quit () 653SDL_Quit ()
493 654
494void 655void
495SDL_ListModes () 656SDL_ListModes (int rgb, int alpha)
496 PPCODE: 657 PPCODE:
497{ 658{
498 SDL_Rect **m; 659 SDL_Rect **m;
499 660
500 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5); 661 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
501 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5); 662 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
502 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5); 663 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
503 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 1); 664 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
504 665
505 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15); 666 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15);
506 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 0); 667 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE , 0);
507 668
508 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE, 0); 669 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE , 0);
509 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0); 670 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
510 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE, 0); 671 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
511 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0); 672 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
512 673
513 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); 674 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
514 675#if SDL_VERSION_ATLEAST(1,2,10)
515 SDL_EnableUNICODE (1); 676 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
516 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL); 677 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
678#endif
517 679
518 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 680 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
519 681
520 if (m && m != (SDL_Rect **)-1) 682 if (m && m != (SDL_Rect **)-1)
521 while (*m) 683 while (*m)
522 { 684 {
685 if ((*m)->w >= 640 && (*m)->h >= 480)
686 {
523 AV *av = newAV (); 687 AV *av = newAV ();
524 av_push (av, newSViv ((*m)->w)); 688 av_push (av, newSViv ((*m)->w));
525 av_push (av, newSViv ((*m)->h)); 689 av_push (av, newSViv ((*m)->h));
690 av_push (av, newSViv (rgb));
691 av_push (av, newSViv (alpha));
526 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av))); 692 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
693 }
527 694
528 ++m; 695 ++m;
529 } 696 }
530} 697}
531 698
532char *
533SDL_GetError ()
534
535int 699int
536SDL_SetVideoMode (int w, int h, int fullscreen) 700SDL_SetVideoMode (int w, int h, int rgb, int alpha, int fullscreen)
537 CODE: 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
538 RETVAL = !!SDL_SetVideoMode ( 711 RETVAL = !!SDL_SetVideoMode (
539 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0) 712 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0)
540 ); 713 );
714
541 if (RETVAL) 715 if (RETVAL)
542 { 716 {
717 av_clear (texture_av);
718
543 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+"); 719 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+");
544# define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name); 720#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
545# include "glfunc.h" 721#include "glfunc.h"
546# undef GL_FUNC 722#undef GL_FUNC
547 } 723 }
724}
548 OUTPUT: 725 OUTPUT:
549 RETVAL 726 RETVAL
550 727
551void 728void
552SDL_GL_SwapBuffers () 729SDL_GL_SwapBuffers ()
553 730
554char * 731char *
555SDL_GetKeyName (int sym) 732SDL_GetKeyName (int sym)
556 733
734int
735SDL_GetAppState ()
736
557void 737void
558SDL_PollEvent () 738poll_events ()
559 PPCODE: 739 PPCODE:
560{ 740{
561 SDL_Event ev; 741 SDL_Event ev;
562 742
563 while (SDL_PollEvent (&ev)) 743 SDL_PumpEvents ();
744 while (SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_ALLEVENTS) > 0)
564 { 745 {
565 HV *hv = newHV (); 746 HV *hv = newHV ();
566 hv_store (hv, "type", 4, newSViv (ev.type), 0); 747 hv_store (hv, "type", 4, newSViv (ev.type), 0);
567 748
568 switch (ev.type) 749 switch (ev.type)
570 case SDL_KEYDOWN: 751 case SDL_KEYDOWN:
571 case SDL_KEYUP: 752 case SDL_KEYUP:
572 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 753 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
573 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 754 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
574 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 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 */
575 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 757 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
576 break; 758 break;
577 759
578 case SDL_ACTIVEEVENT: 760 case SDL_ACTIVEEVENT:
579 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 761 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
580 hv_store (hv, "state", 5, newSViv (ev.active.state), 0); 762 hv_store (hv, "state", 5, newSViv (ev.active.state), 0);
581 break; 763 break;
582 764
583 case SDL_MOUSEMOTION: 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
584 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 784 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);
585
586 hv_store (hv, "state", 5, newSViv (ev.motion.state), 0); 785 hv_store (hv, "state", 5, newSViv (state), 0);
587 hv_store (hv, "x", 1, newSViv (ev.motion.x), 0); 786 hv_store (hv, "x", 1, newSViv (x), 0);
588 hv_store (hv, "y", 1, newSViv (ev.motion.y), 0); 787 hv_store (hv, "y", 1, newSViv (y), 0);
589 hv_store (hv, "xrel", 4, newSViv (ev.motion.xrel), 0); 788 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
590 hv_store (hv, "yrel", 4, newSViv (ev.motion.yrel), 0); 789 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
790 }
591 break; 791 break;
592 792
593 case SDL_MOUSEBUTTONDOWN: 793 case SDL_MOUSEBUTTONDOWN:
594 case SDL_MOUSEBUTTONUP: 794 case SDL_MOUSEBUTTONUP:
595 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 795 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);
605 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0); 805 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0);
606 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0); 806 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0);
607 break; 807 break;
608 } 808 }
609 809
610 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv))); 810 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("CFPlus::UI::Event", 1))));
611 } 811 }
612} 812}
613 813
614int 814int
615Mix_OpenAudio (int frequency = 48000, int format = MIX_DEFAULT_FORMAT, int channels = 1, int chunksize = 2048) 815Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 1024)
616 POSTCALL: 816 POSTCALL:
617 Mix_HookMusicFinished (music_finished); 817 Mix_HookMusicFinished (music_finished);
618 Mix_ChannelFinished (channel_finished); 818 Mix_ChannelFinished (channel_finished);
619 819
620void 820void
621Mix_CloseAudio () 821Mix_CloseAudio ()
622 822
623int 823int
624Mix_AllocateChannels (int numchans = -1) 824Mix_AllocateChannels (int numchans = -1)
625 825
826const char *
827Mix_GetError ()
828
626void 829void
627lowdelay (int fd, int val = 1) 830lowdelay (int fd, int val = 1)
628 CODE: 831 CODE:
832 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val));
833
834void
835win32_proxy_info ()
836 PPCODE:
837{
629#ifndef _WIN32 838#ifdef _WIN32
630 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val)); 839 char buffer[2048];
840 DWORD buflen;
841
842 EXTEND (SP, 3);
843
844 buflen = sizeof (buffer);
845 if (InternetQueryOption (0, INTERNET_OPTION_PROXY, (void *)buffer, &buflen))
846 if (((INTERNET_PROXY_INFO *)buffer)->dwAccessType == INTERNET_OPEN_TYPE_PROXY)
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 }
631#endif 860#endif
861}
632 862
633void 863void
634add_font (char *file) 864add_font (char *file)
635 CODE: 865 CODE:
636 FcConfigAppFontAddFile (0, (const FcChar8 *)file); 866 FcConfigAppFontAddFile (0, (const FcChar8 *)file);
644 STRLEN image_len; 874 STRLEN image_len;
645 char *image = (char *)SvPVbyte (image_, image_len); 875 char *image = (char *)SvPVbyte (image_, image_len);
646 SDL_Surface *surface, *surface2; 876 SDL_Surface *surface, *surface2;
647 SDL_PixelFormat fmt; 877 SDL_PixelFormat fmt;
648 SDL_RWops *rw = ix 878 SDL_RWops *rw = ix
649 ? SDL_RWFromFile (image, "r") 879 ? SDL_RWFromFile (image, "rb")
650 : SDL_RWFromConstMem (image, image_len); 880 : SDL_RWFromConstMem (image, image_len);
651 881
652 if (!rw) 882 if (!rw)
653 croak ("load_image: %s", SDL_GetError ()); 883 croak ("load_image: %s", SDL_GetError ());
654 884
740 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR); 970 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR);
741#endif 971#endif
742 _exit (1); 972 _exit (1);
743 973
744void 974void
745_exit (int retval) 975_exit (int retval = 0)
746 CODE: 976 CODE:
977#ifdef WIN32
978 ExitThread (retval); // unclean, please beam me up
979#else
747 _exit (retval); 980 _exit (retval);
981#endif
748 982
983void
984debug ()
985 CODE:
986{
987#if DEBUG
988 VALGRIND_DO_LEAK_CHECK;
989#endif
990}
991
749MODULE = CFClient PACKAGE = CFClient::Font 992MODULE = CFPlus PACKAGE = CFPlus::Font
750 993
751CFClient::Font 994PROTOTYPES: DISABLE
995
996CFPlus::Font
752new_from_file (SV *class, char *path, int id = 0) 997new_from_file (SV *class, char *path, int id = 0)
753 CODE: 998 CODE:
754{ 999{
755 int count; 1000 int count;
756 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count); 1001 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
759} 1004}
760 OUTPUT: 1005 OUTPUT:
761 RETVAL 1006 RETVAL
762 1007
763void 1008void
764DESTROY (CFClient::Font self) 1009DESTROY (CFPlus::Font self)
765 CODE: 1010 CODE:
766 pango_font_description_free (self); 1011 pango_font_description_free (self);
767 1012
768void 1013void
769make_default (CFClient::Font self) 1014make_default (CFPlus::Font self)
1015 PROTOTYPE: $
770 CODE: 1016 CODE:
771 default_font = self; 1017 default_font = self;
772 1018
773MODULE = CFClient PACKAGE = CFClient::Layout 1019MODULE = CFPlus PACKAGE = CFPlus::Layout
1020
1021PROTOTYPES: DISABLE
774 1022
775void 1023void
776reset_glyph_cache () 1024reset_glyph_cache ()
1025 PROTOTYPE:
777 CODE: 1026 CODE:
778 tc_clear (); 1027 tc_clear ();
779 1028
780CFClient::Layout 1029CFPlus::Layout
781new (SV *class) 1030new (SV *class)
782 CODE: 1031 CODE:
783 New (0, RETVAL, 1, struct cf_layout); 1032 New (0, RETVAL, 1, struct cf_layout);
784 1033
785 RETVAL->pl = pango_layout_new (opengl_context); 1034 RETVAL->pl = pango_layout_new (opengl_context);
794 layout_update_font (RETVAL); 1043 layout_update_font (RETVAL);
795 OUTPUT: 1044 OUTPUT:
796 RETVAL 1045 RETVAL
797 1046
798void 1047void
799DESTROY (CFClient::Layout self) 1048DESTROY (CFPlus::Layout self)
800 CODE: 1049 CODE:
801 g_object_unref (self->pl); 1050 g_object_unref (self->pl);
802 Safefree (self); 1051 Safefree (self);
803 1052
804void 1053void
805set_text (CFClient::Layout self, SV *text_) 1054set_text (CFPlus::Layout self, SV *text_)
806 CODE: 1055 CODE:
807{ 1056{
808 STRLEN textlen; 1057 STRLEN textlen;
809 char *text = SvPVutf8 (text_, textlen); 1058 char *text = SvPVutf8 (text_, textlen);
810 1059
811 pango_layout_set_text (self->pl, text, textlen); 1060 pango_layout_set_text (self->pl, text, textlen);
812} 1061}
813 1062
814void 1063void
815set_markup (CFClient::Layout self, SV *text_) 1064set_markup (CFPlus::Layout self, SV *text_)
816 CODE: 1065 CODE:
817{ 1066{
818 STRLEN textlen; 1067 STRLEN textlen;
819 char *text = SvPVutf8 (text_, textlen); 1068 char *text = SvPVutf8 (text_, textlen);
820 1069
821 pango_layout_set_markup (self->pl, text, textlen); 1070 pango_layout_set_markup (self->pl, text, textlen);
822} 1071}
823 1072
824void 1073void
825set_shapes (CFClient::Layout self, ...) 1074set_shapes (CFPlus::Layout self, ...)
826 CODE: 1075 CODE:
827{ 1076{
828 PangoAttrList *attrs = 0; 1077 PangoAttrList *attrs = 0;
829 const char *text = pango_layout_get_text (self->pl); 1078 const char *text = pango_layout_get_text (self->pl);
830 const char *pos = text; 1079 const char *pos = text;
865 if (attrs) 1114 if (attrs)
866 pango_layout_set_attributes (self->pl, attrs); 1115 pango_layout_set_attributes (self->pl, attrs);
867} 1116}
868 1117
869void 1118void
870get_shapes (CFClient::Layout self) 1119get_shapes (CFPlus::Layout self)
871 PPCODE: 1120 PPCODE:
872{ 1121{
873 PangoLayoutIter *iter = pango_layout_get_iter (self->pl); 1122 PangoLayoutIter *iter = pango_layout_get_iter (self->pl);
874 1123
875 do 1124 do
890 1139
891 pango_layout_iter_free (iter); 1140 pango_layout_iter_free (iter);
892} 1141}
893 1142
894int 1143int
895has_wrapped (CFClient::Layout self) 1144has_wrapped (CFPlus::Layout self)
896 CODE: 1145 CODE:
897{ 1146{
898 int lines = 1; 1147 int lines = 1;
899 const char *text = pango_layout_get_text (self->pl); 1148 const char *text = pango_layout_get_text (self->pl);
900 1149
905} 1154}
906 OUTPUT: 1155 OUTPUT:
907 RETVAL 1156 RETVAL
908 1157
909SV * 1158SV *
910get_text (CFClient::Layout self) 1159get_text (CFPlus::Layout self)
911 CODE: 1160 CODE:
912 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0); 1161 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
913 sv_utf8_decode (RETVAL); 1162 sv_utf8_decode (RETVAL);
914 OUTPUT: 1163 OUTPUT:
915 RETVAL 1164 RETVAL
916 1165
917void 1166void
918set_foreground (CFClient::Layout self, float r, float g, float b, float a = 1.) 1167set_foreground (CFPlus::Layout self, float r, float g, float b, float a = 1.)
919 CODE: 1168 CODE:
920 self->r = r; 1169 self->r = r;
921 self->g = g; 1170 self->g = g;
922 self->b = b; 1171 self->b = b;
923 self->a = a; 1172 self->a = a;
924 1173
925void 1174void
926set_font (CFClient::Layout self, CFClient::Font font = 0) 1175set_font (CFPlus::Layout self, CFPlus::Font font = 0)
927 CODE: 1176 CODE:
928 if (self->font != font) 1177 if (self->font != font)
929 { 1178 {
930 self->font = font; 1179 self->font = font;
931 layout_update_font (self); 1180 layout_update_font (self);
932 } 1181 }
933 1182
934void 1183void
935set_height (CFClient::Layout self, int base_height) 1184set_height (CFPlus::Layout self, int base_height)
936 CODE: 1185 CODE:
937 if (self->base_height != base_height) 1186 if (self->base_height != base_height)
938 { 1187 {
939 self->base_height = base_height; 1188 self->base_height = base_height;
940 layout_update_font (self); 1189 layout_update_font (self);
941 } 1190 }
942 1191
943void 1192void
944set_width (CFClient::Layout self, int max_width = -1) 1193set_width (CFPlus::Layout self, int max_width = -1)
945 CODE: 1194 CODE:
946 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);
947 1196
948void 1197void
949set_indent (CFClient::Layout self, int indent) 1198set_indent (CFPlus::Layout self, int indent)
950 CODE: 1199 CODE:
951 pango_layout_set_indent (self->pl, indent * PANGO_SCALE); 1200 pango_layout_set_indent (self->pl, indent * PANGO_SCALE);
952 1201
953void 1202void
954set_spacing (CFClient::Layout self, int spacing) 1203set_spacing (CFPlus::Layout self, int spacing)
955 CODE: 1204 CODE:
956 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE); 1205 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE);
957 1206
958void 1207void
959set_ellipsise (CFClient::Layout self, int ellipsise) 1208set_ellipsise (CFPlus::Layout self, int ellipsise)
960 CODE: 1209 CODE:
961 pango_layout_set_ellipsize (self->pl, 1210 pango_layout_set_ellipsize (self->pl,
962 ellipsise == 1 ? PANGO_ELLIPSIZE_START 1211 ellipsise == 1 ? PANGO_ELLIPSIZE_START
963 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE 1212 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE
964 : ellipsise == 3 ? PANGO_ELLIPSIZE_END 1213 : ellipsise == 3 ? PANGO_ELLIPSIZE_END
965 : PANGO_ELLIPSIZE_NONE 1214 : PANGO_ELLIPSIZE_NONE
966 ); 1215 );
967 1216
968void 1217void
969set_single_paragraph_mode (CFClient::Layout self, int spm) 1218set_single_paragraph_mode (CFPlus::Layout self, int spm)
970 CODE: 1219 CODE:
971 pango_layout_set_single_paragraph_mode (self->pl, !!spm); 1220 pango_layout_set_single_paragraph_mode (self->pl, !!spm);
972 1221
973void 1222void
974size (CFClient::Layout self) 1223size (CFPlus::Layout self)
975 PPCODE: 1224 PPCODE:
976{ 1225{
977 int w, h; 1226 int w, h;
978 1227
979 layout_get_pixel_size (self, &w, &h); 1228 layout_get_pixel_size (self, &w, &h);
982 PUSHs (sv_2mortal (newSViv (w))); 1231 PUSHs (sv_2mortal (newSViv (w)));
983 PUSHs (sv_2mortal (newSViv (h))); 1232 PUSHs (sv_2mortal (newSViv (h)));
984} 1233}
985 1234
986int 1235int
987descent (CFClient::Layout self) 1236descent (CFPlus::Layout self)
988 CODE: 1237 CODE:
989{ 1238{
990 PangoRectangle rect; 1239 PangoRectangle rect;
991 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0); 1240 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0);
992 pango_layout_line_get_pixel_extents (line, 0, &rect); 1241 pango_layout_line_get_pixel_extents (line, 0, &rect);
994} 1243}
995 OUTPUT: 1244 OUTPUT:
996 RETVAL 1245 RETVAL
997 1246
998int 1247int
999xy_to_index (CFClient::Layout self, int x, int y) 1248xy_to_index (CFPlus::Layout self, int x, int y)
1000 CODE: 1249 CODE:
1001{ 1250{
1002 int index, trailing; 1251 int index, trailing;
1003 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);
1004 RETVAL = index; 1253 RETVAL = index + trailing;
1005} 1254}
1006 OUTPUT: 1255 OUTPUT:
1007 RETVAL 1256 RETVAL
1008 1257
1009void 1258void
1010cursor_pos (CFClient::Layout self, int index) 1259cursor_pos (CFPlus::Layout self, int index)
1011 PPCODE: 1260 PPCODE:
1012{ 1261{
1013 PangoRectangle strong_pos; 1262 PangoRectangle strong_pos;
1014 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1263 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);
1015 1264
1018 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1267 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
1019 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1268 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));
1020} 1269}
1021 1270
1022void 1271void
1272index_to_line_x (CFPlus::Layout self, int index, int trailing = 0)
1273 PPCODE:
1274{
1275 int line, x;
1276
1277 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
1278 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
1279
1280 EXTEND (SP, 2);
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 {
1305 PUSHs (sv_2mortal (newSViv (index)));
1306 PUSHs (sv_2mortal (newSViv (trailing)));
1307 }
1308}
1309
1310void
1023render (CFClient::Layout self, float x, float y) 1311render (CFPlus::Layout self, float x, float y, int flags = 0)
1024 PPCODE: 1312 PPCODE:
1025 pango_opengl_render_layout_subpixel ( 1313 pango_opengl_render_layout_subpixel (
1026 self->pl, 1314 self->pl,
1027 x * PANGO_SCALE, y * PANGO_SCALE, 1315 x * PANGO_SCALE, y * PANGO_SCALE,
1028 self->r, self->g, self->b, self->a 1316 self->r, self->g, self->b, self->a,
1317 flags
1029 ); 1318 );
1030 1319
1031MODULE = CFClient PACKAGE = CFClient::Texture 1320MODULE = CFPlus PACKAGE = CFPlus::Texture
1032 1321
1033void 1322PROTOTYPES: ENABLE
1034pad2pot (SV *data_, SV *w_, SV *h_)
1035 CODE:
1036{
1037 int ow = SvIV (w_);
1038 int oh = SvIV (h_);
1039 1323
1040 if (ow && oh) 1324int minpot (int n)
1325
1326void
1327pad (SV *data_, int ow, int oh, int nw, int nh)
1328 CODE:
1329{
1330 if ((nw != ow || nh != oh) && SvOK (data_))
1041 { 1331 {
1042 int nw = minpot (ow);
1043 int nh = minpot (oh);
1044
1045 if (nw != ow || nh != oh)
1046 {
1047 if (SvOK (data_))
1048 {
1049 STRLEN datalen; 1332 STRLEN datalen;
1050 char *data = SvPVbyte (data_, datalen); 1333 char *data = SvPVbyte (data_, datalen);
1051 int bpp = datalen / (ow * oh); 1334 int bpp = datalen / (ow * oh);
1052 SV *result_ = sv_2mortal (newSV (nw * nh * bpp)); 1335 SV *result_ = sv_2mortal (newSV (nw * nh * bpp));
1053 1336
1054 SvPOK_only (result_); 1337 SvPOK_only (result_);
1055 SvCUR_set (result_, nw * nh * bpp); 1338 SvCUR_set (result_, nw * nh * bpp);
1056 1339
1057 memset (SvPVX (result_), 0, nw * nh * bpp); 1340 memset (SvPVX (result_), 0, nw * nh * bpp);
1058 while (oh--) 1341 while (oh--)
1059 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp); 1342 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp);
1060 1343
1061 sv_setsv (data_, result_); 1344 sv_setsv (data_, result_);
1062 }
1063
1064 sv_setiv (w_, nw);
1065 sv_setiv (h_, nh);
1066 }
1067 } 1345 }
1068} 1346}
1069 1347
1070void 1348void
1071draw_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.)
1077{ 1355{
1078 HV *hv = (HV *)SvRV (self); 1356 HV *hv = (HV *)SvRV (self);
1079 float s = SvNV (*hv_fetch (hv, "s", 1, 1)); 1357 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
1080 float t = SvNV (*hv_fetch (hv, "t", 1, 1)); 1358 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
1081 int name = SvIV (*hv_fetch (hv, "name", 4, 1)); 1359 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
1360
1361 if (name <= 0)
1362 XSRETURN_EMPTY;
1082 1363
1083 if (items < 5) 1364 if (items < 5)
1084 { 1365 {
1085 w = SvNV (*hv_fetch (hv, "w", 1, 1)); 1366 w = SvNV (*hv_fetch (hv, "w", 1, 1));
1086 h = SvNV (*hv_fetch (hv, "h", 1, 1)); 1367 h = SvNV (*hv_fetch (hv, "h", 1, 1));
1114 glDisable (GL_ALPHA_TEST); 1395 glDisable (GL_ALPHA_TEST);
1115 glDisable (GL_BLEND); 1396 glDisable (GL_BLEND);
1116 } 1397 }
1117} 1398}
1118 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
1119MODULE = CFClient PACKAGE = CFClient::Map 1411MODULE = CFPlus PACKAGE = CFPlus::Map
1120 1412
1121CFClient::Map 1413PROTOTYPES: DISABLE
1122new (SV *class, int map_width, int map_height) 1414
1415CFPlus::Map
1416new (SV *class)
1123 CODE: 1417 CODE:
1124 New (0, RETVAL, 1, struct map); 1418 New (0, RETVAL, 1, struct map);
1125 RETVAL->x = 0; 1419 RETVAL->x = 0;
1126 RETVAL->y = 0; 1420 RETVAL->y = 0;
1127 RETVAL->w = map_width; 1421 RETVAL->w = 0;
1128 RETVAL->h = map_height; 1422 RETVAL->h = 0;
1129 RETVAL->ox = 0; 1423 RETVAL->ox = 0;
1130 RETVAL->oy = 0; 1424 RETVAL->oy = 0;
1131 RETVAL->faces = 8192; 1425 RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
1132 Newz (0, RETVAL->face, RETVAL->faces, mapface); 1426 RETVAL->texs = 8192; Newz (0, RETVAL->tex , RETVAL->texs , maptex);
1133 RETVAL->texs = 8192;
1134 Newz (0, RETVAL->tex, RETVAL->texs, maptex);
1135 RETVAL->rows = 0; 1427 RETVAL->rows = 0;
1136 RETVAL->row = 0; 1428 RETVAL->row = 0;
1137 OUTPUT: 1429 OUTPUT:
1138 RETVAL 1430 RETVAL
1139 1431
1140void 1432void
1141DESTROY (CFClient::Map self) 1433DESTROY (CFPlus::Map self)
1142 CODE: 1434 CODE:
1143{ 1435{
1144 map_clear (self); 1436 map_clear (self);
1145 Safefree (self->face); 1437 Safefree (self->face2tile);
1146 Safefree (self->tex); 1438 Safefree (self->tex);
1147 Safefree (self); 1439 Safefree (self);
1148} 1440}
1149 1441
1150void 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
1151clear (CFClient::Map self) 1449clear (CFPlus::Map self)
1152 CODE: 1450 CODE:
1153 map_clear (self); 1451 map_clear (self);
1154 1452
1155void 1453void
1156set_face (CFClient::Map self, int face, int texid) 1454set_tileid (CFPlus::Map self, int face, int tile)
1157 CODE: 1455 CODE:
1158{ 1456{
1159 while (self->faces <= face) 1457 need_facenum (self, face); self->face2tile [face] = tile;
1160 { 1458 need_texid (self, tile);
1161 Append (mapface, self->face, self->faces, self->faces);
1162 self->faces *= 2;
1163 }
1164
1165 self->face [face] = texid;
1166} 1459}
1167 1460
1168void 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
1169set_texture (CFClient::Map self, int texid, 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)
1170 CODE: 1486 CODE:
1171{ 1487{
1172 while (self->texs <= texid) 1488 need_texid (self, texid);
1173 {
1174 Append (maptex, self->tex, self->texs, self->texs);
1175 self->texs *= 2;
1176 }
1177 1489
1178 { 1490 {
1179 maptex *tex = self->tex + texid; 1491 maptex *tex = self->tex + texid;
1180 1492
1181 tex->name = name; 1493 tex->name = name;
1198 // from transparent color bleeding and ugly wrapping effects. 1510 // from transparent color bleeding and ugly wrapping effects.
1199 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1511 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1200} 1512}
1201 1513
1202int 1514int
1203ox (CFClient::Map self) 1515ox (CFPlus::Map self)
1204 ALIAS: 1516 ALIAS:
1205 oy = 1 1517 oy = 1
1206 x = 2 1518 x = 2
1207 y = 3 1519 y = 3
1208 w = 4 1520 w = 4
1219 } 1531 }
1220 OUTPUT: 1532 OUTPUT:
1221 RETVAL 1533 RETVAL
1222 1534
1223void 1535void
1224scroll (CFClient::Map self, int dx, int dy) 1536scroll (CFPlus::Map self, int dx, int dy)
1225 CODE: 1537 CODE:
1226{ 1538{
1227 if (dx > 0) 1539 if (dx > 0)
1228 map_blank (self, self->x, self->y, dx - 1, self->h); 1540 map_blank (self, self->x, self->y, dx, self->h);
1229 else if (dx < 0) 1541 else if (dx < 0)
1230 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);
1231 1543
1232 if (dy > 0) 1544 if (dy > 0)
1233 map_blank (self, self->x, self->y, self->w, dy - 1); 1545 map_blank (self, self->x, self->y, self->w, dy);
1234 else if (dy < 0) 1546 else if (dy < 0)
1235 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);
1236 1548
1237 self->ox += dx; self->x += dx; 1549 self->ox += dx; self->x += dx;
1238 self->oy += dy; self->y += dy; 1550 self->oy += dy; self->y += dy;
1239 1551
1240 while (self->y < 0) 1552 while (self->y < 0)
1244 self->rows += MAP_EXTEND_Y; 1556 self->rows += MAP_EXTEND_Y;
1245 self->y += MAP_EXTEND_Y; 1557 self->y += MAP_EXTEND_Y;
1246 } 1558 }
1247} 1559}
1248 1560
1249void 1561SV *
1250map1a_update (CFClient::Map self, SV *data_) 1562map1a_update (CFPlus::Map self, SV *data_, int extmap)
1251 CODE: 1563 CODE:
1252{ 1564{
1253 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 1565 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1254 uint8_t *data_end = (uint8_t *)SvEND (data_); 1566 uint8_t *data_end = (uint8_t *)SvEND (data_);
1255 mapcell *cell; 1567 mapcell *cell;
1256 int x, y, flags; 1568 int x, y, z, flags;
1569 AV *missing = newAV ();
1570 RETVAL = newRV_noinc ((SV *)missing);
1257 1571
1258 while (data < data_end) 1572 while (data < data_end - 1)
1259 { 1573 {
1260 flags = (data [0] << 8) + data [1]; data += 2; 1574 flags = (data [0] << 8) + data [1]; data += 2;
1261 1575
1262 x = self->x + ((flags >> 10) & 63); 1576 x = self->x + ((flags >> 10) & 63);
1263 y = self->y + ((flags >> 4) & 63); 1577 y = self->y + ((flags >> 4) & 63);
1264 1578
1265 cell = map_get_cell (self, x, y); 1579 cell = map_get_cell (self, x, y);
1266 1580
1267 if (flags & 15) 1581 if (flags & 15)
1268 { 1582 {
1269 if (cell->darkness < 0) 1583 if (!cell->darkness)
1270 { 1584 {
1585 memset (cell, 0, sizeof (*cell));
1271 cell->darkness = 0; 1586 cell->darkness = 256;
1272 cell->face [0] = 0;
1273 cell->face [1] = 0;
1274 cell->face [2] = 0;
1275 } 1587 }
1276 1588
1277 cell->darkness = flags & 8 ? *data++ : 255;
1278
1279 //TODO: don't trust server data to be in-range(!) 1589 //TODO: don't trust server data to be in-range(!)
1280 1590
1281 if (flags & 4) 1591 if (flags & 8)
1282 { 1592 {
1283 cell->face [0] = self->face [(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;
1284 } 1629 }
1285 1630
1631 for (z = 0; z <= 2; ++z)
1286 if (flags & 2) 1632 if (flags & (4 >> z))
1287 { 1633 {
1288 cell->face [1] = self->face [(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 }
1289 } 1651 }
1290
1291 if (flags & 1)
1292 {
1293 cell->face [2] = self->face [(data [0] << 8) + data [1]]; data += 2;
1294 }
1295 } 1652 }
1296 else 1653 else
1297 cell->darkness = -1; 1654 cell->darkness = 0;
1298 } 1655 }
1299} 1656}
1657 OUTPUT:
1658 RETVAL
1300 1659
1301SV * 1660SV *
1302mapmap (CFClient::Map self, int x0, int y0, int w, int h) 1661mapmap (CFPlus::Map self, int x0, int y0, int w, int h)
1303 CODE: 1662 CODE:
1304{ 1663{
1305 int x1, x; 1664 int x1, x;
1306 int y1, y; 1665 int y1, y;
1307 int z; 1666 int z;
1328 { 1687 {
1329 mapcell *cell = row->col + (x - row->c0); 1688 mapcell *cell = row->col + (x - row->c0);
1330 1689
1331 for (z = 0; z <= 0; z++) 1690 for (z = 0; z <= 0; z++)
1332 { 1691 {
1333 mapface face = cell->face [z];
1334
1335 if (face)
1336 {
1337 maptex tex = self->tex [face]; 1692 maptex tex = self->tex [cell->tile [z]];
1338 int a0 = 255 - tex.a; 1693 int a0 = 255 - tex.a;
1339 int a1 = tex.a; 1694 int a1 = tex.a;
1340 1695
1341 r = (r * a0 + tex.r * a1) / 255; 1696 r = (r * a0 + tex.r * a1) / 255;
1342 g = (g * a0 + tex.g * a1) / 255; 1697 g = (g * a0 + tex.g * a1) / 255;
1343 b = (b * a0 + tex.b * a1) / 255; 1698 b = (b * a0 + tex.b * a1) / 255;
1344 a = (a * a0 + tex.a * a1) / 255; 1699 a = (a * a0 + tex.a * a1) / 255;
1345 }
1346 } 1700 }
1347 } 1701 }
1348 1702
1349 *map++ = (r ) 1703 *map++ = (r )
1350 | (g << 8) 1704 | (g << 8)
1357} 1711}
1358 OUTPUT: 1712 OUTPUT:
1359 RETVAL 1713 RETVAL
1360 1714
1361void 1715void
1362draw (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)
1363 CODE: 1717 CODE:
1364{ 1718{
1365 int vx, vy;
1366 int x, y, z; 1719 int x, y, z;
1367 int last_name;
1368 mapface face;
1369 1720
1370 vx = self->x + self->w / 2 - sw / 2 - shift_x; 1721 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1371 vy = self->y + self->h / 2 - sh / 2 - shift_y; 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;
1372 1725
1373 /* 1726 rc_t *rc = rc_alloc ();
1374 int vx = self->vx = self->w >= sw 1727 rc_key_t key;
1375 ? self->x + (self->w - sw) / 2 1728 rc_array_t *arr;
1376 : MIN (self->x, MAX (self->x + self->w - sw + 1, self->vx));
1377 1729
1378 int vy = self->vy = self->h >= sh 1730 // thats current max. sorry.
1379 ? self->y + (self->h - sh) / 2 1731 if (sw > 255) sw = 255;
1380 : MIN (self->y, MAX (self->y + self->h - sh + 1, self->vy)); 1732 if (sh > 255) sh = 255;
1381 */
1382 1733
1383 glColor4ub (255, 255, 255, 255); 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 }
1384 1770
1385 glEnable (GL_BLEND); 1771 glEnable (GL_BLEND);
1386 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 1772 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1387 glEnable (GL_TEXTURE_2D);
1388 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 1773 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1389 1774
1390 glBegin (GL_QUADS);
1391
1392 last_name = 0;
1393
1394 for (z = 0; z < 3; z++) 1775 for (z = 0; z <= 2; z++)
1776 {
1777 memset (smooth_level, 0, sizeof (smooth_level));
1778
1395 for (y = 0; y < sh; y++) 1779 for (y = 0; y < sh; y++)
1396 if (0 <= y + vy && y + vy < self->rows) 1780 if (0 <= y + my && y + my < self->rows)
1397 { 1781 {
1398 maprow *row = self->row + (y + vy); 1782 maprow *row = self->row + (y + my);
1399 1783
1400 for (x = 0; x < sw; x++) 1784 for (x = 0; x < sw; x++)
1401 if (row->c0 <= x + vx && x + vx < row->c1) 1785 if (row->c0 <= x + mx && x + mx < row->c1)
1402 { 1786 {
1403 mapcell *cell = row->col + (x + vx - row->c0); 1787 mapcell *cell = row->col + (x + mx - row->c0);
1404
1405 face = cell->face [z]; 1788 tileid tile = cell->tile [z];
1406 1789
1407 if (face) 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 rc_draw (rc);
1882 rc_clear (rc);
1883
1884 // go through all smoothlevels, lowest to highest, then draw.
1885 // this is basically counting sort
1886 {
1887 int w, b;
1888
1889 for (w = 0; w < 256 / 32; ++w)
1890 {
1891 uint32_t smask = smooth_level [w];
1892 if (smask)
1893 for (b = 0; b < 32; ++b)
1894 if (smask & (((uint32_t)1) << b))
1408 { 1895 {
1409 maptex tex = self->tex [face]; 1896 int level = (w << 5) | b;
1897 HE *he;
1410 1898
1411 int px = (x + 1) * 32 - tex.w; 1899 hv_iterinit (smooth);
1412 int py = (y + 1) * 32 - tex.h; 1900 while ((he = hv_iternext (smooth)))
1413
1414 if (last_name != tex.name)
1415 { 1901 {
1902 smooth_key *skey = (smooth_key *)HeKEY (he);
1903 IV bits = SvIVX (HeVAL (he));
1904
1905 if (!(bits & 0x1000)
1906 && skey->level == level
1907 && level > smooth_max [skey->x][skey->y])
1416 glEnd (); 1908 {
1909 maptex tex = self->tex [skey->tile];
1910 int px = (((int)skey->x) - 1) * T;
1911 int py = (((int)skey->y) - 1) * T;
1912 int border = bits & 15;
1913 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1914 float dx = tex.s * .0625f; // 16 images/row
1915 float dy = tex.t * .5f ; // 2 images/column
1916
1917 if (tex.name)
1918 {
1919 // this time avoiding texture state changes
1920 // save gobs of state changes.
1921 if (key.texname != tex.name)
1922 {
1417 last_name = tex.name; 1923 key.texname = tex.name;
1418 glBindTexture (GL_TEXTURE_2D, last_name); 1924 arr = rc_array (rc, &key);
1419 glBegin (GL_QUADS); 1925 }
1926
1927 if (border)
1928 {
1929 float ox = border * dx;
1930
1931 rc_t2f_v3f (arr, ox , 0.f , px , py , 0);
1932 rc_t2f_v3f (arr, ox , dy , px , py + T, 0);
1933 rc_t2f_v3f (arr, ox + dx, dy , px + T, py + T, 0);
1934 rc_t2f_v3f (arr, ox + dx, 0.f , px + T, py , 0);
1935 }
1936
1937 if (corner)
1938 {
1939 float ox = corner * dx;
1940
1941 rc_t2f_v3f (arr, ox , dy , px , py , 0);
1942 rc_t2f_v3f (arr, ox , dy * 2.f, px , py + T, 0);
1943 rc_t2f_v3f (arr, ox + dx, dy * 2.f, px + T, py + T, 0);
1944 rc_t2f_v3f (arr, ox + dx, dy , px + T, py , 0);
1945 }
1946 }
1947 }
1420 } 1948 }
1421
1422 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1423 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1424 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1425 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1426 } 1949 }
1427 }
1428 } 1950 }
1951 }
1429 1952
1430 glEnd (); 1953 hv_clear (smooth);
1954 rc_draw (rc);
1955 rc_clear (rc);
1956 }
1431 1957
1432 glDisable (GL_TEXTURE_2D);
1433 glDisable (GL_BLEND); 1958 glDisable (GL_BLEND);
1434} 1959 rc_free (rc);
1435 1960
1961 // top layer: overlays such as the health bar
1962 for (y = 0; y < sh; y++)
1963 if (0 <= y + my && y + my < self->rows)
1964 {
1965 maprow *row = self->row + (y + my);
1966
1967 for (x = 0; x < sw; x++)
1968 if (row->c0 <= x + mx && x + mx < row->c1)
1969 {
1970 mapcell *cell = row->col + (x + mx - row->c0);
1971
1972 int px = x * T;
1973 int py = y * T;
1974
1975 if (cell->stat_hp)
1976 {
1977 int width = cell->stat_width * T;
1978 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
1979
1980 glColor3ub (0, 0, 0);
1981 glRectf (px + 1, py - thick - 2,
1982 px + width - 1, py);
1983
1984 glColor3ub (cell->stat_hp, 255 - cell->stat_hp, 0);
1985 glRectf (px + 2,
1986 py - thick - 1,
1987 px + width - 2 - cell->stat_hp * (width - 4) / 255, py - 1);
1988 }
1989 }
1990 }
1991}
1992
1436void 1993void
1437draw_magicmap (CFClient::Map self, int dx, int dy, int w, int h, unsigned char *data) 1994draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data)
1438 CODE: 1995 CODE:
1439{ 1996{
1440 static float color[16][3] = { 1997 static float color[16][3] = {
1441 { 0.00F, 0.00F, 0.00F }, 1998 { 0.00F, 0.00F, 0.00F },
1442 { 1.00F, 1.00F, 1.00F }, 1999 { 1.00F, 1.00F, 1.00F },
1492 glDisable (GL_BLEND); 2049 glDisable (GL_BLEND);
1493 glDisable (GL_TEXTURE_2D); 2050 glDisable (GL_TEXTURE_2D);
1494} 2051}
1495 2052
1496void 2053void
1497fow_texture (CFClient::Map self, int shift_x, int shift_y, int x0, int y0, int sw, int sh) 2054fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh)
1498 PPCODE: 2055 PPCODE:
1499{ 2056{
1500 int vx, vy;
1501 int x, y; 2057 int x, y;
2058 int sw1 = sw + 2;
2059 int sh1 = sh + 2;
2060 int sh3 = sh * 3;
1502 int sw4 = (sw + 3) & ~3; 2061 int sw34 = (sw * 3 + 3) & ~3;
2062 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
1503 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh)); 2063 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));
1504 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv); 2064 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
1505 2065
1506 memset (darkness, 255, sw4 * sh);
1507 SvPOK_only (darkness_sv); 2066 SvPOK_only (darkness3_sv);
1508 SvCUR_set (darkness_sv, sw4 * sh); 2067 SvCUR_set (darkness3_sv, sw34 * sh3);
1509 2068
1510 vx = self->x + (self->w - sw + 1) / 2 - shift_x; 2069 mx += self->x - 1;
1511 vy = self->y + (self->h - sh + 1) / 2 - shift_y; 2070 my += self->y - 1;
1512 2071
2072 memset (darkness1, 255, sw1 * sh1);
2073
1513 for (y = 0; y < sh; y++) 2074 for (y = 0; y < sh1; y++)
1514 if (0 <= y + vy && y + vy < self->rows) 2075 if (0 <= y + my && y + my < self->rows)
1515 { 2076 {
1516 maprow *row = self->row + (y + vy); 2077 maprow *row = self->row + (y + my);
1517 2078
1518 for (x = 0; x < sw; x++) 2079 for (x = 0; x < sw1; x++)
1519 if (row->c0 <= x + vx && x + vx < row->c1) 2080 if (row->c0 <= x + mx && x + mx < row->c1)
1520 { 2081 {
1521 mapcell *cell = row->col + (x + vx - row->c0); 2082 mapcell *cell = row->col + (x + mx - row->c0);
1522 2083
1523 darkness[y * sw4 + x] = cell->darkness < 0 2084 darkness1 [y * sw1 + x] = cell->darkness
2085 ? 255 - (cell->darkness - 1)
1524 ? 255 - FOW_DARKNESS 2086 : 255 - FOW_DARKNESS;
1525 : 255 - cell->darkness;
1526 } 2087 }
1527 } 2088 }
1528 2089
2090 for (y = 0; y < sh; ++y)
2091 for (x = 0; x < sw; ++x)
2092 {
2093 uint8_t d11 = darkness1 [(y ) * sw1 + x ];
2094 uint8_t d21 = darkness1 [(y ) * sw1 + x + 1];
2095 uint8_t d31 = darkness1 [(y ) * sw1 + x + 2];
2096 uint8_t d12 = darkness1 [(y + 1) * sw1 + x ];
2097 uint8_t d22 = darkness1 [(y + 1) * sw1 + x + 1];
2098 uint8_t d32 = darkness1 [(y + 1) * sw1 + x + 2];
2099 uint8_t d13 = darkness1 [(y + 2) * sw1 + x ];
2100 uint8_t d23 = darkness1 [(y + 2) * sw1 + x + 1];
2101 uint8_t d33 = darkness1 [(y + 2) * sw1 + x + 2];
2102
2103 uint8_t r11 = (d11 + d21 + d12) / 3;
2104 uint8_t r21 = d21;
2105 uint8_t r31 = (d21 + d31 + d32) / 3;
2106
2107 uint8_t r12 = d12;
2108 uint8_t r22 = d22;
2109 uint8_t r32 = d32;
2110
2111 uint8_t r13 = (d13 + d23 + d12) / 3;
2112 uint8_t r23 = d23;
2113 uint8_t r33 = (d23 + d33 + d32) / 3;
2114
2115 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11);
2116 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21);
2117 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31);
2118 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12);
2119 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22);
2120 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32);
2121 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13);
2122 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23);
2123 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33);
2124 }
2125
2126 free (darkness1);
2127
1529 EXTEND (SP, 3); 2128 EXTEND (SP, 3);
1530 PUSHs (sv_2mortal (newSViv (sw4))); 2129 PUSHs (sv_2mortal (newSViv (sw34)));
1531 PUSHs (sv_2mortal (newSViv (sh))); 2130 PUSHs (sv_2mortal (newSViv (sh3)));
1532 PUSHs (darkness_sv); 2131 PUSHs (darkness3_sv);
1533} 2132}
1534 2133
1535SV * 2134SV *
1536get_rect (CFClient::Map self, int x0, int y0, int w, int h) 2135get_rect (CFPlus::Map self, int x0, int y0, int w, int h)
1537 CODE: 2136 CODE:
1538{ 2137{
1539 int x, y, x1, y1; 2138 int x, y, x1, y1;
1540 SV *data_sv = newSV (w * h * 7 + 5); 2139 SV *data_sv = newSV (w * h * 7 + 5);
1541 uint8_t *data = (uint8_t *)SvPVX (data_sv); 2140 uint8_t *data = (uint8_t *)SvPVX (data_sv);
1566 if (row && row->c0 <= x && x < row->c1) 2165 if (row && row->c0 <= x && x < row->c1)
1567 { 2166 {
1568 mapcell *cell = row->col + (x - row->c0); 2167 mapcell *cell = row->col + (x - row->c0);
1569 uint8_t flags = 0; 2168 uint8_t flags = 0;
1570 2169
1571 if (cell->face [0]) flags |= 1; 2170 if (cell->tile [0]) flags |= 1;
1572 if (cell->face [1]) flags |= 2; 2171 if (cell->tile [1]) flags |= 2;
1573 if (cell->face [2]) flags |= 4; 2172 if (cell->tile [2]) flags |= 4;
1574 2173
1575 *data++ = flags; 2174 *data++ = flags;
1576 2175
1577 if (flags & 1) 2176 if (flags & 1)
1578 { 2177 {
2178 tileid tile = cell->tile [0];
1579 *data++ = cell->face [0] >> 8; 2179 *data++ = tile >> 8;
1580 *data++ = cell->face [0]; 2180 *data++ = tile;
1581 } 2181 }
1582 2182
1583 if (flags & 2) 2183 if (flags & 2)
1584 { 2184 {
2185 tileid tile = cell->tile [1];
1585 *data++ = cell->face [1] >> 8; 2186 *data++ = tile >> 8;
1586 *data++ = cell->face [1]; 2187 *data++ = tile;
1587 } 2188 }
1588 2189
1589 if (flags & 4) 2190 if (flags & 4)
1590 { 2191 {
2192 tileid tile = cell->tile [2];
1591 *data++ = cell->face [2] >> 8; 2193 *data++ = tile >> 8;
1592 *data++ = cell->face [2]; 2194 *data++ = tile;
1593 } 2195 }
1594 } 2196 }
1595 else 2197 else
1596 *data++ = 0; 2198 *data++ = 0;
1597 } 2199 }
1603} 2205}
1604 OUTPUT: 2206 OUTPUT:
1605 RETVAL 2207 RETVAL
1606 2208
1607void 2209void
1608set_rect (CFClient::Map self, int x0, int y0, uint8_t *data) 2210set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data)
1609 PPCODE: 2211 PPCODE:
1610{ 2212{
1611 int x, y, z; 2213 int x, y, z;
1612 int w, h; 2214 int w, h;
1613 int x1, y1; 2215 int x1, y1;
1637 { 2239 {
1638 uint8_t flags = *data++; 2240 uint8_t flags = *data++;
1639 2241
1640 if (flags) 2242 if (flags)
1641 { 2243 {
1642 mapface face[3] = { 0, 0, 0 };
1643
1644 mapcell *cell = row_get_cell (row, x); 2244 mapcell *cell = row_get_cell (row, x);
2245 tileid tile[3] = { 0, 0, 0 };
1645 2246
1646 if (flags & 1) { face[0] = *data++ << 8; face[0] |= *data++; } 2247 if (flags & 1) { tile[0] = *data++ << 8; tile[0] |= *data++; }
1647 if (flags & 2) { face[1] = *data++ << 8; face[1] |= *data++; } 2248 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
1648 if (flags & 4) { face[2] = *data++ << 8; face[2] |= *data++; } 2249 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
1649 2250
1650 if (cell->darkness <= 0) 2251 if (cell->darkness == 0)
1651 { 2252 {
1652 cell->darkness = -1; 2253 cell->darkness = 0;
1653 2254
1654 for (z = 0; z <= 2; z++) 2255 for (z = 0; z <= 2; z++)
1655 { 2256 {
1656 cell->face[z] = face[z]; 2257 tileid t = tile [z];
1657 2258
1658 if (face[z] && (face[z] >= self->texs || !self->tex[face [z]].name)) 2259 if (t >= self->texs || (t && !self->tex [t].name))
2260 {
1659 XPUSHs (sv_2mortal (newSViv (face[z]))); 2261 XPUSHs (sv_2mortal (newSViv (t)));
2262 need_texid (self, t);
2263 }
2264
2265 cell->tile [z] = t;
1660 } 2266 }
1661 } 2267 }
1662 } 2268 }
1663 } 2269 }
1664 } 2270 }
1665} 2271}
1666 2272
1667MODULE = CFClient PACKAGE = CFClient::MixChunk 2273MODULE = CFPlus PACKAGE = CFPlus::RW
1668 2274
1669CFClient::MixChunk 2275CFPlus::RW
1670new_from_file (SV *class, char *path) 2276new (SV *class, SV *data_sv)
1671 CODE: 2277 CODE:
1672 RETVAL = Mix_LoadWAV (path); 2278{
2279 STRLEN datalen;
2280 char *data = SvPVbyte (data_sv, datalen);
2281
2282 RETVAL = SDL_RWFromConstMem (data, datalen);
2283}
1673 OUTPUT: 2284 OUTPUT:
1674 RETVAL 2285 RETVAL
1675 2286
2287CFPlus::RW
2288new_from_file (SV *class, const char *path, const char *mode = "rb")
2289 CODE:
2290 RETVAL = SDL_RWFromFile (path, mode);
2291 OUTPUT:
2292 RETVAL
2293
2294# fails on win32:
2295# CFPlus.xs(2268) : error C2059: syntax error : '('
1676void 2296#void
2297#close (CFPlus::RW self)
2298# CODE:
2299# (self->(close)) (self);
2300
2301MODULE = CFPlus PACKAGE = CFPlus::Channel
2302
2303PROTOTYPES: DISABLE
2304
2305CFPlus::Channel
2306find ()
2307 CODE:
2308{
2309 RETVAL = Mix_GroupAvailable (-1);
2310
2311 if (RETVAL < 0)
2312 {
2313 RETVAL = Mix_GroupOldest (-1);
2314
2315 if (RETVAL < 0)
2316 XSRETURN_UNDEF;
2317
2318 Mix_HaltChannel (RETVAL);
2319 }
2320
2321 Mix_UnregisterAllEffects (RETVAL);
2322 Mix_Volume (RETVAL, 128);
2323}
2324 OUTPUT:
2325 RETVAL
2326
2327void
2328halt (CFPlus::Channel self)
2329 CODE:
2330 Mix_HaltChannel (self);
2331
2332void
2333expire (CFPlus::Channel self, int ticks = -1)
2334 CODE:
2335 Mix_ExpireChannel (self, ticks);
2336
2337void
2338fade_out (CFPlus::Channel self, int ticks = -1)
2339 CODE:
2340 Mix_FadeOutChannel (self, ticks);
2341
2342int
2343volume (CFPlus::Channel self, int volume)
2344 CODE:
2345 RETVAL = Mix_Volume (self, CLAMP (volume, 0, 128));
2346 OUTPUT:
2347 RETVAL
2348
2349void
2350unregister_all_effects (CFPlus::Channel self)
2351 CODE:
2352 Mix_UnregisterAllEffects (self);
2353
2354void
2355set_panning (CFPlus::Channel self, int left, int right)
2356 CODE:
2357 left = CLAMP (left , 0, 255);
2358 right = CLAMP (right, 0, 255);
2359 Mix_SetPanning (self, left, right);
2360
2361void
2362set_distance (CFPlus::Channel self, int distance)
2363 CODE:
2364 Mix_SetDistance (self, CLAMP (distance, 0, 255));
2365
2366void
2367set_position (CFPlus::Channel self, int angle, int distance)
2368 CODE:
2369
2370void
2371set_position_r (CFPlus::Channel self, int dx, int dy, int maxdistance)
2372 CODE:
2373{
2374 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2375 int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI);
2376 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2377}
2378
2379void
2380set_reverse_stereo (CFPlus::Channel self, int flip)
2381 CODE:
2382 Mix_SetReverseStereo (self, flip);
2383
2384MODULE = CFPlus PACKAGE = CFPlus::MixChunk
2385
2386PROTOTYPES: DISABLE
2387
2388CFPlus::MixChunk
2389new (SV *class, CFPlus::RW rwops)
2390 CODE:
2391 RETVAL = Mix_LoadWAV_RW (rwops, 1);
2392 OUTPUT:
2393 RETVAL
2394
2395void
1677DESTROY (CFClient::MixChunk self) 2396DESTROY (CFPlus::MixChunk self)
1678 CODE: 2397 CODE:
1679 Mix_FreeChunk (self); 2398 Mix_FreeChunk (self);
1680 2399
1681int 2400int
1682volume (CFClient::MixChunk self, int volume = -1) 2401volume (CFPlus::MixChunk self, int volume = -1)
1683 CODE: 2402 CODE:
2403 if (items > 1)
2404 volume = CLAMP (volume, 0, 128);
1684 RETVAL = Mix_VolumeChunk (self, volume); 2405 RETVAL = Mix_VolumeChunk (self, volume);
1685 OUTPUT: 2406 OUTPUT:
1686 RETVAL 2407 RETVAL
1687 2408
1688int 2409CFPlus::Channel
1689play (CFClient::MixChunk self, int channel = -1, int loops = 0, int ticks = -1) 2410play (CFPlus::MixChunk self, CFPlus::Channel channel = -1, int loops = 0, int ticks = -1)
1690 CODE: 2411 CODE:
2412{
1691 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks); 2413 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
2414
2415 if (RETVAL < 0)
2416 XSRETURN_UNDEF;
2417
2418 if (channel < 0)
2419 {
2420 Mix_UnregisterAllEffects (RETVAL);
2421 Mix_Volume (RETVAL, 128);
2422 }
2423}
1692 OUTPUT: 2424 OUTPUT:
1693 RETVAL 2425 RETVAL
1694 2426
1695MODULE = CFClient PACKAGE = CFClient::MixMusic 2427MODULE = CFPlus PACKAGE = CFPlus::MixMusic
1696 2428
1697int 2429int
1698volume (int volume = -1) 2430volume (int volume = -1)
2431 PROTOTYPE: ;$
1699 CODE: 2432 CODE:
2433 if (items > 0)
2434 volume = CLAMP (volume, 0, 128);
1700 RETVAL = Mix_VolumeMusic (volume); 2435 RETVAL = Mix_VolumeMusic (volume);
1701 OUTPUT: 2436 OUTPUT:
1702 RETVAL 2437 RETVAL
1703 2438
2439void
2440fade_out (int ms)
2441 CODE:
2442 Mix_FadeOutMusic (ms);
2443
2444void
2445halt ()
2446 CODE:
2447 Mix_HaltMusic ();
2448
1704CFClient::MixMusic 2449CFPlus::MixMusic
1705new_from_file (SV *class, char *path) 2450new (SV *class, CFPlus::RW rwops)
1706 CODE: 2451 CODE:
1707 RETVAL = Mix_LoadMUS (path); 2452 RETVAL = Mix_LoadMUS_RW (rwops);
1708 OUTPUT: 2453 OUTPUT:
1709 RETVAL 2454 RETVAL
1710 2455
1711void 2456void
1712DESTROY (CFClient::MixMusic self) 2457DESTROY (CFPlus::MixMusic self)
1713 CODE: 2458 CODE:
1714 Mix_FreeMusic (self); 2459 Mix_FreeMusic (self);
1715 2460
1716int 2461int
1717play (CFClient::MixMusic self, int loops = -1) 2462play (CFPlus::MixMusic self, int loops = -1)
1718 CODE: 2463 CODE:
1719 RETVAL = Mix_PlayMusic (self, loops); 2464 RETVAL = Mix_PlayMusic (self, loops);
1720 OUTPUT: 2465 OUTPUT:
1721 RETVAL 2466 RETVAL
1722 2467
2468void
2469fade_in_pos (CFPlus::MixMusic self, int loops, int ms, double position)
2470 CODE:
2471 Mix_FadeInMusicPos (self, loops, ms, position);
2472
1723MODULE = CFClient PACKAGE = CFClient::OpenGL 2473MODULE = CFPlus PACKAGE = CFPlus::OpenGL
2474
2475PROTOTYPES: ENABLE
1724 2476
1725BOOT: 2477BOOT:
1726{ 2478{
1727 HV *stash = gv_stashpv ("CFClient::OpenGL", 1); 2479 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1);
1728 static const struct { 2480 static const struct {
1729 const char *name; 2481 const char *name;
1730 IV iv; 2482 IV iv;
1731 } *civ, const_iv[] = { 2483 } *civ, const_iv[] = {
1732# define const_iv(name) { # name, (IV)name } 2484# define const_iv(name) { # name, (IV)name }
2485 const_iv (GL_VENDOR),
2486 const_iv (GL_VERSION),
2487 const_iv (GL_EXTENSIONS),
1733 const_iv (GL_COLOR_MATERIAL), 2488 const_iv (GL_COLOR_MATERIAL),
1734 const_iv (GL_SMOOTH), 2489 const_iv (GL_SMOOTH),
1735 const_iv (GL_FLAT), 2490 const_iv (GL_FLAT),
1736 const_iv (GL_DITHER), 2491 const_iv (GL_DITHER),
1737 const_iv (GL_BLEND), 2492 const_iv (GL_BLEND),
1741 const_iv (GL_ALPHA_TEST), 2496 const_iv (GL_ALPHA_TEST),
1742 const_iv (GL_NORMALIZE), 2497 const_iv (GL_NORMALIZE),
1743 const_iv (GL_RESCALE_NORMAL), 2498 const_iv (GL_RESCALE_NORMAL),
1744 const_iv (GL_FRONT), 2499 const_iv (GL_FRONT),
1745 const_iv (GL_BACK), 2500 const_iv (GL_BACK),
2501 const_iv (GL_AUX0),
1746 const_iv (GL_AND), 2502 const_iv (GL_AND),
1747 const_iv (GL_ONE), 2503 const_iv (GL_ONE),
1748 const_iv (GL_ZERO), 2504 const_iv (GL_ZERO),
1749 const_iv (GL_SRC_ALPHA), 2505 const_iv (GL_SRC_ALPHA),
1750 const_iv (GL_DST_ALPHA), 2506 const_iv (GL_DST_ALPHA),
1764 const_iv (GL_LUMINANCE), 2520 const_iv (GL_LUMINANCE),
1765 const_iv (GL_LUMINANCE_ALPHA), 2521 const_iv (GL_LUMINANCE_ALPHA),
1766 const_iv (GL_FLOAT), 2522 const_iv (GL_FLOAT),
1767 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV), 2523 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),
1768 const_iv (GL_COMPILE), 2524 const_iv (GL_COMPILE),
2525 const_iv (GL_PROXY_TEXTURE_1D),
2526 const_iv (GL_PROXY_TEXTURE_2D),
1769 const_iv (GL_TEXTURE_1D), 2527 const_iv (GL_TEXTURE_1D),
1770 const_iv (GL_TEXTURE_2D), 2528 const_iv (GL_TEXTURE_2D),
1771 const_iv (GL_TEXTURE_ENV), 2529 const_iv (GL_TEXTURE_ENV),
1772 const_iv (GL_TEXTURE_MAG_FILTER), 2530 const_iv (GL_TEXTURE_MAG_FILTER),
1773 const_iv (GL_TEXTURE_MIN_FILTER), 2531 const_iv (GL_TEXTURE_MIN_FILTER),
1794 const_iv (GL_COLOR_LOGIC_OP), 2552 const_iv (GL_COLOR_LOGIC_OP),
1795 const_iv (GL_SEPARABLE_2D), 2553 const_iv (GL_SEPARABLE_2D),
1796 const_iv (GL_CONVOLUTION_2D), 2554 const_iv (GL_CONVOLUTION_2D),
1797 const_iv (GL_CONVOLUTION_BORDER_MODE), 2555 const_iv (GL_CONVOLUTION_BORDER_MODE),
1798 const_iv (GL_CONSTANT_BORDER), 2556 const_iv (GL_CONSTANT_BORDER),
2557 const_iv (GL_POINTS),
1799 const_iv (GL_LINES), 2558 const_iv (GL_LINES),
2559 const_iv (GL_LINE_STRIP),
1800 const_iv (GL_LINE_LOOP), 2560 const_iv (GL_LINE_LOOP),
1801 const_iv (GL_QUADS), 2561 const_iv (GL_QUADS),
1802 const_iv (GL_QUAD_STRIP), 2562 const_iv (GL_QUAD_STRIP),
1803 const_iv (GL_TRIANGLES), 2563 const_iv (GL_TRIANGLES),
1804 const_iv (GL_TRIANGLE_STRIP), 2564 const_iv (GL_TRIANGLE_STRIP),
1805 const_iv (GL_TRIANGLE_FAN), 2565 const_iv (GL_TRIANGLE_FAN),
2566 const_iv (GL_POLYGON),
1806 const_iv (GL_PERSPECTIVE_CORRECTION_HINT), 2567 const_iv (GL_PERSPECTIVE_CORRECTION_HINT),
2568 const_iv (GL_POINT_SMOOTH_HINT),
2569 const_iv (GL_LINE_SMOOTH_HINT),
2570 const_iv (GL_POLYGON_SMOOTH_HINT),
2571 const_iv (GL_GENERATE_MIPMAP_HINT),
1807 const_iv (GL_FASTEST), 2572 const_iv (GL_FASTEST),
2573 const_iv (GL_DONT_CARE),
2574 const_iv (GL_NICEST),
1808 const_iv (GL_V2F), 2575 const_iv (GL_V2F),
1809 const_iv (GL_V3F), 2576 const_iv (GL_V3F),
1810 const_iv (GL_T2F_V3F), 2577 const_iv (GL_T2F_V3F),
1811 const_iv (GL_T2F_N3F_V3F), 2578 const_iv (GL_T2F_N3F_V3F),
1812# undef const_iv 2579# undef const_iv
1813 }; 2580 };
1814 2581
1815 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 2582 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1816 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 2583 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
2584
2585 texture_av = newAV ();
2586 AvREAL_off (texture_av);
1817} 2587}
1818 2588
1819char * 2589char *
1820gl_vendor () 2590gl_vendor ()
1821 CODE: 2591 CODE:
1835 CODE: 2605 CODE:
1836 RETVAL = (char *)glGetString (GL_EXTENSIONS); 2606 RETVAL = (char *)glGetString (GL_EXTENSIONS);
1837 OUTPUT: 2607 OUTPUT:
1838 RETVAL 2608 RETVAL
1839 2609
2610const char *glGetString (GLenum pname)
2611
2612GLint glGetInteger (GLenum pname)
2613 CODE:
2614 glGetIntegerv (pname, &RETVAL);
2615 OUTPUT:
2616 RETVAL
2617
2618GLdouble glGetDouble (GLenum pname)
2619 CODE:
2620 glGetDoublev (pname, &RETVAL);
2621 OUTPUT:
2622 RETVAL
2623
1840int glGetError () 2624int glGetError ()
1841 2625
1842void glFinish () 2626void glFinish ()
1843 2627
1844void glClear (int mask) 2628void glClear (int mask)
1881# near_ and far_ are due to microsofts buggy "c" compiler 2665# near_ and far_ are due to microsofts buggy "c" compiler
1882void glFrustum (double left, double right, double bottom, double top, double near_, double far_) 2666void glFrustum (double left, double right, double bottom, double top, double near_, double far_)
1883 2667
1884# near_ and far_ are due to microsofts buggy "c" compiler 2668# near_ and far_ are due to microsofts buggy "c" compiler
1885void glOrtho (double left, double right, double bottom, double top, double near_, double far_) 2669void glOrtho (double left, double right, double bottom, double top, double near_, double far_)
2670
2671PROTOTYPES: DISABLE
1886 2672
1887void glViewport (int x, int y, int width, int height) 2673void glViewport (int x, int y, int width, int height)
1888 2674
1889void glScissor (int x, int y, int width, int height) 2675void glScissor (int x, int y, int width, int height)
1890 2676
1898 2684
1899void glRotate (float angle, float x, float y, float z) 2685void glRotate (float angle, float x, float y, float z)
1900 CODE: 2686 CODE:
1901 glRotatef (angle, x, y, z); 2687 glRotatef (angle, x, y, z);
1902 2688
1903void glBegin (int mode)
1904
1905void glEnd ()
1906
1907void glColor (float r, float g, float b, float a = 1.0) 2689void glColor (float r, float g, float b, float a = 1.0)
1908 PROTOTYPE: @
1909 ALIAS: 2690 ALIAS:
1910 glColor_premultiply = 1 2691 glColor_premultiply = 1
1911 CODE: 2692 CODE:
1912 if (ix) 2693 if (ix)
1913 { 2694 {
1916 b *= a; 2697 b *= a;
1917 } 2698 }
1918 // microsoft visual "c" rounds instead of truncating... 2699 // microsoft visual "c" rounds instead of truncating...
1919 glColor4f (r, g, b, a); 2700 glColor4f (r, g, b, a);
1920 2701
1921void glInterleavedArrays (int format, int stride, char *data)
1922
1923void glDrawElements (int mode, int count, int type, char *indices)
1924
1925# 1.2 void glDrawRangeElements (int mode, int start, int end
1926
1927void glRasterPos (float x, float y, float z = 0.) 2702void glRasterPos (float x, float y, float z = 0.)
1928 CODE: 2703 CODE:
1929 glRasterPos3f (0, 0, z); 2704 glRasterPos3f (0, 0, z);
1930 glBitmap (0, 0, 0, 0, x, y, 0); 2705 glBitmap (0, 0, 0, 0, x, y, 0);
1931 2706
1935 2710
1936void glTexCoord (float s, float t) 2711void glTexCoord (float s, float t)
1937 CODE: 2712 CODE:
1938 glTexCoord2f (s, t); 2713 glTexCoord2f (s, t);
1939 2714
2715void glRect (float x1, float y1, float x2, float y2)
2716 CODE:
2717 glRectf (x1, y1, x2, y2);
2718
2719PROTOTYPES: ENABLE
2720
2721void glBegin (int mode)
2722
2723void glEnd ()
2724
2725void glPointSize (GLfloat size)
2726
2727void glLineWidth (GLfloat width)
2728
2729void glInterleavedArrays (int format, int stride, char *data)
2730
2731void glDrawElements (int mode, int count, int type, char *indices)
2732
2733# 1.2 void glDrawRangeElements (int mode, int start, int end
2734
1940void glTexEnv (int target, int pname, float param) 2735void glTexEnv (int target, int pname, float param)
1941 CODE: 2736 CODE:
1942 glTexEnvf (target, pname, param); 2737 glTexEnvf (target, pname, param);
1943 2738
1944void glTexParameter (int target, int pname, float param) 2739void glTexParameter (int target, int pname, float param)
1966 2761
1967void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border) 2762void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
1968 2763
1969void glDrawPixels (int width, int height, int format, int type, char *pixels) 2764void glDrawPixels (int width, int height, int format, int type, char *pixels)
1970 2765
2766void glPixelZoom (float x, float y)
2767
1971void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR) 2768void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
1972 2769
1973int glGenTexture () 2770int glGenTexture ()
1974 CODE: 2771 CODE:
1975{ 2772 RETVAL = gen_texture ();
1976 GLuint name;
1977 glGenTextures (1, &name);
1978 RETVAL = name;
1979}
1980 OUTPUT: 2773 OUTPUT:
1981 RETVAL 2774 RETVAL
1982 2775
1983void glDeleteTexture (int name) 2776void glDeleteTexture (int name)
1984 CODE: 2777 CODE:
1985{
1986 GLuint name_ = name;
1987 glDeleteTextures (1, &name_); 2778 del_texture (name);
1988} 2779
1989
1990int glGenList () 2780int glGenList ()
1991 CODE: 2781 CODE:
1992 RETVAL = glGenLists (1); 2782 RETVAL = glGenLists (1);
1993 OUTPUT: 2783 OUTPUT:
1994 RETVAL 2784 RETVAL
2001 2791
2002void glEndList () 2792void glEndList ()
2003 2793
2004void glCallList (int list) 2794void glCallList (int list)
2005 2795
2796MODULE = CFPlus PACKAGE = CFPlus::UI::Base
2006 2797
2798PROTOTYPES: DISABLE
2799
2800void
2801find_widget (SV *self, NV x, NV y)
2802 PPCODE:
2803{
2804 if (within_widget (self, x, y))
2805 XPUSHs (self);
2806}
2807
2808BOOT:
2809{
2810 hover_gv = gv_fetchpv ("CFPlus::UI::HOVER", 1, SVt_NV);
2811
2812 draw_x_gv = gv_fetchpv ("CFPlus::UI::Base::draw_x", 1, SVt_NV);
2813 draw_y_gv = gv_fetchpv ("CFPlus::UI::Base::draw_y", 1, SVt_NV);
2814 draw_w_gv = gv_fetchpv ("CFPlus::UI::Base::draw_w", 1, SVt_NV);
2815 draw_h_gv = gv_fetchpv ("CFPlus::UI::Base::draw_h", 1, SVt_NV);
2816}
2817
2818void
2819draw (SV *self)
2820 CODE:
2821{
2822 HV *hv;
2823 SV **svp;
2824 NV x, y, w, h;
2825 SV *draw_x_sv = GvSV (draw_x_gv);
2826 SV *draw_y_sv = GvSV (draw_y_gv);
2827 SV *draw_w_sv = GvSV (draw_w_gv);
2828 SV *draw_h_sv = GvSV (draw_h_gv);
2829 SV *hover;
2830 double draw_x, draw_y, draw_w, draw_h;
2831
2832 if (!SvROK (self))
2833 croak ("CFPlus::Base::draw: %s not a reference", SvPV_nolen (self));
2834
2835 hv = (HV *)SvRV (self);
2836
2837 if (SvTYPE (hv) != SVt_PVHV)
2838 croak ("CFPlus::Base::draw: %s not a hashref", SvPV_nolen (self));
2839
2840 svp = hv_fetch (hv, "w", 1, 0); w = svp ? SvNV (*svp) : 0.;
2841 svp = hv_fetch (hv, "h", 1, 0); h = svp ? SvNV (*svp) : 0.;
2842
2843 if (!h || !w)
2844 XSRETURN_EMPTY;
2845
2846 svp = hv_fetch (hv, "x", 1, 0); x = svp ? SvNV (*svp) : 0.;
2847 svp = hv_fetch (hv, "y", 1, 0); y = svp ? SvNV (*svp) : 0.;
2848
2849 draw_x = SvNV (draw_x_sv) + x;
2850 draw_y = SvNV (draw_y_sv) + y;
2851
2852 if (draw_x + w < 0 || draw_x >= SvNV (draw_w_sv)
2853 || draw_y + h < 0 || draw_y >= SvNV (draw_h_sv))
2854 XSRETURN_EMPTY;
2855
2856 sv_setnv (draw_x_sv, draw_x);
2857 sv_setnv (draw_y_sv, draw_y);
2858
2859 glPushMatrix ();
2860 glTranslated (x, y, 0);
2861
2862 if (SvROK (GvSV (hover_gv)) && SvRV (GvSV (hover_gv)) == (SV *)hv)
2863 {
2864 svp = hv_fetch (hv, "can_hover", sizeof ("can_hover") - 1, 0);
2865
2866 if (svp && SvTRUE (*svp))
2867 {
2868 glColor4f (1*0.2f, 0.8*0.2f, 0.5*0.2f, 0.2f);
2869 glEnable (GL_BLEND);
2870 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2871 glBegin (GL_QUADS);
2872 glVertex2f (0, 0);
2873 glVertex2f (w, 0);
2874 glVertex2f (w, h);
2875 glVertex2f (0, h);
2876 glEnd ();
2877 glDisable (GL_BLEND);
2878 }
2879 }
2880#if 0
2881 if ($ENV{CFPLUS_DEBUG} & 1) {
2882 glPushMatrix;
2883 glColor 1, 1, 0, 1;
2884 glTranslate 0.375, 0.375;
2885 glBegin GL_LINE_LOOP;
2886 glVertex 0 , 0;
2887 glVertex $self->{w} - 1, 0;
2888 glVertex $self->{w} - 1, $self->{h} - 1;
2889 glVertex 0 , $self->{h} - 1;
2890 glEnd;
2891 glPopMatrix;
2892 #CFPlus::UI::Label->new (w => $self->{w}, h => $self->{h}, text => $self, fontsize => 0)->_draw;
2893 }
2894#endif
2895 PUSHMARK (SP);
2896 XPUSHs (self);
2897 PUTBACK;
2898 call_method ("_draw", G_VOID | G_DISCARD);
2899 SPAGAIN;
2900
2901 glPopMatrix ();
2902
2903 draw_x = draw_x - x; sv_setnv (draw_x_sv, draw_x);
2904 draw_y = draw_y - y; sv_setnv (draw_y_sv, draw_y);
2905}
2906

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines