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.256 by root, Mon Mar 24 00:24:46 2008 UTC vs.
Revision 1.331 by root, Mon Nov 19 00:10:34 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#ifndef PANGO_VERSION_CHECK 62#ifndef PANGO_VERSION_CHECK
52# define PANGO_VERSION_CHECK(a,b,c) 0 63# define PANGO_VERSION_CHECK(a,b,c) 0
… …
65# include <netinet/in.h> 76# include <netinet/in.h>
66# include <netinet/tcp.h> 77# include <netinet/tcp.h>
67# include <inttypes.h> 78# include <inttypes.h>
68#endif 79#endif
69 80
81#include "ecb.h"
82
70#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */ 83#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
71 84
85/* this is used as fow flag as well, so has to have a different value */
86/* then anything that is computed by incoming darkness */
72#define FOW_DARKNESS 32 87#define FOW_DARKNESS 50
88#define DARKNESS_ADJUST(n) (n)
73 89
74#define MAP_EXTEND_X 32 90#define MAP_EXTEND_X 32
75#define MAP_EXTEND_Y 512 91#define MAP_EXTEND_Y 512
76 92
77#define MIN_FONT_HEIGHT 10 93#define MIN_FONT_HEIGHT 10
78 94
79/* mask out modifiers we are not interested in */ 95/* mask out modifiers we are not interested in */
80#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META) 96#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)
81 97
82#if 0 98#define KMOD_LRAM 0x10000 // our extension
83# define PARACHUTE SDL_INIT_NOPARACHUTE 99
84#else 100#define TEXID_SPEECH 1
85# define PARACHUTE 0 101#define TEXID_NOFACE 2
86#endif 102
103static char *
104fast_sv_grow (SV *sv, STRLEN need)
105{
106 STRLEN len = SvLEN (sv);
107 STRLEN want = SvCUR (sv) + need;
108
109 if (ecb_expect_false (len < want))
110 {
111 do
112 len *= 2;
113 while (len < want);
114
115 sv_grow (sv, len);
116 }
117
118 SvCUR_set (sv, want);
119 return SvEND (sv) - need;
120}
87 121
88static AV *texture_av; 122static AV *texture_av;
89 123
90static struct 124static struct
91{ 125{
… …
148{ 182{
149 GSList *attrs = run->item->analysis.extra_attrs; 183 GSList *attrs = run->item->analysis.extra_attrs;
150 184
151 while (attrs) 185 while (attrs)
152 { 186 {
153 PangoAttribute *attr = attrs->data; 187 PangoAttribute *attr = (PangoAttribute *)attrs->data;
154 188
155 if (attr->klass->type == PANGO_ATTR_SHAPE) 189 if (attr->klass->type == PANGO_ATTR_SHAPE)
156 return 1; 190 return 1;
157 191
158 attrs = attrs->next; 192 attrs = attrs->next;
159 } 193 }
160 194
161 return 0; 195 return 0;
162} 196}
163 197
164typedef struct cf_layout { 198struct cf_layout {
165 PangoLayout *pl; 199 PangoLayout *pl;
166 float r, g, b, a; // default color for rgba mode 200 float r, g, b, a; // default color for rgba mode
167 int base_height; 201 int base_height;
168 DC__Font font; 202 DC__Font font;
169 rc_t *rc; 203 rc_t rc;
170} *DC__Layout; 204};
205
206typedef cf_layout *DC__Layout;
171 207
172static DC__Font default_font; 208static DC__Font default_font;
173static PangoContext *opengl_context; 209static PangoContext *opengl_context;
174static PangoFontMap *opengl_fontmap; 210static PangoFontMap *opengl_fontmap;
175 211
176static void 212static void
177substitute_func (FcPattern *pattern, gpointer data) 213substitute_func (FcPattern *pattern, gpointer data)
178{ 214{
179 FcPatternAddBool (pattern, FC_HINTING, 1); 215 FcPatternAddBool (pattern, FC_HINTING, 1);
180#ifdef FC_HINT_STYLE 216#ifdef FC_HINT_STYLE
181 FcPatternAddBool (pattern, FC_HINT_STYLE, FC_HINT_FULL); 217 FcPatternAddInteger (pattern, FC_HINT_STYLE, FC_HINT_FULL);
182#endif 218#endif
183 FcPatternAddBool (pattern, FC_AUTOHINT, 0); 219 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
184} 220}
185 221
186static void 222static void
187layout_update_font (DC__Layout self) 223layout_update_font (DC__Layout self)
188{ 224{
189 /* use a random scale factor to account for unknown descenders, 0.8 works 225 /* use a random scale factor to account for unknown descenders, 0.8 works
190 * reasonably well with bitstream vera 226 * reasonably well with dejavu/bistream fonts
191 */ 227 */
192 PangoFontDescription *font = self->font ? self->font : default_font; 228 PangoFontDescription *font = self->font ? self->font : default_font;
193 229
194 pango_font_description_set_absolute_size (font, 230 pango_font_description_set_absolute_size (font,
195 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10)); 231 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
… …
213 249
214 *w = rect.width; 250 *w = rect.width;
215 *h = rect.height; 251 *h = rect.height;
216} 252}
217 253
254/////////////////////////////////////////////////////////////////////////////
255
218typedef uint16_t tileid; 256typedef uint16_t tileid;
219typedef uint16_t faceid; 257typedef uint16_t faceid;
220 258
221typedef struct { 259struct maptex
260{
222 GLuint name; 261 GLuint name;
223 int w, h; 262 int w, h;
224 float s, t; 263 float s, t;
225 uint8_t r, g, b, a; 264 uint8_t r, g, b, a;
226 tileid smoothtile; 265 tileid smoothtile;
227 uint8_t smoothlevel; 266 uint8_t smoothlevel;
228} maptex; 267 uint8_t unused; /* set to zero on use */
268};
229 269
230typedef struct { 270struct mapcell
271{
231 uint32_t player; 272 uint32_t player;
232 tileid tile[3]; 273 tileid tile[3];
233 uint16_t darkness; 274 uint16_t darkness;
234 uint8_t stat_width, stat_hp, flags, smoothmax; 275 uint8_t stat_width, stat_hp, flags, smoothmax;
235} mapcell; 276};
236 277
237typedef struct { 278struct maprow
279{
238 int32_t c0, c1; 280 int32_t c0, c1;
239 mapcell *col; 281 mapcell *col;
240} maprow; 282};
241 283
242typedef struct map { 284struct mapgrid {
243 int x, y, w, h; 285 int x, y, w, h;
244 int ox, oy; /* offset to virtual global coordinate system */ 286 int ox, oy; /* offset to virtual global coordinate system */
245 int faces; tileid *face2tile; // [faceid] 287 int faces; tileid *face2tile; // [faceid]
246 int texs; maptex *tex; // [tileid] 288 int texs; maptex *tex; // [tileid]
247 289
248 int32_t rows; 290 int32_t rows;
249 maprow *row; 291 maprow *row;
250} *DC__Map; 292};
251 293
252static char * 294typedef mapgrid *DC__Map;
295
296template<typename T>
297static void
253prepend (char *ptr, int sze, int inc) 298prepend (T *&ptr, int sze, int inc)
254{ 299{
255 char *p; 300 T *p;
256 301
257 New (0, p, sze + inc, char); 302 Newx (p, inc + sze, T);
258 Zero (p, inc, char); 303 Zero (p, inc, T);
259 Move (ptr, p + inc, sze, char); 304 Move (ptr, p + inc, sze, T);
260 Safefree (ptr); 305 Safefree (ptr);
261 306
262 return p; 307 ptr = p;
263} 308}
264 309
265static char * 310template<typename T>
266append (char *ptr, int sze, int inc)
267{
268 Renew (ptr, sze + inc, char);
269 Zero (ptr + sze, inc, char);
270
271 return ptr;
272}
273
274#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
275#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
276
277static void 311static void
312append (T *&ptr, int sze, int inc)
313{
314 Renew (ptr, sze + inc, T);
315 Zero (ptr + sze, inc, T);
316}
317
318static void
278need_facenum (struct map *self, faceid face) 319need_facenum (struct mapgrid *self, faceid face)
279{ 320{
280 while (self->faces <= face) 321 while (self->faces <= face)
281 { 322 {
282 Append (tileid, self->face2tile, self->faces, self->faces); 323 append (self->face2tile, self->faces, self->faces);
283 self->faces *= 2; 324 self->faces *= 2;
284 } 325 }
285} 326}
286 327
287static void 328static void
288need_texid (struct map *self, int texid) 329need_texid (struct mapgrid *self, int texid)
289{ 330{
290 while (self->texs <= texid) 331 while (self->texs <= texid)
291 { 332 {
292 Append (maptex, self->tex, self->texs, self->texs); 333 append (self->tex, self->texs, self->texs);
293 self->texs *= 2; 334 self->texs *= 2;
294 } 335 }
295} 336}
296 337
297static maprow * 338static maprow *
298map_get_row (DC__Map self, int y) 339map_get_row (mapgrid *self, int y)
299{ 340{
300 if (0 > y) 341 if (0 > y)
301 { 342 {
302 int extend = - y + MAP_EXTEND_Y; 343 int extend = - y + MAP_EXTEND_Y;
303 Prepend (maprow, self->row, self->rows, extend); 344 prepend (self->row, self->rows, extend);
304 345
305 self->rows += extend; 346 self->rows += extend;
306 self->y += extend; 347 self->y += extend;
307 y += extend; 348 y += extend;
308 } 349 }
309 else if (y >= self->rows) 350 else if (y >= self->rows)
310 { 351 {
311 int extend = y - self->rows + MAP_EXTEND_Y; 352 int extend = y - self->rows + MAP_EXTEND_Y;
312 Append (maprow, self->row, self->rows, extend); 353 append (self->row, self->rows, extend);
313 self->rows += extend; 354 self->rows += extend;
314 } 355 }
315 356
316 return self->row + y; 357 return self->row + y;
317} 358}
… …
327 } 368 }
328 369
329 if (row->c0 > x) 370 if (row->c0 > x)
330 { 371 {
331 int extend = row->c0 - x + MAP_EXTEND_X; 372 int extend = row->c0 - x + MAP_EXTEND_X;
332 Prepend (mapcell, row->col, row->c1 - row->c0, extend); 373 prepend (row->col, row->c1 - row->c0, extend);
333 row->c0 -= extend; 374 row->c0 -= extend;
334 } 375 }
335 else if (x >= row->c1) 376 else if (x >= row->c1)
336 { 377 {
337 int extend = x - row->c1 + MAP_EXTEND_X; 378 int extend = x - row->c1 + MAP_EXTEND_X;
338 Append (mapcell, row->col, row->c1 - row->c0, extend); 379 append (row->col, row->c1 - row->c0, extend);
339 row->c1 += extend; 380 row->c1 += extend;
340 } 381 }
341 382
342 return row->col + (x - row->c0); 383 return row->col + (x - row->c0);
343} 384}
344 385
345static mapcell * 386static mapcell *
346map_get_cell (DC__Map self, int x, int y) 387map_get_cell (mapgrid *self, int x, int y)
347{ 388{
348 return row_get_cell (map_get_row (self, y), x); 389 return row_get_cell (map_get_row (self, y), x);
349} 390}
350 391
351static void 392static void
352map_clear (DC__Map self) 393map_clear (mapgrid *self)
353{ 394{
354 int r; 395 int r;
355 396
356 for (r = 0; r < self->rows; r++) 397 for (r = 0; r < self->rows; r++)
357 Safefree (self->row[r].col); 398 Safefree (self->row[r].col);
… …
364 self->oy = 0; 405 self->oy = 0;
365 self->row = 0; 406 self->row = 0;
366 self->rows = 0; 407 self->rows = 0;
367} 408}
368 409
410#define CELL_CLEAR(cell) \
411 do { \
412 if ((cell)->player) \
413 (cell)->tile [2] = 0; \
414 (cell)->darkness = 0; \
415 (cell)->stat_hp = 0; \
416 (cell)->flags = 0; \
417 (cell)->player = 0; \
418 } while (0)
419
369static void 420static void
370map_blank (DC__Map self, int x0, int y0, int w, int h) 421map_blank (mapgrid *self, int x0, int y0, int w, int h)
371{ 422{
372 int x, y; 423 int x, y;
373 maprow *row; 424 maprow *row;
374 mapcell *cell; 425 mapcell *cell;
375 426
… …
387 if (x >= row->c1) 438 if (x >= row->c1)
388 break; 439 break;
389 440
390 cell = row->col + x - row->c0; 441 cell = row->col + x - row->c0;
391 442
392 cell->darkness = 0; 443 CELL_CLEAR (cell);
393 cell->stat_hp = 0;
394 cell->flags = 0;
395 cell->player = 0;
396 } 444 }
397 } 445 }
398} 446}
399 447
400typedef struct { 448struct smooth_key
449{
401 tileid tile; 450 tileid tile;
402 uint8_t x, y, level; 451 uint8_t x, y, level;
403} smooth_key; 452
453 bool operator == (const smooth_key &o) const
454 {
455 return tile == o.tile && x == o.x && y == o.y && level == o.level;
456 }
457};
458
459typedef ska::flat_hash_map<smooth_key, IV> smooth_hash;
460
461namespace std {
462 template <>
463 struct hash<smooth_key>
464 {
465 size_t operator () (const smooth_key &v) const
466 {
467 return v.tile + (v.x << 8) + (v.y << 16) + (v.level << 24);
468 }
469 };
470}
404 471
405static void 472static void
406smooth_or_bits (HV *hv, smooth_key *key, IV bits) 473smooth_or_bits (smooth_hash &h, smooth_key &key, IV bits)
407{ 474{
408 SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1); 475 auto &&it = h.find (key);
409 476
410 if (SvIOK (*sv)) 477 if (it == h.end ())
411 SvIV_set (*sv, SvIVX (*sv) | bits); 478 h.insert (std::make_pair (key, bits));
412 else 479 else
413 sv_setiv (*sv, bits); 480 it->second |= bits;
414} 481}
415 482
416static void 483static void
417music_finished (void) 484music_finished (void)
418{ 485{
… …
435 ev.code = 1; 502 ev.code = 1;
436 ev.data1 = (void *)(long)channel; 503 ev.data1 = (void *)(long)channel;
437 ev.data2 = 0; 504 ev.data2 = 0;
438 505
439 SDL_PushEvent ((SDL_Event *)&ev); 506 SDL_PushEvent ((SDL_Event *)&ev);
507}
508
509// approximately divide by 255
510static unsigned int
511div255 (unsigned int n)
512{
513 return (n + (n >> 8)) >> 8;
440} 514}
441 515
442static unsigned int 516static unsigned int
443minpot (unsigned int n) 517minpot (unsigned int n)
444{ 518{
… …
454 n |= n >> 16; 528 n |= n >> 16;
455 529
456 return n + 1; 530 return n + 1;
457} 531}
458 532
459static unsigned int
460popcount (unsigned int n)
461{
462 n -= (n >> 1) & 0x55555555U;
463 n = ((n >> 2) & 0x33333333U) + (n & 0x33333333U);
464 n = ((n >> 4) + n) & 0x0f0f0f0fU;
465 n *= 0x01010101U;
466
467 return n >> 24;
468}
469
470/* SDL should provide this, really. */ 533/* SDL should provide this, really. */
471#define SDLK_MODIFIER_MIN 300 534#define SDLK_MODIFIER_MIN 300
472#define SDLK_MODIFIER_MAX 314 535#define SDLK_MODIFIER_MAX 314
473 536
474/******************************************************************************/ 537/******************************************************************************/
… …
511 if (!svp || !SvTRUE (*svp)) 574 if (!svp || !SvTRUE (*svp))
512 return 0; 575 return 0;
513 576
514 return 1; 577 return 1;
515} 578}
579
580/******************************************************************************/
581
582/* process keyboard modifiers */
583static int
584mod_munge (int mod)
585{
586 mod &= MOD_MASK;
587
588 if (mod & (KMOD_META | KMOD_ALT))
589 mod |= KMOD_LRAM;
590
591 return mod;
592}
593
594static void
595deliantra_main (SV *real_main)
596{
597 dSP;
598
599 PUSHMARK (SP);
600 call_sv (real_main, G_DISCARD | G_VOID);
601}
602
603#ifdef __MACOSX__
604 static SV *real_main;
605
606 /* to due surprising braindamage on the side of SDL design, we
607 * do some mind-boggling hack here: SDL requires a custom main()
608 * on OS X, so... we provide one and call the original main(), which,
609 * due to shared library magic, calls -lSDLmain's main, not perl's main,
610 * and which calls our main (== SDL_main) back.
611 */
612 extern C_LINKAGE int
613 main (int argc, char *argv[])
614 {
615 deliantra_main (real_main);
616 }
617
618 #undef main
619
620 extern C_LINKAGE int main (int argc, char *argv[]);
621
622 static void
623 SDL_main_hack (SV *real_main_)
624 {
625 real_main = real_main_;
626
627 char *argv[] = { "deliantra client", 0 };
628 (main) (1, argv);
629 }
630#else
631 static void
632 SDL_main_hack (SV *real_main)
633 {
634 deliantra_main (real_main);
635 }
636#endif
516 637
517MODULE = Deliantra::Client PACKAGE = DC 638MODULE = Deliantra::Client PACKAGE = DC
518 639
519PROTOTYPES: ENABLE 640PROTOTYPES: ENABLE
520 641
… …
549 const_iv (SDL_USEREVENT), 670 const_iv (SDL_USEREVENT),
550 671
551 const_iv (SDL_APPINPUTFOCUS), 672 const_iv (SDL_APPINPUTFOCUS),
552 const_iv (SDL_APPMOUSEFOCUS), 673 const_iv (SDL_APPMOUSEFOCUS),
553 const_iv (SDL_APPACTIVE), 674 const_iv (SDL_APPACTIVE),
675
676
677 const_iv (SDLK_UNKNOWN),
678 const_iv (SDLK_FIRST),
679 const_iv (SDLK_BACKSPACE),
680 const_iv (SDLK_TAB),
681 const_iv (SDLK_CLEAR),
682 const_iv (SDLK_RETURN),
683 const_iv (SDLK_PAUSE),
684 const_iv (SDLK_ESCAPE),
685 const_iv (SDLK_SPACE),
686 const_iv (SDLK_EXCLAIM),
687 const_iv (SDLK_QUOTEDBL),
688 const_iv (SDLK_HASH),
689 const_iv (SDLK_DOLLAR),
690 const_iv (SDLK_AMPERSAND),
691 const_iv (SDLK_QUOTE),
692 const_iv (SDLK_LEFTPAREN),
693 const_iv (SDLK_RIGHTPAREN),
694 const_iv (SDLK_ASTERISK),
695 const_iv (SDLK_PLUS),
696 const_iv (SDLK_COMMA),
697 const_iv (SDLK_MINUS),
698 const_iv (SDLK_PERIOD),
699 const_iv (SDLK_SLASH),
700 const_iv (SDLK_0),
701 const_iv (SDLK_1),
702 const_iv (SDLK_2),
703 const_iv (SDLK_3),
704 const_iv (SDLK_4),
705 const_iv (SDLK_5),
706 const_iv (SDLK_6),
707 const_iv (SDLK_7),
708 const_iv (SDLK_8),
709 const_iv (SDLK_9),
710 const_iv (SDLK_COLON),
711 const_iv (SDLK_SEMICOLON),
712 const_iv (SDLK_LESS),
713 const_iv (SDLK_EQUALS),
714 const_iv (SDLK_GREATER),
715 const_iv (SDLK_QUESTION),
716 const_iv (SDLK_AT),
717
718 const_iv (SDLK_LEFTBRACKET),
719 const_iv (SDLK_BACKSLASH),
720 const_iv (SDLK_RIGHTBRACKET),
721 const_iv (SDLK_CARET),
722 const_iv (SDLK_UNDERSCORE),
723 const_iv (SDLK_BACKQUOTE),
724 const_iv (SDLK_DELETE),
554 725
555 const_iv (SDLK_FIRST), 726 const_iv (SDLK_FIRST),
556 const_iv (SDLK_LAST), 727 const_iv (SDLK_LAST),
557 const_iv (SDLK_KP0), 728 const_iv (SDLK_KP0),
558 const_iv (SDLK_KP1), 729 const_iv (SDLK_KP1),
… …
634 const_iv (KMOD_RMETA), 805 const_iv (KMOD_RMETA),
635 const_iv (KMOD_NUM), 806 const_iv (KMOD_NUM),
636 const_iv (KMOD_CAPS), 807 const_iv (KMOD_CAPS),
637 const_iv (KMOD_MODE), 808 const_iv (KMOD_MODE),
638 809
810 const_iv (KMOD_LRAM),
811
639 const_iv (MIX_DEFAULT_FORMAT), 812 const_iv (MIX_DEFAULT_FORMAT),
813
814 const_iv (SDL_INIT_TIMER),
815 const_iv (SDL_INIT_AUDIO),
816 const_iv (SDL_INIT_VIDEO),
817 const_iv (SDL_INIT_CDROM),
818 const_iv (SDL_INIT_JOYSTICK),
819 const_iv (SDL_INIT_EVERYTHING),
820 const_iv (SDL_INIT_NOPARACHUTE),
821 const_iv (SDL_INIT_EVENTTHREAD),
822
823 const_iv (SDL_GL_RED_SIZE),
824 const_iv (SDL_GL_GREEN_SIZE),
825 const_iv (SDL_GL_BLUE_SIZE),
826 const_iv (SDL_GL_ALPHA_SIZE),
827 const_iv (SDL_GL_DOUBLEBUFFER),
828 const_iv (SDL_GL_BUFFER_SIZE),
829 const_iv (SDL_GL_DEPTH_SIZE),
830 const_iv (SDL_GL_STENCIL_SIZE),
831 const_iv (SDL_GL_ACCUM_RED_SIZE),
832 const_iv (SDL_GL_ACCUM_GREEN_SIZE),
833 const_iv (SDL_GL_ACCUM_BLUE_SIZE),
834 const_iv (SDL_GL_ACCUM_ALPHA_SIZE),
835 const_iv (SDL_GL_STEREO),
836 const_iv (SDL_GL_MULTISAMPLEBUFFERS),
837 const_iv (SDL_GL_MULTISAMPLESAMPLES),
838 const_iv (SDL_GL_ACCELERATED_VISUAL),
839 const_iv (SDL_GL_SWAP_CONTROL),
840
841 const_iv (FOW_DARKNESS)
640# undef const_iv 842# undef const_iv
641 }; 843 };
642 844
643 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 845 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
644 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 846 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
645 847
646 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK); 848 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
647 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE); 849 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
648} 850}
649 851
… …
665NV ceil (NV x) 867NV ceil (NV x)
666 868
667IV minpot (UV n) 869IV minpot (UV n)
668 870
669IV popcount (UV n) 871IV popcount (UV n)
872 CODE:
873 RETVAL = ecb_popcount32 (n);
874 OUTPUT:
875 RETVAL
876
877NV distance (NV dx, NV dy)
878 CODE:
879 RETVAL = pow (dx * dx + dy * dy, 0.5);
880 OUTPUT:
881 RETVAL
670 882
671void 883void
672pango_init () 884pango_init ()
673 CODE: 885 CODE:
674{ 886{
675 opengl_fontmap = pango_opengl_font_map_new (); 887 opengl_fontmap = pango_opengl_font_map_new ();
676 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0); 888 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
677 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap); 889 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
890 /*pango_context_set_font_description (opengl_context, default_font);*/
678#if PANGO_VERSION_CHECK (1, 15, 2) 891#if PANGO_VERSION_CHECK (1, 15, 2)
679 pango_context_set_language (opengl_context, pango_language_from_string ("en")); 892 pango_context_set_language (opengl_context, pango_language_from_string ("en"));
680 /*pango_context_set_base_dir (opengl_context, PANGO_DIRECTION_WEAK_LTR);*/ 893 /*pango_context_set_base_dir (opengl_context, PANGO_DIRECTION_WEAK_LTR);*/
681#endif 894#endif
682} 895}
683 896
684char *
685SDL_GetError () 897char *SDL_GetError ()
686 898
687int 899void SDL_main_hack (SV *real_main)
688SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE) 900 PROTOTYPE: &
689 901
690void 902int SDL_Init (U32 flags)
903
904int SDL_InitSubSystem (U32 flags)
905
906void SDL_QuitSubSystem (U32 flags)
907
691SDL_Quit () 908void SDL_Quit ()
909
910int SDL_GL_SetAttribute (int attr, int value)
911 C_ARGS: (SDL_GLattr)attr, value
912
913int SDL_GL_GetAttribute (int attr)
914 CODE:
915 if (SDL_GL_GetAttribute ((SDL_GLattr)attr, &RETVAL))
916 XSRETURN_UNDEF;
917 OUTPUT:
918 RETVAL
692 919
693void 920void
694SDL_ListModes (int rgb, int alpha) 921SDL_ListModes (int rgb, int alpha)
695 PPCODE: 922 PPCODE:
696{ 923{
… …
708 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0); 935 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
709 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0); 936 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
710 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0); 937 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
711 938
712 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); 939 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
713#if SDL_VERSION_ATLEAST(1,2,10)
714 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
715 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1); 940 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
716#endif
717 941
718 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 942 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
719 943
720 if (m && m != (SDL_Rect **)-1) 944 if (m && m != (SDL_Rect **)-1)
721 while (*m) 945 while (*m)
722 { 946 {
723 if ((*m)->w >= 800 && (*m)->h >= 480) 947 if ((*m)->w >= 400 && (*m)->h >= 300)
724 { 948 {
725 AV *av = newAV (); 949 AV *av = newAV ();
726 av_push (av, newSViv ((*m)->w)); 950 av_push (av, newSViv ((*m)->w));
727 av_push (av, newSViv ((*m)->h)); 951 av_push (av, newSViv ((*m)->h));
728 av_push (av, newSViv (rgb)); 952 av_push (av, newSViv (rgb));
… …
751 ); 975 );
752 976
753 if (RETVAL) 977 if (RETVAL)
754 { 978 {
755 av_clear (texture_av); 979 av_clear (texture_av);
756
757 SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
758#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name); 980#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
759#include "glfunc.h" 981#include "glfunc.h"
760#undef GL_FUNC 982#undef GL_FUNC
983 if (!gl.ActiveTexture ) gl.ActiveTexture = gl.ActiveTextureARB;
984 if (!gl.MultiTexCoord2f) gl.MultiTexCoord2f = gl.MultiTexCoord2fARB;
761 } 985 }
762} 986}
763 OUTPUT: 987 OUTPUT:
764 RETVAL 988 RETVAL
989
990void
991SDL_WM_SetCaption (const char *title, const char *icon)
765 992
766void 993void
767SDL_GL_SwapBuffers () 994SDL_GL_SwapBuffers ()
768 995
769char * 996char *
770SDL_GetKeyName (int sym) 997SDL_GetKeyName (int sym)
998 C_ARGS: (SDLKey)sym
771 999
772int 1000int
773SDL_GetAppState () 1001SDL_GetAppState ()
774 1002
775int 1003int
776SDL_GetModState () 1004SDL_GetModState ()
777 1005
1006int
1007SDL_WaitEvent ()
1008 C_ARGS: 0
1009
778void 1010void
1011SDL_PumpEvents ()
1012
1013void
779poll_events () 1014peep_events ()
780 PPCODE: 1015 PPCODE:
781{ 1016{
782 SDL_Event ev; 1017 SDL_Event ev;
783 1018
784 SDL_PumpEvents (); 1019 SDL_PumpEvents ();
… …
791 { 1026 {
792 case SDL_KEYDOWN: 1027 case SDL_KEYDOWN:
793 case SDL_KEYUP: 1028 case SDL_KEYUP:
794 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 1029 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
795 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 1030 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
796 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod & MOD_MASK), 0); 1031 hv_store (hv, "mod", 3, newSViv (mod_munge (ev.key.keysym.mod)), 0);
797 hv_store (hv, "cmod", 4, newSViv (SDL_GetModState () & MOD_MASK), 0); /* current mode */ 1032 hv_store (hv, "cmod", 4, newSViv (mod_munge (SDL_GetModState ())), 0); /* current mode */
798 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 1033 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
799 break; 1034 break;
800 1035
801 case SDL_ACTIVEEVENT: 1036 case SDL_ACTIVEEVENT:
802 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 1037 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
… …
820 x = ev.motion.x; 1055 x = ev.motion.x;
821 y = ev.motion.y; 1056 y = ev.motion.y;
822 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)); 1057 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
823 } 1058 }
824 1059
825 hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0); 1060 hv_store (hv, "mod", 3, newSViv (mod_munge (SDL_GetModState ())), 0);
826 hv_store (hv, "state", 5, newSViv (state), 0); 1061 hv_store (hv, "state", 5, newSViv (state), 0);
827 hv_store (hv, "x", 1, newSViv (x), 0); 1062 hv_store (hv, "x", 1, newSViv (x), 0);
828 hv_store (hv, "y", 1, newSViv (y), 0); 1063 hv_store (hv, "y", 1, newSViv (y), 0);
829 hv_store (hv, "xrel", 4, newSViv (xrel), 0); 1064 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
830 hv_store (hv, "yrel", 4, newSViv (yrel), 0); 1065 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
… …
850 1085
851 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1)))); 1086 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1))));
852 } 1087 }
853} 1088}
854 1089
1090char *
1091SDL_AudioDriverName ()
1092 CODE:
1093{
1094 char buf [256];
1095 if (!SDL_AudioDriverName (buf, sizeof (buf)))
1096 XSRETURN_UNDEF;
1097
1098 RETVAL = buf;
1099}
1100 OUTPUT:
1101 RETVAL
1102
855int 1103int
856Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096) 1104Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)
857 POSTCALL: 1105 POSTCALL:
858 Mix_HookMusicFinished (music_finished); 1106 Mix_HookMusicFinished (music_finished);
859 Mix_ChannelFinished (channel_finished); 1107 Mix_ChannelFinished (channel_finished);
860 1108
861void 1109void
862Mix_QuerySpec () 1110Mix_QuerySpec ()
… …
915 } 1163 }
916 } 1164 }
917#endif 1165#endif
918} 1166}
919 1167
920void 1168int
921add_font (char *file) 1169add_font (char *file)
922 CODE: 1170 CODE:
923 FcConfigAppFontAddFile (0, (const FcChar8 *)file); 1171 RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);
1172 OUTPUT:
1173 RETVAL
1174
1175void
1176IMG_Init (int flags = IMG_INIT_JPG | IMG_INIT_PNG)
1177
1178# MIX_INIT_MP3 gives smpeg + libstdc++ + libgcc_s
1179void
1180Mix_Init (int flags = MIX_INIT_MOD | MIX_INIT_OGG)
924 1181
925void 1182void
926load_image_inline (SV *image_) 1183load_image_inline (SV *image_)
927 ALIAS: 1184 ALIAS:
928 load_image_file = 1 1185 load_image_file = 1
… …
974 1231
975 SDL_LockSurface (surface2); 1232 SDL_LockSurface (surface2);
976 EXTEND (SP, 6); 1233 EXTEND (SP, 6);
977 PUSHs (sv_2mortal (newSViv (surface2->w))); 1234 PUSHs (sv_2mortal (newSViv (surface2->w)));
978 PUSHs (sv_2mortal (newSViv (surface2->h))); 1235 PUSHs (sv_2mortal (newSViv (surface2->h)));
979 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 1236 PUSHs (sv_2mortal (newSVpvn ((const char *)surface2->pixels, surface2->h * surface2->pitch)));
980 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB))); 1237 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));
981 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 1238 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
982 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE))); 1239 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
983 SDL_UnlockSurface (surface2); 1240 SDL_UnlockSurface (surface2);
984 1241
… …
1044#if DEBUG 1301#if DEBUG
1045 VALGRIND_DO_LEAK_CHECK; 1302 VALGRIND_DO_LEAK_CHECK;
1046#endif 1303#endif
1047} 1304}
1048 1305
1306int
1307SvREFCNT (SV *sv)
1308 CODE:
1309 RETVAL = SvREFCNT (sv);
1310 OUTPUT:
1311 RETVAL
1312
1049MODULE = Deliantra::Client PACKAGE = DC::Font 1313MODULE = Deliantra::Client PACKAGE = DC::Font
1050 1314
1051PROTOTYPES: DISABLE 1315PROTOTYPES: DISABLE
1052 1316
1053DC::Font 1317DC::Font
1054new_from_file (SV *class, char *path, int id = 0) 1318new_from_file (SV *klass, char *path, int id = 0)
1055 CODE: 1319 CODE:
1056{ 1320{
1057 int count; 1321 int count;
1058 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count); 1322 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
1059 RETVAL = pango_fc_font_description_from_pattern (pattern, 0); 1323 RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
… …
1088 PROTOTYPE: 1352 PROTOTYPE:
1089 CODE: 1353 CODE:
1090 tc_restore (); 1354 tc_restore ();
1091 1355
1092DC::Layout 1356DC::Layout
1093new (SV *class) 1357new (SV *klass)
1094 CODE: 1358 CODE:
1095 New (0, RETVAL, 1, struct cf_layout); 1359 RETVAL = new cf_layout;
1096 1360
1097 RETVAL->pl = pango_layout_new (opengl_context); 1361 RETVAL->pl = pango_layout_new (opengl_context);
1098 RETVAL->r = 1.; 1362 RETVAL->r = 1.;
1099 RETVAL->g = 1.; 1363 RETVAL->g = 1.;
1100 RETVAL->b = 1.; 1364 RETVAL->b = 1.;
1101 RETVAL->a = 1.; 1365 RETVAL->a = 1.;
1102 RETVAL->base_height = MIN_FONT_HEIGHT; 1366 RETVAL->base_height = MIN_FONT_HEIGHT;
1103 RETVAL->font = 0; 1367 RETVAL->font = 0;
1104 RETVAL->rc = rc_alloc ();
1105 1368
1106 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR); 1369 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
1107 layout_update_font (RETVAL); 1370 layout_update_font (RETVAL);
1108 OUTPUT: 1371 OUTPUT:
1109 RETVAL 1372 RETVAL
1110 1373
1111void 1374void
1112DESTROY (DC::Layout self) 1375DESTROY (DC::Layout self)
1113 CODE: 1376 CODE:
1114 g_object_unref (self->pl); 1377 g_object_unref (self->pl);
1115 rc_free (self->rc);
1116 Safefree (self); 1378 delete self;
1117 1379
1118void 1380void
1119set_text (DC::Layout self, SV *text_) 1381set_text (DC::Layout self, SV *text_)
1120 CODE: 1382 CODE:
1121{ 1383{
… …
1247 1509
1248void 1510void
1249set_height (DC::Layout self, int base_height) 1511set_height (DC::Layout self, int base_height)
1250 CODE: 1512 CODE:
1251 if (self->base_height != base_height) 1513 if (self->base_height != base_height)
1252 { 1514 {
1253 self->base_height = base_height; 1515 self->base_height = base_height;
1254 layout_update_font (self); 1516 layout_update_font (self);
1255 } 1517 }
1256 1518
1257void 1519void
… …
1375} 1637}
1376 1638
1377void 1639void
1378render (DC::Layout self, float x, float y, int flags = 0) 1640render (DC::Layout self, float x, float y, int flags = 0)
1379 CODE: 1641 CODE:
1380 rc_clear (self->rc); 1642 self->rc.clear ();
1381 pango_opengl_render_layout_subpixel ( 1643 pango_opengl_render_layout_subpixel (
1382 self->pl, 1644 self->pl,
1383 self->rc, 1645 &self->rc,
1384 x * PANGO_SCALE, y * PANGO_SCALE, 1646 x * PANGO_SCALE, y * PANGO_SCALE,
1385 self->r, self->g, self->b, self->a, 1647 self->r, self->g, self->b, self->a,
1386 flags 1648 flags
1387 ); 1649 );
1388 // we assume that context_change actually clears/frees stuff 1650 // we assume that context_change actually clears/frees stuff
… …
1399 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, 1661 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1400 GL_ONE , GL_ONE_MINUS_SRC_ALPHA); 1662 GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1401 glEnable (GL_ALPHA_TEST); 1663 glEnable (GL_ALPHA_TEST);
1402 glAlphaFunc (GL_GREATER, 7.f / 255.f); 1664 glAlphaFunc (GL_GREATER, 7.f / 255.f);
1403 1665
1404 rc_draw (self->rc); 1666 self->rc.draw ();
1405 1667
1406 glDisable (GL_ALPHA_TEST); 1668 glDisable (GL_ALPHA_TEST);
1407 glDisable (GL_BLEND); 1669 glDisable (GL_BLEND);
1408 glDisable (GL_TEXTURE_2D); 1670 glDisable (GL_TEXTURE_2D);
1409} 1671}
… …
1484 glDisable (GL_ALPHA_TEST); 1746 glDisable (GL_ALPHA_TEST);
1485 glDisable (GL_BLEND); 1747 glDisable (GL_BLEND);
1486 } 1748 }
1487} 1749}
1488 1750
1751void
1752draw_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)
1753 PROTOTYPE: @
1754 CODE:
1755{
1756 glEnable (GL_BLEND);
1757 glBlendFunc (intensity ? GL_SRC_ALPHA : GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1758 glEnable (GL_TEXTURE_2D);
1759 glBindTexture (GL_TEXTURE_2D, name1);
1760
1761 glColor3f (intensity, intensity, intensity);
1762 glPushMatrix ();
1763 glScalef (1./3, 1./3, 1.);
1764
1765 if (blend > 0.f)
1766 {
1767 float dx3 = dx * -3.f / w;
1768 float dy3 = dy * -3.f / h;
1769 GLfloat env_color[4] = { 0., 0., 0., blend };
1770
1771 /* interpolate the two shadow textures */
1772 /* stage 0 == rgb(glcolor) + alpha(t0) */
1773 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1774
1775 /* stage 1 == rgb(glcolor) + alpha(interpolate t0, t1, texenv) */
1776 gl.ActiveTexture (GL_TEXTURE1);
1777 glEnable (GL_TEXTURE_2D);
1778 glBindTexture (GL_TEXTURE_2D, name2);
1779 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
1780
1781 /* rgb == rgb(glcolor) */
1782 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
1783 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
1784 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
1785
1786 /* alpha = interpolate t0, t1 by env_alpha */
1787 glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, env_color);
1788
1789 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_INTERPOLATE);
1790 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
1791 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
1792
1793 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
1794 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
1795
1796 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);
1797 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);
1798
1799 glBegin (GL_QUADS);
1800 gl.MultiTexCoord2f (GL_TEXTURE0, 0, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 ); glVertex2i (0, 0);
1801 gl.MultiTexCoord2f (GL_TEXTURE0, 0, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 + t); glVertex2i (0, h);
1802 gl.MultiTexCoord2f (GL_TEXTURE0, s, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 + t); glVertex2i (w, h);
1803 gl.MultiTexCoord2f (GL_TEXTURE0, s, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 ); glVertex2i (w, 0);
1804 glEnd ();
1805
1806 glDisable (GL_TEXTURE_2D);
1807 gl.ActiveTexture (GL_TEXTURE0);
1808 }
1809 else
1810 {
1811 /* simple blending of one texture, also opengl <1.3 path */
1812 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1813
1814 glBegin (GL_QUADS);
1815 glTexCoord2f (0, 0); glVertex2f (0, 0);
1816 glTexCoord2f (0, t); glVertex2f (0, h);
1817 glTexCoord2f (s, t); glVertex2f (w, h);
1818 glTexCoord2f (s, 0); glVertex2f (w, 0);
1819 glEnd ();
1820 }
1821
1822 /* draw ?-marks or equivalent, this is very clumsy code :/ */
1823 {
1824 int x, y;
1825 int dx3 = dx * 3;
1826 int dy3 = dy * 3;
1827
1828 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1829 glBindTexture (GL_TEXTURE_2D, hidden_tex);
1830 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1831 glTranslatef (-1., -1., 0);
1832 glBegin (GL_QUADS);
1833
1834 for (y = 1; y < h; y += 3)
1835 {
1836 int y1 = y - dy3;
1837 int y1valid = y1 >= 0 && y1 < h;
1838
1839 for (x = 1; x < w; x += 3)
1840 {
1841 int x1 = x - dx3;
1842 uint8_t h1 = data1 [x + y * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1843 uint8_t h2;
1844
1845 if (y1valid && x1 >= 0 && x1 < w)
1846 h2 = data2 [x1 + y1 * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1847 else
1848 h2 = 1; /* out of range == invisible */
1849
1850 if (h1 || h2)
1851 {
1852 float alpha = h1 == h2 ? 1.f : h1 ? 1.f - blend : blend;
1853 glColor4f (1., 1., 1., alpha);
1854
1855 glTexCoord2f (0, 0.); glVertex2i (x , y );
1856 glTexCoord2f (0, 1.); glVertex2i (x , y + 3);
1857 glTexCoord2f (1, 1.); glVertex2i (x + 3, y + 3);
1858 glTexCoord2f (1, 0.); glVertex2i (x + 3, y );
1859 }
1860 }
1861 }
1862 }
1863
1864 glEnd ();
1865
1866 glPopMatrix ();
1867
1868 glDisable (GL_TEXTURE_2D);
1869 glDisable (GL_BLEND);
1870}
1871
1489IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type) 1872IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1490 CODE: 1873 CODE:
1491{ 1874{
1492 GLint width; 1875 GLint width;
1493 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0); 1876 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
… …
1500MODULE = Deliantra::Client PACKAGE = DC::Map 1883MODULE = Deliantra::Client PACKAGE = DC::Map
1501 1884
1502PROTOTYPES: DISABLE 1885PROTOTYPES: DISABLE
1503 1886
1504DC::Map 1887DC::Map
1505new (SV *class) 1888new (SV *klass)
1506 CODE: 1889 CODE:
1507 New (0, RETVAL, 1, struct map); 1890 New (0, RETVAL, 1, mapgrid);
1508 RETVAL->x = 0; 1891 RETVAL->x = 0;
1509 RETVAL->y = 0; 1892 RETVAL->y = 0;
1510 RETVAL->w = 0; 1893 RETVAL->w = 0;
1511 RETVAL->h = 0; 1894 RETVAL->h = 0;
1512 RETVAL->ox = 0; 1895 RETVAL->ox = 0;
… …
1549 1932
1550void 1933void
1551set_smooth (DC::Map self, int face, int smooth, int level) 1934set_smooth (DC::Map self, int face, int smooth, int level)
1552 CODE: 1935 CODE:
1553{ 1936{
1554 tileid texid; 1937 tileid texid;
1555 maptex *tex; 1938 maptex *tex;
1556 1939
1557 if (face < 0 || face >= self->faces) 1940 if (face < 0 || face >= self->faces)
1558 return; 1941 return;
1559 1942
1560 if (smooth < 0 || smooth >= self->faces) 1943 if (smooth < 0 || smooth >= self->faces)
1561 return; 1944 return;
1562 1945
1563 texid = self->face2tile [face]; 1946 texid = self->face2tile [face];
1564 1947
1565 if (!texid) 1948 if (!texid)
1566 return; 1949 return;
1567 1950
1568 tex = self->tex + texid; 1951 tex = self->tex + texid;
… …
1597 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 1980 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1598 // use uglier nearest interpolation because linear suffers 1981 // use uglier nearest interpolation because linear suffers
1599 // from transparent color bleeding and ugly wrapping effects. 1982 // from transparent color bleeding and ugly wrapping effects.
1600 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1983 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1601} 1984}
1985
1986void
1987expire_textures (DC::Map self, int texid, int count)
1988 PPCODE:
1989 for (; texid < self->texs && count; ++texid, --count)
1990 {
1991 maptex *tex = self->tex + texid;
1992
1993 if (tex->name)
1994 {
1995 if (tex->unused)
1996 {
1997 tex->name = 0;
1998 tex->unused = 0;
1999 XPUSHs (sv_2mortal (newSViv (texid)));
2000 }
2001 else
2002 tex->unused = 1;
2003 }
2004 }
1602 2005
1603int 2006int
1604ox (DC::Map self) 2007ox (DC::Map self)
1605 ALIAS: 2008 ALIAS:
1606 oy = 1 2009 oy = 1
… …
1638 self->ox += dx; self->x += dx; 2041 self->ox += dx; self->x += dx;
1639 self->oy += dy; self->y += dy; 2042 self->oy += dy; self->y += dy;
1640 2043
1641 while (self->y < 0) 2044 while (self->y < 0)
1642 { 2045 {
1643 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y); 2046 prepend (self->row, self->rows, MAP_EXTEND_Y);
1644 2047
1645 self->rows += MAP_EXTEND_Y; 2048 self->rows += MAP_EXTEND_Y;
1646 self->y += MAP_EXTEND_Y; 2049 self->y += MAP_EXTEND_Y;
1647 } 2050 }
1648} 2051}
1649 2052
1650SV * 2053SV *
1651map1a_update (DC::Map self, SV *data_, int extmap) 2054map1a_update (DC::Map self, SV *data_)
1652 CODE: 2055 CODE:
1653{ 2056{
1654 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 2057 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1655 uint8_t *data_end = (uint8_t *)SvEND (data_); 2058 uint8_t *data_end = (uint8_t *)SvEND (data_);
1656 mapcell *cell; 2059 mapcell *cell;
… …
1677 2080
1678 //TODO: don't trust server data to be in-range(!) 2081 //TODO: don't trust server data to be in-range(!)
1679 2082
1680 if (flags & 8) 2083 if (flags & 8)
1681 { 2084 {
2085 uint8_t ext, cmd;
2086
1682 if (extmap) 2087 do
1683 { 2088 {
1684 uint8_t ext, cmd; 2089 ext = *data++;
2090 cmd = ext & 0x7f;
1685 2091
1686 do 2092 if (cmd < 4)
2093 cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
2094 else if (cmd == 5) // health
1687 { 2095 {
1688 ext = *data++;
1689 cmd = ext & 0x3f;
1690
1691 if (cmd < 4)
1692 cell->darkness = 255 - ext * 64 + 1;
1693 else if (cmd == 5) // health
1694 {
1695 cell->stat_width = 1; 2096 cell->stat_width = 1;
1696 cell->stat_hp = *data++; 2097 cell->stat_hp = *data++;
1697 }
1698 else if (cmd == 6) // monster width
1699 cell->stat_width = *data++ + 1;
1700 else if (cmd == 0x47)
1701 {
1702 if (*data == 4)
1703 ; // decode player count
1704
1705 data += *data + 1;
1706 }
1707 else if (cmd == 8) // cell flags
1708 cell->flags = *data++;
1709 else if (ext & 0x40) // unknown, multibyte => skip
1710 data += *data + 1;
1711 else
1712 data++;
1713 } 2098 }
1714 while (ext & 0x80); 2099 else if (cmd == 6) // monster width
2100 cell->stat_width = *data++ + 1;
2101 else if (cmd == 0x47)
2102 {
2103 if (*data == 1) cell->player = data [1];
2104 else if (*data == 2) cell->player = data [2] + (data [1] << 8);
2105 else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
2106 else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
2107
2108 data += *data + 1;
2109 }
2110 else if (cmd == 8) // cell flags
2111 cell->flags = *data++;
2112 else if (ext & 0x40) // unknown, multibyte => skip
2113 data += *data + 1;
2114 else
2115 data++;
1715 } 2116 }
1716 else 2117 while (ext & 0x80);
1717 cell->darkness = *data++ + 1;
1718 } 2118 }
1719 2119
1720 for (z = 0; z <= 2; ++z) 2120 for (z = 0; z <= 2; ++z)
1721 if (flags & (4 >> z)) 2121 if (flags & (4 >> z))
1722 { 2122 {
… …
1725 cell->tile [z] = self->face2tile [face]; 2125 cell->tile [z] = self->face2tile [face];
1726 2126
1727 if (cell->tile [z]) 2127 if (cell->tile [z])
1728 { 2128 {
1729 maptex *tex = self->tex + cell->tile [z]; 2129 maptex *tex = self->tex + cell->tile [z];
2130 tex->unused = 0;
1730 if (!tex->name) 2131 if (!tex->name)
1731 av_push (missing, newSViv (cell->tile [z])); 2132 av_push (missing, newSViv (cell->tile [z]));
1732 2133
1733 if (tex->smoothtile) 2134 if (tex->smoothtile)
1734 { 2135 {
1735 maptex *smooth = self->tex + tex->smoothtile; 2136 maptex *smooth = self->tex + tex->smoothtile;
2137 smooth->unused = 0;
1736 if (!smooth->name) 2138 if (!smooth->name)
1737 av_push (missing, newSViv (tex->smoothtile)); 2139 av_push (missing, newSViv (tex->smoothtile));
1738 } 2140 }
1739 } 2141 }
1740 } 2142 }
1741 } 2143 }
1742 else 2144 else
1743 cell->darkness = 0; 2145 CELL_CLEAR (cell);
1744 } 2146 }
1745} 2147}
1746 OUTPUT: 2148 OUTPUT:
1747 RETVAL 2149 RETVAL
1748 2150
… …
1768 ? self->row + y 2170 ? self->row + y
1769 : 0; 2171 : 0;
1770 2172
1771 for (x = x0; x < x1; x++) 2173 for (x = x0; x < x1; x++)
1772 { 2174 {
1773 int r = 32, g = 32, b = 32, a = 192; 2175 unsigned int r = 32, g = 32, b = 32, a = 192;
1774 2176
1775 if (row && row->c0 <= x && x < row->c1) 2177 if (row && row->c0 <= x && x < row->c1)
1776 { 2178 {
1777 mapcell *cell = row->col + (x - row->c0); 2179 mapcell *cell = row->col + (x - row->c0);
1778 2180
… …
1780 { 2182 {
1781 maptex tex = self->tex [cell->tile [z]]; 2183 maptex tex = self->tex [cell->tile [z]];
1782 int a0 = 255 - tex.a; 2184 int a0 = 255 - tex.a;
1783 int a1 = tex.a; 2185 int a1 = tex.a;
1784 2186
1785 r = (r * a0 + tex.r * a1) / 255; 2187 r = div255 (r * a0 + tex.r * a1);
1786 g = (g * a0 + tex.g * a1) / 255; 2188 g = div255 (g * a0 + tex.g * a1);
1787 b = (b * a0 + tex.b * a1) / 255; 2189 b = div255 (b * a0 + tex.b * a1);
1788 a = (a * a0 + tex.a * a1) / 255; 2190 a = div255 (a * a0 + tex.a * a1);
1789 } 2191 }
1790 } 2192 }
1791 2193
1792 *map++ = (r ) 2194 *map++ = (r )
1793 | (g << 8) 2195 | (g << 8)
1794 | (b << 16) 2196 | (b << 16)
1795 | (a << 24); 2197 | (a << 24);
1796 } 2198 }
1797 } 2199 }
1798 2200
1799 RETVAL = map_sv; 2201 RETVAL = map_sv;
1800} 2202}
1801 OUTPUT: 2203 OUTPUT:
1802 RETVAL 2204 RETVAL
1803 2205
1804void 2206void
1805draw (DC::Map self, int mx, int my, int sw, int sh, int T) 2207draw (DC::Map self, int mx, int my, int sw, int sh, int Tw, int Th, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)
1806 CODE: 2208 CODE:
1807{ 2209{
1808 int x, y, z; 2210 int x, y, z;
1809 2211
1810 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1811 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1812 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k) 2212 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k), also, static!
1813 smooth_key skey; 2213 int pl_x, pl_y;
1814 2214 maptex pl_tex;
1815 rc_t *rc = rc_alloc (); 2215 rc_t rc;
2216 rc_t rc_ov;
1816 rc_key_t key; 2217 rc_key_t key;
1817 rc_array_t *arr; 2218 rc_t::array_t *arr;
1818 2219
2220 pl_tex.name = 0;
2221
1819 // thats current max. sorry. 2222 // that's current max. sorry.
1820 if (sw > 255) sw = 255; 2223 if (sw > 255) sw = 255;
1821 if (sh > 255) sh = 255; 2224 if (sh > 255) sh = 255;
1822
1823 // clear key, in case of extra padding
1824 memset (&skey, 0, sizeof (skey));
1825 2225
1826 memset (&key, 0, sizeof (key)); 2226 memset (&key, 0, sizeof (key));
1827 key.r = 255; 2227 key.r = 255;
1828 key.g = 255; 2228 key.g = 255;
1829 key.b = 255; 2229 key.b = 255;
1830 key.a = 255; 2230 key.a = 255;
1831 key.mode = GL_QUADS; 2231 key.mode = GL_QUADS;
1832 key.format = GL_T2F_V3F; 2232 key.format = GL_T2F_V3F;
1833 key.texname = -1;
1834 2233
1835 mx += self->x; 2234 mx += self->x;
1836 my += self->y; 2235 my += self->y;
1837 2236
1838 // first pass: determine smooth_max 2237 // first pass: determine smooth_max
1839 // rather ugly, if you ask me 2238 // rather ugly, if you ask me
1840 // could also be stored inside mapcell and updated on change 2239 // could also be stored inside mapcell and updated on change
1841 memset (smooth_max, 0, sizeof (smooth_max)); 2240 memset (smooth_max, 0, sizeof (smooth_max[0]) * (sh + 1));
1842 2241
1843 for (y = 0; y < sh; y++) 2242 for (y = 0; y < sh; y++)
1844 if (0 <= y + my && y + my < self->rows) 2243 if (0 <= y + my && y + my < self->rows)
1845 { 2244 {
1846 maprow *row = self->row + (y + my); 2245 maprow *row = self->row + (y + my);
… …
1861 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2260 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1862 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2261 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1863 2262
1864 for (z = 0; z <= 2; z++) 2263 for (z = 0; z <= 2; z++)
1865 { 2264 {
1866 memset (smooth_level, 0, sizeof (smooth_level)); 2265 std::bitset<256> smooth_level; // one bit for every possible smooth level
2266 smooth_key skey;
2267 smooth_hash smooth;
2268 key.texname = -1;
1867 2269
1868 for (y = 0; y < sh; y++) 2270 for (y = 0; y < sh; y++)
1869 if (0 <= y + my && y + my < self->rows) 2271 if (0 <= y + my && y + my < self->rows)
1870 { 2272 {
1871 maprow *row = self->row + (y + my); 2273 maprow *row = self->row + (y + my);
… …
1881 maptex tex = self->tex [tile]; 2283 maptex tex = self->tex [tile];
1882 int px, py; 2284 int px, py;
1883 2285
1884 if (key.texname != tex.name) 2286 if (key.texname != tex.name)
1885 { 2287 {
2288 self->tex [tile].unused = 0;
2289
1886 if (!tex.name) 2290 if (!tex.name)
1887 tex = self->tex [2]; /* missing, replace by noface */ 2291 tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
1888 2292
1889 key.texname = tex.name; 2293 key.texname = tex.name;
1890 arr = rc_array (rc, &key); 2294 arr = &rc.array (key);
1891 } 2295 }
1892 2296
1893 px = (x + 1) * T - tex.w; 2297 px = (x + 1) * Th - tex.w;
1894 py = (y + 1) * T - tex.h; 2298 py = (y + 1) * Tw - tex.h;
1895 2299
1896 rc_t2f_v3f (arr, 0 , 0 , px , py , 0); 2300 if (ecb_expect_false (cell->player == player) && ecb_expect_false (z == 2))
1897 rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
1898 rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
1899 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
1900
1901 if (cell->flags && z == 2)
1902 { 2301 {
1903 // overlays such as the speech bubble, probably more to come 2302 pl_x = px;
1904 if (cell->flags & 1) 2303 pl_y = py;
2304 pl_tex = tex;
1905 { 2305 continue;
1906 maptex tex = self->tex [1];
1907 int px = x * T + T * 2 / 32;
1908 int py = y * T - T * 6 / 32;
1909
1910 if (tex.name)
1911 {
1912 if (key.texname != tex.name)
1913 {
1914 key.texname = tex.name;
1915 arr = rc_array (rc, &key);
1916 }
1917
1918 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
1919 rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
1920 rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
1921 rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
1922 }
1923 }
1924 } 2306 }
2307
2308 arr->t2f_v3f (0 , 0 , px , py , 0);
2309 arr->t2f_v3f (0 , tex.t, px , py + tex.h, 0);
2310 arr->t2f_v3f (tex.s, tex.t, px + tex.w, py + tex.h, 0);
2311 arr->t2f_v3f (tex.s, 0 , px + tex.w, py , 0);
1925 2312
1926 // update smooth hash 2313 // update smooth hash
1927 if (tex.smoothtile) 2314 if (tex.smoothtile)
1928 { 2315 {
1929 skey.tile = tex.smoothtile; 2316 skey.tile = tex.smoothtile;
1930 skey.level = tex.smoothlevel; 2317 skey.level = tex.smoothlevel;
1931 2318
1932 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31); 2319 smooth_level[tex.smoothlevel] = 1;
1933 2320
1934 // add bits to current tile and all neighbours. skey.x|y is 2321 // add bits to current tile and all neighbours. skey.x|y is
1935 // shifted +1|+1 so we always stay positive. 2322 // shifted +1|+1 so we always stay positive.
1936 2323
1937 // bits is ___n cccc CCCC bbbb 2324 // bits is ___n cccc CCCC bbbb
… …
1945 2332
1946 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ·· 2333 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1947 // ·· ·· ·┏ ┓· 2334 // ·· ·· ·┏ ┓·
1948 2335
1949 // full tile 2336 // full tile
1950 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000); 2337 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x1000);
1951 2338
1952 // borders 2339 // borders
1953 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091); 2340 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0091);
1954 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032); 2341 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0032);
1955 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064); 2342 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0064);
1956 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8); 2343 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, skey, 0x00c8);
1957 2344
1958 // corners 2345 // corners
1959 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100); 2346 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0100);
1960 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200); 2347 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0200);
1961 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400); 2348 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, skey, 0x0400);
1962 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800); 2349 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, skey, 0x0800);
2350 }
2351 }
2352
2353 if (ecb_expect_false (z == 2) && ecb_expect_false (cell->flags))
2354 {
2355 // overlays such as the speech bubble, probably more to come
2356 if (cell->flags & 1)
2357 {
2358 rc_key_t key_ov = key;
2359 maptex tex = self->tex[TEXID_SPEECH];
2360 int px = x * Tw + Tw * 2 / 32;
2361 int py = y * Th - Th * 6 / 32;
2362
2363 key_ov.texname = tex.name;
2364 rc_t::array_t &arr = rc_ov.array (key_ov);
2365
2366 arr.t2f_v3f (0 , 0 , px , py , 0);
2367 arr.t2f_v3f (0 , tex.t, px , py + Th, 0);
2368 arr.t2f_v3f (tex.s, tex.t, px + Tw, py + Th, 0);
2369 arr.t2f_v3f (tex.s, 0 , px + Tw, py , 0);
1963 } 2370 }
1964 } 2371 }
1965 } 2372 }
1966 } 2373 }
1967 2374
1968 rc_draw (rc); 2375 rc.draw ();
1969 rc_clear (rc); 2376 rc.clear ();
1970 2377
1971 // go through all smoothlevels, lowest to highest, then draw. 2378 // go through all smoothlevels, lowest to highest, then draw.
1972 // this is basically counting sort 2379 // this is basically counting sort
1973 { 2380 {
1974 int w, b; 2381 int w, b;
1975 2382
1976 glEnable (GL_TEXTURE_2D); 2383 glEnable (GL_TEXTURE_2D);
1977 glBegin (GL_QUADS); 2384 glBegin (GL_QUADS);
1978 for (w = 0; w < 256 / 32; ++w) 2385 for (int level = 0; level < smooth_level.size (); ++level)
2386 if (smooth_level[level])
2387 for (auto &&it = smooth.begin (); it != smooth.end (); ++it)
1979 { 2388 {
1980 uint32_t smask = smooth_level [w]; 2389 smooth_key &skey = it->first;
1981 if (smask) 2390 IV bits = it->second;
1982 for (b = 0; b < 32; ++b) 2391
1983 if (smask & (((uint32_t)1) << b)) 2392 if (!(bits & 0x1000)
2393 && skey.level == level
2394 && level > smooth_max [skey.x][skey.y])
1984 { 2395 {
1985 int level = (w << 5) | b; 2396 maptex tex = self->tex [skey.tile];
2397 int px = (((int)skey.x) - 1) * Tw;
2398 int py = (((int)skey.y) - 1) * Th;
2399 int border = bits & 15;
2400 int corner = (bits >> 8) & ~(bits >> 4) & 15;
2401 float dx = tex.s * .0625f; // 16 images/row
2402 float dy = tex.t * .5f ; // 2 images/column
2403
1986 HE *he; 2404 if (tex.name)
1987
1988 hv_iterinit (smooth);
1989 while ((he = hv_iternext (smooth)))
1990 { 2405 {
1991 smooth_key *skey = (smooth_key *)HeKEY (he); 2406 // this time avoiding texture state changes
1992 IV bits = SvIVX (HeVAL (he)); 2407 // save gobs of state changes.
1993 2408 if (key.texname != tex.name)
1994 if (!(bits & 0x1000)
1995 && skey->level == level
1996 && level > smooth_max [skey->x][skey->y])
1997 { 2409 {
1998 maptex tex = self->tex [skey->tile]; 2410 self->tex [skey.tile].unused = 0;
1999 int px = (((int)skey->x) - 1) * T;
2000 int py = (((int)skey->y) - 1) * T;
2001 int border = bits & 15;
2002 int corner = (bits >> 8) & ~(bits >> 4) & 15;
2003 float dx = tex.s * .0625f; // 16 images/row
2004 float dy = tex.t * .5f ; // 2 images/column
2005 2411
2006 if (tex.name)
2007 {
2008 // this time avoiding texture state changes
2009 // save gobs of state changes.
2010 if (key.texname != tex.name)
2011 {
2012 glEnd (); 2412 glEnd ();
2013 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name); 2413 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
2014 glBegin (GL_QUADS); 2414 glBegin (GL_QUADS);
2015 } 2415 }
2016 2416
2017 if (border) 2417 if (border)
2018 { 2418 {
2019 float ox = border * dx; 2419 float ox = border * dx;
2020 2420
2021 glTexCoord2f (ox , 0.f ); glVertex2i (px , py ); 2421 glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
2022 glTexCoord2f (ox , dy ); glVertex2i (px , py + T); 2422 glTexCoord2f (ox , dy ); glVertex2i (px , py + Th);
2023 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T); 2423 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py + Th);
2024 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py ); 2424 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + Tw, py );
2025 } 2425 }
2026 2426
2027 if (corner) 2427 if (corner)
2028 { 2428 {
2029 float ox = corner * dx; 2429 float ox = corner * dx;
2030 2430
2031 glTexCoord2f (ox , dy ); glVertex2i (px , py ); 2431 glTexCoord2f (ox , dy ); glVertex2i (px , py );
2032 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T); 2432 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + Th);
2033 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T); 2433 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + Tw, py + Th);
2034 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py ); 2434 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py );
2035 }
2036 }
2037 } 2435 }
2038 } 2436 }
2039 } 2437 }
2040 } 2438 }
2041 2439
2042 glEnd (); 2440 glEnd ();
2043 glDisable (GL_TEXTURE_2D); 2441 glDisable (GL_TEXTURE_2D);
2044 key.texname = -1; 2442 key.texname = -1;
2045 } 2443 }
2046
2047 hv_clear (smooth);
2048 } 2444 }
2049 2445
2446 if (pl_tex.name)
2447 {
2448 maptex tex = pl_tex;
2449 int px = pl_x + sdx;
2450 int py = pl_y + sdy;
2451
2452 key.texname = tex.name;
2453 rc_t::array_t &arr = rc.array (key);
2454
2455 arr.t2f_v3f (0 , 0 , px , py , 0);
2456 arr.t2f_v3f (0 , tex.t, px , py + tex.h, 0);
2457 arr.t2f_v3f (tex.s, tex.t, px + tex.w, py + tex.h, 0);
2458 arr.t2f_v3f (tex.s, 0 , px + tex.w, py , 0);
2459
2460 rc.draw ();
2461 }
2462
2463 rc_ov.draw ();
2464 rc_ov.clear ();
2465
2050 glDisable (GL_BLEND); 2466 glDisable (GL_BLEND);
2051 rc_free (rc);
2052 2467
2053 // top layer: overlays such as the health bar 2468 // top layer: overlays such as the health bar
2054 for (y = 0; y < sh; y++) 2469 for (y = 0; y < sh; y++)
2055 if (0 <= y + my && y + my < self->rows) 2470 if (0 <= y + my && y + my < self->rows)
2056 { 2471 {
… …
2059 for (x = 0; x < sw; x++) 2474 for (x = 0; x < sw; x++)
2060 if (row->c0 <= x + mx && x + mx < row->c1) 2475 if (row->c0 <= x + mx && x + mx < row->c1)
2061 { 2476 {
2062 mapcell *cell = row->col + (x + mx - row->c0); 2477 mapcell *cell = row->col + (x + mx - row->c0);
2063 2478
2064 int px = x * T; 2479 int px = x * Tw;
2065 int py = y * T; 2480 int py = y * Th;
2481
2482 if (ecb_expect_false (cell->player == player))
2483 {
2484 px += sdx;
2485 py += sdy;
2486 }
2066 2487
2067 if (cell->stat_hp) 2488 if (cell->stat_hp)
2068 { 2489 {
2069 int width = cell->stat_width * T; 2490 int width = cell->stat_width * Tw;
2070 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width; 2491 int thick = (sh * Th / 32 + 27) / 28 + 1 + cell->stat_width;
2071 2492
2072 glColor3ub (0, 0, 0); 2493 glColor3ub (0, 0, 0);
2073 glRectf (px + 1, py - thick - 2, 2494 glRectf (px + 1, py - thick - 2,
2074 px + width - 1, py); 2495 px + width - 1, py);
2075 2496
… …
2081 } 2502 }
2082 } 2503 }
2083} 2504}
2084 2505
2085void 2506void
2086draw_magicmap (DC::Map self, int dx, int dy, int w, int h, unsigned char *data) 2507draw_magicmap (DC::Map self, int w, int h, unsigned char *data)
2087 CODE: 2508 CODE:
2088{ 2509{
2089 static float color[16][3] = { 2510 static float color[16][3] = {
2090 { 0.00F, 0.00F, 0.00F }, 2511 { 0.00f, 0.00f, 0.00f },
2091 { 1.00F, 1.00F, 1.00F }, 2512 { 1.00f, 1.00f, 1.00f },
2092 { 0.00F, 0.00F, 0.55F }, 2513 { 0.00f, 0.00f, 0.55f },
2093 { 1.00F, 0.00F, 0.00F }, 2514 { 1.00f, 0.00f, 0.00f },
2094 2515
2095 { 1.00F, 0.54F, 0.00F }, 2516 { 1.00f, 0.54f, 0.00f },
2096 { 0.11F, 0.56F, 1.00F }, 2517 { 0.11f, 0.56f, 1.00f },
2097 { 0.93F, 0.46F, 0.00F }, 2518 { 0.93f, 0.46f, 0.00f },
2098 { 0.18F, 0.54F, 0.34F }, 2519 { 0.18f, 0.54f, 0.34f },
2099 2520
2100 { 0.56F, 0.73F, 0.56F }, 2521 { 0.56f, 0.73f, 0.56f },
2101 { 0.80F, 0.80F, 0.80F }, 2522 { 0.80f, 0.80f, 0.80f },
2102 { 0.55F, 0.41F, 0.13F }, 2523 { 0.55f, 0.41f, 0.13f },
2103 { 0.99F, 0.77F, 0.26F }, 2524 { 0.99f, 0.77f, 0.26f },
2104 2525
2105 { 0.74F, 0.65F, 0.41F }, 2526 { 0.74f, 0.65f, 0.41f },
2106 2527
2107 { 0.00F, 1.00F, 1.00F }, 2528 { 0.00f, 1.00f, 1.00f },
2108 { 1.00F, 0.00F, 1.00F }, 2529 { 1.00f, 0.00f, 1.00f },
2109 { 1.00F, 1.00F, 0.00F }, 2530 { 1.00f, 1.00f, 0.00f },
2110 }; 2531 };
2111 2532
2112 int x, y; 2533 int x, y;
2113 2534
2114 glEnable (GL_TEXTURE_2D); 2535 glEnable (GL_TEXTURE_2D);
2536 /* GL_REPLACE would be correct, as we don't need to modulate alpha,
2537 * but the nvidia driver (185.18.14) mishandles alpha textures
2538 * and takes the colour from god knows where instead of using
2539 * Cp. MODULATE results in the same colour, but slightly different
2540 * alpha, but atcually gives us the correct colour with nvidia.
2541 */
2115 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2542 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
2116 glEnable (GL_BLEND); 2543 glEnable (GL_BLEND);
2117 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2544 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2118 glBegin (GL_QUADS); 2545 glBegin (GL_QUADS);
2119 2546
2120 for (y = 0; y < h; y++) 2547 for (y = 0; y < h; y++)
… …
2124 2551
2125 if (m) 2552 if (m)
2126 { 2553 {
2127 float *c = color [m & 15]; 2554 float *c = color [m & 15];
2128 2555
2129 float tx1 = m & 0x40 ? 0.5 : 0.; 2556 float tx1 = m & 0x40 ? 0.5f : 0.f;
2130 float tx2 = tx1 + 0.5; 2557 float tx2 = tx1 + 0.5f;
2131 2558
2132 glColor4f (c[0], c[1], c[2], 0.75); 2559 glColor4f (c[0], c[1], c[2], 1);
2133 glTexCoord2f (tx1, 0.); glVertex2i (x , y ); 2560 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2134 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1); 2561 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2135 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1); 2562 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2136 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y ); 2563 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2137 } 2564 }
… …
2145void 2572void
2146fow_texture (DC::Map self, int mx, int my, int sw, int sh) 2573fow_texture (DC::Map self, int mx, int my, int sw, int sh)
2147 PPCODE: 2574 PPCODE:
2148{ 2575{
2149 int x, y; 2576 int x, y;
2150 int sw1 = sw + 2; 2577 int sw1 = sw + 2;
2151 int sh1 = sh + 2; 2578 int sh1 = sh + 2;
2152 int sh3 = sh * 3; 2579 int sh3 = sh * 3;
2153 int sw34 = (sw * 3 + 3) & ~3; 2580 int sw3 = sw * 3;
2581 SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3));
2582 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2154 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1); 2583 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2155 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3)); 2584 memset (darkness1, 0, sw1*sh1);
2156 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2157 2585
2158 SvPOK_only (darkness3_sv); 2586 SvPOK_only (darkness3_sv);
2159 SvCUR_set (darkness3_sv, sw34 * sh3); 2587 SvCUR_set (darkness3_sv, sw3 * sh3);
2160 2588
2161 mx += self->x - 1; 2589 mx += self->x - 1;
2162 my += self->y - 1; 2590 my += self->y - 1;
2163
2164 memset (darkness1, 255, sw1 * sh1);
2165 2591
2166 for (y = 0; y < sh1; y++) 2592 for (y = 0; y < sh1; y++)
2167 if (0 <= y + my && y + my < self->rows) 2593 if (0 <= y + my && y + my < self->rows)
2168 { 2594 {
2169 maprow *row = self->row + (y + my); 2595 maprow *row = self->row + (y + my);
… …
2172 if (row->c0 <= x + mx && x + mx < row->c1) 2598 if (row->c0 <= x + mx && x + mx < row->c1)
2173 { 2599 {
2174 mapcell *cell = row->col + (x + mx - row->c0); 2600 mapcell *cell = row->col + (x + mx - row->c0);
2175 2601
2176 darkness1 [y * sw1 + x] = cell->darkness 2602 darkness1 [y * sw1 + x] = cell->darkness
2177 ? 255 - (cell->darkness - 1) 2603 ? DARKNESS_ADJUST (255 - (cell->darkness - 1))
2178 : 255 - FOW_DARKNESS; 2604 : DARKNESS_ADJUST (255 - FOW_DARKNESS);
2179 } 2605 }
2180 } 2606 }
2181 2607
2182 for (y = 0; y < sh; ++y) 2608 for (y = 0; y < sh; ++y)
2183 for (x = 0; x < sw; ++x) 2609 for (x = 0; x < sw; ++x)
… …
2202 2628
2203 uint8_t r13 = (d13 + d23 + d12) / 3; 2629 uint8_t r13 = (d13 + d23 + d12) / 3;
2204 uint8_t r23 = d23; 2630 uint8_t r23 = d23;
2205 uint8_t r33 = (d23 + d33 + d32) / 3; 2631 uint8_t r33 = (d23 + d33 + d32) / 3;
2206 2632
2207 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11); 2633 darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2208 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21); 2634 darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2209 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31); 2635 darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2210 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12); 2636 darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2211 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22); 2637 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 1)] = MAX (d22, r22); /* this MUST be == d22 */
2212 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32); 2638 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2213 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13); 2639 darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2214 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23); 2640 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2215 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33); 2641 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2216 } 2642 }
2217 2643
2218 free (darkness1); 2644 free (darkness1);
2219 2645
2220 EXTEND (SP, 3); 2646 EXTEND (SP, 3);
2221 PUSHs (sv_2mortal (newSViv (sw34))); 2647 PUSHs (sv_2mortal (newSViv (sw3)));
2222 PUSHs (sv_2mortal (newSViv (sh3))); 2648 PUSHs (sv_2mortal (newSViv (sh3)));
2223 PUSHs (darkness3_sv); 2649 PUSHs (darkness3_sv);
2224} 2650}
2225 2651
2226SV * 2652SV *
… …
2289 else 2715 else
2290 *data++ = 0; 2716 *data++ = 0;
2291 } 2717 }
2292 } 2718 }
2293 2719
2720 /* if size is w*h + 5 then no data has been found */
2721 if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5)
2722 {
2294 SvPOK_only (data_sv); 2723 SvPOK_only (data_sv);
2295 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv)); 2724 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2725 }
2726
2296 RETVAL = data_sv; 2727 RETVAL = data_sv;
2297} 2728}
2298 OUTPUT: 2729 OUTPUT:
2299 RETVAL 2730 RETVAL
2300 2731
2301void 2732void
2302set_rect (DC::Map self, int x0, int y0, uint8_t *data) 2733set_rect (DC::Map self, int x0, int y0, SV *data_sv)
2303 PPCODE: 2734 PPCODE:
2304{ 2735{
2305 int x, y, z; 2736 int x, y, z;
2306 int w, h; 2737 int w, h;
2307 int x1, y1; 2738 int x1, y1;
2739 STRLEN len;
2740 uint8_t *data, *end;
2741
2742 len = SvLEN (data_sv);
2743 SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more
2744 data = (uint8_t *)SvPVbyte_nolen (data_sv);
2745 end = data + len + 8;
2746
2747 if (len < 5)
2748 XSRETURN_EMPTY;
2308 2749
2309 if (*data++ != 0) 2750 if (*data++ != 0)
2310 XSRETURN_EMPTY; /* version mismatch */ 2751 XSRETURN_EMPTY; /* version mismatch */
2311 2752
2312 w = *data++ << 8; w |= *data++; 2753 w = *data++ << 8; w |= *data++;
… …
2327 { 2768 {
2328 maprow *row = map_get_row (self, y); 2769 maprow *row = map_get_row (self, y);
2329 2770
2330 for (x = x0; x < x1; x++) 2771 for (x = x0; x < x1; x++)
2331 { 2772 {
2773 uint8_t flags;
2774
2775 if (data + 7 >= end)
2776 XSRETURN_EMPTY;
2777
2332 uint8_t flags = *data++; 2778 flags = *data++;
2333 2779
2334 if (flags) 2780 if (flags)
2335 { 2781 {
2336 mapcell *cell = row_get_cell (row, x); 2782 mapcell *cell = row_get_cell (row, x);
2337 tileid tile[3] = { 0, 0, 0 }; 2783 tileid tile[3] = { 0, 0, 0 };
… …
2340 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; } 2786 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
2341 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; } 2787 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
2342 2788
2343 if (cell->darkness == 0) 2789 if (cell->darkness == 0)
2344 { 2790 {
2345 cell->darkness = 0; 2791 /*cell->darkness = 0;*/
2792 EXTEND (SP, 3);
2346 2793
2347 for (z = 0; z <= 2; z++) 2794 for (z = 0; z <= 2; z++)
2348 { 2795 {
2349 tileid t = tile [z]; 2796 tileid t = tile [z];
2350 2797
2351 if (t >= self->texs || (t && !self->tex [t].name)) 2798 if (t >= self->texs || (t && !self->tex [t].name))
2352 { 2799 {
2353 XPUSHs (sv_2mortal (newSViv (t))); 2800 PUSHs (sv_2mortal (newSViv (t)));
2354 need_texid (self, t); 2801 need_texid (self, t);
2355 } 2802 }
2356 2803
2357 cell->tile [z] = t; 2804 cell->tile [z] = t;
2358 } 2805 }
… …
2363} 2810}
2364 2811
2365MODULE = Deliantra::Client PACKAGE = DC::RW 2812MODULE = Deliantra::Client PACKAGE = DC::RW
2366 2813
2367DC::RW 2814DC::RW
2368new (SV *class, SV *data_sv) 2815new (SV *klass, SV *data_sv)
2369 CODE: 2816 CODE:
2370{ 2817{
2371 STRLEN datalen; 2818 STRLEN datalen;
2372 char *data = SvPVbyte (data_sv, datalen); 2819 char *data = SvPVbyte (data_sv, datalen);
2373 2820
… …
2375} 2822}
2376 OUTPUT: 2823 OUTPUT:
2377 RETVAL 2824 RETVAL
2378 2825
2379DC::RW 2826DC::RW
2380new_from_file (SV *class, const char *path, const char *mode = "rb") 2827new_from_file (SV *klass, const char *path, const char *mode = "rb")
2381 CODE: 2828 CODE:
2382 RETVAL = SDL_RWFromFile (path, mode); 2829 RETVAL = SDL_RWFromFile (path, mode);
2383 OUTPUT: 2830 OUTPUT:
2384 RETVAL 2831 RETVAL
2385 2832
… …
2403 if (RETVAL < 0) 2850 if (RETVAL < 0)
2404 { 2851 {
2405 RETVAL = Mix_GroupOldest (-1); 2852 RETVAL = Mix_GroupOldest (-1);
2406 2853
2407 if (RETVAL < 0) 2854 if (RETVAL < 0)
2855 {
2856 // happens sometimes, maybe it just stopped playing(?)
2857 RETVAL = Mix_GroupAvailable (-1);
2858
2859 if (RETVAL < 0)
2408 XSRETURN_UNDEF; 2860 XSRETURN_UNDEF;
2409 2861 }
2862 else
2410 Mix_HaltChannel (RETVAL); 2863 Mix_HaltChannel (RETVAL);
2411 } 2864 }
2412 2865
2413 Mix_UnregisterAllEffects (RETVAL); 2866 Mix_UnregisterAllEffects (RETVAL);
2414 Mix_Volume (RETVAL, 128); 2867 Mix_Volume (RETVAL, 128);
2415} 2868}
… …
2462void 2915void
2463set_position_r (DC::Channel self, int dx, int dy, int maxdistance) 2916set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2464 CODE: 2917 CODE:
2465{ 2918{
2466 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance)); 2919 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2467 int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI); 2920 int angle = atan2f (dx, -dy) * 180.f / (float)M_PI + 360.f;
2468 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255)); 2921 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2469} 2922}
2470 2923
2471void 2924void
2472set_reverse_stereo (DC::Channel self, int flip) 2925set_reverse_stereo (DC::Channel self, int flip)
… …
2475 2928
2476MODULE = Deliantra::Client PACKAGE = DC::MixChunk 2929MODULE = Deliantra::Client PACKAGE = DC::MixChunk
2477 2930
2478PROTOTYPES: DISABLE 2931PROTOTYPES: DISABLE
2479 2932
2933void
2934decoders ()
2935 PPCODE:
2936#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
2937 int i, num = Mix_GetNumChunkDecoders ();
2938 EXTEND (SP, num);
2939 for (i = 0; i < num; ++i)
2940 PUSHs (sv_2mortal (newSVpv (Mix_GetChunkDecoder (i), 0)));
2941#else
2942 XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
2943#endif
2944
2480DC::MixChunk 2945DC::MixChunk
2481new (SV *class, DC::RW rwops) 2946new (SV *klass, DC::RW rwops)
2482 CODE: 2947 CODE:
2483 RETVAL = Mix_LoadWAV_RW (rwops, 1); 2948 RETVAL = Mix_LoadWAV_RW (rwops, 1);
2484 OUTPUT: 2949 OUTPUT:
2485 RETVAL 2950 RETVAL
2486 2951
… …
2516 OUTPUT: 2981 OUTPUT:
2517 RETVAL 2982 RETVAL
2518 2983
2519MODULE = Deliantra::Client PACKAGE = DC::MixMusic 2984MODULE = Deliantra::Client PACKAGE = DC::MixMusic
2520 2985
2986void
2987decoders ()
2988 PPCODE:
2989#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
2990 int i, num = Mix_GetNumMusicDecoders ();
2991 EXTEND (SP, num);
2992 for (i = 0; i < num; ++i)
2993 PUSHs (sv_2mortal (newSVpv (Mix_GetMusicDecoder (i), 0)));
2994#else
2995 XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
2996#endif
2997
2521int 2998int
2522volume (int volume = -1) 2999volume (int volume = -1)
2523 PROTOTYPE: ;$ 3000 PROTOTYPE: ;$
2524 CODE: 3001 CODE:
2525 if (items > 0) 3002 if (items > 0)
… …
2536void 3013void
2537halt () 3014halt ()
2538 CODE: 3015 CODE:
2539 Mix_HaltMusic (); 3016 Mix_HaltMusic ();
2540 3017
3018int
3019playing ()
3020 CODE:
3021 RETVAL = Mix_PlayingMusic ();
3022 OUTPUT:
3023 RETVAL
3024
2541DC::MixMusic 3025DC::MixMusic
2542new (SV *class, DC::RW rwops) 3026new (SV *klass, DC::RW rwops)
2543 CODE: 3027 CODE:
2544 RETVAL = Mix_LoadMUS_RW (rwops); 3028 RETVAL = Mix_LoadMUS_RW (rwops);
2545 OUTPUT: 3029 OUTPUT:
2546 RETVAL 3030 RETVAL
2547 3031
… …
2575 } *civ, const_iv[] = { 3059 } *civ, const_iv[] = {
2576# define const_iv(name) { # name, (IV)name } 3060# define const_iv(name) { # name, (IV)name }
2577 const_iv (GL_VENDOR), 3061 const_iv (GL_VENDOR),
2578 const_iv (GL_VERSION), 3062 const_iv (GL_VERSION),
2579 const_iv (GL_EXTENSIONS), 3063 const_iv (GL_EXTENSIONS),
3064 const_iv (GL_MAX_TEXTURE_UNITS),
2580 const_iv (GL_COLOR_MATERIAL), 3065 const_iv (GL_COLOR_MATERIAL),
2581 const_iv (GL_SMOOTH), 3066 const_iv (GL_SMOOTH),
2582 const_iv (GL_FLAT), 3067 const_iv (GL_FLAT),
2583 const_iv (GL_DITHER), 3068 const_iv (GL_DITHER),
2584 const_iv (GL_BLEND), 3069 const_iv (GL_BLEND),
… …
2596 const_iv (GL_ZERO), 3081 const_iv (GL_ZERO),
2597 const_iv (GL_SRC_ALPHA), 3082 const_iv (GL_SRC_ALPHA),
2598 const_iv (GL_DST_ALPHA), 3083 const_iv (GL_DST_ALPHA),
2599 const_iv (GL_ONE_MINUS_SRC_ALPHA), 3084 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2600 const_iv (GL_ONE_MINUS_DST_ALPHA), 3085 const_iv (GL_ONE_MINUS_DST_ALPHA),
3086 const_iv (GL_SRC_COLOR),
3087 const_iv (GL_DST_COLOR),
3088 const_iv (GL_ONE_MINUS_SRC_COLOR),
3089 const_iv (GL_ONE_MINUS_DST_COLOR),
2601 const_iv (GL_SRC_ALPHA_SATURATE), 3090 const_iv (GL_SRC_ALPHA_SATURATE),
2602 const_iv (GL_RGB), 3091 const_iv (GL_RGB),
2603 const_iv (GL_RGBA), 3092 const_iv (GL_RGBA),
2604 const_iv (GL_RGBA4), 3093 const_iv (GL_RGBA4),
2605 const_iv (GL_RGBA8), 3094 const_iv (GL_RGBA8),
… …
2673 const_iv (GL_NICEST), 3162 const_iv (GL_NICEST),
2674 const_iv (GL_V2F), 3163 const_iv (GL_V2F),
2675 const_iv (GL_V3F), 3164 const_iv (GL_V3F),
2676 const_iv (GL_T2F_V3F), 3165 const_iv (GL_T2F_V3F),
2677 const_iv (GL_T2F_N3F_V3F), 3166 const_iv (GL_T2F_N3F_V3F),
3167 const_iv (GL_FUNC_ADD),
3168 const_iv (GL_FUNC_SUBTRACT),
3169 const_iv (GL_FUNC_REVERSE_SUBTRACT),
2678# undef const_iv 3170# undef const_iv
2679 }; 3171 };
2680 3172
2681 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 3173 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
2682 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 3174 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
2683 3175
2684 texture_av = newAV (); 3176 texture_av = newAV ();
2685 AvREAL_off (texture_av); 3177 AvREAL_off (texture_av);
2686} 3178}
2687 3179
… …
2689disable_GL_EXT_blend_func_separate () 3181disable_GL_EXT_blend_func_separate ()
2690 CODE: 3182 CODE:
2691 gl.BlendFuncSeparate = 0; 3183 gl.BlendFuncSeparate = 0;
2692 gl.BlendFuncSeparateEXT = 0; 3184 gl.BlendFuncSeparateEXT = 0;
2693 3185
2694char * 3186void
3187apple_nvidia_bug (int enable)
3188
3189const char *
2695gl_vendor () 3190gl_vendor ()
2696 CODE: 3191 CODE:
2697 RETVAL = (char *)glGetString (GL_VENDOR); 3192 RETVAL = (const char *)glGetString (GL_VENDOR);
2698 OUTPUT: 3193 OUTPUT:
2699 RETVAL 3194 RETVAL
2700 3195
2701char * 3196const char *
2702gl_version () 3197gl_version ()
2703 CODE: 3198 CODE:
2704 RETVAL = (char *)glGetString (GL_VERSION); 3199 RETVAL = (const char *)glGetString (GL_VERSION);
2705 OUTPUT: 3200 OUTPUT:
2706 RETVAL 3201 RETVAL
2707 3202
2708char * 3203const char *
2709gl_extensions () 3204gl_extensions ()
2710 CODE: 3205 CODE:
2711 RETVAL = (char *)glGetString (GL_EXTENSIONS); 3206 RETVAL = (const char *)glGetString (GL_EXTENSIONS);
2712 OUTPUT: 3207 OUTPUT:
2713 RETVAL 3208 RETVAL
2714 3209
2715const char *glGetString (GLenum pname) 3210const char *glGetString (GLenum pname)
3211 CODE:
3212 RETVAL = (const char *)glGetString (pname);
3213 OUTPUT:
3214 RETVAL
2716 3215
2717GLint glGetInteger (GLenum pname) 3216GLint glGetInteger (GLenum pname)
2718 CODE: 3217 CODE:
2719 glGetIntegerv (pname, &RETVAL); 3218 glGetIntegerv (pname, &RETVAL);
2720 OUTPUT: 3219 OUTPUT:
… …
2728 3227
2729int glGetError () 3228int glGetError ()
2730 3229
2731void glFinish () 3230void glFinish ()
2732 3231
3232void glFlush ()
3233
2733void glClear (int mask) 3234void glClear (int mask)
2734 3235
2735void glClearColor (float r, float g, float b, float a = 1.0) 3236void glClearColor (float r, float g, float b, float a = 1.0)
2736 PROTOTYPE: @ 3237 PROTOTYPE: @
2737 3238
… …
2746void glBlendFunc (int sfactor, int dfactor) 3247void glBlendFunc (int sfactor, int dfactor)
2747 3248
2748void glBlendFuncSeparate (int sa, int da, int saa, int daa) 3249void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2749 CODE: 3250 CODE:
2750 gl_BlendFuncSeparate (sa, da, saa, daa); 3251 gl_BlendFuncSeparate (sa, da, saa, daa);
3252
3253# void glBlendEquation (int se)
2751 3254
2752void glDepthMask (int flag) 3255void glDepthMask (int flag)
2753 3256
2754void glLogicOp (int opcode) 3257void glLogicOp (int opcode)
2755 3258
… …
2790void glRotate (float angle, float x, float y, float z) 3293void glRotate (float angle, float x, float y, float z)
2791 CODE: 3294 CODE:
2792 glRotatef (angle, x, y, z); 3295 glRotatef (angle, x, y, z);
2793 3296
2794void glColor (float r, float g, float b, float a = 1.0) 3297void glColor (float r, float g, float b, float a = 1.0)
3298 PROTOTYPE: @
2795 ALIAS: 3299 ALIAS:
2796 glColor_premultiply = 1 3300 glColor_premultiply = 1
2797 CODE: 3301 CODE:
2798 if (ix) 3302 if (ix)
2799 { 3303 {
… …
2905 3409
2906void glEndList () 3410void glEndList ()
2907 3411
2908void glCallList (int list) 3412void glCallList (int list)
2909 3413
3414void c_init ()
3415 CODE:
3416 glPixelStorei (GL_PACK_ALIGNMENT , 1);
3417 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
3418
2910MODULE = Deliantra::Client PACKAGE = DC::UI::Base 3419MODULE = Deliantra::Client PACKAGE = DC::UI::Base
2911 3420
2912PROTOTYPES: DISABLE 3421PROTOTYPES: DISABLE
2913 3422
2914void 3423void
2915find_widget (SV *self, NV x, NV y) 3424find_widget (SV *self, NV x, NV y)
2916 PPCODE: 3425 PPCODE:
2917{ 3426{
2918 if (within_widget (self, x, y)) 3427 if (within_widget (self, x, y))
2919 XPUSHs (self); 3428 XPUSHs (self);
2920} 3429}
2921 3430
2922BOOT: 3431BOOT:
2923{ 3432{
… …
2931 3440
2932void 3441void
2933draw (SV *self) 3442draw (SV *self)
2934 CODE: 3443 CODE:
2935{ 3444{
2936 HV *hv; 3445 HV *hv;
2937 SV **svp; 3446 SV **svp;
2938 NV x, y, w, h; 3447 NV x, y, w, h;
2939 SV *draw_x_sv = GvSV (draw_x_gv); 3448 SV *draw_x_sv = GvSV (draw_x_gv);
2940 SV *draw_y_sv = GvSV (draw_y_gv); 3449 SV *draw_y_sv = GvSV (draw_y_gv);
2941 SV *draw_w_sv = GvSV (draw_w_gv); 3450 SV *draw_w_sv = GvSV (draw_w_gv);
2942 SV *draw_h_sv = GvSV (draw_h_gv); 3451 SV *draw_h_sv = GvSV (draw_h_gv);

Diff Legend

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