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

Diff Legend

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