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.294 by root, Sat Dec 19 05:06:56 2009 UTC vs.
Revision 1.330 by root, Sun Nov 18 15:24:24 2018 UTC

…		…
15		15
16	#include "EXTERN.h"	16	#include "EXTERN.h"
17	#include "perl.h"	17	#include "perl.h"
18	#include "XSUB.h"	18	#include "XSUB.h"
19		19
		20	#include "flat_hash_map.hpp"
		21
20	#ifdef _WIN32	22	#ifdef _WIN32
21	# undef pipe	23	# undef pipe
22	// microsoft vs. C	24	// microsoft vs. C
23	# define sqrtf(x) sqrt(x)	25	# define sqrtf(x) sqrt(x)
24	# define roundf(x) (int)(x)
25	# define atan2f(x,y) atan2(x,y)	26	# define atan2f(x,y) atan2(x,y)
26	# define M_PI 3.14159265f	27	# define M_PI 3.14159265f
27	#endif	28	#endif
28		29
29	#include <assert.h>	30	#include <cassert>
30	#include <math.h>	31	#include <cmath>
31	#include <string.h>	32	#include <cstring>
32	#include <stdio.h>	33	#include <cstdio>
33	#include <stdlib.h>	34	#include <cstdlib>
		35
		36	#include <utility>
		37	#include <bitset>
34		38
35	#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW	39	#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
36		40
37	#include <SDL.h>	41	#include <SDL.h>
38	#include <SDL_thread.h>	42	#include <SDL_thread.h>
…		…
42	#include <SDL_opengl.h>	46	#include <SDL_opengl.h>
43		47
44	/* work around os x broken headers */	48	/* work around os x broken headers */
45	#ifdef __MACOSX__	49	#ifdef __MACOSX__
46	typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);	50	typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
		51	typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture);
		52	typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t);
47	#endif	53	#endif
48		54
49	#define PANGO_ENABLE_BACKEND	55	#define PANGO_ENABLE_BACKEND
50	#define G_DISABLE_CAST_CHECKS	56	#define G_DISABLE_CAST_CHECKS
51		57
52	#include <glib/gmacros.h>	58	#include <glib.h>
53		59
54	#include <pango/pango.h>	60	#include <pango/pango.h>
55		61
56	#ifndef PANGO_VERSION_CHECK	62	#ifndef PANGO_VERSION_CHECK
57	# define PANGO_VERSION_CHECK(a,b,c) 0	63	# define PANGO_VERSION_CHECK(a,b,c) 0
…		…
81	#define expect_false(expr) expect ((expr) != 0, 0)	87	#define expect_false(expr) expect ((expr) != 0, 0)
82	#define expect_true(expr) expect ((expr) != 0, 1)	88	#define expect_true(expr) expect ((expr) != 0, 1)
83		89
84	#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */	90	#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
85		91
		92	/* this is used as fow flag as well, so has to have a different value */
		93	/* then anything that is computed by incoming darkness */
86	#define FOW_DARKNESS 64	94	#define FOW_DARKNESS 50
87	#define DARKNESS_ADJUST(n) ((29 * (int)(n)) >> 5) /* times 0.9 */	95	#define DARKNESS_ADJUST(n) (n)
88		96
89	#define MAP_EXTEND_X 32	97	#define MAP_EXTEND_X 32
90	#define MAP_EXTEND_Y 512	98	#define MAP_EXTEND_Y 512
91		99
92	#define MIN_FONT_HEIGHT 10	100	#define MIN_FONT_HEIGHT 10
…		…
96		104
97	#define KMOD_LRAM 0x10000 // our extension	105	#define KMOD_LRAM 0x10000 // our extension
98		106
99	#define TEXID_SPEECH 1	107	#define TEXID_SPEECH 1
100	#define TEXID_NOFACE 2	108	#define TEXID_NOFACE 2
101	#define TEXID_HIDDEN 3	109
		110	static char *
		111	fast_sv_grow (SV *sv, STRLEN need)
		112	{
		113	STRLEN len = SvLEN (sv);
		114	STRLEN want = SvCUR (sv) + need;
		115
		116	if (expect_false (len < want))
		117	{
		118	do
		119	len *= 2;
		120	while (len < want);
		121
		122	sv_grow (sv, len);
		123	}
		124
		125	SvCUR_set (sv, want);
		126	return SvEND (sv) - need;
		127	}
102		128
103	static AV *texture_av;	129	static AV *texture_av;
104		130
105	static struct	131	static struct
106	{	132	{
…		…
163	{	189	{
164	GSList *attrs = run->item->analysis.extra_attrs;	190	GSList *attrs = run->item->analysis.extra_attrs;
165		191
166	while (attrs)	192	while (attrs)
167	{	193	{
168	PangoAttribute *attr = attrs->data;	194	PangoAttribute *attr = (PangoAttribute *)attrs->data;
169		195
170	if (attr->klass->type == PANGO_ATTR_SHAPE)	196	if (attr->klass->type == PANGO_ATTR_SHAPE)
171	return 1;	197	return 1;
172		198
173	attrs = attrs->next;	199	attrs = attrs->next;
174	}	200	}
175		201
176	return 0;	202	return 0;
177	}	203	}
178		204
179	typedef struct cf_layout {	205	struct cf_layout {
180	PangoLayout *pl;	206	PangoLayout *pl;
181	float r, g, b, a; // default color for rgba mode	207	float r, g, b, a; // default color for rgba mode
182	int base_height;	208	int base_height;
183	DC__Font font;	209	DC__Font font;
184	rc_t *rc;	210	rc_t rc;
185	} *DC__Layout;	211	};
		212
		213	typedef cf_layout *DC__Layout;
186		214
187	static DC__Font default_font;	215	static DC__Font default_font;
188	static PangoContext *opengl_context;	216	static PangoContext *opengl_context;
189	static PangoFontMap *opengl_fontmap;	217	static PangoFontMap *opengl_fontmap;
190		218
191	static void	219	static void
192	substitute_func (FcPattern *pattern, gpointer data)	220	substitute_func (FcPattern *pattern, gpointer data)
193	{	221	{
194	FcPatternAddBool (pattern, FC_HINTING, 1);	222	FcPatternAddBool (pattern, FC_HINTING, 1);
195	#ifdef FC_HINT_STYLE	223	#ifdef FC_HINT_STYLE
196	FcPatternAddBool (pattern, FC_HINT_STYLE, FC_HINT_FULL);	224	FcPatternAddInteger (pattern, FC_HINT_STYLE, FC_HINT_FULL);
197	#endif	225	#endif
198	FcPatternAddBool (pattern, FC_AUTOHINT, 0);	226	FcPatternAddBool (pattern, FC_AUTOHINT, 0);
199	}	227	}
200		228
201	static void	229	static void
…		…
231	}	259	}
232		260
233	typedef uint16_t tileid;	261	typedef uint16_t tileid;
234	typedef uint16_t faceid;	262	typedef uint16_t faceid;
235		263
236	typedef struct {	264	struct maptex
		265	{
237	GLuint name;	266	GLuint name;
238	int w, h;	267	int w, h;
239	float s, t;	268	float s, t;
240	uint8_t r, g, b, a;	269	uint8_t r, g, b, a;
241	tileid smoothtile;	270	tileid smoothtile;
242	uint8_t smoothlevel;	271	uint8_t smoothlevel;
243	uint8_t unused; /* set to zero on use */	272	uint8_t unused; /* set to zero on use */
244	} maptex;	273	};
245		274
246	typedef struct {	275	struct mapcell
		276	{
247	uint32_t player;	277	uint32_t player;
248	tileid tile[3];	278	tileid tile[3];
249	uint16_t darkness;	279	uint16_t darkness;
250	uint8_t stat_width, stat_hp, flags, smoothmax;	280	uint8_t stat_width, stat_hp, flags, smoothmax;
251	} mapcell;	281	};
252		282
253	typedef struct {	283	struct maprow
		284	{
254	int32_t c0, c1;	285	int32_t c0, c1;
255	mapcell *col;	286	mapcell *col;
256	} maprow;	287	};
257		288
258	typedef struct map {	289	struct mapgrid {
259	int x, y, w, h;	290	int x, y, w, h;
260	int ox, oy; /* offset to virtual global coordinate system */	291	int ox, oy; /* offset to virtual global coordinate system */
261	int faces; tileid *face2tile; // [faceid]	292	int faces; tileid *face2tile; // [faceid]
262	int texs; maptex *tex; // [tileid]	293	int texs; maptex *tex; // [tileid]
263		294
264	int32_t rows;	295	int32_t rows;
265	maprow *row;	296	maprow *row;
266	} *DC__Map;	297	};
267		298
268	static char *	299	typedef mapgrid *DC__Map;
		300
		301	template<typename T>
		302	static void
269	prepend (char *ptr, int sze, int inc)	303	prepend (T *&ptr, int sze, int inc)
270	{	304	{
271	char *p;	305	T *p;
272		306
273	New (0, p, sze + inc, char);	307	Newxz (p, sze + inc, T);
274	Zero (p, inc, char);
275	Move (ptr, p + inc, sze, char);	308	Move (ptr, p + inc, sze, T);
276	Safefree (ptr);	309	Safefree (ptr);
277		310
278	return p;	311	ptr = p;
279	}	312	}
280		313
281	static char *	314	template<typename T>
282	append (char *ptr, int sze, int inc)
283	{
284	Renew (ptr, sze + inc, char);
285	Zero (ptr + sze, inc, char);
286
287	return ptr;
288	}
289
290	#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
291	#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
292
293	static void	315	static void
		316	append (T *&ptr, int sze, int inc)
		317	{
		318	Renew (ptr, sze + inc, T);
		319	Zero (ptr + sze, inc, T);
		320	}
		321
		322	static void
