ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/Deliantra-Client/Client.xs

Comparing deliantra/Deliantra-Client/Client.xs (file contents):
Revision 1.271 by root, Sun Jul 20 15:09:29 2008 UTC vs.
Revision 1.322 by root, Sun Nov 18 01:43:12 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>
34		37
35	#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW	38	#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
36		39
37	#include <SDL.h>	40	#include <SDL.h>
38	#include <SDL_thread.h>	41	#include <SDL_thread.h>
39	#include <SDL_endian.h>	42	#include <SDL_endian.h>
40	#include <SDL_image.h>	43	#include <SDL_image.h>
41	#include <SDL_mixer.h>	44	#include <SDL_mixer.h>
42	#include <SDL_opengl.h>	45	#include <SDL_opengl.h>
43		46
		47	/* work around os x broken headers */
		48	#ifdef __MACOSX__
		49	typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
		50	typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture);
		51	typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t);
		52	#endif
		53
44	#define PANGO_ENABLE_BACKEND	54	#define PANGO_ENABLE_BACKEND
45	#define G_DISABLE_CAST_CHECKS	55	#define G_DISABLE_CAST_CHECKS
46		56
47	#include <glib/gmacros.h>	57	#include <glib.h>
48		58
49	#include <pango/pango.h>	59	#include <pango/pango.h>
50		60
51	#ifndef PANGO_VERSION_CHECK	61	#ifndef PANGO_VERSION_CHECK
52	# define PANGO_VERSION_CHECK(a,b,c) 0	62	# define PANGO_VERSION_CHECK(a,b,c) 0
…		…
76	#define expect_false(expr) expect ((expr) != 0, 0)	86	#define expect_false(expr) expect ((expr) != 0, 0)
77	#define expect_true(expr) expect ((expr) != 0, 1)	87	#define expect_true(expr) expect ((expr) != 0, 1)
78		88
79	#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */	89	#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
80		90
		91	/* this is used as fow flag as well, so has to have a different value */
		92	/* then anything that is computed by incoming darkness */
81	#define FOW_DARKNESS 32	93	#define FOW_DARKNESS 50
		94	#define DARKNESS_ADJUST(n) (n)
82		95
83	#define MAP_EXTEND_X 32	96	#define MAP_EXTEND_X 32
84	#define MAP_EXTEND_Y 512	97	#define MAP_EXTEND_Y 512
85		98
86	#define MIN_FONT_HEIGHT 10	99	#define MIN_FONT_HEIGHT 10
87		100
88	/* mask out modifiers we are not interested in */	101	/* mask out modifiers we are not interested in */
89	#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)	102	#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)
		103
		104	#define KMOD_LRAM 0x10000 // our extension
		105
		106	#define TEXID_SPEECH 1
		107	#define TEXID_NOFACE 2
		108
		109	static char *
		110	fast_sv_grow (SV *sv, STRLEN need)
		111	{
		112	STRLEN len = SvLEN (sv);
		113	STRLEN want = SvCUR (sv) + need;
		114
		115	if (expect_false (len < want))
		116	{
		117	do
		118	len *= 2;
		119	while (len < want);
		120
		121	sv_grow (sv, len);
		122	}
		123
		124	SvCUR_set (sv, want);
		125	return SvEND (sv) - need;
		126	}
90		127
91	static AV *texture_av;	128	static AV *texture_av;
92		129
93	static struct	130	static struct
94	{	131	{
…		…
151	{	188	{
152	GSList *attrs = run->item->analysis.extra_attrs;	189	GSList *attrs = run->item->analysis.extra_attrs;
153		190
154	while (attrs)	191	while (attrs)
155	{	192	{
156	PangoAttribute *attr = attrs->data;	193	PangoAttribute *attr = (PangoAttribute *)attrs->data;
157		194
158	if (attr->klass->type == PANGO_ATTR_SHAPE)	195	if (attr->klass->type == PANGO_ATTR_SHAPE)
159	return 1;	196	return 1;
160		197
161	attrs = attrs->next;	198	attrs = attrs->next;
…		…
179	static void	216	static void
180	substitute_func (FcPattern *pattern, gpointer data)	217	substitute_func (FcPattern *pattern, gpointer data)
181	{	218	{
182	FcPatternAddBool (pattern, FC_HINTING, 1);	219	FcPatternAddBool (pattern, FC_HINTING, 1);
183	#ifdef FC_HINT_STYLE	220	#ifdef FC_HINT_STYLE
184	FcPatternAddBool (pattern, FC_HINT_STYLE, FC_HINT_FULL);	221	FcPatternAddInteger (pattern, FC_HINT_STYLE, FC_HINT_FULL);
185	#endif	222	#endif
186	FcPatternAddBool (pattern, FC_AUTOHINT, 0);	223	FcPatternAddBool (pattern, FC_AUTOHINT, 0);
187	}	224	}
188		225
189	static void	226	static void
…		…
226	int w, h;	263	int w, h;
227	float s, t;	264	float s, t;
228	uint8_t r, g, b, a;	265	uint8_t r, g, b, a;
229	tileid smoothtile;	266	tileid smoothtile;
230	uint8_t smoothlevel;	267	uint8_t smoothlevel;
		268	uint8_t unused; /* set to zero on use */
231	} maptex;	269	} maptex;
232		270
233	typedef struct {	271	typedef struct {
234	uint32_t player;	272	uint32_t player;
235	tileid tile[3];	273	tileid tile[3];
…		…
405	CELL_CLEAR (cell);	443	CELL_CLEAR (cell);
406	}	444	}
407	}	445	}
408	}	446	}
409		447
410	typedef struct {	448	struct smooth_key
		449	{
411	tileid tile;	450	tileid tile;
412	uint8_t x, y, level;	451	uint8_t x, y, level;
413	} smooth_key;	452
		453	bool operator == (const smooth_key &o) const
		454	{
		455	return tile == o.tile && x == o.x && y == o.y && level == o.level;
		456	}
		457	};
		458
		459	typedef ska::flat_hash_map<smooth_key, IV> smooth_hash;
		460
		461	namespace std {
		462	template <>
		463	struct hash<smooth_key>
		464	{
		465	size_t operator () (const smooth_key &v) const
		466	{
		467	return v.tile + (v.x << 8) + (v.y << 16) + (v.level << 24);
		468	}
		469	};
		470	}
414		471
415	static void	472	static void
416	smooth_or_bits (HV *hv, smooth_key *key, IV bits)	473	smooth_or_bits (smooth_hash &h, smooth_key &key, IV bits)
417	{	474	{
418	SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1);	475	auto &&it = h.find (key);
419		476
420	if (SvIOK (*sv))	477	if (it == h.end ())
421	SvIV_set (*sv, SvIVX (*sv) | bits);	478	h.insert (std::make_pair (key, bits));
422	else	479	else
423	sv_setiv (*sv, bits);	480	it->second |= bits;
424	}	481	}
425		482
426	static void	483	static void
427	music_finished (void)	484	music_finished (void)
428	{	485	{
…		…
445	ev.code = 1;	502	ev.code = 1;
446	ev.data1 = (void *)(long)channel;	503	ev.data1 = (void *)(long)channel;
447	ev.data2 = 0;	504	ev.data2 = 0;
448		505
449	SDL_PushEvent ((SDL_Event *)&ev);	506	SDL_PushEvent ((SDL_Event *)&ev);
		507	}
		508
		509	// approximately divide by 255
		510	static unsigned int
		511	div255 (unsigned int n)
		512	{
		513	return (n + (n >> 8)) >> 8;
450	}	514	}
451		515
452	static unsigned int	516	static unsigned int
453	minpot (unsigned int n)	517	minpot (unsigned int n)
454	{	518	{
…		…
521	if (!svp || !SvTRUE (*svp))	585	if (!svp || !SvTRUE (*svp))
522	return 0;	586	return 0;
523		587
524	return 1;	588	return 1;
525	}	589	}
		590
		591	/******************************************************************************/
		592
		593	/* process keyboard modifiers */
		594	static int
		595	mod_munge (int mod)
		596	{
		597	mod &= MOD_MASK;
		598
		599	if (mod & (KMOD_META | KMOD_ALT))
		600	mod |= KMOD_LRAM;
		601
		602	return mod;
		603	}
		604
		605	static void
		606	deliantra_main (SV *real_main)
		607	{
		608	dSP;
		609
		610	PUSHMARK (SP);
		611	call_sv (real_main, G_DISCARD | G_VOID);
		612	}
		613
		614	#ifdef __MACOSX__
		615	static SV *real_main;
		616
		617	/* to due surprising braindamage on the side of SDL design, we
		618	* do some mind-boggling hack here: SDL requires a custom main()
		619	* on OS X, so... we provide one and call the original main(), which,
		620	* due to shared library magic, calls -lSDLmain's main, not perl's main,
		621	* and which calls our main (== SDL_main) back.
		622	*/
		623	extern C_LINKAGE int
		624	main (int argc, char *argv[])
		625	{
		626	deliantra_main (real_main);
		627	}
		628
		629	#undef main
		630
		631	extern C_LINKAGE int main (int argc, char *argv[]);
		632
		633	static void
		634	SDL_main_hack (SV *real_main_)
		635	{
		636	real_main = real_main_;
		637
		638	char *argv[] = { "deliantra client", 0 };
		639	(main) (1, argv);
		640	}
		641	#else
		642	static void
		643	SDL_main_hack (SV *real_main)
		644	{
		645	deliantra_main (real_main);
		646	}
		647	#endif
