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.255 by root, Sun Jan 6 18:25:59 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
1010int
1011SDL_GetModState ()
1012
1013int
1014SDL_WaitEvent ()
1015 C_ARGS: 0
1016
775void 1017void
1018SDL_PumpEvents ()
1019
1020void
776poll_events () 1021peep_events ()
777 PPCODE: 1022 PPCODE:
778{ 1023{
779 SDL_Event ev; 1024 SDL_Event ev;
780 1025
781 SDL_PumpEvents (); 1026 SDL_PumpEvents ();
… …
788 { 1033 {
789 case SDL_KEYDOWN: 1034 case SDL_KEYDOWN:
790 case SDL_KEYUP: 1035 case SDL_KEYUP:
791 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 1036 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
792 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 1037 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
793 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);
794 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 */
795 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 1040 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
796 break; 1041 break;
797 1042
798 case SDL_ACTIVEEVENT: 1043 case SDL_ACTIVEEVENT:
799 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 1044 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
… …
817 x = ev.motion.x; 1062 x = ev.motion.x;
818 y = ev.motion.y; 1063 y = ev.motion.y;
819 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)); 1064 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
820 } 1065 }
821 1066
822 hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0); 1067 hv_store (hv, "mod", 3, newSViv (mod_munge (SDL_GetModState ())), 0);
823 hv_store (hv, "state", 5, newSViv (state), 0); 1068 hv_store (hv, "state", 5, newSViv (state), 0);
824 hv_store (hv, "x", 1, newSViv (x), 0); 1069 hv_store (hv, "x", 1, newSViv (x), 0);
825 hv_store (hv, "y", 1, newSViv (y), 0); 1070 hv_store (hv, "y", 1, newSViv (y), 0);
826 hv_store (hv, "xrel", 4, newSViv (xrel), 0); 1071 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
827 hv_store (hv, "yrel", 4, newSViv (yrel), 0); 1072 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
… …
847 1092
848 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))));
849 } 1094 }
850} 1095}
851 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
852int 1110int
853Mix_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)
854 POSTCALL: 1112 POSTCALL:
855 Mix_HookMusicFinished (music_finished); 1113 Mix_HookMusicFinished (music_finished);
856 Mix_ChannelFinished (channel_finished); 1114 Mix_ChannelFinished (channel_finished);
857 1115
858void 1116void
859Mix_QuerySpec () 1117Mix_QuerySpec ()
… …
912 } 1170 }
913 } 1171 }
914#endif 1172#endif
915} 1173}
916 1174
917void 1175int
918add_font (char *file) 1176add_font (char *file)
919 CODE: 1177 CODE:
920 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)
921 1188
922void 1189void
923load_image_inline (SV *image_) 1190load_image_inline (SV *image_)
924 ALIAS: 1191 ALIAS:
925 load_image_file = 1 1192 load_image_file = 1
… …
971 1238
972 SDL_LockSurface (surface2); 1239 SDL_LockSurface (surface2);
973 EXTEND (SP, 6); 1240 EXTEND (SP, 6);
974 PUSHs (sv_2mortal (newSViv (surface2->w))); 1241 PUSHs (sv_2mortal (newSViv (surface2->w)));
975 PUSHs (sv_2mortal (newSViv (surface2->h))); 1242 PUSHs (sv_2mortal (newSViv (surface2->h)));
976 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 1243 PUSHs (sv_2mortal (newSVpvn ((const char *)surface2->pixels, surface2->h * surface2->pitch)));
977 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)));
978 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 1245 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
979 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE))); 1246 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
980 SDL_UnlockSurface (surface2); 1247 SDL_UnlockSurface (surface2);
981 1248
… …
1041#if DEBUG 1308#if DEBUG
1042 VALGRIND_DO_LEAK_CHECK; 1309 VALGRIND_DO_LEAK_CHECK;
1043#endif 1310#endif
1044} 1311}
1045 1312
1313int
1314SvREFCNT (SV *sv)
1315 CODE:
1316 RETVAL = SvREFCNT (sv);
1317 OUTPUT:
1318 RETVAL
1319
1046MODULE = Deliantra::Client PACKAGE = DC::Font 1320MODULE = Deliantra::Client PACKAGE = DC::Font
1047 1321
1048PROTOTYPES: DISABLE 1322PROTOTYPES: DISABLE
1049 1323
1050DC::Font 1324DC::Font
1051new_from_file (SV *class, char *path, int id = 0) 1325new_from_file (SV *klass, char *path, int id = 0)
1052 CODE: 1326 CODE:
1053{ 1327{
1054 int count; 1328 int count;
1055 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count); 1329 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
1056 RETVAL = pango_fc_font_description_from_pattern (pattern, 0); 1330 RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
… …
1085 PROTOTYPE: 1359 PROTOTYPE:
1086 CODE: 1360 CODE:
1087 tc_restore (); 1361 tc_restore ();
1088 1362
1089DC::Layout 1363DC::Layout
1090new (SV *class) 1364new (SV *klass)
1091 CODE: 1365 CODE:
1092 New (0, RETVAL, 1, struct cf_layout); 1366 RETVAL = new cf_layout;
1093 1367
1094 RETVAL->pl = pango_layout_new (opengl_context); 1368 RETVAL->pl = pango_layout_new (opengl_context);
1095 RETVAL->r = 1.; 1369 RETVAL->r = 1.;
1096 RETVAL->g = 1.; 1370 RETVAL->g = 1.;
1097 RETVAL->b = 1.; 1371 RETVAL->b = 1.;
1098 RETVAL->a = 1.; 1372 RETVAL->a = 1.;
1099 RETVAL->base_height = MIN_FONT_HEIGHT; 1373 RETVAL->base_height = MIN_FONT_HEIGHT;
1100 RETVAL->font = 0; 1374 RETVAL->font = 0;
1101 RETVAL->rc = rc_alloc ();
1102 1375
1103 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR); 1376 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
1104 layout_update_font (RETVAL); 1377 layout_update_font (RETVAL);
1105 OUTPUT: 1378 OUTPUT:
1106 RETVAL 1379 RETVAL
1107 1380
1108void 1381void
1109DESTROY (DC::Layout self) 1382DESTROY (DC::Layout self)
1110 CODE: 1383 CODE:
1111 g_object_unref (self->pl); 1384 g_object_unref (self->pl);
1112 rc_free (self->rc);
1113 Safefree (self); 1385 delete self;
1114 1386
1115void 1387void
1116set_text (DC::Layout self, SV *text_) 1388set_text (DC::Layout self, SV *text_)
1117 CODE: 1389 CODE:
1118{ 1390{
… …
1244 1516
1245void 1517void
1246set_height (DC::Layout self, int base_height) 1518set_height (DC::Layout self, int base_height)
1247 CODE: 1519 CODE:
1248 if (self->base_height != base_height) 1520 if (self->base_height != base_height)
1249 { 1521 {
1250 self->base_height = base_height; 1522 self->base_height = base_height;
1251 layout_update_font (self); 1523 layout_update_font (self);
1252 } 1524 }
1253 1525
1254void 1526void
… …
1372} 1644}
1373 1645
1374void 1646void
1375render (DC::Layout self, float x, float y, int flags = 0) 1647render (DC::Layout self, float x, float y, int flags = 0)
1376 CODE: 1648 CODE:
1377 rc_clear (self->rc); 1649 self->rc.clear ();
1378 pango_opengl_render_layout_subpixel ( 1650 pango_opengl_render_layout_subpixel (
1379 self->pl, 1651 self->pl,
1380 self->rc, 1652 &self->rc,
1381 x * PANGO_SCALE, y * PANGO_SCALE, 1653 x * PANGO_SCALE, y * PANGO_SCALE,
1382 self->r, self->g, self->b, self->a, 1654 self->r, self->g, self->b, self->a,
1383 flags 1655 flags
1384 ); 1656 );
1385 // we assume that context_change actually clears/frees stuff 1657 // we assume that context_change actually clears/frees stuff
… …
1396 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, 1668 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1397 GL_ONE , GL_ONE_MINUS_SRC_ALPHA); 1669 GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1398 glEnable (GL_ALPHA_TEST); 1670 glEnable (GL_ALPHA_TEST);
1399 glAlphaFunc (GL_GREATER, 7.f / 255.f); 1671 glAlphaFunc (GL_GREATER, 7.f / 255.f);
1400 1672
1401 rc_draw (self->rc); 1673 self->rc.draw ();
1402 1674
1403 glDisable (GL_ALPHA_TEST); 1675 glDisable (GL_ALPHA_TEST);
1404 glDisable (GL_BLEND); 1676 glDisable (GL_BLEND);
1405 glDisable (GL_TEXTURE_2D); 1677 glDisable (GL_TEXTURE_2D);
1406} 1678}
… …
1481 glDisable (GL_ALPHA_TEST); 1753 glDisable (GL_ALPHA_TEST);
1482 glDisable (GL_BLEND); 1754 glDisable (GL_BLEND);
1483 } 1755 }
1484} 1756}
1485 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
1486IV 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)
1487 CODE: 1880 CODE:
1488{ 1881{
1489 GLint width; 1882 GLint width;
1490 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);
… …
1497MODULE = Deliantra::Client PACKAGE = DC::Map 1890MODULE = Deliantra::Client PACKAGE = DC::Map
1498 1891
1499PROTOTYPES: DISABLE 1892PROTOTYPES: DISABLE
1500 1893
1501DC::Map 1894DC::Map
1502new (SV *class) 1895new (SV *klass)
1503 CODE: 1896 CODE:
1504 New (0, RETVAL, 1, struct map); 1897 New (0, RETVAL, 1, mapgrid);
1505 RETVAL->x = 0; 1898 RETVAL->x = 0;
1506 RETVAL->y = 0; 1899 RETVAL->y = 0;
1507 RETVAL->w = 0; 1900 RETVAL->w = 0;
1508 RETVAL->h = 0; 1901 RETVAL->h = 0;
1509 RETVAL->ox = 0; 1902 RETVAL->ox = 0;
… …
1546 1939
1547void 1940void
1548set_smooth (DC::Map self, int face, int smooth, int level) 1941set_smooth (DC::Map self, int face, int smooth, int level)
1549 CODE: 1942 CODE:
1550{ 1943{
1551 tileid texid; 1944 tileid texid;
1552 maptex *tex; 1945 maptex *tex;
1553 1946
1554 if (face < 0 || face >= self->faces) 1947 if (face < 0 || face >= self->faces)
1555 return; 1948 return;
1556 1949
1557 if (smooth < 0 || smooth >= self->faces) 1950 if (smooth < 0 || smooth >= self->faces)
1558 return; 1951 return;
1559 1952
1560 texid = self->face2tile [face]; 1953 texid = self->face2tile [face];
1561 1954
1562 if (!texid) 1955 if (!texid)
1563 return; 1956 return;
1564 1957
1565 tex = self->tex + texid; 1958 tex = self->tex + texid;
… …
1594 //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);
1595 // use uglier nearest interpolation because linear suffers 1988 // use uglier nearest interpolation because linear suffers
1596 // from transparent color bleeding and ugly wrapping effects. 1989 // from transparent color bleeding and ugly wrapping effects.
1597 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1990 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1598} 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 }
1599 2012
1600int 2013int
1601ox (DC::Map self) 2014ox (DC::Map self)
1602 ALIAS: 2015 ALIAS:
1603 oy = 1 2016 oy = 1
… …
1635 self->ox += dx; self->x += dx; 2048 self->ox += dx; self->x += dx;
1636 self->oy += dy; self->y += dy; 2049 self->oy += dy; self->y += dy;
1637 2050
1638 while (self->y < 0) 2051 while (self->y < 0)
1639 { 2052 {
1640 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y); 2053 prepend (self->row, self->rows, MAP_EXTEND_Y);
1641 2054
1642 self->rows += MAP_EXTEND_Y; 2055 self->rows += MAP_EXTEND_Y;
1643 self->y += MAP_EXTEND_Y; 2056 self->y += MAP_EXTEND_Y;
1644 } 2057 }
1645} 2058}
1646 2059
1647SV * 2060SV *
1648map1a_update (DC::Map self, SV *data_, int extmap) 2061map1a_update (DC::Map self, SV *data_)
1649 CODE: 2062 CODE:
1650{ 2063{
1651 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 2064 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1652 uint8_t *data_end = (uint8_t *)SvEND (data_); 2065 uint8_t *data_end = (uint8_t *)SvEND (data_);
1653 mapcell *cell; 2066 mapcell *cell;
… …
1674 2087
1675 //TODO: don't trust server data to be in-range(!) 2088 //TODO: don't trust server data to be in-range(!)
1676 2089
1677 if (flags & 8) 2090 if (flags & 8)
1678 { 2091 {
2092 uint8_t ext, cmd;
2093
1679 if (extmap) 2094 do
1680 { 2095 {
1681 uint8_t ext, cmd; 2096 ext = *data++;
2097 cmd = ext & 0x7f;
1682 2098
1683 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
1684 { 2102 {
1685 ext = *data++;
1686 cmd = ext & 0x3f;
1687
1688 if (cmd < 4)
1689 cell->darkness = 255 - ext * 64 + 1;
1690 else if (cmd == 5) // health
1691 {
1692 cell->stat_width = 1; 2103 cell->stat_width = 1;
1693 cell->stat_hp = *data++; 2104 cell->stat_hp = *data++;
1694 }
1695 else if (cmd == 6) // monster width
1696 cell->stat_width = *data++ + 1;
1697 else if (cmd == 0x47)
1698 {
1699 if (*data == 4)
1700 ; // decode player count
1701
1702 data += *data + 1;
1703 }
1704 else if (cmd == 8) // cell flags
1705 cell->flags = *data++;
1706 else if (ext & 0x40) // unknown, multibyte => skip
1707 data += *data + 1;
1708 else
1709 data++;
1710 } 2105 }
1711 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++;
1712 } 2123 }
1713 else 2124 while (ext & 0x80);
1714 cell->darkness = *data++ + 1;
1715 } 2125 }
1716 2126
1717 for (z = 0; z <= 2; ++z) 2127 for (z = 0; z <= 2; ++z)
1718 if (flags & (4 >> z)) 2128 if (flags & (4 >> z))
1719 { 2129 {
… …
1722 cell->tile [z] = self->face2tile [face]; 2132 cell->tile [z] = self->face2tile [face];
1723 2133
1724 if (cell->tile [z]) 2134 if (cell->tile [z])
1725 { 2135 {
1726 maptex *tex = self->tex + cell->tile [z]; 2136 maptex *tex = self->tex + cell->tile [z];
2137 tex->unused = 0;
1727 if (!tex->name) 2138 if (!tex->name)
1728 av_push (missing, newSViv (cell->tile [z])); 2139 av_push (missing, newSViv (cell->tile [z]));
1729 2140
1730 if (tex->smoothtile) 2141 if (tex->smoothtile)
1731 { 2142 {
1732 maptex *smooth = self->tex + tex->smoothtile; 2143 maptex *smooth = self->tex + tex->smoothtile;
2144 smooth->unused = 0;
1733 if (!smooth->name) 2145 if (!smooth->name)
1734 av_push (missing, newSViv (tex->smoothtile)); 2146 av_push (missing, newSViv (tex->smoothtile));
1735 } 2147 }
1736 } 2148 }
1737 } 2149 }
1738 } 2150 }
1739 else 2151 else
1740 cell->darkness = 0; 2152 CELL_CLEAR (cell);
1741 } 2153 }
1742} 2154}
1743 OUTPUT: 2155 OUTPUT:
1744 RETVAL 2156 RETVAL
1745 2157
… …
1765 ? self->row + y 2177 ? self->row + y
1766 : 0; 2178 : 0;
1767 2179
1768 for (x = x0; x < x1; x++) 2180 for (x = x0; x < x1; x++)
1769 { 2181 {
1770 int r = 32, g = 32, b = 32, a = 192; 2182 unsigned int r = 32, g = 32, b = 32, a = 192;
1771 2183
1772 if (row && row->c0 <= x && x < row->c1) 2184 if (row && row->c0 <= x && x < row->c1)
1773 { 2185 {
1774 mapcell *cell = row->col + (x - row->c0); 2186 mapcell *cell = row->col + (x - row->c0);
1775 2187
… …
1777 { 2189 {
1778 maptex tex = self->tex [cell->tile [z]]; 2190 maptex tex = self->tex [cell->tile [z]];
1779 int a0 = 255 - tex.a; 2191 int a0 = 255 - tex.a;
1780 int a1 = tex.a; 2192 int a1 = tex.a;
1781 2193
1782 r = (r * a0 + tex.r * a1) / 255; 2194 r = div255 (r * a0 + tex.r * a1);
1783 g = (g * a0 + tex.g * a1) / 255; 2195 g = div255 (g * a0 + tex.g * a1);
1784 b = (b * a0 + tex.b * a1) / 255; 2196 b = div255 (b * a0 + tex.b * a1);
1785 a = (a * a0 + tex.a * a1) / 255; 2197 a = div255 (a * a0 + tex.a * a1);
1786 } 2198 }
1787 } 2199 }
1788 2200
1789 *map++ = (r ) 2201 *map++ = (r )
1790 | (g << 8) 2202 | (g << 8)
1791 | (b << 16) 2203 | (b << 16)
1792 | (a << 24); 2204 | (a << 24);
1793 } 2205 }
1794 } 2206 }
1795 2207
1796 RETVAL = map_sv; 2208 RETVAL = map_sv;
1797} 2209}
1798 OUTPUT: 2210 OUTPUT:
1799 RETVAL 2211 RETVAL
1800 2212
1801void 2213void
1802draw (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)
1803 CODE: 2215 CODE:
1804{ 2216{
1805 int x, y, z; 2217 int x, y, z;
1806 2218
1807 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1808 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1809 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!
1810 smooth_key skey; 2220 int pl_x, pl_y;
1811 2221 maptex pl_tex;
1812 rc_t *rc = rc_alloc (); 2222 rc_t rc;
2223 rc_t rc_ov;
1813 rc_key_t key; 2224 rc_key_t key;
1814 rc_array_t *arr; 2225 rc_t::array_t *arr;
1815 2226
2227 pl_tex.name = 0;
2228
1816 // thats current max. sorry. 2229 // that's current max. sorry.
1817 if (sw > 255) sw = 255; 2230 if (sw > 255) sw = 255;
1818 if (sh > 255) sh = 255; 2231 if (sh > 255) sh = 255;
1819
1820 // clear key, in case of extra padding
1821 memset (&skey, 0, sizeof (skey));
1822 2232
1823 memset (&key, 0, sizeof (key)); 2233 memset (&key, 0, sizeof (key));
1824 key.r = 255; 2234 key.r = 255;
1825 key.g = 255; 2235 key.g = 255;
1826 key.b = 255; 2236 key.b = 255;
1827 key.a = 255; 2237 key.a = 255;
1828 key.mode = GL_QUADS; 2238 key.mode = GL_QUADS;
1829 key.format = GL_T2F_V3F; 2239 key.format = GL_T2F_V3F;
1830 key.texname = -1;
1831 2240
1832 mx += self->x; 2241 mx += self->x;
1833 my += self->y; 2242 my += self->y;
1834 2243
1835 // first pass: determine smooth_max 2244 // first pass: determine smooth_max
1836 // rather ugly, if you ask me 2245 // rather ugly, if you ask me
1837 // could also be stored inside mapcell and updated on change 2246 // could also be stored inside mapcell and updated on change
1838 memset (smooth_max, 0, sizeof (smooth_max)); 2247 memset (smooth_max, 0, sizeof (smooth_max[0]) * (sh + 1));
1839 2248
1840 for (y = 0; y < sh; y++) 2249 for (y = 0; y < sh; y++)
1841 if (0 <= y + my && y + my < self->rows) 2250 if (0 <= y + my && y + my < self->rows)
1842 { 2251 {
1843 maprow *row = self->row + (y + my); 2252 maprow *row = self->row + (y + my);
… …
1858 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2267 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1859 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2268 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1860 2269
1861 for (z = 0; z <= 2; z++) 2270 for (z = 0; z <= 2; z++)
1862 { 2271 {
1863 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;
1864 2276
1865 for (y = 0; y < sh; y++) 2277 for (y = 0; y < sh; y++)
1866 if (0 <= y + my && y + my < self->rows) 2278 if (0 <= y + my && y + my < self->rows)
1867 { 2279 {
1868 maprow *row = self->row + (y + my); 2280 maprow *row = self->row + (y + my);
… …
1878 maptex tex = self->tex [tile]; 2290 maptex tex = self->tex [tile];
1879 int px, py; 2291 int px, py;
1880 2292
1881 if (key.texname != tex.name) 2293 if (key.texname != tex.name)
1882 { 2294 {
2295 self->tex [tile].unused = 0;
2296
1883 if (!tex.name) 2297 if (!tex.name)
1884 tex = self->tex [2]; /* missing, replace by noface */ 2298 tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
1885 2299
1886 key.texname = tex.name; 2300 key.texname = tex.name;
1887 arr = rc_array (rc, &key); 2301 arr = &rc.array (key);
1888 } 2302 }
1889 2303
1890 px = (x + 1) * T - tex.w; 2304 px = (x + 1) * Th - tex.w;
1891 py = (y + 1) * T - tex.h; 2305 py = (y + 1) * Tw - tex.h;
1892 2306
1893 rc_t2f_v3f (arr, 0 , 0 , px , py , 0); 2307 if (ecb_expect_false (cell->player == player) && ecb_expect_false (z == 2))
1894 rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
1895 rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
1896 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
1897
1898 if (cell->flags && z == 2)
1899 { 2308 {
1900 // overlays such as the speech bubble, probably more to come 2309 pl_x = px;
1901 if (cell->flags & 1) 2310 pl_y = py;
2311 pl_tex = tex;
1902 { 2312 continue;
1903 maptex tex = self->tex [1];
1904 int px = x * T + T * 2 / 32;
1905 int py = y * T - T * 6 / 32;
1906
1907 if (tex.name)
1908 {
1909 if (key.texname != tex.name)
1910 {
1911 key.texname = tex.name;
1912 arr = rc_array (rc, &key);
1913 }
1914
1915 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
1916 rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
1917 rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
1918 rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
1919 }
1920 }
1921 } 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);
1922 2319
1923 // update smooth hash 2320 // update smooth hash
1924 if (tex.smoothtile) 2321 if (tex.smoothtile)
1925 { 2322 {
1926 skey.tile = tex.smoothtile; 2323 skey.tile = tex.smoothtile;
1927 skey.level = tex.smoothlevel; 2324 skey.level = tex.smoothlevel;
1928 2325
1929 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31); 2326 smooth_level[tex.smoothlevel] = 1;
1930 2327
1931 // 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
1932 // shifted +1|+1 so we always stay positive. 2329 // shifted +1|+1 so we always stay positive.
1933 2330
1934 // bits is ___n cccc CCCC bbbb 2331 // bits is ___n cccc CCCC bbbb
… …
1942 2339
1943 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ·· 2340 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1944 // ·· ·· ·┏ ┓· 2341 // ·· ·· ·┏ ┓·
1945 2342
1946 // full tile 2343 // full tile
1947 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);
1948 2345
1949 // borders 2346 // borders
1950 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);
1951 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);
1952 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);
1953 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);
1954 2351
1955 // corners 2352 // corners
1956 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);
1957 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);
1958 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);
1959 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);
1960 } 2377 }
1961 } 2378 }
1962 } 2379 }
1963 } 2380 }
1964 2381
1965 rc_draw (rc); 2382 rc.draw ();
1966 rc_clear (rc); 2383 rc.clear ();
1967 2384
1968 // go through all smoothlevels, lowest to highest, then draw. 2385 // go through all smoothlevels, lowest to highest, then draw.
1969 // this is basically counting sort 2386 // this is basically counting sort
1970 { 2387 {
1971 int w, b; 2388 int w, b;
1972 2389
1973 glEnable (GL_TEXTURE_2D); 2390 glEnable (GL_TEXTURE_2D);
1974 glBegin (GL_QUADS); 2391 glBegin (GL_QUADS);
1975 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)
1976 { 2395 {
1977 uint32_t smask = smooth_level [w]; 2396 smooth_key &skey = it->first;
1978 if (smask) 2397 IV bits = it->second;
1979 for (b = 0; b < 32; ++b) 2398
1980 if (smask & (((uint32_t)1) << b)) 2399 if (!(bits & 0x1000)
2400 && skey.level == level
2401 && level > smooth_max [skey.x][skey.y])
1981 { 2402 {
1982 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
1983 HE *he; 2411 if (tex.name)
1984
1985 hv_iterinit (smooth);
1986 while ((he = hv_iternext (smooth)))
1987 { 2412 {
1988 smooth_key *skey = (smooth_key *)HeKEY (he); 2413 // this time avoiding texture state changes
1989 IV bits = SvIVX (HeVAL (he)); 2414 // save gobs of state changes.
1990 2415 if (key.texname != tex.name)
1991 if (!(bits & 0x1000)
1992 && skey->level == level
1993 && level > smooth_max [skey->x][skey->y])
1994 { 2416 {
1995 maptex tex = self->tex [skey->tile]; 2417 self->tex [skey.tile].unused = 0;
1996 int px = (((int)skey->x) - 1) * T;
1997 int py = (((int)skey->y) - 1) * T;
1998 int border = bits & 15;
1999 int corner = (bits >> 8) & ~(bits >> 4) & 15;
2000 float dx = tex.s * .0625f; // 16 images/row
2001 float dy = tex.t * .5f ; // 2 images/column
2002 2418
2003 if (tex.name)
2004 {
2005 // this time avoiding texture state changes
2006 // save gobs of state changes.
2007 if (key.texname != tex.name)
2008 {
2009 glEnd (); 2419 glEnd ();
2010 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name); 2420 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
2011 glBegin (GL_QUADS); 2421 glBegin (GL_QUADS);
2012 } 2422 }
2013 2423
2014 if (border) 2424 if (border)
2015 { 2425 {
2016 float ox = border * dx; 2426 float ox = border * dx;
2017 2427
2018 glTexCoord2f (ox , 0.f ); glVertex2i (px , py ); 2428 glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
2019 glTexCoord2f (ox , dy ); glVertex2i (px , py + T); 2429 glTexCoord2f (ox , dy ); glVertex2i (px , py + Th);
2020 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T); 2430 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py + Th);
2021 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py ); 2431 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + Tw, py );
2022 } 2432 }
2023 2433
2024 if (corner) 2434 if (corner)
2025 { 2435 {
2026 float ox = corner * dx; 2436 float ox = corner * dx;
2027 2437
2028 glTexCoord2f (ox , dy ); glVertex2i (px , py ); 2438 glTexCoord2f (ox , dy ); glVertex2i (px , py );
2029 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T); 2439 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + Th);
2030 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T); 2440 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + Tw, py + Th);
2031 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py ); 2441 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py );
2032 }
2033 }
2034 } 2442 }
2035 } 2443 }
2036 } 2444 }
2037 } 2445 }
2038 2446
2039 glEnd (); 2447 glEnd ();
2040 glDisable (GL_TEXTURE_2D); 2448 glDisable (GL_TEXTURE_2D);
2041 key.texname = -1; 2449 key.texname = -1;
2042 } 2450 }
2043
2044 hv_clear (smooth);
2045 } 2451 }
2046 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
2047 glDisable (GL_BLEND); 2473 glDisable (GL_BLEND);
2048 rc_free (rc);
2049 2474
2050 // top layer: overlays such as the health bar 2475 // top layer: overlays such as the health bar
2051 for (y = 0; y < sh; y++) 2476 for (y = 0; y < sh; y++)
2052 if (0 <= y + my && y + my < self->rows) 2477 if (0 <= y + my && y + my < self->rows)
2053 { 2478 {
… …
2056 for (x = 0; x < sw; x++) 2481 for (x = 0; x < sw; x++)
2057 if (row->c0 <= x + mx && x + mx < row->c1) 2482 if (row->c0 <= x + mx && x + mx < row->c1)
2058 { 2483 {
2059 mapcell *cell = row->col + (x + mx - row->c0); 2484 mapcell *cell = row->col + (x + mx - row->c0);
2060 2485
2061 int px = x * T; 2486 int px = x * Tw;
2062 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 }
2063 2494
2064 if (cell->stat_hp) 2495 if (cell->stat_hp)
2065 { 2496 {
2066 int width = cell->stat_width * T; 2497 int width = cell->stat_width * Tw;
2067 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width; 2498 int thick = (sh * Th / 32 + 27) / 28 + 1 + cell->stat_width;
2068 2499
2069 glColor3ub (0, 0, 0); 2500 glColor3ub (0, 0, 0);
2070 glRectf (px + 1, py - thick - 2, 2501 glRectf (px + 1, py - thick - 2,
2071 px + width - 1, py); 2502 px + width - 1, py);
2072 2503
… …
2078 } 2509 }
2079 } 2510 }
2080} 2511}
2081 2512
2082void 2513void
2083draw_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)
2084 CODE: 2515 CODE:
2085{ 2516{
2086 static float color[16][3] = { 2517 static float color[16][3] = {
2087 { 0.00F, 0.00F, 0.00F }, 2518 { 0.00f, 0.00f, 0.00f },
2088 { 1.00F, 1.00F, 1.00F }, 2519 { 1.00f, 1.00f, 1.00f },
2089 { 0.00F, 0.00F, 0.55F }, 2520 { 0.00f, 0.00f, 0.55f },
2090 { 1.00F, 0.00F, 0.00F }, 2521 { 1.00f, 0.00f, 0.00f },
2091 2522
2092 { 1.00F, 0.54F, 0.00F }, 2523 { 1.00f, 0.54f, 0.00f },
2093 { 0.11F, 0.56F, 1.00F }, 2524 { 0.11f, 0.56f, 1.00f },
2094 { 0.93F, 0.46F, 0.00F }, 2525 { 0.93f, 0.46f, 0.00f },
2095 { 0.18F, 0.54F, 0.34F }, 2526 { 0.18f, 0.54f, 0.34f },
2096 2527
2097 { 0.56F, 0.73F, 0.56F }, 2528 { 0.56f, 0.73f, 0.56f },
2098 { 0.80F, 0.80F, 0.80F }, 2529 { 0.80f, 0.80f, 0.80f },
2099 { 0.55F, 0.41F, 0.13F }, 2530 { 0.55f, 0.41f, 0.13f },
2100 { 0.99F, 0.77F, 0.26F }, 2531 { 0.99f, 0.77f, 0.26f },
2101 2532
2102 { 0.74F, 0.65F, 0.41F }, 2533 { 0.74f, 0.65f, 0.41f },
2103 2534
2104 { 0.00F, 1.00F, 1.00F }, 2535 { 0.00f, 1.00f, 1.00f },
2105 { 1.00F, 0.00F, 1.00F }, 2536 { 1.00f, 0.00f, 1.00f },
2106 { 1.00F, 1.00F, 0.00F }, 2537 { 1.00f, 1.00f, 0.00f },
2107 }; 2538 };
2108 2539
2109 int x, y; 2540 int x, y;
2110 2541
2111 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 */
2112 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2549 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
2113 glEnable (GL_BLEND); 2550 glEnable (GL_BLEND);
2114 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2551 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2115 glBegin (GL_QUADS); 2552 glBegin (GL_QUADS);
2116 2553
2117 for (y = 0; y < h; y++) 2554 for (y = 0; y < h; y++)
… …
2121 2558
2122 if (m) 2559 if (m)
2123 { 2560 {
2124 float *c = color [m & 15]; 2561 float *c = color [m & 15];
2125 2562
2126 float tx1 = m & 0x40 ? 0.5 : 0.; 2563 float tx1 = m & 0x40 ? 0.5f : 0.f;
2127 float tx2 = tx1 + 0.5; 2564 float tx2 = tx1 + 0.5f;
2128 2565
2129 glColor4f (c[0], c[1], c[2], 0.75); 2566 glColor4f (c[0], c[1], c[2], 1);
2130 glTexCoord2f (tx1, 0.); glVertex2i (x , y ); 2567 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2131 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1); 2568 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2132 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1); 2569 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2133 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y ); 2570 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2134 } 2571 }
… …
2142void 2579void
2143fow_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)
2144 PPCODE: 2581 PPCODE:
2145{ 2582{
2146 int x, y; 2583 int x, y;
2147 int sw1 = sw + 2; 2584 int sw1 = sw + 2;
2148 int sh1 = sh + 2; 2585 int sh1 = sh + 2;
2149 int sh3 = sh * 3; 2586 int sh3 = sh * 3;
2150 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);
2151 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1); 2590 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2152 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3)); 2591 memset (darkness1, 0, sw1*sh1);
2153 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2154 2592
2155 SvPOK_only (darkness3_sv); 2593 SvPOK_only (darkness3_sv);
2156 SvCUR_set (darkness3_sv, sw34 * sh3); 2594 SvCUR_set (darkness3_sv, sw3 * sh3);
2157 2595
2158 mx += self->x - 1; 2596 mx += self->x - 1;
2159 my += self->y - 1; 2597 my += self->y - 1;
2160
2161 memset (darkness1, 255, sw1 * sh1);
2162 2598
2163 for (y = 0; y < sh1; y++) 2599 for (y = 0; y < sh1; y++)
2164 if (0 <= y + my && y + my < self->rows) 2600 if (0 <= y + my && y + my < self->rows)
2165 { 2601 {
2166 maprow *row = self->row + (y + my); 2602 maprow *row = self->row + (y + my);
… …
2169 if (row->c0 <= x + mx && x + mx < row->c1) 2605 if (row->c0 <= x + mx && x + mx < row->c1)
2170 { 2606 {
2171 mapcell *cell = row->col + (x + mx - row->c0); 2607 mapcell *cell = row->col + (x + mx - row->c0);
2172 2608
2173 darkness1 [y * sw1 + x] = cell->darkness 2609 darkness1 [y * sw1 + x] = cell->darkness
2174 ? 255 - (cell->darkness - 1) 2610 ? DARKNESS_ADJUST (255 - (cell->darkness - 1))
2175 : 255 - FOW_DARKNESS; 2611 : DARKNESS_ADJUST (255 - FOW_DARKNESS);
2176 } 2612 }
2177 } 2613 }
2178 2614
2179 for (y = 0; y < sh; ++y) 2615 for (y = 0; y < sh; ++y)
2180 for (x = 0; x < sw; ++x) 2616 for (x = 0; x < sw; ++x)
… …
2199 2635
2200 uint8_t r13 = (d13 + d23 + d12) / 3; 2636 uint8_t r13 = (d13 + d23 + d12) / 3;
2201 uint8_t r23 = d23; 2637 uint8_t r23 = d23;
2202 uint8_t r33 = (d23 + d33 + d32) / 3; 2638 uint8_t r33 = (d23 + d33 + d32) / 3;
2203 2639
2204 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11); 2640 darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2205 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21); 2641 darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2206 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31); 2642 darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2207 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12); 2643 darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2208 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 */
2209 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32); 2645 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2210 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13); 2646 darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2211 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23); 2647 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2212 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33); 2648 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2213 } 2649 }
2214 2650
2215 free (darkness1); 2651 free (darkness1);
2216 2652
2217 EXTEND (SP, 3); 2653 EXTEND (SP, 3);
2218 PUSHs (sv_2mortal (newSViv (sw34))); 2654 PUSHs (sv_2mortal (newSViv (sw3)));
2219 PUSHs (sv_2mortal (newSViv (sh3))); 2655 PUSHs (sv_2mortal (newSViv (sh3)));
2220 PUSHs (darkness3_sv); 2656 PUSHs (darkness3_sv);
2221} 2657}
2222 2658
2223SV * 2659SV *
… …
2286 else 2722 else
2287 *data++ = 0; 2723 *data++ = 0;
2288 } 2724 }
2289 } 2725 }
2290 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 {
2291 SvPOK_only (data_sv); 2730 SvPOK_only (data_sv);
2292 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv)); 2731 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2732 }
2733
2293 RETVAL = data_sv; 2734 RETVAL = data_sv;
2294} 2735}
2295 OUTPUT: 2736 OUTPUT:
2296 RETVAL 2737 RETVAL
2297 2738
2298void 2739void
2299set_rect (DC::Map self, int x0, int y0, uint8_t *data) 2740set_rect (DC::Map self, int x0, int y0, SV *data_sv)
2300 PPCODE: 2741 PPCODE:
2301{ 2742{
2302 int x, y, z; 2743 int x, y, z;
2303 int w, h; 2744 int w, h;
2304 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;
2305 2756
2306 if (*data++ != 0) 2757 if (*data++ != 0)
2307 XSRETURN_EMPTY; /* version mismatch */ 2758 XSRETURN_EMPTY; /* version mismatch */
2308 2759
2309 w = *data++ << 8; w |= *data++; 2760 w = *data++ << 8; w |= *data++;
… …
2324 { 2775 {
2325 maprow *row = map_get_row (self, y); 2776 maprow *row = map_get_row (self, y);
2326 2777
2327 for (x = x0; x < x1; x++) 2778 for (x = x0; x < x1; x++)
2328 { 2779 {
2780 uint8_t flags;
2781
2782 if (data + 7 >= end)
2783 XSRETURN_EMPTY;
2784
2329 uint8_t flags = *data++; 2785 flags = *data++;
2330 2786
2331 if (flags) 2787 if (flags)
2332 { 2788 {
2333 mapcell *cell = row_get_cell (row, x); 2789 mapcell *cell = row_get_cell (row, x);
2334 tileid tile[3] = { 0, 0, 0 }; 2790 tileid tile[3] = { 0, 0, 0 };
… …
2337 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; } 2793 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
2338 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; } 2794 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
2339 2795
2340 if (cell->darkness == 0) 2796 if (cell->darkness == 0)
2341 { 2797 {
2342 cell->darkness = 0; 2798 /*cell->darkness = 0;*/
2799 EXTEND (SP, 3);
2343 2800
2344 for (z = 0; z <= 2; z++) 2801 for (z = 0; z <= 2; z++)
2345 { 2802 {
2346 tileid t = tile [z]; 2803 tileid t = tile [z];
2347 2804
2348 if (t >= self->texs || (t && !self->tex [t].name)) 2805 if (t >= self->texs || (t && !self->tex [t].name))
2349 { 2806 {
2350 XPUSHs (sv_2mortal (newSViv (t))); 2807 PUSHs (sv_2mortal (newSViv (t)));
2351 need_texid (self, t); 2808 need_texid (self, t);
2352 } 2809 }
2353 2810
2354 cell->tile [z] = t; 2811 cell->tile [z] = t;
2355 } 2812 }
… …
2360} 2817}
2361 2818
2362MODULE = Deliantra::Client PACKAGE = DC::RW 2819MODULE = Deliantra::Client PACKAGE = DC::RW
2363 2820
2364DC::RW 2821DC::RW
2365new (SV *class, SV *data_sv) 2822new (SV *klass, SV *data_sv)
2366 CODE: 2823 CODE:
2367{ 2824{
2368 STRLEN datalen; 2825 STRLEN datalen;
2369 char *data = SvPVbyte (data_sv, datalen); 2826 char *data = SvPVbyte (data_sv, datalen);
2370 2827
… …
2372} 2829}
2373 OUTPUT: 2830 OUTPUT:
2374 RETVAL 2831 RETVAL
2375 2832
2376DC::RW 2833DC::RW
2377new_from_file (SV *class, const char *path, const char *mode = "rb") 2834new_from_file (SV *klass, const char *path, const char *mode = "rb")
2378 CODE: 2835 CODE:
2379 RETVAL = SDL_RWFromFile (path, mode); 2836 RETVAL = SDL_RWFromFile (path, mode);
2380 OUTPUT: 2837 OUTPUT:
2381 RETVAL 2838 RETVAL
2382 2839
… …
2400 if (RETVAL < 0) 2857 if (RETVAL < 0)
2401 { 2858 {
2402 RETVAL = Mix_GroupOldest (-1); 2859 RETVAL = Mix_GroupOldest (-1);
2403 2860
2404 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)
2405 XSRETURN_UNDEF; 2867 XSRETURN_UNDEF;
2406 2868 }
2869 else
2407 Mix_HaltChannel (RETVAL); 2870 Mix_HaltChannel (RETVAL);
2408 } 2871 }
2409 2872
2410 Mix_UnregisterAllEffects (RETVAL); 2873 Mix_UnregisterAllEffects (RETVAL);
2411 Mix_Volume (RETVAL, 128); 2874 Mix_Volume (RETVAL, 128);
2412} 2875}
… …
2459void 2922void
2460set_position_r (DC::Channel self, int dx, int dy, int maxdistance) 2923set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2461 CODE: 2924 CODE:
2462{ 2925{
2463 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));
2464 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;
2465 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255)); 2928 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2466} 2929}
2467 2930
2468void 2931void
2469set_reverse_stereo (DC::Channel self, int flip) 2932set_reverse_stereo (DC::Channel self, int flip)
… …
2472 2935
2473MODULE = Deliantra::Client PACKAGE = DC::MixChunk 2936MODULE = Deliantra::Client PACKAGE = DC::MixChunk
2474 2937
2475PROTOTYPES: DISABLE 2938PROTOTYPES: DISABLE
2476 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
2477DC::MixChunk 2952DC::MixChunk
2478new (SV *class, DC::RW rwops) 2953new (SV *klass, DC::RW rwops)
2479 CODE: 2954 CODE:
2480 RETVAL = Mix_LoadWAV_RW (rwops, 1); 2955 RETVAL = Mix_LoadWAV_RW (rwops, 1);
2481 OUTPUT: 2956 OUTPUT:
2482 RETVAL 2957 RETVAL
2483 2958
… …
2513 OUTPUT: 2988 OUTPUT:
2514 RETVAL 2989 RETVAL
2515 2990
2516MODULE = Deliantra::Client PACKAGE = DC::MixMusic 2991MODULE = Deliantra::Client PACKAGE = DC::MixMusic
2517 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
2518int 3005int
2519volume (int volume = -1) 3006volume (int volume = -1)
2520 PROTOTYPE: ;$ 3007 PROTOTYPE: ;$
2521 CODE: 3008 CODE:
2522 if (items > 0) 3009 if (items > 0)
… …
2533void 3020void
2534halt () 3021halt ()
2535 CODE: 3022 CODE:
2536 Mix_HaltMusic (); 3023 Mix_HaltMusic ();
2537 3024
3025int
3026playing ()
3027 CODE:
3028 RETVAL = Mix_PlayingMusic ();
3029 OUTPUT:
3030 RETVAL
3031
2538DC::MixMusic 3032DC::MixMusic
2539new (SV *class, DC::RW rwops) 3033new (SV *klass, DC::RW rwops)
2540 CODE: 3034 CODE:
2541 RETVAL = Mix_LoadMUS_RW (rwops); 3035 RETVAL = Mix_LoadMUS_RW (rwops);
2542 OUTPUT: 3036 OUTPUT:
2543 RETVAL 3037 RETVAL
2544 3038
… …
2572 } *civ, const_iv[] = { 3066 } *civ, const_iv[] = {
2573# define const_iv(name) { # name, (IV)name } 3067# define const_iv(name) { # name, (IV)name }
2574 const_iv (GL_VENDOR), 3068 const_iv (GL_VENDOR),
2575 const_iv (GL_VERSION), 3069 const_iv (GL_VERSION),
2576 const_iv (GL_EXTENSIONS), 3070 const_iv (GL_EXTENSIONS),
3071 const_iv (GL_MAX_TEXTURE_UNITS),
2577 const_iv (GL_COLOR_MATERIAL), 3072 const_iv (GL_COLOR_MATERIAL),
2578 const_iv (GL_SMOOTH), 3073 const_iv (GL_SMOOTH),
2579 const_iv (GL_FLAT), 3074 const_iv (GL_FLAT),
2580 const_iv (GL_DITHER), 3075 const_iv (GL_DITHER),
2581 const_iv (GL_BLEND), 3076 const_iv (GL_BLEND),
… …
2593 const_iv (GL_ZERO), 3088 const_iv (GL_ZERO),
2594 const_iv (GL_SRC_ALPHA), 3089 const_iv (GL_SRC_ALPHA),
2595 const_iv (GL_DST_ALPHA), 3090 const_iv (GL_DST_ALPHA),
2596 const_iv (GL_ONE_MINUS_SRC_ALPHA), 3091 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2597 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),
2598 const_iv (GL_SRC_ALPHA_SATURATE), 3097 const_iv (GL_SRC_ALPHA_SATURATE),
2599 const_iv (GL_RGB), 3098 const_iv (GL_RGB),
2600 const_iv (GL_RGBA), 3099 const_iv (GL_RGBA),
2601 const_iv (GL_RGBA4), 3100 const_iv (GL_RGBA4),
2602 const_iv (GL_RGBA8), 3101 const_iv (GL_RGBA8),
… …
2670 const_iv (GL_NICEST), 3169 const_iv (GL_NICEST),
2671 const_iv (GL_V2F), 3170 const_iv (GL_V2F),
2672 const_iv (GL_V3F), 3171 const_iv (GL_V3F),
2673 const_iv (GL_T2F_V3F), 3172 const_iv (GL_T2F_V3F),
2674 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),
2675# undef const_iv 3177# undef const_iv
2676 }; 3178 };
2677 3179
2678 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--)
2679 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 3181 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
2680 3182
2681 texture_av = newAV (); 3183 texture_av = newAV ();
2682 AvREAL_off (texture_av); 3184 AvREAL_off (texture_av);
2683} 3185}
2684 3186
… …
2686disable_GL_EXT_blend_func_separate () 3188disable_GL_EXT_blend_func_separate ()
2687 CODE: 3189 CODE:
2688 gl.BlendFuncSeparate = 0; 3190 gl.BlendFuncSeparate = 0;
2689 gl.BlendFuncSeparateEXT = 0; 3191 gl.BlendFuncSeparateEXT = 0;
2690 3192
2691char * 3193void
3194apple_nvidia_bug (int enable)
3195
3196const char *
2692gl_vendor () 3197gl_vendor ()
2693 CODE: 3198 CODE:
2694 RETVAL = (char *)glGetString (GL_VENDOR); 3199 RETVAL = (const char *)glGetString (GL_VENDOR);
2695 OUTPUT: 3200 OUTPUT:
2696 RETVAL 3201 RETVAL
2697 3202
2698char * 3203const char *
2699gl_version () 3204gl_version ()
2700 CODE: 3205 CODE:
2701 RETVAL = (char *)glGetString (GL_VERSION); 3206 RETVAL = (const char *)glGetString (GL_VERSION);
2702 OUTPUT: 3207 OUTPUT:
2703 RETVAL 3208 RETVAL
2704 3209
2705char * 3210const char *
2706gl_extensions () 3211gl_extensions ()
2707 CODE: 3212 CODE:
2708 RETVAL = (char *)glGetString (GL_EXTENSIONS); 3213 RETVAL = (const char *)glGetString (GL_EXTENSIONS);
2709 OUTPUT: 3214 OUTPUT:
2710 RETVAL 3215 RETVAL
2711 3216
2712const char *glGetString (GLenum pname) 3217const char *glGetString (GLenum pname)
3218 CODE:
3219 RETVAL = (const char *)glGetString (pname);
3220 OUTPUT:
3221 RETVAL
2713 3222
2714GLint glGetInteger (GLenum pname) 3223GLint glGetInteger (GLenum pname)
2715 CODE: 3224 CODE:
2716 glGetIntegerv (pname, &RETVAL); 3225 glGetIntegerv (pname, &RETVAL);
2717 OUTPUT: 3226 OUTPUT:
… …
2725 3234
2726int glGetError () 3235int glGetError ()
2727 3236
2728void glFinish () 3237void glFinish ()
2729 3238
3239void glFlush ()
3240
2730void glClear (int mask) 3241void glClear (int mask)
2731 3242
2732void glClearColor (float r, float g, float b, float a = 1.0) 3243void glClearColor (float r, float g, float b, float a = 1.0)
2733 PROTOTYPE: @ 3244 PROTOTYPE: @
2734 3245
… …
2743void glBlendFunc (int sfactor, int dfactor) 3254void glBlendFunc (int sfactor, int dfactor)
2744 3255
2745void glBlendFuncSeparate (int sa, int da, int saa, int daa) 3256void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2746 CODE: 3257 CODE:
2747 gl_BlendFuncSeparate (sa, da, saa, daa); 3258 gl_BlendFuncSeparate (sa, da, saa, daa);
3259
3260# void glBlendEquation (int se)
2748 3261
2749void glDepthMask (int flag) 3262void glDepthMask (int flag)
2750 3263
2751void glLogicOp (int opcode) 3264void glLogicOp (int opcode)
2752 3265
… …
2787void glRotate (float angle, float x, float y, float z) 3300void glRotate (float angle, float x, float y, float z)
2788 CODE: 3301 CODE:
2789 glRotatef (angle, x, y, z); 3302 glRotatef (angle, x, y, z);
2790 3303
2791void 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: @
2792 ALIAS: 3306 ALIAS:
2793 glColor_premultiply = 1 3307 glColor_premultiply = 1
2794 CODE: 3308 CODE:
2795 if (ix) 3309 if (ix)
2796 { 3310 {
… …
2902 3416
2903void glEndList () 3417void glEndList ()
2904 3418
2905void glCallList (int list) 3419void glCallList (int list)
2906 3420
3421void c_init ()
3422 CODE:
3423 glPixelStorei (GL_PACK_ALIGNMENT , 1);
3424 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
3425
2907MODULE = Deliantra::Client PACKAGE = DC::UI::Base 3426MODULE = Deliantra::Client PACKAGE = DC::UI::Base
2908 3427
2909PROTOTYPES: DISABLE 3428PROTOTYPES: DISABLE
2910 3429
2911void 3430void
2912find_widget (SV *self, NV x, NV y) 3431find_widget (SV *self, NV x, NV y)
2913 PPCODE: 3432 PPCODE:
2914{ 3433{
2915 if (within_widget (self, x, y)) 3434 if (within_widget (self, x, y))
2916 XPUSHs (self); 3435 XPUSHs (self);
2917} 3436}
2918 3437
2919BOOT: 3438BOOT:
2920{ 3439{
… …
2928 3447
2929void 3448void
2930draw (SV *self) 3449draw (SV *self)
2931 CODE: 3450 CODE:
2932{ 3451{
2933 HV *hv; 3452 HV *hv;
2934 SV **svp; 3453 SV **svp;
2935 NV x, y, w, h; 3454 NV x, y, w, h;
2936 SV *draw_x_sv = GvSV (draw_x_gv); 3455 SV *draw_x_sv = GvSV (draw_x_gv);
2937 SV *draw_y_sv = GvSV (draw_y_gv); 3456 SV *draw_y_sv = GvSV (draw_y_gv);
2938 SV *draw_w_sv = GvSV (draw_w_gv); 3457 SV *draw_w_sv = GvSV (draw_w_gv);
2939 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