294	need_facenum (struct map *self, faceid face)	323	need_facenum (struct mapgrid *self, faceid face)
295	{	324	{
296	while (self->faces <= face)	325	while (self->faces <= face)
297	{	326	{
298	Append (tileid, self->face2tile, self->faces, self->faces);	327	append (self->face2tile, self->faces, self->faces);
299	self->faces *= 2;	328	self->faces *= 2;
300	}	329	}
301	}	330	}
302		331
303	static void	332	static void
304	need_texid (struct map *self, int texid)	333	need_texid (struct mapgrid *self, int texid)
305	{	334	{
306	while (self->texs <= texid)	335	while (self->texs <= texid)
307	{	336	{
308	Append (maptex, self->tex, self->texs, self->texs);	337	append (self->tex, self->texs, self->texs);
309	self->texs *= 2;	338	self->texs *= 2;
310	}	339	}
311	}	340	}
312		341
313	static maprow *	342	static maprow *
314	map_get_row (DC__Map self, int y)	343	map_get_row (mapgrid *self, int y)
315	{	344	{
316	if (0 > y)	345	if (0 > y)
317	{	346	{
318	int extend = - y + MAP_EXTEND_Y;	347	int extend = - y + MAP_EXTEND_Y;
319	Prepend (maprow, self->row, self->rows, extend);	348	prepend (self->row, self->rows, extend);
320		349
321	self->rows += extend;	350	self->rows += extend;
322	self->y += extend;	351	self->y += extend;
323	y += extend;	352	y += extend;
324	}	353	}
325	else if (y >= self->rows)	354	else if (y >= self->rows)
326	{	355	{
327	int extend = y - self->rows + MAP_EXTEND_Y;	356	int extend = y - self->rows + MAP_EXTEND_Y;
328	Append (maprow, self->row, self->rows, extend);	357	append (self->row, self->rows, extend);
329	self->rows += extend;	358	self->rows += extend;
330	}	359	}
331		360
332	return self->row + y;	361	return self->row + y;
333	}	362	}
…		…
343	}	372	}
344		373
345	if (row->c0 > x)	374	if (row->c0 > x)
346	{	375	{
347	int extend = row->c0 - x + MAP_EXTEND_X;	376	int extend = row->c0 - x + MAP_EXTEND_X;
348	Prepend (mapcell, row->col, row->c1 - row->c0, extend);	377	prepend (row->col, row->c1 - row->c0, extend);
349	row->c0 -= extend;	378	row->c0 -= extend;
350	}	379	}
351	else if (x >= row->c1)	380	else if (x >= row->c1)
352	{	381	{
353	int extend = x - row->c1 + MAP_EXTEND_X;	382	int extend = x - row->c1 + MAP_EXTEND_X;
354	Append (mapcell, row->col, row->c1 - row->c0, extend);	383	append (row->col, row->c1 - row->c0, extend);
355	row->c1 += extend;	384	row->c1 += extend;
356	}	385	}
357		386
358	return row->col + (x - row->c0);	387	return row->col + (x - row->c0);
359	}	388	}
360		389
361	static mapcell *	390	static mapcell *
362	map_get_cell (DC__Map self, int x, int y)	391	map_get_cell (mapgrid *self, int x, int y)
363	{	392	{
364	return row_get_cell (map_get_row (self, y), x);	393	return row_get_cell (map_get_row (self, y), x);
365	}	394	}
366		395
367	static void	396	static void
368	map_clear (DC__Map self)	397	map_clear (mapgrid *self)
369	{	398	{
370	int r;	399	int r;
371		400
372	for (r = 0; r < self->rows; r++)	401	for (r = 0; r < self->rows; r++)
373	Safefree (self->row[r].col);	402	Safefree (self->row[r].col);
…		…
391	(cell)->flags = 0; \	420	(cell)->flags = 0; \
392	(cell)->player = 0; \	421	(cell)->player = 0; \
393	} while (0)	422	} while (0)
394		423
395	static void	424	static void
396	map_blank (DC__Map self, int x0, int y0, int w, int h)	425	map_blank (mapgrid *self, int x0, int y0, int w, int h)
397	{	426	{
398	int x, y;	427	int x, y;
399	maprow *row;	428	maprow *row;
400	mapcell *cell;	429	mapcell *cell;
401		430
…		…
418	CELL_CLEAR (cell);	447	CELL_CLEAR (cell);
419	}	448	}
420	}	449	}
421	}	450	}
422		451
423	typedef struct {	452	struct smooth_key
		453	{
424	tileid tile;	454	tileid tile;
425	uint8_t x, y, level;	455	uint8_t x, y, level;
426	} smooth_key;	456
		457	bool operator == (const smooth_key &o) const
		458	{
		459	return tile == o.tile && x == o.x && y == o.y && level == o.level;
		460	}
		461	};
		462
		463	typedef ska::flat_hash_map<smooth_key, IV> smooth_hash;
		464
		465	namespace std {
		466	template <>
		467	struct hash<smooth_key>
		468	{
		469	size_t operator () (const smooth_key &v) const
		470	{
		471	return v.tile + (v.x << 8) + (v.y << 16) + (v.level << 24);
		472	}
		473	};
		474	}
427		475
428	static void	476	static void
429	smooth_or_bits (HV *hv, smooth_key *key, IV bits)	477	smooth_or_bits (smooth_hash &h, smooth_key &key, IV bits)
430	{	478	{
431	SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1);	479	auto &&it = h.find (key);
432		480
433	if (SvIOK (*sv))	481	if (it == h.end ())
434	SvIV_set (*sv, SvIVX (*sv) | bits);	482	h.insert (std::make_pair (key, bits));
435	else	483	else
436	sv_setiv (*sv, bits);	484	it->second |= bits;
437	}	485	}
438		486
439	static void	487	static void
440	music_finished (void)	488	music_finished (void)
441	{	489	{
…		…
458	ev.code = 1;	506	ev.code = 1;
459	ev.data1 = (void *)(long)channel;	507	ev.data1 = (void *)(long)channel;
460	ev.data2 = 0;	508	ev.data2 = 0;
461		509
462	SDL_PushEvent ((SDL_Event *)&ev);	510	SDL_PushEvent ((SDL_Event *)&ev);
		511	}
		512
		513	// approximately divide by 255
		514	static unsigned int
		515	div255 (unsigned int n)
		516	{
		517	return (n + (n >> 8)) >> 8;
463	}	518	}
464		519
465	static unsigned int	520	static unsigned int
466	minpot (unsigned int n)	521	minpot (unsigned int n)
467	{	522	{
…		…
550		605
551	return mod;	606	return mod;
552	}	607	}
553		608
554	static void	609	static void
555	deliantra_main ()	610	deliantra_main (SV *real_main)
556	{	611	{
557	char *argv[] = { 0 };	612	dSP;
558	call_argv ("::main", G_DISCARD | G_VOID, argv);	613
		614	PUSHMARK (SP);
		615	call_sv (real_main, G_DISCARD | G_VOID);
559	}	616	}
560		617
561	#ifdef __MACOSX__	618	#ifdef __MACOSX__
		619	static SV *real_main;
		620
562	/* to due surprising braindamage on the side of SDL design, we	621	/* to due surprising braindamage on the side of SDL design, we
563	* do some mind-boggling hack here: SDL requires a custom main()	622	* do some mind-boggling hack here: SDL requires a custom main()
564	* on OS X, so... we provide one and call the original main(), which,	623	* on OS X, so... we provide one and call the original main(), which,
565	* due to share dlibrary magic, calls -lSDLmain's main, not perl's main,	624	* due to shared library magic, calls -lSDLmain's main, not perl's main,
566	* and which calls our main (== SDL_main) back.	625	* and which calls our main (== SDL_main) back.
567	*/	626	*/
568	extern C_LINKAGE int	627	extern C_LINKAGE int
569	main (int argc, char *argv[])	628	main (int argc, char *argv[])
570	{	629	{
571	deliantra_main ();	630	deliantra_main (real_main);
572	}	631	}
573		632
574	#undef main	633	#undef main
575		634
576	extern C_LINKAGE int main (int argc, char *argv[]);	635	extern C_LINKAGE int main (int argc, char *argv[]);
577		636
578	static void	637	static void
579	SDL_braino (void)	638	SDL_main_hack (SV *real_main_)
580	{	639	{
		640	real_main = real_main_;
		641
581	char *argv[] = { "deliantra client", 0 };	642	char *argv[] = { "deliantra client", 0 };
582	(main) (1, argv);	643	(main) (1, argv);
583	}	644	}
584	#else	645	#else
585	static void	646	static void
586	SDL_braino (void)	647	SDL_main_hack (SV *real_main)
587	{	648	{
588	deliantra_main ();	649	deliantra_main (real_main);
589	}	650	}
590	#endif	651	#endif
591		652
592	MODULE = Deliantra::Client PACKAGE = DC	653	MODULE = Deliantra::Client PACKAGE = DC
593		654
…		…
794		855
795	const_iv (FOW_DARKNESS)	856	const_iv (FOW_DARKNESS)
796	# undef const_iv	857	# undef const_iv
797	};	858	};
798		859
799	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	860	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
800	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	861	newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
801		862
802	assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);	863	assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
803	assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);	864	assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
804	}	865	}
805		866
…		…
821	NV ceil (NV x)	882	NV ceil (NV x)
822		883
823	IV minpot (UV n)	884	IV minpot (UV n)
824		885
825	IV popcount (UV n)	886	IV popcount (UV n)
		887
		888	NV distance (NV dx, NV dy)
		889	CODE:
		890	RETVAL = pow (dx * dx + dy * dy, 0.5);
		891	OUTPUT:
		892	RETVAL
826		893
827	void	894	void
828	pango_init ()	895	pango_init ()
829	CODE:	896	CODE:
830	{	897	{
…		…
838	#endif	905	#endif
839	}	906	}
840		907
841	char *SDL_GetError ()	908	char *SDL_GetError ()
842		909
843	void SDL_braino ()	910	void SDL_main_hack (SV *real_main)
		911	PROTOTYPE: &
844		912
845	int SDL_Init (U32 flags)	913	int SDL_Init (U32 flags)
846		914
847	int SDL_InitSubSystem (U32 flags)	915	int SDL_InitSubSystem (U32 flags)
848		916
849	void SDL_QuitSubSystem (U32 flags)	917	void SDL_QuitSubSystem (U32 flags)
850		918
851	void SDL_Quit ()	919	void SDL_Quit ()
852		920
853	int SDL_GL_SetAttribute (int attr, int value)	921	int SDL_GL_SetAttribute (int attr, int value)
		922	C_ARGS: (SDL_GLattr)attr, value
