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.122 by root, Fri Jun 23 22:35:15 2006 UTC vs.
Revision 1.208 by root, Sat Jul 21 16:07:53 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#endif
23
24#include <assert.h>
12#include <math.h> 25#include <math.h>
13#include <string.h> 26#include <string.h>
14#include <stdio.h> 27#include <stdio.h>
15#include <stdlib.h> 28#include <stdlib.h>
16 29
17#include <SDL.h> 30#include <SDL.h>
31#include <SDL_thread.h>
18#include <SDL_endian.h> 32#include <SDL_endian.h>
19#include <SDL_image.h> 33#include <SDL_image.h>
20#include <SDL_mixer.h> 34#include <SDL_mixer.h>
21#include <SDL_opengl.h> 35#include <SDL_opengl.h>
22 36
37#define PANGO_ENABLE_BACKEND
38#define G_DISABLE_CAST_CHECKS
39
23#include <glib/gmacros.h> 40#include <glib/gmacros.h>
24 41
25#include <pango/pango.h> 42#include <pango/pango.h>
26#include <pango/pangofc-fontmap.h>
27#include <pango/pangoft2.h>
28#include <pango/pangocairo.h>
29 43
30#ifndef _WIN32 44#ifndef _WIN32
31# include <sys/types.h> 45# include <sys/types.h>
32# include <sys/socket.h> 46# include <sys/socket.h>
33# include <netinet/in.h> 47# include <netinet/in.h>
34# include <netinet/tcp.h> 48# include <netinet/tcp.h>
35# include <inttypes.h> 49# 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 50#endif
44 51
45#include "glext.h"
46
47#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, objetc replacement character */ 52#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
48 53
49#define FOW_DARKNESS 32 54#define FOW_DARKNESS 32
50 55
51#define MAP_EXTEND_X 32 56#define MAP_EXTEND_X 32
52#define MAP_EXTEND_Y 512 57#define MAP_EXTEND_Y 512
53 58
54#define MIN_FONT_HEIGHT 10 59#define MIN_FONT_HEIGHT 10
60
61#if 0
62# define PARACHUTE SDL_INIT_NOPARACHUTE
63#else
64# define PARACHUTE 0
65#endif
66
67static AV *texture_av;
55 68
56static struct 69static struct
57{ 70{
58#define GL_FUNC(ptr,name) ptr name; 71#define GL_FUNC(ptr,name) ptr name;
59#include "glfunc.h" 72#include "glfunc.h"
60#undef GL_FUNC 73#undef GL_FUNC
61} gl; 74} gl;
62 75
76static void
63static void gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa) 77gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa)
64{ 78{
65 if (gl.BlendFuncSeparate) 79 if (gl.BlendFuncSeparate)
66 gl.BlendFuncSeparate (sa, da, saa, daa); 80 gl.BlendFuncSeparate (sa, da, saa, daa);
67 else if (gl.BlendFuncSeparateEXT) 81 else if (gl.BlendFuncSeparateEXT)
68 gl.BlendFuncSeparateEXT (sa, da, saa, daa); 82 gl.BlendFuncSeparateEXT (sa, da, saa, daa);
69 else 83 else
70 glBlendFunc (sa, da); 84 glBlendFunc (sa, da);
71} 85}
72 86
87static GLuint
88gen_texture ()
89{
90 GLuint name;
91
92 if (AvFILL (texture_av) >= 0)
93 name = (GLuint)(size_t)av_pop (texture_av);
94 else
95 glGenTextures (1, &name);
96
97 return name;
98}
99
100static void
101del_texture (GLuint name)
102{
103 /* make a half-assed attempt at returning the memory used by the texture */
104 /* textures are frequently being reused by cfplus anyway */
105 /*glBindTexture (GL_TEXTURE_2D, name);*/
106 /*glTexImage2D (GL_TEXTURE_2D, 0, GL_ALPHA, 0, 0, 0, GL_ALPHA, GL_UNSIGNED_BYTE, 0);*/
107 av_push (texture_av, (SV *)(size_t)name);
108 glDeleteTextures (1, &name);
109}
110
111#include "texcache.c"
112
113#include "pango-font.c"
114#include "pango-fontmap.c"
115#include "pango-render.c"
116
73typedef Mix_Chunk *CFClient__MixChunk; 117typedef Mix_Chunk *CFPlus__MixChunk;
74typedef Mix_Music *CFClient__MixMusic; 118typedef Mix_Music *CFPlus__MixMusic;
75 119
76typedef PangoFontDescription *CFClient__Font; 120typedef PangoFontDescription *CFPlus__Font;
77 121
78static int 122static int
79shape_attr_p (PangoLayoutRun *run) 123shape_attr_p (PangoLayoutRun *run)
80{ 124{
81 GSList *attrs = run->item->analysis.extra_attrs; 125 GSList *attrs = run->item->analysis.extra_attrs;
… …
92 136
93 return 0; 137 return 0;
94} 138}
95 139
96typedef struct cf_layout { 140typedef struct cf_layout {
97 PangoLayout *pl; // either derived from a cairo or ft2 context 141 PangoLayout *pl;
98 int rgba; // wether we use rgba (cairo) or grayscale (ft2)
99 float r, g, b, a; // default color for rgba mode 142 float r, g, b, a; // default color for rgba mode
100 int base_height; 143 int base_height;
101 CFClient__Font font; 144 CFPlus__Font font;
102} *CFClient__Layout; 145} *CFPlus__Layout;
103 146
104static CFClient__Font default_font; 147static CFPlus__Font default_font;
105static PangoContext *ft2_context, *cairo_context; 148static PangoContext *opengl_context;
106static PangoFontMap *ft2_fontmap, *cairo_fontmap; 149static PangoFontMap *opengl_fontmap;
107 150
108static void 151static void
109substitute_func (FcPattern *pattern, gpointer data) 152substitute_func (FcPattern *pattern, gpointer data)
110{ 153{
111 FcPatternAddBool (pattern, FC_HINTING, 1); 154 FcPatternAddBool (pattern, FC_HINTING, 1);
112#ifdef FC_HINT_STYLE 155#ifdef FC_HINT_STYLE
113 FcPatternAddBool (pattern, FC_HINT_STYLE, FC_HINT_FULL); 156 FcPatternAddBool (pattern, FC_HINT_STYLE, FC_HINT_FULL);
114#endif 157#endif
115#ifdef _WIN32
116 FcPatternAddBool (pattern, FC_AUTOHINT, 1);
117#else
118 FcPatternAddBool (pattern, FC_AUTOHINT, 0); 158 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
119#endif
120} 159}
121 160
122static void 161static void
123layout_update_font (CFClient__Layout self) 162layout_update_font (CFPlus__Layout self)
124{ 163{
125 /* use a random scale factor to account for unknown descenders, 0.8 works 164 /* use a random scale factor to account for unknown descenders, 0.8 works
126 * reasonably well with bitstream vera 165 * reasonably well with bitstream vera
127 */ 166 */
128 PangoFontDescription *font = self->font ? self->font : default_font; 167 PangoFontDescription *font = self->font ? self->font : default_font;
… …
132 171
133 pango_layout_set_font_description (self->pl, font); 172 pango_layout_set_font_description (self->pl, font);
134} 173}
135 174
136static void 175static void
137layout_get_pixel_size (CFClient__Layout self, int *w, int *h) 176layout_get_pixel_size (CFPlus__Layout self, int *w, int *h)
138{ 177{
178 PangoRectangle rect;
179
180 // get_pixel_* wrongly rounds down
139 pango_layout_get_pixel_size (self->pl, w, h); 181 pango_layout_get_extents (self->pl, 0, &rect);
140 182
141 if (!*w) *w = 1; 183 rect.width = (rect.width + PANGO_SCALE - 1) / PANGO_SCALE;
142 if (!*h) *h = 1; 184 rect.height = (rect.height + PANGO_SCALE - 1) / PANGO_SCALE;
143 185
144 *w = (*w + 3) & ~3; 186 if (!rect.width) rect.width = 1;
145} 187 if (!rect.height) rect.height = 1;
146 188
189 *w = rect.width;
190 *h = rect.height;
191}
192
193typedef uint16_t tileid;
147typedef uint16_t mapface; 194typedef uint16_t faceid;
148 195
149typedef struct { 196typedef struct {
150 GLint name; 197 int name;
151 int w, h; 198 int w, h;
152 float s, t; 199 float s, t;
153 uint8_t r, g, b, a; 200 uint8_t r, g, b, a;
201 tileid smoothtile;
202 uint8_t smoothlevel;
154} maptex; 203} maptex;
155 204
156typedef struct { 205typedef struct {
206 uint32_t player;
207 tileid tile[3];
157 int16_t darkness; 208 uint16_t darkness;
158 mapface face[3]; 209 uint8_t stat_width, stat_hp, flags, smoothmax;
159} mapcell; 210} mapcell;
160 211
161typedef struct { 212typedef struct {
162 int32_t c0, c1; 213 int32_t c0, c1;
163 mapcell *col; 214 mapcell *col;
164} maprow; 215} maprow;
165 216
166typedef struct map { 217typedef struct map {
167 int x, y, w, h; 218 int x, y, w, h;
168 int ox, oy; /* offset to virtual global coordinate system */ 219 int ox, oy; /* offset to virtual global coordinate system */
169 int faces; 220 int faces; tileid *face2tile; // [faceid]
170 mapface *face; 221 int texs; maptex *tex; // [tileid]
171
172 int texs;
173 maptex *tex;
174 222
175 int32_t rows; 223 int32_t rows;
176 maprow *row; 224 maprow *row;
177} *CFClient__Map; 225} *CFPlus__Map;
178 226
179static char * 227static char *
180prepend (char *ptr, int sze, int inc) 228prepend (char *ptr, int sze, int inc)
181{ 229{
182 char *p; 230 char *p;
… …
199} 247}
200 248
201#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type)) 249#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
202#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type)) 250#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
203 251
252static void
253need_facenum (struct map *self, faceid face)
254{
255 while (self->faces <= face)
256 {
257 Append (tileid, self->face2tile, self->faces, self->faces);
258 self->faces *= 2;
259 }
260}
261
262static void
263need_texid (struct map *self, int texid)
264{
265 while (self->texs <= texid)
266 {
267 Append (maptex, self->tex, self->texs, self->texs);
268 self->texs *= 2;
269 }
270}
271
204static maprow * 272static maprow *
205map_get_row (CFClient__Map self, int y) 273map_get_row (CFPlus__Map self, int y)
206{ 274{
207 if (0 > y) 275 if (0 > y)
208 { 276 {
209 int extend = - y + MAP_EXTEND_Y; 277 int extend = - y + MAP_EXTEND_Y;
210 Prepend (maprow, self->row, self->rows, extend); 278 Prepend (maprow, self->row, self->rows, extend);
… …
248 316
249 return row->col + (x - row->c0); 317 return row->col + (x - row->c0);
250} 318}
251 319
252static mapcell * 320static mapcell *
253map_get_cell (CFClient__Map self, int x, int y) 321map_get_cell (CFPlus__Map self, int x, int y)
254{ 322{
255 return row_get_cell (map_get_row (self, y), x); 323 return row_get_cell (map_get_row (self, y), x);
256} 324}
257 325
258static void 326static void
259map_clear (CFClient__Map self) 327map_clear (CFPlus__Map self)
260{ 328{
261 int r; 329 int r;
262 330
263 for (r = 0; r < self->rows; r++) 331 for (r = 0; r < self->rows; r++)
264 Safefree (self->row[r].col); 332 Safefree (self->row[r].col);
… …
272 self->row = 0; 340 self->row = 0;
273 self->rows = 0; 341 self->rows = 0;
274} 342}
275 343
276static void 344static void
277map_blank (CFClient__Map self, int x0, int y0, int w, int h) 345map_blank (CFPlus__Map self, int x0, int y0, int w, int h)
278{ 346{
279 int x, y; 347 int x, y;
280 maprow *row; 348 maprow *row;
349 mapcell *cell;
281 350
282 for (y = y0; y < y0 + h; y++) 351 for (y = y0; y < y0 + h; y++)
283 if (y >= 0) 352 if (y >= 0)
284 { 353 {
285 if (y >= self->rows) 354 if (y >= self->rows)
… …
291 if (x >= row->c0) 360 if (x >= row->c0)
292 { 361 {
293 if (x >= row->c1) 362 if (x >= row->c1)
294 break; 363 break;
295 364
296 row->col[x - row->c0].darkness = -1; 365 cell = row->col + x - row->c0;
366
367 cell->darkness = 0;
368 cell->stat_hp = 0;
369 cell->flags = 0;
370 cell->player = 0;
297 } 371 }
298 } 372 }
373}
374
375typedef struct {
376 tileid tile;
377 uint8_t x, y, level;
378} smooth_key;
379
380static void
381smooth_or_bits (HV *hv, smooth_key *key, IV bits)
382{
383 SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1);
384
385 if (SvIOK (*sv))
386 SvIV_set (*sv, SvIVX (*sv) | bits);
387 else
388 sv_setiv (*sv, bits);
299} 389}
300 390
301static void 391static void
302music_finished (void) 392music_finished (void)
303{ 393{
… …
339 n |= n >> 16; 429 n |= n >> 16;
340 430
341 return n + 1; 431 return n + 1;
342} 432}
343 433
434/* SDL should provide this, really. */
435#define SDLK_MODIFIER_MIN 300
436#define SDLK_MODIFIER_MAX 314
437
438/******************************************************************************/
439
440static int
441within_widget (SV *widget, NV x, NV y)
442{
443 HV *self;
444 SV **svp;
445 NV wx, ww, wy, wh;
446
447 if (!SvROK (widget))
448 return 0;
449
450 self = (HV *)SvRV (widget);
451
452 if (SvTYPE (self) != SVt_PVHV)
453 return 0;
454
455 svp = hv_fetch (self, "y", 1, 0); wy = svp ? SvNV (*svp) : 0.;
456 if (y < wy)
457 return 0;
458
459 svp = hv_fetch (self, "h", 1, 0); wh = svp ? SvNV (*svp) : 0.;
460 if (y >= wy + wh)
461 return 0;
462
463 svp = hv_fetch (self, "x", 1, 0); wx = svp ? SvNV (*svp) : 0.;
464 if (x < wx)
465 return 0;
466
467 svp = hv_fetch (self, "w", 1, 0); ww = svp ? SvNV (*svp) : 0.;
468 if (x >= wx + ww)
469 return 0;
470
471 svp = hv_fetch (self, "can_events", sizeof ("can_events") - 1, 0);
472 if (!svp || !SvTRUE (*svp))
473 return 0;
474
475 return 1;
476}
477
344MODULE = CFClient PACKAGE = CFClient 478MODULE = CFPlus PACKAGE = CFPlus
345 479
346PROTOTYPES: ENABLE 480PROTOTYPES: ENABLE
347 481
348BOOT: 482BOOT:
349{ 483{
350 HV *stash = gv_stashpv ("CFClient", 1); 484 HV *stash = gv_stashpv ("CFPlus", 1);
351 static const struct { 485 static const struct {
352 const char *name; 486 const char *name;
353 IV iv; 487 IV iv;
354 } *civ, const_iv[] = { 488 } *civ, const_iv[] = {
355# define const_iv(name) { # name, (IV)name } 489# define const_iv(name) { # name, (IV)name }
490 const_iv (SDLK_MODIFIER_MIN),
491 const_iv (SDLK_MODIFIER_MAX),
492
356 const_iv (SDL_ACTIVEEVENT), 493 const_iv (SDL_ACTIVEEVENT),
357 const_iv (SDL_KEYDOWN), 494 const_iv (SDL_KEYDOWN),
358 const_iv (SDL_KEYUP), 495 const_iv (SDL_KEYUP),
359 const_iv (SDL_MOUSEMOTION), 496 const_iv (SDL_MOUSEMOTION),
360 const_iv (SDL_MOUSEBUTTONDOWN), 497 const_iv (SDL_MOUSEBUTTONDOWN),
… …
369 const_iv (SDL_EVENT_RESERVEDA), 506 const_iv (SDL_EVENT_RESERVEDA),
370 const_iv (SDL_EVENT_RESERVEDB), 507 const_iv (SDL_EVENT_RESERVEDB),
371 const_iv (SDL_VIDEORESIZE), 508 const_iv (SDL_VIDEORESIZE),
372 const_iv (SDL_VIDEOEXPOSE), 509 const_iv (SDL_VIDEOEXPOSE),
373 const_iv (SDL_USEREVENT), 510 const_iv (SDL_USEREVENT),
511
512 const_iv (SDL_APPINPUTFOCUS),
513 const_iv (SDL_APPMOUSEFOCUS),
514 const_iv (SDL_APPACTIVE),
515
374 const_iv (SDLK_KP0), 516 const_iv (SDLK_KP0),
375 const_iv (SDLK_KP1), 517 const_iv (SDLK_KP1),
376 const_iv (SDLK_KP2), 518 const_iv (SDLK_KP2),
377 const_iv (SDLK_KP3), 519 const_iv (SDLK_KP3),
378 const_iv (SDLK_KP4), 520 const_iv (SDLK_KP4),
… …
433 const_iv (SDLK_BREAK), 575 const_iv (SDLK_BREAK),
434 const_iv (SDLK_MENU), 576 const_iv (SDLK_MENU),
435 const_iv (SDLK_POWER), 577 const_iv (SDLK_POWER),
436 const_iv (SDLK_EURO), 578 const_iv (SDLK_EURO),
437 const_iv (SDLK_UNDO), 579 const_iv (SDLK_UNDO),
580
438 const_iv (KMOD_NONE), 581 const_iv (KMOD_NONE),
582 const_iv (KMOD_SHIFT),
439 const_iv (KMOD_LSHIFT), 583 const_iv (KMOD_LSHIFT),
440 const_iv (KMOD_RSHIFT), 584 const_iv (KMOD_RSHIFT),
585 const_iv (KMOD_CTRL),
441 const_iv (KMOD_LCTRL), 586 const_iv (KMOD_LCTRL),
442 const_iv (KMOD_RCTRL), 587 const_iv (KMOD_RCTRL),
588 const_iv (KMOD_ALT),
443 const_iv (KMOD_LALT), 589 const_iv (KMOD_LALT),
444 const_iv (KMOD_RALT), 590 const_iv (KMOD_RALT),
591 const_iv (KMOD_META),
445 const_iv (KMOD_LMETA), 592 const_iv (KMOD_LMETA),
446 const_iv (KMOD_RMETA), 593 const_iv (KMOD_RMETA),
447 const_iv (KMOD_NUM), 594 const_iv (KMOD_NUM),
448 const_iv (KMOD_CAPS), 595 const_iv (KMOD_CAPS),
449 const_iv (KMOD_MODE), 596 const_iv (KMOD_MODE),
450 const_iv (KMOD_CTRL),
451 const_iv (KMOD_SHIFT),
452 const_iv (KMOD_ALT),
453 const_iv (KMOD_META)
454# undef const_iv 597# undef const_iv
455 }; 598 };
456 599
457 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 600 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
458 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 601 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
602
603 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
604 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
459} 605}
606
607void
608weaken (SV *rv)
609 PROTOTYPE: $
610 CODE:
611 sv_rvweaken (rv);
612
613int
614in_destruct ()
615 CODE:
616 RETVAL = PL_main_cv == Nullcv;
617 OUTPUT:
618 RETVAL
460 619
461NV floor (NV x) 620NV floor (NV x)
462 621
463NV ceil (NV x) 622NV ceil (NV x)
464 623
465void 624void
466pango_init () 625pango_init ()
467 CODE: 626 CODE:
468 // delayed, so it can pick up new fonts added by AddFontResourceEx
469{ 627{
470 {
471 ft2_fontmap = pango_ft2_font_map_new (); 628 opengl_fontmap = pango_opengl_font_map_new ();
472 pango_ft2_font_map_set_default_substitute ((PangoFT2FontMap *)ft2_fontmap, substitute_func, 0, 0); 629 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
473 ft2_context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)ft2_fontmap); 630 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
474 }
475 {
476 cairo_font_options_t *fopt = cairo_font_options_create ();
477 cairo_fontmap = pango_cairo_font_map_get_default ();
478 cairo_context = pango_cairo_font_map_create_context ((PangoCairoFontMap *)cairo_fontmap);
479#ifdef _WIN32
480 // cairo looks like shit eaten twice on windows
481 cairo_font_options_set_antialias (fopt, CAIRO_ANTIALIAS_NONE);
482#else
483 cairo_font_options_set_antialias (fopt, CAIRO_ANTIALIAS_GRAY);
484#endif
485 cairo_font_options_set_hint_style (fopt, CAIRO_HINT_STYLE_FULL);
486 cairo_font_options_set_hint_metrics (fopt, CAIRO_HINT_METRICS_ON);
487 pango_cairo_context_set_font_options (cairo_context, fopt);
488 cairo_font_options_destroy (fopt);
489 }
490} 631}
632
633char *
634SDL_GetError ()
491 635
492int 636int
493SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO) 637SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)
494 638
495void 639void
496SDL_Quit () 640SDL_Quit ()
497 641
498void 642void
499SDL_ListModes () 643SDL_ListModes (int rgb, int alpha)
500 PPCODE: 644 PPCODE:
501{ 645{
502 SDL_Rect **m; 646 SDL_Rect **m;
503 647
504 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5); 648 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
505 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5); 649 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
506 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5); 650 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
507 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 1); 651 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
508 652
509 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15); 653 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15);
510 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 0); 654 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE , 0);
511 655
512 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE, 0); 656 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE , 0);
513 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0); 657 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
514 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE, 0); 658 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
515 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0); 659 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
516 660
517 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); 661 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
518 662#if SDL_VERSION_ATLEAST(1,2,10)
519 SDL_EnableUNICODE (1); 663 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
520 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL); 664 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
665#endif
521 666
522 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 667 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
523 668
524 if (m && m != (SDL_Rect **)-1) 669 if (m && m != (SDL_Rect **)-1)
525 while (*m) 670 while (*m)
526 { 671 {
672 if ((*m)->w >= 640 && (*m)->h >= 480)
673 {
527 AV *av = newAV (); 674 AV *av = newAV ();
528 av_push (av, newSViv ((*m)->w)); 675 av_push (av, newSViv ((*m)->w));
529 av_push (av, newSViv ((*m)->h)); 676 av_push (av, newSViv ((*m)->h));
677 av_push (av, newSViv (rgb));
678 av_push (av, newSViv (alpha));
530 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av))); 679 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
680 }
531 681
532 ++m; 682 ++m;
533 } 683 }
534} 684}
535 685
536char *
537SDL_GetError ()
538
539int 686int
540SDL_SetVideoMode (int w, int h, int fullscreen) 687SDL_SetVideoMode (int w, int h, int rgb, int alpha, int fullscreen)
541 CODE: 688 CODE:
689{
690 SDL_EnableUNICODE (1);
691 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
692
693 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
694 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
695 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
696 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
697
542 RETVAL = !!SDL_SetVideoMode ( 698 RETVAL = !!SDL_SetVideoMode (
543 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0) 699 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0)
544 ); 700 );
701
545 if (RETVAL) 702 if (RETVAL)
546 { 703 {
704 av_clear (texture_av);
705
547 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+"); 706 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+");
548# define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name); 707#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
549# include "glfunc.h" 708#include "glfunc.h"
550# undef GL_FUNC 709#undef GL_FUNC
551 } 710 }
711}
552 OUTPUT: 712 OUTPUT:
553 RETVAL 713 RETVAL
554 714
555void 715void
556SDL_GL_SwapBuffers () 716SDL_GL_SwapBuffers ()
557 717
558char * 718char *
559SDL_GetKeyName (int sym) 719SDL_GetKeyName (int sym)
560 720
721int
722SDL_GetAppState ()
723
561void 724void
562SDL_PollEvent () 725poll_events ()
563 PPCODE: 726 PPCODE:
564{ 727{
565 SDL_Event ev; 728 SDL_Event ev;
566 729
567 while (SDL_PollEvent (&ev)) 730 SDL_PumpEvents ();
731 while (SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_ALLEVENTS) > 0)
568 { 732 {
569 HV *hv = newHV (); 733 HV *hv = newHV ();
570 hv_store (hv, "type", 4, newSViv (ev.type), 0); 734 hv_store (hv, "type", 4, newSViv (ev.type), 0);
571 735
572 switch (ev.type) 736 switch (ev.type)
… …
574 case SDL_KEYDOWN: 738 case SDL_KEYDOWN:
575 case SDL_KEYUP: 739 case SDL_KEYUP:
576 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 740 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
577 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 741 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
578 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0); 742 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0);
743 hv_store (hv, "cmod", 4, newSViv (SDL_GetModState ()), 0); /* current mode */
579 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 744 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
580 break; 745 break;
581 746
582 case SDL_ACTIVEEVENT: 747 case SDL_ACTIVEEVENT:
583 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 748 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
584 hv_store (hv, "state", 5, newSViv (ev.active.state), 0); 749 hv_store (hv, "state", 5, newSViv (ev.active.state), 0);
585 break; 750 break;
586 751
587 case SDL_MOUSEMOTION: 752 case SDL_MOUSEMOTION:
753 {
754 int state = ev.motion.state;
755 int x = ev.motion.x;
756 int y = ev.motion.y;
757 int xrel = ev.motion.xrel;
758 int yrel = ev.motion.yrel;
759
760 /* do simplistic event compression */
761 while (SDL_PeepEvents (&ev, 1, SDL_PEEKEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)) > 0
762 && state == ev.motion.state)
763 {
764 xrel += ev.motion.xrel;
765 yrel += ev.motion.yrel;
766 x = ev.motion.x;
767 y = ev.motion.y;
768 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
769 }
770
588 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 771 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);
589
590 hv_store (hv, "state", 5, newSViv (ev.motion.state), 0); 772 hv_store (hv, "state", 5, newSViv (state), 0);
591 hv_store (hv, "x", 1, newSViv (ev.motion.x), 0); 773 hv_store (hv, "x", 1, newSViv (x), 0);
592 hv_store (hv, "y", 1, newSViv (ev.motion.y), 0); 774 hv_store (hv, "y", 1, newSViv (y), 0);
593 hv_store (hv, "xrel", 4, newSViv (ev.motion.xrel), 0); 775 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
594 hv_store (hv, "yrel", 4, newSViv (ev.motion.yrel), 0); 776 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
777 }
595 break; 778 break;
596 779
597 case SDL_MOUSEBUTTONDOWN: 780 case SDL_MOUSEBUTTONDOWN:
598 case SDL_MOUSEBUTTONUP: 781 case SDL_MOUSEBUTTONUP:
599 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 782 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);
… …
609 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0); 792 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0);
610 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0); 793 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0);
611 break; 794 break;
612 } 795 }
613 796
614 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv))); 797 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("CFPlus::UI::Event", 1))));
615 } 798 }
616} 799}
617 800
618int 801int
619Mix_OpenAudio (int frequency = 48000, int format = MIX_DEFAULT_FORMAT, int channels = 1, int chunksize = 2048) 802Mix_OpenAudio (int frequency = 48000, int format = MIX_DEFAULT_FORMAT, int channels = 1, int chunksize = 2048)
… …
628Mix_AllocateChannels (int numchans = -1) 811Mix_AllocateChannels (int numchans = -1)
629 812
630void 813void
631lowdelay (int fd, int val = 1) 814lowdelay (int fd, int val = 1)
632 CODE: 815 CODE:
816 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val));
817
818void
819win32_proxy_info ()
820 PPCODE:
821{
633#ifndef _WIN32 822#ifdef _WIN32
634 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val)); 823 char buffer[2048];
824 DWORD buflen;
825
826 EXTEND (SP, 3);
827
828 buflen = sizeof (buffer);
829 if (InternetQueryOption (0, INTERNET_OPTION_PROXY, (void *)buffer, &buflen))
830 if (((INTERNET_PROXY_INFO *)buffer)->dwAccessType == INTERNET_OPEN_TYPE_PROXY)
831 {
832 PUSHs (newSVpv (((INTERNET_PROXY_INFO *)buffer)->lpszProxy, 0));
833
834 buflen = sizeof (buffer);
835 if (InternetQueryOption (0, INTERNET_OPTION_PROXY_USERNAME, (void *)buffer, &buflen))
836 {
837 PUSHs (newSVpv (buffer, 0));
838
839 buflen = sizeof (buffer);
840 if (InternetQueryOption (0, INTERNET_OPTION_PROXY_PASSWORD, (void *)buffer, &buflen))
841 PUSHs (newSVpv (buffer, 0));
842 }
843 }
635#endif 844#endif
845}
636 846
637void 847void
638add_font (char *file) 848add_font (char *file)
639 CODE: 849 CODE:
640 FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */ 850 FcConfigAppFontAddFile (0, (const FcChar8 *)file);
641#ifdef _WIN32
642 // cairo... sigh... requires win2000
643 AddFontResourceEx (file, FR_PRIVATE, 0);
644#endif
645 851
646void 852void
647load_image_inline (SV *image_) 853load_image_inline (SV *image_)
648 ALIAS: 854 ALIAS:
649 load_image_file = 1 855 load_image_file = 1
… …
691 897
692 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE); 898 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE);
693 899
694 assert (surface2->pitch == surface2->w * 4); 900 assert (surface2->pitch == surface2->w * 4);
695 901
902 SDL_LockSurface (surface2);
696 EXTEND (SP, 5); 903 EXTEND (SP, 6);
697 PUSHs (sv_2mortal (newSViv (surface2->w))); 904 PUSHs (sv_2mortal (newSViv (surface2->w)));
698 PUSHs (sv_2mortal (newSViv (surface2->h))); 905 PUSHs (sv_2mortal (newSViv (surface2->h)));
699 SDL_LockSurface (surface2);
700 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 906 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));
701 SDL_UnlockSurface (surface2);
702 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB))); 907 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));
703 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 908 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
704 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE))); 909 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
910 SDL_UnlockSurface (surface2);
705 911
706 SDL_FreeSurface (surface); 912 SDL_FreeSurface (surface);
707 SDL_FreeSurface (surface2); 913 SDL_FreeSurface (surface2);
708} 914}
709 915
… …
748 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR); 954 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR);
749#endif 955#endif
750 _exit (1); 956 _exit (1);
751 957
752void 958void
753_exit (int retval) 959_exit (int retval = 0)
754 CODE: 960 CODE:
961#ifdef WIN32
962 ExitThread (retval); // unclean, please beam me up
963#else
755 _exit (retval); 964 _exit (retval);
965#endif
756 966
967void
968debug ()
969 CODE:
970{
971#if DEBUG
972 VALGRIND_DO_LEAK_CHECK;
973#endif
974}
975
757MODULE = CFClient PACKAGE = CFClient::Font 976MODULE = CFPlus PACKAGE = CFPlus::Font
758 977
759CFClient::Font 978PROTOTYPES: DISABLE
979
980CFPlus::Font
760new_from_file (SV *class, char *path, int id = 0) 981new_from_file (SV *class, char *path, int id = 0)
761 CODE: 982 CODE:
762{ 983{
763 int count; 984 int count;
764 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count); 985 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
… …
767} 988}
768 OUTPUT: 989 OUTPUT:
769 RETVAL 990 RETVAL
770 991
771void 992void
772DESTROY (CFClient::Font self) 993DESTROY (CFPlus::Font self)
773 CODE: 994 CODE:
774 pango_font_description_free (self); 995 pango_font_description_free (self);
775 996
776void 997void
777make_default (CFClient::Font self) 998make_default (CFPlus::Font self)
999 PROTOTYPE: $
778 CODE: 1000 CODE:
779 default_font = self; 1001 default_font = self;
780 1002
781MODULE = CFClient PACKAGE = CFClient::Layout 1003MODULE = CFPlus PACKAGE = CFPlus::Layout
782 1004
783CFClient::Layout 1005PROTOTYPES: DISABLE
784new (SV *class, int rgba = 0) 1006
1007void
1008reset_glyph_cache ()
1009 PROTOTYPE:
1010 CODE:
1011 tc_clear ();
1012
1013CFPlus::Layout
1014new (SV *class)
785 CODE: 1015 CODE:
786 New (0, RETVAL, 1, struct cf_layout); 1016 New (0, RETVAL, 1, struct cf_layout);
787 1017
788 RETVAL->pl = pango_layout_new (rgba ? cairo_context : ft2_context); 1018 RETVAL->pl = pango_layout_new (opengl_context);
789 RETVAL->rgba = rgba;
790 RETVAL->r = 1.; 1019 RETVAL->r = 1.;
791 RETVAL->g = 1.; 1020 RETVAL->g = 1.;
792 RETVAL->b = 1.; 1021 RETVAL->b = 1.;
793 RETVAL->a = 1.; 1022 RETVAL->a = 1.;
794 RETVAL->base_height = MIN_FONT_HEIGHT; 1023 RETVAL->base_height = MIN_FONT_HEIGHT;
… …
798 layout_update_font (RETVAL); 1027 layout_update_font (RETVAL);
799 OUTPUT: 1028 OUTPUT:
800 RETVAL 1029 RETVAL
801 1030
802void 1031void
803DESTROY (CFClient::Layout self) 1032DESTROY (CFPlus::Layout self)
804 CODE: 1033 CODE:
805 g_object_unref (self->pl); 1034 g_object_unref (self->pl);
806 Safefree (self); 1035 Safefree (self);
807 1036
808int
809is_rgba (CFClient::Layout self)
810 CODE:
811 RETVAL = self->rgba;
812 OUTPUT:
813 RETVAL
814
815void 1037void
816set_text (CFClient::Layout self, SV *text_) 1038set_text (CFPlus::Layout self, SV *text_)
817 CODE: 1039 CODE:
818{ 1040{
819 STRLEN textlen; 1041 STRLEN textlen;
820 char *text = SvPVutf8 (text_, textlen); 1042 char *text = SvPVutf8 (text_, textlen);
821 1043
822 pango_layout_set_text (self->pl, text, textlen); 1044 pango_layout_set_text (self->pl, text, textlen);
823} 1045}
824 1046
825void 1047void
826set_markup (CFClient::Layout self, SV *text_) 1048set_markup (CFPlus::Layout self, SV *text_)
827 CODE: 1049 CODE:
828{ 1050{
829 STRLEN textlen; 1051 STRLEN textlen;
830 char *text = SvPVutf8 (text_, textlen); 1052 char *text = SvPVutf8 (text_, textlen);
831 1053
832 pango_layout_set_markup (self->pl, text, textlen); 1054 pango_layout_set_markup (self->pl, text, textlen);
833} 1055}
834 1056
835void 1057void
836set_shapes (CFClient::Layout self, ...) 1058set_shapes (CFPlus::Layout self, ...)
837 CODE: 1059 CODE:
838{ 1060{
839 PangoAttrList *attrs = 0; 1061 PangoAttrList *attrs = 0;
840 const char *text = pango_layout_get_text (self->pl); 1062 const char *text = pango_layout_get_text (self->pl);
841 const char *pos = text; 1063 const char *pos = text;
… …
876 if (attrs) 1098 if (attrs)
877 pango_layout_set_attributes (self->pl, attrs); 1099 pango_layout_set_attributes (self->pl, attrs);
878} 1100}
879 1101
880void 1102void
881get_shapes (CFClient::Layout self) 1103get_shapes (CFPlus::Layout self)
882 PPCODE: 1104 PPCODE:
883{ 1105{
884 PangoLayoutIter *iter = pango_layout_get_iter (self->pl); 1106 PangoLayoutIter *iter = pango_layout_get_iter (self->pl);
885 1107
886 do 1108 do
… …
890 if (run && shape_attr_p (run)) 1112 if (run && shape_attr_p (run))
891 { 1113 {
892 PangoRectangle extents; 1114 PangoRectangle extents;
893 pango_layout_iter_get_run_extents (iter, 0, &extents); 1115 pango_layout_iter_get_run_extents (iter, 0, &extents);
894 1116
1117 EXTEND (SP, 2);
895 PUSHs (sv_2mortal (newSViv (PANGO_PIXELS (extents.x)))); 1118 PUSHs (sv_2mortal (newSViv (PANGO_PIXELS (extents.x))));
896 PUSHs (sv_2mortal (newSViv (PANGO_PIXELS (extents.y)))); 1119 PUSHs (sv_2mortal (newSViv (PANGO_PIXELS (extents.y))));
897 } 1120 }
898 } 1121 }
899 while (pango_layout_iter_next_run (iter)); 1122 while (pango_layout_iter_next_run (iter));
900 1123
901 pango_layout_iter_free (iter); 1124 pango_layout_iter_free (iter);
902} 1125}
903 1126
904int 1127int
905has_wrapped (CFClient::Layout self) 1128has_wrapped (CFPlus::Layout self)
906 CODE: 1129 CODE:
907{ 1130{
908 int lines = 1; 1131 int lines = 1;
909 const char *text = pango_layout_get_text (self->pl); 1132 const char *text = pango_layout_get_text (self->pl);
910 1133
… …
915} 1138}
916 OUTPUT: 1139 OUTPUT:
917 RETVAL 1140 RETVAL
918 1141
919SV * 1142SV *
920get_text (CFClient::Layout self) 1143get_text (CFPlus::Layout self)
921 CODE: 1144 CODE:
922 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0); 1145 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
923 sv_utf8_decode (RETVAL); 1146 sv_utf8_decode (RETVAL);
924 OUTPUT: 1147 OUTPUT:
925 RETVAL 1148 RETVAL
926 1149
927void 1150void
928set_foreground (CFClient::Layout self, float r, float g, float b, float a = 1.) 1151set_foreground (CFPlus::Layout self, float r, float g, float b, float a = 1.)
929 CODE: 1152 CODE:
930 self->r = r; 1153 self->r = r;
931 self->g = g; 1154 self->g = g;
932 self->b = b; 1155 self->b = b;
933 self->a = a; 1156 self->a = a;
934 1157
935void 1158void
936set_font (CFClient::Layout self, CFClient::Font font = 0) 1159set_font (CFPlus::Layout self, CFPlus::Font font = 0)
937 CODE: 1160 CODE:
938 if (self->font != font) 1161 if (self->font != font)
939 { 1162 {
940 self->font = font; 1163 self->font = font;
941 layout_update_font (self); 1164 layout_update_font (self);
942 } 1165 }
943 1166
944void 1167void
945set_height (CFClient::Layout self, int base_height) 1168set_height (CFPlus::Layout self, int base_height)
946 CODE: 1169 CODE:
947 if (self->base_height != base_height) 1170 if (self->base_height != base_height)
948 { 1171 {
949 self->base_height = base_height; 1172 self->base_height = base_height;
950 layout_update_font (self); 1173 layout_update_font (self);
951 } 1174 }
952 1175
953void 1176void
954set_width (CFClient::Layout self, int max_width = -1) 1177set_width (CFPlus::Layout self, int max_width = -1)
955 CODE: 1178 CODE:
956 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE); 1179 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE);
957 1180
958void 1181void
959set_indent (CFClient::Layout self, int indent) 1182set_indent (CFPlus::Layout self, int indent)
960 CODE: 1183 CODE:
961 pango_layout_set_indent (self->pl, indent * PANGO_SCALE); 1184 pango_layout_set_indent (self->pl, indent * PANGO_SCALE);
962 1185
963void 1186void
964set_spacing (CFClient::Layout self, int spacing) 1187set_spacing (CFPlus::Layout self, int spacing)
965 CODE: 1188 CODE:
966 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE); 1189 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE);
967 1190
968void 1191void
969set_ellipsise (CFClient::Layout self, int ellipsise) 1192set_ellipsise (CFPlus::Layout self, int ellipsise)
970 CODE: 1193 CODE:
971 pango_layout_set_ellipsize (self->pl, 1194 pango_layout_set_ellipsize (self->pl,
972 ellipsise == 1 ? PANGO_ELLIPSIZE_START 1195 ellipsise == 1 ? PANGO_ELLIPSIZE_START
973 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE 1196 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE
974 : ellipsise == 3 ? PANGO_ELLIPSIZE_END 1197 : ellipsise == 3 ? PANGO_ELLIPSIZE_END
975 : PANGO_ELLIPSIZE_NONE 1198 : PANGO_ELLIPSIZE_NONE
976 ); 1199 );
977 1200
978void 1201void
979set_single_paragraph_mode (CFClient::Layout self, int spm) 1202set_single_paragraph_mode (CFPlus::Layout self, int spm)
980 CODE: 1203 CODE:
981 pango_layout_set_single_paragraph_mode (self->pl, !!spm); 1204 pango_layout_set_single_paragraph_mode (self->pl, !!spm);
982 1205
983void 1206void
984size (CFClient::Layout self) 1207size (CFPlus::Layout self)
985 PPCODE: 1208 PPCODE:
986{ 1209{
987 int w, h; 1210 int w, h;
988 1211
989 layout_get_pixel_size (self, &w, &h); 1212 layout_get_pixel_size (self, &w, &h);
… …
992 PUSHs (sv_2mortal (newSViv (w))); 1215 PUSHs (sv_2mortal (newSViv (w)));
993 PUSHs (sv_2mortal (newSViv (h))); 1216 PUSHs (sv_2mortal (newSViv (h)));
994} 1217}
995 1218
996int 1219int
997descent (CFClient::Layout self) 1220descent (CFPlus::Layout self)
998 CODE: 1221 CODE:
999{ 1222{
1000 PangoRectangle rect; 1223 PangoRectangle rect;
1001 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0); 1224 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0);
1002 pango_layout_line_get_pixel_extents (line, 0, &rect); 1225 pango_layout_line_get_pixel_extents (line, 0, &rect);
… …
1004} 1227}
1005 OUTPUT: 1228 OUTPUT:
1006 RETVAL 1229 RETVAL
1007 1230
1008int 1231int
1009xy_to_index (CFClient::Layout self, int x, int y) 1232xy_to_index (CFPlus::Layout self, int x, int y)
1010 CODE: 1233 CODE:
1011{ 1234{
1012 int index, trailing; 1235 int index, trailing;
1013 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing); 1236 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);
1014 RETVAL = index; 1237 RETVAL = index + trailing;
1015} 1238}
1016 OUTPUT: 1239 OUTPUT:
1017 RETVAL 1240 RETVAL
1018 1241
1019void 1242void
1020cursor_pos (CFClient::Layout self, int index) 1243cursor_pos (CFPlus::Layout self, int index)
1021 PPCODE: 1244 PPCODE:
1022{ 1245{
1023 PangoRectangle strong_pos; 1246 PangoRectangle strong_pos;
1024 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1247 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);
1025 1248
… …
1028 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1251 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
1029 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1252 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));
1030} 1253}
1031 1254
1032void 1255void
1033render (CFClient::Layout self) 1256index_to_line_x (CFPlus::Layout self, int index, int trailing = 0)
1034 PPCODE: 1257 PPCODE:
1035{ 1258{
1036 SV *retval; 1259 int line, x;
1037 int w, h;
1038 1260
1039 layout_get_pixel_size (self, &w, &h); 1261 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
1262 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
1040 1263
1041 if (self->rgba)
1042 {
1043 cairo_surface_t *surface;
1044 cairo_t *cairo;
1045
1046 retval = newSV (w * h * 4);
1047 SvPOK_only (retval);
1048 SvCUR_set (retval, w * h * 4);
1049
1050 memset (SvPVX (retval), 0, w * h * 4);
1051
1052 surface = cairo_image_surface_create_for_data (
1053 (void*)SvPVX (retval), CAIRO_FORMAT_ARGB32, w, h, w * 4);
1054 cairo = cairo_create (surface);
1055 cairo_set_source_rgba (cairo, self->r, self->g, self->b, self->a);
1056
1057 pango_cairo_show_layout (cairo, self->pl);
1058
1059 cairo_destroy (cairo);
1060 cairo_surface_destroy (surface);
1061
1062 // what a mess, and its premultiplied, too :(
1063 {
1064 uint32_t *p = (uint32_t *)SvPVX (retval);
1065 uint32_t *e = p + w * h;
1066
1067 while (p < e)
1068 {
1069 uint32_t rgba = *p;
1070 rgba = (rgba >> 24) | (rgba << 8);
1071#if 0
1072#ifdef _WIN32
1073 {//D
1074 uint8_t r = rgba >> 24;
1075 uint8_t g = rgba >> 16;
1076 uint8_t b = rgba >> 8;
1077 uint8_t a = rgba >> 0;
1078
1079 rgba = (rgba & 0xffffff00) | a;
1080 }
1081#endif
1082#endif
1083 rgba = SDL_SwapBE32 (rgba);
1084 *p++ = rgba;
1085 }
1086 }
1087
1088 EXTEND (SP, 5); 1264 EXTEND (SP, 2);
1089 PUSHs (sv_2mortal (newSViv (w))); 1265 PUSHs (sv_2mortal (newSViv (line - 1)));
1266 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE)));
1267}
1268
1269void
1270line_x_to_index (CFPlus::Layout self, int line, int x)
1271 PPCODE:
1272{
1273 PangoLayoutLine *lp;
1274 int index, trailing;
1275
1276 if (line < 0)
1277 XSRETURN_EMPTY;
1278
1279 if (!(lp = pango_layout_get_line (self->pl, line)))
1280 XSRETURN_EMPTY; /* do better */
1281
1282 pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing);
1283
1284 EXTEND (SP, 2);
1285 if (GIMME_V == G_SCALAR)
1090 PUSHs (sv_2mortal (newSViv (h))); 1286 PUSHs (sv_2mortal (newSViv (index + trailing)));
1091 PUSHs (sv_2mortal (retval));
1092 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
1093 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
1094 }
1095 else 1287 else
1096 { 1288 {
1097 FT_Bitmap bitmap;
1098
1099 retval = newSV (w * h);
1100 SvPOK_only (retval);
1101 SvCUR_set (retval, w * h);
1102
1103 bitmap.rows = h;
1104 bitmap.width = w;
1105 bitmap.pitch = w;
1106 bitmap.buffer = (unsigned char*)SvPVX (retval);
1107 bitmap.num_grays = 256;
1108 bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
1109
1110 memset (bitmap.buffer, 0, w * h);
1111
1112 pango_ft2_render_layout (&bitmap, self->pl, 0 * PANGO_SCALE, 0 * PANGO_SCALE);
1113
1114 EXTEND (SP, 5);
1115 PUSHs (sv_2mortal (newSViv (w))); 1289 PUSHs (sv_2mortal (newSViv (index)));
1116 PUSHs (sv_2mortal (newSViv (h))); 1290 PUSHs (sv_2mortal (newSViv (trailing)));
1117 PUSHs (sv_2mortal (retval));
1118 PUSHs (sv_2mortal (newSViv (GL_ALPHA)));
1119 PUSHs (sv_2mortal (newSViv (GL_ALPHA)));
1120 } 1291 }
1121} 1292}
1122 1293
1123MODULE = CFClient PACKAGE = CFClient::Texture
1124
1125void 1294void
1126pad2pot (SV *data_, SV *w_, SV *h_) 1295render (CFPlus::Layout self, float x, float y, int flags = 0)
1127 CODE: 1296 PPCODE:
1128{ 1297 pango_opengl_render_layout_subpixel (
1129 int ow = SvIV (w_); 1298 self->pl,
1130 int oh = SvIV (h_); 1299 x * PANGO_SCALE, y * PANGO_SCALE,
1300 self->r, self->g, self->b, self->a,
1301 flags
1302 );
1131 1303
1132 if (ow && oh) 1304MODULE = CFPlus PACKAGE = CFPlus::Texture
1305
1306PROTOTYPES: ENABLE
1307
1308int minpot (int n)
1309
1310void
1311pad (SV *data_, int ow, int oh, int nw, int nh)
1312 CODE:
1313{
1314 if ((nw != ow || nh != oh) && SvOK (data_))
1133 { 1315 {
1134 int nw = minpot (ow);
1135 int nh = minpot (oh);
1136
1137 if (nw != ow || nh != oh)
1138 {
1139 if (SvOK (data_))
1140 {
1141 STRLEN datalen; 1316 STRLEN datalen;
1142 char *data = SvPVbyte (data_, datalen); 1317 char *data = SvPVbyte (data_, datalen);
1143 int bpp = datalen / (ow * oh); 1318 int bpp = datalen / (ow * oh);
1144 SV *result_ = sv_2mortal (newSV (nw * nh * bpp)); 1319 SV *result_ = sv_2mortal (newSV (nw * nh * bpp));
1145 1320
1146 SvPOK_only (result_); 1321 SvPOK_only (result_);
1147 SvCUR_set (result_, nw * nh * bpp); 1322 SvCUR_set (result_, nw * nh * bpp);
1148 1323
1149 memset (SvPVX (result_), 0, nw * nh * bpp); 1324 memset (SvPVX (result_), 0, nw * nh * bpp);
1150 while (oh--) 1325 while (oh--)
1151 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp); 1326 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp);
1152 1327
1153 sv_setsv (data_, result_); 1328 sv_setsv (data_, result_);
1154 }
1155
1156 sv_setiv (w_, nw);
1157 sv_setiv (h_, nh);
1158 }
1159 } 1329 }
1160} 1330}
1161 1331
1162void 1332void
1163draw_quad (SV *self, float x, float y, float w = 0., float h = 0.) 1333draw_quad (SV *self, float x, float y, float w = 0., float h = 0.)
… …
1206 glDisable (GL_ALPHA_TEST); 1376 glDisable (GL_ALPHA_TEST);
1207 glDisable (GL_BLEND); 1377 glDisable (GL_BLEND);
1208 } 1378 }
1209} 1379}
1210 1380
1381IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1382 CODE:
1383{
1384 GLint width;
1385 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
1386 glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
1387 RETVAL = width > 0;
1388}
1389 OUTPUT:
1390 RETVAL
1391
1211MODULE = CFClient PACKAGE = CFClient::Map 1392MODULE = CFPlus PACKAGE = CFPlus::Map
1212 1393
1213CFClient::Map 1394PROTOTYPES: DISABLE
1214new (SV *class, int map_width, int map_height) 1395
1396CFPlus::Map
1397new (SV *class)
1215 CODE: 1398 CODE:
1216 New (0, RETVAL, 1, struct map); 1399 New (0, RETVAL, 1, struct map);
1217 RETVAL->x = 0; 1400 RETVAL->x = 0;
1218 RETVAL->y = 0; 1401 RETVAL->y = 0;
1219 RETVAL->w = map_width; 1402 RETVAL->w = 0;
1220 RETVAL->h = map_height; 1403 RETVAL->h = 0;
1221 RETVAL->ox = 0; 1404 RETVAL->ox = 0;
1222 RETVAL->oy = 0; 1405 RETVAL->oy = 0;
1223 RETVAL->faces = 8192; 1406 RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
1224 Newz (0, RETVAL->face, RETVAL->faces, mapface); 1407 RETVAL->texs = 8192; Newz (0, RETVAL->tex , RETVAL->texs , maptex);
1225 RETVAL->texs = 8192;
1226 Newz (0, RETVAL->tex, RETVAL->texs, maptex);
1227 RETVAL->rows = 0; 1408 RETVAL->rows = 0;
1228 RETVAL->row = 0; 1409 RETVAL->row = 0;
1229 OUTPUT: 1410 OUTPUT:
1230 RETVAL 1411 RETVAL
1231 1412
1232void 1413void
1233DESTROY (CFClient::Map self) 1414DESTROY (CFPlus::Map self)
1234 CODE: 1415 CODE:
1235{ 1416{
1236 map_clear (self); 1417 map_clear (self);
1237 Safefree (self->face); 1418 Safefree (self->face2tile);
1238 Safefree (self->tex); 1419 Safefree (self->tex);
1239 Safefree (self); 1420 Safefree (self);
1240} 1421}
1241 1422
1242void 1423void
1424resize (CFPlus::Map self, int map_width, int map_height)
1425 CODE:
1426 self->w = map_width;
1427 self->h = map_height;
1428
1429void
1243clear (CFClient::Map self) 1430clear (CFPlus::Map self)
1244 CODE: 1431 CODE:
1245 map_clear (self); 1432 map_clear (self);
1246 1433
1247void 1434void
1248set_face (CFClient::Map self, int face, int texid) 1435set_tileid (CFPlus::Map self, int face, int tile)
1249 CODE: 1436 CODE:
1250{ 1437{
1251 while (self->faces <= face) 1438 need_facenum (self, face); self->face2tile [face] = tile;
1252 { 1439 need_texid (self, tile);
1253 Append (mapface, self->face, self->faces, self->faces);
1254 self->faces *= 2;
1255 }
1256
1257 self->face [face] = texid;
1258} 1440}
1259 1441
1260void 1442void
1443set_smooth (CFPlus::Map self, int face, int smooth, int level)
1444 CODE:
1445{
1446 tileid texid;
1447 maptex *tex;
1448
1449 if (face < 0 || face >= self->faces)
1450 return;
1451
1452 if (smooth < 0 || smooth >= self->faces)
1453 return;
1454
1455 texid = self->face2tile [face];
1456
1457 if (!texid)
1458 return;
1459
1460 tex = self->tex + texid;
1461 tex->smoothtile = self->face2tile [smooth];
1462 tex->smoothlevel = level;
1463}
1464
1465void
1261set_texture (CFClient::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a) 1466set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
1262 CODE: 1467 CODE:
1263{ 1468{
1264 while (self->texs <= texid) 1469 need_texid (self, texid);
1265 {
1266 Append (maptex, self->tex, self->texs, self->texs);
1267 self->texs *= 2;
1268 }
1269 1470
1270 { 1471 {
1271 maptex *tex = self->tex + texid; 1472 maptex *tex = self->tex + texid;
1272 1473
1273 tex->name = name; 1474 tex->name = name;
… …
1290 // from transparent color bleeding and ugly wrapping effects. 1491 // from transparent color bleeding and ugly wrapping effects.
1291 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1492 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1292} 1493}
1293 1494
1294int 1495int
1295ox (CFClient::Map self) 1496ox (CFPlus::Map self)
1296 ALIAS: 1497 ALIAS:
1297 oy = 1 1498 oy = 1
1298 x = 2 1499 x = 2
1299 y = 3 1500 y = 3
1300 w = 4 1501 w = 4
… …
1311 } 1512 }
1312 OUTPUT: 1513 OUTPUT:
1313 RETVAL 1514 RETVAL
1314 1515
1315void 1516void
1316scroll (CFClient::Map self, int dx, int dy) 1517scroll (CFPlus::Map self, int dx, int dy)
1317 CODE: 1518 CODE:
1318{ 1519{
1319 if (dx > 0) 1520 if (dx > 0)
1320 map_blank (self, self->x, self->y, dx - 1, self->h); 1521 map_blank (self, self->x, self->y, dx, self->h);
1321 else if (dx < 0) 1522 else if (dx < 0)
1322 map_blank (self, self->x + self->w + dx + 1, self->y, 1 - dx, self->h); 1523 map_blank (self, self->x + self->w + dx, self->y, -dx, self->h);
1323 1524
1324 if (dy > 0) 1525 if (dy > 0)
1325 map_blank (self, self->x, self->y, self->w, dy - 1); 1526 map_blank (self, self->x, self->y, self->w, dy);
1326 else if (dy < 0) 1527 else if (dy < 0)
1327 map_blank (self, self->x, self->y + self->h + dy + 1, self->w, 1 - dy); 1528 map_blank (self, self->x, self->y + self->h + dy, self->w, -dy);
1328 1529
1329 self->ox += dx; self->x += dx; 1530 self->ox += dx; self->x += dx;
1330 self->oy += dy; self->y += dy; 1531 self->oy += dy; self->y += dy;
1331 1532
1332 while (self->y < 0) 1533 while (self->y < 0)
… …
1337 self->y += MAP_EXTEND_Y; 1538 self->y += MAP_EXTEND_Y;
1338 } 1539 }
1339} 1540}
1340 1541
1341void 1542void
1342map1a_update (CFClient::Map self, SV *data_) 1543map1a_update (CFPlus::Map self, SV *data_, int extmap)
1343 CODE: 1544 CODE:
1344{ 1545{
1345 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 1546 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1346 uint8_t *data_end = (uint8_t *)SvEND (data_); 1547 uint8_t *data_end = (uint8_t *)SvEND (data_);
1347 mapcell *cell; 1548 mapcell *cell;
1348 int x, y, flags; 1549 int x, y, flags;
1349 1550
1350 while (data < data_end) 1551 while (data < data_end - 1)
1351 { 1552 {
1352 flags = (data [0] << 8) + data [1]; data += 2; 1553 flags = (data [0] << 8) + data [1]; data += 2;
1353 1554
1354 x = self->x + ((flags >> 10) & 63); 1555 x = self->x + ((flags >> 10) & 63);
1355 y = self->y + ((flags >> 4) & 63); 1556 y = self->y + ((flags >> 4) & 63);
1356 1557
1357 cell = map_get_cell (self, x, y); 1558 cell = map_get_cell (self, x, y);
1358 1559
1359 if (flags & 15) 1560 if (flags & 15)
1360 { 1561 {
1361 if (cell->darkness < 0) 1562 if (!cell->darkness)
1362 { 1563 {
1564 memset (cell, 0, sizeof (*cell));
1363 cell->darkness = 0; 1565 cell->darkness = 256;
1364 cell->face [0] = 0;
1365 cell->face [1] = 0;
1366 cell->face [2] = 0;
1367 } 1566 }
1368 1567
1369 cell->darkness = flags & 8 ? *data++ : 255;
1370
1371 //TODO: don't trust server data to be in-range(!) 1568 //TODO: don't trust server data to be in-range(!)
1569
1570 if (flags & 8)
1571 {
1572 if (extmap)
1573 {
1574 uint8_t ext, cmd;
1575
1576 do
1577 {
1578 ext = *data++;
1579 cmd = ext & 0x3f;
1580
1581 if (cmd < 4)
1582 cell->darkness = 255 - ext * 64 + 1;
1583 else if (cmd == 5) // health
1584 {
1585 cell->stat_width = 1;
1586 cell->stat_hp = *data++;
1587 }
1588 else if (cmd == 6) // monster width
1589 cell->stat_width = *data++ + 1;
1590 else if (cmd == 0x47)
1591 {
1592 if (*data == 4)
1593 ; // decode player count
1594
1595 data += *data + 1;
1596 }
1597 else if (cmd == 8) // cell flags
1598 cell->flags = *data++;
1599 else if (ext & 0x40) // unknown, multibyte => skip
1600 data += *data + 1;
1601 else
1602 data++;
1603 }
1604 while (ext & 0x80);
1605 }
1606 else
1607 cell->darkness = *data++ + 1;
1608 }
1372 1609
1373 if (flags & 4) 1610 if (flags & 4)
1374 { 1611 {
1375 cell->face [0] = self->face [(data [0] << 8) + data [1]]; data += 2; 1612 faceid face = (data [0] << 8) + data [1]; data += 2;
1613 need_facenum (self, face);
1614 cell->tile [0] = self->face2tile [face];
1376 } 1615 }
1377 1616
1378 if (flags & 2) 1617 if (flags & 2)
1379 { 1618 {
1380 cell->face [1] = self->face [(data [0] << 8) + data [1]]; data += 2; 1619 faceid face = (data [0] << 8) + data [1]; data += 2;
1620 need_facenum (self, face);
1621 cell->tile [1] = self->face2tile [face];
1381 } 1622 }
1382 1623
1383 if (flags & 1) 1624 if (flags & 1)
1384 { 1625 {
1385 cell->face [2] = self->face [(data [0] << 8) + data [1]]; data += 2; 1626 faceid face = (data [0] << 8) + data [1]; data += 2;
1627 need_facenum (self, face);
1628 cell->tile [2] = self->face2tile [face];
1386 } 1629 }
1387 } 1630 }
1388 else 1631 else
1389 cell->darkness = -1; 1632 cell->darkness = 0;
1390 } 1633 }
1391} 1634}
1392 1635
1393SV * 1636SV *
1394mapmap (CFClient::Map self, int x0, int y0, int w, int h) 1637mapmap (CFPlus::Map self, int x0, int y0, int w, int h)
1395 CODE: 1638 CODE:
1396{ 1639{
1397 int x1, x; 1640 int x1, x;
1398 int y1, y; 1641 int y1, y;
1399 int z; 1642 int z;
… …
1420 { 1663 {
1421 mapcell *cell = row->col + (x - row->c0); 1664 mapcell *cell = row->col + (x - row->c0);
1422 1665
1423 for (z = 0; z <= 0; z++) 1666 for (z = 0; z <= 0; z++)
1424 { 1667 {
1425 mapface face = cell->face [z];
1426
1427 if (face)
1428 {
1429 maptex tex = self->tex [face]; 1668 maptex tex = self->tex [cell->tile [z]];
1430 int a0 = 255 - tex.a; 1669 int a0 = 255 - tex.a;
1431 int a1 = tex.a; 1670 int a1 = tex.a;
1432 1671
1433 r = (r * a0 + tex.r * a1) / 255; 1672 r = (r * a0 + tex.r * a1) / 255;
1434 g = (g * a0 + tex.g * a1) / 255; 1673 g = (g * a0 + tex.g * a1) / 255;
1435 b = (b * a0 + tex.b * a1) / 255; 1674 b = (b * a0 + tex.b * a1) / 255;
1436 a = (a * a0 + tex.a * a1) / 255; 1675 a = (a * a0 + tex.a * a1) / 255;
1437 }
1438 } 1676 }
1439 } 1677 }
1440 1678
1441 *map++ = (r ) 1679 *map++ = (r )
1442 | (g << 8) 1680 | (g << 8)
… …
1449} 1687}
1450 OUTPUT: 1688 OUTPUT:
1451 RETVAL 1689 RETVAL
1452 1690
1453void 1691void
1454draw (CFClient::Map self, int shift_x, int shift_y, int x0, int y0, int sw, int sh) 1692draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T)
1455 CODE: 1693 CODE:
1456{ 1694{
1457 int vx, vy; 1695 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1696 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1697 static uint8_t smooth_max[256][256]; // egad, fats and wasteful on memory (64k)
1698 smooth_key skey;
1458 int x, y, z; 1699 int x, y, z;
1459 int last_name; 1700 int last_name;
1460 mapface face;
1461 1701
1462 vx = self->x + self->w / 2 - sw / 2 - shift_x; 1702 // thats current max. sorry.
1463 vy = self->y + self->h / 2 - sh / 2 - shift_y; 1703 if (sw > 255) sw = 255;
1704 if (sh > 255) sh = 255;
1464 1705
1465 /* 1706 // clear key, in case of extra padding
1466 int vx = self->vx = self->w >= sw 1707 memset (&skey, 0, sizeof (skey));
1467 ? self->x + (self->w - sw) / 2
1468 : MIN (self->x, MAX (self->x + self->w - sw + 1, self->vx));
1469
1470 int vy = self->vy = self->h >= sh
1471 ? self->y + (self->h - sh) / 2
1472 : MIN (self->y, MAX (self->y + self->h - sh + 1, self->vy));
1473 */
1474 1708
1475 glColor4ub (255, 255, 255, 255); 1709 glColor4ub (255, 255, 255, 255);
1476 1710
1477 glEnable (GL_BLEND); 1711 glEnable (GL_BLEND);
1478 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 1712 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
… …
1481 1715
1482 glBegin (GL_QUADS); 1716 glBegin (GL_QUADS);
1483 1717
1484 last_name = 0; 1718 last_name = 0;
1485 1719
1720 mx += self->x;
1721 my += self->y;
1722
1723 // first pass: determine smooth_max
1724 // rather ugly, if you ask me
1725 // could also be stored inside mapcell and updated on change
1726 memset (smooth_max, 0, sizeof (smooth_max));
1727
1728 for (y = 0; y < sh; y++)
1729 if (0 <= y + my && y + my < self->rows)
1730 {
1731 maprow *row = self->row + (y + my);
1732
1733 for (x = 0; x < sw; x++)
1734 if (row->c0 <= x + mx && x + mx < row->c1)
1735 {
1736 mapcell *cell = row->col + (x + mx - row->c0);
1737
1738 smooth_max[x + 1][y + 1] =
1739 MAX (self->tex [cell->tile [0]].smoothlevel,
1740 MAX (self->tex [cell->tile [1]].smoothlevel,
1741 self->tex [cell->tile [2]].smoothlevel));
1742 }
1743 }
1744
1486 for (z = 0; z < 3; z++) 1745 for (z = 0; z <= 2; z++)
1746 {
1747 memset (smooth_level, 0, sizeof (smooth_level));
1748
1487 for (y = 0; y < sh; y++) 1749 for (y = 0; y < sh; y++)
1488 if (0 <= y + vy && y + vy < self->rows) 1750 if (0 <= y + my && y + my < self->rows)
1489 { 1751 {
1490 maprow *row = self->row + (y + vy); 1752 maprow *row = self->row + (y + my);
1491 1753
1492 for (x = 0; x < sw; x++) 1754 for (x = 0; x < sw; x++)
1493 if (row->c0 <= x + vx && x + vx < row->c1) 1755 if (row->c0 <= x + mx && x + mx < row->c1)
1494 { 1756 {
1495 mapcell *cell = row->col + (x + vx - row->c0); 1757 mapcell *cell = row->col + (x + mx - row->c0);
1496
1497 face = cell->face [z]; 1758 tileid tile = cell->tile [z];
1498 1759
1499 if (face) 1760 if (tile)
1761 {
1762 maptex tex = self->tex [tile];
1763 int px = (x + 1) * T - tex.w;
1764 int py = (y + 1) * T - tex.h;
1765
1766 // suppressing texture state switches here
1767 // is only moderately effective, but worth the extra effort
1768 if (last_name != tex.name)
1769 {
1770 if (!tex.name)
1771 tex = self->tex [2]; /* missing, replace by noface */
1772
1773 glEnd ();
1774 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1775 glBegin (GL_QUADS);
1776 }
1777
1778 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1779 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1780 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1781 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1782
1783 if (cell->flags && z == 2)
1784 {
1785 if (cell->flags & 1)
1786 {
1787 maptex tex = self->tex [1];
1788 int px = x * T + T * 2 / 32;
1789 int py = y * T - T * 6 / 32;
1790
1791 glEnd ();
1792 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1793 glBegin (GL_QUADS);
1794
1795 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1796 glTexCoord2f (0 , tex.t); glVertex2f (px , py + T);
1797 glTexCoord2f (tex.s, tex.t); glVertex2f (px + T, py + T);
1798 glTexCoord2f (tex.s, 0 ); glVertex2f (px + T, py );
1799 }
1800 }
1801
1802 // update smooth hash
1803 if (tex.smoothtile)
1804 {
1805 skey.tile = tex.smoothtile;
1806 skey.level = tex.smoothlevel;
1807
1808 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31);
1809
1810 // add bits to current tile and all neighbours. skey.x|y is
1811 // shifted +1|+1 so we always stay positive.
1812
1813 // bits is ___n cccc CCCC bbbb
1814 // n do not draw borders&corners
1815 // c draw these corners, but...
1816 // C ... not these
1817 // b draw these borders
1818
1819 // borders: 1 ┃· 2 ━━ 4 ·┃ 8 ··
1820 // ┃· ·· ·┃ ━━
1821
1822 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1823 // ·· ·· ·┏ ┓·
1824
1825 // full tile
1826 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000);
1827
1828 // borders
1829 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091);
1830 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032);
1831 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064);
1832 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8);
1833
1834 // corners
1835 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);
1836 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);
1837 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);
1838 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);
1839 }
1840 }
1841 }
1842 }
1843
1844 // go through all smoothlevels, lowest to highest, then draw.
1845 // this is basically counting sort
1846 {
1847 int w, b;
1848
1849 for (w = 0; w < 256 / 32; ++w)
1850 {
1851 uint32_t smask = smooth_level [w];
1852 if (smask)
1853 for (b = 0; b < 32; ++b)
1854 if (smask & (((uint32_t)1) << b))
1500 { 1855 {
1501 maptex tex = self->tex [face]; 1856 int level = (w << 5) | b;
1857 HE *he;
1502 1858
1503 int px = (x + 1) * 32 - tex.w; 1859 hv_iterinit (smooth);
1504 int py = (y + 1) * 32 - tex.h; 1860 while ((he = hv_iternext (smooth)))
1505
1506 if (last_name != tex.name)
1507 { 1861 {
1862 smooth_key *skey = (smooth_key *)HeKEY (he);
1863 IV bits = SvIVX (HeVAL (he));
1864
1865 if (!(bits & 0x1000)
1866 && skey->level == level
1867 && level > smooth_max [skey->x][skey->y])
1868 {
1869 maptex tex = self->tex [skey->tile];
1870 int px = (((int)skey->x) - 1) * T;
1871 int py = (((int)skey->y) - 1) * T;
1872 int border = bits & 15;
1873 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1874 float dx = tex.s * .0625f; // 16 images/row
1875 float dy = tex.t * .5f ; // 2 images/column
1876
1877 // this time naively avoiding texture state changes
1878 // save gobs of state changes.
1879 if (last_name != tex.name)
1880 {
1881 if (!tex.name)
1882 continue; // smoothing not yet available
1883
1508 glEnd (); 1884 glEnd ();
1509 last_name = tex.name;
1510 glBindTexture (GL_TEXTURE_2D, last_name); 1885 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1511 glBegin (GL_QUADS); 1886 glBegin (GL_QUADS);
1887 }
1888
1889 if (border)
1890 {
1891 float ox = border * dx;
1892
1893 glTexCoord2f (ox , 0.f ); glVertex2f (px , py );
1894 glTexCoord2f (ox , dy ); glVertex2f (px , py + T);
1895 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py + T);
1896 glTexCoord2f (ox + dx, 0.f ); glVertex2f (px + T, py );
1897 }
1898
1899 if (corner)
1900 {
1901 float ox = corner * dx;
1902
1903 glTexCoord2f (ox , dy ); glVertex2f (px , py );
1904 glTexCoord2f (ox , dy * 2.f); glVertex2f (px , py + T);
1905 glTexCoord2f (ox + dx, dy * 2.f); glVertex2f (px + T, py + T);
1906 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py );
1907 }
1908 }
1512 } 1909 }
1513
1514 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1515 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1516 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1517 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1518 } 1910 }
1519 }
1520 } 1911 }
1912 }
1913
1914 hv_clear (smooth);
1915 }
1521 1916
1522 glEnd (); 1917 glEnd ();
1523 1918
1524 glDisable (GL_TEXTURE_2D); 1919 glDisable (GL_TEXTURE_2D);
1525 glDisable (GL_BLEND); 1920 glDisable (GL_BLEND);
1526}
1527 1921
1922 // top layer: overlays such as the health bar
1923 for (y = 0; y < sh; y++)
1924 if (0 <= y + my && y + my < self->rows)
1925 {
1926 maprow *row = self->row + (y + my);
1927
1928 for (x = 0; x < sw; x++)
1929 if (row->c0 <= x + mx && x + mx < row->c1)
1930 {
1931 mapcell *cell = row->col + (x + mx - row->c0);
1932
1933 int px = x * T;
1934 int py = y * T;
1935
1936 if (cell->stat_hp)
1937 {
1938 int width = cell->stat_width * T;
1939 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
1940
1941 glColor3ub (0, 0, 0);
1942 glRectf (px + 1, py - thick - 2,
1943 px + width - 1, py);
1944
1945 glColor3ub (cell->stat_hp, 255 - cell->stat_hp, 0);
1946 glRectf (px + 2,
1947 py - thick - 1,
1948 px + width - 2 - cell->stat_hp * (width - 4) / 255, py - 1);
1949 }
1950 }
1951 }
1952}
1953
1528void 1954void
1529draw_magicmap (CFClient::Map self, int dx, int dy, int w, int h, unsigned char *data) 1955draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data)
1530 CODE: 1956 CODE:
1531{ 1957{
1532 static float color[16][3] = { 1958 static float color[16][3] = {
1533 { 0.00, 0.00, 0.00 }, 1959 { 0.00F, 0.00F, 0.00F },
1534 { 1.00, 1.00, 1.00 }, 1960 { 1.00F, 1.00F, 1.00F },
1535 { 0.00, 0.00, 0.55 }, 1961 { 0.00F, 0.00F, 0.55F },
1536 { 1.00, 0.00, 0.00 }, 1962 { 1.00F, 0.00F, 0.00F },
1537 1963
1538 { 1.00, 0.54, 0.00 }, 1964 { 1.00F, 0.54F, 0.00F },
1539 { 0.11, 0.56, 1.00 }, 1965 { 0.11F, 0.56F, 1.00F },
1540 { 0.93, 0.46, 0.00 }, 1966 { 0.93F, 0.46F, 0.00F },
1541 { 0.18, 0.54, 0.34 }, 1967 { 0.18F, 0.54F, 0.34F },
1542 1968
1543 { 0.56, 0.73, 0.56 }, 1969 { 0.56F, 0.73F, 0.56F },
1544 { 0.80, 0.80, 0.80 }, 1970 { 0.80F, 0.80F, 0.80F },
1545 { 0.55, 0.41, 0.13 }, 1971 { 0.55F, 0.41F, 0.13F },
1546 { 0.99, 0.77, 0.26 }, 1972 { 0.99F, 0.77F, 0.26F },
1547 1973
1548 { 0.74, 0.65, 0.41 }, 1974 { 0.74F, 0.65F, 0.41F },
1549 1975
1550 { 0.00, 1.00, 1.00 }, 1976 { 0.00F, 1.00F, 1.00F },
1551 { 1.00, 0.00, 1.00 }, 1977 { 1.00F, 0.00F, 1.00F },
1552 { 1.00, 1.00, 0.00 }, 1978 { 1.00F, 1.00F, 0.00F },
1553 }; 1979 };
1554 1980
1555 int x, y; 1981 int x, y;
1556 1982
1557 glEnable (GL_TEXTURE_2D); 1983 glEnable (GL_TEXTURE_2D);
… …
1584 glDisable (GL_BLEND); 2010 glDisable (GL_BLEND);
1585 glDisable (GL_TEXTURE_2D); 2011 glDisable (GL_TEXTURE_2D);
1586} 2012}
1587 2013
1588void 2014void
1589fow_texture (CFClient::Map self, int shift_x, int shift_y, int x0, int y0, int sw, int sh) 2015fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh)
1590 PPCODE: 2016 PPCODE:
1591{ 2017{
1592 int vx, vy;
1593 int x, y; 2018 int x, y;
2019 int sw1 = sw + 2;
2020 int sh1 = sh + 2;
2021 int sh3 = sh * 3;
1594 int sw4 = (sw + 3) & ~3; 2022 int sw34 = (sw * 3 + 3) & ~3;
2023 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
1595 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh)); 2024 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));
1596 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv); 2025 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
1597 2026
1598 memset (darkness, 255, sw4 * sh);
1599 SvPOK_only (darkness_sv); 2027 SvPOK_only (darkness3_sv);
1600 SvCUR_set (darkness_sv, sw4 * sh); 2028 SvCUR_set (darkness3_sv, sw34 * sh3);
1601 2029
1602 vx = self->x + (self->w - sw + 1) / 2 - shift_x; 2030 mx += self->x - 1;
1603 vy = self->y + (self->h - sh + 1) / 2 - shift_y; 2031 my += self->y - 1;
1604 2032
2033 memset (darkness1, 255, sw1 * sh1);
2034
1605 for (y = 0; y < sh; y++) 2035 for (y = 0; y < sh1; y++)
1606 if (0 <= y + vy && y + vy < self->rows) 2036 if (0 <= y + my && y + my < self->rows)
1607 { 2037 {
1608 maprow *row = self->row + (y + vy); 2038 maprow *row = self->row + (y + my);
1609 2039
1610 for (x = 0; x < sw; x++) 2040 for (x = 0; x < sw1; x++)
1611 if (row->c0 <= x + vx && x + vx < row->c1) 2041 if (row->c0 <= x + mx && x + mx < row->c1)
1612 { 2042 {
1613 mapcell *cell = row->col + (x + vx - row->c0); 2043 mapcell *cell = row->col + (x + mx - row->c0);
1614 2044
1615 darkness[y * sw4 + x] = cell->darkness < 0 2045 darkness1 [y * sw1 + x] = cell->darkness
2046 ? 255 - (cell->darkness - 1)
1616 ? 255 - FOW_DARKNESS 2047 : 255 - FOW_DARKNESS;
1617 : 255 - cell->darkness;
1618 } 2048 }
1619 } 2049 }
1620 2050
2051 for (y = 0; y < sh; ++y)
2052 for (x = 0; x < sw; ++x)
2053 {
2054 uint8_t d11 = darkness1 [(y ) * sw1 + x ];
2055 uint8_t d21 = darkness1 [(y ) * sw1 + x + 1];
2056 uint8_t d31 = darkness1 [(y ) * sw1 + x + 2];
2057 uint8_t d12 = darkness1 [(y + 1) * sw1 + x ];
2058 uint8_t d22 = darkness1 [(y + 1) * sw1 + x + 1];
2059 uint8_t d32 = darkness1 [(y + 1) * sw1 + x + 2];
2060 uint8_t d13 = darkness1 [(y + 2) * sw1 + x ];
2061 uint8_t d23 = darkness1 [(y + 2) * sw1 + x + 1];
2062 uint8_t d33 = darkness1 [(y + 2) * sw1 + x + 2];
2063
2064 uint8_t r11 = (d11 + d21 + d12) / 3;
2065 uint8_t r21 = d21;
2066 uint8_t r31 = (d21 + d31 + d32) / 3;
2067
2068 uint8_t r12 = d12;
2069 uint8_t r22 = d22;
2070 uint8_t r32 = d32;
2071
2072 uint8_t r13 = (d13 + d23 + d12) / 3;
2073 uint8_t r23 = d23;
2074 uint8_t r33 = (d23 + d33 + d32) / 3;
2075
2076 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11);
2077 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21);
2078 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31);
2079 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12);
2080 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22);
2081 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32);
2082 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13);
2083 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23);
2084 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33);
2085 }
2086
2087 free (darkness1);
2088
1621 EXTEND (SP, 3); 2089 EXTEND (SP, 3);
1622 PUSHs (sv_2mortal (newSViv (sw4))); 2090 PUSHs (sv_2mortal (newSViv (sw34)));
1623 PUSHs (sv_2mortal (newSViv (sh))); 2091 PUSHs (sv_2mortal (newSViv (sh3)));
1624 PUSHs (darkness_sv); 2092 PUSHs (darkness3_sv);
1625} 2093}
1626 2094
1627SV * 2095SV *
1628get_rect (CFClient::Map self, int x0, int y0, int w, int h) 2096get_rect (CFPlus::Map self, int x0, int y0, int w, int h)
1629 CODE: 2097 CODE:
1630{ 2098{
1631 int x, y, x1, y1; 2099 int x, y, x1, y1;
1632 SV *data_sv = newSV (w * h * 7 + 5); 2100 SV *data_sv = newSV (w * h * 7 + 5);
1633 uint8_t *data = (uint8_t *)SvPVX (data_sv); 2101 uint8_t *data = (uint8_t *)SvPVX (data_sv);
… …
1658 if (row && row->c0 <= x && x < row->c1) 2126 if (row && row->c0 <= x && x < row->c1)
1659 { 2127 {
1660 mapcell *cell = row->col + (x - row->c0); 2128 mapcell *cell = row->col + (x - row->c0);
1661 uint8_t flags = 0; 2129 uint8_t flags = 0;
1662 2130
1663 if (cell->face [0]) flags |= 1; 2131 if (cell->tile [0]) flags |= 1;
1664 if (cell->face [1]) flags |= 2; 2132 if (cell->tile [1]) flags |= 2;
1665 if (cell->face [2]) flags |= 4; 2133 if (cell->tile [2]) flags |= 4;
1666 2134
1667 *data++ = flags; 2135 *data++ = flags;
1668 2136
1669 if (flags & 1) 2137 if (flags & 1)
1670 { 2138 {
2139 tileid tile = cell->tile [0];
1671 *data++ = cell->face [0] >> 8; 2140 *data++ = tile >> 8;
1672 *data++ = cell->face [0]; 2141 *data++ = tile;
1673 } 2142 }
1674 2143
1675 if (flags & 2) 2144 if (flags & 2)
1676 { 2145 {
2146 tileid tile = cell->tile [1];
1677 *data++ = cell->face [1] >> 8; 2147 *data++ = tile >> 8;
1678 *data++ = cell->face [1]; 2148 *data++ = tile;
1679 } 2149 }
1680 2150
1681 if (flags & 4) 2151 if (flags & 4)
1682 { 2152 {
2153 tileid tile = cell->tile [2];
1683 *data++ = cell->face [2] >> 8; 2154 *data++ = tile >> 8;
1684 *data++ = cell->face [2]; 2155 *data++ = tile;
1685 } 2156 }
1686 } 2157 }
1687 else 2158 else
1688 *data++ = 0; 2159 *data++ = 0;
1689 } 2160 }
… …
1695} 2166}
1696 OUTPUT: 2167 OUTPUT:
1697 RETVAL 2168 RETVAL
1698 2169
1699void 2170void
1700set_rect (CFClient::Map self, int x0, int y0, uint8_t *data) 2171set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data)
1701 PPCODE: 2172 PPCODE:
1702{ 2173{
1703 int x, y, z; 2174 int x, y, z;
1704 int w, h; 2175 int w, h;
1705 int x1, y1; 2176 int x1, y1;
… …
1729 { 2200 {
1730 uint8_t flags = *data++; 2201 uint8_t flags = *data++;
1731 2202
1732 if (flags) 2203 if (flags)
1733 { 2204 {
1734 mapface face[3] = { 0, 0, 0 };
1735
1736 mapcell *cell = row_get_cell (row, x); 2205 mapcell *cell = row_get_cell (row, x);
2206 tileid tile[3] = { 0, 0, 0 };
1737 2207
1738 if (flags & 1) { face[0] = *data++ << 8; face[0] |= *data++; } 2208 if (flags & 1) { tile[0] = *data++ << 8; tile[0] |= *data++; }
1739 if (flags & 2) { face[1] = *data++ << 8; face[1] |= *data++; } 2209 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
1740 if (flags & 4) { face[2] = *data++ << 8; face[2] |= *data++; } 2210 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
1741 2211
1742 if (cell->darkness <= 0) 2212 if (cell->darkness == 0)
1743 { 2213 {
1744 cell->darkness = -1; 2214 cell->darkness = 0;
1745 2215
1746 for (z = 0; z <= 2; z++) 2216 for (z = 0; z <= 2; z++)
1747 { 2217 {
1748 cell->face[z] = face[z]; 2218 tileid t = tile [z];
1749 2219
1750 if (face[z] && (face[z] >= self->texs || !self->tex[face [z]].name)) 2220 if (t >= self->texs || (t && !self->tex [t].name))
2221 {
1751 XPUSHs (sv_2mortal (newSViv (face[z]))); 2222 XPUSHs (sv_2mortal (newSViv (t)));
2223 need_texid (self, t);
2224 }
2225
2226 cell->tile [z] = t;
1752 } 2227 }
1753 } 2228 }
1754 } 2229 }
1755 } 2230 }
1756 } 2231 }
1757} 2232}
1758 2233
1759MODULE = CFClient PACKAGE = CFClient::MixChunk 2234MODULE = CFPlus PACKAGE = CFPlus::MixChunk
1760 2235
2236PROTOTYPES: DISABLE
2237
1761CFClient::MixChunk 2238CFPlus::MixChunk
1762new_from_file (SV *class, char *path) 2239new_from_file (SV *class, char *path)
1763 CODE: 2240 CODE:
1764 RETVAL = Mix_LoadWAV (path); 2241 RETVAL = Mix_LoadWAV (path);
1765 OUTPUT: 2242 OUTPUT:
1766 RETVAL 2243 RETVAL
1767 2244
1768void 2245void
1769DESTROY (CFClient::MixChunk self) 2246DESTROY (CFPlus::MixChunk self)
1770 CODE: 2247 CODE:
1771 Mix_FreeChunk (self); 2248 Mix_FreeChunk (self);
1772 2249
1773int 2250int
1774volume (CFClient::MixChunk self, int volume = -1) 2251volume (CFPlus::MixChunk self, int volume = -1)
1775 CODE: 2252 CODE:
1776 RETVAL = Mix_VolumeChunk (self, volume); 2253 RETVAL = Mix_VolumeChunk (self, volume);
1777 OUTPUT: 2254 OUTPUT:
1778 RETVAL 2255 RETVAL
1779 2256
1780int 2257int
1781play (CFClient::MixChunk self, int channel = -1, int loops = 0, int ticks = -1) 2258play (CFPlus::MixChunk self, int channel = -1, int loops = 0, int ticks = -1)
1782 CODE: 2259 CODE:
1783 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks); 2260 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
1784 OUTPUT: 2261 OUTPUT:
1785 RETVAL 2262 RETVAL
1786 2263
1787MODULE = CFClient PACKAGE = CFClient::MixMusic 2264MODULE = CFPlus PACKAGE = CFPlus::MixMusic
1788 2265
1789int 2266int
1790volume (int volume = -1) 2267volume (int volume = -1)
2268 PROTOTYPE: ;$
1791 CODE: 2269 CODE:
1792 RETVAL = Mix_VolumeMusic (volume); 2270 RETVAL = Mix_VolumeMusic (volume);
1793 OUTPUT: 2271 OUTPUT:
1794 RETVAL 2272 RETVAL
1795 2273
2274int
2275fade_out (int ms)
2276 CODE:
2277 RETVAL = Mix_FadeOutMusic (ms);
2278 OUTPUT:
2279 RETVAL
2280
1796CFClient::MixMusic 2281CFPlus::MixMusic
1797new_from_file (SV *class, char *path) 2282new_from_file (SV *class, char *path)
1798 CODE: 2283 CODE:
1799 RETVAL = Mix_LoadMUS (path); 2284 RETVAL = Mix_LoadMUS (path);
1800 OUTPUT: 2285 OUTPUT:
1801 RETVAL 2286 RETVAL
1802 2287
1803void 2288void
1804DESTROY (CFClient::MixMusic self) 2289DESTROY (CFPlus::MixMusic self)
1805 CODE: 2290 CODE:
1806 Mix_FreeMusic (self); 2291 Mix_FreeMusic (self);
1807 2292
1808int 2293int
1809play (CFClient::MixMusic self, int loops = -1) 2294play (CFPlus::MixMusic self, int loops = -1)
1810 CODE: 2295 CODE:
1811 RETVAL = Mix_PlayMusic (self, loops); 2296 RETVAL = Mix_PlayMusic (self, loops);
1812 OUTPUT: 2297 OUTPUT:
1813 RETVAL 2298 RETVAL
1814 2299
2300int
2301fade_in_pos (CFPlus::MixMusic self, int loops, int ms, double position)
2302 CODE:
2303 RETVAL = Mix_FadeInMusicPos (self, loops, ms, position);
2304 OUTPUT:
2305 RETVAL
2306
1815MODULE = CFClient PACKAGE = CFClient::OpenGL 2307MODULE = CFPlus PACKAGE = CFPlus::OpenGL
2308
2309PROTOTYPES: ENABLE
1816 2310
1817BOOT: 2311BOOT:
1818{ 2312{
1819 HV *stash = gv_stashpv ("CFClient::OpenGL", 1); 2313 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1);
1820 static const struct { 2314 static const struct {
1821 const char *name; 2315 const char *name;
1822 IV iv; 2316 IV iv;
1823 } *civ, const_iv[] = { 2317 } *civ, const_iv[] = {
1824# define const_iv(name) { # name, (IV)name } 2318# define const_iv(name) { # name, (IV)name }
2319 const_iv (GL_VENDOR),
2320 const_iv (GL_VERSION),
2321 const_iv (GL_EXTENSIONS),
1825 const_iv (GL_COLOR_MATERIAL), 2322 const_iv (GL_COLOR_MATERIAL),
1826 const_iv (GL_SMOOTH), 2323 const_iv (GL_SMOOTH),
1827 const_iv (GL_FLAT), 2324 const_iv (GL_FLAT),
1828 const_iv (GL_DITHER), 2325 const_iv (GL_DITHER),
1829 const_iv (GL_BLEND), 2326 const_iv (GL_BLEND),
… …
1833 const_iv (GL_ALPHA_TEST), 2330 const_iv (GL_ALPHA_TEST),
1834 const_iv (GL_NORMALIZE), 2331 const_iv (GL_NORMALIZE),
1835 const_iv (GL_RESCALE_NORMAL), 2332 const_iv (GL_RESCALE_NORMAL),
1836 const_iv (GL_FRONT), 2333 const_iv (GL_FRONT),
1837 const_iv (GL_BACK), 2334 const_iv (GL_BACK),
2335 const_iv (GL_AUX0),
1838 const_iv (GL_AND), 2336 const_iv (GL_AND),
1839 const_iv (GL_ONE), 2337 const_iv (GL_ONE),
1840 const_iv (GL_ZERO), 2338 const_iv (GL_ZERO),
1841 const_iv (GL_SRC_ALPHA), 2339 const_iv (GL_SRC_ALPHA),
1842 const_iv (GL_DST_ALPHA), 2340 const_iv (GL_DST_ALPHA),
… …
1856 const_iv (GL_LUMINANCE), 2354 const_iv (GL_LUMINANCE),
1857 const_iv (GL_LUMINANCE_ALPHA), 2355 const_iv (GL_LUMINANCE_ALPHA),
1858 const_iv (GL_FLOAT), 2356 const_iv (GL_FLOAT),
1859 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV), 2357 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),
1860 const_iv (GL_COMPILE), 2358 const_iv (GL_COMPILE),
2359 const_iv (GL_PROXY_TEXTURE_1D),
2360 const_iv (GL_PROXY_TEXTURE_2D),
1861 const_iv (GL_TEXTURE_1D), 2361 const_iv (GL_TEXTURE_1D),
1862 const_iv (GL_TEXTURE_2D), 2362 const_iv (GL_TEXTURE_2D),
1863 const_iv (GL_TEXTURE_ENV), 2363 const_iv (GL_TEXTURE_ENV),
1864 const_iv (GL_TEXTURE_MAG_FILTER), 2364 const_iv (GL_TEXTURE_MAG_FILTER),
1865 const_iv (GL_TEXTURE_MIN_FILTER), 2365 const_iv (GL_TEXTURE_MIN_FILTER),
… …
1886 const_iv (GL_COLOR_LOGIC_OP), 2386 const_iv (GL_COLOR_LOGIC_OP),
1887 const_iv (GL_SEPARABLE_2D), 2387 const_iv (GL_SEPARABLE_2D),
1888 const_iv (GL_CONVOLUTION_2D), 2388 const_iv (GL_CONVOLUTION_2D),
1889 const_iv (GL_CONVOLUTION_BORDER_MODE), 2389 const_iv (GL_CONVOLUTION_BORDER_MODE),
1890 const_iv (GL_CONSTANT_BORDER), 2390 const_iv (GL_CONSTANT_BORDER),
2391 const_iv (GL_POINTS),
1891 const_iv (GL_LINES), 2392 const_iv (GL_LINES),
2393 const_iv (GL_LINE_STRIP),
1892 const_iv (GL_LINE_LOOP), 2394 const_iv (GL_LINE_LOOP),
1893 const_iv (GL_QUADS), 2395 const_iv (GL_QUADS),
1894 const_iv (GL_QUAD_STRIP), 2396 const_iv (GL_QUAD_STRIP),
1895 const_iv (GL_TRIANGLES), 2397 const_iv (GL_TRIANGLES),
1896 const_iv (GL_TRIANGLE_STRIP), 2398 const_iv (GL_TRIANGLE_STRIP),
1897 const_iv (GL_TRIANGLE_FAN), 2399 const_iv (GL_TRIANGLE_FAN),
2400 const_iv (GL_POLYGON),
1898 const_iv (GL_PERSPECTIVE_CORRECTION_HINT), 2401 const_iv (GL_PERSPECTIVE_CORRECTION_HINT),
2402 const_iv (GL_POINT_SMOOTH_HINT),
2403 const_iv (GL_LINE_SMOOTH_HINT),
2404 const_iv (GL_POLYGON_SMOOTH_HINT),
2405 const_iv (GL_GENERATE_MIPMAP_HINT),
1899 const_iv (GL_FASTEST), 2406 const_iv (GL_FASTEST),
2407 const_iv (GL_DONT_CARE),
2408 const_iv (GL_NICEST),
1900 const_iv (GL_V2F), 2409 const_iv (GL_V2F),
1901 const_iv (GL_V3F), 2410 const_iv (GL_V3F),
1902 const_iv (GL_T2F_V3F), 2411 const_iv (GL_T2F_V3F),
1903 const_iv (GL_T2F_N3F_V3F), 2412 const_iv (GL_T2F_N3F_V3F),
1904# undef const_iv 2413# undef const_iv
1905 }; 2414 };
1906 2415
1907 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 2416 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1908 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 2417 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
2418
2419 texture_av = newAV ();
2420 AvREAL_off (texture_av);
1909} 2421}
1910 2422
1911char * 2423char *
1912gl_vendor () 2424gl_vendor ()
1913 CODE: 2425 CODE:
… …
1927 CODE: 2439 CODE:
1928 RETVAL = (char *)glGetString (GL_EXTENSIONS); 2440 RETVAL = (char *)glGetString (GL_EXTENSIONS);
1929 OUTPUT: 2441 OUTPUT:
1930 RETVAL 2442 RETVAL
1931 2443
2444const char *glGetString (GLenum pname)
2445
2446GLint glGetInteger (GLenum pname)
2447 CODE:
2448 glGetIntegerv (pname, &RETVAL);
2449 OUTPUT:
2450 RETVAL
2451
2452GLdouble glGetDouble (GLenum pname)
2453 CODE:
2454 glGetDoublev (pname, &RETVAL);
2455 OUTPUT:
2456 RETVAL
2457
1932int glGetError () 2458int glGetError ()
1933 2459
1934void glFinish () 2460void glFinish ()
1935 2461
1936void glClear (int mask) 2462void glClear (int mask)
… …
1973# near_ and far_ are due to microsofts buggy "c" compiler 2499# near_ and far_ are due to microsofts buggy "c" compiler
1974void glFrustum (double left, double right, double bottom, double top, double near_, double far_) 2500void glFrustum (double left, double right, double bottom, double top, double near_, double far_)
1975 2501
1976# near_ and far_ are due to microsofts buggy "c" compiler 2502# near_ and far_ are due to microsofts buggy "c" compiler
1977void glOrtho (double left, double right, double bottom, double top, double near_, double far_) 2503void glOrtho (double left, double right, double bottom, double top, double near_, double far_)
2504
2505PROTOTYPES: DISABLE
1978 2506
1979void glViewport (int x, int y, int width, int height) 2507void glViewport (int x, int y, int width, int height)
1980 2508
1981void glScissor (int x, int y, int width, int height) 2509void glScissor (int x, int y, int width, int height)
1982 2510
… …
1990 2518
1991void glRotate (float angle, float x, float y, float z) 2519void glRotate (float angle, float x, float y, float z)
1992 CODE: 2520 CODE:
1993 glRotatef (angle, x, y, z); 2521 glRotatef (angle, x, y, z);
1994 2522
1995void glBegin (int mode)
1996
1997void glEnd ()
1998
1999void glColor (float r, float g, float b, float a = 1.0) 2523void glColor (float r, float g, float b, float a = 1.0)
2000 PROTOTYPE: @
2001 ALIAS: 2524 ALIAS:
2002 glColor_premultiply = 1 2525 glColor_premultiply = 1
2003 CODE: 2526 CODE:
2004 if (ix) 2527 if (ix)
2005 { 2528 {
2006 r *= a; 2529 r *= a;
2007 g *= a; 2530 g *= a;
2008 b *= a; 2531 b *= a;
2009 } 2532 }
2010 // microsoft visual "c" rounds instead of truncating... 2533 // microsoft visual "c" rounds instead of truncating...
2011 glColor4ub (MIN ((int)(r * 256.f), 255), 2534 glColor4f (r, g, b, a);
2012 MIN ((int)(g * 256.f), 255),
2013 MIN ((int)(b * 256.f), 255),
2014 MIN ((int)(a * 256.f), 255));
2015
2016void glInterleavedArrays (int format, int stride, char *data)
2017
2018void glDrawElements (int mode, int count, int type, char *indices)
2019
2020# 1.2 void glDrawRangeElements (int mode, int start, int end
2021 2535
2022void glRasterPos (float x, float y, float z = 0.) 2536void glRasterPos (float x, float y, float z = 0.)
2023 CODE: 2537 CODE:
2024 glRasterPos3f (0, 0, z); 2538 glRasterPos3f (0, 0, z);
2025 glBitmap (0, 0, 0, 0, x, y, 0); 2539 glBitmap (0, 0, 0, 0, x, y, 0);
… …
2030 2544
2031void glTexCoord (float s, float t) 2545void glTexCoord (float s, float t)
2032 CODE: 2546 CODE:
2033 glTexCoord2f (s, t); 2547 glTexCoord2f (s, t);
2034 2548
2549PROTOTYPES: ENABLE
2550
2551void glBegin (int mode)
2552
2553void glEnd ()
2554
2555void glPointSize (GLfloat size)
2556
2557void glLineWidth (GLfloat width)
2558
2559void glInterleavedArrays (int format, int stride, char *data)
2560
2561void glDrawElements (int mode, int count, int type, char *indices)
2562
2563# 1.2 void glDrawRangeElements (int mode, int start, int end
2564
2035void glTexEnv (int target, int pname, float param) 2565void glTexEnv (int target, int pname, float param)
2036 CODE: 2566 CODE:
2037 glTexEnvf (target, pname, param); 2567 glTexEnvf (target, pname, param);
2038 2568
2039void glTexParameter (int target, int pname, float param) 2569void glTexParameter (int target, int pname, float param)
… …
2061 2591
2062void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border) 2592void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
2063 2593
2064void glDrawPixels (int width, int height, int format, int type, char *pixels) 2594void glDrawPixels (int width, int height, int format, int type, char *pixels)
2065 2595
2596void glPixelZoom (float x, float y)
2597
2066void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR) 2598void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
2067 2599
2068int glGenTexture () 2600int glGenTexture ()
2069 CODE: 2601 CODE:
2070{ 2602 RETVAL = gen_texture ();
2071 GLuint name;
2072 glGenTextures (1, &name);
2073 RETVAL = name;
2074}
2075 OUTPUT: 2603 OUTPUT:
2076 RETVAL 2604 RETVAL
2077 2605
2078void glDeleteTexture (int name) 2606void glDeleteTexture (int name)
2079 CODE: 2607 CODE:
2080{
2081 GLuint name_ = name;
2082 glDeleteTextures (1, &name_); 2608 del_texture (name);
2083} 2609
2084
2085int glGenList () 2610int glGenList ()
2086 CODE: 2611 CODE:
2087 RETVAL = glGenLists (1); 2612 RETVAL = glGenLists (1);
2088 OUTPUT: 2613 OUTPUT:
2089 RETVAL 2614 RETVAL
… …
2096 2621
2097void glEndList () 2622void glEndList ()
2098 2623
2099void glCallList (int list) 2624void glCallList (int list)
2100 2625
2626MODULE = CFPlus PACKAGE = CFPlus::UI::Base
2101 2627
2628PROTOTYPES: DISABLE
2629
2630void
2631find_widget (SV *widget, NV x, NV y)
2632 PPCODE:
2633{
2634 if (within_widget (widget, x, y))
2635 XPUSHs (widget);
2636}
2637

Diff Legend

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