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

Diff Legend

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