854		923
855	int SDL_GL_GetAttribute (int attr)	924	int SDL_GL_GetAttribute (int attr)
856	CODE:	925	CODE:
857	if (SDL_GL_GetAttribute (attr, &RETVAL))	926	if (SDL_GL_GetAttribute ((SDL_GLattr)attr, &RETVAL))
858	XSRETURN_UNDEF;	927	XSRETURN_UNDEF;
859	OUTPUT:	928	OUTPUT:
860	RETVAL	929	RETVAL
861		930
862	void	931	void
…		…
917	);	986	);
918		987
919	if (RETVAL)	988	if (RETVAL)
920	{	989	{
921	av_clear (texture_av);	990	av_clear (texture_av);
922
923	SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
924	#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);	991	#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
925	#include "glfunc.h"	992	#include "glfunc.h"
926	#undef GL_FUNC	993	#undef GL_FUNC
		994	if (!gl.ActiveTexture ) gl.ActiveTexture = gl.ActiveTextureARB;
		995	if (!gl.MultiTexCoord2f) gl.MultiTexCoord2f = gl.MultiTexCoord2fARB;
927	}	996	}
928	}	997	}
929	OUTPUT:	998	OUTPUT:
930	RETVAL	999	RETVAL
		1000
		1001	void
		1002	SDL_WM_SetCaption (const char *title, const char *icon)
931		1003
932	void	1004	void
933	SDL_GL_SwapBuffers ()	1005	SDL_GL_SwapBuffers ()
934		1006
935	char *	1007	char *
936	SDL_GetKeyName (int sym)	1008	SDL_GetKeyName (int sym)
		1009	C_ARGS: (SDLKey)sym
937		1010
938	int	1011	int
939	SDL_GetAppState ()	1012	SDL_GetAppState ()
940		1013
941	int	1014	int
942	SDL_GetModState ()	1015	SDL_GetModState ()
943		1016
		1017	int
		1018	SDL_WaitEvent ()
		1019	C_ARGS: 0
		1020
944	void	1021	void
		1022	SDL_PumpEvents ()
		1023
		1024	void
945	poll_events ()	1025	peep_events ()
946	PPCODE:	1026	PPCODE:
947	{	1027	{
948	SDL_Event ev;	1028	SDL_Event ev;
949		1029
950	SDL_PumpEvents ();	1030	SDL_PumpEvents ();
…		…
1016		1096
1017	XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1))));	1097	XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1))));
1018	}	1098	}
1019	}	1099	}
1020		1100
		1101	char *
		1102	SDL_AudioDriverName ()
		1103	CODE:
		1104	{
		1105	char buf [256];
		1106	if (!SDL_AudioDriverName (buf, sizeof (buf)))
		1107	XSRETURN_UNDEF;
		1108
		1109	RETVAL = buf;
		1110	}
		1111	OUTPUT:
		1112	RETVAL
		1113
1021	int	1114	int
1022	Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)	1115	Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)
1023	POSTCALL:	1116	POSTCALL:
1024	Mix_HookMusicFinished (music_finished);	1117	Mix_HookMusicFinished (music_finished);
1025	Mix_ChannelFinished (channel_finished);	1118	Mix_ChannelFinished (channel_finished);
1026		1119
1027	void	1120	void
1028	Mix_QuerySpec ()	1121	Mix_QuerySpec ()
…		…
1087	add_font (char *file)	1180	add_font (char *file)
1088	CODE:	1181	CODE:
1089	RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);	1182	RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);
1090	OUTPUT:	1183	OUTPUT:
1091	RETVAL	1184	RETVAL
		1185
		1186	void
		1187	IMG_Init (int flags = IMG_INIT_JPG | IMG_INIT_PNG)
		1188
		1189	# MIX_INIT_MP3 gives smpeg + libstdc++ + libgcc_s
		1190	void
		1191	Mix_Init (int flags = MIX_INIT_MOD | MIX_INIT_OGG)
