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

Diff Legend

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