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.109 by root, Wed Jun 7 23:29:13 2006 UTC vs.
Revision 1.249 by root, Fri Dec 28 15:40:07 2007 UTC

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

Diff Legend

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