1092		1192
1093	void	1193	void
1094	load_image_inline (SV *image_)	1194	load_image_inline (SV *image_)
1095	ALIAS:	1195	ALIAS:
1096	load_image_file = 1	1196	load_image_file = 1
…		…
1142		1242
1143	SDL_LockSurface (surface2);	1243	SDL_LockSurface (surface2);
1144	EXTEND (SP, 6);	1244	EXTEND (SP, 6);
1145	PUSHs (sv_2mortal (newSViv (surface2->w)));	1245	PUSHs (sv_2mortal (newSViv (surface2->w)));
1146	PUSHs (sv_2mortal (newSViv (surface2->h)));	1246	PUSHs (sv_2mortal (newSViv (surface2->h)));
1147	PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));	1247	PUSHs (sv_2mortal (newSVpvn ((const char *)surface2->pixels, surface2->h * surface2->pitch)));
1148	PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));	1248	PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));
1149	PUSHs (sv_2mortal (newSViv (GL_RGBA)));	1249	PUSHs (sv_2mortal (newSViv (GL_RGBA)));
1150	PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));	1250	PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
1151	SDL_UnlockSurface (surface2);	1251	SDL_UnlockSurface (surface2);
1152		1252
…		…
1224	MODULE = Deliantra::Client PACKAGE = DC::Font	1324	MODULE = Deliantra::Client PACKAGE = DC::Font
1225		1325
1226	PROTOTYPES: DISABLE	1326	PROTOTYPES: DISABLE
1227		1327
1228	DC::Font	1328	DC::Font
1229	new_from_file (SV *class, char *path, int id = 0)	1329	new_from_file (SV *klass, char *path, int id = 0)
1230	CODE:	1330	CODE:
1231	{	1331	{
1232	int count;	1332	int count;
1233	FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);	1333	FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
1234	RETVAL = pango_fc_font_description_from_pattern (pattern, 0);	1334	RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
…		…
1263	PROTOTYPE:	1363	PROTOTYPE:
1264	CODE:	1364	CODE:
1265	tc_restore ();	1365	tc_restore ();
1266		1366
1267	DC::Layout	1367	DC::Layout
1268	new (SV *class)	1368	new (SV *klass)
1269	CODE:	1369	CODE:
1270	New (0, RETVAL, 1, struct cf_layout);	1370	RETVAL = new cf_layout;
1271		1371
1272	RETVAL->pl = pango_layout_new (opengl_context);	1372	RETVAL->pl = pango_layout_new (opengl_context);
1273	RETVAL->r = 1.;	1373	RETVAL->r = 1.;
1274	RETVAL->g = 1.;	1374	RETVAL->g = 1.;
1275	RETVAL->b = 1.;	1375	RETVAL->b = 1.;
1276	RETVAL->a = 1.;	1376	RETVAL->a = 1.;
1277	RETVAL->base_height = MIN_FONT_HEIGHT;	1377	RETVAL->base_height = MIN_FONT_HEIGHT;
1278	RETVAL->font = 0;	1378	RETVAL->font = 0;
1279	RETVAL->rc = rc_alloc ();
1280		1379
1281	pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);	1380	pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
1282	layout_update_font (RETVAL);	1381	layout_update_font (RETVAL);
1283	OUTPUT:	1382	OUTPUT:
1284	RETVAL	1383	RETVAL
1285		1384
1286	void	1385	void
1287	DESTROY (DC::Layout self)	1386	DESTROY (DC::Layout self)
1288	CODE:	1387	CODE:
1289	g_object_unref (self->pl);	1388	g_object_unref (self->pl);
1290	rc_free (self->rc);
1291	Safefree (self);	1389	delete self;
1292		1390
1293	void	1391	void
1294	set_text (DC::Layout self, SV *text_)	1392	set_text (DC::Layout self, SV *text_)
1295	CODE:	1393	CODE:
1296	{	1394	{
…		…
1422		1520
1423	void	1521	void
1424	set_height (DC::Layout self, int base_height)	1522	set_height (DC::Layout self, int base_height)
1425	CODE:	1523	CODE:
1426	if (self->base_height != base_height)	1524	if (self->base_height != base_height)
1427	{	1525	{
1428	self->base_height = base_height;	1526	self->base_height = base_height;
1429	layout_update_font (self);	1527	layout_update_font (self);
1430	}	1528	}
1431		1529
1432	void	1530	void
…		…
1550	}	1648	}
1551		1649
1552	void	1650	void
1553	render (DC::Layout self, float x, float y, int flags = 0)	1651	render (DC::Layout self, float x, float y, int flags = 0)
1554	CODE:	1652	CODE:
1555	rc_clear (self->rc);	1653	self->rc.clear ();
1556	pango_opengl_render_layout_subpixel (	1654	pango_opengl_render_layout_subpixel (
1557	self->pl,	1655	self->pl,
1558	self->rc,	1656	&self->rc,
1559	x * PANGO_SCALE, y * PANGO_SCALE,	1657	x * PANGO_SCALE, y * PANGO_SCALE,
1560	self->r, self->g, self->b, self->a,	1658	self->r, self->g, self->b, self->a,
1561	flags	1659	flags
1562	);	1660	);
1563	// we assume that context_change actually clears/frees stuff	1661	// we assume that context_change actually clears/frees stuff
…		…
1574	gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,	1672	gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1575	GL_ONE , GL_ONE_MINUS_SRC_ALPHA);	1673	GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1576	glEnable (GL_ALPHA_TEST);	1674	glEnable (GL_ALPHA_TEST);
1577	glAlphaFunc (GL_GREATER, 7.f / 255.f);	1675	glAlphaFunc (GL_GREATER, 7.f / 255.f);
1578		1676
1579	rc_draw (self->rc);	1677	self->rc.draw ();
1580		1678
1581	glDisable (GL_ALPHA_TEST);	1679	glDisable (GL_ALPHA_TEST);
1582	glDisable (GL_BLEND);	1680	glDisable (GL_BLEND);
1583	glDisable (GL_TEXTURE_2D);	1681	glDisable (GL_TEXTURE_2D);
1584	}	1682	}
…		…
1660	glDisable (GL_BLEND);	1758	glDisable (GL_BLEND);
1661	}	1759	}
1662	}	1760	}
1663		1761
1664	void	1762	void
1665	draw_fow_texture (float intensity, int name1, float s1, float t1, float w1, float h1, float blend = 0.f, float dx = 0.f, float dy = 0.f, int name2 = 0, float s2 = 0.f, float t2 = 0.f, float w2 = 0.f, float h2 = 0.f)	1763	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)
1666	PROTOTYPE: @	1764	PROTOTYPE: @
1667	CODE:	1765	CODE:
1668	{	1766	{
		1767	glEnable (GL_BLEND);
		1768	glBlendFunc (intensity ? GL_SRC_ALPHA : GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1669	glEnable (GL_TEXTURE_2D);	1769	glEnable (GL_TEXTURE_2D);
1670	glEnable (GL_BLEND);
1671	glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1672	glBindTexture (GL_TEXTURE_2D, name1);	1770	glBindTexture (GL_TEXTURE_2D, name1);
1673		1771
1674	glColor3f (intensity, intensity, intensity);	1772	glColor3f (intensity, intensity, intensity);
1675	glPushMatrix ();	1773	glPushMatrix ();
1676	glScalef (1./3, 1./3, 1.);	1774	glScalef (1./3, 1./3, 1.);
1677		1775
1678	if (blend > 0.f)	1776	if (blend > 0.f)
1679	{	1777	{
1680	float S2, T2; /* 0. 0. for texture 2 */	1778	float dx3 = dx * -3.f / w;
1681	float w = w1 > w2 ? w1 : w2;	1779	float dy3 = dy * -3.f / h;
1682	float h = h1 > h2 ? h1 : h2;
1683	GLfloat env_color[4] = { 0., 0., 0., blend };	1780	GLfloat env_color[4] = { 0., 0., 0., blend };
1684		1781
1685	/* interpolate the two shadow textures */	1782	/* interpolate the two shadow textures */
1686	/* stage 0 == rgb(glcolor) + alpha(t0) */	1783	/* stage 0 == rgb(glcolor) + alpha(t0) */
1687	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);	1784	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
…		…
1692	glBindTexture (GL_TEXTURE_2D, name2);	1789	glBindTexture (GL_TEXTURE_2D, name2);
1693	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);	1790	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
1694		1791
1695	/* rgb == rgb(glcolor) */	1792	/* rgb == rgb(glcolor) */
1696	glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);	1793	glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
1697	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_CONSTANT);	1794	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
1698	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);	1795	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
1699		1796
1700	/* alpha = interpolate t0, t1 by env_alpha */	1797	/* alpha = interpolate t0, t1 by env_alpha */
1701	glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, env_color);	1798	glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, env_color);
1702		1799
…		…
1708	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);	1805	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
1709		1806
1710	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);	1807	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);
1711	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);	1808	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);
1712		1809
1713	s1 *= w / w1;
1714	t1 *= h / h1;
1715
1716	dx *= -3.f / w2;
1717	dy *= -3.f / h2;
1718	dx *= w / w2;
1719	dy *= h / h2;
1720
1721	s2 *= w / w2;
1722	t2 *= h / h2;
1723
1724	glBegin (GL_QUADS);	1810	glBegin (GL_QUADS);
1725	gl.MultiTexCoord2f (GL_TEXTURE0, 0, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx , dy ); glVertex2f ( 0, 0);	1811	gl.MultiTexCoord2f (GL_TEXTURE0, 0, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 ); glVertex2i (0, 0);
1726	gl.MultiTexCoord2f (GL_TEXTURE0, 0, t1); gl.MultiTexCoord2f (GL_TEXTURE1, dx , dy + t2); glVertex2f ( 0, h1);	1812	gl.MultiTexCoord2f (GL_TEXTURE0, 0, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 + t); glVertex2i (0, h);
1727	gl.MultiTexCoord2f (GL_TEXTURE0, s1, t1); gl.MultiTexCoord2f (GL_TEXTURE1, dx + s2, dy + t2); glVertex2f (w1, h1);	1813	gl.MultiTexCoord2f (GL_TEXTURE0, s, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 + t); glVertex2i (w, h);
1728	gl.MultiTexCoord2f (GL_TEXTURE0, s1, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx + s2, dy ); glVertex2f (w1, 0);	1814	gl.MultiTexCoord2f (GL_TEXTURE0, s, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 ); glVertex2i (w, 0);
1729	glEnd ();	1815	glEnd ();
1730		1816
1731	glDisable (GL_TEXTURE_2D);	1817	glDisable (GL_TEXTURE_2D);
1732	gl.ActiveTexture (GL_TEXTURE0);	1818	gl.ActiveTexture (GL_TEXTURE0);
1733	}	1819	}
…		…
1735	{	1821	{
1736	/* simple blending of one texture, also opengl <1.3 path */	1822	/* simple blending of one texture, also opengl <1.3 path */
1737	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);	1823	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1738		1824
1739	glBegin (GL_QUADS);	1825	glBegin (GL_QUADS);
1740	glTexCoord2f ( 0, 0); glVertex2f ( 0, 0);	1826	glTexCoord2f (0, 0); glVertex2f (0, 0);
1741	glTexCoord2f ( 0, t1); glVertex2f ( 0, h1);	1827	glTexCoord2f (0, t); glVertex2f (0, h);
1742	glTexCoord2f (s1, t1); glVertex2f (w1, h1);	1828	glTexCoord2f (s, t); glVertex2f (w, h);
1743	glTexCoord2f (s1, 0); glVertex2f (w1, 0);	1829	glTexCoord2f (s, 0); glVertex2f (w, 0);
1744	glEnd ();	1830	glEnd ();
1745	}	1831	}
		1832
		1833	/* draw ?-marks or equivalent, this is very clumsy code :/ */
		1834	{
		1835	int x, y;
		1836	int dx3 = dx * 3;
		1837	int dy3 = dy * 3;
		1838
		1839	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
		1840	glBindTexture (GL_TEXTURE_2D, hidden_tex);
		1841	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		1842	glTranslatef (-1., -1., 0);
		1843	glBegin (GL_QUADS);
		1844
		1845	for (y = 1; y < h; y += 3)
		1846	{
		1847	int y1 = y - dy3;
		1848	int y1valid = y1 >= 0 && y1 < h;
		1849
		1850	for (x = 1; x < w; x += 3)
		1851	{
		1852	int x1 = x - dx3;
		1853	uint8_t h1 = data1 [x + y * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
		1854	uint8_t h2;
		1855
		1856	if (y1valid && x1 >= 0 && x1 < w)
		1857	h2 = data2 [x1 + y1 * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
		1858	else
		1859	h2 = 1; /* out of range == invisible */
		1860
		1861	if (h1 || h2)
		1862	{
		1863	float alpha = h1 == h2 ? 1.f : h1 ? 1.f - blend : blend;
		1864	glColor4f (1., 1., 1., alpha);
		1865
		1866	glTexCoord2f (0, 0.); glVertex2i (x , y );
		1867	glTexCoord2f (0, 1.); glVertex2i (x , y + 3);
		1868	glTexCoord2f (1, 1.); glVertex2i (x + 3, y + 3);
		1869	glTexCoord2f (1, 0.); glVertex2i (x + 3, y );
		1870	}
		1871	}
		1872	}
		1873	}
		1874
		1875	glEnd ();
1746		1876
1747	glPopMatrix ();	1877	glPopMatrix ();
1748		1878
1749	glDisable (GL_TEXTURE_2D);	1879	glDisable (GL_TEXTURE_2D);
1750	glDisable (GL_BLEND);	1880	glDisable (GL_BLEND);
…		…
1764	MODULE = Deliantra::Client PACKAGE = DC::Map	1894	MODULE = Deliantra::Client PACKAGE = DC::Map
1765		1895
1766	PROTOTYPES: DISABLE	1896	PROTOTYPES: DISABLE
1767		1897
1768	DC::Map	1898	DC::Map
1769	new (SV *class)	1899	new (SV *klass)
1770	CODE:	1900	CODE:
1771	New (0, RETVAL, 1, struct map);	1901	New (0, RETVAL, 1, mapgrid);
1772	RETVAL->x = 0;	1902	RETVAL->x = 0;
1773	RETVAL->y = 0;	1903	RETVAL->y = 0;
1774	RETVAL->w = 0;	1904	RETVAL->w = 0;
1775	RETVAL->h = 0;	1905	RETVAL->h = 0;
1776	RETVAL->ox = 0;	1906	RETVAL->ox = 0;
…		…
1813		1943
1814	void	1944	void
1815	set_smooth (DC::Map self, int face, int smooth, int level)	1945	set_smooth (DC::Map self, int face, int smooth, int level)
1816	CODE:	1946	CODE:
1817	{	1947	{
1818	tileid texid;	1948	tileid texid;
1819	maptex *tex;	1949	maptex *tex;
1820		1950
1821	if (face < 0 || face >= self->faces)	1951	if (face < 0 || face >= self->faces)
1822	return;	1952	return;
1823		1953
1824	if (smooth < 0 || smooth >= self->faces)	1954	if (smooth < 0 || smooth >= self->faces)
1825	return;	1955	return;
1826		1956
1827	texid = self->face2tile [face];	1957	texid = self->face2tile [face];
1828		1958
1829	if (!texid)	1959	if (!texid)
1830	return;	1960	return;
1831		1961
1832	tex = self->tex + texid;	1962	tex = self->tex + texid;
…		…
1865	}	1995	}
1866		1996
1867	void	1997	void
1868	expire_textures (DC::Map self, int texid, int count)	1998	expire_textures (DC::Map self, int texid, int count)
1869	PPCODE:	1999	PPCODE:
1870	for (; texid < self->texs && count; ++texid, --count)	2000	for (; texid < self->texs && count; ++texid, --count)
1871	{	2001	{
1872	maptex *tex = self->tex + texid;	2002	maptex *tex = self->tex + texid;
1873		2003
1874	if (tex->name)	2004	if (tex->name)
1875	{	2005	{
…		…
1922	self->ox += dx; self->x += dx;	2052	self->ox += dx; self->x += dx;
1923	self->oy += dy; self->y += dy;	2053	self->oy += dy; self->y += dy;
1924		2054
1925	while (self->y < 0)	2055	while (self->y < 0)
1926	{	2056	{
1927	Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);	2057	prepend (self->row, self->rows, MAP_EXTEND_Y);
1928		2058
1929	self->rows += MAP_EXTEND_Y;	2059	self->rows += MAP_EXTEND_Y;
1930	self->y += MAP_EXTEND_Y;	2060	self->y += MAP_EXTEND_Y;
1931	}	2061	}
1932	}	2062	}
1933		2063
1934	SV *	2064	SV *
1935	map1a_update (DC::Map self, SV *data_, int extmap)	2065	map1a_update (DC::Map self, SV *data_)
1936	CODE:	2066	CODE:
1937	{	2067	{
1938	uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);	2068	uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1939	uint8_t *data_end = (uint8_t *)SvEND (data_);	2069	uint8_t *data_end = (uint8_t *)SvEND (data_);
1940	mapcell *cell;	2070	mapcell *cell;
…		…
1961		2091
1962	//TODO: don't trust server data to be in-range(!)	2092	//TODO: don't trust server data to be in-range(!)
1963		2093
1964	if (flags & 8)	2094	if (flags & 8)
1965	{	2095	{
		2096	uint8_t ext, cmd;
		2097
1966	if (extmap)	2098	do
1967	{	2099	{
1968	uint8_t ext, cmd;	2100	ext = *data++;
		2101	cmd = ext & 0x7f;
1969		2102
1970	do	2103	if (cmd < 4)
		2104	cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
		2105	else if (cmd == 5) // health
1971	{	2106	{
1972	ext = *data++;
1973	cmd = ext & 0x7f;
1974
1975	if (cmd < 4)
1976	cell->darkness = 255 - ext * 64 + 1;
1977	else if (cmd == 5) // health
1978	{
1979	cell->stat_width = 1;	2107	cell->stat_width = 1;
1980	cell->stat_hp = *data++;	2108	cell->stat_hp = *data++;
1981	}
1982	else if (cmd == 6) // monster width
1983	cell->stat_width = *data++ + 1;
1984	else if (cmd == 0x47)
1985	{
1986	if (*data == 1) cell->player = data [1];
1987	else if (*data == 2) cell->player = data [2] + (data [1] << 8);
1988	else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
1989	else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
1990
1991	data += *data + 1;
1992	}
1993	else if (cmd == 8) // cell flags
1994	cell->flags = *data++;
1995	else if (ext & 0x40) // unknown, multibyte => skip
1996	data += *data + 1;
1997	else
1998	data++;
1999	}	2109	}
2000	while (ext & 0x80);	2110	else if (cmd == 6) // monster width
		2111	cell->stat_width = *data++ + 1;
		2112	else if (cmd == 0x47)
		2113	{
		2114	if (*data == 1) cell->player = data [1];
		2115	else if (*data == 2) cell->player = data [2] + (data [1] << 8);
		2116	else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
		2117	else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
		2118
		2119	data += *data + 1;
		2120	}
		2121	else if (cmd == 8) // cell flags
		2122	cell->flags = *data++;
		2123	else if (ext & 0x40) // unknown, multibyte => skip
		2124	data += *data + 1;
		2125	else
		2126	data++;
2001	}	2127	}
2002	else	2128	while (ext & 0x80);
2003	cell->darkness = *data++ + 1;
2004	}	2129	}
2005		2130
2006	for (z = 0; z <= 2; ++z)	2131	for (z = 0; z <= 2; ++z)
2007	if (flags & (4 >> z))	2132	if (flags & (4 >> z))
2008	{	2133	{
…		…
2056	? self->row + y	2181	? self->row + y
2057	: 0;	2182	: 0;
2058		2183
2059	for (x = x0; x < x1; x++)	2184	for (x = x0; x < x1; x++)
2060	{	2185	{
2061	int r = 32, g = 32, b = 32, a = 192;	2186	unsigned int r = 32, g = 32, b = 32, a = 192;
2062		2187
2063	if (row && row->c0 <= x && x < row->c1)	2188	if (row && row->c0 <= x && x < row->c1)
2064	{	2189	{
2065	mapcell *cell = row->col + (x - row->c0);	2190	mapcell *cell = row->col + (x - row->c0);
2066		2191
…		…
2068	{	2193	{
2069	maptex tex = self->tex [cell->tile [z]];	2194	maptex tex = self->tex [cell->tile [z]];
2070	int a0 = 255 - tex.a;	2195	int a0 = 255 - tex.a;
2071	int a1 = tex.a;	2196	int a1 = tex.a;
2072		2197
2073	r = (r * a0 + tex.r * a1) / 255;	2198	r = div255 (r * a0 + tex.r * a1);
2074	g = (g * a0 + tex.g * a1) / 255;	2199	g = div255 (g * a0 + tex.g * a1);
2075	b = (b * a0 + tex.b * a1) / 255;	2200	b = div255 (b * a0 + tex.b * a1);
2076	a = (a * a0 + tex.a * a1) / 255;	2201	a = div255 (a * a0 + tex.a * a1);
2077	}	2202	}
2078	}	2203	}
2079		2204
2080	*map++ = (r )	2205	*map++ = (r )
2081	| (g << 8)	2206	| (g << 8)
2082	| (b << 16)	2207	| (b << 16)
2083	| (a << 24);	2208	| (a << 24);
2084	}	2209	}
2085	}	2210	}
2086		2211
2087	RETVAL = map_sv;	2212	RETVAL = map_sv;
2088	}	2213	}
2089	OUTPUT:	2214	OUTPUT:
2090	RETVAL	2215	RETVAL
2091		2216
2092	void	2217	void
2093	draw (DC::Map self, int mx, int my, int sw, int sh, int T, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)	2218	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)
2094	CODE:	2219	CODE:
2095	{	2220	{
2096	int x, y, z;	2221	int x, y, z;
2097		2222
2098	HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
2099	uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
2100	static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k)	2223	static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k), also, static!
2101	smooth_key skey;
2102	int pl_x, pl_y;	2224	int pl_x, pl_y;
2103	maptex pl_tex;	2225	maptex pl_tex;
2104	rc_t *rc = rc_alloc ();	2226	rc_t rc;
2105	rc_t *rc_ov = rc_alloc ();	2227	rc_t rc_ov;
2106	rc_key_t key;	2228	rc_key_t key;
2107	rc_array_t *arr, *arr_hidden;	2229	rc_t::array_t *arr;
2108		2230
2109	pl_tex.name = 0;	2231	pl_tex.name = 0;
2110		2232
2111	// that's current max. sorry.	2233	// that's current max. sorry.
2112	if (sw > 255) sw = 255;	2234	if (sw > 255) sw = 255;
2113	if (sh > 255) sh = 255;	2235	if (sh > 255) sh = 255;
2114
2115	// clear key, in case of extra padding
2116	memset (&skey, 0, sizeof (skey));
2117		2236
2118	memset (&key, 0, sizeof (key));	2237	memset (&key, 0, sizeof (key));
2119	key.r = 255;	2238	key.r = 255;
2120	key.g = 255;	2239	key.g = 255;
2121	key.b = 255;	2240	key.b = 255;
…		…
2127	my += self->y;	2246	my += self->y;
2128		2247
2129	// first pass: determine smooth_max	2248	// first pass: determine smooth_max
2130	// rather ugly, if you ask me	2249	// rather ugly, if you ask me
2131	// could also be stored inside mapcell and updated on change	2250	// could also be stored inside mapcell and updated on change
2132	memset (smooth_max, 0, sizeof (smooth_max));	2251	memset (smooth_max, 0, sizeof (smooth_max[0]) * (sh + 1));
2133		2252
2134	for (y = 0; y < sh; y++)	2253	for (y = 0; y < sh; y++)
2135	if (0 <= y + my && y + my < self->rows)	2254	if (0 <= y + my && y + my < self->rows)
2136	{	2255	{
2137	maprow *row = self->row + (y + my);	2256	maprow *row = self->row + (y + my);
…		…
2150		2269
2151	glEnable (GL_BLEND);	2270	glEnable (GL_BLEND);
2152	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);	2271	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2153	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);	2272	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
2154		2273
2155	key.texname = self->tex [TEXID_HIDDEN].name;
2156	arr_hidden = rc_array (rc_ov, &key);
2157
2158	for (z = 0; z <= 2; z++)	2274	for (z = 0; z <= 2; z++)
2159	{	2275	{
2160	memset (smooth_level, 0, sizeof (smooth_level));	2276	std::bitset<256> smooth_level; // one bit for every possible smooth level
		2277	smooth_key skey;
		2278	smooth_hash smooth;
2161	key.texname = -1;	2279	key.texname = -1;
2162		2280
2163	for (y = 0; y < sh; y++)	2281	for (y = 0; y < sh; y++)
2164	if (0 <= y + my && y + my < self->rows)	2282	if (0 <= y + my && y + my < self->rows)
2165	{	2283	{
…		…
2182		2300
2183	if (!tex.name)	2301	if (!tex.name)
2184	tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */	2302	tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
2185		2303
2186	key.texname = tex.name;	2304	key.texname = tex.name;
2187	arr = rc_array (rc, &key);	2305	arr = &rc.array (key);
2188	}	2306	}
2189		2307
2190	px = (x + 1) * T - tex.w;	2308	px = (x + 1) * Th - tex.w;
2191	py = (y + 1) * T - tex.h;	2309	py = (y + 1) * Tw - tex.h;
2192		2310
2193	if (expect_false (cell->player == player) && expect_false (z == 2))	2311	if (expect_false (cell->player == player) && expect_false (z == 2))
2194	{	2312	{
2195	pl_x = px;	2313	pl_x = px;
2196	pl_y = py;	2314	pl_y = py;
2197	pl_tex = tex;	2315	pl_tex = tex;
2198	continue;	2316	continue;
2199	}	2317	}
2200		2318
2201	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);	2319	arr->t2f_v3f (0 , 0 , px , py , 0);
2202	rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);	2320	arr->t2f_v3f (0 , tex.t, px , py + tex.h, 0);
2203	rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);	2321	arr->t2f_v3f (tex.s, tex.t, px + tex.w, py + tex.h, 0);
2204	rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);	2322	arr->t2f_v3f (tex.s, 0 , px + tex.w, py , 0);
2205		2323
2206	// update smooth hash	2324	// update smooth hash
2207	if (tex.smoothtile)	2325	if (tex.smoothtile)
2208	{	2326	{
2209	skey.tile = tex.smoothtile;	2327	skey.tile = tex.smoothtile;
2210	skey.level = tex.smoothlevel;	2328	skey.level = tex.smoothlevel;
2211		2329
2212	smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31);	2330	smooth_level[tex.smoothlevel] = 1;
2213		2331
2214	// add bits to current tile and all neighbours. skey.x|y is	2332	// add bits to current tile and all neighbours. skey.x|y is
2215	// shifted +1|+1 so we always stay positive.	2333	// shifted +1|+1 so we always stay positive.
2216		2334
2217	// bits is ___n cccc CCCC bbbb	2335	// bits is ___n cccc CCCC bbbb
…		…
2225		2343
2226	// corners: 1 ┛· 2 ·┗ 4 ·· 8 ··	2344	// corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
2227	// ·· ·· ·┏ ┓·	2345	// ·· ·· ·┏ ┓·
2228		2346
2229	// full tile	2347	// full tile
2230	skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000);	2348	skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x1000);
2231		2349
2232	// borders	2350	// borders
2233	skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091);	2351	skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0091);
2234	skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032);	2352	skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0032);
2235	skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064);	2353	skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0064);
2236	skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8);	2354	skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, skey, 0x00c8);
2237		2355
2238	// corners	2356	// corners
2239	skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);	2357	skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0100);
2240	skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);	2358	skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0200);
2241	skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);	2359	skey.x = x ; skey.y = y ; smooth_or_bits (smooth, skey, 0x0400);
2242	skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);	2360	skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, skey, 0x0800);
2243	}	2361	}
2244	}	2362	}
2245		2363
2246	if (expect_false (z == 2))	2364	if (expect_false (z == 2) && expect_false (cell->flags))
2247	{	2365	{
2248	/* draw question marks on top of hidden spaces */	2366	// overlays such as the speech bubble, probably more to come
2249	if (!cell->darkness)	2367	if (cell->flags & 1)
2250	{	2368	{
2251	maptex tex = self->tex [TEXID_HIDDEN];
2252	int px = (x + 1) * T - tex.w;
2253	int py = (y + 1) * T - tex.h;
2254
2255	rc_t2f_v3f (arr_hidden, 0 , 0 , px , py , 0);
2256	rc_t2f_v3f (arr_hidden, 0 , tex.t, px , py + tex.h, 0);
2257	rc_t2f_v3f (arr_hidden, tex.s, tex.t, px + tex.w, py + tex.h, 0);
2258	rc_t2f_v3f (arr_hidden, tex.s, 0 , px + tex.w, py , 0);
2259	}
2260
2261	if (expect_false (cell->flags))
2262	{
2263	// overlays such as the speech bubble, probably more to come
2264	if (cell->flags & 1)
2265	{
2266	rc_key_t key_ov = key;	2369	rc_key_t key_ov = key;
2267	maptex tex = self->tex [TEXID_SPEECH];	2370	maptex tex = self->tex[TEXID_SPEECH];
2268	rc_array_t *arr;
2269	int px = x * T + T * 2 / 32;	2371	int px = x * Tw + Tw * 2 / 32;
2270	int py = y * T - T * 6 / 32;	2372	int py = y * Th - Th * 6 / 32;
2271		2373
2272	key_ov.texname = tex.name;	2374	key_ov.texname = tex.name;
2273	arr = rc_array (rc_ov, &key_ov);	2375	rc_t::array_t &arr = rc_ov.array (key_ov);
2274		2376
2275	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);	2377	arr.t2f_v3f (0 , 0 , px , py , 0);
2276	rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);	2378	arr.t2f_v3f (0 , tex.t, px , py + Th, 0);
2277	rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);	2379	arr.t2f_v3f (tex.s, tex.t, px + Tw, py + Th, 0);
2278	rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);	2380	arr.t2f_v3f (tex.s, 0 , px + Tw, py , 0);
2279	}
2280	}	2381	}
2281	}	2382	}
2282	}	2383	}
2283	}	2384	}
2284		2385
2285	rc_draw (rc);	2386	rc.draw ();
2286	rc_clear (rc);	2387	rc.clear ();
2287		2388
2288	// go through all smoothlevels, lowest to highest, then draw.	2389	// go through all smoothlevels, lowest to highest, then draw.
2289	// this is basically counting sort	2390	// this is basically counting sort
2290	{	2391	{
2291	int w, b;	2392	int w, b;
2292		2393
2293	glEnable (GL_TEXTURE_2D);	2394	glEnable (GL_TEXTURE_2D);
2294	glBegin (GL_QUADS);	2395	glBegin (GL_QUADS);
2295	for (w = 0; w < 256 / 32; ++w)	2396	for (int level = 0; level < smooth_level.size (); ++level)
		2397	if (smooth_level[level])
		2398	for (auto &&it = smooth.begin (); it != smooth.end (); ++it)
2296	{	2399	{
2297	uint32_t smask = smooth_level [w];	2400	smooth_key &skey = it->first;
2298	if (smask)	2401	IV bits = it->second;
2299	for (b = 0; b < 32; ++b)	2402
2300	if (smask & (((uint32_t)1) << b))	2403	if (!(bits & 0x1000)
		2404	&& skey.level == level
		2405	&& level > smooth_max [skey.x][skey.y])
2301	{	2406	{
2302	int level = (w << 5) | b;	2407	maptex tex = self->tex [skey.tile];
		2408	int px = (((int)skey.x) - 1) * Tw;
		2409	int py = (((int)skey.y) - 1) * Th;
		2410	int border = bits & 15;
		2411	int corner = (bits >> 8) & ~(bits >> 4) & 15;
		2412	float dx = tex.s * .0625f; // 16 images/row
		2413	float dy = tex.t * .5f ; // 2 images/column
		2414
2303	HE *he;	2415	if (tex.name)
2304
2305	hv_iterinit (smooth);
2306	while ((he = hv_iternext (smooth)))
2307	{	2416	{
2308	smooth_key *skey = (smooth_key *)HeKEY (he);	2417	// this time avoiding texture state changes
2309	IV bits = SvIVX (HeVAL (he));	2418	// save gobs of state changes.
2310		2419	if (key.texname != tex.name)
2311	if (!(bits & 0x1000)
2312	&& skey->level == level
2313	&& level > smooth_max [skey->x][skey->y])
2314	{	2420	{
2315	maptex tex = self->tex [skey->tile];
2316	int px = (((int)skey->x) - 1) * T;
2317	int py = (((int)skey->y) - 1) * T;
2318	int border = bits & 15;
2319	int corner = (bits >> 8) & ~(bits >> 4) & 15;
2320	float dx = tex.s * .0625f; // 16 images/row
2321	float dy = tex.t * .5f ; // 2 images/column
2322
2323	if (tex.name)
2324	{
2325	// this time avoiding texture state changes
2326	// save gobs of state changes.
2327	if (key.texname != tex.name)
2328	{
2329	self->tex [skey->tile].unused = 0;	2421	self->tex [skey.tile].unused = 0;
2330		2422
2331	glEnd ();	2423	glEnd ();
2332	glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);	2424	glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
2333	glBegin (GL_QUADS);	2425	glBegin (GL_QUADS);
2334	}	2426	}
2335		2427
2336	if (border)	2428	if (border)
2337	{	2429	{
2338	float ox = border * dx;	2430	float ox = border * dx;
2339		2431
2340	glTexCoord2f (ox , 0.f ); glVertex2i (px , py );	2432	glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
2341	glTexCoord2f (ox , dy ); glVertex2i (px , py + T);	2433	glTexCoord2f (ox , dy ); glVertex2i (px , py + Th);
2342	glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T);	2434	glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py + Th);
2343	glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py );	2435	glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + Tw, py );
2344	}	2436	}
2345		2437
2346	if (corner)	2438	if (corner)
2347	{	2439	{
2348	float ox = corner * dx;	2440	float ox = corner * dx;
2349		2441
2350	glTexCoord2f (ox , dy ); glVertex2i (px , py );	2442	glTexCoord2f (ox , dy ); glVertex2i (px , py );
2351	glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T);	2443	glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + Th);
2352	glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T);	2444	glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + Tw, py + Th);
2353	glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py );	2445	glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py );
2354	}
2355	}
2356	}	2446	}
2357	}	2447	}
2358	}	2448	}
2359	}	2449	}
2360		2450
2361	glEnd ();	2451	glEnd ();
2362	glDisable (GL_TEXTURE_2D);	2452	glDisable (GL_TEXTURE_2D);
2363	key.texname = -1;	2453	key.texname = -1;
2364	}	2454	}
2365
2366	hv_clear (smooth);
2367	}	2455	}
2368		2456
2369	if (pl_tex.name)	2457	if (pl_tex.name)
2370	{	2458	{
2371	maptex tex = pl_tex;	2459	maptex tex = pl_tex;
2372	int px = pl_x + sdx;	2460	int px = pl_x + sdx;
2373	int py = pl_y + sdy;	2461	int py = pl_y + sdy;
2374		2462
2375	key.texname = tex.name;	2463	key.texname = tex.name;
2376	arr = rc_array (rc, &key);	2464	rc_t::array_t &arr = rc.array (key);
2377		2465
2378	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);	2466	arr.t2f_v3f (0 , 0 , px , py , 0);
2379	rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);	2467	arr.t2f_v3f (0 , tex.t, px , py + tex.h, 0);
2380	rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);	2468	arr.t2f_v3f (tex.s, tex.t, px + tex.w, py + tex.h, 0);
2381	rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);	2469	arr.t2f_v3f (tex.s, 0 , px + tex.w, py , 0);
2382		2470
2383	rc_draw (rc);	2471	rc.draw ();
2384	}	2472	}
2385		2473
2386	rc_draw (rc_ov);	2474	rc_ov.draw ();
2387	rc_clear (rc_ov);	2475	rc_ov.clear ();
2388		2476
2389	glDisable (GL_BLEND);	2477	glDisable (GL_BLEND);
2390	rc_free (rc);
2391	rc_free (rc_ov);
2392		2478
2393	// top layer: overlays such as the health bar	2479	// top layer: overlays such as the health bar
2394	for (y = 0; y < sh; y++)	2480	for (y = 0; y < sh; y++)
2395	if (0 <= y + my && y + my < self->rows)	2481	if (0 <= y + my && y + my < self->rows)
2396	{	2482	{
…		…
2399	for (x = 0; x < sw; x++)	2485	for (x = 0; x < sw; x++)
2400	if (row->c0 <= x + mx && x + mx < row->c1)	2486	if (row->c0 <= x + mx && x + mx < row->c1)
2401	{	2487	{
2402	mapcell *cell = row->col + (x + mx - row->c0);	2488	mapcell *cell = row->col + (x + mx - row->c0);
2403		2489
2404	int px = x * T;	2490	int px = x * Tw;
2405	int py = y * T;	2491	int py = y * Th;
2406		2492
2407	if (expect_false (cell->player == player))	2493	if (expect_false (cell->player == player))
2408	{	2494	{
2409	px += sdx;	2495	px += sdx;
2410	py += sdy;	2496	py += sdy;
2411	}	2497	}
2412		2498
2413	if (cell->stat_hp)	2499	if (cell->stat_hp)
2414	{	2500	{
2415	int width = cell->stat_width * T;	2501	int width = cell->stat_width * Tw;
2416	int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;	2502	int thick = (sh * Th / 32 + 27) / 28 + 1 + cell->stat_width;
2417		2503
2418	glColor3ub (0, 0, 0);	2504	glColor3ub (0, 0, 0);
2419	glRectf (px + 1, py - thick - 2,	2505	glRectf (px + 1, py - thick - 2,
2420	px + width - 1, py);	2506	px + width - 1, py);
2421		2507
…		…
2427	}	2513	}
2428	}	2514	}
2429	}	2515	}
2430		2516
2431	void	2517	void
2432	draw_magicmap (DC::Map self, int dx, int dy, int w, int h, unsigned char *data)	2518	draw_magicmap (DC::Map self, int w, int h, unsigned char *data)
2433	CODE:	2519	CODE:
2434	{	2520	{
2435	static float color[16][3] = {	2521	static float color[16][3] = {
2436	{ 0.00F, 0.00F, 0.00F },	2522	{ 0.00f, 0.00f, 0.00f },
2437	{ 1.00F, 1.00F, 1.00F },	2523	{ 1.00f, 1.00f, 1.00f },
2438	{ 0.00F, 0.00F, 0.55F },	2524	{ 0.00f, 0.00f, 0.55f },
2439	{ 1.00F, 0.00F, 0.00F },	2525	{ 1.00f, 0.00f, 0.00f },
2440		2526
2441	{ 1.00F, 0.54F, 0.00F },	2527	{ 1.00f, 0.54f, 0.00f },
2442	{ 0.11F, 0.56F, 1.00F },	2528	{ 0.11f, 0.56f, 1.00f },
2443	{ 0.93F, 0.46F, 0.00F },	2529	{ 0.93f, 0.46f, 0.00f },
2444	{ 0.18F, 0.54F, 0.34F },	2530	{ 0.18f, 0.54f, 0.34f },
2445		2531
2446	{ 0.56F, 0.73F, 0.56F },	2532	{ 0.56f, 0.73f, 0.56f },
2447	{ 0.80F, 0.80F, 0.80F },	2533	{ 0.80f, 0.80f, 0.80f },
2448	{ 0.55F, 0.41F, 0.13F },	2534	{ 0.55f, 0.41f, 0.13f },
2449	{ 0.99F, 0.77F, 0.26F },	2535	{ 0.99f, 0.77f, 0.26f },
2450		2536
2451	{ 0.74F, 0.65F, 0.41F },	2537	{ 0.74f, 0.65f, 0.41f },
2452		2538
2453	{ 0.00F, 1.00F, 1.00F },	2539	{ 0.00f, 1.00f, 1.00f },
2454	{ 1.00F, 0.00F, 1.00F },	2540	{ 1.00f, 0.00f, 1.00f },
2455	{ 1.00F, 1.00F, 0.00F },	2541	{ 1.00f, 1.00f, 0.00f },
2456	};	2542	};
2457		2543
2458	int x, y;	2544	int x, y;
2459		2545
2460	glEnable (GL_TEXTURE_2D);	2546	glEnable (GL_TEXTURE_2D);
2461	/* GL_REPLACE would be correct, as we don't need to modulate alpha,	2547	/* GL_REPLACE would be correct, as we don't need to modulate alpha,
2462	* but the nvidia driver (185.18.14) mishandles alpha textures	2548	* but the nvidia driver (185.18.14) mishandles alpha textures
2463	* ansd takes the colour from god knows where instead of using	2549	* and takes the colour from god knows where instead of using
2464	* Cp. MODULATE results in the same colour, but slightly different	2550	* Cp. MODULATE results in the same colour, but slightly different
2465	* alpha, but atcually gives us the correct colour with nvidia.	2551	* alpha, but atcually gives us the correct colour with nvidia.
2466	*/	2552	*/
2467	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);	2553	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
2468	glEnable (GL_BLEND);	2554	glEnable (GL_BLEND);
…		…
2476		2562
2477	if (m)	2563	if (m)
2478	{	2564	{
2479	float *c = color [m & 15];	2565	float *c = color [m & 15];
2480		2566
2481	float tx1 = m & 0x40 ? 0.5 : 0.;	2567	float tx1 = m & 0x40 ? 0.5f : 0.f;
2482	float tx2 = tx1 + 0.5;	2568	float tx2 = tx1 + 0.5f;
2483		2569
2484	glColor4f (c[0], c[1], c[2], 1);	2570	glColor4f (c[0], c[1], c[2], 1);
2485	glTexCoord2f (tx1, 0.); glVertex2i (x , y );	2571	glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2486	glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);	2572	glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2487	glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);	2573	glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
…		…
2497	void	2583	void
2498	fow_texture (DC::Map self, int mx, int my, int sw, int sh)	2584	fow_texture (DC::Map self, int mx, int my, int sw, int sh)
2499	PPCODE:	2585	PPCODE:
2500	{	2586	{
2501	int x, y;	2587	int x, y;
2502	int sw1 = sw + 2;	2588	int sw1 = sw + 2;
2503	int sh1 = sh + 2;	2589	int sh1 = sh + 2;
2504	int sh3 = sh * 3;	2590	int sh3 = sh * 3;
2505	int sw34 = (sw * 3 + 3) & ~3;	2591	int sw3 = sw * 3;
		2592	SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3));
		2593	uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2506	uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);	2594	uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2507	SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));	2595	memset (darkness1, 0, sw1*sh1);