526		648
527	MODULE = Deliantra::Client PACKAGE = DC	649	MODULE = Deliantra::Client PACKAGE = DC
528		650
529	PROTOTYPES: ENABLE	651	PROTOTYPES: ENABLE
530		652
…		…
559	const_iv (SDL_USEREVENT),	681	const_iv (SDL_USEREVENT),
560		682
561	const_iv (SDL_APPINPUTFOCUS),	683	const_iv (SDL_APPINPUTFOCUS),
562	const_iv (SDL_APPMOUSEFOCUS),	684	const_iv (SDL_APPMOUSEFOCUS),
563	const_iv (SDL_APPACTIVE),	685	const_iv (SDL_APPACTIVE),
		686
		687
		688	const_iv (SDLK_UNKNOWN),
		689	const_iv (SDLK_FIRST),
		690	const_iv (SDLK_BACKSPACE),
		691	const_iv (SDLK_TAB),
		692	const_iv (SDLK_CLEAR),
		693	const_iv (SDLK_RETURN),
		694	const_iv (SDLK_PAUSE),
		695	const_iv (SDLK_ESCAPE),
		696	const_iv (SDLK_SPACE),
		697	const_iv (SDLK_EXCLAIM),
		698	const_iv (SDLK_QUOTEDBL),
		699	const_iv (SDLK_HASH),
		700	const_iv (SDLK_DOLLAR),
		701	const_iv (SDLK_AMPERSAND),
		702	const_iv (SDLK_QUOTE),
		703	const_iv (SDLK_LEFTPAREN),
		704	const_iv (SDLK_RIGHTPAREN),
		705	const_iv (SDLK_ASTERISK),
		706	const_iv (SDLK_PLUS),
		707	const_iv (SDLK_COMMA),
		708	const_iv (SDLK_MINUS),
		709	const_iv (SDLK_PERIOD),
		710	const_iv (SDLK_SLASH),
		711	const_iv (SDLK_0),
		712	const_iv (SDLK_1),
		713	const_iv (SDLK_2),
		714	const_iv (SDLK_3),
		715	const_iv (SDLK_4),
		716	const_iv (SDLK_5),
		717	const_iv (SDLK_6),
		718	const_iv (SDLK_7),
		719	const_iv (SDLK_8),
		720	const_iv (SDLK_9),
		721	const_iv (SDLK_COLON),
		722	const_iv (SDLK_SEMICOLON),
		723	const_iv (SDLK_LESS),
		724	const_iv (SDLK_EQUALS),
		725	const_iv (SDLK_GREATER),
		726	const_iv (SDLK_QUESTION),
		727	const_iv (SDLK_AT),
		728
		729	const_iv (SDLK_LEFTBRACKET),
		730	const_iv (SDLK_BACKSLASH),
		731	const_iv (SDLK_RIGHTBRACKET),
		732	const_iv (SDLK_CARET),
		733	const_iv (SDLK_UNDERSCORE),
		734	const_iv (SDLK_BACKQUOTE),
		735	const_iv (SDLK_DELETE),
564		736
565	const_iv (SDLK_FIRST),	737	const_iv (SDLK_FIRST),
566	const_iv (SDLK_LAST),	738	const_iv (SDLK_LAST),
567	const_iv (SDLK_KP0),	739	const_iv (SDLK_KP0),
568	const_iv (SDLK_KP1),	740	const_iv (SDLK_KP1),
…		…
644	const_iv (KMOD_RMETA),	816	const_iv (KMOD_RMETA),
645	const_iv (KMOD_NUM),	817	const_iv (KMOD_NUM),
646	const_iv (KMOD_CAPS),	818	const_iv (KMOD_CAPS),
647	const_iv (KMOD_MODE),	819	const_iv (KMOD_MODE),
648		820
		821	const_iv (KMOD_LRAM),
		822
649	const_iv (MIX_DEFAULT_FORMAT),	823	const_iv (MIX_DEFAULT_FORMAT),
650		824
651	const_iv (SDL_INIT_TIMER),	825	const_iv (SDL_INIT_TIMER),
652	const_iv (SDL_INIT_AUDIO),	826	const_iv (SDL_INIT_AUDIO),
653	const_iv (SDL_INIT_VIDEO),	827	const_iv (SDL_INIT_VIDEO),
…		…
677		851
678	const_iv (FOW_DARKNESS)	852	const_iv (FOW_DARKNESS)
679	# undef const_iv	853	# undef const_iv
680	};	854	};
681		855
682	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	856	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
683	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	857	newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
684		858
685	assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);	859	assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
686	assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);	860	assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
687	}	861	}
688		862
…		…
704	NV ceil (NV x)	878	NV ceil (NV x)
705		879
706	IV minpot (UV n)	880	IV minpot (UV n)
707		881
708	IV popcount (UV n)	882	IV popcount (UV n)
		883
		884	NV distance (NV dx, NV dy)
		885	CODE:
		886	RETVAL = pow (dx * dx + dy * dy, 0.5);
		887	OUTPUT:
		888	RETVAL
709		889
710	void	890	void
711	pango_init ()	891	pango_init ()
712	CODE:	892	CODE:
713	{	893	{
…		…
721	#endif	901	#endif
722	}	902	}
723		903
724	char *SDL_GetError ()	904	char *SDL_GetError ()
725		905
		906	void SDL_main_hack (SV *real_main)
		907	PROTOTYPE: &
		908
726	int SDL_Init (U32 flags)	909	int SDL_Init (U32 flags)
727		910
728	int SDL_InitSubSystem (U32 flags)	911	int SDL_InitSubSystem (U32 flags)
729		912
730	void SDL_QuitSubSystem (U32 flags)	913	void SDL_QuitSubSystem (U32 flags)
731		914
732	void SDL_Quit ()	915	void SDL_Quit ()
733		916
734	int SDL_GL_SetAttribute (int attr, int value)	917	int SDL_GL_SetAttribute (int attr, int value)
		918	C_ARGS: (SDL_GLattr)attr, value
735		919
736	int SDL_GL_GetAttribute (int attr)	920	int SDL_GL_GetAttribute (int attr)
737	CODE:	921	CODE:
738	if (SDL_GL_GetAttribute (attr, &RETVAL))	922	if (SDL_GL_GetAttribute ((SDL_GLattr)attr, &RETVAL))
739	XSRETURN_UNDEF;	923	XSRETURN_UNDEF;
740	OUTPUT:	924	OUTPUT:
741	RETVAL	925	RETVAL
742		926
743	void	927	void
…		…
798	);	982	);
799		983
800	if (RETVAL)	984	if (RETVAL)
801	{	985	{
802	av_clear (texture_av);	986	av_clear (texture_av);
803
804	SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
805	#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);
806	#include "glfunc.h"	988	#include "glfunc.h"
807	#undef GL_FUNC	989	#undef GL_FUNC
		990	if (!gl.ActiveTexture ) gl.ActiveTexture = gl.ActiveTextureARB;
		991	if (!gl.MultiTexCoord2f) gl.MultiTexCoord2f = gl.MultiTexCoord2fARB;
808	}	992	}
809	}	993	}
810	OUTPUT:	994	OUTPUT:
811	RETVAL	995	RETVAL
		996
		997	void
		998	SDL_WM_SetCaption (const char *title, const char *icon)
812		999
813	void	1000	void
814	SDL_GL_SwapBuffers ()	1001	SDL_GL_SwapBuffers ()
815		1002
816	char *	1003	char *
817	SDL_GetKeyName (int sym)	1004	SDL_GetKeyName (int sym)
		1005	C_ARGS: (SDLKey)sym
818		1006
819	int	1007	int
820	SDL_GetAppState ()	1008	SDL_GetAppState ()
821		1009
822	int	1010	int
823	SDL_GetModState ()	1011	SDL_GetModState ()
824		1012
		1013	int
		1014	SDL_WaitEvent ()
		1015	C_ARGS: 0
		1016
825	void	1017	void
		1018	SDL_PumpEvents ()
		1019
		1020	void
826	poll_events ()	1021	peep_events ()
827	PPCODE:	1022	PPCODE:
828	{	1023	{
829	SDL_Event ev;	1024	SDL_Event ev;
830		1025
831	SDL_PumpEvents ();	1026	SDL_PumpEvents ();
…		…
838	{	1033	{
839	case SDL_KEYDOWN:	1034	case SDL_KEYDOWN:
840	case SDL_KEYUP:	1035	case SDL_KEYUP:
841	hv_store (hv, "state", 5, newSViv (ev.key.state), 0);	1036	hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
842	hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);	1037	hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
843	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);
844	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 */
845	hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);	1040	hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
846	break;	1041	break;
847		1042
848	case SDL_ACTIVEEVENT:	1043	case SDL_ACTIVEEVENT:
849	hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);	1044	hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
…		…
867	x = ev.motion.x;	1062	x = ev.motion.x;
868	y = ev.motion.y;	1063	y = ev.motion.y;
869	SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));	1064	SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
870	}	1065	}
871		1066
872	hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0);	1067	hv_store (hv, "mod", 3, newSViv (mod_munge (SDL_GetModState ())), 0);
873	hv_store (hv, "state", 5, newSViv (state), 0);	1068	hv_store (hv, "state", 5, newSViv (state), 0);
874	hv_store (hv, "x", 1, newSViv (x), 0);	1069	hv_store (hv, "x", 1, newSViv (x), 0);
875	hv_store (hv, "y", 1, newSViv (y), 0);	1070	hv_store (hv, "y", 1, newSViv (y), 0);
876	hv_store (hv, "xrel", 4, newSViv (xrel), 0);	1071	hv_store (hv, "xrel", 4, newSViv (xrel), 0);
877	hv_store (hv, "yrel", 4, newSViv (yrel), 0);	1072	hv_store (hv, "yrel", 4, newSViv (yrel), 0);
…		…
897		1092
898	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))));
899	}	1094	}
900	}	1095	}
901		1096
		1097	char *
		1098	SDL_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
