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.29 by root, Thu Apr 13 01:55:38 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
40#include <glib/gmacros.h>
41
12#include <pango/pango.h> 42#include <pango/pango.h>
13#include <pango/pangofc-fontmap.h>
14#include <pango/pangoft2.h>
15 43
44#ifndef _WIN32
16#include <sys/types.h> 45# include <sys/types.h>
17#include <sys/socket.h> 46# include <sys/socket.h>
18#include <netinet/in.h> 47# include <netinet/in.h>
19#include <netinet/tcp.h> 48# include <netinet/tcp.h>
20
21#include <inttypes.h> 49# include <inttypes.h>
50#endif
51
52#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
22 53
23#define FOW_DARKNESS 32 54#define FOW_DARKNESS 32
24 55
25#define MAP_EXTEND_X 32 56#define MAP_EXTEND_X 32
26#define MAP_EXTEND_Y 512 57#define MAP_EXTEND_Y 512
27 58
28static PangoContext *context; 59#define MIN_FONT_HEIGHT 10
29static 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}
30 139
31typedef struct cf_layout { 140typedef struct cf_layout {
32 PangoLayout *pl; 141 PangoLayout *pl;
142 float r, g, b, a; // default color for rgba mode
33 int base_height; 143 int base_height;
144 CFPlus__Font font;
34} *CFClient__Layout; 145} *CFPlus__Layout;
146
147static CFPlus__Font default_font;
148static PangoContext *opengl_context;
149static PangoFontMap *opengl_fontmap;
35 150
36static void 151static void
37substitute_func (FcPattern *pattern, gpointer data) 152substitute_func (FcPattern *pattern, gpointer data)
38{ 153{
39 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
40 FcPatternAddBool (pattern, FC_AUTOHINT, 1); 158 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
41} 159}
42 160
43static void 161static void
44layout_update (CFClient__Layout self) 162layout_update_font (CFPlus__Layout self)
45{ 163{
46 /* 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
47 * reasonably well with bitstream vera 165 * reasonably well with bitstream vera
48 */ 166 */
49 PangoFontDescription *font = pango_context_get_font_description (context); 167 PangoFontDescription *font = self->font ? self->font : default_font;
50 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);
51} 173}
52 174
53static void 175static void
54layout_get_pixel_size (CFClient__Layout self, int *w, int *h) 176layout_get_pixel_size (CFPlus__Layout self, int *w, int *h)
55{ 177{
56 layout_update (self); 178 PangoRectangle rect;
57 179
180 // get_pixel_* wrongly rounds down
58 pango_layout_get_pixel_size (self->pl, w, h); 181 pango_layout_get_extents (self->pl, 0, &rect);
59 182
60 *w = (*w + 3) & ~3; 183 rect.width = (rect.width + PANGO_SCALE - 1) / PANGO_SCALE;
61 if (!*w) *w = 1; 184 rect.height = (rect.height + PANGO_SCALE - 1) / PANGO_SCALE;
62 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;
63} 191}
192
193typedef uint16_t tileid;
194typedef uint16_t faceid;
64 195
65typedef struct { 196typedef struct {
197 int name;
198 int w, h;
199 float s, t;
200 uint8_t r, g, b, a;
201 tileid smoothtile;
202 uint8_t smoothlevel;
203} maptex;
204
205typedef struct {
206 uint32_t player;
207 tileid tile[3];
66 int16_t darkness; 208 uint16_t darkness;
67 uint16_t face[3]; 209 uint8_t stat_width, stat_hp, flags, smoothmax;
68} mapcell; 210} mapcell;
69 211
70typedef struct { 212typedef struct {
71 uint32_t c0, c1; 213 int32_t c0, c1;
72 mapcell *col; 214 mapcell *col;
73} maprow; 215} maprow;
74 216
75typedef struct map { 217typedef struct map {
76 int x, y, w, h; 218 int x, y, w, h;
77 int faces; 219 int ox, oy; /* offset to virtual global coordinate system */
78 GLint *face; 220 int faces; tileid *face2tile; // [faceid]
221 int texs; maptex *tex; // [tileid]
79 222
80 uint32_t rows; 223 int32_t rows;
81 maprow *row; 224 maprow *row;
82} *CFClient__Map; 225} *CFPlus__Map;
226
227static char *
228prepend (char *ptr, int sze, int inc)
229{
230 char *p;
231
232 New (0, p, sze + inc, char);
233 Zero (p, inc, char);
234 Move (ptr, p + inc, sze, char);
235 Safefree (ptr);
236
237 return p;
238}
239
240static char *
241append (char *ptr, int sze, int inc)
242{
243 Renew (ptr, sze + inc, char);
244 Zero (ptr + sze, inc, char);
245
246 return ptr;
247}
248
249#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((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))
83 251
84static 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
327map_clear (CFPlus__Map self)
328{
329 int r;
330
331 for (r = 0; r < self->rows; r++)
332 Safefree (self->row[r].col);
333
334 Safefree (self->row);
335
336 self->x = 0;
337 self->y = 0;
338 self->ox = 0;
339 self->oy = 0;
340 self->row = 0;
341 self->rows = 0;
342}
343
344static void
85map_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)
86{ 346{
87 int x, y; 347 int x, y;
348 maprow *row;
349 mapcell *cell;
88 350
89 for (y = y0; y < y0 + h; y++) 351 for (y = y0; y < y0 + h; y++)
352 if (y >= 0)
90 { 353 {
91 if (y >= self->rows) 354 if (y >= self->rows)
92 break; 355 break;
93 356
94 maprow *row = self->row + y; 357 row = self->row + y;
95 358
96 for (x = x0; x < x0 + w; x++) 359 for (x = x0; x < x0 + w; x++)
97 if (x >= row->c0) 360 if (x >= row->c0)
361 {
362 if (x >= row->c1)
363 break;
364
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;
371 }
372 }
373}
374
375typedef struct {
376 tileid tile;
377 uint8_t x, y, level;
378} smooth_key;
379
380static void
381smooth_or_bits (HV *hv, smooth_key *key, IV bits)
382{
383 SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1);
384
385 if (SvIOK (*sv))
386 SvIV_set (*sv, SvIVX (*sv) | bits);
387 else
388 sv_setiv (*sv, bits);
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
481MODULE = CFPlus PACKAGE = CFPlus
482
483PROTOTYPES: ENABLE
484
485BOOT:
486{
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 ();
632 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
633 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
634}
635
636char *
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)
647 PPCODE:
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)
98 { 706 {
99 if (x >= row->c1) 707 av_clear (texture_av);
100 break;
101 708
102 row->col[x].darkness = -1; 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
103 } 713 }
104 }
105} 714}
106
107MODULE = CFClient PACKAGE = CFClient
108
109PROTOTYPES: ENABLE
110
111BOOT:
112{
113 fontmap = pango_ft2_font_map_new ();
114 pango_ft2_font_map_set_default_substitute ((PangoFT2FontMap *)fontmap, substitute_func, 0, 0);
115 context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)fontmap);
116}
117
118void
119lowdelay (int fd, int val = 1)
120 CODE:
121 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val));
122
123char *
124gl_version ()
125 CODE:
126 RETVAL = (char *)glGetString (GL_VERSION);
127 OUTPUT: 715 OUTPUT:
128 RETVAL 716 RETVAL
129 717
718void
719SDL_GL_SwapBuffers ()
720
130char * 721char *
131gl_extensions () 722SDL_GetKeyName (int sym)
723
724int
725SDL_GetAppState ()
726
727void
728poll_events ()
132 CODE: 729 PPCODE:
133 RETVAL = (char *)glGetString (GL_EXTENSIONS); 730{
134 OUTPUT: 731 SDL_Event ev;
135 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}
136 849
137void 850void
138add_font (char *file) 851add_font (char *file)
139 CODE: 852 CODE:
140 FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */ 853 FcConfigAppFontAddFile (0, (const FcChar8 *)file);
141
142void
143set_font (char *file)
144 CODE:
145{
146 int count;
147 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)file, 0, 0, &count);
148 PangoFontDescription *font = pango_fc_font_description_from_pattern (pattern, 0);
149 FcPatternDestroy (pattern);
150 pango_context_set_font_description (context, font);
151}
152 854
153void 855void
154load_image_inline (SV *image_) 856load_image_inline (SV *image_)
155 ALIAS: 857 ALIAS:
156 load_image_file = 1 858 load_image_file = 1
… …
163 SDL_RWops *rw = ix 865 SDL_RWops *rw = ix
164 ? SDL_RWFromFile (image, "r") 866 ? SDL_RWFromFile (image, "r")
165 : SDL_RWFromConstMem (image, image_len); 867 : SDL_RWFromConstMem (image, image_len);
166 868
167 if (!rw) 869 if (!rw)
168 croak ("load_image: unable to open file"); 870 croak ("load_image: %s", SDL_GetError ());
169 871
170 surface = IMG_Load_RW (rw, 1); 872 surface = IMG_Load_RW (rw, 1);
171 if (!surface) 873 if (!surface)
172 croak ("load_image: unable to read file"); 874 croak ("load_image: %s", SDL_GetError ());
173 875
174 fmt.palette = NULL; 876 fmt.palette = NULL;
175 fmt.BitsPerPixel = 32; 877 fmt.BitsPerPixel = 32;
176 fmt.BytesPerPixel = 4; 878 fmt.BytesPerPixel = 4;
879#if SDL_BYTEORDER == SDL_LIL_ENDIAN
177 fmt.Rmask = 0x000000ff; 880 fmt.Rmask = 0x000000ff;
178 fmt.Gmask = 0x0000ff00; 881 fmt.Gmask = 0x0000ff00;
179 fmt.Bmask = 0x00ff0000; 882 fmt.Bmask = 0x00ff0000;
180 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
181 fmt.Rloss = 0; 890 fmt.Rloss = 0;
182 fmt.Gloss = 0; 891 fmt.Gloss = 0;
183 fmt.Bloss = 0; 892 fmt.Bloss = 0;
184 fmt.Aloss = 0; 893 fmt.Aloss = 0;
185 fmt.Rshift = 0; 894 fmt.Rshift = 0;
… …
189 fmt.colorkey = 0; 898 fmt.colorkey = 0;
190 fmt.alpha = 0; 899 fmt.alpha = 0;
191 900
192 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE); 901 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE);
193 902
903 assert (surface2->pitch == surface2->w * 4);
904
905 SDL_LockSurface (surface2);
194 EXTEND (SP, 5); 906 EXTEND (SP, 6);
195 PUSHs (sv_2mortal (newSViv (surface2->w))); 907 PUSHs (sv_2mortal (newSViv (surface2->w)));
196 PUSHs (sv_2mortal (newSViv (surface2->h))); 908 PUSHs (sv_2mortal (newSViv (surface2->h)));
197 SDL_LockSurface (surface2);
198 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 909 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));
199 SDL_UnlockSurface (surface2);
200 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)));
201 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 911 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
202 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_INT_8_8_8_8_REV))); 912 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
913 SDL_UnlockSurface (surface2);
203 914
204 SDL_FreeSurface (surface); 915 SDL_FreeSurface (surface);
205 SDL_FreeSurface (surface2); 916 SDL_FreeSurface (surface2);
206} 917}
207 918
208void 919void
920average (int x, int y, uint32_t *data)
921 PPCODE:
922{
923 uint32_t r = 0, g = 0, b = 0, a = 0;
924
925 x = y = x * y;
926
927 while (x--)
928 {
929 uint32_t p = *data++;
930
931 r += (p ) & 255;
932 g += (p >> 8) & 255;
933 b += (p >> 16) & 255;
934 a += (p >> 24) & 255;
935 }
936
937 EXTEND (SP, 4);
938 PUSHs (sv_2mortal (newSViv (r / y)));
939 PUSHs (sv_2mortal (newSViv (g / y)));
940 PUSHs (sv_2mortal (newSViv (b / y)));
941 PUSHs (sv_2mortal (newSViv (a / y)));
942}
943
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
209fatal (char *message) 953fatal (char *message)
210 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:
211#ifdef WIN32 964#ifdef WIN32
212 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND); 965 ExitThread (retval); // unclean, please beam me up
213#else 966#else
214 fprintf (stderr, "%s\n", message); 967 _exit (retval);
215#endif 968#endif
216 exit (1);
217 969
218MODULE = CFClient PACKAGE = CFClient::Layout 970void
219 971debug ()
220CFClient::Layout
221new (SV *class, int base_height = 10)
222 CODE: 972 CODE:
223 New (0, RETVAL, 1, struct cf_layout); 973{
224 RETVAL->base_height = base_height; 974#if DEBUG
225 RETVAL->pl = pango_layout_new (context); 975 VALGRIND_DO_LEAK_CHECK;
226 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}
227 OUTPUT: 992 OUTPUT:
228 RETVAL 993 RETVAL
229 994
230void 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
231DESTROY (CFClient::Layout self) 1035DESTROY (CFPlus::Layout self)
232 CODE: 1036 CODE:
233 g_object_unref (self->pl); 1037 g_object_unref (self->pl);
234 Safefree (self); 1038 Safefree (self);
235 1039
236void 1040void
237set_markup (CFClient::Layout self, SV *text_) 1041set_text (CFPlus::Layout self, SV *text_)
238 CODE: 1042 CODE:
239{ 1043{
240 STRLEN textlen; 1044 STRLEN textlen;
241 char *text = SvPVutf8 (text_, textlen); 1045 char *text = SvPVutf8 (text_, textlen);
242 1046
1047 pango_layout_set_text (self->pl, text, textlen);
1048}
1049
1050void
1051set_markup (CFPlus::Layout self, SV *text_)
1052 CODE:
1053{
1054 STRLEN textlen;
1055 char *text = SvPVutf8 (text_, textlen);
1056
243 pango_layout_set_markup (self->pl, text, textlen); 1057 pango_layout_set_markup (self->pl, text, textlen);
244} 1058}
245 1059
246void 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
247set_height (CFClient::Layout self, int base_height) 1171set_height (CFPlus::Layout self, int base_height)
248 CODE: 1172 CODE:
1173 if (self->base_height != base_height)
1174 {
249 self->base_height = base_height; 1175 self->base_height = base_height;
1176 layout_update_font (self);
1177 }
250 1178
251void 1179void
252set_width (CFClient::Layout self, int max_width = -1) 1180set_width (CFPlus::Layout self, int max_width = -1)
253 CODE: 1181 CODE:
254 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);
255 1183
256void 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
257size (CFClient::Layout self) 1210size (CFPlus::Layout self)
258 PPCODE: 1211 PPCODE:
259{ 1212{
260 int w, h; 1213 int w, h;
261 1214
262 layout_update (self);
263 layout_get_pixel_size (self, &w, &h); 1215 layout_get_pixel_size (self, &w, &h);
264 1216
265 EXTEND (SP, 2); 1217 EXTEND (SP, 2);
266 PUSHs (sv_2mortal (newSViv (w))); 1218 PUSHs (sv_2mortal (newSViv (w)));
267 PUSHs (sv_2mortal (newSViv (h))); 1219 PUSHs (sv_2mortal (newSViv (h)));
268} 1220}
269 1221
270int 1222int
271xy_to_index (CFClient::Layout self, int x, int y) 1223descent (CFPlus::Layout self)
272 CODE: 1224 CODE:
273{ 1225{
274 int index, trailing; 1226 PangoRectangle rect;
275 1227 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0);
276 layout_update (self); 1228 pango_layout_line_get_pixel_extents (line, 0, &rect);
277 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing); 1229 RETVAL = PANGO_DESCENT (rect);
278
279 RETVAL = index;
280} 1230}
281 OUTPUT: 1231 OUTPUT:
282 RETVAL 1232 RETVAL
283 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
284void 1245void
285cursor_pos (CFClient::Layout self, int index) 1246cursor_pos (CFPlus::Layout self, int index)
286 PPCODE: 1247 PPCODE:
287{ 1248{
288 PangoRectangle strong_pos; 1249 PangoRectangle strong_pos;
289 layout_update (self);
290 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1250 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);
1251
291 EXTEND (SP, 3); 1252 EXTEND (SP, 3);
292 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1253 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));
293 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1254 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
294 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1255 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));
295} 1256}
296 1257
297void 1258void
298render (CFClient::Layout self) 1259index_to_line_x (CFPlus::Layout self, int index, int trailing = 0)
299 PPCODE: 1260 PPCODE:
300{ 1261{
301 SV *retval; 1262 int line, x;
302 int w, h;
303 FT_Bitmap bitmap;
304 1263
305 layout_update (self); 1264 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
306 layout_get_pixel_size (self, &w, &h); 1265 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
307 1266
308 retval = newSV (w * h);
309 SvPOK_only (retval);
310 SvCUR_set (retval, w * h);
311
312 bitmap.rows = h;
313 bitmap.width = w;
314 bitmap.pitch = w;
315 bitmap.buffer = (unsigned char*)SvPVX (retval);
316 bitmap.num_grays = 256;
317 bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
318
319 memset (bitmap.buffer, 0, w * h);
320
321 pango_ft2_render_layout (&bitmap, self->pl, 0 * PANGO_SCALE, 0 * PANGO_SCALE);
322
323 EXTEND (SP, 3); 1267 EXTEND (SP, 2);
324 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 {
325 PUSHs (sv_2mortal (newSViv (h))); 1292 PUSHs (sv_2mortal (newSViv (index)));
326 PUSHs (sv_2mortal (retval)); 1293 PUSHs (sv_2mortal (newSViv (trailing)));
1294 }
327} 1295}
328 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
329MODULE = CFClient PACKAGE = CFClient::Texture 1307MODULE = CFPlus PACKAGE = CFPlus::Texture
330 1308
1309PROTOTYPES: ENABLE
1310
1311int minpot (int n)
1312
331void 1313void
332draw_quad (SV *self, double x, double y, double w = 0, double h = 0) 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
1336draw_quad (SV *self, float x, float y, float w = 0., float h = 0.)
333 PROTOTYPE: $$$;$$ 1337 PROTOTYPE: $$$;$$
1338 ALIAS:
1339 draw_quad_alpha = 1
1340 draw_quad_alpha_premultiplied = 2
334 CODE: 1341 CODE:
335{ 1342{
336 HV *hv = (HV *)SvRV (self); 1343 HV *hv = (HV *)SvRV (self);
337 double s = SvNV (*hv_fetch (hv, "s", 1, 1)); 1344 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
338 double t = SvNV (*hv_fetch (hv, "t", 1, 1)); 1345 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
339 int name = SvIV (*hv_fetch (hv, "name", 4, 1)); 1346 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
340 1347
341 if (items < 5) 1348 if (items < 5)
342 { 1349 {
343 w = SvNV (*hv_fetch (hv, "w", 1, 1)); 1350 w = SvNV (*hv_fetch (hv, "w", 1, 1));
344 h = SvNV (*hv_fetch (hv, "h", 1, 1)); 1351 h = SvNV (*hv_fetch (hv, "h", 1, 1));
345 } 1352 }
346 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
347 glBindTexture (GL_TEXTURE_2D, name); 1368 glBindTexture (GL_TEXTURE_2D, name);
1369
348 glBegin (GL_QUADS); 1370 glBegin (GL_QUADS);
349 glTexCoord2d (0, 0); glVertex2d (x , y ); 1371 glTexCoord2f (0, 0); glVertex2f (x , y );
350 glTexCoord2d (0, t); glVertex2d (x , y + h); 1372 glTexCoord2f (0, t); glVertex2f (x , y + h);
351 glTexCoord2d (s, t); glVertex2d (x + w, y + h); 1373 glTexCoord2f (s, t); glVertex2f (x + w, y + h);
352 glTexCoord2d (s, 0); glVertex2d (x + w, y ); 1374 glTexCoord2f (s, 0); glVertex2f (x + w, y );
353 glEnd (); 1375 glEnd ();
354}
355 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
356MODULE = CFClient PACKAGE = CFClient::Map 1395MODULE = CFPlus PACKAGE = CFPlus::Map
357 1396
358CFClient::Map 1397PROTOTYPES: DISABLE
359new (SV *class, int map_width, int map_height) 1398
1399CFPlus::Map
1400new (SV *class)
360 CODE: 1401 CODE:
361 New (0, RETVAL, 1, struct map); 1402 New (0, RETVAL, 1, struct map);
362 RETVAL->x = 0; 1403 RETVAL->x = 0;
363 RETVAL->y = 0; 1404 RETVAL->y = 0;
364 RETVAL->w = map_width;
365 RETVAL->h = map_height;
366 RETVAL->faces = 1; 1405 RETVAL->w = 0;
367 Newz (0, RETVAL->face, 1, GLint); 1406 RETVAL->h = 0;
1407 RETVAL->ox = 0;
1408 RETVAL->oy = 0;
1409 RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
1410 RETVAL->texs = 8192; Newz (0, RETVAL->tex , RETVAL->texs , maptex);
368 RETVAL->rows = 0; 1411 RETVAL->rows = 0;
369 RETVAL->row = 0; 1412 RETVAL->row = 0;
370 printf ("new map %d,%d\n", map_width, map_height);//D
371 OUTPUT: 1413 OUTPUT:
372 RETVAL 1414 RETVAL
373 1415
374void 1416void
375DESTROY (CFClient::Map self) 1417DESTROY (CFPlus::Map self)
376 CODE: 1418 CODE:
377{ 1419{
378 int r, c; 1420 map_clear (self);
379
380 printf ("detroy map\n");//D
381 Safefree (self->face); 1421 Safefree (self->face2tile);
382
383 for (r = 0; r < self->rows; r++)
384 Safefree (self->row[r].col);
385
386 Safefree (self->row); 1422 Safefree (self->tex);
387 Safefree (self); 1423 Safefree (self);
388} 1424}
389 1425
390void 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
1433clear (CFPlus::Map self)
1434 CODE:
1435 map_clear (self);
1436
1437void
391set_face (CFClient::Map self, int facenum, int face) 1438set_tileid (CFPlus::Map self, int face, int tile)
392 CODE: 1439 CODE:
393{ 1440{
394 while (self->faces < facenum) 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
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)
1470 CODE:
1471{
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)
395 { 1508 {
396 printf ("setface %d (%d) = %d\n",facenum, self->faces, face);//D 1509 case 0: RETVAL = self->ox; break;
397 Renew (self->face, self->faces * 2, GLint); 1510 case 1: RETVAL = self->oy; break;
398 Zero (self->face + self->faces, self->faces, GLint); 1511 case 2: RETVAL = self->x; break;
399 self->faces *= 2; 1512 case 3: RETVAL = self->y; break;
1513 case 4: RETVAL = self->w; break;
1514 case 5: RETVAL = self->h; break;
400 } 1515 }
1516 OUTPUT:
1517 RETVAL
401 1518
402 self->face [facenum] = face;
403}
404
405void 1519void
406scroll (CFClient::Map self, int dx, int dy) 1520scroll (CFPlus::Map self, int dx, int dy)
407 CODE: 1521 CODE:
408{ 1522{
409 printf ("map_scroll %d,%d\n", dx, dy);//D
410 if (dx > 0) 1523 if (dx > 0)
411 map_blank (self, self->x, self->y, dx - 1, self->h); 1524 map_blank (self, self->x, self->y, dx, self->h);
412 else if (dx < 0) 1525 else if (dx < 0)
413 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);
414 1527
415 if (dy > 0) 1528 if (dy > 0)
416 map_blank (self, self->x, self->y, self->w, dy - 1); 1529 map_blank (self, self->x, self->y, self->w, dy);
417 else if (dy < 0) 1530 else if (dy < 0)
418 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);
419 1532
420 self->x += dx; 1533 self->ox += dx; self->x += dx;
421 self->y += dy; 1534 self->oy += dy; self->y += dy;
422 1535
423 while (self->y < 0) 1536 while (self->y < 0)
424 { 1537 {
425 maprow *row; 1538 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
426
427 New (0, row, self->rows + MAP_EXTEND_Y, maprow);
428 Move (self->row, row + MAP_EXTEND_Y, self->rows, maprow);
429 Zero (row, MAP_EXTEND_Y, maprow);
430 1539
431 self->rows += MAP_EXTEND_Y; 1540 self->rows += MAP_EXTEND_Y;
432 self->y += MAP_EXTEND_Y; 1541 self->y += MAP_EXTEND_Y;
433 self->row = row;
434 } 1542 }
1543}
435 1544
436 if (self->x < 0) 1545void
1546map1a_update (CFPlus::Map self, SV *data_, int extmap)
1547 CODE:
1548{
1549 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1550 uint8_t *data_end = (uint8_t *)SvEND (data_);
1551 mapcell *cell;
1552 int x, y, flags;
1553
1554 while (data < data_end - 1)
437 { 1555 {
438 int y;
439 for (y = 0; y < self->rows; y++)
440 {
441 self->row[y].c0 += self->x;
442 self->row[y].c1 += self->x;
443 }
444
445 self->x = 0;
446 }
447}
448
449void
450map1a_update (CFClient::Map self, SV *data_)
451 CODE:
452{
453 uint8_t *data = (uint8_t *)SvPVbytes_nolen (data_);
454 uint8_t *data_end = (uint8_t *)SvEND (data_) + 1;
455
456 while (data < data_end)
457 {
458 int flags = (data [0] << 8) + data [1]; data += 2; 1556 flags = (data [0] << 8) + data [1]; data += 2;
459 int x = ((flags >> 10) & 63) + self->x;
460 int y = ((flags >> 4) & 63) + self->y;
461
462 while (y >= self->rows)
463 { 1557
464 Renew (self->row, self->rows + MAP_EXTEND_Y, maprow); 1558 x = self->x + ((flags >> 10) & 63);
465 Zero (self->row + self->rows, MAP_EXTEND_Y, maprow); 1559 y = self->y + ((flags >> 4) & 63);
466 1560
467 self->rows += MAP_EXTEND_Y; 1561 cell = map_get_cell (self, x, y);
468 }
469
470 assert (y < self->rows);//D
471
472 maprow *row = self->row + y;
473
474 if (!row->col)
475 {
476 Newz (0, row->col, MAP_EXTEND_X, mapcell);
477 row->c0 = self->x - MAP_EXTEND_X / 4;
478 row->c1 = row->c0 + MAP_EXTEND_X;
479 }
480
481 if (row->c0 > x)
482 {
483 int extend = row->c0 - x + MAP_EXTEND_X;
484 mapcell *col;
485
486 New (0, col, row->c1 - row->c0 + extend, mapcell);
487 Move (row->col, col + extend, row->c1 - row->c0, mapcell);
488 Zero (col, extend, mapcell);
489
490 row->col = col;
491 row->c0 -= extend;
492 }
493 else if (x >= row->c1)
494 {
495 int extend = x - row->c1 + MAP_EXTEND_X;
496
497 Renew (row->col, row->c1 - row->c0 + extend, mapcell);
498 Zero (row->col + row->c1 - row->c0, extend, mapcell);
499
500 row->c1 += extend;
501 }
502
503 assert (x >= row->c0);//D
504 assert (x < row->c1);//D
505 mapcell *cell = row->col + (x - row->c0);
506 1562
507 if (flags & 15) 1563 if (flags & 15)
508 { 1564 {
509 if (cell->darkness < 0) 1565 if (!cell->darkness)
510 { 1566 {
1567 memset (cell, 0, sizeof (*cell));
511 cell->darkness = 0; 1568 cell->darkness = 256;
512 cell->face [0] = 0;
513 cell->face [1] = 0;
514 cell->face [2] = 0;
515 } 1569 }
1570
1571 //TODO: don't trust server data to be in-range(!)
1572
1573 if (flags & 8)
516 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
517 cell->darkness = flags & 8 ? *data++ : 255; 1610 cell->darkness = *data++ + 1;
1611 }
518 1612
519 if (flags & 4) 1613 if (flags & 4)
520 { 1614 {
521 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];
522 } 1618 }
523 1619
524 if (flags & 2) 1620 if (flags & 2)
525 { 1621 {
526 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];
527 } 1625 }
528 1626
529 if (flags & 1) 1627 if (flags & 1)
530 { 1628 {
531 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];
532 } 1632 }
533 } 1633 }
534 else 1634 else
535 cell->darkness = -1; 1635 cell->darkness = 0;
536 } 1636 }
537} 1637}
538 1638
1639SV *
1640mapmap (CFPlus::Map self, int x0, int y0, int w, int h)
1641 CODE:
1642{
1643 int x1, x;
1644 int y1, y;
1645 int z;
1646 SV *map_sv = newSV (w * h * sizeof (uint32_t));
1647 uint32_t *map = (uint32_t *)SvPVX (map_sv);
1648
1649 SvPOK_only (map_sv);
1650 SvCUR_set (map_sv, w * h * sizeof (uint32_t));
1651
1652 x0 += self->x; x1 = x0 + w;
1653 y0 += self->y; y1 = y0 + h;
1654
1655 for (y = y0; y < y1; y++)
1656 {
1657 maprow *row = 0 <= y && y < self->rows
1658 ? self->row + y
1659 : 0;
1660
1661 for (x = x0; x < x1; x++)
1662 {
1663 int r = 32, g = 32, b = 32, a = 192;
1664
1665 if (row && row->c0 <= x && x < row->c1)
1666 {
1667 mapcell *cell = row->col + (x - row->c0);
1668
1669 for (z = 0; z <= 0; z++)
1670 {
1671 maptex tex = self->tex [cell->tile [z]];
1672 int a0 = 255 - tex.a;
1673 int a1 = tex.a;
1674
1675 r = (r * a0 + tex.r * a1) / 255;
1676 g = (g * a0 + tex.g * a1) / 255;
1677 b = (b * a0 + tex.b * a1) / 255;
1678 a = (a * a0 + tex.a * a1) / 255;
1679 }
1680 }
1681
1682 *map++ = (r )
1683 | (g << 8)
1684 | (b << 16)
1685 | (a << 24);
1686 }
1687 }
1688
1689 RETVAL = map_sv;
1690}
1691 OUTPUT:
1692 RETVAL
1693
1694void
1695draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T)
1696 CODE:
1697{
1698 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1699 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
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;
1704
1705 // thats current max. sorry.
1706 if (sw > 255) sw = 255;
1707 if (sh > 255) sh = 255;
1708
1709 // clear key, in case of extra padding
1710 memset (&skey, 0, sizeof (skey));
1711
1712 glColor4ub (255, 255, 255, 255);
1713
1714 glEnable (GL_BLEND);
1715 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1716 glEnable (GL_TEXTURE_2D);
1717 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1718
1719 glBegin (GL_QUADS);
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
1748 for (z = 0; z <= 2; z++)
1749 {
1750 memset (smooth_level, 0, sizeof (smooth_level));
1751
1752 for (y = 0; y < sh; y++)
1753 if (0 <= y + my && y + my < self->rows)
1754 {
1755 maprow *row = self->row + (y + my);
1756
1757 for (x = 0; x < sw; x++)
1758 if (row->c0 <= x + mx && x + mx < row->c1)
1759 {
1760 mapcell *cell = row->col + (x + mx - row->c0);
1761 tileid tile = cell->tile [z];
1762
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))
1858 {
1859 int level = (w << 5) | b;
1860 HE *he;
1861
1862 hv_iterinit (smooth);
1863 while ((he = hv_iternext (smooth)))
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
1887 glEnd ();
1888 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
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 }
1912 }
1913 }
1914 }
1915 }
1916
1917 hv_clear (smooth);
1918 }
1919
1920 glEnd ();
1921
1922 glDisable (GL_TEXTURE_2D);
1923 glDisable (GL_BLEND);
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
2092 EXTEND (SP, 3);
2093 PUSHs (sv_2mortal (newSViv (sw34)));
2094 PUSHs (sv_2mortal (newSViv (sh3)));
2095 PUSHs (darkness3_sv);
2096}
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