2508	uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2509		2596
2510	SvPOK_only (darkness3_sv);	2597	SvPOK_only (darkness3_sv);
2511	SvCUR_set (darkness3_sv, sw34 * sh3);	2598	SvCUR_set (darkness3_sv, sw3 * sh3);
2512		2599
2513	mx += self->x - 1;	2600	mx += self->x - 1;
2514	my += self->y - 1;	2601	my += self->y - 1;
2515
2516	memset (darkness1, DARKNESS_ADJUST (255 - FOW_DARKNESS), sw1 * sh1);
2517		2602
2518	for (y = 0; y < sh1; y++)	2603	for (y = 0; y < sh1; y++)
2519	if (0 <= y + my && y + my < self->rows)	2604	if (0 <= y + my && y + my < self->rows)
2520	{	2605	{
2521	maprow *row = self->row + (y + my);	2606	maprow *row = self->row + (y + my);
…		…
2554		2639
2555	uint8_t r13 = (d13 + d23 + d12) / 3;	2640	uint8_t r13 = (d13 + d23 + d12) / 3;
2556	uint8_t r23 = d23;	2641	uint8_t r23 = d23;
2557	uint8_t r33 = (d23 + d33 + d32) / 3;	2642	uint8_t r33 = (d23 + d33 + d32) / 3;
2558		2643
2559	darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11);	2644	darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2560	darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21);	2645	darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2561	darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31);	2646	darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2562	darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12);	2647	darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2563	darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22);	2648	darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 1)] = MAX (d22, r22); /* this MUST be == d22 */
2564	darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32);	2649	darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2565	darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13);	2650	darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2566	darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23);	2651	darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2567	darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33);	2652	darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2568	}	2653	}
2569		2654
2570	free (darkness1);	2655	free (darkness1);
2571		2656
2572	EXTEND (SP, 3);	2657	EXTEND (SP, 3);
2573	PUSHs (sv_2mortal (newSViv (sw34)));	2658	PUSHs (sv_2mortal (newSViv (sw3)));
2574	PUSHs (sv_2mortal (newSViv (sh3)));	2659	PUSHs (sv_2mortal (newSViv (sh3)));
2575	PUSHs (darkness3_sv);	2660	PUSHs (darkness3_sv);
2576	}	2661	}
2577		2662
2578	SV *	2663	SV *
…		…
2641	else	2726	else
2642	*data++ = 0;	2727	*data++ = 0;
2643	}	2728	}
2644	}	2729	}
2645		2730
2646	/* if size is w*h + 5 then no data has been found */	2731	/* if size is w*h + 5 then no data has been found */
2647	if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5)	2732	if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5)
2648	{	2733	{
2649	SvPOK_only (data_sv);	2734	SvPOK_only (data_sv);
2650	SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));	2735	SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2651	}	2736	}
2652		2737
2653	RETVAL = data_sv;	2738	RETVAL = data_sv;
2654	}	2739	}
2655	OUTPUT:	2740	OUTPUT:
2656	RETVAL	2741	RETVAL
2657		2742
2658	void	2743	void
…		…
2665	STRLEN len;	2750	STRLEN len;
2666	uint8_t *data, *end;	2751	uint8_t *data, *end;
2667		2752
2668	len = SvLEN (data_sv);	2753	len = SvLEN (data_sv);
2669	SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more	2754	SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more
2670	data = SvPVbyte_nolen (data_sv);	2755	data = (uint8_t *)SvPVbyte_nolen (data_sv);
2671	end = data + len + 8;	2756	end = data + len + 8;
2672		2757
2673	if (len < 5)	2758	if (len < 5)
2674	XSRETURN_EMPTY;	2759	XSRETURN_EMPTY;
2675		2760
…		…
2736	}	2821	}
2737		2822
2738	MODULE = Deliantra::Client PACKAGE = DC::RW	2823	MODULE = Deliantra::Client PACKAGE = DC::RW
2739		2824
2740	DC::RW	2825	DC::RW
2741	new (SV *class, SV *data_sv)	2826	new (SV *klass, SV *data_sv)
2742	CODE:	2827	CODE:
2743	{	2828	{
2744	STRLEN datalen;	2829	STRLEN datalen;
2745	char *data = SvPVbyte (data_sv, datalen);	2830	char *data = SvPVbyte (data_sv, datalen);
2746		2831
…		…
2748	}	2833	}
2749	OUTPUT:	2834	OUTPUT:
2750	RETVAL	2835	RETVAL
2751		2836
2752	DC::RW	2837	DC::RW
2753	new_from_file (SV *class, const char *path, const char *mode = "rb")	2838	new_from_file (SV *klass, const char *path, const char *mode = "rb")
2754	CODE:	2839	CODE:
2755	RETVAL = SDL_RWFromFile (path, mode);	2840	RETVAL = SDL_RWFromFile (path, mode);
2756	OUTPUT:	2841	OUTPUT:
2757	RETVAL	2842	RETVAL
2758		2843
…		…
2776	if (RETVAL < 0)	2861	if (RETVAL < 0)
2777	{	2862	{
2778	RETVAL = Mix_GroupOldest (-1);	2863	RETVAL = Mix_GroupOldest (-1);
2779		2864
2780	if (RETVAL < 0)	2865	if (RETVAL < 0)
		2866	{
		2867	// happens sometimes, maybe it just stopped playing(?)
		2868	RETVAL = Mix_GroupAvailable (-1);
		2869
		2870	if (RETVAL < 0)
2781	XSRETURN_UNDEF;	2871	XSRETURN_UNDEF;
2782		2872	}
		2873	else
2783	Mix_HaltChannel (RETVAL);	2874	Mix_HaltChannel (RETVAL);
2784	}	2875	}
2785		2876
2786	Mix_UnregisterAllEffects (RETVAL);	2877	Mix_UnregisterAllEffects (RETVAL);
2787	Mix_Volume (RETVAL, 128);	2878	Mix_Volume (RETVAL, 128);
2788	}	2879	}
…		…
2835	void	2926	void
2836	set_position_r (DC::Channel self, int dx, int dy, int maxdistance)	2927	set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2837	CODE:	2928	CODE:
2838	{	2929	{
2839	int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));	2930	int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2840	int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI);	2931	int angle = atan2f (dx, -dy) * 180.f / (float)M_PI + 360.f;
2841	Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));	2932	Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2842	}	2933	}
2843		2934
2844	void	2935	void
2845	set_reverse_stereo (DC::Channel self, int flip)	2936	set_reverse_stereo (DC::Channel self, int flip)
…		…
2848		2939
2849	MODULE = Deliantra::Client PACKAGE = DC::MixChunk	2940	MODULE = Deliantra::Client PACKAGE = DC::MixChunk
2850		2941
2851	PROTOTYPES: DISABLE	2942	PROTOTYPES: DISABLE
2852		2943
		2944	void
		2945	decoders ()
		2946	PPCODE:
		2947	#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
		2948	int i, num = Mix_GetNumChunkDecoders ();
		2949	EXTEND (SP, num);
		2950	for (i = 0; i < num; ++i)
		2951	PUSHs (sv_2mortal (newSVpv (Mix_GetChunkDecoder (i), 0)));
		2952	#else
		2953	XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
		2954	#endif
		2955