902	int	1110	int
903	Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)	1111	Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)
904	POSTCALL:	1112	POSTCALL:
905	Mix_HookMusicFinished (music_finished);	1113	Mix_HookMusicFinished (music_finished);
906	Mix_ChannelFinished (channel_finished);	1114	Mix_ChannelFinished (channel_finished);
907		1115
908	void	1116	void
909	Mix_QuerySpec ()	1117	Mix_QuerySpec ()
…		…
968	add_font (char *file)	1176	add_font (char *file)
969	CODE:	1177	CODE:
970	RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);	1178	RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);
971	OUTPUT:	1179	OUTPUT:
972	RETVAL	1180	RETVAL
		1181
		1182	void
		1183	IMG_Init (int flags = IMG_INIT_JPG | IMG_INIT_PNG)
		1184
		1185	# MIX_INIT_MP3 gives smpeg + libstdc++ + libgcc_s
		1186	void
		1187	Mix_Init (int flags = MIX_INIT_MOD | MIX_INIT_OGG)
973		1188
974	void	1189	void
975	load_image_inline (SV *image_)	1190	load_image_inline (SV *image_)
976	ALIAS:	1191	ALIAS:
977	load_image_file = 1	1192	load_image_file = 1
…		…
1023		1238
1024	SDL_LockSurface (surface2);	1239	SDL_LockSurface (surface2);
1025	EXTEND (SP, 6);	1240	EXTEND (SP, 6);
1026	PUSHs (sv_2mortal (newSViv (surface2->w)));	1241	PUSHs (sv_2mortal (newSViv (surface2->w)));
1027	PUSHs (sv_2mortal (newSViv (surface2->h)));	1242	PUSHs (sv_2mortal (newSViv (surface2->h)));
1028	PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));	1243	PUSHs (sv_2mortal (newSVpvn ((const char *)surface2->pixels, surface2->h * surface2->pitch)));
1029	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)));
1030	PUSHs (sv_2mortal (newSViv (GL_RGBA)));	1245	PUSHs (sv_2mortal (newSViv (GL_RGBA)));
1031	PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));	1246	PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
1032	SDL_UnlockSurface (surface2);	1247	SDL_UnlockSurface (surface2);
1033		1248
…		…
1093	#if DEBUG	1308	#if DEBUG
1094	VALGRIND_DO_LEAK_CHECK;	1309	VALGRIND_DO_LEAK_CHECK;
1095	#endif	1310	#endif
1096	}	1311	}
1097		1312
		1313	int
		1314	SvREFCNT (SV *sv)
		1315	CODE:
		1316	RETVAL = SvREFCNT (sv);
		1317	OUTPUT:
		1318	RETVAL
		1319
1098	MODULE = Deliantra::Client PACKAGE = DC::Font	1320	MODULE = Deliantra::Client PACKAGE = DC::Font
1099		1321
1100	PROTOTYPES: DISABLE	1322	PROTOTYPES: DISABLE
1101		1323
1102	DC::Font	1324	DC::Font
1103	new_from_file (SV *class, char *path, int id = 0)	1325	new_from_file (SV *klass, char *path, int id = 0)
1104	CODE:	1326	CODE:
1105	{	1327	{
1106	int count;	1328	int count;
1107	FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);	1329	FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
1108	RETVAL = pango_fc_font_description_from_pattern (pattern, 0);	1330	RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
…		…
1137	PROTOTYPE:	1359	PROTOTYPE:
1138	CODE:	1360	CODE:
1139	tc_restore ();	1361	tc_restore ();
1140		1362
1141	DC::Layout	1363	DC::Layout
1142	new (SV *class)	1364	new (SV *klass)
1143	CODE:	1365	CODE:
1144	New (0, RETVAL, 1, struct cf_layout);	1366	New (0, RETVAL, 1, struct cf_layout);
1145		1367
1146	RETVAL->pl = pango_layout_new (opengl_context);	1368	RETVAL->pl = pango_layout_new (opengl_context);
1147	RETVAL->r = 1.;	1369	RETVAL->r = 1.;
…		…
1296		1518
1297	void	1519	void
1298	set_height (DC::Layout self, int base_height)	1520	set_height (DC::Layout self, int base_height)
1299	CODE:	1521	CODE:
1300	if (self->base_height != base_height)	1522	if (self->base_height != base_height)
1301	{	1523	{
1302	self->base_height = base_height;	1524	self->base_height = base_height;
1303	layout_update_font (self);	1525	layout_update_font (self);
1304	}	1526	}
1305		1527
1306	void	1528	void
…		…
1533	glDisable (GL_ALPHA_TEST);	1755	glDisable (GL_ALPHA_TEST);
1534	glDisable (GL_BLEND);	1756	glDisable (GL_BLEND);
1535	}	1757	}
1536	}	1758	}
1537		1759
		1760	void
		1761	draw_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)
		1762	PROTOTYPE: @
		1763	CODE:
		1764	{
		1765	glEnable (GL_BLEND);
		1766	glBlendFunc (intensity ? GL_SRC_ALPHA : GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
		1767	glEnable (GL_TEXTURE_2D);
		1768	glBindTexture (GL_TEXTURE_2D, name1);
		1769
		1770	glColor3f (intensity, intensity, intensity);
		1771	glPushMatrix ();
		1772	glScalef (1./3, 1./3, 1.);
		1773
		1774	if (blend > 0.f)
		1775	{
		1776	float dx3 = dx * -3.f / w;
		1777	float dy3 = dy * -3.f / h;
		1778	GLfloat env_color[4] = { 0., 0., 0., blend };
		1779
		1780	/* interpolate the two shadow textures */
		1781	/* stage 0 == rgb(glcolor) + alpha(t0) */
		1782	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
		1783
		1784	/* stage 1 == rgb(glcolor) + alpha(interpolate t0, t1, texenv) */
		1785	gl.ActiveTexture (GL_TEXTURE1);
		1786	glEnable (GL_TEXTURE_2D);
		1787	glBindTexture (GL_TEXTURE_2D, name2);
		1788	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
		1789
		1790	/* rgb == rgb(glcolor) */
		1791	glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
		1792	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
		1793	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
		1794
		1795	/* alpha = interpolate t0, t1 by env_alpha */
		1796	glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, env_color);
		1797
		1798	glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_INTERPOLATE);
		1799	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
		1800	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
		1801
		1802	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
		1803	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
		1804
		1805	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);
		1806	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);
		1807
		1808	glBegin (GL_QUADS);
		1809	gl.MultiTexCoord2f (GL_TEXTURE0, 0, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 ); glVertex2i (0, 0);
		1810	gl.MultiTexCoord2f (GL_TEXTURE0, 0, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 + t); glVertex2i (0, h);
		1811	gl.MultiTexCoord2f (GL_TEXTURE0, s, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 + t); glVertex2i (w, h);
		1812	gl.MultiTexCoord2f (GL_TEXTURE0, s, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 ); glVertex2i (w, 0);
		1813	glEnd ();
		1814
		1815	glDisable (GL_TEXTURE_2D);
		1816	gl.ActiveTexture (GL_TEXTURE0);
		1817	}
		1818	else
		1819	{
		1820	/* simple blending of one texture, also opengl <1.3 path */
		1821	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
		1822
		1823	glBegin (GL_QUADS);
		1824	glTexCoord2f (0, 0); glVertex2f (0, 0);
		1825	glTexCoord2f (0, t); glVertex2f (0, h);
		1826	glTexCoord2f (s, t); glVertex2f (w, h);
		1827	glTexCoord2f (s, 0); glVertex2f (w, 0);
		1828	glEnd ();
		1829	}
		1830
		1831	/* draw ?-marks or equivalent, this is very clumsy code :/ */
		1832	{
		1833	int x, y;
		1834	int dx3 = dx * 3;
		1835	int dy3 = dy * 3;
		1836
		1837	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
		1838	glBindTexture (GL_TEXTURE_2D, hidden_tex);
		1839	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		1840	glTranslatef (-1., -1., 0);
		1841	glBegin (GL_QUADS);
		1842
		1843	for (y = 1; y < h; y += 3)
		1844	{
		1845	int y1 = y - dy3;
		1846	int y1valid = y1 >= 0 && y1 < h;
		1847
		1848	for (x = 1; x < w; x += 3)
		1849	{
		1850	int x1 = x - dx3;
		1851	uint8_t h1 = data1 [x + y * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
		1852	uint8_t h2;
		1853
		1854	if (y1valid && x1 >= 0 && x1 < w)
		1855	h2 = data2 [x1 + y1 * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
		1856	else
		1857	h2 = 1; /* out of range == invisible */
		1858
		1859	if (h1 || h2)
		1860	{
		1861	float alpha = h1 == h2 ? 1.f : h1 ? 1.f - blend : blend;
		1862	glColor4f (1., 1., 1., alpha);
		1863
		1864	glTexCoord2f (0, 0.); glVertex2i (x , y );
		1865	glTexCoord2f (0, 1.); glVertex2i (x , y + 3);
		1866	glTexCoord2f (1, 1.); glVertex2i (x + 3, y + 3);
		1867	glTexCoord2f (1, 0.); glVertex2i (x + 3, y );
		1868	}
		1869	}
		1870	}
		1871	}
		1872
		1873	glEnd ();
		1874
		1875	glPopMatrix ();
		1876
		1877	glDisable (GL_TEXTURE_2D);
		1878	glDisable (GL_BLEND);
		1879	}
		1880
1538	IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)	1881	IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1539	CODE:	1882	CODE:
1540	{	1883	{
1541	GLint width;	1884	GLint width;
1542	glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);	1885	glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
…		…
1549	MODULE = Deliantra::Client PACKAGE = DC::Map	1892	MODULE = Deliantra::Client PACKAGE = DC::Map
1550		1893
1551	PROTOTYPES: DISABLE	1894	PROTOTYPES: DISABLE
1552		1895
1553	DC::Map	1896	DC::Map
1554	new (SV *class)	1897	new (SV *klass)
1555	CODE:	1898	CODE:
1556	New (0, RETVAL, 1, struct map);	1899	New (0, RETVAL, 1, struct map);
1557	RETVAL->x = 0;	1900	RETVAL->x = 0;
1558	RETVAL->y = 0;	1901	RETVAL->y = 0;
1559	RETVAL->w = 0;	1902	RETVAL->w = 0;
…		…
1598		1941
1599	void	1942	void
1600	set_smooth (DC::Map self, int face, int smooth, int level)	1943	set_smooth (DC::Map self, int face, int smooth, int level)
1601	CODE:	1944	CODE:
1602	{	1945	{
1603	tileid texid;	1946	tileid texid;
1604	maptex *tex;	1947	maptex *tex;
1605		1948
1606	if (face < 0 || face >= self->faces)	1949	if (face < 0 || face >= self->faces)
1607	return;	1950	return;
1608		1951
1609	if (smooth < 0 || smooth >= self->faces)	1952	if (smooth < 0 || smooth >= self->faces)
1610	return;	1953	return;
1611		1954
1612	texid = self->face2tile [face];	1955	texid = self->face2tile [face];
1613		1956
1614	if (!texid)	1957	if (!texid)
1615	return;	1958	return;
1616		1959
1617	tex = self->tex + texid;	1960	tex = self->tex + texid;
…		…
1646	//glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);	1989	//glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1647	// use uglier nearest interpolation because linear suffers	1990	// use uglier nearest interpolation because linear suffers
1648	// from transparent color bleeding and ugly wrapping effects.	1991	// from transparent color bleeding and ugly wrapping effects.
1649	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);	1992	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1650	}	1993	}
		1994
		1995	void
		1996	expire_textures (DC::Map self, int texid, int count)
		1997	PPCODE:
		1998	for (; texid < self->texs && count; ++texid, --count)
		1999	{
		2000	maptex *tex = self->tex + texid;
		2001
		2002	if (tex->name)
		2003	{
		2004	if (tex->unused)
		2005	{
		2006	tex->name = 0;
		2007	tex->unused = 0;
		2008	XPUSHs (sv_2mortal (newSViv (texid)));
		2009	}
		2010	else
		2011	tex->unused = 1;
		2012	}
		2013	}
