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.41 by root, Sat Apr 15 01:52:53 2006 UTC vs.
Revision 1.209 by root, Sat Jul 21 22:54:52 2007 UTC

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

Diff Legend

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