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.113 by root, Wed Jun 14 16:20:21 2006 UTC vs.
Revision 1.235 by root, Tue Aug 28 01:23:47 2007 UTC

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

Diff Legend

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