2853	DC::MixChunk	2956	DC::MixChunk
2854	new (SV *class, DC::RW rwops)	2957	new (SV *klass, DC::RW rwops)
2855	CODE:	2958	CODE:
2856	RETVAL = Mix_LoadWAV_RW (rwops, 1);	2959	RETVAL = Mix_LoadWAV_RW (rwops, 1);
2857	OUTPUT:	2960	OUTPUT:
2858	RETVAL	2961	RETVAL
2859		2962
…		…
2889	OUTPUT:	2992	OUTPUT:
2890	RETVAL	2993	RETVAL
2891		2994
2892	MODULE = Deliantra::Client PACKAGE = DC::MixMusic	2995	MODULE = Deliantra::Client PACKAGE = DC::MixMusic
2893		2996
		2997	void
		2998	decoders ()
		2999	PPCODE:
		3000	#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
		3001	int i, num = Mix_GetNumMusicDecoders ();
		3002	EXTEND (SP, num);
		3003	for (i = 0; i < num; ++i)
		3004	PUSHs (sv_2mortal (newSVpv (Mix_GetMusicDecoder (i), 0)));
		3005	#else
		3006	XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
		3007	#endif
		3008
2894	int	3009	int
2895	volume (int volume = -1)	3010	volume (int volume = -1)
2896	PROTOTYPE: ;$	3011	PROTOTYPE: ;$
2897	CODE:	3012	CODE:
2898	if (items > 0)	3013	if (items > 0)
…		…
2909	void	3024	void
2910	halt ()	3025	halt ()
2911	CODE:	3026	CODE:
2912	Mix_HaltMusic ();	3027	Mix_HaltMusic ();
2913		3028
		3029	int
		3030	playing ()
		3031	CODE:
		3032	RETVAL = Mix_PlayingMusic ();
		3033	OUTPUT:
		3034	RETVAL
		3035