1651		2014
1652	int	2015	int
1653	ox (DC::Map self)	2016	ox (DC::Map self)
1654	ALIAS:	2017	ALIAS:
1655	oy = 1	2018	oy = 1
…		…
1695	self->y += MAP_EXTEND_Y;	2058	self->y += MAP_EXTEND_Y;
1696	}	2059	}
1697	}	2060	}
1698		2061
1699	SV *	2062	SV *
1700	map1a_update (DC::Map self, SV *data_, int extmap)	2063	map1a_update (DC::Map self, SV *data_)
1701	CODE:	2064	CODE:
1702	{	2065	{
1703	uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);	2066	uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1704	uint8_t *data_end = (uint8_t *)SvEND (data_);	2067	uint8_t *data_end = (uint8_t *)SvEND (data_);
1705	mapcell *cell;	2068	mapcell *cell;
…		…
1726		2089
1727	//TODO: don't trust server data to be in-range(!)	2090	//TODO: don't trust server data to be in-range(!)
1728		2091
1729	if (flags & 8)	2092	if (flags & 8)
1730	{	2093	{
		2094	uint8_t ext, cmd;
		2095
1731	if (extmap)	2096	do
1732	{	2097	{
1733	uint8_t ext, cmd;	2098	ext = *data++;
		2099	cmd = ext & 0x7f;
1734		2100
1735	do	2101	if (cmd < 4)
		2102	cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
		2103	else if (cmd == 5) // health
1736	{	2104	{
1737	ext = *data++;
1738	cmd = ext & 0x7f;
1739
1740	if (cmd < 4)
1741	cell->darkness = 255 - ext * 64 + 1;
1742	else if (cmd == 5) // health
1743	{
1744	cell->stat_width = 1;	2105	cell->stat_width = 1;
1745	cell->stat_hp = *data++;	2106	cell->stat_hp = *data++;
1746	}
1747	else if (cmd == 6) // monster width
1748	cell->stat_width = *data++ + 1;
1749	else if (cmd == 0x47)
1750	{
1751	if (*data == 1) cell->player = data [1];
1752	else if (*data == 2) cell->player = data [2] + (data [1] << 8);
1753	else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
1754	else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
1755
1756	data += *data + 1;
1757	}
1758	else if (cmd == 8) // cell flags
1759	cell->flags = *data++;
1760	else if (ext & 0x40) // unknown, multibyte => skip
1761	data += *data + 1;
1762	else
1763	data++;
1764	}	2107	}
1765	while (ext & 0x80);	2108	else if (cmd == 6) // monster width
		2109	cell->stat_width = *data++ + 1;
		2110	else if (cmd == 0x47)
		2111	{
		2112	if (*data == 1) cell->player = data [1];
		2113	else if (*data == 2) cell->player = data [2] + (data [1] << 8);
		2114	else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
		2115	else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
		2116
		2117	data += *data + 1;
		2118	}
		2119	else if (cmd == 8) // cell flags
		2120	cell->flags = *data++;
		2121	else if (ext & 0x40) // unknown, multibyte => skip
		2122	data += *data + 1;
		2123	else
		2124	data++;
1766	}	2125	}
1767	else	2126	while (ext & 0x80);
1768	cell->darkness = *data++ + 1;
1769	}	2127	}
1770		2128
1771	for (z = 0; z <= 2; ++z)	2129	for (z = 0; z <= 2; ++z)
1772	if (flags & (4 >> z))	2130	if (flags & (4 >> z))
1773	{	2131	{
…		…
1776	cell->tile [z] = self->face2tile [face];	2134	cell->tile [z] = self->face2tile [face];
1777		2135
1778	if (cell->tile [z])	2136	if (cell->tile [z])
1779	{	2137	{
1780	maptex *tex = self->tex + cell->tile [z];	2138	maptex *tex = self->tex + cell->tile [z];
		2139	tex->unused = 0;
1781	if (!tex->name)	2140	if (!tex->name)
1782	av_push (missing, newSViv (cell->tile [z]));	2141	av_push (missing, newSViv (cell->tile [z]));
1783		2142
1784	if (tex->smoothtile)	2143	if (tex->smoothtile)
1785	{	2144	{
1786	maptex *smooth = self->tex + tex->smoothtile;	2145	maptex *smooth = self->tex + tex->smoothtile;
		2146	smooth->unused = 0;
1787	if (!smooth->name)	2147	if (!smooth->name)
1788	av_push (missing, newSViv (tex->smoothtile));	2148	av_push (missing, newSViv (tex->smoothtile));
1789	}	2149	}
1790	}	2150	}
1791	}	2151	}
…		…
1819	? self->row + y	2179	? self->row + y
1820	: 0;	2180	: 0;
1821		2181
1822	for (x = x0; x < x1; x++)	2182	for (x = x0; x < x1; x++)
1823	{	2183	{
1824	int r = 32, g = 32, b = 32, a = 192;	2184	unsigned int r = 32, g = 32, b = 32, a = 192;
1825		2185
1826	if (row && row->c0 <= x && x < row->c1)	2186	if (row && row->c0 <= x && x < row->c1)
1827	{	2187	{
1828	mapcell *cell = row->col + (x - row->c0);	2188	mapcell *cell = row->col + (x - row->c0);
1829		2189
…		…
1831	{	2191	{
1832	maptex tex = self->tex [cell->tile [z]];	2192	maptex tex = self->tex [cell->tile [z]];
1833	int a0 = 255 - tex.a;	2193	int a0 = 255 - tex.a;
1834	int a1 = tex.a;	2194	int a1 = tex.a;
1835		2195
1836	r = (r * a0 + tex.r * a1) / 255;	2196	r = div255 (r * a0 + tex.r * a1);
1837	g = (g * a0 + tex.g * a1) / 255;	2197	g = div255 (g * a0 + tex.g * a1);
1838	b = (b * a0 + tex.b * a1) / 255;	2198	b = div255 (b * a0 + tex.b * a1);
1839	a = (a * a0 + tex.a * a1) / 255;	2199	a = div255 (a * a0 + tex.a * a1);
1840	}	2200	}
1841	}	2201	}
1842		2202
1843	*map++ = (r )	2203	*map++ = (r )
1844	| (g << 8)	2204	| (g << 8)
1845	| (b << 16)	2205	| (b << 16)
1846	| (a << 24);	2206	| (a << 24);
1847	}	2207	}
1848	}	2208	}
1849		2209
1850	RETVAL = map_sv;	2210	RETVAL = map_sv;
1851	}	2211	}
1852	OUTPUT:	2212	OUTPUT:
1853	RETVAL	2213	RETVAL
1854		2214
1855	void	2215	void
1856	draw (DC::Map self, int mx, int my, int sw, int sh, int T, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)	2216	draw (DC::Map self, int mx, int my, int sw, int sh, int Tw, int Th, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)
1857	CODE:	2217	CODE:
1858	{	2218	{
1859	int x, y, z;	2219	int x, y, z;
1860		2220
1861	HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1862	uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level	2221	uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1863	static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k)	2222	static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k)
1864	smooth_key skey;	2223	smooth_key skey;
1865	int pl_x, pl_y;	2224	int pl_x, pl_y;
1866	maptex pl_tex;	2225	maptex pl_tex;
1867	rc_t *rc = rc_alloc ();	2226	rc_t *rc = rc_alloc ();
		2227	rc_t *rc_ov = rc_alloc ();
