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.252 by root, Fri Dec 28 17:30:33 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#if 0 102/* mask out modifiers we are not interested in */
76# define PARACHUTE SDL_INIT_NOPARACHUTE 103#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)
77#else 104
78# define PARACHUTE 0 105#define KMOD_LRAM 0x10000 // our extension
79#endif 106
107#define TEXID_SPEECH 1
108#define TEXID_NOFACE 2
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}
80 128
81static AV *texture_av; 129static AV *texture_av;
82 130
83static struct 131static struct
84{ 132{
… …
141{ 189{
142 GSList *attrs = run->item->analysis.extra_attrs; 190 GSList *attrs = run->item->analysis.extra_attrs;
143 191
144 while (attrs) 192 while (attrs)
145 { 193 {
146 PangoAttribute *attr = attrs->data; 194 PangoAttribute *attr = (PangoAttribute *)attrs->data;
147 195
148 if (attr->klass->type == PANGO_ATTR_SHAPE) 196 if (attr->klass->type == PANGO_ATTR_SHAPE)
149 return 1; 197 return 1;
150 198
151 attrs = attrs->next; 199 attrs = attrs->next;
152 } 200 }
153 201
154 return 0; 202 return 0;
155} 203}
156 204
157typedef struct cf_layout { 205struct cf_layout {
158 PangoLayout *pl; 206 PangoLayout *pl;
159 float r, g, b, a; // default color for rgba mode 207 float r, g, b, a; // default color for rgba mode
160 int base_height; 208 int base_height;
161 DC__Font font; 209 DC__Font font;
162 rc_t *rc; 210 rc_t rc;
163} *DC__Layout; 211};
212
213typedef cf_layout *DC__Layout;
164 214
165static DC__Font default_font; 215static DC__Font default_font;
166static PangoContext *opengl_context; 216static PangoContext *opengl_context;
167static PangoFontMap *opengl_fontmap; 217static PangoFontMap *opengl_fontmap;
168 218
169static void 219static void
170substitute_func (FcPattern *pattern, gpointer data) 220substitute_func (FcPattern *pattern, gpointer data)
171{ 221{
172 FcPatternAddBool (pattern, FC_HINTING, 1); 222 FcPatternAddBool (pattern, FC_HINTING, 1);
173#ifdef FC_HINT_STYLE 223#ifdef FC_HINT_STYLE
174 FcPatternAddBool (pattern, FC_HINT_STYLE, FC_HINT_FULL); 224 FcPatternAddInteger (pattern, FC_HINT_STYLE, FC_HINT_FULL);
175#endif 225#endif
176 FcPatternAddBool (pattern, FC_AUTOHINT, 0); 226 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
177} 227}
178 228
179static void 229static void
180layout_update_font (DC__Layout self) 230layout_update_font (DC__Layout self)
181{ 231{
182 /* 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
183 * reasonably well with bitstream vera 233 * reasonably well with dejavu/bistream fonts
184 */ 234 */
185 PangoFontDescription *font = self->font ? self->font : default_font; 235 PangoFontDescription *font = self->font ? self->font : default_font;
186 236
187 pango_font_description_set_absolute_size (font, 237 pango_font_description_set_absolute_size (font,
188 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10)); 238 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
… …
209} 259}
210 260
211typedef uint16_t tileid; 261typedef uint16_t tileid;
212typedef uint16_t faceid; 262typedef uint16_t faceid;
213 263
214typedef struct { 264struct maptex
265{
215 GLuint name; 266 GLuint name;
216 int w, h; 267 int w, h;
217 float s, t; 268 float s, t;
218 uint8_t r, g, b, a; 269 uint8_t r, g, b, a;
219 tileid smoothtile; 270 tileid smoothtile;
220 uint8_t smoothlevel; 271 uint8_t smoothlevel;
221} maptex; 272 uint8_t unused; /* set to zero on use */
273};
222 274
223typedef struct { 275struct mapcell
276{
224 uint32_t player; 277 uint32_t player;
225 tileid tile[3]; 278 tileid tile[3];
226 uint16_t darkness; 279 uint16_t darkness;
227 uint8_t stat_width, stat_hp, flags, smoothmax; 280 uint8_t stat_width, stat_hp, flags, smoothmax;
228} mapcell; 281};
229 282
230typedef struct { 283struct maprow
284{
231 int32_t c0, c1; 285 int32_t c0, c1;
232 mapcell *col; 286 mapcell *col;
233} maprow; 287};
234 288
235typedef struct map { 289struct mapgrid {
236 int x, y, w, h; 290 int x, y, w, h;
237 int ox, oy; /* offset to virtual global coordinate system */ 291 int ox, oy; /* offset to virtual global coordinate system */
238 int faces; tileid *face2tile; // [faceid] 292 int faces; tileid *face2tile; // [faceid]
239 int texs; maptex *tex; // [tileid] 293 int texs; maptex *tex; // [tileid]
240 294
241 int32_t rows; 295 int32_t rows;
242 maprow *row; 296 maprow *row;
243} *DC__Map; 297};
244 298
245static char * 299typedef mapgrid *DC__Map;
300
301template<typename T>
302static void
246prepend (char *ptr, int sze, int inc) 303prepend (T *&ptr, int sze, int inc)
247{ 304{
248 char *p; 305 T *p;
249 306
250 New (0, p, sze + inc, char); 307 Newxz (p, sze + inc, T);
251 Zero (p, inc, char);
252 Move (ptr, p + inc, sze, char); 308 Move (ptr, p + inc, sze, T);
253 Safefree (ptr); 309 Safefree (ptr);
254 310
255 return p; 311 ptr = p;
256} 312}
257 313
258static char * 314template<typename T>
259append (char *ptr, int sze, int inc)
260{
261 Renew (ptr, sze + inc, char);
262 Zero (ptr + sze, inc, char);
263
264 return ptr;
265}
266
267#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((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))
269
270static 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
271need_facenum (struct map *self, faceid face) 323need_facenum (struct mapgrid *self, faceid face)
272{ 324{
273 while (self->faces <= face) 325 while (self->faces <= face)
274 { 326 {
275 Append (tileid, self->face2tile, self->faces, self->faces); 327 append (self->face2tile, self->faces, self->faces);
276 self->faces *= 2; 328 self->faces *= 2;
277 } 329 }
278} 330}
279 331
280static void 332static void
281need_texid (struct map *self, int texid) 333need_texid (struct mapgrid *self, int texid)
282{ 334{
283 while (self->texs <= texid) 335 while (self->texs <= texid)
284 { 336 {
285 Append (maptex, self->tex, self->texs, self->texs); 337 append (self->tex, self->texs, self->texs);
286 self->texs *= 2; 338 self->texs *= 2;
287 } 339 }
288} 340}
289 341
290static maprow * 342static maprow *
291map_get_row (DC__Map self, int y) 343map_get_row (mapgrid *self, int y)
292{ 344{
293 if (0 > y) 345 if (0 > y)
294 { 346 {
295 int extend = - y + MAP_EXTEND_Y; 347 int extend = - y + MAP_EXTEND_Y;
296 Prepend (maprow, self->row, self->rows, extend); 348 prepend (self->row, self->rows, extend);
297 349
298 self->rows += extend; 350 self->rows += extend;
299 self->y += extend; 351 self->y += extend;
300 y += extend; 352 y += extend;
301 } 353 }
302 else if (y >= self->rows) 354 else if (y >= self->rows)
303 { 355 {
304 int extend = y - self->rows + MAP_EXTEND_Y; 356 int extend = y - self->rows + MAP_EXTEND_Y;
305 Append (maprow, self->row, self->rows, extend); 357 append (self->row, self->rows, extend);
306 self->rows += extend; 358 self->rows += extend;
307 } 359 }
308 360
309 return self->row + y; 361 return self->row + y;
310} 362}
… …
320 } 372 }
321 373
322 if (row->c0 > x) 374 if (row->c0 > x)
323 { 375 {
324 int extend = row->c0 - x + MAP_EXTEND_X; 376 int extend = row->c0 - x + MAP_EXTEND_X;
325 Prepend (mapcell, row->col, row->c1 - row->c0, extend); 377 prepend (row->col, row->c1 - row->c0, extend);
326 row->c0 -= extend; 378 row->c0 -= extend;
327 } 379 }
328 else if (x >= row->c1) 380 else if (x >= row->c1)
329 { 381 {
330 int extend = x - row->c1 + MAP_EXTEND_X; 382 int extend = x - row->c1 + MAP_EXTEND_X;
331 Append (mapcell, row->col, row->c1 - row->c0, extend); 383 append (row->col, row->c1 - row->c0, extend);
332 row->c1 += extend; 384 row->c1 += extend;
333 } 385 }
334 386
335 return row->col + (x - row->c0); 387 return row->col + (x - row->c0);
336} 388}
337 389
338static mapcell * 390static mapcell *
339map_get_cell (DC__Map self, int x, int y) 391map_get_cell (mapgrid *self, int x, int y)
340{ 392{
341 return row_get_cell (map_get_row (self, y), x); 393 return row_get_cell (map_get_row (self, y), x);
342} 394}
343 395
344static void 396static void
345map_clear (DC__Map self) 397map_clear (mapgrid *self)
346{ 398{
347 int r; 399 int r;
348 400
349 for (r = 0; r < self->rows; r++) 401 for (r = 0; r < self->rows; r++)
350 Safefree (self->row[r].col); 402 Safefree (self->row[r].col);
… …
357 self->oy = 0; 409 self->oy = 0;
358 self->row = 0; 410 self->row = 0;
359 self->rows = 0; 411 self->rows = 0;
360} 412}
361 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
362static void 424static void
363map_blank (DC__Map self, int x0, int y0, int w, int h) 425map_blank (mapgrid *self, int x0, int y0, int w, int h)
364{ 426{
365 int x, y; 427 int x, y;
366 maprow *row; 428 maprow *row;
367 mapcell *cell; 429 mapcell *cell;
368 430
… …
380 if (x >= row->c1) 442 if (x >= row->c1)
381 break; 443 break;
382 444
383 cell = row->col + x - row->c0; 445 cell = row->col + x - row->c0;
384 446
385 cell->darkness = 0; 447 CELL_CLEAR (cell);
386 cell->stat_hp = 0;
387 cell->flags = 0;
388 cell->player = 0;
389 } 448 }
390 } 449 }
391} 450}
392 451
393typedef struct { 452struct smooth_key
453{
394 tileid tile; 454 tileid tile;
395 uint8_t x, y, level; 455 uint8_t x, y, level;
396} 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}
397 475
398static void 476static void
399smooth_or_bits (HV *hv, smooth_key *key, IV bits) 477smooth_or_bits (smooth_hash &h, smooth_key &key, IV bits)
400{ 478{
401 SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1); 479 auto &&it = h.find (key);
402 480
403 if (SvIOK (*sv)) 481 if (it == h.end ())
404 SvIV_set (*sv, SvIVX (*sv) | bits); 482 h.insert (std::make_pair (key, bits));
405 else 483 else
406 sv_setiv (*sv, bits); 484 it->second |= bits;
407} 485}
408 486
409static void 487static void
410music_finished (void) 488music_finished (void)
411{ 489{
… …
428 ev.code = 1; 506 ev.code = 1;
429 ev.data1 = (void *)(long)channel; 507 ev.data1 = (void *)(long)channel;
430 ev.data2 = 0; 508 ev.data2 = 0;
431 509
432 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;
433} 518}
434 519
435static unsigned int 520static unsigned int
436minpot (unsigned int n) 521minpot (unsigned int n)
437{ 522{
… …
504 if (!svp || !SvTRUE (*svp)) 589 if (!svp || !SvTRUE (*svp))
505 return 0; 590 return 0;
506 591
507 return 1; 592 return 1;
508} 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
509 652
510MODULE = Deliantra::Client PACKAGE = DC 653MODULE = Deliantra::Client PACKAGE = DC
511 654
512PROTOTYPES: ENABLE 655PROTOTYPES: ENABLE
513 656
… …
542 const_iv (SDL_USEREVENT), 685 const_iv (SDL_USEREVENT),
543 686
544 const_iv (SDL_APPINPUTFOCUS), 687 const_iv (SDL_APPINPUTFOCUS),
545 const_iv (SDL_APPMOUSEFOCUS), 688 const_iv (SDL_APPMOUSEFOCUS),
546 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),
547 740
548 const_iv (SDLK_FIRST), 741 const_iv (SDLK_FIRST),
549 const_iv (SDLK_LAST), 742 const_iv (SDLK_LAST),
550 const_iv (SDLK_KP0), 743 const_iv (SDLK_KP0),
551 const_iv (SDLK_KP1), 744 const_iv (SDLK_KP1),
… …
627 const_iv (KMOD_RMETA), 820 const_iv (KMOD_RMETA),
628 const_iv (KMOD_NUM), 821 const_iv (KMOD_NUM),
629 const_iv (KMOD_CAPS), 822 const_iv (KMOD_CAPS),
630 const_iv (KMOD_MODE), 823 const_iv (KMOD_MODE),
631 824
825 const_iv (KMOD_LRAM),
826
632 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)
633# undef const_iv 857# undef const_iv
634 }; 858 };
635 859
636 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--)
637 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 861 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
638 862
639 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK); 863 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
640 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE); 864 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
641} 865}
642 866
… …
658NV ceil (NV x) 882NV ceil (NV x)
659 883
660IV minpot (UV n) 884IV minpot (UV n)
661 885
662IV 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
663 893
664void 894void
665pango_init () 895pango_init ()
666 CODE: 896 CODE:
667{ 897{
668 opengl_fontmap = pango_opengl_font_map_new (); 898 opengl_fontmap = pango_opengl_font_map_new ();
669 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);
670 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap); 900 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
671#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)
672 pango_context_set_language (opengl_context, pango_language_from_string ("en")); 903 pango_context_set_language (opengl_context, pango_language_from_string ("en"));
673 /*pango_context_set_base_dir (opengl_context, PANGO_DIRECTION_WEAK_LTR);*/ 904 /*pango_context_set_base_dir (opengl_context, PANGO_DIRECTION_WEAK_LTR);*/
674#endif 905#endif
675} 906}
676 907
677char *
678SDL_GetError () 908char *SDL_GetError ()
679 909
680int 910void SDL_main_hack (SV *real_main)
681SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE) 911 PROTOTYPE: &
682 912
683void 913int SDL_Init (U32 flags)
914
915int SDL_InitSubSystem (U32 flags)
916
917void SDL_QuitSubSystem (U32 flags)
918
684SDL_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
685 930
686void 931void
687SDL_ListModes (int rgb, int alpha) 932SDL_ListModes (int rgb, int alpha)
688 PPCODE: 933 PPCODE:
689{ 934{
… …
701 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0); 946 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
702 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0); 947 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
703 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0); 948 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
704 949
705 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); 950 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
706#if SDL_VERSION_ATLEAST(1,2,10)
707 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
708 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1); 951 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
709#endif
710 952
711 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 953 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
712 954
713 if (m && m != (SDL_Rect **)-1) 955 if (m && m != (SDL_Rect **)-1)
714 while (*m) 956 while (*m)
715 { 957 {
716 if ((*m)->w >= 800 && (*m)->h >= 480) 958 if ((*m)->w >= 400 && (*m)->h >= 300)
717 { 959 {
718 AV *av = newAV (); 960 AV *av = newAV ();
719 av_push (av, newSViv ((*m)->w)); 961 av_push (av, newSViv ((*m)->w));
720 av_push (av, newSViv ((*m)->h)); 962 av_push (av, newSViv ((*m)->h));
721 av_push (av, newSViv (rgb)); 963 av_push (av, newSViv (rgb));
… …
744 ); 986 );
745 987
746 if (RETVAL) 988 if (RETVAL)
747 { 989 {
748 av_clear (texture_av); 990 av_clear (texture_av);
749
750 SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
751#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name); 991#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
752#include "glfunc.h" 992#include "glfunc.h"
753#undef GL_FUNC 993#undef GL_FUNC
994 if (!gl.ActiveTexture ) gl.ActiveTexture = gl.ActiveTextureARB;
995 if (!gl.MultiTexCoord2f) gl.MultiTexCoord2f = gl.MultiTexCoord2fARB;
754 } 996 }
755} 997}
756 OUTPUT: 998 OUTPUT:
757 RETVAL 999 RETVAL
1000
1001void
1002SDL_WM_SetCaption (const char *title, const char *icon)
758 1003
759void 1004void
760SDL_GL_SwapBuffers () 1005SDL_GL_SwapBuffers ()
761 1006
762char * 1007char *
763SDL_GetKeyName (int sym) 1008SDL_GetKeyName (int sym)
1009 C_ARGS: (SDLKey)sym
764 1010
765int 1011int
766SDL_GetAppState () 1012SDL_GetAppState ()
767 1013
1014int
1015SDL_GetModState ()
1016
1017int
1018SDL_WaitEvent ()
1019 C_ARGS: 0
1020
768void 1021void
1022SDL_PumpEvents ()
1023
1024void
769poll_events () 1025peep_events ()
770 PPCODE: 1026 PPCODE:
771{ 1027{
772 SDL_Event ev; 1028 SDL_Event ev;
773 1029
774 SDL_PumpEvents (); 1030 SDL_PumpEvents ();
… …
781 { 1037 {
782 case SDL_KEYDOWN: 1038 case SDL_KEYDOWN:
783 case SDL_KEYUP: 1039 case SDL_KEYUP:
784 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 1040 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
785 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 1041 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
786 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0); 1042 hv_store (hv, "mod", 3, newSViv (mod_munge (ev.key.keysym.mod)), 0);
787 hv_store (hv, "cmod", 4, newSViv (SDL_GetModState ()), 0); /* current mode */ 1043 hv_store (hv, "cmod", 4, newSViv (mod_munge (SDL_GetModState ())), 0); /* current mode */
788 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 1044 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
789 break; 1045 break;
790 1046
791 case SDL_ACTIVEEVENT: 1047 case SDL_ACTIVEEVENT:
792 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 1048 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
… …
810 x = ev.motion.x; 1066 x = ev.motion.x;
811 y = ev.motion.y; 1067 y = ev.motion.y;
812 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)); 1068 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
813 } 1069 }
814 1070
815 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 1071 hv_store (hv, "mod", 3, newSViv (mod_munge (SDL_GetModState ())), 0);
816 hv_store (hv, "state", 5, newSViv (state), 0); 1072 hv_store (hv, "state", 5, newSViv (state), 0);
817 hv_store (hv, "x", 1, newSViv (x), 0); 1073 hv_store (hv, "x", 1, newSViv (x), 0);
818 hv_store (hv, "y", 1, newSViv (y), 0); 1074 hv_store (hv, "y", 1, newSViv (y), 0);
819 hv_store (hv, "xrel", 4, newSViv (xrel), 0); 1075 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
820 hv_store (hv, "yrel", 4, newSViv (yrel), 0); 1076 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
821 } 1077 }
822 break; 1078 break;
823 1079
824 case SDL_MOUSEBUTTONDOWN: 1080 case SDL_MOUSEBUTTONDOWN:
825 case SDL_MOUSEBUTTONUP: 1081 case SDL_MOUSEBUTTONUP:
826 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 1082 hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0);
827 1083
828 hv_store (hv, "button", 6, newSViv (ev.button.button), 0); 1084 hv_store (hv, "button", 6, newSViv (ev.button.button), 0);
829 hv_store (hv, "state", 5, newSViv (ev.button.state), 0); 1085 hv_store (hv, "state", 5, newSViv (ev.button.state), 0);
830 hv_store (hv, "x", 1, newSViv (ev.button.x), 0); 1086 hv_store (hv, "x", 1, newSViv (ev.button.x), 0);
831 hv_store (hv, "y", 1, newSViv (ev.button.y), 0); 1087 hv_store (hv, "y", 1, newSViv (ev.button.y), 0);
… …
840 1096
841 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))));
842 } 1098 }
843} 1099}
844 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
845int 1114int
846Mix_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)
847 POSTCALL: 1116 POSTCALL:
848 Mix_HookMusicFinished (music_finished); 1117 Mix_HookMusicFinished (music_finished);
849 Mix_ChannelFinished (channel_finished); 1118 Mix_ChannelFinished (channel_finished);
850 1119
851void 1120void
852Mix_QuerySpec () 1121Mix_QuerySpec ()
… …
905 } 1174 }
906 } 1175 }
907#endif 1176#endif
908} 1177}
909 1178
910void 1179int
911add_font (char *file) 1180add_font (char *file)
912 CODE: 1181 CODE:
913 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)
914 1192
915void 1193void
916load_image_inline (SV *image_) 1194load_image_inline (SV *image_)
917 ALIAS: 1195 ALIAS:
918 load_image_file = 1 1196 load_image_file = 1
… …
964 1242
965 SDL_LockSurface (surface2); 1243 SDL_LockSurface (surface2);
966 EXTEND (SP, 6); 1244 EXTEND (SP, 6);
967 PUSHs (sv_2mortal (newSViv (surface2->w))); 1245 PUSHs (sv_2mortal (newSViv (surface2->w)));
968 PUSHs (sv_2mortal (newSViv (surface2->h))); 1246 PUSHs (sv_2mortal (newSViv (surface2->h)));
969 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 1247 PUSHs (sv_2mortal (newSVpvn ((const char *)surface2->pixels, surface2->h * surface2->pitch)));
970 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)));
971 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 1249 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
972 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE))); 1250 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
973 SDL_UnlockSurface (surface2); 1251 SDL_UnlockSurface (surface2);
974 1252
… …
1034#if DEBUG 1312#if DEBUG
1035 VALGRIND_DO_LEAK_CHECK; 1313 VALGRIND_DO_LEAK_CHECK;
1036#endif 1314#endif
1037} 1315}
1038 1316
1317int
1318SvREFCNT (SV *sv)
1319 CODE:
1320 RETVAL = SvREFCNT (sv);
1321 OUTPUT:
1322 RETVAL
1323
1039MODULE = Deliantra::Client PACKAGE = DC::Font 1324MODULE = Deliantra::Client PACKAGE = DC::Font
1040 1325
1041PROTOTYPES: DISABLE 1326PROTOTYPES: DISABLE
1042 1327
1043DC::Font 1328DC::Font
1044new_from_file (SV *class, char *path, int id = 0) 1329new_from_file (SV *klass, char *path, int id = 0)
1045 CODE: 1330 CODE:
1046{ 1331{
1047 int count; 1332 int count;
1048 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count); 1333 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
1049 RETVAL = pango_fc_font_description_from_pattern (pattern, 0); 1334 RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
… …
1078 PROTOTYPE: 1363 PROTOTYPE:
1079 CODE: 1364 CODE:
1080 tc_restore (); 1365 tc_restore ();
1081 1366
1082DC::Layout 1367DC::Layout
1083new (SV *class) 1368new (SV *klass)
1084 CODE: 1369 CODE:
1085 New (0, RETVAL, 1, struct cf_layout); 1370 RETVAL = new cf_layout;
1086 1371
1087 RETVAL->pl = pango_layout_new (opengl_context); 1372 RETVAL->pl = pango_layout_new (opengl_context);
1088 RETVAL->r = 1.; 1373 RETVAL->r = 1.;
1089 RETVAL->g = 1.; 1374 RETVAL->g = 1.;
1090 RETVAL->b = 1.; 1375 RETVAL->b = 1.;
1091 RETVAL->a = 1.; 1376 RETVAL->a = 1.;
1092 RETVAL->base_height = MIN_FONT_HEIGHT; 1377 RETVAL->base_height = MIN_FONT_HEIGHT;
1093 RETVAL->font = 0; 1378 RETVAL->font = 0;
1094 RETVAL->rc = rc_alloc ();
1095 1379
1096 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR); 1380 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
1097 layout_update_font (RETVAL); 1381 layout_update_font (RETVAL);
1098 OUTPUT: 1382 OUTPUT:
1099 RETVAL 1383 RETVAL
1100 1384
1101void 1385void
1102DESTROY (DC::Layout self) 1386DESTROY (DC::Layout self)
1103 CODE: 1387 CODE:
1104 g_object_unref (self->pl); 1388 g_object_unref (self->pl);
1105 rc_free (self->rc);
1106 Safefree (self); 1389 delete self;
1107 1390
1108void 1391void
1109set_text (DC::Layout self, SV *text_) 1392set_text (DC::Layout self, SV *text_)
1110 CODE: 1393 CODE:
1111{ 1394{
… …
1237 1520
1238void 1521void
1239set_height (DC::Layout self, int base_height) 1522set_height (DC::Layout self, int base_height)
1240 CODE: 1523 CODE:
1241 if (self->base_height != base_height) 1524 if (self->base_height != base_height)
1242 { 1525 {
1243 self->base_height = base_height; 1526 self->base_height = base_height;
1244 layout_update_font (self); 1527 layout_update_font (self);
1245 } 1528 }
1246 1529
1247void 1530void
… …
1328 PPCODE: 1611 PPCODE:
1329{ 1612{
1330 int line, x; 1613 int line, x;
1331 1614
1332 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);
1333#if !(defined (PANGO_VERSION_CHECK) && PANGO_VERSION_CHECK (1, 17, 3)) 1616#if !PANGO_VERSION_CHECK (1, 17, 3)
1334 /* pango bug: line is between 1..numlines, not 0..numlines-1 */ 1617 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
1335 --line; 1618 --line;
1336#endif 1619#endif
1337 EXTEND (SP, 2); 1620 EXTEND (SP, 2);
1338 PUSHs (sv_2mortal (newSViv (line))); 1621 PUSHs (sv_2mortal (newSViv (line)));
… …
1365} 1648}
1366 1649
1367void 1650void
1368render (DC::Layout self, float x, float y, int flags = 0) 1651render (DC::Layout self, float x, float y, int flags = 0)
1369 CODE: 1652 CODE:
1370 rc_clear (self->rc); 1653 self->rc.clear ();
1371 pango_opengl_render_layout_subpixel ( 1654 pango_opengl_render_layout_subpixel (
1372 self->pl, 1655 self->pl,
1373 self->rc, 1656 &self->rc,
1374 x * PANGO_SCALE, y * PANGO_SCALE, 1657 x * PANGO_SCALE, y * PANGO_SCALE,
1375 self->r, self->g, self->b, self->a, 1658 self->r, self->g, self->b, self->a,
1376 flags 1659 flags
1377 ); 1660 );
1378 // we assume that context_change actually clears/frees stuff 1661 // we assume that context_change actually clears/frees stuff
… …
1389 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, 1672 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1390 GL_ONE , GL_ONE_MINUS_SRC_ALPHA); 1673 GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1391 glEnable (GL_ALPHA_TEST); 1674 glEnable (GL_ALPHA_TEST);
1392 glAlphaFunc (GL_GREATER, 7.f / 255.f); 1675 glAlphaFunc (GL_GREATER, 7.f / 255.f);
1393 1676
1394 rc_draw (self->rc); 1677 self->rc.draw ();
1395 1678
1396 glDisable (GL_ALPHA_TEST); 1679 glDisable (GL_ALPHA_TEST);
1397 glDisable (GL_BLEND); 1680 glDisable (GL_BLEND);
1398 glDisable (GL_TEXTURE_2D); 1681 glDisable (GL_TEXTURE_2D);
1399} 1682}
… …
1474 glDisable (GL_ALPHA_TEST); 1757 glDisable (GL_ALPHA_TEST);
1475 glDisable (GL_BLEND); 1758 glDisable (GL_BLEND);
1476 } 1759 }
1477} 1760}
1478 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
1479IV 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)
1480 CODE: 1884 CODE:
1481{ 1885{
1482 GLint width; 1886 GLint width;
1483 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);
… …
1490MODULE = Deliantra::Client PACKAGE = DC::Map 1894MODULE = Deliantra::Client PACKAGE = DC::Map
1491 1895
1492PROTOTYPES: DISABLE 1896PROTOTYPES: DISABLE
1493 1897
1494DC::Map 1898DC::Map
1495new (SV *class) 1899new (SV *klass)
1496 CODE: 1900 CODE:
1497 New (0, RETVAL, 1, struct map); 1901 New (0, RETVAL, 1, mapgrid);
1498 RETVAL->x = 0; 1902 RETVAL->x = 0;
1499 RETVAL->y = 0; 1903 RETVAL->y = 0;
1500 RETVAL->w = 0; 1904 RETVAL->w = 0;
1501 RETVAL->h = 0; 1905 RETVAL->h = 0;
1502 RETVAL->ox = 0; 1906 RETVAL->ox = 0;
… …
1539 1943
1540void 1944void
1541set_smooth (DC::Map self, int face, int smooth, int level) 1945set_smooth (DC::Map self, int face, int smooth, int level)
1542 CODE: 1946 CODE:
1543{ 1947{
1544 tileid texid; 1948 tileid texid;
1545 maptex *tex; 1949 maptex *tex;
1546 1950
1547 if (face < 0 || face >= self->faces) 1951 if (face < 0 || face >= self->faces)
1548 return; 1952 return;
1549 1953
1550 if (smooth < 0 || smooth >= self->faces) 1954 if (smooth < 0 || smooth >= self->faces)
1551 return; 1955 return;
1552 1956
1553 texid = self->face2tile [face]; 1957 texid = self->face2tile [face];
1554 1958
1555 if (!texid) 1959 if (!texid)
1556 return; 1960 return;
1557 1961
1558 tex = self->tex + texid; 1962 tex = self->tex + texid;
… …
1587 //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);
1588 // use uglier nearest interpolation because linear suffers 1992 // use uglier nearest interpolation because linear suffers
1589 // from transparent color bleeding and ugly wrapping effects. 1993 // from transparent color bleeding and ugly wrapping effects.
1590 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1994 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1591} 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 }
1592 2016
1593int 2017int
1594ox (DC::Map self) 2018ox (DC::Map self)
1595 ALIAS: 2019 ALIAS:
1596 oy = 1 2020 oy = 1
… …
1628 self->ox += dx; self->x += dx; 2052 self->ox += dx; self->x += dx;
1629 self->oy += dy; self->y += dy; 2053 self->oy += dy; self->y += dy;
1630 2054
1631 while (self->y < 0) 2055 while (self->y < 0)
1632 { 2056 {
1633 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y); 2057 prepend (self->row, self->rows, MAP_EXTEND_Y);
1634 2058
1635 self->rows += MAP_EXTEND_Y; 2059 self->rows += MAP_EXTEND_Y;
1636 self->y += MAP_EXTEND_Y; 2060 self->y += MAP_EXTEND_Y;
1637 } 2061 }
1638} 2062}
1639 2063
1640SV * 2064SV *
1641map1a_update (DC::Map self, SV *data_, int extmap) 2065map1a_update (DC::Map self, SV *data_)
1642 CODE: 2066 CODE:
1643{ 2067{
1644 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 2068 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1645 uint8_t *data_end = (uint8_t *)SvEND (data_); 2069 uint8_t *data_end = (uint8_t *)SvEND (data_);
1646 mapcell *cell; 2070 mapcell *cell;
… …
1667 2091
1668 //TODO: don't trust server data to be in-range(!) 2092 //TODO: don't trust server data to be in-range(!)
1669 2093
1670 if (flags & 8) 2094 if (flags & 8)
1671 { 2095 {
2096 uint8_t ext, cmd;
2097
1672 if (extmap) 2098 do
1673 { 2099 {
1674 uint8_t ext, cmd; 2100 ext = *data++;
2101 cmd = ext & 0x7f;
1675 2102
1676 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
1677 { 2106 {
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; 2107 cell->stat_width = 1;
1686 cell->stat_hp = *data++; 2108 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 } 2109 }
1704 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++;
1705 } 2127 }
1706 else 2128 while (ext & 0x80);
1707 cell->darkness = *data++ + 1;
1708 } 2129 }
1709 2130
1710 for (z = 0; z <= 2; ++z) 2131 for (z = 0; z <= 2; ++z)
1711 if (flags & (4 >> z)) 2132 if (flags & (4 >> z))
1712 { 2133 {
… …
1715 cell->tile [z] = self->face2tile [face]; 2136 cell->tile [z] = self->face2tile [face];
1716 2137
1717 if (cell->tile [z]) 2138 if (cell->tile [z])
1718 { 2139 {
1719 maptex *tex = self->tex + cell->tile [z]; 2140 maptex *tex = self->tex + cell->tile [z];
2141 tex->unused = 0;
1720 if (!tex->name) 2142 if (!tex->name)
1721 av_push (missing, newSViv (cell->tile [z])); 2143 av_push (missing, newSViv (cell->tile [z]));
1722 2144
1723 if (tex->smoothtile) 2145 if (tex->smoothtile)
1724 { 2146 {
1725 maptex *smooth = self->tex + tex->smoothtile; 2147 maptex *smooth = self->tex + tex->smoothtile;
2148 smooth->unused = 0;
1726 if (!smooth->name) 2149 if (!smooth->name)
1727 av_push (missing, newSViv (tex->smoothtile)); 2150 av_push (missing, newSViv (tex->smoothtile));
1728 } 2151 }
1729 } 2152 }
1730 } 2153 }
1731 } 2154 }
1732 else 2155 else
1733 cell->darkness = 0; 2156 CELL_CLEAR (cell);
1734 } 2157 }
1735} 2158}
1736 OUTPUT: 2159 OUTPUT:
1737 RETVAL 2160 RETVAL
1738 2161
… …
1758 ? self->row + y 2181 ? self->row + y
1759 : 0; 2182 : 0;
1760 2183
1761 for (x = x0; x < x1; x++) 2184 for (x = x0; x < x1; x++)
1762 { 2185 {
1763 int r = 32, g = 32, b = 32, a = 192; 2186 unsigned int r = 32, g = 32, b = 32, a = 192;
1764 2187
1765 if (row && row->c0 <= x && x < row->c1) 2188 if (row && row->c0 <= x && x < row->c1)
1766 { 2189 {
1767 mapcell *cell = row->col + (x - row->c0); 2190 mapcell *cell = row->col + (x - row->c0);
1768 2191
… …
1770 { 2193 {
1771 maptex tex = self->tex [cell->tile [z]]; 2194 maptex tex = self->tex [cell->tile [z]];
1772 int a0 = 255 - tex.a; 2195 int a0 = 255 - tex.a;
1773 int a1 = tex.a; 2196 int a1 = tex.a;
1774 2197
1775 r = (r * a0 + tex.r * a1) / 255; 2198 r = div255 (r * a0 + tex.r * a1);
1776 g = (g * a0 + tex.g * a1) / 255; 2199 g = div255 (g * a0 + tex.g * a1);
1777 b = (b * a0 + tex.b * a1) / 255; 2200 b = div255 (b * a0 + tex.b * a1);
1778 a = (a * a0 + tex.a * a1) / 255; 2201 a = div255 (a * a0 + tex.a * a1);
1779 } 2202 }
1780 } 2203 }
1781 2204
1782 *map++ = (r ) 2205 *map++ = (r )
1783 | (g << 8) 2206 | (g << 8)
1784 | (b << 16) 2207 | (b << 16)
1785 | (a << 24); 2208 | (a << 24);
1786 } 2209 }
1787 } 2210 }
1788 2211
1789 RETVAL = map_sv; 2212 RETVAL = map_sv;
1790} 2213}
1791 OUTPUT: 2214 OUTPUT:
1792 RETVAL 2215 RETVAL
1793 2216
1794void 2217void
1795draw (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)
1796 CODE: 2219 CODE:
1797{ 2220{
1798 int x, y, z; 2221 int x, y, z;
1799 2222
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) 2223 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k), also, static!
1803 smooth_key skey; 2224 int pl_x, pl_y;
1804 2225 maptex pl_tex;
1805 rc_t *rc = rc_alloc (); 2226 rc_t rc;
2227 rc_t rc_ov;
1806 rc_key_t key; 2228 rc_key_t key;
1807 rc_array_t *arr; 2229 rc_t::array_t *arr;
1808 2230
2231 pl_tex.name = 0;
2232
1809 // thats current max. sorry. 2233 // that's current max. sorry.
1810 if (sw > 255) sw = 255; 2234 if (sw > 255) sw = 255;
1811 if (sh > 255) sh = 255; 2235 if (sh > 255) sh = 255;
1812
1813 // clear key, in case of extra padding
1814 memset (&skey, 0, sizeof (skey));
1815 2236
1816 memset (&key, 0, sizeof (key)); 2237 memset (&key, 0, sizeof (key));
1817 key.r = 255; 2238 key.r = 255;
1818 key.g = 255; 2239 key.g = 255;
1819 key.b = 255; 2240 key.b = 255;
1820 key.a = 255; 2241 key.a = 255;
1821 key.mode = GL_QUADS; 2242 key.mode = GL_QUADS;
1822 key.format = GL_T2F_V3F; 2243 key.format = GL_T2F_V3F;
1823 key.texname = -1;
1824 2244
1825 mx += self->x; 2245 mx += self->x;
1826 my += self->y; 2246 my += self->y;
1827 2247
1828 // first pass: determine smooth_max 2248 // first pass: determine smooth_max
1829 // rather ugly, if you ask me 2249 // rather ugly, if you ask me
1830 // could also be stored inside mapcell and updated on change 2250 // could also be stored inside mapcell and updated on change
1831 memset (smooth_max, 0, sizeof (smooth_max)); 2251 memset (smooth_max, 0, sizeof (smooth_max[0]) * (sh + 1));
1832 2252
1833 for (y = 0; y < sh; y++) 2253 for (y = 0; y < sh; y++)
1834 if (0 <= y + my && y + my < self->rows) 2254 if (0 <= y + my && y + my < self->rows)
1835 { 2255 {
1836 maprow *row = self->row + (y + my); 2256 maprow *row = self->row + (y + my);
… …
1851 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2271 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1852 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2272 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1853 2273
1854 for (z = 0; z <= 2; z++) 2274 for (z = 0; z <= 2; z++)
1855 { 2275 {
1856 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;
1857 2280
1858 for (y = 0; y < sh; y++) 2281 for (y = 0; y < sh; y++)
1859 if (0 <= y + my && y + my < self->rows) 2282 if (0 <= y + my && y + my < self->rows)
1860 { 2283 {
1861 maprow *row = self->row + (y + my); 2284 maprow *row = self->row + (y + my);
… …
1871 maptex tex = self->tex [tile]; 2294 maptex tex = self->tex [tile];
1872 int px, py; 2295 int px, py;
1873 2296
1874 if (key.texname != tex.name) 2297 if (key.texname != tex.name)
1875 { 2298 {
2299 self->tex [tile].unused = 0;
2300
1876 if (!tex.name) 2301 if (!tex.name)
1877 tex = self->tex [2]; /* missing, replace by noface */ 2302 tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
1878 2303
1879 key.texname = tex.name; 2304 key.texname = tex.name;
1880 arr = rc_array (rc, &key); 2305 arr = &rc.array (key);
1881 } 2306 }
1882 2307
1883 px = (x + 1) * T - tex.w; 2308 px = (x + 1) * Th - tex.w;
1884 py = (y + 1) * T - tex.h; 2309 py = (y + 1) * Tw - tex.h;
1885 2310
1886 rc_t2f_v3f (arr, 0 , 0 , px , py , 0); 2311 if (expect_false (cell->player == player) && expect_false (z == 2))
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 { 2312 {
1893 // overlays such as the speech bubble, probably more to come 2313 pl_x = px;
1894 if (cell->flags & 1) 2314 pl_y = py;
2315 pl_tex = tex;
1895 { 2316 continue;
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 } 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);
1915 2323
1916 // update smooth hash 2324 // update smooth hash
1917 if (tex.smoothtile) 2325 if (tex.smoothtile)
1918 { 2326 {
1919 skey.tile = tex.smoothtile; 2327 skey.tile = tex.smoothtile;
1920 skey.level = tex.smoothlevel; 2328 skey.level = tex.smoothlevel;
1921 2329
1922 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31); 2330 smooth_level[tex.smoothlevel] = 1;
1923 2331
1924 // 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
1925 // shifted +1|+1 so we always stay positive. 2333 // shifted +1|+1 so we always stay positive.
1926 2334
1927 // bits is ___n cccc CCCC bbbb 2335 // bits is ___n cccc CCCC bbbb
… …
1935 2343
1936 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ·· 2344 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1937 // ·· ·· ·┏ ┓· 2345 // ·· ·· ·┏ ┓·
1938 2346
1939 // full tile 2347 // full tile
1940 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);
1941 2349
1942 // borders 2350 // borders
1943 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);
1944 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);
1945 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);
1946 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);
1947 2355
1948 // corners 2356 // corners
1949 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);
1950 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);
1951 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);
1952 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);
1953 } 2381 }
1954 } 2382 }
1955 } 2383 }
1956 } 2384 }
1957 2385
1958 rc_draw (rc); 2386 rc.draw ();
1959 rc_clear (rc); 2387 rc.clear ();
1960 2388
1961 // go through all smoothlevels, lowest to highest, then draw. 2389 // go through all smoothlevels, lowest to highest, then draw.
1962 // this is basically counting sort 2390 // this is basically counting sort
1963 { 2391 {
1964 int w, b; 2392 int w, b;
1965 2393
1966 glEnable (GL_TEXTURE_2D); 2394 glEnable (GL_TEXTURE_2D);
1967 glBegin (GL_QUADS); 2395 glBegin (GL_QUADS);
1968 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)
1969 { 2399 {
1970 uint32_t smask = smooth_level [w]; 2400 smooth_key &skey = it->first;
1971 if (smask) 2401 IV bits = it->second;
1972 for (b = 0; b < 32; ++b) 2402
1973 if (smask & (((uint32_t)1) << b)) 2403 if (!(bits & 0x1000)
2404 && skey.level == level
2405 && level > smooth_max [skey.x][skey.y])
1974 { 2406 {
1975 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
1976 HE *he; 2415 if (tex.name)
1977
1978 hv_iterinit (smooth);
1979 while ((he = hv_iternext (smooth)))
1980 { 2416 {
1981 smooth_key *skey = (smooth_key *)HeKEY (he); 2417 // this time avoiding texture state changes
1982 IV bits = SvIVX (HeVAL (he)); 2418 // save gobs of state changes.
1983 2419 if (key.texname != tex.name)
1984 if (!(bits & 0x1000)
1985 && skey->level == level
1986 && level > smooth_max [skey->x][skey->y])
1987 { 2420 {
1988 maptex tex = self->tex [skey->tile]; 2421 self->tex [skey.tile].unused = 0;
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 2422
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 (); 2423 glEnd ();
2003 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name); 2424 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
2004 glBegin (GL_QUADS); 2425 glBegin (GL_QUADS);
2005 } 2426 }
2006 2427
2007 if (border) 2428 if (border)
2008 { 2429 {
2009 float ox = border * dx; 2430 float ox = border * dx;
2010 2431
2011 glTexCoord2f (ox , 0.f ); glVertex2i (px , py ); 2432 glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
2012 glTexCoord2f (ox , dy ); glVertex2i (px , py + T); 2433 glTexCoord2f (ox , dy ); glVertex2i (px , py + Th);
2013 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T); 2434 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py + Th);
2014 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py ); 2435 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + Tw, py );
2015 } 2436 }
2016 2437
2017 if (corner) 2438 if (corner)
2018 { 2439 {
2019 float ox = corner * dx; 2440 float ox = corner * dx;
2020 2441
2021 glTexCoord2f (ox , dy ); glVertex2i (px , py ); 2442 glTexCoord2f (ox , dy ); glVertex2i (px , py );
2022 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T); 2443 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + Th);
2023 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T); 2444 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + Tw, py + Th);
2024 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py ); 2445 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py );
2025 }
2026 }
2027 } 2446 }
2028 } 2447 }
2029 } 2448 }
2030 } 2449 }
2031 2450
2032 glEnd (); 2451 glEnd ();
2033 glDisable (GL_TEXTURE_2D); 2452 glDisable (GL_TEXTURE_2D);
2034 key.texname = -1; 2453 key.texname = -1;
2035 } 2454 }
2036
2037 hv_clear (smooth);
2038 } 2455 }
2039 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
2040 glDisable (GL_BLEND); 2477 glDisable (GL_BLEND);
2041 rc_free (rc);
2042 2478
2043 // top layer: overlays such as the health bar 2479 // top layer: overlays such as the health bar
2044 for (y = 0; y < sh; y++) 2480 for (y = 0; y < sh; y++)
2045 if (0 <= y + my && y + my < self->rows) 2481 if (0 <= y + my && y + my < self->rows)
2046 { 2482 {
… …
2049 for (x = 0; x < sw; x++) 2485 for (x = 0; x < sw; x++)
2050 if (row->c0 <= x + mx && x + mx < row->c1) 2486 if (row->c0 <= x + mx && x + mx < row->c1)
2051 { 2487 {
2052 mapcell *cell = row->col + (x + mx - row->c0); 2488 mapcell *cell = row->col + (x + mx - row->c0);
2053 2489
2054 int px = x * T; 2490 int px = x * Tw;
2055 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 }
2056 2498
2057 if (cell->stat_hp) 2499 if (cell->stat_hp)
2058 { 2500 {
2059 int width = cell->stat_width * T; 2501 int width = cell->stat_width * Tw;
2060 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width; 2502 int thick = (sh * Th / 32 + 27) / 28 + 1 + cell->stat_width;
2061 2503
2062 glColor3ub (0, 0, 0); 2504 glColor3ub (0, 0, 0);
2063 glRectf (px + 1, py - thick - 2, 2505 glRectf (px + 1, py - thick - 2,
2064 px + width - 1, py); 2506 px + width - 1, py);
2065 2507
… …
2071 } 2513 }
2072 } 2514 }
2073} 2515}
2074 2516
2075void 2517void
2076draw_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)
2077 CODE: 2519 CODE:
2078{ 2520{
2079 static float color[16][3] = { 2521 static float color[16][3] = {
2080 { 0.00F, 0.00F, 0.00F }, 2522 { 0.00f, 0.00f, 0.00f },
2081 { 1.00F, 1.00F, 1.00F }, 2523 { 1.00f, 1.00f, 1.00f },
2082 { 0.00F, 0.00F, 0.55F }, 2524 { 0.00f, 0.00f, 0.55f },
2083 { 1.00F, 0.00F, 0.00F }, 2525 { 1.00f, 0.00f, 0.00f },
2084 2526
2085 { 1.00F, 0.54F, 0.00F }, 2527 { 1.00f, 0.54f, 0.00f },
2086 { 0.11F, 0.56F, 1.00F }, 2528 { 0.11f, 0.56f, 1.00f },
2087 { 0.93F, 0.46F, 0.00F }, 2529 { 0.93f, 0.46f, 0.00f },
2088 { 0.18F, 0.54F, 0.34F }, 2530 { 0.18f, 0.54f, 0.34f },
2089 2531
2090 { 0.56F, 0.73F, 0.56F }, 2532 { 0.56f, 0.73f, 0.56f },
2091 { 0.80F, 0.80F, 0.80F }, 2533 { 0.80f, 0.80f, 0.80f },
2092 { 0.55F, 0.41F, 0.13F }, 2534 { 0.55f, 0.41f, 0.13f },
2093 { 0.99F, 0.77F, 0.26F }, 2535 { 0.99f, 0.77f, 0.26f },
2094 2536
2095 { 0.74F, 0.65F, 0.41F }, 2537 { 0.74f, 0.65f, 0.41f },
2096 2538
2097 { 0.00F, 1.00F, 1.00F }, 2539 { 0.00f, 1.00f, 1.00f },
2098 { 1.00F, 0.00F, 1.00F }, 2540 { 1.00f, 0.00f, 1.00f },
2099 { 1.00F, 1.00F, 0.00F }, 2541 { 1.00f, 1.00f, 0.00f },
2100 }; 2542 };
2101 2543
2102 int x, y; 2544 int x, y;
2103 2545
2104 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 */
2105 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2553 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
2106 glEnable (GL_BLEND); 2554 glEnable (GL_BLEND);
2107 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2555 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2108 glBegin (GL_QUADS); 2556 glBegin (GL_QUADS);
2109 2557
2110 for (y = 0; y < h; y++) 2558 for (y = 0; y < h; y++)
… …
2114 2562
2115 if (m) 2563 if (m)
2116 { 2564 {
2117 float *c = color [m & 15]; 2565 float *c = color [m & 15];
2118 2566
2119 float tx1 = m & 0x40 ? 0.5 : 0.; 2567 float tx1 = m & 0x40 ? 0.5f : 0.f;
2120 float tx2 = tx1 + 0.5; 2568 float tx2 = tx1 + 0.5f;
2121 2569
2122 glColor4f (c[0], c[1], c[2], 0.75); 2570 glColor4f (c[0], c[1], c[2], 1);
2123 glTexCoord2f (tx1, 0.); glVertex2i (x , y ); 2571 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2124 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1); 2572 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2125 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1); 2573 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2126 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y ); 2574 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2127 } 2575 }
… …
2135void 2583void
2136fow_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)
2137 PPCODE: 2585 PPCODE:
2138{ 2586{
2139 int x, y; 2587 int x, y;
2140 int sw1 = sw + 2; 2588 int sw1 = sw + 2;
2141 int sh1 = sh + 2; 2589 int sh1 = sh + 2;
2142 int sh3 = sh * 3; 2590 int sh3 = sh * 3;
2143 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);
2144 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1); 2594 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2145 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3)); 2595 memset (darkness1, 0, sw1*sh1);
2146 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2147 2596
2148 SvPOK_only (darkness3_sv); 2597 SvPOK_only (darkness3_sv);
2149 SvCUR_set (darkness3_sv, sw34 * sh3); 2598 SvCUR_set (darkness3_sv, sw3 * sh3);
2150 2599
2151 mx += self->x - 1; 2600 mx += self->x - 1;
2152 my += self->y - 1; 2601 my += self->y - 1;
2153
2154 memset (darkness1, 255, sw1 * sh1);
2155 2602
2156 for (y = 0; y < sh1; y++) 2603 for (y = 0; y < sh1; y++)
2157 if (0 <= y + my && y + my < self->rows) 2604 if (0 <= y + my && y + my < self->rows)
2158 { 2605 {
2159 maprow *row = self->row + (y + my); 2606 maprow *row = self->row + (y + my);
… …
2162 if (row->c0 <= x + mx && x + mx < row->c1) 2609 if (row->c0 <= x + mx && x + mx < row->c1)
2163 { 2610 {
2164 mapcell *cell = row->col + (x + mx - row->c0); 2611 mapcell *cell = row->col + (x + mx - row->c0);
2165 2612
2166 darkness1 [y * sw1 + x] = cell->darkness 2613 darkness1 [y * sw1 + x] = cell->darkness
2167 ? 255 - (cell->darkness - 1) 2614 ? DARKNESS_ADJUST (255 - (cell->darkness - 1))
2168 : 255 - FOW_DARKNESS; 2615 : DARKNESS_ADJUST (255 - FOW_DARKNESS);
2169 } 2616 }
2170 } 2617 }
2171 2618
2172 for (y = 0; y < sh; ++y) 2619 for (y = 0; y < sh; ++y)
2173 for (x = 0; x < sw; ++x) 2620 for (x = 0; x < sw; ++x)
… …
2192 2639
2193 uint8_t r13 = (d13 + d23 + d12) / 3; 2640 uint8_t r13 = (d13 + d23 + d12) / 3;
2194 uint8_t r23 = d23; 2641 uint8_t r23 = d23;
2195 uint8_t r33 = (d23 + d33 + d32) / 3; 2642 uint8_t r33 = (d23 + d33 + d32) / 3;
2196 2643
2197 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11); 2644 darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2198 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21); 2645 darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2199 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31); 2646 darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2200 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12); 2647 darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2201 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 */
2202 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32); 2649 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2203 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13); 2650 darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2204 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23); 2651 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2205 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33); 2652 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2206 } 2653 }
2207 2654
2208 free (darkness1); 2655 free (darkness1);
2209 2656
2210 EXTEND (SP, 3); 2657 EXTEND (SP, 3);
2211 PUSHs (sv_2mortal (newSViv (sw34))); 2658 PUSHs (sv_2mortal (newSViv (sw3)));
2212 PUSHs (sv_2mortal (newSViv (sh3))); 2659 PUSHs (sv_2mortal (newSViv (sh3)));
2213 PUSHs (darkness3_sv); 2660 PUSHs (darkness3_sv);
2214} 2661}
2215 2662
2216SV * 2663SV *
… …
2279 else 2726 else
2280 *data++ = 0; 2727 *data++ = 0;
2281 } 2728 }
2282 } 2729 }
2283 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 {
2284 SvPOK_only (data_sv); 2734 SvPOK_only (data_sv);
2285 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv)); 2735 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2736 }
2737
2286 RETVAL = data_sv; 2738 RETVAL = data_sv;
2287} 2739}
2288 OUTPUT: 2740 OUTPUT:
2289 RETVAL 2741 RETVAL
2290 2742
2291void 2743void
2292set_rect (DC::Map self, int x0, int y0, uint8_t *data) 2744set_rect (DC::Map self, int x0, int y0, SV *data_sv)
2293 PPCODE: 2745 PPCODE:
2294{ 2746{
2295 int x, y, z; 2747 int x, y, z;
2296 int w, h; 2748 int w, h;
2297 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;
2298 2760
2299 if (*data++ != 0) 2761 if (*data++ != 0)
2300 XSRETURN_EMPTY; /* version mismatch */ 2762 XSRETURN_EMPTY; /* version mismatch */
2301 2763
2302 w = *data++ << 8; w |= *data++; 2764 w = *data++ << 8; w |= *data++;
… …
2317 { 2779 {
2318 maprow *row = map_get_row (self, y); 2780 maprow *row = map_get_row (self, y);
2319 2781
2320 for (x = x0; x < x1; x++) 2782 for (x = x0; x < x1; x++)
2321 { 2783 {
2784 uint8_t flags;
2785
2786 if (data + 7 >= end)
2787 XSRETURN_EMPTY;
2788
2322 uint8_t flags = *data++; 2789 flags = *data++;
2323 2790
2324 if (flags) 2791 if (flags)
2325 { 2792 {
2326 mapcell *cell = row_get_cell (row, x); 2793 mapcell *cell = row_get_cell (row, x);
2327 tileid tile[3] = { 0, 0, 0 }; 2794 tileid tile[3] = { 0, 0, 0 };
… …
2330 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; } 2797 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
2331 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; } 2798 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
2332 2799
2333 if (cell->darkness == 0) 2800 if (cell->darkness == 0)
2334 { 2801 {
2335 cell->darkness = 0; 2802 /*cell->darkness = 0;*/
2803 EXTEND (SP, 3);
2336 2804
2337 for (z = 0; z <= 2; z++) 2805 for (z = 0; z <= 2; z++)
2338 { 2806 {
2339 tileid t = tile [z]; 2807 tileid t = tile [z];
2340 2808
2341 if (t >= self->texs || (t && !self->tex [t].name)) 2809 if (t >= self->texs || (t && !self->tex [t].name))
2342 { 2810 {
2343 XPUSHs (sv_2mortal (newSViv (t))); 2811 PUSHs (sv_2mortal (newSViv (t)));
2344 need_texid (self, t); 2812 need_texid (self, t);
2345 } 2813 }
2346 2814
2347 cell->tile [z] = t; 2815 cell->tile [z] = t;
2348 } 2816 }
… …
2353} 2821}
2354 2822
2355MODULE = Deliantra::Client PACKAGE = DC::RW 2823MODULE = Deliantra::Client PACKAGE = DC::RW
2356 2824
2357DC::RW 2825DC::RW
2358new (SV *class, SV *data_sv) 2826new (SV *klass, SV *data_sv)
2359 CODE: 2827 CODE:
2360{ 2828{
2361 STRLEN datalen; 2829 STRLEN datalen;
2362 char *data = SvPVbyte (data_sv, datalen); 2830 char *data = SvPVbyte (data_sv, datalen);
2363 2831
… …
2365} 2833}
2366 OUTPUT: 2834 OUTPUT:
2367 RETVAL 2835 RETVAL
2368 2836
2369DC::RW 2837DC::RW
2370new_from_file (SV *class, const char *path, const char *mode = "rb") 2838new_from_file (SV *klass, const char *path, const char *mode = "rb")
2371 CODE: 2839 CODE:
2372 RETVAL = SDL_RWFromFile (path, mode); 2840 RETVAL = SDL_RWFromFile (path, mode);
2373 OUTPUT: 2841 OUTPUT:
2374 RETVAL 2842 RETVAL
2375 2843
… …
2393 if (RETVAL < 0) 2861 if (RETVAL < 0)
2394 { 2862 {
2395 RETVAL = Mix_GroupOldest (-1); 2863 RETVAL = Mix_GroupOldest (-1);
2396 2864
2397 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)
2398 XSRETURN_UNDEF; 2871 XSRETURN_UNDEF;
2399 2872 }
2873 else
2400 Mix_HaltChannel (RETVAL); 2874 Mix_HaltChannel (RETVAL);
2401 } 2875 }
2402 2876
2403 Mix_UnregisterAllEffects (RETVAL); 2877 Mix_UnregisterAllEffects (RETVAL);
2404 Mix_Volume (RETVAL, 128); 2878 Mix_Volume (RETVAL, 128);
2405} 2879}
… …
2452void 2926void
2453set_position_r (DC::Channel self, int dx, int dy, int maxdistance) 2927set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2454 CODE: 2928 CODE:
2455{ 2929{
2456 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));
2457 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;
2458 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255)); 2932 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2459} 2933}
2460 2934
2461void 2935void
2462set_reverse_stereo (DC::Channel self, int flip) 2936set_reverse_stereo (DC::Channel self, int flip)
… …
2465 2939
2466MODULE = Deliantra::Client PACKAGE = DC::MixChunk 2940MODULE = Deliantra::Client PACKAGE = DC::MixChunk
2467 2941
2468PROTOTYPES: DISABLE 2942PROTOTYPES: DISABLE
2469 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
2470DC::MixChunk 2956DC::MixChunk
2471new (SV *class, DC::RW rwops) 2957new (SV *klass, DC::RW rwops)
2472 CODE: 2958 CODE:
2473 RETVAL = Mix_LoadWAV_RW (rwops, 1); 2959 RETVAL = Mix_LoadWAV_RW (rwops, 1);
2474 OUTPUT: 2960 OUTPUT:
2475 RETVAL 2961 RETVAL
2476 2962
… …
2506 OUTPUT: 2992 OUTPUT:
2507 RETVAL 2993 RETVAL
2508 2994
2509MODULE = Deliantra::Client PACKAGE = DC::MixMusic 2995MODULE = Deliantra::Client PACKAGE = DC::MixMusic
2510 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
2511int 3009int
2512volume (int volume = -1) 3010volume (int volume = -1)
2513 PROTOTYPE: ;$ 3011 PROTOTYPE: ;$
2514 CODE: 3012 CODE:
2515 if (items > 0) 3013 if (items > 0)
… …
2526void 3024void
2527halt () 3025halt ()
2528 CODE: 3026 CODE:
2529 Mix_HaltMusic (); 3027 Mix_HaltMusic ();
2530 3028
3029int
3030playing ()
3031 CODE:
3032 RETVAL = Mix_PlayingMusic ();
3033 OUTPUT:
3034 RETVAL
3035
2531DC::MixMusic 3036DC::MixMusic
2532new (SV *class, DC::RW rwops) 3037new (SV *klass, DC::RW rwops)
2533 CODE: 3038 CODE:
2534 RETVAL = Mix_LoadMUS_RW (rwops); 3039 RETVAL = Mix_LoadMUS_RW (rwops);
2535 OUTPUT: 3040 OUTPUT:
2536 RETVAL 3041 RETVAL
2537 3042
… …
2565 } *civ, const_iv[] = { 3070 } *civ, const_iv[] = {
2566# define const_iv(name) { # name, (IV)name } 3071# define const_iv(name) { # name, (IV)name }
2567 const_iv (GL_VENDOR), 3072 const_iv (GL_VENDOR),
2568 const_iv (GL_VERSION), 3073 const_iv (GL_VERSION),
2569 const_iv (GL_EXTENSIONS), 3074 const_iv (GL_EXTENSIONS),
3075 const_iv (GL_MAX_TEXTURE_UNITS),
2570 const_iv (GL_COLOR_MATERIAL), 3076 const_iv (GL_COLOR_MATERIAL),
2571 const_iv (GL_SMOOTH), 3077 const_iv (GL_SMOOTH),
2572 const_iv (GL_FLAT), 3078 const_iv (GL_FLAT),
2573 const_iv (GL_DITHER), 3079 const_iv (GL_DITHER),
2574 const_iv (GL_BLEND), 3080 const_iv (GL_BLEND),
… …
2586 const_iv (GL_ZERO), 3092 const_iv (GL_ZERO),
2587 const_iv (GL_SRC_ALPHA), 3093 const_iv (GL_SRC_ALPHA),
2588 const_iv (GL_DST_ALPHA), 3094 const_iv (GL_DST_ALPHA),
2589 const_iv (GL_ONE_MINUS_SRC_ALPHA), 3095 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2590 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),
2591 const_iv (GL_SRC_ALPHA_SATURATE), 3101 const_iv (GL_SRC_ALPHA_SATURATE),
2592 const_iv (GL_RGB), 3102 const_iv (GL_RGB),
2593 const_iv (GL_RGBA), 3103 const_iv (GL_RGBA),
2594 const_iv (GL_RGBA4), 3104 const_iv (GL_RGBA4),
2595 const_iv (GL_RGBA8), 3105 const_iv (GL_RGBA8),
… …
2663 const_iv (GL_NICEST), 3173 const_iv (GL_NICEST),
2664 const_iv (GL_V2F), 3174 const_iv (GL_V2F),
2665 const_iv (GL_V3F), 3175 const_iv (GL_V3F),
2666 const_iv (GL_T2F_V3F), 3176 const_iv (GL_T2F_V3F),
2667 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),
2668# undef const_iv 3181# undef const_iv
2669 }; 3182 };
2670 3183
2671 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--)
2672 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 3185 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
2673 3186
2674 texture_av = newAV (); 3187 texture_av = newAV ();
2675 AvREAL_off (texture_av); 3188 AvREAL_off (texture_av);
2676} 3189}
2677 3190
… …
2679disable_GL_EXT_blend_func_separate () 3192disable_GL_EXT_blend_func_separate ()
2680 CODE: 3193 CODE:
2681 gl.BlendFuncSeparate = 0; 3194 gl.BlendFuncSeparate = 0;
2682 gl.BlendFuncSeparateEXT = 0; 3195 gl.BlendFuncSeparateEXT = 0;
2683 3196
2684char * 3197void
3198apple_nvidia_bug (int enable)
3199
3200const char *
2685gl_vendor () 3201gl_vendor ()
2686 CODE: 3202 CODE:
2687 RETVAL = (char *)glGetString (GL_VENDOR); 3203 RETVAL = (const char *)glGetString (GL_VENDOR);
2688 OUTPUT: 3204 OUTPUT:
2689 RETVAL 3205 RETVAL
2690 3206
2691char * 3207const char *
2692gl_version () 3208gl_version ()
2693 CODE: 3209 CODE:
2694 RETVAL = (char *)glGetString (GL_VERSION); 3210 RETVAL = (const char *)glGetString (GL_VERSION);
2695 OUTPUT: 3211 OUTPUT:
2696 RETVAL 3212 RETVAL
2697 3213
2698char * 3214const char *
2699gl_extensions () 3215gl_extensions ()
2700 CODE: 3216 CODE:
2701 RETVAL = (char *)glGetString (GL_EXTENSIONS); 3217 RETVAL = (const char *)glGetString (GL_EXTENSIONS);
2702 OUTPUT: 3218 OUTPUT:
2703 RETVAL 3219 RETVAL
2704 3220
2705const char *glGetString (GLenum pname) 3221const char *glGetString (GLenum pname)
3222 CODE:
3223 RETVAL = (const char *)glGetString (pname);
3224 OUTPUT:
3225 RETVAL
2706 3226
2707GLint glGetInteger (GLenum pname) 3227GLint glGetInteger (GLenum pname)
2708 CODE: 3228 CODE:
2709 glGetIntegerv (pname, &RETVAL); 3229 glGetIntegerv (pname, &RETVAL);
2710 OUTPUT: 3230 OUTPUT:
… …
2718 3238
2719int glGetError () 3239int glGetError ()
2720 3240
2721void glFinish () 3241void glFinish ()
2722 3242
3243void glFlush ()
3244
2723void glClear (int mask) 3245void glClear (int mask)
2724 3246
2725void glClearColor (float r, float g, float b, float a = 1.0) 3247void glClearColor (float r, float g, float b, float a = 1.0)
2726 PROTOTYPE: @ 3248 PROTOTYPE: @
2727 3249
… …
2736void glBlendFunc (int sfactor, int dfactor) 3258void glBlendFunc (int sfactor, int dfactor)
2737 3259
2738void glBlendFuncSeparate (int sa, int da, int saa, int daa) 3260void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2739 CODE: 3261 CODE:
2740 gl_BlendFuncSeparate (sa, da, saa, daa); 3262 gl_BlendFuncSeparate (sa, da, saa, daa);
3263
3264# void glBlendEquation (int se)
2741 3265
2742void glDepthMask (int flag) 3266void glDepthMask (int flag)
2743 3267
2744void glLogicOp (int opcode) 3268void glLogicOp (int opcode)
2745 3269
… …
2780void glRotate (float angle, float x, float y, float z) 3304void glRotate (float angle, float x, float y, float z)
2781 CODE: 3305 CODE:
2782 glRotatef (angle, x, y, z); 3306 glRotatef (angle, x, y, z);
2783 3307
2784void 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: @
2785 ALIAS: 3310 ALIAS:
2786 glColor_premultiply = 1 3311 glColor_premultiply = 1
2787 CODE: 3312 CODE:
2788 if (ix) 3313 if (ix)
2789 { 3314 {
… …
2895 3420
2896void glEndList () 3421void glEndList ()
2897 3422
2898void glCallList (int list) 3423void glCallList (int list)
2899 3424
3425void c_init ()
3426 CODE:
3427 glPixelStorei (GL_PACK_ALIGNMENT , 1);
3428 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
3429
2900MODULE = Deliantra::Client PACKAGE = DC::UI::Base 3430MODULE = Deliantra::Client PACKAGE = DC::UI::Base
2901 3431
2902PROTOTYPES: DISABLE 3432PROTOTYPES: DISABLE
2903 3433
2904void 3434void
2905find_widget (SV *self, NV x, NV y) 3435find_widget (SV *self, NV x, NV y)
2906 PPCODE: 3436 PPCODE:
2907{ 3437{
2908 if (within_widget (self, x, y)) 3438 if (within_widget (self, x, y))
2909 XPUSHs (self); 3439 XPUSHs (self);
2910} 3440}
2911 3441
2912BOOT: 3442BOOT:
2913{ 3443{
… …
2921 3451
2922void 3452void
2923draw (SV *self) 3453draw (SV *self)
2924 CODE: 3454 CODE:
2925{ 3455{
2926 HV *hv; 3456 HV *hv;
2927 SV **svp; 3457 SV **svp;
2928 NV x, y, w, h; 3458 NV x, y, w, h;
2929 SV *draw_x_sv = GvSV (draw_x_gv); 3459 SV *draw_x_sv = GvSV (draw_x_gv);
2930 SV *draw_y_sv = GvSV (draw_y_gv); 3460 SV *draw_y_sv = GvSV (draw_y_gv);
2931 SV *draw_w_sv = GvSV (draw_w_gv); 3461 SV *draw_w_sv = GvSV (draw_w_gv);
2932 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