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.78 by root, Fri May 12 01:47:03 2006 UTC vs.
Revision 1.229 by root, Mon Aug 13 16:20:17 2007 UTC

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

Diff Legend

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