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.50 by root, Wed Apr 19 00:47:34 2006 UTC vs.
Revision 1.249 by root, Fri Dec 28 15:40:07 2007 UTC

1#ifdef _WIN32 1#ifdef _WIN32
2# define WIN32_LEAN_AND_MEAN
3# define NTDDI_VERSION NTDDI_WIN2K // needed to get win2000 api calls
2# include <malloc.h> 4# include <malloc.h>
5# include <windows.h>
6# include <wininet.h>
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>
3#endif 14#endif
4 15
5#include "EXTERN.h" 16#include "EXTERN.h"
6#include "perl.h" 17#include "perl.h"
7#include "XSUB.h" 18#include "XSUB.h"
8 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>
9#include <string.h> 31#include <string.h>
10#include <stdio.h> 32#include <stdio.h>
33#include <stdlib.h>
34
35#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
11 36
12#include <SDL.h> 37#include <SDL.h>
38#include <SDL_thread.h>
39#include <SDL_endian.h>
13#include <SDL_image.h> 40#include <SDL_image.h>
41#include <SDL_mixer.h>
14#include <SDL_opengl.h> 42#include <SDL_opengl.h>
15 43
44#define PANGO_ENABLE_BACKEND
45#define G_DISABLE_CAST_CHECKS
46
16#include <glib/gmacros.h> 47#include <glib/gmacros.h>
17 48
18#include <pango/pango.h> 49#include <pango/pango.h>
19#include <pango/pangofc-fontmap.h> 50
20#include <pango/pangoft2.h> 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
21 57
22#ifndef _WIN32 58#ifndef _WIN32
23# include <sys/types.h> 59# include <sys/types.h>
24# include <sys/socket.h> 60# include <sys/socket.h>
25# include <netinet/in.h> 61# include <netinet/in.h>
26# include <netinet/tcp.h> 62# include <netinet/tcp.h>
27# include <inttypes.h> 63# include <inttypes.h>
28#else
29 typedef unsigned char uint8_t;
30 typedef unsigned short uint16_t;
31 typedef unsigned int uint32_t;
32 typedef signed char int8_t;
33 typedef signed short int16_t;
34 typedef signed int int32_t;
35#endif 64#endif
65
66#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
36 67
37#define FOW_DARKNESS 32 68#define FOW_DARKNESS 32
38 69
39#define MAP_EXTEND_X 32 70#define MAP_EXTEND_X 32
40#define MAP_EXTEND_Y 512 71#define MAP_EXTEND_Y 512
41 72
42static PangoContext *context; 73#define MIN_FONT_HEIGHT 10
43static 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}
44 156
45typedef struct cf_layout { 157typedef struct cf_layout {
46 PangoLayout *pl; 158 PangoLayout *pl;
159 float r, g, b, a; // default color for rgba mode
47 int base_height; 160 int base_height;
161 DC__Font font;
162 rc_t *rc;
48} *CFClient__Layout; 163} *DC__Layout;
164
165static DC__Font default_font;
166static PangoContext *opengl_context;
167static PangoFontMap *opengl_fontmap;
49 168
50static void 169static void
51substitute_func (FcPattern *pattern, gpointer data) 170substitute_func (FcPattern *pattern, gpointer data)
52{ 171{
53 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
54 FcPatternAddBool (pattern, FC_AUTOHINT, 0); 176 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
55} 177}
56 178
57static void 179static void
58layout_update (CFClient__Layout self) 180layout_update_font (DC__Layout self)
59{ 181{
60 /* 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
61 * reasonably well with bitstream vera 183 * reasonably well with bitstream vera
62 */ 184 */
63 PangoFontDescription *font = pango_context_get_font_description (context); 185 PangoFontDescription *font = self->font ? self->font : default_font;
64 186
65 int height = self->base_height * (PANGO_SCALE * 8 / 10);
66
67 if (pango_font_description_get_size (font) != height)
68 {
69 pango_font_description_set_absolute_size (font, height); 187 pango_font_description_set_absolute_size (font,
70 pango_layout_context_changed (self->pl); 188 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
71 } 189
190 pango_layout_set_font_description (self->pl, font);
72} 191}
73 192
74static void 193static void
75layout_get_pixel_size (CFClient__Layout self, int *w, int *h) 194layout_get_pixel_size (DC__Layout self, int *w, int *h)
76{ 195{
77 layout_update (self); 196 PangoRectangle rect;
78 197
198 // get_pixel_* wrongly rounds down
79 pango_layout_get_pixel_size (self->pl, w, h); 199 pango_layout_get_extents (self->pl, 0, &rect);
80 200
81 *w = (*w + 3) & ~3; 201 rect.width = (rect.width + PANGO_SCALE - 1) / PANGO_SCALE;
82 if (!*w) *w = 1; 202 rect.height = (rect.height + PANGO_SCALE - 1) / PANGO_SCALE;
83 if (!*h) *h = 1;
84}
85 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;
86typedef uint16_t mapface; 212typedef uint16_t faceid;
87 213
88typedef struct { 214typedef struct {
89 GLint name; 215 GLuint name;
90 int w, h; 216 int w, h;
91 float s, t; 217 float s, t;
92 uint8_t r, g, b, a; 218 uint8_t r, g, b, a;
219 tileid smoothtile;
220 uint8_t smoothlevel;
93} maptex; 221} maptex;
94 222
95typedef struct { 223typedef struct {
224 uint32_t player;
225 tileid tile[3];
96 int16_t darkness; 226 uint16_t darkness;
97 mapface face[3]; 227 uint8_t stat_width, stat_hp, flags, smoothmax;
98} mapcell; 228} mapcell;
99 229
100typedef struct { 230typedef struct {
101 int32_t c0, c1; 231 int32_t c0, c1;
102 mapcell *col; 232 mapcell *col;
103} maprow; 233} maprow;
104 234
105typedef struct map { 235typedef struct map {
106 int x, y, w, h; 236 int x, y, w, h;
107 int ox, oy; /* offset to virtual global coordinate system */ 237 int ox, oy; /* offset to virtual global coordinate system */
108 int faces; 238 int faces; tileid *face2tile; // [faceid]
109 mapface *face; 239 int texs; maptex *tex; // [tileid]
110
111 int texs;
112 maptex *tex;
113 240
114 int32_t rows; 241 int32_t rows;
115 maprow *row; 242 maprow *row;
116} *CFClient__Map; 243} *DC__Map;
117 244
118static char * 245static char *
119prepend (char *ptr, int sze, int inc) 246prepend (char *ptr, int sze, int inc)
120{ 247{
121 char *p; 248 char *p;
… …
138} 265}
139 266
140#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))
141#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))
142 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
143static maprow * 290static maprow *
144map_get_row (CFClient__Map self, int y) 291map_get_row (DC__Map self, int y)
145{ 292{
146 if (0 > y) 293 if (0 > y)
147 { 294 {
148 int extend = - y + MAP_EXTEND_Y; 295 int extend = - y + MAP_EXTEND_Y;
149 Prepend (maprow, self->row, self->rows, extend); 296 Prepend (maprow, self->row, self->rows, extend);
… …
187 334
188 return row->col + (x - row->c0); 335 return row->col + (x - row->c0);
189} 336}
190 337
191static mapcell * 338static mapcell *
192map_get_cell (CFClient__Map self, int x, int y) 339map_get_cell (DC__Map self, int x, int y)
193{ 340{
194 return row_get_cell (map_get_row (self, y), x); 341 return row_get_cell (map_get_row (self, y), x);
195} 342}
196 343
197static void 344static void
198map_clear (CFClient__Map self) 345map_clear (DC__Map self)
199{ 346{
200 int r; 347 int r;
201 348
202 for (r = 0; r < self->rows; r++) 349 for (r = 0; r < self->rows; r++)
203 Safefree (self->row[r].col); 350 Safefree (self->row[r].col);
… …
211 self->row = 0; 358 self->row = 0;
212 self->rows = 0; 359 self->rows = 0;
213} 360}
214 361
215static void 362static void
216map_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)
217{ 364{
218 int x, y; 365 int x, y;
219 maprow *row; 366 maprow *row;
367 mapcell *cell;
220 368
221 for (y = y0; y < y0 + h; y++) 369 for (y = y0; y < y0 + h; y++)
222 if (y >= 0) 370 if (y >= 0)
223 { 371 {
224 if (y >= self->rows) 372 if (y >= self->rows)
… …
230 if (x >= row->c0) 378 if (x >= row->c0)
231 { 379 {
232 if (x >= row->c1) 380 if (x >= row->c1)
233 break; 381 break;
234 382
235 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;
236 } 389 }
237 } 390 }
238} 391}
239 392
240MODULE = 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
241 511
242PROTOTYPES: ENABLE 512PROTOTYPES: ENABLE
243 513
244BOOT: 514BOOT:
245{ 515{
246 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 ();
247 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);
248 context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)fontmap); 670 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
249} 671#if defined (PANGO_VERSION_CHECK) && PANGO_VERSION_CHECK (1, 15, 2)
250 672 pango_context_set_language (opengl_context, pango_language_from_string ("en"));
251void 673 pango_context_set_base_dir (opengl_context, PANGO_DIRECTION_WEAK_LTR);
252lowdelay (int fd, int val = 1)
253 CODE:
254#ifndef _WIN32
255 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val));
256#endif 674#endif
675}
257 676
258char * 677char *
259gl_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)
260 CODE: 688 PPCODE:
261 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}
262 OUTPUT: 756 OUTPUT:
263 RETVAL 757 RETVAL
264 758
759void
760SDL_GL_SwapBuffers ()
761
265char * 762char *
266gl_extensions () 763SDL_GetKeyName (int sym)
764
765int
766SDL_GetAppState ()
767
768void
769poll_events ()
267 CODE: 770 PPCODE:
268 RETVAL = (char *)glGetString (GL_EXTENSIONS); 771{
269 OUTPUT: 772 SDL_Event ev;
270 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}
271 909
272void 910void
273add_font (char *file) 911add_font (char *file)
274 CODE: 912 CODE:
275 FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */ 913 FcConfigAppFontAddFile (0, (const FcChar8 *)file);
276
277void
278set_font (char *file)
279 CODE:
280{
281 int count;
282 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)file, 0, 0, &count);
283 PangoFontDescription *font = pango_fc_font_description_from_pattern (pattern, 0);
284 FcPatternDestroy (pattern);
285 pango_context_set_font_description (context, font);
286}
287 914
288void 915void
289load_image_inline (SV *image_) 916load_image_inline (SV *image_)
290 ALIAS: 917 ALIAS:
291 load_image_file = 1 918 load_image_file = 1
… …
294 STRLEN image_len; 921 STRLEN image_len;
295 char *image = (char *)SvPVbyte (image_, image_len); 922 char *image = (char *)SvPVbyte (image_, image_len);
296 SDL_Surface *surface, *surface2; 923 SDL_Surface *surface, *surface2;
297 SDL_PixelFormat fmt; 924 SDL_PixelFormat fmt;
298 SDL_RWops *rw = ix 925 SDL_RWops *rw = ix
299 ? SDL_RWFromFile (image, "r") 926 ? SDL_RWFromFile (image, "rb")
300 : SDL_RWFromConstMem (image, image_len); 927 : SDL_RWFromConstMem (image, image_len);
301 928
302 if (!rw) 929 if (!rw)
303 croak ("load_image: %s", SDL_GetError ()); 930 croak ("load_image: %s", SDL_GetError ());
304 931
… …
333 960
334 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE); 961 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE);
335 962
336 assert (surface2->pitch == surface2->w * 4); 963 assert (surface2->pitch == surface2->w * 4);
337 964
965 SDL_LockSurface (surface2);
338 EXTEND (SP, 5); 966 EXTEND (SP, 6);
339 PUSHs (sv_2mortal (newSViv (surface2->w))); 967 PUSHs (sv_2mortal (newSViv (surface2->w)));
340 PUSHs (sv_2mortal (newSViv (surface2->h))); 968 PUSHs (sv_2mortal (newSViv (surface2->h)));
341 SDL_LockSurface (surface2);
342 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 969 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));
343 SDL_UnlockSurface (surface2);
344 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)));
345 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 971 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
346 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE))); 972 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
973 SDL_UnlockSurface (surface2);
347 974
348 SDL_FreeSurface (surface); 975 SDL_FreeSurface (surface);
349 SDL_FreeSurface (surface2); 976 SDL_FreeSurface (surface2);
350} 977}
351 978
… …
373 PUSHs (sv_2mortal (newSViv (b / y))); 1000 PUSHs (sv_2mortal (newSViv (b / y)));
374 PUSHs (sv_2mortal (newSViv (a / y))); 1001 PUSHs (sv_2mortal (newSViv (a / y)));
375} 1002}
376 1003
377void 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
378fatal (char *message) 1013fatal (char *message)
379 CODE: 1014 CODE:
1015 fprintf (stderr, "FATAL: %s\n", message);
380#ifdef _WIN32 1016#ifdef _WIN32
381 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND); 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:
1024#ifdef WIN32
1025 ExitThread (retval); // unclean, please beam me up
382#else 1026#else
383 fprintf (stderr, "FATAL: %s\n", message); 1027 _exit (retval);
384#endif 1028#endif
385 exit (1);
386 1029
387MODULE = CFClient PACKAGE = CFClient::Layout 1030void
388 1031debug ()
389CFClient::Layout
390new (SV *class, int base_height = 10)
391 CODE: 1032 CODE:
392 New (0, RETVAL, 1, struct cf_layout); 1033{
393 RETVAL->base_height = base_height; 1034#if DEBUG
394 RETVAL->pl = pango_layout_new (context); 1035 VALGRIND_DO_LEAK_CHECK;
395 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}
396 OUTPUT: 1052 OUTPUT:
397 RETVAL 1053 RETVAL
398 1054
399void 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
400DESTROY (CFClient::Layout self) 1102DESTROY (DC::Layout self)
401 CODE: 1103 CODE:
402 g_object_unref (self->pl); 1104 g_object_unref (self->pl);
1105 rc_free (self->rc);
403 Safefree (self); 1106 Safefree (self);
404 1107
405void 1108void
406set_text (CFClient::Layout self, SV *text_) 1109set_text (DC::Layout self, SV *text_)
407 CODE: 1110 CODE:
408{ 1111{
409 STRLEN textlen; 1112 STRLEN textlen;
410 char *text = SvPVutf8 (text_, textlen); 1113 char *text = SvPVutf8 (text_, textlen);
411 1114
412 pango_layout_set_text (self->pl, text, textlen); 1115 pango_layout_set_text (self->pl, text, textlen);
413} 1116}
414 1117
415void 1118void
416set_markup (CFClient::Layout self, SV *text_) 1119set_markup (DC::Layout self, SV *text_)
417 CODE: 1120 CODE:
418{ 1121{
419 STRLEN textlen; 1122 STRLEN textlen;
420 char *text = SvPVutf8 (text_, textlen); 1123 char *text = SvPVutf8 (text_, textlen);
421 1124
422 pango_layout_set_markup (self->pl, text, textlen); 1125 pango_layout_set_markup (self->pl, text, textlen);
423} 1126}
424 1127
425SV * 1128void
426get_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)
427 CODE: 1175 PPCODE:
1176{
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
428 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0); 1208 RETVAL = lines < pango_layout_get_line_count (self->pl);
429 SvUTF8_on (RETVAL); 1209}
430 OUTPUT: 1210 OUTPUT:
431 RETVAL 1211 RETVAL
432 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
433void 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
434set_height (CFClient::Layout self, int base_height) 1239set_height (DC::Layout self, int base_height)
435 CODE: 1240 CODE:
1241 if (self->base_height != base_height)
1242 {
436 self->base_height = base_height; 1243 self->base_height = base_height;
1244 layout_update_font (self);
1245 }
437 1246
438void 1247void
439set_width (CFClient::Layout self, int max_width = -1) 1248set_width (DC::Layout self, int max_width = -1)
440 CODE: 1249 CODE:
441 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);
442 1251
443void 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
444size (CFClient::Layout self) 1278size (DC::Layout self)
445 PPCODE: 1279 PPCODE:
446{ 1280{
447 int w, h; 1281 int w, h;
448 1282
449 layout_update (self);
450 layout_get_pixel_size (self, &w, &h); 1283 layout_get_pixel_size (self, &w, &h);
451 1284
452 EXTEND (SP, 2); 1285 EXTEND (SP, 2);
453 PUSHs (sv_2mortal (newSViv (w))); 1286 PUSHs (sv_2mortal (newSViv (w)));
454 PUSHs (sv_2mortal (newSViv (h))); 1287 PUSHs (sv_2mortal (newSViv (h)));
455} 1288}
456 1289
457int 1290int
458xy_to_index (CFClient::Layout self, int x, int y) 1291descent (DC::Layout self)
459 CODE: 1292 CODE:
460{ 1293{
461 int index, trailing; 1294 PangoRectangle rect;
462 1295 PangoLayoutLine *line = pango_layout_get_line_readonly (self->pl, 0);
463 layout_update (self); 1296 pango_layout_line_get_pixel_extents (line, 0, &rect);
464 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing); 1297 RETVAL = PANGO_DESCENT (rect);
465
466 RETVAL = index;
467} 1298}
468 OUTPUT: 1299 OUTPUT:
469 RETVAL 1300 RETVAL
470 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
471void 1313void
472cursor_pos (CFClient::Layout self, int index) 1314cursor_pos (DC::Layout self, int index)
473 PPCODE: 1315 PPCODE:
474{ 1316{
475 PangoRectangle strong_pos; 1317 PangoRectangle strong_pos;
476 layout_update (self);
477 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1318 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);
478 1319
479 EXTEND (SP, 3); 1320 EXTEND (SP, 3);
480 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1321 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));
481 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1322 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
482 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1323 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));
483} 1324}
484 1325
485void 1326void
486render (CFClient::Layout self) 1327index_to_line_x (DC::Layout self, int index, int trailing = 0)
487 PPCODE: 1328 PPCODE:
488{ 1329{
489 SV *retval; 1330 int line, x;
490 int w, h;
491 FT_Bitmap bitmap;
492 1331
493 layout_update (self); 1332 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
494 layout_get_pixel_size (self, &w, &h); 1333#if !(defined (PANGO_VERSION_CHECK) && PANGO_VERSION_CHECK (1, 17, 3))
495 1334 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
496 retval = newSV (w * h); 1335 --line;
497 SvPOK_only (retval); 1336#endif
498 SvCUR_set (retval, w * h);
499
500 bitmap.rows = h;
501 bitmap.width = w;
502 bitmap.pitch = w;
503 bitmap.buffer = (unsigned char*)SvPVX (retval);
504 bitmap.num_grays = 256;
505 bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
506
507 memset (bitmap.buffer, 0, w * h);
508
509 pango_ft2_render_layout (&bitmap, self->pl, 0 * PANGO_SCALE, 0 * PANGO_SCALE);
510
511 EXTEND (SP, 3); 1337 EXTEND (SP, 2);
512 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 {
513 PUSHs (sv_2mortal (newSViv (h))); 1362 PUSHs (sv_2mortal (newSViv (index)));
514 PUSHs (sv_2mortal (retval)); 1363 PUSHs (sv_2mortal (newSViv (trailing)));
1364 }
515} 1365}
516 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
517MODULE = CFClient PACKAGE = CFClient::Texture 1401MODULE = Deliantra::Client PACKAGE = DC::Texture
518 1402
1403PROTOTYPES: ENABLE
1404
519void 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
520draw_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.)
521 PROTOTYPE: $$$;$$ 1429 PROTOTYPE: $$$;$$
1430 ALIAS:
1431 draw_quad_alpha = 1
1432 draw_quad_alpha_premultiplied = 2
522 CODE: 1433 CODE:
523{ 1434{
524 HV *hv = (HV *)SvRV (self); 1435 HV *hv = (HV *)SvRV (self);
525 float s = SvNV (*hv_fetch (hv, "s", 1, 1)); 1436 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
526 float t = SvNV (*hv_fetch (hv, "t", 1, 1)); 1437 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
527 int name = SvIV (*hv_fetch (hv, "name", 4, 1)); 1438 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
528 int wrap_mode = SvIV (*hv_fetch (hv, "wrap_mode", 9, 1)); 1439
1440 if (name <= 0)
1441 XSRETURN_EMPTY;
529 1442
530 if (items < 5) 1443 if (items < 5)
531 { 1444 {
532 w = SvNV (*hv_fetch (hv, "w", 1, 1)); 1445 w = SvNV (*hv_fetch (hv, "w", 1, 1));
533 h = SvNV (*hv_fetch (hv, "h", 1, 1)); 1446 h = SvNV (*hv_fetch (hv, "h", 1, 1));
534 } 1447 }
535 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
536 glBindTexture (GL_TEXTURE_2D, name); 1463 glBindTexture (GL_TEXTURE_2D, name);
537 if (wrap_mode) { 1464
538 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
539 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
540 }
541 glBegin (GL_QUADS); 1465 glBegin (GL_QUADS);
542 glTexCoord2f (0, 0); glVertex2f (x , y ); 1466 glTexCoord2f (0, 0); glVertex2f (x , y );
543 glTexCoord2f (0, t); glVertex2f (x , y + h); 1467 glTexCoord2f (0, t); glVertex2f (x , y + h);
544 glTexCoord2f (s, t); glVertex2f (x + w, y + h); 1468 glTexCoord2f (s, t); glVertex2f (x + w, y + h);
545 glTexCoord2f (s, 0); glVertex2f (x + w, y ); 1469 glTexCoord2f (s, 0); glVertex2f (x + w, y );
546 glEnd (); 1470 glEnd ();
547}
548 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
549MODULE = CFClient PACKAGE = CFClient::Map 1490MODULE = Deliantra::Client PACKAGE = DC::Map
550 1491
551CFClient::Map 1492PROTOTYPES: DISABLE
552new (SV *class, int map_width, int map_height) 1493
1494DC::Map
1495new (SV *class)
553 CODE: 1496 CODE:
554 New (0, RETVAL, 1, struct map); 1497 New (0, RETVAL, 1, struct map);
555 RETVAL->x = 0; 1498 RETVAL->x = 0;
556 RETVAL->y = 0; 1499 RETVAL->y = 0;
557 RETVAL->w = map_width; 1500 RETVAL->w = 0;
558 RETVAL->h = map_height; 1501 RETVAL->h = 0;
559 RETVAL->ox = 0; 1502 RETVAL->ox = 0;
560 RETVAL->oy = 0; 1503 RETVAL->oy = 0;
561 RETVAL->faces = 8192; 1504 RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
562 Newz (0, RETVAL->face, RETVAL->faces, mapface); 1505 RETVAL->texs = 8192; Newz (0, RETVAL->tex , RETVAL->texs , maptex);
563 RETVAL->texs = 8192;
564 Newz (0, RETVAL->tex, RETVAL->texs, maptex);
565 RETVAL->rows = 0; 1506 RETVAL->rows = 0;
566 RETVAL->row = 0; 1507 RETVAL->row = 0;
567 OUTPUT: 1508 OUTPUT:
568 RETVAL 1509 RETVAL
569 1510
570void 1511void
571DESTROY (CFClient::Map self) 1512DESTROY (DC::Map self)
572 CODE: 1513 CODE:
573{ 1514{
574 map_clear (self); 1515 map_clear (self);
575 Safefree (self->face); 1516 Safefree (self->face2tile);
1517 Safefree (self->tex);
576 Safefree (self); 1518 Safefree (self);
577} 1519}
578 1520
579void 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
580clear (CFClient::Map self) 1528clear (DC::Map self)
581 CODE: 1529 CODE:
582 map_clear (self); 1530 map_clear (self);
583 1531
584void 1532void
585set_face (CFClient::Map self, int face, int texid) 1533set_tileid (DC::Map self, int face, int tile)
586 CODE: 1534 CODE:
587{ 1535{
588 while (self->faces <= face) 1536 need_facenum (self, face); self->face2tile [face] = tile;
589 { 1537 need_texid (self, tile);
590 Append (mapface, self->face, self->faces, self->faces);
591 self->faces *= 2;
592 }
593
594 self->face [face] = texid;
595} 1538}
596 1539
597void 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
598set_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)
599 CODE: 1565 CODE:
600{ 1566{
601 while (self->texs <= texid) 1567 need_texid (self, texid);
602 {
603 Append (maptex, self->tex, self->texs, self->texs);
604 self->texs *= 2;
605 }
606 1568
607 { 1569 {
608 maptex *tex = self->tex + texid; 1570 maptex *tex = self->tex + texid;
609 1571
610 tex->name = name; 1572 tex->name = name;
… …
615 tex->r = r; 1577 tex->r = r;
616 tex->g = g; 1578 tex->g = g;
617 tex->b = b; 1579 tex->b = b;
618 tex->a = a; 1580 tex->a = a;
619 } 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);
620} 1591}
621 1592
622int 1593int
623ox (CFClient::Map self) 1594ox (DC::Map self)
624 ALIAS: 1595 ALIAS:
625 oy = 1 1596 oy = 1
1597 x = 2
1598 y = 3
1599 w = 4
1600 h = 5
626 CODE: 1601 CODE:
627 switch (ix) 1602 switch (ix)
628 { 1603 {
629 case 0: RETVAL = self->ox; break; 1604 case 0: RETVAL = self->ox; break;
630 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;
631 } 1610 }
632 OUTPUT: 1611 OUTPUT:
633 RETVAL 1612 RETVAL
634 1613
635void 1614void
636scroll (CFClient::Map self, int dx, int dy) 1615scroll (DC::Map self, int dx, int dy)
637 CODE: 1616 CODE:
638{ 1617{
639 if (dx > 0) 1618 if (dx > 0)
640 map_blank (self, self->x, self->y, dx - 1, self->h); 1619 map_blank (self, self->x, self->y, dx, self->h);
641 else if (dx < 0) 1620 else if (dx < 0)
642 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);
643 1622
644 if (dy > 0) 1623 if (dy > 0)
645 map_blank (self, self->x, self->y, self->w, dy - 1); 1624 map_blank (self, self->x, self->y, self->w, dy);
646 else if (dy < 0) 1625 else if (dy < 0)
647 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);
648 1627
649 self->ox += dx; self->x += dx; 1628 self->ox += dx; self->x += dx;
650 self->oy += dy; self->y += dy; 1629 self->oy += dy; self->y += dy;
651 1630
652 while (self->y < 0) 1631 while (self->y < 0)
… …
656 self->rows += MAP_EXTEND_Y; 1635 self->rows += MAP_EXTEND_Y;
657 self->y += MAP_EXTEND_Y; 1636 self->y += MAP_EXTEND_Y;
658 } 1637 }
659} 1638}
660 1639
661void 1640SV *
662map1a_update (CFClient::Map self, SV *data_) 1641map1a_update (DC::Map self, SV *data_, int extmap)
663 CODE: 1642 CODE:
664{ 1643{
665 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 1644 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
666 uint8_t *data_end = (uint8_t *)SvEND (data_); 1645 uint8_t *data_end = (uint8_t *)SvEND (data_);
667 mapcell *cell; 1646 mapcell *cell;
668 int x, y, flags; 1647 int x, y, z, flags;
1648 AV *missing = newAV ();
1649 RETVAL = newRV_noinc ((SV *)missing);
669 1650
670 while (data < data_end) 1651 while (data < data_end - 1)
671 { 1652 {
672 flags = (data [0] << 8) + data [1]; data += 2; 1653 flags = (data [0] << 8) + data [1]; data += 2;
673 1654
674 x = ((flags >> 10) & 63) + self->x; 1655 x = self->x + ((flags >> 10) & 63);
675 y = ((flags >> 4) & 63) + self->y; 1656 y = self->y + ((flags >> 4) & 63);
676 1657
677 cell = map_get_cell (self, x, y); 1658 cell = map_get_cell (self, x, y);
678 1659
679 if (flags & 15) 1660 if (flags & 15)
680 { 1661 {
681 if (cell->darkness < 0) 1662 if (!cell->darkness)
682 { 1663 {
1664 memset (cell, 0, sizeof (*cell));
683 cell->darkness = 0; 1665 cell->darkness = 256;
684 cell->face [0] = 0;
685 cell->face [1] = 0;
686 cell->face [2] = 0;
687 } 1666 }
688 1667
689 cell->darkness = flags & 8 ? *data++ : 255;
690
691 //TODO: don't trust server data to be in-range(!) 1668 //TODO: don't trust server data to be in-range(!)
692 1669
693 if (flags & 4) 1670 if (flags & 8)
694 { 1671 {
695 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;
696 } 1708 }
697 1709
1710 for (z = 0; z <= 2; ++z)
698 if (flags & 2) 1711 if (flags & (4 >> z))
699 { 1712 {
700 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 }
701 } 1730 }
702
703 if (flags & 1)
704 {
705 cell->face [2] = self->face [(data [0] << 8) + data [1]]; data += 2;
706 }
707 } 1731 }
708 else 1732 else
709 cell->darkness = -1; 1733 cell->darkness = 0;
710 } 1734 }
711} 1735}
1736 OUTPUT:
1737 RETVAL
712 1738
713SV * 1739SV *
714mapmap (CFClient::Map self, int w, int h) 1740mapmap (DC::Map self, int x0, int y0, int w, int h)
715 CODE: 1741 CODE:
716{ 1742{
717 int x0, x1, x; 1743 int x1, x;
718 int y0, y1, y; 1744 int y1, y;
719 int z; 1745 int z;
720 SV *map_sv = newSV (w * h * sizeof (uint32_t)); 1746 SV *map_sv = newSV (w * h * sizeof (uint32_t));
721 uint32_t *map = (uint32_t *)SvPVX (map_sv); 1747 uint32_t *map = (uint32_t *)SvPVX (map_sv);
722 1748
723 SvPOK_only (map_sv); 1749 SvPOK_only (map_sv);
724 SvCUR_set (map_sv, w * h * sizeof (uint32_t)); 1750 SvCUR_set (map_sv, w * h * sizeof (uint32_t));
725 1751
726 x0 = self->x - w / 2; x1 = x0 + w; 1752 x0 += self->x; x1 = x0 + w;
727 y0 = self->y - h / 2; y1 = y0 + h; 1753 y0 += self->y; y1 = y0 + h;
728 1754
729 for (y = y0; y < y1; y++) 1755 for (y = y0; y < y1; y++)
730 { 1756 {
731 maprow *row = 0 <= y && y < self->rows 1757 maprow *row = 0 <= y && y < self->rows
732 ? self->row + y 1758 ? self->row + y
… …
740 { 1766 {
741 mapcell *cell = row->col + (x - row->c0); 1767 mapcell *cell = row->col + (x - row->c0);
742 1768
743 for (z = 0; z <= 0; z++) 1769 for (z = 0; z <= 0; z++)
744 { 1770 {
745 mapface face = cell->face [z];
746
747 if (face)
748 {
749 maptex tex = self->tex [face]; 1771 maptex tex = self->tex [cell->tile [z]];
750 int a0 = 255 - tex.a; 1772 int a0 = 255 - tex.a;
751 int a1 = tex.a; 1773 int a1 = tex.a;
752 1774
753 r = (r * a0 + tex.r * a1) / 255; 1775 r = (r * a0 + tex.r * a1) / 255;
754 g = (g * a0 + tex.g * a1) / 255; 1776 g = (g * a0 + tex.g * a1) / 255;
755 b = (b * a0 + tex.b * a1) / 255; 1777 b = (b * a0 + tex.b * a1) / 255;
756 a = (a * a0 + tex.a * a1) / 255; 1778 a = (a * a0 + tex.a * a1) / 255;
757 }
758 } 1779 }
759 } 1780 }
760 1781
761 *map++ = (r ) 1782 *map++ = (r )
762 | (g << 8) 1783 | (g << 8)
… …
769} 1790}
770 OUTPUT: 1791 OUTPUT:
771 RETVAL 1792 RETVAL
772 1793
773void 1794void
774draw (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)
775 PPCODE: 2137 PPCODE:
776{ 2138{
777 int vx, vy;
778 int x, y, z; 2139 int x, y;
779 int last_name; 2140 int sw1 = sw + 2;
780 mapface face; 2141 int sh1 = sh + 2;
2142 int sh3 = sh * 3;
781 int sw4 = (sw + 3) & ~3; 2143 int sw34 = (sw * 3 + 3) & ~3;
2144 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
782 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh)); 2145 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));
783 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv); 2146 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
784 2147
785 memset (darkness, 255, sw4 * sh);
786 SvPOK_only (darkness_sv); 2148 SvPOK_only (darkness3_sv);
787 SvCUR_set (darkness_sv, sw4 * sh); 2149 SvCUR_set (darkness3_sv, sw34 * sh3);
788 2150
789 vx = self->x + (self->w - sw) / 2 - shift_x; 2151 mx += self->x - 1;
790 vy = self->y + (self->h - sh) / 2 - shift_y; 2152 my += self->y - 1;
791 2153
792 /* 2154 memset (darkness1, 255, sw1 * sh1);
793 int vx = self->vx = self->w >= sw
794 ? self->x + (self->w - sw) / 2
795 : MIN (self->x, MAX (self->x + self->w - sw + 1, self->vx));
796 2155
797 int vy = self->vy = self->h >= sh
798 ? self->y + (self->h - sh) / 2
799 : MIN (self->y, MAX (self->y + self->h - sh + 1, self->vy));
800 */
801
802 glColor4ub (255, 255, 255, 255);
803
804 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
805 glEnable (GL_BLEND);
806 glEnable (GL_TEXTURE_2D);
807 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
808
809 glBegin (GL_QUADS);
810
811 last_name = 0;
812
813 for (z = 0; z < 3; z++)
814 for (y = 0; y < sh; y++) 2156 for (y = 0; y < sh1; y++)
815 if (0 <= y + vy && y + vy < self->rows) 2157 if (0 <= y + my && y + my < self->rows)
816 { 2158 {
817 maprow *row = self->row + (y + vy); 2159 maprow *row = self->row + (y + my);
818 2160
819 for (x = 0; x < sw; x++) 2161 for (x = 0; x < sw1; x++)
820 if (row->c0 <= x + vx && x + vx < row->c1) 2162 if (row->c0 <= x + mx && x + mx < row->c1)
821 { 2163 {
822 mapcell *cell = row->col + (x + vx - row->c0); 2164 mapcell *cell = row->col + (x + mx - row->c0);
823 2165
824 darkness[y * sw4 + x] = cell->darkness < 0 2166 darkness1 [y * sw1 + x] = cell->darkness
2167 ? 255 - (cell->darkness - 1)
825 ? 255 - FOW_DARKNESS 2168 : 255 - FOW_DARKNESS;
826 : 255 - cell->darkness;
827
828 face = cell->face [z];
829
830 if (face)
831 {
832 maptex tex = self->tex [face];
833
834 int px = (x + 1) * 32 - tex.w;
835 int py = (y + 1) * 32 - tex.h;
836
837 if (last_name != tex.name)
838 {
839 glEnd ();
840 last_name = tex.name;
841 glBindTexture (GL_TEXTURE_2D, last_name);
842 glBegin (GL_QUADS);
843 }
844
845 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
846 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
847 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
848 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
849 }
850 } 2169 }
851 } 2170 }
852 2171
853 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];
854 2184
855 glDisable (GL_TEXTURE_2D); 2185 uint8_t r11 = (d11 + d21 + d12) / 3;
856 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);
857 2209
858 EXTEND (SP, 3); 2210 EXTEND (SP, 3);
859 PUSHs (sv_2mortal (newSViv (sw4))); 2211 PUSHs (sv_2mortal (newSViv (sw34)));
860 PUSHs (sv_2mortal (newSViv (sh))); 2212 PUSHs (sv_2mortal (newSViv (sh3)));
861 PUSHs (darkness_sv); 2213 PUSHs (darkness3_sv);
862} 2214}
863 2215
864SV * 2216SV *
865get_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)
866 CODE: 2218 CODE:
867{ 2219{
868 int x, y, x1, y1; 2220 int x, y, x1, y1;
869 SV *data_sv = newSV (w * h * 7 + 5); 2221 SV *data_sv = newSV (w * h * 7 + 5);
870 uint8_t *data = (uint8_t *)SvPVX (data_sv); 2222 uint8_t *data = (uint8_t *)SvPVX (data_sv);
… …
872 *data++ = 0; /* version 0 format */ 2224 *data++ = 0; /* version 0 format */
873 *data++ = w >> 8; *data++ = w; 2225 *data++ = w >> 8; *data++ = w;
874 *data++ = h >> 8; *data++ = h; 2226 *data++ = h >> 8; *data++ = h;
875 2227
876 // 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
877 // TODO: treat rows as we treat 2229 // TODO: treat rows as we treat columns
878 map_get_row (self, y0 + self->y - self->oy);//D 2230 map_get_row (self, y0 + self->y - self->oy);//D
879 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
880 2232
881 x0 += self->x - self->ox; 2233 x0 += self->x - self->ox;
882 y0 += self->y - self->oy; 2234 y0 += self->y - self->oy;
… …
895 if (row && row->c0 <= x && x < row->c1) 2247 if (row && row->c0 <= x && x < row->c1)
896 { 2248 {
897 mapcell *cell = row->col + (x - row->c0); 2249 mapcell *cell = row->col + (x - row->c0);
898 uint8_t flags = 0; 2250 uint8_t flags = 0;
899 2251
900 if (cell->face [0]) flags |= 1; 2252 if (cell->tile [0]) flags |= 1;
901 if (cell->face [1]) flags |= 2; 2253 if (cell->tile [1]) flags |= 2;
902 if (cell->face [2]) flags |= 4; 2254 if (cell->tile [2]) flags |= 4;
903 2255
904 *data++ = flags; 2256 *data++ = flags;
905 2257
906 if (flags & 1) 2258 if (flags & 1)
907 { 2259 {
2260 tileid tile = cell->tile [0];
908 *data++ = cell->face [0] >> 8; 2261 *data++ = tile >> 8;
909 *data++ = cell->face [0]; 2262 *data++ = tile;
910 } 2263 }
911 2264
912 if (flags & 2) 2265 if (flags & 2)
913 { 2266 {
2267 tileid tile = cell->tile [1];
914 *data++ = cell->face [1] >> 8; 2268 *data++ = tile >> 8;
915 *data++ = cell->face [1]; 2269 *data++ = tile;
916 } 2270 }
917 2271
918 if (flags & 4) 2272 if (flags & 4)
919 { 2273 {
2274 tileid tile = cell->tile [2];
920 *data++ = cell->face [2] >> 8; 2275 *data++ = tile >> 8;
921 *data++ = cell->face [2]; 2276 *data++ = tile;
922 } 2277 }
923 } 2278 }
924 else 2279 else
925 *data++ = 0; 2280 *data++ = 0;
926 } 2281 }
… …
932} 2287}
933 OUTPUT: 2288 OUTPUT:
934 RETVAL 2289 RETVAL
935 2290
936void 2291void
937set_rect (CFClient::Map self, int x0, int y0, uint8_t *data) 2292set_rect (DC::Map self, int x0, int y0, uint8_t *data)
938 PPCODE: 2293 PPCODE:
939{ 2294{
940 int x, y, z; 2295 int x, y, z;
941 int w, h; 2296 int w, h;
942 int x1, y1; 2297 int x1, y1;
943 2298
944 if (*data++ != 0) 2299 if (*data++ != 0)
945 return; /* version mismatch */ 2300 XSRETURN_EMPTY; /* version mismatch */
946 2301
947 w = *data++ << 8; w |= *data++; 2302 w = *data++ << 8; w |= *data++;
948 h = *data++ << 8; h |= *data++; 2303 h = *data++ << 8; h |= *data++;
949 2304
950 // 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
951 // TODO: treat rows as we treat 2306 // TODO: treat rows as we treat columns
952 map_get_row (self, y0 + self->y - self->oy);//D 2307 map_get_row (self, y0 + self->y - self->oy);//D
953 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
954 2309
955 x0 += self->x - self->ox; 2310 x0 += self->x - self->ox;
956 y0 += self->y - self->oy; 2311 y0 += self->y - self->oy;
… …
966 { 2321 {
967 uint8_t flags = *data++; 2322 uint8_t flags = *data++;
968 2323
969 if (flags) 2324 if (flags)
970 { 2325 {
971 mapface face[3] = { 0, 0, 0 };
972
973 mapcell *cell = row_get_cell (row, x); 2326 mapcell *cell = row_get_cell (row, x);
2327 tileid tile[3] = { 0, 0, 0 };
974 2328
975 if (flags & 1) { face[0] = *data++ << 8; face[0] |= *data++; } 2329 if (flags & 1) { tile[0] = *data++ << 8; tile[0] |= *data++; }
976 if (flags & 2) { face[1] = *data++ << 8; face[1] |= *data++; } 2330 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
977 if (flags & 4) { face[2] = *data++ << 8; face[2] |= *data++; } 2331 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
978 2332
979 if (cell->darkness <= 0) 2333 if (cell->darkness == 0)
980 { 2334 {
981 cell->darkness = -1; 2335 cell->darkness = 0;
982 2336
983 for (z = 0; z <= 2; z++) 2337 for (z = 0; z <= 2; z++)
984 { 2338 {
985 cell->face[z] = face[z]; 2339 tileid t = tile [z];
986 2340
987 if (face[z] && (face[z] >= self->texs || !self->tex[face [z]].name)) 2341 if (t >= self->texs || (t && !self->tex [t].name))
2342 {
988 XPUSHs (sv_2mortal (newSViv (face[z]))); 2343 XPUSHs (sv_2mortal (newSViv (t)));
2344 need_texid (self, t);
2345 }
2346
2347 cell->tile [z] = t;
989 } 2348 }
990 } 2349 }
991 } 2350 }
992 } 2351 }
993 } 2352 }
994} 2353}
995 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