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.264 by root, Fri Jul 18 22:32:54 2008 UTC vs.
Revision 1.305 by root, Sun May 2 21:22:20 2010 UTC

… …
19 19
20#ifdef _WIN32 20#ifdef _WIN32
21# undef pipe 21# undef pipe
22// microsoft vs. C 22// microsoft vs. C
23# define sqrtf(x) sqrt(x) 23# define sqrtf(x) sqrt(x)
24# define roundf(x) (int)(x)
25# define atan2f(x,y) atan2(x,y) 24# define atan2f(x,y) atan2(x,y)
26# define M_PI 3.14159265f 25# define M_PI 3.14159265f
27#endif 26#endif
28 27
29#include <assert.h> 28#include <assert.h>
… …
38#include <SDL_thread.h> 37#include <SDL_thread.h>
39#include <SDL_endian.h> 38#include <SDL_endian.h>
40#include <SDL_image.h> 39#include <SDL_image.h>
41#include <SDL_mixer.h> 40#include <SDL_mixer.h>
42#include <SDL_opengl.h> 41#include <SDL_opengl.h>
42
43/* work around os x broken headers */
44#ifdef __MACOSX__
45typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
46typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture);
47typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t);
48#endif
43 49
44#define PANGO_ENABLE_BACKEND 50#define PANGO_ENABLE_BACKEND
45#define G_DISABLE_CAST_CHECKS 51#define G_DISABLE_CAST_CHECKS
46 52
47#include <glib/gmacros.h> 53#include <glib/gmacros.h>
… …
76#define expect_false(expr) expect ((expr) != 0, 0) 82#define expect_false(expr) expect ((expr) != 0, 0)
77#define expect_true(expr) expect ((expr) != 0, 1) 83#define expect_true(expr) expect ((expr) != 0, 1)
78 84
79#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */ 85#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
80 86
87/* this is used as fow flag as well, so has to have a different value */
88/* then anything that is computed by incoming darkness */
81#define FOW_DARKNESS 32 89#define FOW_DARKNESS 50
90#define DARKNESS_ADJUST(n) (n)
82 91
83#define MAP_EXTEND_X 32 92#define MAP_EXTEND_X 32
84#define MAP_EXTEND_Y 512 93#define MAP_EXTEND_Y 512
85 94
86#define MIN_FONT_HEIGHT 10 95#define MIN_FONT_HEIGHT 10
87 96
88/* mask out modifiers we are not interested in */ 97/* mask out modifiers we are not interested in */
89#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META) 98#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)
99
100#define KMOD_LRAM 0x10000 // our extension
101
102#define TEXID_SPEECH 1
103#define TEXID_NOFACE 2
90 104
91static AV *texture_av; 105static AV *texture_av;
92 106
93static struct 107static struct
94{ 108{
… …
226 int w, h; 240 int w, h;
227 float s, t; 241 float s, t;
228 uint8_t r, g, b, a; 242 uint8_t r, g, b, a;
229 tileid smoothtile; 243 tileid smoothtile;
230 uint8_t smoothlevel; 244 uint8_t smoothlevel;
245 uint8_t unused; /* set to zero on use */
231} maptex; 246} maptex;
232 247
233typedef struct { 248typedef struct {
234 uint32_t player; 249 uint32_t player;
235 tileid tile[3]; 250 tileid tile[3];
… …
367 self->oy = 0; 382 self->oy = 0;
368 self->row = 0; 383 self->row = 0;
369 self->rows = 0; 384 self->rows = 0;
370} 385}
371 386
387#define CELL_CLEAR(cell) \
388 do { \
389 if ((cell)->player) \
390 (cell)->tile [2] = 0; \
391 (cell)->darkness = 0; \
392 (cell)->stat_hp = 0; \
393 (cell)->flags = 0; \
394 (cell)->player = 0; \
395 } while (0)
396
372static void 397static void
373map_blank (DC__Map self, int x0, int y0, int w, int h) 398map_blank (DC__Map self, int x0, int y0, int w, int h)
374{ 399{
375 int x, y; 400 int x, y;
376 maprow *row; 401 maprow *row;
… …
390 if (x >= row->c1) 415 if (x >= row->c1)
391 break; 416 break;
392 417
393 cell = row->col + x - row->c0; 418 cell = row->col + x - row->c0;
394 419
395 cell->darkness = 0; 420 CELL_CLEAR (cell);
396 cell->stat_hp = 0;
397 cell->flags = 0;
398 cell->player = 0;
399 } 421 }
400 } 422 }
401} 423}
402 424
403typedef struct { 425typedef struct {
… …
514 if (!svp || !SvTRUE (*svp)) 536 if (!svp || !SvTRUE (*svp))
515 return 0; 537 return 0;
516 538
517 return 1; 539 return 1;
518} 540}
541
542/******************************************************************************/
543
544/* process keyboard modifiers */
545static int
546mod_munge (int mod)
547{
548 mod &= MOD_MASK;
549
550 if (mod & (KMOD_META | KMOD_ALT))
551 mod |= KMOD_LRAM;
552
553 return mod;
554}
555
556static void
557deliantra_main ()
558{
559 char *argv[] = { 0 };
560 call_argv ("::main", G_DISCARD | G_VOID, argv);
561}
562
563#ifdef __MACOSX__
564 /* to due surprising braindamage on the side of SDL design, we
565 * do some mind-boggling hack here: SDL requires a custom main()
566 * on OS X, so... we provide one and call the original main(), which,
567 * due to share dlibrary magic, calls -lSDLmain's main, not perl's main,
568 * and which calls our main (== SDL_main) back.
569 */
570 extern C_LINKAGE int
571 main (int argc, char *argv[])
572 {
573 deliantra_main ();
574 }
575
576 #undef main
577
578 extern C_LINKAGE int main (int argc, char *argv[]);
579
580 static void
581 SDL_braino (void)
582 {
583 char *argv[] = { "deliantra client", 0 };
584 (main) (1, argv);
585 }
586#else
587 static void
588 SDL_braino (void)
589 {
590 deliantra_main ();
591 }
592#endif
519 593
520MODULE = Deliantra::Client PACKAGE = DC 594MODULE = Deliantra::Client PACKAGE = DC
521 595
522PROTOTYPES: ENABLE 596PROTOTYPES: ENABLE
523 597
… …
552 const_iv (SDL_USEREVENT), 626 const_iv (SDL_USEREVENT),
553 627
554 const_iv (SDL_APPINPUTFOCUS), 628 const_iv (SDL_APPINPUTFOCUS),
555 const_iv (SDL_APPMOUSEFOCUS), 629 const_iv (SDL_APPMOUSEFOCUS),
556 const_iv (SDL_APPACTIVE), 630 const_iv (SDL_APPACTIVE),
631
632
633 const_iv (SDLK_UNKNOWN),
634 const_iv (SDLK_FIRST),
635 const_iv (SDLK_BACKSPACE),
636 const_iv (SDLK_TAB),
637 const_iv (SDLK_CLEAR),
638 const_iv (SDLK_RETURN),
639 const_iv (SDLK_PAUSE),
640 const_iv (SDLK_ESCAPE),
641 const_iv (SDLK_SPACE),
642 const_iv (SDLK_EXCLAIM),
643 const_iv (SDLK_QUOTEDBL),
644 const_iv (SDLK_HASH),
645 const_iv (SDLK_DOLLAR),
646 const_iv (SDLK_AMPERSAND),
647 const_iv (SDLK_QUOTE),
648 const_iv (SDLK_LEFTPAREN),
649 const_iv (SDLK_RIGHTPAREN),
650 const_iv (SDLK_ASTERISK),
651 const_iv (SDLK_PLUS),
652 const_iv (SDLK_COMMA),
653 const_iv (SDLK_MINUS),
654 const_iv (SDLK_PERIOD),
655 const_iv (SDLK_SLASH),
656 const_iv (SDLK_0),
657 const_iv (SDLK_1),
658 const_iv (SDLK_2),
659 const_iv (SDLK_3),
660 const_iv (SDLK_4),
661 const_iv (SDLK_5),
662 const_iv (SDLK_6),
663 const_iv (SDLK_7),
664 const_iv (SDLK_8),
665 const_iv (SDLK_9),
666 const_iv (SDLK_COLON),
667 const_iv (SDLK_SEMICOLON),
668 const_iv (SDLK_LESS),
669 const_iv (SDLK_EQUALS),
670 const_iv (SDLK_GREATER),
671 const_iv (SDLK_QUESTION),
672 const_iv (SDLK_AT),
673
674 const_iv (SDLK_LEFTBRACKET),
675 const_iv (SDLK_BACKSLASH),
676 const_iv (SDLK_RIGHTBRACKET),
677 const_iv (SDLK_CARET),
678 const_iv (SDLK_UNDERSCORE),
679 const_iv (SDLK_BACKQUOTE),
680 const_iv (SDLK_DELETE),
557 681
558 const_iv (SDLK_FIRST), 682 const_iv (SDLK_FIRST),
559 const_iv (SDLK_LAST), 683 const_iv (SDLK_LAST),
560 const_iv (SDLK_KP0), 684 const_iv (SDLK_KP0),
561 const_iv (SDLK_KP1), 685 const_iv (SDLK_KP1),
… …
637 const_iv (KMOD_RMETA), 761 const_iv (KMOD_RMETA),
638 const_iv (KMOD_NUM), 762 const_iv (KMOD_NUM),
639 const_iv (KMOD_CAPS), 763 const_iv (KMOD_CAPS),
640 const_iv (KMOD_MODE), 764 const_iv (KMOD_MODE),
641 765
766 const_iv (KMOD_LRAM),
767
642 const_iv (MIX_DEFAULT_FORMAT), 768 const_iv (MIX_DEFAULT_FORMAT),
643 769
644 const_iv (SDL_INIT_TIMER), 770 const_iv (SDL_INIT_TIMER),
645 const_iv (SDL_INIT_AUDIO), 771 const_iv (SDL_INIT_AUDIO),
646 const_iv (SDL_INIT_VIDEO), 772 const_iv (SDL_INIT_VIDEO),
… …
664 const_iv (SDL_GL_ACCUM_ALPHA_SIZE), 790 const_iv (SDL_GL_ACCUM_ALPHA_SIZE),
665 const_iv (SDL_GL_STEREO), 791 const_iv (SDL_GL_STEREO),
666 const_iv (SDL_GL_MULTISAMPLEBUFFERS), 792 const_iv (SDL_GL_MULTISAMPLEBUFFERS),
667 const_iv (SDL_GL_MULTISAMPLESAMPLES), 793 const_iv (SDL_GL_MULTISAMPLESAMPLES),
668 const_iv (SDL_GL_ACCELERATED_VISUAL), 794 const_iv (SDL_GL_ACCELERATED_VISUAL),
669 const_iv (SDL_GL_SWAP_CONTROL) 795 const_iv (SDL_GL_SWAP_CONTROL),
796
797 const_iv (FOW_DARKNESS)
670# undef const_iv 798# undef const_iv
671 }; 799 };
672 800
673 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 801 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
674 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 802 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
… …
695NV ceil (NV x) 823NV ceil (NV x)
696 824
697IV minpot (UV n) 825IV minpot (UV n)
698 826
699IV popcount (UV n) 827IV popcount (UV n)
828
829NV distance (NV dx, NV dy)
830 CODE:
831 RETVAL = pow (dx * dx + dy * dy, 0.5);
832 OUTPUT:
833 RETVAL
700 834
701void 835void
702pango_init () 836pango_init ()
703 CODE: 837 CODE:
704{ 838{
… …
712#endif 846#endif
713} 847}
714 848
715char *SDL_GetError () 849char *SDL_GetError ()
716 850
851void SDL_braino ()
852
717int SDL_Init (U32 flags) 853int SDL_Init (U32 flags)
718 854
719int SDL_InitSubSystem (U32 flags) 855int SDL_InitSubSystem (U32 flags)
720 856
721void SDL_QuitSubSystem (U32 flags) 857void SDL_QuitSubSystem (U32 flags)
… …
756 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 892 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
757 893
758 if (m && m != (SDL_Rect **)-1) 894 if (m && m != (SDL_Rect **)-1)
759 while (*m) 895 while (*m)
760 { 896 {
897 if ((*m)->w >= 400 && (*m)->h >= 300)
898 {
761 AV *av = newAV (); 899 AV *av = newAV ();
762 av_push (av, newSViv ((*m)->w)); 900 av_push (av, newSViv ((*m)->w));
763 av_push (av, newSViv ((*m)->h)); 901 av_push (av, newSViv ((*m)->h));
764 av_push (av, newSViv (rgb)); 902 av_push (av, newSViv (rgb));
765 av_push (av, newSViv (alpha)); 903 av_push (av, newSViv (alpha));
766 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av))); 904 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
905 }
767 906
768 ++m; 907 ++m;
769 } 908 }
770} 909}
771 910
… …
791 930
792 SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra"); 931 SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
793#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name); 932#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
794#include "glfunc.h" 933#include "glfunc.h"
795#undef GL_FUNC 934#undef GL_FUNC
935
936 if (!gl.ActiveTexture ) gl.ActiveTexture = gl.ActiveTextureARB;
937 if (!gl.MultiTexCoord2f) gl.MultiTexCoord2f = gl.MultiTexCoord2fARB;
796 } 938 }
797} 939}
798 OUTPUT: 940 OUTPUT:
799 RETVAL 941 RETVAL
800 942
… …
826 { 968 {
827 case SDL_KEYDOWN: 969 case SDL_KEYDOWN:
828 case SDL_KEYUP: 970 case SDL_KEYUP:
829 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 971 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
830 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 972 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
831 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod & MOD_MASK), 0); 973 hv_store (hv, "mod", 3, newSViv (mod_munge (ev.key.keysym.mod)), 0);
832 hv_store (hv, "cmod", 4, newSViv (SDL_GetModState () & MOD_MASK), 0); /* current mode */ 974 hv_store (hv, "cmod", 4, newSViv (mod_munge (SDL_GetModState ())), 0); /* current mode */
833 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 975 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
834 break; 976 break;
835 977
836 case SDL_ACTIVEEVENT: 978 case SDL_ACTIVEEVENT:
837 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 979 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
… …
855 x = ev.motion.x; 997 x = ev.motion.x;
856 y = ev.motion.y; 998 y = ev.motion.y;
857 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)); 999 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
858 } 1000 }
859 1001
860 hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0); 1002 hv_store (hv, "mod", 3, newSViv (mod_munge (SDL_GetModState ())), 0);
861 hv_store (hv, "state", 5, newSViv (state), 0); 1003 hv_store (hv, "state", 5, newSViv (state), 0);
862 hv_store (hv, "x", 1, newSViv (x), 0); 1004 hv_store (hv, "x", 1, newSViv (x), 0);
863 hv_store (hv, "y", 1, newSViv (y), 0); 1005 hv_store (hv, "y", 1, newSViv (y), 0);
864 hv_store (hv, "xrel", 4, newSViv (xrel), 0); 1006 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
865 hv_store (hv, "yrel", 4, newSViv (yrel), 0); 1007 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
… …
885 1027
886 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1)))); 1028 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1))));
887 } 1029 }
888} 1030}
889 1031
1032char *
1033SDL_AudioDriverName ()
1034 CODE:
1035{
1036 char buf [256];
1037 if (!SDL_AudioDriverName (buf, sizeof (buf)))
1038 XSRETURN_UNDEF;
1039
1040 RETVAL = buf;
1041}
1042 OUTPUT:
1043 RETVAL
1044
890int 1045int
891Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096) 1046Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)
892 POSTCALL: 1047 POSTCALL:
893 Mix_HookMusicFinished (music_finished); 1048 Mix_HookMusicFinished (music_finished);
894 Mix_ChannelFinished (channel_finished); 1049 Mix_ChannelFinished (channel_finished);
… …
956add_font (char *file) 1111add_font (char *file)
957 CODE: 1112 CODE:
958 RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file); 1113 RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);
959 OUTPUT: 1114 OUTPUT:
960 RETVAL 1115 RETVAL
1116
1117void
1118IMG_Init (int flags = IMG_INIT_JPG | IMG_INIT_PNG)
961 1119
962void 1120void
963load_image_inline (SV *image_) 1121load_image_inline (SV *image_)
964 ALIAS: 1122 ALIAS:
965 load_image_file = 1 1123 load_image_file = 1
… …
1081#if DEBUG 1239#if DEBUG
1082 VALGRIND_DO_LEAK_CHECK; 1240 VALGRIND_DO_LEAK_CHECK;
1083#endif 1241#endif
1084} 1242}
1085 1243
1244int
1245SvREFCNT (SV *sv)
1246 CODE:
1247 RETVAL = SvREFCNT (sv);
1248 OUTPUT:
1249 RETVAL
1250
1086MODULE = Deliantra::Client PACKAGE = DC::Font 1251MODULE = Deliantra::Client PACKAGE = DC::Font
1087 1252
1088PROTOTYPES: DISABLE 1253PROTOTYPES: DISABLE
1089 1254
1090DC::Font 1255DC::Font
… …
1519 if (ix) 1684 if (ix)
1520 { 1685 {
1521 glDisable (GL_ALPHA_TEST); 1686 glDisable (GL_ALPHA_TEST);
1522 glDisable (GL_BLEND); 1687 glDisable (GL_BLEND);
1523 } 1688 }
1689}
1690
1691void
1692draw_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)
1693 PROTOTYPE: @
1694 CODE:
1695{
1696 glEnable (GL_BLEND);
1697 glBlendFunc (intensity ? GL_SRC_ALPHA : GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1698 glEnable (GL_TEXTURE_2D);
1699 glBindTexture (GL_TEXTURE_2D, name1);
1700
1701 glColor3f (intensity, intensity, intensity);
1702 glPushMatrix ();
1703 glScalef (1./3, 1./3, 1.);
1704
1705 if (blend > 0.f)
1706 {
1707 float dx3 = dx * -3.f / w;
1708 float dy3 = dy * -3.f / h;
1709 GLfloat env_color[4] = { 0., 0., 0., blend };
1710
1711 /* interpolate the two shadow textures */
1712 /* stage 0 == rgb(glcolor) + alpha(t0) */
1713 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1714
1715 /* stage 1 == rgb(glcolor) + alpha(interpolate t0, t1, texenv) */
1716 gl.ActiveTexture (GL_TEXTURE1);
1717 glEnable (GL_TEXTURE_2D);
1718 glBindTexture (GL_TEXTURE_2D, name2);
1719 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
1720
1721 /* rgb == rgb(glcolor) */
1722 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
1723 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
1724 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
1725
1726 /* alpha = interpolate t0, t1 by env_alpha */
1727 glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, env_color);
1728
1729 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_INTERPOLATE);
1730 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
1731 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
1732
1733 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
1734 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
1735
1736 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);
1737 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);
1738
1739 glBegin (GL_QUADS);
1740 gl.MultiTexCoord2f (GL_TEXTURE0, 0, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 ); glVertex2i (0, 0);
1741 gl.MultiTexCoord2f (GL_TEXTURE0, 0, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 + t); glVertex2i (0, h);
1742 gl.MultiTexCoord2f (GL_TEXTURE0, s, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 + t); glVertex2i (w, h);
1743 gl.MultiTexCoord2f (GL_TEXTURE0, s, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 ); glVertex2i (w, 0);
1744 glEnd ();
1745
1746 glDisable (GL_TEXTURE_2D);
1747 gl.ActiveTexture (GL_TEXTURE0);
1748 }
1749 else
1750 {
1751 /* simple blending of one texture, also opengl <1.3 path */
1752 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1753
1754 glBegin (GL_QUADS);
1755 glTexCoord2f (0, 0); glVertex2f (0, 0);
1756 glTexCoord2f (0, t); glVertex2f (0, h);
1757 glTexCoord2f (s, t); glVertex2f (w, h);
1758 glTexCoord2f (s, 0); glVertex2f (w, 0);
1759 glEnd ();
1760 }
1761
1762 /* draw ?-marks or equivalent, this is very clumsy code :/ */
1763 {
1764 int x, y;
1765 int dx3 = dx * 3;
1766 int dy3 = dy * 3;
1767
1768 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1769 glBindTexture (GL_TEXTURE_2D, hidden_tex);
1770 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1771 glTranslatef (-1., -1., 0);
1772 glBegin (GL_QUADS);
1773
1774 for (y = 1; y < h; y += 3)
1775 {
1776 int y1 = y - dy3;
1777 int y1valid = y1 >= 0 && y1 < h;
1778
1779 for (x = 1; x < w; x += 3)
1780 {
1781 int x1 = x - dx3;
1782 uint8_t h1 = data1 [x + y * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1783 uint8_t h2;
1784
1785 if (y1valid && x1 >= 0 && x1 < w)
1786 h2 = data2 [x1 + y1 * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1787 else
1788 h2 = 1; /* out of range == invisible */
1789
1790 if (h1 || h2)
1791 {
1792 float alpha = h1 == h2 ? 1.f : h1 ? 1.f - blend : blend;
1793 glColor4f (1., 1., 1., alpha);
1794
1795 glTexCoord2f (0, 0.); glVertex2i (x , y );
1796 glTexCoord2f (0, 1.); glVertex2i (x , y + 3);
1797 glTexCoord2f (1, 1.); glVertex2i (x + 3, y + 3);
1798 glTexCoord2f (1, 0.); glVertex2i (x + 3, y );
1799 }
1800 }
1801 }
1802 }
1803
1804 glEnd ();
1805
1806 glPopMatrix ();
1807
1808 glDisable (GL_TEXTURE_2D);
1809 glDisable (GL_BLEND);
1524} 1810}
1525 1811
1526IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type) 1812IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1527 CODE: 1813 CODE:
1528{ 1814{
… …
1634 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 1920 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1635 // use uglier nearest interpolation because linear suffers 1921 // use uglier nearest interpolation because linear suffers
1636 // from transparent color bleeding and ugly wrapping effects. 1922 // from transparent color bleeding and ugly wrapping effects.
1637 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1923 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1638} 1924}
1925
1926void
1927expire_textures (DC::Map self, int texid, int count)
1928 PPCODE:
1929 for (; texid < self->texs && count; ++texid, --count)
1930 {
1931 maptex *tex = self->tex + texid;
1932
1933 if (tex->name)
1934 {
1935 if (tex->unused)
1936 {
1937 tex->name = 0;
1938 tex->unused = 0;
1939 XPUSHs (sv_2mortal (newSViv (texid)));
1940 }
1941 else
1942 tex->unused = 1;
1943 }
1944 }
1639 1945
1640int 1946int
1641ox (DC::Map self) 1947ox (DC::Map self)
1642 ALIAS: 1948 ALIAS:
1643 oy = 1 1949 oy = 1
… …
1724 { 2030 {
1725 ext = *data++; 2031 ext = *data++;
1726 cmd = ext & 0x7f; 2032 cmd = ext & 0x7f;
1727 2033
1728 if (cmd < 4) 2034 if (cmd < 4)
1729 cell->darkness = 255 - ext * 64 + 1; 2035 cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
1730 else if (cmd == 5) // health 2036 else if (cmd == 5) // health
1731 { 2037 {
1732 cell->stat_width = 1; 2038 cell->stat_width = 1;
1733 cell->stat_hp = *data++; 2039 cell->stat_hp = *data++;
1734 } 2040 }
… …
1764 cell->tile [z] = self->face2tile [face]; 2070 cell->tile [z] = self->face2tile [face];
1765 2071
1766 if (cell->tile [z]) 2072 if (cell->tile [z])
1767 { 2073 {
1768 maptex *tex = self->tex + cell->tile [z]; 2074 maptex *tex = self->tex + cell->tile [z];
2075 tex->unused = 0;
1769 if (!tex->name) 2076 if (!tex->name)
1770 av_push (missing, newSViv (cell->tile [z])); 2077 av_push (missing, newSViv (cell->tile [z]));
1771 2078
1772 if (tex->smoothtile) 2079 if (tex->smoothtile)
1773 { 2080 {
1774 maptex *smooth = self->tex + tex->smoothtile; 2081 maptex *smooth = self->tex + tex->smoothtile;
2082 smooth->unused = 0;
1775 if (!smooth->name) 2083 if (!smooth->name)
1776 av_push (missing, newSViv (tex->smoothtile)); 2084 av_push (missing, newSViv (tex->smoothtile));
1777 } 2085 }
1778 } 2086 }
1779 } 2087 }
1780 } 2088 }
1781 else 2089 else
1782 cell->darkness = 0; 2090 CELL_CLEAR (cell);
1783 } 2091 }
1784} 2092}
1785 OUTPUT: 2093 OUTPUT:
1786 RETVAL 2094 RETVAL
1787 2095
… …
1839} 2147}
1840 OUTPUT: 2148 OUTPUT:
1841 RETVAL 2149 RETVAL
1842 2150
1843void 2151void
1844draw (DC::Map self, int mx, int my, int sw, int sh, int T, U32 player = 0xffffffff, int pdx = 0, int pdy = 0) 2152draw (DC::Map self, int mx, int my, int sw, int sh, int T, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)
1845 CODE: 2153 CODE:
1846{ 2154{
1847 int x, y, z; 2155 int x, y, z;
1848 2156
1849 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ()); 2157 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1850 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level 2158 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1851 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k) 2159 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k)
1852 smooth_key skey; 2160 smooth_key skey;
1853 int pl_x, pl_y; 2161 int pl_x, pl_y;
1854 maptex pl_tex; 2162 maptex pl_tex;
1855 rc_t *rc = rc_alloc (); 2163 rc_t *rc = rc_alloc ();
2164 rc_t *rc_ov = rc_alloc ();
1856 rc_key_t key; 2165 rc_key_t key;
1857 rc_array_t *arr; 2166 rc_array_t *arr;
1858 2167
1859 pl_tex.name = 0; 2168 pl_tex.name = 0;
1860 2169
1861 // thats current max. sorry. 2170 // that's current max. sorry.
1862 if (sw > 255) sw = 255; 2171 if (sw > 255) sw = 255;
1863 if (sh > 255) sh = 255; 2172 if (sh > 255) sh = 255;
1864 2173
1865 // clear key, in case of extra padding 2174 // clear key, in case of extra padding
1866 memset (&skey, 0, sizeof (skey)); 2175 memset (&skey, 0, sizeof (skey));
… …
1870 key.g = 255; 2179 key.g = 255;
1871 key.b = 255; 2180 key.b = 255;
1872 key.a = 255; 2181 key.a = 255;
1873 key.mode = GL_QUADS; 2182 key.mode = GL_QUADS;
1874 key.format = GL_T2F_V3F; 2183 key.format = GL_T2F_V3F;
1875 key.texname = -1;
1876 2184
1877 mx += self->x; 2185 mx += self->x;
1878 my += self->y; 2186 my += self->y;
1879 2187
1880 // first pass: determine smooth_max 2188 // first pass: determine smooth_max
… …
1904 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2212 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1905 2213
1906 for (z = 0; z <= 2; z++) 2214 for (z = 0; z <= 2; z++)
1907 { 2215 {
1908 memset (smooth_level, 0, sizeof (smooth_level)); 2216 memset (smooth_level, 0, sizeof (smooth_level));
2217 key.texname = -1;
1909 2218
1910 for (y = 0; y < sh; y++) 2219 for (y = 0; y < sh; y++)
1911 if (0 <= y + my && y + my < self->rows) 2220 if (0 <= y + my && y + my < self->rows)
1912 { 2221 {
1913 maprow *row = self->row + (y + my); 2222 maprow *row = self->row + (y + my);
… …
1919 tileid tile = cell->tile [z]; 2228 tileid tile = cell->tile [z];
1920 2229
1921 if (tile) 2230 if (tile)
1922 { 2231 {
1923 maptex tex = self->tex [tile]; 2232 maptex tex = self->tex [tile];
1924 int px = (x + 1) * T - tex.w; 2233 int px, py;
1925 int py = (y + 1) * T - tex.h;
1926 2234
1927 if (key.texname != tex.name) 2235 if (key.texname != tex.name)
1928 { 2236 {
2237 self->tex [tile].unused = 0;
2238
1929 if (!tex.name) 2239 if (!tex.name)
1930 tex = self->tex [2]; /* missing, replace by noface */ 2240 tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
1931 2241
1932 key.texname = tex.name; 2242 key.texname = tex.name;
1933 arr = rc_array (rc, &key); 2243 arr = rc_array (rc, &key);
1934 } 2244 }
2245
2246 px = (x + 1) * T - tex.w;
2247 py = (y + 1) * T - tex.h;
1935 2248
1936 if (expect_false (cell->player == player) && expect_false (z == 2)) 2249 if (expect_false (cell->player == player) && expect_false (z == 2))
1937 { 2250 {
1938 pl_x = px; 2251 pl_x = px;
1939 pl_y = py; 2252 pl_y = py;
… …
1944 rc_t2f_v3f (arr, 0 , 0 , px , py , 0); 2257 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
1945 rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0); 2258 rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
1946 rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0); 2259 rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
1947 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0); 2260 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
1948 2261
1949 if (expect_false (cell->flags) && expect_false (z == 2))
1950 {
1951 // overlays such as the speech bubble, probably more to come
1952 if (cell->flags & 1)
1953 {
1954 maptex tex = self->tex [1];
1955 int px = x * T + T * 2 / 32;
1956 int py = y * T - T * 6 / 32;
1957
1958 if (tex.name)
1959 {
1960 if (key.texname != tex.name)
1961 {
1962 key.texname = tex.name;
1963 arr = rc_array (rc, &key);
1964 }
1965
1966 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
1967 rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
1968 rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
1969 rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
1970 }
1971 }
1972 }
1973
1974 // update smooth hash 2262 // update smooth hash
1975 if (tex.smoothtile) 2263 if (tex.smoothtile)
1976 { 2264 {
1977 skey.tile = tex.smoothtile; 2265 skey.tile = tex.smoothtile;
1978 skey.level = tex.smoothlevel; 2266 skey.level = tex.smoothlevel;
… …
2006 // corners 2294 // corners
2007 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100); 2295 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);
2008 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200); 2296 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);
2009 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400); 2297 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);
2010 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800); 2298 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);
2299 }
2300 }
2301
2302 if (expect_false (z == 2) && expect_false (cell->flags))
2303 {
2304 // overlays such as the speech bubble, probably more to come
2305 if (cell->flags & 1)
2306 {
2307 rc_key_t key_ov = key;
2308 maptex tex = self->tex [TEXID_SPEECH];
2309 rc_array_t *arr;
2310 int px = x * T + T * 2 / 32;
2311 int py = y * T - T * 6 / 32;
2312
2313 key_ov.texname = tex.name;
2314 arr = rc_array (rc_ov, &key_ov);
2315
2316 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
2317 rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
2318 rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
2319 rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
2011 } 2320 }
2012 } 2321 }
2013 } 2322 }
2014 } 2323 }
2015 2324
… …
2055 { 2364 {
2056 // this time avoiding texture state changes 2365 // this time avoiding texture state changes
2057 // save gobs of state changes. 2366 // save gobs of state changes.
2058 if (key.texname != tex.name) 2367 if (key.texname != tex.name)
2059 { 2368 {
2369 self->tex [skey->tile].unused = 0;
2370
2060 glEnd (); 2371 glEnd ();
2061 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name); 2372 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
2062 glBegin (GL_QUADS); 2373 glBegin (GL_QUADS);
2063 } 2374 }
2064 2375
… …
2096 } 2407 }
2097 2408
2098 if (pl_tex.name) 2409 if (pl_tex.name)
2099 { 2410 {
2100 maptex tex = pl_tex; 2411 maptex tex = pl_tex;
2101 int px = pl_x + pdx; 2412 int px = pl_x + sdx;
2102 int py = pl_y + pdy; 2413 int py = pl_y + sdy;
2103 2414
2104 key.texname = tex.name; 2415 key.texname = tex.name;
2105 arr = rc_array (rc, &key); 2416 arr = rc_array (rc, &key);
2106 2417
2107 rc_t2f_v3f (arr, 0 , 0 , px , py , 0); 2418 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
… …
2110 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0); 2421 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
2111 2422
2112 rc_draw (rc); 2423 rc_draw (rc);
2113 } 2424 }
2114 2425
2426 rc_draw (rc_ov);
2427 rc_clear (rc_ov);
2428
2115 glDisable (GL_BLEND); 2429 glDisable (GL_BLEND);
2116 rc_free (rc); 2430 rc_free (rc);
2431 rc_free (rc_ov);
2117 2432
2118 // top layer: overlays such as the health bar 2433 // top layer: overlays such as the health bar
2119 for (y = 0; y < sh; y++) 2434 for (y = 0; y < sh; y++)
2120 if (0 <= y + my && y + my < self->rows) 2435 if (0 <= y + my && y + my < self->rows)
2121 { 2436 {
… …
2126 { 2441 {
2127 mapcell *cell = row->col + (x + mx - row->c0); 2442 mapcell *cell = row->col + (x + mx - row->c0);
2128 2443
2129 int px = x * T; 2444 int px = x * T;
2130 int py = y * T; 2445 int py = y * T;
2446
2447 if (expect_false (cell->player == player))
2448 {
2449 px += sdx;
2450 py += sdy;
2451 }
2131 2452
2132 if (cell->stat_hp) 2453 if (cell->stat_hp)
2133 { 2454 {
2134 int width = cell->stat_width * T; 2455 int width = cell->stat_width * T;
2135 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width; 2456 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
… …
2146 } 2467 }
2147 } 2468 }
2148} 2469}
2149 2470
2150void 2471void
2151draw_magicmap (DC::Map self, int dx, int dy, int w, int h, unsigned char *data) 2472draw_magicmap (DC::Map self, int w, int h, unsigned char *data)
2152 CODE: 2473 CODE:
2153{ 2474{
2154 static float color[16][3] = { 2475 static float color[16][3] = {
2155 { 0.00F, 0.00F, 0.00F }, 2476 { 0.00f, 0.00f, 0.00f },
2156 { 1.00F, 1.00F, 1.00F }, 2477 { 1.00f, 1.00f, 1.00f },
2157 { 0.00F, 0.00F, 0.55F }, 2478 { 0.00f, 0.00f, 0.55f },
2158 { 1.00F, 0.00F, 0.00F }, 2479 { 1.00f, 0.00f, 0.00f },
2159 2480
2160 { 1.00F, 0.54F, 0.00F }, 2481 { 1.00f, 0.54f, 0.00f },
2161 { 0.11F, 0.56F, 1.00F }, 2482 { 0.11f, 0.56f, 1.00f },
2162 { 0.93F, 0.46F, 0.00F }, 2483 { 0.93f, 0.46f, 0.00f },
2163 { 0.18F, 0.54F, 0.34F }, 2484 { 0.18f, 0.54f, 0.34f },
2164 2485
2165 { 0.56F, 0.73F, 0.56F }, 2486 { 0.56f, 0.73f, 0.56f },
2166 { 0.80F, 0.80F, 0.80F }, 2487 { 0.80f, 0.80f, 0.80f },
2167 { 0.55F, 0.41F, 0.13F }, 2488 { 0.55f, 0.41f, 0.13f },
2168 { 0.99F, 0.77F, 0.26F }, 2489 { 0.99f, 0.77f, 0.26f },
2169 2490
2170 { 0.74F, 0.65F, 0.41F }, 2491 { 0.74f, 0.65f, 0.41f },
2171 2492
2172 { 0.00F, 1.00F, 1.00F }, 2493 { 0.00f, 1.00f, 1.00f },
2173 { 1.00F, 0.00F, 1.00F }, 2494 { 1.00f, 0.00f, 1.00f },
2174 { 1.00F, 1.00F, 0.00F }, 2495 { 1.00f, 1.00f, 0.00f },
2175 }; 2496 };
2176 2497
2177 int x, y; 2498 int x, y;
2178 2499
2179 glEnable (GL_TEXTURE_2D); 2500 glEnable (GL_TEXTURE_2D);
2501 /* GL_REPLACE would be correct, as we don't need to modulate alpha,
2502 * but the nvidia driver (185.18.14) mishandles alpha textures
2503 * and takes the colour from god knows where instead of using
2504 * Cp. MODULATE results in the same colour, but slightly different
2505 * alpha, but atcually gives us the correct colour with nvidia.
2506 */
2180 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2507 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
2181 glEnable (GL_BLEND); 2508 glEnable (GL_BLEND);
2182 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2509 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2183 glBegin (GL_QUADS); 2510 glBegin (GL_QUADS);
2184 2511
2185 for (y = 0; y < h; y++) 2512 for (y = 0; y < h; y++)
… …
2189 2516
2190 if (m) 2517 if (m)
2191 { 2518 {
2192 float *c = color [m & 15]; 2519 float *c = color [m & 15];
2193 2520
2194 float tx1 = m & 0x40 ? 0.5 : 0.; 2521 float tx1 = m & 0x40 ? 0.5f : 0.f;
2195 float tx2 = tx1 + 0.5; 2522 float tx2 = tx1 + 0.5f;
2196 2523
2197 glColor4f (c[0], c[1], c[2], 0.75); 2524 glColor4f (c[0], c[1], c[2], 1);
2198 glTexCoord2f (tx1, 0.); glVertex2i (x , y ); 2525 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2199 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1); 2526 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2200 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1); 2527 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2201 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y ); 2528 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2202 } 2529 }
… …
2210void 2537void
2211fow_texture (DC::Map self, int mx, int my, int sw, int sh) 2538fow_texture (DC::Map self, int mx, int my, int sw, int sh)
2212 PPCODE: 2539 PPCODE:
2213{ 2540{
2214 int x, y; 2541 int x, y;
2215 int sw1 = sw + 2; 2542 int sw1 = sw + 2;
2216 int sh1 = sh + 2; 2543 int sh1 = sh + 2;
2217 int sh3 = sh * 3; 2544 int sh3 = sh * 3;
2218 int sw34 = (sw * 3 + 3) & ~3; 2545 int sw3 = sw * 3;
2219 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1); 2546 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2220 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3)); 2547 SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3));
2221 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv); 2548 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2222 2549
2223 SvPOK_only (darkness3_sv); 2550 SvPOK_only (darkness3_sv);
2224 SvCUR_set (darkness3_sv, sw34 * sh3); 2551 SvCUR_set (darkness3_sv, sw3 * sh3);
2225 2552
2226 mx += self->x - 1; 2553 mx += self->x - 1;
2227 my += self->y - 1; 2554 my += self->y - 1;
2228
2229 memset (darkness1, 255, sw1 * sh1);
2230 2555
2231 for (y = 0; y < sh1; y++) 2556 for (y = 0; y < sh1; y++)
2232 if (0 <= y + my && y + my < self->rows) 2557 if (0 <= y + my && y + my < self->rows)
2233 { 2558 {
2234 maprow *row = self->row + (y + my); 2559 maprow *row = self->row + (y + my);
… …
2237 if (row->c0 <= x + mx && x + mx < row->c1) 2562 if (row->c0 <= x + mx && x + mx < row->c1)
2238 { 2563 {
2239 mapcell *cell = row->col + (x + mx - row->c0); 2564 mapcell *cell = row->col + (x + mx - row->c0);
2240 2565
2241 darkness1 [y * sw1 + x] = cell->darkness 2566 darkness1 [y * sw1 + x] = cell->darkness
2242 ? 255 - (cell->darkness - 1) 2567 ? DARKNESS_ADJUST (255 - (cell->darkness - 1))
2243 : 255 - FOW_DARKNESS; 2568 : DARKNESS_ADJUST (255 - FOW_DARKNESS);
2244 } 2569 }
2245 } 2570 }
2246 2571
2247 for (y = 0; y < sh; ++y) 2572 for (y = 0; y < sh; ++y)
2248 for (x = 0; x < sw; ++x) 2573 for (x = 0; x < sw; ++x)
… …
2267 2592
2268 uint8_t r13 = (d13 + d23 + d12) / 3; 2593 uint8_t r13 = (d13 + d23 + d12) / 3;
2269 uint8_t r23 = d23; 2594 uint8_t r23 = d23;
2270 uint8_t r33 = (d23 + d33 + d32) / 3; 2595 uint8_t r33 = (d23 + d33 + d32) / 3;
2271 2596
2272 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11); 2597 darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2273 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21); 2598 darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2274 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31); 2599 darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2275 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12); 2600 darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2276 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22); 2601 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 1)] = MAX (d22, r22); /* this MUST be == d22 */
2277 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32); 2602 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2278 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13); 2603 darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2279 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23); 2604 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2280 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33); 2605 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2281 } 2606 }
2282 2607
2283 free (darkness1); 2608 free (darkness1);
2284 2609
2285 EXTEND (SP, 3); 2610 EXTEND (SP, 3);
2286 PUSHs (sv_2mortal (newSViv (sw34))); 2611 PUSHs (sv_2mortal (newSViv (sw3)));
2287 PUSHs (sv_2mortal (newSViv (sh3))); 2612 PUSHs (sv_2mortal (newSViv (sh3)));
2288 PUSHs (darkness3_sv); 2613 PUSHs (darkness3_sv);
2289} 2614}
2290 2615
2291SV * 2616SV *
… …
2489 if (RETVAL < 0) 2814 if (RETVAL < 0)
2490 { 2815 {
2491 RETVAL = Mix_GroupOldest (-1); 2816 RETVAL = Mix_GroupOldest (-1);
2492 2817
2493 if (RETVAL < 0) 2818 if (RETVAL < 0)
2819 {
2820 // happens sometimes, maybe it just stopped playing(?)
2821 RETVAL = Mix_GroupAvailable (-1);
2822
2823 if (RETVAL < 0)
2494 XSRETURN_UNDEF; 2824 XSRETURN_UNDEF;
2495 2825 }
2826 else
2496 Mix_HaltChannel (RETVAL); 2827 Mix_HaltChannel (RETVAL);
2497 } 2828 }
2498 2829
2499 Mix_UnregisterAllEffects (RETVAL); 2830 Mix_UnregisterAllEffects (RETVAL);
2500 Mix_Volume (RETVAL, 128); 2831 Mix_Volume (RETVAL, 128);
2501} 2832}
… …
2548void 2879void
2549set_position_r (DC::Channel self, int dx, int dy, int maxdistance) 2880set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2550 CODE: 2881 CODE:
2551{ 2882{
2552 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance)); 2883 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2553 int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI); 2884 int angle = atan2f (dx, -dy) * 180.f / (float)M_PI + 360.f;
2554 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255)); 2885 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2555} 2886}
2556 2887
2557void 2888void
2558set_reverse_stereo (DC::Channel self, int flip) 2889set_reverse_stereo (DC::Channel self, int flip)
… …
2560 Mix_SetReverseStereo (self, flip); 2891 Mix_SetReverseStereo (self, flip);
2561 2892
2562MODULE = Deliantra::Client PACKAGE = DC::MixChunk 2893MODULE = Deliantra::Client PACKAGE = DC::MixChunk
2563 2894
2564PROTOTYPES: DISABLE 2895PROTOTYPES: DISABLE
2896
2897void
2898decoders ()
2899 PPCODE:
2900#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
2901 int i, num = Mix_GetNumChunkDecoders ();
2902 EXTEND (SP, num);
2903 for (i = 0; i < num; ++i)
2904 PUSHs (sv_2mortal (newSVpv (Mix_GetChunkDecoder (i), 0)));
2905#else
2906 XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
2907#endif
2565 2908
2566DC::MixChunk 2909DC::MixChunk
2567new (SV *class, DC::RW rwops) 2910new (SV *class, DC::RW rwops)
2568 CODE: 2911 CODE:
2569 RETVAL = Mix_LoadWAV_RW (rwops, 1); 2912 RETVAL = Mix_LoadWAV_RW (rwops, 1);
… …
2602 OUTPUT: 2945 OUTPUT:
2603 RETVAL 2946 RETVAL
2604 2947
2605MODULE = Deliantra::Client PACKAGE = DC::MixMusic 2948MODULE = Deliantra::Client PACKAGE = DC::MixMusic
2606 2949
2950void
2951decoders ()
2952 PPCODE:
2953#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
2954 int i, num = Mix_GetNumMusicDecoders ();
2955 EXTEND (SP, num);
2956 for (i = 0; i < num; ++i)
2957 PUSHs (sv_2mortal (newSVpv (Mix_GetMusicDecoder (i), 0)));
2958#else
2959 XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
2960#endif
2961
2607int 2962int
2608volume (int volume = -1) 2963volume (int volume = -1)
2609 PROTOTYPE: ;$ 2964 PROTOTYPE: ;$
2610 CODE: 2965 CODE:
2611 if (items > 0) 2966 if (items > 0)
… …
2621 2976
2622void 2977void
2623halt () 2978halt ()
2624 CODE: 2979 CODE:
2625 Mix_HaltMusic (); 2980 Mix_HaltMusic ();
2981
2982int
2983playing ()
2984 CODE:
2985 RETVAL = Mix_PlayingMusic ();
2986 OUTPUT:
2987 RETVAL
2626 2988
2627DC::MixMusic 2989DC::MixMusic
2628new (SV *class, DC::RW rwops) 2990new (SV *class, DC::RW rwops)
2629 CODE: 2991 CODE:
2630 RETVAL = Mix_LoadMUS_RW (rwops); 2992 RETVAL = Mix_LoadMUS_RW (rwops);
… …
2661 } *civ, const_iv[] = { 3023 } *civ, const_iv[] = {
2662# define const_iv(name) { # name, (IV)name } 3024# define const_iv(name) { # name, (IV)name }
2663 const_iv (GL_VENDOR), 3025 const_iv (GL_VENDOR),
2664 const_iv (GL_VERSION), 3026 const_iv (GL_VERSION),
2665 const_iv (GL_EXTENSIONS), 3027 const_iv (GL_EXTENSIONS),
3028 const_iv (GL_MAX_TEXTURE_UNITS),
2666 const_iv (GL_COLOR_MATERIAL), 3029 const_iv (GL_COLOR_MATERIAL),
2667 const_iv (GL_SMOOTH), 3030 const_iv (GL_SMOOTH),
2668 const_iv (GL_FLAT), 3031 const_iv (GL_FLAT),
2669 const_iv (GL_DITHER), 3032 const_iv (GL_DITHER),
2670 const_iv (GL_BLEND), 3033 const_iv (GL_BLEND),
… …
2682 const_iv (GL_ZERO), 3045 const_iv (GL_ZERO),
2683 const_iv (GL_SRC_ALPHA), 3046 const_iv (GL_SRC_ALPHA),
2684 const_iv (GL_DST_ALPHA), 3047 const_iv (GL_DST_ALPHA),
2685 const_iv (GL_ONE_MINUS_SRC_ALPHA), 3048 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2686 const_iv (GL_ONE_MINUS_DST_ALPHA), 3049 const_iv (GL_ONE_MINUS_DST_ALPHA),
3050 const_iv (GL_SRC_COLOR),
3051 const_iv (GL_DST_COLOR),
3052 const_iv (GL_ONE_MINUS_SRC_COLOR),
3053 const_iv (GL_ONE_MINUS_DST_COLOR),
2687 const_iv (GL_SRC_ALPHA_SATURATE), 3054 const_iv (GL_SRC_ALPHA_SATURATE),
2688 const_iv (GL_RGB), 3055 const_iv (GL_RGB),
2689 const_iv (GL_RGBA), 3056 const_iv (GL_RGBA),
2690 const_iv (GL_RGBA4), 3057 const_iv (GL_RGBA4),
2691 const_iv (GL_RGBA8), 3058 const_iv (GL_RGBA8),
… …
2759 const_iv (GL_NICEST), 3126 const_iv (GL_NICEST),
2760 const_iv (GL_V2F), 3127 const_iv (GL_V2F),
2761 const_iv (GL_V3F), 3128 const_iv (GL_V3F),
2762 const_iv (GL_T2F_V3F), 3129 const_iv (GL_T2F_V3F),
2763 const_iv (GL_T2F_N3F_V3F), 3130 const_iv (GL_T2F_N3F_V3F),
3131 const_iv (GL_FUNC_ADD),
3132 const_iv (GL_FUNC_SUBTRACT),
3133 const_iv (GL_FUNC_REVERSE_SUBTRACT),
2764# undef const_iv 3134# undef const_iv
2765 }; 3135 };
2766 3136
2767 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 3137 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
2768 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 3138 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
… …
2775disable_GL_EXT_blend_func_separate () 3145disable_GL_EXT_blend_func_separate ()
2776 CODE: 3146 CODE:
2777 gl.BlendFuncSeparate = 0; 3147 gl.BlendFuncSeparate = 0;
2778 gl.BlendFuncSeparateEXT = 0; 3148 gl.BlendFuncSeparateEXT = 0;
2779 3149
3150void
3151apple_nvidia_bug (int enable)
3152
2780char * 3153char *
2781gl_vendor () 3154gl_vendor ()
2782 CODE: 3155 CODE:
2783 RETVAL = (char *)glGetString (GL_VENDOR); 3156 RETVAL = (char *)glGetString (GL_VENDOR);
2784 OUTPUT: 3157 OUTPUT:
… …
2814 3187
2815int glGetError () 3188int glGetError ()
2816 3189
2817void glFinish () 3190void glFinish ()
2818 3191
3192void glFlush ()
3193
2819void glClear (int mask) 3194void glClear (int mask)
2820 3195
2821void glClearColor (float r, float g, float b, float a = 1.0) 3196void glClearColor (float r, float g, float b, float a = 1.0)
2822 PROTOTYPE: @ 3197 PROTOTYPE: @
2823 3198
… …
2832void glBlendFunc (int sfactor, int dfactor) 3207void glBlendFunc (int sfactor, int dfactor)
2833 3208
2834void glBlendFuncSeparate (int sa, int da, int saa, int daa) 3209void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2835 CODE: 3210 CODE:
2836 gl_BlendFuncSeparate (sa, da, saa, daa); 3211 gl_BlendFuncSeparate (sa, da, saa, daa);
3212
3213# void glBlendEquation (int se)
2837 3214
2838void glDepthMask (int flag) 3215void glDepthMask (int flag)
2839 3216
2840void glLogicOp (int opcode) 3217void glLogicOp (int opcode)
2841 3218
… …
2876void glRotate (float angle, float x, float y, float z) 3253void glRotate (float angle, float x, float y, float z)
2877 CODE: 3254 CODE:
2878 glRotatef (angle, x, y, z); 3255 glRotatef (angle, x, y, z);
2879 3256
2880void glColor (float r, float g, float b, float a = 1.0) 3257void glColor (float r, float g, float b, float a = 1.0)
3258 PROTOTYPE: @
2881 ALIAS: 3259 ALIAS:
2882 glColor_premultiply = 1 3260 glColor_premultiply = 1
2883 CODE: 3261 CODE:
2884 if (ix) 3262 if (ix)
2885 { 3263 {
… …
2990void glNewList (int list, int mode = GL_COMPILE) 3368void glNewList (int list, int mode = GL_COMPILE)
2991 3369
2992void glEndList () 3370void glEndList ()
2993 3371
2994void glCallList (int list) 3372void glCallList (int list)
3373
3374void c_init ()
3375 CODE:
3376 glPixelStorei (GL_PACK_ALIGNMENT , 1);
3377 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
2995 3378
2996MODULE = Deliantra::Client PACKAGE = DC::UI::Base 3379MODULE = Deliantra::Client PACKAGE = DC::UI::Base
2997 3380
2998PROTOTYPES: DISABLE 3381PROTOTYPES: DISABLE
2999 3382

Diff Legend

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