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.110 by root, Sat Jun 10 02:22:33 2006 UTC vs.
Revision 1.253 by root, Fri Dec 28 20:59:14 2007 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines