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.253 by root, Fri Dec 28 20:59:14 2007 UTC vs.
Revision 1.330 by root, Sun Nov 18 15:24:24 2018 UTC

… …
15 15
16#include "EXTERN.h" 16#include "EXTERN.h"
17#include "perl.h" 17#include "perl.h"
18#include "XSUB.h" 18#include "XSUB.h"
19 19
20#include "flat_hash_map.hpp"
21
20#ifdef _WIN32 22#ifdef _WIN32
21# undef pipe 23# undef pipe
22// microsoft vs. C 24// microsoft vs. C
23# define sqrtf(x) sqrt(x) 25# define sqrtf(x) sqrt(x)
24# define roundf(x) (int)(x)
25# define atan2f(x,y) atan2(x,y) 26# define atan2f(x,y) atan2(x,y)
26# define M_PI 3.14159265f 27# define M_PI 3.14159265f
27#endif 28#endif
28 29
29#include <assert.h> 30#include <cassert>
30#include <math.h> 31#include <cmath>
31#include <string.h> 32#include <cstring>
32#include <stdio.h> 33#include <cstdio>
33#include <stdlib.h> 34#include <cstdlib>
35
36#include <utility>
37#include <bitset>
34 38
35#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW 39#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
36 40
37#include <SDL.h> 41#include <SDL.h>
38#include <SDL_thread.h> 42#include <SDL_thread.h>
39#include <SDL_endian.h> 43#include <SDL_endian.h>
40#include <SDL_image.h> 44#include <SDL_image.h>
41#include <SDL_mixer.h> 45#include <SDL_mixer.h>
42#include <SDL_opengl.h> 46#include <SDL_opengl.h>
43 47
48/* work around os x broken headers */
49#ifdef __MACOSX__
50typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
51typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture);
52typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t);
53#endif
54
44#define PANGO_ENABLE_BACKEND 55#define PANGO_ENABLE_BACKEND
45#define G_DISABLE_CAST_CHECKS 56#define G_DISABLE_CAST_CHECKS
46 57
47#include <glib/gmacros.h> 58#include <glib.h>
48 59
49#include <pango/pango.h> 60#include <pango/pango.h>
50 61
51#if !(defined (PANGO_VERSION_CHECK) && PANGO_VERSION_CHECK (1, 15, 2)) 62#ifndef PANGO_VERSION_CHECK
63# define PANGO_VERSION_CHECK(a,b,c) 0
64#endif
65
66#if !PANGO_VERSION_CHECK (1, 15, 2)
52# define pango_layout_get_line_readonly pango_layout_get_line_readonly 67# define pango_layout_get_line_readonly pango_layout_get_line
53# define pango_layout_get_lines_readonly pango_layout_get_lines_readonly 68# define pango_layout_get_lines_readonly pango_layout_get_lines
54# define pango_layout_iter_get_line_readonly pango_layout_iter_get_line_readonly 69# define pango_layout_iter_get_line_readonly pango_layout_iter_get_line
55# define pango_layout_iter_get_run_readonly pango_layout_iter_get_run_readonly 70# define pango_layout_iter_get_run_readonly pango_layout_iter_get_run
56#endif 71#endif
57 72
58#ifndef _WIN32 73#ifndef _WIN32
59# include <sys/types.h> 74# include <sys/types.h>
60# include <sys/socket.h> 75# include <sys/socket.h>
61# include <netinet/in.h> 76# include <netinet/in.h>
62# include <netinet/tcp.h> 77# include <netinet/tcp.h>
63# include <inttypes.h> 78# include <inttypes.h>
64#endif 79#endif
65 80
81#if __GNUC__ >= 4
82# define expect(expr,value) __builtin_expect ((expr),(value))
83#else
84# define expect(expr,value) (expr)
85#endif
86
87#define expect_false(expr) expect ((expr) != 0, 0)
88#define expect_true(expr) expect ((expr) != 0, 1)
89
66#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */ 90#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
67 91
92/* this is used as fow flag as well, so has to have a different value */
93/* then anything that is computed by incoming darkness */
68#define FOW_DARKNESS 32 94#define FOW_DARKNESS 50
95#define DARKNESS_ADJUST(n) (n)
69 96
70#define MAP_EXTEND_X 32 97#define MAP_EXTEND_X 32
71#define MAP_EXTEND_Y 512 98#define MAP_EXTEND_Y 512
72 99
73#define MIN_FONT_HEIGHT 10 100#define MIN_FONT_HEIGHT 10
74 101
75/* mask out modifiers we are not interested in */ 102/* mask out modifiers we are not interested in */
76#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META) 103#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)
77 104
78#if 0 105#define KMOD_LRAM 0x10000 // our extension
79# define PARACHUTE SDL_INIT_NOPARACHUTE 106
80#else 107#define TEXID_SPEECH 1
81# define PARACHUTE 0 108#define TEXID_NOFACE 2
82#endif 109
110static char *
111fast_sv_grow (SV *sv, STRLEN need)
112{
113 STRLEN len = SvLEN (sv);
114 STRLEN want = SvCUR (sv) + need;
115
116 if (expect_false (len < want))
117 {
118 do
119 len *= 2;
120 while (len < want);
121
122 sv_grow (sv, len);
123 }
124
125 SvCUR_set (sv, want);
126 return SvEND (sv) - need;
127}
83 128
84static AV *texture_av; 129static AV *texture_av;
85 130
86static struct 131static struct
87{ 132{
… …
144{ 189{
145 GSList *attrs = run->item->analysis.extra_attrs; 190 GSList *attrs = run->item->analysis.extra_attrs;
146 191
147 while (attrs) 192 while (attrs)
148 { 193 {
149 PangoAttribute *attr = attrs->data; 194 PangoAttribute *attr = (PangoAttribute *)attrs->data;
150 195
151 if (attr->klass->type == PANGO_ATTR_SHAPE) 196 if (attr->klass->type == PANGO_ATTR_SHAPE)
152 return 1; 197 return 1;
153 198
154 attrs = attrs->next; 199 attrs = attrs->next;
155 } 200 }
156 201
157 return 0; 202 return 0;
158} 203}
159 204
160typedef struct cf_layout { 205struct cf_layout {
161 PangoLayout *pl; 206 PangoLayout *pl;
162 float r, g, b, a; // default color for rgba mode 207 float r, g, b, a; // default color for rgba mode
163 int base_height; 208 int base_height;
164 DC__Font font; 209 DC__Font font;
165 rc_t *rc; 210 rc_t rc;
166} *DC__Layout; 211};
212
213typedef cf_layout *DC__Layout;
167 214
168static DC__Font default_font; 215static DC__Font default_font;
169static PangoContext *opengl_context; 216static PangoContext *opengl_context;
170static PangoFontMap *opengl_fontmap; 217static PangoFontMap *opengl_fontmap;
171 218
172static void 219static void
173substitute_func (FcPattern *pattern, gpointer data) 220substitute_func (FcPattern *pattern, gpointer data)
174{ 221{
175 FcPatternAddBool (pattern, FC_HINTING, 1); 222 FcPatternAddBool (pattern, FC_HINTING, 1);
176#ifdef FC_HINT_STYLE 223#ifdef FC_HINT_STYLE
177 FcPatternAddBool (pattern, FC_HINT_STYLE, FC_HINT_FULL); 224 FcPatternAddInteger (pattern, FC_HINT_STYLE, FC_HINT_FULL);
178#endif 225#endif
179 FcPatternAddBool (pattern, FC_AUTOHINT, 0); 226 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
180} 227}
181 228
182static void 229static void
183layout_update_font (DC__Layout self) 230layout_update_font (DC__Layout self)
184{ 231{
185 /* use a random scale factor to account for unknown descenders, 0.8 works 232 /* use a random scale factor to account for unknown descenders, 0.8 works
186 * reasonably well with bitstream vera 233 * reasonably well with dejavu/bistream fonts
187 */ 234 */
188 PangoFontDescription *font = self->font ? self->font : default_font; 235 PangoFontDescription *font = self->font ? self->font : default_font;
189 236
190 pango_font_description_set_absolute_size (font, 237 pango_font_description_set_absolute_size (font,
191 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10)); 238 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
… …
212} 259}
213 260
214typedef uint16_t tileid; 261typedef uint16_t tileid;
215typedef uint16_t faceid; 262typedef uint16_t faceid;
216 263
217typedef struct { 264struct maptex
265{
218 GLuint name; 266 GLuint name;
219 int w, h; 267 int w, h;
220 float s, t; 268 float s, t;
221 uint8_t r, g, b, a; 269 uint8_t r, g, b, a;
222 tileid smoothtile; 270 tileid smoothtile;
223 uint8_t smoothlevel; 271 uint8_t smoothlevel;
224} maptex; 272 uint8_t unused; /* set to zero on use */
273};
225 274
226typedef struct { 275struct mapcell
276{
227 uint32_t player; 277 uint32_t player;
228 tileid tile[3]; 278 tileid tile[3];
229 uint16_t darkness; 279 uint16_t darkness;
230 uint8_t stat_width, stat_hp, flags, smoothmax; 280 uint8_t stat_width, stat_hp, flags, smoothmax;
231} mapcell; 281};
232 282
233typedef struct { 283struct maprow
284{
234 int32_t c0, c1; 285 int32_t c0, c1;
235 mapcell *col; 286 mapcell *col;
236} maprow; 287};
237 288
238typedef struct map { 289struct mapgrid {
239 int x, y, w, h; 290 int x, y, w, h;
240 int ox, oy; /* offset to virtual global coordinate system */ 291 int ox, oy; /* offset to virtual global coordinate system */
241 int faces; tileid *face2tile; // [faceid] 292 int faces; tileid *face2tile; // [faceid]
242 int texs; maptex *tex; // [tileid] 293 int texs; maptex *tex; // [tileid]
243 294
244 int32_t rows; 295 int32_t rows;
245 maprow *row; 296 maprow *row;
246} *DC__Map; 297};
247 298
248static char * 299typedef mapgrid *DC__Map;
300
301template<typename T>
302static void
249prepend (char *ptr, int sze, int inc) 303prepend (T *&ptr, int sze, int inc)
250{ 304{
251 char *p; 305 T *p;
252 306
253 New (0, p, sze + inc, char); 307 Newxz (p, sze + inc, T);
254 Zero (p, inc, char);
255 Move (ptr, p + inc, sze, char); 308 Move (ptr, p + inc, sze, T);
256 Safefree (ptr); 309 Safefree (ptr);
257 310
258 return p; 311 ptr = p;
259} 312}
260 313
261static char * 314template<typename T>
262append (char *ptr, int sze, int inc)
263{
264 Renew (ptr, sze + inc, char);
265 Zero (ptr + sze, inc, char);
266
267 return ptr;
268}
269
270#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
271#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
272
273static void 315static void
316append (T *&ptr, int sze, int inc)
317{
318 Renew (ptr, sze + inc, T);
319 Zero (ptr + sze, inc, T);
320}
321
322static void
274need_facenum (struct map *self, faceid face) 323need_facenum (struct mapgrid *self, faceid face)
275{ 324{
276 while (self->faces <= face) 325 while (self->faces <= face)
277 { 326 {
278 Append (tileid, self->face2tile, self->faces, self->faces); 327 append (self->face2tile, self->faces, self->faces);
279 self->faces *= 2; 328 self->faces *= 2;
280 } 329 }
281} 330}
282 331
283static void 332static void
284need_texid (struct map *self, int texid) 333need_texid (struct mapgrid *self, int texid)
285{ 334{
286 while (self->texs <= texid) 335 while (self->texs <= texid)
287 { 336 {
288 Append (maptex, self->tex, self->texs, self->texs); 337 append (self->tex, self->texs, self->texs);
289 self->texs *= 2; 338 self->texs *= 2;
290 } 339 }
291} 340}
292 341
293static maprow * 342static maprow *
294map_get_row (DC__Map self, int y) 343map_get_row (mapgrid *self, int y)
295{ 344{
296 if (0 > y) 345 if (0 > y)
297 { 346 {
298 int extend = - y + MAP_EXTEND_Y; 347 int extend = - y + MAP_EXTEND_Y;
299 Prepend (maprow, self->row, self->rows, extend); 348 prepend (self->row, self->rows, extend);
300 349
301 self->rows += extend; 350 self->rows += extend;
302 self->y += extend; 351 self->y += extend;
303 y += extend; 352 y += extend;
304 } 353 }
305 else if (y >= self->rows) 354 else if (y >= self->rows)
306 { 355 {
307 int extend = y - self->rows + MAP_EXTEND_Y; 356 int extend = y - self->rows + MAP_EXTEND_Y;
308 Append (maprow, self->row, self->rows, extend); 357 append (self->row, self->rows, extend);
309 self->rows += extend; 358 self->rows += extend;
310 } 359 }
311 360
312 return self->row + y; 361 return self->row + y;
313} 362}
… …
323 } 372 }
324 373
325 if (row->c0 > x) 374 if (row->c0 > x)
326 { 375 {
327 int extend = row->c0 - x + MAP_EXTEND_X; 376 int extend = row->c0 - x + MAP_EXTEND_X;
328 Prepend (mapcell, row->col, row->c1 - row->c0, extend); 377 prepend (row->col, row->c1 - row->c0, extend);
329 row->c0 -= extend; 378 row->c0 -= extend;
330 } 379 }
331 else if (x >= row->c1) 380 else if (x >= row->c1)
332 { 381 {
333 int extend = x - row->c1 + MAP_EXTEND_X; 382 int extend = x - row->c1 + MAP_EXTEND_X;
334 Append (mapcell, row->col, row->c1 - row->c0, extend); 383 append (row->col, row->c1 - row->c0, extend);
335 row->c1 += extend; 384 row->c1 += extend;
336 } 385 }
337 386
338 return row->col + (x - row->c0); 387 return row->col + (x - row->c0);
339} 388}
340 389
341static mapcell * 390static mapcell *
342map_get_cell (DC__Map self, int x, int y) 391map_get_cell (mapgrid *self, int x, int y)
343{ 392{
344 return row_get_cell (map_get_row (self, y), x); 393 return row_get_cell (map_get_row (self, y), x);
345} 394}
346 395
347static void 396static void
348map_clear (DC__Map self) 397map_clear (mapgrid *self)
349{ 398{
350 int r; 399 int r;
351 400
352 for (r = 0; r < self->rows; r++) 401 for (r = 0; r < self->rows; r++)
353 Safefree (self->row[r].col); 402 Safefree (self->row[r].col);
… …
360 self->oy = 0; 409 self->oy = 0;
361 self->row = 0; 410 self->row = 0;
362 self->rows = 0; 411 self->rows = 0;
363} 412}
364 413
414#define CELL_CLEAR(cell) \
415 do { \
416 if ((cell)->player) \
417 (cell)->tile [2] = 0; \
418 (cell)->darkness = 0; \
419 (cell)->stat_hp = 0; \
420 (cell)->flags = 0; \
421 (cell)->player = 0; \
422 } while (0)
423
365static void 424static void
366map_blank (DC__Map self, int x0, int y0, int w, int h) 425map_blank (mapgrid *self, int x0, int y0, int w, int h)
367{ 426{
368 int x, y; 427 int x, y;
369 maprow *row; 428 maprow *row;
370 mapcell *cell; 429 mapcell *cell;
371 430
… …
383 if (x >= row->c1) 442 if (x >= row->c1)
384 break; 443 break;
385 444
386 cell = row->col + x - row->c0; 445 cell = row->col + x - row->c0;
387 446
388 cell->darkness = 0; 447 CELL_CLEAR (cell);
389 cell->stat_hp = 0;
390 cell->flags = 0;
391 cell->player = 0;
392 } 448 }
393 } 449 }
394} 450}
395 451
396typedef struct { 452struct smooth_key
453{
397 tileid tile; 454 tileid tile;
398 uint8_t x, y, level; 455 uint8_t x, y, level;
399} smooth_key; 456
457 bool operator == (const smooth_key &o) const
458 {
459 return tile == o.tile && x == o.x && y == o.y && level == o.level;
460 }
461};
462
463typedef ska::flat_hash_map<smooth_key, IV> smooth_hash;
464
465namespace std {
466 template <>
467 struct hash<smooth_key>
468 {
469 size_t operator () (const smooth_key &v) const
470 {
471 return v.tile + (v.x << 8) + (v.y << 16) + (v.level << 24);
472 }
473 };
474}
400 475
401static void 476static void
402smooth_or_bits (HV *hv, smooth_key *key, IV bits) 477smooth_or_bits (smooth_hash &h, smooth_key &key, IV bits)
403{ 478{
404 SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1); 479 auto &&it = h.find (key);
405 480
406 if (SvIOK (*sv)) 481 if (it == h.end ())
407 SvIV_set (*sv, SvIVX (*sv) | bits); 482 h.insert (std::make_pair (key, bits));
408 else 483 else
409 sv_setiv (*sv, bits); 484 it->second |= bits;
410} 485}
411 486
412static void 487static void
413music_finished (void) 488music_finished (void)
414{ 489{
… …
431 ev.code = 1; 506 ev.code = 1;
432 ev.data1 = (void *)(long)channel; 507 ev.data1 = (void *)(long)channel;
433 ev.data2 = 0; 508 ev.data2 = 0;
434 509
435 SDL_PushEvent ((SDL_Event *)&ev); 510 SDL_PushEvent ((SDL_Event *)&ev);
511}
512
513// approximately divide by 255
514static unsigned int
515div255 (unsigned int n)
516{
517 return (n + (n >> 8)) >> 8;
436} 518}
437 519
438static unsigned int 520static unsigned int
439minpot (unsigned int n) 521minpot (unsigned int n)
440{ 522{
… …
507 if (!svp || !SvTRUE (*svp)) 589 if (!svp || !SvTRUE (*svp))
508 return 0; 590 return 0;
509 591
510 return 1; 592 return 1;
511} 593}
594
595/******************************************************************************/
596
597/* process keyboard modifiers */
598static int
599mod_munge (int mod)
600{
601 mod &= MOD_MASK;
602
603 if (mod & (KMOD_META | KMOD_ALT))
604 mod |= KMOD_LRAM;
605
606 return mod;
607}
608
609static void
610deliantra_main (SV *real_main)
611{
612 dSP;
613
614 PUSHMARK (SP);
615 call_sv (real_main, G_DISCARD | G_VOID);
616}
617
618#ifdef __MACOSX__
619 static SV *real_main;
620
621 /* to due surprising braindamage on the side of SDL design, we
622 * do some mind-boggling hack here: SDL requires a custom main()
623 * on OS X, so... we provide one and call the original main(), which,
624 * due to shared library magic, calls -lSDLmain's main, not perl's main,
625 * and which calls our main (== SDL_main) back.
626 */
627 extern C_LINKAGE int
628 main (int argc, char *argv[])
629 {
630 deliantra_main (real_main);
631 }
632
633 #undef main
634
635 extern C_LINKAGE int main (int argc, char *argv[]);
636
637 static void
638 SDL_main_hack (SV *real_main_)
639 {
640 real_main = real_main_;
641
642 char *argv[] = { "deliantra client", 0 };
643 (main) (1, argv);
644 }
645#else
646 static void
647 SDL_main_hack (SV *real_main)
648 {
649 deliantra_main (real_main);
650 }
651#endif
512 652
513MODULE = Deliantra::Client PACKAGE = DC 653MODULE = Deliantra::Client PACKAGE = DC
514 654
515PROTOTYPES: ENABLE 655PROTOTYPES: ENABLE
516 656
… …
545 const_iv (SDL_USEREVENT), 685 const_iv (SDL_USEREVENT),
546 686
547 const_iv (SDL_APPINPUTFOCUS), 687 const_iv (SDL_APPINPUTFOCUS),
548 const_iv (SDL_APPMOUSEFOCUS), 688 const_iv (SDL_APPMOUSEFOCUS),
549 const_iv (SDL_APPACTIVE), 689 const_iv (SDL_APPACTIVE),
690
691
692 const_iv (SDLK_UNKNOWN),
693 const_iv (SDLK_FIRST),
694 const_iv (SDLK_BACKSPACE),
695 const_iv (SDLK_TAB),
696 const_iv (SDLK_CLEAR),
697 const_iv (SDLK_RETURN),
698 const_iv (SDLK_PAUSE),
699 const_iv (SDLK_ESCAPE),
700 const_iv (SDLK_SPACE),
701 const_iv (SDLK_EXCLAIM),
702 const_iv (SDLK_QUOTEDBL),
703 const_iv (SDLK_HASH),
704 const_iv (SDLK_DOLLAR),
705 const_iv (SDLK_AMPERSAND),
706 const_iv (SDLK_QUOTE),
707 const_iv (SDLK_LEFTPAREN),
708 const_iv (SDLK_RIGHTPAREN),
709 const_iv (SDLK_ASTERISK),
710 const_iv (SDLK_PLUS),
711 const_iv (SDLK_COMMA),
712 const_iv (SDLK_MINUS),
713 const_iv (SDLK_PERIOD),
714 const_iv (SDLK_SLASH),
715 const_iv (SDLK_0),
716 const_iv (SDLK_1),
717 const_iv (SDLK_2),
718 const_iv (SDLK_3),
719 const_iv (SDLK_4),
720 const_iv (SDLK_5),
721 const_iv (SDLK_6),
722 const_iv (SDLK_7),
723 const_iv (SDLK_8),
724 const_iv (SDLK_9),
725 const_iv (SDLK_COLON),
726 const_iv (SDLK_SEMICOLON),
727 const_iv (SDLK_LESS),
728 const_iv (SDLK_EQUALS),
729 const_iv (SDLK_GREATER),
730 const_iv (SDLK_QUESTION),
731 const_iv (SDLK_AT),
732
733 const_iv (SDLK_LEFTBRACKET),
734 const_iv (SDLK_BACKSLASH),
735 const_iv (SDLK_RIGHTBRACKET),
736 const_iv (SDLK_CARET),
737 const_iv (SDLK_UNDERSCORE),
738 const_iv (SDLK_BACKQUOTE),
739 const_iv (SDLK_DELETE),
550 740
551 const_iv (SDLK_FIRST), 741 const_iv (SDLK_FIRST),
552 const_iv (SDLK_LAST), 742 const_iv (SDLK_LAST),
553 const_iv (SDLK_KP0), 743 const_iv (SDLK_KP0),
554 const_iv (SDLK_KP1), 744 const_iv (SDLK_KP1),
… …
630 const_iv (KMOD_RMETA), 820 const_iv (KMOD_RMETA),
631 const_iv (KMOD_NUM), 821 const_iv (KMOD_NUM),
632 const_iv (KMOD_CAPS), 822 const_iv (KMOD_CAPS),
633 const_iv (KMOD_MODE), 823 const_iv (KMOD_MODE),
634 824
825 const_iv (KMOD_LRAM),
826
635 const_iv (MIX_DEFAULT_FORMAT), 827 const_iv (MIX_DEFAULT_FORMAT),
828
829 const_iv (SDL_INIT_TIMER),
830 const_iv (SDL_INIT_AUDIO),
831 const_iv (SDL_INIT_VIDEO),
832 const_iv (SDL_INIT_CDROM),
833 const_iv (SDL_INIT_JOYSTICK),
834 const_iv (SDL_INIT_EVERYTHING),
835 const_iv (SDL_INIT_NOPARACHUTE),
836 const_iv (SDL_INIT_EVENTTHREAD),
837
838 const_iv (SDL_GL_RED_SIZE),
839 const_iv (SDL_GL_GREEN_SIZE),
840 const_iv (SDL_GL_BLUE_SIZE),
841 const_iv (SDL_GL_ALPHA_SIZE),
842 const_iv (SDL_GL_DOUBLEBUFFER),
843 const_iv (SDL_GL_BUFFER_SIZE),
844 const_iv (SDL_GL_DEPTH_SIZE),
845 const_iv (SDL_GL_STENCIL_SIZE),
846 const_iv (SDL_GL_ACCUM_RED_SIZE),
847 const_iv (SDL_GL_ACCUM_GREEN_SIZE),
848 const_iv (SDL_GL_ACCUM_BLUE_SIZE),
849 const_iv (SDL_GL_ACCUM_ALPHA_SIZE),
850 const_iv (SDL_GL_STEREO),
851 const_iv (SDL_GL_MULTISAMPLEBUFFERS),
852 const_iv (SDL_GL_MULTISAMPLESAMPLES),
853 const_iv (SDL_GL_ACCELERATED_VISUAL),
854 const_iv (SDL_GL_SWAP_CONTROL),
855
856 const_iv (FOW_DARKNESS)
636# undef const_iv 857# undef const_iv
637 }; 858 };
638 859
639 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 860 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
640 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 861 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
641 862
642 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK); 863 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
643 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE); 864 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
644} 865}
645 866
… …
661NV ceil (NV x) 882NV ceil (NV x)
662 883
663IV minpot (UV n) 884IV minpot (UV n)
664 885
665IV popcount (UV n) 886IV popcount (UV n)
887
888NV distance (NV dx, NV dy)
889 CODE:
890 RETVAL = pow (dx * dx + dy * dy, 0.5);
891 OUTPUT:
892 RETVAL
666 893
667void 894void
668pango_init () 895pango_init ()
669 CODE: 896 CODE:
670{ 897{
671 opengl_fontmap = pango_opengl_font_map_new (); 898 opengl_fontmap = pango_opengl_font_map_new ();
672 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0); 899 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
673 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap); 900 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
674#if defined (PANGO_VERSION_CHECK) && PANGO_VERSION_CHECK (1, 15, 2) 901 /*pango_context_set_font_description (opengl_context, default_font);*/
902#if PANGO_VERSION_CHECK (1, 15, 2)
675 pango_context_set_language (opengl_context, pango_language_from_string ("en")); 903 pango_context_set_language (opengl_context, pango_language_from_string ("en"));
676 /*pango_context_set_base_dir (opengl_context, PANGO_DIRECTION_WEAK_LTR);*/ 904 /*pango_context_set_base_dir (opengl_context, PANGO_DIRECTION_WEAK_LTR);*/
677#endif 905#endif
678} 906}
679 907
680char *
681SDL_GetError () 908char *SDL_GetError ()
682 909
683int 910void SDL_main_hack (SV *real_main)
684SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE) 911 PROTOTYPE: &
685 912
686void 913int SDL_Init (U32 flags)
914
915int SDL_InitSubSystem (U32 flags)
916
917void SDL_QuitSubSystem (U32 flags)
918
687SDL_Quit () 919void SDL_Quit ()
920
921int SDL_GL_SetAttribute (int attr, int value)
922 C_ARGS: (SDL_GLattr)attr, value
923
924int SDL_GL_GetAttribute (int attr)
925 CODE:
926 if (SDL_GL_GetAttribute ((SDL_GLattr)attr, &RETVAL))
927 XSRETURN_UNDEF;
928 OUTPUT:
929 RETVAL
688 930
689void 931void
690SDL_ListModes (int rgb, int alpha) 932SDL_ListModes (int rgb, int alpha)
691 PPCODE: 933 PPCODE:
692{ 934{
… …
704 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0); 946 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
705 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0); 947 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
706 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0); 948 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
707 949
708 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); 950 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
709#if SDL_VERSION_ATLEAST(1,2,10)
710 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
711 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1); 951 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
712#endif
713 952
714 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 953 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
715 954
716 if (m && m != (SDL_Rect **)-1) 955 if (m && m != (SDL_Rect **)-1)
717 while (*m) 956 while (*m)
718 { 957 {
719 if ((*m)->w >= 800 && (*m)->h >= 480) 958 if ((*m)->w >= 400 && (*m)->h >= 300)
720 { 959 {
721 AV *av = newAV (); 960 AV *av = newAV ();
722 av_push (av, newSViv ((*m)->w)); 961 av_push (av, newSViv ((*m)->w));
723 av_push (av, newSViv ((*m)->h)); 962 av_push (av, newSViv ((*m)->h));
724 av_push (av, newSViv (rgb)); 963 av_push (av, newSViv (rgb));
… …
747 ); 986 );
748 987
749 if (RETVAL) 988 if (RETVAL)
750 { 989 {
751 av_clear (texture_av); 990 av_clear (texture_av);
752
753 SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
754#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name); 991#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
755#include "glfunc.h" 992#include "glfunc.h"
756#undef GL_FUNC 993#undef GL_FUNC
994 if (!gl.ActiveTexture ) gl.ActiveTexture = gl.ActiveTextureARB;
995 if (!gl.MultiTexCoord2f) gl.MultiTexCoord2f = gl.MultiTexCoord2fARB;
757 } 996 }
758} 997}
759 OUTPUT: 998 OUTPUT:
760 RETVAL 999 RETVAL
1000
1001void
1002SDL_WM_SetCaption (const char *title, const char *icon)
761 1003
762void 1004void
763SDL_GL_SwapBuffers () 1005SDL_GL_SwapBuffers ()
764 1006
765char * 1007char *
766SDL_GetKeyName (int sym) 1008SDL_GetKeyName (int sym)
1009 C_ARGS: (SDLKey)sym
767 1010
768int 1011int
769SDL_GetAppState () 1012SDL_GetAppState ()
770 1013
1014int
1015SDL_GetModState ()
1016
1017int
1018SDL_WaitEvent ()
1019 C_ARGS: 0
1020
771void 1021void
1022SDL_PumpEvents ()
1023
1024void
772poll_events () 1025peep_events ()
773 PPCODE: 1026 PPCODE:
774{ 1027{
775 SDL_Event ev; 1028 SDL_Event ev;
776 1029
777 SDL_PumpEvents (); 1030 SDL_PumpEvents ();
… …
784 { 1037 {
785 case SDL_KEYDOWN: 1038 case SDL_KEYDOWN:
786 case SDL_KEYUP: 1039 case SDL_KEYUP:
787 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 1040 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
788 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 1041 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
789 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod & MOD_MASK), 0); 1042 hv_store (hv, "mod", 3, newSViv (mod_munge (ev.key.keysym.mod)), 0);
790 hv_store (hv, "cmod", 4, newSViv (SDL_GetModState () & MOD_MASK), 0); /* current mode */ 1043 hv_store (hv, "cmod", 4, newSViv (mod_munge (SDL_GetModState ())), 0); /* current mode */
791 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 1044 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
792 break; 1045 break;
793 1046
794 case SDL_ACTIVEEVENT: 1047 case SDL_ACTIVEEVENT:
795 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 1048 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
… …
813 x = ev.motion.x; 1066 x = ev.motion.x;
814 y = ev.motion.y; 1067 y = ev.motion.y;
815 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)); 1068 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
816 } 1069 }
817 1070
818 hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0); 1071 hv_store (hv, "mod", 3, newSViv (mod_munge (SDL_GetModState ())), 0);
819 hv_store (hv, "state", 5, newSViv (state), 0); 1072 hv_store (hv, "state", 5, newSViv (state), 0);
820 hv_store (hv, "x", 1, newSViv (x), 0); 1073 hv_store (hv, "x", 1, newSViv (x), 0);
821 hv_store (hv, "y", 1, newSViv (y), 0); 1074 hv_store (hv, "y", 1, newSViv (y), 0);
822 hv_store (hv, "xrel", 4, newSViv (xrel), 0); 1075 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
823 hv_store (hv, "yrel", 4, newSViv (yrel), 0); 1076 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
… …
843 1096
844 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1)))); 1097 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1))));
845 } 1098 }
846} 1099}
847 1100
1101char *
1102SDL_AudioDriverName ()
1103 CODE:
1104{
1105 char buf [256];
1106 if (!SDL_AudioDriverName (buf, sizeof (buf)))
1107 XSRETURN_UNDEF;
1108
1109 RETVAL = buf;
1110}
1111 OUTPUT:
1112 RETVAL
1113
848int 1114int
849Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096) 1115Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)
850 POSTCALL: 1116 POSTCALL:
851 Mix_HookMusicFinished (music_finished); 1117 Mix_HookMusicFinished (music_finished);
852 Mix_ChannelFinished (channel_finished); 1118 Mix_ChannelFinished (channel_finished);
853 1119
854void 1120void
855Mix_QuerySpec () 1121Mix_QuerySpec ()
… …
908 } 1174 }
909 } 1175 }
910#endif 1176#endif
911} 1177}
912 1178
913void 1179int
914add_font (char *file) 1180add_font (char *file)
915 CODE: 1181 CODE:
916 FcConfigAppFontAddFile (0, (const FcChar8 *)file); 1182 RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);
1183 OUTPUT:
1184 RETVAL
1185
1186void
1187IMG_Init (int flags = IMG_INIT_JPG | IMG_INIT_PNG)
1188
1189# MIX_INIT_MP3 gives smpeg + libstdc++ + libgcc_s
1190void
1191Mix_Init (int flags = MIX_INIT_MOD | MIX_INIT_OGG)
917 1192
918void 1193void
919load_image_inline (SV *image_) 1194load_image_inline (SV *image_)
920 ALIAS: 1195 ALIAS:
921 load_image_file = 1 1196 load_image_file = 1
… …
967 1242
968 SDL_LockSurface (surface2); 1243 SDL_LockSurface (surface2);
969 EXTEND (SP, 6); 1244 EXTEND (SP, 6);
970 PUSHs (sv_2mortal (newSViv (surface2->w))); 1245 PUSHs (sv_2mortal (newSViv (surface2->w)));
971 PUSHs (sv_2mortal (newSViv (surface2->h))); 1246 PUSHs (sv_2mortal (newSViv (surface2->h)));
972 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 1247 PUSHs (sv_2mortal (newSVpvn ((const char *)surface2->pixels, surface2->h * surface2->pitch)));
973 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB))); 1248 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));
974 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 1249 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
975 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE))); 1250 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
976 SDL_UnlockSurface (surface2); 1251 SDL_UnlockSurface (surface2);
977 1252
… …
1037#if DEBUG 1312#if DEBUG
1038 VALGRIND_DO_LEAK_CHECK; 1313 VALGRIND_DO_LEAK_CHECK;
1039#endif 1314#endif
1040} 1315}
1041 1316
1317int
1318SvREFCNT (SV *sv)
1319 CODE:
1320 RETVAL = SvREFCNT (sv);
1321 OUTPUT:
1322 RETVAL
1323
1042MODULE = Deliantra::Client PACKAGE = DC::Font 1324MODULE = Deliantra::Client PACKAGE = DC::Font
1043 1325
1044PROTOTYPES: DISABLE 1326PROTOTYPES: DISABLE
1045 1327
1046DC::Font 1328DC::Font
1047new_from_file (SV *class, char *path, int id = 0) 1329new_from_file (SV *klass, char *path, int id = 0)
1048 CODE: 1330 CODE:
1049{ 1331{
1050 int count; 1332 int count;
1051 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count); 1333 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
1052 RETVAL = pango_fc_font_description_from_pattern (pattern, 0); 1334 RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
… …
1081 PROTOTYPE: 1363 PROTOTYPE:
1082 CODE: 1364 CODE:
1083 tc_restore (); 1365 tc_restore ();
1084 1366
1085DC::Layout 1367DC::Layout
1086new (SV *class) 1368new (SV *klass)
1087 CODE: 1369 CODE:
1088 New (0, RETVAL, 1, struct cf_layout); 1370 RETVAL = new cf_layout;
1089 1371
1090 RETVAL->pl = pango_layout_new (opengl_context); 1372 RETVAL->pl = pango_layout_new (opengl_context);
1091 RETVAL->r = 1.; 1373 RETVAL->r = 1.;
1092 RETVAL->g = 1.; 1374 RETVAL->g = 1.;
1093 RETVAL->b = 1.; 1375 RETVAL->b = 1.;
1094 RETVAL->a = 1.; 1376 RETVAL->a = 1.;
1095 RETVAL->base_height = MIN_FONT_HEIGHT; 1377 RETVAL->base_height = MIN_FONT_HEIGHT;
1096 RETVAL->font = 0; 1378 RETVAL->font = 0;
1097 RETVAL->rc = rc_alloc ();
1098 1379
1099 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR); 1380 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
1100 layout_update_font (RETVAL); 1381 layout_update_font (RETVAL);
1101 OUTPUT: 1382 OUTPUT:
1102 RETVAL 1383 RETVAL
1103 1384
1104void 1385void
1105DESTROY (DC::Layout self) 1386DESTROY (DC::Layout self)
1106 CODE: 1387 CODE:
1107 g_object_unref (self->pl); 1388 g_object_unref (self->pl);
1108 rc_free (self->rc);
1109 Safefree (self); 1389 delete self;
1110 1390
1111void 1391void
1112set_text (DC::Layout self, SV *text_) 1392set_text (DC::Layout self, SV *text_)
1113 CODE: 1393 CODE:
1114{ 1394{
… …
1240 1520
1241void 1521void
1242set_height (DC::Layout self, int base_height) 1522set_height (DC::Layout self, int base_height)
1243 CODE: 1523 CODE:
1244 if (self->base_height != base_height) 1524 if (self->base_height != base_height)
1245 { 1525 {
1246 self->base_height = base_height; 1526 self->base_height = base_height;
1247 layout_update_font (self); 1527 layout_update_font (self);
1248 } 1528 }
1249 1529
1250void 1530void
… …
1331 PPCODE: 1611 PPCODE:
1332{ 1612{
1333 int line, x; 1613 int line, x;
1334 1614
1335 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x); 1615 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
1336#if !(defined (PANGO_VERSION_CHECK) && PANGO_VERSION_CHECK (1, 17, 3)) 1616#if !PANGO_VERSION_CHECK (1, 17, 3)
1337 /* pango bug: line is between 1..numlines, not 0..numlines-1 */ 1617 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
1338 --line; 1618 --line;
1339#endif 1619#endif
1340 EXTEND (SP, 2); 1620 EXTEND (SP, 2);
1341 PUSHs (sv_2mortal (newSViv (line))); 1621 PUSHs (sv_2mortal (newSViv (line)));
… …
1368} 1648}
1369 1649
1370void 1650void
1371render (DC::Layout self, float x, float y, int flags = 0) 1651render (DC::Layout self, float x, float y, int flags = 0)
1372 CODE: 1652 CODE:
1373 rc_clear (self->rc); 1653 self->rc.clear ();
1374 pango_opengl_render_layout_subpixel ( 1654 pango_opengl_render_layout_subpixel (
1375 self->pl, 1655 self->pl,
1376 self->rc, 1656 &self->rc,
1377 x * PANGO_SCALE, y * PANGO_SCALE, 1657 x * PANGO_SCALE, y * PANGO_SCALE,
1378 self->r, self->g, self->b, self->a, 1658 self->r, self->g, self->b, self->a,
1379 flags 1659 flags
1380 ); 1660 );
1381 // we assume that context_change actually clears/frees stuff 1661 // we assume that context_change actually clears/frees stuff
… …
1392 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, 1672 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1393 GL_ONE , GL_ONE_MINUS_SRC_ALPHA); 1673 GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1394 glEnable (GL_ALPHA_TEST); 1674 glEnable (GL_ALPHA_TEST);
1395 glAlphaFunc (GL_GREATER, 7.f / 255.f); 1675 glAlphaFunc (GL_GREATER, 7.f / 255.f);
1396 1676
1397 rc_draw (self->rc); 1677 self->rc.draw ();
1398 1678
1399 glDisable (GL_ALPHA_TEST); 1679 glDisable (GL_ALPHA_TEST);
1400 glDisable (GL_BLEND); 1680 glDisable (GL_BLEND);
1401 glDisable (GL_TEXTURE_2D); 1681 glDisable (GL_TEXTURE_2D);
1402} 1682}
… …
1477 glDisable (GL_ALPHA_TEST); 1757 glDisable (GL_ALPHA_TEST);
1478 glDisable (GL_BLEND); 1758 glDisable (GL_BLEND);
1479 } 1759 }
1480} 1760}
1481 1761
1762void
1763draw_fow_texture (float intensity, int hidden_tex, int name1, uint8_t *data1, float s, float t, int w, int h, float blend = 0.f, int dx = 0, int dy = 0, int name2 = 0, uint8_t *data2 = data1)
1764 PROTOTYPE: @
1765 CODE:
1766{
1767 glEnable (GL_BLEND);
1768 glBlendFunc (intensity ? GL_SRC_ALPHA : GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1769 glEnable (GL_TEXTURE_2D);
1770 glBindTexture (GL_TEXTURE_2D, name1);
1771
1772 glColor3f (intensity, intensity, intensity);
1773 glPushMatrix ();
1774 glScalef (1./3, 1./3, 1.);
1775
1776 if (blend > 0.f)
1777 {
1778 float dx3 = dx * -3.f / w;
1779 float dy3 = dy * -3.f / h;
1780 GLfloat env_color[4] = { 0., 0., 0., blend };
1781
1782 /* interpolate the two shadow textures */
1783 /* stage 0 == rgb(glcolor) + alpha(t0) */
1784 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1785
1786 /* stage 1 == rgb(glcolor) + alpha(interpolate t0, t1, texenv) */
1787 gl.ActiveTexture (GL_TEXTURE1);
1788 glEnable (GL_TEXTURE_2D);
1789 glBindTexture (GL_TEXTURE_2D, name2);
1790 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
1791
1792 /* rgb == rgb(glcolor) */
1793 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
1794 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
1795 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
1796
1797 /* alpha = interpolate t0, t1 by env_alpha */
1798 glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, env_color);
1799
1800 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_INTERPOLATE);
1801 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
1802 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
1803
1804 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
1805 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
1806
1807 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);
1808 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);
1809
1810 glBegin (GL_QUADS);
1811 gl.MultiTexCoord2f (GL_TEXTURE0, 0, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 ); glVertex2i (0, 0);
1812 gl.MultiTexCoord2f (GL_TEXTURE0, 0, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 + t); glVertex2i (0, h);
1813 gl.MultiTexCoord2f (GL_TEXTURE0, s, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 + t); glVertex2i (w, h);
1814 gl.MultiTexCoord2f (GL_TEXTURE0, s, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 ); glVertex2i (w, 0);
1815 glEnd ();
1816
1817 glDisable (GL_TEXTURE_2D);
1818 gl.ActiveTexture (GL_TEXTURE0);
1819 }
1820 else
1821 {
1822 /* simple blending of one texture, also opengl <1.3 path */
1823 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1824
1825 glBegin (GL_QUADS);
1826 glTexCoord2f (0, 0); glVertex2f (0, 0);
1827 glTexCoord2f (0, t); glVertex2f (0, h);
1828 glTexCoord2f (s, t); glVertex2f (w, h);
1829 glTexCoord2f (s, 0); glVertex2f (w, 0);
1830 glEnd ();
1831 }
1832
1833 /* draw ?-marks or equivalent, this is very clumsy code :/ */
1834 {
1835 int x, y;
1836 int dx3 = dx * 3;
1837 int dy3 = dy * 3;
1838
1839 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1840 glBindTexture (GL_TEXTURE_2D, hidden_tex);
1841 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1842 glTranslatef (-1., -1., 0);
1843 glBegin (GL_QUADS);
1844
1845 for (y = 1; y < h; y += 3)
1846 {
1847 int y1 = y - dy3;
1848 int y1valid = y1 >= 0 && y1 < h;
1849
1850 for (x = 1; x < w; x += 3)
1851 {
1852 int x1 = x - dx3;
1853 uint8_t h1 = data1 [x + y * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1854 uint8_t h2;
1855
1856 if (y1valid && x1 >= 0 && x1 < w)
1857 h2 = data2 [x1 + y1 * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1858 else
1859 h2 = 1; /* out of range == invisible */
1860
1861 if (h1 || h2)
1862 {
1863 float alpha = h1 == h2 ? 1.f : h1 ? 1.f - blend : blend;
1864 glColor4f (1., 1., 1., alpha);
1865
1866 glTexCoord2f (0, 0.); glVertex2i (x , y );
1867 glTexCoord2f (0, 1.); glVertex2i (x , y + 3);
1868 glTexCoord2f (1, 1.); glVertex2i (x + 3, y + 3);
1869 glTexCoord2f (1, 0.); glVertex2i (x + 3, y );
1870 }
1871 }
1872 }
1873 }
1874
1875 glEnd ();
1876
1877 glPopMatrix ();
1878
1879 glDisable (GL_TEXTURE_2D);
1880 glDisable (GL_BLEND);
1881}
1882
1482IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type) 1883IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1483 CODE: 1884 CODE:
1484{ 1885{
1485 GLint width; 1886 GLint width;
1486 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0); 1887 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
… …
1493MODULE = Deliantra::Client PACKAGE = DC::Map 1894MODULE = Deliantra::Client PACKAGE = DC::Map
1494 1895
1495PROTOTYPES: DISABLE 1896PROTOTYPES: DISABLE
1496 1897
1497DC::Map 1898DC::Map
1498new (SV *class) 1899new (SV *klass)
1499 CODE: 1900 CODE:
1500 New (0, RETVAL, 1, struct map); 1901 New (0, RETVAL, 1, mapgrid);
1501 RETVAL->x = 0; 1902 RETVAL->x = 0;
1502 RETVAL->y = 0; 1903 RETVAL->y = 0;
1503 RETVAL->w = 0; 1904 RETVAL->w = 0;
1504 RETVAL->h = 0; 1905 RETVAL->h = 0;
1505 RETVAL->ox = 0; 1906 RETVAL->ox = 0;
… …
1542 1943
1543void 1944void
1544set_smooth (DC::Map self, int face, int smooth, int level) 1945set_smooth (DC::Map self, int face, int smooth, int level)
1545 CODE: 1946 CODE:
1546{ 1947{
1547 tileid texid; 1948 tileid texid;
1548 maptex *tex; 1949 maptex *tex;
1549 1950
1550 if (face < 0 || face >= self->faces) 1951 if (face < 0 || face >= self->faces)
1551 return; 1952 return;
1552 1953
1553 if (smooth < 0 || smooth >= self->faces) 1954 if (smooth < 0 || smooth >= self->faces)
1554 return; 1955 return;
1555 1956
1556 texid = self->face2tile [face]; 1957 texid = self->face2tile [face];
1557 1958
1558 if (!texid) 1959 if (!texid)
1559 return; 1960 return;
1560 1961
1561 tex = self->tex + texid; 1962 tex = self->tex + texid;
… …
1590 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 1991 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1591 // use uglier nearest interpolation because linear suffers 1992 // use uglier nearest interpolation because linear suffers
1592 // from transparent color bleeding and ugly wrapping effects. 1993 // from transparent color bleeding and ugly wrapping effects.
1593 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1994 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1594} 1995}
1996
1997void
1998expire_textures (DC::Map self, int texid, int count)
1999 PPCODE:
2000 for (; texid < self->texs && count; ++texid, --count)
2001 {
2002 maptex *tex = self->tex + texid;
2003
2004 if (tex->name)
2005 {
2006 if (tex->unused)
2007 {
2008 tex->name = 0;
2009 tex->unused = 0;
2010 XPUSHs (sv_2mortal (newSViv (texid)));
2011 }
2012 else
2013 tex->unused = 1;
2014 }
2015 }
1595 2016
1596int 2017int
1597ox (DC::Map self) 2018ox (DC::Map self)
1598 ALIAS: 2019 ALIAS:
1599 oy = 1 2020 oy = 1
… …
1631 self->ox += dx; self->x += dx; 2052 self->ox += dx; self->x += dx;
1632 self->oy += dy; self->y += dy; 2053 self->oy += dy; self->y += dy;
1633 2054
1634 while (self->y < 0) 2055 while (self->y < 0)
1635 { 2056 {
1636 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y); 2057 prepend (self->row, self->rows, MAP_EXTEND_Y);
1637 2058
1638 self->rows += MAP_EXTEND_Y; 2059 self->rows += MAP_EXTEND_Y;
1639 self->y += MAP_EXTEND_Y; 2060 self->y += MAP_EXTEND_Y;
1640 } 2061 }
1641} 2062}
1642 2063
1643SV * 2064SV *
1644map1a_update (DC::Map self, SV *data_, int extmap) 2065map1a_update (DC::Map self, SV *data_)
1645 CODE: 2066 CODE:
1646{ 2067{
1647 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 2068 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1648 uint8_t *data_end = (uint8_t *)SvEND (data_); 2069 uint8_t *data_end = (uint8_t *)SvEND (data_);
1649 mapcell *cell; 2070 mapcell *cell;
… …
1670 2091
1671 //TODO: don't trust server data to be in-range(!) 2092 //TODO: don't trust server data to be in-range(!)
1672 2093
1673 if (flags & 8) 2094 if (flags & 8)
1674 { 2095 {
2096 uint8_t ext, cmd;
2097
1675 if (extmap) 2098 do
1676 { 2099 {
1677 uint8_t ext, cmd; 2100 ext = *data++;
2101 cmd = ext & 0x7f;
1678 2102
1679 do 2103 if (cmd < 4)
2104 cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
2105 else if (cmd == 5) // health
1680 { 2106 {
1681 ext = *data++;
1682 cmd = ext & 0x3f;
1683
1684 if (cmd < 4)
1685 cell->darkness = 255 - ext * 64 + 1;
1686 else if (cmd == 5) // health
1687 {
1688 cell->stat_width = 1; 2107 cell->stat_width = 1;
1689 cell->stat_hp = *data++; 2108 cell->stat_hp = *data++;
1690 }
1691 else if (cmd == 6) // monster width
1692 cell->stat_width = *data++ + 1;
1693 else if (cmd == 0x47)
1694 {
1695 if (*data == 4)
1696 ; // decode player count
1697
1698 data += *data + 1;
1699 }
1700 else if (cmd == 8) // cell flags
1701 cell->flags = *data++;
1702 else if (ext & 0x40) // unknown, multibyte => skip
1703 data += *data + 1;
1704 else
1705 data++;
1706 } 2109 }
1707 while (ext & 0x80); 2110 else if (cmd == 6) // monster width
2111 cell->stat_width = *data++ + 1;
2112 else if (cmd == 0x47)
2113 {
2114 if (*data == 1) cell->player = data [1];
2115 else if (*data == 2) cell->player = data [2] + (data [1] << 8);
2116 else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
2117 else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
2118
2119 data += *data + 1;
2120 }
2121 else if (cmd == 8) // cell flags
2122 cell->flags = *data++;
2123 else if (ext & 0x40) // unknown, multibyte => skip
2124 data += *data + 1;
2125 else
2126 data++;
1708 } 2127 }
1709 else 2128 while (ext & 0x80);
1710 cell->darkness = *data++ + 1;
1711 } 2129 }
1712 2130
1713 for (z = 0; z <= 2; ++z) 2131 for (z = 0; z <= 2; ++z)
1714 if (flags & (4 >> z)) 2132 if (flags & (4 >> z))
1715 { 2133 {
… …
1718 cell->tile [z] = self->face2tile [face]; 2136 cell->tile [z] = self->face2tile [face];
1719 2137
1720 if (cell->tile [z]) 2138 if (cell->tile [z])
1721 { 2139 {
1722 maptex *tex = self->tex + cell->tile [z]; 2140 maptex *tex = self->tex + cell->tile [z];
2141 tex->unused = 0;
1723 if (!tex->name) 2142 if (!tex->name)
1724 av_push (missing, newSViv (cell->tile [z])); 2143 av_push (missing, newSViv (cell->tile [z]));
1725 2144
1726 if (tex->smoothtile) 2145 if (tex->smoothtile)
1727 { 2146 {
1728 maptex *smooth = self->tex + tex->smoothtile; 2147 maptex *smooth = self->tex + tex->smoothtile;
2148 smooth->unused = 0;
1729 if (!smooth->name) 2149 if (!smooth->name)
1730 av_push (missing, newSViv (tex->smoothtile)); 2150 av_push (missing, newSViv (tex->smoothtile));
1731 } 2151 }
1732 } 2152 }
1733 } 2153 }
1734 } 2154 }
1735 else 2155 else
1736 cell->darkness = 0; 2156 CELL_CLEAR (cell);
1737 } 2157 }
1738} 2158}
1739 OUTPUT: 2159 OUTPUT:
1740 RETVAL 2160 RETVAL
1741 2161
… …
1761 ? self->row + y 2181 ? self->row + y
1762 : 0; 2182 : 0;
1763 2183
1764 for (x = x0; x < x1; x++) 2184 for (x = x0; x < x1; x++)
1765 { 2185 {
1766 int r = 32, g = 32, b = 32, a = 192; 2186 unsigned int r = 32, g = 32, b = 32, a = 192;
1767 2187
1768 if (row && row->c0 <= x && x < row->c1) 2188 if (row && row->c0 <= x && x < row->c1)
1769 { 2189 {
1770 mapcell *cell = row->col + (x - row->c0); 2190 mapcell *cell = row->col + (x - row->c0);
1771 2191
… …
1773 { 2193 {
1774 maptex tex = self->tex [cell->tile [z]]; 2194 maptex tex = self->tex [cell->tile [z]];
1775 int a0 = 255 - tex.a; 2195 int a0 = 255 - tex.a;
1776 int a1 = tex.a; 2196 int a1 = tex.a;
1777 2197
1778 r = (r * a0 + tex.r * a1) / 255; 2198 r = div255 (r * a0 + tex.r * a1);
1779 g = (g * a0 + tex.g * a1) / 255; 2199 g = div255 (g * a0 + tex.g * a1);
1780 b = (b * a0 + tex.b * a1) / 255; 2200 b = div255 (b * a0 + tex.b * a1);
1781 a = (a * a0 + tex.a * a1) / 255; 2201 a = div255 (a * a0 + tex.a * a1);
1782 } 2202 }
1783 } 2203 }
1784 2204
1785 *map++ = (r ) 2205 *map++ = (r )
1786 | (g << 8) 2206 | (g << 8)
1787 | (b << 16) 2207 | (b << 16)
1788 | (a << 24); 2208 | (a << 24);
1789 } 2209 }
1790 } 2210 }
1791 2211
1792 RETVAL = map_sv; 2212 RETVAL = map_sv;
1793} 2213}
1794 OUTPUT: 2214 OUTPUT:
1795 RETVAL 2215 RETVAL
1796 2216
1797void 2217void
1798draw (DC::Map self, int mx, int my, int sw, int sh, int T) 2218draw (DC::Map self, int mx, int my, int sw, int sh, int Tw, int Th, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)
1799 CODE: 2219 CODE:
1800{ 2220{
1801 int x, y, z; 2221 int x, y, z;
1802 2222
1803 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1804 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1805 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k) 2223 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k), also, static!
1806 smooth_key skey; 2224 int pl_x, pl_y;
1807 2225 maptex pl_tex;
1808 rc_t *rc = rc_alloc (); 2226 rc_t rc;
2227 rc_t rc_ov;
1809 rc_key_t key; 2228 rc_key_t key;
1810 rc_array_t *arr; 2229 rc_t::array_t *arr;
1811 2230
2231 pl_tex.name = 0;
2232
1812 // thats current max. sorry. 2233 // that's current max. sorry.
1813 if (sw > 255) sw = 255; 2234 if (sw > 255) sw = 255;
1814 if (sh > 255) sh = 255; 2235 if (sh > 255) sh = 255;
1815
1816 // clear key, in case of extra padding
1817 memset (&skey, 0, sizeof (skey));
1818 2236
1819 memset (&key, 0, sizeof (key)); 2237 memset (&key, 0, sizeof (key));
1820 key.r = 255; 2238 key.r = 255;
1821 key.g = 255; 2239 key.g = 255;
1822 key.b = 255; 2240 key.b = 255;
1823 key.a = 255; 2241 key.a = 255;
1824 key.mode = GL_QUADS; 2242 key.mode = GL_QUADS;
1825 key.format = GL_T2F_V3F; 2243 key.format = GL_T2F_V3F;
1826 key.texname = -1;
1827 2244
1828 mx += self->x; 2245 mx += self->x;
1829 my += self->y; 2246 my += self->y;
1830 2247
1831 // first pass: determine smooth_max 2248 // first pass: determine smooth_max
1832 // rather ugly, if you ask me 2249 // rather ugly, if you ask me
1833 // could also be stored inside mapcell and updated on change 2250 // could also be stored inside mapcell and updated on change
1834 memset (smooth_max, 0, sizeof (smooth_max)); 2251 memset (smooth_max, 0, sizeof (smooth_max[0]) * (sh + 1));
1835 2252
1836 for (y = 0; y < sh; y++) 2253 for (y = 0; y < sh; y++)
1837 if (0 <= y + my && y + my < self->rows) 2254 if (0 <= y + my && y + my < self->rows)
1838 { 2255 {
1839 maprow *row = self->row + (y + my); 2256 maprow *row = self->row + (y + my);
… …
1854 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2271 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1855 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2272 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1856 2273
1857 for (z = 0; z <= 2; z++) 2274 for (z = 0; z <= 2; z++)
1858 { 2275 {
1859 memset (smooth_level, 0, sizeof (smooth_level)); 2276 std::bitset<256> smooth_level; // one bit for every possible smooth level
2277 smooth_key skey;
2278 smooth_hash smooth;
2279 key.texname = -1;
1860 2280
1861 for (y = 0; y < sh; y++) 2281 for (y = 0; y < sh; y++)
1862 if (0 <= y + my && y + my < self->rows) 2282 if (0 <= y + my && y + my < self->rows)
1863 { 2283 {
1864 maprow *row = self->row + (y + my); 2284 maprow *row = self->row + (y + my);
… …
1874 maptex tex = self->tex [tile]; 2294 maptex tex = self->tex [tile];
1875 int px, py; 2295 int px, py;
1876 2296
1877 if (key.texname != tex.name) 2297 if (key.texname != tex.name)
1878 { 2298 {
2299 self->tex [tile].unused = 0;
2300
1879 if (!tex.name) 2301 if (!tex.name)
1880 tex = self->tex [2]; /* missing, replace by noface */ 2302 tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
1881 2303
1882 key.texname = tex.name; 2304 key.texname = tex.name;
1883 arr = rc_array (rc, &key); 2305 arr = &rc.array (key);
1884 } 2306 }
1885 2307
1886 px = (x + 1) * T - tex.w; 2308 px = (x + 1) * Th - tex.w;
1887 py = (y + 1) * T - tex.h; 2309 py = (y + 1) * Tw - tex.h;
1888 2310
1889 rc_t2f_v3f (arr, 0 , 0 , px , py , 0); 2311 if (expect_false (cell->player == player) && expect_false (z == 2))
1890 rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
1891 rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
1892 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
1893
1894 if (cell->flags && z == 2)
1895 { 2312 {
1896 // overlays such as the speech bubble, probably more to come 2313 pl_x = px;
1897 if (cell->flags & 1) 2314 pl_y = py;
2315 pl_tex = tex;
1898 { 2316 continue;
1899 maptex tex = self->tex [1];
1900 int px = x * T + T * 2 / 32;
1901 int py = y * T - T * 6 / 32;
1902
1903 if (tex.name)
1904 {
1905 if (key.texname != tex.name)
1906 {
1907 key.texname = tex.name;
1908 arr = rc_array (rc, &key);
1909 }
1910
1911 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
1912 rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
1913 rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
1914 rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
1915 }
1916 }
1917 } 2317 }
2318
2319 arr->t2f_v3f (0 , 0 , px , py , 0);
2320 arr->t2f_v3f (0 , tex.t, px , py + tex.h, 0);
2321 arr->t2f_v3f (tex.s, tex.t, px + tex.w, py + tex.h, 0);
2322 arr->t2f_v3f (tex.s, 0 , px + tex.w, py , 0);
1918 2323
1919 // update smooth hash 2324 // update smooth hash
1920 if (tex.smoothtile) 2325 if (tex.smoothtile)
1921 { 2326 {
1922 skey.tile = tex.smoothtile; 2327 skey.tile = tex.smoothtile;
1923 skey.level = tex.smoothlevel; 2328 skey.level = tex.smoothlevel;
1924 2329
1925 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31); 2330 smooth_level[tex.smoothlevel] = 1;
1926 2331
1927 // add bits to current tile and all neighbours. skey.x|y is 2332 // add bits to current tile and all neighbours. skey.x|y is
1928 // shifted +1|+1 so we always stay positive. 2333 // shifted +1|+1 so we always stay positive.
1929 2334
1930 // bits is ___n cccc CCCC bbbb 2335 // bits is ___n cccc CCCC bbbb
… …
1938 2343
1939 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ·· 2344 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1940 // ·· ·· ·┏ ┓· 2345 // ·· ·· ·┏ ┓·
1941 2346
1942 // full tile 2347 // full tile
1943 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000); 2348 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x1000);
1944 2349
1945 // borders 2350 // borders
1946 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091); 2351 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0091);
1947 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032); 2352 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0032);
1948 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064); 2353 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0064);
1949 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8); 2354 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, skey, 0x00c8);
1950 2355
1951 // corners 2356 // corners
1952 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100); 2357 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0100);
1953 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200); 2358 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0200);
1954 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400); 2359 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, skey, 0x0400);
1955 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800); 2360 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, skey, 0x0800);
2361 }
2362 }
2363
2364 if (expect_false (z == 2) && expect_false (cell->flags))
2365 {
2366 // overlays such as the speech bubble, probably more to come
2367 if (cell->flags & 1)
2368 {
2369 rc_key_t key_ov = key;
2370 maptex tex = self->tex[TEXID_SPEECH];
2371 int px = x * Tw + Tw * 2 / 32;
2372 int py = y * Th - Th * 6 / 32;
2373
2374 key_ov.texname = tex.name;
2375 rc_t::array_t &arr = rc_ov.array (key_ov);
2376
2377 arr.t2f_v3f (0 , 0 , px , py , 0);
2378 arr.t2f_v3f (0 , tex.t, px , py + Th, 0);
2379 arr.t2f_v3f (tex.s, tex.t, px + Tw, py + Th, 0);
2380 arr.t2f_v3f (tex.s, 0 , px + Tw, py , 0);
1956 } 2381 }
1957 } 2382 }
1958 } 2383 }
1959 } 2384 }
1960 2385
1961 rc_draw (rc); 2386 rc.draw ();
1962 rc_clear (rc); 2387 rc.clear ();
1963 2388
1964 // go through all smoothlevels, lowest to highest, then draw. 2389 // go through all smoothlevels, lowest to highest, then draw.
1965 // this is basically counting sort 2390 // this is basically counting sort
1966 { 2391 {
1967 int w, b; 2392 int w, b;
1968 2393
1969 glEnable (GL_TEXTURE_2D); 2394 glEnable (GL_TEXTURE_2D);
1970 glBegin (GL_QUADS); 2395 glBegin (GL_QUADS);
1971 for (w = 0; w < 256 / 32; ++w) 2396 for (int level = 0; level < smooth_level.size (); ++level)
2397 if (smooth_level[level])
2398 for (auto &&it = smooth.begin (); it != smooth.end (); ++it)
1972 { 2399 {
1973 uint32_t smask = smooth_level [w]; 2400 smooth_key &skey = it->first;
1974 if (smask) 2401 IV bits = it->second;
1975 for (b = 0; b < 32; ++b) 2402
1976 if (smask & (((uint32_t)1) << b)) 2403 if (!(bits & 0x1000)
2404 && skey.level == level
2405 && level > smooth_max [skey.x][skey.y])
1977 { 2406 {
1978 int level = (w << 5) | b; 2407 maptex tex = self->tex [skey.tile];
2408 int px = (((int)skey.x) - 1) * Tw;
2409 int py = (((int)skey.y) - 1) * Th;
2410 int border = bits & 15;
2411 int corner = (bits >> 8) & ~(bits >> 4) & 15;
2412 float dx = tex.s * .0625f; // 16 images/row
2413 float dy = tex.t * .5f ; // 2 images/column
2414
1979 HE *he; 2415 if (tex.name)
1980
1981 hv_iterinit (smooth);
1982 while ((he = hv_iternext (smooth)))
1983 { 2416 {
1984 smooth_key *skey = (smooth_key *)HeKEY (he); 2417 // this time avoiding texture state changes
1985 IV bits = SvIVX (HeVAL (he)); 2418 // save gobs of state changes.
1986 2419 if (key.texname != tex.name)
1987 if (!(bits & 0x1000)
1988 && skey->level == level
1989 && level > smooth_max [skey->x][skey->y])
1990 { 2420 {
1991 maptex tex = self->tex [skey->tile]; 2421 self->tex [skey.tile].unused = 0;
1992 int px = (((int)skey->x) - 1) * T;
1993 int py = (((int)skey->y) - 1) * T;
1994 int border = bits & 15;
1995 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1996 float dx = tex.s * .0625f; // 16 images/row
1997 float dy = tex.t * .5f ; // 2 images/column
1998 2422
1999 if (tex.name)
2000 {
2001 // this time avoiding texture state changes
2002 // save gobs of state changes.
2003 if (key.texname != tex.name)
2004 {
2005 glEnd (); 2423 glEnd ();
2006 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name); 2424 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
2007 glBegin (GL_QUADS); 2425 glBegin (GL_QUADS);
2008 } 2426 }
2009 2427
2010 if (border) 2428 if (border)
2011 { 2429 {
2012 float ox = border * dx; 2430 float ox = border * dx;
2013 2431
2014 glTexCoord2f (ox , 0.f ); glVertex2i (px , py ); 2432 glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
2015 glTexCoord2f (ox , dy ); glVertex2i (px , py + T); 2433 glTexCoord2f (ox , dy ); glVertex2i (px , py + Th);
2016 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T); 2434 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py + Th);
2017 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py ); 2435 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + Tw, py );
2018 } 2436 }
2019 2437
2020 if (corner) 2438 if (corner)
2021 { 2439 {
2022 float ox = corner * dx; 2440 float ox = corner * dx;
2023 2441
2024 glTexCoord2f (ox , dy ); glVertex2i (px , py ); 2442 glTexCoord2f (ox , dy ); glVertex2i (px , py );
2025 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T); 2443 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + Th);
2026 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T); 2444 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + Tw, py + Th);
2027 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py ); 2445 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py );
2028 }
2029 }
2030 } 2446 }
2031 } 2447 }
2032 } 2448 }
2033 } 2449 }
2034 2450
2035 glEnd (); 2451 glEnd ();
2036 glDisable (GL_TEXTURE_2D); 2452 glDisable (GL_TEXTURE_2D);
2037 key.texname = -1; 2453 key.texname = -1;
2038 } 2454 }
2039
2040 hv_clear (smooth);
2041 } 2455 }
2042 2456
2457 if (pl_tex.name)
2458 {
2459 maptex tex = pl_tex;
2460 int px = pl_x + sdx;
2461 int py = pl_y + sdy;
2462
2463 key.texname = tex.name;
2464 rc_t::array_t &arr = rc.array (key);
2465
2466 arr.t2f_v3f (0 , 0 , px , py , 0);
2467 arr.t2f_v3f (0 , tex.t, px , py + tex.h, 0);
2468 arr.t2f_v3f (tex.s, tex.t, px + tex.w, py + tex.h, 0);
2469 arr.t2f_v3f (tex.s, 0 , px + tex.w, py , 0);
2470
2471 rc.draw ();
2472 }
2473
2474 rc_ov.draw ();
2475 rc_ov.clear ();
2476
2043 glDisable (GL_BLEND); 2477 glDisable (GL_BLEND);
2044 rc_free (rc);
2045 2478
2046 // top layer: overlays such as the health bar 2479 // top layer: overlays such as the health bar
2047 for (y = 0; y < sh; y++) 2480 for (y = 0; y < sh; y++)
2048 if (0 <= y + my && y + my < self->rows) 2481 if (0 <= y + my && y + my < self->rows)
2049 { 2482 {
… …
2052 for (x = 0; x < sw; x++) 2485 for (x = 0; x < sw; x++)
2053 if (row->c0 <= x + mx && x + mx < row->c1) 2486 if (row->c0 <= x + mx && x + mx < row->c1)
2054 { 2487 {
2055 mapcell *cell = row->col + (x + mx - row->c0); 2488 mapcell *cell = row->col + (x + mx - row->c0);
2056 2489
2057 int px = x * T; 2490 int px = x * Tw;
2058 int py = y * T; 2491 int py = y * Th;
2492
2493 if (expect_false (cell->player == player))
2494 {
2495 px += sdx;
2496 py += sdy;
2497 }
2059 2498
2060 if (cell->stat_hp) 2499 if (cell->stat_hp)
2061 { 2500 {
2062 int width = cell->stat_width * T; 2501 int width = cell->stat_width * Tw;
2063 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width; 2502 int thick = (sh * Th / 32 + 27) / 28 + 1 + cell->stat_width;
2064 2503
2065 glColor3ub (0, 0, 0); 2504 glColor3ub (0, 0, 0);
2066 glRectf (px + 1, py - thick - 2, 2505 glRectf (px + 1, py - thick - 2,
2067 px + width - 1, py); 2506 px + width - 1, py);
2068 2507
… …
2074 } 2513 }
2075 } 2514 }
2076} 2515}
2077 2516
2078void 2517void
2079draw_magicmap (DC::Map self, int dx, int dy, int w, int h, unsigned char *data) 2518draw_magicmap (DC::Map self, int w, int h, unsigned char *data)
2080 CODE: 2519 CODE:
2081{ 2520{
2082 static float color[16][3] = { 2521 static float color[16][3] = {
2083 { 0.00F, 0.00F, 0.00F }, 2522 { 0.00f, 0.00f, 0.00f },
2084 { 1.00F, 1.00F, 1.00F }, 2523 { 1.00f, 1.00f, 1.00f },
2085 { 0.00F, 0.00F, 0.55F }, 2524 { 0.00f, 0.00f, 0.55f },
2086 { 1.00F, 0.00F, 0.00F }, 2525 { 1.00f, 0.00f, 0.00f },
2087 2526
2088 { 1.00F, 0.54F, 0.00F }, 2527 { 1.00f, 0.54f, 0.00f },
2089 { 0.11F, 0.56F, 1.00F }, 2528 { 0.11f, 0.56f, 1.00f },
2090 { 0.93F, 0.46F, 0.00F }, 2529 { 0.93f, 0.46f, 0.00f },
2091 { 0.18F, 0.54F, 0.34F }, 2530 { 0.18f, 0.54f, 0.34f },
2092 2531
2093 { 0.56F, 0.73F, 0.56F }, 2532 { 0.56f, 0.73f, 0.56f },
2094 { 0.80F, 0.80F, 0.80F }, 2533 { 0.80f, 0.80f, 0.80f },
2095 { 0.55F, 0.41F, 0.13F }, 2534 { 0.55f, 0.41f, 0.13f },
2096 { 0.99F, 0.77F, 0.26F }, 2535 { 0.99f, 0.77f, 0.26f },
2097 2536
2098 { 0.74F, 0.65F, 0.41F }, 2537 { 0.74f, 0.65f, 0.41f },
2099 2538
2100 { 0.00F, 1.00F, 1.00F }, 2539 { 0.00f, 1.00f, 1.00f },
2101 { 1.00F, 0.00F, 1.00F }, 2540 { 1.00f, 0.00f, 1.00f },
2102 { 1.00F, 1.00F, 0.00F }, 2541 { 1.00f, 1.00f, 0.00f },
2103 }; 2542 };
2104 2543
2105 int x, y; 2544 int x, y;
2106 2545
2107 glEnable (GL_TEXTURE_2D); 2546 glEnable (GL_TEXTURE_2D);
2547 /* GL_REPLACE would be correct, as we don't need to modulate alpha,
2548 * but the nvidia driver (185.18.14) mishandles alpha textures
2549 * and takes the colour from god knows where instead of using
2550 * Cp. MODULATE results in the same colour, but slightly different
2551 * alpha, but atcually gives us the correct colour with nvidia.
2552 */
2108 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2553 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
2109 glEnable (GL_BLEND); 2554 glEnable (GL_BLEND);
2110 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2555 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2111 glBegin (GL_QUADS); 2556 glBegin (GL_QUADS);
2112 2557
2113 for (y = 0; y < h; y++) 2558 for (y = 0; y < h; y++)
… …
2117 2562
2118 if (m) 2563 if (m)
2119 { 2564 {
2120 float *c = color [m & 15]; 2565 float *c = color [m & 15];
2121 2566
2122 float tx1 = m & 0x40 ? 0.5 : 0.; 2567 float tx1 = m & 0x40 ? 0.5f : 0.f;
2123 float tx2 = tx1 + 0.5; 2568 float tx2 = tx1 + 0.5f;
2124 2569
2125 glColor4f (c[0], c[1], c[2], 0.75); 2570 glColor4f (c[0], c[1], c[2], 1);
2126 glTexCoord2f (tx1, 0.); glVertex2i (x , y ); 2571 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2127 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1); 2572 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2128 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1); 2573 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2129 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y ); 2574 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2130 } 2575 }
… …
2138void 2583void
2139fow_texture (DC::Map self, int mx, int my, int sw, int sh) 2584fow_texture (DC::Map self, int mx, int my, int sw, int sh)
2140 PPCODE: 2585 PPCODE:
2141{ 2586{
2142 int x, y; 2587 int x, y;
2143 int sw1 = sw + 2; 2588 int sw1 = sw + 2;
2144 int sh1 = sh + 2; 2589 int sh1 = sh + 2;
2145 int sh3 = sh * 3; 2590 int sh3 = sh * 3;
2146 int sw34 = (sw * 3 + 3) & ~3; 2591 int sw3 = sw * 3;
2592 SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3));
2593 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2147 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1); 2594 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2148 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3)); 2595 memset (darkness1, 0, sw1*sh1);
2149 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2150 2596
2151 SvPOK_only (darkness3_sv); 2597 SvPOK_only (darkness3_sv);
2152 SvCUR_set (darkness3_sv, sw34 * sh3); 2598 SvCUR_set (darkness3_sv, sw3 * sh3);
2153 2599
2154 mx += self->x - 1; 2600 mx += self->x - 1;
2155 my += self->y - 1; 2601 my += self->y - 1;
2156
2157 memset (darkness1, 255, sw1 * sh1);
2158 2602
2159 for (y = 0; y < sh1; y++) 2603 for (y = 0; y < sh1; y++)
2160 if (0 <= y + my && y + my < self->rows) 2604 if (0 <= y + my && y + my < self->rows)
2161 { 2605 {
2162 maprow *row = self->row + (y + my); 2606 maprow *row = self->row + (y + my);
… …
2165 if (row->c0 <= x + mx && x + mx < row->c1) 2609 if (row->c0 <= x + mx && x + mx < row->c1)
2166 { 2610 {
2167 mapcell *cell = row->col + (x + mx - row->c0); 2611 mapcell *cell = row->col + (x + mx - row->c0);
2168 2612
2169 darkness1 [y * sw1 + x] = cell->darkness 2613 darkness1 [y * sw1 + x] = cell->darkness
2170 ? 255 - (cell->darkness - 1) 2614 ? DARKNESS_ADJUST (255 - (cell->darkness - 1))
2171 : 255 - FOW_DARKNESS; 2615 : DARKNESS_ADJUST (255 - FOW_DARKNESS);
2172 } 2616 }
2173 } 2617 }
2174 2618
2175 for (y = 0; y < sh; ++y) 2619 for (y = 0; y < sh; ++y)
2176 for (x = 0; x < sw; ++x) 2620 for (x = 0; x < sw; ++x)
… …
2195 2639
2196 uint8_t r13 = (d13 + d23 + d12) / 3; 2640 uint8_t r13 = (d13 + d23 + d12) / 3;
2197 uint8_t r23 = d23; 2641 uint8_t r23 = d23;
2198 uint8_t r33 = (d23 + d33 + d32) / 3; 2642 uint8_t r33 = (d23 + d33 + d32) / 3;
2199 2643
2200 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11); 2644 darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2201 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21); 2645 darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2202 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31); 2646 darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2203 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12); 2647 darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2204 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22); 2648 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 1)] = MAX (d22, r22); /* this MUST be == d22 */
2205 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32); 2649 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2206 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13); 2650 darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2207 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23); 2651 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2208 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33); 2652 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2209 } 2653 }
2210 2654
2211 free (darkness1); 2655 free (darkness1);
2212 2656
2213 EXTEND (SP, 3); 2657 EXTEND (SP, 3);
2214 PUSHs (sv_2mortal (newSViv (sw34))); 2658 PUSHs (sv_2mortal (newSViv (sw3)));
2215 PUSHs (sv_2mortal (newSViv (sh3))); 2659 PUSHs (sv_2mortal (newSViv (sh3)));
2216 PUSHs (darkness3_sv); 2660 PUSHs (darkness3_sv);
2217} 2661}
2218 2662
2219SV * 2663SV *
… …
2282 else 2726 else
2283 *data++ = 0; 2727 *data++ = 0;
2284 } 2728 }
2285 } 2729 }
2286 2730
2731 /* if size is w*h + 5 then no data has been found */
2732 if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5)
2733 {
2287 SvPOK_only (data_sv); 2734 SvPOK_only (data_sv);
2288 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv)); 2735 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2736 }
2737
2289 RETVAL = data_sv; 2738 RETVAL = data_sv;
2290} 2739}
2291 OUTPUT: 2740 OUTPUT:
2292 RETVAL 2741 RETVAL
2293 2742
2294void 2743void
2295set_rect (DC::Map self, int x0, int y0, uint8_t *data) 2744set_rect (DC::Map self, int x0, int y0, SV *data_sv)
2296 PPCODE: 2745 PPCODE:
2297{ 2746{
2298 int x, y, z; 2747 int x, y, z;
2299 int w, h; 2748 int w, h;
2300 int x1, y1; 2749 int x1, y1;
2750 STRLEN len;
2751 uint8_t *data, *end;
2752
2753 len = SvLEN (data_sv);
2754 SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more
2755 data = (uint8_t *)SvPVbyte_nolen (data_sv);
2756 end = data + len + 8;
2757
2758 if (len < 5)
2759 XSRETURN_EMPTY;
2301 2760
2302 if (*data++ != 0) 2761 if (*data++ != 0)
2303 XSRETURN_EMPTY; /* version mismatch */ 2762 XSRETURN_EMPTY; /* version mismatch */
2304 2763
2305 w = *data++ << 8; w |= *data++; 2764 w = *data++ << 8; w |= *data++;
… …
2320 { 2779 {
2321 maprow *row = map_get_row (self, y); 2780 maprow *row = map_get_row (self, y);
2322 2781
2323 for (x = x0; x < x1; x++) 2782 for (x = x0; x < x1; x++)
2324 { 2783 {
2784 uint8_t flags;
2785
2786 if (data + 7 >= end)
2787 XSRETURN_EMPTY;
2788
2325 uint8_t flags = *data++; 2789 flags = *data++;
2326 2790
2327 if (flags) 2791 if (flags)
2328 { 2792 {
2329 mapcell *cell = row_get_cell (row, x); 2793 mapcell *cell = row_get_cell (row, x);
2330 tileid tile[3] = { 0, 0, 0 }; 2794 tileid tile[3] = { 0, 0, 0 };
… …
2333 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; } 2797 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
2334 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; } 2798 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
2335 2799
2336 if (cell->darkness == 0) 2800 if (cell->darkness == 0)
2337 { 2801 {
2338 cell->darkness = 0; 2802 /*cell->darkness = 0;*/
2803 EXTEND (SP, 3);
2339 2804
2340 for (z = 0; z <= 2; z++) 2805 for (z = 0; z <= 2; z++)
2341 { 2806 {
2342 tileid t = tile [z]; 2807 tileid t = tile [z];
2343 2808
2344 if (t >= self->texs || (t && !self->tex [t].name)) 2809 if (t >= self->texs || (t && !self->tex [t].name))
2345 { 2810 {
2346 XPUSHs (sv_2mortal (newSViv (t))); 2811 PUSHs (sv_2mortal (newSViv (t)));
2347 need_texid (self, t); 2812 need_texid (self, t);
2348 } 2813 }
2349 2814
2350 cell->tile [z] = t; 2815 cell->tile [z] = t;
2351 } 2816 }
… …
2356} 2821}
2357 2822
2358MODULE = Deliantra::Client PACKAGE = DC::RW 2823MODULE = Deliantra::Client PACKAGE = DC::RW
2359 2824
2360DC::RW 2825DC::RW
2361new (SV *class, SV *data_sv) 2826new (SV *klass, SV *data_sv)
2362 CODE: 2827 CODE:
2363{ 2828{
2364 STRLEN datalen; 2829 STRLEN datalen;
2365 char *data = SvPVbyte (data_sv, datalen); 2830 char *data = SvPVbyte (data_sv, datalen);
2366 2831
… …
2368} 2833}
2369 OUTPUT: 2834 OUTPUT:
2370 RETVAL 2835 RETVAL
2371 2836
2372DC::RW 2837DC::RW
2373new_from_file (SV *class, const char *path, const char *mode = "rb") 2838new_from_file (SV *klass, const char *path, const char *mode = "rb")
2374 CODE: 2839 CODE:
2375 RETVAL = SDL_RWFromFile (path, mode); 2840 RETVAL = SDL_RWFromFile (path, mode);
2376 OUTPUT: 2841 OUTPUT:
2377 RETVAL 2842 RETVAL
2378 2843
… …
2396 if (RETVAL < 0) 2861 if (RETVAL < 0)
2397 { 2862 {
2398 RETVAL = Mix_GroupOldest (-1); 2863 RETVAL = Mix_GroupOldest (-1);
2399 2864
2400 if (RETVAL < 0) 2865 if (RETVAL < 0)
2866 {
2867 // happens sometimes, maybe it just stopped playing(?)
2868 RETVAL = Mix_GroupAvailable (-1);
2869
2870 if (RETVAL < 0)
2401 XSRETURN_UNDEF; 2871 XSRETURN_UNDEF;
2402 2872 }
2873 else
2403 Mix_HaltChannel (RETVAL); 2874 Mix_HaltChannel (RETVAL);
2404 } 2875 }
2405 2876
2406 Mix_UnregisterAllEffects (RETVAL); 2877 Mix_UnregisterAllEffects (RETVAL);
2407 Mix_Volume (RETVAL, 128); 2878 Mix_Volume (RETVAL, 128);
2408} 2879}
… …
2455void 2926void
2456set_position_r (DC::Channel self, int dx, int dy, int maxdistance) 2927set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2457 CODE: 2928 CODE:
2458{ 2929{
2459 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance)); 2930 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2460 int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI); 2931 int angle = atan2f (dx, -dy) * 180.f / (float)M_PI + 360.f;
2461 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255)); 2932 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2462} 2933}
2463 2934
2464void 2935void
2465set_reverse_stereo (DC::Channel self, int flip) 2936set_reverse_stereo (DC::Channel self, int flip)
… …
2468 2939
2469MODULE = Deliantra::Client PACKAGE = DC::MixChunk 2940MODULE = Deliantra::Client PACKAGE = DC::MixChunk
2470 2941
2471PROTOTYPES: DISABLE 2942PROTOTYPES: DISABLE
2472 2943
2944void
2945decoders ()
2946 PPCODE:
2947#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
2948 int i, num = Mix_GetNumChunkDecoders ();
2949 EXTEND (SP, num);
2950 for (i = 0; i < num; ++i)
2951 PUSHs (sv_2mortal (newSVpv (Mix_GetChunkDecoder (i), 0)));
2952#else
2953 XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
2954#endif
2955
2473DC::MixChunk 2956DC::MixChunk
2474new (SV *class, DC::RW rwops) 2957new (SV *klass, DC::RW rwops)
2475 CODE: 2958 CODE:
2476 RETVAL = Mix_LoadWAV_RW (rwops, 1); 2959 RETVAL = Mix_LoadWAV_RW (rwops, 1);
2477 OUTPUT: 2960 OUTPUT:
2478 RETVAL 2961 RETVAL
2479 2962
… …
2509 OUTPUT: 2992 OUTPUT:
2510 RETVAL 2993 RETVAL
2511 2994
2512MODULE = Deliantra::Client PACKAGE = DC::MixMusic 2995MODULE = Deliantra::Client PACKAGE = DC::MixMusic
2513 2996
2997void
2998decoders ()
2999 PPCODE:
3000#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
3001 int i, num = Mix_GetNumMusicDecoders ();
3002 EXTEND (SP, num);
3003 for (i = 0; i < num; ++i)
3004 PUSHs (sv_2mortal (newSVpv (Mix_GetMusicDecoder (i), 0)));
3005#else
3006 XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
3007#endif
3008
2514int 3009int
2515volume (int volume = -1) 3010volume (int volume = -1)
2516 PROTOTYPE: ;$ 3011 PROTOTYPE: ;$
2517 CODE: 3012 CODE:
2518 if (items > 0) 3013 if (items > 0)
… …
2529void 3024void
2530halt () 3025halt ()
2531 CODE: 3026 CODE:
2532 Mix_HaltMusic (); 3027 Mix_HaltMusic ();
2533 3028
3029int
3030playing ()
3031 CODE:
3032 RETVAL = Mix_PlayingMusic ();
3033 OUTPUT:
3034 RETVAL
3035
2534DC::MixMusic 3036DC::MixMusic
2535new (SV *class, DC::RW rwops) 3037new (SV *klass, DC::RW rwops)
2536 CODE: 3038 CODE:
2537 RETVAL = Mix_LoadMUS_RW (rwops); 3039 RETVAL = Mix_LoadMUS_RW (rwops);
2538 OUTPUT: 3040 OUTPUT:
2539 RETVAL 3041 RETVAL
2540 3042
… …
2568 } *civ, const_iv[] = { 3070 } *civ, const_iv[] = {
2569# define const_iv(name) { # name, (IV)name } 3071# define const_iv(name) { # name, (IV)name }
2570 const_iv (GL_VENDOR), 3072 const_iv (GL_VENDOR),
2571 const_iv (GL_VERSION), 3073 const_iv (GL_VERSION),
2572 const_iv (GL_EXTENSIONS), 3074 const_iv (GL_EXTENSIONS),
3075 const_iv (GL_MAX_TEXTURE_UNITS),
2573 const_iv (GL_COLOR_MATERIAL), 3076 const_iv (GL_COLOR_MATERIAL),
2574 const_iv (GL_SMOOTH), 3077 const_iv (GL_SMOOTH),
2575 const_iv (GL_FLAT), 3078 const_iv (GL_FLAT),
2576 const_iv (GL_DITHER), 3079 const_iv (GL_DITHER),
2577 const_iv (GL_BLEND), 3080 const_iv (GL_BLEND),
… …
2589 const_iv (GL_ZERO), 3092 const_iv (GL_ZERO),
2590 const_iv (GL_SRC_ALPHA), 3093 const_iv (GL_SRC_ALPHA),
2591 const_iv (GL_DST_ALPHA), 3094 const_iv (GL_DST_ALPHA),
2592 const_iv (GL_ONE_MINUS_SRC_ALPHA), 3095 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2593 const_iv (GL_ONE_MINUS_DST_ALPHA), 3096 const_iv (GL_ONE_MINUS_DST_ALPHA),
3097 const_iv (GL_SRC_COLOR),
3098 const_iv (GL_DST_COLOR),
3099 const_iv (GL_ONE_MINUS_SRC_COLOR),
3100 const_iv (GL_ONE_MINUS_DST_COLOR),
2594 const_iv (GL_SRC_ALPHA_SATURATE), 3101 const_iv (GL_SRC_ALPHA_SATURATE),
2595 const_iv (GL_RGB), 3102 const_iv (GL_RGB),
2596 const_iv (GL_RGBA), 3103 const_iv (GL_RGBA),
2597 const_iv (GL_RGBA4), 3104 const_iv (GL_RGBA4),
2598 const_iv (GL_RGBA8), 3105 const_iv (GL_RGBA8),
… …
2666 const_iv (GL_NICEST), 3173 const_iv (GL_NICEST),
2667 const_iv (GL_V2F), 3174 const_iv (GL_V2F),
2668 const_iv (GL_V3F), 3175 const_iv (GL_V3F),
2669 const_iv (GL_T2F_V3F), 3176 const_iv (GL_T2F_V3F),
2670 const_iv (GL_T2F_N3F_V3F), 3177 const_iv (GL_T2F_N3F_V3F),
3178 const_iv (GL_FUNC_ADD),
3179 const_iv (GL_FUNC_SUBTRACT),
3180 const_iv (GL_FUNC_REVERSE_SUBTRACT),
2671# undef const_iv 3181# undef const_iv
2672 }; 3182 };
2673 3183
2674 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 3184 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
2675 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 3185 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
2676 3186
2677 texture_av = newAV (); 3187 texture_av = newAV ();
2678 AvREAL_off (texture_av); 3188 AvREAL_off (texture_av);
2679} 3189}
2680 3190
… …
2682disable_GL_EXT_blend_func_separate () 3192disable_GL_EXT_blend_func_separate ()
2683 CODE: 3193 CODE:
2684 gl.BlendFuncSeparate = 0; 3194 gl.BlendFuncSeparate = 0;
2685 gl.BlendFuncSeparateEXT = 0; 3195 gl.BlendFuncSeparateEXT = 0;
2686 3196
2687char * 3197void
3198apple_nvidia_bug (int enable)
3199
3200const char *
2688gl_vendor () 3201gl_vendor ()
2689 CODE: 3202 CODE:
2690 RETVAL = (char *)glGetString (GL_VENDOR); 3203 RETVAL = (const char *)glGetString (GL_VENDOR);
2691 OUTPUT: 3204 OUTPUT:
2692 RETVAL 3205 RETVAL
2693 3206
2694char * 3207const char *
2695gl_version () 3208gl_version ()
2696 CODE: 3209 CODE:
2697 RETVAL = (char *)glGetString (GL_VERSION); 3210 RETVAL = (const char *)glGetString (GL_VERSION);
2698 OUTPUT: 3211 OUTPUT:
2699 RETVAL 3212 RETVAL
2700 3213
2701char * 3214const char *
2702gl_extensions () 3215gl_extensions ()
2703 CODE: 3216 CODE:
2704 RETVAL = (char *)glGetString (GL_EXTENSIONS); 3217 RETVAL = (const char *)glGetString (GL_EXTENSIONS);
2705 OUTPUT: 3218 OUTPUT:
2706 RETVAL 3219 RETVAL
2707 3220
2708const char *glGetString (GLenum pname) 3221const char *glGetString (GLenum pname)
3222 CODE:
3223 RETVAL = (const char *)glGetString (pname);
3224 OUTPUT:
3225 RETVAL
2709 3226
2710GLint glGetInteger (GLenum pname) 3227GLint glGetInteger (GLenum pname)
2711 CODE: 3228 CODE:
2712 glGetIntegerv (pname, &RETVAL); 3229 glGetIntegerv (pname, &RETVAL);
2713 OUTPUT: 3230 OUTPUT:
… …
2721 3238
2722int glGetError () 3239int glGetError ()
2723 3240
2724void glFinish () 3241void glFinish ()
2725 3242
3243void glFlush ()
3244
2726void glClear (int mask) 3245void glClear (int mask)
2727 3246
2728void glClearColor (float r, float g, float b, float a = 1.0) 3247void glClearColor (float r, float g, float b, float a = 1.0)
2729 PROTOTYPE: @ 3248 PROTOTYPE: @
2730 3249
… …
2739void glBlendFunc (int sfactor, int dfactor) 3258void glBlendFunc (int sfactor, int dfactor)
2740 3259
2741void glBlendFuncSeparate (int sa, int da, int saa, int daa) 3260void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2742 CODE: 3261 CODE:
2743 gl_BlendFuncSeparate (sa, da, saa, daa); 3262 gl_BlendFuncSeparate (sa, da, saa, daa);
3263
3264# void glBlendEquation (int se)
2744 3265
2745void glDepthMask (int flag) 3266void glDepthMask (int flag)
2746 3267
2747void glLogicOp (int opcode) 3268void glLogicOp (int opcode)
2748 3269
… …
2783void glRotate (float angle, float x, float y, float z) 3304void glRotate (float angle, float x, float y, float z)
2784 CODE: 3305 CODE:
2785 glRotatef (angle, x, y, z); 3306 glRotatef (angle, x, y, z);
2786 3307
2787void glColor (float r, float g, float b, float a = 1.0) 3308void glColor (float r, float g, float b, float a = 1.0)
3309 PROTOTYPE: @
2788 ALIAS: 3310 ALIAS:
2789 glColor_premultiply = 1 3311 glColor_premultiply = 1
2790 CODE: 3312 CODE:
2791 if (ix) 3313 if (ix)
2792 { 3314 {
… …
2898 3420
2899void glEndList () 3421void glEndList ()
2900 3422
2901void glCallList (int list) 3423void glCallList (int list)
2902 3424
3425void c_init ()
3426 CODE:
3427 glPixelStorei (GL_PACK_ALIGNMENT , 1);
3428 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
3429
2903MODULE = Deliantra::Client PACKAGE = DC::UI::Base 3430MODULE = Deliantra::Client PACKAGE = DC::UI::Base
2904 3431
2905PROTOTYPES: DISABLE 3432PROTOTYPES: DISABLE
2906 3433
2907void 3434void
2908find_widget (SV *self, NV x, NV y) 3435find_widget (SV *self, NV x, NV y)
2909 PPCODE: 3436 PPCODE:
2910{ 3437{
2911 if (within_widget (self, x, y)) 3438 if (within_widget (self, x, y))
2912 XPUSHs (self); 3439 XPUSHs (self);
2913} 3440}
2914 3441
2915BOOT: 3442BOOT:
2916{ 3443{
… …
2924 3451
2925void 3452void
2926draw (SV *self) 3453draw (SV *self)
2927 CODE: 3454 CODE:
2928{ 3455{
2929 HV *hv; 3456 HV *hv;
2930 SV **svp; 3457 SV **svp;
2931 NV x, y, w, h; 3458 NV x, y, w, h;
2932 SV *draw_x_sv = GvSV (draw_x_gv); 3459 SV *draw_x_sv = GvSV (draw_x_gv);
2933 SV *draw_y_sv = GvSV (draw_y_gv); 3460 SV *draw_y_sv = GvSV (draw_y_gv);
2934 SV *draw_w_sv = GvSV (draw_w_gv); 3461 SV *draw_w_sv = GvSV (draw_w_gv);
2935 SV *draw_h_sv = GvSV (draw_h_gv); 3462 SV *draw_h_sv = GvSV (draw_h_gv);

Diff Legend

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