2914	DC::MixMusic	3036	DC::MixMusic
2915	new (SV *class, DC::RW rwops)	3037	new (SV *klass, DC::RW rwops)
2916	CODE:	3038	CODE:
2917	RETVAL = Mix_LoadMUS_RW (rwops);	3039	RETVAL = Mix_LoadMUS_RW (rwops);
2918	OUTPUT:	3040	OUTPUT:
2919	RETVAL	3041	RETVAL
2920		3042
…		…
3057	const_iv (GL_FUNC_SUBTRACT),	3179	const_iv (GL_FUNC_SUBTRACT),
3058	const_iv (GL_FUNC_REVERSE_SUBTRACT),	3180	const_iv (GL_FUNC_REVERSE_SUBTRACT),
3059	# undef const_iv	3181	# undef const_iv
3060	};	3182	};
3061		3183
3062	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	3184	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
3063	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	3185	newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
3064		3186
3065	texture_av = newAV ();	3187	texture_av = newAV ();
3066	AvREAL_off (texture_av);	3188	AvREAL_off (texture_av);
3067	}	3189	}
3068		3190
…		…
3073	gl.BlendFuncSeparateEXT = 0;	3195	gl.BlendFuncSeparateEXT = 0;
3074		3196
3075	void	3197	void
3076	apple_nvidia_bug (int enable)	3198	apple_nvidia_bug (int enable)
3077		3199
3078	char *	3200	const char *
3079	gl_vendor ()	3201	gl_vendor ()
3080	CODE:	3202	CODE:
3081	RETVAL = (char *)glGetString (GL_VENDOR);	3203	RETVAL = (const char *)glGetString (GL_VENDOR);
3082	OUTPUT:	3204	OUTPUT:
3083	RETVAL	3205	RETVAL
3084		3206
3085	char *	3207	const char *
3086	gl_version ()	3208	gl_version ()
3087	CODE:	3209	CODE:
3088	RETVAL = (char *)glGetString (GL_VERSION);	3210	RETVAL = (const char *)glGetString (GL_VERSION);
3089	OUTPUT:	3211	OUTPUT:
3090	RETVAL	3212	RETVAL
3091		3213
3092	char *	3214	const char *
3093	gl_extensions ()	3215	gl_extensions ()
3094	CODE:	3216	CODE:
3095	RETVAL = (char *)glGetString (GL_EXTENSIONS);	3217	RETVAL = (const char *)glGetString (GL_EXTENSIONS);
3096	OUTPUT:	3218	OUTPUT:
3097	RETVAL	3219	RETVAL
3098		3220
3099	const char *glGetString (GLenum pname)	3221	const char *glGetString (GLenum pname)
		3222	CODE:
		3223	RETVAL = (const char *)glGetString (pname);
		3224	OUTPUT:
		3225	RETVAL