1868	rc_key_t key;	2228	rc_key_t key;
1869	rc_array_t *arr;	2229	rc_array_t *arr;
1870		2230
1871	pl_tex.name = 0;	2231	pl_tex.name = 0;
1872		2232
1873	// thats current max. sorry.	2233	// that's current max. sorry.
1874	if (sw > 255) sw = 255;	2234	if (sw > 255) sw = 255;
1875	if (sh > 255) sh = 255;	2235	if (sh > 255) sh = 255;
1876		2236
1877	// clear key, in case of extra padding	2237	// clear key, in case of extra padding
1878	memset (&skey, 0, sizeof (skey));	2238	memset (&skey, 0, sizeof (skey));
…		…
1882	key.g = 255;	2242	key.g = 255;
1883	key.b = 255;	2243	key.b = 255;
1884	key.a = 255;	2244	key.a = 255;
1885	key.mode = GL_QUADS;	2245	key.mode = GL_QUADS;
1886	key.format = GL_T2F_V3F;	2246	key.format = GL_T2F_V3F;
1887	key.texname = -1;
1888		2247
1889	mx += self->x;	2248	mx += self->x;
1890	my += self->y;	2249	my += self->y;
1891		2250
1892	// first pass: determine smooth_max	2251	// first pass: determine smooth_max
…		…
1915	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);	2274	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1916	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);	2275	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1917		2276
1918	for (z = 0; z <= 2; z++)	2277	for (z = 0; z <= 2; z++)
1919	{	2278	{
		2279	smooth_hash smooth;
1920	memset (smooth_level, 0, sizeof (smooth_level));	2280	memset (smooth_level, 0, sizeof (smooth_level));
		2281	key.texname = -1;
1921		2282
1922	for (y = 0; y < sh; y++)	2283	for (y = 0; y < sh; y++)
1923	if (0 <= y + my && y + my < self->rows)	2284	if (0 <= y + my && y + my < self->rows)
1924	{	2285	{
1925	maprow *row = self->row + (y + my);	2286	maprow *row = self->row + (y + my);
…		…
1931	tileid tile = cell->tile [z];	2292	tileid tile = cell->tile [z];
1932		2293
1933	if (tile)	2294	if (tile)
1934	{	2295	{
1935	maptex tex = self->tex [tile];	2296	maptex tex = self->tex [tile];
1936	int px = (x + 1) * T - tex.w;	2297	int px, py;
1937	int py = (y + 1) * T - tex.h;
1938		2298
1939	if (key.texname != tex.name)	2299	if (key.texname != tex.name)
1940	{	2300	{
		2301	self->tex [tile].unused = 0;
		2302
1941	if (!tex.name)	2303	if (!tex.name)
1942	tex = self->tex [2]; /* missing, replace by noface */	2304	tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
1943		2305
1944	key.texname = tex.name;	2306	key.texname = tex.name;
1945	arr = rc_array (rc, &key);	2307	arr = rc_array (rc, &key);
1946	}	2308	}
		2309
		2310	px = (x + 1) * Th - tex.w;
		2311	py = (y + 1) * Tw - tex.h;
1947		2312
1948	if (expect_false (cell->player == player) && expect_false (z == 2))	2313	if (expect_false (cell->player == player) && expect_false (z == 2))
1949	{	2314	{
1950	pl_x = px;	2315	pl_x = px;
1951	pl_y = py;	2316	pl_y = py;
…		…
1956	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);	2321	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
1957	rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);	2322	rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
1958	rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);	2323	rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
1959	rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);	2324	rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
1960		2325
1961	if (expect_false (cell->flags) && expect_false (z == 2))
1962	{
1963	// overlays such as the speech bubble, probably more to come
1964	if (cell->flags & 1)
1965	{
1966	maptex tex = self->tex [1];
1967	int px = x * T + T * 2 / 32;
1968	int py = y * T - T * 6 / 32;
1969
1970	if (tex.name)
1971	{
1972	if (key.texname != tex.name)
1973	{
1974	key.texname = tex.name;
1975	arr = rc_array (rc, &key);
1976	}
1977
1978	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
1979	rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
1980	rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
1981	rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
1982	}
1983	}
1984	}
1985
1986	// update smooth hash	2326	// update smooth hash
1987	if (tex.smoothtile)	2327	if (tex.smoothtile)
1988	{	2328	{
1989	skey.tile = tex.smoothtile;	2329	skey.tile = tex.smoothtile;
1990	skey.level = tex.smoothlevel;	2330	skey.level = tex.smoothlevel;
…		…
2005		2345
2006	// corners: 1 ┛· 2 ·┗ 4 ·· 8 ··	2346	// corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
2007	// ·· ·· ·┏ ┓·	2347	// ·· ·· ·┏ ┓·
2008		2348
2009	// full tile	2349	// full tile
2010	skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000);	2350	skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x1000);
2011		2351
2012	// borders	2352	// borders
2013	skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091);	2353	skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0091);
2014	skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032);	2354	skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0032);
2015	skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064);	2355	skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0064);
2016	skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8);	2356	skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, skey, 0x00c8);
2017		2357
2018	// corners	2358	// corners
2019	skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);	2359	skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0100);
2020	skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);	2360	skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0200);
2021	skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);	2361	skey.x = x ; skey.y = y ; smooth_or_bits (smooth, skey, 0x0400);
2022	skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);	2362	skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, skey, 0x0800);
		2363	}
		2364	}
		2365
		2366	if (expect_false (z == 2) && expect_false (cell->flags))
		2367	{
		2368	// overlays such as the speech bubble, probably more to come
		2369	if (cell->flags & 1)
		2370	{
		2371	rc_key_t key_ov = key;
		2372	maptex tex = self->tex [TEXID_SPEECH];
		2373	rc_array_t *arr;
		2374	int px = x * Tw + Tw * 2 / 32;
		2375	int py = y * Th - Th * 6 / 32;
		2376
		2377	key_ov.texname = tex.name;
		2378	arr = rc_array (rc_ov, &key_ov);
		2379
		2380	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
		2381	rc_t2f_v3f (arr, 0 , tex.t, px , py + Th, 0);
		2382	rc_t2f_v3f (arr, tex.s, tex.t, px + Tw, py + Th, 0);
		2383	rc_t2f_v3f (arr, tex.s, 0 , px + Tw, py , 0);
2023	}	2384	}
2024	}	2385	}
2025	}	2386	}
2026	}	2387	}
2027		2388
…		…
2043	if (smask & (((uint32_t)1) << b))	2404	if (smask & (((uint32_t)1) << b))
2044	{	2405	{
2045	int level = (w << 5) | b;	2406	int level = (w << 5) | b;
2046	HE *he;	2407	HE *he;
2047		2408
2048	hv_iterinit (smooth);	2409	for (auto &&it = smooth.begin (); it != smooth.end (); ++it)
2049	while ((he = hv_iternext (smooth)))
2050	{	2410	{
2051	smooth_key *skey = (smooth_key *)HeKEY (he);	2411	smooth_key &skey = it->first;
2052	IV bits = SvIVX (HeVAL (he));	2412	IV bits = it->second;
2053		2413
2054	if (!(bits & 0x1000)	2414	if (!(bits & 0x1000)
2055	&& skey->level == level	2415	&& skey.level == level
2056	&& level > smooth_max [skey->x][skey->y])	2416	&& level > smooth_max [skey.x][skey.y])
2057	{	2417	{
2058	maptex tex = self->tex [skey->tile];	2418	maptex tex = self->tex [skey.tile];
2059	int px = (((int)skey->x) - 1) * T;	2419	int px = (((int)skey.x) - 1) * Tw;
2060	int py = (((int)skey->y) - 1) * T;	2420	int py = (((int)skey.y) - 1) * Th;
2061	int border = bits & 15;	2421	int border = bits & 15;
2062	int corner = (bits >> 8) & ~(bits >> 4) & 15;	2422	int corner = (bits >> 8) & ~(bits >> 4) & 15;
2063	float dx = tex.s * .0625f; // 16 images/row	2423	float dx = tex.s * .0625f; // 16 images/row
2064	float dy = tex.t * .5f ; // 2 images/column	2424	float dy = tex.t * .5f ; // 2 images/column
2065		2425
…		…
2067	{	2427	{
2068	// this time avoiding texture state changes	2428	// this time avoiding texture state changes
2069	// save gobs of state changes.	2429	// save gobs of state changes.
2070	if (key.texname != tex.name)	2430	if (key.texname != tex.name)
2071	{	2431	{
		2432	self->tex [skey.tile].unused = 0;
		2433
2072	glEnd ();	2434	glEnd ();
2073	glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);	2435	glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
2074	glBegin (GL_QUADS);	2436	glBegin (GL_QUADS);
2075	}	2437	}
2076		2438
2077	if (border)	2439	if (border)
2078	{	2440	{
2079	float ox = border * dx;	2441	float ox = border * dx;
2080		2442
2081	glTexCoord2f (ox , 0.f ); glVertex2i (px , py );	2443	glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
2082	glTexCoord2f (ox , dy ); glVertex2i (px , py + T);	2444	glTexCoord2f (ox , dy ); glVertex2i (px , py + Th);
2083	glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T);	2445	glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py + Th);
2084	glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py );	2446	glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + Tw, py );
2085	}	2447	}
2086		2448
2087	if (corner)	2449	if (corner)
2088	{	2450	{
2089	float ox = corner * dx;	2451	float ox = corner * dx;
2090		2452
2091	glTexCoord2f (ox , dy ); glVertex2i (px , py );	2453	glTexCoord2f (ox , dy ); glVertex2i (px , py );
2092	glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T);	2454	glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + Th);
2093	glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T);	2455	glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + Tw, py + Th);
2094	glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py );	2456	glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py );
2095	}	2457	}
2096	}	2458	}
2097	}	2459	}
2098	}	2460	}
2099	}	2461	}
…		…
2101		2463
2102	glEnd ();	2464	glEnd ();
2103	glDisable (GL_TEXTURE_2D);	2465	glDisable (GL_TEXTURE_2D);
2104	key.texname = -1;	2466	key.texname = -1;
2105	}	2467	}
2106
2107	hv_clear (smooth);
2108	}	2468	}
2109		2469
2110	if (pl_tex.name)	2470	if (pl_tex.name)
2111	{	2471	{
2112	maptex tex = pl_tex;	2472	maptex tex = pl_tex;
…		…
2122	rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);	2482	rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
2123		2483
2124	rc_draw (rc);	2484	rc_draw (rc);
2125	}	2485	}
2126		2486
		2487	rc_draw (rc_ov);
		2488	rc_clear (rc_ov);
		2489
