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

Diff Legend

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