3100		3226
3101	GLint glGetInteger (GLenum pname)	3227	GLint glGetInteger (GLenum pname)
3102	CODE:	3228	CODE:
3103	glGetIntegerv (pname, &RETVAL);	3229	glGetIntegerv (pname, &RETVAL);
3104	OUTPUT:	3230	OUTPUT:
…		…
3111	RETVAL	3237	RETVAL
3112		3238
3113	int glGetError ()	3239	int glGetError ()
3114		3240
3115	void glFinish ()	3241	void glFinish ()
		3242
		3243	void glFlush ()
3116		3244
3117	void glClear (int mask)	3245	void glClear (int mask)
3118		3246
3119	void glClearColor (float r, float g, float b, float a = 1.0)	3247	void glClearColor (float r, float g, float b, float a = 1.0)
3120	PROTOTYPE: @	3248	PROTOTYPE: @
…		…
3292		3420
3293	void glEndList ()	3421	void glEndList ()
3294		3422
3295	void glCallList (int list)	3423	void glCallList (int list)
3296		3424
		3425	void c_init ()
		3426	CODE:
		3427	glPixelStorei (GL_PACK_ALIGNMENT , 1);
		3428	glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
		3429
3297	MODULE = Deliantra::Client PACKAGE = DC::UI::Base	3430	MODULE = Deliantra::Client PACKAGE = DC::UI::Base
3298		3431
3299	PROTOTYPES: DISABLE	3432	PROTOTYPES: DISABLE
3300		3433
3301	void	3434	void
3302	find_widget (SV *self, NV x, NV y)	3435	find_widget (SV *self, NV x, NV y)
3303	PPCODE:	3436	PPCODE:
3304	{	3437	{
3305	if (within_widget (self, x, y))	3438	if (within_widget (self, x, y))
3306	XPUSHs (self);	3439	XPUSHs (self);
3307	}	3440	}
3308		3441
3309	BOOT:	3442	BOOT:
3310	{	3443	{
…		…
3318		3451
3319	void	3452	void
3320	draw (SV *self)	3453	draw (SV *self)
3321	CODE:	3454	CODE:
3322	{	3455	{
3323	HV *hv;	3456	HV *hv;
3324	SV **svp;	3457	SV **svp;
3325	NV x, y, w, h;	3458	NV x, y, w, h;
3326	SV *draw_x_sv = GvSV (draw_x_gv);	3459	SV *draw_x_sv = GvSV (draw_x_gv);
3327	SV *draw_y_sv = GvSV (draw_y_gv);	3460	SV *draw_y_sv = GvSV (draw_y_gv);
3328	SV *draw_w_sv = GvSV (draw_w_gv);	3461	SV *draw_w_sv = GvSV (draw_w_gv);
3329	SV *draw_h_sv = GvSV (draw_h_gv);	3462	SV *draw_h_sv = GvSV (draw_h_gv);

Diff Legend

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