2127	glDisable (GL_BLEND);	2490	glDisable (GL_BLEND);
2128	rc_free (rc);	2491	rc_free (rc);
		2492	rc_free (rc_ov);
2129		2493
2130	// top layer: overlays such as the health bar	2494	// top layer: overlays such as the health bar
2131	for (y = 0; y < sh; y++)	2495	for (y = 0; y < sh; y++)
2132	if (0 <= y + my && y + my < self->rows)	2496	if (0 <= y + my && y + my < self->rows)
2133	{	2497	{
…		…
2136	for (x = 0; x < sw; x++)	2500	for (x = 0; x < sw; x++)
2137	if (row->c0 <= x + mx && x + mx < row->c1)	2501	if (row->c0 <= x + mx && x + mx < row->c1)
2138	{	2502	{
2139	mapcell *cell = row->col + (x + mx - row->c0);	2503	mapcell *cell = row->col + (x + mx - row->c0);
2140		2504
2141	int px = x * T;	2505	int px = x * Tw;
2142	int py = y * T;	2506	int py = y * Th;
		2507
		2508	if (expect_false (cell->player == player))
		2509	{
		2510	px += sdx;
		2511	py += sdy;
		2512	}
2143		2513
2144	if (cell->stat_hp)	2514	if (cell->stat_hp)
2145	{	2515	{
2146	int width = cell->stat_width * T;	2516	int width = cell->stat_width * Tw;
2147	int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;	2517	int thick = (sh * Th / 32 + 27) / 28 + 1 + cell->stat_width;
2148		2518
2149	glColor3ub (0, 0, 0);	2519	glColor3ub (0, 0, 0);
2150	glRectf (px + 1, py - thick - 2,	2520	glRectf (px + 1, py - thick - 2,
2151	px + width - 1, py);	2521	px + width - 1, py);
2152		2522
…		…
2158	}	2528	}
2159	}	2529	}
2160	}	2530	}
2161		2531
2162	void	2532	void
2163	draw_magicmap (DC::Map self, int dx, int dy, int w, int h, unsigned char *data)	2533	draw_magicmap (DC::Map self, int w, int h, unsigned char *data)
2164	CODE:	2534	CODE:
2165	{	2535	{
2166	static float color[16][3] = {	2536	static float color[16][3] = {
2167	{ 0.00F, 0.00F, 0.00F },	2537	{ 0.00f, 0.00f, 0.00f },
2168	{ 1.00F, 1.00F, 1.00F },	2538	{ 1.00f, 1.00f, 1.00f },
2169	{ 0.00F, 0.00F, 0.55F },	2539	{ 0.00f, 0.00f, 0.55f },
2170	{ 1.00F, 0.00F, 0.00F },	2540	{ 1.00f, 0.00f, 0.00f },
2171		2541
2172	{ 1.00F, 0.54F, 0.00F },	2542	{ 1.00f, 0.54f, 0.00f },
2173	{ 0.11F, 0.56F, 1.00F },	2543	{ 0.11f, 0.56f, 1.00f },
2174	{ 0.93F, 0.46F, 0.00F },	2544	{ 0.93f, 0.46f, 0.00f },
2175	{ 0.18F, 0.54F, 0.34F },	2545	{ 0.18f, 0.54f, 0.34f },
2176		2546
2177	{ 0.56F, 0.73F, 0.56F },	2547	{ 0.56f, 0.73f, 0.56f },
2178	{ 0.80F, 0.80F, 0.80F },	2548	{ 0.80f, 0.80f, 0.80f },
2179	{ 0.55F, 0.41F, 0.13F },	2549	{ 0.55f, 0.41f, 0.13f },
2180	{ 0.99F, 0.77F, 0.26F },	2550	{ 0.99f, 0.77f, 0.26f },
2181		2551
2182	{ 0.74F, 0.65F, 0.41F },	2552	{ 0.74f, 0.65f, 0.41f },
2183		2553
2184	{ 0.00F, 1.00F, 1.00F },	2554	{ 0.00f, 1.00f, 1.00f },
2185	{ 1.00F, 0.00F, 1.00F },	2555	{ 1.00f, 0.00f, 1.00f },
2186	{ 1.00F, 1.00F, 0.00F },	2556	{ 1.00f, 1.00f, 0.00f },
2187	};	2557	};
2188		2558
2189	int x, y;	2559	int x, y;
2190		2560
2191	glEnable (GL_TEXTURE_2D);	2561	glEnable (GL_TEXTURE_2D);
		2562	/* GL_REPLACE would be correct, as we don't need to modulate alpha,
		2563	* but the nvidia driver (185.18.14) mishandles alpha textures
		2564	* and takes the colour from god knows where instead of using
		2565	* Cp. MODULATE results in the same colour, but slightly different
		2566	* alpha, but atcually gives us the correct colour with nvidia.
		2567	*/
2192	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);	2568	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
2193	glEnable (GL_BLEND);	2569	glEnable (GL_BLEND);
2194	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);	2570	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2195	glBegin (GL_QUADS);	2571	glBegin (GL_QUADS);
2196		2572
2197	for (y = 0; y < h; y++)	2573	for (y = 0; y < h; y++)
…		…
2201		2577
2202	if (m)	2578	if (m)
2203	{	2579	{
2204	float *c = color [m & 15];	2580	float *c = color [m & 15];
2205		2581
2206	float tx1 = m & 0x40 ? 0.5 : 0.;	2582	float tx1 = m & 0x40 ? 0.5f : 0.f;
2207	float tx2 = tx1 + 0.5;	2583	float tx2 = tx1 + 0.5f;
2208		2584
2209	glColor4f (c[0], c[1], c[2], 0.75);	2585	glColor4f (c[0], c[1], c[2], 1);
2210	glTexCoord2f (tx1, 0.); glVertex2i (x , y );	2586	glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2211	glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);	2587	glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2212	glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);	2588	glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2213	glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );	2589	glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2214	}	2590	}
…		…
2222	void	2598	void
2223	fow_texture (DC::Map self, int mx, int my, int sw, int sh)	2599	fow_texture (DC::Map self, int mx, int my, int sw, int sh)
2224	PPCODE:	2600	PPCODE:
2225	{	2601	{
2226	int x, y;	2602	int x, y;
2227	int sw1 = sw + 2;	2603	int sw1 = sw + 2;
2228	int sh1 = sh + 2;	2604	int sh1 = sh + 2;
2229	int sh3 = sh * 3;	2605	int sh3 = sh * 3;
2230	int sw34 = (sw * 3 + 3) & ~3;	2606	int sw3 = sw * 3;
		2607	SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3));
		2608	uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2231	uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);	2609	uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2232	SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));	2610	memset (darkness1, 0, sw1*sh1);
2233	uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2234		2611
2235	SvPOK_only (darkness3_sv);	2612	SvPOK_only (darkness3_sv);
2236	SvCUR_set (darkness3_sv, sw34 * sh3);	2613	SvCUR_set (darkness3_sv, sw3 * sh3);
2237		2614
2238	mx += self->x - 1;	2615	mx += self->x - 1;
2239	my += self->y - 1;	2616	my += self->y - 1;
2240
2241	memset (darkness1, 255 - FOW_DARKNESS, sw1 * sh1);
2242		2617
2243	for (y = 0; y < sh1; y++)	2618	for (y = 0; y < sh1; y++)
2244	if (0 <= y + my && y + my < self->rows)	2619	if (0 <= y + my && y + my < self->rows)
2245	{	2620	{
2246	maprow *row = self->row + (y + my);	2621	maprow *row = self->row + (y + my);
…		…
2249	if (row->c0 <= x + mx && x + mx < row->c1)	2624	if (row->c0 <= x + mx && x + mx < row->c1)
2250	{	2625	{
2251	mapcell *cell = row->col + (x + mx - row->c0);	2626	mapcell *cell = row->col + (x + mx - row->c0);
2252		2627
2253	darkness1 [y * sw1 + x] = cell->darkness	2628	darkness1 [y * sw1 + x] = cell->darkness
2254	? 255 - (cell->darkness - 1)	2629	? DARKNESS_ADJUST (255 - (cell->darkness - 1))
2255	: 255 - FOW_DARKNESS;	2630	: DARKNESS_ADJUST (255 - FOW_DARKNESS);
2256	}	2631	}
2257	}	2632	}
2258		2633
2259	for (y = 0; y < sh; ++y)	2634	for (y = 0; y < sh; ++y)
2260	for (x = 0; x < sw; ++x)	2635	for (x = 0; x < sw; ++x)
…		…
2279		2654
2280	uint8_t r13 = (d13 + d23 + d12) / 3;	2655	uint8_t r13 = (d13 + d23 + d12) / 3;
2281	uint8_t r23 = d23;	2656	uint8_t r23 = d23;
2282	uint8_t r33 = (d23 + d33 + d32) / 3;	2657	uint8_t r33 = (d23 + d33 + d32) / 3;
2283		2658
2284	darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11);	2659	darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2285	darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21);	2660	darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2286	darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31);	2661	darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2287	darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12);	2662	darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2288	darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22);	2663	darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 1)] = MAX (d22, r22); /* this MUST be == d22 */
2289	darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32);	2664	darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2290	darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13);	2665	darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2291	darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23);	2666	darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2292	darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33);	2667	darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2293	}	2668	}
2294		2669
2295	free (darkness1);	2670	free (darkness1);
2296		2671
2297	EXTEND (SP, 3);	2672	EXTEND (SP, 3);
2298	PUSHs (sv_2mortal (newSViv (sw34)));	2673	PUSHs (sv_2mortal (newSViv (sw3)));
2299	PUSHs (sv_2mortal (newSViv (sh3)));	2674	PUSHs (sv_2mortal (newSViv (sh3)));
2300	PUSHs (darkness3_sv);	2675	PUSHs (darkness3_sv);
2301	}	2676	}
2302		2677
2303	SV *	2678	SV *
…		…
2366	else	2741	else
2367	*data++ = 0;	2742	*data++ = 0;
2368	}	2743	}
2369	}	2744	}
2370		2745
2371	/* if size is w*h + 5 then no data has been found */	2746	/* if size is w*h + 5 then no data has been found */
2372	if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5)	2747	if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5)
2373	{	2748	{
2374	SvPOK_only (data_sv);	2749	SvPOK_only (data_sv);
2375	SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));	2750	SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2376	}	2751	}
2377		2752
2378	RETVAL = data_sv;	2753	RETVAL = data_sv;
2379	}	2754	}
2380	OUTPUT:	2755	OUTPUT:
2381	RETVAL	2756	RETVAL
2382		2757
2383	void	2758	void
…		…
2390	STRLEN len;	2765	STRLEN len;
2391	uint8_t *data, *end;	2766	uint8_t *data, *end;
2392		2767
2393	len = SvLEN (data_sv);	2768	len = SvLEN (data_sv);
2394	SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more	2769	SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more
2395	data = SvPVbyte_nolen (data_sv);	2770	data = (uint8_t *)SvPVbyte_nolen (data_sv);
2396	end = data + len + 8;	2771	end = data + len + 8;
2397		2772
2398	if (len < 5)	2773	if (len < 5)
2399	XSRETURN_EMPTY;	2774	XSRETURN_EMPTY;
2400		2775
…		…
2461	}	2836	}
2462		2837
2463	MODULE = Deliantra::Client PACKAGE = DC::RW	2838	MODULE = Deliantra::Client PACKAGE = DC::RW
2464		2839
2465	DC::RW	2840	DC::RW
2466	new (SV *class, SV *data_sv)	2841	new (SV *klass, SV *data_sv)
2467	CODE:	2842	CODE:
2468	{	2843	{
2469	STRLEN datalen;	2844	STRLEN datalen;
2470	char *data = SvPVbyte (data_sv, datalen);	2845	char *data = SvPVbyte (data_sv, datalen);
2471		2846
…		…
2473	}	2848	}
2474	OUTPUT:	2849	OUTPUT:
2475	RETVAL	2850	RETVAL
2476		2851
2477	DC::RW	2852	DC::RW
2478	new_from_file (SV *class, const char *path, const char *mode = "rb")	2853	new_from_file (SV *klass, const char *path, const char *mode = "rb")
2479	CODE:	2854	CODE:
2480	RETVAL = SDL_RWFromFile (path, mode);	2855	RETVAL = SDL_RWFromFile (path, mode);
2481	OUTPUT:	2856	OUTPUT:
2482	RETVAL	2857	RETVAL
2483		2858
…		…
2501	if (RETVAL < 0)	2876	if (RETVAL < 0)
2502	{	2877	{
2503	RETVAL = Mix_GroupOldest (-1);	2878	RETVAL = Mix_GroupOldest (-1);
2504		2879
2505	if (RETVAL < 0)	2880	if (RETVAL < 0)
		2881	{
		2882	// happens sometimes, maybe it just stopped playing(?)
		2883	RETVAL = Mix_GroupAvailable (-1);
		2884
		2885	if (RETVAL < 0)
2506	XSRETURN_UNDEF;	2886	XSRETURN_UNDEF;
2507		2887	}
		2888	else
2508	Mix_HaltChannel (RETVAL);	2889	Mix_HaltChannel (RETVAL);
2509	}	2890	}
2510		2891
2511	Mix_UnregisterAllEffects (RETVAL);	2892	Mix_UnregisterAllEffects (RETVAL);
2512	Mix_Volume (RETVAL, 128);	2893	Mix_Volume (RETVAL, 128);
2513	}	2894	}
…		…
2560	void	2941	void
2561	set_position_r (DC::Channel self, int dx, int dy, int maxdistance)	2942	set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2562	CODE:	2943	CODE:
2563	{	2944	{
2564	int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));	2945	int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2565	int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI);	2946	int angle = atan2f (dx, -dy) * 180.f / (float)M_PI + 360.f;
2566	Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));	2947	Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2567	}	2948	}
2568		2949
2569	void	2950	void
2570	set_reverse_stereo (DC::Channel self, int flip)	2951	set_reverse_stereo (DC::Channel self, int flip)
…		…
2573		2954
2574	MODULE = Deliantra::Client PACKAGE = DC::MixChunk	2955	MODULE = Deliantra::Client PACKAGE = DC::MixChunk
2575		2956
2576	PROTOTYPES: DISABLE	2957	PROTOTYPES: DISABLE
2577		2958
		2959	void
		2960	decoders ()
		2961	PPCODE:
		2962	#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
		2963	int i, num = Mix_GetNumChunkDecoders ();
		2964	EXTEND (SP, num);
		2965	for (i = 0; i < num; ++i)
		2966	PUSHs (sv_2mortal (newSVpv (Mix_GetChunkDecoder (i), 0)));
		2967	#else
		2968	XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
		2969	#endif
		2970
2578	DC::MixChunk	2971	DC::MixChunk
2579	new (SV *class, DC::RW rwops)	2972	new (SV *klass, DC::RW rwops)
2580	CODE:	2973	CODE:
2581	RETVAL = Mix_LoadWAV_RW (rwops, 1);	2974	RETVAL = Mix_LoadWAV_RW (rwops, 1);
2582	OUTPUT:	2975	OUTPUT:
2583	RETVAL	2976	RETVAL
2584		2977
…		…
2614	OUTPUT:	3007	OUTPUT:
2615	RETVAL	3008	RETVAL
2616		3009
2617	MODULE = Deliantra::Client PACKAGE = DC::MixMusic	3010	MODULE = Deliantra::Client PACKAGE = DC::MixMusic
2618		3011
		3012	void
		3013	decoders ()
		3014	PPCODE:
		3015	#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
		3016	int i, num = Mix_GetNumMusicDecoders ();
		3017	EXTEND (SP, num);
		3018	for (i = 0; i < num; ++i)
		3019	PUSHs (sv_2mortal (newSVpv (Mix_GetMusicDecoder (i), 0)));
		3020	#else
		3021	XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
		3022	#endif
		3023
2619	int	3024	int
2620	volume (int volume = -1)	3025	volume (int volume = -1)
2621	PROTOTYPE: ;$	3026	PROTOTYPE: ;$
2622	CODE:	3027	CODE:
2623	if (items > 0)	3028	if (items > 0)
…		…
2634	void	3039	void
2635	halt ()	3040	halt ()
2636	CODE:	3041	CODE:
2637	Mix_HaltMusic ();	3042	Mix_HaltMusic ();
2638		3043
		3044	int
		3045	playing ()
		3046	CODE:
		3047	RETVAL = Mix_PlayingMusic ();
		3048	OUTPUT:
		3049	RETVAL
		3050
2639	DC::MixMusic	3051	DC::MixMusic
2640	new (SV *class, DC::RW rwops)	3052	new (SV *klass, DC::RW rwops)
2641	CODE:	3053	CODE:
2642	RETVAL = Mix_LoadMUS_RW (rwops);	3054	RETVAL = Mix_LoadMUS_RW (rwops);
2643	OUTPUT:	3055	OUTPUT:
2644	RETVAL	3056	RETVAL
2645		3057
…		…
2673	} *civ, const_iv[] = {	3085	} *civ, const_iv[] = {
2674	# define const_iv(name) { # name, (IV)name }	3086	# define const_iv(name) { # name, (IV)name }
2675	const_iv (GL_VENDOR),	3087	const_iv (GL_VENDOR),
2676	const_iv (GL_VERSION),	3088	const_iv (GL_VERSION),
2677	const_iv (GL_EXTENSIONS),	3089	const_iv (GL_EXTENSIONS),
		3090	const_iv (GL_MAX_TEXTURE_UNITS),
2678	const_iv (GL_COLOR_MATERIAL),	3091	const_iv (GL_COLOR_MATERIAL),
2679	const_iv (GL_SMOOTH),	3092	const_iv (GL_SMOOTH),
2680	const_iv (GL_FLAT),	3093	const_iv (GL_FLAT),
2681	const_iv (GL_DITHER),	3094	const_iv (GL_DITHER),
2682	const_iv (GL_BLEND),	3095	const_iv (GL_BLEND),
…		…
2694	const_iv (GL_ZERO),	3107	const_iv (GL_ZERO),
2695	const_iv (GL_SRC_ALPHA),	3108	const_iv (GL_SRC_ALPHA),
2696	const_iv (GL_DST_ALPHA),	3109	const_iv (GL_DST_ALPHA),
2697	const_iv (GL_ONE_MINUS_SRC_ALPHA),	3110	const_iv (GL_ONE_MINUS_SRC_ALPHA),
2698	const_iv (GL_ONE_MINUS_DST_ALPHA),	3111	const_iv (GL_ONE_MINUS_DST_ALPHA),
		3112	const_iv (GL_SRC_COLOR),
		3113	const_iv (GL_DST_COLOR),
		3114	const_iv (GL_ONE_MINUS_SRC_COLOR),
		3115	const_iv (GL_ONE_MINUS_DST_COLOR),
2699	const_iv (GL_SRC_ALPHA_SATURATE),	3116	const_iv (GL_SRC_ALPHA_SATURATE),
2700	const_iv (GL_RGB),	3117	const_iv (GL_RGB),
2701	const_iv (GL_RGBA),	3118	const_iv (GL_RGBA),
2702	const_iv (GL_RGBA4),	3119	const_iv (GL_RGBA4),
2703	const_iv (GL_RGBA8),	3120	const_iv (GL_RGBA8),
…		…
2771	const_iv (GL_NICEST),	3188	const_iv (GL_NICEST),
2772	const_iv (GL_V2F),	3189	const_iv (GL_V2F),
2773	const_iv (GL_V3F),	3190	const_iv (GL_V3F),
2774	const_iv (GL_T2F_V3F),	3191	const_iv (GL_T2F_V3F),
2775	const_iv (GL_T2F_N3F_V3F),	3192	const_iv (GL_T2F_N3F_V3F),
		3193	const_iv (GL_FUNC_ADD),
		3194	const_iv (GL_FUNC_SUBTRACT),
		3195	const_iv (GL_FUNC_REVERSE_SUBTRACT),
2776	# undef const_iv	3196	# undef const_iv
2777	};	3197	};
2778		3198
2779	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	3199	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
2780	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	3200	newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
2781		3201
2782	texture_av = newAV ();	3202	texture_av = newAV ();
2783	AvREAL_off (texture_av);	3203	AvREAL_off (texture_av);
2784	}	3204	}
2785		3205
…		…
2787	disable_GL_EXT_blend_func_separate ()	3207	disable_GL_EXT_blend_func_separate ()
2788	CODE:	3208	CODE:
2789	gl.BlendFuncSeparate = 0;	3209	gl.BlendFuncSeparate = 0;
2790	gl.BlendFuncSeparateEXT = 0;	3210	gl.BlendFuncSeparateEXT = 0;
2791		3211
2792	char *	3212	void
		3213	apple_nvidia_bug (int enable)
		3214
		3215	const char *
2793	gl_vendor ()	3216	gl_vendor ()
2794	CODE:	3217	CODE:
2795	RETVAL = (char *)glGetString (GL_VENDOR);	3218	RETVAL = (const char *)glGetString (GL_VENDOR);
2796	OUTPUT:	3219	OUTPUT:
2797	RETVAL	3220	RETVAL
2798		3221
2799	char *	3222	const char *
2800	gl_version ()	3223	gl_version ()
2801	CODE:	3224	CODE:
2802	RETVAL = (char *)glGetString (GL_VERSION);	3225	RETVAL = (const char *)glGetString (GL_VERSION);
2803	OUTPUT:	3226	OUTPUT:
2804	RETVAL	3227	RETVAL
2805		3228
2806	char *	3229	const char *
2807	gl_extensions ()	3230	gl_extensions ()
2808	CODE:	3231	CODE:
2809	RETVAL = (char *)glGetString (GL_EXTENSIONS);	3232	RETVAL = (const char *)glGetString (GL_EXTENSIONS);
2810	OUTPUT:	3233	OUTPUT:
2811	RETVAL	3234	RETVAL
2812		3235
2813	const char *glGetString (GLenum pname)	3236	const char *glGetString (GLenum pname)
		3237	CODE:
		3238	RETVAL = (const char *)glGetString (pname);
		3239	OUTPUT:
		3240	RETVAL
2814		3241
2815	GLint glGetInteger (GLenum pname)	3242	GLint glGetInteger (GLenum pname)
2816	CODE:	3243	CODE:
2817	glGetIntegerv (pname, &RETVAL);	3244	glGetIntegerv (pname, &RETVAL);
2818	OUTPUT:	3245	OUTPUT:
…		…
2826		3253
2827	int glGetError ()	3254	int glGetError ()
2828		3255
2829	void glFinish ()	3256	void glFinish ()
2830		3257
		3258	void glFlush ()
		3259
2831	void glClear (int mask)	3260	void glClear (int mask)
2832		3261
2833	void glClearColor (float r, float g, float b, float a = 1.0)	3262	void glClearColor (float r, float g, float b, float a = 1.0)
2834	PROTOTYPE: @	3263	PROTOTYPE: @
2835		3264
…		…
2844	void glBlendFunc (int sfactor, int dfactor)	3273	void glBlendFunc (int sfactor, int dfactor)
2845		3274
2846	void glBlendFuncSeparate (int sa, int da, int saa, int daa)	3275	void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2847	CODE:	3276	CODE:
2848	gl_BlendFuncSeparate (sa, da, saa, daa);	3277	gl_BlendFuncSeparate (sa, da, saa, daa);
		3278
		3279	# void glBlendEquation (int se)
2849		3280
2850	void glDepthMask (int flag)	3281	void glDepthMask (int flag)
2851		3282
2852	void glLogicOp (int opcode)	3283	void glLogicOp (int opcode)
2853		3284
…		…
2888	void glRotate (float angle, float x, float y, float z)	3319	void glRotate (float angle, float x, float y, float z)
2889	CODE:	3320	CODE:
2890	glRotatef (angle, x, y, z);	3321	glRotatef (angle, x, y, z);
2891		3322
2892	void glColor (float r, float g, float b, float a = 1.0)	3323	void glColor (float r, float g, float b, float a = 1.0)
		3324	PROTOTYPE: @
2893	ALIAS:	3325	ALIAS:
2894	glColor_premultiply = 1	3326	glColor_premultiply = 1
2895	CODE:	3327	CODE:
2896	if (ix)	3328	if (ix)
2897	{	3329	{
…		…
3003		3435
3004	void glEndList ()	3436	void glEndList ()
3005		3437
3006	void glCallList (int list)	3438	void glCallList (int list)
3007		3439
		3440	void c_init ()
		3441	CODE:
		3442	glPixelStorei (GL_PACK_ALIGNMENT , 1);
		3443	glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
		3444
3008	MODULE = Deliantra::Client PACKAGE = DC::UI::Base	3445	MODULE = Deliantra::Client PACKAGE = DC::UI::Base
3009		3446
3010	PROTOTYPES: DISABLE	3447	PROTOTYPES: DISABLE
3011		3448
3012	void	3449	void
3013	find_widget (SV *self, NV x, NV y)	3450	find_widget (SV *self, NV x, NV y)
3014	PPCODE:	3451	PPCODE:
3015	{	3452	{
3016	if (within_widget (self, x, y))	3453	if (within_widget (self, x, y))
3017	XPUSHs (self);	3454	XPUSHs (self);
3018	}	3455	}
3019		3456
3020	BOOT:	3457	BOOT:
3021	{	3458	{
…		…
3029		3466
3030	void	3467	void
3031	draw (SV *self)	3468	draw (SV *self)
3032	CODE:	3469	CODE:
3033	{	3470	{
3034	HV *hv;	3471	HV *hv;
3035	SV **svp;	3472	SV **svp;
3036	NV x, y, w, h;	3473	NV x, y, w, h;
3037	SV *draw_x_sv = GvSV (draw_x_gv);	3474	SV *draw_x_sv = GvSV (draw_x_gv);
3038	SV *draw_y_sv = GvSV (draw_y_gv);	3475	SV *draw_y_sv = GvSV (draw_y_gv);
3039	SV *draw_w_sv = GvSV (draw_w_gv);	3476	SV *draw_w_sv = GvSV (draw_w_gv);
3040	SV *draw_h_sv = GvSV (draw_h_gv);	3477	SV *draw_h_sv = GvSV (draw_h_gv);

Diff Legend

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